xfs_trans_buf.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782
  1. /*
  2. * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
  3. * All Rights Reserved.
  4. *
  5. * This program is free software; you can redistribute it and/or
  6. * modify it under the terms of the GNU General Public License as
  7. * published by the Free Software Foundation.
  8. *
  9. * This program is distributed in the hope that it would be useful,
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. * GNU General Public License for more details.
  13. *
  14. * You should have received a copy of the GNU General Public License
  15. * along with this program; if not, write the Free Software Foundation,
  16. * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  17. */
  18. #include "xfs.h"
  19. #include "xfs_fs.h"
  20. #include "xfs_types.h"
  21. #include "xfs_log.h"
  22. #include "xfs_trans.h"
  23. #include "xfs_sb.h"
  24. #include "xfs_ag.h"
  25. #include "xfs_mount.h"
  26. #include "xfs_bmap_btree.h"
  27. #include "xfs_alloc_btree.h"
  28. #include "xfs_ialloc_btree.h"
  29. #include "xfs_dinode.h"
  30. #include "xfs_inode.h"
  31. #include "xfs_buf_item.h"
  32. #include "xfs_trans_priv.h"
  33. #include "xfs_error.h"
  34. #include "xfs_trace.h"
  35. /*
  36. * Check to see if a buffer matching the given parameters is already
  37. * a part of the given transaction.
  38. */
  39. STATIC struct xfs_buf *
  40. xfs_trans_buf_item_match(
  41. struct xfs_trans *tp,
  42. struct xfs_buftarg *target,
  43. xfs_daddr_t blkno,
  44. int len)
  45. {
  46. struct xfs_log_item_desc *lidp;
  47. struct xfs_buf_log_item *blip;
  48. len = BBTOB(len);
  49. list_for_each_entry(lidp, &tp->t_items, lid_trans) {
  50. blip = (struct xfs_buf_log_item *)lidp->lid_item;
  51. if (blip->bli_item.li_type == XFS_LI_BUF &&
  52. blip->bli_buf->b_target == target &&
  53. XFS_BUF_ADDR(blip->bli_buf) == blkno &&
  54. BBTOB(blip->bli_buf->b_length) == len)
  55. return blip->bli_buf;
  56. }
  57. return NULL;
  58. }
  59. /*
  60. * Add the locked buffer to the transaction.
  61. *
  62. * The buffer must be locked, and it cannot be associated with any
  63. * transaction.
  64. *
  65. * If the buffer does not yet have a buf log item associated with it,
  66. * then allocate one for it. Then add the buf item to the transaction.
  67. */
  68. STATIC void
  69. _xfs_trans_bjoin(
  70. struct xfs_trans *tp,
  71. struct xfs_buf *bp,
  72. int reset_recur)
  73. {
  74. struct xfs_buf_log_item *bip;
  75. ASSERT(bp->b_transp == NULL);
  76. /*
  77. * The xfs_buf_log_item pointer is stored in b_fsprivate. If
  78. * it doesn't have one yet, then allocate one and initialize it.
  79. * The checks to see if one is there are in xfs_buf_item_init().
  80. */
  81. xfs_buf_item_init(bp, tp->t_mountp);
  82. bip = bp->b_fspriv;
  83. ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
  84. ASSERT(!(bip->bli_format.blf_flags & XFS_BLF_CANCEL));
  85. ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
  86. if (reset_recur)
  87. bip->bli_recur = 0;
  88. /*
  89. * Take a reference for this transaction on the buf item.
  90. */
  91. atomic_inc(&bip->bli_refcount);
  92. /*
  93. * Get a log_item_desc to point at the new item.
  94. */
  95. xfs_trans_add_item(tp, &bip->bli_item);
  96. /*
  97. * Initialize b_fsprivate2 so we can find it with incore_match()
  98. * in xfs_trans_get_buf() and friends above.
  99. */
  100. bp->b_transp = tp;
  101. }
  102. void
  103. xfs_trans_bjoin(
  104. struct xfs_trans *tp,
  105. struct xfs_buf *bp)
  106. {
  107. _xfs_trans_bjoin(tp, bp, 0);
  108. trace_xfs_trans_bjoin(bp->b_fspriv);
  109. }
  110. /*
  111. * Get and lock the buffer for the caller if it is not already
  112. * locked within the given transaction. If it is already locked
  113. * within the transaction, just increment its lock recursion count
  114. * and return a pointer to it.
  115. *
  116. * If the transaction pointer is NULL, make this just a normal
  117. * get_buf() call.
  118. */
  119. xfs_buf_t *
  120. xfs_trans_get_buf(xfs_trans_t *tp,
  121. xfs_buftarg_t *target_dev,
  122. xfs_daddr_t blkno,
  123. int len,
  124. uint flags)
  125. {
  126. xfs_buf_t *bp;
  127. xfs_buf_log_item_t *bip;
  128. if (flags == 0)
  129. flags = XBF_MAPPED;
  130. /*
  131. * Default to a normal get_buf() call if the tp is NULL.
  132. */
  133. if (tp == NULL)
  134. return xfs_buf_get(target_dev, blkno, len, flags);
  135. /*
  136. * If we find the buffer in the cache with this transaction
  137. * pointer in its b_fsprivate2 field, then we know we already
  138. * have it locked. In this case we just increment the lock
  139. * recursion count and return the buffer to the caller.
  140. */
  141. bp = xfs_trans_buf_item_match(tp, target_dev, blkno, len);
  142. if (bp != NULL) {
  143. ASSERT(xfs_buf_islocked(bp));
  144. if (XFS_FORCED_SHUTDOWN(tp->t_mountp)) {
  145. xfs_buf_stale(bp);
  146. XFS_BUF_DONE(bp);
  147. }
  148. ASSERT(bp->b_transp == tp);
  149. bip = bp->b_fspriv;
  150. ASSERT(bip != NULL);
  151. ASSERT(atomic_read(&bip->bli_refcount) > 0);
  152. bip->bli_recur++;
  153. trace_xfs_trans_get_buf_recur(bip);
  154. return (bp);
  155. }
  156. bp = xfs_buf_get(target_dev, blkno, len, flags);
  157. if (bp == NULL) {
  158. return NULL;
  159. }
  160. ASSERT(!bp->b_error);
  161. _xfs_trans_bjoin(tp, bp, 1);
  162. trace_xfs_trans_get_buf(bp->b_fspriv);
  163. return (bp);
  164. }
  165. /*
  166. * Get and lock the superblock buffer of this file system for the
  167. * given transaction.
  168. *
  169. * We don't need to use incore_match() here, because the superblock
  170. * buffer is a private buffer which we keep a pointer to in the
  171. * mount structure.
  172. */
  173. xfs_buf_t *
  174. xfs_trans_getsb(xfs_trans_t *tp,
  175. struct xfs_mount *mp,
  176. int flags)
  177. {
  178. xfs_buf_t *bp;
  179. xfs_buf_log_item_t *bip;
  180. /*
  181. * Default to just trying to lock the superblock buffer
  182. * if tp is NULL.
  183. */
  184. if (tp == NULL) {
  185. return (xfs_getsb(mp, flags));
  186. }
  187. /*
  188. * If the superblock buffer already has this transaction
  189. * pointer in its b_fsprivate2 field, then we know we already
  190. * have it locked. In this case we just increment the lock
  191. * recursion count and return the buffer to the caller.
  192. */
  193. bp = mp->m_sb_bp;
  194. if (bp->b_transp == tp) {
  195. bip = bp->b_fspriv;
  196. ASSERT(bip != NULL);
  197. ASSERT(atomic_read(&bip->bli_refcount) > 0);
  198. bip->bli_recur++;
  199. trace_xfs_trans_getsb_recur(bip);
  200. return (bp);
  201. }
  202. bp = xfs_getsb(mp, flags);
  203. if (bp == NULL)
  204. return NULL;
  205. _xfs_trans_bjoin(tp, bp, 1);
  206. trace_xfs_trans_getsb(bp->b_fspriv);
  207. return (bp);
  208. }
  209. #ifdef DEBUG
  210. xfs_buftarg_t *xfs_error_target;
  211. int xfs_do_error;
  212. int xfs_req_num;
  213. int xfs_error_mod = 33;
  214. #endif
  215. /*
  216. * Get and lock the buffer for the caller if it is not already
  217. * locked within the given transaction. If it has not yet been
  218. * read in, read it from disk. If it is already locked
  219. * within the transaction and already read in, just increment its
  220. * lock recursion count and return a pointer to it.
  221. *
  222. * If the transaction pointer is NULL, make this just a normal
  223. * read_buf() call.
  224. */
  225. int
  226. xfs_trans_read_buf(
  227. xfs_mount_t *mp,
  228. xfs_trans_t *tp,
  229. xfs_buftarg_t *target,
  230. xfs_daddr_t blkno,
  231. int len,
  232. uint flags,
  233. xfs_buf_t **bpp)
  234. {
  235. xfs_buf_t *bp;
  236. xfs_buf_log_item_t *bip;
  237. int error;
  238. *bpp = NULL;
  239. if (flags == 0)
  240. flags = XBF_MAPPED;
  241. /*
  242. * Default to a normal get_buf() call if the tp is NULL.
  243. */
  244. if (tp == NULL) {
  245. bp = xfs_buf_read(target, blkno, len, flags);
  246. if (!bp)
  247. return (flags & XBF_TRYLOCK) ?
  248. EAGAIN : XFS_ERROR(ENOMEM);
  249. if (bp->b_error) {
  250. error = bp->b_error;
  251. xfs_buf_ioerror_alert(bp, __func__);
  252. XFS_BUF_UNDONE(bp);
  253. xfs_buf_stale(bp);
  254. xfs_buf_relse(bp);
  255. return error;
  256. }
  257. #ifdef DEBUG
  258. if (xfs_do_error) {
  259. if (xfs_error_target == target) {
  260. if (((xfs_req_num++) % xfs_error_mod) == 0) {
  261. xfs_buf_relse(bp);
  262. xfs_debug(mp, "Returning error!");
  263. return XFS_ERROR(EIO);
  264. }
  265. }
  266. }
  267. #endif
  268. if (XFS_FORCED_SHUTDOWN(mp))
  269. goto shutdown_abort;
  270. *bpp = bp;
  271. return 0;
  272. }
  273. /*
  274. * If we find the buffer in the cache with this transaction
  275. * pointer in its b_fsprivate2 field, then we know we already
  276. * have it locked. If it is already read in we just increment
  277. * the lock recursion count and return the buffer to the caller.
  278. * If the buffer is not yet read in, then we read it in, increment
  279. * the lock recursion count, and return it to the caller.
  280. */
  281. bp = xfs_trans_buf_item_match(tp, target, blkno, len);
  282. if (bp != NULL) {
  283. ASSERT(xfs_buf_islocked(bp));
  284. ASSERT(bp->b_transp == tp);
  285. ASSERT(bp->b_fspriv != NULL);
  286. ASSERT(!bp->b_error);
  287. if (!(XFS_BUF_ISDONE(bp))) {
  288. trace_xfs_trans_read_buf_io(bp, _RET_IP_);
  289. ASSERT(!XFS_BUF_ISASYNC(bp));
  290. XFS_BUF_READ(bp);
  291. xfsbdstrat(tp->t_mountp, bp);
  292. error = xfs_buf_iowait(bp);
  293. if (error) {
  294. xfs_buf_ioerror_alert(bp, __func__);
  295. xfs_buf_relse(bp);
  296. /*
  297. * We can gracefully recover from most read
  298. * errors. Ones we can't are those that happen
  299. * after the transaction's already dirty.
  300. */
  301. if (tp->t_flags & XFS_TRANS_DIRTY)
  302. xfs_force_shutdown(tp->t_mountp,
  303. SHUTDOWN_META_IO_ERROR);
  304. return error;
  305. }
  306. }
  307. /*
  308. * We never locked this buf ourselves, so we shouldn't
  309. * brelse it either. Just get out.
  310. */
  311. if (XFS_FORCED_SHUTDOWN(mp)) {
  312. trace_xfs_trans_read_buf_shut(bp, _RET_IP_);
  313. *bpp = NULL;
  314. return XFS_ERROR(EIO);
  315. }
  316. bip = bp->b_fspriv;
  317. bip->bli_recur++;
  318. ASSERT(atomic_read(&bip->bli_refcount) > 0);
  319. trace_xfs_trans_read_buf_recur(bip);
  320. *bpp = bp;
  321. return 0;
  322. }
  323. bp = xfs_buf_read(target, blkno, len, flags);
  324. if (bp == NULL) {
  325. *bpp = NULL;
  326. return (flags & XBF_TRYLOCK) ?
  327. 0 : XFS_ERROR(ENOMEM);
  328. }
  329. if (bp->b_error) {
  330. error = bp->b_error;
  331. xfs_buf_stale(bp);
  332. XFS_BUF_DONE(bp);
  333. xfs_buf_ioerror_alert(bp, __func__);
  334. if (tp->t_flags & XFS_TRANS_DIRTY)
  335. xfs_force_shutdown(tp->t_mountp, SHUTDOWN_META_IO_ERROR);
  336. xfs_buf_relse(bp);
  337. return error;
  338. }
  339. #ifdef DEBUG
  340. if (xfs_do_error && !(tp->t_flags & XFS_TRANS_DIRTY)) {
  341. if (xfs_error_target == target) {
  342. if (((xfs_req_num++) % xfs_error_mod) == 0) {
  343. xfs_force_shutdown(tp->t_mountp,
  344. SHUTDOWN_META_IO_ERROR);
  345. xfs_buf_relse(bp);
  346. xfs_debug(mp, "Returning trans error!");
  347. return XFS_ERROR(EIO);
  348. }
  349. }
  350. }
  351. #endif
  352. if (XFS_FORCED_SHUTDOWN(mp))
  353. goto shutdown_abort;
  354. _xfs_trans_bjoin(tp, bp, 1);
  355. trace_xfs_trans_read_buf(bp->b_fspriv);
  356. *bpp = bp;
  357. return 0;
  358. shutdown_abort:
  359. trace_xfs_trans_read_buf_shut(bp, _RET_IP_);
  360. xfs_buf_relse(bp);
  361. *bpp = NULL;
  362. return XFS_ERROR(EIO);
  363. }
  364. /*
  365. * Release the buffer bp which was previously acquired with one of the
  366. * xfs_trans_... buffer allocation routines if the buffer has not
  367. * been modified within this transaction. If the buffer is modified
  368. * within this transaction, do decrement the recursion count but do
  369. * not release the buffer even if the count goes to 0. If the buffer is not
  370. * modified within the transaction, decrement the recursion count and
  371. * release the buffer if the recursion count goes to 0.
  372. *
  373. * If the buffer is to be released and it was not modified before
  374. * this transaction began, then free the buf_log_item associated with it.
  375. *
  376. * If the transaction pointer is NULL, make this just a normal
  377. * brelse() call.
  378. */
  379. void
  380. xfs_trans_brelse(xfs_trans_t *tp,
  381. xfs_buf_t *bp)
  382. {
  383. xfs_buf_log_item_t *bip;
  384. /*
  385. * Default to a normal brelse() call if the tp is NULL.
  386. */
  387. if (tp == NULL) {
  388. ASSERT(bp->b_transp == NULL);
  389. xfs_buf_relse(bp);
  390. return;
  391. }
  392. ASSERT(bp->b_transp == tp);
  393. bip = bp->b_fspriv;
  394. ASSERT(bip->bli_item.li_type == XFS_LI_BUF);
  395. ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
  396. ASSERT(!(bip->bli_format.blf_flags & XFS_BLF_CANCEL));
  397. ASSERT(atomic_read(&bip->bli_refcount) > 0);
  398. trace_xfs_trans_brelse(bip);
  399. /*
  400. * If the release is just for a recursive lock,
  401. * then decrement the count and return.
  402. */
  403. if (bip->bli_recur > 0) {
  404. bip->bli_recur--;
  405. return;
  406. }
  407. /*
  408. * If the buffer is dirty within this transaction, we can't
  409. * release it until we commit.
  410. */
  411. if (bip->bli_item.li_desc->lid_flags & XFS_LID_DIRTY)
  412. return;
  413. /*
  414. * If the buffer has been invalidated, then we can't release
  415. * it until the transaction commits to disk unless it is re-dirtied
  416. * as part of this transaction. This prevents us from pulling
  417. * the item from the AIL before we should.
  418. */
  419. if (bip->bli_flags & XFS_BLI_STALE)
  420. return;
  421. ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
  422. /*
  423. * Free up the log item descriptor tracking the released item.
  424. */
  425. xfs_trans_del_item(&bip->bli_item);
  426. /*
  427. * Clear the hold flag in the buf log item if it is set.
  428. * We wouldn't want the next user of the buffer to
  429. * get confused.
  430. */
  431. if (bip->bli_flags & XFS_BLI_HOLD) {
  432. bip->bli_flags &= ~XFS_BLI_HOLD;
  433. }
  434. /*
  435. * Drop our reference to the buf log item.
  436. */
  437. atomic_dec(&bip->bli_refcount);
  438. /*
  439. * If the buf item is not tracking data in the log, then
  440. * we must free it before releasing the buffer back to the
  441. * free pool. Before releasing the buffer to the free pool,
  442. * clear the transaction pointer in b_fsprivate2 to dissolve
  443. * its relation to this transaction.
  444. */
  445. if (!xfs_buf_item_dirty(bip)) {
  446. /***
  447. ASSERT(bp->b_pincount == 0);
  448. ***/
  449. ASSERT(atomic_read(&bip->bli_refcount) == 0);
  450. ASSERT(!(bip->bli_item.li_flags & XFS_LI_IN_AIL));
  451. ASSERT(!(bip->bli_flags & XFS_BLI_INODE_ALLOC_BUF));
  452. xfs_buf_item_relse(bp);
  453. }
  454. bp->b_transp = NULL;
  455. xfs_buf_relse(bp);
  456. }
  457. /*
  458. * Mark the buffer as not needing to be unlocked when the buf item's
  459. * IOP_UNLOCK() routine is called. The buffer must already be locked
  460. * and associated with the given transaction.
  461. */
  462. /* ARGSUSED */
  463. void
  464. xfs_trans_bhold(xfs_trans_t *tp,
  465. xfs_buf_t *bp)
  466. {
  467. xfs_buf_log_item_t *bip = bp->b_fspriv;
  468. ASSERT(bp->b_transp == tp);
  469. ASSERT(bip != NULL);
  470. ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
  471. ASSERT(!(bip->bli_format.blf_flags & XFS_BLF_CANCEL));
  472. ASSERT(atomic_read(&bip->bli_refcount) > 0);
  473. bip->bli_flags |= XFS_BLI_HOLD;
  474. trace_xfs_trans_bhold(bip);
  475. }
  476. /*
  477. * Cancel the previous buffer hold request made on this buffer
  478. * for this transaction.
  479. */
  480. void
  481. xfs_trans_bhold_release(xfs_trans_t *tp,
  482. xfs_buf_t *bp)
  483. {
  484. xfs_buf_log_item_t *bip = bp->b_fspriv;
  485. ASSERT(bp->b_transp == tp);
  486. ASSERT(bip != NULL);
  487. ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
  488. ASSERT(!(bip->bli_format.blf_flags & XFS_BLF_CANCEL));
  489. ASSERT(atomic_read(&bip->bli_refcount) > 0);
  490. ASSERT(bip->bli_flags & XFS_BLI_HOLD);
  491. bip->bli_flags &= ~XFS_BLI_HOLD;
  492. trace_xfs_trans_bhold_release(bip);
  493. }
  494. /*
  495. * This is called to mark bytes first through last inclusive of the given
  496. * buffer as needing to be logged when the transaction is committed.
  497. * The buffer must already be associated with the given transaction.
  498. *
  499. * First and last are numbers relative to the beginning of this buffer,
  500. * so the first byte in the buffer is numbered 0 regardless of the
  501. * value of b_blkno.
  502. */
  503. void
  504. xfs_trans_log_buf(xfs_trans_t *tp,
  505. xfs_buf_t *bp,
  506. uint first,
  507. uint last)
  508. {
  509. xfs_buf_log_item_t *bip = bp->b_fspriv;
  510. ASSERT(bp->b_transp == tp);
  511. ASSERT(bip != NULL);
  512. ASSERT(first <= last && last < BBTOB(bp->b_length));
  513. ASSERT(bp->b_iodone == NULL ||
  514. bp->b_iodone == xfs_buf_iodone_callbacks);
  515. /*
  516. * Mark the buffer as needing to be written out eventually,
  517. * and set its iodone function to remove the buffer's buf log
  518. * item from the AIL and free it when the buffer is flushed
  519. * to disk. See xfs_buf_attach_iodone() for more details
  520. * on li_cb and xfs_buf_iodone_callbacks().
  521. * If we end up aborting this transaction, we trap this buffer
  522. * inside the b_bdstrat callback so that this won't get written to
  523. * disk.
  524. */
  525. XFS_BUF_DONE(bp);
  526. ASSERT(atomic_read(&bip->bli_refcount) > 0);
  527. bp->b_iodone = xfs_buf_iodone_callbacks;
  528. bip->bli_item.li_cb = xfs_buf_iodone;
  529. trace_xfs_trans_log_buf(bip);
  530. /*
  531. * If we invalidated the buffer within this transaction, then
  532. * cancel the invalidation now that we're dirtying the buffer
  533. * again. There are no races with the code in xfs_buf_item_unpin(),
  534. * because we have a reference to the buffer this entire time.
  535. */
  536. if (bip->bli_flags & XFS_BLI_STALE) {
  537. bip->bli_flags &= ~XFS_BLI_STALE;
  538. ASSERT(XFS_BUF_ISSTALE(bp));
  539. XFS_BUF_UNSTALE(bp);
  540. bip->bli_format.blf_flags &= ~XFS_BLF_CANCEL;
  541. }
  542. tp->t_flags |= XFS_TRANS_DIRTY;
  543. bip->bli_item.li_desc->lid_flags |= XFS_LID_DIRTY;
  544. bip->bli_flags |= XFS_BLI_LOGGED;
  545. xfs_buf_item_log(bip, first, last);
  546. }
  547. /*
  548. * Invalidate a buffer that is being used within a transaction.
  549. *
  550. * Typically this is because the blocks in the buffer are being freed, so we
  551. * need to prevent it from being written out when we're done. Allowing it
  552. * to be written again might overwrite data in the free blocks if they are
  553. * reallocated to a file.
  554. *
  555. * We prevent the buffer from being written out by marking it stale. We can't
  556. * get rid of the buf log item at this point because the buffer may still be
  557. * pinned by another transaction. If that is the case, then we'll wait until
  558. * the buffer is committed to disk for the last time (we can tell by the ref
  559. * count) and free it in xfs_buf_item_unpin(). Until that happens we will
  560. * keep the buffer locked so that the buffer and buf log item are not reused.
  561. *
  562. * We also set the XFS_BLF_CANCEL flag in the buf log format structure and log
  563. * the buf item. This will be used at recovery time to determine that copies
  564. * of the buffer in the log before this should not be replayed.
  565. *
  566. * We mark the item descriptor and the transaction dirty so that we'll hold
  567. * the buffer until after the commit.
  568. *
  569. * Since we're invalidating the buffer, we also clear the state about which
  570. * parts of the buffer have been logged. We also clear the flag indicating
  571. * that this is an inode buffer since the data in the buffer will no longer
  572. * be valid.
  573. *
  574. * We set the stale bit in the buffer as well since we're getting rid of it.
  575. */
  576. void
  577. xfs_trans_binval(
  578. xfs_trans_t *tp,
  579. xfs_buf_t *bp)
  580. {
  581. xfs_buf_log_item_t *bip = bp->b_fspriv;
  582. ASSERT(bp->b_transp == tp);
  583. ASSERT(bip != NULL);
  584. ASSERT(atomic_read(&bip->bli_refcount) > 0);
  585. trace_xfs_trans_binval(bip);
  586. if (bip->bli_flags & XFS_BLI_STALE) {
  587. /*
  588. * If the buffer is already invalidated, then
  589. * just return.
  590. */
  591. ASSERT(XFS_BUF_ISSTALE(bp));
  592. ASSERT(!(bip->bli_flags & (XFS_BLI_LOGGED | XFS_BLI_DIRTY)));
  593. ASSERT(!(bip->bli_format.blf_flags & XFS_BLF_INODE_BUF));
  594. ASSERT(bip->bli_format.blf_flags & XFS_BLF_CANCEL);
  595. ASSERT(bip->bli_item.li_desc->lid_flags & XFS_LID_DIRTY);
  596. ASSERT(tp->t_flags & XFS_TRANS_DIRTY);
  597. return;
  598. }
  599. xfs_buf_stale(bp);
  600. bip->bli_flags |= XFS_BLI_STALE;
  601. bip->bli_flags &= ~(XFS_BLI_INODE_BUF | XFS_BLI_LOGGED | XFS_BLI_DIRTY);
  602. bip->bli_format.blf_flags &= ~XFS_BLF_INODE_BUF;
  603. bip->bli_format.blf_flags |= XFS_BLF_CANCEL;
  604. memset((char *)(bip->bli_format.blf_data_map), 0,
  605. (bip->bli_format.blf_map_size * sizeof(uint)));
  606. bip->bli_item.li_desc->lid_flags |= XFS_LID_DIRTY;
  607. tp->t_flags |= XFS_TRANS_DIRTY;
  608. }
  609. /*
  610. * This call is used to indicate that the buffer contains on-disk inodes which
  611. * must be handled specially during recovery. They require special handling
  612. * because only the di_next_unlinked from the inodes in the buffer should be
  613. * recovered. The rest of the data in the buffer is logged via the inodes
  614. * themselves.
  615. *
  616. * All we do is set the XFS_BLI_INODE_BUF flag in the items flags so it can be
  617. * transferred to the buffer's log format structure so that we'll know what to
  618. * do at recovery time.
  619. */
  620. void
  621. xfs_trans_inode_buf(
  622. xfs_trans_t *tp,
  623. xfs_buf_t *bp)
  624. {
  625. xfs_buf_log_item_t *bip = bp->b_fspriv;
  626. ASSERT(bp->b_transp == tp);
  627. ASSERT(bip != NULL);
  628. ASSERT(atomic_read(&bip->bli_refcount) > 0);
  629. bip->bli_flags |= XFS_BLI_INODE_BUF;
  630. }
  631. /*
  632. * This call is used to indicate that the buffer is going to
  633. * be staled and was an inode buffer. This means it gets
  634. * special processing during unpin - where any inodes
  635. * associated with the buffer should be removed from ail.
  636. * There is also special processing during recovery,
  637. * any replay of the inodes in the buffer needs to be
  638. * prevented as the buffer may have been reused.
  639. */
  640. void
  641. xfs_trans_stale_inode_buf(
  642. xfs_trans_t *tp,
  643. xfs_buf_t *bp)
  644. {
  645. xfs_buf_log_item_t *bip = bp->b_fspriv;
  646. ASSERT(bp->b_transp == tp);
  647. ASSERT(bip != NULL);
  648. ASSERT(atomic_read(&bip->bli_refcount) > 0);
  649. bip->bli_flags |= XFS_BLI_STALE_INODE;
  650. bip->bli_item.li_cb = xfs_buf_iodone;
  651. }
  652. /*
  653. * Mark the buffer as being one which contains newly allocated
  654. * inodes. We need to make sure that even if this buffer is
  655. * relogged as an 'inode buf' we still recover all of the inode
  656. * images in the face of a crash. This works in coordination with
  657. * xfs_buf_item_committed() to ensure that the buffer remains in the
  658. * AIL at its original location even after it has been relogged.
  659. */
  660. /* ARGSUSED */
  661. void
  662. xfs_trans_inode_alloc_buf(
  663. xfs_trans_t *tp,
  664. xfs_buf_t *bp)
  665. {
  666. xfs_buf_log_item_t *bip = bp->b_fspriv;
  667. ASSERT(bp->b_transp == tp);
  668. ASSERT(bip != NULL);
  669. ASSERT(atomic_read(&bip->bli_refcount) > 0);
  670. bip->bli_flags |= XFS_BLI_INODE_ALLOC_BUF;
  671. }
  672. /*
  673. * Similar to xfs_trans_inode_buf(), this marks the buffer as a cluster of
  674. * dquots. However, unlike in inode buffer recovery, dquot buffers get
  675. * recovered in their entirety. (Hence, no XFS_BLI_DQUOT_ALLOC_BUF flag).
  676. * The only thing that makes dquot buffers different from regular
  677. * buffers is that we must not replay dquot bufs when recovering
  678. * if a _corresponding_ quotaoff has happened. We also have to distinguish
  679. * between usr dquot bufs and grp dquot bufs, because usr and grp quotas
  680. * can be turned off independently.
  681. */
  682. /* ARGSUSED */
  683. void
  684. xfs_trans_dquot_buf(
  685. xfs_trans_t *tp,
  686. xfs_buf_t *bp,
  687. uint type)
  688. {
  689. xfs_buf_log_item_t *bip = bp->b_fspriv;
  690. ASSERT(bp->b_transp == tp);
  691. ASSERT(bip != NULL);
  692. ASSERT(type == XFS_BLF_UDQUOT_BUF ||
  693. type == XFS_BLF_PDQUOT_BUF ||
  694. type == XFS_BLF_GDQUOT_BUF);
  695. ASSERT(atomic_read(&bip->bli_refcount) > 0);
  696. bip->bli_format.blf_flags |= type;
  697. }