dir.c 47.7 KB
Newer Older
D
David Teigland 已提交
1 2
/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3
 * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
D
David Teigland 已提交
4 5 6
 *
 * This copyrighted material is made available to anyone wishing to use,
 * modify, copy, or redistribute it subject to the terms and conditions
7
 * of the GNU General Public License version 2.
D
David Teigland 已提交
8 9 10
 */

/*
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
 * Implements Extendible Hashing as described in:
 *   "Extendible Hashing" by Fagin, et al in
 *     __ACM Trans. on Database Systems__, Sept 1979.
 *
 *
 * Here's the layout of dirents which is essentially the same as that of ext2
 * within a single block. The field de_name_len is the number of bytes
 * actually required for the name (no null terminator). The field de_rec_len
 * is the number of bytes allocated to the dirent. The offset of the next
 * dirent in the block is (dirent + dirent->de_rec_len). When a dirent is
 * deleted, the preceding dirent inherits its allocated space, ie
 * prev->de_rec_len += deleted->de_rec_len. Since the next dirent is obtained
 * by adding de_rec_len to the current dirent, this essentially causes the
 * deleted dirent to get jumped over when iterating through all the dirents.
 *
 * When deleting the first dirent in a block, there is no previous dirent so
 * the field de_ino is set to zero to designate it as deleted. When allocating
 * a dirent, gfs2_dirent_alloc iterates through the dirents in a block. If the
 * first dirent has (de_ino == 0) and de_rec_len is large enough, this first
 * dirent is allocated. Otherwise it must go through all the 'used' dirents
 * searching for one in which the amount of total space minus the amount of
 * used space will provide enough space for the new dirent.
 *
 * There are two types of blocks in which dirents reside. In a stuffed dinode,
 * the dirents begin at offset sizeof(struct gfs2_dinode) from the beginning of
 * the block.  In leaves, they begin at offset sizeof(struct gfs2_leaf) from the
 * beginning of the leaf block. The dirents reside in leaves when
 *
39
 * dip->i_diskflags & GFS2_DIF_EXHASH is true
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
 *
 * Otherwise, the dirents are "linear", within a single stuffed dinode block.
 *
 * When the dirents are in leaves, the actual contents of the directory file are
 * used as an array of 64-bit block pointers pointing to the leaf blocks. The
 * dirents are NOT in the directory file itself. There can be more than one
 * block pointer in the array that points to the same leaf. In fact, when a
 * directory is first converted from linear to exhash, all of the pointers
 * point to the same leaf.
 *
 * When a leaf is completely full, the size of the hash table can be
 * doubled unless it is already at the maximum size which is hard coded into
 * GFS2_DIR_MAX_DEPTH. After that, leaves are chained together in a linked list,
 * but never before the maximum hash table size has been reached.
 */
D
David Teigland 已提交
55 56 57 58 59

#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/buffer_head.h>
#include <linux/sort.h>
60
#include <linux/gfs2_ondisk.h>
61
#include <linux/crc32.h>
62
#include <linux/vmalloc.h>
D
David Teigland 已提交
63 64

#include "gfs2.h"
65
#include "incore.h"
D
David Teigland 已提交
66 67 68 69 70 71 72
#include "dir.h"
#include "glock.h"
#include "inode.h"
#include "meta_io.h"
#include "quota.h"
#include "rgrp.h"
#include "trans.h"
73
#include "bmap.h"
74
#include "util.h"
D
David Teigland 已提交
75 76 77 78

#define IS_LEAF     1 /* Hashed (leaf) directory */
#define IS_DINODE   2 /* Linear (stuffed dinode block) directory */

79 80
#define MAX_RA_BLOCKS 32 /* max read-ahead blocks */

81 82
#define gfs2_disk_hash2offset(h) (((u64)(h)) >> 1)
#define gfs2_dir_offset2hash(p) ((u32)(((u64)(p)) << 1))
D
David Teigland 已提交
83

84 85 86
struct qstr gfs2_qdot __read_mostly;
struct qstr gfs2_qdotdot __read_mostly;

87 88
typedef int (*gfs2_dscan_t)(const struct gfs2_dirent *dent,
			    const struct qstr *name, void *opaque);
D
David Teigland 已提交
89

90
int gfs2_dir_get_new_buffer(struct gfs2_inode *ip, u64 block,
91
			    struct buffer_head **bhp)
92 93 94
{
	struct buffer_head *bh;

95
	bh = gfs2_meta_new(ip->i_gl, block);
96
	gfs2_trans_add_meta(ip->i_gl, bh);
97 98
	gfs2_metatype_set(bh, GFS2_METATYPE_JD, GFS2_FORMAT_JD);
	gfs2_buffer_clear_tail(bh, sizeof(struct gfs2_meta_header));
99 100 101 102
	*bhp = bh;
	return 0;
}

103
static int gfs2_dir_get_existing_buffer(struct gfs2_inode *ip, u64 block,
104 105 106 107
					struct buffer_head **bhp)
{
	struct buffer_head *bh;
	int error;
108

S
Steven Whitehouse 已提交
109
	error = gfs2_meta_read(ip->i_gl, block, DIO_WAIT, &bh);
110 111
	if (error)
		return error;
112
	if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), bh, GFS2_METATYPE_JD)) {
113 114 115 116 117 118
		brelse(bh);
		return -EIO;
	}
	*bhp = bh;
	return 0;
}
119 120 121 122 123 124 125 126 127 128 129

static int gfs2_dir_write_stuffed(struct gfs2_inode *ip, const char *buf,
				  unsigned int offset, unsigned int size)
{
	struct buffer_head *dibh;
	int error;

	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (error)
		return error;

130
	gfs2_trans_add_meta(ip->i_gl, dibh);
131
	memcpy(dibh->b_data + offset + sizeof(struct gfs2_dinode), buf, size);
S
Steven Whitehouse 已提交
132 133
	if (ip->i_inode.i_size < offset + size)
		i_size_write(&ip->i_inode, offset + size);
134
	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
135
	gfs2_dinode_out(ip, dibh->b_data);
136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153

	brelse(dibh);

	return size;
}



/**
 * gfs2_dir_write_data - Write directory information to the inode
 * @ip: The GFS2 inode
 * @buf: The buffer containing information to be written
 * @offset: The file offset to start writing at
 * @size: The amount of data to write
 *
 * Returns: The number of bytes correctly written or error code
 */
static int gfs2_dir_write_data(struct gfs2_inode *ip, const char *buf,
154
			       u64 offset, unsigned int size)
155
{
156
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
157
	struct buffer_head *dibh;
158 159
	u64 lblock, dblock;
	u32 extlen = 0;
160 161 162
	unsigned int o;
	int copied = 0;
	int error = 0;
163
	int new = 0;
164 165 166 167 168 169

	if (!size)
		return 0;

	if (gfs2_is_stuffed(ip) &&
	    offset + size <= sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode))
170 171
		return gfs2_dir_write_stuffed(ip, buf, (unsigned int)offset,
					      size);
172 173 174 175 176

	if (gfs2_assert_warn(sdp, gfs2_is_jdata(ip)))
		return -EINVAL;

	if (gfs2_is_stuffed(ip)) {
177
		error = gfs2_unstuff_dinode(ip, NULL);
178
		if (error)
179
			return error;
180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
	}

	lblock = offset;
	o = do_div(lblock, sdp->sd_jbsize) + sizeof(struct gfs2_meta_header);

	while (copied < size) {
		unsigned int amount;
		struct buffer_head *bh;

		amount = size - copied;
		if (amount > sdp->sd_sb.sb_bsize - o)
			amount = sdp->sd_sb.sb_bsize - o;

		if (!extlen) {
			new = 1;
195
			error = gfs2_extent_map(&ip->i_inode, lblock, &new,
S
Steven Whitehouse 已提交
196
						&dblock, &extlen);
197 198 199 200 201 202 203
			if (error)
				goto fail;
			error = -EIO;
			if (gfs2_assert_withdraw(sdp, dblock))
				goto fail;
		}

204 205 206 207 208
		if (amount == sdp->sd_jbsize || new)
			error = gfs2_dir_get_new_buffer(ip, dblock, &bh);
		else
			error = gfs2_dir_get_existing_buffer(ip, dblock, &bh);

209 210 211
		if (error)
			goto fail;

212
		gfs2_trans_add_meta(ip->i_gl, bh);
213 214 215
		memcpy(bh->b_data + o, buf, amount);
		brelse(bh);

216
		buf += amount;
217 218 219 220 221 222 223 224 225 226 227 228 229
		copied += amount;
		lblock++;
		dblock++;
		extlen--;

		o = sizeof(struct gfs2_meta_header);
	}

out:
	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (error)
		return error;

S
Steven Whitehouse 已提交
230 231
	if (ip->i_inode.i_size < offset + copied)
		i_size_write(&ip->i_inode, offset + copied);
232
	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
233

234
	gfs2_trans_add_meta(ip->i_gl, dibh);
235
	gfs2_dinode_out(ip, dibh->b_data);
236 237 238 239 240 241 242 243 244
	brelse(dibh);

	return copied;
fail:
	if (copied)
		goto out;
	return error;
}

245 246
static int gfs2_dir_read_stuffed(struct gfs2_inode *ip, __be64 *buf,
				 unsigned int size)
247 248 249 250 251 252
{
	struct buffer_head *dibh;
	int error;

	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (!error) {
253
		memcpy(buf, dibh->b_data + sizeof(struct gfs2_dinode), size);
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268
		brelse(dibh);
	}

	return (error) ? error : size;
}


/**
 * gfs2_dir_read_data - Read a data from a directory inode
 * @ip: The GFS2 Inode
 * @buf: The buffer to place result into
 * @size: Amount of data to transfer
 *
 * Returns: The amount of data actually copied or the error
 */
269 270
static int gfs2_dir_read_data(struct gfs2_inode *ip, __be64 *buf,
			      unsigned int size)
