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