cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

inode.h (10560B)


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