271
{
272
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
273 274
	u64 lblock, dblock;
	u32 extlen = 0;
275 276 277 278 279
	unsigned int o;
	int copied = 0;
	int error = 0;

	if (gfs2_is_stuffed(ip))
280
		return gfs2_dir_read_stuffed(ip, buf, size);
281 282 283 284

	if (gfs2_assert_warn(sdp, gfs2_is_jdata(ip)))
		return -EINVAL;

285
	lblock = 0;
286 287 288 289 290 291 292 293 294 295 296 297 298
	o = do_div(lblock, sdp->sd_jbsize) + sizeof(struct gfs2_meta_header);

	while (copied < size) {
		unsigned int amount;
		struct buffer_head *bh;
		int new;

		amount = size - copied;
		if (amount > sdp->sd_sb.sb_bsize - o)
			amount = sdp->sd_sb.sb_bsize - o;

		if (!extlen) {
			new = 0;
299
			error = gfs2_extent_map(&ip->i_inode, lblock, &new,
S
Steven Whitehouse 已提交
300
						&dblock, &extlen);
S
Steven Whitehouse 已提交
301
			if (error || !dblock)
302
				goto fail;
S
Steven Whitehouse 已提交
303 304
			BUG_ON(extlen < 1);
			bh = gfs2_meta_ra(ip->i_gl, dblock, extlen);
305
		} else {
S
Steven Whitehouse 已提交
306
			error = gfs2_meta_read(ip->i_gl, dblock, DIO_WAIT, &bh);
307 308
			if (error)
				goto fail;
S
Steven Whitehouse 已提交
309 310 311 312 313 314 315 316
		}
		error = gfs2_metatype_check(sdp, bh, GFS2_METATYPE_JD);
		if (error) {
			brelse(bh);
			goto fail;
		}
		dblock++;
		extlen--;
317 318
		memcpy(buf, bh->b_data + o, amount);
		brelse(bh);
319
		buf += (amount/sizeof(__be64));
320 321 322 323 324 325 326 327 328 329
		copied += amount;
		lblock++;
		o = sizeof(struct gfs2_meta_header);
	}

	return copied;
fail:
	return (copied) ? copied : error;
}

330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356
/**
 * gfs2_dir_get_hash_table - Get pointer to the dir hash table
 * @ip: The inode in question
 *
 * Returns: The hash table or an error
 */

static __be64 *gfs2_dir_get_hash_table(struct gfs2_inode *ip)
{
	struct inode *inode = &ip->i_inode;
	int ret;
	u32 hsize;
	__be64 *hc;

	BUG_ON(!(ip->i_diskflags & GFS2_DIF_EXHASH));

	hc = ip->i_hash_cache;
	if (hc)
		return hc;

	hsize = 1 << ip->i_depth;
	hsize *= sizeof(__be64);
	if (hsize != i_size_read(&ip->i_inode)) {
		gfs2_consist_inode(ip);
		return ERR_PTR(-EIO);
	}

357 358 359 360
	hc = kmalloc(hsize, GFP_NOFS | __GFP_NOWARN);
	if (hc == NULL)
		hc = __vmalloc(hsize, GFP_NOFS, PAGE_KERNEL);

361 362 363
	if (hc == NULL)
		return ERR_PTR(-ENOMEM);

364
	ret = gfs2_dir_read_data(ip, hc, hsize);
365
	if (ret < 0) {
366 367 368 369
		if (is_vmalloc_addr(hc))
			vfree(hc);
		else
			kfree(hc);
370 371 372 373
		return ERR_PTR(ret);
	}

	spin_lock(&inode->i_lock);
374 375 376 377 378 379
	if (ip->i_hash_cache) {
		if (is_vmalloc_addr(hc))
			vfree(hc);
		else
			kfree(hc);
	} else {
380
		ip->i_hash_cache = hc;
381
	}
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396
	spin_unlock(&inode->i_lock);

	return ip->i_hash_cache;
}

/**
 * gfs2_dir_hash_inval - Invalidate dir hash
 * @ip: The directory inode
 *
 * Must be called with an exclusive glock, or during glock invalidation.
 */
void gfs2_dir_hash_inval(struct gfs2_inode *ip)
{
	__be64 *hc = ip->i_hash_cache;
	ip->i_hash_cache = NULL;
397 398 399 400
	if (is_vmalloc_addr(hc))
		vfree(hc);
	else
		kfree(hc);
401 402
}

403 404 405 406 407
static inline int gfs2_dirent_sentinel(const struct gfs2_dirent *dent)
{
	return dent->de_inum.no_addr == 0 || dent->de_inum.no_formal_ino == 0;
}

408 409 410
static inline int __gfs2_dirent_find(const struct gfs2_dirent *dent,
				     const struct qstr *name, int ret)
{
411
	if (!gfs2_dirent_sentinel(dent) &&
412 413
	    be32_to_cpu(dent->de_hash) == name->hash &&
	    be16_to_cpu(dent->de_name_len) == name->len &&
414
	    memcmp(dent+1, name->name, name->len) == 0)
415 416 417 418 419
		return ret;
	return 0;
}

static int gfs2_dirent_find(const struct gfs2_dirent *dent,
420 421
			    const struct qstr *name,
			    void *opaque)
422 423 424 425 426
{
	return __gfs2_dirent_find(dent, name, 1);
}

static int gfs2_dirent_prev(const struct gfs2_dirent *dent,
427 428
			    const struct qstr *name,
			    void *opaque)
429 430 431 432 433 434 435
{
	return __gfs2_dirent_find(dent, name, 2);
}

/*
 * name->name holds ptr to start of block.
 * name->len holds size of block.
D
David Teigland 已提交
436
 */
437
static int gfs2_dirent_last(const struct gfs2_dirent *dent,
438 439
			    const struct qstr *name,
			    void *opaque)
440 441 442 443 444 445 446
{
	const char *start = name->name;
	const char *end = (const char *)dent + be16_to_cpu(dent->de_rec_len);
	if (name->len == (end - start))
		return 1;
	return 0;
}
D
David Teigland 已提交
447

448
static int gfs2_dirent_find_space(const struct gfs2_dirent *dent,
449 450
				  const struct qstr *name,
				  void *opaque)
D
David Teigland 已提交
451
{
452 453 454 455
	unsigned required = GFS2_DIRENT_SIZE(name->len);
	unsigned actual = GFS2_DIRENT_SIZE(be16_to_cpu(dent->de_name_len));
	unsigned totlen = be16_to_cpu(dent->de_rec_len);

456
	if (gfs2_dirent_sentinel(dent))
B
Bob Peterson 已提交
457
		actual = 0;
J
Jan Engelhardt 已提交
458
	if (totlen - actual >= required)
459 460 461 462
		return 1;
	return 0;
}

463 464 465 466 467 468 469 470 471 472
struct dirent_gather {
	const struct gfs2_dirent **pdent;
	unsigned offset;
};

static int gfs2_dirent_gather(const struct gfs2_dirent *dent,
			      const struct qstr *name,
			      void *opaque)
{
	struct dirent_gather *g = opaque;
473
	if (!gfs2_dirent_sentinel(dent)) {
474 475 476 477 478
		g->pdent[g->offset++] = dent;
	}
	return 0;
}

479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500
/*
 * Other possible things to check:
 * - Inode located within filesystem size (and on valid block)
 * - Valid directory entry type
 * Not sure how heavy-weight we want to make this... could also check
 * hash is correct for example, but that would take a lot of extra time.
 * For now the most important thing is to check that the various sizes
 * are correct.
 */
static int gfs2_check_dirent(struct gfs2_dirent *dent, unsigned int offset,
			     unsigned int size, unsigned int len, int first)
{
	const char *msg = "gfs2_dirent too small";
	if (unlikely(size < sizeof(struct gfs2_dirent)))
		goto error;
	msg = "gfs2_dirent misaligned";
	if (unlikely(offset & 0x7))
		goto error;
	msg = "gfs2_dirent points beyond end of block";
	if (unlikely(offset + size > len))
		goto error;
	msg = "zero inode number";
501
	if (unlikely(!first && gfs2_dirent_sentinel(dent)))
502 503
		goto error;
	msg = "name length is greater than space in dirent";
504
	if (!gfs2_dirent_sentinel(dent) &&
505 506 507 508 509 510 511 512
	    unlikely(sizeof(struct gfs2_dirent)+be16_to_cpu(dent->de_name_len) >
		     size))
		goto error;
	return 0;
error:
	printk(KERN_WARNING "gfs2_check_dirent: %s (%s)\n", msg,
	       first ? "first in block" : "not first in block");
	return -EIO;
D
David Teigland 已提交
513 514
}

515
static int gfs2_dirent_offset(const void *buf)
516
{
517 518
	const struct gfs2_meta_header *h = buf;
	int offset;
519 520 521

	BUG_ON(buf == NULL);

522
	switch(be32_to_cpu(h->mh_type)) {
523 524 525 526 527 528 529 530 531
	case GFS2_METATYPE_LF:
		offset = sizeof(struct gfs2_leaf);
		break;
	case GFS2_METATYPE_DI:
		offset = sizeof(struct gfs2_dinode);
		break;
	default:
		goto wrong_type;
	}
532 533 534
	return offset;
wrong_type:
	printk(KERN_WARNING "gfs2_scan_dirent: wrong block type %u\n",
535
	       be32_to_cpu(h->mh_type));
536 537 538
	return -1;
}

