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