xfs: pass mp to XFS_WANT_CORRUPTED_*
cover xfs: pass mp to XFS_WANT_CORRUPTED_*
These 2 patches provide information about which filesystem hit the error...
Thanks,
-Eric
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH 1/2 xfs: pass mp to XFS_WANT_CORRUPTED_GOTO
Today, if we hit an XFS_WANT_CORRUPTED_GOTO we don't print any information about which filesystem hit it. Passing in the mp allows us to print the filesystem (device) name, which is a pretty critical piece of information.
Tested by running fsfuzzer 'til I hit some.
---
fs/xfs/libxfs/xfs_alloc.c +36 -35
@@ -682,7 +682,7 @@ xfs_alloc_ag_vextent_exact( error =xfs_alloc_get_rec (bno_cur, &fbno, &flen, &i);if (error) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (args->mp, i ==1 , error0);ASSERT (fbno <= args->agbno);/*
@@ -783,7 +783,7 @@ xfs_alloc_find_best_extent( error =xfs_alloc_get_rec (*scur, sbno, slen, &i);if (error) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (args->mp, i ==1 , error0);xfs_alloc_compute_aligned (args, *sbno, *slen, sbnoa, slena);/*
@@ -946,7 +946,7 @@ restart:if ((error =xfs_alloc_get_rec (cnt_cur, <bno, <len, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (args->mp, i ==1 , error0);if (ltlen >= args->minlen)break ;if ((error =xfs_btree_increment (cnt_cur,0 , &i)))
@@ -966,7 +966,7 @@ restart:*/ if ((error =xfs_alloc_get_rec (cnt_cur, <bno, <len, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (args->mp, i ==1 , error0);xfs_alloc_compute_aligned (args, ltbno, ltlen, <bnoa, <lena);if (ltlena < args->minlen)
@@ -999,7 +999,7 @@ restart: cnt_cur->bc_ptrs[0 ] = besti;if ((error =xfs_alloc_get_rec (cnt_cur, <bno, <len, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (args->mp, i ==1 , error0);ASSERT (ltbno + ltlen <=be32_to_cpu (XFS_BUF_TO_AGF (args->agbp)->agf_length)); args->len = blen;if (!xfs_alloc_fix_minleft (args)) {
@@ -1088,7 +1088,7 @@ restart:if (bno_cur_lt) {if ((error =xfs_alloc_get_rec (bno_cur_lt, <bno, <len, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (args->mp, i ==1 , error0);xfs_alloc_compute_aligned (args, ltbno, ltlen, <bnoa, <lena);if (ltlena >= args->minlen)
@@ -1104,7 +1104,7 @@ restart:if (bno_cur_gt) {if ((error =xfs_alloc_get_rec (bno_cur_gt, >bno, >len, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (args->mp, i ==1 , error0);xfs_alloc_compute_aligned (args, gtbno, gtlen, >bnoa, >lena);if (gtlena >= args->minlen)
@@ -1303,7 +1303,7 @@ restart: error =xfs_alloc_get_rec (cnt_cur, &fbno, &flen, &i);if (error) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (args->mp, i ==1 , error0);xfs_alloc_compute_aligned (args, fbno, flen, &rbno, &rlen);
@@ -1342,7 +1342,7 @@ restart:* This can't happen in the second case above. */ rlen =XFS_EXTLEN_MIN (args->maxlen, rlen); -XFS_WANT_CORRUPTED_GOTO (rlen ==0 || +XFS_WANT_CORRUPTED_GOTO (args->mp, rlen ==0 || (rlen <= flen && rbno + rlen <= fbno + flen), error0);if (rlen < args->maxlen) {xfs_agblock_t bestfbno;
@@ -1362,13 +1362,13 @@ restart:if ((error =xfs_alloc_get_rec (cnt_cur, &fbno, &flen, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (args->mp, i ==1 , error0);if (flen < bestrlen)break ;xfs_alloc_compute_aligned (args, fbno, flen, &rbno, &rlen); rlen =XFS_EXTLEN_MIN (args->maxlen, rlen); -XFS_WANT_CORRUPTED_GOTO (rlen ==0 || +XFS_WANT_CORRUPTED_GOTO (args->mp, rlen ==0 || (rlen <= flen && rbno + rlen <= fbno + flen), error0);if (rlen > bestrlen) {
@@ -1383,7 +1383,7 @@ restart:if ((error =xfs_alloc_lookup_eq (cnt_cur, bestfbno, bestflen, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (args->mp, i ==1 , error0); rlen = bestrlen; rbno = bestrbno; flen = bestflen;
@@ -1408,7 +1408,7 @@ restart:if (!xfs_alloc_fix_minleft (args)) goto out_nominleft; rlen = args->len; -XFS_WANT_CORRUPTED_GOTO (rlen <= flen, error0); +XFS_WANT_CORRUPTED_GOTO (args->mp, rlen <= flen, error0);/* * Allocate and initialize a cursor for the by-block tree. */
@@ -1422,7 +1422,7 @@ restart: cnt_cur = bno_cur =NULL ; args->len = rlen; args->agbno = rbno; -XFS_WANT_CORRUPTED_GOTO ( +XFS_WANT_CORRUPTED_GOTO (args->mp, args->agbno + args->len <=be32_to_cpu (XFS_BUF_TO_AGF (args->agbp)->agf_length), error0);
@@ -1467,7 +1467,7 @@ xfs_alloc_ag_vextent_small(if (i) {if ((error =xfs_alloc_get_rec (ccur, &fbno, &flen, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (args->mp, i ==1 , error0); }/* * Nothing in the btree, try the freelist. Make sure
@@ -1493,7 +1493,7 @@ xfs_alloc_ag_vextent_small( } args->len =1 ; args->agbno = fbno; -XFS_WANT_CORRUPTED_GOTO ( +XFS_WANT_CORRUPTED_GOTO (args->mp, args->agbno + args->len <=be32_to_cpu (XFS_BUF_TO_AGF (args->agbp)->agf_length), error0);
@@ -1579,7 +1579,7 @@ xfs_free_ag_extent(*/ if ((error =xfs_alloc_get_rec (bno_cur, <bno, <len, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , error0);/* * It's not contiguous, though. */
@@ -1591,7 +1591,8 @@ xfs_free_ag_extent(* space was invalid, it's (partly) already free. * Very bad. */ -XFS_WANT_CORRUPTED_GOTO (ltbno + ltlen <= bno, error0); +XFS_WANT_CORRUPTED_GOTO (mp, + ltbno + ltlen <= bno, error0); } }/*
@@ -1606,7 +1607,7 @@ xfs_free_ag_extent(*/ if ((error =xfs_alloc_get_rec (bno_cur, >bno, >len, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , error0);/* * It's not contiguous, though. */
@@ -1618,7 +1619,7 @@ xfs_free_ag_extent(* space was invalid, it's (partly) already free. * Very bad. */ -XFS_WANT_CORRUPTED_GOTO (gtbno >= bno + len, error0); +XFS_WANT_CORRUPTED_GOTO (mp, gtbno >= bno + len, error0); } }/*
@@ -1635,31 +1636,31 @@ xfs_free_ag_extent(*/ if ((error =xfs_alloc_lookup_eq (cnt_cur, ltbno, ltlen, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , error0);if ((error =xfs_btree_delete (cnt_cur, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , error0);/* * Delete the old by-size entry on the right. */ if ((error =xfs_alloc_lookup_eq (cnt_cur, gtbno, gtlen, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , error0);if ((error =xfs_btree_delete (cnt_cur, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , error0);/* * Delete the old by-block entry for the right block. */ if ((error =xfs_btree_delete (bno_cur, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , error0);/* * Move the by-block cursor back to the left neighbor. */ if ((error =xfs_btree_decrement (bno_cur,0 , &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , error0);#ifdef DEBUG /* * Check that this is the right record: delete didn't
@@ -1672,7 +1673,7 @@ xfs_free_ag_extent(if ((error =xfs_alloc_get_rec (bno_cur, &xxbno, &xxlen, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO ( +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 && xxbno == ltbno && xxlen == ltlen, error0); }
@@ -1695,17 +1696,17 @@ xfs_free_ag_extent(*/ if ((error =xfs_alloc_lookup_eq (cnt_cur, ltbno, ltlen, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , error0);if ((error =xfs_btree_delete (cnt_cur, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , error0);/* * Back up the by-block cursor to the left neighbor, and * update its length. */ if ((error =xfs_btree_decrement (bno_cur,0 , &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , error0); nbno = ltbno; nlen = len + ltlen;if ((error =xfs_alloc_update (bno_cur, nbno, nlen)))
@@ -1721,10 +1722,10 @@ xfs_free_ag_extent(*/ if ((error =xfs_alloc_lookup_eq (cnt_cur, gtbno, gtlen, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , error0);if ((error =xfs_btree_delete (cnt_cur, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , error0);/* * Update the starting block and length of the right * neighbor in the by-block tree.
@@ -1743,7 +1744,7 @@ xfs_free_ag_extent( nlen = len;if ((error =xfs_btree_insert (bno_cur, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , error0); }xfs_btree_del_cursor (bno_cur,XFS_BTREE_NOERROR ); bno_cur =NULL ;
@@ -1752,10 +1753,10 @@ xfs_free_ag_extent(*/ if ((error =xfs_alloc_lookup_eq (cnt_cur, nbno, nlen, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==0 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, i ==0 , error0);if ((error =xfs_btree_insert (cnt_cur, &i))) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , error0);xfs_btree_del_cursor (cnt_cur,XFS_BTREE_NOERROR ); cnt_cur =NULL ;
fs/xfs/libxfs/xfs_bmap.c +64 -57
410 lines not on this page · raw message
fs/xfs/libxfs/xfs_btree.c +9 -9
@@ -2285,7 +2285,7 @@ xfs_btree_rshift(if (error) goto error0; i =xfs_btree_lastrec (tcur, level); -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (cur->bc_mp, i ==1 , error0); error =xfs_btree_increment (tcur, level, &i);if (error)
@@ -3138,7 +3138,7 @@ xfs_btree_insert( goto error0; } -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (cur->bc_mp, i ==1 , error0); level++;/*
@@ -3582,15 +3582,15 @@ xfs_btree_delrec(* Actually any entry but the first would suffice. */ i =xfs_btree_lastrec (tcur, level); -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (cur->bc_mp, i ==1 , error0); error =xfs_btree_increment (tcur, level, &i);if (error) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (cur->bc_mp, i ==1 , error0); i =xfs_btree_lastrec (tcur, level); -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (cur->bc_mp, i ==1 , error0);/* Grab a pointer to the block. */ right =xfs_btree_get_block (tcur, level, &rbp);
@@ -3634,12 +3634,12 @@ xfs_btree_delrec( rrecs =xfs_btree_get_numrecs (right);if (!xfs_btree_ptr_is_null (cur, &lptr)) { i =xfs_btree_firstrec (tcur, level); -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (cur->bc_mp, i ==1 , error0); error =xfs_btree_decrement (tcur, level, &i);if (error) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (cur->bc_mp, i ==1 , error0); } }
@@ -3653,13 +3653,13 @@ xfs_btree_delrec(* previous block. */ i =xfs_btree_firstrec (tcur, level); -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (cur->bc_mp, i ==1 , error0); error =xfs_btree_decrement (tcur, level, &i);if (error) goto error0; i =xfs_btree_firstrec (tcur, level); -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (cur->bc_mp, i ==1 , error0);/* Grab a pointer to the block. */ left =xfs_btree_get_block (tcur, level, &lbp);
fs/xfs/libxfs/xfs_ialloc.c +12 -12
@@ -783,12 +783,12 @@ xfs_dialloc_ag_inobt( error =xfs_inobt_lookup (cur, pagino,XFS_LOOKUP_LE , &i);if (error) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , error0); error =xfs_inobt_get_rec (cur, &rec, &j);if (error) goto error0; -XFS_WANT_CORRUPTED_GOTO (j ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, j ==1 , error0);if (rec.ir_freecount >0 ) {/*
@@ -944,19 +944,19 @@ newino: error =xfs_inobt_lookup (cur,0 ,XFS_LOOKUP_GE , &i);if (error) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , error0);for (;;) { error =xfs_inobt_get_rec (cur, &rec, &i);if (error) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , error0);if (rec.ir_freecount >0 )break ; error =xfs_btree_increment (cur,0 , &i);if (error) goto error0; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , error0); } alloc_inode:
@@ -1039,10 +1039,10 @@ xfs_dialloc_ag_finobt_near( error =xfs_inobt_get_rec (rcur, &rrec, &j);if (error) goto error_rcur; -XFS_WANT_CORRUPTED_GOTO (j ==1 , error_rcur); +XFS_WANT_CORRUPTED_GOTO (lcur->bc_mp, j ==1 , error_rcur); } -XFS_WANT_CORRUPTED_GOTO (i ==1 || j ==1 , error_rcur); +XFS_WANT_CORRUPTED_GOTO (lcur->bc_mp, i ==1 || j ==1 , error_rcur);if (i ==1 && j ==1 ) {/* * Both the left and right records are valid. Choose the closer
@@ -1475,14 +1475,14 @@ xfs_difree_inobt( __func__, error); goto error0; } -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , error0); error =xfs_inobt_get_rec (cur, &rec, &i);if (error) {xfs_warn (mp,"%s: xfs_inobt_get_rec() returned error %d." , __func__, error); goto error0; } -XFS_WANT_CORRUPTED_GOTO (i ==1 , error0); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , error0);/* * Get the offset in the inode chunk. */
@@ -1592,7 +1592,7 @@ xfs_difree_finobt(* freed an inode in a previously fully allocated chunk. If not, * something is out of sync. */ -XFS_WANT_CORRUPTED_GOTO (ibtrec->ir_freecount ==1 , error); +XFS_WANT_CORRUPTED_GOTO (mp, ibtrec->ir_freecount ==1 , error); error =xfs_inobt_insert_rec (cur, ibtrec->ir_freecount, ibtrec->ir_free, &i);
@@ -1613,12 +1613,12 @@ xfs_difree_finobt( error =xfs_inobt_get_rec (cur, &rec, &i);if (error) goto error; -XFS_WANT_CORRUPTED_GOTO (i ==1 , error); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , error); rec.ir_free |=XFS_INOBT_MASK (offset); rec.ir_freecount++; -XFS_WANT_CORRUPTED_GOTO ((rec.ir_free == ibtrec->ir_free) && +XFS_WANT_CORRUPTED_GOTO (mp, (rec.ir_free == ibtrec->ir_free) && (rec.ir_freecount == ibtrec->ir_freecount), error);
fs/xfs/xfs_discard.c +1 -1
@@ -84,7 +84,7 @@ xfs_trim_extents( error =xfs_alloc_get_rec (cur, &fbno, &flen, &i);if (error) goto out_del_cursor; -XFS_WANT_CORRUPTED_GOTO (i ==1 , out_del_cursor); +XFS_WANT_CORRUPTED_GOTO (mp, i ==1 , out_del_cursor);ASSERT (flen <=be32_to_cpu (XFS_BUF_TO_AGF (agbp)->agf_longest));/*
fs/xfs/xfs_error.h +2 -2
@@ -40,13 +40,13 @@ extern void xfs_verifier_error(struct xfs_buf *bp);/* * Macros to set EFSCORRUPTED & return/branch. */ -#define XFS_WANT_CORRUPTED_GOTO (x,l) \ +#define XFS_WANT_CORRUPTED_GOTO (mp, x, l) \ { \ int fs_is_ok = (x); \ ASSERT(fs_is_ok); \ if (unlikely(!fs_is_ok)) { \ XFS_ERROR_REPORT("XFS_WANT_CORRUPTED_GOTO", \ - XFS_ERRLEVEL_LOW, NULL); \ + XFS_ERRLEVEL_LOW, mp); \ error = -EFSCORRUPTED; \ goto l; \ } \
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH 2/2 xfs: pass mp to XFS_WANT_CORRUPTED_RETURN
In reply to Eric SandeenToday, if we hit an XFS_WANT_CORRUPTED_RETURN we don't print any information about which filesystem hit it. Passing in the mp allows us to print the filesystem (device) name, which is a pretty critical piece of information.
Tested by running fsfuzzer 'til I hit some.
---
fs/xfs/libxfs/xfs_alloc.c +16 -13
@@ -315,6 +315,9 @@ xfs_alloc_fixup_trees(xfs_agblock_t nfbno2;/* second new free startblock */ xfs_extlen_t nflen1=0 ;/* first new free length */ xfs_extlen_t nflen2=0 ;/* second new free length */ +struct xfs_mount *mp; + + mp = cnt_cur->bc_mp;/* * Look up the record in the by-size tree if necessary.
@@ -323,13 +326,13 @@ xfs_alloc_fixup_trees(#ifdef DEBUG if ((error =xfs_alloc_get_rec (cnt_cur, &nfbno1, &nflen1, &i)))return error; -XFS_WANT_CORRUPTED_RETURN ( +XFS_WANT_CORRUPTED_RETURN (mp, i ==1 && nfbno1 == fbno && nflen1 == flen);#endif }else {if ((error =xfs_alloc_lookup_eq (cnt_cur, fbno, flen, &i)))return error; -XFS_WANT_CORRUPTED_RETURN (i ==1 ); +XFS_WANT_CORRUPTED_RETURN (mp, i ==1 ); }/* * Look up the record in the by-block tree if necessary.
@@ -338,13 +341,13 @@ xfs_alloc_fixup_trees(#ifdef DEBUG if ((error =xfs_alloc_get_rec (bno_cur, &nfbno1, &nflen1, &i)))return error; -XFS_WANT_CORRUPTED_RETURN ( +XFS_WANT_CORRUPTED_RETURN (mp, i ==1 && nfbno1 == fbno && nflen1 == flen);#endif }else {if ((error =xfs_alloc_lookup_eq (bno_cur, fbno, flen, &i)))return error; -XFS_WANT_CORRUPTED_RETURN (i ==1 ); +XFS_WANT_CORRUPTED_RETURN (mp, i ==1 ); }#ifdef DEBUG
@@ -355,7 +358,7 @@ xfs_alloc_fixup_trees( bnoblock =XFS_BUF_TO_BLOCK (bno_cur->bc_bufs[0 ]); cntblock =XFS_BUF_TO_BLOCK (cnt_cur->bc_bufs[0 ]); -XFS_WANT_CORRUPTED_RETURN ( +XFS_WANT_CORRUPTED_RETURN (mp, bnoblock->bb_numrecs == cntblock->bb_numrecs); }#endif
@@ -386,25 +389,25 @@ xfs_alloc_fixup_trees(*/ if ((error =xfs_btree_delete (cnt_cur, &i)))return error; -XFS_WANT_CORRUPTED_RETURN (i ==1 ); +XFS_WANT_CORRUPTED_RETURN (mp, i ==1 );/* * Add new by-size btree entry(s). */ if (nfbno1 !=NULLAGBLOCK ) {if ((error =xfs_alloc_lookup_eq (cnt_cur, nfbno1, nflen1, &i)))return error; -XFS_WANT_CORRUPTED_RETURN (i ==0 ); +XFS_WANT_CORRUPTED_RETURN (mp, i ==0 );if ((error =xfs_btree_insert (cnt_cur, &i)))return error; -XFS_WANT_CORRUPTED_RETURN (i ==1 ); +XFS_WANT_CORRUPTED_RETURN (mp, i ==1 ); }if (nfbno2 !=NULLAGBLOCK ) {if ((error =xfs_alloc_lookup_eq (cnt_cur, nfbno2, nflen2, &i)))return error; -XFS_WANT_CORRUPTED_RETURN (i ==0 ); +XFS_WANT_CORRUPTED_RETURN (mp, i ==0 );if ((error =xfs_btree_insert (cnt_cur, &i)))return error; -XFS_WANT_CORRUPTED_RETURN (i ==1 ); +XFS_WANT_CORRUPTED_RETURN (mp, i ==1 ); }/* * Fix up the by-block btree entry(s).
@@ -415,7 +418,7 @@ xfs_alloc_fixup_trees(*/ if ((error =xfs_btree_delete (bno_cur, &i)))return error; -XFS_WANT_CORRUPTED_RETURN (i ==1 ); +XFS_WANT_CORRUPTED_RETURN (mp, i ==1 ); }else {/* * Update the by-block entry to start later|be shorter.
@@ -429,10 +432,10 @@ xfs_alloc_fixup_trees(*/ if ((error =xfs_alloc_lookup_eq (bno_cur, nfbno2, nflen2, &i)))return error; -XFS_WANT_CORRUPTED_RETURN (i ==0 ); +XFS_WANT_CORRUPTED_RETURN (mp, i ==0 );if ((error =xfs_btree_insert (bno_cur, &i)))return error; -XFS_WANT_CORRUPTED_RETURN (i ==1 ); +XFS_WANT_CORRUPTED_RETURN (mp, i ==1 ); }return 0 ; }
fs/xfs/libxfs/xfs_bmap.c +8 -5
@@ -5458,6 +5458,7 @@ xfs_bmse_merge(struct xfs_bmbt_irec left;xfs_filblks_t blockcount;int error, i; +struct xfs_mount *mp = ip->i_mount;xfs_bmbt_get_all (gotp, &got);xfs_bmbt_get_all (leftp, &left);
@@ -5492,19 +5493,19 @@ xfs_bmse_merge( got.br_blockcount, &i);if (error)return error; -XFS_WANT_CORRUPTED_RETURN (i ==1 ); +XFS_WANT_CORRUPTED_RETURN (mp, i ==1 ); error =xfs_btree_delete (cur, &i);if (error)return error; -XFS_WANT_CORRUPTED_RETURN (i ==1 ); +XFS_WANT_CORRUPTED_RETURN (mp, i ==1 );/* lookup and update size of the previous extent */ error =xfs_bmbt_lookup_eq (cur, left.br_startoff, left.br_startblock, left.br_blockcount, &i);if (error)return error; -XFS_WANT_CORRUPTED_RETURN (i ==1 ); +XFS_WANT_CORRUPTED_RETURN (mp, i ==1 ); left.br_blockcount = blockcount;
@@ -5526,6 +5527,7 @@ xfs_bmse_shift_one( int *logflags) {struct xfs_ifork *ifp; +struct xfs_mount *mp;xfs_fileoff_t startoff;struct xfs_bmbt_rec_host *leftp;struct xfs_bmbt_irec got;
@@ -5533,13 +5535,14 @@ xfs_bmse_shift_one(int error;int i; + mp = ip->i_mount; ifp =XFS_IFORK_PTR (ip, whichfork);xfs_bmbt_get_all (gotp, &got); startoff = got.br_startoff - offset_shift_fsb;/* delalloc extents should be prevented by caller */ -XFS_WANT_CORRUPTED_RETURN (!isnullstartblock (got.br_startblock)); +XFS_WANT_CORRUPTED_RETURN (mp, !isnullstartblock (got.br_startblock));/* * Check for merge if we've got an extent to the left, otherwise make
@@ -5578,7 +5581,7 @@ xfs_bmse_shift_one( got.br_blockcount, &i);if (error)return error; -XFS_WANT_CORRUPTED_RETURN (i ==1 ); +XFS_WANT_CORRUPTED_RETURN (mp, i ==1 ); got.br_startoff = startoff; return xfs_bmbt_update(cur, got.br_startoff, got.br_startblock,
fs/xfs/libxfs/xfs_btree.c +3 -3
@@ -168,7 +168,7 @@ xfs_btree_check_lptr(xfs_fsblock_t bno,/* btree block disk address */ int level) /* btree block level */ { -XFS_WANT_CORRUPTED_RETURN ( + XFS_WANT_CORRUPTED_RETURN(cur->bc_mp, level > 0 && bno != NULLFSBLOCK && XFS_FSB_SANITY_CHECK(cur->bc_mp, bno));
@@ -187,7 +187,7 @@ xfs_btree_check_sptr( {xfs_agblock_t agblocks = cur->bc_mp->m_sb.sb_agblocks; - XFS_WANT_CORRUPTED_RETURN( + XFS_WANT_CORRUPTED_RETURN(cur->bc_mp, level > 0 && bno != NULLAGBLOCK && bno != 0 &&
@@ -1825,7 +1825,7 @@ xfs_btree_lookup( error =xfs_btree_increment (cur,0 , &i);if (error) goto error0; -XFS_WANT_CORRUPTED_RETURN (i ==1 ); +XFS_WANT_CORRUPTED_RETURN (cur->bc_mp, i ==1 );XFS_BTREE_TRACE_CURSOR (cur,XBT_EXIT ); *stat =1 ;return 0 ;
fs/xfs/libxfs/xfs_dir2_data.c +20 -19
@@ -89,7 +89,7 @@ __xfs_dir3_data_check(* so just ensure that the count falls somewhere inside the * block right now. */ -XFS_WANT_CORRUPTED_RETURN (be32_to_cpu (btp->count) < +XFS_WANT_CORRUPTED_RETURN (mp,be32_to_cpu (btp->count) < ((char *)btp - p) /sizeof (struct xfs_dir2_leaf_entry ));break ;case cpu_to_be32 (XFS_DIR3_DATA_MAGIC ):
@@ -107,21 +107,21 @@ __xfs_dir3_data_check( bf = ops->data_bestfree_p (hdr); count = lastfree = freeseen =0 ;if (!bf[0 ].length) { -XFS_WANT_CORRUPTED_RETURN (!bf[0 ].offset); +XFS_WANT_CORRUPTED_RETURN (mp, !bf[0 ].offset); freeseen |=1 <<0 ; }if (!bf[1 ].length) { -XFS_WANT_CORRUPTED_RETURN (!bf[1 ].offset); +XFS_WANT_CORRUPTED_RETURN (mp, !bf[1 ].offset); freeseen |=1 <<1 ; }if (!bf[2 ].length) { -XFS_WANT_CORRUPTED_RETURN (!bf[2 ].offset); +XFS_WANT_CORRUPTED_RETURN (mp, !bf[2 ].offset); freeseen |=1 <<2 ; } -XFS_WANT_CORRUPTED_RETURN (be16_to_cpu (bf[0 ].length) >= +XFS_WANT_CORRUPTED_RETURN (mp,be16_to_cpu (bf[0 ].length) >=be16_to_cpu (bf[1 ].length)); -XFS_WANT_CORRUPTED_RETURN (be16_to_cpu (bf[1 ].length) >= +XFS_WANT_CORRUPTED_RETURN (mp,be16_to_cpu (bf[1 ].length) >=be16_to_cpu (bf[2 ].length));/* * Loop over the data/unused entries.
@@ -134,18 +134,18 @@ __xfs_dir3_data_check(* doesn't need to be there. */ if (be16_to_cpu (dup->freetag) ==XFS_DIR2_DATA_FREE_TAG ) { -XFS_WANT_CORRUPTED_RETURN (lastfree ==0 ); -XFS_WANT_CORRUPTED_RETURN ( +XFS_WANT_CORRUPTED_RETURN (mp, lastfree ==0 ); +XFS_WANT_CORRUPTED_RETURN (mp,be16_to_cpu (*xfs_dir2_data_unused_tag_p (dup)) == (char *)dup - (char *)hdr); dfp =xfs_dir2_data_freefind (hdr, bf, dup);if (dfp) { i = (int )(dfp - bf); -XFS_WANT_CORRUPTED_RETURN ( +XFS_WANT_CORRUPTED_RETURN (mp, (freeseen & (1 << i)) ==0 ); freeseen |=1 << i; }else { -XFS_WANT_CORRUPTED_RETURN ( +XFS_WANT_CORRUPTED_RETURN (mp,be16_to_cpu (dup->length) <=be16_to_cpu (bf[2 ].length)); }
@@ -160,13 +160,13 @@ __xfs_dir3_data_check(* The linear search is crude but this is DEBUG code. */ dep = (xfs_dir2_data_entry_t *)p; -XFS_WANT_CORRUPTED_RETURN (dep->namelen !=0 ); -XFS_WANT_CORRUPTED_RETURN ( +XFS_WANT_CORRUPTED_RETURN (mp, dep->namelen !=0 ); +XFS_WANT_CORRUPTED_RETURN (mp, !xfs_dir_ino_validate (mp,be64_to_cpu (dep->inumber))); -XFS_WANT_CORRUPTED_RETURN ( +XFS_WANT_CORRUPTED_RETURN (mp,be16_to_cpu (*ops->data_entry_tag_p (dep)) == (char *)dep - (char *)hdr); -XFS_WANT_CORRUPTED_RETURN ( +XFS_WANT_CORRUPTED_RETURN (mp, ops->data_get_ftype (dep) <XFS_DIR3_FT_MAX ); count++; lastfree =0 ;
@@ -183,14 +183,15 @@ __xfs_dir3_data_check( be32_to_cpu(lep[i].hashval) == hash)break ; } -XFS_WANT_CORRUPTED_RETURN (i <be32_to_cpu (btp->count)); +XFS_WANT_CORRUPTED_RETURN (mp, + i <be32_to_cpu (btp->count)); } p += ops->data_entsize (dep->namelen); }/* * Need to have seen all the entries and all the bestfree slots. */ -XFS_WANT_CORRUPTED_RETURN (freeseen ==7 ); +XFS_WANT_CORRUPTED_RETURN (mp, freeseen ==7 );if (hdr->magic ==cpu_to_be32 (XFS_DIR2_BLOCK_MAGIC ) || hdr->magic ==cpu_to_be32 (XFS_DIR3_BLOCK_MAGIC )) {for (i = stale =0 ; i <be32_to_cpu (btp->count); i++) {
@@ -198,13 +199,13 @@ __xfs_dir3_data_check( cpu_to_be32(XFS_DIR2_NULL_DATAPTR)) stale++;if (i >0 ) -XFS_WANT_CORRUPTED_RETURN ( +XFS_WANT_CORRUPTED_RETURN (mp,be32_to_cpu (lep[i].hashval) >=be32_to_cpu (lep[i -1 ].hashval)); } -XFS_WANT_CORRUPTED_RETURN (count == +XFS_WANT_CORRUPTED_RETURN (mp, count ==be32_to_cpu (btp->count) -be32_to_cpu (btp->stale)); -XFS_WANT_CORRUPTED_RETURN (stale ==be32_to_cpu (btp->stale)); +XFS_WANT_CORRUPTED_RETURN (mp, stale ==be32_to_cpu (btp->stale)); }return 0 ; }
fs/xfs/libxfs/xfs_ialloc.c +9 -9
@@ -700,7 +700,7 @@ xfs_ialloc_next_rec( error =xfs_inobt_get_rec (cur, rec, &i);if (error)return error; -XFS_WANT_CORRUPTED_RETURN (i ==1 ); +XFS_WANT_CORRUPTED_RETURN (cur->bc_mp, i ==1 ); }return 0 ;
@@ -724,7 +724,7 @@ xfs_ialloc_get_rec( error =xfs_inobt_get_rec (cur, rec, &i);if (error)return error; -XFS_WANT_CORRUPTED_RETURN (i ==1 ); +XFS_WANT_CORRUPTED_RETURN (cur->bc_mp, i ==1 ); }return 0 ;
@@ -1016,7 +1016,7 @@ xfs_dialloc_ag_finobt_near( error =xfs_inobt_get_rec (lcur, rec, &i);if (error)return error; -XFS_WANT_CORRUPTED_RETURN (i ==1 ); +XFS_WANT_CORRUPTED_RETURN (lcur->bc_mp, i ==1 );/* * See if we've landed in the parent inode record. The finobt
@@ -1095,7 +1095,7 @@ xfs_dialloc_ag_finobt_newino( error =xfs_inobt_get_rec (cur, rec, &i);if (error)return error; -XFS_WANT_CORRUPTED_RETURN (i ==1 ); +XFS_WANT_CORRUPTED_RETURN (cur->bc_mp, i ==1 );return 0 ; } }
@@ -1106,12 +1106,12 @@ xfs_dialloc_ag_finobt_newino( error =xfs_inobt_lookup (cur,0 ,XFS_LOOKUP_GE , &i);if (error)return error; -XFS_WANT_CORRUPTED_RETURN (i ==1 ); +XFS_WANT_CORRUPTED_RETURN (cur->bc_mp, i ==1 ); error =xfs_inobt_get_rec (cur, rec, &i);if (error)return error; -XFS_WANT_CORRUPTED_RETURN (i ==1 ); +XFS_WANT_CORRUPTED_RETURN (cur->bc_mp, i ==1 );return 0 ; }
@@ -1133,19 +1133,19 @@ xfs_dialloc_ag_update_inobt( error =xfs_inobt_lookup (cur, frec->ir_startino,XFS_LOOKUP_EQ , &i);if (error)return error; -XFS_WANT_CORRUPTED_RETURN (i ==1 ); +XFS_WANT_CORRUPTED_RETURN (cur->bc_mp, i ==1 ); error =xfs_inobt_get_rec (cur, &rec, &i);if (error)return error; -XFS_WANT_CORRUPTED_RETURN (i ==1 ); +XFS_WANT_CORRUPTED_RETURN (cur->bc_mp, i ==1 );ASSERT ((XFS_AGINO_TO_OFFSET (cur->bc_mp, rec.ir_startino) %XFS_INODES_PER_CHUNK ) ==0 ); rec.ir_free &= ~XFS_INOBT_MASK (offset); rec.ir_freecount--; -XFS_WANT_CORRUPTED_RETURN ((rec.ir_free == frec->ir_free) && +XFS_WANT_CORRUPTED_RETURN (cur->bc_mp, (rec.ir_free == frec->ir_free) && (rec.ir_freecount == frec->ir_freecount));return xfs_inobt_update (cur, &rec);
fs/xfs/xfs_error.h +2 -2
@@ -52,13 +52,13 @@ extern void xfs_verifier_error(struct xfs_buf *bp); } \ } -#define XFS_WANT_CORRUPTED_RETURN (x) \ +#define XFS_WANT_CORRUPTED_RETURN (mp, x) \ { \ int fs_is_ok = (x); \ ASSERT(fs_is_ok); \ if (unlikely(!fs_is_ok)) { \ XFS_ERROR_REPORT("XFS_WANT_CORRUPTED_RETURN", \ - XFS_ERRLEVEL_LOW, NULL); \ + XFS_ERRLEVEL_LOW, mp); \ return -EFSCORRUPTED; \ } \ }
fs/xfs/xfs_itable.c +1 -1
@@ -229,7 +229,7 @@ xfs_bulkstat_grab_ichunk( error =xfs_inobt_get_rec (cur, irec, &stat);if (error)return error; -XFS_WANT_CORRUPTED_RETURN (stat ==1 ); +XFS_WANT_CORRUPTED_RETURN (cur->bc_mp, stat ==1 );/* Check if the record contains the inode in request */ if (irec->ir_startino +XFS_INODES_PER_CHUNK <= agino) {
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Quoted 2 lines · Eric Sandeen
These 2 patches provide information about which filesystem hit the error...
If we are going to touch every one of these macros, then can we rename them to something a little shorter like XFS_CORRUPT_GOTO() and XFS_CORRUPT_RETURN() at the same time? That will make the code a little less eye-bleedy where there are lots of these statements, and make formatting of complex checks a bit easier, too...
Cheers,
Dave.
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Quoted 10 lines · Dave Chinner
Quoted 2 lines · Eric Sandeen
These 2 patches provide information about which filesystem hit the error...
If we are going to touch every one of these macros, then can we rename them to something a little shorter like
XFS_CORRUPT_GOTO()andXFS_CORRUPT_RETURN()at the same time? That will make the code a little less eye-bleedy where there are lots of these statements, and make formatting of complex checks a bit easier, too...
XFS_CORRUPT_DOSOMETHING() jumps out to me as indicate corruption if the logic statement evaluates as true rather than false. The latter (e.g., assert-like logic) is how they work today, so that could be a bit confusing to somebody who isn't already familiar with how these macros work.
Unfortunately, nothing shorter than the current naming immediately comes to mind... :/ We could kill the XFS_ prefix I suppose or even invert the logic of the calls, but that's certainly a more significant change. Thoughts?
Brian
Quoted 11 lines
Cheers,
Dave.
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Quoted 18 lines · Brian Foster
Quoted 10 lines · Dave Chinner
Quoted 2 lines · Eric Sandeen
These 2 patches provide information about which filesystem hit the error...
If we are going to touch every one of these macros, then can we rename them to something a little shorter like
XFS_CORRUPT_GOTO()andXFS_CORRUPT_RETURN()at the same time? That will make the code a little less eye-bleedy where there are lots of these statements, and make formatting of complex checks a bit easier, too...
XFS_CORRUPT_DOSOMETHING()jumps out to me as indicate corruption if the logic statement evaluates as true rather than false. The latter (e.g., assert-like logic) is how they work today, so that could be a bit confusing to somebody who isn't already familiar with how these macros work.
Quoted 4 lines
Unfortunately, nothing shorter than the current naming immediately comes to mind... :/ We could kill the
XFS_prefix I suppose or even invert the logic of the calls, but that's certainly a more significant change. Thoughts?
Right, so today it's XFS_WANT_CORRUPTED_RETURN(thing_that_should_be_true) and I agree, that's always felt a bit odd.
Dave suggests XFS_CORRUPT_RETURN(thing_that_should_be_true)
I guess the "WANT" was supposed to imply that the argument is the test that we "want" to be true? :)
I'm not super excited about inverting every test, but we could ...
XFS_CORRUPT_RETURN_IF_NOT(test) would be explicit, at least. Or XFS_CORRUPT_RETURN_UNLESS(test).
I can't think of a nice short name that conveys more meaning, either, but I'm not really sure that it's critical to change it at this point.
-Eric
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Quoted 12 lines · Brian Foster
Quoted 10 lines · Dave Chinner
Quoted 2 lines · Eric Sandeen
These 2 patches provide information about which filesystem hit the error...
If we are going to touch every one of these macros, then can we rename them to something a little shorter like
XFS_CORRUPT_GOTO()andXFS_CORRUPT_RETURN()at the same time? That will make the code a little less eye-bleedy where there are lots of these statements, and make formatting of complex checks a bit easier, too...
Quoted 5 lines
XFS_CORRUPT_DOSOMETHING()jumps out to me as indicate corruption if the logic statement evaluates as true rather than false. The latter (e.g., assert-like logic) is how they work today, so that could be a bit confusing to somebody who isn't already familiar with how these macros work.
Someone not familiar with XFS conventions is already going to get caught by "should be true" logic of these statements anyway as the logic is the opposite of BUG_ON() and WARN_ON(). i.e. BUG_ON(1) will kill the kernel, while ASSERT(1) indicates everything is fine.
I suggested shortening the macro because it makes the code that uses it extensively shouty and hard to read because it splits logic statements across lines regularly (e.g __xfs_dir3_data_check). I want to use this more extensively in verifiers to give better corruption detection reporting, but the current macro will make the verifier code rather ugly. Hence my suggestion to make it shorter, neater and a little less shouty...
Quoted 4 lines
Unfortunately, nothing shorter than the current naming immediately comes to mind... :/ We could kill the
XFS_prefix I suppose or even invert the logic of the calls, but that's certainly a more significant change. Thoughts?
No logic changes, please.
Cheers,
Dave.
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Quoted 19 lines · Dave Chinner
Quoted 12 lines · Brian Foster
Quoted 10 lines · Dave Chinner
Quoted 2 lines · Eric Sandeen
These 2 patches provide information about which filesystem hit the error...
If we are going to touch every one of these macros, then can we rename them to something a little shorter like
XFS_CORRUPT_GOTO()andXFS_CORRUPT_RETURN()at the same time? That will make the code a little less eye-bleedy where there are lots of these statements, and make formatting of complex checks a bit easier, too...Quoted 5 lines
XFS_CORRUPT_DOSOMETHING()jumps out to me as indicate corruption if the logic statement evaluates as true rather than false. The latter (e.g., assert-like logic) is how they work today, so that could be a bit confusing to somebody who isn't already familiar with how these macros work.
Quoted 5 lines
Someone not familiar with XFS conventions is already going to get caught by "should be true" logic of these statements anyway as the logic is the opposite of
BUG_ON()andWARN_ON(). i.e.BUG_ON(1)will kill the kernel, while ASSERT(1) indicates everything is fine.
BUG_ON() and ASSERT() are self-explanatory, the latter being a pretty standard/common thing ('man assert'). As Eric mentioned, the WANT bit of the macro is what suggests assert-like semantics.
Quoted 8 lines
I suggested shortening the macro because it makes the code that uses it extensively shouty and hard to read because it splits logic statements across lines regularly (e.g
__xfs_dir3_data_check). I want to use this more extensively in verifiers to give better corruption detection reporting, but the current macro will make the verifier code rather ugly. Hence my suggestion to make it shorter, neater and a little less shouty...
Sure, but ASSERT_CORRUPT_RET() is the same length as the example above. ASSERT_CORRUPT_GOTO() is only a few chars longer than the associated example. We could still use WANT over ASSERT I suppose to shorten it up further. Either of those are at least still self-explanatory in my opinion.
Brian
Quoted 5 lines
Quoted 4 lines
Unfortunately, nothing shorter than the current naming immediately comes to mind... :/ We could kill the
XFS_prefix I suppose or even invert the logic of the calls, but that's certainly a more significant change. Thoughts?
Quoted 8 lines
No logic changes, please.
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Quoted 39 lines · Brian Foster
Quoted 19 lines · Dave Chinner
Quoted 12 lines · Brian Foster
Quoted 10 lines · Dave Chinner
Quoted 2 lines · Eric Sandeen
These 2 patches provide information about which filesystem hit the error...
If we are going to touch every one of these macros, then can we rename them to something a little shorter like
XFS_CORRUPT_GOTO()andXFS_CORRUPT_RETURN()at the same time? That will make the code a little less eye-bleedy where there are lots of these statements, and make formatting of complex checks a bit easier, too...Quoted 5 lines
XFS_CORRUPT_DOSOMETHING()jumps out to me as indicate corruption if the logic statement evaluates as true rather than false. The latter (e.g., assert-like logic) is how they work today, so that could be a bit confusing to somebody who isn't already familiar with how these macros work.Quoted 5 lines
Someone not familiar with XFS conventions is already going to get caught by "should be true" logic of these statements anyway as the logic is the opposite of
BUG_ON()andWARN_ON(). i.e.BUG_ON(1)will kill the kernel, while ASSERT(1) indicates everything is fine.
BUG_ON()andASSERT()are self-explanatory, the latter being a pretty standard/common thing ('man assert'). As Eric mentioned, the WANT bit of the macro is what suggests assert-like semantics.Quoted 8 lines
I suggested shortening the macro because it makes the code that uses it extensively shouty and hard to read because it splits logic statements across lines regularly (e.g
__xfs_dir3_data_check). I want to use this more extensively in verifiers to give better corruption detection reporting, but the current macro will make the verifier code rather ugly. Hence my suggestion to make it shorter, neater and a little less shouty...
Quoted 5 lines
Sure, but
ASSERT_CORRUPT_RET()is the same length as the example above.ASSERT_CORRUPT_GOTO()is only a few chars longer than the associated example. We could still use WANT over ASSERT I suppose to shorten it up further. Either of those are at least still self-explanatory in my opinion.
Thinking on it a bit further, the XFS_WANT_CORRUPTED macros have an internal ASSERT in them, so they are effectively an ASSERT statement. I could live with those names, especially as ASSERT is something that can be compiled into production kernels via CONFIG_XFS_WARN=y to turn them into error messages...
Cheers,
Dave.
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Quoted 2 lines · Dave Chinner
Quoted 1 line · Brian Foster
On Tue, Feb 10, 2015 at 08:17:44AM +1100, Dave Chinner wrote:
...
Quoted 11 lines
Quoted 5 lines
Sure, but
ASSERT_CORRUPT_RET()is the same length as the example above.ASSERT_CORRUPT_GOTO()is only a few chars longer than the associated example. We could still use WANT over ASSERT I suppose to shorten it up further. Either of those are at least still self-explanatory in my opinion.Thinking on it a bit further, the
XFS_WANT_CORRUPTEDmacros have an internal ASSERT in them, so they are effectively an ASSERT statement. I could live with those names, especially as ASSERT is something that can be compiled into production kernels viaCONFIG_XFS_WARN=yto turn them into error messages...
Sooooo you all want "ASSERT_CORRUPTED_RET / ASSERT_CORRUPTED_GOTO" ?
In a light mauve? ;)
-Eric
Quoted 4 lines
Cheers,
Dave.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Quoted 18 lines · Eric Sandeen
Quoted 2 lines · Dave Chinner
Quoted 1 line · Brian Foster
On Tue, Feb 10, 2015 at 08:17:44AM +1100, Dave Chinner wrote:
...
Quoted 11 lines
Quoted 5 lines
Sure, but
ASSERT_CORRUPT_RET()is the same length as the example above.ASSERT_CORRUPT_GOTO()is only a few chars longer than the associated example. We could still use WANT over ASSERT I suppose to shorten it up further. Either of those are at least still self-explanatory in my opinion.Thinking on it a bit further, the
XFS_WANT_CORRUPTEDmacros have an internal ASSERT in them, so they are effectively an ASSERT statement. I could live with those names, especially as ASSERT is something that can be compiled into production kernels viaCONFIG_XFS_WARN=yto turn them into error messages...
Quoted 4 lines
Sooooo you all want "
ASSERT_CORRUPTED_RET/ASSERT_CORRUPTED_GOTO" ?In a light mauve? ;)
I could live with that, better a relative big macro's name than a shorter abbreviated one that you should buy a crystal ball to really understand what it means :)
Quoted 11 lines
-Eric
Quoted 4 lines
Cheers,
Dave.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Signature · 6 lines
Carlos _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs