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
 * 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 gfs2_disk_hash2offset(h) (((u64)(h)) >> 1)
#define gfs2_dir_offset2hash(p) ((u32)(((u64)(p)) << 1))
D
David Teigland 已提交
81

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

87

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

93 94 95 96
	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));
97 98 99 100
	*bhp = bh;
	return 0;
}

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

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

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

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

	if (!size)
		return 0;

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

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

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

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

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

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

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

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

		o = sizeof(struct gfs2_meta_header);
	}

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

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

	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
233
	gfs2_dinode_out(ip, dibh->b_data);
234 235 236 237 238 239 240 241 242 243
	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 已提交
244
				 u64 offset, unsigned int size)
245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268
{
	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 已提交
269 270
static int gfs2_dir_read_data(struct gfs2_inode *ip, char *buf, u64 offset,
			      unsigned int size, unsigned ra)
271
{
272
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
273 274
	u64 lblock, dblock;
	u32 extlen = 0;
275 276 277 278
	unsigned int o;
	int copied = 0;
	int error = 0;

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

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

	if (!size)
		return 0;

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

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

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

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

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

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

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

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

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

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

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

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

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

	BUG_ON(buf == NULL);

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

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

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

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


D
David Teigland 已提交
529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544
/**
 * 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;

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

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

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

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

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

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

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

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

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

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

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

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

671
	if (!gfs2_dirent_sentinel(dent))
672 673 674 675 676 677 678 679
		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 已提交
680 681
}

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

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

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

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

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

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

	*leaf_out = be64_to_cpu(leaf_no);

	return 0;
}

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

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

	return error;
}

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

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

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

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

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

788

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

802 803
static struct gfs2_leaf *new_leaf(struct inode *inode, struct buffer_head **pbh, u16 depth)
{
804
	struct gfs2_inode *ip = GFS2_I(inode);
805
	unsigned int n = 1;
806 807 808
	u64 bn;
	int error;
	struct buffer_head *bh;
809 810
	struct gfs2_leaf *leaf;
	struct gfs2_dirent *dent;
811
	struct qstr name = { .name = "", .len = 0, .hash = 0 };
812 813 814 815 816

	error = gfs2_alloc_block(ip, &bn, &n);
	if (error)
		return NULL;
	bh = gfs2_meta_new(ip->i_gl, bn);
817 818
	if (!bh)
		return NULL;
819

820
	gfs2_trans_add_unrevoke(GFS2_SB(inode), bn, 1);
821 822 823 824
	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);
825
	leaf->lf_entries = 0;
826
	leaf->lf_dirent_format = cpu_to_be32(GFS2_FORMAT_DE);
827
	leaf->lf_next = 0;
828 829
	memset(leaf->lf_reserved, 0, sizeof(leaf->lf_reserved));
	dent = (struct gfs2_dirent *)(leaf+1);
830
	gfs2_qstr2dirent(&name, bh->b_size - sizeof(struct gfs2_leaf), dent);
831 832
	*pbh = bh;
	return leaf;
D
David Teigland 已提交
833 834 835 836 837 838 839 840 841
}

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

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

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

	/*  Turn over a new leaf  */

862 863 864 865
	leaf = new_leaf(inode, &bh, 0);
	if (!leaf)
		return -ENOSPC;
	bn = bh->b_blocknr;
D
David Teigland 已提交
866

867 868
	gfs2_assert(sdp, dip->i_entries < (1 << 16));
	leaf->lf_entries = cpu_to_be16(dip->i_entries);
D
David Teigland 已提交
869 870 871 872 873 874 875 876 877

	/*  Copy dirents  */

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

	/*  Find last entry  */

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

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

897
	dent->de_rec_len = cpu_to_be16(be16_to_cpu(dent->de_rec_len) +
D
David Teigland 已提交
898
		sizeof(struct gfs2_dinode) -
899
		sizeof(struct gfs2_leaf));
D
David Teigland 已提交
900 901 902 903 904 905

	brelse(bh);

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

906
	gfs2_trans_add_bh(dip->i_gl, dibh, 1);
D
David Teigland 已提交
907 908
	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));

A
Al Viro 已提交
909
	lp = (__be64 *)(dibh->b_data + sizeof(struct gfs2_dinode));
D
David Teigland 已提交
910 911 912 913

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

