dir.c 47.3 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 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
 * 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
 *
 * dip->i_di.di_flags & GFS2_DIF_EXHASH is true
 *
 * 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>
63
#include <linux/lm_interface.h>
D
David Teigland 已提交
64 65

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

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

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

83
typedef int (*leaf_call_t) (struct gfs2_inode *dip, u32 index, u32 len,
84 85 86
			    u64 leaf_no, void *data);
typedef int (*gfs2_dscan_t)(const struct gfs2_dirent *dent,
			    const struct qstr *name, void *opaque);
D
David Teigland 已提交
87

88

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

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

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

S
Steven Whitehouse 已提交
108
	error = gfs2_meta_read(ip->i_gl, block, DIO_WAIT, &bh);
109 110
	if (error)
		return error;
111
	if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), bh, GFS2_METATYPE_JD)) {
112 113 114 115 116 117
		brelse(bh);
		return -EIO;
	}
	*bhp = bh;
	return 0;
}
118 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;

	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
130
	memcpy(dibh->b_data + offset + sizeof(struct gfs2_dinode), buf, size);
131 132
	if (ip->i_disksize < offset + size)
		ip->i_disksize = offset + size;
133
	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
134
	gfs2_dinode_out(ip, dibh->b_data);
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152

	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,
153
			       u64 offset, unsigned int size)
154
{
155
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
156
	struct buffer_head *dibh;
157 158
	u64 lblock, dblock;
	u32 extlen = 0;
159 160 161
	unsigned int o;
	int copied = 0;
	int error = 0;
162
	int new = 0;
163 164 165 166 167 168

	if (!size)
		return 0;

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

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

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

	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;
194
			error = gfs2_extent_map(&ip->i_inode, lblock, &new,
S
Steven Whitehouse 已提交
195
						&dblock, &extlen);
196 197 198 199 200 201 202
			if (error)
				goto fail;
			error = -EIO;
			if (gfs2_assert_withdraw(sdp, dblock))
				goto fail;
		}

203 204 205 206 207
		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);

208 209 210 211 212 213 214
		if (error)
			goto fail;

		gfs2_trans_add_bh(ip->i_gl, bh, 1);
		memcpy(bh->b_data + o, buf, amount);
		brelse(bh);

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

		o = sizeof(struct gfs2_meta_header);
	}

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

229 230
	if (ip->i_disksize < offset + copied)
		ip->i_disksize = offset + copied;
231
	ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
232 233

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

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

static int gfs2_dir_read_stuffed(struct gfs2_inode *ip, char *buf,
S
Steven Whitehouse 已提交
245
				 u64 offset, unsigned int size)
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269
{
	struct buffer_head *dibh;
	int error;

	error = gfs2_meta_inode_buffer(ip, &dibh);
	if (!error) {
		offset += sizeof(struct gfs2_dinode);
		memcpy(buf, dibh->b_data + offset, size);
		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
 * @offset: File offset to begin jdata_readng from
 * @size: Amount of data to transfer
 *
 * Returns: The amount of data actually copied or the error
 */
S
Steven Whitehouse 已提交
270 271
static int gfs2_dir_read_data(struct gfs2_inode *ip, char *buf, u64 offset,
			      unsigned int size, unsigned ra)
272
{
273
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
274 275
	u64 lblock, dblock;
	u32 extlen = 0;
276 277 278 279
	unsigned int o;
	int copied = 0;
	int error = 0;

280
	if (offset >= ip->i_disksize)
281 282
		return 0;

283 284
	if (offset + size > ip->i_disksize)
		size = ip->i_disksize - offset;
285 286 287 288 289

	if (!size)
		return 0;

	if (gfs2_is_stuffed(ip))
S
Steven Whitehouse 已提交
290
		return gfs2_dir_read_stuffed(ip, buf, offset, size);
291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308

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

	lblock = offset;
	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;
309
			error = gfs2_extent_map(&ip->i_inode, lblock, &new,
S
Steven Whitehouse 已提交
310
						&dblock, &extlen);
S
Steven Whitehouse 已提交
311
			if (error || !dblock)
312
				goto fail;
S
Steven Whitehouse 已提交
313 314 315 316
			BUG_ON(extlen < 1);
			if (!ra)
				extlen = 1;
			bh = gfs2_meta_ra(ip->i_gl, dblock, extlen);
317
		} else {
S
Steven Whitehouse 已提交
318
			error = gfs2_meta_read(ip->i_gl, dblock, DIO_WAIT, &bh);
319 320
			if (error)
				goto fail;
S
Steven Whitehouse 已提交
321 322 323 324 325 326 327 328
		}
		error = gfs2_metatype_check(sdp, bh, GFS2_METATYPE_JD);
		if (error) {
			brelse(bh);
			goto fail;
		}
		dblock++;
		extlen--;
329 330
		memcpy(buf, bh->b_data + o, amount);
		brelse(bh);
331
		buf += amount;
332 333 334 335 336 337 338 339 340 341
		copied += amount;
		lblock++;
		o = sizeof(struct gfs2_meta_header);
	}

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

342 343 344 345 346
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;
}

347 348 349
static inline int __gfs2_dirent_find(const struct gfs2_dirent *dent,
				     const struct qstr *name, int ret)
{
350
	if (!gfs2_dirent_sentinel(dent) &&
351 352
	    be32_to_cpu(dent->de_hash) == name->hash &&
	    be16_to_cpu(dent->de_name_len) == name->len &&
353
	    memcmp(dent+1, name->name, name->len) == 0)
354 355 356 357 358
		return ret;
	return 0;
}

static int gfs2_dirent_find(const struct gfs2_dirent *dent,
359 360
			    const struct qstr *name,
			    void *opaque)
361 362 363 364 365
{
	return __gfs2_dirent_find(dent, name, 1);
}

static int gfs2_dirent_prev(const struct gfs2_dirent *dent,
366 367
			    const struct qstr *name,
			    void *opaque)
368 369 370 371 372 373 374
{
	return __gfs2_dirent_find(dent, name, 2);
}

/*
 * name->name holds ptr to start of block.
 * name->len holds size of block.
D
David Teigland 已提交
375
 */
376
static int gfs2_dirent_last(const struct gfs2_dirent *dent,
377 378
			    const struct qstr *name,
			    void *opaque)
379 380 381 382 383 384 385
{
	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 已提交
386

387
static int gfs2_dirent_find_space(const struct gfs2_dirent *dent,
388 389
				  const struct qstr *name,
				  void *opaque)
D
David Teigland 已提交
390
{
391 392 393 394
	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);

395
	if (gfs2_dirent_sentinel(dent))
396
		actual = GFS2_DIRENT_SIZE(0);
J
Jan Engelhardt 已提交
397
	if (totlen - actual >= required)
398 399 400 401
		return 1;
	return 0;
}

