unix_io.c revision fd1c5a0622a9578b86f695d2f60df7d4f8b21875
1/*
2 * unix_io.c --- This is the Unix (well, really POSIX) implementation
3 * 	of the I/O manager.
4 *
5 * Implements a one-block write-through cache.
6 *
7 * Includes support for Windows NT support under Cygwin.
8 *
9 * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
10 * 	2002 by Theodore Ts'o.
11 *
12 * %Begin-Header%
13 * This file may be redistributed under the terms of the GNU Library
14 * General Public License, version 2.
15 * %End-Header%
16 */
17
18#define _LARGEFILE_SOURCE
19#define _LARGEFILE64_SOURCE
20#ifndef _GNU_SOURCE
21#define _GNU_SOURCE
22#endif
23
24#include "config.h"
25#include <stdio.h>
26#include <string.h>
27#if HAVE_UNISTD_H
28#include <unistd.h>
29#endif
30#if HAVE_ERRNO_H
31#include <errno.h>
32#endif
33#include <fcntl.h>
34#include <time.h>
35#ifdef __linux__
36#include <sys/utsname.h>
37#endif
38#ifdef HAVE_SYS_IOCTL_H
39#include <sys/ioctl.h>
40#endif
41#ifdef HAVE_SYS_MOUNT_H
42#include <sys/mount.h>
43#endif
44#if HAVE_SYS_STAT_H
45#include <sys/stat.h>
46#endif
47#if HAVE_SYS_TYPES_H
48#include <sys/types.h>
49#endif
50#if HAVE_SYS_RESOURCE_H
51#include <sys/resource.h>
52#endif
53#if HAVE_LINUX_FALLOC_H
54#include <linux/falloc.h>
55#endif
56
57#if defined(__linux__) && defined(_IO) && !defined(BLKROGET)
58#define BLKROGET   _IO(0x12, 94) /* Get read-only status (0 = read_write).  */
59#endif
60
61#undef ALIGN_DEBUG
62
63#include "ext2_fs.h"
64#include "ext2fs.h"
65
66/*
67 * For checking structure magic numbers...
68 */
69
70#define EXT2_CHECK_MAGIC(struct, code) \
71	  if ((struct)->magic != (code)) return (code)
72
73struct unix_cache {
74	char		*buf;
75	unsigned long	block;
76	int		access_time;
77	unsigned	dirty:1;
78	unsigned	in_use:1;
79};
80
81#define CACHE_SIZE 8
82#define WRITE_DIRECT_SIZE 4	/* Must be smaller than CACHE_SIZE */
83#define READ_DIRECT_SIZE 4	/* Should be smaller than CACHE_SIZE */
84
85struct unix_private_data {
86	int	magic;
87	int	dev;
88	int	flags;
89	int	align;
90	int	access_time;
91	ext2_loff_t offset;
92	struct unix_cache cache[CACHE_SIZE];
93	void	*bounce;
94	struct struct_io_stats io_stats;
95};
96
97#define IS_ALIGNED(n, align) ((((unsigned long) n) & \
98			       ((unsigned long) ((align)-1))) == 0)
99
100static errcode_t unix_open(const char *name, int flags, io_channel *channel);
101static errcode_t unix_close(io_channel channel);
102static errcode_t unix_set_blksize(io_channel channel, int blksize);
103static errcode_t unix_read_blk(io_channel channel, unsigned long block,
104			       int count, void *data);
105static errcode_t unix_write_blk(io_channel channel, unsigned long block,
106				int count, const void *data);
107static errcode_t unix_flush(io_channel channel);
108static errcode_t unix_write_byte(io_channel channel, unsigned long offset,
109				int size, const void *data);
110static errcode_t unix_set_option(io_channel channel, const char *option,
111				 const char *arg);
112static errcode_t unix_get_stats(io_channel channel, io_stats *stats)
113;
114static void reuse_cache(io_channel channel, struct unix_private_data *data,
115		 struct unix_cache *cache, unsigned long long block);
116static errcode_t unix_read_blk64(io_channel channel, unsigned long long block,
117			       int count, void *data);
118static errcode_t unix_write_blk64(io_channel channel, unsigned long long block,
119				int count, const void *data);
120static errcode_t unix_discard(io_channel channel, unsigned long long block,
121			      unsigned long long count);
122
123static struct struct_io_manager struct_unix_manager = {
124	EXT2_ET_MAGIC_IO_MANAGER,
125	"Unix I/O Manager",
126	unix_open,
127	unix_close,
128	unix_set_blksize,
129	unix_read_blk,
130	unix_write_blk,
131	unix_flush,
132	unix_write_byte,
133	unix_set_option,
134	unix_get_stats,
135	unix_read_blk64,
136	unix_write_blk64,
137	unix_discard,
138};
139
140io_manager unix_io_manager = &struct_unix_manager;
141
142static errcode_t unix_get_stats(io_channel channel, io_stats *stats)
143{
144	errcode_t 	retval = 0;
145
146	struct unix_private_data *data;
147
148	EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
149	data = (struct unix_private_data *) channel->private_data;
150	EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL);
151
152	if (stats)
153		*stats = &data->io_stats;
154
155	return retval;
156}
157
158/*
159 * Here are the raw I/O functions
160 */
161static errcode_t raw_read_blk(io_channel channel,
162			      struct unix_private_data *data,
163			      unsigned long long block,
164			      int count, void *bufv)
165{
166	errcode_t	retval;
167	ssize_t		size;
168	ext2_loff_t	location;
169	int		actual = 0;
170	unsigned char	*buf = bufv;
171
172	size = (count < 0) ? -count : count * channel->block_size;
173	data->io_stats.bytes_read += size;
174	location = ((ext2_loff_t) block * channel->block_size) + data->offset;
175	if (ext2fs_llseek(data->dev, location, SEEK_SET) != location) {
176		retval = errno ? errno : EXT2_ET_LLSEEK_FAILED;
177		goto error_out;
178	}
179	if ((channel->align == 0) ||
180	    (IS_ALIGNED(buf, channel->align) &&
181	     IS_ALIGNED(size, channel->align))) {
182		actual = read(data->dev, buf, size);
183		if (actual != size) {
184		short_read:
185			if (actual < 0)
186				actual = 0;
187			retval = EXT2_ET_SHORT_READ;
188			goto error_out;
189		}
190		return 0;
191	}
192
193#ifdef ALIGN_DEBUG
194	printf("raw_read_blk: O_DIRECT fallback: %p %lu\n", buf,
195	       (unsigned long) size);
196#endif
197
198	/*
199	 * The buffer or size which we're trying to read isn't aligned
200	 * to the O_DIRECT rules, so we need to do this the hard way...
201	 */
202	while (size > 0) {
203		actual = read(data->dev, data->bounce, channel->block_size);
204		if (actual != channel->block_size)
205			goto short_read;
206		actual = size;
207		if (size > channel->block_size)
208			actual = channel->block_size;
209		memcpy(buf, data->bounce, actual);
210		size -= actual;
211		buf += actual;
212	}
213	return 0;
214
215error_out:
216	memset((char *) buf+actual, 0, size-actual);
217	if (channel->read_error)
218		retval = (channel->read_error)(channel, block, count, buf,
219					       size, actual, retval);
220	return retval;
221}
222
223static errcode_t raw_write_blk(io_channel channel,
224			       struct unix_private_data *data,
225			       unsigned long long block,
226			       int count, const void *bufv)
227{
228	ssize_t		size;
229	ext2_loff_t	location;
230	int		actual = 0;
231	errcode_t	retval;
232	const unsigned char *buf = bufv;
233
234	if (count == 1)
235		size = channel->block_size;
236	else {
237		if (count < 0)
238			size = -count;
239		else
240			size = count * channel->block_size;
241	}
242	data->io_stats.bytes_written += size;
243
244	location = ((ext2_loff_t) block * channel->block_size) + data->offset;
245	if (ext2fs_llseek(data->dev, location, SEEK_SET) != location) {
246		retval = errno ? errno : EXT2_ET_LLSEEK_FAILED;
247		goto error_out;
248	}
249
250	if ((channel->align == 0) ||
251	    (IS_ALIGNED(buf, channel->align) &&
252	     IS_ALIGNED(size, channel->align))) {
253		actual = write(data->dev, buf, size);
254		if (actual != size) {
255		short_write:
256			retval = EXT2_ET_SHORT_WRITE;
257			goto error_out;
258		}
259		return 0;
260	}
261
262#ifdef ALIGN_DEBUG
263	printf("raw_write_blk: O_DIRECT fallback: %p %lu\n", buf,
264	       (unsigned long) size);
265#endif
266	/*
267	 * The buffer or size which we're trying to write isn't aligned
268	 * to the O_DIRECT rules, so we need to do this the hard way...
269	 */
270	while (size > 0) {
271		if (size < channel->block_size) {
272			actual = read(data->dev, data->bounce,
273				      channel->block_size);
274			if (actual != channel->block_size) {
275				retval = EXT2_ET_SHORT_READ;
276				goto error_out;
277			}
278		}
279		actual = size;
280		if (size > channel->block_size)
281			actual = channel->block_size;
282		memcpy(data->bounce, buf, actual);
283		actual = write(data->dev, data->bounce, channel->block_size);
284		if (actual != channel->block_size)
285			goto short_write;
286		size -= actual;
287		buf += actual;
288	}
289	return 0;
290
291error_out:
292	if (channel->write_error)
293		retval = (channel->write_error)(channel, block, count, buf,
294						size, actual, retval);
295	return retval;
296}
297
298
299/*
300 * Here we implement the cache functions
301 */
302
303/* Allocate the cache buffers */
304static errcode_t alloc_cache(io_channel channel,
305			     struct unix_private_data *data)
306{
307	errcode_t		retval;
308	struct unix_cache	*cache;
309	int			i;
310
311	data->access_time = 0;
312	for (i=0, cache = data->cache; i < CACHE_SIZE; i++, cache++) {
313		cache->block = 0;
314		cache->access_time = 0;
315		cache->dirty = 0;
316		cache->in_use = 0;
317		if (cache->buf)
318			ext2fs_free_mem(&cache->buf);
319		retval = io_channel_alloc_buf(channel, 0, &cache->buf);
320		if (retval)
321			return retval;
322	}
323	if (channel->align) {
324		if (data->bounce)
325			ext2fs_free_mem(&data->bounce);
326		retval = io_channel_alloc_buf(channel, 0, &data->bounce);
327	}
328	return retval;
329}
330
331/* Free the cache buffers */
332static void free_cache(struct unix_private_data *data)
333{
334	struct unix_cache	*cache;
335	int			i;
336
337	data->access_time = 0;
338	for (i=0, cache = data->cache; i < CACHE_SIZE; i++, cache++) {
339		cache->block = 0;
340		cache->access_time = 0;
341		cache->dirty = 0;
342		cache->in_use = 0;
343		if (cache->buf)
344			ext2fs_free_mem(&cache->buf);
345	}
346	if (data->bounce)
347		ext2fs_free_mem(&data->bounce);
348}
349
350#ifndef NO_IO_CACHE
351/*
352 * Try to find a block in the cache.  If the block is not found, and
353 * eldest is a non-zero pointer, then fill in eldest with the cache
354 * entry to that should be reused.
355 */
356static struct unix_cache *find_cached_block(struct unix_private_data *data,
357					    unsigned long long block,
358					    struct unix_cache **eldest)
359{
360	struct unix_cache	*cache, *unused_cache, *oldest_cache;
361	int			i;
362
363	unused_cache = oldest_cache = 0;
364	for (i=0, cache = data->cache; i < CACHE_SIZE; i++, cache++) {
365		if (!cache->in_use) {
366			if (!unused_cache)
367				unused_cache = cache;
368			continue;
369		}
370		if (cache->block == block) {
371			cache->access_time = ++data->access_time;
372			return cache;
373		}
374		if (!oldest_cache ||
375		    (cache->access_time < oldest_cache->access_time))
376			oldest_cache = cache;
377	}
378	if (eldest)
379		*eldest = (unused_cache) ? unused_cache : oldest_cache;
380	return 0;
381}
382
383/*
384 * Reuse a particular cache entry for another block.
385 */
386static void reuse_cache(io_channel channel, struct unix_private_data *data,
387		 struct unix_cache *cache, unsigned long long block)
388{
389	if (cache->dirty && cache->in_use)
390		raw_write_blk(channel, data, cache->block, 1, cache->buf);
391
392	cache->in_use = 1;
393	cache->dirty = 0;
394	cache->block = block;
395	cache->access_time = ++data->access_time;
396}
397
398/*
399 * Flush all of the blocks in the cache
400 */
401static errcode_t flush_cached_blocks(io_channel channel,
402				     struct unix_private_data *data,
403				     int invalidate)
404
405{
406	struct unix_cache	*cache;
407	errcode_t		retval, retval2;
408	int			i;
409
410	retval2 = 0;
411	for (i=0, cache = data->cache; i < CACHE_SIZE; i++, cache++) {
412		if (!cache->in_use)
413			continue;
414
415		if (invalidate)
416			cache->in_use = 0;
417
418		if (!cache->dirty)
419			continue;
420
421		retval = raw_write_blk(channel, data,
422				       cache->block, 1, cache->buf);
423		if (retval)
424			retval2 = retval;
425		else
426			cache->dirty = 0;
427	}
428	return retval2;
429}
430#endif /* NO_IO_CACHE */
431
432#ifdef __linux__
433#ifndef BLKDISCARDZEROES
434#define BLKDISCARDZEROES _IO(0x12,124)
435#endif
436#endif
437
438static errcode_t unix_open(const char *name, int flags, io_channel *channel)
439{
440	io_channel	io = NULL;
441	struct unix_private_data *data = NULL;
442	errcode_t	retval;
443	int		open_flags, zeroes = 0;
444	int		f_nocache = 0;
445	ext2fs_struct_stat st;
446#ifdef __linux__
447	struct 		utsname ut;
448#endif
449
450	if (name == 0)
451		return EXT2_ET_BAD_DEVICE_NAME;
452	retval = ext2fs_get_mem(sizeof(struct struct_io_channel), &io);
453	if (retval)
454		goto cleanup;
455	memset(io, 0, sizeof(struct struct_io_channel));
456	io->magic = EXT2_ET_MAGIC_IO_CHANNEL;
457	retval = ext2fs_get_mem(sizeof(struct unix_private_data), &data);
458	if (retval)
459		goto cleanup;
460
461	io->manager = unix_io_manager;
462	retval = ext2fs_get_mem(strlen(name)+1, &io->name);
463	if (retval)
464		goto cleanup;
465
466	strcpy(io->name, name);
467	io->private_data = data;
468	io->block_size = 1024;
469	io->read_error = 0;
470	io->write_error = 0;
471	io->refcount = 1;
472
473	memset(data, 0, sizeof(struct unix_private_data));
474	data->magic = EXT2_ET_MAGIC_UNIX_IO_CHANNEL;
475	data->io_stats.num_fields = 2;
476
477	open_flags = (flags & IO_FLAG_RW) ? O_RDWR : O_RDONLY;
478	if (flags & IO_FLAG_EXCLUSIVE)
479		open_flags |= O_EXCL;
480#if defined(O_DIRECT)
481	if (flags & IO_FLAG_DIRECT_IO) {
482		open_flags |= O_DIRECT;
483		io->align = ext2fs_get_dio_alignment(data->dev);
484	}
485#elif defined(F_NOCACHE)
486	if (flags & IO_FLAG_DIRECT_IO) {
487		f_nocache = F_NOCACHE;
488		io->align = 4096;
489	}
490#endif
491	data->flags = flags;
492
493	data->dev = ext2fs_open_file(io->name, open_flags, 0);
494	if (data->dev < 0) {
495		retval = errno;
496		goto cleanup;
497	}
498	if (f_nocache) {
499		if (fcntl(data->dev, f_nocache, 1) < 0) {
500			retval = errno;
501			goto cleanup;
502		}
503	}
504
505	/*
506	 * If the device is really a block device, then set the
507	 * appropriate flag, otherwise we can set DISCARD_ZEROES flag
508	 * because we are going to use punch hole instead of discard
509	 * and if it succeed, subsequent read from sparse area returns
510	 * zero.
511	 */
512	if (ext2fs_stat(io->name, &st) == 0) {
513		if (S_ISBLK(st.st_mode))
514			io->flags |= CHANNEL_FLAGS_BLOCK_DEVICE;
515		else
516			io->flags |= CHANNEL_FLAGS_DISCARD_ZEROES;
517	}
518
519#ifdef BLKDISCARDZEROES
520	ioctl(data->dev, BLKDISCARDZEROES, &zeroes);
521	if (zeroes)
522		io->flags |= CHANNEL_FLAGS_DISCARD_ZEROES;
523#endif
524
525#if defined(__CYGWIN__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
526	/*
527	 * Some operating systems require that the buffers be aligned,
528	 * regardless of O_DIRECT
529	 */
530	if (!io->align)
531		io->align = 512;
532#endif
533
534
535	if ((retval = alloc_cache(io, data)))
536		goto cleanup;
537
538#ifdef BLKROGET
539	if (flags & IO_FLAG_RW) {
540		int error;
541		int readonly = 0;
542
543		/* Is the block device actually writable? */
544		error = ioctl(data->dev, BLKROGET, &readonly);
545		if (!error && readonly) {
546			close(data->dev);
547			retval = EPERM;
548			goto cleanup;
549		}
550	}
551#endif
552
553#ifdef __linux__
554#undef RLIM_INFINITY
555#if (defined(__alpha__) || ((defined(__sparc__) || defined(__mips__)) && (SIZEOF_LONG == 4)))
556#define RLIM_INFINITY	((unsigned long)(~0UL>>1))
557#else
558#define RLIM_INFINITY  (~0UL)
559#endif
560	/*
561	 * Work around a bug in 2.4.10-2.4.18 kernels where writes to
562	 * block devices are wrongly getting hit by the filesize
563	 * limit.  This workaround isn't perfect, since it won't work
564	 * if glibc wasn't built against 2.2 header files.  (Sigh.)
565	 *
566	 */
567	if ((flags & IO_FLAG_RW) &&
568	    (uname(&ut) == 0) &&
569	    ((ut.release[0] == '2') && (ut.release[1] == '.') &&
570	     (ut.release[2] == '4') && (ut.release[3] == '.') &&
571	     (ut.release[4] == '1') && (ut.release[5] >= '0') &&
572	     (ut.release[5] < '8')) &&
573	    (ext2fs_stat(io->name, &st) == 0) &&
574	    (S_ISBLK(st.st_mode))) {
575		struct rlimit	rlim;
576
577		rlim.rlim_cur = rlim.rlim_max = (unsigned long) RLIM_INFINITY;
578		setrlimit(RLIMIT_FSIZE, &rlim);
579		getrlimit(RLIMIT_FSIZE, &rlim);
580		if (((unsigned long) rlim.rlim_cur) <
581		    ((unsigned long) rlim.rlim_max)) {
582			rlim.rlim_cur = rlim.rlim_max;
583			setrlimit(RLIMIT_FSIZE, &rlim);
584		}
585	}
586#endif
587	*channel = io;
588	return 0;
589
590cleanup:
591	if (data) {
592		free_cache(data);
593		ext2fs_free_mem(&data);
594	}
595	if (io)
596		ext2fs_free_mem(&io);
597	return retval;
598}
599
600static errcode_t unix_close(io_channel channel)
601{
602	struct unix_private_data *data;
603	errcode_t	retval = 0;
604
605	EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
606	data = (struct unix_private_data *) channel->private_data;
607	EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL);
608
609	if (--channel->refcount > 0)
610		return 0;
611
612#ifndef NO_IO_CACHE
613	retval = flush_cached_blocks(channel, data, 0);
614#endif
615
616	if (close(data->dev) < 0)
617		retval = errno;
618	free_cache(data);
619
620	ext2fs_free_mem(&channel->private_data);
621	if (channel->name)
622		ext2fs_free_mem(&channel->name);
623	ext2fs_free_mem(&channel);
624	return retval;
625}
626
627static errcode_t unix_set_blksize(io_channel channel, int blksize)
628{
629	struct unix_private_data *data;
630	errcode_t		retval;
631
632	EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
633	data = (struct unix_private_data *) channel->private_data;
634	EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL);
635
636	if (channel->block_size != blksize) {
637#ifndef NO_IO_CACHE
638		if ((retval = flush_cached_blocks(channel, data, 0)))
639			return retval;
640#endif
641
642		channel->block_size = blksize;
643		free_cache(data);
644		if ((retval = alloc_cache(channel, data)))
645			return retval;
646	}
647	return 0;
648}
649
650
651static errcode_t unix_read_blk64(io_channel channel, unsigned long long block,
652			       int count, void *buf)
653{
654	struct unix_private_data *data;
655	struct unix_cache *cache, *reuse[READ_DIRECT_SIZE];
656	errcode_t	retval;
657	char		*cp;
658	int		i, j;
659
660	EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
661	data = (struct unix_private_data *) channel->private_data;
662	EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL);
663
664#ifdef NO_IO_CACHE
665	return raw_read_blk(channel, data, block, count, buf);
666#else
667	/*
668	 * If we're doing an odd-sized read or a very large read,
669	 * flush out the cache and then do a direct read.
670	 */
671	if (count < 0 || count > WRITE_DIRECT_SIZE) {
672		if ((retval = flush_cached_blocks(channel, data, 0)))
673			return retval;
674		return raw_read_blk(channel, data, block, count, buf);
675	}
676
677	cp = buf;
678	while (count > 0) {
679		/* If it's in the cache, use it! */
680		if ((cache = find_cached_block(data, block, &reuse[0]))) {
681#ifdef DEBUG
682			printf("Using cached block %lu\n", block);
683#endif
684			memcpy(cp, cache->buf, channel->block_size);
685			count--;
686			block++;
687			cp += channel->block_size;
688			continue;
689		}
690		if (count == 1) {
691			/*
692			 * Special case where we read directly into the
693			 * cache buffer; important in the O_DIRECT case
694			 */
695			cache = reuse[0];
696			reuse_cache(channel, data, cache, block);
697			if ((retval = raw_read_blk(channel, data, block, 1,
698						   cache->buf))) {
699				cache->in_use = 0;
700				return retval;
701			}
702			memcpy(cp, cache->buf, channel->block_size);
703			return 0;
704		}
705
706		/*
707		 * Find the number of uncached blocks so we can do a
708		 * single read request
709		 */
710		for (i=1; i < count; i++)
711			if (find_cached_block(data, block+i, &reuse[i]))
712				break;
713#ifdef DEBUG
714		printf("Reading %d blocks starting at %lu\n", i, block);
715#endif
716		if ((retval = raw_read_blk(channel, data, block, i, cp)))
717			return retval;
718
719		/* Save the results in the cache */
720		for (j=0; j < i; j++) {
721			count--;
722			cache = reuse[j];
723			reuse_cache(channel, data, cache, block++);
724			memcpy(cache->buf, cp, channel->block_size);
725			cp += channel->block_size;
726		}
727	}
728	return 0;
729#endif /* NO_IO_CACHE */
730}
731
732static errcode_t unix_read_blk(io_channel channel, unsigned long block,
733			       int count, void *buf)
734{
735	return unix_read_blk64(channel, block, count, buf);
736}
737
738static errcode_t unix_write_blk64(io_channel channel, unsigned long long block,
739				int count, const void *buf)
740{
741	struct unix_private_data *data;
742	struct unix_cache *cache, *reuse;
743	errcode_t	retval = 0;
744	const char	*cp;
745	int		writethrough;
746
747	EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
748	data = (struct unix_private_data *) channel->private_data;
749	EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL);
750
751#ifdef NO_IO_CACHE
752	return raw_write_blk(channel, data, block, count, buf);
753#else
754	/*
755	 * If we're doing an odd-sized write or a very large write,
756	 * flush out the cache completely and then do a direct write.
757	 */
758	if (count < 0 || count > WRITE_DIRECT_SIZE) {
759		if ((retval = flush_cached_blocks(channel, data, 1)))
760			return retval;
761		return raw_write_blk(channel, data, block, count, buf);
762	}
763
764	/*
765	 * For a moderate-sized multi-block write, first force a write
766	 * if we're in write-through cache mode, and then fill the
767	 * cache with the blocks.
768	 */
769	writethrough = channel->flags & CHANNEL_FLAGS_WRITETHROUGH;
770	if (writethrough)
771		retval = raw_write_blk(channel, data, block, count, buf);
772
773	cp = buf;
774	while (count > 0) {
775		cache = find_cached_block(data, block, &reuse);
776		if (!cache) {
777			cache = reuse;
778			reuse_cache(channel, data, cache, block);
779		}
780		memcpy(cache->buf, cp, channel->block_size);
781		cache->dirty = !writethrough;
782		count--;
783		block++;
784		cp += channel->block_size;
785	}
786	return retval;
787#endif /* NO_IO_CACHE */
788}
789
790static errcode_t unix_write_blk(io_channel channel, unsigned long block,
791				int count, const void *buf)
792{
793	return unix_write_blk64(channel, block, count, buf);
794}
795
796static errcode_t unix_write_byte(io_channel channel, unsigned long offset,
797				 int size, const void *buf)
798{
799	struct unix_private_data *data;
800	errcode_t	retval = 0;
801	ssize_t		actual;
802
803	EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
804	data = (struct unix_private_data *) channel->private_data;
805	EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL);
806
807	if (channel->align != 0) {
808#ifdef ALIGN_DEBUG
809		printf("unix_write_byte: O_DIRECT fallback\n");
810#endif
811		return EXT2_ET_UNIMPLEMENTED;
812	}
813
814#ifndef NO_IO_CACHE
815	/*
816	 * Flush out the cache completely
817	 */
818	if ((retval = flush_cached_blocks(channel, data, 1)))
819		return retval;
820#endif
821
822	if (lseek(data->dev, offset + data->offset, SEEK_SET) < 0)
823		return errno;
824
825	actual = write(data->dev, buf, size);
826	if (actual != size)
827		return EXT2_ET_SHORT_WRITE;
828
829	return 0;
830}
831
832/*
833 * Flush data buffers to disk.
834 */
835static errcode_t unix_flush(io_channel channel)
836{
837	struct unix_private_data *data;
838	errcode_t retval = 0;
839
840	EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
841	data = (struct unix_private_data *) channel->private_data;
842	EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL);
843
844#ifndef NO_IO_CACHE
845	retval = flush_cached_blocks(channel, data, 0);
846#endif
847	fsync(data->dev);
848	return retval;
849}
850
851static errcode_t unix_set_option(io_channel channel, const char *option,
852				 const char *arg)
853{
854	struct unix_private_data *data;
855	unsigned long long tmp;
856	char *end;
857
858	EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
859	data = (struct unix_private_data *) channel->private_data;
860	EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL);
861
862	if (!strcmp(option, "offset")) {
863		if (!arg)
864			return EXT2_ET_INVALID_ARGUMENT;
865
866		tmp = strtoull(arg, &end, 0);
867		if (*end)
868			return EXT2_ET_INVALID_ARGUMENT;
869		data->offset = tmp;
870		if (data->offset < 0)
871			return EXT2_ET_INVALID_ARGUMENT;
872		return 0;
873	}
874	return EXT2_ET_INVALID_ARGUMENT;
875}
876
877#if defined(__linux__) && !defined(BLKDISCARD)
878#define BLKDISCARD		_IO(0x12,119)
879#endif
880
881static errcode_t unix_discard(io_channel channel, unsigned long long block,
882			      unsigned long long count)
883{
884	struct unix_private_data *data;
885	__uint64_t	range[2];
886	int		ret;
887
888	EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
889	data = (struct unix_private_data *) channel->private_data;
890	EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL);
891
892	if (channel->flags & CHANNEL_FLAGS_BLOCK_DEVICE) {
893#ifdef BLKDISCARD
894		range[0] = (__uint64_t)(block) * channel->block_size;
895		range[1] = (__uint64_t)(count) * channel->block_size;
896
897		ret = ioctl(data->dev, BLKDISCARD, &range);
898#else
899		goto unimplemented;
900#endif
901	} else {
902#if defined(HAVE_FALLOCATE) && defined(FALLOC_FL_PUNCH_HOLE)
903		/*
904		 * If we are not on block device, try to use punch hole
905		 * to reclaim free space.
906		 */
907		ret = fallocate(data->dev,
908				FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
909				(off_t)(block) * channel->block_size,
910				(off_t)(count) * channel->block_size);
911#else
912		goto unimplemented;
913#endif
914	}
915	if (ret < 0) {
916		if (errno == EOPNOTSUPP)
917			goto unimplemented;
918		return errno;
919	}
920	return 0;
921unimplemented:
922	return EXT2_ET_UNIMPLEMENTED;
923}
924