Import changeset

Documentation/filesystems/ntfs.txt

+
+

fs/ntfs/Makefile

+# Rules for making the NTFS TNG driver.
+
+O_TARGET := ntfs.o
+
+obj-y   := time.o unistr.o inode.o file.o mft.o super.o debug.o aops.o \
+		attrib.o dir.o namei.o mst.o upcase.o compress.o sysctl.o
+
+obj-m   := $(O_TARGET)
+
+EXTRA_CFLAGS = -DNTFS_VERSION=\"TNG-0.0.8\"
+
+# Uncomment this to enable debugging code.
+EXTRA_CFLAGS += -DDEBUG
+
+include $(TOPDIR)/Rules.make
+

fs/ntfs/attraops.c

+#include "ntfs.h"
+
+/*
+ * We need to define the attribute object structure. FIXME: Move these to
+ * ntfs.h.
+ */
+typedef struct {
+	ntfs_inode *a_ni;
+	ntfs_volume *a_vol;
+	atomic_t a_count;
+	s64 a_size;
+	struct rw_semaphore a_sem;
+	struct address_space a_mapping;
+	unsigned long a_flags;
+} attr_obj;
+
+/**
+ * ntfs_attr_readpage - fill a page @page of an attribute object @aobj with data
+ * @aobj:	attribute object to which the page @page belongs
+ * @page:	page cache page to fill with data
+ *
+ */
+//static int ntfs_attr_readpage(attr_obj *aobj, struct page *page)
+static int ntfs_attr_readpage(struct file *aobj, struct page *page)
+{
+	return -EOPNOTSUPP;
+}
+
+/*
+ * Address space operations for accessing attributes. Note that these functions
+ * do not accept an inode as the first parameter but an attribute object. We
+ * use this to implement a generic interface that is not bound to inodes in
+ * order to support multiple named streams per file, multiple bitmaps per file
+ * and directory, etc. Basically, this gives access to any attribute within an
+ * mft record.
+ *
+ * We make use of a slab cache for attribute object allocations.
+ */
+struct address_space_operations ntfs_attr_aops = {
+	writepage:	NULL,			/* Write dirty page to disk. */
+	readpage:	ntfs_attr_readpage,	/* Fill page with data. */
+	sync_page:	block_sync_page,	/* Currently, just unplugs the
+						   disk request queue. */
+	prepare_write:	NULL,			/* . */
+	commit_write:	NULL,			/* . */
+	//truncatepage:	NULL,			/* . */
+};
+

fs/ntfs/attrib.h

+/*
+ * attrib.h - Defines for attribute handling in NTFS Linux kernel driver.
+ *	      Part of the Linux-NTFS project.
+ *
+ * Copyright (c) 2001,2002 Anton Altaparmakov.
+ * Copyright (C) 2002 Richard Russon.
+ *
+ * This program/include file is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program/include file is distributed in the hope that it will be 
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty 
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program (in the main directory of the Linux-NTFS 
+ * distribution in the file COPYING); if not, write to the Free Software
+ * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _LINUX_NTFS_ATTRIB_H
+#define _LINUX_NTFS_ATTRIB_H
+
+#include <linux/fs.h>
+
+#include "endian.h"
+#include "types.h"
+#include "layout.h"
+
+typedef enum {
+	LCN_HOLE		= -1,	/* Keep this as highest value or die! */
+	LCN_RL_NOT_MAPPED	= -2,
+	LCN_ENOENT		= -3,
+	LCN_EINVAL		= -4,
+} LCN_SPECIAL_VALUES;
+
+/**
+ * attr_search_context - used in attribute search functions
+ * @mrec:	buffer containing mft record to search
+ * @attr:	attribute record in @mrec where to begin/continue search
+ * @is_first:	if true lookup_attr() begins search with @attr, else after @attr
+ *
+ * Structure must be initialized to zero before the first call to one of the
+ * attribute search functions. Initialize @mrec to point to the mft record to
+ * search, and @attr to point to the first attribute within @mrec (not necessary
+ * if calling the _first() functions), and set @is_first to TRUE (not necessary
+ * if calling the _first() functions).
+ *
+ * If @is_first is TRUE, the search begins with @attr. If @is_first is FALSE,
+ * the search begins after @attr. This is so that, after the first call to one
+ * of the search attribute functions, we can call the function again, without
+ * any modification of the search context, to automagically get the next
+ * matching attribute.
+ */
+typedef struct {
+	MFT_RECORD *mrec;
+	ATTR_RECORD *attr;
+	BOOL is_first;
+	ntfs_inode *ntfs_ino;
+	ATTR_LIST_ENTRY *al_entry;
+	ntfs_inode *base_ntfs_ino;
+	MFT_RECORD *base_mrec;
+	ATTR_RECORD *base_attr;
+} attr_search_context;
+
+extern run_list_element *decompress_mapping_pairs(const ntfs_volume *vol,
+		const ATTR_RECORD *attr, run_list_element *old_rl);
+
+extern int map_run_list(ntfs_inode *ni, VCN vcn);
+
+extern LCN vcn_to_lcn(const run_list_element *rl, const VCN vcn);
+
+extern BOOL find_attr(const ATTR_TYPES type, const uchar_t *name,
+		const u32 name_len, const IGNORE_CASE_BOOL ic, const u8 *val,
+		const u32 val_len, attr_search_context *ctx);
+
+BOOL lookup_attr(const ATTR_TYPES type, const uchar_t *name, const u32 name_len,
+		const IGNORE_CASE_BOOL ic, const VCN lowest_vcn, const u8 *val,
+		const u32 val_len, attr_search_context *ctx);
+
+extern int load_attribute_list(ntfs_volume *vol, run_list_element *rl, u8 *al,
+		const s64 size);
+
+static inline s64 attribute_value_length(const ATTR_RECORD *a)
+{
+	if (!a->non_resident)
+		return (s64)le32_to_cpu(a->_ARA(value_length));
+	return sle64_to_cpu(a->_ANR(data_size));
+}
+
+extern void reinit_attr_search_ctx(attr_search_context *ctx);
+extern int get_attr_search_ctx(attr_search_context **ctx, ntfs_inode *ni,
+		MFT_RECORD *mrec);
+extern void put_attr_search_ctx(attr_search_context *ctx);
+
+#endif /* _LINUX_NTFS_ATTRIB_H */
+

