[mirror_ubuntu-bionic-kernel.git] / fs / ntfs / inode.h

/*
 * inode.h - Defines for inode structures NTFS Linux kernel driver. Part of
 *	     the Linux-NTFS project.
 *
 * Copyright (c) 2001-2007 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/atomic.h>

#include <linux/fs.h>
#include <linux/list.h>
#include <linux/mm.h>
#include <linux/mutex.h>
#include <linux/seq_file.h>

#include "layout.h"
#include "volume.h"
#include "types.h"
#include "runlist.h"
#include "debug.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 {
	rwlock_t size_lock;	/* Lock serializing access to inode sizes. */
	s64 initialized_size;	/* Copy from the attribute record. */
	s64 allocated_size;	/* Copy from the attribute record. */
	unsigned long state;	/* NTFS specific flags describing this inode.
				   See ntfs_inode_state_bits below. */
	unsigned long mft_no;	/* Number of the mft record / inode. */
	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. */
	/*
	 * If NInoAttr() is true, the below fields describe the attribute which
	 * this fake inode belongs to. The actual inode of this attribute is
	 * pointed to by base_ntfs_ino and nr_extents is always set to -1 (see
	 * below). For real inodes, we also set the type (AT_DATA for files and
	 * AT_INDEX_ALLOCATION for directories), with the name = NULL and
	 * name_len = 0 for files and name = I30 (global constant) and
	 * name_len = 4 for directories.
	 */
	ATTR_TYPE type;	/* Attribute type of this fake inode. */
	ntfschar *name;		/* Attribute name of this fake inode. */
	u32 name_len;		/* Attribute name length of this fake inode. */
	runlist runlist;	/* If state has the NI_NonResident bit set,
				   the runlist of the unnamed data attribute
				   (if a file) or of the index allocation
				   attribute (directory) or of the attribute
				   described by the fake inode (if NInoAttr()).
				   If runlist.rl is NULL, the runlist has not
				   been read in yet or has been unmapped. If
				   NI_NonResident is clear, the attribute is
				   resident (file and fake inode) or there is
				   no $I30 index allocation attribute
				   (small directory). In the latter case
				   runlist.rl is always NULL.*/
	/*
	 * The following fields are only valid for real inodes and extent
	 * inodes.
	 */
	struct mutex mrec_lock;	/* Lock for serializing access to the
				   mft record belonging to this inode. */
	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. */
	runlist attr_list_rl;	/* Run list for the attribute list value. */
	union {
		struct { /* It is a directory, $MFT, or an index inode. */
			u32 block_size;		/* Size of an index block. */
			u32 vcn_size;		/* Size of a vcn in this
						   index. */
			COLLATION_RULE collation_rule; /* The collation rule
						   for the index. */
			u8 block_size_bits; 	/* Log2 of the above. */
			u8 vcn_size_bits;	/* Log2 of the above. */
		} index;
		struct { /* It is a compressed/sparse file/attribute inode. */
			s64 size;		/* Copy of compressed_size from
						   $DATA. */
			u32 block_size;		/* Size of a compression block
						   (cb). */
			u8 block_size_bits;	/* Log2 of the size of a cb. */
			u8 block_clusters;	/* Number of clusters per cb. */
		} compressed;
	} itype;
	struct mutex 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 and for fake
			   inodes describing an attribute 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
						   ntfs inode of the base mft
						   record. For fake inodes, the
						   real (base) inode to which
						   the attribute belongs. */
	} ext;
};

/*
 * Defined bits for the state field in the ntfs_inode structure.
 * (f) = files only, (d) = directories only, (a) = attributes/fake inodes only
 */
