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