fs/ntfs/debug.c

+/*
+ * debug.c - NTFS kernel debug support. Part of the Linux-NTFS project.
+ *
+ * Copyright (c) 2001,2002 Anton Altaparmakov.
+ *
+ * This program/include file is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program/include file is distributed in the hope that it will be 
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty 
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program (in the main directory of the Linux-NTFS 
+ * distribution in the file COPYING); if not, write to the Free Software
+ * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "debug.h"
+
+/*
+ * A static buffer to hold the error string being displayed and a spinlock
+ * to protect concurrent accesses to it.
+ */
+static char err_buf[1024];
+static spinlock_t err_buf_lock = SPIN_LOCK_UNLOCKED;
+
+/**
+ * __ntfs_warning - output a warning to the syslog
+ * @function:	name of function outputting the warning
+ * @sb:		super block of mounted ntfs filesystem
+ * @fmt:	warning string containing format specifications
+ * @...:	a variable number of arguments specified in @fmt
+ *
+ * Outputs a warning to the syslog for the mounted ntfs filesystem described
+ * by @sb.
+ *
+ * @fmt and the corresponding @... is printf style format string containing
+ * the warning string and the corresponding format arguments, respectively.
+ *
+ * @function is the name of the function from which __ntfs_warning is being
+ * called.
+ *
+ * Note, you should be using debug.h::ntfs_warning(@sb, @fmt, @...) instead
+ * as this provides the @function parameter automatically.
+ */
+void __ntfs_warning(const char *function, const struct super_block *sb,
+		const char *fmt, ...)
+{
+	va_list args;
+	int flen = 0;
+
+	if (function)
+		flen = strlen(function);
+	spin_lock(&err_buf_lock);
+	va_start(args, fmt);
+	vsnprintf(err_buf, sizeof(err_buf), fmt, args);
+	va_end(args);
+	if (sb)
+		printk(KERN_ERR "NTFS-fs warning (device %s): %s(): %s\n",
+				sb->s_id, flen ? function : "", err_buf);
+	else
+		printk(KERN_ERR "NTFS-fs warning: %s(): %s\n",
+				flen ? function : "", err_buf);
+	spin_unlock(&err_buf_lock);
+}
+
+/**
+ * __ntfs_error - output an error to the syslog
+ * @function:	name of function outputting the error
+ * @sb:		super block of mounted ntfs filesystem
+ * @fmt:	error string containing format specifications
+ * @...:	a variable number of arguments specified in @fmt
+ *
+ * Outputs an error to the syslog for the mounted ntfs filesystem described
+ * by @sb.
+ *
+ * @fmt and the corresponding @... is printf style format string containing
+ * the error string and the corresponding format arguments, respectively.
+ *
+ * @function is the name of the function from which __ntfs_error is being
+ * called.
+ *
+ * Note, you should be using debug.h::ntfs_error(@sb, @fmt, @...) instead
+ * as this provides the @function parameter automatically.
+ */
+void __ntfs_error(const char *function, const struct super_block *sb,
+		const char *fmt, ...)
+{
+	va_list args;
+	int flen = 0;
+
+	if (function)
+		flen = strlen(function);
+	spin_lock(&err_buf_lock);
+	va_start(args, fmt);
+	vsnprintf(err_buf, sizeof(err_buf), fmt, args);
+	va_end(args);
+	if (sb)
+		printk(KERN_ERR "NTFS-fs error (device %s): %s(): %s\n",
+				sb->s_id, flen ? function : "", err_buf);
+	else
+		printk(KERN_ERR "NTFS-fs error: %s(): %s\n",
+				flen ? function : "", err_buf);
+	spin_unlock(&err_buf_lock);
+}
+
+#ifdef DEBUG
+
+/* If 1, output debug messages, and if 0, don't. */
+int debug_msgs = 0;
+
+void __ntfs_debug (const char *file, int line, const char *function,
+		const char *fmt, ...)
+{
+	va_list args;
+	int flen = 0;
+
+	if (!debug_msgs)
+		return;
+	if (function)
+		flen = strlen(function);
+	spin_lock(&err_buf_lock);
+	va_start(args, fmt);
+	vsnprintf(err_buf, sizeof(err_buf), fmt, args);
+	va_end(args);
+	printk(KERN_DEBUG "NTFS-fs DEBUG (%s, %d): %s: %s\n",
+		file, line, flen ? function : "", err_buf);
+	spin_unlock(&err_buf_lock);
+}
+
+/* Dump a run list. Caller has to provide synchronisation for @rl. */
+void ntfs_debug_dump_runlist(const run_list_element *rl)
+{
+	int i;
+	const char *lcn_str[5] = { "LCN_HOLE         ", "LCN_RL_NOT_MAPPED",
+				   "LCN_ENOENT       ", "LCN_EINVAL       ",
+				   "LCN_unknown      " };
+
+	if (!debug_msgs)
+		return;
+	printk(KERN_DEBUG "NTFS-fs DEBUG: Dumping run list (values "
+			"in hex):\n");
+	if (!rl) {
+		printk(KERN_DEBUG "Run list not present.\n");
+		return;
+	}
+	printk(KERN_DEBUG "VCN              LCN               Run length\n");
+	for (i = 0; ; i++) {
+		LCN lcn = (rl + i)->lcn;
+
+		if (lcn < (LCN)0) {
+			int index = -lcn - 1;
+
+			if (index > -LCN_EINVAL - 1)
+				index = 4;
+			printk(KERN_DEBUG "%-16Lx %s %-16Lx%s\n",
+				(rl + i)->vcn, lcn_str[index],
+				(rl + i)->length, (rl + i)->length ?
+				"" : " (run list end)");
+		} else
+			printk(KERN_DEBUG "%-16Lx %-16Lx  %-16Lx%s\n",
+				(rl + i)->vcn, (rl + i)->lcn,
+				(rl + i)->length, (rl + i)->length ?
+				"" : " (run list end)");
+		if (!(rl + i)->length)
+			break;
+	}
+}
+
+#endif
+

