X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lib%2Fext2fs%2Funix_io.c;h=628e60c39eaf1400ea2dbbd5898262f077ba127d;hb=336c440ccea8f94b0728f881cddee84f730e7cc7;hp=8c599aa6515852d0d019b4820784caa586f2cc2d;hpb=543547a52a20cb7e69d74921b2f691078fd55d83;p=tools%2Fe2fsprogs.git diff --git a/lib/ext2fs/unix_io.c b/lib/ext2fs/unix_io.c index 8c599aa..628e60c 100644 --- a/lib/ext2fs/unix_io.c +++ b/lib/ext2fs/unix_io.c @@ -1,13 +1,13 @@ /* * unix_io.c --- This is the Unix (well, really POSIX) implementation - * of the I/O manager. + * 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. + * 2002 by Theodore Ts'o. * * %Begin-Header% * This file may be redistributed under the terms of the GNU Library @@ -15,9 +15,22 @@ * %End-Header% */ +#if !defined(__FreeBSD__) && !defined(__NetBSD__) && !defined(__OpenBSD__) +#define _XOPEN_SOURCE 600 +#define _DARWIN_C_SOURCE +#define _FILE_OFFSET_BITS 64 +#ifndef _LARGEFILE_SOURCE #define _LARGEFILE_SOURCE +#endif +#ifndef _LARGEFILE64_SOURCE #define _LARGEFILE64_SOURCE +#endif +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif +#endif +#include "config.h" #include #include #if HAVE_UNISTD_H @@ -31,28 +44,39 @@ #ifdef __linux__ #include #endif +#if HAVE_SYS_TYPES_H +#include +#endif #ifdef HAVE_SYS_IOCTL_H #include #endif #ifdef HAVE_SYS_MOUNT_H #include #endif +#ifdef HAVE_SYS_PRCTL_H +#include +#else +#define PR_GET_DUMPABLE 3 +#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(BLKGETSIZE) +#if defined(__linux__) && defined(_IO) && !defined(BLKROGET) #define BLKROGET _IO(0x12, 94) /* Get read-only status (0 = read_write). */ #endif +#undef ALIGN_DEBUG + #include "ext2_fs.h" #include "ext2fs.h" +#include "ext2fsP.h" /* * For checking structure magic numbers... @@ -62,11 +86,11 @@ if ((struct)->magic != (code)) return (code) struct unix_cache { - char *buf; - unsigned long block; - int access_time; - unsigned dirty:1; - unsigned in_use:1; + char *buf; + unsigned long long block; + int access_time; + unsigned dirty:1; + unsigned in_use:1; }; #define CACHE_SIZE 8 @@ -77,66 +101,20 @@ 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; }; -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); -static errcode_t unix_read_blk(io_channel channel, unsigned long block, - int count, void *data); -static errcode_t unix_write_blk(io_channel channel, unsigned long block, - int count, const void *data); -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 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); - -/* __FreeBSD_kernel__ is defined by GNU/kFreeBSD - the FreeBSD kernel - * does not know buffered block devices - everything is raw. */ -#if defined(__CYGWIN__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) -#define NEED_BOUNCE_BUFFER -#else -#undef NEED_BOUNCE_BUFFER -#endif - -static struct struct_io_manager struct_unix_manager = { - EXT2_ET_MAGIC_IO_MANAGER, - "Unix I/O Manager", - unix_open, - unix_close, - unix_set_blksize, - unix_read_blk, - unix_write_blk, - unix_flush, -#ifdef NEED_BOUNCE_BUFFER - 0, -#else - unix_write_byte, -#endif - unix_set_option, - unix_get_stats, - unix_read_blk64, - unix_write_blk64, -}; - -io_manager unix_io_manager = &struct_unix_manager; +#define IS_ALIGNED(n, align) ((((uintptr_t) n) & \ + ((uintptr_t) ((align)-1))) == 0) static errcode_t unix_get_stats(io_channel channel, io_stats *stats) { - errcode_t retval = 0; + errcode_t retval = 0; struct unix_private_data *data; @@ -150,108 +128,146 @@ static errcode_t unix_get_stats(io_channel channel, io_stats *stats) return retval; } +static char *safe_getenv(const char *arg) +{ + if ((getuid() != geteuid()) || (getgid() != getegid())) + return NULL; +#ifdef HAVE_PRCTL + if (prctl(PR_GET_DUMPABLE, 0, 0, 0, 0) == 0) + return NULL; +#else +#if (defined(linux) && defined(SYS_prctl)) + if (syscall(SYS_prctl, PR_GET_DUMPABLE, 0, 0, 0, 0) == 0) + return NULL; +#endif +#endif + +#if defined(HAVE_SECURE_GETENV) + return secure_getenv(arg); +#elif defined(HAVE___SECURE_GETENV) + return __secure_getenv(arg); +#else + return getenv(arg); +#endif +} + /* * Here are the raw I/O functions */ -#ifndef NEED_BOUNCE_BUFFER static errcode_t raw_read_blk(io_channel channel, struct unix_private_data *data, unsigned long long block, - int count, void *buf) + int count, void *bufv) { errcode_t retval; ssize_t size; ext2_loff_t location; int actual = 0; + unsigned char *buf = bufv; + ssize_t really_read = 0; - size = (count < 0) ? -count : count * channel->block_size; + size = (count < 0) ? -count : (ext2_loff_t) count * 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->flags & IO_FLAG_FORCE_BOUNCE) { + if (ext2fs_llseek(data->dev, location, SEEK_SET) != location) { + retval = errno ? errno : EXT2_ET_LLSEEK_FAILED; + goto error_out; + } + goto bounce_read; } - return 0; -error_out: - memset((char *) buf+actual, 0, size-actual); - if (channel->read_error) - retval = (channel->read_error)(channel, block, count, buf, - size, actual, retval); - return retval; -} -#else /* NEED_BOUNCE_BUFFER */ -/* - * Windows and FreeBSD block devices only allow sector alignment IO in offset and size - */ -static errcode_t raw_read_blk(io_channel channel, - struct unix_private_data *data, - unsigned long block, - int count, void *buf) -{ - errcode_t retval; - size_t size, alignsize, fragment; - ext2_loff_t location; - int total = 0, actual; -#define BLOCKALIGN 512 - char sector[BLOCKALIGN]; +#ifdef HAVE_PREAD64 + /* Try an aligned pread */ + if ((channel->align == 0) || + (IS_ALIGNED(buf, channel->align) && + IS_ALIGNED(size, channel->align))) { + actual = pread64(data->dev, buf, size, location); + if (actual == size) + return 0; + actual = 0; + } +#elif HAVE_PREAD + /* Try an aligned pread */ + if ((sizeof(off_t) >= sizeof(ext2_loff_t)) && + ((channel->align == 0) || + (IS_ALIGNED(buf, channel->align) && + IS_ALIGNED(size, channel->align)))) { + actual = pread(data->dev, buf, size, location); + if (actual == size) + return 0; + actual = 0; + } +#endif /* HAVE_PREAD */ - size = (count < 0) ? -count : count * channel->block_size; - data->io_stats.bytes_read += size; - location = ((ext2_loff_t) block * channel->block_size) + data->offset; -#ifdef DEBUG - printf("count=%d, size=%d, block=%lu, blk_size=%d, location=%llx\n", - count, size, block, channel->block_size, (long long)location); -#endif if (ext2fs_llseek(data->dev, location, SEEK_SET) != location) { retval = errno ? errno : EXT2_ET_LLSEEK_FAILED; goto error_out; } - fragment = size % BLOCKALIGN; - alignsize = size - fragment; - if (alignsize) { - actual = read(data->dev, buf, alignsize); - if (actual != alignsize) - goto short_read; + if ((channel->align == 0) || + (IS_ALIGNED(buf, channel->align) && + IS_ALIGNED(size, channel->align))) { + actual = read(data->dev, buf, size); + if (actual != size) { + short_read: + if (actual < 0) { + retval = errno; + actual = 0; + } else + retval = EXT2_ET_SHORT_READ; + goto error_out; + } + return 0; } - if (fragment) { - actual = read(data->dev, sector, BLOCKALIGN); - if (actual != BLOCKALIGN) + +#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... + */ +bounce_read: + while (size > 0) { + actual = read(data->dev, data->bounce, channel->block_size); + if (actual != channel->block_size) { + actual = really_read; + buf -= really_read; + size += really_read; goto short_read; - memcpy(buf+alignsize, sector, fragment); + } + actual = size; + if (size > channel->block_size) + actual = channel->block_size; + memcpy(buf, data->bounce, actual); + really_read += actual; + size -= actual; + buf += actual; } return 0; -short_read: - if (actual>0) - total += actual; - retval = EXT2_ET_SHORT_READ; - error_out: - memset((char *) buf+total, 0, size-actual); + if (actual >= 0 && actual < size) + memset((char *) buf+actual, 0, size-actual); if (channel->read_error) retval = (channel->read_error)(channel, block, count, buf, size, actual, retval); return retval; } -#endif static errcode_t raw_write_blk(io_channel channel, struct unix_private_data *data, unsigned long long block, - int count, const void *buf) + int count, const void *bufv) { 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; @@ -259,20 +275,102 @@ static errcode_t raw_write_blk(io_channel channel, if (count < 0) size = -count; else - size = count * channel->block_size; + size = (ext2_loff_t) count * channel->block_size; } data->io_stats.bytes_written += size; location = ((ext2_loff_t) block * channel->block_size) + data->offset; + + if (data->flags & IO_FLAG_FORCE_BOUNCE) { + if (ext2fs_llseek(data->dev, location, SEEK_SET) != location) { + retval = errno ? errno : EXT2_ET_LLSEEK_FAILED; + goto error_out; + } + goto bounce_write; + } + +#ifdef HAVE_PWRITE64 + /* Try an aligned pwrite */ + if ((channel->align == 0) || + (IS_ALIGNED(buf, channel->align) && + IS_ALIGNED(size, channel->align))) { + actual = pwrite64(data->dev, buf, size, location); + if (actual == size) + return 0; + } +#elif HAVE_PWRITE + /* Try an aligned pwrite */ + if ((sizeof(off_t) >= sizeof(ext2_loff_t)) && + ((channel->align == 0) || + (IS_ALIGNED(buf, channel->align) && + IS_ALIGNED(size, channel->align)))) { + actual = pwrite(data->dev, buf, size, location); + if (actual == size) + return 0; + } +#endif /* HAVE_PWRITE */ + 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 ((channel->align == 0) || + (IS_ALIGNED(buf, channel->align) && + IS_ALIGNED(size, channel->align))) { + actual = write(data->dev, buf, size); + if (actual < 0) { + retval = errno; + goto error_out; + } + 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... + */ +bounce_write: + while (size > 0) { + if (size < channel->block_size) { + actual = read(data->dev, data->bounce, + channel->block_size); + if (actual != channel->block_size) { + if (actual < 0) { + retval = errno; + goto error_out; + } + memset((char *) data->bounce + actual, 0, + channel->block_size - actual); + } + } + actual = size; + if (size > channel->block_size) + actual = channel->block_size; + memcpy(data->bounce, buf, actual); + if (ext2fs_llseek(data->dev, location, SEEK_SET) != location) { + retval = errno ? errno : EXT2_ET_LLSEEK_FAILED; + goto error_out; + } + actual = write(data->dev, data->bounce, channel->block_size); + if (actual < 0) { + retval = errno; + goto error_out; + } + if (actual != channel->block_size) + goto short_write; + size -= actual; + buf += actual; + location += actual; } return 0; @@ -302,11 +400,18 @@ static errcode_t alloc_cache(io_channel channel, cache->access_time = 0; cache->dirty = 0; cache->in_use = 0; - if ((retval = ext2fs_get_mem(channel->block_size, - &cache->buf))) + if (cache->buf) + ext2fs_free_mem(&cache->buf); + retval = io_channel_alloc_buf(channel, 0, &cache->buf); + if (retval) return retval; } - return 0; + if (channel->align || data->flags & IO_FLAG_FORCE_BOUNCE) { + if (data->bounce) + ext2fs_free_mem(&data->bounce); + retval = io_channel_alloc_buf(channel, 0, &data->bounce); + } + return retval; } /* Free the cache buffers */ @@ -323,8 +428,9 @@ static void free_cache(struct unix_private_data *data) cache->in_use = 0; if (cache->buf) ext2fs_free_mem(&cache->buf); - cache->buf = 0; } + if (data->bounce) + ext2fs_free_mem(&data->bounce); } #ifndef NO_IO_CACHE @@ -409,29 +515,78 @@ static errcode_t flush_cached_blocks(io_channel channel, } #endif /* NO_IO_CACHE */ -static errcode_t unix_open(const char *name, int flags, io_channel *channel) +#ifdef __linux__ +#ifndef BLKDISCARDZEROES +#define BLKDISCARDZEROES _IO(0x12,124) +#endif +#endif + +int ext2fs_open_file(const char *pathname, int flags, mode_t mode) +{ + if (mode) +#if defined(HAVE_OPEN64) && !defined(__OSX_AVAILABLE_BUT_DEPRECATED) + return open64(pathname, flags, mode); + else + return open64(pathname, flags); +#else + return open(pathname, flags, mode); + else + return open(pathname, flags); +#endif +} + +int ext2fs_stat(const char *path, ext2fs_struct_stat *buf) +{ +#if defined(HAVE_FSTAT64) && !defined(__OSX_AVAILABLE_BUT_DEPRECATED) + return stat64(path, buf); +#else + return stat(path, buf); +#endif +} + +int ext2fs_fstat(int fd, ext2fs_struct_stat *buf) +{ +#if defined(HAVE_FSTAT64) && !defined(__OSX_AVAILABLE_BUT_DEPRECATED) + return fstat64(fd, buf); +#else + return fstat(fd, buf); +#endif +} + + +static errcode_t unix_open_channel(const char *name, int fd, + int flags, io_channel *channel, + io_manager io_mgr) { io_channel io = NULL; struct unix_private_data *data = NULL; errcode_t retval; - int open_flags; - struct stat st; + ext2fs_struct_stat st; #ifdef __linux__ - struct utsname ut; + struct utsname ut; +#endif + + if (safe_getenv("UNIX_IO_FORCE_BOUNCE")) + flags |= IO_FLAG_FORCE_BOUNCE; + +#ifdef __linux__ + /* + * We need to make sure any previous errors in the block + * device are thrown away, sigh. + */ + (void) fsync(fd); #endif - if (name == 0) - return EXT2_ET_BAD_DEVICE_NAME; 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), &data); if (retval) goto cleanup; - io->manager = unix_io_manager; + io->manager = io_mgr; retval = ext2fs_get_mem(strlen(name)+1, &io->name); if (retval) goto cleanup; @@ -446,22 +601,60 @@ 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; + data->flags = flags; + data->dev = fd; + +#if defined(O_DIRECT) + if (flags & IO_FLAG_DIRECT_IO) + io->align = ext2fs_get_dio_alignment(data->dev); +#elif defined(F_NOCACHE) + if (flags & IO_FLAG_DIRECT_IO) + io->align = 4096; +#endif - if ((retval = alloc_cache(io, data))) - 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_fstat(data->dev, &st) == 0) { + if (ext2fsP_is_disk_device(st.st_mode)) + io->flags |= CHANNEL_FLAGS_BLOCK_DEVICE; + else + io->flags |= CHANNEL_FLAGS_DISCARD_ZEROES; + } - open_flags = (flags & IO_FLAG_RW) ? O_RDWR : O_RDONLY; - if (flags & IO_FLAG_EXCLUSIVE) - open_flags |= O_EXCL; -#ifdef HAVE_OPEN64 - data->dev = open64(io->name, open_flags); -#else - data->dev = open(io->name, open_flags); +#ifdef BLKDISCARDZEROES + { + int zeroes = 0; + if (ioctl(data->dev, BLKDISCARDZEROES, &zeroes) == 0 && + zeroes) + io->flags |= CHANNEL_FLAGS_DISCARD_ZEROES; + } #endif - if (data->dev < 0) { - retval = errno; - goto cleanup; + +#if defined(__CYGWIN__) + /* + * Some operating systems require that the buffers be aligned, + * regardless of O_DIRECT + */ + if (!io->align) + io->align = 512; +#endif + +#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) + if (io->flags & CHANNEL_FLAGS_BLOCK_DEVICE) { + int dio_align = ext2fs_get_dio_alignment(fd); + + if (io->align < dio_align) + io->align = dio_align; } +#endif + + if ((retval = alloc_cache(io, data))) + goto cleanup; #ifdef BLKROGET if (flags & IO_FLAG_RW) { @@ -471,7 +664,6 @@ static errcode_t unix_open(const char *name, int flags, io_channel *channel) /* Is the block device actually writable? */ error = ioctl(data->dev, BLKROGET, &readonly); if (!error && readonly) { - close(data->dev); retval = EPERM; goto cleanup; } @@ -498,8 +690,8 @@ 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) && - (S_ISBLK(st.st_mode))) { + (ext2fs_fstat(data->dev, &st) == 0) && + (ext2fsP_is_disk_device(st.st_mode))) { struct rlimit rlim; rlim.rlim_cur = rlim.rlim_max = (unsigned long) RLIM_INFINITY; @@ -517,14 +709,74 @@ static errcode_t unix_open(const char *name, int flags, io_channel *channel) cleanup: if (data) { + if (data->dev >= 0) + close(data->dev); free_cache(data); ext2fs_free_mem(&data); } - if (io) + if (io) { + if (io->name) { + ext2fs_free_mem(&io->name); + } ext2fs_free_mem(&io); + } return retval; } +static errcode_t unixfd_open(const char *str_fd, int flags, + io_channel *channel) +{ + int fd; + int fd_flags; + + fd = atoi(str_fd); +#if defined(HAVE_FCNTL) + fd_flags = fcntl(fd, F_GETFD); + if (fd_flags == -1) + return -EBADF; + + flags = 0; + if (fd_flags & O_RDWR) + flags |= IO_FLAG_RW; + if (fd_flags & O_EXCL) + flags |= IO_FLAG_EXCLUSIVE; +#if defined(O_DIRECT) + if (fd_flags & O_DIRECT) + flags |= IO_FLAG_DIRECT_IO; +#endif +#endif /* HAVE_FCNTL */ + + return unix_open_channel(str_fd, fd, flags, channel, unixfd_io_manager); +} + +static errcode_t unix_open(const char *name, int flags, + io_channel *channel) +{ + int fd = -1; + int open_flags; + + if (name == 0) + return EXT2_ET_BAD_DEVICE_NAME; + + open_flags = (flags & IO_FLAG_RW) ? O_RDWR : O_RDONLY; + if (flags & IO_FLAG_EXCLUSIVE) + open_flags |= O_EXCL; +#if defined(O_DIRECT) + if (flags & IO_FLAG_DIRECT_IO) + open_flags |= O_DIRECT; +#endif + fd = ext2fs_open_file(name, open_flags, 0); + if (fd < 0) + return errno; +#if defined(F_NOCACHE) && !defined(IO_DIRECT) + if (flags & IO_FLAG_DIRECT_IO) { + if (fcntl(fd, F_NOCACHE, 1) < 0) + return errno; + } +#endif + return unix_open_channel(name, fd, flags, channel, unix_io_manager); +} + static errcode_t unix_close(io_channel channel) { struct unix_private_data *data; @@ -575,7 +827,6 @@ static errcode_t unix_set_blksize(io_channel channel, int blksize) return 0; } - static errcode_t unix_read_blk64(io_channel channel, unsigned long long block, int count, void *buf) { @@ -615,6 +866,22 @@ static errcode_t unix_read_blk64(io_channel channel, unsigned long 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 @@ -689,7 +956,8 @@ static errcode_t unix_write_blk64(io_channel channel, unsigned long long block, cache = reuse; reuse_cache(channel, data, cache, block); } - memcpy(cache->buf, cp, channel->block_size); + if (cache->buf != cp) + memcpy(cache->buf, cp, channel->block_size); cache->dirty = !writethrough; count--; block++; @@ -699,6 +967,24 @@ static errcode_t unix_write_blk64(io_channel channel, unsigned long long block, #endif /* NO_IO_CACHE */ } +static errcode_t unix_cache_readahead(io_channel channel, + unsigned long long block, + unsigned long long count) +{ +#ifdef POSIX_FADV_WILLNEED + struct unix_private_data *data; + + data = (struct unix_private_data *)channel->private_data; + EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); + return posix_fadvise(data->dev, + (ext2_loff_t)block * channel->block_size + data->offset, + (ext2_loff_t)count * channel->block_size, + POSIX_FADV_WILLNEED); +#else + return EXT2_ET_OP_NOT_SUPPORTED; +#endif +} + static errcode_t unix_write_blk(io_channel channel, unsigned long block, int count, const void *buf) { @@ -716,6 +1002,13 @@ static errcode_t unix_write_byte(io_channel channel, unsigned long offset, data = (struct unix_private_data *) channel->private_data; EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_UNIX_IO_CHANNEL); + if (channel->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 @@ -728,6 +1021,8 @@ static errcode_t unix_write_byte(io_channel channel, unsigned long offset, return errno; actual = write(data->dev, buf, size); + if (actual < 0) + return errno; if (actual != size) return EXT2_ET_SHORT_WRITE; @@ -749,7 +1044,10 @@ static errcode_t unix_flush(io_channel channel) #ifndef NO_IO_CACHE retval = flush_cached_blocks(channel, data, 0); #endif - fsync(data->dev); +#ifdef HAVE_FSYNC + if (!retval && fsync(data->dev) != 0) + return errno; +#endif return retval; } @@ -778,3 +1076,176 @@ static errcode_t unix_set_option(io_channel channel, const char *option, } 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; + 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 + __u64 range[2]; + + range[0] = (__u64)(block) * channel->block_size + data->offset; + range[1] = (__u64)(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 + data->offset, + (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; +} + +/* + * If we know about ZERO_RANGE, try that before we try PUNCH_HOLE because + * ZERO_RANGE doesn't unmap preallocated blocks. We prefer fallocate because + * it always invalidates page cache, and libext2fs requires that reads after + * ZERO_RANGE return zeroes. + */ +static int __unix_zeroout(int fd, off_t offset, off_t len) +{ + int ret = -1; + +#if defined(HAVE_FALLOCATE) && defined(FALLOC_FL_ZERO_RANGE) + ret = fallocate(fd, FALLOC_FL_ZERO_RANGE, offset, len); + if (ret == 0) + return 0; +#endif +#if defined(HAVE_FALLOCATE) && defined(FALLOC_FL_PUNCH_HOLE) && defined(FALLOC_FL_KEEP_SIZE) + ret = fallocate(fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, + offset, len); + if (ret == 0) + return 0; +#endif + errno = EOPNOTSUPP; + return ret; +} + +/* parameters might not be used if OS doesn't support zeroout */ +#if __GNUC_PREREQ (4, 6) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wunused-parameter" +#endif +static errcode_t unix_zeroout(io_channel channel, unsigned long long block, + unsigned long long count) +{ + struct unix_private_data *data; + 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 (safe_getenv("UNIX_IO_NOZEROOUT")) + goto unimplemented; + + if (!(channel->flags & CHANNEL_FLAGS_BLOCK_DEVICE)) { + /* Regular file, try to use truncate/punch/zero. */ + struct stat statbuf; + + if (count == 0) + return 0; + /* + * If we're trying to zero a range past the end of the file, + * extend the file size, then truncate everything. + */ + ret = fstat(data->dev, &statbuf); + if (ret) + goto err; + if ((unsigned long long) statbuf.st_size < + (block + count) * channel->block_size + data->offset) { + ret = ftruncate(data->dev, + (block + count) * channel->block_size + data->offset); + if (ret) + goto err; + } + } + + ret = __unix_zeroout(data->dev, + (off_t)(block) * channel->block_size + data->offset, + (off_t)(count) * channel->block_size); +err: + if (ret < 0) { + if (errno == EOPNOTSUPP) + goto unimplemented; + return errno; + } + return 0; +unimplemented: + return EXT2_ET_UNIMPLEMENTED; +} +#if __GNUC_PREREQ (4, 6) +#pragma GCC diagnostic pop +#endif + +static struct struct_io_manager struct_unix_manager = { + .magic = EXT2_ET_MAGIC_IO_MANAGER, + .name = "Unix I/O Manager", + .open = unix_open, + .close = unix_close, + .set_blksize = unix_set_blksize, + .read_blk = unix_read_blk, + .write_blk = unix_write_blk, + .flush = unix_flush, + .write_byte = unix_write_byte, + .set_option = unix_set_option, + .get_stats = unix_get_stats, + .read_blk64 = unix_read_blk64, + .write_blk64 = unix_write_blk64, + .discard = unix_discard, + .cache_readahead = unix_cache_readahead, + .zeroout = unix_zeroout, +}; + +io_manager unix_io_manager = &struct_unix_manager; + +static struct struct_io_manager struct_unixfd_manager = { + .magic = EXT2_ET_MAGIC_IO_MANAGER, + .name = "Unix fd I/O Manager", + .open = unixfd_open, + .close = unix_close, + .set_blksize = unix_set_blksize, + .read_blk = unix_read_blk, + .write_blk = unix_write_blk, + .flush = unix_flush, + .write_byte = unix_write_byte, + .set_option = unix_set_option, + .get_stats = unix_get_stats, + .read_blk64 = unix_read_blk64, + .write_blk64 = unix_write_blk64, + .discard = unix_discard, + .cache_readahead = unix_cache_readahead, + .zeroout = unix_zeroout, +}; + +io_manager unixfd_io_manager = &struct_unixfd_manager;