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