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