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