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