402 403 404 405 406 407 408 409 410 411
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;
412
	if (!gfs2_dirent_sentinel(dent)) {
413 414 415 416 417
		g->pdent[g->offset++] = dent;
	}
	return 0;
}

418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439
/*
 * 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";
440
	if (unlikely(!first && gfs2_dirent_sentinel(dent)))
441 442
		goto error;
	msg = "name length is greater than space in dirent";
443
	if (!gfs2_dirent_sentinel(dent) &&
444 445 446 447 448 449 450 451
	    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 已提交
452 453
}

454
static int gfs2_dirent_offset(const void *buf)
455
{
456 457
	const struct gfs2_meta_header *h = buf;
	int offset;
458 459 460

	BUG_ON(buf == NULL);

461
	switch(be32_to_cpu(h->mh_type)) {
462 463 464 465 466 467 468 469 470
	case GFS2_METATYPE_LF:
		offset = sizeof(struct gfs2_leaf);
		break;
	case GFS2_METATYPE_DI:
		offset = sizeof(struct gfs2_dinode);
		break;
	default:
		goto wrong_type;
	}
471 472 473
	return offset;
wrong_type:
	printk(KERN_WARNING "gfs2_scan_dirent: wrong block type %u\n",
474
	       be32_to_cpu(h->mh_type));
475 476 477
	return -1;
}

478
static struct gfs2_dirent *gfs2_dirent_scan(struct inode *inode, void *buf,
479 480 481 482 483 484 485 486
					    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;
487

488 489 490 491 492
	ret = gfs2_dirent_offset(buf);
	if (ret < 0)
		goto consist_inode;

	offset = ret;
493
	prev = NULL;
494
	dent = buf + offset;
495 496 497 498
	size = be16_to_cpu(dent->de_rec_len);
	if (gfs2_check_dirent(dent, offset, size, len, 1))
		goto consist_inode;
	do {
499
		ret = scan(dent, name, opaque);
500 501 502 503 504 505
		if (ret)
			break;
		offset += size;
		if (offset == len)
			break;
		prev = dent;
506
		dent = buf + offset;
507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524
		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:
525
	gfs2_consist_inode(GFS2_I(inode));
526 527 528 529
	return ERR_PTR(-EIO);
}


D
David Teigland 已提交
530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545
/**
 * dirent_first - Return the first dirent
 * @dip: the directory
 * @bh: The buffer
 * @dent: Pointer to list of dirents
 *
 * return first dirent whether bh points to leaf or stuffed dinode
 *
 * Returns: IS_LEAF, IS_DINODE, or -errno
 */

static int dirent_first(struct gfs2_inode *dip, struct buffer_head *bh,
			struct gfs2_dirent **dent)
{
	struct gfs2_meta_header *h = (struct gfs2_meta_header *)bh->b_data;

546
	if (be32_to_cpu(h->mh_type) == GFS2_METATYPE_LF) {
547
		if (gfs2_meta_check(GFS2_SB(&dip->i_inode), bh))
D
David Teigland 已提交
548 549 550 551 552
			return -EIO;
		*dent = (struct gfs2_dirent *)(bh->b_data +
					       sizeof(struct gfs2_leaf));
		return IS_LEAF;
	} else {
553
		if (gfs2_metatype_check(GFS2_SB(&dip->i_inode), bh, GFS2_METATYPE_DI))
D
David Teigland 已提交
554 555 556 557 558 559 560
			return -EIO;
		*dent = (struct gfs2_dirent *)(bh->b_data +
					       sizeof(struct gfs2_dinode));
		return IS_DINODE;
	}
}

561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
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 已提交
579 580 581 582 583 584 585 586 587 588 589 590
/**
 * 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)
{
591 592 593
	struct gfs2_dirent *cur = *dent, *tmp;
	char *bh_end = bh->b_data + bh->b_size;
	int ret;
D
David Teigland 已提交
594

595 596 597
	ret = dirent_check_reclen(dip, cur, bh_end);
	if (ret < 0)
		return ret;
598

599 600 601 602
	tmp = (void *)cur + ret;
	ret = dirent_check_reclen(dip, tmp, bh_end);
	if (ret == -EIO)
		return ret;
603

D
David Teigland 已提交
604
        /* Only the first dent could ever have de_inum.no_addr == 0 */
605
	if (gfs2_dirent_sentinel(tmp)) {
D
David Teigland 已提交
606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625
		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)
{
626
	u16 cur_rec_len, prev_rec_len;
D
David Teigland 已提交
627

628
	if (gfs2_dirent_sentinel(cur)) {
D
David Teigland 已提交
629 630 631 632
		gfs2_consist_inode(dip);
		return;
	}

633
	gfs2_trans_add_bh(dip->i_gl, bh, 1);
D
David Teigland 已提交
634 635 636 637 638 639

	/* 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) {
640 641
		cur->de_inum.no_addr = 0;
		cur->de_inum.no_formal_ino = 0;
D
David Teigland 已提交
642 643 644 645 646
		return;
	}

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

647 648
	prev_rec_len = be16_to_cpu(prev->de_rec_len);
	cur_rec_len = be16_to_cpu(cur->de_rec_len);
D
David Teigland 已提交
649 650 651 652 653 654 655

	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;
656
	prev->de_rec_len = cpu_to_be16(prev_rec_len);
D
David Teigland 已提交
657 658
}

659 660 661
/*
 * Takes a dent from which to grab space as an argument. Returns the
 * newly created dent.
D
David Teigland 已提交
662
 */
663 664 665 666
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 已提交
667
{
668
	struct gfs2_inode *ip = GFS2_I(inode);
669 670 671
	struct gfs2_dirent *ndent;
	unsigned offset = 0, totlen;

672
	if (!gfs2_dirent_sentinel(dent))
673 674 675 676 677 678 679 680
		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);
	gfs2_trans_add_bh(ip->i_gl, bh, 1);
	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 已提交
681 682
}

683 684 685
static struct gfs2_dirent *gfs2_dirent_alloc(struct inode *inode,
					     struct buffer_head *bh,
					     const struct qstr *name)
D
David Teigland 已提交
686 687
{
	struct gfs2_dirent *dent;
688
	dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size,
689
				gfs2_dirent_find_space, name, NULL);
690 691 692
	if (!dent || IS_ERR(dent))
		return dent;
	return gfs2_init_dirent(inode, dent, name, bh);
D
David Teigland 已提交
693 694
}

