blob: 71c2f22a3f6e096d902b5b0d2a0adb9d2868236d [file] [log] [blame]
Dave Chinner0b61f8a2018-06-05 19:42:14 -07001// SPDX-License-Identifier: GPL-2.0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
Nathan Scott7b718762005-11-02 14:58:39 +11003 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
Dave Chinner24df33b2013-04-12 07:30:21 +10004 * Copyright (c) 2013 Red Hat, Inc.
Nathan Scott7b718762005-11-02 14:58:39 +11005 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07007#include "xfs.h"
Nathan Scotta844f452005-11-02 14:38:42 +11008#include "xfs_fs.h"
Darrick J. Wong5467b342019-06-28 19:25:35 -07009#include "xfs_shared.h"
Dave Chinnera4fbe6a2013-10-23 10:51:50 +110010#include "xfs_format.h"
Dave Chinner239880e2013-10-23 10:50:10 +110011#include "xfs_log_format.h"
12#include "xfs_trans_resv.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include "xfs_mount.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include "xfs_inode.h"
15#include "xfs_bmap.h"
Dave Chinner2b9ab5a2013-08-12 20:49:37 +100016#include "xfs_dir2.h"
Christoph Hellwig57926642011-07-13 13:43:48 +020017#include "xfs_dir2_priv.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include "xfs_error.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000019#include "xfs_trace.h"
Dave Chinner239880e2013-10-23 10:50:10 +110020#include "xfs_trans.h"
Dave Chinner24df33b2013-04-12 07:30:21 +100021#include "xfs_buf_item.h"
Darrick J. Wongca14c092024-02-22 12:32:18 -080022#include "xfs_health.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
24/*
25 * Local function declarations.
26 */
Dave Chinner1d9025e2012-06-22 18:50:14 +100027static int xfs_dir2_leaf_lookup_int(xfs_da_args_t *args, struct xfs_buf **lbpp,
Christoph Hellwig787b0892019-11-08 14:57:50 -080028 int *indexp, struct xfs_buf **dbpp,
29 struct xfs_dir3_icleaf_hdr *leafhdr);
Dave Chinnerbc851782014-06-06 15:20:54 +100030static void xfs_dir3_leaf_log_bests(struct xfs_da_args *args,
31 struct xfs_buf *bp, int first, int last);
32static void xfs_dir3_leaf_log_tail(struct xfs_da_args *args,
33 struct xfs_buf *bp);
Christoph Hellwigba0f32d2005-06-21 15:36:52 +100034
Christoph Hellwig51842552019-11-08 14:57:49 -080035void
36xfs_dir2_leaf_hdr_from_disk(
37 struct xfs_mount *mp,
38 struct xfs_dir3_icleaf_hdr *to,
39 struct xfs_dir2_leaf *from)
40{
Dave Chinnerebd90272021-08-18 18:46:55 -070041 if (xfs_has_crc(mp)) {
Christoph Hellwig51842552019-11-08 14:57:49 -080042 struct xfs_dir3_leaf *from3 = (struct xfs_dir3_leaf *)from;
43
44 to->forw = be32_to_cpu(from3->hdr.info.hdr.forw);
45 to->back = be32_to_cpu(from3->hdr.info.hdr.back);
46 to->magic = be16_to_cpu(from3->hdr.info.hdr.magic);
47 to->count = be16_to_cpu(from3->hdr.count);
48 to->stale = be16_to_cpu(from3->hdr.stale);
Christoph Hellwig787b0892019-11-08 14:57:50 -080049 to->ents = from3->__ents;
Christoph Hellwig51842552019-11-08 14:57:49 -080050
51 ASSERT(to->magic == XFS_DIR3_LEAF1_MAGIC ||
52 to->magic == XFS_DIR3_LEAFN_MAGIC);
53 } else {
54 to->forw = be32_to_cpu(from->hdr.info.forw);
55 to->back = be32_to_cpu(from->hdr.info.back);
56 to->magic = be16_to_cpu(from->hdr.info.magic);
57 to->count = be16_to_cpu(from->hdr.count);
58 to->stale = be16_to_cpu(from->hdr.stale);
Christoph Hellwig787b0892019-11-08 14:57:50 -080059 to->ents = from->__ents;
Christoph Hellwig51842552019-11-08 14:57:49 -080060
61 ASSERT(to->magic == XFS_DIR2_LEAF1_MAGIC ||
62 to->magic == XFS_DIR2_LEAFN_MAGIC);
63 }
64}
65
Christoph Hellwig163fbbb2019-11-08 14:57:50 -080066void
67xfs_dir2_leaf_hdr_to_disk(
68 struct xfs_mount *mp,
69 struct xfs_dir2_leaf *to,
70 struct xfs_dir3_icleaf_hdr *from)
71{
Dave Chinnerebd90272021-08-18 18:46:55 -070072 if (xfs_has_crc(mp)) {
Christoph Hellwig163fbbb2019-11-08 14:57:50 -080073 struct xfs_dir3_leaf *to3 = (struct xfs_dir3_leaf *)to;
74
75 ASSERT(from->magic == XFS_DIR3_LEAF1_MAGIC ||
76 from->magic == XFS_DIR3_LEAFN_MAGIC);
77
78 to3->hdr.info.hdr.forw = cpu_to_be32(from->forw);
79 to3->hdr.info.hdr.back = cpu_to_be32(from->back);
80 to3->hdr.info.hdr.magic = cpu_to_be16(from->magic);
81 to3->hdr.count = cpu_to_be16(from->count);
82 to3->hdr.stale = cpu_to_be16(from->stale);
83 } else {
84 ASSERT(from->magic == XFS_DIR2_LEAF1_MAGIC ||
85 from->magic == XFS_DIR2_LEAFN_MAGIC);
86
87 to->hdr.info.forw = cpu_to_be32(from->forw);
88 to->hdr.info.back = cpu_to_be32(from->back);
89 to->hdr.info.magic = cpu_to_be16(from->magic);
90 to->hdr.count = cpu_to_be16(from->count);
91 to->hdr.stale = cpu_to_be16(from->stale);
92 }
93}
94
Dave Chinner24df33b2013-04-12 07:30:21 +100095/*
96 * Check the internal consistency of a leaf1 block.
97 * Pop an assert if something is wrong.
98 */
99#ifdef DEBUG
Darrick J. Wonga6a781a2018-01-08 10:51:03 -0800100static xfs_failaddr_t
Dave Chinner24df33b2013-04-12 07:30:21 +1000101xfs_dir3_leaf1_check(
Dave Chinner41419562013-10-29 22:11:50 +1100102 struct xfs_inode *dp,
Dave Chinner24df33b2013-04-12 07:30:21 +1000103 struct xfs_buf *bp)
104{
105 struct xfs_dir2_leaf *leaf = bp->b_addr;
106 struct xfs_dir3_icleaf_hdr leafhdr;
107
Christoph Hellwig51842552019-11-08 14:57:49 -0800108 xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &leafhdr, leaf);
Dave Chinner24df33b2013-04-12 07:30:21 +1000109
110 if (leafhdr.magic == XFS_DIR3_LEAF1_MAGIC) {
111 struct xfs_dir3_leaf_hdr *leaf3 = bp->b_addr;
Dave Chinner9343ee72021-08-18 18:47:05 -0700112 if (be64_to_cpu(leaf3->info.blkno) != xfs_buf_daddr(bp))
Darrick J. Wonga6a781a2018-01-08 10:51:03 -0800113 return __this_address;
Dave Chinner24df33b2013-04-12 07:30:21 +1000114 } else if (leafhdr.magic != XFS_DIR2_LEAF1_MAGIC)
Darrick J. Wonga6a781a2018-01-08 10:51:03 -0800115 return __this_address;
Dave Chinner24df33b2013-04-12 07:30:21 +1000116
Dave Chinner1fea3232021-03-22 09:52:05 -0700117 return xfs_dir3_leaf_check_int(dp->i_mount, &leafhdr, leaf, false);
Dave Chinner24df33b2013-04-12 07:30:21 +1000118}
Darrick J. Wonga6a781a2018-01-08 10:51:03 -0800119
120static inline void
121xfs_dir3_leaf_check(
122 struct xfs_inode *dp,
123 struct xfs_buf *bp)
124{
125 xfs_failaddr_t fa;
126
127 fa = xfs_dir3_leaf1_check(dp, bp);
128 if (!fa)
129 return;
130 xfs_corruption_error(__func__, XFS_ERRLEVEL_LOW, dp->i_mount,
Darrick J. Wong2551a532018-06-04 10:23:54 -0700131 bp->b_addr, BBTOB(bp->b_length), __FILE__, __LINE__,
132 fa);
Darrick J. Wonga6a781a2018-01-08 10:51:03 -0800133 ASSERT(0);
134}
Dave Chinner24df33b2013-04-12 07:30:21 +1000135#else
Dave Chinner41419562013-10-29 22:11:50 +1100136#define xfs_dir3_leaf_check(dp, bp)
Dave Chinner24df33b2013-04-12 07:30:21 +1000137#endif
138
Darrick J. Wonga6a781a2018-01-08 10:51:03 -0800139xfs_failaddr_t
Dave Chinner24df33b2013-04-12 07:30:21 +1000140xfs_dir3_leaf_check_int(
Christoph Hellwig23220fe2019-11-08 15:06:03 -0800141 struct xfs_mount *mp,
142 struct xfs_dir3_icleaf_hdr *hdr,
Dave Chinner1fea3232021-03-22 09:52:05 -0700143 struct xfs_dir2_leaf *leaf,
144 bool expensive_checking)
Dave Chinner24df33b2013-04-12 07:30:21 +1000145{
Christoph Hellwig23220fe2019-11-08 15:06:03 -0800146 struct xfs_da_geometry *geo = mp->m_dir_geo;
147 xfs_dir2_leaf_tail_t *ltp;
148 int stale;
149 int i;
Guo Xuenan13cf24e2022-10-18 14:32:35 -0700150 bool isleaf1 = (hdr->magic == XFS_DIR2_LEAF1_MAGIC ||
151 hdr->magic == XFS_DIR3_LEAF1_MAGIC);
Dave Chinner01ba43b2013-10-29 22:11:52 +1100152
Dave Chinner8f661932014-06-06 15:15:59 +1000153 ltp = xfs_dir2_leaf_tail_p(geo, leaf);
Dave Chinner24df33b2013-04-12 07:30:21 +1000154
155 /*
156 * XXX (dgc): This value is not restrictive enough.
157 * Should factor in the size of the bests table as well.
Christoph Hellwig13d2c102021-03-29 11:11:40 -0700158 * We can deduce a value for that from i_disk_size.
Dave Chinner24df33b2013-04-12 07:30:21 +1000159 */
Christoph Hellwig478c7832019-11-08 14:57:51 -0800160 if (hdr->count > geo->leaf_max_ents)
Darrick J. Wonga6a781a2018-01-08 10:51:03 -0800161 return __this_address;
Dave Chinner24df33b2013-04-12 07:30:21 +1000162
163 /* Leaves and bests don't overlap in leaf format. */
Guo Xuenan13cf24e2022-10-18 14:32:35 -0700164 if (isleaf1 &&
Christoph Hellwig787b0892019-11-08 14:57:50 -0800165 (char *)&hdr->ents[hdr->count] > (char *)xfs_dir2_leaf_bests_p(ltp))
Darrick J. Wonga6a781a2018-01-08 10:51:03 -0800166 return __this_address;
Dave Chinner24df33b2013-04-12 07:30:21 +1000167
Dave Chinner1fea3232021-03-22 09:52:05 -0700168 if (!expensive_checking)
169 return NULL;
170
Dave Chinner24df33b2013-04-12 07:30:21 +1000171 /* Check hash value order, count stale entries. */
172 for (i = stale = 0; i < hdr->count; i++) {
173 if (i + 1 < hdr->count) {
Christoph Hellwig787b0892019-11-08 14:57:50 -0800174 if (be32_to_cpu(hdr->ents[i].hashval) >
175 be32_to_cpu(hdr->ents[i + 1].hashval))
Darrick J. Wonga6a781a2018-01-08 10:51:03 -0800176 return __this_address;
Dave Chinner24df33b2013-04-12 07:30:21 +1000177 }
Christoph Hellwig787b0892019-11-08 14:57:50 -0800178 if (hdr->ents[i].address == cpu_to_be32(XFS_DIR2_NULL_DATAPTR))
Dave Chinner24df33b2013-04-12 07:30:21 +1000179 stale++;
Guo Xuenan13cf24e2022-10-18 14:32:35 -0700180 if (isleaf1 && xfs_dir2_dataptr_to_db(geo,
181 be32_to_cpu(hdr->ents[i].address)) >=
182 be32_to_cpu(ltp->bestcount))
183 return __this_address;
Dave Chinner24df33b2013-04-12 07:30:21 +1000184 }
185 if (hdr->stale != stale)
Darrick J. Wonga6a781a2018-01-08 10:51:03 -0800186 return __this_address;
187 return NULL;
Dave Chinner24df33b2013-04-12 07:30:21 +1000188}
189
Dave Chinner0f295a22013-09-03 10:06:58 +1000190/*
191 * We verify the magic numbers before decoding the leaf header so that on debug
192 * kernels we don't get assertion failures in xfs_dir3_leaf_hdr_from_disk() due
193 * to incorrect magic numbers.
194 */
Darrick J. Wonga6a781a2018-01-08 10:51:03 -0800195static xfs_failaddr_t
Dave Chinner24df33b2013-04-12 07:30:21 +1000196xfs_dir3_leaf_verify(
Christoph Hellwig23220fe2019-11-08 15:06:03 -0800197 struct xfs_buf *bp)
Dave Chinnere6f76672012-11-12 22:54:15 +1100198{
Christoph Hellwig23220fe2019-11-08 15:06:03 -0800199 struct xfs_mount *mp = bp->b_mount;
200 struct xfs_dir3_icleaf_hdr leafhdr;
201 xfs_failaddr_t fa;
Dave Chinnere6f76672012-11-12 22:54:15 +1100202
Brian Foster8764f982019-02-07 10:45:48 -0800203 fa = xfs_da3_blkinfo_verify(bp, bp->b_addr);
204 if (fa)
205 return fa;
Dave Chinner0f295a22013-09-03 10:06:58 +1000206
Christoph Hellwig23220fe2019-11-08 15:06:03 -0800207 xfs_dir2_leaf_hdr_from_disk(mp, &leafhdr, bp->b_addr);
Dave Chinner1fea3232021-03-22 09:52:05 -0700208 return xfs_dir3_leaf_check_int(mp, &leafhdr, bp->b_addr, true);
Dave Chinner24df33b2013-04-12 07:30:21 +1000209}
210
Darrick J. Wong402eef12024-04-15 14:54:39 -0700211xfs_failaddr_t
212xfs_dir3_leaf_header_check(
213 struct xfs_buf *bp,
214 xfs_ino_t owner)
215{
216 struct xfs_mount *mp = bp->b_mount;
217
218 if (xfs_has_crc(mp)) {
219 struct xfs_dir3_leaf *hdr3 = bp->b_addr;
220
221 if (hdr3->hdr.info.hdr.magic !=
222 cpu_to_be16(XFS_DIR3_LEAF1_MAGIC) &&
223 hdr3->hdr.info.hdr.magic !=
224 cpu_to_be16(XFS_DIR3_LEAFN_MAGIC))
225 return __this_address;
226
227 if (be64_to_cpu(hdr3->hdr.info.owner) != owner)
228 return __this_address;
229 }
230
231 return NULL;
232}
233
Dave Chinner24df33b2013-04-12 07:30:21 +1000234static void
Brian Foster09f42012019-02-07 10:45:47 -0800235xfs_dir3_leaf_read_verify(
236 struct xfs_buf *bp)
Dave Chinner24df33b2013-04-12 07:30:21 +1000237{
Christoph Hellwigdbd329f12019-06-28 19:27:29 -0700238 struct xfs_mount *mp = bp->b_mount;
Darrick J. Wongbc1a09b2018-01-08 10:51:03 -0800239 xfs_failaddr_t fa;
Dave Chinner24df33b2013-04-12 07:30:21 +1000240
Dave Chinner38c26bf2021-08-18 18:46:37 -0700241 if (xfs_has_crc(mp) &&
Eric Sandeence5028c2014-02-27 15:23:10 +1100242 !xfs_buf_verify_cksum(bp, XFS_DIR3_LEAF_CRC_OFF))
Darrick J. Wongbc1a09b2018-01-08 10:51:03 -0800243 xfs_verifier_error(bp, -EFSBADCRC, __this_address);
244 else {
Brian Foster09f42012019-02-07 10:45:47 -0800245 fa = xfs_dir3_leaf_verify(bp);
Darrick J. Wongbc1a09b2018-01-08 10:51:03 -0800246 if (fa)
247 xfs_verifier_error(bp, -EFSCORRUPTED, fa);
248 }
Dave Chinner612cfbf2012-11-14 17:52:32 +1100249}
Dave Chinnere6f76672012-11-12 22:54:15 +1100250
Dave Chinner612cfbf2012-11-14 17:52:32 +1100251static void
Brian Foster09f42012019-02-07 10:45:47 -0800252xfs_dir3_leaf_write_verify(
253 struct xfs_buf *bp)
Dave Chinner612cfbf2012-11-14 17:52:32 +1100254{
Christoph Hellwigdbd329f12019-06-28 19:27:29 -0700255 struct xfs_mount *mp = bp->b_mount;
Carlos Maiolinofb1755a2018-01-24 13:38:48 -0800256 struct xfs_buf_log_item *bip = bp->b_log_item;
Dave Chinner24df33b2013-04-12 07:30:21 +1000257 struct xfs_dir3_leaf_hdr *hdr3 = bp->b_addr;
Darrick J. Wongbc1a09b2018-01-08 10:51:03 -0800258 xfs_failaddr_t fa;
Dave Chinner24df33b2013-04-12 07:30:21 +1000259
Brian Foster09f42012019-02-07 10:45:47 -0800260 fa = xfs_dir3_leaf_verify(bp);
Darrick J. Wongbc1a09b2018-01-08 10:51:03 -0800261 if (fa) {
262 xfs_verifier_error(bp, -EFSCORRUPTED, fa);
Dave Chinner24df33b2013-04-12 07:30:21 +1000263 return;
264 }
265
Dave Chinner38c26bf2021-08-18 18:46:37 -0700266 if (!xfs_has_crc(mp))
Dave Chinner24df33b2013-04-12 07:30:21 +1000267 return;
268
269 if (bip)
270 hdr3->info.lsn = cpu_to_be64(bip->bli_item.li_lsn);
271
Eric Sandeenf1dbcd72014-02-27 15:18:23 +1100272 xfs_buf_update_cksum(bp, XFS_DIR3_LEAF_CRC_OFF);
Dave Chinner612cfbf2012-11-14 17:52:32 +1100273}
274
Dave Chinnerd75afeb2013-04-03 16:11:29 +1100275const struct xfs_buf_ops xfs_dir3_leaf1_buf_ops = {
Eric Sandeen233135b2016-01-04 16:10:19 +1100276 .name = "xfs_dir3_leaf1",
Darrick J. Wong15baadf2019-02-16 11:47:28 -0800277 .magic16 = { cpu_to_be16(XFS_DIR2_LEAF1_MAGIC),
278 cpu_to_be16(XFS_DIR3_LEAF1_MAGIC) },
Brian Foster09f42012019-02-07 10:45:47 -0800279 .verify_read = xfs_dir3_leaf_read_verify,
280 .verify_write = xfs_dir3_leaf_write_verify,
281 .verify_struct = xfs_dir3_leaf_verify,
Dave Chinner1813dd62012-11-14 17:54:40 +1100282};
283
Dave Chinner24df33b2013-04-12 07:30:21 +1000284const struct xfs_buf_ops xfs_dir3_leafn_buf_ops = {
Eric Sandeen233135b2016-01-04 16:10:19 +1100285 .name = "xfs_dir3_leafn",
Darrick J. Wong15baadf2019-02-16 11:47:28 -0800286 .magic16 = { cpu_to_be16(XFS_DIR2_LEAFN_MAGIC),
287 cpu_to_be16(XFS_DIR3_LEAFN_MAGIC) },
Brian Foster09f42012019-02-07 10:45:47 -0800288 .verify_read = xfs_dir3_leaf_read_verify,
289 .verify_write = xfs_dir3_leaf_write_verify,
290 .verify_struct = xfs_dir3_leaf_verify,
Dave Chinner1813dd62012-11-14 17:54:40 +1100291};
Dave Chinnere6f76672012-11-12 22:54:15 +1100292
Darrick J. Wong26788092017-06-16 11:00:07 -0700293int
Dave Chinner24df33b2013-04-12 07:30:21 +1000294xfs_dir3_leaf_read(
Dave Chinnere6f76672012-11-12 22:54:15 +1100295 struct xfs_trans *tp,
296 struct xfs_inode *dp,
Darrick J. Wong402eef12024-04-15 14:54:39 -0700297 xfs_ino_t owner,
Dave Chinnere6f76672012-11-12 22:54:15 +1100298 xfs_dablk_t fbno,
Dave Chinnere6f76672012-11-12 22:54:15 +1100299 struct xfs_buf **bpp)
300{
Darrick J. Wong402eef12024-04-15 14:54:39 -0700301 xfs_failaddr_t fa;
Dave Chinnerd75afeb2013-04-03 16:11:29 +1100302 int err;
303
Christoph Hellwigcd2c9f12019-11-20 09:46:04 -0800304 err = xfs_da_read_buf(tp, dp, fbno, 0, bpp, XFS_DATA_FORK,
Christoph Hellwigc943c0b2019-11-20 09:46:03 -0800305 &xfs_dir3_leaf1_buf_ops);
Darrick J. Wong402eef12024-04-15 14:54:39 -0700306 if (err || !(*bpp))
307 return err;
308
309 fa = xfs_dir3_leaf_header_check(*bpp, owner);
310 if (fa) {
311 __xfs_buf_mark_corrupt(*bpp, fa);
312 xfs_trans_brelse(tp, *bpp);
313 *bpp = NULL;
314 xfs_dirattr_mark_sick(dp, XFS_DATA_FORK);
315 return -EFSCORRUPTED;
316 }
317
318 if (tp)
Dave Chinner61fe1352013-04-03 16:11:30 +1100319 xfs_trans_buf_set_type(tp, *bpp, XFS_BLFT_DIR_LEAF1_BUF);
Darrick J. Wong402eef12024-04-15 14:54:39 -0700320 return 0;
Dave Chinnere6f76672012-11-12 22:54:15 +1100321}
322
323int
Dave Chinner24df33b2013-04-12 07:30:21 +1000324xfs_dir3_leafn_read(
Dave Chinnere6f76672012-11-12 22:54:15 +1100325 struct xfs_trans *tp,
326 struct xfs_inode *dp,
Darrick J. Wong402eef12024-04-15 14:54:39 -0700327 xfs_ino_t owner,
Dave Chinnere6f76672012-11-12 22:54:15 +1100328 xfs_dablk_t fbno,
Dave Chinnere6f76672012-11-12 22:54:15 +1100329 struct xfs_buf **bpp)
330{
Darrick J. Wong402eef12024-04-15 14:54:39 -0700331 xfs_failaddr_t fa;
Dave Chinnerd75afeb2013-04-03 16:11:29 +1100332 int err;
333
Christoph Hellwigcd2c9f12019-11-20 09:46:04 -0800334 err = xfs_da_read_buf(tp, dp, fbno, 0, bpp, XFS_DATA_FORK,
Christoph Hellwigf3fcb312019-11-20 09:46:03 -0800335 &xfs_dir3_leafn_buf_ops);
Darrick J. Wong402eef12024-04-15 14:54:39 -0700336 if (err || !(*bpp))
337 return err;
338
339 fa = xfs_dir3_leaf_header_check(*bpp, owner);
340 if (fa) {
341 __xfs_buf_mark_corrupt(*bpp, fa);
342 xfs_trans_brelse(tp, *bpp);
343 *bpp = NULL;
344 xfs_dirattr_mark_sick(dp, XFS_DATA_FORK);
345 return -EFSCORRUPTED;
346 }
347
348 if (tp)
Dave Chinner61fe1352013-04-03 16:11:30 +1100349 xfs_trans_buf_set_type(tp, *bpp, XFS_BLFT_DIR_LEAFN_BUF);
Darrick J. Wong402eef12024-04-15 14:54:39 -0700350 return 0;
Dave Chinner24df33b2013-04-12 07:30:21 +1000351}
352
353/*
354 * Initialize a new leaf block, leaf1 or leafn magic accepted.
355 */
356static void
357xfs_dir3_leaf_init(
Darrick J. Wong17a85dc2024-04-15 14:54:34 -0700358 struct xfs_da_args *args,
Dave Chinner24df33b2013-04-12 07:30:21 +1000359 struct xfs_buf *bp,
Darrick J. Wongc8ce5402017-06-16 11:00:05 -0700360 uint16_t type)
Dave Chinner24df33b2013-04-12 07:30:21 +1000361{
Darrick J. Wong17a85dc2024-04-15 14:54:34 -0700362 struct xfs_mount *mp = args->dp->i_mount;
363 struct xfs_trans *tp = args->trans;
Dave Chinner24df33b2013-04-12 07:30:21 +1000364 struct xfs_dir2_leaf *leaf = bp->b_addr;
365
366 ASSERT(type == XFS_DIR2_LEAF1_MAGIC || type == XFS_DIR2_LEAFN_MAGIC);
367
Dave Chinner38c26bf2021-08-18 18:46:37 -0700368 if (xfs_has_crc(mp)) {
Dave Chinner24df33b2013-04-12 07:30:21 +1000369 struct xfs_dir3_leaf_hdr *leaf3 = bp->b_addr;
370
371 memset(leaf3, 0, sizeof(*leaf3));
372
373 leaf3->info.hdr.magic = (type == XFS_DIR2_LEAF1_MAGIC)
374 ? cpu_to_be16(XFS_DIR3_LEAF1_MAGIC)
375 : cpu_to_be16(XFS_DIR3_LEAFN_MAGIC);
Dave Chinner9343ee72021-08-18 18:47:05 -0700376 leaf3->info.blkno = cpu_to_be64(xfs_buf_daddr(bp));
Darrick J. Wong17a85dc2024-04-15 14:54:34 -0700377 leaf3->info.owner = cpu_to_be64(args->owner);
Eric Sandeence748ea2015-07-29 11:53:31 +1000378 uuid_copy(&leaf3->info.uuid, &mp->m_sb.sb_meta_uuid);
Dave Chinner24df33b2013-04-12 07:30:21 +1000379 } else {
380 memset(leaf, 0, sizeof(*leaf));
381 leaf->hdr.info.magic = cpu_to_be16(type);
382 }
383
384 /*
385 * If it's a leaf-format directory initialize the tail.
386 * Caller is responsible for initialising the bests table.
387 */
388 if (type == XFS_DIR2_LEAF1_MAGIC) {
389 struct xfs_dir2_leaf_tail *ltp;
390
Dave Chinner8f661932014-06-06 15:15:59 +1000391 ltp = xfs_dir2_leaf_tail_p(mp->m_dir_geo, leaf);
Dave Chinner24df33b2013-04-12 07:30:21 +1000392 ltp->bestcount = 0;
393 bp->b_ops = &xfs_dir3_leaf1_buf_ops;
Dave Chinner61fe1352013-04-03 16:11:30 +1100394 xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DIR_LEAF1_BUF);
Dave Chinnerd75afeb2013-04-03 16:11:29 +1100395 } else {
Dave Chinner24df33b2013-04-12 07:30:21 +1000396 bp->b_ops = &xfs_dir3_leafn_buf_ops;
Dave Chinner61fe1352013-04-03 16:11:30 +1100397 xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DIR_LEAFN_BUF);
Dave Chinnerd75afeb2013-04-03 16:11:29 +1100398 }
Dave Chinner24df33b2013-04-12 07:30:21 +1000399}
400
401int
402xfs_dir3_leaf_get_buf(
403 xfs_da_args_t *args,
404 xfs_dir2_db_t bno,
405 struct xfs_buf **bpp,
Darrick J. Wongc8ce5402017-06-16 11:00:05 -0700406 uint16_t magic)
Dave Chinner24df33b2013-04-12 07:30:21 +1000407{
408 struct xfs_inode *dp = args->dp;
409 struct xfs_trans *tp = args->trans;
Dave Chinner24df33b2013-04-12 07:30:21 +1000410 struct xfs_buf *bp;
411 int error;
412
413 ASSERT(magic == XFS_DIR2_LEAF1_MAGIC || magic == XFS_DIR2_LEAFN_MAGIC);
Dave Chinner30028032014-06-06 15:08:18 +1000414 ASSERT(bno >= xfs_dir2_byte_to_db(args->geo, XFS_DIR2_LEAF_OFFSET) &&
415 bno < xfs_dir2_byte_to_db(args->geo, XFS_DIR2_FREE_OFFSET));
Dave Chinner24df33b2013-04-12 07:30:21 +1000416
Dave Chinner2998ab1d2014-06-06 15:07:53 +1000417 error = xfs_da_get_buf(tp, dp, xfs_dir2_db_to_da(args->geo, bno),
Christoph Hellwig2911edb2019-11-20 09:46:05 -0800418 &bp, XFS_DATA_FORK);
Dave Chinner24df33b2013-04-12 07:30:21 +1000419 if (error)
420 return error;
421
Darrick J. Wong17a85dc2024-04-15 14:54:34 -0700422 xfs_dir3_leaf_init(args, bp, magic);
Dave Chinnerbc851782014-06-06 15:20:54 +1000423 xfs_dir3_leaf_log_header(args, bp);
Dave Chinner24df33b2013-04-12 07:30:21 +1000424 if (magic == XFS_DIR2_LEAF1_MAGIC)
Dave Chinnerbc851782014-06-06 15:20:54 +1000425 xfs_dir3_leaf_log_tail(args, bp);
Dave Chinner24df33b2013-04-12 07:30:21 +1000426 *bpp = bp;
427 return 0;
Dave Chinnere6f76672012-11-12 22:54:15 +1100428}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
430/*
431 * Convert a block form directory to a leaf form directory.
432 */
433int /* error */
434xfs_dir2_block_to_leaf(
435 xfs_da_args_t *args, /* operation arguments */
Dave Chinner1d9025e2012-06-22 18:50:14 +1000436 struct xfs_buf *dbp) /* input block's buffer */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437{
Nathan Scott68b3a102006-03-17 17:27:19 +1100438 __be16 *bestsp; /* leaf's bestsp entries */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 xfs_dablk_t blkno; /* leaf block's bno */
Christoph Hellwig4f6ae1a2011-07-08 14:35:27 +0200440 xfs_dir2_data_hdr_t *hdr; /* block header */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 xfs_dir2_leaf_entry_t *blp; /* block's leaf entries */
442 xfs_dir2_block_tail_t *btp; /* block's tail */
443 xfs_inode_t *dp; /* incore directory inode */
444 int error; /* error return code */
Dave Chinner1d9025e2012-06-22 18:50:14 +1000445 struct xfs_buf *lbp; /* leaf block's buffer */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 xfs_dir2_db_t ldb; /* leaf block's bno */
447 xfs_dir2_leaf_t *leaf; /* leaf structure */
448 xfs_dir2_leaf_tail_t *ltp; /* leaf's tail */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 int needlog; /* need to log block header */
450 int needscan; /* need to rescan bestfree */
451 xfs_trans_t *tp; /* transaction pointer */
Dave Chinner33363fe2013-04-03 16:11:22 +1100452 struct xfs_dir2_data_free *bf;
Dave Chinner24df33b2013-04-12 07:30:21 +1000453 struct xfs_dir3_icleaf_hdr leafhdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000455 trace_xfs_dir2_block_to_leaf(args);
456
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 dp = args->dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 tp = args->trans;
459 /*
460 * Add the leaf block to the inode.
461 * This interface will only put blocks in the leaf/node range.
462 * Since that's empty now, we'll get the root (block 0 in range).
463 */
464 if ((error = xfs_da_grow_inode(args, &blkno))) {
465 return error;
466 }
Dave Chinner2998ab1d2014-06-06 15:07:53 +1000467 ldb = xfs_dir2_da_to_db(args->geo, blkno);
Dave Chinner30028032014-06-06 15:08:18 +1000468 ASSERT(ldb == xfs_dir2_byte_to_db(args->geo, XFS_DIR2_LEAF_OFFSET));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 /*
470 * Initialize the leaf block, get a buffer for it.
471 */
Dave Chinner24df33b2013-04-12 07:30:21 +1000472 error = xfs_dir3_leaf_get_buf(args, ldb, &lbp, XFS_DIR2_LEAF1_MAGIC);
473 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 return error;
Dave Chinner24df33b2013-04-12 07:30:21 +1000475
Dave Chinner1d9025e2012-06-22 18:50:14 +1000476 leaf = lbp->b_addr;
477 hdr = dbp->b_addr;
Dave Chinner33363fe2013-04-03 16:11:22 +1100478 xfs_dir3_data_check(dp, dbp);
Dave Chinner8f661932014-06-06 15:15:59 +1000479 btp = xfs_dir2_block_tail_p(args->geo, hdr);
Christoph Hellwigbbaaf532007-06-28 16:43:50 +1000480 blp = xfs_dir2_block_leaf_p(btp);
Christoph Hellwig1848b602019-11-08 15:05:39 -0800481 bf = xfs_dir2_data_bestfree_p(dp->i_mount, hdr);
Dave Chinner24df33b2013-04-12 07:30:21 +1000482
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 /*
484 * Set the counts in the leaf header.
485 */
Christoph Hellwig51842552019-11-08 14:57:49 -0800486 xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &leafhdr, leaf);
Dave Chinner24df33b2013-04-12 07:30:21 +1000487 leafhdr.count = be32_to_cpu(btp->count);
488 leafhdr.stale = be32_to_cpu(btp->stale);
Christoph Hellwig163fbbb2019-11-08 14:57:50 -0800489 xfs_dir2_leaf_hdr_to_disk(dp->i_mount, leaf, &leafhdr);
Dave Chinnerbc851782014-06-06 15:20:54 +1000490 xfs_dir3_leaf_log_header(args, lbp);
Dave Chinner24df33b2013-04-12 07:30:21 +1000491
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 /*
493 * Could compact these but I think we always do the conversion
494 * after squeezing out stale entries.
495 */
Christoph Hellwig787b0892019-11-08 14:57:50 -0800496 memcpy(leafhdr.ents, blp,
497 be32_to_cpu(btp->count) * sizeof(struct xfs_dir2_leaf_entry));
498 xfs_dir3_leaf_log_ents(args, &leafhdr, lbp, 0, leafhdr.count - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 needscan = 0;
500 needlog = 1;
501 /*
502 * Make the space formerly occupied by the leaf entries and block
503 * tail be free.
504 */
Dave Chinnerbc851782014-06-06 15:20:54 +1000505 xfs_dir2_data_make_free(args, dbp,
Christoph Hellwig4f6ae1a2011-07-08 14:35:27 +0200506 (xfs_dir2_data_aoff_t)((char *)blp - (char *)hdr),
Dave Chinner8f661932014-06-06 15:15:59 +1000507 (xfs_dir2_data_aoff_t)((char *)hdr + args->geo->blksize -
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 (char *)blp),
509 &needlog, &needscan);
510 /*
511 * Fix up the block header, make it a data block.
512 */
Dave Chinner33363fe2013-04-03 16:11:22 +1100513 dbp->b_ops = &xfs_dir3_data_buf_ops;
Dave Chinner61fe1352013-04-03 16:11:30 +1100514 xfs_trans_buf_set_type(tp, dbp, XFS_BLFT_DIR_DATA_BUF);
Dave Chinner33363fe2013-04-03 16:11:22 +1100515 if (hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC))
516 hdr->magic = cpu_to_be32(XFS_DIR2_DATA_MAGIC);
517 else
518 hdr->magic = cpu_to_be32(XFS_DIR3_DATA_MAGIC);
519
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 if (needscan)
Christoph Hellwigae429762019-11-08 15:06:02 -0800521 xfs_dir2_data_freescan(dp->i_mount, hdr, &needlog);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 /*
523 * Set up leaf tail and bests table.
524 */
Dave Chinner8f661932014-06-06 15:15:59 +1000525 ltp = xfs_dir2_leaf_tail_p(args->geo, leaf);
Nathan Scottafbcb3f2006-03-17 17:27:28 +1100526 ltp->bestcount = cpu_to_be32(1);
Christoph Hellwigbbaaf532007-06-28 16:43:50 +1000527 bestsp = xfs_dir2_leaf_bests_p(ltp);
Dave Chinnerf5f3d9b2013-04-03 16:11:20 +1100528 bestsp[0] = bf[0].length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 /*
530 * Log the data header and leaf bests table.
531 */
532 if (needlog)
Dave Chinnerbc851782014-06-06 15:20:54 +1000533 xfs_dir2_data_log_header(args, dbp);
Dave Chinner41419562013-10-29 22:11:50 +1100534 xfs_dir3_leaf_check(dp, lbp);
Dave Chinner33363fe2013-04-03 16:11:22 +1100535 xfs_dir3_data_check(dp, dbp);
Dave Chinnerbc851782014-06-06 15:20:54 +1000536 xfs_dir3_leaf_log_bests(args, lbp, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 return 0;
538}
539
Christoph Hellwiga230a1d2011-07-13 13:43:48 +0200540STATIC void
Dave Chinner24df33b2013-04-12 07:30:21 +1000541xfs_dir3_leaf_find_stale(
542 struct xfs_dir3_icleaf_hdr *leafhdr,
543 struct xfs_dir2_leaf_entry *ents,
Christoph Hellwiga230a1d2011-07-13 13:43:48 +0200544 int index,
545 int *lowstale,
546 int *highstale)
547{
548 /*
549 * Find the first stale entry before our index, if any.
550 */
551 for (*lowstale = index - 1; *lowstale >= 0; --*lowstale) {
Dave Chinner24df33b2013-04-12 07:30:21 +1000552 if (ents[*lowstale].address ==
Christoph Hellwiga230a1d2011-07-13 13:43:48 +0200553 cpu_to_be32(XFS_DIR2_NULL_DATAPTR))
554 break;
555 }
556
557 /*
558 * Find the first stale entry at or after our index, if any.
559 * Stop if the result would require moving more entries than using
560 * lowstale.
561 */
Dave Chinner24df33b2013-04-12 07:30:21 +1000562 for (*highstale = index; *highstale < leafhdr->count; ++*highstale) {
563 if (ents[*highstale].address ==
Christoph Hellwiga230a1d2011-07-13 13:43:48 +0200564 cpu_to_be32(XFS_DIR2_NULL_DATAPTR))
565 break;
566 if (*lowstale >= 0 && index - *lowstale <= *highstale - index)
567 break;
568 }
569}
570
Christoph Hellwig4fb44c82011-07-08 14:34:59 +0200571struct xfs_dir2_leaf_entry *
Dave Chinner24df33b2013-04-12 07:30:21 +1000572xfs_dir3_leaf_find_entry(
573 struct xfs_dir3_icleaf_hdr *leafhdr,
574 struct xfs_dir2_leaf_entry *ents,
Christoph Hellwig4fb44c82011-07-08 14:34:59 +0200575 int index, /* leaf table position */
576 int compact, /* need to compact leaves */
577 int lowstale, /* index of prev stale leaf */
578 int highstale, /* index of next stale leaf */
579 int *lfloglow, /* low leaf logging index */
580 int *lfloghigh) /* high leaf logging index */
581{
Dave Chinner24df33b2013-04-12 07:30:21 +1000582 if (!leafhdr->stale) {
Christoph Hellwig4fb44c82011-07-08 14:34:59 +0200583 xfs_dir2_leaf_entry_t *lep; /* leaf entry table pointer */
584
585 /*
586 * Now we need to make room to insert the leaf entry.
587 *
588 * If there are no stale entries, just insert a hole at index.
589 */
Dave Chinner24df33b2013-04-12 07:30:21 +1000590 lep = &ents[index];
591 if (index < leafhdr->count)
Christoph Hellwig4fb44c82011-07-08 14:34:59 +0200592 memmove(lep + 1, lep,
Dave Chinner24df33b2013-04-12 07:30:21 +1000593 (leafhdr->count - index) * sizeof(*lep));
Christoph Hellwig4fb44c82011-07-08 14:34:59 +0200594
595 /*
596 * Record low and high logging indices for the leaf.
597 */
598 *lfloglow = index;
Dave Chinner24df33b2013-04-12 07:30:21 +1000599 *lfloghigh = leafhdr->count++;
Christoph Hellwig4fb44c82011-07-08 14:34:59 +0200600 return lep;
601 }
602
603 /*
604 * There are stale entries.
605 *
606 * We will use one of them for the new entry. It's probably not at
607 * the right location, so we'll have to shift some up or down first.
608 *
609 * If we didn't compact before, we need to find the nearest stale
610 * entries before and after our insertion point.
611 */
Christoph Hellwiga230a1d2011-07-13 13:43:48 +0200612 if (compact == 0)
Dave Chinner24df33b2013-04-12 07:30:21 +1000613 xfs_dir3_leaf_find_stale(leafhdr, ents, index,
614 &lowstale, &highstale);
Christoph Hellwig4fb44c82011-07-08 14:34:59 +0200615
616 /*
617 * If the low one is better, use it.
618 */
619 if (lowstale >= 0 &&
Dave Chinner24df33b2013-04-12 07:30:21 +1000620 (highstale == leafhdr->count ||
Christoph Hellwig4fb44c82011-07-08 14:34:59 +0200621 index - lowstale - 1 < highstale - index)) {
622 ASSERT(index - lowstale - 1 >= 0);
Dave Chinner24df33b2013-04-12 07:30:21 +1000623 ASSERT(ents[lowstale].address ==
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200624 cpu_to_be32(XFS_DIR2_NULL_DATAPTR));
Christoph Hellwig4fb44c82011-07-08 14:34:59 +0200625
626 /*
627 * Copy entries up to cover the stale entry and make room
628 * for the new entry.
629 */
630 if (index - lowstale - 1 > 0) {
Dave Chinner24df33b2013-04-12 07:30:21 +1000631 memmove(&ents[lowstale], &ents[lowstale + 1],
Christoph Hellwig4fb44c82011-07-08 14:34:59 +0200632 (index - lowstale - 1) *
Dave Chinner24df33b2013-04-12 07:30:21 +1000633 sizeof(xfs_dir2_leaf_entry_t));
Christoph Hellwig4fb44c82011-07-08 14:34:59 +0200634 }
Dave Chinner9bb54cb2018-06-07 07:54:02 -0700635 *lfloglow = min(lowstale, *lfloglow);
636 *lfloghigh = max(index - 1, *lfloghigh);
Dave Chinner24df33b2013-04-12 07:30:21 +1000637 leafhdr->stale--;
638 return &ents[index - 1];
Christoph Hellwig4fb44c82011-07-08 14:34:59 +0200639 }
640
641 /*
642 * The high one is better, so use that one.
643 */
644 ASSERT(highstale - index >= 0);
Dave Chinner24df33b2013-04-12 07:30:21 +1000645 ASSERT(ents[highstale].address == cpu_to_be32(XFS_DIR2_NULL_DATAPTR));
Christoph Hellwig4fb44c82011-07-08 14:34:59 +0200646
647 /*
648 * Copy entries down to cover the stale entry and make room for the
649 * new entry.
650 */
651 if (highstale - index > 0) {
Dave Chinner24df33b2013-04-12 07:30:21 +1000652 memmove(&ents[index + 1], &ents[index],
Christoph Hellwig4fb44c82011-07-08 14:34:59 +0200653 (highstale - index) * sizeof(xfs_dir2_leaf_entry_t));
654 }
Dave Chinner9bb54cb2018-06-07 07:54:02 -0700655 *lfloglow = min(index, *lfloglow);
656 *lfloghigh = max(highstale, *lfloghigh);
Dave Chinner24df33b2013-04-12 07:30:21 +1000657 leafhdr->stale--;
658 return &ents[index];
Christoph Hellwig4fb44c82011-07-08 14:34:59 +0200659}
660
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661/*
662 * Add an entry to a leaf form directory.
663 */
664int /* error */
665xfs_dir2_leaf_addname(
Darrick J. Wong6ef50fe2019-03-10 11:46:28 -0700666 struct xfs_da_args *args) /* operation arguments */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667{
Darrick J. Wong6ef50fe2019-03-10 11:46:28 -0700668 struct xfs_dir3_icleaf_hdr leafhdr;
669 struct xfs_trans *tp = args->trans;
Nathan Scott68b3a102006-03-17 17:27:19 +1100670 __be16 *bestsp; /* freespace table in leaf */
Darrick J. Wong6ef50fe2019-03-10 11:46:28 -0700671 __be16 *tagp; /* end of data entry */
Dave Chinner1d9025e2012-06-22 18:50:14 +1000672 struct xfs_buf *dbp; /* data block buffer */
Darrick J. Wong6ef50fe2019-03-10 11:46:28 -0700673 struct xfs_buf *lbp; /* leaf's buffer */
674 struct xfs_dir2_leaf *leaf; /* leaf structure */
675 struct xfs_inode *dp = args->dp; /* incore directory inode */
676 struct xfs_dir2_data_hdr *hdr; /* data block header */
677 struct xfs_dir2_data_entry *dep; /* data block entry */
678 struct xfs_dir2_leaf_entry *lep; /* leaf entry table pointer */
679 struct xfs_dir2_leaf_entry *ents;
680 struct xfs_dir2_data_unused *dup; /* data unused entry */
681 struct xfs_dir2_leaf_tail *ltp; /* leaf tail pointer */
682 struct xfs_dir2_data_free *bf; /* bestfree table */
683 int compact; /* need to compact leaves */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 int error; /* error return value */
685 int grown; /* allocated new data block */
Darrick J. Wongf51fac62019-03-10 11:41:31 -0700686 int highstale = 0; /* index of next stale leaf */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 int i; /* temporary, index */
688 int index; /* leaf table position */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 int length; /* length of new entry */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 int lfloglow; /* low leaf logging index */
691 int lfloghigh; /* high leaf logging index */
Darrick J. Wongf51fac62019-03-10 11:41:31 -0700692 int lowstale = 0; /* index of prev stale leaf */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 int needbytes; /* leaf block bytes needed */
694 int needlog; /* need to log data header */
695 int needscan; /* need to rescan data free */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 xfs_dir2_db_t use_block; /* data block number */
697
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000698 trace_xfs_dir2_leaf_addname(args);
699
Darrick J. Wong402eef12024-04-15 14:54:39 -0700700 error = xfs_dir3_leaf_read(tp, dp, args->owner, args->geo->leafblk,
701 &lbp);
Dave Chinner4bb20a82012-11-12 22:54:10 +1100702 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 return error;
Dave Chinnere6f76672012-11-12 22:54:15 +1100704
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 /*
706 * Look up the entry by hash value and name.
707 * We know it's not there, our caller has already done a lookup.
708 * So the index is of the entry to insert in front of.
709 * But if there are dup hash values the index is of the first of those.
710 */
711 index = xfs_dir2_leaf_search_hash(args, lbp);
Dave Chinner1d9025e2012-06-22 18:50:14 +1000712 leaf = lbp->b_addr;
Dave Chinner8f661932014-06-06 15:15:59 +1000713 ltp = xfs_dir2_leaf_tail_p(args->geo, leaf);
Christoph Hellwig51842552019-11-08 14:57:49 -0800714 xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &leafhdr, leaf);
Christoph Hellwig787b0892019-11-08 14:57:50 -0800715 ents = leafhdr.ents;
Christoph Hellwigbbaaf532007-06-28 16:43:50 +1000716 bestsp = xfs_dir2_leaf_bests_p(ltp);
Christoph Hellwigfdbb8c52019-11-08 15:05:37 -0800717 length = xfs_dir2_data_entsize(dp->i_mount, args->namelen);
Dave Chinner24df33b2013-04-12 07:30:21 +1000718
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 /*
720 * See if there are any entries with the same hash value
721 * and space in their block for the new entry.
722 * This is good because it puts multiple same-hash value entries
723 * in a data block, improving the lookup of those entries.
724 */
Dave Chinner24df33b2013-04-12 07:30:21 +1000725 for (use_block = -1, lep = &ents[index];
726 index < leafhdr.count && be32_to_cpu(lep->hashval) == args->hashval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 index++, lep++) {
Nathan Scott3c1f9c12006-03-17 17:28:18 +1100728 if (be32_to_cpu(lep->address) == XFS_DIR2_NULL_DATAPTR)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 continue;
Dave Chinner30028032014-06-06 15:08:18 +1000730 i = xfs_dir2_dataptr_to_db(args->geo, be32_to_cpu(lep->address));
Nathan Scottafbcb3f2006-03-17 17:27:28 +1100731 ASSERT(i < be32_to_cpu(ltp->bestcount));
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200732 ASSERT(bestsp[i] != cpu_to_be16(NULLDATAOFF));
Nathan Scott68b3a102006-03-17 17:27:19 +1100733 if (be16_to_cpu(bestsp[i]) >= length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 use_block = i;
735 break;
736 }
737 }
738 /*
739 * Didn't find a block yet, linear search all the data blocks.
740 */
741 if (use_block == -1) {
Nathan Scottafbcb3f2006-03-17 17:27:28 +1100742 for (i = 0; i < be32_to_cpu(ltp->bestcount); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 /*
744 * Remember a block we see that's missing.
745 */
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200746 if (bestsp[i] == cpu_to_be16(NULLDATAOFF) &&
747 use_block == -1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 use_block = i;
Nathan Scott68b3a102006-03-17 17:27:19 +1100749 else if (be16_to_cpu(bestsp[i]) >= length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 use_block = i;
751 break;
752 }
753 }
754 }
755 /*
756 * How many bytes do we need in the leaf block?
757 */
Christoph Hellwig22823962011-07-08 14:35:53 +0200758 needbytes = 0;
Dave Chinner24df33b2013-04-12 07:30:21 +1000759 if (!leafhdr.stale)
Christoph Hellwig22823962011-07-08 14:35:53 +0200760 needbytes += sizeof(xfs_dir2_leaf_entry_t);
761 if (use_block == -1)
762 needbytes += sizeof(xfs_dir2_data_off_t);
763
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 /*
765 * Now kill use_block if it refers to a missing block, so we
766 * can use it as an indication of allocation needed.
767 */
Christoph Hellwig69ef9212011-07-08 14:36:05 +0200768 if (use_block != -1 && bestsp[use_block] == cpu_to_be16(NULLDATAOFF))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 use_block = -1;
770 /*
771 * If we don't have enough free bytes but we can make enough
772 * by compacting out stale entries, we'll do that.
773 */
Dave Chinner24df33b2013-04-12 07:30:21 +1000774 if ((char *)bestsp - (char *)&ents[leafhdr.count] < needbytes &&
775 leafhdr.stale > 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 compact = 1;
Dave Chinner24df33b2013-04-12 07:30:21 +1000777
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 /*
779 * Otherwise if we don't have enough free bytes we need to
780 * convert to node form.
781 */
Dave Chinner24df33b2013-04-12 07:30:21 +1000782 else if ((char *)bestsp - (char *)&ents[leafhdr.count] < needbytes) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 /*
784 * Just checking or no space reservation, give up.
785 */
Barry Naujok6a178102008-05-21 16:42:05 +1000786 if ((args->op_flags & XFS_DA_OP_JUSTCHECK) ||
787 args->total == 0) {
Dave Chinner1d9025e2012-06-22 18:50:14 +1000788 xfs_trans_brelse(tp, lbp);
Dave Chinner24513372014-06-25 14:58:08 +1000789 return -ENOSPC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 }
791 /*
792 * Convert to node form.
793 */
794 error = xfs_dir2_leaf_to_node(args, lbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 if (error)
796 return error;
797 /*
798 * Then add the new entry.
799 */
800 return xfs_dir2_node_addname(args);
801 }
802 /*
803 * Otherwise it will fit without compaction.
804 */
805 else
806 compact = 0;
807 /*
808 * If just checking, then it will fit unless we needed to allocate
809 * a new data block.
810 */
Barry Naujok6a178102008-05-21 16:42:05 +1000811 if (args->op_flags & XFS_DA_OP_JUSTCHECK) {
Dave Chinner1d9025e2012-06-22 18:50:14 +1000812 xfs_trans_brelse(tp, lbp);
Dave Chinner24513372014-06-25 14:58:08 +1000813 return use_block == -1 ? -ENOSPC : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 }
815 /*
816 * If no allocations are allowed, return now before we've
817 * changed anything.
818 */
819 if (args->total == 0 && use_block == -1) {
Dave Chinner1d9025e2012-06-22 18:50:14 +1000820 xfs_trans_brelse(tp, lbp);
Dave Chinner24513372014-06-25 14:58:08 +1000821 return -ENOSPC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 }
823 /*
824 * Need to compact the leaf entries, removing stale ones.
825 * Leave one stale entry behind - the one closest to our
826 * insertion index - and we'll shift that one to our insertion
827 * point later.
828 */
829 if (compact) {
Dave Chinner24df33b2013-04-12 07:30:21 +1000830 xfs_dir3_leaf_compact_x1(&leafhdr, ents, &index, &lowstale,
831 &highstale, &lfloglow, &lfloghigh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 }
833 /*
834 * There are stale entries, so we'll need log-low and log-high
835 * impossibly bad values later.
836 */
Dave Chinner24df33b2013-04-12 07:30:21 +1000837 else if (leafhdr.stale) {
838 lfloglow = leafhdr.count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 lfloghigh = -1;
840 }
841 /*
842 * If there was no data block space found, we need to allocate
843 * a new one.
844 */
845 if (use_block == -1) {
846 /*
847 * Add the new data block.
848 */
849 if ((error = xfs_dir2_grow_inode(args, XFS_DIR2_DATA_SPACE,
850 &use_block))) {
Dave Chinner1d9025e2012-06-22 18:50:14 +1000851 xfs_trans_brelse(tp, lbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 return error;
853 }
854 /*
855 * Initialize the block.
856 */
Dave Chinnerf5f3d9b2013-04-03 16:11:20 +1100857 if ((error = xfs_dir3_data_init(args, use_block, &dbp))) {
Dave Chinner1d9025e2012-06-22 18:50:14 +1000858 xfs_trans_brelse(tp, lbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 return error;
860 }
861 /*
862 * If we're adding a new data block on the end we need to
863 * extend the bests table. Copy it up one entry.
864 */
Nathan Scottafbcb3f2006-03-17 17:27:28 +1100865 if (use_block >= be32_to_cpu(ltp->bestcount)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 bestsp--;
867 memmove(&bestsp[0], &bestsp[1],
Nathan Scottafbcb3f2006-03-17 17:27:28 +1100868 be32_to_cpu(ltp->bestcount) * sizeof(bestsp[0]));
Marcin Slusarz413d57c2008-02-13 15:03:29 -0800869 be32_add_cpu(&ltp->bestcount, 1);
Dave Chinnerbc851782014-06-06 15:20:54 +1000870 xfs_dir3_leaf_log_tail(args, lbp);
871 xfs_dir3_leaf_log_bests(args, lbp, 0,
872 be32_to_cpu(ltp->bestcount) - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 }
874 /*
875 * If we're filling in a previously empty block just log it.
876 */
877 else
Dave Chinnerbc851782014-06-06 15:20:54 +1000878 xfs_dir3_leaf_log_bests(args, lbp, use_block, use_block);
Dave Chinner1d9025e2012-06-22 18:50:14 +1000879 hdr = dbp->b_addr;
Christoph Hellwig1848b602019-11-08 15:05:39 -0800880 bf = xfs_dir2_data_bestfree_p(dp->i_mount, hdr);
Dave Chinner33363fe2013-04-03 16:11:22 +1100881 bestsp[use_block] = bf[0].length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 grown = 1;
Dave Chinnere4813572012-11-12 22:54:14 +1100883 } else {
884 /*
885 * Already had space in some data block.
886 * Just read that one in.
887 */
Darrick J. Wongcc6740d2024-04-15 14:54:40 -0700888 error = xfs_dir3_data_read(tp, dp, args->owner,
889 xfs_dir2_db_to_da(args->geo, use_block), 0,
890 &dbp);
Dave Chinner4bb20a82012-11-12 22:54:10 +1100891 if (error) {
Dave Chinner1d9025e2012-06-22 18:50:14 +1000892 xfs_trans_brelse(tp, lbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 return error;
894 }
Dave Chinner1d9025e2012-06-22 18:50:14 +1000895 hdr = dbp->b_addr;
Christoph Hellwig1848b602019-11-08 15:05:39 -0800896 bf = xfs_dir2_data_bestfree_p(dp->i_mount, hdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 grown = 0;
898 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 /*
900 * Point to the biggest freespace in our data block.
901 */
902 dup = (xfs_dir2_data_unused_t *)
Dave Chinner33363fe2013-04-03 16:11:22 +1100903 ((char *)hdr + be16_to_cpu(bf[0].offset));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 needscan = needlog = 0;
905 /*
906 * Mark the initial part of our freespace in use for the new entry.
907 */
Darrick J. Wong6915ef32018-03-23 10:06:51 -0700908 error = xfs_dir2_data_use_free(args, dbp, dup,
909 (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr),
910 length, &needlog, &needscan);
911 if (error) {
912 xfs_trans_brelse(tp, lbp);
913 return error;
914 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 /*
916 * Initialize our new entry (at last).
917 */
918 dep = (xfs_dir2_data_entry_t *)dup;
Christoph Hellwigff9901c2006-06-09 14:48:37 +1000919 dep->inumber = cpu_to_be64(args->inumber);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 dep->namelen = args->namelen;
921 memcpy(dep->name, args->name, dep->namelen);
Christoph Hellwig59b8b462019-11-08 15:05:48 -0800922 xfs_dir2_data_put_ftype(dp->i_mount, dep, args->filetype);
Christoph Hellwig7e8ae7bd2019-11-08 15:05:37 -0800923 tagp = xfs_dir2_data_entry_tag_p(dp->i_mount, dep);
Christoph Hellwigc2066e22011-07-08 14:35:38 +0200924 *tagp = cpu_to_be16((char *)dep - (char *)hdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 /*
926 * Need to scan fix up the bestfree table.
927 */
928 if (needscan)
Christoph Hellwigae429762019-11-08 15:06:02 -0800929 xfs_dir2_data_freescan(dp->i_mount, hdr, &needlog);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 /*
931 * Need to log the data block's header.
932 */
933 if (needlog)
Dave Chinnerbc851782014-06-06 15:20:54 +1000934 xfs_dir2_data_log_header(args, dbp);
935 xfs_dir2_data_log_entry(args, dbp, dep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 /*
937 * If the bests table needs to be changed, do it.
938 * Log the change unless we've already done that.
939 */
Dave Chinner33363fe2013-04-03 16:11:22 +1100940 if (be16_to_cpu(bestsp[use_block]) != be16_to_cpu(bf[0].length)) {
941 bestsp[use_block] = bf[0].length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 if (!grown)
Dave Chinnerbc851782014-06-06 15:20:54 +1000943 xfs_dir3_leaf_log_bests(args, lbp, use_block, use_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 }
Christoph Hellwig4fb44c82011-07-08 14:34:59 +0200945
Dave Chinner24df33b2013-04-12 07:30:21 +1000946 lep = xfs_dir3_leaf_find_entry(&leafhdr, ents, index, compact, lowstale,
Christoph Hellwig4fb44c82011-07-08 14:34:59 +0200947 highstale, &lfloglow, &lfloghigh);
948
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 /*
950 * Fill in the new leaf entry.
951 */
Nathan Scott3c1f9c12006-03-17 17:28:18 +1100952 lep->hashval = cpu_to_be32(args->hashval);
Dave Chinner30028032014-06-06 15:08:18 +1000953 lep->address = cpu_to_be32(
954 xfs_dir2_db_off_to_dataptr(args->geo, use_block,
Nathan Scott3d693c62006-03-17 17:28:27 +1100955 be16_to_cpu(*tagp)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 /*
957 * Log the leaf fields and give up the buffers.
958 */
Christoph Hellwig163fbbb2019-11-08 14:57:50 -0800959 xfs_dir2_leaf_hdr_to_disk(dp->i_mount, leaf, &leafhdr);
Dave Chinnerbc851782014-06-06 15:20:54 +1000960 xfs_dir3_leaf_log_header(args, lbp);
Christoph Hellwig787b0892019-11-08 14:57:50 -0800961 xfs_dir3_leaf_log_ents(args, &leafhdr, lbp, lfloglow, lfloghigh);
Dave Chinner41419562013-10-29 22:11:50 +1100962 xfs_dir3_leaf_check(dp, lbp);
Dave Chinner33363fe2013-04-03 16:11:22 +1100963 xfs_dir3_data_check(dp, dbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 return 0;
965}
966
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967/*
968 * Compact out any stale entries in the leaf.
969 * Log the header and changed leaf entries, if any.
970 */
971void
Dave Chinner24df33b2013-04-12 07:30:21 +1000972xfs_dir3_leaf_compact(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 xfs_da_args_t *args, /* operation arguments */
Dave Chinner24df33b2013-04-12 07:30:21 +1000974 struct xfs_dir3_icleaf_hdr *leafhdr,
Dave Chinner1d9025e2012-06-22 18:50:14 +1000975 struct xfs_buf *bp) /* leaf buffer */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976{
977 int from; /* source leaf index */
978 xfs_dir2_leaf_t *leaf; /* leaf structure */
979 int loglow; /* first leaf entry to log */
980 int to; /* target leaf index */
Dave Chinner01ba43b2013-10-29 22:11:52 +1100981 struct xfs_inode *dp = args->dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982
Dave Chinner1d9025e2012-06-22 18:50:14 +1000983 leaf = bp->b_addr;
Dave Chinner24df33b2013-04-12 07:30:21 +1000984 if (!leafhdr->stale)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 return;
Dave Chinner24df33b2013-04-12 07:30:21 +1000986
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 /*
988 * Compress out the stale entries in place.
989 */
Dave Chinner24df33b2013-04-12 07:30:21 +1000990 for (from = to = 0, loglow = -1; from < leafhdr->count; from++) {
Christoph Hellwig787b0892019-11-08 14:57:50 -0800991 if (leafhdr->ents[from].address ==
992 cpu_to_be32(XFS_DIR2_NULL_DATAPTR))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 continue;
994 /*
995 * Only actually copy the entries that are different.
996 */
997 if (from > to) {
998 if (loglow == -1)
999 loglow = to;
Christoph Hellwig787b0892019-11-08 14:57:50 -08001000 leafhdr->ents[to] = leafhdr->ents[from];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 }
1002 to++;
1003 }
1004 /*
1005 * Update and log the header, log the leaf entries.
1006 */
Dave Chinner24df33b2013-04-12 07:30:21 +10001007 ASSERT(leafhdr->stale == from - to);
1008 leafhdr->count -= leafhdr->stale;
1009 leafhdr->stale = 0;
1010
Christoph Hellwig163fbbb2019-11-08 14:57:50 -08001011 xfs_dir2_leaf_hdr_to_disk(dp->i_mount, leaf, leafhdr);
Dave Chinnerbc851782014-06-06 15:20:54 +10001012 xfs_dir3_leaf_log_header(args, bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 if (loglow != -1)
Christoph Hellwig787b0892019-11-08 14:57:50 -08001014 xfs_dir3_leaf_log_ents(args, leafhdr, bp, loglow, to - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015}
1016
1017/*
1018 * Compact the leaf entries, removing stale ones.
1019 * Leave one stale entry behind - the one closest to our
1020 * insertion index - and the caller will shift that one to our insertion
1021 * point later.
1022 * Return new insertion index, where the remaining stale entry is,
1023 * and leaf logging indices.
1024 */
1025void
Dave Chinner24df33b2013-04-12 07:30:21 +10001026xfs_dir3_leaf_compact_x1(
1027 struct xfs_dir3_icleaf_hdr *leafhdr,
1028 struct xfs_dir2_leaf_entry *ents,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 int *indexp, /* insertion index */
1030 int *lowstalep, /* out: stale entry before us */
1031 int *highstalep, /* out: stale entry after us */
1032 int *lowlogp, /* out: low log index */
1033 int *highlogp) /* out: high log index */
1034{
1035 int from; /* source copy index */
1036 int highstale; /* stale entry at/after index */
1037 int index; /* insertion index */
1038 int keepstale; /* source index of kept stale */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 int lowstale; /* stale entry before index */
1040 int newindex=0; /* new insertion index */
1041 int to; /* destination copy index */
1042
Dave Chinner24df33b2013-04-12 07:30:21 +10001043 ASSERT(leafhdr->stale > 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 index = *indexp;
Christoph Hellwiga230a1d2011-07-13 13:43:48 +02001045
Dave Chinner24df33b2013-04-12 07:30:21 +10001046 xfs_dir3_leaf_find_stale(leafhdr, ents, index, &lowstale, &highstale);
Christoph Hellwiga230a1d2011-07-13 13:43:48 +02001047
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 /*
1049 * Pick the better of lowstale and highstale.
1050 */
1051 if (lowstale >= 0 &&
Dave Chinner24df33b2013-04-12 07:30:21 +10001052 (highstale == leafhdr->count ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 index - lowstale <= highstale - index))
1054 keepstale = lowstale;
1055 else
1056 keepstale = highstale;
1057 /*
1058 * Copy the entries in place, removing all the stale entries
1059 * except keepstale.
1060 */
Dave Chinner24df33b2013-04-12 07:30:21 +10001061 for (from = to = 0; from < leafhdr->count; from++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 /*
1063 * Notice the new value of index.
1064 */
1065 if (index == from)
1066 newindex = to;
1067 if (from != keepstale &&
Dave Chinner24df33b2013-04-12 07:30:21 +10001068 ents[from].address == cpu_to_be32(XFS_DIR2_NULL_DATAPTR)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 if (from == to)
1070 *lowlogp = to;
1071 continue;
1072 }
1073 /*
1074 * Record the new keepstale value for the insertion.
1075 */
1076 if (from == keepstale)
1077 lowstale = highstale = to;
1078 /*
1079 * Copy only the entries that have moved.
1080 */
1081 if (from > to)
Dave Chinner24df33b2013-04-12 07:30:21 +10001082 ents[to] = ents[from];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 to++;
1084 }
1085 ASSERT(from > to);
1086 /*
1087 * If the insertion point was past the last entry,
1088 * set the new insertion point accordingly.
1089 */
1090 if (index == from)
1091 newindex = to;
1092 *indexp = newindex;
1093 /*
1094 * Adjust the leaf header values.
1095 */
Dave Chinner24df33b2013-04-12 07:30:21 +10001096 leafhdr->count -= from - to;
1097 leafhdr->stale = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 /*
1099 * Remember the low/high stale value only in the "right"
1100 * direction.
1101 */
1102 if (lowstale >= newindex)
1103 lowstale = -1;
1104 else
Dave Chinner24df33b2013-04-12 07:30:21 +10001105 highstale = leafhdr->count;
1106 *highlogp = leafhdr->count - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 *lowstalep = lowstale;
1108 *highstalep = highstale;
1109}
1110
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111/*
1112 * Log the bests entries indicated from a leaf1 block.
1113 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10001114static void
Dave Chinner24df33b2013-04-12 07:30:21 +10001115xfs_dir3_leaf_log_bests(
Dave Chinnerbc851782014-06-06 15:20:54 +10001116 struct xfs_da_args *args,
Dave Chinner1d9025e2012-06-22 18:50:14 +10001117 struct xfs_buf *bp, /* leaf buffer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 int first, /* first entry to log */
1119 int last) /* last entry to log */
1120{
Nathan Scott68b3a102006-03-17 17:27:19 +11001121 __be16 *firstb; /* pointer to first entry */
1122 __be16 *lastb; /* pointer to last entry */
Dave Chinner24df33b2013-04-12 07:30:21 +10001123 struct xfs_dir2_leaf *leaf = bp->b_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 xfs_dir2_leaf_tail_t *ltp; /* leaf tail structure */
1125
Dave Chinner24df33b2013-04-12 07:30:21 +10001126 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC) ||
1127 leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAF1_MAGIC));
1128
Dave Chinnerbc851782014-06-06 15:20:54 +10001129 ltp = xfs_dir2_leaf_tail_p(args->geo, leaf);
Christoph Hellwigbbaaf532007-06-28 16:43:50 +10001130 firstb = xfs_dir2_leaf_bests_p(ltp) + first;
1131 lastb = xfs_dir2_leaf_bests_p(ltp) + last;
Dave Chinnerbc851782014-06-06 15:20:54 +10001132 xfs_trans_log_buf(args->trans, bp,
1133 (uint)((char *)firstb - (char *)leaf),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 (uint)((char *)lastb - (char *)leaf + sizeof(*lastb) - 1));
1135}
1136
1137/*
1138 * Log the leaf entries indicated from a leaf1 or leafn block.
1139 */
1140void
Dave Chinner24df33b2013-04-12 07:30:21 +10001141xfs_dir3_leaf_log_ents(
Dave Chinnerbc851782014-06-06 15:20:54 +10001142 struct xfs_da_args *args,
Christoph Hellwig787b0892019-11-08 14:57:50 -08001143 struct xfs_dir3_icleaf_hdr *hdr,
Dave Chinner41419562013-10-29 22:11:50 +11001144 struct xfs_buf *bp,
1145 int first,
1146 int last)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147{
1148 xfs_dir2_leaf_entry_t *firstlep; /* pointer to first entry */
1149 xfs_dir2_leaf_entry_t *lastlep; /* pointer to last entry */
Dave Chinner24df33b2013-04-12 07:30:21 +10001150 struct xfs_dir2_leaf *leaf = bp->b_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151
Christoph Hellwig69ef9212011-07-08 14:36:05 +02001152 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC) ||
Dave Chinner24df33b2013-04-12 07:30:21 +10001153 leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAF1_MAGIC) ||
1154 leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||
1155 leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC));
1156
Christoph Hellwig787b0892019-11-08 14:57:50 -08001157 firstlep = &hdr->ents[first];
1158 lastlep = &hdr->ents[last];
Dave Chinnerbc851782014-06-06 15:20:54 +10001159 xfs_trans_log_buf(args->trans, bp,
1160 (uint)((char *)firstlep - (char *)leaf),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 (uint)((char *)lastlep - (char *)leaf + sizeof(*lastlep) - 1));
1162}
1163
1164/*
1165 * Log the header of the leaf1 or leafn block.
1166 */
1167void
Dave Chinner24df33b2013-04-12 07:30:21 +10001168xfs_dir3_leaf_log_header(
Dave Chinnerbc851782014-06-06 15:20:54 +10001169 struct xfs_da_args *args,
Dave Chinner1d9025e2012-06-22 18:50:14 +10001170 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171{
Dave Chinner24df33b2013-04-12 07:30:21 +10001172 struct xfs_dir2_leaf *leaf = bp->b_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173
Christoph Hellwig69ef9212011-07-08 14:36:05 +02001174 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC) ||
Dave Chinner24df33b2013-04-12 07:30:21 +10001175 leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAF1_MAGIC) ||
1176 leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||
1177 leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC));
1178
Dave Chinnerbc851782014-06-06 15:20:54 +10001179 xfs_trans_log_buf(args->trans, bp,
1180 (uint)((char *)&leaf->hdr - (char *)leaf),
Christoph Hellwig545910b2019-11-08 14:57:51 -08001181 args->geo->leaf_hdr_size - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182}
1183
1184/*
1185 * Log the tail of the leaf1 block.
1186 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10001187STATIC void
Dave Chinner24df33b2013-04-12 07:30:21 +10001188xfs_dir3_leaf_log_tail(
Dave Chinnerbc851782014-06-06 15:20:54 +10001189 struct xfs_da_args *args,
Dave Chinner1d9025e2012-06-22 18:50:14 +10001190 struct xfs_buf *bp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191{
Dave Chinner24df33b2013-04-12 07:30:21 +10001192 struct xfs_dir2_leaf *leaf = bp->b_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 xfs_dir2_leaf_tail_t *ltp; /* leaf tail structure */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194
Dave Chinner24df33b2013-04-12 07:30:21 +10001195 ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC) ||
1196 leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAF1_MAGIC) ||
1197 leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||
1198 leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC));
1199
Dave Chinnerbc851782014-06-06 15:20:54 +10001200 ltp = xfs_dir2_leaf_tail_p(args->geo, leaf);
1201 xfs_trans_log_buf(args->trans, bp, (uint)((char *)ltp - (char *)leaf),
1202 (uint)(args->geo->blksize - 1));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203}
1204
1205/*
1206 * Look up the entry referred to by args in the leaf format directory.
1207 * Most of the work is done by the xfs_dir2_leaf_lookup_int routine which
1208 * is also used by the node-format code.
1209 */
1210int
1211xfs_dir2_leaf_lookup(
1212 xfs_da_args_t *args) /* operation arguments */
1213{
Dave Chinner1d9025e2012-06-22 18:50:14 +10001214 struct xfs_buf *dbp; /* data block buffer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 xfs_dir2_data_entry_t *dep; /* data block entry */
1216 xfs_inode_t *dp; /* incore directory inode */
1217 int error; /* error return code */
1218 int index; /* found entry index */
Dave Chinner1d9025e2012-06-22 18:50:14 +10001219 struct xfs_buf *lbp; /* leaf buffer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220 xfs_dir2_leaf_entry_t *lep; /* leaf entry */
1221 xfs_trans_t *tp; /* transaction pointer */
Christoph Hellwig787b0892019-11-08 14:57:50 -08001222 struct xfs_dir3_icleaf_hdr leafhdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001224 trace_xfs_dir2_leaf_lookup(args);
1225
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 /*
1227 * Look up name in the leaf block, returning both buffers and index.
1228 */
Christoph Hellwig787b0892019-11-08 14:57:50 -08001229 error = xfs_dir2_leaf_lookup_int(args, &lbp, &index, &dbp, &leafhdr);
1230 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231 return error;
Christoph Hellwig787b0892019-11-08 14:57:50 -08001232
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 tp = args->trans;
1234 dp = args->dp;
Dave Chinner41419562013-10-29 22:11:50 +11001235 xfs_dir3_leaf_check(dp, lbp);
Christoph Hellwig787b0892019-11-08 14:57:50 -08001236
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237 /*
1238 * Get to the leaf entry and contained data entry address.
1239 */
Christoph Hellwig787b0892019-11-08 14:57:50 -08001240 lep = &leafhdr.ents[index];
Dave Chinner24df33b2013-04-12 07:30:21 +10001241
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242 /*
1243 * Point to the data entry.
1244 */
1245 dep = (xfs_dir2_data_entry_t *)
Dave Chinner1d9025e2012-06-22 18:50:14 +10001246 ((char *)dbp->b_addr +
Dave Chinner30028032014-06-06 15:08:18 +10001247 xfs_dir2_dataptr_to_off(args->geo, be32_to_cpu(lep->address)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 /*
Barry Naujok384f3ce2008-05-21 16:58:22 +10001249 * Return the found inode number & CI name if appropriate
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 */
Christoph Hellwigff9901c2006-06-09 14:48:37 +10001251 args->inumber = be64_to_cpu(dep->inumber);
Christoph Hellwig59b8b462019-11-08 15:05:48 -08001252 args->filetype = xfs_dir2_data_get_ftype(dp->i_mount, dep);
Barry Naujok384f3ce2008-05-21 16:58:22 +10001253 error = xfs_dir_cilookup_result(args, dep->name, dep->namelen);
Dave Chinner1d9025e2012-06-22 18:50:14 +10001254 xfs_trans_brelse(tp, dbp);
1255 xfs_trans_brelse(tp, lbp);
Eric Sandeenb474c7a2014-06-22 15:04:54 +10001256 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257}
1258
1259/*
1260 * Look up name/hash in the leaf block.
1261 * Fill in indexp with the found index, and dbpp with the data buffer.
1262 * If not found dbpp will be NULL, and ENOENT comes back.
1263 * lbpp will always be filled in with the leaf buffer unless there's an error.
1264 */
1265static int /* error */
1266xfs_dir2_leaf_lookup_int(
1267 xfs_da_args_t *args, /* operation arguments */
Dave Chinner1d9025e2012-06-22 18:50:14 +10001268 struct xfs_buf **lbpp, /* out: leaf buffer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 int *indexp, /* out: index in leaf block */
Christoph Hellwig787b0892019-11-08 14:57:50 -08001270 struct xfs_buf **dbpp, /* out: data buffer */
1271 struct xfs_dir3_icleaf_hdr *leafhdr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272{
Barry Naujok07fe4dd2008-06-27 13:32:11 +10001273 xfs_dir2_db_t curdb = -1; /* current data block number */
Dave Chinner1d9025e2012-06-22 18:50:14 +10001274 struct xfs_buf *dbp = NULL; /* data buffer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 xfs_dir2_data_entry_t *dep; /* data entry */
1276 xfs_inode_t *dp; /* incore directory inode */
1277 int error; /* error return code */
1278 int index; /* index in leaf block */
Dave Chinner1d9025e2012-06-22 18:50:14 +10001279 struct xfs_buf *lbp; /* leaf buffer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 xfs_dir2_leaf_entry_t *lep; /* leaf entry */
1281 xfs_dir2_leaf_t *leaf; /* leaf structure */
1282 xfs_mount_t *mp; /* filesystem mount point */
1283 xfs_dir2_db_t newdb; /* new data block number */
1284 xfs_trans_t *tp; /* transaction pointer */
Barry Naujok07fe4dd2008-06-27 13:32:11 +10001285 xfs_dir2_db_t cidb = -1; /* case match data block no. */
Barry Naujok5163f952008-05-21 16:41:01 +10001286 enum xfs_dacmp cmp; /* name compare result */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287
1288 dp = args->dp;
1289 tp = args->trans;
1290 mp = dp->i_mount;
Dave Chinnere6f76672012-11-12 22:54:15 +11001291
Darrick J. Wong402eef12024-04-15 14:54:39 -07001292 error = xfs_dir3_leaf_read(tp, dp, args->owner, args->geo->leafblk,
1293 &lbp);
Barry Naujok07fe4dd2008-06-27 13:32:11 +10001294 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 return error;
Dave Chinnere6f76672012-11-12 22:54:15 +11001296
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 *lbpp = lbp;
Dave Chinner1d9025e2012-06-22 18:50:14 +10001298 leaf = lbp->b_addr;
Dave Chinner41419562013-10-29 22:11:50 +11001299 xfs_dir3_leaf_check(dp, lbp);
Christoph Hellwig787b0892019-11-08 14:57:50 -08001300 xfs_dir2_leaf_hdr_from_disk(mp, leafhdr, leaf);
Dave Chinner24df33b2013-04-12 07:30:21 +10001301
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 /*
1303 * Look for the first leaf entry with our hash value.
1304 */
1305 index = xfs_dir2_leaf_search_hash(args, lbp);
1306 /*
1307 * Loop over all the entries with the right hash value
1308 * looking to match the name.
1309 */
Christoph Hellwig787b0892019-11-08 14:57:50 -08001310 for (lep = &leafhdr->ents[index];
1311 index < leafhdr->count &&
1312 be32_to_cpu(lep->hashval) == args->hashval;
Dave Chinner24df33b2013-04-12 07:30:21 +10001313 lep++, index++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 /*
1315 * Skip over stale leaf entries.
1316 */
Nathan Scott3c1f9c12006-03-17 17:28:18 +11001317 if (be32_to_cpu(lep->address) == XFS_DIR2_NULL_DATAPTR)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 continue;
1319 /*
1320 * Get the new data block number.
1321 */
Dave Chinner30028032014-06-06 15:08:18 +10001322 newdb = xfs_dir2_dataptr_to_db(args->geo,
1323 be32_to_cpu(lep->address));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 /*
1325 * If it's not the same as the old data block number,
1326 * need to pitch the old one and read the new one.
1327 */
1328 if (newdb != curdb) {
Barry Naujok07fe4dd2008-06-27 13:32:11 +10001329 if (dbp)
Dave Chinner1d9025e2012-06-22 18:50:14 +10001330 xfs_trans_brelse(tp, dbp);
Darrick J. Wongcc6740d2024-04-15 14:54:40 -07001331 error = xfs_dir3_data_read(tp, dp, args->owner,
1332 xfs_dir2_db_to_da(args->geo, newdb), 0,
1333 &dbp);
Barry Naujok5163f952008-05-21 16:41:01 +10001334 if (error) {
Dave Chinner1d9025e2012-06-22 18:50:14 +10001335 xfs_trans_brelse(tp, lbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 return error;
1337 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 curdb = newdb;
1339 }
1340 /*
1341 * Point to the data entry.
1342 */
Dave Chinner1d9025e2012-06-22 18:50:14 +10001343 dep = (xfs_dir2_data_entry_t *)((char *)dbp->b_addr +
Dave Chinner30028032014-06-06 15:08:18 +10001344 xfs_dir2_dataptr_to_off(args->geo,
1345 be32_to_cpu(lep->address)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 /*
Barry Naujok5163f952008-05-21 16:41:01 +10001347 * Compare name and if it's an exact match, return the index
1348 * and buffer. If it's the first case-insensitive match, store
1349 * the index and buffer and continue looking for an exact match.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 */
Christoph Hellwigd8d11fc2019-11-11 12:59:26 -08001351 cmp = xfs_dir2_compname(args, dep->name, dep->namelen);
Barry Naujok5163f952008-05-21 16:41:01 +10001352 if (cmp != XFS_CMP_DIFFERENT && cmp != args->cmpresult) {
1353 args->cmpresult = cmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 *indexp = index;
Barry Naujok07fe4dd2008-06-27 13:32:11 +10001355 /* case exact match: return the current buffer. */
Barry Naujok5163f952008-05-21 16:41:01 +10001356 if (cmp == XFS_CMP_EXACT) {
Barry Naujok5163f952008-05-21 16:41:01 +10001357 *dbpp = dbp;
1358 return 0;
1359 }
Barry Naujok07fe4dd2008-06-27 13:32:11 +10001360 cidb = curdb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 }
1362 }
Barry Naujok6a178102008-05-21 16:42:05 +10001363 ASSERT(args->op_flags & XFS_DA_OP_OKNOENT);
Barry Naujok5163f952008-05-21 16:41:01 +10001364 /*
Barry Naujok07fe4dd2008-06-27 13:32:11 +10001365 * Here, we can only be doing a lookup (not a rename or remove).
1366 * If a case-insensitive match was found earlier, re-read the
1367 * appropriate data block if required and return it.
Barry Naujok5163f952008-05-21 16:41:01 +10001368 */
1369 if (args->cmpresult == XFS_CMP_CASE) {
Barry Naujok07fe4dd2008-06-27 13:32:11 +10001370 ASSERT(cidb != -1);
1371 if (cidb != curdb) {
Dave Chinner1d9025e2012-06-22 18:50:14 +10001372 xfs_trans_brelse(tp, dbp);
Darrick J. Wongcc6740d2024-04-15 14:54:40 -07001373 error = xfs_dir3_data_read(tp, dp, args->owner,
1374 xfs_dir2_db_to_da(args->geo, cidb), 0,
1375 &dbp);
Barry Naujok07fe4dd2008-06-27 13:32:11 +10001376 if (error) {
Dave Chinner1d9025e2012-06-22 18:50:14 +10001377 xfs_trans_brelse(tp, lbp);
Barry Naujok07fe4dd2008-06-27 13:32:11 +10001378 return error;
1379 }
1380 }
1381 *dbpp = dbp;
Barry Naujok5163f952008-05-21 16:41:01 +10001382 return 0;
1383 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 /*
Dave Chinner24513372014-06-25 14:58:08 +10001385 * No match found, return -ENOENT.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 */
Barry Naujok07fe4dd2008-06-27 13:32:11 +10001387 ASSERT(cidb == -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 if (dbp)
Dave Chinner1d9025e2012-06-22 18:50:14 +10001389 xfs_trans_brelse(tp, dbp);
1390 xfs_trans_brelse(tp, lbp);
Dave Chinner24513372014-06-25 14:58:08 +10001391 return -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392}
1393
1394/*
1395 * Remove an entry from a leaf format directory.
1396 */
1397int /* error */
1398xfs_dir2_leaf_removename(
1399 xfs_da_args_t *args) /* operation arguments */
1400{
Christoph Hellwigd73e1ce2019-11-08 15:05:38 -08001401 struct xfs_da_geometry *geo = args->geo;
Nathan Scott68b3a102006-03-17 17:27:19 +11001402 __be16 *bestsp; /* leaf block best freespace */
Christoph Hellwigc2066e22011-07-08 14:35:38 +02001403 xfs_dir2_data_hdr_t *hdr; /* data block header */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 xfs_dir2_db_t db; /* data block number */
Dave Chinner1d9025e2012-06-22 18:50:14 +10001405 struct xfs_buf *dbp; /* data block buffer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 xfs_dir2_data_entry_t *dep; /* data entry structure */
1407 xfs_inode_t *dp; /* incore directory inode */
1408 int error; /* error return code */
1409 xfs_dir2_db_t i; /* temporary data block # */
1410 int index; /* index into leaf entries */
Dave Chinner1d9025e2012-06-22 18:50:14 +10001411 struct xfs_buf *lbp; /* leaf buffer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 xfs_dir2_leaf_t *leaf; /* leaf structure */
1413 xfs_dir2_leaf_entry_t *lep; /* leaf entry */
1414 xfs_dir2_leaf_tail_t *ltp; /* leaf tail structure */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 int needlog; /* need to log data header */
1416 int needscan; /* need to rescan data frees */
1417 xfs_dir2_data_off_t oldbest; /* old value of best free */
Dave Chinner33363fe2013-04-03 16:11:22 +11001418 struct xfs_dir2_data_free *bf; /* bestfree table */
Dave Chinner24df33b2013-04-12 07:30:21 +10001419 struct xfs_dir3_icleaf_hdr leafhdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001421 trace_xfs_dir2_leaf_removename(args);
1422
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 /*
1424 * Lookup the leaf entry, get the leaf and data blocks read in.
1425 */
Christoph Hellwig787b0892019-11-08 14:57:50 -08001426 error = xfs_dir2_leaf_lookup_int(args, &lbp, &index, &dbp, &leafhdr);
1427 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 return error;
Christoph Hellwig787b0892019-11-08 14:57:50 -08001429
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 dp = args->dp;
Dave Chinner1d9025e2012-06-22 18:50:14 +10001431 leaf = lbp->b_addr;
1432 hdr = dbp->b_addr;
Dave Chinner33363fe2013-04-03 16:11:22 +11001433 xfs_dir3_data_check(dp, dbp);
Christoph Hellwig1848b602019-11-08 15:05:39 -08001434 bf = xfs_dir2_data_bestfree_p(dp->i_mount, hdr);
Christoph Hellwig787b0892019-11-08 14:57:50 -08001435
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 /*
1437 * Point to the leaf entry, use that to point to the data entry.
1438 */
Christoph Hellwig787b0892019-11-08 14:57:50 -08001439 lep = &leafhdr.ents[index];
Christoph Hellwigd73e1ce2019-11-08 15:05:38 -08001440 db = xfs_dir2_dataptr_to_db(geo, be32_to_cpu(lep->address));
Dave Chinner30028032014-06-06 15:08:18 +10001441 dep = (xfs_dir2_data_entry_t *)((char *)hdr +
Christoph Hellwigd73e1ce2019-11-08 15:05:38 -08001442 xfs_dir2_dataptr_to_off(geo, be32_to_cpu(lep->address)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 needscan = needlog = 0;
Dave Chinner33363fe2013-04-03 16:11:22 +11001444 oldbest = be16_to_cpu(bf[0].length);
Christoph Hellwigd73e1ce2019-11-08 15:05:38 -08001445 ltp = xfs_dir2_leaf_tail_p(geo, leaf);
Christoph Hellwigbbaaf532007-06-28 16:43:50 +10001446 bestsp = xfs_dir2_leaf_bests_p(ltp);
Darrick J. Wonga5155b82019-11-02 09:40:53 -07001447 if (be16_to_cpu(bestsp[db]) != oldbest) {
Darrick J. Wong8d57c212020-03-11 10:37:54 -07001448 xfs_buf_mark_corrupt(lbp);
Darrick J. Wongca14c092024-02-22 12:32:18 -08001449 xfs_da_mark_sick(args);
Darrick J. Wong3f883f52018-03-06 17:08:31 -08001450 return -EFSCORRUPTED;
Darrick J. Wonga5155b82019-11-02 09:40:53 -07001451 }
Darrick J. Wongca14c092024-02-22 12:32:18 -08001452
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 /*
1454 * Mark the former data entry unused.
1455 */
Dave Chinnerbc851782014-06-06 15:20:54 +10001456 xfs_dir2_data_make_free(args, dbp,
Christoph Hellwigc2066e22011-07-08 14:35:38 +02001457 (xfs_dir2_data_aoff_t)((char *)dep - (char *)hdr),
Christoph Hellwigfdbb8c52019-11-08 15:05:37 -08001458 xfs_dir2_data_entsize(dp->i_mount, dep->namelen), &needlog,
1459 &needscan);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 /*
1461 * We just mark the leaf entry stale by putting a null in it.
1462 */
Dave Chinner24df33b2013-04-12 07:30:21 +10001463 leafhdr.stale++;
Christoph Hellwig163fbbb2019-11-08 14:57:50 -08001464 xfs_dir2_leaf_hdr_to_disk(dp->i_mount, leaf, &leafhdr);
Dave Chinnerbc851782014-06-06 15:20:54 +10001465 xfs_dir3_leaf_log_header(args, lbp);
Dave Chinner24df33b2013-04-12 07:30:21 +10001466
Nathan Scott3c1f9c12006-03-17 17:28:18 +11001467 lep->address = cpu_to_be32(XFS_DIR2_NULL_DATAPTR);
Christoph Hellwig787b0892019-11-08 14:57:50 -08001468 xfs_dir3_leaf_log_ents(args, &leafhdr, lbp, index, index);
Dave Chinner24df33b2013-04-12 07:30:21 +10001469
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470 /*
1471 * Scan the freespace in the data block again if necessary,
1472 * log the data block header if necessary.
1473 */
1474 if (needscan)
Christoph Hellwigae429762019-11-08 15:06:02 -08001475 xfs_dir2_data_freescan(dp->i_mount, hdr, &needlog);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476 if (needlog)
Dave Chinnerbc851782014-06-06 15:20:54 +10001477 xfs_dir2_data_log_header(args, dbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 /*
1479 * If the longest freespace in the data block has changed,
1480 * put the new value in the bests table and log that.
1481 */
Dave Chinner33363fe2013-04-03 16:11:22 +11001482 if (be16_to_cpu(bf[0].length) != oldbest) {
1483 bestsp[db] = bf[0].length;
Dave Chinnerbc851782014-06-06 15:20:54 +10001484 xfs_dir3_leaf_log_bests(args, lbp, db, db);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 }
Dave Chinner33363fe2013-04-03 16:11:22 +11001486 xfs_dir3_data_check(dp, dbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 /*
1488 * If the data block is now empty then get rid of the data block.
1489 */
Dave Chinner33363fe2013-04-03 16:11:22 +11001490 if (be16_to_cpu(bf[0].length) ==
Christoph Hellwigd73e1ce2019-11-08 15:05:38 -08001491 geo->blksize - geo->data_entry_offset) {
1492 ASSERT(db != geo->datablk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 if ((error = xfs_dir2_shrink_inode(args, db, dbp))) {
1494 /*
1495 * Nope, can't get rid of it because it caused
1496 * allocation of a bmap btree block to do so.
1497 * Just go on, returning success, leaving the
1498 * empty block in place.
1499 */
Dave Chinner24513372014-06-25 14:58:08 +10001500 if (error == -ENOSPC && args->total == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 error = 0;
Dave Chinner41419562013-10-29 22:11:50 +11001502 xfs_dir3_leaf_check(dp, lbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 return error;
1504 }
1505 dbp = NULL;
1506 /*
1507 * If this is the last data block then compact the
1508 * bests table by getting rid of entries.
1509 */
Nathan Scottafbcb3f2006-03-17 17:27:28 +11001510 if (db == be32_to_cpu(ltp->bestcount) - 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 /*
1512 * Look for the last active entry (i).
1513 */
1514 for (i = db - 1; i > 0; i--) {
Christoph Hellwig69ef9212011-07-08 14:36:05 +02001515 if (bestsp[i] != cpu_to_be16(NULLDATAOFF))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 break;
1517 }
1518 /*
1519 * Copy the table down so inactive entries at the
1520 * end are removed.
1521 */
1522 memmove(&bestsp[db - i], bestsp,
Nathan Scottafbcb3f2006-03-17 17:27:28 +11001523 (be32_to_cpu(ltp->bestcount) - (db - i)) * sizeof(*bestsp));
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001524 be32_add_cpu(&ltp->bestcount, -(db - i));
Dave Chinnerbc851782014-06-06 15:20:54 +10001525 xfs_dir3_leaf_log_tail(args, lbp);
1526 xfs_dir3_leaf_log_bests(args, lbp, 0,
1527 be32_to_cpu(ltp->bestcount) - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 } else
Nathan Scott68b3a102006-03-17 17:27:19 +11001529 bestsp[db] = cpu_to_be16(NULLDATAOFF);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 }
1531 /*
1532 * If the data block was not the first one, drop it.
1533 */
Christoph Hellwigd73e1ce2019-11-08 15:05:38 -08001534 else if (db != geo->datablk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 dbp = NULL;
Dave Chinner1d9025e2012-06-22 18:50:14 +10001536
Dave Chinner41419562013-10-29 22:11:50 +11001537 xfs_dir3_leaf_check(dp, lbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 /*
1539 * See if we can convert to block form.
1540 */
1541 return xfs_dir2_leaf_to_block(args, lbp, dbp);
1542}
1543
1544/*
1545 * Replace the inode number in a leaf format directory entry.
1546 */
1547int /* error */
1548xfs_dir2_leaf_replace(
1549 xfs_da_args_t *args) /* operation arguments */
1550{
Dave Chinner1d9025e2012-06-22 18:50:14 +10001551 struct xfs_buf *dbp; /* data block buffer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552 xfs_dir2_data_entry_t *dep; /* data block entry */
1553 xfs_inode_t *dp; /* incore directory inode */
1554 int error; /* error return code */
1555 int index; /* index of leaf entry */
Dave Chinner1d9025e2012-06-22 18:50:14 +10001556 struct xfs_buf *lbp; /* leaf buffer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 xfs_dir2_leaf_entry_t *lep; /* leaf entry */
1558 xfs_trans_t *tp; /* transaction pointer */
Christoph Hellwig787b0892019-11-08 14:57:50 -08001559 struct xfs_dir3_icleaf_hdr leafhdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001561 trace_xfs_dir2_leaf_replace(args);
1562
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 /*
1564 * Look up the entry.
1565 */
Christoph Hellwig787b0892019-11-08 14:57:50 -08001566 error = xfs_dir2_leaf_lookup_int(args, &lbp, &index, &dbp, &leafhdr);
1567 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568 return error;
Christoph Hellwig787b0892019-11-08 14:57:50 -08001569
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 dp = args->dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 /*
1572 * Point to the leaf entry, get data address from it.
1573 */
Christoph Hellwig787b0892019-11-08 14:57:50 -08001574 lep = &leafhdr.ents[index];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 /*
1576 * Point to the data entry.
1577 */
1578 dep = (xfs_dir2_data_entry_t *)
Dave Chinner1d9025e2012-06-22 18:50:14 +10001579 ((char *)dbp->b_addr +
Dave Chinner30028032014-06-06 15:08:18 +10001580 xfs_dir2_dataptr_to_off(args->geo, be32_to_cpu(lep->address)));
Christoph Hellwigff9901c2006-06-09 14:48:37 +10001581 ASSERT(args->inumber != be64_to_cpu(dep->inumber));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 /*
1583 * Put the new inode number in, log it.
1584 */
Christoph Hellwigff9901c2006-06-09 14:48:37 +10001585 dep->inumber = cpu_to_be64(args->inumber);
Christoph Hellwig59b8b462019-11-08 15:05:48 -08001586 xfs_dir2_data_put_ftype(dp->i_mount, dep, args->filetype);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 tp = args->trans;
Dave Chinnerbc851782014-06-06 15:20:54 +10001588 xfs_dir2_data_log_entry(args, dbp, dep);
Dave Chinner41419562013-10-29 22:11:50 +11001589 xfs_dir3_leaf_check(dp, lbp);
Dave Chinner1d9025e2012-06-22 18:50:14 +10001590 xfs_trans_brelse(tp, lbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 return 0;
1592}
1593
1594/*
1595 * Return index in the leaf block (lbp) which is either the first
1596 * one with this hash value, or if there are none, the insert point
1597 * for that hash value.
1598 */
1599int /* index value */
1600xfs_dir2_leaf_search_hash(
1601 xfs_da_args_t *args, /* operation arguments */
Dave Chinner1d9025e2012-06-22 18:50:14 +10001602 struct xfs_buf *lbp) /* leaf buffer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603{
1604 xfs_dahash_t hash=0; /* hash from this entry */
1605 xfs_dahash_t hashwant; /* hash value looking for */
1606 int high; /* high leaf index */
1607 int low; /* low leaf index */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608 xfs_dir2_leaf_entry_t *lep; /* leaf entry */
1609 int mid=0; /* current leaf index */
Dave Chinner24df33b2013-04-12 07:30:21 +10001610 struct xfs_dir3_icleaf_hdr leafhdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611
Christoph Hellwig787b0892019-11-08 14:57:50 -08001612 xfs_dir2_leaf_hdr_from_disk(args->dp->i_mount, &leafhdr, lbp->b_addr);
Dave Chinner24df33b2013-04-12 07:30:21 +10001613
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614 /*
1615 * Note, the table cannot be empty, so we have to go through the loop.
1616 * Binary search the leaf entries looking for our hash value.
1617 */
Christoph Hellwig787b0892019-11-08 14:57:50 -08001618 for (lep = leafhdr.ents, low = 0, high = leafhdr.count - 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 hashwant = args->hashval;
1620 low <= high; ) {
1621 mid = (low + high) >> 1;
Nathan Scott3c1f9c12006-03-17 17:28:18 +11001622 if ((hash = be32_to_cpu(lep[mid].hashval)) == hashwant)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 break;
1624 if (hash < hashwant)
1625 low = mid + 1;
1626 else
1627 high = mid - 1;
1628 }
1629 /*
1630 * Found one, back up through all the equal hash values.
1631 */
1632 if (hash == hashwant) {
Nathan Scott3c1f9c12006-03-17 17:28:18 +11001633 while (mid > 0 && be32_to_cpu(lep[mid - 1].hashval) == hashwant) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634 mid--;
1635 }
1636 }
1637 /*
1638 * Need to point to an entry higher than ours.
1639 */
1640 else if (hash < hashwant)
1641 mid++;
1642 return mid;
1643}
1644
1645/*
1646 * Trim off a trailing data block. We know it's empty since the leaf
1647 * freespace table says so.
1648 */
1649int /* error */
1650xfs_dir2_leaf_trim_data(
1651 xfs_da_args_t *args, /* operation arguments */
Dave Chinner1d9025e2012-06-22 18:50:14 +10001652 struct xfs_buf *lbp, /* leaf buffer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653 xfs_dir2_db_t db) /* data block number */
1654{
Christoph Hellwigd73e1ce2019-11-08 15:05:38 -08001655 struct xfs_da_geometry *geo = args->geo;
Nathan Scott68b3a102006-03-17 17:27:19 +11001656 __be16 *bestsp; /* leaf bests table */
Dave Chinner1d9025e2012-06-22 18:50:14 +10001657 struct xfs_buf *dbp; /* data block buffer */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 xfs_inode_t *dp; /* incore directory inode */
1659 int error; /* error return value */
1660 xfs_dir2_leaf_t *leaf; /* leaf structure */
1661 xfs_dir2_leaf_tail_t *ltp; /* leaf tail structure */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662 xfs_trans_t *tp; /* transaction pointer */
1663
1664 dp = args->dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665 tp = args->trans;
1666 /*
1667 * Read the offending data block. We need its buffer.
1668 */
Darrick J. Wongcc6740d2024-04-15 14:54:40 -07001669 error = xfs_dir3_data_read(tp, dp, args->owner,
1670 xfs_dir2_db_to_da(geo, db), 0, &dbp);
Dave Chinner4bb20a82012-11-12 22:54:10 +11001671 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673
Dave Chinner1d9025e2012-06-22 18:50:14 +10001674 leaf = lbp->b_addr;
Christoph Hellwigd73e1ce2019-11-08 15:05:38 -08001675 ltp = xfs_dir2_leaf_tail_p(geo, leaf);
Christoph Hellwigc2066e22011-07-08 14:35:38 +02001676
1677#ifdef DEBUG
1678{
Dave Chinner1d9025e2012-06-22 18:50:14 +10001679 struct xfs_dir2_data_hdr *hdr = dbp->b_addr;
Christoph Hellwig1848b602019-11-08 15:05:39 -08001680 struct xfs_dir2_data_free *bf =
1681 xfs_dir2_data_bestfree_p(dp->i_mount, hdr);
Christoph Hellwigc2066e22011-07-08 14:35:38 +02001682
Dave Chinner33363fe2013-04-03 16:11:22 +11001683 ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
1684 hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC));
1685 ASSERT(be16_to_cpu(bf[0].length) ==
Christoph Hellwigd73e1ce2019-11-08 15:05:38 -08001686 geo->blksize - geo->data_entry_offset);
Nathan Scottafbcb3f2006-03-17 17:27:28 +11001687 ASSERT(db == be32_to_cpu(ltp->bestcount) - 1);
Christoph Hellwigc2066e22011-07-08 14:35:38 +02001688}
1689#endif
1690
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 /*
1692 * Get rid of the data block.
1693 */
1694 if ((error = xfs_dir2_shrink_inode(args, db, dbp))) {
Dave Chinner24513372014-06-25 14:58:08 +10001695 ASSERT(error != -ENOSPC);
Dave Chinner1d9025e2012-06-22 18:50:14 +10001696 xfs_trans_brelse(tp, dbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 return error;
1698 }
1699 /*
1700 * Eliminate the last bests entry from the table.
1701 */
Christoph Hellwigbbaaf532007-06-28 16:43:50 +10001702 bestsp = xfs_dir2_leaf_bests_p(ltp);
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001703 be32_add_cpu(&ltp->bestcount, -1);
Nathan Scottafbcb3f2006-03-17 17:27:28 +11001704 memmove(&bestsp[1], &bestsp[0], be32_to_cpu(ltp->bestcount) * sizeof(*bestsp));
Dave Chinnerbc851782014-06-06 15:20:54 +10001705 xfs_dir3_leaf_log_tail(args, lbp);
1706 xfs_dir3_leaf_log_bests(args, lbp, 0, be32_to_cpu(ltp->bestcount) - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 return 0;
1708}
1709
Christoph Hellwig22823962011-07-08 14:35:53 +02001710static inline size_t
Dave Chinner24df33b2013-04-12 07:30:21 +10001711xfs_dir3_leaf_size(
1712 struct xfs_dir3_icleaf_hdr *hdr,
Christoph Hellwig22823962011-07-08 14:35:53 +02001713 int counts)
1714{
Dave Chinner24df33b2013-04-12 07:30:21 +10001715 int entries;
1716 int hdrsize;
Christoph Hellwig22823962011-07-08 14:35:53 +02001717
Dave Chinner24df33b2013-04-12 07:30:21 +10001718 entries = hdr->count - hdr->stale;
1719 if (hdr->magic == XFS_DIR2_LEAF1_MAGIC ||
1720 hdr->magic == XFS_DIR2_LEAFN_MAGIC)
1721 hdrsize = sizeof(struct xfs_dir2_leaf_hdr);
1722 else
1723 hdrsize = sizeof(struct xfs_dir3_leaf_hdr);
1724
1725 return hdrsize + entries * sizeof(xfs_dir2_leaf_entry_t)
1726 + counts * sizeof(xfs_dir2_data_off_t)
1727 + sizeof(xfs_dir2_leaf_tail_t);
Christoph Hellwig22823962011-07-08 14:35:53 +02001728}
1729
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730/*
1731 * Convert node form directory to leaf form directory.
1732 * The root of the node form dir needs to already be a LEAFN block.
1733 * Just return if we can't do anything.
1734 */
1735int /* error */
1736xfs_dir2_node_to_leaf(
1737 xfs_da_state_t *state) /* directory operation state */
1738{
1739 xfs_da_args_t *args; /* operation arguments */
1740 xfs_inode_t *dp; /* incore directory inode */
1741 int error; /* error return code */
Dave Chinner1d9025e2012-06-22 18:50:14 +10001742 struct xfs_buf *fbp; /* buffer for freespace block */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743 xfs_fileoff_t fo; /* freespace file offset */
Dave Chinner1d9025e2012-06-22 18:50:14 +10001744 struct xfs_buf *lbp; /* buffer for leaf block */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745 xfs_dir2_leaf_tail_t *ltp; /* tail of leaf structure */
1746 xfs_dir2_leaf_t *leaf; /* leaf structure */
1747 xfs_mount_t *mp; /* filesystem mount point */
1748 int rval; /* successful free trim? */
1749 xfs_trans_t *tp; /* transaction pointer */
Dave Chinner24df33b2013-04-12 07:30:21 +10001750 struct xfs_dir3_icleaf_hdr leafhdr;
Dave Chinnercbc8adf2013-04-03 16:11:21 +11001751 struct xfs_dir3_icfree_hdr freehdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752
1753 /*
1754 * There's more than a leaf level in the btree, so there must
1755 * be multiple leafn blocks. Give up.
1756 */
1757 if (state->path.active > 1)
1758 return 0;
1759 args = state->args;
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001760
1761 trace_xfs_dir2_node_to_leaf(args);
1762
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763 mp = state->mp;
1764 dp = args->dp;
1765 tp = args->trans;
1766 /*
1767 * Get the last offset in the file.
1768 */
Eric Sandeen7fb2cd42014-04-14 18:58:05 +10001769 if ((error = xfs_bmap_last_offset(dp, &fo, XFS_DATA_FORK))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770 return error;
1771 }
Dave Chinnerd6cf1302014-06-06 15:14:11 +10001772 fo -= args->geo->fsbcount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773 /*
1774 * If there are freespace blocks other than the first one,
1775 * take this opportunity to remove trailing empty freespace blocks
1776 * that may have been left behind during no-space-reservation
1777 * operations.
1778 */
Dave Chinner7dda6e82014-06-06 15:11:18 +10001779 while (fo > args->geo->freeblk) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780 if ((error = xfs_dir2_node_trim_free(args, fo, &rval))) {
1781 return error;
1782 }
1783 if (rval)
Dave Chinnerd6cf1302014-06-06 15:14:11 +10001784 fo -= args->geo->fsbcount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 else
1786 return 0;
1787 }
1788 /*
1789 * Now find the block just before the freespace block.
1790 */
1791 if ((error = xfs_bmap_last_before(tp, dp, &fo, XFS_DATA_FORK))) {
1792 return error;
1793 }
1794 /*
1795 * If it's not the single leaf block, give up.
1796 */
Dave Chinner8f661932014-06-06 15:15:59 +10001797 if (XFS_FSB_TO_B(mp, fo) > XFS_DIR2_LEAF_OFFSET + args->geo->blksize)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798 return 0;
1799 lbp = state->path.blk[0].bp;
Dave Chinner1d9025e2012-06-22 18:50:14 +10001800 leaf = lbp->b_addr;
Christoph Hellwig51842552019-11-08 14:57:49 -08001801 xfs_dir2_leaf_hdr_from_disk(mp, &leafhdr, leaf);
Dave Chinner24df33b2013-04-12 07:30:21 +10001802
1803 ASSERT(leafhdr.magic == XFS_DIR2_LEAFN_MAGIC ||
1804 leafhdr.magic == XFS_DIR3_LEAFN_MAGIC);
1805
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806 /*
1807 * Read the freespace block.
1808 */
Darrick J. Wongfe6c9f82024-04-15 14:54:41 -07001809 error = xfs_dir2_free_read(tp, dp, args->owner, args->geo->freeblk,
1810 &fbp);
Dave Chinner4bb20a82012-11-12 22:54:10 +11001811 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812 return error;
Christoph Hellwiga84f3d52019-11-08 14:58:05 -08001813 xfs_dir2_free_hdr_from_disk(mp, &freehdr, fbp->b_addr);
Dave Chinnercbc8adf2013-04-03 16:11:21 +11001814
1815 ASSERT(!freehdr.firstdb);
Christoph Hellwig22823962011-07-08 14:35:53 +02001816
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 /*
1818 * Now see if the leafn and free data will fit in a leaf1.
1819 * If not, release the buffer and give up.
1820 */
Dave Chinner8f661932014-06-06 15:15:59 +10001821 if (xfs_dir3_leaf_size(&leafhdr, freehdr.nvalid) > args->geo->blksize) {
Dave Chinner1d9025e2012-06-22 18:50:14 +10001822 xfs_trans_brelse(tp, fbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823 return 0;
1824 }
Christoph Hellwig22823962011-07-08 14:35:53 +02001825
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 /*
1827 * If the leaf has any stale entries in it, compress them out.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828 */
Dave Chinner24df33b2013-04-12 07:30:21 +10001829 if (leafhdr.stale)
1830 xfs_dir3_leaf_compact(args, &leafhdr, lbp);
Dave Chinnerb0f539de2012-11-14 17:53:49 +11001831
Dave Chinner24df33b2013-04-12 07:30:21 +10001832 lbp->b_ops = &xfs_dir3_leaf1_buf_ops;
Dave Chinner61fe1352013-04-03 16:11:30 +11001833 xfs_trans_buf_set_type(tp, lbp, XFS_BLFT_DIR_LEAF1_BUF);
Dave Chinner24df33b2013-04-12 07:30:21 +10001834 leafhdr.magic = (leafhdr.magic == XFS_DIR2_LEAFN_MAGIC)
1835 ? XFS_DIR2_LEAF1_MAGIC
1836 : XFS_DIR3_LEAF1_MAGIC;
Dave Chinnerb0f539de2012-11-14 17:53:49 +11001837
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 /*
1839 * Set up the leaf tail from the freespace block.
1840 */
Dave Chinner8f661932014-06-06 15:15:59 +10001841 ltp = xfs_dir2_leaf_tail_p(args->geo, leaf);
Dave Chinnercbc8adf2013-04-03 16:11:21 +11001842 ltp->bestcount = cpu_to_be32(freehdr.nvalid);
Dave Chinner24df33b2013-04-12 07:30:21 +10001843
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844 /*
1845 * Set up the leaf bests table.
1846 */
Christoph Hellwiga84f3d52019-11-08 14:58:05 -08001847 memcpy(xfs_dir2_leaf_bests_p(ltp), freehdr.bests,
Dave Chinnercbc8adf2013-04-03 16:11:21 +11001848 freehdr.nvalid * sizeof(xfs_dir2_data_off_t));
Dave Chinner24df33b2013-04-12 07:30:21 +10001849
Christoph Hellwig163fbbb2019-11-08 14:57:50 -08001850 xfs_dir2_leaf_hdr_to_disk(mp, leaf, &leafhdr);
Dave Chinnerbc851782014-06-06 15:20:54 +10001851 xfs_dir3_leaf_log_header(args, lbp);
1852 xfs_dir3_leaf_log_bests(args, lbp, 0, be32_to_cpu(ltp->bestcount) - 1);
1853 xfs_dir3_leaf_log_tail(args, lbp);
Dave Chinner41419562013-10-29 22:11:50 +11001854 xfs_dir3_leaf_check(dp, lbp);
Dave Chinner24df33b2013-04-12 07:30:21 +10001855
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856 /*
1857 * Get rid of the freespace block.
1858 */
Dave Chinner8c44a282014-06-06 15:04:41 +10001859 error = xfs_dir2_shrink_inode(args,
Dave Chinner30028032014-06-06 15:08:18 +10001860 xfs_dir2_byte_to_db(args->geo, XFS_DIR2_FREE_OFFSET),
1861 fbp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 if (error) {
1863 /*
1864 * This can't fail here because it can only happen when
1865 * punching out the middle of an extent, and this is an
1866 * isolated block.
1867 */
Dave Chinner24513372014-06-25 14:58:08 +10001868 ASSERT(error != -ENOSPC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869 return error;
1870 }
1871 fbp = NULL;
1872 /*
1873 * Now see if we can convert the single-leaf directory
1874 * down to a block form directory.
1875 * This routine always kills the dabuf for the leaf, so
1876 * eliminate it from the path.
1877 */
1878 error = xfs_dir2_leaf_to_block(args, lbp, NULL);
1879 state->path.blk[0].bp = NULL;
1880 return error;
1881}