xfs_inode.h 11.5 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2 3
 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
 * All Rights Reserved.
L
Linus Torvalds 已提交
4
 *
5 6
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
L
Linus Torvalds 已提交
7 8
 * published by the Free Software Foundation.
 *
9 10 11 12
 * This program is distributed in the hope that it would 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.
L
Linus Torvalds 已提交
13
 *
14 15 16
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
L
Linus Torvalds 已提交
17 18 19 20
 */
#ifndef	__XFS_INODE_H__
#define	__XFS_INODE_H__

21
#include "xfs_inode_buf.h"
22
#include "xfs_inode_fork.h"
L
Linus Torvalds 已提交
23

24
/*
25
 * Kernel only inode definitions
26
 */
27 28
struct xfs_dinode;
struct xfs_inode;
29 30 31 32 33 34 35 36
struct xfs_buf;
struct xfs_bmap_free;
struct xfs_bmbt_irec;
struct xfs_inode_log_item;
struct xfs_mount;
struct xfs_trans;
struct xfs_dquot;

L
Linus Torvalds 已提交
37 38 39 40 41
typedef struct xfs_inode {
	/* Inode linking and identification information. */
	struct xfs_mount	*i_mount;	/* fs mount struct ptr */
	struct xfs_dquot	*i_udquot;	/* user dquot */
	struct xfs_dquot	*i_gdquot;	/* group dquot */
42
	struct xfs_dquot	*i_pdquot;	/* project dquot */
L
Linus Torvalds 已提交
43 44 45

	/* Inode location stuff */
	xfs_ino_t		i_ino;		/* inode number (agno/agino)*/
46
	struct xfs_imap		i_imap;		/* location for xfs_imap() */
L
Linus Torvalds 已提交
47 48 49 50 51 52 53 54 55 56

	/* Extent information. */
	xfs_ifork_t		*i_afp;		/* attribute fork pointer */
	xfs_ifork_t		i_df;		/* data fork */

	/* Transaction and locking information. */
	struct xfs_inode_log_item *i_itemp;	/* logging information */
	mrlock_t		i_lock;		/* inode lock */
	mrlock_t		i_iolock;	/* inode IO lock */
	atomic_t		i_pincount;	/* inode pin count */
57
	spinlock_t		i_flags_lock;	/* inode i_flags lock */
L
Linus Torvalds 已提交
58
	/* Miscellaneous state. */
59
	unsigned long		i_flags;	/* see defined flags below */
L
Linus Torvalds 已提交
60 61
	unsigned int		i_delayed_blks;	/* count of delay alloc blks */

62
	xfs_icdinode_t		i_d;		/* most of ondisk inode */
L
Linus Torvalds 已提交
63

64 65
	/* VFS inode */
	struct inode		i_vnode;	/* embedded VFS inode */
L
Linus Torvalds 已提交
66 67
} xfs_inode_t;

68 69 70
/* Convert from vfs inode to xfs inode */
static inline struct xfs_inode *XFS_I(struct inode *inode)
{
71
	return container_of(inode, struct xfs_inode, i_vnode);
72 73 74 75 76
}

/* convert from xfs inode to vfs inode */
static inline struct inode *VFS_I(struct xfs_inode *ip)
{
77
	return &ip->i_vnode;
78 79
}

80 81 82 83 84 85 86 87 88 89 90 91
/*
 * For regular files we only update the on-disk filesize when actually
 * writing data back to disk.  Until then only the copy in the VFS inode
 * is uptodate.
 */
static inline xfs_fsize_t XFS_ISIZE(struct xfs_inode *ip)
{
	if (S_ISREG(ip->i_d.di_mode))
		return i_size_read(VFS_I(ip));
	return ip->i_d.di_size;
}

92 93 94 95 96 97 98 99 100 101 102 103 104 105
/*
 * If this I/O goes past the on-disk inode size update it unless it would
 * be past the current in-core inode size.
 */
static inline xfs_fsize_t
xfs_new_eof(struct xfs_inode *ip, xfs_fsize_t new_size)
{
	xfs_fsize_t i_size = i_size_read(VFS_I(ip));

	if (new_size > i_size)
		new_size = i_size;
	return new_size > ip->i_d.di_size ? new_size : 0;
}

106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
/*
 * i_flags helper functions
 */
static inline void
__xfs_iflags_set(xfs_inode_t *ip, unsigned short flags)
{
	ip->i_flags |= flags;
}

static inline void
xfs_iflags_set(xfs_inode_t *ip, unsigned short flags)
{
	spin_lock(&ip->i_flags_lock);
	__xfs_iflags_set(ip, flags);
	spin_unlock(&ip->i_flags_lock);
}