539
static struct gfs2_dirent *gfs2_dirent_scan(struct inode *inode, void *buf,
540 541 542 543 544 545 546 547
					    unsigned int len, gfs2_dscan_t scan,
					    const struct qstr *name,
					    void *opaque)
{
	struct gfs2_dirent *dent, *prev;
	unsigned offset;
	unsigned size;
	int ret = 0;
548

549 550 551 552 553
	ret = gfs2_dirent_offset(buf);
	if (ret < 0)
		goto consist_inode;

	offset = ret;
554
	prev = NULL;
555
	dent = buf + offset;
556 557 558 559
	size = be16_to_cpu(dent->de_rec_len);
	if (gfs2_check_dirent(dent, offset, size, len, 1))
		goto consist_inode;
	do {
560
		ret = scan(dent, name, opaque);
561 562 563 564 565 566
		if (ret)
			break;
		offset += size;
		if (offset == len)
			break;
		prev = dent;
567
		dent = buf + offset;
568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585
		size = be16_to_cpu(dent->de_rec_len);
		if (gfs2_check_dirent(dent, offset, size, len, 0))
			goto consist_inode;
	} while(1);

	switch(ret) {
	case 0:
		return NULL;
	case 1:
		return dent;
	case 2:
		return prev ? prev : dent;
	default:
		BUG_ON(ret > 0);
		return ERR_PTR(ret);
	}

consist_inode:
586
	gfs2_consist_inode(GFS2_I(inode));
587 588 589
	return ERR_PTR(-EIO);
}

590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607
static int dirent_check_reclen(struct gfs2_inode *dip,
			       const struct gfs2_dirent *d, const void *end_p)
{
	const void *ptr = d;
	u16 rec_len = be16_to_cpu(d->de_rec_len);

	if (unlikely(rec_len < sizeof(struct gfs2_dirent)))
		goto broken;
	ptr += rec_len;
	if (ptr < end_p)
		return rec_len;
	if (ptr == end_p)
		return -ENOENT;
broken:
	gfs2_consist_inode(dip);
	return -EIO;
}

D
David Teigland 已提交
608 609 610 611 612 613 614 615 616 617 618 619
/**
 * dirent_next - Next dirent
 * @dip: the directory
 * @bh: The buffer
 * @dent: Pointer to list of dirents
 *
 * Returns: 0 on success, error code otherwise
 */

static int dirent_next(struct gfs2_inode *dip, struct buffer_head *bh,
		       struct gfs2_dirent **dent)
{
620 621 622
	struct gfs2_dirent *cur = *dent, *tmp;
	char *bh_end = bh->b_data + bh->b_size;
	int ret;
D
David Teigland 已提交
623

624 625 626
	ret = dirent_check_reclen(dip, cur, bh_end);
	if (ret < 0)
		return ret;
627

628 629 630 631
	tmp = (void *)cur + ret;
	ret = dirent_check_reclen(dip, tmp, bh_end);
	if (ret == -EIO)
		return ret;
632

D
David Teigland 已提交
633
        /* Only the first dent could ever have de_inum.no_addr == 0 */
634
	if (gfs2_dirent_sentinel(tmp)) {
D
David Teigland 已提交
635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
		gfs2_consist_inode(dip);
		return -EIO;
	}

	*dent = tmp;
	return 0;
}

/**
 * dirent_del - Delete a dirent
 * @dip: The GFS2 inode
 * @bh: The buffer
 * @prev: The previous dirent
 * @cur: The current dirent
 *
 */

static void dirent_del(struct gfs2_inode *dip, struct buffer_head *bh,
		       struct gfs2_dirent *prev, struct gfs2_dirent *cur)
{
655
	u16 cur_rec_len, prev_rec_len;
D
David Teigland 已提交
656

657
	if (gfs2_dirent_sentinel(cur)) {
D
David Teigland 已提交
658 659 660 661
		gfs2_consist_inode(dip);
		return;
	}

662
	gfs2_trans_add_meta(dip->i_gl, bh);
D
David Teigland 已提交
663 664 665 666 667 668

	/* If there is no prev entry, this is the first entry in the block.
	   The de_rec_len is already as big as it needs to be.  Just zero
	   out the inode number and return.  */

	if (!prev) {
669 670
		cur->de_inum.no_addr = 0;
		cur->de_inum.no_formal_ino = 0;
D
David Teigland 已提交
671 672 673 674 675
		return;
	}

	/*  Combine this dentry with the previous one.  */

676 677
	prev_rec_len = be16_to_cpu(prev->de_rec_len);
	cur_rec_len = be16_to_cpu(cur->de_rec_len);
D
David Teigland 已提交
678 679 680 681 682 683 684

	if ((char *)prev + prev_rec_len != (char *)cur)
		gfs2_consist_inode(dip);
	if ((char *)cur + cur_rec_len > bh->b_data + bh->b_size)
		gfs2_consist_inode(dip);

	prev_rec_len += cur_rec_len;
685
	prev->de_rec_len = cpu_to_be16(prev_rec_len);
D
David Teigland 已提交
686 687
}

688 689 690
/*
 * Takes a dent from which to grab space as an argument. Returns the
 * newly created dent.
D
David Teigland 已提交
691
 */
692 693 694 695
static struct gfs2_dirent *gfs2_init_dirent(struct inode *inode,
					    struct gfs2_dirent *dent,
					    const struct qstr *name,
					    struct buffer_head *bh)
D
David Teigland 已提交
696
{
697
	struct gfs2_inode *ip = GFS2_I(inode);
698 699 700
	struct gfs2_dirent *ndent;
	unsigned offset = 0, totlen;

701
	if (!gfs2_dirent_sentinel(dent))
702 703 704
		offset = GFS2_DIRENT_SIZE(be16_to_cpu(dent->de_name_len));
	totlen = be16_to_cpu(dent->de_rec_len);
	BUG_ON(offset + name->len > totlen);
705
	gfs2_trans_add_meta(ip->i_gl, bh);
706 707 708 709
	ndent = (struct gfs2_dirent *)((char *)dent + offset);
	dent->de_rec_len = cpu_to_be16(offset);
	gfs2_qstr2dirent(name, totlen - offset, ndent);
	return ndent;
D
David Teigland 已提交
710 711
}

712 713 714
static struct gfs2_dirent *gfs2_dirent_alloc(struct inode *inode,
					     struct buffer_head *bh,
					     const struct qstr *name)
D
David Teigland 已提交
715 716
{
	struct gfs2_dirent *dent;
717
	dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size,
718
				gfs2_dirent_find_space, name, NULL);
719 720 721
	if (!dent || IS_ERR(dent))
		return dent;
	return gfs2_init_dirent(inode, dent, name, bh);
D
David Teigland 已提交
722 723
}

724
static int get_leaf(struct gfs2_inode *dip, u64 leaf_no,
D
David Teigland 已提交
725 726 727 728
		    struct buffer_head **bhp)
{
	int error;

S
Steven Whitehouse 已提交
729
	error = gfs2_meta_read(dip->i_gl, leaf_no, DIO_WAIT, bhp);
730 731
	if (!error && gfs2_metatype_check(GFS2_SB(&dip->i_inode), *bhp, GFS2_METATYPE_LF)) {
		/* printk(KERN_INFO "block num=%llu\n", leaf_no); */
D
David Teigland 已提交
732
		error = -EIO;
733
	}
D
David Teigland 已提交
734 735 736 737 738 739 740 741 742 743 744 745 746

	return error;
}

/**
 * get_leaf_nr - Get a leaf number associated with the index
 * @dip: The GFS2 inode
 * @index:
 * @leaf_out:
 *
 * Returns: 0 on success, error code otherwise
 */

747 748
static int get_leaf_nr(struct gfs2_inode *dip, u32 index,
		       u64 *leaf_out)
D
David Teigland 已提交
749
{
750
	__be64 *hash;
D
David Teigland 已提交
751

752 753 754 755
	hash = gfs2_dir_get_hash_table(dip);
	if (IS_ERR(hash))
		return PTR_ERR(hash);
	*leaf_out = be64_to_cpu(*(hash + index));
D
David Teigland 已提交
756 757 758
	return 0;
}

759
static int get_first_leaf(struct gfs2_inode *dip, u32 index,
D
David Teigland 已提交
760 761
			  struct buffer_head **bh_out)
{
762
	u64 leaf_no;
D
David Teigland 已提交
763 764 765 766 767 768 769 770 771
	int error;

	error = get_leaf_nr(dip, index, &leaf_no);
	if (!error)
		error = get_leaf(dip, leaf_no, bh_out);

	return error;
}

772 773 774 775
static struct gfs2_dirent *gfs2_dirent_search(struct inode *inode,
					      const struct qstr *name,
					      gfs2_dscan_t scan,
					      struct buffer_head **pbh)
D
David Teigland 已提交
776
{
777 778
	struct buffer_head *bh;
	struct gfs2_dirent *dent;
779
	struct gfs2_inode *ip = GFS2_I(inode);
D
David Teigland 已提交
780 781
	int error;

782
	if (ip->i_diskflags & GFS2_DIF_EXHASH) {
783
		struct gfs2_leaf *leaf;
784
		unsigned hsize = 1 << ip->i_depth;
785 786
		unsigned index;
		u64 ln;
S
Steven Whitehouse 已提交
787
		if (hsize * sizeof(u64) != i_size_read(inode)) {
788 789 790
			gfs2_consist_inode(ip);
			return ERR_PTR(-EIO);
		}
791

792
		index = name->hash >> (32 - ip->i_depth);
793 794 795 796 797
		error = get_first_leaf(ip, index, &bh);
		if (error)
			return ERR_PTR(error);
		do {
			dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size,
798
						scan, name, NULL);
799 800 801 802
			if (dent)
				goto got_dent;
			leaf = (struct gfs2_leaf *)bh->b_data;
			ln = be64_to_cpu(leaf->lf_next);
803
			brelse(bh);
804 805
			if (!ln)
				break;
806

807 808
			error = get_leaf(ip, ln, &bh);
		} while(!error);
D
David Teigland 已提交
809

810
		return error ? ERR_PTR(error) : NULL;
D
David Teigland 已提交
811 812
	}

813