fs/ntfs/debug.h

+/*
+ * debug.h - NTFS kernel debug support. Part of the Linux-NTFS project.
+ *
+ * Copyright (c) 2001,2002 Anton Altaparmakov.
+ *
+ * This program/include file is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program/include file is distributed in the hope that it will be 
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty 
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program (in the main directory of the Linux-NTFS 
+ * distribution in the file COPYING); if not, write to the Free Software
+ * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _LINUX_NTFS_DEBUG_H
+#define _LINUX_NTFS_DEBUG_H
+
+#include <linux/kernel.h>
+#include <linux/string.h>
+#include <linux/spinlock.h>
+#include <linux/fs.h>
+
+#include "inode.h"
+#include "attrib.h"
+
+#ifdef DEBUG
+
+extern int debug_msgs;
+
+#if 0 /* Fool kernel-doc since it doesn't do macros yet */
+/**
+ * ntfs_debug - write a debug level message to syslog
+ * @f:		a printf format string containing the message
+ * @...:	the variables to substitute into @f
+ *
+ * ntfs_debug() writes a DEBUG level message to the syslog but only if the
+ * driver was compiled with -DDEBUG. Otherwise, the call turns into a NOP.
+ */
+static void ntfs_debug(const char *f, ...);
+#endif
+
+extern void __ntfs_debug (const char *file, int line, const char *function,
+	const char *format, ...) __attribute__ ((format (printf, 4, 5)));
+#define ntfs_debug(f, a...)						\
+	__ntfs_debug(__FILE__, __LINE__, __FUNCTION__, f, ##a)
+
+extern void ntfs_debug_dump_runlist(const run_list_element *rl);
+
+#else	/* !DEBUG */
+
+#define ntfs_debug(f, a...)		do {} while (0)
+#define ntfs_debug_dump_runlist(rl)	do {} while (0)
+
+#endif	/* !DEBUG */
+
+extern void __ntfs_warning(const char *function, const struct super_block *sb,
+		const char *fmt, ...) __attribute__ ((format (printf, 3, 4)));
+#define ntfs_warning(sb, f, a...)	__ntfs_warning(__FUNCTION__, sb, f, ##a)
+
+extern void __ntfs_error(const char *function, const struct super_block *sb,
+		const char *fmt, ...) __attribute__ ((format (printf, 3, 4)));
+#define ntfs_error(sb, f, a...)		__ntfs_error(__FUNCTION__, sb, f, ##a)
+
+#endif /* _LINUX_NTFS_DEBUG_H */
+

fs/ntfs/endian.h

+/*
+ * endian.h - Defines for endianness handling in NTFS Linux kernel driver.
+ *	      Part of the Linux-NTFS project.
+ *
+ * Copyright (c) 2001 Anton Altaparmakov.
+ *
+ * This program/include file is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program/include file is distributed in the hope that it will be 
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty 
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program (in the main directory of the Linux-NTFS 
+ * distribution in the file COPYING); if not, write to the Free Software
+ * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _LINUX_NTFS_ENDIAN_H
+#define _LINUX_NTFS_ENDIAN_H
+
+#include <asm/byteorder.h>
+
+/*
+ * Signed endianness conversion defines.
+ */
+#define sle16_to_cpu(x)		((s16)__le16_to_cpu((s16)(x)))
+#define sle32_to_cpu(x)		((s32)__le32_to_cpu((s32)(x)))
+#define sle64_to_cpu(x)		((s64)__le64_to_cpu((s64)(x)))
+
+#define sle16_to_cpup(x)	((s16)__le16_to_cpu(*(s16*)(x)))
+#define sle32_to_cpup(x)	((s32)__le32_to_cpu(*(s32*)(x)))
+#define sle64_to_cpup(x)	((s64)__le64_to_cpu(*(s64*)(x)))
+
+#define cpu_to_sle16(x)		((s16)__cpu_to_le16((s16)(x)))
+#define cpu_to_sle32(x)		((s32)__cpu_to_le32((s32)(x)))
+#define cpu_to_sle64(x)		((s64)__cpu_to_le64((s64)(x)))
+
+#define cpu_to_sle16p(x)	((s16)__cpu_to_le16(*(s16*)(x)))
+#define cpu_to_sle32p(x)	((s32)__cpu_to_le32(*(s32*)(x)))
+#define cpu_to_sle64p(x)	((s64)__cpu_to_le64(*(s64*)(x)))
+
+#endif /* _LINUX_NTFS_ENDIAN_H */
+

fs/ntfs/file.c

+/*
+ * file.c - NTFS kernel file operations. Part of the Linux-NTFS project.
+ *
+ * Copyright (c) 2001 Anton Altaparmakov.
+ *
+ * This program/include file is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program/include file is distributed in the hope that it will be 
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty 
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program (in the main directory of the Linux-NTFS 
+ * distribution in the file COPYING); if not, write to the Free Software
+ * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "ntfs.h"
+
+struct file_operations ntfs_file_ops = {
+	llseek:			generic_file_llseek,	/* Seek inside file. */
+	read:			generic_file_read,	/* Read from file. */
+	write:			NULL,			/* . */
+	readdir:		NULL,			/* . */
+	poll:			NULL,			/* . */
+	ioctl:			NULL,			/* . */
+	mmap:			generic_file_mmap,	/* Mmap file. */
+	open:			generic_file_open,	/* Open file. */
+	flush:			NULL,			/* . */
+	release:		NULL,			/* . */
+	fsync:			NULL,			/* . */
+	fasync:			NULL,			/* . */
+	lock:			NULL,			/* . */
+	readv:			NULL,			/* . */
+	writev:			NULL,			/* . */
+	sendpage:		NULL,			/* . */
+	get_unmapped_area:	NULL,			/* . */
+};
+
+struct inode_operations ntfs_file_inode_ops = {
+	create:		NULL,		/* . */
+	lookup:		NULL,		/* . */
+	link:		NULL,		/* . */
+	unlink:		NULL,		/* . */
+	symlink:	NULL,		/* . */
+	mkdir:		NULL,		/* . */
+	rmdir:		NULL,		/* . */
+	mknod:		NULL,		/* . */
+	rename:		NULL,		/* . */
+	readlink:	NULL,		/* . */
+	follow_link:	NULL,		/* . */
+	truncate:	NULL,		/* . */
+	permission:	NULL,		/* . */
+	revalidate:	NULL,		/* . */
+	setattr:	NULL,		/* . */
+	getattr:	NULL,		/* . */
+};
+
+#if 0
+/* NOTE: read, write, poll, fsync, readv, writev can be called without the big
+ * kernel lock held in all filesystems. */
+struct file_operations {
+	struct module *owner;
+	loff_t (*llseek) (struct file *, loff_t, int);
+	ssize_t (*read) (struct file *, char *, size_t, loff_t *);
+	ssize_t (*write) (struct file *, const char *, size_t, loff_t *);
+	int (*readdir) (struct file *, void *, filldir_t);
+	unsigned int (*poll) (struct file *, struct poll_table_struct *);
+	int (*ioctl) (struct inode *, struct file *, unsigned int,
+			unsigned long);
+	int (*mmap) (struct file *, struct vm_area_struct *);
+	int (*flush) (struct file *);
+	int (*release) (struct inode *, struct file *);
+	int (*fsync) (struct file *, struct dentry *, int datasync);
+	int (*fasync) (int, struct file *, int);
+	int (*lock) (struct file *, int, struct file_lock *);
+	ssize_t (*readv) (struct file *, const struct iovec *, unsigned long,
+			loff_t *);
+	ssize_t (*writev) (struct file *, const struct iovec *, unsigned long,
+			loff_t *);
+	ssize_t (*sendpage) (struct file *, struct page *, int, size_t,
+			loff_t *, int);
+	unsigned long (*get_unmapped_area)(struct file *, unsigned long,
+			unsigned long, unsigned long, unsigned long);
+};
+
+struct inode_operations {
+	int (*create) (struct inode *,struct dentry *,int);
+	struct dentry * (*lookup) (struct inode *,struct dentry *);
+	int (*link) (struct dentry *,struct inode *,struct dentry *);
+	int (*unlink) (struct inode *,struct dentry *);
+	int (*symlink) (struct inode *,struct dentry *,const char *);
+	int (*mkdir) (struct inode *,struct dentry *,int);
+	int (*rmdir) (struct inode *,struct dentry *);
+	int (*mknod) (struct inode *,struct dentry *,int,int);
+	int (*rename) (struct inode *, struct dentry *,
+			struct inode *, struct dentry *);
+	int (*readlink) (struct dentry *, char *,int);
+	int (*follow_link) (struct dentry *, struct nameidata *);
+	void (*truncate) (struct inode *);
+	int (*permission) (struct inode *, int);
+	int (*revalidate) (struct dentry *);
+	int (*setattr) (struct dentry *, struct iattr *);
+	int (*getattr) (struct dentry *, struct iattr *);
+};
+#endif
+
+struct file_operations ntfs_empty_file_ops = {
+	llseek:			NULL,			/* . */
+	read:			NULL,			/* . */
+	write:			NULL,			/* . */
+	readdir:		NULL,			/* . */
+	poll:			NULL,			/* . */
+	ioctl:			NULL,			/* . */
+	mmap:			NULL,			/* . */
+	open:			NULL,			/* . */
+	flush:			NULL,			/* . */
+	release:		NULL,			/* . */
+	fsync:			NULL,			/* . */
+	fasync:			NULL,			/* . */
+	lock:			NULL,			/* . */
+	readv:			NULL,			/* . */
+	writev:			NULL,			/* . */
+	sendpage:		NULL,			/* . */
+	get_unmapped_area:	NULL,			/* . */
+};
+
+struct inode_operations ntfs_empty_inode_ops = {
+	create:		NULL,		/* . */
+	lookup:		NULL,		/* . */
+	link:		NULL,		/* . */
+	unlink:		NULL,		/* . */
+	symlink:	NULL,		/* . */
+	mkdir:		NULL,		/* . */
+	rmdir:		NULL,		/* . */
+	mknod:		NULL,		/* . */
+	rename:		NULL,		/* . */
+	readlink:	NULL,		/* . */
+	follow_link:	NULL,		/* . */
+	truncate:	NULL,		/* . */
+	permission:	NULL,		/* . */
+	revalidate:	NULL,		/* . */
+	setattr:	NULL,		/* . */
+	getattr:	NULL,		/* . */
+};
+

