]>
Commit | Line | Data |
---|---|---|
37b3b4d6 | 1 | // SPDX-License-Identifier: GPL-2.0 |
2bd0ea18 | 2 | /* |
da23017d NS |
3 | * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc. |
4 | * All Rights Reserved. | |
2bd0ea18 | 5 | */ |
9c799827 | 6 | #include "libxfs_priv.h" |
b626fb59 DC |
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" | |
f944d3d0 | 14 | #include "xfs_defer.h" |
b626fb59 DC |
15 | #include "xfs_inode.h" |
16 | #include "xfs_trans.h" | |
17 | #include "xfs_alloc.h" | |
18 | #include "xfs_btree.h" | |
19 | #include "xfs_bmap_btree.h" | |
20 | #include "xfs_bmap.h" | |
21 | #include "xfs_trace.h" | |
22 | #include "xfs_cksum.h" | |
85aec44f | 23 | #include "xfs_rmap.h" |
2bd0ea18 | 24 | |
2bd0ea18 NS |
25 | /* |
26 | * Convert on-disk form of btree root to in-memory form. | |
27 | */ | |
28 | void | |
29 | xfs_bmdr_to_bmbt( | |
5dfa5cd2 | 30 | struct xfs_inode *ip, |
2bd0ea18 NS |
31 | xfs_bmdr_block_t *dblock, |
32 | int dblocklen, | |
b3563c19 | 33 | struct xfs_btree_block *rblock, |
2bd0ea18 NS |
34 | int rblocklen) |
35 | { | |
5dfa5cd2 | 36 | struct xfs_mount *mp = ip->i_mount; |
2bd0ea18 NS |
37 | int dmxr; |
38 | xfs_bmbt_key_t *fkp; | |
5e656dbb | 39 | __be64 *fpp; |
2bd0ea18 | 40 | xfs_bmbt_key_t *tkp; |
5e656dbb | 41 | __be64 *tpp; |
2bd0ea18 | 42 | |
e394a4b1 ES |
43 | xfs_btree_init_block_int(mp, rblock, XFS_BUF_DADDR_NULL, |
44 | XFS_BTNUM_BMAP, 0, 0, ip->i_ino, | |
f4241a08 | 45 | XFS_BTREE_LONG_PTRS); |
6e3140c7 NS |
46 | rblock->bb_level = dblock->bb_level; |
47 | ASSERT(be16_to_cpu(rblock->bb_level) > 0); | |
48 | rblock->bb_numrecs = dblock->bb_numrecs; | |
ff105f75 | 49 | dmxr = xfs_bmdr_maxrecs(dblocklen, 0); |
b3563c19 BN |
50 | fkp = XFS_BMDR_KEY_ADDR(dblock, 1); |
51 | tkp = XFS_BMBT_KEY_ADDR(mp, rblock, 1); | |
52 | fpp = XFS_BMDR_PTR_ADDR(dblock, 1, dmxr); | |
53 | tpp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, rblocklen); | |
6e3140c7 | 54 | dmxr = be16_to_cpu(dblock->bb_numrecs); |
32181a02 | 55 | memcpy(tkp, fkp, sizeof(*fkp) * dmxr); |
5e656dbb | 56 | memcpy(tpp, fpp, sizeof(*fpp) * dmxr); |
2bd0ea18 NS |
57 | } |
58 | ||
f9e56f43 | 59 | void |
b37d753d CH |
60 | xfs_bmbt_disk_get_all( |
61 | struct xfs_bmbt_rec *rec, | |
62 | struct xfs_bmbt_irec *irec) | |
2bd0ea18 | 63 | { |
b37d753d CH |
64 | uint64_t l0 = get_unaligned_be64(&rec->l0); |
65 | uint64_t l1 = get_unaligned_be64(&rec->l1); | |
f9e56f43 | 66 | |
b37d753d CH |
67 | irec->br_startoff = (l0 & xfs_mask64lo(64 - BMBT_EXNTFLAG_BITLEN)) >> 9; |
68 | irec->br_startblock = ((l0 & xfs_mask64lo(9)) << 43) | (l1 >> 21); | |
69 | irec->br_blockcount = l1 & xfs_mask64lo(21); | |
70 | if (l0 >> (64 - BMBT_EXNTFLAG_BITLEN)) | |
71 | irec->br_state = XFS_EXT_UNWRITTEN; | |
72 | else | |
73 | irec->br_state = XFS_EXT_NORM; | |
f9e56f43 NS |
74 | } |
75 | ||
2bd0ea18 | 76 | /* |
b194c7d8 | 77 | * Extract the blockcount field from an on disk bmap extent record. |
2bd0ea18 | 78 | */ |
b194c7d8 BN |
79 | xfs_filblks_t |
80 | xfs_bmbt_disk_get_blockcount( | |
81 | xfs_bmbt_rec_t *r) | |
2bd0ea18 | 82 | { |
56b2de80 | 83 | return (xfs_filblks_t)(be64_to_cpu(r->l1) & xfs_mask64lo(21)); |
2bd0ea18 NS |
84 | } |
85 | ||
2bd0ea18 | 86 | /* |
b194c7d8 | 87 | * Extract the startoff field from a disk format bmap extent record. |
2bd0ea18 | 88 | */ |
b194c7d8 BN |
89 | xfs_fileoff_t |
90 | xfs_bmbt_disk_get_startoff( | |
91 | xfs_bmbt_rec_t *r) | |
2bd0ea18 | 92 | { |
b194c7d8 | 93 | return ((xfs_fileoff_t)be64_to_cpu(r->l0) & |
56b2de80 | 94 | xfs_mask64lo(64 - BMBT_EXNTFLAG_BITLEN)) >> 9; |
2bd0ea18 NS |
95 | } |
96 | ||
2bd0ea18 | 97 | /* |
d0e5f1ff | 98 | * Set all the fields in a bmap extent record from the uncompressed form. |
2bd0ea18 NS |
99 | */ |
100 | void | |
d0e5f1ff CH |
101 | xfs_bmbt_disk_set_all( |
102 | struct xfs_bmbt_rec *r, | |
103 | struct xfs_bmbt_irec *s) | |
2bd0ea18 | 104 | { |
d0e5f1ff | 105 | int extent_flag = (s->br_state != XFS_EXT_NORM); |
5e656dbb | 106 | |
d0e5f1ff CH |
107 | ASSERT(s->br_state == XFS_EXT_NORM || s->br_state == XFS_EXT_UNWRITTEN); |
108 | ASSERT(!(s->br_startoff & xfs_mask64hi(64-BMBT_STARTOFF_BITLEN))); | |
109 | ASSERT(!(s->br_blockcount & xfs_mask64hi(64-BMBT_BLOCKCOUNT_BITLEN))); | |
110 | ASSERT(!(s->br_startblock & xfs_mask64hi(64-BMBT_STARTBLOCK_BITLEN))); | |
5e656dbb | 111 | |
c2e6c704 | 112 | put_unaligned_be64( |
5e656dbb | 113 | ((xfs_bmbt_rec_base_t)extent_flag << 63) | |
d0e5f1ff | 114 | ((xfs_bmbt_rec_base_t)s->br_startoff << 9) | |
c2e6c704 CH |
115 | ((xfs_bmbt_rec_base_t)s->br_startblock >> 43), &r->l0); |
116 | put_unaligned_be64( | |
d0e5f1ff CH |
117 | ((xfs_bmbt_rec_base_t)s->br_startblock << 21) | |
118 | ((xfs_bmbt_rec_base_t)s->br_blockcount & | |
c2e6c704 | 119 | (xfs_bmbt_rec_base_t)xfs_mask64lo(21)), &r->l1); |
2bd0ea18 | 120 | } |
5e656dbb | 121 | |
2bd0ea18 NS |
122 | /* |
123 | * Convert in-memory form of btree root to on-disk form. | |
124 | */ | |
125 | void | |
126 | xfs_bmbt_to_bmdr( | |
b3563c19 BN |
127 | struct xfs_mount *mp, |
128 | struct xfs_btree_block *rblock, | |
2bd0ea18 NS |
129 | int rblocklen, |
130 | xfs_bmdr_block_t *dblock, | |
131 | int dblocklen) | |
132 | { | |
133 | int dmxr; | |
134 | xfs_bmbt_key_t *fkp; | |
5e656dbb | 135 | __be64 *fpp; |
2bd0ea18 | 136 | xfs_bmbt_key_t *tkp; |
5e656dbb | 137 | __be64 *tpp; |
2bd0ea18 | 138 | |
5dfa5cd2 DC |
139 | if (xfs_sb_version_hascrc(&mp->m_sb)) { |
140 | ASSERT(rblock->bb_magic == cpu_to_be32(XFS_BMAP_CRC_MAGIC)); | |
9c4e12fb ES |
141 | ASSERT(uuid_equal(&rblock->bb_u.l.bb_uuid, |
142 | &mp->m_sb.sb_meta_uuid)); | |
5dfa5cd2 DC |
143 | ASSERT(rblock->bb_u.l.bb_blkno == |
144 | cpu_to_be64(XFS_BUF_DADDR_NULL)); | |
145 | } else | |
146 | ASSERT(rblock->bb_magic == cpu_to_be32(XFS_BMAP_MAGIC)); | |
5a35bf2c DC |
147 | ASSERT(rblock->bb_u.l.bb_leftsib == cpu_to_be64(NULLFSBLOCK)); |
148 | ASSERT(rblock->bb_u.l.bb_rightsib == cpu_to_be64(NULLFSBLOCK)); | |
a2ceac1f | 149 | ASSERT(rblock->bb_level != 0); |
6e3140c7 NS |
150 | dblock->bb_level = rblock->bb_level; |
151 | dblock->bb_numrecs = rblock->bb_numrecs; | |
ff105f75 | 152 | dmxr = xfs_bmdr_maxrecs(dblocklen, 0); |
b3563c19 BN |
153 | fkp = XFS_BMBT_KEY_ADDR(mp, rblock, 1); |
154 | tkp = XFS_BMDR_KEY_ADDR(dblock, 1); | |
155 | fpp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, rblocklen); | |
156 | tpp = XFS_BMDR_PTR_ADDR(dblock, 1, dmxr); | |
6e3140c7 | 157 | dmxr = be16_to_cpu(dblock->bb_numrecs); |
32181a02 | 158 | memcpy(tkp, fkp, sizeof(*fkp) * dmxr); |
5e656dbb | 159 | memcpy(tpp, fpp, sizeof(*fpp) * dmxr); |
2bd0ea18 NS |
160 | } |
161 | ||
b194c7d8 BN |
162 | STATIC struct xfs_btree_cur * |
163 | xfs_bmbt_dup_cursor( | |
164 | struct xfs_btree_cur *cur) | |
165 | { | |
166 | struct xfs_btree_cur *new; | |
167 | ||
168 | new = xfs_bmbt_init_cursor(cur->bc_mp, cur->bc_tp, | |
169 | cur->bc_private.b.ip, cur->bc_private.b.whichfork); | |
170 | ||
171 | /* | |
f33cea1a | 172 | * Copy the firstblock, dfops, and flags values, |
b194c7d8 BN |
173 | * since init cursor doesn't get them. |
174 | */ | |
b194c7d8 BN |
175 | new->bc_private.b.flags = cur->bc_private.b.flags; |
176 | ||
177 | return new; | |
178 | } | |
179 | ||
180 | STATIC void | |
181 | xfs_bmbt_update_cursor( | |
182 | struct xfs_btree_cur *src, | |
183 | struct xfs_btree_cur *dst) | |
184 | { | |
f44a348b | 185 | ASSERT((dst->bc_tp->t_firstblock != NULLFSBLOCK) || |
b194c7d8 | 186 | (dst->bc_private.b.ip->i_d.di_flags & XFS_DIFLAG_REALTIME)); |
b194c7d8 BN |
187 | |
188 | dst->bc_private.b.allocated += src->bc_private.b.allocated; | |
f44a348b | 189 | dst->bc_tp->t_firstblock = src->bc_tp->t_firstblock; |
b194c7d8 BN |
190 | |
191 | src->bc_private.b.allocated = 0; | |
192 | } | |
193 | ||
194 | STATIC int | |
195 | xfs_bmbt_alloc_block( | |
196 | struct xfs_btree_cur *cur, | |
197 | union xfs_btree_ptr *start, | |
198 | union xfs_btree_ptr *new, | |
b194c7d8 BN |
199 | int *stat) |
200 | { | |
201 | xfs_alloc_arg_t args; /* block allocation args */ | |
202 | int error; /* error return value */ | |
203 | ||
204 | memset(&args, 0, sizeof(args)); | |
205 | args.tp = cur->bc_tp; | |
206 | args.mp = cur->bc_mp; | |
f44a348b | 207 | args.fsbno = cur->bc_tp->t_firstblock; |
85aec44f DW |
208 | xfs_rmap_ino_bmbt_owner(&args.oinfo, cur->bc_private.b.ip->i_ino, |
209 | cur->bc_private.b.whichfork); | |
b194c7d8 BN |
210 | |
211 | if (args.fsbno == NULLFSBLOCK) { | |
212 | args.fsbno = be64_to_cpu(start->l); | |
213 | args.type = XFS_ALLOCTYPE_START_BNO; | |
214 | /* | |
215 | * Make sure there is sufficient room left in the AG to | |
216 | * complete a full tree split for an extent insert. If | |
217 | * we are converting the middle part of an extent then | |
218 | * we may need space for two tree splits. | |
219 | * | |
220 | * We are relying on the caller to make the correct block | |
221 | * reservation for this operation to succeed. If the | |
222 | * reservation amount is insufficient then we may fail a | |
223 | * block allocation here and corrupt the filesystem. | |
224 | */ | |
0268fdc3 | 225 | args.minleft = args.tp->t_blk_res; |
565e96c6 | 226 | } else if (cur->bc_tp->t_flags & XFS_TRANS_LOWMODE) { |
b194c7d8 BN |
227 | args.type = XFS_ALLOCTYPE_START_BNO; |
228 | } else { | |
229 | args.type = XFS_ALLOCTYPE_NEAR_BNO; | |
230 | } | |
231 | ||
232 | args.minlen = args.maxlen = args.prod = 1; | |
233 | args.wasdel = cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL; | |
0268fdc3 | 234 | if (!args.wasdel && args.tp->t_blk_res == 0) { |
12b53197 | 235 | error = -ENOSPC; |
b194c7d8 BN |
236 | goto error0; |
237 | } | |
238 | error = xfs_alloc_vextent(&args); | |
239 | if (error) | |
240 | goto error0; | |
241 | ||
242 | if (args.fsbno == NULLFSBLOCK && args.minleft) { | |
243 | /* | |
244 | * Could not find an AG with enough free space to satisfy | |
a3b4a951 | 245 | * a full btree split. Try again and if |
b194c7d8 BN |
246 | * successful activate the lowspace algorithm. |
247 | */ | |
248 | args.fsbno = 0; | |
249 | args.type = XFS_ALLOCTYPE_FIRST_AG; | |
b194c7d8 BN |
250 | error = xfs_alloc_vextent(&args); |
251 | if (error) | |
252 | goto error0; | |
565e96c6 | 253 | cur->bc_tp->t_flags |= XFS_TRANS_LOWMODE; |
b194c7d8 | 254 | } |
c1587ecf | 255 | if (WARN_ON_ONCE(args.fsbno == NULLFSBLOCK)) { |
b194c7d8 BN |
256 | *stat = 0; |
257 | return 0; | |
258 | } | |
97b3ffd0 | 259 | |
b194c7d8 | 260 | ASSERT(args.len == 1); |
f44a348b | 261 | cur->bc_tp->t_firstblock = args.fsbno; |
b194c7d8 BN |
262 | cur->bc_private.b.allocated++; |
263 | cur->bc_private.b.ip->i_d.di_nblocks++; | |
264 | xfs_trans_log_inode(args.tp, cur->bc_private.b.ip, XFS_ILOG_CORE); | |
56b2de80 | 265 | xfs_trans_mod_dquot_byino(args.tp, cur->bc_private.b.ip, |
b194c7d8 BN |
266 | XFS_TRANS_DQ_BCOUNT, 1L); |
267 | ||
268 | new->l = cpu_to_be64(args.fsbno); | |
269 | ||
b194c7d8 BN |
270 | *stat = 1; |
271 | return 0; | |
272 | ||
273 | error0: | |
b194c7d8 BN |
274 | return error; |
275 | } | |
276 | ||
277 | STATIC int | |
278 | xfs_bmbt_free_block( | |
279 | struct xfs_btree_cur *cur, | |
280 | struct xfs_buf *bp) | |
281 | { | |
282 | struct xfs_mount *mp = cur->bc_mp; | |
283 | struct xfs_inode *ip = cur->bc_private.b.ip; | |
284 | struct xfs_trans *tp = cur->bc_tp; | |
285 | xfs_fsblock_t fsbno = XFS_DADDR_TO_FSB(mp, XFS_BUF_ADDR(bp)); | |
85aec44f | 286 | struct xfs_owner_info oinfo; |
b194c7d8 | 287 | |
85aec44f | 288 | xfs_rmap_ino_bmbt_owner(&oinfo, ip->i_ino, cur->bc_private.b.whichfork); |
21375e5d | 289 | xfs_bmap_add_free(cur->bc_tp, fsbno, 1, &oinfo); |
b194c7d8 BN |
290 | ip->i_d.di_nblocks--; |
291 | ||
292 | xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); | |
56b2de80 | 293 | xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, -1L); |
b194c7d8 BN |
294 | return 0; |
295 | } | |
296 | ||
297 | STATIC int | |
298 | xfs_bmbt_get_minrecs( | |
299 | struct xfs_btree_cur *cur, | |
300 | int level) | |
301 | { | |
b3563c19 BN |
302 | if (level == cur->bc_nlevels - 1) { |
303 | struct xfs_ifork *ifp; | |
304 | ||
305 | ifp = XFS_IFORK_PTR(cur->bc_private.b.ip, | |
306 | cur->bc_private.b.whichfork); | |
307 | ||
308 | return xfs_bmbt_maxrecs(cur->bc_mp, | |
309 | ifp->if_broot_bytes, level == 0) / 2; | |
310 | } | |
311 | ||
312 | return cur->bc_mp->m_bmap_dmnr[level != 0]; | |
b194c7d8 BN |
313 | } |
314 | ||
b3563c19 | 315 | int |
b194c7d8 BN |
316 | xfs_bmbt_get_maxrecs( |
317 | struct xfs_btree_cur *cur, | |
318 | int level) | |
319 | { | |
b3563c19 BN |
320 | if (level == cur->bc_nlevels - 1) { |
321 | struct xfs_ifork *ifp; | |
322 | ||
323 | ifp = XFS_IFORK_PTR(cur->bc_private.b.ip, | |
324 | cur->bc_private.b.whichfork); | |
325 | ||
326 | return xfs_bmbt_maxrecs(cur->bc_mp, | |
327 | ifp->if_broot_bytes, level == 0); | |
328 | } | |
329 | ||
330 | return cur->bc_mp->m_bmap_dmxr[level != 0]; | |
331 | ||
b194c7d8 BN |
332 | } |
333 | ||
334 | /* | |
335 | * Get the maximum records we could store in the on-disk format. | |
336 | * | |
337 | * For non-root nodes this is equivalent to xfs_bmbt_get_maxrecs, but | |
338 | * for the root node this checks the available space in the dinode fork | |
339 | * so that we can resize the in-memory buffer to match it. After a | |
340 | * resize to the maximum size this function returns the same value | |
341 | * as xfs_bmbt_get_maxrecs for the root node, too. | |
342 | */ | |
343 | STATIC int | |
344 | xfs_bmbt_get_dmaxrecs( | |
345 | struct xfs_btree_cur *cur, | |
346 | int level) | |
347 | { | |
b3563c19 BN |
348 | if (level != cur->bc_nlevels - 1) |
349 | return cur->bc_mp->m_bmap_dmxr[level != 0]; | |
ff105f75 | 350 | return xfs_bmdr_maxrecs(cur->bc_private.b.forksize, level == 0); |
b194c7d8 BN |
351 | } |
352 | ||
353 | STATIC void | |
354 | xfs_bmbt_init_key_from_rec( | |
355 | union xfs_btree_key *key, | |
356 | union xfs_btree_rec *rec) | |
357 | { | |
358 | key->bmbt.br_startoff = | |
359 | cpu_to_be64(xfs_bmbt_disk_get_startoff(&rec->bmbt)); | |
360 | } | |
361 | ||
4e388bc9 DW |
362 | STATIC void |
363 | xfs_bmbt_init_high_key_from_rec( | |
364 | union xfs_btree_key *key, | |
365 | union xfs_btree_rec *rec) | |
366 | { | |
367 | key->bmbt.br_startoff = cpu_to_be64( | |
368 | xfs_bmbt_disk_get_startoff(&rec->bmbt) + | |
369 | xfs_bmbt_disk_get_blockcount(&rec->bmbt) - 1); | |
370 | } | |
371 | ||
b194c7d8 BN |
372 | STATIC void |
373 | xfs_bmbt_init_rec_from_cur( | |
374 | struct xfs_btree_cur *cur, | |
375 | union xfs_btree_rec *rec) | |
376 | { | |
377 | xfs_bmbt_disk_set_all(&rec->bmbt, &cur->bc_rec.b); | |
378 | } | |
379 | ||
380 | STATIC void | |
381 | xfs_bmbt_init_ptr_from_cur( | |
382 | struct xfs_btree_cur *cur, | |
383 | union xfs_btree_ptr *ptr) | |
384 | { | |
385 | ptr->l = 0; | |
386 | } | |
387 | ||
4a492e72 | 388 | STATIC int64_t |
b194c7d8 BN |
389 | xfs_bmbt_key_diff( |
390 | struct xfs_btree_cur *cur, | |
391 | union xfs_btree_key *key) | |
392 | { | |
4a492e72 | 393 | return (int64_t)be64_to_cpu(key->bmbt.br_startoff) - |
b194c7d8 BN |
394 | cur->bc_rec.b.br_startoff; |
395 | } | |
396 | ||
4e388bc9 DW |
397 | STATIC int64_t |
398 | xfs_bmbt_diff_two_keys( | |
399 | struct xfs_btree_cur *cur, | |
400 | union xfs_btree_key *k1, | |
401 | union xfs_btree_key *k2) | |
402 | { | |
403 | return (int64_t)be64_to_cpu(k1->bmbt.br_startoff) - | |
404 | be64_to_cpu(k2->bmbt.br_startoff); | |
405 | } | |
406 | ||
bc01119d | 407 | static xfs_failaddr_t |
a2ceac1f DC |
408 | xfs_bmbt_verify( |
409 | struct xfs_buf *bp) | |
410 | { | |
411 | struct xfs_mount *mp = bp->b_target->bt_mount; | |
412 | struct xfs_btree_block *block = XFS_BUF_TO_BLOCK(bp); | |
bc01119d | 413 | xfs_failaddr_t fa; |
a2ceac1f | 414 | unsigned int level; |
a2ceac1f | 415 | |
c0adfb03 DC |
416 | switch (block->bb_magic) { |
417 | case cpu_to_be32(XFS_BMAP_CRC_MAGIC): | |
5dfa5cd2 DC |
418 | /* |
419 | * XXX: need a better way of verifying the owner here. Right now | |
420 | * just make sure there has been one set. | |
421 | */ | |
bc01119d DW |
422 | fa = xfs_btree_lblock_v5hdr_verify(bp, XFS_RMAP_OWN_UNKNOWN); |
423 | if (fa) | |
424 | return fa; | |
5dfa5cd2 | 425 | /* fall through */ |
c0adfb03 | 426 | case cpu_to_be32(XFS_BMAP_MAGIC): |
5dfa5cd2 DC |
427 | break; |
428 | default: | |
bc01119d | 429 | return __this_address; |
5dfa5cd2 DC |
430 | } |
431 | ||
432 | /* | |
433 | * numrecs and level verification. | |
a2ceac1f | 434 | * |
5dfa5cd2 | 435 | * We don't know what fork we belong to, so just verify that the level |
a2ceac1f DC |
436 | * is less than the maximum of the two. Later checks will be more |
437 | * precise. | |
438 | */ | |
439 | level = be16_to_cpu(block->bb_level); | |
e6d77a21 | 440 | if (level > max(mp->m_bm_maxlevels[0], mp->m_bm_maxlevels[1])) |
bc01119d | 441 | return __this_address; |
5dfa5cd2 | 442 | |
fb75464f | 443 | return xfs_btree_lblock_verify(bp, mp->m_bmap_dmxr[level != 0]); |
a2ceac1f DC |
444 | } |
445 | ||
446 | static void | |
447 | xfs_bmbt_read_verify( | |
448 | struct xfs_buf *bp) | |
449 | { | |
1e697959 DW |
450 | xfs_failaddr_t fa; |
451 | ||
45922933 | 452 | if (!xfs_btree_lblock_verify_crc(bp)) |
1e697959 DW |
453 | xfs_verifier_error(bp, -EFSBADCRC, __this_address); |
454 | else { | |
455 | fa = xfs_bmbt_verify(bp); | |
456 | if (fa) | |
457 | xfs_verifier_error(bp, -EFSCORRUPTED, fa); | |
458 | } | |
45922933 | 459 | |
7e6c95f1 | 460 | if (bp->b_error) |
45922933 | 461 | trace_xfs_btree_corrupt(bp, _RET_IP_); |
a2ceac1f DC |
462 | } |
463 | ||
464 | static void | |
465 | xfs_bmbt_write_verify( | |
466 | struct xfs_buf *bp) | |
467 | { | |
1e697959 DW |
468 | xfs_failaddr_t fa; |
469 | ||
470 | fa = xfs_bmbt_verify(bp); | |
471 | if (fa) { | |
5dfa5cd2 | 472 | trace_xfs_btree_corrupt(bp, _RET_IP_); |
1e697959 | 473 | xfs_verifier_error(bp, -EFSCORRUPTED, fa); |
5dfa5cd2 DC |
474 | return; |
475 | } | |
476 | xfs_btree_lblock_calc_crc(bp); | |
a2ceac1f DC |
477 | } |
478 | ||
479 | const struct xfs_buf_ops xfs_bmbt_buf_ops = { | |
a3fac935 | 480 | .name = "xfs_bmbt", |
a2ceac1f DC |
481 | .verify_read = xfs_bmbt_read_verify, |
482 | .verify_write = xfs_bmbt_write_verify, | |
95d9582b | 483 | .verify_struct = xfs_bmbt_verify, |
a2ceac1f DC |
484 | }; |
485 | ||
486 | ||
b194c7d8 BN |
487 | STATIC int |
488 | xfs_bmbt_keys_inorder( | |
489 | struct xfs_btree_cur *cur, | |
490 | union xfs_btree_key *k1, | |
491 | union xfs_btree_key *k2) | |
492 | { | |
493 | return be64_to_cpu(k1->bmbt.br_startoff) < | |
494 | be64_to_cpu(k2->bmbt.br_startoff); | |
495 | } | |
496 | ||
497 | STATIC int | |
498 | xfs_bmbt_recs_inorder( | |
499 | struct xfs_btree_cur *cur, | |
500 | union xfs_btree_rec *r1, | |
501 | union xfs_btree_rec *r2) | |
502 | { | |
503 | return xfs_bmbt_disk_get_startoff(&r1->bmbt) + | |
504 | xfs_bmbt_disk_get_blockcount(&r1->bmbt) <= | |
505 | xfs_bmbt_disk_get_startoff(&r2->bmbt); | |
506 | } | |
b194c7d8 | 507 | |
b194c7d8 BN |
508 | static const struct xfs_btree_ops xfs_bmbt_ops = { |
509 | .rec_len = sizeof(xfs_bmbt_rec_t), | |
510 | .key_len = sizeof(xfs_bmbt_key_t), | |
511 | ||
512 | .dup_cursor = xfs_bmbt_dup_cursor, | |
513 | .update_cursor = xfs_bmbt_update_cursor, | |
514 | .alloc_block = xfs_bmbt_alloc_block, | |
515 | .free_block = xfs_bmbt_free_block, | |
516 | .get_maxrecs = xfs_bmbt_get_maxrecs, | |
517 | .get_minrecs = xfs_bmbt_get_minrecs, | |
518 | .get_dmaxrecs = xfs_bmbt_get_dmaxrecs, | |
519 | .init_key_from_rec = xfs_bmbt_init_key_from_rec, | |
4e388bc9 | 520 | .init_high_key_from_rec = xfs_bmbt_init_high_key_from_rec, |
b194c7d8 BN |
521 | .init_rec_from_cur = xfs_bmbt_init_rec_from_cur, |
522 | .init_ptr_from_cur = xfs_bmbt_init_ptr_from_cur, | |
523 | .key_diff = xfs_bmbt_key_diff, | |
4e388bc9 | 524 | .diff_two_keys = xfs_bmbt_diff_two_keys, |
a2ceac1f | 525 | .buf_ops = &xfs_bmbt_buf_ops, |
b194c7d8 BN |
526 | .keys_inorder = xfs_bmbt_keys_inorder, |
527 | .recs_inorder = xfs_bmbt_recs_inorder, | |
b194c7d8 BN |
528 | }; |
529 | ||
530 | /* | |
531 | * Allocate a new bmap btree cursor. | |
532 | */ | |
533 | struct xfs_btree_cur * /* new bmap btree cursor */ | |
534 | xfs_bmbt_init_cursor( | |
535 | struct xfs_mount *mp, /* file system mount point */ | |
536 | struct xfs_trans *tp, /* transaction pointer */ | |
537 | struct xfs_inode *ip, /* inode owning the btree */ | |
538 | int whichfork) /* data or attr fork */ | |
539 | { | |
540 | struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); | |
541 | struct xfs_btree_cur *cur; | |
cb8a004a | 542 | ASSERT(whichfork != XFS_COW_FORK); |
b194c7d8 | 543 | |
762989ef | 544 | cur = kmem_zone_zalloc(xfs_btree_cur_zone, KM_NOFS); |
b194c7d8 BN |
545 | |
546 | cur->bc_tp = tp; | |
547 | cur->bc_mp = mp; | |
548 | cur->bc_nlevels = be16_to_cpu(ifp->if_broot->bb_level) + 1; | |
549 | cur->bc_btnum = XFS_BTNUM_BMAP; | |
550 | cur->bc_blocklog = mp->m_sb.sb_blocklog; | |
5d8acc46 | 551 | cur->bc_statoff = XFS_STATS_CALC_INDEX(xs_bmbt_2); |
b194c7d8 BN |
552 | |
553 | cur->bc_ops = &xfs_bmbt_ops; | |
554 | cur->bc_flags = XFS_BTREE_LONG_PTRS | XFS_BTREE_ROOT_IN_INODE; | |
5dfa5cd2 DC |
555 | if (xfs_sb_version_hascrc(&mp->m_sb)) |
556 | cur->bc_flags |= XFS_BTREE_CRC_BLOCKS; | |
b194c7d8 BN |
557 | |
558 | cur->bc_private.b.forksize = XFS_IFORK_SIZE(ip, whichfork); | |
559 | cur->bc_private.b.ip = ip; | |
b194c7d8 BN |
560 | cur->bc_private.b.allocated = 0; |
561 | cur->bc_private.b.flags = 0; | |
562 | cur->bc_private.b.whichfork = whichfork; | |
563 | ||
564 | return cur; | |
565 | } | |
b3563c19 BN |
566 | |
567 | /* | |
568 | * Calculate number of records in a bmap btree block. | |
569 | */ | |
570 | int | |
571 | xfs_bmbt_maxrecs( | |
572 | struct xfs_mount *mp, | |
573 | int blocklen, | |
574 | int leaf) | |
575 | { | |
576 | blocklen -= XFS_BMBT_BLOCK_LEN(mp); | |
577 | ||
578 | if (leaf) | |
579 | return blocklen / sizeof(xfs_bmbt_rec_t); | |
580 | return blocklen / (sizeof(xfs_bmbt_key_t) + sizeof(xfs_bmbt_ptr_t)); | |
581 | } | |
582 | ||
583 | /* | |
584 | * Calculate number of records in a bmap btree inode root. | |
585 | */ | |
586 | int | |
587 | xfs_bmdr_maxrecs( | |
b3563c19 BN |
588 | int blocklen, |
589 | int leaf) | |
590 | { | |
591 | blocklen -= sizeof(xfs_bmdr_block_t); | |
592 | ||
593 | if (leaf) | |
594 | return blocklen / sizeof(xfs_bmdr_rec_t); | |
595 | return blocklen / (sizeof(xfs_bmdr_key_t) + sizeof(xfs_bmdr_ptr_t)); | |
596 | } | |
9c6ebc42 DC |
597 | |
598 | /* | |
ff105f75 | 599 | * Change the owner of a btree format fork fo the inode passed in. Change it to |
9c6ebc42 DC |
600 | * the owner of that is passed in so that we can change owners before or after |
601 | * we switch forks between inodes. The operation that the caller is doing will | |
602 | * determine whether is needs to change owner before or after the switch. | |
603 | * | |
604 | * For demand paged transactional modification, the fork switch should be done | |
605 | * after reading in all the blocks, modifying them and pinning them in the | |
606 | * transaction. For modification when the buffers are already pinned in memory, | |
607 | * the fork switch can be done before changing the owner as we won't need to | |
608 | * validate the owner until the btree buffers are unpinned and writes can occur | |
609 | * again. | |
610 | * | |
611 | * For recovery based ownership change, there is no transactional context and | |
612 | * so a buffer list must be supplied so that we can record the buffers that we | |
613 | * modified for the caller to issue IO on. | |
614 | */ | |
615 | int | |
616 | xfs_bmbt_change_owner( | |
617 | struct xfs_trans *tp, | |
618 | struct xfs_inode *ip, | |
619 | int whichfork, | |
620 | xfs_ino_t new_owner, | |
621 | struct list_head *buffer_list) | |
622 | { | |
623 | struct xfs_btree_cur *cur; | |
624 | int error; | |
625 | ||
626 | ASSERT(tp || buffer_list); | |
627 | ASSERT(!(tp && buffer_list)); | |
628 | if (whichfork == XFS_DATA_FORK) | |
629 | ASSERT(ip->i_d.di_format == XFS_DINODE_FMT_BTREE); | |
630 | else | |
631 | ASSERT(ip->i_d.di_aformat == XFS_DINODE_FMT_BTREE); | |
632 | ||
633 | cur = xfs_bmbt_init_cursor(ip->i_mount, tp, ip, whichfork); | |
634 | if (!cur) | |
12b53197 | 635 | return -ENOMEM; |
c7ba1731 | 636 | cur->bc_private.b.flags |= XFS_BTCUR_BPRV_INVALID_OWNER; |
9c6ebc42 DC |
637 | |
638 | error = xfs_btree_change_owner(cur, new_owner, buffer_list); | |
660265b7 | 639 | xfs_btree_del_cursor(cur, error); |
9c6ebc42 DC |
640 | return error; |
641 | } | |
5f728383 DW |
642 | |
643 | /* Calculate the bmap btree size for some records. */ | |
644 | unsigned long long | |
645 | xfs_bmbt_calc_size( | |
646 | struct xfs_mount *mp, | |
647 | unsigned long long len) | |
648 | { | |
649 | return xfs_btree_calc_size(mp->m_bmap_dmnr, len); | |
650 | } |