Root/fs/udf/super.c

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

Archive Download this file



interactive