static inline void
xfs_iflags_clear(xfs_inode_t *ip, unsigned short flags)
{
	spin_lock(&ip->i_flags_lock);
	ip->i_flags &= ~flags;
	spin_unlock(&ip->i_flags_lock);
}

static inline int
__xfs_iflags_test(xfs_inode_t *ip, unsigned short flags)
{
	return (ip->i_flags & flags);
}

static inline int
xfs_iflags_test(xfs_inode_t *ip, unsigned short flags)
{
	int ret;
	spin_lock(&ip->i_flags_lock);
	ret = __xfs_iflags_test(ip, flags);
	spin_unlock(&ip->i_flags_lock);
	return ret;
}
146 147 148 149 150 151 152 153 154 155 156 157 158

static inline int
xfs_iflags_test_and_clear(xfs_inode_t *ip, unsigned short flags)
{
	int ret;

	spin_lock(&ip->i_flags_lock);
	ret = ip->i_flags & flags;
	if (ret)
		ip->i_flags &= ~flags;
	spin_unlock(&ip->i_flags_lock);
	return ret;
}
L
Linus Torvalds 已提交
159

160 161 162 163 164 165 166 167 168 169 170 171 172
static inline int
xfs_iflags_test_and_set(xfs_inode_t *ip, unsigned short flags)
{
	int ret;

	spin_lock(&ip->i_flags_lock);
	ret = ip->i_flags & flags;
	if (!ret)
		ip->i_flags |= flags;
	spin_unlock(&ip->i_flags_lock);
	return ret;
}

173 174
/*
 * Project quota id helpers (previously projid was 16bit only
L
Lucas De Marchi 已提交
175
 * and using two 16bit values to hold new 32bit projid was chosen
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
 * to retain compatibility with "old" filesystems).
 */
static inline prid_t
xfs_get_projid(struct xfs_inode *ip)
{
	return (prid_t)ip->i_d.di_projid_hi << 16 | ip->i_d.di_projid_lo;
}

static inline void
xfs_set_projid(struct xfs_inode *ip,
		prid_t projid)
{
	ip->i_d.di_projid_hi = (__uint16_t) (projid >> 16);
	ip->i_d.di_projid_lo = (__uint16_t) (projid & 0xffff);
}

L
Linus Torvalds 已提交
192 193 194
/*
 * In-core inode flags.
 */
195 196 197 198 199 200 201 202 203
#define XFS_IRECLAIM		(1 << 0) /* started reclaiming this inode */
#define XFS_ISTALE		(1 << 1) /* inode has been staled */
#define XFS_IRECLAIMABLE	(1 << 2) /* inode can be reclaimed */
#define XFS_INEW		(1 << 3) /* inode has just been allocated */
#define XFS_IFILESTREAM		(1 << 4) /* inode is in a filestream dir. */
#define XFS_ITRUNCATED		(1 << 5) /* truncated down so flush-on-close */
#define XFS_IDIRTY_RELEASE	(1 << 6) /* dirty release already seen */
#define __XFS_IFLOCK_BIT	7	 /* inode is being flushed right now */
#define XFS_IFLOCK		(1 << __XFS_IFLOCK_BIT)
204 205
#define __XFS_IPINNED_BIT	8	 /* wakeup key for zero pin count */
#define XFS_IPINNED		(1 << __XFS_IPINNED_BIT)
206
#define XFS_IDONTCACHE		(1 << 9) /* don't cache the inode long term */
L
Linus Torvalds 已提交
207

208 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
211 212 213 214 215 216 217
 * ocurring.
 */
#define XFS_IRECLAIM_RESET_FLAGS	\
	(XFS_IRECLAIMABLE | XFS_IRECLAIM | \
	 XFS_IDIRTY_RELEASE | XFS_ITRUNCATED | \
	 XFS_IFILESTREAM);

218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
/*
 * Synchronize processes attempting to flush the in-core inode back to disk.
 */

extern void __xfs_iflock(struct xfs_inode *ip);

static inline int xfs_iflock_nowait(struct xfs_inode *ip)
{
	return !xfs_iflags_test_and_set(ip, XFS_IFLOCK);
}

static inline void xfs_iflock(struct xfs_inode *ip)
{
	if (!xfs_iflock_nowait(ip))
		__xfs_iflock(ip);
}

