blob: 422913645709a360ee5d54839f36c0054133eaa8 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Nathan Scott7b718762005-11-02 14:58:39 +11002 * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Nathan Scott7b718762005-11-02 14:58:39 +11005 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * published by the Free Software Foundation.
8 *
Nathan Scott7b718762005-11-02 14:58:39 +11009 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Nathan Scott7b718762005-11-02 14:58:39 +110014 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include "xfs.h"
Nathan Scotta844f452005-11-02 14:38:42 +110019#include "xfs_fs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "xfs_types.h"
Nathan Scotta844f452005-11-02 14:38:42 +110021#include "xfs_bit.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include "xfs_log.h"
Nathan Scotta844f452005-11-02 14:38:42 +110023#include "xfs_inum.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include "xfs_trans.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include "xfs_sb.h"
26#include "xfs_ag.h"
27#include "xfs_dir.h"
Nathan Scotta844f452005-11-02 14:38:42 +110028#include "xfs_dir2.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include "xfs_dmapi.h"
30#include "xfs_mount.h"
Nathan Scotta844f452005-11-02 14:38:42 +110031#include "xfs_bmap_btree.h"
32#include "xfs_alloc_btree.h"
33#include "xfs_ialloc_btree.h"
34#include "xfs_dir_sf.h"
35#include "xfs_dir2_sf.h"
36#include "xfs_attr_sf.h"
37#include "xfs_dinode.h"
38#include "xfs_inode.h"
39#include "xfs_buf_item.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include "xfs_trans_priv.h"
41#include "xfs_error.h"
42#include "xfs_rw.h"
43
44
45STATIC xfs_buf_t *xfs_trans_buf_item_match(xfs_trans_t *, xfs_buftarg_t *,
46 xfs_daddr_t, int);
47STATIC xfs_buf_t *xfs_trans_buf_item_match_all(xfs_trans_t *, xfs_buftarg_t *,
48 xfs_daddr_t, int);
49
50
51/*
52 * Get and lock the buffer for the caller if it is not already
53 * locked within the given transaction. If it is already locked
54 * within the transaction, just increment its lock recursion count
55 * and return a pointer to it.
56 *
57 * Use the fast path function xfs_trans_buf_item_match() or the buffer
58 * cache routine incore_match() to find the buffer
59 * if it is already owned by this transaction.
60 *
61 * If we don't already own the buffer, use get_buf() to get it.
62 * If it doesn't yet have an associated xfs_buf_log_item structure,
63 * then allocate one and add the item to this transaction.
64 *
65 * If the transaction pointer is NULL, make this just a normal
66 * get_buf() call.
67 */
68xfs_buf_t *
69xfs_trans_get_buf(xfs_trans_t *tp,
70 xfs_buftarg_t *target_dev,
71 xfs_daddr_t blkno,
72 int len,
73 uint flags)
74{
75 xfs_buf_t *bp;
76 xfs_buf_log_item_t *bip;
77
78 if (flags == 0)
79 flags = XFS_BUF_LOCK | XFS_BUF_MAPPED;
80
81 /*
82 * Default to a normal get_buf() call if the tp is NULL.
83 */
84 if (tp == NULL) {
85 bp = xfs_buf_get_flags(target_dev, blkno, len,
86 flags | BUF_BUSY);
87 return(bp);
88 }
89
90 /*
91 * If we find the buffer in the cache with this transaction
92 * pointer in its b_fsprivate2 field, then we know we already
93 * have it locked. In this case we just increment the lock
94 * recursion count and return the buffer to the caller.
95 */
96 if (tp->t_items.lic_next == NULL) {
97 bp = xfs_trans_buf_item_match(tp, target_dev, blkno, len);
98 } else {
99 bp = xfs_trans_buf_item_match_all(tp, target_dev, blkno, len);
100 }
101 if (bp != NULL) {
102 ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
103 if (XFS_FORCED_SHUTDOWN(tp->t_mountp)) {
104 xfs_buftrace("TRANS GET RECUR SHUT", bp);
105 XFS_BUF_SUPER_STALE(bp);
106 }
107 /*
108 * If the buffer is stale then it was binval'ed
109 * since last read. This doesn't matter since the
110 * caller isn't allowed to use the data anyway.
111 */
112 else if (XFS_BUF_ISSTALE(bp)) {
113 xfs_buftrace("TRANS GET RECUR STALE", bp);
114 ASSERT(!XFS_BUF_ISDELAYWRITE(bp));
115 }
116 ASSERT(XFS_BUF_FSPRIVATE2(bp, xfs_trans_t *) == tp);
117 bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *);
118 ASSERT(bip != NULL);
119 ASSERT(atomic_read(&bip->bli_refcount) > 0);
120 bip->bli_recur++;
121 xfs_buftrace("TRANS GET RECUR", bp);
122 xfs_buf_item_trace("GET RECUR", bip);
123 return (bp);
124 }
125
126 /*
127 * We always specify the BUF_BUSY flag within a transaction so
128 * that get_buf does not try to push out a delayed write buffer
129 * which might cause another transaction to take place (if the
130 * buffer was delayed alloc). Such recursive transactions can
131 * easily deadlock with our current transaction as well as cause
132 * us to run out of stack space.
133 */
134 bp = xfs_buf_get_flags(target_dev, blkno, len, flags | BUF_BUSY);
135 if (bp == NULL) {
136 return NULL;
137 }
138
139 ASSERT(!XFS_BUF_GETERROR(bp));
140
141 /*
142 * The xfs_buf_log_item pointer is stored in b_fsprivate. If
143 * it doesn't have one yet, then allocate one and initialize it.
144 * The checks to see if one is there are in xfs_buf_item_init().
145 */
146 xfs_buf_item_init(bp, tp->t_mountp);
147
148 /*
149 * Set the recursion count for the buffer within this transaction
150 * to 0.
151 */
152 bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t*);
153 ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
154 ASSERT(!(bip->bli_format.blf_flags & XFS_BLI_CANCEL));
155 ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
156 bip->bli_recur = 0;
157
158 /*
159 * Take a reference for this transaction on the buf item.
160 */
161 atomic_inc(&bip->bli_refcount);
162
163 /*
164 * Get a log_item_desc to point at the new item.
165 */
166 (void) xfs_trans_add_item(tp, (xfs_log_item_t*)bip);
167
168 /*
169 * Initialize b_fsprivate2 so we can find it with incore_match()
170 * above.
171 */
172 XFS_BUF_SET_FSPRIVATE2(bp, tp);
173
174 xfs_buftrace("TRANS GET", bp);
175 xfs_buf_item_trace("GET", bip);
176 return (bp);
177}
178
179/*
180 * Get and lock the superblock buffer of this file system for the
181 * given transaction.
182 *
183 * We don't need to use incore_match() here, because the superblock
184 * buffer is a private buffer which we keep a pointer to in the
185 * mount structure.
186 */
187xfs_buf_t *
188xfs_trans_getsb(xfs_trans_t *tp,
189 struct xfs_mount *mp,
190 int flags)
191{
192 xfs_buf_t *bp;
193 xfs_buf_log_item_t *bip;
194
195 /*
196 * Default to just trying to lock the superblock buffer
197 * if tp is NULL.
198 */
199 if (tp == NULL) {
200 return (xfs_getsb(mp, flags));
201 }
202
203 /*
204 * If the superblock buffer already has this transaction
205 * pointer in its b_fsprivate2 field, then we know we already
206 * have it locked. In this case we just increment the lock
207 * recursion count and return the buffer to the caller.
208 */
209 bp = mp->m_sb_bp;
210 if (XFS_BUF_FSPRIVATE2(bp, xfs_trans_t *) == tp) {
211 bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t*);
212 ASSERT(bip != NULL);
213 ASSERT(atomic_read(&bip->bli_refcount) > 0);
214 bip->bli_recur++;
215 xfs_buf_item_trace("GETSB RECUR", bip);
216 return (bp);
217 }
218
219 bp = xfs_getsb(mp, flags);
220 if (bp == NULL) {
221 return NULL;
222 }
223
224 /*
225 * The xfs_buf_log_item pointer is stored in b_fsprivate. If
226 * it doesn't have one yet, then allocate one and initialize it.
227 * The checks to see if one is there are in xfs_buf_item_init().
228 */
229 xfs_buf_item_init(bp, mp);
230
231 /*
232 * Set the recursion count for the buffer within this transaction
233 * to 0.
234 */
235 bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t*);
236 ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
237 ASSERT(!(bip->bli_format.blf_flags & XFS_BLI_CANCEL));
238 ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
239 bip->bli_recur = 0;
240
241 /*
242 * Take a reference for this transaction on the buf item.
243 */
244 atomic_inc(&bip->bli_refcount);
245
246 /*
247 * Get a log_item_desc to point at the new item.
248 */
249 (void) xfs_trans_add_item(tp, (xfs_log_item_t*)bip);
250
251 /*
252 * Initialize b_fsprivate2 so we can find it with incore_match()
253 * above.
254 */
255 XFS_BUF_SET_FSPRIVATE2(bp, tp);
256
257 xfs_buf_item_trace("GETSB", bip);
258 return (bp);
259}
260
261#ifdef DEBUG
262xfs_buftarg_t *xfs_error_target;
263int xfs_do_error;
264int xfs_req_num;
265int xfs_error_mod = 33;
266#endif
267
268/*
269 * Get and lock the buffer for the caller if it is not already
270 * locked within the given transaction. If it has not yet been
271 * read in, read it from disk. If it is already locked
272 * within the transaction and already read in, just increment its
273 * lock recursion count and return a pointer to it.
274 *
275 * Use the fast path function xfs_trans_buf_item_match() or the buffer
276 * cache routine incore_match() to find the buffer
277 * if it is already owned by this transaction.
278 *
279 * If we don't already own the buffer, use read_buf() to get it.
280 * If it doesn't yet have an associated xfs_buf_log_item structure,
281 * then allocate one and add the item to this transaction.
282 *
283 * If the transaction pointer is NULL, make this just a normal
284 * read_buf() call.
285 */
286int
287xfs_trans_read_buf(
288 xfs_mount_t *mp,
289 xfs_trans_t *tp,
290 xfs_buftarg_t *target,
291 xfs_daddr_t blkno,
292 int len,
293 uint flags,
294 xfs_buf_t **bpp)
295{
296 xfs_buf_t *bp;
297 xfs_buf_log_item_t *bip;
298 int error;
299
300 if (flags == 0)
301 flags = XFS_BUF_LOCK | XFS_BUF_MAPPED;
302
303 /*
304 * Default to a normal get_buf() call if the tp is NULL.
305 */
306 if (tp == NULL) {
307 bp = xfs_buf_read_flags(target, blkno, len, flags | BUF_BUSY);
308 if (!bp)
309 return XFS_ERROR(ENOMEM);
310
311 if ((bp != NULL) && (XFS_BUF_GETERROR(bp) != 0)) {
312 xfs_ioerror_alert("xfs_trans_read_buf", mp,
313 bp, blkno);
314 error = XFS_BUF_GETERROR(bp);
315 xfs_buf_relse(bp);
316 return error;
317 }
318#ifdef DEBUG
319 if (xfs_do_error && (bp != NULL)) {
320 if (xfs_error_target == target) {
321 if (((xfs_req_num++) % xfs_error_mod) == 0) {
322 xfs_buf_relse(bp);
323 printk("Returning error!\n");
324 return XFS_ERROR(EIO);
325 }
326 }
327 }
328#endif
329 if (XFS_FORCED_SHUTDOWN(mp))
330 goto shutdown_abort;
331 *bpp = bp;
332 return 0;
333 }
334
335 /*
336 * If we find the buffer in the cache with this transaction
337 * pointer in its b_fsprivate2 field, then we know we already
338 * have it locked. If it is already read in we just increment
339 * the lock recursion count and return the buffer to the caller.
340 * If the buffer is not yet read in, then we read it in, increment
341 * the lock recursion count, and return it to the caller.
342 */
343 if (tp->t_items.lic_next == NULL) {
344 bp = xfs_trans_buf_item_match(tp, target, blkno, len);
345 } else {
346 bp = xfs_trans_buf_item_match_all(tp, target, blkno, len);
347 }
348 if (bp != NULL) {
349 ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
350 ASSERT(XFS_BUF_FSPRIVATE2(bp, xfs_trans_t *) == tp);
351 ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL);
352 ASSERT((XFS_BUF_ISERROR(bp)) == 0);
353 if (!(XFS_BUF_ISDONE(bp))) {
354 xfs_buftrace("READ_BUF_INCORE !DONE", bp);
355 ASSERT(!XFS_BUF_ISASYNC(bp));
356 XFS_BUF_READ(bp);
357 xfsbdstrat(tp->t_mountp, bp);
358 xfs_iowait(bp);
359 if (XFS_BUF_GETERROR(bp) != 0) {
360 xfs_ioerror_alert("xfs_trans_read_buf", mp,
361 bp, blkno);
362 error = XFS_BUF_GETERROR(bp);
363 xfs_buf_relse(bp);
364 /*
365 * We can gracefully recover from most
366 * read errors. Ones we can't are those
367 * that happen after the transaction's
368 * already dirty.
369 */
370 if (tp->t_flags & XFS_TRANS_DIRTY)
371 xfs_force_shutdown(tp->t_mountp,
Nathan Scott7d04a332006-06-09 14:58:38 +1000372 SHUTDOWN_META_IO_ERROR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 return error;
374 }
375 }
376 /*
377 * We never locked this buf ourselves, so we shouldn't
378 * brelse it either. Just get out.
379 */
380 if (XFS_FORCED_SHUTDOWN(mp)) {
381 xfs_buftrace("READ_BUF_INCORE XFSSHUTDN", bp);
382 *bpp = NULL;
383 return XFS_ERROR(EIO);
384 }
385
386
387 bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t*);
388 bip->bli_recur++;
389
390 ASSERT(atomic_read(&bip->bli_refcount) > 0);
391 xfs_buf_item_trace("READ RECUR", bip);
392 *bpp = bp;
393 return 0;
394 }
395
396 /*
397 * We always specify the BUF_BUSY flag within a transaction so
398 * that get_buf does not try to push out a delayed write buffer
399 * which might cause another transaction to take place (if the
400 * buffer was delayed alloc). Such recursive transactions can
401 * easily deadlock with our current transaction as well as cause
402 * us to run out of stack space.
403 */
404 bp = xfs_buf_read_flags(target, blkno, len, flags | BUF_BUSY);
405 if (bp == NULL) {
406 *bpp = NULL;
407 return 0;
408 }
409 if (XFS_BUF_GETERROR(bp) != 0) {
410 XFS_BUF_SUPER_STALE(bp);
411 xfs_buftrace("READ ERROR", bp);
412 error = XFS_BUF_GETERROR(bp);
413
414 xfs_ioerror_alert("xfs_trans_read_buf", mp,
415 bp, blkno);
416 if (tp->t_flags & XFS_TRANS_DIRTY)
Nathan Scott7d04a332006-06-09 14:58:38 +1000417 xfs_force_shutdown(tp->t_mountp, SHUTDOWN_META_IO_ERROR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 xfs_buf_relse(bp);
419 return error;
420 }
421#ifdef DEBUG
422 if (xfs_do_error && !(tp->t_flags & XFS_TRANS_DIRTY)) {
423 if (xfs_error_target == target) {
424 if (((xfs_req_num++) % xfs_error_mod) == 0) {
425 xfs_force_shutdown(tp->t_mountp,
Nathan Scott7d04a332006-06-09 14:58:38 +1000426 SHUTDOWN_META_IO_ERROR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 xfs_buf_relse(bp);
428 printk("Returning error in trans!\n");
429 return XFS_ERROR(EIO);
430 }
431 }
432 }
433#endif
434 if (XFS_FORCED_SHUTDOWN(mp))
435 goto shutdown_abort;
436
437 /*
438 * The xfs_buf_log_item pointer is stored in b_fsprivate. If
439 * it doesn't have one yet, then allocate one and initialize it.
440 * The checks to see if one is there are in xfs_buf_item_init().
441 */
442 xfs_buf_item_init(bp, tp->t_mountp);
443
444 /*
445 * Set the recursion count for the buffer within this transaction
446 * to 0.
447 */
448 bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t*);
449 ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
450 ASSERT(!(bip->bli_format.blf_flags & XFS_BLI_CANCEL));
451 ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
452 bip->bli_recur = 0;
453
454 /*
455 * Take a reference for this transaction on the buf item.
456 */
457 atomic_inc(&bip->bli_refcount);
458
459 /*
460 * Get a log_item_desc to point at the new item.
461 */
462 (void) xfs_trans_add_item(tp, (xfs_log_item_t*)bip);
463
464 /*
465 * Initialize b_fsprivate2 so we can find it with incore_match()
466 * above.
467 */
468 XFS_BUF_SET_FSPRIVATE2(bp, tp);
469
470 xfs_buftrace("TRANS READ", bp);
471 xfs_buf_item_trace("READ", bip);
472 *bpp = bp;
473 return 0;
474
475shutdown_abort:
476 /*
477 * the theory here is that buffer is good but we're
478 * bailing out because the filesystem is being forcibly
479 * shut down. So we should leave the b_flags alone since
480 * the buffer's not staled and just get out.
481 */
482#if defined(DEBUG)
483 if (XFS_BUF_ISSTALE(bp) && XFS_BUF_ISDELAYWRITE(bp))
484 cmn_err(CE_NOTE, "about to pop assert, bp == 0x%p", bp);
485#endif
486 ASSERT((XFS_BUF_BFLAGS(bp) & (XFS_B_STALE|XFS_B_DELWRI)) !=
487 (XFS_B_STALE|XFS_B_DELWRI));
488
489 xfs_buftrace("READ_BUF XFSSHUTDN", bp);
490 xfs_buf_relse(bp);
491 *bpp = NULL;
492 return XFS_ERROR(EIO);
493}
494
495
496/*
497 * Release the buffer bp which was previously acquired with one of the
498 * xfs_trans_... buffer allocation routines if the buffer has not
499 * been modified within this transaction. If the buffer is modified
500 * within this transaction, do decrement the recursion count but do
501 * not release the buffer even if the count goes to 0. If the buffer is not
502 * modified within the transaction, decrement the recursion count and
503 * release the buffer if the recursion count goes to 0.
504 *
505 * If the buffer is to be released and it was not modified before
506 * this transaction began, then free the buf_log_item associated with it.
507 *
508 * If the transaction pointer is NULL, make this just a normal
509 * brelse() call.
510 */
511void
512xfs_trans_brelse(xfs_trans_t *tp,
513 xfs_buf_t *bp)
514{
515 xfs_buf_log_item_t *bip;
516 xfs_log_item_t *lip;
517 xfs_log_item_desc_t *lidp;
518
519 /*
520 * Default to a normal brelse() call if the tp is NULL.
521 */
522 if (tp == NULL) {
523 ASSERT(XFS_BUF_FSPRIVATE2(bp, void *) == NULL);
524 /*
525 * If there's a buf log item attached to the buffer,
526 * then let the AIL know that the buffer is being
527 * unlocked.
528 */
529 if (XFS_BUF_FSPRIVATE(bp, void *) != NULL) {
530 lip = XFS_BUF_FSPRIVATE(bp, xfs_log_item_t *);
531 if (lip->li_type == XFS_LI_BUF) {
532 bip = XFS_BUF_FSPRIVATE(bp,xfs_buf_log_item_t*);
533 xfs_trans_unlocked_item(
534 bip->bli_item.li_mountp,
535 lip);
536 }
537 }
538 xfs_buf_relse(bp);
539 return;
540 }
541
542 ASSERT(XFS_BUF_FSPRIVATE2(bp, xfs_trans_t *) == tp);
543 bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *);
544 ASSERT(bip->bli_item.li_type == XFS_LI_BUF);
545 ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
546 ASSERT(!(bip->bli_format.blf_flags & XFS_BLI_CANCEL));
547 ASSERT(atomic_read(&bip->bli_refcount) > 0);
548
549 /*
550 * Find the item descriptor pointing to this buffer's
551 * log item. It must be there.
552 */
553 lidp = xfs_trans_find_item(tp, (xfs_log_item_t*)bip);
554 ASSERT(lidp != NULL);
555
556 /*
557 * If the release is just for a recursive lock,
558 * then decrement the count and return.
559 */
560 if (bip->bli_recur > 0) {
561 bip->bli_recur--;
562 xfs_buf_item_trace("RELSE RECUR", bip);
563 return;
564 }
565
566 /*
567 * If the buffer is dirty within this transaction, we can't
568 * release it until we commit.
569 */
570 if (lidp->lid_flags & XFS_LID_DIRTY) {
571 xfs_buf_item_trace("RELSE DIRTY", bip);
572 return;
573 }
574
575 /*
576 * If the buffer has been invalidated, then we can't release
577 * it until the transaction commits to disk unless it is re-dirtied
578 * as part of this transaction. This prevents us from pulling
579 * the item from the AIL before we should.
580 */
581 if (bip->bli_flags & XFS_BLI_STALE) {
582 xfs_buf_item_trace("RELSE STALE", bip);
583 return;
584 }
585
586 ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
587 xfs_buf_item_trace("RELSE", bip);
588
589 /*
590 * Free up the log item descriptor tracking the released item.
591 */
592 xfs_trans_free_item(tp, lidp);
593
594 /*
595 * Clear the hold flag in the buf log item if it is set.
596 * We wouldn't want the next user of the buffer to
597 * get confused.
598 */
599 if (bip->bli_flags & XFS_BLI_HOLD) {
600 bip->bli_flags &= ~XFS_BLI_HOLD;
601 }
602
603 /*
604 * Drop our reference to the buf log item.
605 */
606 atomic_dec(&bip->bli_refcount);
607
608 /*
609 * If the buf item is not tracking data in the log, then
610 * we must free it before releasing the buffer back to the
611 * free pool. Before releasing the buffer to the free pool,
612 * clear the transaction pointer in b_fsprivate2 to dissolve
613 * its relation to this transaction.
614 */
615 if (!xfs_buf_item_dirty(bip)) {
616/***
617 ASSERT(bp->b_pincount == 0);
618***/
619 ASSERT(atomic_read(&bip->bli_refcount) == 0);
620 ASSERT(!(bip->bli_item.li_flags & XFS_LI_IN_AIL));
621 ASSERT(!(bip->bli_flags & XFS_BLI_INODE_ALLOC_BUF));
622 xfs_buf_item_relse(bp);
623 bip = NULL;
624 }
625 XFS_BUF_SET_FSPRIVATE2(bp, NULL);
626
627 /*
628 * If we've still got a buf log item on the buffer, then
629 * tell the AIL that the buffer is being unlocked.
630 */
631 if (bip != NULL) {
632 xfs_trans_unlocked_item(bip->bli_item.li_mountp,
633 (xfs_log_item_t*)bip);
634 }
635
636 xfs_buf_relse(bp);
637 return;
638}
639
640/*
641 * Add the locked buffer to the transaction.
642 * The buffer must be locked, and it cannot be associated with any
643 * transaction.
644 *
645 * If the buffer does not yet have a buf log item associated with it,
646 * then allocate one for it. Then add the buf item to the transaction.
647 */
648void
649xfs_trans_bjoin(xfs_trans_t *tp,
650 xfs_buf_t *bp)
651{
652 xfs_buf_log_item_t *bip;
653
654 ASSERT(XFS_BUF_ISBUSY(bp));
655 ASSERT(XFS_BUF_FSPRIVATE2(bp, void *) == NULL);
656
657 /*
658 * The xfs_buf_log_item pointer is stored in b_fsprivate. If
659 * it doesn't have one yet, then allocate one and initialize it.
660 * The checks to see if one is there are in xfs_buf_item_init().
661 */
662 xfs_buf_item_init(bp, tp->t_mountp);
663 bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *);
664 ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
665 ASSERT(!(bip->bli_format.blf_flags & XFS_BLI_CANCEL));
666 ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
667
668 /*
669 * Take a reference for this transaction on the buf item.
670 */
671 atomic_inc(&bip->bli_refcount);
672
673 /*
674 * Get a log_item_desc to point at the new item.
675 */
676 (void) xfs_trans_add_item(tp, (xfs_log_item_t *)bip);
677
678 /*
679 * Initialize b_fsprivate2 so we can find it with incore_match()
680 * in xfs_trans_get_buf() and friends above.
681 */
682 XFS_BUF_SET_FSPRIVATE2(bp, tp);
683
684 xfs_buf_item_trace("BJOIN", bip);
685}
686
687/*
688 * Mark the buffer as not needing to be unlocked when the buf item's
689 * IOP_UNLOCK() routine is called. The buffer must already be locked
690 * and associated with the given transaction.
691 */
692/* ARGSUSED */
693void
694xfs_trans_bhold(xfs_trans_t *tp,
695 xfs_buf_t *bp)
696{
697 xfs_buf_log_item_t *bip;
698
699 ASSERT(XFS_BUF_ISBUSY(bp));
700 ASSERT(XFS_BUF_FSPRIVATE2(bp, xfs_trans_t *) == tp);
701 ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL);
702
703 bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *);
704 ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
705 ASSERT(!(bip->bli_format.blf_flags & XFS_BLI_CANCEL));
706 ASSERT(atomic_read(&bip->bli_refcount) > 0);
707 bip->bli_flags |= XFS_BLI_HOLD;
708 xfs_buf_item_trace("BHOLD", bip);
709}
710
711/*
Tim Shimminefa092f2005-09-05 08:29:01 +1000712 * Cancel the previous buffer hold request made on this buffer
713 * for this transaction.
714 */
715void
716xfs_trans_bhold_release(xfs_trans_t *tp,
717 xfs_buf_t *bp)
718{
719 xfs_buf_log_item_t *bip;
720
721 ASSERT(XFS_BUF_ISBUSY(bp));
722 ASSERT(XFS_BUF_FSPRIVATE2(bp, xfs_trans_t *) == tp);
723 ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL);
724
725 bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *);
726 ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
727 ASSERT(!(bip->bli_format.blf_flags & XFS_BLI_CANCEL));
728 ASSERT(atomic_read(&bip->bli_refcount) > 0);
729 ASSERT(bip->bli_flags & XFS_BLI_HOLD);
730 bip->bli_flags &= ~XFS_BLI_HOLD;
731 xfs_buf_item_trace("BHOLD RELEASE", bip);
732}
733
734/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 * This is called to mark bytes first through last inclusive of the given
736 * buffer as needing to be logged when the transaction is committed.
737 * The buffer must already be associated with the given transaction.
738 *
739 * First and last are numbers relative to the beginning of this buffer,
740 * so the first byte in the buffer is numbered 0 regardless of the
741 * value of b_blkno.
742 */
743void
744xfs_trans_log_buf(xfs_trans_t *tp,
745 xfs_buf_t *bp,
746 uint first,
747 uint last)
748{
749 xfs_buf_log_item_t *bip;
750 xfs_log_item_desc_t *lidp;
751
752 ASSERT(XFS_BUF_ISBUSY(bp));
753 ASSERT(XFS_BUF_FSPRIVATE2(bp, xfs_trans_t *) == tp);
754 ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL);
755 ASSERT((first <= last) && (last < XFS_BUF_COUNT(bp)));
756 ASSERT((XFS_BUF_IODONE_FUNC(bp) == NULL) ||
757 (XFS_BUF_IODONE_FUNC(bp) == xfs_buf_iodone_callbacks));
758
759 /*
760 * Mark the buffer as needing to be written out eventually,
761 * and set its iodone function to remove the buffer's buf log
762 * item from the AIL and free it when the buffer is flushed
763 * to disk. See xfs_buf_attach_iodone() for more details
764 * on li_cb and xfs_buf_iodone_callbacks().
765 * If we end up aborting this transaction, we trap this buffer
766 * inside the b_bdstrat callback so that this won't get written to
767 * disk.
768 */
769 XFS_BUF_DELAYWRITE(bp);
770 XFS_BUF_DONE(bp);
771
772 bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *);
773 ASSERT(atomic_read(&bip->bli_refcount) > 0);
774 XFS_BUF_SET_IODONE_FUNC(bp, xfs_buf_iodone_callbacks);
775 bip->bli_item.li_cb = (void(*)(xfs_buf_t*,xfs_log_item_t*))xfs_buf_iodone;
776
777 /*
778 * If we invalidated the buffer within this transaction, then
779 * cancel the invalidation now that we're dirtying the buffer
780 * again. There are no races with the code in xfs_buf_item_unpin(),
781 * because we have a reference to the buffer this entire time.
782 */
783 if (bip->bli_flags & XFS_BLI_STALE) {
784 xfs_buf_item_trace("BLOG UNSTALE", bip);
785 bip->bli_flags &= ~XFS_BLI_STALE;
786 ASSERT(XFS_BUF_ISSTALE(bp));
787 XFS_BUF_UNSTALE(bp);
788 bip->bli_format.blf_flags &= ~XFS_BLI_CANCEL;
789 }
790
791 lidp = xfs_trans_find_item(tp, (xfs_log_item_t*)bip);
792 ASSERT(lidp != NULL);
793
794 tp->t_flags |= XFS_TRANS_DIRTY;
795 lidp->lid_flags |= XFS_LID_DIRTY;
796 lidp->lid_flags &= ~XFS_LID_BUF_STALE;
797 bip->bli_flags |= XFS_BLI_LOGGED;
798 xfs_buf_item_log(bip, first, last);
799 xfs_buf_item_trace("BLOG", bip);
800}
801
802
803/*
804 * This called to invalidate a buffer that is being used within
805 * a transaction. Typically this is because the blocks in the
806 * buffer are being freed, so we need to prevent it from being
807 * written out when we're done. Allowing it to be written again
808 * might overwrite data in the free blocks if they are reallocated
809 * to a file.
810 *
811 * We prevent the buffer from being written out by clearing the
812 * B_DELWRI flag. We can't always
813 * get rid of the buf log item at this point, though, because
814 * the buffer may still be pinned by another transaction. If that
815 * is the case, then we'll wait until the buffer is committed to
816 * disk for the last time (we can tell by the ref count) and
817 * free it in xfs_buf_item_unpin(). Until it is cleaned up we
818 * will keep the buffer locked so that the buffer and buf log item
819 * are not reused.
820 */
821void
822xfs_trans_binval(
823 xfs_trans_t *tp,
824 xfs_buf_t *bp)
825{
826 xfs_log_item_desc_t *lidp;
827 xfs_buf_log_item_t *bip;
828
829 ASSERT(XFS_BUF_ISBUSY(bp));
830 ASSERT(XFS_BUF_FSPRIVATE2(bp, xfs_trans_t *) == tp);
831 ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL);
832
833 bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *);
834 lidp = xfs_trans_find_item(tp, (xfs_log_item_t*)bip);
835 ASSERT(lidp != NULL);
836 ASSERT(atomic_read(&bip->bli_refcount) > 0);
837
838 if (bip->bli_flags & XFS_BLI_STALE) {
839 /*
840 * If the buffer is already invalidated, then
841 * just return.
842 */
843 ASSERT(!(XFS_BUF_ISDELAYWRITE(bp)));
844 ASSERT(XFS_BUF_ISSTALE(bp));
845 ASSERT(!(bip->bli_flags & (XFS_BLI_LOGGED | XFS_BLI_DIRTY)));
846 ASSERT(!(bip->bli_format.blf_flags & XFS_BLI_INODE_BUF));
847 ASSERT(bip->bli_format.blf_flags & XFS_BLI_CANCEL);
848 ASSERT(lidp->lid_flags & XFS_LID_DIRTY);
849 ASSERT(tp->t_flags & XFS_TRANS_DIRTY);
850 xfs_buftrace("XFS_BINVAL RECUR", bp);
851 xfs_buf_item_trace("BINVAL RECUR", bip);
852 return;
853 }
854
855 /*
856 * Clear the dirty bit in the buffer and set the STALE flag
857 * in the buf log item. The STALE flag will be used in
858 * xfs_buf_item_unpin() to determine if it should clean up
859 * when the last reference to the buf item is given up.
860 * We set the XFS_BLI_CANCEL flag in the buf log format structure
861 * and log the buf item. This will be used at recovery time
862 * to determine that copies of the buffer in the log before
863 * this should not be replayed.
864 * We mark the item descriptor and the transaction dirty so
865 * that we'll hold the buffer until after the commit.
866 *
867 * Since we're invalidating the buffer, we also clear the state
868 * about which parts of the buffer have been logged. We also
869 * clear the flag indicating that this is an inode buffer since
870 * the data in the buffer will no longer be valid.
871 *
872 * We set the stale bit in the buffer as well since we're getting
873 * rid of it.
874 */
875 XFS_BUF_UNDELAYWRITE(bp);
876 XFS_BUF_STALE(bp);
877 bip->bli_flags |= XFS_BLI_STALE;
878 bip->bli_flags &= ~(XFS_BLI_LOGGED | XFS_BLI_DIRTY);
879 bip->bli_format.blf_flags &= ~XFS_BLI_INODE_BUF;
880 bip->bli_format.blf_flags |= XFS_BLI_CANCEL;
881 memset((char *)(bip->bli_format.blf_data_map), 0,
882 (bip->bli_format.blf_map_size * sizeof(uint)));
883 lidp->lid_flags |= XFS_LID_DIRTY|XFS_LID_BUF_STALE;
884 tp->t_flags |= XFS_TRANS_DIRTY;
885 xfs_buftrace("XFS_BINVAL", bp);
886 xfs_buf_item_trace("BINVAL", bip);
887}
888
889/*
890 * This call is used to indicate that the buffer contains on-disk
891 * inodes which must be handled specially during recovery. They
892 * require special handling because only the di_next_unlinked from
893 * the inodes in the buffer should be recovered. The rest of the
894 * data in the buffer is logged via the inodes themselves.
895 *
896 * All we do is set the XFS_BLI_INODE_BUF flag in the buffer's log
897 * format structure so that we'll know what to do at recovery time.
898 */
899/* ARGSUSED */
900void
901xfs_trans_inode_buf(
902 xfs_trans_t *tp,
903 xfs_buf_t *bp)
904{
905 xfs_buf_log_item_t *bip;
906
907 ASSERT(XFS_BUF_ISBUSY(bp));
908 ASSERT(XFS_BUF_FSPRIVATE2(bp, xfs_trans_t *) == tp);
909 ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL);
910
911 bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *);
912 ASSERT(atomic_read(&bip->bli_refcount) > 0);
913
914 bip->bli_format.blf_flags |= XFS_BLI_INODE_BUF;
915}
916
917/*
918 * This call is used to indicate that the buffer is going to
919 * be staled and was an inode buffer. This means it gets
920 * special processing during unpin - where any inodes
921 * associated with the buffer should be removed from ail.
922 * There is also special processing during recovery,
923 * any replay of the inodes in the buffer needs to be
924 * prevented as the buffer may have been reused.
925 */
926void
927xfs_trans_stale_inode_buf(
928 xfs_trans_t *tp,
929 xfs_buf_t *bp)
930{
931 xfs_buf_log_item_t *bip;
932
933 ASSERT(XFS_BUF_ISBUSY(bp));
934 ASSERT(XFS_BUF_FSPRIVATE2(bp, xfs_trans_t *) == tp);
935 ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL);
936
937 bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *);
938 ASSERT(atomic_read(&bip->bli_refcount) > 0);
939
940 bip->bli_flags |= XFS_BLI_STALE_INODE;
941 bip->bli_item.li_cb = (void(*)(xfs_buf_t*,xfs_log_item_t*))
942 xfs_buf_iodone;
943}
944
945
946
947/*
948 * Mark the buffer as being one which contains newly allocated
949 * inodes. We need to make sure that even if this buffer is
950 * relogged as an 'inode buf' we still recover all of the inode
951 * images in the face of a crash. This works in coordination with
952 * xfs_buf_item_committed() to ensure that the buffer remains in the
953 * AIL at its original location even after it has been relogged.
954 */
955/* ARGSUSED */
956void
957xfs_trans_inode_alloc_buf(
958 xfs_trans_t *tp,
959 xfs_buf_t *bp)
960{
961 xfs_buf_log_item_t *bip;
962
963 ASSERT(XFS_BUF_ISBUSY(bp));
964 ASSERT(XFS_BUF_FSPRIVATE2(bp, xfs_trans_t *) == tp);
965 ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL);
966
967 bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *);
968 ASSERT(atomic_read(&bip->bli_refcount) > 0);
969
970 bip->bli_flags |= XFS_BLI_INODE_ALLOC_BUF;
971}
972
973
974/*
975 * Similar to xfs_trans_inode_buf(), this marks the buffer as a cluster of
976 * dquots. However, unlike in inode buffer recovery, dquot buffers get
977 * recovered in their entirety. (Hence, no XFS_BLI_DQUOT_ALLOC_BUF flag).
978 * The only thing that makes dquot buffers different from regular
979 * buffers is that we must not replay dquot bufs when recovering
980 * if a _corresponding_ quotaoff has happened. We also have to distinguish
981 * between usr dquot bufs and grp dquot bufs, because usr and grp quotas
982 * can be turned off independently.
983 */
984/* ARGSUSED */
985void
986xfs_trans_dquot_buf(
987 xfs_trans_t *tp,
988 xfs_buf_t *bp,
989 uint type)
990{
991 xfs_buf_log_item_t *bip;
992
993 ASSERT(XFS_BUF_ISBUSY(bp));
994 ASSERT(XFS_BUF_FSPRIVATE2(bp, xfs_trans_t *) == tp);
995 ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL);
996 ASSERT(type == XFS_BLI_UDQUOT_BUF ||
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000997 type == XFS_BLI_PDQUOT_BUF ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 type == XFS_BLI_GDQUOT_BUF);
999
1000 bip = XFS_BUF_FSPRIVATE(bp, xfs_buf_log_item_t *);
1001 ASSERT(atomic_read(&bip->bli_refcount) > 0);
1002
1003 bip->bli_format.blf_flags |= type;
1004}
1005
1006/*
1007 * Check to see if a buffer matching the given parameters is already
1008 * a part of the given transaction. Only check the first, embedded
1009 * chunk, since we don't want to spend all day scanning large transactions.
1010 */
1011STATIC xfs_buf_t *
1012xfs_trans_buf_item_match(
1013 xfs_trans_t *tp,
1014 xfs_buftarg_t *target,
1015 xfs_daddr_t blkno,
1016 int len)
1017{
1018 xfs_log_item_chunk_t *licp;
1019 xfs_log_item_desc_t *lidp;
1020 xfs_buf_log_item_t *blip;
1021 xfs_buf_t *bp;
1022 int i;
1023
1024 bp = NULL;
1025 len = BBTOB(len);
1026 licp = &tp->t_items;
1027 if (!XFS_LIC_ARE_ALL_FREE(licp)) {
1028 for (i = 0; i < licp->lic_unused; i++) {
1029 /*
1030 * Skip unoccupied slots.
1031 */
1032 if (XFS_LIC_ISFREE(licp, i)) {
1033 continue;
1034 }
1035
1036 lidp = XFS_LIC_SLOT(licp, i);
1037 blip = (xfs_buf_log_item_t *)lidp->lid_item;
1038 if (blip->bli_item.li_type != XFS_LI_BUF) {
1039 continue;
1040 }
1041
1042 bp = blip->bli_buf;
1043 if ((XFS_BUF_TARGET(bp) == target) &&
1044 (XFS_BUF_ADDR(bp) == blkno) &&
1045 (XFS_BUF_COUNT(bp) == len)) {
1046 /*
1047 * We found it. Break out and
1048 * return the pointer to the buffer.
1049 */
1050 break;
1051 } else {
1052 bp = NULL;
1053 }
1054 }
1055 }
1056 return bp;
1057}
1058
1059/*
1060 * Check to see if a buffer matching the given parameters is already
1061 * a part of the given transaction. Check all the chunks, we
1062 * want to be thorough.
1063 */
1064STATIC xfs_buf_t *
1065xfs_trans_buf_item_match_all(
1066 xfs_trans_t *tp,
1067 xfs_buftarg_t *target,
1068 xfs_daddr_t blkno,
1069 int len)
1070{
1071 xfs_log_item_chunk_t *licp;
1072 xfs_log_item_desc_t *lidp;
1073 xfs_buf_log_item_t *blip;
1074 xfs_buf_t *bp;
1075 int i;
1076
1077 bp = NULL;
1078 len = BBTOB(len);
1079 for (licp = &tp->t_items; licp != NULL; licp = licp->lic_next) {
1080 if (XFS_LIC_ARE_ALL_FREE(licp)) {
1081 ASSERT(licp == &tp->t_items);
1082 ASSERT(licp->lic_next == NULL);
1083 return NULL;
1084 }
1085 for (i = 0; i < licp->lic_unused; i++) {
1086 /*
1087 * Skip unoccupied slots.
1088 */
1089 if (XFS_LIC_ISFREE(licp, i)) {
1090 continue;
1091 }
1092
1093 lidp = XFS_LIC_SLOT(licp, i);
1094 blip = (xfs_buf_log_item_t *)lidp->lid_item;
1095 if (blip->bli_item.li_type != XFS_LI_BUF) {
1096 continue;
1097 }
1098
1099 bp = blip->bli_buf;
1100 if ((XFS_BUF_TARGET(bp) == target) &&
1101 (XFS_BUF_ADDR(bp) == blkno) &&
1102 (XFS_BUF_COUNT(bp) == len)) {
1103 /*
1104 * We found it. Break out and
1105 * return the pointer to the buffer.
1106 */
1107 return bp;
1108 }
1109 }
1110 }
1111 return NULL;
1112}