814 815 816
	error = gfs2_meta_inode_buffer(ip, &bh);
	if (error)
		return ERR_PTR(error);
817
	dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size, scan, name, NULL);
818
got_dent:
819
	if (unlikely(dent == NULL || IS_ERR(dent))) {
820 821 822
		brelse(bh);
		bh = NULL;
	}
823 824 825
	*pbh = bh;
	return dent;
}
D
David Teigland 已提交
826

827 828
static struct gfs2_leaf *new_leaf(struct inode *inode, struct buffer_head **pbh, u16 depth)
{
829
	struct gfs2_inode *ip = GFS2_I(inode);
830
	unsigned int n = 1;
831 832 833
	u64 bn;
	int error;
	struct buffer_head *bh;
834 835
	struct gfs2_leaf *leaf;
	struct gfs2_dirent *dent;
836
	struct qstr name = { .name = "" };
837

838
	error = gfs2_alloc_blocks(ip, &bn, &n, 0, NULL);
839 840 841
	if (error)
		return NULL;
	bh = gfs2_meta_new(ip->i_gl, bn);
842 843
	if (!bh)
		return NULL;
844

845
	gfs2_trans_add_unrevoke(GFS2_SB(inode), bn, 1);
846
	gfs2_trans_add_meta(ip->i_gl, bh);
847 848 849
	gfs2_metatype_set(bh, GFS2_METATYPE_LF, GFS2_FORMAT_LF);
	leaf = (struct gfs2_leaf *)bh->b_data;
	leaf->lf_depth = cpu_to_be16(depth);
850
	leaf->lf_entries = 0;
851
	leaf->lf_dirent_format = cpu_to_be32(GFS2_FORMAT_DE);
852
	leaf->lf_next = 0;
853 854
	memset(leaf->lf_reserved, 0, sizeof(leaf->lf_reserved));
	dent = (struct gfs2_dirent *)(leaf+1);
855
	gfs2_qstr2dirent(&name, bh->b_size - sizeof(struct gfs2_leaf), dent);
856 857
	*pbh = bh;
	return leaf;
D
David Teigland 已提交
858 859 860 861 862 863 864 865 866
}

/**
 * dir_make_exhash - Convert a stuffed directory into an ExHash directory
 * @dip: The GFS2 inode
 *
 * Returns: 0 on success, error code otherwise
 */

867
static int dir_make_exhash(struct inode *inode)
D
David Teigland 已提交
868
{
869 870
	struct gfs2_inode *dip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
D
David Teigland 已提交
871
	struct gfs2_dirent *dent;
872
	struct qstr args;
D
David Teigland 已提交
873 874 875
	struct buffer_head *bh, *dibh;
	struct gfs2_leaf *leaf;
	int y;
876
	u32 x;
A
Al Viro 已提交
877 878
	__be64 *lp;
	u64 bn;
D
David Teigland 已提交
879 880 881 882 883 884 885 886
	int error;

	error = gfs2_meta_inode_buffer(dip, &dibh);
	if (error)
		return error;

	/*  Turn over a new leaf  */

887 888 889 890
	leaf = new_leaf(inode, &bh, 0);
	if (!leaf)
		return -ENOSPC;
	bn = bh->b_blocknr;
D
David Teigland 已提交
891

892 893
	gfs2_assert(sdp, dip->i_entries < (1 << 16));
	leaf->lf_entries = cpu_to_be16(dip->i_entries);
D
David Teigland 已提交
894 895 896 897 898 899 900 901 902

	/*  Copy dirents  */

	gfs2_buffer_copy_tail(bh, sizeof(struct gfs2_leaf), dibh,
			     sizeof(struct gfs2_dinode));

	/*  Find last entry  */

	x = 0;
903 904 905
	args.len = bh->b_size - sizeof(struct gfs2_dinode) +
		   sizeof(struct gfs2_leaf);
	args.name = bh->b_data;
906
	dent = gfs2_dirent_scan(&dip->i_inode, bh->b_data, bh->b_size,
907
				gfs2_dirent_last, &args, NULL);
908 909 910 911 912 913 914 915 916
	if (!dent) {
		brelse(bh);
		brelse(dibh);
		return -EIO;
	}
	if (IS_ERR(dent)) {
		brelse(bh);
		brelse(dibh);
		return PTR_ERR(dent);
D
David Teigland 已提交
917 918 919 920 921
	}

	/*  Adjust the last dirent's record length
	   (Remember that dent still points to the last entry.)  */

922
	dent->de_rec_len = cpu_to_be16(be16_to_cpu(dent->de_rec_len) +
D
David Teigland 已提交
923
		sizeof(struct gfs2_dinode) -
924
		sizeof(struct gfs2_leaf));
D
David Teigland 已提交
925 926 927 928 929 930

	brelse(bh);

	/*  We're done with the new leaf block, now setup the new
	    hash table.  */

931
	gfs2_trans_add_meta(dip->i_gl, dibh);
D
David Teigland 已提交
932 933
	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));

A
Al Viro 已提交
934
	lp = (__be64 *)(dibh->b_data + sizeof(struct gfs2_dinode));
D
David Teigland 已提交
935 936 937 938

	for (x = sdp->sd_hash_ptrs; x--; lp++)
		*lp = cpu_to_be64(bn);

S
Steven Whitehouse 已提交
939
	i_size_write(inode, sdp->sd_sb.sb_bsize / 2);
940
	gfs2_add_inode_blocks(&dip->i_inode, 1);
941
	dip->i_diskflags |= GFS2_DIF_EXHASH;
D
David Teigland 已提交
942 943

	for (x = sdp->sd_hash_ptrs, y = -1; x; x >>= 1, y++) ;
944
	dip->i_depth = y;
D
David Teigland 已提交
945

946
	gfs2_dinode_out(dip, dibh->b_data);
D
David Teigland 已提交
947 948 949 950 951 952 953 954 955 956 957 958 959 960 961

	brelse(dibh);

	return 0;
}

/**
 * dir_split_leaf - Split a leaf block into two
 * @dip: The GFS2 inode
 * @index:
 * @leaf_no:
 *
 * Returns: 0 on success, error code on failure
 */

962
static int dir_split_leaf(struct inode *inode, const struct qstr *name)
D
David Teigland 已提交
963
{
964
	struct gfs2_inode *dip = GFS2_I(inode);
D
David Teigland 已提交
965 966
	struct buffer_head *nbh, *obh, *dibh;
	struct gfs2_leaf *nleaf, *oleaf;
967
	struct gfs2_dirent *dent = NULL, *prev = NULL, *next = NULL, *new;
968
	u32 start, len, half_len, divider;
A
Al Viro 已提交
969 970
	u64 bn, leaf_no;
	__be64 *lp;
971
	u32 index;
D
David Teigland 已提交
972 973 974
	int x, moved = 0;
	int error;

975
	index = name->hash >> (32 - dip->i_depth);
976 977 978
	error = get_leaf_nr(dip, index, &leaf_no);
	if (error)
		return error;
D
David Teigland 已提交
979 980 981 982

	/*  Get the old leaf block  */
	error = get_leaf(dip, leaf_no, &obh);
	if (error)
983
		return error;
D
David Teigland 已提交
984 985

	oleaf = (struct gfs2_leaf *)obh->b_data;
986
	if (dip->i_depth == be16_to_cpu(oleaf->lf_depth)) {
987 988 989 990
		brelse(obh);
		return 1; /* can't split */
	}

991
	gfs2_trans_add_meta(dip->i_gl, obh);
D
David Teigland 已提交
992

993 994 995 996 997 998
	nleaf = new_leaf(inode, &nbh, be16_to_cpu(oleaf->lf_depth) + 1);
	if (!nleaf) {
		brelse(obh);
		return -ENOSPC;
	}
	bn = nbh->b_blocknr;
D
David Teigland 已提交
999

1000
	/*  Compute the start and len of leaf pointers in the hash table.  */
1001
	len = 1 << (dip->i_depth - be16_to_cpu(oleaf->lf_depth));
D
David Teigland 已提交
1002 1003
	half_len = len >> 1;
	if (!half_len) {
1004
		printk(KERN_WARNING "i_depth %u lf_depth %u index %u\n", dip->i_depth, be16_to_cpu(oleaf->lf_depth), index);
D
David Teigland 已提交
1005 1006 1007 1008 1009 1010 1011 1012 1013 1014
		gfs2_consist_inode(dip);
		error = -EIO;
		goto fail_brelse;
	}

	start = (index & ~(len - 1));

	/* Change the pointers.
	   Don't bother distinguishing stuffed from non-stuffed.
	   This code is complicated enough already. */
1015 1016 1017 1018 1019 1020
	lp = kmalloc(half_len * sizeof(__be64), GFP_NOFS);
	if (!lp) {
		error = -ENOMEM;
		goto fail_brelse;
	}

D
David Teigland 已提交
1021 1022 1023 1024
	/*  Change the pointers  */
	for (x = 0; x < half_len; x++)
		lp[x] = cpu_to_be64(bn);

1025 1026
	gfs2_dir_hash_inval(dip);

1027 1028 1029
	error = gfs2_dir_write_data(dip, (char *)lp, start * sizeof(u64),
				    half_len * sizeof(u64));
	if (error != half_len * sizeof(u64)) {
D
David Teigland 已提交
1030 1031 1032 1033 1034 1035 1036 1037
		if (error >= 0)
			error = -EIO;
		goto fail_lpfree;
	}

	kfree(lp);

	/*  Compute the divider  */
1038
	divider = (start + half_len) << (32 - dip->i_depth);
D
David Teigland 已提交
1039 1040

	/*  Copy the entries  */
1041
	dent = (struct gfs2_dirent *)(obh->b_data + sizeof(struct gfs2_leaf));
D
David Teigland 已提交
1042 1043 1044 1045 1046 1047

	do {
		next = dent;
		if (dirent_next(dip, obh, &next))
			next = NULL;

1048
		if (!gfs2_dirent_sentinel(dent) &&
D
David Teigland 已提交
1049
		    be32_to_cpu(dent->de_hash) < divider) {
1050 1051 1052 1053
			struct qstr str;
			str.name = (char*)(dent+1);
			str.len = be16_to_cpu(dent->de_name_len);
			str.hash = be32_to_cpu(dent->de_hash);
1054
			new = gfs2_dirent_alloc(inode, nbh, &str);
1055 1056 1057 1058
			if (IS_ERR(new)) {
				error = PTR_ERR(new);
				break;
			}
D
David Teigland 已提交
1059 1060 1061

			new->de_inum = dent->de_inum; /* No endian worries */
			new->de_type = dent->de_type; /* No endian worries */
M
Marcin Slusarz 已提交
1062
			be16_add_cpu(&nleaf->lf_entries, 1);
D
David Teigland 已提交
1063 1064 1065 1066 1067

			dirent_del(dip, obh, prev, dent);

			if (!oleaf->lf_entries)
				gfs2_consist_inode(dip);
M
Marcin Slusarz 已提交
1068
			be16_add_cpu(&oleaf->lf_entries, -1);
D
David Teigland 已提交
1069 1070 1071 1072 1073

			if (!prev)
				prev = dent;

			moved = 1;
1074
		} else {
D
David Teigland 已提交
1075
			prev = dent;
1076
		}
D
David Teigland 已提交
1077
		dent = next;
1078
	} while (dent);
D
David Teigland 已提交
1079

1080
	oleaf->lf_depth = nleaf->lf_depth;
D
David Teigland 已提交
1081 1082

	error = gfs2_meta_inode_buffer(dip, &dibh);
1083
	if (!gfs2_assert_withdraw(GFS2_SB(&dip->i_inode), !error)) {
1084
		gfs2_trans_add_meta(dip->i_gl, dibh);
1085
		gfs2_add_inode_blocks(&dip->i_inode, 1);
1086
		gfs2_dinode_out(dip, dibh->b_data);
D
David Teigland 已提交
1087 1088 1089 1090 1091 1092 1093 1094
		brelse(dibh);
	}

	brelse(obh);
	brelse(nbh);

	return error;

1095
fail_lpfree:
D
David Teigland 已提交
1096 1097
	kfree(lp);

1098
fail_brelse:
D
David Teigland 已提交
1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113
	brelse(obh);
	brelse(nbh);
	return error;
}

