2005-04-16 16:20:36 -06: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 05:20:28 -07:00
|
|
|
* 12/06/98 blf really hosed things royally. vat/sparing support. sequenced
|
|
|
|
* vol descs. rewrote option handling based on isofs
|
2005-04-16 16:20:36 -06:00
|
|
|
* 12/20/98 find the free space bitmap (if it exists)
|
|
|
|
*/
|
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
#include "udfdecl.h"
|
2005-04-16 16:20:36 -06: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 05:20:32 -07:00
|
|
|
#include <linux/errno.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <asm/byteorder.h>
|
|
|
|
|
|
|
|
#include <linux/udf_fs.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
|
|
|
|
|
|
|
|
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 int udf_load_partition(struct super_block *, kernel_lb_addr *);
|
2007-07-19 02:47:43 -06:00
|
|
|
static int udf_load_logicalvol(struct super_block *, struct buffer_head *,
|
|
|
|
kernel_lb_addr *);
|
2005-04-16 16:20:36 -06:00
|
|
|
static void udf_load_logicalvolint(struct super_block *, kernel_extent_ad);
|
|
|
|
static void udf_find_anchor(struct super_block *);
|
2007-07-19 02:47:43 -06:00
|
|
|
static int udf_find_fileset(struct super_block *, kernel_lb_addr *,
|
|
|
|
kernel_lb_addr *);
|
2005-04-16 16:20:36 -06:00
|
|
|
static void udf_load_pvoldesc(struct super_block *, struct buffer_head *);
|
2007-07-19 02:47:43 -06:00
|
|
|
static void udf_load_fileset(struct super_block *, struct buffer_head *,
|
|
|
|
kernel_lb_addr *);
|
2007-08-31 00:56:22 -06:00
|
|
|
static int udf_load_partdesc(struct super_block *, struct buffer_head *);
|
2005-04-16 16:20:36 -06: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 03:02:58 -06:00
|
|
|
static int udf_statfs(struct dentry *, struct kstatfs *);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu(struct udf_sb_info *sbi)
|
|
|
|
{
|
2008-02-08 05:20:36 -07:00
|
|
|
struct logicalVolIntegrityDesc *lvid =
|
|
|
|
(struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
|
2008-02-08 05:20:30 -07:00
|
|
|
__u32 number_of_partitions = le32_to_cpu(lvid->numOfPartitions);
|
2008-02-08 05:20:36 -07:00
|
|
|
__u32 offset = number_of_partitions * 2 *
|
|
|
|
sizeof(uint32_t)/sizeof(uint8_t);
|
2008-02-08 05:20:30 -07:00
|
|
|
return (struct logicalVolIntegrityDescImpUse *)&(lvid->impUse[offset]);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06: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 03:02:57 -06:00
|
|
|
static int udf_get_sb(struct file_system_type *fs_type,
|
2007-07-19 02:47:43 -06:00
|
|
|
int flags, const char *dev_name, void *data,
|
|
|
|
struct vfsmount *mnt)
|
2005-04-16 16:20:36 -06: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 03:02:57 -06:00
|
|
|
return get_sb_bdev(fs_type, flags, dev_name, data, udf_fill_super, mnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct file_system_type udf_fstype = {
|
2007-07-21 05:37:18 -06:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.name = "udf",
|
|
|
|
.get_sb = udf_get_sb,
|
|
|
|
.kill_sb = kill_block_super,
|
|
|
|
.fs_flags = FS_REQUIRES_DEV,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
static struct kmem_cache *udf_inode_cachep;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
static struct inode *udf_alloc_inode(struct super_block *sb)
|
|
|
|
{
|
|
|
|
struct udf_inode_info *ei;
|
2008-02-08 05:20:28 -07:00
|
|
|
ei = kmem_cache_alloc(udf_inode_cachep, GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!ei)
|
|
|
|
return NULL;
|
2006-08-14 00:24:18 -06: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 16:20:36 -06: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 00:25:51 -06:00
|
|
|
static void init_once(struct kmem_cache *cachep, void *foo)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-07-19 02:47:43 -06:00
|
|
|
struct udf_inode_info *ei = (struct udf_inode_info *)foo;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-16 23:10:57 -06:00
|
|
|
ei->i_ext.i_data = NULL;
|
|
|
|
inode_init_once(&ei->vfs_inode);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int init_inodecache(void)
|
|
|
|
{
|
|
|
|
udf_inode_cachep = kmem_cache_create("udf_inode_cache",
|
|
|
|
sizeof(struct udf_inode_info),
|
2007-07-19 02:47:43 -06:00
|
|
|
0, (SLAB_RECLAIM_ACCOUNT |
|
|
|
|
SLAB_MEM_SPREAD),
|
2007-07-19 19:11:58 -06:00
|
|
|
init_once);
|
2007-07-21 05:37:18 -06:00
|
|
|
if (!udf_inode_cachep)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void destroy_inodecache(void)
|
|
|
|
{
|
2006-09-27 02:49:40 -06:00
|
|
|
kmem_cache_destroy(udf_inode_cachep);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Superblock operations */
|
2007-02-12 01:55:41 -07:00
|
|
|
static const struct super_operations udf_sb_ops = {
|
2007-07-21 05:37:18 -06: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,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
struct udf_options {
|
2005-04-16 16:20:36 -06: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 05:37:18 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
err = init_inodecache();
|
|
|
|
if (err)
|
|
|
|
goto out1;
|
|
|
|
err = register_filesystem(&udf_fstype);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
2007-07-21 05:37:18 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
2007-07-21 05:37:18 -06:00
|
|
|
|
|
|
|
out:
|
2005-04-16 16:20:36 -06:00
|
|
|
destroy_inodecache();
|
2007-07-21 05:37:18 -06:00
|
|
|
|
|
|
|
out1:
|
2005-04-16 16:20:36 -06:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit exit_udf_fs(void)
|
|
|
|
{
|
|
|
|
unregister_filesystem(&udf_fstype);
|
|
|
|
destroy_inodecache();
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(init_udf_fs)
|
2007-07-21 05:37:18 -06:00
|
|
|
module_exit(exit_udf_fs)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:32 -07: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;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06: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 05:37:18 -06:00
|
|
|
* novrs Skip volume sequence recognition
|
2005-04-16 16:20:36 -06: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 05:37:18 -06:00
|
|
|
|
2005-04-16 16:20:36 -06: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-07 22:55:24 -07:00
|
|
|
Opt_err, Opt_uforget, Opt_uignore, Opt_gforget, Opt_gignore
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static match_table_t tokens = {
|
2007-07-21 05:37:18 -06: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 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
static int udf_parse_options(char *options, struct udf_options *uopt)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
int option;
|
|
|
|
|
|
|
|
uopt->novrs = 0;
|
|
|
|
uopt->blocksize = 2048;
|
|
|
|
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 02:47:43 -06:00
|
|
|
while ((p = strsep(&options, ",")) != NULL) {
|
2005-04-16 16:20:36 -06:00
|
|
|
substring_t args[MAX_OPT_ARGS];
|
|
|
|
int token;
|
|
|
|
if (!*p)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
token = match_token(p, tokens, args);
|
2007-07-19 02:47:43 -06: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 01:39:40 -06:00
|
|
|
uopt->flags |= (1 << UDF_FLAG_GID_SET);
|
2007-07-19 02:47:43 -06:00
|
|
|
break;
|
|
|
|
case Opt_uid:
|
|
|
|
if (match_int(args, &option))
|
|
|
|
return 0;
|
|
|
|
uopt->uid = option;
|
2007-07-31 01:39:40 -06:00
|
|
|
uopt->flags |= (1 << UDF_FLAG_UID_SET);
|
2007-07-19 02:47:43 -06: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;
|
|
|
|
break;
|
|
|
|
case Opt_lastblock:
|
|
|
|
if (match_int(args, &option))
|
|
|
|
return 0;
|
|
|
|
uopt->lastblock = option;
|
|
|
|
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 16:20:36 -06:00
|
|
|
#ifdef CONFIG_UDF_NLS
|
2007-07-19 02:47:43 -06:00
|
|
|
case Opt_iocharset:
|
|
|
|
uopt->nls_map = load_nls(args[0].from);
|
|
|
|
uopt->flags |= (1 << UDF_FLAG_NLS_MAP);
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2007-07-19 02:47:43 -06: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 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-02-08 05:20:35 -07:00
|
|
|
static void udf_write_super(struct super_block *sb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
lock_kernel();
|
2007-07-21 05:37:18 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!(sb->s_flags & MS_RDONLY))
|
|
|
|
udf_open_lvid(sb);
|
|
|
|
sb->s_dirt = 0;
|
2007-07-21 05:37:18 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
unlock_kernel();
|
|
|
|
}
|
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
static int udf_remount_fs(struct super_block *sb, int *flags, char *options)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct udf_options uopt;
|
2008-02-08 05:20:30 -07:00
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
uopt.flags = sbi->s_flags;
|
|
|
|
uopt.uid = sbi->s_uid;
|
|
|
|
uopt.gid = sbi->s_gid;
|
|
|
|
uopt.umask = sbi->s_umask;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
if (!udf_parse_options(options, &uopt))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
sbi->s_flags = uopt.flags;
|
|
|
|
sbi->s_uid = uopt.uid;
|
|
|
|
sbi->s_gid = uopt.gid;
|
|
|
|
sbi->s_umask = uopt.umask;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
if (sbi->s_lvid_bh) {
|
|
|
|
int write_rev = le16_to_cpu(udf_sb_lvidiu(sbi)->minUDFWriteRev);
|
2005-04-16 16:20:36 -06: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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* udf_set_blocksize
|
|
|
|
*
|
|
|
|
* PURPOSE
|
|
|
|
* Set the block size to be used in all transfers.
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* To allow room for a DMA transfer, it is best to guess big when unsure.
|
|
|
|
* This routine picks 2048 bytes as the blocksize when guessing. This
|
|
|
|
* should be adequate until devices with larger block sizes become common.
|
|
|
|
*
|
|
|
|
* Note that the Linux kernel can currently only deal with blocksizes of
|
|
|
|
* 512, 1024, 2048, 4096, and 8192 bytes.
|
|
|
|
*
|
|
|
|
* PRE-CONDITIONS
|
|
|
|
* sb Pointer to _locked_ superblock.
|
|
|
|
*
|
|
|
|
* POST-CONDITIONS
|
|
|
|
* sb->s_blocksize Blocksize.
|
|
|
|
* sb->s_blocksize_bits log2 of blocksize.
|
|
|
|
* <return> 0 Blocksize is valid.
|
|
|
|
* <return> 1 Blocksize is invalid.
|
|
|
|
*
|
|
|
|
* HISTORY
|
|
|
|
* July 1, 1997 - Andrew E. Mileski
|
|
|
|
* Written, tested, and released.
|
|
|
|
*/
|
2007-07-19 02:47:43 -06:00
|
|
|
static int udf_set_blocksize(struct super_block *sb, int bsize)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
if (!sb_min_blocksize(sb, bsize)) {
|
|
|
|
udf_debug("Bad block size (%d)\n", bsize);
|
|
|
|
printk(KERN_ERR "udf: bad block size (%d)\n", bsize);
|
|
|
|
return 0;
|
|
|
|
}
|
2007-07-21 05:37:18 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return sb->s_blocksize;
|
|
|
|
}
|
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
static int udf_vrs(struct super_block *sb, int silent)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct volStructDesc *vsd = NULL;
|
|
|
|
int sector = 32768;
|
|
|
|
int sectorsize;
|
|
|
|
struct buffer_head *bh = NULL;
|
2007-07-19 02:47:43 -06:00
|
|
|
int iso9660 = 0;
|
|
|
|
int nsr02 = 0;
|
|
|
|
int nsr03 = 0;
|
2008-02-08 05:20:30 -07:00
|
|
|
struct udf_sb_info *sbi;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Block size must be a multiple of 512 */
|
|
|
|
if (sb->s_blocksize & 511)
|
|
|
|
return 0;
|
2008-02-08 05:20:30 -07:00
|
|
|
sbi = UDF_SB(sb);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (sb->s_blocksize < sizeof(struct volStructDesc))
|
|
|
|
sectorsize = sizeof(struct volStructDesc);
|
|
|
|
else
|
|
|
|
sectorsize = sb->s_blocksize;
|
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
sector += (sbi->s_session << sb->s_blocksize_bits);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
udf_debug("Starting at sector %u (%ld byte sectors)\n",
|
2007-07-19 02:47:43 -06:00
|
|
|
(sector >> sb->s_blocksize_bits), sb->s_blocksize);
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Process the sequence (if applicable) */
|
2007-07-19 02:47:43 -06:00
|
|
|
for (; !nsr02 && !nsr03; sector += sectorsize) {
|
2005-04-16 16:20:36 -06: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 05:20:28 -07:00
|
|
|
(sector & (sb->s_blocksize - 1)));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
if (vsd->stdIdent[0] == 0) {
|
2007-05-08 01:35:16 -06:00
|
|
|
brelse(bh);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2008-02-08 05:20:28 -07:00
|
|
|
} else if (!strncmp(vsd->stdIdent, VSD_STD_ID_CD001,
|
|
|
|
VSD_STD_ID_LEN)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
iso9660 = sector;
|
2007-07-19 02:47:43 -06:00
|
|
|
switch (vsd->structType) {
|
|
|
|
case 0:
|
|
|
|
udf_debug("ISO9660 Boot Record found\n");
|
|
|
|
break;
|
|
|
|
case 1:
|
2008-02-08 05:20:28 -07:00
|
|
|
udf_debug("ISO9660 Primary Volume Descriptor "
|
|
|
|
"found\n");
|
2007-07-19 02:47:43 -06:00
|
|
|
break;
|
|
|
|
case 2:
|
2008-02-08 05:20:28 -07:00
|
|
|
udf_debug("ISO9660 Supplementary Volume "
|
|
|
|
"Descriptor found\n");
|
2007-07-19 02:47:43 -06:00
|
|
|
break;
|
|
|
|
case 3:
|
2008-02-08 05:20:28 -07:00
|
|
|
udf_debug("ISO9660 Volume Partition Descriptor "
|
|
|
|
"found\n");
|
2007-07-19 02:47:43 -06:00
|
|
|
break;
|
|
|
|
case 255:
|
2008-02-08 05:20:28 -07:00
|
|
|
udf_debug("ISO9660 Volume Descriptor Set "
|
|
|
|
"Terminator found\n");
|
2007-07-19 02:47:43 -06:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
udf_debug("ISO9660 VRS (%u) found\n",
|
|
|
|
vsd->structType);
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-02-08 05:20:28 -07: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 01:35:16 -06:00
|
|
|
brelse(bh);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2008-02-08 05:20:28 -07:00
|
|
|
} else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR02,
|
|
|
|
VSD_STD_ID_LEN))
|
2005-04-16 16:20:36 -06:00
|
|
|
nsr02 = sector;
|
2008-02-08 05:20:28 -07:00
|
|
|
else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR03,
|
|
|
|
VSD_STD_ID_LEN))
|
2005-04-16 16:20:36 -06:00
|
|
|
nsr03 = sector;
|
2007-05-08 01:35:16 -06:00
|
|
|
brelse(bh);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (nsr03)
|
|
|
|
return nsr03;
|
|
|
|
else if (nsr02)
|
|
|
|
return nsr02;
|
2008-02-08 05:20:30 -07:00
|
|
|
else if (sector - (sbi->s_session << sb->s_blocksize_bits) == 32768)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -1;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* udf_find_anchor
|
|
|
|
*
|
|
|
|
* PURPOSE
|
|
|
|
* Find an anchor volume descriptor.
|
|
|
|
*
|
|
|
|
* PRE-CONDITIONS
|
|
|
|
* sb Pointer to _locked_ superblock.
|
|
|
|
* lastblock Last block on media.
|
|
|
|
*
|
|
|
|
* POST-CONDITIONS
|
|
|
|
* <return> 1 if not found, 0 if ok
|
|
|
|
*
|
|
|
|
* HISTORY
|
|
|
|
* July 1, 1997 - Andrew E. Mileski
|
|
|
|
* Written, tested, and released.
|
|
|
|
*/
|
2007-07-19 02:47:43 -06:00
|
|
|
static void udf_find_anchor(struct super_block *sb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-02-08 05:20:30 -07:00
|
|
|
int lastblock;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct buffer_head *bh = NULL;
|
|
|
|
uint16_t ident;
|
|
|
|
uint32_t location;
|
|
|
|
int i;
|
2008-02-08 05:20:30 -07:00
|
|
|
struct udf_sb_info *sbi;
|
|
|
|
|
|
|
|
sbi = UDF_SB(sb);
|
|
|
|
lastblock = sbi->s_last_block;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
if (lastblock) {
|
2005-04-16 16:20:36 -06:00
|
|
|
int varlastblock = udf_variable_to_fixed(lastblock);
|
2007-07-21 05:37:18 -06:00
|
|
|
int last[] = { lastblock, lastblock - 2,
|
|
|
|
lastblock - 150, lastblock - 152,
|
|
|
|
varlastblock, varlastblock - 2,
|
|
|
|
varlastblock - 150, varlastblock - 152 };
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
lastblock = 0;
|
|
|
|
|
|
|
|
/* Search for an anchor volume descriptor pointer */
|
|
|
|
|
|
|
|
/* 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 04:15:34 -07:00
|
|
|
for (i = 0; !lastblock && i < ARRAY_SIZE(last); i++) {
|
2008-02-08 05:20:28 -07:00
|
|
|
ident = location = 0;
|
|
|
|
if (last[i] >= 0) {
|
|
|
|
bh = sb_bread(sb, last[i]);
|
|
|
|
if (bh) {
|
|
|
|
tag *t = (tag *)bh->b_data;
|
|
|
|
ident = le16_to_cpu(t->tagIdent);
|
|
|
|
location = le32_to_cpu(t->tagLocation);
|
|
|
|
brelse(bh);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-03-24 04:15:34 -07:00
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
if (ident == TAG_IDENT_AVDP) {
|
2008-02-08 05:20:30 -07:00
|
|
|
if (location == last[i] - sbi->s_session) {
|
|
|
|
lastblock = last[i] - sbi->s_session;
|
|
|
|
sbi->s_anchor[0] = lastblock;
|
|
|
|
sbi->s_anchor[1] = lastblock - 256;
|
2008-02-08 05:20:36 -07:00
|
|
|
} else if (location ==
|
|
|
|
udf_variable_to_fixed(last[i]) -
|
|
|
|
sbi->s_session) {
|
2005-04-16 16:20:36 -06:00
|
|
|
UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
|
2008-02-08 05:20:36 -07:00
|
|
|
lastblock =
|
|
|
|
udf_variable_to_fixed(last[i]) -
|
|
|
|
sbi->s_session;
|
2008-02-08 05:20:30 -07:00
|
|
|
sbi->s_anchor[0] = lastblock;
|
2008-02-08 05:20:36 -07:00
|
|
|
sbi->s_anchor[1] = lastblock - 256 -
|
|
|
|
sbi->s_session;
|
2007-07-21 05:37:18 -06:00
|
|
|
} else {
|
2008-02-08 05:20:36 -07:00
|
|
|
udf_debug("Anchor found at block %d, "
|
|
|
|
"location mismatch %d.\n",
|
2007-07-21 05:37:18 -06:00
|
|
|
last[i], location);
|
|
|
|
}
|
2008-02-08 05:20:36 -07:00
|
|
|
} else if (ident == TAG_IDENT_FE ||
|
|
|
|
ident == TAG_IDENT_EFE) {
|
2005-04-16 16:20:36 -06:00
|
|
|
lastblock = last[i];
|
2008-02-08 05:20:30 -07:00
|
|
|
sbi->s_anchor[3] = 512;
|
2007-07-19 02:47:43 -06:00
|
|
|
} else {
|
2008-02-08 05:20:28 -07:00
|
|
|
ident = location = 0;
|
|
|
|
if (last[i] >= 256) {
|
|
|
|
bh = sb_bread(sb, last[i] - 256);
|
|
|
|
if (bh) {
|
|
|
|
tag *t = (tag *)bh->b_data;
|
2008-02-08 05:20:36 -07:00
|
|
|
ident = le16_to_cpu(
|
|
|
|
t->tagIdent);
|
|
|
|
location = le32_to_cpu(
|
|
|
|
t->tagLocation);
|
2008-02-08 05:20:28 -07:00
|
|
|
brelse(bh);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-07-19 02:47:43 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ident == TAG_IDENT_AVDP &&
|
2008-02-08 05:20:36 -07:00
|
|
|
location == last[i] - 256 -
|
|
|
|
sbi->s_session) {
|
2005-04-16 16:20:36 -06:00
|
|
|
lastblock = last[i];
|
2008-02-08 05:20:30 -07:00
|
|
|
sbi->s_anchor[1] = last[i] - 256;
|
2007-07-19 02:47:43 -06:00
|
|
|
} else {
|
2008-02-08 05:20:28 -07:00
|
|
|
ident = location = 0;
|
2008-02-08 05:20:30 -07:00
|
|
|
if (last[i] >= 312 + sbi->s_session) {
|
2008-02-08 05:20:36 -07:00
|
|
|
bh = sb_bread(sb,
|
|
|
|
last[i] - 312 -
|
|
|
|
sbi->s_session);
|
2008-02-08 05:20:28 -07:00
|
|
|
if (bh) {
|
2008-02-08 05:20:36 -07:00
|
|
|
tag *t = (tag *)
|
|
|
|
bh->b_data;
|
|
|
|
ident = le16_to_cpu(
|
|
|
|
t->tagIdent);
|
|
|
|
location = le32_to_cpu(
|
|
|
|
t->tagLocation);
|
2008-02-08 05:20:28 -07:00
|
|
|
brelse(bh);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-07-19 02:47:43 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ident == TAG_IDENT_AVDP &&
|
2007-07-21 05:37:18 -06:00
|
|
|
location == udf_variable_to_fixed(last[i]) - 256) {
|
2008-02-08 05:20:36 -07:00
|
|
|
UDF_SET_FLAG(sb,
|
|
|
|
UDF_FLAG_VARCONV);
|
2007-07-21 05:37:18 -06:00
|
|
|
lastblock = udf_variable_to_fixed(last[i]);
|
2008-02-08 05:20:30 -07:00
|
|
|
sbi->s_anchor[1] = lastblock - 256;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
if (!lastblock) {
|
2008-02-08 05:20:28 -07:00
|
|
|
/* We haven't found the lastblock. check 312 */
|
2008-02-08 05:20:30 -07:00
|
|
|
bh = sb_bread(sb, 312 + sbi->s_session);
|
2008-02-08 05:20:28 -07:00
|
|
|
if (bh) {
|
|
|
|
tag *t = (tag *)bh->b_data;
|
|
|
|
ident = le16_to_cpu(t->tagIdent);
|
|
|
|
location = le32_to_cpu(t->tagLocation);
|
2007-05-08 01:35:16 -06:00
|
|
|
brelse(bh);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (ident == TAG_IDENT_AVDP && location == 256)
|
|
|
|
UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
for (i = 0; i < ARRAY_SIZE(sbi->s_anchor); i++) {
|
|
|
|
if (sbi->s_anchor[i]) {
|
|
|
|
bh = udf_read_tagged(sb, sbi->s_anchor[i],
|
|
|
|
sbi->s_anchor[i], &ident);
|
2008-02-08 05:20:28 -07:00
|
|
|
if (!bh)
|
2008-02-08 05:20:30 -07:00
|
|
|
sbi->s_anchor[i] = 0;
|
2008-02-08 05:20:28 -07:00
|
|
|
else {
|
2007-05-08 01:35:16 -06:00
|
|
|
brelse(bh);
|
2007-07-21 05:37:18 -06:00
|
|
|
if ((ident != TAG_IDENT_AVDP) &&
|
2008-02-08 05:20:36 -07:00
|
|
|
(i || (ident != TAG_IDENT_FE &&
|
|
|
|
ident != TAG_IDENT_EFE)))
|
2008-02-08 05:20:30 -07:00
|
|
|
sbi->s_anchor[i] = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
sbi->s_last_block = lastblock;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-02-08 05:20:28 -07:00
|
|
|
static int udf_find_fileset(struct super_block *sb,
|
|
|
|
kernel_lb_addr *fileset,
|
|
|
|
kernel_lb_addr *root)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct buffer_head *bh = NULL;
|
|
|
|
long lastblock;
|
|
|
|
uint16_t ident;
|
2008-02-08 05:20:30 -07:00
|
|
|
struct udf_sb_info *sbi;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (fileset->logicalBlockNum != 0xFFFFFFFF ||
|
2007-07-19 02:47:43 -06:00
|
|
|
fileset->partitionReferenceNum != 0xFFFF) {
|
2005-04-16 16:20:36 -06:00
|
|
|
bh = udf_read_ptagged(sb, *fileset, 0, &ident);
|
|
|
|
|
2007-07-21 05:37:18 -06:00
|
|
|
if (!bh) {
|
2005-04-16 16:20:36 -06:00
|
|
|
return 1;
|
2007-07-21 05:37:18 -06:00
|
|
|
} else if (ident != TAG_IDENT_FSD) {
|
2007-05-08 01:35:16 -06:00
|
|
|
brelse(bh);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 1;
|
|
|
|
}
|
2007-07-19 02:47:43 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
sbi = UDF_SB(sb);
|
2008-02-08 05:20:28 -07:00
|
|
|
if (!bh) {
|
|
|
|
/* Search backwards through the partitions */
|
2005-04-16 16:20:36 -06:00
|
|
|
kernel_lb_addr newfileset;
|
|
|
|
|
2007-07-21 05:37:18 -06:00
|
|
|
/* --> cvg: FIXME - is it reasonable? */
|
2005-04-16 16:20:36 -06:00
|
|
|
return 1;
|
2007-07-19 02:47:43 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
for (newfileset.partitionReferenceNum = sbi->s_partitions - 1;
|
2007-07-19 02:47:43 -06:00
|
|
|
(newfileset.partitionReferenceNum != 0xFFFF &&
|
|
|
|
fileset->logicalBlockNum == 0xFFFFFFFF &&
|
|
|
|
fileset->partitionReferenceNum == 0xFFFF);
|
|
|
|
newfileset.partitionReferenceNum--) {
|
2008-02-08 05:20:30 -07:00
|
|
|
lastblock = sbi->s_partmaps
|
|
|
|
[newfileset.partitionReferenceNum]
|
|
|
|
.s_partition_len;
|
2005-04-16 16:20:36 -06:00
|
|
|
newfileset.logicalBlockNum = 0;
|
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
do {
|
2008-02-08 05:20:28 -07:00
|
|
|
bh = udf_read_ptagged(sb, newfileset, 0,
|
|
|
|
&ident);
|
2007-07-19 02:47:43 -06:00
|
|
|
if (!bh) {
|
|
|
|
newfileset.logicalBlockNum++;
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
switch (ident) {
|
|
|
|
case TAG_IDENT_SBD:
|
2007-07-21 05:37:18 -06:00
|
|
|
{
|
|
|
|
struct spaceBitmapDesc *sp;
|
2008-02-08 05:20:36 -07:00
|
|
|
sp = (struct spaceBitmapDesc *)
|
|
|
|
bh->b_data;
|
2007-07-21 05:37:18 -06:00
|
|
|
newfileset.logicalBlockNum += 1 +
|
|
|
|
((le32_to_cpu(sp->numOfBytes) +
|
2008-02-08 05:20:36 -07:00
|
|
|
sizeof(struct spaceBitmapDesc)
|
|
|
|
- 1) >> sb->s_blocksize_bits);
|
2007-07-21 05:37:18 -06:00
|
|
|
brelse(bh);
|
|
|
|
break;
|
|
|
|
}
|
2007-07-19 02:47:43 -06:00
|
|
|
case TAG_IDENT_FSD:
|
2007-07-21 05:37:18 -06:00
|
|
|
*fileset = newfileset;
|
|
|
|
break;
|
2007-07-19 02:47:43 -06:00
|
|
|
default:
|
2007-07-21 05:37:18 -06:00
|
|
|
newfileset.logicalBlockNum++;
|
|
|
|
brelse(bh);
|
|
|
|
bh = NULL;
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-07-21 05:37:18 -06:00
|
|
|
} while (newfileset.logicalBlockNum < lastblock &&
|
|
|
|
fileset->logicalBlockNum == 0xFFFFFFFF &&
|
|
|
|
fileset->partitionReferenceNum == 0xFFFF);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((fileset->logicalBlockNum != 0xFFFFFFFF ||
|
2007-07-19 02:47:43 -06:00
|
|
|
fileset->partitionReferenceNum != 0xFFFF) && bh) {
|
2005-04-16 16:20:36 -06:00
|
|
|
udf_debug("Fileset at block=%d, partition=%d\n",
|
2007-07-19 02:47:43 -06:00
|
|
|
fileset->logicalBlockNum,
|
|
|
|
fileset->partitionReferenceNum);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
sbi->s_partition = fileset->partitionReferenceNum;
|
2005-04-16 16:20:36 -06:00
|
|
|
udf_load_fileset(sb, bh, root);
|
2007-05-08 01:35:16 -06:00
|
|
|
brelse(bh);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
static void udf_load_pvoldesc(struct super_block *sb, struct buffer_head *bh)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct primaryVolDesc *pvoldesc;
|
|
|
|
time_t recording;
|
|
|
|
long recording_usec;
|
|
|
|
struct ustr instr;
|
|
|
|
struct ustr outstr;
|
|
|
|
|
|
|
|
pvoldesc = (struct primaryVolDesc *)bh->b_data;
|
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
if (udf_stamp_to_time(&recording, &recording_usec,
|
|
|
|
lets_to_cpu(pvoldesc->recordingDateAndTime))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
kernel_timestamp ts;
|
|
|
|
ts = lets_to_cpu(pvoldesc->recordingDateAndTime);
|
2008-02-08 05:20:28 -07:00
|
|
|
udf_debug("recording time %ld/%ld, %04u/%02u/%02u"
|
|
|
|
" %02u:%02u (%x)\n",
|
2007-07-21 05:37:18 -06:00
|
|
|
recording, recording_usec,
|
|
|
|
ts.year, ts.month, ts.day, ts.hour,
|
|
|
|
ts.minute, ts.typeAndTimezone);
|
2008-02-08 05:20:30 -07:00
|
|
|
UDF_SB(sb)->s_record_time.tv_sec = recording;
|
|
|
|
UDF_SB(sb)->s_record_time.tv_nsec = recording_usec * 1000;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-02-08 05:20:36 -07:00
|
|
|
if (!udf_build_ustr(&instr, pvoldesc->volIdent, 32))
|
2007-07-19 02:47:43 -06:00
|
|
|
if (udf_CS0toUTF8(&outstr, &instr)) {
|
2008-02-08 05:20:30 -07:00
|
|
|
strncpy(UDF_SB(sb)->s_volume_ident, outstr.u_name,
|
2005-04-16 16:20:36 -06:00
|
|
|
outstr.u_len > 31 ? 31 : outstr.u_len);
|
2008-02-08 05:20:36 -07:00
|
|
|
udf_debug("volIdent[] = '%s'\n",
|
|
|
|
UDF_SB(sb)->s_volume_ident);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-02-08 05:20:36 -07:00
|
|
|
if (!udf_build_ustr(&instr, pvoldesc->volSetIdent, 128))
|
2005-04-16 16:20:36 -06:00
|
|
|
if (udf_CS0toUTF8(&outstr, &instr))
|
|
|
|
udf_debug("volSetIdent[] = '%s'\n", outstr.u_name);
|
|
|
|
}
|
|
|
|
|
2007-07-21 05:37:18 -06:00
|
|
|
static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh,
|
|
|
|
kernel_lb_addr *root)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct fileSetDesc *fset;
|
|
|
|
|
|
|
|
fset = (struct fileSetDesc *)bh->b_data;
|
|
|
|
|
|
|
|
*root = lelb_to_cpu(fset->rootDirectoryICB.extLocation);
|
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
UDF_SB(sb)->s_serial_number = le16_to_cpu(fset->descTag.tagSerialNum);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
udf_debug("Rootdir at block=%d, partition=%d\n",
|
|
|
|
root->logicalBlockNum, root->partitionReferenceNum);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-02-08 05:20:34 -07:00
|
|
|
int udf_compute_nr_groups(struct super_block *sb, u32 partition)
|
|
|
|
{
|
|
|
|
struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
|
|
|
|
return (map->s_partition_len +
|
|
|
|
(sizeof(struct spaceBitmapDesc) << 3) +
|
|
|
|
(sb->s_blocksize * 8) - 1) /
|
|
|
|
(sb->s_blocksize * 8);
|
|
|
|
}
|
|
|
|
|
2008-02-08 05:20:33 -07: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 05:20:34 -07:00
|
|
|
nr_groups = udf_compute_nr_groups(sb, index);
|
2008-02-08 05:20:33 -07: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;
|
|
|
|
}
|
|
|
|
|
2007-08-31 00:56:22 -06:00
|
|
|
static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct partitionDesc *p;
|
|
|
|
int i;
|
2008-02-08 05:20:30 -07:00
|
|
|
struct udf_part_map *map;
|
|
|
|
struct udf_sb_info *sbi;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
p = (struct partitionDesc *)bh->b_data;
|
2008-02-08 05:20:30 -07:00
|
|
|
sbi = UDF_SB(sb);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
for (i = 0; i < sbi->s_partitions; i++) {
|
|
|
|
map = &sbi->s_partmaps[i];
|
2007-07-19 02:47:43 -06:00
|
|
|
udf_debug("Searching map: (%d == %d)\n",
|
2008-02-08 05:20:36 -07:00
|
|
|
map->s_partition_num,
|
|
|
|
le16_to_cpu(p->partitionNumber));
|
|
|
|
if (map->s_partition_num ==
|
|
|
|
le16_to_cpu(p->partitionNumber)) {
|
|
|
|
map->s_partition_len =
|
|
|
|
le32_to_cpu(p->partitionLength); /* blocks */
|
|
|
|
map->s_partition_root =
|
|
|
|
le32_to_cpu(p->partitionStartingLocation);
|
|
|
|
if (le32_to_cpu(p->accessType) ==
|
|
|
|
PD_ACCESS_TYPE_READ_ONLY)
|
|
|
|
map->s_partition_flags |=
|
|
|
|
UDF_PART_FLAG_READ_ONLY;
|
|
|
|
if (le32_to_cpu(p->accessType) ==
|
|
|
|
PD_ACCESS_TYPE_WRITE_ONCE)
|
|
|
|
map->s_partition_flags |=
|
|
|
|
UDF_PART_FLAG_WRITE_ONCE;
|
|
|
|
if (le32_to_cpu(p->accessType) ==
|
|
|
|
PD_ACCESS_TYPE_REWRITABLE)
|
|
|
|
map->s_partition_flags |=
|
|
|
|
UDF_PART_FLAG_REWRITABLE;
|
|
|
|
if (le32_to_cpu(p->accessType) ==
|
|
|
|
PD_ACCESS_TYPE_OVERWRITABLE)
|
|
|
|
map->s_partition_flags |=
|
|
|
|
UDF_PART_FLAG_OVERWRITABLE;
|
2007-07-21 05:37:18 -06:00
|
|
|
|
2008-02-08 05:20:28 -07:00
|
|
|
if (!strcmp(p->partitionContents.ident,
|
|
|
|
PD_PARTITION_CONTENTS_NSR02) ||
|
|
|
|
!strcmp(p->partitionContents.ident,
|
|
|
|
PD_PARTITION_CONTENTS_NSR03)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
struct partitionHeaderDesc *phd;
|
|
|
|
|
2008-02-08 05:20:36 -07:00
|
|
|
phd = (struct partitionHeaderDesc *)
|
|
|
|
(p->partitionContentsUse);
|
2007-07-19 02:47:43 -06:00
|
|
|
if (phd->unallocSpaceTable.extLength) {
|
2007-07-21 05:37:18 -06:00
|
|
|
kernel_lb_addr loc = {
|
|
|
|
.logicalBlockNum = le32_to_cpu(phd->unallocSpaceTable.extPosition),
|
|
|
|
.partitionReferenceNum = i,
|
|
|
|
};
|
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
map->s_uspace.s_table =
|
2007-07-21 05:37:18 -06:00
|
|
|
udf_iget(sb, loc);
|
2008-02-08 05:20:30 -07:00
|
|
|
if (!map->s_uspace.s_table) {
|
2007-10-17 00:30:08 -06:00
|
|
|
udf_debug("cannot load unallocSpaceTable (part %d)\n", i);
|
2007-08-31 00:56:22 -06:00
|
|
|
return 1;
|
|
|
|
}
|
2008-02-08 05:20:36 -07:00
|
|
|
map->s_partition_flags |=
|
|
|
|
UDF_PART_FLAG_UNALLOC_TABLE;
|
2007-07-21 05:37:18 -06:00
|
|
|
udf_debug("unallocSpaceTable (part %d) @ %ld\n",
|
2008-02-08 05:20:30 -07:00
|
|
|
i, map->s_uspace.s_table->i_ino);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-07-19 02:47:43 -06:00
|
|
|
if (phd->unallocSpaceBitmap.extLength) {
|
2008-02-08 05:20:36 -07:00
|
|
|
struct udf_bitmap *bitmap =
|
|
|
|
udf_sb_alloc_bitmap(sb, i);
|
|
|
|
map->s_uspace.s_bitmap = bitmap;
|
|
|
|
if (bitmap != NULL) {
|
|
|
|
bitmap->s_extLength =
|
2007-07-21 05:37:18 -06:00
|
|
|
le32_to_cpu(phd->unallocSpaceBitmap.extLength);
|
2008-02-08 05:20:36 -07:00
|
|
|
bitmap->s_extPosition =
|
2007-07-21 05:37:18 -06:00
|
|
|
le32_to_cpu(phd->unallocSpaceBitmap.extPosition);
|
2008-02-08 05:20:30 -07:00
|
|
|
map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_BITMAP;
|
2007-07-21 05:37:18 -06:00
|
|
|
udf_debug("unallocSpaceBitmap (part %d) @ %d\n",
|
2008-02-08 05:20:36 -07:00
|
|
|
i, bitmap->s_extPosition);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (phd->partitionIntegrityTable.extLength)
|
2007-07-21 05:37:18 -06:00
|
|
|
udf_debug("partitionIntegrityTable (part %d)\n", i);
|
2007-07-19 02:47:43 -06:00
|
|
|
if (phd->freedSpaceTable.extLength) {
|
2007-07-21 05:37:18 -06:00
|
|
|
kernel_lb_addr loc = {
|
|
|
|
.logicalBlockNum = le32_to_cpu(phd->freedSpaceTable.extPosition),
|
|
|
|
.partitionReferenceNum = i,
|
|
|
|
};
|
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
map->s_fspace.s_table =
|
2007-07-21 05:37:18 -06:00
|
|
|
udf_iget(sb, loc);
|
2008-02-08 05:20:30 -07:00
|
|
|
if (!map->s_fspace.s_table) {
|
2007-10-17 00:30:08 -06:00
|
|
|
udf_debug("cannot load freedSpaceTable (part %d)\n", i);
|
2007-08-31 00:56:22 -06:00
|
|
|
return 1;
|
|
|
|
}
|
2008-02-08 05:20:36 -07:00
|
|
|
map->s_partition_flags |=
|
|
|
|
UDF_PART_FLAG_FREED_TABLE;
|
2007-07-21 05:37:18 -06:00
|
|
|
udf_debug("freedSpaceTable (part %d) @ %ld\n",
|
2008-02-08 05:20:30 -07:00
|
|
|
i, map->s_fspace.s_table->i_ino);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-07-19 02:47:43 -06:00
|
|
|
if (phd->freedSpaceBitmap.extLength) {
|
2008-02-08 05:20:36 -07:00
|
|
|
struct udf_bitmap *bitmap =
|
|
|
|
udf_sb_alloc_bitmap(sb, i);
|
|
|
|
map->s_fspace.s_bitmap = bitmap;
|
|
|
|
if (bitmap != NULL) {
|
|
|
|
bitmap->s_extLength =
|
2007-07-21 05:37:18 -06:00
|
|
|
le32_to_cpu(phd->freedSpaceBitmap.extLength);
|
2008-02-08 05:20:36 -07:00
|
|
|
bitmap->s_extPosition =
|
2007-07-21 05:37:18 -06:00
|
|
|
le32_to_cpu(phd->freedSpaceBitmap.extPosition);
|
2008-02-08 05:20:30 -07:00
|
|
|
map->s_partition_flags |= UDF_PART_FLAG_FREED_BITMAP;
|
2007-07-21 05:37:18 -06:00
|
|
|
udf_debug("freedSpaceBitmap (part %d) @ %d\n",
|
2008-02-08 05:20:36 -07:00
|
|
|
i, bitmap->s_extPosition);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2008-02-08 05:20:36 -07:00
|
|
|
if (i == sbi->s_partitions)
|
2007-07-19 02:47:43 -06:00
|
|
|
udf_debug("Partition (%d) not found in partition map\n",
|
|
|
|
le16_to_cpu(p->partitionNumber));
|
2008-02-08 05:20:36 -07:00
|
|
|
else
|
2008-02-08 05:20:28 -07:00
|
|
|
udf_debug("Partition (%d:%d type %x) starts at physical %d, "
|
|
|
|
"block length %d\n",
|
|
|
|
le16_to_cpu(p->partitionNumber), i,
|
2008-02-08 05:20:30 -07:00
|
|
|
map->s_partition_type,
|
|
|
|
map->s_partition_root,
|
|
|
|
map->s_partition_len);
|
2007-08-31 00:56:22 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-07-21 05:37:18 -06:00
|
|
|
static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh,
|
|
|
|
kernel_lb_addr *fileset)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct logicalVolDesc *lvd;
|
|
|
|
int i, j, offset;
|
|
|
|
uint8_t type;
|
2008-02-08 05:20:30 -07:00
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
2008-02-08 05:20:36 -07:00
|
|
|
struct genericPartitionMap *gpm;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
lvd = (struct logicalVolDesc *)bh->b_data;
|
|
|
|
|
2008-02-08 05:20:32 -07:00
|
|
|
i = udf_sb_alloc_partition_maps(sb, le32_to_cpu(lvd->numPartitionMaps));
|
|
|
|
if (i != 0)
|
|
|
|
return i;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
for (i = 0, offset = 0;
|
2008-02-08 05:20:30 -07:00
|
|
|
i < sbi->s_partitions && offset < le32_to_cpu(lvd->mapTableLength);
|
2008-02-08 05:20:36 -07: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 02:47:43 -06:00
|
|
|
if (type == 1) {
|
2008-02-08 05:20:36 -07:00
|
|
|
struct genericPartitionMap1 *gpm1 =
|
|
|
|
(struct genericPartitionMap1 *)gpm;
|
2008-02-08 05:20:30 -07: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 02:47:43 -06:00
|
|
|
} else if (type == 2) {
|
2008-02-08 05:20:36 -07: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 16:20:36 -06:00
|
|
|
}
|
2008-02-08 05:20:36 -07:00
|
|
|
} else if (!strncmp(upm2->partIdent.ident,
|
|
|
|
UDF_ID_SPARABLE,
|
|
|
|
strlen(UDF_ID_SPARABLE))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
uint32_t loc;
|
|
|
|
uint16_t ident;
|
|
|
|
struct sparingTable *st;
|
2008-02-08 05:20:36 -07:00
|
|
|
struct sparablePartitionMap *spm =
|
|
|
|
(struct sparablePartitionMap *)gpm;
|
2007-07-21 05:37:18 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
map->s_partition_type = UDF_SPARABLE_MAP15;
|
2008-02-08 05:20:36 -07:00
|
|
|
map->s_type_specific.s_sparing.s_packet_len =
|
|
|
|
le16_to_cpu(spm->packetLength);
|
2007-07-19 02:47:43 -06:00
|
|
|
for (j = 0; j < spm->numSparingTables; j++) {
|
2008-02-08 05:20:36 -07: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;
|
|
|
|
|
|
|
|
if (bh2 != NULL) {
|
|
|
|
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 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-02-08 05:20:30 -07:00
|
|
|
map->s_partition_func = udf_get_pblock_spar15;
|
2007-07-19 02:47:43 -06:00
|
|
|
} else {
|
2008-02-08 05:20:28 -07:00
|
|
|
udf_debug("Unknown ident: %s\n",
|
|
|
|
upm2->partIdent.ident);
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
|
|
|
}
|
2008-02-08 05:20:30 -07:00
|
|
|
map->s_volumeseqnum = le16_to_cpu(upm2->volSeqNum);
|
|
|
|
map->s_partition_num = le16_to_cpu(upm2->partitionNum);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
udf_debug("Partition (%d:%d) type %d on volume %d\n",
|
2008-02-08 05:20:30 -07:00
|
|
|
i, map->s_partition_num, type,
|
|
|
|
map->s_volumeseqnum);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
if (fileset) {
|
2007-07-21 05:37:18 -06:00
|
|
|
long_ad *la = (long_ad *)&(lvd->logicalVolContentsUse[0]);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
*fileset = lelb_to_cpu(la->extLocation);
|
2008-02-08 05:20:28 -07:00
|
|
|
udf_debug("FileSet found in LogicalVolDesc at block=%d, "
|
|
|
|
"partition=%d\n", fileset->logicalBlockNum,
|
2007-07-21 05:37:18 -06:00
|
|
|
fileset->partitionReferenceNum);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
if (lvd->integritySeqExt.extLength)
|
|
|
|
udf_load_logicalvolint(sb, leea_to_cpu(lvd->integritySeqExt));
|
2007-07-21 05:37:18 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* udf_load_logicalvolint
|
|
|
|
*
|
|
|
|
*/
|
2007-07-19 02:47:43 -06:00
|
|
|
static void udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct buffer_head *bh = NULL;
|
|
|
|
uint16_t ident;
|
2008-02-08 05:20:30 -07:00
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
|
|
|
struct logicalVolIntegrityDesc *lvid;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
while (loc.extLength > 0 &&
|
2007-07-19 02:47:43 -06:00
|
|
|
(bh = udf_read_tagged(sb, loc.extLocation,
|
|
|
|
loc.extLocation, &ident)) &&
|
|
|
|
ident == TAG_IDENT_LVID) {
|
2008-02-08 05:20:30 -07:00
|
|
|
sbi->s_lvid_bh = bh;
|
|
|
|
lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
|
2007-07-19 02:47:43 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
if (lvid->nextIntegrityExt.extLength)
|
2008-02-08 05:20:28 -07:00
|
|
|
udf_load_logicalvolint(sb,
|
2008-02-08 05:20:30 -07:00
|
|
|
leea_to_cpu(lvid->nextIntegrityExt));
|
2007-07-19 02:47:43 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
if (sbi->s_lvid_bh != bh)
|
2007-05-08 01:35:16 -06:00
|
|
|
brelse(bh);
|
2005-04-16 16:20:36 -06:00
|
|
|
loc.extLength -= sb->s_blocksize;
|
2007-07-19 02:47:43 -06:00
|
|
|
loc.extLocation++;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-02-08 05:20:30 -07:00
|
|
|
if (sbi->s_lvid_bh != bh)
|
2007-05-08 01:35:16 -06:00
|
|
|
brelse(bh);
|
2005-04-16 16:20:36 -06: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-02-08 05:20:28 -07:00
|
|
|
static int udf_process_sequence(struct super_block *sb, long block,
|
|
|
|
long lastblock, kernel_lb_addr *fileset)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct buffer_head *bh = NULL;
|
|
|
|
struct udf_vds_record vds[VDS_POS_LENGTH];
|
2008-02-08 05:20:36 -07:00
|
|
|
struct udf_vds_record *curr;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct generic_desc *gd;
|
|
|
|
struct volDescPtr *vdp;
|
2007-07-19 02:47:43 -06:00
|
|
|
int done = 0;
|
|
|
|
int i, j;
|
2005-04-16 16:20:36 -06: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);
|
|
|
|
|
|
|
|
/* Read the main descriptor sequence */
|
2007-07-19 02:47:43 -06:00
|
|
|
for (; (!done && block <= lastblock); block++) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
bh = udf_read_tagged(sb, block, block, &ident);
|
2007-07-19 02:47:43 -06:00
|
|
|
if (!bh)
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
/* 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 02:47:43 -06:00
|
|
|
switch (ident) {
|
2007-07-21 05:37:18 -06:00
|
|
|
case TAG_IDENT_PVD: /* ISO 13346 3/10.1 */
|
2008-02-08 05:20:36 -07:00
|
|
|
curr = &vds[VDS_POS_PRIMARY_VOL_DESC];
|
|
|
|
if (vdsn >= curr->volDescSeqNum) {
|
|
|
|
curr->volDescSeqNum = vdsn;
|
|
|
|
curr->block = block;
|
2007-07-19 02:47:43 -06:00
|
|
|
}
|
|
|
|
break;
|
2007-07-21 05:37:18 -06:00
|
|
|
case TAG_IDENT_VDP: /* ISO 13346 3/10.3 */
|
2008-02-08 05:20:36 -07:00
|
|
|
curr = &vds[VDS_POS_VOL_DESC_PTR];
|
|
|
|
if (vdsn >= curr->volDescSeqNum) {
|
|
|
|
curr->volDescSeqNum = vdsn;
|
|
|
|
curr->block = block;
|
2007-07-19 02:47:43 -06:00
|
|
|
|
|
|
|
vdp = (struct volDescPtr *)bh->b_data;
|
2008-02-08 05:20:36 -07:00
|
|
|
next_s = le32_to_cpu(
|
|
|
|
vdp->nextVolDescSeqExt.extLocation);
|
|
|
|
next_e = le32_to_cpu(
|
|
|
|
vdp->nextVolDescSeqExt.extLength);
|
2007-07-19 02:47:43 -06:00
|
|
|
next_e = next_e >> sb->s_blocksize_bits;
|
|
|
|
next_e += next_s;
|
|
|
|
}
|
|
|
|
break;
|
2007-07-21 05:37:18 -06:00
|
|
|
case TAG_IDENT_IUVD: /* ISO 13346 3/10.4 */
|
2008-02-08 05:20:36 -07:00
|
|
|
curr = &vds[VDS_POS_IMP_USE_VOL_DESC];
|
|
|
|
if (vdsn >= curr->volDescSeqNum) {
|
|
|
|
curr->volDescSeqNum = vdsn;
|
|
|
|
curr->block = block;
|
2007-07-19 02:47:43 -06:00
|
|
|
}
|
|
|
|
break;
|
2007-07-21 05:37:18 -06:00
|
|
|
case TAG_IDENT_PD: /* ISO 13346 3/10.5 */
|
2008-02-08 05:20:36 -07:00
|
|
|
curr = &vds[VDS_POS_PARTITION_DESC];
|
|
|
|
if (!curr->block)
|
|
|
|
curr->block = block;
|
2007-07-19 02:47:43 -06:00
|
|
|
break;
|
2007-07-21 05:37:18 -06:00
|
|
|
case TAG_IDENT_LVD: /* ISO 13346 3/10.6 */
|
2008-02-08 05:20:36 -07:00
|
|
|
curr = &vds[VDS_POS_LOGICAL_VOL_DESC];
|
|
|
|
if (vdsn >= curr->volDescSeqNum) {
|
|
|
|
curr->volDescSeqNum = vdsn;
|
|
|
|
curr->block = block;
|
2007-07-19 02:47:43 -06:00
|
|
|
}
|
|
|
|
break;
|
2007-07-21 05:37:18 -06:00
|
|
|
case TAG_IDENT_USD: /* ISO 13346 3/10.8 */
|
2008-02-08 05:20:36 -07:00
|
|
|
curr = &vds[VDS_POS_UNALLOC_SPACE_DESC];
|
|
|
|
if (vdsn >= curr->volDescSeqNum) {
|
|
|
|
curr->volDescSeqNum = vdsn;
|
|
|
|
curr->block = block;
|
2007-07-19 02:47:43 -06:00
|
|
|
}
|
|
|
|
break;
|
2007-07-21 05:37:18 -06:00
|
|
|
case TAG_IDENT_TD: /* ISO 13346 3/10.9 */
|
2007-07-19 02:47:43 -06: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 05:20:36 -07:00
|
|
|
} else
|
2007-07-19 02:47:43 -06:00
|
|
|
done = 1;
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-05-08 01:35:16 -06:00
|
|
|
brelse(bh);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-07-19 02:47:43 -06:00
|
|
|
for (i = 0; i < VDS_POS_LENGTH; i++) {
|
|
|
|
if (vds[i].block) {
|
2008-02-08 05:20:28 -07:00
|
|
|
bh = udf_read_tagged(sb, vds[i].block, vds[i].block,
|
|
|
|
&ident);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-21 05:37:18 -06:00
|
|
|
if (i == VDS_POS_PRIMARY_VOL_DESC) {
|
2005-04-16 16:20:36 -06:00
|
|
|
udf_load_pvoldesc(sb, bh);
|
2007-07-21 05:37:18 -06:00
|
|
|
} else if (i == VDS_POS_LOGICAL_VOL_DESC) {
|
2008-02-08 05:20:33 -07:00
|
|
|
if (udf_load_logicalvol(sb, bh, fileset)) {
|
|
|
|
brelse(bh);
|
|
|
|
return 1;
|
|
|
|
}
|
2007-07-21 05:37:18 -06:00
|
|
|
} else if (i == VDS_POS_PARTITION_DESC) {
|
2005-04-16 16:20:36 -06:00
|
|
|
struct buffer_head *bh2 = NULL;
|
2007-08-31 00:56:22 -06:00
|
|
|
if (udf_load_partdesc(sb, bh)) {
|
|
|
|
brelse(bh);
|
|
|
|
return 1;
|
|
|
|
}
|
2008-02-08 05:20:28 -07:00
|
|
|
for (j = vds[i].block + 1;
|
|
|
|
j < vds[VDS_POS_TERMINATING_DESC].block;
|
|
|
|
j++) {
|
2005-04-16 16:20:36 -06:00
|
|
|
bh2 = udf_read_tagged(sb, j, j, &ident);
|
|
|
|
gd = (struct generic_desc *)bh2->b_data;
|
|
|
|
if (ident == TAG_IDENT_PD)
|
2008-02-08 05:20:28 -07:00
|
|
|
if (udf_load_partdesc(sb,
|
|
|
|
bh2)) {
|
2007-08-31 00:56:22 -06:00
|
|
|
brelse(bh);
|
|
|
|
brelse(bh2);
|
|
|
|
return 1;
|
|
|
|
}
|
2007-05-08 01:35:16 -06:00
|
|
|
brelse(bh2);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
2007-05-08 01:35:16 -06:00
|
|
|
brelse(bh);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* udf_check_valid()
|
|
|
|
*/
|
2007-07-19 02:47:43 -06:00
|
|
|
static int udf_check_valid(struct super_block *sb, int novrs, int silent)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
long block;
|
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
if (novrs) {
|
2005-04-16 16:20:36 -06: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-08 05:20:28 -07:00
|
|
|
else {
|
|
|
|
block = udf_vrs(sb, silent);
|
|
|
|
if (block == -1) {
|
2008-02-08 05:20:30 -07:00
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
2008-02-08 05:20:28 -07:00
|
|
|
udf_debug("Failed to read byte 32768. Assuming open "
|
|
|
|
"disc. Skipping validity check\n");
|
2008-02-08 05:20:30 -07:00
|
|
|
if (!sbi->s_last_block)
|
|
|
|
sbi->s_last_block = udf_get_last_block(sb);
|
2008-02-08 05:20:28 -07:00
|
|
|
return 0;
|
|
|
|
} else
|
|
|
|
return !block;
|
2007-07-21 05:37:18 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-07-21 05:37:18 -06:00
|
|
|
static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct anchorVolDescPtr *anchor;
|
|
|
|
uint16_t ident;
|
|
|
|
struct buffer_head *bh;
|
|
|
|
long main_s, main_e, reserve_s, reserve_e;
|
|
|
|
int i, j;
|
2008-02-08 05:20:30 -07:00
|
|
|
struct udf_sb_info *sbi;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!sb)
|
|
|
|
return 1;
|
2008-02-08 05:20:30 -07:00
|
|
|
sbi = UDF_SB(sb);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
for (i = 0; i < ARRAY_SIZE(sbi->s_anchor); i++) {
|
|
|
|
if (sbi->s_anchor[i] &&
|
|
|
|
(bh = udf_read_tagged(sb, sbi->s_anchor[i],
|
|
|
|
sbi->s_anchor[i], &ident))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
anchor = (struct anchorVolDescPtr *)bh->b_data;
|
|
|
|
|
|
|
|
/* Locate the main sequence */
|
2008-02-08 05:20:36 -07:00
|
|
|
main_s = le32_to_cpu(
|
|
|
|
anchor->mainVolDescSeqExt.extLocation);
|
|
|
|
main_e = le32_to_cpu(
|
|
|
|
anchor->mainVolDescSeqExt.extLength);
|
2005-04-16 16:20:36 -06:00
|
|
|
main_e = main_e >> sb->s_blocksize_bits;
|
|
|
|
main_e += main_s;
|
2006-03-24 04:15:34 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Locate the reserve sequence */
|
2008-02-08 05:20:36 -07:00
|
|
|
reserve_s = le32_to_cpu(
|
|
|
|
anchor->reserveVolDescSeqExt.extLocation);
|
|
|
|
reserve_e = le32_to_cpu(
|
|
|
|
anchor->reserveVolDescSeqExt.extLength);
|
2005-04-16 16:20:36 -06:00
|
|
|
reserve_e = reserve_e >> sb->s_blocksize_bits;
|
|
|
|
reserve_e += reserve_s;
|
|
|
|
|
2007-05-08 01:35:16 -06:00
|
|
|
brelse(bh);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Process the main & reserve sequences */
|
|
|
|
/* responsible for finding the PartitionDesc(s) */
|
2008-02-08 05:20:36 -07:00
|
|
|
if (!(udf_process_sequence(sb, main_s, main_e,
|
|
|
|
fileset) &&
|
|
|
|
udf_process_sequence(sb, reserve_s, reserve_e,
|
|
|
|
fileset)))
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
if (i == ARRAY_SIZE(sbi->s_anchor)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
udf_debug("No Anchor block found\n");
|
|
|
|
return 1;
|
2006-03-24 04:15:34 -07:00
|
|
|
} else
|
2008-02-08 05:20:30 -07:00
|
|
|
udf_debug("Using anchor in block %d\n", sbi->s_anchor[i]);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
for (i = 0; i < sbi->s_partitions; i++) {
|
2007-07-21 05:37:18 -06:00
|
|
|
kernel_lb_addr uninitialized_var(ino);
|
2008-02-08 05:20:30 -07:00
|
|
|
struct udf_part_map *map = &sbi->s_partmaps[i];
|
|
|
|
switch (map->s_partition_type) {
|
2007-07-19 02:47:43 -06:00
|
|
|
case UDF_VIRTUAL_MAP15:
|
|
|
|
case UDF_VIRTUAL_MAP20:
|
2008-02-08 05:20:30 -07:00
|
|
|
if (!sbi->s_last_block) {
|
|
|
|
sbi->s_last_block = udf_get_last_block(sb);
|
2007-07-21 05:37:18 -06:00
|
|
|
udf_find_anchor(sb);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
if (!sbi->s_last_block) {
|
2007-07-21 05:37:18 -06:00
|
|
|
udf_debug("Unable to determine Lastblock (For "
|
2007-10-17 00:30:08 -06:00
|
|
|
"Virtual Partition)\n");
|
2007-07-21 05:37:18 -06:00
|
|
|
return 1;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
for (j = 0; j < sbi->s_partitions; j++) {
|
|
|
|
struct udf_part_map *map2 = &sbi->s_partmaps[j];
|
2007-10-17 00:30:08 -06:00
|
|
|
if (j != i &&
|
2008-02-08 05:20:36 -07:00
|
|
|
map->s_volumeseqnum ==
|
|
|
|
map2->s_volumeseqnum &&
|
|
|
|
map->s_partition_num ==
|
|
|
|
map2->s_partition_num) {
|
2007-07-21 05:37:18 -06:00
|
|
|
ino.partitionReferenceNum = j;
|
2008-02-08 05:20:36 -07:00
|
|
|
ino.logicalBlockNum =
|
|
|
|
sbi->s_last_block -
|
|
|
|
map2->s_partition_root;
|
2007-07-21 05:37:18 -06:00
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-07-21 05:37:18 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
if (j == sbi->s_partitions)
|
2007-07-21 05:37:18 -06:00
|
|
|
return 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
sbi->s_vat_inode = udf_iget(sb, ino);
|
|
|
|
if (!sbi->s_vat_inode)
|
2007-07-21 05:37:18 -06:00
|
|
|
return 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
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) {
|
2007-07-21 05:37:18 -06:00
|
|
|
uint32_t pos;
|
2008-02-08 05:20:36 -07:00
|
|
|
struct virtualAllocationTable20 *vat20;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
pos = udf_block_map(sbi->s_vat_inode, 0);
|
2007-07-21 05:37:18 -06:00
|
|
|
bh = sb_bread(sb, pos);
|
|
|
|
if (!bh)
|
|
|
|
return 1;
|
2008-02-08 05:20:36 -07:00
|
|
|
vat20 = (struct virtualAllocationTable20 *)
|
|
|
|
bh->b_data +
|
|
|
|
udf_ext0_offset(sbi->s_vat_inode);
|
2008-02-08 05:20:30 -07:00
|
|
|
map->s_type_specific.s_virtual.s_start_offset =
|
2008-02-08 05:20:36 -07:00
|
|
|
le16_to_cpu(vat20->lengthHeader) +
|
2008-02-08 05:20:30 -07:00
|
|
|
udf_ext0_offset(sbi->s_vat_inode);
|
2008-02-08 05:20:36 -07: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;
|
2007-07-21 05:37:18 -06:00
|
|
|
brelse(bh);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-02-08 05:20:30 -07:00
|
|
|
map->s_partition_root = udf_get_pblock(sb, 0, i, 0);
|
|
|
|
map->s_partition_len =
|
|
|
|
sbi->s_partmaps[ino.partitionReferenceNum].
|
|
|
|
s_partition_len;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void udf_open_lvid(struct super_block *sb)
|
|
|
|
{
|
2008-02-08 05:20:30 -07:00
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
|
|
|
struct buffer_head *bh = sbi->s_lvid_bh;
|
|
|
|
if (bh) {
|
2005-04-16 16:20:36 -06:00
|
|
|
int i;
|
|
|
|
kernel_timestamp cpu_time;
|
2008-02-08 05:20:36 -07:00
|
|
|
struct logicalVolIntegrityDesc *lvid =
|
|
|
|
(struct logicalVolIntegrityDesc *)bh->b_data;
|
|
|
|
struct logicalVolIntegrityDescImpUse *lvidiu =
|
|
|
|
udf_sb_lvidiu(sbi);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
|
|
|
|
lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (udf_time_to_stamp(&cpu_time, CURRENT_TIME))
|
2008-02-08 05:20:30 -07:00
|
|
|
lvid->recordingDateAndTime = cpu_to_lets(cpu_time);
|
|
|
|
lvid->integrityType = LVID_INTEGRITY_TYPE_OPEN;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:36 -07:00
|
|
|
lvid->descTag.descCRC = cpu_to_le16(
|
|
|
|
udf_crc((char *)lvid + sizeof(tag),
|
|
|
|
le16_to_cpu(lvid->descTag.descCRCLength),
|
|
|
|
0));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
lvid->descTag.tagChecksum = 0;
|
2007-07-19 02:47:43 -06:00
|
|
|
for (i = 0; i < 16; i++)
|
2005-04-16 16:20:36 -06:00
|
|
|
if (i != 4)
|
2008-02-08 05:20:30 -07:00
|
|
|
lvid->descTag.tagChecksum +=
|
|
|
|
((uint8_t *) &(lvid->descTag))[i];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
mark_buffer_dirty(bh);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void udf_close_lvid(struct super_block *sb)
|
|
|
|
{
|
2007-07-21 05:37:18 -06:00
|
|
|
kernel_timestamp cpu_time;
|
|
|
|
int i;
|
2008-02-08 05:20:30 -07:00
|
|
|
struct udf_sb_info *sbi = UDF_SB(sb);
|
|
|
|
struct buffer_head *bh = sbi->s_lvid_bh;
|
|
|
|
struct logicalVolIntegrityDesc *lvid;
|
2007-07-21 05:37:18 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
if (!bh)
|
|
|
|
return;
|
|
|
|
|
|
|
|
lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
|
|
|
|
|
|
|
|
if (lvid->integrityType == LVID_INTEGRITY_TYPE_OPEN) {
|
2008-02-08 05:20:36 -07:00
|
|
|
struct logicalVolIntegrityDescImpUse *lvidiu =
|
|
|
|
udf_sb_lvidiu(sbi);
|
2008-02-08 05:20:30 -07:00
|
|
|
lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
|
|
|
|
lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (udf_time_to_stamp(&cpu_time, CURRENT_TIME))
|
2008-02-08 05:20:30 -07:00
|
|
|
lvid->recordingDateAndTime = cpu_to_lets(cpu_time);
|
|
|
|
if (UDF_MAX_WRITE_VERSION > le16_to_cpu(lvidiu->maxUDFWriteRev))
|
2008-02-08 05:20:36 -07:00
|
|
|
lvidiu->maxUDFWriteRev =
|
|
|
|
cpu_to_le16(UDF_MAX_WRITE_VERSION);
|
2008-02-08 05:20:30 -07:00
|
|
|
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);
|
|
|
|
|
2008-02-08 05:20:36 -07:00
|
|
|
lvid->descTag.descCRC = cpu_to_le16(
|
|
|
|
udf_crc((char *)lvid + sizeof(tag),
|
|
|
|
le16_to_cpu(lvid->descTag.descCRCLength),
|
|
|
|
0));
|
2008-02-08 05:20:30 -07:00
|
|
|
|
|
|
|
lvid->descTag.tagChecksum = 0;
|
2007-07-19 02:47:43 -06:00
|
|
|
for (i = 0; i < 16; i++)
|
2005-04-16 16:20:36 -06:00
|
|
|
if (i != 4)
|
2008-02-08 05:20:30 -07:00
|
|
|
lvid->descTag.tagChecksum +=
|
|
|
|
((uint8_t *)&(lvid->descTag))[i];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
mark_buffer_dirty(bh);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-08 05:20:33 -07:00
|
|
|
static void udf_sb_free_bitmap(struct udf_bitmap *bitmap)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int nr_groups = bitmap->s_nr_groups;
|
2008-02-08 05:20:36 -07:00
|
|
|
int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) *
|
|
|
|
nr_groups);
|
2008-02-08 05:20:33 -07: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);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* udf_read_super
|
|
|
|
*
|
|
|
|
* PURPOSE
|
|
|
|
* Complete the specified super block.
|
|
|
|
*
|
|
|
|
* PRE-CONDITIONS
|
|
|
|
* sb Pointer to superblock to complete - never NULL.
|
|
|
|
* sb->s_dev Device to read suberblock from.
|
|
|
|
* options Pointer to mount options.
|
|
|
|
* silent Silent flag.
|
|
|
|
*
|
|
|
|
* HISTORY
|
|
|
|
* July 1, 1997 - Andrew E. Mileski
|
|
|
|
* Written, tested, and released.
|
|
|
|
*/
|
|
|
|
static int udf_fill_super(struct super_block *sb, void *options, int silent)
|
|
|
|
{
|
|
|
|
int i;
|
2007-07-19 02:47:43 -06:00
|
|
|
struct inode *inode = NULL;
|
2005-04-16 16:20:36 -06: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 05:20:30 -07:00
|
|
|
sbi = kzalloc(sizeof(struct udf_sb_info), GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!sbi)
|
|
|
|
return -ENOMEM;
|
2007-07-21 05:37:18 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
sb->s_fs_info = sbi;
|
|
|
|
|
2006-03-23 04:00:44 -07:00
|
|
|
mutex_init(&sbi->s_alloc_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!udf_parse_options((char *)options, &uopt))
|
|
|
|
goto error_out;
|
|
|
|
|
|
|
|
if (uopt.flags & (1 << UDF_FLAG_UTF8) &&
|
2007-07-19 02:47:43 -06:00
|
|
|
uopt.flags & (1 << UDF_FLAG_NLS_MAP)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
udf_error(sb, "udf_read_super",
|
2007-07-19 02:47:43 -06:00
|
|
|
"utf8 cannot be combined with iocharset\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
#ifdef CONFIG_UDF_NLS
|
2007-07-19 02:47:43 -06:00
|
|
|
if ((uopt.flags & (1 << UDF_FLAG_NLS_MAP)) && !uopt.nls_map) {
|
2005-04-16 16:20:36 -06: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 05:20:30 -07: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 16:20:36 -06:00
|
|
|
|
|
|
|
/* Set the block size for all transfers */
|
|
|
|
if (!udf_set_blocksize(sb, uopt.blocksize))
|
|
|
|
goto error_out;
|
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
if (uopt.session == 0xFFFFFFFF)
|
2008-02-08 05:20:30 -07:00
|
|
|
sbi->s_session = udf_get_last_session(sb);
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
2008-02-08 05:20:30 -07:00
|
|
|
sbi->s_session = uopt.session;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
udf_debug("Multi-session=%d\n", sbi->s_session);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
sbi->s_last_block = uopt.lastblock;
|
|
|
|
sbi->s_anchor[0] = sbi->s_anchor[1] = 0;
|
|
|
|
sbi->s_anchor[2] = uopt.anchor;
|
|
|
|
sbi->s_anchor[3] = 256;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:28 -07: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 02:47:43 -06:00
|
|
|
goto error_out;
|
2005-04-16 16:20:36 -06: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;
|
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
if (udf_load_partition(sb, &fileset)) {
|
2008-02-08 05:20:28 -07:00
|
|
|
printk(KERN_WARNING "UDF-fs: No partition found (1)\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
udf_debug("Lastblock=%d\n", sbi->s_last_block);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
if (sbi->s_lvid_bh) {
|
2008-02-08 05:20:36 -07:00
|
|
|
struct logicalVolIntegrityDescImpUse *lvidiu =
|
|
|
|
udf_sb_lvidiu(sbi);
|
2008-02-08 05:20:30 -07:00
|
|
|
uint16_t minUDFReadRev = le16_to_cpu(lvidiu->minUDFReadRev);
|
|
|
|
uint16_t minUDFWriteRev = le16_to_cpu(lvidiu->minUDFWriteRev);
|
2008-02-08 05:20:36 -07:00
|
|
|
/* uint16_t maxUDFWriteRev =
|
|
|
|
le16_to_cpu(lvidiu->maxUDFWriteRev); */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
if (minUDFReadRev > UDF_MAX_READ_VERSION) {
|
2008-02-08 05:20:36 -07:00
|
|
|
printk(KERN_ERR "UDF-fs: minUDFReadRev=%x "
|
|
|
|
"(max is %x)\n",
|
2008-02-08 05:20:30 -07:00
|
|
|
le16_to_cpu(lvidiu->minUDFReadRev),
|
2007-07-19 02:47:43 -06:00
|
|
|
UDF_MAX_READ_VERSION);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto error_out;
|
2008-02-08 05:20:36 -07:00
|
|
|
} else if (minUDFWriteRev > UDF_MAX_WRITE_VERSION)
|
2005-04-16 16:20:36 -06:00
|
|
|
sb->s_flags |= MS_RDONLY;
|
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
sbi->s_udfrev = minUDFWriteRev;
|
2005-04-16 16:20:36 -06: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 05:20:30 -07:00
|
|
|
if (!sbi->s_partitions) {
|
2008-02-08 05:20:28 -07:00
|
|
|
printk(KERN_WARNING "UDF-fs: No partition found (2)\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
|
2008-02-08 05:20:36 -07: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 02:59:41 -06:00
|
|
|
sb->s_flags |= MS_RDONLY;
|
2006-10-05 13:17:50 -06:00
|
|
|
}
|
2006-09-29 02:59:41 -06:00
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
if (udf_find_fileset(sb, &fileset, &rootdir)) {
|
2008-02-08 05:20:28 -07:00
|
|
|
printk(KERN_WARNING "UDF-fs: No fileset found\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
if (!silent) {
|
2005-04-16 16:20:36 -06:00
|
|
|
kernel_timestamp ts;
|
2008-02-08 05:20:30 -07:00
|
|
|
udf_time_to_stamp(&ts, sbi->s_record_time);
|
2007-07-21 05:37:18 -06:00
|
|
|
udf_info("UDF %s (%s) Mounting volume '%s', "
|
|
|
|
"timestamp %04u/%02u/%02u %02u:%02u (%x)\n",
|
|
|
|
UDFFS_VERSION, UDFFS_DATE,
|
2008-02-08 05:20:30 -07:00
|
|
|
sbi->s_volume_ident, ts.year, ts.month, ts.day,
|
|
|
|
ts.hour, ts.minute, ts.typeAndTimezone);
|
2005-04-16 16:20:36 -06: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 02:47:43 -06:00
|
|
|
inode = udf_iget(sb, rootdir);
|
|
|
|
if (!inode) {
|
2008-02-08 05:20:36 -07:00
|
|
|
printk(KERN_ERR "UDF-fs: Error in udf_iget, block=%d, "
|
|
|
|
"partition=%d\n",
|
2007-07-19 02:47:43 -06:00
|
|
|
rootdir.logicalBlockNum, rootdir.partitionReferenceNum);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate a dentry for the root inode */
|
|
|
|
sb->s_root = d_alloc_root(inode);
|
2007-07-19 02:47:43 -06:00
|
|
|
if (!sb->s_root) {
|
2008-02-08 05:20:28 -07:00
|
|
|
printk(KERN_ERR "UDF-fs: Couldn't allocate root dentry\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
iput(inode);
|
|
|
|
goto error_out;
|
|
|
|
}
|
2007-05-08 01:35:21 -06:00
|
|
|
sb->s_maxbytes = MAX_LFS_FILESIZE;
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
|
2007-07-21 05:37:18 -06:00
|
|
|
error_out:
|
2008-02-08 05:20:30 -07:00
|
|
|
if (sbi->s_vat_inode)
|
|
|
|
iput(sbi->s_vat_inode);
|
|
|
|
if (sbi->s_partitions) {
|
|
|
|
struct udf_part_map *map = &sbi->s_partmaps[sbi->s_partition];
|
|
|
|
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)
|
2008-02-08 05:20:33 -07:00
|
|
|
udf_sb_free_bitmap(map->s_uspace.s_bitmap);
|
2008-02-08 05:20:30 -07:00
|
|
|
if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
|
2008-02-08 05:20:33 -07:00
|
|
|
udf_sb_free_bitmap(map->s_fspace.s_bitmap);
|
2008-02-08 05:20:30 -07:00
|
|
|
if (map->s_partition_type == UDF_SPARABLE_MAP15)
|
2007-07-19 02:47:43 -06:00
|
|
|
for (i = 0; i < 4; i++)
|
2008-02-08 05:20:36 -07:00
|
|
|
brelse(map->s_type_specific.s_sparing.
|
|
|
|
s_spar_map[i]);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
#ifdef CONFIG_UDF_NLS
|
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
|
2008-02-08 05:20:30 -07:00
|
|
|
unload_nls(sbi->s_nls_map);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
if (!(sb->s_flags & MS_RDONLY))
|
|
|
|
udf_close_lvid(sb);
|
2008-02-08 05:20:30 -07:00
|
|
|
brelse(sbi->s_lvid_bh);
|
|
|
|
|
|
|
|
kfree(sbi->s_partmaps);
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree(sbi);
|
|
|
|
sb->s_fs_info = NULL;
|
2007-07-21 05:37:18 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void udf_error(struct super_block *sb, const char *function,
|
2007-07-19 02:47:43 -06:00
|
|
|
const char *fmt, ...)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
if (!(sb->s_flags & MS_RDONLY)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* mark sb error */
|
|
|
|
sb->s_dirt = 1;
|
|
|
|
}
|
|
|
|
va_start(args, fmt);
|
2006-12-06 21:37:04 -07:00
|
|
|
vsnprintf(error_buf, sizeof(error_buf), fmt, args);
|
2005-04-16 16:20:36 -06:00
|
|
|
va_end(args);
|
2008-02-08 05:20:28 -07:00
|
|
|
printk(KERN_CRIT "UDF-fs error (device %s): %s: %s\n",
|
2007-07-21 05:37:18 -06:00
|
|
|
sb->s_id, function, error_buf);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void udf_warning(struct super_block *sb, const char *function,
|
2007-07-19 02:47:43 -06:00
|
|
|
const char *fmt, ...)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
va_start(args, fmt);
|
2006-12-06 21:37:04 -07:00
|
|
|
vsnprintf(error_buf, sizeof(error_buf), fmt, args);
|
2005-04-16 16:20:36 -06:00
|
|
|
va_end(args);
|
|
|
|
printk(KERN_WARNING "UDF-fs warning (device %s): %s: %s\n",
|
2007-07-19 02:47:43 -06:00
|
|
|
sb->s_id, function, error_buf);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* udf_put_super
|
|
|
|
*
|
|
|
|
* PURPOSE
|
|
|
|
* Prepare for destruction of the superblock.
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Called before the filesystem is unmounted.
|
|
|
|
*
|
|
|
|
* HISTORY
|
|
|
|
* July 1, 1997 - Andrew E. Mileski
|
|
|
|
* Written, tested, and released.
|
|
|
|
*/
|
2007-07-19 02:47:43 -06:00
|
|
|
static void udf_put_super(struct super_block *sb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int i;
|
2008-02-08 05:20:30 -07:00
|
|
|
struct udf_sb_info *sbi;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
sbi = UDF_SB(sb);
|
|
|
|
if (sbi->s_vat_inode)
|
|
|
|
iput(sbi->s_vat_inode);
|
|
|
|
if (sbi->s_partitions) {
|
|
|
|
struct udf_part_map *map = &sbi->s_partmaps[sbi->s_partition];
|
|
|
|
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)
|
2008-02-08 05:20:33 -07:00
|
|
|
udf_sb_free_bitmap(map->s_uspace.s_bitmap);
|
2008-02-08 05:20:30 -07:00
|
|
|
if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
|
2008-02-08 05:20:33 -07:00
|
|
|
udf_sb_free_bitmap(map->s_fspace.s_bitmap);
|
2008-02-08 05:20:30 -07:00
|
|
|
if (map->s_partition_type == UDF_SPARABLE_MAP15)
|
2007-07-19 02:47:43 -06:00
|
|
|
for (i = 0; i < 4; i++)
|
2008-02-08 05:20:36 -07:00
|
|
|
brelse(map->s_type_specific.s_sparing.
|
|
|
|
s_spar_map[i]);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
#ifdef CONFIG_UDF_NLS
|
|
|
|
if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
|
2008-02-08 05:20:30 -07:00
|
|
|
unload_nls(sbi->s_nls_map);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
if (!(sb->s_flags & MS_RDONLY))
|
|
|
|
udf_close_lvid(sb);
|
2008-02-08 05:20:30 -07:00
|
|
|
brelse(sbi->s_lvid_bh);
|
|
|
|
kfree(sbi->s_partmaps);
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree(sb->s_fs_info);
|
|
|
|
sb->s_fs_info = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* udf_stat_fs
|
|
|
|
*
|
|
|
|
* PURPOSE
|
|
|
|
* Return info about the filesystem.
|
|
|
|
*
|
|
|
|
* DESCRIPTION
|
|
|
|
* Called by sys_statfs()
|
|
|
|
*
|
|
|
|
* HISTORY
|
|
|
|
* July 1, 1997 - Andrew E. Mileski
|
|
|
|
* Written, tested, and released.
|
|
|
|
*/
|
2007-07-19 02:47:43 -06:00
|
|
|
static int udf_statfs(struct dentry *dentry, struct kstatfs *buf)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-06-23 03:02:58 -06:00
|
|
|
struct super_block *sb = dentry->d_sb;
|
2008-02-08 05:20:30 -07: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 03:02:58 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
buf->f_type = UDF_SUPER_MAGIC;
|
|
|
|
buf->f_bsize = sb->s_blocksize;
|
2008-02-08 05:20:30 -07:00
|
|
|
buf->f_blocks = sbi->s_partmaps[sbi->s_partition].s_partition_len;
|
2005-04-16 16:20:36 -06:00
|
|
|
buf->f_bfree = udf_count_free(sb);
|
|
|
|
buf->f_bavail = buf->f_bfree;
|
2008-02-08 05:20:30 -07:00
|
|
|
buf->f_files = (lvidiu != NULL ? (le32_to_cpu(lvidiu->numFiles) +
|
|
|
|
le32_to_cpu(lvidiu->numDirs)) : 0)
|
|
|
|
+ buf->f_bfree;
|
2005-04-16 16:20:36 -06:00
|
|
|
buf->f_ffree = buf->f_bfree;
|
|
|
|
/* __kernel_fsid_t f_fsid */
|
2007-07-19 02:47:43 -06:00
|
|
|
buf->f_namelen = UDF_NAME_LEN - 2;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned char udf_bitmap_lookup[16] = {
|
|
|
|
0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4
|
|
|
|
};
|
|
|
|
|
2008-02-08 05:20:36 -07:00
|
|
|
static unsigned int udf_count_free_bitmap(struct super_block *sb,
|
|
|
|
struct udf_bitmap *bitmap)
|
2005-04-16 16:20:36 -06: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 value;
|
|
|
|
uint8_t *ptr;
|
|
|
|
uint16_t ident;
|
|
|
|
struct spaceBitmapDesc *bm;
|
|
|
|
|
|
|
|
lock_kernel();
|
|
|
|
|
|
|
|
loc.logicalBlockNum = bitmap->s_extPosition;
|
2008-02-08 05:20:30 -07:00
|
|
|
loc.partitionReferenceNum = UDF_SB(sb)->s_partition;
|
2005-04-16 16:20:36 -06:00
|
|
|
bh = udf_read_ptagged(sb, loc, 0, &ident);
|
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
if (!bh) {
|
2005-04-16 16:20:36 -06:00
|
|
|
printk(KERN_ERR "udf: udf_count_free failed\n");
|
|
|
|
goto out;
|
2007-07-19 02:47:43 -06:00
|
|
|
} else if (ident != TAG_IDENT_SBD) {
|
2007-05-08 01:35:16 -06:00
|
|
|
brelse(bh);
|
2005-04-16 16:20:36 -06: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 05:37:18 -06:00
|
|
|
index = sizeof(struct spaceBitmapDesc); /* offset in first block only */
|
|
|
|
ptr = (uint8_t *)bh->b_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-19 02:47:43 -06:00
|
|
|
while (bytes > 0) {
|
|
|
|
while ((bytes > 0) && (index < sb->s_blocksize)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
value = ptr[index];
|
2007-07-19 02:47:43 -06:00
|
|
|
accum += udf_bitmap_lookup[value & 0x0f];
|
|
|
|
accum += udf_bitmap_lookup[value >> 4];
|
2005-04-16 16:20:36 -06:00
|
|
|
index++;
|
|
|
|
bytes--;
|
|
|
|
}
|
2007-07-19 02:47:43 -06:00
|
|
|
if (bytes) {
|
2007-05-08 01:35:16 -06:00
|
|
|
brelse(bh);
|
2005-04-16 16:20:36 -06:00
|
|
|
newblock = udf_get_lb_pblock(sb, loc, ++block);
|
|
|
|
bh = udf_tread(sb, newblock);
|
2007-07-19 02:47:43 -06:00
|
|
|
if (!bh) {
|
2005-04-16 16:20:36 -06:00
|
|
|
udf_debug("read failed\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
index = 0;
|
2007-07-21 05:37:18 -06:00
|
|
|
ptr = (uint8_t *)bh->b_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
2007-05-08 01:35:16 -06:00
|
|
|
brelse(bh);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-21 05:37:18 -06:00
|
|
|
out:
|
2005-04-16 16:20:36 -06:00
|
|
|
unlock_kernel();
|
|
|
|
|
|
|
|
return accum;
|
|
|
|
}
|
|
|
|
|
2008-02-08 05:20:36 -07:00
|
|
|
static unsigned int udf_count_free_table(struct super_block *sb,
|
|
|
|
struct inode *table)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
unsigned int accum = 0;
|
2007-05-08 01:35:14 -06:00
|
|
|
uint32_t elen;
|
|
|
|
kernel_lb_addr eloc;
|
2005-04-16 16:20:36 -06:00
|
|
|
int8_t etype;
|
2007-05-08 01:35:14 -06:00
|
|
|
struct extent_position epos;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
lock_kernel();
|
|
|
|
|
2007-05-08 01:35:14 -06:00
|
|
|
epos.block = UDF_I_LOCATION(table);
|
|
|
|
epos.offset = sizeof(struct unallocSpaceEntry);
|
|
|
|
epos.bh = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:28 -07:00
|
|
|
while ((etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
|
2005-04-16 16:20:36 -06:00
|
|
|
accum += (elen >> table->i_sb->s_blocksize_bits);
|
2008-02-08 05:20:28 -07:00
|
|
|
|
2007-05-08 01:35:16 -06:00
|
|
|
brelse(epos.bh);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
unlock_kernel();
|
|
|
|
|
|
|
|
return accum;
|
|
|
|
}
|
2007-07-19 02:47:43 -06:00
|
|
|
|
|
|
|
static unsigned int udf_count_free(struct super_block *sb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
unsigned int accum = 0;
|
2008-02-08 05:20:30 -07:00
|
|
|
struct udf_sb_info *sbi;
|
|
|
|
struct udf_part_map *map;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
sbi = UDF_SB(sb);
|
|
|
|
if (sbi->s_lvid_bh) {
|
2008-02-08 05:20:36 -07:00
|
|
|
struct logicalVolIntegrityDesc *lvid =
|
|
|
|
(struct logicalVolIntegrityDesc *)
|
|
|
|
sbi->s_lvid_bh->b_data;
|
2008-02-08 05:20:30 -07:00
|
|
|
if (le32_to_cpu(lvid->numOfPartitions) > sbi->s_partition) {
|
2008-02-08 05:20:36 -07:00
|
|
|
accum = le32_to_cpu(
|
|
|
|
lvid->freeSpaceTable[sbi->s_partition]);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (accum == 0xFFFFFFFF)
|
|
|
|
accum = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (accum)
|
|
|
|
return accum;
|
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
map = &sbi->s_partmaps[sbi->s_partition];
|
|
|
|
if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) {
|
2007-07-21 05:37:18 -06:00
|
|
|
accum += udf_count_free_bitmap(sb,
|
2008-02-08 05:20:30 -07:00
|
|
|
map->s_uspace.s_bitmap);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-02-08 05:20:30 -07:00
|
|
|
if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) {
|
2007-07-21 05:37:18 -06:00
|
|
|
accum += udf_count_free_bitmap(sb,
|
2008-02-08 05:20:30 -07:00
|
|
|
map->s_fspace.s_bitmap);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
if (accum)
|
|
|
|
return accum;
|
|
|
|
|
2008-02-08 05:20:30 -07:00
|
|
|
if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) {
|
2007-07-21 05:37:18 -06:00
|
|
|
accum += udf_count_free_table(sb,
|
2008-02-08 05:20:30 -07:00
|
|
|
map->s_uspace.s_table);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-02-08 05:20:30 -07:00
|
|
|
if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) {
|
2007-07-21 05:37:18 -06:00
|
|
|
accum += udf_count_free_table(sb,
|
2008-02-08 05:20:30 -07:00
|
|
|
map->s_fspace.s_table);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return accum;
|
|
|
|
}
|