2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* super.c
|
|
|
|
*
|
|
|
|
* PURPOSE
|
|
|
|
* Super block routines for the OSTA-UDF(tm) filesystem.
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* OSTA-UDF(tm) = Optical Storage Technology Association
|
|
|
|
* Universal Disk Format.
|
|
|
|
*
|
|
|
|
* This code is based on version 2.00 of the UDF specification,
|
|
|
|
* and revision 3 of the ECMA 167 standard [equivalent to ISO 13346].
|
|
|
|
* http://www.osta.org/
|
2020-07-13 20:07:38 +00:00
|
|
|
* https://www.ecma.ch/
|
|
|
|
* https://www.iso.org/
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* COPYRIGHT
|
|
|
|
* This file is distributed under the terms of the GNU General Public
|
|
|
|
* License (GPL). Copies of the GPL can be obtained from:
|
|
|
|
* ftp://prep.ai.mit.edu/pub/gnu/GPL
|
|
|
|
* Each contributing author retains all rights to their own work.
|
|
|
|
*
|
|
|
|
* (C) 1998 Dave Boynton
|
|
|
|
* (C) 1998-2004 Ben Fennema
|
|
|
|
* (C) 2000 Stelias Computing Inc
|
|
|
|
*
|
|
|
|
* HISTORY
|
|
|
|
*
|
|
|
|
* 09/24/98 dgb changed to allow compiling outside of kernel, and
|
|
|
|
* added some debugging.
|
|
|
|
* 10/01/98 dgb updated to allow (some) possibility of compiling w/2.0.34
|
|
|
|
* 10/16/98 attempting some multi-session support
|
|
|
|
* 10/17/98 added freespace count for "df"
|
|
|
|
* 11/11/98 gr added novrs option
|
|
|
|
* 11/26/98 dgb added fileset,anchor mount options
|
2008-02-08 12:20:28 +00:00
|
|
|
* 12/06/98 blf really hosed things royally. vat/sparing support. sequenced
|
|
|
|
* vol descs. rewrote option handling based on isofs
|
2005-04-16 22:20:36 +00:00
|
|
|
* 12/20/98 find the free space bitmap (if it exists)
|
|
|
|
*/
|
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
#include "udfdecl.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <linux/blkdev.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/parser.h>
|
|
|
|
#include <linux/stat.h>
|
|
|
|
#include <linux/cdrom.h>
|
|
|
|
#include <linux/nls.h>
|
|
|
|
#include <linux/vfs.h>
|
|
|
|
#include <linux/vmalloc.h>
|
2008-02-08 12:20:32 +00:00
|
|
|
#include <linux/errno.h>
|
2008-02-08 12:21:50 +00:00
|
|
|
#include <linux/mount.h>
|
|
|
|
#include <linux/seq_file.h>
|
2008-02-02 21:37:07 +00:00
|
|
|
#include <linux/bitmap.h>
|
2008-04-17 07:47:48 +00:00
|
|
|
#include <linux/crc-itu-t.h>
|
2012-06-27 19:23:07 +00:00
|
|
|
#include <linux/log2.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/byteorder.h>
|
2021-11-04 14:22:35 +00:00
|
|
|
#include <linux/iversion.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include "udf_sb.h"
|
|
|
|
#include "udf_i.h"
|
|
|
|
|
|
|
|
#include <linux/init.h>
|
2014-06-18 17:38:24 +00:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2018-02-09 11:52:28 +00:00
|
|
|
enum {
|
|
|
|
VDS_POS_PRIMARY_VOL_DESC,
|
|
|
|
VDS_POS_UNALLOC_SPACE_DESC,
|
|
|
|
VDS_POS_LOGICAL_VOL_DESC,
|
|
|
|
VDS_POS_IMP_USE_VOL_DESC,
|
|
|
|
VDS_POS_LENGTH
|
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
|
udf: fix for pathetic mount times in case of invalid file system
The UDF driver was not strict enough about checking the IDs in the
VSDs when mounting, which resulted in reading through all the sectors
of the block device in some unfortunate cases. Eg, trying to mount my
uninitialized 200G SSD partition (all 0xFF bytes) took ~350 minutes to
fail, because the code expected some of the valid IDs or a zero byte.
During this, the mount couldn't be killed, sync from the cmdline
blocked, and the machine froze into the shutdown. Valid filesystems
(extX, btrfs, ntfs) were rejected by the mere accident of having a
zero byte at just the right place in some of their sectors, close
enough to the beginning not to generate excess I/O. The fix adds a
hard limit on the VSD sector offset, adds the two missing VSD IDs, and
stops scanning when encountering an invalid ID. Also replaced the
magic number 32768 with a more meaningful #define, and supressed the
bogus message about failing to read the first sector if no UDF fs was
detected.
Signed-off-by: Peter A. Felvegi <petschy@gmail.com>
Signed-off-by: Jan Kara <jack@suse.cz>
2013-10-18 18:07:44 +00:00
|
|
|
#define VSD_FIRST_SECTOR_OFFSET 32768
|
|
|
|
#define VSD_MAX_SECTOR_OFFSET 0x800000
|
|
|
|
|
2016-04-26 02:27:56 +00:00
|
|
|
/*
|
|
|
|
* Maximum number of Terminating Descriptor / Logical Volume Integrity
|
|
|
|
* Descriptor redirections. The chosen numbers are arbitrary - just that we
|
|
|
|
* hopefully don't limit any real use of rewritten inode on write-once media
|
|
|
|
* but avoid looping for too long on corrupted media.
|
|
|
|
*/
|
|
|
|
#define UDF_MAX_TD_NESTING 64
|
|
|
|
#define UDF_MAX_LVID_NESTING 1000
|
|
|
|
|
2012-02-06 17:45:27 +00:00
|
|
|
enum { UDF_MAX_LINKS = 0xffff };
|
2023-01-25 16:56:06 +00:00
|
|
|
/*
|
|
|
|
* We limit filesize to 4TB. This is arbitrary as the on-disk format supports
|
|
|
|
* more but because the file space is described by a linked list of extents,
|
|
|
|
* each of which can have at most 1GB, the creation and handling of extents
|
|
|
|
* gets unusably slow beyond certain point...
|
|
|
|
*/
|
|
|
|
#define UDF_MAX_FILESIZE (1ULL << 42)
|
2012-02-06 17:45:27 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* These are the "meat" - everything else is stuffing */
|
|
|
|
static int udf_fill_super(struct super_block *, void *, int);
|
|
|
|
static void udf_put_super(struct super_block *);
|
2009-03-16 17:27:37 +00:00
|
|
|
static int udf_sync_fs(struct super_block *, int);
|
2005-04-16 22:20:36 +00:00
|
|
|
static int udf_remount_fs(struct super_block *, int *, char *);
|
2008-10-15 10:28:03 +00:00
|
|
|
static void udf_load_logicalvolint(struct super_block *, struct kernel_extent_ad);
|
2005-04-16 22:20:36 +00:00
|
|
|
static void udf_open_lvid(struct super_block *);
|
|
|
|
static void udf_close_lvid(struct super_block *);
|
|
|
|
static unsigned int udf_count_free(struct super_block *);
|
2006-06-23 09:02:58 +00:00
|
|
|
static int udf_statfs(struct dentry *, struct kstatfs *);
|
2011-12-09 02:32:45 +00:00
|
|
|
static int udf_show_options(struct seq_file *, struct dentry *);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-09-12 20:00:15 +00:00
|
|
|
struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu(struct super_block *sb)
|
2008-02-08 12:20:30 +00:00
|
|
|
{
|
2013-09-12 20:00:15 +00:00
|
|
|
struct logicalVolIntegrityDesc *lvid;
|
|
|
|
unsigned int partnum;
|
|
|
|
unsigned int offset;
|
|
|
|
|
|
|
|
if (!UDF_SB(sb)->s_lvid_bh)
|
|
|
|
return NULL;
|
|
|
|
lvid = (struct logicalVolIntegrityDesc *)UDF_SB(sb)->s_lvid_bh->b_data;
|
|
|
|
partnum = le32_to_cpu(lvid->numOfPartitions);
|
|
|
|
/* The offset is to skip freeSpaceTable and sizeTable arrays */
|
|
|
|
offset = partnum * 2 * sizeof(uint32_t);
|
2021-05-03 09:39:03 +00:00
|
|
|
return (struct logicalVolIntegrityDescImpUse *)
|
|
|
|
(((uint8_t *)(lvid + 1)) + offset);
|
2008-02-08 12:20:30 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* UDF filesystem type */
|
2010-07-24 20:46:55 +00:00
|
|
|
static struct dentry *udf_mount(struct file_system_type *fs_type,
|
|
|
|
int flags, const char *dev_name, void *data)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2010-07-24 20:46:55 +00:00
|
|
|
return mount_bdev(fs_type, flags, dev_name, data, udf_fill_super);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct file_system_type udf_fstype = {
|
2007-07-21 11:37:18 +00:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.name = "udf",
|
2010-07-24 20:46:55 +00:00
|
|
|
.mount = udf_mount,
|
2007-07-21 11:37:18 +00:00
|
|
|
.kill_sb = kill_block_super,
|
|
|
|
.fs_flags = FS_REQUIRES_DEV,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
2013-03-11 14:05:42 +00:00
|
|
|
MODULE_ALIAS_FS("udf");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
static struct kmem_cache *udf_inode_cachep;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static struct inode *udf_alloc_inode(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct udf_inode_info *ei;
|
2022-03-22 21:41:03 +00:00
|
|
|
ei = alloc_inode_sb(sb, udf_inode_cachep, GFP_KERNEL);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!ei)
|
|
|
|
return NULL;
|
2006-08-14 06:24:18 +00:00
|
|
|
|
|
|
|
ei->i_unique = 0;
|
|
|
|
ei->i_lenExtents = 0;
|
2019-08-14 12:50:02 +00:00
|
|
|
ei->i_lenStreams = 0;
|
2006-08-14 06:24:18 +00:00
|
|
|
ei->i_next_alloc_block = 0;
|
|
|
|
ei->i_next_alloc_goal = 0;
|
|
|
|
ei->i_strat4096 = 0;
|
2019-08-14 12:50:02 +00:00
|
|
|
ei->i_streamdir = 0;
|
2023-01-03 08:56:56 +00:00
|
|
|
ei->i_hidden = 0;
|
2010-11-16 17:40:47 +00:00
|
|
|
init_rwsem(&ei->i_data_sem);
|
2013-01-19 02:17:14 +00:00
|
|
|
ei->cached_extent.lstart = -1;
|
|
|
|
spin_lock_init(&ei->i_extent_cache_lock);
|
2021-11-04 14:22:35 +00:00
|
|
|
inode_set_iversion(&ei->vfs_inode, 1);
|
2006-08-14 06:24:18 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return &ei->vfs_inode;
|
|
|
|
}
|
|
|
|
|
2019-04-16 02:25:06 +00:00
|
|
|
static void udf_free_in_core_inode(struct inode *inode)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
kmem_cache_free(udf_inode_cachep, UDF_I(inode));
|
|
|
|
}
|
|
|
|
|
2008-07-26 02:45:34 +00:00
|
|
|
static void init_once(void *foo)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2022-10-12 10:42:35 +00:00
|
|
|
struct udf_inode_info *ei = foo;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2020-09-25 10:29:54 +00:00
|
|
|
ei->i_data = NULL;
|
2007-05-17 05:10:57 +00:00
|
|
|
inode_init_once(&ei->vfs_inode);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2014-02-01 07:45:18 +00:00
|
|
|
static int __init init_inodecache(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
udf_inode_cachep = kmem_cache_create("udf_inode_cache",
|
|
|
|
sizeof(struct udf_inode_info),
|
2007-07-19 08:47:43 +00:00
|
|
|
0, (SLAB_RECLAIM_ACCOUNT |
|
2016-01-14 23:18:21 +00:00
|
|
|
SLAB_MEM_SPREAD |
|
|
|
|
SLAB_ACCOUNT),
|
2007-07-20 01:11:58 +00:00
|
|
|
init_once);
|
2007-07-21 11:37:18 +00:00
|
|
|
if (!udf_inode_cachep)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void destroy_inodecache(void)
|
|
|
|
{
|
2012-09-26 01:33:07 +00:00
|
|
|
/*
|
|
|
|
* Make sure all delayed rcu free inodes are flushed before we
|
|
|
|
* destroy cache.
|
|
|
|
*/
|
|
|
|
rcu_barrier();
|
2006-09-27 08:49:40 +00:00
|
|
|
kmem_cache_destroy(udf_inode_cachep);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Superblock operations */
|
2007-02-12 08:55:41 +00:00
|
|
|
static const struct super_operations udf_sb_ops = {
|
2007-07-21 11:37:18 +00:00
|
|
|
.alloc_inode = udf_alloc_inode,
|
2019-04-16 02:25:06 +00:00
|
|
|
.free_inode = udf_free_in_core_inode,
|
2007-07-21 11:37:18 +00:00
|
|
|
.write_inode = udf_write_inode,
|
2010-06-07 04:43:39 +00:00
|
|
|
.evict_inode = udf_evict_inode,
|
2007-07-21 11:37:18 +00:00
|
|
|
.put_super = udf_put_super,
|
2009-03-16 17:27:37 +00:00
|
|
|
.sync_fs = udf_sync_fs,
|
2007-07-21 11:37:18 +00:00
|
|
|
.statfs = udf_statfs,
|
|
|
|
.remount_fs = udf_remount_fs,
|
2008-02-08 12:21:50 +00:00
|
|
|
.show_options = udf_show_options,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
struct udf_options {
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned char novrs;
|
|
|
|
unsigned int blocksize;
|
|
|
|
unsigned int session;
|
|
|
|
unsigned int lastblock;
|
|
|
|
unsigned int anchor;
|
|
|
|
unsigned int flags;
|
2011-07-26 07:18:29 +00:00
|
|
|
umode_t umask;
|
2012-02-10 20:20:35 +00:00
|
|
|
kgid_t gid;
|
|
|
|
kuid_t uid;
|
2011-07-26 07:18:29 +00:00
|
|
|
umode_t fmode;
|
|
|
|
umode_t dmode;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct nls_table *nls_map;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init init_udf_fs(void)
|
|
|
|
{
|
|
|
|
int err;
|
2007-07-21 11:37:18 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
err = init_inodecache();
|
|
|
|
if (err)
|
|
|
|
goto out1;
|
|
|
|
err = register_filesystem(&udf_fstype);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
2007-07-21 11:37:18 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
2007-07-21 11:37:18 +00:00
|
|
|
|
|
|
|
out:
|
2005-04-16 22:20:36 +00:00
|
|
|
destroy_inodecache();
|
2007-07-21 11:37:18 +00:00
|
|
|
|
|
|
|
out1:
|
2005-04-16 22:20:36 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit exit_udf_fs(void)
|
|
|
|
{
|
|
|
|
unregister_filesystem(&udf_fstype);
|
|
|
|
destroy_inodecache();
|
|
|
|
}
|
|
|
|
|
2008-02-08 12:20:32 +00:00
|
|
|
static int udf_sb_alloc_partition_maps(struct super_block *sb, u32 count)
|
|
|
|
{
|
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
|
|
|
|
2017-08-15 14:45:44 +00:00
|
|
|
sbi->s_partmaps = kcalloc(count, sizeof(*sbi->s_partmaps), GFP_KERNEL);
|
2008-02-08 12:20:32 +00:00
|
|
|
if (!sbi->s_partmaps) {
|
|
|
|
sbi->s_partitions = 0;
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
sbi->s_partitions = count;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-27 20:27:05 +00:00
|
|
|
static void udf_sb_free_bitmap(struct udf_bitmap *bitmap)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int nr_groups = bitmap->s_nr_groups;
|
|
|
|
|
|
|
|
for (i = 0; i < nr_groups; i++)
|
2019-09-03 19:12:09 +00:00
|
|
|
brelse(bitmap->s_block_bitmap[i]);
|
2012-06-27 20:27:05 +00:00
|
|
|
|
2016-01-22 23:11:02 +00:00
|
|
|
kvfree(bitmap);
|
2012-06-27 20:27:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void udf_free_partition(struct udf_part_map *map)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct udf_meta_data *mdata;
|
|
|
|
|
|
|
|
if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
|
|
|
|
iput(map->s_uspace.s_table);
|
|
|
|
if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
|
|
|
|
udf_sb_free_bitmap(map->s_uspace.s_bitmap);
|
|
|
|
if (map->s_partition_type == UDF_SPARABLE_MAP15)
|
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
brelse(map->s_type_specific.s_sparing.s_spar_map[i]);
|
|
|
|
else if (map->s_partition_type == UDF_METADATA_MAP25) {
|
|
|
|
mdata = &map->s_type_specific.s_metadata;
|
|
|
|
iput(mdata->s_metadata_fe);
|
|
|
|
mdata->s_metadata_fe = NULL;
|
|
|
|
|
|
|
|
iput(mdata->s_mirror_fe);
|
|
|
|
mdata->s_mirror_fe = NULL;
|
|
|
|
|
|
|
|
iput(mdata->s_bitmap_fe);
|
|
|
|
mdata->s_bitmap_fe = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void udf_sb_free_partitions(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
|
|
|
int i;
|
2017-08-15 15:03:06 +00:00
|
|
|
|
|
|
|
if (!sbi->s_partmaps)
|
2013-01-14 21:53:47 +00:00
|
|
|
return;
|
2012-06-27 20:27:05 +00:00
|
|
|
for (i = 0; i < sbi->s_partitions; i++)
|
|
|
|
udf_free_partition(&sbi->s_partmaps[i]);
|
|
|
|
kfree(sbi->s_partmaps);
|
|
|
|
sbi->s_partmaps = NULL;
|
|
|
|
}
|
|
|
|
|
2011-12-09 02:32:45 +00:00
|
|
|
static int udf_show_options(struct seq_file *seq, struct dentry *root)
|
2008-02-08 12:21:50 +00:00
|
|
|
{
|
2011-12-09 02:32:45 +00:00
|
|
|
struct super_block *sb = root->d_sb;
|
2008-02-08 12:21:50 +00:00
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
|
|
|
|
|
|
|
if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT))
|
|
|
|
seq_puts(seq, ",nostrict");
|
2009-03-11 14:57:47 +00:00
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_BLOCKSIZE_SET))
|
2008-02-08 12:21:50 +00:00
|
|
|
seq_printf(seq, ",bs=%lu", sb->s_blocksize);
|
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_UNHIDE))
|
|
|
|
seq_puts(seq, ",unhide");
|
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_UNDELETE))
|
|
|
|
seq_puts(seq, ",undelete");
|
|
|
|
if (!UDF_QUERY_FLAG(sb, UDF_FLAG_USE_AD_IN_ICB))
|
|
|
|
seq_puts(seq, ",noadinicb");
|
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_USE_SHORT_AD))
|
|
|
|
seq_puts(seq, ",shortad");
|
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_UID_FORGET))
|
|
|
|
seq_puts(seq, ",uid=forget");
|
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_FORGET))
|
|
|
|
seq_puts(seq, ",gid=forget");
|
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_UID_SET))
|
2012-02-10 20:20:35 +00:00
|
|
|
seq_printf(seq, ",uid=%u", from_kuid(&init_user_ns, sbi->s_uid));
|
2008-02-08 12:21:50 +00:00
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_SET))
|
2012-02-10 20:20:35 +00:00
|
|
|
seq_printf(seq, ",gid=%u", from_kgid(&init_user_ns, sbi->s_gid));
|
2008-02-08 12:21:50 +00:00
|
|
|
if (sbi->s_umask != 0)
|
2011-07-26 07:18:29 +00:00
|
|
|
seq_printf(seq, ",umask=%ho", sbi->s_umask);
|
2008-12-02 12:40:11 +00:00
|
|
|
if (sbi->s_fmode != UDF_INVALID_MODE)
|
2011-07-26 07:18:29 +00:00
|
|
|
seq_printf(seq, ",mode=%ho", sbi->s_fmode);
|
2008-12-02 12:40:11 +00:00
|
|
|
if (sbi->s_dmode != UDF_INVALID_MODE)
|
2011-07-26 07:18:29 +00:00
|
|
|
seq_printf(seq, ",dmode=%ho", sbi->s_dmode);
|
2008-02-08 12:21:50 +00:00
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_SESSION_SET))
|
2017-10-12 13:48:41 +00:00
|
|
|
seq_printf(seq, ",session=%d", sbi->s_session);
|
2008-02-08 12:21:50 +00:00
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_LASTBLOCK_SET))
|
|
|
|
seq_printf(seq, ",lastblock=%u", sbi->s_last_block);
|
2009-03-19 15:21:38 +00:00
|
|
|
if (sbi->s_anchor != 0)
|
|
|
|
seq_printf(seq, ",anchor=%u", sbi->s_anchor);
|
2021-08-08 16:24:36 +00:00
|
|
|
if (sbi->s_nls_map)
|
2008-02-08 12:21:50 +00:00
|
|
|
seq_printf(seq, ",iocharset=%s", sbi->s_nls_map->charset);
|
2021-08-08 16:24:36 +00:00
|
|
|
else
|
|
|
|
seq_puts(seq, ",iocharset=utf8");
|
2008-02-08 12:21:50 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* udf_parse_options
|
|
|
|
*
|
|
|
|
* PURPOSE
|
|
|
|
* Parse mount options.
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* The following mount options are supported:
|
|
|
|
*
|
|
|
|
* gid= Set the default group.
|
|
|
|
* umask= Set the default umask.
|
2008-11-16 19:52:19 +00:00
|
|
|
* mode= Set the default file permissions.
|
|
|
|
* dmode= Set the default directory permissions.
|
2005-04-16 22:20:36 +00:00
|
|
|
* uid= Set the default user.
|
|
|
|
* bs= Set the block size.
|
|
|
|
* unhide Show otherwise hidden files.
|
|
|
|
* undelete Show deleted files in lists.
|
|
|
|
* adinicb Embed data in the inode (default)
|
|
|
|
* noadinicb Don't embed data in the inode
|
|
|
|
* shortad Use short ad's
|
|
|
|
* longad Use long ad's (default)
|
|
|
|
* nostrict Unset strict conformance
|
|
|
|
* iocharset= Set the NLS character set
|
|
|
|
*
|
|
|
|
* The remaining are for debugging and disaster recovery:
|
|
|
|
*
|
2007-07-21 11:37:18 +00:00
|
|
|
* novrs Skip volume sequence recognition
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* The following expect a offset from 0.
|
|
|
|
*
|
|
|
|
* session= Set the CDROM session (default= last session)
|
|
|
|
* anchor= Override standard anchor location. (default= 256)
|
|
|
|
* volume= Override the VolumeDesc location. (unused)
|
|
|
|
* partition= Override the PartitionDesc location. (unused)
|
|
|
|
* lastblock= Set the last block of the filesystem/
|
|
|
|
*
|
|
|
|
* The following expect a offset from the partition root.
|
|
|
|
*
|
|
|
|
* fileset= Override the fileset block location. (unused)
|
|
|
|
* rootdir= Override the root directory location. (unused)
|
|
|
|
* WARNING: overriding the rootdir to a non-directory may
|
|
|
|
* yield highly unpredictable results.
|
|
|
|
*
|
|
|
|
* PRE-CONDITIONS
|
|
|
|
* options Pointer to mount options string.
|
|
|
|
* uopts Pointer to mount options variable.
|
|
|
|
*
|
|
|
|
* POST-CONDITIONS
|
|
|
|
* <return> 1 Mount options parsed okay.
|
|
|
|
* <return> 0 Error parsing mount options.
|
|
|
|
*
|
|
|
|
* HISTORY
|
|
|
|
* July 1, 1997 - Andrew E. Mileski
|
|
|
|
* Written, tested, and released.
|
|
|
|
*/
|
2007-07-21 11:37:18 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
enum {
|
|
|
|
Opt_novrs, Opt_nostrict, Opt_bs, Opt_unhide, Opt_undelete,
|
|
|
|
Opt_noadinicb, Opt_adinicb, Opt_shortad, Opt_longad,
|
|
|
|
Opt_gid, Opt_uid, Opt_umask, Opt_session, Opt_lastblock,
|
|
|
|
Opt_anchor, Opt_volume, Opt_partition, Opt_fileset,
|
|
|
|
Opt_rootdir, Opt_utf8, Opt_iocharset,
|
2008-11-16 19:52:19 +00:00
|
|
|
Opt_err, Opt_uforget, Opt_uignore, Opt_gforget, Opt_gignore,
|
|
|
|
Opt_fmode, Opt_dmode
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2008-10-13 09:46:57 +00:00
|
|
|
static const match_table_t tokens = {
|
2007-07-21 11:37:18 +00:00
|
|
|
{Opt_novrs, "novrs"},
|
|
|
|
{Opt_nostrict, "nostrict"},
|
|
|
|
{Opt_bs, "bs=%u"},
|
|
|
|
{Opt_unhide, "unhide"},
|
|
|
|
{Opt_undelete, "undelete"},
|
|
|
|
{Opt_noadinicb, "noadinicb"},
|
|
|
|
{Opt_adinicb, "adinicb"},
|
|
|
|
{Opt_shortad, "shortad"},
|
|
|
|
{Opt_longad, "longad"},
|
|
|
|
{Opt_uforget, "uid=forget"},
|
|
|
|
{Opt_uignore, "uid=ignore"},
|
|
|
|
{Opt_gforget, "gid=forget"},
|
|
|
|
{Opt_gignore, "gid=ignore"},
|
|
|
|
{Opt_gid, "gid=%u"},
|
|
|
|
{Opt_uid, "uid=%u"},
|
|
|
|
{Opt_umask, "umask=%o"},
|
|
|
|
{Opt_session, "session=%u"},
|
|
|
|
{Opt_lastblock, "lastblock=%u"},
|
|
|
|
{Opt_anchor, "anchor=%u"},
|
|
|
|
{Opt_volume, "volume=%u"},
|
|
|
|
{Opt_partition, "partition=%u"},
|
|
|
|
{Opt_fileset, "fileset=%u"},
|
|
|
|
{Opt_rootdir, "rootdir=%u"},
|
|
|
|
{Opt_utf8, "utf8"},
|
|
|
|
{Opt_iocharset, "iocharset=%s"},
|
2008-11-16 19:52:19 +00:00
|
|
|
{Opt_fmode, "mode=%o"},
|
|
|
|
{Opt_dmode, "dmode=%o"},
|
2007-07-21 11:37:18 +00:00
|
|
|
{Opt_err, NULL}
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2008-02-08 12:21:50 +00:00
|
|
|
static int udf_parse_options(char *options, struct udf_options *uopt,
|
|
|
|
bool remount)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
int option;
|
2021-01-29 04:55:02 +00:00
|
|
|
unsigned int uv;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
uopt->novrs = 0;
|
|
|
|
uopt->session = 0xFFFFFFFF;
|
|
|
|
uopt->lastblock = 0;
|
|
|
|
uopt->anchor = 0;
|
|
|
|
|
|
|
|
if (!options)
|
|
|
|
return 1;
|
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
while ((p = strsep(&options, ",")) != NULL) {
|
2005-04-16 22:20:36 +00:00
|
|
|
substring_t args[MAX_OPT_ARGS];
|
|
|
|
int token;
|
2014-01-29 09:13:16 +00:00
|
|
|
unsigned n;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!*p)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
token = match_token(p, tokens, args);
|
2007-07-19 08:47:43 +00:00
|
|
|
switch (token) {
|
|
|
|
case Opt_novrs:
|
|
|
|
uopt->novrs = 1;
|
2009-03-06 08:16:49 +00:00
|
|
|
break;
|
2007-07-19 08:47:43 +00:00
|
|
|
case Opt_bs:
|
|
|
|
if (match_int(&args[0], &option))
|
|
|
|
return 0;
|
2014-01-29 09:13:16 +00:00
|
|
|
n = option;
|
|
|
|
if (n != 512 && n != 1024 && n != 2048 && n != 4096)
|
|
|
|
return 0;
|
|
|
|
uopt->blocksize = n;
|
2009-03-11 14:57:47 +00:00
|
|
|
uopt->flags |= (1 << UDF_FLAG_BLOCKSIZE_SET);
|
2007-07-19 08:47:43 +00:00
|
|
|
break;
|
|
|
|
case Opt_unhide:
|
|
|
|
uopt->flags |= (1 << UDF_FLAG_UNHIDE);
|
|
|
|
break;
|
|
|
|
case Opt_undelete:
|
|
|
|
uopt->flags |= (1 << UDF_FLAG_UNDELETE);
|
|
|
|
break;
|
|
|
|
case Opt_noadinicb:
|
|
|
|
uopt->flags &= ~(1 << UDF_FLAG_USE_AD_IN_ICB);
|
|
|
|
break;
|
|
|
|
case Opt_adinicb:
|
|
|
|
uopt->flags |= (1 << UDF_FLAG_USE_AD_IN_ICB);
|
|
|
|
break;
|
|
|
|
case Opt_shortad:
|
|
|
|
uopt->flags |= (1 << UDF_FLAG_USE_SHORT_AD);
|
|
|
|
break;
|
|
|
|
case Opt_longad:
|
|
|
|
uopt->flags &= ~(1 << UDF_FLAG_USE_SHORT_AD);
|
|
|
|
break;
|
|
|
|
case Opt_gid:
|
2021-01-29 04:55:02 +00:00
|
|
|
if (match_uint(args, &uv))
|
2007-07-19 08:47:43 +00:00
|
|
|
return 0;
|
2021-01-29 04:55:02 +00:00
|
|
|
uopt->gid = make_kgid(current_user_ns(), uv);
|
2012-02-10 20:20:35 +00:00
|
|
|
if (!gid_valid(uopt->gid))
|
|
|
|
return 0;
|
2007-07-31 07:39:40 +00:00
|
|
|
uopt->flags |= (1 << UDF_FLAG_GID_SET);
|
2007-07-19 08:47:43 +00:00
|
|
|
break;
|
|
|
|
case Opt_uid:
|
2021-01-29 04:55:02 +00:00
|
|
|
if (match_uint(args, &uv))
|
2007-07-19 08:47:43 +00:00
|
|
|
return 0;
|
2021-01-29 04:55:02 +00:00
|
|
|
uopt->uid = make_kuid(current_user_ns(), uv);
|
2012-02-10 20:20:35 +00:00
|
|
|
if (!uid_valid(uopt->uid))
|
|
|
|
return 0;
|
2007-07-31 07:39:40 +00:00
|
|
|
uopt->flags |= (1 << UDF_FLAG_UID_SET);
|
2007-07-19 08:47:43 +00:00
|
|
|
break;
|
|
|
|
case Opt_umask:
|
|
|
|
if (match_octal(args, &option))
|
|
|
|
return 0;
|
|
|
|
uopt->umask = option;
|
|
|
|
break;
|
|
|
|
case Opt_nostrict:
|
|
|
|
uopt->flags &= ~(1 << UDF_FLAG_STRICT);
|
|
|
|
break;
|
|
|
|
case Opt_session:
|
|
|
|
if (match_int(args, &option))
|
|
|
|
return 0;
|
|
|
|
uopt->session = option;
|
2008-02-08 12:21:50 +00:00
|
|
|
if (!remount)
|
|
|
|
uopt->flags |= (1 << UDF_FLAG_SESSION_SET);
|
2007-07-19 08:47:43 +00:00
|
|
|
break;
|
|
|
|
case Opt_lastblock:
|
|
|
|
if (match_int(args, &option))
|
|
|
|
return 0;
|
|
|
|
uopt->lastblock = option;
|
2008-02-08 12:21:50 +00:00
|
|
|
if (!remount)
|
|
|
|
uopt->flags |= (1 << UDF_FLAG_LASTBLOCK_SET);
|
2007-07-19 08:47:43 +00:00
|
|
|
break;
|
|
|
|
case Opt_anchor:
|
|
|
|
if (match_int(args, &option))
|
|
|
|
return 0;
|
|
|
|
uopt->anchor = option;
|
|
|
|
break;
|
|
|
|
case Opt_volume:
|
|
|
|
case Opt_partition:
|
|
|
|
case Opt_fileset:
|
|
|
|
case Opt_rootdir:
|
2018-02-22 13:33:04 +00:00
|
|
|
/* Ignored (never implemented properly) */
|
2007-07-19 08:47:43 +00:00
|
|
|
break;
|
|
|
|
case Opt_utf8:
|
2021-08-08 16:24:36 +00:00
|
|
|
if (!remount) {
|
|
|
|
unload_nls(uopt->nls_map);
|
|
|
|
uopt->nls_map = NULL;
|
|
|
|
}
|
2007-07-19 08:47:43 +00:00
|
|
|
break;
|
|
|
|
case Opt_iocharset:
|
2018-02-25 13:25:07 +00:00
|
|
|
if (!remount) {
|
2021-08-08 16:24:36 +00:00
|
|
|
unload_nls(uopt->nls_map);
|
|
|
|
uopt->nls_map = NULL;
|
|
|
|
}
|
|
|
|
/* When nls_map is not loaded then UTF-8 is used */
|
|
|
|
if (!remount && strcmp(args[0].from, "utf8") != 0) {
|
2018-02-25 13:25:07 +00:00
|
|
|
uopt->nls_map = load_nls(args[0].from);
|
2021-08-08 16:24:36 +00:00
|
|
|
if (!uopt->nls_map) {
|
|
|
|
pr_err("iocharset %s not found\n",
|
|
|
|
args[0].from);
|
|
|
|
return 0;
|
|
|
|
}
|
2018-02-25 13:25:07 +00:00
|
|
|
}
|
2007-07-19 08:47:43 +00:00
|
|
|
break;
|
|
|
|
case Opt_uforget:
|
|
|
|
uopt->flags |= (1 << UDF_FLAG_UID_FORGET);
|
|
|
|
break;
|
2018-02-21 16:27:44 +00:00
|
|
|
case Opt_uignore:
|
2007-07-19 08:47:43 +00:00
|
|
|
case Opt_gignore:
|
2018-02-21 16:27:44 +00:00
|
|
|
/* These options are superseeded by uid=<number> */
|
2007-07-19 08:47:43 +00:00
|
|
|
break;
|
|
|
|
case Opt_gforget:
|
|
|
|
uopt->flags |= (1 << UDF_FLAG_GID_FORGET);
|
|
|
|
break;
|
2008-11-16 19:52:19 +00:00
|
|
|
case Opt_fmode:
|
|
|
|
if (match_octal(args, &option))
|
|
|
|
return 0;
|
|
|
|
uopt->fmode = option & 0777;
|
|
|
|
break;
|
|
|
|
case Opt_dmode:
|
|
|
|
if (match_octal(args, &option))
|
|
|
|
return 0;
|
|
|
|
uopt->dmode = option & 0777;
|
|
|
|
break;
|
2007-07-19 08:47:43 +00:00
|
|
|
default:
|
2011-10-10 08:08:05 +00:00
|
|
|
pr_err("bad mount option \"%s\" or missing value\n", p);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
static int udf_remount_fs(struct super_block *sb, int *flags, char *options)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct udf_options uopt;
|
2008-02-08 12:20:30 +00:00
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
2010-05-19 11:16:40 +00:00
|
|
|
int error = 0;
|
2018-09-06 13:56:10 +00:00
|
|
|
|
|
|
|
if (!(*flags & SB_RDONLY) && UDF_QUERY_FLAG(sb, UDF_FLAG_RW_INCOMPAT))
|
|
|
|
return -EACCES;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-03-13 14:14:33 +00:00
|
|
|
sync_filesystem(sb);
|
2013-07-25 14:15:16 +00:00
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
uopt.flags = sbi->s_flags;
|
|
|
|
uopt.uid = sbi->s_uid;
|
|
|
|
uopt.gid = sbi->s_gid;
|
|
|
|
uopt.umask = sbi->s_umask;
|
2008-11-16 19:52:19 +00:00
|
|
|
uopt.fmode = sbi->s_fmode;
|
|
|
|
uopt.dmode = sbi->s_dmode;
|
2018-02-25 13:25:07 +00:00
|
|
|
uopt.nls_map = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-08 12:21:50 +00:00
|
|
|
if (!udf_parse_options(options, &uopt, true))
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2010-10-20 20:17:28 +00:00
|
|
|
write_lock(&sbi->s_cred_lock);
|
2008-02-08 12:20:30 +00:00
|
|
|
sbi->s_flags = uopt.flags;
|
|
|
|
sbi->s_uid = uopt.uid;
|
|
|
|
sbi->s_gid = uopt.gid;
|
|
|
|
sbi->s_umask = uopt.umask;
|
2008-11-16 19:52:19 +00:00
|
|
|
sbi->s_fmode = uopt.fmode;
|
|
|
|
sbi->s_dmode = uopt.dmode;
|
2010-10-20 20:17:28 +00:00
|
|
|
write_unlock(&sbi->s_cred_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-11-27 21:05:09 +00:00
|
|
|
if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
|
2010-05-19 11:16:40 +00:00
|
|
|
goto out_unlock;
|
|
|
|
|
2017-11-27 21:05:09 +00:00
|
|
|
if (*flags & SB_RDONLY)
|
2005-04-16 22:20:36 +00:00
|
|
|
udf_close_lvid(sb);
|
2010-05-19 14:28:56 +00:00
|
|
|
else
|
2005-04-16 22:20:36 +00:00
|
|
|
udf_open_lvid(sb);
|
|
|
|
|
2010-05-19 11:16:40 +00:00
|
|
|
out_unlock:
|
|
|
|
return error;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2019-07-11 13:38:51 +00:00
|
|
|
/*
|
|
|
|
* Check VSD descriptor. Returns -1 in case we are at the end of volume
|
|
|
|
* recognition area, 0 if the descriptor is valid but non-interesting, 1 if
|
|
|
|
* we found one of NSR descriptors we are looking for.
|
|
|
|
*/
|
|
|
|
static int identify_vsd(const struct volStructDesc *vsd)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!memcmp(vsd->stdIdent, VSD_STD_ID_CD001, VSD_STD_ID_LEN)) {
|
|
|
|
switch (vsd->structType) {
|
|
|
|
case 0:
|
|
|
|
udf_debug("ISO9660 Boot Record found\n");
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
udf_debug("ISO9660 Primary Volume Descriptor found\n");
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
udf_debug("ISO9660 Supplementary Volume Descriptor found\n");
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
udf_debug("ISO9660 Volume Partition Descriptor found\n");
|
|
|
|
break;
|
|
|
|
case 255:
|
|
|
|
udf_debug("ISO9660 Volume Descriptor Set Terminator found\n");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
udf_debug("ISO9660 VRS (%u) found\n", vsd->structType);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else if (!memcmp(vsd->stdIdent, VSD_STD_ID_BEA01, VSD_STD_ID_LEN))
|
|
|
|
; /* ret = 0 */
|
|
|
|
else if (!memcmp(vsd->stdIdent, VSD_STD_ID_NSR02, VSD_STD_ID_LEN))
|
|
|
|
ret = 1;
|
|
|
|
else if (!memcmp(vsd->stdIdent, VSD_STD_ID_NSR03, VSD_STD_ID_LEN))
|
|
|
|
ret = 1;
|
|
|
|
else if (!memcmp(vsd->stdIdent, VSD_STD_ID_BOOT2, VSD_STD_ID_LEN))
|
|
|
|
; /* ret = 0 */
|
|
|
|
else if (!memcmp(vsd->stdIdent, VSD_STD_ID_CDW02, VSD_STD_ID_LEN))
|
|
|
|
; /* ret = 0 */
|
|
|
|
else {
|
|
|
|
/* TEA01 or invalid id : end of volume recognition area */
|
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check Volume Structure Descriptors (ECMA 167 2/9.1)
|
|
|
|
* We also check any "CD-ROM Volume Descriptor Set" (ECMA 167 2/8.3.1)
|
|
|
|
* @return 1 if NSR02 or NSR03 found,
|
|
|
|
* -1 if first sector read error, 0 otherwise
|
|
|
|
*/
|
|
|
|
static int udf_check_vsd(struct super_block *sb)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct volStructDesc *vsd = NULL;
|
udf: fix for pathetic mount times in case of invalid file system
The UDF driver was not strict enough about checking the IDs in the
VSDs when mounting, which resulted in reading through all the sectors
of the block device in some unfortunate cases. Eg, trying to mount my
uninitialized 200G SSD partition (all 0xFF bytes) took ~350 minutes to
fail, because the code expected some of the valid IDs or a zero byte.
During this, the mount couldn't be killed, sync from the cmdline
blocked, and the machine froze into the shutdown. Valid filesystems
(extX, btrfs, ntfs) were rejected by the mere accident of having a
zero byte at just the right place in some of their sectors, close
enough to the beginning not to generate excess I/O. The fix adds a
hard limit on the VSD sector offset, adds the two missing VSD IDs, and
stops scanning when encountering an invalid ID. Also replaced the
magic number 32768 with a more meaningful #define, and supressed the
bogus message about failing to read the first sector if no UDF fs was
detected.
Signed-off-by: Peter A. Felvegi <petschy@gmail.com>
Signed-off-by: Jan Kara <jack@suse.cz>
2013-10-18 18:07:44 +00:00
|
|
|
loff_t sector = VSD_FIRST_SECTOR_OFFSET;
|
2005-04-16 22:20:36 +00:00
|
|
|
int sectorsize;
|
|
|
|
struct buffer_head *bh = NULL;
|
2019-07-11 13:38:51 +00:00
|
|
|
int nsr = 0;
|
2008-02-08 12:20:30 +00:00
|
|
|
struct udf_sb_info *sbi;
|
udf: fix the problem that the disc content is not displayed
When the capacity of the disc is too large (assuming the 4.7G
specification), the disc (UDF file system) will be burned
multiple times in the windows (Multisession Usage). When the
remaining capacity of the CD is less than 300M (estimated
value, for reference only), open the CD in the Linux system,
the content of the CD is displayed as blank (the kernel will
say "No VRS found"). Windows can display the contents of the
CD normally.
Through analysis, in the "fs/udf/super.c": udf_check_vsd
function, the actual value of VSD_MAX_SECTOR_OFFSET may
be much larger than 0x800000. According to the current code
logic, it is found that the type of sbi->s_session is "__s32",
when the remaining capacity of the disc is less than 300M
(take a set of test values: sector=3154903040,
sbi->s_session=1540464, sb->s_blocksize_bits=11 ), the
calculation result of "sbi->s_session << sb->s_blocksize_bits"
will overflow. Therefore, it is necessary to convert the
type of s_session to "loff_t" (when udf_check_vsd starts,
assign a value to _sector, which is also converted in this
way), so that the result will not overflow, and then the
content of the disc can be displayed normally.
Link: https://lore.kernel.org/r/20210114075741.30448-1-changlianzhi@uniontech.com
Signed-off-by: lianzhi chang <changlianzhi@uniontech.com>
Signed-off-by: Jan Kara <jack@suse.cz>
2021-01-14 07:57:41 +00:00
|
|
|
loff_t session_offset;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
sbi = UDF_SB(sb);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (sb->s_blocksize < sizeof(struct volStructDesc))
|
|
|
|
sectorsize = sizeof(struct volStructDesc);
|
|
|
|
else
|
|
|
|
sectorsize = sb->s_blocksize;
|
|
|
|
|
udf: fix the problem that the disc content is not displayed
When the capacity of the disc is too large (assuming the 4.7G
specification), the disc (UDF file system) will be burned
multiple times in the windows (Multisession Usage). When the
remaining capacity of the CD is less than 300M (estimated
value, for reference only), open the CD in the Linux system,
the content of the CD is displayed as blank (the kernel will
say "No VRS found"). Windows can display the contents of the
CD normally.
Through analysis, in the "fs/udf/super.c": udf_check_vsd
function, the actual value of VSD_MAX_SECTOR_OFFSET may
be much larger than 0x800000. According to the current code
logic, it is found that the type of sbi->s_session is "__s32",
when the remaining capacity of the disc is less than 300M
(take a set of test values: sector=3154903040,
sbi->s_session=1540464, sb->s_blocksize_bits=11 ), the
calculation result of "sbi->s_session << sb->s_blocksize_bits"
will overflow. Therefore, it is necessary to convert the
type of s_session to "loff_t" (when udf_check_vsd starts,
assign a value to _sector, which is also converted in this
way), so that the result will not overflow, and then the
content of the disc can be displayed normally.
Link: https://lore.kernel.org/r/20210114075741.30448-1-changlianzhi@uniontech.com
Signed-off-by: lianzhi chang <changlianzhi@uniontech.com>
Signed-off-by: Jan Kara <jack@suse.cz>
2021-01-14 07:57:41 +00:00
|
|
|
session_offset = (loff_t)sbi->s_session << sb->s_blocksize_bits;
|
|
|
|
sector += session_offset;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-10-12 13:48:41 +00:00
|
|
|
udf_debug("Starting at sector %u (%lu byte sectors)\n",
|
2008-04-14 15:13:01 +00:00
|
|
|
(unsigned int)(sector >> sb->s_blocksize_bits),
|
|
|
|
sb->s_blocksize);
|
udf: fix for pathetic mount times in case of invalid file system
The UDF driver was not strict enough about checking the IDs in the
VSDs when mounting, which resulted in reading through all the sectors
of the block device in some unfortunate cases. Eg, trying to mount my
uninitialized 200G SSD partition (all 0xFF bytes) took ~350 minutes to
fail, because the code expected some of the valid IDs or a zero byte.
During this, the mount couldn't be killed, sync from the cmdline
blocked, and the machine froze into the shutdown. Valid filesystems
(extX, btrfs, ntfs) were rejected by the mere accident of having a
zero byte at just the right place in some of their sectors, close
enough to the beginning not to generate excess I/O. The fix adds a
hard limit on the VSD sector offset, adds the two missing VSD IDs, and
stops scanning when encountering an invalid ID. Also replaced the
magic number 32768 with a more meaningful #define, and supressed the
bogus message about failing to read the first sector if no UDF fs was
detected.
Signed-off-by: Peter A. Felvegi <petschy@gmail.com>
Signed-off-by: Jan Kara <jack@suse.cz>
2013-10-18 18:07:44 +00:00
|
|
|
/* Process the sequence (if applicable). The hard limit on the sector
|
|
|
|
* offset is arbitrary, hopefully large enough so that all valid UDF
|
|
|
|
* filesystems will be recognised. There is no mention of an upper
|
|
|
|
* bound to the size of the volume recognition area in the standard.
|
|
|
|
* The limit will prevent the code to read all the sectors of a
|
|
|
|
* specially crafted image (like a bluray disc full of CD001 sectors),
|
|
|
|
* potentially causing minutes or even hours of uninterruptible I/O
|
|
|
|
* activity. This actually happened with uninitialised SSD partitions
|
|
|
|
* (all 0xFF) before the check for the limit and all valid IDs were
|
|
|
|
* added */
|
2019-07-11 13:38:51 +00:00
|
|
|
for (; !nsr && sector < VSD_MAX_SECTOR_OFFSET; sector += sectorsize) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Read a block */
|
2023-01-18 12:27:07 +00:00
|
|
|
bh = sb_bread(sb, sector >> sb->s_blocksize_bits);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!bh)
|
|
|
|
break;
|
|
|
|
|
|
|
|
vsd = (struct volStructDesc *)(bh->b_data +
|
2008-02-08 12:20:28 +00:00
|
|
|
(sector & (sb->s_blocksize - 1)));
|
2019-07-11 13:38:51 +00:00
|
|
|
nsr = identify_vsd(vsd);
|
2019-07-11 13:38:52 +00:00
|
|
|
/* Found NSR or end? */
|
|
|
|
if (nsr) {
|
|
|
|
brelse(bh);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Special handling for improperly formatted VRS (e.g., Win10)
|
|
|
|
* where components are separated by 2048 bytes even though
|
|
|
|
* sectors are 4K
|
|
|
|
*/
|
|
|
|
if (sb->s_blocksize == 4096) {
|
|
|
|
nsr = identify_vsd(vsd + 1);
|
|
|
|
/* Ignore unknown IDs... */
|
|
|
|
if (nsr < 0)
|
|
|
|
nsr = 0;
|
|
|
|
}
|
2007-05-08 07:35:16 +00:00
|
|
|
brelse(bh);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2019-07-11 13:38:51 +00:00
|
|
|
if (nsr > 0)
|
|
|
|
return 1;
|
udf: fix the problem that the disc content is not displayed
When the capacity of the disc is too large (assuming the 4.7G
specification), the disc (UDF file system) will be burned
multiple times in the windows (Multisession Usage). When the
remaining capacity of the CD is less than 300M (estimated
value, for reference only), open the CD in the Linux system,
the content of the CD is displayed as blank (the kernel will
say "No VRS found"). Windows can display the contents of the
CD normally.
Through analysis, in the "fs/udf/super.c": udf_check_vsd
function, the actual value of VSD_MAX_SECTOR_OFFSET may
be much larger than 0x800000. According to the current code
logic, it is found that the type of sbi->s_session is "__s32",
when the remaining capacity of the disc is less than 300M
(take a set of test values: sector=3154903040,
sbi->s_session=1540464, sb->s_blocksize_bits=11 ), the
calculation result of "sbi->s_session << sb->s_blocksize_bits"
will overflow. Therefore, it is necessary to convert the
type of s_session to "loff_t" (when udf_check_vsd starts,
assign a value to _sector, which is also converted in this
way), so that the result will not overflow, and then the
content of the disc can be displayed normally.
Link: https://lore.kernel.org/r/20210114075741.30448-1-changlianzhi@uniontech.com
Signed-off-by: lianzhi chang <changlianzhi@uniontech.com>
Signed-off-by: Jan Kara <jack@suse.cz>
2021-01-14 07:57:41 +00:00
|
|
|
else if (!bh && sector - session_offset == VSD_FIRST_SECTOR_OFFSET)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -1;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-08-29 12:19:30 +00:00
|
|
|
static int udf_verify_domain_identifier(struct super_block *sb,
|
|
|
|
struct regid *ident, char *dname)
|
|
|
|
{
|
2020-01-07 21:29:03 +00:00
|
|
|
struct domainIdentSuffix *suffix;
|
2019-08-29 12:19:30 +00:00
|
|
|
|
|
|
|
if (memcmp(ident->ident, UDF_ID_COMPLIANT, strlen(UDF_ID_COMPLIANT))) {
|
|
|
|
udf_warn(sb, "Not OSTA UDF compliant %s descriptor.\n", dname);
|
|
|
|
goto force_ro;
|
|
|
|
}
|
2020-01-12 22:13:53 +00:00
|
|
|
if (ident->flags & ENTITYID_FLAGS_DIRTY) {
|
2019-08-29 12:19:30 +00:00
|
|
|
udf_warn(sb, "Possibly not OSTA UDF compliant %s descriptor.\n",
|
|
|
|
dname);
|
|
|
|
goto force_ro;
|
|
|
|
}
|
2020-01-07 21:29:03 +00:00
|
|
|
suffix = (struct domainIdentSuffix *)ident->identSuffix;
|
|
|
|
if ((suffix->domainFlags & DOMAIN_FLAGS_HARD_WRITE_PROTECT) ||
|
|
|
|
(suffix->domainFlags & DOMAIN_FLAGS_SOFT_WRITE_PROTECT)) {
|
2019-08-29 12:19:30 +00:00
|
|
|
if (!sb_rdonly(sb)) {
|
|
|
|
udf_warn(sb, "Descriptor for %s marked write protected."
|
|
|
|
" Forcing read only mount.\n", dname);
|
|
|
|
}
|
|
|
|
goto force_ro;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
force_ro:
|
|
|
|
if (!sb_rdonly(sb))
|
|
|
|
return -EACCES;
|
|
|
|
UDF_SET_FLAG(sb, UDF_FLAG_RW_INCOMPAT);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int udf_load_fileset(struct super_block *sb, struct fileSetDesc *fset,
|
|
|
|
struct kernel_lb_addr *root)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = udf_verify_domain_identifier(sb, &fset->domainIdent, "file set");
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
*root = lelb_to_cpu(fset->rootDirectoryICB.extLocation);
|
|
|
|
UDF_SB(sb)->s_serial_number = le16_to_cpu(fset->descTag.tagSerialNum);
|
|
|
|
|
|
|
|
udf_debug("Rootdir at block=%u, partition=%u\n",
|
|
|
|
root->logicalBlockNum, root->partitionReferenceNum);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-02-08 12:20:28 +00:00
|
|
|
static int udf_find_fileset(struct super_block *sb,
|
2008-10-15 10:28:03 +00:00
|
|
|
struct kernel_lb_addr *fileset,
|
|
|
|
struct kernel_lb_addr *root)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2022-10-12 10:42:35 +00:00
|
|
|
struct buffer_head *bh;
|
2005-04-16 22:20:36 +00:00
|
|
|
uint16_t ident;
|
2019-08-29 12:11:54 +00:00
|
|
|
int ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2019-08-29 12:11:54 +00:00
|
|
|
if (fileset->logicalBlockNum == 0xFFFFFFFF &&
|
|
|
|
fileset->partitionReferenceNum == 0xFFFF)
|
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2019-08-29 12:11:54 +00:00
|
|
|
bh = udf_read_ptagged(sb, fileset, 0, &ident);
|
|
|
|
if (!bh)
|
|
|
|
return -EIO;
|
|
|
|
if (ident != TAG_IDENT_FSD) {
|
2007-05-08 07:35:16 +00:00
|
|
|
brelse(bh);
|
2019-08-29 12:11:54 +00:00
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2019-08-29 12:11:54 +00:00
|
|
|
|
|
|
|
udf_debug("Fileset at block=%u, partition=%u\n",
|
|
|
|
fileset->logicalBlockNum, fileset->partitionReferenceNum);
|
|
|
|
|
|
|
|
UDF_SB(sb)->s_partition = fileset->partitionReferenceNum;
|
|
|
|
ret = udf_load_fileset(sb, (struct fileSetDesc *)bh->b_data, root);
|
|
|
|
brelse(bh);
|
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-07-25 17:10:59 +00:00
|
|
|
/*
|
|
|
|
* Load primary Volume Descriptor Sequence
|
|
|
|
*
|
|
|
|
* Return <0 on error, 0 on success. -EAGAIN is special meaning next sequence
|
|
|
|
* should be tried.
|
|
|
|
*/
|
2008-04-01 14:50:35 +00:00
|
|
|
static int udf_load_pvoldesc(struct super_block *sb, sector_t block)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct primaryVolDesc *pvoldesc;
|
2016-01-15 08:44:22 +00:00
|
|
|
uint8_t *outstr;
|
2008-04-01 14:50:35 +00:00
|
|
|
struct buffer_head *bh;
|
|
|
|
uint16_t ident;
|
2020-09-22 08:13:22 +00:00
|
|
|
int ret;
|
2018-05-10 15:26:17 +00:00
|
|
|
struct timestamp *ts;
|
2008-11-16 18:01:44 +00:00
|
|
|
|
2016-01-15 08:44:22 +00:00
|
|
|
outstr = kmalloc(128, GFP_NOFS);
|
2008-11-16 18:01:44 +00:00
|
|
|
if (!outstr)
|
2016-01-15 08:44:22 +00:00
|
|
|
return -ENOMEM;
|
2008-04-01 14:50:35 +00:00
|
|
|
|
|
|
|
bh = udf_read_tagged(sb, block, block, &ident);
|
2013-07-25 17:10:59 +00:00
|
|
|
if (!bh) {
|
|
|
|
ret = -EAGAIN;
|
2008-11-16 18:01:44 +00:00
|
|
|
goto out2;
|
2013-07-25 17:10:59 +00:00
|
|
|
}
|
2008-11-16 18:01:44 +00:00
|
|
|
|
2013-07-25 17:10:59 +00:00
|
|
|
if (ident != TAG_IDENT_PVD) {
|
|
|
|
ret = -EIO;
|
|
|
|
goto out_bh;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
pvoldesc = (struct primaryVolDesc *)bh->b_data;
|
|
|
|
|
2018-05-10 15:26:17 +00:00
|
|
|
udf_disk_stamp_to_time(&UDF_SB(sb)->s_record_time,
|
|
|
|
pvoldesc->recordingDateAndTime);
|
|
|
|
ts = &pvoldesc->recordingDateAndTime;
|
|
|
|
udf_debug("recording time %04u/%02u/%02u %02u:%02u (%x)\n",
|
|
|
|
le16_to_cpu(ts->year), ts->month, ts->day, ts->hour,
|
|
|
|
ts->minute, le16_to_cpu(ts->typeAndTimezone));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2018-04-16 13:44:19 +00:00
|
|
|
ret = udf_dstrCS0toChar(sb, outstr, 31, pvoldesc->volIdent, 32);
|
2018-11-16 12:43:17 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
strcpy(UDF_SB(sb)->s_volume_ident, "InvalidName");
|
|
|
|
pr_warn("incorrect volume identification, setting to "
|
|
|
|
"'InvalidName'\n");
|
|
|
|
} else {
|
|
|
|
strncpy(UDF_SB(sb)->s_volume_ident, outstr, ret);
|
|
|
|
}
|
2016-01-15 08:44:22 +00:00
|
|
|
udf_debug("volIdent[] = '%s'\n", UDF_SB(sb)->s_volume_ident);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2018-04-16 13:44:19 +00:00
|
|
|
ret = udf_dstrCS0toChar(sb, outstr, 127, pvoldesc->volSetIdent, 128);
|
2018-11-16 12:43:17 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
ret = 0;
|
2016-01-15 08:44:22 +00:00
|
|
|
goto out_bh;
|
2018-11-16 12:43:17 +00:00
|
|
|
}
|
2016-01-15 08:44:22 +00:00
|
|
|
outstr[ret] = 0;
|
|
|
|
udf_debug("volSetIdent[] = '%s'\n", outstr);
|
2008-04-01 14:50:35 +00:00
|
|
|
|
2008-11-16 18:01:44 +00:00
|
|
|
ret = 0;
|
2013-07-25 17:10:59 +00:00
|
|
|
out_bh:
|
|
|
|
brelse(bh);
|
2008-11-16 18:01:44 +00:00
|
|
|
out2:
|
|
|
|
kfree(outstr);
|
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2011-10-23 10:28:32 +00:00
|
|
|
struct inode *udf_find_metadata_inode_efe(struct super_block *sb,
|
2016-05-18 21:09:19 +00:00
|
|
|
u32 meta_file_loc, u32 partition_ref)
|
2011-10-23 10:28:32 +00:00
|
|
|
{
|
|
|
|
struct kernel_lb_addr addr;
|
|
|
|
struct inode *metadata_fe;
|
|
|
|
|
|
|
|
addr.logicalBlockNum = meta_file_loc;
|
2016-05-18 21:09:19 +00:00
|
|
|
addr.partitionReferenceNum = partition_ref;
|
2011-10-23 10:28:32 +00:00
|
|
|
|
2014-10-09 10:52:16 +00:00
|
|
|
metadata_fe = udf_iget_special(sb, &addr);
|
2011-10-23 10:28:32 +00:00
|
|
|
|
2014-09-04 14:15:51 +00:00
|
|
|
if (IS_ERR(metadata_fe)) {
|
2011-10-23 10:28:32 +00:00
|
|
|
udf_warn(sb, "metadata inode efe not found\n");
|
2014-09-04 14:15:51 +00:00
|
|
|
return metadata_fe;
|
|
|
|
}
|
|
|
|
if (UDF_I(metadata_fe)->i_alloc_type != ICBTAG_FLAG_AD_SHORT) {
|
2011-10-23 10:28:32 +00:00
|
|
|
udf_warn(sb, "metadata inode efe does not have short allocation descriptors!\n");
|
|
|
|
iput(metadata_fe);
|
2014-09-04 14:15:51 +00:00
|
|
|
return ERR_PTR(-EIO);
|
2011-10-23 10:28:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return metadata_fe;
|
|
|
|
}
|
|
|
|
|
2016-05-18 21:09:19 +00:00
|
|
|
static int udf_load_metadata_files(struct super_block *sb, int partition,
|
|
|
|
int type1_index)
|
2008-04-08 18:37:21 +00:00
|
|
|
{
|
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
|
|
|
struct udf_part_map *map;
|
|
|
|
struct udf_meta_data *mdata;
|
2008-10-15 10:28:03 +00:00
|
|
|
struct kernel_lb_addr addr;
|
2014-09-04 14:15:51 +00:00
|
|
|
struct inode *fe;
|
2008-04-08 18:37:21 +00:00
|
|
|
|
|
|
|
map = &sbi->s_partmaps[partition];
|
|
|
|
mdata = &map->s_type_specific.s_metadata;
|
2016-05-18 21:09:19 +00:00
|
|
|
mdata->s_phys_partition_ref = type1_index;
|
2008-04-08 18:37:21 +00:00
|
|
|
|
|
|
|
/* metadata address */
|
2017-10-12 13:48:41 +00:00
|
|
|
udf_debug("Metadata file location: block = %u part = %u\n",
|
2016-05-18 21:09:19 +00:00
|
|
|
mdata->s_meta_file_loc, mdata->s_phys_partition_ref);
|
2008-04-08 18:37:21 +00:00
|
|
|
|
2014-09-04 14:15:51 +00:00
|
|
|
fe = udf_find_metadata_inode_efe(sb, mdata->s_meta_file_loc,
|
2016-05-18 21:09:19 +00:00
|
|
|
mdata->s_phys_partition_ref);
|
2014-09-04 14:15:51 +00:00
|
|
|
if (IS_ERR(fe)) {
|
2011-10-23 10:28:32 +00:00
|
|
|
/* mirror file entry */
|
2017-10-12 13:48:41 +00:00
|
|
|
udf_debug("Mirror metadata file location: block = %u part = %u\n",
|
2016-05-18 21:09:19 +00:00
|
|
|
mdata->s_mirror_file_loc, mdata->s_phys_partition_ref);
|
2008-04-08 18:37:21 +00:00
|
|
|
|
2014-09-04 14:15:51 +00:00
|
|
|
fe = udf_find_metadata_inode_efe(sb, mdata->s_mirror_file_loc,
|
2016-05-18 21:09:19 +00:00
|
|
|
mdata->s_phys_partition_ref);
|
2008-04-08 18:37:21 +00:00
|
|
|
|
2014-09-04 14:15:51 +00:00
|
|
|
if (IS_ERR(fe)) {
|
2011-10-23 10:28:32 +00:00
|
|
|
udf_err(sb, "Both metadata and mirror metadata inode efe can not found\n");
|
2014-09-04 14:15:51 +00:00
|
|
|
return PTR_ERR(fe);
|
2011-10-23 10:28:32 +00:00
|
|
|
}
|
2014-09-04 14:15:51 +00:00
|
|
|
mdata->s_mirror_fe = fe;
|
|
|
|
} else
|
|
|
|
mdata->s_metadata_fe = fe;
|
|
|
|
|
2008-04-08 18:37:21 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* bitmap file entry
|
|
|
|
* Note:
|
|
|
|
* Load only if bitmap file location differs from 0xFFFFFFFF (DCN-5102)
|
|
|
|
*/
|
|
|
|
if (mdata->s_bitmap_file_loc != 0xFFFFFFFF) {
|
|
|
|
addr.logicalBlockNum = mdata->s_bitmap_file_loc;
|
2016-05-18 21:09:19 +00:00
|
|
|
addr.partitionReferenceNum = mdata->s_phys_partition_ref;
|
2008-04-08 18:37:21 +00:00
|
|
|
|
2017-10-12 13:48:41 +00:00
|
|
|
udf_debug("Bitmap file location: block = %u part = %u\n",
|
2011-10-10 08:08:07 +00:00
|
|
|
addr.logicalBlockNum, addr.partitionReferenceNum);
|
2008-04-08 18:37:21 +00:00
|
|
|
|
2014-10-09 10:52:16 +00:00
|
|
|
fe = udf_iget_special(sb, &addr);
|
2014-09-04 14:15:51 +00:00
|
|
|
if (IS_ERR(fe)) {
|
2017-07-17 07:45:34 +00:00
|
|
|
if (sb_rdonly(sb))
|
2011-10-10 08:08:04 +00:00
|
|
|
udf_warn(sb, "bitmap inode efe not found but it's ok since the disc is mounted read-only\n");
|
2008-04-08 18:37:21 +00:00
|
|
|
else {
|
2011-10-10 08:08:03 +00:00
|
|
|
udf_err(sb, "bitmap inode efe not found and attempted read-write mount\n");
|
2014-09-04 14:15:51 +00:00
|
|
|
return PTR_ERR(fe);
|
2008-04-08 18:37:21 +00:00
|
|
|
}
|
2014-09-04 14:15:51 +00:00
|
|
|
} else
|
|
|
|
mdata->s_bitmap_fe = fe;
|
2008-04-08 18:37:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
udf_debug("udf_load_metadata_files Ok\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-02-08 12:20:34 +00:00
|
|
|
int udf_compute_nr_groups(struct super_block *sb, u32 partition)
|
|
|
|
{
|
|
|
|
struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
|
2008-02-14 15:15:45 +00:00
|
|
|
return DIV_ROUND_UP(map->s_partition_len +
|
|
|
|
(sizeof(struct spaceBitmapDesc) << 3),
|
|
|
|
sb->s_blocksize * 8);
|
2008-02-08 12:20:34 +00:00
|
|
|
}
|
|
|
|
|
2008-02-08 12:20:33 +00:00
|
|
|
static struct udf_bitmap *udf_sb_alloc_bitmap(struct super_block *sb, u32 index)
|
|
|
|
{
|
|
|
|
struct udf_bitmap *bitmap;
|
2020-08-27 22:16:52 +00:00
|
|
|
int nr_groups = udf_compute_nr_groups(sb, index);
|
2008-02-08 12:20:33 +00:00
|
|
|
|
2020-08-27 22:16:52 +00:00
|
|
|
bitmap = kvzalloc(struct_size(bitmap, s_block_bitmap, nr_groups),
|
|
|
|
GFP_KERNEL);
|
2017-08-15 15:03:06 +00:00
|
|
|
if (!bitmap)
|
2008-02-08 12:20:33 +00:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
bitmap->s_nr_groups = nr_groups;
|
|
|
|
return bitmap;
|
|
|
|
}
|
|
|
|
|
2018-09-06 13:46:17 +00:00
|
|
|
static int check_partition_desc(struct super_block *sb,
|
|
|
|
struct partitionDesc *p,
|
|
|
|
struct udf_part_map *map)
|
|
|
|
{
|
|
|
|
bool umap, utable, fmap, ftable;
|
|
|
|
struct partitionHeaderDesc *phd;
|
|
|
|
|
|
|
|
switch (le32_to_cpu(p->accessType)) {
|
|
|
|
case PD_ACCESS_TYPE_READ_ONLY:
|
|
|
|
case PD_ACCESS_TYPE_WRITE_ONCE:
|
|
|
|
case PD_ACCESS_TYPE_NONE:
|
|
|
|
goto force_ro;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* No Partition Header Descriptor? */
|
|
|
|
if (strcmp(p->partitionContents.ident, PD_PARTITION_CONTENTS_NSR02) &&
|
|
|
|
strcmp(p->partitionContents.ident, PD_PARTITION_CONTENTS_NSR03))
|
|
|
|
goto force_ro;
|
|
|
|
|
|
|
|
phd = (struct partitionHeaderDesc *)p->partitionContentsUse;
|
|
|
|
utable = phd->unallocSpaceTable.extLength;
|
|
|
|
umap = phd->unallocSpaceBitmap.extLength;
|
|
|
|
ftable = phd->freedSpaceTable.extLength;
|
|
|
|
fmap = phd->freedSpaceBitmap.extLength;
|
|
|
|
|
|
|
|
/* No allocation info? */
|
|
|
|
if (!utable && !umap && !ftable && !fmap)
|
|
|
|
goto force_ro;
|
|
|
|
|
|
|
|
/* We don't support blocks that require erasing before overwrite */
|
|
|
|
if (ftable || fmap)
|
|
|
|
goto force_ro;
|
|
|
|
/* UDF 2.60: 2.3.3 - no mixing of tables & bitmaps, no VAT. */
|
|
|
|
if (utable && umap)
|
|
|
|
goto force_ro;
|
|
|
|
|
|
|
|
if (map->s_partition_type == UDF_VIRTUAL_MAP15 ||
|
2020-01-12 14:49:59 +00:00
|
|
|
map->s_partition_type == UDF_VIRTUAL_MAP20 ||
|
|
|
|
map->s_partition_type == UDF_METADATA_MAP25)
|
2018-09-06 13:46:17 +00:00
|
|
|
goto force_ro;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
force_ro:
|
|
|
|
if (!sb_rdonly(sb))
|
|
|
|
return -EACCES;
|
|
|
|
UDF_SET_FLAG(sb, UDF_FLAG_RW_INCOMPAT);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-02 10:26:36 +00:00
|
|
|
static int udf_fill_partdesc_info(struct super_block *sb,
|
|
|
|
struct partitionDesc *p, int p_index)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-02-08 12:20:30 +00:00
|
|
|
struct udf_part_map *map;
|
2008-02-10 10:33:08 +00:00
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
2008-04-02 10:26:36 +00:00
|
|
|
struct partitionHeaderDesc *phd;
|
2018-09-06 13:46:17 +00:00
|
|
|
int err;
|
2008-02-10 10:33:08 +00:00
|
|
|
|
2008-04-02 10:26:36 +00:00
|
|
|
map = &sbi->s_partmaps[p_index];
|
2008-02-10 10:33:08 +00:00
|
|
|
|
|
|
|
map->s_partition_len = le32_to_cpu(p->partitionLength); /* blocks */
|
|
|
|
map->s_partition_root = le32_to_cpu(p->partitionStartingLocation);
|
|
|
|
|
|
|
|
if (p->accessType == cpu_to_le32(PD_ACCESS_TYPE_READ_ONLY))
|
|
|
|
map->s_partition_flags |= UDF_PART_FLAG_READ_ONLY;
|
|
|
|
if (p->accessType == cpu_to_le32(PD_ACCESS_TYPE_WRITE_ONCE))
|
|
|
|
map->s_partition_flags |= UDF_PART_FLAG_WRITE_ONCE;
|
|
|
|
if (p->accessType == cpu_to_le32(PD_ACCESS_TYPE_REWRITABLE))
|
|
|
|
map->s_partition_flags |= UDF_PART_FLAG_REWRITABLE;
|
|
|
|
if (p->accessType == cpu_to_le32(PD_ACCESS_TYPE_OVERWRITABLE))
|
|
|
|
map->s_partition_flags |= UDF_PART_FLAG_OVERWRITABLE;
|
|
|
|
|
2017-10-12 13:48:41 +00:00
|
|
|
udf_debug("Partition (%d type %x) starts at physical %u, block length %u\n",
|
2011-10-10 08:08:07 +00:00
|
|
|
p_index, map->s_partition_type,
|
|
|
|
map->s_partition_root, map->s_partition_len);
|
2008-02-10 10:33:08 +00:00
|
|
|
|
2018-09-06 13:46:17 +00:00
|
|
|
err = check_partition_desc(sb, p, map);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Skip loading allocation info it we cannot ever write to the fs.
|
|
|
|
* This is a correctness thing as we may have decided to force ro mount
|
|
|
|
* to avoid allocation info we don't support.
|
|
|
|
*/
|
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_RW_INCOMPAT))
|
2008-04-02 10:26:36 +00:00
|
|
|
return 0;
|
2008-02-10 10:33:08 +00:00
|
|
|
|
|
|
|
phd = (struct partitionHeaderDesc *)p->partitionContentsUse;
|
|
|
|
if (phd->unallocSpaceTable.extLength) {
|
2008-10-15 10:28:03 +00:00
|
|
|
struct kernel_lb_addr loc = {
|
2008-02-10 10:33:08 +00:00
|
|
|
.logicalBlockNum = le32_to_cpu(
|
|
|
|
phd->unallocSpaceTable.extPosition),
|
2008-04-02 10:26:36 +00:00
|
|
|
.partitionReferenceNum = p_index,
|
2008-02-10 10:33:08 +00:00
|
|
|
};
|
2014-09-04 14:15:51 +00:00
|
|
|
struct inode *inode;
|
2008-02-10 10:33:08 +00:00
|
|
|
|
2014-10-09 10:52:16 +00:00
|
|
|
inode = udf_iget_special(sb, &loc);
|
2014-09-04 14:15:51 +00:00
|
|
|
if (IS_ERR(inode)) {
|
2008-02-10 10:33:08 +00:00
|
|
|
udf_debug("cannot load unallocSpaceTable (part %d)\n",
|
2011-10-10 08:08:07 +00:00
|
|
|
p_index);
|
2014-09-04 14:15:51 +00:00
|
|
|
return PTR_ERR(inode);
|
2008-02-10 10:33:08 +00:00
|
|
|
}
|
2014-09-04 14:15:51 +00:00
|
|
|
map->s_uspace.s_table = inode;
|
2008-02-10 10:33:08 +00:00
|
|
|
map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_TABLE;
|
2017-10-12 13:48:41 +00:00
|
|
|
udf_debug("unallocSpaceTable (part %d) @ %lu\n",
|
2011-10-10 08:08:07 +00:00
|
|
|
p_index, map->s_uspace.s_table->i_ino);
|
2008-02-10 10:33:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (phd->unallocSpaceBitmap.extLength) {
|
2008-04-02 10:26:36 +00:00
|
|
|
struct udf_bitmap *bitmap = udf_sb_alloc_bitmap(sb, p_index);
|
|
|
|
if (!bitmap)
|
2013-07-25 17:10:59 +00:00
|
|
|
return -ENOMEM;
|
2008-02-10 10:33:08 +00:00
|
|
|
map->s_uspace.s_bitmap = bitmap;
|
2008-04-01 16:08:51 +00:00
|
|
|
bitmap->s_extPosition = le32_to_cpu(
|
2008-02-10 10:33:08 +00:00
|
|
|
phd->unallocSpaceBitmap.extPosition);
|
2008-04-01 16:08:51 +00:00
|
|
|
map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_BITMAP;
|
2017-10-12 13:48:41 +00:00
|
|
|
udf_debug("unallocSpaceBitmap (part %d) @ %u\n",
|
2011-10-10 08:08:07 +00:00
|
|
|
p_index, bitmap->s_extPosition);
|
2008-02-10 10:33:08 +00:00
|
|
|
}
|
|
|
|
|
2008-04-02 10:26:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-11-30 18:47:55 +00:00
|
|
|
static void udf_find_vat_block(struct super_block *sb, int p_index,
|
|
|
|
int type1_index, sector_t start_block)
|
2008-04-02 14:01:35 +00:00
|
|
|
{
|
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
|
|
|
struct udf_part_map *map = &sbi->s_partmaps[p_index];
|
2009-11-30 18:47:55 +00:00
|
|
|
sector_t vat_block;
|
2008-10-15 10:28:03 +00:00
|
|
|
struct kernel_lb_addr ino;
|
2014-09-04 14:15:51 +00:00
|
|
|
struct inode *inode;
|
2009-11-30 18:47:55 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* VAT file entry is in the last recorded block. Some broken disks have
|
|
|
|
* it a few blocks before so try a bit harder...
|
|
|
|
*/
|
|
|
|
ino.partitionReferenceNum = type1_index;
|
|
|
|
for (vat_block = start_block;
|
|
|
|
vat_block >= map->s_partition_root &&
|
2014-09-04 14:15:51 +00:00
|
|
|
vat_block >= start_block - 3; vat_block--) {
|
2009-11-30 18:47:55 +00:00
|
|
|
ino.logicalBlockNum = vat_block - map->s_partition_root;
|
2014-10-09 10:52:16 +00:00
|
|
|
inode = udf_iget_special(sb, &ino);
|
2014-09-04 14:15:51 +00:00
|
|
|
if (!IS_ERR(inode)) {
|
|
|
|
sbi->s_vat_inode = inode;
|
|
|
|
break;
|
|
|
|
}
|
2009-11-30 18:47:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int udf_load_vat(struct super_block *sb, int p_index, int type1_index)
|
|
|
|
{
|
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
|
|
|
struct udf_part_map *map = &sbi->s_partmaps[p_index];
|
2008-04-08 00:08:53 +00:00
|
|
|
struct buffer_head *bh = NULL;
|
|
|
|
struct udf_inode_info *vati;
|
|
|
|
struct virtualAllocationTable20 *vat20;
|
2021-10-18 10:11:30 +00:00
|
|
|
sector_t blocks = sb_bdev_nr_blocks(sb);
|
2008-04-02 14:01:35 +00:00
|
|
|
|
2009-11-30 18:47:55 +00:00
|
|
|
udf_find_vat_block(sb, p_index, type1_index, sbi->s_last_block);
|
2009-07-14 17:30:23 +00:00
|
|
|
if (!sbi->s_vat_inode &&
|
|
|
|
sbi->s_last_block != blocks - 1) {
|
2011-10-10 08:08:05 +00:00
|
|
|
pr_notice("Failed to read VAT inode from the last recorded block (%lu), retrying with the last block of the device (%lu).\n",
|
|
|
|
(unsigned long)sbi->s_last_block,
|
|
|
|
(unsigned long)blocks - 1);
|
2009-11-30 18:47:55 +00:00
|
|
|
udf_find_vat_block(sb, p_index, type1_index, blocks - 1);
|
2009-07-14 17:30:23 +00:00
|
|
|
}
|
2008-04-02 14:01:35 +00:00
|
|
|
if (!sbi->s_vat_inode)
|
2013-07-25 17:10:59 +00:00
|
|
|
return -EIO;
|
2008-04-02 14:01:35 +00:00
|
|
|
|
|
|
|
if (map->s_partition_type == UDF_VIRTUAL_MAP15) {
|
2008-04-14 15:06:36 +00:00
|
|
|
map->s_type_specific.s_virtual.s_start_offset = 0;
|
2008-04-02 14:01:35 +00:00
|
|
|
map->s_type_specific.s_virtual.s_num_entries =
|
|
|
|
(sbi->s_vat_inode->i_size - 36) >> 2;
|
|
|
|
} else if (map->s_partition_type == UDF_VIRTUAL_MAP20) {
|
2008-04-08 00:08:53 +00:00
|
|
|
vati = UDF_I(sbi->s_vat_inode);
|
|
|
|
if (vati->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
|
2023-01-18 13:08:10 +00:00
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
bh = udf_bread(sbi->s_vat_inode, 0, 0, &err);
|
|
|
|
if (!bh) {
|
|
|
|
if (!err)
|
|
|
|
err = -EFSCORRUPTED;
|
|
|
|
return err;
|
|
|
|
}
|
2008-04-08 00:08:53 +00:00
|
|
|
vat20 = (struct virtualAllocationTable20 *)bh->b_data;
|
|
|
|
} else {
|
|
|
|
vat20 = (struct virtualAllocationTable20 *)
|
2020-09-25 10:29:54 +00:00
|
|
|
vati->i_data;
|
2008-04-08 00:08:53 +00:00
|
|
|
}
|
2008-04-02 14:01:35 +00:00
|
|
|
|
|
|
|
map->s_type_specific.s_virtual.s_start_offset =
|
2008-04-14 15:06:36 +00:00
|
|
|
le16_to_cpu(vat20->lengthHeader);
|
2008-04-02 14:01:35 +00:00
|
|
|
map->s_type_specific.s_virtual.s_num_entries =
|
|
|
|
(sbi->s_vat_inode->i_size -
|
|
|
|
map->s_type_specific.s_virtual.
|
|
|
|
s_start_offset) >> 2;
|
|
|
|
brelse(bh);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-07-25 17:10:59 +00:00
|
|
|
/*
|
|
|
|
* Load partition descriptor block
|
|
|
|
*
|
|
|
|
* Returns <0 on error, 0 on success, -EAGAIN is special - try next descriptor
|
|
|
|
* sequence.
|
|
|
|
*/
|
2008-04-02 10:26:36 +00:00
|
|
|
static int udf_load_partdesc(struct super_block *sb, sector_t block)
|
|
|
|
{
|
|
|
|
struct buffer_head *bh;
|
|
|
|
struct partitionDesc *p;
|
|
|
|
struct udf_part_map *map;
|
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
2008-04-02 14:01:35 +00:00
|
|
|
int i, type1_idx;
|
2008-04-02 10:26:36 +00:00
|
|
|
uint16_t partitionNumber;
|
|
|
|
uint16_t ident;
|
2013-07-25 17:10:59 +00:00
|
|
|
int ret;
|
2008-04-02 10:26:36 +00:00
|
|
|
|
|
|
|
bh = udf_read_tagged(sb, block, block, &ident);
|
|
|
|
if (!bh)
|
2013-07-25 17:10:59 +00:00
|
|
|
return -EAGAIN;
|
|
|
|
if (ident != TAG_IDENT_PD) {
|
|
|
|
ret = 0;
|
2008-04-02 10:26:36 +00:00
|
|
|
goto out_bh;
|
2013-07-25 17:10:59 +00:00
|
|
|
}
|
2008-04-02 10:26:36 +00:00
|
|
|
|
|
|
|
p = (struct partitionDesc *)bh->b_data;
|
|
|
|
partitionNumber = le16_to_cpu(p->partitionNumber);
|
2008-04-02 14:01:35 +00:00
|
|
|
|
2016-05-18 21:09:19 +00:00
|
|
|
/* First scan for TYPE1 and SPARABLE partitions */
|
2008-04-02 10:26:36 +00:00
|
|
|
for (i = 0; i < sbi->s_partitions; i++) {
|
|
|
|
map = &sbi->s_partmaps[i];
|
2017-10-12 13:48:41 +00:00
|
|
|
udf_debug("Searching map: (%u == %u)\n",
|
2008-04-02 10:26:36 +00:00
|
|
|
map->s_partition_num, partitionNumber);
|
2008-04-02 14:01:35 +00:00
|
|
|
if (map->s_partition_num == partitionNumber &&
|
|
|
|
(map->s_partition_type == UDF_TYPE1_MAP15 ||
|
|
|
|
map->s_partition_type == UDF_SPARABLE_MAP15))
|
2008-04-02 10:26:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-04-02 14:01:35 +00:00
|
|
|
if (i >= sbi->s_partitions) {
|
2017-10-12 13:48:41 +00:00
|
|
|
udf_debug("Partition (%u) not found in partition map\n",
|
2008-04-02 10:26:36 +00:00
|
|
|
partitionNumber);
|
2013-07-25 17:10:59 +00:00
|
|
|
ret = 0;
|
2008-04-02 10:26:36 +00:00
|
|
|
goto out_bh;
|
|
|
|
}
|
2008-02-10 10:33:08 +00:00
|
|
|
|
2008-04-02 10:26:36 +00:00
|
|
|
ret = udf_fill_partdesc_info(sb, p, i);
|
2013-07-25 17:10:59 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto out_bh;
|
2008-04-02 14:01:35 +00:00
|
|
|
|
|
|
|
/*
|
2008-04-08 18:37:21 +00:00
|
|
|
* Now rescan for VIRTUAL or METADATA partitions when SPARABLE and
|
|
|
|
* PHYSICAL partitions are already set up
|
2008-04-02 14:01:35 +00:00
|
|
|
*/
|
|
|
|
type1_idx = i;
|
udf: fix for pathetic mount times in case of invalid file system
The UDF driver was not strict enough about checking the IDs in the
VSDs when mounting, which resulted in reading through all the sectors
of the block device in some unfortunate cases. Eg, trying to mount my
uninitialized 200G SSD partition (all 0xFF bytes) took ~350 minutes to
fail, because the code expected some of the valid IDs or a zero byte.
During this, the mount couldn't be killed, sync from the cmdline
blocked, and the machine froze into the shutdown. Valid filesystems
(extX, btrfs, ntfs) were rejected by the mere accident of having a
zero byte at just the right place in some of their sectors, close
enough to the beginning not to generate excess I/O. The fix adds a
hard limit on the VSD sector offset, adds the two missing VSD IDs, and
stops scanning when encountering an invalid ID. Also replaced the
magic number 32768 with a more meaningful #define, and supressed the
bogus message about failing to read the first sector if no UDF fs was
detected.
Signed-off-by: Peter A. Felvegi <petschy@gmail.com>
Signed-off-by: Jan Kara <jack@suse.cz>
2013-10-18 18:07:44 +00:00
|
|
|
map = NULL; /* supress 'maybe used uninitialized' warning */
|
2008-04-02 14:01:35 +00:00
|
|
|
for (i = 0; i < sbi->s_partitions; i++) {
|
|
|
|
map = &sbi->s_partmaps[i];
|
|
|
|
|
|
|
|
if (map->s_partition_num == partitionNumber &&
|
|
|
|
(map->s_partition_type == UDF_VIRTUAL_MAP15 ||
|
2008-04-08 18:37:21 +00:00
|
|
|
map->s_partition_type == UDF_VIRTUAL_MAP20 ||
|
|
|
|
map->s_partition_type == UDF_METADATA_MAP25))
|
2008-04-02 14:01:35 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-07-25 17:10:59 +00:00
|
|
|
if (i >= sbi->s_partitions) {
|
|
|
|
ret = 0;
|
2008-04-02 14:01:35 +00:00
|
|
|
goto out_bh;
|
2013-07-25 17:10:59 +00:00
|
|
|
}
|
2008-04-02 14:01:35 +00:00
|
|
|
|
|
|
|
ret = udf_fill_partdesc_info(sb, p, i);
|
2013-07-25 17:10:59 +00:00
|
|
|
if (ret < 0)
|
2008-04-02 14:01:35 +00:00
|
|
|
goto out_bh;
|
|
|
|
|
2008-04-08 18:37:21 +00:00
|
|
|
if (map->s_partition_type == UDF_METADATA_MAP25) {
|
2016-05-18 21:09:19 +00:00
|
|
|
ret = udf_load_metadata_files(sb, i, type1_idx);
|
2013-07-25 17:10:59 +00:00
|
|
|
if (ret < 0) {
|
2011-10-10 08:08:05 +00:00
|
|
|
udf_err(sb, "error loading MetaData partition map %d\n",
|
|
|
|
i);
|
2008-04-08 18:37:21 +00:00
|
|
|
goto out_bh;
|
|
|
|
}
|
|
|
|
} else {
|
2013-07-25 14:15:16 +00:00
|
|
|
/*
|
|
|
|
* If we have a partition with virtual map, we don't handle
|
|
|
|
* writing to it (we overwrite blocks instead of relocating
|
|
|
|
* them).
|
|
|
|
*/
|
2017-07-17 07:45:34 +00:00
|
|
|
if (!sb_rdonly(sb)) {
|
2013-07-25 14:15:16 +00:00
|
|
|
ret = -EACCES;
|
|
|
|
goto out_bh;
|
|
|
|
}
|
2018-09-06 13:56:10 +00:00
|
|
|
UDF_SET_FLAG(sb, UDF_FLAG_RW_INCOMPAT);
|
2008-04-08 18:37:21 +00:00
|
|
|
ret = udf_load_vat(sb, i, type1_idx);
|
2013-07-25 17:10:59 +00:00
|
|
|
if (ret < 0)
|
2008-04-08 18:37:21 +00:00
|
|
|
goto out_bh;
|
|
|
|
}
|
2013-07-25 17:10:59 +00:00
|
|
|
ret = 0;
|
2008-04-01 14:50:35 +00:00
|
|
|
out_bh:
|
2008-04-01 16:08:51 +00:00
|
|
|
/* In case loading failed, we handle cleanup in udf_fill_super */
|
2008-04-01 14:50:35 +00:00
|
|
|
brelse(bh);
|
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2012-06-27 19:23:07 +00:00
|
|
|
static int udf_load_sparable_map(struct super_block *sb,
|
|
|
|
struct udf_part_map *map,
|
|
|
|
struct sparablePartitionMap *spm)
|
|
|
|
{
|
|
|
|
uint32_t loc;
|
|
|
|
uint16_t ident;
|
|
|
|
struct sparingTable *st;
|
|
|
|
struct udf_sparing_data *sdata = &map->s_type_specific.s_sparing;
|
|
|
|
int i;
|
|
|
|
struct buffer_head *bh;
|
|
|
|
|
|
|
|
map->s_partition_type = UDF_SPARABLE_MAP15;
|
|
|
|
sdata->s_packet_len = le16_to_cpu(spm->packetLength);
|
|
|
|
if (!is_power_of_2(sdata->s_packet_len)) {
|
|
|
|
udf_err(sb, "error loading logical volume descriptor: "
|
|
|
|
"Invalid packet length %u\n",
|
|
|
|
(unsigned)sdata->s_packet_len);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
if (spm->numSparingTables > 4) {
|
|
|
|
udf_err(sb, "error loading logical volume descriptor: "
|
|
|
|
"Too many sparing tables (%d)\n",
|
|
|
|
(int)spm->numSparingTables);
|
|
|
|
return -EIO;
|
|
|
|
}
|
2020-09-25 12:53:08 +00:00
|
|
|
if (le32_to_cpu(spm->sizeSparingTable) > sb->s_blocksize) {
|
|
|
|
udf_err(sb, "error loading logical volume descriptor: "
|
|
|
|
"Too big sparing table size (%u)\n",
|
|
|
|
le32_to_cpu(spm->sizeSparingTable));
|
|
|
|
return -EIO;
|
|
|
|
}
|
2012-06-27 19:23:07 +00:00
|
|
|
|
|
|
|
for (i = 0; i < spm->numSparingTables; i++) {
|
|
|
|
loc = le32_to_cpu(spm->locSparingTable[i]);
|
|
|
|
bh = udf_read_tagged(sb, loc, loc, &ident);
|
|
|
|
if (!bh)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
st = (struct sparingTable *)bh->b_data;
|
|
|
|
if (ident != 0 ||
|
|
|
|
strncmp(st->sparingIdent.ident, UDF_ID_SPARING,
|
|
|
|
strlen(UDF_ID_SPARING)) ||
|
|
|
|
sizeof(*st) + le16_to_cpu(st->reallocationTableLen) >
|
|
|
|
sb->s_blocksize) {
|
|
|
|
brelse(bh);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
sdata->s_spar_map[i] = bh;
|
|
|
|
}
|
|
|
|
map->s_partition_func = udf_get_pblock_spar15;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-01 14:50:35 +00:00
|
|
|
static int udf_load_logicalvol(struct super_block *sb, sector_t block,
|
2008-10-15 10:28:03 +00:00
|
|
|
struct kernel_lb_addr *fileset)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct logicalVolDesc *lvd;
|
2012-06-27 19:23:07 +00:00
|
|
|
int i, offset;
|
2005-04-16 22:20:36 +00:00
|
|
|
uint8_t type;
|
2008-02-08 12:20:30 +00:00
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
2008-02-08 12:20:36 +00:00
|
|
|
struct genericPartitionMap *gpm;
|
2008-04-01 14:50:35 +00:00
|
|
|
uint16_t ident;
|
|
|
|
struct buffer_head *bh;
|
2012-06-27 18:20:22 +00:00
|
|
|
unsigned int table_len;
|
2013-07-25 17:10:59 +00:00
|
|
|
int ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-01 14:50:35 +00:00
|
|
|
bh = udf_read_tagged(sb, block, block, &ident);
|
|
|
|
if (!bh)
|
2013-07-25 17:10:59 +00:00
|
|
|
return -EAGAIN;
|
2008-04-01 14:50:35 +00:00
|
|
|
BUG_ON(ident != TAG_IDENT_LVD);
|
2005-04-16 22:20:36 +00:00
|
|
|
lvd = (struct logicalVolDesc *)bh->b_data;
|
2012-06-27 18:20:22 +00:00
|
|
|
table_len = le32_to_cpu(lvd->mapTableLength);
|
2012-07-10 15:58:04 +00:00
|
|
|
if (table_len > sb->s_blocksize - sizeof(*lvd)) {
|
2012-06-27 18:20:22 +00:00
|
|
|
udf_err(sb, "error loading logical volume descriptor: "
|
|
|
|
"Partition table too long (%u > %lu)\n", table_len,
|
|
|
|
sb->s_blocksize - sizeof(*lvd));
|
2013-07-25 17:10:59 +00:00
|
|
|
ret = -EIO;
|
2012-06-27 18:20:22 +00:00
|
|
|
goto out_bh;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2019-08-29 12:11:54 +00:00
|
|
|
ret = udf_verify_domain_identifier(sb, &lvd->domainIdent,
|
|
|
|
"logical volume");
|
|
|
|
if (ret)
|
|
|
|
goto out_bh;
|
2012-06-27 18:08:44 +00:00
|
|
|
ret = udf_sb_alloc_partition_maps(sb, le32_to_cpu(lvd->numPartitionMaps));
|
|
|
|
if (ret)
|
2008-04-01 14:50:35 +00:00
|
|
|
goto out_bh;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
for (i = 0, offset = 0;
|
2012-06-27 18:20:22 +00:00
|
|
|
i < sbi->s_partitions && offset < table_len;
|
2008-02-08 12:20:36 +00:00
|
|
|
i++, offset += gpm->partitionMapLength) {
|
|
|
|
struct udf_part_map *map = &sbi->s_partmaps[i];
|
|
|
|
gpm = (struct genericPartitionMap *)
|
|
|
|
&(lvd->partitionMaps[offset]);
|
|
|
|
type = gpm->partitionMapType;
|
2007-07-19 08:47:43 +00:00
|
|
|
if (type == 1) {
|
2008-02-08 12:20:36 +00:00
|
|
|
struct genericPartitionMap1 *gpm1 =
|
|
|
|
(struct genericPartitionMap1 *)gpm;
|
2008-02-08 12:20:30 +00:00
|
|
|
map->s_partition_type = UDF_TYPE1_MAP15;
|
|
|
|
map->s_volumeseqnum = le16_to_cpu(gpm1->volSeqNum);
|
|
|
|
map->s_partition_num = le16_to_cpu(gpm1->partitionNum);
|
|
|
|
map->s_partition_func = NULL;
|
2007-07-19 08:47:43 +00:00
|
|
|
} else if (type == 2) {
|
2008-02-08 12:20:36 +00:00
|
|
|
struct udfPartitionMap2 *upm2 =
|
|
|
|
(struct udfPartitionMap2 *)gpm;
|
|
|
|
if (!strncmp(upm2->partIdent.ident, UDF_ID_VIRTUAL,
|
|
|
|
strlen(UDF_ID_VIRTUAL))) {
|
|
|
|
u16 suf =
|
|
|
|
le16_to_cpu(((__le16 *)upm2->partIdent.
|
|
|
|
identSuffix)[0]);
|
2008-04-07 23:16:32 +00:00
|
|
|
if (suf < 0x0200) {
|
2008-02-08 12:20:36 +00:00
|
|
|
map->s_partition_type =
|
|
|
|
UDF_VIRTUAL_MAP15;
|
|
|
|
map->s_partition_func =
|
|
|
|
udf_get_pblock_virt15;
|
2008-04-07 23:16:32 +00:00
|
|
|
} else {
|
2008-02-08 12:20:36 +00:00
|
|
|
map->s_partition_type =
|
|
|
|
UDF_VIRTUAL_MAP20;
|
|
|
|
map->s_partition_func =
|
|
|
|
udf_get_pblock_virt20;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-02-08 12:20:36 +00:00
|
|
|
} else if (!strncmp(upm2->partIdent.ident,
|
|
|
|
UDF_ID_SPARABLE,
|
|
|
|
strlen(UDF_ID_SPARABLE))) {
|
2013-07-25 17:10:59 +00:00
|
|
|
ret = udf_load_sparable_map(sb, map,
|
|
|
|
(struct sparablePartitionMap *)gpm);
|
|
|
|
if (ret < 0)
|
2012-06-27 19:23:07 +00:00
|
|
|
goto out_bh;
|
2008-04-08 18:37:21 +00:00
|
|
|
} else if (!strncmp(upm2->partIdent.ident,
|
|
|
|
UDF_ID_METADATA,
|
|
|
|
strlen(UDF_ID_METADATA))) {
|
|
|
|
struct udf_meta_data *mdata =
|
|
|
|
&map->s_type_specific.s_metadata;
|
|
|
|
struct metadataPartitionMap *mdm =
|
|
|
|
(struct metadataPartitionMap *)
|
|
|
|
&(lvd->partitionMaps[offset]);
|
2017-10-12 13:48:41 +00:00
|
|
|
udf_debug("Parsing Logical vol part %d type %u id=%s\n",
|
2011-10-10 08:08:07 +00:00
|
|
|
i, type, UDF_ID_METADATA);
|
2008-04-08 18:37:21 +00:00
|
|
|
|
|
|
|
map->s_partition_type = UDF_METADATA_MAP25;
|
|
|
|
map->s_partition_func = udf_get_pblock_meta25;
|
|
|
|
|
|
|
|
mdata->s_meta_file_loc =
|
|
|
|
le32_to_cpu(mdm->metadataFileLoc);
|
|
|
|
mdata->s_mirror_file_loc =
|
|
|
|
le32_to_cpu(mdm->metadataMirrorFileLoc);
|
|
|
|
mdata->s_bitmap_file_loc =
|
|
|
|
le32_to_cpu(mdm->metadataBitmapFileLoc);
|
|
|
|
mdata->s_alloc_unit_size =
|
|
|
|
le32_to_cpu(mdm->allocUnitSize);
|
|
|
|
mdata->s_align_unit_size =
|
|
|
|
le16_to_cpu(mdm->alignUnitSize);
|
2011-10-24 14:47:48 +00:00
|
|
|
if (mdm->flags & 0x01)
|
|
|
|
mdata->s_flags |= MF_DUPLICATE_MD;
|
2008-04-08 18:37:21 +00:00
|
|
|
|
|
|
|
udf_debug("Metadata Ident suffix=0x%x\n",
|
2011-10-10 08:08:07 +00:00
|
|
|
le16_to_cpu(*(__le16 *)
|
|
|
|
mdm->partIdent.identSuffix));
|
2017-10-12 13:48:41 +00:00
|
|
|
udf_debug("Metadata part num=%u\n",
|
2011-10-10 08:08:07 +00:00
|
|
|
le16_to_cpu(mdm->partitionNum));
|
2017-10-12 13:48:41 +00:00
|
|
|
udf_debug("Metadata part alloc unit size=%u\n",
|
2011-10-10 08:08:07 +00:00
|
|
|
le32_to_cpu(mdm->allocUnitSize));
|
2017-10-12 13:48:41 +00:00
|
|
|
udf_debug("Metadata file loc=%u\n",
|
2011-10-10 08:08:07 +00:00
|
|
|
le32_to_cpu(mdm->metadataFileLoc));
|
2017-10-12 13:48:41 +00:00
|
|
|
udf_debug("Mirror file loc=%u\n",
|
2011-10-10 08:08:07 +00:00
|
|
|
le32_to_cpu(mdm->metadataMirrorFileLoc));
|
2017-10-12 13:48:41 +00:00
|
|
|
udf_debug("Bitmap file loc=%u\n",
|
2011-10-10 08:08:07 +00:00
|
|
|
le32_to_cpu(mdm->metadataBitmapFileLoc));
|
2017-10-12 13:48:41 +00:00
|
|
|
udf_debug("Flags: %d %u\n",
|
2011-10-24 14:47:48 +00:00
|
|
|
mdata->s_flags, mdm->flags);
|
2007-07-19 08:47:43 +00:00
|
|
|
} else {
|
2008-02-08 12:20:28 +00:00
|
|
|
udf_debug("Unknown ident: %s\n",
|
|
|
|
upm2->partIdent.ident);
|
2005-04-16 22:20:36 +00:00
|
|
|
continue;
|
|
|
|
}
|
2008-02-08 12:20:30 +00:00
|
|
|
map->s_volumeseqnum = le16_to_cpu(upm2->volSeqNum);
|
|
|
|
map->s_partition_num = le16_to_cpu(upm2->partitionNum);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2017-10-12 13:48:41 +00:00
|
|
|
udf_debug("Partition (%d:%u) type %u on volume %u\n",
|
2011-10-10 08:08:07 +00:00
|
|
|
i, map->s_partition_num, type, map->s_volumeseqnum);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
if (fileset) {
|
2008-10-15 10:28:03 +00:00
|
|
|
struct long_ad *la = (struct long_ad *)&(lvd->logicalVolContentsUse[0]);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
*fileset = lelb_to_cpu(la->extLocation);
|
2017-10-12 13:48:41 +00:00
|
|
|
udf_debug("FileSet found in LogicalVolDesc at block=%u, partition=%u\n",
|
2011-10-10 08:08:07 +00:00
|
|
|
fileset->logicalBlockNum,
|
2007-07-21 11:37:18 +00:00
|
|
|
fileset->partitionReferenceNum);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
if (lvd->integritySeqExt.extLength)
|
|
|
|
udf_load_logicalvolint(sb, leea_to_cpu(lvd->integritySeqExt));
|
2013-07-25 17:10:59 +00:00
|
|
|
ret = 0;
|
2019-02-11 14:24:38 +00:00
|
|
|
|
|
|
|
if (!sbi->s_lvid_bh) {
|
|
|
|
/* We can't generate unique IDs without a valid LVID */
|
|
|
|
if (sb_rdonly(sb)) {
|
|
|
|
UDF_SET_FLAG(sb, UDF_FLAG_RW_INCOMPAT);
|
|
|
|
} else {
|
|
|
|
udf_warn(sb, "Damaged or missing LVID, forcing "
|
|
|
|
"readonly mount\n");
|
|
|
|
ret = -EACCES;
|
|
|
|
}
|
|
|
|
}
|
2008-04-01 14:50:35 +00:00
|
|
|
out_bh:
|
|
|
|
brelse(bh);
|
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2016-04-26 02:27:56 +00:00
|
|
|
* Find the prevailing Logical Volume Integrity Descriptor.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-10-15 10:28:03 +00:00
|
|
|
static void udf_load_logicalvolint(struct super_block *sb, struct kernel_extent_ad loc)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-04-26 02:27:56 +00:00
|
|
|
struct buffer_head *bh, *final_bh;
|
2005-04-16 22:20:36 +00:00
|
|
|
uint16_t ident;
|
2008-02-08 12:20:30 +00:00
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
|
|
|
struct logicalVolIntegrityDesc *lvid;
|
2016-04-26 02:27:56 +00:00
|
|
|
int indirections = 0;
|
2021-05-03 09:39:03 +00:00
|
|
|
u32 parts, impuselen;
|
2016-04-26 02:27:56 +00:00
|
|
|
|
|
|
|
while (++indirections <= UDF_MAX_LVID_NESTING) {
|
|
|
|
final_bh = NULL;
|
|
|
|
while (loc.extLength > 0 &&
|
|
|
|
(bh = udf_read_tagged(sb, loc.extLocation,
|
|
|
|
loc.extLocation, &ident))) {
|
|
|
|
if (ident != TAG_IDENT_LVID) {
|
|
|
|
brelse(bh);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
brelse(final_bh);
|
|
|
|
final_bh = bh;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2016-04-26 02:27:56 +00:00
|
|
|
loc.extLength -= sb->s_blocksize;
|
|
|
|
loc.extLocation++;
|
|
|
|
}
|
2007-07-19 08:47:43 +00:00
|
|
|
|
2016-04-26 02:27:56 +00:00
|
|
|
if (!final_bh)
|
|
|
|
return;
|
2007-07-19 08:47:43 +00:00
|
|
|
|
2016-04-26 02:27:56 +00:00
|
|
|
brelse(sbi->s_lvid_bh);
|
|
|
|
sbi->s_lvid_bh = final_bh;
|
|
|
|
|
|
|
|
lvid = (struct logicalVolIntegrityDesc *)final_bh->b_data;
|
|
|
|
if (lvid->nextIntegrityExt.extLength == 0)
|
2021-05-03 09:39:03 +00:00
|
|
|
goto check;
|
2016-04-26 02:27:56 +00:00
|
|
|
|
|
|
|
loc = leea_to_cpu(lvid->nextIntegrityExt);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2016-04-26 02:27:56 +00:00
|
|
|
|
|
|
|
udf_warn(sb, "Too many LVID indirections (max %u), ignoring.\n",
|
|
|
|
UDF_MAX_LVID_NESTING);
|
2021-05-03 09:39:03 +00:00
|
|
|
out_err:
|
2016-04-26 02:27:56 +00:00
|
|
|
brelse(sbi->s_lvid_bh);
|
|
|
|
sbi->s_lvid_bh = NULL;
|
2021-05-03 09:39:03 +00:00
|
|
|
return;
|
|
|
|
check:
|
|
|
|
parts = le32_to_cpu(lvid->numOfPartitions);
|
|
|
|
impuselen = le32_to_cpu(lvid->lengthOfImpUse);
|
|
|
|
if (parts >= sb->s_blocksize || impuselen >= sb->s_blocksize ||
|
|
|
|
sizeof(struct logicalVolIntegrityDesc) + impuselen +
|
|
|
|
2 * parts * sizeof(u32) > sb->s_blocksize) {
|
|
|
|
udf_warn(sb, "Corrupted LVID (parts=%u, impuselen=%u), "
|
|
|
|
"ignoring.\n", parts, impuselen);
|
|
|
|
goto out_err;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2018-02-09 14:56:34 +00:00
|
|
|
/*
|
|
|
|
* Step for reallocation of table of partition descriptor sequence numbers.
|
|
|
|
* Must be power of 2.
|
|
|
|
*/
|
|
|
|
#define PART_DESC_ALLOC_STEP 32
|
|
|
|
|
2018-08-21 12:52:34 +00:00
|
|
|
struct part_desc_seq_scan_data {
|
|
|
|
struct udf_vds_record rec;
|
|
|
|
u32 partnum;
|
|
|
|
};
|
|
|
|
|
2018-02-09 14:56:34 +00:00
|
|
|
struct desc_seq_scan_data {
|
|
|
|
struct udf_vds_record vds[VDS_POS_LENGTH];
|
|
|
|
unsigned int size_part_descs;
|
2018-08-21 12:52:34 +00:00
|
|
|
unsigned int num_part_descs;
|
|
|
|
struct part_desc_seq_scan_data *part_descs_loc;
|
2018-02-09 14:56:34 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct udf_vds_record *handle_partition_descriptor(
|
|
|
|
struct buffer_head *bh,
|
|
|
|
struct desc_seq_scan_data *data)
|
|
|
|
{
|
|
|
|
struct partitionDesc *desc = (struct partitionDesc *)bh->b_data;
|
|
|
|
int partnum;
|
2018-08-21 12:52:34 +00:00
|
|
|
int i;
|
2018-02-09 14:56:34 +00:00
|
|
|
|
|
|
|
partnum = le16_to_cpu(desc->partitionNumber);
|
2018-08-21 12:52:34 +00:00
|
|
|
for (i = 0; i < data->num_part_descs; i++)
|
|
|
|
if (partnum == data->part_descs_loc[i].partnum)
|
|
|
|
return &(data->part_descs_loc[i].rec);
|
|
|
|
if (data->num_part_descs >= data->size_part_descs) {
|
|
|
|
struct part_desc_seq_scan_data *new_loc;
|
2018-02-09 14:56:34 +00:00
|
|
|
unsigned int new_size = ALIGN(partnum, PART_DESC_ALLOC_STEP);
|
|
|
|
|
treewide: kzalloc() -> kcalloc()
The kzalloc() function has a 2-factor argument form, kcalloc(). This
patch replaces cases of:
kzalloc(a * b, gfp)
with:
kcalloc(a * b, gfp)
as well as handling cases of:
kzalloc(a * b * c, gfp)
with:
kzalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kzalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kzalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kzalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kzalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kzalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kzalloc
+ kcalloc
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kzalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kzalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kzalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kzalloc(sizeof(THING) * C2, ...)
|
kzalloc(sizeof(TYPE) * C2, ...)
|
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(C1 * C2, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * E2
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 21:03:40 +00:00
|
|
|
new_loc = kcalloc(new_size, sizeof(*new_loc), GFP_KERNEL);
|
2018-02-09 14:56:34 +00:00
|
|
|
if (!new_loc)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
memcpy(new_loc, data->part_descs_loc,
|
|
|
|
data->size_part_descs * sizeof(*new_loc));
|
|
|
|
kfree(data->part_descs_loc);
|
|
|
|
data->part_descs_loc = new_loc;
|
|
|
|
data->size_part_descs = new_size;
|
|
|
|
}
|
2018-08-21 12:52:34 +00:00
|
|
|
return &(data->part_descs_loc[data->num_part_descs++].rec);
|
2018-02-09 14:56:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static struct udf_vds_record *get_volume_descriptor_record(uint16_t ident,
|
|
|
|
struct buffer_head *bh, struct desc_seq_scan_data *data)
|
2018-02-09 14:15:39 +00:00
|
|
|
{
|
|
|
|
switch (ident) {
|
|
|
|
case TAG_IDENT_PVD: /* ISO 13346 3/10.1 */
|
2018-02-09 14:56:34 +00:00
|
|
|
return &(data->vds[VDS_POS_PRIMARY_VOL_DESC]);
|
2018-02-09 14:15:39 +00:00
|
|
|
case TAG_IDENT_IUVD: /* ISO 13346 3/10.4 */
|
2018-02-09 14:56:34 +00:00
|
|
|
return &(data->vds[VDS_POS_IMP_USE_VOL_DESC]);
|
2018-02-09 14:15:39 +00:00
|
|
|
case TAG_IDENT_LVD: /* ISO 13346 3/10.6 */
|
2018-02-09 14:56:34 +00:00
|
|
|
return &(data->vds[VDS_POS_LOGICAL_VOL_DESC]);
|
2018-02-09 14:15:39 +00:00
|
|
|
case TAG_IDENT_USD: /* ISO 13346 3/10.8 */
|
2018-02-09 14:56:34 +00:00
|
|
|
return &(data->vds[VDS_POS_UNALLOC_SPACE_DESC]);
|
|
|
|
case TAG_IDENT_PD: /* ISO 13346 3/10.5 */
|
|
|
|
return handle_partition_descriptor(bh, data);
|
2018-02-09 14:15:39 +00:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
2015-12-10 16:13:41 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2013-07-25 17:10:59 +00:00
|
|
|
* Process a main/reserve volume descriptor sequence.
|
|
|
|
* @block First block of first extent of the sequence.
|
|
|
|
* @lastblock Lastblock of first extent of the sequence.
|
|
|
|
* @fileset There we store extent containing root fileset
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2013-07-25 17:10:59 +00:00
|
|
|
* Returns <0 on error, 0 on success. -EAGAIN is special - try next descriptor
|
|
|
|
* sequence
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2013-07-25 17:10:59 +00:00
|
|
|
static noinline int udf_process_sequence(
|
|
|
|
struct super_block *sb,
|
|
|
|
sector_t block, sector_t lastblock,
|
|
|
|
struct kernel_lb_addr *fileset)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct buffer_head *bh = NULL;
|
2008-02-08 12:20:36 +00:00
|
|
|
struct udf_vds_record *curr;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct generic_desc *gd;
|
|
|
|
struct volDescPtr *vdp;
|
2015-02-04 17:15:04 +00:00
|
|
|
bool done = false;
|
2005-04-16 22:20:36 +00:00
|
|
|
uint32_t vdsn;
|
|
|
|
uint16_t ident;
|
2013-07-25 17:10:59 +00:00
|
|
|
int ret;
|
2015-12-10 16:13:41 +00:00
|
|
|
unsigned int indirections = 0;
|
2018-02-09 14:56:34 +00:00
|
|
|
struct desc_seq_scan_data data;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
memset(data.vds, 0, sizeof(struct udf_vds_record) * VDS_POS_LENGTH);
|
|
|
|
data.size_part_descs = PART_DESC_ALLOC_STEP;
|
2018-08-21 12:52:34 +00:00
|
|
|
data.num_part_descs = 0;
|
treewide: kzalloc() -> kcalloc()
The kzalloc() function has a 2-factor argument form, kcalloc(). This
patch replaces cases of:
kzalloc(a * b, gfp)
with:
kcalloc(a * b, gfp)
as well as handling cases of:
kzalloc(a * b * c, gfp)
with:
kzalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kzalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kzalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kzalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kzalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kzalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kzalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kzalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kzalloc
+ kcalloc
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kzalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kzalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kzalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kzalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kzalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kzalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kzalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kzalloc(sizeof(THING) * C2, ...)
|
kzalloc(sizeof(TYPE) * C2, ...)
|
kzalloc(C1 * C2 * C3, ...)
|
kzalloc(C1 * C2, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * E2
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kzalloc
+ kcalloc
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 21:03:40 +00:00
|
|
|
data.part_descs_loc = kcalloc(data.size_part_descs,
|
|
|
|
sizeof(*data.part_descs_loc),
|
|
|
|
GFP_KERNEL);
|
2018-02-09 14:56:34 +00:00
|
|
|
if (!data.part_descs_loc)
|
|
|
|
return -ENOMEM;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-01 14:50:35 +00:00
|
|
|
/*
|
|
|
|
* Read the main descriptor sequence and find which descriptors
|
|
|
|
* are in it.
|
|
|
|
*/
|
2007-07-19 08:47:43 +00:00
|
|
|
for (; (!done && block <= lastblock); block++) {
|
2005-04-16 22:20:36 +00:00
|
|
|
bh = udf_read_tagged(sb, block, block, &ident);
|
2018-02-08 17:10:54 +00:00
|
|
|
if (!bh)
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Process each descriptor (ISO 13346 3/8.3-8.4) */
|
|
|
|
gd = (struct generic_desc *)bh->b_data;
|
|
|
|
vdsn = le32_to_cpu(gd->volDescSeqNum);
|
2007-07-19 08:47:43 +00:00
|
|
|
switch (ident) {
|
2007-07-21 11:37:18 +00:00
|
|
|
case TAG_IDENT_VDP: /* ISO 13346 3/10.3 */
|
2018-02-09 12:28:41 +00:00
|
|
|
if (++indirections > UDF_MAX_TD_NESTING) {
|
|
|
|
udf_err(sb, "too many Volume Descriptor "
|
|
|
|
"Pointers (max %u supported)\n",
|
|
|
|
UDF_MAX_TD_NESTING);
|
|
|
|
brelse(bh);
|
2020-09-22 10:20:14 +00:00
|
|
|
ret = -EIO;
|
|
|
|
goto out;
|
2007-07-19 08:47:43 +00:00
|
|
|
}
|
2018-02-09 12:28:41 +00:00
|
|
|
|
|
|
|
vdp = (struct volDescPtr *)bh->b_data;
|
|
|
|
block = le32_to_cpu(vdp->nextVolDescSeqExt.extLocation);
|
|
|
|
lastblock = le32_to_cpu(
|
|
|
|
vdp->nextVolDescSeqExt.extLength) >>
|
|
|
|
sb->s_blocksize_bits;
|
|
|
|
lastblock += block - 1;
|
|
|
|
/* For loop is going to increment 'block' again */
|
|
|
|
block--;
|
2007-07-19 08:47:43 +00:00
|
|
|
break;
|
2018-02-09 14:15:39 +00:00
|
|
|
case TAG_IDENT_PVD: /* ISO 13346 3/10.1 */
|
2007-07-21 11:37:18 +00:00
|
|
|
case TAG_IDENT_IUVD: /* ISO 13346 3/10.4 */
|
2018-02-09 14:15:39 +00:00
|
|
|
case TAG_IDENT_LVD: /* ISO 13346 3/10.6 */
|
|
|
|
case TAG_IDENT_USD: /* ISO 13346 3/10.8 */
|
2018-02-09 14:56:34 +00:00
|
|
|
case TAG_IDENT_PD: /* ISO 13346 3/10.5 */
|
|
|
|
curr = get_volume_descriptor_record(ident, bh, &data);
|
|
|
|
if (IS_ERR(curr)) {
|
|
|
|
brelse(bh);
|
2020-09-22 10:20:14 +00:00
|
|
|
ret = PTR_ERR(curr);
|
|
|
|
goto out;
|
2018-02-09 14:56:34 +00:00
|
|
|
}
|
|
|
|
/* Descriptor we don't care about? */
|
|
|
|
if (!curr)
|
|
|
|
break;
|
2008-02-08 12:20:36 +00:00
|
|
|
if (vdsn >= curr->volDescSeqNum) {
|
|
|
|
curr->volDescSeqNum = vdsn;
|
|
|
|
curr->block = block;
|
2007-07-19 08:47:43 +00:00
|
|
|
}
|
|
|
|
break;
|
2007-07-21 11:37:18 +00:00
|
|
|
case TAG_IDENT_TD: /* ISO 13346 3/10.9 */
|
2018-02-09 12:28:41 +00:00
|
|
|
done = true;
|
2007-07-19 08:47:43 +00:00
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2007-05-08 07:35:16 +00:00
|
|
|
brelse(bh);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-04-01 14:50:35 +00:00
|
|
|
/*
|
|
|
|
* Now read interesting descriptors again and process them
|
|
|
|
* in a suitable order
|
|
|
|
*/
|
2018-02-09 14:56:34 +00:00
|
|
|
if (!data.vds[VDS_POS_PRIMARY_VOL_DESC].block) {
|
2011-10-10 08:08:05 +00:00
|
|
|
udf_err(sb, "Primary Volume Descriptor not found!\n");
|
2020-09-22 10:20:14 +00:00
|
|
|
ret = -EAGAIN;
|
|
|
|
goto out;
|
2013-07-25 17:10:59 +00:00
|
|
|
}
|
2018-02-09 14:56:34 +00:00
|
|
|
ret = udf_load_pvoldesc(sb, data.vds[VDS_POS_PRIMARY_VOL_DESC].block);
|
2013-07-25 17:10:59 +00:00
|
|
|
if (ret < 0)
|
2020-09-22 10:20:14 +00:00
|
|
|
goto out;
|
2013-07-25 17:10:59 +00:00
|
|
|
|
2018-02-09 14:56:34 +00:00
|
|
|
if (data.vds[VDS_POS_LOGICAL_VOL_DESC].block) {
|
2013-07-25 17:10:59 +00:00
|
|
|
ret = udf_load_logicalvol(sb,
|
2018-02-09 14:56:34 +00:00
|
|
|
data.vds[VDS_POS_LOGICAL_VOL_DESC].block,
|
|
|
|
fileset);
|
2013-07-25 17:10:59 +00:00
|
|
|
if (ret < 0)
|
2020-09-22 10:20:14 +00:00
|
|
|
goto out;
|
2008-04-01 14:50:35 +00:00
|
|
|
}
|
2008-02-10 10:33:08 +00:00
|
|
|
|
2018-02-09 14:56:34 +00:00
|
|
|
/* Now handle prevailing Partition Descriptors */
|
2018-08-21 12:52:34 +00:00
|
|
|
for (i = 0; i < data.num_part_descs; i++) {
|
|
|
|
ret = udf_load_partdesc(sb, data.part_descs_loc[i].rec.block);
|
|
|
|
if (ret < 0)
|
2020-09-22 10:20:14 +00:00
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2020-09-22 10:20:14 +00:00
|
|
|
ret = 0;
|
|
|
|
out:
|
|
|
|
kfree(data.part_descs_loc);
|
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2013-07-25 17:10:59 +00:00
|
|
|
/*
|
|
|
|
* Load Volume Descriptor Sequence described by anchor in bh
|
|
|
|
*
|
|
|
|
* Returns <0 on error, 0 on success
|
|
|
|
*/
|
2009-03-19 15:21:38 +00:00
|
|
|
static int udf_load_sequence(struct super_block *sb, struct buffer_head *bh,
|
|
|
|
struct kernel_lb_addr *fileset)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-03-19 15:21:38 +00:00
|
|
|
struct anchorVolDescPtr *anchor;
|
2013-07-25 17:10:59 +00:00
|
|
|
sector_t main_s, main_e, reserve_s, reserve_e;
|
|
|
|
int ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-03-19 15:21:38 +00:00
|
|
|
anchor = (struct anchorVolDescPtr *)bh->b_data;
|
|
|
|
|
|
|
|
/* Locate the main sequence */
|
|
|
|
main_s = le32_to_cpu(anchor->mainVolDescSeqExt.extLocation);
|
|
|
|
main_e = le32_to_cpu(anchor->mainVolDescSeqExt.extLength);
|
|
|
|
main_e = main_e >> sb->s_blocksize_bits;
|
2018-02-08 16:39:01 +00:00
|
|
|
main_e += main_s - 1;
|
2009-03-19 15:21:38 +00:00
|
|
|
|
|
|
|
/* Locate the reserve sequence */
|
|
|
|
reserve_s = le32_to_cpu(anchor->reserveVolDescSeqExt.extLocation);
|
|
|
|
reserve_e = le32_to_cpu(anchor->reserveVolDescSeqExt.extLength);
|
|
|
|
reserve_e = reserve_e >> sb->s_blocksize_bits;
|
2018-02-08 16:39:01 +00:00
|
|
|
reserve_e += reserve_s - 1;
|
2009-03-19 15:21:38 +00:00
|
|
|
|
|
|
|
/* Process the main & reserve sequences */
|
|
|
|
/* responsible for finding the PartitionDesc(s) */
|
2013-07-25 17:10:59 +00:00
|
|
|
ret = udf_process_sequence(sb, main_s, main_e, fileset);
|
|
|
|
if (ret != -EAGAIN)
|
|
|
|
return ret;
|
2012-06-27 20:27:05 +00:00
|
|
|
udf_sb_free_partitions(sb);
|
2013-07-25 17:10:59 +00:00
|
|
|
ret = udf_process_sequence(sb, reserve_s, reserve_e, fileset);
|
|
|
|
if (ret < 0) {
|
|
|
|
udf_sb_free_partitions(sb);
|
|
|
|
/* No sequence was OK, return -EIO */
|
|
|
|
if (ret == -EAGAIN)
|
|
|
|
ret = -EIO;
|
|
|
|
}
|
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-03-19 15:21:38 +00:00
|
|
|
/*
|
|
|
|
* Check whether there is an anchor block in the given block and
|
|
|
|
* load Volume Descriptor Sequence if so.
|
2013-07-25 17:10:59 +00:00
|
|
|
*
|
|
|
|
* Returns <0 on error, 0 on success, -EAGAIN is special - try next anchor
|
|
|
|
* block
|
2009-03-19 15:21:38 +00:00
|
|
|
*/
|
|
|
|
static int udf_check_anchor_block(struct super_block *sb, sector_t block,
|
|
|
|
struct kernel_lb_addr *fileset)
|
2009-03-11 14:57:47 +00:00
|
|
|
{
|
2009-03-19 15:21:38 +00:00
|
|
|
struct buffer_head *bh;
|
|
|
|
uint16_t ident;
|
|
|
|
int ret;
|
2009-03-11 14:57:47 +00:00
|
|
|
|
2009-03-19 15:21:38 +00:00
|
|
|
bh = udf_read_tagged(sb, block, block, &ident);
|
|
|
|
if (!bh)
|
2013-07-25 17:10:59 +00:00
|
|
|
return -EAGAIN;
|
2009-03-19 15:21:38 +00:00
|
|
|
if (ident != TAG_IDENT_AVDP) {
|
|
|
|
brelse(bh);
|
2013-07-25 17:10:59 +00:00
|
|
|
return -EAGAIN;
|
2009-03-11 14:57:47 +00:00
|
|
|
}
|
2009-03-19 15:21:38 +00:00
|
|
|
ret = udf_load_sequence(sb, bh, fileset);
|
|
|
|
brelse(bh);
|
|
|
|
return ret;
|
2009-03-11 14:57:47 +00:00
|
|
|
}
|
|
|
|
|
2013-07-25 17:10:59 +00:00
|
|
|
/*
|
|
|
|
* Search for an anchor volume descriptor pointer.
|
|
|
|
*
|
|
|
|
* Returns < 0 on error, 0 on success. -EAGAIN is special - try next set
|
|
|
|
* of anchors.
|
|
|
|
*/
|
2023-01-18 12:55:31 +00:00
|
|
|
static int udf_scan_anchors(struct super_block *sb, udf_pblk_t *lastblock,
|
2013-07-25 17:10:59 +00:00
|
|
|
struct kernel_lb_addr *fileset)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2023-01-18 12:55:31 +00:00
|
|
|
udf_pblk_t last[6];
|
2008-04-02 14:01:35 +00:00
|
|
|
int i;
|
2009-03-19 15:21:38 +00:00
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
|
|
|
int last_count = 0;
|
2013-07-25 17:10:59 +00:00
|
|
|
int ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-03-19 15:21:38 +00:00
|
|
|
/* First try user provided anchor */
|
|
|
|
if (sbi->s_anchor) {
|
2013-07-25 17:10:59 +00:00
|
|
|
ret = udf_check_anchor_block(sb, sbi->s_anchor, fileset);
|
|
|
|
if (ret != -EAGAIN)
|
|
|
|
return ret;
|
2009-03-19 15:21:38 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* according to spec, anchor is in either:
|
|
|
|
* block 256
|
|
|
|
* lastblock-256
|
|
|
|
* lastblock
|
|
|
|
* however, if the disc isn't closed, it could be 512.
|
|
|
|
*/
|
2013-07-25 17:10:59 +00:00
|
|
|
ret = udf_check_anchor_block(sb, sbi->s_session + 256, fileset);
|
|
|
|
if (ret != -EAGAIN)
|
|
|
|
return ret;
|
2009-03-19 15:21:38 +00:00
|
|
|
/*
|
|
|
|
* The trouble is which block is the last one. Drives often misreport
|
|
|
|
* this so we try various possibilities.
|
|
|
|
*/
|
2013-07-25 17:10:59 +00:00
|
|
|
last[last_count++] = *lastblock;
|
|
|
|
if (*lastblock >= 1)
|
|
|
|
last[last_count++] = *lastblock - 1;
|
|
|
|
last[last_count++] = *lastblock + 1;
|
|
|
|
if (*lastblock >= 2)
|
|
|
|
last[last_count++] = *lastblock - 2;
|
|
|
|
if (*lastblock >= 150)
|
|
|
|
last[last_count++] = *lastblock - 150;
|
|
|
|
if (*lastblock >= 152)
|
|
|
|
last[last_count++] = *lastblock - 152;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-03-19 15:21:38 +00:00
|
|
|
for (i = 0; i < last_count; i++) {
|
2021-10-18 10:11:30 +00:00
|
|
|
if (last[i] >= sb_bdev_nr_blocks(sb))
|
2008-02-08 12:20:46 +00:00
|
|
|
continue;
|
2013-07-25 17:10:59 +00:00
|
|
|
ret = udf_check_anchor_block(sb, last[i], fileset);
|
|
|
|
if (ret != -EAGAIN) {
|
|
|
|
if (!ret)
|
|
|
|
*lastblock = last[i];
|
|
|
|
return ret;
|
|
|
|
}
|
2009-03-19 15:21:38 +00:00
|
|
|
if (last[i] < 256)
|
2008-02-08 12:20:46 +00:00
|
|
|
continue;
|
2013-07-25 17:10:59 +00:00
|
|
|
ret = udf_check_anchor_block(sb, last[i] - 256, fileset);
|
|
|
|
if (ret != -EAGAIN) {
|
|
|
|
if (!ret)
|
|
|
|
*lastblock = last[i];
|
|
|
|
return ret;
|
|
|
|
}
|
2009-03-19 15:21:38 +00:00
|
|
|
}
|
2008-02-08 12:20:46 +00:00
|
|
|
|
2009-03-19 15:21:38 +00:00
|
|
|
/* Finally try block 512 in case media is open */
|
2013-07-25 17:10:59 +00:00
|
|
|
return udf_check_anchor_block(sb, sbi->s_session + 512, fileset);
|
2009-03-19 15:21:38 +00:00
|
|
|
}
|
2008-02-08 12:20:46 +00:00
|
|
|
|
2009-03-19 15:21:38 +00:00
|
|
|
/*
|
|
|
|
* Check Volume Structure Descriptor, find Anchor block and load Volume
|
2013-07-25 17:10:59 +00:00
|
|
|
* Descriptor Sequence.
|
|
|
|
*
|
|
|
|
* Returns < 0 on error, 0 on success. -EAGAIN is special meaning anchor
|
|
|
|
* block was not found.
|
2009-03-19 15:21:38 +00:00
|
|
|
*/
|
|
|
|
static int udf_load_vrs(struct super_block *sb, struct udf_options *uopt,
|
|
|
|
int silent, struct kernel_lb_addr *fileset)
|
|
|
|
{
|
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
2019-07-11 13:38:51 +00:00
|
|
|
int nsr = 0;
|
2013-07-25 17:10:59 +00:00
|
|
|
int ret;
|
2009-03-19 15:21:38 +00:00
|
|
|
|
|
|
|
if (!sb_set_blocksize(sb, uopt->blocksize)) {
|
|
|
|
if (!silent)
|
2011-10-10 08:08:05 +00:00
|
|
|
udf_warn(sb, "Bad block size\n");
|
2013-07-25 17:10:59 +00:00
|
|
|
return -EINVAL;
|
2009-03-19 15:21:38 +00:00
|
|
|
}
|
|
|
|
sbi->s_last_block = uopt->lastblock;
|
|
|
|
if (!uopt->novrs) {
|
|
|
|
/* Check that it is NSR02 compliant */
|
2019-07-11 13:38:51 +00:00
|
|
|
nsr = udf_check_vsd(sb);
|
|
|
|
if (!nsr) {
|
2009-03-19 15:21:38 +00:00
|
|
|
if (!silent)
|
2011-10-10 08:08:05 +00:00
|
|
|
udf_warn(sb, "No VRS found\n");
|
2017-01-18 18:39:35 +00:00
|
|
|
return -EINVAL;
|
2009-03-19 15:21:38 +00:00
|
|
|
}
|
2019-07-11 13:38:51 +00:00
|
|
|
if (nsr == -1)
|
udf: fix for pathetic mount times in case of invalid file system
The UDF driver was not strict enough about checking the IDs in the
VSDs when mounting, which resulted in reading through all the sectors
of the block device in some unfortunate cases. Eg, trying to mount my
uninitialized 200G SSD partition (all 0xFF bytes) took ~350 minutes to
fail, because the code expected some of the valid IDs or a zero byte.
During this, the mount couldn't be killed, sync from the cmdline
blocked, and the machine froze into the shutdown. Valid filesystems
(extX, btrfs, ntfs) were rejected by the mere accident of having a
zero byte at just the right place in some of their sectors, close
enough to the beginning not to generate excess I/O. The fix adds a
hard limit on the VSD sector offset, adds the two missing VSD IDs, and
stops scanning when encountering an invalid ID. Also replaced the
magic number 32768 with a more meaningful #define, and supressed the
bogus message about failing to read the first sector if no UDF fs was
detected.
Signed-off-by: Peter A. Felvegi <petschy@gmail.com>
Signed-off-by: Jan Kara <jack@suse.cz>
2013-10-18 18:07:44 +00:00
|
|
|
udf_debug("Failed to read sector at offset %d. "
|
|
|
|
"Assuming open disc. Skipping validity "
|
|
|
|
"check\n", VSD_FIRST_SECTOR_OFFSET);
|
2009-03-19 15:21:38 +00:00
|
|
|
if (!sbi->s_last_block)
|
|
|
|
sbi->s_last_block = udf_get_last_block(sb);
|
|
|
|
} else {
|
|
|
|
udf_debug("Validity check skipped because of novrs option\n");
|
2008-02-08 12:20:46 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-03-19 15:21:38 +00:00
|
|
|
/* Look for anchor block and load Volume Descriptor Sequence */
|
|
|
|
sbi->s_anchor = uopt->anchor;
|
2023-01-18 12:27:07 +00:00
|
|
|
ret = udf_scan_anchors(sb, &sbi->s_last_block, fileset);
|
2013-07-25 17:10:59 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
if (!silent && ret == -EAGAIN)
|
2011-10-10 08:08:05 +00:00
|
|
|
udf_warn(sb, "No anchor found\n");
|
2013-07-25 17:10:59 +00:00
|
|
|
return ret;
|
2009-03-19 15:21:38 +00:00
|
|
|
}
|
2013-07-25 17:10:59 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2019-02-08 17:34:54 +00:00
|
|
|
static void udf_finalize_lvid(struct logicalVolIntegrityDesc *lvid)
|
|
|
|
{
|
|
|
|
struct timespec64 ts;
|
|
|
|
|
|
|
|
ktime_get_real_ts64(&ts);
|
|
|
|
udf_time_to_disk_stamp(&lvid->recordingDateAndTime, ts);
|
|
|
|
lvid->descTag.descCRC = cpu_to_le16(
|
|
|
|
crc_itu_t(0, (char *)lvid + sizeof(struct tag),
|
|
|
|
le16_to_cpu(lvid->descTag.descCRCLength)));
|
|
|
|
lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static void udf_open_lvid(struct super_block *sb)
|
|
|
|
{
|
2008-02-08 12:20:30 +00:00
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
|
|
|
struct buffer_head *bh = sbi->s_lvid_bh;
|
2008-02-10 10:33:08 +00:00
|
|
|
struct logicalVolIntegrityDesc *lvid;
|
|
|
|
struct logicalVolIntegrityDescImpUse *lvidiu;
|
2009-03-16 17:27:37 +00:00
|
|
|
|
2008-02-10 10:33:08 +00:00
|
|
|
if (!bh)
|
|
|
|
return;
|
|
|
|
lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
|
2013-09-12 20:00:15 +00:00
|
|
|
lvidiu = udf_sb_lvidiu(sb);
|
|
|
|
if (!lvidiu)
|
|
|
|
return;
|
2008-02-10 10:33:08 +00:00
|
|
|
|
2013-09-12 20:00:15 +00:00
|
|
|
mutex_lock(&sbi->s_alloc_mutex);
|
2008-02-10 10:33:08 +00:00
|
|
|
lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
|
|
|
|
lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
|
2018-02-27 17:55:31 +00:00
|
|
|
if (le32_to_cpu(lvid->integrityType) == LVID_INTEGRITY_TYPE_CLOSE)
|
|
|
|
lvid->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_OPEN);
|
|
|
|
else
|
|
|
|
UDF_SET_FLAG(sb, UDF_FLAG_INCONSISTENT);
|
2008-02-10 10:33:08 +00:00
|
|
|
|
2019-02-08 17:34:54 +00:00
|
|
|
udf_finalize_lvid(lvid);
|
2008-02-10 10:33:08 +00:00
|
|
|
mark_buffer_dirty(bh);
|
2009-03-16 17:27:37 +00:00
|
|
|
sbi->s_lvid_dirty = 0;
|
2010-10-20 16:49:20 +00:00
|
|
|
mutex_unlock(&sbi->s_alloc_mutex);
|
2013-01-17 21:11:38 +00:00
|
|
|
/* Make opening of filesystem visible on the media immediately */
|
|
|
|
sync_dirty_buffer(bh);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void udf_close_lvid(struct super_block *sb)
|
|
|
|
{
|
2008-02-08 12:20:30 +00:00
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
|
|
|
struct buffer_head *bh = sbi->s_lvid_bh;
|
|
|
|
struct logicalVolIntegrityDesc *lvid;
|
2008-02-10 10:33:08 +00:00
|
|
|
struct logicalVolIntegrityDescImpUse *lvidiu;
|
2007-07-21 11:37:18 +00:00
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
if (!bh)
|
|
|
|
return;
|
2013-09-12 20:00:15 +00:00
|
|
|
lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
|
|
|
|
lvidiu = udf_sb_lvidiu(sb);
|
|
|
|
if (!lvidiu)
|
|
|
|
return;
|
2008-02-08 12:20:30 +00:00
|
|
|
|
2010-10-20 16:49:20 +00:00
|
|
|
mutex_lock(&sbi->s_alloc_mutex);
|
2008-02-10 10:33:08 +00:00
|
|
|
lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
|
|
|
|
lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
|
|
|
|
if (UDF_MAX_WRITE_VERSION > le16_to_cpu(lvidiu->maxUDFWriteRev))
|
|
|
|
lvidiu->maxUDFWriteRev = cpu_to_le16(UDF_MAX_WRITE_VERSION);
|
|
|
|
if (sbi->s_udfrev > le16_to_cpu(lvidiu->minUDFReadRev))
|
|
|
|
lvidiu->minUDFReadRev = cpu_to_le16(sbi->s_udfrev);
|
|
|
|
if (sbi->s_udfrev > le16_to_cpu(lvidiu->minUDFWriteRev))
|
|
|
|
lvidiu->minUDFWriteRev = cpu_to_le16(sbi->s_udfrev);
|
2018-02-27 17:55:31 +00:00
|
|
|
if (!UDF_QUERY_FLAG(sb, UDF_FLAG_INCONSISTENT))
|
|
|
|
lvid->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE);
|
2008-02-10 10:33:08 +00:00
|
|
|
|
2011-12-23 10:53:07 +00:00
|
|
|
/*
|
|
|
|
* We set buffer uptodate unconditionally here to avoid spurious
|
|
|
|
* warnings from mark_buffer_dirty() when previous EIO has marked
|
|
|
|
* the buffer as !uptodate
|
|
|
|
*/
|
|
|
|
set_buffer_uptodate(bh);
|
2019-02-08 17:34:54 +00:00
|
|
|
udf_finalize_lvid(lvid);
|
2008-02-10 10:33:08 +00:00
|
|
|
mark_buffer_dirty(bh);
|
2009-03-16 17:27:37 +00:00
|
|
|
sbi->s_lvid_dirty = 0;
|
2010-10-20 16:49:20 +00:00
|
|
|
mutex_unlock(&sbi->s_alloc_mutex);
|
2013-01-17 21:11:38 +00:00
|
|
|
/* Make closing of filesystem visible on the media immediately */
|
|
|
|
sync_dirty_buffer(bh);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2010-10-20 16:28:46 +00:00
|
|
|
u64 lvid_get_unique_id(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct buffer_head *bh;
|
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
|
|
|
struct logicalVolIntegrityDesc *lvid;
|
|
|
|
struct logicalVolHeaderDesc *lvhd;
|
|
|
|
u64 uniqueID;
|
|
|
|
u64 ret;
|
|
|
|
|
|
|
|
bh = sbi->s_lvid_bh;
|
|
|
|
if (!bh)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
|
|
|
|
lvhd = (struct logicalVolHeaderDesc *)lvid->logicalVolContentsUse;
|
|
|
|
|
|
|
|
mutex_lock(&sbi->s_alloc_mutex);
|
|
|
|
ret = uniqueID = le64_to_cpu(lvhd->uniqueID);
|
|
|
|
if (!(++uniqueID & 0xFFFFFFFF))
|
|
|
|
uniqueID += 16;
|
|
|
|
lvhd->uniqueID = cpu_to_le64(uniqueID);
|
2019-02-08 17:34:55 +00:00
|
|
|
udf_updated_lvid(sb);
|
2010-10-20 16:28:46 +00:00
|
|
|
mutex_unlock(&sbi->s_alloc_mutex);
|
|
|
|
|
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int udf_fill_super(struct super_block *sb, void *options, int silent)
|
|
|
|
{
|
2013-07-25 17:10:59 +00:00
|
|
|
int ret = -EINVAL;
|
2007-07-19 08:47:43 +00:00
|
|
|
struct inode *inode = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct udf_options uopt;
|
2008-10-15 10:28:03 +00:00
|
|
|
struct kernel_lb_addr rootdir, fileset;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct udf_sb_info *sbi;
|
2015-08-20 12:50:07 +00:00
|
|
|
bool lvid_open = false;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
uopt.flags = (1 << UDF_FLAG_USE_AD_IN_ICB) | (1 << UDF_FLAG_STRICT);
|
2018-02-22 09:39:52 +00:00
|
|
|
/* By default we'll use overflow[ug]id when UDF inode [ug]id == -1 */
|
|
|
|
uopt.uid = make_kuid(current_user_ns(), overflowuid);
|
|
|
|
uopt.gid = make_kgid(current_user_ns(), overflowgid);
|
2005-04-16 22:20:36 +00:00
|
|
|
uopt.umask = 0;
|
2008-12-02 12:40:11 +00:00
|
|
|
uopt.fmode = UDF_INVALID_MODE;
|
|
|
|
uopt.dmode = UDF_INVALID_MODE;
|
2018-02-25 13:25:07 +00:00
|
|
|
uopt.nls_map = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-08-15 14:45:44 +00:00
|
|
|
sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
|
2010-11-16 17:40:49 +00:00
|
|
|
if (!sbi)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -ENOMEM;
|
2007-07-21 11:37:18 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
sb->s_fs_info = sbi;
|
|
|
|
|
2006-03-23 11:00:44 +00:00
|
|
|
mutex_init(&sbi->s_alloc_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-08 12:21:50 +00:00
|
|
|
if (!udf_parse_options((char *)options, &uopt, false))
|
2014-11-18 17:29:10 +00:00
|
|
|
goto parse_options_failure;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
fileset.logicalBlockNum = 0xFFFFFFFF;
|
|
|
|
fileset.partitionReferenceNum = 0xFFFF;
|
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
sbi->s_flags = uopt.flags;
|
|
|
|
sbi->s_uid = uopt.uid;
|
|
|
|
sbi->s_gid = uopt.gid;
|
|
|
|
sbi->s_umask = uopt.umask;
|
2008-11-16 19:52:19 +00:00
|
|
|
sbi->s_fmode = uopt.fmode;
|
|
|
|
sbi->s_dmode = uopt.dmode;
|
2008-02-08 12:20:30 +00:00
|
|
|
sbi->s_nls_map = uopt.nls_map;
|
2010-10-20 20:17:28 +00:00
|
|
|
rwlock_init(&sbi->s_cred_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
if (uopt.session == 0xFFFFFFFF)
|
2008-02-08 12:20:30 +00:00
|
|
|
sbi->s_session = udf_get_last_session(sb);
|
2005-04-16 22:20:36 +00:00
|
|
|
else
|
2008-02-08 12:20:30 +00:00
|
|
|
sbi->s_session = uopt.session;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
udf_debug("Multi-session=%d\n", sbi->s_session);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-03-19 15:21:38 +00:00
|
|
|
/* Fill in the rest of the superblock */
|
|
|
|
sb->s_op = &udf_sb_ops;
|
|
|
|
sb->s_export_op = &udf_export_ops;
|
2010-05-19 11:16:44 +00:00
|
|
|
|
2009-03-19 15:21:38 +00:00
|
|
|
sb->s_magic = UDF_SUPER_MAGIC;
|
|
|
|
sb->s_time_gran = 1000;
|
|
|
|
|
2009-03-11 14:57:47 +00:00
|
|
|
if (uopt.flags & (1 << UDF_FLAG_BLOCKSIZE_SET)) {
|
2009-03-19 15:21:38 +00:00
|
|
|
ret = udf_load_vrs(sb, &uopt, silent, &fileset);
|
2009-03-11 14:57:47 +00:00
|
|
|
} else {
|
2009-05-22 21:17:49 +00:00
|
|
|
uopt.blocksize = bdev_logical_block_size(sb->s_bdev);
|
2017-01-18 18:39:35 +00:00
|
|
|
while (uopt.blocksize <= 4096) {
|
2009-03-19 15:21:38 +00:00
|
|
|
ret = udf_load_vrs(sb, &uopt, silent, &fileset);
|
2017-01-18 18:39:35 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
if (!silent && ret != -EACCES) {
|
2017-10-12 13:48:41 +00:00
|
|
|
pr_notice("Scanning with blocksize %u failed\n",
|
2017-01-18 18:39:35 +00:00
|
|
|
uopt.blocksize);
|
|
|
|
}
|
|
|
|
brelse(sbi->s_lvid_bh);
|
|
|
|
sbi->s_lvid_bh = NULL;
|
|
|
|
/*
|
|
|
|
* EACCES is special - we want to propagate to
|
|
|
|
* upper layers that we cannot handle RW mount.
|
|
|
|
*/
|
|
|
|
if (ret == -EACCES)
|
|
|
|
break;
|
|
|
|
} else
|
|
|
|
break;
|
|
|
|
|
|
|
|
uopt.blocksize <<= 1;
|
2009-03-11 14:57:47 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2013-07-25 17:10:59 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
if (ret == -EAGAIN) {
|
|
|
|
udf_warn(sb, "No partition found (1)\n");
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
|
2017-10-12 13:48:41 +00:00
|
|
|
udf_debug("Lastblock=%u\n", sbi->s_last_block);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
if (sbi->s_lvid_bh) {
|
2008-02-08 12:20:36 +00:00
|
|
|
struct logicalVolIntegrityDescImpUse *lvidiu =
|
2013-09-12 20:00:15 +00:00
|
|
|
udf_sb_lvidiu(sb);
|
|
|
|
uint16_t minUDFReadRev;
|
|
|
|
uint16_t minUDFWriteRev;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-09-12 20:00:15 +00:00
|
|
|
if (!lvidiu) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
minUDFReadRev = le16_to_cpu(lvidiu->minUDFReadRev);
|
|
|
|
minUDFWriteRev = le16_to_cpu(lvidiu->minUDFWriteRev);
|
2007-07-19 08:47:43 +00:00
|
|
|
if (minUDFReadRev > UDF_MAX_READ_VERSION) {
|
2011-10-10 08:08:05 +00:00
|
|
|
udf_err(sb, "minUDFReadRev=%x (max is %x)\n",
|
2013-09-12 20:00:15 +00:00
|
|
|
minUDFReadRev,
|
2011-10-10 08:08:05 +00:00
|
|
|
UDF_MAX_READ_VERSION);
|
2013-07-25 17:10:59 +00:00
|
|
|
ret = -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
goto error_out;
|
2018-09-06 13:56:10 +00:00
|
|
|
} else if (minUDFWriteRev > UDF_MAX_WRITE_VERSION) {
|
|
|
|
if (!sb_rdonly(sb)) {
|
|
|
|
ret = -EACCES;
|
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
UDF_SET_FLAG(sb, UDF_FLAG_RW_INCOMPAT);
|
2013-07-25 14:15:16 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
sbi->s_udfrev = minUDFWriteRev;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (minUDFReadRev >= UDF_VERS_USE_EXTENDED_FE)
|
|
|
|
UDF_SET_FLAG(sb, UDF_FLAG_USE_EXTENDED_FE);
|
|
|
|
if (minUDFReadRev >= UDF_VERS_USE_STREAMS)
|
|
|
|
UDF_SET_FLAG(sb, UDF_FLAG_USE_STREAMS);
|
|
|
|
}
|
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
if (!sbi->s_partitions) {
|
2011-10-10 08:08:05 +00:00
|
|
|
udf_warn(sb, "No partition found (2)\n");
|
2013-07-25 17:10:59 +00:00
|
|
|
ret = -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
|
2008-02-08 12:20:36 +00:00
|
|
|
if (sbi->s_partmaps[sbi->s_partition].s_partition_flags &
|
2018-09-06 13:56:10 +00:00
|
|
|
UDF_PART_FLAG_READ_ONLY) {
|
|
|
|
if (!sb_rdonly(sb)) {
|
|
|
|
ret = -EACCES;
|
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
UDF_SET_FLAG(sb, UDF_FLAG_RW_INCOMPAT);
|
2006-10-05 19:17:50 +00:00
|
|
|
}
|
2006-09-29 08:59:41 +00:00
|
|
|
|
2019-08-29 12:11:54 +00:00
|
|
|
ret = udf_find_fileset(sb, &fileset, &rootdir);
|
|
|
|
if (ret < 0) {
|
2011-10-10 08:08:05 +00:00
|
|
|
udf_warn(sb, "No fileset found\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
if (!silent) {
|
2008-10-15 10:28:03 +00:00
|
|
|
struct timestamp ts;
|
2008-02-10 10:25:31 +00:00
|
|
|
udf_time_to_disk_stamp(&ts, sbi->s_record_time);
|
2011-10-10 08:08:05 +00:00
|
|
|
udf_info("Mounting volume '%s', timestamp %04u/%02u/%02u %02u:%02u (%x)\n",
|
|
|
|
sbi->s_volume_ident,
|
|
|
|
le16_to_cpu(ts.year), ts.month, ts.day,
|
2008-02-10 10:25:31 +00:00
|
|
|
ts.hour, ts.minute, le16_to_cpu(ts.typeAndTimezone));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2017-07-17 07:45:34 +00:00
|
|
|
if (!sb_rdonly(sb)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
udf_open_lvid(sb);
|
2015-08-20 12:50:07 +00:00
|
|
|
lvid_open = true;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Assign the root inode */
|
|
|
|
/* assign inodes by physical block number */
|
|
|
|
/* perhaps it's not extensible enough, but for now ... */
|
2008-10-15 10:29:03 +00:00
|
|
|
inode = udf_iget(sb, &rootdir);
|
2014-09-04 14:15:51 +00:00
|
|
|
if (IS_ERR(inode)) {
|
2017-10-12 13:48:41 +00:00
|
|
|
udf_err(sb, "Error in udf_iget, block=%u, partition=%u\n",
|
2007-07-19 08:47:43 +00:00
|
|
|
rootdir.logicalBlockNum, rootdir.partitionReferenceNum);
|
2014-09-04 14:15:51 +00:00
|
|
|
ret = PTR_ERR(inode);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate a dentry for the root inode */
|
2012-01-09 03:15:13 +00:00
|
|
|
sb->s_root = d_make_root(inode);
|
2007-07-19 08:47:43 +00:00
|
|
|
if (!sb->s_root) {
|
2011-10-10 08:08:05 +00:00
|
|
|
udf_err(sb, "Couldn't allocate root dentry\n");
|
2013-07-25 17:10:59 +00:00
|
|
|
ret = -ENOMEM;
|
2005-04-16 22:20:36 +00:00
|
|
|
goto error_out;
|
|
|
|
}
|
2023-01-25 16:56:06 +00:00
|
|
|
sb->s_maxbytes = UDF_MAX_FILESIZE;
|
2012-02-06 17:45:27 +00:00
|
|
|
sb->s_max_links = UDF_MAX_LINKS;
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
|
2007-07-21 11:37:18 +00:00
|
|
|
error_out:
|
2014-11-18 16:17:46 +00:00
|
|
|
iput(sbi->s_vat_inode);
|
2014-11-18 17:29:10 +00:00
|
|
|
parse_options_failure:
|
2021-08-08 16:24:36 +00:00
|
|
|
unload_nls(uopt.nls_map);
|
2015-08-20 12:50:07 +00:00
|
|
|
if (lvid_open)
|
2005-04-16 22:20:36 +00:00
|
|
|
udf_close_lvid(sb);
|
2008-02-08 12:20:30 +00:00
|
|
|
brelse(sbi->s_lvid_bh);
|
2012-06-27 20:27:05 +00:00
|
|
|
udf_sb_free_partitions(sb);
|
2005-04-16 22:20:36 +00:00
|
|
|
kfree(sbi);
|
|
|
|
sb->s_fs_info = NULL;
|
2007-07-21 11:37:18 +00:00
|
|
|
|
2013-07-25 17:10:59 +00:00
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2011-10-10 08:08:03 +00:00
|
|
|
void _udf_err(struct super_block *sb, const char *function,
|
|
|
|
const char *fmt, ...)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2011-10-10 08:08:06 +00:00
|
|
|
struct va_format vaf;
|
2005-04-16 22:20:36 +00:00
|
|
|
va_list args;
|
|
|
|
|
|
|
|
va_start(args, fmt);
|
2011-10-10 08:08:06 +00:00
|
|
|
|
|
|
|
vaf.fmt = fmt;
|
|
|
|
vaf.va = &args;
|
|
|
|
|
|
|
|
pr_err("error (device %s): %s: %pV", sb->s_id, function, &vaf);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
va_end(args);
|
|
|
|
}
|
|
|
|
|
2011-10-10 08:08:04 +00:00
|
|
|
void _udf_warn(struct super_block *sb, const char *function,
|
|
|
|
const char *fmt, ...)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2011-10-10 08:08:06 +00:00
|
|
|
struct va_format vaf;
|
2005-04-16 22:20:36 +00:00
|
|
|
va_list args;
|
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
va_start(args, fmt);
|
2011-10-10 08:08:06 +00:00
|
|
|
|
|
|
|
vaf.fmt = fmt;
|
|
|
|
vaf.va = &args;
|
|
|
|
|
|
|
|
pr_warn("warning (device %s): %s: %pV", sb->s_id, function, &vaf);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
va_end(args);
|
|
|
|
}
|
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
static void udf_put_super(struct super_block *sb)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-02-08 12:20:30 +00:00
|
|
|
struct udf_sb_info *sbi;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
sbi = UDF_SB(sb);
|
push BKL down into ->put_super
Move BKL into ->put_super from the only caller. A couple of
filesystems had trivial enough ->put_super (only kfree and NULLing of
s_fs_info + stuff in there) to not get any locking: coda, cramfs, efs,
hugetlbfs, omfs, qnx4, shmem, all others got the full treatment. Most
of them probably don't need it, but I'd rather sort that out individually.
Preferably after all the other BKL pushdowns in that area.
[AV: original used to move lock_super() down as well; these changes are
removed since we don't do lock_super() at all in generic_shutdown_super()
now]
[AV: fuse, btrfs and xfs are known to need no damn BKL, exempt]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2009-05-05 13:40:36 +00:00
|
|
|
|
2014-11-18 16:17:46 +00:00
|
|
|
iput(sbi->s_vat_inode);
|
2021-08-08 16:24:36 +00:00
|
|
|
unload_nls(sbi->s_nls_map);
|
2017-07-17 07:45:34 +00:00
|
|
|
if (!sb_rdonly(sb))
|
2005-04-16 22:20:36 +00:00
|
|
|
udf_close_lvid(sb);
|
2008-02-08 12:20:30 +00:00
|
|
|
brelse(sbi->s_lvid_bh);
|
2012-06-27 20:27:05 +00:00
|
|
|
udf_sb_free_partitions(sb);
|
2015-01-10 18:13:32 +00:00
|
|
|
mutex_destroy(&sbi->s_alloc_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
kfree(sb->s_fs_info);
|
|
|
|
sb->s_fs_info = NULL;
|
|
|
|
}
|
|
|
|
|
2009-03-16 17:27:37 +00:00
|
|
|
static int udf_sync_fs(struct super_block *sb, int wait)
|
|
|
|
{
|
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
|
|
|
|
|
|
|
mutex_lock(&sbi->s_alloc_mutex);
|
|
|
|
if (sbi->s_lvid_dirty) {
|
2019-02-08 17:34:55 +00:00
|
|
|
struct buffer_head *bh = sbi->s_lvid_bh;
|
2019-02-19 13:59:43 +00:00
|
|
|
struct logicalVolIntegrityDesc *lvid;
|
2019-02-08 17:34:55 +00:00
|
|
|
|
2019-02-19 13:59:43 +00:00
|
|
|
lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
|
|
|
|
udf_finalize_lvid(lvid);
|
2019-02-08 17:34:55 +00:00
|
|
|
|
2009-03-16 17:27:37 +00:00
|
|
|
/*
|
|
|
|
* Blockdevice will be synced later so we don't have to submit
|
|
|
|
* the buffer for IO
|
|
|
|
*/
|
2019-02-08 17:34:55 +00:00
|
|
|
mark_buffer_dirty(bh);
|
2009-03-16 17:27:37 +00:00
|
|
|
sbi->s_lvid_dirty = 0;
|
|
|
|
}
|
|
|
|
mutex_unlock(&sbi->s_alloc_mutex);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
static int udf_statfs(struct dentry *dentry, struct kstatfs *buf)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-06-23 09:02:58 +00:00
|
|
|
struct super_block *sb = dentry->d_sb;
|
2008-02-08 12:20:30 +00:00
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
|
|
|
struct logicalVolIntegrityDescImpUse *lvidiu;
|
2009-01-19 17:36:55 +00:00
|
|
|
u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
|
2008-02-08 12:20:30 +00:00
|
|
|
|
2013-09-12 20:00:15 +00:00
|
|
|
lvidiu = udf_sb_lvidiu(sb);
|
2005-04-16 22:20:36 +00:00
|
|
|
buf->f_type = UDF_SUPER_MAGIC;
|
|
|
|
buf->f_bsize = sb->s_blocksize;
|
2008-02-08 12:20:30 +00:00
|
|
|
buf->f_blocks = sbi->s_partmaps[sbi->s_partition].s_partition_len;
|
2005-04-16 22:20:36 +00:00
|
|
|
buf->f_bfree = udf_count_free(sb);
|
|
|
|
buf->f_bavail = buf->f_bfree;
|
2020-01-17 11:36:38 +00:00
|
|
|
/*
|
|
|
|
* Let's pretend each free block is also a free 'inode' since UDF does
|
|
|
|
* not have separate preallocated table of inodes.
|
|
|
|
*/
|
2008-02-08 12:20:30 +00:00
|
|
|
buf->f_files = (lvidiu != NULL ? (le32_to_cpu(lvidiu->numFiles) +
|
|
|
|
le32_to_cpu(lvidiu->numDirs)) : 0)
|
|
|
|
+ buf->f_bfree;
|
2005-04-16 22:20:36 +00:00
|
|
|
buf->f_ffree = buf->f_bfree;
|
2016-01-15 08:44:21 +00:00
|
|
|
buf->f_namelen = UDF_NAME_LEN;
|
2020-09-18 20:45:50 +00:00
|
|
|
buf->f_fsid = u64_to_fsid(id);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-02-08 12:20:36 +00:00
|
|
|
static unsigned int udf_count_free_bitmap(struct super_block *sb,
|
|
|
|
struct udf_bitmap *bitmap)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct buffer_head *bh = NULL;
|
|
|
|
unsigned int accum = 0;
|
|
|
|
int index;
|
2017-10-12 13:48:40 +00:00
|
|
|
udf_pblk_t block = 0, newblock;
|
2008-10-15 10:28:03 +00:00
|
|
|
struct kernel_lb_addr loc;
|
2005-04-16 22:20:36 +00:00
|
|
|
uint32_t bytes;
|
|
|
|
uint8_t *ptr;
|
|
|
|
uint16_t ident;
|
|
|
|
struct spaceBitmapDesc *bm;
|
|
|
|
|
|
|
|
loc.logicalBlockNum = bitmap->s_extPosition;
|
2008-02-08 12:20:30 +00:00
|
|
|
loc.partitionReferenceNum = UDF_SB(sb)->s_partition;
|
2008-10-15 10:29:03 +00:00
|
|
|
bh = udf_read_ptagged(sb, &loc, 0, &ident);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
if (!bh) {
|
2011-10-10 08:08:05 +00:00
|
|
|
udf_err(sb, "udf_count_free failed\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out;
|
2007-07-19 08:47:43 +00:00
|
|
|
} else if (ident != TAG_IDENT_SBD) {
|
2007-05-08 07:35:16 +00:00
|
|
|
brelse(bh);
|
2011-10-10 08:08:05 +00:00
|
|
|
udf_err(sb, "udf_count_free failed\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
bm = (struct spaceBitmapDesc *)bh->b_data;
|
|
|
|
bytes = le32_to_cpu(bm->numOfBytes);
|
2007-07-21 11:37:18 +00:00
|
|
|
index = sizeof(struct spaceBitmapDesc); /* offset in first block only */
|
|
|
|
ptr = (uint8_t *)bh->b_data;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
while (bytes > 0) {
|
2008-02-02 21:37:07 +00:00
|
|
|
u32 cur_bytes = min_t(u32, bytes, sb->s_blocksize - index);
|
|
|
|
accum += bitmap_weight((const unsigned long *)(ptr + index),
|
|
|
|
cur_bytes * 8);
|
|
|
|
bytes -= cur_bytes;
|
2007-07-19 08:47:43 +00:00
|
|
|
if (bytes) {
|
2007-05-08 07:35:16 +00:00
|
|
|
brelse(bh);
|
2008-10-15 10:29:03 +00:00
|
|
|
newblock = udf_get_lb_pblock(sb, &loc, ++block);
|
2023-01-18 12:27:07 +00:00
|
|
|
bh = sb_bread(sb, newblock);
|
2007-07-19 08:47:43 +00:00
|
|
|
if (!bh) {
|
2005-04-16 22:20:36 +00:00
|
|
|
udf_debug("read failed\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
index = 0;
|
2007-07-21 11:37:18 +00:00
|
|
|
ptr = (uint8_t *)bh->b_data;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
2007-05-08 07:35:16 +00:00
|
|
|
brelse(bh);
|
2007-07-21 11:37:18 +00:00
|
|
|
out:
|
2005-04-16 22:20:36 +00:00
|
|
|
return accum;
|
|
|
|
}
|
|
|
|
|
2008-02-08 12:20:36 +00:00
|
|
|
static unsigned int udf_count_free_table(struct super_block *sb,
|
|
|
|
struct inode *table)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
unsigned int accum = 0;
|
2007-05-08 07:35:14 +00:00
|
|
|
uint32_t elen;
|
2008-10-15 10:28:03 +00:00
|
|
|
struct kernel_lb_addr eloc;
|
2007-05-08 07:35:14 +00:00
|
|
|
struct extent_position epos;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-10-20 21:24:12 +00:00
|
|
|
mutex_lock(&UDF_SB(sb)->s_alloc_mutex);
|
2008-02-08 12:20:42 +00:00
|
|
|
epos.block = UDF_I(table)->i_location;
|
2007-05-08 07:35:14 +00:00
|
|
|
epos.offset = sizeof(struct unallocSpaceEntry);
|
|
|
|
epos.bh = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2022-03-07 15:21:49 +00:00
|
|
|
while (udf_next_aext(table, &epos, &eloc, &elen, 1) != -1)
|
2005-04-16 22:20:36 +00:00
|
|
|
accum += (elen >> table->i_sb->s_blocksize_bits);
|
2008-02-08 12:20:28 +00:00
|
|
|
|
2007-05-08 07:35:16 +00:00
|
|
|
brelse(epos.bh);
|
2010-10-20 21:24:12 +00:00
|
|
|
mutex_unlock(&UDF_SB(sb)->s_alloc_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return accum;
|
|
|
|
}
|
2007-07-19 08:47:43 +00:00
|
|
|
|
|
|
|
static unsigned int udf_count_free(struct super_block *sb)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
unsigned int accum = 0;
|
2020-01-07 15:36:49 +00:00
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
2008-02-08 12:20:30 +00:00
|
|
|
struct udf_part_map *map;
|
2020-01-07 15:36:49 +00:00
|
|
|
unsigned int part = sbi->s_partition;
|
|
|
|
int ptype = sbi->s_partmaps[part].s_partition_type;
|
|
|
|
|
|
|
|
if (ptype == UDF_METADATA_MAP25) {
|
|
|
|
part = sbi->s_partmaps[part].s_type_specific.s_metadata.
|
|
|
|
s_phys_partition_ref;
|
|
|
|
} else if (ptype == UDF_VIRTUAL_MAP15 || ptype == UDF_VIRTUAL_MAP20) {
|
|
|
|
/*
|
|
|
|
* Filesystems with VAT are append-only and we cannot write to
|
|
|
|
* them. Let's just report 0 here.
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
if (sbi->s_lvid_bh) {
|
2008-02-08 12:20:36 +00:00
|
|
|
struct logicalVolIntegrityDesc *lvid =
|
|
|
|
(struct logicalVolIntegrityDesc *)
|
|
|
|
sbi->s_lvid_bh->b_data;
|
2020-01-07 15:36:49 +00:00
|
|
|
if (le32_to_cpu(lvid->numOfPartitions) > part) {
|
2008-02-08 12:20:36 +00:00
|
|
|
accum = le32_to_cpu(
|
2020-01-07 15:36:49 +00:00
|
|
|
lvid->freeSpaceTable[part]);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (accum == 0xFFFFFFFF)
|
|
|
|
accum = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (accum)
|
|
|
|
return accum;
|
|
|
|
|
2020-01-07 15:36:49 +00:00
|
|
|
map = &sbi->s_partmaps[part];
|
2008-02-08 12:20:30 +00:00
|
|
|
if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) {
|
2007-07-21 11:37:18 +00:00
|
|
|
accum += udf_count_free_bitmap(sb,
|
2008-02-08 12:20:30 +00:00
|
|
|
map->s_uspace.s_bitmap);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
if (accum)
|
|
|
|
return accum;
|
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) {
|
2007-07-21 11:37:18 +00:00
|
|
|
accum += udf_count_free_table(sb,
|
2008-02-08 12:20:30 +00:00
|
|
|
map->s_uspace.s_table);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
return accum;
|
|
|
|
}
|
2017-01-06 20:53:57 +00:00
|
|
|
|
|
|
|
MODULE_AUTHOR("Ben Fennema");
|
|
|
|
MODULE_DESCRIPTION("Universal Disk Format Filesystem");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
module_init(init_udf_fs)
|
|
|
|
module_exit(exit_udf_fs)
|