914
	dip->i_disksize = sdp->sd_sb.sb_bsize / 2;
915
	gfs2_add_inode_blocks(&dip->i_inode, 1);
916
	dip->i_diskflags |= GFS2_DIF_EXHASH;
D
David Teigland 已提交
917 918

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

921
	gfs2_dinode_out(dip, dibh->b_data);
D
David Teigland 已提交
922 923 924 925 926 927 928 929 930 931 932 933 934 935 936

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

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

950
	index = name->hash >> (32 - dip->i_depth);
951 952 953
	error = get_leaf_nr(dip, index, &leaf_no);
	if (error)
		return error;
D
David Teigland 已提交
954 955 956 957

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

	oleaf = (struct gfs2_leaf *)obh->b_data;
961
	if (dip->i_depth == be16_to_cpu(oleaf->lf_depth)) {
962 963 964 965 966
		brelse(obh);
		return 1; /* can't split */
	}

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

968 969 970 971 972 973
	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 已提交
974

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

995 996 997
	error = gfs2_dir_write_data(dip, (char *)lp, start * sizeof(u64),
				    half_len * sizeof(u64));
	if (error != half_len * sizeof(u64)) {
D
David Teigland 已提交
998 999 1000 1001 1002 1003 1004 1005
		if (error >= 0)
			error = -EIO;
		goto fail_lpfree;
	}

	kfree(lp);

	/*  Compute the divider  */
1006
	divider = (start + half_len) << (32 - dip->i_depth);
D
David Teigland 已提交
1007 1008 1009 1010 1011 1012 1013 1014 1015

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

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

1016
		if (!gfs2_dirent_sentinel(dent) &&
D
David Teigland 已提交
1017
		    be32_to_cpu(dent->de_hash) < divider) {
1018 1019 1020 1021
			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);
1022
			new = gfs2_dirent_alloc(inode, nbh, &str);
1023 1024 1025 1026
			if (IS_ERR(new)) {
				error = PTR_ERR(new);
				break;
			}
D
David Teigland 已提交
1027 1028 1029

			new->de_inum = dent->de_inum; /* No endian worries */
			new->de_type = dent->de_type; /* No endian worries */
M
Marcin Slusarz 已提交
1030
			be16_add_cpu(&nleaf->lf_entries, 1);
D
David Teigland 已提交
1031 1032 1033 1034 1035

			dirent_del(dip, obh, prev, dent);

			if (!oleaf->lf_entries)
				gfs2_consist_inode(dip);
M
Marcin Slusarz 已提交
1036
			be16_add_cpu(&oleaf->lf_entries, -1);
D
David Teigland 已提交
1037 1038 1039 1040 1041

			if (!prev)
				prev = dent;

			moved = 1;
1042
		} else {
D
David Teigland 已提交
1043
			prev = dent;
1044
		}
D
David Teigland 已提交
1045
		dent = next;
1046
	} while (dent);
D
David Teigland 已提交
1047

1048
	oleaf->lf_depth = nleaf->lf_depth;
D
David Teigland 已提交
1049 1050

	error = gfs2_meta_inode_buffer(dip, &dibh);
1051
	if (!gfs2_assert_withdraw(GFS2_SB(&dip->i_inode), !error)) {
1052
		gfs2_trans_add_bh(dip->i_gl, dibh, 1);
1053
		gfs2_add_inode_blocks(&dip->i_inode, 1);
1054
		gfs2_dinode_out(dip, dibh->b_data);
D
David Teigland 已提交
1055 1056 1057 1058 1059 1060 1061 1062
		brelse(dibh);
	}

	brelse(obh);
	brelse(nbh);

	return error;

1063
fail_lpfree:
D
David Teigland 已提交
1064 1065
	kfree(lp);

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

1090
	hsize = 1 << dip->i_depth;
1091
	if (hsize * sizeof(u64) != dip->i_disksize) {
D
David Teigland 已提交
1092 1093 1094 1095 1096 1097
		gfs2_consist_inode(dip);
		return -EIO;
	}

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

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