/**
 * dir_double_exhash - Double size of ExHash table
 * @dip: The GFS2 dinode
 *
 * Returns: 0 on success, error code on failure
 */

static int dir_double_exhash(struct gfs2_inode *dip)
{
	struct buffer_head *dibh;
1114
	u32 hsize;
1115 1116 1117
	u32 hsize_bytes;
	__be64 *hc;
	__be64 *hc2, *h;
D
David Teigland 已提交
1118 1119 1120
	int x;
	int error = 0;

1121
	hsize = 1 << dip->i_depth;
1122
	hsize_bytes = hsize * sizeof(__be64);
D
David Teigland 已提交
1123

1124 1125 1126
	hc = gfs2_dir_get_hash_table(dip);
	if (IS_ERR(hc))
		return PTR_ERR(hc);
D
David Teigland 已提交
1127

1128 1129 1130 1131
	h = hc2 = kmalloc(hsize_bytes * 2, GFP_NOFS | __GFP_NOWARN);
	if (hc2 == NULL)
		hc2 = __vmalloc(hsize_bytes * 2, GFP_NOFS, PAGE_KERNEL);

1132
	if (!hc2)
1133
		return -ENOMEM;
D
David Teigland 已提交
1134

1135 1136 1137
	error = gfs2_meta_inode_buffer(dip, &dibh);
	if (error)
		goto out_kfree;
D
David Teigland 已提交
1138

1139 1140 1141 1142
	for (x = 0; x < hsize; x++) {
		*h++ = *hc;
		*h++ = *hc;
		hc++;
D
David Teigland 已提交
1143 1144
	}

1145 1146 1147
	error = gfs2_dir_write_data(dip, (char *)hc2, 0, hsize_bytes * 2);
	if (error != (hsize_bytes * 2))
		goto fail;
D
David Teigland 已提交
1148

1149 1150 1151 1152 1153 1154
	gfs2_dir_hash_inval(dip);
	dip->i_hash_cache = hc2;
	dip->i_depth++;
	gfs2_dinode_out(dip, dibh->b_data);
	brelse(dibh);
	return 0;
D
David Teigland 已提交
1155

1156
fail:
1157 1158 1159 1160 1161 1162
	/* Replace original hash table & size */
	gfs2_dir_write_data(dip, (char *)hc, 0, hsize_bytes);
	i_size_write(&dip->i_inode, hsize_bytes);
	gfs2_dinode_out(dip, dibh->b_data);
	brelse(dibh);
out_kfree:
1163 1164 1165 1166
	if (is_vmalloc_addr(hc2))
		vfree(hc2);
	else
		kfree(hc2);
D
David Teigland 已提交
1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182
	return error;
}

/**
 * compare_dents - compare directory entries by hash value
 * @a: first dent
 * @b: second dent
 *
 * When comparing the hash entries of @a to @b:
 *   gt: returns 1
 *   lt: returns -1
 *   eq: returns 0
 */

static int compare_dents(const void *a, const void *b)
{
1183
	const struct gfs2_dirent *dent_a, *dent_b;
1184
	u32 hash_a, hash_b;
D
David Teigland 已提交
1185 1186
	int ret = 0;

1187
	dent_a = *(const struct gfs2_dirent **)a;
1188
	hash_a = be32_to_cpu(dent_a->de_hash);
D
David Teigland 已提交
1189

1190
	dent_b = *(const struct gfs2_dirent **)b;
1191
	hash_b = be32_to_cpu(dent_b->de_hash);
D
David Teigland 已提交
1192 1193 1194 1195 1196 1197

	if (hash_a > hash_b)
		ret = 1;
	else if (hash_a < hash_b)
		ret = -1;
	else {
1198 1199
		unsigned int len_a = be16_to_cpu(dent_a->de_name_len);
		unsigned int len_b = be16_to_cpu(dent_b->de_name_len);
D
David Teigland 已提交
1200 1201 1202 1203 1204 1205

		if (len_a > len_b)
			ret = 1;
		else if (len_a < len_b)
			ret = -1;
		else
1206
			ret = memcmp(dent_a + 1, dent_b + 1, len_a);
D
David Teigland 已提交
1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229
	}

	return ret;
}

/**
 * do_filldir_main - read out directory entries
 * @dip: The GFS2 inode
 * @offset: The offset in the file to read from
 * @opaque: opaque data to pass to filldir
 * @filldir: The function to pass entries to
 * @darr: an array of struct gfs2_dirent pointers to read
 * @entries: the number of entries in darr
 * @copied: pointer to int that's non-zero if a entry has been copied out
 *
 * Jump through some hoops to make sure that if there are hash collsions,
 * they are read out at the beginning of a buffer.  We want to minimize
 * the possibility that they will fall into different readdir buffers or
 * that someone will want to seek to that location.
 *
 * Returns: errno, >0 on exception from filldir
 */

1230
static int do_filldir_main(struct gfs2_inode *dip, u64 *offset,
1231
			   void *opaque, filldir_t filldir,
1232
			   const struct gfs2_dirent **darr, u32 entries,
D
David Teigland 已提交
1233 1234
			   int *copied)
{
1235
	const struct gfs2_dirent *dent, *dent_next;
1236
	u64 off, off_next;
D
David Teigland 已提交
1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271
	unsigned int x, y;
	int run = 0;
	int error = 0;

	sort(darr, entries, sizeof(struct gfs2_dirent *), compare_dents, NULL);

	dent_next = darr[0];
	off_next = be32_to_cpu(dent_next->de_hash);
	off_next = gfs2_disk_hash2offset(off_next);

	for (x = 0, y = 1; x < entries; x++, y++) {
		dent = dent_next;
		off = off_next;

		if (y < entries) {
			dent_next = darr[y];
			off_next = be32_to_cpu(dent_next->de_hash);
			off_next = gfs2_disk_hash2offset(off_next);

			if (off < *offset)
				continue;
			*offset = off;

			if (off_next == off) {
				if (*copied && !run)
					return 1;
				run = 1;
			} else
				run = 0;
		} else {
			if (off < *offset)
				continue;
			*offset = off;
		}

1272
		error = filldir(opaque, (const char *)(dent + 1),
1273
				be16_to_cpu(dent->de_name_len),
1274
				off, be64_to_cpu(dent->de_inum.no_addr),
1275
				be16_to_cpu(dent->de_type));
D
David Teigland 已提交
1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290
		if (error)
			return 1;

		*copied = 1;
	}

	/* Increment the *offset by one, so the next time we come into the
	   do_filldir fxn, we get the next entry instead of the last one in the
	   current leaf */

	(*offset)++;

	return 0;
}

1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309
static void *gfs2_alloc_sort_buffer(unsigned size)
{
	void *ptr = NULL;

	if (size < KMALLOC_MAX_SIZE)
		ptr = kmalloc(size, GFP_NOFS | __GFP_NOWARN);
	if (!ptr)
		ptr = __vmalloc(size, GFP_NOFS, PAGE_KERNEL);
	return ptr;
}

static void gfs2_free_sort_buffer(void *ptr)
{
	if (is_vmalloc_addr(ptr))
		vfree(ptr);
	else
		kfree(ptr);
}

1310
static int gfs2_dir_read_leaf(struct inode *inode, u64 *offset, void *opaque,
1311 1312
			      filldir_t filldir, int *copied, unsigned *depth,
			      u64 leaf_no)
