hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

xfs: Clean up XFS_BLI_* flag namespace 

Clean up the buffer log format (XFS_BLI_*) flags because they have a
polluted namespace. They XFS_BLI_ prefix is used for both in-memory
and on-disk flag feilds, but have overlapping values for different
flags. Rename the buffer log format flags to use the XFS_BLF_*
prefix to avoid confusing them with the in-memory XFS_BLI_* prefixed
flags.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>
This commit is contained in:
Dave Chinner 2010-05-07 11:05:19 +10:00 committed by Alex Elder
parent 64fc35de60
commit c11554104f
7 changed files with 70 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
fs/xfs/linux-2.6/xfs_super.c
View File

@ -1754,7 +1754,7 @@ xfs_init_zones(void)
* but it is much faster. * but it is much faster.
*/ */
xfs_buf_item_zone = kmem_zone_init((sizeof(xfs_buf_log_item_t) + xfs_buf_item_zone = kmem_zone_init((sizeof(xfs_buf_log_item_t) +
(((XFS_MAX_BLOCKSIZE / XFS_BLI_CHUNK) / (((XFS_MAX_BLOCKSIZE / XFS_BLF_CHUNK) /
NBWORD) * sizeof(int))), "xfs_buf_item"); NBWORD) * sizeof(int))), "xfs_buf_item");
if (!xfs_buf_item_zone) if (!xfs_buf_item_zone)
goto out_destroy_trans_zone; goto out_destroy_trans_zone;

6
fs/xfs/quota/xfs_dquot.c
View File

@ -344,9 +344,9 @@ xfs_qm_init_dquot_blk(
for (i = 0; i < q->qi_dqperchunk; i++, d++, curid++) for (i = 0; i < q->qi_dqperchunk; i++, d++, curid++)
xfs_qm_dqinit_core(curid, type, d); xfs_qm_dqinit_core(curid, type, d);
xfs_trans_dquot_buf(tp, bp, xfs_trans_dquot_buf(tp, bp,
(type & XFS_DQ_USER ? XFS_BLI_UDQUOT_BUF : (type & XFS_DQ_USER ? XFS_BLF_UDQUOT_BUF :
((type & XFS_DQ_PROJ) ? XFS_BLI_PDQUOT_BUF : ((type & XFS_DQ_PROJ) ? XFS_BLF_PDQUOT_BUF :
XFS_BLI_GDQUOT_BUF))); XFS_BLF_GDQUOT_BUF)));
xfs_trans_log_buf(tp, bp, 0, BBTOB(q->qi_dqchunklen) - 1); xfs_trans_log_buf(tp, bp, 0, BBTOB(q->qi_dqchunklen) - 1);
} }

42
fs/xfs/xfs_buf_item.c
View File

