X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lib%2Fext2fs%2Funix_io.c;h=da3f8fdea8fa9d3a477804b1b0a1be2d658778c8;hb=800766ee4a2bcdc0a32442d093d20da6ea3815ab;hp=312313662bd161c384b3a3d3c1a01c61cc69865b;hpb=23b7c8b88673248b1f93abc717943867ad037bb4;p=tools%2Fe2fsprogs.git diff --git a/lib/ext2fs/unix_io.c b/lib/ext2fs/unix_io.c index 3123136..da3f8fd 100644 --- a/lib/ext2fs/unix_io.c +++ b/lib/ext2fs/unix_io.c @@ -1,20 +1,27 @@ /* - * unix_io.c --- This is the Unix I/O interface to the I/O manager. + * unix_io.c --- This is the Unix (well, really POSIX) implementation + * of the I/O manager. * * Implements a one-block write-through cache. * + * Includes support for Windows NT support under Cygwin. + * * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, * 2002 by Theodore Ts'o. * * %Begin-Header% - * This file may be redistributed under the terms of the GNU Public - * License. + * This file may be redistributed under the terms of the GNU Library + * General Public License, version 2. * %End-Header% */ #define _LARGEFILE_SOURCE #define _LARGEFILE64_SOURCE +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif +#include "config.h" #include #include #if HAVE_UNISTD_H @@ -28,13 +35,34 @@ #ifdef __linux__ #include #endif +#ifdef HAVE_SYS_IOCTL_H +#include +#endif +#ifdef HAVE_SYS_MOUNT_H +#include +#endif #if HAVE_SYS_STAT_H #include #endif #if HAVE_SYS_TYPES_H #include #endif +#if HAVE_SYS_RESOURCE_H #include +#endif +#if HAVE_LINUX_FALLOC_H +#include +#endif + +#if defined(__linux__) && defined(_IO) && !defined(BLKROGET) +#define BLKROGET _IO(0x12, 94) /* Get read-only status (0 = read_write). */ +#endif + +#if defined(__linux__) && defined(_IO) && !defined(BLKSSZGET) +#define BLKSSZGET _IO(0x12,104)/* get block device sector size */ +#endif + +#undef ALIGN_DEBUG #include "ext2_fs.h" #include "ext2fs.h" @@ -50,8 +78,8 @@ struct unix_cache { char *buf; unsigned long block; int access_time; - int dirty:1; - int in_use:1; + unsigned dirty:1; + unsigned in_use:1; }; #define CACHE_SIZE 8 @@ -62,10 +90,17 @@ struct unix_private_data { int magic; int dev; int flags; + int align; int access_time; + ext2_loff_t offset; struct unix_cache cache[CACHE_SIZE]; + void *bounce; + struct struct_io_stats io_stats; }; +#define IS_ALIGNED(n, align) ((((unsigned long) n) & \ + ((unsigned long) ((align)-1))) == 0) + static errcode_t unix_open(const char *name, int flags, io_channel *channel); static errcode_t unix_close(io_channel channel); static errcode_t unix_set_blksize(io_channel channel, int blksize); @@ -76,9 +111,18 @@ static errcode_t unix_write_blk(io_channel channel, unsigned long block, static errcode_t unix_flush(io_channel channel); static errcode_t unix_write_byte(io_channel channel, unsigned long offset, int size, const void *data); - +static errcode_t unix_set_option(io_channel channel, const char *option, + const char *arg); +static errcode_t unix_get_stats(io_channel channel, io_stats *stats) +; static void reuse_cache(io_channel channel, struct unix_private_data *data, - struct unix_cache *cache, unsigned long block); + struct unix_cache *cache, unsigned long long block); +static errcode_t unix_read_blk64(io_channel channel, unsigned long long block, + int count, void *data); +static errcode_t unix_write_blk64(io_channel channel, unsigned long long block, + int count, const void *data); +static errcode_t unix_discard(io_channel channel, unsigned long long block, + unsigned long long count); static struct struct_io_manager struct_unix_manager = { EXT2_ET_MAGIC_IO_MANAGER, @@ -89,39 +133,88 @@ static struct struct_io_manager struct_unix_manager = { unix_read_blk, unix_write_blk, unix_flush, - unix_write_byte + unix_write_byte, + unix_set_option, + unix_get_stats, + unix_read_blk64, + unix_write_blk64, + unix_discard, }; io_manager unix_io_manager = &struct_unix_manager; +static errcode_t unix_get_stats(io_channel channel, io_stats *stats) +{ + errcode_t retval = 0; + + struct unix_private_data *data; + + EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); + data = (struct unix_private_data *) channel->private_data; + EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); + + if (stats) + *stats = &data->io_stats; + + return retval; +} + /* * Here are the raw I/O functions */ static errcode_t raw_read_blk(io_channel channel, struct unix_private_data *data, - unsigned long block, - int count, void *buf) + unsigned long long block, + int count, void *bufv) { errcode_t retval; - size_t size; + ssize_t size; ext2_loff_t location; int actual = 0; + unsigned char *buf = bufv; size = (count < 0) ? -count : count * channel->block_size; - location = (ext2_loff_t) block * channel->block_size; + data->io_stats.bytes_read += size; + location = ((ext2_loff_t) block * channel->block_size) + data->offset; if (ext2fs_llseek(data->dev, location, SEEK_SET) != location) { retval = errno ? errno : EXT2_ET_LLSEEK_FAILED; goto error_out; } - actual = read(data->dev, buf, size); - if (actual != size) { - if (actual < 0) - actual = 0; - retval = EXT2_ET_SHORT_READ; - goto error_out; + if ((data->align == 0) || + ((IS_ALIGNED(buf, data->align)) && IS_ALIGNED(size, data->align))) { + actual = read(data->dev, buf, size); + if (actual != size) { + short_read: + if (actual < 0) + actual = 0; + retval = EXT2_ET_SHORT_READ; + goto error_out; + } + return 0; + } + +#ifdef ALIGN_DEBUG + printf("raw_read_blk: O_DIRECT fallback: %p %lu\n", buf, + (unsigned long) size); +#endif + + /* + * The buffer or size which we're trying to read isn't aligned + * to the O_DIRECT rules, so we need to do this the hard way... + */ + while (size > 0) { + actual = read(data->dev, data->bounce, channel->block_size); + if (actual != channel->block_size) + goto short_read; + actual = size; + if (size > channel->block_size) + actual = channel->block_size; + memcpy(buf, data->bounce, actual); + size -= actual; + buf += actual; } return 0; - + error_out: memset((char *) buf+actual, 0, size-actual); if (channel->read_error) @@ -132,13 +225,14 @@ error_out: static errcode_t raw_write_blk(io_channel channel, struct unix_private_data *data, - unsigned long block, - int count, const void *buf) + unsigned long long block, + int count, const void *bufv) { - size_t size; + ssize_t size; ext2_loff_t location; int actual = 0; errcode_t retval; + const unsigned char *buf = bufv; if (count == 1) size = channel->block_size; @@ -148,20 +242,54 @@ static errcode_t raw_write_blk(io_channel channel, else size = count * channel->block_size; } + data->io_stats.bytes_written += size; - location = (ext2_loff_t) block * channel->block_size; + location = ((ext2_loff_t) block * channel->block_size) + data->offset; if (ext2fs_llseek(data->dev, location, SEEK_SET) != location) { retval = errno ? errno : EXT2_ET_LLSEEK_FAILED; goto error_out; } - - actual = write(data->dev, buf, size); - if (actual != size) { - retval = EXT2_ET_SHORT_WRITE; - goto error_out; + + if ((data->align == 0) || + ((IS_ALIGNED(buf, data->align)) && IS_ALIGNED(size, data->align))) { + actual = write(data->dev, buf, size); + if (actual != size) { + short_write: + retval = EXT2_ET_SHORT_WRITE; + goto error_out; + } + return 0; + } + +#ifdef ALIGN_DEBUG + printf("raw_write_blk: O_DIRECT fallback: %p %lu\n", buf, + (unsigned long) size); +#endif + /* + * The buffer or size which we're trying to write isn't aligned + * to the O_DIRECT rules, so we need to do this the hard way... + */ + while (size > 0) { + if (size < channel->block_size) { + actual = read(data->dev, data->bounce, + channel->block_size); + if (actual != channel->block_size) { + retval = EXT2_ET_SHORT_READ; + goto error_out; + } + } + actual = size; + if (size > channel->block_size) + actual = channel->block_size; + memcpy(data->bounce, buf, actual); + actual = write(data->dev, data->bounce, channel->block_size); + if (actual != channel->block_size) + goto short_write; + size -= actual; + buf += actual; } return 0; - + error_out: if (channel->write_error) retval = (channel->write_error)(channel, block, count, buf, @@ -181,27 +309,35 @@ static errcode_t alloc_cache(io_channel channel, errcode_t retval; struct unix_cache *cache; int i; - + data->access_time = 0; for (i=0, cache = data->cache; i < CACHE_SIZE; i++, cache++) { cache->block = 0; cache->access_time = 0; cache->dirty = 0; cache->in_use = 0; - if ((retval = ext2fs_get_mem(channel->block_size, - (void **) &cache->buf))) + if (cache->buf) + ext2fs_free_mem(&cache->buf); + retval = ext2fs_get_memalign(channel->block_size, + data->align, &cache->buf); + if (retval) return retval; } - return 0; + if (data->align) { + if (data->bounce) + ext2fs_free_mem(&data->bounce); + retval = ext2fs_get_memalign(channel->block_size, data->align, + &data->bounce); + } + return retval; } /* Free the cache buffers */ -static void free_cache(io_channel channel, - struct unix_private_data *data) +static void free_cache(struct unix_private_data *data) { struct unix_cache *cache; int i; - + data->access_time = 0; for (i=0, cache = data->cache; i < CACHE_SIZE; i++, cache++) { cache->block = 0; @@ -209,24 +345,25 @@ static void free_cache(io_channel channel, cache->dirty = 0; cache->in_use = 0; if (cache->buf) - ext2fs_free_mem((void **) &cache->buf); - cache->buf = 0; + ext2fs_free_mem(&cache->buf); } + if (data->bounce) + ext2fs_free_mem(&data->bounce); } +#ifndef NO_IO_CACHE /* * Try to find a block in the cache. If the block is not found, and * eldest is a non-zero pointer, then fill in eldest with the cache * entry to that should be reused. */ -static struct unix_cache *find_cached_block(io_channel channel, - struct unix_private_data *data, - unsigned long block, +static struct unix_cache *find_cached_block(struct unix_private_data *data, + unsigned long long block, struct unix_cache **eldest) { struct unix_cache *cache, *unused_cache, *oldest_cache; int i; - + unused_cache = oldest_cache = 0; for (i=0, cache = data->cache; i < CACHE_SIZE; i++, cache++) { if (!cache->in_use) { @@ -251,7 +388,7 @@ static struct unix_cache *find_cached_block(io_channel channel, * Reuse a particular cache entry for another block. */ static void reuse_cache(io_channel channel, struct unix_private_data *data, - struct unix_cache *cache, unsigned long block) + struct unix_cache *cache, unsigned long long block) { if (cache->dirty && cache->in_use) raw_write_blk(channel, data, cache->block, 1, cache->buf); @@ -273,18 +410,18 @@ static errcode_t flush_cached_blocks(io_channel channel, struct unix_cache *cache; errcode_t retval, retval2; int i; - + retval2 = 0; for (i=0, cache = data->cache; i < CACHE_SIZE; i++, cache++) { if (!cache->in_use) continue; - + if (invalidate) cache->in_use = 0; - + if (!cache->dirty) continue; - + retval = raw_write_blk(channel, data, cache->block, 1, cache->buf); if (retval) @@ -294,35 +431,39 @@ static errcode_t flush_cached_blocks(io_channel channel, } return retval2; } +#endif /* NO_IO_CACHE */ - +#ifdef __linux__ +#ifndef BLKDISCARDZEROES +#define BLKDISCARDZEROES _IO(0x12,124) +#endif +#endif static errcode_t unix_open(const char *name, int flags, io_channel *channel) { io_channel io = NULL; struct unix_private_data *data = NULL; errcode_t retval; - int open_flags; - struct stat st; + int open_flags, zeroes = 0; + int f_nocache = 0; + ext2fs_struct_stat st; #ifdef __linux__ struct utsname ut; #endif if (name == 0) return EXT2_ET_BAD_DEVICE_NAME; - retval = ext2fs_get_mem(sizeof(struct struct_io_channel), - (void **) &io); + retval = ext2fs_get_mem(sizeof(struct struct_io_channel), &io); if (retval) - return retval; + goto cleanup; memset(io, 0, sizeof(struct struct_io_channel)); io->magic = EXT2_ET_MAGIC_IO_CHANNEL; - retval = ext2fs_get_mem(sizeof(struct unix_private_data), - (void **) &data); + retval = ext2fs_get_mem(sizeof(struct unix_private_data), &data); if (retval) goto cleanup; io->manager = unix_io_manager; - retval = ext2fs_get_mem(strlen(name)+1, (void **) &io->name); + retval = ext2fs_get_mem(strlen(name)+1, &io->name); if (retval) goto cleanup; @@ -335,20 +476,85 @@ static errcode_t unix_open(const char *name, int flags, io_channel *channel) memset(data, 0, sizeof(struct unix_private_data)); data->magic = EXT2_ET_MAGIC_UNIX_IO_CHANNEL; + data->io_stats.num_fields = 2; - if ((retval = alloc_cache(io, data))) - goto cleanup; - open_flags = (flags & IO_FLAG_RW) ? O_RDWR : O_RDONLY; -#ifdef HAVE_OPEN64 - data->dev = open64(name, open_flags); -#else - data->dev = open(name, open_flags); + if (flags & IO_FLAG_EXCLUSIVE) + open_flags |= O_EXCL; +#if defined(O_DIRECT) + if (flags & IO_FLAG_DIRECT_IO) + open_flags |= O_DIRECT; +#elif defined(F_NOCACHE) + if (flags & IO_FLAG_DIRECT_IO) + f_nocache = F_NOCACHE; #endif + data->flags = flags; + + data->dev = ext2fs_open_file(io->name, open_flags, 0); if (data->dev < 0) { retval = errno; goto cleanup; } + if (f_nocache) { + if (fcntl(data->dev, f_nocache, 1) < 0) { + retval = errno; + goto cleanup; + } + } + + /* + * If the device is really a block device, then set the + * appropriate flag, otherwise we can set DISCARD_ZEROES flag + * because we are going to use punch hole instead of discard + * and if it succeed, subsequent read from sparse area returns + * zero. + */ + if (ext2fs_stat(io->name, &st) == 0) { + if (S_ISBLK(st.st_mode)) + io->flags |= CHANNEL_FLAGS_BLOCK_DEVICE; + else + io->flags |= CHANNEL_FLAGS_DISCARD_ZEROES; + } + +#ifdef BLKSSZGET + if (flags & IO_FLAG_DIRECT_IO) { + if (ioctl(data->dev, BLKSSZGET, &data->align) != 0) + data->align = io->block_size; + } +#endif + +#ifdef BLKDISCARDZEROES + ioctl(data->dev, BLKDISCARDZEROES, &zeroes); + if (zeroes) + io->flags |= CHANNEL_FLAGS_DISCARD_ZEROES; +#endif + +#if defined(__CYGWIN__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) + /* + * Some operating systems require that the buffers be aligned, + * regardless of O_DIRECT + */ + data->align = 512; +#endif + + + if ((retval = alloc_cache(io, data))) + goto cleanup; + +#ifdef BLKROGET + if (flags & IO_FLAG_RW) { + int error; + int readonly = 0; + + /* Is the block device actually writable? */ + error = ioctl(data->dev, BLKROGET, &readonly); + if (!error && readonly) { + close(data->dev); + retval = EPERM; + goto cleanup; + } + } +#endif #ifdef __linux__ #undef RLIM_INFINITY @@ -362,7 +568,7 @@ static errcode_t unix_open(const char *name, int flags, io_channel *channel) * block devices are wrongly getting hit by the filesize * limit. This workaround isn't perfect, since it won't work * if glibc wasn't built against 2.2 header files. (Sigh.) - * + * */ if ((flags & IO_FLAG_RW) && (uname(&ut) == 0) && @@ -370,10 +576,10 @@ static errcode_t unix_open(const char *name, int flags, io_channel *channel) (ut.release[2] == '4') && (ut.release[3] == '.') && (ut.release[4] == '1') && (ut.release[5] >= '0') && (ut.release[5] < '8')) && - (fstat(data->dev, &st) == 0) && + (ext2fs_stat(io->name, &st) == 0) && (S_ISBLK(st.st_mode))) { struct rlimit rlim; - + rlim.rlim_cur = rlim.rlim_max = (unsigned long) RLIM_INFINITY; setrlimit(RLIMIT_FSIZE, &rlim); getrlimit(RLIMIT_FSIZE, &rlim); @@ -389,11 +595,11 @@ static errcode_t unix_open(const char *name, int flags, io_channel *channel) cleanup: if (data) { - free_cache(io, data); - ext2fs_free_mem((void **) &data); + free_cache(data); + ext2fs_free_mem(&data); } if (io) - ext2fs_free_mem((void **) &io); + ext2fs_free_mem(&io); return retval; } @@ -409,16 +615,18 @@ static errcode_t unix_close(io_channel channel) if (--channel->refcount > 0) return 0; +#ifndef NO_IO_CACHE retval = flush_cached_blocks(channel, data, 0); +#endif if (close(data->dev) < 0) retval = errno; - free_cache(channel, data); + free_cache(data); - ext2fs_free_mem((void **) &channel->private_data); + ext2fs_free_mem(&channel->private_data); if (channel->name) - ext2fs_free_mem((void **) &channel->name); - ext2fs_free_mem((void **) &channel); + ext2fs_free_mem(&channel->name); + ext2fs_free_mem(&channel); return retval; } @@ -432,11 +640,13 @@ static errcode_t unix_set_blksize(io_channel channel, int blksize) EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); if (channel->block_size != blksize) { +#ifndef NO_IO_CACHE if ((retval = flush_cached_blocks(channel, data, 0))) return retval; - +#endif + channel->block_size = blksize; - free_cache(channel, data); + free_cache(data); if ((retval = alloc_cache(channel, data))) return retval; } @@ -444,7 +654,7 @@ static errcode_t unix_set_blksize(io_channel channel, int blksize) } -static errcode_t unix_read_blk(io_channel channel, unsigned long block, +static errcode_t unix_read_blk64(io_channel channel, unsigned long long block, int count, void *buf) { struct unix_private_data *data; @@ -457,6 +667,9 @@ static errcode_t unix_read_blk(io_channel channel, unsigned long block, data = (struct unix_private_data *) channel->private_data; EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); +#ifdef NO_IO_CACHE + return raw_read_blk(channel, data, block, count, buf); +#else /* * If we're doing an odd-sized read or a very large read, * flush out the cache and then do a direct read. @@ -470,10 +683,9 @@ static errcode_t unix_read_blk(io_channel channel, unsigned long block, cp = buf; while (count > 0) { /* If it's in the cache, use it! */ - if ((cache = find_cached_block(channel, data, block, - &reuse[0]))) { + if ((cache = find_cached_block(data, block, &reuse[0]))) { #ifdef DEBUG - printf("Using cached block %d\n", block); + printf("Using cached block %lu\n", block); #endif memcpy(cp, cache->buf, channel->block_size); count--; @@ -481,20 +693,35 @@ static errcode_t unix_read_blk(io_channel channel, unsigned long block, cp += channel->block_size; continue; } + if (count == 1) { + /* + * Special case where we read directly into the + * cache buffer; important in the O_DIRECT case + */ + cache = reuse[0]; + reuse_cache(channel, data, cache, block); + if ((retval = raw_read_blk(channel, data, block, 1, + cache->buf))) { + cache->in_use = 0; + return retval; + } + memcpy(cp, cache->buf, channel->block_size); + return 0; + } + /* * Find the number of uncached blocks so we can do a * single read request */ for (i=1; i < count; i++) - if (find_cached_block(channel, data, block+i, - &reuse[i])) + if (find_cached_block(data, block+i, &reuse[i])) break; #ifdef DEBUG - printf("Reading %d blocks starting at %d\n", i, block); + printf("Reading %d blocks starting at %lu\n", i, block); #endif if ((retval = raw_read_blk(channel, data, block, i, cp))) return retval; - + /* Save the results in the cache */ for (j=0; j < i; j++) { count--; @@ -505,9 +732,16 @@ static errcode_t unix_read_blk(io_channel channel, unsigned long block, } } return 0; +#endif /* NO_IO_CACHE */ } -static errcode_t unix_write_blk(io_channel channel, unsigned long block, +static errcode_t unix_read_blk(io_channel channel, unsigned long block, + int count, void *buf) +{ + return unix_read_blk64(channel, block, count, buf); +} + +static errcode_t unix_write_blk64(io_channel channel, unsigned long long block, int count, const void *buf) { struct unix_private_data *data; @@ -520,6 +754,9 @@ static errcode_t unix_write_blk(io_channel channel, unsigned long block, data = (struct unix_private_data *) channel->private_data; EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); +#ifdef NO_IO_CACHE + return raw_write_blk(channel, data, block, count, buf); +#else /* * If we're doing an odd-sized write or a very large write, * flush out the cache completely and then do a direct write. @@ -538,10 +775,10 @@ static errcode_t unix_write_blk(io_channel channel, unsigned long block, writethrough = channel->flags & CHANNEL_FLAGS_WRITETHROUGH; if (writethrough) retval = raw_write_blk(channel, data, block, count, buf); - + cp = buf; while (count > 0) { - cache = find_cached_block(channel, data, block, &reuse); + cache = find_cached_block(data, block, &reuse); if (!cache) { cache = reuse; reuse_cache(channel, data, cache, block); @@ -553,6 +790,13 @@ static errcode_t unix_write_blk(io_channel channel, unsigned long block, cp += channel->block_size; } return retval; +#endif /* NO_IO_CACHE */ +} + +static errcode_t unix_write_blk(io_channel channel, unsigned long block, + int count, const void *buf) +{ + return unix_write_blk64(channel, block, count, buf); } static errcode_t unix_write_byte(io_channel channel, unsigned long offset, @@ -560,21 +804,30 @@ static errcode_t unix_write_byte(io_channel channel, unsigned long offset, { struct unix_private_data *data; errcode_t retval = 0; - size_t actual; + ssize_t actual; EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); data = (struct unix_private_data *) channel->private_data; EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); + if (data->align != 0) { +#ifdef ALIGN_DEBUG + printf("unix_write_byte: O_DIRECT fallback\n"); +#endif + return EXT2_ET_UNIMPLEMENTED; + } + +#ifndef NO_IO_CACHE /* * Flush out the cache completely */ if ((retval = flush_cached_blocks(channel, data, 1))) return retval; +#endif - if (lseek(data->dev, offset, SEEK_SET) < 0) + if (lseek(data->dev, offset + data->offset, SEEK_SET) < 0) return errno; - + actual = write(data->dev, buf, size); if (actual != size) return EXT2_ET_SHORT_WRITE; @@ -583,19 +836,94 @@ static errcode_t unix_write_byte(io_channel channel, unsigned long offset, } /* - * Flush data buffers to disk. + * Flush data buffers to disk. */ static errcode_t unix_flush(io_channel channel) { struct unix_private_data *data; errcode_t retval = 0; - + EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); data = (struct unix_private_data *) channel->private_data; EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); +#ifndef NO_IO_CACHE retval = flush_cached_blocks(channel, data, 0); +#endif fsync(data->dev); return retval; } +static errcode_t unix_set_option(io_channel channel, const char *option, + const char *arg) +{ + struct unix_private_data *data; + unsigned long long tmp; + char *end; + + EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); + data = (struct unix_private_data *) channel->private_data; + EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); + + if (!strcmp(option, "offset")) { + if (!arg) + return EXT2_ET_INVALID_ARGUMENT; + + tmp = strtoull(arg, &end, 0); + if (*end) + return EXT2_ET_INVALID_ARGUMENT; + data->offset = tmp; + if (data->offset < 0) + return EXT2_ET_INVALID_ARGUMENT; + return 0; + } + return EXT2_ET_INVALID_ARGUMENT; +} + +#if defined(__linux__) && !defined(BLKDISCARD) +#define BLKDISCARD _IO(0x12,119) +#endif + +static errcode_t unix_discard(io_channel channel, unsigned long long block, + unsigned long long count) +{ + struct unix_private_data *data; + __uint64_t range[2]; + int ret; + + EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); + data = (struct unix_private_data *) channel->private_data; + EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); + + if (channel->flags & CHANNEL_FLAGS_BLOCK_DEVICE) { +#ifdef BLKDISCARD + range[0] = (__uint64_t)(block) * channel->block_size; + range[1] = (__uint64_t)(count) * channel->block_size; + + ret = ioctl(data->dev, BLKDISCARD, &range); +#else + goto unimplemented; +#endif + } else { +#if defined(HAVE_FALLOCATE) && defined(FALLOC_FL_PUNCH_HOLE) + /* + * If we are not on block device, try to use punch hole + * to reclaim free space. + */ + ret = fallocate(data->dev, + FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, + (off_t)(block) * channel->block_size, + (off_t)(count) * channel->block_size); +#else + goto unimplemented; +#endif + } + if (ret < 0) { + if (errno == EOPNOTSUPP) + goto unimplemented; + return errno; + } + return 0; +unimplemented: + return EXT2_ET_UNIMPLEMENTED; +}