blob: 647b6f1d8923fee484ada5eea3e2e68d47df8286 [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"
Dave Chinner70a98832013-10-23 10:36:05 +110020#include "xfs_shared.h"
Dave Chinnera4fbe6a2013-10-23 10:51:50 +110021#include "xfs_format.h"
Dave Chinner239880e2013-10-23 10:50:10 +110022#include "xfs_log_format.h"
23#include "xfs_trans_resv.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include "xfs_sb.h"
25#include "xfs_ag.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include "xfs_mount.h"
Nathan Scotta844f452005-11-02 14:38:42 +110027#include "xfs_inode.h"
Dave Chinner239880e2013-10-23 10:50:10 +110028#include "xfs_trans.h"
Nathan Scotta844f452005-11-02 14:38:42 +110029#include "xfs_buf_item.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include "xfs_trans_priv.h"
31#include "xfs_error.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000032#include "xfs_trace.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
Christoph Hellwig4a5224d2010-04-18 00:10:45 +000034/*
35 * Check to see if a buffer matching the given parameters is already
36 * a part of the given transaction.
37 */
38STATIC struct xfs_buf *
39xfs_trans_buf_item_match(
40 struct xfs_trans *tp,
41 struct xfs_buftarg *target,
Dave Chinnerde2a4f52012-06-22 18:50:11 +100042 struct xfs_buf_map *map,
43 int nmaps)
Christoph Hellwig4a5224d2010-04-18 00:10:45 +000044{
Christoph Hellwige98c4142010-06-23 18:11:15 +100045 struct xfs_log_item_desc *lidp;
46 struct xfs_buf_log_item *blip;
Dave Chinnerde2a4f52012-06-22 18:50:11 +100047 int len = 0;
48 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
Dave Chinnerde2a4f52012-06-22 18:50:11 +100050 for (i = 0; i < nmaps; i++)
51 len += map[i].bm_len;
52
Christoph Hellwige98c4142010-06-23 18:11:15 +100053 list_for_each_entry(lidp, &tp->t_items, lid_trans) {
54 blip = (struct xfs_buf_log_item *)lidp->lid_item;
55 if (blip->bli_item.li_type == XFS_LI_BUF &&
Chandra Seetharaman49074c02011-07-22 23:40:40 +000056 blip->bli_buf->b_target == target &&
Dave Chinnerde2a4f52012-06-22 18:50:11 +100057 XFS_BUF_ADDR(blip->bli_buf) == map[0].bm_bn &&
58 blip->bli_buf->b_length == len) {
59 ASSERT(blip->bli_buf->b_map_count == nmaps);
Christoph Hellwige98c4142010-06-23 18:11:15 +100060 return blip->bli_buf;
Dave Chinnerde2a4f52012-06-22 18:50:11 +100061 }
Christoph Hellwig4a5224d2010-04-18 00:10:45 +000062 }
63
64 return NULL;
65}
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
Christoph Hellwigd7e84f42010-02-15 23:35:09 +000067/*
68 * Add the locked buffer to the transaction.
69 *
70 * The buffer must be locked, and it cannot be associated with any
71 * transaction.
72 *
73 * If the buffer does not yet have a buf log item associated with it,
74 * then allocate one for it. Then add the buf item to the transaction.
75 */
76STATIC void
77_xfs_trans_bjoin(
78 struct xfs_trans *tp,
79 struct xfs_buf *bp,
80 int reset_recur)
81{
82 struct xfs_buf_log_item *bip;
83
Christoph Hellwigbf9d9012011-07-13 13:43:49 +020084 ASSERT(bp->b_transp == NULL);
Christoph Hellwigd7e84f42010-02-15 23:35:09 +000085
86 /*
87 * The xfs_buf_log_item pointer is stored in b_fsprivate. If
88 * it doesn't have one yet, then allocate one and initialize it.
89 * The checks to see if one is there are in xfs_buf_item_init().
90 */
91 xfs_buf_item_init(bp, tp->t_mountp);
Christoph Hellwigadadbee2011-07-13 13:43:49 +020092 bip = bp->b_fspriv;
Christoph Hellwigd7e84f42010-02-15 23:35:09 +000093 ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
Mark Tinguely0f22f9d2012-12-04 17:18:03 -060094 ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_CANCEL));
Christoph Hellwigd7e84f42010-02-15 23:35:09 +000095 ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
96 if (reset_recur)
97 bip->bli_recur = 0;
98
99 /*
100 * Take a reference for this transaction on the buf item.
101 */
102 atomic_inc(&bip->bli_refcount);
103
104 /*
105 * Get a log_item_desc to point at the new item.
106 */
Christoph Hellwige98c4142010-06-23 18:11:15 +1000107 xfs_trans_add_item(tp, &bip->bli_item);
Christoph Hellwigd7e84f42010-02-15 23:35:09 +0000108
109 /*
110 * Initialize b_fsprivate2 so we can find it with incore_match()
111 * in xfs_trans_get_buf() and friends above.
112 */
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200113 bp->b_transp = tp;
Christoph Hellwigd7e84f42010-02-15 23:35:09 +0000114
115}
116
117void
118xfs_trans_bjoin(
119 struct xfs_trans *tp,
120 struct xfs_buf *bp)
121{
122 _xfs_trans_bjoin(tp, bp, 0);
123 trace_xfs_trans_bjoin(bp->b_fspriv);
124}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125
126/*
127 * Get and lock the buffer for the caller if it is not already
128 * locked within the given transaction. If it is already locked
129 * within the transaction, just increment its lock recursion count
130 * and return a pointer to it.
131 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 * If the transaction pointer is NULL, make this just a normal
133 * get_buf() call.
134 */
Dave Chinnerde2a4f52012-06-22 18:50:11 +1000135struct xfs_buf *
136xfs_trans_get_buf_map(
137 struct xfs_trans *tp,
138 struct xfs_buftarg *target,
139 struct xfs_buf_map *map,
140 int nmaps,
141 xfs_buf_flags_t flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142{
143 xfs_buf_t *bp;
144 xfs_buf_log_item_t *bip;
145
Dave Chinnerde2a4f52012-06-22 18:50:11 +1000146 if (!tp)
147 return xfs_buf_get_map(target, map, nmaps, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
149 /*
150 * If we find the buffer in the cache with this transaction
151 * pointer in its b_fsprivate2 field, then we know we already
152 * have it locked. In this case we just increment the lock
153 * recursion count and return the buffer to the caller.
154 */
Dave Chinnerde2a4f52012-06-22 18:50:11 +1000155 bp = xfs_trans_buf_item_match(tp, target, map, nmaps);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 if (bp != NULL) {
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200157 ASSERT(xfs_buf_islocked(bp));
Christoph Hellwigc867cb62011-10-10 16:52:46 +0000158 if (XFS_FORCED_SHUTDOWN(tp->t_mountp)) {
159 xfs_buf_stale(bp);
Christoph Hellwigc867cb62011-10-10 16:52:46 +0000160 XFS_BUF_DONE(bp);
161 }
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000162
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200163 ASSERT(bp->b_transp == tp);
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200164 bip = bp->b_fspriv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 ASSERT(bip != NULL);
166 ASSERT(atomic_read(&bip->bli_refcount) > 0);
167 bip->bli_recur++;
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000168 trace_xfs_trans_get_buf_recur(bip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 return (bp);
170 }
171
Dave Chinnerde2a4f52012-06-22 18:50:11 +1000172 bp = xfs_buf_get_map(target, map, nmaps, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 if (bp == NULL) {
174 return NULL;
175 }
176
Chandra Seetharaman5a52c2a582011-07-22 23:39:51 +0000177 ASSERT(!bp->b_error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
Christoph Hellwigd7e84f42010-02-15 23:35:09 +0000179 _xfs_trans_bjoin(tp, bp, 1);
180 trace_xfs_trans_get_buf(bp->b_fspriv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 return (bp);
182}
183
184/*
185 * Get and lock the superblock buffer of this file system for the
186 * given transaction.
187 *
188 * We don't need to use incore_match() here, because the superblock
189 * buffer is a private buffer which we keep a pointer to in the
190 * mount structure.
191 */
192xfs_buf_t *
193xfs_trans_getsb(xfs_trans_t *tp,
194 struct xfs_mount *mp,
195 int flags)
196{
197 xfs_buf_t *bp;
198 xfs_buf_log_item_t *bip;
199
200 /*
201 * Default to just trying to lock the superblock buffer
202 * if tp is NULL.
203 */
204 if (tp == NULL) {
205 return (xfs_getsb(mp, flags));
206 }
207
208 /*
209 * If the superblock buffer already has this transaction
210 * pointer in its b_fsprivate2 field, then we know we already
211 * have it locked. In this case we just increment the lock
212 * recursion count and return the buffer to the caller.
213 */
214 bp = mp->m_sb_bp;
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200215 if (bp->b_transp == tp) {
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200216 bip = bp->b_fspriv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 ASSERT(bip != NULL);
218 ASSERT(atomic_read(&bip->bli_refcount) > 0);
219 bip->bli_recur++;
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000220 trace_xfs_trans_getsb_recur(bip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 return (bp);
222 }
223
224 bp = xfs_getsb(mp, flags);
Christoph Hellwigd7e84f42010-02-15 23:35:09 +0000225 if (bp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227
Christoph Hellwigd7e84f42010-02-15 23:35:09 +0000228 _xfs_trans_bjoin(tp, bp, 1);
229 trace_xfs_trans_getsb(bp->b_fspriv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 return (bp);
231}
232
233#ifdef DEBUG
234xfs_buftarg_t *xfs_error_target;
235int xfs_do_error;
236int xfs_req_num;
237int xfs_error_mod = 33;
238#endif
239
240/*
241 * Get and lock the buffer for the caller if it is not already
242 * locked within the given transaction. If it has not yet been
243 * read in, read it from disk. If it is already locked
244 * within the transaction and already read in, just increment its
245 * lock recursion count and return a pointer to it.
246 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 * If the transaction pointer is NULL, make this just a normal
248 * read_buf() call.
249 */
250int
Dave Chinnerde2a4f52012-06-22 18:50:11 +1000251xfs_trans_read_buf_map(
252 struct xfs_mount *mp,
253 struct xfs_trans *tp,
254 struct xfs_buftarg *target,
255 struct xfs_buf_map *map,
256 int nmaps,
257 xfs_buf_flags_t flags,
Dave Chinnerc3f8fc72012-11-12 22:54:01 +1100258 struct xfs_buf **bpp,
Dave Chinner1813dd62012-11-14 17:54:40 +1100259 const struct xfs_buf_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260{
261 xfs_buf_t *bp;
262 xfs_buf_log_item_t *bip;
263 int error;
264
Dave Chinner7ca790a2012-04-23 15:58:55 +1000265 *bpp = NULL;
Dave Chinnerde2a4f52012-06-22 18:50:11 +1000266 if (!tp) {
Dave Chinner1813dd62012-11-14 17:54:40 +1100267 bp = xfs_buf_read_map(target, map, nmaps, flags, ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 if (!bp)
Christoph Hellwig0cadda12010-01-19 09:56:44 +0000269 return (flags & XBF_TRYLOCK) ?
David Chinnera3f74ff2008-03-06 13:43:42 +1100270 EAGAIN : XFS_ERROR(ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271
Chandra Seetharaman5a52c2a582011-07-22 23:39:51 +0000272 if (bp->b_error) {
273 error = bp->b_error;
Christoph Hellwig901796a2011-10-10 16:52:49 +0000274 xfs_buf_ioerror_alert(bp, __func__);
Dave Chinner7ca790a2012-04-23 15:58:55 +1000275 XFS_BUF_UNDONE(bp);
276 xfs_buf_stale(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 xfs_buf_relse(bp);
278 return error;
279 }
280#ifdef DEBUG
Julia Lawalla0f7bfd2009-07-27 18:15:25 +0200281 if (xfs_do_error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 if (xfs_error_target == target) {
283 if (((xfs_req_num++) % xfs_error_mod) == 0) {
284 xfs_buf_relse(bp);
Dave Chinner0b932cc2011-03-07 10:08:35 +1100285 xfs_debug(mp, "Returning error!");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 return XFS_ERROR(EIO);
287 }
288 }
289 }
290#endif
291 if (XFS_FORCED_SHUTDOWN(mp))
292 goto shutdown_abort;
293 *bpp = bp;
294 return 0;
295 }
296
297 /*
298 * If we find the buffer in the cache with this transaction
299 * pointer in its b_fsprivate2 field, then we know we already
300 * have it locked. If it is already read in we just increment
301 * the lock recursion count and return the buffer to the caller.
302 * If the buffer is not yet read in, then we read it in, increment
303 * the lock recursion count, and return it to the caller.
304 */
Dave Chinnerde2a4f52012-06-22 18:50:11 +1000305 bp = xfs_trans_buf_item_match(tp, target, map, nmaps);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 if (bp != NULL) {
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200307 ASSERT(xfs_buf_islocked(bp));
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200308 ASSERT(bp->b_transp == tp);
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200309 ASSERT(bp->b_fspriv != NULL);
Chandra Seetharaman5a52c2a582011-07-22 23:39:51 +0000310 ASSERT(!bp->b_error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 if (!(XFS_BUF_ISDONE(bp))) {
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000312 trace_xfs_trans_read_buf_io(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 ASSERT(!XFS_BUF_ISASYNC(bp));
Dave Chinnerc3f8fc72012-11-12 22:54:01 +1100314 ASSERT(bp->b_iodone == NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 XFS_BUF_READ(bp);
Dave Chinner1813dd62012-11-14 17:54:40 +1100316 bp->b_ops = ops;
Christoph Hellwig83a0adc2013-12-17 00:03:52 -0800317
318 /*
319 * XXX(hch): clean up the error handling here to be less
320 * of a mess..
321 */
322 if (XFS_FORCED_SHUTDOWN(mp)) {
323 trace_xfs_bdstrat_shut(bp, _RET_IP_);
324 xfs_bioerror_relse(bp);
325 } else {
326 xfs_buf_iorequest(bp);
327 }
328
Christoph Hellwig1a1a3e92010-10-06 18:41:18 +0000329 error = xfs_buf_iowait(bp);
David Chinnerd64e31a2008-04-10 12:22:17 +1000330 if (error) {
Christoph Hellwig901796a2011-10-10 16:52:49 +0000331 xfs_buf_ioerror_alert(bp, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 xfs_buf_relse(bp);
333 /*
David Chinnerd64e31a2008-04-10 12:22:17 +1000334 * We can gracefully recover from most read
335 * errors. Ones we can't are those that happen
336 * after the transaction's already dirty.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 */
338 if (tp->t_flags & XFS_TRANS_DIRTY)
339 xfs_force_shutdown(tp->t_mountp,
Nathan Scott7d04a332006-06-09 14:58:38 +1000340 SHUTDOWN_META_IO_ERROR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 return error;
342 }
343 }
344 /*
345 * We never locked this buf ourselves, so we shouldn't
346 * brelse it either. Just get out.
347 */
348 if (XFS_FORCED_SHUTDOWN(mp)) {
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000349 trace_xfs_trans_read_buf_shut(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 *bpp = NULL;
351 return XFS_ERROR(EIO);
352 }
353
354
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200355 bip = bp->b_fspriv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 bip->bli_recur++;
357
358 ASSERT(atomic_read(&bip->bli_refcount) > 0);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000359 trace_xfs_trans_read_buf_recur(bip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 *bpp = bp;
361 return 0;
362 }
363
Dave Chinner1813dd62012-11-14 17:54:40 +1100364 bp = xfs_buf_read_map(target, map, nmaps, flags, ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 if (bp == NULL) {
366 *bpp = NULL;
Dave Chinner7401aaf2011-03-26 09:14:44 +1100367 return (flags & XBF_TRYLOCK) ?
368 0 : XFS_ERROR(ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 }
Chandra Seetharaman5a52c2a582011-07-22 23:39:51 +0000370 if (bp->b_error) {
371 error = bp->b_error;
Christoph Hellwigc867cb62011-10-10 16:52:46 +0000372 xfs_buf_stale(bp);
Christoph Hellwigc867cb62011-10-10 16:52:46 +0000373 XFS_BUF_DONE(bp);
Christoph Hellwig901796a2011-10-10 16:52:49 +0000374 xfs_buf_ioerror_alert(bp, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 if (tp->t_flags & XFS_TRANS_DIRTY)
Nathan Scott7d04a332006-06-09 14:58:38 +1000376 xfs_force_shutdown(tp->t_mountp, SHUTDOWN_META_IO_ERROR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 xfs_buf_relse(bp);
378 return error;
379 }
380#ifdef DEBUG
381 if (xfs_do_error && !(tp->t_flags & XFS_TRANS_DIRTY)) {
382 if (xfs_error_target == target) {
383 if (((xfs_req_num++) % xfs_error_mod) == 0) {
384 xfs_force_shutdown(tp->t_mountp,
Nathan Scott7d04a332006-06-09 14:58:38 +1000385 SHUTDOWN_META_IO_ERROR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 xfs_buf_relse(bp);
Dave Chinner0b932cc2011-03-07 10:08:35 +1100387 xfs_debug(mp, "Returning trans error!");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 return XFS_ERROR(EIO);
389 }
390 }
391 }
392#endif
393 if (XFS_FORCED_SHUTDOWN(mp))
394 goto shutdown_abort;
395
Christoph Hellwigd7e84f42010-02-15 23:35:09 +0000396 _xfs_trans_bjoin(tp, bp, 1);
397 trace_xfs_trans_read_buf(bp->b_fspriv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 *bpp = bp;
400 return 0;
401
402shutdown_abort:
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000403 trace_xfs_trans_read_buf_shut(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 xfs_buf_relse(bp);
405 *bpp = NULL;
406 return XFS_ERROR(EIO);
407}
408
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409/*
410 * Release the buffer bp which was previously acquired with one of the
411 * xfs_trans_... buffer allocation routines if the buffer has not
412 * been modified within this transaction. If the buffer is modified
413 * within this transaction, do decrement the recursion count but do
414 * not release the buffer even if the count goes to 0. If the buffer is not
415 * modified within the transaction, decrement the recursion count and
416 * release the buffer if the recursion count goes to 0.
417 *
418 * If the buffer is to be released and it was not modified before
419 * this transaction began, then free the buf_log_item associated with it.
420 *
421 * If the transaction pointer is NULL, make this just a normal
422 * brelse() call.
423 */
424void
425xfs_trans_brelse(xfs_trans_t *tp,
426 xfs_buf_t *bp)
427{
428 xfs_buf_log_item_t *bip;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
430 /*
431 * Default to a normal brelse() call if the tp is NULL.
432 */
433 if (tp == NULL) {
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200434 ASSERT(bp->b_transp == NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 xfs_buf_relse(bp);
436 return;
437 }
438
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200439 ASSERT(bp->b_transp == tp);
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200440 bip = bp->b_fspriv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 ASSERT(bip->bli_item.li_type == XFS_LI_BUF);
442 ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
Mark Tinguely0f22f9d2012-12-04 17:18:03 -0600443 ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_CANCEL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 ASSERT(atomic_read(&bip->bli_refcount) > 0);
445
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000446 trace_xfs_trans_brelse(bip);
447
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 /*
449 * If the release is just for a recursive lock,
450 * then decrement the count and return.
451 */
452 if (bip->bli_recur > 0) {
453 bip->bli_recur--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 return;
455 }
456
457 /*
458 * If the buffer is dirty within this transaction, we can't
459 * release it until we commit.
460 */
Christoph Hellwige98c4142010-06-23 18:11:15 +1000461 if (bip->bli_item.li_desc->lid_flags & XFS_LID_DIRTY)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463
464 /*
465 * If the buffer has been invalidated, then we can't release
466 * it until the transaction commits to disk unless it is re-dirtied
467 * as part of this transaction. This prevents us from pulling
468 * the item from the AIL before we should.
469 */
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000470 if (bip->bli_flags & XFS_BLI_STALE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
473 ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474
475 /*
476 * Free up the log item descriptor tracking the released item.
477 */
Christoph Hellwige98c4142010-06-23 18:11:15 +1000478 xfs_trans_del_item(&bip->bli_item);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479
480 /*
481 * Clear the hold flag in the buf log item if it is set.
482 * We wouldn't want the next user of the buffer to
483 * get confused.
484 */
485 if (bip->bli_flags & XFS_BLI_HOLD) {
486 bip->bli_flags &= ~XFS_BLI_HOLD;
487 }
488
489 /*
490 * Drop our reference to the buf log item.
491 */
492 atomic_dec(&bip->bli_refcount);
493
494 /*
495 * If the buf item is not tracking data in the log, then
496 * we must free it before releasing the buffer back to the
497 * free pool. Before releasing the buffer to the free pool,
498 * clear the transaction pointer in b_fsprivate2 to dissolve
499 * its relation to this transaction.
500 */
501 if (!xfs_buf_item_dirty(bip)) {
502/***
503 ASSERT(bp->b_pincount == 0);
504***/
505 ASSERT(atomic_read(&bip->bli_refcount) == 0);
506 ASSERT(!(bip->bli_item.li_flags & XFS_LI_IN_AIL));
507 ASSERT(!(bip->bli_flags & XFS_BLI_INODE_ALLOC_BUF));
508 xfs_buf_item_relse(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 }
Christoph Hellwig5b03ff12012-02-20 02:31:22 +0000510
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200511 bp->b_transp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 xfs_buf_relse(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513}
514
515/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 * Mark the buffer as not needing to be unlocked when the buf item's
Dave Chinner904c17e2013-08-28 21:12:03 +1000517 * iop_unlock() routine is called. The buffer must already be locked
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 * and associated with the given transaction.
519 */
520/* ARGSUSED */
521void
522xfs_trans_bhold(xfs_trans_t *tp,
523 xfs_buf_t *bp)
524{
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200525 xfs_buf_log_item_t *bip = bp->b_fspriv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200527 ASSERT(bp->b_transp == tp);
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200528 ASSERT(bip != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
Mark Tinguely0f22f9d2012-12-04 17:18:03 -0600530 ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_CANCEL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 ASSERT(atomic_read(&bip->bli_refcount) > 0);
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200532
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 bip->bli_flags |= XFS_BLI_HOLD;
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000534 trace_xfs_trans_bhold(bip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535}
536
537/*
Tim Shimminefa092f2005-09-05 08:29:01 +1000538 * Cancel the previous buffer hold request made on this buffer
539 * for this transaction.
540 */
541void
542xfs_trans_bhold_release(xfs_trans_t *tp,
543 xfs_buf_t *bp)
544{
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200545 xfs_buf_log_item_t *bip = bp->b_fspriv;
Tim Shimminefa092f2005-09-05 08:29:01 +1000546
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200547 ASSERT(bp->b_transp == tp);
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200548 ASSERT(bip != NULL);
Tim Shimminefa092f2005-09-05 08:29:01 +1000549 ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
Mark Tinguely0f22f9d2012-12-04 17:18:03 -0600550 ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_CANCEL));
Tim Shimminefa092f2005-09-05 08:29:01 +1000551 ASSERT(atomic_read(&bip->bli_refcount) > 0);
552 ASSERT(bip->bli_flags & XFS_BLI_HOLD);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000553
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200554 bip->bli_flags &= ~XFS_BLI_HOLD;
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000555 trace_xfs_trans_bhold_release(bip);
Tim Shimminefa092f2005-09-05 08:29:01 +1000556}
557
558/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 * This is called to mark bytes first through last inclusive of the given
560 * buffer as needing to be logged when the transaction is committed.
561 * The buffer must already be associated with the given transaction.
562 *
563 * First and last are numbers relative to the beginning of this buffer,
564 * so the first byte in the buffer is numbered 0 regardless of the
565 * value of b_blkno.
566 */
567void
568xfs_trans_log_buf(xfs_trans_t *tp,
569 xfs_buf_t *bp,
570 uint first,
571 uint last)
572{
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200573 xfs_buf_log_item_t *bip = bp->b_fspriv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200575 ASSERT(bp->b_transp == tp);
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200576 ASSERT(bip != NULL);
Dave Chinneraa0e8832012-04-23 15:58:52 +1000577 ASSERT(first <= last && last < BBTOB(bp->b_length));
Christoph Hellwigcb669ca2011-07-13 13:43:49 +0200578 ASSERT(bp->b_iodone == NULL ||
579 bp->b_iodone == xfs_buf_iodone_callbacks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580
581 /*
582 * Mark the buffer as needing to be written out eventually,
583 * and set its iodone function to remove the buffer's buf log
584 * item from the AIL and free it when the buffer is flushed
585 * to disk. See xfs_buf_attach_iodone() for more details
586 * on li_cb and xfs_buf_iodone_callbacks().
587 * If we end up aborting this transaction, we trap this buffer
588 * inside the b_bdstrat callback so that this won't get written to
589 * disk.
590 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 XFS_BUF_DONE(bp);
592
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 ASSERT(atomic_read(&bip->bli_refcount) > 0);
Christoph Hellwigcb669ca2011-07-13 13:43:49 +0200594 bp->b_iodone = xfs_buf_iodone_callbacks;
Christoph Hellwigca30b2a2010-06-23 18:11:15 +1000595 bip->bli_item.li_cb = xfs_buf_iodone;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000597 trace_xfs_trans_log_buf(bip);
598
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 /*
600 * If we invalidated the buffer within this transaction, then
601 * cancel the invalidation now that we're dirtying the buffer
602 * again. There are no races with the code in xfs_buf_item_unpin(),
603 * because we have a reference to the buffer this entire time.
604 */
605 if (bip->bli_flags & XFS_BLI_STALE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 bip->bli_flags &= ~XFS_BLI_STALE;
607 ASSERT(XFS_BUF_ISSTALE(bp));
608 XFS_BUF_UNSTALE(bp);
Mark Tinguely0f22f9d2012-12-04 17:18:03 -0600609 bip->__bli_format.blf_flags &= ~XFS_BLF_CANCEL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 }
611
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 tp->t_flags |= XFS_TRANS_DIRTY;
Christoph Hellwige98c4142010-06-23 18:11:15 +1000613 bip->bli_item.li_desc->lid_flags |= XFS_LID_DIRTY;
Dave Chinner5f6bed72013-06-27 16:04:52 +1000614
615 /*
616 * If we have an ordered buffer we are not logging any dirty range but
617 * it still needs to be marked dirty and that it has been logged.
618 */
619 bip->bli_flags |= XFS_BLI_DIRTY | XFS_BLI_LOGGED;
620 if (!(bip->bli_flags & XFS_BLI_ORDERED))
621 xfs_buf_item_log(bip, first, last);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622}
623
624
625/*
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000626 * Invalidate a buffer that is being used within a transaction.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 *
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000628 * Typically this is because the blocks in the buffer are being freed, so we
629 * need to prevent it from being written out when we're done. Allowing it
630 * to be written again might overwrite data in the free blocks if they are
631 * reallocated to a file.
632 *
633 * We prevent the buffer from being written out by marking it stale. We can't
634 * get rid of the buf log item at this point because the buffer may still be
635 * pinned by another transaction. If that is the case, then we'll wait until
636 * the buffer is committed to disk for the last time (we can tell by the ref
637 * count) and free it in xfs_buf_item_unpin(). Until that happens we will
638 * keep the buffer locked so that the buffer and buf log item are not reused.
639 *
640 * We also set the XFS_BLF_CANCEL flag in the buf log format structure and log
641 * the buf item. This will be used at recovery time to determine that copies
642 * of the buffer in the log before this should not be replayed.
643 *
644 * We mark the item descriptor and the transaction dirty so that we'll hold
645 * the buffer until after the commit.
646 *
647 * Since we're invalidating the buffer, we also clear the state about which
648 * parts of the buffer have been logged. We also clear the flag indicating
649 * that this is an inode buffer since the data in the buffer will no longer
650 * be valid.
651 *
652 * We set the stale bit in the buffer as well since we're getting rid of it.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 */
654void
655xfs_trans_binval(
656 xfs_trans_t *tp,
657 xfs_buf_t *bp)
658{
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200659 xfs_buf_log_item_t *bip = bp->b_fspriv;
Mark Tinguely91e4bac2012-12-04 17:18:05 -0600660 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200662 ASSERT(bp->b_transp == tp);
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200663 ASSERT(bip != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 ASSERT(atomic_read(&bip->bli_refcount) > 0);
665
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000666 trace_xfs_trans_binval(bip);
667
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 if (bip->bli_flags & XFS_BLI_STALE) {
669 /*
670 * If the buffer is already invalidated, then
671 * just return.
672 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 ASSERT(XFS_BUF_ISSTALE(bp));
674 ASSERT(!(bip->bli_flags & (XFS_BLI_LOGGED | XFS_BLI_DIRTY)));
Mark Tinguely0f22f9d2012-12-04 17:18:03 -0600675 ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_INODE_BUF));
Dave Chinner61fe1352013-04-03 16:11:30 +1100676 ASSERT(!(bip->__bli_format.blf_flags & XFS_BLFT_MASK));
Mark Tinguely0f22f9d2012-12-04 17:18:03 -0600677 ASSERT(bip->__bli_format.blf_flags & XFS_BLF_CANCEL);
Christoph Hellwige98c4142010-06-23 18:11:15 +1000678 ASSERT(bip->bli_item.li_desc->lid_flags & XFS_LID_DIRTY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 ASSERT(tp->t_flags & XFS_TRANS_DIRTY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 return;
681 }
682
Christoph Hellwigc867cb62011-10-10 16:52:46 +0000683 xfs_buf_stale(bp);
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000684
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 bip->bli_flags |= XFS_BLI_STALE;
Dave Chinnerccf7c232010-05-20 23:19:42 +1000686 bip->bli_flags &= ~(XFS_BLI_INODE_BUF | XFS_BLI_LOGGED | XFS_BLI_DIRTY);
Mark Tinguely0f22f9d2012-12-04 17:18:03 -0600687 bip->__bli_format.blf_flags &= ~XFS_BLF_INODE_BUF;
688 bip->__bli_format.blf_flags |= XFS_BLF_CANCEL;
Dave Chinner61fe1352013-04-03 16:11:30 +1100689 bip->__bli_format.blf_flags &= ~XFS_BLFT_MASK;
Mark Tinguely91e4bac2012-12-04 17:18:05 -0600690 for (i = 0; i < bip->bli_format_count; i++) {
691 memset(bip->bli_formats[i].blf_data_map, 0,
692 (bip->bli_formats[i].blf_map_size * sizeof(uint)));
693 }
Christoph Hellwige98c4142010-06-23 18:11:15 +1000694 bip->bli_item.li_desc->lid_flags |= XFS_LID_DIRTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 tp->t_flags |= XFS_TRANS_DIRTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696}
697
698/*
Dave Chinnerccf7c232010-05-20 23:19:42 +1000699 * This call is used to indicate that the buffer contains on-disk inodes which
700 * must be handled specially during recovery. They require special handling
701 * because only the di_next_unlinked from the inodes in the buffer should be
702 * recovered. The rest of the data in the buffer is logged via the inodes
703 * themselves.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 *
Dave Chinnerccf7c232010-05-20 23:19:42 +1000705 * All we do is set the XFS_BLI_INODE_BUF flag in the items flags so it can be
706 * transferred to the buffer's log format structure so that we'll know what to
707 * do at recovery time.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709void
710xfs_trans_inode_buf(
711 xfs_trans_t *tp,
712 xfs_buf_t *bp)
713{
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200714 xfs_buf_log_item_t *bip = bp->b_fspriv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200716 ASSERT(bp->b_transp == tp);
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200717 ASSERT(bip != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 ASSERT(atomic_read(&bip->bli_refcount) > 0);
719
Dave Chinnerccf7c232010-05-20 23:19:42 +1000720 bip->bli_flags |= XFS_BLI_INODE_BUF;
Dave Chinner61fe1352013-04-03 16:11:30 +1100721 xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DINO_BUF);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722}
723
724/*
725 * This call is used to indicate that the buffer is going to
726 * be staled and was an inode buffer. This means it gets
Christoph Hellwig93848a92013-04-03 16:11:17 +1100727 * special processing during unpin - where any inodes
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 * associated with the buffer should be removed from ail.
729 * There is also special processing during recovery,
730 * any replay of the inodes in the buffer needs to be
731 * prevented as the buffer may have been reused.
732 */
733void
734xfs_trans_stale_inode_buf(
735 xfs_trans_t *tp,
736 xfs_buf_t *bp)
737{
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200738 xfs_buf_log_item_t *bip = bp->b_fspriv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200740 ASSERT(bp->b_transp == tp);
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200741 ASSERT(bip != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 ASSERT(atomic_read(&bip->bli_refcount) > 0);
743
744 bip->bli_flags |= XFS_BLI_STALE_INODE;
Christoph Hellwigca30b2a2010-06-23 18:11:15 +1000745 bip->bli_item.li_cb = xfs_buf_iodone;
Dave Chinner61fe1352013-04-03 16:11:30 +1100746 xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DINO_BUF);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747}
748
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749/*
750 * Mark the buffer as being one which contains newly allocated
751 * inodes. We need to make sure that even if this buffer is
752 * relogged as an 'inode buf' we still recover all of the inode
753 * images in the face of a crash. This works in coordination with
754 * xfs_buf_item_committed() to ensure that the buffer remains in the
755 * AIL at its original location even after it has been relogged.
756 */
757/* ARGSUSED */
758void
759xfs_trans_inode_alloc_buf(
760 xfs_trans_t *tp,
761 xfs_buf_t *bp)
762{
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200763 xfs_buf_log_item_t *bip = bp->b_fspriv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200765 ASSERT(bp->b_transp == tp);
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200766 ASSERT(bip != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 ASSERT(atomic_read(&bip->bli_refcount) > 0);
768
769 bip->bli_flags |= XFS_BLI_INODE_ALLOC_BUF;
Dave Chinner61fe1352013-04-03 16:11:30 +1100770 xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DINO_BUF);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771}
772
Christoph Hellwigee1a47a2013-04-21 14:53:46 -0500773/*
Dave Chinner5f6bed72013-06-27 16:04:52 +1000774 * Mark the buffer as ordered for this transaction. This means
775 * that the contents of the buffer are not recorded in the transaction
776 * but it is tracked in the AIL as though it was. This allows us
777 * to record logical changes in transactions rather than the physical
778 * changes we make to the buffer without changing writeback ordering
779 * constraints of metadata buffers.
780 */
781void
782xfs_trans_ordered_buf(
783 struct xfs_trans *tp,
784 struct xfs_buf *bp)
785{
786 struct xfs_buf_log_item *bip = bp->b_fspriv;
787
788 ASSERT(bp->b_transp == tp);
789 ASSERT(bip != NULL);
790 ASSERT(atomic_read(&bip->bli_refcount) > 0);
791
792 bip->bli_flags |= XFS_BLI_ORDERED;
793 trace_xfs_buf_item_ordered(bip);
794}
795
796/*
Christoph Hellwigee1a47a2013-04-21 14:53:46 -0500797 * Set the type of the buffer for log recovery so that it can correctly identify
798 * and hence attach the correct buffer ops to the buffer after replay.
799 */
800void
801xfs_trans_buf_set_type(
802 struct xfs_trans *tp,
803 struct xfs_buf *bp,
Dave Chinner61fe1352013-04-03 16:11:30 +1100804 enum xfs_blft type)
Christoph Hellwigee1a47a2013-04-21 14:53:46 -0500805{
806 struct xfs_buf_log_item *bip = bp->b_fspriv;
807
Dave Chinnerd75afeb2013-04-03 16:11:29 +1100808 if (!tp)
809 return;
810
Christoph Hellwigee1a47a2013-04-21 14:53:46 -0500811 ASSERT(bp->b_transp == tp);
812 ASSERT(bip != NULL);
813 ASSERT(atomic_read(&bip->bli_refcount) > 0);
Christoph Hellwigee1a47a2013-04-21 14:53:46 -0500814
Dave Chinner61fe1352013-04-03 16:11:30 +1100815 xfs_blft_to_flags(&bip->__bli_format, type);
Christoph Hellwigee1a47a2013-04-21 14:53:46 -0500816}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817
Dave Chinnerd75afeb2013-04-03 16:11:29 +1100818void
819xfs_trans_buf_copy_type(
820 struct xfs_buf *dst_bp,
821 struct xfs_buf *src_bp)
822{
823 struct xfs_buf_log_item *sbip = src_bp->b_fspriv;
824 struct xfs_buf_log_item *dbip = dst_bp->b_fspriv;
Dave Chinner61fe1352013-04-03 16:11:30 +1100825 enum xfs_blft type;
Dave Chinnerd75afeb2013-04-03 16:11:29 +1100826
Dave Chinner61fe1352013-04-03 16:11:30 +1100827 type = xfs_blft_from_flags(&sbip->__bli_format);
828 xfs_blft_to_flags(&dbip->__bli_format, type);
Dave Chinnerd75afeb2013-04-03 16:11:29 +1100829}
830
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831/*
832 * Similar to xfs_trans_inode_buf(), this marks the buffer as a cluster of
833 * dquots. However, unlike in inode buffer recovery, dquot buffers get
834 * recovered in their entirety. (Hence, no XFS_BLI_DQUOT_ALLOC_BUF flag).
835 * The only thing that makes dquot buffers different from regular
836 * buffers is that we must not replay dquot bufs when recovering
837 * if a _corresponding_ quotaoff has happened. We also have to distinguish
838 * between usr dquot bufs and grp dquot bufs, because usr and grp quotas
839 * can be turned off independently.
840 */
841/* ARGSUSED */
842void
843xfs_trans_dquot_buf(
844 xfs_trans_t *tp,
845 xfs_buf_t *bp,
846 uint type)
847{
Dave Chinner61fe1352013-04-03 16:11:30 +1100848 struct xfs_buf_log_item *bip = bp->b_fspriv;
849
Dave Chinnerc1155412010-05-07 11:05:19 +1000850 ASSERT(type == XFS_BLF_UDQUOT_BUF ||
851 type == XFS_BLF_PDQUOT_BUF ||
852 type == XFS_BLF_GDQUOT_BUF);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853
Dave Chinner61fe1352013-04-03 16:11:30 +1100854 bip->__bli_format.blf_flags |= type;
855
856 switch (type) {
857 case XFS_BLF_UDQUOT_BUF:
858 type = XFS_BLFT_UDQUOT_BUF;
859 break;
860 case XFS_BLF_PDQUOT_BUF:
861 type = XFS_BLFT_PDQUOT_BUF;
862 break;
863 case XFS_BLF_GDQUOT_BUF:
864 type = XFS_BLFT_GDQUOT_BUF;
865 break;
866 default:
867 type = XFS_BLFT_UNKNOWN_BUF;
868 break;
869 }
870
Christoph Hellwigee1a47a2013-04-21 14:53:46 -0500871 xfs_trans_buf_set_type(tp, bp, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872}