1 /* 2 * Copyright (C) 2015-2016 Anton Ivanov (aivanov@brocade.com) 3 * Copyright (C) 2000 Jeff Dike (jdike@karaya.com) 4 * Licensed under the GPL 5 */ 6 7 /* 2001-09-28...2002-04-17 8 * Partition stuff by James_McMechan@hotmail.com 9 * old style ubd by setting UBD_SHIFT to 0 10 * 2002-09-27...2002-10-18 massive tinkering for 2.5 11 * partitions have changed in 2.5 12 * 2003-01-29 more tinkering for 2.5.59-1 13 * This should now address the sysfs problems and has 14 * the symlink for devfs to allow for booting with 15 * the common /dev/ubd/discX/... names rather than 16 * only /dev/ubdN/discN this version also has lots of 17 * clean ups preparing for ubd-many. 18 * James McMechan 19 */ 20 21 #define UBD_SHIFT 4 22 23 #include <linux/module.h> 24 #include <linux/init.h> 25 #include <linux/blkdev.h> 26 #include <linux/blk-mq.h> 27 #include <linux/ata.h> 28 #include <linux/hdreg.h> 29 #include <linux/cdrom.h> 30 #include <linux/proc_fs.h> 31 #include <linux/seq_file.h> 32 #include <linux/ctype.h> 33 #include <linux/slab.h> 34 #include <linux/vmalloc.h> 35 #include <linux/platform_device.h> 36 #include <linux/scatterlist.h> 37 #include <asm/tlbflush.h> 38 #include <kern_util.h> 39 #include "mconsole_kern.h" 40 #include <init.h> 41 #include <irq_kern.h> 42 #include "ubd.h" 43 #include <os.h> 44 #include "cow.h" 45 46 enum ubd_req { UBD_READ, UBD_WRITE, UBD_FLUSH }; 47 48 struct io_thread_req { 49 struct request *req; 50 enum ubd_req op; 51 int fds[2]; 52 unsigned long offsets[2]; 53 unsigned long long offset; 54 unsigned long length; 55 char *buffer; 56 int sectorsize; 57 unsigned long sector_mask; 58 unsigned long long cow_offset; 59 unsigned long bitmap_words[2]; 60 int error; 61 }; 62 63 64 static struct io_thread_req * (*irq_req_buffer)[]; 65 static struct io_thread_req *irq_remainder; 66 static int irq_remainder_size; 67 68 static struct io_thread_req * (*io_req_buffer)[]; 69 static struct io_thread_req *io_remainder; 70 static int io_remainder_size; 71 72 73 74 static inline int ubd_test_bit(__u64 bit, unsigned char *data) 75 { 76 __u64 n; 77 int bits, off; 78 79 bits = sizeof(data[0]) * 8; 80 n = bit / bits; 81 off = bit % bits; 82 return (data[n] & (1 << off)) != 0; 83 } 84 85 static inline void ubd_set_bit(__u64 bit, unsigned char *data) 86 { 87 __u64 n; 88 int bits, off; 89 90 bits = sizeof(data[0]) * 8; 91 n = bit / bits; 92 off = bit % bits; 93 data[n] |= (1 << off); 94 } 95 /*End stuff from ubd_user.h*/ 96 97 #define DRIVER_NAME "uml-blkdev" 98 99 static DEFINE_MUTEX(ubd_lock); 100 static DEFINE_MUTEX(ubd_mutex); /* replaces BKL, might not be needed */ 101 102 static int ubd_open(struct block_device *bdev, fmode_t mode); 103 static void ubd_release(struct gendisk *disk, fmode_t mode); 104 static int ubd_ioctl(struct block_device *bdev, fmode_t mode, 105 unsigned int cmd, unsigned long arg); 106 static int ubd_getgeo(struct block_device *bdev, struct hd_geometry *geo); 107 108 #define MAX_DEV (16) 109 110 static const struct block_device_operations ubd_blops = { 111 .owner = THIS_MODULE, 112 .open = ubd_open, 113 .release = ubd_release, 114 .ioctl = ubd_ioctl, 115 .getgeo = ubd_getgeo, 116 }; 117 118 /* Protected by ubd_lock */ 119 static int fake_major = UBD_MAJOR; 120 static struct gendisk *ubd_gendisk[MAX_DEV]; 121 static struct gendisk *fake_gendisk[MAX_DEV]; 122 123 #ifdef CONFIG_BLK_DEV_UBD_SYNC 124 #define OPEN_FLAGS ((struct openflags) { .r = 1, .w = 1, .s = 1, .c = 0, \ 125 .cl = 1 }) 126 #else 127 #define OPEN_FLAGS ((struct openflags) { .r = 1, .w = 1, .s = 0, .c = 0, \ 128 .cl = 1 }) 129 #endif 130 static struct openflags global_openflags = OPEN_FLAGS; 131 132 struct cow { 133 /* backing file name */ 134 char *file; 135 /* backing file fd */ 136 int fd; 137 unsigned long *bitmap; 138 unsigned long bitmap_len; 139 int bitmap_offset; 140 int data_offset; 141 }; 142 143 #define MAX_SG 64 144 145 struct ubd { 146 /* name (and fd, below) of the file opened for writing, either the 147 * backing or the cow file. */ 148 char *file; 149 int count; 150 int fd; 151 __u64 size; 152 struct openflags boot_openflags; 153 struct openflags openflags; 154 unsigned shared:1; 155 unsigned no_cow:1; 156 struct cow cow; 157 struct platform_device pdev; 158 struct request_queue *queue; 159 struct blk_mq_tag_set tag_set; 160 spinlock_t lock; 161 }; 162 163 #define DEFAULT_COW { \ 164 .file = NULL, \ 165 .fd = -1, \ 166 .bitmap = NULL, \ 167 .bitmap_offset = 0, \ 168 .data_offset = 0, \ 169 } 170 171 #define DEFAULT_UBD { \ 172 .file = NULL, \ 173 .count = 0, \ 174 .fd = -1, \ 175 .size = -1, \ 176 .boot_openflags = OPEN_FLAGS, \ 177 .openflags = OPEN_FLAGS, \ 178 .no_cow = 0, \ 179 .shared = 0, \ 180 .cow = DEFAULT_COW, \ 181 .lock = __SPIN_LOCK_UNLOCKED(ubd_devs.lock), \ 182 } 183 184 /* Protected by ubd_lock */ 185 static struct ubd ubd_devs[MAX_DEV] = { [0 ... MAX_DEV - 1] = DEFAULT_UBD }; 186 187 /* Only changed by fake_ide_setup which is a setup */ 188 static int fake_ide = 0; 189 static struct proc_dir_entry *proc_ide_root = NULL; 190 static struct proc_dir_entry *proc_ide = NULL; 191 192 static blk_status_t ubd_queue_rq(struct blk_mq_hw_ctx *hctx, 193 const struct blk_mq_queue_data *bd); 194 195 static void make_proc_ide(void) 196 { 197 proc_ide_root = proc_mkdir("ide", NULL); 198 proc_ide = proc_mkdir("ide0", proc_ide_root); 199 } 200 201 static int fake_ide_media_proc_show(struct seq_file *m, void *v) 202 { 203 seq_puts(m, "disk\n"); 204 return 0; 205 } 206 207 static void make_ide_entries(const char *dev_name) 208 { 209 struct proc_dir_entry *dir, *ent; 210 char name[64]; 211 212 if(proc_ide_root == NULL) make_proc_ide(); 213 214 dir = proc_mkdir(dev_name, proc_ide); 215 if(!dir) return; 216 217 ent = proc_create_single("media", S_IRUGO, dir, 218 fake_ide_media_proc_show); 219 if(!ent) return; 220 snprintf(name, sizeof(name), "ide0/%s", dev_name); 221 proc_symlink(dev_name, proc_ide_root, name); 222 } 223 224 static int fake_ide_setup(char *str) 225 { 226 fake_ide = 1; 227 return 1; 228 } 229 230 __setup("fake_ide", fake_ide_setup); 231 232 __uml_help(fake_ide_setup, 233 "fake_ide\n" 234 " Create ide0 entries that map onto ubd devices.\n\n" 235 ); 236 237 static int parse_unit(char **ptr) 238 { 239 char *str = *ptr, *end; 240 int n = -1; 241 242 if(isdigit(*str)) { 243 n = simple_strtoul(str, &end, 0); 244 if(end == str) 245 return -1; 246 *ptr = end; 247 } 248 else if (('a' <= *str) && (*str <= 'z')) { 249 n = *str - 'a'; 250 str++; 251 *ptr = str; 252 } 253 return n; 254 } 255 256 /* If *index_out == -1 at exit, the passed option was a general one; 257 * otherwise, the str pointer is used (and owned) inside ubd_devs array, so it 258 * should not be freed on exit. 259 */ 260 static int ubd_setup_common(char *str, int *index_out, char **error_out) 261 { 262 struct ubd *ubd_dev; 263 struct openflags flags = global_openflags; 264 char *backing_file; 265 int n, err = 0, i; 266 267 if(index_out) *index_out = -1; 268 n = *str; 269 if(n == '='){ 270 char *end; 271 int major; 272 273 str++; 274 if(!strcmp(str, "sync")){ 275 global_openflags = of_sync(global_openflags); 276 goto out1; 277 } 278 279 err = -EINVAL; 280 major = simple_strtoul(str, &end, 0); 281 if((*end != '\0') || (end == str)){ 282 *error_out = "Didn't parse major number"; 283 goto out1; 284 } 285 286 mutex_lock(&ubd_lock); 287 if (fake_major != UBD_MAJOR) { 288 *error_out = "Can't assign a fake major twice"; 289 goto out1; 290 } 291 292 fake_major = major; 293 294 printk(KERN_INFO "Setting extra ubd major number to %d\n", 295 major); 296 err = 0; 297 out1: 298 mutex_unlock(&ubd_lock); 299 return err; 300 } 301 302 n = parse_unit(&str); 303 if(n < 0){ 304 *error_out = "Couldn't parse device number"; 305 return -EINVAL; 306 } 307 if(n >= MAX_DEV){ 308 *error_out = "Device number out of range"; 309 return 1; 310 } 311 312 err = -EBUSY; 313 mutex_lock(&ubd_lock); 314 315 ubd_dev = &ubd_devs[n]; 316 if(ubd_dev->file != NULL){ 317 *error_out = "Device is already configured"; 318 goto out; 319 } 320 321 if (index_out) 322 *index_out = n; 323 324 err = -EINVAL; 325 for (i = 0; i < sizeof("rscd="); i++) { 326 switch (*str) { 327 case 'r': 328 flags.w = 0; 329 break; 330 case 's': 331 flags.s = 1; 332 break; 333 case 'd': 334 ubd_dev->no_cow = 1; 335 break; 336 case 'c': 337 ubd_dev->shared = 1; 338 break; 339 case '=': 340 str++; 341 goto break_loop; 342 default: 343 *error_out = "Expected '=' or flag letter " 344 "(r, s, c, or d)"; 345 goto out; 346 } 347 str++; 348 } 349 350 if (*str == '=') 351 *error_out = "Too many flags specified"; 352 else 353 *error_out = "Missing '='"; 354 goto out; 355 356 break_loop: 357 backing_file = strchr(str, ','); 358 359 if (backing_file == NULL) 360 backing_file = strchr(str, ':'); 361 362 if(backing_file != NULL){ 363 if(ubd_dev->no_cow){ 364 *error_out = "Can't specify both 'd' and a cow file"; 365 goto out; 366 } 367 else { 368 *backing_file = '\0'; 369 backing_file++; 370 } 371 } 372 err = 0; 373 ubd_dev->file = str; 374 ubd_dev->cow.file = backing_file; 375 ubd_dev->boot_openflags = flags; 376 out: 377 mutex_unlock(&ubd_lock); 378 return err; 379 } 380 381 static int ubd_setup(char *str) 382 { 383 char *error; 384 int err; 385 386 err = ubd_setup_common(str, NULL, &error); 387 if(err) 388 printk(KERN_ERR "Failed to initialize device with \"%s\" : " 389 "%s\n", str, error); 390 return 1; 391 } 392 393 __setup("ubd", ubd_setup); 394 __uml_help(ubd_setup, 395 "ubd<n><flags>=<filename>[(:|,)<filename2>]\n" 396 " This is used to associate a device with a file in the underlying\n" 397 " filesystem. When specifying two filenames, the first one is the\n" 398 " COW name and the second is the backing file name. As separator you can\n" 399 " use either a ':' or a ',': the first one allows writing things like;\n" 400 " ubd0=~/Uml/root_cow:~/Uml/root_backing_file\n" 401 " while with a ',' the shell would not expand the 2nd '~'.\n" 402 " When using only one filename, UML will detect whether to treat it like\n" 403 " a COW file or a backing file. To override this detection, add the 'd'\n" 404 " flag:\n" 405 " ubd0d=BackingFile\n" 406 " Usually, there is a filesystem in the file, but \n" 407 " that's not required. Swap devices containing swap files can be\n" 408 " specified like this. Also, a file which doesn't contain a\n" 409 " filesystem can have its contents read in the virtual \n" 410 " machine by running 'dd' on the device. <n> must be in the range\n" 411 " 0 to 7. Appending an 'r' to the number will cause that device\n" 412 " to be mounted read-only. For example ubd1r=./ext_fs. Appending\n" 413 " an 's' will cause data to be written to disk on the host immediately.\n" 414 " 'c' will cause the device to be treated as being shared between multiple\n" 415 " UMLs and file locking will be turned off - this is appropriate for a\n" 416 " cluster filesystem and inappropriate at almost all other times.\n\n" 417 ); 418 419 static int udb_setup(char *str) 420 { 421 printk("udb%s specified on command line is almost certainly a ubd -> " 422 "udb TYPO\n", str); 423 return 1; 424 } 425 426 __setup("udb", udb_setup); 427 __uml_help(udb_setup, 428 "udb\n" 429 " This option is here solely to catch ubd -> udb typos, which can be\n" 430 " to impossible to catch visually unless you specifically look for\n" 431 " them. The only result of any option starting with 'udb' is an error\n" 432 " in the boot output.\n\n" 433 ); 434 435 /* Only changed by ubd_init, which is an initcall. */ 436 static int thread_fd = -1; 437 438 /* Function to read several request pointers at a time 439 * handling fractional reads if (and as) needed 440 */ 441 442 static int bulk_req_safe_read( 443 int fd, 444 struct io_thread_req * (*request_buffer)[], 445 struct io_thread_req **remainder, 446 int *remainder_size, 447 int max_recs 448 ) 449 { 450 int n = 0; 451 int res = 0; 452 453 if (*remainder_size > 0) { 454 memmove( 455 (char *) request_buffer, 456 (char *) remainder, *remainder_size 457 ); 458 n = *remainder_size; 459 } 460 461 res = os_read_file( 462 fd, 463 ((char *) request_buffer) + *remainder_size, 464 sizeof(struct io_thread_req *)*max_recs 465 - *remainder_size 466 ); 467 if (res > 0) { 468 n += res; 469 if ((n % sizeof(struct io_thread_req *)) > 0) { 470 /* 471 * Read somehow returned not a multiple of dword 472 * theoretically possible, but never observed in the 473 * wild, so read routine must be able to handle it 474 */ 475 *remainder_size = n % sizeof(struct io_thread_req *); 476 WARN(*remainder_size > 0, "UBD IPC read returned a partial result"); 477 memmove( 478 remainder, 479 ((char *) request_buffer) + 480 (n/sizeof(struct io_thread_req *))*sizeof(struct io_thread_req *), 481 *remainder_size 482 ); 483 n = n - *remainder_size; 484 } 485 } else { 486 n = res; 487 } 488 return n; 489 } 490 491 /* Called without dev->lock held, and only in interrupt context. */ 492 static void ubd_handler(void) 493 { 494 int n; 495 int count; 496 497 while(1){ 498 n = bulk_req_safe_read( 499 thread_fd, 500 irq_req_buffer, 501 &irq_remainder, 502 &irq_remainder_size, 503 UBD_REQ_BUFFER_SIZE 504 ); 505 if (n < 0) { 506 if(n == -EAGAIN) 507 break; 508 printk(KERN_ERR "spurious interrupt in ubd_handler, " 509 "err = %d\n", -n); 510 return; 511 } 512 for (count = 0; count < n/sizeof(struct io_thread_req *); count++) { 513 struct io_thread_req *io_req = (*irq_req_buffer)[count]; 514 int err = io_req->error ? BLK_STS_IOERR : BLK_STS_OK; 515 516 if (!blk_update_request(io_req->req, err, io_req->length)) 517 __blk_mq_end_request(io_req->req, err); 518 519 kfree(io_req); 520 } 521 } 522 523 reactivate_fd(thread_fd, UBD_IRQ); 524 } 525 526 static irqreturn_t ubd_intr(int irq, void *dev) 527 { 528 ubd_handler(); 529 return IRQ_HANDLED; 530 } 531 532 /* Only changed by ubd_init, which is an initcall. */ 533 static int io_pid = -1; 534 535 static void kill_io_thread(void) 536 { 537 if(io_pid != -1) 538 os_kill_process(io_pid, 1); 539 } 540 541 __uml_exitcall(kill_io_thread); 542 543 static inline int ubd_file_size(struct ubd *ubd_dev, __u64 *size_out) 544 { 545 char *file; 546 int fd; 547 int err; 548 549 __u32 version; 550 __u32 align; 551 char *backing_file; 552 time_t mtime; 553 unsigned long long size; 554 int sector_size; 555 int bitmap_offset; 556 557 if (ubd_dev->file && ubd_dev->cow.file) { 558 file = ubd_dev->cow.file; 559 560 goto out; 561 } 562 563 fd = os_open_file(ubd_dev->file, of_read(OPENFLAGS()), 0); 564 if (fd < 0) 565 return fd; 566 567 err = read_cow_header(file_reader, &fd, &version, &backing_file, \ 568 &mtime, &size, §or_size, &align, &bitmap_offset); 569 os_close_file(fd); 570 571 if(err == -EINVAL) 572 file = ubd_dev->file; 573 else 574 file = backing_file; 575 576 out: 577 return os_file_size(file, size_out); 578 } 579 580 static int read_cow_bitmap(int fd, void *buf, int offset, int len) 581 { 582 int err; 583 584 err = os_pread_file(fd, buf, len, offset); 585 if (err < 0) 586 return err; 587 588 return 0; 589 } 590 591 static int backing_file_mismatch(char *file, __u64 size, time_t mtime) 592 { 593 unsigned long modtime; 594 unsigned long long actual; 595 int err; 596 597 err = os_file_modtime(file, &modtime); 598 if (err < 0) { 599 printk(KERN_ERR "Failed to get modification time of backing " 600 "file \"%s\", err = %d\n", file, -err); 601 return err; 602 } 603 604 err = os_file_size(file, &actual); 605 if (err < 0) { 606 printk(KERN_ERR "Failed to get size of backing file \"%s\", " 607 "err = %d\n", file, -err); 608 return err; 609 } 610 611 if (actual != size) { 612 /*__u64 can be a long on AMD64 and with %lu GCC complains; so 613 * the typecast.*/ 614 printk(KERN_ERR "Size mismatch (%llu vs %llu) of COW header " 615 "vs backing file\n", (unsigned long long) size, actual); 616 return -EINVAL; 617 } 618 if (modtime != mtime) { 619 printk(KERN_ERR "mtime mismatch (%ld vs %ld) of COW header vs " 620 "backing file\n", mtime, modtime); 621 return -EINVAL; 622 } 623 return 0; 624 } 625 626 static int path_requires_switch(char *from_cmdline, char *from_cow, char *cow) 627 { 628 struct uml_stat buf1, buf2; 629 int err; 630 631 if (from_cmdline == NULL) 632 return 0; 633 if (!strcmp(from_cmdline, from_cow)) 634 return 0; 635 636 err = os_stat_file(from_cmdline, &buf1); 637 if (err < 0) { 638 printk(KERN_ERR "Couldn't stat '%s', err = %d\n", from_cmdline, 639 -err); 640 return 0; 641 } 642 err = os_stat_file(from_cow, &buf2); 643 if (err < 0) { 644 printk(KERN_ERR "Couldn't stat '%s', err = %d\n", from_cow, 645 -err); 646 return 1; 647 } 648 if ((buf1.ust_dev == buf2.ust_dev) && (buf1.ust_ino == buf2.ust_ino)) 649 return 0; 650 651 printk(KERN_ERR "Backing file mismatch - \"%s\" requested, " 652 "\"%s\" specified in COW header of \"%s\"\n", 653 from_cmdline, from_cow, cow); 654 return 1; 655 } 656 657 static int open_ubd_file(char *file, struct openflags *openflags, int shared, 658 char **backing_file_out, int *bitmap_offset_out, 659 unsigned long *bitmap_len_out, int *data_offset_out, 660 int *create_cow_out) 661 { 662 time_t mtime; 663 unsigned long long size; 664 __u32 version, align; 665 char *backing_file; 666 int fd, err, sectorsize, asked_switch, mode = 0644; 667 668 fd = os_open_file(file, *openflags, mode); 669 if (fd < 0) { 670 if ((fd == -ENOENT) && (create_cow_out != NULL)) 671 *create_cow_out = 1; 672 if (!openflags->w || 673 ((fd != -EROFS) && (fd != -EACCES))) 674 return fd; 675 openflags->w = 0; 676 fd = os_open_file(file, *openflags, mode); 677 if (fd < 0) 678 return fd; 679 } 680 681 if (shared) 682 printk(KERN_INFO "Not locking \"%s\" on the host\n", file); 683 else { 684 err = os_lock_file(fd, openflags->w); 685 if (err < 0) { 686 printk(KERN_ERR "Failed to lock '%s', err = %d\n", 687 file, -err); 688 goto out_close; 689 } 690 } 691 692 /* Successful return case! */ 693 if (backing_file_out == NULL) 694 return fd; 695 696 err = read_cow_header(file_reader, &fd, &version, &backing_file, &mtime, 697 &size, §orsize, &align, bitmap_offset_out); 698 if (err && (*backing_file_out != NULL)) { 699 printk(KERN_ERR "Failed to read COW header from COW file " 700 "\"%s\", errno = %d\n", file, -err); 701 goto out_close; 702 } 703 if (err) 704 return fd; 705 706 asked_switch = path_requires_switch(*backing_file_out, backing_file, 707 file); 708 709 /* Allow switching only if no mismatch. */ 710 if (asked_switch && !backing_file_mismatch(*backing_file_out, size, 711 mtime)) { 712 printk(KERN_ERR "Switching backing file to '%s'\n", 713 *backing_file_out); 714 err = write_cow_header(file, fd, *backing_file_out, 715 sectorsize, align, &size); 716 if (err) { 717 printk(KERN_ERR "Switch failed, errno = %d\n", -err); 718 goto out_close; 719 } 720 } else { 721 *backing_file_out = backing_file; 722 err = backing_file_mismatch(*backing_file_out, size, mtime); 723 if (err) 724 goto out_close; 725 } 726 727 cow_sizes(version, size, sectorsize, align, *bitmap_offset_out, 728 bitmap_len_out, data_offset_out); 729 730 return fd; 731 out_close: 732 os_close_file(fd); 733 return err; 734 } 735 736 static int create_cow_file(char *cow_file, char *backing_file, 737 struct openflags flags, 738 int sectorsize, int alignment, int *bitmap_offset_out, 739 unsigned long *bitmap_len_out, int *data_offset_out) 740 { 741 int err, fd; 742 743 flags.c = 1; 744 fd = open_ubd_file(cow_file, &flags, 0, NULL, NULL, NULL, NULL, NULL); 745 if (fd < 0) { 746 err = fd; 747 printk(KERN_ERR "Open of COW file '%s' failed, errno = %d\n", 748 cow_file, -err); 749 goto out; 750 } 751 752 err = init_cow_file(fd, cow_file, backing_file, sectorsize, alignment, 753 bitmap_offset_out, bitmap_len_out, 754 data_offset_out); 755 if (!err) 756 return fd; 757 os_close_file(fd); 758 out: 759 return err; 760 } 761 762 static void ubd_close_dev(struct ubd *ubd_dev) 763 { 764 os_close_file(ubd_dev->fd); 765 if(ubd_dev->cow.file == NULL) 766 return; 767 768 os_close_file(ubd_dev->cow.fd); 769 vfree(ubd_dev->cow.bitmap); 770 ubd_dev->cow.bitmap = NULL; 771 } 772 773 static int ubd_open_dev(struct ubd *ubd_dev) 774 { 775 struct openflags flags; 776 char **back_ptr; 777 int err, create_cow, *create_ptr; 778 int fd; 779 780 ubd_dev->openflags = ubd_dev->boot_openflags; 781 create_cow = 0; 782 create_ptr = (ubd_dev->cow.file != NULL) ? &create_cow : NULL; 783 back_ptr = ubd_dev->no_cow ? NULL : &ubd_dev->cow.file; 784 785 fd = open_ubd_file(ubd_dev->file, &ubd_dev->openflags, ubd_dev->shared, 786 back_ptr, &ubd_dev->cow.bitmap_offset, 787 &ubd_dev->cow.bitmap_len, &ubd_dev->cow.data_offset, 788 create_ptr); 789 790 if((fd == -ENOENT) && create_cow){ 791 fd = create_cow_file(ubd_dev->file, ubd_dev->cow.file, 792 ubd_dev->openflags, 1 << 9, PAGE_SIZE, 793 &ubd_dev->cow.bitmap_offset, 794 &ubd_dev->cow.bitmap_len, 795 &ubd_dev->cow.data_offset); 796 if(fd >= 0){ 797 printk(KERN_INFO "Creating \"%s\" as COW file for " 798 "\"%s\"\n", ubd_dev->file, ubd_dev->cow.file); 799 } 800 } 801 802 if(fd < 0){ 803 printk("Failed to open '%s', errno = %d\n", ubd_dev->file, 804 -fd); 805 return fd; 806 } 807 ubd_dev->fd = fd; 808 809 if(ubd_dev->cow.file != NULL){ 810 blk_queue_max_hw_sectors(ubd_dev->queue, 8 * sizeof(long)); 811 812 err = -ENOMEM; 813 ubd_dev->cow.bitmap = vmalloc(ubd_dev->cow.bitmap_len); 814 if(ubd_dev->cow.bitmap == NULL){ 815 printk(KERN_ERR "Failed to vmalloc COW bitmap\n"); 816 goto error; 817 } 818 flush_tlb_kernel_vm(); 819 820 err = read_cow_bitmap(ubd_dev->fd, ubd_dev->cow.bitmap, 821 ubd_dev->cow.bitmap_offset, 822 ubd_dev->cow.bitmap_len); 823 if(err < 0) 824 goto error; 825 826 flags = ubd_dev->openflags; 827 flags.w = 0; 828 err = open_ubd_file(ubd_dev->cow.file, &flags, ubd_dev->shared, NULL, 829 NULL, NULL, NULL, NULL); 830 if(err < 0) goto error; 831 ubd_dev->cow.fd = err; 832 } 833 return 0; 834 error: 835 os_close_file(ubd_dev->fd); 836 return err; 837 } 838 839 static void ubd_device_release(struct device *dev) 840 { 841 struct ubd *ubd_dev = dev_get_drvdata(dev); 842 843 blk_cleanup_queue(ubd_dev->queue); 844 blk_mq_free_tag_set(&ubd_dev->tag_set); 845 *ubd_dev = ((struct ubd) DEFAULT_UBD); 846 } 847 848 static int ubd_disk_register(int major, u64 size, int unit, 849 struct gendisk **disk_out) 850 { 851 struct device *parent = NULL; 852 struct gendisk *disk; 853 854 disk = alloc_disk(1 << UBD_SHIFT); 855 if(disk == NULL) 856 return -ENOMEM; 857 858 disk->major = major; 859 disk->first_minor = unit << UBD_SHIFT; 860 disk->fops = &ubd_blops; 861 set_capacity(disk, size / 512); 862 if (major == UBD_MAJOR) 863 sprintf(disk->disk_name, "ubd%c", 'a' + unit); 864 else 865 sprintf(disk->disk_name, "ubd_fake%d", unit); 866 867 /* sysfs register (not for ide fake devices) */ 868 if (major == UBD_MAJOR) { 869 ubd_devs[unit].pdev.id = unit; 870 ubd_devs[unit].pdev.name = DRIVER_NAME; 871 ubd_devs[unit].pdev.dev.release = ubd_device_release; 872 dev_set_drvdata(&ubd_devs[unit].pdev.dev, &ubd_devs[unit]); 873 platform_device_register(&ubd_devs[unit].pdev); 874 parent = &ubd_devs[unit].pdev.dev; 875 } 876 877 disk->private_data = &ubd_devs[unit]; 878 disk->queue = ubd_devs[unit].queue; 879 device_add_disk(parent, disk, NULL); 880 881 *disk_out = disk; 882 return 0; 883 } 884 885 #define ROUND_BLOCK(n) ((n + ((1 << 9) - 1)) & (-1 << 9)) 886 887 static const struct blk_mq_ops ubd_mq_ops = { 888 .queue_rq = ubd_queue_rq, 889 }; 890 891 static int ubd_add(int n, char **error_out) 892 { 893 struct ubd *ubd_dev = &ubd_devs[n]; 894 int err = 0; 895 896 if(ubd_dev->file == NULL) 897 goto out; 898 899 err = ubd_file_size(ubd_dev, &ubd_dev->size); 900 if(err < 0){ 901 *error_out = "Couldn't determine size of device's file"; 902 goto out; 903 } 904 905 ubd_dev->size = ROUND_BLOCK(ubd_dev->size); 906 907 ubd_dev->tag_set.ops = &ubd_mq_ops; 908 ubd_dev->tag_set.queue_depth = 64; 909 ubd_dev->tag_set.numa_node = NUMA_NO_NODE; 910 ubd_dev->tag_set.flags = BLK_MQ_F_SHOULD_MERGE; 911 ubd_dev->tag_set.driver_data = ubd_dev; 912 ubd_dev->tag_set.nr_hw_queues = 1; 913 914 err = blk_mq_alloc_tag_set(&ubd_dev->tag_set); 915 if (err) 916 goto out; 917 918 ubd_dev->queue = blk_mq_init_queue(&ubd_dev->tag_set); 919 if (IS_ERR(ubd_dev->queue)) { 920 err = PTR_ERR(ubd_dev->queue); 921 goto out_cleanup; 922 } 923 924 ubd_dev->queue->queuedata = ubd_dev; 925 blk_queue_write_cache(ubd_dev->queue, true, false); 926 927 blk_queue_max_segments(ubd_dev->queue, MAX_SG); 928 err = ubd_disk_register(UBD_MAJOR, ubd_dev->size, n, &ubd_gendisk[n]); 929 if(err){ 930 *error_out = "Failed to register device"; 931 goto out_cleanup_tags; 932 } 933 934 if (fake_major != UBD_MAJOR) 935 ubd_disk_register(fake_major, ubd_dev->size, n, 936 &fake_gendisk[n]); 937 938 /* 939 * Perhaps this should also be under the "if (fake_major)" above 940 * using the fake_disk->disk_name 941 */ 942 if (fake_ide) 943 make_ide_entries(ubd_gendisk[n]->disk_name); 944 945 err = 0; 946 out: 947 return err; 948 949 out_cleanup_tags: 950 blk_mq_free_tag_set(&ubd_dev->tag_set); 951 out_cleanup: 952 blk_cleanup_queue(ubd_dev->queue); 953 goto out; 954 } 955 956 static int ubd_config(char *str, char **error_out) 957 { 958 int n, ret; 959 960 /* This string is possibly broken up and stored, so it's only 961 * freed if ubd_setup_common fails, or if only general options 962 * were set. 963 */ 964 str = kstrdup(str, GFP_KERNEL); 965 if (str == NULL) { 966 *error_out = "Failed to allocate memory"; 967 return -ENOMEM; 968 } 969 970 ret = ubd_setup_common(str, &n, error_out); 971 if (ret) 972 goto err_free; 973 974 if (n == -1) { 975 ret = 0; 976 goto err_free; 977 } 978 979 mutex_lock(&ubd_lock); 980 ret = ubd_add(n, error_out); 981 if (ret) 982 ubd_devs[n].file = NULL; 983 mutex_unlock(&ubd_lock); 984 985 out: 986 return ret; 987 988 err_free: 989 kfree(str); 990 goto out; 991 } 992 993 static int ubd_get_config(char *name, char *str, int size, char **error_out) 994 { 995 struct ubd *ubd_dev; 996 int n, len = 0; 997 998 n = parse_unit(&name); 999 if((n >= MAX_DEV) || (n < 0)){ 1000 *error_out = "ubd_get_config : device number out of range"; 1001 return -1; 1002 } 1003 1004 ubd_dev = &ubd_devs[n]; 1005 mutex_lock(&ubd_lock); 1006 1007 if(ubd_dev->file == NULL){ 1008 CONFIG_CHUNK(str, size, len, "", 1); 1009 goto out; 1010 } 1011 1012 CONFIG_CHUNK(str, size, len, ubd_dev->file, 0); 1013 1014 if(ubd_dev->cow.file != NULL){ 1015 CONFIG_CHUNK(str, size, len, ",", 0); 1016 CONFIG_CHUNK(str, size, len, ubd_dev->cow.file, 1); 1017 } 1018 else CONFIG_CHUNK(str, size, len, "", 1); 1019 1020 out: 1021 mutex_unlock(&ubd_lock); 1022 return len; 1023 } 1024 1025 static int ubd_id(char **str, int *start_out, int *end_out) 1026 { 1027 int n; 1028 1029 n = parse_unit(str); 1030 *start_out = 0; 1031 *end_out = MAX_DEV - 1; 1032 return n; 1033 } 1034 1035 static int ubd_remove(int n, char **error_out) 1036 { 1037 struct gendisk *disk = ubd_gendisk[n]; 1038 struct ubd *ubd_dev; 1039 int err = -ENODEV; 1040 1041 mutex_lock(&ubd_lock); 1042 1043 ubd_dev = &ubd_devs[n]; 1044 1045 if(ubd_dev->file == NULL) 1046 goto out; 1047 1048 /* you cannot remove a open disk */ 1049 err = -EBUSY; 1050 if(ubd_dev->count > 0) 1051 goto out; 1052 1053 ubd_gendisk[n] = NULL; 1054 if(disk != NULL){ 1055 del_gendisk(disk); 1056 put_disk(disk); 1057 } 1058 1059 if(fake_gendisk[n] != NULL){ 1060 del_gendisk(fake_gendisk[n]); 1061 put_disk(fake_gendisk[n]); 1062 fake_gendisk[n] = NULL; 1063 } 1064 1065 err = 0; 1066 platform_device_unregister(&ubd_dev->pdev); 1067 out: 1068 mutex_unlock(&ubd_lock); 1069 return err; 1070 } 1071 1072 /* All these are called by mconsole in process context and without 1073 * ubd-specific locks. The structure itself is const except for .list. 1074 */ 1075 static struct mc_device ubd_mc = { 1076 .list = LIST_HEAD_INIT(ubd_mc.list), 1077 .name = "ubd", 1078 .config = ubd_config, 1079 .get_config = ubd_get_config, 1080 .id = ubd_id, 1081 .remove = ubd_remove, 1082 }; 1083 1084 static int __init ubd_mc_init(void) 1085 { 1086 mconsole_register_dev(&ubd_mc); 1087 return 0; 1088 } 1089 1090 __initcall(ubd_mc_init); 1091 1092 static int __init ubd0_init(void) 1093 { 1094 struct ubd *ubd_dev = &ubd_devs[0]; 1095 1096 mutex_lock(&ubd_lock); 1097 if(ubd_dev->file == NULL) 1098 ubd_dev->file = "root_fs"; 1099 mutex_unlock(&ubd_lock); 1100 1101 return 0; 1102 } 1103 1104 __initcall(ubd0_init); 1105 1106 /* Used in ubd_init, which is an initcall */ 1107 static struct platform_driver ubd_driver = { 1108 .driver = { 1109 .name = DRIVER_NAME, 1110 }, 1111 }; 1112 1113 static int __init ubd_init(void) 1114 { 1115 char *error; 1116 int i, err; 1117 1118 if (register_blkdev(UBD_MAJOR, "ubd")) 1119 return -1; 1120 1121 if (fake_major != UBD_MAJOR) { 1122 char name[sizeof("ubd_nnn\0")]; 1123 1124 snprintf(name, sizeof(name), "ubd_%d", fake_major); 1125 if (register_blkdev(fake_major, "ubd")) 1126 return -1; 1127 } 1128 1129 irq_req_buffer = kmalloc_array(UBD_REQ_BUFFER_SIZE, 1130 sizeof(struct io_thread_req *), 1131 GFP_KERNEL 1132 ); 1133 irq_remainder = 0; 1134 1135 if (irq_req_buffer == NULL) { 1136 printk(KERN_ERR "Failed to initialize ubd buffering\n"); 1137 return -1; 1138 } 1139 io_req_buffer = kmalloc_array(UBD_REQ_BUFFER_SIZE, 1140 sizeof(struct io_thread_req *), 1141 GFP_KERNEL 1142 ); 1143 1144 io_remainder = 0; 1145 1146 if (io_req_buffer == NULL) { 1147 printk(KERN_ERR "Failed to initialize ubd buffering\n"); 1148 return -1; 1149 } 1150 platform_driver_register(&ubd_driver); 1151 mutex_lock(&ubd_lock); 1152 for (i = 0; i < MAX_DEV; i++){ 1153 err = ubd_add(i, &error); 1154 if(err) 1155 printk(KERN_ERR "Failed to initialize ubd device %d :" 1156 "%s\n", i, error); 1157 } 1158 mutex_unlock(&ubd_lock); 1159 return 0; 1160 } 1161 1162 late_initcall(ubd_init); 1163 1164 static int __init ubd_driver_init(void){ 1165 unsigned long stack; 1166 int err; 1167 1168 /* Set by CONFIG_BLK_DEV_UBD_SYNC or ubd=sync.*/ 1169 if(global_openflags.s){ 1170 printk(KERN_INFO "ubd: Synchronous mode\n"); 1171 /* Letting ubd=sync be like using ubd#s= instead of ubd#= is 1172 * enough. So use anyway the io thread. */ 1173 } 1174 stack = alloc_stack(0, 0); 1175 io_pid = start_io_thread(stack + PAGE_SIZE - sizeof(void *), 1176 &thread_fd); 1177 if(io_pid < 0){ 1178 printk(KERN_ERR 1179 "ubd : Failed to start I/O thread (errno = %d) - " 1180 "falling back to synchronous I/O\n", -io_pid); 1181 io_pid = -1; 1182 return 0; 1183 } 1184 err = um_request_irq(UBD_IRQ, thread_fd, IRQ_READ, ubd_intr, 1185 0, "ubd", ubd_devs); 1186 if(err != 0) 1187 printk(KERN_ERR "um_request_irq failed - errno = %d\n", -err); 1188 return 0; 1189 } 1190 1191 device_initcall(ubd_driver_init); 1192 1193 static int ubd_open(struct block_device *bdev, fmode_t mode) 1194 { 1195 struct gendisk *disk = bdev->bd_disk; 1196 struct ubd *ubd_dev = disk->private_data; 1197 int err = 0; 1198 1199 mutex_lock(&ubd_mutex); 1200 if(ubd_dev->count == 0){ 1201 err = ubd_open_dev(ubd_dev); 1202 if(err){ 1203 printk(KERN_ERR "%s: Can't open \"%s\": errno = %d\n", 1204 disk->disk_name, ubd_dev->file, -err); 1205 goto out; 1206 } 1207 } 1208 ubd_dev->count++; 1209 set_disk_ro(disk, !ubd_dev->openflags.w); 1210 1211 /* This should no more be needed. And it didn't work anyway to exclude 1212 * read-write remounting of filesystems.*/ 1213 /*if((mode & FMODE_WRITE) && !ubd_dev->openflags.w){ 1214 if(--ubd_dev->count == 0) ubd_close_dev(ubd_dev); 1215 err = -EROFS; 1216 }*/ 1217 out: 1218 mutex_unlock(&ubd_mutex); 1219 return err; 1220 } 1221 1222 static void ubd_release(struct gendisk *disk, fmode_t mode) 1223 { 1224 struct ubd *ubd_dev = disk->private_data; 1225 1226 mutex_lock(&ubd_mutex); 1227 if(--ubd_dev->count == 0) 1228 ubd_close_dev(ubd_dev); 1229 mutex_unlock(&ubd_mutex); 1230 } 1231 1232 static void cowify_bitmap(__u64 io_offset, int length, unsigned long *cow_mask, 1233 __u64 *cow_offset, unsigned long *bitmap, 1234 __u64 bitmap_offset, unsigned long *bitmap_words, 1235 __u64 bitmap_len) 1236 { 1237 __u64 sector = io_offset >> 9; 1238 int i, update_bitmap = 0; 1239 1240 for(i = 0; i < length >> 9; i++){ 1241 if(cow_mask != NULL) 1242 ubd_set_bit(i, (unsigned char *) cow_mask); 1243 if(ubd_test_bit(sector + i, (unsigned char *) bitmap)) 1244 continue; 1245 1246 update_bitmap = 1; 1247 ubd_set_bit(sector + i, (unsigned char *) bitmap); 1248 } 1249 1250 if(!update_bitmap) 1251 return; 1252 1253 *cow_offset = sector / (sizeof(unsigned long) * 8); 1254 1255 /* This takes care of the case where we're exactly at the end of the 1256 * device, and *cow_offset + 1 is off the end. So, just back it up 1257 * by one word. Thanks to Lynn Kerby for the fix and James McMechan 1258 * for the original diagnosis. 1259 */ 1260 if (*cow_offset == (DIV_ROUND_UP(bitmap_len, 1261 sizeof(unsigned long)) - 1)) 1262 (*cow_offset)--; 1263 1264 bitmap_words[0] = bitmap[*cow_offset]; 1265 bitmap_words[1] = bitmap[*cow_offset + 1]; 1266 1267 *cow_offset *= sizeof(unsigned long); 1268 *cow_offset += bitmap_offset; 1269 } 1270 1271 static void cowify_req(struct io_thread_req *req, unsigned long *bitmap, 1272 __u64 bitmap_offset, __u64 bitmap_len) 1273 { 1274 __u64 sector = req->offset >> 9; 1275 int i; 1276 1277 if(req->length > (sizeof(req->sector_mask) * 8) << 9) 1278 panic("Operation too long"); 1279 1280 if(req->op == UBD_READ) { 1281 for(i = 0; i < req->length >> 9; i++){ 1282 if(ubd_test_bit(sector + i, (unsigned char *) bitmap)) 1283 ubd_set_bit(i, (unsigned char *) 1284 &req->sector_mask); 1285 } 1286 } 1287 else cowify_bitmap(req->offset, req->length, &req->sector_mask, 1288 &req->cow_offset, bitmap, bitmap_offset, 1289 req->bitmap_words, bitmap_len); 1290 } 1291 1292 static int ubd_queue_one_vec(struct blk_mq_hw_ctx *hctx, struct request *req, 1293 u64 off, struct bio_vec *bvec) 1294 { 1295 struct ubd *dev = hctx->queue->queuedata; 1296 struct io_thread_req *io_req; 1297 int ret; 1298 1299 io_req = kmalloc(sizeof(struct io_thread_req), GFP_ATOMIC); 1300 if (!io_req) 1301 return -ENOMEM; 1302 1303 io_req->req = req; 1304 if (dev->cow.file) 1305 io_req->fds[0] = dev->cow.fd; 1306 else 1307 io_req->fds[0] = dev->fd; 1308 1309 if (req_op(req) == REQ_OP_FLUSH) { 1310 io_req->op = UBD_FLUSH; 1311 } else { 1312 io_req->fds[1] = dev->fd; 1313 io_req->cow_offset = -1; 1314 io_req->offset = off; 1315 io_req->length = bvec->bv_len; 1316 io_req->error = 0; 1317 io_req->sector_mask = 0; 1318 1319 io_req->op = rq_data_dir(req) == READ ? UBD_READ : UBD_WRITE; 1320 io_req->offsets[0] = 0; 1321 io_req->offsets[1] = dev->cow.data_offset; 1322 io_req->buffer = page_address(bvec->bv_page) + bvec->bv_offset; 1323 io_req->sectorsize = 1 << 9; 1324 1325 if (dev->cow.file) { 1326 cowify_req(io_req, dev->cow.bitmap, 1327 dev->cow.bitmap_offset, dev->cow.bitmap_len); 1328 } 1329 } 1330 1331 ret = os_write_file(thread_fd, &io_req, sizeof(io_req)); 1332 if (ret != sizeof(io_req)) { 1333 if (ret != -EAGAIN) 1334 pr_err("write to io thread failed: %d\n", -ret); 1335 kfree(io_req); 1336 } 1337 1338 return ret; 1339 } 1340 1341 static blk_status_t ubd_queue_rq(struct blk_mq_hw_ctx *hctx, 1342 const struct blk_mq_queue_data *bd) 1343 { 1344 struct request *req = bd->rq; 1345 int ret = 0; 1346 1347 blk_mq_start_request(req); 1348 1349 if (req_op(req) == REQ_OP_FLUSH) { 1350 ret = ubd_queue_one_vec(hctx, req, 0, NULL); 1351 } else { 1352 struct req_iterator iter; 1353 struct bio_vec bvec; 1354 u64 off = (u64)blk_rq_pos(req) << 9; 1355 1356 rq_for_each_segment(bvec, req, iter) { 1357 ret = ubd_queue_one_vec(hctx, req, off, &bvec); 1358 if (ret < 0) 1359 goto out; 1360 off += bvec.bv_len; 1361 } 1362 } 1363 out: 1364 if (ret < 0) { 1365 blk_mq_requeue_request(req, true); 1366 } 1367 return BLK_STS_OK; 1368 } 1369 1370 static int ubd_getgeo(struct block_device *bdev, struct hd_geometry *geo) 1371 { 1372 struct ubd *ubd_dev = bdev->bd_disk->private_data; 1373 1374 geo->heads = 128; 1375 geo->sectors = 32; 1376 geo->cylinders = ubd_dev->size / (128 * 32 * 512); 1377 return 0; 1378 } 1379 1380 static int ubd_ioctl(struct block_device *bdev, fmode_t mode, 1381 unsigned int cmd, unsigned long arg) 1382 { 1383 struct ubd *ubd_dev = bdev->bd_disk->private_data; 1384 u16 ubd_id[ATA_ID_WORDS]; 1385 1386 switch (cmd) { 1387 struct cdrom_volctrl volume; 1388 case HDIO_GET_IDENTITY: 1389 memset(&ubd_id, 0, ATA_ID_WORDS * 2); 1390 ubd_id[ATA_ID_CYLS] = ubd_dev->size / (128 * 32 * 512); 1391 ubd_id[ATA_ID_HEADS] = 128; 1392 ubd_id[ATA_ID_SECTORS] = 32; 1393 if(copy_to_user((char __user *) arg, (char *) &ubd_id, 1394 sizeof(ubd_id))) 1395 return -EFAULT; 1396 return 0; 1397 1398 case CDROMVOLREAD: 1399 if(copy_from_user(&volume, (char __user *) arg, sizeof(volume))) 1400 return -EFAULT; 1401 volume.channel0 = 255; 1402 volume.channel1 = 255; 1403 volume.channel2 = 255; 1404 volume.channel3 = 255; 1405 if(copy_to_user((char __user *) arg, &volume, sizeof(volume))) 1406 return -EFAULT; 1407 return 0; 1408 } 1409 return -EINVAL; 1410 } 1411 1412 static int update_bitmap(struct io_thread_req *req) 1413 { 1414 int n; 1415 1416 if(req->cow_offset == -1) 1417 return 0; 1418 1419 n = os_pwrite_file(req->fds[1], &req->bitmap_words, 1420 sizeof(req->bitmap_words), req->cow_offset); 1421 if(n != sizeof(req->bitmap_words)){ 1422 printk("do_io - bitmap update failed, err = %d fd = %d\n", -n, 1423 req->fds[1]); 1424 return 1; 1425 } 1426 1427 return 0; 1428 } 1429 1430 static void do_io(struct io_thread_req *req) 1431 { 1432 char *buf; 1433 unsigned long len; 1434 int n, nsectors, start, end, bit; 1435 __u64 off; 1436 1437 if (req->op == UBD_FLUSH) { 1438 /* fds[0] is always either the rw image or our cow file */ 1439 n = os_sync_file(req->fds[0]); 1440 if (n != 0) { 1441 printk("do_io - sync failed err = %d " 1442 "fd = %d\n", -n, req->fds[0]); 1443 req->error = 1; 1444 } 1445 return; 1446 } 1447 1448 nsectors = req->length / req->sectorsize; 1449 start = 0; 1450 do { 1451 bit = ubd_test_bit(start, (unsigned char *) &req->sector_mask); 1452 end = start; 1453 while((end < nsectors) && 1454 (ubd_test_bit(end, (unsigned char *) 1455 &req->sector_mask) == bit)) 1456 end++; 1457 1458 off = req->offset + req->offsets[bit] + 1459 start * req->sectorsize; 1460 len = (end - start) * req->sectorsize; 1461 buf = &req->buffer[start * req->sectorsize]; 1462 1463 if(req->op == UBD_READ){ 1464 n = 0; 1465 do { 1466 buf = &buf[n]; 1467 len -= n; 1468 n = os_pread_file(req->fds[bit], buf, len, off); 1469 if (n < 0) { 1470 printk("do_io - read failed, err = %d " 1471 "fd = %d\n", -n, req->fds[bit]); 1472 req->error = 1; 1473 return; 1474 } 1475 } while((n < len) && (n != 0)); 1476 if (n < len) memset(&buf[n], 0, len - n); 1477 } else { 1478 n = os_pwrite_file(req->fds[bit], buf, len, off); 1479 if(n != len){ 1480 printk("do_io - write failed err = %d " 1481 "fd = %d\n", -n, req->fds[bit]); 1482 req->error = 1; 1483 return; 1484 } 1485 } 1486 1487 start = end; 1488 } while(start < nsectors); 1489 1490 req->error = update_bitmap(req); 1491 } 1492 1493 /* Changed in start_io_thread, which is serialized by being called only 1494 * from ubd_init, which is an initcall. 1495 */ 1496 int kernel_fd = -1; 1497 1498 /* Only changed by the io thread. XXX: currently unused. */ 1499 static int io_count = 0; 1500 1501 int io_thread(void *arg) 1502 { 1503 int n, count, written, res; 1504 1505 os_fix_helper_signals(); 1506 1507 while(1){ 1508 n = bulk_req_safe_read( 1509 kernel_fd, 1510 io_req_buffer, 1511 &io_remainder, 1512 &io_remainder_size, 1513 UBD_REQ_BUFFER_SIZE 1514 ); 1515 if (n < 0) { 1516 if (n == -EAGAIN) { 1517 ubd_read_poll(-1); 1518 continue; 1519 } else { 1520 printk("io_thread - read failed, fd = %d, " 1521 "err = %d," 1522 "reminder = %d\n", 1523 kernel_fd, -n, io_remainder_size); 1524 } 1525 } 1526 1527 for (count = 0; count < n/sizeof(struct io_thread_req *); count++) { 1528 io_count++; 1529 do_io((*io_req_buffer)[count]); 1530 } 1531 1532 written = 0; 1533 1534 do { 1535 res = os_write_file(kernel_fd, ((char *) io_req_buffer) + written, n); 1536 if (res >= 0) { 1537 written += res; 1538 } else { 1539 if (res != -EAGAIN) { 1540 printk("io_thread - write failed, fd = %d, " 1541 "err = %d\n", kernel_fd, -n); 1542 } 1543 } 1544 if (written < n) { 1545 ubd_write_poll(-1); 1546 } 1547 } while (written < n); 1548 } 1549 1550 return 0; 1551 } 1552