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