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