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