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