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