695
static int get_leaf(struct gfs2_inode *dip, u64 leaf_no,
D
David Teigland 已提交
696 697 698 699
		    struct buffer_head **bhp)
{
	int error;

S
Steven Whitehouse 已提交
700
	error = gfs2_meta_read(dip->i_gl, leaf_no, DIO_WAIT, bhp);
701 702
	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 已提交
703
		error = -EIO;
704
	}
D
David Teigland 已提交
705 706 707 708 709 710 711 712 713 714 715 716 717

	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
 */

718 719
static int get_leaf_nr(struct gfs2_inode *dip, u32 index,
		       u64 *leaf_out)
D
David Teigland 已提交
720
{
A
Al Viro 已提交
721
	__be64 leaf_no;
D
David Teigland 已提交
722 723
	int error;

724
	error = gfs2_dir_read_data(dip, (char *)&leaf_no,
A
Al Viro 已提交
725 726
				    index * sizeof(__be64),
				    sizeof(__be64), 0);
727
	if (error != sizeof(u64))
D
David Teigland 已提交
728 729 730 731 732 733 734
		return (error < 0) ? error : -EIO;

	*leaf_out = be64_to_cpu(leaf_no);

	return 0;
}

735
static int get_first_leaf(struct gfs2_inode *dip, u32 index,
D
David Teigland 已提交
736 737
			  struct buffer_head **bh_out)
{
738
	u64 leaf_no;
D
David Teigland 已提交
739 740 741 742 743 744 745 746 747
	int error;

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

	return error;
}

748 749 750 751
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 已提交
752
{
753 754
	struct buffer_head *bh;
	struct gfs2_dirent *dent;
755
	struct gfs2_inode *ip = GFS2_I(inode);
D
David Teigland 已提交
756 757
	int error;

758 759
	if (ip->i_di.di_flags & GFS2_DIF_EXHASH) {
		struct gfs2_leaf *leaf;
760
		unsigned hsize = 1 << ip->i_depth;
761 762
		unsigned index;
		u64 ln;
763
		if (hsize * sizeof(u64) != ip->i_disksize) {
764 765 766
			gfs2_consist_inode(ip);
			return ERR_PTR(-EIO);
		}
767

768
		index = name->hash >> (32 - ip->i_depth);
769 770 771 772 773
		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,
774
						scan, name, NULL);
775 776 777 778
			if (dent)
				goto got_dent;
			leaf = (struct gfs2_leaf *)bh->b_data;
			ln = be64_to_cpu(leaf->lf_next);
779
			brelse(bh);
780 781
			if (!ln)
				break;
782

783 784
			error = get_leaf(ip, ln, &bh);
		} while(!error);
D
David Teigland 已提交
785

786
		return error ? ERR_PTR(error) : NULL;
D
David Teigland 已提交
787 788
	}

789

790 791 792
	error = gfs2_meta_inode_buffer(ip, &bh);
	if (error)
		return ERR_PTR(error);
793
	dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size, scan, name, NULL);
794
got_dent:
795
	if (unlikely(dent == NULL || IS_ERR(dent))) {
796 797 798
		brelse(bh);
		bh = NULL;
	}
799 800 801
	*pbh = bh;
	return dent;
}
D
David Teigland 已提交
802

803 804
static struct gfs2_leaf *new_leaf(struct inode *inode, struct buffer_head **pbh, u16 depth)
{
805
	struct gfs2_inode *ip = GFS2_I(inode);
806 807
	unsigned int n = 1;
	u64 bn = gfs2_alloc_block(ip, &n);
808 809 810
	struct buffer_head *bh = gfs2_meta_new(ip->i_gl, bn);
	struct gfs2_leaf *leaf;
	struct gfs2_dirent *dent;
811
	struct qstr name = { .name = "", .len = 0, .hash = 0 };
812 813
	if (!bh)
		return NULL;
814
	gfs2_trans_add_unrevoke(GFS2_SB(inode), bn, 1);
815 816 817 818
	gfs2_trans_add_bh(ip->i_gl, bh, 1);
	gfs2_metatype_set(bh, GFS2_METATYPE_LF, GFS2_FORMAT_LF);
	leaf = (struct gfs2_leaf *)bh->b_data;
	leaf->lf_depth = cpu_to_be16(depth);
819
	leaf->lf_entries = 0;
820
	leaf->lf_dirent_format = cpu_to_be32(GFS2_FORMAT_DE);
821
	leaf->lf_next = 0;
822 823
	memset(leaf->lf_reserved, 0, sizeof(leaf->lf_reserved));
	dent = (struct gfs2_dirent *)(leaf+1);
824
	gfs2_qstr2dirent(&name, bh->b_size - sizeof(struct gfs2_leaf), dent);
825 826
	*pbh = bh;
	return leaf;
D
David Teigland 已提交
827 828 829 830 831 832 833 834 835
}

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

836
static int dir_make_exhash(struct inode *inode)
D
David Teigland 已提交
837
{
838 839
	struct gfs2_inode *dip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
D
David Teigland 已提交
840
	struct gfs2_dirent *dent;
841
	struct qstr args;
D
David Teigland 已提交
842 843 844
	struct buffer_head *bh, *dibh;
	struct gfs2_leaf *leaf;
	int y;
845
	u32 x;
A
Al Viro 已提交
846 847
	__be64 *lp;
	u64 bn;
D
David Teigland 已提交
848 849 850 851 852 853 854 855
	int error;

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

	/*  Turn over a new leaf  */

856 857 858 859
	leaf = new_leaf(inode, &bh, 0);
	if (!leaf)
		return -ENOSPC;
	bn = bh->b_blocknr;
D
David Teigland 已提交
860

861 862
	gfs2_assert(sdp, dip->i_entries < (1 << 16));
	leaf->lf_entries = cpu_to_be16(dip->i_entries);
D
David Teigland 已提交
863 864 865 866 867 868 869 870 871

	/*  Copy dirents  */

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

	/*  Find last entry  */

	x = 0;
872 873 874
	args.len = bh->b_size - sizeof(struct gfs2_dinode) +
		   sizeof(struct gfs2_leaf);
	args.name = bh->b_data;
875
	dent = gfs2_dirent_scan(&dip->i_inode, bh->b_data, bh->b_size,
876
				gfs2_dirent_last, &args, NULL);
877 878 879 880 881 882 883 884 885
	if (!dent) {
		brelse(bh);
		brelse(dibh);
		return -EIO;
	}
	if (IS_ERR(dent)) {
		brelse(bh);
		brelse(dibh);
		return PTR_ERR(dent);
D
David Teigland 已提交
886 887 888 889 890
	}

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

891
	dent->de_rec_len = cpu_to_be16(be16_to_cpu(dent->de_rec_len) +
D
David Teigland 已提交
892
		sizeof(struct gfs2_dinode) -
893
		sizeof(struct gfs2_leaf));
D
David Teigland 已提交
894 895 896 897 898 899

	brelse(bh);

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

900
	gfs2_trans_add_bh(dip->i_gl, dibh, 1);
D
David Teigland 已提交
901 902
	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));

