Skip to content

K
Kernel

openeuler / Kernel
大约 1 年 前同步成功

通知 5
Star 0
Fork 0
K
Kernel

体验新版 GitCode，发现更多精彩内容 >>

提交 1b4d40a5 编写于 作者: L Linus Torvalds
浏览文件
操作

Merge branch 'for-linus' of git://oss.sgi.com/xfs/xfs 

* 'for-linus' of git://oss.sgi.com/xfs/xfs:
  xfs: Ensure we force all busy extents in range to disk
  xfs: Don't flush stale inodes
  xfs: fix timestamp handling in xfs_setattr
  xfs: use DECLARE_EVENT_CLASS
上级 79ecb043 fd45e478
显示空白变更内容
内联 并排
Showing with 666 addition and 625 deletion
fs/xfs/linux-2.6/xfs_acl.c
浏览文件 @ 1b4d40a5
...@@ -251,8 +251,9 @@ xfs_set_mode(struct inode *inode, mode_t mode) ...@@ -251,8 +251,9 @@ xfs_set_mode(struct inode *inode, mode_t mode)
if (mode != inode->i_mode) { if (mode != inode->i_mode) {
struct iattr iattr; struct iattr iattr;
iattr.ia_valid = ATTR_MODE; iattr.ia_valid = ATTR_MODE | ATTR_CTIME;
iattr.ia_mode = mode; iattr.ia_mode = mode;
iattr.ia_ctime = current_fs_time(inode->i_sb);
error = -xfs_setattr(XFS_I(inode), &iattr, XFS_ATTR_NOACL); error = -xfs_setattr(XFS_I(inode), &iattr, XFS_ATTR_NOACL);
} }
......
fs/xfs/linux-2.6/xfs_trace.h
浏览文件 @ 1b4d40a5
...@@ -33,51 +33,55 @@ struct xfs_dquot; ...@@ -33,51 +33,55 @@ struct xfs_dquot;
struct xlog_ticket; struct xlog_ticket;
struct log; struct log;
DECLARE_EVENT_CLASS(xfs_attr_list_class,
TP_PROTO(struct xfs_attr_list_context *ctx),
TP_ARGS(ctx),
TP_STRUCT__entry(
__field(dev_t, dev)
__field(xfs_ino_t, ino)
__field(u32, hashval)
__field(u32, blkno)
__field(u32, offset)
__field(void *, alist)
__field(int, bufsize)
__field(int, count)
__field(int, firstu)
__field(int, dupcnt)
__field(int, flags)
),
TP_fast_assign(
__entry->dev = VFS_I(ctx->dp)->i_sb->s_dev;
__entry->ino = ctx->dp->i_ino;
__entry->hashval = ctx->cursor->hashval;
__entry->blkno = ctx->cursor->blkno;
__entry->offset = ctx->cursor->offset;
__entry->alist = ctx->alist;
__entry->bufsize = ctx->bufsize;
__entry->count = ctx->count;
__entry->firstu = ctx->firstu;
__entry->flags = ctx->flags;
),
TP_printk("dev %d:%d ino 0x%llx cursor h/b/o 0x%x/0x%x/%u dupcnt %u "
"alist 0x%p size %u count %u firstu %u flags %d %s",
MAJOR(__entry->dev), MINOR(__entry->dev),
__entry->ino,
__entry->hashval,
__entry->blkno,
__entry->offset,
__entry->dupcnt,
__entry->alist,
__entry->bufsize,
__entry->count,
__entry->firstu,
__entry->flags,
__print_flags(__entry->flags, "|", XFS_ATTR_FLAGS)
)
)
#define DEFINE_ATTR_LIST_EVENT(name) \ #define DEFINE_ATTR_LIST_EVENT(name) \
TRACE_EVENT(name, \ DEFINE_EVENT(xfs_attr_list_class, name, \
TP_PROTO(struct xfs_attr_list_context *ctx), \ TP_PROTO(struct xfs_attr_list_context *ctx), \
TP_ARGS(ctx), \ TP_ARGS(ctx))
TP_STRUCT__entry( \
__field(dev_t, dev) \
__field(xfs_ino_t, ino) \
__field(u32, hashval) \
__field(u32, blkno) \
__field(u32, offset) \
__field(void *, alist) \
__field(int, bufsize) \
__field(int, count) \
__field(int, firstu) \
__field(int, dupcnt) \
__field(int, flags) \
), \
TP_fast_assign( \
__entry->dev = VFS_I(ctx->dp)->i_sb->s_dev; \
__entry->ino = ctx->dp->i_ino; \
__entry->hashval = ctx->cursor->hashval; \
__entry->blkno = ctx->cursor->blkno; \
__entry->offset = ctx->cursor->offset; \
__entry->alist = ctx->alist; \
__entry->bufsize = ctx->bufsize; \
__entry->count = ctx->count; \
__entry->firstu = ctx->firstu; \
__entry->flags = ctx->flags; \
), \
TP_printk("dev %d:%d ino 0x%llx cursor h/b/o 0x%x/0x%x/%u dupcnt %u " \
"alist 0x%p size %u count %u firstu %u flags %d %s", \
MAJOR(__entry->dev), MINOR(__entry->dev), \
__entry->ino, \
__entry->hashval, \
__entry->blkno, \
__entry->offset, \
__entry->dupcnt, \
__entry->alist, \
__entry->bufsize, \
__entry->count, \
__entry->firstu, \
__entry->flags, \
__print_flags(__entry->flags, "|", XFS_ATTR_FLAGS) \
) \
)
DEFINE_ATTR_LIST_EVENT(xfs_attr_list_sf); DEFINE_ATTR_LIST_EVENT(xfs_attr_list_sf);
DEFINE_ATTR_LIST_EVENT(xfs_attr_list_sf_all); DEFINE_ATTR_LIST_EVENT(xfs_attr_list_sf_all);
DEFINE_ATTR_LIST_EVENT(xfs_attr_list_leaf); DEFINE_ATTR_LIST_EVENT(xfs_attr_list_leaf);
...@@ -178,91 +182,99 @@ TRACE_EVENT(xfs_iext_insert, ...@@ -178,91 +182,99 @@ TRACE_EVENT(xfs_iext_insert,
(char *)__entry->caller_ip) (char *)__entry->caller_ip)
); );
DECLARE_EVENT_CLASS(xfs_bmap_class,
TP_PROTO(struct xfs_inode *ip, xfs_extnum_t idx, int state,
unsigned long caller_ip),
TP_ARGS(ip, idx, state, caller_ip),
TP_STRUCT__entry(
__field(dev_t, dev)
__field(xfs_ino_t, ino)
__field(xfs_extnum_t, idx)
__field(xfs_fileoff_t, startoff)
__field(xfs_fsblock_t, startblock)
__field(xfs_filblks_t, blockcount)
__field(xfs_exntst_t, state)
__field(int, bmap_state)
__field(unsigned long, caller_ip)
),
TP_fast_assign(
struct xfs_ifork *ifp = (state & BMAP_ATTRFORK) ?
ip->i_afp : &ip->i_df;
struct xfs_bmbt_irec r;
xfs_bmbt_get_all(xfs_iext_get_ext(ifp, idx), &r);
__entry->dev = VFS_I(ip)->i_sb->s_dev;
__entry->ino = ip->i_ino;
__entry->idx = idx;
__entry->startoff = r.br_startoff;
__entry->startblock = r.br_startblock;
__entry->blockcount = r.br_blockcount;
__entry->state = r.br_state;
__entry->bmap_state = state;
__entry->caller_ip = caller_ip;
),
TP_printk("dev %d:%d ino 0x%llx state %s idx %ld "
"offset %lld block %s count %lld flag %d caller %pf",
MAJOR(__entry->dev), MINOR(__entry->dev),
__entry->ino,
__print_flags(__entry->bmap_state, "|", XFS_BMAP_EXT_FLAGS),
(long)__entry->idx,
__entry->startoff,
xfs_fmtfsblock(__entry->startblock),
__entry->blockcount,
__entry->state,
(char *)__entry->caller_ip)
)
#define DEFINE_BMAP_EVENT(name) \ #define DEFINE_BMAP_EVENT(name) \
TRACE_EVENT(name, \ DEFINE_EVENT(xfs_bmap_class, name, \
TP_PROTO(struct xfs_inode *ip, xfs_extnum_t idx, int state, \ TP_PROTO(struct xfs_inode *ip, xfs_extnum_t idx, int state, \
unsigned long caller_ip), \ unsigned long caller_ip), \
TP_ARGS(ip, idx, state, caller_ip), \ TP_ARGS(ip, idx, state, caller_ip))
TP_STRUCT__entry( \
__field(dev_t, dev) \
__field(xfs_ino_t, ino) \
__field(xfs_extnum_t, idx) \
__field(xfs_fileoff_t, startoff) \
__field(xfs_fsblock_t, startblock) \
__field(xfs_filblks_t, blockcount) \
__field(xfs_exntst_t, state) \
__field(int, bmap_state) \
__field(unsigned long, caller_ip) \
), \
TP_fast_assign( \
struct xfs_ifork *ifp = (state & BMAP_ATTRFORK) ? \
ip->i_afp : &ip->i_df; \
struct xfs_bmbt_irec r; \
\
xfs_bmbt_get_all(xfs_iext_get_ext(ifp, idx), &r); \
__entry->dev = VFS_I(ip)->i_sb->s_dev; \
__entry->ino = ip->i_ino; \
__entry->idx = idx; \
__entry->startoff = r.br_startoff; \
__entry->startblock = r.br_startblock; \
__entry->blockcount = r.br_blockcount; \
__entry->state = r.br_state; \
__entry->bmap_state = state; \
__entry->caller_ip = caller_ip; \
), \
TP_printk("dev %d:%d ino 0x%llx state %s idx %ld " \
"offset %lld block %s count %lld flag %d caller %pf", \
MAJOR(__entry->dev), MINOR(__entry->dev), \
__entry->ino, \
__print_flags(__entry->bmap_state, "|", XFS_BMAP_EXT_FLAGS), \
(long)__entry->idx, \
__entry->startoff, \
xfs_fmtfsblock(__entry->startblock), \
__entry->blockcount, \
__entry->state, \
(char *)__entry->caller_ip) \
)
DEFINE_BMAP_EVENT(xfs_iext_remove); DEFINE_BMAP_EVENT(xfs_iext_remove);
DEFINE_BMAP_EVENT(xfs_bmap_pre_update); DEFINE_BMAP_EVENT(xfs_bmap_pre_update);
DEFINE_BMAP_EVENT(xfs_bmap_post_update); DEFINE_BMAP_EVENT(xfs_bmap_post_update);
DEFINE_BMAP_EVENT(xfs_extlist); DEFINE_BMAP_EVENT(xfs_extlist);
#define DEFINE_BUF_EVENT(tname) \ DECLARE_EVENT_CLASS(xfs_buf_class,
TRACE_EVENT(tname, \ TP_PROTO(struct xfs_buf *bp, unsigned long caller_ip),
TP_PROTO(struct xfs_buf *bp, unsigned long caller_ip), \ TP_ARGS(bp, caller_ip),
TP_ARGS(bp, caller_ip), \ TP_STRUCT__entry(
TP_STRUCT__entry( \ __field(dev_t, dev)
__field(dev_t, dev) \ __field(xfs_daddr_t, bno)
__field(xfs_daddr_t, bno) \ __field(size_t, buffer_length)
__field(size_t, buffer_length) \ __field(int, hold)
__field(int, hold) \ __field(int, pincount)
__field(int, pincount) \ __field(unsigned, lockval)
__field(unsigned, lockval) \ __field(unsigned, flags)
__field(unsigned, flags) \ __field(unsigned long, caller_ip)
__field(unsigned long, caller_ip) \ ),
), \ TP_fast_assign(
TP_fast_assign( \ __entry->dev = bp->b_target->bt_dev;
__entry->dev = bp->b_target->bt_dev; \ __entry->bno = bp->b_bn;
__entry->bno = bp->b_bn; \ __entry->buffer_length = bp->b_buffer_length;
__entry->buffer_length = bp->b_buffer_length; \ __entry->hold = atomic_read(&bp->b_hold);
__entry->hold = atomic_read(&bp->b_hold); \ __entry->pincount = atomic_read(&bp->b_pin_count);
__entry->pincount = atomic_read(&bp->b_pin_count); \ __entry->lockval = xfs_buf_lock_value(bp);
__entry->lockval = xfs_buf_lock_value(bp); \ __entry->flags = bp->b_flags;
__entry->flags = bp->b_flags; \ __entry->caller_ip = caller_ip;
__entry->caller_ip = caller_ip; \ ),
), \ TP_printk("dev %d:%d bno 0x%llx len 0x%zx hold %d pincount %d "
TP_printk("dev %d:%d bno 0x%llx len 0x%zx hold %d pincount %d " \ "lock %d flags %s caller %pf",
"lock %d flags %s caller %pf", \ MAJOR(__entry->dev), MINOR(__entry->dev),
MAJOR(__entry->dev), MINOR(__entry->dev), \ (unsigned long long)__entry->bno,
(unsigned long long)__entry->bno, \ __entry->buffer_length,
__entry->buffer_length, \ __entry->hold,
__entry->hold, \ __entry->pincount,
__entry->pincount, \ __entry->lockval,
__entry->lockval, \ __print_flags(__entry->flags, "|", XFS_BUF_FLAGS),
__print_flags(__entry->flags, "|", XFS_BUF_FLAGS), \ (void *)__entry->caller_ip)
(void *)__entry->caller_ip) \
) )
#define DEFINE_BUF_EVENT(name) \
DEFINE_EVENT(xfs_buf_class, name, \
TP_PROTO(struct xfs_buf *bp, unsigned long caller_ip), \
TP_ARGS(bp, caller_ip))
DEFINE_BUF_EVENT(xfs_buf_init); DEFINE_BUF_EVENT(xfs_buf_init);
DEFINE_BUF_EVENT(xfs_buf_free); DEFINE_BUF_EVENT(xfs_buf_free);
DEFINE_BUF_EVENT(xfs_buf_hold); DEFINE_BUF_EVENT(xfs_buf_hold);
...@@ -299,41 +311,45 @@ DEFINE_BUF_EVENT(xfs_reset_dqcounts); ...@@ -299,41 +311,45 @@ DEFINE_BUF_EVENT(xfs_reset_dqcounts);
DEFINE_BUF_EVENT(xfs_inode_item_push); DEFINE_BUF_EVENT(xfs_inode_item_push);
/* pass flags explicitly */ /* pass flags explicitly */
#define DEFINE_BUF_FLAGS_EVENT(tname) \ DECLARE_EVENT_CLASS(xfs_buf_flags_class,
TRACE_EVENT(tname, \ TP_PROTO(struct xfs_buf *bp, unsigned flags, unsigned long caller_ip),
TP_PROTO(struct xfs_buf *bp, unsigned flags, unsigned long caller_ip), \ TP_ARGS(bp, flags, caller_ip),
TP_ARGS(bp, flags, caller_ip), \ TP_STRUCT__entry(
TP_STRUCT__entry( \ __field(dev_t, dev)
__field(dev_t, dev) \ __field(xfs_daddr_t, bno)
__field(xfs_daddr_t, bno) \ __field(size_t, buffer_length)
__field(size_t, buffer_length) \ __field(int, hold)
__field(int, hold) \ __field(int, pincount)
__field(int, pincount) \ __field(unsigned, lockval)
__field(unsigned, lockval) \ __field(unsigned, flags)
__field(unsigned, flags) \ __field(unsigned long, caller_ip)
__field(unsigned long, caller_ip) \ ),
), \ TP_fast_assign(
TP_fast_assign( \ __entry->dev = bp->b_target->bt_dev;
__entry->dev = bp->b_target->bt_dev; \ __entry->bno = bp->b_bn;
__entry->bno = bp->b_bn; \ __entry->buffer_length = bp->b_buffer_length;
__entry->buffer_length = bp->b_buffer_length; \ __entry->flags = flags;
__entry->flags = flags; \ __entry->hold = atomic_read(&bp->b_hold);
__entry->hold = atomic_read(&bp->b_hold); \ __entry->pincount = atomic_read(&bp->b_pin_count);
__entry->pincount = atomic_read(&bp->b_pin_count); \ __entry->lockval = xfs_buf_lock_value(bp);
__entry->lockval = xfs_buf_lock_value(bp); \ __entry->caller_ip = caller_ip;
__entry->caller_ip = caller_ip; \ ),
), \ TP_printk("dev %d:%d bno 0x%llx len 0x%zx hold %d pincount %d "
TP_printk("dev %d:%d bno 0x%llx len 0x%zx hold %d pincount %d " \ "lock %d flags %s caller %pf",
"lock %d flags %s caller %pf", \ MAJOR(__entry->dev), MINOR(__entry->dev),
MAJOR(__entry->dev), MINOR(__entry->dev), \ (unsigned long long)__entry->bno,
(unsigned long long)__entry->bno, \ __entry->buffer_length,
__entry->buffer_length, \ __entry->hold,
__entry->hold, \ __entry->pincount,
__entry->pincount, \ __entry->lockval,
__entry->lockval, \ __print_flags(__entry->flags, "|", XFS_BUF_FLAGS),
__print_flags(__entry->flags, "|", XFS_BUF_FLAGS), \ (void *)__entry->caller_ip)
(void *)__entry->caller_ip) \
) )
#define DEFINE_BUF_FLAGS_EVENT(name) \
DEFINE_EVENT(xfs_buf_flags_class, name, \
TP_PROTO(struct xfs_buf *bp, unsigned flags, unsigned long caller_ip), \
TP_ARGS(bp, flags, caller_ip))
DEFINE_BUF_FLAGS_EVENT(xfs_buf_find); DEFINE_BUF_FLAGS_EVENT(xfs_buf_find);
DEFINE_BUF_FLAGS_EVENT(xfs_buf_get); DEFINE_BUF_FLAGS_EVENT(xfs_buf_get);
DEFINE_BUF_FLAGS_EVENT(xfs_buf_read); DEFINE_BUF_FLAGS_EVENT(xfs_buf_read);
...@@ -376,55 +392,58 @@ TRACE_EVENT(xfs_buf_ioerror, ...@@ -376,55 +392,58 @@ TRACE_EVENT(xfs_buf_ioerror,
(void *)__entry->caller_ip) (void *)__entry->caller_ip)
); );
#define DEFINE_BUF_ITEM_EVENT(tname) \ DECLARE_EVENT_CLASS(xfs_buf_item_class,
TRACE_EVENT(tname, \ TP_PROTO(struct xfs_buf_log_item *bip),
TP_PROTO(struct xfs_buf_log_item *bip), \ TP_ARGS(bip),
TP_ARGS(bip), \ TP_STRUCT__entry(
TP_STRUCT__entry( \ __field(dev_t, dev)
__field(dev_t, dev) \ __field(xfs_daddr_t, buf_bno)
__field(xfs_daddr_t, buf_bno) \ __field(size_t, buf_len)
__field(size_t, buf_len) \ __field(int, buf_hold)
__field(int, buf_hold) \ __field(int, buf_pincount)
__field(int, buf_pincount) \ __field(int, buf_lockval)
__field(int, buf_lockval) \ __field(unsigned, buf_flags)
__field(unsigned, buf_flags) \ __field(unsigned, bli_recur)
__field(unsigned, bli_recur) \ __field(int, bli_refcount)
__field(int, bli_refcount) \ __field(unsigned, bli_flags)
__field(unsigned, bli_flags) \ __field(void *, li_desc)
__field(void *, li_desc) \ __field(unsigned, li_flags)
__field(unsigned, li_flags) \ ),
), \ TP_fast_assign(
TP_fast_assign( \ __entry->dev = bip->bli_buf->b_target->bt_dev;
__entry->dev = bip->bli_buf->b_target->bt_dev; \ __entry->bli_flags = bip->bli_flags;
__entry->bli_flags = bip->bli_flags; \ __entry->bli_recur = bip->bli_recur;
__entry->bli_recur = bip->bli_recur; \ __entry->bli_refcount = atomic_read(&bip->bli_refcount);
__entry->bli_refcount = atomic_read(&bip->bli_refcount); \ __entry->buf_bno = bip->bli_buf->b_bn;
__entry->buf_bno = bip->bli_buf->b_bn; \ __entry->buf_len = bip->bli_buf->b_buffer_length;
__entry->buf_len = bip->bli_buf->b_buffer_length; \ __entry->buf_flags = bip->bli_buf->b_flags;
__entry->buf_flags = bip->bli_buf->b_flags; \ __entry->buf_hold = atomic_read(&bip->bli_buf->b_hold);
__entry->buf_hold = atomic_read(&bip->bli_buf->b_hold); \ __entry->buf_pincount = atomic_read(&bip->bli_buf->b_pin_count);
__entry->buf_pincount = \ __entry->buf_lockval = xfs_buf_lock_value(bip->bli_buf);
atomic_read(&bip->bli_buf->b_pin_count); \ __entry->li_desc = bip->bli_item.li_desc;
__entry->buf_lockval = xfs_buf_lock_value(bip->bli_buf); \ __entry->li_flags = bip->bli_item.li_flags;
__entry->li_desc = bip->bli_item.li_desc; \ ),
__entry->li_flags = bip->bli_item.li_flags; \ TP_printk("dev %d:%d bno 0x%llx len 0x%zx hold %d pincount %d "
), \ "lock %d flags %s recur %d refcount %d bliflags %s "
TP_printk("dev %d:%d bno 0x%llx len 0x%zx hold %d pincount %d " \ "lidesc 0x%p liflags %s",
"lock %d flags %s recur %d refcount %d bliflags %s " \ MAJOR(__entry->dev), MINOR(__entry->dev),
"lidesc 0x%p liflags %s", \ (unsigned long long)__entry->buf_bno,
MAJOR(__entry->dev), MINOR(__entry->dev), \ __entry->buf_len,
(unsigned long long)__entry->buf_bno, \ __entry->buf_hold,
__entry->buf_len, \ __entry->buf_pincount,
__entry->buf_hold, \ __entry->buf_lockval,
__entry->buf_pincount, \ __print_flags(__entry->buf_flags, "|", XFS_BUF_FLAGS),
__entry->buf_lockval, \ __entry->bli_recur,
__print_flags(__entry->buf_flags, "|", XFS_BUF_FLAGS), \ __entry->bli_refcount,
__entry->bli_recur, \ __print_flags(__entry->bli_flags, "|", XFS_BLI_FLAGS),
__entry->bli_refcount, \ __entry->li_desc,
__print_flags(__entry->bli_flags, "|", XFS_BLI_FLAGS), \ __print_flags(__entry->li_flags, "|", XFS_LI_FLAGS))
__entry->li_desc, \
__print_flags(__entry->li_flags, "|", XFS_LI_FLAGS)) \
) )
#define DEFINE_BUF_ITEM_EVENT(name) \
DEFINE_EVENT(xfs_buf_item_class, name, \
TP_PROTO(struct xfs_buf_log_item *bip), \
TP_ARGS(bip))
DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size); DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size);
DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size_stale); DEFINE_BUF_ITEM_EVENT(xfs_buf_item_size_stale);
DEFINE_BUF_ITEM_EVENT(xfs_buf_item_format); DEFINE_BUF_ITEM_EVENT(xfs_buf_item_format);
...@@ -450,78 +469,90 @@ DEFINE_BUF_ITEM_EVENT(xfs_trans_bhold); ...@@ -450,78 +469,90 @@ DEFINE_BUF_ITEM_EVENT(xfs_trans_bhold);
DEFINE_BUF_ITEM_EVENT(xfs_trans_bhold_release); DEFINE_BUF_ITEM_EVENT(xfs_trans_bhold_release);
DEFINE_BUF_ITEM_EVENT(xfs_trans_binval); DEFINE_BUF_ITEM_EVENT(xfs_trans_binval);
DECLARE_EVENT_CLASS(xfs_lock_class,
TP_PROTO(struct xfs_inode *ip, unsigned lock_flags,
unsigned long caller_ip),
TP_ARGS(ip, lock_flags, caller_ip),
TP_STRUCT__entry(
__field(dev_t, dev)
__field(xfs_ino_t, ino)
__field(int, lock_flags)
__field(unsigned long, caller_ip)
),
TP_fast_assign(
__entry->dev = VFS_I(ip)->i_sb->s_dev;
__entry->ino = ip->i_ino;
__entry->lock_flags = lock_flags;
__entry->caller_ip = caller_ip;
),
TP_printk("dev %d:%d ino 0x%llx flags %s caller %pf",
MAJOR(__entry->dev), MINOR(__entry->dev),
__entry->ino,
__print_flags(__entry->lock_flags, "|", XFS_LOCK_FLAGS),
(void *)__entry->caller_ip)
)
#define DEFINE_LOCK_EVENT(name) \ #define DEFINE_LOCK_EVENT(name) \
TRACE_EVENT(name, \ DEFINE_EVENT(xfs_lock_class, name, \
TP_PROTO(struct xfs_inode *ip, unsigned lock_flags, \ TP_PROTO(struct xfs_inode *ip, unsigned lock_flags, \
unsigned long caller_ip), \ unsigned long caller_ip), \
TP_ARGS(ip, lock_flags, caller_ip), \ TP_ARGS(ip, lock_flags, caller_ip))
TP_STRUCT__entry( \
__field(dev_t, dev) \
__field(xfs_ino_t, ino) \
__field(int, lock_flags) \
__field(unsigned long, caller_ip) \
), \
TP_fast_assign( \
__entry->dev = VFS_I(ip)->i_sb->s_dev; \
__entry->ino = ip->i_ino; \
__entry->lock_flags = lock_flags; \
__entry->caller_ip = caller_ip; \
), \
TP_printk("dev %d:%d ino 0x%llx flags %s caller %pf", \
MAJOR(__entry->dev), MINOR(__entry->dev), \
__entry->ino, \
__print_flags(__entry->lock_flags, "|", XFS_LOCK_FLAGS), \
(void *)__entry->caller_ip) \
)
DEFINE_LOCK_EVENT(xfs_ilock); DEFINE_LOCK_EVENT(xfs_ilock);
DEFINE_LOCK_EVENT(xfs_ilock_nowait); DEFINE_LOCK_EVENT(xfs_ilock_nowait);
DEFINE_LOCK_EVENT(xfs_ilock_demote); DEFINE_LOCK_EVENT(xfs_ilock_demote);
DEFINE_LOCK_EVENT(xfs_iunlock); DEFINE_LOCK_EVENT(xfs_iunlock);
DECLARE_EVENT_CLASS(xfs_iget_class,
TP_PROTO(struct xfs_inode *ip),
TP_ARGS(ip),
TP_STRUCT__entry(
__field(dev_t, dev)
__field(xfs_ino_t, ino)
),
TP_fast_assign(
__entry->dev = VFS_I(ip)->i_sb->s_dev;
__entry->ino = ip->i_ino;
),
TP_printk("dev %d:%d ino 0x%llx",
MAJOR(__entry->dev), MINOR(__entry->dev),
__entry->ino)
)
#define DEFINE_IGET_EVENT(name) \ #define DEFINE_IGET_EVENT(name) \
TRACE_EVENT(name, \ DEFINE_EVENT(xfs_iget_class, name, \
TP_PROTO(struct xfs_inode *ip), \ TP_PROTO(struct xfs_inode *ip), \
TP_ARGS(ip), \ TP_ARGS(ip))
TP_STRUCT__entry( \
__field(dev_t, dev) \
__field(xfs_ino_t, ino) \
), \
TP_fast_assign( \
__entry->dev = VFS_I(ip)->i_sb->s_dev; \
__entry->ino = ip->i_ino; \
), \
TP_printk("dev %d:%d ino 0x%llx", \
MAJOR(__entry->dev), MINOR(__entry->dev), \
__entry->ino) \
)
DEFINE_IGET_EVENT(xfs_iget_skip); DEFINE_IGET_EVENT(xfs_iget_skip);
DEFINE_IGET_EVENT(xfs_iget_reclaim); DEFINE_IGET_EVENT(xfs_iget_reclaim);
DEFINE_IGET_EVENT(xfs_iget_found); DEFINE_IGET_EVENT(xfs_iget_found);
DEFINE_IGET_EVENT(xfs_iget_alloc); DEFINE_IGET_EVENT(xfs_iget_alloc);
DECLARE_EVENT_CLASS(xfs_inode_class,
TP_PROTO(struct xfs_inode *ip, unsigned long caller_ip),
TP_ARGS(ip, caller_ip),
TP_STRUCT__entry(
__field(dev_t, dev)
__field(xfs_ino_t, ino)
__field(int, count)
__field(unsigned long, caller_ip)
),
TP_fast_assign(
__entry->dev = VFS_I(ip)->i_sb->s_dev;
__entry->ino = ip->i_ino;
__entry->count = atomic_read(&VFS_I(ip)->i_count);
__entry->caller_ip = caller_ip;
),
TP_printk("dev %d:%d ino 0x%llx count %d caller %pf",
MAJOR(__entry->dev), MINOR(__entry->dev),
__entry->ino,
__entry->count,
(char *)__entry->caller_ip)
)
#define DEFINE_INODE_EVENT(name) \ #define DEFINE_INODE_EVENT(name) \
TRACE_EVENT(name, \ DEFINE_EVENT(xfs_inode_class, name, \
TP_PROTO(struct xfs_inode *ip, unsigned long caller_ip), \ TP_PROTO(struct xfs_inode *ip, unsigned long caller_ip), \
TP_ARGS(ip, caller_ip), \ TP_ARGS(ip, caller_ip))
TP_STRUCT__entry( \
__field(dev_t, dev) \
__field(xfs_ino_t, ino) \
__field(int, count) \
__field(unsigned long, caller_ip) \
), \
TP_fast_assign( \
__entry->dev = VFS_I(ip)->i_sb->s_dev; \
__entry->ino = ip->i_ino; \
__entry->count = atomic_read(&VFS_I(ip)->i_count); \
__entry->caller_ip = caller_ip; \
), \
TP_printk("dev %d:%d ino 0x%llx count %d caller %pf", \
MAJOR(__entry->dev), MINOR(__entry->dev), \
__entry->ino, \
__entry->count, \
(char *)__entry->caller_ip) \
)
DEFINE_INODE_EVENT(xfs_ihold); DEFINE_INODE_EVENT(xfs_ihold);
DEFINE_INODE_EVENT(xfs_irele); DEFINE_INODE_EVENT(xfs_irele);
/* the old xfs_itrace_entry tracer - to be replaced by s.th. in the VFS */ /* the old xfs_itrace_entry tracer - to be replaced by s.th. in the VFS */
...@@ -529,55 +560,59 @@ DEFINE_INODE_EVENT(xfs_inode); ...@@ -529,55 +560,59 @@ DEFINE_INODE_EVENT(xfs_inode);
#define xfs_itrace_entry(ip) \ #define xfs_itrace_entry(ip) \
trace_xfs_inode(ip, _THIS_IP_) trace_xfs_inode(ip, _THIS_IP_)
#define DEFINE_DQUOT_EVENT(tname) \ DECLARE_EVENT_CLASS(xfs_dquot_class,
TRACE_EVENT(tname, \ TP_PROTO(struct xfs_dquot *dqp),
TP_PROTO(struct xfs_dquot *dqp), \ TP_ARGS(dqp),
TP_ARGS(dqp), \ TP_STRUCT__entry(
TP_STRUCT__entry( \ __field(dev_t, dev)
__field(dev_t, dev) \ __field(__be32, id)
__field(__be32, id) \ __field(unsigned, flags)
__field(unsigned, flags) \ __field(unsigned, nrefs)
__field(unsigned, nrefs) \ __field(unsigned long long, res_bcount)
__field(unsigned long long, res_bcount) \ __field(unsigned long long, bcount)
__field(unsigned long long, bcount) \ __field(unsigned long long, icount)
__field(unsigned long long, icount) \ __field(unsigned long long, blk_hardlimit)
__field(unsigned long long, blk_hardlimit) \ __field(unsigned long long, blk_softlimit)
__field(unsigned long long, blk_softlimit) \ __field(unsigned long long, ino_hardlimit)
__field(unsigned long long, ino_hardlimit) \ __field(unsigned long long, ino_softlimit)
__field(unsigned long long, ino_softlimit) \
), \
TP_fast_assign( \
__entry->dev = dqp->q_mount->m_super->s_dev; \
__entry->id = dqp->q_core.d_id; \
__entry->flags = dqp->dq_flags; \
__entry->nrefs = dqp->q_nrefs; \
__entry->res_bcount = dqp->q_res_bcount; \
__entry->bcount = be64_to_cpu(dqp->q_core.d_bcount); \
__entry->icount = be64_to_cpu(dqp->q_core.d_icount); \
__entry->blk_hardlimit = \
be64_to_cpu(dqp->q_core.d_blk_hardlimit); \
__entry->blk_softlimit = \
be64_to_cpu(dqp->q_core.d_blk_softlimit); \
__entry->ino_hardlimit = \
be64_to_cpu(dqp->q_core.d_ino_hardlimit); \
__entry->ino_softlimit = \
be64_to_cpu(dqp->q_core.d_ino_softlimit); \
), \ ), \
TP_printk("dev %d:%d id 0x%x flags %s nrefs %u res_bc 0x%llx " \ TP_fast_assign(
"bcnt 0x%llx [hard 0x%llx | soft 0x%llx] " \ __entry->dev = dqp->q_mount->m_super->s_dev;
"icnt 0x%llx [hard 0x%llx | soft 0x%llx]", \ __entry->id = dqp->q_core.d_id;
MAJOR(__entry->dev), MINOR(__entry->dev), \ __entry->flags = dqp->dq_flags;
be32_to_cpu(__entry->id), \ __entry->nrefs = dqp->q_nrefs;
__print_flags(__entry->flags, "|", XFS_DQ_FLAGS), \ __entry->res_bcount = dqp->q_res_bcount;
__entry->nrefs, \ __entry->bcount = be64_to_cpu(dqp->q_core.d_bcount);
__entry->res_bcount, \ __entry->icount = be64_to_cpu(dqp->q_core.d_icount);
__entry->bcount, \ __entry->blk_hardlimit =
__entry->blk_hardlimit, \ be64_to_cpu(dqp->q_core.d_blk_hardlimit);
__entry->blk_softlimit, \ __entry->blk_softlimit =
__entry->icount, \ be64_to_cpu(dqp->q_core.d_blk_softlimit);
__entry->ino_hardlimit, \ __entry->ino_hardlimit =
__entry->ino_softlimit) \ be64_to_cpu(dqp->q_core.d_ino_hardlimit);
__entry->ino_softlimit =
be64_to_cpu(dqp->q_core.d_ino_softlimit);
),
TP_printk("dev %d:%d id 0x%x flags %s nrefs %u res_bc 0x%llx "
"bcnt 0x%llx [hard 0x%llx | soft 0x%llx] "
"icnt 0x%llx [hard 0x%llx | soft 0x%llx]",
MAJOR(__entry->dev), MINOR(__entry->dev),
be32_to_cpu(__entry->id),
__print_flags(__entry->flags, "|", XFS_DQ_FLAGS),
__entry->nrefs,
__entry->res_bcount,
__entry->bcount,
__entry->blk_hardlimit,
__entry->blk_softlimit,
__entry->icount,
__entry->ino_hardlimit,
__entry->ino_softlimit)
) )
#define DEFINE_DQUOT_EVENT(name) \
DEFINE_EVENT(xfs_dquot_class, name, \
TP_PROTO(struct xfs_dquot *dqp), \
TP_ARGS(dqp))
DEFINE_DQUOT_EVENT(xfs_dqadjust); DEFINE_DQUOT_EVENT(xfs_dqadjust);
DEFINE_DQUOT_EVENT(xfs_dqshake_dirty); DEFINE_DQUOT_EVENT(xfs_dqshake_dirty);
DEFINE_DQUOT_EVENT(xfs_dqshake_unlink); DEFINE_DQUOT_EVENT(xfs_dqshake_unlink);
...@@ -610,72 +645,75 @@ DEFINE_DQUOT_EVENT(xfs_dqflush_done); ...@@ -610,72 +645,75 @@ DEFINE_DQUOT_EVENT(xfs_dqflush_done);
DEFINE_IGET_EVENT(xfs_dquot_dqalloc); DEFINE_IGET_EVENT(xfs_dquot_dqalloc);
DEFINE_IGET_EVENT(xfs_dquot_dqdetach); DEFINE_IGET_EVENT(xfs_dquot_dqdetach);
DECLARE_EVENT_CLASS(xfs_loggrant_class,
TP_PROTO(struct log *log, struct xlog_ticket *tic),
TP_ARGS(log, tic),
TP_STRUCT__entry(
__field(dev_t, dev)
__field(unsigned, trans_type)
__field(char, ocnt)
__field(char, cnt)
__field(int, curr_res)
__field(int, unit_res)
__field(unsigned int, flags)
__field(void *, reserve_headq)
__field(void *, write_headq)
__field(int, grant_reserve_cycle)
__field(int, grant_reserve_bytes)
__field(int, grant_write_cycle)
__field(int, grant_write_bytes)
__field(int, curr_cycle)
__field(int, curr_block)
__field(xfs_lsn_t, tail_lsn)
),
TP_fast_assign(
__entry->dev = log->l_mp->m_super->s_dev;
__entry->trans_type = tic->t_trans_type;
__entry->ocnt = tic->t_ocnt;
__entry->cnt = tic->t_cnt;
__entry->curr_res = tic->t_curr_res;
__entry->unit_res = tic->t_unit_res;
__entry->flags = tic->t_flags;
__entry->reserve_headq = log->l_reserve_headq;
__entry->write_headq = log->l_write_headq;
__entry->grant_reserve_cycle = log->l_grant_reserve_cycle;
__entry->grant_reserve_bytes = log->l_grant_reserve_bytes;
__entry->grant_write_cycle = log->l_grant_write_cycle;
__entry->grant_write_bytes = log->l_grant_write_bytes;
__entry->curr_cycle = log->l_curr_cycle;
__entry->curr_block = log->l_curr_block;
__entry->tail_lsn = log->l_tail_lsn;
),
TP_printk("dev %d:%d type %s t_ocnt %u t_cnt %u t_curr_res %u "
"t_unit_res %u t_flags %s reserve_headq 0x%p "
"write_headq 0x%p grant_reserve_cycle %d "
"grant_reserve_bytes %d grant_write_cycle %d "
"grant_write_bytes %d curr_cycle %d curr_block %d "
"tail_cycle %d tail_block %d",
MAJOR(__entry->dev), MINOR(__entry->dev),
__print_symbolic(__entry->trans_type, XFS_TRANS_TYPES),
__entry->ocnt,
__entry->cnt,
__entry->curr_res,
__entry->unit_res,
__print_flags(__entry->flags, "|", XLOG_TIC_FLAGS),
__entry->reserve_headq,
__entry->write_headq,
__entry->grant_reserve_cycle,
__entry->grant_reserve_bytes,
__entry->grant_write_cycle,
__entry->grant_write_bytes,
__entry->curr_cycle,
__entry->curr_block,
CYCLE_LSN(__entry->tail_lsn),
BLOCK_LSN(__entry->tail_lsn)
)
)
#define DEFINE_LOGGRANT_EVENT(tname) \ #define DEFINE_LOGGRANT_EVENT(name) \
TRACE_EVENT(tname, \ DEFINE_EVENT(xfs_loggrant_class, name, \
TP_PROTO(struct log *log, struct xlog_ticket *tic), \ TP_PROTO(struct log *log, struct xlog_ticket *tic), \
TP_ARGS(log, tic), \ TP_ARGS(log, tic))
TP_STRUCT__entry( \
__field(dev_t, dev) \
__field(unsigned, trans_type) \
__field(char, ocnt) \
__field(char, cnt) \
__field(int, curr_res) \
__field(int, unit_res) \
__field(unsigned int, flags) \
__field(void *, reserve_headq) \
__field(void *, write_headq) \
__field(int, grant_reserve_cycle) \
__field(int, grant_reserve_bytes) \
__field(int, grant_write_cycle) \
__field(int, grant_write_bytes) \
__field(int, curr_cycle) \
__field(int, curr_block) \
__field(xfs_lsn_t, tail_lsn) \
), \
TP_fast_assign( \
__entry->dev = log->l_mp->m_super->s_dev; \
__entry->trans_type = tic->t_trans_type; \
__entry->ocnt = tic->t_ocnt; \
__entry->cnt = tic->t_cnt; \
__entry->curr_res = tic->t_curr_res; \
__entry->unit_res = tic->t_unit_res; \
__entry->flags = tic->t_flags; \
__entry->reserve_headq = log->l_reserve_headq; \
__entry->write_headq = log->l_write_headq; \
__entry->grant_reserve_cycle = log->l_grant_reserve_cycle; \
__entry->grant_reserve_bytes = log->l_grant_reserve_bytes; \
__entry->grant_write_cycle = log->l_grant_write_cycle; \
__entry->grant_write_bytes = log->l_grant_write_bytes; \
__entry->curr_cycle = log->l_curr_cycle; \
__entry->curr_block = log->l_curr_block; \
__entry->tail_lsn = log->l_tail_lsn; \
), \
TP_printk("dev %d:%d type %s t_ocnt %u t_cnt %u t_curr_res %u " \
"t_unit_res %u t_flags %s reserve_headq 0x%p " \
"write_headq 0x%p grant_reserve_cycle %d " \
"grant_reserve_bytes %d grant_write_cycle %d " \
"grant_write_bytes %d curr_cycle %d curr_block %d " \
"tail_cycle %d tail_block %d", \
MAJOR(__entry->dev), MINOR(__entry->dev), \
__print_symbolic(__entry->trans_type, XFS_TRANS_TYPES), \
__entry->ocnt, \
__entry->cnt, \
__entry->curr_res, \
__entry->unit_res, \
__print_flags(__entry->flags, "|", XLOG_TIC_FLAGS), \
__entry->reserve_headq, \
__entry->write_headq, \
__entry->grant_reserve_cycle, \
__entry->grant_reserve_bytes, \
__entry->grant_write_cycle, \
__entry->grant_write_bytes, \
__entry->curr_cycle, \
__entry->curr_block, \
CYCLE_LSN(__entry->tail_lsn), \
BLOCK_LSN(__entry->tail_lsn) \
) \
)
DEFINE_LOGGRANT_EVENT(xfs_log_done_nonperm); DEFINE_LOGGRANT_EVENT(xfs_log_done_nonperm);
DEFINE_LOGGRANT_EVENT(xfs_log_done_perm); DEFINE_LOGGRANT_EVENT(xfs_log_done_perm);
DEFINE_LOGGRANT_EVENT(xfs_log_reserve); DEFINE_LOGGRANT_EVENT(xfs_log_reserve);
...@@ -897,28 +935,32 @@ TRACE_EVENT(xfs_itruncate_start, ...@@ -897,28 +935,32 @@ TRACE_EVENT(xfs_itruncate_start,
__entry->toss_finish) __entry->toss_finish)
); );
DECLARE_EVENT_CLASS(xfs_itrunc_class,
TP_PROTO(struct xfs_inode *ip, xfs_fsize_t new_size),
TP_ARGS(ip, new_size),
TP_STRUCT__entry(
__field(dev_t, dev)
__field(xfs_ino_t, ino)
__field(xfs_fsize_t, size)
__field(xfs_fsize_t, new_size)
),
TP_fast_assign(
__entry->dev = VFS_I(ip)->i_sb->s_dev;
__entry->ino = ip->i_ino;
__entry->size = ip->i_d.di_size;
__entry->new_size = new_size;
),
TP_printk("dev %d:%d ino 0x%llx size 0x%llx new_size 0x%llx",
MAJOR(__entry->dev), MINOR(__entry->dev),
__entry->ino,
__entry->size,
__entry->new_size)
)
#define DEFINE_ITRUNC_EVENT(name) \ #define DEFINE_ITRUNC_EVENT(name) \
TRACE_EVENT(name, \ DEFINE_EVENT(xfs_itrunc_class, name, \
TP_PROTO(struct xfs_inode *ip, xfs_fsize_t new_size), \ TP_PROTO(struct xfs_inode *ip, xfs_fsize_t new_size), \
TP_ARGS(ip, new_size), \ TP_ARGS(ip, new_size))
TP_STRUCT__entry( \
__field(dev_t, dev) \
__field(xfs_ino_t, ino) \
__field(xfs_fsize_t, size) \
__field(xfs_fsize_t, new_size) \
), \
TP_fast_assign( \
__entry->dev = VFS_I(ip)->i_sb->s_dev; \
__entry->ino = ip->i_ino; \
__entry->size = ip->i_d.di_size; \
__entry->new_size = new_size; \
), \
TP_printk("dev %d:%d ino 0x%llx size 0x%llx new_size 0x%llx", \
MAJOR(__entry->dev), MINOR(__entry->dev), \
__entry->ino, \
__entry->size, \
__entry->new_size) \
)
DEFINE_ITRUNC_EVENT(xfs_itruncate_finish_start); DEFINE_ITRUNC_EVENT(xfs_itruncate_finish_start);
DEFINE_ITRUNC_EVENT(xfs_itruncate_finish_end); DEFINE_ITRUNC_EVENT(xfs_itruncate_finish_end);
...@@ -1037,28 +1079,28 @@ TRACE_EVENT(xfs_alloc_unbusy, ...@@ -1037,28 +1079,28 @@ TRACE_EVENT(xfs_alloc_unbusy,
TRACE_EVENT(xfs_alloc_busysearch, TRACE_EVENT(xfs_alloc_busysearch,
TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agblock_t agbno, TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, xfs_agblock_t agbno,
xfs_extlen_t len, int found), xfs_extlen_t len, xfs_lsn_t lsn),
TP_ARGS(mp, agno, agbno, len, found), TP_ARGS(mp, agno, agbno, len, lsn),
TP_STRUCT__entry( TP_STRUCT__entry(
__field(dev_t, dev) __field(dev_t, dev)
__field(xfs_agnumber_t, agno) __field(xfs_agnumber_t, agno)
__field(xfs_agblock_t, agbno) __field(xfs_agblock_t, agbno)
__field(xfs_extlen_t, len) __field(xfs_extlen_t, len)
__field(int, found) __field(xfs_lsn_t, lsn)
), ),
TP_fast_assign( TP_fast_assign(
__entry->dev = mp->m_super->s_dev; __entry->dev = mp->m_super->s_dev;
__entry->agno = agno; __entry->agno = agno;
__entry->agbno = agbno; __entry->agbno = agbno;
__entry->len = len; __entry->len = len;
__entry->found = found; __entry->lsn = lsn;
), ),
TP_printk("dev %d:%d agno %u agbno %u len %u %s", TP_printk("dev %d:%d agno %u agbno %u len %u force lsn 0x%llx",
MAJOR(__entry->dev), MINOR(__entry->dev), MAJOR(__entry->dev), MINOR(__entry->dev),
__entry->agno, __entry->agno,
__entry->agbno, __entry->agbno,
__entry->len, __entry->len,
__print_symbolic(__entry->found, XFS_BUSY_STATES)) __entry->lsn)
); );
TRACE_EVENT(xfs_agf, TRACE_EVENT(xfs_agf,
...@@ -1152,77 +1194,80 @@ TRACE_EVENT(xfs_free_extent, ...@@ -1152,77 +1194,80 @@ TRACE_EVENT(xfs_free_extent,
); );
#define DEFINE_ALLOC_EVENT(name) \ DECLARE_EVENT_CLASS(xfs_alloc_class,
TRACE_EVENT(name, \ TP_PROTO(struct xfs_alloc_arg *args),
TP_PROTO(struct xfs_alloc_arg *args), \ TP_ARGS(args),
TP_ARGS(args), \ TP_STRUCT__entry(
TP_STRUCT__entry( \ __field(dev_t, dev)
__field(dev_t, dev) \ __field(xfs_agnumber_t, agno)
__field(xfs_agnumber_t, agno) \ __field(xfs_agblock_t, agbno)
__field(xfs_agblock_t, agbno) \ __field(xfs_extlen_t, minlen)
__field(xfs_extlen_t, minlen) \ __field(xfs_extlen_t, maxlen)
__field(xfs_extlen_t, maxlen) \ __field(xfs_extlen_t, mod)
__field(xfs_extlen_t, mod) \ __field(xfs_extlen_t, prod)
__field(xfs_extlen_t, prod) \ __field(xfs_extlen_t, minleft)
__field(xfs_extlen_t, minleft) \ __field(xfs_extlen_t, total)
__field(xfs_extlen_t, total) \ __field(xfs_extlen_t, alignment)
__field(xfs_extlen_t, alignment) \ __field(xfs_extlen_t, minalignslop)
__field(xfs_extlen_t, minalignslop) \ __field(xfs_extlen_t, len)
__field(xfs_extlen_t, len) \ __field(short, type)
__field(short, type) \ __field(short, otype)
__field(short, otype) \ __field(char, wasdel)
__field(char, wasdel) \ __field(char, wasfromfl)
__field(char, wasfromfl) \ __field(char, isfl)
__field(char, isfl) \ __field(char, userdata)
__field(char, userdata) \ __field(xfs_fsblock_t, firstblock)
__field(xfs_fsblock_t, firstblock) \ ),
), \ TP_fast_assign(
TP_fast_assign( \ __entry->dev = args->mp->m_super->s_dev;
__entry->dev = args->mp->m_super->s_dev; \ __entry->agno = args->agno;
__entry->agno = args->agno; \ __entry->agbno = args->agbno;
__entry->agbno = args->agbno; \ __entry->minlen = args->minlen;
__entry->minlen = args->minlen; \ __entry->maxlen = args->maxlen;
__entry->maxlen = args->maxlen; \ __entry->mod = args->mod;
__entry->mod = args->mod; \ __entry->prod = args->prod;
__entry->prod = args->prod; \ __entry->minleft = args->minleft;
__entry->minleft = args->minleft; \ __entry->total = args->total;
__entry->total = args->total; \ __entry->alignment = args->alignment;
__entry->alignment = args->alignment; \ __entry->minalignslop = args->minalignslop;
__entry->minalignslop = args->minalignslop; \ __entry->len = args->len;
__entry->len = args->len; \ __entry->type = args->type;
__entry->type = args->type; \ __entry->otype = args->otype;
__entry->otype = args->otype; \ __entry->wasdel = args->wasdel;
__entry->wasdel = args->wasdel; \ __entry->wasfromfl = args->wasfromfl;
__entry->wasfromfl = args->wasfromfl; \ __entry->isfl = args->isfl;
__entry->isfl = args->isfl; \ __entry->userdata = args->userdata;
__entry->userdata = args->userdata; \ __entry->firstblock = args->firstblock;
__entry->firstblock = args->firstblock; \ ),
), \ TP_printk("dev %d:%d agno %u agbno %u minlen %u maxlen %u mod %u "
TP_printk("dev %d:%d agno %u agbno %u minlen %u maxlen %u mod %u " \ "prod %u minleft %u total %u alignment %u minalignslop %u "
"prod %u minleft %u total %u alignment %u minalignslop %u " \ "len %u type %s otype %s wasdel %d wasfromfl %d isfl %d "
"len %u type %s otype %s wasdel %d wasfromfl %d isfl %d " \ "userdata %d firstblock 0x%llx",
"userdata %d firstblock %s", \ MAJOR(__entry->dev), MINOR(__entry->dev),
MAJOR(__entry->dev), MINOR(__entry->dev), \ __entry->agno,
__entry->agno, \ __entry->agbno,
__entry->agbno, \ __entry->minlen,
__entry->minlen, \ __entry->maxlen,
__entry->maxlen, \ __entry->mod,
__entry->mod, \ __entry->prod,
__entry->prod, \ __entry->minleft,
__entry->minleft, \ __entry->total,
__entry->total, \ __entry->alignment,
__entry->alignment, \ __entry->minalignslop,
__entry->minalignslop, \ __entry->len,
__entry->len, \ __print_symbolic(__entry->type, XFS_ALLOC_TYPES),
__print_symbolic(__entry->type, XFS_ALLOC_TYPES), \ __print_symbolic(__entry->otype, XFS_ALLOC_TYPES),
__print_symbolic(__entry->otype, XFS_ALLOC_TYPES), \ __entry->wasdel,
__entry->wasdel, \ __entry->wasfromfl,
__entry->wasfromfl, \ __entry->isfl,
__entry->isfl, \ __entry->userdata,
__entry->userdata, \ __entry->firstblock)
xfs_fmtfsblock(__entry->firstblock)) \
) )
#define DEFINE_ALLOC_EVENT(name) \
DEFINE_EVENT(xfs_alloc_class, name, \
TP_PROTO(struct xfs_alloc_arg *args), \
TP_ARGS(args))
DEFINE_ALLOC_EVENT(xfs_alloc_exact_done); DEFINE_ALLOC_EVENT(xfs_alloc_exact_done);
DEFINE_ALLOC_EVENT(xfs_alloc_exact_error); DEFINE_ALLOC_EVENT(xfs_alloc_exact_error);
DEFINE_ALLOC_EVENT(xfs_alloc_near_nominleft); DEFINE_ALLOC_EVENT(xfs_alloc_near_nominleft);
...@@ -1245,92 +1290,100 @@ DEFINE_ALLOC_EVENT(xfs_alloc_vextent_noagbp); ...@@ -1245,92 +1290,100 @@ DEFINE_ALLOC_EVENT(xfs_alloc_vextent_noagbp);
DEFINE_ALLOC_EVENT(xfs_alloc_vextent_loopfailed); DEFINE_ALLOC_EVENT(xfs_alloc_vextent_loopfailed);
DEFINE_ALLOC_EVENT(xfs_alloc_vextent_allfailed); DEFINE_ALLOC_EVENT(xfs_alloc_vextent_allfailed);
#define DEFINE_DIR2_TRACE(tname) \ DECLARE_EVENT_CLASS(xfs_dir2_class,
TRACE_EVENT(tname, \ TP_PROTO(struct xfs_da_args *args),
TP_ARGS(args),
TP_STRUCT__entry(
__field(dev_t, dev)
__field(xfs_ino_t, ino)
__dynamic_array(char, name, args->namelen)
__field(int, namelen)
__field(xfs_dahash_t, hashval)
__field(xfs_ino_t, inumber)
__field(int, op_flags)
),
TP_fast_assign(
__entry->dev = VFS_I(args->dp)->i_sb->s_dev;
__entry->ino = args->dp->i_ino;
if (args->namelen)
memcpy(__get_str(name), args->name, args->namelen);
__entry->namelen = args->namelen;
__entry->hashval = args->hashval;
__entry->inumber = args->inumber;
__entry->op_flags = args->op_flags;
),
TP_printk("dev %d:%d ino 0x%llx name %.*s namelen %d hashval 0x%x "
"inumber 0x%llx op_flags %s",
MAJOR(__entry->dev), MINOR(__entry->dev),
__entry->ino,
__entry->namelen,
__entry->namelen ? __get_str(name) : NULL,
__entry->namelen,
__entry->hashval,
__entry->inumber,
__print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS))
)
#define DEFINE_DIR2_EVENT(name) \
DEFINE_EVENT(xfs_dir2_class, name, \
TP_PROTO(struct xfs_da_args *args), \ TP_PROTO(struct xfs_da_args *args), \
TP_ARGS(args), \ TP_ARGS(args))
TP_STRUCT__entry( \ DEFINE_DIR2_EVENT(xfs_dir2_sf_addname);
__field(dev_t, dev) \ DEFINE_DIR2_EVENT(xfs_dir2_sf_create);
__field(xfs_ino_t, ino) \ DEFINE_DIR2_EVENT(xfs_dir2_sf_lookup);
__dynamic_array(char, name, args->namelen) \ DEFINE_DIR2_EVENT(xfs_dir2_sf_replace);
__field(int, namelen) \ DEFINE_DIR2_EVENT(xfs_dir2_sf_removename);
__field(xfs_dahash_t, hashval) \ DEFINE_DIR2_EVENT(xfs_dir2_sf_toino4);
__field(xfs_ino_t, inumber) \ DEFINE_DIR2_EVENT(xfs_dir2_sf_toino8);
__field(int, op_flags) \ DEFINE_DIR2_EVENT(xfs_dir2_sf_to_block);
), \ DEFINE_DIR2_EVENT(xfs_dir2_block_addname);
TP_fast_assign( \ DEFINE_DIR2_EVENT(xfs_dir2_block_lookup);
__entry->dev = VFS_I(args->dp)->i_sb->s_dev; \ DEFINE_DIR2_EVENT(xfs_dir2_block_replace);
__entry->ino = args->dp->i_ino; \ DEFINE_DIR2_EVENT(xfs_dir2_block_removename);
if (args->namelen) \ DEFINE_DIR2_EVENT(xfs_dir2_block_to_sf);
memcpy(__get_str(name), args->name, args->namelen); \ DEFINE_DIR2_EVENT(xfs_dir2_block_to_leaf);
__entry->namelen = args->namelen; \ DEFINE_DIR2_EVENT(xfs_dir2_leaf_addname);
__entry->hashval = args->hashval; \ DEFINE_DIR2_EVENT(xfs_dir2_leaf_lookup);
__entry->inumber = args->inumber; \ DEFINE_DIR2_EVENT(xfs_dir2_leaf_replace);
__entry->op_flags = args->op_flags; \ DEFINE_DIR2_EVENT(xfs_dir2_leaf_removename);
), \ DEFINE_DIR2_EVENT(xfs_dir2_leaf_to_block);
TP_printk("dev %d:%d ino 0x%llx name %.*s namelen %d hashval 0x%x " \ DEFINE_DIR2_EVENT(xfs_dir2_leaf_to_node);
"inumber 0x%llx op_flags %s", \ DEFINE_DIR2_EVENT(xfs_dir2_node_addname);
MAJOR(__entry->dev), MINOR(__entry->dev), \ DEFINE_DIR2_EVENT(xfs_dir2_node_lookup);
__entry->ino, \ DEFINE_DIR2_EVENT(xfs_dir2_node_replace);
__entry->namelen, \ DEFINE_DIR2_EVENT(xfs_dir2_node_removename);
__entry->namelen ? __get_str(name) : NULL, \ DEFINE_DIR2_EVENT(xfs_dir2_node_to_leaf);
__entry->namelen, \
__entry->hashval, \ DECLARE_EVENT_CLASS(xfs_dir2_space_class,
__entry->inumber, \ TP_PROTO(struct xfs_da_args *args, int idx),
__print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS)) \ TP_ARGS(args, idx),
TP_STRUCT__entry(
__field(dev_t, dev)
__field(xfs_ino_t, ino)
__field(int, op_flags)
__field(int, idx)
),
TP_fast_assign(
__entry->dev = VFS_I(args->dp)->i_sb->s_dev;
__entry->ino = args->dp->i_ino;
__entry->op_flags = args->op_flags;
__entry->idx = idx;
),
TP_printk("dev %d:%d ino 0x%llx op_flags %s index %d",
MAJOR(__entry->dev), MINOR(__entry->dev),
__entry->ino,
__print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS),
__entry->idx)
) )
DEFINE_DIR2_TRACE(xfs_dir2_sf_addname);
DEFINE_DIR2_TRACE(xfs_dir2_sf_create);
DEFINE_DIR2_TRACE(xfs_dir2_sf_lookup);
DEFINE_DIR2_TRACE(xfs_dir2_sf_replace);
DEFINE_DIR2_TRACE(xfs_dir2_sf_removename);
DEFINE_DIR2_TRACE(xfs_dir2_sf_toino4);
DEFINE_DIR2_TRACE(xfs_dir2_sf_toino8);
DEFINE_DIR2_TRACE(xfs_dir2_sf_to_block);
DEFINE_DIR2_TRACE(xfs_dir2_block_addname);
DEFINE_DIR2_TRACE(xfs_dir2_block_lookup);
DEFINE_DIR2_TRACE(xfs_dir2_block_replace);
DEFINE_DIR2_TRACE(xfs_dir2_block_removename);
DEFINE_DIR2_TRACE(xfs_dir2_block_to_sf);
DEFINE_DIR2_TRACE(xfs_dir2_block_to_leaf);
DEFINE_DIR2_TRACE(xfs_dir2_leaf_addname);
DEFINE_DIR2_TRACE(xfs_dir2_leaf_lookup);
DEFINE_DIR2_TRACE(xfs_dir2_leaf_replace);
DEFINE_DIR2_TRACE(xfs_dir2_leaf_removename);
DEFINE_DIR2_TRACE(xfs_dir2_leaf_to_block);
DEFINE_DIR2_TRACE(xfs_dir2_leaf_to_node);
DEFINE_DIR2_TRACE(xfs_dir2_node_addname);
DEFINE_DIR2_TRACE(xfs_dir2_node_lookup);
DEFINE_DIR2_TRACE(xfs_dir2_node_replace);
DEFINE_DIR2_TRACE(xfs_dir2_node_removename);
DEFINE_DIR2_TRACE(xfs_dir2_node_to_leaf);
#define DEFINE_DIR2_SPACE_TRACE(tname) \ #define DEFINE_DIR2_SPACE_EVENT(name) \
TRACE_EVENT(tname, \ DEFINE_EVENT(xfs_dir2_space_class, name, \
TP_PROTO(struct xfs_da_args *args, int idx), \ TP_PROTO(struct xfs_da_args *args, int idx), \
TP_ARGS(args, idx), \ TP_ARGS(args, idx))
TP_STRUCT__entry( \ DEFINE_DIR2_SPACE_EVENT(xfs_dir2_leafn_add);
__field(dev_t, dev) \ DEFINE_DIR2_SPACE_EVENT(xfs_dir2_leafn_remove);
__field(xfs_ino_t, ino) \ DEFINE_DIR2_SPACE_EVENT(xfs_dir2_grow_inode);
__field(int, op_flags) \ DEFINE_DIR2_SPACE_EVENT(xfs_dir2_shrink_inode);
__field(int, idx) \
), \
TP_fast_assign( \
__entry->dev = VFS_I(args->dp)->i_sb->s_dev; \
__entry->ino = args->dp->i_ino; \
__entry->op_flags = args->op_flags; \
__entry->idx = idx; \
), \
TP_printk("dev %d:%d ino 0x%llx op_flags %s index %d", \
MAJOR(__entry->dev), MINOR(__entry->dev), \
__entry->ino, \
__print_flags(__entry->op_flags, "|", XFS_DA_OP_FLAGS), \
__entry->idx) \
)
DEFINE_DIR2_SPACE_TRACE(xfs_dir2_leafn_add);
DEFINE_DIR2_SPACE_TRACE(xfs_dir2_leafn_remove);
DEFINE_DIR2_SPACE_TRACE(xfs_dir2_grow_inode);
DEFINE_DIR2_SPACE_TRACE(xfs_dir2_shrink_inode);
TRACE_EVENT(xfs_dir2_leafn_moveents, TRACE_EVENT(xfs_dir2_leafn_moveents,
TP_PROTO(struct xfs_da_args *args, int src_idx, int dst_idx, int count), TP_PROTO(struct xfs_da_args *args, int src_idx, int dst_idx, int count),
......
fs/xfs/xfs_alloc.c
浏览文件 @ 1b4d40a5
...@@ -2563,43 +2563,41 @@ xfs_alloc_search_busy(xfs_trans_t *tp, ...@@ -2563,43 +2563,41 @@ xfs_alloc_search_busy(xfs_trans_t *tp,
xfs_mount_t *mp; xfs_mount_t *mp;
xfs_perag_busy_t *bsy; xfs_perag_busy_t *bsy;
xfs_agblock_t uend, bend; xfs_agblock_t uend, bend;
xfs_lsn_t lsn; xfs_lsn_t lsn = 0;
int cnt; int cnt;
mp = tp->t_mountp; mp = tp->t_mountp;
spin_lock(&mp->m_perag[agno].pagb_lock); spin_lock(&mp->m_perag[agno].pagb_lock);
cnt = mp->m_perag[agno].pagb_count;
uend = bno + len - 1; uend = bno + len - 1;
/* search pagb_list for this slot, skipping open slots */
for (bsy = mp->m_perag[agno].pagb_list; cnt; bsy++) {
/* /*
* (start1,length1) within (start2, length2) * search pagb_list for this slot, skipping open slots. We have to
* search the entire array as there may be multiple overlaps and
* we have to get the most recent LSN for the log force to push out
* all the transactions that span the range.
*/ */
if (bsy->busy_tp != NULL) { for (cnt = 0; cnt < mp->m_perag[agno].pagb_count; cnt++) {
bsy = &mp->m_perag[agno].pagb_list[cnt];
if (!bsy->busy_tp)
continue;
bend = bsy->busy_start + bsy->busy_length - 1; bend = bsy->busy_start + bsy->busy_length - 1;
if ((bno > bend) || (uend < bsy->busy_start)) { if (bno > bend || uend < bsy->busy_start)
cnt--; continue;
} else {
break;
}
}
}
trace_xfs_alloc_busysearch(mp, agno, bno, len, !!cnt); /* (start1,length1) within (start2, length2) */
if (XFS_LSN_CMP(bsy->busy_tp->t_commit_lsn, lsn) > 0)
lsn = bsy->busy_tp->t_commit_lsn;
}
spin_unlock(&mp->m_perag[agno].pagb_lock);
trace_xfs_alloc_busysearch(tp->t_mountp, agno, bno, len, lsn);
/* /*
* If a block was found, force the log through the LSN of the * If a block was found, force the log through the LSN of the
* transaction that freed the block * transaction that freed the block
*/ */
if (cnt) { if (lsn)
lsn = bsy->busy_tp->t_commit_lsn;
spin_unlock(&mp->m_perag[agno].pagb_lock);
xfs_log_force(mp, lsn, XFS_LOG_FORCE|XFS_LOG_SYNC); xfs_log_force(mp, lsn, XFS_LOG_FORCE|XFS_LOG_SYNC);
} else {
spin_unlock(&mp->m_perag[agno].pagb_lock);
}
} }
fs/xfs/xfs_inode.c
浏览文件 @ 1b4d40a5
...@@ -2841,10 +2841,14 @@ xfs_iflush( ...@@ -2841,10 +2841,14 @@ xfs_iflush(
mp = ip->i_mount; mp = ip->i_mount;
/* /*
* If the inode isn't dirty, then just release the inode * If the inode isn't dirty, then just release the inode flush lock and
* flush lock and do nothing. * do nothing. Treat stale inodes the same; we cannot rely on the
*/ * backing buffer remaining stale in cache for the remaining life of
if (xfs_inode_clean(ip)) { * the stale inode and so xfs_itobp() below may give us a buffer that
* no longer contains inodes below. Doing this stale check here also
* avoids forcing the log on pinned, stale inodes.
*/
if (xfs_inode_clean(ip) || xfs_iflags_test(ip, XFS_ISTALE)) {
xfs_ifunlock(ip); xfs_ifunlock(ip);
return 0; return 0;
} }
......
fs/xfs/xfs_vnodeops.c
浏览文件 @ 1b4d40a5
...@@ -70,7 +70,6 @@ xfs_setattr( ...@@ -70,7 +70,6 @@ xfs_setattr(
uint commit_flags=0; uint commit_flags=0;
uid_t uid=0, iuid=0; uid_t uid=0, iuid=0;
gid_t gid=0, igid=0; gid_t gid=0, igid=0;
int timeflags = 0;
struct xfs_dquot *udqp, *gdqp, *olddquot1, *olddquot2; struct xfs_dquot *udqp, *gdqp, *olddquot1, *olddquot2;
int need_iolock = 1; int need_iolock = 1;
...@@ -135,17 +134,14 @@ xfs_setattr( ...@@ -135,17 +134,14 @@ xfs_setattr(
if (flags & XFS_ATTR_NOLOCK) if (flags & XFS_ATTR_NOLOCK)
need_iolock = 0; need_iolock = 0;
if (!(mask & ATTR_SIZE)) { if (!(mask & ATTR_SIZE)) {
if ((mask != (ATTR_CTIME|ATTR_ATIME|ATTR_MTIME)) ||
(mp->m_flags & XFS_MOUNT_WSYNC)) {
tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE); tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE);
commit_flags = 0; commit_flags = 0;
if ((code = xfs_trans_reserve(tp, 0, code = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES(mp),
XFS_ICHANGE_LOG_RES(mp), 0, 0, 0, 0);
0, 0))) { if (code) {
lock_flags = 0; lock_flags = 0;
goto error_return; goto error_return;
} }
}
} else { } else {
if (DM_EVENT_ENABLED(ip, DM_EVENT_TRUNCATE) && if (DM_EVENT_ENABLED(ip, DM_EVENT_TRUNCATE) &&
!(flags & XFS_ATTR_DMI)) { !(flags & XFS_ATTR_DMI)) {
...@@ -295,15 +291,23 @@ xfs_setattr( ...@@ -295,15 +291,23 @@ xfs_setattr(
* or we are explicitly asked to change it. This handles * or we are explicitly asked to change it. This handles
* the semantic difference between truncate() and ftruncate() * the semantic difference between truncate() and ftruncate()
* as implemented in the VFS. * as implemented in the VFS.
*
* The regular truncate() case without ATTR_CTIME and ATTR_MTIME
* is a special case where we need to update the times despite
* not having these flags set. For all other operations the
* VFS set these flags explicitly if it wants a timestamp
* update.
*/ */
if (iattr->ia_size != ip->i_size || (mask & ATTR_CTIME)) if (iattr->ia_size != ip->i_size &&
timeflags |= XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG; (!(mask & (ATTR_CTIME | ATTR_MTIME)))) {
iattr->ia_ctime = iattr->ia_mtime =
current_fs_time(inode->i_sb);
mask |= ATTR_CTIME | ATTR_MTIME;
}
if (iattr->ia_size > ip->i_size) { if (iattr->ia_size > ip->i_size) {
ip->i_d.di_size = iattr->ia_size; ip->i_d.di_size = iattr->ia_size;
ip->i_size = iattr->ia_size; ip->i_size = iattr->ia_size;
if (!(flags & XFS_ATTR_DMI))
xfs_ichgtime(ip, XFS_ICHGTIME_CHG);
xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
} else if (iattr->ia_size <= ip->i_size || } else if (iattr->ia_size <= ip->i_size ||
(iattr->ia_size == 0 && ip->i_d.di_nextents)) { (iattr->ia_size == 0 && ip->i_d.di_nextents)) {
...@@ -374,9 +378,6 @@ xfs_setattr( ...@@ -374,9 +378,6 @@ xfs_setattr(
ip->i_d.di_gid = gid; ip->i_d.di_gid = gid;
inode->i_gid = gid; inode->i_gid = gid;
} }
xfs_trans_log_inode (tp, ip, XFS_ILOG_CORE);
timeflags |= XFS_ICHGTIME_CHG;
} }
/* /*
...@@ -393,51 +394,37 @@ xfs_setattr( ...@@ -393,51 +394,37 @@ xfs_setattr(
inode->i_mode &= S_IFMT; inode->i_mode &= S_IFMT;
inode->i_mode |= mode & ~S_IFMT; inode->i_mode |= mode & ~S_IFMT;
xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
timeflags |= XFS_ICHGTIME_CHG;
} }
/* /*
* Change file access or modified times. * Change file access or modified times.
*/ */
if (mask & (ATTR_ATIME|ATTR_MTIME)) {
if (mask & ATTR_ATIME) { if (mask & ATTR_ATIME) {
inode->i_atime = iattr->ia_atime; inode->i_atime = iattr->ia_atime;
ip->i_d.di_atime.t_sec = iattr->ia_atime.tv_sec; ip->i_d.di_atime.t_sec = iattr->ia_atime.tv_sec;
ip->i_d.di_atime.t_nsec = iattr->ia_atime.tv_nsec; ip->i_d.di_atime.t_nsec = iattr->ia_atime.tv_nsec;
ip->i_update_core = 1; ip->i_update_core = 1;
} }
if (mask & ATTR_CTIME) {
inode->i_ctime = iattr->ia_ctime;
ip->i_d.di_ctime.t_sec = iattr->ia_ctime.tv_sec;
ip->i_d.di_ctime.t_nsec = iattr->ia_ctime.tv_nsec;
ip->i_update_core = 1;
}
if (mask & ATTR_MTIME) { if (mask & ATTR_MTIME) {
inode->i_mtime = iattr->ia_mtime; inode->i_mtime = iattr->ia_mtime;
ip->i_d.di_mtime.t_sec = iattr->ia_mtime.tv_sec; ip->i_d.di_mtime.t_sec = iattr->ia_mtime.tv_sec;
ip->i_d.di_mtime.t_nsec = iattr->ia_mtime.tv_nsec; ip->i_d.di_mtime.t_nsec = iattr->ia_mtime.tv_nsec;
timeflags &= ~XFS_ICHGTIME_MOD;
timeflags |= XFS_ICHGTIME_CHG;
}
if (tp && (mask & (ATTR_MTIME_SET|ATTR_ATIME_SET)))
xfs_trans_log_inode (tp, ip, XFS_ILOG_CORE);
}
/*
* Change file inode change time only if ATTR_CTIME set
* AND we have been called by a DMI function.
*/
if ((flags & XFS_ATTR_DMI) && (mask & ATTR_CTIME)) {
inode->i_ctime = iattr->ia_ctime;
ip->i_d.di_ctime.t_sec = iattr->ia_ctime.tv_sec;
ip->i_d.di_ctime.t_nsec = iattr->ia_ctime.tv_nsec;
ip->i_update_core = 1; ip->i_update_core = 1;
timeflags &= ~XFS_ICHGTIME_CHG;
} }
/* /*
* Send out timestamp changes that need to be set to the * And finally, log the inode core if any attribute in it
* current time. Not done when called by a DMI function. * has been changed.
*/ */
if (timeflags && !(flags & XFS_ATTR_DMI)) if (mask & (ATTR_UID|ATTR_GID|ATTR_MODE|
xfs_ichgtime(ip, timeflags); ATTR_ATIME|ATTR_CTIME|ATTR_MTIME))
xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
XFS_STATS_INC(xs_ig_attrchg); XFS_STATS_INC(xs_ig_attrchg);
...@@ -452,12 +439,10 @@ xfs_setattr( ...@@ -452,12 +439,10 @@ xfs_setattr(
* mix so this probably isn't worth the trouble to optimize. * mix so this probably isn't worth the trouble to optimize.
*/ */
code = 0; code = 0;
if (tp) {
if (mp->m_flags & XFS_MOUNT_WSYNC) if (mp->m_flags & XFS_MOUNT_WSYNC)
xfs_trans_set_sync(tp); xfs_trans_set_sync(tp);
code = xfs_trans_commit(tp, commit_flags); code = xfs_trans_commit(tp, commit_flags);
}
xfs_iunlock(ip, lock_flags); xfs_iunlock(ip, lock_flags);
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或