D
David Teigland 已提交
1313
{
1314
	struct gfs2_inode *ip = GFS2_I(inode);
1315
	struct gfs2_sbd *sdp = GFS2_SB(inode);
1316 1317
	struct buffer_head *bh;
	struct gfs2_leaf *lf;
1318
	unsigned entries = 0, entries2 = 0;
1319 1320 1321 1322 1323 1324 1325
	unsigned leaves = 0;
	const struct gfs2_dirent **darr, *dent;
	struct dirent_gather g;
	struct buffer_head **larr;
	int leaf = 0;
	int error, i;
	u64 lfn = leaf_no;
D
David Teigland 已提交
1326 1327

	do {
1328
		error = get_leaf(ip, lfn, &bh);
D
David Teigland 已提交
1329
		if (error)
1330 1331 1332 1333 1334 1335 1336 1337 1338
			goto out;
		lf = (struct gfs2_leaf *)bh->b_data;
		if (leaves == 0)
			*depth = be16_to_cpu(lf->lf_depth);
		entries += be16_to_cpu(lf->lf_entries);
		leaves++;
		lfn = be64_to_cpu(lf->lf_next);
		brelse(bh);
	} while(lfn);
D
David Teigland 已提交
1339 1340 1341 1342

	if (!entries)
		return 0;

1343
	error = -ENOMEM;
1344 1345 1346 1347 1348 1349
	/*
	 * The extra 99 entries are not normally used, but are a buffer
	 * zone in case the number of entries in the leaf is corrupt.
	 * 99 is the maximum number of entries that can fit in a single
	 * leaf block.
	 */
1350
	larr = gfs2_alloc_sort_buffer((leaves + entries + 99) * sizeof(void *));
1351 1352 1353 1354 1355 1356
	if (!larr)
		goto out;
	darr = (const struct gfs2_dirent **)(larr + leaves);
	g.pdent = darr;
	g.offset = 0;
	lfn = leaf_no;
D
David Teigland 已提交
1357

1358 1359
	do {
		error = get_leaf(ip, lfn, &bh);
D
David Teigland 已提交
1360
		if (error)
1361
			goto out_free;
1362 1363 1364
		lf = (struct gfs2_leaf *)bh->b_data;
		lfn = be64_to_cpu(lf->lf_next);
		if (lf->lf_entries) {
1365
			entries2 += be16_to_cpu(lf->lf_entries);
1366 1367 1368
			dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size,
						gfs2_dirent_gather, NULL, &g);
			error = PTR_ERR(dent);
1369
			if (IS_ERR(dent))
1370
				goto out_free;
1371
			if (entries2 != g.offset) {
1372 1373 1374 1375 1376
				fs_warn(sdp, "Number of entries corrupt in dir "
						"leaf %llu, entries2 (%u) != "
						"g.offset (%u)\n",
					(unsigned long long)bh->b_blocknr,
					entries2, g.offset);
1377 1378
					
				error = -EIO;
1379
				goto out_free;
1380 1381 1382
			}
			error = 0;
			larr[leaf++] = bh;
D
David Teigland 已提交
1383
		} else {
1384
			brelse(bh);
D
David Teigland 已提交
1385
		}
1386
	} while(lfn);
D
David Teigland 已提交
1387

1388
	BUG_ON(entries2 != entries);
1389
	error = do_filldir_main(ip, offset, opaque, filldir, darr,
D
David Teigland 已提交
1390
				entries, copied);
1391
out_free:
1392 1393
	for(i = 0; i < leaf; i++)
		brelse(larr[i]);
1394
	gfs2_free_sort_buffer(larr);
1395
out:
D
David Teigland 已提交
1396 1397 1398
	return error;
}

1399 1400
/**
 * gfs2_dir_readahead - Issue read-ahead requests for leaf blocks.
1401 1402 1403 1404
 *
 * Note: we can't calculate each index like dir_e_read can because we don't
 * have the leaf, and therefore we don't have the depth, and therefore we
 * don't have the length. So we have to just read enough ahead to make up
1405 1406
 * for the loss of information.
 */
1407 1408 1409 1410 1411 1412 1413 1414 1415 1416
static void gfs2_dir_readahead(struct inode *inode, unsigned hsize, u32 index,
			       struct file_ra_state *f_ra)
{
	struct gfs2_inode *ip = GFS2_I(inode);
	struct gfs2_glock *gl = ip->i_gl;
	struct buffer_head *bh;
	u64 blocknr = 0, last;
	unsigned count;

	/* First check if we've already read-ahead for the whole range. */
1417
	if (index + MAX_RA_BLOCKS < f_ra->start)
1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444
		return;

	f_ra->start = max((pgoff_t)index, f_ra->start);
	for (count = 0; count < MAX_RA_BLOCKS; count++) {
		if (f_ra->start >= hsize) /* if exceeded the hash table */
			break;

		last = blocknr;
		blocknr = be64_to_cpu(ip->i_hash_cache[f_ra->start]);
		f_ra->start++;
		if (blocknr == last)
			continue;

		bh = gfs2_getbuf(gl, blocknr, 1);
		if (trylock_buffer(bh)) {
			if (buffer_uptodate(bh)) {
				unlock_buffer(bh);
				brelse(bh);
				continue;
			}
			bh->b_end_io = end_buffer_read_sync;
			submit_bh(READA | REQ_META, bh);
			continue;
		}
		brelse(bh);
	}
}
1445

D
David Teigland 已提交
1446
/**
1447 1448 1449 1450 1451
 * dir_e_read - Reads the entries from a directory into a filldir buffer
 * @dip: dinode pointer
 * @offset: the hash of the last entry read shifted to the right once
 * @opaque: buffer for the filldir function to fill
 * @filldir: points to the filldir function to use
D
David Teigland 已提交
1452
 *
1453
 * Returns: errno
D
David Teigland 已提交
1454 1455
 */

1456
static int dir_e_read(struct inode *inode, u64 *offset, void *opaque,
1457
		      filldir_t filldir, struct file_ra_state *f_ra)
D
David Teigland 已提交
1458
{
1459
	struct gfs2_inode *dip = GFS2_I(inode);
1460 1461
	u32 hsize, len = 0;
	u32 hash, index;
A
Al Viro 已提交
1462
	__be64 *lp;
1463 1464
	int copied = 0;
	int error = 0;
1465
	unsigned depth = 0;
D
David Teigland 已提交
1466

1467
	hsize = 1 << dip->i_depth;
D
David Teigland 已提交
1468
	hash = gfs2_dir_offset2hash(*offset);
1469
	index = hash >> (32 - dip->i_depth);
D
David Teigland 已提交
1470

1471
	if (dip->i_hash_cache == NULL)
1472
		f_ra->start = 0;
1473 1474 1475
	lp = gfs2_dir_get_hash_table(dip);
	if (IS_ERR(lp))
		return PTR_ERR(lp);
D
David Teigland 已提交
1476

1477 1478
	gfs2_dir_readahead(inode, hsize, index, f_ra);

D
David Teigland 已提交
1479
	while (index < hsize) {
1480 1481
		error = gfs2_dir_read_leaf(inode, offset, opaque, filldir,
					   &copied, &depth,
1482
					   be64_to_cpu(lp[index]));
D
David Teigland 已提交
1483
		if (error)
1484
			break;
D
David Teigland 已提交
1485

1486
		len = 1 << (dip->i_depth - depth);
D
David Teigland 已提交
1487 1488 1489
		index = (index & ~(len - 1)) + len;
	}

1490 1491
	if (error > 0)
		error = 0;
D
David Teigland 已提交
1492 1493 1494
	return error;
}

1495
int gfs2_dir_read(struct inode *inode, u64 *offset, void *opaque,
1496
		  filldir_t filldir, struct file_ra_state *f_ra)
D
David Teigland 已提交
1497
{
1498
	struct gfs2_inode *dip = GFS2_I(inode);
1499
	struct gfs2_sbd *sdp = GFS2_SB(inode);
1500 1501
	struct dirent_gather g;
	const struct gfs2_dirent **darr, *dent;
D
David Teigland 已提交
1502 1503 1504 1505
	struct buffer_head *dibh;
	int copied = 0;
	int error;

1506
	if (!dip->i_entries)
1507 1508
		return 0;

1509
	if (dip->i_diskflags & GFS2_DIF_EXHASH)
1510
		return dir_e_read(inode, offset, opaque, filldir, f_ra);
1511

D
David Teigland 已提交
1512 1513 1514 1515 1516 1517 1518 1519 1520
	if (!gfs2_is_stuffed(dip)) {
		gfs2_consist_inode(dip);
		return -EIO;
	}

	error = gfs2_meta_inode_buffer(dip, &dibh);
	if (error)
		return error;

1521
	error = -ENOMEM;
1522
	/* 96 is max number of dirents which can be stuffed into an inode */
J
Josef Bacik 已提交
1523
	darr = kmalloc(96 * sizeof(struct gfs2_dirent *), GFP_NOFS);
1524 1525 1526 1527 1528 1529 1530 1531 1532
	if (darr) {
		g.pdent = darr;
		g.offset = 0;
		dent = gfs2_dirent_scan(inode, dibh->b_data, dibh->b_size,
					gfs2_dirent_gather, NULL, &g);
		if (IS_ERR(dent)) {
			error = PTR_ERR(dent);
			goto out;
		}
1533
		if (dip->i_entries != g.offset) {
1534
			fs_warn(sdp, "Number of entries corrupt in dir %llu, "
1535
				"ip->i_entries (%u) != g.offset (%u)\n",
1536
				(unsigned long long)dip->i_no_addr,
1537
				dip->i_entries,
1538 1539 1540 1541
				g.offset);
			error = -EIO;
			goto out;
		}
1542
		error = do_filldir_main(dip, offset, opaque, filldir, darr,
1543
					dip->i_entries, &copied);
1544 1545 1546 1547
out:
		kfree(darr);
	}

D
David Teigland 已提交
1548 1549 1550 1551 1552 1553 1554 1555 1556 1557
	if (error > 0)
		error = 0;

	brelse(dibh);

	return error;
}

