1	// SPDX-License-Identifier: GPL-2.0-only
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/
15	* https://www.ecma.ch/
16	* https://www.iso.org/
17	*
18	* COPYRIGHT
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
32	* 12/06/98 blf really hosed things royally. vat/sparing support. sequenced
33	* vol descs. rewrote option handling based on isofs
34	* 12/20/98 find the free space bitmap (if it exists)
35	*/
36
37	#include "udfdecl.h"
38
39	#include <linux/blkdev.h>
40	#include <linux/slab.h>
41	#include <linux/kernel.h>
42	#include <linux/module.h>
43	#include <linux/stat.h>
44	#include <linux/cdrom.h>
45	#include <linux/nls.h>
46	#include <linux/vfs.h>
47	#include <linux/vmalloc.h>
48	#include <linux/errno.h>
49	#include <linux/seq_file.h>
50	#include <linux/bitmap.h>
51	#include <linux/crc-itu-t.h>
52	#include <linux/log2.h>
53	#include <asm/byteorder.h>
54	#include <linux/iversion.h>
55	#include <linux/fs_context.h>
56	#include <linux/fs_parser.h>
57
58	#include "udf_sb.h"
59	#include "udf_i.h"
60
61	#include <linux/init.h>
62	#include <linux/uaccess.h>
63
64	enum {
65	VDS_POS_PRIMARY_VOL_DESC,
66	VDS_POS_UNALLOC_SPACE_DESC,
67	VDS_POS_LOGICAL_VOL_DESC,
68	VDS_POS_IMP_USE_VOL_DESC,
69	VDS_POS_LENGTH
70	};
71
72	#define VSD_FIRST_SECTOR_OFFSET 32768
73	#define VSD_MAX_SECTOR_OFFSET 0x800000
74
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
84	enum { UDF_MAX_LINKS = 0xffff };
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)
92
93	/* These are the "meat" - everything else is stuffing */
94	static int udf_fill_super(struct super_block *sb, struct fs_context *fc);
95	static void udf_put_super(struct super_block *);
96	static int udf_sync_fs(struct super_block *, int);
97	static void udf_load_logicalvolint(struct super_block *, struct kernel_extent_ad);
98	static void udf_open_lvid(struct super_block *);
99	static void udf_close_lvid(struct super_block *);
100	static unsigned int udf_count_free(struct super_block *);
101	static int udf_statfs(struct dentry *, struct kstatfs *);
102	static int udf_show_options(struct seq_file *, struct dentry *);
103	static int udf_init_fs_context(struct fs_context *fc);
104	static int udf_parse_param(struct fs_context *fc, struct fs_parameter *param);
105	static int udf_reconfigure(struct fs_context *fc);
106	static void udf_free_fc(struct fs_context *fc);
107	static const struct fs_parameter_spec udf_param_spec[];
108
109	struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu(struct super_block *sb)
110	{
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);
119	/* The offset is to skip freeSpaceTable and sizeTable arrays */
120	offset = partnum * 2 * sizeof(uint32_t);
121	return (struct logicalVolIntegrityDescImpUse *)
122	(((uint8_t *)(lvid + 1)) + offset);
123	}
124
125	/* UDF filesystem type */
126	static int udf_get_tree(struct fs_context *fc)
127	{
128	return get_tree_bdev(fc, fill_super: udf_fill_super);
129	}
130
131	static 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
138	static struct file_system_type udf_fstype = {
139	.owner = THIS_MODULE,
140	.name = "udf",
141	.kill_sb = kill_block_super,
142	.fs_flags = FS_REQUIRES_DEV,
143	.init_fs_context = udf_init_fs_context,
144	.parameters = udf_param_spec,
145	};
146	MODULE_ALIAS_FS("udf");
147
148	static struct kmem_cache *udf_inode_cachep;
149
150	static struct inode *udf_alloc_inode(struct super_block *sb)
151	{
152	struct udf_inode_info *ei;
153	ei = alloc_inode_sb(sb, cache: udf_inode_cachep, GFP_KERNEL);
154	if (!ei)
155	return NULL;
156
157	ei->i_unique = 0;
158	ei->i_lenExtents = 0;
159	ei->i_lenStreams = 0;
160	ei->i_next_alloc_block = 0;
161	ei->i_next_alloc_goal = 0;
162	ei->i_strat4096 = 0;
163	ei->i_streamdir = 0;
164	ei->i_hidden = 0;
165	init_rwsem(&ei->i_data_sem);
166	ei->cached_extent.lstart = -1;
167	spin_lock_init(&ei->i_extent_cache_lock);
168	inode_set_iversion(inode: &ei->vfs_inode, val: 1);
169
170	return &ei->vfs_inode;
171	}
172
173	static void udf_free_in_core_inode(struct inode *inode)
174	{
175	kmem_cache_free(s: udf_inode_cachep, objp: UDF_I(inode));
176	}
177
178	static void init_once(void *foo)
179	{
180	struct udf_inode_info *ei = foo;
181
182	ei->i_data = NULL;
183	inode_init_once(&ei->vfs_inode);
184	}
185
186	static int __init init_inodecache(void)
187	{
188	udf_inode_cachep = kmem_cache_create(name: "udf_inode_cache",
189	size: sizeof(struct udf_inode_info),
190	align: 0, flags: (SLAB_RECLAIM_ACCOUNT |
191	SLAB_ACCOUNT),
192	ctor: init_once);
193	if (!udf_inode_cachep)
194	return -ENOMEM;
195	return 0;
196	}
197
198	static void destroy_inodecache(void)
199	{
200	/*
201	* Make sure all delayed rcu free inodes are flushed before we
202	* destroy cache.
203	*/
204	rcu_barrier();
205	kmem_cache_destroy(s: udf_inode_cachep);
206	}
207
208	/* Superblock operations */
209	static const struct super_operations udf_sb_ops = {
210	.alloc_inode = udf_alloc_inode,
211	.free_inode = udf_free_in_core_inode,
212	.write_inode = udf_write_inode,
213	.evict_inode = udf_evict_inode,
214	.put_super = udf_put_super,
215	.sync_fs = udf_sync_fs,
216	.statfs = udf_statfs,
217	.show_options = udf_show_options,
218	};
219
220	struct udf_options {
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	/*
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	*/
239	static 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(), uid: overflowuid);
260	uopt->gid = make_kgid(current_user_ns(), gid: 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
269	static int udf_init_fs_context(struct fs_context *fc)
270	{
271	struct udf_options *uopt;
272
273	uopt = kzalloc(size: 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
285	static 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(objp: fc->fs_private);
291	}
292
293	static int __init init_udf_fs(void)
294	{
295	int err;
296
297	err = init_inodecache();
298	if (err)
299	goto out1;
300	err = register_filesystem(&udf_fstype);
301	if (err)
302	goto out;
303
304	return 0;
305
306	out:
307	destroy_inodecache();
308
309	out1:
310	return err;
311	}
312
313	static void __exit exit_udf_fs(void)
314	{
315	unregister_filesystem(&udf_fstype);
316	destroy_inodecache();
317	}
318
319	static int udf_sb_alloc_partition_maps(struct super_block *sb, u32 count)
320	{
321	struct udf_sb_info *sbi = UDF_SB(sb);
322
323	sbi->s_partmaps = kcalloc(n: count, size: sizeof(*sbi->s_partmaps), GFP_KERNEL);
324	if (!sbi->s_partmaps) {
325	sbi->s_partitions = 0;
326	return -ENOMEM;
327	}
328
329	sbi->s_partitions = count;
330	return 0;
331	}
332
333	static void udf_sb_free_bitmap(struct udf_bitmap *bitmap)
334	{
335	int i;
336	int nr_groups = bitmap->s_nr_groups;
337
338	for (i = 0; i < nr_groups; i++)
339	brelse(bh: bitmap->s_block_bitmap[i]);
340
341	kvfree(addr: bitmap);
342	}
343
344	static 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);
351	if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
352	udf_sb_free_bitmap(bitmap: map->s_uspace.s_bitmap);
353	if (map->s_partition_type == UDF_SPARABLE_MAP15)
354	for (i = 0; i < 4; i++)
355	brelse(bh: 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
369	static void udf_sb_free_partitions(struct super_block *sb)
370	{
371	struct udf_sb_info *sbi = UDF_SB(sb);
372	int i;
373
374	if (!sbi->s_partmaps)
375	return;
376	for (i = 0; i < sbi->s_partitions; i++)
377	udf_free_partition(map: &sbi->s_partmaps[i]);
378	kfree(objp: sbi->s_partmaps);
379	sbi->s_partmaps = NULL;
380	}
381
382	static int udf_show_options(struct seq_file *seq, struct dentry *root)
383	{
384	struct super_block *sb = root->d_sb;
385	struct udf_sb_info *sbi = UDF_SB(sb);
386
387	if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT))
388	seq_puts(m: seq, s: ",nostrict");
389	if (UDF_QUERY_FLAG(sb, UDF_FLAG_BLOCKSIZE_SET))
390	seq_printf(m: seq, fmt: ",bs=%lu", sb->s_blocksize);
391	if (UDF_QUERY_FLAG(sb, UDF_FLAG_UNHIDE))
392	seq_puts(m: seq, s: ",unhide");
393	if (UDF_QUERY_FLAG(sb, UDF_FLAG_UNDELETE))
394	seq_puts(m: seq, s: ",undelete");
395	if (!UDF_QUERY_FLAG(sb, UDF_FLAG_USE_AD_IN_ICB))
396	seq_puts(m: seq, s: ",noadinicb");
397	if (UDF_QUERY_FLAG(sb, UDF_FLAG_USE_SHORT_AD))
398	seq_puts(m: seq, s: ",shortad");
399	if (UDF_QUERY_FLAG(sb, UDF_FLAG_UID_FORGET))
400	seq_puts(m: seq, s: ",uid=forget");
401	if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_FORGET))
402	seq_puts(m: seq, s: ",gid=forget");
403	if (UDF_QUERY_FLAG(sb, UDF_FLAG_UID_SET))
404	seq_printf(m: seq, fmt: ",uid=%u", from_kuid(to: &init_user_ns, uid: sbi->s_uid));
405	if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_SET))
406	seq_printf(m: seq, fmt: ",gid=%u", from_kgid(to: &init_user_ns, gid: sbi->s_gid));
407	if (sbi->s_umask != 0)
408	seq_printf(m: seq, fmt: ",umask=%ho", sbi->s_umask);
409	if (sbi->s_fmode != UDF_INVALID_MODE)
410	seq_printf(m: seq, fmt: ",mode=%ho", sbi->s_fmode);
411	if (sbi->s_dmode != UDF_INVALID_MODE)
412	seq_printf(m: seq, fmt: ",dmode=%ho", sbi->s_dmode);
413	if (UDF_QUERY_FLAG(sb, UDF_FLAG_SESSION_SET))
414	seq_printf(m: seq, fmt: ",session=%d", sbi->s_session);
415	if (UDF_QUERY_FLAG(sb, UDF_FLAG_LASTBLOCK_SET))
416	seq_printf(m: seq, fmt: ",lastblock=%u", sbi->s_last_block);
417	if (sbi->s_anchor != 0)
418	seq_printf(m: seq, fmt: ",anchor=%u", sbi->s_anchor);
419	if (sbi->s_nls_map)
420	seq_printf(m: seq, fmt: ",iocharset=%s", sbi->s_nls_map->charset);
421	else
422	seq_puts(m: seq, s: ",iocharset=utf8");
423
424	return 0;
425	}
426
427	/*
428	* udf_parse_param
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.
438	* mode= Set the default file permissions.
439	* dmode= Set the default directory permissions.
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	*
453	* novrs Skip volume sequence recognition
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
471	* fc fs_context with pointer to mount options variable.
472	* param Pointer to fs_parameter being parsed.
473	*
474	* POST-CONDITIONS
475	* <return> 0 Mount options parsed okay.
476	* <return> errno Error parsing mount options.
477	*
478	* HISTORY
479	* July 1, 1997 - Andrew E. Mileski
480	* Written, tested, and released.
481	*/
482
483	enum {
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,
488	Opt_rootdir, Opt_utf8, Opt_iocharset, Opt_err, Opt_fmode, Opt_dmode
489	};
490
491	static 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
517	static int udf_parse_param(struct fs_context *fc, struct fs_parameter *param)
518	{
519	unsigned int uv;
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, desc: udf_param_spec, param, result: &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)
549	uopt->flags &= ~(1 << UDF_FLAG_USE_AD_IN_ICB);
550	else
551	uopt->flags |= (1 << UDF_FLAG_USE_AD_IN_ICB);
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(s: param->string, base: 10, res: &uv) == 0) {
561	kgid_t gid = make_kgid(current_user_ns(), gid: uv);
562	if (!gid_valid(gid))
563	return -EINVAL;
564	uopt->gid = gid;
565	uopt->flags |= (1 << UDF_FLAG_GID_SET);
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(s: param->string, base: 10, res: &uv) == 0) {
577	kuid_t uid = make_kuid(current_user_ns(), uid: uv);
578	if (!uid_valid(uid))
579	return -EINVAL;
580	uopt->uid = uid;
581	uopt->flags |= (1 << UDF_FLAG_UID_SET);
582	} else if (!strcmp(param->string, "forget")) {
583	uopt->flags |= (1 << UDF_FLAG_UID_FORGET);
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;
626	}
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(charset: param->string);
630	if (!uopt->nls_map) {
631	errorf(fc, "iocharset %s not found",
632	param->string);
633	return -EINVAL;;
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;
645	}
646	return 0;
647	}
648
649	static int udf_reconfigure(struct fs_context *fc)
650	{
651	struct udf_options *uopt = fc->fs_private;
652	struct super_block *sb = fc->root->d_sb;
653	struct udf_sb_info *sbi = UDF_SB(sb);
654	int readonly = fc->sb_flags & SB_RDONLY;
655	int error = 0;
656
657	if (!readonly && UDF_QUERY_FLAG(sb, UDF_FLAG_RW_INCOMPAT))
658	return -EACCES;
659
660	sync_filesystem(sb);
661
662	write_lock(&sbi->s_cred_lock);
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;
669	write_unlock(&sbi->s_cred_lock);
670
671	if (readonly == sb_rdonly(sb))
672	goto out_unlock;
673
674	if (readonly)
675	udf_close_lvid(sb);
676	else
677	udf_open_lvid(sb);
678
679	out_unlock:
680	return error;
681	}
682
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	*/
688	static int identify_vsd(const struct volStructDesc *vsd)
689	{
690	int ret = 0;
691
692	if (!memcmp(p: 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(p: vsd->stdIdent, VSD_STD_ID_BEA01, VSD_STD_ID_LEN))
714	; /* ret = 0 */
715	else if (!memcmp(p: vsd->stdIdent, VSD_STD_ID_NSR02, VSD_STD_ID_LEN))
716	ret = 1;
717	else if (!memcmp(p: vsd->stdIdent, VSD_STD_ID_NSR03, VSD_STD_ID_LEN))
718	ret = 1;
719	else if (!memcmp(p: vsd->stdIdent, VSD_STD_ID_BOOT2, VSD_STD_ID_LEN))
720	; /* ret = 0 */
721	else if (!memcmp(p: 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	*/
737	static int udf_check_vsd(struct super_block *sb)
738	{
739	struct volStructDesc *vsd = NULL;
740	loff_t sector = VSD_FIRST_SECTOR_OFFSET;
741	int sectorsize;
742	struct buffer_head *bh = NULL;
743	int nsr = 0;
744	struct udf_sb_info *sbi;
745	loff_t session_offset;
746
747	sbi = UDF_SB(sb);
748	if (sb->s_blocksize < sizeof(struct volStructDesc))
749	sectorsize = sizeof(struct volStructDesc);
750	else
751	sectorsize = sb->s_blocksize;
752
753	session_offset = (loff_t)sbi->s_session << sb->s_blocksize_bits;
754	sector += session_offset;
755
756	udf_debug("Starting at sector %u (%lu byte sectors)\n",
757	(unsigned int)(sector >> sb->s_blocksize_bits),
758	sb->s_blocksize);
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 */
769	for (; !nsr && sector < VSD_MAX_SECTOR_OFFSET; sector += sectorsize) {
770	/* Read a block */
771	bh = sb_bread(sb, block: sector >> sb->s_blocksize_bits);
772	if (!bh)
773	break;
774
775	vsd = (struct volStructDesc *)(bh->b_data +
776	(sector & (sb->s_blocksize - 1)));
777	nsr = identify_vsd(vsd);
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: vsd + 1);
790	/* Ignore unknown IDs... */
791	if (nsr < 0)
792	nsr = 0;
793	}
794	brelse(bh);
795	}
796
797	if (nsr > 0)
798	return 1;
799	else if (!bh && sector - session_offset == VSD_FIRST_SECTOR_OFFSET)
800	return -1;
801	else
802	return 0;
803	}
804
805	static int udf_verify_domain_identifier(struct super_block *sb,
806	struct regid *ident, char *dname)
807	{
808	struct domainIdentSuffix *suffix;
809
810	if (memcmp(p: 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	}
814	if (ident->flags & ENTITYID_FLAGS_DIRTY) {
815	udf_warn(sb, "Possibly not OSTA UDF compliant %s descriptor.\n",
816	dname);
817	goto force_ro;
818	}
819	suffix = (struct domainIdentSuffix *)ident->identSuffix;
820	if ((suffix->domainFlags & DOMAIN_FLAGS_HARD_WRITE_PROTECT) ||
821	(suffix->domainFlags & DOMAIN_FLAGS_SOFT_WRITE_PROTECT)) {
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
830	force_ro:
831	if (!sb_rdonly(sb))
832	return -EACCES;
833	UDF_SET_FLAG(sb, UDF_FLAG_RW_INCOMPAT);
834	return 0;
835	}
836
837	static 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, ident: &fset->domainIdent, dname: "file set");
843	if (ret < 0)
844	return ret;
845
846	*root = lelb_to_cpu(in: 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
854	static int udf_find_fileset(struct super_block *sb,
855	struct kernel_lb_addr *fileset,
856	struct kernel_lb_addr *root)
857	{
858	struct buffer_head *bh;
859	uint16_t ident;
860	int ret;
861
862	if (fileset->logicalBlockNum == 0xFFFFFFFF &&
863	fileset->partitionReferenceNum == 0xFFFF)
864	return -EINVAL;
865
866	bh = udf_read_ptagged(sb, fileset, 0, &ident);
867	if (!bh)
868	return -EIO;
869	if (ident != TAG_IDENT_FSD) {
870	brelse(bh);
871	return -EINVAL;
872	}
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, fset: (struct fileSetDesc *)bh->b_data, root);
879	brelse(bh);
880	return ret;
881	}
882
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	*/
889	static int udf_load_pvoldesc(struct super_block *sb, sector_t block)
890	{
891	struct primaryVolDesc *pvoldesc;
892	uint8_t *outstr;
893	struct buffer_head *bh;
894	uint16_t ident;
895	int ret;
896	struct timestamp *ts;
897
898	outstr = kmalloc(size: 128, GFP_KERNEL);
899	if (!outstr)
900	return -ENOMEM;
901
902	bh = udf_read_tagged(sb, block, block, &ident);
903	if (!bh) {
904	ret = -EAGAIN;
905	goto out2;
906	}
907
908	if (ident != TAG_IDENT_PVD) {
909	ret = -EIO;
910	goto out_bh;
911	}
912
913	pvoldesc = (struct primaryVolDesc *)bh->b_data;
914
915	udf_disk_stamp_to_time(dest: &UDF_SB(sb)->s_record_time,
916	src: pvoldesc->recordingDateAndTime);
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));
921
922	ret = udf_dstrCS0toChar(sb, outstr, 31, pvoldesc->volIdent, 32);
923	if (ret < 0) {
924	strcpy(p: UDF_SB(sb)->s_volume_ident, q: "InvalidName");
925	pr_warn("incorrect volume identification, setting to "
926	"'InvalidName'\n");
927	} else {
928	strncpy(p: UDF_SB(sb)->s_volume_ident, q: outstr, size: ret);
929	}
930	udf_debug("volIdent[] = '%s'\n", UDF_SB(sb)->s_volume_ident);
931
932	ret = udf_dstrCS0toChar(sb, outstr, 127, pvoldesc->volSetIdent, 128);
933	if (ret < 0) {
934	ret = 0;
935	goto out_bh;
936	}
937	outstr[ret] = 0;
938	udf_debug("volSetIdent[] = '%s'\n", outstr);
939
940	ret = 0;
941	out_bh:
942	brelse(bh);
943	out2:
944	kfree(objp: outstr);
945	return ret;
946	}
947
948	struct inode *udf_find_metadata_inode_efe(struct super_block *sb,
949	u32 meta_file_loc, u32 partition_ref)
950	{
951	struct kernel_lb_addr addr;
952	struct inode *metadata_fe;
953
954	addr.logicalBlockNum = meta_file_loc;
955	addr.partitionReferenceNum = partition_ref;
956
957	metadata_fe = udf_iget_special(sb, ino: &addr);
958
959	if (IS_ERR(ptr: metadata_fe)) {
960	udf_warn(sb, "metadata inode efe not found\n");
961	return metadata_fe;
962	}
963	if (UDF_I(inode: metadata_fe)->i_alloc_type != ICBTAG_FLAG_AD_SHORT) {
964	udf_warn(sb, "metadata inode efe does not have short allocation descriptors!\n");
965	iput(metadata_fe);
966	return ERR_PTR(error: -EIO);
967	}
968
969	return metadata_fe;
970	}
971
972	static int udf_load_metadata_files(struct super_block *sb, int partition,
973	int type1_index)
974	{
975	struct udf_sb_info *sbi = UDF_SB(sb);
976	struct udf_part_map *map;
977	struct udf_meta_data *mdata;
978	struct kernel_lb_addr addr;
979	struct inode *fe;
980
981	map = &sbi->s_partmaps[partition];
982	mdata = &map->s_type_specific.s_metadata;
983	mdata->s_phys_partition_ref = type1_index;
984
985	/* metadata address */
986	udf_debug("Metadata file location: block = %u part = %u\n",
987	mdata->s_meta_file_loc, mdata->s_phys_partition_ref);
988
989	fe = udf_find_metadata_inode_efe(sb, meta_file_loc: mdata->s_meta_file_loc,
990	partition_ref: mdata->s_phys_partition_ref);
991	if (IS_ERR(ptr: fe)) {
992	/* mirror file entry */
993	udf_debug("Mirror metadata file location: block = %u part = %u\n",
994	mdata->s_mirror_file_loc, mdata->s_phys_partition_ref);
995
996	fe = udf_find_metadata_inode_efe(sb, meta_file_loc: mdata->s_mirror_file_loc,
997	partition_ref: mdata->s_phys_partition_ref);
998
999	if (IS_ERR(ptr: fe)) {
1000	udf_err(sb, "Both metadata and mirror metadata inode efe can not found\n");
1001	return PTR_ERR(ptr: fe);
1002	}
1003	mdata->s_mirror_fe = fe;
1004	} else
1005	mdata->s_metadata_fe = fe;
1006
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;
1015	addr.partitionReferenceNum = mdata->s_phys_partition_ref;
1016
1017	udf_debug("Bitmap file location: block = %u part = %u\n",
1018	addr.logicalBlockNum, addr.partitionReferenceNum);
1019
1020	fe = udf_iget_special(sb, ino: &addr);
1021	if (IS_ERR(ptr: fe)) {
1022	if (sb_rdonly(sb))
1023	udf_warn(sb, "bitmap inode efe not found but it's ok since the disc is mounted read-only\n");
1024	else {
1025	udf_err(sb, "bitmap inode efe not found and attempted read-write mount\n");
1026	return PTR_ERR(ptr: fe);
1027	}
1028	} else
1029	mdata->s_bitmap_fe = fe;
1030	}
1031
1032	udf_debug("udf_load_metadata_files Ok\n");
1033	return 0;
1034	}
1035
1036	int udf_compute_nr_groups(struct super_block *sb, u32 partition)
1037	{
1038	struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
1039	return DIV_ROUND_UP(map->s_partition_len +
1040	(sizeof(struct spaceBitmapDesc) << 3),
1041	sb->s_blocksize * 8);
1042	}
1043
1044	static struct udf_bitmap *udf_sb_alloc_bitmap(struct super_block *sb, u32 index)
1045	{
1046	struct udf_bitmap *bitmap;
1047	int nr_groups = udf_compute_nr_groups(sb, partition: index);
1048
1049	bitmap = kvzalloc(struct_size(bitmap, s_block_bitmap, nr_groups),
1050	GFP_KERNEL);
1051	if (!bitmap)
1052	return NULL;
1053
1054	bitmap->s_nr_groups = nr_groups;
1055	return bitmap;
1056	}
1057
1058	static 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:
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 ||
1095	map->s_partition_type == UDF_VIRTUAL_MAP20 ||
1096	map->s_partition_type == UDF_METADATA_MAP25)
1097	goto force_ro;
1098
1099	return 0;
1100	force_ro:
1101	if (!sb_rdonly(sb))
1102	return -EACCES;
1103	UDF_SET_FLAG(sb, UDF_FLAG_RW_INCOMPAT);
1104	return 0;
1105	}
1106
1107	static int udf_fill_partdesc_info(struct super_block *sb,
1108	struct partitionDesc *p, int p_index)
1109	{
1110	struct udf_part_map *map;
1111	struct udf_sb_info *sbi = UDF_SB(sb);
1112	struct partitionHeaderDesc *phd;
1113	int err;
1114
1115	map = &sbi->s_partmaps[p_index];
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
1129	udf_debug("Partition (%d type %x) starts at physical %u, block length %u\n",
1130	p_index, map->s_partition_type,
1131	map->s_partition_root, map->s_partition_len);
1132
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))
1143	return 0;
1144
1145	phd = (struct partitionHeaderDesc *)p->partitionContentsUse;
1146	if (phd->unallocSpaceTable.extLength) {
1147	struct kernel_lb_addr loc = {
1148	.logicalBlockNum = le32_to_cpu(
1149	phd->unallocSpaceTable.extPosition),
1150	.partitionReferenceNum = p_index,
1151	};
1152	struct inode *inode;
1153
1154	inode = udf_iget_special(sb, ino: &loc);
1155	if (IS_ERR(ptr: inode)) {
1156	udf_debug("cannot load unallocSpaceTable (part %d)\n",
1157	p_index);
1158	return PTR_ERR(ptr: inode);
1159	}
1160	map->s_uspace.s_table = inode;
1161	map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_TABLE;
1162	udf_debug("unallocSpaceTable (part %d) @ %lu\n",
1163	p_index, map->s_uspace.s_table->i_ino);
1164	}
1165
1166	if (phd->unallocSpaceBitmap.extLength) {
1167	struct udf_bitmap *bitmap = udf_sb_alloc_bitmap(sb, index: p_index);
1168	if (!bitmap)
1169	return -ENOMEM;
1170	map->s_uspace.s_bitmap = bitmap;
1171	bitmap->s_extPosition = le32_to_cpu(
1172	phd->unallocSpaceBitmap.extPosition);
1173	map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_BITMAP;
1174	udf_debug("unallocSpaceBitmap (part %d) @ %u\n",
1175	p_index, bitmap->s_extPosition);
1176	}
1177
1178	return 0;
1179	}
1180
1181	static void udf_find_vat_block(struct super_block *sb, int p_index,
1182	int type1_index, sector_t start_block)
1183	{
1184	struct udf_sb_info *sbi = UDF_SB(sb);
1185	struct udf_part_map *map = &sbi->s_partmaps[p_index];
1186	sector_t vat_block;
1187	struct kernel_lb_addr ino;
1188	struct inode *inode;
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 &&
1197	vat_block >= start_block - 3; vat_block--) {
1198	ino.logicalBlockNum = vat_block - map->s_partition_root;
1199	inode = udf_iget_special(sb, ino: &ino);
1200	if (!IS_ERR(ptr: inode)) {
1201	sbi->s_vat_inode = inode;
1202	break;
1203	}
1204	}
1205	}
1206
1207	static 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];
1211	struct buffer_head *bh = NULL;
1212	struct udf_inode_info *vati;
1213	struct virtualAllocationTable20 *vat20;
1214	sector_t blocks = sb_bdev_nr_blocks(sb);
1215
1216	udf_find_vat_block(sb, p_index, type1_index, start_block: sbi->s_last_block);
1217	if (!sbi->s_vat_inode &&
1218	sbi->s_last_block != blocks - 1) {
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);
1222	udf_find_vat_block(sb, p_index, type1_index, start_block: blocks - 1);
1223	}
1224	if (!sbi->s_vat_inode)
1225	return -EIO;
1226
1227	if (map->s_partition_type == UDF_VIRTUAL_MAP15) {
1228	map->s_type_specific.s_virtual.s_start_offset = 0;
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) {
1232	vati = UDF_I(inode: sbi->s_vat_inode);
1233	if (vati->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
1234	int err = 0;
1235
1236	bh = udf_bread(inode: sbi->s_vat_inode, block: 0, create: 0, err: &err);
1237	if (!bh) {
1238	if (!err)
1239	err = -EFSCORRUPTED;
1240	return err;
1241	}
1242	vat20 = (struct virtualAllocationTable20 *)bh->b_data;
1243	} else {
1244	vat20 = (struct virtualAllocationTable20 *)
1245	vati->i_data;
1246	}
1247
1248	map->s_type_specific.s_virtual.s_start_offset =
1249	le16_to_cpu(vat20->lengthHeader);
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
1259	/*
1260	* Load partition descriptor block
1261	*
1262	* Returns <0 on error, 0 on success, -EAGAIN is special - try next descriptor
1263	* sequence.
1264	*/
1265	static 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);
1271	int i, type1_idx;
1272	uint16_t partitionNumber;
1273	uint16_t ident;
1274	int ret;
1275
1276	bh = udf_read_tagged(sb, block, block, &ident);
1277	if (!bh)
1278	return -EAGAIN;
1279	if (ident != TAG_IDENT_PD) {
1280	ret = 0;
1281	goto out_bh;
1282	}
1283
1284	p = (struct partitionDesc *)bh->b_data;
1285	partitionNumber = le16_to_cpu(p->partitionNumber);
1286
1287	/* First scan for TYPE1 and SPARABLE partitions */
1288	for (i = 0; i < sbi->s_partitions; i++) {
1289	map = &sbi->s_partmaps[i];
1290	udf_debug("Searching map: (%u == %u)\n",
1291	map->s_partition_num, partitionNumber);
1292	if (map->s_partition_num == partitionNumber &&
1293	(map->s_partition_type == UDF_TYPE1_MAP15 ||
1294	map->s_partition_type == UDF_SPARABLE_MAP15))
1295	break;
1296	}
1297
1298	if (i >= sbi->s_partitions) {
1299	udf_debug("Partition (%u) not found in partition map\n",
1300	partitionNumber);
1301	ret = 0;
1302	goto out_bh;
1303	}
1304
1305	ret = udf_fill_partdesc_info(sb, p, p_index: i);
1306	if (ret < 0)
1307	goto out_bh;
1308
1309	/*
1310	* Now rescan for VIRTUAL or METADATA partitions when SPARABLE and
1311	* PHYSICAL partitions are already set up
1312	*/
1313	type1_idx = i;
1314	map = NULL; /* supress 'maybe used uninitialized' warning */
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 ||
1320	map->s_partition_type == UDF_VIRTUAL_MAP20 ||
1321	map->s_partition_type == UDF_METADATA_MAP25))
1322	break;
1323	}
1324
1325	if (i >= sbi->s_partitions) {
1326	ret = 0;
1327	goto out_bh;
1328	}
1329
1330	ret = udf_fill_partdesc_info(sb, p, p_index: i);
1331	if (ret < 0)
1332	goto out_bh;
1333
1334	if (map->s_partition_type == UDF_METADATA_MAP25) {
1335	ret = udf_load_metadata_files(sb, partition: i, type1_index: type1_idx);
1336	if (ret < 0) {
1337	udf_err(sb, "error loading MetaData partition map %d\n",
1338	i);
1339	goto out_bh;
1340	}
1341	} else {
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	*/
1347	if (!sb_rdonly(sb)) {
1348	ret = -EACCES;
1349	goto out_bh;
1350	}
1351	UDF_SET_FLAG(sb, UDF_FLAG_RW_INCOMPAT);
1352	ret = udf_load_vat(sb, p_index: i, type1_index: type1_idx);
1353	if (ret < 0)
1354	goto out_bh;
1355	}
1356	ret = 0;
1357	out_bh:
1358	/* In case loading failed, we handle cleanup in udf_fill_super */
1359	brelse(bh);
1360	return ret;
1361	}
1362
1363	static 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(n: 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	}
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	}
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
1417	static int udf_load_logicalvol(struct super_block *sb, sector_t block,
1418	struct kernel_lb_addr *fileset)
1419	{
1420	struct logicalVolDesc *lvd;
1421	int i, offset;
1422	uint8_t type;
1423	struct udf_sb_info *sbi = UDF_SB(sb);
1424	struct genericPartitionMap *gpm;
1425	uint16_t ident;
1426	struct buffer_head *bh;
1427	unsigned int table_len;
1428	int ret;
1429
1430	bh = udf_read_tagged(sb, block, block, &ident);
1431	if (!bh)
1432	return -EAGAIN;
1433	BUG_ON(ident != TAG_IDENT_LVD);
1434	lvd = (struct logicalVolDesc *)bh->b_data;
1435	table_len = le32_to_cpu(lvd->mapTableLength);
1436	if (table_len > sb->s_blocksize - sizeof(*lvd)) {
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));
1440	ret = -EIO;
1441	goto out_bh;
1442	}
1443
1444	ret = udf_verify_domain_identifier(sb, ident: &lvd->domainIdent,
1445	dname: "logical volume");
1446	if (ret)
1447	goto out_bh;
1448	ret = udf_sb_alloc_partition_maps(sb, le32_to_cpu(lvd->numPartitionMaps));
1449	if (ret)
1450	goto out_bh;
1451
1452	for (i = 0, offset = 0;
1453	i < sbi->s_partitions && offset < table_len;
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;
1459	if (type == 1) {
1460	struct genericPartitionMap1 *gpm1 =
1461	(struct genericPartitionMap1 *)gpm;
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;
1466	} else if (type == 2) {
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]);
1474	if (suf < 0x0200) {
1475	map->s_partition_type =
1476	UDF_VIRTUAL_MAP15;
1477	map->s_partition_func =
1478	udf_get_pblock_virt15;
1479	} else {
1480	map->s_partition_type =
1481	UDF_VIRTUAL_MAP20;
1482	map->s_partition_func =
1483	udf_get_pblock_virt20;
1484	}
1485	} else if (!strncmp(upm2->partIdent.ident,
1486	UDF_ID_SPARABLE,
1487	strlen(UDF_ID_SPARABLE))) {
1488	ret = udf_load_sparable_map(sb, map,
1489	spm: (struct sparablePartitionMap *)gpm);
1490	if (ret < 0)
1491	goto out_bh;
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]);
1500	udf_debug("Parsing Logical vol part %d type %u id=%s\n",
1501	i, type, UDF_ID_METADATA);
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);
1516	if (mdm->flags & 0x01)
1517	mdata->s_flags |= MF_DUPLICATE_MD;
1518
1519	udf_debug("Metadata Ident suffix=0x%x\n",
1520	le16_to_cpu(*(__le16 *)
1521	mdm->partIdent.identSuffix));
1522	udf_debug("Metadata part num=%u\n",
1523	le16_to_cpu(mdm->partitionNum));
1524	udf_debug("Metadata part alloc unit size=%u\n",
1525	le32_to_cpu(mdm->allocUnitSize));
1526	udf_debug("Metadata file loc=%u\n",
1527	le32_to_cpu(mdm->metadataFileLoc));
1528	udf_debug("Mirror file loc=%u\n",
1529	le32_to_cpu(mdm->metadataMirrorFileLoc));
1530	udf_debug("Bitmap file loc=%u\n",
1531	le32_to_cpu(mdm->metadataBitmapFileLoc));
1532	udf_debug("Flags: %d %u\n",
1533	mdata->s_flags, mdm->flags);
1534	} else {
1535	udf_debug("Unknown ident: %s\n",
1536	upm2->partIdent.ident);
1537	continue;
1538	}
1539	map->s_volumeseqnum = le16_to_cpu(upm2->volSeqNum);
1540	map->s_partition_num = le16_to_cpu(upm2->partitionNum);
1541	}
1542	udf_debug("Partition (%d:%u) type %u on volume %u\n",
1543	i, map->s_partition_num, type, map->s_volumeseqnum);
1544	}
1545
1546	if (fileset) {
1547	struct long_ad *la = (struct long_ad *)&(lvd->logicalVolContentsUse[0]);
1548
1549	*fileset = lelb_to_cpu(in: la->extLocation);
1550	udf_debug("FileSet found in LogicalVolDesc at block=%u, partition=%u\n",
1551	fileset->logicalBlockNum,
1552	fileset->partitionReferenceNum);
1553	}
1554	if (lvd->integritySeqExt.extLength)
1555	udf_load_logicalvolint(sb, leea_to_cpu(in: lvd->integritySeqExt));
1556	ret = 0;
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	}
1568	out_bh:
1569	brelse(bh);
1570	return ret;
1571	}
1572
1573	static 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
1587	/*
1588	* Find the prevailing Logical Volume Integrity Descriptor.
1589	*/
1590	static void udf_load_logicalvolint(struct super_block *sb, struct kernel_extent_ad loc)
1591	{
1592	struct buffer_head *bh, *final_bh;
1593	uint16_t ident;
1594	struct udf_sb_info *sbi = UDF_SB(sb);
1595	struct logicalVolIntegrityDesc *lvid;
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(bh: final_bh);
1609	final_bh = bh;
1610
1611	loc.extLength -= sb->s_blocksize;
1612	loc.extLocation++;
1613	}
1614
1615	if (!final_bh)
1616	return;
1617
1618	lvid = (struct logicalVolIntegrityDesc *)final_bh->b_data;
1619	if (udf_lvid_valid(sb, lvid)) {
1620	brelse(bh: 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
1629	if (lvid->nextIntegrityExt.extLength == 0)
1630	return;
1631
1632	loc = leea_to_cpu(in: lvid->nextIntegrityExt);
1633	}
1634
1635	udf_warn(sb, "Too many LVID indirections (max %u), ignoring.\n",
1636	UDF_MAX_LVID_NESTING);
1637	brelse(bh: sbi->s_lvid_bh);
1638	sbi->s_lvid_bh = NULL;
1639	}
1640
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
1647	struct part_desc_seq_scan_data {
1648	struct udf_vds_record rec;
1649	u32 partnum;
1650	};
1651
1652	struct desc_seq_scan_data {
1653	struct udf_vds_record vds[VDS_POS_LENGTH];
1654	unsigned int size_part_descs;
1655	unsigned int num_part_descs;
1656	struct part_desc_seq_scan_data *part_descs_loc;
1657	};
1658
1659	static 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;
1665	int i;
1666
1667	partnum = le16_to_cpu(desc->partitionNumber);
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;
1673	unsigned int new_size = ALIGN(partnum, PART_DESC_ALLOC_STEP);
1674
1675	new_loc = kcalloc(n: new_size, size: sizeof(*new_loc), GFP_KERNEL);
1676	if (!new_loc)
1677	return ERR_PTR(error: -ENOMEM);
1678	memcpy(new_loc, data->part_descs_loc,
1679	data->size_part_descs * sizeof(*new_loc));
1680	kfree(objp: data->part_descs_loc);
1681	data->part_descs_loc = new_loc;
1682	data->size_part_descs = new_size;
1683	}
1684	return &(data->part_descs_loc[data->num_part_descs++].rec);
1685	}
1686
1687
1688	static struct udf_vds_record *get_volume_descriptor_record(uint16_t ident,
1689	struct buffer_head *bh, struct desc_seq_scan_data *data)
1690	{
1691	switch (ident) {
1692	case TAG_IDENT_PVD: /* ISO 13346 3/10.1 */
1693	return &(data->vds[VDS_POS_PRIMARY_VOL_DESC]);
1694	case TAG_IDENT_IUVD: /* ISO 13346 3/10.4 */
1695	return &(data->vds[VDS_POS_IMP_USE_VOL_DESC]);
1696	case TAG_IDENT_LVD: /* ISO 13346 3/10.6 */
1697	return &(data->vds[VDS_POS_LOGICAL_VOL_DESC]);
1698	case TAG_IDENT_USD: /* ISO 13346 3/10.8 */
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);
1702	}
1703	return NULL;
1704	}
1705
1706	/*
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
1711	*
1712	* Returns <0 on error, 0 on success. -EAGAIN is special - try next descriptor
1713	* sequence
1714	*/
1715	static noinline int udf_process_sequence(
1716	struct super_block *sb,
1717	sector_t block, sector_t lastblock,
1718	struct kernel_lb_addr *fileset)
1719	{
1720	struct buffer_head *bh = NULL;
1721	struct udf_vds_record *curr;
1722	struct generic_desc *gd;
1723	struct volDescPtr *vdp;
1724	bool done = false;
1725	uint32_t vdsn;
1726	uint16_t ident;
1727	int ret;
1728	unsigned int indirections = 0;
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;
1734	data.num_part_descs = 0;
1735	data.part_descs_loc = kcalloc(n: data.size_part_descs,
1736	size: sizeof(*data.part_descs_loc),
1737	GFP_KERNEL);
1738	if (!data.part_descs_loc)
1739	return -ENOMEM;
1740
1741	/*
1742	* Read the main descriptor sequence and find which descriptors
1743	* are in it.
1744	*/
1745	for (; (!done && block <= lastblock); block++) {
1746	bh = udf_read_tagged(sb, block, block, &ident);
1747	if (!bh)
1748	break;
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);
1753	switch (ident) {
1754	case TAG_IDENT_VDP: /* ISO 13346 3/10.3 */
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);
1760	ret = -EIO;
1761	goto out;
1762	}
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--;
1772	break;
1773	case TAG_IDENT_PVD: /* ISO 13346 3/10.1 */
1774	case TAG_IDENT_IUVD: /* ISO 13346 3/10.4 */
1775	case TAG_IDENT_LVD: /* ISO 13346 3/10.6 */
1776	case TAG_IDENT_USD: /* ISO 13346 3/10.8 */
1777	case TAG_IDENT_PD: /* ISO 13346 3/10.5 */
1778	curr = get_volume_descriptor_record(ident, bh, data: &data);
1779	if (IS_ERR(ptr: curr)) {
1780	brelse(bh);
1781	ret = PTR_ERR(ptr: curr);
1782	goto out;
1783	}
1784	/* Descriptor we don't care about? */
1785	if (!curr)
1786	break;
1787	if (vdsn >= curr->volDescSeqNum) {
1788	curr->volDescSeqNum = vdsn;
1789	curr->block = block;
1790	}
1791	break;
1792	case TAG_IDENT_TD: /* ISO 13346 3/10.9 */
1793	done = true;
1794	break;
1795	}
1796	brelse(bh);
1797	}
1798	/*
1799	* Now read interesting descriptors again and process them
1800	* in a suitable order
1801	*/
1802	if (!data.vds[VDS_POS_PRIMARY_VOL_DESC].block) {
1803	udf_err(sb, "Primary Volume Descriptor not found!\n");
1804	ret = -EAGAIN;
1805	goto out;
1806	}
1807	ret = udf_load_pvoldesc(sb, block: data.vds[VDS_POS_PRIMARY_VOL_DESC].block);
1808	if (ret < 0)
1809	goto out;
1810
1811	if (data.vds[VDS_POS_LOGICAL_VOL_DESC].block) {
1812	ret = udf_load_logicalvol(sb,
1813	block: data.vds[VDS_POS_LOGICAL_VOL_DESC].block,
1814	fileset);
1815	if (ret < 0)
1816	goto out;
1817	}
1818
1819	/* Now handle prevailing Partition Descriptors */
1820	for (i = 0; i < data.num_part_descs; i++) {
1821	ret = udf_load_partdesc(sb, block: data.part_descs_loc[i].rec.block);
1822	if (ret < 0)
1823	goto out;
1824	}
1825	ret = 0;
1826	out:
1827	kfree(objp: data.part_descs_loc);
1828	return ret;
1829	}
1830
1831	/*
1832	* Load Volume Descriptor Sequence described by anchor in bh
1833	*
1834	* Returns <0 on error, 0 on success
1835	*/
1836	static int udf_load_sequence(struct super_block *sb, struct buffer_head *bh,
1837	struct kernel_lb_addr *fileset)
1838	{
1839	struct anchorVolDescPtr *anchor;
1840	sector_t main_s, main_e, reserve_s, reserve_e;
1841	int ret;
1842
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;
1849	main_e += main_s - 1;
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;
1855	reserve_e += reserve_s - 1;
1856
1857	/* Process the main & reserve sequences */
1858	/* responsible for finding the PartitionDesc(s) */
1859	ret = udf_process_sequence(sb, block: main_s, lastblock: main_e, fileset);
1860	if (ret != -EAGAIN)
1861	return ret;
1862	udf_sb_free_partitions(sb);
1863	ret = udf_process_sequence(sb, block: reserve_s, lastblock: 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;
1871	}
1872
1873	/*
1874	* Check whether there is an anchor block in the given block and
1875	* load Volume Descriptor Sequence if so.
1876	*
1877	* Returns <0 on error, 0 on success, -EAGAIN is special - try next anchor
1878	* block
1879	*/
1880	static int udf_check_anchor_block(struct super_block *sb, sector_t block,
1881	struct kernel_lb_addr *fileset)
1882	{
1883	struct buffer_head *bh;
1884	uint16_t ident;
1885	int ret;
1886
1887	bh = udf_read_tagged(sb, block, block, &ident);
1888	if (!bh)
1889	return -EAGAIN;
1890	if (ident != TAG_IDENT_AVDP) {
1891	brelse(bh);
1892	return -EAGAIN;
1893	}
1894	ret = udf_load_sequence(sb, bh, fileset);
1895	brelse(bh);
1896	return ret;
1897	}
1898
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	*/
1905	static int udf_scan_anchors(struct super_block *sb, udf_pblk_t *lastblock,
1906	struct kernel_lb_addr *fileset)
1907	{
1908	udf_pblk_t last[6];
1909	int i;
1910	struct udf_sb_info *sbi = UDF_SB(sb);
1911	int last_count = 0;
1912	int ret;
1913
1914	/* First try user provided anchor */
1915	if (sbi->s_anchor) {
1916	ret = udf_check_anchor_block(sb, block: sbi->s_anchor, fileset);
1917	if (ret != -EAGAIN)
1918	return ret;
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	*/
1927	ret = udf_check_anchor_block(sb, block: sbi->s_session + 256, fileset);
1928	if (ret != -EAGAIN)
1929	return ret;
1930	/*
1931	* The trouble is which block is the last one. Drives often misreport
1932	* this so we try various possibilities.
1933	*/
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;
1944
1945	for (i = 0; i < last_count; i++) {
1946	if (last[i] >= sb_bdev_nr_blocks(sb))
1947	continue;
1948	ret = udf_check_anchor_block(sb, block: last[i], fileset);
1949	if (ret != -EAGAIN) {
1950	if (!ret)
1951	*lastblock = last[i];
1952	return ret;
1953	}
1954	if (last[i] < 256)
1955	continue;
1956	ret = udf_check_anchor_block(sb, block: last[i] - 256, fileset);
1957	if (ret != -EAGAIN) {
1958	if (!ret)
1959	*lastblock = last[i];
1960	return ret;
1961	}
1962	}
1963
1964	/* Finally try block 512 in case media is open */
1965	return udf_check_anchor_block(sb, block: sbi->s_session + 512, fileset);
1966	}
1967
1968	/*
1969	* Check Volume Structure Descriptor, find Anchor block and load Volume
1970	* Descriptor Sequence.
1971	*
1972	* Returns < 0 on error, 0 on success. -EAGAIN is special meaning anchor
1973	* block was not found.
1974	*/
1975	static 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);
1979	int nsr = 0;
1980	int ret;
1981
1982	if (!sb_set_blocksize(sb, uopt->blocksize)) {
1983	if (!silent)
1984	udf_warn(sb, "Bad block size\n");
1985	return -EINVAL;
1986	}
1987	sbi->s_last_block = uopt->lastblock;
1988	if (!UDF_QUERY_FLAG(sb, UDF_FLAG_NOVRS)) {
1989	/* Check that it is NSR02 compliant */
1990	nsr = udf_check_vsd(sb);
1991	if (!nsr) {
1992	if (!silent)
1993	udf_warn(sb, "No VRS found\n");
1994	return -EINVAL;
1995	}
1996	if (nsr == -1)
1997	udf_debug("Failed to read sector at offset %d. "
1998	"Assuming open disc. Skipping validity "
1999	"check\n", VSD_FIRST_SECTOR_OFFSET);
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");
2004	}
2005
2006	/* Look for anchor block and load Volume Descriptor Sequence */
2007	sbi->s_anchor = uopt->anchor;
2008	ret = udf_scan_anchors(sb, lastblock: &sbi->s_last_block, fileset);
2009	if (ret < 0) {
2010	if (!silent && ret == -EAGAIN)
2011	udf_warn(sb, "No anchor found\n");
2012	return ret;
2013	}
2014	return 0;
2015	}
2016
2017	static void udf_finalize_lvid(struct logicalVolIntegrityDesc *lvid)
2018	{
2019	struct timespec64 ts;
2020
2021	ktime_get_real_ts64(tv: &ts);
2022	udf_time_to_disk_stamp(dest: &lvid->recordingDateAndTime, src: 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(t: &lvid->descTag);
2027	}
2028
2029	static void udf_open_lvid(struct super_block *sb)
2030	{
2031	struct udf_sb_info *sbi = UDF_SB(sb);
2032	struct buffer_head *bh = sbi->s_lvid_bh;
2033	struct logicalVolIntegrityDesc *lvid;
2034	struct logicalVolIntegrityDescImpUse *lvidiu;
2035
2036	if (!bh)
2037	return;
2038	lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
2039	lvidiu = udf_sb_lvidiu(sb);
2040	if (!lvidiu)
2041	return;
2042
2043	mutex_lock(&sbi->s_alloc_mutex);
2044	lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
2045	lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
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);
2050
2051	udf_finalize_lvid(lvid);
2052	mark_buffer_dirty(bh);
2053	sbi->s_lvid_dirty = 0;
2054	mutex_unlock(lock: &sbi->s_alloc_mutex);
2055	/* Make opening of filesystem visible on the media immediately */
2056	sync_dirty_buffer(bh);
2057	}
2058
2059	static void udf_close_lvid(struct super_block *sb)
2060	{
2061	struct udf_sb_info *sbi = UDF_SB(sb);
2062	struct buffer_head *bh = sbi->s_lvid_bh;
2063	struct logicalVolIntegrityDesc *lvid;
2064	struct logicalVolIntegrityDescImpUse *lvidiu;
2065
2066	if (!bh)
2067	return;
2068	lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
2069	lvidiu = udf_sb_lvidiu(sb);
2070	if (!lvidiu)
2071	return;
2072
2073	mutex_lock(&sbi->s_alloc_mutex);
2074	lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
2075	lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
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);
2082	if (!UDF_QUERY_FLAG(sb, UDF_FLAG_INCONSISTENT))
2083	lvid->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE);
2084
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);
2091	udf_finalize_lvid(lvid);
2092	mark_buffer_dirty(bh);
2093	sbi->s_lvid_dirty = 0;
2094	mutex_unlock(lock: &sbi->s_alloc_mutex);
2095	/* Make closing of filesystem visible on the media immediately */
2096	sync_dirty_buffer(bh);
2097	}
2098
2099	u64 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);
2120	udf_updated_lvid(sb);
2121	mutex_unlock(lock: &sbi->s_alloc_mutex);
2122
2123	return ret;
2124	}
2125
2126	static int udf_fill_super(struct super_block *sb, struct fs_context *fc)
2127	{
2128	int ret = -EINVAL;
2129	struct inode *inode = NULL;
2130	struct udf_options *uopt = fc->fs_private;
2131	struct kernel_lb_addr rootdir, fileset;
2132	struct udf_sb_info *sbi;
2133	bool lvid_open = false;
2134	int silent = fc->sb_flags & SB_SILENT;
2135
2136	sbi = kzalloc(size: sizeof(*sbi), GFP_KERNEL);
2137	if (!sbi)
2138	return -ENOMEM;
2139
2140	sb->s_fs_info = sbi;
2141
2142	mutex_init(&sbi->s_alloc_mutex);
2143
2144	fileset.logicalBlockNum = 0xFFFFFFFF;
2145	fileset.partitionReferenceNum = 0xFFFF;
2146
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;
2155	rwlock_init(&sbi->s_cred_lock);
2156
2157	if (uopt->session == 0xFFFFFFFF)
2158	sbi->s_session = udf_get_last_session(sb);
2159	else
2160	sbi->s_session = uopt->session;
2161
2162	udf_debug("Multi-session=%d\n", sbi->s_session);
2163
2164	/* Fill in the rest of the superblock */
2165	sb->s_op = &udf_sb_ops;
2166	sb->s_export_op = &udf_export_ops;
2167
2168	sb->s_magic = UDF_SUPER_MAGIC;
2169	sb->s_time_gran = 1000;
2170
2171	if (uopt->flags & (1 << UDF_FLAG_BLOCKSIZE_SET)) {
2172	ret = udf_load_vrs(sb, uopt, silent, fileset: &fileset);
2173	} else {
2174	uopt->blocksize = bdev_logical_block_size(bdev: sb->s_bdev);
2175	while (uopt->blocksize <= 4096) {
2176	ret = udf_load_vrs(sb, uopt, silent, fileset: &fileset);
2177	if (ret < 0) {
2178	if (!silent && ret != -EACCES) {
2179	pr_notice("Scanning with blocksize %u failed\n",
2180	uopt->blocksize);
2181	}
2182	brelse(bh: 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
2193	uopt->blocksize <<= 1;
2194	}
2195	}
2196	if (ret < 0) {
2197	if (ret == -EAGAIN) {
2198	udf_warn(sb, "No partition found (1)\n");
2199	ret = -EINVAL;
2200	}
2201	goto error_out;
2202	}
2203
2204	udf_debug("Lastblock=%u\n", sbi->s_last_block);
2205
2206	if (sbi->s_lvid_bh) {
2207	struct logicalVolIntegrityDescImpUse *lvidiu =
2208	udf_sb_lvidiu(sb);
2209	uint16_t minUDFReadRev;
2210	uint16_t minUDFWriteRev;
2211
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);
2218	if (minUDFReadRev > UDF_MAX_READ_VERSION) {
2219	udf_err(sb, "minUDFReadRev=%x (max is %x)\n",
2220	minUDFReadRev,
2221	UDF_MAX_READ_VERSION);
2222	ret = -EINVAL;
2223	goto error_out;
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);
2230	}
2231
2232	sbi->s_udfrev = minUDFWriteRev;
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
2240	if (!sbi->s_partitions) {
2241	udf_warn(sb, "No partition found (2)\n");
2242	ret = -EINVAL;
2243	goto error_out;
2244	}
2245
2246	if (sbi->s_partmaps[sbi->s_partition].s_partition_flags &
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);
2253	}
2254
2255	ret = udf_find_fileset(sb, fileset: &fileset, root: &rootdir);
2256	if (ret < 0) {
2257	udf_warn(sb, "No fileset found\n");
2258	goto error_out;
2259	}
2260
2261	if (!silent) {
2262	struct timestamp ts;
2263	udf_time_to_disk_stamp(dest: &ts, src: sbi->s_record_time);
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,
2267	ts.hour, ts.minute, le16_to_cpu(ts.typeAndTimezone));
2268	}
2269	if (!sb_rdonly(sb)) {
2270	udf_open_lvid(sb);
2271	lvid_open = true;
2272	}
2273
2274	/* Assign the root inode */
2275	/* assign inodes by physical block number */
2276	/* perhaps it's not extensible enough, but for now ... */
2277	inode = udf_iget(sb, ino: &rootdir);
2278	if (IS_ERR(ptr: inode)) {
2279	udf_err(sb, "Error in udf_iget, block=%u, partition=%u\n",
2280	rootdir.logicalBlockNum, rootdir.partitionReferenceNum);
2281	ret = PTR_ERR(ptr: inode);
2282	goto error_out;
2283	}
2284
2285	/* Allocate a dentry for the root inode */
2286	sb->s_root = d_make_root(inode);
2287	if (!sb->s_root) {
2288	udf_err(sb, "Couldn't allocate root dentry\n");
2289	ret = -ENOMEM;
2290	goto error_out;
2291	}
2292	sb->s_maxbytes = UDF_MAX_FILESIZE;
2293	sb->s_max_links = UDF_MAX_LINKS;
2294	return 0;
2295
2296	error_out:
2297	iput(sbi->s_vat_inode);
2298	unload_nls(uopt->nls_map);
2299	if (lvid_open)
2300	udf_close_lvid(sb);
2301	brelse(bh: sbi->s_lvid_bh);
2302	udf_sb_free_partitions(sb);
2303	kfree(objp: sbi);
2304	sb->s_fs_info = NULL;
2305
2306	return ret;
2307	}
2308
2309	void _udf_err(struct super_block *sb, const char *function,
2310	const char *fmt, ...)
2311	{
2312	struct va_format vaf;
2313	va_list args;
2314
2315	va_start(args, fmt);
2316
2317	vaf.fmt = fmt;
2318	vaf.va = &args;
2319
2320	pr_err("error (device %s): %s: %pV", sb->s_id, function, &vaf);
2321
2322	va_end(args);
2323	}
2324
2325	void _udf_warn(struct super_block *sb, const char *function,
2326	const char *fmt, ...)
2327	{
2328	struct va_format vaf;
2329	va_list args;
2330
2331	va_start(args, fmt);
2332
2333	vaf.fmt = fmt;
2334	vaf.va = &args;
2335
2336	pr_warn("warning (device %s): %s: %pV", sb->s_id, function, &vaf);
2337
2338	va_end(args);
2339	}
2340
2341	static void udf_put_super(struct super_block *sb)
2342	{
2343	struct udf_sb_info *sbi;
2344
2345	sbi = UDF_SB(sb);
2346
2347	iput(sbi->s_vat_inode);
2348	unload_nls(sbi->s_nls_map);
2349	if (!sb_rdonly(sb))
2350	udf_close_lvid(sb);
2351	brelse(bh: sbi->s_lvid_bh);
2352	udf_sb_free_partitions(sb);
2353	mutex_destroy(lock: &sbi->s_alloc_mutex);
2354	kfree(objp: sb->s_fs_info);
2355	sb->s_fs_info = NULL;
2356	}
2357
2358	static 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) {
2364	struct buffer_head *bh = sbi->s_lvid_bh;
2365	struct logicalVolIntegrityDesc *lvid;
2366
2367	lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
2368	udf_finalize_lvid(lvid);
2369
2370	/*
2371	* Blockdevice will be synced later so we don't have to submit
2372	* the buffer for IO
2373	*/
2374	mark_buffer_dirty(bh);
2375	sbi->s_lvid_dirty = 0;
2376	}
2377	mutex_unlock(lock: &sbi->s_alloc_mutex);
2378
2379	return 0;
2380	}
2381
2382	static int udf_statfs(struct dentry *dentry, struct kstatfs *buf)
2383	{
2384	struct super_block *sb = dentry->d_sb;
2385	struct udf_sb_info *sbi = UDF_SB(sb);
2386	struct logicalVolIntegrityDescImpUse *lvidiu;
2387	u64 id = huge_encode_dev(dev: sb->s_bdev->bd_dev);
2388
2389	lvidiu = udf_sb_lvidiu(sb);
2390	buf->f_type = UDF_SUPER_MAGIC;
2391	buf->f_bsize = sb->s_blocksize;
2392	buf->f_blocks = sbi->s_partmaps[sbi->s_partition].s_partition_len;
2393	buf->f_bfree = udf_count_free(sb);
2394	buf->f_bavail = buf->f_bfree;
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	*/
2399	buf->f_files = (lvidiu != NULL ? (le32_to_cpu(lvidiu->numFiles) +
2400	le32_to_cpu(lvidiu->numDirs)) : 0)
2401	+ buf->f_bfree;
2402	buf->f_ffree = buf->f_bfree;
2403	buf->f_namelen = UDF_NAME_LEN;
2404	buf->f_fsid = u64_to_fsid(v: id);
2405
2406	return 0;
2407	}
2408
2409	static unsigned int udf_count_free_bitmap(struct super_block *sb,
2410	struct udf_bitmap *bitmap)
2411	{
2412	struct buffer_head *bh = NULL;
2413	unsigned int accum = 0;
2414	int index;
2415	udf_pblk_t block = 0, newblock;
2416	struct kernel_lb_addr loc;
2417	uint32_t bytes;
2418	uint8_t *ptr;
2419	uint16_t ident;
2420	struct spaceBitmapDesc *bm;
2421
2422	loc.logicalBlockNum = bitmap->s_extPosition;
2423	loc.partitionReferenceNum = UDF_SB(sb)->s_partition;
2424	bh = udf_read_ptagged(sb, &loc, 0, &ident);
2425
2426	if (!bh) {
2427	udf_err(sb, "udf_count_free failed\n");
2428	goto out;
2429	} else if (ident != TAG_IDENT_SBD) {
2430	brelse(bh);
2431	udf_err(sb, "udf_count_free failed\n");
2432	goto out;
2433	}
2434
2435	bm = (struct spaceBitmapDesc *)bh->b_data;
2436	bytes = le32_to_cpu(bm->numOfBytes);
2437	index = sizeof(struct spaceBitmapDesc); /* offset in first block only */
2438	ptr = (uint8_t *)bh->b_data;
2439
2440	while (bytes > 0) {
2441	u32 cur_bytes = min_t(u32, bytes, sb->s_blocksize - index);
2442	accum += bitmap_weight(src: (const unsigned long *)(ptr + index),
2443	nbits: cur_bytes * 8);
2444	bytes -= cur_bytes;
2445	if (bytes) {
2446	brelse(bh);
2447	newblock = udf_get_lb_pblock(sb, loc: &loc, offset: ++block);
2448	bh = sb_bread(sb, block: newblock);
2449	if (!bh) {
2450	udf_debug("read failed\n");
2451	goto out;
2452	}
2453	index = 0;
2454	ptr = (uint8_t *)bh->b_data;
2455	}
2456	}
2457	brelse(bh);
2458	out:
2459	return accum;
2460	}
2461
2462	static unsigned int udf_count_free_table(struct super_block *sb,
2463	struct inode *table)
2464	{
2465	unsigned int accum = 0;
2466	uint32_t elen;
2467	struct kernel_lb_addr eloc;
2468	struct extent_position epos;
2469
2470	mutex_lock(&UDF_SB(sb)->s_alloc_mutex);
2471	epos.block = UDF_I(inode: table)->i_location;
2472	epos.offset = sizeof(struct unallocSpaceEntry);
2473	epos.bh = NULL;
2474
2475	while (udf_next_aext(table, &epos, &eloc, &elen, 1) != -1)
2476	accum += (elen >> table->i_sb->s_blocksize_bits);
2477
2478	brelse(bh: epos.bh);
2479	mutex_unlock(lock: &UDF_SB(sb)->s_alloc_mutex);
2480
2481	return accum;
2482	}
2483
2484	static unsigned int udf_count_free(struct super_block *sb)
2485	{
2486	unsigned int accum = 0;
2487	struct udf_sb_info *sbi = UDF_SB(sb);
2488	struct udf_part_map *map;
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	}
2502
2503	if (sbi->s_lvid_bh) {
2504	struct logicalVolIntegrityDesc *lvid =
2505	(struct logicalVolIntegrityDesc *)
2506	sbi->s_lvid_bh->b_data;
2507	if (le32_to_cpu(lvid->numOfPartitions) > part) {
2508	accum = le32_to_cpu(
2509	lvid->freeSpaceTable[part]);
2510	if (accum == 0xFFFFFFFF)
2511	accum = 0;
2512	}
2513	}
2514
2515	if (accum)
2516	return accum;
2517
2518	map = &sbi->s_partmaps[part];
2519	if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) {
2520	accum += udf_count_free_bitmap(sb,
2521	bitmap: map->s_uspace.s_bitmap);
2522	}
2523	if (accum)
2524	return accum;
2525
2526	if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) {
2527	accum += udf_count_free_table(sb,
2528	table: map->s_uspace.s_table);
2529	}
2530	return accum;
2531	}
2532
2533	MODULE_AUTHOR("Ben Fennema");
2534	MODULE_DESCRIPTION("Universal Disk Format Filesystem");
2535	MODULE_LICENSE("GPL");
2536	module_init(init_udf_fs)
2537	module_exit(exit_udf_fs)
2538