@ -64,7 +64,7 @@ xfs_buf_item_log_debug(
nbytes = last - first + 1; nbytes = last - first + 1;
bfset(bip->bli_logged, first, nbytes); bfset(bip->bli_logged, first, nbytes);
for (x = 0; x < nbytes; x++) { for (x = 0; x < nbytes; x++) {
chunk_num = byte >> XFS_BLI_SHIFT; chunk_num = byte >> XFS_BLF_SHIFT;
word_num = chunk_num >> BIT_TO_WORD_SHIFT; word_num = chunk_num >> BIT_TO_WORD_SHIFT;
bit_num = chunk_num & (NBWORD - 1); bit_num = chunk_num & (NBWORD - 1);
wordp = &(bip->bli_format.blf_data_map[word_num]); wordp = &(bip->bli_format.blf_data_map[word_num]);
@ -166,7 +166,7 @@ xfs_buf_item_size(
* cancel flag in it. * cancel flag in it.
*/ */
trace_xfs_buf_item_size_stale(bip); trace_xfs_buf_item_size_stale(bip);
ASSERT(bip->bli_format.blf_flags & XFS_BLI_CANCEL); ASSERT(bip->bli_format.blf_flags & XFS_BLF_CANCEL);
return 1; return 1;
} }
@ -197,9 +197,9 @@ xfs_buf_item_size(
} else if (next_bit != last_bit + 1) { } else if (next_bit != last_bit + 1) {
last_bit = next_bit; last_bit = next_bit;
nvecs++; nvecs++;
} else if (xfs_buf_offset(bp, next_bit * XFS_BLI_CHUNK) != } else if (xfs_buf_offset(bp, next_bit * XFS_BLF_CHUNK) !=
(xfs_buf_offset(bp, last_bit * XFS_BLI_CHUNK) + (xfs_buf_offset(bp, last_bit * XFS_BLF_CHUNK) +
XFS_BLI_CHUNK)) { XFS_BLF_CHUNK)) {
last_bit = next_bit; last_bit = next_bit;
nvecs++; nvecs++;
} else { } else {
@ -261,7 +261,7 @@ xfs_buf_item_format(
* cancel flag in it. * cancel flag in it.
*/ */
trace_xfs_buf_item_format_stale(bip); trace_xfs_buf_item_format_stale(bip);
ASSERT(bip->bli_format.blf_flags & XFS_BLI_CANCEL); ASSERT(bip->bli_format.blf_flags & XFS_BLF_CANCEL);
bip->bli_format.blf_size = nvecs; bip->bli_format.blf_size = nvecs;
return; return;
} }
@ -294,28 +294,28 @@ xfs_buf_item_format(
* keep counting and scanning. * keep counting and scanning.
*/ */
if (next_bit == -1) { if (next_bit == -1) {
buffer_offset = first_bit * XFS_BLI_CHUNK; buffer_offset = first_bit * XFS_BLF_CHUNK;
vecp->i_addr = xfs_buf_offset(bp, buffer_offset); vecp->i_addr = xfs_buf_offset(bp, buffer_offset);
vecp->i_len = nbits * XFS_BLI_CHUNK; vecp->i_len = nbits * XFS_BLF_CHUNK;
vecp->i_type = XLOG_REG_TYPE_BCHUNK; vecp->i_type = XLOG_REG_TYPE_BCHUNK;
nvecs++; nvecs++;
break; break;
} else if (next_bit != last_bit + 1) { } else if (next_bit != last_bit + 1) {
buffer_offset = first_bit * XFS_BLI_CHUNK; buffer_offset = first_bit * XFS_BLF_CHUNK;
vecp->i_addr = xfs_buf_offset(bp, buffer_offset); vecp->i_addr = xfs_buf_offset(bp, buffer_offset);
vecp->i_len = nbits * XFS_BLI_CHUNK; vecp->i_len = nbits * XFS_BLF_CHUNK;
vecp->i_type = XLOG_REG_TYPE_BCHUNK; vecp->i_type = XLOG_REG_TYPE_BCHUNK;
nvecs++; nvecs++;
vecp++; vecp++;
first_bit = next_bit; first_bit = next_bit;
last_bit = next_bit; last_bit = next_bit;
nbits = 1; nbits = 1;
} else if (xfs_buf_offset(bp, next_bit << XFS_BLI_SHIFT) != } else if (xfs_buf_offset(bp, next_bit << XFS_BLF_SHIFT) !=
(xfs_buf_offset(bp, last_bit << XFS_BLI_SHIFT) + (xfs_buf_offset(bp, last_bit << XFS_BLF_SHIFT) +
XFS_BLI_CHUNK)) { XFS_BLF_CHUNK)) {
buffer_offset = first_bit * XFS_BLI_CHUNK; buffer_offset = first_bit * XFS_BLF_CHUNK;
vecp->i_addr = xfs_buf_offset(bp, buffer_offset); vecp->i_addr = xfs_buf_offset(bp, buffer_offset);
vecp->i_len = nbits * XFS_BLI_CHUNK; vecp->i_len = nbits * XFS_BLF_CHUNK;
vecp->i_type = XLOG_REG_TYPE_BCHUNK; vecp->i_type = XLOG_REG_TYPE_BCHUNK;
/* You would think we need to bump the nvecs here too, but we do not /* You would think we need to bump the nvecs here too, but we do not
* this number is used by recovery, and it gets confused by the boundary * this number is used by recovery, and it gets confused by the boundary
@ -399,7 +399,7 @@ xfs_buf_item_unpin(
ASSERT(XFS_BUF_VALUSEMA(bp) <= 0); ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
ASSERT(!(XFS_BUF_ISDELAYWRITE(bp))); ASSERT(!(XFS_BUF_ISDELAYWRITE(bp)));
ASSERT(XFS_BUF_ISSTALE(bp)); ASSERT(XFS_BUF_ISSTALE(bp));
ASSERT(bip->bli_format.blf_flags & XFS_BLI_CANCEL); ASSERT(bip->bli_format.blf_flags & XFS_BLF_CANCEL);
trace_xfs_buf_item_unpin_stale(bip); trace_xfs_buf_item_unpin_stale(bip);
/* /*
@ -550,7 +550,7 @@ xfs_buf_item_unlock(
*/ */
if (bip->bli_flags & XFS_BLI_STALE) { if (bip->bli_flags & XFS_BLI_STALE) {
trace_xfs_buf_item_unlock_stale(bip); trace_xfs_buf_item_unlock_stale(bip);
ASSERT(bip->bli_format.blf_flags & XFS_BLI_CANCEL); ASSERT(bip->bli_format.blf_flags & XFS_BLF_CANCEL);
if (!aborted) { if (!aborted) {
atomic_dec(&bip->bli_refcount); atomic_dec(&bip->bli_refcount);
return; return;
@ -707,12 +707,12 @@ xfs_buf_item_init(
} }
/* /*
* chunks is the number of XFS_BLI_CHUNK size pieces * chunks is the number of XFS_BLF_CHUNK size pieces
* the buffer can be divided into. Make sure not to * the buffer can be divided into. Make sure not to
* truncate any pieces. map_size is the size of the * truncate any pieces. map_size is the size of the
* bitmap needed to describe the chunks of the buffer. * bitmap needed to describe the chunks of the buffer.
*/ */
chunks = (int)((XFS_BUF_COUNT(bp) + (XFS_BLI_CHUNK - 1)) >> XFS_BLI_SHIFT); chunks = (int)((XFS_BUF_COUNT(bp) + (XFS_BLF_CHUNK - 1)) >> XFS_BLF_SHIFT);
map_size = (int)((chunks + NBWORD) >> BIT_TO_WORD_SHIFT); map_size = (int)((chunks + NBWORD) >> BIT_TO_WORD_SHIFT);
bip = (xfs_buf_log_item_t*)kmem_zone_zalloc(xfs_buf_item_zone, bip = (xfs_buf_log_item_t*)kmem_zone_zalloc(xfs_buf_item_zone,
@ -780,8 +780,8 @@ xfs_buf_item_log(
/* /*
* Convert byte offsets to bit numbers. * Convert byte offsets to bit numbers.
*/ */
first_bit = first >> XFS_BLI_SHIFT; first_bit = first >> XFS_BLF_SHIFT;
last_bit = last >> XFS_BLI_SHIFT; last_bit = last >> XFS_BLF_SHIFT;
/* /*
* Calculate the total number of bits to be set. * Calculate the total number of bits to be set.

14
fs/xfs/xfs_buf_item.h
View File

@ -41,22 +41,22 @@ typedef struct xfs_buf_log_format {
* This flag indicates that the buffer contains on disk inodes * This flag indicates that the buffer contains on disk inodes
* and requires special recovery handling. * and requires special recovery handling.
*/ */
#define XFS_BLI_INODE_BUF 0x1 #define XFS_BLF_INODE_BUF 0x1
/* /*
* This flag indicates that the buffer should not be replayed * This flag indicates that the buffer should not be replayed
* during recovery because its blocks are being freed. * during recovery because its blocks are being freed.
*/ */
#define XFS_BLI_CANCEL 0x2 #define XFS_BLF_CANCEL 0x2
/* /*
* This flag indicates that the buffer contains on disk * This flag indicates that the buffer contains on disk
* user or group dquots and may require special recovery handling. * user or group dquots and may require special recovery handling.
*/ */
#define XFS_BLI_UDQUOT_BUF 0x4 #define XFS_BLF_UDQUOT_BUF 0x4
#define XFS_BLI_PDQUOT_BUF 0x8 #define XFS_BLF_PDQUOT_BUF 0x8
#define XFS_BLI_GDQUOT_BUF 0x10 #define XFS_BLF_GDQUOT_BUF 0x10
#define XFS_BLI_CHUNK 128 #define XFS_BLF_CHUNK 128
#define XFS_BLI_SHIFT 7 #define XFS_BLF_SHIFT 7
#define BIT_TO_WORD_SHIFT 5 #define BIT_TO_WORD_SHIFT 5
#define NBWORD (NBBY * sizeof(unsigned int)) #define NBWORD (NBBY * sizeof(unsigned int))

46
fs/xfs/xfs_log_recover.c
View File

@ -1576,7 +1576,7 @@ xlog_recover_reorder_trans(
switch (ITEM_TYPE(item)) { switch (ITEM_TYPE(item)) {
case XFS_LI_BUF: case XFS_LI_BUF:
if (!(buf_f->blf_flags & XFS_BLI_CANCEL)) { if (!(buf_f->blf_flags & XFS_BLF_CANCEL)) {
trace_xfs_log_recover_item_reorder_head(log, trace_xfs_log_recover_item_reorder_head(log,
trans, item, pass); trans, item, pass);
list_move(&item->ri_list, &trans->r_itemq); list_move(&item->ri_list, &trans->r_itemq);
@ -1638,7 +1638,7 @@ xlog_recover_do_buffer_pass1(
/* /*
* If this isn't a cancel buffer item, then just return. * If this isn't a cancel buffer item, then just return.
*/ */
if (!(flags & XFS_BLI_CANCEL)) { if (!(flags & XFS_BLF_CANCEL)) {
trace_xfs_log_recover_buf_not_cancel(log, buf_f); trace_xfs_log_recover_buf_not_cancel(log, buf_f);
return; return;
} }
@ -1696,7 +1696,7 @@ xlog_recover_do_buffer_pass1(
* Check to see whether the buffer being recovered has a corresponding * Check to see whether the buffer being recovered has a corresponding
* entry in the buffer cancel record table. If it does then return 1 * entry in the buffer cancel record table. If it does then return 1
* so that it will be cancelled, otherwise return 0. If the buffer is * so that it will be cancelled, otherwise return 0. If the buffer is
* actually a buffer cancel item (XFS_BLI_CANCEL is set), then decrement * actually a buffer cancel item (XFS_BLF_CANCEL is set), then decrement
* the refcount on the entry in the table and remove it from the table * the refcount on the entry in the table and remove it from the table
* if this is the last reference. * if this is the last reference.
* *
@ -1721,7 +1721,7 @@ xlog_check_buffer_cancelled(
* There is nothing in the table built in pass one, * There is nothing in the table built in pass one,
* so this buffer must not be cancelled. * so this buffer must not be cancelled.
*/ */
ASSERT(!(flags & XFS_BLI_CANCEL)); ASSERT(!(flags & XFS_BLF_CANCEL));
return 0; return 0;
} }
@ -1733,7 +1733,7 @@ xlog_check_buffer_cancelled(
* There is no corresponding entry in the table built * There is no corresponding entry in the table built
* in pass one, so this buffer has not been cancelled. * in pass one, so this buffer has not been cancelled.
*/ */
ASSERT(!(flags & XFS_BLI_CANCEL)); ASSERT(!(flags & XFS_BLF_CANCEL));
return 0; return 0;
} }
@ -1752,7 +1752,7 @@ xlog_check_buffer_cancelled(
* one in the table and remove it if this is the * one in the table and remove it if this is the
* last reference. * last reference.
*/ */
if (flags & XFS_BLI_CANCEL) { if (flags & XFS_BLF_CANCEL) {
bcp->bc_refcount--; bcp->bc_refcount--;
if (bcp->bc_refcount == 0) { if (bcp->bc_refcount == 0) {
if (prevp == NULL) { if (prevp == NULL) {
@ -1772,7 +1772,7 @@ xlog_check_buffer_cancelled(
* We didn't find a corresponding entry in the table, so * We didn't find a corresponding entry in the table, so
* return 0 so that the buffer is NOT cancelled. * return 0 so that the buffer is NOT cancelled.
*/ */
ASSERT(!(flags & XFS_BLI_CANCEL)); ASSERT(!(flags & XFS_BLF_CANCEL));
return 0; return 0;
} }
@ -1874,8 +1874,8 @@ xlog_recover_do_inode_buffer(
nbits = xfs_contig_bits(data_map, map_size, nbits = xfs_contig_bits(data_map, map_size,
bit); bit);
ASSERT(nbits > 0); ASSERT(nbits > 0);
reg_buf_offset = bit << XFS_BLI_SHIFT; reg_buf_offset = bit << XFS_BLF_SHIFT;
reg_buf_bytes = nbits << XFS_BLI_SHIFT; reg_buf_bytes = nbits << XFS_BLF_SHIFT;
item_index++; item_index++;
} }
@ -1889,7 +1889,7 @@ xlog_recover_do_inode_buffer(
} }
ASSERT(item->ri_buf[item_index].i_addr != NULL); ASSERT(item->ri_buf[item_index].i_addr != NULL);
ASSERT((item->ri_buf[item_index].i_len % XFS_BLI_CHUNK) == 0); ASSERT((item->ri_buf[item_index].i_len % XFS_BLF_CHUNK) == 0);
ASSERT((reg_buf_offset + reg_buf_bytes) <= XFS_BUF_COUNT(bp)); ASSERT((reg_buf_offset + reg_buf_bytes) <= XFS_BUF_COUNT(bp));
/* /*
@ -1955,9 +1955,9 @@ xlog_recover_do_reg_buffer(
nbits = xfs_contig_bits(data_map, map_size, bit); nbits = xfs_contig_bits(data_map, map_size, bit);
ASSERT(nbits > 0); ASSERT(nbits > 0);
ASSERT(item->ri_buf[i].i_addr != NULL); ASSERT(item->ri_buf[i].i_addr != NULL);
ASSERT(item->ri_buf[i].i_len % XFS_BLI_CHUNK == 0); ASSERT(item->ri_buf[i].i_len % XFS_BLF_CHUNK == 0);
ASSERT(XFS_BUF_COUNT(bp) >= ASSERT(XFS_BUF_COUNT(bp) >=
((uint)bit << XFS_BLI_SHIFT)+(nbits<<XFS_BLI_SHIFT)); ((uint)bit << XFS_BLF_SHIFT)+(nbits<<XFS_BLF_SHIFT));
/* /*
* Do a sanity check if this is a dquot buffer. Just checking * Do a sanity check if this is a dquot buffer. Just checking
@ -1966,7 +1966,7 @@ xlog_recover_do_reg_buffer(
*/ */
error = 0; error = 0;
if (buf_f->blf_flags & if (buf_f->blf_flags &
(XFS_BLI_UDQUOT_BUF|XFS_BLI_PDQUOT_BUF|XFS_BLI_GDQUOT_BUF)) { (XFS_BLF_UDQUOT_BUF|XFS_BLF_PDQUOT_BUF|XFS_BLF_GDQUOT_BUF)) {
if (item->ri_buf[i].i_addr == NULL) { if (item->ri_buf[i].i_addr == NULL) {
cmn_err(CE_ALERT, cmn_err(CE_ALERT,
"XFS: NULL dquot in %s.", __func__); "XFS: NULL dquot in %s.", __func__);
@ -1987,9 +1987,9 @@ xlog_recover_do_reg_buffer(
} }
memcpy(xfs_buf_offset(bp, memcpy(xfs_buf_offset(bp,
(uint)bit << XFS_BLI_SHIFT), /* dest */ (uint)bit << XFS_BLF_SHIFT), /* dest */
item->ri_buf[i].i_addr, /* source */ item->ri_buf[i].i_addr, /* source */
nbits<<XFS_BLI_SHIFT); /* length */ nbits<<XFS_BLF_SHIFT); /* length */
next: next:
i++; i++;
bit += nbits; bit += nbits;
@ -2148,11 +2148,11 @@ xlog_recover_do_dquot_buffer(
} }
type = 0; type = 0;
if (buf_f->blf_flags & XFS_BLI_UDQUOT_BUF) if (buf_f->blf_flags & XFS_BLF_UDQUOT_BUF)
type |= XFS_DQ_USER; type |= XFS_DQ_USER;
if (buf_f->blf_flags & XFS_BLI_PDQUOT_BUF) if (buf_f->blf_flags & XFS_BLF_PDQUOT_BUF)
type |= XFS_DQ_PROJ; type |= XFS_DQ_PROJ;
if (buf_f->blf_flags & XFS_BLI_GDQUOT_BUF) if (buf_f->blf_flags & XFS_BLF_GDQUOT_BUF)
type |= XFS_DQ_GROUP; type |= XFS_DQ_GROUP;
/* /*
* This type of quotas was turned off, so ignore this buffer * This type of quotas was turned off, so ignore this buffer
@ -2173,7 +2173,7 @@ xlog_recover_do_dquot_buffer(
* here which overlaps that may be stale. * here which overlaps that may be stale.
* *
* When meta-data buffers are freed at run time we log a buffer item * When meta-data buffers are freed at run time we log a buffer item
* with the XFS_BLI_CANCEL bit set to indicate that previous copies * with the XFS_BLF_CANCEL bit set to indicate that previous copies
* of the buffer in the log should not be replayed at recovery time. * of the buffer in the log should not be replayed at recovery time.
* This is so that if the blocks covered by the buffer are reused for * This is so that if the blocks covered by the buffer are reused for
* file data before we crash we don't end up replaying old, freed * file data before we crash we don't end up replaying old, freed
@ -2207,7 +2207,7 @@ xlog_recover_do_buffer_trans(
if (pass == XLOG_RECOVER_PASS1) { if (pass == XLOG_RECOVER_PASS1) {
/* /*
* In this pass we're only looking for buf items * In this pass we're only looking for buf items
* with the XFS_BLI_CANCEL bit set. * with the XFS_BLF_CANCEL bit set.
*/ */
xlog_recover_do_buffer_pass1(log, buf_f); xlog_recover_do_buffer_pass1(log, buf_f);
return 0; return 0;
@ -2244,7 +2244,7 @@ xlog_recover_do_buffer_trans(
mp = log->l_mp; mp = log->l_mp;
buf_flags = XBF_LOCK; buf_flags = XBF_LOCK;
if (!(flags & XFS_BLI_INODE_BUF)) if (!(flags & XFS_BLF_INODE_BUF))
buf_flags |= XBF_MAPPED; buf_flags |= XBF_MAPPED;
bp = xfs_buf_read(mp->m_ddev_targp, blkno, len, buf_flags); bp = xfs_buf_read(mp->m_ddev_targp, blkno, len, buf_flags);
@ -2257,10 +2257,10 @@ xlog_recover_do_buffer_trans(
} }
error = 0; error = 0;
if (flags & XFS_BLI_INODE_BUF) { if (flags & XFS_BLF_INODE_BUF) {
error = xlog_recover_do_inode_buffer(mp, item, bp, buf_f); error = xlog_recover_do_inode_buffer(mp, item, bp, buf_f);
} else if (flags & } else if (flags &
(XFS_BLI_UDQUOT_BUF|XFS_BLI_PDQUOT_BUF|XFS_BLI_GDQUOT_BUF)) { (XFS_BLF_UDQUOT_BUF|XFS_BLF_PDQUOT_BUF|XFS_BLF_GDQUOT_BUF)) {
xlog_recover_do_dquot_buffer(mp, log, item, bp, buf_f); xlog_recover_do_dquot_buffer(mp, log, item, bp, buf_f);
} else { } else {
xlog_recover_do_reg_buffer(mp, item, bp, buf_f); xlog_recover_do_reg_buffer(mp, item, bp, buf_f);

2
fs/xfs/xfs_log_recover.h
View File

@ -28,7 +28,7 @@
#define XLOG_RHASH(tid) \ #define XLOG_RHASH(tid) \
((((__uint32_t)tid)>>XLOG_RHASH_SHIFT) & (XLOG_RHASH_SIZE-1)) ((((__uint32_t)tid)>>XLOG_RHASH_SHIFT) & (XLOG_RHASH_SIZE-1))
#define XLOG_MAX_REGIONS_IN_ITEM (XFS_MAX_BLOCKSIZE / XFS_BLI_CHUNK / 2 + 1) #define XLOG_MAX_REGIONS_IN_ITEM (XFS_MAX_BLOCKSIZE / XFS_BLF_CHUNK / 2 + 1)
/* /*

28
fs/xfs/xfs_trans_buf.c
View File

@ -114,7 +114,7 @@ _xfs_trans_bjoin(
xfs_buf_item_init(bp, tp->t_mountp); xfs_buf_item_init(bp, tp->t_mountp);
bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *); bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *);
ASSERT(!(bip->bli_flags & XFS_BLI_STALE)); ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
ASSERT(!(bip->bli_format.blf_flags & XFS_BLI_CANCEL)); ASSERT(!(bip->bli_format.blf_flags & XFS_BLF_CANCEL));
ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED)); ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
if (reset_recur) if (reset_recur)
bip->bli_recur = 0; bip->bli_recur = 0;
@ -511,7 +511,7 @@ xfs_trans_brelse(xfs_trans_t *tp,
bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *); bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *);
ASSERT(bip->bli_item.li_type == XFS_LI_BUF); ASSERT(bip->bli_item.li_type == XFS_LI_BUF);
ASSERT(!(bip->bli_flags & XFS_BLI_STALE)); ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
ASSERT(!(bip->bli_format.blf_flags & XFS_BLI_CANCEL)); ASSERT(!(bip->bli_format.blf_flags & XFS_BLF_CANCEL));
ASSERT(atomic_read(&bip->bli_refcount) > 0); ASSERT(atomic_read(&bip->bli_refcount) > 0);
/* /*
@ -619,7 +619,7 @@ xfs_trans_bhold(xfs_trans_t *tp,
bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *); bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *);
ASSERT(!(bip->bli_flags & XFS_BLI_STALE)); ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
ASSERT(!(bip->bli_format.blf_flags & XFS_BLI_CANCEL)); ASSERT(!(bip->bli_format.blf_flags & XFS_BLF_CANCEL));
ASSERT(atomic_read(&bip->bli_refcount) > 0); ASSERT(atomic_read(&bip->bli_refcount) > 0);
bip->bli_flags |= XFS_BLI_HOLD; bip->bli_flags |= XFS_BLI_HOLD;
trace_xfs_trans_bhold(bip); trace_xfs_trans_bhold(bip);
@ -641,7 +641,7 @@ xfs_trans_bhold_release(xfs_trans_t *tp,
bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *); bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *);
ASSERT(!(bip->bli_flags & XFS_BLI_STALE)); ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
ASSERT(!(bip->bli_format.blf_flags & XFS_BLI_CANCEL)); ASSERT(!(bip->bli_format.blf_flags & XFS_BLF_CANCEL));
ASSERT(atomic_read(&bip->bli_refcount) > 0); ASSERT(atomic_read(&bip->bli_refcount) > 0);
ASSERT(bip->bli_flags & XFS_BLI_HOLD); ASSERT(bip->bli_flags & XFS_BLI_HOLD);
bip->bli_flags &= ~XFS_BLI_HOLD; bip->bli_flags &= ~XFS_BLI_HOLD;
@ -704,7 +704,7 @@ xfs_trans_log_buf(xfs_trans_t *tp,
bip->bli_flags &= ~XFS_BLI_STALE; bip->bli_flags &= ~XFS_BLI_STALE;
ASSERT(XFS_BUF_ISSTALE(bp)); ASSERT(XFS_BUF_ISSTALE(bp));
XFS_BUF_UNSTALE(bp); XFS_BUF_UNSTALE(bp);
bip->bli_format.blf_flags &= ~XFS_BLI_CANCEL; bip->bli_format.blf_flags &= ~XFS_BLF_CANCEL;
} }
lidp = xfs_trans_find_item(tp, (xfs_log_item_t*)bip); lidp = xfs_trans_find_item(tp, (xfs_log_item_t*)bip);
@ -762,8 +762,8 @@ xfs_trans_binval(
ASSERT(!(XFS_BUF_ISDELAYWRITE(bp))); ASSERT(!(XFS_BUF_ISDELAYWRITE(bp)));
ASSERT(XFS_BUF_ISSTALE(bp)); ASSERT(XFS_BUF_ISSTALE(bp));
ASSERT(!(bip->bli_flags & (XFS_BLI_LOGGED | XFS_BLI_DIRTY))); ASSERT(!(bip->bli_flags & (XFS_BLI_LOGGED | XFS_BLI_DIRTY)));
ASSERT(!(bip->bli_format.blf_flags & XFS_BLI_INODE_BUF)); ASSERT(!(bip->bli_format.blf_flags & XFS_BLF_INODE_BUF));
ASSERT(bip->bli_format.blf_flags & XFS_BLI_CANCEL); ASSERT(bip->bli_format.blf_flags & XFS_BLF_CANCEL);
ASSERT(lidp->lid_flags & XFS_LID_DIRTY); ASSERT(lidp->lid_flags & XFS_LID_DIRTY);
ASSERT(tp->t_flags & XFS_TRANS_DIRTY); ASSERT(tp->t_flags & XFS_TRANS_DIRTY);
return; return;
@ -774,7 +774,7 @@ xfs_trans_binval(
* in the buf log item. The STALE flag will be used in * in the buf log item. The STALE flag will be used in
* xfs_buf_item_unpin() to determine if it should clean up * xfs_buf_item_unpin() to determine if it should clean up
* when the last reference to the buf item is given up. * when the last reference to the buf item is given up.
* We set the XFS_BLI_CANCEL flag in the buf log format structure * We set the XFS_BLF_CANCEL flag in the buf log format structure
* and log the buf item. This will be used at recovery time * and log the buf item. This will be used at recovery time
* to determine that copies of the buffer in the log before * to determine that copies of the buffer in the log before
* this should not be replayed. * this should not be replayed.
@ -793,8 +793,8 @@ xfs_trans_binval(
XFS_BUF_STALE(bp); XFS_BUF_STALE(bp);
bip->bli_flags |= XFS_BLI_STALE; bip->bli_flags |= XFS_BLI_STALE;
bip->bli_flags &= ~(XFS_BLI_LOGGED | XFS_BLI_DIRTY); bip->bli_flags &= ~(XFS_BLI_LOGGED | XFS_BLI_DIRTY);
bip->bli_format.blf_flags &= ~XFS_BLI_INODE_BUF; bip->bli_format.blf_flags &= ~XFS_BLF_INODE_BUF;
bip->bli_format.blf_flags |= XFS_BLI_CANCEL; bip->bli_format.blf_flags |= XFS_BLF_CANCEL;
memset((char *)(bip->bli_format.blf_data_map), 0, memset((char *)(bip->bli_format.blf_data_map), 0,
(bip->bli_format.blf_map_size * sizeof(uint))); (bip->bli_format.blf_map_size * sizeof(uint)));
lidp->lid_flags |= XFS_LID_DIRTY; lidp->lid_flags |= XFS_LID_DIRTY;
@ -826,7 +826,7 @@ xfs_trans_inode_buf(
bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *); bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *);
ASSERT(atomic_read(&bip->bli_refcount) > 0); ASSERT(atomic_read(&bip->bli_refcount) > 0);
bip->bli_format.blf_flags |= XFS_BLI_INODE_BUF; bip->bli_format.blf_flags |= XFS_BLF_INODE_BUF;
} }
/* /*
@ -908,9 +908,9 @@ xfs_trans_dquot_buf(
ASSERT(XFS_BUF_ISBUSY(bp)); ASSERT(XFS_BUF_ISBUSY(bp));
ASSERT(XFS_BUF_FSPRIVATE2(bp, xfs_trans_t *) == tp); ASSERT(XFS_BUF_FSPRIVATE2(bp, xfs_trans_t *) == tp);
ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL); ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL);
ASSERT(type == XFS_BLI_UDQUOT_BUF || ASSERT(type == XFS_BLF_UDQUOT_BUF ||
type == XFS_BLI_PDQUOT_BUF || type == XFS_BLF_PDQUOT_BUF ||
type == XFS_BLI_GDQUOT_BUF); type == XFS_BLF_GDQUOT_BUF);
bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *); bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *);
ASSERT(atomic_read(&bip->bli_refcount) > 0); ASSERT(atomic_read(&bip->bli_refcount) > 0);