1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * super.c 4 * 5 * PURPOSE 6 * Super block routines for the OSTA-UDF(tm) filesystem. 7 * 8 * DESCRIPTION 9 * OSTA-UDF(tm) = Optical Storage Technology Association 10 * Universal Disk Format. 11 * 12 * This code is based on version 2.00 of the UDF specification, 13 * and revision 3 of the ECMA 167 standard [equivalent to ISO 13346]. 14 * http://www.osta.org/ 15 * https://www.ecma.ch/ 16 * https://www.iso.org/ 17 * 18 * COPYRIGHT 19 * (C) 1998 Dave Boynton 20 * (C) 1998-2004 Ben Fennema 21 * (C) 2000 Stelias Computing Inc 22 * 23 * HISTORY 24 * 25 * 09/24/98 dgb changed to allow compiling outside of kernel, and 26 * added some debugging. 27 * 10/01/98 dgb updated to allow (some) possibility of compiling w/2.0.34 28 * 10/16/98 attempting some multi-session support 29 * 10/17/98 added freespace count for "df" 30 * 11/11/98 gr added novrs option 31 * 11/26/98 dgb added fileset,anchor mount options 32 * 12/06/98 blf really hosed things royally. vat/sparing support. sequenced 33 * vol descs. rewrote option handling based on isofs 34 * 12/20/98 find the free space bitmap (if it exists) 35 */ 36 37 #include "udfdecl.h" 38 39 #include <linux/blkdev.h> 40 #include <linux/slab.h> 41 #include <linux/kernel.h> 42 #include <linux/module.h> 43 #include <linux/stat.h> 44 #include <linux/cdrom.h> 45 #include <linux/nls.h> 46 #include <linux/vfs.h> 47 #include <linux/vmalloc.h> 48 #include <linux/errno.h> 49 #include <linux/seq_file.h> 50 #include <linux/bitmap.h> 51 #include <linux/crc-itu-t.h> 52 #include <linux/log2.h> 53 #include <asm/byteorder.h> 54 #include <linux/iversion.h> 55 #include <linux/fs_context.h> 56 #include <linux/fs_parser.h> 57 58 #include "udf_sb.h" 59 #include "udf_i.h" 60 61 #include <linux/init.h> 62 #include <linux/uaccess.h> 63 64 enum { 65 VDS_POS_PRIMARY_VOL_DESC, 66 VDS_POS_UNALLOC_SPACE_DESC, 67 VDS_POS_LOGICAL_VOL_DESC, 68 VDS_POS_IMP_USE_VOL_DESC, 69 VDS_POS_LENGTH 70 }; 71 72 #define VSD_FIRST_SECTOR_OFFSET 32768 73 #define VSD_MAX_SECTOR_OFFSET 0x800000 74 75 /* 76 * Maximum number of Terminating Descriptor / Logical Volume Integrity 77 * Descriptor redirections. The chosen numbers are arbitrary - just that we 78 * hopefully don't limit any real use of rewritten inode on write-once media 79 * but avoid looping for too long on corrupted media. 80 */ 81 #define UDF_MAX_TD_NESTING 64 82 #define UDF_MAX_LVID_NESTING 1000 83 84 enum { UDF_MAX_LINKS = 0xffff }; 85 /* 86 * We limit filesize to 4TB. This is arbitrary as the on-disk format supports 87 * more but because the file space is described by a linked list of extents, 88 * each of which can have at most 1GB, the creation and handling of extents 89 * gets unusably slow beyond certain point... 90 */ 91 #define UDF_MAX_FILESIZE (1ULL << 42) 92 93 /* These are the "meat" - everything else is stuffing */ 94 static int udf_fill_super(struct super_block *sb, struct fs_context *fc); 95 static void udf_put_super(struct super_block *); 96 static int udf_sync_fs(struct super_block *, int); 97 static void udf_load_logicalvolint(struct super_block *, struct kernel_extent_ad); 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 dentry *); 103 static int udf_init_fs_context(struct fs_context *fc); 104 static int udf_parse_param(struct fs_context *fc, struct fs_parameter *param); 105 static int udf_reconfigure(struct fs_context *fc); 106 static void udf_free_fc(struct fs_context *fc); 107 static const struct fs_parameter_spec udf_param_spec[]; 108 109 struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu(struct super_block *sb) 110 { 111 struct logicalVolIntegrityDesc *lvid; 112 unsigned int partnum; 113 unsigned int offset; 114 115 if (!UDF_SB(sb)->s_lvid_bh) 116 return NULL; 117 lvid = (struct logicalVolIntegrityDesc *)UDF_SB(sb)->s_lvid_bh->b_data; 118 partnum = le32_to_cpu(lvid->numOfPartitions); 119 /* The offset is to skip freeSpaceTable and sizeTable arrays */ 120 offset = partnum * 2 * sizeof(uint32_t); 121 return (struct logicalVolIntegrityDescImpUse *) 122 (((uint8_t *)(lvid + 1)) + offset); 123 } 124 125 /* UDF filesystem type */ 126 static int udf_get_tree(struct fs_context *fc) 127 { 128 return get_tree_bdev(fc, udf_fill_super); 129 } 130 131 static const struct fs_context_operations udf_context_ops = { 132 .parse_param = udf_parse_param, 133 .get_tree = udf_get_tree, 134 .reconfigure = udf_reconfigure, 135 .free = udf_free_fc, 136 }; 137 138 static struct file_system_type udf_fstype = { 139 .owner = THIS_MODULE, 140 .name = "udf", 141 .kill_sb = kill_block_super, 142 .fs_flags = FS_REQUIRES_DEV, 143 .init_fs_context = udf_init_fs_context, 144 .parameters = udf_param_spec, 145 }; 146 MODULE_ALIAS_FS("udf"); 147 148 static struct kmem_cache *udf_inode_cachep; 149 150 static struct inode *udf_alloc_inode(struct super_block *sb) 151 { 152 struct udf_inode_info *ei; 153 ei = alloc_inode_sb(sb, udf_inode_cachep, GFP_KERNEL); 154 if (!ei) 155 return NULL; 156 157 ei->i_unique = 0; 158 ei->i_lenExtents = 0; 159 ei->i_lenStreams = 0; 160 ei->i_next_alloc_block = 0; 161 ei->i_next_alloc_goal = 0; 162 ei->i_strat4096 = 0; 163 ei->i_streamdir = 0; 164 ei->i_hidden = 0; 165 init_rwsem(&ei->i_data_sem); 166 ei->cached_extent.lstart = -1; 167 spin_lock_init(&ei->i_extent_cache_lock); 168 inode_set_iversion(&ei->vfs_inode, 1); 169 170 return &ei->vfs_inode; 171 } 172 173 static void udf_free_in_core_inode(struct inode *inode) 174 { 175 kmem_cache_free(udf_inode_cachep, UDF_I(inode)); 176 } 177 178 static void init_once(void *foo) 179 { 180 struct udf_inode_info *ei = foo; 181 182 ei->i_data = NULL; 183 inode_init_once(&ei->vfs_inode); 184 } 185 186 static int __init init_inodecache(void) 187 { 188 udf_inode_cachep = kmem_cache_create("udf_inode_cache", 189 sizeof(struct udf_inode_info), 190 0, (SLAB_RECLAIM_ACCOUNT | 191 SLAB_ACCOUNT), 192 init_once); 193 if (!udf_inode_cachep) 194 return -ENOMEM; 195 return 0; 196 } 197 198 static void destroy_inodecache(void) 199 { 200 /* 201 * Make sure all delayed rcu free inodes are flushed before we 202 * destroy cache. 203 */ 204 rcu_barrier(); 205 kmem_cache_destroy(udf_inode_cachep); 206 } 207 208 /* Superblock operations */ 209 static const struct super_operations udf_sb_ops = { 210 .alloc_inode = udf_alloc_inode, 211 .free_inode = udf_free_in_core_inode, 212 .write_inode = udf_write_inode, 213 .evict_inode = udf_evict_inode, 214 .put_super = udf_put_super, 215 .sync_fs = udf_sync_fs, 216 .statfs = udf_statfs, 217 .show_options = udf_show_options, 218 }; 219 220 struct udf_options { 221 unsigned int blocksize; 222 unsigned int session; 223 unsigned int lastblock; 224 unsigned int anchor; 225 unsigned int flags; 226 umode_t umask; 227 kgid_t gid; 228 kuid_t uid; 229 umode_t fmode; 230 umode_t dmode; 231 struct nls_table *nls_map; 232 }; 233 234 /* 235 * UDF has historically preserved prior mount options across 236 * a remount, so copy those here if remounting, otherwise set 237 * initial mount defaults. 238 */ 239 static void udf_init_options(struct fs_context *fc, struct udf_options *uopt) 240 { 241 if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) { 242 struct super_block *sb = fc->root->d_sb; 243 struct udf_sb_info *sbi = UDF_SB(sb); 244 245 uopt->flags = sbi->s_flags; 246 uopt->uid = sbi->s_uid; 247 uopt->gid = sbi->s_gid; 248 uopt->umask = sbi->s_umask; 249 uopt->fmode = sbi->s_fmode; 250 uopt->dmode = sbi->s_dmode; 251 uopt->nls_map = NULL; 252 } else { 253 uopt->flags = (1 << UDF_FLAG_USE_AD_IN_ICB) | 254 (1 << UDF_FLAG_STRICT); 255 /* 256 * By default we'll use overflow[ug]id when UDF 257 * inode [ug]id == -1 258 */ 259 uopt->uid = make_kuid(current_user_ns(), overflowuid); 260 uopt->gid = make_kgid(current_user_ns(), overflowgid); 261 uopt->umask = 0; 262 uopt->fmode = UDF_INVALID_MODE; 263 uopt->dmode = UDF_INVALID_MODE; 264 uopt->nls_map = NULL; 265 uopt->session = 0xFFFFFFFF; 266 } 267 } 268 269 static int udf_init_fs_context(struct fs_context *fc) 270 { 271 struct udf_options *uopt; 272 273 uopt = kzalloc_obj(*uopt, GFP_KERNEL); 274 if (!uopt) 275 return -ENOMEM; 276 277 udf_init_options(fc, uopt); 278 279 fc->fs_private = uopt; 280 fc->ops = &udf_context_ops; 281 282 return 0; 283 } 284 285 static void udf_free_fc(struct fs_context *fc) 286 { 287 struct udf_options *uopt = fc->fs_private; 288 289 unload_nls(uopt->nls_map); 290 kfree(fc->fs_private); 291 } 292 293 static int __init init_udf_fs(void) 294 { 295 int err; 296 297 err = init_inodecache(); 298 if (err) 299 goto out1; 300 err = register_filesystem(&udf_fstype); 301 if (err) 302 goto out; 303 304 return 0; 305 306 out: 307 destroy_inodecache(); 308 309 out1: 310 return err; 311 } 312 313 static void __exit exit_udf_fs(void) 314 { 315 unregister_filesystem(&udf_fstype); 316 destroy_inodecache(); 317 } 318 319 static int udf_sb_alloc_partition_maps(struct super_block *sb, u32 count) 320 { 321 struct udf_sb_info *sbi = UDF_SB(sb); 322 323 sbi->s_partmaps = kzalloc_objs(*sbi->s_partmaps, count, GFP_KERNEL); 324 if (!sbi->s_partmaps) { 325 sbi->s_partitions = 0; 326 return -ENOMEM; 327 } 328 329 sbi->s_partitions = count; 330 return 0; 331 } 332 333 static void udf_sb_free_bitmap(struct udf_bitmap *bitmap) 334 { 335 int i; 336 int nr_groups = bitmap->s_nr_groups; 337 338 for (i = 0; i < nr_groups; i++) 339 if (!IS_ERR_OR_NULL(bitmap->s_block_bitmap[i])) 340 brelse(bitmap->s_block_bitmap[i]); 341 342 kvfree(bitmap); 343 } 344 345 static void udf_free_partition(struct udf_part_map *map) 346 { 347 int i; 348 struct udf_meta_data *mdata; 349 350 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) 351 iput(map->s_uspace.s_table); 352 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) 353 udf_sb_free_bitmap(map->s_uspace.s_bitmap); 354 if (map->s_partition_type == UDF_SPARABLE_MAP15) 355 for (i = 0; i < 4; i++) 356 brelse(map->s_type_specific.s_sparing.s_spar_map[i]); 357 else if (map->s_partition_type == UDF_METADATA_MAP25) { 358 mdata = &map->s_type_specific.s_metadata; 359 iput(mdata->s_metadata_fe); 360 mdata->s_metadata_fe = NULL; 361 362 iput(mdata->s_mirror_fe); 363 mdata->s_mirror_fe = NULL; 364 365 iput(mdata->s_bitmap_fe); 366 mdata->s_bitmap_fe = NULL; 367 } 368 } 369 370 static void udf_sb_free_partitions(struct super_block *sb) 371 { 372 struct udf_sb_info *sbi = UDF_SB(sb); 373 int i; 374 375 if (!sbi->s_partmaps) 376 return; 377 for (i = 0; i < sbi->s_partitions; i++) 378 udf_free_partition(&sbi->s_partmaps[i]); 379 kfree(sbi->s_partmaps); 380 sbi->s_partmaps = NULL; 381 } 382 383 static int udf_show_options(struct seq_file *seq, struct dentry *root) 384 { 385 struct super_block *sb = root->d_sb; 386 struct udf_sb_info *sbi = UDF_SB(sb); 387 388 if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT)) 389 seq_puts(seq, ",nostrict"); 390 if (UDF_QUERY_FLAG(sb, UDF_FLAG_BLOCKSIZE_SET)) 391 seq_printf(seq, ",bs=%lu", sb->s_blocksize); 392 if (UDF_QUERY_FLAG(sb, UDF_FLAG_UNHIDE)) 393 seq_puts(seq, ",unhide"); 394 if (UDF_QUERY_FLAG(sb, UDF_FLAG_UNDELETE)) 395 seq_puts(seq, ",undelete"); 396 if (!UDF_QUERY_FLAG(sb, UDF_FLAG_USE_AD_IN_ICB)) 397 seq_puts(seq, ",noadinicb"); 398 if (UDF_QUERY_FLAG(sb, UDF_FLAG_USE_SHORT_AD)) 399 seq_puts(seq, ",shortad"); 400 if (UDF_QUERY_FLAG(sb, UDF_FLAG_UID_FORGET)) 401 seq_puts(seq, ",uid=forget"); 402 if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_FORGET)) 403 seq_puts(seq, ",gid=forget"); 404 if (UDF_QUERY_FLAG(sb, UDF_FLAG_UID_SET)) 405 seq_printf(seq, ",uid=%u", from_kuid(&init_user_ns, sbi->s_uid)); 406 if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_SET)) 407 seq_printf(seq, ",gid=%u", from_kgid(&init_user_ns, sbi->s_gid)); 408 if (sbi->s_umask != 0) 409 seq_printf(seq, ",umask=%ho", sbi->s_umask); 410 if (sbi->s_fmode != UDF_INVALID_MODE) 411 seq_printf(seq, ",mode=%ho", sbi->s_fmode); 412 if (sbi->s_dmode != UDF_INVALID_MODE) 413 seq_printf(seq, ",dmode=%ho", sbi->s_dmode); 414 if (UDF_QUERY_FLAG(sb, UDF_FLAG_SESSION_SET)) 415 seq_printf(seq, ",session=%d", sbi->s_session); 416 if (UDF_QUERY_FLAG(sb, UDF_FLAG_LASTBLOCK_SET)) 417 seq_printf(seq, ",lastblock=%u", sbi->s_last_block); 418 if (sbi->s_anchor != 0) 419 seq_printf(seq, ",anchor=%u", sbi->s_anchor); 420 if (sbi->s_nls_map) 421 seq_printf(seq, ",iocharset=%s", sbi->s_nls_map->charset); 422 else 423 seq_puts(seq, ",iocharset=utf8"); 424 425 return 0; 426 } 427 428 /* 429 * udf_parse_param 430 * 431 * PURPOSE 432 * Parse mount options. 433 * 434 * DESCRIPTION 435 * The following mount options are supported: 436 * 437 * gid= Set the default group. 438 * umask= Set the default umask. 439 * mode= Set the default file permissions. 440 * dmode= Set the default directory permissions. 441 * uid= Set the default user. 442 * bs= Set the block size. 443 * unhide Show otherwise hidden files. 444 * undelete Show deleted files in lists. 445 * adinicb Embed data in the inode (default) 446 * noadinicb Don't embed data in the inode 447 * shortad Use short ad's 448 * longad Use long ad's (default) 449 * nostrict Unset strict conformance 450 * iocharset= Set the NLS character set 451 * 452 * The remaining are for debugging and disaster recovery: 453 * 454 * novrs Skip volume sequence recognition 455 * 456 * The following expect a offset from 0. 457 * 458 * session= Set the CDROM session (default= last session) 459 * anchor= Override standard anchor location. (default= 256) 460 * volume= Override the VolumeDesc location. (unused) 461 * partition= Override the PartitionDesc location. (unused) 462 * lastblock= Set the last block of the filesystem/ 463 * 464 * The following expect a offset from the partition root. 465 * 466 * fileset= Override the fileset block location. (unused) 467 * rootdir= Override the root directory location. (unused) 468 * WARNING: overriding the rootdir to a non-directory may 469 * yield highly unpredictable results. 470 * 471 * PRE-CONDITIONS 472 * fc fs_context with pointer to mount options variable. 473 * param Pointer to fs_parameter being parsed. 474 * 475 * POST-CONDITIONS 476 * <return> 0 Mount options parsed okay. 477 * <return> errno Error parsing mount options. 478 * 479 * HISTORY 480 * July 1, 1997 - Andrew E. Mileski 481 * Written, tested, and released. 482 */ 483 484 enum { 485 Opt_novrs, Opt_nostrict, Opt_bs, Opt_unhide, Opt_undelete, 486 Opt_noadinicb, Opt_adinicb, Opt_shortad, Opt_longad, 487 Opt_gid, Opt_uid, Opt_umask, Opt_session, Opt_lastblock, 488 Opt_anchor, Opt_volume, Opt_partition, Opt_fileset, 489 Opt_rootdir, Opt_utf8, Opt_iocharset, Opt_err, Opt_fmode, Opt_dmode 490 }; 491 492 static const struct fs_parameter_spec udf_param_spec[] = { 493 fsparam_flag ("novrs", Opt_novrs), 494 fsparam_flag ("nostrict", Opt_nostrict), 495 fsparam_u32 ("bs", Opt_bs), 496 fsparam_flag ("unhide", Opt_unhide), 497 fsparam_flag ("undelete", Opt_undelete), 498 fsparam_flag_no ("adinicb", Opt_adinicb), 499 fsparam_flag ("shortad", Opt_shortad), 500 fsparam_flag ("longad", Opt_longad), 501 fsparam_string ("gid", Opt_gid), 502 fsparam_string ("uid", Opt_uid), 503 fsparam_u32 ("umask", Opt_umask), 504 fsparam_u32 ("session", Opt_session), 505 fsparam_u32 ("lastblock", Opt_lastblock), 506 fsparam_u32 ("anchor", Opt_anchor), 507 fsparam_u32 ("volume", Opt_volume), 508 fsparam_u32 ("partition", Opt_partition), 509 fsparam_u32 ("fileset", Opt_fileset), 510 fsparam_u32 ("rootdir", Opt_rootdir), 511 fsparam_flag ("utf8", Opt_utf8), 512 fsparam_string ("iocharset", Opt_iocharset), 513 fsparam_u32 ("mode", Opt_fmode), 514 fsparam_u32 ("dmode", Opt_dmode), 515 {} 516 }; 517 518 static int udf_parse_param(struct fs_context *fc, struct fs_parameter *param) 519 { 520 unsigned int uv; 521 unsigned int n; 522 struct udf_options *uopt = fc->fs_private; 523 struct fs_parse_result result; 524 int token; 525 bool remount = (fc->purpose & FS_CONTEXT_FOR_RECONFIGURE); 526 527 token = fs_parse(fc, udf_param_spec, param, &result); 528 if (token < 0) 529 return token; 530 531 switch (token) { 532 case Opt_novrs: 533 uopt->flags |= (1 << UDF_FLAG_NOVRS); 534 break; 535 case Opt_bs: 536 n = result.uint_32; 537 if (n != 512 && n != 1024 && n != 2048 && n != 4096) 538 return -EINVAL; 539 uopt->blocksize = n; 540 uopt->flags |= (1 << UDF_FLAG_BLOCKSIZE_SET); 541 break; 542 case Opt_unhide: 543 uopt->flags |= (1 << UDF_FLAG_UNHIDE); 544 break; 545 case Opt_undelete: 546 uopt->flags |= (1 << UDF_FLAG_UNDELETE); 547 break; 548 case Opt_adinicb: 549 if (result.negated) 550 uopt->flags &= ~(1 << UDF_FLAG_USE_AD_IN_ICB); 551 else 552 uopt->flags |= (1 << UDF_FLAG_USE_AD_IN_ICB); 553 break; 554 case Opt_shortad: 555 uopt->flags |= (1 << UDF_FLAG_USE_SHORT_AD); 556 break; 557 case Opt_longad: 558 uopt->flags &= ~(1 << UDF_FLAG_USE_SHORT_AD); 559 break; 560 case Opt_gid: 561 if (kstrtoint(param->string, 10, &uv) == 0) { 562 kgid_t gid = make_kgid(current_user_ns(), uv); 563 if (!gid_valid(gid)) 564 return -EINVAL; 565 uopt->gid = gid; 566 uopt->flags |= (1 << UDF_FLAG_GID_SET); 567 } else if (!strcmp(param->string, "forget")) { 568 uopt->flags |= (1 << UDF_FLAG_GID_FORGET); 569 } else if (!strcmp(param->string, "ignore")) { 570 /* this option is superseded by gid=<number> */ 571 ; 572 } else { 573 return -EINVAL; 574 } 575 break; 576 case Opt_uid: 577 if (kstrtoint(param->string, 10, &uv) == 0) { 578 kuid_t uid = make_kuid(current_user_ns(), uv); 579 if (!uid_valid(uid)) 580 return -EINVAL; 581 uopt->uid = uid; 582 uopt->flags |= (1 << UDF_FLAG_UID_SET); 583 } else if (!strcmp(param->string, "forget")) { 584 uopt->flags |= (1 << UDF_FLAG_UID_FORGET); 585 } else if (!strcmp(param->string, "ignore")) { 586 /* this option is superseded by uid=<number> */ 587 ; 588 } else { 589 return -EINVAL; 590 } 591 break; 592 case Opt_umask: 593 uopt->umask = result.uint_32; 594 break; 595 case Opt_nostrict: 596 uopt->flags &= ~(1 << UDF_FLAG_STRICT); 597 break; 598 case Opt_session: 599 uopt->session = result.uint_32; 600 if (!remount) 601 uopt->flags |= (1 << UDF_FLAG_SESSION_SET); 602 break; 603 case Opt_lastblock: 604 uopt->lastblock = result.uint_32; 605 if (!remount) 606 uopt->flags |= (1 << UDF_FLAG_LASTBLOCK_SET); 607 break; 608 case Opt_anchor: 609 uopt->anchor = result.uint_32; 610 break; 611 case Opt_volume: 612 case Opt_partition: 613 case Opt_fileset: 614 case Opt_rootdir: 615 /* Ignored (never implemented properly) */ 616 break; 617 case Opt_utf8: 618 if (!remount) { 619 unload_nls(uopt->nls_map); 620 uopt->nls_map = NULL; 621 } 622 break; 623 case Opt_iocharset: 624 if (!remount) { 625 unload_nls(uopt->nls_map); 626 uopt->nls_map = NULL; 627 } 628 /* When nls_map is not loaded then UTF-8 is used */ 629 if (!remount && strcmp(param->string, "utf8") != 0) { 630 uopt->nls_map = load_nls(param->string); 631 if (!uopt->nls_map) { 632 errorf(fc, "iocharset %s not found", 633 param->string); 634 return -EINVAL; 635 } 636 } 637 break; 638 case Opt_fmode: 639 uopt->fmode = result.uint_32 & 0777; 640 break; 641 case Opt_dmode: 642 uopt->dmode = result.uint_32 & 0777; 643 break; 644 default: 645 return -EINVAL; 646 } 647 return 0; 648 } 649 650 static int udf_reconfigure(struct fs_context *fc) 651 { 652 struct udf_options *uopt = fc->fs_private; 653 struct super_block *sb = fc->root->d_sb; 654 struct udf_sb_info *sbi = UDF_SB(sb); 655 int readonly = fc->sb_flags & SB_RDONLY; 656 int error = 0; 657 658 if (!readonly && UDF_QUERY_FLAG(sb, UDF_FLAG_RW_INCOMPAT)) 659 return -EACCES; 660 661 sync_filesystem(sb); 662 663 write_lock(&sbi->s_cred_lock); 664 sbi->s_flags = uopt->flags; 665 sbi->s_uid = uopt->uid; 666 sbi->s_gid = uopt->gid; 667 sbi->s_umask = uopt->umask; 668 sbi->s_fmode = uopt->fmode; 669 sbi->s_dmode = uopt->dmode; 670 write_unlock(&sbi->s_cred_lock); 671 672 if (readonly == sb_rdonly(sb)) 673 goto out_unlock; 674 675 if (readonly) 676 udf_close_lvid(sb); 677 else 678 udf_open_lvid(sb); 679 680 out_unlock: 681 return error; 682 } 683 684 /* 685 * Check VSD descriptor. Returns -1 in case we are at the end of volume 686 * recognition area, 0 if the descriptor is valid but non-interesting, 1 if 687 * we found one of NSR descriptors we are looking for. 688 */ 689 static int identify_vsd(const struct volStructDesc *vsd) 690 { 691 int ret = 0; 692 693 if (!memcmp(vsd->stdIdent, VSD_STD_ID_CD001, VSD_STD_ID_LEN)) { 694 switch (vsd->structType) { 695 case 0: 696 udf_debug("ISO9660 Boot Record found\n"); 697 break; 698 case 1: 699 udf_debug("ISO9660 Primary Volume Descriptor found\n"); 700 break; 701 case 2: 702 udf_debug("ISO9660 Supplementary Volume Descriptor found\n"); 703 break; 704 case 3: 705 udf_debug("ISO9660 Volume Partition Descriptor found\n"); 706 break; 707 case 255: 708 udf_debug("ISO9660 Volume Descriptor Set Terminator found\n"); 709 break; 710 default: 711 udf_debug("ISO9660 VRS (%u) found\n", vsd->structType); 712 break; 713 } 714 } else if (!memcmp(vsd->stdIdent, VSD_STD_ID_BEA01, VSD_STD_ID_LEN)) 715 ; /* ret = 0 */ 716 else if (!memcmp(vsd->stdIdent, VSD_STD_ID_NSR02, VSD_STD_ID_LEN)) 717 ret = 1; 718 else if (!memcmp(vsd->stdIdent, VSD_STD_ID_NSR03, VSD_STD_ID_LEN)) 719 ret = 1; 720 else if (!memcmp(vsd->stdIdent, VSD_STD_ID_BOOT2, VSD_STD_ID_LEN)) 721 ; /* ret = 0 */ 722 else if (!memcmp(vsd->stdIdent, VSD_STD_ID_CDW02, VSD_STD_ID_LEN)) 723 ; /* ret = 0 */ 724 else { 725 /* TEA01 or invalid id : end of volume recognition area */ 726 ret = -1; 727 } 728 729 return ret; 730 } 731 732 /* 733 * Check Volume Structure Descriptors (ECMA 167 2/9.1) 734 * We also check any "CD-ROM Volume Descriptor Set" (ECMA 167 2/8.3.1) 735 * @return 1 if NSR02 or NSR03 found, 736 * -1 if first sector read error, 0 otherwise 737 */ 738 static int udf_check_vsd(struct super_block *sb) 739 { 740 struct volStructDesc *vsd = NULL; 741 loff_t sector = VSD_FIRST_SECTOR_OFFSET; 742 int sectorsize; 743 struct buffer_head *bh = NULL; 744 int nsr = 0; 745 struct udf_sb_info *sbi; 746 loff_t session_offset; 747 748 sbi = UDF_SB(sb); 749 if (sb->s_blocksize < sizeof(struct volStructDesc)) 750 sectorsize = sizeof(struct volStructDesc); 751 else 752 sectorsize = sb->s_blocksize; 753 754 session_offset = (loff_t)sbi->s_session << sb->s_blocksize_bits; 755 sector += session_offset; 756 757 udf_debug("Starting at sector %u (%lu byte sectors)\n", 758 (unsigned int)(sector >> sb->s_blocksize_bits), 759 sb->s_blocksize); 760 /* Process the sequence (if applicable). The hard limit on the sector 761 * offset is arbitrary, hopefully large enough so that all valid UDF 762 * filesystems will be recognised. There is no mention of an upper 763 * bound to the size of the volume recognition area in the standard. 764 * The limit will prevent the code to read all the sectors of a 765 * specially crafted image (like a bluray disc full of CD001 sectors), 766 * potentially causing minutes or even hours of uninterruptible I/O 767 * activity. This actually happened with uninitialised SSD partitions 768 * (all 0xFF) before the check for the limit and all valid IDs were 769 * added */ 770 for (; !nsr && sector < VSD_MAX_SECTOR_OFFSET; sector += sectorsize) { 771 /* Read a block */ 772 bh = sb_bread(sb, sector >> sb->s_blocksize_bits); 773 if (!bh) 774 break; 775 776 vsd = (struct volStructDesc *)(bh->b_data + 777 (sector & (sb->s_blocksize - 1))); 778 nsr = identify_vsd(vsd); 779 /* Found NSR or end? */ 780 if (nsr) { 781 brelse(bh); 782 break; 783 } 784 /* 785 * Special handling for improperly formatted VRS (e.g., Win10) 786 * where components are separated by 2048 bytes even though 787 * sectors are 4K 788 */ 789 if (sb->s_blocksize == 4096) { 790 nsr = identify_vsd(vsd + 1); 791 /* Ignore unknown IDs... */ 792 if (nsr < 0) 793 nsr = 0; 794 } 795 brelse(bh); 796 } 797 798 if (nsr > 0) 799 return 1; 800 else if (!bh && sector - session_offset == VSD_FIRST_SECTOR_OFFSET) 801 return -1; 802 else 803 return 0; 804 } 805 806 static int udf_verify_domain_identifier(struct super_block *sb, 807 struct regid *ident, char *dname) 808 { 809 struct domainIdentSuffix *suffix; 810 811 if (memcmp(ident->ident, UDF_ID_COMPLIANT, strlen(UDF_ID_COMPLIANT))) { 812 udf_warn(sb, "Not OSTA UDF compliant %s descriptor.\n", dname); 813 goto force_ro; 814 } 815 if (ident->flags & ENTITYID_FLAGS_DIRTY) { 816 udf_warn(sb, "Possibly not OSTA UDF compliant %s descriptor.\n", 817 dname); 818 goto force_ro; 819 } 820 suffix = (struct domainIdentSuffix *)ident->identSuffix; 821 if ((suffix->domainFlags & DOMAIN_FLAGS_HARD_WRITE_PROTECT) || 822 (suffix->domainFlags & DOMAIN_FLAGS_SOFT_WRITE_PROTECT)) { 823 if (!sb_rdonly(sb)) { 824 udf_warn(sb, "Descriptor for %s marked write protected." 825 " Forcing read only mount.\n", dname); 826 } 827 goto force_ro; 828 } 829 return 0; 830 831 force_ro: 832 if (!sb_rdonly(sb)) 833 return -EACCES; 834 UDF_SET_FLAG(sb, UDF_FLAG_RW_INCOMPAT); 835 return 0; 836 } 837 838 static int udf_load_fileset(struct super_block *sb, struct fileSetDesc *fset, 839 struct kernel_lb_addr *root) 840 { 841 int ret; 842 843 ret = udf_verify_domain_identifier(sb, &fset->domainIdent, "file set"); 844 if (ret < 0) 845 return ret; 846 847 *root = lelb_to_cpu(fset->rootDirectoryICB.extLocation); 848 UDF_SB(sb)->s_serial_number = le16_to_cpu(fset->descTag.tagSerialNum); 849 850 udf_debug("Rootdir at block=%u, partition=%u\n", 851 root->logicalBlockNum, root->partitionReferenceNum); 852 return 0; 853 } 854 855 static int udf_find_fileset(struct super_block *sb, 856 struct kernel_lb_addr *fileset, 857 struct kernel_lb_addr *root) 858 { 859 struct buffer_head *bh; 860 uint16_t ident; 861 int ret; 862 863 if (fileset->logicalBlockNum == 0xFFFFFFFF && 864 fileset->partitionReferenceNum == 0xFFFF) 865 return -EINVAL; 866 867 bh = udf_read_ptagged(sb, fileset, 0, &ident); 868 if (!bh) 869 return -EIO; 870 if (ident != TAG_IDENT_FSD) { 871 brelse(bh); 872 return -EINVAL; 873 } 874 875 udf_debug("Fileset at block=%u, partition=%u\n", 876 fileset->logicalBlockNum, fileset->partitionReferenceNum); 877 878 UDF_SB(sb)->s_partition = fileset->partitionReferenceNum; 879 ret = udf_load_fileset(sb, (struct fileSetDesc *)bh->b_data, root); 880 brelse(bh); 881 return ret; 882 } 883 884 /* 885 * Load primary Volume Descriptor Sequence 886 * 887 * Return <0 on error, 0 on success. -EAGAIN is special meaning next sequence 888 * should be tried. 889 */ 890 static int udf_load_pvoldesc(struct super_block *sb, sector_t block) 891 { 892 struct primaryVolDesc *pvoldesc; 893 uint8_t *outstr; 894 struct buffer_head *bh; 895 uint16_t ident; 896 int ret; 897 struct timestamp *ts; 898 899 outstr = kzalloc(128, GFP_KERNEL); 900 if (!outstr) 901 return -ENOMEM; 902 903 bh = udf_read_tagged(sb, block, block, &ident); 904 if (!bh) { 905 ret = -EAGAIN; 906 goto out2; 907 } 908 909 if (ident != TAG_IDENT_PVD) { 910 ret = -EIO; 911 goto out_bh; 912 } 913 914 pvoldesc = (struct primaryVolDesc *)bh->b_data; 915 916 udf_disk_stamp_to_time(&UDF_SB(sb)->s_record_time, 917 pvoldesc->recordingDateAndTime); 918 ts = &pvoldesc->recordingDateAndTime; 919 udf_debug("recording time %04u/%02u/%02u %02u:%02u (%x)\n", 920 le16_to_cpu(ts->year), ts->month, ts->day, ts->hour, 921 ts->minute, le16_to_cpu(ts->typeAndTimezone)); 922 923 ret = udf_dstrCS0toChar(sb, outstr, 31, pvoldesc->volIdent, 32); 924 if (ret < 0) { 925 strscpy_pad(UDF_SB(sb)->s_volume_ident, "InvalidName"); 926 pr_warn("incorrect volume identification, setting to " 927 "'InvalidName'\n"); 928 } else { 929 strscpy_pad(UDF_SB(sb)->s_volume_ident, outstr); 930 } 931 udf_debug("volIdent[] = '%s'\n", UDF_SB(sb)->s_volume_ident); 932 933 ret = udf_dstrCS0toChar(sb, outstr, 127, pvoldesc->volSetIdent, 128); 934 if (ret < 0) { 935 ret = 0; 936 goto out_bh; 937 } 938 outstr[ret] = 0; 939 udf_debug("volSetIdent[] = '%s'\n", outstr); 940 941 ret = 0; 942 out_bh: 943 brelse(bh); 944 out2: 945 kfree(outstr); 946 return ret; 947 } 948 949 struct inode *udf_find_metadata_inode_efe(struct super_block *sb, 950 u32 meta_file_loc, u32 partition_ref) 951 { 952 struct kernel_lb_addr addr; 953 struct inode *metadata_fe; 954 955 addr.logicalBlockNum = meta_file_loc; 956 addr.partitionReferenceNum = partition_ref; 957 958 metadata_fe = udf_iget_special(sb, &addr); 959 960 if (IS_ERR(metadata_fe)) { 961 udf_warn(sb, "metadata inode efe not found\n"); 962 return metadata_fe; 963 } 964 if (UDF_I(metadata_fe)->i_alloc_type != ICBTAG_FLAG_AD_SHORT) { 965 udf_warn(sb, "metadata inode efe does not have short allocation descriptors!\n"); 966 iput(metadata_fe); 967 return ERR_PTR(-EIO); 968 } 969 970 return metadata_fe; 971 } 972 973 static int udf_load_metadata_files(struct super_block *sb, int partition, 974 int type1_index) 975 { 976 struct udf_sb_info *sbi = UDF_SB(sb); 977 struct udf_part_map *map; 978 struct udf_meta_data *mdata; 979 struct kernel_lb_addr addr; 980 struct inode *fe; 981 982 map = &sbi->s_partmaps[partition]; 983 mdata = &map->s_type_specific.s_metadata; 984 mdata->s_phys_partition_ref = type1_index; 985 986 /* metadata address */ 987 udf_debug("Metadata file location: block = %u part = %u\n", 988 mdata->s_meta_file_loc, mdata->s_phys_partition_ref); 989 990 fe = udf_find_metadata_inode_efe(sb, mdata->s_meta_file_loc, 991 mdata->s_phys_partition_ref); 992 if (IS_ERR(fe)) { 993 /* mirror file entry */ 994 udf_debug("Mirror metadata file location: block = %u part = %u\n", 995 mdata->s_mirror_file_loc, mdata->s_phys_partition_ref); 996 997 fe = udf_find_metadata_inode_efe(sb, mdata->s_mirror_file_loc, 998 mdata->s_phys_partition_ref); 999 1000 if (IS_ERR(fe)) { 1001 udf_err(sb, "Both metadata and mirror metadata inode efe can not found\n"); 1002 return PTR_ERR(fe); 1003 } 1004 mdata->s_mirror_fe = fe; 1005 } else 1006 mdata->s_metadata_fe = fe; 1007 1008 1009 /* 1010 * bitmap file entry 1011 * Note: 1012 * Load only if bitmap file location differs from 0xFFFFFFFF (DCN-5102) 1013 */ 1014 if (mdata->s_bitmap_file_loc != 0xFFFFFFFF) { 1015 addr.logicalBlockNum = mdata->s_bitmap_file_loc; 1016 addr.partitionReferenceNum = mdata->s_phys_partition_ref; 1017 1018 udf_debug("Bitmap file location: block = %u part = %u\n", 1019 addr.logicalBlockNum, addr.partitionReferenceNum); 1020 1021 fe = udf_iget_special(sb, &addr); 1022 if (IS_ERR(fe)) { 1023 if (sb_rdonly(sb)) 1024 udf_warn(sb, "bitmap inode efe not found but it's ok since the disc is mounted read-only\n"); 1025 else { 1026 udf_err(sb, "bitmap inode efe not found and attempted read-write mount\n"); 1027 return PTR_ERR(fe); 1028 } 1029 } else 1030 mdata->s_bitmap_fe = fe; 1031 } 1032 1033 udf_debug("udf_load_metadata_files Ok\n"); 1034 return 0; 1035 } 1036 1037 int udf_compute_nr_groups(struct super_block *sb, u32 partition) 1038 { 1039 struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition]; 1040 return DIV_ROUND_UP(map->s_partition_len + 1041 (sizeof(struct spaceBitmapDesc) << 3), 1042 sb->s_blocksize * 8); 1043 } 1044 1045 static struct udf_bitmap *udf_sb_alloc_bitmap(struct super_block *sb, u32 index) 1046 { 1047 struct udf_bitmap *bitmap; 1048 int nr_groups = udf_compute_nr_groups(sb, index); 1049 1050 bitmap = kvzalloc_flex(*bitmap, s_block_bitmap, nr_groups, GFP_KERNEL); 1051 if (!bitmap) 1052 return NULL; 1053 1054 bitmap->s_nr_groups = nr_groups; 1055 return bitmap; 1056 } 1057 1058 static int check_partition_desc(struct super_block *sb, 1059 struct partitionDesc *p, 1060 struct udf_part_map *map) 1061 { 1062 bool umap, utable, fmap, ftable; 1063 struct partitionHeaderDesc *phd; 1064 1065 switch (le32_to_cpu(p->accessType)) { 1066 case PD_ACCESS_TYPE_READ_ONLY: 1067 case PD_ACCESS_TYPE_WRITE_ONCE: 1068 case PD_ACCESS_TYPE_NONE: 1069 goto force_ro; 1070 } 1071 1072 /* No Partition Header Descriptor? */ 1073 if (strcmp(p->partitionContents.ident, PD_PARTITION_CONTENTS_NSR02) && 1074 strcmp(p->partitionContents.ident, PD_PARTITION_CONTENTS_NSR03)) 1075 goto force_ro; 1076 1077 phd = (struct partitionHeaderDesc *)p->partitionContentsUse; 1078 utable = phd->unallocSpaceTable.extLength; 1079 umap = phd->unallocSpaceBitmap.extLength; 1080 ftable = phd->freedSpaceTable.extLength; 1081 fmap = phd->freedSpaceBitmap.extLength; 1082 1083 /* No allocation info? */ 1084 if (!utable && !umap && !ftable && !fmap) 1085 goto force_ro; 1086 1087 /* We don't support blocks that require erasing before overwrite */ 1088 if (ftable || fmap) 1089 goto force_ro; 1090 /* UDF 2.60: 2.3.3 - no mixing of tables & bitmaps, no VAT. */ 1091 if (utable && umap) 1092 goto force_ro; 1093 1094 if (map->s_partition_type == UDF_VIRTUAL_MAP15 || 1095 map->s_partition_type == UDF_VIRTUAL_MAP20 || 1096 map->s_partition_type == UDF_METADATA_MAP25) 1097 goto force_ro; 1098 1099 return 0; 1100 force_ro: 1101 if (!sb_rdonly(sb)) 1102 return -EACCES; 1103 UDF_SET_FLAG(sb, UDF_FLAG_RW_INCOMPAT); 1104 return 0; 1105 } 1106 1107 static int udf_fill_partdesc_info(struct super_block *sb, 1108 struct partitionDesc *p, int p_index) 1109 { 1110 struct udf_part_map *map; 1111 struct udf_sb_info *sbi = UDF_SB(sb); 1112 struct partitionHeaderDesc *phd; 1113 u32 sum; 1114 int err; 1115 1116 map = &sbi->s_partmaps[p_index]; 1117 1118 map->s_partition_len = le32_to_cpu(p->partitionLength); /* blocks */ 1119 map->s_partition_root = le32_to_cpu(p->partitionStartingLocation); 1120 if (check_add_overflow(map->s_partition_root, map->s_partition_len, 1121 &sum)) { 1122 udf_err(sb, "Partition %d has invalid location %u + %u\n", 1123 p_index, map->s_partition_root, map->s_partition_len); 1124 return -EFSCORRUPTED; 1125 } 1126 1127 if (p->accessType == cpu_to_le32(PD_ACCESS_TYPE_READ_ONLY)) 1128 map->s_partition_flags |= UDF_PART_FLAG_READ_ONLY; 1129 if (p->accessType == cpu_to_le32(PD_ACCESS_TYPE_WRITE_ONCE)) 1130 map->s_partition_flags |= UDF_PART_FLAG_WRITE_ONCE; 1131 if (p->accessType == cpu_to_le32(PD_ACCESS_TYPE_REWRITABLE)) 1132 map->s_partition_flags |= UDF_PART_FLAG_REWRITABLE; 1133 if (p->accessType == cpu_to_le32(PD_ACCESS_TYPE_OVERWRITABLE)) 1134 map->s_partition_flags |= UDF_PART_FLAG_OVERWRITABLE; 1135 1136 udf_debug("Partition (%d type %x) starts at physical %u, block length %u\n", 1137 p_index, map->s_partition_type, 1138 map->s_partition_root, map->s_partition_len); 1139 1140 err = check_partition_desc(sb, p, map); 1141 if (err) 1142 return err; 1143 1144 /* 1145 * Skip loading allocation info it we cannot ever write to the fs. 1146 * This is a correctness thing as we may have decided to force ro mount 1147 * to avoid allocation info we don't support. 1148 */ 1149 if (UDF_QUERY_FLAG(sb, UDF_FLAG_RW_INCOMPAT)) 1150 return 0; 1151 1152 phd = (struct partitionHeaderDesc *)p->partitionContentsUse; 1153 if (phd->unallocSpaceTable.extLength) { 1154 struct kernel_lb_addr loc = { 1155 .logicalBlockNum = le32_to_cpu( 1156 phd->unallocSpaceTable.extPosition), 1157 .partitionReferenceNum = p_index, 1158 }; 1159 struct inode *inode; 1160 1161 inode = udf_iget_special(sb, &loc); 1162 if (IS_ERR(inode)) { 1163 udf_debug("cannot load unallocSpaceTable (part %d)\n", 1164 p_index); 1165 return PTR_ERR(inode); 1166 } 1167 map->s_uspace.s_table = inode; 1168 map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_TABLE; 1169 udf_debug("unallocSpaceTable (part %d) @ %lu\n", 1170 p_index, map->s_uspace.s_table->i_ino); 1171 } 1172 1173 if (phd->unallocSpaceBitmap.extLength) { 1174 struct udf_bitmap *bitmap = udf_sb_alloc_bitmap(sb, p_index); 1175 if (!bitmap) 1176 return -ENOMEM; 1177 map->s_uspace.s_bitmap = bitmap; 1178 bitmap->s_extPosition = le32_to_cpu( 1179 phd->unallocSpaceBitmap.extPosition); 1180 map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_BITMAP; 1181 /* Check whether math over bitmap won't overflow. */ 1182 if (check_add_overflow(map->s_partition_len, 1183 sizeof(struct spaceBitmapDesc) << 3, 1184 &sum)) { 1185 udf_err(sb, "Partition %d is too long (%u)\n", p_index, 1186 map->s_partition_len); 1187 return -EFSCORRUPTED; 1188 } 1189 udf_debug("unallocSpaceBitmap (part %d) @ %u\n", 1190 p_index, bitmap->s_extPosition); 1191 } 1192 1193 return 0; 1194 } 1195 1196 static void udf_find_vat_block(struct super_block *sb, int p_index, 1197 int type1_index, sector_t start_block) 1198 { 1199 struct udf_sb_info *sbi = UDF_SB(sb); 1200 struct udf_part_map *map = &sbi->s_partmaps[p_index]; 1201 sector_t vat_block; 1202 struct kernel_lb_addr ino; 1203 struct inode *inode; 1204 1205 /* 1206 * VAT file entry is in the last recorded block. Some broken disks have 1207 * it a few blocks before so try a bit harder... 1208 */ 1209 ino.partitionReferenceNum = type1_index; 1210 for (vat_block = start_block; 1211 vat_block >= map->s_partition_root && 1212 vat_block >= start_block - 3; vat_block--) { 1213 ino.logicalBlockNum = vat_block - map->s_partition_root; 1214 inode = udf_iget_special(sb, &ino); 1215 if (!IS_ERR(inode)) { 1216 sbi->s_vat_inode = inode; 1217 break; 1218 } 1219 } 1220 } 1221 1222 static int udf_load_vat(struct super_block *sb, int p_index, int type1_index) 1223 { 1224 struct udf_sb_info *sbi = UDF_SB(sb); 1225 struct udf_part_map *map = &sbi->s_partmaps[p_index]; 1226 struct buffer_head *bh = NULL; 1227 struct udf_inode_info *vati; 1228 struct virtualAllocationTable20 *vat20; 1229 sector_t blocks = sb_bdev_nr_blocks(sb); 1230 1231 udf_find_vat_block(sb, p_index, type1_index, sbi->s_last_block); 1232 if (!sbi->s_vat_inode && 1233 sbi->s_last_block != blocks - 1) { 1234 pr_notice("Failed to read VAT inode from the last recorded block (%lu), retrying with the last block of the device (%lu).\n", 1235 (unsigned long)sbi->s_last_block, 1236 (unsigned long)blocks - 1); 1237 udf_find_vat_block(sb, p_index, type1_index, blocks - 1); 1238 } 1239 if (!sbi->s_vat_inode) 1240 return -EIO; 1241 1242 if (map->s_partition_type == UDF_VIRTUAL_MAP15) { 1243 map->s_type_specific.s_virtual.s_start_offset = 0; 1244 map->s_type_specific.s_virtual.s_num_entries = 1245 (sbi->s_vat_inode->i_size - 36) >> 2; 1246 } else if (map->s_partition_type == UDF_VIRTUAL_MAP20) { 1247 vati = UDF_I(sbi->s_vat_inode); 1248 if (vati->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) { 1249 int err = 0; 1250 1251 bh = udf_bread(sbi->s_vat_inode, 0, 0, &err); 1252 if (!bh) { 1253 if (!err) 1254 err = -EFSCORRUPTED; 1255 return err; 1256 } 1257 vat20 = (struct virtualAllocationTable20 *)bh->b_data; 1258 } else { 1259 vat20 = (struct virtualAllocationTable20 *) 1260 vati->i_data; 1261 } 1262 1263 map->s_type_specific.s_virtual.s_start_offset = 1264 le16_to_cpu(vat20->lengthHeader); 1265 map->s_type_specific.s_virtual.s_num_entries = 1266 (sbi->s_vat_inode->i_size - 1267 map->s_type_specific.s_virtual. 1268 s_start_offset) >> 2; 1269 brelse(bh); 1270 } 1271 return 0; 1272 } 1273 1274 /* 1275 * Load partition descriptor block 1276 * 1277 * Returns <0 on error, 0 on success, -EAGAIN is special - try next descriptor 1278 * sequence. 1279 */ 1280 static int udf_load_partdesc(struct super_block *sb, sector_t block) 1281 { 1282 struct buffer_head *bh; 1283 struct partitionDesc *p; 1284 struct udf_part_map *map; 1285 struct udf_sb_info *sbi = UDF_SB(sb); 1286 int i, type1_idx; 1287 uint16_t partitionNumber; 1288 uint16_t ident; 1289 int ret; 1290 1291 bh = udf_read_tagged(sb, block, block, &ident); 1292 if (!bh) 1293 return -EAGAIN; 1294 if (ident != TAG_IDENT_PD) { 1295 ret = 0; 1296 goto out_bh; 1297 } 1298 1299 p = (struct partitionDesc *)bh->b_data; 1300 partitionNumber = le16_to_cpu(p->partitionNumber); 1301 1302 /* First scan for TYPE1 and SPARABLE partitions */ 1303 for (i = 0; i < sbi->s_partitions; i++) { 1304 map = &sbi->s_partmaps[i]; 1305 udf_debug("Searching map: (%u == %u)\n", 1306 map->s_partition_num, partitionNumber); 1307 if (map->s_partition_num == partitionNumber && 1308 (map->s_partition_type == UDF_TYPE1_MAP15 || 1309 map->s_partition_type == UDF_SPARABLE_MAP15)) 1310 break; 1311 } 1312 1313 if (i >= sbi->s_partitions) { 1314 udf_debug("Partition (%u) not found in partition map\n", 1315 partitionNumber); 1316 ret = 0; 1317 goto out_bh; 1318 } 1319 1320 ret = udf_fill_partdesc_info(sb, p, i); 1321 if (ret < 0) 1322 goto out_bh; 1323 1324 /* 1325 * Now rescan for VIRTUAL or METADATA partitions when SPARABLE and 1326 * PHYSICAL partitions are already set up 1327 */ 1328 type1_idx = i; 1329 map = NULL; /* supress 'maybe used uninitialized' warning */ 1330 for (i = 0; i < sbi->s_partitions; i++) { 1331 map = &sbi->s_partmaps[i]; 1332 1333 if (map->s_partition_num == partitionNumber && 1334 (map->s_partition_type == UDF_VIRTUAL_MAP15 || 1335 map->s_partition_type == UDF_VIRTUAL_MAP20 || 1336 map->s_partition_type == UDF_METADATA_MAP25)) 1337 break; 1338 } 1339 1340 if (i >= sbi->s_partitions) { 1341 ret = 0; 1342 goto out_bh; 1343 } 1344 1345 ret = udf_fill_partdesc_info(sb, p, i); 1346 if (ret < 0) 1347 goto out_bh; 1348 1349 if (map->s_partition_type == UDF_METADATA_MAP25) { 1350 ret = udf_load_metadata_files(sb, i, type1_idx); 1351 if (ret < 0) { 1352 udf_err(sb, "error loading MetaData partition map %d\n", 1353 i); 1354 goto out_bh; 1355 } 1356 } else { 1357 /* 1358 * If we have a partition with virtual map, we don't handle 1359 * writing to it (we overwrite blocks instead of relocating 1360 * them). 1361 */ 1362 if (!sb_rdonly(sb)) { 1363 ret = -EACCES; 1364 goto out_bh; 1365 } 1366 UDF_SET_FLAG(sb, UDF_FLAG_RW_INCOMPAT); 1367 ret = udf_load_vat(sb, i, type1_idx); 1368 if (ret < 0) 1369 goto out_bh; 1370 } 1371 ret = 0; 1372 out_bh: 1373 /* In case loading failed, we handle cleanup in udf_fill_super */ 1374 brelse(bh); 1375 return ret; 1376 } 1377 1378 static int udf_load_sparable_map(struct super_block *sb, 1379 struct udf_part_map *map, 1380 struct sparablePartitionMap *spm) 1381 { 1382 uint32_t loc; 1383 uint16_t ident; 1384 struct sparingTable *st; 1385 struct udf_sparing_data *sdata = &map->s_type_specific.s_sparing; 1386 int i; 1387 struct buffer_head *bh; 1388 1389 map->s_partition_type = UDF_SPARABLE_MAP15; 1390 sdata->s_packet_len = le16_to_cpu(spm->packetLength); 1391 if (!is_power_of_2(sdata->s_packet_len)) { 1392 udf_err(sb, "error loading logical volume descriptor: " 1393 "Invalid packet length %u\n", 1394 (unsigned)sdata->s_packet_len); 1395 return -EIO; 1396 } 1397 if (spm->numSparingTables > 4) { 1398 udf_err(sb, "error loading logical volume descriptor: " 1399 "Too many sparing tables (%d)\n", 1400 (int)spm->numSparingTables); 1401 return -EIO; 1402 } 1403 if (le32_to_cpu(spm->sizeSparingTable) > sb->s_blocksize) { 1404 udf_err(sb, "error loading logical volume descriptor: " 1405 "Too big sparing table size (%u)\n", 1406 le32_to_cpu(spm->sizeSparingTable)); 1407 return -EIO; 1408 } 1409 1410 for (i = 0; i < spm->numSparingTables; i++) { 1411 loc = le32_to_cpu(spm->locSparingTable[i]); 1412 bh = udf_read_tagged(sb, loc, loc, &ident); 1413 if (!bh) 1414 continue; 1415 1416 st = (struct sparingTable *)bh->b_data; 1417 if (ident != 0 || 1418 strncmp(st->sparingIdent.ident, UDF_ID_SPARING, 1419 strlen(UDF_ID_SPARING)) || 1420 sizeof(*st) + le16_to_cpu(st->reallocationTableLen) > 1421 sb->s_blocksize) { 1422 brelse(bh); 1423 continue; 1424 } 1425 1426 sdata->s_spar_map[i] = bh; 1427 } 1428 map->s_partition_func = udf_get_pblock_spar15; 1429 return 0; 1430 } 1431 1432 static int udf_load_logicalvol(struct super_block *sb, sector_t block, 1433 struct kernel_lb_addr *fileset) 1434 { 1435 struct logicalVolDesc *lvd; 1436 int i, offset; 1437 uint8_t type; 1438 struct udf_sb_info *sbi = UDF_SB(sb); 1439 struct genericPartitionMap *gpm; 1440 uint16_t ident; 1441 struct buffer_head *bh; 1442 unsigned int table_len, part_map_count; 1443 int ret; 1444 1445 bh = udf_read_tagged(sb, block, block, &ident); 1446 if (!bh) 1447 return -EAGAIN; 1448 BUG_ON(ident != TAG_IDENT_LVD); 1449 lvd = (struct logicalVolDesc *)bh->b_data; 1450 table_len = le32_to_cpu(lvd->mapTableLength); 1451 if (table_len > sb->s_blocksize - sizeof(*lvd)) { 1452 udf_err(sb, "error loading logical volume descriptor: " 1453 "Partition table too long (%u > %lu)\n", table_len, 1454 sb->s_blocksize - sizeof(*lvd)); 1455 ret = -EIO; 1456 goto out_bh; 1457 } 1458 1459 ret = udf_verify_domain_identifier(sb, &lvd->domainIdent, 1460 "logical volume"); 1461 if (ret) 1462 goto out_bh; 1463 1464 part_map_count = le32_to_cpu(lvd->numPartitionMaps); 1465 if (part_map_count > table_len / sizeof(struct genericPartitionMap1)) { 1466 udf_err(sb, "error loading logical volume descriptor: " 1467 "Too many partition maps (%u > %u)\n", part_map_count, 1468 table_len / (unsigned)sizeof(struct genericPartitionMap1)); 1469 ret = -EIO; 1470 goto out_bh; 1471 } 1472 ret = udf_sb_alloc_partition_maps(sb, part_map_count); 1473 if (ret) 1474 goto out_bh; 1475 1476 for (i = 0, offset = 0; 1477 i < sbi->s_partitions && offset < table_len; 1478 i++, offset += gpm->partitionMapLength) { 1479 struct udf_part_map *map = &sbi->s_partmaps[i]; 1480 gpm = (struct genericPartitionMap *) 1481 &(lvd->partitionMaps[offset]); 1482 type = gpm->partitionMapType; 1483 if (type == 1) { 1484 struct genericPartitionMap1 *gpm1 = 1485 (struct genericPartitionMap1 *)gpm; 1486 map->s_partition_type = UDF_TYPE1_MAP15; 1487 map->s_volumeseqnum = le16_to_cpu(gpm1->volSeqNum); 1488 map->s_partition_num = le16_to_cpu(gpm1->partitionNum); 1489 map->s_partition_func = NULL; 1490 } else if (type == 2) { 1491 struct udfPartitionMap2 *upm2 = 1492 (struct udfPartitionMap2 *)gpm; 1493 if (!strncmp(upm2->partIdent.ident, UDF_ID_VIRTUAL, 1494 strlen(UDF_ID_VIRTUAL))) { 1495 u16 suf = 1496 le16_to_cpu(((__le16 *)upm2->partIdent. 1497 identSuffix)[0]); 1498 if (suf < 0x0200) { 1499 map->s_partition_type = 1500 UDF_VIRTUAL_MAP15; 1501 map->s_partition_func = 1502 udf_get_pblock_virt15; 1503 } else { 1504 map->s_partition_type = 1505 UDF_VIRTUAL_MAP20; 1506 map->s_partition_func = 1507 udf_get_pblock_virt20; 1508 } 1509 } else if (!strncmp(upm2->partIdent.ident, 1510 UDF_ID_SPARABLE, 1511 strlen(UDF_ID_SPARABLE))) { 1512 ret = udf_load_sparable_map(sb, map, 1513 (struct sparablePartitionMap *)gpm); 1514 if (ret < 0) 1515 goto out_bh; 1516 } else if (!strncmp(upm2->partIdent.ident, 1517 UDF_ID_METADATA, 1518 strlen(UDF_ID_METADATA))) { 1519 struct udf_meta_data *mdata = 1520 &map->s_type_specific.s_metadata; 1521 struct metadataPartitionMap *mdm = 1522 (struct metadataPartitionMap *) 1523 &(lvd->partitionMaps[offset]); 1524 udf_debug("Parsing Logical vol part %d type %u id=%s\n", 1525 i, type, UDF_ID_METADATA); 1526 1527 map->s_partition_type = UDF_METADATA_MAP25; 1528 map->s_partition_func = udf_get_pblock_meta25; 1529 1530 mdata->s_meta_file_loc = 1531 le32_to_cpu(mdm->metadataFileLoc); 1532 mdata->s_mirror_file_loc = 1533 le32_to_cpu(mdm->metadataMirrorFileLoc); 1534 mdata->s_bitmap_file_loc = 1535 le32_to_cpu(mdm->metadataBitmapFileLoc); 1536 mdata->s_alloc_unit_size = 1537 le32_to_cpu(mdm->allocUnitSize); 1538 mdata->s_align_unit_size = 1539 le16_to_cpu(mdm->alignUnitSize); 1540 if (mdm->flags & 0x01) 1541 mdata->s_flags |= MF_DUPLICATE_MD; 1542 1543 udf_debug("Metadata Ident suffix=0x%x\n", 1544 le16_to_cpu(*(__le16 *) 1545 mdm->partIdent.identSuffix)); 1546 udf_debug("Metadata part num=%u\n", 1547 le16_to_cpu(mdm->partitionNum)); 1548 udf_debug("Metadata part alloc unit size=%u\n", 1549 le32_to_cpu(mdm->allocUnitSize)); 1550 udf_debug("Metadata file loc=%u\n", 1551 le32_to_cpu(mdm->metadataFileLoc)); 1552 udf_debug("Mirror file loc=%u\n", 1553 le32_to_cpu(mdm->metadataMirrorFileLoc)); 1554 udf_debug("Bitmap file loc=%u\n", 1555 le32_to_cpu(mdm->metadataBitmapFileLoc)); 1556 udf_debug("Flags: %d %u\n", 1557 mdata->s_flags, mdm->flags); 1558 } else { 1559 udf_debug("Unknown ident: %s\n", 1560 upm2->partIdent.ident); 1561 continue; 1562 } 1563 map->s_volumeseqnum = le16_to_cpu(upm2->volSeqNum); 1564 map->s_partition_num = le16_to_cpu(upm2->partitionNum); 1565 } 1566 udf_debug("Partition (%d:%u) type %u on volume %u\n", 1567 i, map->s_partition_num, type, map->s_volumeseqnum); 1568 } 1569 1570 if (fileset) { 1571 struct long_ad *la = (struct long_ad *)&(lvd->logicalVolContentsUse[0]); 1572 1573 *fileset = lelb_to_cpu(la->extLocation); 1574 udf_debug("FileSet found in LogicalVolDesc at block=%u, partition=%u\n", 1575 fileset->logicalBlockNum, 1576 fileset->partitionReferenceNum); 1577 } 1578 if (lvd->integritySeqExt.extLength) 1579 udf_load_logicalvolint(sb, leea_to_cpu(lvd->integritySeqExt)); 1580 ret = 0; 1581 1582 if (!sbi->s_lvid_bh) { 1583 /* We can't generate unique IDs without a valid LVID */ 1584 if (sb_rdonly(sb)) { 1585 UDF_SET_FLAG(sb, UDF_FLAG_RW_INCOMPAT); 1586 } else { 1587 udf_warn(sb, "Damaged or missing LVID, forcing " 1588 "readonly mount\n"); 1589 ret = -EACCES; 1590 } 1591 } 1592 out_bh: 1593 brelse(bh); 1594 return ret; 1595 } 1596 1597 static bool udf_lvid_valid(struct super_block *sb, 1598 struct logicalVolIntegrityDesc *lvid) 1599 { 1600 u32 parts, impuselen; 1601 1602 parts = le32_to_cpu(lvid->numOfPartitions); 1603 impuselen = le32_to_cpu(lvid->lengthOfImpUse); 1604 if (parts >= sb->s_blocksize || impuselen >= sb->s_blocksize || 1605 sizeof(struct logicalVolIntegrityDesc) + impuselen + 1606 2 * parts * sizeof(u32) > sb->s_blocksize) 1607 return false; 1608 return true; 1609 } 1610 1611 /* 1612 * Find the prevailing Logical Volume Integrity Descriptor. 1613 */ 1614 static void udf_load_logicalvolint(struct super_block *sb, struct kernel_extent_ad loc) 1615 { 1616 struct buffer_head *bh, *final_bh; 1617 uint16_t ident; 1618 struct udf_sb_info *sbi = UDF_SB(sb); 1619 struct logicalVolIntegrityDesc *lvid; 1620 int indirections = 0; 1621 1622 while (++indirections <= UDF_MAX_LVID_NESTING) { 1623 final_bh = NULL; 1624 while (loc.extLength > 0 && 1625 (bh = udf_read_tagged(sb, loc.extLocation, 1626 loc.extLocation, &ident))) { 1627 if (ident != TAG_IDENT_LVID) { 1628 brelse(bh); 1629 break; 1630 } 1631 1632 brelse(final_bh); 1633 final_bh = bh; 1634 1635 loc.extLength -= sb->s_blocksize; 1636 loc.extLocation++; 1637 } 1638 1639 if (!final_bh) 1640 return; 1641 1642 lvid = (struct logicalVolIntegrityDesc *)final_bh->b_data; 1643 if (udf_lvid_valid(sb, lvid)) { 1644 brelse(sbi->s_lvid_bh); 1645 sbi->s_lvid_bh = final_bh; 1646 } else { 1647 udf_warn(sb, "Corrupted LVID (parts=%u, impuselen=%u), " 1648 "ignoring.\n", 1649 le32_to_cpu(lvid->numOfPartitions), 1650 le32_to_cpu(lvid->lengthOfImpUse)); 1651 } 1652 1653 if (lvid->nextIntegrityExt.extLength == 0) 1654 return; 1655 1656 loc = leea_to_cpu(lvid->nextIntegrityExt); 1657 } 1658 1659 udf_warn(sb, "Too many LVID indirections (max %u), ignoring.\n", 1660 UDF_MAX_LVID_NESTING); 1661 brelse(sbi->s_lvid_bh); 1662 sbi->s_lvid_bh = NULL; 1663 } 1664 1665 /* 1666 * Step for reallocation of table of partition descriptor sequence numbers. 1667 * Must be power of 2. 1668 */ 1669 #define PART_DESC_ALLOC_STEP 32 1670 1671 struct part_desc_seq_scan_data { 1672 struct udf_vds_record rec; 1673 u32 partnum; 1674 }; 1675 1676 struct desc_seq_scan_data { 1677 struct udf_vds_record vds[VDS_POS_LENGTH]; 1678 unsigned int size_part_descs; 1679 unsigned int num_part_descs; 1680 struct part_desc_seq_scan_data *part_descs_loc; 1681 }; 1682 1683 static struct udf_vds_record *handle_partition_descriptor( 1684 struct buffer_head *bh, 1685 struct desc_seq_scan_data *data) 1686 { 1687 struct partitionDesc *desc = (struct partitionDesc *)bh->b_data; 1688 int partnum; 1689 int i; 1690 1691 partnum = le16_to_cpu(desc->partitionNumber); 1692 for (i = 0; i < data->num_part_descs; i++) 1693 if (partnum == data->part_descs_loc[i].partnum) 1694 return &(data->part_descs_loc[i].rec); 1695 if (data->num_part_descs >= data->size_part_descs) { 1696 struct part_desc_seq_scan_data *new_loc; 1697 unsigned int new_size = ALIGN(partnum, PART_DESC_ALLOC_STEP); 1698 1699 new_loc = kzalloc_objs(*new_loc, new_size, GFP_KERNEL); 1700 if (!new_loc) 1701 return ERR_PTR(-ENOMEM); 1702 memcpy(new_loc, data->part_descs_loc, 1703 data->size_part_descs * sizeof(*new_loc)); 1704 kfree(data->part_descs_loc); 1705 data->part_descs_loc = new_loc; 1706 data->size_part_descs = new_size; 1707 } 1708 return &(data->part_descs_loc[data->num_part_descs++].rec); 1709 } 1710 1711 1712 static struct udf_vds_record *get_volume_descriptor_record(uint16_t ident, 1713 struct buffer_head *bh, struct desc_seq_scan_data *data) 1714 { 1715 switch (ident) { 1716 case TAG_IDENT_PVD: /* ISO 13346 3/10.1 */ 1717 return &(data->vds[VDS_POS_PRIMARY_VOL_DESC]); 1718 case TAG_IDENT_IUVD: /* ISO 13346 3/10.4 */ 1719 return &(data->vds[VDS_POS_IMP_USE_VOL_DESC]); 1720 case TAG_IDENT_LVD: /* ISO 13346 3/10.6 */ 1721 return &(data->vds[VDS_POS_LOGICAL_VOL_DESC]); 1722 case TAG_IDENT_USD: /* ISO 13346 3/10.8 */ 1723 return &(data->vds[VDS_POS_UNALLOC_SPACE_DESC]); 1724 case TAG_IDENT_PD: /* ISO 13346 3/10.5 */ 1725 return handle_partition_descriptor(bh, data); 1726 } 1727 return NULL; 1728 } 1729 1730 /* 1731 * Process a main/reserve volume descriptor sequence. 1732 * @block First block of first extent of the sequence. 1733 * @lastblock Lastblock of first extent of the sequence. 1734 * @fileset There we store extent containing root fileset 1735 * 1736 * Returns <0 on error, 0 on success. -EAGAIN is special - try next descriptor 1737 * sequence 1738 */ 1739 static noinline int udf_process_sequence( 1740 struct super_block *sb, 1741 sector_t block, sector_t lastblock, 1742 struct kernel_lb_addr *fileset) 1743 { 1744 struct buffer_head *bh = NULL; 1745 struct udf_vds_record *curr; 1746 struct generic_desc *gd; 1747 struct volDescPtr *vdp; 1748 bool done = false; 1749 uint32_t vdsn; 1750 uint16_t ident; 1751 int ret; 1752 unsigned int indirections = 0; 1753 struct desc_seq_scan_data data; 1754 unsigned int i; 1755 1756 memset(data.vds, 0, sizeof(struct udf_vds_record) * VDS_POS_LENGTH); 1757 data.size_part_descs = PART_DESC_ALLOC_STEP; 1758 data.num_part_descs = 0; 1759 data.part_descs_loc = kzalloc_objs(*data.part_descs_loc, 1760 data.size_part_descs, GFP_KERNEL); 1761 if (!data.part_descs_loc) 1762 return -ENOMEM; 1763 1764 /* 1765 * Read the main descriptor sequence and find which descriptors 1766 * are in it. 1767 */ 1768 for (; (!done && block <= lastblock); block++) { 1769 bh = udf_read_tagged(sb, block, block, &ident); 1770 if (!bh) 1771 break; 1772 1773 /* Process each descriptor (ISO 13346 3/8.3-8.4) */ 1774 gd = (struct generic_desc *)bh->b_data; 1775 vdsn = le32_to_cpu(gd->volDescSeqNum); 1776 switch (ident) { 1777 case TAG_IDENT_VDP: /* ISO 13346 3/10.3 */ 1778 if (++indirections > UDF_MAX_TD_NESTING) { 1779 udf_err(sb, "too many Volume Descriptor " 1780 "Pointers (max %u supported)\n", 1781 UDF_MAX_TD_NESTING); 1782 brelse(bh); 1783 ret = -EIO; 1784 goto out; 1785 } 1786 1787 vdp = (struct volDescPtr *)bh->b_data; 1788 block = le32_to_cpu(vdp->nextVolDescSeqExt.extLocation); 1789 lastblock = le32_to_cpu( 1790 vdp->nextVolDescSeqExt.extLength) >> 1791 sb->s_blocksize_bits; 1792 lastblock += block - 1; 1793 /* For loop is going to increment 'block' again */ 1794 block--; 1795 break; 1796 case TAG_IDENT_PVD: /* ISO 13346 3/10.1 */ 1797 case TAG_IDENT_IUVD: /* ISO 13346 3/10.4 */ 1798 case TAG_IDENT_LVD: /* ISO 13346 3/10.6 */ 1799 case TAG_IDENT_USD: /* ISO 13346 3/10.8 */ 1800 case TAG_IDENT_PD: /* ISO 13346 3/10.5 */ 1801 curr = get_volume_descriptor_record(ident, bh, &data); 1802 if (IS_ERR(curr)) { 1803 brelse(bh); 1804 ret = PTR_ERR(curr); 1805 goto out; 1806 } 1807 /* Descriptor we don't care about? */ 1808 if (!curr) 1809 break; 1810 if (vdsn >= curr->volDescSeqNum) { 1811 curr->volDescSeqNum = vdsn; 1812 curr->block = block; 1813 } 1814 break; 1815 case TAG_IDENT_TD: /* ISO 13346 3/10.9 */ 1816 done = true; 1817 break; 1818 } 1819 brelse(bh); 1820 } 1821 /* 1822 * Now read interesting descriptors again and process them 1823 * in a suitable order 1824 */ 1825 if (!data.vds[VDS_POS_PRIMARY_VOL_DESC].block) { 1826 udf_err(sb, "Primary Volume Descriptor not found!\n"); 1827 ret = -EAGAIN; 1828 goto out; 1829 } 1830 ret = udf_load_pvoldesc(sb, data.vds[VDS_POS_PRIMARY_VOL_DESC].block); 1831 if (ret < 0) 1832 goto out; 1833 1834 if (data.vds[VDS_POS_LOGICAL_VOL_DESC].block) { 1835 ret = udf_load_logicalvol(sb, 1836 data.vds[VDS_POS_LOGICAL_VOL_DESC].block, 1837 fileset); 1838 if (ret < 0) 1839 goto out; 1840 } 1841 1842 /* Now handle prevailing Partition Descriptors */ 1843 for (i = 0; i < data.num_part_descs; i++) { 1844 ret = udf_load_partdesc(sb, data.part_descs_loc[i].rec.block); 1845 if (ret < 0) 1846 goto out; 1847 } 1848 ret = 0; 1849 out: 1850 kfree(data.part_descs_loc); 1851 return ret; 1852 } 1853 1854 /* 1855 * Load Volume Descriptor Sequence described by anchor in bh 1856 * 1857 * Returns <0 on error, 0 on success 1858 */ 1859 static int udf_load_sequence(struct super_block *sb, struct buffer_head *bh, 1860 struct kernel_lb_addr *fileset) 1861 { 1862 struct anchorVolDescPtr *anchor; 1863 sector_t main_s, main_e, reserve_s, reserve_e; 1864 int ret; 1865 1866 anchor = (struct anchorVolDescPtr *)bh->b_data; 1867 1868 /* Locate the main sequence */ 1869 main_s = le32_to_cpu(anchor->mainVolDescSeqExt.extLocation); 1870 main_e = le32_to_cpu(anchor->mainVolDescSeqExt.extLength); 1871 main_e = main_e >> sb->s_blocksize_bits; 1872 main_e += main_s - 1; 1873 1874 /* Locate the reserve sequence */ 1875 reserve_s = le32_to_cpu(anchor->reserveVolDescSeqExt.extLocation); 1876 reserve_e = le32_to_cpu(anchor->reserveVolDescSeqExt.extLength); 1877 reserve_e = reserve_e >> sb->s_blocksize_bits; 1878 reserve_e += reserve_s - 1; 1879 1880 /* Process the main & reserve sequences */ 1881 /* responsible for finding the PartitionDesc(s) */ 1882 ret = udf_process_sequence(sb, main_s, main_e, fileset); 1883 if (ret != -EAGAIN) 1884 return ret; 1885 udf_sb_free_partitions(sb); 1886 ret = udf_process_sequence(sb, reserve_s, reserve_e, fileset); 1887 if (ret < 0) { 1888 udf_sb_free_partitions(sb); 1889 /* No sequence was OK, return -EIO */ 1890 if (ret == -EAGAIN) 1891 ret = -EIO; 1892 } 1893 return ret; 1894 } 1895 1896 /* 1897 * Check whether there is an anchor block in the given block and 1898 * load Volume Descriptor Sequence if so. 1899 * 1900 * Returns <0 on error, 0 on success, -EAGAIN is special - try next anchor 1901 * block 1902 */ 1903 static int udf_check_anchor_block(struct super_block *sb, sector_t block, 1904 struct kernel_lb_addr *fileset) 1905 { 1906 struct buffer_head *bh; 1907 uint16_t ident; 1908 int ret; 1909 1910 bh = udf_read_tagged(sb, block, block, &ident); 1911 if (!bh) 1912 return -EAGAIN; 1913 if (ident != TAG_IDENT_AVDP) { 1914 brelse(bh); 1915 return -EAGAIN; 1916 } 1917 ret = udf_load_sequence(sb, bh, fileset); 1918 brelse(bh); 1919 return ret; 1920 } 1921 1922 /* 1923 * Search for an anchor volume descriptor pointer. 1924 * 1925 * Returns < 0 on error, 0 on success. -EAGAIN is special - try next set 1926 * of anchors. 1927 */ 1928 static int udf_scan_anchors(struct super_block *sb, udf_pblk_t *lastblock, 1929 struct kernel_lb_addr *fileset) 1930 { 1931 udf_pblk_t last[6]; 1932 int i; 1933 struct udf_sb_info *sbi = UDF_SB(sb); 1934 int last_count = 0; 1935 int ret; 1936 1937 /* First try user provided anchor */ 1938 if (sbi->s_anchor) { 1939 ret = udf_check_anchor_block(sb, sbi->s_anchor, fileset); 1940 if (ret != -EAGAIN) 1941 return ret; 1942 } 1943 /* 1944 * according to spec, anchor is in either: 1945 * block 256 1946 * lastblock-256 1947 * lastblock 1948 * however, if the disc isn't closed, it could be 512. 1949 */ 1950 ret = udf_check_anchor_block(sb, sbi->s_session + 256, fileset); 1951 if (ret != -EAGAIN) 1952 return ret; 1953 /* 1954 * The trouble is which block is the last one. Drives often misreport 1955 * this so we try various possibilities. 1956 */ 1957 last[last_count++] = *lastblock; 1958 if (*lastblock >= 1) 1959 last[last_count++] = *lastblock - 1; 1960 last[last_count++] = *lastblock + 1; 1961 if (*lastblock >= 2) 1962 last[last_count++] = *lastblock - 2; 1963 if (*lastblock >= 150) 1964 last[last_count++] = *lastblock - 150; 1965 if (*lastblock >= 152) 1966 last[last_count++] = *lastblock - 152; 1967 1968 for (i = 0; i < last_count; i++) { 1969 if (last[i] >= sb_bdev_nr_blocks(sb)) 1970 continue; 1971 ret = udf_check_anchor_block(sb, last[i], fileset); 1972 if (ret != -EAGAIN) { 1973 if (!ret) 1974 *lastblock = last[i]; 1975 return ret; 1976 } 1977 if (last[i] < 256) 1978 continue; 1979 ret = udf_check_anchor_block(sb, last[i] - 256, fileset); 1980 if (ret != -EAGAIN) { 1981 if (!ret) 1982 *lastblock = last[i]; 1983 return ret; 1984 } 1985 } 1986 1987 /* Finally try block 512 in case media is open */ 1988 return udf_check_anchor_block(sb, sbi->s_session + 512, fileset); 1989 } 1990 1991 /* 1992 * Check Volume Structure Descriptor, find Anchor block and load Volume 1993 * Descriptor Sequence. 1994 * 1995 * Returns < 0 on error, 0 on success. -EAGAIN is special meaning anchor 1996 * block was not found. 1997 */ 1998 static int udf_load_vrs(struct super_block *sb, struct udf_options *uopt, 1999 int silent, struct kernel_lb_addr *fileset) 2000 { 2001 struct udf_sb_info *sbi = UDF_SB(sb); 2002 int nsr = 0; 2003 int ret; 2004 2005 if (!sb_set_blocksize(sb, uopt->blocksize)) { 2006 if (!silent) 2007 udf_warn(sb, "Bad block size\n"); 2008 return -EINVAL; 2009 } 2010 sbi->s_last_block = uopt->lastblock; 2011 if (!UDF_QUERY_FLAG(sb, UDF_FLAG_NOVRS)) { 2012 /* Check that it is NSR02 compliant */ 2013 nsr = udf_check_vsd(sb); 2014 if (!nsr) { 2015 if (!silent) 2016 udf_warn(sb, "No VRS found\n"); 2017 return -EINVAL; 2018 } 2019 if (nsr == -1) 2020 udf_debug("Failed to read sector at offset %d. " 2021 "Assuming open disc. Skipping validity " 2022 "check\n", VSD_FIRST_SECTOR_OFFSET); 2023 if (!sbi->s_last_block) 2024 sbi->s_last_block = udf_get_last_block(sb); 2025 } else { 2026 udf_debug("Validity check skipped because of novrs option\n"); 2027 } 2028 2029 /* Look for anchor block and load Volume Descriptor Sequence */ 2030 sbi->s_anchor = uopt->anchor; 2031 ret = udf_scan_anchors(sb, &sbi->s_last_block, fileset); 2032 if (ret < 0) { 2033 if (!silent && ret == -EAGAIN) 2034 udf_warn(sb, "No anchor found\n"); 2035 return ret; 2036 } 2037 return 0; 2038 } 2039 2040 static void udf_finalize_lvid(struct logicalVolIntegrityDesc *lvid) 2041 { 2042 struct timespec64 ts; 2043 2044 ktime_get_real_ts64(&ts); 2045 udf_time_to_disk_stamp(&lvid->recordingDateAndTime, ts); 2046 lvid->descTag.descCRC = cpu_to_le16( 2047 crc_itu_t(0, (char *)lvid + sizeof(struct tag), 2048 le16_to_cpu(lvid->descTag.descCRCLength))); 2049 lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag); 2050 } 2051 2052 static void udf_open_lvid(struct super_block *sb) 2053 { 2054 struct udf_sb_info *sbi = UDF_SB(sb); 2055 struct buffer_head *bh = sbi->s_lvid_bh; 2056 struct logicalVolIntegrityDesc *lvid; 2057 struct logicalVolIntegrityDescImpUse *lvidiu; 2058 2059 if (!bh) 2060 return; 2061 lvid = (struct logicalVolIntegrityDesc *)bh->b_data; 2062 lvidiu = udf_sb_lvidiu(sb); 2063 if (!lvidiu) 2064 return; 2065 2066 mutex_lock(&sbi->s_alloc_mutex); 2067 lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX; 2068 lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX; 2069 if (le32_to_cpu(lvid->integrityType) == LVID_INTEGRITY_TYPE_CLOSE) 2070 lvid->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_OPEN); 2071 else 2072 UDF_SET_FLAG(sb, UDF_FLAG_INCONSISTENT); 2073 2074 udf_finalize_lvid(lvid); 2075 mark_buffer_dirty(bh); 2076 sbi->s_lvid_dirty = 0; 2077 mutex_unlock(&sbi->s_alloc_mutex); 2078 /* Make opening of filesystem visible on the media immediately */ 2079 sync_dirty_buffer(bh); 2080 } 2081 2082 static void udf_close_lvid(struct super_block *sb) 2083 { 2084 struct udf_sb_info *sbi = UDF_SB(sb); 2085 struct buffer_head *bh = sbi->s_lvid_bh; 2086 struct logicalVolIntegrityDesc *lvid; 2087 struct logicalVolIntegrityDescImpUse *lvidiu; 2088 2089 if (!bh) 2090 return; 2091 lvid = (struct logicalVolIntegrityDesc *)bh->b_data; 2092 lvidiu = udf_sb_lvidiu(sb); 2093 if (!lvidiu) 2094 return; 2095 2096 mutex_lock(&sbi->s_alloc_mutex); 2097 lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX; 2098 lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX; 2099 if (UDF_MAX_WRITE_VERSION > le16_to_cpu(lvidiu->maxUDFWriteRev)) 2100 lvidiu->maxUDFWriteRev = cpu_to_le16(UDF_MAX_WRITE_VERSION); 2101 if (sbi->s_udfrev > le16_to_cpu(lvidiu->minUDFReadRev)) 2102 lvidiu->minUDFReadRev = cpu_to_le16(sbi->s_udfrev); 2103 if (sbi->s_udfrev > le16_to_cpu(lvidiu->minUDFWriteRev)) 2104 lvidiu->minUDFWriteRev = cpu_to_le16(sbi->s_udfrev); 2105 if (!UDF_QUERY_FLAG(sb, UDF_FLAG_INCONSISTENT)) 2106 lvid->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE); 2107 2108 /* 2109 * We set buffer uptodate unconditionally here to avoid spurious 2110 * warnings from mark_buffer_dirty() when previous EIO has marked 2111 * the buffer as !uptodate 2112 */ 2113 set_buffer_uptodate(bh); 2114 udf_finalize_lvid(lvid); 2115 mark_buffer_dirty(bh); 2116 sbi->s_lvid_dirty = 0; 2117 mutex_unlock(&sbi->s_alloc_mutex); 2118 /* Make closing of filesystem visible on the media immediately */ 2119 sync_dirty_buffer(bh); 2120 } 2121 2122 u64 lvid_get_unique_id(struct super_block *sb) 2123 { 2124 struct buffer_head *bh; 2125 struct udf_sb_info *sbi = UDF_SB(sb); 2126 struct logicalVolIntegrityDesc *lvid; 2127 struct logicalVolHeaderDesc *lvhd; 2128 u64 uniqueID; 2129 u64 ret; 2130 2131 bh = sbi->s_lvid_bh; 2132 if (!bh) 2133 return 0; 2134 2135 lvid = (struct logicalVolIntegrityDesc *)bh->b_data; 2136 lvhd = (struct logicalVolHeaderDesc *)lvid->logicalVolContentsUse; 2137 2138 mutex_lock(&sbi->s_alloc_mutex); 2139 ret = uniqueID = le64_to_cpu(lvhd->uniqueID); 2140 if (!(++uniqueID & 0xFFFFFFFF)) 2141 uniqueID += 16; 2142 lvhd->uniqueID = cpu_to_le64(uniqueID); 2143 udf_updated_lvid(sb); 2144 mutex_unlock(&sbi->s_alloc_mutex); 2145 2146 return ret; 2147 } 2148 2149 static int udf_fill_super(struct super_block *sb, struct fs_context *fc) 2150 { 2151 int ret = -EINVAL; 2152 struct inode *inode = NULL; 2153 struct udf_options *uopt = fc->fs_private; 2154 struct kernel_lb_addr rootdir, fileset; 2155 struct udf_sb_info *sbi; 2156 bool lvid_open = false; 2157 int silent = fc->sb_flags & SB_SILENT; 2158 2159 sbi = kzalloc_obj(*sbi, GFP_KERNEL); 2160 if (!sbi) 2161 return -ENOMEM; 2162 2163 sb->s_fs_info = sbi; 2164 2165 mutex_init(&sbi->s_alloc_mutex); 2166 2167 fileset.logicalBlockNum = 0xFFFFFFFF; 2168 fileset.partitionReferenceNum = 0xFFFF; 2169 2170 sbi->s_flags = uopt->flags; 2171 sbi->s_uid = uopt->uid; 2172 sbi->s_gid = uopt->gid; 2173 sbi->s_umask = uopt->umask; 2174 sbi->s_fmode = uopt->fmode; 2175 sbi->s_dmode = uopt->dmode; 2176 sbi->s_nls_map = uopt->nls_map; 2177 uopt->nls_map = NULL; 2178 rwlock_init(&sbi->s_cred_lock); 2179 2180 if (uopt->session == 0xFFFFFFFF) 2181 sbi->s_session = udf_get_last_session(sb); 2182 else 2183 sbi->s_session = uopt->session; 2184 2185 udf_debug("Multi-session=%d\n", sbi->s_session); 2186 2187 /* Fill in the rest of the superblock */ 2188 sb->s_op = &udf_sb_ops; 2189 sb->s_export_op = &udf_export_ops; 2190 2191 sb->s_magic = UDF_SUPER_MAGIC; 2192 sb->s_time_gran = 1000; 2193 2194 if (uopt->flags & (1 << UDF_FLAG_BLOCKSIZE_SET)) { 2195 ret = udf_load_vrs(sb, uopt, silent, &fileset); 2196 } else { 2197 uopt->blocksize = bdev_logical_block_size(sb->s_bdev); 2198 while (uopt->blocksize <= 4096) { 2199 ret = udf_load_vrs(sb, uopt, silent, &fileset); 2200 if (ret < 0) { 2201 if (!silent && ret != -EACCES) { 2202 pr_notice("Scanning with blocksize %u failed\n", 2203 uopt->blocksize); 2204 } 2205 brelse(sbi->s_lvid_bh); 2206 sbi->s_lvid_bh = NULL; 2207 /* 2208 * EACCES is special - we want to propagate to 2209 * upper layers that we cannot handle RW mount. 2210 */ 2211 if (ret == -EACCES) 2212 break; 2213 } else 2214 break; 2215 2216 uopt->blocksize <<= 1; 2217 } 2218 } 2219 if (ret < 0) { 2220 if (ret == -EAGAIN) { 2221 udf_warn(sb, "No partition found (1)\n"); 2222 ret = -EINVAL; 2223 } 2224 goto error_out; 2225 } 2226 2227 udf_debug("Lastblock=%u\n", sbi->s_last_block); 2228 2229 if (sbi->s_lvid_bh) { 2230 struct logicalVolIntegrityDescImpUse *lvidiu = 2231 udf_sb_lvidiu(sb); 2232 uint16_t minUDFReadRev; 2233 uint16_t minUDFWriteRev; 2234 2235 if (!lvidiu) { 2236 ret = -EINVAL; 2237 goto error_out; 2238 } 2239 minUDFReadRev = le16_to_cpu(lvidiu->minUDFReadRev); 2240 minUDFWriteRev = le16_to_cpu(lvidiu->minUDFWriteRev); 2241 if (minUDFReadRev > UDF_MAX_READ_VERSION) { 2242 udf_err(sb, "minUDFReadRev=%x (max is %x)\n", 2243 minUDFReadRev, 2244 UDF_MAX_READ_VERSION); 2245 ret = -EINVAL; 2246 goto error_out; 2247 } else if (minUDFWriteRev > UDF_MAX_WRITE_VERSION) { 2248 if (!sb_rdonly(sb)) { 2249 ret = -EACCES; 2250 goto error_out; 2251 } 2252 UDF_SET_FLAG(sb, UDF_FLAG_RW_INCOMPAT); 2253 } 2254 2255 sbi->s_udfrev = minUDFWriteRev; 2256 2257 if (minUDFReadRev >= UDF_VERS_USE_EXTENDED_FE) 2258 UDF_SET_FLAG(sb, UDF_FLAG_USE_EXTENDED_FE); 2259 if (minUDFReadRev >= UDF_VERS_USE_STREAMS) 2260 UDF_SET_FLAG(sb, UDF_FLAG_USE_STREAMS); 2261 } 2262 2263 if (!sbi->s_partitions) { 2264 udf_warn(sb, "No partition found (2)\n"); 2265 ret = -EINVAL; 2266 goto error_out; 2267 } 2268 2269 if (sbi->s_partmaps[sbi->s_partition].s_partition_flags & 2270 UDF_PART_FLAG_READ_ONLY) { 2271 if (!sb_rdonly(sb)) { 2272 ret = -EACCES; 2273 goto error_out; 2274 } 2275 UDF_SET_FLAG(sb, UDF_FLAG_RW_INCOMPAT); 2276 } 2277 2278 ret = udf_find_fileset(sb, &fileset, &rootdir); 2279 if (ret < 0) { 2280 udf_warn(sb, "No fileset found\n"); 2281 goto error_out; 2282 } 2283 2284 if (!silent) { 2285 struct timestamp ts; 2286 udf_time_to_disk_stamp(&ts, sbi->s_record_time); 2287 udf_info("Mounting volume '%s', timestamp %04u/%02u/%02u %02u:%02u (%x)\n", 2288 sbi->s_volume_ident, 2289 le16_to_cpu(ts.year), ts.month, ts.day, 2290 ts.hour, ts.minute, le16_to_cpu(ts.typeAndTimezone)); 2291 } 2292 if (!sb_rdonly(sb)) { 2293 udf_open_lvid(sb); 2294 lvid_open = true; 2295 } 2296 2297 /* Assign the root inode */ 2298 /* assign inodes by physical block number */ 2299 /* perhaps it's not extensible enough, but for now ... */ 2300 inode = udf_iget(sb, &rootdir); 2301 if (IS_ERR(inode)) { 2302 udf_err(sb, "Error in udf_iget, block=%u, partition=%u\n", 2303 rootdir.logicalBlockNum, rootdir.partitionReferenceNum); 2304 ret = PTR_ERR(inode); 2305 goto error_out; 2306 } 2307 2308 /* Allocate a dentry for the root inode */ 2309 sb->s_root = d_make_root(inode); 2310 if (!sb->s_root) { 2311 udf_err(sb, "Couldn't allocate root dentry\n"); 2312 ret = -ENOMEM; 2313 goto error_out; 2314 } 2315 sb->s_maxbytes = UDF_MAX_FILESIZE; 2316 sb->s_max_links = UDF_MAX_LINKS; 2317 return 0; 2318 2319 error_out: 2320 iput(sbi->s_vat_inode); 2321 unload_nls(uopt->nls_map); 2322 if (lvid_open) 2323 udf_close_lvid(sb); 2324 brelse(sbi->s_lvid_bh); 2325 udf_sb_free_partitions(sb); 2326 kfree(sbi); 2327 sb->s_fs_info = NULL; 2328 2329 return ret; 2330 } 2331 2332 void _udf_err(struct super_block *sb, const char *function, 2333 const char *fmt, ...) 2334 { 2335 struct va_format vaf; 2336 va_list args; 2337 2338 va_start(args, fmt); 2339 2340 vaf.fmt = fmt; 2341 vaf.va = &args; 2342 2343 pr_err("error (device %s): %s: %pV", sb->s_id, function, &vaf); 2344 2345 va_end(args); 2346 } 2347 2348 void _udf_warn(struct super_block *sb, const char *function, 2349 const char *fmt, ...) 2350 { 2351 struct va_format vaf; 2352 va_list args; 2353 2354 va_start(args, fmt); 2355 2356 vaf.fmt = fmt; 2357 vaf.va = &args; 2358 2359 pr_warn("warning (device %s): %s: %pV", sb->s_id, function, &vaf); 2360 2361 va_end(args); 2362 } 2363 2364 static void udf_put_super(struct super_block *sb) 2365 { 2366 struct udf_sb_info *sbi; 2367 2368 sbi = UDF_SB(sb); 2369 2370 iput(sbi->s_vat_inode); 2371 unload_nls(sbi->s_nls_map); 2372 if (!sb_rdonly(sb)) 2373 udf_close_lvid(sb); 2374 brelse(sbi->s_lvid_bh); 2375 udf_sb_free_partitions(sb); 2376 mutex_destroy(&sbi->s_alloc_mutex); 2377 kfree(sb->s_fs_info); 2378 sb->s_fs_info = NULL; 2379 } 2380 2381 static int udf_sync_fs(struct super_block *sb, int wait) 2382 { 2383 struct udf_sb_info *sbi = UDF_SB(sb); 2384 2385 mutex_lock(&sbi->s_alloc_mutex); 2386 if (sbi->s_lvid_dirty) { 2387 struct buffer_head *bh = sbi->s_lvid_bh; 2388 struct logicalVolIntegrityDesc *lvid; 2389 2390 lvid = (struct logicalVolIntegrityDesc *)bh->b_data; 2391 udf_finalize_lvid(lvid); 2392 2393 /* 2394 * Blockdevice will be synced later so we don't have to submit 2395 * the buffer for IO 2396 */ 2397 mark_buffer_dirty(bh); 2398 sbi->s_lvid_dirty = 0; 2399 } 2400 mutex_unlock(&sbi->s_alloc_mutex); 2401 2402 return 0; 2403 } 2404 2405 static int udf_statfs(struct dentry *dentry, struct kstatfs *buf) 2406 { 2407 struct super_block *sb = dentry->d_sb; 2408 struct udf_sb_info *sbi = UDF_SB(sb); 2409 struct logicalVolIntegrityDescImpUse *lvidiu; 2410 u64 id = huge_encode_dev(sb->s_bdev->bd_dev); 2411 2412 lvidiu = udf_sb_lvidiu(sb); 2413 buf->f_type = UDF_SUPER_MAGIC; 2414 buf->f_bsize = sb->s_blocksize; 2415 buf->f_blocks = sbi->s_partmaps[sbi->s_partition].s_partition_len; 2416 buf->f_bfree = udf_count_free(sb); 2417 buf->f_bavail = buf->f_bfree; 2418 /* 2419 * Let's pretend each free block is also a free 'inode' since UDF does 2420 * not have separate preallocated table of inodes. 2421 */ 2422 buf->f_files = (lvidiu != NULL ? (le32_to_cpu(lvidiu->numFiles) + 2423 le32_to_cpu(lvidiu->numDirs)) : 0) 2424 + buf->f_bfree; 2425 buf->f_ffree = buf->f_bfree; 2426 buf->f_namelen = UDF_NAME_LEN; 2427 buf->f_fsid = u64_to_fsid(id); 2428 2429 return 0; 2430 } 2431 2432 static unsigned int udf_count_free_bitmap(struct super_block *sb, 2433 struct udf_bitmap *bitmap) 2434 { 2435 struct buffer_head *bh = NULL; 2436 unsigned int accum = 0; 2437 int index; 2438 udf_pblk_t block = 0, newblock; 2439 struct kernel_lb_addr loc; 2440 uint32_t bytes; 2441 uint8_t *ptr; 2442 uint16_t ident; 2443 struct spaceBitmapDesc *bm; 2444 2445 loc.logicalBlockNum = bitmap->s_extPosition; 2446 loc.partitionReferenceNum = UDF_SB(sb)->s_partition; 2447 bh = udf_read_ptagged(sb, &loc, 0, &ident); 2448 2449 if (!bh) { 2450 udf_err(sb, "udf_count_free failed\n"); 2451 goto out; 2452 } else if (ident != TAG_IDENT_SBD) { 2453 brelse(bh); 2454 udf_err(sb, "udf_count_free failed\n"); 2455 goto out; 2456 } 2457 2458 bm = (struct spaceBitmapDesc *)bh->b_data; 2459 bytes = le32_to_cpu(bm->numOfBytes); 2460 index = sizeof(struct spaceBitmapDesc); /* offset in first block only */ 2461 ptr = (uint8_t *)bh->b_data; 2462 2463 while (bytes > 0) { 2464 u32 cur_bytes = min_t(u32, bytes, sb->s_blocksize - index); 2465 accum += bitmap_weight((const unsigned long *)(ptr + index), 2466 cur_bytes * 8); 2467 bytes -= cur_bytes; 2468 if (bytes) { 2469 brelse(bh); 2470 newblock = udf_get_lb_pblock(sb, &loc, ++block); 2471 bh = sb_bread(sb, newblock); 2472 if (!bh) { 2473 udf_debug("read failed\n"); 2474 goto out; 2475 } 2476 index = 0; 2477 ptr = (uint8_t *)bh->b_data; 2478 } 2479 } 2480 brelse(bh); 2481 out: 2482 return accum; 2483 } 2484 2485 static unsigned int udf_count_free_table(struct super_block *sb, 2486 struct inode *table) 2487 { 2488 unsigned int accum = 0; 2489 uint32_t elen; 2490 struct kernel_lb_addr eloc; 2491 struct extent_position epos; 2492 int8_t etype; 2493 2494 mutex_lock(&UDF_SB(sb)->s_alloc_mutex); 2495 epos.block = UDF_I(table)->i_location; 2496 epos.offset = sizeof(struct unallocSpaceEntry); 2497 epos.bh = NULL; 2498 2499 while (udf_next_aext(table, &epos, &eloc, &elen, &etype, 1) > 0) 2500 accum += (elen >> table->i_sb->s_blocksize_bits); 2501 2502 brelse(epos.bh); 2503 mutex_unlock(&UDF_SB(sb)->s_alloc_mutex); 2504 2505 return accum; 2506 } 2507 2508 static unsigned int udf_count_free(struct super_block *sb) 2509 { 2510 unsigned int accum = 0; 2511 struct udf_sb_info *sbi = UDF_SB(sb); 2512 struct udf_part_map *map; 2513 unsigned int part = sbi->s_partition; 2514 int ptype = sbi->s_partmaps[part].s_partition_type; 2515 2516 if (ptype == UDF_METADATA_MAP25) { 2517 part = sbi->s_partmaps[part].s_type_specific.s_metadata. 2518 s_phys_partition_ref; 2519 } else if (ptype == UDF_VIRTUAL_MAP15 || ptype == UDF_VIRTUAL_MAP20) { 2520 /* 2521 * Filesystems with VAT are append-only and we cannot write to 2522 * them. Let's just report 0 here. 2523 */ 2524 return 0; 2525 } 2526 2527 if (sbi->s_lvid_bh) { 2528 struct logicalVolIntegrityDesc *lvid = 2529 (struct logicalVolIntegrityDesc *) 2530 sbi->s_lvid_bh->b_data; 2531 if (le32_to_cpu(lvid->numOfPartitions) > part) { 2532 accum = le32_to_cpu( 2533 lvid->freeSpaceTable[part]); 2534 if (accum == 0xFFFFFFFF) 2535 accum = 0; 2536 } 2537 } 2538 2539 if (accum) 2540 return accum; 2541 2542 map = &sbi->s_partmaps[part]; 2543 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) { 2544 accum += udf_count_free_bitmap(sb, 2545 map->s_uspace.s_bitmap); 2546 } 2547 if (accum) 2548 return accum; 2549 2550 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) { 2551 accum += udf_count_free_table(sb, 2552 map->s_uspace.s_table); 2553 } 2554 return accum; 2555 } 2556 2557 MODULE_AUTHOR("Ben Fennema"); 2558 MODULE_DESCRIPTION("Universal Disk Format Filesystem"); 2559 MODULE_LICENSE("GPL"); 2560 module_init(init_udf_fs) 2561 module_exit(exit_udf_fs) 2562