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