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