static inline void xfs_ifunlock(struct xfs_inode *ip)
{
	xfs_iflags_clear(ip, XFS_IFLOCK);
238
	smp_mb();
239 240 241 242 243 244 245 246
	wake_up_bit(&ip->i_flags, __XFS_IFLOCK_BIT);
}

static inline int xfs_isiflocked(struct xfs_inode *ip)
{
	return xfs_iflags_test(ip, XFS_IFLOCK);
}

L
Linus Torvalds 已提交
247 248
/*
 * Flags for inode locking.
249 250
 * Bit ranges:	1<<1  - 1<<16-1 -- iolock/ilock modes (bitfield)
 *		1<<16 - 1<<32-1 -- lockdep annotation (integers)
L
Linus Torvalds 已提交
251
 */
252 253 254 255
#define	XFS_IOLOCK_EXCL		(1<<0)
#define	XFS_IOLOCK_SHARED	(1<<1)
#define	XFS_ILOCK_EXCL		(1<<2)
#define	XFS_ILOCK_SHARED	(1<<3)
L
Linus Torvalds 已提交
256

257
#define XFS_LOCK_MASK		(XFS_IOLOCK_EXCL | XFS_IOLOCK_SHARED \
C
Christoph Hellwig 已提交
258
				| XFS_ILOCK_EXCL | XFS_ILOCK_SHARED)
259

C
Christoph Hellwig 已提交
260 261 262 263
#define XFS_LOCK_FLAGS \
	{ XFS_IOLOCK_EXCL,	"IOLOCK_EXCL" }, \
	{ XFS_IOLOCK_SHARED,	"IOLOCK_SHARED" }, \
	{ XFS_ILOCK_EXCL,	"ILOCK_EXCL" }, \
264
	{ XFS_ILOCK_SHARED,	"ILOCK_SHARED" }
C
Christoph Hellwig 已提交
265 266


267 268 269
/*
 * Flags for lockdep annotations.
 *
270 271 272 273 274 275 276 277
 * XFS_LOCK_PARENT - for directory operations that require locking a
 * parent directory inode and a child entry inode.  The parent gets locked
 * with this flag so it gets a lockdep subclass of 1 and the child entry
 * lock will have a lockdep subclass of 0.
 *
 * XFS_LOCK_RTBITMAP/XFS_LOCK_RTSUM - the realtime device bitmap and summary
 * inodes do not participate in the normal lock order, and thus have their
 * own subclasses.
278
 *
279
 * XFS_LOCK_INUMORDER - for locking several inodes at the some time
280 281
 * with xfs_lock_inodes().  This flag is used as the starting subclass
 * and each subsequent lock acquired will increment the subclass by one.
282 283
 * So the first lock acquired will have a lockdep subclass of 4, the
 * second lock will have a lockdep subclass of 5, and so on. It is
284 285
 * the responsibility of the class builder to shift this to the correct
 * portion of the lock_mode lockdep mask.
286
 */
287
#define XFS_LOCK_PARENT		1
288 289 290
#define XFS_LOCK_RTBITMAP	2
#define XFS_LOCK_RTSUM		3
#define XFS_LOCK_INUMORDER	4
291

292
#define XFS_IOLOCK_SHIFT	16
293
#define	XFS_IOLOCK_PARENT	(XFS_LOCK_PARENT << XFS_IOLOCK_SHIFT)
294 295

#define XFS_ILOCK_SHIFT		24
296
#define	XFS_ILOCK_PARENT	(XFS_LOCK_PARENT << XFS_ILOCK_SHIFT)
297 298
#define	XFS_ILOCK_RTBITMAP	(XFS_LOCK_RTBITMAP << XFS_ILOCK_SHIFT)
#define	XFS_ILOCK_RTSUM		(XFS_LOCK_RTSUM << XFS_ILOCK_SHIFT)
299 300 301 302 303 304 305

#define XFS_IOLOCK_DEP_MASK	0x00ff0000
#define XFS_ILOCK_DEP_MASK	0xff000000
#define XFS_LOCK_DEP_MASK	(XFS_IOLOCK_DEP_MASK | XFS_ILOCK_DEP_MASK)

#define XFS_IOLOCK_DEP(flags)	(((flags) & XFS_IOLOCK_DEP_MASK) >> XFS_IOLOCK_SHIFT)
#define XFS_ILOCK_DEP(flags)	(((flags) & XFS_ILOCK_DEP_MASK) >> XFS_ILOCK_SHIFT)
L
Linus Torvalds 已提交
306 307 308 309 310 311

/*
 * For multiple groups support: if S_ISGID bit is set in the parent
 * directory, group of new file is set to that of the parent, and
 * new subdirectory gets S_ISGID bit from parent.
 */
