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