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_rtbitmap.h" |
27 | #include "xfs_ag.h" |
28 | |
29 | /* Convert an xfs_fsmap to an fsmap. */ |
30 | static void |
31 | xfs_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. */ |
47 | void |
48 | xfs_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. */ |
61 | static int |
62 | xfs_fsmap_owner_to_rmap( |
63 | struct xfs_rmap_irec *dest, |
64 | const 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. */ |
112 | static int |
113 | xfs_fsmap_owner_from_rmap( |
114 | struct xfs_fsmap *dest, |
115 | const 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 */ |
157 | struct 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 | /* daddr of low fsmap key when we're using the rtbitmap */ |
164 | xfs_daddr_t low_daddr; |
165 | u64 missing_owner; /* owner of holes */ |
166 | u32 dev; /* device id */ |
167 | /* |
168 | * Low rmap key for the query. If low.rm_blockcount is nonzero, this |
169 | * is the second (or later) call to retrieve the recordset in pieces. |
170 | * xfs_getfsmap_rec_before_start will compare all records retrieved |
171 | * by the rmapbt query to filter out any records that start before |
172 | * the last record. |
173 | */ |
174 | struct xfs_rmap_irec low; |
175 | struct xfs_rmap_irec high; /* high rmap key */ |
176 | bool last; /* last extent? */ |
177 | }; |
178 | |
179 | /* Associate a device with a getfsmap handler. */ |
180 | struct xfs_getfsmap_dev { |
181 | u32 dev; |
182 | int (*fn)(struct xfs_trans *tp, |
183 | const struct xfs_fsmap *keys, |
184 | struct xfs_getfsmap_info *info); |
185 | }; |
186 | |
187 | /* Compare two getfsmap device handlers. */ |
188 | static int |
189 | xfs_getfsmap_dev_compare( |
190 | const void *p1, |
191 | const void *p2) |
192 | { |
193 | const struct xfs_getfsmap_dev *d1 = p1; |
194 | const struct xfs_getfsmap_dev *d2 = p2; |
195 | |
196 | return d1->dev - d2->dev; |
197 | } |
198 | |
199 | /* Decide if this mapping is shared. */ |
200 | STATIC int |
201 | xfs_getfsmap_is_shared( |
202 | struct xfs_trans *tp, |
203 | struct xfs_getfsmap_info *info, |
204 | const struct xfs_rmap_irec *rec, |
205 | bool *stat) |
206 | { |
207 | struct xfs_mount *mp = tp->t_mountp; |
208 | struct xfs_btree_cur *cur; |
209 | xfs_agblock_t fbno; |
210 | xfs_extlen_t flen; |
211 | int error; |
212 | |
213 | *stat = false; |
214 | if (!xfs_has_reflink(mp)) |
215 | return 0; |
216 | /* rt files will have no perag structure */ |
217 | if (!info->pag) |
218 | return 0; |
219 | |
220 | /* Are there any shared blocks here? */ |
221 | flen = 0; |
222 | cur = xfs_refcountbt_init_cursor(mp, tp, info->agf_bp, info->pag); |
223 | |
224 | error = xfs_refcount_find_shared(cur, rec->rm_startblock, |
225 | rec->rm_blockcount, &fbno, &flen, false); |
226 | |
227 | xfs_btree_del_cursor(cur, error); |
228 | if (error) |
229 | return error; |
230 | |
231 | *stat = flen > 0; |
232 | return 0; |
233 | } |
234 | |
235 | static inline void |
236 | xfs_getfsmap_format( |
237 | struct xfs_mount *mp, |
238 | struct xfs_fsmap *xfm, |
239 | struct xfs_getfsmap_info *info) |
240 | { |
241 | struct fsmap *rec; |
242 | |
243 | trace_xfs_getfsmap_mapping(mp, fsmap: xfm); |
244 | |
245 | rec = &info->fsmap_recs[info->head->fmh_entries++]; |
246 | xfs_fsmap_from_internal(dest: rec, src: xfm); |
247 | } |
248 | |
249 | static inline bool |
250 | xfs_getfsmap_rec_before_start( |
251 | struct xfs_getfsmap_info *info, |
252 | const struct xfs_rmap_irec *rec, |
253 | xfs_daddr_t rec_daddr) |
254 | { |
255 | if (info->low_daddr != -1ULL) |
256 | return rec_daddr < info->low_daddr; |
257 | if (info->low.rm_blockcount) |
258 | return xfs_rmap_compare(rec, &info->low) < 0; |
259 | return false; |
260 | } |
261 | |
262 | /* |
263 | * Format a reverse mapping for getfsmap, having translated rm_startblock |
264 | * into the appropriate daddr units. Pass in a nonzero @len_daddr if the |
265 | * length could be larger than rm_blockcount in struct xfs_rmap_irec. |
266 | */ |
267 | STATIC int |
268 | xfs_getfsmap_helper( |
269 | struct xfs_trans *tp, |
270 | struct xfs_getfsmap_info *info, |
271 | const struct xfs_rmap_irec *rec, |
272 | xfs_daddr_t rec_daddr, |
273 | xfs_daddr_t len_daddr) |
274 | { |
275 | struct xfs_fsmap fmr; |
276 | struct xfs_mount *mp = tp->t_mountp; |
277 | bool shared; |
278 | int error; |
279 | |
280 | if (fatal_signal_pending(current)) |
281 | return -EINTR; |
282 | |
283 | if (len_daddr == 0) |
284 | len_daddr = XFS_FSB_TO_BB(mp, rec->rm_blockcount); |
285 | |
286 | /* |
287 | * Filter out records that start before our startpoint, if the |
288 | * caller requested that. |
289 | */ |
290 | if (xfs_getfsmap_rec_before_start(info, rec, rec_daddr)) { |
291 | rec_daddr += len_daddr; |
292 | if (info->next_daddr < rec_daddr) |
293 | info->next_daddr = rec_daddr; |
294 | return 0; |
295 | } |
296 | |
297 | /* Are we just counting mappings? */ |
298 | if (info->head->fmh_count == 0) { |
299 | if (info->head->fmh_entries == UINT_MAX) |
300 | return -ECANCELED; |
301 | |
302 | if (rec_daddr > info->next_daddr) |
303 | info->head->fmh_entries++; |
304 | |
305 | if (info->last) |
306 | return 0; |
307 | |
308 | info->head->fmh_entries++; |
309 | |
310 | rec_daddr += len_daddr; |
311 | if (info->next_daddr < rec_daddr) |
312 | info->next_daddr = rec_daddr; |
313 | return 0; |
314 | } |
315 | |
316 | /* |
317 | * If the record starts past the last physical block we saw, |
318 | * then we've found a gap. Report the gap as being owned by |
319 | * whatever the caller specified is the missing owner. |
320 | */ |
321 | if (rec_daddr > info->next_daddr) { |
322 | if (info->head->fmh_entries >= info->head->fmh_count) |
323 | return -ECANCELED; |
324 | |
325 | fmr.fmr_device = info->dev; |
326 | fmr.fmr_physical = info->next_daddr; |
327 | fmr.fmr_owner = info->missing_owner; |
328 | fmr.fmr_offset = 0; |
329 | fmr.fmr_length = rec_daddr - info->next_daddr; |
330 | fmr.fmr_flags = FMR_OF_SPECIAL_OWNER; |
331 | xfs_getfsmap_format(mp, xfm: &fmr, info); |
332 | } |
333 | |
334 | if (info->last) |
335 | goto out; |
336 | |
337 | /* Fill out the extent we found */ |
338 | if (info->head->fmh_entries >= info->head->fmh_count) |
339 | return -ECANCELED; |
340 | |
341 | trace_xfs_fsmap_mapping(mp, info->dev, |
342 | info->pag ? info->pag->pag_agno : NULLAGNUMBER, rec); |
343 | |
344 | fmr.fmr_device = info->dev; |
345 | fmr.fmr_physical = rec_daddr; |
346 | error = xfs_fsmap_owner_from_rmap(dest: &fmr, src: rec); |
347 | if (error) |
348 | return error; |
349 | fmr.fmr_offset = XFS_FSB_TO_BB(mp, rec->rm_offset); |
350 | fmr.fmr_length = len_daddr; |
351 | if (rec->rm_flags & XFS_RMAP_UNWRITTEN) |
352 | fmr.fmr_flags |= FMR_OF_PREALLOC; |
353 | if (rec->rm_flags & XFS_RMAP_ATTR_FORK) |
354 | fmr.fmr_flags |= FMR_OF_ATTR_FORK; |
355 | if (rec->rm_flags & XFS_RMAP_BMBT_BLOCK) |
356 | fmr.fmr_flags |= FMR_OF_EXTENT_MAP; |
357 | if (fmr.fmr_flags == 0) { |
358 | error = xfs_getfsmap_is_shared(tp, info, rec, stat: &shared); |
359 | if (error) |
360 | return error; |
361 | if (shared) |
362 | fmr.fmr_flags |= FMR_OF_SHARED; |
363 | } |
364 | |
365 | xfs_getfsmap_format(mp, xfm: &fmr, info); |
366 | out: |
367 | rec_daddr += len_daddr; |
368 | if (info->next_daddr < rec_daddr) |
369 | info->next_daddr = rec_daddr; |
370 | return 0; |
371 | } |
372 | |
373 | /* Transform a rmapbt irec into a fsmap */ |
374 | STATIC int |
375 | xfs_getfsmap_datadev_helper( |
376 | struct xfs_btree_cur *cur, |
377 | const struct xfs_rmap_irec *rec, |
378 | void *priv) |
379 | { |
380 | struct xfs_mount *mp = cur->bc_mp; |
381 | struct xfs_getfsmap_info *info = priv; |
382 | xfs_fsblock_t fsb; |
383 | xfs_daddr_t rec_daddr; |
384 | |
385 | fsb = XFS_AGB_TO_FSB(mp, cur->bc_ag.pag->pag_agno, rec->rm_startblock); |
386 | rec_daddr = XFS_FSB_TO_DADDR(mp, fsb); |
387 | |
388 | return xfs_getfsmap_helper(tp: cur->bc_tp, info, rec, rec_daddr, len_daddr: 0); |
389 | } |
390 | |
391 | /* Transform a bnobt irec into a fsmap */ |
392 | STATIC int |
393 | xfs_getfsmap_datadev_bnobt_helper( |
394 | struct xfs_btree_cur *cur, |
395 | const struct xfs_alloc_rec_incore *rec, |
396 | void *priv) |
397 | { |
398 | struct xfs_mount *mp = cur->bc_mp; |
399 | struct xfs_getfsmap_info *info = priv; |
400 | struct xfs_rmap_irec irec; |
401 | xfs_daddr_t rec_daddr; |
402 | |
403 | rec_daddr = XFS_AGB_TO_DADDR(mp, cur->bc_ag.pag->pag_agno, |
404 | rec->ar_startblock); |
405 | |
406 | irec.rm_startblock = rec->ar_startblock; |
407 | irec.rm_blockcount = rec->ar_blockcount; |
408 | irec.rm_owner = XFS_RMAP_OWN_NULL; /* "free" */ |
409 | irec.rm_offset = 0; |
410 | irec.rm_flags = 0; |
411 | |
412 | return xfs_getfsmap_helper(tp: cur->bc_tp, info, rec: &irec, rec_daddr, len_daddr: 0); |
413 | } |
414 | |
415 | /* Set rmap flags based on the getfsmap flags */ |
416 | static void |
417 | xfs_getfsmap_set_irec_flags( |
418 | struct xfs_rmap_irec *irec, |
419 | const struct xfs_fsmap *fmr) |
420 | { |
421 | irec->rm_flags = 0; |
422 | if (fmr->fmr_flags & FMR_OF_ATTR_FORK) |
423 | irec->rm_flags |= XFS_RMAP_ATTR_FORK; |
424 | if (fmr->fmr_flags & FMR_OF_EXTENT_MAP) |
425 | irec->rm_flags |= XFS_RMAP_BMBT_BLOCK; |
426 | if (fmr->fmr_flags & FMR_OF_PREALLOC) |
427 | irec->rm_flags |= XFS_RMAP_UNWRITTEN; |
428 | } |
429 | |
430 | /* Execute a getfsmap query against the log device. */ |
431 | STATIC int |
432 | xfs_getfsmap_logdev( |
433 | struct xfs_trans *tp, |
434 | const struct xfs_fsmap *keys, |
435 | struct xfs_getfsmap_info *info) |
436 | { |
437 | struct xfs_mount *mp = tp->t_mountp; |
438 | struct xfs_rmap_irec rmap; |
439 | xfs_daddr_t rec_daddr, len_daddr; |
440 | xfs_fsblock_t start_fsb, end_fsb; |
441 | uint64_t eofs; |
442 | |
443 | eofs = XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks); |
444 | if (keys[0].fmr_physical >= eofs) |
445 | return 0; |
446 | start_fsb = XFS_BB_TO_FSBT(mp, |
447 | keys[0].fmr_physical + keys[0].fmr_length); |
448 | end_fsb = XFS_BB_TO_FSB(mp, min(eofs - 1, keys[1].fmr_physical)); |
449 | |
450 | /* Adjust the low key if we are continuing from where we left off. */ |
451 | if (keys[0].fmr_length > 0) |
452 | info->low_daddr = XFS_FSB_TO_BB(mp, start_fsb); |
453 | |
454 | trace_xfs_fsmap_low_key_linear(mp, info->dev, start_fsb); |
455 | trace_xfs_fsmap_high_key_linear(mp, info->dev, end_fsb); |
456 | |
457 | if (start_fsb > 0) |
458 | return 0; |
459 | |
460 | /* Fabricate an rmap entry for the external log device. */ |
461 | rmap.rm_startblock = 0; |
462 | rmap.rm_blockcount = mp->m_sb.sb_logblocks; |
463 | rmap.rm_owner = XFS_RMAP_OWN_LOG; |
464 | rmap.rm_offset = 0; |
465 | rmap.rm_flags = 0; |
466 | |
467 | rec_daddr = XFS_FSB_TO_BB(mp, rmap.rm_startblock); |
468 | len_daddr = XFS_FSB_TO_BB(mp, rmap.rm_blockcount); |
469 | return xfs_getfsmap_helper(tp, info, rec: &rmap, rec_daddr, len_daddr); |
470 | } |
471 | |
472 | #ifdef CONFIG_XFS_RT |
473 | /* Transform a rtbitmap "record" into a fsmap */ |
474 | STATIC int |
475 | xfs_getfsmap_rtdev_rtbitmap_helper( |
476 | struct xfs_mount *mp, |
477 | struct xfs_trans *tp, |
478 | const struct xfs_rtalloc_rec *rec, |
479 | void *priv) |
480 | { |
481 | struct xfs_getfsmap_info *info = priv; |
482 | struct xfs_rmap_irec irec; |
483 | xfs_rtblock_t rtbno; |
484 | xfs_daddr_t rec_daddr, len_daddr; |
485 | |
486 | rtbno = xfs_rtx_to_rtb(mp, rec->ar_startext); |
487 | rec_daddr = XFS_FSB_TO_BB(mp, rtbno); |
488 | irec.rm_startblock = rtbno; |
489 | |
490 | rtbno = xfs_rtx_to_rtb(mp, rec->ar_extcount); |
491 | len_daddr = XFS_FSB_TO_BB(mp, rtbno); |
492 | irec.rm_blockcount = rtbno; |
493 | |
494 | irec.rm_owner = XFS_RMAP_OWN_NULL; /* "free" */ |
495 | irec.rm_offset = 0; |
496 | irec.rm_flags = 0; |
497 | |
498 | return xfs_getfsmap_helper(tp, info, rec: &irec, rec_daddr, len_daddr); |
499 | } |
500 | |
501 | /* Execute a getfsmap query against the realtime device rtbitmap. */ |
502 | STATIC int |
503 | xfs_getfsmap_rtdev_rtbitmap( |
504 | struct xfs_trans *tp, |
505 | const struct xfs_fsmap *keys, |
506 | struct xfs_getfsmap_info *info) |
507 | { |
508 | |
509 | struct xfs_rtalloc_rec alow = { 0 }; |
510 | struct xfs_rtalloc_rec ahigh = { 0 }; |
511 | struct xfs_mount *mp = tp->t_mountp; |
512 | xfs_rtblock_t start_rtb; |
513 | xfs_rtblock_t end_rtb; |
514 | uint64_t eofs; |
515 | int error; |
516 | |
517 | eofs = XFS_FSB_TO_BB(mp, xfs_rtx_to_rtb(mp, mp->m_sb.sb_rextents)); |
518 | if (keys[0].fmr_physical >= eofs) |
519 | return 0; |
520 | start_rtb = XFS_BB_TO_FSBT(mp, |
521 | keys[0].fmr_physical + keys[0].fmr_length); |
522 | end_rtb = XFS_BB_TO_FSB(mp, min(eofs - 1, keys[1].fmr_physical)); |
523 | |
524 | info->missing_owner = XFS_FMR_OWN_UNKNOWN; |
525 | |
526 | /* Adjust the low key if we are continuing from where we left off. */ |
527 | if (keys[0].fmr_length > 0) { |
528 | info->low_daddr = XFS_FSB_TO_BB(mp, start_rtb); |
529 | if (info->low_daddr >= eofs) |
530 | return 0; |
531 | } |
532 | |
533 | trace_xfs_fsmap_low_key_linear(mp, info->dev, start_rtb); |
534 | trace_xfs_fsmap_high_key_linear(mp, info->dev, end_rtb); |
535 | |
536 | xfs_ilock(mp->m_rbmip, XFS_ILOCK_SHARED | XFS_ILOCK_RTBITMAP); |
537 | |
538 | /* |
539 | * Set up query parameters to return free rtextents covering the range |
540 | * we want. |
541 | */ |
542 | alow.ar_startext = xfs_rtb_to_rtx(mp, start_rtb); |
543 | ahigh.ar_startext = xfs_rtb_to_rtxup(mp, end_rtb); |
544 | error = xfs_rtalloc_query_range(mp, tp, &alow, &ahigh, |
545 | xfs_getfsmap_rtdev_rtbitmap_helper, info); |
546 | if (error) |
547 | goto err; |
548 | |
549 | /* |
550 | * Report any gaps at the end of the rtbitmap by simulating a null |
551 | * rmap starting at the block after the end of the query range. |
552 | */ |
553 | info->last = true; |
554 | ahigh.ar_startext = min(mp->m_sb.sb_rextents, ahigh.ar_startext); |
555 | |
556 | error = xfs_getfsmap_rtdev_rtbitmap_helper(mp, tp, rec: &ahigh, priv: info); |
557 | if (error) |
558 | goto err; |
559 | err: |
560 | xfs_iunlock(mp->m_rbmip, XFS_ILOCK_SHARED | XFS_ILOCK_RTBITMAP); |
561 | return error; |
562 | } |
563 | #endif /* CONFIG_XFS_RT */ |
564 | |
565 | static inline bool |
566 | rmap_not_shareable(struct xfs_mount *mp, const struct xfs_rmap_irec *r) |
567 | { |
568 | if (!xfs_has_reflink(mp)) |
569 | return true; |
570 | if (XFS_RMAP_NON_INODE_OWNER(r->rm_owner)) |
571 | return true; |
572 | if (r->rm_flags & (XFS_RMAP_ATTR_FORK | XFS_RMAP_BMBT_BLOCK | |
573 | XFS_RMAP_UNWRITTEN)) |
574 | return true; |
575 | return false; |
576 | } |
577 | |
578 | /* Execute a getfsmap query against the regular data device. */ |
579 | STATIC int |
580 | __xfs_getfsmap_datadev( |
581 | struct xfs_trans *tp, |
582 | const struct xfs_fsmap *keys, |
583 | struct xfs_getfsmap_info *info, |
584 | int (*query_fn)(struct xfs_trans *, |
585 | struct xfs_getfsmap_info *, |
586 | struct xfs_btree_cur **, |
587 | void *), |
588 | void *priv) |
589 | { |
590 | struct xfs_mount *mp = tp->t_mountp; |
591 | struct xfs_perag *pag; |
592 | struct xfs_btree_cur *bt_cur = NULL; |
593 | xfs_fsblock_t start_fsb; |
594 | xfs_fsblock_t end_fsb; |
595 | xfs_agnumber_t start_ag; |
596 | xfs_agnumber_t end_ag; |
597 | uint64_t eofs; |
598 | int error = 0; |
599 | |
600 | eofs = XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks); |
601 | if (keys[0].fmr_physical >= eofs) |
602 | return 0; |
603 | start_fsb = XFS_DADDR_TO_FSB(mp, keys[0].fmr_physical); |
604 | end_fsb = XFS_DADDR_TO_FSB(mp, min(eofs - 1, keys[1].fmr_physical)); |
605 | |
606 | /* |
607 | * Convert the fsmap low/high keys to AG based keys. Initialize |
608 | * low to the fsmap low key and max out the high key to the end |
609 | * of the AG. |
610 | */ |
611 | info->low.rm_offset = XFS_BB_TO_FSBT(mp, keys[0].fmr_offset); |
612 | error = xfs_fsmap_owner_to_rmap(dest: &info->low, src: &keys[0]); |
613 | if (error) |
614 | return error; |
615 | info->low.rm_blockcount = XFS_BB_TO_FSBT(mp, keys[0].fmr_length); |
616 | xfs_getfsmap_set_irec_flags(irec: &info->low, fmr: &keys[0]); |
617 | |
618 | /* Adjust the low key if we are continuing from where we left off. */ |
619 | if (info->low.rm_blockcount == 0) { |
620 | /* No previous record from which to continue */ |
621 | } else if (rmap_not_shareable(mp, r: &info->low)) { |
622 | /* Last record seen was an unshareable extent */ |
623 | info->low.rm_owner = 0; |
624 | info->low.rm_offset = 0; |
625 | |
626 | start_fsb += info->low.rm_blockcount; |
627 | if (XFS_FSB_TO_DADDR(mp, start_fsb) >= eofs) |
628 | return 0; |
629 | } else { |
630 | /* Last record seen was a shareable file data extent */ |
631 | info->low.rm_offset += info->low.rm_blockcount; |
632 | } |
633 | info->low.rm_startblock = XFS_FSB_TO_AGBNO(mp, start_fsb); |
634 | |
635 | info->high.rm_startblock = -1U; |
636 | info->high.rm_owner = ULLONG_MAX; |
637 | info->high.rm_offset = ULLONG_MAX; |
638 | info->high.rm_blockcount = 0; |
639 | info->high.rm_flags = XFS_RMAP_KEY_FLAGS | XFS_RMAP_REC_FLAGS; |
640 | |
641 | start_ag = XFS_FSB_TO_AGNO(mp, start_fsb); |
642 | end_ag = XFS_FSB_TO_AGNO(mp, end_fsb); |
643 | |
644 | for_each_perag_range(mp, start_ag, end_ag, pag) { |
645 | /* |
646 | * Set the AG high key from the fsmap high key if this |
647 | * is the last AG that we're querying. |
648 | */ |
649 | info->pag = pag; |
650 | if (pag->pag_agno == end_ag) { |
651 | info->high.rm_startblock = XFS_FSB_TO_AGBNO(mp, |
652 | end_fsb); |
653 | info->high.rm_offset = XFS_BB_TO_FSBT(mp, |
654 | keys[1].fmr_offset); |
655 | error = xfs_fsmap_owner_to_rmap(&info->high, &keys[1]); |
656 | if (error) |
657 | break; |
658 | xfs_getfsmap_set_irec_flags(&info->high, &keys[1]); |
659 | } |
660 | |
661 | if (bt_cur) { |
662 | xfs_btree_del_cursor(bt_cur, XFS_BTREE_NOERROR); |
663 | bt_cur = NULL; |
664 | xfs_trans_brelse(tp, info->agf_bp); |
665 | info->agf_bp = NULL; |
666 | } |
667 | |
668 | error = xfs_alloc_read_agf(pag, tp, 0, &info->agf_bp); |
669 | if (error) |
670 | break; |
671 | |
672 | trace_xfs_fsmap_low_key(mp, info->dev, pag->pag_agno, |
673 | &info->low); |
674 | trace_xfs_fsmap_high_key(mp, info->dev, pag->pag_agno, |
675 | &info->high); |
676 | |
677 | error = query_fn(tp, info, &bt_cur, priv); |
678 | if (error) |
679 | break; |
680 | |
681 | /* |
682 | * Set the AG low key to the start of the AG prior to |
683 | * moving on to the next AG. |
684 | */ |
685 | if (pag->pag_agno == start_ag) |
686 | memset(&info->low, 0, sizeof(info->low)); |
687 | |
688 | /* |
689 | * If this is the last AG, report any gap at the end of it |
690 | * before we drop the reference to the perag when the loop |
691 | * terminates. |
692 | */ |
693 | if (pag->pag_agno == end_ag) { |
694 | info->last = true; |
695 | error = query_fn(tp, info, &bt_cur, priv); |
696 | if (error) |
697 | break; |
698 | } |
699 | info->pag = NULL; |
700 | } |
701 | |
702 | if (bt_cur) |
703 | xfs_btree_del_cursor(bt_cur, error < 0 ? XFS_BTREE_ERROR : |
704 | XFS_BTREE_NOERROR); |
705 | if (info->agf_bp) { |
706 | xfs_trans_brelse(tp, info->agf_bp); |
707 | info->agf_bp = NULL; |
708 | } |
709 | if (info->pag) { |
710 | xfs_perag_rele(info->pag); |
711 | info->pag = NULL; |
712 | } else if (pag) { |
713 | /* loop termination case */ |
714 | xfs_perag_rele(pag); |
715 | } |
716 | |
717 | return error; |
718 | } |
719 | |
720 | /* Actually query the rmap btree. */ |
721 | STATIC int |
722 | xfs_getfsmap_datadev_rmapbt_query( |
723 | struct xfs_trans *tp, |
724 | struct xfs_getfsmap_info *info, |
725 | struct xfs_btree_cur **curpp, |
726 | void *priv) |
727 | { |
728 | /* Report any gap at the end of the last AG. */ |
729 | if (info->last) |
730 | return xfs_getfsmap_datadev_helper(cur: *curpp, rec: &info->high, priv: info); |
731 | |
732 | /* Allocate cursor for this AG and query_range it. */ |
733 | *curpp = xfs_rmapbt_init_cursor(tp->t_mountp, tp, info->agf_bp, |
734 | info->pag); |
735 | return xfs_rmap_query_range(*curpp, &info->low, &info->high, |
736 | xfs_getfsmap_datadev_helper, info); |
737 | } |
738 | |
739 | /* Execute a getfsmap query against the regular data device rmapbt. */ |
740 | STATIC int |
741 | xfs_getfsmap_datadev_rmapbt( |
742 | struct xfs_trans *tp, |
743 | const struct xfs_fsmap *keys, |
744 | struct xfs_getfsmap_info *info) |
745 | { |
746 | info->missing_owner = XFS_FMR_OWN_FREE; |
747 | return __xfs_getfsmap_datadev(tp, keys, info, |
748 | query_fn: xfs_getfsmap_datadev_rmapbt_query, NULL); |
749 | } |
750 | |
751 | /* Actually query the bno btree. */ |
752 | STATIC int |
753 | xfs_getfsmap_datadev_bnobt_query( |
754 | struct xfs_trans *tp, |
755 | struct xfs_getfsmap_info *info, |
756 | struct xfs_btree_cur **curpp, |
757 | void *priv) |
758 | { |
759 | struct xfs_alloc_rec_incore *key = priv; |
760 | |
761 | /* Report any gap at the end of the last AG. */ |
762 | if (info->last) |
763 | return xfs_getfsmap_datadev_bnobt_helper(*curpp, &key[1], info); |
764 | |
765 | /* Allocate cursor for this AG and query_range it. */ |
766 | *curpp = xfs_bnobt_init_cursor(tp->t_mountp, tp, info->agf_bp, |
767 | info->pag); |
768 | key->ar_startblock = info->low.rm_startblock; |
769 | key[1].ar_startblock = info->high.rm_startblock; |
770 | return xfs_alloc_query_range(*curpp, key, &key[1], |
771 | xfs_getfsmap_datadev_bnobt_helper, info); |
772 | } |
773 | |
774 | /* Execute a getfsmap query against the regular data device's bnobt. */ |
775 | STATIC int |
776 | xfs_getfsmap_datadev_bnobt( |
777 | struct xfs_trans *tp, |
778 | const struct xfs_fsmap *keys, |
779 | struct xfs_getfsmap_info *info) |
780 | { |
781 | struct xfs_alloc_rec_incore akeys[2]; |
782 | |
783 | memset(akeys, 0, sizeof(akeys)); |
784 | info->missing_owner = XFS_FMR_OWN_UNKNOWN; |
785 | return __xfs_getfsmap_datadev(tp, keys, info, |
786 | query_fn: xfs_getfsmap_datadev_bnobt_query, priv: &akeys[0]); |
787 | } |
788 | |
789 | /* Do we recognize the device? */ |
790 | STATIC bool |
791 | xfs_getfsmap_is_valid_device( |
792 | struct xfs_mount *mp, |
793 | struct xfs_fsmap *fm) |
794 | { |
795 | if (fm->fmr_device == 0 || fm->fmr_device == UINT_MAX || |
796 | fm->fmr_device == new_encode_dev(dev: mp->m_ddev_targp->bt_dev)) |
797 | return true; |
798 | if (mp->m_logdev_targp && |
799 | fm->fmr_device == new_encode_dev(dev: mp->m_logdev_targp->bt_dev)) |
800 | return true; |
801 | if (mp->m_rtdev_targp && |
802 | fm->fmr_device == new_encode_dev(dev: mp->m_rtdev_targp->bt_dev)) |
803 | return true; |
804 | return false; |
805 | } |
806 | |
807 | /* Ensure that the low key is less than the high key. */ |
808 | STATIC bool |
809 | xfs_getfsmap_check_keys( |
810 | struct xfs_fsmap *low_key, |
811 | struct xfs_fsmap *high_key) |
812 | { |
813 | if (low_key->fmr_flags & (FMR_OF_SPECIAL_OWNER | FMR_OF_EXTENT_MAP)) { |
814 | if (low_key->fmr_offset) |
815 | return false; |
816 | } |
817 | if (high_key->fmr_flags != -1U && |
818 | (high_key->fmr_flags & (FMR_OF_SPECIAL_OWNER | |
819 | FMR_OF_EXTENT_MAP))) { |
820 | if (high_key->fmr_offset && high_key->fmr_offset != -1ULL) |
821 | return false; |
822 | } |
823 | if (high_key->fmr_length && high_key->fmr_length != -1ULL) |
824 | return false; |
825 | |
826 | if (low_key->fmr_device > high_key->fmr_device) |
827 | return false; |
828 | if (low_key->fmr_device < high_key->fmr_device) |
829 | return true; |
830 | |
831 | if (low_key->fmr_physical > high_key->fmr_physical) |
832 | return false; |
833 | if (low_key->fmr_physical < high_key->fmr_physical) |
834 | return true; |
835 | |
836 | if (low_key->fmr_owner > high_key->fmr_owner) |
837 | return false; |
838 | if (low_key->fmr_owner < high_key->fmr_owner) |
839 | return true; |
840 | |
841 | if (low_key->fmr_offset > high_key->fmr_offset) |
842 | return false; |
843 | if (low_key->fmr_offset < high_key->fmr_offset) |
844 | return true; |
845 | |
846 | return false; |
847 | } |
848 | |
849 | /* |
850 | * There are only two devices if we didn't configure RT devices at build time. |
851 | */ |
852 | #ifdef CONFIG_XFS_RT |
853 | #define XFS_GETFSMAP_DEVS 3 |
854 | #else |
855 | #define XFS_GETFSMAP_DEVS 2 |
856 | #endif /* CONFIG_XFS_RT */ |
857 | |
858 | /* |
859 | * Get filesystem's extents as described in head, and format for output. Fills |
860 | * in the supplied records array until there are no more reverse mappings to |
861 | * return or head.fmh_entries == head.fmh_count. In the second case, this |
862 | * function returns -ECANCELED to indicate that more records would have been |
863 | * returned. |
864 | * |
865 | * Key to Confusion |
866 | * ---------------- |
867 | * There are multiple levels of keys and counters at work here: |
868 | * xfs_fsmap_head.fmh_keys -- low and high fsmap keys passed in; |
869 | * these reflect fs-wide sector addrs. |
870 | * dkeys -- fmh_keys used to query each device; |
871 | * these are fmh_keys but w/ the low key |
872 | * bumped up by fmr_length. |
873 | * xfs_getfsmap_info.next_daddr -- next disk addr we expect to see; this |
874 | * is how we detect gaps in the fsmap |
875 | records and report them. |
876 | * xfs_getfsmap_info.low/high -- per-AG low/high keys computed from |
877 | * dkeys; used to query the metadata. |
878 | */ |
879 | int |
880 | xfs_getfsmap( |
881 | struct xfs_mount *mp, |
882 | struct xfs_fsmap_head *head, |
883 | struct fsmap *fsmap_recs) |
884 | { |
885 | struct xfs_trans *tp = NULL; |
886 | struct xfs_fsmap dkeys[2]; /* per-dev keys */ |
887 | struct xfs_getfsmap_dev handlers[XFS_GETFSMAP_DEVS]; |
888 | struct xfs_getfsmap_info info = { NULL }; |
889 | bool use_rmap; |
890 | int i; |
891 | int error = 0; |
892 | |
893 | if (head->fmh_iflags & ~FMH_IF_VALID) |
894 | return -EINVAL; |
895 | if (!xfs_getfsmap_is_valid_device(mp, fm: &head->fmh_keys[0]) || |
896 | !xfs_getfsmap_is_valid_device(mp, fm: &head->fmh_keys[1])) |
897 | return -EINVAL; |
898 | if (!xfs_getfsmap_check_keys(low_key: &head->fmh_keys[0], high_key: &head->fmh_keys[1])) |
899 | return -EINVAL; |
900 | |
901 | use_rmap = xfs_has_rmapbt(mp) && |
902 | has_capability_noaudit(current, CAP_SYS_ADMIN); |
903 | head->fmh_entries = 0; |
904 | |
905 | /* Set up our device handlers. */ |
906 | memset(handlers, 0, sizeof(handlers)); |
907 | handlers[0].dev = new_encode_dev(dev: mp->m_ddev_targp->bt_dev); |
908 | if (use_rmap) |
909 | handlers[0].fn = xfs_getfsmap_datadev_rmapbt; |
910 | else |
911 | handlers[0].fn = xfs_getfsmap_datadev_bnobt; |
912 | if (mp->m_logdev_targp != mp->m_ddev_targp) { |
913 | handlers[1].dev = new_encode_dev(dev: mp->m_logdev_targp->bt_dev); |
914 | handlers[1].fn = xfs_getfsmap_logdev; |
915 | } |
916 | #ifdef CONFIG_XFS_RT |
917 | if (mp->m_rtdev_targp) { |
918 | handlers[2].dev = new_encode_dev(dev: mp->m_rtdev_targp->bt_dev); |
919 | handlers[2].fn = xfs_getfsmap_rtdev_rtbitmap; |
920 | } |
921 | #endif /* CONFIG_XFS_RT */ |
922 | |
923 | xfs_sort(handlers, XFS_GETFSMAP_DEVS, sizeof(struct xfs_getfsmap_dev), |
924 | xfs_getfsmap_dev_compare); |
925 | |
926 | /* |
927 | * To continue where we left off, we allow userspace to use the |
928 | * last mapping from a previous call as the low key of the next. |
929 | * This is identified by a non-zero length in the low key. We |
930 | * have to increment the low key in this scenario to ensure we |
931 | * don't return the same mapping again, and instead return the |
932 | * very next mapping. |
933 | * |
934 | * If the low key mapping refers to file data, the same physical |
935 | * blocks could be mapped to several other files/offsets. |
936 | * According to rmapbt record ordering, the minimal next |
937 | * possible record for the block range is the next starting |
938 | * offset in the same inode. Therefore, each fsmap backend bumps |
939 | * the file offset to continue the search appropriately. For |
940 | * all other low key mapping types (attr blocks, metadata), each |
941 | * fsmap backend bumps the physical offset as there can be no |
942 | * other mapping for the same physical block range. |
943 | */ |
944 | dkeys[0] = head->fmh_keys[0]; |
945 | memset(&dkeys[1], 0xFF, sizeof(struct xfs_fsmap)); |
946 | |
947 | info.next_daddr = head->fmh_keys[0].fmr_physical + |
948 | head->fmh_keys[0].fmr_length; |
949 | info.fsmap_recs = fsmap_recs; |
950 | info.head = head; |
951 | |
952 | /* For each device we support... */ |
953 | for (i = 0; i < XFS_GETFSMAP_DEVS; i++) { |
954 | /* Is this device within the range the user asked for? */ |
955 | if (!handlers[i].fn) |
956 | continue; |
957 | if (head->fmh_keys[0].fmr_device > handlers[i].dev) |
958 | continue; |
959 | if (head->fmh_keys[1].fmr_device < handlers[i].dev) |
960 | break; |
961 | |
962 | /* |
963 | * If this device number matches the high key, we have |
964 | * to pass the high key to the handler to limit the |
965 | * query results. If the device number exceeds the |
966 | * low key, zero out the low key so that we get |
967 | * everything from the beginning. |
968 | */ |
969 | if (handlers[i].dev == head->fmh_keys[1].fmr_device) |
970 | dkeys[1] = head->fmh_keys[1]; |
971 | if (handlers[i].dev > head->fmh_keys[0].fmr_device) |
972 | memset(&dkeys[0], 0, sizeof(struct xfs_fsmap)); |
973 | |
974 | /* |
975 | * Grab an empty transaction so that we can use its recursive |
976 | * buffer locking abilities to detect cycles in the rmapbt |
977 | * without deadlocking. |
978 | */ |
979 | error = xfs_trans_alloc_empty(mp, tpp: &tp); |
980 | if (error) |
981 | break; |
982 | |
983 | info.dev = handlers[i].dev; |
984 | info.last = false; |
985 | info.pag = NULL; |
986 | info.low_daddr = -1ULL; |
987 | info.low.rm_blockcount = 0; |
988 | error = handlers[i].fn(tp, dkeys, &info); |
989 | if (error) |
990 | break; |
991 | xfs_trans_cancel(tp); |
992 | tp = NULL; |
993 | info.next_daddr = 0; |
994 | } |
995 | |
996 | if (tp) |
997 | xfs_trans_cancel(tp); |
998 | head->fmh_oflags = FMH_OF_DEV_T; |
999 | return error; |
1000 | } |
1001 | |