1100
	for (block = dip->i_disksize >> sdp->sd_hash_bsize_shift; block--;) {
1101
		error = gfs2_dir_read_data(dip, (char *)buf,
D
David Teigland 已提交
1102
					    block * sdp->sd_hash_bsize,
S
Steven Whitehouse 已提交
1103
					    sdp->sd_hash_bsize, 1);
D
David Teigland 已提交
1104 1105 1106 1107 1108 1109 1110
		if (error != sdp->sd_hash_bsize) {
			if (error >= 0)
				error = -EIO;
			goto fail;
		}

		from = buf;
1111
		to = (u64 *)((char *)buf + sdp->sd_hash_bsize);
D
David Teigland 已提交
1112 1113 1114 1115 1116 1117

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

1118
		error = gfs2_dir_write_data(dip,
D
David Teigland 已提交
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132
					     (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)) {
1133
		dip->i_depth++;
1134
		gfs2_dinode_out(dip, dibh->b_data);
D
David Teigland 已提交
1135 1136 1137 1138 1139
		brelse(dibh);
	}

	return error;

1140
fail:
D
David Teigland 已提交
1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157
	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)
{
1158
	const struct gfs2_dirent *dent_a, *dent_b;
1159
	u32 hash_a, hash_b;
D
David Teigland 已提交
1160 1161
	int ret = 0;

1162
	dent_a = *(const struct gfs2_dirent **)a;
1163
	hash_a = be32_to_cpu(dent_a->de_hash);
D
David Teigland 已提交
1164

1165
	dent_b = *(const struct gfs2_dirent **)b;
1166
	hash_b = be32_to_cpu(dent_b->de_hash);
D
David Teigland 已提交
1167 1168 1169 1170 1171 1172

	if (hash_a > hash_b)
		ret = 1;
	else if (hash_a < hash_b)
		ret = -1;
	else {
1173 1174
		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 已提交
1175 1176 1177 1178 1179 1180

		if (len_a > len_b)
			ret = 1;
		else if (len_a < len_b)
			ret = -1;
		else
1181
			ret = memcmp(dent_a + 1, dent_b + 1, len_a);
D
David Teigland 已提交
1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204
	}

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

1205
static int do_filldir_main(struct gfs2_inode *dip, u64 *offset,
1206
			   void *opaque, filldir_t filldir,
1207
			   const struct gfs2_dirent **darr, u32 entries,
D
David Teigland 已提交
1208 1209
			   int *copied)
{
1210
	const struct gfs2_dirent *dent, *dent_next;
1211
	u64 off, off_next;
D
David Teigland 已提交
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 1241 1242 1243 1244 1245 1246
	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;
		}

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

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

	do {
1284
		error = get_leaf(ip, lfn, &bh);
D
David Teigland 已提交
1285
		if (error)
1286 1287 1288 1289 1290 1291 1292 1293 1294
			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 已提交
1295 1296 1297 1298

	if (!entries)
		return 0;

1299
	error = -ENOMEM;
1300 1301 1302 1303 1304 1305 1306
	/*
	 * 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 *));
1307 1308 1309 1310 1311 1312
	if (!larr)
		goto out;
	darr = (const struct gfs2_dirent **)(larr + leaves);
	g.pdent = darr;
	g.offset = 0;
	lfn = leaf_no;
D
David Teigland 已提交
1313

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

1344
	BUG_ON(entries2 != entries);
1345
	error = do_filldir_main(ip, offset, opaque, filldir, darr,
D
David Teigland 已提交
1346
				entries, copied);
1347 1348 1349
out_kfree:
	for(i = 0; i < leaf; i++)
		brelse(larr[i]);
1350
	vfree(larr);
1351
out:
D
David Teigland 已提交
1352 1353 1354 1355
	return error;
}

/**
1356 1357 1358 1359 1360
 * 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 已提交
1361
 *
1362
 * Returns: errno
D
David Teigland 已提交
1363 1364
 */

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

1378
	hsize = 1 << dip->i_depth;
1379
	if (hsize * sizeof(u64) != dip->i_disksize) {
D
David Teigland 已提交
1380 1381 1382 1383 1384
		gfs2_consist_inode(dip);
		return -EIO;
	}

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

J
Josef Bacik 已提交
1387
	lp = kmalloc(sdp->sd_hash_bsize, GFP_NOFS);
D
David Teigland 已提交
1388 1389 1390 1391 1392 1393 1394 1395
	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) {
1396
			error = gfs2_dir_read_data(dip, (char *)lp,
A
Al Viro 已提交
1397
						ht_offset * sizeof(__be64),
S
Steven Whitehouse 已提交
1398
						sdp->sd_hash_bsize, 1);
D
David Teigland 已提交
1399 1400 1401 1402 1403 1404 1405 1406
			if (error != sdp->sd_hash_bsize) {
				if (error >= 0)
					error = -EIO;
				goto out;
			}
			ht_offset_cur = ht_offset;
		}

1407 1408 1409
		error = gfs2_dir_read_leaf(inode, offset, opaque, filldir,
					   &copied, &depth,
					   be64_to_cpu(lp[lp_offset]));
D
David Teigland 已提交
1410
		if (error)
1411
			break;
D
David Teigland 已提交
1412

1413
		len = 1 << (dip->i_depth - depth);
D
David Teigland 已提交
1414 1415 1416
		index = (index & ~(len - 1)) + len;
	}