/**
 * gfs2_dir_search - Search a directory
1558 1559 1560
 * @dip: The GFS2 dir inode
 * @name: The name we are looking up
 * @fail_on_exist: Fail if the name exists rather than looking it up
D
David Teigland 已提交
1561 1562 1563 1564 1565 1566 1567
 *
 * This routine searches a directory for a file or another directory.
 * Assumes a glock is held on dip.
 *
 * Returns: errno
 */

1568 1569
struct inode *gfs2_dir_search(struct inode *dir, const struct qstr *name,
			      bool fail_on_exist)
D
David Teigland 已提交
1570
{
1571 1572
	struct buffer_head *bh;
	struct gfs2_dirent *dent;
1573 1574
	u64 addr, formal_ino;
	u16 dtype;
1575 1576 1577 1578

	dent = gfs2_dirent_search(dir, name, gfs2_dirent_find, &bh);
	if (dent) {
		if (IS_ERR(dent))
1579
			return ERR_CAST(dent);
1580 1581 1582
		dtype = be16_to_cpu(dent->de_type);
		addr = be64_to_cpu(dent->de_inum.no_addr);
		formal_ino = be64_to_cpu(dent->de_inum.no_formal_ino);
1583
		brelse(bh);
1584 1585 1586
		if (fail_on_exist)
			return ERR_PTR(-EEXIST);
		return gfs2_inode_lookup(dir->i_sb, dtype, addr, formal_ino, 0);
1587 1588 1589 1590 1591 1592 1593 1594 1595 1596
	}
	return ERR_PTR(-ENOENT);
}

int gfs2_dir_check(struct inode *dir, const struct qstr *name,
		   const struct gfs2_inode *ip)
{
	struct buffer_head *bh;
	struct gfs2_dirent *dent;
	int ret = -ENOENT;
1597 1598 1599 1600 1601

	dent = gfs2_dirent_search(dir, name, gfs2_dirent_find, &bh);
	if (dent) {
		if (IS_ERR(dent))
			return PTR_ERR(dent);
1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616
		if (ip) {
			if (be64_to_cpu(dent->de_inum.no_addr) != ip->i_no_addr)
				goto out;
			if (be64_to_cpu(dent->de_inum.no_formal_ino) !=
			    ip->i_no_formal_ino)
				goto out;
			if (unlikely(IF2DT(ip->i_inode.i_mode) !=
			    be16_to_cpu(dent->de_type))) {
				gfs2_consist_inode(GFS2_I(dir));
				ret = -EIO;
				goto out;
			}
		}
		ret = 0;
out:
1617 1618
		brelse(bh);
	}
1619
	return ret;
1620 1621 1622 1623 1624
}

static int dir_new_leaf(struct inode *inode, const struct qstr *name)
{
	struct buffer_head *bh, *obh;
1625
	struct gfs2_inode *ip = GFS2_I(inode);
1626
	struct gfs2_leaf *leaf, *oleaf;
D
David Teigland 已提交
1627
	int error;
1628 1629
	u32 index;
	u64 bn;
D
David Teigland 已提交
1630

1631
	index = name->hash >> (32 - ip->i_depth);
1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644
	error = get_first_leaf(ip, index, &obh);
	if (error)
		return error;
	do {
		oleaf = (struct gfs2_leaf *)obh->b_data;
		bn = be64_to_cpu(oleaf->lf_next);
		if (!bn)
			break;
		brelse(obh);
		error = get_leaf(ip, bn, &obh);
		if (error)
			return error;
	} while(1);
D
David Teigland 已提交
1645

1646
	gfs2_trans_add_meta(ip->i_gl, obh);
1647 1648 1649 1650 1651 1652

	leaf = new_leaf(inode, &bh, be16_to_cpu(oleaf->lf_depth));
	if (!leaf) {
		brelse(obh);
		return -ENOSPC;
	}
1653
	oleaf->lf_next = cpu_to_be64(bh->b_blocknr);
1654 1655 1656 1657 1658 1659
	brelse(bh);
	brelse(obh);

	error = gfs2_meta_inode_buffer(ip, &bh);
	if (error)
		return error;
1660
	gfs2_trans_add_meta(ip->i_gl, bh);
1661
	gfs2_add_inode_blocks(&ip->i_inode, 1);
1662
	gfs2_dinode_out(ip, bh->b_data);
1663 1664
	brelse(bh);
	return 0;
D
David Teigland 已提交
1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676
}

/**
 * gfs2_dir_add - Add new filename into directory
 * @dip: The GFS2 inode
 * @filename: The new name
 * @inode: The inode number of the entry
 * @type: The type of the entry
 *
 * Returns: 0 on success, error code on failure
 */

1677
int gfs2_dir_add(struct inode *inode, const struct qstr *name,
1678
		 const struct gfs2_inode *nip)
D
David Teigland 已提交
1679
{
1680
	struct gfs2_inode *ip = GFS2_I(inode);
1681 1682 1683
	struct buffer_head *bh;
	struct gfs2_dirent *dent;
	struct gfs2_leaf *leaf;
D
David Teigland 已提交
1684 1685
	int error;

1686 1687 1688 1689 1690 1691 1692
	while(1) {
		dent = gfs2_dirent_search(inode, name, gfs2_dirent_find_space,
					  &bh);
		if (dent) {
			if (IS_ERR(dent))
				return PTR_ERR(dent);
			dent = gfs2_init_dirent(inode, dent, name, bh);
1693
			gfs2_inum_out(nip, dent);
1694
			dent->de_type = cpu_to_be16(IF2DT(nip->i_inode.i_mode));
1695
			if (ip->i_diskflags & GFS2_DIF_EXHASH) {
1696
				leaf = (struct gfs2_leaf *)bh->b_data;
M
Marcin Slusarz 已提交
1697
				be16_add_cpu(&leaf->lf_entries, 1);
1698 1699
			}
			brelse(bh);
1700
			ip->i_entries++;
1701
			ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
1702 1703
			if (S_ISDIR(nip->i_inode.i_mode))
				inc_nlink(&ip->i_inode);
1704
			mark_inode_dirty(inode);
1705 1706 1707
			error = 0;
			break;
		}
1708
		if (!(ip->i_diskflags & GFS2_DIF_EXHASH)) {
1709 1710 1711 1712 1713 1714 1715 1716
			error = dir_make_exhash(inode);
			if (error)
				break;
			continue;
		}
		error = dir_split_leaf(inode, name);
		if (error == 0)
			continue;
1717
		if (error < 0)
1718
			break;
1719
		if (ip->i_depth < GFS2_DIR_MAX_DEPTH) {
1720 1721 1722 1723
			error = dir_double_exhash(ip);
			if (error)
				break;
			error = dir_split_leaf(inode, name);
1724
			if (error < 0)
1725
				break;
1726 1727
			if (error == 0)
				continue;
1728 1729 1730 1731 1732 1733 1734
		}
		error = dir_new_leaf(inode, name);
		if (!error)
			continue;
		error = -ENOSPC;
		break;
	}
D
David Teigland 已提交
1735 1736 1737
	return error;
}

1738

D
David Teigland 已提交
1739 1740 1741 1742 1743 1744 1745 1746
/**
 * gfs2_dir_del - Delete a directory entry
 * @dip: The GFS2 inode
 * @filename: The filename
 *
 * Returns: 0 on success, error code on failure
 */

1747
int gfs2_dir_del(struct gfs2_inode *dip, const struct dentry *dentry)
D
David Teigland 已提交
1748
{
1749
	const struct qstr *name = &dentry->d_name;
1750 1751
	struct gfs2_dirent *dent, *prev = NULL;
	struct buffer_head *bh;
D
David Teigland 已提交
1752

1753 1754
	/* Returns _either_ the entry (if its first in block) or the
	   previous entry otherwise */
1755
	dent = gfs2_dirent_search(&dip->i_inode, name, gfs2_dirent_prev, &bh);
1756 1757 1758 1759 1760 1761 1762 1763 1764
	if (!dent) {
		gfs2_consist_inode(dip);
		return -EIO;
	}
	if (IS_ERR(dent)) {
		gfs2_consist_inode(dip);
		return PTR_ERR(dent);
	}
	/* If not first in block, adjust pointers accordingly */
1765
	if (gfs2_dirent_find(dent, name, NULL) == 0) {
1766 1767 1768 1769 1770
		prev = dent;
		dent = (struct gfs2_dirent *)((char *)dent + be16_to_cpu(prev->de_rec_len));
	}

	dirent_del(dip, bh, prev, dent);
1771
	if (dip->i_diskflags & GFS2_DIF_EXHASH) {
1772 1773 1774 1775 1776 1777
		struct gfs2_leaf *leaf = (struct gfs2_leaf *)bh->b_data;
		u16 entries = be16_to_cpu(leaf->lf_entries);
		if (!entries)
			gfs2_consist_inode(dip);
		leaf->lf_entries = cpu_to_be16(--entries);
	}
1778
	brelse(bh);
1779

1780
	if (!dip->i_entries)
1781
		gfs2_consist_inode(dip);
1782
	dip->i_entries--;
1783
	dip->i_inode.i_mtime = dip->i_inode.i_ctime = CURRENT_TIME;
1784 1785
	if (S_ISDIR(dentry->d_inode->i_mode))
		drop_nlink(&dip->i_inode);
1786
	mark_inode_dirty(&dip->i_inode);
D
David Teigland 已提交
1787

S
Steven Whitehouse 已提交
1788
	return 0;
D
David Teigland 已提交
1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803
}

/**
 * gfs2_dir_mvino - Change inode number of directory entry
 * @dip: The GFS2 inode
 * @filename:
 * @new_inode:
 *
 * This routine changes the inode number of a directory entry.  It's used
 * by rename to change ".." when a directory is moved.
 * Assumes a glock is held on dvp.
 *
 * Returns: errno
 */

