xfs: pass mp to XFS_WANT_CORRUPTED_GOTO

+36 -35

fs/xfs/libxfs/xfs_alloc.c

··· 682 682 error = xfs_alloc_get_rec(bno_cur, &fbno, &flen, &i); 683 683 if (error) 684 684 goto error0; 685 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 685 + XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0); 686 686 ASSERT(fbno <= args->agbno); 687 687 688 688 /* ··· 783 783 error = xfs_alloc_get_rec(*scur, sbno, slen, &i); 784 784 if (error) 785 785 goto error0; 786 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 786 + XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0); 787 787 xfs_alloc_compute_aligned(args, *sbno, *slen, sbnoa, slena); 788 788 789 789 /* ··· 946 946 if ((error = xfs_alloc_get_rec(cnt_cur, &ltbno, 947 947 &ltlen, &i))) 948 948 goto error0; 949 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 949 + XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0); 950 950 if (ltlen >= args->minlen) 951 951 break; 952 952 if ((error = xfs_btree_increment(cnt_cur, 0, &i))) ··· 966 966 */ 967 967 if ((error = xfs_alloc_get_rec(cnt_cur, &ltbno, &ltlen, &i))) 968 968 goto error0; 969 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 969 + XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0); 970 970 xfs_alloc_compute_aligned(args, ltbno, ltlen, 971 971 &ltbnoa, &ltlena); 972 972 if (ltlena < args->minlen) ··· 999 999 cnt_cur->bc_ptrs[0] = besti; 1000 1000 if ((error = xfs_alloc_get_rec(cnt_cur, &ltbno, &ltlen, &i))) 1001 1001 goto error0; 1002 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1002 + XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0); 1003 1003 ASSERT(ltbno + ltlen <= be32_to_cpu(XFS_BUF_TO_AGF(args->agbp)->agf_length)); 1004 1004 args->len = blen; 1005 1005 if (!xfs_alloc_fix_minleft(args)) { ··· 1088 1088 if (bno_cur_lt) { 1089 1089 if ((error = xfs_alloc_get_rec(bno_cur_lt, &ltbno, &ltlen, &i))) 1090 1090 goto error0; 1091 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1091 + XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0); 1092 1092 xfs_alloc_compute_aligned(args, ltbno, ltlen, 1093 1093 &ltbnoa, &ltlena); 1094 1094 if (ltlena >= args->minlen) ··· 1104 1104 if (bno_cur_gt) { 1105 1105 if ((error = xfs_alloc_get_rec(bno_cur_gt, &gtbno, &gtlen, &i))) 1106 1106 goto error0; 1107 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1107 + XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0); 1108 1108 xfs_alloc_compute_aligned(args, gtbno, gtlen, 1109 1109 &gtbnoa, &gtlena); 1110 1110 if (gtlena >= args->minlen) ··· 1303 1303 error = xfs_alloc_get_rec(cnt_cur, &fbno, &flen, &i); 1304 1304 if (error) 1305 1305 goto error0; 1306 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1306 + XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0); 1307 1307 1308 1308 xfs_alloc_compute_aligned(args, fbno, flen, 1309 1309 &rbno, &rlen); ··· 1342 1342 * This can't happen in the second case above. 1343 1343 */ 1344 1344 rlen = XFS_EXTLEN_MIN(args->maxlen, rlen); 1345 - XFS_WANT_CORRUPTED_GOTO(rlen == 0 || 1345 + XFS_WANT_CORRUPTED_GOTO(args->mp, rlen == 0 || 1346 1346 (rlen <= flen && rbno + rlen <= fbno + flen), error0); 1347 1347 if (rlen < args->maxlen) { 1348 1348 xfs_agblock_t bestfbno; ··· 1362 1362 if ((error = xfs_alloc_get_rec(cnt_cur, &fbno, &flen, 1363 1363 &i))) 1364 1364 goto error0; 1365 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1365 + XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0); 1366 1366 if (flen < bestrlen) 1367 1367 break; 1368 1368 xfs_alloc_compute_aligned(args, fbno, flen, 1369 1369 &rbno, &rlen); 1370 1370 rlen = XFS_EXTLEN_MIN(args->maxlen, rlen); 1371 - XFS_WANT_CORRUPTED_GOTO(rlen == 0 || 1371 + XFS_WANT_CORRUPTED_GOTO(args->mp, rlen == 0 || 1372 1372 (rlen <= flen && rbno + rlen <= fbno + flen), 1373 1373 error0); 1374 1374 if (rlen > bestrlen) { ··· 1383 1383 if ((error = xfs_alloc_lookup_eq(cnt_cur, bestfbno, bestflen, 1384 1384 &i))) 1385 1385 goto error0; 1386 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1386 + XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0); 1387 1387 rlen = bestrlen; 1388 1388 rbno = bestrbno; 1389 1389 flen = bestflen; ··· 1408 1408 if (!xfs_alloc_fix_minleft(args)) 1409 1409 goto out_nominleft; 1410 1410 rlen = args->len; 1411 - XFS_WANT_CORRUPTED_GOTO(rlen <= flen, error0); 1411 + XFS_WANT_CORRUPTED_GOTO(args->mp, rlen <= flen, error0); 1412 1412 /* 1413 1413 * Allocate and initialize a cursor for the by-block tree. 1414 1414 */ ··· 1422 1422 cnt_cur = bno_cur = NULL; 1423 1423 args->len = rlen; 1424 1424 args->agbno = rbno; 1425 - XFS_WANT_CORRUPTED_GOTO( 1425 + XFS_WANT_CORRUPTED_GOTO(args->mp, 1426 1426 args->agbno + args->len <= 1427 1427 be32_to_cpu(XFS_BUF_TO_AGF(args->agbp)->agf_length), 1428 1428 error0); ··· 1467 1467 if (i) { 1468 1468 if ((error = xfs_alloc_get_rec(ccur, &fbno, &flen, &i))) 1469 1469 goto error0; 1470 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1470 + XFS_WANT_CORRUPTED_GOTO(args->mp, i == 1, error0); 1471 1471 } 1472 1472 /* 1473 1473 * Nothing in the btree, try the freelist. Make sure ··· 1493 1493 } 1494 1494 args->len = 1; 1495 1495 args->agbno = fbno; 1496 - XFS_WANT_CORRUPTED_GOTO( 1496 + XFS_WANT_CORRUPTED_GOTO(args->mp, 1497 1497 args->agbno + args->len <= 1498 1498 be32_to_cpu(XFS_BUF_TO_AGF(args->agbp)->agf_length), 1499 1499 error0); ··· 1579 1579 */ 1580 1580 if ((error = xfs_alloc_get_rec(bno_cur, &ltbno, &ltlen, &i))) 1581 1581 goto error0; 1582 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1582 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1583 1583 /* 1584 1584 * It's not contiguous, though. 1585 1585 */ ··· 1591 1591 * space was invalid, it's (partly) already free. 1592 1592 * Very bad. 1593 1593 */ 1594 - XFS_WANT_CORRUPTED_GOTO(ltbno + ltlen <= bno, error0); 1594 + XFS_WANT_CORRUPTED_GOTO(mp, 1595 + ltbno + ltlen <= bno, error0); 1595 1596 } 1596 1597 } 1597 1598 /* ··· 1607 1606 */ 1608 1607 if ((error = xfs_alloc_get_rec(bno_cur, &gtbno, &gtlen, &i))) 1609 1608 goto error0; 1610 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1609 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1611 1610 /* 1612 1611 * It's not contiguous, though. 1613 1612 */ ··· 1619 1618 * space was invalid, it's (partly) already free. 1620 1619 * Very bad. 1621 1620 */ 1622 - XFS_WANT_CORRUPTED_GOTO(gtbno >= bno + len, error0); 1621 + XFS_WANT_CORRUPTED_GOTO(mp, gtbno >= bno + len, error0); 1623 1622 } 1624 1623 } 1625 1624 /* ··· 1636 1635 */ 1637 1636 if ((error = xfs_alloc_lookup_eq(cnt_cur, ltbno, ltlen, &i))) 1638 1637 goto error0; 1639 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1638 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1640 1639 if ((error = xfs_btree_delete(cnt_cur, &i))) 1641 1640 goto error0; 1642 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1641 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1643 1642 /* 1644 1643 * Delete the old by-size entry on the right. 1645 1644 */ 1646 1645 if ((error = xfs_alloc_lookup_eq(cnt_cur, gtbno, gtlen, &i))) 1647 1646 goto error0; 1648 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1647 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1649 1648 if ((error = xfs_btree_delete(cnt_cur, &i))) 1650 1649 goto error0; 1651 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1650 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1652 1651 /* 1653 1652 * Delete the old by-block entry for the right block. 1654 1653 */ 1655 1654 if ((error = xfs_btree_delete(bno_cur, &i))) 1656 1655 goto error0; 1657 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1656 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1658 1657 /* 1659 1658 * Move the by-block cursor back to the left neighbor. 1660 1659 */ 1661 1660 if ((error = xfs_btree_decrement(bno_cur, 0, &i))) 1662 1661 goto error0; 1663 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1662 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1664 1663 #ifdef DEBUG 1665 1664 /* 1666 1665 * Check that this is the right record: delete didn't ··· 1673 1672 if ((error = xfs_alloc_get_rec(bno_cur, &xxbno, &xxlen, 1674 1673 &i))) 1675 1674 goto error0; 1676 - XFS_WANT_CORRUPTED_GOTO( 1675 + XFS_WANT_CORRUPTED_GOTO(mp, 1677 1676 i == 1 && xxbno == ltbno && xxlen == ltlen, 1678 1677 error0); 1679 1678 } ··· 1696 1695 */ 1697 1696 if ((error = xfs_alloc_lookup_eq(cnt_cur, ltbno, ltlen, &i))) 1698 1697 goto error0; 1699 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1698 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1700 1699 if ((error = xfs_btree_delete(cnt_cur, &i))) 1701 1700 goto error0; 1702 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1701 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1703 1702 /* 1704 1703 * Back up the by-block cursor to the left neighbor, and 1705 1704 * update its length. 1706 1705 */ 1707 1706 if ((error = xfs_btree_decrement(bno_cur, 0, &i))) 1708 1707 goto error0; 1709 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1708 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1710 1709 nbno = ltbno; 1711 1710 nlen = len + ltlen; 1712 1711 if ((error = xfs_alloc_update(bno_cur, nbno, nlen))) ··· 1722 1721 */ 1723 1722 if ((error = xfs_alloc_lookup_eq(cnt_cur, gtbno, gtlen, &i))) 1724 1723 goto error0; 1725 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1724 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1726 1725 if ((error = xfs_btree_delete(cnt_cur, &i))) 1727 1726 goto error0; 1728 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1727 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1729 1728 /* 1730 1729 * Update the starting block and length of the right 1731 1730 * neighbor in the by-block tree. ··· 1744 1743 nlen = len; 1745 1744 if ((error = xfs_btree_insert(bno_cur, &i))) 1746 1745 goto error0; 1747 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1746 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1748 1747 } 1749 1748 xfs_btree_del_cursor(bno_cur, XFS_BTREE_NOERROR); 1750 1749 bno_cur = NULL; ··· 1753 1752 */ 1754 1753 if ((error = xfs_alloc_lookup_eq(cnt_cur, nbno, nlen, &i))) 1755 1754 goto error0; 1756 - XFS_WANT_CORRUPTED_GOTO(i == 0, error0); 1755 + XFS_WANT_CORRUPTED_GOTO(mp, i == 0, error0); 1757 1756 if ((error = xfs_btree_insert(cnt_cur, &i))) 1758 1757 goto error0; 1759 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1758 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1760 1759 xfs_btree_del_cursor(cnt_cur, XFS_BTREE_NOERROR); 1761 1760 cnt_cur = NULL; 1762 1761