1417
out:
D
David Teigland 已提交
1418
	kfree(lp);
1419 1420
	if (error > 0)
		error = 0;
D
David Teigland 已提交
1421 1422 1423
	return error;
}

1424
int gfs2_dir_read(struct inode *inode, u64 *offset, void *opaque,
1425
		  filldir_t filldir)
D
David Teigland 已提交
1426
{
1427
	struct gfs2_inode *dip = GFS2_I(inode);
1428
	struct gfs2_sbd *sdp = GFS2_SB(inode);
1429 1430
	struct dirent_gather g;
	const struct gfs2_dirent **darr, *dent;
D
David Teigland 已提交
1431 1432 1433 1434
	struct buffer_head *dibh;
	int copied = 0;
	int error;

1435
	if (!dip->i_entries)
1436 1437
		return 0;

1438
	if (dip->i_diskflags & GFS2_DIF_EXHASH)
1439 1440
		return dir_e_read(inode, offset, opaque, filldir);

D
David Teigland 已提交
1441 1442 1443 1444 1445 1446 1447 1448 1449
	if (!gfs2_is_stuffed(dip)) {
		gfs2_consist_inode(dip);
		return -EIO;
	}

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

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

D
David Teigland 已提交
1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496
	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
 */

1497
struct inode *gfs2_dir_search(struct inode *dir, const struct qstr *name)
D
David Teigland 已提交
1498
{
1499 1500
	struct buffer_head *bh;
	struct gfs2_dirent *dent;
1501 1502 1503 1504 1505
	struct inode *inode;

	dent = gfs2_dirent_search(dir, name, gfs2_dirent_find, &bh);
	if (dent) {
		if (IS_ERR(dent))
1506
			return ERR_CAST(dent);
1507 1508 1509
		inode = gfs2_inode_lookup(dir->i_sb, 
				be16_to_cpu(dent->de_type),
				be64_to_cpu(dent->de_inum.no_addr),
1510
				be64_to_cpu(dent->de_inum.no_formal_ino), 0);
1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522
		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;
1523 1524 1525 1526 1527

	dent = gfs2_dirent_search(dir, name, gfs2_dirent_find, &bh);
	if (dent) {
		if (IS_ERR(dent))
			return PTR_ERR(dent);
1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542
		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:
1543 1544
		brelse(bh);
	}
1545
	return ret;
1546 1547 1548 1549 1550
}

static int dir_new_leaf(struct inode *inode, const struct qstr *name)
{
	struct buffer_head *bh, *obh;
1551
	struct gfs2_inode *ip = GFS2_I(inode);
1552
	struct gfs2_leaf *leaf, *oleaf;
D
David Teigland 已提交
1553
	int error;
1554 1555
	u32 index;
	u64 bn;
D
David Teigland 已提交
1556

1557
	index = name->hash >> (32 - ip->i_depth);
1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570
	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 已提交
1571

1572 1573 1574 1575 1576 1577 1578
	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;
	}
1579
	oleaf->lf_next = cpu_to_be64(bh->b_blocknr);
1580 1581 1582 1583 1584 1585 1586
	brelse(bh);
	brelse(obh);

	error = gfs2_meta_inode_buffer(ip, &bh);
	if (error)
		return error;
	gfs2_trans_add_bh(ip->i_gl, bh, 1);
1587
	gfs2_add_inode_blocks(&ip->i_inode, 1);
1588
	gfs2_dinode_out(ip, bh->b_data);
1589 1590
	brelse(bh);
	return 0;
D
David Teigland 已提交
1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602
}

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

1603
int gfs2_dir_add(struct inode *inode, const struct qstr *name,
1604
		 const struct gfs2_inode *nip, unsigned type)
D
David Teigland 已提交
1605
{
1606
	struct gfs2_inode *ip = GFS2_I(inode);
1607 1608 1609
	struct buffer_head *bh;
	struct gfs2_dirent *dent;
	struct gfs2_leaf *leaf;
D
David Teigland 已提交
1610 1611
	int error;

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

1667

D
David Teigland 已提交
1668 1669 1670 1671 1672 1673 1674 1675
/**
 * gfs2_dir_del - Delete a directory entry
 * @dip: The GFS2 inode
 * @filename: The filename
 *
 * Returns: 0 on success, error code on failure
 */

1676
int gfs2_dir_del(struct gfs2_inode *dip, const struct qstr *name)
D
David Teigland 已提交
1677
{
1678 1679
	struct gfs2_dirent *dent, *prev = NULL;
	struct buffer_head *bh;
D
David Teigland 已提交
1680 1681
	int error;

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

	dirent_del(dip, bh, prev, dent);
1700
	if (dip->i_diskflags & GFS2_DIF_EXHASH) {
1701 1702 1703 1704 1705 1706
		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);
	}
1707
	brelse(bh);
1708 1709 1710 1711 1712

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

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

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

1738
int gfs2_dir_mvino(struct gfs2_inode *dip, const struct qstr *filename,
1739
		   const struct gfs2_inode *nip, unsigned int new_type)
D
David Teigland 已提交
1740
{
1741 1742
	struct buffer_head *bh;
	struct gfs2_dirent *dent;
D
David Teigland 已提交
1743 1744
	int error;

1745
	dent = gfs2_dirent_search(&dip->i_inode, filename, gfs2_dirent_find, &bh);
1746 1747 1748 1749 1750 1751
	if (!dent) {
		gfs2_consist_inode(dip);
		return -EIO;
	}
	if (IS_ERR(dent))
		return PTR_ERR(dent);
D
David Teigland 已提交
1752

1753
	gfs2_trans_add_bh(dip->i_gl, bh, 1);
1754
	gfs2_inum_out(nip, dent);
1755 1756
	dent->de_type = cpu_to_be16(new_type);

1757
	if (dip->i_diskflags & GFS2_DIF_EXHASH) {
1758 1759 1760 1761 1762 1763 1764
		brelse(bh);
		error = gfs2_meta_inode_buffer(dip, &bh);
		if (error)
			return error;
		gfs2_trans_add_bh(dip->i_gl, bh, 1);
	}

1765
	dip->i_inode.i_mtime = dip->i_inode.i_ctime = CURRENT_TIME;
1766
	gfs2_dinode_out(dip, bh->b_data);
1767 1768
	brelse(bh);
	return 0;
D
David Teigland 已提交
1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781
}

/**
 * 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)
{
1782
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
D
David Teigland 已提交
1783
	struct buffer_head *bh;
1784
	struct gfs2_leaf *leaf;
1785 1786 1787
	u32 hsize, len;
	u32 ht_offset, lp_offset, ht_offset_cur = -1;
	u32 index = 0;
A
Al Viro 已提交
1788
	__be64 *lp;
1789
	u64 leaf_no;
D
David Teigland 已提交
1790 1791
	int error = 0;

1792
	hsize = 1 << dip->i_depth;
1793
	if (hsize * sizeof(u64) != dip->i_disksize) {
D
David Teigland 已提交
1794 1795 1796 1797
		gfs2_consist_inode(dip);
		return -EIO;
	}

J
Josef Bacik 已提交
1798
	lp = kmalloc(sdp->sd_hash_bsize, GFP_NOFS);
D
David Teigland 已提交
1799 1800 1801 1802 1803 1804 1805 1806
	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) {
1807
			error = gfs2_dir_read_data(dip, (char *)lp,
A
Al Viro 已提交
1808
						ht_offset * sizeof(__be64),
S
Steven Whitehouse 已提交
1809
						sdp->sd_hash_bsize, 1);
D
David Teigland 已提交
1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822
			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;
1823
			leaf = (struct gfs2_leaf *)bh->b_data;
1824
			len = 1 << (dip->i_depth - be16_to_cpu(leaf->lf_depth));
1825
			brelse(bh);
D
David Teigland 已提交
1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840

			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;
	}

1841
out:
D
David Teigland 已提交
1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857
	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
 */

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

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

J
Josef Bacik 已提交
1873
	ht = kzalloc(size, GFP_NOFS);
D
David Teigland 已提交
1874 1875 1876
	if (!ht)
		return -ENOMEM;

1877 1878 1879 1880
	if (!gfs2_alloc_get(dip)) {
		error = -ENOMEM;
		goto out;
	}
D
David Teigland 已提交
1881 1882 1883

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

1886
	error = gfs2_rindex_hold(sdp, &dip->i_alloc->al_ri_gh);
D
David Teigland 已提交
1887 1888 1889 1890 1891
	if (error)
		goto out_qs;

	/*  Count the number of leaves  */

1892
	for (blk = leaf_no; blk; blk = nblk) {
D
David Teigland 已提交
1893 1894 1895
		error = get_leaf(dip, blk, &bh);
		if (error)
			goto out_rlist;
1896 1897
		tmp_leaf = (struct gfs2_leaf *)bh->b_data;
		nblk = be64_to_cpu(tmp_leaf->lf_next);
D
David Teigland 已提交
1898 1899 1900 1901 1902 1903
		brelse(bh);

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

1904
	gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE);
D
David Teigland 已提交
1905 1906 1907

	for (x = 0; x < rlist.rl_rgrps; x++) {
		struct gfs2_rgrpd *rgd;
1908
		rgd = rlist.rl_ghs[x].gh_gl->gl_object;
1909
		rg_blocks += rgd->rd_length;
D
David Teigland 已提交
1910 1911 1912 1913 1914 1915 1916
	}

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

	error = gfs2_trans_begin(sdp,
1917
			rg_blocks + (DIV_ROUND_UP(size, sdp->sd_jbsize) + 1) +
D
David Teigland 已提交
1918 1919 1920 1921
			RES_DINODE + RES_STATFS + RES_QUOTA, l_blocks);
	if (error)
		goto out_rg_gunlock;

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

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

1934
	error = gfs2_dir_write_data(dip, ht, index * sizeof(u64), size);
D
David Teigland 已提交
1935 1936 1937 1938 1939 1940 1941 1942 1943 1944
	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;

1945
	gfs2_trans_add_bh(dip->i_gl, dibh, 1);
1946
	gfs2_dinode_out(dip, dibh->b_data);
D
David Teigland 已提交
1947 1948
	brelse(dibh);

1949
out_end_trans:
D
David Teigland 已提交
1950
	gfs2_trans_end(sdp);
1951
out_rg_gunlock:
D
David Teigland 已提交
1952
	gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);
1953
out_rlist:
D
David Teigland 已提交
1954
	gfs2_rlist_free(&rlist);
1955
	gfs2_glock_dq_uninit(&dip->i_alloc->al_ri_gh);
1956
out_qs:
D
David Teigland 已提交
1957
	gfs2_quota_unhold(dip);
1958
out_put:
D
David Teigland 已提交
1959
	gfs2_alloc_put(dip);
1960
out:
D
David Teigland 已提交
1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976
	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)
{
1977
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
D
David Teigland 已提交
1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994
	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) {
1995
		gfs2_trans_add_bh(dip->i_gl, bh, 1);
1996 1997
		((struct gfs2_dinode *)bh->b_data)->di_mode =
						cpu_to_be32(S_IFREG);
D
David Teigland 已提交
1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010
		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
 *
2011
 * Returns: 1 if alloc required, 0 if not, -ve on error
D
David Teigland 已提交
2012 2013
 */

2014
int gfs2_diradd_alloc_required(struct inode *inode, const struct qstr *name)
D
David Teigland 已提交
2015
{
2016 2017
	struct gfs2_dirent *dent;
	struct buffer_head *bh;
D
David Teigland 已提交
2018

2019
	dent = gfs2_dirent_search(inode, name, gfs2_dirent_find_space, &bh);
2020
	if (!dent) {
2021
		return 1;
2022
	}
2023 2024 2025 2026
	if (IS_ERR(dent))
		return PTR_ERR(dent);
	brelse(bh);
	return 0;
D
David Teigland 已提交
2027 2028
}