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