typedef enum {
	NI_Dirty,		/* 1: Mft record needs to be written to disk. */
	NI_AttrList,		/* 1: Mft record contains an attribute list. */
	NI_AttrListNonResident,	/* 1: Attribute list is non-resident. Implies
				      NI_AttrList is set. */

	NI_Attr,		/* 1: Fake inode for attribute i/o.
				   0: Real inode or extent inode. */

	NI_MstProtected,	/* 1: Attribute is protected by MST fixups.
				   0: Attribute is not protected by fixups. */
	NI_NonResident,		/* 1: Unnamed data attr is non-resident (f).
				   1: Attribute is non-resident (a). */
	NI_IndexAllocPresent = NI_NonResident,	/* 1: $I30 index alloc attr is
						   present (d). */
	NI_Compressed,		/* 1: Unnamed data attr is compressed (f).
				   1: Create compressed files by default (d).
				   1: Attribute is compressed (a). */
	NI_Encrypted,		/* 1: Unnamed data attr is encrypted (f).
				   1: Create encrypted files by default (d).
				   1: Attribute is encrypted (a). */
	NI_Sparse,		/* 1: Unnamed data attr is sparse (f).
				   1: Create sparse files by default (d).
				   1: Attribute is sparse (a). */
	NI_SparseDisabled,	/* 1: May not create sparse regions. */
	NI_TruncateFailed,	/* 1: Last ntfs_truncate() call failed. */
} ntfs_inode_state_bits;

/*
 * NOTE: We should be adding dirty mft records to a list somewhere and they
 * should be independent of the (ntfs/vfs) inode structure so that an inode can
 * be removed but the record can be left dirty for syncing later.
 */

/*
 * Macro tricks to expand the NInoFoo(), NInoSetFoo(), and NInoClearFoo()
 * functions.
 */