fs/ntfs/inode.h

+/*
+ * inode.h - Defines for inode structures NTFS Linux kernel driver. Part of
+ *	     the Linux-NTFS project.
+ *
+ * Copyright (c) 2001,2002 Anton Altaparmakov.
+ * Copyright (C) 2002 Richard Russon.
+ *
+ * This program/include file is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program/include file is distributed in the hope that it will be 
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty 
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program (in the main directory of the Linux-NTFS 
+ * distribution in the file COPYING); if not, write to the Free Software
+ * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _LINUX_NTFS_INODE_H
+#define _LINUX_NTFS_INODE_H
+
+#include <linux/seq_file.h>
+
+#include "volume.h"
+
+typedef struct _ntfs_inode ntfs_inode;
+
+/*
+ * The NTFS in-memory inode structure. It is just used as an extension to the
+ * fields already provided in the VFS inode.
+ */
+struct _ntfs_inode {
+	s64 initialized_size;	/* Copy from $DATA/$INDEX_ALLOCATION. */
+	s64 allocated_size;	/* Copy from $DATA/$INDEX_ALLOCATION. */
+	unsigned long state;	/* NTFS specific flags describing this inode.
+				   See fs/ntfs/ntfs.h:ntfs_inode_state_bits. */
+	u64 mft_no;		/* Mft record number (inode number). */
+	u16 seq_no;		/* Sequence number of the mft record. */
+	atomic_t count;		/* Inode reference count for book keeping. */
+	ntfs_volume *vol;	/* Pointer to the ntfs volume of this inode. */
+	run_list run_list;	/* If state has the NI_NonResident bit set,
+				   the run list of the unnamed data attribute
+				   (if a file) or of the index allocation
+				   attribute (directory). If run_list.rl is
+				   NULL, the run list has not been read in or
+				   has been unmapped. If NI_NonResident is
+				   clear, the unnamed data attribute is
+				   resident (file) or there is no $I30 index
+				   allocation attribute (directory). In that
+				   case run_list.rl is always NULL.*/
+	struct rw_semaphore mrec_lock;	/* Lock for serializing access to the
+				   mft record belonging to this inode. */
+	atomic_t mft_count;	/* Mapping reference count for book keeping. */
+	struct page *page;	/* The page containing the mft record of the
+				   inode. This should only be touched by the
+				   (un)map_mft_record*() functions. */
+	int page_ofs;		/* Offset into the page at which the mft record
+				   begins. This should only be touched by the
+				   (un)map_mft_record*() functions. */
+	/*
+	 * Attribute list support (only for use by the attribute lookup
+	 * functions). Setup during read_inode for all inodes with attribute
+	 * lists. Only valid if NI_AttrList is set in state, and attr_list_rl is
+	 * further only valid if NI_AttrListNonResident is set.
+	 */
+	u32 attr_list_size;	/* Length of attribute list value in bytes. */
+	u8 *attr_list;		/* Attribute list value itself. */
+	run_list attr_list_rl;	/* Run list for the attribute list value. */
+	union {
+		struct { /* It is a directory or $MFT. */
+			u32 index_block_size;	/* Size of an index block. */
+			u8 index_block_size_bits; /* Log2 of the above. */
+			u32 index_vcn_size;	/* Size of a vcn in this
+						   directory index. */
+			u8 index_vcn_size_bits;	/* Log2 of the above. */
+			s64 bmp_size;		/* Size of the $I30 bitmap. */
+			s64 bmp_initialized_size; /* Copy from $I30 bitmap. */
+			s64 bmp_allocated_size;	/* Copy from $I30 bitmap. */
+			run_list bmp_rl;	/* Run list for the $I30 bitmap
+						   if it is non-resident. */
+		} SN(idm);
+		struct { /* It is a compressed file. */
+			u32 compression_block_size;     /* Size of a compression
+						           block (cb). */
+			u8 compression_block_size_bits; /* Log2 of the size of
+							   a cb. */
+			u8 compression_block_clusters;  /* Number of clusters
+							   per compression
+							   block. */
+			s64 compressed_size;		/* Copy from $DATA. */
+		} SN(icf);
+	} SN(idc);
+	struct semaphore extent_lock;	/* Lock for accessing/modifying the
+					   below . */
+	s32 nr_extents;	/* For a base mft record, the number of attached extent
+			   inodes (0 if none), for extent records this is -1. */
+	union {		/* This union is only used if nr_extents != 0. */
+		ntfs_inode **extent_ntfs_inos;	/* For nr_extents > 0, array of
+						   the ntfs inodes of the extent
+						   mft records belonging to
+						   this base inode which have
+						   been loaded. */
+		ntfs_inode *base_ntfs_ino;	/* For nr_extents == -1, the
+						   vfs inode of the base mft
+						   record. */
+	} SN(ine);
+};
+
+#define _IDM(X)  SC(idc.idm,X)
+#define _ICF(X)  SC(idc.icf,X)
+#define _INE(X)  SC(ine,X)
+
+typedef struct {
+	ntfs_inode ntfs_inode;
+	struct inode vfs_inode;		/* The vfs inode structure. */
+} big_ntfs_inode;
+
+/**
+ * NTFS_I - return the ntfs inode given a vfs inode
+ * @inode:	VFS inode
+ *
+ * NTFS_I() returns the ntfs inode associated with the VFS @inode.
+ */
+static inline ntfs_inode *NTFS_I(struct inode *inode)
+{
+	return (ntfs_inode *)list_entry(inode, big_ntfs_inode, vfs_inode);
+}
+
+static inline struct inode *VFS_I(ntfs_inode *ni)
+{
+	return &((big_ntfs_inode*)ni)->vfs_inode;
+}
+
+extern struct inode *ntfs_alloc_big_inode(struct super_block *sb);
+extern void ntfs_destroy_big_inode(struct inode *inode);
+extern void ntfs_clear_big_inode(struct inode *vi);
+
+extern ntfs_inode *ntfs_new_inode(struct super_block *sb);
+extern void ntfs_clear_inode(ntfs_inode *ni);
+
+extern void ntfs_read_inode(struct inode *vi);
+extern void ntfs_read_inode_mount(struct inode *vi);
+
+extern void ntfs_dirty_inode(struct inode *vi);
+
+extern int ntfs_show_options(struct seq_file *sf, struct vfsmount *mnt);
+
+#endif /* _LINUX_NTFS_FS_INODE_H */
+