A
Al Viro 已提交
903
	lp = (__be64 *)(dibh->b_data + sizeof(struct gfs2_dinode));
D
David Teigland 已提交
904 905 906 907

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

908
	dip->i_disksize = sdp->sd_sb.sb_bsize / 2;
909
	gfs2_add_inode_blocks(&dip->i_inode, 1);
D
David Teigland 已提交
910 911 912
	dip->i_di.di_flags |= GFS2_DIF_EXHASH;

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

915
	gfs2_dinode_out(dip, dibh->b_data);
D
David Teigland 已提交
916 917 918 919 920 921 922 923 924 925 926 927 928 929 930

	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
 */

931
static int dir_split_leaf(struct inode *inode, const struct qstr *name)
D
David Teigland 已提交
932
{
933
	struct gfs2_inode *dip = GFS2_I(inode);
D
David Teigland 已提交
934 935
	struct buffer_head *nbh, *obh, *dibh;
	struct gfs2_leaf *nleaf, *oleaf;
936
	struct gfs2_dirent *dent = NULL, *prev = NULL, *next = NULL, *new;
937
	u32 start, len, half_len, divider;
A
Al Viro 已提交
938 939
	u64 bn, leaf_no;
	__be64 *lp;
940
	u32 index;
D
David Teigland 已提交
941 942 943
	int x, moved = 0;
	int error;

944
	index = name->hash >> (32 - dip->i_depth);
945 946 947
	error = get_leaf_nr(dip, index, &leaf_no);
	if (error)
		return error;
D
David Teigland 已提交
948 949 950 951

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

	oleaf = (struct gfs2_leaf *)obh->b_data;
955
	if (dip->i_depth == be16_to_cpu(oleaf->lf_depth)) {
956 957 958 959 960
		brelse(obh);
		return 1; /* can't split */
	}

	gfs2_trans_add_bh(dip->i_gl, obh, 1);
D
David Teigland 已提交
961

962 963 964 965 966 967
	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 已提交
968

969
	/*  Compute the start and len of leaf pointers in the hash table.  */
970
	len = 1 << (dip->i_depth - be16_to_cpu(oleaf->lf_depth));
D
David Teigland 已提交
971 972
	half_len = len >> 1;
	if (!half_len) {
973
		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 已提交
974 975 976 977 978 979 980 981 982 983
		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. */
A
Al Viro 已提交
984
	lp = kmalloc(half_len * sizeof(__be64), GFP_NOFS | __GFP_NOFAIL);
D
David Teigland 已提交
985 986 987 988
	/*  Change the pointers  */
	for (x = 0; x < half_len; x++)
		lp[x] = cpu_to_be64(bn);

989 990 991
	error = gfs2_dir_write_data(dip, (char *)lp, start * sizeof(u64),
				    half_len * sizeof(u64));
	if (error != half_len * sizeof(u64)) {
D
David Teigland 已提交
992 993 994 995 996 997 998 999
		if (error >= 0)
			error = -EIO;
		goto fail_lpfree;
	}

	kfree(lp);

	/*  Compute the divider  */
1000
	divider = (start + half_len) << (32 - dip->i_depth);
D
David Teigland 已提交
1001 1002 1003 1004 1005 1006 1007 1008 1009

	/*  Copy the entries  */
	dirent_first(dip, obh, &dent);

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

1010
		if (!gfs2_dirent_sentinel(dent) &&
D
David Teigland 已提交
1011
		    be32_to_cpu(dent->de_hash) < divider) {
1012 1013 1014 1015
			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);
1016
			new = gfs2_dirent_alloc(inode, nbh, &str);
1017 1018 1019 1020
			if (IS_ERR(new)) {
				error = PTR_ERR(new);
				break;
			}
D
David Teigland 已提交
1021 1022 1023

			new->de_inum = dent->de_inum; /* No endian worries */
			new->de_type = dent->de_type; /* No endian worries */
M
Marcin Slusarz 已提交
1024
			be16_add_cpu(&nleaf->lf_entries, 1);
D
David Teigland 已提交
1025 1026 1027 1028 1029

			dirent_del(dip, obh, prev, dent);

			if (!oleaf->lf_entries)
				gfs2_consist_inode(dip);
M
Marcin Slusarz 已提交
1030
			be16_add_cpu(&oleaf->lf_entries, -1);
D
David Teigland 已提交
1031 1032 1033 1034 1035

			if (!prev)
				prev = dent;

			moved = 1;
1036
		} else {
D
David Teigland 已提交
1037
			prev = dent;
1038
		}
D
David Teigland 已提交
1039
		dent = next;
1040
	} while (dent);
D
David Teigland 已提交
1041

1042
	oleaf->lf_depth = nleaf->lf_depth;
D
David Teigland 已提交
1043 1044

	error = gfs2_meta_inode_buffer(dip, &dibh);
1045
	if (!gfs2_assert_withdraw(GFS2_SB(&dip->i_inode), !error)) {
1046
		gfs2_trans_add_bh(dip->i_gl, dibh, 1);
1047
		gfs2_add_inode_blocks(&dip->i_inode, 1);
1048
		gfs2_dinode_out(dip, dibh->b_data);
D
David Teigland 已提交
1049 1050 1051 1052 1053 1054 1055 1056
		brelse(dibh);
	}

	brelse(obh);
	brelse(nbh);

	return error;

1057
fail_lpfree:
D
David Teigland 已提交
1058 1059
	kfree(lp);