+64 -57

fs/xfs/libxfs/xfs_bmap.c

··· 410 410 goto error_norelse; 411 411 } 412 412 block = XFS_BUF_TO_BLOCK(bp); 413 - XFS_WANT_CORRUPTED_GOTO( 413 + XFS_WANT_CORRUPTED_GOTO(mp, 414 414 xfs_bmap_sanity_check(mp, bp, level), 415 415 error0); 416 416 if (level == 0) ··· 424 424 xfs_check_block(block, mp, 0, 0); 425 425 pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]); 426 426 bno = be64_to_cpu(*pp); 427 - XFS_WANT_CORRUPTED_GOTO(XFS_FSB_SANITY_CHECK(mp, bno), error0); 427 + XFS_WANT_CORRUPTED_GOTO(mp, 428 + XFS_FSB_SANITY_CHECK(mp, bno), error0); 428 429 if (bp_release) { 429 430 bp_release = 0; 430 431 xfs_trans_brelse(NULL, bp); ··· 1030 1029 if ((error = xfs_bmbt_lookup_ge(cur, 0, 0, 0, &stat))) 1031 1030 goto error0; 1032 1031 /* must be at least one entry */ 1033 - XFS_WANT_CORRUPTED_GOTO(stat == 1, error0); 1032 + XFS_WANT_CORRUPTED_GOTO(mp, stat == 1, error0); 1034 1033 if ((error = xfs_btree_new_iroot(cur, flags, &stat))) 1035 1034 goto error0; 1036 1035 if (stat == 0) { ··· 1312 1311 if (error) 1313 1312 return error; 1314 1313 block = XFS_BUF_TO_BLOCK(bp); 1315 - XFS_WANT_CORRUPTED_GOTO( 1316 - xfs_bmap_sanity_check(mp, bp, level), 1317 - error0); 1314 + XFS_WANT_CORRUPTED_GOTO(mp, 1315 + xfs_bmap_sanity_check(mp, bp, level), error0); 1318 1316 if (level == 0) 1319 1317 break; 1320 1318 pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]); 1321 1319 bno = be64_to_cpu(*pp); 1322 - XFS_WANT_CORRUPTED_GOTO(XFS_FSB_SANITY_CHECK(mp, bno), error0); 1320 + XFS_WANT_CORRUPTED_GOTO(mp, 1321 + XFS_FSB_SANITY_CHECK(mp, bno), error0); 1323 1322 xfs_trans_brelse(tp, bp); 1324 1323 } 1325 1324 /* ··· 1346 1345 XFS_ERRLEVEL_LOW, ip->i_mount, block); 1347 1346 goto error0; 1348 1347 } 1349 - XFS_WANT_CORRUPTED_GOTO( 1348 + XFS_WANT_CORRUPTED_GOTO(mp, 1350 1349 xfs_bmap_sanity_check(mp, bp, 0), 1351 1350 error0); 1352 1351 /* ··· 1756 1755 xfs_filblks_t temp=0; /* value for da_new calculations */ 1757 1756 xfs_filblks_t temp2=0;/* value for da_new calculations */ 1758 1757 int tmp_rval; /* partial logging flags */ 1758 + struct xfs_mount *mp; 1759 1759 1760 + mp = bma->tp ? bma->tp->t_mountp : NULL; 1760 1761 ifp = XFS_IFORK_PTR(bma->ip, XFS_DATA_FORK); 1761 1762 1762 1763 ASSERT(bma->idx >= 0); ··· 1869 1866 RIGHT.br_blockcount, &i); 1870 1867 if (error) 1871 1868 goto done; 1872 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 1869 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 1873 1870 error = xfs_btree_delete(bma->cur, &i); 1874 1871 if (error) 1875 1872 goto done; 1876 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 1873 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 1877 1874 error = xfs_btree_decrement(bma->cur, 0, &i); 1878 1875 if (error) 1879 1876 goto done; 1880 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 1877 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 1881 1878 error = xfs_bmbt_update(bma->cur, LEFT.br_startoff, 1882 1879 LEFT.br_startblock, 1883 1880 LEFT.br_blockcount + ··· 1910 1907 &i); 1911 1908 if (error) 1912 1909 goto done; 1913 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 1910 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 1914 1911 error = xfs_bmbt_update(bma->cur, LEFT.br_startoff, 1915 1912 LEFT.br_startblock, 1916 1913 LEFT.br_blockcount + ··· 1941 1938 RIGHT.br_blockcount, &i); 1942 1939 if (error) 1943 1940 goto done; 1944 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 1941 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 1945 1942 error = xfs_bmbt_update(bma->cur, PREV.br_startoff, 1946 1943 new->br_startblock, 1947 1944 PREV.br_blockcount + ··· 1971 1968 &i); 1972 1969 if (error) 1973 1970 goto done; 1974 - XFS_WANT_CORRUPTED_GOTO(i == 0, done); 1971 + XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 1975 1972 bma->cur->bc_rec.b.br_state = XFS_EXT_NORM; 1976 1973 error = xfs_btree_insert(bma->cur, &i); 1977 1974 if (error) 1978 1975 goto done; 1979 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 1976 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 1980 1977 } 1981 1978 break; 1982 1979 ··· 2004 2001 &i); 2005 2002 if (error) 2006 2003 goto done; 2007 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2004 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2008 2005 error = xfs_bmbt_update(bma->cur, LEFT.br_startoff, 2009 2006 LEFT.br_startblock, 2010 2007 LEFT.br_blockcount + ··· 2041 2038 &i); 2042 2039 if (error) 2043 2040 goto done; 2044 - XFS_WANT_CORRUPTED_GOTO(i == 0, done); 2041 + XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 2045 2042 bma->cur->bc_rec.b.br_state = XFS_EXT_NORM; 2046 2043 error = xfs_btree_insert(bma->cur, &i); 2047 2044 if (error) 2048 2045 goto done; 2049 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2046 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2050 2047 } 2051 2048 2052 2049 if (xfs_bmap_needs_btree(bma->ip, XFS_DATA_FORK)) { ··· 2087 2084 RIGHT.br_blockcount, &i); 2088 2085 if (error) 2089 2086 goto done; 2090 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2087 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2091 2088 error = xfs_bmbt_update(bma->cur, new->br_startoff, 2092 2089 new->br_startblock, 2093 2090 new->br_blockcount + ··· 2125 2122 &i); 2126 2123 if (error) 2127 2124 goto done; 2128 - XFS_WANT_CORRUPTED_GOTO(i == 0, done); 2125 + XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 2129 2126 bma->cur->bc_rec.b.br_state = XFS_EXT_NORM; 2130 2127 error = xfs_btree_insert(bma->cur, &i); 2131 2128 if (error) 2132 2129 goto done; 2133 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2130 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2134 2131 } 2135 2132 2136 2133 if (xfs_bmap_needs_btree(bma->ip, XFS_DATA_FORK)) { ··· 2194 2191 &i); 2195 2192 if (error) 2196 2193 goto done; 2197 - XFS_WANT_CORRUPTED_GOTO(i == 0, done); 2194 + XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 2198 2195 bma->cur->bc_rec.b.br_state = XFS_EXT_NORM; 2199 2196 error = xfs_btree_insert(bma->cur, &i); 2200 2197 if (error) 2201 2198 goto done; 2202 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2199 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2203 2200 } 2204 2201 2205 2202 if (xfs_bmap_needs_btree(bma->ip, XFS_DATA_FORK)) { ··· 2312 2309 /* left is 0, right is 1, prev is 2 */ 2313 2310 int rval=0; /* return value (logging flags) */ 2314 2311 int state = 0;/* state bits, accessed thru macros */ 2312 + struct xfs_mount *mp = tp->t_mountp; 2315 2313 2316 2314 *logflagsp = 0; 2317 2315 ··· 2425 2421 RIGHT.br_startblock, 2426 2422 RIGHT.br_blockcount, &i))) 2427 2423 goto done; 2428 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2424 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2429 2425 if ((error = xfs_btree_delete(cur, &i))) 2430 2426 goto done; 2431 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2427 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2432 2428 if ((error = xfs_btree_decrement(cur, 0, &i))) 2433 2429 goto done; 2434 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2430 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2435 2431 if ((error = xfs_btree_delete(cur, &i))) 2436 2432 goto done; 2437 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2433 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2438 2434 if ((error = xfs_btree_decrement(cur, 0, &i))) 2439 2435 goto done; 2440 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2436 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2441 2437 if ((error = xfs_bmbt_update(cur, LEFT.br_startoff, 2442 2438 LEFT.br_startblock, 2443 2439 LEFT.br_blockcount + PREV.br_blockcount + ··· 2468 2464 PREV.br_startblock, PREV.br_blockcount, 2469 2465 &i))) 2470 2466 goto done; 2471 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2467 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2472 2468 if ((error = xfs_btree_delete(cur, &i))) 2473 2469 goto done; 2474 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2470 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2475 2471 if ((error = xfs_btree_decrement(cur, 0, &i))) 2476 2472 goto done; 2477 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2473 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2478 2474 if ((error = xfs_bmbt_update(cur, LEFT.br_startoff, 2479 2475 LEFT.br_startblock, 2480 2476 LEFT.br_blockcount + PREV.br_blockcount, ··· 2503 2499 RIGHT.br_startblock, 2504 2500 RIGHT.br_blockcount, &i))) 2505 2501 goto done; 2506 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2502 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2507 2503 if ((error = xfs_btree_delete(cur, &i))) 2508 2504 goto done; 2509 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2505 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2510 2506 if ((error = xfs_btree_decrement(cur, 0, &i))) 2511 2507 goto done; 2512 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2508 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2513 2509 if ((error = xfs_bmbt_update(cur, new->br_startoff, 2514 2510 new->br_startblock, 2515 2511 new->br_blockcount + RIGHT.br_blockcount, ··· 2536 2532 new->br_startblock, new->br_blockcount, 2537 2533 &i))) 2538 2534 goto done; 2539 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2535 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2540 2536 if ((error = xfs_bmbt_update(cur, new->br_startoff, 2541 2537 new->br_startblock, new->br_blockcount, 2542 2538 newext))) ··· 2573 2569 PREV.br_startblock, PREV.br_blockcount, 2574 2570 &i))) 2575 2571 goto done; 2576 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2572 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2577 2573 if ((error = xfs_bmbt_update(cur, 2578 2574 PREV.br_startoff + new->br_blockcount, 2579 2575 PREV.br_startblock + new->br_blockcount, ··· 2615 2611 PREV.br_startblock, PREV.br_blockcount, 2616 2612 &i))) 2617 2613 goto done; 2618 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2614 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2619 2615 if ((error = xfs_bmbt_update(cur, 2620 2616 PREV.br_startoff + new->br_blockcount, 2621 2617 PREV.br_startblock + new->br_blockcount, ··· 2625 2621 cur->bc_rec.b = *new; 2626 2622 if ((error = xfs_btree_insert(cur, &i))) 2627 2623 goto done; 2628 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2624 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2629 2625 } 2630 2626 break; 2631 2627 ··· 2655 2651 PREV.br_startblock, 2656 2652 PREV.br_blockcount, &i))) 2657 2653 goto done; 2658 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2654 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2659 2655 if ((error = xfs_bmbt_update(cur, PREV.br_startoff, 2660 2656 PREV.br_startblock, 2661 2657 PREV.br_blockcount - new->br_blockcount, ··· 2693 2689 PREV.br_startblock, PREV.br_blockcount, 2694 2690 &i))) 2695 2691 goto done; 2696 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2692 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2697 2693 if ((error = xfs_bmbt_update(cur, PREV.br_startoff, 2698 2694 PREV.br_startblock, 2699 2695 PREV.br_blockcount - new->br_blockcount, ··· 2703 2699 new->br_startblock, new->br_blockcount, 2704 2700 &i))) 2705 2701 goto done; 2706 - XFS_WANT_CORRUPTED_GOTO(i == 0, done); 2702 + XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 2707 2703 cur->bc_rec.b.br_state = XFS_EXT_NORM; 2708 2704 if ((error = xfs_btree_insert(cur, &i))) 2709 2705 goto done; 2710 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2706 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2711 2707 } 2712 2708 break; 2713 2709 ··· 2741 2737 PREV.br_startblock, PREV.br_blockcount, 2742 2738 &i))) 2743 2739 goto done; 2744 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2740 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2745 2741 /* new right extent - oldext */ 2746 2742 if ((error = xfs_bmbt_update(cur, r[1].br_startoff, 2747 2743 r[1].br_startblock, r[1].br_blockcount, ··· 2753 2749 new->br_startoff - PREV.br_startoff; 2754 2750 if ((error = xfs_btree_insert(cur, &i))) 2755 2751 goto done; 2756 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2752 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2757 2753 /* 2758 2754 * Reset the cursor to the position of the new extent 2759 2755 * we are about to insert as we can't trust it after ··· 2763 2759 new->br_startblock, new->br_blockcount, 2764 2760 &i))) 2765 2761 goto done; 2766 - XFS_WANT_CORRUPTED_GOTO(i == 0, done); 2762 + XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 2767 2763 /* new middle extent - newext */ 2768 2764 cur->bc_rec.b.br_state = new->br_state; 2769 2765 if ((error = xfs_btree_insert(cur, &i))) 2770 2766 goto done; 2771 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 2767 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2772 2768 } 2773 2769 break; 2774 2770 ··· 2972 2968 xfs_bmbt_irec_t right; /* right neighbor extent entry */ 2973 2969 int rval=0; /* return value (logging flags) */ 2974 2970 int state; /* state bits, accessed thru macros */ 2971 + struct xfs_mount *mp; 2975 2972 2973 + mp = bma->tp ? bma->tp->t_mountp : NULL; 2976 2974 ifp = XFS_IFORK_PTR(bma->ip, whichfork); 2977 2975 2978 2976 ASSERT(bma->idx >= 0); ··· 3062 3056 &i); 3063 3057 if (error) 3064 3058 goto done; 3065 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 3059 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 3066 3060 error = xfs_btree_delete(bma->cur, &i); 3067 3061 if (error) 3068 3062 goto done; 3069 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 3063 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 3070 3064 error = xfs_btree_decrement(bma->cur, 0, &i); 3071 3065 if (error) 3072 3066 goto done; 3073 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 3067 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 3074 3068 error = xfs_bmbt_update(bma->cur, left.br_startoff, 3075 3069 left.br_startblock, 3076 3070 left.br_blockcount + ··· 3103 3097 &i); 3104 3098 if (error) 3105 3099 goto done; 3106 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 3100 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 3107 3101 error = xfs_bmbt_update(bma->cur, left.br_startoff, 3108 3102 left.br_startblock, 3109 3103 left.br_blockcount + ··· 3137 3131 right.br_blockcount, &i); 3138 3132 if (error) 3139 3133 goto done; 3140 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 3134 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 3141 3135 error = xfs_bmbt_update(bma->cur, new->br_startoff, 3142 3136 new->br_startblock, 3143 3137 new->br_blockcount + ··· 3167 3161 new->br_blockcount, &i); 3168 3162 if (error) 3169 3163 goto done; 3170 - XFS_WANT_CORRUPTED_GOTO(i == 0, done); 3164 + XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 3171 3165 bma->cur->bc_rec.b.br_state = new->br_state; 3172 3166 error = xfs_btree_insert(bma->cur, &i); 3173 3167 if (error) 3174 3168 goto done; 3175 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 3169 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 3176 3170 } 3177 3171 break; 3178 3172 } ··· 4807 4801 got.br_startblock, got.br_blockcount, 4808 4802 &i))) 4809 4803 goto done; 4810 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 4804 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 4811 4805 } 4812 4806 da_old = da_new = 0; 4813 4807 } else { ··· 4841 4835 } 4842 4836 if ((error = xfs_btree_delete(cur, &i))) 4843 4837 goto done; 4844 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 4838 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 4845 4839 break; 4846 4840 4847 4841 case 2: ··· 4941 4935 got.br_startblock, 4942 4936 temp, &i))) 4943 4937 goto done; 4944 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 4938 + XFS_WANT_CORRUPTED_GOTO(mp, 4939 + i == 1, done); 4945 4940 /* 4946 4941 * Update the btree record back 4947 4942 * to the original value. ··· 4963 4956 error = -ENOSPC; 4964 4957 goto done; 4965 4958 } 4966 - XFS_WANT_CORRUPTED_GOTO(i == 1, done); 4959 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 4967 4960 } else 4968 4961 flags |= xfs_ilog_fext(whichfork); 4969 4962 XFS_IFORK_NEXT_SET(ip, whichfork,

+9 -9

fs/xfs/libxfs/xfs_btree.c

··· 2285 2285 if (error) 2286 2286 goto error0; 2287 2287 i = xfs_btree_lastrec(tcur, level); 2288 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 2288 + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, i == 1, error0); 2289 2289 2290 2290 error = xfs_btree_increment(tcur, level, &i); 2291 2291 if (error) ··· 3138 3138 goto error0; 3139 3139 } 3140 3140 3141 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 3141 + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, i == 1, error0); 3142 3142 level++; 3143 3143 3144 3144 /* ··· 3582 3582 * Actually any entry but the first would suffice. 3583 3583 */ 3584 3584 i = xfs_btree_lastrec(tcur, level); 3585 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 3585 + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, i == 1, error0); 3586 3586 3587 3587 error = xfs_btree_increment(tcur, level, &i); 3588 3588 if (error) 3589 3589 goto error0; 3590 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 3590 + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, i == 1, error0); 3591 3591 3592 3592 i = xfs_btree_lastrec(tcur, level); 3593 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 3593 + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, i == 1, error0); 3594 3594 3595 3595 /* Grab a pointer to the block. */ 3596 3596 right = xfs_btree_get_block(tcur, level, &rbp); ··· 3634 3634 rrecs = xfs_btree_get_numrecs(right); 3635 3635 if (!xfs_btree_ptr_is_null(cur, &lptr)) { 3636 3636 i = xfs_btree_firstrec(tcur, level); 3637 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 3637 + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, i == 1, error0); 3638 3638 3639 3639 error = xfs_btree_decrement(tcur, level, &i); 3640 3640 if (error) 3641 3641 goto error0; 3642 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 3642 + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, i == 1, error0); 3643 3643 } 3644 3644 } 3645 3645 ··· 3653 3653 * previous block. 3654 3654 */ 3655 3655 i = xfs_btree_firstrec(tcur, level); 3656 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 3656 + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, i == 1, error0); 3657 3657 3658 3658 error = xfs_btree_decrement(tcur, level, &i); 3659 3659 if (error) 3660 3660 goto error0; 3661 3661 i = xfs_btree_firstrec(tcur, level); 3662 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 3662 + XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, i == 1, error0); 3663 3663 3664 3664 /* Grab a pointer to the block. */ 3665 3665 left = xfs_btree_get_block(tcur, level, &lbp);

