1 /* 2 * linux/fs/isofs/inode.c 3 * 4 * (C) 1991 Linus Torvalds - minix filesystem 5 * 1992, 1993, 1994 Eric Youngdale Modified for ISO 9660 filesystem. 6 * 1994 Eberhard Moenkeberg - multi session handling. 7 * 1995 Mark Dobie - allow mounting of some weird VideoCDs and PhotoCDs. 8 * 1997 Gordon Chaffee - Joliet CDs 9 * 1998 Eric Lammerts - ISO 9660 Level 3 10 * 2004 Paul Serice - Inode Support pushed out from 4GB to 128GB 11 * 2004 Paul Serice - NFS Export Operations 12 */ 13 14 #include <linux/init.h> 15 #include <linux/module.h> 16 17 #include <linux/slab.h> 18 #include <linux/nls.h> 19 #include <linux/ctype.h> 20 #include <linux/smp_lock.h> 21 #include <linux/statfs.h> 22 #include <linux/cdrom.h> 23 #include <linux/parser.h> 24 25 #include "isofs.h" 26 #include "zisofs.h" 27 28 #define BEQUIET 29 30 static int isofs_hashi(struct dentry *parent, struct qstr *qstr); 31 static int isofs_hash(struct dentry *parent, struct qstr *qstr); 32 static int isofs_dentry_cmpi(struct dentry *dentry, struct qstr *a, struct qstr *b); 33 static int isofs_dentry_cmp(struct dentry *dentry, struct qstr *a, struct qstr *b); 34 35 #ifdef CONFIG_JOLIET 36 static int isofs_hashi_ms(struct dentry *parent, struct qstr *qstr); 37 static int isofs_hash_ms(struct dentry *parent, struct qstr *qstr); 38 static int isofs_dentry_cmpi_ms(struct dentry *dentry, struct qstr *a, struct qstr *b); 39 static int isofs_dentry_cmp_ms(struct dentry *dentry, struct qstr *a, struct qstr *b); 40 #endif 41 42 static void isofs_put_super(struct super_block *sb) 43 { 44 struct isofs_sb_info *sbi = ISOFS_SB(sb); 45 #ifdef CONFIG_JOLIET 46 if (sbi->s_nls_iocharset) { 47 unload_nls(sbi->s_nls_iocharset); 48 sbi->s_nls_iocharset = NULL; 49 } 50 #endif 51 52 kfree(sbi); 53 sb->s_fs_info = NULL; 54 return; 55 } 56 57 static void isofs_read_inode(struct inode *); 58 static int isofs_statfs (struct dentry *, struct kstatfs *); 59 60 static struct kmem_cache *isofs_inode_cachep; 61 62 static struct inode *isofs_alloc_inode(struct super_block *sb) 63 { 64 struct iso_inode_info *ei; 65 ei = kmem_cache_alloc(isofs_inode_cachep, GFP_KERNEL); 66 if (!ei) 67 return NULL; 68 return &ei->vfs_inode; 69 } 70 71 static void isofs_destroy_inode(struct inode *inode) 72 { 73 kmem_cache_free(isofs_inode_cachep, ISOFS_I(inode)); 74 } 75 76 static void init_once(void *foo, struct kmem_cache * cachep, unsigned long flags) 77 { 78 struct iso_inode_info *ei = foo; 79 80 if (flags & SLAB_CTOR_CONSTRUCTOR) 81 inode_init_once(&ei->vfs_inode); 82 } 83 84 static int init_inodecache(void) 85 { 86 isofs_inode_cachep = kmem_cache_create("isofs_inode_cache", 87 sizeof(struct iso_inode_info), 88 0, (SLAB_RECLAIM_ACCOUNT| 89 SLAB_MEM_SPREAD), 90 init_once, NULL); 91 if (isofs_inode_cachep == NULL) 92 return -ENOMEM; 93 return 0; 94 } 95 96 static void destroy_inodecache(void) 97 { 98 kmem_cache_destroy(isofs_inode_cachep); 99 } 100 101 static int isofs_remount(struct super_block *sb, int *flags, char *data) 102 { 103 /* we probably want a lot more here */ 104 *flags |= MS_RDONLY; 105 return 0; 106 } 107 108 static const struct super_operations isofs_sops = { 109 .alloc_inode = isofs_alloc_inode, 110 .destroy_inode = isofs_destroy_inode, 111 .read_inode = isofs_read_inode, 112 .put_super = isofs_put_super, 113 .statfs = isofs_statfs, 114 .remount_fs = isofs_remount, 115 }; 116 117 118 static struct dentry_operations isofs_dentry_ops[] = { 119 { 120 .d_hash = isofs_hash, 121 .d_compare = isofs_dentry_cmp, 122 }, 123 { 124 .d_hash = isofs_hashi, 125 .d_compare = isofs_dentry_cmpi, 126 }, 127 #ifdef CONFIG_JOLIET 128 { 129 .d_hash = isofs_hash_ms, 130 .d_compare = isofs_dentry_cmp_ms, 131 }, 132 { 133 .d_hash = isofs_hashi_ms, 134 .d_compare = isofs_dentry_cmpi_ms, 135 }, 136 #endif 137 }; 138 139 struct iso9660_options{ 140 char map; 141 char rock; 142 char joliet; 143 char cruft; 144 char hide; 145 char showassoc; 146 char nocompress; 147 unsigned char check; 148 unsigned int blocksize; 149 mode_t mode; 150 gid_t gid; 151 uid_t uid; 152 char *iocharset; 153 unsigned char utf8; 154 /* LVE */ 155 s32 session; 156 s32 sbsector; 157 }; 158 159 /* 160 * Compute the hash for the isofs name corresponding to the dentry. 161 */ 162 static int 163 isofs_hash_common(struct dentry *dentry, struct qstr *qstr, int ms) 164 { 165 const char *name; 166 int len; 167 168 len = qstr->len; 169 name = qstr->name; 170 if (ms) { 171 while (len && name[len-1] == '.') 172 len--; 173 } 174 175 qstr->hash = full_name_hash(name, len); 176 177 return 0; 178 } 179 180 /* 181 * Compute the hash for the isofs name corresponding to the dentry. 182 */ 183 static int 184 isofs_hashi_common(struct dentry *dentry, struct qstr *qstr, int ms) 185 { 186 const char *name; 187 int len; 188 char c; 189 unsigned long hash; 190 191 len = qstr->len; 192 name = qstr->name; 193 if (ms) { 194 while (len && name[len-1] == '.') 195 len--; 196 } 197 198 hash = init_name_hash(); 199 while (len--) { 200 c = tolower(*name++); 201 hash = partial_name_hash(tolower(c), hash); 202 } 203 qstr->hash = end_name_hash(hash); 204 205 return 0; 206 } 207 208 /* 209 * Case insensitive compare of two isofs names. 210 */ 211 static int isofs_dentry_cmpi_common(struct dentry *dentry, struct qstr *a, 212 struct qstr *b, int ms) 213 { 214 int alen, blen; 215 216 /* A filename cannot end in '.' or we treat it like it has none */ 217 alen = a->len; 218 blen = b->len; 219 if (ms) { 220 while (alen && a->name[alen-1] == '.') 221 alen--; 222 while (blen && b->name[blen-1] == '.') 223 blen--; 224 } 225 if (alen == blen) { 226 if (strnicmp(a->name, b->name, alen) == 0) 227 return 0; 228 } 229 return 1; 230 } 231 232 /* 233 * Case sensitive compare of two isofs names. 234 */ 235 static int isofs_dentry_cmp_common(struct dentry *dentry, struct qstr *a, 236 struct qstr *b, int ms) 237 { 238 int alen, blen; 239 240 /* A filename cannot end in '.' or we treat it like it has none */ 241 alen = a->len; 242 blen = b->len; 243 if (ms) { 244 while (alen && a->name[alen-1] == '.') 245 alen--; 246 while (blen && b->name[blen-1] == '.') 247 blen--; 248 } 249 if (alen == blen) { 250 if (strncmp(a->name, b->name, alen) == 0) 251 return 0; 252 } 253 return 1; 254 } 255 256 static int 257 isofs_hash(struct dentry *dentry, struct qstr *qstr) 258 { 259 return isofs_hash_common(dentry, qstr, 0); 260 } 261 262 static int 263 isofs_hashi(struct dentry *dentry, struct qstr *qstr) 264 { 265 return isofs_hashi_common(dentry, qstr, 0); 266 } 267 268 static int 269 isofs_dentry_cmp(struct dentry *dentry,struct qstr *a,struct qstr *b) 270 { 271 return isofs_dentry_cmp_common(dentry, a, b, 0); 272 } 273 274 static int 275 isofs_dentry_cmpi(struct dentry *dentry,struct qstr *a,struct qstr *b) 276 { 277 return isofs_dentry_cmpi_common(dentry, a, b, 0); 278 } 279 280 #ifdef CONFIG_JOLIET 281 static int 282 isofs_hash_ms(struct dentry *dentry, struct qstr *qstr) 283 { 284 return isofs_hash_common(dentry, qstr, 1); 285 } 286 287 static int 288 isofs_hashi_ms(struct dentry *dentry, struct qstr *qstr) 289 { 290 return isofs_hashi_common(dentry, qstr, 1); 291 } 292 293 static int 294 isofs_dentry_cmp_ms(struct dentry *dentry,struct qstr *a,struct qstr *b) 295 { 296 return isofs_dentry_cmp_common(dentry, a, b, 1); 297 } 298 299 static int 300 isofs_dentry_cmpi_ms(struct dentry *dentry,struct qstr *a,struct qstr *b) 301 { 302 return isofs_dentry_cmpi_common(dentry, a, b, 1); 303 } 304 #endif 305 306 enum { 307 Opt_block, Opt_check_r, Opt_check_s, Opt_cruft, Opt_gid, Opt_ignore, 308 Opt_iocharset, Opt_map_a, Opt_map_n, Opt_map_o, Opt_mode, Opt_nojoliet, 309 Opt_norock, Opt_sb, Opt_session, Opt_uid, Opt_unhide, Opt_utf8, Opt_err, 310 Opt_nocompress, Opt_hide, Opt_showassoc, 311 }; 312 313 static match_table_t tokens = { 314 {Opt_norock, "norock"}, 315 {Opt_nojoliet, "nojoliet"}, 316 {Opt_unhide, "unhide"}, 317 {Opt_hide, "hide"}, 318 {Opt_showassoc, "showassoc"}, 319 {Opt_cruft, "cruft"}, 320 {Opt_utf8, "utf8"}, 321 {Opt_iocharset, "iocharset=%s"}, 322 {Opt_map_a, "map=acorn"}, 323 {Opt_map_a, "map=a"}, 324 {Opt_map_n, "map=normal"}, 325 {Opt_map_n, "map=n"}, 326 {Opt_map_o, "map=off"}, 327 {Opt_map_o, "map=o"}, 328 {Opt_session, "session=%u"}, 329 {Opt_sb, "sbsector=%u"}, 330 {Opt_check_r, "check=relaxed"}, 331 {Opt_check_r, "check=r"}, 332 {Opt_check_s, "check=strict"}, 333 {Opt_check_s, "check=s"}, 334 {Opt_uid, "uid=%u"}, 335 {Opt_gid, "gid=%u"}, 336 {Opt_mode, "mode=%u"}, 337 {Opt_block, "block=%u"}, 338 {Opt_ignore, "conv=binary"}, 339 {Opt_ignore, "conv=b"}, 340 {Opt_ignore, "conv=text"}, 341 {Opt_ignore, "conv=t"}, 342 {Opt_ignore, "conv=mtext"}, 343 {Opt_ignore, "conv=m"}, 344 {Opt_ignore, "conv=auto"}, 345 {Opt_ignore, "conv=a"}, 346 {Opt_nocompress, "nocompress"}, 347 {Opt_err, NULL} 348 }; 349 350 static int parse_options(char *options, struct iso9660_options *popt) 351 { 352 char *p; 353 int option; 354 355 popt->map = 'n'; 356 popt->rock = 'y'; 357 popt->joliet = 'y'; 358 popt->cruft = 'n'; 359 popt->hide = 'n'; 360 popt->showassoc = 'n'; 361 popt->check = 'u'; /* unset */ 362 popt->nocompress = 0; 363 popt->blocksize = 1024; 364 popt->mode = S_IRUGO | S_IXUGO; /* r-x for all. The disc could 365 be shared with DOS machines so 366 virtually anything could be 367 a valid executable. */ 368 popt->gid = 0; 369 popt->uid = 0; 370 popt->iocharset = NULL; 371 popt->utf8 = 0; 372 popt->session=-1; 373 popt->sbsector=-1; 374 if (!options) 375 return 1; 376 377 while ((p = strsep(&options, ",")) != NULL) { 378 int token; 379 substring_t args[MAX_OPT_ARGS]; 380 unsigned n; 381 382 if (!*p) 383 continue; 384 385 token = match_token(p, tokens, args); 386 switch (token) { 387 case Opt_norock: 388 popt->rock = 'n'; 389 break; 390 case Opt_nojoliet: 391 popt->joliet = 'n'; 392 break; 393 case Opt_hide: 394 popt->hide = 'y'; 395 break; 396 case Opt_unhide: 397 case Opt_showassoc: 398 popt->showassoc = 'y'; 399 break; 400 case Opt_cruft: 401 popt->cruft = 'y'; 402 break; 403 case Opt_utf8: 404 popt->utf8 = 1; 405 break; 406 #ifdef CONFIG_JOLIET 407 case Opt_iocharset: 408 popt->iocharset = match_strdup(&args[0]); 409 break; 410 #endif 411 case Opt_map_a: 412 popt->map = 'a'; 413 break; 414 case Opt_map_o: 415 popt->map = 'o'; 416 break; 417 case Opt_map_n: 418 popt->map = 'n'; 419 break; 420 case Opt_session: 421 if (match_int(&args[0], &option)) 422 return 0; 423 n = option; 424 if (n > 99) 425 return 0; 426 popt->session = n + 1; 427 break; 428 case Opt_sb: 429 if (match_int(&args[0], &option)) 430 return 0; 431 popt->sbsector = option; 432 break; 433 case Opt_check_r: 434 popt->check = 'r'; 435 break; 436 case Opt_check_s: 437 popt->check = 's'; 438 break; 439 case Opt_ignore: 440 break; 441 case Opt_uid: 442 if (match_int(&args[0], &option)) 443 return 0; 444 popt->uid = option; 445 break; 446 case Opt_gid: 447 if (match_int(&args[0], &option)) 448 return 0; 449 popt->gid = option; 450 break; 451 case Opt_mode: 452 if (match_int(&args[0], &option)) 453 return 0; 454 popt->mode = option; 455 break; 456 case Opt_block: 457 if (match_int(&args[0], &option)) 458 return 0; 459 n = option; 460 if (n != 512 && n != 1024 && n != 2048) 461 return 0; 462 popt->blocksize = n; 463 break; 464 case Opt_nocompress: 465 popt->nocompress = 1; 466 break; 467 default: 468 return 0; 469 } 470 } 471 return 1; 472 } 473 474 /* 475 * look if the driver can tell the multi session redirection value 476 * 477 * don't change this if you don't know what you do, please! 478 * Multisession is legal only with XA disks. 479 * A non-XA disk with more than one volume descriptor may do it right, but 480 * usually is written in a nowhere standardized "multi-partition" manner. 481 * Multisession uses absolute addressing (solely the first frame of the whole 482 * track is #0), multi-partition uses relative addressing (each first frame of 483 * each track is #0), and a track is not a session. 484 * 485 * A broken CDwriter software or drive firmware does not set new standards, 486 * at least not if conflicting with the existing ones. 487 * 488 * emoenke@gwdg.de 489 */ 490 #define WE_OBEY_THE_WRITTEN_STANDARDS 1 491 492 static unsigned int isofs_get_last_session(struct super_block *sb, s32 session) 493 { 494 struct cdrom_multisession ms_info; 495 unsigned int vol_desc_start; 496 struct block_device *bdev = sb->s_bdev; 497 int i; 498 499 vol_desc_start=0; 500 ms_info.addr_format=CDROM_LBA; 501 if(session >= 0 && session <= 99) { 502 struct cdrom_tocentry Te; 503 Te.cdte_track=session; 504 Te.cdte_format=CDROM_LBA; 505 i = ioctl_by_bdev(bdev, CDROMREADTOCENTRY, (unsigned long) &Te); 506 if (!i) { 507 printk(KERN_DEBUG "Session %d start %d type %d\n", 508 session, Te.cdte_addr.lba, 509 Te.cdte_ctrl&CDROM_DATA_TRACK); 510 if ((Te.cdte_ctrl&CDROM_DATA_TRACK) == 4) 511 return Te.cdte_addr.lba; 512 } 513 514 printk(KERN_ERR "Invalid session number or type of track\n"); 515 } 516 i = ioctl_by_bdev(bdev, CDROMMULTISESSION, (unsigned long) &ms_info); 517 if (session > 0) 518 printk(KERN_ERR "Invalid session number\n"); 519 #if 0 520 printk("isofs.inode: CDROMMULTISESSION: rc=%d\n",i); 521 if (i==0) { 522 printk("isofs.inode: XA disk: %s\n",ms_info.xa_flag?"yes":"no"); 523 printk("isofs.inode: vol_desc_start = %d\n", ms_info.addr.lba); 524 } 525 #endif 526 if (i==0) 527 #if WE_OBEY_THE_WRITTEN_STANDARDS 528 if (ms_info.xa_flag) /* necessary for a valid ms_info.addr */ 529 #endif 530 vol_desc_start=ms_info.addr.lba; 531 return vol_desc_start; 532 } 533 534 /* 535 * Initialize the superblock and read the root inode. 536 * 537 * Note: a check_disk_change() has been done immediately prior 538 * to this call, so we don't need to check again. 539 */ 540 static int isofs_fill_super(struct super_block *s, void *data, int silent) 541 { 542 struct buffer_head * bh = NULL, *pri_bh = NULL; 543 struct hs_primary_descriptor * h_pri = NULL; 544 struct iso_primary_descriptor * pri = NULL; 545 struct iso_supplementary_descriptor *sec = NULL; 546 struct iso_directory_record * rootp; 547 int joliet_level = 0; 548 int iso_blknum, block; 549 int orig_zonesize; 550 int table; 551 unsigned int vol_desc_start; 552 unsigned long first_data_zone; 553 struct inode * inode; 554 struct iso9660_options opt; 555 struct isofs_sb_info * sbi; 556 557 sbi = kzalloc(sizeof(*sbi), GFP_KERNEL); 558 if (!sbi) 559 return -ENOMEM; 560 s->s_fs_info = sbi; 561 562 if (!parse_options((char *)data, &opt)) 563 goto out_freesbi; 564 565 /* 566 * First of all, get the hardware blocksize for this device. 567 * If we don't know what it is, or the hardware blocksize is 568 * larger than the blocksize the user specified, then use 569 * that value. 570 */ 571 /* 572 * What if bugger tells us to go beyond page size? 573 */ 574 opt.blocksize = sb_min_blocksize(s, opt.blocksize); 575 576 sbi->s_high_sierra = 0; /* default is iso9660 */ 577 578 vol_desc_start = (opt.sbsector != -1) ? 579 opt.sbsector : isofs_get_last_session(s,opt.session); 580 581 for (iso_blknum = vol_desc_start+16; 582 iso_blknum < vol_desc_start+100; iso_blknum++) 583 { 584 struct hs_volume_descriptor * hdp; 585 struct iso_volume_descriptor * vdp; 586 587 block = iso_blknum << (ISOFS_BLOCK_BITS - s->s_blocksize_bits); 588 if (!(bh = sb_bread(s, block))) 589 goto out_no_read; 590 591 vdp = (struct iso_volume_descriptor *)bh->b_data; 592 hdp = (struct hs_volume_descriptor *)bh->b_data; 593 594 /* Due to the overlapping physical location of the descriptors, 595 * ISO CDs can match hdp->id==HS_STANDARD_ID as well. To ensure 596 * proper identification in this case, we first check for ISO. 597 */ 598 if (strncmp (vdp->id, ISO_STANDARD_ID, sizeof vdp->id) == 0) { 599 if (isonum_711 (vdp->type) == ISO_VD_END) 600 break; 601 if (isonum_711 (vdp->type) == ISO_VD_PRIMARY) { 602 if (pri == NULL) { 603 pri = (struct iso_primary_descriptor *)vdp; 604 /* Save the buffer in case we need it ... */ 605 pri_bh = bh; 606 bh = NULL; 607 } 608 } 609 #ifdef CONFIG_JOLIET 610 else if (isonum_711 (vdp->type) == ISO_VD_SUPPLEMENTARY) { 611 sec = (struct iso_supplementary_descriptor *)vdp; 612 if (sec->escape[0] == 0x25 && sec->escape[1] == 0x2f) { 613 if (opt.joliet == 'y') { 614 if (sec->escape[2] == 0x40) { 615 joliet_level = 1; 616 } else if (sec->escape[2] == 0x43) { 617 joliet_level = 2; 618 } else if (sec->escape[2] == 0x45) { 619 joliet_level = 3; 620 } 621 printk(KERN_DEBUG"ISO 9660 Extensions: Microsoft Joliet Level %d\n", 622 joliet_level); 623 } 624 goto root_found; 625 } else { 626 /* Unknown supplementary volume descriptor */ 627 sec = NULL; 628 } 629 } 630 #endif 631 } else { 632 if (strncmp (hdp->id, HS_STANDARD_ID, sizeof hdp->id) == 0) { 633 if (isonum_711 (hdp->type) != ISO_VD_PRIMARY) 634 goto out_freebh; 635 636 sbi->s_high_sierra = 1; 637 opt.rock = 'n'; 638 h_pri = (struct hs_primary_descriptor *)vdp; 639 goto root_found; 640 } 641 } 642 643 /* Just skip any volume descriptors we don't recognize */ 644 645 brelse(bh); 646 bh = NULL; 647 } 648 /* 649 * If we fall through, either no volume descriptor was found, 650 * or else we passed a primary descriptor looking for others. 651 */ 652 if (!pri) 653 goto out_unknown_format; 654 brelse(bh); 655 bh = pri_bh; 656 pri_bh = NULL; 657 658 root_found: 659 660 if (joliet_level && (pri == NULL || opt.rock == 'n')) { 661 /* This is the case of Joliet with the norock mount flag. 662 * A disc with both Joliet and Rock Ridge is handled later 663 */ 664 pri = (struct iso_primary_descriptor *) sec; 665 } 666 667 if(sbi->s_high_sierra){ 668 rootp = (struct iso_directory_record *) h_pri->root_directory_record; 669 sbi->s_nzones = isonum_733 (h_pri->volume_space_size); 670 sbi->s_log_zone_size = isonum_723 (h_pri->logical_block_size); 671 sbi->s_max_size = isonum_733(h_pri->volume_space_size); 672 } else { 673 if (!pri) 674 goto out_freebh; 675 rootp = (struct iso_directory_record *) pri->root_directory_record; 676 sbi->s_nzones = isonum_733 (pri->volume_space_size); 677 sbi->s_log_zone_size = isonum_723 (pri->logical_block_size); 678 sbi->s_max_size = isonum_733(pri->volume_space_size); 679 } 680 681 sbi->s_ninodes = 0; /* No way to figure this out easily */ 682 683 orig_zonesize = sbi->s_log_zone_size; 684 /* 685 * If the zone size is smaller than the hardware sector size, 686 * this is a fatal error. This would occur if the disc drive 687 * had sectors that were 2048 bytes, but the filesystem had 688 * blocks that were 512 bytes (which should only very rarely 689 * happen.) 690 */ 691 if(orig_zonesize < opt.blocksize) 692 goto out_bad_size; 693 694 /* RDE: convert log zone size to bit shift */ 695 switch (sbi->s_log_zone_size) 696 { case 512: sbi->s_log_zone_size = 9; break; 697 case 1024: sbi->s_log_zone_size = 10; break; 698 case 2048: sbi->s_log_zone_size = 11; break; 699 700 default: 701 goto out_bad_zone_size; 702 } 703 704 s->s_magic = ISOFS_SUPER_MAGIC; 705 s->s_maxbytes = 0xffffffff; /* We can handle files up to 4 GB */ 706 707 /* The CDROM is read-only, has no nodes (devices) on it, and since 708 all of the files appear to be owned by root, we really do not want 709 to allow suid. (suid or devices will not show up unless we have 710 Rock Ridge extensions) */ 711 712 s->s_flags |= MS_RDONLY /* | MS_NODEV | MS_NOSUID */; 713 714 /* Set this for reference. Its not currently used except on write 715 which we don't have .. */ 716 717 first_data_zone = isonum_733 (rootp->extent) + 718 isonum_711 (rootp->ext_attr_length); 719 sbi->s_firstdatazone = first_data_zone; 720 #ifndef BEQUIET 721 printk(KERN_DEBUG "Max size:%ld Log zone size:%ld\n", 722 sbi->s_max_size, 723 1UL << sbi->s_log_zone_size); 724 printk(KERN_DEBUG "First datazone:%ld\n", sbi->s_firstdatazone); 725 if(sbi->s_high_sierra) 726 printk(KERN_DEBUG "Disc in High Sierra format.\n"); 727 #endif 728 729 /* 730 * If the Joliet level is set, we _may_ decide to use the 731 * secondary descriptor, but can't be sure until after we 732 * read the root inode. But before reading the root inode 733 * we may need to change the device blocksize, and would 734 * rather release the old buffer first. So, we cache the 735 * first_data_zone value from the secondary descriptor. 736 */ 737 if (joliet_level) { 738 pri = (struct iso_primary_descriptor *) sec; 739 rootp = (struct iso_directory_record *) 740 pri->root_directory_record; 741 first_data_zone = isonum_733 (rootp->extent) + 742 isonum_711 (rootp->ext_attr_length); 743 } 744 745 /* 746 * We're all done using the volume descriptor, and may need 747 * to change the device blocksize, so release the buffer now. 748 */ 749 brelse(pri_bh); 750 brelse(bh); 751 752 /* 753 * Force the blocksize to 512 for 512 byte sectors. The file 754 * read primitives really get it wrong in a bad way if we don't 755 * do this. 756 * 757 * Note - we should never be setting the blocksize to something 758 * less than the hardware sector size for the device. If we 759 * do, we would end up having to read larger buffers and split 760 * out portions to satisfy requests. 761 * 762 * Note2- the idea here is that we want to deal with the optimal 763 * zonesize in the filesystem. If we have it set to something less, 764 * then we have horrible problems with trying to piece together 765 * bits of adjacent blocks in order to properly read directory 766 * entries. By forcing the blocksize in this way, we ensure 767 * that we will never be required to do this. 768 */ 769 sb_set_blocksize(s, orig_zonesize); 770 771 sbi->s_nls_iocharset = NULL; 772 773 #ifdef CONFIG_JOLIET 774 if (joliet_level && opt.utf8 == 0) { 775 char * p = opt.iocharset ? opt.iocharset : CONFIG_NLS_DEFAULT; 776 sbi->s_nls_iocharset = load_nls(p); 777 if (! sbi->s_nls_iocharset) { 778 /* Fail only if explicit charset specified */ 779 if (opt.iocharset) 780 goto out_freesbi; 781 sbi->s_nls_iocharset = load_nls_default(); 782 } 783 } 784 #endif 785 s->s_op = &isofs_sops; 786 s->s_export_op = &isofs_export_ops; 787 sbi->s_mapping = opt.map; 788 sbi->s_rock = (opt.rock == 'y' ? 2 : 0); 789 sbi->s_rock_offset = -1; /* initial offset, will guess until SP is found*/ 790 sbi->s_cruft = opt.cruft; 791 sbi->s_hide = opt.hide; 792 sbi->s_showassoc = opt.showassoc; 793 sbi->s_uid = opt.uid; 794 sbi->s_gid = opt.gid; 795 sbi->s_utf8 = opt.utf8; 796 sbi->s_nocompress = opt.nocompress; 797 /* 798 * It would be incredibly stupid to allow people to mark every file 799 * on the disk as suid, so we merely allow them to set the default 800 * permissions. 801 */ 802 sbi->s_mode = opt.mode & 0777; 803 804 /* 805 * Read the root inode, which _may_ result in changing 806 * the s_rock flag. Once we have the final s_rock value, 807 * we then decide whether to use the Joliet descriptor. 808 */ 809 inode = isofs_iget(s, sbi->s_firstdatazone, 0); 810 811 /* 812 * If this disk has both Rock Ridge and Joliet on it, then we 813 * want to use Rock Ridge by default. This can be overridden 814 * by using the norock mount option. There is still one other 815 * possibility that is not taken into account: a Rock Ridge 816 * CD with Unicode names. Until someone sees such a beast, it 817 * will not be supported. 818 */ 819 if (sbi->s_rock == 1) { 820 joliet_level = 0; 821 } else if (joliet_level) { 822 sbi->s_rock = 0; 823 if (sbi->s_firstdatazone != first_data_zone) { 824 sbi->s_firstdatazone = first_data_zone; 825 printk(KERN_DEBUG 826 "ISOFS: changing to secondary root\n"); 827 iput(inode); 828 inode = isofs_iget(s, sbi->s_firstdatazone, 0); 829 } 830 } 831 832 if (opt.check == 'u') { 833 /* Only Joliet is case insensitive by default */ 834 if (joliet_level) opt.check = 'r'; 835 else opt.check = 's'; 836 } 837 sbi->s_joliet_level = joliet_level; 838 839 /* check the root inode */ 840 if (!inode) 841 goto out_no_root; 842 if (!inode->i_op) 843 goto out_bad_root; 844 /* get the root dentry */ 845 s->s_root = d_alloc_root(inode); 846 if (!(s->s_root)) 847 goto out_no_root; 848 849 table = 0; 850 if (joliet_level) table += 2; 851 if (opt.check == 'r') table++; 852 s->s_root->d_op = &isofs_dentry_ops[table]; 853 854 kfree(opt.iocharset); 855 856 return 0; 857 858 /* 859 * Display error messages and free resources. 860 */ 861 out_bad_root: 862 printk(KERN_WARNING "isofs_fill_super: root inode not initialized\n"); 863 goto out_iput; 864 out_no_root: 865 printk(KERN_WARNING "isofs_fill_super: get root inode failed\n"); 866 out_iput: 867 iput(inode); 868 #ifdef CONFIG_JOLIET 869 if (sbi->s_nls_iocharset) 870 unload_nls(sbi->s_nls_iocharset); 871 #endif 872 goto out_freesbi; 873 out_no_read: 874 printk(KERN_WARNING "isofs_fill_super: " 875 "bread failed, dev=%s, iso_blknum=%d, block=%d\n", 876 s->s_id, iso_blknum, block); 877 goto out_freesbi; 878 out_bad_zone_size: 879 printk(KERN_WARNING "Bad logical zone size %ld\n", 880 sbi->s_log_zone_size); 881 goto out_freebh; 882 out_bad_size: 883 printk(KERN_WARNING "Logical zone size(%d) < hardware blocksize(%u)\n", 884 orig_zonesize, opt.blocksize); 885 goto out_freebh; 886 out_unknown_format: 887 if (!silent) 888 printk(KERN_WARNING "Unable to identify CD-ROM format.\n"); 889 890 out_freebh: 891 brelse(bh); 892 out_freesbi: 893 kfree(opt.iocharset); 894 kfree(sbi); 895 s->s_fs_info = NULL; 896 return -EINVAL; 897 } 898 899 static int isofs_statfs (struct dentry *dentry, struct kstatfs *buf) 900 { 901 struct super_block *sb = dentry->d_sb; 902 903 buf->f_type = ISOFS_SUPER_MAGIC; 904 buf->f_bsize = sb->s_blocksize; 905 buf->f_blocks = (ISOFS_SB(sb)->s_nzones 906 << (ISOFS_SB(sb)->s_log_zone_size - sb->s_blocksize_bits)); 907 buf->f_bfree = 0; 908 buf->f_bavail = 0; 909 buf->f_files = ISOFS_SB(sb)->s_ninodes; 910 buf->f_ffree = 0; 911 buf->f_namelen = NAME_MAX; 912 return 0; 913 } 914 915 /* 916 * Get a set of blocks; filling in buffer_heads if already allocated 917 * or getblk() if they are not. Returns the number of blocks inserted 918 * (0 == error.) 919 */ 920 int isofs_get_blocks(struct inode *inode, sector_t iblock_s, 921 struct buffer_head **bh, unsigned long nblocks) 922 { 923 unsigned long b_off; 924 unsigned offset, sect_size; 925 unsigned int firstext; 926 unsigned long nextblk, nextoff; 927 long iblock = (long)iblock_s; 928 int section, rv; 929 struct iso_inode_info *ei = ISOFS_I(inode); 930 931 lock_kernel(); 932 933 rv = 0; 934 if (iblock < 0 || iblock != iblock_s) { 935 printk("isofs_get_blocks: block number too large\n"); 936 goto abort; 937 } 938 939 b_off = iblock; 940 941 offset = 0; 942 firstext = ei->i_first_extent; 943 sect_size = ei->i_section_size >> ISOFS_BUFFER_BITS(inode); 944 nextblk = ei->i_next_section_block; 945 nextoff = ei->i_next_section_offset; 946 section = 0; 947 948 while ( nblocks ) { 949 /* If we are *way* beyond the end of the file, print a message. 950 * Access beyond the end of the file up to the next page boundary 951 * is normal, however because of the way the page cache works. 952 * In this case, we just return 0 so that we can properly fill 953 * the page with useless information without generating any 954 * I/O errors. 955 */ 956 if (b_off > ((inode->i_size + PAGE_CACHE_SIZE - 1) >> ISOFS_BUFFER_BITS(inode))) { 957 printk("isofs_get_blocks: block >= EOF (%ld, %ld)\n", 958 iblock, (unsigned long) inode->i_size); 959 goto abort; 960 } 961 962 /* On the last section, nextblk == 0, section size is likely to 963 * exceed sect_size by a partial block, and access beyond the 964 * end of the file will reach beyond the section size, too. 965 */ 966 while (nextblk && (b_off >= (offset + sect_size))) { 967 struct inode *ninode; 968 969 offset += sect_size; 970 ninode = isofs_iget(inode->i_sb, nextblk, nextoff); 971 if (!ninode) 972 goto abort; 973 firstext = ISOFS_I(ninode)->i_first_extent; 974 sect_size = ISOFS_I(ninode)->i_section_size >> ISOFS_BUFFER_BITS(ninode); 975 nextblk = ISOFS_I(ninode)->i_next_section_block; 976 nextoff = ISOFS_I(ninode)->i_next_section_offset; 977 iput(ninode); 978 979 if (++section > 100) { 980 printk("isofs_get_blocks: More than 100 file sections ?!?, aborting...\n"); 981 printk("isofs_get_blocks: block=%ld firstext=%u sect_size=%u " 982 "nextblk=%lu nextoff=%lu\n", 983 iblock, firstext, (unsigned) sect_size, 984 nextblk, nextoff); 985 goto abort; 986 } 987 } 988 989 if ( *bh ) { 990 map_bh(*bh, inode->i_sb, firstext + b_off - offset); 991 } else { 992 *bh = sb_getblk(inode->i_sb, firstext+b_off-offset); 993 if ( !*bh ) 994 goto abort; 995 } 996 bh++; /* Next buffer head */ 997 b_off++; /* Next buffer offset */ 998 nblocks--; 999 rv++; 1000 } 1001 1002 abort: 1003 unlock_kernel(); 1004 return rv; 1005 } 1006 1007 /* 1008 * Used by the standard interfaces. 1009 */ 1010 static int isofs_get_block(struct inode *inode, sector_t iblock, 1011 struct buffer_head *bh_result, int create) 1012 { 1013 if (create) { 1014 printk("isofs_get_block: Kernel tries to allocate a block\n"); 1015 return -EROFS; 1016 } 1017 1018 return isofs_get_blocks(inode, iblock, &bh_result, 1) ? 0 : -EIO; 1019 } 1020 1021 static int isofs_bmap(struct inode *inode, sector_t block) 1022 { 1023 struct buffer_head dummy; 1024 int error; 1025 1026 dummy.b_state = 0; 1027 dummy.b_blocknr = -1000; 1028 error = isofs_get_block(inode, block, &dummy, 0); 1029 if (!error) 1030 return dummy.b_blocknr; 1031 return 0; 1032 } 1033 1034 struct buffer_head *isofs_bread(struct inode *inode, sector_t block) 1035 { 1036 sector_t blknr = isofs_bmap(inode, block); 1037 if (!blknr) 1038 return NULL; 1039 return sb_bread(inode->i_sb, blknr); 1040 } 1041 1042 static int isofs_readpage(struct file *file, struct page *page) 1043 { 1044 return block_read_full_page(page,isofs_get_block); 1045 } 1046 1047 static sector_t _isofs_bmap(struct address_space *mapping, sector_t block) 1048 { 1049 return generic_block_bmap(mapping,block,isofs_get_block); 1050 } 1051 1052 static const struct address_space_operations isofs_aops = { 1053 .readpage = isofs_readpage, 1054 .sync_page = block_sync_page, 1055 .bmap = _isofs_bmap 1056 }; 1057 1058 static inline void test_and_set_uid(uid_t *p, uid_t value) 1059 { 1060 if (value) 1061 *p = value; 1062 } 1063 1064 static inline void test_and_set_gid(gid_t *p, gid_t value) 1065 { 1066 if (value) 1067 *p = value; 1068 } 1069 1070 static int isofs_read_level3_size(struct inode *inode) 1071 { 1072 unsigned long bufsize = ISOFS_BUFFER_SIZE(inode); 1073 int high_sierra = ISOFS_SB(inode->i_sb)->s_high_sierra; 1074 struct buffer_head * bh = NULL; 1075 unsigned long block, offset, block_saved, offset_saved; 1076 int i = 0; 1077 int more_entries = 0; 1078 struct iso_directory_record * tmpde = NULL; 1079 struct iso_inode_info *ei = ISOFS_I(inode); 1080 1081 inode->i_size = 0; 1082 1083 /* The first 16 blocks are reserved as the System Area. Thus, 1084 * no inodes can appear in block 0. We use this to flag that 1085 * this is the last section. */ 1086 ei->i_next_section_block = 0; 1087 ei->i_next_section_offset = 0; 1088 1089 block = ei->i_iget5_block; 1090 offset = ei->i_iget5_offset; 1091 1092 do { 1093 struct iso_directory_record * de; 1094 unsigned int de_len; 1095 1096 if (!bh) { 1097 bh = sb_bread(inode->i_sb, block); 1098 if (!bh) 1099 goto out_noread; 1100 } 1101 de = (struct iso_directory_record *) (bh->b_data + offset); 1102 de_len = *(unsigned char *) de; 1103 1104 if (de_len == 0) { 1105 brelse(bh); 1106 bh = NULL; 1107 ++block; 1108 offset = 0; 1109 continue; 1110 } 1111 1112 block_saved = block; 1113 offset_saved = offset; 1114 offset += de_len; 1115 1116 /* Make sure we have a full directory entry */ 1117 if (offset >= bufsize) { 1118 int slop = bufsize - offset + de_len; 1119 if (!tmpde) { 1120 tmpde = kmalloc(256, GFP_KERNEL); 1121 if (!tmpde) 1122 goto out_nomem; 1123 } 1124 memcpy(tmpde, de, slop); 1125 offset &= bufsize - 1; 1126 block++; 1127 brelse(bh); 1128 bh = NULL; 1129 if (offset) { 1130 bh = sb_bread(inode->i_sb, block); 1131 if (!bh) 1132 goto out_noread; 1133 memcpy((void *)tmpde+slop, bh->b_data, offset); 1134 } 1135 de = tmpde; 1136 } 1137 1138 inode->i_size += isonum_733(de->size); 1139 if (i == 1) { 1140 ei->i_next_section_block = block_saved; 1141 ei->i_next_section_offset = offset_saved; 1142 } 1143 1144 more_entries = de->flags[-high_sierra] & 0x80; 1145 1146 i++; 1147 if (i > 100) 1148 goto out_toomany; 1149 } while (more_entries); 1150 out: 1151 kfree(tmpde); 1152 if (bh) 1153 brelse(bh); 1154 return 0; 1155 1156 out_nomem: 1157 if (bh) 1158 brelse(bh); 1159 return -ENOMEM; 1160 1161 out_noread: 1162 printk(KERN_INFO "ISOFS: unable to read i-node block %lu\n", block); 1163 kfree(tmpde); 1164 return -EIO; 1165 1166 out_toomany: 1167 printk(KERN_INFO "isofs_read_level3_size: " 1168 "More than 100 file sections ?!?, aborting...\n" 1169 "isofs_read_level3_size: inode=%lu\n", 1170 inode->i_ino); 1171 goto out; 1172 } 1173 1174 static void isofs_read_inode(struct inode *inode) 1175 { 1176 struct super_block *sb = inode->i_sb; 1177 struct isofs_sb_info *sbi = ISOFS_SB(sb); 1178 unsigned long bufsize = ISOFS_BUFFER_SIZE(inode); 1179 unsigned long block; 1180 int high_sierra = sbi->s_high_sierra; 1181 struct buffer_head * bh = NULL; 1182 struct iso_directory_record * de; 1183 struct iso_directory_record * tmpde = NULL; 1184 unsigned int de_len; 1185 unsigned long offset; 1186 struct iso_inode_info *ei = ISOFS_I(inode); 1187 1188 block = ei->i_iget5_block; 1189 bh = sb_bread(inode->i_sb, block); 1190 if (!bh) 1191 goto out_badread; 1192 1193 offset = ei->i_iget5_offset; 1194 1195 de = (struct iso_directory_record *) (bh->b_data + offset); 1196 de_len = *(unsigned char *) de; 1197 1198 if (offset + de_len > bufsize) { 1199 int frag1 = bufsize - offset; 1200 1201 tmpde = kmalloc(de_len, GFP_KERNEL); 1202 if (tmpde == NULL) { 1203 printk(KERN_INFO "isofs_read_inode: out of memory\n"); 1204 goto fail; 1205 } 1206 memcpy(tmpde, bh->b_data + offset, frag1); 1207 brelse(bh); 1208 bh = sb_bread(inode->i_sb, ++block); 1209 if (!bh) 1210 goto out_badread; 1211 memcpy((char *)tmpde+frag1, bh->b_data, de_len - frag1); 1212 de = tmpde; 1213 } 1214 1215 inode->i_ino = isofs_get_ino(ei->i_iget5_block, 1216 ei->i_iget5_offset, 1217 ISOFS_BUFFER_BITS(inode)); 1218 1219 /* Assume it is a normal-format file unless told otherwise */ 1220 ei->i_file_format = isofs_file_normal; 1221 1222 if (de->flags[-high_sierra] & 2) { 1223 inode->i_mode = S_IRUGO | S_IXUGO | S_IFDIR; 1224 inode->i_nlink = 1; /* Set to 1. We know there are 2, but 1225 the find utility tries to optimize 1226 if it is 2, and it screws up. It is 1227 easier to give 1 which tells find to 1228 do it the hard way. */ 1229 } else { 1230 /* Everybody gets to read the file. */ 1231 inode->i_mode = sbi->s_mode; 1232 inode->i_nlink = 1; 1233 inode->i_mode |= S_IFREG; 1234 } 1235 inode->i_uid = sbi->s_uid; 1236 inode->i_gid = sbi->s_gid; 1237 inode->i_blocks = 0; 1238 1239 ei->i_format_parm[0] = 0; 1240 ei->i_format_parm[1] = 0; 1241 ei->i_format_parm[2] = 0; 1242 1243 ei->i_section_size = isonum_733 (de->size); 1244 if (de->flags[-high_sierra] & 0x80) { 1245 if(isofs_read_level3_size(inode)) goto fail; 1246 } else { 1247 ei->i_next_section_block = 0; 1248 ei->i_next_section_offset = 0; 1249 inode->i_size = isonum_733 (de->size); 1250 } 1251 1252 /* 1253 * Some dipshit decided to store some other bit of information 1254 * in the high byte of the file length. Truncate size in case 1255 * this CDROM was mounted with the cruft option. 1256 */ 1257 1258 if (sbi->s_cruft == 'y') 1259 inode->i_size &= 0x00ffffff; 1260 1261 if (de->interleave[0]) { 1262 printk("Interleaved files not (yet) supported.\n"); 1263 inode->i_size = 0; 1264 } 1265 1266 /* I have no idea what file_unit_size is used for, so 1267 we will flag it for now */ 1268 if (de->file_unit_size[0] != 0) { 1269 printk("File unit size != 0 for ISO file (%ld).\n", 1270 inode->i_ino); 1271 } 1272 1273 /* I have no idea what other flag bits are used for, so 1274 we will flag it for now */ 1275 #ifdef DEBUG 1276 if((de->flags[-high_sierra] & ~2)!= 0){ 1277 printk("Unusual flag settings for ISO file (%ld %x).\n", 1278 inode->i_ino, de->flags[-high_sierra]); 1279 } 1280 #endif 1281 1282 inode->i_mtime.tv_sec = 1283 inode->i_atime.tv_sec = 1284 inode->i_ctime.tv_sec = iso_date(de->date, high_sierra); 1285 inode->i_mtime.tv_nsec = 1286 inode->i_atime.tv_nsec = 1287 inode->i_ctime.tv_nsec = 0; 1288 1289 ei->i_first_extent = (isonum_733 (de->extent) + 1290 isonum_711 (de->ext_attr_length)); 1291 1292 /* Set the number of blocks for stat() - should be done before RR */ 1293 inode->i_blocks = (inode->i_size + 511) >> 9; 1294 1295 /* 1296 * Now test for possible Rock Ridge extensions which will override 1297 * some of these numbers in the inode structure. 1298 */ 1299 1300 if (!high_sierra) { 1301 parse_rock_ridge_inode(de, inode); 1302 /* if we want uid/gid set, override the rock ridge setting */ 1303 test_and_set_uid(&inode->i_uid, sbi->s_uid); 1304 test_and_set_gid(&inode->i_gid, sbi->s_gid); 1305 } 1306 1307 /* Install the inode operations vector */ 1308 if (S_ISREG(inode->i_mode)) { 1309 inode->i_fop = &generic_ro_fops; 1310 switch ( ei->i_file_format ) { 1311 #ifdef CONFIG_ZISOFS 1312 case isofs_file_compressed: 1313 inode->i_data.a_ops = &zisofs_aops; 1314 break; 1315 #endif 1316 default: 1317 inode->i_data.a_ops = &isofs_aops; 1318 break; 1319 } 1320 } else if (S_ISDIR(inode->i_mode)) { 1321 inode->i_op = &isofs_dir_inode_operations; 1322 inode->i_fop = &isofs_dir_operations; 1323 } else if (S_ISLNK(inode->i_mode)) { 1324 inode->i_op = &page_symlink_inode_operations; 1325 inode->i_data.a_ops = &isofs_symlink_aops; 1326 } else 1327 /* XXX - parse_rock_ridge_inode() had already set i_rdev. */ 1328 init_special_inode(inode, inode->i_mode, inode->i_rdev); 1329 1330 out: 1331 kfree(tmpde); 1332 if (bh) 1333 brelse(bh); 1334 return; 1335 1336 out_badread: 1337 printk(KERN_WARNING "ISOFS: unable to read i-node block\n"); 1338 fail: 1339 make_bad_inode(inode); 1340 goto out; 1341 } 1342 1343 struct isofs_iget5_callback_data { 1344 unsigned long block; 1345 unsigned long offset; 1346 }; 1347 1348 static int isofs_iget5_test(struct inode *ino, void *data) 1349 { 1350 struct iso_inode_info *i = ISOFS_I(ino); 1351 struct isofs_iget5_callback_data *d = 1352 (struct isofs_iget5_callback_data*)data; 1353 return (i->i_iget5_block == d->block) 1354 && (i->i_iget5_offset == d->offset); 1355 } 1356 1357 static int isofs_iget5_set(struct inode *ino, void *data) 1358 { 1359 struct iso_inode_info *i = ISOFS_I(ino); 1360 struct isofs_iget5_callback_data *d = 1361 (struct isofs_iget5_callback_data*)data; 1362 i->i_iget5_block = d->block; 1363 i->i_iget5_offset = d->offset; 1364 return 0; 1365 } 1366 1367 /* Store, in the inode's containing structure, the block and block 1368 * offset that point to the underlying meta-data for the inode. The 1369 * code below is otherwise similar to the iget() code in 1370 * include/linux/fs.h */ 1371 struct inode *isofs_iget(struct super_block *sb, 1372 unsigned long block, 1373 unsigned long offset) 1374 { 1375 unsigned long hashval; 1376 struct inode *inode; 1377 struct isofs_iget5_callback_data data; 1378 1379 if (offset >= 1ul << sb->s_blocksize_bits) 1380 return NULL; 1381 1382 data.block = block; 1383 data.offset = offset; 1384 1385 hashval = (block << sb->s_blocksize_bits) | offset; 1386 1387 inode = iget5_locked(sb, hashval, &isofs_iget5_test, 1388 &isofs_iget5_set, &data); 1389 1390 if (inode && (inode->i_state & I_NEW)) { 1391 sb->s_op->read_inode(inode); 1392 unlock_new_inode(inode); 1393 } 1394 1395 return inode; 1396 } 1397 1398 static int isofs_get_sb(struct file_system_type *fs_type, 1399 int flags, const char *dev_name, void *data, struct vfsmount *mnt) 1400 { 1401 return get_sb_bdev(fs_type, flags, dev_name, data, isofs_fill_super, 1402 mnt); 1403 } 1404 1405 static struct file_system_type iso9660_fs_type = { 1406 .owner = THIS_MODULE, 1407 .name = "iso9660", 1408 .get_sb = isofs_get_sb, 1409 .kill_sb = kill_block_super, 1410 .fs_flags = FS_REQUIRES_DEV, 1411 }; 1412 1413 static int __init init_iso9660_fs(void) 1414 { 1415 int err = init_inodecache(); 1416 if (err) 1417 goto out; 1418 #ifdef CONFIG_ZISOFS 1419 err = zisofs_init(); 1420 if (err) 1421 goto out1; 1422 #endif 1423 err = register_filesystem(&iso9660_fs_type); 1424 if (err) 1425 goto out2; 1426 return 0; 1427 out2: 1428 #ifdef CONFIG_ZISOFS 1429 zisofs_cleanup(); 1430 out1: 1431 #endif 1432 destroy_inodecache(); 1433 out: 1434 return err; 1435 } 1436 1437 static void __exit exit_iso9660_fs(void) 1438 { 1439 unregister_filesystem(&iso9660_fs_type); 1440 #ifdef CONFIG_ZISOFS 1441 zisofs_cleanup(); 1442 #endif 1443 destroy_inodecache(); 1444 } 1445 1446 module_init(init_iso9660_fs) 1447 module_exit(exit_iso9660_fs) 1448 MODULE_LICENSE("GPL"); 1449 /* Actual filesystem name is iso9660, as requested in filesystems.c */ 1450 MODULE_ALIAS("iso9660"); 1451