1060
fail_brelse:
D
David Teigland 已提交
1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
	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)
{
1075
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
D
David Teigland 已提交
1076
	struct buffer_head *dibh;
1077 1078 1079 1080
	u32 hsize;
	u64 *buf;
	u64 *from, *to;
	u64 block;
D
David Teigland 已提交
1081 1082 1083
	int x;
	int error = 0;

1084
	hsize = 1 << dip->i_depth;
1085
	if (hsize * sizeof(u64) != dip->i_disksize) {
D
David Teigland 已提交
1086 1087 1088 1089 1090 1091
		gfs2_consist_inode(dip);
		return -EIO;
	}

	/*  Allocate both the "from" and "to" buffers in one big chunk  */

J
Josef Bacik 已提交
1092
	buf = kcalloc(3, sdp->sd_hash_bsize, GFP_NOFS | __GFP_NOFAIL);
D
David Teigland 已提交
1093

1094
	for (block = dip->i_disksize >> sdp->sd_hash_bsize_shift; block--;) {
1095
		error = gfs2_dir_read_data(dip, (char *)buf,
D
David Teigland 已提交
1096
					    block * sdp->sd_hash_bsize,
S
Steven Whitehouse 已提交
1097
					    sdp->sd_hash_bsize, 1);
D
David Teigland 已提交
1098 1099 1100 1101 1102 1103 1104
		if (error != sdp->sd_hash_bsize) {
			if (error >= 0)
				error = -EIO;
			goto fail;
		}

		from = buf;
1105
		to = (u64 *)((char *)buf + sdp->sd_hash_bsize);
D
David Teigland 已提交
1106 1107 1108 1109 1110 1111

		for (x = sdp->sd_hash_ptrs; x--; from++) {
			*to++ = *from;	/*  No endianess worries  */
			*to++ = *from;
		}

1112
		error = gfs2_dir_write_data(dip,
D
David Teigland 已提交
1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126
					     (char *)buf + sdp->sd_hash_bsize,
					     block * sdp->sd_sb.sb_bsize,
					     sdp->sd_sb.sb_bsize);
		if (error != sdp->sd_sb.sb_bsize) {
			if (error >= 0)
				error = -EIO;
			goto fail;
		}
	}

	kfree(buf);

	error = gfs2_meta_inode_buffer(dip, &dibh);
	if (!gfs2_assert_withdraw(sdp, !error)) {
1127
		dip->i_depth++;
1128
		gfs2_dinode_out(dip, dibh->b_data);
D
David Teigland 已提交
1129 1130 1131 1132 1133
		brelse(dibh);
	}

	return error;

1134
fail:
D
David Teigland 已提交
1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151
	kfree(buf);
	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)
{
1152
	const struct gfs2_dirent *dent_a, *dent_b;
1153
	u32 hash_a, hash_b;
D
David Teigland 已提交
1154 1155
	int ret = 0;

1156
	dent_a = *(const struct gfs2_dirent **)a;
1157
	hash_a = be32_to_cpu(dent_a->de_hash);
D
David Teigland 已提交
1158

1159
	dent_b = *(const struct gfs2_dirent **)b;
1160
	hash_b = be32_to_cpu(dent_b->de_hash);
D
David Teigland 已提交
1161 1162 1163 1164 1165 1166

	if (hash_a > hash_b)
		ret = 1;
	else if (hash_a < hash_b)
		ret = -1;
	else {
1167 1168
		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 已提交
1169 1170 1171 1172 1173 1174

		if (len_a > len_b)
			ret = 1;
		else if (len_a < len_b)
			ret = -1;
		else
1175
			ret = memcmp(dent_a + 1, dent_b + 1, len_a);
D
David Teigland 已提交
1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198
	}

	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
 */

1199
static int do_filldir_main(struct gfs2_inode *dip, u64 *offset,
1200
			   void *opaque, filldir_t filldir,
1201
			   const struct gfs2_dirent **darr, u32 entries,
D
David Teigland 已提交
1202 1203
			   int *copied)
{
1204
	const struct gfs2_dirent *dent, *dent_next;
1205
	u64 off, off_next;
D
David Teigland 已提交
1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240
	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;
		}

1241
		error = filldir(opaque, (const char *)(dent + 1),
1242
				be16_to_cpu(dent->de_name_len),
1243
				off, be64_to_cpu(dent->de_inum.no_addr),
1244
				be16_to_cpu(dent->de_type));
D
David Teigland 已提交
1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259
		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;
}

1260
static int gfs2_dir_read_leaf(struct inode *inode, u64 *offset, void *opaque,
1261 1262
			      filldir_t filldir, int *copied, unsigned *depth,
			      u64 leaf_no)
D
David Teigland 已提交
1263
{
1264
	struct gfs2_inode *ip = GFS2_I(inode);
1265
	struct gfs2_sbd *sdp = GFS2_SB(inode);
1266 1267
	struct buffer_head *bh;
	struct gfs2_leaf *lf;
1268
	unsigned entries = 0, entries2 = 0;
1269 1270 1271 1272 1273 1274 1275
	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 已提交
1276 1277

	do {
1278
		error = get_leaf(ip, lfn, &bh);
D
David Teigland 已提交
1279
		if (error)
1280 1281 1282 1283 1284 1285 1286 1287 1288
			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 已提交
1289 1290 1291 1292

	if (!entries)
		return 0;

1293
	error = -ENOMEM;
1294 1295 1296 1297 1298 1299 1300
	/*
	 * 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.
	 */
	larr = vmalloc((leaves + entries + 99) * sizeof(void *));
1301 1302 1303 1304 1305 1306
	if (!larr)
		goto out;
	darr = (const struct gfs2_dirent **)(larr + leaves);
	g.pdent = darr;
	g.offset = 0;
	lfn = leaf_no;
D
David Teigland 已提交
1307

1308 1309
	do {
		error = get_leaf(ip, lfn, &bh);
D
David Teigland 已提交
1310
		if (error)
1311 1312 1313 1314
			goto out_kfree;
		lf = (struct gfs2_leaf *)bh->b_data;
		lfn = be64_to_cpu(lf->lf_next);
		if (lf->lf_entries) {
1315
			entries2 += be16_to_cpu(lf->lf_entries);
1316 1317 1318
			dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size,
						gfs2_dirent_gather, NULL, &g);
			error = PTR_ERR(dent);
1319 1320 1321
			if (IS_ERR(dent))
				goto out_kfree;
			if (entries2 != g.offset) {
1322 1323 1324 1325 1326
				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);
1327 1328
					
				error = -EIO;
1329 1330 1331 1332
				goto out_kfree;
			}
			error = 0;
			larr[leaf++] = bh;
D
David Teigland 已提交
1333
		} else {
1334
			brelse(bh);
D
David Teigland 已提交
1335
		}
1336
	} while(lfn);
D
David Teigland 已提交
1337

1338
	BUG_ON(entries2 != entries);
1339
	error = do_filldir_main(ip, offset, opaque, filldir, darr,
D
David Teigland 已提交
1340
				entries, copied);
1341 1342 1343
out_kfree:
	for(i = 0; i < leaf; i++)
		brelse(larr[i]);
1344
	vfree(larr);
1345
out:
D
David Teigland 已提交
1346 1347 1348 1349
	return error;
}

/**
1350 1351 1352 1353 1354
 * 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 已提交
1355
 *
1356
 * Returns: errno
D
David Teigland 已提交
1357 1358
 */

1359
static int dir_e_read(struct inode *inode, u64 *offset, void *opaque,
1360
		      filldir_t filldir)
