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/
|
|
|
|
* http://www.ecma.ch/
|
|
|
|
* http://www.iso.org/
|
|
|
|
*
|
|
|
|
* 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/smp_lock.h>
|
|
|
|
#include <linux/buffer_head.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>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/byteorder.h>
|
|
|
|
|
|
|
|
#include "udf_sb.h"
|
|
|
|
#include "udf_i.h"
|
|
|
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
|
|
|
|
#define VDS_POS_PRIMARY_VOL_DESC 0
|
|
|
|
#define VDS_POS_UNALLOC_SPACE_DESC 1
|
|
|
|
#define VDS_POS_LOGICAL_VOL_DESC 2
|
|
|
|
#define VDS_POS_PARTITION_DESC 3
|
|
|
|
#define VDS_POS_IMP_USE_VOL_DESC 4
|
|
|
|
#define VDS_POS_VOL_DESC_PTR 5
|
|
|
|
#define VDS_POS_TERMINATING_DESC 6
|
|
|
|
#define VDS_POS_LENGTH 7
|
|
|
|
|
2008-02-08 12:21:50 +00:00
|
|
|
#define UDF_DEFAULT_BLOCKSIZE 2048
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static char error_buf[1024];
|
|
|
|
|
|
|
|
/* 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 *);
|
|
|
|
static void udf_write_super(struct super_block *);
|
|
|
|
static int udf_remount_fs(struct super_block *, int *, char *);
|
|
|
|
static int udf_check_valid(struct super_block *, int, int);
|
|
|
|
static int udf_vrs(struct super_block *sb, int silent);
|
|
|
|
static void udf_load_logicalvolint(struct super_block *, kernel_extent_ad);
|
|
|
|
static void udf_find_anchor(struct super_block *);
|
2007-07-19 08:47:43 +00:00
|
|
|
static int udf_find_fileset(struct super_block *, kernel_lb_addr *,
|
|
|
|
kernel_lb_addr *);
|
|
|
|
static void udf_load_fileset(struct super_block *, struct buffer_head *,
|
|
|
|
kernel_lb_addr *);
|
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 *);
|
2008-02-08 12:21:50 +00:00
|
|
|
static int udf_show_options(struct seq_file *, struct vfsmount *);
|
2008-02-17 08:19:55 +00:00
|
|
|
static void udf_error(struct super_block *sb, const char *function,
|
|
|
|
const char *fmt, ...);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu(struct udf_sb_info *sbi)
|
|
|
|
{
|
2008-02-08 12:20:36 +00:00
|
|
|
struct logicalVolIntegrityDesc *lvid =
|
|
|
|
(struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
|
2008-02-08 12:20:30 +00:00
|
|
|
__u32 number_of_partitions = le32_to_cpu(lvid->numOfPartitions);
|
2008-02-08 12:20:36 +00:00
|
|
|
__u32 offset = number_of_partitions * 2 *
|
|
|
|
sizeof(uint32_t)/sizeof(uint8_t);
|
2008-02-08 12:20:30 +00:00
|
|
|
return (struct logicalVolIntegrityDescImpUse *)&(lvid->impUse[offset]);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* UDF filesystem type */
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 09:02:57 +00:00
|
|
|
static int udf_get_sb(struct file_system_type *fs_type,
|
2007-07-19 08:47:43 +00:00
|
|
|
int flags, const char *dev_name, void *data,
|
|
|
|
struct vfsmount *mnt)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
[PATCH] VFS: Permit filesystem to override root dentry on mount
Extend the get_sb() filesystem operation to take an extra argument that
permits the VFS to pass in the target vfsmount that defines the mountpoint.
The filesystem is then required to manually set the superblock and root dentry
pointers. For most filesystems, this should be done with simple_set_mnt()
which will set the superblock pointer and then set the root dentry to the
superblock's s_root (as per the old default behaviour).
The get_sb() op now returns an integer as there's now no need to return the
superblock pointer.
This patch permits a superblock to be implicitly shared amongst several mount
points, such as can be done with NFS to avoid potential inode aliasing. In
such a case, simple_set_mnt() would not be called, and instead the mnt_root
and mnt_sb would be set directly.
The patch also makes the following changes:
(*) the get_sb_*() convenience functions in the core kernel now take a vfsmount
pointer argument and return an integer, so most filesystems have to change
very little.
(*) If one of the convenience function is not used, then get_sb() should
normally call simple_set_mnt() to instantiate the vfsmount. This will
always return 0, and so can be tail-called from get_sb().
(*) generic_shutdown_super() now calls shrink_dcache_sb() to clean up the
dcache upon superblock destruction rather than shrink_dcache_anon().
This is required because the superblock may now have multiple trees that
aren't actually bound to s_root, but that still need to be cleaned up. The
currently called functions assume that the whole tree is rooted at s_root,
and that anonymous dentries are not the roots of trees which results in
dentries being left unculled.
However, with the way NFS superblock sharing are currently set to be
implemented, these assumptions are violated: the root of the filesystem is
simply a dummy dentry and inode (the real inode for '/' may well be
inaccessible), and all the vfsmounts are rooted on anonymous[*] dentries
with child trees.
[*] Anonymous until discovered from another tree.
(*) The documentation has been adjusted, including the additional bit of
changing ext2_* into foo_* in the documentation.
[akpm@osdl.org: convert ipath_fs, do other stuff]
Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Al Viro <viro@zeniv.linux.org.uk>
Cc: Nathan Scott <nathans@sgi.com>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-23 09:02:57 +00:00
|
|
|
return get_sb_bdev(fs_type, flags, dev_name, data, udf_fill_super, mnt);
|
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",
|
|
|
|
.get_sb = udf_get_sb,
|
|
|
|
.kill_sb = kill_block_super,
|
|
|
|
.fs_flags = FS_REQUIRES_DEV,
|
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;
|
2008-02-08 12:20:28 +00:00
|
|
|
ei = kmem_cache_alloc(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;
|
|
|
|
ei->i_next_alloc_block = 0;
|
|
|
|
ei->i_next_alloc_goal = 0;
|
|
|
|
ei->i_strat4096 = 0;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return &ei->vfs_inode;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void udf_destroy_inode(struct inode *inode)
|
|
|
|
{
|
|
|
|
kmem_cache_free(udf_inode_cachep, UDF_I(inode));
|
|
|
|
}
|
|
|
|
|
2007-10-17 06:25:51 +00:00
|
|
|
static void init_once(struct kmem_cache *cachep, void *foo)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-07-19 08:47:43 +00:00
|
|
|
struct udf_inode_info *ei = (struct udf_inode_info *)foo;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-17 05:10:57 +00:00
|
|
|
ei->i_ext.i_data = NULL;
|
|
|
|
inode_init_once(&ei->vfs_inode);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int init_inodecache(void)
|
|
|
|
{
|
|
|
|
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 |
|
|
|
|
SLAB_MEM_SPREAD),
|
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)
|
|
|
|
{
|
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,
|
|
|
|
.destroy_inode = udf_destroy_inode,
|
|
|
|
.write_inode = udf_write_inode,
|
|
|
|
.delete_inode = udf_delete_inode,
|
|
|
|
.clear_inode = udf_clear_inode,
|
|
|
|
.put_super = udf_put_super,
|
|
|
|
.write_super = udf_write_super,
|
|
|
|
.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 volume;
|
|
|
|
unsigned short partition;
|
|
|
|
unsigned int fileset;
|
|
|
|
unsigned int rootdir;
|
|
|
|
unsigned int flags;
|
|
|
|
mode_t umask;
|
|
|
|
gid_t gid;
|
|
|
|
uid_t uid;
|
|
|
|
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();
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(init_udf_fs)
|
2007-07-21 11:37:18 +00:00
|
|
|
module_exit(exit_udf_fs)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
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);
|
|
|
|
|
|
|
|
sbi->s_partmaps = kcalloc(count, sizeof(struct udf_part_map),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!sbi->s_partmaps) {
|
|
|
|
udf_error(sb, __FUNCTION__,
|
|
|
|
"Unable to allocate space for %d partition maps",
|
|
|
|
count);
|
|
|
|
sbi->s_partitions = 0;
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
sbi->s_partitions = count;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-02-08 12:21:50 +00:00
|
|
|
static int udf_show_options(struct seq_file *seq, struct vfsmount *mnt)
|
|
|
|
{
|
|
|
|
struct super_block *sb = mnt->mnt_sb;
|
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
|
|
|
|
|
|
|
if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT))
|
|
|
|
seq_puts(seq, ",nostrict");
|
|
|
|
if (sb->s_blocksize != UDF_DEFAULT_BLOCKSIZE)
|
|
|
|
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_UID_IGNORE))
|
|
|
|
seq_puts(seq, ",uid=ignore");
|
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_FORGET))
|
|
|
|
seq_puts(seq, ",gid=forget");
|
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_IGNORE))
|
|
|
|
seq_puts(seq, ",gid=ignore");
|
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_UID_SET))
|
|
|
|
seq_printf(seq, ",uid=%u", sbi->s_uid);
|
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_SET))
|
|
|
|
seq_printf(seq, ",gid=%u", sbi->s_gid);
|
|
|
|
if (sbi->s_umask != 0)
|
|
|
|
seq_printf(seq, ",umask=%o", sbi->s_umask);
|
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_SESSION_SET))
|
|
|
|
seq_printf(seq, ",session=%u", sbi->s_session);
|
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_LASTBLOCK_SET))
|
|
|
|
seq_printf(seq, ",lastblock=%u", sbi->s_last_block);
|
|
|
|
/*
|
|
|
|
* s_anchor[2] could be zeroed out in case there is no anchor
|
|
|
|
* in the specified block, but then the "anchor=N" option
|
|
|
|
* originally given by the user wasn't effective, so it's OK
|
|
|
|
* if we don't show it.
|
|
|
|
*/
|
|
|
|
if (sbi->s_anchor[2] != 0)
|
|
|
|
seq_printf(seq, ",anchor=%u", sbi->s_anchor[2]);
|
|
|
|
/*
|
|
|
|
* volume, partition, fileset and rootdir seem to be ignored
|
|
|
|
* currently
|
|
|
|
*/
|
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8))
|
|
|
|
seq_puts(seq, ",utf8");
|
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP) && sbi->s_nls_map)
|
|
|
|
seq_printf(seq, ",iocharset=%s", sbi->s_nls_map->charset);
|
|
|
|
|
|
|
|
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.
|
|
|
|
* 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,
|
2006-03-08 05:55:24 +00:00
|
|
|
Opt_err, Opt_uforget, Opt_uignore, Opt_gforget, Opt_gignore
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static 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"},
|
|
|
|
{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;
|
|
|
|
|
|
|
|
uopt->novrs = 0;
|
2008-02-08 12:21:50 +00:00
|
|
|
uopt->blocksize = UDF_DEFAULT_BLOCKSIZE;
|
2005-04-16 22:20:36 +00:00
|
|
|
uopt->partition = 0xFFFF;
|
|
|
|
uopt->session = 0xFFFFFFFF;
|
|
|
|
uopt->lastblock = 0;
|
|
|
|
uopt->anchor = 0;
|
|
|
|
uopt->volume = 0xFFFFFFFF;
|
|
|
|
uopt->rootdir = 0xFFFFFFFF;
|
|
|
|
uopt->fileset = 0xFFFFFFFF;
|
|
|
|
uopt->nls_map = NULL;
|
|
|
|
|
|
|
|
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;
|
|
|
|
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;
|
|
|
|
case Opt_bs:
|
|
|
|
if (match_int(&args[0], &option))
|
|
|
|
return 0;
|
|
|
|
uopt->blocksize = option;
|
|
|
|
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:
|
|
|
|
if (match_int(args, &option))
|
|
|
|
return 0;
|
|
|
|
uopt->gid = option;
|
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:
|
|
|
|
if (match_int(args, &option))
|
|
|
|
return 0;
|
|
|
|
uopt->uid = option;
|
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:
|
|
|
|
if (match_int(args, &option))
|
|
|
|
return 0;
|
|
|
|
uopt->volume = option;
|
|
|
|
break;
|
|
|
|
case Opt_partition:
|
|
|
|
if (match_int(args, &option))
|
|
|
|
return 0;
|
|
|
|
uopt->partition = option;
|
|
|
|
break;
|
|
|
|
case Opt_fileset:
|
|
|
|
if (match_int(args, &option))
|
|
|
|
return 0;
|
|
|
|
uopt->fileset = option;
|
|
|
|
break;
|
|
|
|
case Opt_rootdir:
|
|
|
|
if (match_int(args, &option))
|
|
|
|
return 0;
|
|
|
|
uopt->rootdir = option;
|
|
|
|
break;
|
|
|
|
case Opt_utf8:
|
|
|
|
uopt->flags |= (1 << UDF_FLAG_UTF8);
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef CONFIG_UDF_NLS
|
2007-07-19 08:47:43 +00:00
|
|
|
case Opt_iocharset:
|
|
|
|
uopt->nls_map = load_nls(args[0].from);
|
|
|
|
uopt->flags |= (1 << UDF_FLAG_NLS_MAP);
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
2007-07-19 08:47:43 +00:00
|
|
|
case Opt_uignore:
|
|
|
|
uopt->flags |= (1 << UDF_FLAG_UID_IGNORE);
|
|
|
|
break;
|
|
|
|
case Opt_uforget:
|
|
|
|
uopt->flags |= (1 << UDF_FLAG_UID_FORGET);
|
|
|
|
break;
|
|
|
|
case Opt_gignore:
|
|
|
|
uopt->flags |= (1 << UDF_FLAG_GID_IGNORE);
|
|
|
|
break;
|
|
|
|
case Opt_gforget:
|
|
|
|
uopt->flags |= (1 << UDF_FLAG_GID_FORGET);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printk(KERN_ERR "udf: bad mount option \"%s\" "
|
|
|
|
"or missing value\n", p);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-02-08 12:20:35 +00:00
|
|
|
static void udf_write_super(struct super_block *sb)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
lock_kernel();
|
2007-07-21 11:37:18 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!(sb->s_flags & MS_RDONLY))
|
|
|
|
udf_open_lvid(sb);
|
|
|
|
sb->s_dirt = 0;
|
2007-07-21 11:37:18 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
unlock_kernel();
|
|
|
|
}
|
|
|
|
|
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);
|
2005-04-16 22:20:36 +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;
|
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;
|
|
|
|
|
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;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
if (sbi->s_lvid_bh) {
|
|
|
|
int write_rev = le16_to_cpu(udf_sb_lvidiu(sbi)->minUDFWriteRev);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (write_rev > UDF_MAX_WRITE_VERSION)
|
|
|
|
*flags |= MS_RDONLY;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
|
|
|
|
return 0;
|
|
|
|
if (*flags & MS_RDONLY)
|
|
|
|
udf_close_lvid(sb);
|
|
|
|
else
|
|
|
|
udf_open_lvid(sb);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
static int udf_vrs(struct super_block *sb, int silent)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct volStructDesc *vsd = NULL;
|
|
|
|
int sector = 32768;
|
|
|
|
int sectorsize;
|
|
|
|
struct buffer_head *bh = NULL;
|
2007-07-19 08:47:43 +00:00
|
|
|
int iso9660 = 0;
|
|
|
|
int nsr02 = 0;
|
|
|
|
int nsr03 = 0;
|
2008-02-08 12:20:30 +00:00
|
|
|
struct udf_sb_info *sbi;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Block size must be a multiple of 512 */
|
|
|
|
if (sb->s_blocksize & 511)
|
|
|
|
return 0;
|
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;
|
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
sector += (sbi->s_session << sb->s_blocksize_bits);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
udf_debug("Starting at sector %u (%ld byte sectors)\n",
|
2007-07-19 08:47:43 +00:00
|
|
|
(sector >> sb->s_blocksize_bits), sb->s_blocksize);
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Process the sequence (if applicable) */
|
2007-07-19 08:47:43 +00:00
|
|
|
for (; !nsr02 && !nsr03; sector += sectorsize) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Read a block */
|
|
|
|
bh = udf_tread(sb, sector >> sb->s_blocksize_bits);
|
|
|
|
if (!bh)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Look for ISO descriptors */
|
|
|
|
vsd = (struct volStructDesc *)(bh->b_data +
|
2008-02-08 12:20:28 +00:00
|
|
|
(sector & (sb->s_blocksize - 1)));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
if (vsd->stdIdent[0] == 0) {
|
2007-05-08 07:35:16 +00:00
|
|
|
brelse(bh);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
2008-02-08 12:20:28 +00:00
|
|
|
} else if (!strncmp(vsd->stdIdent, VSD_STD_ID_CD001,
|
|
|
|
VSD_STD_ID_LEN)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
iso9660 = sector;
|
2007-07-19 08:47:43 +00:00
|
|
|
switch (vsd->structType) {
|
|
|
|
case 0:
|
|
|
|
udf_debug("ISO9660 Boot Record found\n");
|
|
|
|
break;
|
|
|
|
case 1:
|
2008-02-08 12:20:28 +00:00
|
|
|
udf_debug("ISO9660 Primary Volume Descriptor "
|
|
|
|
"found\n");
|
2007-07-19 08:47:43 +00:00
|
|
|
break;
|
|
|
|
case 2:
|
2008-02-08 12:20:28 +00:00
|
|
|
udf_debug("ISO9660 Supplementary Volume "
|
|
|
|
"Descriptor found\n");
|
2007-07-19 08:47:43 +00:00
|
|
|
break;
|
|
|
|
case 3:
|
2008-02-08 12:20:28 +00:00
|
|
|
udf_debug("ISO9660 Volume Partition Descriptor "
|
|
|
|
"found\n");
|
2007-07-19 08:47:43 +00:00
|
|
|
break;
|
|
|
|
case 255:
|
2008-02-08 12:20:28 +00:00
|
|
|
udf_debug("ISO9660 Volume Descriptor Set "
|
|
|
|
"Terminator found\n");
|
2007-07-19 08:47:43 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
udf_debug("ISO9660 VRS (%u) found\n",
|
|
|
|
vsd->structType);
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-02-08 12:20:28 +00:00
|
|
|
} else if (!strncmp(vsd->stdIdent, VSD_STD_ID_BEA01,
|
|
|
|
VSD_STD_ID_LEN))
|
|
|
|
; /* nothing */
|
|
|
|
else if (!strncmp(vsd->stdIdent, VSD_STD_ID_TEA01,
|
|
|
|
VSD_STD_ID_LEN)) {
|
2007-05-08 07:35:16 +00:00
|
|
|
brelse(bh);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
2008-02-08 12:20:28 +00:00
|
|
|
} else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR02,
|
|
|
|
VSD_STD_ID_LEN))
|
2005-04-16 22:20:36 +00:00
|
|
|
nsr02 = sector;
|
2008-02-08 12:20:28 +00:00
|
|
|
else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR03,
|
|
|
|
VSD_STD_ID_LEN))
|
2005-04-16 22:20:36 +00:00
|
|
|
nsr03 = sector;
|
2007-05-08 07:35:16 +00:00
|
|
|
brelse(bh);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (nsr03)
|
|
|
|
return nsr03;
|
|
|
|
else if (nsr02)
|
|
|
|
return nsr02;
|
2008-02-08 12:20:30 +00:00
|
|
|
else if (sector - (sbi->s_session << sb->s_blocksize_bits) == 32768)
|
2005-04-16 22:20:36 +00:00
|
|
|
return -1;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-04-07 13:59:23 +00:00
|
|
|
* Check whether there is an anchor block in the given block
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-04-07 13:59:23 +00:00
|
|
|
static int udf_check_anchor_block(struct super_block *sb, sector_t block,
|
|
|
|
bool varconv)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct buffer_head *bh = NULL;
|
2008-04-07 13:59:23 +00:00
|
|
|
tag *t;
|
2005-04-16 22:20:36 +00:00
|
|
|
uint16_t ident;
|
|
|
|
uint32_t location;
|
2008-04-07 13:59:23 +00:00
|
|
|
|
|
|
|
if (varconv)
|
|
|
|
bh = sb_bread(sb, udf_fixed_to_variable(block));
|
|
|
|
else
|
|
|
|
bh = sb_bread(sb, block);
|
|
|
|
|
|
|
|
if (!bh)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
t = (tag *)bh->b_data;
|
|
|
|
ident = le16_to_cpu(t->tagIdent);
|
|
|
|
location = le32_to_cpu(t->tagLocation);
|
|
|
|
brelse(bh);
|
|
|
|
if (ident != TAG_IDENT_AVDP)
|
|
|
|
return 0;
|
|
|
|
return location == block;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Search for an anchor volume descriptor pointer */
|
|
|
|
static sector_t udf_scan_anchors(struct super_block *sb, bool varconv,
|
|
|
|
sector_t lastblock)
|
|
|
|
{
|
2008-04-07 14:15:04 +00:00
|
|
|
sector_t last[6];
|
2005-04-16 22:20:36 +00:00
|
|
|
int i;
|
2008-04-07 13:59:23 +00:00
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
2008-02-08 12:20:30 +00:00
|
|
|
|
2008-04-07 13:59:23 +00:00
|
|
|
last[0] = lastblock;
|
2008-04-07 14:15:04 +00:00
|
|
|
last[1] = last[0] - 1;
|
|
|
|
last[2] = last[0] + 1;
|
|
|
|
last[3] = last[0] - 2;
|
|
|
|
last[4] = last[0] - 150;
|
|
|
|
last[5] = last[0] - 152;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-07 13:59:23 +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 */
|
2006-03-24 11:15:34 +00:00
|
|
|
|
2008-04-07 13:59:23 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(last); i++) {
|
|
|
|
if (last[i] < 0)
|
|
|
|
continue;
|
2008-04-07 14:15:04 +00:00
|
|
|
if (last[i] >= sb->s_bdev->bd_inode->i_size >>
|
|
|
|
sb->s_blocksize_bits)
|
|
|
|
continue;
|
2007-07-19 08:47:43 +00:00
|
|
|
|
2008-04-07 13:59:23 +00:00
|
|
|
if (udf_check_anchor_block(sb, last[i], varconv)) {
|
|
|
|
sbi->s_anchor[0] = last[i];
|
|
|
|
sbi->s_anchor[1] = last[i] - 256;
|
|
|
|
return last[i];
|
|
|
|
}
|
2007-07-19 08:47:43 +00:00
|
|
|
|
2008-04-07 13:59:23 +00:00
|
|
|
if (last[i] < 256)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (udf_check_anchor_block(sb, last[i] - 256, varconv)) {
|
|
|
|
sbi->s_anchor[1] = last[i] - 256;
|
|
|
|
return last[i];
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-07 13:59:23 +00:00
|
|
|
if (udf_check_anchor_block(sb, sbi->s_session + 256, varconv)) {
|
|
|
|
sbi->s_anchor[0] = sbi->s_session + 256;
|
|
|
|
return last[0];
|
|
|
|
}
|
|
|
|
if (udf_check_anchor_block(sb, sbi->s_session + 512, varconv)) {
|
|
|
|
sbi->s_anchor[0] = sbi->s_session + 512;
|
|
|
|
return last[0];
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-07 13:59:23 +00:00
|
|
|
/*
|
|
|
|
* Find an anchor volume descriptor. The function expects sbi->s_lastblock to
|
|
|
|
* be the last block on the media.
|
|
|
|
*
|
|
|
|
* Return 1 if not found, 0 if ok
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static void udf_find_anchor(struct super_block *sb)
|
|
|
|
{
|
|
|
|
sector_t lastblock;
|
|
|
|
struct buffer_head *bh = NULL;
|
|
|
|
uint16_t ident;
|
|
|
|
int i;
|
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
|
|
|
|
|
|
|
lastblock = udf_scan_anchors(sb, 0, sbi->s_last_block);
|
|
|
|
if (lastblock)
|
|
|
|
goto check_anchor;
|
|
|
|
|
|
|
|
/* No anchor found? Try VARCONV conversion of block numbers */
|
|
|
|
/* Firstly, we try to not convert number of the last block */
|
|
|
|
lastblock = udf_scan_anchors(sb, 1,
|
|
|
|
udf_variable_to_fixed(sbi->s_last_block));
|
|
|
|
if (lastblock) {
|
|
|
|
UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
|
|
|
|
goto check_anchor;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-04-07 13:59:23 +00:00
|
|
|
/* Secondly, we try with converted number of the last block */
|
|
|
|
lastblock = udf_scan_anchors(sb, 1, sbi->s_last_block);
|
|
|
|
if (lastblock)
|
|
|
|
UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
|
|
|
|
|
|
|
|
check_anchor:
|
|
|
|
/*
|
|
|
|
* Check located anchors and the anchor block supplied via
|
|
|
|
* mount options
|
|
|
|
*/
|
2008-02-08 12:20:30 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(sbi->s_anchor); i++) {
|
2008-02-10 10:33:08 +00:00
|
|
|
if (!sbi->s_anchor[i])
|
|
|
|
continue;
|
|
|
|
bh = udf_read_tagged(sb, sbi->s_anchor[i],
|
|
|
|
sbi->s_anchor[i], &ident);
|
|
|
|
if (!bh)
|
|
|
|
sbi->s_anchor[i] = 0;
|
|
|
|
else {
|
|
|
|
brelse(bh);
|
2008-04-07 13:59:23 +00:00
|
|
|
if (ident != TAG_IDENT_AVDP)
|
2008-02-08 12:20:30 +00:00
|
|
|
sbi->s_anchor[i] = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
sbi->s_last_block = lastblock;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-02-08 12:20:28 +00:00
|
|
|
static int udf_find_fileset(struct super_block *sb,
|
|
|
|
kernel_lb_addr *fileset,
|
|
|
|
kernel_lb_addr *root)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct buffer_head *bh = NULL;
|
|
|
|
long lastblock;
|
|
|
|
uint16_t ident;
|
2008-02-08 12:20:30 +00:00
|
|
|
struct udf_sb_info *sbi;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (fileset->logicalBlockNum != 0xFFFFFFFF ||
|
2007-07-19 08:47:43 +00:00
|
|
|
fileset->partitionReferenceNum != 0xFFFF) {
|
2005-04-16 22:20:36 +00:00
|
|
|
bh = udf_read_ptagged(sb, *fileset, 0, &ident);
|
|
|
|
|
2007-07-21 11:37:18 +00:00
|
|
|
if (!bh) {
|
2005-04-16 22:20:36 +00:00
|
|
|
return 1;
|
2007-07-21 11:37:18 +00:00
|
|
|
} else if (ident != TAG_IDENT_FSD) {
|
2007-05-08 07:35:16 +00:00
|
|
|
brelse(bh);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 1;
|
|
|
|
}
|
2007-07-19 08:47:43 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
sbi = UDF_SB(sb);
|
2008-02-08 12:20:28 +00:00
|
|
|
if (!bh) {
|
|
|
|
/* Search backwards through the partitions */
|
2005-04-16 22:20:36 +00:00
|
|
|
kernel_lb_addr newfileset;
|
|
|
|
|
2007-07-21 11:37:18 +00:00
|
|
|
/* --> cvg: FIXME - is it reasonable? */
|
2005-04-16 22:20:36 +00:00
|
|
|
return 1;
|
2007-07-19 08:47:43 +00:00
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
for (newfileset.partitionReferenceNum = sbi->s_partitions - 1;
|
2007-07-19 08:47:43 +00:00
|
|
|
(newfileset.partitionReferenceNum != 0xFFFF &&
|
|
|
|
fileset->logicalBlockNum == 0xFFFFFFFF &&
|
|
|
|
fileset->partitionReferenceNum == 0xFFFF);
|
|
|
|
newfileset.partitionReferenceNum--) {
|
2008-02-08 12:20:30 +00:00
|
|
|
lastblock = sbi->s_partmaps
|
|
|
|
[newfileset.partitionReferenceNum]
|
|
|
|
.s_partition_len;
|
2005-04-16 22:20:36 +00:00
|
|
|
newfileset.logicalBlockNum = 0;
|
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
do {
|
2008-02-08 12:20:28 +00:00
|
|
|
bh = udf_read_ptagged(sb, newfileset, 0,
|
|
|
|
&ident);
|
2007-07-19 08:47:43 +00:00
|
|
|
if (!bh) {
|
|
|
|
newfileset.logicalBlockNum++;
|
2005-04-16 22:20:36 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
switch (ident) {
|
|
|
|
case TAG_IDENT_SBD:
|
2007-07-21 11:37:18 +00:00
|
|
|
{
|
|
|
|
struct spaceBitmapDesc *sp;
|
2008-02-08 12:20:36 +00:00
|
|
|
sp = (struct spaceBitmapDesc *)
|
|
|
|
bh->b_data;
|
2007-07-21 11:37:18 +00:00
|
|
|
newfileset.logicalBlockNum += 1 +
|
|
|
|
((le32_to_cpu(sp->numOfBytes) +
|
2008-02-08 12:20:36 +00:00
|
|
|
sizeof(struct spaceBitmapDesc)
|
|
|
|
- 1) >> sb->s_blocksize_bits);
|
2007-07-21 11:37:18 +00:00
|
|
|
brelse(bh);
|
|
|
|
break;
|
|
|
|
}
|
2007-07-19 08:47:43 +00:00
|
|
|
case TAG_IDENT_FSD:
|
2007-07-21 11:37:18 +00:00
|
|
|
*fileset = newfileset;
|
|
|
|
break;
|
2007-07-19 08:47:43 +00:00
|
|
|
default:
|
2007-07-21 11:37:18 +00:00
|
|
|
newfileset.logicalBlockNum++;
|
|
|
|
brelse(bh);
|
|
|
|
bh = NULL;
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2007-07-21 11:37:18 +00:00
|
|
|
} while (newfileset.logicalBlockNum < lastblock &&
|
|
|
|
fileset->logicalBlockNum == 0xFFFFFFFF &&
|
|
|
|
fileset->partitionReferenceNum == 0xFFFF);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((fileset->logicalBlockNum != 0xFFFFFFFF ||
|
2007-07-19 08:47:43 +00:00
|
|
|
fileset->partitionReferenceNum != 0xFFFF) && bh) {
|
2005-04-16 22:20:36 +00:00
|
|
|
udf_debug("Fileset at block=%d, partition=%d\n",
|
2007-07-19 08:47:43 +00:00
|
|
|
fileset->logicalBlockNum,
|
|
|
|
fileset->partitionReferenceNum);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
sbi->s_partition = fileset->partitionReferenceNum;
|
2005-04-16 22:20:36 +00:00
|
|
|
udf_load_fileset(sb, bh, root);
|
2007-05-08 07:35:16 +00:00
|
|
|
brelse(bh);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
struct ustr instr;
|
|
|
|
struct ustr outstr;
|
2008-04-01 14:50:35 +00:00
|
|
|
struct buffer_head *bh;
|
|
|
|
uint16_t ident;
|
|
|
|
|
|
|
|
bh = udf_read_tagged(sb, block, block, &ident);
|
|
|
|
if (!bh)
|
|
|
|
return 1;
|
|
|
|
BUG_ON(ident != TAG_IDENT_PVD);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
pvoldesc = (struct primaryVolDesc *)bh->b_data;
|
|
|
|
|
2008-02-10 10:25:31 +00:00
|
|
|
if (udf_disk_stamp_to_time(&UDF_SB(sb)->s_record_time,
|
|
|
|
pvoldesc->recordingDateAndTime)) {
|
2008-02-10 10:29:10 +00:00
|
|
|
#ifdef UDFFS_DEBUG
|
|
|
|
timestamp *ts = &pvoldesc->recordingDateAndTime;
|
2008-02-27 21:50:14 +00:00
|
|
|
udf_debug("recording time %04u/%02u/%02u"
|
2008-02-08 12:20:28 +00:00
|
|
|
" %02u:%02u (%x)\n",
|
2008-02-10 10:29:10 +00:00
|
|
|
le16_to_cpu(ts->year), ts->month, ts->day, ts->hour,
|
|
|
|
ts->minute, le16_to_cpu(ts->typeAndTimezone));
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-02-08 12:20:36 +00:00
|
|
|
if (!udf_build_ustr(&instr, pvoldesc->volIdent, 32))
|
2007-07-19 08:47:43 +00:00
|
|
|
if (udf_CS0toUTF8(&outstr, &instr)) {
|
2008-02-08 12:20:30 +00:00
|
|
|
strncpy(UDF_SB(sb)->s_volume_ident, outstr.u_name,
|
2005-04-16 22:20:36 +00:00
|
|
|
outstr.u_len > 31 ? 31 : outstr.u_len);
|
2008-02-08 12:20:36 +00:00
|
|
|
udf_debug("volIdent[] = '%s'\n",
|
|
|
|
UDF_SB(sb)->s_volume_ident);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-02-08 12:20:36 +00:00
|
|
|
if (!udf_build_ustr(&instr, pvoldesc->volSetIdent, 128))
|
2005-04-16 22:20:36 +00:00
|
|
|
if (udf_CS0toUTF8(&outstr, &instr))
|
|
|
|
udf_debug("volSetIdent[] = '%s'\n", outstr.u_name);
|
2008-04-01 14:50:35 +00:00
|
|
|
|
|
|
|
brelse(bh);
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-07-21 11:37:18 +00:00
|
|
|
static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh,
|
|
|
|
kernel_lb_addr *root)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct fileSetDesc *fset;
|
|
|
|
|
|
|
|
fset = (struct fileSetDesc *)bh->b_data;
|
|
|
|
|
|
|
|
*root = lelb_to_cpu(fset->rootDirectoryICB.extLocation);
|
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
UDF_SB(sb)->s_serial_number = le16_to_cpu(fset->descTag.tagSerialNum);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
udf_debug("Rootdir at block=%d, partition=%d\n",
|
|
|
|
root->logicalBlockNum, root->partitionReferenceNum);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
int nr_groups;
|
|
|
|
int size;
|
|
|
|
|
2008-02-08 12:20:34 +00:00
|
|
|
nr_groups = udf_compute_nr_groups(sb, index);
|
2008-02-08 12:20:33 +00:00
|
|
|
size = sizeof(struct udf_bitmap) +
|
|
|
|
(sizeof(struct buffer_head *) * nr_groups);
|
|
|
|
|
|
|
|
if (size <= PAGE_SIZE)
|
|
|
|
bitmap = kmalloc(size, GFP_KERNEL);
|
|
|
|
else
|
|
|
|
bitmap = vmalloc(size); /* TODO: get rid of vmalloc */
|
|
|
|
|
|
|
|
if (bitmap == NULL) {
|
|
|
|
udf_error(sb, __FUNCTION__,
|
|
|
|
"Unable to allocate space for bitmap "
|
|
|
|
"and %d buffer_head pointers", nr_groups);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(bitmap, 0x00, size);
|
|
|
|
bitmap->s_block_bitmap = (struct buffer_head **)(bitmap + 1);
|
|
|
|
bitmap->s_nr_groups = nr_groups;
|
|
|
|
return bitmap;
|
|
|
|
}
|
|
|
|
|
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;
|
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;
|
|
|
|
|
|
|
|
udf_debug("Partition (%d:%d type %x) starts at physical %d, "
|
2008-04-02 10:26:36 +00:00
|
|
|
"block length %d\n", partitionNumber, p_index,
|
2008-02-10 10:33:08 +00:00
|
|
|
map->s_partition_type, map->s_partition_root,
|
|
|
|
map->s_partition_len);
|
|
|
|
|
|
|
|
if (strcmp(p->partitionContents.ident, PD_PARTITION_CONTENTS_NSR02) &&
|
|
|
|
strcmp(p->partitionContents.ident, PD_PARTITION_CONTENTS_NSR03))
|
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) {
|
|
|
|
kernel_lb_addr loc = {
|
|
|
|
.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
|
|
|
};
|
|
|
|
|
|
|
|
map->s_uspace.s_table = udf_iget(sb, loc);
|
|
|
|
if (!map->s_uspace.s_table) {
|
|
|
|
udf_debug("cannot load unallocSpaceTable (part %d)\n",
|
2008-04-02 10:26:36 +00:00
|
|
|
p_index);
|
|
|
|
return 1;
|
2008-02-10 10:33:08 +00:00
|
|
|
}
|
|
|
|
map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_TABLE;
|
|
|
|
udf_debug("unallocSpaceTable (part %d) @ %ld\n",
|
2008-04-02 10:26:36 +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)
|
|
|
|
return 1;
|
2008-02-10 10:33:08 +00:00
|
|
|
map->s_uspace.s_bitmap = bitmap;
|
2008-04-01 16:08:51 +00:00
|
|
|
bitmap->s_extLength = le32_to_cpu(
|
2008-02-10 10:33:08 +00:00
|
|
|
phd->unallocSpaceBitmap.extLength);
|
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;
|
2008-04-02 10:26:36 +00:00
|
|
|
udf_debug("unallocSpaceBitmap (part %d) @ %d\n", p_index,
|
2008-04-01 16:08:51 +00:00
|
|
|
bitmap->s_extPosition);
|
2008-02-10 10:33:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (phd->partitionIntegrityTable.extLength)
|
2008-04-02 10:26:36 +00:00
|
|
|
udf_debug("partitionIntegrityTable (part %d)\n", p_index);
|
2008-02-10 10:33:08 +00:00
|
|
|
|
|
|
|
if (phd->freedSpaceTable.extLength) {
|
|
|
|
kernel_lb_addr loc = {
|
|
|
|
.logicalBlockNum = le32_to_cpu(
|
|
|
|
phd->freedSpaceTable.extPosition),
|
2008-04-02 10:26:36 +00:00
|
|
|
.partitionReferenceNum = p_index,
|
2008-02-10 10:33:08 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
map->s_fspace.s_table = udf_iget(sb, loc);
|
|
|
|
if (!map->s_fspace.s_table) {
|
2008-04-02 10:26:36 +00:00
|
|
|
udf_debug("cannot load freedSpaceTable (part %d)\n",
|
|
|
|
p_index);
|
|
|
|
return 1;
|
2008-02-10 10:33:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
map->s_partition_flags |= UDF_PART_FLAG_FREED_TABLE;
|
|
|
|
udf_debug("freedSpaceTable (part %d) @ %ld\n",
|
2008-04-02 10:26:36 +00:00
|
|
|
p_index, map->s_fspace.s_table->i_ino);
|
2008-02-10 10:33:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (phd->freedSpaceBitmap.extLength) {
|
2008-04-02 10:26:36 +00:00
|
|
|
struct udf_bitmap *bitmap = udf_sb_alloc_bitmap(sb, p_index);
|
|
|
|
if (!bitmap)
|
|
|
|
return 1;
|
2008-02-10 10:33:08 +00:00
|
|
|
map->s_fspace.s_bitmap = bitmap;
|
2008-04-01 16:08:51 +00:00
|
|
|
bitmap->s_extLength = le32_to_cpu(
|
2008-02-10 10:33:08 +00:00
|
|
|
phd->freedSpaceBitmap.extLength);
|
2008-04-01 16:08:51 +00:00
|
|
|
bitmap->s_extPosition = le32_to_cpu(
|
2008-02-10 10:33:08 +00:00
|
|
|
phd->freedSpaceBitmap.extPosition);
|
2008-04-01 16:08:51 +00:00
|
|
|
map->s_partition_flags |= UDF_PART_FLAG_FREED_BITMAP;
|
2008-04-02 10:26:36 +00:00
|
|
|
udf_debug("freedSpaceBitmap (part %d) @ %d\n", p_index,
|
2008-04-01 16:08:51 +00:00
|
|
|
bitmap->s_extPosition);
|
2008-02-10 10:33:08 +00:00
|
|
|
}
|
2008-04-02 10:26:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-02 14:01:35 +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];
|
|
|
|
kernel_lb_addr ino;
|
|
|
|
struct buffer_head *bh;
|
|
|
|
|
|
|
|
/* VAT file entry is in the last recorded block */
|
|
|
|
ino.partitionReferenceNum = type1_index;
|
|
|
|
ino.logicalBlockNum = sbi->s_last_block - map->s_partition_root;
|
|
|
|
sbi->s_vat_inode = udf_iget(sb, ino);
|
|
|
|
if (!sbi->s_vat_inode)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (map->s_partition_type == UDF_VIRTUAL_MAP15) {
|
|
|
|
map->s_type_specific.s_virtual.s_start_offset =
|
|
|
|
udf_ext0_offset(sbi->s_vat_inode);
|
|
|
|
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) {
|
|
|
|
uint32_t pos;
|
|
|
|
struct virtualAllocationTable20 *vat20;
|
|
|
|
|
|
|
|
pos = udf_block_map(sbi->s_vat_inode, 0);
|
|
|
|
bh = sb_bread(sb, pos);
|
|
|
|
if (!bh)
|
|
|
|
return 1;
|
|
|
|
vat20 = (struct virtualAllocationTable20 *)bh->b_data +
|
|
|
|
udf_ext0_offset(sbi->s_vat_inode);
|
|
|
|
map->s_type_specific.s_virtual.s_start_offset =
|
|
|
|
le16_to_cpu(vat20->lengthHeader) +
|
|
|
|
udf_ext0_offset(sbi->s_vat_inode);
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
bh = udf_read_tagged(sb, block, block, &ident);
|
|
|
|
if (!bh)
|
|
|
|
return 1;
|
|
|
|
if (ident != TAG_IDENT_PD)
|
|
|
|
goto out_bh;
|
|
|
|
|
|
|
|
p = (struct partitionDesc *)bh->b_data;
|
|
|
|
partitionNumber = le16_to_cpu(p->partitionNumber);
|
2008-04-02 14:01:35 +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];
|
|
|
|
udf_debug("Searching map: (%d == %d)\n",
|
|
|
|
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) {
|
2008-04-02 10:26:36 +00:00
|
|
|
udf_debug("Partition (%d) not found in partition map\n",
|
|
|
|
partitionNumber);
|
|
|
|
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);
|
2008-04-02 14:01:35 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Now rescan for VIRTUAL partitions when TYPE1 partitions are
|
|
|
|
* already set up
|
|
|
|
*/
|
|
|
|
type1_idx = i;
|
|
|
|
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 ||
|
|
|
|
map->s_partition_type == UDF_VIRTUAL_MAP20))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i >= sbi->s_partitions)
|
|
|
|
goto out_bh;
|
|
|
|
|
|
|
|
ret = udf_fill_partdesc_info(sb, p, i);
|
|
|
|
if (ret)
|
|
|
|
goto out_bh;
|
|
|
|
|
|
|
|
ret = udf_load_vat(sb, i, type1_idx);
|
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
|
|
|
}
|
|
|
|
|
2008-04-01 14:50:35 +00:00
|
|
|
static int udf_load_logicalvol(struct super_block *sb, sector_t block,
|
2007-07-21 11:37:18 +00:00
|
|
|
kernel_lb_addr *fileset)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct logicalVolDesc *lvd;
|
|
|
|
int i, j, offset;
|
|
|
|
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;
|
|
|
|
int ret = 0;
|
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)
|
|
|
|
return 1;
|
|
|
|
BUG_ON(ident != TAG_IDENT_LVD);
|
2005-04-16 22:20:36 +00:00
|
|
|
lvd = (struct logicalVolDesc *)bh->b_data;
|
|
|
|
|
2008-02-08 12:20:32 +00:00
|
|
|
i = udf_sb_alloc_partition_maps(sb, le32_to_cpu(lvd->numPartitionMaps));
|
2008-04-01 14:50:35 +00:00
|
|
|
if (i != 0) {
|
|
|
|
ret = i;
|
|
|
|
goto out_bh;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
for (i = 0, offset = 0;
|
2008-02-08 12:20:30 +00:00
|
|
|
i < sbi->s_partitions && offset < le32_to_cpu(lvd->mapTableLength);
|
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]);
|
|
|
|
if (suf == 0x0150) {
|
|
|
|
map->s_partition_type =
|
|
|
|
UDF_VIRTUAL_MAP15;
|
|
|
|
map->s_partition_func =
|
|
|
|
udf_get_pblock_virt15;
|
|
|
|
} else if (suf == 0x0200) {
|
|
|
|
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))) {
|
2005-04-16 22:20:36 +00:00
|
|
|
uint32_t loc;
|
|
|
|
struct sparingTable *st;
|
2008-02-08 12:20:36 +00:00
|
|
|
struct sparablePartitionMap *spm =
|
|
|
|
(struct sparablePartitionMap *)gpm;
|
2007-07-21 11:37:18 +00:00
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
map->s_partition_type = UDF_SPARABLE_MAP15;
|
2008-02-08 12:20:36 +00:00
|
|
|
map->s_type_specific.s_sparing.s_packet_len =
|
|
|
|
le16_to_cpu(spm->packetLength);
|
2007-07-19 08:47:43 +00:00
|
|
|
for (j = 0; j < spm->numSparingTables; j++) {
|
2008-02-08 12:20:36 +00:00
|
|
|
struct buffer_head *bh2;
|
|
|
|
|
|
|
|
loc = le32_to_cpu(
|
|
|
|
spm->locSparingTable[j]);
|
|
|
|
bh2 = udf_read_tagged(sb, loc, loc,
|
|
|
|
&ident);
|
|
|
|
map->s_type_specific.s_sparing.
|
|
|
|
s_spar_map[j] = bh2;
|
|
|
|
|
2008-02-10 10:33:08 +00:00
|
|
|
if (bh2 == NULL)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
st = (struct sparingTable *)bh2->b_data;
|
|
|
|
if (ident != 0 || strncmp(
|
|
|
|
st->sparingIdent.ident,
|
|
|
|
UDF_ID_SPARING,
|
|
|
|
strlen(UDF_ID_SPARING))) {
|
|
|
|
brelse(bh2);
|
|
|
|
map->s_type_specific.s_sparing.
|
|
|
|
s_spar_map[j] = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
2008-02-08 12:20:30 +00:00
|
|
|
map->s_partition_func = udf_get_pblock_spar15;
|
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
|
|
|
}
|
|
|
|
udf_debug("Partition (%d:%d) type %d on volume %d\n",
|
2008-02-08 12:20:30 +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) {
|
2007-07-21 11:37:18 +00:00
|
|
|
long_ad *la = (long_ad *)&(lvd->logicalVolContentsUse[0]);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
*fileset = lelb_to_cpu(la->extLocation);
|
2008-02-08 12:20:28 +00:00
|
|
|
udf_debug("FileSet found in LogicalVolDesc at block=%d, "
|
|
|
|
"partition=%d\n", 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));
|
2007-07-21 11:37:18 +00:00
|
|
|
|
2008-04-01 14:50:35 +00:00
|
|
|
out_bh:
|
|
|
|
brelse(bh);
|
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* udf_load_logicalvolint
|
|
|
|
*
|
|
|
|
*/
|
2007-07-19 08:47:43 +00:00
|
|
|
static void udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct buffer_head *bh = NULL;
|
|
|
|
uint16_t ident;
|
2008-02-08 12:20:30 +00:00
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
|
|
|
struct logicalVolIntegrityDesc *lvid;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
while (loc.extLength > 0 &&
|
2007-07-19 08:47:43 +00:00
|
|
|
(bh = udf_read_tagged(sb, loc.extLocation,
|
|
|
|
loc.extLocation, &ident)) &&
|
|
|
|
ident == TAG_IDENT_LVID) {
|
2008-02-08 12:20:30 +00:00
|
|
|
sbi->s_lvid_bh = bh;
|
|
|
|
lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
|
2007-07-19 08:47:43 +00:00
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
if (lvid->nextIntegrityExt.extLength)
|
2008-02-08 12:20:28 +00:00
|
|
|
udf_load_logicalvolint(sb,
|
2008-02-08 12:20:30 +00:00
|
|
|
leea_to_cpu(lvid->nextIntegrityExt));
|
2007-07-19 08:47:43 +00:00
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
if (sbi->s_lvid_bh != bh)
|
2007-05-08 07:35:16 +00:00
|
|
|
brelse(bh);
|
2005-04-16 22:20:36 +00:00
|
|
|
loc.extLength -= sb->s_blocksize;
|
2007-07-19 08:47:43 +00:00
|
|
|
loc.extLocation++;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-02-08 12:20:30 +00:00
|
|
|
if (sbi->s_lvid_bh != bh)
|
2007-05-08 07:35:16 +00:00
|
|
|
brelse(bh);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* udf_process_sequence
|
|
|
|
*
|
|
|
|
* PURPOSE
|
|
|
|
* Process a main/reserve volume descriptor sequence.
|
|
|
|
*
|
|
|
|
* PRE-CONDITIONS
|
|
|
|
* sb Pointer to _locked_ superblock.
|
|
|
|
* block First block of first extent of the sequence.
|
|
|
|
* lastblock Lastblock of first extent of the sequence.
|
|
|
|
*
|
|
|
|
* HISTORY
|
|
|
|
* July 1, 1997 - Andrew E. Mileski
|
|
|
|
* Written, tested, and released.
|
|
|
|
*/
|
2008-03-04 12:03:09 +00:00
|
|
|
static noinline int udf_process_sequence(struct super_block *sb, long block,
|
2008-02-08 12:20:28 +00:00
|
|
|
long lastblock, kernel_lb_addr *fileset)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct buffer_head *bh = NULL;
|
|
|
|
struct udf_vds_record vds[VDS_POS_LENGTH];
|
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;
|
2007-07-19 08:47:43 +00:00
|
|
|
int done = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
uint32_t vdsn;
|
|
|
|
uint16_t ident;
|
|
|
|
long next_s = 0, next_e = 0;
|
|
|
|
|
|
|
|
memset(vds, 0, sizeof(struct udf_vds_record) * VDS_POS_LENGTH);
|
|
|
|
|
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);
|
2008-04-01 14:50:35 +00:00
|
|
|
if (!bh) {
|
|
|
|
printk(KERN_ERR "udf: Block %Lu of volume descriptor "
|
|
|
|
"sequence is corrupted or we could not read "
|
|
|
|
"it.\n", (unsigned long long)block);
|
|
|
|
return 1;
|
|
|
|
}
|
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_PVD: /* ISO 13346 3/10.1 */
|
2008-02-08 12:20:36 +00:00
|
|
|
curr = &vds[VDS_POS_PRIMARY_VOL_DESC];
|
|
|
|
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_VDP: /* ISO 13346 3/10.3 */
|
2008-02-08 12:20:36 +00:00
|
|
|
curr = &vds[VDS_POS_VOL_DESC_PTR];
|
|
|
|
if (vdsn >= curr->volDescSeqNum) {
|
|
|
|
curr->volDescSeqNum = vdsn;
|
|
|
|
curr->block = block;
|
2007-07-19 08:47:43 +00:00
|
|
|
|
|
|
|
vdp = (struct volDescPtr *)bh->b_data;
|
2008-02-08 12:20:36 +00:00
|
|
|
next_s = le32_to_cpu(
|
|
|
|
vdp->nextVolDescSeqExt.extLocation);
|
|
|
|
next_e = le32_to_cpu(
|
|
|
|
vdp->nextVolDescSeqExt.extLength);
|
2007-07-19 08:47:43 +00:00
|
|
|
next_e = next_e >> sb->s_blocksize_bits;
|
|
|
|
next_e += next_s;
|
|
|
|
}
|
|
|
|
break;
|
2007-07-21 11:37:18 +00:00
|
|
|
case TAG_IDENT_IUVD: /* ISO 13346 3/10.4 */
|
2008-02-08 12:20:36 +00:00
|
|
|
curr = &vds[VDS_POS_IMP_USE_VOL_DESC];
|
|
|
|
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_PD: /* ISO 13346 3/10.5 */
|
2008-02-08 12:20:36 +00:00
|
|
|
curr = &vds[VDS_POS_PARTITION_DESC];
|
|
|
|
if (!curr->block)
|
|
|
|
curr->block = block;
|
2007-07-19 08:47:43 +00:00
|
|
|
break;
|
2007-07-21 11:37:18 +00:00
|
|
|
case TAG_IDENT_LVD: /* ISO 13346 3/10.6 */
|
2008-02-08 12:20:36 +00:00
|
|
|
curr = &vds[VDS_POS_LOGICAL_VOL_DESC];
|
|
|
|
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_USD: /* ISO 13346 3/10.8 */
|
2008-02-08 12:20:36 +00:00
|
|
|
curr = &vds[VDS_POS_UNALLOC_SPACE_DESC];
|
|
|
|
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 */
|
2007-07-19 08:47:43 +00:00
|
|
|
vds[VDS_POS_TERMINATING_DESC].block = block;
|
|
|
|
if (next_e) {
|
|
|
|
block = next_s;
|
|
|
|
lastblock = next_e;
|
|
|
|
next_s = next_e = 0;
|
2008-02-08 12:20:36 +00:00
|
|
|
} else
|
2007-07-19 08:47:43 +00:00
|
|
|
done = 1;
|
|
|
|
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
|
|
|
|
*/
|
|
|
|
if (!vds[VDS_POS_PRIMARY_VOL_DESC].block) {
|
|
|
|
printk(KERN_ERR "udf: Primary Volume Descriptor not found!\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (udf_load_pvoldesc(sb, vds[VDS_POS_PRIMARY_VOL_DESC].block))
|
|
|
|
return 1;
|
2008-02-10 10:33:08 +00:00
|
|
|
|
2008-04-01 14:50:35 +00:00
|
|
|
if (vds[VDS_POS_LOGICAL_VOL_DESC].block && udf_load_logicalvol(sb,
|
|
|
|
vds[VDS_POS_LOGICAL_VOL_DESC].block, fileset))
|
|
|
|
return 1;
|
2008-02-10 10:33:08 +00:00
|
|
|
|
2008-04-01 14:50:35 +00:00
|
|
|
if (vds[VDS_POS_PARTITION_DESC].block) {
|
|
|
|
/*
|
|
|
|
* We rescan the whole descriptor sequence to find
|
|
|
|
* partition descriptor blocks and process them.
|
|
|
|
*/
|
|
|
|
for (block = vds[VDS_POS_PARTITION_DESC].block;
|
|
|
|
block < vds[VDS_POS_TERMINATING_DESC].block;
|
|
|
|
block++)
|
|
|
|
if (udf_load_partdesc(sb, block))
|
2008-02-10 10:33:08 +00:00
|
|
|
return 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* udf_check_valid()
|
|
|
|
*/
|
2007-07-19 08:47:43 +00:00
|
|
|
static int udf_check_valid(struct super_block *sb, int novrs, int silent)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
long block;
|
2008-03-04 23:03:36 +00:00
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
if (novrs) {
|
2005-04-16 22:20:36 +00:00
|
|
|
udf_debug("Validity check skipped because of novrs option\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/* Check that it is NSR02 compliant */
|
|
|
|
/* Process any "CD-ROM Volume Descriptor Set" (ECMA 167 2/8.3.1) */
|
2008-02-10 10:33:08 +00:00
|
|
|
block = udf_vrs(sb, silent);
|
2008-03-04 23:03:36 +00:00
|
|
|
if (block == -1)
|
|
|
|
udf_debug("Failed to read byte 32768. Assuming open "
|
|
|
|
"disc. Skipping validity check\n");
|
|
|
|
if (block && !sbi->s_last_block)
|
2008-02-10 10:33:08 +00:00
|
|
|
sbi->s_last_block = udf_get_last_block(sb);
|
2008-03-04 23:03:36 +00:00
|
|
|
return !block;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-04-02 14:01:35 +00:00
|
|
|
static int udf_load_sequence(struct super_block *sb, kernel_lb_addr *fileset)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct anchorVolDescPtr *anchor;
|
|
|
|
uint16_t ident;
|
|
|
|
struct buffer_head *bh;
|
|
|
|
long main_s, main_e, reserve_s, reserve_e;
|
2008-04-02 14:01:35 +00:00
|
|
|
int i;
|
2008-02-08 12:20:30 +00:00
|
|
|
struct udf_sb_info *sbi;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!sb)
|
|
|
|
return 1;
|
2008-02-08 12:20:30 +00:00
|
|
|
sbi = UDF_SB(sb);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(sbi->s_anchor); i++) {
|
2008-02-08 12:20:46 +00:00
|
|
|
if (!sbi->s_anchor[i])
|
|
|
|
continue;
|
2008-02-10 10:33:08 +00:00
|
|
|
|
2008-02-08 12:20:46 +00:00
|
|
|
bh = udf_read_tagged(sb, sbi->s_anchor[i], sbi->s_anchor[i],
|
|
|
|
&ident);
|
|
|
|
if (!bh)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
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;
|
|
|
|
main_e += main_s;
|
|
|
|
|
|
|
|
/* Locate the reserve sequence */
|
|
|
|
reserve_s = le32_to_cpu(
|
2008-02-08 12:20:36 +00:00
|
|
|
anchor->reserveVolDescSeqExt.extLocation);
|
2008-02-08 12:20:46 +00:00
|
|
|
reserve_e = le32_to_cpu(
|
2008-02-08 12:20:36 +00:00
|
|
|
anchor->reserveVolDescSeqExt.extLength);
|
2008-02-08 12:20:46 +00:00
|
|
|
reserve_e = reserve_e >> sb->s_blocksize_bits;
|
|
|
|
reserve_e += reserve_s;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-08 12:20:46 +00:00
|
|
|
brelse(bh);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-08 12:20:46 +00:00
|
|
|
/* Process the main & reserve sequences */
|
|
|
|
/* responsible for finding the PartitionDesc(s) */
|
|
|
|
if (!(udf_process_sequence(sb, main_s, main_e,
|
|
|
|
fileset) &&
|
|
|
|
udf_process_sequence(sb, reserve_s, reserve_e,
|
|
|
|
fileset)))
|
|
|
|
break;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
if (i == ARRAY_SIZE(sbi->s_anchor)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
udf_debug("No Anchor block found\n");
|
|
|
|
return 1;
|
2008-02-08 12:20:46 +00:00
|
|
|
}
|
|
|
|
udf_debug("Using anchor in block %d\n", sbi->s_anchor[i]);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
if (!bh)
|
|
|
|
return;
|
|
|
|
|
|
|
|
lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
|
|
|
|
lvidiu = udf_sb_lvidiu(sbi);
|
|
|
|
|
|
|
|
lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
|
|
|
|
lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
|
|
|
|
udf_time_to_disk_stamp(&lvid->recordingDateAndTime,
|
|
|
|
CURRENT_TIME);
|
|
|
|
lvid->integrityType = LVID_INTEGRITY_TYPE_OPEN;
|
|
|
|
|
|
|
|
lvid->descTag.descCRC = cpu_to_le16(
|
|
|
|
udf_crc((char *)lvid + sizeof(tag),
|
|
|
|
le16_to_cpu(lvid->descTag.descCRCLength), 0));
|
|
|
|
|
|
|
|
lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag);
|
|
|
|
mark_buffer_dirty(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;
|
|
|
|
|
|
|
|
lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
|
|
|
|
|
2008-02-10 10:33:08 +00:00
|
|
|
if (lvid->integrityType != LVID_INTEGRITY_TYPE_OPEN)
|
|
|
|
return;
|
|
|
|
|
|
|
|
lvidiu = udf_sb_lvidiu(sbi);
|
|
|
|
lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
|
|
|
|
lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
|
|
|
|
udf_time_to_disk_stamp(&lvid->recordingDateAndTime, CURRENT_TIME);
|
|
|
|
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);
|
|
|
|
lvid->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE);
|
|
|
|
|
|
|
|
lvid->descTag.descCRC = cpu_to_le16(
|
|
|
|
udf_crc((char *)lvid + sizeof(tag),
|
|
|
|
le16_to_cpu(lvid->descTag.descCRCLength),
|
|
|
|
0));
|
|
|
|
|
|
|
|
lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag);
|
|
|
|
mark_buffer_dirty(bh);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-02-08 12:20:33 +00:00
|
|
|
static void udf_sb_free_bitmap(struct udf_bitmap *bitmap)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int nr_groups = bitmap->s_nr_groups;
|
2008-02-08 12:20:36 +00:00
|
|
|
int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) *
|
|
|
|
nr_groups);
|
2008-02-08 12:20:33 +00:00
|
|
|
|
|
|
|
for (i = 0; i < nr_groups; i++)
|
|
|
|
if (bitmap->s_block_bitmap[i])
|
|
|
|
brelse(bitmap->s_block_bitmap[i]);
|
|
|
|
|
|
|
|
if (size <= PAGE_SIZE)
|
|
|
|
kfree(bitmap);
|
|
|
|
else
|
|
|
|
vfree(bitmap);
|
|
|
|
}
|
|
|
|
|
2008-04-01 16:08:51 +00:00
|
|
|
static void udf_free_partition(struct udf_part_map *map)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
|
|
|
|
iput(map->s_uspace.s_table);
|
|
|
|
if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
|
|
|
|
iput(map->s_fspace.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_flags & UDF_PART_FLAG_FREED_BITMAP)
|
|
|
|
udf_sb_free_bitmap(map->s_fspace.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]);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int udf_fill_super(struct super_block *sb, void *options, int silent)
|
|
|
|
{
|
|
|
|
int i;
|
2007-07-19 08:47:43 +00:00
|
|
|
struct inode *inode = NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct udf_options uopt;
|
|
|
|
kernel_lb_addr rootdir, fileset;
|
|
|
|
struct udf_sb_info *sbi;
|
|
|
|
|
|
|
|
uopt.flags = (1 << UDF_FLAG_USE_AD_IN_ICB) | (1 << UDF_FLAG_STRICT);
|
|
|
|
uopt.uid = -1;
|
|
|
|
uopt.gid = -1;
|
|
|
|
uopt.umask = 0;
|
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
sbi = kzalloc(sizeof(struct udf_sb_info), GFP_KERNEL);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!sbi)
|
|
|
|
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))
|
2005-04-16 22:20:36 +00:00
|
|
|
goto error_out;
|
|
|
|
|
|
|
|
if (uopt.flags & (1 << UDF_FLAG_UTF8) &&
|
2007-07-19 08:47:43 +00:00
|
|
|
uopt.flags & (1 << UDF_FLAG_NLS_MAP)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
udf_error(sb, "udf_read_super",
|
2007-07-19 08:47:43 +00:00
|
|
|
"utf8 cannot be combined with iocharset\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
#ifdef CONFIG_UDF_NLS
|
2007-07-19 08:47:43 +00:00
|
|
|
if ((uopt.flags & (1 << UDF_FLAG_NLS_MAP)) && !uopt.nls_map) {
|
2005-04-16 22:20:36 +00:00
|
|
|
uopt.nls_map = load_nls_default();
|
|
|
|
if (!uopt.nls_map)
|
|
|
|
uopt.flags &= ~(1 << UDF_FLAG_NLS_MAP);
|
|
|
|
else
|
|
|
|
udf_debug("Using default NLS map\n");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
if (!(uopt.flags & (1 << UDF_FLAG_NLS_MAP)))
|
|
|
|
uopt.flags |= (1 << UDF_FLAG_UTF8);
|
|
|
|
|
|
|
|
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;
|
|
|
|
sbi->s_nls_map = uopt.nls_map;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Set the block size for all transfers */
|
2008-02-22 11:38:02 +00:00
|
|
|
if (!sb_min_blocksize(sb, uopt.blocksize)) {
|
|
|
|
udf_debug("Bad block size (%d)\n", uopt.blocksize);
|
|
|
|
printk(KERN_ERR "udf: bad block size (%d)\n", uopt.blocksize);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto error_out;
|
2008-02-22 11:38:02 +00:00
|
|
|
}
|
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
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
sbi->s_last_block = uopt.lastblock;
|
|
|
|
sbi->s_anchor[0] = sbi->s_anchor[1] = 0;
|
|
|
|
sbi->s_anchor[2] = uopt.anchor;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-08 12:20:28 +00:00
|
|
|
if (udf_check_valid(sb, uopt.novrs, silent)) {
|
|
|
|
/* read volume recognition sequences */
|
|
|
|
printk(KERN_WARNING "UDF-fs: No VRS found\n");
|
2007-07-19 08:47:43 +00:00
|
|
|
goto error_out;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
udf_find_anchor(sb);
|
|
|
|
|
|
|
|
/* Fill in the rest of the superblock */
|
|
|
|
sb->s_op = &udf_sb_ops;
|
|
|
|
sb->dq_op = NULL;
|
|
|
|
sb->s_dirt = 0;
|
|
|
|
sb->s_magic = UDF_SUPER_MAGIC;
|
|
|
|
sb->s_time_gran = 1000;
|
|
|
|
|
2008-04-02 14:01:35 +00:00
|
|
|
if (udf_load_sequence(sb, &fileset)) {
|
2008-02-08 12:20:28 +00:00
|
|
|
printk(KERN_WARNING "UDF-fs: No partition found (1)\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
udf_debug("Lastblock=%d\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 =
|
|
|
|
udf_sb_lvidiu(sbi);
|
2008-02-08 12:20:30 +00:00
|
|
|
uint16_t minUDFReadRev = le16_to_cpu(lvidiu->minUDFReadRev);
|
|
|
|
uint16_t minUDFWriteRev = le16_to_cpu(lvidiu->minUDFWriteRev);
|
2008-02-08 12:20:36 +00:00
|
|
|
/* uint16_t maxUDFWriteRev =
|
|
|
|
le16_to_cpu(lvidiu->maxUDFWriteRev); */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
if (minUDFReadRev > UDF_MAX_READ_VERSION) {
|
2008-02-08 12:20:36 +00:00
|
|
|
printk(KERN_ERR "UDF-fs: minUDFReadRev=%x "
|
|
|
|
"(max is %x)\n",
|
2008-02-08 12:20:30 +00:00
|
|
|
le16_to_cpu(lvidiu->minUDFReadRev),
|
2007-07-19 08:47:43 +00:00
|
|
|
UDF_MAX_READ_VERSION);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto error_out;
|
2008-02-08 12:20:36 +00:00
|
|
|
} else if (minUDFWriteRev > UDF_MAX_WRITE_VERSION)
|
2005-04-16 22:20:36 +00:00
|
|
|
sb->s_flags |= MS_RDONLY;
|
|
|
|
|
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) {
|
2008-02-08 12:20:28 +00:00
|
|
|
printk(KERN_WARNING "UDF-fs: No partition found (2)\n");
|
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 &
|
|
|
|
UDF_PART_FLAG_READ_ONLY) {
|
|
|
|
printk(KERN_NOTICE "UDF-fs: Partition marked readonly; "
|
|
|
|
"forcing readonly mount\n");
|
2006-09-29 08:59:41 +00:00
|
|
|
sb->s_flags |= MS_RDONLY;
|
2006-10-05 19:17:50 +00:00
|
|
|
}
|
2006-09-29 08:59:41 +00:00
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
if (udf_find_fileset(sb, &fileset, &rootdir)) {
|
2008-02-08 12:20:28 +00:00
|
|
|
printk(KERN_WARNING "UDF-fs: 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-02-10 10:25:31 +00:00
|
|
|
timestamp ts;
|
|
|
|
udf_time_to_disk_stamp(&ts, sbi->s_record_time);
|
2008-02-08 12:20:47 +00:00
|
|
|
udf_info("UDF: Mounting volume '%s', "
|
2007-07-21 11:37:18 +00:00
|
|
|
"timestamp %04u/%02u/%02u %02u:%02u (%x)\n",
|
2008-02-10 10:25:31 +00:00
|
|
|
sbi->s_volume_ident, 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
|
|
|
}
|
|
|
|
if (!(sb->s_flags & MS_RDONLY))
|
|
|
|
udf_open_lvid(sb);
|
|
|
|
|
|
|
|
/* Assign the root inode */
|
|
|
|
/* assign inodes by physical block number */
|
|
|
|
/* perhaps it's not extensible enough, but for now ... */
|
2007-07-19 08:47:43 +00:00
|
|
|
inode = udf_iget(sb, rootdir);
|
|
|
|
if (!inode) {
|
2008-02-08 12:20:36 +00:00
|
|
|
printk(KERN_ERR "UDF-fs: Error in udf_iget, block=%d, "
|
|
|
|
"partition=%d\n",
|
2007-07-19 08:47:43 +00:00
|
|
|
rootdir.logicalBlockNum, rootdir.partitionReferenceNum);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate a dentry for the root inode */
|
|
|
|
sb->s_root = d_alloc_root(inode);
|
2007-07-19 08:47:43 +00:00
|
|
|
if (!sb->s_root) {
|
2008-02-08 12:20:28 +00:00
|
|
|
printk(KERN_ERR "UDF-fs: Couldn't allocate root dentry\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
iput(inode);
|
|
|
|
goto error_out;
|
|
|
|
}
|
2007-05-08 07:35:21 +00:00
|
|
|
sb->s_maxbytes = MAX_LFS_FILESIZE;
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
|
2007-07-21 11:37:18 +00:00
|
|
|
error_out:
|
2008-02-08 12:20:30 +00:00
|
|
|
if (sbi->s_vat_inode)
|
|
|
|
iput(sbi->s_vat_inode);
|
2008-04-01 16:08:51 +00:00
|
|
|
if (sbi->s_partitions)
|
|
|
|
for (i = 0; i < sbi->s_partitions; i++)
|
|
|
|
udf_free_partition(&sbi->s_partmaps[i]);
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef CONFIG_UDF_NLS
|
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
|
2008-02-08 12:20:30 +00:00
|
|
|
unload_nls(sbi->s_nls_map);
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
if (!(sb->s_flags & MS_RDONLY))
|
|
|
|
udf_close_lvid(sb);
|
2008-02-08 12:20:30 +00:00
|
|
|
brelse(sbi->s_lvid_bh);
|
|
|
|
|
|
|
|
kfree(sbi->s_partmaps);
|
2005-04-16 22:20:36 +00:00
|
|
|
kfree(sbi);
|
|
|
|
sb->s_fs_info = NULL;
|
2007-07-21 11:37:18 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-02-17 08:19:55 +00:00
|
|
|
static void udf_error(struct super_block *sb, const char *function,
|
|
|
|
const char *fmt, ...)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
if (!(sb->s_flags & MS_RDONLY)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/* mark sb error */
|
|
|
|
sb->s_dirt = 1;
|
|
|
|
}
|
|
|
|
va_start(args, fmt);
|
2006-12-07 04:37:04 +00:00
|
|
|
vsnprintf(error_buf, sizeof(error_buf), fmt, args);
|
2005-04-16 22:20:36 +00:00
|
|
|
va_end(args);
|
2008-02-08 12:20:28 +00:00
|
|
|
printk(KERN_CRIT "UDF-fs error (device %s): %s: %s\n",
|
2007-07-21 11:37:18 +00:00
|
|
|
sb->s_id, function, error_buf);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void udf_warning(struct super_block *sb, const char *function,
|
2007-07-19 08:47:43 +00:00
|
|
|
const char *fmt, ...)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
va_start(args, fmt);
|
2006-12-07 04:37:04 +00:00
|
|
|
vsnprintf(error_buf, sizeof(error_buf), fmt, args);
|
2005-04-16 22:20:36 +00:00
|
|
|
va_end(args);
|
|
|
|
printk(KERN_WARNING "UDF-fs warning (device %s): %s: %s\n",
|
2007-07-19 08:47:43 +00:00
|
|
|
sb->s_id, function, error_buf);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
|
|
|
int i;
|
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);
|
|
|
|
if (sbi->s_vat_inode)
|
|
|
|
iput(sbi->s_vat_inode);
|
2008-04-01 16:08:51 +00:00
|
|
|
if (sbi->s_partitions)
|
|
|
|
for (i = 0; i < sbi->s_partitions; i++)
|
|
|
|
udf_free_partition(&sbi->s_partmaps[i]);
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef CONFIG_UDF_NLS
|
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
|
2008-02-08 12:20:30 +00:00
|
|
|
unload_nls(sbi->s_nls_map);
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
if (!(sb->s_flags & MS_RDONLY))
|
|
|
|
udf_close_lvid(sb);
|
2008-02-08 12:20:30 +00:00
|
|
|
brelse(sbi->s_lvid_bh);
|
|
|
|
kfree(sbi->s_partmaps);
|
2005-04-16 22:20:36 +00:00
|
|
|
kfree(sb->s_fs_info);
|
|
|
|
sb->s_fs_info = NULL;
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
if (sbi->s_lvid_bh != NULL)
|
|
|
|
lvidiu = udf_sb_lvidiu(sbi);
|
|
|
|
else
|
|
|
|
lvidiu = NULL;
|
2006-06-23 09:02:58 +00:00
|
|
|
|
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;
|
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;
|
|
|
|
/* __kernel_fsid_t f_fsid */
|
2007-07-19 08:47:43 +00:00
|
|
|
buf->f_namelen = UDF_NAME_LEN - 2;
|
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;
|
|
|
|
int block = 0, newblock;
|
|
|
|
kernel_lb_addr loc;
|
|
|
|
uint32_t bytes;
|
|
|
|
uint8_t *ptr;
|
|
|
|
uint16_t ident;
|
|
|
|
struct spaceBitmapDesc *bm;
|
|
|
|
|
|
|
|
lock_kernel();
|
|
|
|
|
|
|
|
loc.logicalBlockNum = bitmap->s_extPosition;
|
2008-02-08 12:20:30 +00:00
|
|
|
loc.partitionReferenceNum = UDF_SB(sb)->s_partition;
|
2005-04-16 22:20:36 +00:00
|
|
|
bh = udf_read_ptagged(sb, loc, 0, &ident);
|
|
|
|
|
2007-07-19 08:47:43 +00:00
|
|
|
if (!bh) {
|
2005-04-16 22:20:36 +00:00
|
|
|
printk(KERN_ERR "udf: udf_count_free failed\n");
|
|
|
|
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);
|
2005-04-16 22:20:36 +00:00
|
|
|
printk(KERN_ERR "udf: udf_count_free failed\n");
|
|
|
|
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);
|
2005-04-16 22:20:36 +00:00
|
|
|
newblock = udf_get_lb_pblock(sb, loc, ++block);
|
|
|
|
bh = udf_tread(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);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-07-21 11:37:18 +00:00
|
|
|
out:
|
2005-04-16 22:20:36 +00:00
|
|
|
unlock_kernel();
|
|
|
|
|
|
|
|
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;
|
|
|
|
kernel_lb_addr eloc;
|
2005-04-16 22:20:36 +00:00
|
|
|
int8_t etype;
|
2007-05-08 07:35:14 +00:00
|
|
|
struct extent_position epos;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
lock_kernel();
|
|
|
|
|
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
|
|
|
|
2008-02-08 12:20:28 +00:00
|
|
|
while ((etype = 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);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
unlock_kernel();
|
|
|
|
|
|
|
|
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;
|
2008-02-08 12:20:30 +00:00
|
|
|
struct udf_sb_info *sbi;
|
|
|
|
struct udf_part_map *map;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
sbi = UDF_SB(sb);
|
|
|
|
if (sbi->s_lvid_bh) {
|
2008-02-08 12:20:36 +00:00
|
|
|
struct logicalVolIntegrityDesc *lvid =
|
|
|
|
(struct logicalVolIntegrityDesc *)
|
|
|
|
sbi->s_lvid_bh->b_data;
|
2008-02-08 12:20:30 +00:00
|
|
|
if (le32_to_cpu(lvid->numOfPartitions) > sbi->s_partition) {
|
2008-02-08 12:20:36 +00:00
|
|
|
accum = le32_to_cpu(
|
|
|
|
lvid->freeSpaceTable[sbi->s_partition]);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (accum == 0xFFFFFFFF)
|
|
|
|
accum = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (accum)
|
|
|
|
return accum;
|
|
|
|
|
2008-02-08 12:20:30 +00:00
|
|
|
map = &sbi->s_partmaps[sbi->s_partition];
|
|
|
|
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
|
|
|
}
|
2008-02-08 12:20:30 +00:00
|
|
|
if (map->s_partition_flags & UDF_PART_FLAG_FREED_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_fspace.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
|
|
|
}
|
2008-02-08 12:20:30 +00:00
|
|
|
if (map->s_partition_flags & UDF_PART_FLAG_FREED_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_fspace.s_table);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return accum;
|
|
|
|
}
|