inode.h

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*
    2  * inode.h - Defines for inode structures NTFS Linux kernel driver. Part of
    3  *           the Linux-NTFS project.
    4  *
    5  * Copyright (c) 2001-2007 Anton Altaparmakov
    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 
   27 #include <linux/atomic.h>
   28 
   29 #include <linux/fs.h>
   30 #include <linux/list.h>
   31 #include <linux/mm.h>
   32 #include <linux/mutex.h>
   33 #include <linux/seq_file.h>
   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 {
   48         rwlock_t size_lock;     /* Lock serializing access to inode sizes. */
   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          */
   85         struct mutex mrec_lock; /* Lock for serializing access to the
   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. */
  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;
  112                 struct { /* It is a compressed/sparse file/attribute inode. */
  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;
  121         struct mutex extent_lock;       /* Lock for accessing/modifying the
  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). */
  168         NI_SparseDisabled,      /* 1: May not create sparse regions. */
  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)
  221 NINO_FNS(SparseDisabled)
  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 {
  242         return (ntfs_inode *)list_entry(inode, big_ntfs_inode, vfs_inode);
  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);
  282 extern void ntfs_evict_big_inode(struct inode *vi);
  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 
  301 extern int ntfs_show_options(struct seq_file *sf, struct dentry *root);
  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 
  310 extern int __ntfs_write_inode(struct inode *vi, int sync);
  311 
  312 static inline void ntfs_commit_inode(struct inode *vi)
  313 {
  314         if (!is_bad_inode(vi))
  315                 __ntfs_write_inode(vi, 1);
  316         return;
  317 }
  318 
  319 #else
  320 
  321 static inline void ntfs_truncate_vfs(struct inode *vi) {}
  322 
  323 #endif /* NTFS_RW */
  324 
  325 #endif /* _LINUX_NTFS_INODE_H */
Cache object: f1f604f00893f77addb6ce224a265ccc
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/fs/ntfs/inode.h

FreeBSD/Linux Kernel Cross Reference
sys/fs/ntfs/inode.h
