1 /* 2 * super.c 3 * 4 * PURPOSE 5 * Super block routines for the OSTA-UDF(tm) filesystem. 6 * 7 * DESCRIPTION 8 * OSTA-UDF(tm) = Optical Storage Technology Association 9 * Universal Disk Format. 10 * 11 * This code is based on version 2.00 of the UDF specification, 12 * and revision 3 of the ECMA 167 standard [equivalent to ISO 13346]. 13 * http://www.osta.org/ 14 * http://www.ecma.ch/ 15 * http://www.iso.org/ 16 * 17 * COPYRIGHT 18 * This file is distributed under the terms of the GNU General Public 19 * License (GPL). Copies of the GPL can be obtained from: 20 * ftp://prep.ai.mit.edu/pub/gnu/GPL 21 * Each contributing author retains all rights to their own work. 22 * 23 * (C) 1998 Dave Boynton 24 * (C) 1998-2004 Ben Fennema 25 * (C) 2000 Stelias Computing Inc 26 * 27 * HISTORY 28 * 29 * 09/24/98 dgb changed to allow compiling outside of kernel, and 30 * added some debugging. 31 * 10/01/98 dgb updated to allow (some) possibility of compiling w/2.0.34 32 * 10/16/98 attempting some multi-session support 33 * 10/17/98 added freespace count for "df" 34 * 11/11/98 gr added novrs option 35 * 11/26/98 dgb added fileset,anchor mount options 36 * 12/06/98 blf really hosed things royally. vat/sparing support. sequenced 37 * vol descs. rewrote option handling based on isofs 38 * 12/20/98 find the free space bitmap (if it exists) 39 */ 40 41 #include "udfdecl.h" 42 43 #include <linux/blkdev.h> 44 #include <linux/slab.h> 45 #include <linux/kernel.h> 46 #include <linux/module.h> 47 #include <linux/parser.h> 48 #include <linux/stat.h> 49 #include <linux/cdrom.h> 50 #include <linux/nls.h> 51 #include <linux/smp_lock.h> 52 #include <linux/buffer_head.h> 53 #include <linux/vfs.h> 54 #include <linux/vmalloc.h> 55 #include <linux/errno.h> 56 #include <linux/mount.h> 57 #include <linux/seq_file.h> 58 #include <linux/bitmap.h> 59 #include <asm/byteorder.h> 60 61 #include "udf_sb.h" 62 #include "udf_i.h" 63 64 #include <linux/init.h> 65 #include <asm/uaccess.h> 66 67 #define VDS_POS_PRIMARY_VOL_DESC 0 68 #define VDS_POS_UNALLOC_SPACE_DESC 1 69 #define VDS_POS_LOGICAL_VOL_DESC 2 70 #define VDS_POS_PARTITION_DESC 3 71 #define VDS_POS_IMP_USE_VOL_DESC 4 72 #define VDS_POS_VOL_DESC_PTR 5 73 #define VDS_POS_TERMINATING_DESC 6 74 #define VDS_POS_LENGTH 7 75 76 #define UDF_DEFAULT_BLOCKSIZE 2048 77 78 static char error_buf[1024]; 79 80 /* These are the "meat" - everything else is stuffing */ 81 static int udf_fill_super(struct super_block *, void *, int); 82 static void udf_put_super(struct super_block *); 83 static void udf_write_super(struct super_block *); 84 static int udf_remount_fs(struct super_block *, int *, char *); 85 static int udf_check_valid(struct super_block *, int, int); 86 static int udf_vrs(struct super_block *sb, int silent); 87 static int udf_load_partition(struct super_block *, kernel_lb_addr *); 88 static int udf_load_logicalvol(struct super_block *, struct buffer_head *, 89 kernel_lb_addr *); 90 static void udf_load_logicalvolint(struct super_block *, kernel_extent_ad); 91 static void udf_find_anchor(struct super_block *); 92 static int udf_find_fileset(struct super_block *, kernel_lb_addr *, 93 kernel_lb_addr *); 94 static void udf_load_pvoldesc(struct super_block *, struct buffer_head *); 95 static void udf_load_fileset(struct super_block *, struct buffer_head *, 96 kernel_lb_addr *); 97 static int udf_load_partdesc(struct super_block *, struct buffer_head *); 98 static void udf_open_lvid(struct super_block *); 99 static void udf_close_lvid(struct super_block *); 100 static unsigned int udf_count_free(struct super_block *); 101 static int udf_statfs(struct dentry *, struct kstatfs *); 102 static int udf_show_options(struct seq_file *, struct vfsmount *); 103 static void udf_error(struct super_block *sb, const char *function, 104 const char *fmt, ...); 105 106 struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu(struct udf_sb_info *sbi) 107 { 108 struct logicalVolIntegrityDesc *lvid = 109 (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data; 110 __u32 number_of_partitions = le32_to_cpu(lvid->numOfPartitions); 111 __u32 offset = number_of_partitions * 2 * 112 sizeof(uint32_t)/sizeof(uint8_t); 113 return (struct logicalVolIntegrityDescImpUse *)&(lvid->impUse[offset]); 114 } 115 116 /* UDF filesystem type */ 117 static int udf_get_sb(struct file_system_type *fs_type, 118 int flags, const char *dev_name, void *data, 119 struct vfsmount *mnt) 120 { 121 return get_sb_bdev(fs_type, flags, dev_name, data, udf_fill_super, mnt); 122 } 123 124 static struct file_system_type udf_fstype = { 125 .owner = THIS_MODULE, 126 .name = "udf", 127 .get_sb = udf_get_sb, 128 .kill_sb = kill_block_super, 129 .fs_flags = FS_REQUIRES_DEV, 130 }; 131 132 static struct kmem_cache *udf_inode_cachep; 133 134 static struct inode *udf_alloc_inode(struct super_block *sb) 135 { 136 struct udf_inode_info *ei; 137 ei = kmem_cache_alloc(udf_inode_cachep, GFP_KERNEL); 138 if (!ei) 139 return NULL; 140 141 ei->i_unique = 0; 142 ei->i_lenExtents = 0; 143 ei->i_next_alloc_block = 0; 144 ei->i_next_alloc_goal = 0; 145 ei->i_strat4096 = 0; 146 147 return &ei->vfs_inode; 148 } 149 150 static void udf_destroy_inode(struct inode *inode) 151 { 152 kmem_cache_free(udf_inode_cachep, UDF_I(inode)); 153 } 154 155 static void init_once(struct kmem_cache *cachep, void *foo) 156 { 157 struct udf_inode_info *ei = (struct udf_inode_info *)foo; 158 159 ei->i_ext.i_data = NULL; 160 inode_init_once(&ei->vfs_inode); 161 } 162 163 static int init_inodecache(void) 164 { 165 udf_inode_cachep = kmem_cache_create("udf_inode_cache", 166 sizeof(struct udf_inode_info), 167 0, (SLAB_RECLAIM_ACCOUNT | 168 SLAB_MEM_SPREAD), 169 init_once); 170 if (!udf_inode_cachep) 171 return -ENOMEM; 172 return 0; 173 } 174 175 static void destroy_inodecache(void) 176 { 177 kmem_cache_destroy(udf_inode_cachep); 178 } 179 180 /* Superblock operations */ 181 static const struct super_operations udf_sb_ops = { 182 .alloc_inode = udf_alloc_inode, 183 .destroy_inode = udf_destroy_inode, 184 .write_inode = udf_write_inode, 185 .delete_inode = udf_delete_inode, 186 .clear_inode = udf_clear_inode, 187 .put_super = udf_put_super, 188 .write_super = udf_write_super, 189 .statfs = udf_statfs, 190 .remount_fs = udf_remount_fs, 191 .show_options = udf_show_options, 192 }; 193 194 struct udf_options { 195 unsigned char novrs; 196 unsigned int blocksize; 197 unsigned int session; 198 unsigned int lastblock; 199 unsigned int anchor; 200 unsigned int volume; 201 unsigned short partition; 202 unsigned int fileset; 203 unsigned int rootdir; 204 unsigned int flags; 205 mode_t umask; 206 gid_t gid; 207 uid_t uid; 208 struct nls_table *nls_map; 209 }; 210 211 static int __init init_udf_fs(void) 212 { 213 int err; 214 215 err = init_inodecache(); 216 if (err) 217 goto out1; 218 err = register_filesystem(&udf_fstype); 219 if (err) 220 goto out; 221 222 return 0; 223 224 out: 225 destroy_inodecache(); 226 227 out1: 228 return err; 229 } 230 231 static void __exit exit_udf_fs(void) 232 { 233 unregister_filesystem(&udf_fstype); 234 destroy_inodecache(); 235 } 236 237 module_init(init_udf_fs) 238 module_exit(exit_udf_fs) 239 240 static int udf_sb_alloc_partition_maps(struct super_block *sb, u32 count) 241 { 242 struct udf_sb_info *sbi = UDF_SB(sb); 243 244 sbi->s_partmaps = kcalloc(count, sizeof(struct udf_part_map), 245 GFP_KERNEL); 246 if (!sbi->s_partmaps) { 247 udf_error(sb, __FUNCTION__, 248 "Unable to allocate space for %d partition maps", 249 count); 250 sbi->s_partitions = 0; 251 return -ENOMEM; 252 } 253 254 sbi->s_partitions = count; 255 return 0; 256 } 257 258 static int udf_show_options(struct seq_file *seq, struct vfsmount *mnt) 259 { 260 struct super_block *sb = mnt->mnt_sb; 261 struct udf_sb_info *sbi = UDF_SB(sb); 262 263 if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT)) 264 seq_puts(seq, ",nostrict"); 265 if (sb->s_blocksize != UDF_DEFAULT_BLOCKSIZE) 266 seq_printf(seq, ",bs=%lu", sb->s_blocksize); 267 if (UDF_QUERY_FLAG(sb, UDF_FLAG_UNHIDE)) 268 seq_puts(seq, ",unhide"); 269 if (UDF_QUERY_FLAG(sb, UDF_FLAG_UNDELETE)) 270 seq_puts(seq, ",undelete"); 271 if (!UDF_QUERY_FLAG(sb, UDF_FLAG_USE_AD_IN_ICB)) 272 seq_puts(seq, ",noadinicb"); 273 if (UDF_QUERY_FLAG(sb, UDF_FLAG_USE_SHORT_AD)) 274 seq_puts(seq, ",shortad"); 275 if (UDF_QUERY_FLAG(sb, UDF_FLAG_UID_FORGET)) 276 seq_puts(seq, ",uid=forget"); 277 if (UDF_QUERY_FLAG(sb, UDF_FLAG_UID_IGNORE)) 278 seq_puts(seq, ",uid=ignore"); 279 if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_FORGET)) 280 seq_puts(seq, ",gid=forget"); 281 if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_IGNORE)) 282 seq_puts(seq, ",gid=ignore"); 283 if (UDF_QUERY_FLAG(sb, UDF_FLAG_UID_SET)) 284 seq_printf(seq, ",uid=%u", sbi->s_uid); 285 if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_SET)) 286 seq_printf(seq, ",gid=%u", sbi->s_gid); 287 if (sbi->s_umask != 0) 288 seq_printf(seq, ",umask=%o", sbi->s_umask); 289 if (UDF_QUERY_FLAG(sb, UDF_FLAG_SESSION_SET)) 290 seq_printf(seq, ",session=%u", sbi->s_session); 291 if (UDF_QUERY_FLAG(sb, UDF_FLAG_LASTBLOCK_SET)) 292 seq_printf(seq, ",lastblock=%u", sbi->s_last_block); 293 /* 294 * s_anchor[2] could be zeroed out in case there is no anchor 295 * in the specified block, but then the "anchor=N" option 296 * originally given by the user wasn't effective, so it's OK 297 * if we don't show it. 298 */ 299 if (sbi->s_anchor[2] != 0) 300 seq_printf(seq, ",anchor=%u", sbi->s_anchor[2]); 301 /* 302 * volume, partition, fileset and rootdir seem to be ignored 303 * currently 304 */ 305 if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8)) 306 seq_puts(seq, ",utf8"); 307 if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP) && sbi->s_nls_map) 308 seq_printf(seq, ",iocharset=%s", sbi->s_nls_map->charset); 309 310 return 0; 311 } 312 313 /* 314 * udf_parse_options 315 * 316 * PURPOSE 317 * Parse mount options. 318 * 319 * DESCRIPTION 320 * The following mount options are supported: 321 * 322 * gid= Set the default group. 323 * umask= Set the default umask. 324 * uid= Set the default user. 325 * bs= Set the block size. 326 * unhide Show otherwise hidden files. 327 * undelete Show deleted files in lists. 328 * adinicb Embed data in the inode (default) 329 * noadinicb Don't embed data in the inode 330 * shortad Use short ad's 331 * longad Use long ad's (default) 332 * nostrict Unset strict conformance 333 * iocharset= Set the NLS character set 334 * 335 * The remaining are for debugging and disaster recovery: 336 * 337 * novrs Skip volume sequence recognition 338 * 339 * The following expect a offset from 0. 340 * 341 * session= Set the CDROM session (default= last session) 342 * anchor= Override standard anchor location. (default= 256) 343 * volume= Override the VolumeDesc location. (unused) 344 * partition= Override the PartitionDesc location. (unused) 345 * lastblock= Set the last block of the filesystem/ 346 * 347 * The following expect a offset from the partition root. 348 * 349 * fileset= Override the fileset block location. (unused) 350 * rootdir= Override the root directory location. (unused) 351 * WARNING: overriding the rootdir to a non-directory may 352 * yield highly unpredictable results. 353 * 354 * PRE-CONDITIONS 355 * options Pointer to mount options string. 356 * uopts Pointer to mount options variable. 357 * 358 * POST-CONDITIONS 359 * <return> 1 Mount options parsed okay. 360 * <return> 0 Error parsing mount options. 361 * 362 * HISTORY 363 * July 1, 1997 - Andrew E. Mileski 364 * Written, tested, and released. 365 */ 366 367 enum { 368 Opt_novrs, Opt_nostrict, Opt_bs, Opt_unhide, Opt_undelete, 369 Opt_noadinicb, Opt_adinicb, Opt_shortad, Opt_longad, 370 Opt_gid, Opt_uid, Opt_umask, Opt_session, Opt_lastblock, 371 Opt_anchor, Opt_volume, Opt_partition, Opt_fileset, 372 Opt_rootdir, Opt_utf8, Opt_iocharset, 373 Opt_err, Opt_uforget, Opt_uignore, Opt_gforget, Opt_gignore 374 }; 375 376 static match_table_t tokens = { 377 {Opt_novrs, "novrs"}, 378 {Opt_nostrict, "nostrict"}, 379 {Opt_bs, "bs=%u"}, 380 {Opt_unhide, "unhide"}, 381 {Opt_undelete, "undelete"}, 382 {Opt_noadinicb, "noadinicb"}, 383 {Opt_adinicb, "adinicb"}, 384 {Opt_shortad, "shortad"}, 385 {Opt_longad, "longad"}, 386 {Opt_uforget, "uid=forget"}, 387 {Opt_uignore, "uid=ignore"}, 388 {Opt_gforget, "gid=forget"}, 389 {Opt_gignore, "gid=ignore"}, 390 {Opt_gid, "gid=%u"}, 391 {Opt_uid, "uid=%u"}, 392 {Opt_umask, "umask=%o"}, 393 {Opt_session, "session=%u"}, 394 {Opt_lastblock, "lastblock=%u"}, 395 {Opt_anchor, "anchor=%u"}, 396 {Opt_volume, "volume=%u"}, 397 {Opt_partition, "partition=%u"}, 398 {Opt_fileset, "fileset=%u"}, 399 {Opt_rootdir, "rootdir=%u"}, 400 {Opt_utf8, "utf8"}, 401 {Opt_iocharset, "iocharset=%s"}, 402 {Opt_err, NULL} 403 }; 404 405 static int udf_parse_options(char *options, struct udf_options *uopt, 406 bool remount) 407 { 408 char *p; 409 int option; 410 411 uopt->novrs = 0; 412 uopt->blocksize = UDF_DEFAULT_BLOCKSIZE; 413 uopt->partition = 0xFFFF; 414 uopt->session = 0xFFFFFFFF; 415 uopt->lastblock = 0; 416 uopt->anchor = 0; 417 uopt->volume = 0xFFFFFFFF; 418 uopt->rootdir = 0xFFFFFFFF; 419 uopt->fileset = 0xFFFFFFFF; 420 uopt->nls_map = NULL; 421 422 if (!options) 423 return 1; 424 425 while ((p = strsep(&options, ",")) != NULL) { 426 substring_t args[MAX_OPT_ARGS]; 427 int token; 428 if (!*p) 429 continue; 430 431 token = match_token(p, tokens, args); 432 switch (token) { 433 case Opt_novrs: 434 uopt->novrs = 1; 435 case Opt_bs: 436 if (match_int(&args[0], &option)) 437 return 0; 438 uopt->blocksize = option; 439 break; 440 case Opt_unhide: 441 uopt->flags |= (1 << UDF_FLAG_UNHIDE); 442 break; 443 case Opt_undelete: 444 uopt->flags |= (1 << UDF_FLAG_UNDELETE); 445 break; 446 case Opt_noadinicb: 447 uopt->flags &= ~(1 << UDF_FLAG_USE_AD_IN_ICB); 448 break; 449 case Opt_adinicb: 450 uopt->flags |= (1 << UDF_FLAG_USE_AD_IN_ICB); 451 break; 452 case Opt_shortad: 453 uopt->flags |= (1 << UDF_FLAG_USE_SHORT_AD); 454 break; 455 case Opt_longad: 456 uopt->flags &= ~(1 << UDF_FLAG_USE_SHORT_AD); 457 break; 458 case Opt_gid: 459 if (match_int(args, &option)) 460 return 0; 461 uopt->gid = option; 462 uopt->flags |= (1 << UDF_FLAG_GID_SET); 463 break; 464 case Opt_uid: 465 if (match_int(args, &option)) 466 return 0; 467 uopt->uid = option; 468 uopt->flags |= (1 << UDF_FLAG_UID_SET); 469 break; 470 case Opt_umask: 471 if (match_octal(args, &option)) 472 return 0; 473 uopt->umask = option; 474 break; 475 case Opt_nostrict: 476 uopt->flags &= ~(1 << UDF_FLAG_STRICT); 477 break; 478 case Opt_session: 479 if (match_int(args, &option)) 480 return 0; 481 uopt->session = option; 482 if (!remount) 483 uopt->flags |= (1 << UDF_FLAG_SESSION_SET); 484 break; 485 case Opt_lastblock: 486 if (match_int(args, &option)) 487 return 0; 488 uopt->lastblock = option; 489 if (!remount) 490 uopt->flags |= (1 << UDF_FLAG_LASTBLOCK_SET); 491 break; 492 case Opt_anchor: 493 if (match_int(args, &option)) 494 return 0; 495 uopt->anchor = option; 496 break; 497 case Opt_volume: 498 if (match_int(args, &option)) 499 return 0; 500 uopt->volume = option; 501 break; 502 case Opt_partition: 503 if (match_int(args, &option)) 504 return 0; 505 uopt->partition = option; 506 break; 507 case Opt_fileset: 508 if (match_int(args, &option)) 509 return 0; 510 uopt->fileset = option; 511 break; 512 case Opt_rootdir: 513 if (match_int(args, &option)) 514 return 0; 515 uopt->rootdir = option; 516 break; 517 case Opt_utf8: 518 uopt->flags |= (1 << UDF_FLAG_UTF8); 519 break; 520 #ifdef CONFIG_UDF_NLS 521 case Opt_iocharset: 522 uopt->nls_map = load_nls(args[0].from); 523 uopt->flags |= (1 << UDF_FLAG_NLS_MAP); 524 break; 525 #endif 526 case Opt_uignore: 527 uopt->flags |= (1 << UDF_FLAG_UID_IGNORE); 528 break; 529 case Opt_uforget: 530 uopt->flags |= (1 << UDF_FLAG_UID_FORGET); 531 break; 532 case Opt_gignore: 533 uopt->flags |= (1 << UDF_FLAG_GID_IGNORE); 534 break; 535 case Opt_gforget: 536 uopt->flags |= (1 << UDF_FLAG_GID_FORGET); 537 break; 538 default: 539 printk(KERN_ERR "udf: bad mount option \"%s\" " 540 "or missing value\n", p); 541 return 0; 542 } 543 } 544 return 1; 545 } 546 547 static void udf_write_super(struct super_block *sb) 548 { 549 lock_kernel(); 550 551 if (!(sb->s_flags & MS_RDONLY)) 552 udf_open_lvid(sb); 553 sb->s_dirt = 0; 554 555 unlock_kernel(); 556 } 557 558 static int udf_remount_fs(struct super_block *sb, int *flags, char *options) 559 { 560 struct udf_options uopt; 561 struct udf_sb_info *sbi = UDF_SB(sb); 562 563 uopt.flags = sbi->s_flags; 564 uopt.uid = sbi->s_uid; 565 uopt.gid = sbi->s_gid; 566 uopt.umask = sbi->s_umask; 567 568 if (!udf_parse_options(options, &uopt, true)) 569 return -EINVAL; 570 571 sbi->s_flags = uopt.flags; 572 sbi->s_uid = uopt.uid; 573 sbi->s_gid = uopt.gid; 574 sbi->s_umask = uopt.umask; 575 576 if (sbi->s_lvid_bh) { 577 int write_rev = le16_to_cpu(udf_sb_lvidiu(sbi)->minUDFWriteRev); 578 if (write_rev > UDF_MAX_WRITE_VERSION) 579 *flags |= MS_RDONLY; 580 } 581 582 if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) 583 return 0; 584 if (*flags & MS_RDONLY) 585 udf_close_lvid(sb); 586 else 587 udf_open_lvid(sb); 588 589 return 0; 590 } 591 592 static int udf_vrs(struct super_block *sb, int silent) 593 { 594 struct volStructDesc *vsd = NULL; 595 int sector = 32768; 596 int sectorsize; 597 struct buffer_head *bh = NULL; 598 int iso9660 = 0; 599 int nsr02 = 0; 600 int nsr03 = 0; 601 struct udf_sb_info *sbi; 602 603 /* Block size must be a multiple of 512 */ 604 if (sb->s_blocksize & 511) 605 return 0; 606 sbi = UDF_SB(sb); 607 608 if (sb->s_blocksize < sizeof(struct volStructDesc)) 609 sectorsize = sizeof(struct volStructDesc); 610 else 611 sectorsize = sb->s_blocksize; 612 613 sector += (sbi->s_session << sb->s_blocksize_bits); 614 615 udf_debug("Starting at sector %u (%ld byte sectors)\n", 616 (sector >> sb->s_blocksize_bits), sb->s_blocksize); 617 /* Process the sequence (if applicable) */ 618 for (; !nsr02 && !nsr03; sector += sectorsize) { 619 /* Read a block */ 620 bh = udf_tread(sb, sector >> sb->s_blocksize_bits); 621 if (!bh) 622 break; 623 624 /* Look for ISO descriptors */ 625 vsd = (struct volStructDesc *)(bh->b_data + 626 (sector & (sb->s_blocksize - 1))); 627 628 if (vsd->stdIdent[0] == 0) { 629 brelse(bh); 630 break; 631 } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_CD001, 632 VSD_STD_ID_LEN)) { 633 iso9660 = sector; 634 switch (vsd->structType) { 635 case 0: 636 udf_debug("ISO9660 Boot Record found\n"); 637 break; 638 case 1: 639 udf_debug("ISO9660 Primary Volume Descriptor " 640 "found\n"); 641 break; 642 case 2: 643 udf_debug("ISO9660 Supplementary Volume " 644 "Descriptor found\n"); 645 break; 646 case 3: 647 udf_debug("ISO9660 Volume Partition Descriptor " 648 "found\n"); 649 break; 650 case 255: 651 udf_debug("ISO9660 Volume Descriptor Set " 652 "Terminator found\n"); 653 break; 654 default: 655 udf_debug("ISO9660 VRS (%u) found\n", 656 vsd->structType); 657 break; 658 } 659 } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_BEA01, 660 VSD_STD_ID_LEN)) 661 ; /* nothing */ 662 else if (!strncmp(vsd->stdIdent, VSD_STD_ID_TEA01, 663 VSD_STD_ID_LEN)) { 664 brelse(bh); 665 break; 666 } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR02, 667 VSD_STD_ID_LEN)) 668 nsr02 = sector; 669 else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR03, 670 VSD_STD_ID_LEN)) 671 nsr03 = sector; 672 brelse(bh); 673 } 674 675 if (nsr03) 676 return nsr03; 677 else if (nsr02) 678 return nsr02; 679 else if (sector - (sbi->s_session << sb->s_blocksize_bits) == 32768) 680 return -1; 681 else 682 return 0; 683 } 684 685 /* 686 * udf_find_anchor 687 * 688 * PURPOSE 689 * Find an anchor volume descriptor. 690 * 691 * PRE-CONDITIONS 692 * sb Pointer to _locked_ superblock. 693 * lastblock Last block on media. 694 * 695 * POST-CONDITIONS 696 * <return> 1 if not found, 0 if ok 697 * 698 * HISTORY 699 * July 1, 1997 - Andrew E. Mileski 700 * Written, tested, and released. 701 */ 702 static void udf_find_anchor(struct super_block *sb) 703 { 704 int lastblock; 705 struct buffer_head *bh = NULL; 706 uint16_t ident; 707 uint32_t location; 708 int i; 709 struct udf_sb_info *sbi; 710 711 sbi = UDF_SB(sb); 712 lastblock = sbi->s_last_block; 713 714 if (lastblock) { 715 int varlastblock = udf_variable_to_fixed(lastblock); 716 int last[] = { lastblock, lastblock - 2, 717 lastblock - 150, lastblock - 152, 718 varlastblock, varlastblock - 2, 719 varlastblock - 150, varlastblock - 152 }; 720 721 lastblock = 0; 722 723 /* Search for an anchor volume descriptor pointer */ 724 725 /* according to spec, anchor is in either: 726 * block 256 727 * lastblock-256 728 * lastblock 729 * however, if the disc isn't closed, it could be 512 */ 730 731 for (i = 0; !lastblock && i < ARRAY_SIZE(last); i++) { 732 ident = location = 0; 733 if (last[i] >= 0) { 734 bh = sb_bread(sb, last[i]); 735 if (bh) { 736 tag *t = (tag *)bh->b_data; 737 ident = le16_to_cpu(t->tagIdent); 738 location = le32_to_cpu(t->tagLocation); 739 brelse(bh); 740 } 741 } 742 743 if (ident == TAG_IDENT_AVDP) { 744 if (location == last[i] - sbi->s_session) { 745 lastblock = last[i] - sbi->s_session; 746 sbi->s_anchor[0] = lastblock; 747 sbi->s_anchor[1] = lastblock - 256; 748 } else if (location == 749 udf_variable_to_fixed(last[i]) - 750 sbi->s_session) { 751 UDF_SET_FLAG(sb, UDF_FLAG_VARCONV); 752 lastblock = 753 udf_variable_to_fixed(last[i]) - 754 sbi->s_session; 755 sbi->s_anchor[0] = lastblock; 756 sbi->s_anchor[1] = lastblock - 256 - 757 sbi->s_session; 758 } else { 759 udf_debug("Anchor found at block %d, " 760 "location mismatch %d.\n", 761 last[i], location); 762 } 763 } else if (ident == TAG_IDENT_FE || 764 ident == TAG_IDENT_EFE) { 765 lastblock = last[i]; 766 sbi->s_anchor[3] = 512; 767 } else { 768 ident = location = 0; 769 if (last[i] >= 256) { 770 bh = sb_bread(sb, last[i] - 256); 771 if (bh) { 772 tag *t = (tag *)bh->b_data; 773 ident = le16_to_cpu( 774 t->tagIdent); 775 location = le32_to_cpu( 776 t->tagLocation); 777 brelse(bh); 778 } 779 } 780 781 if (ident == TAG_IDENT_AVDP && 782 location == last[i] - 256 - 783 sbi->s_session) { 784 lastblock = last[i]; 785 sbi->s_anchor[1] = last[i] - 256; 786 } else { 787 ident = location = 0; 788 if (last[i] >= 312 + sbi->s_session) { 789 bh = sb_bread(sb, 790 last[i] - 312 - 791 sbi->s_session); 792 if (bh) { 793 tag *t = (tag *) 794 bh->b_data; 795 ident = le16_to_cpu( 796 t->tagIdent); 797 location = le32_to_cpu( 798 t->tagLocation); 799 brelse(bh); 800 } 801 } 802 803 if (ident == TAG_IDENT_AVDP && 804 location == udf_variable_to_fixed(last[i]) - 256) { 805 UDF_SET_FLAG(sb, 806 UDF_FLAG_VARCONV); 807 lastblock = udf_variable_to_fixed(last[i]); 808 sbi->s_anchor[1] = lastblock - 256; 809 } 810 } 811 } 812 } 813 } 814 815 if (!lastblock) { 816 /* We haven't found the lastblock. check 312 */ 817 bh = sb_bread(sb, 312 + sbi->s_session); 818 if (bh) { 819 tag *t = (tag *)bh->b_data; 820 ident = le16_to_cpu(t->tagIdent); 821 location = le32_to_cpu(t->tagLocation); 822 brelse(bh); 823 824 if (ident == TAG_IDENT_AVDP && location == 256) 825 UDF_SET_FLAG(sb, UDF_FLAG_VARCONV); 826 } 827 } 828 829 for (i = 0; i < ARRAY_SIZE(sbi->s_anchor); i++) { 830 if (sbi->s_anchor[i]) { 831 bh = udf_read_tagged(sb, sbi->s_anchor[i], 832 sbi->s_anchor[i], &ident); 833 if (!bh) 834 sbi->s_anchor[i] = 0; 835 else { 836 brelse(bh); 837 if ((ident != TAG_IDENT_AVDP) && 838 (i || (ident != TAG_IDENT_FE && 839 ident != TAG_IDENT_EFE))) 840 sbi->s_anchor[i] = 0; 841 } 842 } 843 } 844 845 sbi->s_last_block = lastblock; 846 } 847 848 static int udf_find_fileset(struct super_block *sb, 849 kernel_lb_addr *fileset, 850 kernel_lb_addr *root) 851 { 852 struct buffer_head *bh = NULL; 853 long lastblock; 854 uint16_t ident; 855 struct udf_sb_info *sbi; 856 857 if (fileset->logicalBlockNum != 0xFFFFFFFF || 858 fileset->partitionReferenceNum != 0xFFFF) { 859 bh = udf_read_ptagged(sb, *fileset, 0, &ident); 860 861 if (!bh) { 862 return 1; 863 } else if (ident != TAG_IDENT_FSD) { 864 brelse(bh); 865 return 1; 866 } 867 868 } 869 870 sbi = UDF_SB(sb); 871 if (!bh) { 872 /* Search backwards through the partitions */ 873 kernel_lb_addr newfileset; 874 875 /* --> cvg: FIXME - is it reasonable? */ 876 return 1; 877 878 for (newfileset.partitionReferenceNum = sbi->s_partitions - 1; 879 (newfileset.partitionReferenceNum != 0xFFFF && 880 fileset->logicalBlockNum == 0xFFFFFFFF && 881 fileset->partitionReferenceNum == 0xFFFF); 882 newfileset.partitionReferenceNum--) { 883 lastblock = sbi->s_partmaps 884 [newfileset.partitionReferenceNum] 885 .s_partition_len; 886 newfileset.logicalBlockNum = 0; 887 888 do { 889 bh = udf_read_ptagged(sb, newfileset, 0, 890 &ident); 891 if (!bh) { 892 newfileset.logicalBlockNum++; 893 continue; 894 } 895 896 switch (ident) { 897 case TAG_IDENT_SBD: 898 { 899 struct spaceBitmapDesc *sp; 900 sp = (struct spaceBitmapDesc *) 901 bh->b_data; 902 newfileset.logicalBlockNum += 1 + 903 ((le32_to_cpu(sp->numOfBytes) + 904 sizeof(struct spaceBitmapDesc) 905 - 1) >> sb->s_blocksize_bits); 906 brelse(bh); 907 break; 908 } 909 case TAG_IDENT_FSD: 910 *fileset = newfileset; 911 break; 912 default: 913 newfileset.logicalBlockNum++; 914 brelse(bh); 915 bh = NULL; 916 break; 917 } 918 } while (newfileset.logicalBlockNum < lastblock && 919 fileset->logicalBlockNum == 0xFFFFFFFF && 920 fileset->partitionReferenceNum == 0xFFFF); 921 } 922 } 923 924 if ((fileset->logicalBlockNum != 0xFFFFFFFF || 925 fileset->partitionReferenceNum != 0xFFFF) && bh) { 926 udf_debug("Fileset at block=%d, partition=%d\n", 927 fileset->logicalBlockNum, 928 fileset->partitionReferenceNum); 929 930 sbi->s_partition = fileset->partitionReferenceNum; 931 udf_load_fileset(sb, bh, root); 932 brelse(bh); 933 return 0; 934 } 935 return 1; 936 } 937 938 static void udf_load_pvoldesc(struct super_block *sb, struct buffer_head *bh) 939 { 940 struct primaryVolDesc *pvoldesc; 941 time_t recording; 942 long recording_usec; 943 struct ustr instr; 944 struct ustr outstr; 945 946 pvoldesc = (struct primaryVolDesc *)bh->b_data; 947 948 if (udf_stamp_to_time(&recording, &recording_usec, 949 lets_to_cpu(pvoldesc->recordingDateAndTime))) { 950 kernel_timestamp ts; 951 ts = lets_to_cpu(pvoldesc->recordingDateAndTime); 952 udf_debug("recording time %ld/%ld, %04u/%02u/%02u" 953 " %02u:%02u (%x)\n", 954 recording, recording_usec, 955 ts.year, ts.month, ts.day, ts.hour, 956 ts.minute, ts.typeAndTimezone); 957 UDF_SB(sb)->s_record_time.tv_sec = recording; 958 UDF_SB(sb)->s_record_time.tv_nsec = recording_usec * 1000; 959 } 960 961 if (!udf_build_ustr(&instr, pvoldesc->volIdent, 32)) 962 if (udf_CS0toUTF8(&outstr, &instr)) { 963 strncpy(UDF_SB(sb)->s_volume_ident, outstr.u_name, 964 outstr.u_len > 31 ? 31 : outstr.u_len); 965 udf_debug("volIdent[] = '%s'\n", 966 UDF_SB(sb)->s_volume_ident); 967 } 968 969 if (!udf_build_ustr(&instr, pvoldesc->volSetIdent, 128)) 970 if (udf_CS0toUTF8(&outstr, &instr)) 971 udf_debug("volSetIdent[] = '%s'\n", outstr.u_name); 972 } 973 974 static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh, 975 kernel_lb_addr *root) 976 { 977 struct fileSetDesc *fset; 978 979 fset = (struct fileSetDesc *)bh->b_data; 980 981 *root = lelb_to_cpu(fset->rootDirectoryICB.extLocation); 982 983 UDF_SB(sb)->s_serial_number = le16_to_cpu(fset->descTag.tagSerialNum); 984 985 udf_debug("Rootdir at block=%d, partition=%d\n", 986 root->logicalBlockNum, root->partitionReferenceNum); 987 } 988 989 int udf_compute_nr_groups(struct super_block *sb, u32 partition) 990 { 991 struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition]; 992 return DIV_ROUND_UP(map->s_partition_len + 993 (sizeof(struct spaceBitmapDesc) << 3), 994 sb->s_blocksize * 8); 995 } 996 997 static struct udf_bitmap *udf_sb_alloc_bitmap(struct super_block *sb, u32 index) 998 { 999 struct udf_bitmap *bitmap; 1000 int nr_groups; 1001 int size; 1002 1003 nr_groups = udf_compute_nr_groups(sb, index); 1004 size = sizeof(struct udf_bitmap) + 1005 (sizeof(struct buffer_head *) * nr_groups); 1006 1007 if (size <= PAGE_SIZE) 1008 bitmap = kmalloc(size, GFP_KERNEL); 1009 else 1010 bitmap = vmalloc(size); /* TODO: get rid of vmalloc */ 1011 1012 if (bitmap == NULL) { 1013 udf_error(sb, __FUNCTION__, 1014 "Unable to allocate space for bitmap " 1015 "and %d buffer_head pointers", nr_groups); 1016 return NULL; 1017 } 1018 1019 memset(bitmap, 0x00, size); 1020 bitmap->s_block_bitmap = (struct buffer_head **)(bitmap + 1); 1021 bitmap->s_nr_groups = nr_groups; 1022 return bitmap; 1023 } 1024 1025 static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh) 1026 { 1027 struct partitionDesc *p; 1028 int i; 1029 struct udf_part_map *map; 1030 struct udf_sb_info *sbi; 1031 1032 p = (struct partitionDesc *)bh->b_data; 1033 sbi = UDF_SB(sb); 1034 1035 for (i = 0; i < sbi->s_partitions; i++) { 1036 map = &sbi->s_partmaps[i]; 1037 udf_debug("Searching map: (%d == %d)\n", 1038 map->s_partition_num, 1039 le16_to_cpu(p->partitionNumber)); 1040 if (map->s_partition_num == 1041 le16_to_cpu(p->partitionNumber)) { 1042 map->s_partition_len = 1043 le32_to_cpu(p->partitionLength); /* blocks */ 1044 map->s_partition_root = 1045 le32_to_cpu(p->partitionStartingLocation); 1046 if (p->accessType == 1047 cpu_to_le32(PD_ACCESS_TYPE_READ_ONLY)) 1048 map->s_partition_flags |= 1049 UDF_PART_FLAG_READ_ONLY; 1050 if (p->accessType == 1051 cpu_to_le32(PD_ACCESS_TYPE_WRITE_ONCE)) 1052 map->s_partition_flags |= 1053 UDF_PART_FLAG_WRITE_ONCE; 1054 if (p->accessType == 1055 cpu_to_le32(PD_ACCESS_TYPE_REWRITABLE)) 1056 map->s_partition_flags |= 1057 UDF_PART_FLAG_REWRITABLE; 1058 if (p->accessType == 1059 cpu_to_le32(PD_ACCESS_TYPE_OVERWRITABLE)) 1060 map->s_partition_flags |= 1061 UDF_PART_FLAG_OVERWRITABLE; 1062 1063 if (!strcmp(p->partitionContents.ident, 1064 PD_PARTITION_CONTENTS_NSR02) || 1065 !strcmp(p->partitionContents.ident, 1066 PD_PARTITION_CONTENTS_NSR03)) { 1067 struct partitionHeaderDesc *phd; 1068 1069 phd = (struct partitionHeaderDesc *) 1070 (p->partitionContentsUse); 1071 if (phd->unallocSpaceTable.extLength) { 1072 kernel_lb_addr loc = { 1073 .logicalBlockNum = le32_to_cpu(phd->unallocSpaceTable.extPosition), 1074 .partitionReferenceNum = i, 1075 }; 1076 1077 map->s_uspace.s_table = 1078 udf_iget(sb, loc); 1079 if (!map->s_uspace.s_table) { 1080 udf_debug("cannot load unallocSpaceTable (part %d)\n", i); 1081 return 1; 1082 } 1083 map->s_partition_flags |= 1084 UDF_PART_FLAG_UNALLOC_TABLE; 1085 udf_debug("unallocSpaceTable (part %d) @ %ld\n", 1086 i, map->s_uspace.s_table->i_ino); 1087 } 1088 if (phd->unallocSpaceBitmap.extLength) { 1089 struct udf_bitmap *bitmap = 1090 udf_sb_alloc_bitmap(sb, i); 1091 map->s_uspace.s_bitmap = bitmap; 1092 if (bitmap != NULL) { 1093 bitmap->s_extLength = 1094 le32_to_cpu(phd->unallocSpaceBitmap.extLength); 1095 bitmap->s_extPosition = 1096 le32_to_cpu(phd->unallocSpaceBitmap.extPosition); 1097 map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_BITMAP; 1098 udf_debug("unallocSpaceBitmap (part %d) @ %d\n", 1099 i, bitmap->s_extPosition); 1100 } 1101 } 1102 if (phd->partitionIntegrityTable.extLength) 1103 udf_debug("partitionIntegrityTable (part %d)\n", i); 1104 if (phd->freedSpaceTable.extLength) { 1105 kernel_lb_addr loc = { 1106 .logicalBlockNum = le32_to_cpu(phd->freedSpaceTable.extPosition), 1107 .partitionReferenceNum = i, 1108 }; 1109 1110 map->s_fspace.s_table = 1111 udf_iget(sb, loc); 1112 if (!map->s_fspace.s_table) { 1113 udf_debug("cannot load freedSpaceTable (part %d)\n", i); 1114 return 1; 1115 } 1116 map->s_partition_flags |= 1117 UDF_PART_FLAG_FREED_TABLE; 1118 udf_debug("freedSpaceTable (part %d) @ %ld\n", 1119 i, map->s_fspace.s_table->i_ino); 1120 } 1121 if (phd->freedSpaceBitmap.extLength) { 1122 struct udf_bitmap *bitmap = 1123 udf_sb_alloc_bitmap(sb, i); 1124 map->s_fspace.s_bitmap = bitmap; 1125 if (bitmap != NULL) { 1126 bitmap->s_extLength = 1127 le32_to_cpu(phd->freedSpaceBitmap.extLength); 1128 bitmap->s_extPosition = 1129 le32_to_cpu(phd->freedSpaceBitmap.extPosition); 1130 map->s_partition_flags |= UDF_PART_FLAG_FREED_BITMAP; 1131 udf_debug("freedSpaceBitmap (part %d) @ %d\n", 1132 i, bitmap->s_extPosition); 1133 } 1134 } 1135 } 1136 break; 1137 } 1138 } 1139 if (i == sbi->s_partitions) 1140 udf_debug("Partition (%d) not found in partition map\n", 1141 le16_to_cpu(p->partitionNumber)); 1142 else 1143 udf_debug("Partition (%d:%d type %x) starts at physical %d, " 1144 "block length %d\n", 1145 le16_to_cpu(p->partitionNumber), i, 1146 map->s_partition_type, 1147 map->s_partition_root, 1148 map->s_partition_len); 1149 return 0; 1150 } 1151 1152 static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh, 1153 kernel_lb_addr *fileset) 1154 { 1155 struct logicalVolDesc *lvd; 1156 int i, j, offset; 1157 uint8_t type; 1158 struct udf_sb_info *sbi = UDF_SB(sb); 1159 struct genericPartitionMap *gpm; 1160 1161 lvd = (struct logicalVolDesc *)bh->b_data; 1162 1163 i = udf_sb_alloc_partition_maps(sb, le32_to_cpu(lvd->numPartitionMaps)); 1164 if (i != 0) 1165 return i; 1166 1167 for (i = 0, offset = 0; 1168 i < sbi->s_partitions && offset < le32_to_cpu(lvd->mapTableLength); 1169 i++, offset += gpm->partitionMapLength) { 1170 struct udf_part_map *map = &sbi->s_partmaps[i]; 1171 gpm = (struct genericPartitionMap *) 1172 &(lvd->partitionMaps[offset]); 1173 type = gpm->partitionMapType; 1174 if (type == 1) { 1175 struct genericPartitionMap1 *gpm1 = 1176 (struct genericPartitionMap1 *)gpm; 1177 map->s_partition_type = UDF_TYPE1_MAP15; 1178 map->s_volumeseqnum = le16_to_cpu(gpm1->volSeqNum); 1179 map->s_partition_num = le16_to_cpu(gpm1->partitionNum); 1180 map->s_partition_func = NULL; 1181 } else if (type == 2) { 1182 struct udfPartitionMap2 *upm2 = 1183 (struct udfPartitionMap2 *)gpm; 1184 if (!strncmp(upm2->partIdent.ident, UDF_ID_VIRTUAL, 1185 strlen(UDF_ID_VIRTUAL))) { 1186 u16 suf = 1187 le16_to_cpu(((__le16 *)upm2->partIdent. 1188 identSuffix)[0]); 1189 if (suf == 0x0150) { 1190 map->s_partition_type = 1191 UDF_VIRTUAL_MAP15; 1192 map->s_partition_func = 1193 udf_get_pblock_virt15; 1194 } else if (suf == 0x0200) { 1195 map->s_partition_type = 1196 UDF_VIRTUAL_MAP20; 1197 map->s_partition_func = 1198 udf_get_pblock_virt20; 1199 } 1200 } else if (!strncmp(upm2->partIdent.ident, 1201 UDF_ID_SPARABLE, 1202 strlen(UDF_ID_SPARABLE))) { 1203 uint32_t loc; 1204 uint16_t ident; 1205 struct sparingTable *st; 1206 struct sparablePartitionMap *spm = 1207 (struct sparablePartitionMap *)gpm; 1208 1209 map->s_partition_type = UDF_SPARABLE_MAP15; 1210 map->s_type_specific.s_sparing.s_packet_len = 1211 le16_to_cpu(spm->packetLength); 1212 for (j = 0; j < spm->numSparingTables; j++) { 1213 struct buffer_head *bh2; 1214 1215 loc = le32_to_cpu( 1216 spm->locSparingTable[j]); 1217 bh2 = udf_read_tagged(sb, loc, loc, 1218 &ident); 1219 map->s_type_specific.s_sparing. 1220 s_spar_map[j] = bh2; 1221 1222 if (bh2 != NULL) { 1223 st = (struct sparingTable *) 1224 bh2->b_data; 1225 if (ident != 0 || strncmp( 1226 st->sparingIdent.ident, 1227 UDF_ID_SPARING, 1228 strlen(UDF_ID_SPARING))) { 1229 brelse(bh2); 1230 map->s_type_specific. 1231 s_sparing. 1232 s_spar_map[j] = 1233 NULL; 1234 } 1235 } 1236 } 1237 map->s_partition_func = udf_get_pblock_spar15; 1238 } else { 1239 udf_debug("Unknown ident: %s\n", 1240 upm2->partIdent.ident); 1241 continue; 1242 } 1243 map->s_volumeseqnum = le16_to_cpu(upm2->volSeqNum); 1244 map->s_partition_num = le16_to_cpu(upm2->partitionNum); 1245 } 1246 udf_debug("Partition (%d:%d) type %d on volume %d\n", 1247 i, map->s_partition_num, type, 1248 map->s_volumeseqnum); 1249 } 1250 1251 if (fileset) { 1252 long_ad *la = (long_ad *)&(lvd->logicalVolContentsUse[0]); 1253 1254 *fileset = lelb_to_cpu(la->extLocation); 1255 udf_debug("FileSet found in LogicalVolDesc at block=%d, " 1256 "partition=%d\n", fileset->logicalBlockNum, 1257 fileset->partitionReferenceNum); 1258 } 1259 if (lvd->integritySeqExt.extLength) 1260 udf_load_logicalvolint(sb, leea_to_cpu(lvd->integritySeqExt)); 1261 1262 return 0; 1263 } 1264 1265 /* 1266 * udf_load_logicalvolint 1267 * 1268 */ 1269 static void udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc) 1270 { 1271 struct buffer_head *bh = NULL; 1272 uint16_t ident; 1273 struct udf_sb_info *sbi = UDF_SB(sb); 1274 struct logicalVolIntegrityDesc *lvid; 1275 1276 while (loc.extLength > 0 && 1277 (bh = udf_read_tagged(sb, loc.extLocation, 1278 loc.extLocation, &ident)) && 1279 ident == TAG_IDENT_LVID) { 1280 sbi->s_lvid_bh = bh; 1281 lvid = (struct logicalVolIntegrityDesc *)bh->b_data; 1282 1283 if (lvid->nextIntegrityExt.extLength) 1284 udf_load_logicalvolint(sb, 1285 leea_to_cpu(lvid->nextIntegrityExt)); 1286 1287 if (sbi->s_lvid_bh != bh) 1288 brelse(bh); 1289 loc.extLength -= sb->s_blocksize; 1290 loc.extLocation++; 1291 } 1292 if (sbi->s_lvid_bh != bh) 1293 brelse(bh); 1294 } 1295 1296 /* 1297 * udf_process_sequence 1298 * 1299 * PURPOSE 1300 * Process a main/reserve volume descriptor sequence. 1301 * 1302 * PRE-CONDITIONS 1303 * sb Pointer to _locked_ superblock. 1304 * block First block of first extent of the sequence. 1305 * lastblock Lastblock of first extent of the sequence. 1306 * 1307 * HISTORY 1308 * July 1, 1997 - Andrew E. Mileski 1309 * Written, tested, and released. 1310 */ 1311 static int udf_process_sequence(struct super_block *sb, long block, 1312 long lastblock, kernel_lb_addr *fileset) 1313 { 1314 struct buffer_head *bh = NULL; 1315 struct udf_vds_record vds[VDS_POS_LENGTH]; 1316 struct udf_vds_record *curr; 1317 struct generic_desc *gd; 1318 struct volDescPtr *vdp; 1319 int done = 0; 1320 int i, j; 1321 uint32_t vdsn; 1322 uint16_t ident; 1323 long next_s = 0, next_e = 0; 1324 1325 memset(vds, 0, sizeof(struct udf_vds_record) * VDS_POS_LENGTH); 1326 1327 /* Read the main descriptor sequence */ 1328 for (; (!done && block <= lastblock); block++) { 1329 1330 bh = udf_read_tagged(sb, block, block, &ident); 1331 if (!bh) 1332 break; 1333 1334 /* Process each descriptor (ISO 13346 3/8.3-8.4) */ 1335 gd = (struct generic_desc *)bh->b_data; 1336 vdsn = le32_to_cpu(gd->volDescSeqNum); 1337 switch (ident) { 1338 case TAG_IDENT_PVD: /* ISO 13346 3/10.1 */ 1339 curr = &vds[VDS_POS_PRIMARY_VOL_DESC]; 1340 if (vdsn >= curr->volDescSeqNum) { 1341 curr->volDescSeqNum = vdsn; 1342 curr->block = block; 1343 } 1344 break; 1345 case TAG_IDENT_VDP: /* ISO 13346 3/10.3 */ 1346 curr = &vds[VDS_POS_VOL_DESC_PTR]; 1347 if (vdsn >= curr->volDescSeqNum) { 1348 curr->volDescSeqNum = vdsn; 1349 curr->block = block; 1350 1351 vdp = (struct volDescPtr *)bh->b_data; 1352 next_s = le32_to_cpu( 1353 vdp->nextVolDescSeqExt.extLocation); 1354 next_e = le32_to_cpu( 1355 vdp->nextVolDescSeqExt.extLength); 1356 next_e = next_e >> sb->s_blocksize_bits; 1357 next_e += next_s; 1358 } 1359 break; 1360 case TAG_IDENT_IUVD: /* ISO 13346 3/10.4 */ 1361 curr = &vds[VDS_POS_IMP_USE_VOL_DESC]; 1362 if (vdsn >= curr->volDescSeqNum) { 1363 curr->volDescSeqNum = vdsn; 1364 curr->block = block; 1365 } 1366 break; 1367 case TAG_IDENT_PD: /* ISO 13346 3/10.5 */ 1368 curr = &vds[VDS_POS_PARTITION_DESC]; 1369 if (!curr->block) 1370 curr->block = block; 1371 break; 1372 case TAG_IDENT_LVD: /* ISO 13346 3/10.6 */ 1373 curr = &vds[VDS_POS_LOGICAL_VOL_DESC]; 1374 if (vdsn >= curr->volDescSeqNum) { 1375 curr->volDescSeqNum = vdsn; 1376 curr->block = block; 1377 } 1378 break; 1379 case TAG_IDENT_USD: /* ISO 13346 3/10.8 */ 1380 curr = &vds[VDS_POS_UNALLOC_SPACE_DESC]; 1381 if (vdsn >= curr->volDescSeqNum) { 1382 curr->volDescSeqNum = vdsn; 1383 curr->block = block; 1384 } 1385 break; 1386 case TAG_IDENT_TD: /* ISO 13346 3/10.9 */ 1387 vds[VDS_POS_TERMINATING_DESC].block = block; 1388 if (next_e) { 1389 block = next_s; 1390 lastblock = next_e; 1391 next_s = next_e = 0; 1392 } else 1393 done = 1; 1394 break; 1395 } 1396 brelse(bh); 1397 } 1398 for (i = 0; i < VDS_POS_LENGTH; i++) { 1399 if (vds[i].block) { 1400 bh = udf_read_tagged(sb, vds[i].block, vds[i].block, 1401 &ident); 1402 1403 if (i == VDS_POS_PRIMARY_VOL_DESC) { 1404 udf_load_pvoldesc(sb, bh); 1405 } else if (i == VDS_POS_LOGICAL_VOL_DESC) { 1406 if (udf_load_logicalvol(sb, bh, fileset)) { 1407 brelse(bh); 1408 return 1; 1409 } 1410 } else if (i == VDS_POS_PARTITION_DESC) { 1411 struct buffer_head *bh2 = NULL; 1412 if (udf_load_partdesc(sb, bh)) { 1413 brelse(bh); 1414 return 1; 1415 } 1416 for (j = vds[i].block + 1; 1417 j < vds[VDS_POS_TERMINATING_DESC].block; 1418 j++) { 1419 bh2 = udf_read_tagged(sb, j, j, &ident); 1420 gd = (struct generic_desc *)bh2->b_data; 1421 if (ident == TAG_IDENT_PD) 1422 if (udf_load_partdesc(sb, 1423 bh2)) { 1424 brelse(bh); 1425 brelse(bh2); 1426 return 1; 1427 } 1428 brelse(bh2); 1429 } 1430 } 1431 brelse(bh); 1432 } 1433 } 1434 1435 return 0; 1436 } 1437 1438 /* 1439 * udf_check_valid() 1440 */ 1441 static int udf_check_valid(struct super_block *sb, int novrs, int silent) 1442 { 1443 long block; 1444 1445 if (novrs) { 1446 udf_debug("Validity check skipped because of novrs option\n"); 1447 return 0; 1448 } 1449 /* Check that it is NSR02 compliant */ 1450 /* Process any "CD-ROM Volume Descriptor Set" (ECMA 167 2/8.3.1) */ 1451 else { 1452 block = udf_vrs(sb, silent); 1453 if (block == -1) { 1454 struct udf_sb_info *sbi = UDF_SB(sb); 1455 udf_debug("Failed to read byte 32768. Assuming open " 1456 "disc. Skipping validity check\n"); 1457 if (!sbi->s_last_block) 1458 sbi->s_last_block = udf_get_last_block(sb); 1459 return 0; 1460 } else 1461 return !block; 1462 } 1463 } 1464 1465 static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset) 1466 { 1467 struct anchorVolDescPtr *anchor; 1468 uint16_t ident; 1469 struct buffer_head *bh; 1470 long main_s, main_e, reserve_s, reserve_e; 1471 int i, j; 1472 struct udf_sb_info *sbi; 1473 1474 if (!sb) 1475 return 1; 1476 sbi = UDF_SB(sb); 1477 1478 for (i = 0; i < ARRAY_SIZE(sbi->s_anchor); i++) { 1479 if (!sbi->s_anchor[i]) 1480 continue; 1481 bh = udf_read_tagged(sb, sbi->s_anchor[i], sbi->s_anchor[i], 1482 &ident); 1483 if (!bh) 1484 continue; 1485 1486 anchor = (struct anchorVolDescPtr *)bh->b_data; 1487 1488 /* Locate the main sequence */ 1489 main_s = le32_to_cpu(anchor->mainVolDescSeqExt.extLocation); 1490 main_e = le32_to_cpu(anchor->mainVolDescSeqExt.extLength); 1491 main_e = main_e >> sb->s_blocksize_bits; 1492 main_e += main_s; 1493 1494 /* Locate the reserve sequence */ 1495 reserve_s = le32_to_cpu( 1496 anchor->reserveVolDescSeqExt.extLocation); 1497 reserve_e = le32_to_cpu( 1498 anchor->reserveVolDescSeqExt.extLength); 1499 reserve_e = reserve_e >> sb->s_blocksize_bits; 1500 reserve_e += reserve_s; 1501 1502 brelse(bh); 1503 1504 /* Process the main & reserve sequences */ 1505 /* responsible for finding the PartitionDesc(s) */ 1506 if (!(udf_process_sequence(sb, main_s, main_e, 1507 fileset) && 1508 udf_process_sequence(sb, reserve_s, reserve_e, 1509 fileset))) 1510 break; 1511 } 1512 1513 if (i == ARRAY_SIZE(sbi->s_anchor)) { 1514 udf_debug("No Anchor block found\n"); 1515 return 1; 1516 } 1517 udf_debug("Using anchor in block %d\n", sbi->s_anchor[i]); 1518 1519 for (i = 0; i < sbi->s_partitions; i++) { 1520 kernel_lb_addr uninitialized_var(ino); 1521 struct udf_part_map *map = &sbi->s_partmaps[i]; 1522 switch (map->s_partition_type) { 1523 case UDF_VIRTUAL_MAP15: 1524 case UDF_VIRTUAL_MAP20: 1525 if (!sbi->s_last_block) { 1526 sbi->s_last_block = udf_get_last_block(sb); 1527 udf_find_anchor(sb); 1528 } 1529 1530 if (!sbi->s_last_block) { 1531 udf_debug("Unable to determine Lastblock (For " 1532 "Virtual Partition)\n"); 1533 return 1; 1534 } 1535 1536 for (j = 0; j < sbi->s_partitions; j++) { 1537 struct udf_part_map *map2 = &sbi->s_partmaps[j]; 1538 if (j != i && 1539 map->s_volumeseqnum == 1540 map2->s_volumeseqnum && 1541 map->s_partition_num == 1542 map2->s_partition_num) { 1543 ino.partitionReferenceNum = j; 1544 ino.logicalBlockNum = 1545 sbi->s_last_block - 1546 map2->s_partition_root; 1547 break; 1548 } 1549 } 1550 1551 if (j == sbi->s_partitions) 1552 return 1; 1553 1554 sbi->s_vat_inode = udf_iget(sb, ino); 1555 if (!sbi->s_vat_inode) 1556 return 1; 1557 1558 if (map->s_partition_type == UDF_VIRTUAL_MAP15) { 1559 map->s_type_specific.s_virtual.s_start_offset = 1560 udf_ext0_offset(sbi->s_vat_inode); 1561 map->s_type_specific.s_virtual.s_num_entries = 1562 (sbi->s_vat_inode->i_size - 36) >> 2; 1563 } else if (map->s_partition_type == UDF_VIRTUAL_MAP20) { 1564 uint32_t pos; 1565 struct virtualAllocationTable20 *vat20; 1566 1567 pos = udf_block_map(sbi->s_vat_inode, 0); 1568 bh = sb_bread(sb, pos); 1569 if (!bh) 1570 return 1; 1571 vat20 = (struct virtualAllocationTable20 *) 1572 bh->b_data + 1573 udf_ext0_offset(sbi->s_vat_inode); 1574 map->s_type_specific.s_virtual.s_start_offset = 1575 le16_to_cpu(vat20->lengthHeader) + 1576 udf_ext0_offset(sbi->s_vat_inode); 1577 map->s_type_specific.s_virtual.s_num_entries = 1578 (sbi->s_vat_inode->i_size - 1579 map->s_type_specific.s_virtual. 1580 s_start_offset) >> 2; 1581 brelse(bh); 1582 } 1583 map->s_partition_root = udf_get_pblock(sb, 0, i, 0); 1584 map->s_partition_len = 1585 sbi->s_partmaps[ino.partitionReferenceNum]. 1586 s_partition_len; 1587 } 1588 } 1589 return 0; 1590 } 1591 1592 static void udf_open_lvid(struct super_block *sb) 1593 { 1594 struct udf_sb_info *sbi = UDF_SB(sb); 1595 struct buffer_head *bh = sbi->s_lvid_bh; 1596 if (bh) { 1597 kernel_timestamp cpu_time; 1598 struct logicalVolIntegrityDesc *lvid = 1599 (struct logicalVolIntegrityDesc *)bh->b_data; 1600 struct logicalVolIntegrityDescImpUse *lvidiu = 1601 udf_sb_lvidiu(sbi); 1602 1603 lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX; 1604 lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX; 1605 if (udf_time_to_stamp(&cpu_time, CURRENT_TIME)) 1606 lvid->recordingDateAndTime = cpu_to_lets(cpu_time); 1607 lvid->integrityType = LVID_INTEGRITY_TYPE_OPEN; 1608 1609 lvid->descTag.descCRC = cpu_to_le16( 1610 udf_crc((char *)lvid + sizeof(tag), 1611 le16_to_cpu(lvid->descTag.descCRCLength), 1612 0)); 1613 1614 lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag); 1615 mark_buffer_dirty(bh); 1616 } 1617 } 1618 1619 static void udf_close_lvid(struct super_block *sb) 1620 { 1621 kernel_timestamp cpu_time; 1622 struct udf_sb_info *sbi = UDF_SB(sb); 1623 struct buffer_head *bh = sbi->s_lvid_bh; 1624 struct logicalVolIntegrityDesc *lvid; 1625 1626 if (!bh) 1627 return; 1628 1629 lvid = (struct logicalVolIntegrityDesc *)bh->b_data; 1630 1631 if (lvid->integrityType == LVID_INTEGRITY_TYPE_OPEN) { 1632 struct logicalVolIntegrityDescImpUse *lvidiu = 1633 udf_sb_lvidiu(sbi); 1634 lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX; 1635 lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX; 1636 if (udf_time_to_stamp(&cpu_time, CURRENT_TIME)) 1637 lvid->recordingDateAndTime = cpu_to_lets(cpu_time); 1638 if (UDF_MAX_WRITE_VERSION > le16_to_cpu(lvidiu->maxUDFWriteRev)) 1639 lvidiu->maxUDFWriteRev = 1640 cpu_to_le16(UDF_MAX_WRITE_VERSION); 1641 if (sbi->s_udfrev > le16_to_cpu(lvidiu->minUDFReadRev)) 1642 lvidiu->minUDFReadRev = cpu_to_le16(sbi->s_udfrev); 1643 if (sbi->s_udfrev > le16_to_cpu(lvidiu->minUDFWriteRev)) 1644 lvidiu->minUDFWriteRev = cpu_to_le16(sbi->s_udfrev); 1645 lvid->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE); 1646 1647 lvid->descTag.descCRC = cpu_to_le16( 1648 udf_crc((char *)lvid + sizeof(tag), 1649 le16_to_cpu(lvid->descTag.descCRCLength), 1650 0)); 1651 1652 lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag); 1653 mark_buffer_dirty(bh); 1654 } 1655 } 1656 1657 static void udf_sb_free_bitmap(struct udf_bitmap *bitmap) 1658 { 1659 int i; 1660 int nr_groups = bitmap->s_nr_groups; 1661 int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) * 1662 nr_groups); 1663 1664 for (i = 0; i < nr_groups; i++) 1665 if (bitmap->s_block_bitmap[i]) 1666 brelse(bitmap->s_block_bitmap[i]); 1667 1668 if (size <= PAGE_SIZE) 1669 kfree(bitmap); 1670 else 1671 vfree(bitmap); 1672 } 1673 1674 static int udf_fill_super(struct super_block *sb, void *options, int silent) 1675 { 1676 int i; 1677 struct inode *inode = NULL; 1678 struct udf_options uopt; 1679 kernel_lb_addr rootdir, fileset; 1680 struct udf_sb_info *sbi; 1681 1682 uopt.flags = (1 << UDF_FLAG_USE_AD_IN_ICB) | (1 << UDF_FLAG_STRICT); 1683 uopt.uid = -1; 1684 uopt.gid = -1; 1685 uopt.umask = 0; 1686 1687 sbi = kzalloc(sizeof(struct udf_sb_info), GFP_KERNEL); 1688 if (!sbi) 1689 return -ENOMEM; 1690 1691 sb->s_fs_info = sbi; 1692 1693 mutex_init(&sbi->s_alloc_mutex); 1694 1695 if (!udf_parse_options((char *)options, &uopt, false)) 1696 goto error_out; 1697 1698 if (uopt.flags & (1 << UDF_FLAG_UTF8) && 1699 uopt.flags & (1 << UDF_FLAG_NLS_MAP)) { 1700 udf_error(sb, "udf_read_super", 1701 "utf8 cannot be combined with iocharset\n"); 1702 goto error_out; 1703 } 1704 #ifdef CONFIG_UDF_NLS 1705 if ((uopt.flags & (1 << UDF_FLAG_NLS_MAP)) && !uopt.nls_map) { 1706 uopt.nls_map = load_nls_default(); 1707 if (!uopt.nls_map) 1708 uopt.flags &= ~(1 << UDF_FLAG_NLS_MAP); 1709 else 1710 udf_debug("Using default NLS map\n"); 1711 } 1712 #endif 1713 if (!(uopt.flags & (1 << UDF_FLAG_NLS_MAP))) 1714 uopt.flags |= (1 << UDF_FLAG_UTF8); 1715 1716 fileset.logicalBlockNum = 0xFFFFFFFF; 1717 fileset.partitionReferenceNum = 0xFFFF; 1718 1719 sbi->s_flags = uopt.flags; 1720 sbi->s_uid = uopt.uid; 1721 sbi->s_gid = uopt.gid; 1722 sbi->s_umask = uopt.umask; 1723 sbi->s_nls_map = uopt.nls_map; 1724 1725 /* Set the block size for all transfers */ 1726 if (!sb_min_blocksize(sb, uopt.blocksize)) { 1727 udf_debug("Bad block size (%d)\n", uopt.blocksize); 1728 printk(KERN_ERR "udf: bad block size (%d)\n", uopt.blocksize); 1729 goto error_out; 1730 } 1731 1732 if (uopt.session == 0xFFFFFFFF) 1733 sbi->s_session = udf_get_last_session(sb); 1734 else 1735 sbi->s_session = uopt.session; 1736 1737 udf_debug("Multi-session=%d\n", sbi->s_session); 1738 1739 sbi->s_last_block = uopt.lastblock; 1740 sbi->s_anchor[0] = sbi->s_anchor[1] = 0; 1741 sbi->s_anchor[2] = uopt.anchor; 1742 sbi->s_anchor[3] = 256; 1743 1744 if (udf_check_valid(sb, uopt.novrs, silent)) { 1745 /* read volume recognition sequences */ 1746 printk(KERN_WARNING "UDF-fs: No VRS found\n"); 1747 goto error_out; 1748 } 1749 1750 udf_find_anchor(sb); 1751 1752 /* Fill in the rest of the superblock */ 1753 sb->s_op = &udf_sb_ops; 1754 sb->dq_op = NULL; 1755 sb->s_dirt = 0; 1756 sb->s_magic = UDF_SUPER_MAGIC; 1757 sb->s_time_gran = 1000; 1758 1759 if (udf_load_partition(sb, &fileset)) { 1760 printk(KERN_WARNING "UDF-fs: No partition found (1)\n"); 1761 goto error_out; 1762 } 1763 1764 udf_debug("Lastblock=%d\n", sbi->s_last_block); 1765 1766 if (sbi->s_lvid_bh) { 1767 struct logicalVolIntegrityDescImpUse *lvidiu = 1768 udf_sb_lvidiu(sbi); 1769 uint16_t minUDFReadRev = le16_to_cpu(lvidiu->minUDFReadRev); 1770 uint16_t minUDFWriteRev = le16_to_cpu(lvidiu->minUDFWriteRev); 1771 /* uint16_t maxUDFWriteRev = 1772 le16_to_cpu(lvidiu->maxUDFWriteRev); */ 1773 1774 if (minUDFReadRev > UDF_MAX_READ_VERSION) { 1775 printk(KERN_ERR "UDF-fs: minUDFReadRev=%x " 1776 "(max is %x)\n", 1777 le16_to_cpu(lvidiu->minUDFReadRev), 1778 UDF_MAX_READ_VERSION); 1779 goto error_out; 1780 } else if (minUDFWriteRev > UDF_MAX_WRITE_VERSION) 1781 sb->s_flags |= MS_RDONLY; 1782 1783 sbi->s_udfrev = minUDFWriteRev; 1784 1785 if (minUDFReadRev >= UDF_VERS_USE_EXTENDED_FE) 1786 UDF_SET_FLAG(sb, UDF_FLAG_USE_EXTENDED_FE); 1787 if (minUDFReadRev >= UDF_VERS_USE_STREAMS) 1788 UDF_SET_FLAG(sb, UDF_FLAG_USE_STREAMS); 1789 } 1790 1791 if (!sbi->s_partitions) { 1792 printk(KERN_WARNING "UDF-fs: No partition found (2)\n"); 1793 goto error_out; 1794 } 1795 1796 if (sbi->s_partmaps[sbi->s_partition].s_partition_flags & 1797 UDF_PART_FLAG_READ_ONLY) { 1798 printk(KERN_NOTICE "UDF-fs: Partition marked readonly; " 1799 "forcing readonly mount\n"); 1800 sb->s_flags |= MS_RDONLY; 1801 } 1802 1803 if (udf_find_fileset(sb, &fileset, &rootdir)) { 1804 printk(KERN_WARNING "UDF-fs: No fileset found\n"); 1805 goto error_out; 1806 } 1807 1808 if (!silent) { 1809 kernel_timestamp ts; 1810 udf_time_to_stamp(&ts, sbi->s_record_time); 1811 udf_info("UDF: Mounting volume '%s', " 1812 "timestamp %04u/%02u/%02u %02u:%02u (%x)\n", 1813 sbi->s_volume_ident, ts.year, ts.month, ts.day, 1814 ts.hour, ts.minute, ts.typeAndTimezone); 1815 } 1816 if (!(sb->s_flags & MS_RDONLY)) 1817 udf_open_lvid(sb); 1818 1819 /* Assign the root inode */ 1820 /* assign inodes by physical block number */ 1821 /* perhaps it's not extensible enough, but for now ... */ 1822 inode = udf_iget(sb, rootdir); 1823 if (!inode) { 1824 printk(KERN_ERR "UDF-fs: Error in udf_iget, block=%d, " 1825 "partition=%d\n", 1826 rootdir.logicalBlockNum, rootdir.partitionReferenceNum); 1827 goto error_out; 1828 } 1829 1830 /* Allocate a dentry for the root inode */ 1831 sb->s_root = d_alloc_root(inode); 1832 if (!sb->s_root) { 1833 printk(KERN_ERR "UDF-fs: Couldn't allocate root dentry\n"); 1834 iput(inode); 1835 goto error_out; 1836 } 1837 sb->s_maxbytes = MAX_LFS_FILESIZE; 1838 return 0; 1839 1840 error_out: 1841 if (sbi->s_vat_inode) 1842 iput(sbi->s_vat_inode); 1843 if (sbi->s_partitions) { 1844 struct udf_part_map *map = &sbi->s_partmaps[sbi->s_partition]; 1845 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) 1846 iput(map->s_uspace.s_table); 1847 if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) 1848 iput(map->s_fspace.s_table); 1849 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) 1850 udf_sb_free_bitmap(map->s_uspace.s_bitmap); 1851 if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) 1852 udf_sb_free_bitmap(map->s_fspace.s_bitmap); 1853 if (map->s_partition_type == UDF_SPARABLE_MAP15) 1854 for (i = 0; i < 4; i++) 1855 brelse(map->s_type_specific.s_sparing. 1856 s_spar_map[i]); 1857 } 1858 #ifdef CONFIG_UDF_NLS 1859 if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) 1860 unload_nls(sbi->s_nls_map); 1861 #endif 1862 if (!(sb->s_flags & MS_RDONLY)) 1863 udf_close_lvid(sb); 1864 brelse(sbi->s_lvid_bh); 1865 1866 kfree(sbi->s_partmaps); 1867 kfree(sbi); 1868 sb->s_fs_info = NULL; 1869 1870 return -EINVAL; 1871 } 1872 1873 static void udf_error(struct super_block *sb, const char *function, 1874 const char *fmt, ...) 1875 { 1876 va_list args; 1877 1878 if (!(sb->s_flags & MS_RDONLY)) { 1879 /* mark sb error */ 1880 sb->s_dirt = 1; 1881 } 1882 va_start(args, fmt); 1883 vsnprintf(error_buf, sizeof(error_buf), fmt, args); 1884 va_end(args); 1885 printk(KERN_CRIT "UDF-fs error (device %s): %s: %s\n", 1886 sb->s_id, function, error_buf); 1887 } 1888 1889 void udf_warning(struct super_block *sb, const char *function, 1890 const char *fmt, ...) 1891 { 1892 va_list args; 1893 1894 va_start(args, fmt); 1895 vsnprintf(error_buf, sizeof(error_buf), fmt, args); 1896 va_end(args); 1897 printk(KERN_WARNING "UDF-fs warning (device %s): %s: %s\n", 1898 sb->s_id, function, error_buf); 1899 } 1900 1901 static void udf_put_super(struct super_block *sb) 1902 { 1903 int i; 1904 struct udf_sb_info *sbi; 1905 1906 sbi = UDF_SB(sb); 1907 if (sbi->s_vat_inode) 1908 iput(sbi->s_vat_inode); 1909 if (sbi->s_partitions) { 1910 struct udf_part_map *map = &sbi->s_partmaps[sbi->s_partition]; 1911 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) 1912 iput(map->s_uspace.s_table); 1913 if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) 1914 iput(map->s_fspace.s_table); 1915 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) 1916 udf_sb_free_bitmap(map->s_uspace.s_bitmap); 1917 if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) 1918 udf_sb_free_bitmap(map->s_fspace.s_bitmap); 1919 if (map->s_partition_type == UDF_SPARABLE_MAP15) 1920 for (i = 0; i < 4; i++) 1921 brelse(map->s_type_specific.s_sparing. 1922 s_spar_map[i]); 1923 } 1924 #ifdef CONFIG_UDF_NLS 1925 if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) 1926 unload_nls(sbi->s_nls_map); 1927 #endif 1928 if (!(sb->s_flags & MS_RDONLY)) 1929 udf_close_lvid(sb); 1930 brelse(sbi->s_lvid_bh); 1931 kfree(sbi->s_partmaps); 1932 kfree(sb->s_fs_info); 1933 sb->s_fs_info = NULL; 1934 } 1935 1936 static int udf_statfs(struct dentry *dentry, struct kstatfs *buf) 1937 { 1938 struct super_block *sb = dentry->d_sb; 1939 struct udf_sb_info *sbi = UDF_SB(sb); 1940 struct logicalVolIntegrityDescImpUse *lvidiu; 1941 1942 if (sbi->s_lvid_bh != NULL) 1943 lvidiu = udf_sb_lvidiu(sbi); 1944 else 1945 lvidiu = NULL; 1946 1947 buf->f_type = UDF_SUPER_MAGIC; 1948 buf->f_bsize = sb->s_blocksize; 1949 buf->f_blocks = sbi->s_partmaps[sbi->s_partition].s_partition_len; 1950 buf->f_bfree = udf_count_free(sb); 1951 buf->f_bavail = buf->f_bfree; 1952 buf->f_files = (lvidiu != NULL ? (le32_to_cpu(lvidiu->numFiles) + 1953 le32_to_cpu(lvidiu->numDirs)) : 0) 1954 + buf->f_bfree; 1955 buf->f_ffree = buf->f_bfree; 1956 /* __kernel_fsid_t f_fsid */ 1957 buf->f_namelen = UDF_NAME_LEN - 2; 1958 1959 return 0; 1960 } 1961 1962 static unsigned int udf_count_free_bitmap(struct super_block *sb, 1963 struct udf_bitmap *bitmap) 1964 { 1965 struct buffer_head *bh = NULL; 1966 unsigned int accum = 0; 1967 int index; 1968 int block = 0, newblock; 1969 kernel_lb_addr loc; 1970 uint32_t bytes; 1971 uint8_t *ptr; 1972 uint16_t ident; 1973 struct spaceBitmapDesc *bm; 1974 1975 lock_kernel(); 1976 1977 loc.logicalBlockNum = bitmap->s_extPosition; 1978 loc.partitionReferenceNum = UDF_SB(sb)->s_partition; 1979 bh = udf_read_ptagged(sb, loc, 0, &ident); 1980 1981 if (!bh) { 1982 printk(KERN_ERR "udf: udf_count_free failed\n"); 1983 goto out; 1984 } else if (ident != TAG_IDENT_SBD) { 1985 brelse(bh); 1986 printk(KERN_ERR "udf: udf_count_free failed\n"); 1987 goto out; 1988 } 1989 1990 bm = (struct spaceBitmapDesc *)bh->b_data; 1991 bytes = le32_to_cpu(bm->numOfBytes); 1992 index = sizeof(struct spaceBitmapDesc); /* offset in first block only */ 1993 ptr = (uint8_t *)bh->b_data; 1994 1995 while (bytes > 0) { 1996 u32 cur_bytes = min_t(u32, bytes, sb->s_blocksize - index); 1997 accum += bitmap_weight((const unsigned long *)(ptr + index), 1998 cur_bytes * 8); 1999 bytes -= cur_bytes; 2000 if (bytes) { 2001 brelse(bh); 2002 newblock = udf_get_lb_pblock(sb, loc, ++block); 2003 bh = udf_tread(sb, newblock); 2004 if (!bh) { 2005 udf_debug("read failed\n"); 2006 goto out; 2007 } 2008 index = 0; 2009 ptr = (uint8_t *)bh->b_data; 2010 } 2011 } 2012 brelse(bh); 2013 2014 out: 2015 unlock_kernel(); 2016 2017 return accum; 2018 } 2019 2020 static unsigned int udf_count_free_table(struct super_block *sb, 2021 struct inode *table) 2022 { 2023 unsigned int accum = 0; 2024 uint32_t elen; 2025 kernel_lb_addr eloc; 2026 int8_t etype; 2027 struct extent_position epos; 2028 2029 lock_kernel(); 2030 2031 epos.block = UDF_I(table)->i_location; 2032 epos.offset = sizeof(struct unallocSpaceEntry); 2033 epos.bh = NULL; 2034 2035 while ((etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) 2036 accum += (elen >> table->i_sb->s_blocksize_bits); 2037 2038 brelse(epos.bh); 2039 2040 unlock_kernel(); 2041 2042 return accum; 2043 } 2044 2045 static unsigned int udf_count_free(struct super_block *sb) 2046 { 2047 unsigned int accum = 0; 2048 struct udf_sb_info *sbi; 2049 struct udf_part_map *map; 2050 2051 sbi = UDF_SB(sb); 2052 if (sbi->s_lvid_bh) { 2053 struct logicalVolIntegrityDesc *lvid = 2054 (struct logicalVolIntegrityDesc *) 2055 sbi->s_lvid_bh->b_data; 2056 if (le32_to_cpu(lvid->numOfPartitions) > sbi->s_partition) { 2057 accum = le32_to_cpu( 2058 lvid->freeSpaceTable[sbi->s_partition]); 2059 if (accum == 0xFFFFFFFF) 2060 accum = 0; 2061 } 2062 } 2063 2064 if (accum) 2065 return accum; 2066 2067 map = &sbi->s_partmaps[sbi->s_partition]; 2068 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) { 2069 accum += udf_count_free_bitmap(sb, 2070 map->s_uspace.s_bitmap); 2071 } 2072 if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) { 2073 accum += udf_count_free_bitmap(sb, 2074 map->s_fspace.s_bitmap); 2075 } 2076 if (accum) 2077 return accum; 2078 2079 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) { 2080 accum += udf_count_free_table(sb, 2081 map->s_uspace.s_table); 2082 } 2083 if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) { 2084 accum += udf_count_free_table(sb, 2085 map->s_fspace.s_table); 2086 } 2087 2088 return accum; 2089 } 2090