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