D
David Teigland 已提交
1361
{
1362 1363
	struct gfs2_inode *dip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
1364 1365 1366
	u32 hsize, len = 0;
	u32 ht_offset, lp_offset, ht_offset_cur = -1;
	u32 hash, index;
A
Al Viro 已提交
1367
	__be64 *lp;
1368 1369
	int copied = 0;
	int error = 0;
1370
	unsigned depth = 0;
D
David Teigland 已提交
1371

1372
	hsize = 1 << dip->i_depth;
1373
	if (hsize * sizeof(u64) != dip->i_disksize) {
D
David Teigland 已提交
1374 1375 1376 1377 1378
		gfs2_consist_inode(dip);
		return -EIO;
	}

	hash = gfs2_dir_offset2hash(*offset);
1379
	index = hash >> (32 - dip->i_depth);
D
David Teigland 已提交
1380

J
Josef Bacik 已提交
1381
	lp = kmalloc(sdp->sd_hash_bsize, GFP_NOFS);
D
David Teigland 已提交
1382 1383 1384 1385 1386 1387 1388 1389
	if (!lp)
		return -ENOMEM;

	while (index < hsize) {
		lp_offset = index & (sdp->sd_hash_ptrs - 1);
		ht_offset = index - lp_offset;

		if (ht_offset_cur != ht_offset) {
1390
			error = gfs2_dir_read_data(dip, (char *)lp,
A
Al Viro 已提交
1391
						ht_offset * sizeof(__be64),
S
Steven Whitehouse 已提交
1392
						sdp->sd_hash_bsize, 1);
D
David Teigland 已提交
1393 1394 1395 1396 1397 1398 1399 1400
			if (error != sdp->sd_hash_bsize) {
				if (error >= 0)
					error = -EIO;
				goto out;
			}
			ht_offset_cur = ht_offset;
		}

1401 1402 1403
		error = gfs2_dir_read_leaf(inode, offset, opaque, filldir,
					   &copied, &depth,
					   be64_to_cpu(lp[lp_offset]));
D
David Teigland 已提交
1404
		if (error)
1405
			break;
D
David Teigland 已提交
1406

1407
		len = 1 << (dip->i_depth - depth);
D
David Teigland 已提交
1408 1409 1410
		index = (index & ~(len - 1)) + len;
	}

1411
out:
D
David Teigland 已提交
1412
	kfree(lp);
1413 1414
	if (error > 0)
		error = 0;
D
David Teigland 已提交
1415 1416 1417
	return error;
}

1418
int gfs2_dir_read(struct inode *inode, u64 *offset, void *opaque,
1419
		  filldir_t filldir)
D
David Teigland 已提交
1420
{
1421
	struct gfs2_inode *dip = GFS2_I(inode);
1422
	struct gfs2_sbd *sdp = GFS2_SB(inode);
1423 1424
	struct dirent_gather g;
	const struct gfs2_dirent **darr, *dent;
D
David Teigland 已提交
1425 1426 1427 1428
	struct buffer_head *dibh;
	int copied = 0;
	int error;

1429
	if (!dip->i_entries)
1430 1431 1432 1433 1434
		return 0;

	if (dip->i_di.di_flags & GFS2_DIF_EXHASH)
		return dir_e_read(inode, offset, opaque, filldir);

D
David Teigland 已提交
1435 1436 1437 1438 1439 1440 1441 1442 1443
	if (!gfs2_is_stuffed(dip)) {
		gfs2_consist_inode(dip);
		return -EIO;
	}

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

1444
	error = -ENOMEM;
1445
	/* 96 is max number of dirents which can be stuffed into an inode */
J
Josef Bacik 已提交
1446
	darr = kmalloc(96 * sizeof(struct gfs2_dirent *), GFP_NOFS);
1447 1448 1449 1450 1451 1452 1453 1454 1455
	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;
		}
1456
		if (dip->i_entries != g.offset) {
1457
			fs_warn(sdp, "Number of entries corrupt in dir %llu, "
1458
				"ip->i_entries (%u) != g.offset (%u)\n",
1459
				(unsigned long long)dip->i_no_addr,
1460
				dip->i_entries,
1461 1462 1463 1464
				g.offset);
			error = -EIO;
			goto out;
		}
1465
		error = do_filldir_main(dip, offset, opaque, filldir, darr,
1466
					dip->i_entries, &copied);
1467 1468 1469 1470
out:
		kfree(darr);
	}

D
David Teigland 已提交
1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490
	if (error > 0)
		error = 0;

	brelse(dibh);

	return error;
}

/**
 * gfs2_dir_search - Search a directory
 * @dip: The GFS2 inode
 * @filename:
 * @inode:
 *
 * This routine searches a directory for a file or another directory.
 * Assumes a glock is held on dip.
 *
 * Returns: errno
 */

1491
struct inode *gfs2_dir_search(struct inode *dir, const struct qstr *name)
D
David Teigland 已提交
1492
{
1493 1494
	struct buffer_head *bh;
	struct gfs2_dirent *dent;
1495 1496 1497 1498 1499
	struct inode *inode;

	dent = gfs2_dirent_search(dir, name, gfs2_dirent_find, &bh);
	if (dent) {
		if (IS_ERR(dent))
1500
			return ERR_CAST(dent);
1501 1502 1503
		inode = gfs2_inode_lookup(dir->i_sb, 
				be16_to_cpu(dent->de_type),
				be64_to_cpu(dent->de_inum.no_addr),
1504
				be64_to_cpu(dent->de_inum.no_formal_ino), 0);
1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516
		brelse(bh);
		return inode;
	}
	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;
1517 1518 1519 1520 1521

	dent = gfs2_dirent_search(dir, name, gfs2_dirent_find, &bh);
	if (dent) {
		if (IS_ERR(dent))
			return PTR_ERR(dent);
1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536
		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:
1537 1538
		brelse(bh);
	}
1539
	return ret;
1540 1541 1542 1543 1544
}

static int dir_new_leaf(struct inode *inode, const struct qstr *name)
{
	struct buffer_head *bh, *obh;
1545
	struct gfs2_inode *ip = GFS2_I(inode);
1546
	struct gfs2_leaf *leaf, *oleaf;
D
David Teigland 已提交
1547
	int error;
1548 1549
	u32 index;
	u64 bn;
D
David Teigland 已提交
1550

1551
	index = name->hash >> (32 - ip->i_depth);
1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564
	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 已提交
1565

1566 1567 1568 1569 1570 1571 1572
	gfs2_trans_add_bh(ip->i_gl, obh, 1);

	leaf = new_leaf(inode, &bh, be16_to_cpu(oleaf->lf_depth));
	if (!leaf) {
		brelse(obh);
		return -ENOSPC;
	}
1573
	oleaf->lf_next = cpu_to_be64(bh->b_blocknr);
1574 1575 1576 1577 1578 1579 1580
	brelse(bh);
	brelse(obh);

	error = gfs2_meta_inode_buffer(ip, &bh);
	if (error)
		return error;
	gfs2_trans_add_bh(ip->i_gl, bh, 1);
1581
	gfs2_add_inode_blocks(&ip->i_inode, 1);
1582
	gfs2_dinode_out(ip, bh->b_data);
1583 1584
	brelse(bh);
	return 0;
D
David Teigland 已提交
1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596
}

