~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/udf/super.c

Version: ~ [ linux-5.8-rc4 ] ~ [ linux-5.7.7 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.50 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.131 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.187 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.229 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.229 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp