]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blame - fs/gfs2/dir.c
rtc: at91sam9: Remove unnecessary offset variable checks
[mirror_ubuntu-jammy-kernel.git] / fs / gfs2 / dir.c
CommitLineData
7336d0e6 1// SPDX-License-Identifier: GPL-2.0-only
b3b94faa
DT
2/*
3 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3a8a9a10 4 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
b3b94faa
DT
5 */
6
7/*
61e085a8
SW
8 * Implements Extendible Hashing as described in:
9 * "Extendible Hashing" by Fagin, et al in
10 * __ACM Trans. on Database Systems__, Sept 1979.
11 *
12 *
13 * Here's the layout of dirents which is essentially the same as that of ext2
14 * within a single block. The field de_name_len is the number of bytes
15 * actually required for the name (no null terminator). The field de_rec_len
16 * is the number of bytes allocated to the dirent. The offset of the next
17 * dirent in the block is (dirent + dirent->de_rec_len). When a dirent is
18 * deleted, the preceding dirent inherits its allocated space, ie
19 * prev->de_rec_len += deleted->de_rec_len. Since the next dirent is obtained
20 * by adding de_rec_len to the current dirent, this essentially causes the
21 * deleted dirent to get jumped over when iterating through all the dirents.
22 *
23 * When deleting the first dirent in a block, there is no previous dirent so
24 * the field de_ino is set to zero to designate it as deleted. When allocating
25 * a dirent, gfs2_dirent_alloc iterates through the dirents in a block. If the
26 * first dirent has (de_ino == 0) and de_rec_len is large enough, this first
27 * dirent is allocated. Otherwise it must go through all the 'used' dirents
28 * searching for one in which the amount of total space minus the amount of
29 * used space will provide enough space for the new dirent.
30 *
31 * There are two types of blocks in which dirents reside. In a stuffed dinode,
32 * the dirents begin at offset sizeof(struct gfs2_dinode) from the beginning of
33 * the block. In leaves, they begin at offset sizeof(struct gfs2_leaf) from the
34 * beginning of the leaf block. The dirents reside in leaves when
35 *
383f01fb 36 * dip->i_diskflags & GFS2_DIF_EXHASH is true
61e085a8
SW
37 *
38 * Otherwise, the dirents are "linear", within a single stuffed dinode block.
39 *
40 * When the dirents are in leaves, the actual contents of the directory file are
41 * used as an array of 64-bit block pointers pointing to the leaf blocks. The
42 * dirents are NOT in the directory file itself. There can be more than one
43 * block pointer in the array that points to the same leaf. In fact, when a
44 * directory is first converted from linear to exhash, all of the pointers
45 * point to the same leaf.
46 *
47 * When a leaf is completely full, the size of the hash table can be
48 * doubled unless it is already at the maximum size which is hard coded into
49 * GFS2_DIR_MAX_DEPTH. After that, leaves are chained together in a linked list,
50 * but never before the maximum hash table size has been reached.
51 */
b3b94faa 52
d77d1b58
JP
53#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
54
b3b94faa
DT
55#include <linux/slab.h>
56#include <linux/spinlock.h>
b3b94faa
DT
57#include <linux/buffer_head.h>
58#include <linux/sort.h>
5c676f6d 59#include <linux/gfs2_ondisk.h>
71b86f56 60#include <linux/crc32.h>
fe1bdedc 61#include <linux/vmalloc.h>
2f8b5444 62#include <linux/bio.h>
b3b94faa
DT
63
64#include "gfs2.h"
5c676f6d 65#include "incore.h"
b3b94faa
DT
66#include "dir.h"
67#include "glock.h"
68#include "inode.h"
b3b94faa
DT
69#include "meta_io.h"
70#include "quota.h"
71#include "rgrp.h"
72#include "trans.h"
e13940ba 73#include "bmap.h"
5c676f6d 74#include "util.h"
b3b94faa 75
dfe4d34b
BP
76#define MAX_RA_BLOCKS 32 /* max read-ahead blocks */
77
cd915493
SW
78#define gfs2_disk_hash2offset(h) (((u64)(h)) >> 1)
79#define gfs2_dir_offset2hash(p) ((u32)(((u64)(p)) << 1))
471f3db2
BM
80#define GFS2_HASH_INDEX_MASK 0xffffc000
81#define GFS2_USE_HASH_FLAG 0x2000
b3b94faa 82
8d123585
SW
83struct qstr gfs2_qdot __read_mostly;
84struct qstr gfs2_qdotdot __read_mostly;
85
2bdbc5d7
SW
86typedef int (*gfs2_dscan_t)(const struct gfs2_dirent *dent,
87 const struct qstr *name, void *opaque);
b3b94faa 88
cd915493 89int gfs2_dir_get_new_buffer(struct gfs2_inode *ip, u64 block,
61e085a8 90 struct buffer_head **bhp)
e13940ba
SW
91{
92 struct buffer_head *bh;
e13940ba 93
61e085a8 94 bh = gfs2_meta_new(ip->i_gl, block);
350a9b0a 95 gfs2_trans_add_meta(ip->i_gl, bh);
61e085a8
SW
96 gfs2_metatype_set(bh, GFS2_METATYPE_JD, GFS2_FORMAT_JD);
97 gfs2_buffer_clear_tail(bh, sizeof(struct gfs2_meta_header));
e13940ba
SW
98 *bhp = bh;
99 return 0;
100}
101
cd915493 102static int gfs2_dir_get_existing_buffer(struct gfs2_inode *ip, u64 block,
61e085a8
SW
103 struct buffer_head **bhp)
104{
105 struct buffer_head *bh;
106 int error;
e13940ba 107
c8d57703 108 error = gfs2_meta_read(ip->i_gl, block, DIO_WAIT, 0, &bh);
61e085a8
SW
109 if (error)
110 return error;
feaa7bba 111 if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), bh, GFS2_METATYPE_JD)) {
61e085a8
SW
112 brelse(bh);
113 return -EIO;
114 }
115 *bhp = bh;
116 return 0;
117}
e13940ba
SW
118
119static int gfs2_dir_write_stuffed(struct gfs2_inode *ip, const char *buf,
120 unsigned int offset, unsigned int size)
e13940ba
SW
121{
122 struct buffer_head *dibh;
123 int error;
124
125 error = gfs2_meta_inode_buffer(ip, &dibh);
126 if (error)
127 return error;
128
350a9b0a 129 gfs2_trans_add_meta(ip->i_gl, dibh);
c752666c 130 memcpy(dibh->b_data + offset + sizeof(struct gfs2_dinode), buf, size);
a2e0f799
SW
131 if (ip->i_inode.i_size < offset + size)
132 i_size_write(&ip->i_inode, offset + size);
078cd827 133 ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
539e5d6b 134 gfs2_dinode_out(ip, dibh->b_data);
e13940ba
SW
135
136 brelse(dibh);
137
138 return size;
139}
140
141
142
143/**
144 * gfs2_dir_write_data - Write directory information to the inode
145 * @ip: The GFS2 inode
146 * @buf: The buffer containing information to be written
147 * @offset: The file offset to start writing at
148 * @size: The amount of data to write
149 *
150 * Returns: The number of bytes correctly written or error code
151 */
152static int gfs2_dir_write_data(struct gfs2_inode *ip, const char *buf,
cd915493 153 u64 offset, unsigned int size)
e13940ba 154{
feaa7bba 155 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
e13940ba 156 struct buffer_head *dibh;
cd915493
SW
157 u64 lblock, dblock;
158 u32 extlen = 0;
e13940ba
SW
159 unsigned int o;
160 int copied = 0;
161 int error = 0;
9153dac1 162 bool new = false;
e13940ba
SW
163
164 if (!size)
165 return 0;
166
235628c5 167 if (gfs2_is_stuffed(ip) && offset + size <= gfs2_max_stuffed_size(ip))
568f4c96
SW
168 return gfs2_dir_write_stuffed(ip, buf, (unsigned int)offset,
169 size);
e13940ba
SW
170
171 if (gfs2_assert_warn(sdp, gfs2_is_jdata(ip)))
172 return -EINVAL;
173
174 if (gfs2_is_stuffed(ip)) {
f25ef0c1 175 error = gfs2_unstuff_dinode(ip, NULL);
e13940ba 176 if (error)
c752666c 177 return error;
e13940ba
SW
178 }
179
180 lblock = offset;
181 o = do_div(lblock, sdp->sd_jbsize) + sizeof(struct gfs2_meta_header);
182
183 while (copied < size) {
184 unsigned int amount;
185 struct buffer_head *bh;
e13940ba
SW
186
187 amount = size - copied;
188 if (amount > sdp->sd_sb.sb_bsize - o)
189 amount = sdp->sd_sb.sb_bsize - o;
190
191 if (!extlen) {
9153dac1
AG
192 extlen = 1;
193 error = gfs2_alloc_extent(&ip->i_inode, lblock, &dblock,
194 &extlen, &new);
e13940ba
SW
195 if (error)
196 goto fail;
197 error = -EIO;
198 if (gfs2_assert_withdraw(sdp, dblock))
199 goto fail;
200 }
201
61e085a8
SW
202 if (amount == sdp->sd_jbsize || new)
203 error = gfs2_dir_get_new_buffer(ip, dblock, &bh);
204 else
205 error = gfs2_dir_get_existing_buffer(ip, dblock, &bh);
206
e13940ba
SW
207 if (error)
208 goto fail;
209
350a9b0a 210 gfs2_trans_add_meta(ip->i_gl, bh);
e13940ba
SW
211 memcpy(bh->b_data + o, buf, amount);
212 brelse(bh);
e13940ba 213
899bb264 214 buf += amount;
e13940ba
SW
215 copied += amount;
216 lblock++;
217 dblock++;
218 extlen--;
219
220 o = sizeof(struct gfs2_meta_header);
221 }
222
223out:
224 error = gfs2_meta_inode_buffer(ip, &dibh);
225 if (error)
226 return error;
227
a2e0f799
SW
228 if (ip->i_inode.i_size < offset + copied)
229 i_size_write(&ip->i_inode, offset + copied);
078cd827 230 ip->i_inode.i_mtime = ip->i_inode.i_ctime = current_time(&ip->i_inode);
e13940ba 231
350a9b0a 232 gfs2_trans_add_meta(ip->i_gl, dibh);
539e5d6b 233 gfs2_dinode_out(ip, dibh->b_data);
e13940ba
SW
234 brelse(dibh);
235
236 return copied;
237fail:
238 if (copied)
239 goto out;
240 return error;
241}
242
4c28d338
SW
243static int gfs2_dir_read_stuffed(struct gfs2_inode *ip, __be64 *buf,
244 unsigned int size)
e13940ba
SW
245{
246 struct buffer_head *dibh;
247 int error;
248
249 error = gfs2_meta_inode_buffer(ip, &dibh);
250 if (!error) {
4c28d338 251 memcpy(buf, dibh->b_data + sizeof(struct gfs2_dinode), size);
e13940ba
SW
252 brelse(dibh);
253 }
254
255 return (error) ? error : size;
256}
257
258
259/**
260 * gfs2_dir_read_data - Read a data from a directory inode
261 * @ip: The GFS2 Inode
262 * @buf: The buffer to place result into
e13940ba
SW
263 * @size: Amount of data to transfer
264 *
265 * Returns: The amount of data actually copied or the error
266 */
4c28d338
SW
267static int gfs2_dir_read_data(struct gfs2_inode *ip, __be64 *buf,
268 unsigned int size)
e13940ba 269{
feaa7bba 270 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
cd915493
SW
271 u64 lblock, dblock;
272 u32 extlen = 0;
e13940ba
SW
273 unsigned int o;
274 int copied = 0;
275 int error = 0;
e13940ba
SW
276
277 if (gfs2_is_stuffed(ip))
4c28d338 278 return gfs2_dir_read_stuffed(ip, buf, size);
e13940ba
SW
279
280 if (gfs2_assert_warn(sdp, gfs2_is_jdata(ip)))
281 return -EINVAL;
282
4c28d338 283 lblock = 0;
e13940ba
SW
284 o = do_div(lblock, sdp->sd_jbsize) + sizeof(struct gfs2_meta_header);
285
286 while (copied < size) {
287 unsigned int amount;
288 struct buffer_head *bh;
e13940ba
SW
289
290 amount = size - copied;
291 if (amount > sdp->sd_sb.sb_bsize - o)
292 amount = sdp->sd_sb.sb_bsize - o;
293
294 if (!extlen) {
9153dac1
AG
295 extlen = 32;
296 error = gfs2_get_extent(&ip->i_inode, lblock,
fd88de56 297 &dblock, &extlen);
7276b3b0 298 if (error || !dblock)
e13940ba 299 goto fail;
7276b3b0 300 BUG_ON(extlen < 1);
7276b3b0 301 bh = gfs2_meta_ra(ip->i_gl, dblock, extlen);
b7d8ac3e 302 } else {
c8d57703 303 error = gfs2_meta_read(ip->i_gl, dblock, DIO_WAIT, 0, &bh);
e13940ba
SW
304 if (error)
305 goto fail;
7276b3b0
SW
306 }
307 error = gfs2_metatype_check(sdp, bh, GFS2_METATYPE_JD);
308 if (error) {
309 brelse(bh);
310 goto fail;
311 }
312 dblock++;
313 extlen--;
e13940ba
SW
314 memcpy(buf, bh->b_data + o, amount);
315 brelse(bh);
4c28d338 316 buf += (amount/sizeof(__be64));
e13940ba
SW
317 copied += amount;
318 lblock++;
e13940ba
SW
319 o = sizeof(struct gfs2_meta_header);
320 }
321
322 return copied;
323fail:
324 return (copied) ? copied : error;
325}
326
17d539f0
SW
327/**
328 * gfs2_dir_get_hash_table - Get pointer to the dir hash table
329 * @ip: The inode in question
330 *
331 * Returns: The hash table or an error
332 */
333
334static __be64 *gfs2_dir_get_hash_table(struct gfs2_inode *ip)
335{
336 struct inode *inode = &ip->i_inode;
337 int ret;
338 u32 hsize;
339 __be64 *hc;
340
341 BUG_ON(!(ip->i_diskflags & GFS2_DIF_EXHASH));
342
343 hc = ip->i_hash_cache;
344 if (hc)
345 return hc;
346
47a9a527 347 hsize = BIT(ip->i_depth);
17d539f0
SW
348 hsize *= sizeof(__be64);
349 if (hsize != i_size_read(&ip->i_inode)) {
350 gfs2_consist_inode(ip);
351 return ERR_PTR(-EIO);
352 }
353
e8830d88
BP
354 hc = kmalloc(hsize, GFP_NOFS | __GFP_NOWARN);
355 if (hc == NULL)
88dca4ca 356 hc = __vmalloc(hsize, GFP_NOFS);
e8830d88 357
17d539f0
SW
358 if (hc == NULL)
359 return ERR_PTR(-ENOMEM);
360
4c28d338 361 ret = gfs2_dir_read_data(ip, hc, hsize);
17d539f0 362 if (ret < 0) {
3cdcf63e 363 kvfree(hc);
17d539f0
SW
364 return ERR_PTR(ret);
365 }
366
367 spin_lock(&inode->i_lock);
9265f1d0 368 if (likely(!ip->i_hash_cache)) {
17d539f0 369 ip->i_hash_cache = hc;
9265f1d0
AV
370 hc = NULL;
371 }
17d539f0 372 spin_unlock(&inode->i_lock);
9265f1d0 373 kvfree(hc);
17d539f0
SW
374
375 return ip->i_hash_cache;
376}
377
378/**
379 * gfs2_dir_hash_inval - Invalidate dir hash
380 * @ip: The directory inode
381 *
382 * Must be called with an exclusive glock, or during glock invalidation.
383 */
384void gfs2_dir_hash_inval(struct gfs2_inode *ip)
385{
c36b97e9
BP
386 __be64 *hc;
387
388 spin_lock(&ip->i_inode.i_lock);
389 hc = ip->i_hash_cache;
17d539f0 390 ip->i_hash_cache = NULL;
c36b97e9
BP
391 spin_unlock(&ip->i_inode.i_lock);
392
3cdcf63e 393 kvfree(hc);
17d539f0
SW
394}
395
5e7d65cd
SW
396static inline int gfs2_dirent_sentinel(const struct gfs2_dirent *dent)
397{
398 return dent->de_inum.no_addr == 0 || dent->de_inum.no_formal_ino == 0;
399}
400
c752666c
SW
401static inline int __gfs2_dirent_find(const struct gfs2_dirent *dent,
402 const struct qstr *name, int ret)
403{
5e7d65cd 404 if (!gfs2_dirent_sentinel(dent) &&
c752666c
SW
405 be32_to_cpu(dent->de_hash) == name->hash &&
406 be16_to_cpu(dent->de_name_len) == name->len &&
2bdbc5d7 407 memcmp(dent+1, name->name, name->len) == 0)
c752666c
SW
408 return ret;
409 return 0;
410}
411
412static int gfs2_dirent_find(const struct gfs2_dirent *dent,
71b86f56
SW
413 const struct qstr *name,
414 void *opaque)
c752666c
SW
415{
416 return __gfs2_dirent_find(dent, name, 1);
417}
418
419static int gfs2_dirent_prev(const struct gfs2_dirent *dent,
71b86f56
SW
420 const struct qstr *name,
421 void *opaque)
c752666c
SW
422{
423 return __gfs2_dirent_find(dent, name, 2);
424}
425
426/*
427 * name->name holds ptr to start of block.
428 * name->len holds size of block.
b3b94faa 429 */
c752666c 430static int gfs2_dirent_last(const struct gfs2_dirent *dent,
71b86f56
SW
431 const struct qstr *name,
432 void *opaque)
c752666c
SW
433{
434 const char *start = name->name;
435 const char *end = (const char *)dent + be16_to_cpu(dent->de_rec_len);
436 if (name->len == (end - start))
437 return 1;
438 return 0;
439}
b3b94faa 440
34017472
BM
441/* Look for the dirent that contains the offset specified in data. Once we
442 * find that dirent, there must be space available there for the new dirent */
443static int gfs2_dirent_find_offset(const struct gfs2_dirent *dent,
444 const struct qstr *name,
445 void *ptr)
446{
447 unsigned required = GFS2_DIRENT_SIZE(name->len);
448 unsigned actual = GFS2_DIRENT_SIZE(be16_to_cpu(dent->de_name_len));
449 unsigned totlen = be16_to_cpu(dent->de_rec_len);
450
451 if (ptr < (void *)dent || ptr >= (void *)dent + totlen)
452 return 0;
453 if (gfs2_dirent_sentinel(dent))
454 actual = 0;
455 if (ptr < (void *)dent + actual)
456 return -1;
457 if ((void *)dent + totlen >= ptr + required)
458 return 1;
459 return -1;
460}
461
c752666c 462static int gfs2_dirent_find_space(const struct gfs2_dirent *dent,
71b86f56
SW
463 const struct qstr *name,
464 void *opaque)
b3b94faa 465{
c752666c
SW
466 unsigned required = GFS2_DIRENT_SIZE(name->len);
467 unsigned actual = GFS2_DIRENT_SIZE(be16_to_cpu(dent->de_name_len));
468 unsigned totlen = be16_to_cpu(dent->de_rec_len);
469
5e7d65cd 470 if (gfs2_dirent_sentinel(dent))
728a756b 471 actual = 0;
c5392124 472 if (totlen - actual >= required)
c752666c
SW
473 return 1;
474 return 0;
475}
476
71b86f56
SW
477struct dirent_gather {
478 const struct gfs2_dirent **pdent;
479 unsigned offset;
480};
481
482static int gfs2_dirent_gather(const struct gfs2_dirent *dent,
483 const struct qstr *name,
484 void *opaque)
485{
486 struct dirent_gather *g = opaque;
5e7d65cd 487 if (!gfs2_dirent_sentinel(dent)) {
71b86f56
SW
488 g->pdent[g->offset++] = dent;
489 }
490 return 0;
491}
492
c752666c
SW
493/*
494 * Other possible things to check:
495 * - Inode located within filesystem size (and on valid block)
496 * - Valid directory entry type
497 * Not sure how heavy-weight we want to make this... could also check
498 * hash is correct for example, but that would take a lot of extra time.
499 * For now the most important thing is to check that the various sizes
500 * are correct.
501 */
e54c78a2
BP
502static int gfs2_check_dirent(struct gfs2_sbd *sdp,
503 struct gfs2_dirent *dent, unsigned int offset,
c752666c
SW
504 unsigned int size, unsigned int len, int first)
505{
506 const char *msg = "gfs2_dirent too small";
507 if (unlikely(size < sizeof(struct gfs2_dirent)))
508 goto error;
509 msg = "gfs2_dirent misaligned";
510 if (unlikely(offset & 0x7))
511 goto error;
512 msg = "gfs2_dirent points beyond end of block";
513 if (unlikely(offset + size > len))
514 goto error;
515 msg = "zero inode number";
5e7d65cd 516 if (unlikely(!first && gfs2_dirent_sentinel(dent)))
c752666c
SW
517 goto error;
518 msg = "name length is greater than space in dirent";
5e7d65cd 519 if (!gfs2_dirent_sentinel(dent) &&
c752666c
SW
520 unlikely(sizeof(struct gfs2_dirent)+be16_to_cpu(dent->de_name_len) >
521 size))
522 goto error;
523 return 0;
524error:
e54c78a2 525 fs_warn(sdp, "%s: %s (%s)\n",
d77d1b58 526 __func__, msg, first ? "first in block" : "not first in block");
c752666c 527 return -EIO;
b3b94faa
DT
528}
529
e54c78a2 530static int gfs2_dirent_offset(struct gfs2_sbd *sdp, const void *buf)
c752666c 531{
71b86f56
SW
532 const struct gfs2_meta_header *h = buf;
533 int offset;
c752666c
SW
534
535 BUG_ON(buf == NULL);
c752666c 536
e3167ded 537 switch(be32_to_cpu(h->mh_type)) {
c752666c
SW
538 case GFS2_METATYPE_LF:
539 offset = sizeof(struct gfs2_leaf);
540 break;
541 case GFS2_METATYPE_DI:
542 offset = sizeof(struct gfs2_dinode);
543 break;
544 default:
545 goto wrong_type;
546 }
71b86f56
SW
547 return offset;
548wrong_type:
e54c78a2
BP
549 fs_warn(sdp, "%s: wrong block type %u\n", __func__,
550 be32_to_cpu(h->mh_type));
71b86f56
SW
551 return -1;
552}
553
2bdbc5d7 554static struct gfs2_dirent *gfs2_dirent_scan(struct inode *inode, void *buf,
71b86f56
SW
555 unsigned int len, gfs2_dscan_t scan,
556 const struct qstr *name,
557 void *opaque)
558{
559 struct gfs2_dirent *dent, *prev;
560 unsigned offset;
561 unsigned size;
562 int ret = 0;
c752666c 563
e54c78a2 564 ret = gfs2_dirent_offset(GFS2_SB(inode), buf);
71b86f56
SW
565 if (ret < 0)
566 goto consist_inode;
567
568 offset = ret;
c752666c 569 prev = NULL;
2bdbc5d7 570 dent = buf + offset;
c752666c 571 size = be16_to_cpu(dent->de_rec_len);
e54c78a2 572 if (gfs2_check_dirent(GFS2_SB(inode), dent, offset, size, len, 1))
c752666c
SW
573 goto consist_inode;
574 do {
71b86f56 575 ret = scan(dent, name, opaque);
c752666c
SW
576 if (ret)
577 break;
578 offset += size;
579 if (offset == len)
580 break;
581 prev = dent;
2bdbc5d7 582 dent = buf + offset;
c752666c 583 size = be16_to_cpu(dent->de_rec_len);
e54c78a2
BP
584 if (gfs2_check_dirent(GFS2_SB(inode), dent, offset, size,
585 len, 0))
c752666c
SW
586 goto consist_inode;
587 } while(1);
588
589 switch(ret) {
590 case 0:
591 return NULL;
592 case 1:
593 return dent;
594 case 2:
595 return prev ? prev : dent;
596 default:
597 BUG_ON(ret > 0);
598 return ERR_PTR(ret);
599 }
600
c752666c 601consist_inode:
feaa7bba 602 gfs2_consist_inode(GFS2_I(inode));
c752666c
SW
603 return ERR_PTR(-EIO);
604}
605
2bdbc5d7
SW
606static int dirent_check_reclen(struct gfs2_inode *dip,
607 const struct gfs2_dirent *d, const void *end_p)
608{
609 const void *ptr = d;
610 u16 rec_len = be16_to_cpu(d->de_rec_len);
611
612 if (unlikely(rec_len < sizeof(struct gfs2_dirent)))
613 goto broken;
614 ptr += rec_len;
615 if (ptr < end_p)
616 return rec_len;
617 if (ptr == end_p)
618 return -ENOENT;
619broken:
620 gfs2_consist_inode(dip);
621 return -EIO;
622}
623
b3b94faa
DT
624/**
625 * dirent_next - Next dirent
626 * @dip: the directory
627 * @bh: The buffer
628 * @dent: Pointer to list of dirents
629 *
630 * Returns: 0 on success, error code otherwise
631 */
632
633static int dirent_next(struct gfs2_inode *dip, struct buffer_head *bh,
634 struct gfs2_dirent **dent)
635{
2bdbc5d7
SW
636 struct gfs2_dirent *cur = *dent, *tmp;
637 char *bh_end = bh->b_data + bh->b_size;
638 int ret;
b3b94faa 639
2bdbc5d7
SW
640 ret = dirent_check_reclen(dip, cur, bh_end);
641 if (ret < 0)
642 return ret;
4dd651ad 643
2bdbc5d7
SW
644 tmp = (void *)cur + ret;
645 ret = dirent_check_reclen(dip, tmp, bh_end);
646 if (ret == -EIO)
647 return ret;
4dd651ad 648
b3b94faa 649 /* Only the first dent could ever have de_inum.no_addr == 0 */
5e7d65cd 650 if (gfs2_dirent_sentinel(tmp)) {
b3b94faa
DT
651 gfs2_consist_inode(dip);
652 return -EIO;
653 }
654
655 *dent = tmp;
b3b94faa
DT
656 return 0;
657}
658
659/**
660 * dirent_del - Delete a dirent
661 * @dip: The GFS2 inode
662 * @bh: The buffer
663 * @prev: The previous dirent
664 * @cur: The current dirent
665 *
666 */
667
668static void dirent_del(struct gfs2_inode *dip, struct buffer_head *bh,
669 struct gfs2_dirent *prev, struct gfs2_dirent *cur)
670{
cd915493 671 u16 cur_rec_len, prev_rec_len;
b3b94faa 672
5e7d65cd 673 if (gfs2_dirent_sentinel(cur)) {
b3b94faa
DT
674 gfs2_consist_inode(dip);
675 return;
676 }
677
350a9b0a 678 gfs2_trans_add_meta(dip->i_gl, bh);
b3b94faa
DT
679
680 /* If there is no prev entry, this is the first entry in the block.
681 The de_rec_len is already as big as it needs to be. Just zero
682 out the inode number and return. */
683
684 if (!prev) {
5e7d65cd
SW
685 cur->de_inum.no_addr = 0;
686 cur->de_inum.no_formal_ino = 0;
b3b94faa
DT
687 return;
688 }
689
690 /* Combine this dentry with the previous one. */
691
fc69d0d3
SW
692 prev_rec_len = be16_to_cpu(prev->de_rec_len);
693 cur_rec_len = be16_to_cpu(cur->de_rec_len);
b3b94faa
DT
694
695 if ((char *)prev + prev_rec_len != (char *)cur)
696 gfs2_consist_inode(dip);
697 if ((char *)cur + cur_rec_len > bh->b_data + bh->b_size)
698 gfs2_consist_inode(dip);
699
700 prev_rec_len += cur_rec_len;
fc69d0d3 701 prev->de_rec_len = cpu_to_be16(prev_rec_len);
b3b94faa
DT
702}
703
34017472
BM
704
705static struct gfs2_dirent *do_init_dirent(struct inode *inode,
706 struct gfs2_dirent *dent,
707 const struct qstr *name,
708 struct buffer_head *bh,
709 unsigned offset)
710{
711 struct gfs2_inode *ip = GFS2_I(inode);
712 struct gfs2_dirent *ndent;
713 unsigned totlen;
714
715 totlen = be16_to_cpu(dent->de_rec_len);
716 BUG_ON(offset + name->len > totlen);
717 gfs2_trans_add_meta(ip->i_gl, bh);
718 ndent = (struct gfs2_dirent *)((char *)dent + offset);
719 dent->de_rec_len = cpu_to_be16(offset);
720 gfs2_qstr2dirent(name, totlen - offset, ndent);
721 return ndent;
722}
723
724
c752666c
SW
725/*
726 * Takes a dent from which to grab space as an argument. Returns the
727 * newly created dent.
b3b94faa 728 */
08bc2dbc
AB
729static struct gfs2_dirent *gfs2_init_dirent(struct inode *inode,
730 struct gfs2_dirent *dent,
731 const struct qstr *name,
732 struct buffer_head *bh)
b3b94faa 733{
34017472 734 unsigned offset = 0;
c752666c 735
5e7d65cd 736 if (!gfs2_dirent_sentinel(dent))
c752666c 737 offset = GFS2_DIRENT_SIZE(be16_to_cpu(dent->de_name_len));
34017472 738 return do_init_dirent(inode, dent, name, bh, offset);
b3b94faa
DT
739}
740
34017472
BM
741static struct gfs2_dirent *gfs2_dirent_split_alloc(struct inode *inode,
742 struct buffer_head *bh,
743 const struct qstr *name,
744 void *ptr)
b3b94faa
DT
745{
746 struct gfs2_dirent *dent;
907b9bce 747 dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size,
34017472 748 gfs2_dirent_find_offset, name, ptr);
15a798f7 749 if (IS_ERR_OR_NULL(dent))
c752666c 750 return dent;
34017472
BM
751 return do_init_dirent(inode, dent, name, bh,
752 (unsigned)(ptr - (void *)dent));
b3b94faa
DT
753}
754
cd915493 755static int get_leaf(struct gfs2_inode *dip, u64 leaf_no,
b3b94faa
DT
756 struct buffer_head **bhp)
757{
758 int error;
759
c8d57703 760 error = gfs2_meta_read(dip->i_gl, leaf_no, DIO_WAIT, 0, bhp);
feaa7bba 761 if (!error && gfs2_metatype_check(GFS2_SB(&dip->i_inode), *bhp, GFS2_METATYPE_LF)) {
d77d1b58 762 /* pr_info("block num=%llu\n", leaf_no); */
b3b94faa 763 error = -EIO;
feaa7bba 764 }
b3b94faa
DT
765
766 return error;
767}
768
769/**
770 * get_leaf_nr - Get a leaf number associated with the index
771 * @dip: The GFS2 inode
3ae3a7d6
BP
772 * @index: hash table index of the targeted leaf
773 * @leaf_out: Resulting leaf block number
b3b94faa
DT
774 *
775 * Returns: 0 on success, error code otherwise
776 */
777
3ae3a7d6 778static int get_leaf_nr(struct gfs2_inode *dip, u32 index, u64 *leaf_out)
b3b94faa 779{
17d539f0 780 __be64 *hash;
287980e4 781 int error;
b3b94faa 782
17d539f0 783 hash = gfs2_dir_get_hash_table(dip);
287980e4
AB
784 error = PTR_ERR_OR_ZERO(hash);
785
786 if (!error)
787 *leaf_out = be64_to_cpu(*(hash + index));
788
789 return error;
b3b94faa
DT
790}
791
cd915493 792static int get_first_leaf(struct gfs2_inode *dip, u32 index,
b3b94faa
DT
793 struct buffer_head **bh_out)
794{
cd915493 795 u64 leaf_no;
b3b94faa
DT
796 int error;
797
798 error = get_leaf_nr(dip, index, &leaf_no);
287980e4 799 if (!error)
b3b94faa
DT
800 error = get_leaf(dip, leaf_no, bh_out);
801
802 return error;
803}
804
c752666c
SW
805static struct gfs2_dirent *gfs2_dirent_search(struct inode *inode,
806 const struct qstr *name,
807 gfs2_dscan_t scan,
808 struct buffer_head **pbh)
b3b94faa 809{
c752666c
SW
810 struct buffer_head *bh;
811 struct gfs2_dirent *dent;
feaa7bba 812 struct gfs2_inode *ip = GFS2_I(inode);
b3b94faa
DT
813 int error;
814
383f01fb 815 if (ip->i_diskflags & GFS2_DIF_EXHASH) {
c752666c 816 struct gfs2_leaf *leaf;
47a9a527
FF
817 unsigned int hsize = BIT(ip->i_depth);
818 unsigned int index;
c752666c 819 u64 ln;
a2e0f799 820 if (hsize * sizeof(u64) != i_size_read(inode)) {
c752666c
SW
821 gfs2_consist_inode(ip);
822 return ERR_PTR(-EIO);
823 }
907b9bce 824
9a004508 825 index = name->hash >> (32 - ip->i_depth);
c752666c
SW
826 error = get_first_leaf(ip, index, &bh);
827 if (error)
828 return ERR_PTR(error);
829 do {
830 dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size,
71b86f56 831 scan, name, NULL);
c752666c
SW
832 if (dent)
833 goto got_dent;
834 leaf = (struct gfs2_leaf *)bh->b_data;
835 ln = be64_to_cpu(leaf->lf_next);
f4154ea0 836 brelse(bh);
c752666c
SW
837 if (!ln)
838 break;
907b9bce 839
c752666c
SW
840 error = get_leaf(ip, ln, &bh);
841 } while(!error);
b3b94faa 842
c752666c 843 return error ? ERR_PTR(error) : NULL;
b3b94faa 844 }
b3b94faa 845
907b9bce 846
c752666c
SW
847 error = gfs2_meta_inode_buffer(ip, &bh);
848 if (error)
849 return ERR_PTR(error);
71b86f56 850 dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size, scan, name, NULL);
c752666c 851got_dent:
15a798f7 852 if (IS_ERR_OR_NULL(dent)) {
ed386507
SW
853 brelse(bh);
854 bh = NULL;
855 }
c752666c
SW
856 *pbh = bh;
857 return dent;
858}
b3b94faa 859
c752666c
SW
860static struct gfs2_leaf *new_leaf(struct inode *inode, struct buffer_head **pbh, u16 depth)
861{
feaa7bba 862 struct gfs2_inode *ip = GFS2_I(inode);
b45e41d7 863 unsigned int n = 1;
09010978
SW
864 u64 bn;
865 int error;
866 struct buffer_head *bh;
c752666c
SW
867 struct gfs2_leaf *leaf;
868 struct gfs2_dirent *dent;
95582b00 869 struct timespec64 tv = current_time(inode);
09010978 870
6e87ed0f 871 error = gfs2_alloc_blocks(ip, &bn, &n, 0, NULL);
09010978
SW
872 if (error)
873 return NULL;
874 bh = gfs2_meta_new(ip->i_gl, bn);
c752666c
SW
875 if (!bh)
876 return NULL;
09010978 877
fbb27873 878 gfs2_trans_remove_revoke(GFS2_SB(inode), bn, 1);
350a9b0a 879 gfs2_trans_add_meta(ip->i_gl, bh);
c752666c
SW
880 gfs2_metatype_set(bh, GFS2_METATYPE_LF, GFS2_FORMAT_LF);
881 leaf = (struct gfs2_leaf *)bh->b_data;
882 leaf->lf_depth = cpu_to_be16(depth);
2bdbc5d7 883 leaf->lf_entries = 0;
a2d7d021 884 leaf->lf_dirent_format = cpu_to_be32(GFS2_FORMAT_DE);
2bdbc5d7 885 leaf->lf_next = 0;
01bcb0de
SW
886 leaf->lf_inode = cpu_to_be64(ip->i_no_addr);
887 leaf->lf_dist = cpu_to_be32(1);
888 leaf->lf_nsec = cpu_to_be32(tv.tv_nsec);
889 leaf->lf_sec = cpu_to_be64(tv.tv_sec);
890 memset(leaf->lf_reserved2, 0, sizeof(leaf->lf_reserved2));
c752666c 891 dent = (struct gfs2_dirent *)(leaf+1);
cdf01226 892 gfs2_qstr2dirent(&empty_name, bh->b_size - sizeof(struct gfs2_leaf), dent);
c752666c
SW
893 *pbh = bh;
894 return leaf;
b3b94faa
DT
895}
896
897/**
898 * dir_make_exhash - Convert a stuffed directory into an ExHash directory
3ae3a7d6 899 * @inode: The directory inode to be converted to exhash
b3b94faa
DT
900 *
901 * Returns: 0 on success, error code otherwise
902 */
903
c752666c 904static int dir_make_exhash(struct inode *inode)
b3b94faa 905{
feaa7bba
SW
906 struct gfs2_inode *dip = GFS2_I(inode);
907 struct gfs2_sbd *sdp = GFS2_SB(inode);
b3b94faa 908 struct gfs2_dirent *dent;
c752666c 909 struct qstr args;
b3b94faa
DT
910 struct buffer_head *bh, *dibh;
911 struct gfs2_leaf *leaf;
912 int y;
cd915493 913 u32 x;
b44b84d7
AV
914 __be64 *lp;
915 u64 bn;
b3b94faa
DT
916 int error;
917
918 error = gfs2_meta_inode_buffer(dip, &dibh);
919 if (error)
920 return error;
921
b3b94faa
DT
922 /* Turn over a new leaf */
923
c752666c
SW
924 leaf = new_leaf(inode, &bh, 0);
925 if (!leaf)
926 return -ENOSPC;
927 bn = bh->b_blocknr;
b3b94faa 928
47a9a527 929 gfs2_assert(sdp, dip->i_entries < BIT(16));
ad6203f2 930 leaf->lf_entries = cpu_to_be16(dip->i_entries);
b3b94faa
DT
931
932 /* Copy dirents */
933
934 gfs2_buffer_copy_tail(bh, sizeof(struct gfs2_leaf), dibh,
935 sizeof(struct gfs2_dinode));
936
937 /* Find last entry */
938
939 x = 0;
c752666c
SW
940 args.len = bh->b_size - sizeof(struct gfs2_dinode) +
941 sizeof(struct gfs2_leaf);
942 args.name = bh->b_data;
feaa7bba 943 dent = gfs2_dirent_scan(&dip->i_inode, bh->b_data, bh->b_size,
71b86f56 944 gfs2_dirent_last, &args, NULL);
c752666c
SW
945 if (!dent) {
946 brelse(bh);
947 brelse(dibh);
948 return -EIO;
949 }
950 if (IS_ERR(dent)) {
951 brelse(bh);
952 brelse(dibh);
953 return PTR_ERR(dent);
b3b94faa 954 }
b3b94faa
DT
955
956 /* Adjust the last dirent's record length
957 (Remember that dent still points to the last entry.) */
958
4dd651ad 959 dent->de_rec_len = cpu_to_be16(be16_to_cpu(dent->de_rec_len) +
b3b94faa 960 sizeof(struct gfs2_dinode) -
4dd651ad 961 sizeof(struct gfs2_leaf));
b3b94faa
DT
962
963 brelse(bh);
964
965 /* We're done with the new leaf block, now setup the new
966 hash table. */
967
350a9b0a 968 gfs2_trans_add_meta(dip->i_gl, dibh);
b3b94faa
DT
969 gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));
970
b44b84d7 971 lp = (__be64 *)(dibh->b_data + sizeof(struct gfs2_dinode));
b3b94faa
DT
972
973 for (x = sdp->sd_hash_ptrs; x--; lp++)
974 *lp = cpu_to_be64(bn);
975
a2e0f799 976 i_size_write(inode, sdp->sd_sb.sb_bsize / 2);
77658aad 977 gfs2_add_inode_blocks(&dip->i_inode, 1);
383f01fb 978 dip->i_diskflags |= GFS2_DIF_EXHASH;
b3b94faa
DT
979
980 for (x = sdp->sd_hash_ptrs, y = -1; x; x >>= 1, y++) ;
9a004508 981 dip->i_depth = y;
b3b94faa 982
539e5d6b 983 gfs2_dinode_out(dip, dibh->b_data);
b3b94faa
DT
984
985 brelse(dibh);
986
987 return 0;
988}
989
990/**
991 * dir_split_leaf - Split a leaf block into two
3ae3a7d6
BP
992 * @inode: The directory inode to be split
993 * @name: name of the dirent we're trying to insert
b3b94faa
DT
994 *
995 * Returns: 0 on success, error code on failure
996 */
997
c752666c 998static int dir_split_leaf(struct inode *inode, const struct qstr *name)
b3b94faa 999{
feaa7bba 1000 struct gfs2_inode *dip = GFS2_I(inode);
b3b94faa
DT
1001 struct buffer_head *nbh, *obh, *dibh;
1002 struct gfs2_leaf *nleaf, *oleaf;
4da3c646 1003 struct gfs2_dirent *dent = NULL, *prev = NULL, *next = NULL, *new;
cd915493 1004 u32 start, len, half_len, divider;
b44b84d7
AV
1005 u64 bn, leaf_no;
1006 __be64 *lp;
cd915493 1007 u32 index;
d1b0cb93 1008 int x;
b3b94faa
DT
1009 int error;
1010
9a004508 1011 index = name->hash >> (32 - dip->i_depth);
c752666c 1012 error = get_leaf_nr(dip, index, &leaf_no);
287980e4 1013 if (error)
c752666c 1014 return error;
b3b94faa
DT
1015
1016 /* Get the old leaf block */
b3b94faa
DT
1017 error = get_leaf(dip, leaf_no, &obh);
1018 if (error)
e90deff5 1019 return error;
b3b94faa 1020
b3b94faa 1021 oleaf = (struct gfs2_leaf *)obh->b_data;
9a004508 1022 if (dip->i_depth == be16_to_cpu(oleaf->lf_depth)) {
e90deff5
SW
1023 brelse(obh);
1024 return 1; /* can't split */
1025 }
1026
350a9b0a 1027 gfs2_trans_add_meta(dip->i_gl, obh);
b3b94faa 1028
c752666c
SW
1029 nleaf = new_leaf(inode, &nbh, be16_to_cpu(oleaf->lf_depth) + 1);
1030 if (!nleaf) {
1031 brelse(obh);
1032 return -ENOSPC;
1033 }
1034 bn = nbh->b_blocknr;
b3b94faa 1035
c752666c 1036 /* Compute the start and len of leaf pointers in the hash table. */
47a9a527 1037 len = BIT(dip->i_depth - be16_to_cpu(oleaf->lf_depth));
b3b94faa
DT
1038 half_len = len >> 1;
1039 if (!half_len) {
e54c78a2 1040 fs_warn(GFS2_SB(inode), "i_depth %u lf_depth %u index %u\n",
d77d1b58 1041 dip->i_depth, be16_to_cpu(oleaf->lf_depth), index);
b3b94faa
DT
1042 gfs2_consist_inode(dip);
1043 error = -EIO;
1044 goto fail_brelse;
1045 }
1046
1047 start = (index & ~(len - 1));
1048
1049 /* Change the pointers.
1050 Don't bother distinguishing stuffed from non-stuffed.
1051 This code is complicated enough already. */
6da2ec56 1052 lp = kmalloc_array(half_len, sizeof(__be64), GFP_NOFS);
4244b52e
DR
1053 if (!lp) {
1054 error = -ENOMEM;
1055 goto fail_brelse;
1056 }
1057
b3b94faa 1058 /* Change the pointers */
b3b94faa
DT
1059 for (x = 0; x < half_len; x++)
1060 lp[x] = cpu_to_be64(bn);
1061
17d539f0
SW
1062 gfs2_dir_hash_inval(dip);
1063
cd915493
SW
1064 error = gfs2_dir_write_data(dip, (char *)lp, start * sizeof(u64),
1065 half_len * sizeof(u64));
1066 if (error != half_len * sizeof(u64)) {
b3b94faa
DT
1067 if (error >= 0)
1068 error = -EIO;
1069 goto fail_lpfree;
1070 }
1071
1072 kfree(lp);
1073
1074 /* Compute the divider */
9a004508 1075 divider = (start + half_len) << (32 - dip->i_depth);
b3b94faa
DT
1076
1077 /* Copy the entries */
1579343a 1078 dent = (struct gfs2_dirent *)(obh->b_data + sizeof(struct gfs2_leaf));
b3b94faa
DT
1079
1080 do {
1081 next = dent;
1082 if (dirent_next(dip, obh, &next))
1083 next = NULL;
1084
5e7d65cd 1085 if (!gfs2_dirent_sentinel(dent) &&
b3b94faa 1086 be32_to_cpu(dent->de_hash) < divider) {
c752666c 1087 struct qstr str;
34017472 1088 void *ptr = ((char *)dent - obh->b_data) + nbh->b_data;
c752666c
SW
1089 str.name = (char*)(dent+1);
1090 str.len = be16_to_cpu(dent->de_name_len);
1091 str.hash = be32_to_cpu(dent->de_hash);
34017472 1092 new = gfs2_dirent_split_alloc(inode, nbh, &str, ptr);
c752666c
SW
1093 if (IS_ERR(new)) {
1094 error = PTR_ERR(new);
1095 break;
1096 }
b3b94faa
DT
1097
1098 new->de_inum = dent->de_inum; /* No endian worries */
b3b94faa 1099 new->de_type = dent->de_type; /* No endian worries */
bb16b342 1100 be16_add_cpu(&nleaf->lf_entries, 1);
b3b94faa
DT
1101
1102 dirent_del(dip, obh, prev, dent);
1103
1104 if (!oleaf->lf_entries)
1105 gfs2_consist_inode(dip);
bb16b342 1106 be16_add_cpu(&oleaf->lf_entries, -1);
b3b94faa
DT
1107
1108 if (!prev)
1109 prev = dent;
c752666c 1110 } else {
b3b94faa 1111 prev = dent;
c752666c 1112 }
b3b94faa 1113 dent = next;
c752666c 1114 } while (dent);
b3b94faa 1115
c752666c 1116 oleaf->lf_depth = nleaf->lf_depth;
b3b94faa
DT
1117
1118 error = gfs2_meta_inode_buffer(dip, &dibh);
feaa7bba 1119 if (!gfs2_assert_withdraw(GFS2_SB(&dip->i_inode), !error)) {
350a9b0a 1120 gfs2_trans_add_meta(dip->i_gl, dibh);
77658aad 1121 gfs2_add_inode_blocks(&dip->i_inode, 1);
539e5d6b 1122 gfs2_dinode_out(dip, dibh->b_data);
b3b94faa
DT
1123 brelse(dibh);
1124 }
1125
1126 brelse(obh);
1127 brelse(nbh);
1128
1129 return error;
1130
e90deff5 1131fail_lpfree:
b3b94faa
DT
1132 kfree(lp);
1133
e90deff5 1134fail_brelse:
b3b94faa 1135 brelse(obh);
b3b94faa
DT
1136 brelse(nbh);
1137 return error;
1138}
1139
1140/**
1141 * dir_double_exhash - Double size of ExHash table
1142 * @dip: The GFS2 dinode
1143 *
1144 * Returns: 0 on success, error code on failure
1145 */
1146
1147static int dir_double_exhash(struct gfs2_inode *dip)
1148{
b3b94faa 1149 struct buffer_head *dibh;
cd915493 1150 u32 hsize;
17d539f0
SW
1151 u32 hsize_bytes;
1152 __be64 *hc;
1153 __be64 *hc2, *h;
b3b94faa
DT
1154 int x;
1155 int error = 0;
1156
47a9a527 1157 hsize = BIT(dip->i_depth);
17d539f0 1158 hsize_bytes = hsize * sizeof(__be64);
b3b94faa 1159
17d539f0
SW
1160 hc = gfs2_dir_get_hash_table(dip);
1161 if (IS_ERR(hc))
1162 return PTR_ERR(hc);
b3b94faa 1163
6da2ec56 1164 hc2 = kmalloc_array(hsize_bytes, 2, GFP_NOFS | __GFP_NOWARN);
e8830d88 1165 if (hc2 == NULL)
88dca4ca 1166 hc2 = __vmalloc(hsize_bytes * 2, GFP_NOFS);
e8830d88 1167
17d539f0 1168 if (!hc2)
4244b52e 1169 return -ENOMEM;
b3b94faa 1170
512cbf02 1171 h = hc2;
17d539f0
SW
1172 error = gfs2_meta_inode_buffer(dip, &dibh);
1173 if (error)
1174 goto out_kfree;
b3b94faa 1175
17d539f0
SW
1176 for (x = 0; x < hsize; x++) {
1177 *h++ = *hc;
1178 *h++ = *hc;
1179 hc++;
b3b94faa
DT
1180 }
1181
17d539f0
SW
1182 error = gfs2_dir_write_data(dip, (char *)hc2, 0, hsize_bytes * 2);
1183 if (error != (hsize_bytes * 2))
1184 goto fail;
b3b94faa 1185
17d539f0
SW
1186 gfs2_dir_hash_inval(dip);
1187 dip->i_hash_cache = hc2;
1188 dip->i_depth++;
1189 gfs2_dinode_out(dip, dibh->b_data);
1190 brelse(dibh);
1191 return 0;
b3b94faa 1192
a91ea69f 1193fail:
17d539f0
SW
1194 /* Replace original hash table & size */
1195 gfs2_dir_write_data(dip, (char *)hc, 0, hsize_bytes);
1196 i_size_write(&dip->i_inode, hsize_bytes);
1197 gfs2_dinode_out(dip, dibh->b_data);
1198 brelse(dibh);
1199out_kfree:
3cdcf63e 1200 kvfree(hc2);
b3b94faa
DT
1201 return error;
1202}
1203
1204/**
1205 * compare_dents - compare directory entries by hash value
1206 * @a: first dent
1207 * @b: second dent
1208 *
1209 * When comparing the hash entries of @a to @b:
1210 * gt: returns 1
1211 * lt: returns -1
1212 * eq: returns 0
1213 */
1214
1215static int compare_dents(const void *a, const void *b)
1216{
2bdbc5d7 1217 const struct gfs2_dirent *dent_a, *dent_b;
cd915493 1218 u32 hash_a, hash_b;
b3b94faa
DT
1219 int ret = 0;
1220
2bdbc5d7 1221 dent_a = *(const struct gfs2_dirent **)a;
471f3db2 1222 hash_a = dent_a->de_cookie;
b3b94faa 1223
2bdbc5d7 1224 dent_b = *(const struct gfs2_dirent **)b;
471f3db2 1225 hash_b = dent_b->de_cookie;
b3b94faa
DT
1226
1227 if (hash_a > hash_b)
1228 ret = 1;
1229 else if (hash_a < hash_b)
1230 ret = -1;
1231 else {
4dd651ad
SW
1232 unsigned int len_a = be16_to_cpu(dent_a->de_name_len);
1233 unsigned int len_b = be16_to_cpu(dent_b->de_name_len);
b3b94faa
DT
1234
1235 if (len_a > len_b)
1236 ret = 1;
1237 else if (len_a < len_b)
1238 ret = -1;
1239 else
2bdbc5d7 1240 ret = memcmp(dent_a + 1, dent_b + 1, len_a);
b3b94faa
DT
1241 }
1242
1243 return ret;
1244}
1245
1246/**
1247 * do_filldir_main - read out directory entries
1248 * @dip: The GFS2 inode
d81a8ef5 1249 * @ctx: what to feed the entries to
b3b94faa
DT
1250 * @darr: an array of struct gfs2_dirent pointers to read
1251 * @entries: the number of entries in darr
3ae3a7d6 1252 * @sort_start: index of the directory array to start our sort
b3b94faa
DT
1253 * @copied: pointer to int that's non-zero if a entry has been copied out
1254 *
1255 * Jump through some hoops to make sure that if there are hash collsions,
1256 * they are read out at the beginning of a buffer. We want to minimize
1257 * the possibility that they will fall into different readdir buffers or
1258 * that someone will want to seek to that location.
1259 *
d81a8ef5 1260 * Returns: errno, >0 if the actor tells you to stop
b3b94faa
DT
1261 */
1262
d81a8ef5 1263static int do_filldir_main(struct gfs2_inode *dip, struct dir_context *ctx,
471f3db2
BM
1264 struct gfs2_dirent **darr, u32 entries,
1265 u32 sort_start, int *copied)
b3b94faa 1266{
71b86f56 1267 const struct gfs2_dirent *dent, *dent_next;
cd915493 1268 u64 off, off_next;
b3b94faa
DT
1269 unsigned int x, y;
1270 int run = 0;
b3b94faa 1271
471f3db2
BM
1272 if (sort_start < entries)
1273 sort(&darr[sort_start], entries - sort_start,
1274 sizeof(struct gfs2_dirent *), compare_dents, NULL);
b3b94faa
DT
1275
1276 dent_next = darr[0];
471f3db2 1277 off_next = dent_next->de_cookie;
b3b94faa
DT
1278
1279 for (x = 0, y = 1; x < entries; x++, y++) {
1280 dent = dent_next;
1281 off = off_next;
1282
1283 if (y < entries) {
1284 dent_next = darr[y];
471f3db2 1285 off_next = dent_next->de_cookie;
b3b94faa 1286
d81a8ef5 1287 if (off < ctx->pos)
b3b94faa 1288 continue;
d81a8ef5 1289 ctx->pos = off;
b3b94faa
DT
1290
1291 if (off_next == off) {
1292 if (*copied && !run)
1293 return 1;
1294 run = 1;
1295 } else
1296 run = 0;
1297 } else {
d81a8ef5 1298 if (off < ctx->pos)
b3b94faa 1299 continue;
d81a8ef5 1300 ctx->pos = off;
b3b94faa
DT
1301 }
1302
d81a8ef5 1303 if (!dir_emit(ctx, (const char *)(dent + 1),
4dd651ad 1304 be16_to_cpu(dent->de_name_len),
d81a8ef5
AV
1305 be64_to_cpu(dent->de_inum.no_addr),
1306 be16_to_cpu(dent->de_type)))
b3b94faa
DT
1307 return 1;
1308
1309 *copied = 1;
1310 }
1311
d81a8ef5 1312 /* Increment the ctx->pos by one, so the next time we come into the
b3b94faa
DT
1313 do_filldir fxn, we get the next entry instead of the last one in the
1314 current leaf */
1315
d81a8ef5 1316 ctx->pos++;
b3b94faa
DT
1317
1318 return 0;
1319}
1320
d2a97a4e
SW
1321static void *gfs2_alloc_sort_buffer(unsigned size)
1322{
1323 void *ptr = NULL;
1324
1325 if (size < KMALLOC_MAX_SIZE)
1326 ptr = kmalloc(size, GFP_NOFS | __GFP_NOWARN);
1327 if (!ptr)
88dca4ca 1328 ptr = __vmalloc(size, GFP_NOFS);
d2a97a4e
SW
1329 return ptr;
1330}
1331
471f3db2
BM
1332
1333static int gfs2_set_cookies(struct gfs2_sbd *sdp, struct buffer_head *bh,
1334 unsigned leaf_nr, struct gfs2_dirent **darr,
1335 unsigned entries)
1336{
1337 int sort_id = -1;
1338 int i;
1339
1340 for (i = 0; i < entries; i++) {
1341 unsigned offset;
1342
1343 darr[i]->de_cookie = be32_to_cpu(darr[i]->de_hash);
1344 darr[i]->de_cookie = gfs2_disk_hash2offset(darr[i]->de_cookie);
1345
1346 if (!sdp->sd_args.ar_loccookie)
1347 continue;
1348 offset = (char *)(darr[i]) -
e54c78a2 1349 (bh->b_data + gfs2_dirent_offset(sdp, bh->b_data));
471f3db2
BM
1350 offset /= GFS2_MIN_DIRENT_SIZE;
1351 offset += leaf_nr * sdp->sd_max_dents_per_leaf;
1352 if (offset >= GFS2_USE_HASH_FLAG ||
1353 leaf_nr >= GFS2_USE_HASH_FLAG) {
1354 darr[i]->de_cookie |= GFS2_USE_HASH_FLAG;
1355 if (sort_id < 0)
1356 sort_id = i;
1357 continue;
1358 }
1359 darr[i]->de_cookie &= GFS2_HASH_INDEX_MASK;
1360 darr[i]->de_cookie |= offset;
1361 }
1362 return sort_id;
1363}
1364
1365
d81a8ef5
AV
1366static int gfs2_dir_read_leaf(struct inode *inode, struct dir_context *ctx,
1367 int *copied, unsigned *depth,
3699e3a4 1368 u64 leaf_no)
b3b94faa 1369{
feaa7bba 1370 struct gfs2_inode *ip = GFS2_I(inode);
bdd19a22 1371 struct gfs2_sbd *sdp = GFS2_SB(inode);
71b86f56
SW
1372 struct buffer_head *bh;
1373 struct gfs2_leaf *lf;
bdd19a22 1374 unsigned entries = 0, entries2 = 0;
471f3db2
BM
1375 unsigned leaves = 0, leaf = 0, offset, sort_offset;
1376 struct gfs2_dirent **darr, *dent;
71b86f56
SW
1377 struct dirent_gather g;
1378 struct buffer_head **larr;
471f3db2 1379 int error, i, need_sort = 0, sort_id;
71b86f56 1380 u64 lfn = leaf_no;
b3b94faa 1381
b3b94faa 1382 do {
71b86f56 1383 error = get_leaf(ip, lfn, &bh);
b3b94faa 1384 if (error)
71b86f56
SW
1385 goto out;
1386 lf = (struct gfs2_leaf *)bh->b_data;
1387 if (leaves == 0)
1388 *depth = be16_to_cpu(lf->lf_depth);
1389 entries += be16_to_cpu(lf->lf_entries);
1390 leaves++;
1391 lfn = be64_to_cpu(lf->lf_next);
1392 brelse(bh);
1393 } while(lfn);
b3b94faa 1394
471f3db2
BM
1395 if (*depth < GFS2_DIR_MAX_DEPTH || !sdp->sd_args.ar_loccookie) {
1396 need_sort = 1;
1397 sort_offset = 0;
1398 }
1399
b3b94faa
DT
1400 if (!entries)
1401 return 0;
1402
71b86f56 1403 error = -ENOMEM;
bdd19a22
SW
1404 /*
1405 * The extra 99 entries are not normally used, but are a buffer
1406 * zone in case the number of entries in the leaf is corrupt.
1407 * 99 is the maximum number of entries that can fit in a single
1408 * leaf block.
1409 */
d2a97a4e 1410 larr = gfs2_alloc_sort_buffer((leaves + entries + 99) * sizeof(void *));
71b86f56
SW
1411 if (!larr)
1412 goto out;
471f3db2
BM
1413 darr = (struct gfs2_dirent **)(larr + leaves);
1414 g.pdent = (const struct gfs2_dirent **)darr;
71b86f56
SW
1415 g.offset = 0;
1416 lfn = leaf_no;
b3b94faa 1417
71b86f56
SW
1418 do {
1419 error = get_leaf(ip, lfn, &bh);
b3b94faa 1420 if (error)
d2a97a4e 1421 goto out_free;
71b86f56
SW
1422 lf = (struct gfs2_leaf *)bh->b_data;
1423 lfn = be64_to_cpu(lf->lf_next);
1424 if (lf->lf_entries) {
471f3db2 1425 offset = g.offset;
bdd19a22 1426 entries2 += be16_to_cpu(lf->lf_entries);
71b86f56
SW
1427 dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size,
1428 gfs2_dirent_gather, NULL, &g);
1429 error = PTR_ERR(dent);
bdd19a22 1430 if (IS_ERR(dent))
d2a97a4e 1431 goto out_free;
bdd19a22 1432 if (entries2 != g.offset) {
f391a4ea
AM
1433 fs_warn(sdp, "Number of entries corrupt in dir "
1434 "leaf %llu, entries2 (%u) != "
1435 "g.offset (%u)\n",
1436 (unsigned long long)bh->b_blocknr,
1437 entries2, g.offset);
d87d62b7 1438 gfs2_consist_inode(ip);
bdd19a22 1439 error = -EIO;
d2a97a4e 1440 goto out_free;
71b86f56
SW
1441 }
1442 error = 0;
471f3db2
BM
1443 sort_id = gfs2_set_cookies(sdp, bh, leaf, &darr[offset],
1444 be16_to_cpu(lf->lf_entries));
1445 if (!need_sort && sort_id >= 0) {
1446 need_sort = 1;
1447 sort_offset = offset + sort_id;
1448 }
71b86f56 1449 larr[leaf++] = bh;
b3b94faa 1450 } else {
471f3db2 1451 larr[leaf++] = NULL;
71b86f56 1452 brelse(bh);
b3b94faa 1453 }
71b86f56 1454 } while(lfn);
b3b94faa 1455
bdd19a22 1456 BUG_ON(entries2 != entries);
471f3db2
BM
1457 error = do_filldir_main(ip, ctx, darr, entries, need_sort ?
1458 sort_offset : entries, copied);
d2a97a4e 1459out_free:
71b86f56 1460 for(i = 0; i < leaf; i++)
bccaef90 1461 brelse(larr[i]);
3cdcf63e 1462 kvfree(larr);
71b86f56 1463out:
b3b94faa
DT
1464 return error;
1465}
1466
79c4c379
SW
1467/**
1468 * gfs2_dir_readahead - Issue read-ahead requests for leaf blocks.
3ae3a7d6
BP
1469 * @inode: the directory inode
1470 * @hsize: hash table size
1471 * @index: index into the hash table
1472 * @f_ra: read-ahead parameters
dfe4d34b
BP
1473 *
1474 * Note: we can't calculate each index like dir_e_read can because we don't
1475 * have the leaf, and therefore we don't have the depth, and therefore we
1476 * don't have the length. So we have to just read enough ahead to make up
79c4c379
SW
1477 * for the loss of information.
1478 */
dfe4d34b
BP
1479static void gfs2_dir_readahead(struct inode *inode, unsigned hsize, u32 index,
1480 struct file_ra_state *f_ra)
1481{
1482 struct gfs2_inode *ip = GFS2_I(inode);
1483 struct gfs2_glock *gl = ip->i_gl;
1484 struct buffer_head *bh;
1485 u64 blocknr = 0, last;
1486 unsigned count;
1487
1488 /* First check if we've already read-ahead for the whole range. */
79c4c379 1489 if (index + MAX_RA_BLOCKS < f_ra->start)
dfe4d34b
BP
1490 return;
1491
1492 f_ra->start = max((pgoff_t)index, f_ra->start);
1493 for (count = 0; count < MAX_RA_BLOCKS; count++) {
1494 if (f_ra->start >= hsize) /* if exceeded the hash table */
1495 break;
1496
1497 last = blocknr;
1498 blocknr = be64_to_cpu(ip->i_hash_cache[f_ra->start]);
1499 f_ra->start++;
1500 if (blocknr == last)
1501 continue;
1502
1503 bh = gfs2_getbuf(gl, blocknr, 1);
1504 if (trylock_buffer(bh)) {
1505 if (buffer_uptodate(bh)) {
1506 unlock_buffer(bh);
1507 brelse(bh);
1508 continue;
1509 }
1510 bh->b_end_io = end_buffer_read_sync;
e477b24b
CL
1511 submit_bh(REQ_OP_READ,
1512 REQ_RAHEAD | REQ_META | REQ_PRIO,
1513 bh);
dfe4d34b
BP
1514 continue;
1515 }
1516 brelse(bh);
1517 }
1518}
17d539f0 1519
b3b94faa 1520/**
c752666c 1521 * dir_e_read - Reads the entries from a directory into a filldir buffer
3ae3a7d6 1522 * @inode: the directory inode
d81a8ef5 1523 * @ctx: actor to feed the entries to
3ae3a7d6 1524 * @f_ra: read-ahead parameters
b3b94faa 1525 *
c752666c 1526 * Returns: errno
b3b94faa
DT
1527 */
1528
d81a8ef5
AV
1529static int dir_e_read(struct inode *inode, struct dir_context *ctx,
1530 struct file_ra_state *f_ra)
b3b94faa 1531{
feaa7bba 1532 struct gfs2_inode *dip = GFS2_I(inode);
cd915493 1533 u32 hsize, len = 0;
cd915493 1534 u32 hash, index;
b44b84d7 1535 __be64 *lp;
c752666c
SW
1536 int copied = 0;
1537 int error = 0;
4da3c646 1538 unsigned depth = 0;
b3b94faa 1539
47a9a527 1540 hsize = BIT(dip->i_depth);
d81a8ef5 1541 hash = gfs2_dir_offset2hash(ctx->pos);
9a004508 1542 index = hash >> (32 - dip->i_depth);
b3b94faa 1543
79c4c379 1544 if (dip->i_hash_cache == NULL)
dfe4d34b 1545 f_ra->start = 0;
17d539f0
SW
1546 lp = gfs2_dir_get_hash_table(dip);
1547 if (IS_ERR(lp))
1548 return PTR_ERR(lp);
b3b94faa 1549
dfe4d34b
BP
1550 gfs2_dir_readahead(inode, hsize, index, f_ra);
1551
b3b94faa 1552 while (index < hsize) {
d81a8ef5 1553 error = gfs2_dir_read_leaf(inode, ctx,
71b86f56 1554 &copied, &depth,
17d539f0 1555 be64_to_cpu(lp[index]));
b3b94faa 1556 if (error)
71b86f56 1557 break;
b3b94faa 1558
47a9a527 1559 len = BIT(dip->i_depth - depth);
b3b94faa
DT
1560 index = (index & ~(len - 1)) + len;
1561 }
1562
71b86f56
SW
1563 if (error > 0)
1564 error = 0;
b3b94faa
DT
1565 return error;
1566}
1567
d81a8ef5
AV
1568int gfs2_dir_read(struct inode *inode, struct dir_context *ctx,
1569 struct file_ra_state *f_ra)
b3b94faa 1570{
feaa7bba 1571 struct gfs2_inode *dip = GFS2_I(inode);
bdd19a22 1572 struct gfs2_sbd *sdp = GFS2_SB(inode);
71b86f56 1573 struct dirent_gather g;
471f3db2 1574 struct gfs2_dirent **darr, *dent;
b3b94faa
DT
1575 struct buffer_head *dibh;
1576 int copied = 0;
1577 int error;
1578
ad6203f2 1579 if (!dip->i_entries)
71b86f56
SW
1580 return 0;
1581
383f01fb 1582 if (dip->i_diskflags & GFS2_DIF_EXHASH)
d81a8ef5 1583 return dir_e_read(inode, ctx, f_ra);
71b86f56 1584
b3b94faa
DT
1585 if (!gfs2_is_stuffed(dip)) {
1586 gfs2_consist_inode(dip);
1587 return -EIO;
1588 }
1589
b3b94faa
DT
1590 error = gfs2_meta_inode_buffer(dip, &dibh);
1591 if (error)
1592 return error;
1593
71b86f56 1594 error = -ENOMEM;
bdd19a22 1595 /* 96 is max number of dirents which can be stuffed into an inode */
6da2ec56 1596 darr = kmalloc_array(96, sizeof(struct gfs2_dirent *), GFP_NOFS);
71b86f56 1597 if (darr) {
471f3db2 1598 g.pdent = (const struct gfs2_dirent **)darr;
71b86f56
SW
1599 g.offset = 0;
1600 dent = gfs2_dirent_scan(inode, dibh->b_data, dibh->b_size,
1601 gfs2_dirent_gather, NULL, &g);
1602 if (IS_ERR(dent)) {
1603 error = PTR_ERR(dent);
1604 goto out;
1605 }
ad6203f2 1606 if (dip->i_entries != g.offset) {
bdd19a22 1607 fs_warn(sdp, "Number of entries corrupt in dir %llu, "
ad6203f2 1608 "ip->i_entries (%u) != g.offset (%u)\n",
dbb7cae2 1609 (unsigned long long)dip->i_no_addr,
ad6203f2 1610 dip->i_entries,
bdd19a22 1611 g.offset);
d87d62b7 1612 gfs2_consist_inode(dip);
bdd19a22
SW
1613 error = -EIO;
1614 goto out;
1615 }
471f3db2 1616 gfs2_set_cookies(sdp, dibh, 0, darr, dip->i_entries);
d81a8ef5 1617 error = do_filldir_main(dip, ctx, darr,
471f3db2 1618 dip->i_entries, 0, &copied);
71b86f56
SW
1619out:
1620 kfree(darr);
1621 }
1622
b3b94faa
DT
1623 if (error > 0)
1624 error = 0;
1625
1626 brelse(dibh);
1627
1628 return error;
1629}
1630
b3b94faa
DT
1631/**
1632 * gfs2_dir_search - Search a directory
3ae3a7d6 1633 * @dir: The GFS2 directory inode
5a00f3cc
SW
1634 * @name: The name we are looking up
1635 * @fail_on_exist: Fail if the name exists rather than looking it up
b3b94faa
DT
1636 *
1637 * This routine searches a directory for a file or another directory.
1638 * Assumes a glock is held on dip.
1639 *
1640 * Returns: errno
1641 */
1642
5a00f3cc
SW
1643struct inode *gfs2_dir_search(struct inode *dir, const struct qstr *name,
1644 bool fail_on_exist)
b3b94faa 1645{
c752666c
SW
1646 struct buffer_head *bh;
1647 struct gfs2_dirent *dent;
5a00f3cc
SW
1648 u64 addr, formal_ino;
1649 u16 dtype;
dbb7cae2
SW
1650
1651 dent = gfs2_dirent_search(dir, name, gfs2_dirent_find, &bh);
1652 if (dent) {
c8d57703
AG
1653 struct inode *inode;
1654 u16 rahead;
1655
dbb7cae2 1656 if (IS_ERR(dent))
e231c2ee 1657 return ERR_CAST(dent);
5a00f3cc 1658 dtype = be16_to_cpu(dent->de_type);
c8d57703 1659 rahead = be16_to_cpu(dent->de_rahead);
5a00f3cc
SW
1660 addr = be64_to_cpu(dent->de_inum.no_addr);
1661 formal_ino = be64_to_cpu(dent->de_inum.no_formal_ino);
dbb7cae2 1662 brelse(bh);
5a00f3cc
SW
1663 if (fail_on_exist)
1664 return ERR_PTR(-EEXIST);
3ce37b2c
AG
1665 inode = gfs2_inode_lookup(dir->i_sb, dtype, addr, formal_ino,
1666 GFS2_BLKST_FREE /* ignore */);
c8d57703
AG
1667 if (!IS_ERR(inode))
1668 GFS2_I(inode)->i_rahead = rahead;
1669 return inode;
dbb7cae2
SW
1670 }
1671 return ERR_PTR(-ENOENT);
1672}
1673
1674int gfs2_dir_check(struct inode *dir, const struct qstr *name,
1675 const struct gfs2_inode *ip)
1676{
1677 struct buffer_head *bh;
1678 struct gfs2_dirent *dent;
1679 int ret = -ENOENT;
c752666c
SW
1680
1681 dent = gfs2_dirent_search(dir, name, gfs2_dirent_find, &bh);
1682 if (dent) {
1683 if (IS_ERR(dent))
1684 return PTR_ERR(dent);
dbb7cae2
SW
1685 if (ip) {
1686 if (be64_to_cpu(dent->de_inum.no_addr) != ip->i_no_addr)
1687 goto out;
1688 if (be64_to_cpu(dent->de_inum.no_formal_ino) !=
1689 ip->i_no_formal_ino)
1690 goto out;
1691 if (unlikely(IF2DT(ip->i_inode.i_mode) !=
1692 be16_to_cpu(dent->de_type))) {
1693 gfs2_consist_inode(GFS2_I(dir));
1694 ret = -EIO;
1695 goto out;
1696 }
1697 }
1698 ret = 0;
1699out:
c752666c 1700 brelse(bh);
c752666c 1701 }
dbb7cae2 1702 return ret;
c752666c
SW
1703}
1704
01bcb0de
SW
1705/**
1706 * dir_new_leaf - Add a new leaf onto hash chain
1707 * @inode: The directory
1708 * @name: The name we are adding
1709 *
1710 * This adds a new dir leaf onto an existing leaf when there is not
1711 * enough space to add a new dir entry. This is a last resort after
1712 * we've expanded the hash table to max size and also split existing
1713 * leaf blocks, so it will only occur for very large directories.
1714 *
1715 * The dist parameter is set to 1 for leaf blocks directly attached
1716 * to the hash table, 2 for one layer of indirection, 3 for two layers
1717 * etc. We are thus able to tell the difference between an old leaf
1718 * with dist set to zero (i.e. "don't know") and a new one where we
1719 * set this information for debug/fsck purposes.
1720 *
1721 * Returns: 0 on success, or -ve on error
1722 */
1723
c752666c
SW
1724static int dir_new_leaf(struct inode *inode, const struct qstr *name)
1725{
1726 struct buffer_head *bh, *obh;
feaa7bba 1727 struct gfs2_inode *ip = GFS2_I(inode);
c752666c 1728 struct gfs2_leaf *leaf, *oleaf;
01bcb0de 1729 u32 dist = 1;
b3b94faa 1730 int error;
c752666c
SW
1731 u32 index;
1732 u64 bn;
b3b94faa 1733
9a004508 1734 index = name->hash >> (32 - ip->i_depth);
c752666c
SW
1735 error = get_first_leaf(ip, index, &obh);
1736 if (error)
1737 return error;
1738 do {
01bcb0de 1739 dist++;
c752666c
SW
1740 oleaf = (struct gfs2_leaf *)obh->b_data;
1741 bn = be64_to_cpu(oleaf->lf_next);
1742 if (!bn)
1743 break;
1744 brelse(obh);
1745 error = get_leaf(ip, bn, &obh);
1746 if (error)
1747 return error;
1748 } while(1);
b3b94faa 1749
350a9b0a 1750 gfs2_trans_add_meta(ip->i_gl, obh);
c752666c
SW
1751
1752 leaf = new_leaf(inode, &bh, be16_to_cpu(oleaf->lf_depth));
1753 if (!leaf) {
1754 brelse(obh);
1755 return -ENOSPC;
1756 }
01bcb0de 1757 leaf->lf_dist = cpu_to_be32(dist);
4d8012b6 1758 oleaf->lf_next = cpu_to_be64(bh->b_blocknr);
c752666c
SW
1759 brelse(bh);
1760 brelse(obh);
1761
1762 error = gfs2_meta_inode_buffer(ip, &bh);
1763 if (error)
1764 return error;
350a9b0a 1765 gfs2_trans_add_meta(ip->i_gl, bh);
77658aad 1766 gfs2_add_inode_blocks(&ip->i_inode, 1);
539e5d6b 1767 gfs2_dinode_out(ip, bh->b_data);
c752666c
SW
1768 brelse(bh);
1769 return 0;
b3b94faa
DT
1770}
1771
44aaada9
SW
1772static u16 gfs2_inode_ra_len(const struct gfs2_inode *ip)
1773{
1774 u64 where = ip->i_no_addr + 1;
1775 if (ip->i_eattr == where)
1776 return 1;
1777 return 0;
1778}
1779
b3b94faa
DT
1780/**
1781 * gfs2_dir_add - Add new filename into directory
2b47dad8
SW
1782 * @inode: The directory inode
1783 * @name: The new name
1784 * @nip: The GFS2 inode to be linked in to the directory
1785 * @da: The directory addition info
1786 *
1787 * If the call to gfs2_diradd_alloc_required resulted in there being
1788 * no need to allocate any new directory blocks, then it will contain
1789 * a pointer to the directory entry and the bh in which it resides. We
1790 * can use that without having to repeat the search. If there was no
1791 * free space, then we must now create more space.
b3b94faa
DT
1792 *
1793 * Returns: 0 on success, error code on failure
1794 */
1795
c752666c 1796int gfs2_dir_add(struct inode *inode, const struct qstr *name,
2b47dad8 1797 const struct gfs2_inode *nip, struct gfs2_diradd *da)
b3b94faa 1798{
feaa7bba 1799 struct gfs2_inode *ip = GFS2_I(inode);
2b47dad8
SW
1800 struct buffer_head *bh = da->bh;
1801 struct gfs2_dirent *dent = da->dent;
95582b00 1802 struct timespec64 tv;
c752666c 1803 struct gfs2_leaf *leaf;
b3b94faa
DT
1804 int error;
1805
c752666c 1806 while(1) {
2b47dad8
SW
1807 if (da->bh == NULL) {
1808 dent = gfs2_dirent_search(inode, name,
1809 gfs2_dirent_find_space, &bh);
1810 }
c752666c
SW
1811 if (dent) {
1812 if (IS_ERR(dent))
1813 return PTR_ERR(dent);
1814 dent = gfs2_init_dirent(inode, dent, name, bh);
dbb7cae2 1815 gfs2_inum_out(nip, dent);
3d6ecb7d 1816 dent->de_type = cpu_to_be16(IF2DT(nip->i_inode.i_mode));
44aaada9 1817 dent->de_rahead = cpu_to_be16(gfs2_inode_ra_len(nip));
078cd827 1818 tv = current_time(&ip->i_inode);
383f01fb 1819 if (ip->i_diskflags & GFS2_DIF_EXHASH) {
c752666c 1820 leaf = (struct gfs2_leaf *)bh->b_data;
bb16b342 1821 be16_add_cpu(&leaf->lf_entries, 1);
01bcb0de
SW
1822 leaf->lf_nsec = cpu_to_be32(tv.tv_nsec);
1823 leaf->lf_sec = cpu_to_be64(tv.tv_sec);
c752666c 1824 }
2b47dad8
SW
1825 da->dent = NULL;
1826 da->bh = NULL;
c752666c 1827 brelse(bh);
ad6203f2 1828 ip->i_entries++;
01bcb0de 1829 ip->i_inode.i_mtime = ip->i_inode.i_ctime = tv;
3d6ecb7d
SW
1830 if (S_ISDIR(nip->i_inode.i_mode))
1831 inc_nlink(&ip->i_inode);
343cd8f0 1832 mark_inode_dirty(inode);
c752666c
SW
1833 error = 0;
1834 break;
1835 }
383f01fb 1836 if (!(ip->i_diskflags & GFS2_DIF_EXHASH)) {
c752666c
SW
1837 error = dir_make_exhash(inode);
1838 if (error)
1839 break;
1840 continue;
1841 }
1842 error = dir_split_leaf(inode, name);
1843 if (error == 0)
1844 continue;
e90deff5 1845 if (error < 0)
c752666c 1846 break;
9a004508 1847 if (ip->i_depth < GFS2_DIR_MAX_DEPTH) {
c752666c
SW
1848 error = dir_double_exhash(ip);
1849 if (error)
1850 break;
1851 error = dir_split_leaf(inode, name);
e90deff5 1852 if (error < 0)
c752666c 1853 break;
e90deff5
SW
1854 if (error == 0)
1855 continue;
c752666c
SW
1856 }
1857 error = dir_new_leaf(inode, name);
1858 if (!error)
1859 continue;
1860 error = -ENOSPC;
1861 break;
1862 }
b3b94faa
DT
1863 return error;
1864}
1865
c752666c 1866
b3b94faa
DT
1867/**
1868 * gfs2_dir_del - Delete a directory entry
1869 * @dip: The GFS2 inode
3ae3a7d6 1870 * @dentry: The directory entry we want to delete
b3b94faa
DT
1871 *
1872 * Returns: 0 on success, error code on failure
1873 */
1874
855d23ce 1875int gfs2_dir_del(struct gfs2_inode *dip, const struct dentry *dentry)
b3b94faa 1876{
855d23ce 1877 const struct qstr *name = &dentry->d_name;
c752666c
SW
1878 struct gfs2_dirent *dent, *prev = NULL;
1879 struct buffer_head *bh;
95582b00 1880 struct timespec64 tv = current_time(&dip->i_inode);
b3b94faa 1881
c752666c
SW
1882 /* Returns _either_ the entry (if its first in block) or the
1883 previous entry otherwise */
feaa7bba 1884 dent = gfs2_dirent_search(&dip->i_inode, name, gfs2_dirent_prev, &bh);
c752666c
SW
1885 if (!dent) {
1886 gfs2_consist_inode(dip);
1887 return -EIO;
1888 }
1889 if (IS_ERR(dent)) {
1890 gfs2_consist_inode(dip);
1891 return PTR_ERR(dent);
1892 }
1893 /* If not first in block, adjust pointers accordingly */
71b86f56 1894 if (gfs2_dirent_find(dent, name, NULL) == 0) {
c752666c
SW
1895 prev = dent;
1896 dent = (struct gfs2_dirent *)((char *)dent + be16_to_cpu(prev->de_rec_len));
1897 }
1898
1899 dirent_del(dip, bh, prev, dent);
383f01fb 1900 if (dip->i_diskflags & GFS2_DIF_EXHASH) {
c752666c
SW
1901 struct gfs2_leaf *leaf = (struct gfs2_leaf *)bh->b_data;
1902 u16 entries = be16_to_cpu(leaf->lf_entries);
1903 if (!entries)
1904 gfs2_consist_inode(dip);
1905 leaf->lf_entries = cpu_to_be16(--entries);
01bcb0de
SW
1906 leaf->lf_nsec = cpu_to_be32(tv.tv_nsec);
1907 leaf->lf_sec = cpu_to_be64(tv.tv_sec);
c752666c 1908 }
ed386507 1909 brelse(bh);
c752666c 1910
ad6203f2 1911 if (!dip->i_entries)
c752666c 1912 gfs2_consist_inode(dip);
ad6203f2 1913 dip->i_entries--;
01bcb0de 1914 dip->i_inode.i_mtime = dip->i_inode.i_ctime = tv;
e36cb0b8 1915 if (d_is_dir(dentry))
855d23ce 1916 drop_nlink(&dip->i_inode);
feaa7bba 1917 mark_inode_dirty(&dip->i_inode);
b3b94faa 1918
ab9bbda0 1919 return 0;
b3b94faa
DT
1920}
1921
b3b94faa
DT
1922/**
1923 * gfs2_dir_mvino - Change inode number of directory entry
3ae3a7d6
BP
1924 * @dip: The GFS2 directory inode
1925 * @filename: the filename to be moved
1926 * @nip: the new GFS2 inode
1927 * @new_type: the de_type of the new dirent
b3b94faa
DT
1928 *
1929 * This routine changes the inode number of a directory entry. It's used
1930 * by rename to change ".." when a directory is moved.
1931 * Assumes a glock is held on dvp.
1932 *
1933 * Returns: errno
1934 */
1935
c752666c 1936int gfs2_dir_mvino(struct gfs2_inode *dip, const struct qstr *filename,
dbb7cae2 1937 const struct gfs2_inode *nip, unsigned int new_type)
b3b94faa 1938{
c752666c
SW
1939 struct buffer_head *bh;
1940 struct gfs2_dirent *dent;
b3b94faa 1941
feaa7bba 1942 dent = gfs2_dirent_search(&dip->i_inode, filename, gfs2_dirent_find, &bh);
c752666c
SW
1943 if (!dent) {
1944 gfs2_consist_inode(dip);
1945 return -EIO;
1946 }
1947 if (IS_ERR(dent))
1948 return PTR_ERR(dent);
b3b94faa 1949
350a9b0a 1950 gfs2_trans_add_meta(dip->i_gl, bh);
dbb7cae2 1951 gfs2_inum_out(nip, dent);
c752666c 1952 dent->de_type = cpu_to_be16(new_type);
83998ccd 1953 brelse(bh);
c752666c 1954
078cd827 1955 dip->i_inode.i_mtime = dip->i_inode.i_ctime = current_time(&dip->i_inode);
83998ccd 1956 mark_inode_dirty_sync(&dip->i_inode);
c752666c 1957 return 0;
b3b94faa
DT
1958}
1959
b3b94faa
DT
1960/**
1961 * leaf_dealloc - Deallocate a directory leaf
1962 * @dip: the directory
1963 * @index: the hash table offset in the directory
1964 * @len: the number of pointers to this leaf
1965 * @leaf_no: the leaf number
ec038c82 1966 * @leaf_bh: buffer_head for the starting leaf
3ae3a7d6 1967 * @last_dealloc: 1 if this is the final dealloc for the leaf, else 0
b3b94faa
DT
1968 *
1969 * Returns: errno
1970 */
1971
cd915493 1972static int leaf_dealloc(struct gfs2_inode *dip, u32 index, u32 len,
ec038c82
BP
1973 u64 leaf_no, struct buffer_head *leaf_bh,
1974 int last_dealloc)
b3b94faa 1975{
feaa7bba 1976 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
c752666c 1977 struct gfs2_leaf *tmp_leaf;
b3b94faa
DT
1978 struct gfs2_rgrp_list rlist;
1979 struct buffer_head *bh, *dibh;
cd915493 1980 u64 blk, nblk;
b3b94faa
DT
1981 unsigned int rg_blocks = 0, l_blocks = 0;
1982 char *ht;
cd915493 1983 unsigned int x, size = len * sizeof(u64);
b3b94faa
DT
1984 int error;
1985
5e2f7d61
BP
1986 error = gfs2_rindex_update(sdp);
1987 if (error)
1988 return error;
1989
b3b94faa
DT
1990 memset(&rlist, 0, sizeof(struct gfs2_rgrp_list));
1991
8be04b93 1992 ht = kzalloc(size, GFP_NOFS | __GFP_NOWARN);
e8830d88 1993 if (ht == NULL)
88dca4ca 1994 ht = __vmalloc(size, GFP_NOFS | __GFP_NOWARN | __GFP_ZERO);
b3b94faa
DT
1995 if (!ht)
1996 return -ENOMEM;
1997
f4108a60 1998 error = gfs2_quota_hold(dip, NO_UID_QUOTA_CHANGE, NO_GID_QUOTA_CHANGE);
b3b94faa 1999 if (error)
5407e242 2000 goto out;
b3b94faa 2001
b3b94faa 2002 /* Count the number of leaves */
ec038c82 2003 bh = leaf_bh;
b3b94faa 2004
c752666c 2005 for (blk = leaf_no; blk; blk = nblk) {
ec038c82
BP
2006 if (blk != leaf_no) {
2007 error = get_leaf(dip, blk, &bh);
2008 if (error)
2009 goto out_rlist;
2010 }
c752666c
SW
2011 tmp_leaf = (struct gfs2_leaf *)bh->b_data;
2012 nblk = be64_to_cpu(tmp_leaf->lf_next);
ec038c82
BP
2013 if (blk != leaf_no)
2014 brelse(bh);
b3b94faa 2015
70b0c365 2016 gfs2_rlist_add(dip, &rlist, blk);
b3b94faa
DT
2017 l_blocks++;
2018 }
2019
c3abc29e 2020 gfs2_rlist_alloc(&rlist);
b3b94faa
DT
2021
2022 for (x = 0; x < rlist.rl_rgrps; x++) {
6f6597ba
AG
2023 struct gfs2_rgrpd *rgd = gfs2_glock2rgrp(rlist.rl_ghs[x].gh_gl);
2024
bb8d8a6f 2025 rg_blocks += rgd->rd_length;
b3b94faa
DT
2026 }
2027
2028 error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);
2029 if (error)
2030 goto out_rlist;
2031
2032 error = gfs2_trans_begin(sdp,
5c676f6d 2033 rg_blocks + (DIV_ROUND_UP(size, sdp->sd_jbsize) + 1) +
cc44457f
BP
2034 RES_DINODE + RES_STATFS + RES_QUOTA, RES_DINODE +
2035 l_blocks);
b3b94faa
DT
2036 if (error)
2037 goto out_rg_gunlock;
2038
ec038c82
BP
2039 bh = leaf_bh;
2040
c752666c 2041 for (blk = leaf_no; blk; blk = nblk) {
0ddeded4
AG
2042 struct gfs2_rgrpd *rgd;
2043
ec038c82
BP
2044 if (blk != leaf_no) {
2045 error = get_leaf(dip, blk, &bh);
2046 if (error)
2047 goto out_end_trans;
2048 }
c752666c
SW
2049 tmp_leaf = (struct gfs2_leaf *)bh->b_data;
2050 nblk = be64_to_cpu(tmp_leaf->lf_next);
ec038c82
BP
2051 if (blk != leaf_no)
2052 brelse(bh);
b3b94faa 2053
0ddeded4
AG
2054 rgd = gfs2_blk2rgrpd(sdp, blk, true);
2055 gfs2_free_meta(dip, rgd, blk, 1);
77658aad 2056 gfs2_add_inode_blocks(&dip->i_inode, -1);
b3b94faa
DT
2057 }
2058
cd915493 2059 error = gfs2_dir_write_data(dip, ht, index * sizeof(u64), size);
b3b94faa
DT
2060 if (error != size) {
2061 if (error >= 0)
2062 error = -EIO;
2063 goto out_end_trans;
2064 }
2065
2066 error = gfs2_meta_inode_buffer(dip, &dibh);
2067 if (error)
2068 goto out_end_trans;
2069
350a9b0a 2070 gfs2_trans_add_meta(dip->i_gl, dibh);
d24a7a43
BP
2071 /* On the last dealloc, make this a regular file in case we crash.
2072 (We don't want to free these blocks a second time.) */
2073 if (last_dealloc)
2074 dip->i_inode.i_mode = S_IFREG;
539e5d6b 2075 gfs2_dinode_out(dip, dibh->b_data);
b3b94faa
DT
2076 brelse(dibh);
2077
a91ea69f 2078out_end_trans:
b3b94faa 2079 gfs2_trans_end(sdp);
a91ea69f 2080out_rg_gunlock:
b3b94faa 2081 gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);
a91ea69f 2082out_rlist:
b3b94faa 2083 gfs2_rlist_free(&rlist);
b3b94faa 2084 gfs2_quota_unhold(dip);
182fe5ab 2085out:
3cdcf63e 2086 kvfree(ht);
b3b94faa
DT
2087 return error;
2088}
2089
2090/**
2091 * gfs2_dir_exhash_dealloc - free all the leaf blocks in a directory
2092 * @dip: the directory
2093 *
2094 * Dealloc all on-disk directory leaves to FREEMETA state
2095 * Change on-disk inode type to "regular file"
2096 *
2097 * Returns: errno
2098 */
2099
2100int gfs2_dir_exhash_dealloc(struct gfs2_inode *dip)
2101{
556bb179
BP
2102 struct buffer_head *bh;
2103 struct gfs2_leaf *leaf;
2104 u32 hsize, len;
556bb179
BP
2105 u32 index = 0, next_index;
2106 __be64 *lp;
2107 u64 leaf_no;
2108 int error = 0, last;
2109
47a9a527 2110 hsize = BIT(dip->i_depth);
556bb179 2111
17d539f0
SW
2112 lp = gfs2_dir_get_hash_table(dip);
2113 if (IS_ERR(lp))
2114 return PTR_ERR(lp);
556bb179
BP
2115
2116 while (index < hsize) {
17d539f0 2117 leaf_no = be64_to_cpu(lp[index]);
556bb179
BP
2118 if (leaf_no) {
2119 error = get_leaf(dip, leaf_no, &bh);
2120 if (error)
2121 goto out;
2122 leaf = (struct gfs2_leaf *)bh->b_data;
47a9a527 2123 len = BIT(dip->i_depth - be16_to_cpu(leaf->lf_depth));
556bb179
BP
2124
2125 next_index = (index & ~(len - 1)) + len;
2126 last = ((next_index >= hsize) ? 1 : 0);
2127 error = leaf_dealloc(dip, index, len, leaf_no, bh,
2128 last);
2129 brelse(bh);
2130 if (error)
2131 goto out;
2132 index = next_index;
2133 } else
2134 index++;
2135 }
2136
2137 if (index != hsize) {
2138 gfs2_consist_inode(dip);
2139 error = -EIO;
2140 }
2141
2142out:
556bb179
BP
2143
2144 return error;
b3b94faa
DT
2145}
2146
2147/**
2148 * gfs2_diradd_alloc_required - find if adding entry will require an allocation
3ae3a7d6
BP
2149 * @inode: the directory inode being written to
2150 * @name: the filename that's going to be added
3c1c0ae1 2151 * @da: The structure to return dir alloc info
b3b94faa 2152 *
3c1c0ae1 2153 * Returns: 0 if ok, -ve on error
b3b94faa
DT
2154 */
2155
3c1c0ae1
SW
2156int gfs2_diradd_alloc_required(struct inode *inode, const struct qstr *name,
2157 struct gfs2_diradd *da)
b3b94faa 2158{
22b5a6c0 2159 struct gfs2_inode *ip = GFS2_I(inode);
3c1c0ae1 2160 struct gfs2_sbd *sdp = GFS2_SB(inode);
22b5a6c0 2161 const unsigned int extra = sizeof(struct gfs2_dinode) - sizeof(struct gfs2_leaf);
c752666c
SW
2162 struct gfs2_dirent *dent;
2163 struct buffer_head *bh;
b3b94faa 2164
3c1c0ae1 2165 da->nr_blocks = 0;
2b47dad8
SW
2166 da->bh = NULL;
2167 da->dent = NULL;
3c1c0ae1 2168
c752666c 2169 dent = gfs2_dirent_search(inode, name, gfs2_dirent_find_space, &bh);
ed386507 2170 if (!dent) {
3c1c0ae1 2171 da->nr_blocks = sdp->sd_max_dirres;
22b5a6c0
SW
2172 if (!(ip->i_diskflags & GFS2_DIF_EXHASH) &&
2173 (GFS2_DIRENT_SIZE(name->len) < extra))
2174 da->nr_blocks = 1;
3c1c0ae1 2175 return 0;
ed386507 2176 }
c752666c
SW
2177 if (IS_ERR(dent))
2178 return PTR_ERR(dent);
19aeb5a6
BP
2179
2180 if (da->save_loc) {
2181 da->bh = bh;
2182 da->dent = dent;
2183 } else {
2184 brelse(bh);
2185 }
c752666c 2186 return 0;
b3b94faa
DT
2187}
2188