Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (c) 2014 Red Hat, Inc.
4 * All Rights Reserved.
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_bit.h"
13#include "xfs_mount.h"
14#include "xfs_sb.h"
15#include "xfs_defer.h"
16#include "xfs_btree.h"
17#include "xfs_trans.h"
18#include "xfs_alloc.h"
19#include "xfs_rmap.h"
20#include "xfs_rmap_btree.h"
21#include "xfs_trace.h"
22#include "xfs_errortag.h"
23#include "xfs_error.h"
24#include "xfs_inode.h"
25#include "xfs_ag.h"
26
27struct kmem_cache *xfs_rmap_intent_cache;
28
29/*
30 * Lookup the first record less than or equal to [bno, len, owner, offset]
31 * in the btree given by cur.
32 */
33int
34xfs_rmap_lookup_le(
35 struct xfs_btree_cur *cur,
36 xfs_agblock_t bno,
37 uint64_t owner,
38 uint64_t offset,
39 unsigned int flags,
40 struct xfs_rmap_irec *irec,
41 int *stat)
42{
43 int get_stat = 0;
44 int error;
45
46 cur->bc_rec.r.rm_startblock = bno;
47 cur->bc_rec.r.rm_blockcount = 0;
48 cur->bc_rec.r.rm_owner = owner;
49 cur->bc_rec.r.rm_offset = offset;
50 cur->bc_rec.r.rm_flags = flags;
51
52 error = xfs_btree_lookup(cur, XFS_LOOKUP_LE, stat);
53 if (error || !(*stat) || !irec)
54 return error;
55
56 error = xfs_rmap_get_rec(cur, irec, &get_stat);
57 if (error)
58 return error;
59 if (!get_stat)
60 return -EFSCORRUPTED;
61
62 return 0;
63}
64
65/*
66 * Lookup the record exactly matching [bno, len, owner, offset]
67 * in the btree given by cur.
68 */
69int
70xfs_rmap_lookup_eq(
71 struct xfs_btree_cur *cur,
72 xfs_agblock_t bno,
73 xfs_extlen_t len,
74 uint64_t owner,
75 uint64_t offset,
76 unsigned int flags,
77 int *stat)
78{
79 cur->bc_rec.r.rm_startblock = bno;
80 cur->bc_rec.r.rm_blockcount = len;
81 cur->bc_rec.r.rm_owner = owner;
82 cur->bc_rec.r.rm_offset = offset;
83 cur->bc_rec.r.rm_flags = flags;
84 return xfs_btree_lookup(cur, XFS_LOOKUP_EQ, stat);
85}
86
87/*
88 * Update the record referred to by cur to the value given
89 * by [bno, len, owner, offset].
90 * This either works (return 0) or gets an EFSCORRUPTED error.
91 */
92STATIC int
93xfs_rmap_update(
94 struct xfs_btree_cur *cur,
95 struct xfs_rmap_irec *irec)
96{
97 union xfs_btree_rec rec;
98 int error;
99
100 trace_xfs_rmap_update(cur->bc_mp, cur->bc_ag.pag->pag_agno,
101 irec->rm_startblock, irec->rm_blockcount,
102 irec->rm_owner, irec->rm_offset, irec->rm_flags);
103
104 rec.rmap.rm_startblock = cpu_to_be32(irec->rm_startblock);
105 rec.rmap.rm_blockcount = cpu_to_be32(irec->rm_blockcount);
106 rec.rmap.rm_owner = cpu_to_be64(irec->rm_owner);
107 rec.rmap.rm_offset = cpu_to_be64(
108 xfs_rmap_irec_offset_pack(irec));
109 error = xfs_btree_update(cur, &rec);
110 if (error)
111 trace_xfs_rmap_update_error(cur->bc_mp,
112 cur->bc_ag.pag->pag_agno, error, _RET_IP_);
113 return error;
114}
115
116int
117xfs_rmap_insert(
118 struct xfs_btree_cur *rcur,
119 xfs_agblock_t agbno,
120 xfs_extlen_t len,
121 uint64_t owner,
122 uint64_t offset,
123 unsigned int flags)
124{
125 int i;
126 int error;
127
128 trace_xfs_rmap_insert(rcur->bc_mp, rcur->bc_ag.pag->pag_agno, agbno,
129 len, owner, offset, flags);
130
131 error = xfs_rmap_lookup_eq(rcur, agbno, len, owner, offset, flags, &i);
132 if (error)
133 goto done;
134 if (XFS_IS_CORRUPT(rcur->bc_mp, i != 0)) {
135 error = -EFSCORRUPTED;
136 goto done;
137 }
138
139 rcur->bc_rec.r.rm_startblock = agbno;
140 rcur->bc_rec.r.rm_blockcount = len;
141 rcur->bc_rec.r.rm_owner = owner;
142 rcur->bc_rec.r.rm_offset = offset;
143 rcur->bc_rec.r.rm_flags = flags;
144 error = xfs_btree_insert(rcur, &i);
145 if (error)
146 goto done;
147 if (XFS_IS_CORRUPT(rcur->bc_mp, i != 1)) {
148 error = -EFSCORRUPTED;
149 goto done;
150 }
151done:
152 if (error)
153 trace_xfs_rmap_insert_error(rcur->bc_mp,
154 rcur->bc_ag.pag->pag_agno, error, _RET_IP_);
155 return error;
156}
157
158STATIC int
159xfs_rmap_delete(
160 struct xfs_btree_cur *rcur,
161 xfs_agblock_t agbno,
162 xfs_extlen_t len,
163 uint64_t owner,
164 uint64_t offset,
165 unsigned int flags)
166{
167 int i;
168 int error;
169
170 trace_xfs_rmap_delete(rcur->bc_mp, rcur->bc_ag.pag->pag_agno, agbno,
171 len, owner, offset, flags);
172
173 error = xfs_rmap_lookup_eq(rcur, agbno, len, owner, offset, flags, &i);
174 if (error)
175 goto done;
176 if (XFS_IS_CORRUPT(rcur->bc_mp, i != 1)) {
177 error = -EFSCORRUPTED;
178 goto done;
179 }
180
181 error = xfs_btree_delete(rcur, &i);
182 if (error)
183 goto done;
184 if (XFS_IS_CORRUPT(rcur->bc_mp, i != 1)) {
185 error = -EFSCORRUPTED;
186 goto done;
187 }
188done:
189 if (error)
190 trace_xfs_rmap_delete_error(rcur->bc_mp,
191 rcur->bc_ag.pag->pag_agno, error, _RET_IP_);
192 return error;
193}
194
195/* Convert an internal btree record to an rmap record. */
196int
197xfs_rmap_btrec_to_irec(
198 const union xfs_btree_rec *rec,
199 struct xfs_rmap_irec *irec)
200{
201 irec->rm_startblock = be32_to_cpu(rec->rmap.rm_startblock);
202 irec->rm_blockcount = be32_to_cpu(rec->rmap.rm_blockcount);
203 irec->rm_owner = be64_to_cpu(rec->rmap.rm_owner);
204 return xfs_rmap_irec_offset_unpack(be64_to_cpu(rec->rmap.rm_offset),
205 irec);
206}
207
208/*
209 * Get the data from the pointed-to record.
210 */
211int
212xfs_rmap_get_rec(
213 struct xfs_btree_cur *cur,
214 struct xfs_rmap_irec *irec,
215 int *stat)
216{
217 struct xfs_mount *mp = cur->bc_mp;
218 struct xfs_perag *pag = cur->bc_ag.pag;
219 union xfs_btree_rec *rec;
220 int error;
221
222 error = xfs_btree_get_rec(cur, &rec, stat);
223 if (error || !*stat)
224 return error;
225
226 if (xfs_rmap_btrec_to_irec(rec, irec))
227 goto out_bad_rec;
228
229 if (irec->rm_blockcount == 0)
230 goto out_bad_rec;
231 if (irec->rm_startblock <= XFS_AGFL_BLOCK(mp)) {
232 if (irec->rm_owner != XFS_RMAP_OWN_FS)
233 goto out_bad_rec;
234 if (irec->rm_blockcount != XFS_AGFL_BLOCK(mp) + 1)
235 goto out_bad_rec;
236 } else {
237 /* check for valid extent range, including overflow */
238 if (!xfs_verify_agbext(pag, irec->rm_startblock,
239 irec->rm_blockcount))
240 goto out_bad_rec;
241 }
242
243 if (!(xfs_verify_ino(mp, irec->rm_owner) ||
244 (irec->rm_owner <= XFS_RMAP_OWN_FS &&
245 irec->rm_owner >= XFS_RMAP_OWN_MIN)))
246 goto out_bad_rec;
247
248 return 0;
249out_bad_rec:
250 xfs_warn(mp,
251 "Reverse Mapping BTree record corruption in AG %d detected!",
252 pag->pag_agno);
253 xfs_warn(mp,
254 "Owner 0x%llx, flags 0x%x, start block 0x%x block count 0x%x",
255 irec->rm_owner, irec->rm_flags, irec->rm_startblock,
256 irec->rm_blockcount);
257 return -EFSCORRUPTED;
258}
259
260struct xfs_find_left_neighbor_info {
261 struct xfs_rmap_irec high;
262 struct xfs_rmap_irec *irec;
263};
264
265/* For each rmap given, figure out if it matches the key we want. */
266STATIC int
267xfs_rmap_find_left_neighbor_helper(
268 struct xfs_btree_cur *cur,
269 const struct xfs_rmap_irec *rec,
270 void *priv)
271{
272 struct xfs_find_left_neighbor_info *info = priv;
273
274 trace_xfs_rmap_find_left_neighbor_candidate(cur->bc_mp,
275 cur->bc_ag.pag->pag_agno, rec->rm_startblock,
276 rec->rm_blockcount, rec->rm_owner, rec->rm_offset,
277 rec->rm_flags);
278
279 if (rec->rm_owner != info->high.rm_owner)
280 return 0;
281 if (!XFS_RMAP_NON_INODE_OWNER(rec->rm_owner) &&
282 !(rec->rm_flags & XFS_RMAP_BMBT_BLOCK) &&
283 rec->rm_offset + rec->rm_blockcount - 1 != info->high.rm_offset)
284 return 0;
285
286 *info->irec = *rec;
287 return -ECANCELED;
288}
289
290/*
291 * Find the record to the left of the given extent, being careful only to
292 * return a match with the same owner and adjacent physical and logical
293 * block ranges.
294 */
295STATIC int
296xfs_rmap_find_left_neighbor(
297 struct xfs_btree_cur *cur,
298 xfs_agblock_t bno,
299 uint64_t owner,
300 uint64_t offset,
301 unsigned int flags,
302 struct xfs_rmap_irec *irec,
303 int *stat)
304{
305 struct xfs_find_left_neighbor_info info;
306 int found = 0;
307 int error;
308
309 *stat = 0;
310 if (bno == 0)
311 return 0;
312 info.high.rm_startblock = bno - 1;
313 info.high.rm_owner = owner;
314 if (!XFS_RMAP_NON_INODE_OWNER(owner) &&
315 !(flags & XFS_RMAP_BMBT_BLOCK)) {
316 if (offset == 0)
317 return 0;
318 info.high.rm_offset = offset - 1;
319 } else
320 info.high.rm_offset = 0;
321 info.high.rm_flags = flags;
322 info.high.rm_blockcount = 0;
323 info.irec = irec;
324
325 trace_xfs_rmap_find_left_neighbor_query(cur->bc_mp,
326 cur->bc_ag.pag->pag_agno, bno, 0, owner, offset, flags);
327
328 /*
329 * Historically, we always used the range query to walk every reverse
330 * mapping that could possibly overlap the key that the caller asked
331 * for, and filter out the ones that don't. That is very slow when
332 * there are a lot of records.
333 *
334 * However, there are two scenarios where the classic btree search can
335 * produce correct results -- if the index contains a record that is an
336 * exact match for the lookup key; and if there are no other records
337 * between the record we want and the key we supplied.
338 *
339 * As an optimization, try a non-overlapped lookup first. This makes
340 * extent conversion and remap operations run a bit faster if the
341 * physical extents aren't being shared. If we don't find what we
342 * want, we fall back to the overlapped query.
343 */
344 error = xfs_rmap_lookup_le(cur, bno, owner, offset, flags, irec,
345 &found);
346 if (error)
347 return error;
348 if (found)
349 error = xfs_rmap_find_left_neighbor_helper(cur, irec, &info);
350 if (!error)
351 error = xfs_rmap_query_range(cur, &info.high, &info.high,
352 xfs_rmap_find_left_neighbor_helper, &info);
353 if (error != -ECANCELED)
354 return error;
355
356 *stat = 1;
357 trace_xfs_rmap_find_left_neighbor_result(cur->bc_mp,
358 cur->bc_ag.pag->pag_agno, irec->rm_startblock,
359 irec->rm_blockcount, irec->rm_owner, irec->rm_offset,
360 irec->rm_flags);
361 return 0;
362}
363
364/* For each rmap given, figure out if it matches the key we want. */
365STATIC int
366xfs_rmap_lookup_le_range_helper(
367 struct xfs_btree_cur *cur,
368 const struct xfs_rmap_irec *rec,
369 void *priv)
370{
371 struct xfs_find_left_neighbor_info *info = priv;
372
373 trace_xfs_rmap_lookup_le_range_candidate(cur->bc_mp,
374 cur->bc_ag.pag->pag_agno, rec->rm_startblock,
375 rec->rm_blockcount, rec->rm_owner, rec->rm_offset,
376 rec->rm_flags);
377
378 if (rec->rm_owner != info->high.rm_owner)
379 return 0;
380 if (!XFS_RMAP_NON_INODE_OWNER(rec->rm_owner) &&
381 !(rec->rm_flags & XFS_RMAP_BMBT_BLOCK) &&
382 (rec->rm_offset > info->high.rm_offset ||
383 rec->rm_offset + rec->rm_blockcount <= info->high.rm_offset))
384 return 0;
385
386 *info->irec = *rec;
387 return -ECANCELED;
388}
389
390/*
391 * Find the record to the left of the given extent, being careful only to
392 * return a match with the same owner and overlapping physical and logical
393 * block ranges. This is the overlapping-interval version of
394 * xfs_rmap_lookup_le.
395 */
396int
397xfs_rmap_lookup_le_range(
398 struct xfs_btree_cur *cur,
399 xfs_agblock_t bno,
400 uint64_t owner,
401 uint64_t offset,
402 unsigned int flags,
403 struct xfs_rmap_irec *irec,
404 int *stat)
405{
406 struct xfs_find_left_neighbor_info info;
407 int found = 0;
408 int error;
409
410 info.high.rm_startblock = bno;
411 info.high.rm_owner = owner;
412 if (!XFS_RMAP_NON_INODE_OWNER(owner) && !(flags & XFS_RMAP_BMBT_BLOCK))
413 info.high.rm_offset = offset;
414 else
415 info.high.rm_offset = 0;
416 info.high.rm_flags = flags;
417 info.high.rm_blockcount = 0;
418 *stat = 0;
419 info.irec = irec;
420
421 trace_xfs_rmap_lookup_le_range(cur->bc_mp, cur->bc_ag.pag->pag_agno,
422 bno, 0, owner, offset, flags);
423
424 /*
425 * Historically, we always used the range query to walk every reverse
426 * mapping that could possibly overlap the key that the caller asked
427 * for, and filter out the ones that don't. That is very slow when
428 * there are a lot of records.
429 *
430 * However, there are two scenarios where the classic btree search can
431 * produce correct results -- if the index contains a record that is an
432 * exact match for the lookup key; and if there are no other records
433 * between the record we want and the key we supplied.
434 *
435 * As an optimization, try a non-overlapped lookup first. This makes
436 * scrub run much faster on most filesystems because bmbt records are
437 * usually an exact match for rmap records. If we don't find what we
438 * want, we fall back to the overlapped query.
439 */
440 error = xfs_rmap_lookup_le(cur, bno, owner, offset, flags, irec,
441 &found);
442 if (error)
443 return error;
444 if (found)
445 error = xfs_rmap_lookup_le_range_helper(cur, irec, &info);
446 if (!error)
447 error = xfs_rmap_query_range(cur, &info.high, &info.high,
448 xfs_rmap_lookup_le_range_helper, &info);
449 if (error != -ECANCELED)
450 return error;
451
452 *stat = 1;
453 trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,
454 cur->bc_ag.pag->pag_agno, irec->rm_startblock,
455 irec->rm_blockcount, irec->rm_owner, irec->rm_offset,
456 irec->rm_flags);
457 return 0;
458}
459
460/*
461 * Perform all the relevant owner checks for a removal op. If we're doing an
462 * unknown-owner removal then we have no owner information to check.
463 */
464static int
465xfs_rmap_free_check_owner(
466 struct xfs_mount *mp,
467 uint64_t ltoff,
468 struct xfs_rmap_irec *rec,
469 xfs_filblks_t len,
470 uint64_t owner,
471 uint64_t offset,
472 unsigned int flags)
473{
474 int error = 0;
475
476 if (owner == XFS_RMAP_OWN_UNKNOWN)
477 return 0;
478
479 /* Make sure the unwritten flag matches. */
480 if (XFS_IS_CORRUPT(mp,
481 (flags & XFS_RMAP_UNWRITTEN) !=
482 (rec->rm_flags & XFS_RMAP_UNWRITTEN))) {
483 error = -EFSCORRUPTED;
484 goto out;
485 }
486
487 /* Make sure the owner matches what we expect to find in the tree. */
488 if (XFS_IS_CORRUPT(mp, owner != rec->rm_owner)) {
489 error = -EFSCORRUPTED;
490 goto out;
491 }
492
493 /* Check the offset, if necessary. */
494 if (XFS_RMAP_NON_INODE_OWNER(owner))
495 goto out;
496
497 if (flags & XFS_RMAP_BMBT_BLOCK) {
498 if (XFS_IS_CORRUPT(mp,
499 !(rec->rm_flags & XFS_RMAP_BMBT_BLOCK))) {
500 error = -EFSCORRUPTED;
501 goto out;
502 }
503 } else {
504 if (XFS_IS_CORRUPT(mp, rec->rm_offset > offset)) {
505 error = -EFSCORRUPTED;
506 goto out;
507 }
508 if (XFS_IS_CORRUPT(mp,
509 offset + len > ltoff + rec->rm_blockcount)) {
510 error = -EFSCORRUPTED;
511 goto out;
512 }
513 }
514
515out:
516 return error;
517}
518
519/*
520 * Find the extent in the rmap btree and remove it.
521 *
522 * The record we find should always be an exact match for the extent that we're
523 * looking for, since we insert them into the btree without modification.
524 *
525 * Special Case #1: when growing the filesystem, we "free" an extent when
526 * growing the last AG. This extent is new space and so it is not tracked as
527 * used space in the btree. The growfs code will pass in an owner of
528 * XFS_RMAP_OWN_NULL to indicate that it expected that there is no owner of this
529 * extent. We verify that - the extent lookup result in a record that does not
530 * overlap.
531 *
532 * Special Case #2: EFIs do not record the owner of the extent, so when
533 * recovering EFIs from the log we pass in XFS_RMAP_OWN_UNKNOWN to tell the rmap
534 * btree to ignore the owner (i.e. wildcard match) so we don't trigger
535 * corruption checks during log recovery.
536 */
537STATIC int
538xfs_rmap_unmap(
539 struct xfs_btree_cur *cur,
540 xfs_agblock_t bno,
541 xfs_extlen_t len,
542 bool unwritten,
543 const struct xfs_owner_info *oinfo)
544{
545 struct xfs_mount *mp = cur->bc_mp;
546 struct xfs_rmap_irec ltrec;
547 uint64_t ltoff;
548 int error = 0;
549 int i;
550 uint64_t owner;
551 uint64_t offset;
552 unsigned int flags;
553 bool ignore_off;
554
555 xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
556 ignore_off = XFS_RMAP_NON_INODE_OWNER(owner) ||
557 (flags & XFS_RMAP_BMBT_BLOCK);
558 if (unwritten)
559 flags |= XFS_RMAP_UNWRITTEN;
560 trace_xfs_rmap_unmap(mp, cur->bc_ag.pag->pag_agno, bno, len,
561 unwritten, oinfo);
562
563 /*
564 * We should always have a left record because there's a static record
565 * for the AG headers at rm_startblock == 0 created by mkfs/growfs that
566 * will not ever be removed from the tree.
567 */
568 error = xfs_rmap_lookup_le(cur, bno, owner, offset, flags, <rec, &i);
569 if (error)
570 goto out_error;
571 if (XFS_IS_CORRUPT(mp, i != 1)) {
572 error = -EFSCORRUPTED;
573 goto out_error;
574 }
575
576 trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,
577 cur->bc_ag.pag->pag_agno, ltrec.rm_startblock,
578 ltrec.rm_blockcount, ltrec.rm_owner,
579 ltrec.rm_offset, ltrec.rm_flags);
580 ltoff = ltrec.rm_offset;
581
582 /*
583 * For growfs, the incoming extent must be beyond the left record we
584 * just found as it is new space and won't be used by anyone. This is
585 * just a corruption check as we don't actually do anything with this
586 * extent. Note that we need to use >= instead of > because it might
587 * be the case that the "left" extent goes all the way to EOFS.
588 */
589 if (owner == XFS_RMAP_OWN_NULL) {
590 if (XFS_IS_CORRUPT(mp,
591 bno <
592 ltrec.rm_startblock + ltrec.rm_blockcount)) {
593 error = -EFSCORRUPTED;
594 goto out_error;
595 }
596 goto out_done;
597 }
598
599 /*
600 * If we're doing an unknown-owner removal for EFI recovery, we expect
601 * to find the full range in the rmapbt or nothing at all. If we
602 * don't find any rmaps overlapping either end of the range, we're
603 * done. Hopefully this means that the EFI creator already queued
604 * (and finished) a RUI to remove the rmap.
605 */
606 if (owner == XFS_RMAP_OWN_UNKNOWN &&
607 ltrec.rm_startblock + ltrec.rm_blockcount <= bno) {
608 struct xfs_rmap_irec rtrec;
609
610 error = xfs_btree_increment(cur, 0, &i);
611 if (error)
612 goto out_error;
613 if (i == 0)
614 goto out_done;
615 error = xfs_rmap_get_rec(cur, &rtrec, &i);
616 if (error)
617 goto out_error;
618 if (XFS_IS_CORRUPT(mp, i != 1)) {
619 error = -EFSCORRUPTED;
620 goto out_error;
621 }
622 if (rtrec.rm_startblock >= bno + len)
623 goto out_done;
624 }
625
626 /* Make sure the extent we found covers the entire freeing range. */
627 if (XFS_IS_CORRUPT(mp,
628 ltrec.rm_startblock > bno ||
629 ltrec.rm_startblock + ltrec.rm_blockcount <
630 bno + len)) {
631 error = -EFSCORRUPTED;
632 goto out_error;
633 }
634
635 /* Check owner information. */
636 error = xfs_rmap_free_check_owner(mp, ltoff, <rec, len, owner,
637 offset, flags);
638 if (error)
639 goto out_error;
640
641 if (ltrec.rm_startblock == bno && ltrec.rm_blockcount == len) {
642 /* exact match, simply remove the record from rmap tree */
643 trace_xfs_rmap_delete(mp, cur->bc_ag.pag->pag_agno,
644 ltrec.rm_startblock, ltrec.rm_blockcount,
645 ltrec.rm_owner, ltrec.rm_offset,
646 ltrec.rm_flags);
647 error = xfs_btree_delete(cur, &i);
648 if (error)
649 goto out_error;
650 if (XFS_IS_CORRUPT(mp, i != 1)) {
651 error = -EFSCORRUPTED;
652 goto out_error;
653 }
654 } else if (ltrec.rm_startblock == bno) {
655 /*
656 * overlap left hand side of extent: move the start, trim the
657 * length and update the current record.
658 *
659 * ltbno ltlen
660 * Orig: |oooooooooooooooooooo|
661 * Freeing: |fffffffff|
662 * Result: |rrrrrrrrrr|
663 * bno len
664 */
665 ltrec.rm_startblock += len;
666 ltrec.rm_blockcount -= len;
667 if (!ignore_off)
668 ltrec.rm_offset += len;
669 error = xfs_rmap_update(cur, <rec);
670 if (error)
671 goto out_error;
672 } else if (ltrec.rm_startblock + ltrec.rm_blockcount == bno + len) {
673 /*
674 * overlap right hand side of extent: trim the length and update
675 * the current record.
676 *
677 * ltbno ltlen
678 * Orig: |oooooooooooooooooooo|
679 * Freeing: |fffffffff|
680 * Result: |rrrrrrrrrr|
681 * bno len
682 */
683 ltrec.rm_blockcount -= len;
684 error = xfs_rmap_update(cur, <rec);
685 if (error)
686 goto out_error;
687 } else {
688
689 /*
690 * overlap middle of extent: trim the length of the existing
691 * record to the length of the new left-extent size, increment
692 * the insertion position so we can insert a new record
693 * containing the remaining right-extent space.
694 *
695 * ltbno ltlen
696 * Orig: |oooooooooooooooooooo|
697 * Freeing: |fffffffff|
698 * Result: |rrrrr| |rrrr|
699 * bno len
700 */
701 xfs_extlen_t orig_len = ltrec.rm_blockcount;
702
703 ltrec.rm_blockcount = bno - ltrec.rm_startblock;
704 error = xfs_rmap_update(cur, <rec);
705 if (error)
706 goto out_error;
707
708 error = xfs_btree_increment(cur, 0, &i);
709 if (error)
710 goto out_error;
711
712 cur->bc_rec.r.rm_startblock = bno + len;
713 cur->bc_rec.r.rm_blockcount = orig_len - len -
714 ltrec.rm_blockcount;
715 cur->bc_rec.r.rm_owner = ltrec.rm_owner;
716 if (ignore_off)
717 cur->bc_rec.r.rm_offset = 0;
718 else
719 cur->bc_rec.r.rm_offset = offset + len;
720 cur->bc_rec.r.rm_flags = flags;
721 trace_xfs_rmap_insert(mp, cur->bc_ag.pag->pag_agno,
722 cur->bc_rec.r.rm_startblock,
723 cur->bc_rec.r.rm_blockcount,
724 cur->bc_rec.r.rm_owner,
725 cur->bc_rec.r.rm_offset,
726 cur->bc_rec.r.rm_flags);
727 error = xfs_btree_insert(cur, &i);
728 if (error)
729 goto out_error;
730 }
731
732out_done:
733 trace_xfs_rmap_unmap_done(mp, cur->bc_ag.pag->pag_agno, bno, len,
734 unwritten, oinfo);
735out_error:
736 if (error)
737 trace_xfs_rmap_unmap_error(mp, cur->bc_ag.pag->pag_agno,
738 error, _RET_IP_);
739 return error;
740}
741
742/*
743 * Remove a reference to an extent in the rmap btree.
744 */
745int
746xfs_rmap_free(
747 struct xfs_trans *tp,
748 struct xfs_buf *agbp,
749 struct xfs_perag *pag,
750 xfs_agblock_t bno,
751 xfs_extlen_t len,
752 const struct xfs_owner_info *oinfo)
753{
754 struct xfs_mount *mp = tp->t_mountp;
755 struct xfs_btree_cur *cur;
756 int error;
757
758 if (!xfs_has_rmapbt(mp))
759 return 0;
760
761 cur = xfs_rmapbt_init_cursor(mp, tp, agbp, pag);
762
763 error = xfs_rmap_unmap(cur, bno, len, false, oinfo);
764
765 xfs_btree_del_cursor(cur, error);
766 return error;
767}
768
769/*
770 * A mergeable rmap must have the same owner and the same values for
771 * the unwritten, attr_fork, and bmbt flags. The startblock and
772 * offset are checked separately.
773 */
774static bool
775xfs_rmap_is_mergeable(
776 struct xfs_rmap_irec *irec,
777 uint64_t owner,
778 unsigned int flags)
779{
780 if (irec->rm_owner == XFS_RMAP_OWN_NULL)
781 return false;
782 if (irec->rm_owner != owner)
783 return false;
784 if ((flags & XFS_RMAP_UNWRITTEN) ^
785 (irec->rm_flags & XFS_RMAP_UNWRITTEN))
786 return false;
787 if ((flags & XFS_RMAP_ATTR_FORK) ^
788 (irec->rm_flags & XFS_RMAP_ATTR_FORK))
789 return false;
790 if ((flags & XFS_RMAP_BMBT_BLOCK) ^
791 (irec->rm_flags & XFS_RMAP_BMBT_BLOCK))
792 return false;
793 return true;
794}
795
796/*
797 * When we allocate a new block, the first thing we do is add a reference to
798 * the extent in the rmap btree. This takes the form of a [agbno, length,
799 * owner, offset] record. Flags are encoded in the high bits of the offset
800 * field.
801 */
802STATIC int
803xfs_rmap_map(
804 struct xfs_btree_cur *cur,
805 xfs_agblock_t bno,
806 xfs_extlen_t len,
807 bool unwritten,
808 const struct xfs_owner_info *oinfo)
809{
810 struct xfs_mount *mp = cur->bc_mp;
811 struct xfs_rmap_irec ltrec;
812 struct xfs_rmap_irec gtrec;
813 int have_gt;
814 int have_lt;
815 int error = 0;
816 int i;
817 uint64_t owner;
818 uint64_t offset;
819 unsigned int flags = 0;
820 bool ignore_off;
821
822 xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
823 ASSERT(owner != 0);
824 ignore_off = XFS_RMAP_NON_INODE_OWNER(owner) ||
825 (flags & XFS_RMAP_BMBT_BLOCK);
826 if (unwritten)
827 flags |= XFS_RMAP_UNWRITTEN;
828 trace_xfs_rmap_map(mp, cur->bc_ag.pag->pag_agno, bno, len,
829 unwritten, oinfo);
830 ASSERT(!xfs_rmap_should_skip_owner_update(oinfo));
831
832 /*
833 * For the initial lookup, look for an exact match or the left-adjacent
834 * record for our insertion point. This will also give us the record for
835 * start block contiguity tests.
836 */
837 error = xfs_rmap_lookup_le(cur, bno, owner, offset, flags, <rec,
838 &have_lt);
839 if (error)
840 goto out_error;
841 if (have_lt) {
842 trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,
843 cur->bc_ag.pag->pag_agno, ltrec.rm_startblock,
844 ltrec.rm_blockcount, ltrec.rm_owner,
845 ltrec.rm_offset, ltrec.rm_flags);
846
847 if (!xfs_rmap_is_mergeable(<rec, owner, flags))
848 have_lt = 0;
849 }
850
851 if (XFS_IS_CORRUPT(mp,
852 have_lt != 0 &&
853 ltrec.rm_startblock + ltrec.rm_blockcount > bno)) {
854 error = -EFSCORRUPTED;
855 goto out_error;
856 }
857
858 /*
859 * Increment the cursor to see if we have a right-adjacent record to our
860 * insertion point. This will give us the record for end block
861 * contiguity tests.
862 */
863 error = xfs_btree_increment(cur, 0, &have_gt);
864 if (error)
865 goto out_error;
866 if (have_gt) {
867 error = xfs_rmap_get_rec(cur, >rec, &have_gt);
868 if (error)
869 goto out_error;
870 if (XFS_IS_CORRUPT(mp, have_gt != 1)) {
871 error = -EFSCORRUPTED;
872 goto out_error;
873 }
874 if (XFS_IS_CORRUPT(mp, bno + len > gtrec.rm_startblock)) {
875 error = -EFSCORRUPTED;
876 goto out_error;
877 }
878 trace_xfs_rmap_find_right_neighbor_result(cur->bc_mp,
879 cur->bc_ag.pag->pag_agno, gtrec.rm_startblock,
880 gtrec.rm_blockcount, gtrec.rm_owner,
881 gtrec.rm_offset, gtrec.rm_flags);
882 if (!xfs_rmap_is_mergeable(>rec, owner, flags))
883 have_gt = 0;
884 }
885
886 /*
887 * Note: cursor currently points one record to the right of ltrec, even
888 * if there is no record in the tree to the right.
889 */
890 if (have_lt &&
891 ltrec.rm_startblock + ltrec.rm_blockcount == bno &&
892 (ignore_off || ltrec.rm_offset + ltrec.rm_blockcount == offset)) {
893 /*
894 * left edge contiguous, merge into left record.
895 *
896 * ltbno ltlen
897 * orig: |ooooooooo|
898 * adding: |aaaaaaaaa|
899 * result: |rrrrrrrrrrrrrrrrrrr|
900 * bno len
901 */
902 ltrec.rm_blockcount += len;
903 if (have_gt &&
904 bno + len == gtrec.rm_startblock &&
905 (ignore_off || offset + len == gtrec.rm_offset) &&
906 (unsigned long)ltrec.rm_blockcount + len +
907 gtrec.rm_blockcount <= XFS_RMAP_LEN_MAX) {
908 /*
909 * right edge also contiguous, delete right record
910 * and merge into left record.
911 *
912 * ltbno ltlen gtbno gtlen
913 * orig: |ooooooooo| |ooooooooo|
914 * adding: |aaaaaaaaa|
915 * result: |rrrrrrrrrrrrrrrrrrrrrrrrrrrrr|
916 */
917 ltrec.rm_blockcount += gtrec.rm_blockcount;
918 trace_xfs_rmap_delete(mp, cur->bc_ag.pag->pag_agno,
919 gtrec.rm_startblock,
920 gtrec.rm_blockcount,
921 gtrec.rm_owner,
922 gtrec.rm_offset,
923 gtrec.rm_flags);
924 error = xfs_btree_delete(cur, &i);
925 if (error)
926 goto out_error;
927 if (XFS_IS_CORRUPT(mp, i != 1)) {
928 error = -EFSCORRUPTED;
929 goto out_error;
930 }
931 }
932
933 /* point the cursor back to the left record and update */
934 error = xfs_btree_decrement(cur, 0, &have_gt);
935 if (error)
936 goto out_error;
937 error = xfs_rmap_update(cur, <rec);
938 if (error)
939 goto out_error;
940 } else if (have_gt &&
941 bno + len == gtrec.rm_startblock &&
942 (ignore_off || offset + len == gtrec.rm_offset)) {
943 /*
944 * right edge contiguous, merge into right record.
945 *
946 * gtbno gtlen
947 * Orig: |ooooooooo|
948 * adding: |aaaaaaaaa|
949 * Result: |rrrrrrrrrrrrrrrrrrr|
950 * bno len
951 */
952 gtrec.rm_startblock = bno;
953 gtrec.rm_blockcount += len;
954 if (!ignore_off)
955 gtrec.rm_offset = offset;
956 error = xfs_rmap_update(cur, >rec);
957 if (error)
958 goto out_error;
959 } else {
960 /*
961 * no contiguous edge with identical owner, insert
962 * new record at current cursor position.
963 */
964 cur->bc_rec.r.rm_startblock = bno;
965 cur->bc_rec.r.rm_blockcount = len;
966 cur->bc_rec.r.rm_owner = owner;
967 cur->bc_rec.r.rm_offset = offset;
968 cur->bc_rec.r.rm_flags = flags;
969 trace_xfs_rmap_insert(mp, cur->bc_ag.pag->pag_agno, bno, len,
970 owner, offset, flags);
971 error = xfs_btree_insert(cur, &i);
972 if (error)
973 goto out_error;
974 if (XFS_IS_CORRUPT(mp, i != 1)) {
975 error = -EFSCORRUPTED;
976 goto out_error;
977 }
978 }
979
980 trace_xfs_rmap_map_done(mp, cur->bc_ag.pag->pag_agno, bno, len,
981 unwritten, oinfo);
982out_error:
983 if (error)
984 trace_xfs_rmap_map_error(mp, cur->bc_ag.pag->pag_agno,
985 error, _RET_IP_);
986 return error;
987}
988
989/*
990 * Add a reference to an extent in the rmap btree.
991 */
992int
993xfs_rmap_alloc(
994 struct xfs_trans *tp,
995 struct xfs_buf *agbp,
996 struct xfs_perag *pag,
997 xfs_agblock_t bno,
998 xfs_extlen_t len,
999 const struct xfs_owner_info *oinfo)
1000{
1001 struct xfs_mount *mp = tp->t_mountp;
1002 struct xfs_btree_cur *cur;
1003 int error;
1004
1005 if (!xfs_has_rmapbt(mp))
1006 return 0;
1007
1008 cur = xfs_rmapbt_init_cursor(mp, tp, agbp, pag);
1009 error = xfs_rmap_map(cur, bno, len, false, oinfo);
1010
1011 xfs_btree_del_cursor(cur, error);
1012 return error;
1013}
1014
1015#define RMAP_LEFT_CONTIG (1 << 0)
1016#define RMAP_RIGHT_CONTIG (1 << 1)
1017#define RMAP_LEFT_FILLING (1 << 2)
1018#define RMAP_RIGHT_FILLING (1 << 3)
1019#define RMAP_LEFT_VALID (1 << 6)
1020#define RMAP_RIGHT_VALID (1 << 7)
1021
1022#define LEFT r[0]
1023#define RIGHT r[1]
1024#define PREV r[2]
1025#define NEW r[3]
1026
1027/*
1028 * Convert an unwritten extent to a real extent or vice versa.
1029 * Does not handle overlapping extents.
1030 */
1031STATIC int
1032xfs_rmap_convert(
1033 struct xfs_btree_cur *cur,
1034 xfs_agblock_t bno,
1035 xfs_extlen_t len,
1036 bool unwritten,
1037 const struct xfs_owner_info *oinfo)
1038{
1039 struct xfs_mount *mp = cur->bc_mp;
1040 struct xfs_rmap_irec r[4]; /* neighbor extent entries */
1041 /* left is 0, right is 1, */
1042 /* prev is 2, new is 3 */
1043 uint64_t owner;
1044 uint64_t offset;
1045 uint64_t new_endoff;
1046 unsigned int oldext;
1047 unsigned int newext;
1048 unsigned int flags = 0;
1049 int i;
1050 int state = 0;
1051 int error;
1052
1053 xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
1054 ASSERT(!(XFS_RMAP_NON_INODE_OWNER(owner) ||
1055 (flags & (XFS_RMAP_ATTR_FORK | XFS_RMAP_BMBT_BLOCK))));
1056 oldext = unwritten ? XFS_RMAP_UNWRITTEN : 0;
1057 new_endoff = offset + len;
1058 trace_xfs_rmap_convert(mp, cur->bc_ag.pag->pag_agno, bno, len,
1059 unwritten, oinfo);
1060
1061 /*
1062 * For the initial lookup, look for an exact match or the left-adjacent
1063 * record for our insertion point. This will also give us the record for
1064 * start block contiguity tests.
1065 */
1066 error = xfs_rmap_lookup_le(cur, bno, owner, offset, oldext, &PREV, &i);
1067 if (error)
1068 goto done;
1069 if (XFS_IS_CORRUPT(mp, i != 1)) {
1070 error = -EFSCORRUPTED;
1071 goto done;
1072 }
1073
1074 trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,
1075 cur->bc_ag.pag->pag_agno, PREV.rm_startblock,
1076 PREV.rm_blockcount, PREV.rm_owner,
1077 PREV.rm_offset, PREV.rm_flags);
1078
1079 ASSERT(PREV.rm_offset <= offset);
1080 ASSERT(PREV.rm_offset + PREV.rm_blockcount >= new_endoff);
1081 ASSERT((PREV.rm_flags & XFS_RMAP_UNWRITTEN) == oldext);
1082 newext = ~oldext & XFS_RMAP_UNWRITTEN;
1083
1084 /*
1085 * Set flags determining what part of the previous oldext allocation
1086 * extent is being replaced by a newext allocation.
1087 */
1088 if (PREV.rm_offset == offset)
1089 state |= RMAP_LEFT_FILLING;
1090 if (PREV.rm_offset + PREV.rm_blockcount == new_endoff)
1091 state |= RMAP_RIGHT_FILLING;
1092
1093 /*
1094 * Decrement the cursor to see if we have a left-adjacent record to our
1095 * insertion point. This will give us the record for end block
1096 * contiguity tests.
1097 */
1098 error = xfs_btree_decrement(cur, 0, &i);
1099 if (error)
1100 goto done;
1101 if (i) {
1102 state |= RMAP_LEFT_VALID;
1103 error = xfs_rmap_get_rec(cur, &LEFT, &i);
1104 if (error)
1105 goto done;
1106 if (XFS_IS_CORRUPT(mp, i != 1)) {
1107 error = -EFSCORRUPTED;
1108 goto done;
1109 }
1110 if (XFS_IS_CORRUPT(mp,
1111 LEFT.rm_startblock + LEFT.rm_blockcount >
1112 bno)) {
1113 error = -EFSCORRUPTED;
1114 goto done;
1115 }
1116 trace_xfs_rmap_find_left_neighbor_result(cur->bc_mp,
1117 cur->bc_ag.pag->pag_agno, LEFT.rm_startblock,
1118 LEFT.rm_blockcount, LEFT.rm_owner,
1119 LEFT.rm_offset, LEFT.rm_flags);
1120 if (LEFT.rm_startblock + LEFT.rm_blockcount == bno &&
1121 LEFT.rm_offset + LEFT.rm_blockcount == offset &&
1122 xfs_rmap_is_mergeable(&LEFT, owner, newext))
1123 state |= RMAP_LEFT_CONTIG;
1124 }
1125
1126 /*
1127 * Increment the cursor to see if we have a right-adjacent record to our
1128 * insertion point. This will give us the record for end block
1129 * contiguity tests.
1130 */
1131 error = xfs_btree_increment(cur, 0, &i);
1132 if (error)
1133 goto done;
1134 if (XFS_IS_CORRUPT(mp, i != 1)) {
1135 error = -EFSCORRUPTED;
1136 goto done;
1137 }
1138 error = xfs_btree_increment(cur, 0, &i);
1139 if (error)
1140 goto done;
1141 if (i) {
1142 state |= RMAP_RIGHT_VALID;
1143 error = xfs_rmap_get_rec(cur, &RIGHT, &i);
1144 if (error)
1145 goto done;
1146 if (XFS_IS_CORRUPT(mp, i != 1)) {
1147 error = -EFSCORRUPTED;
1148 goto done;
1149 }
1150 if (XFS_IS_CORRUPT(mp, bno + len > RIGHT.rm_startblock)) {
1151 error = -EFSCORRUPTED;
1152 goto done;
1153 }
1154 trace_xfs_rmap_find_right_neighbor_result(cur->bc_mp,
1155 cur->bc_ag.pag->pag_agno, RIGHT.rm_startblock,
1156 RIGHT.rm_blockcount, RIGHT.rm_owner,
1157 RIGHT.rm_offset, RIGHT.rm_flags);
1158 if (bno + len == RIGHT.rm_startblock &&
1159 offset + len == RIGHT.rm_offset &&
1160 xfs_rmap_is_mergeable(&RIGHT, owner, newext))
1161 state |= RMAP_RIGHT_CONTIG;
1162 }
1163
1164 /* check that left + prev + right is not too long */
1165 if ((state & (RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |
1166 RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG)) ==
1167 (RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |
1168 RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG) &&
1169 (unsigned long)LEFT.rm_blockcount + len +
1170 RIGHT.rm_blockcount > XFS_RMAP_LEN_MAX)
1171 state &= ~RMAP_RIGHT_CONTIG;
1172
1173 trace_xfs_rmap_convert_state(mp, cur->bc_ag.pag->pag_agno, state,
1174 _RET_IP_);
1175
1176 /* reset the cursor back to PREV */
1177 error = xfs_rmap_lookup_le(cur, bno, owner, offset, oldext, NULL, &i);
1178 if (error)
1179 goto done;
1180 if (XFS_IS_CORRUPT(mp, i != 1)) {
1181 error = -EFSCORRUPTED;
1182 goto done;
1183 }
1184
1185 /*
1186 * Switch out based on the FILLING and CONTIG state bits.
1187 */
1188 switch (state & (RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |
1189 RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG)) {
1190 case RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |
1191 RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG:
1192 /*
1193 * Setting all of a previous oldext extent to newext.
1194 * The left and right neighbors are both contiguous with new.
1195 */
1196 error = xfs_btree_increment(cur, 0, &i);
1197 if (error)
1198 goto done;
1199 if (XFS_IS_CORRUPT(mp, i != 1)) {
1200 error = -EFSCORRUPTED;
1201 goto done;
1202 }
1203 trace_xfs_rmap_delete(mp, cur->bc_ag.pag->pag_agno,
1204 RIGHT.rm_startblock, RIGHT.rm_blockcount,
1205 RIGHT.rm_owner, RIGHT.rm_offset,
1206 RIGHT.rm_flags);
1207 error = xfs_btree_delete(cur, &i);
1208 if (error)
1209 goto done;
1210 if (XFS_IS_CORRUPT(mp, i != 1)) {
1211 error = -EFSCORRUPTED;
1212 goto done;
1213 }
1214 error = xfs_btree_decrement(cur, 0, &i);
1215 if (error)
1216 goto done;
1217 if (XFS_IS_CORRUPT(mp, i != 1)) {
1218 error = -EFSCORRUPTED;
1219 goto done;
1220 }
1221 trace_xfs_rmap_delete(mp, cur->bc_ag.pag->pag_agno,
1222 PREV.rm_startblock, PREV.rm_blockcount,
1223 PREV.rm_owner, PREV.rm_offset,
1224 PREV.rm_flags);
1225 error = xfs_btree_delete(cur, &i);
1226 if (error)
1227 goto done;
1228 if (XFS_IS_CORRUPT(mp, i != 1)) {
1229 error = -EFSCORRUPTED;
1230 goto done;
1231 }
1232 error = xfs_btree_decrement(cur, 0, &i);
1233 if (error)
1234 goto done;
1235 if (XFS_IS_CORRUPT(mp, i != 1)) {
1236 error = -EFSCORRUPTED;
1237 goto done;
1238 }
1239 NEW = LEFT;
1240 NEW.rm_blockcount += PREV.rm_blockcount + RIGHT.rm_blockcount;
1241 error = xfs_rmap_update(cur, &NEW);
1242 if (error)
1243 goto done;
1244 break;
1245
1246 case RMAP_LEFT_FILLING | RMAP_RIGHT_FILLING | RMAP_LEFT_CONTIG:
1247 /*
1248 * Setting all of a previous oldext extent to newext.
1249 * The left neighbor is contiguous, the right is not.
1250 */
1251 trace_xfs_rmap_delete(mp, cur->bc_ag.pag->pag_agno,
1252 PREV.rm_startblock, PREV.rm_blockcount,
1253 PREV.rm_owner, PREV.rm_offset,
1254 PREV.rm_flags);
1255 error = xfs_btree_delete(cur, &i);
1256 if (error)
1257 goto done;
1258 if (XFS_IS_CORRUPT(mp, i != 1)) {
1259 error = -EFSCORRUPTED;
1260 goto done;
1261 }
1262 error = xfs_btree_decrement(cur, 0, &i);
1263 if (error)
1264 goto done;
1265 if (XFS_IS_CORRUPT(mp, i != 1)) {
1266 error = -EFSCORRUPTED;
1267 goto done;
1268 }
1269 NEW = LEFT;
1270 NEW.rm_blockcount += PREV.rm_blockcount;
1271 error = xfs_rmap_update(cur, &NEW);
1272 if (error)
1273 goto done;
1274 break;
1275
1276 case RMAP_LEFT_FILLING | RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG:
1277 /*
1278 * Setting all of a previous oldext extent to newext.
1279 * The right neighbor is contiguous, the left is not.
1280 */
1281 error = xfs_btree_increment(cur, 0, &i);
1282 if (error)
1283 goto done;
1284 if (XFS_IS_CORRUPT(mp, i != 1)) {
1285 error = -EFSCORRUPTED;
1286 goto done;
1287 }
1288 trace_xfs_rmap_delete(mp, cur->bc_ag.pag->pag_agno,
1289 RIGHT.rm_startblock, RIGHT.rm_blockcount,
1290 RIGHT.rm_owner, RIGHT.rm_offset,
1291 RIGHT.rm_flags);
1292 error = xfs_btree_delete(cur, &i);
1293 if (error)
1294 goto done;
1295 if (XFS_IS_CORRUPT(mp, i != 1)) {
1296 error = -EFSCORRUPTED;
1297 goto done;
1298 }
1299 error = xfs_btree_decrement(cur, 0, &i);
1300 if (error)
1301 goto done;
1302 if (XFS_IS_CORRUPT(mp, i != 1)) {
1303 error = -EFSCORRUPTED;
1304 goto done;
1305 }
1306 NEW = PREV;
1307 NEW.rm_blockcount = len + RIGHT.rm_blockcount;
1308 NEW.rm_flags = newext;
1309 error = xfs_rmap_update(cur, &NEW);
1310 if (error)
1311 goto done;
1312 break;
1313
1314 case RMAP_LEFT_FILLING | RMAP_RIGHT_FILLING:
1315 /*
1316 * Setting all of a previous oldext extent to newext.
1317 * Neither the left nor right neighbors are contiguous with
1318 * the new one.
1319 */
1320 NEW = PREV;
1321 NEW.rm_flags = newext;
1322 error = xfs_rmap_update(cur, &NEW);
1323 if (error)
1324 goto done;
1325 break;
1326
1327 case RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG:
1328 /*
1329 * Setting the first part of a previous oldext extent to newext.
1330 * The left neighbor is contiguous.
1331 */
1332 NEW = PREV;
1333 NEW.rm_offset += len;
1334 NEW.rm_startblock += len;
1335 NEW.rm_blockcount -= len;
1336 error = xfs_rmap_update(cur, &NEW);
1337 if (error)
1338 goto done;
1339 error = xfs_btree_decrement(cur, 0, &i);
1340 if (error)
1341 goto done;
1342 NEW = LEFT;
1343 NEW.rm_blockcount += len;
1344 error = xfs_rmap_update(cur, &NEW);
1345 if (error)
1346 goto done;
1347 break;
1348
1349 case RMAP_LEFT_FILLING:
1350 /*
1351 * Setting the first part of a previous oldext extent to newext.
1352 * The left neighbor is not contiguous.
1353 */
1354 NEW = PREV;
1355 NEW.rm_startblock += len;
1356 NEW.rm_offset += len;
1357 NEW.rm_blockcount -= len;
1358 error = xfs_rmap_update(cur, &NEW);
1359 if (error)
1360 goto done;
1361 NEW.rm_startblock = bno;
1362 NEW.rm_owner = owner;
1363 NEW.rm_offset = offset;
1364 NEW.rm_blockcount = len;
1365 NEW.rm_flags = newext;
1366 cur->bc_rec.r = NEW;
1367 trace_xfs_rmap_insert(mp, cur->bc_ag.pag->pag_agno, bno,
1368 len, owner, offset, newext);
1369 error = xfs_btree_insert(cur, &i);
1370 if (error)
1371 goto done;
1372 if (XFS_IS_CORRUPT(mp, i != 1)) {
1373 error = -EFSCORRUPTED;
1374 goto done;
1375 }
1376 break;
1377
1378 case RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG:
1379 /*
1380 * Setting the last part of a previous oldext extent to newext.
1381 * The right neighbor is contiguous with the new allocation.
1382 */
1383 NEW = PREV;
1384 NEW.rm_blockcount -= len;
1385 error = xfs_rmap_update(cur, &NEW);
1386 if (error)
1387 goto done;
1388 error = xfs_btree_increment(cur, 0, &i);
1389 if (error)
1390 goto done;
1391 NEW = RIGHT;
1392 NEW.rm_offset = offset;
1393 NEW.rm_startblock = bno;
1394 NEW.rm_blockcount += len;
1395 error = xfs_rmap_update(cur, &NEW);
1396 if (error)
1397 goto done;
1398 break;
1399
1400 case RMAP_RIGHT_FILLING:
1401 /*
1402 * Setting the last part of a previous oldext extent to newext.
1403 * The right neighbor is not contiguous.
1404 */
1405 NEW = PREV;
1406 NEW.rm_blockcount -= len;
1407 error = xfs_rmap_update(cur, &NEW);
1408 if (error)
1409 goto done;
1410 error = xfs_rmap_lookup_eq(cur, bno, len, owner, offset,
1411 oldext, &i);
1412 if (error)
1413 goto done;
1414 if (XFS_IS_CORRUPT(mp, i != 0)) {
1415 error = -EFSCORRUPTED;
1416 goto done;
1417 }
1418 NEW.rm_startblock = bno;
1419 NEW.rm_owner = owner;
1420 NEW.rm_offset = offset;
1421 NEW.rm_blockcount = len;
1422 NEW.rm_flags = newext;
1423 cur->bc_rec.r = NEW;
1424 trace_xfs_rmap_insert(mp, cur->bc_ag.pag->pag_agno, bno,
1425 len, owner, offset, newext);
1426 error = xfs_btree_insert(cur, &i);
1427 if (error)
1428 goto done;
1429 if (XFS_IS_CORRUPT(mp, i != 1)) {
1430 error = -EFSCORRUPTED;
1431 goto done;
1432 }
1433 break;
1434
1435 case 0:
1436 /*
1437 * Setting the middle part of a previous oldext extent to
1438 * newext. Contiguity is impossible here.
1439 * One extent becomes three extents.
1440 */
1441 /* new right extent - oldext */
1442 NEW.rm_startblock = bno + len;
1443 NEW.rm_owner = owner;
1444 NEW.rm_offset = new_endoff;
1445 NEW.rm_blockcount = PREV.rm_offset + PREV.rm_blockcount -
1446 new_endoff;
1447 NEW.rm_flags = PREV.rm_flags;
1448 error = xfs_rmap_update(cur, &NEW);
1449 if (error)
1450 goto done;
1451 /* new left extent - oldext */
1452 NEW = PREV;
1453 NEW.rm_blockcount = offset - PREV.rm_offset;
1454 cur->bc_rec.r = NEW;
1455 trace_xfs_rmap_insert(mp, cur->bc_ag.pag->pag_agno,
1456 NEW.rm_startblock, NEW.rm_blockcount,
1457 NEW.rm_owner, NEW.rm_offset,
1458 NEW.rm_flags);
1459 error = xfs_btree_insert(cur, &i);
1460 if (error)
1461 goto done;
1462 if (XFS_IS_CORRUPT(mp, i != 1)) {
1463 error = -EFSCORRUPTED;
1464 goto done;
1465 }
1466 /*
1467 * Reset the cursor to the position of the new extent
1468 * we are about to insert as we can't trust it after
1469 * the previous insert.
1470 */
1471 error = xfs_rmap_lookup_eq(cur, bno, len, owner, offset,
1472 oldext, &i);
1473 if (error)
1474 goto done;
1475 if (XFS_IS_CORRUPT(mp, i != 0)) {
1476 error = -EFSCORRUPTED;
1477 goto done;
1478 }
1479 /* new middle extent - newext */
1480 cur->bc_rec.r.rm_flags &= ~XFS_RMAP_UNWRITTEN;
1481 cur->bc_rec.r.rm_flags |= newext;
1482 trace_xfs_rmap_insert(mp, cur->bc_ag.pag->pag_agno, bno, len,
1483 owner, offset, newext);
1484 error = xfs_btree_insert(cur, &i);
1485 if (error)
1486 goto done;
1487 if (XFS_IS_CORRUPT(mp, i != 1)) {
1488 error = -EFSCORRUPTED;
1489 goto done;
1490 }
1491 break;
1492
1493 case RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG | RMAP_RIGHT_CONTIG:
1494 case RMAP_RIGHT_FILLING | RMAP_LEFT_CONTIG | RMAP_RIGHT_CONTIG:
1495 case RMAP_LEFT_FILLING | RMAP_RIGHT_CONTIG:
1496 case RMAP_RIGHT_FILLING | RMAP_LEFT_CONTIG:
1497 case RMAP_LEFT_CONTIG | RMAP_RIGHT_CONTIG:
1498 case RMAP_LEFT_CONTIG:
1499 case RMAP_RIGHT_CONTIG:
1500 /*
1501 * These cases are all impossible.
1502 */
1503 ASSERT(0);
1504 }
1505
1506 trace_xfs_rmap_convert_done(mp, cur->bc_ag.pag->pag_agno, bno, len,
1507 unwritten, oinfo);
1508done:
1509 if (error)
1510 trace_xfs_rmap_convert_error(cur->bc_mp,
1511 cur->bc_ag.pag->pag_agno, error, _RET_IP_);
1512 return error;
1513}
1514
1515/*
1516 * Convert an unwritten extent to a real extent or vice versa. If there is no
1517 * possibility of overlapping extents, delegate to the simpler convert
1518 * function.
1519 */
1520STATIC int
1521xfs_rmap_convert_shared(
1522 struct xfs_btree_cur *cur,
1523 xfs_agblock_t bno,
1524 xfs_extlen_t len,
1525 bool unwritten,
1526 const struct xfs_owner_info *oinfo)
1527{
1528 struct xfs_mount *mp = cur->bc_mp;
1529 struct xfs_rmap_irec r[4]; /* neighbor extent entries */
1530 /* left is 0, right is 1, */
1531 /* prev is 2, new is 3 */
1532 uint64_t owner;
1533 uint64_t offset;
1534 uint64_t new_endoff;
1535 unsigned int oldext;
1536 unsigned int newext;
1537 unsigned int flags = 0;
1538 int i;
1539 int state = 0;
1540 int error;
1541
1542 xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
1543 ASSERT(!(XFS_RMAP_NON_INODE_OWNER(owner) ||
1544 (flags & (XFS_RMAP_ATTR_FORK | XFS_RMAP_BMBT_BLOCK))));
1545 oldext = unwritten ? XFS_RMAP_UNWRITTEN : 0;
1546 new_endoff = offset + len;
1547 trace_xfs_rmap_convert(mp, cur->bc_ag.pag->pag_agno, bno, len,
1548 unwritten, oinfo);
1549
1550 /*
1551 * For the initial lookup, look for and exact match or the left-adjacent
1552 * record for our insertion point. This will also give us the record for
1553 * start block contiguity tests.
1554 */
1555 error = xfs_rmap_lookup_le_range(cur, bno, owner, offset, oldext,
1556 &PREV, &i);
1557 if (error)
1558 goto done;
1559 if (XFS_IS_CORRUPT(mp, i != 1)) {
1560 error = -EFSCORRUPTED;
1561 goto done;
1562 }
1563
1564 ASSERT(PREV.rm_offset <= offset);
1565 ASSERT(PREV.rm_offset + PREV.rm_blockcount >= new_endoff);
1566 ASSERT((PREV.rm_flags & XFS_RMAP_UNWRITTEN) == oldext);
1567 newext = ~oldext & XFS_RMAP_UNWRITTEN;
1568
1569 /*
1570 * Set flags determining what part of the previous oldext allocation
1571 * extent is being replaced by a newext allocation.
1572 */
1573 if (PREV.rm_offset == offset)
1574 state |= RMAP_LEFT_FILLING;
1575 if (PREV.rm_offset + PREV.rm_blockcount == new_endoff)
1576 state |= RMAP_RIGHT_FILLING;
1577
1578 /* Is there a left record that abuts our range? */
1579 error = xfs_rmap_find_left_neighbor(cur, bno, owner, offset, newext,
1580 &LEFT, &i);
1581 if (error)
1582 goto done;
1583 if (i) {
1584 state |= RMAP_LEFT_VALID;
1585 if (XFS_IS_CORRUPT(mp,
1586 LEFT.rm_startblock + LEFT.rm_blockcount >
1587 bno)) {
1588 error = -EFSCORRUPTED;
1589 goto done;
1590 }
1591 if (xfs_rmap_is_mergeable(&LEFT, owner, newext))
1592 state |= RMAP_LEFT_CONTIG;
1593 }
1594
1595 /* Is there a right record that abuts our range? */
1596 error = xfs_rmap_lookup_eq(cur, bno + len, len, owner, offset + len,
1597 newext, &i);
1598 if (error)
1599 goto done;
1600 if (i) {
1601 state |= RMAP_RIGHT_VALID;
1602 error = xfs_rmap_get_rec(cur, &RIGHT, &i);
1603 if (error)
1604 goto done;
1605 if (XFS_IS_CORRUPT(mp, i != 1)) {
1606 error = -EFSCORRUPTED;
1607 goto done;
1608 }
1609 if (XFS_IS_CORRUPT(mp, bno + len > RIGHT.rm_startblock)) {
1610 error = -EFSCORRUPTED;
1611 goto done;
1612 }
1613 trace_xfs_rmap_find_right_neighbor_result(cur->bc_mp,
1614 cur->bc_ag.pag->pag_agno, RIGHT.rm_startblock,
1615 RIGHT.rm_blockcount, RIGHT.rm_owner,
1616 RIGHT.rm_offset, RIGHT.rm_flags);
1617 if (xfs_rmap_is_mergeable(&RIGHT, owner, newext))
1618 state |= RMAP_RIGHT_CONTIG;
1619 }
1620
1621 /* check that left + prev + right is not too long */
1622 if ((state & (RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |
1623 RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG)) ==
1624 (RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |
1625 RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG) &&
1626 (unsigned long)LEFT.rm_blockcount + len +
1627 RIGHT.rm_blockcount > XFS_RMAP_LEN_MAX)
1628 state &= ~RMAP_RIGHT_CONTIG;
1629
1630 trace_xfs_rmap_convert_state(mp, cur->bc_ag.pag->pag_agno, state,
1631 _RET_IP_);
1632 /*
1633 * Switch out based on the FILLING and CONTIG state bits.
1634 */
1635 switch (state & (RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |
1636 RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG)) {
1637 case RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |
1638 RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG:
1639 /*
1640 * Setting all of a previous oldext extent to newext.
1641 * The left and right neighbors are both contiguous with new.
1642 */
1643 error = xfs_rmap_delete(cur, RIGHT.rm_startblock,
1644 RIGHT.rm_blockcount, RIGHT.rm_owner,
1645 RIGHT.rm_offset, RIGHT.rm_flags);
1646 if (error)
1647 goto done;
1648 error = xfs_rmap_delete(cur, PREV.rm_startblock,
1649 PREV.rm_blockcount, PREV.rm_owner,
1650 PREV.rm_offset, PREV.rm_flags);
1651 if (error)
1652 goto done;
1653 NEW = LEFT;
1654 error = xfs_rmap_lookup_eq(cur, NEW.rm_startblock,
1655 NEW.rm_blockcount, NEW.rm_owner,
1656 NEW.rm_offset, NEW.rm_flags, &i);
1657 if (error)
1658 goto done;
1659 if (XFS_IS_CORRUPT(mp, i != 1)) {
1660 error = -EFSCORRUPTED;
1661 goto done;
1662 }
1663 NEW.rm_blockcount += PREV.rm_blockcount + RIGHT.rm_blockcount;
1664 error = xfs_rmap_update(cur, &NEW);
1665 if (error)
1666 goto done;
1667 break;
1668
1669 case RMAP_LEFT_FILLING | RMAP_RIGHT_FILLING | RMAP_LEFT_CONTIG:
1670 /*
1671 * Setting all of a previous oldext extent to newext.
1672 * The left neighbor is contiguous, the right is not.
1673 */
1674 error = xfs_rmap_delete(cur, PREV.rm_startblock,
1675 PREV.rm_blockcount, PREV.rm_owner,
1676 PREV.rm_offset, PREV.rm_flags);
1677 if (error)
1678 goto done;
1679 NEW = LEFT;
1680 error = xfs_rmap_lookup_eq(cur, NEW.rm_startblock,
1681 NEW.rm_blockcount, NEW.rm_owner,
1682 NEW.rm_offset, NEW.rm_flags, &i);
1683 if (error)
1684 goto done;
1685 if (XFS_IS_CORRUPT(mp, i != 1)) {
1686 error = -EFSCORRUPTED;
1687 goto done;
1688 }
1689 NEW.rm_blockcount += PREV.rm_blockcount;
1690 error = xfs_rmap_update(cur, &NEW);
1691 if (error)
1692 goto done;
1693 break;
1694
1695 case RMAP_LEFT_FILLING | RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG:
1696 /*
1697 * Setting all of a previous oldext extent to newext.
1698 * The right neighbor is contiguous, the left is not.
1699 */
1700 error = xfs_rmap_delete(cur, RIGHT.rm_startblock,
1701 RIGHT.rm_blockcount, RIGHT.rm_owner,
1702 RIGHT.rm_offset, RIGHT.rm_flags);
1703 if (error)
1704 goto done;
1705 NEW = PREV;
1706 error = xfs_rmap_lookup_eq(cur, NEW.rm_startblock,
1707 NEW.rm_blockcount, NEW.rm_owner,
1708 NEW.rm_offset, NEW.rm_flags, &i);
1709 if (error)
1710 goto done;
1711 if (XFS_IS_CORRUPT(mp, i != 1)) {
1712 error = -EFSCORRUPTED;
1713 goto done;
1714 }
1715 NEW.rm_blockcount += RIGHT.rm_blockcount;
1716 NEW.rm_flags = RIGHT.rm_flags;
1717 error = xfs_rmap_update(cur, &NEW);
1718 if (error)
1719 goto done;
1720 break;
1721
1722 case RMAP_LEFT_FILLING | RMAP_RIGHT_FILLING:
1723 /*
1724 * Setting all of a previous oldext extent to newext.
1725 * Neither the left nor right neighbors are contiguous with
1726 * the new one.
1727 */
1728 NEW = PREV;
1729 error = xfs_rmap_lookup_eq(cur, NEW.rm_startblock,
1730 NEW.rm_blockcount, NEW.rm_owner,
1731 NEW.rm_offset, NEW.rm_flags, &i);
1732 if (error)
1733 goto done;
1734 if (XFS_IS_CORRUPT(mp, i != 1)) {
1735 error = -EFSCORRUPTED;
1736 goto done;
1737 }
1738 NEW.rm_flags = newext;
1739 error = xfs_rmap_update(cur, &NEW);
1740 if (error)
1741 goto done;
1742 break;
1743
1744 case RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG:
1745 /*
1746 * Setting the first part of a previous oldext extent to newext.
1747 * The left neighbor is contiguous.
1748 */
1749 NEW = PREV;
1750 error = xfs_rmap_delete(cur, NEW.rm_startblock,
1751 NEW.rm_blockcount, NEW.rm_owner,
1752 NEW.rm_offset, NEW.rm_flags);
1753 if (error)
1754 goto done;
1755 NEW.rm_offset += len;
1756 NEW.rm_startblock += len;
1757 NEW.rm_blockcount -= len;
1758 error = xfs_rmap_insert(cur, NEW.rm_startblock,
1759 NEW.rm_blockcount, NEW.rm_owner,
1760 NEW.rm_offset, NEW.rm_flags);
1761 if (error)
1762 goto done;
1763 NEW = LEFT;
1764 error = xfs_rmap_lookup_eq(cur, NEW.rm_startblock,
1765 NEW.rm_blockcount, NEW.rm_owner,
1766 NEW.rm_offset, NEW.rm_flags, &i);
1767 if (error)
1768 goto done;
1769 if (XFS_IS_CORRUPT(mp, i != 1)) {
1770 error = -EFSCORRUPTED;
1771 goto done;
1772 }
1773 NEW.rm_blockcount += len;
1774 error = xfs_rmap_update(cur, &NEW);
1775 if (error)
1776 goto done;
1777 break;
1778
1779 case RMAP_LEFT_FILLING:
1780 /*
1781 * Setting the first part of a previous oldext extent to newext.
1782 * The left neighbor is not contiguous.
1783 */
1784 NEW = PREV;
1785 error = xfs_rmap_delete(cur, NEW.rm_startblock,
1786 NEW.rm_blockcount, NEW.rm_owner,
1787 NEW.rm_offset, NEW.rm_flags);
1788 if (error)
1789 goto done;
1790 NEW.rm_offset += len;
1791 NEW.rm_startblock += len;
1792 NEW.rm_blockcount -= len;
1793 error = xfs_rmap_insert(cur, NEW.rm_startblock,
1794 NEW.rm_blockcount, NEW.rm_owner,
1795 NEW.rm_offset, NEW.rm_flags);
1796 if (error)
1797 goto done;
1798 error = xfs_rmap_insert(cur, bno, len, owner, offset, newext);
1799 if (error)
1800 goto done;
1801 break;
1802
1803 case RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG:
1804 /*
1805 * Setting the last part of a previous oldext extent to newext.
1806 * The right neighbor is contiguous with the new allocation.
1807 */
1808 NEW = PREV;
1809 error = xfs_rmap_lookup_eq(cur, NEW.rm_startblock,
1810 NEW.rm_blockcount, NEW.rm_owner,
1811 NEW.rm_offset, NEW.rm_flags, &i);
1812 if (error)
1813 goto done;
1814 if (XFS_IS_CORRUPT(mp, i != 1)) {
1815 error = -EFSCORRUPTED;
1816 goto done;
1817 }
1818 NEW.rm_blockcount = offset - NEW.rm_offset;
1819 error = xfs_rmap_update(cur, &NEW);
1820 if (error)
1821 goto done;
1822 NEW = RIGHT;
1823 error = xfs_rmap_delete(cur, NEW.rm_startblock,
1824 NEW.rm_blockcount, NEW.rm_owner,
1825 NEW.rm_offset, NEW.rm_flags);
1826 if (error)
1827 goto done;
1828 NEW.rm_offset = offset;
1829 NEW.rm_startblock = bno;
1830 NEW.rm_blockcount += len;
1831 error = xfs_rmap_insert(cur, NEW.rm_startblock,
1832 NEW.rm_blockcount, NEW.rm_owner,
1833 NEW.rm_offset, NEW.rm_flags);
1834 if (error)
1835 goto done;
1836 break;
1837
1838 case RMAP_RIGHT_FILLING:
1839 /*
1840 * Setting the last part of a previous oldext extent to newext.
1841 * The right neighbor is not contiguous.
1842 */
1843 NEW = PREV;
1844 error = xfs_rmap_lookup_eq(cur, NEW.rm_startblock,
1845 NEW.rm_blockcount, NEW.rm_owner,
1846 NEW.rm_offset, NEW.rm_flags, &i);
1847 if (error)
1848 goto done;
1849 if (XFS_IS_CORRUPT(mp, i != 1)) {
1850 error = -EFSCORRUPTED;
1851 goto done;
1852 }
1853 NEW.rm_blockcount -= len;
1854 error = xfs_rmap_update(cur, &NEW);
1855 if (error)
1856 goto done;
1857 error = xfs_rmap_insert(cur, bno, len, owner, offset, newext);
1858 if (error)
1859 goto done;
1860 break;
1861
1862 case 0:
1863 /*
1864 * Setting the middle part of a previous oldext extent to
1865 * newext. Contiguity is impossible here.
1866 * One extent becomes three extents.
1867 */
1868 /* new right extent - oldext */
1869 NEW.rm_startblock = bno + len;
1870 NEW.rm_owner = owner;
1871 NEW.rm_offset = new_endoff;
1872 NEW.rm_blockcount = PREV.rm_offset + PREV.rm_blockcount -
1873 new_endoff;
1874 NEW.rm_flags = PREV.rm_flags;
1875 error = xfs_rmap_insert(cur, NEW.rm_startblock,
1876 NEW.rm_blockcount, NEW.rm_owner, NEW.rm_offset,
1877 NEW.rm_flags);
1878 if (error)
1879 goto done;
1880 /* new left extent - oldext */
1881 NEW = PREV;
1882 error = xfs_rmap_lookup_eq(cur, NEW.rm_startblock,
1883 NEW.rm_blockcount, NEW.rm_owner,
1884 NEW.rm_offset, NEW.rm_flags, &i);
1885 if (error)
1886 goto done;
1887 if (XFS_IS_CORRUPT(mp, i != 1)) {
1888 error = -EFSCORRUPTED;
1889 goto done;
1890 }
1891 NEW.rm_blockcount = offset - NEW.rm_offset;
1892 error = xfs_rmap_update(cur, &NEW);
1893 if (error)
1894 goto done;
1895 /* new middle extent - newext */
1896 NEW.rm_startblock = bno;
1897 NEW.rm_blockcount = len;
1898 NEW.rm_owner = owner;
1899 NEW.rm_offset = offset;
1900 NEW.rm_flags = newext;
1901 error = xfs_rmap_insert(cur, NEW.rm_startblock,
1902 NEW.rm_blockcount, NEW.rm_owner, NEW.rm_offset,
1903 NEW.rm_flags);
1904 if (error)
1905 goto done;
1906 break;
1907
1908 case RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG | RMAP_RIGHT_CONTIG:
1909 case RMAP_RIGHT_FILLING | RMAP_LEFT_CONTIG | RMAP_RIGHT_CONTIG:
1910 case RMAP_LEFT_FILLING | RMAP_RIGHT_CONTIG:
1911 case RMAP_RIGHT_FILLING | RMAP_LEFT_CONTIG:
1912 case RMAP_LEFT_CONTIG | RMAP_RIGHT_CONTIG:
1913 case RMAP_LEFT_CONTIG:
1914 case RMAP_RIGHT_CONTIG:
1915 /*
1916 * These cases are all impossible.
1917 */
1918 ASSERT(0);
1919 }
1920
1921 trace_xfs_rmap_convert_done(mp, cur->bc_ag.pag->pag_agno, bno, len,
1922 unwritten, oinfo);
1923done:
1924 if (error)
1925 trace_xfs_rmap_convert_error(cur->bc_mp,
1926 cur->bc_ag.pag->pag_agno, error, _RET_IP_);
1927 return error;
1928}
1929
1930#undef NEW
1931#undef LEFT
1932#undef RIGHT
1933#undef PREV
1934
1935/*
1936 * Find an extent in the rmap btree and unmap it. For rmap extent types that
1937 * can overlap (data fork rmaps on reflink filesystems) we must be careful
1938 * that the prev/next records in the btree might belong to another owner.
1939 * Therefore we must use delete+insert to alter any of the key fields.
1940 *
1941 * For every other situation there can only be one owner for a given extent,
1942 * so we can call the regular _free function.
1943 */
1944STATIC int
1945xfs_rmap_unmap_shared(
1946 struct xfs_btree_cur *cur,
1947 xfs_agblock_t bno,
1948 xfs_extlen_t len,
1949 bool unwritten,
1950 const struct xfs_owner_info *oinfo)
1951{
1952 struct xfs_mount *mp = cur->bc_mp;
1953 struct xfs_rmap_irec ltrec;
1954 uint64_t ltoff;
1955 int error = 0;
1956 int i;
1957 uint64_t owner;
1958 uint64_t offset;
1959 unsigned int flags;
1960
1961 xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
1962 if (unwritten)
1963 flags |= XFS_RMAP_UNWRITTEN;
1964 trace_xfs_rmap_unmap(mp, cur->bc_ag.pag->pag_agno, bno, len,
1965 unwritten, oinfo);
1966
1967 /*
1968 * We should always have a left record because there's a static record
1969 * for the AG headers at rm_startblock == 0 created by mkfs/growfs that
1970 * will not ever be removed from the tree.
1971 */
1972 error = xfs_rmap_lookup_le_range(cur, bno, owner, offset, flags,
1973 <rec, &i);
1974 if (error)
1975 goto out_error;
1976 if (XFS_IS_CORRUPT(mp, i != 1)) {
1977 error = -EFSCORRUPTED;
1978 goto out_error;
1979 }
1980 ltoff = ltrec.rm_offset;
1981
1982 /* Make sure the extent we found covers the entire freeing range. */
1983 if (XFS_IS_CORRUPT(mp,
1984 ltrec.rm_startblock > bno ||
1985 ltrec.rm_startblock + ltrec.rm_blockcount <
1986 bno + len)) {
1987 error = -EFSCORRUPTED;
1988 goto out_error;
1989 }
1990
1991 /* Make sure the owner matches what we expect to find in the tree. */
1992 if (XFS_IS_CORRUPT(mp, owner != ltrec.rm_owner)) {
1993 error = -EFSCORRUPTED;
1994 goto out_error;
1995 }
1996
1997 /* Make sure the unwritten flag matches. */
1998 if (XFS_IS_CORRUPT(mp,
1999 (flags & XFS_RMAP_UNWRITTEN) !=
2000 (ltrec.rm_flags & XFS_RMAP_UNWRITTEN))) {
2001 error = -EFSCORRUPTED;
2002 goto out_error;
2003 }
2004
2005 /* Check the offset. */
2006 if (XFS_IS_CORRUPT(mp, ltrec.rm_offset > offset)) {
2007 error = -EFSCORRUPTED;
2008 goto out_error;
2009 }
2010 if (XFS_IS_CORRUPT(mp, offset > ltoff + ltrec.rm_blockcount)) {
2011 error = -EFSCORRUPTED;
2012 goto out_error;
2013 }
2014
2015 if (ltrec.rm_startblock == bno && ltrec.rm_blockcount == len) {
2016 /* Exact match, simply remove the record from rmap tree. */
2017 error = xfs_rmap_delete(cur, ltrec.rm_startblock,
2018 ltrec.rm_blockcount, ltrec.rm_owner,
2019 ltrec.rm_offset, ltrec.rm_flags);
2020 if (error)
2021 goto out_error;
2022 } else if (ltrec.rm_startblock == bno) {
2023 /*
2024 * Overlap left hand side of extent: move the start, trim the
2025 * length and update the current record.
2026 *
2027 * ltbno ltlen
2028 * Orig: |oooooooooooooooooooo|
2029 * Freeing: |fffffffff|
2030 * Result: |rrrrrrrrrr|
2031 * bno len
2032 */
2033
2034 /* Delete prev rmap. */
2035 error = xfs_rmap_delete(cur, ltrec.rm_startblock,
2036 ltrec.rm_blockcount, ltrec.rm_owner,
2037 ltrec.rm_offset, ltrec.rm_flags);
2038 if (error)
2039 goto out_error;
2040
2041 /* Add an rmap at the new offset. */
2042 ltrec.rm_startblock += len;
2043 ltrec.rm_blockcount -= len;
2044 ltrec.rm_offset += len;
2045 error = xfs_rmap_insert(cur, ltrec.rm_startblock,
2046 ltrec.rm_blockcount, ltrec.rm_owner,
2047 ltrec.rm_offset, ltrec.rm_flags);
2048 if (error)
2049 goto out_error;
2050 } else if (ltrec.rm_startblock + ltrec.rm_blockcount == bno + len) {
2051 /*
2052 * Overlap right hand side of extent: trim the length and
2053 * update the current record.
2054 *
2055 * ltbno ltlen
2056 * Orig: |oooooooooooooooooooo|
2057 * Freeing: |fffffffff|
2058 * Result: |rrrrrrrrrr|
2059 * bno len
2060 */
2061 error = xfs_rmap_lookup_eq(cur, ltrec.rm_startblock,
2062 ltrec.rm_blockcount, ltrec.rm_owner,
2063 ltrec.rm_offset, ltrec.rm_flags, &i);
2064 if (error)
2065 goto out_error;
2066 if (XFS_IS_CORRUPT(mp, i != 1)) {
2067 error = -EFSCORRUPTED;
2068 goto out_error;
2069 }
2070 ltrec.rm_blockcount -= len;
2071 error = xfs_rmap_update(cur, <rec);
2072 if (error)
2073 goto out_error;
2074 } else {
2075 /*
2076 * Overlap middle of extent: trim the length of the existing
2077 * record to the length of the new left-extent size, increment
2078 * the insertion position so we can insert a new record
2079 * containing the remaining right-extent space.
2080 *
2081 * ltbno ltlen
2082 * Orig: |oooooooooooooooooooo|
2083 * Freeing: |fffffffff|
2084 * Result: |rrrrr| |rrrr|
2085 * bno len
2086 */
2087 xfs_extlen_t orig_len = ltrec.rm_blockcount;
2088
2089 /* Shrink the left side of the rmap */
2090 error = xfs_rmap_lookup_eq(cur, ltrec.rm_startblock,
2091 ltrec.rm_blockcount, ltrec.rm_owner,
2092 ltrec.rm_offset, ltrec.rm_flags, &i);
2093 if (error)
2094 goto out_error;
2095 if (XFS_IS_CORRUPT(mp, i != 1)) {
2096 error = -EFSCORRUPTED;
2097 goto out_error;
2098 }
2099 ltrec.rm_blockcount = bno - ltrec.rm_startblock;
2100 error = xfs_rmap_update(cur, <rec);
2101 if (error)
2102 goto out_error;
2103
2104 /* Add an rmap at the new offset */
2105 error = xfs_rmap_insert(cur, bno + len,
2106 orig_len - len - ltrec.rm_blockcount,
2107 ltrec.rm_owner, offset + len,
2108 ltrec.rm_flags);
2109 if (error)
2110 goto out_error;
2111 }
2112
2113 trace_xfs_rmap_unmap_done(mp, cur->bc_ag.pag->pag_agno, bno, len,
2114 unwritten, oinfo);
2115out_error:
2116 if (error)
2117 trace_xfs_rmap_unmap_error(cur->bc_mp,
2118 cur->bc_ag.pag->pag_agno, error, _RET_IP_);
2119 return error;
2120}
2121
2122/*
2123 * Find an extent in the rmap btree and map it. For rmap extent types that
2124 * can overlap (data fork rmaps on reflink filesystems) we must be careful
2125 * that the prev/next records in the btree might belong to another owner.
2126 * Therefore we must use delete+insert to alter any of the key fields.
2127 *
2128 * For every other situation there can only be one owner for a given extent,
2129 * so we can call the regular _alloc function.
2130 */
2131STATIC int
2132xfs_rmap_map_shared(
2133 struct xfs_btree_cur *cur,
2134 xfs_agblock_t bno,
2135 xfs_extlen_t len,
2136 bool unwritten,
2137 const struct xfs_owner_info *oinfo)
2138{
2139 struct xfs_mount *mp = cur->bc_mp;
2140 struct xfs_rmap_irec ltrec;
2141 struct xfs_rmap_irec gtrec;
2142 int have_gt;
2143 int have_lt;
2144 int error = 0;
2145 int i;
2146 uint64_t owner;
2147 uint64_t offset;
2148 unsigned int flags = 0;
2149
2150 xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
2151 if (unwritten)
2152 flags |= XFS_RMAP_UNWRITTEN;
2153 trace_xfs_rmap_map(mp, cur->bc_ag.pag->pag_agno, bno, len,
2154 unwritten, oinfo);
2155
2156 /* Is there a left record that abuts our range? */
2157 error = xfs_rmap_find_left_neighbor(cur, bno, owner, offset, flags,
2158 <rec, &have_lt);
2159 if (error)
2160 goto out_error;
2161 if (have_lt &&
2162 !xfs_rmap_is_mergeable(<rec, owner, flags))
2163 have_lt = 0;
2164
2165 /* Is there a right record that abuts our range? */
2166 error = xfs_rmap_lookup_eq(cur, bno + len, len, owner, offset + len,
2167 flags, &have_gt);
2168 if (error)
2169 goto out_error;
2170 if (have_gt) {
2171 error = xfs_rmap_get_rec(cur, >rec, &have_gt);
2172 if (error)
2173 goto out_error;
2174 if (XFS_IS_CORRUPT(mp, have_gt != 1)) {
2175 error = -EFSCORRUPTED;
2176 goto out_error;
2177 }
2178 trace_xfs_rmap_find_right_neighbor_result(cur->bc_mp,
2179 cur->bc_ag.pag->pag_agno, gtrec.rm_startblock,
2180 gtrec.rm_blockcount, gtrec.rm_owner,
2181 gtrec.rm_offset, gtrec.rm_flags);
2182
2183 if (!xfs_rmap_is_mergeable(>rec, owner, flags))
2184 have_gt = 0;
2185 }
2186
2187 if (have_lt &&
2188 ltrec.rm_startblock + ltrec.rm_blockcount == bno &&
2189 ltrec.rm_offset + ltrec.rm_blockcount == offset) {
2190 /*
2191 * Left edge contiguous, merge into left record.
2192 *
2193 * ltbno ltlen
2194 * orig: |ooooooooo|
2195 * adding: |aaaaaaaaa|
2196 * result: |rrrrrrrrrrrrrrrrrrr|
2197 * bno len
2198 */
2199 ltrec.rm_blockcount += len;
2200 if (have_gt &&
2201 bno + len == gtrec.rm_startblock &&
2202 offset + len == gtrec.rm_offset) {
2203 /*
2204 * Right edge also contiguous, delete right record
2205 * and merge into left record.
2206 *
2207 * ltbno ltlen gtbno gtlen
2208 * orig: |ooooooooo| |ooooooooo|
2209 * adding: |aaaaaaaaa|
2210 * result: |rrrrrrrrrrrrrrrrrrrrrrrrrrrrr|
2211 */
2212 ltrec.rm_blockcount += gtrec.rm_blockcount;
2213 error = xfs_rmap_delete(cur, gtrec.rm_startblock,
2214 gtrec.rm_blockcount, gtrec.rm_owner,
2215 gtrec.rm_offset, gtrec.rm_flags);
2216 if (error)
2217 goto out_error;
2218 }
2219
2220 /* Point the cursor back to the left record and update. */
2221 error = xfs_rmap_lookup_eq(cur, ltrec.rm_startblock,
2222 ltrec.rm_blockcount, ltrec.rm_owner,
2223 ltrec.rm_offset, ltrec.rm_flags, &i);
2224 if (error)
2225 goto out_error;
2226 if (XFS_IS_CORRUPT(mp, i != 1)) {
2227 error = -EFSCORRUPTED;
2228 goto out_error;
2229 }
2230
2231 error = xfs_rmap_update(cur, <rec);
2232 if (error)
2233 goto out_error;
2234 } else if (have_gt &&
2235 bno + len == gtrec.rm_startblock &&
2236 offset + len == gtrec.rm_offset) {
2237 /*
2238 * Right edge contiguous, merge into right record.
2239 *
2240 * gtbno gtlen
2241 * Orig: |ooooooooo|
2242 * adding: |aaaaaaaaa|
2243 * Result: |rrrrrrrrrrrrrrrrrrr|
2244 * bno len
2245 */
2246 /* Delete the old record. */
2247 error = xfs_rmap_delete(cur, gtrec.rm_startblock,
2248 gtrec.rm_blockcount, gtrec.rm_owner,
2249 gtrec.rm_offset, gtrec.rm_flags);
2250 if (error)
2251 goto out_error;
2252
2253 /* Move the start and re-add it. */
2254 gtrec.rm_startblock = bno;
2255 gtrec.rm_blockcount += len;
2256 gtrec.rm_offset = offset;
2257 error = xfs_rmap_insert(cur, gtrec.rm_startblock,
2258 gtrec.rm_blockcount, gtrec.rm_owner,
2259 gtrec.rm_offset, gtrec.rm_flags);
2260 if (error)
2261 goto out_error;
2262 } else {
2263 /*
2264 * No contiguous edge with identical owner, insert
2265 * new record at current cursor position.
2266 */
2267 error = xfs_rmap_insert(cur, bno, len, owner, offset, flags);
2268 if (error)
2269 goto out_error;
2270 }
2271
2272 trace_xfs_rmap_map_done(mp, cur->bc_ag.pag->pag_agno, bno, len,
2273 unwritten, oinfo);
2274out_error:
2275 if (error)
2276 trace_xfs_rmap_map_error(cur->bc_mp,
2277 cur->bc_ag.pag->pag_agno, error, _RET_IP_);
2278 return error;
2279}
2280
2281/* Insert a raw rmap into the rmapbt. */
2282int
2283xfs_rmap_map_raw(
2284 struct xfs_btree_cur *cur,
2285 struct xfs_rmap_irec *rmap)
2286{
2287 struct xfs_owner_info oinfo;
2288
2289 oinfo.oi_owner = rmap->rm_owner;
2290 oinfo.oi_offset = rmap->rm_offset;
2291 oinfo.oi_flags = 0;
2292 if (rmap->rm_flags & XFS_RMAP_ATTR_FORK)
2293 oinfo.oi_flags |= XFS_OWNER_INFO_ATTR_FORK;
2294 if (rmap->rm_flags & XFS_RMAP_BMBT_BLOCK)
2295 oinfo.oi_flags |= XFS_OWNER_INFO_BMBT_BLOCK;
2296
2297 if (rmap->rm_flags || XFS_RMAP_NON_INODE_OWNER(rmap->rm_owner))
2298 return xfs_rmap_map(cur, rmap->rm_startblock,
2299 rmap->rm_blockcount,
2300 rmap->rm_flags & XFS_RMAP_UNWRITTEN,
2301 &oinfo);
2302
2303 return xfs_rmap_map_shared(cur, rmap->rm_startblock,
2304 rmap->rm_blockcount,
2305 rmap->rm_flags & XFS_RMAP_UNWRITTEN,
2306 &oinfo);
2307}
2308
2309struct xfs_rmap_query_range_info {
2310 xfs_rmap_query_range_fn fn;
2311 void *priv;
2312};
2313
2314/* Format btree record and pass to our callback. */
2315STATIC int
2316xfs_rmap_query_range_helper(
2317 struct xfs_btree_cur *cur,
2318 const union xfs_btree_rec *rec,
2319 void *priv)
2320{
2321 struct xfs_rmap_query_range_info *query = priv;
2322 struct xfs_rmap_irec irec;
2323 int error;
2324
2325 error = xfs_rmap_btrec_to_irec(rec, &irec);
2326 if (error)
2327 return error;
2328 return query->fn(cur, &irec, query->priv);
2329}
2330
2331/* Find all rmaps between two keys. */
2332int
2333xfs_rmap_query_range(
2334 struct xfs_btree_cur *cur,
2335 const struct xfs_rmap_irec *low_rec,
2336 const struct xfs_rmap_irec *high_rec,
2337 xfs_rmap_query_range_fn fn,
2338 void *priv)
2339{
2340 union xfs_btree_irec low_brec;
2341 union xfs_btree_irec high_brec;
2342 struct xfs_rmap_query_range_info query;
2343
2344 low_brec.r = *low_rec;
2345 high_brec.r = *high_rec;
2346 query.priv = priv;
2347 query.fn = fn;
2348 return xfs_btree_query_range(cur, &low_brec, &high_brec,
2349 xfs_rmap_query_range_helper, &query);
2350}
2351
2352/* Find all rmaps. */
2353int
2354xfs_rmap_query_all(
2355 struct xfs_btree_cur *cur,
2356 xfs_rmap_query_range_fn fn,
2357 void *priv)
2358{
2359 struct xfs_rmap_query_range_info query;
2360
2361 query.priv = priv;
2362 query.fn = fn;
2363 return xfs_btree_query_all(cur, xfs_rmap_query_range_helper, &query);
2364}
2365
2366/* Clean up after calling xfs_rmap_finish_one. */
2367void
2368xfs_rmap_finish_one_cleanup(
2369 struct xfs_trans *tp,
2370 struct xfs_btree_cur *rcur,
2371 int error)
2372{
2373 struct xfs_buf *agbp;
2374
2375 if (rcur == NULL)
2376 return;
2377 agbp = rcur->bc_ag.agbp;
2378 xfs_btree_del_cursor(rcur, error);
2379 if (error)
2380 xfs_trans_brelse(tp, agbp);
2381}
2382
2383/*
2384 * Process one of the deferred rmap operations. We pass back the
2385 * btree cursor to maintain our lock on the rmapbt between calls.
2386 * This saves time and eliminates a buffer deadlock between the
2387 * superblock and the AGF because we'll always grab them in the same
2388 * order.
2389 */
2390int
2391xfs_rmap_finish_one(
2392 struct xfs_trans *tp,
2393 enum xfs_rmap_intent_type type,
2394 uint64_t owner,
2395 int whichfork,
2396 xfs_fileoff_t startoff,
2397 xfs_fsblock_t startblock,
2398 xfs_filblks_t blockcount,
2399 xfs_exntst_t state,
2400 struct xfs_btree_cur **pcur)
2401{
2402 struct xfs_mount *mp = tp->t_mountp;
2403 struct xfs_perag *pag;
2404 struct xfs_btree_cur *rcur;
2405 struct xfs_buf *agbp = NULL;
2406 int error = 0;
2407 struct xfs_owner_info oinfo;
2408 xfs_agblock_t bno;
2409 bool unwritten;
2410
2411 pag = xfs_perag_get(mp, XFS_FSB_TO_AGNO(mp, startblock));
2412 bno = XFS_FSB_TO_AGBNO(mp, startblock);
2413
2414 trace_xfs_rmap_deferred(mp, pag->pag_agno, type, bno, owner, whichfork,
2415 startoff, blockcount, state);
2416
2417 if (XFS_TEST_ERROR(false, mp, XFS_ERRTAG_RMAP_FINISH_ONE)) {
2418 error = -EIO;
2419 goto out_drop;
2420 }
2421
2422
2423 /*
2424 * If we haven't gotten a cursor or the cursor AG doesn't match
2425 * the startblock, get one now.
2426 */
2427 rcur = *pcur;
2428 if (rcur != NULL && rcur->bc_ag.pag != pag) {
2429 xfs_rmap_finish_one_cleanup(tp, rcur, 0);
2430 rcur = NULL;
2431 *pcur = NULL;
2432 }
2433 if (rcur == NULL) {
2434 /*
2435 * Refresh the freelist before we start changing the
2436 * rmapbt, because a shape change could cause us to
2437 * allocate blocks.
2438 */
2439 error = xfs_free_extent_fix_freelist(tp, pag, &agbp);
2440 if (error)
2441 goto out_drop;
2442 if (XFS_IS_CORRUPT(tp->t_mountp, !agbp)) {
2443 error = -EFSCORRUPTED;
2444 goto out_drop;
2445 }
2446
2447 rcur = xfs_rmapbt_init_cursor(mp, tp, agbp, pag);
2448 }
2449 *pcur = rcur;
2450
2451 xfs_rmap_ino_owner(&oinfo, owner, whichfork, startoff);
2452 unwritten = state == XFS_EXT_UNWRITTEN;
2453 bno = XFS_FSB_TO_AGBNO(rcur->bc_mp, startblock);
2454
2455 switch (type) {
2456 case XFS_RMAP_ALLOC:
2457 case XFS_RMAP_MAP:
2458 error = xfs_rmap_map(rcur, bno, blockcount, unwritten, &oinfo);
2459 break;
2460 case XFS_RMAP_MAP_SHARED:
2461 error = xfs_rmap_map_shared(rcur, bno, blockcount, unwritten,
2462 &oinfo);
2463 break;
2464 case XFS_RMAP_FREE:
2465 case XFS_RMAP_UNMAP:
2466 error = xfs_rmap_unmap(rcur, bno, blockcount, unwritten,
2467 &oinfo);
2468 break;
2469 case XFS_RMAP_UNMAP_SHARED:
2470 error = xfs_rmap_unmap_shared(rcur, bno, blockcount, unwritten,
2471 &oinfo);
2472 break;
2473 case XFS_RMAP_CONVERT:
2474 error = xfs_rmap_convert(rcur, bno, blockcount, !unwritten,
2475 &oinfo);
2476 break;
2477 case XFS_RMAP_CONVERT_SHARED:
2478 error = xfs_rmap_convert_shared(rcur, bno, blockcount,
2479 !unwritten, &oinfo);
2480 break;
2481 default:
2482 ASSERT(0);
2483 error = -EFSCORRUPTED;
2484 }
2485out_drop:
2486 xfs_perag_put(pag);
2487 return error;
2488}
2489
2490/*
2491 * Don't defer an rmap if we aren't an rmap filesystem.
2492 */
2493static bool
2494xfs_rmap_update_is_needed(
2495 struct xfs_mount *mp,
2496 int whichfork)
2497{
2498 return xfs_has_rmapbt(mp) && whichfork != XFS_COW_FORK;
2499}
2500
2501/*
2502 * Record a rmap intent; the list is kept sorted first by AG and then by
2503 * increasing age.
2504 */
2505static void
2506__xfs_rmap_add(
2507 struct xfs_trans *tp,
2508 enum xfs_rmap_intent_type type,
2509 uint64_t owner,
2510 int whichfork,
2511 struct xfs_bmbt_irec *bmap)
2512{
2513 struct xfs_rmap_intent *ri;
2514
2515 trace_xfs_rmap_defer(tp->t_mountp,
2516 XFS_FSB_TO_AGNO(tp->t_mountp, bmap->br_startblock),
2517 type,
2518 XFS_FSB_TO_AGBNO(tp->t_mountp, bmap->br_startblock),
2519 owner, whichfork,
2520 bmap->br_startoff,
2521 bmap->br_blockcount,
2522 bmap->br_state);
2523
2524 ri = kmem_cache_alloc(xfs_rmap_intent_cache, GFP_NOFS | __GFP_NOFAIL);
2525 INIT_LIST_HEAD(&ri->ri_list);
2526 ri->ri_type = type;
2527 ri->ri_owner = owner;
2528 ri->ri_whichfork = whichfork;
2529 ri->ri_bmap = *bmap;
2530
2531 xfs_defer_add(tp, XFS_DEFER_OPS_TYPE_RMAP, &ri->ri_list);
2532}
2533
2534/* Map an extent into a file. */
2535void
2536xfs_rmap_map_extent(
2537 struct xfs_trans *tp,
2538 struct xfs_inode *ip,
2539 int whichfork,
2540 struct xfs_bmbt_irec *PREV)
2541{
2542 enum xfs_rmap_intent_type type = XFS_RMAP_MAP;
2543
2544 if (!xfs_rmap_update_is_needed(tp->t_mountp, whichfork))
2545 return;
2546
2547 if (whichfork != XFS_ATTR_FORK && xfs_is_reflink_inode(ip))
2548 type = XFS_RMAP_MAP_SHARED;
2549
2550 __xfs_rmap_add(tp, type, ip->i_ino, whichfork, PREV);
2551}
2552
2553/* Unmap an extent out of a file. */
2554void
2555xfs_rmap_unmap_extent(
2556 struct xfs_trans *tp,
2557 struct xfs_inode *ip,
2558 int whichfork,
2559 struct xfs_bmbt_irec *PREV)
2560{
2561 enum xfs_rmap_intent_type type = XFS_RMAP_UNMAP;
2562
2563 if (!xfs_rmap_update_is_needed(tp->t_mountp, whichfork))
2564 return;
2565
2566 if (whichfork != XFS_ATTR_FORK && xfs_is_reflink_inode(ip))
2567 type = XFS_RMAP_UNMAP_SHARED;
2568
2569 __xfs_rmap_add(tp, type, ip->i_ino, whichfork, PREV);
2570}
2571
2572/*
2573 * Convert a data fork extent from unwritten to real or vice versa.
2574 *
2575 * Note that tp can be NULL here as no transaction is used for COW fork
2576 * unwritten conversion.
2577 */
2578void
2579xfs_rmap_convert_extent(
2580 struct xfs_mount *mp,
2581 struct xfs_trans *tp,
2582 struct xfs_inode *ip,
2583 int whichfork,
2584 struct xfs_bmbt_irec *PREV)
2585{
2586 enum xfs_rmap_intent_type type = XFS_RMAP_CONVERT;
2587
2588 if (!xfs_rmap_update_is_needed(mp, whichfork))
2589 return;
2590
2591 if (whichfork != XFS_ATTR_FORK && xfs_is_reflink_inode(ip))
2592 type = XFS_RMAP_CONVERT_SHARED;
2593
2594 __xfs_rmap_add(tp, type, ip->i_ino, whichfork, PREV);
2595}
2596
2597/* Schedule the creation of an rmap for non-file data. */
2598void
2599xfs_rmap_alloc_extent(
2600 struct xfs_trans *tp,
2601 xfs_agnumber_t agno,
2602 xfs_agblock_t bno,
2603 xfs_extlen_t len,
2604 uint64_t owner)
2605{
2606 struct xfs_bmbt_irec bmap;
2607
2608 if (!xfs_rmap_update_is_needed(tp->t_mountp, XFS_DATA_FORK))
2609 return;
2610
2611 bmap.br_startblock = XFS_AGB_TO_FSB(tp->t_mountp, agno, bno);
2612 bmap.br_blockcount = len;
2613 bmap.br_startoff = 0;
2614 bmap.br_state = XFS_EXT_NORM;
2615
2616 __xfs_rmap_add(tp, XFS_RMAP_ALLOC, owner, XFS_DATA_FORK, &bmap);
2617}
2618
2619/* Schedule the deletion of an rmap for non-file data. */
2620void
2621xfs_rmap_free_extent(
2622 struct xfs_trans *tp,
2623 xfs_agnumber_t agno,
2624 xfs_agblock_t bno,
2625 xfs_extlen_t len,
2626 uint64_t owner)
2627{
2628 struct xfs_bmbt_irec bmap;
2629
2630 if (!xfs_rmap_update_is_needed(tp->t_mountp, XFS_DATA_FORK))
2631 return;
2632
2633 bmap.br_startblock = XFS_AGB_TO_FSB(tp->t_mountp, agno, bno);
2634 bmap.br_blockcount = len;
2635 bmap.br_startoff = 0;
2636 bmap.br_state = XFS_EXT_NORM;
2637
2638 __xfs_rmap_add(tp, XFS_RMAP_FREE, owner, XFS_DATA_FORK, &bmap);
2639}
2640
2641/* Compare rmap records. Returns -1 if a < b, 1 if a > b, and 0 if equal. */
2642int
2643xfs_rmap_compare(
2644 const struct xfs_rmap_irec *a,
2645 const struct xfs_rmap_irec *b)
2646{
2647 __u64 oa;
2648 __u64 ob;
2649
2650 oa = xfs_rmap_irec_offset_pack(a);
2651 ob = xfs_rmap_irec_offset_pack(b);
2652
2653 if (a->rm_startblock < b->rm_startblock)
2654 return -1;
2655 else if (a->rm_startblock > b->rm_startblock)
2656 return 1;
2657 else if (a->rm_owner < b->rm_owner)
2658 return -1;
2659 else if (a->rm_owner > b->rm_owner)
2660 return 1;
2661 else if (oa < ob)
2662 return -1;
2663 else if (oa > ob)
2664 return 1;
2665 else
2666 return 0;
2667}
2668
2669/* Is there a record covering a given extent? */
2670int
2671xfs_rmap_has_record(
2672 struct xfs_btree_cur *cur,
2673 xfs_agblock_t bno,
2674 xfs_extlen_t len,
2675 bool *exists)
2676{
2677 union xfs_btree_irec low;
2678 union xfs_btree_irec high;
2679
2680 memset(&low, 0, sizeof(low));
2681 low.r.rm_startblock = bno;
2682 memset(&high, 0xFF, sizeof(high));
2683 high.r.rm_startblock = bno + len - 1;
2684
2685 return xfs_btree_has_record(cur, &low, &high, exists);
2686}
2687
2688/*
2689 * Is there a record for this owner completely covering a given physical
2690 * extent? If so, *has_rmap will be set to true. If there is no record
2691 * or the record only covers part of the range, we set *has_rmap to false.
2692 * This function doesn't perform range lookups or offset checks, so it is
2693 * not suitable for checking data fork blocks.
2694 */
2695int
2696xfs_rmap_record_exists(
2697 struct xfs_btree_cur *cur,
2698 xfs_agblock_t bno,
2699 xfs_extlen_t len,
2700 const struct xfs_owner_info *oinfo,
2701 bool *has_rmap)
2702{
2703 uint64_t owner;
2704 uint64_t offset;
2705 unsigned int flags;
2706 int has_record;
2707 struct xfs_rmap_irec irec;
2708 int error;
2709
2710 xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
2711 ASSERT(XFS_RMAP_NON_INODE_OWNER(owner) ||
2712 (flags & XFS_RMAP_BMBT_BLOCK));
2713
2714 error = xfs_rmap_lookup_le(cur, bno, owner, offset, flags, &irec,
2715 &has_record);
2716 if (error)
2717 return error;
2718 if (!has_record) {
2719 *has_rmap = false;
2720 return 0;
2721 }
2722
2723 *has_rmap = (irec.rm_owner == owner && irec.rm_startblock <= bno &&
2724 irec.rm_startblock + irec.rm_blockcount >= bno + len);
2725 return 0;
2726}
2727
2728struct xfs_rmap_key_state {
2729 uint64_t owner;
2730 uint64_t offset;
2731 unsigned int flags;
2732};
2733
2734/* For each rmap given, figure out if it doesn't match the key we want. */
2735STATIC int
2736xfs_rmap_has_other_keys_helper(
2737 struct xfs_btree_cur *cur,
2738 const struct xfs_rmap_irec *rec,
2739 void *priv)
2740{
2741 struct xfs_rmap_key_state *rks = priv;
2742
2743 if (rks->owner == rec->rm_owner && rks->offset == rec->rm_offset &&
2744 ((rks->flags & rec->rm_flags) & XFS_RMAP_KEY_FLAGS) == rks->flags)
2745 return 0;
2746 return -ECANCELED;
2747}
2748
2749/*
2750 * Given an extent and some owner info, can we find records overlapping
2751 * the extent whose owner info does not match the given owner?
2752 */
2753int
2754xfs_rmap_has_other_keys(
2755 struct xfs_btree_cur *cur,
2756 xfs_agblock_t bno,
2757 xfs_extlen_t len,
2758 const struct xfs_owner_info *oinfo,
2759 bool *has_rmap)
2760{
2761 struct xfs_rmap_irec low = {0};
2762 struct xfs_rmap_irec high;
2763 struct xfs_rmap_key_state rks;
2764 int error;
2765
2766 xfs_owner_info_unpack(oinfo, &rks.owner, &rks.offset, &rks.flags);
2767 *has_rmap = false;
2768
2769 low.rm_startblock = bno;
2770 memset(&high, 0xFF, sizeof(high));
2771 high.rm_startblock = bno + len - 1;
2772
2773 error = xfs_rmap_query_range(cur, &low, &high,
2774 xfs_rmap_has_other_keys_helper, &rks);
2775 if (error == -ECANCELED) {
2776 *has_rmap = true;
2777 return 0;
2778 }
2779
2780 return error;
2781}
2782
2783const struct xfs_owner_info XFS_RMAP_OINFO_SKIP_UPDATE = {
2784 .oi_owner = XFS_RMAP_OWN_NULL,
2785};
2786const struct xfs_owner_info XFS_RMAP_OINFO_ANY_OWNER = {
2787 .oi_owner = XFS_RMAP_OWN_UNKNOWN,
2788};
2789const struct xfs_owner_info XFS_RMAP_OINFO_FS = {
2790 .oi_owner = XFS_RMAP_OWN_FS,
2791};
2792const struct xfs_owner_info XFS_RMAP_OINFO_LOG = {
2793 .oi_owner = XFS_RMAP_OWN_LOG,
2794};
2795const struct xfs_owner_info XFS_RMAP_OINFO_AG = {
2796 .oi_owner = XFS_RMAP_OWN_AG,
2797};
2798const struct xfs_owner_info XFS_RMAP_OINFO_INOBT = {
2799 .oi_owner = XFS_RMAP_OWN_INOBT,
2800};
2801const struct xfs_owner_info XFS_RMAP_OINFO_INODES = {
2802 .oi_owner = XFS_RMAP_OWN_INODES,
2803};
2804const struct xfs_owner_info XFS_RMAP_OINFO_REFC = {
2805 .oi_owner = XFS_RMAP_OWN_REFC,
2806};
2807const struct xfs_owner_info XFS_RMAP_OINFO_COW = {
2808 .oi_owner = XFS_RMAP_OWN_COW,
2809};
2810
2811int __init
2812xfs_rmap_intent_init_cache(void)
2813{
2814 xfs_rmap_intent_cache = kmem_cache_create("xfs_rmap_intent",
2815 sizeof(struct xfs_rmap_intent),
2816 0, 0, NULL);
2817
2818 return xfs_rmap_intent_cache != NULL ? 0 : -ENOMEM;
2819}
2820
2821void
2822xfs_rmap_intent_destroy_cache(void)
2823{
2824 kmem_cache_destroy(xfs_rmap_intent_cache);
2825 xfs_rmap_intent_cache = NULL;
2826}
1/*
2 * Copyright (c) 2014 Red Hat, Inc.
3 * All Rights Reserved.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18#include "xfs.h"
19#include "xfs_fs.h"
20#include "xfs_shared.h"
21#include "xfs_format.h"
22#include "xfs_log_format.h"
23#include "xfs_trans_resv.h"
24#include "xfs_bit.h"
25#include "xfs_sb.h"
26#include "xfs_mount.h"
27#include "xfs_defer.h"
28#include "xfs_da_format.h"
29#include "xfs_da_btree.h"
30#include "xfs_btree.h"
31#include "xfs_trans.h"
32#include "xfs_alloc.h"
33#include "xfs_rmap.h"
34#include "xfs_rmap_btree.h"
35#include "xfs_trans_space.h"
36#include "xfs_trace.h"
37#include "xfs_error.h"
38#include "xfs_extent_busy.h"
39#include "xfs_bmap.h"
40#include "xfs_inode.h"
41
42/*
43 * Lookup the first record less than or equal to [bno, len, owner, offset]
44 * in the btree given by cur.
45 */
46int
47xfs_rmap_lookup_le(
48 struct xfs_btree_cur *cur,
49 xfs_agblock_t bno,
50 xfs_extlen_t len,
51 uint64_t owner,
52 uint64_t offset,
53 unsigned int flags,
54 int *stat)
55{
56 cur->bc_rec.r.rm_startblock = bno;
57 cur->bc_rec.r.rm_blockcount = len;
58 cur->bc_rec.r.rm_owner = owner;
59 cur->bc_rec.r.rm_offset = offset;
60 cur->bc_rec.r.rm_flags = flags;
61 return xfs_btree_lookup(cur, XFS_LOOKUP_LE, stat);
62}
63
64/*
65 * Lookup the record exactly matching [bno, len, owner, offset]
66 * in the btree given by cur.
67 */
68int
69xfs_rmap_lookup_eq(
70 struct xfs_btree_cur *cur,
71 xfs_agblock_t bno,
72 xfs_extlen_t len,
73 uint64_t owner,
74 uint64_t offset,
75 unsigned int flags,
76 int *stat)
77{
78 cur->bc_rec.r.rm_startblock = bno;
79 cur->bc_rec.r.rm_blockcount = len;
80 cur->bc_rec.r.rm_owner = owner;
81 cur->bc_rec.r.rm_offset = offset;
82 cur->bc_rec.r.rm_flags = flags;
83 return xfs_btree_lookup(cur, XFS_LOOKUP_EQ, stat);
84}
85
86/*
87 * Update the record referred to by cur to the value given
88 * by [bno, len, owner, offset].
89 * This either works (return 0) or gets an EFSCORRUPTED error.
90 */
91STATIC int
92xfs_rmap_update(
93 struct xfs_btree_cur *cur,
94 struct xfs_rmap_irec *irec)
95{
96 union xfs_btree_rec rec;
97 int error;
98
99 trace_xfs_rmap_update(cur->bc_mp, cur->bc_private.a.agno,
100 irec->rm_startblock, irec->rm_blockcount,
101 irec->rm_owner, irec->rm_offset, irec->rm_flags);
102
103 rec.rmap.rm_startblock = cpu_to_be32(irec->rm_startblock);
104 rec.rmap.rm_blockcount = cpu_to_be32(irec->rm_blockcount);
105 rec.rmap.rm_owner = cpu_to_be64(irec->rm_owner);
106 rec.rmap.rm_offset = cpu_to_be64(
107 xfs_rmap_irec_offset_pack(irec));
108 error = xfs_btree_update(cur, &rec);
109 if (error)
110 trace_xfs_rmap_update_error(cur->bc_mp,
111 cur->bc_private.a.agno, error, _RET_IP_);
112 return error;
113}
114
115int
116xfs_rmap_insert(
117 struct xfs_btree_cur *rcur,
118 xfs_agblock_t agbno,
119 xfs_extlen_t len,
120 uint64_t owner,
121 uint64_t offset,
122 unsigned int flags)
123{
124 int i;
125 int error;
126
127 trace_xfs_rmap_insert(rcur->bc_mp, rcur->bc_private.a.agno, agbno,
128 len, owner, offset, flags);
129
130 error = xfs_rmap_lookup_eq(rcur, agbno, len, owner, offset, flags, &i);
131 if (error)
132 goto done;
133 XFS_WANT_CORRUPTED_GOTO(rcur->bc_mp, i == 0, done);
134
135 rcur->bc_rec.r.rm_startblock = agbno;
136 rcur->bc_rec.r.rm_blockcount = len;
137 rcur->bc_rec.r.rm_owner = owner;
138 rcur->bc_rec.r.rm_offset = offset;
139 rcur->bc_rec.r.rm_flags = flags;
140 error = xfs_btree_insert(rcur, &i);
141 if (error)
142 goto done;
143 XFS_WANT_CORRUPTED_GOTO(rcur->bc_mp, i == 1, done);
144done:
145 if (error)
146 trace_xfs_rmap_insert_error(rcur->bc_mp,
147 rcur->bc_private.a.agno, error, _RET_IP_);
148 return error;
149}
150
151STATIC int
152xfs_rmap_delete(
153 struct xfs_btree_cur *rcur,
154 xfs_agblock_t agbno,
155 xfs_extlen_t len,
156 uint64_t owner,
157 uint64_t offset,
158 unsigned int flags)
159{
160 int i;
161 int error;
162
163 trace_xfs_rmap_delete(rcur->bc_mp, rcur->bc_private.a.agno, agbno,
164 len, owner, offset, flags);
165
166 error = xfs_rmap_lookup_eq(rcur, agbno, len, owner, offset, flags, &i);
167 if (error)
168 goto done;
169 XFS_WANT_CORRUPTED_GOTO(rcur->bc_mp, i == 1, done);
170
171 error = xfs_btree_delete(rcur, &i);
172 if (error)
173 goto done;
174 XFS_WANT_CORRUPTED_GOTO(rcur->bc_mp, i == 1, done);
175done:
176 if (error)
177 trace_xfs_rmap_delete_error(rcur->bc_mp,
178 rcur->bc_private.a.agno, error, _RET_IP_);
179 return error;
180}
181
182static int
183xfs_rmap_btrec_to_irec(
184 union xfs_btree_rec *rec,
185 struct xfs_rmap_irec *irec)
186{
187 irec->rm_flags = 0;
188 irec->rm_startblock = be32_to_cpu(rec->rmap.rm_startblock);
189 irec->rm_blockcount = be32_to_cpu(rec->rmap.rm_blockcount);
190 irec->rm_owner = be64_to_cpu(rec->rmap.rm_owner);
191 return xfs_rmap_irec_offset_unpack(be64_to_cpu(rec->rmap.rm_offset),
192 irec);
193}
194
195/*
196 * Get the data from the pointed-to record.
197 */
198int
199xfs_rmap_get_rec(
200 struct xfs_btree_cur *cur,
201 struct xfs_rmap_irec *irec,
202 int *stat)
203{
204 union xfs_btree_rec *rec;
205 int error;
206
207 error = xfs_btree_get_rec(cur, &rec, stat);
208 if (error || !*stat)
209 return error;
210
211 return xfs_rmap_btrec_to_irec(rec, irec);
212}
213
214struct xfs_find_left_neighbor_info {
215 struct xfs_rmap_irec high;
216 struct xfs_rmap_irec *irec;
217 int *stat;
218};
219
220/* For each rmap given, figure out if it matches the key we want. */
221STATIC int
222xfs_rmap_find_left_neighbor_helper(
223 struct xfs_btree_cur *cur,
224 struct xfs_rmap_irec *rec,
225 void *priv)
226{
227 struct xfs_find_left_neighbor_info *info = priv;
228
229 trace_xfs_rmap_find_left_neighbor_candidate(cur->bc_mp,
230 cur->bc_private.a.agno, rec->rm_startblock,
231 rec->rm_blockcount, rec->rm_owner, rec->rm_offset,
232 rec->rm_flags);
233
234 if (rec->rm_owner != info->high.rm_owner)
235 return XFS_BTREE_QUERY_RANGE_CONTINUE;
236 if (!XFS_RMAP_NON_INODE_OWNER(rec->rm_owner) &&
237 !(rec->rm_flags & XFS_RMAP_BMBT_BLOCK) &&
238 rec->rm_offset + rec->rm_blockcount - 1 != info->high.rm_offset)
239 return XFS_BTREE_QUERY_RANGE_CONTINUE;
240
241 *info->irec = *rec;
242 *info->stat = 1;
243 return XFS_BTREE_QUERY_RANGE_ABORT;
244}
245
246/*
247 * Find the record to the left of the given extent, being careful only to
248 * return a match with the same owner and adjacent physical and logical
249 * block ranges.
250 */
251int
252xfs_rmap_find_left_neighbor(
253 struct xfs_btree_cur *cur,
254 xfs_agblock_t bno,
255 uint64_t owner,
256 uint64_t offset,
257 unsigned int flags,
258 struct xfs_rmap_irec *irec,
259 int *stat)
260{
261 struct xfs_find_left_neighbor_info info;
262 int error;
263
264 *stat = 0;
265 if (bno == 0)
266 return 0;
267 info.high.rm_startblock = bno - 1;
268 info.high.rm_owner = owner;
269 if (!XFS_RMAP_NON_INODE_OWNER(owner) &&
270 !(flags & XFS_RMAP_BMBT_BLOCK)) {
271 if (offset == 0)
272 return 0;
273 info.high.rm_offset = offset - 1;
274 } else
275 info.high.rm_offset = 0;
276 info.high.rm_flags = flags;
277 info.high.rm_blockcount = 0;
278 info.irec = irec;
279 info.stat = stat;
280
281 trace_xfs_rmap_find_left_neighbor_query(cur->bc_mp,
282 cur->bc_private.a.agno, bno, 0, owner, offset, flags);
283
284 error = xfs_rmap_query_range(cur, &info.high, &info.high,
285 xfs_rmap_find_left_neighbor_helper, &info);
286 if (error == XFS_BTREE_QUERY_RANGE_ABORT)
287 error = 0;
288 if (*stat)
289 trace_xfs_rmap_find_left_neighbor_result(cur->bc_mp,
290 cur->bc_private.a.agno, irec->rm_startblock,
291 irec->rm_blockcount, irec->rm_owner,
292 irec->rm_offset, irec->rm_flags);
293 return error;
294}
295
296/* For each rmap given, figure out if it matches the key we want. */
297STATIC int
298xfs_rmap_lookup_le_range_helper(
299 struct xfs_btree_cur *cur,
300 struct xfs_rmap_irec *rec,
301 void *priv)
302{
303 struct xfs_find_left_neighbor_info *info = priv;
304
305 trace_xfs_rmap_lookup_le_range_candidate(cur->bc_mp,
306 cur->bc_private.a.agno, rec->rm_startblock,
307 rec->rm_blockcount, rec->rm_owner, rec->rm_offset,
308 rec->rm_flags);
309
310 if (rec->rm_owner != info->high.rm_owner)
311 return XFS_BTREE_QUERY_RANGE_CONTINUE;
312 if (!XFS_RMAP_NON_INODE_OWNER(rec->rm_owner) &&
313 !(rec->rm_flags & XFS_RMAP_BMBT_BLOCK) &&
314 (rec->rm_offset > info->high.rm_offset ||
315 rec->rm_offset + rec->rm_blockcount <= info->high.rm_offset))
316 return XFS_BTREE_QUERY_RANGE_CONTINUE;
317
318 *info->irec = *rec;
319 *info->stat = 1;
320 return XFS_BTREE_QUERY_RANGE_ABORT;
321}
322
323/*
324 * Find the record to the left of the given extent, being careful only to
325 * return a match with the same owner and overlapping physical and logical
326 * block ranges. This is the overlapping-interval version of
327 * xfs_rmap_lookup_le.
328 */
329int
330xfs_rmap_lookup_le_range(
331 struct xfs_btree_cur *cur,
332 xfs_agblock_t bno,
333 uint64_t owner,
334 uint64_t offset,
335 unsigned int flags,
336 struct xfs_rmap_irec *irec,
337 int *stat)
338{
339 struct xfs_find_left_neighbor_info info;
340 int error;
341
342 info.high.rm_startblock = bno;
343 info.high.rm_owner = owner;
344 if (!XFS_RMAP_NON_INODE_OWNER(owner) && !(flags & XFS_RMAP_BMBT_BLOCK))
345 info.high.rm_offset = offset;
346 else
347 info.high.rm_offset = 0;
348 info.high.rm_flags = flags;
349 info.high.rm_blockcount = 0;
350 *stat = 0;
351 info.irec = irec;
352 info.stat = stat;
353
354 trace_xfs_rmap_lookup_le_range(cur->bc_mp,
355 cur->bc_private.a.agno, bno, 0, owner, offset, flags);
356 error = xfs_rmap_query_range(cur, &info.high, &info.high,
357 xfs_rmap_lookup_le_range_helper, &info);
358 if (error == XFS_BTREE_QUERY_RANGE_ABORT)
359 error = 0;
360 if (*stat)
361 trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,
362 cur->bc_private.a.agno, irec->rm_startblock,
363 irec->rm_blockcount, irec->rm_owner,
364 irec->rm_offset, irec->rm_flags);
365 return error;
366}
367
368/*
369 * Find the extent in the rmap btree and remove it.
370 *
371 * The record we find should always be an exact match for the extent that we're
372 * looking for, since we insert them into the btree without modification.
373 *
374 * Special Case #1: when growing the filesystem, we "free" an extent when
375 * growing the last AG. This extent is new space and so it is not tracked as
376 * used space in the btree. The growfs code will pass in an owner of
377 * XFS_RMAP_OWN_NULL to indicate that it expected that there is no owner of this
378 * extent. We verify that - the extent lookup result in a record that does not
379 * overlap.
380 *
381 * Special Case #2: EFIs do not record the owner of the extent, so when
382 * recovering EFIs from the log we pass in XFS_RMAP_OWN_UNKNOWN to tell the rmap
383 * btree to ignore the owner (i.e. wildcard match) so we don't trigger
384 * corruption checks during log recovery.
385 */
386STATIC int
387xfs_rmap_unmap(
388 struct xfs_btree_cur *cur,
389 xfs_agblock_t bno,
390 xfs_extlen_t len,
391 bool unwritten,
392 struct xfs_owner_info *oinfo)
393{
394 struct xfs_mount *mp = cur->bc_mp;
395 struct xfs_rmap_irec ltrec;
396 uint64_t ltoff;
397 int error = 0;
398 int i;
399 uint64_t owner;
400 uint64_t offset;
401 unsigned int flags;
402 bool ignore_off;
403
404 xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
405 ignore_off = XFS_RMAP_NON_INODE_OWNER(owner) ||
406 (flags & XFS_RMAP_BMBT_BLOCK);
407 if (unwritten)
408 flags |= XFS_RMAP_UNWRITTEN;
409 trace_xfs_rmap_unmap(mp, cur->bc_private.a.agno, bno, len,
410 unwritten, oinfo);
411
412 /*
413 * We should always have a left record because there's a static record
414 * for the AG headers at rm_startblock == 0 created by mkfs/growfs that
415 * will not ever be removed from the tree.
416 */
417 error = xfs_rmap_lookup_le(cur, bno, len, owner, offset, flags, &i);
418 if (error)
419 goto out_error;
420 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
421
422 error = xfs_rmap_get_rec(cur, <rec, &i);
423 if (error)
424 goto out_error;
425 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
426 trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,
427 cur->bc_private.a.agno, ltrec.rm_startblock,
428 ltrec.rm_blockcount, ltrec.rm_owner,
429 ltrec.rm_offset, ltrec.rm_flags);
430 ltoff = ltrec.rm_offset;
431
432 /*
433 * For growfs, the incoming extent must be beyond the left record we
434 * just found as it is new space and won't be used by anyone. This is
435 * just a corruption check as we don't actually do anything with this
436 * extent. Note that we need to use >= instead of > because it might
437 * be the case that the "left" extent goes all the way to EOFS.
438 */
439 if (owner == XFS_RMAP_OWN_NULL) {
440 XFS_WANT_CORRUPTED_GOTO(mp, bno >= ltrec.rm_startblock +
441 ltrec.rm_blockcount, out_error);
442 goto out_done;
443 }
444
445 /* Make sure the unwritten flag matches. */
446 XFS_WANT_CORRUPTED_GOTO(mp, (flags & XFS_RMAP_UNWRITTEN) ==
447 (ltrec.rm_flags & XFS_RMAP_UNWRITTEN), out_error);
448
449 /* Make sure the extent we found covers the entire freeing range. */
450 XFS_WANT_CORRUPTED_GOTO(mp, ltrec.rm_startblock <= bno &&
451 ltrec.rm_startblock + ltrec.rm_blockcount >=
452 bno + len, out_error);
453
454 /* Make sure the owner matches what we expect to find in the tree. */
455 XFS_WANT_CORRUPTED_GOTO(mp, owner == ltrec.rm_owner ||
456 XFS_RMAP_NON_INODE_OWNER(owner), out_error);
457
458 /* Check the offset, if necessary. */
459 if (!XFS_RMAP_NON_INODE_OWNER(owner)) {
460 if (flags & XFS_RMAP_BMBT_BLOCK) {
461 XFS_WANT_CORRUPTED_GOTO(mp,
462 ltrec.rm_flags & XFS_RMAP_BMBT_BLOCK,
463 out_error);
464 } else {
465 XFS_WANT_CORRUPTED_GOTO(mp,
466 ltrec.rm_offset <= offset, out_error);
467 XFS_WANT_CORRUPTED_GOTO(mp,
468 ltoff + ltrec.rm_blockcount >= offset + len,
469 out_error);
470 }
471 }
472
473 if (ltrec.rm_startblock == bno && ltrec.rm_blockcount == len) {
474 /* exact match, simply remove the record from rmap tree */
475 trace_xfs_rmap_delete(mp, cur->bc_private.a.agno,
476 ltrec.rm_startblock, ltrec.rm_blockcount,
477 ltrec.rm_owner, ltrec.rm_offset,
478 ltrec.rm_flags);
479 error = xfs_btree_delete(cur, &i);
480 if (error)
481 goto out_error;
482 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
483 } else if (ltrec.rm_startblock == bno) {
484 /*
485 * overlap left hand side of extent: move the start, trim the
486 * length and update the current record.
487 *
488 * ltbno ltlen
489 * Orig: |oooooooooooooooooooo|
490 * Freeing: |fffffffff|
491 * Result: |rrrrrrrrrr|
492 * bno len
493 */
494 ltrec.rm_startblock += len;
495 ltrec.rm_blockcount -= len;
496 if (!ignore_off)
497 ltrec.rm_offset += len;
498 error = xfs_rmap_update(cur, <rec);
499 if (error)
500 goto out_error;
501 } else if (ltrec.rm_startblock + ltrec.rm_blockcount == bno + len) {
502 /*
503 * overlap right hand side of extent: trim the length and update
504 * the current record.
505 *
506 * ltbno ltlen
507 * Orig: |oooooooooooooooooooo|
508 * Freeing: |fffffffff|
509 * Result: |rrrrrrrrrr|
510 * bno len
511 */
512 ltrec.rm_blockcount -= len;
513 error = xfs_rmap_update(cur, <rec);
514 if (error)
515 goto out_error;
516 } else {
517
518 /*
519 * overlap middle of extent: trim the length of the existing
520 * record to the length of the new left-extent size, increment
521 * the insertion position so we can insert a new record
522 * containing the remaining right-extent space.
523 *
524 * ltbno ltlen
525 * Orig: |oooooooooooooooooooo|
526 * Freeing: |fffffffff|
527 * Result: |rrrrr| |rrrr|
528 * bno len
529 */
530 xfs_extlen_t orig_len = ltrec.rm_blockcount;
531
532 ltrec.rm_blockcount = bno - ltrec.rm_startblock;
533 error = xfs_rmap_update(cur, <rec);
534 if (error)
535 goto out_error;
536
537 error = xfs_btree_increment(cur, 0, &i);
538 if (error)
539 goto out_error;
540
541 cur->bc_rec.r.rm_startblock = bno + len;
542 cur->bc_rec.r.rm_blockcount = orig_len - len -
543 ltrec.rm_blockcount;
544 cur->bc_rec.r.rm_owner = ltrec.rm_owner;
545 if (ignore_off)
546 cur->bc_rec.r.rm_offset = 0;
547 else
548 cur->bc_rec.r.rm_offset = offset + len;
549 cur->bc_rec.r.rm_flags = flags;
550 trace_xfs_rmap_insert(mp, cur->bc_private.a.agno,
551 cur->bc_rec.r.rm_startblock,
552 cur->bc_rec.r.rm_blockcount,
553 cur->bc_rec.r.rm_owner,
554 cur->bc_rec.r.rm_offset,
555 cur->bc_rec.r.rm_flags);
556 error = xfs_btree_insert(cur, &i);
557 if (error)
558 goto out_error;
559 }
560
561out_done:
562 trace_xfs_rmap_unmap_done(mp, cur->bc_private.a.agno, bno, len,
563 unwritten, oinfo);
564out_error:
565 if (error)
566 trace_xfs_rmap_unmap_error(mp, cur->bc_private.a.agno,
567 error, _RET_IP_);
568 return error;
569}
570
571/*
572 * Remove a reference to an extent in the rmap btree.
573 */
574int
575xfs_rmap_free(
576 struct xfs_trans *tp,
577 struct xfs_buf *agbp,
578 xfs_agnumber_t agno,
579 xfs_agblock_t bno,
580 xfs_extlen_t len,
581 struct xfs_owner_info *oinfo)
582{
583 struct xfs_mount *mp = tp->t_mountp;
584 struct xfs_btree_cur *cur;
585 int error;
586
587 if (!xfs_sb_version_hasrmapbt(&mp->m_sb))
588 return 0;
589
590 cur = xfs_rmapbt_init_cursor(mp, tp, agbp, agno);
591
592 error = xfs_rmap_unmap(cur, bno, len, false, oinfo);
593 if (error)
594 goto out_error;
595
596 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
597 return 0;
598
599out_error:
600 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
601 return error;
602}
603
604/*
605 * A mergeable rmap must have the same owner and the same values for
606 * the unwritten, attr_fork, and bmbt flags. The startblock and
607 * offset are checked separately.
608 */
609static bool
610xfs_rmap_is_mergeable(
611 struct xfs_rmap_irec *irec,
612 uint64_t owner,
613 unsigned int flags)
614{
615 if (irec->rm_owner == XFS_RMAP_OWN_NULL)
616 return false;
617 if (irec->rm_owner != owner)
618 return false;
619 if ((flags & XFS_RMAP_UNWRITTEN) ^
620 (irec->rm_flags & XFS_RMAP_UNWRITTEN))
621 return false;
622 if ((flags & XFS_RMAP_ATTR_FORK) ^
623 (irec->rm_flags & XFS_RMAP_ATTR_FORK))
624 return false;
625 if ((flags & XFS_RMAP_BMBT_BLOCK) ^
626 (irec->rm_flags & XFS_RMAP_BMBT_BLOCK))
627 return false;
628 return true;
629}
630
631/*
632 * When we allocate a new block, the first thing we do is add a reference to
633 * the extent in the rmap btree. This takes the form of a [agbno, length,
634 * owner, offset] record. Flags are encoded in the high bits of the offset
635 * field.
636 */
637STATIC int
638xfs_rmap_map(
639 struct xfs_btree_cur *cur,
640 xfs_agblock_t bno,
641 xfs_extlen_t len,
642 bool unwritten,
643 struct xfs_owner_info *oinfo)
644{
645 struct xfs_mount *mp = cur->bc_mp;
646 struct xfs_rmap_irec ltrec;
647 struct xfs_rmap_irec gtrec;
648 int have_gt;
649 int have_lt;
650 int error = 0;
651 int i;
652 uint64_t owner;
653 uint64_t offset;
654 unsigned int flags = 0;
655 bool ignore_off;
656
657 xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
658 ASSERT(owner != 0);
659 ignore_off = XFS_RMAP_NON_INODE_OWNER(owner) ||
660 (flags & XFS_RMAP_BMBT_BLOCK);
661 if (unwritten)
662 flags |= XFS_RMAP_UNWRITTEN;
663 trace_xfs_rmap_map(mp, cur->bc_private.a.agno, bno, len,
664 unwritten, oinfo);
665
666 /*
667 * For the initial lookup, look for an exact match or the left-adjacent
668 * record for our insertion point. This will also give us the record for
669 * start block contiguity tests.
670 */
671 error = xfs_rmap_lookup_le(cur, bno, len, owner, offset, flags,
672 &have_lt);
673 if (error)
674 goto out_error;
675 XFS_WANT_CORRUPTED_GOTO(mp, have_lt == 1, out_error);
676
677 error = xfs_rmap_get_rec(cur, <rec, &have_lt);
678 if (error)
679 goto out_error;
680 XFS_WANT_CORRUPTED_GOTO(mp, have_lt == 1, out_error);
681 trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,
682 cur->bc_private.a.agno, ltrec.rm_startblock,
683 ltrec.rm_blockcount, ltrec.rm_owner,
684 ltrec.rm_offset, ltrec.rm_flags);
685
686 if (!xfs_rmap_is_mergeable(<rec, owner, flags))
687 have_lt = 0;
688
689 XFS_WANT_CORRUPTED_GOTO(mp,
690 have_lt == 0 ||
691 ltrec.rm_startblock + ltrec.rm_blockcount <= bno, out_error);
692
693 /*
694 * Increment the cursor to see if we have a right-adjacent record to our
695 * insertion point. This will give us the record for end block
696 * contiguity tests.
697 */
698 error = xfs_btree_increment(cur, 0, &have_gt);
699 if (error)
700 goto out_error;
701 if (have_gt) {
702 error = xfs_rmap_get_rec(cur, >rec, &have_gt);
703 if (error)
704 goto out_error;
705 XFS_WANT_CORRUPTED_GOTO(mp, have_gt == 1, out_error);
706 XFS_WANT_CORRUPTED_GOTO(mp, bno + len <= gtrec.rm_startblock,
707 out_error);
708 trace_xfs_rmap_find_right_neighbor_result(cur->bc_mp,
709 cur->bc_private.a.agno, gtrec.rm_startblock,
710 gtrec.rm_blockcount, gtrec.rm_owner,
711 gtrec.rm_offset, gtrec.rm_flags);
712 if (!xfs_rmap_is_mergeable(>rec, owner, flags))
713 have_gt = 0;
714 }
715
716 /*
717 * Note: cursor currently points one record to the right of ltrec, even
718 * if there is no record in the tree to the right.
719 */
720 if (have_lt &&
721 ltrec.rm_startblock + ltrec.rm_blockcount == bno &&
722 (ignore_off || ltrec.rm_offset + ltrec.rm_blockcount == offset)) {
723 /*
724 * left edge contiguous, merge into left record.
725 *
726 * ltbno ltlen
727 * orig: |ooooooooo|
728 * adding: |aaaaaaaaa|
729 * result: |rrrrrrrrrrrrrrrrrrr|
730 * bno len
731 */
732 ltrec.rm_blockcount += len;
733 if (have_gt &&
734 bno + len == gtrec.rm_startblock &&
735 (ignore_off || offset + len == gtrec.rm_offset) &&
736 (unsigned long)ltrec.rm_blockcount + len +
737 gtrec.rm_blockcount <= XFS_RMAP_LEN_MAX) {
738 /*
739 * right edge also contiguous, delete right record
740 * and merge into left record.
741 *
742 * ltbno ltlen gtbno gtlen
743 * orig: |ooooooooo| |ooooooooo|
744 * adding: |aaaaaaaaa|
745 * result: |rrrrrrrrrrrrrrrrrrrrrrrrrrrrr|
746 */
747 ltrec.rm_blockcount += gtrec.rm_blockcount;
748 trace_xfs_rmap_delete(mp, cur->bc_private.a.agno,
749 gtrec.rm_startblock,
750 gtrec.rm_blockcount,
751 gtrec.rm_owner,
752 gtrec.rm_offset,
753 gtrec.rm_flags);
754 error = xfs_btree_delete(cur, &i);
755 if (error)
756 goto out_error;
757 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
758 }
759
760 /* point the cursor back to the left record and update */
761 error = xfs_btree_decrement(cur, 0, &have_gt);
762 if (error)
763 goto out_error;
764 error = xfs_rmap_update(cur, <rec);
765 if (error)
766 goto out_error;
767 } else if (have_gt &&
768 bno + len == gtrec.rm_startblock &&
769 (ignore_off || offset + len == gtrec.rm_offset)) {
770 /*
771 * right edge contiguous, merge into right record.
772 *
773 * gtbno gtlen
774 * Orig: |ooooooooo|
775 * adding: |aaaaaaaaa|
776 * Result: |rrrrrrrrrrrrrrrrrrr|
777 * bno len
778 */
779 gtrec.rm_startblock = bno;
780 gtrec.rm_blockcount += len;
781 if (!ignore_off)
782 gtrec.rm_offset = offset;
783 error = xfs_rmap_update(cur, >rec);
784 if (error)
785 goto out_error;
786 } else {
787 /*
788 * no contiguous edge with identical owner, insert
789 * new record at current cursor position.
790 */
791 cur->bc_rec.r.rm_startblock = bno;
792 cur->bc_rec.r.rm_blockcount = len;
793 cur->bc_rec.r.rm_owner = owner;
794 cur->bc_rec.r.rm_offset = offset;
795 cur->bc_rec.r.rm_flags = flags;
796 trace_xfs_rmap_insert(mp, cur->bc_private.a.agno, bno, len,
797 owner, offset, flags);
798 error = xfs_btree_insert(cur, &i);
799 if (error)
800 goto out_error;
801 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
802 }
803
804 trace_xfs_rmap_map_done(mp, cur->bc_private.a.agno, bno, len,
805 unwritten, oinfo);
806out_error:
807 if (error)
808 trace_xfs_rmap_map_error(mp, cur->bc_private.a.agno,
809 error, _RET_IP_);
810 return error;
811}
812
813/*
814 * Add a reference to an extent in the rmap btree.
815 */
816int
817xfs_rmap_alloc(
818 struct xfs_trans *tp,
819 struct xfs_buf *agbp,
820 xfs_agnumber_t agno,
821 xfs_agblock_t bno,
822 xfs_extlen_t len,
823 struct xfs_owner_info *oinfo)
824{
825 struct xfs_mount *mp = tp->t_mountp;
826 struct xfs_btree_cur *cur;
827 int error;
828
829 if (!xfs_sb_version_hasrmapbt(&mp->m_sb))
830 return 0;
831
832 cur = xfs_rmapbt_init_cursor(mp, tp, agbp, agno);
833 error = xfs_rmap_map(cur, bno, len, false, oinfo);
834 if (error)
835 goto out_error;
836
837 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
838 return 0;
839
840out_error:
841 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
842 return error;
843}
844
845#define RMAP_LEFT_CONTIG (1 << 0)
846#define RMAP_RIGHT_CONTIG (1 << 1)
847#define RMAP_LEFT_FILLING (1 << 2)
848#define RMAP_RIGHT_FILLING (1 << 3)
849#define RMAP_LEFT_VALID (1 << 6)
850#define RMAP_RIGHT_VALID (1 << 7)
851
852#define LEFT r[0]
853#define RIGHT r[1]
854#define PREV r[2]
855#define NEW r[3]
856
857/*
858 * Convert an unwritten extent to a real extent or vice versa.
859 * Does not handle overlapping extents.
860 */
861STATIC int
862xfs_rmap_convert(
863 struct xfs_btree_cur *cur,
864 xfs_agblock_t bno,
865 xfs_extlen_t len,
866 bool unwritten,
867 struct xfs_owner_info *oinfo)
868{
869 struct xfs_mount *mp = cur->bc_mp;
870 struct xfs_rmap_irec r[4]; /* neighbor extent entries */
871 /* left is 0, right is 1, prev is 2 */
872 /* new is 3 */
873 uint64_t owner;
874 uint64_t offset;
875 uint64_t new_endoff;
876 unsigned int oldext;
877 unsigned int newext;
878 unsigned int flags = 0;
879 int i;
880 int state = 0;
881 int error;
882
883 xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
884 ASSERT(!(XFS_RMAP_NON_INODE_OWNER(owner) ||
885 (flags & (XFS_RMAP_ATTR_FORK | XFS_RMAP_BMBT_BLOCK))));
886 oldext = unwritten ? XFS_RMAP_UNWRITTEN : 0;
887 new_endoff = offset + len;
888 trace_xfs_rmap_convert(mp, cur->bc_private.a.agno, bno, len,
889 unwritten, oinfo);
890
891 /*
892 * For the initial lookup, look for an exact match or the left-adjacent
893 * record for our insertion point. This will also give us the record for
894 * start block contiguity tests.
895 */
896 error = xfs_rmap_lookup_le(cur, bno, len, owner, offset, oldext, &i);
897 if (error)
898 goto done;
899 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
900
901 error = xfs_rmap_get_rec(cur, &PREV, &i);
902 if (error)
903 goto done;
904 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
905 trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,
906 cur->bc_private.a.agno, PREV.rm_startblock,
907 PREV.rm_blockcount, PREV.rm_owner,
908 PREV.rm_offset, PREV.rm_flags);
909
910 ASSERT(PREV.rm_offset <= offset);
911 ASSERT(PREV.rm_offset + PREV.rm_blockcount >= new_endoff);
912 ASSERT((PREV.rm_flags & XFS_RMAP_UNWRITTEN) == oldext);
913 newext = ~oldext & XFS_RMAP_UNWRITTEN;
914
915 /*
916 * Set flags determining what part of the previous oldext allocation
917 * extent is being replaced by a newext allocation.
918 */
919 if (PREV.rm_offset == offset)
920 state |= RMAP_LEFT_FILLING;
921 if (PREV.rm_offset + PREV.rm_blockcount == new_endoff)
922 state |= RMAP_RIGHT_FILLING;
923
924 /*
925 * Decrement the cursor to see if we have a left-adjacent record to our
926 * insertion point. This will give us the record for end block
927 * contiguity tests.
928 */
929 error = xfs_btree_decrement(cur, 0, &i);
930 if (error)
931 goto done;
932 if (i) {
933 state |= RMAP_LEFT_VALID;
934 error = xfs_rmap_get_rec(cur, &LEFT, &i);
935 if (error)
936 goto done;
937 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
938 XFS_WANT_CORRUPTED_GOTO(mp,
939 LEFT.rm_startblock + LEFT.rm_blockcount <= bno,
940 done);
941 trace_xfs_rmap_find_left_neighbor_result(cur->bc_mp,
942 cur->bc_private.a.agno, LEFT.rm_startblock,
943 LEFT.rm_blockcount, LEFT.rm_owner,
944 LEFT.rm_offset, LEFT.rm_flags);
945 if (LEFT.rm_startblock + LEFT.rm_blockcount == bno &&
946 LEFT.rm_offset + LEFT.rm_blockcount == offset &&
947 xfs_rmap_is_mergeable(&LEFT, owner, newext))
948 state |= RMAP_LEFT_CONTIG;
949 }
950
951 /*
952 * Increment the cursor to see if we have a right-adjacent record to our
953 * insertion point. This will give us the record for end block
954 * contiguity tests.
955 */
956 error = xfs_btree_increment(cur, 0, &i);
957 if (error)
958 goto done;
959 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
960 error = xfs_btree_increment(cur, 0, &i);
961 if (error)
962 goto done;
963 if (i) {
964 state |= RMAP_RIGHT_VALID;
965 error = xfs_rmap_get_rec(cur, &RIGHT, &i);
966 if (error)
967 goto done;
968 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
969 XFS_WANT_CORRUPTED_GOTO(mp, bno + len <= RIGHT.rm_startblock,
970 done);
971 trace_xfs_rmap_find_right_neighbor_result(cur->bc_mp,
972 cur->bc_private.a.agno, RIGHT.rm_startblock,
973 RIGHT.rm_blockcount, RIGHT.rm_owner,
974 RIGHT.rm_offset, RIGHT.rm_flags);
975 if (bno + len == RIGHT.rm_startblock &&
976 offset + len == RIGHT.rm_offset &&
977 xfs_rmap_is_mergeable(&RIGHT, owner, newext))
978 state |= RMAP_RIGHT_CONTIG;
979 }
980
981 /* check that left + prev + right is not too long */
982 if ((state & (RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |
983 RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG)) ==
984 (RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |
985 RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG) &&
986 (unsigned long)LEFT.rm_blockcount + len +
987 RIGHT.rm_blockcount > XFS_RMAP_LEN_MAX)
988 state &= ~RMAP_RIGHT_CONTIG;
989
990 trace_xfs_rmap_convert_state(mp, cur->bc_private.a.agno, state,
991 _RET_IP_);
992
993 /* reset the cursor back to PREV */
994 error = xfs_rmap_lookup_le(cur, bno, len, owner, offset, oldext, &i);
995 if (error)
996 goto done;
997 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
998
999 /*
1000 * Switch out based on the FILLING and CONTIG state bits.
1001 */
1002 switch (state & (RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |
1003 RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG)) {
1004 case RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |
1005 RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG:
1006 /*
1007 * Setting all of a previous oldext extent to newext.
1008 * The left and right neighbors are both contiguous with new.
1009 */
1010 error = xfs_btree_increment(cur, 0, &i);
1011 if (error)
1012 goto done;
1013 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1014 trace_xfs_rmap_delete(mp, cur->bc_private.a.agno,
1015 RIGHT.rm_startblock, RIGHT.rm_blockcount,
1016 RIGHT.rm_owner, RIGHT.rm_offset,
1017 RIGHT.rm_flags);
1018 error = xfs_btree_delete(cur, &i);
1019 if (error)
1020 goto done;
1021 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1022 error = xfs_btree_decrement(cur, 0, &i);
1023 if (error)
1024 goto done;
1025 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1026 trace_xfs_rmap_delete(mp, cur->bc_private.a.agno,
1027 PREV.rm_startblock, PREV.rm_blockcount,
1028 PREV.rm_owner, PREV.rm_offset,
1029 PREV.rm_flags);
1030 error = xfs_btree_delete(cur, &i);
1031 if (error)
1032 goto done;
1033 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1034 error = xfs_btree_decrement(cur, 0, &i);
1035 if (error)
1036 goto done;
1037 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1038 NEW = LEFT;
1039 NEW.rm_blockcount += PREV.rm_blockcount + RIGHT.rm_blockcount;
1040 error = xfs_rmap_update(cur, &NEW);
1041 if (error)
1042 goto done;
1043 break;
1044
1045 case RMAP_LEFT_FILLING | RMAP_RIGHT_FILLING | RMAP_LEFT_CONTIG:
1046 /*
1047 * Setting all of a previous oldext extent to newext.
1048 * The left neighbor is contiguous, the right is not.
1049 */
1050 trace_xfs_rmap_delete(mp, cur->bc_private.a.agno,
1051 PREV.rm_startblock, PREV.rm_blockcount,
1052 PREV.rm_owner, PREV.rm_offset,
1053 PREV.rm_flags);
1054 error = xfs_btree_delete(cur, &i);
1055 if (error)
1056 goto done;
1057 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1058 error = xfs_btree_decrement(cur, 0, &i);
1059 if (error)
1060 goto done;
1061 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1062 NEW = LEFT;
1063 NEW.rm_blockcount += PREV.rm_blockcount;
1064 error = xfs_rmap_update(cur, &NEW);
1065 if (error)
1066 goto done;
1067 break;
1068
1069 case RMAP_LEFT_FILLING | RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG:
1070 /*
1071 * Setting all of a previous oldext extent to newext.
1072 * The right neighbor is contiguous, the left is not.
1073 */
1074 error = xfs_btree_increment(cur, 0, &i);
1075 if (error)
1076 goto done;
1077 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1078 trace_xfs_rmap_delete(mp, cur->bc_private.a.agno,
1079 RIGHT.rm_startblock, RIGHT.rm_blockcount,
1080 RIGHT.rm_owner, RIGHT.rm_offset,
1081 RIGHT.rm_flags);
1082 error = xfs_btree_delete(cur, &i);
1083 if (error)
1084 goto done;
1085 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1086 error = xfs_btree_decrement(cur, 0, &i);
1087 if (error)
1088 goto done;
1089 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1090 NEW = PREV;
1091 NEW.rm_blockcount = len + RIGHT.rm_blockcount;
1092 NEW.rm_flags = newext;
1093 error = xfs_rmap_update(cur, &NEW);
1094 if (error)
1095 goto done;
1096 break;
1097
1098 case RMAP_LEFT_FILLING | RMAP_RIGHT_FILLING:
1099 /*
1100 * Setting all of a previous oldext extent to newext.
1101 * Neither the left nor right neighbors are contiguous with
1102 * the new one.
1103 */
1104 NEW = PREV;
1105 NEW.rm_flags = newext;
1106 error = xfs_rmap_update(cur, &NEW);
1107 if (error)
1108 goto done;
1109 break;
1110
1111 case RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG:
1112 /*
1113 * Setting the first part of a previous oldext extent to newext.
1114 * The left neighbor is contiguous.
1115 */
1116 NEW = PREV;
1117 NEW.rm_offset += len;
1118 NEW.rm_startblock += len;
1119 NEW.rm_blockcount -= len;
1120 error = xfs_rmap_update(cur, &NEW);
1121 if (error)
1122 goto done;
1123 error = xfs_btree_decrement(cur, 0, &i);
1124 if (error)
1125 goto done;
1126 NEW = LEFT;
1127 NEW.rm_blockcount += len;
1128 error = xfs_rmap_update(cur, &NEW);
1129 if (error)
1130 goto done;
1131 break;
1132
1133 case RMAP_LEFT_FILLING:
1134 /*
1135 * Setting the first part of a previous oldext extent to newext.
1136 * The left neighbor is not contiguous.
1137 */
1138 NEW = PREV;
1139 NEW.rm_startblock += len;
1140 NEW.rm_offset += len;
1141 NEW.rm_blockcount -= len;
1142 error = xfs_rmap_update(cur, &NEW);
1143 if (error)
1144 goto done;
1145 NEW.rm_startblock = bno;
1146 NEW.rm_owner = owner;
1147 NEW.rm_offset = offset;
1148 NEW.rm_blockcount = len;
1149 NEW.rm_flags = newext;
1150 cur->bc_rec.r = NEW;
1151 trace_xfs_rmap_insert(mp, cur->bc_private.a.agno, bno,
1152 len, owner, offset, newext);
1153 error = xfs_btree_insert(cur, &i);
1154 if (error)
1155 goto done;
1156 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1157 break;
1158
1159 case RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG:
1160 /*
1161 * Setting the last part of a previous oldext extent to newext.
1162 * The right neighbor is contiguous with the new allocation.
1163 */
1164 NEW = PREV;
1165 NEW.rm_blockcount -= len;
1166 error = xfs_rmap_update(cur, &NEW);
1167 if (error)
1168 goto done;
1169 error = xfs_btree_increment(cur, 0, &i);
1170 if (error)
1171 goto done;
1172 NEW = RIGHT;
1173 NEW.rm_offset = offset;
1174 NEW.rm_startblock = bno;
1175 NEW.rm_blockcount += len;
1176 error = xfs_rmap_update(cur, &NEW);
1177 if (error)
1178 goto done;
1179 break;
1180
1181 case RMAP_RIGHT_FILLING:
1182 /*
1183 * Setting the last part of a previous oldext extent to newext.
1184 * The right neighbor is not contiguous.
1185 */
1186 NEW = PREV;
1187 NEW.rm_blockcount -= len;
1188 error = xfs_rmap_update(cur, &NEW);
1189 if (error)
1190 goto done;
1191 error = xfs_rmap_lookup_eq(cur, bno, len, owner, offset,
1192 oldext, &i);
1193 if (error)
1194 goto done;
1195 XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done);
1196 NEW.rm_startblock = bno;
1197 NEW.rm_owner = owner;
1198 NEW.rm_offset = offset;
1199 NEW.rm_blockcount = len;
1200 NEW.rm_flags = newext;
1201 cur->bc_rec.r = NEW;
1202 trace_xfs_rmap_insert(mp, cur->bc_private.a.agno, bno,
1203 len, owner, offset, newext);
1204 error = xfs_btree_insert(cur, &i);
1205 if (error)
1206 goto done;
1207 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1208 break;
1209
1210 case 0:
1211 /*
1212 * Setting the middle part of a previous oldext extent to
1213 * newext. Contiguity is impossible here.
1214 * One extent becomes three extents.
1215 */
1216 /* new right extent - oldext */
1217 NEW.rm_startblock = bno + len;
1218 NEW.rm_owner = owner;
1219 NEW.rm_offset = new_endoff;
1220 NEW.rm_blockcount = PREV.rm_offset + PREV.rm_blockcount -
1221 new_endoff;
1222 NEW.rm_flags = PREV.rm_flags;
1223 error = xfs_rmap_update(cur, &NEW);
1224 if (error)
1225 goto done;
1226 /* new left extent - oldext */
1227 NEW = PREV;
1228 NEW.rm_blockcount = offset - PREV.rm_offset;
1229 cur->bc_rec.r = NEW;
1230 trace_xfs_rmap_insert(mp, cur->bc_private.a.agno,
1231 NEW.rm_startblock, NEW.rm_blockcount,
1232 NEW.rm_owner, NEW.rm_offset,
1233 NEW.rm_flags);
1234 error = xfs_btree_insert(cur, &i);
1235 if (error)
1236 goto done;
1237 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1238 /*
1239 * Reset the cursor to the position of the new extent
1240 * we are about to insert as we can't trust it after
1241 * the previous insert.
1242 */
1243 error = xfs_rmap_lookup_eq(cur, bno, len, owner, offset,
1244 oldext, &i);
1245 if (error)
1246 goto done;
1247 XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done);
1248 /* new middle extent - newext */
1249 cur->bc_rec.r.rm_flags &= ~XFS_RMAP_UNWRITTEN;
1250 cur->bc_rec.r.rm_flags |= newext;
1251 trace_xfs_rmap_insert(mp, cur->bc_private.a.agno, bno, len,
1252 owner, offset, newext);
1253 error = xfs_btree_insert(cur, &i);
1254 if (error)
1255 goto done;
1256 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1257 break;
1258
1259 case RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG | RMAP_RIGHT_CONTIG:
1260 case RMAP_RIGHT_FILLING | RMAP_LEFT_CONTIG | RMAP_RIGHT_CONTIG:
1261 case RMAP_LEFT_FILLING | RMAP_RIGHT_CONTIG:
1262 case RMAP_RIGHT_FILLING | RMAP_LEFT_CONTIG:
1263 case RMAP_LEFT_CONTIG | RMAP_RIGHT_CONTIG:
1264 case RMAP_LEFT_CONTIG:
1265 case RMAP_RIGHT_CONTIG:
1266 /*
1267 * These cases are all impossible.
1268 */
1269 ASSERT(0);
1270 }
1271
1272 trace_xfs_rmap_convert_done(mp, cur->bc_private.a.agno, bno, len,
1273 unwritten, oinfo);
1274done:
1275 if (error)
1276 trace_xfs_rmap_convert_error(cur->bc_mp,
1277 cur->bc_private.a.agno, error, _RET_IP_);
1278 return error;
1279}
1280
1281/*
1282 * Convert an unwritten extent to a real extent or vice versa. If there is no
1283 * possibility of overlapping extents, delegate to the simpler convert
1284 * function.
1285 */
1286STATIC int
1287xfs_rmap_convert_shared(
1288 struct xfs_btree_cur *cur,
1289 xfs_agblock_t bno,
1290 xfs_extlen_t len,
1291 bool unwritten,
1292 struct xfs_owner_info *oinfo)
1293{
1294 struct xfs_mount *mp = cur->bc_mp;
1295 struct xfs_rmap_irec r[4]; /* neighbor extent entries */
1296 /* left is 0, right is 1, prev is 2 */
1297 /* new is 3 */
1298 uint64_t owner;
1299 uint64_t offset;
1300 uint64_t new_endoff;
1301 unsigned int oldext;
1302 unsigned int newext;
1303 unsigned int flags = 0;
1304 int i;
1305 int state = 0;
1306 int error;
1307
1308 xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
1309 ASSERT(!(XFS_RMAP_NON_INODE_OWNER(owner) ||
1310 (flags & (XFS_RMAP_ATTR_FORK | XFS_RMAP_BMBT_BLOCK))));
1311 oldext = unwritten ? XFS_RMAP_UNWRITTEN : 0;
1312 new_endoff = offset + len;
1313 trace_xfs_rmap_convert(mp, cur->bc_private.a.agno, bno, len,
1314 unwritten, oinfo);
1315
1316 /*
1317 * For the initial lookup, look for and exact match or the left-adjacent
1318 * record for our insertion point. This will also give us the record for
1319 * start block contiguity tests.
1320 */
1321 error = xfs_rmap_lookup_le_range(cur, bno, owner, offset, flags,
1322 &PREV, &i);
1323 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1324
1325 ASSERT(PREV.rm_offset <= offset);
1326 ASSERT(PREV.rm_offset + PREV.rm_blockcount >= new_endoff);
1327 ASSERT((PREV.rm_flags & XFS_RMAP_UNWRITTEN) == oldext);
1328 newext = ~oldext & XFS_RMAP_UNWRITTEN;
1329
1330 /*
1331 * Set flags determining what part of the previous oldext allocation
1332 * extent is being replaced by a newext allocation.
1333 */
1334 if (PREV.rm_offset == offset)
1335 state |= RMAP_LEFT_FILLING;
1336 if (PREV.rm_offset + PREV.rm_blockcount == new_endoff)
1337 state |= RMAP_RIGHT_FILLING;
1338
1339 /* Is there a left record that abuts our range? */
1340 error = xfs_rmap_find_left_neighbor(cur, bno, owner, offset, newext,
1341 &LEFT, &i);
1342 if (error)
1343 goto done;
1344 if (i) {
1345 state |= RMAP_LEFT_VALID;
1346 XFS_WANT_CORRUPTED_GOTO(mp,
1347 LEFT.rm_startblock + LEFT.rm_blockcount <= bno,
1348 done);
1349 if (xfs_rmap_is_mergeable(&LEFT, owner, newext))
1350 state |= RMAP_LEFT_CONTIG;
1351 }
1352
1353 /* Is there a right record that abuts our range? */
1354 error = xfs_rmap_lookup_eq(cur, bno + len, len, owner, offset + len,
1355 newext, &i);
1356 if (error)
1357 goto done;
1358 if (i) {
1359 state |= RMAP_RIGHT_VALID;
1360 error = xfs_rmap_get_rec(cur, &RIGHT, &i);
1361 if (error)
1362 goto done;
1363 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1364 XFS_WANT_CORRUPTED_GOTO(mp, bno + len <= RIGHT.rm_startblock,
1365 done);
1366 trace_xfs_rmap_find_right_neighbor_result(cur->bc_mp,
1367 cur->bc_private.a.agno, RIGHT.rm_startblock,
1368 RIGHT.rm_blockcount, RIGHT.rm_owner,
1369 RIGHT.rm_offset, RIGHT.rm_flags);
1370 if (xfs_rmap_is_mergeable(&RIGHT, owner, newext))
1371 state |= RMAP_RIGHT_CONTIG;
1372 }
1373
1374 /* check that left + prev + right is not too long */
1375 if ((state & (RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |
1376 RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG)) ==
1377 (RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |
1378 RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG) &&
1379 (unsigned long)LEFT.rm_blockcount + len +
1380 RIGHT.rm_blockcount > XFS_RMAP_LEN_MAX)
1381 state &= ~RMAP_RIGHT_CONTIG;
1382
1383 trace_xfs_rmap_convert_state(mp, cur->bc_private.a.agno, state,
1384 _RET_IP_);
1385 /*
1386 * Switch out based on the FILLING and CONTIG state bits.
1387 */
1388 switch (state & (RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |
1389 RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG)) {
1390 case RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |
1391 RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG:
1392 /*
1393 * Setting all of a previous oldext extent to newext.
1394 * The left and right neighbors are both contiguous with new.
1395 */
1396 error = xfs_rmap_delete(cur, RIGHT.rm_startblock,
1397 RIGHT.rm_blockcount, RIGHT.rm_owner,
1398 RIGHT.rm_offset, RIGHT.rm_flags);
1399 if (error)
1400 goto done;
1401 error = xfs_rmap_delete(cur, PREV.rm_startblock,
1402 PREV.rm_blockcount, PREV.rm_owner,
1403 PREV.rm_offset, PREV.rm_flags);
1404 if (error)
1405 goto done;
1406 NEW = LEFT;
1407 error = xfs_rmap_lookup_eq(cur, NEW.rm_startblock,
1408 NEW.rm_blockcount, NEW.rm_owner,
1409 NEW.rm_offset, NEW.rm_flags, &i);
1410 if (error)
1411 goto done;
1412 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1413 NEW.rm_blockcount += PREV.rm_blockcount + RIGHT.rm_blockcount;
1414 error = xfs_rmap_update(cur, &NEW);
1415 if (error)
1416 goto done;
1417 break;
1418
1419 case RMAP_LEFT_FILLING | RMAP_RIGHT_FILLING | RMAP_LEFT_CONTIG:
1420 /*
1421 * Setting all of a previous oldext extent to newext.
1422 * The left neighbor is contiguous, the right is not.
1423 */
1424 error = xfs_rmap_delete(cur, PREV.rm_startblock,
1425 PREV.rm_blockcount, PREV.rm_owner,
1426 PREV.rm_offset, PREV.rm_flags);
1427 if (error)
1428 goto done;
1429 NEW = LEFT;
1430 error = xfs_rmap_lookup_eq(cur, NEW.rm_startblock,
1431 NEW.rm_blockcount, NEW.rm_owner,
1432 NEW.rm_offset, NEW.rm_flags, &i);
1433 if (error)
1434 goto done;
1435 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1436 NEW.rm_blockcount += PREV.rm_blockcount;
1437 error = xfs_rmap_update(cur, &NEW);
1438 if (error)
1439 goto done;
1440 break;
1441
1442 case RMAP_LEFT_FILLING | RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG:
1443 /*
1444 * Setting all of a previous oldext extent to newext.
1445 * The right neighbor is contiguous, the left is not.
1446 */
1447 error = xfs_rmap_delete(cur, RIGHT.rm_startblock,
1448 RIGHT.rm_blockcount, RIGHT.rm_owner,
1449 RIGHT.rm_offset, RIGHT.rm_flags);
1450 if (error)
1451 goto done;
1452 NEW = PREV;
1453 error = xfs_rmap_lookup_eq(cur, NEW.rm_startblock,
1454 NEW.rm_blockcount, NEW.rm_owner,
1455 NEW.rm_offset, NEW.rm_flags, &i);
1456 if (error)
1457 goto done;
1458 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1459 NEW.rm_blockcount += RIGHT.rm_blockcount;
1460 NEW.rm_flags = RIGHT.rm_flags;
1461 error = xfs_rmap_update(cur, &NEW);
1462 if (error)
1463 goto done;
1464 break;
1465
1466 case RMAP_LEFT_FILLING | RMAP_RIGHT_FILLING:
1467 /*
1468 * Setting all of a previous oldext extent to newext.
1469 * Neither the left nor right neighbors are contiguous with
1470 * the new one.
1471 */
1472 NEW = PREV;
1473 error = xfs_rmap_lookup_eq(cur, NEW.rm_startblock,
1474 NEW.rm_blockcount, NEW.rm_owner,
1475 NEW.rm_offset, NEW.rm_flags, &i);
1476 if (error)
1477 goto done;
1478 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1479 NEW.rm_flags = newext;
1480 error = xfs_rmap_update(cur, &NEW);
1481 if (error)
1482 goto done;
1483 break;
1484
1485 case RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG:
1486 /*
1487 * Setting the first part of a previous oldext extent to newext.
1488 * The left neighbor is contiguous.
1489 */
1490 NEW = PREV;
1491 error = xfs_rmap_delete(cur, NEW.rm_startblock,
1492 NEW.rm_blockcount, NEW.rm_owner,
1493 NEW.rm_offset, NEW.rm_flags);
1494 if (error)
1495 goto done;
1496 NEW.rm_offset += len;
1497 NEW.rm_startblock += len;
1498 NEW.rm_blockcount -= len;
1499 error = xfs_rmap_insert(cur, NEW.rm_startblock,
1500 NEW.rm_blockcount, NEW.rm_owner,
1501 NEW.rm_offset, NEW.rm_flags);
1502 if (error)
1503 goto done;
1504 NEW = LEFT;
1505 error = xfs_rmap_lookup_eq(cur, NEW.rm_startblock,
1506 NEW.rm_blockcount, NEW.rm_owner,
1507 NEW.rm_offset, NEW.rm_flags, &i);
1508 if (error)
1509 goto done;
1510 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1511 NEW.rm_blockcount += len;
1512 error = xfs_rmap_update(cur, &NEW);
1513 if (error)
1514 goto done;
1515 break;
1516
1517 case RMAP_LEFT_FILLING:
1518 /*
1519 * Setting the first part of a previous oldext extent to newext.
1520 * The left neighbor is not contiguous.
1521 */
1522 NEW = PREV;
1523 error = xfs_rmap_delete(cur, NEW.rm_startblock,
1524 NEW.rm_blockcount, NEW.rm_owner,
1525 NEW.rm_offset, NEW.rm_flags);
1526 if (error)
1527 goto done;
1528 NEW.rm_offset += len;
1529 NEW.rm_startblock += len;
1530 NEW.rm_blockcount -= len;
1531 error = xfs_rmap_insert(cur, NEW.rm_startblock,
1532 NEW.rm_blockcount, NEW.rm_owner,
1533 NEW.rm_offset, NEW.rm_flags);
1534 if (error)
1535 goto done;
1536 error = xfs_rmap_insert(cur, bno, len, owner, offset, newext);
1537 if (error)
1538 goto done;
1539 break;
1540
1541 case RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG:
1542 /*
1543 * Setting the last part of a previous oldext extent to newext.
1544 * The right neighbor is contiguous with the new allocation.
1545 */
1546 NEW = PREV;
1547 error = xfs_rmap_lookup_eq(cur, NEW.rm_startblock,
1548 NEW.rm_blockcount, NEW.rm_owner,
1549 NEW.rm_offset, NEW.rm_flags, &i);
1550 if (error)
1551 goto done;
1552 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1553 NEW.rm_blockcount = offset - NEW.rm_offset;
1554 error = xfs_rmap_update(cur, &NEW);
1555 if (error)
1556 goto done;
1557 NEW = RIGHT;
1558 error = xfs_rmap_delete(cur, NEW.rm_startblock,
1559 NEW.rm_blockcount, NEW.rm_owner,
1560 NEW.rm_offset, NEW.rm_flags);
1561 if (error)
1562 goto done;
1563 NEW.rm_offset = offset;
1564 NEW.rm_startblock = bno;
1565 NEW.rm_blockcount += len;
1566 error = xfs_rmap_insert(cur, NEW.rm_startblock,
1567 NEW.rm_blockcount, NEW.rm_owner,
1568 NEW.rm_offset, NEW.rm_flags);
1569 if (error)
1570 goto done;
1571 break;
1572
1573 case RMAP_RIGHT_FILLING:
1574 /*
1575 * Setting the last part of a previous oldext extent to newext.
1576 * The right neighbor is not contiguous.
1577 */
1578 NEW = PREV;
1579 error = xfs_rmap_lookup_eq(cur, NEW.rm_startblock,
1580 NEW.rm_blockcount, NEW.rm_owner,
1581 NEW.rm_offset, NEW.rm_flags, &i);
1582 if (error)
1583 goto done;
1584 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1585 NEW.rm_blockcount -= len;
1586 error = xfs_rmap_update(cur, &NEW);
1587 if (error)
1588 goto done;
1589 error = xfs_rmap_insert(cur, bno, len, owner, offset, newext);
1590 if (error)
1591 goto done;
1592 break;
1593
1594 case 0:
1595 /*
1596 * Setting the middle part of a previous oldext extent to
1597 * newext. Contiguity is impossible here.
1598 * One extent becomes three extents.
1599 */
1600 /* new right extent - oldext */
1601 NEW.rm_startblock = bno + len;
1602 NEW.rm_owner = owner;
1603 NEW.rm_offset = new_endoff;
1604 NEW.rm_blockcount = PREV.rm_offset + PREV.rm_blockcount -
1605 new_endoff;
1606 NEW.rm_flags = PREV.rm_flags;
1607 error = xfs_rmap_insert(cur, NEW.rm_startblock,
1608 NEW.rm_blockcount, NEW.rm_owner, NEW.rm_offset,
1609 NEW.rm_flags);
1610 if (error)
1611 goto done;
1612 /* new left extent - oldext */
1613 NEW = PREV;
1614 error = xfs_rmap_lookup_eq(cur, NEW.rm_startblock,
1615 NEW.rm_blockcount, NEW.rm_owner,
1616 NEW.rm_offset, NEW.rm_flags, &i);
1617 if (error)
1618 goto done;
1619 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
1620 NEW.rm_blockcount = offset - NEW.rm_offset;
1621 error = xfs_rmap_update(cur, &NEW);
1622 if (error)
1623 goto done;
1624 /* new middle extent - newext */
1625 NEW.rm_startblock = bno;
1626 NEW.rm_blockcount = len;
1627 NEW.rm_owner = owner;
1628 NEW.rm_offset = offset;
1629 NEW.rm_flags = newext;
1630 error = xfs_rmap_insert(cur, NEW.rm_startblock,
1631 NEW.rm_blockcount, NEW.rm_owner, NEW.rm_offset,
1632 NEW.rm_flags);
1633 if (error)
1634 goto done;
1635 break;
1636
1637 case RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG | RMAP_RIGHT_CONTIG:
1638 case RMAP_RIGHT_FILLING | RMAP_LEFT_CONTIG | RMAP_RIGHT_CONTIG:
1639 case RMAP_LEFT_FILLING | RMAP_RIGHT_CONTIG:
1640 case RMAP_RIGHT_FILLING | RMAP_LEFT_CONTIG:
1641 case RMAP_LEFT_CONTIG | RMAP_RIGHT_CONTIG:
1642 case RMAP_LEFT_CONTIG:
1643 case RMAP_RIGHT_CONTIG:
1644 /*
1645 * These cases are all impossible.
1646 */
1647 ASSERT(0);
1648 }
1649
1650 trace_xfs_rmap_convert_done(mp, cur->bc_private.a.agno, bno, len,
1651 unwritten, oinfo);
1652done:
1653 if (error)
1654 trace_xfs_rmap_convert_error(cur->bc_mp,
1655 cur->bc_private.a.agno, error, _RET_IP_);
1656 return error;
1657}
1658
1659#undef NEW
1660#undef LEFT
1661#undef RIGHT
1662#undef PREV
1663
1664/*
1665 * Find an extent in the rmap btree and unmap it. For rmap extent types that
1666 * can overlap (data fork rmaps on reflink filesystems) we must be careful
1667 * that the prev/next records in the btree might belong to another owner.
1668 * Therefore we must use delete+insert to alter any of the key fields.
1669 *
1670 * For every other situation there can only be one owner for a given extent,
1671 * so we can call the regular _free function.
1672 */
1673STATIC int
1674xfs_rmap_unmap_shared(
1675 struct xfs_btree_cur *cur,
1676 xfs_agblock_t bno,
1677 xfs_extlen_t len,
1678 bool unwritten,
1679 struct xfs_owner_info *oinfo)
1680{
1681 struct xfs_mount *mp = cur->bc_mp;
1682 struct xfs_rmap_irec ltrec;
1683 uint64_t ltoff;
1684 int error = 0;
1685 int i;
1686 uint64_t owner;
1687 uint64_t offset;
1688 unsigned int flags;
1689
1690 xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
1691 if (unwritten)
1692 flags |= XFS_RMAP_UNWRITTEN;
1693 trace_xfs_rmap_unmap(mp, cur->bc_private.a.agno, bno, len,
1694 unwritten, oinfo);
1695
1696 /*
1697 * We should always have a left record because there's a static record
1698 * for the AG headers at rm_startblock == 0 created by mkfs/growfs that
1699 * will not ever be removed from the tree.
1700 */
1701 error = xfs_rmap_lookup_le_range(cur, bno, owner, offset, flags,
1702 <rec, &i);
1703 if (error)
1704 goto out_error;
1705 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
1706 ltoff = ltrec.rm_offset;
1707
1708 /* Make sure the extent we found covers the entire freeing range. */
1709 XFS_WANT_CORRUPTED_GOTO(mp, ltrec.rm_startblock <= bno &&
1710 ltrec.rm_startblock + ltrec.rm_blockcount >=
1711 bno + len, out_error);
1712
1713 /* Make sure the owner matches what we expect to find in the tree. */
1714 XFS_WANT_CORRUPTED_GOTO(mp, owner == ltrec.rm_owner, out_error);
1715
1716 /* Make sure the unwritten flag matches. */
1717 XFS_WANT_CORRUPTED_GOTO(mp, (flags & XFS_RMAP_UNWRITTEN) ==
1718 (ltrec.rm_flags & XFS_RMAP_UNWRITTEN), out_error);
1719
1720 /* Check the offset. */
1721 XFS_WANT_CORRUPTED_GOTO(mp, ltrec.rm_offset <= offset, out_error);
1722 XFS_WANT_CORRUPTED_GOTO(mp, offset <= ltoff + ltrec.rm_blockcount,
1723 out_error);
1724
1725 if (ltrec.rm_startblock == bno && ltrec.rm_blockcount == len) {
1726 /* Exact match, simply remove the record from rmap tree. */
1727 error = xfs_rmap_delete(cur, ltrec.rm_startblock,
1728 ltrec.rm_blockcount, ltrec.rm_owner,
1729 ltrec.rm_offset, ltrec.rm_flags);
1730 if (error)
1731 goto out_error;
1732 } else if (ltrec.rm_startblock == bno) {
1733 /*
1734 * Overlap left hand side of extent: move the start, trim the
1735 * length and update the current record.
1736 *
1737 * ltbno ltlen
1738 * Orig: |oooooooooooooooooooo|
1739 * Freeing: |fffffffff|
1740 * Result: |rrrrrrrrrr|
1741 * bno len
1742 */
1743
1744 /* Delete prev rmap. */
1745 error = xfs_rmap_delete(cur, ltrec.rm_startblock,
1746 ltrec.rm_blockcount, ltrec.rm_owner,
1747 ltrec.rm_offset, ltrec.rm_flags);
1748 if (error)
1749 goto out_error;
1750
1751 /* Add an rmap at the new offset. */
1752 ltrec.rm_startblock += len;
1753 ltrec.rm_blockcount -= len;
1754 ltrec.rm_offset += len;
1755 error = xfs_rmap_insert(cur, ltrec.rm_startblock,
1756 ltrec.rm_blockcount, ltrec.rm_owner,
1757 ltrec.rm_offset, ltrec.rm_flags);
1758 if (error)
1759 goto out_error;
1760 } else if (ltrec.rm_startblock + ltrec.rm_blockcount == bno + len) {
1761 /*
1762 * Overlap right hand side of extent: trim the length and
1763 * update the current record.
1764 *
1765 * ltbno ltlen
1766 * Orig: |oooooooooooooooooooo|
1767 * Freeing: |fffffffff|
1768 * Result: |rrrrrrrrrr|
1769 * bno len
1770 */
1771 error = xfs_rmap_lookup_eq(cur, ltrec.rm_startblock,
1772 ltrec.rm_blockcount, ltrec.rm_owner,
1773 ltrec.rm_offset, ltrec.rm_flags, &i);
1774 if (error)
1775 goto out_error;
1776 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
1777 ltrec.rm_blockcount -= len;
1778 error = xfs_rmap_update(cur, <rec);
1779 if (error)
1780 goto out_error;
1781 } else {
1782 /*
1783 * Overlap middle of extent: trim the length of the existing
1784 * record to the length of the new left-extent size, increment
1785 * the insertion position so we can insert a new record
1786 * containing the remaining right-extent space.
1787 *
1788 * ltbno ltlen
1789 * Orig: |oooooooooooooooooooo|
1790 * Freeing: |fffffffff|
1791 * Result: |rrrrr| |rrrr|
1792 * bno len
1793 */
1794 xfs_extlen_t orig_len = ltrec.rm_blockcount;
1795
1796 /* Shrink the left side of the rmap */
1797 error = xfs_rmap_lookup_eq(cur, ltrec.rm_startblock,
1798 ltrec.rm_blockcount, ltrec.rm_owner,
1799 ltrec.rm_offset, ltrec.rm_flags, &i);
1800 if (error)
1801 goto out_error;
1802 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
1803 ltrec.rm_blockcount = bno - ltrec.rm_startblock;
1804 error = xfs_rmap_update(cur, <rec);
1805 if (error)
1806 goto out_error;
1807
1808 /* Add an rmap at the new offset */
1809 error = xfs_rmap_insert(cur, bno + len,
1810 orig_len - len - ltrec.rm_blockcount,
1811 ltrec.rm_owner, offset + len,
1812 ltrec.rm_flags);
1813 if (error)
1814 goto out_error;
1815 }
1816
1817 trace_xfs_rmap_unmap_done(mp, cur->bc_private.a.agno, bno, len,
1818 unwritten, oinfo);
1819out_error:
1820 if (error)
1821 trace_xfs_rmap_unmap_error(cur->bc_mp,
1822 cur->bc_private.a.agno, error, _RET_IP_);
1823 return error;
1824}
1825
1826/*
1827 * Find an extent in the rmap btree and map it. For rmap extent types that
1828 * can overlap (data fork rmaps on reflink filesystems) we must be careful
1829 * that the prev/next records in the btree might belong to another owner.
1830 * Therefore we must use delete+insert to alter any of the key fields.
1831 *
1832 * For every other situation there can only be one owner for a given extent,
1833 * so we can call the regular _alloc function.
1834 */
1835STATIC int
1836xfs_rmap_map_shared(
1837 struct xfs_btree_cur *cur,
1838 xfs_agblock_t bno,
1839 xfs_extlen_t len,
1840 bool unwritten,
1841 struct xfs_owner_info *oinfo)
1842{
1843 struct xfs_mount *mp = cur->bc_mp;
1844 struct xfs_rmap_irec ltrec;
1845 struct xfs_rmap_irec gtrec;
1846 int have_gt;
1847 int have_lt;
1848 int error = 0;
1849 int i;
1850 uint64_t owner;
1851 uint64_t offset;
1852 unsigned int flags = 0;
1853
1854 xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
1855 if (unwritten)
1856 flags |= XFS_RMAP_UNWRITTEN;
1857 trace_xfs_rmap_map(mp, cur->bc_private.a.agno, bno, len,
1858 unwritten, oinfo);
1859
1860 /* Is there a left record that abuts our range? */
1861 error = xfs_rmap_find_left_neighbor(cur, bno, owner, offset, flags,
1862 <rec, &have_lt);
1863 if (error)
1864 goto out_error;
1865 if (have_lt &&
1866 !xfs_rmap_is_mergeable(<rec, owner, flags))
1867 have_lt = 0;
1868
1869 /* Is there a right record that abuts our range? */
1870 error = xfs_rmap_lookup_eq(cur, bno + len, len, owner, offset + len,
1871 flags, &have_gt);
1872 if (error)
1873 goto out_error;
1874 if (have_gt) {
1875 error = xfs_rmap_get_rec(cur, >rec, &have_gt);
1876 if (error)
1877 goto out_error;
1878 XFS_WANT_CORRUPTED_GOTO(mp, have_gt == 1, out_error);
1879 trace_xfs_rmap_find_right_neighbor_result(cur->bc_mp,
1880 cur->bc_private.a.agno, gtrec.rm_startblock,
1881 gtrec.rm_blockcount, gtrec.rm_owner,
1882 gtrec.rm_offset, gtrec.rm_flags);
1883
1884 if (!xfs_rmap_is_mergeable(>rec, owner, flags))
1885 have_gt = 0;
1886 }
1887
1888 if (have_lt &&
1889 ltrec.rm_startblock + ltrec.rm_blockcount == bno &&
1890 ltrec.rm_offset + ltrec.rm_blockcount == offset) {
1891 /*
1892 * Left edge contiguous, merge into left record.
1893 *
1894 * ltbno ltlen
1895 * orig: |ooooooooo|
1896 * adding: |aaaaaaaaa|
1897 * result: |rrrrrrrrrrrrrrrrrrr|
1898 * bno len
1899 */
1900 ltrec.rm_blockcount += len;
1901 if (have_gt &&
1902 bno + len == gtrec.rm_startblock &&
1903 offset + len == gtrec.rm_offset) {
1904 /*
1905 * Right edge also contiguous, delete right record
1906 * and merge into left record.
1907 *
1908 * ltbno ltlen gtbno gtlen
1909 * orig: |ooooooooo| |ooooooooo|
1910 * adding: |aaaaaaaaa|
1911 * result: |rrrrrrrrrrrrrrrrrrrrrrrrrrrrr|
1912 */
1913 ltrec.rm_blockcount += gtrec.rm_blockcount;
1914 error = xfs_rmap_delete(cur, gtrec.rm_startblock,
1915 gtrec.rm_blockcount, gtrec.rm_owner,
1916 gtrec.rm_offset, gtrec.rm_flags);
1917 if (error)
1918 goto out_error;
1919 }
1920
1921 /* Point the cursor back to the left record and update. */
1922 error = xfs_rmap_lookup_eq(cur, ltrec.rm_startblock,
1923 ltrec.rm_blockcount, ltrec.rm_owner,
1924 ltrec.rm_offset, ltrec.rm_flags, &i);
1925 if (error)
1926 goto out_error;
1927 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
1928
1929 error = xfs_rmap_update(cur, <rec);
1930 if (error)
1931 goto out_error;
1932 } else if (have_gt &&
1933 bno + len == gtrec.rm_startblock &&
1934 offset + len == gtrec.rm_offset) {
1935 /*
1936 * Right edge contiguous, merge into right record.
1937 *
1938 * gtbno gtlen
1939 * Orig: |ooooooooo|
1940 * adding: |aaaaaaaaa|
1941 * Result: |rrrrrrrrrrrrrrrrrrr|
1942 * bno len
1943 */
1944 /* Delete the old record. */
1945 error = xfs_rmap_delete(cur, gtrec.rm_startblock,
1946 gtrec.rm_blockcount, gtrec.rm_owner,
1947 gtrec.rm_offset, gtrec.rm_flags);
1948 if (error)
1949 goto out_error;
1950
1951 /* Move the start and re-add it. */
1952 gtrec.rm_startblock = bno;
1953 gtrec.rm_blockcount += len;
1954 gtrec.rm_offset = offset;
1955 error = xfs_rmap_insert(cur, gtrec.rm_startblock,
1956 gtrec.rm_blockcount, gtrec.rm_owner,
1957 gtrec.rm_offset, gtrec.rm_flags);
1958 if (error)
1959 goto out_error;
1960 } else {
1961 /*
1962 * No contiguous edge with identical owner, insert
1963 * new record at current cursor position.
1964 */
1965 error = xfs_rmap_insert(cur, bno, len, owner, offset, flags);
1966 if (error)
1967 goto out_error;
1968 }
1969
1970 trace_xfs_rmap_map_done(mp, cur->bc_private.a.agno, bno, len,
1971 unwritten, oinfo);
1972out_error:
1973 if (error)
1974 trace_xfs_rmap_map_error(cur->bc_mp,
1975 cur->bc_private.a.agno, error, _RET_IP_);
1976 return error;
1977}
1978
1979struct xfs_rmap_query_range_info {
1980 xfs_rmap_query_range_fn fn;
1981 void *priv;
1982};
1983
1984/* Format btree record and pass to our callback. */
1985STATIC int
1986xfs_rmap_query_range_helper(
1987 struct xfs_btree_cur *cur,
1988 union xfs_btree_rec *rec,
1989 void *priv)
1990{
1991 struct xfs_rmap_query_range_info *query = priv;
1992 struct xfs_rmap_irec irec;
1993 int error;
1994
1995 error = xfs_rmap_btrec_to_irec(rec, &irec);
1996 if (error)
1997 return error;
1998 return query->fn(cur, &irec, query->priv);
1999}
2000
2001/* Find all rmaps between two keys. */
2002int
2003xfs_rmap_query_range(
2004 struct xfs_btree_cur *cur,
2005 struct xfs_rmap_irec *low_rec,
2006 struct xfs_rmap_irec *high_rec,
2007 xfs_rmap_query_range_fn fn,
2008 void *priv)
2009{
2010 union xfs_btree_irec low_brec;
2011 union xfs_btree_irec high_brec;
2012 struct xfs_rmap_query_range_info query;
2013
2014 low_brec.r = *low_rec;
2015 high_brec.r = *high_rec;
2016 query.priv = priv;
2017 query.fn = fn;
2018 return xfs_btree_query_range(cur, &low_brec, &high_brec,
2019 xfs_rmap_query_range_helper, &query);
2020}
2021
2022/* Clean up after calling xfs_rmap_finish_one. */
2023void
2024xfs_rmap_finish_one_cleanup(
2025 struct xfs_trans *tp,
2026 struct xfs_btree_cur *rcur,
2027 int error)
2028{
2029 struct xfs_buf *agbp;
2030
2031 if (rcur == NULL)
2032 return;
2033 agbp = rcur->bc_private.a.agbp;
2034 xfs_btree_del_cursor(rcur, error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR);
2035 if (error)
2036 xfs_trans_brelse(tp, agbp);
2037}
2038
2039/*
2040 * Process one of the deferred rmap operations. We pass back the
2041 * btree cursor to maintain our lock on the rmapbt between calls.
2042 * This saves time and eliminates a buffer deadlock between the
2043 * superblock and the AGF because we'll always grab them in the same
2044 * order.
2045 */
2046int
2047xfs_rmap_finish_one(
2048 struct xfs_trans *tp,
2049 enum xfs_rmap_intent_type type,
2050 __uint64_t owner,
2051 int whichfork,
2052 xfs_fileoff_t startoff,
2053 xfs_fsblock_t startblock,
2054 xfs_filblks_t blockcount,
2055 xfs_exntst_t state,
2056 struct xfs_btree_cur **pcur)
2057{
2058 struct xfs_mount *mp = tp->t_mountp;
2059 struct xfs_btree_cur *rcur;
2060 struct xfs_buf *agbp = NULL;
2061 int error = 0;
2062 xfs_agnumber_t agno;
2063 struct xfs_owner_info oinfo;
2064 xfs_agblock_t bno;
2065 bool unwritten;
2066
2067 agno = XFS_FSB_TO_AGNO(mp, startblock);
2068 ASSERT(agno != NULLAGNUMBER);
2069 bno = XFS_FSB_TO_AGBNO(mp, startblock);
2070
2071 trace_xfs_rmap_deferred(mp, agno, type, bno, owner, whichfork,
2072 startoff, blockcount, state);
2073
2074 if (XFS_TEST_ERROR(false, mp,
2075 XFS_ERRTAG_RMAP_FINISH_ONE,
2076 XFS_RANDOM_RMAP_FINISH_ONE))
2077 return -EIO;
2078
2079 /*
2080 * If we haven't gotten a cursor or the cursor AG doesn't match
2081 * the startblock, get one now.
2082 */
2083 rcur = *pcur;
2084 if (rcur != NULL && rcur->bc_private.a.agno != agno) {
2085 xfs_rmap_finish_one_cleanup(tp, rcur, 0);
2086 rcur = NULL;
2087 *pcur = NULL;
2088 }
2089 if (rcur == NULL) {
2090 /*
2091 * Refresh the freelist before we start changing the
2092 * rmapbt, because a shape change could cause us to
2093 * allocate blocks.
2094 */
2095 error = xfs_free_extent_fix_freelist(tp, agno, &agbp);
2096 if (error)
2097 return error;
2098 if (!agbp)
2099 return -EFSCORRUPTED;
2100
2101 rcur = xfs_rmapbt_init_cursor(mp, tp, agbp, agno);
2102 if (!rcur) {
2103 error = -ENOMEM;
2104 goto out_cur;
2105 }
2106 }
2107 *pcur = rcur;
2108
2109 xfs_rmap_ino_owner(&oinfo, owner, whichfork, startoff);
2110 unwritten = state == XFS_EXT_UNWRITTEN;
2111 bno = XFS_FSB_TO_AGBNO(rcur->bc_mp, startblock);
2112
2113 switch (type) {
2114 case XFS_RMAP_ALLOC:
2115 case XFS_RMAP_MAP:
2116 error = xfs_rmap_map(rcur, bno, blockcount, unwritten, &oinfo);
2117 break;
2118 case XFS_RMAP_MAP_SHARED:
2119 error = xfs_rmap_map_shared(rcur, bno, blockcount, unwritten,
2120 &oinfo);
2121 break;
2122 case XFS_RMAP_FREE:
2123 case XFS_RMAP_UNMAP:
2124 error = xfs_rmap_unmap(rcur, bno, blockcount, unwritten,
2125 &oinfo);
2126 break;
2127 case XFS_RMAP_UNMAP_SHARED:
2128 error = xfs_rmap_unmap_shared(rcur, bno, blockcount, unwritten,
2129 &oinfo);
2130 break;
2131 case XFS_RMAP_CONVERT:
2132 error = xfs_rmap_convert(rcur, bno, blockcount, !unwritten,
2133 &oinfo);
2134 break;
2135 case XFS_RMAP_CONVERT_SHARED:
2136 error = xfs_rmap_convert_shared(rcur, bno, blockcount,
2137 !unwritten, &oinfo);
2138 break;
2139 default:
2140 ASSERT(0);
2141 error = -EFSCORRUPTED;
2142 }
2143 return error;
2144
2145out_cur:
2146 xfs_trans_brelse(tp, agbp);
2147
2148 return error;
2149}
2150
2151/*
2152 * Don't defer an rmap if we aren't an rmap filesystem.
2153 */
2154static bool
2155xfs_rmap_update_is_needed(
2156 struct xfs_mount *mp,
2157 int whichfork)
2158{
2159 return xfs_sb_version_hasrmapbt(&mp->m_sb) && whichfork != XFS_COW_FORK;
2160}
2161
2162/*
2163 * Record a rmap intent; the list is kept sorted first by AG and then by
2164 * increasing age.
2165 */
2166static int
2167__xfs_rmap_add(
2168 struct xfs_mount *mp,
2169 struct xfs_defer_ops *dfops,
2170 enum xfs_rmap_intent_type type,
2171 __uint64_t owner,
2172 int whichfork,
2173 struct xfs_bmbt_irec *bmap)
2174{
2175 struct xfs_rmap_intent *ri;
2176
2177 trace_xfs_rmap_defer(mp, XFS_FSB_TO_AGNO(mp, bmap->br_startblock),
2178 type,
2179 XFS_FSB_TO_AGBNO(mp, bmap->br_startblock),
2180 owner, whichfork,
2181 bmap->br_startoff,
2182 bmap->br_blockcount,
2183 bmap->br_state);
2184
2185 ri = kmem_alloc(sizeof(struct xfs_rmap_intent), KM_SLEEP | KM_NOFS);
2186 INIT_LIST_HEAD(&ri->ri_list);
2187 ri->ri_type = type;
2188 ri->ri_owner = owner;
2189 ri->ri_whichfork = whichfork;
2190 ri->ri_bmap = *bmap;
2191
2192 xfs_defer_add(dfops, XFS_DEFER_OPS_TYPE_RMAP, &ri->ri_list);
2193 return 0;
2194}
2195
2196/* Map an extent into a file. */
2197int
2198xfs_rmap_map_extent(
2199 struct xfs_mount *mp,
2200 struct xfs_defer_ops *dfops,
2201 struct xfs_inode *ip,
2202 int whichfork,
2203 struct xfs_bmbt_irec *PREV)
2204{
2205 if (!xfs_rmap_update_is_needed(mp, whichfork))
2206 return 0;
2207
2208 return __xfs_rmap_add(mp, dfops, xfs_is_reflink_inode(ip) ?
2209 XFS_RMAP_MAP_SHARED : XFS_RMAP_MAP, ip->i_ino,
2210 whichfork, PREV);
2211}
2212
2213/* Unmap an extent out of a file. */
2214int
2215xfs_rmap_unmap_extent(
2216 struct xfs_mount *mp,
2217 struct xfs_defer_ops *dfops,
2218 struct xfs_inode *ip,
2219 int whichfork,
2220 struct xfs_bmbt_irec *PREV)
2221{
2222 if (!xfs_rmap_update_is_needed(mp, whichfork))
2223 return 0;
2224
2225 return __xfs_rmap_add(mp, dfops, xfs_is_reflink_inode(ip) ?
2226 XFS_RMAP_UNMAP_SHARED : XFS_RMAP_UNMAP, ip->i_ino,
2227 whichfork, PREV);
2228}
2229
2230/* Convert a data fork extent from unwritten to real or vice versa. */
2231int
2232xfs_rmap_convert_extent(
2233 struct xfs_mount *mp,
2234 struct xfs_defer_ops *dfops,
2235 struct xfs_inode *ip,
2236 int whichfork,
2237 struct xfs_bmbt_irec *PREV)
2238{
2239 if (!xfs_rmap_update_is_needed(mp, whichfork))
2240 return 0;
2241
2242 return __xfs_rmap_add(mp, dfops, xfs_is_reflink_inode(ip) ?
2243 XFS_RMAP_CONVERT_SHARED : XFS_RMAP_CONVERT, ip->i_ino,
2244 whichfork, PREV);
2245}
2246
2247/* Schedule the creation of an rmap for non-file data. */
2248int
2249xfs_rmap_alloc_extent(
2250 struct xfs_mount *mp,
2251 struct xfs_defer_ops *dfops,
2252 xfs_agnumber_t agno,
2253 xfs_agblock_t bno,
2254 xfs_extlen_t len,
2255 __uint64_t owner)
2256{
2257 struct xfs_bmbt_irec bmap;
2258
2259 if (!xfs_rmap_update_is_needed(mp, XFS_DATA_FORK))
2260 return 0;
2261
2262 bmap.br_startblock = XFS_AGB_TO_FSB(mp, agno, bno);
2263 bmap.br_blockcount = len;
2264 bmap.br_startoff = 0;
2265 bmap.br_state = XFS_EXT_NORM;
2266
2267 return __xfs_rmap_add(mp, dfops, XFS_RMAP_ALLOC, owner,
2268 XFS_DATA_FORK, &bmap);
2269}
2270
2271/* Schedule the deletion of an rmap for non-file data. */
2272int
2273xfs_rmap_free_extent(
2274 struct xfs_mount *mp,
2275 struct xfs_defer_ops *dfops,
2276 xfs_agnumber_t agno,
2277 xfs_agblock_t bno,
2278 xfs_extlen_t len,
2279 __uint64_t owner)
2280{
2281 struct xfs_bmbt_irec bmap;
2282
2283 if (!xfs_rmap_update_is_needed(mp, XFS_DATA_FORK))
2284 return 0;
2285
2286 bmap.br_startblock = XFS_AGB_TO_FSB(mp, agno, bno);
2287 bmap.br_blockcount = len;
2288 bmap.br_startoff = 0;
2289 bmap.br_state = XFS_EXT_NORM;
2290
2291 return __xfs_rmap_add(mp, dfops, XFS_RMAP_FREE, owner,
2292 XFS_DATA_FORK, &bmap);
2293}