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