1804
int gfs2_dir_mvino(struct gfs2_inode *dip, const struct qstr *filename,
1805
		   const struct gfs2_inode *nip, unsigned int new_type)
D
David Teigland 已提交
1806
{
1807 1808
	struct buffer_head *bh;
	struct gfs2_dirent *dent;
D
David Teigland 已提交
1809 1810
	int error;

1811
	dent = gfs2_dirent_search(&dip->i_inode, filename, gfs2_dirent_find, &bh);
1812 1813 1814 1815 1816 1817
	if (!dent) {
		gfs2_consist_inode(dip);
		return -EIO;
	}
	if (IS_ERR(dent))
		return PTR_ERR(dent);
D
David Teigland 已提交
1818

1819
	gfs2_trans_add_meta(dip->i_gl, bh);
1820
	gfs2_inum_out(nip, dent);
1821 1822
	dent->de_type = cpu_to_be16(new_type);

1823
	if (dip->i_diskflags & GFS2_DIF_EXHASH) {
1824 1825 1826 1827
		brelse(bh);
		error = gfs2_meta_inode_buffer(dip, &bh);
		if (error)
			return error;
1828
		gfs2_trans_add_meta(dip->i_gl, bh);
1829 1830
	}

1831
	dip->i_inode.i_mtime = dip->i_inode.i_ctime = CURRENT_TIME;
1832
	gfs2_dinode_out(dip, bh->b_data);
1833 1834
	brelse(bh);
	return 0;
D
David Teigland 已提交
1835 1836 1837 1838 1839 1840 1841 1842
}

/**
 * leaf_dealloc - Deallocate a directory leaf
 * @dip: the directory
 * @index: the hash table offset in the directory
 * @len: the number of pointers to this leaf
 * @leaf_no: the leaf number
1843
 * @leaf_bh: buffer_head for the starting leaf
1844
 * last_dealloc: 1 if this is the final dealloc for the leaf, else 0
D
David Teigland 已提交
1845 1846 1847 1848
 *
 * Returns: errno
 */

1849
static int leaf_dealloc(struct gfs2_inode *dip, u32 index, u32 len,
1850 1851
			u64 leaf_no, struct buffer_head *leaf_bh,
			int last_dealloc)
D
David Teigland 已提交
1852
{
1853
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
1854
	struct gfs2_leaf *tmp_leaf;
D
David Teigland 已提交
1855 1856
	struct gfs2_rgrp_list rlist;
	struct buffer_head *bh, *dibh;
1857
	u64 blk, nblk;
D
David Teigland 已提交
1858 1859
	unsigned int rg_blocks = 0, l_blocks = 0;
	char *ht;
1860
	unsigned int x, size = len * sizeof(u64);
D
David Teigland 已提交
1861 1862
	int error;

1863 1864 1865 1866
	error = gfs2_rindex_update(sdp);
	if (error)
		return error;

D
David Teigland 已提交
1867 1868
	memset(&rlist, 0, sizeof(struct gfs2_rgrp_list));

J
Josef Bacik 已提交
1869
	ht = kzalloc(size, GFP_NOFS);
1870 1871
	if (ht == NULL)
		ht = vzalloc(size);
D
David Teigland 已提交
1872 1873 1874
	if (!ht)
		return -ENOMEM;

1875
	error = gfs2_quota_hold(dip, NO_UID_QUOTA_CHANGE, NO_GID_QUOTA_CHANGE);
D
David Teigland 已提交
1876
	if (error)
1877
		goto out;
D
David Teigland 已提交
1878 1879

	/*  Count the number of leaves  */
1880
	bh = leaf_bh;
D
David Teigland 已提交
1881

1882
	for (blk = leaf_no; blk; blk = nblk) {
1883 1884 1885 1886 1887
		if (blk != leaf_no) {
			error = get_leaf(dip, blk, &bh);
			if (error)
				goto out_rlist;
		}
1888 1889
		tmp_leaf = (struct gfs2_leaf *)bh->b_data;
		nblk = be64_to_cpu(tmp_leaf->lf_next);
1890 1891
		if (blk != leaf_no)
			brelse(bh);
D
David Teigland 已提交
1892

1893
		gfs2_rlist_add(dip, &rlist, blk);
D
David Teigland 已提交
1894 1895 1896
		l_blocks++;
	}

1897
	gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE);
D
David Teigland 已提交
1898 1899 1900

	for (x = 0; x < rlist.rl_rgrps; x++) {
		struct gfs2_rgrpd *rgd;
1901
		rgd = rlist.rl_ghs[x].gh_gl->gl_object;
1902
		rg_blocks += rgd->rd_length;
D
David Teigland 已提交
1903 1904 1905 1906 1907 1908 1909
	}

	error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);
	if (error)
		goto out_rlist;

	error = gfs2_trans_begin(sdp,
1910
			rg_blocks + (DIV_ROUND_UP(size, sdp->sd_jbsize) + 1) +
D
David Teigland 已提交
1911 1912 1913 1914
			RES_DINODE + RES_STATFS + RES_QUOTA, l_blocks);
	if (error)
		goto out_rg_gunlock;

1915 1916
	bh = leaf_bh;

1917
	for (blk = leaf_no; blk; blk = nblk) {
1918 1919 1920 1921 1922
		if (blk != leaf_no) {
			error = get_leaf(dip, blk, &bh);
			if (error)
				goto out_end_trans;
		}
1923 1924
		tmp_leaf = (struct gfs2_leaf *)bh->b_data;
		nblk = be64_to_cpu(tmp_leaf->lf_next);
1925 1926
		if (blk != leaf_no)
			brelse(bh);
D
David Teigland 已提交
1927 1928

		gfs2_free_meta(dip, blk, 1);
1929
		gfs2_add_inode_blocks(&dip->i_inode, -1);
D
David Teigland 已提交
1930 1931
	}

1932
	error = gfs2_dir_write_data(dip, ht, index * sizeof(u64), size);
D
David Teigland 已提交
1933 1934 1935 1936 1937 1938 1939 1940 1941 1942
	if (error != size) {
		if (error >= 0)
			error = -EIO;
		goto out_end_trans;
	}

	error = gfs2_meta_inode_buffer(dip, &dibh);
	if (error)
		goto out_end_trans;

1943
	gfs2_trans_add_meta(dip->i_gl, dibh);
1944 1945 1946 1947
	/* On the last dealloc, make this a regular file in case we crash.
	   (We don't want to free these blocks a second time.)  */
	if (last_dealloc)
		dip->i_inode.i_mode = S_IFREG;
1948
	gfs2_dinode_out(dip, dibh->b_data);
D
David Teigland 已提交
1949 1950
	brelse(dibh);

1951
out_end_trans:
D
David Teigland 已提交
1952
	gfs2_trans_end(sdp);
1953
out_rg_gunlock:
D
David Teigland 已提交
1954
	gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);
1955
out_rlist:
D
David Teigland 已提交
1956 1957
	gfs2_rlist_free(&rlist);
	gfs2_quota_unhold(dip);
1958
out:
1959 1960 1961 1962
	if (is_vmalloc_addr(ht))
		vfree(ht);
	else
		kfree(ht);
D
David Teigland 已提交
1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977
	return error;
}

/**
 * gfs2_dir_exhash_dealloc - free all the leaf blocks in a directory
 * @dip: the directory
 *
 * Dealloc all on-disk directory leaves to FREEMETA state
 * Change on-disk inode type to "regular file"
 *
 * Returns: errno
 */

int gfs2_dir_exhash_dealloc(struct gfs2_inode *dip)
{
1978 1979 1980 1981 1982 1983 1984 1985 1986 1987
	struct buffer_head *bh;
	struct gfs2_leaf *leaf;
	u32 hsize, len;
	u32 index = 0, next_index;
	__be64 *lp;
	u64 leaf_no;
	int error = 0, last;

	hsize = 1 << dip->i_depth;

1988 1989 1990
	lp = gfs2_dir_get_hash_table(dip);
	if (IS_ERR(lp))
		return PTR_ERR(lp);
1991 1992

	while (index < hsize) {
1993
		leaf_no = be64_to_cpu(lp[index]);
1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020
		if (leaf_no) {
			error = get_leaf(dip, leaf_no, &bh);
			if (error)
				goto out;
			leaf = (struct gfs2_leaf *)bh->b_data;
			len = 1 << (dip->i_depth - be16_to_cpu(leaf->lf_depth));

			next_index = (index & ~(len - 1)) + len;
			last = ((next_index >= hsize) ? 1 : 0);
			error = leaf_dealloc(dip, index, len, leaf_no, bh,
					     last);
			brelse(bh);
			if (error)
				goto out;
			index = next_index;
		} else
			index++;
	}

	if (index != hsize) {
		gfs2_consist_inode(dip);
		error = -EIO;
	}

out:

	return error;
D
David Teigland 已提交
2021 2022 2023 2024 2025 2026 2027
}

/**
 * gfs2_diradd_alloc_required - find if adding entry will require an allocation
 * @ip: the file being written to
 * @filname: the filename that's going to be added
 *
2028
 * Returns: 1 if alloc required, 0 if not, -ve on error
D
David Teigland 已提交
2029 2030
 */

2031
int gfs2_diradd_alloc_required(struct inode *inode, const struct qstr *name)
D
David Teigland 已提交
2032
{
2033 2034
	struct gfs2_dirent *dent;
	struct buffer_head *bh;
D
David Teigland 已提交
2035

2036
	dent = gfs2_dirent_search(inode, name, gfs2_dirent_find_space, &bh);
2037
	if (!dent) {
2038
		return 1;
2039
	}
2040 2041 2042 2043
	if (IS_ERR(dent))
		return PTR_ERR(dent);
	brelse(bh);
	return 0;
D
David Teigland 已提交
2044 2045
}