Loading...
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright (C) 2017 Oracle. All Rights Reserved.
4 * Author: Darrick J. Wong <darrick.wong@oracle.com>
5 */
6#include "xfs.h"
7#include "xfs_fs.h"
8#include "xfs_shared.h"
9#include "xfs_format.h"
10#include "xfs_log_format.h"
11#include "xfs_trans_resv.h"
12#include "xfs_mount.h"
13#include "xfs_inode.h"
14#include "xfs_trans.h"
15#include "xfs_btree.h"
16#include "xfs_rmap_btree.h"
17#include "xfs_trace.h"
18#include "xfs_rmap.h"
19#include "xfs_alloc.h"
20#include "xfs_bit.h"
21#include <linux/fsmap.h>
22#include "xfs_fsmap.h"
23#include "xfs_refcount.h"
24#include "xfs_refcount_btree.h"
25#include "xfs_alloc_btree.h"
26#include "xfs_rtalloc.h"
27
28/* Convert an xfs_fsmap to an fsmap. */
29void
30xfs_fsmap_from_internal(
31 struct fsmap *dest,
32 struct xfs_fsmap *src)
33{
34 dest->fmr_device = src->fmr_device;
35 dest->fmr_flags = src->fmr_flags;
36 dest->fmr_physical = BBTOB(src->fmr_physical);
37 dest->fmr_owner = src->fmr_owner;
38 dest->fmr_offset = BBTOB(src->fmr_offset);
39 dest->fmr_length = BBTOB(src->fmr_length);
40 dest->fmr_reserved[0] = 0;
41 dest->fmr_reserved[1] = 0;
42 dest->fmr_reserved[2] = 0;
43}
44
45/* Convert an fsmap to an xfs_fsmap. */
46void
47xfs_fsmap_to_internal(
48 struct xfs_fsmap *dest,
49 struct fsmap *src)
50{
51 dest->fmr_device = src->fmr_device;
52 dest->fmr_flags = src->fmr_flags;
53 dest->fmr_physical = BTOBBT(src->fmr_physical);
54 dest->fmr_owner = src->fmr_owner;
55 dest->fmr_offset = BTOBBT(src->fmr_offset);
56 dest->fmr_length = BTOBBT(src->fmr_length);
57}
58
59/* Convert an fsmap owner into an rmapbt owner. */
60static int
61xfs_fsmap_owner_to_rmap(
62 struct xfs_rmap_irec *dest,
63 struct xfs_fsmap *src)
64{
65 if (!(src->fmr_flags & FMR_OF_SPECIAL_OWNER)) {
66 dest->rm_owner = src->fmr_owner;
67 return 0;
68 }
69
70 switch (src->fmr_owner) {
71 case 0: /* "lowest owner id possible" */
72 case -1ULL: /* "highest owner id possible" */
73 dest->rm_owner = 0;
74 break;
75 case XFS_FMR_OWN_FREE:
76 dest->rm_owner = XFS_RMAP_OWN_NULL;
77 break;
78 case XFS_FMR_OWN_UNKNOWN:
79 dest->rm_owner = XFS_RMAP_OWN_UNKNOWN;
80 break;
81 case XFS_FMR_OWN_FS:
82 dest->rm_owner = XFS_RMAP_OWN_FS;
83 break;
84 case XFS_FMR_OWN_LOG:
85 dest->rm_owner = XFS_RMAP_OWN_LOG;
86 break;
87 case XFS_FMR_OWN_AG:
88 dest->rm_owner = XFS_RMAP_OWN_AG;
89 break;
90 case XFS_FMR_OWN_INOBT:
91 dest->rm_owner = XFS_RMAP_OWN_INOBT;
92 break;
93 case XFS_FMR_OWN_INODES:
94 dest->rm_owner = XFS_RMAP_OWN_INODES;
95 break;
96 case XFS_FMR_OWN_REFC:
97 dest->rm_owner = XFS_RMAP_OWN_REFC;
98 break;
99 case XFS_FMR_OWN_COW:
100 dest->rm_owner = XFS_RMAP_OWN_COW;
101 break;
102 case XFS_FMR_OWN_DEFECTIVE: /* not implemented */
103 /* fall through */
104 default:
105 return -EINVAL;
106 }
107 return 0;
108}
109
110/* Convert an rmapbt owner into an fsmap owner. */
111static int
112xfs_fsmap_owner_from_rmap(
113 struct xfs_fsmap *dest,
114 struct xfs_rmap_irec *src)
115{
116 dest->fmr_flags = 0;
117 if (!XFS_RMAP_NON_INODE_OWNER(src->rm_owner)) {
118 dest->fmr_owner = src->rm_owner;
119 return 0;
120 }
121 dest->fmr_flags |= FMR_OF_SPECIAL_OWNER;
122
123 switch (src->rm_owner) {
124 case XFS_RMAP_OWN_FS:
125 dest->fmr_owner = XFS_FMR_OWN_FS;
126 break;
127 case XFS_RMAP_OWN_LOG:
128 dest->fmr_owner = XFS_FMR_OWN_LOG;
129 break;
130 case XFS_RMAP_OWN_AG:
131 dest->fmr_owner = XFS_FMR_OWN_AG;
132 break;
133 case XFS_RMAP_OWN_INOBT:
134 dest->fmr_owner = XFS_FMR_OWN_INOBT;
135 break;
136 case XFS_RMAP_OWN_INODES:
137 dest->fmr_owner = XFS_FMR_OWN_INODES;
138 break;
139 case XFS_RMAP_OWN_REFC:
140 dest->fmr_owner = XFS_FMR_OWN_REFC;
141 break;
142 case XFS_RMAP_OWN_COW:
143 dest->fmr_owner = XFS_FMR_OWN_COW;
144 break;
145 case XFS_RMAP_OWN_NULL: /* "free" */
146 dest->fmr_owner = XFS_FMR_OWN_FREE;
147 break;
148 default:
149 return -EFSCORRUPTED;
150 }
151 return 0;
152}
153
154/* getfsmap query state */
155struct xfs_getfsmap_info {
156 struct xfs_fsmap_head *head;
157 xfs_fsmap_format_t formatter; /* formatting fn */
158 void *format_arg; /* format buffer */
159 struct xfs_buf *agf_bp; /* AGF, for refcount queries */
160 xfs_daddr_t next_daddr; /* next daddr we expect */
161 u64 missing_owner; /* owner of holes */
162 u32 dev; /* device id */
163 xfs_agnumber_t agno; /* AG number, if applicable */
164 struct xfs_rmap_irec low; /* low rmap key */
165 struct xfs_rmap_irec high; /* high rmap key */
166 bool last; /* last extent? */
167};
168
169/* Associate a device with a getfsmap handler. */
170struct xfs_getfsmap_dev {
171 u32 dev;
172 int (*fn)(struct xfs_trans *tp,
173 struct xfs_fsmap *keys,
174 struct xfs_getfsmap_info *info);
175};
176
177/* Compare two getfsmap device handlers. */
178static int
179xfs_getfsmap_dev_compare(
180 const void *p1,
181 const void *p2)
182{
183 const struct xfs_getfsmap_dev *d1 = p1;
184 const struct xfs_getfsmap_dev *d2 = p2;
185
186 return d1->dev - d2->dev;
187}
188
189/* Decide if this mapping is shared. */
190STATIC int
191xfs_getfsmap_is_shared(
192 struct xfs_trans *tp,
193 struct xfs_getfsmap_info *info,
194 struct xfs_rmap_irec *rec,
195 bool *stat)
196{
197 struct xfs_mount *mp = tp->t_mountp;
198 struct xfs_btree_cur *cur;
199 xfs_agblock_t fbno;
200 xfs_extlen_t flen;
201 int error;
202
203 *stat = false;
204 if (!xfs_sb_version_hasreflink(&mp->m_sb))
205 return 0;
206 /* rt files will have agno set to NULLAGNUMBER */
207 if (info->agno == NULLAGNUMBER)
208 return 0;
209
210 /* Are there any shared blocks here? */
211 flen = 0;
212 cur = xfs_refcountbt_init_cursor(mp, tp, info->agf_bp,
213 info->agno);
214
215 error = xfs_refcount_find_shared(cur, rec->rm_startblock,
216 rec->rm_blockcount, &fbno, &flen, false);
217
218 xfs_btree_del_cursor(cur, error);
219 if (error)
220 return error;
221
222 *stat = flen > 0;
223 return 0;
224}
225
226/*
227 * Format a reverse mapping for getfsmap, having translated rm_startblock
228 * into the appropriate daddr units.
229 */
230STATIC int
231xfs_getfsmap_helper(
232 struct xfs_trans *tp,
233 struct xfs_getfsmap_info *info,
234 struct xfs_rmap_irec *rec,
235 xfs_daddr_t rec_daddr)
236{
237 struct xfs_fsmap fmr;
238 struct xfs_mount *mp = tp->t_mountp;
239 bool shared;
240 int error;
241
242 if (fatal_signal_pending(current))
243 return -EINTR;
244
245 /*
246 * Filter out records that start before our startpoint, if the
247 * caller requested that.
248 */
249 if (xfs_rmap_compare(rec, &info->low) < 0) {
250 rec_daddr += XFS_FSB_TO_BB(mp, rec->rm_blockcount);
251 if (info->next_daddr < rec_daddr)
252 info->next_daddr = rec_daddr;
253 return 0;
254 }
255
256 /* Are we just counting mappings? */
257 if (info->head->fmh_count == 0) {
258 if (rec_daddr > info->next_daddr)
259 info->head->fmh_entries++;
260
261 if (info->last)
262 return 0;
263
264 info->head->fmh_entries++;
265
266 rec_daddr += XFS_FSB_TO_BB(mp, rec->rm_blockcount);
267 if (info->next_daddr < rec_daddr)
268 info->next_daddr = rec_daddr;
269 return 0;
270 }
271
272 /*
273 * If the record starts past the last physical block we saw,
274 * then we've found a gap. Report the gap as being owned by
275 * whatever the caller specified is the missing owner.
276 */
277 if (rec_daddr > info->next_daddr) {
278 if (info->head->fmh_entries >= info->head->fmh_count)
279 return -ECANCELED;
280
281 fmr.fmr_device = info->dev;
282 fmr.fmr_physical = info->next_daddr;
283 fmr.fmr_owner = info->missing_owner;
284 fmr.fmr_offset = 0;
285 fmr.fmr_length = rec_daddr - info->next_daddr;
286 fmr.fmr_flags = FMR_OF_SPECIAL_OWNER;
287 error = info->formatter(&fmr, info->format_arg);
288 if (error)
289 return error;
290 info->head->fmh_entries++;
291 }
292
293 if (info->last)
294 goto out;
295
296 /* Fill out the extent we found */
297 if (info->head->fmh_entries >= info->head->fmh_count)
298 return -ECANCELED;
299
300 trace_xfs_fsmap_mapping(mp, info->dev, info->agno, rec);
301
302 fmr.fmr_device = info->dev;
303 fmr.fmr_physical = rec_daddr;
304 error = xfs_fsmap_owner_from_rmap(&fmr, rec);
305 if (error)
306 return error;
307 fmr.fmr_offset = XFS_FSB_TO_BB(mp, rec->rm_offset);
308 fmr.fmr_length = XFS_FSB_TO_BB(mp, rec->rm_blockcount);
309 if (rec->rm_flags & XFS_RMAP_UNWRITTEN)
310 fmr.fmr_flags |= FMR_OF_PREALLOC;
311 if (rec->rm_flags & XFS_RMAP_ATTR_FORK)
312 fmr.fmr_flags |= FMR_OF_ATTR_FORK;
313 if (rec->rm_flags & XFS_RMAP_BMBT_BLOCK)
314 fmr.fmr_flags |= FMR_OF_EXTENT_MAP;
315 if (fmr.fmr_flags == 0) {
316 error = xfs_getfsmap_is_shared(tp, info, rec, &shared);
317 if (error)
318 return error;
319 if (shared)
320 fmr.fmr_flags |= FMR_OF_SHARED;
321 }
322 error = info->formatter(&fmr, info->format_arg);
323 if (error)
324 return error;
325 info->head->fmh_entries++;
326
327out:
328 rec_daddr += XFS_FSB_TO_BB(mp, rec->rm_blockcount);
329 if (info->next_daddr < rec_daddr)
330 info->next_daddr = rec_daddr;
331 return 0;
332}
333
334/* Transform a rmapbt irec into a fsmap */
335STATIC int
336xfs_getfsmap_datadev_helper(
337 struct xfs_btree_cur *cur,
338 struct xfs_rmap_irec *rec,
339 void *priv)
340{
341 struct xfs_mount *mp = cur->bc_mp;
342 struct xfs_getfsmap_info *info = priv;
343 xfs_fsblock_t fsb;
344 xfs_daddr_t rec_daddr;
345
346 fsb = XFS_AGB_TO_FSB(mp, cur->bc_private.a.agno, rec->rm_startblock);
347 rec_daddr = XFS_FSB_TO_DADDR(mp, fsb);
348
349 return xfs_getfsmap_helper(cur->bc_tp, info, rec, rec_daddr);
350}
351
352/* Transform a bnobt irec into a fsmap */
353STATIC int
354xfs_getfsmap_datadev_bnobt_helper(
355 struct xfs_btree_cur *cur,
356 struct xfs_alloc_rec_incore *rec,
357 void *priv)
358{
359 struct xfs_mount *mp = cur->bc_mp;
360 struct xfs_getfsmap_info *info = priv;
361 struct xfs_rmap_irec irec;
362 xfs_daddr_t rec_daddr;
363
364 rec_daddr = XFS_AGB_TO_DADDR(mp, cur->bc_private.a.agno,
365 rec->ar_startblock);
366
367 irec.rm_startblock = rec->ar_startblock;
368 irec.rm_blockcount = rec->ar_blockcount;
369 irec.rm_owner = XFS_RMAP_OWN_NULL; /* "free" */
370 irec.rm_offset = 0;
371 irec.rm_flags = 0;
372
373 return xfs_getfsmap_helper(cur->bc_tp, info, &irec, rec_daddr);
374}
375
376/* Set rmap flags based on the getfsmap flags */
377static void
378xfs_getfsmap_set_irec_flags(
379 struct xfs_rmap_irec *irec,
380 struct xfs_fsmap *fmr)
381{
382 irec->rm_flags = 0;
383 if (fmr->fmr_flags & FMR_OF_ATTR_FORK)
384 irec->rm_flags |= XFS_RMAP_ATTR_FORK;
385 if (fmr->fmr_flags & FMR_OF_EXTENT_MAP)
386 irec->rm_flags |= XFS_RMAP_BMBT_BLOCK;
387 if (fmr->fmr_flags & FMR_OF_PREALLOC)
388 irec->rm_flags |= XFS_RMAP_UNWRITTEN;
389}
390
391/* Execute a getfsmap query against the log device. */
392STATIC int
393xfs_getfsmap_logdev(
394 struct xfs_trans *tp,
395 struct xfs_fsmap *keys,
396 struct xfs_getfsmap_info *info)
397{
398 struct xfs_mount *mp = tp->t_mountp;
399 struct xfs_rmap_irec rmap;
400 int error;
401
402 /* Set up search keys */
403 info->low.rm_startblock = XFS_BB_TO_FSBT(mp, keys[0].fmr_physical);
404 info->low.rm_offset = XFS_BB_TO_FSBT(mp, keys[0].fmr_offset);
405 error = xfs_fsmap_owner_to_rmap(&info->low, keys);
406 if (error)
407 return error;
408 info->low.rm_blockcount = 0;
409 xfs_getfsmap_set_irec_flags(&info->low, &keys[0]);
410
411 error = xfs_fsmap_owner_to_rmap(&info->high, keys + 1);
412 if (error)
413 return error;
414 info->high.rm_startblock = -1U;
415 info->high.rm_owner = ULLONG_MAX;
416 info->high.rm_offset = ULLONG_MAX;
417 info->high.rm_blockcount = 0;
418 info->high.rm_flags = XFS_RMAP_KEY_FLAGS | XFS_RMAP_REC_FLAGS;
419 info->missing_owner = XFS_FMR_OWN_FREE;
420
421 trace_xfs_fsmap_low_key(mp, info->dev, info->agno, &info->low);
422 trace_xfs_fsmap_high_key(mp, info->dev, info->agno, &info->high);
423
424 if (keys[0].fmr_physical > 0)
425 return 0;
426
427 /* Fabricate an rmap entry for the external log device. */
428 rmap.rm_startblock = 0;
429 rmap.rm_blockcount = mp->m_sb.sb_logblocks;
430 rmap.rm_owner = XFS_RMAP_OWN_LOG;
431 rmap.rm_offset = 0;
432 rmap.rm_flags = 0;
433
434 return xfs_getfsmap_helper(tp, info, &rmap, 0);
435}
436
437#ifdef CONFIG_XFS_RT
438/* Transform a rtbitmap "record" into a fsmap */
439STATIC int
440xfs_getfsmap_rtdev_rtbitmap_helper(
441 struct xfs_trans *tp,
442 struct xfs_rtalloc_rec *rec,
443 void *priv)
444{
445 struct xfs_mount *mp = tp->t_mountp;
446 struct xfs_getfsmap_info *info = priv;
447 struct xfs_rmap_irec irec;
448 xfs_daddr_t rec_daddr;
449
450 irec.rm_startblock = rec->ar_startext * mp->m_sb.sb_rextsize;
451 rec_daddr = XFS_FSB_TO_BB(mp, irec.rm_startblock);
452 irec.rm_blockcount = rec->ar_extcount * mp->m_sb.sb_rextsize;
453 irec.rm_owner = XFS_RMAP_OWN_NULL; /* "free" */
454 irec.rm_offset = 0;
455 irec.rm_flags = 0;
456
457 return xfs_getfsmap_helper(tp, info, &irec, rec_daddr);
458}
459
460/* Execute a getfsmap query against the realtime device. */
461STATIC int
462__xfs_getfsmap_rtdev(
463 struct xfs_trans *tp,
464 struct xfs_fsmap *keys,
465 int (*query_fn)(struct xfs_trans *,
466 struct xfs_getfsmap_info *),
467 struct xfs_getfsmap_info *info)
468{
469 struct xfs_mount *mp = tp->t_mountp;
470 xfs_fsblock_t start_fsb;
471 xfs_fsblock_t end_fsb;
472 xfs_daddr_t eofs;
473 int error = 0;
474
475 eofs = XFS_FSB_TO_BB(mp, mp->m_sb.sb_rblocks);
476 if (keys[0].fmr_physical >= eofs)
477 return 0;
478 if (keys[1].fmr_physical >= eofs)
479 keys[1].fmr_physical = eofs - 1;
480 start_fsb = XFS_BB_TO_FSBT(mp, keys[0].fmr_physical);
481 end_fsb = XFS_BB_TO_FSB(mp, keys[1].fmr_physical);
482
483 /* Set up search keys */
484 info->low.rm_startblock = start_fsb;
485 error = xfs_fsmap_owner_to_rmap(&info->low, &keys[0]);
486 if (error)
487 return error;
488 info->low.rm_offset = XFS_BB_TO_FSBT(mp, keys[0].fmr_offset);
489 info->low.rm_blockcount = 0;
490 xfs_getfsmap_set_irec_flags(&info->low, &keys[0]);
491
492 info->high.rm_startblock = end_fsb;
493 error = xfs_fsmap_owner_to_rmap(&info->high, &keys[1]);
494 if (error)
495 return error;
496 info->high.rm_offset = XFS_BB_TO_FSBT(mp, keys[1].fmr_offset);
497 info->high.rm_blockcount = 0;
498 xfs_getfsmap_set_irec_flags(&info->high, &keys[1]);
499
500 trace_xfs_fsmap_low_key(mp, info->dev, info->agno, &info->low);
501 trace_xfs_fsmap_high_key(mp, info->dev, info->agno, &info->high);
502
503 return query_fn(tp, info);
504}
505
506/* Actually query the realtime bitmap. */
507STATIC int
508xfs_getfsmap_rtdev_rtbitmap_query(
509 struct xfs_trans *tp,
510 struct xfs_getfsmap_info *info)
511{
512 struct xfs_rtalloc_rec alow = { 0 };
513 struct xfs_rtalloc_rec ahigh = { 0 };
514 int error;
515
516 xfs_ilock(tp->t_mountp->m_rbmip, XFS_ILOCK_SHARED);
517
518 alow.ar_startext = info->low.rm_startblock;
519 ahigh.ar_startext = info->high.rm_startblock;
520 do_div(alow.ar_startext, tp->t_mountp->m_sb.sb_rextsize);
521 if (do_div(ahigh.ar_startext, tp->t_mountp->m_sb.sb_rextsize))
522 ahigh.ar_startext++;
523 error = xfs_rtalloc_query_range(tp, &alow, &ahigh,
524 xfs_getfsmap_rtdev_rtbitmap_helper, info);
525 if (error)
526 goto err;
527
528 /* Report any gaps at the end of the rtbitmap */
529 info->last = true;
530 error = xfs_getfsmap_rtdev_rtbitmap_helper(tp, &ahigh, info);
531 if (error)
532 goto err;
533err:
534 xfs_iunlock(tp->t_mountp->m_rbmip, XFS_ILOCK_SHARED);
535 return error;
536}
537
538/* Execute a getfsmap query against the realtime device rtbitmap. */
539STATIC int
540xfs_getfsmap_rtdev_rtbitmap(
541 struct xfs_trans *tp,
542 struct xfs_fsmap *keys,
543 struct xfs_getfsmap_info *info)
544{
545 info->missing_owner = XFS_FMR_OWN_UNKNOWN;
546 return __xfs_getfsmap_rtdev(tp, keys, xfs_getfsmap_rtdev_rtbitmap_query,
547 info);
548}
549#endif /* CONFIG_XFS_RT */
550
551/* Execute a getfsmap query against the regular data device. */
552STATIC int
553__xfs_getfsmap_datadev(
554 struct xfs_trans *tp,
555 struct xfs_fsmap *keys,
556 struct xfs_getfsmap_info *info,
557 int (*query_fn)(struct xfs_trans *,
558 struct xfs_getfsmap_info *,
559 struct xfs_btree_cur **,
560 void *),
561 void *priv)
562{
563 struct xfs_mount *mp = tp->t_mountp;
564 struct xfs_btree_cur *bt_cur = NULL;
565 xfs_fsblock_t start_fsb;
566 xfs_fsblock_t end_fsb;
567 xfs_agnumber_t start_ag;
568 xfs_agnumber_t end_ag;
569 xfs_daddr_t eofs;
570 int error = 0;
571
572 eofs = XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks);
573 if (keys[0].fmr_physical >= eofs)
574 return 0;
575 if (keys[1].fmr_physical >= eofs)
576 keys[1].fmr_physical = eofs - 1;
577 start_fsb = XFS_DADDR_TO_FSB(mp, keys[0].fmr_physical);
578 end_fsb = XFS_DADDR_TO_FSB(mp, keys[1].fmr_physical);
579
580 /*
581 * Convert the fsmap low/high keys to AG based keys. Initialize
582 * low to the fsmap low key and max out the high key to the end
583 * of the AG.
584 */
585 info->low.rm_startblock = XFS_FSB_TO_AGBNO(mp, start_fsb);
586 info->low.rm_offset = XFS_BB_TO_FSBT(mp, keys[0].fmr_offset);
587 error = xfs_fsmap_owner_to_rmap(&info->low, &keys[0]);
588 if (error)
589 return error;
590 info->low.rm_blockcount = 0;
591 xfs_getfsmap_set_irec_flags(&info->low, &keys[0]);
592
593 info->high.rm_startblock = -1U;
594 info->high.rm_owner = ULLONG_MAX;
595 info->high.rm_offset = ULLONG_MAX;
596 info->high.rm_blockcount = 0;
597 info->high.rm_flags = XFS_RMAP_KEY_FLAGS | XFS_RMAP_REC_FLAGS;
598
599 start_ag = XFS_FSB_TO_AGNO(mp, start_fsb);
600 end_ag = XFS_FSB_TO_AGNO(mp, end_fsb);
601
602 /* Query each AG */
603 for (info->agno = start_ag; info->agno <= end_ag; info->agno++) {
604 /*
605 * Set the AG high key from the fsmap high key if this
606 * is the last AG that we're querying.
607 */
608 if (info->agno == end_ag) {
609 info->high.rm_startblock = XFS_FSB_TO_AGBNO(mp,
610 end_fsb);
611 info->high.rm_offset = XFS_BB_TO_FSBT(mp,
612 keys[1].fmr_offset);
613 error = xfs_fsmap_owner_to_rmap(&info->high, &keys[1]);
614 if (error)
615 goto err;
616 xfs_getfsmap_set_irec_flags(&info->high, &keys[1]);
617 }
618
619 if (bt_cur) {
620 xfs_btree_del_cursor(bt_cur, XFS_BTREE_NOERROR);
621 bt_cur = NULL;
622 xfs_trans_brelse(tp, info->agf_bp);
623 info->agf_bp = NULL;
624 }
625
626 error = xfs_alloc_read_agf(mp, tp, info->agno, 0,
627 &info->agf_bp);
628 if (error)
629 goto err;
630
631 trace_xfs_fsmap_low_key(mp, info->dev, info->agno, &info->low);
632 trace_xfs_fsmap_high_key(mp, info->dev, info->agno,
633 &info->high);
634
635 error = query_fn(tp, info, &bt_cur, priv);
636 if (error)
637 goto err;
638
639 /*
640 * Set the AG low key to the start of the AG prior to
641 * moving on to the next AG.
642 */
643 if (info->agno == start_ag) {
644 info->low.rm_startblock = 0;
645 info->low.rm_owner = 0;
646 info->low.rm_offset = 0;
647 info->low.rm_flags = 0;
648 }
649 }
650
651 /* Report any gap at the end of the AG */
652 info->last = true;
653 error = query_fn(tp, info, &bt_cur, priv);
654 if (error)
655 goto err;
656
657err:
658 if (bt_cur)
659 xfs_btree_del_cursor(bt_cur, error < 0 ? XFS_BTREE_ERROR :
660 XFS_BTREE_NOERROR);
661 if (info->agf_bp) {
662 xfs_trans_brelse(tp, info->agf_bp);
663 info->agf_bp = NULL;
664 }
665
666 return error;
667}
668
669/* Actually query the rmap btree. */
670STATIC int
671xfs_getfsmap_datadev_rmapbt_query(
672 struct xfs_trans *tp,
673 struct xfs_getfsmap_info *info,
674 struct xfs_btree_cur **curpp,
675 void *priv)
676{
677 /* Report any gap at the end of the last AG. */
678 if (info->last)
679 return xfs_getfsmap_datadev_helper(*curpp, &info->high, info);
680
681 /* Allocate cursor for this AG and query_range it. */
682 *curpp = xfs_rmapbt_init_cursor(tp->t_mountp, tp, info->agf_bp,
683 info->agno);
684 return xfs_rmap_query_range(*curpp, &info->low, &info->high,
685 xfs_getfsmap_datadev_helper, info);
686}
687
688/* Execute a getfsmap query against the regular data device rmapbt. */
689STATIC int
690xfs_getfsmap_datadev_rmapbt(
691 struct xfs_trans *tp,
692 struct xfs_fsmap *keys,
693 struct xfs_getfsmap_info *info)
694{
695 info->missing_owner = XFS_FMR_OWN_FREE;
696 return __xfs_getfsmap_datadev(tp, keys, info,
697 xfs_getfsmap_datadev_rmapbt_query, NULL);
698}
699
700/* Actually query the bno btree. */
701STATIC int
702xfs_getfsmap_datadev_bnobt_query(
703 struct xfs_trans *tp,
704 struct xfs_getfsmap_info *info,
705 struct xfs_btree_cur **curpp,
706 void *priv)
707{
708 struct xfs_alloc_rec_incore *key = priv;
709
710 /* Report any gap at the end of the last AG. */
711 if (info->last)
712 return xfs_getfsmap_datadev_bnobt_helper(*curpp, &key[1], info);
713
714 /* Allocate cursor for this AG and query_range it. */
715 *curpp = xfs_allocbt_init_cursor(tp->t_mountp, tp, info->agf_bp,
716 info->agno, XFS_BTNUM_BNO);
717 key->ar_startblock = info->low.rm_startblock;
718 key[1].ar_startblock = info->high.rm_startblock;
719 return xfs_alloc_query_range(*curpp, key, &key[1],
720 xfs_getfsmap_datadev_bnobt_helper, info);
721}
722
723/* Execute a getfsmap query against the regular data device's bnobt. */
724STATIC int
725xfs_getfsmap_datadev_bnobt(
726 struct xfs_trans *tp,
727 struct xfs_fsmap *keys,
728 struct xfs_getfsmap_info *info)
729{
730 struct xfs_alloc_rec_incore akeys[2];
731
732 info->missing_owner = XFS_FMR_OWN_UNKNOWN;
733 return __xfs_getfsmap_datadev(tp, keys, info,
734 xfs_getfsmap_datadev_bnobt_query, &akeys[0]);
735}
736
737/* Do we recognize the device? */
738STATIC bool
739xfs_getfsmap_is_valid_device(
740 struct xfs_mount *mp,
741 struct xfs_fsmap *fm)
742{
743 if (fm->fmr_device == 0 || fm->fmr_device == UINT_MAX ||
744 fm->fmr_device == new_encode_dev(mp->m_ddev_targp->bt_dev))
745 return true;
746 if (mp->m_logdev_targp &&
747 fm->fmr_device == new_encode_dev(mp->m_logdev_targp->bt_dev))
748 return true;
749 if (mp->m_rtdev_targp &&
750 fm->fmr_device == new_encode_dev(mp->m_rtdev_targp->bt_dev))
751 return true;
752 return false;
753}
754
755/* Ensure that the low key is less than the high key. */
756STATIC bool
757xfs_getfsmap_check_keys(
758 struct xfs_fsmap *low_key,
759 struct xfs_fsmap *high_key)
760{
761 if (low_key->fmr_device > high_key->fmr_device)
762 return false;
763 if (low_key->fmr_device < high_key->fmr_device)
764 return true;
765
766 if (low_key->fmr_physical > high_key->fmr_physical)
767 return false;
768 if (low_key->fmr_physical < high_key->fmr_physical)
769 return true;
770
771 if (low_key->fmr_owner > high_key->fmr_owner)
772 return false;
773 if (low_key->fmr_owner < high_key->fmr_owner)
774 return true;
775
776 if (low_key->fmr_offset > high_key->fmr_offset)
777 return false;
778 if (low_key->fmr_offset < high_key->fmr_offset)
779 return true;
780
781 return false;
782}
783
784/*
785 * There are only two devices if we didn't configure RT devices at build time.
786 */
787#ifdef CONFIG_XFS_RT
788#define XFS_GETFSMAP_DEVS 3
789#else
790#define XFS_GETFSMAP_DEVS 2
791#endif /* CONFIG_XFS_RT */
792
793/*
794 * Get filesystem's extents as described in head, and format for
795 * output. Calls formatter to fill the user's buffer until all
796 * extents are mapped, until the passed-in head->fmh_count slots have
797 * been filled, or until the formatter short-circuits the loop, if it
798 * is tracking filled-in extents on its own.
799 *
800 * Key to Confusion
801 * ----------------
802 * There are multiple levels of keys and counters at work here:
803 * xfs_fsmap_head.fmh_keys -- low and high fsmap keys passed in;
804 * these reflect fs-wide sector addrs.
805 * dkeys -- fmh_keys used to query each device;
806 * these are fmh_keys but w/ the low key
807 * bumped up by fmr_length.
808 * xfs_getfsmap_info.next_daddr -- next disk addr we expect to see; this
809 * is how we detect gaps in the fsmap
810 records and report them.
811 * xfs_getfsmap_info.low/high -- per-AG low/high keys computed from
812 * dkeys; used to query the metadata.
813 */
814int
815xfs_getfsmap(
816 struct xfs_mount *mp,
817 struct xfs_fsmap_head *head,
818 xfs_fsmap_format_t formatter,
819 void *arg)
820{
821 struct xfs_trans *tp = NULL;
822 struct xfs_fsmap dkeys[2]; /* per-dev keys */
823 struct xfs_getfsmap_dev handlers[XFS_GETFSMAP_DEVS];
824 struct xfs_getfsmap_info info = { NULL };
825 bool use_rmap;
826 int i;
827 int error = 0;
828
829 if (head->fmh_iflags & ~FMH_IF_VALID)
830 return -EINVAL;
831 if (!xfs_getfsmap_is_valid_device(mp, &head->fmh_keys[0]) ||
832 !xfs_getfsmap_is_valid_device(mp, &head->fmh_keys[1]))
833 return -EINVAL;
834
835 use_rmap = capable(CAP_SYS_ADMIN) &&
836 xfs_sb_version_hasrmapbt(&mp->m_sb);
837 head->fmh_entries = 0;
838
839 /* Set up our device handlers. */
840 memset(handlers, 0, sizeof(handlers));
841 handlers[0].dev = new_encode_dev(mp->m_ddev_targp->bt_dev);
842 if (use_rmap)
843 handlers[0].fn = xfs_getfsmap_datadev_rmapbt;
844 else
845 handlers[0].fn = xfs_getfsmap_datadev_bnobt;
846 if (mp->m_logdev_targp != mp->m_ddev_targp) {
847 handlers[1].dev = new_encode_dev(mp->m_logdev_targp->bt_dev);
848 handlers[1].fn = xfs_getfsmap_logdev;
849 }
850#ifdef CONFIG_XFS_RT
851 if (mp->m_rtdev_targp) {
852 handlers[2].dev = new_encode_dev(mp->m_rtdev_targp->bt_dev);
853 handlers[2].fn = xfs_getfsmap_rtdev_rtbitmap;
854 }
855#endif /* CONFIG_XFS_RT */
856
857 xfs_sort(handlers, XFS_GETFSMAP_DEVS, sizeof(struct xfs_getfsmap_dev),
858 xfs_getfsmap_dev_compare);
859
860 /*
861 * To continue where we left off, we allow userspace to use the
862 * last mapping from a previous call as the low key of the next.
863 * This is identified by a non-zero length in the low key. We
864 * have to increment the low key in this scenario to ensure we
865 * don't return the same mapping again, and instead return the
866 * very next mapping.
867 *
868 * If the low key mapping refers to file data, the same physical
869 * blocks could be mapped to several other files/offsets.
870 * According to rmapbt record ordering, the minimal next
871 * possible record for the block range is the next starting
872 * offset in the same inode. Therefore, bump the file offset to
873 * continue the search appropriately. For all other low key
874 * mapping types (attr blocks, metadata), bump the physical
875 * offset as there can be no other mapping for the same physical
876 * block range.
877 */
878 dkeys[0] = head->fmh_keys[0];
879 if (dkeys[0].fmr_flags & (FMR_OF_SPECIAL_OWNER | FMR_OF_EXTENT_MAP)) {
880 dkeys[0].fmr_physical += dkeys[0].fmr_length;
881 dkeys[0].fmr_owner = 0;
882 if (dkeys[0].fmr_offset)
883 return -EINVAL;
884 } else
885 dkeys[0].fmr_offset += dkeys[0].fmr_length;
886 dkeys[0].fmr_length = 0;
887 memset(&dkeys[1], 0xFF, sizeof(struct xfs_fsmap));
888
889 if (!xfs_getfsmap_check_keys(dkeys, &head->fmh_keys[1]))
890 return -EINVAL;
891
892 info.next_daddr = head->fmh_keys[0].fmr_physical +
893 head->fmh_keys[0].fmr_length;
894 info.formatter = formatter;
895 info.format_arg = arg;
896 info.head = head;
897
898 /* For each device we support... */
899 for (i = 0; i < XFS_GETFSMAP_DEVS; i++) {
900 /* Is this device within the range the user asked for? */
901 if (!handlers[i].fn)
902 continue;
903 if (head->fmh_keys[0].fmr_device > handlers[i].dev)
904 continue;
905 if (head->fmh_keys[1].fmr_device < handlers[i].dev)
906 break;
907
908 /*
909 * If this device number matches the high key, we have
910 * to pass the high key to the handler to limit the
911 * query results. If the device number exceeds the
912 * low key, zero out the low key so that we get
913 * everything from the beginning.
914 */
915 if (handlers[i].dev == head->fmh_keys[1].fmr_device)
916 dkeys[1] = head->fmh_keys[1];
917 if (handlers[i].dev > head->fmh_keys[0].fmr_device)
918 memset(&dkeys[0], 0, sizeof(struct xfs_fsmap));
919
920 error = xfs_trans_alloc_empty(mp, &tp);
921 if (error)
922 break;
923
924 info.dev = handlers[i].dev;
925 info.last = false;
926 info.agno = NULLAGNUMBER;
927 error = handlers[i].fn(tp, dkeys, &info);
928 if (error)
929 break;
930 xfs_trans_cancel(tp);
931 tp = NULL;
932 info.next_daddr = 0;
933 }
934
935 if (tp)
936 xfs_trans_cancel(tp);
937 head->fmh_oflags = FMH_OF_DEV_T;
938 return error;
939}
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright (C) 2017 Oracle. All Rights Reserved.
4 * Author: Darrick J. Wong <darrick.wong@oracle.com>
5 */
6#include "xfs.h"
7#include "xfs_fs.h"
8#include "xfs_shared.h"
9#include "xfs_format.h"
10#include "xfs_log_format.h"
11#include "xfs_trans_resv.h"
12#include "xfs_mount.h"
13#include "xfs_inode.h"
14#include "xfs_trans.h"
15#include "xfs_btree.h"
16#include "xfs_rmap_btree.h"
17#include "xfs_trace.h"
18#include "xfs_rmap.h"
19#include "xfs_alloc.h"
20#include "xfs_bit.h"
21#include <linux/fsmap.h>
22#include "xfs_fsmap.h"
23#include "xfs_refcount.h"
24#include "xfs_refcount_btree.h"
25#include "xfs_alloc_btree.h"
26#include "xfs_rtalloc.h"
27#include "xfs_ag.h"
28
29/* Convert an xfs_fsmap to an fsmap. */
30static void
31xfs_fsmap_from_internal(
32 struct fsmap *dest,
33 struct xfs_fsmap *src)
34{
35 dest->fmr_device = src->fmr_device;
36 dest->fmr_flags = src->fmr_flags;
37 dest->fmr_physical = BBTOB(src->fmr_physical);
38 dest->fmr_owner = src->fmr_owner;
39 dest->fmr_offset = BBTOB(src->fmr_offset);
40 dest->fmr_length = BBTOB(src->fmr_length);
41 dest->fmr_reserved[0] = 0;
42 dest->fmr_reserved[1] = 0;
43 dest->fmr_reserved[2] = 0;
44}
45
46/* Convert an fsmap to an xfs_fsmap. */
47void
48xfs_fsmap_to_internal(
49 struct xfs_fsmap *dest,
50 struct fsmap *src)
51{
52 dest->fmr_device = src->fmr_device;
53 dest->fmr_flags = src->fmr_flags;
54 dest->fmr_physical = BTOBBT(src->fmr_physical);
55 dest->fmr_owner = src->fmr_owner;
56 dest->fmr_offset = BTOBBT(src->fmr_offset);
57 dest->fmr_length = BTOBBT(src->fmr_length);
58}
59
60/* Convert an fsmap owner into an rmapbt owner. */
61static int
62xfs_fsmap_owner_to_rmap(
63 struct xfs_rmap_irec *dest,
64 struct xfs_fsmap *src)
65{
66 if (!(src->fmr_flags & FMR_OF_SPECIAL_OWNER)) {
67 dest->rm_owner = src->fmr_owner;
68 return 0;
69 }
70
71 switch (src->fmr_owner) {
72 case 0: /* "lowest owner id possible" */
73 case -1ULL: /* "highest owner id possible" */
74 dest->rm_owner = 0;
75 break;
76 case XFS_FMR_OWN_FREE:
77 dest->rm_owner = XFS_RMAP_OWN_NULL;
78 break;
79 case XFS_FMR_OWN_UNKNOWN:
80 dest->rm_owner = XFS_RMAP_OWN_UNKNOWN;
81 break;
82 case XFS_FMR_OWN_FS:
83 dest->rm_owner = XFS_RMAP_OWN_FS;
84 break;
85 case XFS_FMR_OWN_LOG:
86 dest->rm_owner = XFS_RMAP_OWN_LOG;
87 break;
88 case XFS_FMR_OWN_AG:
89 dest->rm_owner = XFS_RMAP_OWN_AG;
90 break;
91 case XFS_FMR_OWN_INOBT:
92 dest->rm_owner = XFS_RMAP_OWN_INOBT;
93 break;
94 case XFS_FMR_OWN_INODES:
95 dest->rm_owner = XFS_RMAP_OWN_INODES;
96 break;
97 case XFS_FMR_OWN_REFC:
98 dest->rm_owner = XFS_RMAP_OWN_REFC;
99 break;
100 case XFS_FMR_OWN_COW:
101 dest->rm_owner = XFS_RMAP_OWN_COW;
102 break;
103 case XFS_FMR_OWN_DEFECTIVE: /* not implemented */
104 /* fall through */
105 default:
106 return -EINVAL;
107 }
108 return 0;
109}
110
111/* Convert an rmapbt owner into an fsmap owner. */
112static int
113xfs_fsmap_owner_from_rmap(
114 struct xfs_fsmap *dest,
115 struct xfs_rmap_irec *src)
116{
117 dest->fmr_flags = 0;
118 if (!XFS_RMAP_NON_INODE_OWNER(src->rm_owner)) {
119 dest->fmr_owner = src->rm_owner;
120 return 0;
121 }
122 dest->fmr_flags |= FMR_OF_SPECIAL_OWNER;
123
124 switch (src->rm_owner) {
125 case XFS_RMAP_OWN_FS:
126 dest->fmr_owner = XFS_FMR_OWN_FS;
127 break;
128 case XFS_RMAP_OWN_LOG:
129 dest->fmr_owner = XFS_FMR_OWN_LOG;
130 break;
131 case XFS_RMAP_OWN_AG:
132 dest->fmr_owner = XFS_FMR_OWN_AG;
133 break;
134 case XFS_RMAP_OWN_INOBT:
135 dest->fmr_owner = XFS_FMR_OWN_INOBT;
136 break;
137 case XFS_RMAP_OWN_INODES:
138 dest->fmr_owner = XFS_FMR_OWN_INODES;
139 break;
140 case XFS_RMAP_OWN_REFC:
141 dest->fmr_owner = XFS_FMR_OWN_REFC;
142 break;
143 case XFS_RMAP_OWN_COW:
144 dest->fmr_owner = XFS_FMR_OWN_COW;
145 break;
146 case XFS_RMAP_OWN_NULL: /* "free" */
147 dest->fmr_owner = XFS_FMR_OWN_FREE;
148 break;
149 default:
150 ASSERT(0);
151 return -EFSCORRUPTED;
152 }
153 return 0;
154}
155
156/* getfsmap query state */
157struct xfs_getfsmap_info {
158 struct xfs_fsmap_head *head;
159 struct fsmap *fsmap_recs; /* mapping records */
160 struct xfs_buf *agf_bp; /* AGF, for refcount queries */
161 struct xfs_perag *pag; /* AG info, if applicable */
162 xfs_daddr_t next_daddr; /* next daddr we expect */
163 u64 missing_owner; /* owner of holes */
164 u32 dev; /* device id */
165 struct xfs_rmap_irec low; /* low rmap key */
166 struct xfs_rmap_irec high; /* high rmap key */
167 bool last; /* last extent? */
168};
169
170/* Associate a device with a getfsmap handler. */
171struct xfs_getfsmap_dev {
172 u32 dev;
173 int (*fn)(struct xfs_trans *tp,
174 struct xfs_fsmap *keys,
175 struct xfs_getfsmap_info *info);
176};
177
178/* Compare two getfsmap device handlers. */
179static int
180xfs_getfsmap_dev_compare(
181 const void *p1,
182 const void *p2)
183{
184 const struct xfs_getfsmap_dev *d1 = p1;
185 const struct xfs_getfsmap_dev *d2 = p2;
186
187 return d1->dev - d2->dev;
188}
189
190/* Decide if this mapping is shared. */
191STATIC int
192xfs_getfsmap_is_shared(
193 struct xfs_trans *tp,
194 struct xfs_getfsmap_info *info,
195 struct xfs_rmap_irec *rec,
196 bool *stat)
197{
198 struct xfs_mount *mp = tp->t_mountp;
199 struct xfs_btree_cur *cur;
200 xfs_agblock_t fbno;
201 xfs_extlen_t flen;
202 int error;
203
204 *stat = false;
205 if (!xfs_sb_version_hasreflink(&mp->m_sb))
206 return 0;
207 /* rt files will have no perag structure */
208 if (!info->pag)
209 return 0;
210
211 /* Are there any shared blocks here? */
212 flen = 0;
213 cur = xfs_refcountbt_init_cursor(mp, tp, info->agf_bp, info->pag);
214
215 error = xfs_refcount_find_shared(cur, rec->rm_startblock,
216 rec->rm_blockcount, &fbno, &flen, false);
217
218 xfs_btree_del_cursor(cur, error);
219 if (error)
220 return error;
221
222 *stat = flen > 0;
223 return 0;
224}
225
226static inline void
227xfs_getfsmap_format(
228 struct xfs_mount *mp,
229 struct xfs_fsmap *xfm,
230 struct xfs_getfsmap_info *info)
231{
232 struct fsmap *rec;
233
234 trace_xfs_getfsmap_mapping(mp, xfm);
235
236 rec = &info->fsmap_recs[info->head->fmh_entries++];
237 xfs_fsmap_from_internal(rec, xfm);
238}
239
240/*
241 * Format a reverse mapping for getfsmap, having translated rm_startblock
242 * into the appropriate daddr units.
243 */
244STATIC int
245xfs_getfsmap_helper(
246 struct xfs_trans *tp,
247 struct xfs_getfsmap_info *info,
248 struct xfs_rmap_irec *rec,
249 xfs_daddr_t rec_daddr)
250{
251 struct xfs_fsmap fmr;
252 struct xfs_mount *mp = tp->t_mountp;
253 bool shared;
254 int error;
255
256 if (fatal_signal_pending(current))
257 return -EINTR;
258
259 /*
260 * Filter out records that start before our startpoint, if the
261 * caller requested that.
262 */
263 if (xfs_rmap_compare(rec, &info->low) < 0) {
264 rec_daddr += XFS_FSB_TO_BB(mp, rec->rm_blockcount);
265 if (info->next_daddr < rec_daddr)
266 info->next_daddr = rec_daddr;
267 return 0;
268 }
269
270 /* Are we just counting mappings? */
271 if (info->head->fmh_count == 0) {
272 if (info->head->fmh_entries == UINT_MAX)
273 return -ECANCELED;
274
275 if (rec_daddr > info->next_daddr)
276 info->head->fmh_entries++;
277
278 if (info->last)
279 return 0;
280
281 info->head->fmh_entries++;
282
283 rec_daddr += XFS_FSB_TO_BB(mp, rec->rm_blockcount);
284 if (info->next_daddr < rec_daddr)
285 info->next_daddr = rec_daddr;
286 return 0;
287 }
288
289 /*
290 * If the record starts past the last physical block we saw,
291 * then we've found a gap. Report the gap as being owned by
292 * whatever the caller specified is the missing owner.
293 */
294 if (rec_daddr > info->next_daddr) {
295 if (info->head->fmh_entries >= info->head->fmh_count)
296 return -ECANCELED;
297
298 fmr.fmr_device = info->dev;
299 fmr.fmr_physical = info->next_daddr;
300 fmr.fmr_owner = info->missing_owner;
301 fmr.fmr_offset = 0;
302 fmr.fmr_length = rec_daddr - info->next_daddr;
303 fmr.fmr_flags = FMR_OF_SPECIAL_OWNER;
304 xfs_getfsmap_format(mp, &fmr, info);
305 }
306
307 if (info->last)
308 goto out;
309
310 /* Fill out the extent we found */
311 if (info->head->fmh_entries >= info->head->fmh_count)
312 return -ECANCELED;
313
314 trace_xfs_fsmap_mapping(mp, info->dev,
315 info->pag ? info->pag->pag_agno : NULLAGNUMBER, rec);
316
317 fmr.fmr_device = info->dev;
318 fmr.fmr_physical = rec_daddr;
319 error = xfs_fsmap_owner_from_rmap(&fmr, rec);
320 if (error)
321 return error;
322 fmr.fmr_offset = XFS_FSB_TO_BB(mp, rec->rm_offset);
323 fmr.fmr_length = XFS_FSB_TO_BB(mp, rec->rm_blockcount);
324 if (rec->rm_flags & XFS_RMAP_UNWRITTEN)
325 fmr.fmr_flags |= FMR_OF_PREALLOC;
326 if (rec->rm_flags & XFS_RMAP_ATTR_FORK)
327 fmr.fmr_flags |= FMR_OF_ATTR_FORK;
328 if (rec->rm_flags & XFS_RMAP_BMBT_BLOCK)
329 fmr.fmr_flags |= FMR_OF_EXTENT_MAP;
330 if (fmr.fmr_flags == 0) {
331 error = xfs_getfsmap_is_shared(tp, info, rec, &shared);
332 if (error)
333 return error;
334 if (shared)
335 fmr.fmr_flags |= FMR_OF_SHARED;
336 }
337
338 xfs_getfsmap_format(mp, &fmr, info);
339out:
340 rec_daddr += XFS_FSB_TO_BB(mp, rec->rm_blockcount);
341 if (info->next_daddr < rec_daddr)
342 info->next_daddr = rec_daddr;
343 return 0;
344}
345
346/* Transform a rmapbt irec into a fsmap */
347STATIC int
348xfs_getfsmap_datadev_helper(
349 struct xfs_btree_cur *cur,
350 struct xfs_rmap_irec *rec,
351 void *priv)
352{
353 struct xfs_mount *mp = cur->bc_mp;
354 struct xfs_getfsmap_info *info = priv;
355 xfs_fsblock_t fsb;
356 xfs_daddr_t rec_daddr;
357
358 fsb = XFS_AGB_TO_FSB(mp, cur->bc_ag.pag->pag_agno, rec->rm_startblock);
359 rec_daddr = XFS_FSB_TO_DADDR(mp, fsb);
360
361 return xfs_getfsmap_helper(cur->bc_tp, info, rec, rec_daddr);
362}
363
364/* Transform a bnobt irec into a fsmap */
365STATIC int
366xfs_getfsmap_datadev_bnobt_helper(
367 struct xfs_btree_cur *cur,
368 struct xfs_alloc_rec_incore *rec,
369 void *priv)
370{
371 struct xfs_mount *mp = cur->bc_mp;
372 struct xfs_getfsmap_info *info = priv;
373 struct xfs_rmap_irec irec;
374 xfs_daddr_t rec_daddr;
375
376 rec_daddr = XFS_AGB_TO_DADDR(mp, cur->bc_ag.pag->pag_agno,
377 rec->ar_startblock);
378
379 irec.rm_startblock = rec->ar_startblock;
380 irec.rm_blockcount = rec->ar_blockcount;
381 irec.rm_owner = XFS_RMAP_OWN_NULL; /* "free" */
382 irec.rm_offset = 0;
383 irec.rm_flags = 0;
384
385 return xfs_getfsmap_helper(cur->bc_tp, info, &irec, rec_daddr);
386}
387
388/* Set rmap flags based on the getfsmap flags */
389static void
390xfs_getfsmap_set_irec_flags(
391 struct xfs_rmap_irec *irec,
392 struct xfs_fsmap *fmr)
393{
394 irec->rm_flags = 0;
395 if (fmr->fmr_flags & FMR_OF_ATTR_FORK)
396 irec->rm_flags |= XFS_RMAP_ATTR_FORK;
397 if (fmr->fmr_flags & FMR_OF_EXTENT_MAP)
398 irec->rm_flags |= XFS_RMAP_BMBT_BLOCK;
399 if (fmr->fmr_flags & FMR_OF_PREALLOC)
400 irec->rm_flags |= XFS_RMAP_UNWRITTEN;
401}
402
403/* Execute a getfsmap query against the log device. */
404STATIC int
405xfs_getfsmap_logdev(
406 struct xfs_trans *tp,
407 struct xfs_fsmap *keys,
408 struct xfs_getfsmap_info *info)
409{
410 struct xfs_mount *mp = tp->t_mountp;
411 struct xfs_rmap_irec rmap;
412 int error;
413
414 /* Set up search keys */
415 info->low.rm_startblock = XFS_BB_TO_FSBT(mp, keys[0].fmr_physical);
416 info->low.rm_offset = XFS_BB_TO_FSBT(mp, keys[0].fmr_offset);
417 error = xfs_fsmap_owner_to_rmap(&info->low, keys);
418 if (error)
419 return error;
420 info->low.rm_blockcount = 0;
421 xfs_getfsmap_set_irec_flags(&info->low, &keys[0]);
422
423 error = xfs_fsmap_owner_to_rmap(&info->high, keys + 1);
424 if (error)
425 return error;
426 info->high.rm_startblock = -1U;
427 info->high.rm_owner = ULLONG_MAX;
428 info->high.rm_offset = ULLONG_MAX;
429 info->high.rm_blockcount = 0;
430 info->high.rm_flags = XFS_RMAP_KEY_FLAGS | XFS_RMAP_REC_FLAGS;
431 info->missing_owner = XFS_FMR_OWN_FREE;
432
433 trace_xfs_fsmap_low_key(mp, info->dev, NULLAGNUMBER, &info->low);
434 trace_xfs_fsmap_high_key(mp, info->dev, NULLAGNUMBER, &info->high);
435
436 if (keys[0].fmr_physical > 0)
437 return 0;
438
439 /* Fabricate an rmap entry for the external log device. */
440 rmap.rm_startblock = 0;
441 rmap.rm_blockcount = mp->m_sb.sb_logblocks;
442 rmap.rm_owner = XFS_RMAP_OWN_LOG;
443 rmap.rm_offset = 0;
444 rmap.rm_flags = 0;
445
446 return xfs_getfsmap_helper(tp, info, &rmap, 0);
447}
448
449#ifdef CONFIG_XFS_RT
450/* Transform a rtbitmap "record" into a fsmap */
451STATIC int
452xfs_getfsmap_rtdev_rtbitmap_helper(
453 struct xfs_trans *tp,
454 struct xfs_rtalloc_rec *rec,
455 void *priv)
456{
457 struct xfs_mount *mp = tp->t_mountp;
458 struct xfs_getfsmap_info *info = priv;
459 struct xfs_rmap_irec irec;
460 xfs_daddr_t rec_daddr;
461
462 irec.rm_startblock = rec->ar_startext * mp->m_sb.sb_rextsize;
463 rec_daddr = XFS_FSB_TO_BB(mp, irec.rm_startblock);
464 irec.rm_blockcount = rec->ar_extcount * mp->m_sb.sb_rextsize;
465 irec.rm_owner = XFS_RMAP_OWN_NULL; /* "free" */
466 irec.rm_offset = 0;
467 irec.rm_flags = 0;
468
469 return xfs_getfsmap_helper(tp, info, &irec, rec_daddr);
470}
471
472/* Execute a getfsmap query against the realtime device. */
473STATIC int
474__xfs_getfsmap_rtdev(
475 struct xfs_trans *tp,
476 struct xfs_fsmap *keys,
477 int (*query_fn)(struct xfs_trans *,
478 struct xfs_getfsmap_info *),
479 struct xfs_getfsmap_info *info)
480{
481 struct xfs_mount *mp = tp->t_mountp;
482 xfs_fsblock_t start_fsb;
483 xfs_fsblock_t end_fsb;
484 xfs_daddr_t eofs;
485 int error = 0;
486
487 eofs = XFS_FSB_TO_BB(mp, mp->m_sb.sb_rblocks);
488 if (keys[0].fmr_physical >= eofs)
489 return 0;
490 if (keys[1].fmr_physical >= eofs)
491 keys[1].fmr_physical = eofs - 1;
492 start_fsb = XFS_BB_TO_FSBT(mp, keys[0].fmr_physical);
493 end_fsb = XFS_BB_TO_FSB(mp, keys[1].fmr_physical);
494
495 /* Set up search keys */
496 info->low.rm_startblock = start_fsb;
497 error = xfs_fsmap_owner_to_rmap(&info->low, &keys[0]);
498 if (error)
499 return error;
500 info->low.rm_offset = XFS_BB_TO_FSBT(mp, keys[0].fmr_offset);
501 info->low.rm_blockcount = 0;
502 xfs_getfsmap_set_irec_flags(&info->low, &keys[0]);
503
504 info->high.rm_startblock = end_fsb;
505 error = xfs_fsmap_owner_to_rmap(&info->high, &keys[1]);
506 if (error)
507 return error;
508 info->high.rm_offset = XFS_BB_TO_FSBT(mp, keys[1].fmr_offset);
509 info->high.rm_blockcount = 0;
510 xfs_getfsmap_set_irec_flags(&info->high, &keys[1]);
511
512 trace_xfs_fsmap_low_key(mp, info->dev, NULLAGNUMBER, &info->low);
513 trace_xfs_fsmap_high_key(mp, info->dev, NULLAGNUMBER, &info->high);
514
515 return query_fn(tp, info);
516}
517
518/* Actually query the realtime bitmap. */
519STATIC int
520xfs_getfsmap_rtdev_rtbitmap_query(
521 struct xfs_trans *tp,
522 struct xfs_getfsmap_info *info)
523{
524 struct xfs_rtalloc_rec alow = { 0 };
525 struct xfs_rtalloc_rec ahigh = { 0 };
526 int error;
527
528 xfs_ilock(tp->t_mountp->m_rbmip, XFS_ILOCK_SHARED);
529
530 alow.ar_startext = info->low.rm_startblock;
531 ahigh.ar_startext = info->high.rm_startblock;
532 do_div(alow.ar_startext, tp->t_mountp->m_sb.sb_rextsize);
533 if (do_div(ahigh.ar_startext, tp->t_mountp->m_sb.sb_rextsize))
534 ahigh.ar_startext++;
535 error = xfs_rtalloc_query_range(tp, &alow, &ahigh,
536 xfs_getfsmap_rtdev_rtbitmap_helper, info);
537 if (error)
538 goto err;
539
540 /* Report any gaps at the end of the rtbitmap */
541 info->last = true;
542 error = xfs_getfsmap_rtdev_rtbitmap_helper(tp, &ahigh, info);
543 if (error)
544 goto err;
545err:
546 xfs_iunlock(tp->t_mountp->m_rbmip, XFS_ILOCK_SHARED);
547 return error;
548}
549
550/* Execute a getfsmap query against the realtime device rtbitmap. */
551STATIC int
552xfs_getfsmap_rtdev_rtbitmap(
553 struct xfs_trans *tp,
554 struct xfs_fsmap *keys,
555 struct xfs_getfsmap_info *info)
556{
557 info->missing_owner = XFS_FMR_OWN_UNKNOWN;
558 return __xfs_getfsmap_rtdev(tp, keys, xfs_getfsmap_rtdev_rtbitmap_query,
559 info);
560}
561#endif /* CONFIG_XFS_RT */
562
563/* Execute a getfsmap query against the regular data device. */
564STATIC int
565__xfs_getfsmap_datadev(
566 struct xfs_trans *tp,
567 struct xfs_fsmap *keys,
568 struct xfs_getfsmap_info *info,
569 int (*query_fn)(struct xfs_trans *,
570 struct xfs_getfsmap_info *,
571 struct xfs_btree_cur **,
572 void *),
573 void *priv)
574{
575 struct xfs_mount *mp = tp->t_mountp;
576 struct xfs_perag *pag;
577 struct xfs_btree_cur *bt_cur = NULL;
578 xfs_fsblock_t start_fsb;
579 xfs_fsblock_t end_fsb;
580 xfs_agnumber_t start_ag;
581 xfs_agnumber_t end_ag;
582 xfs_daddr_t eofs;
583 int error = 0;
584
585 eofs = XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks);
586 if (keys[0].fmr_physical >= eofs)
587 return 0;
588 if (keys[1].fmr_physical >= eofs)
589 keys[1].fmr_physical = eofs - 1;
590 start_fsb = XFS_DADDR_TO_FSB(mp, keys[0].fmr_physical);
591 end_fsb = XFS_DADDR_TO_FSB(mp, keys[1].fmr_physical);
592
593 /*
594 * Convert the fsmap low/high keys to AG based keys. Initialize
595 * low to the fsmap low key and max out the high key to the end
596 * of the AG.
597 */
598 info->low.rm_startblock = XFS_FSB_TO_AGBNO(mp, start_fsb);
599 info->low.rm_offset = XFS_BB_TO_FSBT(mp, keys[0].fmr_offset);
600 error = xfs_fsmap_owner_to_rmap(&info->low, &keys[0]);
601 if (error)
602 return error;
603 info->low.rm_blockcount = 0;
604 xfs_getfsmap_set_irec_flags(&info->low, &keys[0]);
605
606 info->high.rm_startblock = -1U;
607 info->high.rm_owner = ULLONG_MAX;
608 info->high.rm_offset = ULLONG_MAX;
609 info->high.rm_blockcount = 0;
610 info->high.rm_flags = XFS_RMAP_KEY_FLAGS | XFS_RMAP_REC_FLAGS;
611
612 start_ag = XFS_FSB_TO_AGNO(mp, start_fsb);
613 end_ag = XFS_FSB_TO_AGNO(mp, end_fsb);
614
615 for_each_perag_range(mp, start_ag, end_ag, pag) {
616 /*
617 * Set the AG high key from the fsmap high key if this
618 * is the last AG that we're querying.
619 */
620 info->pag = pag;
621 if (pag->pag_agno == end_ag) {
622 info->high.rm_startblock = XFS_FSB_TO_AGBNO(mp,
623 end_fsb);
624 info->high.rm_offset = XFS_BB_TO_FSBT(mp,
625 keys[1].fmr_offset);
626 error = xfs_fsmap_owner_to_rmap(&info->high, &keys[1]);
627 if (error)
628 break;
629 xfs_getfsmap_set_irec_flags(&info->high, &keys[1]);
630 }
631
632 if (bt_cur) {
633 xfs_btree_del_cursor(bt_cur, XFS_BTREE_NOERROR);
634 bt_cur = NULL;
635 xfs_trans_brelse(tp, info->agf_bp);
636 info->agf_bp = NULL;
637 }
638
639 error = xfs_alloc_read_agf(mp, tp, pag->pag_agno, 0,
640 &info->agf_bp);
641 if (error)
642 break;
643
644 trace_xfs_fsmap_low_key(mp, info->dev, pag->pag_agno,
645 &info->low);
646 trace_xfs_fsmap_high_key(mp, info->dev, pag->pag_agno,
647 &info->high);
648
649 error = query_fn(tp, info, &bt_cur, priv);
650 if (error)
651 break;
652
653 /*
654 * Set the AG low key to the start of the AG prior to
655 * moving on to the next AG.
656 */
657 if (pag->pag_agno == start_ag) {
658 info->low.rm_startblock = 0;
659 info->low.rm_owner = 0;
660 info->low.rm_offset = 0;
661 info->low.rm_flags = 0;
662 }
663
664 /*
665 * If this is the last AG, report any gap at the end of it
666 * before we drop the reference to the perag when the loop
667 * terminates.
668 */
669 if (pag->pag_agno == end_ag) {
670 info->last = true;
671 error = query_fn(tp, info, &bt_cur, priv);
672 if (error)
673 break;
674 }
675 info->pag = NULL;
676 }
677
678 if (bt_cur)
679 xfs_btree_del_cursor(bt_cur, error < 0 ? XFS_BTREE_ERROR :
680 XFS_BTREE_NOERROR);
681 if (info->agf_bp) {
682 xfs_trans_brelse(tp, info->agf_bp);
683 info->agf_bp = NULL;
684 }
685 if (info->pag) {
686 xfs_perag_put(info->pag);
687 info->pag = NULL;
688 } else if (pag) {
689 /* loop termination case */
690 xfs_perag_put(pag);
691 }
692
693 return error;
694}
695
696/* Actually query the rmap btree. */
697STATIC int
698xfs_getfsmap_datadev_rmapbt_query(
699 struct xfs_trans *tp,
700 struct xfs_getfsmap_info *info,
701 struct xfs_btree_cur **curpp,
702 void *priv)
703{
704 /* Report any gap at the end of the last AG. */
705 if (info->last)
706 return xfs_getfsmap_datadev_helper(*curpp, &info->high, info);
707
708 /* Allocate cursor for this AG and query_range it. */
709 *curpp = xfs_rmapbt_init_cursor(tp->t_mountp, tp, info->agf_bp,
710 info->pag);
711 return xfs_rmap_query_range(*curpp, &info->low, &info->high,
712 xfs_getfsmap_datadev_helper, info);
713}
714
715/* Execute a getfsmap query against the regular data device rmapbt. */
716STATIC int
717xfs_getfsmap_datadev_rmapbt(
718 struct xfs_trans *tp,
719 struct xfs_fsmap *keys,
720 struct xfs_getfsmap_info *info)
721{
722 info->missing_owner = XFS_FMR_OWN_FREE;
723 return __xfs_getfsmap_datadev(tp, keys, info,
724 xfs_getfsmap_datadev_rmapbt_query, NULL);
725}
726
727/* Actually query the bno btree. */
728STATIC int
729xfs_getfsmap_datadev_bnobt_query(
730 struct xfs_trans *tp,
731 struct xfs_getfsmap_info *info,
732 struct xfs_btree_cur **curpp,
733 void *priv)
734{
735 struct xfs_alloc_rec_incore *key = priv;
736
737 /* Report any gap at the end of the last AG. */
738 if (info->last)
739 return xfs_getfsmap_datadev_bnobt_helper(*curpp, &key[1], info);
740
741 /* Allocate cursor for this AG and query_range it. */
742 *curpp = xfs_allocbt_init_cursor(tp->t_mountp, tp, info->agf_bp,
743 info->pag, XFS_BTNUM_BNO);
744 key->ar_startblock = info->low.rm_startblock;
745 key[1].ar_startblock = info->high.rm_startblock;
746 return xfs_alloc_query_range(*curpp, key, &key[1],
747 xfs_getfsmap_datadev_bnobt_helper, info);
748}
749
750/* Execute a getfsmap query against the regular data device's bnobt. */
751STATIC int
752xfs_getfsmap_datadev_bnobt(
753 struct xfs_trans *tp,
754 struct xfs_fsmap *keys,
755 struct xfs_getfsmap_info *info)
756{
757 struct xfs_alloc_rec_incore akeys[2];
758
759 info->missing_owner = XFS_FMR_OWN_UNKNOWN;
760 return __xfs_getfsmap_datadev(tp, keys, info,
761 xfs_getfsmap_datadev_bnobt_query, &akeys[0]);
762}
763
764/* Do we recognize the device? */
765STATIC bool
766xfs_getfsmap_is_valid_device(
767 struct xfs_mount *mp,
768 struct xfs_fsmap *fm)
769{
770 if (fm->fmr_device == 0 || fm->fmr_device == UINT_MAX ||
771 fm->fmr_device == new_encode_dev(mp->m_ddev_targp->bt_dev))
772 return true;
773 if (mp->m_logdev_targp &&
774 fm->fmr_device == new_encode_dev(mp->m_logdev_targp->bt_dev))
775 return true;
776 if (mp->m_rtdev_targp &&
777 fm->fmr_device == new_encode_dev(mp->m_rtdev_targp->bt_dev))
778 return true;
779 return false;
780}
781
782/* Ensure that the low key is less than the high key. */
783STATIC bool
784xfs_getfsmap_check_keys(
785 struct xfs_fsmap *low_key,
786 struct xfs_fsmap *high_key)
787{
788 if (low_key->fmr_device > high_key->fmr_device)
789 return false;
790 if (low_key->fmr_device < high_key->fmr_device)
791 return true;
792
793 if (low_key->fmr_physical > high_key->fmr_physical)
794 return false;
795 if (low_key->fmr_physical < high_key->fmr_physical)
796 return true;
797
798 if (low_key->fmr_owner > high_key->fmr_owner)
799 return false;
800 if (low_key->fmr_owner < high_key->fmr_owner)
801 return true;
802
803 if (low_key->fmr_offset > high_key->fmr_offset)
804 return false;
805 if (low_key->fmr_offset < high_key->fmr_offset)
806 return true;
807
808 return false;
809}
810
811/*
812 * There are only two devices if we didn't configure RT devices at build time.
813 */
814#ifdef CONFIG_XFS_RT
815#define XFS_GETFSMAP_DEVS 3
816#else
817#define XFS_GETFSMAP_DEVS 2
818#endif /* CONFIG_XFS_RT */
819
820/*
821 * Get filesystem's extents as described in head, and format for output. Fills
822 * in the supplied records array until there are no more reverse mappings to
823 * return or head.fmh_entries == head.fmh_count. In the second case, this
824 * function returns -ECANCELED to indicate that more records would have been
825 * returned.
826 *
827 * Key to Confusion
828 * ----------------
829 * There are multiple levels of keys and counters at work here:
830 * xfs_fsmap_head.fmh_keys -- low and high fsmap keys passed in;
831 * these reflect fs-wide sector addrs.
832 * dkeys -- fmh_keys used to query each device;
833 * these are fmh_keys but w/ the low key
834 * bumped up by fmr_length.
835 * xfs_getfsmap_info.next_daddr -- next disk addr we expect to see; this
836 * is how we detect gaps in the fsmap
837 records and report them.
838 * xfs_getfsmap_info.low/high -- per-AG low/high keys computed from
839 * dkeys; used to query the metadata.
840 */
841int
842xfs_getfsmap(
843 struct xfs_mount *mp,
844 struct xfs_fsmap_head *head,
845 struct fsmap *fsmap_recs)
846{
847 struct xfs_trans *tp = NULL;
848 struct xfs_fsmap dkeys[2]; /* per-dev keys */
849 struct xfs_getfsmap_dev handlers[XFS_GETFSMAP_DEVS];
850 struct xfs_getfsmap_info info = { NULL };
851 bool use_rmap;
852 int i;
853 int error = 0;
854
855 if (head->fmh_iflags & ~FMH_IF_VALID)
856 return -EINVAL;
857 if (!xfs_getfsmap_is_valid_device(mp, &head->fmh_keys[0]) ||
858 !xfs_getfsmap_is_valid_device(mp, &head->fmh_keys[1]))
859 return -EINVAL;
860
861 use_rmap = capable(CAP_SYS_ADMIN) &&
862 xfs_sb_version_hasrmapbt(&mp->m_sb);
863 head->fmh_entries = 0;
864
865 /* Set up our device handlers. */
866 memset(handlers, 0, sizeof(handlers));
867 handlers[0].dev = new_encode_dev(mp->m_ddev_targp->bt_dev);
868 if (use_rmap)
869 handlers[0].fn = xfs_getfsmap_datadev_rmapbt;
870 else
871 handlers[0].fn = xfs_getfsmap_datadev_bnobt;
872 if (mp->m_logdev_targp != mp->m_ddev_targp) {
873 handlers[1].dev = new_encode_dev(mp->m_logdev_targp->bt_dev);
874 handlers[1].fn = xfs_getfsmap_logdev;
875 }
876#ifdef CONFIG_XFS_RT
877 if (mp->m_rtdev_targp) {
878 handlers[2].dev = new_encode_dev(mp->m_rtdev_targp->bt_dev);
879 handlers[2].fn = xfs_getfsmap_rtdev_rtbitmap;
880 }
881#endif /* CONFIG_XFS_RT */
882
883 xfs_sort(handlers, XFS_GETFSMAP_DEVS, sizeof(struct xfs_getfsmap_dev),
884 xfs_getfsmap_dev_compare);
885
886 /*
887 * To continue where we left off, we allow userspace to use the
888 * last mapping from a previous call as the low key of the next.
889 * This is identified by a non-zero length in the low key. We
890 * have to increment the low key in this scenario to ensure we
891 * don't return the same mapping again, and instead return the
892 * very next mapping.
893 *
894 * If the low key mapping refers to file data, the same physical
895 * blocks could be mapped to several other files/offsets.
896 * According to rmapbt record ordering, the minimal next
897 * possible record for the block range is the next starting
898 * offset in the same inode. Therefore, bump the file offset to
899 * continue the search appropriately. For all other low key
900 * mapping types (attr blocks, metadata), bump the physical
901 * offset as there can be no other mapping for the same physical
902 * block range.
903 */
904 dkeys[0] = head->fmh_keys[0];
905 if (dkeys[0].fmr_flags & (FMR_OF_SPECIAL_OWNER | FMR_OF_EXTENT_MAP)) {
906 dkeys[0].fmr_physical += dkeys[0].fmr_length;
907 dkeys[0].fmr_owner = 0;
908 if (dkeys[0].fmr_offset)
909 return -EINVAL;
910 } else
911 dkeys[0].fmr_offset += dkeys[0].fmr_length;
912 dkeys[0].fmr_length = 0;
913 memset(&dkeys[1], 0xFF, sizeof(struct xfs_fsmap));
914
915 if (!xfs_getfsmap_check_keys(dkeys, &head->fmh_keys[1]))
916 return -EINVAL;
917
918 info.next_daddr = head->fmh_keys[0].fmr_physical +
919 head->fmh_keys[0].fmr_length;
920 info.fsmap_recs = fsmap_recs;
921 info.head = head;
922
923 /* For each device we support... */
924 for (i = 0; i < XFS_GETFSMAP_DEVS; i++) {
925 /* Is this device within the range the user asked for? */
926 if (!handlers[i].fn)
927 continue;
928 if (head->fmh_keys[0].fmr_device > handlers[i].dev)
929 continue;
930 if (head->fmh_keys[1].fmr_device < handlers[i].dev)
931 break;
932
933 /*
934 * If this device number matches the high key, we have
935 * to pass the high key to the handler to limit the
936 * query results. If the device number exceeds the
937 * low key, zero out the low key so that we get
938 * everything from the beginning.
939 */
940 if (handlers[i].dev == head->fmh_keys[1].fmr_device)
941 dkeys[1] = head->fmh_keys[1];
942 if (handlers[i].dev > head->fmh_keys[0].fmr_device)
943 memset(&dkeys[0], 0, sizeof(struct xfs_fsmap));
944
945 /*
946 * Grab an empty transaction so that we can use its recursive
947 * buffer locking abilities to detect cycles in the rmapbt
948 * without deadlocking.
949 */
950 error = xfs_trans_alloc_empty(mp, &tp);
951 if (error)
952 break;
953
954 info.dev = handlers[i].dev;
955 info.last = false;
956 info.pag = NULL;
957 error = handlers[i].fn(tp, dkeys, &info);
958 if (error)
959 break;
960 xfs_trans_cancel(tp);
961 tp = NULL;
962 info.next_daddr = 0;
963 }
964
965 if (tp)
966 xfs_trans_cancel(tp);
967 head->fmh_oflags = FMH_OF_DEV_T;
968 return error;
969}