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