+12 -12

fs/xfs/libxfs/xfs_ialloc.c

··· 783 783 error = xfs_inobt_lookup(cur, pagino, XFS_LOOKUP_LE, &i); 784 784 if (error) 785 785 goto error0; 786 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 786 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 787 787 788 788 error = xfs_inobt_get_rec(cur, &rec, &j); 789 789 if (error) 790 790 goto error0; 791 - XFS_WANT_CORRUPTED_GOTO(j == 1, error0); 791 + XFS_WANT_CORRUPTED_GOTO(mp, j == 1, error0); 792 792 793 793 if (rec.ir_freecount > 0) { 794 794 /* ··· 944 944 error = xfs_inobt_lookup(cur, 0, XFS_LOOKUP_GE, &i); 945 945 if (error) 946 946 goto error0; 947 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 947 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 948 948 949 949 for (;;) { 950 950 error = xfs_inobt_get_rec(cur, &rec, &i); 951 951 if (error) 952 952 goto error0; 953 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 953 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 954 954 if (rec.ir_freecount > 0) 955 955 break; 956 956 error = xfs_btree_increment(cur, 0, &i); 957 957 if (error) 958 958 goto error0; 959 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 959 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 960 960 } 961 961 962 962 alloc_inode: ··· 1039 1039 error = xfs_inobt_get_rec(rcur, &rrec, &j); 1040 1040 if (error) 1041 1041 goto error_rcur; 1042 - XFS_WANT_CORRUPTED_GOTO(j == 1, error_rcur); 1042 + XFS_WANT_CORRUPTED_GOTO(lcur->bc_mp, j == 1, error_rcur); 1043 1043 } 1044 1044 1045 - XFS_WANT_CORRUPTED_GOTO(i == 1 || j == 1, error_rcur); 1045 + XFS_WANT_CORRUPTED_GOTO(lcur->bc_mp, i == 1 || j == 1, error_rcur); 1046 1046 if (i == 1 && j == 1) { 1047 1047 /* 1048 1048 * Both the left and right records are valid. Choose the closer ··· 1475 1475 __func__, error); 1476 1476 goto error0; 1477 1477 } 1478 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1478 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1479 1479 error = xfs_inobt_get_rec(cur, &rec, &i); 1480 1480 if (error) { 1481 1481 xfs_warn(mp, "%s: xfs_inobt_get_rec() returned error %d.", 1482 1482 __func__, error); 1483 1483 goto error0; 1484 1484 } 1485 - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); 1485 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1486 1486 /* 1487 1487 * Get the offset in the inode chunk. 1488 1488 */ ··· 1592 1592 * freed an inode in a previously fully allocated chunk. If not, 1593 1593 * something is out of sync. 1594 1594 */ 1595 - XFS_WANT_CORRUPTED_GOTO(ibtrec->ir_freecount == 1, error); 1595 + XFS_WANT_CORRUPTED_GOTO(mp, ibtrec->ir_freecount == 1, error); 1596 1596 1597 1597 error = xfs_inobt_insert_rec(cur, ibtrec->ir_freecount, 1598 1598 ibtrec->ir_free, &i); ··· 1613 1613 error = xfs_inobt_get_rec(cur, &rec, &i); 1614 1614 if (error) 1615 1615 goto error; 1616 - XFS_WANT_CORRUPTED_GOTO(i == 1, error); 1616 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error); 1617 1617 1618 1618 rec.ir_free |= XFS_INOBT_MASK(offset); 1619 1619 rec.ir_freecount++; 1620 1620 1621 - XFS_WANT_CORRUPTED_GOTO((rec.ir_free == ibtrec->ir_free) && 1621 + XFS_WANT_CORRUPTED_GOTO(mp, (rec.ir_free == ibtrec->ir_free) && 1622 1622 (rec.ir_freecount == ibtrec->ir_freecount), 1623 1623 error); 1624 1624

+1 -1

fs/xfs/xfs_discard.c

··· 84 84 error = xfs_alloc_get_rec(cur, &fbno, &flen, &i); 85 85 if (error) 86 86 goto out_del_cursor; 87 - XFS_WANT_CORRUPTED_GOTO(i == 1, out_del_cursor); 87 + XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_del_cursor); 88 88 ASSERT(flen <= be32_to_cpu(XFS_BUF_TO_AGF(agbp)->agf_longest)); 89 89 90 90 /*

+2 -2

fs/xfs/xfs_error.h

··· 40 40 /* 41 41 * Macros to set EFSCORRUPTED & return/branch. 42 42 */ 43 - #define XFS_WANT_CORRUPTED_GOTO(x,l) \ 43 + #define XFS_WANT_CORRUPTED_GOTO(mp, x, l) \ 44 44 { \ 45 45 int fs_is_ok = (x); \ 46 46 ASSERT(fs_is_ok); \ 47 47 if (unlikely(!fs_is_ok)) { \ 48 48 XFS_ERROR_REPORT("XFS_WANT_CORRUPTED_GOTO", \ 49 - XFS_ERRLEVEL_LOW, NULL); \ 49 + XFS_ERRLEVEL_LOW, mp); \ 50 50 error = -EFSCORRUPTED; \ 51 51 goto l; \ 52 52 } \