fs/ntfs/malloc.h

+/*
+ * malloc.h - NTFS kernel memory handling. Part of the Linux-NTFS project.
+ *
+ * Copyright (c) 2001,2002 Anton Altaparmakov.
+ *
+ * This program/include file is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program/include file is distributed in the hope that it will be 
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty 
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program (in the main directory of the Linux-NTFS 
+ * distribution in the file COPYING); if not, write to the Free Software
+ * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _LINUX_NTFS_MALLOC_H
+#define _LINUX_NTFS_MALLOC_H
+
+#include <linux/vmalloc.h>
+#include <linux/slab.h>
+
+/**
+ * vmalloc_nofs - allocate any pages but don't allow calls into fs layer
+ * @size:	number of bytes to allocate
+ *
+ * Allocate any pages but don't allow calls into fs layer. Return allocated
+ * memory or NULL if insufficient memory.
+ */
+static inline void *vmalloc_nofs(unsigned long size)
+{
+	if (likely(size >> PAGE_SHIFT < num_physpages))
+		return __vmalloc(size, GFP_NOFS | __GFP_HIGHMEM, PAGE_KERNEL);
+	return NULL;
+}
+
+/**
+ * ntfs_malloc_nofs - allocate memory in multiples of pages
+ * @size	number of bytes to allocate
+ *
+ * Allocates @size bytes of memory, rounded up to multiples of PAGE_SIZE and
+ * returns a pointer to the allocated memory.
+ *
+ * If there was insufficient memory to complete the request, return NULL.
+ */
+static inline void *ntfs_malloc_nofs(unsigned long size)
+{
+	if (likely(size <= PAGE_SIZE)) {
+		if (likely(size)) {
+			/* kmalloc() has per-CPU caches so if faster for now. */
+			return kmalloc(PAGE_SIZE, GFP_NOFS);
+			/* return (void *)__get_free_page(GFP_NOFS |
+					__GFP_HIGHMEM); */
+		}
+		BUG();
+	}
+	if (likely(size >> PAGE_SHIFT < num_physpages))
+		return __vmalloc(size, GFP_NOFS | __GFP_HIGHMEM, PAGE_KERNEL);
+	return NULL;
+}
+
+static inline void ntfs_free(void *addr)
+{
+	if (likely((unsigned long)addr < VMALLOC_START)) {
+		return kfree(addr);
+		/* return free_page((unsigned long)addr); */
+	}
+	vfree(addr);
+}
+
+#endif /* _LINUX_NTFS_MALLOC_H */
+

fs/ntfs/mft.h

+/*
+ * mft.h - Defines for mft record handling in NTFS Linux kernel driver.
+ *	   Part of the Linux-NTFS project.
+ *
+ * Copyright (c) 2001,2002 Anton Altaparmakov.
+ *
+ * This program/include file is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program/include file is distributed in the hope that it will be 
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty 
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program (in the main directory of the Linux-NTFS 
+ * distribution in the file COPYING); if not, write to the Free Software
+ * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _LINUX_NTFS_MFT_H
+#define _LINUX_NTFS_MFT_H
+
+#include <linux/fs.h>
+
+#include "inode.h"
+
+extern int format_mft_record(ntfs_inode *ni, MFT_RECORD *m);
+//extern int format_mft_record2(struct super_block *vfs_sb,
+//		const unsigned long inum, MFT_RECORD *m);
+
+extern MFT_RECORD *map_mft_record(const int rw, ntfs_inode *ni);
+extern void unmap_mft_record(const int rw, ntfs_inode *ni);
+
+extern MFT_RECORD *map_extent_mft_record(ntfs_inode *base_ni, MFT_REF mref,
+		ntfs_inode **ntfs_ino);
+
+static inline void unmap_extent_mft_record(ntfs_inode *ni)
+{
+	unmap_mft_record(READ, ni);
+	return;
+}
+
+#endif /* _LINUX_NTFS_MFT_H */
+