/**
 * 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
 */

1597
int gfs2_dir_add(struct inode *inode, const struct qstr *name,
1598
		 const struct gfs2_inode *nip, unsigned type)
D
David Teigland 已提交
1599
{
1600
	struct gfs2_inode *ip = GFS2_I(inode);
1601 1602 1603
	struct buffer_head *bh;
	struct gfs2_dirent *dent;
	struct gfs2_leaf *leaf;
D
David Teigland 已提交
1604 1605
	int error;

1606 1607 1608 1609 1610 1611 1612
	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);
1613
			gfs2_inum_out(nip, dent);
1614 1615 1616
			dent->de_type = cpu_to_be16(type);
			if (ip->i_di.di_flags & GFS2_DIF_EXHASH) {
				leaf = (struct gfs2_leaf *)bh->b_data;
M
Marcin Slusarz 已提交
1617
				be16_add_cpu(&leaf->lf_entries, 1);
1618 1619 1620 1621 1622 1623
			}
			brelse(bh);
			error = gfs2_meta_inode_buffer(ip, &bh);
			if (error)
				break;
			gfs2_trans_add_bh(ip->i_gl, bh, 1);
1624
			ip->i_entries++;
1625
			ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
1626
			gfs2_dinode_out(ip, bh->b_data);
1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639
			brelse(bh);
			error = 0;
			break;
		}
		if (!(ip->i_di.di_flags & GFS2_DIF_EXHASH)) {
			error = dir_make_exhash(inode);
			if (error)
				break;
			continue;
		}
		error = dir_split_leaf(inode, name);
		if (error == 0)
			continue;
1640
		if (error < 0)
1641
			break;
1642
		if (ip->i_depth < GFS2_DIR_MAX_DEPTH) {
1643 1644 1645 1646
			error = dir_double_exhash(ip);
			if (error)
				break;
			error = dir_split_leaf(inode, name);
1647
			if (error < 0)
1648
				break;
1649 1650
			if (error == 0)
				continue;
1651 1652 1653 1654 1655 1656 1657
		}
		error = dir_new_leaf(inode, name);
		if (!error)
			continue;
		error = -ENOSPC;
		break;
	}
D
David Teigland 已提交
1658 1659 1660
	return error;
}

1661

D
David Teigland 已提交
1662 1663 1664 1665 1666 1667 1668 1669
/**
 * gfs2_dir_del - Delete a directory entry
 * @dip: The GFS2 inode
 * @filename: The filename
 *
 * Returns: 0 on success, error code on failure
 */

1670
int gfs2_dir_del(struct gfs2_inode *dip, const struct qstr *name)
D
David Teigland 已提交
1671
{
1672 1673
	struct gfs2_dirent *dent, *prev = NULL;
	struct buffer_head *bh;
D
David Teigland 已提交
1674 1675
	int error;

1676 1677
	/* Returns _either_ the entry (if its first in block) or the
	   previous entry otherwise */
1678
	dent = gfs2_dirent_search(&dip->i_inode, name, gfs2_dirent_prev, &bh);
1679 1680 1681 1682 1683 1684 1685 1686 1687
	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 */
1688
	if (gfs2_dirent_find(dent, name, NULL) == 0) {
1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700
		prev = dent;
		dent = (struct gfs2_dirent *)((char *)dent + be16_to_cpu(prev->de_rec_len));
	}

	dirent_del(dip, bh, prev, dent);
	if (dip->i_di.di_flags & GFS2_DIF_EXHASH) {
		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);
	}
1701
	brelse(bh);
1702 1703 1704 1705 1706

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

1707
	if (!dip->i_entries)
1708 1709
		gfs2_consist_inode(dip);
	gfs2_trans_add_bh(dip->i_gl, bh, 1);
1710
	dip->i_entries--;
1711
	dip->i_inode.i_mtime = dip->i_inode.i_ctime = CURRENT_TIME;
1712
	gfs2_dinode_out(dip, bh->b_data);
1713
	brelse(bh);
1714
	mark_inode_dirty(&dip->i_inode);
D
David Teigland 已提交
1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731

	return error;
}

/**
 * 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
 */

1732
int gfs2_dir_mvino(struct gfs2_inode *dip, const struct qstr *filename,
1733
		   const struct gfs2_inode *nip, unsigned int new_type)
D
David Teigland 已提交
1734
{
1735 1736
	struct buffer_head *bh;
	struct gfs2_dirent *dent;
D
David Teigland 已提交
1737 1738
	int error;

1739
	dent = gfs2_dirent_search(&dip->i_inode, filename, gfs2_dirent_find, &bh);
1740 1741 1742 1743 1744 1745
	if (!dent) {
		gfs2_consist_inode(dip);
		return -EIO;
	}
	if (IS_ERR(dent))
		return PTR_ERR(dent);
D
David Teigland 已提交
1746

1747
	gfs2_trans_add_bh(dip->i_gl, bh, 1);
1748
	gfs2_inum_out(nip, dent);
1749 1750 1751 1752 1753 1754 1755 1756 1757 1758
	dent->de_type = cpu_to_be16(new_type);

	if (dip->i_di.di_flags & GFS2_DIF_EXHASH) {
		brelse(bh);
		error = gfs2_meta_inode_buffer(dip, &bh);
		if (error)
			return error;
		gfs2_trans_add_bh(dip->i_gl, bh, 1);
	}

1759
	dip->i_inode.i_mtime = dip->i_inode.i_ctime = CURRENT_TIME;
1760
	gfs2_dinode_out(dip, bh->b_data);
1761 1762
	brelse(bh);
	return 0;
D
David Teigland 已提交
1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775
}

/**
 * foreach_leaf - call a function for each leaf in a directory
 * @dip: the directory
 * @lc: the function to call for each each
 * @data: private data to pass to it
 *
 * Returns: errno
 */

