blob: c035d11b7734196c4fd689121d945e598a8d6d7a [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 Chinner70a9883c2013-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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 xfsbdstrat(tp->t_mountp, bp);
Christoph Hellwig1a1a3e92010-10-06 18:41:18 +0000318 error = xfs_buf_iowait(bp);
David Chinnerd64e31a2008-04-10 12:22:17 +1000319 if (error) {
Christoph Hellwig901796a2011-10-10 16:52:49 +0000320 xfs_buf_ioerror_alert(bp, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 xfs_buf_relse(bp);
322 /*
David Chinnerd64e31a2008-04-10 12:22:17 +1000323 * We can gracefully recover from most read
324 * errors. Ones we can't are those that happen
325 * after the transaction's already dirty.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 */
327 if (tp->t_flags & XFS_TRANS_DIRTY)
328 xfs_force_shutdown(tp->t_mountp,
Nathan Scott7d04a332006-06-09 14:58:38 +1000329 SHUTDOWN_META_IO_ERROR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 return error;
331 }
332 }
333 /*
334 * We never locked this buf ourselves, so we shouldn't
335 * brelse it either. Just get out.
336 */
337 if (XFS_FORCED_SHUTDOWN(mp)) {
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000338 trace_xfs_trans_read_buf_shut(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 *bpp = NULL;
340 return XFS_ERROR(EIO);
341 }
342
343
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200344 bip = bp->b_fspriv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 bip->bli_recur++;
346
347 ASSERT(atomic_read(&bip->bli_refcount) > 0);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000348 trace_xfs_trans_read_buf_recur(bip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 *bpp = bp;
350 return 0;
351 }
352
Dave Chinner1813dd62012-11-14 17:54:40 +1100353 bp = xfs_buf_read_map(target, map, nmaps, flags, ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 if (bp == NULL) {
355 *bpp = NULL;
Dave Chinner7401aaf2011-03-26 09:14:44 +1100356 return (flags & XBF_TRYLOCK) ?
357 0 : XFS_ERROR(ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 }
Chandra Seetharaman5a52c2a582011-07-22 23:39:51 +0000359 if (bp->b_error) {
360 error = bp->b_error;
Christoph Hellwigc867cb62011-10-10 16:52:46 +0000361 xfs_buf_stale(bp);
Christoph Hellwigc867cb62011-10-10 16:52:46 +0000362 XFS_BUF_DONE(bp);
Christoph Hellwig901796a2011-10-10 16:52:49 +0000363 xfs_buf_ioerror_alert(bp, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 if (tp->t_flags & XFS_TRANS_DIRTY)
Nathan Scott7d04a332006-06-09 14:58:38 +1000365 xfs_force_shutdown(tp->t_mountp, SHUTDOWN_META_IO_ERROR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 xfs_buf_relse(bp);
367 return error;
368 }
369#ifdef DEBUG
370 if (xfs_do_error && !(tp->t_flags & XFS_TRANS_DIRTY)) {
371 if (xfs_error_target == target) {
372 if (((xfs_req_num++) % xfs_error_mod) == 0) {
373 xfs_force_shutdown(tp->t_mountp,
Nathan Scott7d04a332006-06-09 14:58:38 +1000374 SHUTDOWN_META_IO_ERROR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 xfs_buf_relse(bp);
Dave Chinner0b932cc2011-03-07 10:08:35 +1100376 xfs_debug(mp, "Returning trans error!");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 return XFS_ERROR(EIO);
378 }
379 }
380 }
381#endif
382 if (XFS_FORCED_SHUTDOWN(mp))
383 goto shutdown_abort;
384
Christoph Hellwigd7e84f42010-02-15 23:35:09 +0000385 _xfs_trans_bjoin(tp, bp, 1);
386 trace_xfs_trans_read_buf(bp->b_fspriv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 *bpp = bp;
389 return 0;
390
391shutdown_abort:
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000392 trace_xfs_trans_read_buf_shut(bp, _RET_IP_);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 xfs_buf_relse(bp);
394 *bpp = NULL;
395 return XFS_ERROR(EIO);
396}
397
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398/*
399 * Release the buffer bp which was previously acquired with one of the
400 * xfs_trans_... buffer allocation routines if the buffer has not
401 * been modified within this transaction. If the buffer is modified
402 * within this transaction, do decrement the recursion count but do
403 * not release the buffer even if the count goes to 0. If the buffer is not
404 * modified within the transaction, decrement the recursion count and
405 * release the buffer if the recursion count goes to 0.
406 *
407 * If the buffer is to be released and it was not modified before
408 * this transaction began, then free the buf_log_item associated with it.
409 *
410 * If the transaction pointer is NULL, make this just a normal
411 * brelse() call.
412 */
413void
414xfs_trans_brelse(xfs_trans_t *tp,
415 xfs_buf_t *bp)
416{
417 xfs_buf_log_item_t *bip;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418
419 /*
420 * Default to a normal brelse() call if the tp is NULL.
421 */
422 if (tp == NULL) {
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200423 ASSERT(bp->b_transp == NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 xfs_buf_relse(bp);
425 return;
426 }
427
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200428 ASSERT(bp->b_transp == tp);
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200429 bip = bp->b_fspriv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 ASSERT(bip->bli_item.li_type == XFS_LI_BUF);
431 ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
Mark Tinguely0f22f9d2012-12-04 17:18:03 -0600432 ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_CANCEL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 ASSERT(atomic_read(&bip->bli_refcount) > 0);
434
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000435 trace_xfs_trans_brelse(bip);
436
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 /*
438 * If the release is just for a recursive lock,
439 * then decrement the count and return.
440 */
441 if (bip->bli_recur > 0) {
442 bip->bli_recur--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 return;
444 }
445
446 /*
447 * If the buffer is dirty within this transaction, we can't
448 * release it until we commit.
449 */
Christoph Hellwige98c4142010-06-23 18:11:15 +1000450 if (bip->bli_item.li_desc->lid_flags & XFS_LID_DIRTY)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452
453 /*
454 * If the buffer has been invalidated, then we can't release
455 * it until the transaction commits to disk unless it is re-dirtied
456 * as part of this transaction. This prevents us from pulling
457 * the item from the AIL before we should.
458 */
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000459 if (bip->bli_flags & XFS_BLI_STALE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461
462 ASSERT(!(bip->bli_flags & XFS_BLI_LOGGED));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463
464 /*
465 * Free up the log item descriptor tracking the released item.
466 */
Christoph Hellwige98c4142010-06-23 18:11:15 +1000467 xfs_trans_del_item(&bip->bli_item);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468
469 /*
470 * Clear the hold flag in the buf log item if it is set.
471 * We wouldn't want the next user of the buffer to
472 * get confused.
473 */
474 if (bip->bli_flags & XFS_BLI_HOLD) {
475 bip->bli_flags &= ~XFS_BLI_HOLD;
476 }
477
478 /*
479 * Drop our reference to the buf log item.
480 */
481 atomic_dec(&bip->bli_refcount);
482
483 /*
484 * If the buf item is not tracking data in the log, then
485 * we must free it before releasing the buffer back to the
486 * free pool. Before releasing the buffer to the free pool,
487 * clear the transaction pointer in b_fsprivate2 to dissolve
488 * its relation to this transaction.
489 */
490 if (!xfs_buf_item_dirty(bip)) {
491/***
492 ASSERT(bp->b_pincount == 0);
493***/
494 ASSERT(atomic_read(&bip->bli_refcount) == 0);
495 ASSERT(!(bip->bli_item.li_flags & XFS_LI_IN_AIL));
496 ASSERT(!(bip->bli_flags & XFS_BLI_INODE_ALLOC_BUF));
497 xfs_buf_item_relse(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 }
Christoph Hellwig5b03ff12012-02-20 02:31:22 +0000499
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200500 bp->b_transp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 xfs_buf_relse(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502}
503
504/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 * Mark the buffer as not needing to be unlocked when the buf item's
Dave Chinner904c17e2013-08-28 21:12:03 +1000506 * iop_unlock() routine is called. The buffer must already be locked
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 * and associated with the given transaction.
508 */
509/* ARGSUSED */
510void
511xfs_trans_bhold(xfs_trans_t *tp,
512 xfs_buf_t *bp)
513{
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200514 xfs_buf_log_item_t *bip = bp->b_fspriv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200516 ASSERT(bp->b_transp == tp);
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200517 ASSERT(bip != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
Mark Tinguely0f22f9d2012-12-04 17:18:03 -0600519 ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_CANCEL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 ASSERT(atomic_read(&bip->bli_refcount) > 0);
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200521
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 bip->bli_flags |= XFS_BLI_HOLD;
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000523 trace_xfs_trans_bhold(bip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524}
525
526/*
Tim Shimminefa092f2005-09-05 08:29:01 +1000527 * Cancel the previous buffer hold request made on this buffer
528 * for this transaction.
529 */
530void
531xfs_trans_bhold_release(xfs_trans_t *tp,
532 xfs_buf_t *bp)
533{
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200534 xfs_buf_log_item_t *bip = bp->b_fspriv;
Tim Shimminefa092f2005-09-05 08:29:01 +1000535
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200536 ASSERT(bp->b_transp == tp);
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200537 ASSERT(bip != NULL);
Tim Shimminefa092f2005-09-05 08:29:01 +1000538 ASSERT(!(bip->bli_flags & XFS_BLI_STALE));
Mark Tinguely0f22f9d2012-12-04 17:18:03 -0600539 ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_CANCEL));
Tim Shimminefa092f2005-09-05 08:29:01 +1000540 ASSERT(atomic_read(&bip->bli_refcount) > 0);
541 ASSERT(bip->bli_flags & XFS_BLI_HOLD);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000542
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200543 bip->bli_flags &= ~XFS_BLI_HOLD;
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000544 trace_xfs_trans_bhold_release(bip);
Tim Shimminefa092f2005-09-05 08:29:01 +1000545}
546
547/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 * This is called to mark bytes first through last inclusive of the given
549 * buffer as needing to be logged when the transaction is committed.
550 * The buffer must already be associated with the given transaction.
551 *
552 * First and last are numbers relative to the beginning of this buffer,
553 * so the first byte in the buffer is numbered 0 regardless of the
554 * value of b_blkno.
555 */
556void
557xfs_trans_log_buf(xfs_trans_t *tp,
558 xfs_buf_t *bp,
559 uint first,
560 uint last)
561{
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200562 xfs_buf_log_item_t *bip = bp->b_fspriv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200564 ASSERT(bp->b_transp == tp);
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200565 ASSERT(bip != NULL);
Dave Chinneraa0e8832012-04-23 15:58:52 +1000566 ASSERT(first <= last && last < BBTOB(bp->b_length));
Christoph Hellwigcb669ca2011-07-13 13:43:49 +0200567 ASSERT(bp->b_iodone == NULL ||
568 bp->b_iodone == xfs_buf_iodone_callbacks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
570 /*
571 * Mark the buffer as needing to be written out eventually,
572 * and set its iodone function to remove the buffer's buf log
573 * item from the AIL and free it when the buffer is flushed
574 * to disk. See xfs_buf_attach_iodone() for more details
575 * on li_cb and xfs_buf_iodone_callbacks().
576 * If we end up aborting this transaction, we trap this buffer
577 * inside the b_bdstrat callback so that this won't get written to
578 * disk.
579 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 XFS_BUF_DONE(bp);
581
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 ASSERT(atomic_read(&bip->bli_refcount) > 0);
Christoph Hellwigcb669ca2011-07-13 13:43:49 +0200583 bp->b_iodone = xfs_buf_iodone_callbacks;
Christoph Hellwigca30b2a2010-06-23 18:11:15 +1000584 bip->bli_item.li_cb = xfs_buf_iodone;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000586 trace_xfs_trans_log_buf(bip);
587
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 /*
589 * If we invalidated the buffer within this transaction, then
590 * cancel the invalidation now that we're dirtying the buffer
591 * again. There are no races with the code in xfs_buf_item_unpin(),
592 * because we have a reference to the buffer this entire time.
593 */
594 if (bip->bli_flags & XFS_BLI_STALE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 bip->bli_flags &= ~XFS_BLI_STALE;
596 ASSERT(XFS_BUF_ISSTALE(bp));
597 XFS_BUF_UNSTALE(bp);
Mark Tinguely0f22f9d2012-12-04 17:18:03 -0600598 bip->__bli_format.blf_flags &= ~XFS_BLF_CANCEL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 }
600
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 tp->t_flags |= XFS_TRANS_DIRTY;
Christoph Hellwige98c4142010-06-23 18:11:15 +1000602 bip->bli_item.li_desc->lid_flags |= XFS_LID_DIRTY;
Dave Chinner5f6bed72013-06-27 16:04:52 +1000603
604 /*
605 * If we have an ordered buffer we are not logging any dirty range but
606 * it still needs to be marked dirty and that it has been logged.
607 */
608 bip->bli_flags |= XFS_BLI_DIRTY | XFS_BLI_LOGGED;
609 if (!(bip->bli_flags & XFS_BLI_ORDERED))
610 xfs_buf_item_log(bip, first, last);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611}
612
613
614/*
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000615 * Invalidate a buffer that is being used within a transaction.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 *
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000617 * Typically this is because the blocks in the buffer are being freed, so we
618 * need to prevent it from being written out when we're done. Allowing it
619 * to be written again might overwrite data in the free blocks if they are
620 * reallocated to a file.
621 *
622 * We prevent the buffer from being written out by marking it stale. We can't
623 * get rid of the buf log item at this point because the buffer may still be
624 * pinned by another transaction. If that is the case, then we'll wait until
625 * the buffer is committed to disk for the last time (we can tell by the ref
626 * count) and free it in xfs_buf_item_unpin(). Until that happens we will
627 * keep the buffer locked so that the buffer and buf log item are not reused.
628 *
629 * We also set the XFS_BLF_CANCEL flag in the buf log format structure and log
630 * the buf item. This will be used at recovery time to determine that copies
631 * of the buffer in the log before this should not be replayed.
632 *
633 * We mark the item descriptor and the transaction dirty so that we'll hold
634 * the buffer until after the commit.
635 *
636 * Since we're invalidating the buffer, we also clear the state about which
637 * parts of the buffer have been logged. We also clear the flag indicating
638 * that this is an inode buffer since the data in the buffer will no longer
639 * be valid.
640 *
641 * We set the stale bit in the buffer as well since we're getting rid of it.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 */
643void
644xfs_trans_binval(
645 xfs_trans_t *tp,
646 xfs_buf_t *bp)
647{
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200648 xfs_buf_log_item_t *bip = bp->b_fspriv;
Mark Tinguely91e4bac2012-12-04 17:18:05 -0600649 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200651 ASSERT(bp->b_transp == tp);
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200652 ASSERT(bip != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 ASSERT(atomic_read(&bip->bli_refcount) > 0);
654
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000655 trace_xfs_trans_binval(bip);
656
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 if (bip->bli_flags & XFS_BLI_STALE) {
658 /*
659 * If the buffer is already invalidated, then
660 * just return.
661 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 ASSERT(XFS_BUF_ISSTALE(bp));
663 ASSERT(!(bip->bli_flags & (XFS_BLI_LOGGED | XFS_BLI_DIRTY)));
Mark Tinguely0f22f9d2012-12-04 17:18:03 -0600664 ASSERT(!(bip->__bli_format.blf_flags & XFS_BLF_INODE_BUF));
Dave Chinner61fe1352013-04-03 16:11:30 +1100665 ASSERT(!(bip->__bli_format.blf_flags & XFS_BLFT_MASK));
Mark Tinguely0f22f9d2012-12-04 17:18:03 -0600666 ASSERT(bip->__bli_format.blf_flags & XFS_BLF_CANCEL);
Christoph Hellwige98c4142010-06-23 18:11:15 +1000667 ASSERT(bip->bli_item.li_desc->lid_flags & XFS_LID_DIRTY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 ASSERT(tp->t_flags & XFS_TRANS_DIRTY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 return;
670 }
671
Christoph Hellwigc867cb62011-10-10 16:52:46 +0000672 xfs_buf_stale(bp);
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000673
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 bip->bli_flags |= XFS_BLI_STALE;
Dave Chinnerccf7c232010-05-20 23:19:42 +1000675 bip->bli_flags &= ~(XFS_BLI_INODE_BUF | XFS_BLI_LOGGED | XFS_BLI_DIRTY);
Mark Tinguely0f22f9d2012-12-04 17:18:03 -0600676 bip->__bli_format.blf_flags &= ~XFS_BLF_INODE_BUF;
677 bip->__bli_format.blf_flags |= XFS_BLF_CANCEL;
Dave Chinner61fe1352013-04-03 16:11:30 +1100678 bip->__bli_format.blf_flags &= ~XFS_BLFT_MASK;
Mark Tinguely91e4bac2012-12-04 17:18:05 -0600679 for (i = 0; i < bip->bli_format_count; i++) {
680 memset(bip->bli_formats[i].blf_data_map, 0,
681 (bip->bli_formats[i].blf_map_size * sizeof(uint)));
682 }
Christoph Hellwige98c4142010-06-23 18:11:15 +1000683 bip->bli_item.li_desc->lid_flags |= XFS_LID_DIRTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 tp->t_flags |= XFS_TRANS_DIRTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685}
686
687/*
Dave Chinnerccf7c232010-05-20 23:19:42 +1000688 * This call is used to indicate that the buffer contains on-disk inodes which
689 * must be handled specially during recovery. They require special handling
690 * because only the di_next_unlinked from the inodes in the buffer should be
691 * recovered. The rest of the data in the buffer is logged via the inodes
692 * themselves.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 *
Dave Chinnerccf7c232010-05-20 23:19:42 +1000694 * All we do is set the XFS_BLI_INODE_BUF flag in the items flags so it can be
695 * transferred to the buffer's log format structure so that we'll know what to
696 * do at recovery time.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698void
699xfs_trans_inode_buf(
700 xfs_trans_t *tp,
701 xfs_buf_t *bp)
702{
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200703 xfs_buf_log_item_t *bip = bp->b_fspriv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200705 ASSERT(bp->b_transp == tp);
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200706 ASSERT(bip != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 ASSERT(atomic_read(&bip->bli_refcount) > 0);
708
Dave Chinnerccf7c232010-05-20 23:19:42 +1000709 bip->bli_flags |= XFS_BLI_INODE_BUF;
Dave Chinner61fe1352013-04-03 16:11:30 +1100710 xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DINO_BUF);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711}
712
713/*
714 * This call is used to indicate that the buffer is going to
715 * be staled and was an inode buffer. This means it gets
Christoph Hellwig93848a92013-04-03 16:11:17 +1100716 * special processing during unpin - where any inodes
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 * associated with the buffer should be removed from ail.
718 * There is also special processing during recovery,
719 * any replay of the inodes in the buffer needs to be
720 * prevented as the buffer may have been reused.
721 */
722void
723xfs_trans_stale_inode_buf(
724 xfs_trans_t *tp,
725 xfs_buf_t *bp)
726{
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200727 xfs_buf_log_item_t *bip = bp->b_fspriv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200729 ASSERT(bp->b_transp == tp);
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200730 ASSERT(bip != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 ASSERT(atomic_read(&bip->bli_refcount) > 0);
732
733 bip->bli_flags |= XFS_BLI_STALE_INODE;
Christoph Hellwigca30b2a2010-06-23 18:11:15 +1000734 bip->bli_item.li_cb = xfs_buf_iodone;
Dave Chinner61fe1352013-04-03 16:11:30 +1100735 xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DINO_BUF);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736}
737
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738/*
739 * Mark the buffer as being one which contains newly allocated
740 * inodes. We need to make sure that even if this buffer is
741 * relogged as an 'inode buf' we still recover all of the inode
742 * images in the face of a crash. This works in coordination with
743 * xfs_buf_item_committed() to ensure that the buffer remains in the
744 * AIL at its original location even after it has been relogged.
745 */
746/* ARGSUSED */
747void
748xfs_trans_inode_alloc_buf(
749 xfs_trans_t *tp,
750 xfs_buf_t *bp)
751{
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200752 xfs_buf_log_item_t *bip = bp->b_fspriv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753
Christoph Hellwigbf9d9012011-07-13 13:43:49 +0200754 ASSERT(bp->b_transp == tp);
Christoph Hellwigadadbee2011-07-13 13:43:49 +0200755 ASSERT(bip != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 ASSERT(atomic_read(&bip->bli_refcount) > 0);
757
758 bip->bli_flags |= XFS_BLI_INODE_ALLOC_BUF;
Dave Chinner61fe1352013-04-03 16:11:30 +1100759 xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DINO_BUF);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760}
761
Christoph Hellwigee1a47a2013-04-21 14:53:46 -0500762/*
Dave Chinner5f6bed72013-06-27 16:04:52 +1000763 * Mark the buffer as ordered for this transaction. This means
764 * that the contents of the buffer are not recorded in the transaction
765 * but it is tracked in the AIL as though it was. This allows us
766 * to record logical changes in transactions rather than the physical
767 * changes we make to the buffer without changing writeback ordering
768 * constraints of metadata buffers.
769 */
770void
771xfs_trans_ordered_buf(
772 struct xfs_trans *tp,
773 struct xfs_buf *bp)
774{
775 struct xfs_buf_log_item *bip = bp->b_fspriv;
776
777 ASSERT(bp->b_transp == tp);
778 ASSERT(bip != NULL);
779 ASSERT(atomic_read(&bip->bli_refcount) > 0);
780
781 bip->bli_flags |= XFS_BLI_ORDERED;
782 trace_xfs_buf_item_ordered(bip);
783}
784
785/*
Christoph Hellwigee1a47a2013-04-21 14:53:46 -0500786 * Set the type of the buffer for log recovery so that it can correctly identify
787 * and hence attach the correct buffer ops to the buffer after replay.
788 */
789void
790xfs_trans_buf_set_type(
791 struct xfs_trans *tp,
792 struct xfs_buf *bp,
Dave Chinner61fe1352013-04-03 16:11:30 +1100793 enum xfs_blft type)
Christoph Hellwigee1a47a2013-04-21 14:53:46 -0500794{
795 struct xfs_buf_log_item *bip = bp->b_fspriv;
796
Dave Chinnerd75afeb2013-04-03 16:11:29 +1100797 if (!tp)
798 return;
799
Christoph Hellwigee1a47a2013-04-21 14:53:46 -0500800 ASSERT(bp->b_transp == tp);
801 ASSERT(bip != NULL);
802 ASSERT(atomic_read(&bip->bli_refcount) > 0);
Christoph Hellwigee1a47a2013-04-21 14:53:46 -0500803
Dave Chinner61fe1352013-04-03 16:11:30 +1100804 xfs_blft_to_flags(&bip->__bli_format, type);
Christoph Hellwigee1a47a2013-04-21 14:53:46 -0500805}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806
Dave Chinnerd75afeb2013-04-03 16:11:29 +1100807void
808xfs_trans_buf_copy_type(
809 struct xfs_buf *dst_bp,
810 struct xfs_buf *src_bp)
811{
812 struct xfs_buf_log_item *sbip = src_bp->b_fspriv;
813 struct xfs_buf_log_item *dbip = dst_bp->b_fspriv;
Dave Chinner61fe1352013-04-03 16:11:30 +1100814 enum xfs_blft type;
Dave Chinnerd75afeb2013-04-03 16:11:29 +1100815
Dave Chinner61fe1352013-04-03 16:11:30 +1100816 type = xfs_blft_from_flags(&sbip->__bli_format);
817 xfs_blft_to_flags(&dbip->__bli_format, type);
Dave Chinnerd75afeb2013-04-03 16:11:29 +1100818}
819
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820/*
821 * Similar to xfs_trans_inode_buf(), this marks the buffer as a cluster of
822 * dquots. However, unlike in inode buffer recovery, dquot buffers get
823 * recovered in their entirety. (Hence, no XFS_BLI_DQUOT_ALLOC_BUF flag).
824 * The only thing that makes dquot buffers different from regular
825 * buffers is that we must not replay dquot bufs when recovering
826 * if a _corresponding_ quotaoff has happened. We also have to distinguish
827 * between usr dquot bufs and grp dquot bufs, because usr and grp quotas
828 * can be turned off independently.
829 */
830/* ARGSUSED */
831void
832xfs_trans_dquot_buf(
833 xfs_trans_t *tp,
834 xfs_buf_t *bp,
835 uint type)
836{
Dave Chinner61fe1352013-04-03 16:11:30 +1100837 struct xfs_buf_log_item *bip = bp->b_fspriv;
838
Dave Chinnerc1155412010-05-07 11:05:19 +1000839 ASSERT(type == XFS_BLF_UDQUOT_BUF ||
840 type == XFS_BLF_PDQUOT_BUF ||
841 type == XFS_BLF_GDQUOT_BUF);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842
Dave Chinner61fe1352013-04-03 16:11:30 +1100843 bip->__bli_format.blf_flags |= type;
844
845 switch (type) {
846 case XFS_BLF_UDQUOT_BUF:
847 type = XFS_BLFT_UDQUOT_BUF;
848 break;
849 case XFS_BLF_PDQUOT_BUF:
850 type = XFS_BLFT_PDQUOT_BUF;
851 break;
852 case XFS_BLF_GDQUOT_BUF:
853 type = XFS_BLFT_GDQUOT_BUF;
854 break;
855 default:
856 type = XFS_BLFT_UNKNOWN_BUF;
857 break;
858 }
859
Christoph Hellwigee1a47a2013-04-21 14:53:46 -0500860 xfs_trans_buf_set_type(tp, bp, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861}