]> git.ipfire.org Git - thirdparty/xfsprogs-dev.git/blob - libxfs/xfs_bmap.c
projects / thirdparty / xfsprogs-dev.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
xfs: refactor common transaction/inode/quota allocation idiom
[thirdparty/xfsprogs-dev.git] / libxfs / xfs_bmap.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
4 * All Rights Reserved.
5 */
6 #include "libxfs_priv.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_sb.h"
14 #include "xfs_mount.h"
15 #include "xfs_defer.h"
16 #include "xfs_dir2.h"
17 #include "xfs_inode.h"
18 #include "xfs_btree.h"
19 #include "xfs_trans.h"
20 #include "xfs_alloc.h"
21 #include "xfs_bmap.h"
22 #include "xfs_bmap_btree.h"
23 #include "xfs_errortag.h"
24 #include "xfs_trans_space.h"
25 #include "xfs_trace.h"
26 #include "xfs_attr_leaf.h"
27 #include "xfs_quota_defs.h"
28 #include "xfs_rmap.h"
29 #include "xfs_ag_resv.h"
30 #include "xfs_refcount.h"
31
32
33 kmem_zone_t *xfs_bmap_free_item_zone;
34
35 /*
36 * Miscellaneous helper functions
37 */
38
39 /*
40 * Compute and fill in the value of the maximum depth of a bmap btree
41 * in this filesystem. Done once, during mount.
42 */
43 void
44 xfs_bmap_compute_maxlevels(
45 xfs_mount_t *mp, /* file system mount structure */
46 int whichfork) /* data or attr fork */
47 {
48 int level; /* btree level */
49 uint maxblocks; /* max blocks at this level */
50 uint maxleafents; /* max leaf entries possible */
51 int maxrootrecs; /* max records in root block */
52 int minleafrecs; /* min records in leaf block */
53 int minnoderecs; /* min records in node block */
54 int sz; /* root block size */
55
56 /*
57 * The maximum number of extents in a file, hence the maximum number of
58 * leaf entries, is controlled by the size of the on-disk extent count,
59 * either a signed 32-bit number for the data fork, or a signed 16-bit
60 * number for the attr fork.
61 *
62 * Note that we can no longer assume that if we are in ATTR1 that
63 * the fork offset of all the inodes will be
64 * (xfs_default_attroffset(ip) >> 3) because we could have mounted
65 * with ATTR2 and then mounted back with ATTR1, keeping the
66 * di_forkoff's fixed but probably at various positions. Therefore,
67 * for both ATTR1 and ATTR2 we have to assume the worst case scenario
68 * of a minimum size available.
69 */
70 if (whichfork == XFS_DATA_FORK) {
71 maxleafents = MAXEXTNUM;
72 sz = XFS_BMDR_SPACE_CALC(MINDBTPTRS);
73 } else {
74 maxleafents = MAXAEXTNUM;
75 sz = XFS_BMDR_SPACE_CALC(MINABTPTRS);
76 }
77 maxrootrecs = xfs_bmdr_maxrecs(sz, 0);
78 minleafrecs = mp->m_bmap_dmnr[0];
79 minnoderecs = mp->m_bmap_dmnr[1];
80 maxblocks = (maxleafents + minleafrecs - 1) / minleafrecs;
81 for (level = 1; maxblocks > 1; level++) {
82 if (maxblocks <= maxrootrecs)
83 maxblocks = 1;
84 else
85 maxblocks = (maxblocks + minnoderecs - 1) / minnoderecs;
86 }
87 mp->m_bm_maxlevels[whichfork] = level;
88 }
89
90 STATIC int /* error */
91 xfs_bmbt_lookup_eq(
92 struct xfs_btree_cur *cur,
93 struct xfs_bmbt_irec *irec,
94 int *stat) /* success/failure */
95 {
96 cur->bc_rec.b = *irec;
97 return xfs_btree_lookup(cur, XFS_LOOKUP_EQ, stat);
98 }
99
100 STATIC int /* error */
101 xfs_bmbt_lookup_first(
102 struct xfs_btree_cur *cur,
103 int *stat) /* success/failure */
104 {
105 cur->bc_rec.b.br_startoff = 0;
106 cur->bc_rec.b.br_startblock = 0;
107 cur->bc_rec.b.br_blockcount = 0;
108 return xfs_btree_lookup(cur, XFS_LOOKUP_GE, stat);
109 }
110
111 /*
112 * Check if the inode needs to be converted to btree format.
113 */
114 static inline bool xfs_bmap_needs_btree(struct xfs_inode *ip, int whichfork)
115 {
116 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
117
118 return whichfork != XFS_COW_FORK &&
119 ifp->if_format == XFS_DINODE_FMT_EXTENTS &&
120 ifp->if_nextents > XFS_IFORK_MAXEXT(ip, whichfork);
121 }
122
123 /*
124 * Check if the inode should be converted to extent format.
125 */
126 static inline bool xfs_bmap_wants_extents(struct xfs_inode *ip, int whichfork)
127 {
128 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
129
130 return whichfork != XFS_COW_FORK &&
131 ifp->if_format == XFS_DINODE_FMT_BTREE &&
132 ifp->if_nextents <= XFS_IFORK_MAXEXT(ip, whichfork);
133 }
134
135 /*
136 * Update the record referred to by cur to the value given by irec
137 * This either works (return 0) or gets an EFSCORRUPTED error.
138 */
139 STATIC int
140 xfs_bmbt_update(
141 struct xfs_btree_cur *cur,
142 struct xfs_bmbt_irec *irec)
143 {
144 union xfs_btree_rec rec;
145
146 xfs_bmbt_disk_set_all(&rec.bmbt, irec);
147 return xfs_btree_update(cur, &rec);
148 }
149
150 /*
151 * Compute the worst-case number of indirect blocks that will be used
152 * for ip's delayed extent of length "len".
153 */
154 STATIC xfs_filblks_t
155 xfs_bmap_worst_indlen(
156 xfs_inode_t *ip, /* incore inode pointer */
157 xfs_filblks_t len) /* delayed extent length */
158 {
159 int level; /* btree level number */
160 int maxrecs; /* maximum record count at this level */
161 xfs_mount_t *mp; /* mount structure */
162 xfs_filblks_t rval; /* return value */
163
164 mp = ip->i_mount;
165 maxrecs = mp->m_bmap_dmxr[0];
166 for (level = 0, rval = 0;
167 level < XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK);
168 level++) {
169 len += maxrecs - 1;
170 do_div(len, maxrecs);
171 rval += len;
172 if (len == 1)
173 return rval + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) -
174 level - 1;
175 if (level == 0)
176 maxrecs = mp->m_bmap_dmxr[1];
177 }
178 return rval;
179 }
180
181 /*
182 * Calculate the default attribute fork offset for newly created inodes.
183 */
184 uint
185 xfs_default_attroffset(
186 struct xfs_inode *ip)
187 {
188 struct xfs_mount *mp = ip->i_mount;
189 uint offset;
190
191 if (mp->m_sb.sb_inodesize == 256)
192 offset = XFS_LITINO(mp) - XFS_BMDR_SPACE_CALC(MINABTPTRS);
193 else
194 offset = XFS_BMDR_SPACE_CALC(6 * MINABTPTRS);
195
196 ASSERT(offset < XFS_LITINO(mp));
197 return offset;
198 }
199
200 /*
201 * Helper routine to reset inode di_forkoff field when switching
202 * attribute fork from local to extent format - we reset it where
203 * possible to make space available for inline data fork extents.
204 */
205 STATIC void
206 xfs_bmap_forkoff_reset(
207 xfs_inode_t *ip,
208 int whichfork)
209 {
210 if (whichfork == XFS_ATTR_FORK &&
211 ip->i_df.if_format != XFS_DINODE_FMT_DEV &&
212 ip->i_df.if_format != XFS_DINODE_FMT_BTREE) {
213 uint dfl_forkoff = xfs_default_attroffset(ip) >> 3;
214
215 if (dfl_forkoff > ip->i_d.di_forkoff)
216 ip->i_d.di_forkoff = dfl_forkoff;
217 }
218 }
219
220 #ifdef DEBUG
221 STATIC struct xfs_buf *
222 xfs_bmap_get_bp(
223 struct xfs_btree_cur *cur,
224 xfs_fsblock_t bno)
225 {
226 struct xfs_log_item *lip;
227 int i;
228
229 if (!cur)
230 return NULL;
231
232 for (i = 0; i < XFS_BTREE_MAXLEVELS; i++) {
233 if (!cur->bc_bufs[i])
234 break;
235 if (XFS_BUF_ADDR(cur->bc_bufs[i]) == bno)
236 return cur->bc_bufs[i];
237 }
238
239 /* Chase down all the log items to see if the bp is there */
240 list_for_each_entry(lip, &cur->bc_tp->t_items, li_trans) {
241 struct xfs_buf_log_item *bip = (struct xfs_buf_log_item *)lip;
242
243 if (bip->bli_item.li_type == XFS_LI_BUF &&
244 XFS_BUF_ADDR(bip->bli_buf) == bno)
245 return bip->bli_buf;
246 }
247
248 return NULL;
249 }
250
251 STATIC void
252 xfs_check_block(
253 struct xfs_btree_block *block,
254 xfs_mount_t *mp,
255 int root,
256 short sz)
257 {
258 int i, j, dmxr;
259 __be64 *pp, *thispa; /* pointer to block address */
260 xfs_bmbt_key_t *prevp, *keyp;
261
262 ASSERT(be16_to_cpu(block->bb_level) > 0);
263
264 prevp = NULL;
265 for( i = 1; i <= xfs_btree_get_numrecs(block); i++) {
266 dmxr = mp->m_bmap_dmxr[0];
267 keyp = XFS_BMBT_KEY_ADDR(mp, block, i);
268
269 if (prevp) {
270 ASSERT(be64_to_cpu(prevp->br_startoff) <
271 be64_to_cpu(keyp->br_startoff));
272 }
273 prevp = keyp;
274
275 /*
276 * Compare the block numbers to see if there are dups.
277 */
278 if (root)
279 pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, i, sz);
280 else
281 pp = XFS_BMBT_PTR_ADDR(mp, block, i, dmxr);
282
283 for (j = i+1; j <= be16_to_cpu(block->bb_numrecs); j++) {
284 if (root)
285 thispa = XFS_BMAP_BROOT_PTR_ADDR(mp, block, j, sz);
286 else
287 thispa = XFS_BMBT_PTR_ADDR(mp, block, j, dmxr);
288 if (*thispa == *pp) {
289 xfs_warn(mp, "%s: thispa(%d) == pp(%d) %Ld",
290 __func__, j, i,
291 (unsigned long long)be64_to_cpu(*thispa));
292 xfs_err(mp, "%s: ptrs are equal in node\n",
293 __func__);
294 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
295 }
296 }
297 }
298 }
299
300 /*
301 * Check that the extents for the inode ip are in the right order in all
302 * btree leaves. THis becomes prohibitively expensive for large extent count
303 * files, so don't bother with inodes that have more than 10,000 extents in
304 * them. The btree record ordering checks will still be done, so for such large
305 * bmapbt constructs that is going to catch most corruptions.
306 */
307 STATIC void
308 xfs_bmap_check_leaf_extents(
309 xfs_btree_cur_t *cur, /* btree cursor or null */
310 xfs_inode_t *ip, /* incore inode pointer */
311 int whichfork) /* data or attr fork */
312 {
313 struct xfs_mount *mp = ip->i_mount;
314 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
315 struct xfs_btree_block *block; /* current btree block */
316 xfs_fsblock_t bno; /* block # of "block" */
317 struct xfs_buf *bp; /* buffer for "block" */
318 int error; /* error return value */
319 xfs_extnum_t i=0, j; /* index into the extents list */
320 int level; /* btree level, for checking */
321 __be64 *pp; /* pointer to block address */
322 xfs_bmbt_rec_t *ep; /* pointer to current extent */
323 xfs_bmbt_rec_t last = {0, 0}; /* last extent in prev block */
324 xfs_bmbt_rec_t *nextp; /* pointer to next extent */
325 int bp_release = 0;
326
327 if (ifp->if_format != XFS_DINODE_FMT_BTREE)
328 return;
329
330 /* skip large extent count inodes */
331 if (ip->i_df.if_nextents > 10000)
332 return;
333
334 bno = NULLFSBLOCK;
335 block = ifp->if_broot;
336 /*
337 * Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out.
338 */
339 level = be16_to_cpu(block->bb_level);
340 ASSERT(level > 0);
341 xfs_check_block(block, mp, 1, ifp->if_broot_bytes);
342 pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes);
343 bno = be64_to_cpu(*pp);
344
345 ASSERT(bno != NULLFSBLOCK);
346 ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount);
347 ASSERT(XFS_FSB_TO_AGBNO(mp, bno) < mp->m_sb.sb_agblocks);
348
349 /*
350 * Go down the tree until leaf level is reached, following the first
351 * pointer (leftmost) at each level.
352 */
353 while (level-- > 0) {
354 /* See if buf is in cur first */
355 bp_release = 0;
356 bp = xfs_bmap_get_bp(cur, XFS_FSB_TO_DADDR(mp, bno));
357 if (!bp) {
358 bp_release = 1;
359 error = xfs_btree_read_bufl(mp, NULL, bno, &bp,
360 XFS_BMAP_BTREE_REF,
361 &xfs_bmbt_buf_ops);
362 if (error)
363 goto error_norelse;
364 }
365 block = XFS_BUF_TO_BLOCK(bp);
366 if (level == 0)
367 break;
368
369 /*
370 * Check this block for basic sanity (increasing keys and
371 * no duplicate blocks).
372 */
373
374 xfs_check_block(block, mp, 0, 0);
375 pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]);
376 bno = be64_to_cpu(*pp);
377 if (XFS_IS_CORRUPT(mp, !xfs_verify_fsbno(mp, bno))) {
378 error = -EFSCORRUPTED;
379 goto error0;
380 }
381 if (bp_release) {
382 bp_release = 0;
383 xfs_trans_brelse(NULL, bp);
384 }
385 }
386
387 /*
388 * Here with bp and block set to the leftmost leaf node in the tree.
389 */
390 i = 0;
391
392 /*
393 * Loop over all leaf nodes checking that all extents are in the right order.
394 */
395 for (;;) {
396 xfs_fsblock_t nextbno;
397 xfs_extnum_t num_recs;
398
399
400 num_recs = xfs_btree_get_numrecs(block);
401
402 /*
403 * Read-ahead the next leaf block, if any.
404 */
405
406 nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib);
407
408 /*
409 * Check all the extents to make sure they are OK.
410 * If we had a previous block, the last entry should
411 * conform with the first entry in this one.
412 */
413
414 ep = XFS_BMBT_REC_ADDR(mp, block, 1);
415 if (i) {
416 ASSERT(xfs_bmbt_disk_get_startoff(&last) +
417 xfs_bmbt_disk_get_blockcount(&last) <=
418 xfs_bmbt_disk_get_startoff(ep));
419 }
420 for (j = 1; j < num_recs; j++) {
421 nextp = XFS_BMBT_REC_ADDR(mp, block, j + 1);
422 ASSERT(xfs_bmbt_disk_get_startoff(ep) +
423 xfs_bmbt_disk_get_blockcount(ep) <=
424 xfs_bmbt_disk_get_startoff(nextp));
425 ep = nextp;
426 }
427
428 last = *ep;
429 i += num_recs;
430 if (bp_release) {
431 bp_release = 0;
432 xfs_trans_brelse(NULL, bp);
433 }
434 bno = nextbno;
435 /*
436 * If we've reached the end, stop.
437 */
438 if (bno == NULLFSBLOCK)
439 break;
440
441 bp_release = 0;
442 bp = xfs_bmap_get_bp(cur, XFS_FSB_TO_DADDR(mp, bno));
443 if (!bp) {
444 bp_release = 1;
445 error = xfs_btree_read_bufl(mp, NULL, bno, &bp,
446 XFS_BMAP_BTREE_REF,
447 &xfs_bmbt_buf_ops);
448 if (error)
449 goto error_norelse;
450 }
451 block = XFS_BUF_TO_BLOCK(bp);
452 }
453
454 return;
455
456 error0:
457 xfs_warn(mp, "%s: at error0", __func__);
458 if (bp_release)
459 xfs_trans_brelse(NULL, bp);
460 error_norelse:
461 xfs_warn(mp, "%s: BAD after btree leaves for %d extents",
462 __func__, i);
463 xfs_err(mp, "%s: CORRUPTED BTREE OR SOMETHING", __func__);
464 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
465 return;
466 }
467
468 /*
469 * Validate that the bmbt_irecs being returned from bmapi are valid
470 * given the caller's original parameters. Specifically check the
471 * ranges of the returned irecs to ensure that they only extend beyond
472 * the given parameters if the XFS_BMAPI_ENTIRE flag was set.
473 */
474 STATIC void
475 xfs_bmap_validate_ret(
476 xfs_fileoff_t bno,
477 xfs_filblks_t len,
478 int flags,
479 xfs_bmbt_irec_t *mval,
480 int nmap,
481 int ret_nmap)
482 {
483 int i; /* index to map values */
484
485 ASSERT(ret_nmap <= nmap);
486
487 for (i = 0; i < ret_nmap; i++) {
488 ASSERT(mval[i].br_blockcount > 0);
489 if (!(flags & XFS_BMAPI_ENTIRE)) {
490 ASSERT(mval[i].br_startoff >= bno);
491 ASSERT(mval[i].br_blockcount <= len);
492 ASSERT(mval[i].br_startoff + mval[i].br_blockcount <=
493 bno + len);
494 } else {
495 ASSERT(mval[i].br_startoff < bno + len);
496 ASSERT(mval[i].br_startoff + mval[i].br_blockcount >
497 bno);
498 }
499 ASSERT(i == 0 ||
500 mval[i - 1].br_startoff + mval[i - 1].br_blockcount ==
501 mval[i].br_startoff);
502 ASSERT(mval[i].br_startblock != DELAYSTARTBLOCK &&
503 mval[i].br_startblock != HOLESTARTBLOCK);
504 ASSERT(mval[i].br_state == XFS_EXT_NORM ||
505 mval[i].br_state == XFS_EXT_UNWRITTEN);
506 }
507 }
508
509 #else
510 #define xfs_bmap_check_leaf_extents(cur, ip, whichfork) do { } while (0)
511 #define xfs_bmap_validate_ret(bno,len,flags,mval,onmap,nmap) do { } while (0)
512 #endif /* DEBUG */
513
514 /*
515 * bmap free list manipulation functions
516 */
517
518 /*
519 * Add the extent to the list of extents to be free at transaction end.
520 * The list is maintained sorted (by block number).
521 */
522 void
523 __xfs_bmap_add_free(
524 struct xfs_trans *tp,
525 xfs_fsblock_t bno,
526 xfs_filblks_t len,
527 const struct xfs_owner_info *oinfo,
528 bool skip_discard)
529 {
530 struct xfs_extent_free_item *new; /* new element */
531 #ifdef DEBUG
532 struct xfs_mount *mp = tp->t_mountp;
533 xfs_agnumber_t agno;
534 xfs_agblock_t agbno;
535
536 ASSERT(bno != NULLFSBLOCK);
537 ASSERT(len > 0);
538 ASSERT(len <= MAXEXTLEN);
539 ASSERT(!isnullstartblock(bno));
540 agno = XFS_FSB_TO_AGNO(mp, bno);
541 agbno = XFS_FSB_TO_AGBNO(mp, bno);
542 ASSERT(agno < mp->m_sb.sb_agcount);
543 ASSERT(agbno < mp->m_sb.sb_agblocks);
544 ASSERT(len < mp->m_sb.sb_agblocks);
545 ASSERT(agbno + len <= mp->m_sb.sb_agblocks);
546 #endif
547 ASSERT(xfs_bmap_free_item_zone != NULL);
548
549 new = kmem_cache_alloc(xfs_bmap_free_item_zone,
550 GFP_KERNEL | __GFP_NOFAIL);
551 new->xefi_startblock = bno;
552 new->xefi_blockcount = (xfs_extlen_t)len;
553 if (oinfo)
554 new->xefi_oinfo = *oinfo;
555 else
556 new->xefi_oinfo = XFS_RMAP_OINFO_SKIP_UPDATE;
557 new->xefi_skip_discard = skip_discard;
558 trace_xfs_bmap_free_defer(tp->t_mountp,
559 XFS_FSB_TO_AGNO(tp->t_mountp, bno), 0,
560 XFS_FSB_TO_AGBNO(tp->t_mountp, bno), len);
561 xfs_defer_add(tp, XFS_DEFER_OPS_TYPE_FREE, &new->xefi_list);
562 }
563
564 /*
565 * Inode fork format manipulation functions
566 */
567
568 /*
569 * Convert the inode format to extent format if it currently is in btree format,
570 * but the extent list is small enough that it fits into the extent format.
571 *
572 * Since the extents are already in-core, all we have to do is give up the space
573 * for the btree root and pitch the leaf block.
574 */
575 STATIC int /* error */
576 xfs_bmap_btree_to_extents(
577 struct xfs_trans *tp, /* transaction pointer */
578 struct xfs_inode *ip, /* incore inode pointer */
579 struct xfs_btree_cur *cur, /* btree cursor */
580 int *logflagsp, /* inode logging flags */
581 int whichfork) /* data or attr fork */
582 {
583 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
584 struct xfs_mount *mp = ip->i_mount;
585 struct xfs_btree_block *rblock = ifp->if_broot;
586 struct xfs_btree_block *cblock;/* child btree block */
587 xfs_fsblock_t cbno; /* child block number */
588 struct xfs_buf *cbp; /* child block's buffer */
589 int error; /* error return value */
590 __be64 *pp; /* ptr to block address */
591 struct xfs_owner_info oinfo;
592
593 /* check if we actually need the extent format first: */
594 if (!xfs_bmap_wants_extents(ip, whichfork))
595 return 0;
596
597 ASSERT(cur);
598 ASSERT(whichfork != XFS_COW_FORK);
599 ASSERT(ifp->if_flags & XFS_IFEXTENTS);
600 ASSERT(ifp->if_format == XFS_DINODE_FMT_BTREE);
601 ASSERT(be16_to_cpu(rblock->bb_level) == 1);
602 ASSERT(be16_to_cpu(rblock->bb_numrecs) == 1);
603 ASSERT(xfs_bmbt_maxrecs(mp, ifp->if_broot_bytes, 0) == 1);
604
605 pp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, ifp->if_broot_bytes);
606 cbno = be64_to_cpu(*pp);
607 #ifdef DEBUG
608 if (XFS_IS_CORRUPT(cur->bc_mp, !xfs_btree_check_lptr(cur, cbno, 1)))
609 return -EFSCORRUPTED;
610 #endif
611 error = xfs_btree_read_bufl(mp, tp, cbno, &cbp, XFS_BMAP_BTREE_REF,
612 &xfs_bmbt_buf_ops);
613 if (error)
614 return error;
615 cblock = XFS_BUF_TO_BLOCK(cbp);
616 if ((error = xfs_btree_check_block(cur, cblock, 0, cbp)))
617 return error;
618 xfs_rmap_ino_bmbt_owner(&oinfo, ip->i_ino, whichfork);
619 xfs_bmap_add_free(cur->bc_tp, cbno, 1, &oinfo);
620 ip->i_d.di_nblocks--;
621 xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, -1L);
622 xfs_trans_binval(tp, cbp);
623 if (cur->bc_bufs[0] == cbp)
624 cur->bc_bufs[0] = NULL;
625 xfs_iroot_realloc(ip, -1, whichfork);
626 ASSERT(ifp->if_broot == NULL);
627 ASSERT((ifp->if_flags & XFS_IFBROOT) == 0);
628 ifp->if_format = XFS_DINODE_FMT_EXTENTS;
629 *logflagsp |= XFS_ILOG_CORE | xfs_ilog_fext(whichfork);
630 return 0;
631 }
632
633 /*
634 * Convert an extents-format file into a btree-format file.
635 * The new file will have a root block (in the inode) and a single child block.
636 */
637 STATIC int /* error */
638 xfs_bmap_extents_to_btree(
639 struct xfs_trans *tp, /* transaction pointer */
640 struct xfs_inode *ip, /* incore inode pointer */
641 struct xfs_btree_cur **curp, /* cursor returned to caller */
642 int wasdel, /* converting a delayed alloc */
643 int *logflagsp, /* inode logging flags */
644 int whichfork) /* data or attr fork */
645 {
646 struct xfs_btree_block *ablock; /* allocated (child) bt block */
647 struct xfs_buf *abp; /* buffer for ablock */
648 struct xfs_alloc_arg args; /* allocation arguments */
649 struct xfs_bmbt_rec *arp; /* child record pointer */
650 struct xfs_btree_block *block; /* btree root block */
651 struct xfs_btree_cur *cur; /* bmap btree cursor */
652 int error; /* error return value */
653 struct xfs_ifork *ifp; /* inode fork pointer */
654 struct xfs_bmbt_key *kp; /* root block key pointer */
655 struct xfs_mount *mp; /* mount structure */
656 xfs_bmbt_ptr_t *pp; /* root block address pointer */
657 struct xfs_iext_cursor icur;
658 struct xfs_bmbt_irec rec;
659 xfs_extnum_t cnt = 0;
660
661 mp = ip->i_mount;
662 ASSERT(whichfork != XFS_COW_FORK);
663 ifp = XFS_IFORK_PTR(ip, whichfork);
664 ASSERT(ifp->if_format == XFS_DINODE_FMT_EXTENTS);
665
666 /*
667 * Make space in the inode incore. This needs to be undone if we fail
668 * to expand the root.
669 */
670 xfs_iroot_realloc(ip, 1, whichfork);
671 ifp->if_flags |= XFS_IFBROOT;
672
673 /*
674 * Fill in the root.
675 */
676 block = ifp->if_broot;
677 xfs_btree_init_block_int(mp, block, XFS_BUF_DADDR_NULL,
678 XFS_BTNUM_BMAP, 1, 1, ip->i_ino,
679 XFS_BTREE_LONG_PTRS);
680 /*
681 * Need a cursor. Can't allocate until bb_level is filled in.
682 */
683 cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
684 cur->bc_ino.flags = wasdel ? XFS_BTCUR_BMBT_WASDEL : 0;
685 /*
686 * Convert to a btree with two levels, one record in root.
687 */
688 ifp->if_format = XFS_DINODE_FMT_BTREE;
689 memset(&args, 0, sizeof(args));
690 args.tp = tp;
691 args.mp = mp;
692 xfs_rmap_ino_bmbt_owner(&args.oinfo, ip->i_ino, whichfork);
693 if (tp->t_firstblock == NULLFSBLOCK) {
694 args.type = XFS_ALLOCTYPE_START_BNO;
695 args.fsbno = XFS_INO_TO_FSB(mp, ip->i_ino);
696 } else if (tp->t_flags & XFS_TRANS_LOWMODE) {
697 args.type = XFS_ALLOCTYPE_START_BNO;
698 args.fsbno = tp->t_firstblock;
699 } else {
700 args.type = XFS_ALLOCTYPE_NEAR_BNO;
701 args.fsbno = tp->t_firstblock;
702 }
703 args.minlen = args.maxlen = args.prod = 1;
704 args.wasdel = wasdel;
705 *logflagsp = 0;
706 error = xfs_alloc_vextent(&args);
707 if (error)
708 goto out_root_realloc;
709
710 if (WARN_ON_ONCE(args.fsbno == NULLFSBLOCK)) {
711 error = -ENOSPC;
712 goto out_root_realloc;
713 }
714
715 /*
716 * Allocation can't fail, the space was reserved.
717 */
718 ASSERT(tp->t_firstblock == NULLFSBLOCK ||
719 args.agno >= XFS_FSB_TO_AGNO(mp, tp->t_firstblock));
720 tp->t_firstblock = args.fsbno;
721 cur->bc_ino.allocated++;
722 ip->i_d.di_nblocks++;
723 xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, 1L);
724 error = xfs_trans_get_buf(tp, mp->m_ddev_targp,
725 XFS_FSB_TO_DADDR(mp, args.fsbno),
726 mp->m_bsize, 0, &abp);
727 if (error)
728 goto out_unreserve_dquot;
729
730 /*
731 * Fill in the child block.
732 */
733 abp->b_ops = &xfs_bmbt_buf_ops;
734 ablock = XFS_BUF_TO_BLOCK(abp);
735 xfs_btree_init_block_int(mp, ablock, abp->b_bn,
736 XFS_BTNUM_BMAP, 0, 0, ip->i_ino,
737 XFS_BTREE_LONG_PTRS);
738
739 for_each_xfs_iext(ifp, &icur, &rec) {
740 if (isnullstartblock(rec.br_startblock))
741 continue;
742 arp = XFS_BMBT_REC_ADDR(mp, ablock, 1 + cnt);
743 xfs_bmbt_disk_set_all(arp, &rec);
744 cnt++;
745 }
746 ASSERT(cnt == ifp->if_nextents);
747 xfs_btree_set_numrecs(ablock, cnt);
748
749 /*
750 * Fill in the root key and pointer.
751 */
752 kp = XFS_BMBT_KEY_ADDR(mp, block, 1);
753 arp = XFS_BMBT_REC_ADDR(mp, ablock, 1);
754 kp->br_startoff = cpu_to_be64(xfs_bmbt_disk_get_startoff(arp));
755 pp = XFS_BMBT_PTR_ADDR(mp, block, 1, xfs_bmbt_get_maxrecs(cur,
756 be16_to_cpu(block->bb_level)));
757 *pp = cpu_to_be64(args.fsbno);
758
759 /*
760 * Do all this logging at the end so that
761 * the root is at the right level.
762 */
763 xfs_btree_log_block(cur, abp, XFS_BB_ALL_BITS);
764 xfs_btree_log_recs(cur, abp, 1, be16_to_cpu(ablock->bb_numrecs));
765 ASSERT(*curp == NULL);
766 *curp = cur;
767 *logflagsp = XFS_ILOG_CORE | xfs_ilog_fbroot(whichfork);
768 return 0;
769
770 out_unreserve_dquot:
771 xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, -1L);
772 out_root_realloc:
773 xfs_iroot_realloc(ip, -1, whichfork);
774 ifp->if_format = XFS_DINODE_FMT_EXTENTS;
775 ASSERT(ifp->if_broot == NULL);
776 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
777
778 return error;
779 }
780
781 /*
782 * Convert a local file to an extents file.
783 * This code is out of bounds for data forks of regular files,
784 * since the file data needs to get logged so things will stay consistent.
785 * (The bmap-level manipulations are ok, though).
786 */
787 void
788 xfs_bmap_local_to_extents_empty(
789 struct xfs_trans *tp,
790 struct xfs_inode *ip,
791 int whichfork)
792 {
793 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
794
795 ASSERT(whichfork != XFS_COW_FORK);
796 ASSERT(ifp->if_format == XFS_DINODE_FMT_LOCAL);
797 ASSERT(ifp->if_bytes == 0);
798 ASSERT(ifp->if_nextents == 0);
799
800 xfs_bmap_forkoff_reset(ip, whichfork);
801 ifp->if_flags &= ~XFS_IFINLINE;
802 ifp->if_flags |= XFS_IFEXTENTS;
803 ifp->if_u1.if_root = NULL;
804 ifp->if_height = 0;
805 ifp->if_format = XFS_DINODE_FMT_EXTENTS;
806 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
807 }
808
809
810 STATIC int /* error */
811 xfs_bmap_local_to_extents(
812 xfs_trans_t *tp, /* transaction pointer */
813 xfs_inode_t *ip, /* incore inode pointer */
814 xfs_extlen_t total, /* total blocks needed by transaction */
815 int *logflagsp, /* inode logging flags */
816 int whichfork,
817 void (*init_fn)(struct xfs_trans *tp,
818 struct xfs_buf *bp,
819 struct xfs_inode *ip,
820 struct xfs_ifork *ifp))
821 {
822 int error = 0;
823 int flags; /* logging flags returned */
824 struct xfs_ifork *ifp; /* inode fork pointer */
825 xfs_alloc_arg_t args; /* allocation arguments */
826 struct xfs_buf *bp; /* buffer for extent block */
827 struct xfs_bmbt_irec rec;
828 struct xfs_iext_cursor icur;
829
830 /*
831 * We don't want to deal with the case of keeping inode data inline yet.
832 * So sending the data fork of a regular inode is invalid.
833 */
834 ASSERT(!(S_ISREG(VFS_I(ip)->i_mode) && whichfork == XFS_DATA_FORK));
835 ifp = XFS_IFORK_PTR(ip, whichfork);
836 ASSERT(ifp->if_format == XFS_DINODE_FMT_LOCAL);
837
838 if (!ifp->if_bytes) {
839 xfs_bmap_local_to_extents_empty(tp, ip, whichfork);
840 flags = XFS_ILOG_CORE;
841 goto done;
842 }
843
844 flags = 0;
845 error = 0;
846 ASSERT((ifp->if_flags & (XFS_IFINLINE|XFS_IFEXTENTS)) == XFS_IFINLINE);
847 memset(&args, 0, sizeof(args));
848 args.tp = tp;
849 args.mp = ip->i_mount;
850 xfs_rmap_ino_owner(&args.oinfo, ip->i_ino, whichfork, 0);
851 /*
852 * Allocate a block. We know we need only one, since the
853 * file currently fits in an inode.
854 */
855 if (tp->t_firstblock == NULLFSBLOCK) {
856 args.fsbno = XFS_INO_TO_FSB(args.mp, ip->i_ino);
857 args.type = XFS_ALLOCTYPE_START_BNO;
858 } else {
859 args.fsbno = tp->t_firstblock;
860 args.type = XFS_ALLOCTYPE_NEAR_BNO;
861 }
862 args.total = total;
863 args.minlen = args.maxlen = args.prod = 1;
864 error = xfs_alloc_vextent(&args);
865 if (error)
866 goto done;
867
868 /* Can't fail, the space was reserved. */
869 ASSERT(args.fsbno != NULLFSBLOCK);
870 ASSERT(args.len == 1);
871 tp->t_firstblock = args.fsbno;
872 error = xfs_trans_get_buf(tp, args.mp->m_ddev_targp,
873 XFS_FSB_TO_DADDR(args.mp, args.fsbno),
874 args.mp->m_bsize, 0, &bp);
875 if (error)
876 goto done;
877
878 /*
879 * Initialize the block, copy the data and log the remote buffer.
880 *
881 * The callout is responsible for logging because the remote format
882 * might differ from the local format and thus we don't know how much to
883 * log here. Note that init_fn must also set the buffer log item type
884 * correctly.
885 */
886 init_fn(tp, bp, ip, ifp);
887
888 /* account for the change in fork size */
889 xfs_idata_realloc(ip, -ifp->if_bytes, whichfork);
890 xfs_bmap_local_to_extents_empty(tp, ip, whichfork);
891 flags |= XFS_ILOG_CORE;
892
893 ifp->if_u1.if_root = NULL;
894 ifp->if_height = 0;
895
896 rec.br_startoff = 0;
897 rec.br_startblock = args.fsbno;
898 rec.br_blockcount = 1;
899 rec.br_state = XFS_EXT_NORM;
900 xfs_iext_first(ifp, &icur);
901 xfs_iext_insert(ip, &icur, &rec, 0);
902
903 ifp->if_nextents = 1;
904 ip->i_d.di_nblocks = 1;
905 xfs_trans_mod_dquot_byino(tp, ip,
906 XFS_TRANS_DQ_BCOUNT, 1L);
907 flags |= xfs_ilog_fext(whichfork);
908
909 done:
910 *logflagsp = flags;
911 return error;
912 }
913
914 /*
915 * Called from xfs_bmap_add_attrfork to handle btree format files.
916 */
917 STATIC int /* error */
918 xfs_bmap_add_attrfork_btree(
919 xfs_trans_t *tp, /* transaction pointer */
920 xfs_inode_t *ip, /* incore inode pointer */
921 int *flags) /* inode logging flags */
922 {
923 xfs_btree_cur_t *cur; /* btree cursor */
924 int error; /* error return value */
925 xfs_mount_t *mp; /* file system mount struct */
926 int stat; /* newroot status */
927
928 mp = ip->i_mount;
929 if (ip->i_df.if_broot_bytes <= XFS_IFORK_DSIZE(ip))
930 *flags |= XFS_ILOG_DBROOT;
931 else {
932 cur = xfs_bmbt_init_cursor(mp, tp, ip, XFS_DATA_FORK);
933 error = xfs_bmbt_lookup_first(cur, &stat);
934 if (error)
935 goto error0;
936 /* must be at least one entry */
937 if (XFS_IS_CORRUPT(mp, stat != 1)) {
938 error = -EFSCORRUPTED;
939 goto error0;
940 }
941 if ((error = xfs_btree_new_iroot(cur, flags, &stat)))
942 goto error0;
943 if (stat == 0) {
944 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
945 return -ENOSPC;
946 }
947 cur->bc_ino.allocated = 0;
948 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
949 }
950 return 0;
951 error0:
952 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
953 return error;
954 }
955
956 /*
957 * Called from xfs_bmap_add_attrfork to handle extents format files.
958 */
959 STATIC int /* error */
960 xfs_bmap_add_attrfork_extents(
961 struct xfs_trans *tp, /* transaction pointer */
962 struct xfs_inode *ip, /* incore inode pointer */
963 int *flags) /* inode logging flags */
964 {
965 xfs_btree_cur_t *cur; /* bmap btree cursor */
966 int error; /* error return value */
967
968 if (ip->i_df.if_nextents * sizeof(struct xfs_bmbt_rec) <=
969 XFS_IFORK_DSIZE(ip))
970 return 0;
971 cur = NULL;
972 error = xfs_bmap_extents_to_btree(tp, ip, &cur, 0, flags,
973 XFS_DATA_FORK);
974 if (cur) {
975 cur->bc_ino.allocated = 0;
976 xfs_btree_del_cursor(cur, error);
977 }
978 return error;
979 }
980
981 /*
982 * Called from xfs_bmap_add_attrfork to handle local format files. Each
983 * different data fork content type needs a different callout to do the
984 * conversion. Some are basic and only require special block initialisation
985 * callouts for the data formating, others (directories) are so specialised they
986 * handle everything themselves.
987 *
988 * XXX (dgc): investigate whether directory conversion can use the generic
989 * formatting callout. It should be possible - it's just a very complex
990 * formatter.
991 */
992 STATIC int /* error */
993 xfs_bmap_add_attrfork_local(
994 struct xfs_trans *tp, /* transaction pointer */
995 struct xfs_inode *ip, /* incore inode pointer */
996 int *flags) /* inode logging flags */
997 {
998 struct xfs_da_args dargs; /* args for dir/attr code */
999
1000 if (ip->i_df.if_bytes <= XFS_IFORK_DSIZE(ip))
1001 return 0;
1002
1003 if (S_ISDIR(VFS_I(ip)->i_mode)) {
1004 memset(&dargs, 0, sizeof(dargs));
1005 dargs.geo = ip->i_mount->m_dir_geo;
1006 dargs.dp = ip;
1007 dargs.total = dargs.geo->fsbcount;
1008 dargs.whichfork = XFS_DATA_FORK;
1009 dargs.trans = tp;
1010 return xfs_dir2_sf_to_block(&dargs);
1011 }
1012
1013 if (S_ISLNK(VFS_I(ip)->i_mode))
1014 return xfs_bmap_local_to_extents(tp, ip, 1, flags,
1015 XFS_DATA_FORK,
1016 xfs_symlink_local_to_remote);
1017
1018 /* should only be called for types that support local format data */
1019 ASSERT(0);
1020 return -EFSCORRUPTED;
1021 }
1022
1023 /* Set an inode attr fork off based on the format */
1024 int
1025 xfs_bmap_set_attrforkoff(
1026 struct xfs_inode *ip,
1027 int size,
1028 int *version)
1029 {
1030 switch (ip->i_df.if_format) {
1031 case XFS_DINODE_FMT_DEV:
1032 ip->i_d.di_forkoff = roundup(sizeof(xfs_dev_t), 8) >> 3;
1033 break;
1034 case XFS_DINODE_FMT_LOCAL:
1035 case XFS_DINODE_FMT_EXTENTS:
1036 case XFS_DINODE_FMT_BTREE:
1037 ip->i_d.di_forkoff = xfs_attr_shortform_bytesfit(ip, size);
1038 if (!ip->i_d.di_forkoff)
1039 ip->i_d.di_forkoff = xfs_default_attroffset(ip) >> 3;
1040 else if ((ip->i_mount->m_flags & XFS_MOUNT_ATTR2) && version)
1041 *version = 2;
1042 break;
1043 default:
1044 ASSERT(0);
1045 return -EINVAL;
1046 }
1047
1048 return 0;
1049 }
1050
1051 /*
1052 * Convert inode from non-attributed to attributed.
1053 * Must not be in a transaction, ip must not be locked.
1054 */
1055 int /* error code */
1056 xfs_bmap_add_attrfork(
1057 xfs_inode_t *ip, /* incore inode pointer */
1058 int size, /* space new attribute needs */
1059 int rsvd) /* xact may use reserved blks */
1060 {
1061 xfs_mount_t *mp; /* mount structure */
1062 xfs_trans_t *tp; /* transaction pointer */
1063 int blks; /* space reservation */
1064 int version = 1; /* superblock attr version */
1065 int logflags; /* logging flags */
1066 int error; /* error return value */
1067
1068 ASSERT(XFS_IFORK_Q(ip) == 0);
1069
1070 mp = ip->i_mount;
1071 ASSERT(!XFS_NOT_DQATTACHED(mp, ip));
1072
1073 blks = XFS_ADDAFORK_SPACE_RES(mp);
1074
1075 error = xfs_trans_alloc_inode(ip, &M_RES(mp)->tr_addafork, blks,
1076 rsvd, &tp);
1077 if (error)
1078 return error;
1079 if (XFS_IFORK_Q(ip))
1080 goto trans_cancel;
1081
1082 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1083 error = xfs_bmap_set_attrforkoff(ip, size, &version);
1084 if (error)
1085 goto trans_cancel;
1086 ASSERT(ip->i_afp == NULL);
1087
1088 ip->i_afp = kmem_cache_zalloc(xfs_ifork_zone,
1089 GFP_KERNEL | __GFP_NOFAIL);
1090
1091 ip->i_afp->if_format = XFS_DINODE_FMT_EXTENTS;
1092 ip->i_afp->if_flags = XFS_IFEXTENTS;
1093 logflags = 0;
1094 switch (ip->i_df.if_format) {
1095 case XFS_DINODE_FMT_LOCAL:
1096 error = xfs_bmap_add_attrfork_local(tp, ip, &logflags);
1097 break;
1098 case XFS_DINODE_FMT_EXTENTS:
1099 error = xfs_bmap_add_attrfork_extents(tp, ip, &logflags);
1100 break;
1101 case XFS_DINODE_FMT_BTREE:
1102 error = xfs_bmap_add_attrfork_btree(tp, ip, &logflags);
1103 break;
1104 default:
1105 error = 0;
1106 break;
1107 }
1108 if (logflags)
1109 xfs_trans_log_inode(tp, ip, logflags);
1110 if (error)
1111 goto trans_cancel;
1112 if (!xfs_sb_version_hasattr(&mp->m_sb) ||
1113 (!xfs_sb_version_hasattr2(&mp->m_sb) && version == 2)) {
1114 bool log_sb = false;
1115
1116 spin_lock(&mp->m_sb_lock);
1117 if (!xfs_sb_version_hasattr(&mp->m_sb)) {
1118 xfs_sb_version_addattr(&mp->m_sb);
1119 log_sb = true;
1120 }
1121 if (!xfs_sb_version_hasattr2(&mp->m_sb) && version == 2) {
1122 xfs_sb_version_addattr2(&mp->m_sb);
1123 log_sb = true;
1124 }
1125 spin_unlock(&mp->m_sb_lock);
1126 if (log_sb)
1127 xfs_log_sb(tp);
1128 }
1129
1130 error = xfs_trans_commit(tp);
1131 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1132 return error;
1133
1134 trans_cancel:
1135 xfs_trans_cancel(tp);
1136 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1137 return error;
1138 }
1139
1140 /*
1141 * Internal and external extent tree search functions.
1142 */
1143
1144 struct xfs_iread_state {
1145 struct xfs_iext_cursor icur;
1146 xfs_extnum_t loaded;
1147 };
1148
1149 /* Stuff every bmbt record from this block into the incore extent map. */
1150 static int
1151 xfs_iread_bmbt_block(
1152 struct xfs_btree_cur *cur,
1153 int level,
1154 void *priv)
1155 {
1156 struct xfs_iread_state *ir = priv;
1157 struct xfs_mount *mp = cur->bc_mp;
1158 struct xfs_inode *ip = cur->bc_ino.ip;
1159 struct xfs_btree_block *block;
1160 struct xfs_buf *bp;
1161 struct xfs_bmbt_rec *frp;
1162 xfs_extnum_t num_recs;
1163 xfs_extnum_t j;
1164 int whichfork = cur->bc_ino.whichfork;
1165 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
1166
1167 block = xfs_btree_get_block(cur, level, &bp);
1168
1169 /* Abort if we find more records than nextents. */
1170 num_recs = xfs_btree_get_numrecs(block);
1171 if (unlikely(ir->loaded + num_recs > ifp->if_nextents)) {
1172 xfs_warn(ip->i_mount, "corrupt dinode %llu, (btree extents).",
1173 (unsigned long long)ip->i_ino);
1174 xfs_inode_verifier_error(ip, -EFSCORRUPTED, __func__, block,
1175 sizeof(*block), __this_address);
1176 return -EFSCORRUPTED;
1177 }
1178
1179 /* Copy records into the incore cache. */
1180 frp = XFS_BMBT_REC_ADDR(mp, block, 1);
1181 for (j = 0; j < num_recs; j++, frp++, ir->loaded++) {
1182 struct xfs_bmbt_irec new;
1183 xfs_failaddr_t fa;
1184
1185 xfs_bmbt_disk_get_all(frp, &new);
1186 fa = xfs_bmap_validate_extent(ip, whichfork, &new);
1187 if (fa) {
1188 xfs_inode_verifier_error(ip, -EFSCORRUPTED,
1189 "xfs_iread_extents(2)", frp,
1190 sizeof(*frp), fa);
1191 return -EFSCORRUPTED;
1192 }
1193 xfs_iext_insert(ip, &ir->icur, &new,
1194 xfs_bmap_fork_to_state(whichfork));
1195 trace_xfs_read_extent(ip, &ir->icur,
1196 xfs_bmap_fork_to_state(whichfork), _THIS_IP_);
1197 xfs_iext_next(ifp, &ir->icur);
1198 }
1199
1200 return 0;
1201 }
1202
1203 /*
1204 * Read in extents from a btree-format inode.
1205 */
1206 int
1207 xfs_iread_extents(
1208 struct xfs_trans *tp,
1209 struct xfs_inode *ip,
1210 int whichfork)
1211 {
1212 struct xfs_iread_state ir;
1213 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
1214 struct xfs_mount *mp = ip->i_mount;
1215 struct xfs_btree_cur *cur;
1216 int error;
1217
1218 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
1219
1220 if (XFS_IS_CORRUPT(mp, ifp->if_format != XFS_DINODE_FMT_BTREE)) {
1221 error = -EFSCORRUPTED;
1222 goto out;
1223 }
1224
1225 ir.loaded = 0;
1226 xfs_iext_first(ifp, &ir.icur);
1227 cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
1228 error = xfs_btree_visit_blocks(cur, xfs_iread_bmbt_block,
1229 XFS_BTREE_VISIT_RECORDS, &ir);
1230 xfs_btree_del_cursor(cur, error);
1231 if (error)
1232 goto out;
1233
1234 if (XFS_IS_CORRUPT(mp, ir.loaded != ifp->if_nextents)) {
1235 error = -EFSCORRUPTED;
1236 goto out;
1237 }
1238 ASSERT(ir.loaded == xfs_iext_count(ifp));
1239
1240 ifp->if_flags |= XFS_IFEXTENTS;
1241 return 0;
1242 out:
1243 xfs_iext_destroy(ifp);
1244 return error;
1245 }
1246
1247 /*
1248 * Returns the relative block number of the first unused block(s) in the given
1249 * fork with at least "len" logically contiguous blocks free. This is the
1250 * lowest-address hole if the fork has holes, else the first block past the end
1251 * of fork. Return 0 if the fork is currently local (in-inode).
1252 */
1253 int /* error */
1254 xfs_bmap_first_unused(
1255 struct xfs_trans *tp, /* transaction pointer */
1256 struct xfs_inode *ip, /* incore inode */
1257 xfs_extlen_t len, /* size of hole to find */
1258 xfs_fileoff_t *first_unused, /* unused block */
1259 int whichfork) /* data or attr fork */
1260 {
1261 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
1262 struct xfs_bmbt_irec got;
1263 struct xfs_iext_cursor icur;
1264 xfs_fileoff_t lastaddr = 0;
1265 xfs_fileoff_t lowest, max;
1266 int error;
1267
1268 if (ifp->if_format == XFS_DINODE_FMT_LOCAL) {
1269 *first_unused = 0;
1270 return 0;
1271 }
1272
1273 ASSERT(xfs_ifork_has_extents(ifp));
1274
1275 if (!(ifp->if_flags & XFS_IFEXTENTS)) {
1276 error = xfs_iread_extents(tp, ip, whichfork);
1277 if (error)
1278 return error;
1279 }
1280
1281 lowest = max = *first_unused;
1282 for_each_xfs_iext(ifp, &icur, &got) {
1283 /*
1284 * See if the hole before this extent will work.
1285 */
1286 if (got.br_startoff >= lowest + len &&
1287 got.br_startoff - max >= len)
1288 break;
1289 lastaddr = got.br_startoff + got.br_blockcount;
1290 max = XFS_FILEOFF_MAX(lastaddr, lowest);
1291 }
1292
1293 *first_unused = max;
1294 return 0;
1295 }
1296
1297 /*
1298 * Returns the file-relative block number of the last block - 1 before
1299 * last_block (input value) in the file.
1300 * This is not based on i_size, it is based on the extent records.
1301 * Returns 0 for local files, as they do not have extent records.
1302 */
1303 int /* error */
1304 xfs_bmap_last_before(
1305 struct xfs_trans *tp, /* transaction pointer */
1306 struct xfs_inode *ip, /* incore inode */
1307 xfs_fileoff_t *last_block, /* last block */
1308 int whichfork) /* data or attr fork */
1309 {
1310 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
1311 struct xfs_bmbt_irec got;
1312 struct xfs_iext_cursor icur;
1313 int error;
1314
1315 switch (ifp->if_format) {
1316 case XFS_DINODE_FMT_LOCAL:
1317 *last_block = 0;
1318 return 0;
1319 case XFS_DINODE_FMT_BTREE:
1320 case XFS_DINODE_FMT_EXTENTS:
1321 break;
1322 default:
1323 ASSERT(0);
1324 return -EFSCORRUPTED;
1325 }
1326
1327 if (!(ifp->if_flags & XFS_IFEXTENTS)) {
1328 error = xfs_iread_extents(tp, ip, whichfork);
1329 if (error)
1330 return error;
1331 }
1332
1333 if (!xfs_iext_lookup_extent_before(ip, ifp, last_block, &icur, &got))
1334 *last_block = 0;
1335 return 0;
1336 }
1337
1338 int
1339 xfs_bmap_last_extent(
1340 struct xfs_trans *tp,
1341 struct xfs_inode *ip,
1342 int whichfork,
1343 struct xfs_bmbt_irec *rec,
1344 int *is_empty)
1345 {
1346 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
1347 struct xfs_iext_cursor icur;
1348 int error;
1349
1350 if (!(ifp->if_flags & XFS_IFEXTENTS)) {
1351 error = xfs_iread_extents(tp, ip, whichfork);
1352 if (error)
1353 return error;
1354 }
1355
1356 xfs_iext_last(ifp, &icur);
1357 if (!xfs_iext_get_extent(ifp, &icur, rec))
1358 *is_empty = 1;
1359 else
1360 *is_empty = 0;
1361 return 0;
1362 }
1363
1364 /*
1365 * Check the last inode extent to determine whether this allocation will result
1366 * in blocks being allocated at the end of the file. When we allocate new data
1367 * blocks at the end of the file which do not start at the previous data block,
1368 * we will try to align the new blocks at stripe unit boundaries.
1369 *
1370 * Returns 1 in bma->aeof if the file (fork) is empty as any new write will be
1371 * at, or past the EOF.
1372 */
1373 STATIC int
1374 xfs_bmap_isaeof(
1375 struct xfs_bmalloca *bma,
1376 int whichfork)
1377 {
1378 struct xfs_bmbt_irec rec;
1379 int is_empty;
1380 int error;
1381
1382 bma->aeof = false;
1383 error = xfs_bmap_last_extent(NULL, bma->ip, whichfork, &rec,
1384 &is_empty);
1385 if (error)
1386 return error;
1387
1388 if (is_empty) {
1389 bma->aeof = true;
1390 return 0;
1391 }
1392
1393 /*
1394 * Check if we are allocation or past the last extent, or at least into
1395 * the last delayed allocated extent.
1396 */
1397 bma->aeof = bma->offset >= rec.br_startoff + rec.br_blockcount ||
1398 (bma->offset >= rec.br_startoff &&
1399 isnullstartblock(rec.br_startblock));
1400 return 0;
1401 }
1402
1403 /*
1404 * Returns the file-relative block number of the first block past eof in
1405 * the file. This is not based on i_size, it is based on the extent records.
1406 * Returns 0 for local files, as they do not have extent records.
1407 */
1408 int
1409 xfs_bmap_last_offset(
1410 struct xfs_inode *ip,
1411 xfs_fileoff_t *last_block,
1412 int whichfork)
1413 {
1414 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
1415 struct xfs_bmbt_irec rec;
1416 int is_empty;
1417 int error;
1418
1419 *last_block = 0;
1420
1421 if (ifp->if_format == XFS_DINODE_FMT_LOCAL)
1422 return 0;
1423
1424 if (XFS_IS_CORRUPT(ip->i_mount, !xfs_ifork_has_extents(ifp)))
1425 return -EFSCORRUPTED;
1426
1427 error = xfs_bmap_last_extent(NULL, ip, whichfork, &rec, &is_empty);
1428 if (error || is_empty)
1429 return error;
1430
1431 *last_block = rec.br_startoff + rec.br_blockcount;
1432 return 0;
1433 }
1434
1435 /*
1436 * Returns whether the selected fork of the inode has exactly one
1437 * block or not. For the data fork we check this matches di_size,
1438 * implying the file's range is 0..bsize-1.
1439 */
1440 int /* 1=>1 block, 0=>otherwise */
1441 xfs_bmap_one_block(
1442 struct xfs_inode *ip, /* incore inode */
1443 int whichfork) /* data or attr fork */
1444 {
1445 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
1446 int rval; /* return value */
1447 struct xfs_bmbt_irec s; /* internal version of extent */
1448 struct xfs_iext_cursor icur;
1449
1450 #ifndef DEBUG
1451 if (whichfork == XFS_DATA_FORK)
1452 return XFS_ISIZE(ip) == ip->i_mount->m_sb.sb_blocksize;
1453 #endif /* !DEBUG */
1454 if (ifp->if_nextents != 1)
1455 return 0;
1456 if (ifp->if_format != XFS_DINODE_FMT_EXTENTS)
1457 return 0;
1458 ASSERT(ifp->if_flags & XFS_IFEXTENTS);
1459 xfs_iext_first(ifp, &icur);
1460 xfs_iext_get_extent(ifp, &icur, &s);
1461 rval = s.br_startoff == 0 && s.br_blockcount == 1;
1462 if (rval && whichfork == XFS_DATA_FORK)
1463 ASSERT(XFS_ISIZE(ip) == ip->i_mount->m_sb.sb_blocksize);
1464 return rval;
1465 }
1466
1467 /*
1468 * Extent tree manipulation functions used during allocation.
1469 */
1470
1471 /*
1472 * Convert a delayed allocation to a real allocation.
1473 */
1474 STATIC int /* error */
1475 xfs_bmap_add_extent_delay_real(
1476 struct xfs_bmalloca *bma,
1477 int whichfork)
1478 {
1479 struct xfs_mount *mp = bma->ip->i_mount;
1480 struct xfs_ifork *ifp = XFS_IFORK_PTR(bma->ip, whichfork);
1481 struct xfs_bmbt_irec *new = &bma->got;
1482 int error; /* error return value */
1483 int i; /* temp state */
1484 xfs_fileoff_t new_endoff; /* end offset of new entry */
1485 xfs_bmbt_irec_t r[3]; /* neighbor extent entries */
1486 /* left is 0, right is 1, prev is 2 */
1487 int rval=0; /* return value (logging flags) */
1488 int state = xfs_bmap_fork_to_state(whichfork);
1489 xfs_filblks_t da_new; /* new count del alloc blocks used */
1490 xfs_filblks_t da_old; /* old count del alloc blocks used */
1491 xfs_filblks_t temp=0; /* value for da_new calculations */
1492 int tmp_rval; /* partial logging flags */
1493 struct xfs_bmbt_irec old;
1494
1495 ASSERT(whichfork != XFS_ATTR_FORK);
1496 ASSERT(!isnullstartblock(new->br_startblock));
1497 ASSERT(!bma->cur ||
1498 (bma->cur->bc_ino.flags & XFS_BTCUR_BMBT_WASDEL));
1499
1500 XFS_STATS_INC(mp, xs_add_exlist);
1501
1502 #define LEFT r[0]
1503 #define RIGHT r[1]
1504 #define PREV r[2]
1505
1506 /*
1507 * Set up a bunch of variables to make the tests simpler.
1508 */
1509 xfs_iext_get_extent(ifp, &bma->icur, &PREV);
1510 new_endoff = new->br_startoff + new->br_blockcount;
1511 ASSERT(isnullstartblock(PREV.br_startblock));
1512 ASSERT(PREV.br_startoff <= new->br_startoff);
1513 ASSERT(PREV.br_startoff + PREV.br_blockcount >= new_endoff);
1514
1515 da_old = startblockval(PREV.br_startblock);
1516 da_new = 0;
1517
1518 /*
1519 * Set flags determining what part of the previous delayed allocation
1520 * extent is being replaced by a real allocation.
1521 */
1522 if (PREV.br_startoff == new->br_startoff)
1523 state |= BMAP_LEFT_FILLING;
1524 if (PREV.br_startoff + PREV.br_blockcount == new_endoff)
1525 state |= BMAP_RIGHT_FILLING;
1526
1527 /*
1528 * Check and set flags if this segment has a left neighbor.
1529 * Don't set contiguous if the combined extent would be too large.
1530 */
1531 if (xfs_iext_peek_prev_extent(ifp, &bma->icur, &LEFT)) {
1532 state |= BMAP_LEFT_VALID;
1533 if (isnullstartblock(LEFT.br_startblock))
1534 state |= BMAP_LEFT_DELAY;
1535 }
1536
1537 if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) &&
1538 LEFT.br_startoff + LEFT.br_blockcount == new->br_startoff &&
1539 LEFT.br_startblock + LEFT.br_blockcount == new->br_startblock &&
1540 LEFT.br_state == new->br_state &&
1541 LEFT.br_blockcount + new->br_blockcount <= MAXEXTLEN)
1542 state |= BMAP_LEFT_CONTIG;
1543
1544 /*
1545 * Check and set flags if this segment has a right neighbor.
1546 * Don't set contiguous if the combined extent would be too large.
1547 * Also check for all-three-contiguous being too large.
1548 */
1549 if (xfs_iext_peek_next_extent(ifp, &bma->icur, &RIGHT)) {
1550 state |= BMAP_RIGHT_VALID;
1551 if (isnullstartblock(RIGHT.br_startblock))
1552 state |= BMAP_RIGHT_DELAY;
1553 }
1554
1555 if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) &&
1556 new_endoff == RIGHT.br_startoff &&
1557 new->br_startblock + new->br_blockcount == RIGHT.br_startblock &&
1558 new->br_state == RIGHT.br_state &&
1559 new->br_blockcount + RIGHT.br_blockcount <= MAXEXTLEN &&
1560 ((state & (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING |
1561 BMAP_RIGHT_FILLING)) !=
1562 (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING |
1563 BMAP_RIGHT_FILLING) ||
1564 LEFT.br_blockcount + new->br_blockcount + RIGHT.br_blockcount
1565 <= MAXEXTLEN))
1566 state |= BMAP_RIGHT_CONTIG;
1567
1568 error = 0;
1569 /*
1570 * Switch out based on the FILLING and CONTIG state bits.
1571 */
1572 switch (state & (BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG |
1573 BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG)) {
1574 case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG |
1575 BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
1576 /*
1577 * Filling in all of a previously delayed allocation extent.
1578 * The left and right neighbors are both contiguous with new.
1579 */
1580 LEFT.br_blockcount += PREV.br_blockcount + RIGHT.br_blockcount;
1581
1582 xfs_iext_remove(bma->ip, &bma->icur, state);
1583 xfs_iext_remove(bma->ip, &bma->icur, state);
1584 xfs_iext_prev(ifp, &bma->icur);
1585 xfs_iext_update_extent(bma->ip, state, &bma->icur, &LEFT);
1586 ifp->if_nextents--;
1587
1588 if (bma->cur == NULL)
1589 rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
1590 else {
1591 rval = XFS_ILOG_CORE;
1592 error = xfs_bmbt_lookup_eq(bma->cur, &RIGHT, &i);
1593 if (error)
1594 goto done;
1595 if (XFS_IS_CORRUPT(mp, i != 1)) {
1596 error = -EFSCORRUPTED;
1597 goto done;
1598 }
1599 error = xfs_btree_delete(bma->cur, &i);
1600 if (error)
1601 goto done;
1602 if (XFS_IS_CORRUPT(mp, i != 1)) {
1603 error = -EFSCORRUPTED;
1604 goto done;
1605 }
1606 error = xfs_btree_decrement(bma->cur, 0, &i);
1607 if (error)
1608 goto done;
1609 if (XFS_IS_CORRUPT(mp, i != 1)) {
1610 error = -EFSCORRUPTED;
1611 goto done;
1612 }
1613 error = xfs_bmbt_update(bma->cur, &LEFT);
1614 if (error)
1615 goto done;
1616 }
1617 break;
1618
1619 case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG:
1620 /*
1621 * Filling in all of a previously delayed allocation extent.
1622 * The left neighbor is contiguous, the right is not.
1623 */
1624 old = LEFT;
1625 LEFT.br_blockcount += PREV.br_blockcount;
1626
1627 xfs_iext_remove(bma->ip, &bma->icur, state);
1628 xfs_iext_prev(ifp, &bma->icur);
1629 xfs_iext_update_extent(bma->ip, state, &bma->icur, &LEFT);
1630
1631 if (bma->cur == NULL)
1632 rval = XFS_ILOG_DEXT;
1633 else {
1634 rval = 0;
1635 error = xfs_bmbt_lookup_eq(bma->cur, &old, &i);
1636 if (error)
1637 goto done;
1638 if (XFS_IS_CORRUPT(mp, i != 1)) {
1639 error = -EFSCORRUPTED;
1640 goto done;
1641 }
1642 error = xfs_bmbt_update(bma->cur, &LEFT);
1643 if (error)
1644 goto done;
1645 }
1646 break;
1647
1648 case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
1649 /*
1650 * Filling in all of a previously delayed allocation extent.
1651 * The right neighbor is contiguous, the left is not. Take care
1652 * with delay -> unwritten extent allocation here because the
1653 * delalloc record we are overwriting is always written.
1654 */
1655 PREV.br_startblock = new->br_startblock;
1656 PREV.br_blockcount += RIGHT.br_blockcount;
1657 PREV.br_state = new->br_state;
1658
1659 xfs_iext_next(ifp, &bma->icur);
1660 xfs_iext_remove(bma->ip, &bma->icur, state);
1661 xfs_iext_prev(ifp, &bma->icur);
1662 xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV);
1663
1664 if (bma->cur == NULL)
1665 rval = XFS_ILOG_DEXT;
1666 else {
1667 rval = 0;
1668 error = xfs_bmbt_lookup_eq(bma->cur, &RIGHT, &i);
1669 if (error)
1670 goto done;
1671 if (XFS_IS_CORRUPT(mp, i != 1)) {
1672 error = -EFSCORRUPTED;
1673 goto done;
1674 }
1675 error = xfs_bmbt_update(bma->cur, &PREV);
1676 if (error)
1677 goto done;
1678 }
1679 break;
1680
1681 case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING:
1682 /*
1683 * Filling in all of a previously delayed allocation extent.
1684 * Neither the left nor right neighbors are contiguous with
1685 * the new one.
1686 */
1687 PREV.br_startblock = new->br_startblock;
1688 PREV.br_state = new->br_state;
1689 xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV);
1690 ifp->if_nextents++;
1691
1692 if (bma->cur == NULL)
1693 rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
1694 else {
1695 rval = XFS_ILOG_CORE;
1696 error = xfs_bmbt_lookup_eq(bma->cur, new, &i);
1697 if (error)
1698 goto done;
1699 if (XFS_IS_CORRUPT(mp, i != 0)) {
1700 error = -EFSCORRUPTED;
1701 goto done;
1702 }
1703 error = xfs_btree_insert(bma->cur, &i);
1704 if (error)
1705 goto done;
1706 if (XFS_IS_CORRUPT(mp, i != 1)) {
1707 error = -EFSCORRUPTED;
1708 goto done;
1709 }
1710 }
1711 break;
1712
1713 case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG:
1714 /*
1715 * Filling in the first part of a previous delayed allocation.
1716 * The left neighbor is contiguous.
1717 */
1718 old = LEFT;
1719 temp = PREV.br_blockcount - new->br_blockcount;
1720 da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp),
1721 startblockval(PREV.br_startblock));
1722
1723 LEFT.br_blockcount += new->br_blockcount;
1724
1725 PREV.br_blockcount = temp;
1726 PREV.br_startoff += new->br_blockcount;
1727 PREV.br_startblock = nullstartblock(da_new);
1728
1729 xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV);
1730 xfs_iext_prev(ifp, &bma->icur);
1731 xfs_iext_update_extent(bma->ip, state, &bma->icur, &LEFT);
1732
1733 if (bma->cur == NULL)
1734 rval = XFS_ILOG_DEXT;
1735 else {
1736 rval = 0;
1737 error = xfs_bmbt_lookup_eq(bma->cur, &old, &i);
1738 if (error)
1739 goto done;
1740 if (XFS_IS_CORRUPT(mp, i != 1)) {
1741 error = -EFSCORRUPTED;
1742 goto done;
1743 }
1744 error = xfs_bmbt_update(bma->cur, &LEFT);
1745 if (error)
1746 goto done;
1747 }
1748 break;
1749
1750 case BMAP_LEFT_FILLING:
1751 /*
1752 * Filling in the first part of a previous delayed allocation.
1753 * The left neighbor is not contiguous.
1754 */
1755 xfs_iext_update_extent(bma->ip, state, &bma->icur, new);
1756 ifp->if_nextents++;
1757
1758 if (bma->cur == NULL)
1759 rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
1760 else {
1761 rval = XFS_ILOG_CORE;
1762 error = xfs_bmbt_lookup_eq(bma->cur, new, &i);
1763 if (error)
1764 goto done;
1765 if (XFS_IS_CORRUPT(mp, i != 0)) {
1766 error = -EFSCORRUPTED;
1767 goto done;
1768 }
1769 error = xfs_btree_insert(bma->cur, &i);
1770 if (error)
1771 goto done;
1772 if (XFS_IS_CORRUPT(mp, i != 1)) {
1773 error = -EFSCORRUPTED;
1774 goto done;
1775 }
1776 }
1777
1778 if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
1779 error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
1780 &bma->cur, 1, &tmp_rval, whichfork);
1781 rval |= tmp_rval;
1782 if (error)
1783 goto done;
1784 }
1785
1786 temp = PREV.br_blockcount - new->br_blockcount;
1787 da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp),
1788 startblockval(PREV.br_startblock) -
1789 (bma->cur ? bma->cur->bc_ino.allocated : 0));
1790
1791 PREV.br_startoff = new_endoff;
1792 PREV.br_blockcount = temp;
1793 PREV.br_startblock = nullstartblock(da_new);
1794 xfs_iext_next(ifp, &bma->icur);
1795 xfs_iext_insert(bma->ip, &bma->icur, &PREV, state);
1796 xfs_iext_prev(ifp, &bma->icur);
1797 break;
1798
1799 case BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
1800 /*
1801 * Filling in the last part of a previous delayed allocation.
1802 * The right neighbor is contiguous with the new allocation.
1803 */
1804 old = RIGHT;
1805 RIGHT.br_startoff = new->br_startoff;
1806 RIGHT.br_startblock = new->br_startblock;
1807 RIGHT.br_blockcount += new->br_blockcount;
1808
1809 if (bma->cur == NULL)
1810 rval = XFS_ILOG_DEXT;
1811 else {
1812 rval = 0;
1813 error = xfs_bmbt_lookup_eq(bma->cur, &old, &i);
1814 if (error)
1815 goto done;
1816 if (XFS_IS_CORRUPT(mp, i != 1)) {
1817 error = -EFSCORRUPTED;
1818 goto done;
1819 }
1820 error = xfs_bmbt_update(bma->cur, &RIGHT);
1821 if (error)
1822 goto done;
1823 }
1824
1825 temp = PREV.br_blockcount - new->br_blockcount;
1826 da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp),
1827 startblockval(PREV.br_startblock));
1828
1829 PREV.br_blockcount = temp;
1830 PREV.br_startblock = nullstartblock(da_new);
1831
1832 xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV);
1833 xfs_iext_next(ifp, &bma->icur);
1834 xfs_iext_update_extent(bma->ip, state, &bma->icur, &RIGHT);
1835 break;
1836
1837 case BMAP_RIGHT_FILLING:
1838 /*
1839 * Filling in the last part of a previous delayed allocation.
1840 * The right neighbor is not contiguous.
1841 */
1842 xfs_iext_update_extent(bma->ip, state, &bma->icur, new);
1843 ifp->if_nextents++;
1844
1845 if (bma->cur == NULL)
1846 rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
1847 else {
1848 rval = XFS_ILOG_CORE;
1849 error = xfs_bmbt_lookup_eq(bma->cur, new, &i);
1850 if (error)
1851 goto done;
1852 if (XFS_IS_CORRUPT(mp, i != 0)) {
1853 error = -EFSCORRUPTED;
1854 goto done;
1855 }
1856 error = xfs_btree_insert(bma->cur, &i);
1857 if (error)
1858 goto done;
1859 if (XFS_IS_CORRUPT(mp, i != 1)) {
1860 error = -EFSCORRUPTED;
1861 goto done;
1862 }
1863 }
1864
1865 if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
1866 error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
1867 &bma->cur, 1, &tmp_rval, whichfork);
1868 rval |= tmp_rval;
1869 if (error)
1870 goto done;
1871 }
1872
1873 temp = PREV.br_blockcount - new->br_blockcount;
1874 da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp),
1875 startblockval(PREV.br_startblock) -
1876 (bma->cur ? bma->cur->bc_ino.allocated : 0));
1877
1878 PREV.br_startblock = nullstartblock(da_new);
1879 PREV.br_blockcount = temp;
1880 xfs_iext_insert(bma->ip, &bma->icur, &PREV, state);
1881 xfs_iext_next(ifp, &bma->icur);
1882 break;
1883
1884 case 0:
1885 /*
1886 * Filling in the middle part of a previous delayed allocation.
1887 * Contiguity is impossible here.
1888 * This case is avoided almost all the time.
1889 *
1890 * We start with a delayed allocation:
1891 *
1892 * +ddddddddddddddddddddddddddddddddddddddddddddddddddddddd+
1893 * PREV @ idx
1894 *
1895 * and we are allocating:
1896 * +rrrrrrrrrrrrrrrrr+
1897 * new
1898 *
1899 * and we set it up for insertion as:
1900 * +ddddddddddddddddddd+rrrrrrrrrrrrrrrrr+ddddddddddddddddd+
1901 * new
1902 * PREV @ idx LEFT RIGHT
1903 * inserted at idx + 1
1904 */
1905 old = PREV;
1906
1907 /* LEFT is the new middle */
1908 LEFT = *new;
1909
1910 /* RIGHT is the new right */
1911 RIGHT.br_state = PREV.br_state;
1912 RIGHT.br_startoff = new_endoff;
1913 RIGHT.br_blockcount =
1914 PREV.br_startoff + PREV.br_blockcount - new_endoff;
1915 RIGHT.br_startblock =
1916 nullstartblock(xfs_bmap_worst_indlen(bma->ip,
1917 RIGHT.br_blockcount));
1918
1919 /* truncate PREV */
1920 PREV.br_blockcount = new->br_startoff - PREV.br_startoff;
1921 PREV.br_startblock =
1922 nullstartblock(xfs_bmap_worst_indlen(bma->ip,
1923 PREV.br_blockcount));
1924 xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV);
1925
1926 xfs_iext_next(ifp, &bma->icur);
1927 xfs_iext_insert(bma->ip, &bma->icur, &RIGHT, state);
1928 xfs_iext_insert(bma->ip, &bma->icur, &LEFT, state);
1929 ifp->if_nextents++;
1930
1931 if (bma->cur == NULL)
1932 rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
1933 else {
1934 rval = XFS_ILOG_CORE;
1935 error = xfs_bmbt_lookup_eq(bma->cur, new, &i);
1936 if (error)
1937 goto done;
1938 if (XFS_IS_CORRUPT(mp, i != 0)) {
1939 error = -EFSCORRUPTED;
1940 goto done;
1941 }
1942 error = xfs_btree_insert(bma->cur, &i);
1943 if (error)
1944 goto done;
1945 if (XFS_IS_CORRUPT(mp, i != 1)) {
1946 error = -EFSCORRUPTED;
1947 goto done;
1948 }
1949 }
1950
1951 if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
1952 error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
1953 &bma->cur, 1, &tmp_rval, whichfork);
1954 rval |= tmp_rval;
1955 if (error)
1956 goto done;
1957 }
1958
1959 da_new = startblockval(PREV.br_startblock) +
1960 startblockval(RIGHT.br_startblock);
1961 break;
1962
1963 case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
1964 case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
1965 case BMAP_LEFT_FILLING | BMAP_RIGHT_CONTIG:
1966 case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG:
1967 case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
1968 case BMAP_LEFT_CONTIG:
1969 case BMAP_RIGHT_CONTIG:
1970 /*
1971 * These cases are all impossible.
1972 */
1973 ASSERT(0);
1974 }
1975
1976 /* add reverse mapping unless caller opted out */
1977 if (!(bma->flags & XFS_BMAPI_NORMAP))
1978 xfs_rmap_map_extent(bma->tp, bma->ip, whichfork, new);
1979
1980 /* convert to a btree if necessary */
1981 if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
1982 int tmp_logflags; /* partial log flag return val */
1983
1984 ASSERT(bma->cur == NULL);
1985 error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
1986 &bma->cur, da_old > 0, &tmp_logflags,
1987 whichfork);
1988 bma->logflags |= tmp_logflags;
1989 if (error)
1990 goto done;
1991 }
1992
1993 if (da_new != da_old)
1994 xfs_mod_delalloc(mp, (int64_t)da_new - da_old);
1995
1996 if (bma->cur) {
1997 da_new += bma->cur->bc_ino.allocated;
1998 bma->cur->bc_ino.allocated = 0;
1999 }
2000
2001 /* adjust for changes in reserved delayed indirect blocks */
2002 if (da_new != da_old) {
2003 ASSERT(state == 0 || da_new < da_old);
2004 error = xfs_mod_fdblocks(mp, (int64_t)(da_old - da_new),
2005 false);
2006 }
2007
2008 xfs_bmap_check_leaf_extents(bma->cur, bma->ip, whichfork);
2009 done:
2010 if (whichfork != XFS_COW_FORK)
2011 bma->logflags |= rval;
2012 return error;
2013 #undef LEFT
2014 #undef RIGHT
2015 #undef PREV
2016 }
2017
2018 /*
2019 * Convert an unwritten allocation to a real allocation or vice versa.
2020 */
2021 int /* error */
2022 xfs_bmap_add_extent_unwritten_real(
2023 struct xfs_trans *tp,
2024 xfs_inode_t *ip, /* incore inode pointer */
2025 int whichfork,
2026 struct xfs_iext_cursor *icur,
2027 xfs_btree_cur_t **curp, /* if *curp is null, not a btree */
2028 xfs_bmbt_irec_t *new, /* new data to add to file extents */
2029 int *logflagsp) /* inode logging flags */
2030 {
2031 xfs_btree_cur_t *cur; /* btree cursor */
2032 int error; /* error return value */
2033 int i; /* temp state */
2034 struct xfs_ifork *ifp; /* inode fork pointer */
2035 xfs_fileoff_t new_endoff; /* end offset of new entry */
2036 xfs_bmbt_irec_t r[3]; /* neighbor extent entries */
2037 /* left is 0, right is 1, prev is 2 */
2038 int rval=0; /* return value (logging flags) */
2039 int state = xfs_bmap_fork_to_state(whichfork);
2040 struct xfs_mount *mp = ip->i_mount;
2041 struct xfs_bmbt_irec old;
2042
2043 *logflagsp = 0;
2044
2045 cur = *curp;
2046 ifp = XFS_IFORK_PTR(ip, whichfork);
2047
2048 ASSERT(!isnullstartblock(new->br_startblock));
2049
2050 XFS_STATS_INC(mp, xs_add_exlist);
2051
2052 #define LEFT r[0]
2053 #define RIGHT r[1]
2054 #define PREV r[2]
2055
2056 /*
2057 * Set up a bunch of variables to make the tests simpler.
2058 */
2059 error = 0;
2060 xfs_iext_get_extent(ifp, icur, &PREV);
2061 ASSERT(new->br_state != PREV.br_state);
2062 new_endoff = new->br_startoff + new->br_blockcount;
2063 ASSERT(PREV.br_startoff <= new->br_startoff);
2064 ASSERT(PREV.br_startoff + PREV.br_blockcount >= new_endoff);
2065
2066 /*
2067 * Set flags determining what part of the previous oldext allocation
2068 * extent is being replaced by a newext allocation.
2069 */
2070 if (PREV.br_startoff == new->br_startoff)
2071 state |= BMAP_LEFT_FILLING;
2072 if (PREV.br_startoff + PREV.br_blockcount == new_endoff)
2073 state |= BMAP_RIGHT_FILLING;
2074
2075 /*
2076 * Check and set flags if this segment has a left neighbor.
2077 * Don't set contiguous if the combined extent would be too large.
2078 */
2079 if (xfs_iext_peek_prev_extent(ifp, icur, &LEFT)) {
2080 state |= BMAP_LEFT_VALID;
2081 if (isnullstartblock(LEFT.br_startblock))
2082 state |= BMAP_LEFT_DELAY;
2083 }
2084
2085 if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) &&
2086 LEFT.br_startoff + LEFT.br_blockcount == new->br_startoff &&
2087 LEFT.br_startblock + LEFT.br_blockcount == new->br_startblock &&
2088 LEFT.br_state == new->br_state &&
2089 LEFT.br_blockcount + new->br_blockcount <= MAXEXTLEN)
2090 state |= BMAP_LEFT_CONTIG;
2091
2092 /*
2093 * Check and set flags if this segment has a right neighbor.
2094 * Don't set contiguous if the combined extent would be too large.
2095 * Also check for all-three-contiguous being too large.
2096 */
2097 if (xfs_iext_peek_next_extent(ifp, icur, &RIGHT)) {
2098 state |= BMAP_RIGHT_VALID;
2099 if (isnullstartblock(RIGHT.br_startblock))
2100 state |= BMAP_RIGHT_DELAY;
2101 }
2102
2103 if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) &&
2104 new_endoff == RIGHT.br_startoff &&
2105 new->br_startblock + new->br_blockcount == RIGHT.br_startblock &&
2106 new->br_state == RIGHT.br_state &&
2107 new->br_blockcount + RIGHT.br_blockcount <= MAXEXTLEN &&
2108 ((state & (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING |
2109 BMAP_RIGHT_FILLING)) !=
2110 (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING |
2111 BMAP_RIGHT_FILLING) ||
2112 LEFT.br_blockcount + new->br_blockcount + RIGHT.br_blockcount
2113 <= MAXEXTLEN))
2114 state |= BMAP_RIGHT_CONTIG;
2115
2116 /*
2117 * Switch out based on the FILLING and CONTIG state bits.
2118 */
2119 switch (state & (BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG |
2120 BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG)) {
2121 case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG |
2122 BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
2123 /*
2124 * Setting all of a previous oldext extent to newext.
2125 * The left and right neighbors are both contiguous with new.
2126 */
2127 LEFT.br_blockcount += PREV.br_blockcount + RIGHT.br_blockcount;
2128
2129 xfs_iext_remove(ip, icur, state);
2130 xfs_iext_remove(ip, icur, state);
2131 xfs_iext_prev(ifp, icur);
2132 xfs_iext_update_extent(ip, state, icur, &LEFT);
2133 ifp->if_nextents -= 2;
2134 if (cur == NULL)
2135 rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
2136 else {
2137 rval = XFS_ILOG_CORE;
2138 error = xfs_bmbt_lookup_eq(cur, &RIGHT, &i);
2139 if (error)
2140 goto done;
2141 if (XFS_IS_CORRUPT(mp, i != 1)) {
2142 error = -EFSCORRUPTED;
2143 goto done;
2144 }
2145 if ((error = xfs_btree_delete(cur, &i)))
2146 goto done;
2147 if (XFS_IS_CORRUPT(mp, i != 1)) {
2148 error = -EFSCORRUPTED;
2149 goto done;
2150 }
2151 if ((error = xfs_btree_decrement(cur, 0, &i)))
2152 goto done;
2153 if (XFS_IS_CORRUPT(mp, i != 1)) {
2154 error = -EFSCORRUPTED;
2155 goto done;
2156 }
2157 if ((error = xfs_btree_delete(cur, &i)))
2158 goto done;
2159 if (XFS_IS_CORRUPT(mp, i != 1)) {
2160 error = -EFSCORRUPTED;
2161 goto done;
2162 }
2163 if ((error = xfs_btree_decrement(cur, 0, &i)))
2164 goto done;
2165 if (XFS_IS_CORRUPT(mp, i != 1)) {
2166 error = -EFSCORRUPTED;
2167 goto done;
2168 }
2169 error = xfs_bmbt_update(cur, &LEFT);
2170 if (error)
2171 goto done;
2172 }
2173 break;
2174
2175 case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG:
2176 /*
2177 * Setting all of a previous oldext extent to newext.
2178 * The left neighbor is contiguous, the right is not.
2179 */
2180 LEFT.br_blockcount += PREV.br_blockcount;
2181
2182 xfs_iext_remove(ip, icur, state);
2183 xfs_iext_prev(ifp, icur);
2184 xfs_iext_update_extent(ip, state, icur, &LEFT);
2185 ifp->if_nextents--;
2186 if (cur == NULL)
2187 rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
2188 else {
2189 rval = XFS_ILOG_CORE;
2190 error = xfs_bmbt_lookup_eq(cur, &PREV, &i);
2191 if (error)
2192 goto done;
2193 if (XFS_IS_CORRUPT(mp, i != 1)) {
2194 error = -EFSCORRUPTED;
2195 goto done;
2196 }
2197 if ((error = xfs_btree_delete(cur, &i)))
2198 goto done;
2199 if (XFS_IS_CORRUPT(mp, i != 1)) {
2200 error = -EFSCORRUPTED;
2201 goto done;
2202 }
2203 if ((error = xfs_btree_decrement(cur, 0, &i)))
2204 goto done;
2205 if (XFS_IS_CORRUPT(mp, i != 1)) {
2206 error = -EFSCORRUPTED;
2207 goto done;
2208 }
2209 error = xfs_bmbt_update(cur, &LEFT);
2210 if (error)
2211 goto done;
2212 }
2213 break;
2214
2215 case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
2216 /*
2217 * Setting all of a previous oldext extent to newext.
2218 * The right neighbor is contiguous, the left is not.
2219 */
2220 PREV.br_blockcount += RIGHT.br_blockcount;
2221 PREV.br_state = new->br_state;
2222
2223 xfs_iext_next(ifp, icur);
2224 xfs_iext_remove(ip, icur, state);
2225 xfs_iext_prev(ifp, icur);
2226 xfs_iext_update_extent(ip, state, icur, &PREV);
2227 ifp->if_nextents--;
2228
2229 if (cur == NULL)
2230 rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
2231 else {
2232 rval = XFS_ILOG_CORE;
2233 error = xfs_bmbt_lookup_eq(cur, &RIGHT, &i);
2234 if (error)
2235 goto done;
2236 if (XFS_IS_CORRUPT(mp, i != 1)) {
2237 error = -EFSCORRUPTED;
2238 goto done;
2239 }
2240 if ((error = xfs_btree_delete(cur, &i)))
2241 goto done;
2242 if (XFS_IS_CORRUPT(mp, i != 1)) {
2243 error = -EFSCORRUPTED;
2244 goto done;
2245 }
2246 if ((error = xfs_btree_decrement(cur, 0, &i)))
2247 goto done;
2248 if (XFS_IS_CORRUPT(mp, i != 1)) {
2249 error = -EFSCORRUPTED;
2250 goto done;
2251 }
2252 error = xfs_bmbt_update(cur, &PREV);
2253 if (error)
2254 goto done;
2255 }
2256 break;
2257
2258 case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING:
2259 /*
2260 * Setting all of a previous oldext extent to newext.
2261 * Neither the left nor right neighbors are contiguous with
2262 * the new one.
2263 */
2264 PREV.br_state = new->br_state;
2265 xfs_iext_update_extent(ip, state, icur, &PREV);
2266
2267 if (cur == NULL)
2268 rval = XFS_ILOG_DEXT;
2269 else {
2270 rval = 0;
2271 error = xfs_bmbt_lookup_eq(cur, new, &i);
2272 if (error)
2273 goto done;
2274 if (XFS_IS_CORRUPT(mp, i != 1)) {
2275 error = -EFSCORRUPTED;
2276 goto done;
2277 }
2278 error = xfs_bmbt_update(cur, &PREV);
2279 if (error)
2280 goto done;
2281 }
2282 break;
2283
2284 case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG:
2285 /*
2286 * Setting the first part of a previous oldext extent to newext.
2287 * The left neighbor is contiguous.
2288 */
2289 LEFT.br_blockcount += new->br_blockcount;
2290
2291 old = PREV;
2292 PREV.br_startoff += new->br_blockcount;
2293 PREV.br_startblock += new->br_blockcount;
2294 PREV.br_blockcount -= new->br_blockcount;
2295
2296 xfs_iext_update_extent(ip, state, icur, &PREV);
2297 xfs_iext_prev(ifp, icur);
2298 xfs_iext_update_extent(ip, state, icur, &LEFT);
2299
2300 if (cur == NULL)
2301 rval = XFS_ILOG_DEXT;
2302 else {
2303 rval = 0;
2304 error = xfs_bmbt_lookup_eq(cur, &old, &i);
2305 if (error)
2306 goto done;
2307 if (XFS_IS_CORRUPT(mp, i != 1)) {
2308 error = -EFSCORRUPTED;
2309 goto done;
2310 }
2311 error = xfs_bmbt_update(cur, &PREV);
2312 if (error)
2313 goto done;
2314 error = xfs_btree_decrement(cur, 0, &i);
2315 if (error)
2316 goto done;
2317 error = xfs_bmbt_update(cur, &LEFT);
2318 if (error)
2319 goto done;
2320 }
2321 break;
2322
2323 case BMAP_LEFT_FILLING:
2324 /*
2325 * Setting the first part of a previous oldext extent to newext.
2326 * The left neighbor is not contiguous.
2327 */
2328 old = PREV;
2329 PREV.br_startoff += new->br_blockcount;
2330 PREV.br_startblock += new->br_blockcount;
2331 PREV.br_blockcount -= new->br_blockcount;
2332
2333 xfs_iext_update_extent(ip, state, icur, &PREV);
2334 xfs_iext_insert(ip, icur, new, state);
2335 ifp->if_nextents++;
2336
2337 if (cur == NULL)
2338 rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
2339 else {
2340 rval = XFS_ILOG_CORE;
2341 error = xfs_bmbt_lookup_eq(cur, &old, &i);
2342 if (error)
2343 goto done;
2344 if (XFS_IS_CORRUPT(mp, i != 1)) {
2345 error = -EFSCORRUPTED;
2346 goto done;
2347 }
2348 error = xfs_bmbt_update(cur, &PREV);
2349 if (error)
2350 goto done;
2351 cur->bc_rec.b = *new;
2352 if ((error = xfs_btree_insert(cur, &i)))
2353 goto done;
2354 if (XFS_IS_CORRUPT(mp, i != 1)) {
2355 error = -EFSCORRUPTED;
2356 goto done;
2357 }
2358 }
2359 break;
2360
2361 case BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
2362 /*
2363 * Setting the last part of a previous oldext extent to newext.
2364 * The right neighbor is contiguous with the new allocation.
2365 */
2366 old = PREV;
2367 PREV.br_blockcount -= new->br_blockcount;
2368
2369 RIGHT.br_startoff = new->br_startoff;
2370 RIGHT.br_startblock = new->br_startblock;
2371 RIGHT.br_blockcount += new->br_blockcount;
2372
2373 xfs_iext_update_extent(ip, state, icur, &PREV);
2374 xfs_iext_next(ifp, icur);
2375 xfs_iext_update_extent(ip, state, icur, &RIGHT);
2376
2377 if (cur == NULL)
2378 rval = XFS_ILOG_DEXT;
2379 else {
2380 rval = 0;
2381 error = xfs_bmbt_lookup_eq(cur, &old, &i);
2382 if (error)
2383 goto done;
2384 if (XFS_IS_CORRUPT(mp, i != 1)) {
2385 error = -EFSCORRUPTED;
2386 goto done;
2387 }
2388 error = xfs_bmbt_update(cur, &PREV);
2389 if (error)
2390 goto done;
2391 error = xfs_btree_increment(cur, 0, &i);
2392 if (error)
2393 goto done;
2394 error = xfs_bmbt_update(cur, &RIGHT);
2395 if (error)
2396 goto done;
2397 }
2398 break;
2399
2400 case BMAP_RIGHT_FILLING:
2401 /*
2402 * Setting the last part of a previous oldext extent to newext.
2403 * The right neighbor is not contiguous.
2404 */
2405 old = PREV;
2406 PREV.br_blockcount -= new->br_blockcount;
2407
2408 xfs_iext_update_extent(ip, state, icur, &PREV);
2409 xfs_iext_next(ifp, icur);
2410 xfs_iext_insert(ip, icur, new, state);
2411 ifp->if_nextents++;
2412
2413 if (cur == NULL)
2414 rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
2415 else {
2416 rval = XFS_ILOG_CORE;
2417 error = xfs_bmbt_lookup_eq(cur, &old, &i);
2418 if (error)
2419 goto done;
2420 if (XFS_IS_CORRUPT(mp, i != 1)) {
2421 error = -EFSCORRUPTED;
2422 goto done;
2423 }
2424 error = xfs_bmbt_update(cur, &PREV);
2425 if (error)
2426 goto done;
2427 error = xfs_bmbt_lookup_eq(cur, new, &i);
2428 if (error)
2429 goto done;
2430 if (XFS_IS_CORRUPT(mp, i != 0)) {
2431 error = -EFSCORRUPTED;
2432 goto done;
2433 }
2434 if ((error = xfs_btree_insert(cur, &i)))
2435 goto done;
2436 if (XFS_IS_CORRUPT(mp, i != 1)) {
2437 error = -EFSCORRUPTED;
2438 goto done;
2439 }
2440 }
2441 break;
2442
2443 case 0:
2444 /*
2445 * Setting the middle part of a previous oldext extent to
2446 * newext. Contiguity is impossible here.
2447 * One extent becomes three extents.
2448 */
2449 old = PREV;
2450 PREV.br_blockcount = new->br_startoff - PREV.br_startoff;
2451
2452 r[0] = *new;
2453 r[1].br_startoff = new_endoff;
2454 r[1].br_blockcount =
2455 old.br_startoff + old.br_blockcount - new_endoff;
2456 r[1].br_startblock = new->br_startblock + new->br_blockcount;
2457 r[1].br_state = PREV.br_state;
2458
2459 xfs_iext_update_extent(ip, state, icur, &PREV);
2460 xfs_iext_next(ifp, icur);
2461 xfs_iext_insert(ip, icur, &r[1], state);
2462 xfs_iext_insert(ip, icur, &r[0], state);
2463 ifp->if_nextents += 2;
2464
2465 if (cur == NULL)
2466 rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
2467 else {
2468 rval = XFS_ILOG_CORE;
2469 error = xfs_bmbt_lookup_eq(cur, &old, &i);
2470 if (error)
2471 goto done;
2472 if (XFS_IS_CORRUPT(mp, i != 1)) {
2473 error = -EFSCORRUPTED;
2474 goto done;
2475 }
2476 /* new right extent - oldext */
2477 error = xfs_bmbt_update(cur, &r[1]);
2478 if (error)
2479 goto done;
2480 /* new left extent - oldext */
2481 cur->bc_rec.b = PREV;
2482 if ((error = xfs_btree_insert(cur, &i)))
2483 goto done;
2484 if (XFS_IS_CORRUPT(mp, i != 1)) {
2485 error = -EFSCORRUPTED;
2486 goto done;
2487 }
2488 /*
2489 * Reset the cursor to the position of the new extent
2490 * we are about to insert as we can't trust it after
2491 * the previous insert.
2492 */
2493 error = xfs_bmbt_lookup_eq(cur, new, &i);
2494 if (error)
2495 goto done;
2496 if (XFS_IS_CORRUPT(mp, i != 0)) {
2497 error = -EFSCORRUPTED;
2498 goto done;
2499 }
2500 /* new middle extent - newext */
2501 if ((error = xfs_btree_insert(cur, &i)))
2502 goto done;
2503 if (XFS_IS_CORRUPT(mp, i != 1)) {
2504 error = -EFSCORRUPTED;
2505 goto done;
2506 }
2507 }
2508 break;
2509
2510 case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
2511 case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
2512 case BMAP_LEFT_FILLING | BMAP_RIGHT_CONTIG:
2513 case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG:
2514 case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
2515 case BMAP_LEFT_CONTIG:
2516 case BMAP_RIGHT_CONTIG:
2517 /*
2518 * These cases are all impossible.
2519 */
2520 ASSERT(0);
2521 }
2522
2523 /* update reverse mappings */
2524 xfs_rmap_convert_extent(mp, tp, ip, whichfork, new);
2525
2526 /* convert to a btree if necessary */
2527 if (xfs_bmap_needs_btree(ip, whichfork)) {
2528 int tmp_logflags; /* partial log flag return val */
2529
2530 ASSERT(cur == NULL);
2531 error = xfs_bmap_extents_to_btree(tp, ip, &cur, 0,
2532 &tmp_logflags, whichfork);
2533 *logflagsp |= tmp_logflags;
2534 if (error)
2535 goto done;
2536 }
2537
2538 /* clear out the allocated field, done with it now in any case. */
2539 if (cur) {
2540 cur->bc_ino.allocated = 0;
2541 *curp = cur;
2542 }
2543
2544 xfs_bmap_check_leaf_extents(*curp, ip, whichfork);
2545 done:
2546 *logflagsp |= rval;
2547 return error;
2548 #undef LEFT
2549 #undef RIGHT
2550 #undef PREV
2551 }
2552
2553 /*
2554 * Convert a hole to a delayed allocation.
2555 */
2556 STATIC void
2557 xfs_bmap_add_extent_hole_delay(
2558 xfs_inode_t *ip, /* incore inode pointer */
2559 int whichfork,
2560 struct xfs_iext_cursor *icur,
2561 xfs_bmbt_irec_t *new) /* new data to add to file extents */
2562 {
2563 struct xfs_ifork *ifp; /* inode fork pointer */
2564 xfs_bmbt_irec_t left; /* left neighbor extent entry */
2565 xfs_filblks_t newlen=0; /* new indirect size */
2566 xfs_filblks_t oldlen=0; /* old indirect size */
2567 xfs_bmbt_irec_t right; /* right neighbor extent entry */
2568 int state = xfs_bmap_fork_to_state(whichfork);
2569 xfs_filblks_t temp; /* temp for indirect calculations */
2570
2571 ifp = XFS_IFORK_PTR(ip, whichfork);
2572 ASSERT(isnullstartblock(new->br_startblock));
2573
2574 /*
2575 * Check and set flags if this segment has a left neighbor
2576 */
2577 if (xfs_iext_peek_prev_extent(ifp, icur, &left)) {
2578 state |= BMAP_LEFT_VALID;
2579 if (isnullstartblock(left.br_startblock))
2580 state |= BMAP_LEFT_DELAY;
2581 }
2582
2583 /*
2584 * Check and set flags if the current (right) segment exists.
2585 * If it doesn't exist, we're converting the hole at end-of-file.
2586 */
2587 if (xfs_iext_get_extent(ifp, icur, &right)) {
2588 state |= BMAP_RIGHT_VALID;
2589 if (isnullstartblock(right.br_startblock))
2590 state |= BMAP_RIGHT_DELAY;
2591 }
2592
2593 /*
2594 * Set contiguity flags on the left and right neighbors.
2595 * Don't let extents get too large, even if the pieces are contiguous.
2596 */
2597 if ((state & BMAP_LEFT_VALID) && (state & BMAP_LEFT_DELAY) &&
2598 left.br_startoff + left.br_blockcount == new->br_startoff &&
2599 left.br_blockcount + new->br_blockcount <= MAXEXTLEN)
2600 state |= BMAP_LEFT_CONTIG;
2601
2602 if ((state & BMAP_RIGHT_VALID) && (state & BMAP_RIGHT_DELAY) &&
2603 new->br_startoff + new->br_blockcount == right.br_startoff &&
2604 new->br_blockcount + right.br_blockcount <= MAXEXTLEN &&
2605 (!(state & BMAP_LEFT_CONTIG) ||
2606 (left.br_blockcount + new->br_blockcount +
2607 right.br_blockcount <= MAXEXTLEN)))
2608 state |= BMAP_RIGHT_CONTIG;
2609
2610 /*
2611 * Switch out based on the contiguity flags.
2612 */
2613 switch (state & (BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG)) {
2614 case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
2615 /*
2616 * New allocation is contiguous with delayed allocations
2617 * on the left and on the right.
2618 * Merge all three into a single extent record.
2619 */
2620 temp = left.br_blockcount + new->br_blockcount +
2621 right.br_blockcount;
2622
2623 oldlen = startblockval(left.br_startblock) +
2624 startblockval(new->br_startblock) +
2625 startblockval(right.br_startblock);
2626 newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp),
2627 oldlen);
2628 left.br_startblock = nullstartblock(newlen);
2629 left.br_blockcount = temp;
2630
2631 xfs_iext_remove(ip, icur, state);
2632 xfs_iext_prev(ifp, icur);
2633 xfs_iext_update_extent(ip, state, icur, &left);
2634 break;
2635
2636 case BMAP_LEFT_CONTIG:
2637 /*
2638 * New allocation is contiguous with a delayed allocation
2639 * on the left.
2640 * Merge the new allocation with the left neighbor.
2641 */
2642 temp = left.br_blockcount + new->br_blockcount;
2643
2644 oldlen = startblockval(left.br_startblock) +
2645 startblockval(new->br_startblock);
2646 newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp),
2647 oldlen);
2648 left.br_blockcount = temp;
2649 left.br_startblock = nullstartblock(newlen);
2650
2651 xfs_iext_prev(ifp, icur);
2652 xfs_iext_update_extent(ip, state, icur, &left);
2653 break;
2654
2655 case BMAP_RIGHT_CONTIG:
2656 /*
2657 * New allocation is contiguous with a delayed allocation
2658 * on the right.
2659 * Merge the new allocation with the right neighbor.
2660 */
2661 temp = new->br_blockcount + right.br_blockcount;
2662 oldlen = startblockval(new->br_startblock) +
2663 startblockval(right.br_startblock);
2664 newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp),
2665 oldlen);
2666 right.br_startoff = new->br_startoff;
2667 right.br_startblock = nullstartblock(newlen);
2668 right.br_blockcount = temp;
2669 xfs_iext_update_extent(ip, state, icur, &right);
2670 break;
2671
2672 case 0:
2673 /*
2674 * New allocation is not contiguous with another
2675 * delayed allocation.
2676 * Insert a new entry.
2677 */
2678 oldlen = newlen = 0;
2679 xfs_iext_insert(ip, icur, new, state);
2680 break;
2681 }
2682 if (oldlen != newlen) {
2683 ASSERT(oldlen > newlen);
2684 xfs_mod_fdblocks(ip->i_mount, (int64_t)(oldlen - newlen),
2685 false);
2686 /*
2687 * Nothing to do for disk quota accounting here.
2688 */
2689 xfs_mod_delalloc(ip->i_mount, (int64_t)newlen - oldlen);
2690 }
2691 }
2692
2693 /*
2694 * Convert a hole to a real allocation.
2695 */
2696 STATIC int /* error */
2697 xfs_bmap_add_extent_hole_real(
2698 struct xfs_trans *tp,
2699 struct xfs_inode *ip,
2700 int whichfork,
2701 struct xfs_iext_cursor *icur,
2702 struct xfs_btree_cur **curp,
2703 struct xfs_bmbt_irec *new,
2704 int *logflagsp,
2705 int flags)
2706 {
2707 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
2708 struct xfs_mount *mp = ip->i_mount;
2709 struct xfs_btree_cur *cur = *curp;
2710 int error; /* error return value */
2711 int i; /* temp state */
2712 xfs_bmbt_irec_t left; /* left neighbor extent entry */
2713 xfs_bmbt_irec_t right; /* right neighbor extent entry */
2714 int rval=0; /* return value (logging flags) */
2715 int state = xfs_bmap_fork_to_state(whichfork);
2716 struct xfs_bmbt_irec old;
2717
2718 ASSERT(!isnullstartblock(new->br_startblock));
2719 ASSERT(!cur || !(cur->bc_ino.flags & XFS_BTCUR_BMBT_WASDEL));
2720
2721 XFS_STATS_INC(mp, xs_add_exlist);
2722
2723 /*
2724 * Check and set flags if this segment has a left neighbor.
2725 */
2726 if (xfs_iext_peek_prev_extent(ifp, icur, &left)) {
2727 state |= BMAP_LEFT_VALID;
2728 if (isnullstartblock(left.br_startblock))
2729 state |= BMAP_LEFT_DELAY;
2730 }
2731
2732 /*
2733 * Check and set flags if this segment has a current value.
2734 * Not true if we're inserting into the "hole" at eof.
2735 */
2736 if (xfs_iext_get_extent(ifp, icur, &right)) {
2737 state |= BMAP_RIGHT_VALID;
2738 if (isnullstartblock(right.br_startblock))
2739 state |= BMAP_RIGHT_DELAY;
2740 }
2741
2742 /*
2743 * We're inserting a real allocation between "left" and "right".
2744 * Set the contiguity flags. Don't let extents get too large.
2745 */
2746 if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) &&
2747 left.br_startoff + left.br_blockcount == new->br_startoff &&
2748 left.br_startblock + left.br_blockcount == new->br_startblock &&
2749 left.br_state == new->br_state &&
2750 left.br_blockcount + new->br_blockcount <= MAXEXTLEN)
2751 state |= BMAP_LEFT_CONTIG;
2752
2753 if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) &&
2754 new->br_startoff + new->br_blockcount == right.br_startoff &&
2755 new->br_startblock + new->br_blockcount == right.br_startblock &&
2756 new->br_state == right.br_state &&
2757 new->br_blockcount + right.br_blockcount <= MAXEXTLEN &&
2758 (!(state & BMAP_LEFT_CONTIG) ||
2759 left.br_blockcount + new->br_blockcount +
2760 right.br_blockcount <= MAXEXTLEN))
2761 state |= BMAP_RIGHT_CONTIG;
2762
2763 error = 0;
2764 /*
2765 * Select which case we're in here, and implement it.
2766 */
2767 switch (state & (BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG)) {
2768 case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
2769 /*
2770 * New allocation is contiguous with real allocations on the
2771 * left and on the right.
2772 * Merge all three into a single extent record.
2773 */
2774 left.br_blockcount += new->br_blockcount + right.br_blockcount;
2775
2776 xfs_iext_remove(ip, icur, state);
2777 xfs_iext_prev(ifp, icur);
2778 xfs_iext_update_extent(ip, state, icur, &left);
2779 ifp->if_nextents--;
2780
2781 if (cur == NULL) {
2782 rval = XFS_ILOG_CORE | xfs_ilog_fext(whichfork);
2783 } else {
2784 rval = XFS_ILOG_CORE;
2785 error = xfs_bmbt_lookup_eq(cur, &right, &i);
2786 if (error)
2787 goto done;
2788 if (XFS_IS_CORRUPT(mp, i != 1)) {
2789 error = -EFSCORRUPTED;
2790 goto done;
2791 }
2792 error = xfs_btree_delete(cur, &i);
2793 if (error)
2794 goto done;
2795 if (XFS_IS_CORRUPT(mp, i != 1)) {
2796 error = -EFSCORRUPTED;
2797 goto done;
2798 }
2799 error = xfs_btree_decrement(cur, 0, &i);
2800 if (error)
2801 goto done;
2802 if (XFS_IS_CORRUPT(mp, i != 1)) {
2803 error = -EFSCORRUPTED;
2804 goto done;
2805 }
2806 error = xfs_bmbt_update(cur, &left);
2807 if (error)
2808 goto done;
2809 }
2810 break;
2811
2812 case BMAP_LEFT_CONTIG:
2813 /*
2814 * New allocation is contiguous with a real allocation
2815 * on the left.
2816 * Merge the new allocation with the left neighbor.
2817 */
2818 old = left;
2819 left.br_blockcount += new->br_blockcount;
2820
2821 xfs_iext_prev(ifp, icur);
2822 xfs_iext_update_extent(ip, state, icur, &left);
2823
2824 if (cur == NULL) {
2825 rval = xfs_ilog_fext(whichfork);
2826 } else {
2827 rval = 0;
2828 error = xfs_bmbt_lookup_eq(cur, &old, &i);
2829 if (error)
2830 goto done;
2831 if (XFS_IS_CORRUPT(mp, i != 1)) {
2832 error = -EFSCORRUPTED;
2833 goto done;
2834 }
2835 error = xfs_bmbt_update(cur, &left);
2836 if (error)
2837 goto done;
2838 }
2839 break;
2840
2841 case BMAP_RIGHT_CONTIG:
2842 /*
2843 * New allocation is contiguous with a real allocation
2844 * on the right.
2845 * Merge the new allocation with the right neighbor.
2846 */
2847 old = right;
2848
2849 right.br_startoff = new->br_startoff;
2850 right.br_startblock = new->br_startblock;
2851 right.br_blockcount += new->br_blockcount;
2852 xfs_iext_update_extent(ip, state, icur, &right);
2853
2854 if (cur == NULL) {
2855 rval = xfs_ilog_fext(whichfork);
2856 } else {
2857 rval = 0;
2858 error = xfs_bmbt_lookup_eq(cur, &old, &i);
2859 if (error)
2860 goto done;
2861 if (XFS_IS_CORRUPT(mp, i != 1)) {
2862 error = -EFSCORRUPTED;
2863 goto done;
2864 }
2865 error = xfs_bmbt_update(cur, &right);
2866 if (error)
2867 goto done;
2868 }
2869 break;
2870
2871 case 0:
2872 /*
2873 * New allocation is not contiguous with another
2874 * real allocation.
2875 * Insert a new entry.
2876 */
2877 xfs_iext_insert(ip, icur, new, state);
2878 ifp->if_nextents++;
2879
2880 if (cur == NULL) {
2881 rval = XFS_ILOG_CORE | xfs_ilog_fext(whichfork);
2882 } else {
2883 rval = XFS_ILOG_CORE;
2884 error = xfs_bmbt_lookup_eq(cur, new, &i);
2885 if (error)
2886 goto done;
2887 if (XFS_IS_CORRUPT(mp, i != 0)) {
2888 error = -EFSCORRUPTED;
2889 goto done;
2890 }
2891 error = xfs_btree_insert(cur, &i);
2892 if (error)
2893 goto done;
2894 if (XFS_IS_CORRUPT(mp, i != 1)) {
2895 error = -EFSCORRUPTED;
2896 goto done;
2897 }
2898 }
2899 break;
2900 }
2901
2902 /* add reverse mapping unless caller opted out */
2903 if (!(flags & XFS_BMAPI_NORMAP))
2904 xfs_rmap_map_extent(tp, ip, whichfork, new);
2905
2906 /* convert to a btree if necessary */
2907 if (xfs_bmap_needs_btree(ip, whichfork)) {
2908 int tmp_logflags; /* partial log flag return val */
2909
2910 ASSERT(cur == NULL);
2911 error = xfs_bmap_extents_to_btree(tp, ip, curp, 0,
2912 &tmp_logflags, whichfork);
2913 *logflagsp |= tmp_logflags;
2914 cur = *curp;
2915 if (error)
2916 goto done;
2917 }
2918
2919 /* clear out the allocated field, done with it now in any case. */
2920 if (cur)
2921 cur->bc_ino.allocated = 0;
2922
2923 xfs_bmap_check_leaf_extents(cur, ip, whichfork);
2924 done:
2925 *logflagsp |= rval;
2926 return error;
2927 }
2928
2929 /*
2930 * Functions used in the extent read, allocate and remove paths
2931 */
2932
2933 /*
2934 * Adjust the size of the new extent based on di_extsize and rt extsize.
2935 */
2936 int
2937 xfs_bmap_extsize_align(
2938 xfs_mount_t *mp,
2939 xfs_bmbt_irec_t *gotp, /* next extent pointer */
2940 xfs_bmbt_irec_t *prevp, /* previous extent pointer */
2941 xfs_extlen_t extsz, /* align to this extent size */
2942 int rt, /* is this a realtime inode? */
2943 int eof, /* is extent at end-of-file? */
2944 int delay, /* creating delalloc extent? */
2945 int convert, /* overwriting unwritten extent? */
2946 xfs_fileoff_t *offp, /* in/out: aligned offset */
2947 xfs_extlen_t *lenp) /* in/out: aligned length */
2948 {
2949 xfs_fileoff_t orig_off; /* original offset */
2950 xfs_extlen_t orig_alen; /* original length */
2951 xfs_fileoff_t orig_end; /* original off+len */
2952 xfs_fileoff_t nexto; /* next file offset */
2953 xfs_fileoff_t prevo; /* previous file offset */
2954 xfs_fileoff_t align_off; /* temp for offset */
2955 xfs_extlen_t align_alen; /* temp for length */
2956 xfs_extlen_t temp; /* temp for calculations */
2957
2958 if (convert)
2959 return 0;
2960
2961 orig_off = align_off = *offp;
2962 orig_alen = align_alen = *lenp;
2963 orig_end = orig_off + orig_alen;
2964
2965 /*
2966 * If this request overlaps an existing extent, then don't
2967 * attempt to perform any additional alignment.
2968 */
2969 if (!delay && !eof &&
2970 (orig_off >= gotp->br_startoff) &&
2971 (orig_end <= gotp->br_startoff + gotp->br_blockcount)) {
2972 return 0;
2973 }
2974
2975 /*
2976 * If the file offset is unaligned vs. the extent size
2977 * we need to align it. This will be possible unless
2978 * the file was previously written with a kernel that didn't
2979 * perform this alignment, or if a truncate shot us in the
2980 * foot.
2981 */
2982 div_u64_rem(orig_off, extsz, &temp);
2983 if (temp) {
2984 align_alen += temp;
2985 align_off -= temp;
2986 }
2987
2988 /* Same adjustment for the end of the requested area. */
2989 temp = (align_alen % extsz);
2990 if (temp)
2991 align_alen += extsz - temp;
2992
2993 /*
2994 * For large extent hint sizes, the aligned extent might be larger than
2995 * MAXEXTLEN. In that case, reduce the size by an extsz so that it pulls
2996 * the length back under MAXEXTLEN. The outer allocation loops handle
2997 * short allocation just fine, so it is safe to do this. We only want to
2998 * do it when we are forced to, though, because it means more allocation
2999 * operations are required.
3000 */
3001 while (align_alen > MAXEXTLEN)
3002 align_alen -= extsz;
3003 ASSERT(align_alen <= MAXEXTLEN);
3004
3005 /*
3006 * If the previous block overlaps with this proposed allocation
3007 * then move the start forward without adjusting the length.
3008 */
3009 if (prevp->br_startoff != NULLFILEOFF) {
3010 if (prevp->br_startblock == HOLESTARTBLOCK)
3011 prevo = prevp->br_startoff;
3012 else
3013 prevo = prevp->br_startoff + prevp->br_blockcount;
3014 } else
3015 prevo = 0;
3016 if (align_off != orig_off && align_off < prevo)
3017 align_off = prevo;
3018 /*
3019 * If the next block overlaps with this proposed allocation
3020 * then move the start back without adjusting the length,
3021 * but not before offset 0.
3022 * This may of course make the start overlap previous block,
3023 * and if we hit the offset 0 limit then the next block
3024 * can still overlap too.
3025 */
3026 if (!eof && gotp->br_startoff != NULLFILEOFF) {
3027 if ((delay && gotp->br_startblock == HOLESTARTBLOCK) ||
3028 (!delay && gotp->br_startblock == DELAYSTARTBLOCK))
3029 nexto = gotp->br_startoff + gotp->br_blockcount;
3030 else
3031 nexto = gotp->br_startoff;
3032 } else
3033 nexto = NULLFILEOFF;
3034 if (!eof &&
3035 align_off + align_alen != orig_end &&
3036 align_off + align_alen > nexto)
3037 align_off = nexto > align_alen ? nexto - align_alen : 0;
3038 /*
3039 * If we're now overlapping the next or previous extent that
3040 * means we can't fit an extsz piece in this hole. Just move
3041 * the start forward to the first valid spot and set
3042 * the length so we hit the end.
3043 */
3044 if (align_off != orig_off && align_off < prevo)
3045 align_off = prevo;
3046 if (align_off + align_alen != orig_end &&
3047 align_off + align_alen > nexto &&
3048 nexto != NULLFILEOFF) {
3049 ASSERT(nexto > prevo);
3050 align_alen = nexto - align_off;
3051 }
3052
3053 /*
3054 * If realtime, and the result isn't a multiple of the realtime
3055 * extent size we need to remove blocks until it is.
3056 */
3057 if (rt && (temp = (align_alen % mp->m_sb.sb_rextsize))) {
3058 /*
3059 * We're not covering the original request, or
3060 * we won't be able to once we fix the length.
3061 */
3062 if (orig_off < align_off ||
3063 orig_end > align_off + align_alen ||
3064 align_alen - temp < orig_alen)
3065 return -EINVAL;
3066 /*
3067 * Try to fix it by moving the start up.
3068 */
3069 if (align_off + temp <= orig_off) {
3070 align_alen -= temp;
3071 align_off += temp;
3072 }
3073 /*
3074 * Try to fix it by moving the end in.
3075 */
3076 else if (align_off + align_alen - temp >= orig_end)
3077 align_alen -= temp;
3078 /*
3079 * Set the start to the minimum then trim the length.
3080 */
3081 else {
3082 align_alen -= orig_off - align_off;
3083 align_off = orig_off;
3084 align_alen -= align_alen % mp->m_sb.sb_rextsize;
3085 }
3086 /*
3087 * Result doesn't cover the request, fail it.
3088 */
3089 if (orig_off < align_off || orig_end > align_off + align_alen)
3090 return -EINVAL;
3091 } else {
3092 ASSERT(orig_off >= align_off);
3093 /* see MAXEXTLEN handling above */
3094 ASSERT(orig_end <= align_off + align_alen ||
3095 align_alen + extsz > MAXEXTLEN);
3096 }
3097
3098 #ifdef DEBUG
3099 if (!eof && gotp->br_startoff != NULLFILEOFF)
3100 ASSERT(align_off + align_alen <= gotp->br_startoff);
3101 if (prevp->br_startoff != NULLFILEOFF)
3102 ASSERT(align_off >= prevp->br_startoff + prevp->br_blockcount);
3103 #endif
3104
3105 *lenp = align_alen;
3106 *offp = align_off;
3107 return 0;
3108 }
3109
3110 #define XFS_ALLOC_GAP_UNITS 4
3111
3112 void
3113 xfs_bmap_adjacent(
3114 struct xfs_bmalloca *ap) /* bmap alloc argument struct */
3115 {
3116 xfs_fsblock_t adjust; /* adjustment to block numbers */
3117 xfs_agnumber_t fb_agno; /* ag number of ap->firstblock */
3118 xfs_mount_t *mp; /* mount point structure */
3119 int nullfb; /* true if ap->firstblock isn't set */
3120 int rt; /* true if inode is realtime */
3121
3122 #define ISVALID(x,y) \
3123 (rt ? \
3124 (x) < mp->m_sb.sb_rblocks : \
3125 XFS_FSB_TO_AGNO(mp, x) == XFS_FSB_TO_AGNO(mp, y) && \
3126 XFS_FSB_TO_AGNO(mp, x) < mp->m_sb.sb_agcount && \
3127 XFS_FSB_TO_AGBNO(mp, x) < mp->m_sb.sb_agblocks)
3128
3129 mp = ap->ip->i_mount;
3130 nullfb = ap->tp->t_firstblock == NULLFSBLOCK;
3131 rt = XFS_IS_REALTIME_INODE(ap->ip) &&
3132 (ap->datatype & XFS_ALLOC_USERDATA);
3133 fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp,
3134 ap->tp->t_firstblock);
3135 /*
3136 * If allocating at eof, and there's a previous real block,
3137 * try to use its last block as our starting point.
3138 */
3139 if (ap->eof && ap->prev.br_startoff != NULLFILEOFF &&
3140 !isnullstartblock(ap->prev.br_startblock) &&
3141 ISVALID(ap->prev.br_startblock + ap->prev.br_blockcount,
3142 ap->prev.br_startblock)) {
3143 ap->blkno = ap->prev.br_startblock + ap->prev.br_blockcount;
3144 /*
3145 * Adjust for the gap between prevp and us.
3146 */
3147 adjust = ap->offset -
3148 (ap->prev.br_startoff + ap->prev.br_blockcount);
3149 if (adjust &&
3150 ISVALID(ap->blkno + adjust, ap->prev.br_startblock))
3151 ap->blkno += adjust;
3152 }
3153 /*
3154 * If not at eof, then compare the two neighbor blocks.
3155 * Figure out whether either one gives us a good starting point,
3156 * and pick the better one.
3157 */
3158 else if (!ap->eof) {
3159 xfs_fsblock_t gotbno; /* right side block number */
3160 xfs_fsblock_t gotdiff=0; /* right side difference */
3161 xfs_fsblock_t prevbno; /* left side block number */
3162 xfs_fsblock_t prevdiff=0; /* left side difference */
3163
3164 /*
3165 * If there's a previous (left) block, select a requested
3166 * start block based on it.
3167 */
3168 if (ap->prev.br_startoff != NULLFILEOFF &&
3169 !isnullstartblock(ap->prev.br_startblock) &&
3170 (prevbno = ap->prev.br_startblock +
3171 ap->prev.br_blockcount) &&
3172 ISVALID(prevbno, ap->prev.br_startblock)) {
3173 /*
3174 * Calculate gap to end of previous block.
3175 */
3176 adjust = prevdiff = ap->offset -
3177 (ap->prev.br_startoff +
3178 ap->prev.br_blockcount);
3179 /*
3180 * Figure the startblock based on the previous block's
3181 * end and the gap size.
3182 * Heuristic!
3183 * If the gap is large relative to the piece we're
3184 * allocating, or using it gives us an invalid block
3185 * number, then just use the end of the previous block.
3186 */
3187 if (prevdiff <= XFS_ALLOC_GAP_UNITS * ap->length &&
3188 ISVALID(prevbno + prevdiff,
3189 ap->prev.br_startblock))
3190 prevbno += adjust;
3191 else
3192 prevdiff += adjust;
3193 /*
3194 * If the firstblock forbids it, can't use it,
3195 * must use default.
3196 */
3197 if (!rt && !nullfb &&
3198 XFS_FSB_TO_AGNO(mp, prevbno) != fb_agno)
3199 prevbno = NULLFSBLOCK;
3200 }
3201 /*
3202 * No previous block or can't follow it, just default.
3203 */
3204 else
3205 prevbno = NULLFSBLOCK;
3206 /*
3207 * If there's a following (right) block, select a requested
3208 * start block based on it.
3209 */
3210 if (!isnullstartblock(ap->got.br_startblock)) {
3211 /*
3212 * Calculate gap to start of next block.
3213 */
3214 adjust = gotdiff = ap->got.br_startoff - ap->offset;
3215 /*
3216 * Figure the startblock based on the next block's
3217 * start and the gap size.
3218 */
3219 gotbno = ap->got.br_startblock;
3220 /*
3221 * Heuristic!
3222 * If the gap is large relative to the piece we're
3223 * allocating, or using it gives us an invalid block
3224 * number, then just use the start of the next block
3225 * offset by our length.
3226 */
3227 if (gotdiff <= XFS_ALLOC_GAP_UNITS * ap->length &&
3228 ISVALID(gotbno - gotdiff, gotbno))
3229 gotbno -= adjust;
3230 else if (ISVALID(gotbno - ap->length, gotbno)) {
3231 gotbno -= ap->length;
3232 gotdiff += adjust - ap->length;
3233 } else
3234 gotdiff += adjust;
3235 /*
3236 * If the firstblock forbids it, can't use it,
3237 * must use default.
3238 */
3239 if (!rt && !nullfb &&
3240 XFS_FSB_TO_AGNO(mp, gotbno) != fb_agno)
3241 gotbno = NULLFSBLOCK;
3242 }
3243 /*
3244 * No next block, just default.
3245 */
3246 else
3247 gotbno = NULLFSBLOCK;
3248 /*
3249 * If both valid, pick the better one, else the only good
3250 * one, else ap->blkno is already set (to 0 or the inode block).
3251 */
3252 if (prevbno != NULLFSBLOCK && gotbno != NULLFSBLOCK)
3253 ap->blkno = prevdiff <= gotdiff ? prevbno : gotbno;
3254 else if (prevbno != NULLFSBLOCK)
3255 ap->blkno = prevbno;
3256 else if (gotbno != NULLFSBLOCK)
3257 ap->blkno = gotbno;
3258 }
3259 #undef ISVALID
3260 }
3261
3262 static int
3263 xfs_bmap_longest_free_extent(
3264 struct xfs_trans *tp,
3265 xfs_agnumber_t ag,
3266 xfs_extlen_t *blen,
3267 int *notinit)
3268 {
3269 struct xfs_mount *mp = tp->t_mountp;
3270 struct xfs_perag *pag;
3271 xfs_extlen_t longest;
3272 int error = 0;
3273
3274 pag = xfs_perag_get(mp, ag);
3275 if (!pag->pagf_init) {
3276 error = xfs_alloc_pagf_init(mp, tp, ag, XFS_ALLOC_FLAG_TRYLOCK);
3277 if (error) {
3278 /* Couldn't lock the AGF, so skip this AG. */
3279 if (error == -EAGAIN) {
3280 *notinit = 1;
3281 error = 0;
3282 }
3283 goto out;
3284 }
3285 }
3286
3287 longest = xfs_alloc_longest_free_extent(pag,
3288 xfs_alloc_min_freelist(mp, pag),
3289 xfs_ag_resv_needed(pag, XFS_AG_RESV_NONE));
3290 if (*blen < longest)
3291 *blen = longest;
3292
3293 out:
3294 xfs_perag_put(pag);
3295 return error;
3296 }
3297
3298 static void
3299 xfs_bmap_select_minlen(
3300 struct xfs_bmalloca *ap,
3301 struct xfs_alloc_arg *args,
3302 xfs_extlen_t *blen,
3303 int notinit)
3304 {
3305 if (notinit || *blen < ap->minlen) {
3306 /*
3307 * Since we did a BUF_TRYLOCK above, it is possible that
3308 * there is space for this request.
3309 */
3310 args->minlen = ap->minlen;
3311 } else if (*blen < args->maxlen) {
3312 /*
3313 * If the best seen length is less than the request length,
3314 * use the best as the minimum.
3315 */
3316 args->minlen = *blen;
3317 } else {
3318 /*
3319 * Otherwise we've seen an extent as big as maxlen, use that
3320 * as the minimum.
3321 */
3322 args->minlen = args->maxlen;
3323 }
3324 }
3325
3326 STATIC int
3327 xfs_bmap_btalloc_nullfb(
3328 struct xfs_bmalloca *ap,
3329 struct xfs_alloc_arg *args,
3330 xfs_extlen_t *blen)
3331 {
3332 struct xfs_mount *mp = ap->ip->i_mount;
3333 xfs_agnumber_t ag, startag;
3334 int notinit = 0;
3335 int error;
3336
3337 args->type = XFS_ALLOCTYPE_START_BNO;
3338 args->total = ap->total;
3339
3340 startag = ag = XFS_FSB_TO_AGNO(mp, args->fsbno);
3341 if (startag == NULLAGNUMBER)
3342 startag = ag = 0;
3343
3344 while (*blen < args->maxlen) {
3345 error = xfs_bmap_longest_free_extent(args->tp, ag, blen,
3346 &notinit);
3347 if (error)
3348 return error;
3349
3350 if (++ag == mp->m_sb.sb_agcount)
3351 ag = 0;
3352 if (ag == startag)
3353 break;
3354 }
3355
3356 xfs_bmap_select_minlen(ap, args, blen, notinit);
3357 return 0;
3358 }
3359
3360 STATIC int
3361 xfs_bmap_btalloc_filestreams(
3362 struct xfs_bmalloca *ap,
3363 struct xfs_alloc_arg *args,
3364 xfs_extlen_t *blen)
3365 {
3366 struct xfs_mount *mp = ap->ip->i_mount;
3367 xfs_agnumber_t ag;
3368 int notinit = 0;
3369 int error;
3370
3371 args->type = XFS_ALLOCTYPE_NEAR_BNO;
3372 args->total = ap->total;
3373
3374 ag = XFS_FSB_TO_AGNO(mp, args->fsbno);
3375 if (ag == NULLAGNUMBER)
3376 ag = 0;
3377
3378 error = xfs_bmap_longest_free_extent(args->tp, ag, blen, &notinit);
3379 if (error)
3380 return error;
3381
3382 if (*blen < args->maxlen) {
3383 error = xfs_filestream_new_ag(ap, &ag);
3384 if (error)
3385 return error;
3386
3387 error = xfs_bmap_longest_free_extent(args->tp, ag, blen,
3388 &notinit);
3389 if (error)
3390 return error;
3391
3392 }
3393
3394 xfs_bmap_select_minlen(ap, args, blen, notinit);
3395
3396 /*
3397 * Set the failure fallback case to look in the selected AG as stream
3398 * may have moved.
3399 */
3400 ap->blkno = args->fsbno = XFS_AGB_TO_FSB(mp, ag, 0);
3401 return 0;
3402 }
3403
3404 /* Update all inode and quota accounting for the allocation we just did. */
3405 static void
3406 xfs_bmap_btalloc_accounting(
3407 struct xfs_bmalloca *ap,
3408 struct xfs_alloc_arg *args)
3409 {
3410 if (ap->flags & XFS_BMAPI_COWFORK) {
3411 /*
3412 * COW fork blocks are in-core only and thus are treated as
3413 * in-core quota reservation (like delalloc blocks) even when
3414 * converted to real blocks. The quota reservation is not
3415 * accounted to disk until blocks are remapped to the data
3416 * fork. So if these blocks were previously delalloc, we
3417 * already have quota reservation and there's nothing to do
3418 * yet.
3419 */
3420 if (ap->wasdel) {
3421 xfs_mod_delalloc(ap->ip->i_mount, -(int64_t)args->len);
3422 return;
3423 }
3424
3425 /*
3426 * Otherwise, we've allocated blocks in a hole. The transaction
3427 * has acquired in-core quota reservation for this extent.
3428 * Rather than account these as real blocks, however, we reduce
3429 * the transaction quota reservation based on the allocation.
3430 * This essentially transfers the transaction quota reservation
3431 * to that of a delalloc extent.
3432 */
3433 ap->ip->i_delayed_blks += args->len;
3434 xfs_trans_mod_dquot_byino(ap->tp, ap->ip, XFS_TRANS_DQ_RES_BLKS,
3435 -(long)args->len);
3436 return;
3437 }
3438
3439 /* data/attr fork only */
3440 ap->ip->i_d.di_nblocks += args->len;
3441 xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE);
3442 if (ap->wasdel) {
3443 ap->ip->i_delayed_blks -= args->len;
3444 xfs_mod_delalloc(ap->ip->i_mount, -(int64_t)args->len);
3445 }
3446 xfs_trans_mod_dquot_byino(ap->tp, ap->ip,
3447 ap->wasdel ? XFS_TRANS_DQ_DELBCOUNT : XFS_TRANS_DQ_BCOUNT,
3448 args->len);
3449 }
3450
3451 static int
3452 xfs_bmap_compute_alignments(
3453 struct xfs_bmalloca *ap,
3454 struct xfs_alloc_arg *args)
3455 {
3456 struct xfs_mount *mp = args->mp;
3457 xfs_extlen_t align = 0; /* minimum allocation alignment */
3458 int stripe_align = 0;
3459
3460 /* stripe alignment for allocation is determined by mount parameters */
3461 if (mp->m_swidth && (mp->m_flags & XFS_MOUNT_SWALLOC))
3462 stripe_align = mp->m_swidth;
3463 else if (mp->m_dalign)
3464 stripe_align = mp->m_dalign;
3465
3466 if (ap->flags & XFS_BMAPI_COWFORK)
3467 align = xfs_get_cowextsz_hint(ap->ip);
3468 else if (ap->datatype & XFS_ALLOC_USERDATA)
3469 align = xfs_get_extsz_hint(ap->ip);
3470 if (align) {
3471 if (xfs_bmap_extsize_align(mp, &ap->got, &ap->prev, align, 0,
3472 ap->eof, 0, ap->conv, &ap->offset,
3473 &ap->length))
3474 ASSERT(0);
3475 ASSERT(ap->length);
3476 }
3477
3478 /* apply extent size hints if obtained earlier */
3479 if (align) {
3480 args->prod = align;
3481 div_u64_rem(ap->offset, args->prod, &args->mod);
3482 if (args->mod)
3483 args->mod = args->prod - args->mod;
3484 } else if (mp->m_sb.sb_blocksize >= PAGE_SIZE) {
3485 args->prod = 1;
3486 args->mod = 0;
3487 } else {
3488 args->prod = PAGE_SIZE >> mp->m_sb.sb_blocklog;
3489 div_u64_rem(ap->offset, args->prod, &args->mod);
3490 if (args->mod)
3491 args->mod = args->prod - args->mod;
3492 }
3493
3494 return stripe_align;
3495 }
3496
3497 static void
3498 xfs_bmap_process_allocated_extent(
3499 struct xfs_bmalloca *ap,
3500 struct xfs_alloc_arg *args,
3501 xfs_fileoff_t orig_offset,
3502 xfs_extlen_t orig_length)
3503 {
3504 int nullfb;
3505
3506 nullfb = ap->tp->t_firstblock == NULLFSBLOCK;
3507
3508 /*
3509 * check the allocation happened at the same or higher AG than
3510 * the first block that was allocated.
3511 */
3512 ASSERT(nullfb ||
3513 XFS_FSB_TO_AGNO(args->mp, ap->tp->t_firstblock) <=
3514 XFS_FSB_TO_AGNO(args->mp, args->fsbno));
3515
3516 ap->blkno = args->fsbno;
3517 if (nullfb)
3518 ap->tp->t_firstblock = args->fsbno;
3519 ap->length = args->len;
3520 /*
3521 * If the extent size hint is active, we tried to round the
3522 * caller's allocation request offset down to extsz and the
3523 * length up to another extsz boundary. If we found a free
3524 * extent we mapped it in starting at this new offset. If the
3525 * newly mapped space isn't long enough to cover any of the
3526 * range of offsets that was originally requested, move the
3527 * mapping up so that we can fill as much of the caller's
3528 * original request as possible. Free space is apparently
3529 * very fragmented so we're unlikely to be able to satisfy the
3530 * hints anyway.
3531 */
3532 if (ap->length <= orig_length)
3533 ap->offset = orig_offset;
3534 else if (ap->offset + ap->length < orig_offset + orig_length)
3535 ap->offset = orig_offset + orig_length - ap->length;
3536 xfs_bmap_btalloc_accounting(ap, args);
3537 }
3538
3539 #ifdef DEBUG
3540 static int
3541 xfs_bmap_exact_minlen_extent_alloc(
3542 struct xfs_bmalloca *ap)
3543 {
3544 struct xfs_mount *mp = ap->ip->i_mount;
3545 struct xfs_alloc_arg args = { .tp = ap->tp, .mp = mp };
3546 xfs_fileoff_t orig_offset;
3547 xfs_extlen_t orig_length;
3548 int error;
3549
3550 ASSERT(ap->length);
3551
3552 if (ap->minlen != 1) {
3553 ap->blkno = NULLFSBLOCK;
3554 ap->length = 0;
3555 return 0;
3556 }
3557
3558 orig_offset = ap->offset;
3559 orig_length = ap->length;
3560
3561 args.alloc_minlen_only = 1;
3562
3563 xfs_bmap_compute_alignments(ap, &args);
3564
3565 if (ap->tp->t_firstblock == NULLFSBLOCK) {
3566 /*
3567 * Unlike the longest extent available in an AG, we don't track
3568 * the length of an AG's shortest extent.
3569 * XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT is a debug only knob and
3570 * hence we can afford to start traversing from the 0th AG since
3571 * we need not be concerned about a drop in performance in
3572 * "debug only" code paths.
3573 */
3574 ap->blkno = XFS_AGB_TO_FSB(mp, 0, 0);
3575 } else {
3576 ap->blkno = ap->tp->t_firstblock;
3577 }
3578
3579 args.fsbno = ap->blkno;
3580 args.oinfo = XFS_RMAP_OINFO_SKIP_UPDATE;
3581 args.type = XFS_ALLOCTYPE_FIRST_AG;
3582 args.total = args.minlen = args.maxlen = ap->minlen;
3583
3584 args.alignment = 1;
3585 args.minalignslop = 0;
3586
3587 args.minleft = ap->minleft;
3588 args.wasdel = ap->wasdel;
3589 args.resv = XFS_AG_RESV_NONE;
3590 args.datatype = ap->datatype;
3591
3592 error = xfs_alloc_vextent(&args);
3593 if (error)
3594 return error;
3595
3596 if (args.fsbno != NULLFSBLOCK) {
3597 xfs_bmap_process_allocated_extent(ap, &args, orig_offset,
3598 orig_length);
3599 } else {
3600 ap->blkno = NULLFSBLOCK;
3601 ap->length = 0;
3602 }
3603
3604 return 0;
3605 }
3606 #else
3607
3608 #define xfs_bmap_exact_minlen_extent_alloc(bma) (-EFSCORRUPTED)
3609
3610 #endif
3611
3612 STATIC int
3613 xfs_bmap_btalloc(
3614 struct xfs_bmalloca *ap)
3615 {
3616 struct xfs_mount *mp = ap->ip->i_mount;
3617 struct xfs_alloc_arg args = { .tp = ap->tp, .mp = mp };
3618 xfs_alloctype_t atype = 0;
3619 xfs_agnumber_t fb_agno; /* ag number of ap->firstblock */
3620 xfs_agnumber_t ag;
3621 xfs_fileoff_t orig_offset;
3622 xfs_extlen_t orig_length;
3623 xfs_extlen_t blen;
3624 xfs_extlen_t nextminlen = 0;
3625 int nullfb; /* true if ap->firstblock isn't set */
3626 int isaligned;
3627 int tryagain;
3628 int error;
3629 int stripe_align;
3630
3631 ASSERT(ap->length);
3632 orig_offset = ap->offset;
3633 orig_length = ap->length;
3634
3635 stripe_align = xfs_bmap_compute_alignments(ap, &args);
3636
3637 nullfb = ap->tp->t_firstblock == NULLFSBLOCK;
3638 fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp,
3639 ap->tp->t_firstblock);
3640 if (nullfb) {
3641 if ((ap->datatype & XFS_ALLOC_USERDATA) &&
3642 xfs_inode_is_filestream(ap->ip)) {
3643 ag = xfs_filestream_lookup_ag(ap->ip);
3644 ag = (ag != NULLAGNUMBER) ? ag : 0;
3645 ap->blkno = XFS_AGB_TO_FSB(mp, ag, 0);
3646 } else {
3647 ap->blkno = XFS_INO_TO_FSB(mp, ap->ip->i_ino);
3648 }
3649 } else
3650 ap->blkno = ap->tp->t_firstblock;
3651
3652 xfs_bmap_adjacent(ap);
3653
3654 /*
3655 * If allowed, use ap->blkno; otherwise must use firstblock since
3656 * it's in the right allocation group.
3657 */
3658 if (nullfb || XFS_FSB_TO_AGNO(mp, ap->blkno) == fb_agno)
3659 ;
3660 else
3661 ap->blkno = ap->tp->t_firstblock;
3662 /*
3663 * Normal allocation, done through xfs_alloc_vextent.
3664 */
3665 tryagain = isaligned = 0;
3666 args.fsbno = ap->blkno;
3667 args.oinfo = XFS_RMAP_OINFO_SKIP_UPDATE;
3668
3669 /* Trim the allocation back to the maximum an AG can fit. */
3670 args.maxlen = min(ap->length, mp->m_ag_max_usable);
3671 blen = 0;
3672 if (nullfb) {
3673 /*
3674 * Search for an allocation group with a single extent large
3675 * enough for the request. If one isn't found, then adjust
3676 * the minimum allocation size to the largest space found.
3677 */
3678 if ((ap->datatype & XFS_ALLOC_USERDATA) &&
3679 xfs_inode_is_filestream(ap->ip))
3680 error = xfs_bmap_btalloc_filestreams(ap, &args, &blen);
3681 else
3682 error = xfs_bmap_btalloc_nullfb(ap, &args, &blen);
3683 if (error)
3684 return error;
3685 } else if (ap->tp->t_flags & XFS_TRANS_LOWMODE) {
3686 if (xfs_inode_is_filestream(ap->ip))
3687 args.type = XFS_ALLOCTYPE_FIRST_AG;
3688 else
3689 args.type = XFS_ALLOCTYPE_START_BNO;
3690 args.total = args.minlen = ap->minlen;
3691 } else {
3692 args.type = XFS_ALLOCTYPE_NEAR_BNO;
3693 args.total = ap->total;
3694 args.minlen = ap->minlen;
3695 }
3696
3697 /*
3698 * If we are not low on available data blocks, and the underlying
3699 * logical volume manager is a stripe, and the file offset is zero then
3700 * try to allocate data blocks on stripe unit boundary. NOTE: ap->aeof
3701 * is only set if the allocation length is >= the stripe unit and the
3702 * allocation offset is at the end of file.
3703 */
3704 if (!(ap->tp->t_flags & XFS_TRANS_LOWMODE) && ap->aeof) {
3705 if (!ap->offset) {
3706 args.alignment = stripe_align;
3707 atype = args.type;
3708 isaligned = 1;
3709 /*
3710 * Adjust minlen to try and preserve alignment if we
3711 * can't guarantee an aligned maxlen extent.
3712 */
3713 if (blen > args.alignment &&
3714 blen <= args.maxlen + args.alignment)
3715 args.minlen = blen - args.alignment;
3716 args.minalignslop = 0;
3717 } else {
3718 /*
3719 * First try an exact bno allocation.
3720 * If it fails then do a near or start bno
3721 * allocation with alignment turned on.
3722 */
3723 atype = args.type;
3724 tryagain = 1;
3725 args.type = XFS_ALLOCTYPE_THIS_BNO;
3726 args.alignment = 1;
3727 /*
3728 * Compute the minlen+alignment for the
3729 * next case. Set slop so that the value
3730 * of minlen+alignment+slop doesn't go up
3731 * between the calls.
3732 */
3733 if (blen > stripe_align && blen <= args.maxlen)
3734 nextminlen = blen - stripe_align;
3735 else
3736 nextminlen = args.minlen;
3737 if (nextminlen + stripe_align > args.minlen + 1)
3738 args.minalignslop =
3739 nextminlen + stripe_align -
3740 args.minlen - 1;
3741 else
3742 args.minalignslop = 0;
3743 }
3744 } else {
3745 args.alignment = 1;
3746 args.minalignslop = 0;
3747 }
3748 args.minleft = ap->minleft;
3749 args.wasdel = ap->wasdel;
3750 args.resv = XFS_AG_RESV_NONE;
3751 args.datatype = ap->datatype;
3752
3753 error = xfs_alloc_vextent(&args);
3754 if (error)
3755 return error;
3756
3757 if (tryagain && args.fsbno == NULLFSBLOCK) {
3758 /*
3759 * Exact allocation failed. Now try with alignment
3760 * turned on.
3761 */
3762 args.type = atype;
3763 args.fsbno = ap->blkno;
3764 args.alignment = stripe_align;
3765 args.minlen = nextminlen;
3766 args.minalignslop = 0;
3767 isaligned = 1;
3768 if ((error = xfs_alloc_vextent(&args)))
3769 return error;
3770 }
3771 if (isaligned && args.fsbno == NULLFSBLOCK) {
3772 /*
3773 * allocation failed, so turn off alignment and
3774 * try again.
3775 */
3776 args.type = atype;
3777 args.fsbno = ap->blkno;
3778 args.alignment = 0;
3779 if ((error = xfs_alloc_vextent(&args)))
3780 return error;
3781 }
3782 if (args.fsbno == NULLFSBLOCK && nullfb &&
3783 args.minlen > ap->minlen) {
3784 args.minlen = ap->minlen;
3785 args.type = XFS_ALLOCTYPE_START_BNO;
3786 args.fsbno = ap->blkno;
3787 if ((error = xfs_alloc_vextent(&args)))
3788 return error;
3789 }
3790 if (args.fsbno == NULLFSBLOCK && nullfb) {
3791 args.fsbno = 0;
3792 args.type = XFS_ALLOCTYPE_FIRST_AG;
3793 args.total = ap->minlen;
3794 if ((error = xfs_alloc_vextent(&args)))
3795 return error;
3796 ap->tp->t_flags |= XFS_TRANS_LOWMODE;
3797 }
3798
3799 if (args.fsbno != NULLFSBLOCK) {
3800 xfs_bmap_process_allocated_extent(ap, &args, orig_offset,
3801 orig_length);
3802 } else {
3803 ap->blkno = NULLFSBLOCK;
3804 ap->length = 0;
3805 }
3806 return 0;
3807 }
3808
3809 /* Trim extent to fit a logical block range. */
3810 void
3811 xfs_trim_extent(
3812 struct xfs_bmbt_irec *irec,
3813 xfs_fileoff_t bno,
3814 xfs_filblks_t len)
3815 {
3816 xfs_fileoff_t distance;
3817 xfs_fileoff_t end = bno + len;
3818
3819 if (irec->br_startoff + irec->br_blockcount <= bno ||
3820 irec->br_startoff >= end) {
3821 irec->br_blockcount = 0;
3822 return;
3823 }
3824
3825 if (irec->br_startoff < bno) {
3826 distance = bno - irec->br_startoff;
3827 if (isnullstartblock(irec->br_startblock))
3828 irec->br_startblock = DELAYSTARTBLOCK;
3829 if (irec->br_startblock != DELAYSTARTBLOCK &&
3830 irec->br_startblock != HOLESTARTBLOCK)
3831 irec->br_startblock += distance;
3832 irec->br_startoff += distance;
3833 irec->br_blockcount -= distance;
3834 }
3835
3836 if (end < irec->br_startoff + irec->br_blockcount) {
3837 distance = irec->br_startoff + irec->br_blockcount - end;
3838 irec->br_blockcount -= distance;
3839 }
3840 }
3841
3842 /*
3843 * Trim the returned map to the required bounds
3844 */
3845 STATIC void
3846 xfs_bmapi_trim_map(
3847 struct xfs_bmbt_irec *mval,
3848 struct xfs_bmbt_irec *got,
3849 xfs_fileoff_t *bno,
3850 xfs_filblks_t len,
3851 xfs_fileoff_t obno,
3852 xfs_fileoff_t end,
3853 int n,
3854 int flags)
3855 {
3856 if ((flags & XFS_BMAPI_ENTIRE) ||
3857 got->br_startoff + got->br_blockcount <= obno) {
3858 *mval = *got;
3859 if (isnullstartblock(got->br_startblock))
3860 mval->br_startblock = DELAYSTARTBLOCK;
3861 return;
3862 }
3863
3864 if (obno > *bno)
3865 *bno = obno;
3866 ASSERT((*bno >= obno) || (n == 0));
3867 ASSERT(*bno < end);
3868 mval->br_startoff = *bno;
3869 if (isnullstartblock(got->br_startblock))
3870 mval->br_startblock = DELAYSTARTBLOCK;
3871 else
3872 mval->br_startblock = got->br_startblock +
3873 (*bno - got->br_startoff);
3874 /*
3875 * Return the minimum of what we got and what we asked for for
3876 * the length. We can use the len variable here because it is
3877 * modified below and we could have been there before coming
3878 * here if the first part of the allocation didn't overlap what
3879 * was asked for.
3880 */
3881 mval->br_blockcount = XFS_FILBLKS_MIN(end - *bno,
3882 got->br_blockcount - (*bno - got->br_startoff));
3883 mval->br_state = got->br_state;
3884 ASSERT(mval->br_blockcount <= len);
3885 return;
3886 }
3887
3888 /*
3889 * Update and validate the extent map to return
3890 */
3891 STATIC void
3892 xfs_bmapi_update_map(
3893 struct xfs_bmbt_irec **map,
3894 xfs_fileoff_t *bno,
3895 xfs_filblks_t *len,
3896 xfs_fileoff_t obno,
3897 xfs_fileoff_t end,
3898 int *n,
3899 int flags)
3900 {
3901 xfs_bmbt_irec_t *mval = *map;
3902
3903 ASSERT((flags & XFS_BMAPI_ENTIRE) ||
3904 ((mval->br_startoff + mval->br_blockcount) <= end));
3905 ASSERT((flags & XFS_BMAPI_ENTIRE) || (mval->br_blockcount <= *len) ||
3906 (mval->br_startoff < obno));
3907
3908 *bno = mval->br_startoff + mval->br_blockcount;
3909 *len = end - *bno;
3910 if (*n > 0 && mval->br_startoff == mval[-1].br_startoff) {
3911 /* update previous map with new information */
3912 ASSERT(mval->br_startblock == mval[-1].br_startblock);
3913 ASSERT(mval->br_blockcount > mval[-1].br_blockcount);
3914 ASSERT(mval->br_state == mval[-1].br_state);
3915 mval[-1].br_blockcount = mval->br_blockcount;
3916 mval[-1].br_state = mval->br_state;
3917 } else if (*n > 0 && mval->br_startblock != DELAYSTARTBLOCK &&
3918 mval[-1].br_startblock != DELAYSTARTBLOCK &&
3919 mval[-1].br_startblock != HOLESTARTBLOCK &&
3920 mval->br_startblock == mval[-1].br_startblock +
3921 mval[-1].br_blockcount &&
3922 mval[-1].br_state == mval->br_state) {
3923 ASSERT(mval->br_startoff ==
3924 mval[-1].br_startoff + mval[-1].br_blockcount);
3925 mval[-1].br_blockcount += mval->br_blockcount;
3926 } else if (*n > 0 &&
3927 mval->br_startblock == DELAYSTARTBLOCK &&
3928 mval[-1].br_startblock == DELAYSTARTBLOCK &&
3929 mval->br_startoff ==
3930 mval[-1].br_startoff + mval[-1].br_blockcount) {
3931 mval[-1].br_blockcount += mval->br_blockcount;
3932 mval[-1].br_state = mval->br_state;
3933 } else if (!((*n == 0) &&
3934 ((mval->br_startoff + mval->br_blockcount) <=
3935 obno))) {
3936 mval++;
3937 (*n)++;
3938 }
3939 *map = mval;
3940 }
3941
3942 /*
3943 * Map file blocks to filesystem blocks without allocation.
3944 */
3945 int
3946 xfs_bmapi_read(
3947 struct xfs_inode *ip,
3948 xfs_fileoff_t bno,
3949 xfs_filblks_t len,
3950 struct xfs_bmbt_irec *mval,
3951 int *nmap,
3952 int flags)
3953 {
3954 struct xfs_mount *mp = ip->i_mount;
3955 int whichfork = xfs_bmapi_whichfork(flags);
3956 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
3957 struct xfs_bmbt_irec got;
3958 xfs_fileoff_t obno;
3959 xfs_fileoff_t end;
3960 struct xfs_iext_cursor icur;
3961 int error;
3962 bool eof = false;
3963 int n = 0;
3964
3965 ASSERT(*nmap >= 1);
3966 ASSERT(!(flags & ~(XFS_BMAPI_ATTRFORK | XFS_BMAPI_ENTIRE)));
3967 ASSERT(xfs_isilocked(ip, XFS_ILOCK_SHARED|XFS_ILOCK_EXCL));
3968
3969 if (WARN_ON_ONCE(!ifp))
3970 return -EFSCORRUPTED;
3971
3972 if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
3973 XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT))
3974 return -EFSCORRUPTED;
3975
3976 if (XFS_FORCED_SHUTDOWN(mp))
3977 return -EIO;
3978
3979 XFS_STATS_INC(mp, xs_blk_mapr);
3980
3981 if (!(ifp->if_flags & XFS_IFEXTENTS)) {
3982 error = xfs_iread_extents(NULL, ip, whichfork);
3983 if (error)
3984 return error;
3985 }
3986
3987 if (!xfs_iext_lookup_extent(ip, ifp, bno, &icur, &got))
3988 eof = true;
3989 end = bno + len;
3990 obno = bno;
3991
3992 while (bno < end && n < *nmap) {
3993 /* Reading past eof, act as though there's a hole up to end. */
3994 if (eof)
3995 got.br_startoff = end;
3996 if (got.br_startoff > bno) {
3997 /* Reading in a hole. */
3998 mval->br_startoff = bno;
3999 mval->br_startblock = HOLESTARTBLOCK;
4000 mval->br_blockcount =
4001 XFS_FILBLKS_MIN(len, got.br_startoff - bno);
4002 mval->br_state = XFS_EXT_NORM;
4003 bno += mval->br_blockcount;
4004 len -= mval->br_blockcount;
4005 mval++;
4006 n++;
4007 continue;
4008 }
4009
4010 /* set up the extent map to return. */
4011 xfs_bmapi_trim_map(mval, &got, &bno, len, obno, end, n, flags);
4012 xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags);
4013
4014 /* If we're done, stop now. */
4015 if (bno >= end || n >= *nmap)
4016 break;
4017
4018 /* Else go on to the next record. */
4019 if (!xfs_iext_next_extent(ifp, &icur, &got))
4020 eof = true;
4021 }
4022 *nmap = n;
4023 return 0;
4024 }
4025
4026 /*
4027 * Add a delayed allocation extent to an inode. Blocks are reserved from the
4028 * global pool and the extent inserted into the inode in-core extent tree.
4029 *
4030 * On entry, got refers to the first extent beyond the offset of the extent to
4031 * allocate or eof is specified if no such extent exists. On return, got refers
4032 * to the extent record that was inserted to the inode fork.
4033 *
4034 * Note that the allocated extent may have been merged with contiguous extents
4035 * during insertion into the inode fork. Thus, got does not reflect the current
4036 * state of the inode fork on return. If necessary, the caller can use lastx to
4037 * look up the updated record in the inode fork.
4038 */
4039 int
4040 xfs_bmapi_reserve_delalloc(
4041 struct xfs_inode *ip,
4042 int whichfork,
4043 xfs_fileoff_t off,
4044 xfs_filblks_t len,
4045 xfs_filblks_t prealloc,
4046 struct xfs_bmbt_irec *got,
4047 struct xfs_iext_cursor *icur,
4048 int eof)
4049 {
4050 struct xfs_mount *mp = ip->i_mount;
4051 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
4052 xfs_extlen_t alen;
4053 xfs_extlen_t indlen;
4054 int error;
4055 xfs_fileoff_t aoff = off;
4056
4057 /*
4058 * Cap the alloc length. Keep track of prealloc so we know whether to
4059 * tag the inode before we return.
4060 */
4061 alen = XFS_FILBLKS_MIN(len + prealloc, MAXEXTLEN);
4062 if (!eof)
4063 alen = XFS_FILBLKS_MIN(alen, got->br_startoff - aoff);
4064 if (prealloc && alen >= len)
4065 prealloc = alen - len;
4066
4067 /* Figure out the extent size, adjust alen */
4068 if (whichfork == XFS_COW_FORK) {
4069 struct xfs_bmbt_irec prev;
4070 xfs_extlen_t extsz = xfs_get_cowextsz_hint(ip);
4071
4072 if (!xfs_iext_peek_prev_extent(ifp, icur, &prev))
4073 prev.br_startoff = NULLFILEOFF;
4074
4075 error = xfs_bmap_extsize_align(mp, got, &prev, extsz, 0, eof,
4076 1, 0, &aoff, &alen);
4077 ASSERT(!error);
4078 }
4079
4080 /*
4081 * Make a transaction-less quota reservation for delayed allocation
4082 * blocks. This number gets adjusted later. We return if we haven't
4083 * allocated blocks already inside this loop.
4084 */
4085 error = xfs_quota_reserve_blkres(ip, alen);
4086 if (error)
4087 return error;
4088
4089 /*
4090 * Split changing sb for alen and indlen since they could be coming
4091 * from different places.
4092 */
4093 indlen = (xfs_extlen_t)xfs_bmap_worst_indlen(ip, alen);
4094 ASSERT(indlen > 0);
4095
4096 error = xfs_mod_fdblocks(mp, -((int64_t)alen), false);
4097 if (error)
4098 goto out_unreserve_quota;
4099
4100 error = xfs_mod_fdblocks(mp, -((int64_t)indlen), false);
4101 if (error)
4102 goto out_unreserve_blocks;
4103
4104
4105 ip->i_delayed_blks += alen;
4106 xfs_mod_delalloc(ip->i_mount, alen + indlen);
4107
4108 got->br_startoff = aoff;
4109 got->br_startblock = nullstartblock(indlen);
4110 got->br_blockcount = alen;
4111 got->br_state = XFS_EXT_NORM;
4112
4113 xfs_bmap_add_extent_hole_delay(ip, whichfork, icur, got);
4114
4115 /*
4116 * Tag the inode if blocks were preallocated. Note that COW fork
4117 * preallocation can occur at the start or end of the extent, even when
4118 * prealloc == 0, so we must also check the aligned offset and length.
4119 */
4120 if (whichfork == XFS_DATA_FORK && prealloc)
4121 xfs_inode_set_eofblocks_tag(ip);
4122 if (whichfork == XFS_COW_FORK && (prealloc || aoff < off || alen > len))
4123 xfs_inode_set_cowblocks_tag(ip);
4124
4125 return 0;
4126
4127 out_unreserve_blocks:
4128 xfs_mod_fdblocks(mp, alen, false);
4129 out_unreserve_quota:
4130 if (XFS_IS_QUOTA_ON(mp))
4131 xfs_quota_unreserve_blkres(ip, alen);
4132 return error;
4133 }
4134
4135 static int
4136 xfs_bmap_alloc_userdata(
4137 struct xfs_bmalloca *bma)
4138 {
4139 struct xfs_mount *mp = bma->ip->i_mount;
4140 int whichfork = xfs_bmapi_whichfork(bma->flags);
4141 int error;
4142
4143 /*
4144 * Set the data type being allocated. For the data fork, the first data
4145 * in the file is treated differently to all other allocations. For the
4146 * attribute fork, we only need to ensure the allocated range is not on
4147 * the busy list.
4148 */
4149 bma->datatype = XFS_ALLOC_NOBUSY;
4150 if (whichfork == XFS_DATA_FORK) {
4151 bma->datatype |= XFS_ALLOC_USERDATA;
4152 if (bma->offset == 0)
4153 bma->datatype |= XFS_ALLOC_INITIAL_USER_DATA;
4154
4155 if (mp->m_dalign && bma->length >= mp->m_dalign) {
4156 error = xfs_bmap_isaeof(bma, whichfork);
4157 if (error)
4158 return error;
4159 }
4160
4161 if (XFS_IS_REALTIME_INODE(bma->ip))
4162 return xfs_bmap_rtalloc(bma);
4163 }
4164
4165 if (unlikely(XFS_TEST_ERROR(false, mp,
4166 XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT)))
4167 return xfs_bmap_exact_minlen_extent_alloc(bma);
4168
4169 return xfs_bmap_btalloc(bma);
4170 }
4171
4172 static int
4173 xfs_bmapi_allocate(
4174 struct xfs_bmalloca *bma)
4175 {
4176 struct xfs_mount *mp = bma->ip->i_mount;
4177 int whichfork = xfs_bmapi_whichfork(bma->flags);
4178 struct xfs_ifork *ifp = XFS_IFORK_PTR(bma->ip, whichfork);
4179 int tmp_logflags = 0;
4180 int error;
4181
4182 ASSERT(bma->length > 0);
4183
4184 /*
4185 * For the wasdelay case, we could also just allocate the stuff asked
4186 * for in this bmap call but that wouldn't be as good.
4187 */
4188 if (bma->wasdel) {
4189 bma->length = (xfs_extlen_t)bma->got.br_blockcount;
4190 bma->offset = bma->got.br_startoff;
4191 if (!xfs_iext_peek_prev_extent(ifp, &bma->icur, &bma->prev))
4192 bma->prev.br_startoff = NULLFILEOFF;
4193 } else {
4194 bma->length = XFS_FILBLKS_MIN(bma->length, MAXEXTLEN);
4195 if (!bma->eof)
4196 bma->length = XFS_FILBLKS_MIN(bma->length,
4197 bma->got.br_startoff - bma->offset);
4198 }
4199
4200 if (bma->flags & XFS_BMAPI_CONTIG)
4201 bma->minlen = bma->length;
4202 else
4203 bma->minlen = 1;
4204
4205 if (bma->flags & XFS_BMAPI_METADATA) {
4206 if (unlikely(XFS_TEST_ERROR(false, mp,
4207 XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT)))
4208 error = xfs_bmap_exact_minlen_extent_alloc(bma);
4209 else
4210 error = xfs_bmap_btalloc(bma);
4211 } else {
4212 error = xfs_bmap_alloc_userdata(bma);
4213 }
4214 if (error || bma->blkno == NULLFSBLOCK)
4215 return error;
4216
4217 if (bma->flags & XFS_BMAPI_ZERO) {
4218 error = xfs_zero_extent(bma->ip, bma->blkno, bma->length);
4219 if (error)
4220 return error;
4221 }
4222
4223 if ((ifp->if_flags & XFS_IFBROOT) && !bma->cur)
4224 bma->cur = xfs_bmbt_init_cursor(mp, bma->tp, bma->ip, whichfork);
4225 /*
4226 * Bump the number of extents we've allocated
4227 * in this call.
4228 */
4229 bma->nallocs++;
4230
4231 if (bma->cur)
4232 bma->cur->bc_ino.flags =
4233 bma->wasdel ? XFS_BTCUR_BMBT_WASDEL : 0;
4234
4235 bma->got.br_startoff = bma->offset;
4236 bma->got.br_startblock = bma->blkno;
4237 bma->got.br_blockcount = bma->length;
4238 bma->got.br_state = XFS_EXT_NORM;
4239
4240 if (bma->flags & XFS_BMAPI_PREALLOC)
4241 bma->got.br_state = XFS_EXT_UNWRITTEN;
4242
4243 if (bma->wasdel)
4244 error = xfs_bmap_add_extent_delay_real(bma, whichfork);
4245 else
4246 error = xfs_bmap_add_extent_hole_real(bma->tp, bma->ip,
4247 whichfork, &bma->icur, &bma->cur, &bma->got,
4248 &bma->logflags, bma->flags);
4249
4250 bma->logflags |= tmp_logflags;
4251 if (error)
4252 return error;
4253
4254 /*
4255 * Update our extent pointer, given that xfs_bmap_add_extent_delay_real
4256 * or xfs_bmap_add_extent_hole_real might have merged it into one of
4257 * the neighbouring ones.
4258 */
4259 xfs_iext_get_extent(ifp, &bma->icur, &bma->got);
4260
4261 ASSERT(bma->got.br_startoff <= bma->offset);
4262 ASSERT(bma->got.br_startoff + bma->got.br_blockcount >=
4263 bma->offset + bma->length);
4264 ASSERT(bma->got.br_state == XFS_EXT_NORM ||
4265 bma->got.br_state == XFS_EXT_UNWRITTEN);
4266 return 0;
4267 }
4268
4269 STATIC int
4270 xfs_bmapi_convert_unwritten(
4271 struct xfs_bmalloca *bma,
4272 struct xfs_bmbt_irec *mval,
4273 xfs_filblks_t len,
4274 int flags)
4275 {
4276 int whichfork = xfs_bmapi_whichfork(flags);
4277 struct xfs_ifork *ifp = XFS_IFORK_PTR(bma->ip, whichfork);
4278 int tmp_logflags = 0;
4279 int error;
4280
4281 /* check if we need to do unwritten->real conversion */
4282 if (mval->br_state == XFS_EXT_UNWRITTEN &&
4283 (flags & XFS_BMAPI_PREALLOC))
4284 return 0;
4285
4286 /* check if we need to do real->unwritten conversion */
4287 if (mval->br_state == XFS_EXT_NORM &&
4288 (flags & (XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT)) !=
4289 (XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT))
4290 return 0;
4291
4292 /*
4293 * Modify (by adding) the state flag, if writing.
4294 */
4295 ASSERT(mval->br_blockcount <= len);
4296 if ((ifp->if_flags & XFS_IFBROOT) && !bma->cur) {
4297 bma->cur = xfs_bmbt_init_cursor(bma->ip->i_mount, bma->tp,
4298 bma->ip, whichfork);
4299 }
4300 mval->br_state = (mval->br_state == XFS_EXT_UNWRITTEN)
4301 ? XFS_EXT_NORM : XFS_EXT_UNWRITTEN;
4302
4303 /*
4304 * Before insertion into the bmbt, zero the range being converted
4305 * if required.
4306 */
4307 if (flags & XFS_BMAPI_ZERO) {
4308 error = xfs_zero_extent(bma->ip, mval->br_startblock,
4309 mval->br_blockcount);
4310 if (error)
4311 return error;
4312 }
4313
4314 error = xfs_bmap_add_extent_unwritten_real(bma->tp, bma->ip, whichfork,
4315 &bma->icur, &bma->cur, mval, &tmp_logflags);
4316 /*
4317 * Log the inode core unconditionally in the unwritten extent conversion
4318 * path because the conversion might not have done so (e.g., if the
4319 * extent count hasn't changed). We need to make sure the inode is dirty
4320 * in the transaction for the sake of fsync(), even if nothing has
4321 * changed, because fsync() will not force the log for this transaction
4322 * unless it sees the inode pinned.
4323 *
4324 * Note: If we're only converting cow fork extents, there aren't
4325 * any on-disk updates to make, so we don't need to log anything.
4326 */
4327 if (whichfork != XFS_COW_FORK)
4328 bma->logflags |= tmp_logflags | XFS_ILOG_CORE;
4329 if (error)
4330 return error;
4331
4332 /*
4333 * Update our extent pointer, given that
4334 * xfs_bmap_add_extent_unwritten_real might have merged it into one
4335 * of the neighbouring ones.
4336 */
4337 xfs_iext_get_extent(ifp, &bma->icur, &bma->got);
4338
4339 /*
4340 * We may have combined previously unwritten space with written space,
4341 * so generate another request.
4342 */
4343 if (mval->br_blockcount < len)
4344 return -EAGAIN;
4345 return 0;
4346 }
4347
4348 static inline xfs_extlen_t
4349 xfs_bmapi_minleft(
4350 struct xfs_trans *tp,
4351 struct xfs_inode *ip,
4352 int fork)
4353 {
4354 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, fork);
4355
4356 if (tp && tp->t_firstblock != NULLFSBLOCK)
4357 return 0;
4358 if (ifp->if_format != XFS_DINODE_FMT_BTREE)
4359 return 1;
4360 return be16_to_cpu(ifp->if_broot->bb_level) + 1;
4361 }
4362
4363 /*
4364 * Log whatever the flags say, even if error. Otherwise we might miss detecting
4365 * a case where the data is changed, there's an error, and it's not logged so we
4366 * don't shutdown when we should. Don't bother logging extents/btree changes if
4367 * we converted to the other format.
4368 */
4369 static void
4370 xfs_bmapi_finish(
4371 struct xfs_bmalloca *bma,
4372 int whichfork,
4373 int error)
4374 {
4375 struct xfs_ifork *ifp = XFS_IFORK_PTR(bma->ip, whichfork);
4376
4377 if ((bma->logflags & xfs_ilog_fext(whichfork)) &&
4378 ifp->if_format != XFS_DINODE_FMT_EXTENTS)
4379 bma->logflags &= ~xfs_ilog_fext(whichfork);
4380 else if ((bma->logflags & xfs_ilog_fbroot(whichfork)) &&
4381 ifp->if_format != XFS_DINODE_FMT_BTREE)
4382 bma->logflags &= ~xfs_ilog_fbroot(whichfork);
4383
4384 if (bma->logflags)
4385 xfs_trans_log_inode(bma->tp, bma->ip, bma->logflags);
4386 if (bma->cur)
4387 xfs_btree_del_cursor(bma->cur, error);
4388 }
4389
4390 /*
4391 * Map file blocks to filesystem blocks, and allocate blocks or convert the
4392 * extent state if necessary. Details behaviour is controlled by the flags
4393 * parameter. Only allocates blocks from a single allocation group, to avoid
4394 * locking problems.
4395 */
4396 int
4397 xfs_bmapi_write(
4398 struct xfs_trans *tp, /* transaction pointer */
4399 struct xfs_inode *ip, /* incore inode */
4400 xfs_fileoff_t bno, /* starting file offs. mapped */
4401 xfs_filblks_t len, /* length to map in file */
4402 int flags, /* XFS_BMAPI_... */
4403 xfs_extlen_t total, /* total blocks needed */
4404 struct xfs_bmbt_irec *mval, /* output: map values */
4405 int *nmap) /* i/o: mval size/count */
4406 {
4407 struct xfs_bmalloca bma = {
4408 .tp = tp,
4409 .ip = ip,
4410 .total = total,
4411 };
4412 struct xfs_mount *mp = ip->i_mount;
4413 int whichfork = xfs_bmapi_whichfork(flags);
4414 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
4415 xfs_fileoff_t end; /* end of mapped file region */
4416 bool eof = false; /* after the end of extents */
4417 int error; /* error return */
4418 int n; /* current extent index */
4419 xfs_fileoff_t obno; /* old block number (offset) */
4420
4421 #ifdef DEBUG
4422 xfs_fileoff_t orig_bno; /* original block number value */
4423 int orig_flags; /* original flags arg value */
4424 xfs_filblks_t orig_len; /* original value of len arg */
4425 struct xfs_bmbt_irec *orig_mval; /* original value of mval */
4426 int orig_nmap; /* original value of *nmap */
4427
4428 orig_bno = bno;
4429 orig_len = len;
4430 orig_flags = flags;
4431 orig_mval = mval;
4432 orig_nmap = *nmap;
4433 #endif
4434
4435 ASSERT(*nmap >= 1);
4436 ASSERT(*nmap <= XFS_BMAP_MAX_NMAP);
4437 ASSERT(tp != NULL);
4438 ASSERT(len > 0);
4439 ASSERT(ifp->if_format != XFS_DINODE_FMT_LOCAL);
4440 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
4441 ASSERT(!(flags & XFS_BMAPI_REMAP));
4442
4443 /* zeroing is for currently only for data extents, not metadata */
4444 ASSERT((flags & (XFS_BMAPI_METADATA | XFS_BMAPI_ZERO)) !=
4445 (XFS_BMAPI_METADATA | XFS_BMAPI_ZERO));
4446 /*
4447 * we can allocate unwritten extents or pre-zero allocated blocks,
4448 * but it makes no sense to do both at once. This would result in
4449 * zeroing the unwritten extent twice, but it still being an
4450 * unwritten extent....
4451 */
4452 ASSERT((flags & (XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO)) !=
4453 (XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO));
4454
4455 if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
4456 XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
4457 return -EFSCORRUPTED;
4458 }
4459
4460 if (XFS_FORCED_SHUTDOWN(mp))
4461 return -EIO;
4462
4463 XFS_STATS_INC(mp, xs_blk_mapw);
4464
4465 if (!(ifp->if_flags & XFS_IFEXTENTS)) {
4466 error = xfs_iread_extents(tp, ip, whichfork);
4467 if (error)
4468 goto error0;
4469 }
4470
4471 if (!xfs_iext_lookup_extent(ip, ifp, bno, &bma.icur, &bma.got))
4472 eof = true;
4473 if (!xfs_iext_peek_prev_extent(ifp, &bma.icur, &bma.prev))
4474 bma.prev.br_startoff = NULLFILEOFF;
4475 bma.minleft = xfs_bmapi_minleft(tp, ip, whichfork);
4476
4477 n = 0;
4478 end = bno + len;
4479 obno = bno;
4480 while (bno < end && n < *nmap) {
4481 bool need_alloc = false, wasdelay = false;
4482
4483 /* in hole or beyond EOF? */
4484 if (eof || bma.got.br_startoff > bno) {
4485 /*
4486 * CoW fork conversions should /never/ hit EOF or
4487 * holes. There should always be something for us
4488 * to work on.
4489 */
4490 ASSERT(!((flags & XFS_BMAPI_CONVERT) &&
4491 (flags & XFS_BMAPI_COWFORK)));
4492
4493 need_alloc = true;
4494 } else if (isnullstartblock(bma.got.br_startblock)) {
4495 wasdelay = true;
4496 }
4497
4498 /*
4499 * First, deal with the hole before the allocated space
4500 * that we found, if any.
4501 */
4502 if (need_alloc || wasdelay) {
4503 bma.eof = eof;
4504 bma.conv = !!(flags & XFS_BMAPI_CONVERT);
4505 bma.wasdel = wasdelay;
4506 bma.offset = bno;
4507 bma.flags = flags;
4508
4509 /*
4510 * There's a 32/64 bit type mismatch between the
4511 * allocation length request (which can be 64 bits in
4512 * length) and the bma length request, which is
4513 * xfs_extlen_t and therefore 32 bits. Hence we have to
4514 * check for 32-bit overflows and handle them here.
4515 */
4516 if (len > (xfs_filblks_t)MAXEXTLEN)
4517 bma.length = MAXEXTLEN;
4518 else
4519 bma.length = len;
4520
4521 ASSERT(len > 0);
4522 ASSERT(bma.length > 0);
4523 error = xfs_bmapi_allocate(&bma);
4524 if (error)
4525 goto error0;
4526 if (bma.blkno == NULLFSBLOCK)
4527 break;
4528
4529 /*
4530 * If this is a CoW allocation, record the data in
4531 * the refcount btree for orphan recovery.
4532 */
4533 if (whichfork == XFS_COW_FORK)
4534 xfs_refcount_alloc_cow_extent(tp, bma.blkno,
4535 bma.length);
4536 }
4537
4538 /* Deal with the allocated space we found. */
4539 xfs_bmapi_trim_map(mval, &bma.got, &bno, len, obno,
4540 end, n, flags);
4541
4542 /* Execute unwritten extent conversion if necessary */
4543 error = xfs_bmapi_convert_unwritten(&bma, mval, len, flags);
4544 if (error == -EAGAIN)
4545 continue;
4546 if (error)
4547 goto error0;
4548
4549 /* update the extent map to return */
4550 xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags);
4551
4552 /*
4553 * If we're done, stop now. Stop when we've allocated
4554 * XFS_BMAP_MAX_NMAP extents no matter what. Otherwise
4555 * the transaction may get too big.
4556 */
4557 if (bno >= end || n >= *nmap || bma.nallocs >= *nmap)
4558 break;
4559
4560 /* Else go on to the next record. */
4561 bma.prev = bma.got;
4562 if (!xfs_iext_next_extent(ifp, &bma.icur, &bma.got))
4563 eof = true;
4564 }
4565 *nmap = n;
4566
4567 error = xfs_bmap_btree_to_extents(tp, ip, bma.cur, &bma.logflags,
4568 whichfork);
4569 if (error)
4570 goto error0;
4571
4572 ASSERT(ifp->if_format != XFS_DINODE_FMT_BTREE ||
4573 ifp->if_nextents > XFS_IFORK_MAXEXT(ip, whichfork));
4574 xfs_bmapi_finish(&bma, whichfork, 0);
4575 xfs_bmap_validate_ret(orig_bno, orig_len, orig_flags, orig_mval,
4576 orig_nmap, *nmap);
4577 return 0;
4578 error0:
4579 xfs_bmapi_finish(&bma, whichfork, error);
4580 return error;
4581 }
4582
4583 /*
4584 * Convert an existing delalloc extent to real blocks based on file offset. This
4585 * attempts to allocate the entire delalloc extent and may require multiple
4586 * invocations to allocate the target offset if a large enough physical extent
4587 * is not available.
4588 */
4589 int
4590 xfs_bmapi_convert_delalloc(
4591 struct xfs_inode *ip,
4592 int whichfork,
4593 xfs_off_t offset,
4594 struct iomap *iomap,
4595 unsigned int *seq)
4596 {
4597 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
4598 struct xfs_mount *mp = ip->i_mount;
4599 xfs_fileoff_t offset_fsb = XFS_B_TO_FSBT(mp, offset);
4600 struct xfs_bmalloca bma = { NULL };
4601 uint16_t flags = 0;
4602 struct xfs_trans *tp;
4603 int error;
4604
4605 if (whichfork == XFS_COW_FORK)
4606 flags |= IOMAP_F_SHARED;
4607
4608 /*
4609 * Space for the extent and indirect blocks was reserved when the
4610 * delalloc extent was created so there's no need to do so here.
4611 */
4612 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, 0, 0,
4613 XFS_TRANS_RESERVE, &tp);
4614 if (error)
4615 return error;
4616
4617 xfs_ilock(ip, XFS_ILOCK_EXCL);
4618
4619 error = xfs_iext_count_may_overflow(ip, whichfork,
4620 XFS_IEXT_ADD_NOSPLIT_CNT);
4621 if (error)
4622 goto out_trans_cancel;
4623
4624 xfs_trans_ijoin(tp, ip, 0);
4625
4626 if (!xfs_iext_lookup_extent(ip, ifp, offset_fsb, &bma.icur, &bma.got) ||
4627 bma.got.br_startoff > offset_fsb) {
4628 /*
4629 * No extent found in the range we are trying to convert. This
4630 * should only happen for the COW fork, where another thread
4631 * might have moved the extent to the data fork in the meantime.
4632 */
4633 WARN_ON_ONCE(whichfork != XFS_COW_FORK);
4634 error = -EAGAIN;
4635 goto out_trans_cancel;
4636 }
4637
4638 /*
4639 * If we find a real extent here we raced with another thread converting
4640 * the extent. Just return the real extent at this offset.
4641 */
4642 if (!isnullstartblock(bma.got.br_startblock)) {
4643 xfs_bmbt_to_iomap(ip, iomap, &bma.got, flags);
4644 *seq = READ_ONCE(ifp->if_seq);
4645 goto out_trans_cancel;
4646 }
4647
4648 bma.tp = tp;
4649 bma.ip = ip;
4650 bma.wasdel = true;
4651 bma.offset = bma.got.br_startoff;
4652 bma.length = max_t(xfs_filblks_t, bma.got.br_blockcount, MAXEXTLEN);
4653 bma.minleft = xfs_bmapi_minleft(tp, ip, whichfork);
4654
4655 /*
4656 * When we're converting the delalloc reservations backing dirty pages
4657 * in the page cache, we must be careful about how we create the new
4658 * extents:
4659 *
4660 * New CoW fork extents are created unwritten, turned into real extents
4661 * when we're about to write the data to disk, and mapped into the data
4662 * fork after the write finishes. End of story.
4663 *
4664 * New data fork extents must be mapped in as unwritten and converted
4665 * to real extents after the write succeeds to avoid exposing stale
4666 * disk contents if we crash.
4667 */
4668 bma.flags = XFS_BMAPI_PREALLOC;
4669 if (whichfork == XFS_COW_FORK)
4670 bma.flags |= XFS_BMAPI_COWFORK;
4671
4672 if (!xfs_iext_peek_prev_extent(ifp, &bma.icur, &bma.prev))
4673 bma.prev.br_startoff = NULLFILEOFF;
4674
4675 error = xfs_bmapi_allocate(&bma);
4676 if (error)
4677 goto out_finish;
4678
4679 error = -ENOSPC;
4680 if (WARN_ON_ONCE(bma.blkno == NULLFSBLOCK))
4681 goto out_finish;
4682 error = -EFSCORRUPTED;
4683 if (WARN_ON_ONCE(!xfs_valid_startblock(ip, bma.got.br_startblock)))
4684 goto out_finish;
4685
4686 XFS_STATS_ADD(mp, xs_xstrat_bytes, XFS_FSB_TO_B(mp, bma.length));
4687 XFS_STATS_INC(mp, xs_xstrat_quick);
4688
4689 ASSERT(!isnullstartblock(bma.got.br_startblock));
4690 xfs_bmbt_to_iomap(ip, iomap, &bma.got, flags);
4691 *seq = READ_ONCE(ifp->if_seq);
4692
4693 if (whichfork == XFS_COW_FORK)
4694 xfs_refcount_alloc_cow_extent(tp, bma.blkno, bma.length);
4695
4696 error = xfs_bmap_btree_to_extents(tp, ip, bma.cur, &bma.logflags,
4697 whichfork);
4698 if (error)
4699 goto out_finish;
4700
4701 xfs_bmapi_finish(&bma, whichfork, 0);
4702 error = xfs_trans_commit(tp);
4703 xfs_iunlock(ip, XFS_ILOCK_EXCL);
4704 return error;
4705
4706 out_finish:
4707 xfs_bmapi_finish(&bma, whichfork, error);
4708 out_trans_cancel:
4709 xfs_trans_cancel(tp);
4710 xfs_iunlock(ip, XFS_ILOCK_EXCL);
4711 return error;
4712 }
4713
4714 int
4715 xfs_bmapi_remap(
4716 struct xfs_trans *tp,
4717 struct xfs_inode *ip,
4718 xfs_fileoff_t bno,
4719 xfs_filblks_t len,
4720 xfs_fsblock_t startblock,
4721 int flags)
4722 {
4723 struct xfs_mount *mp = ip->i_mount;
4724 struct xfs_ifork *ifp;
4725 struct xfs_btree_cur *cur = NULL;
4726 struct xfs_bmbt_irec got;
4727 struct xfs_iext_cursor icur;
4728 int whichfork = xfs_bmapi_whichfork(flags);
4729 int logflags = 0, error;
4730
4731 ifp = XFS_IFORK_PTR(ip, whichfork);
4732 ASSERT(len > 0);
4733 ASSERT(len <= (xfs_filblks_t)MAXEXTLEN);
4734 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
4735 ASSERT(!(flags & ~(XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC |
4736 XFS_BMAPI_NORMAP)));
4737 ASSERT((flags & (XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC)) !=
4738 (XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC));
4739
4740 if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
4741 XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
4742 return -EFSCORRUPTED;
4743 }
4744
4745 if (XFS_FORCED_SHUTDOWN(mp))
4746 return -EIO;
4747
4748 if (!(ifp->if_flags & XFS_IFEXTENTS)) {
4749 error = xfs_iread_extents(tp, ip, whichfork);
4750 if (error)
4751 return error;
4752 }
4753
4754 if (xfs_iext_lookup_extent(ip, ifp, bno, &icur, &got)) {
4755 /* make sure we only reflink into a hole. */
4756 ASSERT(got.br_startoff > bno);
4757 ASSERT(got.br_startoff - bno >= len);
4758 }
4759
4760 ip->i_d.di_nblocks += len;
4761 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
4762
4763 if (ifp->if_flags & XFS_IFBROOT) {
4764 cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
4765 cur->bc_ino.flags = 0;
4766 }
4767
4768 got.br_startoff = bno;
4769 got.br_startblock = startblock;
4770 got.br_blockcount = len;
4771 if (flags & XFS_BMAPI_PREALLOC)
4772 got.br_state = XFS_EXT_UNWRITTEN;
4773 else
4774 got.br_state = XFS_EXT_NORM;
4775
4776 error = xfs_bmap_add_extent_hole_real(tp, ip, whichfork, &icur,
4777 &cur, &got, &logflags, flags);
4778 if (error)
4779 goto error0;
4780
4781 error = xfs_bmap_btree_to_extents(tp, ip, cur, &logflags, whichfork);
4782
4783 error0:
4784 if (ip->i_df.if_format != XFS_DINODE_FMT_EXTENTS)
4785 logflags &= ~XFS_ILOG_DEXT;
4786 else if (ip->i_df.if_format != XFS_DINODE_FMT_BTREE)
4787 logflags &= ~XFS_ILOG_DBROOT;
4788
4789 if (logflags)
4790 xfs_trans_log_inode(tp, ip, logflags);
4791 if (cur)
4792 xfs_btree_del_cursor(cur, error);
4793 return error;
4794 }
4795
4796 /*
4797 * When a delalloc extent is split (e.g., due to a hole punch), the original
4798 * indlen reservation must be shared across the two new extents that are left
4799 * behind.
4800 *
4801 * Given the original reservation and the worst case indlen for the two new
4802 * extents (as calculated by xfs_bmap_worst_indlen()), split the original
4803 * reservation fairly across the two new extents. If necessary, steal available
4804 * blocks from a deleted extent to make up a reservation deficiency (e.g., if
4805 * ores == 1). The number of stolen blocks is returned. The availability and
4806 * subsequent accounting of stolen blocks is the responsibility of the caller.
4807 */
4808 static xfs_filblks_t
4809 xfs_bmap_split_indlen(
4810 xfs_filblks_t ores, /* original res. */
4811 xfs_filblks_t *indlen1, /* ext1 worst indlen */
4812 xfs_filblks_t *indlen2, /* ext2 worst indlen */
4813 xfs_filblks_t avail) /* stealable blocks */
4814 {
4815 xfs_filblks_t len1 = *indlen1;
4816 xfs_filblks_t len2 = *indlen2;
4817 xfs_filblks_t nres = len1 + len2; /* new total res. */
4818 xfs_filblks_t stolen = 0;
4819 xfs_filblks_t resfactor;
4820
4821 /*
4822 * Steal as many blocks as we can to try and satisfy the worst case
4823 * indlen for both new extents.
4824 */
4825 if (ores < nres && avail)
4826 stolen = XFS_FILBLKS_MIN(nres - ores, avail);
4827 ores += stolen;
4828
4829 /* nothing else to do if we've satisfied the new reservation */
4830 if (ores >= nres)
4831 return stolen;
4832
4833 /*
4834 * We can't meet the total required reservation for the two extents.
4835 * Calculate the percent of the overall shortage between both extents
4836 * and apply this percentage to each of the requested indlen values.
4837 * This distributes the shortage fairly and reduces the chances that one
4838 * of the two extents is left with nothing when extents are repeatedly
4839 * split.
4840 */
4841 resfactor = (ores * 100);
4842 do_div(resfactor, nres);
4843 len1 *= resfactor;
4844 do_div(len1, 100);
4845 len2 *= resfactor;
4846 do_div(len2, 100);
4847 ASSERT(len1 + len2 <= ores);
4848 ASSERT(len1 < *indlen1 && len2 < *indlen2);
4849
4850 /*
4851 * Hand out the remainder to each extent. If one of the two reservations
4852 * is zero, we want to make sure that one gets a block first. The loop
4853 * below starts with len1, so hand len2 a block right off the bat if it
4854 * is zero.
4855 */
4856 ores -= (len1 + len2);
4857 ASSERT((*indlen1 - len1) + (*indlen2 - len2) >= ores);
4858 if (ores && !len2 && *indlen2) {
4859 len2++;
4860 ores--;
4861 }
4862 while (ores) {
4863 if (len1 < *indlen1) {
4864 len1++;
4865 ores--;
4866 }
4867 if (!ores)
4868 break;
4869 if (len2 < *indlen2) {
4870 len2++;
4871 ores--;
4872 }
4873 }
4874
4875 *indlen1 = len1;
4876 *indlen2 = len2;
4877
4878 return stolen;
4879 }
4880
4881 int
4882 xfs_bmap_del_extent_delay(
4883 struct xfs_inode *ip,
4884 int whichfork,
4885 struct xfs_iext_cursor *icur,
4886 struct xfs_bmbt_irec *got,
4887 struct xfs_bmbt_irec *del)
4888 {
4889 struct xfs_mount *mp = ip->i_mount;
4890 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
4891 struct xfs_bmbt_irec new;
4892 int64_t da_old, da_new, da_diff = 0;
4893 xfs_fileoff_t del_endoff, got_endoff;
4894 xfs_filblks_t got_indlen, new_indlen, stolen;
4895 int state = xfs_bmap_fork_to_state(whichfork);
4896 int error = 0;
4897 bool isrt;
4898
4899 XFS_STATS_INC(mp, xs_del_exlist);
4900
4901 isrt = (whichfork == XFS_DATA_FORK) && XFS_IS_REALTIME_INODE(ip);
4902 del_endoff = del->br_startoff + del->br_blockcount;
4903 got_endoff = got->br_startoff + got->br_blockcount;
4904 da_old = startblockval(got->br_startblock);
4905 da_new = 0;
4906
4907 ASSERT(del->br_blockcount > 0);
4908 ASSERT(got->br_startoff <= del->br_startoff);
4909 ASSERT(got_endoff >= del_endoff);
4910
4911 if (isrt) {
4912 uint64_t rtexts = XFS_FSB_TO_B(mp, del->br_blockcount);
4913
4914 do_div(rtexts, mp->m_sb.sb_rextsize);
4915 xfs_mod_frextents(mp, rtexts);
4916 }
4917
4918 /*
4919 * Update the inode delalloc counter now and wait to update the
4920 * sb counters as we might have to borrow some blocks for the
4921 * indirect block accounting.
4922 */
4923 ASSERT(!isrt);
4924 error = xfs_quota_unreserve_blkres(ip, del->br_blockcount);
4925 if (error)
4926 return error;
4927 ip->i_delayed_blks -= del->br_blockcount;
4928
4929 if (got->br_startoff == del->br_startoff)
4930 state |= BMAP_LEFT_FILLING;
4931 if (got_endoff == del_endoff)
4932 state |= BMAP_RIGHT_FILLING;
4933
4934 switch (state & (BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING)) {
4935 case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING:
4936 /*
4937 * Matches the whole extent. Delete the entry.
4938 */
4939 xfs_iext_remove(ip, icur, state);
4940 xfs_iext_prev(ifp, icur);
4941 break;
4942 case BMAP_LEFT_FILLING:
4943 /*
4944 * Deleting the first part of the extent.
4945 */
4946 got->br_startoff = del_endoff;
4947 got->br_blockcount -= del->br_blockcount;
4948 da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip,
4949 got->br_blockcount), da_old);
4950 got->br_startblock = nullstartblock((int)da_new);
4951 xfs_iext_update_extent(ip, state, icur, got);
4952 break;
4953 case BMAP_RIGHT_FILLING:
4954 /*
4955 * Deleting the last part of the extent.
4956 */
4957 got->br_blockcount = got->br_blockcount - del->br_blockcount;
4958 da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip,
4959 got->br_blockcount), da_old);
4960 got->br_startblock = nullstartblock((int)da_new);
4961 xfs_iext_update_extent(ip, state, icur, got);
4962 break;
4963 case 0:
4964 /*
4965 * Deleting the middle of the extent.
4966 *
4967 * Distribute the original indlen reservation across the two new
4968 * extents. Steal blocks from the deleted extent if necessary.
4969 * Stealing blocks simply fudges the fdblocks accounting below.
4970 * Warn if either of the new indlen reservations is zero as this
4971 * can lead to delalloc problems.
4972 */
4973 got->br_blockcount = del->br_startoff - got->br_startoff;
4974 got_indlen = xfs_bmap_worst_indlen(ip, got->br_blockcount);
4975
4976 new.br_blockcount = got_endoff - del_endoff;
4977 new_indlen = xfs_bmap_worst_indlen(ip, new.br_blockcount);
4978
4979 WARN_ON_ONCE(!got_indlen || !new_indlen);
4980 stolen = xfs_bmap_split_indlen(da_old, &got_indlen, &new_indlen,
4981 del->br_blockcount);
4982
4983 got->br_startblock = nullstartblock((int)got_indlen);
4984
4985 new.br_startoff = del_endoff;
4986 new.br_state = got->br_state;
4987 new.br_startblock = nullstartblock((int)new_indlen);
4988
4989 xfs_iext_update_extent(ip, state, icur, got);
4990 xfs_iext_next(ifp, icur);
4991 xfs_iext_insert(ip, icur, &new, state);
4992
4993 da_new = got_indlen + new_indlen - stolen;
4994 del->br_blockcount -= stolen;
4995 break;
4996 }
4997
4998 ASSERT(da_old >= da_new);
4999 da_diff = da_old - da_new;
5000 if (!isrt)
5001 da_diff += del->br_blockcount;
5002 if (da_diff) {
5003 xfs_mod_fdblocks(mp, da_diff, false);
5004 xfs_mod_delalloc(mp, -da_diff);
5005 }
5006 return error;
5007 }
5008
5009 void
5010 xfs_bmap_del_extent_cow(
5011 struct xfs_inode *ip,
5012 struct xfs_iext_cursor *icur,
5013 struct xfs_bmbt_irec *got,
5014 struct xfs_bmbt_irec *del)
5015 {
5016 struct xfs_mount *mp = ip->i_mount;
5017 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK);
5018 struct xfs_bmbt_irec new;
5019 xfs_fileoff_t del_endoff, got_endoff;
5020 int state = BMAP_COWFORK;
5021
5022 XFS_STATS_INC(mp, xs_del_exlist);
5023
5024 del_endoff = del->br_startoff + del->br_blockcount;
5025 got_endoff = got->br_startoff + got->br_blockcount;
5026
5027 ASSERT(del->br_blockcount > 0);
5028 ASSERT(got->br_startoff <= del->br_startoff);
5029 ASSERT(got_endoff >= del_endoff);
5030 ASSERT(!isnullstartblock(got->br_startblock));
5031
5032 if (got->br_startoff == del->br_startoff)
5033 state |= BMAP_LEFT_FILLING;
5034 if (got_endoff == del_endoff)
5035 state |= BMAP_RIGHT_FILLING;
5036
5037 switch (state & (BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING)) {
5038 case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING:
5039 /*
5040 * Matches the whole extent. Delete the entry.
5041 */
5042 xfs_iext_remove(ip, icur, state);
5043 xfs_iext_prev(ifp, icur);
5044 break;
5045 case BMAP_LEFT_FILLING:
5046 /*
5047 * Deleting the first part of the extent.
5048 */
5049 got->br_startoff = del_endoff;
5050 got->br_blockcount -= del->br_blockcount;
5051 got->br_startblock = del->br_startblock + del->br_blockcount;
5052 xfs_iext_update_extent(ip, state, icur, got);
5053 break;
5054 case BMAP_RIGHT_FILLING:
5055 /*
5056 * Deleting the last part of the extent.
5057 */
5058 got->br_blockcount -= del->br_blockcount;
5059 xfs_iext_update_extent(ip, state, icur, got);
5060 break;
5061 case 0:
5062 /*
5063 * Deleting the middle of the extent.
5064 */
5065 got->br_blockcount = del->br_startoff - got->br_startoff;
5066
5067 new.br_startoff = del_endoff;
5068 new.br_blockcount = got_endoff - del_endoff;
5069 new.br_state = got->br_state;
5070 new.br_startblock = del->br_startblock + del->br_blockcount;
5071
5072 xfs_iext_update_extent(ip, state, icur, got);
5073 xfs_iext_next(ifp, icur);
5074 xfs_iext_insert(ip, icur, &new, state);
5075 break;
5076 }
5077 ip->i_delayed_blks -= del->br_blockcount;
5078 }
5079
5080 /*
5081 * Called by xfs_bmapi to update file extent records and the btree
5082 * after removing space.
5083 */
5084 STATIC int /* error */
5085 xfs_bmap_del_extent_real(
5086 xfs_inode_t *ip, /* incore inode pointer */
5087 xfs_trans_t *tp, /* current transaction pointer */
5088 struct xfs_iext_cursor *icur,
5089 xfs_btree_cur_t *cur, /* if null, not a btree */
5090 xfs_bmbt_irec_t *del, /* data to remove from extents */
5091 int *logflagsp, /* inode logging flags */
5092 int whichfork, /* data or attr fork */
5093 int bflags) /* bmapi flags */
5094 {
5095 xfs_fsblock_t del_endblock=0; /* first block past del */
5096 xfs_fileoff_t del_endoff; /* first offset past del */
5097 int do_fx; /* free extent at end of routine */
5098 int error; /* error return value */
5099 int flags = 0;/* inode logging flags */
5100 struct xfs_bmbt_irec got; /* current extent entry */
5101 xfs_fileoff_t got_endoff; /* first offset past got */
5102 int i; /* temp state */
5103 struct xfs_ifork *ifp; /* inode fork pointer */
5104 xfs_mount_t *mp; /* mount structure */
5105 xfs_filblks_t nblks; /* quota/sb block count */
5106 xfs_bmbt_irec_t new; /* new record to be inserted */
5107 /* REFERENCED */
5108 uint qfield; /* quota field to update */
5109 int state = xfs_bmap_fork_to_state(whichfork);
5110 struct xfs_bmbt_irec old;
5111
5112 mp = ip->i_mount;
5113 XFS_STATS_INC(mp, xs_del_exlist);
5114
5115 ifp = XFS_IFORK_PTR(ip, whichfork);
5116 ASSERT(del->br_blockcount > 0);
5117 xfs_iext_get_extent(ifp, icur, &got);
5118 ASSERT(got.br_startoff <= del->br_startoff);
5119 del_endoff = del->br_startoff + del->br_blockcount;
5120 got_endoff = got.br_startoff + got.br_blockcount;
5121 ASSERT(got_endoff >= del_endoff);
5122 ASSERT(!isnullstartblock(got.br_startblock));
5123 qfield = 0;
5124 error = 0;
5125
5126 /*
5127 * If it's the case where the directory code is running with no block
5128 * reservation, and the deleted block is in the middle of its extent,
5129 * and the resulting insert of an extent would cause transformation to
5130 * btree format, then reject it. The calling code will then swap blocks
5131 * around instead. We have to do this now, rather than waiting for the
5132 * conversion to btree format, since the transaction will be dirty then.
5133 */
5134 if (tp->t_blk_res == 0 &&
5135 ifp->if_format == XFS_DINODE_FMT_EXTENTS &&
5136 ifp->if_nextents >= XFS_IFORK_MAXEXT(ip, whichfork) &&
5137 del->br_startoff > got.br_startoff && del_endoff < got_endoff)
5138 return -ENOSPC;
5139
5140 flags = XFS_ILOG_CORE;
5141 if (whichfork == XFS_DATA_FORK && XFS_IS_REALTIME_INODE(ip)) {
5142 xfs_filblks_t len;
5143 xfs_extlen_t mod;
5144
5145 len = div_u64_rem(del->br_blockcount, mp->m_sb.sb_rextsize,
5146 &mod);
5147 ASSERT(mod == 0);
5148
5149 if (!(bflags & XFS_BMAPI_REMAP)) {
5150 xfs_fsblock_t bno;
5151
5152 bno = div_u64_rem(del->br_startblock,
5153 mp->m_sb.sb_rextsize, &mod);
5154 ASSERT(mod == 0);
5155
5156 error = xfs_rtfree_extent(tp, bno, (xfs_extlen_t)len);
5157 if (error)
5158 goto done;
5159 }
5160
5161 do_fx = 0;
5162 nblks = len * mp->m_sb.sb_rextsize;
5163 qfield = XFS_TRANS_DQ_RTBCOUNT;
5164 } else {
5165 do_fx = 1;
5166 nblks = del->br_blockcount;
5167 qfield = XFS_TRANS_DQ_BCOUNT;
5168 }
5169
5170 del_endblock = del->br_startblock + del->br_blockcount;
5171 if (cur) {
5172 error = xfs_bmbt_lookup_eq(cur, &got, &i);
5173 if (error)
5174 goto done;
5175 if (XFS_IS_CORRUPT(mp, i != 1)) {
5176 error = -EFSCORRUPTED;
5177 goto done;
5178 }
5179 }
5180
5181 if (got.br_startoff == del->br_startoff)
5182 state |= BMAP_LEFT_FILLING;
5183 if (got_endoff == del_endoff)
5184 state |= BMAP_RIGHT_FILLING;
5185
5186 switch (state & (BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING)) {
5187 case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING:
5188 /*
5189 * Matches the whole extent. Delete the entry.
5190 */
5191 xfs_iext_remove(ip, icur, state);
5192 xfs_iext_prev(ifp, icur);
5193 ifp->if_nextents--;
5194
5195 flags |= XFS_ILOG_CORE;
5196 if (!cur) {
5197 flags |= xfs_ilog_fext(whichfork);
5198 break;
5199 }
5200 if ((error = xfs_btree_delete(cur, &i)))
5201 goto done;
5202 if (XFS_IS_CORRUPT(mp, i != 1)) {
5203 error = -EFSCORRUPTED;
5204 goto done;
5205 }
5206 break;
5207 case BMAP_LEFT_FILLING:
5208 /*
5209 * Deleting the first part of the extent.
5210 */
5211 got.br_startoff = del_endoff;
5212 got.br_startblock = del_endblock;
5213 got.br_blockcount -= del->br_blockcount;
5214 xfs_iext_update_extent(ip, state, icur, &got);
5215 if (!cur) {
5216 flags |= xfs_ilog_fext(whichfork);
5217 break;
5218 }
5219 error = xfs_bmbt_update(cur, &got);
5220 if (error)
5221 goto done;
5222 break;
5223 case BMAP_RIGHT_FILLING:
5224 /*
5225 * Deleting the last part of the extent.
5226 */
5227 got.br_blockcount -= del->br_blockcount;
5228 xfs_iext_update_extent(ip, state, icur, &got);
5229 if (!cur) {
5230 flags |= xfs_ilog_fext(whichfork);
5231 break;
5232 }
5233 error = xfs_bmbt_update(cur, &got);
5234 if (error)
5235 goto done;
5236 break;
5237 case 0:
5238 /*
5239 * Deleting the middle of the extent.
5240 */
5241
5242 /*
5243 * For directories, -ENOSPC is returned since a directory entry
5244 * remove operation must not fail due to low extent count
5245 * availability. -ENOSPC will be handled by higher layers of XFS
5246 * by letting the corresponding empty Data/Free blocks to linger
5247 * until a future remove operation. Dabtree blocks would be
5248 * swapped with the last block in the leaf space and then the
5249 * new last block will be unmapped.
5250 *
5251 * The above logic also applies to the source directory entry of
5252 * a rename operation.
5253 */
5254 error = xfs_iext_count_may_overflow(ip, whichfork, 1);
5255 if (error) {
5256 ASSERT(S_ISDIR(VFS_I(ip)->i_mode) &&
5257 whichfork == XFS_DATA_FORK);
5258 error = -ENOSPC;
5259 goto done;
5260 }
5261
5262 old = got;
5263
5264 got.br_blockcount = del->br_startoff - got.br_startoff;
5265 xfs_iext_update_extent(ip, state, icur, &got);
5266
5267 new.br_startoff = del_endoff;
5268 new.br_blockcount = got_endoff - del_endoff;
5269 new.br_state = got.br_state;
5270 new.br_startblock = del_endblock;
5271
5272 flags |= XFS_ILOG_CORE;
5273 if (cur) {
5274 error = xfs_bmbt_update(cur, &got);
5275 if (error)
5276 goto done;
5277 error = xfs_btree_increment(cur, 0, &i);
5278 if (error)
5279 goto done;
5280 cur->bc_rec.b = new;
5281 error = xfs_btree_insert(cur, &i);
5282 if (error && error != -ENOSPC)
5283 goto done;
5284 /*
5285 * If get no-space back from btree insert, it tried a
5286 * split, and we have a zero block reservation. Fix up
5287 * our state and return the error.
5288 */
5289 if (error == -ENOSPC) {
5290 /*
5291 * Reset the cursor, don't trust it after any
5292 * insert operation.
5293 */
5294 error = xfs_bmbt_lookup_eq(cur, &got, &i);
5295 if (error)
5296 goto done;
5297 if (XFS_IS_CORRUPT(mp, i != 1)) {
5298 error = -EFSCORRUPTED;
5299 goto done;
5300 }
5301 /*
5302 * Update the btree record back
5303 * to the original value.
5304 */
5305 error = xfs_bmbt_update(cur, &old);
5306 if (error)
5307 goto done;
5308 /*
5309 * Reset the extent record back
5310 * to the original value.
5311 */
5312 xfs_iext_update_extent(ip, state, icur, &old);
5313 flags = 0;
5314 error = -ENOSPC;
5315 goto done;
5316 }
5317 if (XFS_IS_CORRUPT(mp, i != 1)) {
5318 error = -EFSCORRUPTED;
5319 goto done;
5320 }
5321 } else
5322 flags |= xfs_ilog_fext(whichfork);
5323
5324 ifp->if_nextents++;
5325 xfs_iext_next(ifp, icur);
5326 xfs_iext_insert(ip, icur, &new, state);
5327 break;
5328 }
5329
5330 /* remove reverse mapping */
5331 xfs_rmap_unmap_extent(tp, ip, whichfork, del);
5332
5333 /*
5334 * If we need to, add to list of extents to delete.
5335 */
5336 if (do_fx && !(bflags & XFS_BMAPI_REMAP)) {
5337 if (xfs_is_reflink_inode(ip) && whichfork == XFS_DATA_FORK) {
5338 xfs_refcount_decrease_extent(tp, del);
5339 } else {
5340 __xfs_bmap_add_free(tp, del->br_startblock,
5341 del->br_blockcount, NULL,
5342 (bflags & XFS_BMAPI_NODISCARD) ||
5343 del->br_state == XFS_EXT_UNWRITTEN);
5344 }
5345 }
5346
5347 /*
5348 * Adjust inode # blocks in the file.
5349 */
5350 if (nblks)
5351 ip->i_d.di_nblocks -= nblks;
5352 /*
5353 * Adjust quota data.
5354 */
5355 if (qfield && !(bflags & XFS_BMAPI_REMAP))
5356 xfs_trans_mod_dquot_byino(tp, ip, qfield, (long)-nblks);
5357
5358 done:
5359 *logflagsp = flags;
5360 return error;
5361 }
5362
5363 /*
5364 * Unmap (remove) blocks from a file.
5365 * If nexts is nonzero then the number of extents to remove is limited to
5366 * that value. If not all extents in the block range can be removed then
5367 * *done is set.
5368 */
5369 int /* error */
5370 __xfs_bunmapi(
5371 struct xfs_trans *tp, /* transaction pointer */
5372 struct xfs_inode *ip, /* incore inode */
5373 xfs_fileoff_t start, /* first file offset deleted */
5374 xfs_filblks_t *rlen, /* i/o: amount remaining */
5375 int flags, /* misc flags */
5376 xfs_extnum_t nexts) /* number of extents max */
5377 {
5378 struct xfs_btree_cur *cur; /* bmap btree cursor */
5379 struct xfs_bmbt_irec del; /* extent being deleted */
5380 int error; /* error return value */
5381 xfs_extnum_t extno; /* extent number in list */
5382 struct xfs_bmbt_irec got; /* current extent record */
5383 struct xfs_ifork *ifp; /* inode fork pointer */
5384 int isrt; /* freeing in rt area */
5385 int logflags; /* transaction logging flags */
5386 xfs_extlen_t mod; /* rt extent offset */
5387 struct xfs_mount *mp = ip->i_mount;
5388 int tmp_logflags; /* partial logging flags */
5389 int wasdel; /* was a delayed alloc extent */
5390 int whichfork; /* data or attribute fork */
5391 xfs_fsblock_t sum;
5392 xfs_filblks_t len = *rlen; /* length to unmap in file */
5393 xfs_fileoff_t max_len;
5394 xfs_agnumber_t prev_agno = NULLAGNUMBER, agno;
5395 xfs_fileoff_t end;
5396 struct xfs_iext_cursor icur;
5397 bool done = false;
5398
5399 trace_xfs_bunmap(ip, start, len, flags, _RET_IP_);
5400
5401 whichfork = xfs_bmapi_whichfork(flags);
5402 ASSERT(whichfork != XFS_COW_FORK);
5403 ifp = XFS_IFORK_PTR(ip, whichfork);
5404 if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)))
5405 return -EFSCORRUPTED;
5406 if (XFS_FORCED_SHUTDOWN(mp))
5407 return -EIO;
5408
5409 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
5410 ASSERT(len > 0);
5411 ASSERT(nexts >= 0);
5412
5413 /*
5414 * Guesstimate how many blocks we can unmap without running the risk of
5415 * blowing out the transaction with a mix of EFIs and reflink
5416 * adjustments.
5417 */
5418 if (tp && xfs_is_reflink_inode(ip) && whichfork == XFS_DATA_FORK)
5419 max_len = min(len, xfs_refcount_max_unmap(tp->t_log_res));
5420 else
5421 max_len = len;
5422
5423 if (!(ifp->if_flags & XFS_IFEXTENTS) &&
5424 (error = xfs_iread_extents(tp, ip, whichfork)))
5425 return error;
5426 if (xfs_iext_count(ifp) == 0) {
5427 *rlen = 0;
5428 return 0;
5429 }
5430 XFS_STATS_INC(mp, xs_blk_unmap);
5431 isrt = (whichfork == XFS_DATA_FORK) && XFS_IS_REALTIME_INODE(ip);
5432 end = start + len;
5433
5434 if (!xfs_iext_lookup_extent_before(ip, ifp, &end, &icur, &got)) {
5435 *rlen = 0;
5436 return 0;
5437 }
5438 end--;
5439
5440 logflags = 0;
5441 if (ifp->if_flags & XFS_IFBROOT) {
5442 ASSERT(ifp->if_format == XFS_DINODE_FMT_BTREE);
5443 cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
5444 cur->bc_ino.flags = 0;
5445 } else
5446 cur = NULL;
5447
5448 if (isrt) {
5449 /*
5450 * Synchronize by locking the bitmap inode.
5451 */
5452 xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL|XFS_ILOCK_RTBITMAP);
5453 xfs_trans_ijoin(tp, mp->m_rbmip, XFS_ILOCK_EXCL);
5454 xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL|XFS_ILOCK_RTSUM);
5455 xfs_trans_ijoin(tp, mp->m_rsumip, XFS_ILOCK_EXCL);
5456 }
5457
5458 extno = 0;
5459 while (end != (xfs_fileoff_t)-1 && end >= start &&
5460 (nexts == 0 || extno < nexts) && max_len > 0) {
5461 /*
5462 * Is the found extent after a hole in which end lives?
5463 * Just back up to the previous extent, if so.
5464 */
5465 if (got.br_startoff > end &&
5466 !xfs_iext_prev_extent(ifp, &icur, &got)) {
5467 done = true;
5468 break;
5469 }
5470 /*
5471 * Is the last block of this extent before the range
5472 * we're supposed to delete? If so, we're done.
5473 */
5474 end = XFS_FILEOFF_MIN(end,
5475 got.br_startoff + got.br_blockcount - 1);
5476 if (end < start)
5477 break;
5478 /*
5479 * Then deal with the (possibly delayed) allocated space
5480 * we found.
5481 */
5482 del = got;
5483 wasdel = isnullstartblock(del.br_startblock);
5484
5485 /*
5486 * Make sure we don't touch multiple AGF headers out of order
5487 * in a single transaction, as that could cause AB-BA deadlocks.
5488 */
5489 if (!wasdel && !isrt) {
5490 agno = XFS_FSB_TO_AGNO(mp, del.br_startblock);
5491 if (prev_agno != NULLAGNUMBER && prev_agno > agno)
5492 break;
5493 prev_agno = agno;
5494 }
5495 if (got.br_startoff < start) {
5496 del.br_startoff = start;
5497 del.br_blockcount -= start - got.br_startoff;
5498 if (!wasdel)
5499 del.br_startblock += start - got.br_startoff;
5500 }
5501 if (del.br_startoff + del.br_blockcount > end + 1)
5502 del.br_blockcount = end + 1 - del.br_startoff;
5503
5504 /* How much can we safely unmap? */
5505 if (max_len < del.br_blockcount) {
5506 del.br_startoff += del.br_blockcount - max_len;
5507 if (!wasdel)
5508 del.br_startblock += del.br_blockcount - max_len;
5509 del.br_blockcount = max_len;
5510 }
5511
5512 if (!isrt)
5513 goto delete;
5514
5515 sum = del.br_startblock + del.br_blockcount;
5516 div_u64_rem(sum, mp->m_sb.sb_rextsize, &mod);
5517 if (mod) {
5518 /*
5519 * Realtime extent not lined up at the end.
5520 * The extent could have been split into written
5521 * and unwritten pieces, or we could just be
5522 * unmapping part of it. But we can't really
5523 * get rid of part of a realtime extent.
5524 */
5525 if (del.br_state == XFS_EXT_UNWRITTEN) {
5526 /*
5527 * This piece is unwritten, or we're not
5528 * using unwritten extents. Skip over it.
5529 */
5530 ASSERT(end >= mod);
5531 end -= mod > del.br_blockcount ?
5532 del.br_blockcount : mod;
5533 if (end < got.br_startoff &&
5534 !xfs_iext_prev_extent(ifp, &icur, &got)) {
5535 done = true;
5536 break;
5537 }
5538 continue;
5539 }
5540 /*
5541 * It's written, turn it unwritten.
5542 * This is better than zeroing it.
5543 */
5544 ASSERT(del.br_state == XFS_EXT_NORM);
5545 ASSERT(tp->t_blk_res > 0);
5546 /*
5547 * If this spans a realtime extent boundary,
5548 * chop it back to the start of the one we end at.
5549 */
5550 if (del.br_blockcount > mod) {
5551 del.br_startoff += del.br_blockcount - mod;
5552 del.br_startblock += del.br_blockcount - mod;
5553 del.br_blockcount = mod;
5554 }
5555 del.br_state = XFS_EXT_UNWRITTEN;
5556 error = xfs_bmap_add_extent_unwritten_real(tp, ip,
5557 whichfork, &icur, &cur, &del,
5558 &logflags);
5559 if (error)
5560 goto error0;
5561 goto nodelete;
5562 }
5563 div_u64_rem(del.br_startblock, mp->m_sb.sb_rextsize, &mod);
5564 if (mod) {
5565 xfs_extlen_t off = mp->m_sb.sb_rextsize - mod;
5566
5567 /*
5568 * Realtime extent is lined up at the end but not
5569 * at the front. We'll get rid of full extents if
5570 * we can.
5571 */
5572 if (del.br_blockcount > off) {
5573 del.br_blockcount -= off;
5574 del.br_startoff += off;
5575 del.br_startblock += off;
5576 } else if (del.br_startoff == start &&
5577 (del.br_state == XFS_EXT_UNWRITTEN ||
5578 tp->t_blk_res == 0)) {
5579 /*
5580 * Can't make it unwritten. There isn't
5581 * a full extent here so just skip it.
5582 */
5583 ASSERT(end >= del.br_blockcount);
5584 end -= del.br_blockcount;
5585 if (got.br_startoff > end &&
5586 !xfs_iext_prev_extent(ifp, &icur, &got)) {
5587 done = true;
5588 break;
5589 }
5590 continue;
5591 } else if (del.br_state == XFS_EXT_UNWRITTEN) {
5592 struct xfs_bmbt_irec prev;
5593 xfs_fileoff_t unwrite_start;
5594
5595 /*
5596 * This one is already unwritten.
5597 * It must have a written left neighbor.
5598 * Unwrite the killed part of that one and
5599 * try again.
5600 */
5601 if (!xfs_iext_prev_extent(ifp, &icur, &prev))
5602 ASSERT(0);
5603 ASSERT(prev.br_state == XFS_EXT_NORM);
5604 ASSERT(!isnullstartblock(prev.br_startblock));
5605 ASSERT(del.br_startblock ==
5606 prev.br_startblock + prev.br_blockcount);
5607 unwrite_start = max3(start,
5608 del.br_startoff - mod,
5609 prev.br_startoff);
5610 mod = unwrite_start - prev.br_startoff;
5611 prev.br_startoff = unwrite_start;
5612 prev.br_startblock += mod;
5613 prev.br_blockcount -= mod;
5614 prev.br_state = XFS_EXT_UNWRITTEN;
5615 error = xfs_bmap_add_extent_unwritten_real(tp,
5616 ip, whichfork, &icur, &cur,
5617 &prev, &logflags);
5618 if (error)
5619 goto error0;
5620 goto nodelete;
5621 } else {
5622 ASSERT(del.br_state == XFS_EXT_NORM);
5623 del.br_state = XFS_EXT_UNWRITTEN;
5624 error = xfs_bmap_add_extent_unwritten_real(tp,
5625 ip, whichfork, &icur, &cur,
5626 &del, &logflags);
5627 if (error)
5628 goto error0;
5629 goto nodelete;
5630 }
5631 }
5632
5633 delete:
5634 if (wasdel) {
5635 error = xfs_bmap_del_extent_delay(ip, whichfork, &icur,
5636 &got, &del);
5637 } else {
5638 error = xfs_bmap_del_extent_real(ip, tp, &icur, cur,
5639 &del, &tmp_logflags, whichfork,
5640 flags);
5641 logflags |= tmp_logflags;
5642 }
5643
5644 if (error)
5645 goto error0;
5646
5647 max_len -= del.br_blockcount;
5648 end = del.br_startoff - 1;
5649 nodelete:
5650 /*
5651 * If not done go on to the next (previous) record.
5652 */
5653 if (end != (xfs_fileoff_t)-1 && end >= start) {
5654 if (!xfs_iext_get_extent(ifp, &icur, &got) ||
5655 (got.br_startoff > end &&
5656 !xfs_iext_prev_extent(ifp, &icur, &got))) {
5657 done = true;
5658 break;
5659 }
5660 extno++;
5661 }
5662 }
5663 if (done || end == (xfs_fileoff_t)-1 || end < start)
5664 *rlen = 0;
5665 else
5666 *rlen = end - start + 1;
5667
5668 /*
5669 * Convert to a btree if necessary.
5670 */
5671 if (xfs_bmap_needs_btree(ip, whichfork)) {
5672 ASSERT(cur == NULL);
5673 error = xfs_bmap_extents_to_btree(tp, ip, &cur, 0,
5674 &tmp_logflags, whichfork);
5675 logflags |= tmp_logflags;
5676 } else {
5677 error = xfs_bmap_btree_to_extents(tp, ip, cur, &logflags,
5678 whichfork);
5679 }
5680
5681 error0:
5682 /*
5683 * Log everything. Do this after conversion, there's no point in
5684 * logging the extent records if we've converted to btree format.
5685 */
5686 if ((logflags & xfs_ilog_fext(whichfork)) &&
5687 ifp->if_format != XFS_DINODE_FMT_EXTENTS)
5688 logflags &= ~xfs_ilog_fext(whichfork);
5689 else if ((logflags & xfs_ilog_fbroot(whichfork)) &&
5690 ifp->if_format != XFS_DINODE_FMT_BTREE)
5691 logflags &= ~xfs_ilog_fbroot(whichfork);
5692 /*
5693 * Log inode even in the error case, if the transaction
5694 * is dirty we'll need to shut down the filesystem.
5695 */
5696 if (logflags)
5697 xfs_trans_log_inode(tp, ip, logflags);
5698 if (cur) {
5699 if (!error)
5700 cur->bc_ino.allocated = 0;
5701 xfs_btree_del_cursor(cur, error);
5702 }
5703 return error;
5704 }
5705
5706 /* Unmap a range of a file. */
5707 int
5708 xfs_bunmapi(
5709 xfs_trans_t *tp,
5710 struct xfs_inode *ip,
5711 xfs_fileoff_t bno,
5712 xfs_filblks_t len,
5713 int flags,
5714 xfs_extnum_t nexts,
5715 int *done)
5716 {
5717 int error;
5718
5719 error = __xfs_bunmapi(tp, ip, bno, &len, flags, nexts);
5720 *done = (len == 0);
5721 return error;
5722 }
5723
5724 /*
5725 * Determine whether an extent shift can be accomplished by a merge with the
5726 * extent that precedes the target hole of the shift.
5727 */
5728 STATIC bool
5729 xfs_bmse_can_merge(
5730 struct xfs_bmbt_irec *left, /* preceding extent */
5731 struct xfs_bmbt_irec *got, /* current extent to shift */
5732 xfs_fileoff_t shift) /* shift fsb */
5733 {
5734 xfs_fileoff_t startoff;
5735
5736 startoff = got->br_startoff - shift;
5737
5738 /*
5739 * The extent, once shifted, must be adjacent in-file and on-disk with
5740 * the preceding extent.
5741 */
5742 if ((left->br_startoff + left->br_blockcount != startoff) ||
5743 (left->br_startblock + left->br_blockcount != got->br_startblock) ||
5744 (left->br_state != got->br_state) ||
5745 (left->br_blockcount + got->br_blockcount > MAXEXTLEN))
5746 return false;
5747
5748 return true;
5749 }
5750
5751 /*
5752 * A bmap extent shift adjusts the file offset of an extent to fill a preceding
5753 * hole in the file. If an extent shift would result in the extent being fully
5754 * adjacent to the extent that currently precedes the hole, we can merge with
5755 * the preceding extent rather than do the shift.
5756 *
5757 * This function assumes the caller has verified a shift-by-merge is possible
5758 * with the provided extents via xfs_bmse_can_merge().
5759 */
5760 STATIC int
5761 xfs_bmse_merge(
5762 struct xfs_trans *tp,
5763 struct xfs_inode *ip,
5764 int whichfork,
5765 xfs_fileoff_t shift, /* shift fsb */
5766 struct xfs_iext_cursor *icur,
5767 struct xfs_bmbt_irec *got, /* extent to shift */
5768 struct xfs_bmbt_irec *left, /* preceding extent */
5769 struct xfs_btree_cur *cur,
5770 int *logflags) /* output */
5771 {
5772 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
5773 struct xfs_bmbt_irec new;
5774 xfs_filblks_t blockcount;
5775 int error, i;
5776 struct xfs_mount *mp = ip->i_mount;
5777
5778 blockcount = left->br_blockcount + got->br_blockcount;
5779
5780 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
5781 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
5782 ASSERT(xfs_bmse_can_merge(left, got, shift));
5783
5784 new = *left;
5785 new.br_blockcount = blockcount;
5786
5787 /*
5788 * Update the on-disk extent count, the btree if necessary and log the
5789 * inode.
5790 */
5791 ifp->if_nextents--;
5792 *logflags |= XFS_ILOG_CORE;
5793 if (!cur) {
5794 *logflags |= XFS_ILOG_DEXT;
5795 goto done;
5796 }
5797
5798 /* lookup and remove the extent to merge */
5799 error = xfs_bmbt_lookup_eq(cur, got, &i);
5800 if (error)
5801 return error;
5802 if (XFS_IS_CORRUPT(mp, i != 1))
5803 return -EFSCORRUPTED;
5804
5805 error = xfs_btree_delete(cur, &i);
5806 if (error)
5807 return error;
5808 if (XFS_IS_CORRUPT(mp, i != 1))
5809 return -EFSCORRUPTED;
5810
5811 /* lookup and update size of the previous extent */
5812 error = xfs_bmbt_lookup_eq(cur, left, &i);
5813 if (error)
5814 return error;
5815 if (XFS_IS_CORRUPT(mp, i != 1))
5816 return -EFSCORRUPTED;
5817
5818 error = xfs_bmbt_update(cur, &new);
5819 if (error)
5820 return error;
5821
5822 /* change to extent format if required after extent removal */
5823 error = xfs_bmap_btree_to_extents(tp, ip, cur, logflags, whichfork);
5824 if (error)
5825 return error;
5826
5827 done:
5828 xfs_iext_remove(ip, icur, 0);
5829 xfs_iext_prev(ifp, icur);
5830 xfs_iext_update_extent(ip, xfs_bmap_fork_to_state(whichfork), icur,
5831 &new);
5832
5833 /* update reverse mapping. rmap functions merge the rmaps for us */
5834 xfs_rmap_unmap_extent(tp, ip, whichfork, got);
5835 memcpy(&new, got, sizeof(new));
5836 new.br_startoff = left->br_startoff + left->br_blockcount;
5837 xfs_rmap_map_extent(tp, ip, whichfork, &new);
5838 return 0;
5839 }
5840
5841 static int
5842 xfs_bmap_shift_update_extent(
5843 struct xfs_trans *tp,
5844 struct xfs_inode *ip,
5845 int whichfork,
5846 struct xfs_iext_cursor *icur,
5847 struct xfs_bmbt_irec *got,
5848 struct xfs_btree_cur *cur,
5849 int *logflags,
5850 xfs_fileoff_t startoff)
5851 {
5852 struct xfs_mount *mp = ip->i_mount;
5853 struct xfs_bmbt_irec prev = *got;
5854 int error, i;
5855
5856 *logflags |= XFS_ILOG_CORE;
5857
5858 got->br_startoff = startoff;
5859
5860 if (cur) {
5861 error = xfs_bmbt_lookup_eq(cur, &prev, &i);
5862 if (error)
5863 return error;
5864 if (XFS_IS_CORRUPT(mp, i != 1))
5865 return -EFSCORRUPTED;
5866
5867 error = xfs_bmbt_update(cur, got);
5868 if (error)
5869 return error;
5870 } else {
5871 *logflags |= XFS_ILOG_DEXT;
5872 }
5873
5874 xfs_iext_update_extent(ip, xfs_bmap_fork_to_state(whichfork), icur,
5875 got);
5876
5877 /* update reverse mapping */
5878 xfs_rmap_unmap_extent(tp, ip, whichfork, &prev);
5879 xfs_rmap_map_extent(tp, ip, whichfork, got);
5880 return 0;
5881 }
5882
5883 int
5884 xfs_bmap_collapse_extents(
5885 struct xfs_trans *tp,
5886 struct xfs_inode *ip,
5887 xfs_fileoff_t *next_fsb,
5888 xfs_fileoff_t offset_shift_fsb,
5889 bool *done)
5890 {
5891 int whichfork = XFS_DATA_FORK;
5892 struct xfs_mount *mp = ip->i_mount;
5893 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
5894 struct xfs_btree_cur *cur = NULL;
5895 struct xfs_bmbt_irec got, prev;
5896 struct xfs_iext_cursor icur;
5897 xfs_fileoff_t new_startoff;
5898 int error = 0;
5899 int logflags = 0;
5900
5901 if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
5902 XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
5903 return -EFSCORRUPTED;
5904 }
5905
5906 if (XFS_FORCED_SHUTDOWN(mp))
5907 return -EIO;
5908
5909 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL));
5910
5911 if (!(ifp->if_flags & XFS_IFEXTENTS)) {
5912 error = xfs_iread_extents(tp, ip, whichfork);
5913 if (error)
5914 return error;
5915 }
5916
5917 if (ifp->if_flags & XFS_IFBROOT) {
5918 cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
5919 cur->bc_ino.flags = 0;
5920 }
5921
5922 if (!xfs_iext_lookup_extent(ip, ifp, *next_fsb, &icur, &got)) {
5923 *done = true;
5924 goto del_cursor;
5925 }
5926 if (XFS_IS_CORRUPT(mp, isnullstartblock(got.br_startblock))) {
5927 error = -EFSCORRUPTED;
5928 goto del_cursor;
5929 }
5930
5931 new_startoff = got.br_startoff - offset_shift_fsb;
5932 if (xfs_iext_peek_prev_extent(ifp, &icur, &prev)) {
5933 if (new_startoff < prev.br_startoff + prev.br_blockcount) {
5934 error = -EINVAL;
5935 goto del_cursor;
5936 }
5937
5938 if (xfs_bmse_can_merge(&prev, &got, offset_shift_fsb)) {
5939 error = xfs_bmse_merge(tp, ip, whichfork,
5940 offset_shift_fsb, &icur, &got, &prev,
5941 cur, &logflags);
5942 if (error)
5943 goto del_cursor;
5944 goto done;
5945 }
5946 } else {
5947 if (got.br_startoff < offset_shift_fsb) {
5948 error = -EINVAL;
5949 goto del_cursor;
5950 }
5951 }
5952
5953 error = xfs_bmap_shift_update_extent(tp, ip, whichfork, &icur, &got,
5954 cur, &logflags, new_startoff);
5955 if (error)
5956 goto del_cursor;
5957
5958 done:
5959 if (!xfs_iext_next_extent(ifp, &icur, &got)) {
5960 *done = true;
5961 goto del_cursor;
5962 }
5963
5964 *next_fsb = got.br_startoff;
5965 del_cursor:
5966 if (cur)
5967 xfs_btree_del_cursor(cur, error);
5968 if (logflags)
5969 xfs_trans_log_inode(tp, ip, logflags);
5970 return error;
5971 }
5972
5973 /* Make sure we won't be right-shifting an extent past the maximum bound. */
5974 int
5975 xfs_bmap_can_insert_extents(
5976 struct xfs_inode *ip,
5977 xfs_fileoff_t off,
5978 xfs_fileoff_t shift)
5979 {
5980 struct xfs_bmbt_irec got;
5981 int is_empty;
5982 int error = 0;
5983
5984 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
5985
5986 if (XFS_FORCED_SHUTDOWN(ip->i_mount))
5987 return -EIO;
5988
5989 xfs_ilock(ip, XFS_ILOCK_EXCL);
5990 error = xfs_bmap_last_extent(NULL, ip, XFS_DATA_FORK, &got, &is_empty);
5991 if (!error && !is_empty && got.br_startoff >= off &&
5992 ((got.br_startoff + shift) & BMBT_STARTOFF_MASK) < got.br_startoff)
5993 error = -EINVAL;
5994 xfs_iunlock(ip, XFS_ILOCK_EXCL);
5995
5996 return error;
5997 }
5998
5999 int
6000 xfs_bmap_insert_extents(
6001 struct xfs_trans *tp,
6002 struct xfs_inode *ip,
6003 xfs_fileoff_t *next_fsb,
6004 xfs_fileoff_t offset_shift_fsb,
6005 bool *done,
6006 xfs_fileoff_t stop_fsb)
6007 {
6008 int whichfork = XFS_DATA_FORK;
6009 struct xfs_mount *mp = ip->i_mount;
6010 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
6011 struct xfs_btree_cur *cur = NULL;
6012 struct xfs_bmbt_irec got, next;
6013 struct xfs_iext_cursor icur;
6014 xfs_fileoff_t new_startoff;
6015 int error = 0;
6016 int logflags = 0;
6017
6018 if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
6019 XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
6020 return -EFSCORRUPTED;
6021 }
6022
6023 if (XFS_FORCED_SHUTDOWN(mp))
6024 return -EIO;
6025
6026 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL));
6027
6028 if (!(ifp->if_flags & XFS_IFEXTENTS)) {
6029 error = xfs_iread_extents(tp, ip, whichfork);
6030 if (error)
6031 return error;
6032 }
6033
6034 if (ifp->if_flags & XFS_IFBROOT) {
6035 cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
6036 cur->bc_ino.flags = 0;
6037 }
6038
6039 if (*next_fsb == NULLFSBLOCK) {
6040 xfs_iext_last(ifp, &icur);
6041 if (!xfs_iext_get_extent(ifp, &icur, &got) ||
6042 stop_fsb > got.br_startoff) {
6043 *done = true;
6044 goto del_cursor;
6045 }
6046 } else {
6047 if (!xfs_iext_lookup_extent(ip, ifp, *next_fsb, &icur, &got)) {
6048 *done = true;
6049 goto del_cursor;
6050 }
6051 }
6052 if (XFS_IS_CORRUPT(mp, isnullstartblock(got.br_startblock))) {
6053 error = -EFSCORRUPTED;
6054 goto del_cursor;
6055 }
6056
6057 if (XFS_IS_CORRUPT(mp, stop_fsb > got.br_startoff)) {
6058 error = -EFSCORRUPTED;
6059 goto del_cursor;
6060 }
6061
6062 new_startoff = got.br_startoff + offset_shift_fsb;
6063 if (xfs_iext_peek_next_extent(ifp, &icur, &next)) {
6064 if (new_startoff + got.br_blockcount > next.br_startoff) {
6065 error = -EINVAL;
6066 goto del_cursor;
6067 }
6068
6069 /*
6070 * Unlike a left shift (which involves a hole punch), a right
6071 * shift does not modify extent neighbors in any way. We should
6072 * never find mergeable extents in this scenario. Check anyways
6073 * and warn if we encounter two extents that could be one.
6074 */
6075 if (xfs_bmse_can_merge(&got, &next, offset_shift_fsb))
6076 WARN_ON_ONCE(1);
6077 }
6078
6079 error = xfs_bmap_shift_update_extent(tp, ip, whichfork, &icur, &got,
6080 cur, &logflags, new_startoff);
6081 if (error)
6082 goto del_cursor;
6083
6084 if (!xfs_iext_prev_extent(ifp, &icur, &got) ||
6085 stop_fsb >= got.br_startoff + got.br_blockcount) {
6086 *done = true;
6087 goto del_cursor;
6088 }
6089
6090 *next_fsb = got.br_startoff;
6091 del_cursor:
6092 if (cur)
6093 xfs_btree_del_cursor(cur, error);
6094 if (logflags)
6095 xfs_trans_log_inode(tp, ip, logflags);
6096 return error;
6097 }
6098
6099 /*
6100 * Splits an extent into two extents at split_fsb block such that it is the
6101 * first block of the current_ext. @ext is a target extent to be split.
6102 * @split_fsb is a block where the extents is split. If split_fsb lies in a
6103 * hole or the first block of extents, just return 0.
6104 */
6105 int
6106 xfs_bmap_split_extent(
6107 struct xfs_trans *tp,
6108 struct xfs_inode *ip,
6109 xfs_fileoff_t split_fsb)
6110 {
6111 int whichfork = XFS_DATA_FORK;
6112 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
6113 struct xfs_btree_cur *cur = NULL;
6114 struct xfs_bmbt_irec got;
6115 struct xfs_bmbt_irec new; /* split extent */
6116 struct xfs_mount *mp = ip->i_mount;
6117 xfs_fsblock_t gotblkcnt; /* new block count for got */
6118 struct xfs_iext_cursor icur;
6119 int error = 0;
6120 int logflags = 0;
6121 int i = 0;
6122
6123 if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
6124 XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
6125 return -EFSCORRUPTED;
6126 }
6127
6128 if (XFS_FORCED_SHUTDOWN(mp))
6129 return -EIO;
6130
6131 if (!(ifp->if_flags & XFS_IFEXTENTS)) {
6132 /* Read in all the extents */
6133 error = xfs_iread_extents(tp, ip, whichfork);
6134 if (error)
6135 return error;
6136 }
6137
6138 /*
6139 * If there are not extents, or split_fsb lies in a hole we are done.
6140 */
6141 if (!xfs_iext_lookup_extent(ip, ifp, split_fsb, &icur, &got) ||
6142 got.br_startoff >= split_fsb)
6143 return 0;
6144
6145 gotblkcnt = split_fsb - got.br_startoff;
6146 new.br_startoff = split_fsb;
6147 new.br_startblock = got.br_startblock + gotblkcnt;
6148 new.br_blockcount = got.br_blockcount - gotblkcnt;
6149 new.br_state = got.br_state;
6150
6151 if (ifp->if_flags & XFS_IFBROOT) {
6152 cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
6153 cur->bc_ino.flags = 0;
6154 error = xfs_bmbt_lookup_eq(cur, &got, &i);
6155 if (error)
6156 goto del_cursor;
6157 if (XFS_IS_CORRUPT(mp, i != 1)) {
6158 error = -EFSCORRUPTED;
6159 goto del_cursor;
6160 }
6161 }
6162
6163 got.br_blockcount = gotblkcnt;
6164 xfs_iext_update_extent(ip, xfs_bmap_fork_to_state(whichfork), &icur,
6165 &got);
6166
6167 logflags = XFS_ILOG_CORE;
6168 if (cur) {
6169 error = xfs_bmbt_update(cur, &got);
6170 if (error)
6171 goto del_cursor;
6172 } else
6173 logflags |= XFS_ILOG_DEXT;
6174
6175 /* Add new extent */
6176 xfs_iext_next(ifp, &icur);
6177 xfs_iext_insert(ip, &icur, &new, 0);
6178 ifp->if_nextents++;
6179
6180 if (cur) {
6181 error = xfs_bmbt_lookup_eq(cur, &new, &i);
6182 if (error)
6183 goto del_cursor;
6184 if (XFS_IS_CORRUPT(mp, i != 0)) {
6185 error = -EFSCORRUPTED;
6186 goto del_cursor;
6187 }
6188 error = xfs_btree_insert(cur, &i);
6189 if (error)
6190 goto del_cursor;
6191 if (XFS_IS_CORRUPT(mp, i != 1)) {
6192 error = -EFSCORRUPTED;
6193 goto del_cursor;
6194 }
6195 }
6196
6197 /*
6198 * Convert to a btree if necessary.
6199 */
6200 if (xfs_bmap_needs_btree(ip, whichfork)) {
6201 int tmp_logflags; /* partial log flag return val */
6202
6203 ASSERT(cur == NULL);
6204 error = xfs_bmap_extents_to_btree(tp, ip, &cur, 0,
6205 &tmp_logflags, whichfork);
6206 logflags |= tmp_logflags;
6207 }
6208
6209 del_cursor:
6210 if (cur) {
6211 cur->bc_ino.allocated = 0;
6212 xfs_btree_del_cursor(cur, error);
6213 }
6214
6215 if (logflags)
6216 xfs_trans_log_inode(tp, ip, logflags);
6217 return error;
6218 }
6219
6220 /* Deferred mapping is only for real extents in the data fork. */
6221 static bool
6222 xfs_bmap_is_update_needed(
6223 struct xfs_bmbt_irec *bmap)
6224 {
6225 return bmap->br_startblock != HOLESTARTBLOCK &&
6226 bmap->br_startblock != DELAYSTARTBLOCK;
6227 }
6228
6229 /* Record a bmap intent. */
6230 static int
6231 __xfs_bmap_add(
6232 struct xfs_trans *tp,
6233 enum xfs_bmap_intent_type type,
6234 struct xfs_inode *ip,
6235 int whichfork,
6236 struct xfs_bmbt_irec *bmap)
6237 {
6238 struct xfs_bmap_intent *bi;
6239
6240 trace_xfs_bmap_defer(tp->t_mountp,
6241 XFS_FSB_TO_AGNO(tp->t_mountp, bmap->br_startblock),
6242 type,
6243 XFS_FSB_TO_AGBNO(tp->t_mountp, bmap->br_startblock),
6244 ip->i_ino, whichfork,
6245 bmap->br_startoff,
6246 bmap->br_blockcount,
6247 bmap->br_state);
6248
6249 bi = kmem_alloc(sizeof(struct xfs_bmap_intent), KM_NOFS);
6250 INIT_LIST_HEAD(&bi->bi_list);
6251 bi->bi_type = type;
6252 bi->bi_owner = ip;
6253 bi->bi_whichfork = whichfork;
6254 bi->bi_bmap = *bmap;
6255
6256 xfs_defer_add(tp, XFS_DEFER_OPS_TYPE_BMAP, &bi->bi_list);
6257 return 0;
6258 }
6259
6260 /* Map an extent into a file. */
6261 void
6262 xfs_bmap_map_extent(
6263 struct xfs_trans *tp,
6264 struct xfs_inode *ip,
6265 struct xfs_bmbt_irec *PREV)
6266 {
6267 if (!xfs_bmap_is_update_needed(PREV))
6268 return;
6269
6270 __xfs_bmap_add(tp, XFS_BMAP_MAP, ip, XFS_DATA_FORK, PREV);
6271 }
6272
6273 /* Unmap an extent out of a file. */
6274 void
6275 xfs_bmap_unmap_extent(
6276 struct xfs_trans *tp,
6277 struct xfs_inode *ip,
6278 struct xfs_bmbt_irec *PREV)
6279 {
6280 if (!xfs_bmap_is_update_needed(PREV))
6281 return;
6282
6283 __xfs_bmap_add(tp, XFS_BMAP_UNMAP, ip, XFS_DATA_FORK, PREV);
6284 }
6285
6286 /*
6287 * Process one of the deferred bmap operations. We pass back the
6288 * btree cursor to maintain our lock on the bmapbt between calls.
6289 */
6290 int
6291 xfs_bmap_finish_one(
6292 struct xfs_trans *tp,
6293 struct xfs_inode *ip,
6294 enum xfs_bmap_intent_type type,
6295 int whichfork,
6296 xfs_fileoff_t startoff,
6297 xfs_fsblock_t startblock,
6298 xfs_filblks_t *blockcount,
6299 xfs_exntst_t state)
6300 {
6301 int error = 0;
6302
6303 ASSERT(tp->t_firstblock == NULLFSBLOCK);
6304
6305 trace_xfs_bmap_deferred(tp->t_mountp,
6306 XFS_FSB_TO_AGNO(tp->t_mountp, startblock), type,
6307 XFS_FSB_TO_AGBNO(tp->t_mountp, startblock),
6308 ip->i_ino, whichfork, startoff, *blockcount, state);
6309
6310 if (WARN_ON_ONCE(whichfork != XFS_DATA_FORK))
6311 return -EFSCORRUPTED;
6312
6313 if (XFS_TEST_ERROR(false, tp->t_mountp,
6314 XFS_ERRTAG_BMAP_FINISH_ONE))
6315 return -EIO;
6316
6317 switch (type) {
6318 case XFS_BMAP_MAP:
6319 error = xfs_bmapi_remap(tp, ip, startoff, *blockcount,
6320 startblock, 0);
6321 *blockcount = 0;
6322 break;
6323 case XFS_BMAP_UNMAP:
6324 error = __xfs_bunmapi(tp, ip, startoff, blockcount,
6325 XFS_BMAPI_REMAP, 1);
6326 break;
6327 default:
6328 ASSERT(0);
6329 error = -EFSCORRUPTED;
6330 }
6331
6332 return error;
6333 }
6334
6335 /* Check that an inode's extent does not have invalid flags or bad ranges. */
6336 xfs_failaddr_t
6337 xfs_bmap_validate_extent(
6338 struct xfs_inode *ip,
6339 int whichfork,
6340 struct xfs_bmbt_irec *irec)
6341 {
6342 struct xfs_mount *mp = ip->i_mount;
6343
6344 if (!xfs_verify_fileext(mp, irec->br_startoff, irec->br_blockcount))
6345 return __this_address;
6346
6347 if (XFS_IS_REALTIME_INODE(ip) && whichfork == XFS_DATA_FORK) {
6348 if (!xfs_verify_rtext(mp, irec->br_startblock,
6349 irec->br_blockcount))
6350 return __this_address;
6351 } else {
6352 if (!xfs_verify_fsbext(mp, irec->br_startblock,
6353 irec->br_blockcount))
6354 return __this_address;
6355 }
6356 if (irec->br_state != XFS_EXT_NORM && whichfork != XFS_DATA_FORK)
6357 return __this_address;
6358 return NULL;
6359 }
Unnamed repository; edit this file 'description' to name the repository.