Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0
2 : /*
3 : * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
4 : * All Rights Reserved.
5 : */
6 : #include "xfs.h"
7 : #include "xfs_fs.h"
8 : #include "xfs_shared.h"
9 : #include "xfs_format.h"
10 : #include "xfs_log_format.h"
11 : #include "xfs_trans_resv.h"
12 : #include "xfs_bit.h"
13 : #include "xfs_mount.h"
14 : #include "xfs_inode.h"
15 : #include "xfs_trans.h"
16 : #include "xfs_alloc.h"
17 : #include "xfs_btree.h"
18 : #include "xfs_bmap_btree.h"
19 : #include "xfs_bmap.h"
20 : #include "xfs_error.h"
21 : #include "xfs_quota.h"
22 : #include "xfs_trace.h"
23 : #include "xfs_rmap.h"
24 : #include "xfs_ag.h"
25 :
26 : static struct kmem_cache *xfs_bmbt_cur_cache;
27 :
28 : /*
29 : * Convert on-disk form of btree root to in-memory form.
30 : */
31 : void
32 5927596 : xfs_bmdr_to_bmbt(
33 : struct xfs_inode *ip,
34 : xfs_bmdr_block_t *dblock,
35 : int dblocklen,
36 : struct xfs_btree_block *rblock,
37 : int rblocklen)
38 : {
39 5927596 : struct xfs_mount *mp = ip->i_mount;
40 5927596 : int dmxr;
41 5927596 : xfs_bmbt_key_t *fkp;
42 5927596 : __be64 *fpp;
43 5927596 : xfs_bmbt_key_t *tkp;
44 5927596 : __be64 *tpp;
45 :
46 5927596 : xfs_btree_init_block_int(mp, rblock, XFS_BUF_DADDR_NULL,
47 : XFS_BTNUM_BMAP, 0, 0, ip->i_ino,
48 : XFS_BTREE_LONG_PTRS);
49 5927592 : rblock->bb_level = dblock->bb_level;
50 5927592 : ASSERT(be16_to_cpu(rblock->bb_level) > 0);
51 5927592 : rblock->bb_numrecs = dblock->bb_numrecs;
52 5927592 : dmxr = xfs_bmdr_maxrecs(dblocklen, 0);
53 5927592 : fkp = XFS_BMDR_KEY_ADDR(dblock, 1);
54 11855184 : tkp = XFS_BMBT_KEY_ADDR(mp, rblock, 1);
55 5927592 : fpp = XFS_BMDR_PTR_ADDR(dblock, 1, dmxr);
56 5927592 : tpp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, rblocklen);
57 5927592 : dmxr = be16_to_cpu(dblock->bb_numrecs);
58 5927592 : memcpy(tkp, fkp, sizeof(*fkp) * dmxr);
59 11855184 : memcpy(tpp, fpp, sizeof(*fpp) * dmxr);
60 5927592 : }
61 :
62 : void
63 1798456348 : xfs_bmbt_disk_get_all(
64 : const struct xfs_bmbt_rec *rec,
65 : struct xfs_bmbt_irec *irec)
66 : {
67 3596912696 : uint64_t l0 = get_unaligned_be64(&rec->l0);
68 1798456348 : uint64_t l1 = get_unaligned_be64(&rec->l1);
69 :
70 1798456348 : irec->br_startoff = (l0 & xfs_mask64lo(64 - BMBT_EXNTFLAG_BITLEN)) >> 9;
71 1798456348 : irec->br_startblock = ((l0 & xfs_mask64lo(9)) << 43) | (l1 >> 21);
72 1798456348 : irec->br_blockcount = l1 & xfs_mask64lo(21);
73 1798456348 : if (l0 >> (64 - BMBT_EXNTFLAG_BITLEN))
74 189548215 : irec->br_state = XFS_EXT_UNWRITTEN;
75 : else
76 1608908133 : irec->br_state = XFS_EXT_NORM;
77 1798456348 : }
78 :
79 : /*
80 : * Extract the blockcount field from an on disk bmap extent record.
81 : */
82 : xfs_filblks_t
83 >12608*10^7 : xfs_bmbt_disk_get_blockcount(
84 : const struct xfs_bmbt_rec *r)
85 : {
86 >12653*10^7 : return (xfs_filblks_t)(be64_to_cpu(r->l1) & xfs_mask64lo(21));
87 : }
88 :
89 : /*
90 : * Extract the startoff field from a disk format bmap extent record.
91 : */
92 : xfs_fileoff_t
93 >25214*10^7 : xfs_bmbt_disk_get_startoff(
94 : const struct xfs_bmbt_rec *r)
95 : {
96 >25524*10^7 : return ((xfs_fileoff_t)be64_to_cpu(r->l0) &
97 >25524*10^7 : xfs_mask64lo(64 - BMBT_EXNTFLAG_BITLEN)) >> 9;
98 : }
99 :
100 : /*
101 : * Set all the fields in a bmap extent record from the uncompressed form.
102 : */
103 : void
104 3301455582 : xfs_bmbt_disk_set_all(
105 : struct xfs_bmbt_rec *r,
106 : struct xfs_bmbt_irec *s)
107 : {
108 3301455582 : int extent_flag = (s->br_state != XFS_EXT_NORM);
109 :
110 3301455582 : ASSERT(s->br_state == XFS_EXT_NORM || s->br_state == XFS_EXT_UNWRITTEN);
111 3301455582 : ASSERT(!(s->br_startoff & xfs_mask64hi(64-BMBT_STARTOFF_BITLEN)));
112 3301455582 : ASSERT(!(s->br_blockcount & xfs_mask64hi(64-BMBT_BLOCKCOUNT_BITLEN)));
113 3301455582 : ASSERT(!(s->br_startblock & xfs_mask64hi(64-BMBT_STARTBLOCK_BITLEN)));
114 :
115 3301455582 : put_unaligned_be64(
116 3301455582 : ((xfs_bmbt_rec_base_t)extent_flag << 63) |
117 3301455582 : ((xfs_bmbt_rec_base_t)s->br_startoff << 9) |
118 3301455582 : ((xfs_bmbt_rec_base_t)s->br_startblock >> 43), &r->l0);
119 3301455582 : put_unaligned_be64(
120 3301455582 : ((xfs_bmbt_rec_base_t)s->br_startblock << 21) |
121 3301455582 : ((xfs_bmbt_rec_base_t)s->br_blockcount &
122 : (xfs_bmbt_rec_base_t)xfs_mask64lo(21)), &r->l1);
123 3301455582 : }
124 :
125 : /*
126 : * Convert in-memory form of btree root to on-disk form.
127 : */
128 : void
129 973256 : xfs_bmbt_to_bmdr(
130 : struct xfs_mount *mp,
131 : struct xfs_btree_block *rblock,
132 : int rblocklen,
133 : xfs_bmdr_block_t *dblock,
134 : int dblocklen)
135 : {
136 973256 : int dmxr;
137 973256 : xfs_bmbt_key_t *fkp;
138 973256 : __be64 *fpp;
139 973256 : xfs_bmbt_key_t *tkp;
140 973256 : __be64 *tpp;
141 :
142 973256 : if (xfs_has_crc(mp)) {
143 973256 : ASSERT(rblock->bb_magic == cpu_to_be32(XFS_BMAP_CRC_MAGIC));
144 973256 : ASSERT(uuid_equal(&rblock->bb_u.l.bb_uuid,
145 : &mp->m_sb.sb_meta_uuid));
146 973256 : ASSERT(rblock->bb_u.l.bb_blkno ==
147 : cpu_to_be64(XFS_BUF_DADDR_NULL));
148 : } else
149 0 : ASSERT(rblock->bb_magic == cpu_to_be32(XFS_BMAP_MAGIC));
150 973256 : ASSERT(rblock->bb_u.l.bb_leftsib == cpu_to_be64(NULLFSBLOCK));
151 973256 : ASSERT(rblock->bb_u.l.bb_rightsib == cpu_to_be64(NULLFSBLOCK));
152 973256 : ASSERT(rblock->bb_level != 0);
153 973256 : dblock->bb_level = rblock->bb_level;
154 973256 : dblock->bb_numrecs = rblock->bb_numrecs;
155 973256 : dmxr = xfs_bmdr_maxrecs(dblocklen, 0);
156 1946512 : fkp = XFS_BMBT_KEY_ADDR(mp, rblock, 1);
157 973256 : tkp = XFS_BMDR_KEY_ADDR(dblock, 1);
158 973256 : fpp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, rblocklen);
159 973256 : tpp = XFS_BMDR_PTR_ADDR(dblock, 1, dmxr);
160 973256 : dmxr = be16_to_cpu(dblock->bb_numrecs);
161 973256 : memcpy(tkp, fkp, sizeof(*fkp) * dmxr);
162 1946512 : memcpy(tpp, fpp, sizeof(*fpp) * dmxr);
163 973256 : }
164 :
165 : STATIC struct xfs_btree_cur *
166 55866209 : xfs_bmbt_dup_cursor(
167 : struct xfs_btree_cur *cur)
168 : {
169 55866209 : struct xfs_btree_cur *new;
170 :
171 55866209 : new = xfs_bmbt_init_cursor(cur->bc_mp, cur->bc_tp,
172 55866209 : cur->bc_ino.ip, cur->bc_ino.whichfork);
173 :
174 : /*
175 : * Copy the firstblock, dfops, and flags values,
176 : * since init cursor doesn't get them.
177 : */
178 55867038 : new->bc_ino.flags = cur->bc_ino.flags;
179 :
180 55867038 : return new;
181 : }
182 :
183 : STATIC void
184 481216 : xfs_bmbt_update_cursor(
185 : struct xfs_btree_cur *src,
186 : struct xfs_btree_cur *dst)
187 : {
188 481216 : ASSERT((dst->bc_tp->t_highest_agno != NULLAGNUMBER) ||
189 : (dst->bc_ino.ip->i_diflags & XFS_DIFLAG_REALTIME));
190 :
191 481216 : dst->bc_ino.allocated += src->bc_ino.allocated;
192 481216 : dst->bc_tp->t_highest_agno = src->bc_tp->t_highest_agno;
193 :
194 481216 : src->bc_ino.allocated = 0;
195 481216 : }
196 :
197 : STATIC int
198 484074 : xfs_bmbt_alloc_block(
199 : struct xfs_btree_cur *cur,
200 : const union xfs_btree_ptr *start,
201 : union xfs_btree_ptr *new,
202 : int *stat)
203 : {
204 484074 : struct xfs_alloc_arg args;
205 484074 : int error;
206 :
207 484074 : memset(&args, 0, sizeof(args));
208 484074 : args.tp = cur->bc_tp;
209 484074 : args.mp = cur->bc_mp;
210 484074 : xfs_rmap_ino_bmbt_owner(&args.oinfo, cur->bc_ino.ip->i_ino,
211 484074 : cur->bc_ino.whichfork);
212 484074 : args.minlen = args.maxlen = args.prod = 1;
213 484074 : args.wasdel = cur->bc_ino.flags & XFS_BTCUR_BMBT_WASDEL;
214 484074 : if (!args.wasdel && args.tp->t_blk_res == 0)
215 : return -ENOSPC;
216 :
217 : /*
218 : * If we are coming here from something like unwritten extent
219 : * conversion, there has been no data extent allocation already done, so
220 : * we have to ensure that we attempt to locate the entire set of bmbt
221 : * allocations in the same AG, as xfs_bmapi_write() would have reserved.
222 : */
223 484074 : if (cur->bc_tp->t_highest_agno == NULLAGNUMBER)
224 451580 : args.minleft = xfs_bmapi_minleft(cur->bc_tp, cur->bc_ino.ip,
225 : cur->bc_ino.whichfork);
226 :
227 484074 : error = xfs_alloc_vextent_start_ag(&args, be64_to_cpu(start->l));
228 484075 : if (error)
229 : return error;
230 :
231 484073 : if (args.fsbno == NULLFSBLOCK && args.minleft) {
232 : /*
233 : * Could not find an AG with enough free space to satisfy
234 : * a full btree split. Try again and if
235 : * successful activate the lowspace algorithm.
236 : */
237 0 : args.minleft = 0;
238 0 : error = xfs_alloc_vextent_start_ag(&args, 0);
239 0 : if (error)
240 : return error;
241 0 : cur->bc_tp->t_flags |= XFS_TRANS_LOWMODE;
242 : }
243 484073 : if (WARN_ON_ONCE(args.fsbno == NULLFSBLOCK)) {
244 0 : *stat = 0;
245 0 : return 0;
246 : }
247 :
248 484073 : ASSERT(args.len == 1);
249 484073 : cur->bc_ino.allocated++;
250 484073 : cur->bc_ino.ip->i_nblocks++;
251 484073 : xfs_trans_log_inode(args.tp, cur->bc_ino.ip, XFS_ILOG_CORE);
252 484074 : xfs_trans_mod_dquot_byino(args.tp, cur->bc_ino.ip,
253 : XFS_TRANS_DQ_BCOUNT, 1L);
254 :
255 484074 : new->l = cpu_to_be64(args.fsbno);
256 :
257 484074 : *stat = 1;
258 484074 : return 0;
259 : }
260 :
261 : STATIC int
262 177585 : xfs_bmbt_free_block(
263 : struct xfs_btree_cur *cur,
264 : struct xfs_buf *bp)
265 : {
266 177585 : struct xfs_mount *mp = cur->bc_mp;
267 177585 : struct xfs_inode *ip = cur->bc_ino.ip;
268 177585 : struct xfs_trans *tp = cur->bc_tp;
269 177585 : xfs_fsblock_t fsbno = XFS_DADDR_TO_FSB(mp, xfs_buf_daddr(bp));
270 177585 : struct xfs_owner_info oinfo;
271 177585 : int error;
272 :
273 177585 : xfs_rmap_ino_bmbt_owner(&oinfo, ip->i_ino, cur->bc_ino.whichfork);
274 177585 : error = xfs_free_extent_later(cur->bc_tp, fsbno, 1, &oinfo,
275 : XFS_AG_RESV_NONE);
276 177585 : if (error)
277 : return error;
278 :
279 177585 : ip->i_nblocks--;
280 177585 : xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
281 177585 : xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, -1L);
282 177585 : return 0;
283 : }
284 :
285 : STATIC int
286 103437060 : xfs_bmbt_get_minrecs(
287 : struct xfs_btree_cur *cur,
288 : int level)
289 : {
290 103437060 : if (level == cur->bc_nlevels - 1) {
291 3983825 : struct xfs_ifork *ifp;
292 :
293 3983825 : ifp = xfs_ifork_ptr(cur->bc_ino.ip,
294 3983825 : cur->bc_ino.whichfork);
295 :
296 3983715 : return xfs_bmbt_maxrecs(cur->bc_mp,
297 7967430 : ifp->if_broot_bytes, level == 0) / 2;
298 : }
299 :
300 99453235 : return cur->bc_mp->m_bmap_dmnr[level != 0];
301 : }
302 :
303 : int
304 1691646368 : xfs_bmbt_get_maxrecs(
305 : struct xfs_btree_cur *cur,
306 : int level)
307 : {
308 1691646368 : if (level == cur->bc_nlevels - 1) {
309 359826975 : struct xfs_ifork *ifp;
310 :
311 359826975 : ifp = xfs_ifork_ptr(cur->bc_ino.ip,
312 359826975 : cur->bc_ino.whichfork);
313 :
314 359823716 : return xfs_bmbt_maxrecs(cur->bc_mp,
315 359823716 : ifp->if_broot_bytes, level == 0);
316 : }
317 :
318 1331819393 : return cur->bc_mp->m_bmap_dmxr[level != 0];
319 :
320 : }
321 :
322 : /*
323 : * Get the maximum records we could store in the on-disk format.
324 : *
325 : * For non-root nodes this is equivalent to xfs_bmbt_get_maxrecs, but
326 : * for the root node this checks the available space in the dinode fork
327 : * so that we can resize the in-memory buffer to match it. After a
328 : * resize to the maximum size this function returns the same value
329 : * as xfs_bmbt_get_maxrecs for the root node, too.
330 : */
331 : STATIC int
332 4113130 : xfs_bmbt_get_dmaxrecs(
333 : struct xfs_btree_cur *cur,
334 : int level)
335 : {
336 4113130 : if (level != cur->bc_nlevels - 1)
337 0 : return cur->bc_mp->m_bmap_dmxr[level != 0];
338 4113130 : return xfs_bmdr_maxrecs(cur->bc_ino.forksize, level == 0);
339 : }
340 :
341 : STATIC void
342 2648954514 : xfs_bmbt_init_key_from_rec(
343 : union xfs_btree_key *key,
344 : const union xfs_btree_rec *rec)
345 : {
346 2648954514 : key->bmbt.br_startoff =
347 2648954514 : cpu_to_be64(xfs_bmbt_disk_get_startoff(&rec->bmbt));
348 2648954514 : }
349 :
350 : STATIC void
351 0 : xfs_bmbt_init_high_key_from_rec(
352 : union xfs_btree_key *key,
353 : const union xfs_btree_rec *rec)
354 : {
355 0 : key->bmbt.br_startoff = cpu_to_be64(
356 : xfs_bmbt_disk_get_startoff(&rec->bmbt) +
357 : xfs_bmbt_disk_get_blockcount(&rec->bmbt) - 1);
358 0 : }
359 :
360 : STATIC void
361 130682042 : xfs_bmbt_init_rec_from_cur(
362 : struct xfs_btree_cur *cur,
363 : union xfs_btree_rec *rec)
364 : {
365 130682042 : xfs_bmbt_disk_set_all(&rec->bmbt, &cur->bc_rec.b);
366 130682427 : }
367 :
368 : STATIC void
369 309286651 : xfs_bmbt_init_ptr_from_cur(
370 : struct xfs_btree_cur *cur,
371 : union xfs_btree_ptr *ptr)
372 : {
373 309286651 : ptr->l = 0;
374 309286651 : }
375 :
376 : STATIC int64_t
377 4075938064 : xfs_bmbt_key_diff(
378 : struct xfs_btree_cur *cur,
379 : const union xfs_btree_key *key)
380 : {
381 4075938064 : return (int64_t)be64_to_cpu(key->bmbt.br_startoff) -
382 4075938064 : cur->bc_rec.b.br_startoff;
383 : }
384 :
385 : STATIC int64_t
386 314299737 : xfs_bmbt_diff_two_keys(
387 : struct xfs_btree_cur *cur,
388 : const union xfs_btree_key *k1,
389 : const union xfs_btree_key *k2,
390 : const union xfs_btree_key *mask)
391 : {
392 314299737 : uint64_t a = be64_to_cpu(k1->bmbt.br_startoff);
393 314299737 : uint64_t b = be64_to_cpu(k2->bmbt.br_startoff);
394 :
395 314299737 : ASSERT(!mask || mask->bmbt.br_startoff);
396 :
397 : /*
398 : * Note: This routine previously casted a and b to int64 and subtracted
399 : * them to generate a result. This lead to problems if b was the
400 : * "maximum" key value (all ones) being signed incorrectly, hence this
401 : * somewhat less efficient version.
402 : */
403 314299737 : if (a > b)
404 : return 1;
405 14346610 : if (b > a)
406 0 : return -1;
407 : return 0;
408 : }
409 :
410 : static xfs_failaddr_t
411 15471899 : xfs_bmbt_verify(
412 : struct xfs_buf *bp)
413 : {
414 15471899 : struct xfs_mount *mp = bp->b_mount;
415 15471899 : struct xfs_btree_block *block = XFS_BUF_TO_BLOCK(bp);
416 15471899 : xfs_failaddr_t fa;
417 15471899 : unsigned int level;
418 :
419 15471899 : if (!xfs_verify_magic(bp, block->bb_magic))
420 0 : return __this_address;
421 :
422 15471220 : if (xfs_has_crc(mp)) {
423 : /*
424 : * XXX: need a better way of verifying the owner here. Right now
425 : * just make sure there has been one set.
426 : */
427 15471254 : fa = xfs_btree_lblock_v5hdr_verify(bp, XFS_RMAP_OWN_UNKNOWN);
428 15471640 : if (fa)
429 : return fa;
430 : }
431 :
432 : /*
433 : * numrecs and level verification.
434 : *
435 : * We don't know what fork we belong to, so just verify that the level
436 : * is less than the maximum of the two. Later checks will be more
437 : * precise.
438 : */
439 15471655 : level = be16_to_cpu(block->bb_level);
440 15471655 : if (level > max(mp->m_bm_maxlevels[0], mp->m_bm_maxlevels[1]))
441 0 : return __this_address;
442 :
443 15471655 : return xfs_btree_lblock_verify(bp, mp->m_bmap_dmxr[level != 0]);
444 : }
445 :
446 : static void
447 4908449 : xfs_bmbt_read_verify(
448 : struct xfs_buf *bp)
449 : {
450 4908449 : xfs_failaddr_t fa;
451 :
452 4908449 : if (!xfs_btree_lblock_verify_crc(bp))
453 20 : xfs_verifier_error(bp, -EFSBADCRC, __this_address);
454 : else {
455 4908429 : fa = xfs_bmbt_verify(bp);
456 4908429 : if (fa)
457 0 : xfs_verifier_error(bp, -EFSCORRUPTED, fa);
458 : }
459 :
460 4908449 : if (bp->b_error)
461 20 : trace_xfs_btree_corrupt(bp, _RET_IP_);
462 4908449 : }
463 :
464 : static void
465 4464724 : xfs_bmbt_write_verify(
466 : struct xfs_buf *bp)
467 : {
468 4464724 : xfs_failaddr_t fa;
469 :
470 4464724 : fa = xfs_bmbt_verify(bp);
471 4464724 : if (fa) {
472 0 : trace_xfs_btree_corrupt(bp, _RET_IP_);
473 0 : xfs_verifier_error(bp, -EFSCORRUPTED, fa);
474 0 : return;
475 : }
476 4464724 : xfs_btree_lblock_calc_crc(bp);
477 : }
478 :
479 : const struct xfs_buf_ops xfs_bmbt_buf_ops = {
480 : .name = "xfs_bmbt",
481 : .magic = { cpu_to_be32(XFS_BMAP_MAGIC),
482 : cpu_to_be32(XFS_BMAP_CRC_MAGIC) },
483 : .verify_read = xfs_bmbt_read_verify,
484 : .verify_write = xfs_bmbt_write_verify,
485 : .verify_struct = xfs_bmbt_verify,
486 : };
487 :
488 :
489 : STATIC int
490 1033163 : xfs_bmbt_keys_inorder(
491 : struct xfs_btree_cur *cur,
492 : const union xfs_btree_key *k1,
493 : const union xfs_btree_key *k2)
494 : {
495 1033163 : return be64_to_cpu(k1->bmbt.br_startoff) <
496 1033163 : be64_to_cpu(k2->bmbt.br_startoff);
497 : }
498 :
499 : STATIC int
500 450678815 : xfs_bmbt_recs_inorder(
501 : struct xfs_btree_cur *cur,
502 : const union xfs_btree_rec *r1,
503 : const union xfs_btree_rec *r2)
504 : {
505 450678815 : return xfs_bmbt_disk_get_startoff(&r1->bmbt) +
506 450678815 : xfs_bmbt_disk_get_blockcount(&r1->bmbt) <=
507 : xfs_bmbt_disk_get_startoff(&r2->bmbt);
508 : }
509 :
510 : STATIC enum xbtree_key_contig
511 0 : xfs_bmbt_keys_contiguous(
512 : struct xfs_btree_cur *cur,
513 : const union xfs_btree_key *key1,
514 : const union xfs_btree_key *key2,
515 : const union xfs_btree_key *mask)
516 : {
517 0 : ASSERT(!mask || mask->bmbt.br_startoff);
518 :
519 0 : return xbtree_key_contig(be64_to_cpu(key1->bmbt.br_startoff),
520 0 : be64_to_cpu(key2->bmbt.br_startoff));
521 : }
522 :
523 : static const struct xfs_btree_ops xfs_bmbt_ops = {
524 : .rec_len = sizeof(xfs_bmbt_rec_t),
525 : .key_len = sizeof(xfs_bmbt_key_t),
526 :
527 : .dup_cursor = xfs_bmbt_dup_cursor,
528 : .update_cursor = xfs_bmbt_update_cursor,
529 : .alloc_block = xfs_bmbt_alloc_block,
530 : .free_block = xfs_bmbt_free_block,
531 : .get_maxrecs = xfs_bmbt_get_maxrecs,
532 : .get_minrecs = xfs_bmbt_get_minrecs,
533 : .get_dmaxrecs = xfs_bmbt_get_dmaxrecs,
534 : .init_key_from_rec = xfs_bmbt_init_key_from_rec,
535 : .init_high_key_from_rec = xfs_bmbt_init_high_key_from_rec,
536 : .init_rec_from_cur = xfs_bmbt_init_rec_from_cur,
537 : .init_ptr_from_cur = xfs_bmbt_init_ptr_from_cur,
538 : .key_diff = xfs_bmbt_key_diff,
539 : .diff_two_keys = xfs_bmbt_diff_two_keys,
540 : .buf_ops = &xfs_bmbt_buf_ops,
541 : .keys_inorder = xfs_bmbt_keys_inorder,
542 : .recs_inorder = xfs_bmbt_recs_inorder,
543 : .keys_contiguous = xfs_bmbt_keys_contiguous,
544 : };
545 :
546 : /*
547 : * Allocate a new bmap btree cursor.
548 : */
549 : struct xfs_btree_cur * /* new bmap btree cursor */
550 339645857 : xfs_bmbt_init_cursor(
551 : struct xfs_mount *mp, /* file system mount point */
552 : struct xfs_trans *tp, /* transaction pointer */
553 : struct xfs_inode *ip, /* inode owning the btree */
554 : int whichfork) /* data or attr fork */
555 : {
556 339645857 : struct xfs_ifork *ifp = xfs_ifork_ptr(ip, whichfork);
557 339640876 : struct xfs_btree_cur *cur;
558 339640876 : ASSERT(whichfork != XFS_COW_FORK);
559 :
560 679283094 : cur = xfs_btree_alloc_cursor(mp, tp, XFS_BTNUM_BMAP,
561 339640876 : mp->m_bm_maxlevels[whichfork], xfs_bmbt_cur_cache);
562 339651432 : cur->bc_nlevels = be16_to_cpu(ifp->if_broot->bb_level) + 1;
563 339651432 : cur->bc_statoff = XFS_STATS_CALC_INDEX(xs_bmbt_2);
564 :
565 339651432 : cur->bc_ops = &xfs_bmbt_ops;
566 339651432 : cur->bc_flags = XFS_BTREE_LONG_PTRS | XFS_BTREE_ROOT_IN_INODE;
567 339651432 : if (xfs_has_crc(mp))
568 339651437 : cur->bc_flags |= XFS_BTREE_CRC_BLOCKS;
569 :
570 339651432 : cur->bc_ino.forksize = xfs_inode_fork_size(ip, whichfork);
571 339651432 : cur->bc_ino.ip = ip;
572 339651432 : cur->bc_ino.allocated = 0;
573 339651432 : cur->bc_ino.flags = 0;
574 339651432 : cur->bc_ino.whichfork = whichfork;
575 :
576 339651432 : return cur;
577 : }
578 :
579 : /* Calculate number of records in a block mapping btree block. */
580 : static inline unsigned int
581 : xfs_bmbt_block_maxrecs(
582 : unsigned int blocklen,
583 : bool leaf)
584 : {
585 1638834702 : if (leaf)
586 59415 : return blocklen / sizeof(xfs_bmbt_rec_t);
587 1631874439 : return blocklen / (sizeof(xfs_bmbt_key_t) + sizeof(xfs_bmbt_ptr_t));
588 : }
589 :
590 : /*
591 : * Calculate number of records in a bmap btree block.
592 : */
593 : int
594 1268126423 : xfs_bmbt_maxrecs(
595 : struct xfs_mount *mp,
596 : int blocklen,
597 : int leaf)
598 : {
599 1631933854 : blocklen -= XFS_BMBT_BLOCK_LEN(mp);
600 2002642133 : return xfs_bmbt_block_maxrecs(blocklen, leaf);
601 : }
602 :
603 : /*
604 : * Calculate the maximum possible height of the btree that the on-disk format
605 : * supports. This is used for sizing structures large enough to support every
606 : * possible configuration of a filesystem that might get mounted.
607 : */
608 : unsigned int
609 118860 : xfs_bmbt_maxlevels_ondisk(void)
610 : {
611 118860 : unsigned int minrecs[2];
612 118860 : unsigned int blocklen;
613 :
614 118860 : blocklen = min(XFS_MIN_BLOCKSIZE - XFS_BTREE_SBLOCK_LEN,
615 : XFS_MIN_CRC_BLOCKSIZE - XFS_BTREE_SBLOCK_CRC_LEN);
616 :
617 118860 : minrecs[0] = xfs_bmbt_block_maxrecs(blocklen, true) / 2;
618 118860 : minrecs[1] = xfs_bmbt_block_maxrecs(blocklen, false) / 2;
619 :
620 : /* One extra level for the inode root. */
621 118860 : return xfs_btree_compute_maxlevels(minrecs,
622 118860 : XFS_MAX_EXTCNT_DATA_FORK_LARGE) + 1;
623 : }
624 :
625 : /*
626 : * Calculate number of records in a bmap btree inode root.
627 : */
628 : int
629 118810 : xfs_bmdr_maxrecs(
630 : int blocklen,
631 : int leaf)
632 : {
633 11132788 : blocklen -= sizeof(xfs_bmdr_block_t);
634 :
635 4231940 : if (leaf)
636 0 : return blocklen / sizeof(xfs_bmdr_rec_t);
637 11132788 : return blocklen / (sizeof(xfs_bmdr_key_t) + sizeof(xfs_bmdr_ptr_t));
638 : }
639 :
640 : /*
641 : * Change the owner of a btree format fork fo the inode passed in. Change it to
642 : * the owner of that is passed in so that we can change owners before or after
643 : * we switch forks between inodes. The operation that the caller is doing will
644 : * determine whether is needs to change owner before or after the switch.
645 : *
646 : * For demand paged transactional modification, the fork switch should be done
647 : * after reading in all the blocks, modifying them and pinning them in the
648 : * transaction. For modification when the buffers are already pinned in memory,
649 : * the fork switch can be done before changing the owner as we won't need to
650 : * validate the owner until the btree buffers are unpinned and writes can occur
651 : * again.
652 : *
653 : * For recovery based ownership change, there is no transactional context and
654 : * so a buffer list must be supplied so that we can record the buffers that we
655 : * modified for the caller to issue IO on.
656 : */
657 : int
658 8396 : xfs_bmbt_change_owner(
659 : struct xfs_trans *tp,
660 : struct xfs_inode *ip,
661 : int whichfork,
662 : xfs_ino_t new_owner,
663 : struct list_head *buffer_list)
664 : {
665 8396 : struct xfs_btree_cur *cur;
666 8396 : int error;
667 :
668 8396 : ASSERT(tp || buffer_list);
669 8396 : ASSERT(!(tp && buffer_list));
670 8396 : ASSERT(xfs_ifork_ptr(ip, whichfork)->if_format == XFS_DINODE_FMT_BTREE);
671 :
672 8396 : cur = xfs_bmbt_init_cursor(ip->i_mount, tp, ip, whichfork);
673 8396 : cur->bc_ino.flags |= XFS_BTCUR_BMBT_INVALID_OWNER;
674 :
675 8396 : error = xfs_btree_change_owner(cur, new_owner, buffer_list);
676 8396 : xfs_btree_del_cursor(cur, error);
677 8396 : return error;
678 : }
679 :
680 : /* Calculate the bmap btree size for some records. */
681 : unsigned long long
682 0 : xfs_bmbt_calc_size(
683 : struct xfs_mount *mp,
684 : unsigned long long len)
685 : {
686 0 : return xfs_btree_calc_size(mp->m_bmap_dmnr, len);
687 : }
688 :
689 : int __init
690 50 : xfs_bmbt_init_cur_cache(void)
691 : {
692 50 : xfs_bmbt_cur_cache = kmem_cache_create("xfs_bmbt_cur",
693 50 : xfs_btree_cur_sizeof(xfs_bmbt_maxlevels_ondisk()),
694 : 0, 0, NULL);
695 :
696 50 : if (!xfs_bmbt_cur_cache)
697 0 : return -ENOMEM;
698 : return 0;
699 : }
700 :
701 : void
702 49 : xfs_bmbt_destroy_cur_cache(void)
703 : {
704 49 : kmem_cache_destroy(xfs_bmbt_cur_cache);
705 49 : xfs_bmbt_cur_cache = NULL;
706 49 : }
|