fs/ntfs/namei.c

+/*
+ * namei.c - NTFS kernel directory inode operations. Part of the Linux-NTFS
+ * 	     project.
+ *
+ * Copyright (c) 2001,2002 Anton Altaparmakov.
+ *
+ * This program/include file is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program/include file is distributed in the hope that it will be 
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty 
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program (in the main directory of the Linux-NTFS 
+ * distribution in the file COPYING); if not, write to the Free Software
+ * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "ntfs.h"
+
+/**
+ * ntfs_lookup - find the inode represented by a dentry in a directory inode
+ * @dir_ino:	directory inode in which to look for the inode
+ * @dent:	dentry representing the inode to look for
+ *
+ * In short, ntfs_lookup() looks for the inode represented by the dentry @dent
+ * in the directory inode @dir_ino and if found attaches the inode to the
+ * dentry @dent.
+ *
+ * In more detail, the dentry @dent specifies which inode to look for by
+ * supplying the name of the inode in @dent->d_name.name. ntfs_lookup()
+ * converts the name to Unicode and walks the contents of the directory inode
+ * @dir_ino looking for the converted Unicode name. If the name is found in the
+ * directory, the corresponding inode is loaded by calling iget() on its inode
+ * number and the inode is associated with the dentry @dent via a call to
+ * d_add().
+ *
+ * If the name is not found in the directory, a NULL inode is inserted into the
+ * dentry @dent. The dentry is then termed a negative dentry.
+ *
+ * Only if an actual error occurs, do we return an error via ERR_PTR().
+ */
+static struct dentry *ntfs_lookup(struct inode *dir_ino, struct dentry *dent)
+{
+	ntfs_volume *vol = NTFS_SB(dir_ino->i_sb);
+	struct inode *dent_inode;
+	u64 mref;
+	unsigned long dent_ino;
+	uchar_t *uname;
+	int uname_len;
+
+	ntfs_debug("Looking up %s in directory inode 0x%lx.",
+			dent->d_name.name, dir_ino->i_ino);
+	/* Convert the name of the dentry to Unicode. */
+	uname_len = ntfs_nlstoucs(vol, dent->d_name.name, dent->d_name.len,
+			&uname);
+	if (uname_len < 0) {
+		ntfs_error(vol->sb, "Failed to convert name to Unicode.");
+		return ERR_PTR(uname_len);
+	}
+	mref = ntfs_lookup_inode_by_name(NTFS_I(dir_ino), uname, uname_len);
+	kmem_cache_free(ntfs_name_cache, uname);
+	if (!IS_ERR_MREF(mref)) {
+		dent_ino = (unsigned long)MREF(mref);
+		ntfs_debug("Found inode 0x%lx. Calling iget.", dent_ino);
+		dent_inode = iget(vol->sb, dent_ino);
+		if (dent_inode) {
+			/* Consistency check. */
+			if (MSEQNO(mref) == NTFS_I(dent_inode)->seq_no ||
+					dent_ino == FILE_MFT) {
+				d_add(dent, dent_inode);
+				ntfs_debug("Done.");
+				return NULL;
+			}
+			ntfs_error(vol->sb, "Found stale reference to inode "
+					"0x%Lx (reference sequence number = "
+					"0x%x, inode sequence number = 0x%x, "
+					"returning -EACCES. Run chkdsk.",
+					(unsigned long long)MREF(mref),
+					MSEQNO(mref),
+					NTFS_I(dent_inode)->seq_no);
+			iput(dent_inode);
+		} else
+			ntfs_error(vol->sb, "iget(0x%Lx) failed, returning "
+					"-EACCES.",
+					(unsigned long long)MREF(mref));
+		return ERR_PTR(-EACCES);
+	}
+	if (MREF_ERR(mref) == -ENOENT) {
+		ntfs_debug("Entry was not found, adding negative dentry.");
+		/* The dcache will handle negative entries. */
+		d_add(dent, NULL);
+		ntfs_debug("Done.");
+		return NULL;
+	}
+	ntfs_error(vol->sb, "ntfs_lookup_ino_by_name() failed with error "
+			"code %i.", -MREF_ERR(mref));
+	return ERR_PTR(MREF_ERR(mref));
+}
+
+struct inode_operations ntfs_dir_inode_ops = {
+	create:		NULL,		/* . */
+	lookup:		ntfs_lookup,	/* lookup directory. */
+	link:		NULL,		/* . */
+	unlink:		NULL,		/* . */
+	symlink:	NULL,		/* . */
+	mkdir:		NULL,		/* . */
+	rmdir:		NULL,		/* . */
+	mknod:		NULL,		/* . */
+	rename:		NULL,		/* . */
+	readlink:	NULL,		/* . */
+	follow_link:	NULL,		/* . */
+	truncate:	NULL,		/* . */
+	permission:	NULL,		/* . */
+	revalidate:	NULL,		/* . */
+	setattr:	NULL,		/* . */
+	getattr:	NULL,		/* . */
+};
+
+#if 0
+struct inode_operations {
+	int (*create) (struct inode *,struct dentry *,int);
+	struct dentry * (*lookup) (struct inode *,struct dentry *);
+	int (*link) (struct dentry *,struct inode *,struct dentry *);
+	int (*unlink) (struct inode *,struct dentry *);
+	int (*symlink) (struct inode *,struct dentry *,const char *);
+	int (*mkdir) (struct inode *,struct dentry *,int);
+	int (*rmdir) (struct inode *,struct dentry *);
+	int (*mknod) (struct inode *,struct dentry *,int,int);
+	int (*rename) (struct inode *, struct dentry *,
+			struct inode *, struct dentry *);
+	int (*readlink) (struct dentry *, char *,int);
+	int (*follow_link) (struct dentry *, struct nameidata *);
+	void (*truncate) (struct inode *);
+	int (*permission) (struct inode *, int);
+	int (*revalidate) (struct dentry *);
+	int (*setattr) (struct dentry *, struct iattr *);
+	int (*getattr) (struct dentry *, struct iattr *);
+};
+#endif
+