patch-2.4.10 linux/fs/ntfs/fs.c
Next file: linux/fs/ntfs/inode.c
Previous file: linux/fs/ntfs/dir.c
Back to the patch index
Back to the overall index
- Lines: 974
- Date:
Tue Sep 11 17:02:46 2001
- Orig file:
v2.4.9/linux/fs/ntfs/fs.c
- Orig date:
Mon Aug 27 12:41:46 2001
diff -u --recursive --new-file v2.4.9/linux/fs/ntfs/fs.c linux/fs/ntfs/fs.c
@@ -11,7 +11,7 @@
*/
#include <linux/config.h>
-
+#include <linux/errno.h>
#include "ntfstypes.h"
#include "struct.h"
#include "util.h"
@@ -21,16 +21,15 @@
#include "support.h"
#include "macros.h"
#include "sysctl.h"
+#include "attr.h"
#include <linux/module.h>
#include <asm/uaccess.h>
#include <linux/locks.h>
#include <linux/init.h>
#include <linux/smp_lock.h>
#include <asm/page.h>
-
-#ifndef NLS_MAX_CHARSET_SIZE
#include <linux/nls.h>
-#endif
+#include <linux/ntfs_fs.h>
/* Forward declarations. */
static struct inode_operations ntfs_dir_inode_operations;
@@ -67,6 +66,7 @@
{
int error;
ntfs_io io;
+ ntfs_attribute *attr;
ntfs_inode *ino = NTFS_LINO2NINO(filp->f_dentry->d_inode);
/* Inode is not properly initialized. */
@@ -75,11 +75,14 @@
ntfs_debug(DEBUG_OTHER, "ntfs_read %x, %Lx, %x ->",
(unsigned)ino->i_number, (unsigned long long)*off,
(unsigned)count);
+ attr = ntfs_find_attr(ino, ino->vol->at_data, NULL);
/* Inode has no unnamed data attribute. */
- if(!ntfs_find_attr(ino, ino->vol->at_data, NULL)) {
+ if (!attr) {
ntfs_debug(DEBUG_OTHER, "ntfs_read: $DATA not found!\n");
return -EINVAL;
}
+ if (attr->flags & ATTR_IS_ENCRYPTED)
+ return -EACCES;
/* Read the data. */
io.fn_put = ntfs_putuser;
io.fn_get = 0;
@@ -98,175 +101,226 @@
}
#ifdef CONFIG_NTFS_RW
-static ssize_t ntfs_write(struct file *filp, const char* buf, size_t count,
- loff_t *pos)
+static ssize_t ntfs_write(struct file *filp, const char *buf, size_t count,
+ loff_t *pos)
{
- int ret;
+ int err;
+ struct inode *vfs_ino = filp->f_dentry->d_inode;
+ ntfs_inode *ntfs_ino = NTFS_LINO2NINO(vfs_ino);
+ ntfs_attribute *data;
ntfs_io io;
- struct inode *inode = filp->f_dentry->d_inode;
- ntfs_inode *ino = NTFS_LINO2NINO(inode);
struct ntfs_getuser_update_vm_s param;
- if (!ino)
+ if (!ntfs_ino)
return -EINVAL;
- ntfs_debug(DEBUG_LINUX, "ntfs_write %x, %x, %x ->\n",
- (unsigned)ino->i_number, (unsigned)*pos, (unsigned)count);
+ ntfs_debug(DEBUG_LINUX, __FUNCTION__ "(): Entering for inode 0x%lx, "
+ "*pos 0x%Lx, count 0x%x.\n", ntfs_ino->i_number, *pos,
+ count);
/* Allows to lock fs ro at any time. */
- if (inode->i_sb->s_flags & MS_RDONLY)
- return -ENOSPC;
- if (!ntfs_find_attr(ino, ino->vol->at_data, NULL))
+ if (vfs_ino->i_sb->s_flags & MS_RDONLY)
+ return -EROFS;
+ data = ntfs_find_attr(ntfs_ino, ntfs_ino->vol->at_data, NULL);
+ if (!data)
return -EINVAL;
/* Evaluating O_APPEND is the file system's job... */
if (filp->f_flags & O_APPEND)
- *pos = inode->i_size;
+ *pos = vfs_ino->i_size;
+ if (!data->resident && *pos + count > data->allocated) {
+ err = ntfs_extend_attr(ntfs_ino, data, *pos + count);
+ if (err < 0)
+ return err;
+ }
param.user = buf;
- param.ino = inode;
+ param.ino = vfs_ino;
param.off = *pos;
io.fn_put = 0;
io.fn_get = ntfs_getuser_update_vm;
io.param = ¶m;
io.size = count;
- ret = ntfs_write_attr(ino, ino->vol->at_data, NULL, *pos, &io);
- ntfs_debug(DEBUG_LINUX, "write -> %x\n", ret);
- if (ret < 0)
- return -EINVAL;
- *pos += io.size;
- if (*pos > inode->i_size)
- inode->i_size = *pos;
- mark_inode_dirty(filp->f_dentry->d_inode);
- return io.size;
+ io.do_read = 0;
+ err = ntfs_readwrite_attr(ntfs_ino, data, *pos, &io);
+ ntfs_debug(DEBUG_LINUX, __FUNCTION__ "(): Returning %i\n", -err);
+ if (!err) {
+ *pos += io.size;
+ if (*pos > vfs_ino->i_size)
+ vfs_ino->i_size = *pos;
+ mark_inode_dirty(vfs_ino);
+ return io.size;
+ }
+ return err;
}
#endif
-struct ntfs_filldir{
+struct ntfs_filldir {
struct inode *dir;
filldir_t filldir;
unsigned int type;
- ntfs_u32 ph,pl;
+ u32 ph, pl;
void *dirent;
char *name;
int namelen;
+ int ret_code;
};
-
+
static int ntfs_printcb(ntfs_u8 *entry, void *param)
{
+ unsigned long inum = NTFS_GETU64(entry) & 0xffffffffffff;
struct ntfs_filldir *nf = param;
- int flags = NTFS_GETU8(entry + 0x51);
- int show_hidden = 0;
- int length = NTFS_GETU8(entry + 0x50);
- int inum = NTFS_GETU32(entry);
- int error;
-#ifdef NTFS_NGT_NT_DOES_LOWER
- int i, to_lower = 0;
-#endif
+ u32 flags = NTFS_GETU32(entry + 0x48);
+ char show_sys_files = 0;
+ u8 name_len = NTFS_GETU8(entry + 0x50);
+ u8 name_type = NTFS_GETU8(entry + 0x51);
+ int err;
+ unsigned file_type;
+
switch (nf->type) {
case ngt_dos:
/* Don't display long names. */
- if ((flags & 2) == 0)
+ if (!(name_type & 2))
return 0;
break;
case ngt_nt:
/* Don't display short-only names. */
- switch (flags & 3) {
- case 2:
+ if ((name_type & 3) == 2)
return 0;
-#ifdef NTFS_NGT_NT_DOES_LOWER
- case 3:
- to_lower = 1;
-#endif
- }
break;
case ngt_posix:
break;
case ngt_full:
- show_hidden = 1;
+ show_sys_files = 1;
break;
+ default:
+ BUG();
}
- if (!show_hidden && ((NTFS_GETU8(entry + 0x48) & 2) == 2)) {
- ntfs_debug(DEBUG_OTHER, "Skipping hidden file\n");
- return 0;
- }
- nf->name = 0;
- if (ntfs_encodeuni(NTFS_INO2VOL(nf->dir), (ntfs_u16*)(entry + 0x52),
- length, &nf->name, &nf->namelen)){
- ntfs_debug(DEBUG_OTHER, "Skipping unrepresentable file\n");
- if (nf->name)
- ntfs_free(nf->name);
- return 0;
+ err = ntfs_encodeuni(NTFS_INO2VOL(nf->dir), (ntfs_u16*)(entry + 0x52),
+ name_len, &nf->name, &nf->namelen);
+ if (err) {
+ ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Skipping "
+ "unrepresentable file.\n");
+ err = 0;
+ goto err_ret;
+ }
+ if (!show_sys_files && inum < 0x10UL) {
+ ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Skipping system "
+ "file (%s).\n", nf->name);
+ err = 0;
+ goto err_ret;
}
/* Do not return ".", as this is faked. */
- if (length == 1 && *nf->name == '.')
- return 0;
-#ifdef NTFS_NGT_NT_DOES_LOWER
- if (to_lower)
- for(i = 0; i < nf->namelen; i++)
- /* This supports ASCII only. Since only DOS-only names
- * get converted, and since those are restricted to
- * ASCII, this should be correct. */
- if (nf->name[i] >= 'A' && nf->name[i] <= 'Z')
- nf->name[i] += 'a' - 'A';
-#endif
+ if (nf->namelen == 1 && nf->name[0] == '.') {
+ ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Skipping \".\"\n");
+ err = 0;
+ goto err_ret;
+ }
nf->name[nf->namelen] = 0;
- ntfs_debug(DEBUG_OTHER, "readdir got %s, len %d\n", nf->name,
- nf->namelen);
- /* filldir expects an off_t rather than an loff_t. Hope we don't have
- * more than 65535 index records. */
- error = nf->filldir(nf->dirent, nf->name, nf->namelen,
- (nf->ph << 16) | nf->pl, inum, DT_UNKNOWN);
+ if (flags & 0x10000000) /* FILE_ATTR_DUP_FILE_NAME_INDEX_PRESENT */
+ file_type = DT_DIR;
+ else
+ file_type = DT_REG;
+ ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Calling filldir for %s with "
+ "len %i, f_pos 0x%Lx, inode %lu, %s.\n",
+ nf->name, nf->namelen, (loff_t)(nf->ph << 16) | nf->pl,
+ inum, file_type == DT_DIR ? "DT_DIR" : "DT_REG");
+ /*
+ * Userspace side of filldir expects an off_t rather than an loff_t.
+ * And it also doesn't like the most significant bit being set as it
+ * then considers the value to be negative. Thus this implementation
+ * limits the number of index records to 32766, which should be plenty.
+ */
+ err = nf->filldir(nf->dirent, nf->name, nf->namelen,
+ (loff_t)(nf->ph << 16) | nf->pl, inum, file_type);
+ if (err)
+ nf->ret_code = err;
+err_ret:
+ nf->namelen = 0;
ntfs_free(nf->name);
- return error;
+ nf->name = NULL;
+ return err;
}
-/* readdir returns '..', then '.', then the directory entries in sequence.
- * As the root directory contains a entry for itself, '.' is not emulated for
- * the root directory. */
+/*
+ * readdir returns '.', then '..', then the directory entries in sequence.
+ * As the root directory contains an entry for itself, '.' is not emulated for
+ * the root directory.
+ */
static int ntfs_readdir(struct file* filp, void *dirent, filldir_t filldir)
{
- struct ntfs_filldir cb;
- int error;
struct inode *dir = filp->f_dentry->d_inode;
+ int err;
+ struct ntfs_filldir cb;
- ntfs_debug(DEBUG_OTHER, "ntfs_readdir ino %x mode %x\n",
- (unsigned)dir->i_ino, (unsigned int)dir->i_mode);
-
- ntfs_debug(DEBUG_OTHER, "readdir: Looking for file %x dircount %d\n",
- (unsigned)filp->f_pos, atomic_read(&dir->i_count));
- cb.pl = filp->f_pos & 0xFFFF;
- cb.ph = filp->f_pos >> 16;
- /* End of directory. */
- if (cb.ph == 0xFFFF) {
- /* FIXME: Maybe we can return those with the previous call. */
- switch (cb.pl) {
- case 0:
- filldir(dirent, ".", 1, filp->f_pos, dir->i_ino,DT_DIR);
- filp->f_pos = 0xFFFF0001;
- return 0;
- /* FIXME: Parent directory. */
- case 1:
- filldir(dirent, "..", 2, filp->f_pos, 0, DT_DIR);
- filp->f_pos = 0xFFFF0002;
- return 0;
+ cb.ret_code = 0;
+ cb.pl = filp->f_pos & 0xffff;
+ cb.ph = (filp->f_pos >> 16) & 0x7fff;
+ filp->f_pos = (loff_t)(cb.ph << 16) | cb.pl;
+ ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Entering for inode %lu, "
+ "f_pos 0x%Lx, i_mode 0x%x, i_count %lu.\n", dir->i_ino,
+ filp->f_pos, (unsigned int)dir->i_mode,
+ atomic_read(&dir->i_count));
+ if (!cb.ph) {
+ /* Start of directory. Emulate "." and "..". */
+ if (!cb.pl) {
+ ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Calling "
+ "filldir for . with len 1, f_pos 0x%Lx, "
+ "inode %lu, DT_DIR.\n", filp->f_pos,
+ dir->i_ino);
+ cb.ret_code = filldir(dirent, ".", 1, filp->f_pos,
+ dir->i_ino, DT_DIR);
+ if (cb.ret_code)
+ goto done;
+ cb.pl++;
+ filp->f_pos = (loff_t)(cb.ph << 16) | cb.pl;
}
- ntfs_debug(DEBUG_OTHER, "readdir: EOD\n");
- return 0;
- }
+ if (cb.pl == (u32)1) {
+ ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Calling "
+ "filldir for .. with len 2, f_pos 0x%Lx, "
+ "inode %lu, DT_DIR.\n", filp->f_pos,
+ filp->f_dentry->d_parent->d_inode->i_ino);
+ cb.ret_code = filldir(dirent, "..", 2, filp->f_pos,
+ filp->f_dentry->d_parent->d_inode->i_ino,
+ DT_DIR);
+ if (cb.ret_code)
+ goto done;
+ cb.pl++;
+ filp->f_pos = (loff_t)(cb.ph << 16) | cb.pl;
+ }
+ } else if (cb.ph >= 0x7fff)
+ /* End of directory. */
+ goto done;
cb.dir = dir;
cb.filldir = filldir;
cb.dirent = dirent;
cb.type = NTFS_INO2VOL(dir)->ngt;
do {
- ntfs_debug(DEBUG_OTHER,"looking for next file\n");
- error = ntfs_getdir_unsorted(NTFS_LINO2NINO(dir), &cb.ph,
- &cb.pl, ntfs_printcb, &cb);
- } while (!error && cb.ph != 0xFFFFFFFF);
- filp->f_pos = (cb.ph << 16) | cb.pl;
- ntfs_debug(DEBUG_OTHER, "new position %x\n", (unsigned)filp->f_pos);
- /* -EINVAL is on user buffer full. This is not considered as an error
- * by sys_getdents. */
- if (error == -EINVAL)
- error = 0;
- /* Otherwise (device error, inconsistent data) return the error code. */
- return error;
+ ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Looking for next "
+ "file using ntfs_getdir_unsorted(), f_pos "
+ "0x%Lx.\n", (loff_t)(cb.ph << 16) | cb.pl);
+ err = ntfs_getdir_unsorted(NTFS_LINO2NINO(dir), &cb.ph, &cb.pl,
+ ntfs_printcb, &cb);
+ } while (!err && !cb.ret_code && cb.ph < 0x7fff);
+ filp->f_pos = (loff_t)(cb.ph << 16) | cb.pl;
+ ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): After ntfs_getdir_unsorted()"
+ " calls, f_pos 0x%Lx.\n", filp->f_pos);
+ if (!err) {
+#ifdef DEBUG
+ if (cb.ph != 0x7fff || cb.pl)
+ BUG();
+done:
+ if (!cb.ret_code)
+ ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): EOD, f_pos "
+ "0x%Lx, returning 0.\n", filp->f_pos);
+ else
+ ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): filldir "
+ "returned %i, returning 0, f_pos "
+ "0x%Lx.\n", cb.ret_code, filp->f_pos);
+#else
+done:
+#endif
+ return 0;
+ }
+ ntfs_debug(DEBUG_OTHER, __FUNCTION__ "(): Returning %i, f_pos 0x%Lx.\n",
+ err, filp->f_pos);
+ return err;
}
/* Copied from vfat driver. */
@@ -285,8 +339,21 @@
return 1;
}
+/*
+ * This needs to be outside parse_options() otherwise a remount will reset
+ * these unintentionally.
+ */
+static void init_ntfs_super_block(ntfs_volume* vol)
+{
+ vol->uid = vol->gid = 0;
+ vol->umask = 0077;
+ vol->ngt = ngt_nt;
+ vol->nls_map = (void*)-1;
+ vol->mft_zone_multiplier = -1;
+}
+
/* Parse the (re)mount options. */
-static int parse_options(ntfs_volume *vol, char *opt, int remount)
+static int parse_options(ntfs_volume *vol, char *opt)
{
char *value; /* Defaults if not specified and !remount. */
ntfs_uid_t uid = -1; /* 0, root user only */
@@ -296,6 +363,8 @@
void *nls_map = NULL; /* Try to load the default NLS. */
int use_utf8 = -1; /* If no NLS specified and loading the default
NLS failed use utf8. */
+ int mft_zone_mul = -1; /* 1 */
+
if (!opt)
goto done;
for (opt = strtok(opt, ","); opt; opt = strtok(NULL, ",")) {
@@ -326,6 +395,24 @@
"argument\n");
return 0;
}
+ } else if (strcmp(opt, "mft_zone_multiplier") == 0) {
+ unsigned long ul;
+
+ if (!value || !*value)
+ goto needs_arg;
+ ul = simple_strtoul(value, &value, 0);
+ if (*value) {
+ printk(KERN_ERR "NTFS: mft_zone_multiplier "
+ "invalid argument\n");
+ return 0;
+ }
+ if (ul >= 1 && ul <= 4)
+ mft_zone_mul = ul;
+ else {
+ mft_zone_mul = 1;
+ printk(KERN_WARNING "NTFS: mft_zone_multiplier "
+ "out of range. Setting to 1.\n");
+ }
} else if (strcmp(opt, "posix") == 0) {
int val;
if (!value || !*value)
@@ -361,40 +448,69 @@
}
}
done:
- if (use_utf8 != -1 && use_utf8) {
- if (nls_map) {
+ if (use_utf8 == -1) {
+ /* utf8 was not specified at all. */
+ if (!nls_map) {
+ /*
+ * No NLS was specified. If first mount, load the
+ * default NLS, otherwise don't change the NLS setting.
+ */
+ if (vol->nls_map == (void*)-1)
+ vol->nls_map = load_nls_default();
+ } else {
+ /* If an NLS was already loaded, unload it first. */
+ if (vol->nls_map && vol->nls_map != (void*)-1)
+ unload_nls(vol->nls_map);
+ /* Use the specified NLS. */
+ vol->nls_map = nls_map;
+ }
+ } else {
+ /* utf8 was specified. */
+ if (use_utf8 && nls_map) {
unload_nls(nls_map);
printk(KERN_ERR "NTFS: utf8 cannot be combined with "
"iocharset.\n");
return 0;
}
- if (remount && vol->nls_map)
+ /* If an NLS was already loaded, unload it first. */
+ if (vol->nls_map && vol->nls_map != (void*)-1)
unload_nls(vol->nls_map);
- vol->nls_map = NULL;
- } else {
- if (nls_map) {
- if (remount && vol->nls_map)
- unload_nls(vol->nls_map);
- vol->nls_map = nls_map;
- } else if (!remount || (remount && !use_utf8 && !vol->nls_map))
- vol->nls_map = load_nls_default();
+ if (!use_utf8) {
+ /* utf8 was specified as false. */
+ if (!nls_map)
+ /* No NLS was specified, load the default. */
+ vol->nls_map = load_nls_default();
+ else
+ /* Use the specified NLS. */
+ vol->nls_map = nls_map;
+ } else
+ /* utf8 was specified as true. */
+ vol->nls_map = NULL;
}
if (uid != -1)
vol->uid = uid;
- else if (!remount)
- vol->uid = 0;
if (gid != -1)
vol->gid = gid;
- else if (!remount)
- vol->gid = 0;
if (umask != -1)
vol->umask = (ntmode_t)umask;
- else if (!remount)
- vol->umask = 0077;
if (ngt != -1)
vol->ngt = ngt;
- else if (!remount)
- vol->ngt = ngt_nt;
+ if (mft_zone_mul != -1) {
+ /* mft_zone_multiplier was specified. */
+ if (vol->mft_zone_multiplier != -1) {
+ /* This is a remount, ignore a change and warn user. */
+ if (vol->mft_zone_multiplier != mft_zone_mul)
+ printk(KERN_WARNING "NTFS: Ignoring changes in "
+ "mft_zone_multiplier on "
+ "remount. If you want to "
+ "change this you need to "
+ "umount and mount again.\n");
+ } else
+ /* Use the specified multiplier. */
+ vol->mft_zone_multiplier = mft_zone_mul;
+ } else if (vol->mft_zone_multiplier == -1)
+ /* No multiplier specified and first mount, so set default. */
+ vol->mft_zone_multiplier = 1;
return 1;
needs_arg:
printk(KERN_ERR "NTFS: %s needs an argument", opt);
@@ -409,18 +525,22 @@
struct inode *res = 0;
char *item = 0;
ntfs_iterate_s walk;
- int error;
+ int err;
- ntfs_debug(DEBUG_NAME1, "Looking up %s in %x\n", d->d_name.name,
- (unsigned)dir->i_ino);
+ ntfs_debug(DEBUG_NAME1, __FUNCTION__ "(): Looking up %s in directory "
+ "ino 0x%x.\n", d->d_name.name, (unsigned)dir->i_ino);
+ walk.name = NULL;
+ walk.namelen = 0;
/* Convert to wide string. */
- error = ntfs_decodeuni(NTFS_INO2VOL(dir), (char*)d->d_name.name,
+ err = ntfs_decodeuni(NTFS_INO2VOL(dir), (char*)d->d_name.name,
d->d_name.len, &walk.name, &walk.namelen);
- if (error)
- return ERR_PTR(error);
+ if (err)
+ goto err_ret;
item = ntfs_malloc(ITEM_SIZE);
- if (!item)
- return ERR_PTR(-ENOMEM);
+ if (!item) {
+ err = -ENOMEM;
+ goto err_ret;
+ }
/* ntfs_getdir will place the directory entry into item, and the first
* long long is the MFT record number. */
walk.type = BY_NAME;
@@ -433,16 +553,21 @@
ntfs_free(walk.name);
/* Always return success, the dcache will handle negative entries. */
return NULL;
+err_ret:
+ ntfs_free(walk.name);
+ return ERR_PTR(err);
}
-static struct file_operations ntfs_file_operations_nommap = {
+static struct file_operations ntfs_file_operations = {
+ llseek: generic_file_llseek,
read: ntfs_read,
#ifdef CONFIG_NTFS_RW
write: ntfs_write,
#endif
+ open: generic_file_open,
};
-static struct inode_operations ntfs_inode_operations_nobmap;
+static struct inode_operations ntfs_inode_operations;
#ifdef CONFIG_NTFS_RW
static int ntfs_create(struct inode* dir, struct dentry *d, int mode)
@@ -488,8 +613,8 @@
r->i_mtime = ntfs_ntutc2unixutc(NTFS_GETU64(attr + 8));
}
/* It's not a directory */
- r->i_op = &ntfs_inode_operations_nobmap;
- r->i_fop = &ntfs_file_operations_nommap,
+ r->i_op = &ntfs_inode_operations;
+ r->i_fop = &ntfs_file_operations;
r->i_mode = S_IFREG | S_IRUGO;
#ifdef CONFIG_NTFS_RW
r->i_mode |= S_IWUGO;
@@ -556,36 +681,6 @@
}
#endif
-#if 0
-static int ntfs_bmap(struct inode *ino, int block)
-{
- int ret = ntfs_vcn_to_lcn(NTFS_LINO2NINO(ino), block);
- ntfs_debug(DEBUG_OTHER, "bmap of %lx, block %x is %x\n", ino->i_ino,
- block, ret);
- return (ret == -1) ? 0 : ret;
-}
-#endif
-
-/* It's fscking broken. */
-/* FIXME: [bm]map code is disabled until ntfs_get_block() gets sorted! */
-/*
-static int ntfs_get_block(struct inode *inode, long block, struct buffer_head *bh, int create)
-{
- BUG();
- return -1;
-}
-
-static struct file_operations ntfs_file_operations = {
- read: ntfs_read,
- mmap: generic_file_mmap,
-#ifdef CONFIG_NTFS_RW
- write: ntfs_write,
-#endif
-};
-
-static struct inode_operations ntfs_inode_operations;
-*/
-
static struct file_operations ntfs_dir_operations = {
read: generic_read_dir,
readdir: ntfs_readdir,
@@ -599,39 +694,6 @@
#endif
};
-/*
-static int ntfs_writepage(struct page *page)
-{
- return block_write_full_page(page,ntfs_get_block);
-}
-
-static int ntfs_readpage(struct file *file, struct page *page)
-{
- return block_read_full_page(page,ntfs_get_block);
-}
-
-static int ntfs_prepare_write(struct file *file, struct page *page,
- unsigned from, unsigned to)
-{
- return cont_prepare_write(page, from, to, ntfs_get_block,
- &page->mapping->host->u.ntfs_i.mmu_private);
-}
-
-static int _ntfs_bmap(struct address_space *mapping, long block)
-{
- return generic_block_bmap(mapping, block, ntfs_get_block);
-}
-
-struct address_space_operations ntfs_aops = {
- readpage: ntfs_readpage,
- writepage: ntfs_writepage,
- sync_page: block_sync_page,
- prepare_write: ntfs_prepare_write,
- commit_write: generic_commit_write,
- bmap: _ntfs_bmap
-};
-*/
-
/* ntfs_read_inode() is called by the Virtual File System (the kernel layer
* that deals with filesystems) when iget is called requesting an inode not
* already present in the inode table. Typically filesystems have separate
@@ -639,26 +701,16 @@
static void ntfs_read_inode(struct inode* inode)
{
ntfs_volume *vol;
- int can_mmap = 0;
ntfs_inode *ino;
ntfs_attribute *data;
ntfs_attribute *si;
vol = NTFS_INO2VOL(inode);
inode->i_mode = 0;
- ntfs_debug(DEBUG_OTHER, "ntfs_read_inode 0x%x\n", (unsigned)inode->i_ino);
- /*
- * This kills all accesses to system files (except $Extend directory).
- * The driver can bypass this by calling ntfs_init_inode() directly.
- * Only if ngt is ngt_full do we allow access to the system files.
- */
+ ntfs_debug(DEBUG_OTHER, "ntfs_read_inode 0x%lx\n", inode->i_ino);
switch (inode->i_ino) {
/* Those are loaded special files. */
- case FILE_$Mft:
- if (vol->ngt != ngt_full) {
- ntfs_error("Trying to open $MFT!\n");
- return;
- }
+ case FILE_Mft:
if (!vol->mft_ino || ((vol->ino_flags & 1) == 0))
goto sys_file_error;
ntfs_memcpy(&inode->u.ntfs_i, vol->mft_ino, sizeof(ntfs_inode));
@@ -669,11 +721,7 @@
ino = vol->mft_ino;
ntfs_debug(DEBUG_OTHER, "Opening $MFT!\n");
break;
- case FILE_$MftMirr:
- if (vol->ngt != ngt_full) {
- ntfs_error("Trying to open $MFTMirr!\n");
- return;
- }
+ case FILE_MftMirr:
if (!vol->mftmirr || ((vol->ino_flags & 2) == 0))
goto sys_file_error;
ntfs_memcpy(&inode->u.ntfs_i, vol->mftmirr, sizeof(ntfs_inode));
@@ -684,11 +732,7 @@
ino = vol->mftmirr;
ntfs_debug(DEBUG_OTHER, "Opening $MFTMirr!\n");
break;
- case FILE_$BitMap:
- if (vol->ngt != ngt_full) {
- ntfs_error("Trying to open $Bitmap!\n");
- return;
- }
+ case FILE_BitMap:
if (!vol->bitmap || ((vol->ino_flags & 4) == 0))
goto sys_file_error;
ntfs_memcpy(&inode->u.ntfs_i, vol->bitmap, sizeof(ntfs_inode));
@@ -699,15 +743,11 @@
ino = vol->bitmap;
ntfs_debug(DEBUG_OTHER, "Opening $Bitmap!\n");
break;
- case FILE_$LogFile ... FILE_$AttrDef:
- /* We need to allow reading the root directory. */
- case FILE_$Boot ... FILE_$UpCase:
- if (vol->ngt != ngt_full) {
- ntfs_error("Trying to open system file %i!\n",
- inode->i_ino);
- return;
- } /* Do the default for ngt_full. */
- ntfs_debug(DEBUG_OTHER, "Opening system file %i!\n", inode->i_ino);
+ case FILE_LogFile ... FILE_AttrDef:
+ /* No need to log root directory accesses. */
+ case FILE_Boot ... FILE_UpCase:
+ ntfs_debug(DEBUG_OTHER, "Opening system file %i!\n",
+ inode->i_ino);
default:
ino = &inode->u.ntfs_i;
if (!ino || ntfs_init_inode(ino, NTFS_INO2VOL(inode),
@@ -724,16 +764,10 @@
inode->i_nlink = 1;
/* Use the size of the data attribute as file size */
data = ntfs_find_attr(ino, vol->at_data, NULL);
- if (!data) {
+ if (!data)
inode->i_size = 0;
- can_mmap = 0;
- } else {
+ else
inode->i_size = data->size;
- /* FIXME: once ntfs_get_block is implemented, uncomment the
- * next line and remove the "can_mmap = 0;". (AIA) */
- /* can_mmap = !data->resident && !data->compressed; */
- can_mmap = 0;
- }
/* Get the file modification times from the standard information. */
si = ntfs_find_attr(ino, vol->at_standard_information, NULL);
if (si) {
@@ -751,24 +785,12 @@
inode->i_fop = &ntfs_dir_operations;
inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
} else {
- /* As long as ntfs_get_block() is just a call to BUG() do not
- * define any [bm]map ops or we get the BUG() whenever someone
- * runs mc or mpg123 on an ntfs partition!
- * FIXME: Uncomment the below code when ntfs_get_block is
- * implemented. */
- /* if (can_mmap) {
- inode->i_op = &ntfs_inode_operations;
- inode->i_fop = &ntfs_file_operations;
- inode->i_mapping->a_ops = &ntfs_aops;
- inode->u.ntfs_i.mmu_private = inode->i_size;
- } else */ {
- inode->i_op = &ntfs_inode_operations_nobmap;
- inode->i_fop = &ntfs_file_operations_nommap;
- }
+ inode->i_op = &ntfs_inode_operations;
+ inode->i_fop = &ntfs_file_operations;
inode->i_mode = S_IFREG | S_IRUGO;
}
#ifdef CONFIG_NTFS_RW
- if (!data || !data->compressed)
+ if (!data || !(data->flags & (ATTR_IS_COMPRESSED | ATTR_IS_ENCRYPTED)))
inode->i_mode |= S_IWUGO;
#endif
inode->i_mode &= ~vol->umask;
@@ -798,13 +820,10 @@
ntfs_debug(DEBUG_OTHER, "_ntfs_clear_inode 0x%x\n", inode->i_ino);
vol = NTFS_INO2VOL(inode);
if (!vol)
- ntfs_error("_ntfs_clear_inode: vol = NTFS_INO2VOL(inode) is NULL.\n");
+ ntfs_error("_ntfs_clear_inode: vol = NTFS_INO2VOL(inode) is "
+ "NULL.\n");
switch (inode->i_ino) {
- case FILE_$Mft:
- if (vol->ngt != ngt_full) {
- ntfs_error("Trying to _clear_inode of $MFT!\n");
- goto unl_out;
- }
+ case FILE_Mft:
if (vol->mft_ino && ((vol->ino_flags & 1) == 0)) {
ino = (ntfs_inode*)ntfs_malloc(sizeof(ntfs_inode));
ntfs_memcpy(ino, &inode->u.ntfs_i, sizeof(ntfs_inode));
@@ -813,11 +832,7 @@
goto unl_out;
}
break;
- case FILE_$MftMirr:
- if (vol->ngt != ngt_full) {
- ntfs_error("Trying to _clear_inode of $MFTMirr!\n");
- goto unl_out;
- }
+ case FILE_MftMirr:
if (vol->mftmirr && ((vol->ino_flags & 2) == 0)) {
ino = (ntfs_inode*)ntfs_malloc(sizeof(ntfs_inode));
ntfs_memcpy(ino, &inode->u.ntfs_i, sizeof(ntfs_inode));
@@ -826,11 +841,7 @@
goto unl_out;
}
break;
- case FILE_$BitMap:
- if (vol->ngt != ngt_full) {
- ntfs_error("Trying to _clear_inode of $Bitmap!\n");
- goto unl_out;
- }
+ case FILE_BitMap:
if (vol->bitmap && ((vol->ino_flags & 4) == 0)) {
ino = (ntfs_inode*)ntfs_malloc(sizeof(ntfs_inode));
ntfs_memcpy(ino, &inode->u.ntfs_i, sizeof(ntfs_inode));
@@ -839,13 +850,6 @@
goto unl_out;
}
break;
- case FILE_$LogFile ... FILE_$AttrDef:
- case FILE_$Boot ... FILE_$UpCase:
- if (vol->ngt != ngt_full) {
- ntfs_error("Trying to _clear_inode of system file %i! "
- "Shouldn't happen.\n", inode->i_ino);
- goto unl_out;
- } /* Do the default for ngt_full. */
default:
/* Nothing. Just clear the inode and exit. */
}
@@ -889,9 +893,11 @@
if (size < 0LL)
size = 0;
sf->f_bfree = sf->f_bavail = size;
- ntfs_debug(DEBUG_OTHER, "ntfs_statfs: calling mft = iget(sb, FILE_$Mft)\n");
- mft = iget(sb, FILE_$Mft);
- ntfs_debug(DEBUG_OTHER, "ntfs_statfs: iget(sb, FILE_$Mft) returned 0x%x\n", mft);
+ ntfs_debug(DEBUG_OTHER, "ntfs_statfs: calling mft = iget(sb, "
+ "FILE_Mft)\n");
+ mft = iget(sb, FILE_Mft);
+ ntfs_debug(DEBUG_OTHER, "ntfs_statfs: iget(sb, FILE_Mft) returned "
+ "0x%x\n", mft);
if (!mft)
return -EIO;
sf->f_files = mft->i_size >> vol->mft_record_size_bits;
@@ -905,7 +911,7 @@
/* Called when remounting a filesystem by do_remount_sb() in fs/super.c. */
static int ntfs_remount_fs(struct super_block *sb, int *flags, char *options)
{
- if (!parse_options(NTFS_SB2VOL(sb), options, 1))
+ if (!parse_options(NTFS_SB2VOL(sb), options))
return -EINVAL;
return 0;
}
@@ -1001,16 +1007,17 @@
*
* NOTE : A context switch can happen in kernel code only if the code blocks
* (= calls schedule() in kernel/sched.c). */
-struct super_block * ntfs_read_super(struct super_block *sb, void *options,
- int silent)
+struct super_block *ntfs_read_super(struct super_block *sb, void *options,
+ int silent)
{
ntfs_volume *vol;
struct buffer_head *bh;
- int i;
+ int i, to_read;
ntfs_debug(DEBUG_OTHER, "ntfs_read_super\n");
vol = NTFS_SB2VOL(sb);
- if (!parse_options(vol, (char*)options, 0))
+ init_ntfs_super_block(vol);
+ if (!parse_options(vol, (char*)options))
goto ntfs_read_super_vol;
/* Assume a 512 bytes block device for now. */
set_blocksize(sb->s_dev, 512);
@@ -1032,7 +1039,7 @@
bforget(bh);
goto ntfs_read_super_unl;
}
- ntfs_debug(DEBUG_OTHER, "$Mft at cluster 0x%Lx\n", vol->mft_lcn);
+ ntfs_debug(DEBUG_OTHER, "$Mft at cluster 0x%lx\n", vol->mft_lcn);
bforget(bh);
NTFS_SB(vol) = sb;
if (vol->cluster_size > PAGE_SIZE) {
@@ -1048,12 +1055,17 @@
set_blocksize(sb->s_dev, sb->s_blocksize);
ntfs_debug(DEBUG_OTHER, "set_blocksize\n");
/* Allocate an MFT record (MFT record can be smaller than a cluster). */
- if (!(vol->mft = ntfs_malloc(max(int, vol->mft_record_size,
- vol->cluster_size))))
+ i = vol->cluster_size;
+ if (i < vol->mft_record_size)
+ i = vol->mft_record_size;
+ if (!(vol->mft = ntfs_malloc(i)))
goto ntfs_read_super_unl;
/* Read at least the MFT record for $Mft. */
- for (i = 0; i < max(int, vol->mft_clusters_per_record, 1); i++) {
+ to_read = vol->mft_clusters_per_record;
+ if (to_read < 1)
+ to_read = 1;
+ for (i = 0; i < to_read; i++) {
if (!(bh = bread(sb->s_dev, vol->mft_lcn + i,
vol->cluster_size))) {
ntfs_error("Could not read $Mft record 0\n");
@@ -1081,7 +1093,7 @@
}
ntfs_debug(DEBUG_OTHER, "Getting RootDir\n");
/* Get the root directory. */
- if (!(sb->s_root = d_alloc_root(iget(sb, FILE_$root)))) {
+ if (!(sb->s_root = d_alloc_root(iget(sb, FILE_root)))) {
ntfs_error("Could not get root dir inode\n");
goto ntfs_read_super_mft;
}
@@ -1105,7 +1117,19 @@
#if defined(DEBUG) && !defined(MODULE)
console_verbose();
#endif
- printk(KERN_NOTICE "NTFS version " NTFS_VERSION "\n");
+ printk(KERN_NOTICE "NTFS driver v" NTFS_VERSION " [Flags: R/"
+#ifdef CONFIG_NTFS_RW
+ "W"
+#else
+ "O"
+#endif
+#ifdef DEBUG
+ " DEBUG"
+#endif
+#ifdef MODULE
+ " MODULE"
+#endif
+ "]\n");
SYSCTL(1);
ntfs_debug(DEBUG_OTHER, "registering %s\n", ntfs_fs_type.name);
/* Add this filesystem to the kernel table of filesystems. */
@@ -1125,7 +1149,7 @@
* I am just maintaining and rewriting it.
*/
MODULE_AUTHOR("Anton Altaparmakov <aia21@cus.cam.ac.uk>");
-MODULE_DESCRIPTION("NTFS driver");
+MODULE_DESCRIPTION("Linux NTFS driver");
#ifdef DEBUG
MODULE_PARM(ntdebug, "i");
MODULE_PARM_DESC(ntdebug, "Debug level");
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen (who was at: slshen@lbl.gov)