#define NINO_FNS(flag)					\
static inline int NIno##flag(ntfs_inode *ni)		\
{							\
	return test_bit(NI_##flag, &(ni)->state);	\
}							\
static inline void NInoSet##flag(ntfs_inode *ni)	\
{							\
	set_bit(NI_##flag, &(ni)->state);		\
}							\
static inline void NInoClear##flag(ntfs_inode *ni)	\
{							\
	clear_bit(NI_##flag, &(ni)->state);		\
}

/*
 * As above for NInoTestSetFoo() and NInoTestClearFoo().
 */
#define TAS_NINO_FNS(flag)					\
static inline int NInoTestSet##flag(ntfs_inode *ni)		\
{								\
	return test_and_set_bit(NI_##flag, &(ni)->state);	\
}								\
static inline int NInoTestClear##flag(ntfs_inode *ni)		\
{								\
	return test_and_clear_bit(NI_##flag, &(ni)->state);	\
}

/* Emit the ntfs inode bitops functions. */
NINO_FNS(Dirty)
TAS_NINO_FNS(Dirty)
NINO_FNS(AttrList)
NINO_FNS(AttrListNonResident)
NINO_FNS(Attr)
NINO_FNS(MstProtected)
NINO_FNS(NonResident)
NINO_FNS(IndexAllocPresent)
NINO_FNS(Compressed)
NINO_FNS(Encrypted)
NINO_FNS(Sparse)
NINO_FNS(SparseDisabled)
NINO_FNS(TruncateFailed)

/*
 * The full structure containing a ntfs_inode and a vfs struct inode. Used for
 * all real and fake inodes but not for extent inodes which lack the vfs struct
 * inode.
 */
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 *)container_of(inode, big_ntfs_inode, vfs_inode);
}

static inline struct inode *VFS_I(ntfs_inode *ni)
{
	return &((big_ntfs_inode *)ni)->vfs_inode;
}

/**
 * ntfs_attr - ntfs in memory attribute structure
 * @mft_no:	mft record number of the base mft record of this attribute
 * @name:	Unicode name of the attribute (NULL if unnamed)
 * @name_len:	length of @name in Unicode characters (0 if unnamed)
 * @type:	attribute type (see layout.h)
 *
 * This structure exists only to provide a small structure for the
 * ntfs_{attr_}iget()/ntfs_test_inode()/ntfs_init_locked_inode() mechanism.
 *
 * NOTE: Elements are ordered by size to make the structure as compact as
 * possible on all architectures.
 */
typedef struct {
	unsigned long mft_no;
	ntfschar *name;
	u32 name_len;
	ATTR_TYPE type;
} ntfs_attr;

typedef int (*test_t)(struct inode *, void *);

extern int ntfs_test_inode(struct inode *vi, ntfs_attr *na);

extern struct inode *ntfs_iget(struct super_block *sb, unsigned long mft_no);
extern struct inode *ntfs_attr_iget(struct inode *base_vi, ATTR_TYPE type,
		ntfschar *name, u32 name_len);
extern struct inode *ntfs_index_iget(struct inode *base_vi, ntfschar *name,
		u32 name_len);

extern struct inode *ntfs_alloc_big_inode(struct super_block *sb);
extern void ntfs_destroy_big_inode(struct inode *inode);
extern void ntfs_evict_big_inode(struct inode *vi);

extern void __ntfs_init_inode(struct super_block *sb, ntfs_inode *ni);

static inline void ntfs_init_big_inode(struct inode *vi)
{
	ntfs_inode *ni = NTFS_I(vi);

	ntfs_debug("Entering.");
	__ntfs_init_inode(vi->i_sb, ni);
	ni->mft_no = vi->i_ino;
}

extern ntfs_inode *ntfs_new_extent_inode(struct super_block *sb,
		unsigned long mft_no);
extern void ntfs_clear_extent_inode(ntfs_inode *ni);

extern int ntfs_read_inode_mount(struct inode *vi);

extern int ntfs_show_options(struct seq_file *sf, struct dentry *root);

#ifdef NTFS_RW

extern int ntfs_truncate(struct inode *vi);
extern void ntfs_truncate_vfs(struct inode *vi);

extern int ntfs_setattr(struct dentry *dentry, struct iattr *attr);

extern int __ntfs_write_inode(struct inode *vi, int sync);

static inline void ntfs_commit_inode(struct inode *vi)
{
	if (!is_bad_inode(vi))
		__ntfs_write_inode(vi, 1);
	return;
}

#else

static inline void ntfs_truncate_vfs(struct inode *vi) {}

#endif /* NTFS_RW */

#endif /* _LINUX_NTFS_INODE_H */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* inode.h - Defines for inode structures NTFS Linux kernel driver. Part of
	3	* the Linux-NTFS project.
	4	*
8331191e	5	* Copyright (c) 2001-2007 Anton Altaparmakov
1da177e4 LT	6	* Copyright (c) 2002 Richard Russon
	7	*
	8	* This program/include file is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License as published
	10	* by the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program/include file is distributed in the hope that it will be
	14	* useful, but WITHOUT ANY WARRANTY; without even the implied warranty
	15	* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program (in the main directory of the Linux-NTFS
	20	* distribution in the file COPYING); if not, write to the Free Software
	21	* Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	22	*/
	23
	24	#ifndef _LINUX_NTFS_INODE_H
	25	#define _LINUX_NTFS_INODE_H
	26
60063497	27	#include <linux/atomic.h>
4e5e529a	28
1da177e4	29	#include <linux/fs.h>
1da177e4	30	#include <linux/list.h>
4e5e529a IM	31	#include <linux/mm.h>
	32	#include <linux/mutex.h>
	33	#include <linux/seq_file.h>
1da177e4 LT	34
	35	#include "layout.h"
	36	#include "volume.h"
	37	#include "types.h"
	38	#include "runlist.h"
	39	#include "debug.h"
	40
	41	typedef struct _ntfs_inode ntfs_inode;
	42
	43	/*
	44	* The NTFS in-memory inode structure. It is just used as an extension to the
	45	* fields already provided in the VFS inode.
	46	*/
	47	struct _ntfs_inode {
36763677	48	rwlock_t size_lock; /* Lock serializing access to inode sizes. */
1da177e4 LT	49	s64 initialized_size; /* Copy from the attribute record. */
	50	s64 allocated_size; /* Copy from the attribute record. */
	51	unsigned long state; /* NTFS specific flags describing this inode.
	52	See ntfs_inode_state_bits below. */
	53	unsigned long mft_no; /* Number of the mft record / inode. */
	54	u16 seq_no; /* Sequence number of the mft record. */
	55	atomic_t count; /* Inode reference count for book keeping. */
	56	ntfs_volume vol; / Pointer to the ntfs volume of this inode. */
	57	/*
	58	* If NInoAttr() is true, the below fields describe the attribute which
	59	* this fake inode belongs to. The actual inode of this attribute is
	60	* pointed to by base_ntfs_ino and nr_extents is always set to -1 (see
	61	* below). For real inodes, we also set the type (AT_DATA for files and
	62	* AT_INDEX_ALLOCATION for directories), with the name = NULL and
	63	* name_len = 0 for files and name = I30 (global constant) and
	64	* name_len = 4 for directories.
	65	*/
	66	ATTR_TYPE type; /* Attribute type of this fake inode. */
	67	ntfschar name; / Attribute name of this fake inode. */
	68	u32 name_len; /* Attribute name length of this fake inode. */
	69	runlist runlist; /* If state has the NI_NonResident bit set,
	70	the runlist of the unnamed data attribute
	71	(if a file) or of the index allocation
	72	attribute (directory) or of the attribute
	73	described by the fake inode (if NInoAttr()).
	74	If runlist.rl is NULL, the runlist has not
	75	been read in yet or has been unmapped. If
	76	NI_NonResident is clear, the attribute is
	77	resident (file and fake inode) or there is
	78	no $I30 index allocation attribute
	79	(small directory). In the latter case
	80	runlist.rl is always NULL.*/
	81	/*
	82	* The following fields are only valid for real inodes and extent
	83	* inodes.
	84	*/
4e5e529a	85	struct mutex mrec_lock; /* Lock for serializing access to the
1da177e4 LT	86	mft record belonging to this inode. */
	87	struct page page; / The page containing the mft record of the
	88	inode. This should only be touched by the
	89	(un)map_mft_record() functions. /
	90	int page_ofs; /* Offset into the page at which the mft record
	91	begins. This should only be touched by the
	92	(un)map_mft_record() functions. /
	93	/*
	94	* Attribute list support (only for use by the attribute lookup
	95	* functions). Setup during read_inode for all inodes with attribute
	96	* lists. Only valid if NI_AttrList is set in state, and attr_list_rl is
	97	* further only valid if NI_AttrListNonResident is set.
	98	*/
	99	u32 attr_list_size; /* Length of attribute list value in bytes. */
	100	u8 attr_list; / Attribute list value itself. */
	101	runlist attr_list_rl; /* Run list for the attribute list value. */
	102	union {
	103	struct { /* It is a directory, $MFT, or an index inode. */
1da177e4 LT	104	u32 block_size; /* Size of an index block. */
	105	u32 vcn_size; /* Size of a vcn in this
	106	index. */
	107	COLLATION_RULE collation_rule; /* The collation rule
	108	for the index. */
	109	u8 block_size_bits; /* Log2 of the above. */
	110	u8 vcn_size_bits; /* Log2 of the above. */
	111	} index;
3bd1f4a1	112	struct { /* It is a compressed/sparse file/attribute inode. */
1da177e4 LT	113	s64 size; /* Copy of compressed_size from
	114	$DATA. */
	115	u32 block_size; /* Size of a compression block
	116	(cb). */
	117	u8 block_size_bits; /* Log2 of the size of a cb. */
	118	u8 block_clusters; /* Number of clusters per cb. */
	119	} compressed;
	120	} itype;
4e5e529a	121	struct mutex extent_lock; /* Lock for accessing/modifying the
1da177e4 LT	122	below . */
	123	s32 nr_extents; /* For a base mft record, the number of attached extent
	124	inodes (0 if none), for extent records and for fake
	125	inodes describing an attribute this is -1. */
	126	union { /* This union is only used if nr_extents != 0. */
	127	ntfs_inode *extent_ntfs_inos; / For nr_extents > 0, array of
	128	the ntfs inodes of the extent
	129	mft records belonging to
	130	this base inode which have
	131	been loaded. */
	132	ntfs_inode base_ntfs_ino; / For nr_extents == -1, the
	133	ntfs inode of the base mft
	134	record. For fake inodes, the
	135	real (base) inode to which
	136	the attribute belongs. */
	137	} ext;
	138	};
	139
	140	/*
	141	* Defined bits for the state field in the ntfs_inode structure.
	142	* (f) = files only, (d) = directories only, (a) = attributes/fake inodes only
	143	*/
	144	typedef enum {
	145	NI_Dirty, /* 1: Mft record needs to be written to disk. */
	146	NI_AttrList, /* 1: Mft record contains an attribute list. */
	147	NI_AttrListNonResident, /* 1: Attribute list is non-resident. Implies
	148	NI_AttrList is set. */
	149
	150	NI_Attr, /* 1: Fake inode for attribute i/o.
	151	0: Real inode or extent inode. */
	152
	153	NI_MstProtected, /* 1: Attribute is protected by MST fixups.
	154	0: Attribute is not protected by fixups. */
	155	NI_NonResident, /* 1: Unnamed data attr is non-resident (f).
	156	1: Attribute is non-resident (a). */
	157	NI_IndexAllocPresent = NI_NonResident, /* 1: $I30 index alloc attr is
	158	present (d). */
	159	NI_Compressed, /* 1: Unnamed data attr is compressed (f).
	160	1: Create compressed files by default (d).
	161	1: Attribute is compressed (a). */
	162	NI_Encrypted, /* 1: Unnamed data attr is encrypted (f).
	163	1: Create encrypted files by default (d).
	164	1: Attribute is encrypted (a). */
	165	NI_Sparse, /* 1: Unnamed data attr is sparse (f).
	166	1: Create sparse files by default (d).
	167	1: Attribute is sparse (a). */
c002f425	168	NI_SparseDisabled, /* 1: May not create sparse regions. */
1da177e4 LT	169	NI_TruncateFailed, /* 1: Last ntfs_truncate() call failed. */
	170	} ntfs_inode_state_bits;
	171
	172	/*
	173	* NOTE: We should be adding dirty mft records to a list somewhere and they
	174	* should be independent of the (ntfs/vfs) inode structure so that an inode can
	175	* be removed but the record can be left dirty for syncing later.
	176	*/
	177
	178	/*
	179	* Macro tricks to expand the NInoFoo(), NInoSetFoo(), and NInoClearFoo()
	180	* functions.
	181	*/
	182	#define NINO_FNS(flag) \
	183	static inline int NIno##flag(ntfs_inode *ni) \
	184	{ \
	185	return test_bit(NI_##flag, &(ni)->state); \
	186	} \
	187	static inline void NInoSet##flag(ntfs_inode *ni) \
	188	{ \
	189	set_bit(NI_##flag, &(ni)->state); \
	190	} \
	191	static inline void NInoClear##flag(ntfs_inode *ni) \
	192	{ \
	193	clear_bit(NI_##flag, &(ni)->state); \
	194	}
	195
	196	/*
	197	* As above for NInoTestSetFoo() and NInoTestClearFoo().
	198	*/
	199	#define TAS_NINO_FNS(flag) \
	200	static inline int NInoTestSet##flag(ntfs_inode *ni) \
	201	{ \
	202	return test_and_set_bit(NI_##flag, &(ni)->state); \
	203	} \
	204	static inline int NInoTestClear##flag(ntfs_inode *ni) \
	205	{ \
	206	return test_and_clear_bit(NI_##flag, &(ni)->state); \
	207	}
	208
	209	/* Emit the ntfs inode bitops functions. */
	210	NINO_FNS(Dirty)
	211	TAS_NINO_FNS(Dirty)
	212	NINO_FNS(AttrList)
	213	NINO_FNS(AttrListNonResident)
	214	NINO_FNS(Attr)
	215	NINO_FNS(MstProtected)
	216	NINO_FNS(NonResident)
	217	NINO_FNS(IndexAllocPresent)
	218	NINO_FNS(Compressed)
	219	NINO_FNS(Encrypted)
	220	NINO_FNS(Sparse)
c002f425	221	NINO_FNS(SparseDisabled)
1da177e4 LT	222	NINO_FNS(TruncateFailed)
	223
	224	/*
	225	* The full structure containing a ntfs_inode and a vfs struct inode. Used for
	226	* all real and fake inodes but not for extent inodes which lack the vfs struct
	227	* inode.
	228	*/
	229	typedef struct {
	230	ntfs_inode ntfs_inode;
	231	struct inode vfs_inode; /* The vfs inode structure. */
	232	} big_ntfs_inode;
	233
	234	/**
	235	* NTFS_I - return the ntfs inode given a vfs inode
	236	* @inode: VFS inode
	237	*
	238	* NTFS_I() returns the ntfs inode associated with the VFS @inode.
	239	*/
	240	static inline ntfs_inode NTFS_I(struct inode inode)
	241	{
db6172c4	242	return (ntfs_inode *)container_of(inode, big_ntfs_inode, vfs_inode);
1da177e4 LT	243	}
	244
	245	static inline struct inode VFS_I(ntfs_inode ni)
	246	{
	247	return &((big_ntfs_inode *)ni)->vfs_inode;
	248	}
	249
	250	/**
	251	* ntfs_attr - ntfs in memory attribute structure
	252	* @mft_no: mft record number of the base mft record of this attribute
	253	* @name: Unicode name of the attribute (NULL if unnamed)
	254	* @name_len: length of @name in Unicode characters (0 if unnamed)
	255	* @type: attribute type (see layout.h)
	256	*
	257	* This structure exists only to provide a small structure for the
	258	* ntfs_{attr_}iget()/ntfs_test_inode()/ntfs_init_locked_inode() mechanism.
	259	*
	260	* NOTE: Elements are ordered by size to make the structure as compact as
	261	* possible on all architectures.
	262	*/
	263	typedef struct {
	264	unsigned long mft_no;
	265	ntfschar *name;
	266	u32 name_len;
	267	ATTR_TYPE type;
	268	} ntfs_attr;
	269
	270	typedef int (test_t)(struct inode , void *);
	271
	272	extern int ntfs_test_inode(struct inode vi, ntfs_attr na);
	273
	274	extern struct inode ntfs_iget(struct super_block sb, unsigned long mft_no);
	275	extern struct inode ntfs_attr_iget(struct inode base_vi, ATTR_TYPE type,
	276	ntfschar *name, u32 name_len);
	277	extern struct inode ntfs_index_iget(struct inode base_vi, ntfschar *name,
	278	u32 name_len);
	279
	280	extern struct inode ntfs_alloc_big_inode(struct super_block sb);
	281	extern void ntfs_destroy_big_inode(struct inode *inode);
b57922d9	282	extern void ntfs_evict_big_inode(struct inode *vi);
1da177e4 LT	283
	284	extern void __ntfs_init_inode(struct super_block sb, ntfs_inode ni);
	285
	286	static inline void ntfs_init_big_inode(struct inode *vi)
	287	{
	288	ntfs_inode *ni = NTFS_I(vi);
	289
	290	ntfs_debug("Entering.");
	291	__ntfs_init_inode(vi->i_sb, ni);
	292	ni->mft_no = vi->i_ino;
	293	}
	294
	295	extern ntfs_inode ntfs_new_extent_inode(struct super_block sb,
	296	unsigned long mft_no);
	297	extern void ntfs_clear_extent_inode(ntfs_inode *ni);
	298
	299	extern int ntfs_read_inode_mount(struct inode *vi);
	300
34c80b1d	301	extern int ntfs_show_options(struct seq_file sf, struct dentry root);
1da177e4 LT	302
	303	#ifdef NTFS_RW
	304
	305	extern int ntfs_truncate(struct inode *vi);
	306	extern void ntfs_truncate_vfs(struct inode *vi);
	307
	308	extern int ntfs_setattr(struct dentry dentry, struct iattr attr);
	309
a9185b41	310	extern int __ntfs_write_inode(struct inode *vi, int sync);
1da177e4 LT	311
	312	static inline void ntfs_commit_inode(struct inode *vi)
	313	{
	314	if (!is_bad_inode(vi))
a9185b41	315	__ntfs_write_inode(vi, 1);
1da177e4 LT	316	return;
	317	}
	318
9014da75 MS	319	#else
	320
	321	static inline void ntfs_truncate_vfs(struct inode *vi) {}
	322
1da177e4 LT	323	#endif /* NTFS_RW */
	324
	325	#endif /* _LINUX_NTFS_INODE_H */