312 313 314
#define XFS_INHERIT_GID(pip)	\
	(((pip)->i_mount->m_flags & XFS_MOUNT_GRPID) || \
	 ((pip)->i_d.di_mode & S_ISGID))
L
Linus Torvalds 已提交
315

D
Dave Chinner 已提交
316

D
Dave Chinner 已提交
317
int		xfs_release(struct xfs_inode *ip);
318
void		xfs_inactive(struct xfs_inode *ip);
D
Dave Chinner 已提交
319 320 321 322 323 324 325 326 327 328 329 330 331
int		xfs_lookup(struct xfs_inode *dp, struct xfs_name *name,
			   struct xfs_inode **ipp, struct xfs_name *ci_name);
int		xfs_create(struct xfs_inode *dp, struct xfs_name *name,
			   umode_t mode, xfs_dev_t rdev, struct xfs_inode **ipp);
int		xfs_remove(struct xfs_inode *dp, struct xfs_name *name,
			   struct xfs_inode *ip);
int		xfs_link(struct xfs_inode *tdp, struct xfs_inode *sip,
			 struct xfs_name *target_name);
int		xfs_rename(struct xfs_inode *src_dp, struct xfs_name *src_name,
			   struct xfs_inode *src_ip, struct xfs_inode *target_dp,
			   struct xfs_name *target_name,
			   struct xfs_inode *target_ip);

L
Linus Torvalds 已提交
332 333 334 335
void		xfs_ilock(xfs_inode_t *, uint);
int		xfs_ilock_nowait(xfs_inode_t *, uint);
void		xfs_iunlock(xfs_inode_t *, uint);
void		xfs_ilock_demote(xfs_inode_t *, uint);
C
Christoph Hellwig 已提交
336
int		xfs_isilocked(xfs_inode_t *, uint);
L
Linus Torvalds 已提交
337 338
uint		xfs_ilock_map_shared(xfs_inode_t *);
void		xfs_iunlock_map_shared(xfs_inode_t *, uint);
A
Al Viro 已提交
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 **);
342

L
Linus Torvalds 已提交
343
uint		xfs_ip2xflags(struct xfs_inode *);
344
uint		xfs_dic2xflags(struct xfs_dinode *);
L
Linus Torvalds 已提交
345 346
int		xfs_ifree(struct xfs_trans *, xfs_inode_t *,
			   struct xfs_bmap_free *);
347 348
int		xfs_itruncate_extents(struct xfs_trans **, struct xfs_inode *,
				      int, xfs_fsize_t);
L
Linus Torvalds 已提交
349 350 351
int		xfs_iunlink(struct xfs_trans *, xfs_inode_t *);

void		xfs_iext_realloc(xfs_inode_t *, int, int);
352

353
void		xfs_iunpin_wait(xfs_inode_t *);
354 355
#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);
L
Linus Torvalds 已提交
359

360 361
xfs_extlen_t	xfs_get_extsz_hint(struct xfs_inode *ip);

D
Dave Chinner 已提交
362 363 364 365 366 367 368
int		xfs_dir_ialloc(struct xfs_trans **, struct xfs_inode *, umode_t,
			       xfs_nlink_t, xfs_dev_t, prid_t, int,
			       struct xfs_inode **, int *);
int		xfs_droplink(struct xfs_trans *, struct xfs_inode *);
int		xfs_bumplink(struct xfs_trans *, struct xfs_inode *);
void		xfs_bump_ino_vers2(struct xfs_trans *, struct xfs_inode *);

D
Dave Chinner 已提交
369 370 371 372 373
/* from xfs_file.c */
int		xfs_zero_eof(struct xfs_inode *, xfs_off_t, xfs_fsize_t);
int		xfs_iozero(struct xfs_inode *, loff_t, size_t);


374 375 376
#define IHOLD(ip) \
do { \
	ASSERT(atomic_read(&VFS_I(ip)->i_count) > 0) ; \
A
Al Viro 已提交
377
	ihold(VFS_I(ip)); \
C
Christoph Hellwig 已提交
378
	trace_xfs_ihold(ip, _THIS_IP_); \
379 380 381 382
} while (0)

#define IRELE(ip) \
do { \
C
Christoph Hellwig 已提交
383
	trace_xfs_irele(ip, _THIS_IP_); \
384 385 386
	iput(VFS_I(ip)); \
} while (0)

L
Linus Torvalds 已提交
387 388 389
extern struct kmem_zone	*xfs_inode_zone;

#endif	/* __XFS_INODE_H__ */