2 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18 #ifndef __XFS_INODE_H__
19 #define __XFS_INODE_H__
21 #include "xfs_inode_buf.h"
22 #include "xfs_inode_fork.h"
25 * Kernel only inode definitions
32 struct xfs_inode_log_item
;
37 typedef struct xfs_inode
{
38 /* Inode linking and identification information. */
39 struct xfs_mount
*i_mount
; /* fs mount struct ptr */
40 struct xfs_dquot
*i_udquot
; /* user dquot */
41 struct xfs_dquot
*i_gdquot
; /* group dquot */
42 struct xfs_dquot
*i_pdquot
; /* project dquot */
44 /* Inode location stuff */
45 xfs_ino_t i_ino
; /* inode number (agno/agino)*/
46 struct xfs_imap i_imap
; /* location for xfs_imap() */
48 /* Extent information. */
49 xfs_ifork_t
*i_afp
; /* attribute fork pointer */
50 xfs_ifork_t i_df
; /* data fork */
52 /* Transaction and locking information. */
53 struct xfs_inode_log_item
*i_itemp
; /* logging information */
54 mrlock_t i_lock
; /* inode lock */
55 mrlock_t i_iolock
; /* inode IO lock */
56 atomic_t i_pincount
; /* inode pin count */
57 spinlock_t i_flags_lock
; /* inode i_flags lock */
58 /* Miscellaneous state. */
59 unsigned long i_flags
; /* see defined flags below */
60 unsigned int i_delayed_blks
; /* count of delay alloc blks */
62 xfs_icdinode_t i_d
; /* most of ondisk inode */
65 struct inode i_vnode
; /* embedded VFS inode */
68 /* Convert from vfs inode to xfs inode */
69 static inline struct xfs_inode
*XFS_I(struct inode
*inode
)
71 return container_of(inode
, struct xfs_inode
, i_vnode
);
74 /* convert from xfs inode to vfs inode */
75 static inline struct inode
*VFS_I(struct xfs_inode
*ip
)
81 * For regular files we only update the on-disk filesize when actually
82 * writing data back to disk. Until then only the copy in the VFS inode
85 static inline xfs_fsize_t
XFS_ISIZE(struct xfs_inode
*ip
)
87 if (S_ISREG(ip
->i_d
.di_mode
))
88 return i_size_read(VFS_I(ip
));
89 return ip
->i_d
.di_size
;
93 * If this I/O goes past the on-disk inode size update it unless it would
94 * be past the current in-core inode size.
96 static inline xfs_fsize_t
97 xfs_new_eof(struct xfs_inode
*ip
, xfs_fsize_t new_size
)
99 xfs_fsize_t i_size
= i_size_read(VFS_I(ip
));
101 if (new_size
> i_size
)
103 return new_size
> ip
->i_d
.di_size
? new_size
: 0;
107 * i_flags helper functions
110 __xfs_iflags_set(xfs_inode_t
*ip
, unsigned short flags
)
112 ip
->i_flags
|= flags
;
116 xfs_iflags_set(xfs_inode_t
*ip
, unsigned short flags
)
118 spin_lock(&ip
->i_flags_lock
);
119 __xfs_iflags_set(ip
, flags
);
120 spin_unlock(&ip
->i_flags_lock
);
124 xfs_iflags_clear(xfs_inode_t
*ip
, unsigned short flags
)
126 spin_lock(&ip
->i_flags_lock
);
127 ip
->i_flags
&= ~flags
;
128 spin_unlock(&ip
->i_flags_lock
);
132 __xfs_iflags_test(xfs_inode_t
*ip
, unsigned short flags
)
134 return (ip
->i_flags
& flags
);
138 xfs_iflags_test(xfs_inode_t
*ip
, unsigned short flags
)
141 spin_lock(&ip
->i_flags_lock
);
142 ret
= __xfs_iflags_test(ip
, flags
);
143 spin_unlock(&ip
->i_flags_lock
);
148 xfs_iflags_test_and_clear(xfs_inode_t
*ip
, unsigned short flags
)
152 spin_lock(&ip
->i_flags_lock
);
153 ret
= ip
->i_flags
& flags
;
155 ip
->i_flags
&= ~flags
;
156 spin_unlock(&ip
->i_flags_lock
);
161 xfs_iflags_test_and_set(xfs_inode_t
*ip
, unsigned short flags
)
165 spin_lock(&ip
->i_flags_lock
);
166 ret
= ip
->i_flags
& flags
;
168 ip
->i_flags
|= flags
;
169 spin_unlock(&ip
->i_flags_lock
);
174 * Project quota id helpers (previously projid was 16bit only
175 * and using two 16bit values to hold new 32bit projid was chosen
176 * to retain compatibility with "old" filesystems).
179 xfs_get_projid(struct xfs_inode
*ip
)
181 return (prid_t
)ip
->i_d
.di_projid_hi
<< 16 | ip
->i_d
.di_projid_lo
;
185 xfs_set_projid(struct xfs_inode
*ip
,
188 ip
->i_d
.di_projid_hi
= (__uint16_t
) (projid
>> 16);
189 ip
->i_d
.di_projid_lo
= (__uint16_t
) (projid
& 0xffff);
193 * In-core inode flags.
195 #define XFS_IRECLAIM (1 << 0) /* started reclaiming this inode */
196 #define XFS_ISTALE (1 << 1) /* inode has been staled */
197 #define XFS_IRECLAIMABLE (1 << 2) /* inode can be reclaimed */
198 #define XFS_INEW (1 << 3) /* inode has just been allocated */
199 #define XFS_IFILESTREAM (1 << 4) /* inode is in a filestream dir. */
200 #define XFS_ITRUNCATED (1 << 5) /* truncated down so flush-on-close */
201 #define XFS_IDIRTY_RELEASE (1 << 6) /* dirty release already seen */
202 #define __XFS_IFLOCK_BIT 7 /* inode is being flushed right now */
203 #define XFS_IFLOCK (1 << __XFS_IFLOCK_BIT)
204 #define __XFS_IPINNED_BIT 8 /* wakeup key for zero pin count */
205 #define XFS_IPINNED (1 << __XFS_IPINNED_BIT)
206 #define XFS_IDONTCACHE (1 << 9) /* don't cache the inode long term */
209 * Per-lifetime flags need to be reset when re-using a reclaimable inode during
210 * inode lookup. This prevents unintended behaviour on the new inode from
213 #define XFS_IRECLAIM_RESET_FLAGS \
214 (XFS_IRECLAIMABLE | XFS_IRECLAIM | \
215 XFS_IDIRTY_RELEASE | XFS_ITRUNCATED | \
219 * Synchronize processes attempting to flush the in-core inode back to disk.
222 extern void __xfs_iflock(struct xfs_inode
*ip
);
224 static inline int xfs_iflock_nowait(struct xfs_inode
*ip
)
226 return !xfs_iflags_test_and_set(ip
, XFS_IFLOCK
);
229 static inline void xfs_iflock(struct xfs_inode
*ip
)
231 if (!xfs_iflock_nowait(ip
))
235 static inline void xfs_ifunlock(struct xfs_inode
*ip
)
237 xfs_iflags_clear(ip
, XFS_IFLOCK
);
239 wake_up_bit(&ip
->i_flags
, __XFS_IFLOCK_BIT
);
242 static inline int xfs_isiflocked(struct xfs_inode
*ip
)
244 return xfs_iflags_test(ip
, XFS_IFLOCK
);
248 * Flags for inode locking.
249 * Bit ranges: 1<<1 - 1<<16-1 -- iolock/ilock modes (bitfield)
250 * 1<<16 - 1<<32-1 -- lockdep annotation (integers)
252 #define XFS_IOLOCK_EXCL (1<<0)
253 #define XFS_IOLOCK_SHARED (1<<1)
254 #define XFS_ILOCK_EXCL (1<<2)
255 #define XFS_ILOCK_SHARED (1<<3)
257 #define XFS_LOCK_MASK (XFS_IOLOCK_EXCL | XFS_IOLOCK_SHARED \
258 | XFS_ILOCK_EXCL | XFS_ILOCK_SHARED)
260 #define XFS_LOCK_FLAGS \
261 { XFS_IOLOCK_EXCL, "IOLOCK_EXCL" }, \
262 { XFS_IOLOCK_SHARED, "IOLOCK_SHARED" }, \
263 { XFS_ILOCK_EXCL, "ILOCK_EXCL" }, \
264 { XFS_ILOCK_SHARED, "ILOCK_SHARED" }
268 * Flags for lockdep annotations.
270 * XFS_LOCK_PARENT - for directory operations that require locking a
271 * parent directory inode and a child entry inode. The parent gets locked
272 * with this flag so it gets a lockdep subclass of 1 and the child entry
273 * lock will have a lockdep subclass of 0.
275 * XFS_LOCK_RTBITMAP/XFS_LOCK_RTSUM - the realtime device bitmap and summary
276 * inodes do not participate in the normal lock order, and thus have their
279 * XFS_LOCK_INUMORDER - for locking several inodes at the some time
280 * with xfs_lock_inodes(). This flag is used as the starting subclass
281 * and each subsequent lock acquired will increment the subclass by one.
282 * So the first lock acquired will have a lockdep subclass of 4, the
283 * second lock will have a lockdep subclass of 5, and so on. It is
284 * the responsibility of the class builder to shift this to the correct
285 * portion of the lock_mode lockdep mask.
287 #define XFS_LOCK_PARENT 1
288 #define XFS_LOCK_RTBITMAP 2
289 #define XFS_LOCK_RTSUM 3
290 #define XFS_LOCK_INUMORDER 4
292 #define XFS_IOLOCK_SHIFT 16
293 #define XFS_IOLOCK_PARENT (XFS_LOCK_PARENT << XFS_IOLOCK_SHIFT)
295 #define XFS_ILOCK_SHIFT 24
296 #define XFS_ILOCK_PARENT (XFS_LOCK_PARENT << XFS_ILOCK_SHIFT)
297 #define XFS_ILOCK_RTBITMAP (XFS_LOCK_RTBITMAP << XFS_ILOCK_SHIFT)
298 #define XFS_ILOCK_RTSUM (XFS_LOCK_RTSUM << XFS_ILOCK_SHIFT)
300 #define XFS_IOLOCK_DEP_MASK 0x00ff0000
301 #define XFS_ILOCK_DEP_MASK 0xff000000
302 #define XFS_LOCK_DEP_MASK (XFS_IOLOCK_DEP_MASK | XFS_ILOCK_DEP_MASK)
304 #define XFS_IOLOCK_DEP(flags) (((flags) & XFS_IOLOCK_DEP_MASK) >> XFS_IOLOCK_SHIFT)
305 #define XFS_ILOCK_DEP(flags) (((flags) & XFS_ILOCK_DEP_MASK) >> XFS_ILOCK_SHIFT)
308 * For multiple groups support: if S_ISGID bit is set in the parent
309 * directory, group of new file is set to that of the parent, and
310 * new subdirectory gets S_ISGID bit from parent.
312 #define XFS_INHERIT_GID(pip) \
313 (((pip)->i_mount->m_flags & XFS_MOUNT_GRPID) || \
314 ((pip)->i_d.di_mode & S_ISGID))
317 int xfs_release(struct xfs_inode
*ip
);
318 void xfs_inactive(struct xfs_inode
*ip
);
319 int xfs_lookup(struct xfs_inode
*dp
, struct xfs_name
*name
,
320 struct xfs_inode
**ipp
, struct xfs_name
*ci_name
);
321 int xfs_create(struct xfs_inode
*dp
, struct xfs_name
*name
,
322 umode_t mode
, xfs_dev_t rdev
, struct xfs_inode
**ipp
);
323 int xfs_remove(struct xfs_inode
*dp
, struct xfs_name
*name
,
324 struct xfs_inode
*ip
);
325 int xfs_link(struct xfs_inode
*tdp
, struct xfs_inode
*sip
,
326 struct xfs_name
*target_name
);
327 int xfs_rename(struct xfs_inode
*src_dp
, struct xfs_name
*src_name
,
328 struct xfs_inode
*src_ip
, struct xfs_inode
*target_dp
,
329 struct xfs_name
*target_name
,
330 struct xfs_inode
*target_ip
);
332 void xfs_ilock(xfs_inode_t
*, uint
);
333 int xfs_ilock_nowait(xfs_inode_t
*, uint
);
334 void xfs_iunlock(xfs_inode_t
*, uint
);
335 void xfs_ilock_demote(xfs_inode_t
*, uint
);
336 int xfs_isilocked(xfs_inode_t
*, uint
);
337 uint
xfs_ilock_map_shared(xfs_inode_t
*);
338 void xfs_iunlock_map_shared(xfs_inode_t
*, uint
);
339 int xfs_ialloc(struct xfs_trans
*, xfs_inode_t
*, umode_t
,
340 xfs_nlink_t
, xfs_dev_t
, prid_t
, int,
341 struct xfs_buf
**, xfs_inode_t
**);
343 uint
xfs_ip2xflags(struct xfs_inode
*);
344 uint
xfs_dic2xflags(struct xfs_dinode
*);
345 int xfs_ifree(struct xfs_trans
*, xfs_inode_t
*,
346 struct xfs_bmap_free
*);
347 int xfs_itruncate_extents(struct xfs_trans
**, struct xfs_inode
*,
349 int xfs_iunlink(struct xfs_trans
*, xfs_inode_t
*);
351 void xfs_iext_realloc(xfs_inode_t
*, int, int);
353 void xfs_iunpin_wait(xfs_inode_t
*);
354 #define xfs_ipincount(ip) ((unsigned int) atomic_read(&ip->i_pincount))
356 int xfs_iflush(struct xfs_inode
*, struct xfs_buf
**);
357 void xfs_lock_inodes(xfs_inode_t
**, int, uint
);
358 void xfs_lock_two_inodes(xfs_inode_t
*, xfs_inode_t
*, uint
);
360 xfs_extlen_t
xfs_get_extsz_hint(struct xfs_inode
*ip
);
362 int xfs_dir_ialloc(struct xfs_trans
**, struct xfs_inode
*, umode_t
,
363 xfs_nlink_t
, xfs_dev_t
, prid_t
, int,
364 struct xfs_inode
**, int *);
365 int xfs_droplink(struct xfs_trans
*, struct xfs_inode
*);
366 int xfs_bumplink(struct xfs_trans
*, struct xfs_inode
*);
367 void xfs_bump_ino_vers2(struct xfs_trans
*, struct xfs_inode
*);
369 /* from xfs_file.c */
370 int xfs_zero_eof(struct xfs_inode
*, xfs_off_t
, xfs_fsize_t
);
371 int xfs_iozero(struct xfs_inode
*, loff_t
, size_t);
376 ASSERT(atomic_read(&VFS_I(ip)->i_count) > 0) ; \
378 trace_xfs_ihold(ip, _THIS_IP_); \
383 trace_xfs_irele(ip, _THIS_IP_); \
387 extern struct kmem_zone
*xfs_inode_zone
;
389 #endif /* __XFS_INODE_H__ */
This page took 0.037224 seconds and 5 git commands to generate.