static int foreach_leaf(struct gfs2_inode *dip, leaf_call_t lc, void *data)
{
1776
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
D
David Teigland 已提交
1777
	struct buffer_head *bh;
1778
	struct gfs2_leaf *leaf;
1779 1780 1781
	u32 hsize, len;
	u32 ht_offset, lp_offset, ht_offset_cur = -1;
	u32 index = 0;
A
Al Viro 已提交
1782
	__be64 *lp;
1783
	u64 leaf_no;
D
David Teigland 已提交
1784 1785
	int error = 0;

1786
	hsize = 1 << dip->i_depth;
1787
	if (hsize * sizeof(u64) != dip->i_disksize) {
D
David Teigland 已提交
1788 1789 1790 1791
		gfs2_consist_inode(dip);
		return -EIO;
	}

J
Josef Bacik 已提交
1792
	lp = kmalloc(sdp->sd_hash_bsize, GFP_NOFS);
D
David Teigland 已提交
1793 1794 1795 1796 1797 1798 1799 1800
	if (!lp)
		return -ENOMEM;

	while (index < hsize) {
		lp_offset = index & (sdp->sd_hash_ptrs - 1);
		ht_offset = index - lp_offset;

		if (ht_offset_cur != ht_offset) {
1801
			error = gfs2_dir_read_data(dip, (char *)lp,
A
Al Viro 已提交
1802
						ht_offset * sizeof(__be64),
S
Steven Whitehouse 已提交
1803
						sdp->sd_hash_bsize, 1);
D
David Teigland 已提交
1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816
			if (error != sdp->sd_hash_bsize) {
				if (error >= 0)
					error = -EIO;
				goto out;
			}
			ht_offset_cur = ht_offset;
		}

		leaf_no = be64_to_cpu(lp[lp_offset]);
		if (leaf_no) {
			error = get_leaf(dip, leaf_no, &bh);
			if (error)
				goto out;
1817
			leaf = (struct gfs2_leaf *)bh->b_data;
1818
			len = 1 << (dip->i_depth - be16_to_cpu(leaf->lf_depth));
1819
			brelse(bh);
D
David Teigland 已提交
1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834

			error = lc(dip, index, len, leaf_no, data);
			if (error)
				goto out;

			index = (index & ~(len - 1)) + len;
		} else
			index++;
	}

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

1835
out:
D
David Teigland 已提交
1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851
	kfree(lp);

	return error;
}

/**
 * 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
 * @data: not used
 *
 * Returns: errno
 */

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

	memset(&rlist, 0, sizeof(struct gfs2_rgrp_list));

J
Josef Bacik 已提交
1867
	ht = kzalloc(size, GFP_NOFS);
D
David Teigland 已提交
1868 1869 1870
	if (!ht)
		return -ENOMEM;

1871 1872 1873 1874
	if (!gfs2_alloc_get(dip)) {
		error = -ENOMEM;
		goto out;
	}
D
David Teigland 已提交
1875 1876 1877

	error = gfs2_quota_hold(dip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
	if (error)
1878
		goto out_put;
D
David Teigland 已提交
1879

1880
	error = gfs2_rindex_hold(sdp, &dip->i_alloc->al_ri_gh);
D
David Teigland 已提交
1881 1882 1883 1884 1885
	if (error)
		goto out_qs;

	/*  Count the number of leaves  */

1886
	for (blk = leaf_no; blk; blk = nblk) {
D
David Teigland 已提交
1887 1888 1889
		error = get_leaf(dip, blk, &bh);
		if (error)
			goto out_rlist;
1890 1891
		tmp_leaf = (struct gfs2_leaf *)bh->b_data;
		nblk = be64_to_cpu(tmp_leaf->lf_next);
D
David Teigland 已提交
1892 1893 1894 1895 1896 1897
		brelse(bh);

		gfs2_rlist_add(sdp, &rlist, blk);
		l_blocks++;
	}

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

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

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

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

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

		gfs2_free_meta(dip, blk, 1);
1925
		gfs2_add_inode_blocks(&dip->i_inode, -1);
D
David Teigland 已提交
1926 1927
	}

1928
	error = gfs2_dir_write_data(dip, ht, index * sizeof(u64), size);
D
David Teigland 已提交
1929 1930 1931 1932 1933 1934 1935 1936 1937 1938
	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;

1939
	gfs2_trans_add_bh(dip->i_gl, dibh, 1);
1940
	gfs2_dinode_out(dip, dibh->b_data);
D
David Teigland 已提交
1941 1942
	brelse(dibh);

1943
out_end_trans:
D
David Teigland 已提交
1944
	gfs2_trans_end(sdp);
1945
out_rg_gunlock:
D
David Teigland 已提交
1946
	gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);
1947
out_rlist:
D
David Teigland 已提交
1948
	gfs2_rlist_free(&rlist);
1949
	gfs2_glock_dq_uninit(&dip->i_alloc->al_ri_gh);
1950
out_qs:
D
David Teigland 已提交
1951
	gfs2_quota_unhold(dip);
1952
out_put:
D
David Teigland 已提交
1953
	gfs2_alloc_put(dip);
1954
out:
D
David Teigland 已提交
1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970
	kfree(ht);
	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)
{
1971
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
D
David Teigland 已提交
1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988
	struct buffer_head *bh;
	int error;

	/* Dealloc on-disk leaves to FREEMETA state */
	error = foreach_leaf(dip, leaf_dealloc, NULL);
	if (error)
		return error;

	/* Make this a regular file in case we crash.
	   (We don't want to free these blocks a second time.)  */

	error = gfs2_trans_begin(sdp, RES_DINODE, 0);
	if (error)
		return error;

	error = gfs2_meta_inode_buffer(dip, &bh);
	if (!error) {
1989
		gfs2_trans_add_bh(dip->i_gl, bh, 1);
1990 1991
		((struct gfs2_dinode *)bh->b_data)->di_mode =
						cpu_to_be32(S_IFREG);
D
David Teigland 已提交
1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004
		brelse(bh);
	}

	gfs2_trans_end(sdp);

	return error;
}

/**
 * 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
 *
2005
 * Returns: 1 if alloc required, 0 if not, -ve on error
D
David Teigland 已提交
2006 2007
 */

2008
int gfs2_diradd_alloc_required(struct inode *inode, const struct qstr *name)
D
David Teigland 已提交
2009
{
2010 2011
	struct gfs2_dirent *dent;
	struct buffer_head *bh;
D
David Teigland 已提交
2012

2013
	dent = gfs2_dirent_search(inode, name, gfs2_dirent_find_space, &bh);
2014
	if (!dent) {
2015
		return 1;
2016
	}
2017 2018 2019 2020
	if (IS_ERR(dent))
		return PTR_ERR(dent);
	brelse(bh);
	return 0;
D
David Teigland 已提交
2021 2022
}