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