dir.c 45.8 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 60

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

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

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

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

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

89

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

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

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

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

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);
131
	memcpy(dibh->b_data + offset + sizeof(struct gfs2_dinode), buf, size);
132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
	if (ip->i_di.di_size < offset + size)
		ip->i_di.di_size = offset + size;
	ip->i_di.di_mtime = ip->i_di.di_ctime = get_seconds();
	gfs2_dinode_out(&ip->i_di, dibh->b_data);

	brelse(dibh);

	return size;
}



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

	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
	}

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

	while (copied < size) {
		unsigned int amount;
		struct buffer_head *bh;
187
		int new = 0;
188 189 190 191 192 193 194

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

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

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

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

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

216
		buf += amount;
217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
		copied += amount;
		lblock++;
		dblock++;
		extlen--;

		o = sizeof(struct gfs2_meta_header);
	}

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

	if (ip->i_di.di_size < offset + copied)
		ip->i_di.di_size = offset + copied;
	ip->i_di.di_mtime = ip->i_di.di_ctime = get_seconds();

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

	if (offset >= ip->i_di.di_size)
		return 0;

J
Jan Engelhardt 已提交
284
	if (offset + size > ip->i_di.di_size)
285 286 287 288 289 290
		size = ip->i_di.di_size - offset;

	if (!size)
		return 0;

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

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

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

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

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

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

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

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

391 392
	if (!dent->de_inum.no_addr)
		actual = GFS2_DIRENT_SIZE(0);
J
Jan Engelhardt 已提交
393
	if (totlen - actual >= required)
394 395 396 397
		return 1;
	return 0;
}

398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413
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;
	if (dent->de_inum.no_addr) {
		g->pdent[g->offset++] = dent;
	}
	return 0;
}

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

450
static int gfs2_dirent_offset(const void *buf)
451
{
452 453
	const struct gfs2_meta_header *h = buf;
	int offset;
454 455 456

	BUG_ON(buf == NULL);

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

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

484 485 486 487 488
	ret = gfs2_dirent_offset(buf);
	if (ret < 0)
		goto consist_inode;

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


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

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

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

591 592 593
	ret = dirent_check_reclen(dip, cur, bh_end);
	if (ret < 0)
		return ret;
594

595 596 597 598
	tmp = (void *)cur + ret;
	ret = dirent_check_reclen(dip, tmp, bh_end);
	if (ret == -EIO)
		return ret;
599

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

	if (!cur->de_inum.no_addr) {
		gfs2_consist_inode(dip);
		return;
	}

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

	/* 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) {
		cur->de_inum.no_addr = 0;	/* No endianess worries */
		return;
	}

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

642 643
	prev_rec_len = be16_to_cpu(prev->de_rec_len);
	cur_rec_len = be16_to_cpu(cur->de_rec_len);
D
David Teigland 已提交
644 645 646 647 648 649 650

	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;
651
	prev->de_rec_len = cpu_to_be16(prev_rec_len);
D
David Teigland 已提交
652 653
}

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

	if (dent->de_inum.no_addr)
		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 已提交
676 677
}

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

690
static int get_leaf(struct gfs2_inode *dip, u64 leaf_no,
D
David Teigland 已提交
691 692 693 694
		    struct buffer_head **bhp)
{
	int error;

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

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

713 714
static int get_leaf_nr(struct gfs2_inode *dip, u32 index,
		       u64 *leaf_out)
D
David Teigland 已提交
715
{
716
	u64 leaf_no;
D
David Teigland 已提交
717 718
	int error;

719
	error = gfs2_dir_read_data(dip, (char *)&leaf_no,
720
				    index * sizeof(u64),
S
Steven Whitehouse 已提交
721
				    sizeof(u64), 0);
722
	if (error != sizeof(u64))
D
David Teigland 已提交
723 724 725 726 727 728 729
		return (error < 0) ? error : -EIO;

	*leaf_out = be64_to_cpu(leaf_no);

	return 0;
}

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

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

	return error;
}

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

753 754 755 756 757 758 759 760 761
	if (ip->i_di.di_flags & GFS2_DIF_EXHASH) {
		struct gfs2_leaf *leaf;
		unsigned hsize = 1 << ip->i_di.di_depth;
		unsigned index;
		u64 ln;
		if (hsize * sizeof(u64) != ip->i_di.di_size) {
			gfs2_consist_inode(ip);
			return ERR_PTR(-EIO);
		}
762

763 764 765 766 767 768
		index = name->hash >> (32 - ip->i_di.di_depth);
		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,
769
						scan, name, NULL);
770 771 772 773
			if (dent)
				goto got_dent;
			leaf = (struct gfs2_leaf *)bh->b_data;
			ln = be64_to_cpu(leaf->lf_next);
774
			brelse(bh);
775 776
			if (!ln)
				break;
777

778 779
			error = get_leaf(ip, ln, &bh);
		} while(!error);
D
David Teigland 已提交
780

781
		return error ? ERR_PTR(error) : NULL;
D
David Teigland 已提交
782 783
	}

784

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

798 799
static struct gfs2_leaf *new_leaf(struct inode *inode, struct buffer_head **pbh, u16 depth)
{
800
	struct gfs2_inode *ip = GFS2_I(inode);
801 802 803 804
	u64 bn = gfs2_alloc_meta(ip);
	struct buffer_head *bh = gfs2_meta_new(ip->i_gl, bn);
	struct gfs2_leaf *leaf;
	struct gfs2_dirent *dent;
805
	struct qstr name = { .name = "", .len = 0, .hash = 0 };
806 807
	if (!bh)
		return NULL;
808

809 810 811 812
	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);
813
	leaf->lf_entries = 0;
814
	leaf->lf_dirent_format = cpu_to_be32(GFS2_FORMAT_DE);
815
	leaf->lf_next = 0;
816 817
	memset(leaf->lf_reserved, 0, sizeof(leaf->lf_reserved));
	dent = (struct gfs2_dirent *)(leaf+1);
818
	gfs2_qstr2dirent(&name, bh->b_size - sizeof(struct gfs2_leaf), dent);
819 820
	*pbh = bh;
	return leaf;
D
David Teigland 已提交
821 822 823 824 825 826 827 828 829
}

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

830
static int dir_make_exhash(struct inode *inode)
D
David Teigland 已提交
831
{
832 833
	struct gfs2_inode *dip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
D
David Teigland 已提交
834
	struct gfs2_dirent *dent;
835
	struct qstr args;
D
David Teigland 已提交
836 837 838
	struct buffer_head *bh, *dibh;
	struct gfs2_leaf *leaf;
	int y;
839 840
	u32 x;
	u64 *lp, bn;
D
David Teigland 已提交
841 842 843 844 845 846 847 848
	int error;

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

	/*  Turn over a new leaf  */

849 850 851 852
	leaf = new_leaf(inode, &bh, 0);
	if (!leaf)
		return -ENOSPC;
	bn = bh->b_blocknr;
D
David Teigland 已提交
853 854 855 856 857 858 859 860 861 862 863 864

	gfs2_assert(sdp, dip->i_di.di_entries < (1 << 16));
	leaf->lf_entries = cpu_to_be16(dip->i_di.di_entries);

	/*  Copy dirents  */

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

	/*  Find last entry  */

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

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

884
	dent->de_rec_len = cpu_to_be16(be16_to_cpu(dent->de_rec_len) +
D
David Teigland 已提交
885
		sizeof(struct gfs2_dinode) -
886
		sizeof(struct gfs2_leaf));
D
David Teigland 已提交
887 888 889 890 891 892

	brelse(bh);

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

893
	gfs2_trans_add_bh(dip->i_gl, dibh, 1);
D
David Teigland 已提交
894 895
	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));

896
	lp = (u64 *)(dibh->b_data + sizeof(struct gfs2_dinode));
D
David Teigland 已提交
897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924

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

	dip->i_di.di_size = sdp->sd_sb.sb_bsize / 2;
	dip->i_di.di_blocks++;
	dip->i_di.di_flags |= GFS2_DIF_EXHASH;
	dip->i_di.di_payload_format = 0;

	for (x = sdp->sd_hash_ptrs, y = -1; x; x >>= 1, y++) ;
	dip->i_di.di_depth = y;

	gfs2_dinode_out(&dip->i_di, dibh->b_data);

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

925
static int dir_split_leaf(struct inode *inode, const struct qstr *name)
D
David Teigland 已提交
926
{
927
	struct gfs2_inode *dip = GFS2_I(inode);
D
David Teigland 已提交
928 929
	struct buffer_head *nbh, *obh, *dibh;
	struct gfs2_leaf *nleaf, *oleaf;
930
	struct gfs2_dirent *dent = NULL, *prev = NULL, *next = NULL, *new;
931 932 933
	u32 start, len, half_len, divider;
	u64 bn, *lp, leaf_no;
	u32 index;
D
David Teigland 已提交
934 935 936
	int x, moved = 0;
	int error;

937 938 939 940
	index = name->hash >> (32 - dip->i_di.di_depth);
	error = get_leaf_nr(dip, index, &leaf_no);
	if (error)
		return error;
D
David Teigland 已提交
941 942 943 944

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

	oleaf = (struct gfs2_leaf *)obh->b_data;
948 949 950 951 952 953
	if (dip->i_di.di_depth == be16_to_cpu(oleaf->lf_depth)) {
		brelse(obh);
		return 1; /* can't split */
	}

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

955 956 957 958 959 960
	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 已提交
961

962
	/*  Compute the start and len of leaf pointers in the hash table.  */
D
David Teigland 已提交
963 964 965
	len = 1 << (dip->i_di.di_depth - be16_to_cpu(oleaf->lf_depth));
	half_len = len >> 1;
	if (!half_len) {
966
		printk(KERN_WARNING "di_depth %u lf_depth %u index %u\n", dip->i_di.di_depth, be16_to_cpu(oleaf->lf_depth), index);
D
David Teigland 已提交
967 968 969 970 971 972 973 974 975 976
		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. */
977
	lp = kmalloc(half_len * sizeof(u64), GFP_NOFS | __GFP_NOFAIL);
D
David Teigland 已提交
978 979 980 981
	/*  Change the pointers  */
	for (x = 0; x < half_len; x++)
		lp[x] = cpu_to_be64(bn);

982 983 984
	error = gfs2_dir_write_data(dip, (char *)lp, start * sizeof(u64),
				    half_len * sizeof(u64));
	if (error != half_len * sizeof(u64)) {
D
David Teigland 已提交
985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004
		if (error >= 0)
			error = -EIO;
		goto fail_lpfree;
	}

	kfree(lp);

	/*  Compute the divider  */
	divider = (start + half_len) << (32 - dip->i_di.di_depth);

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

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

		if (dent->de_inum.no_addr &&
		    be32_to_cpu(dent->de_hash) < divider) {
1005 1006 1007 1008
			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);
1009
			new = gfs2_dirent_alloc(inode, nbh, &str);
1010 1011 1012 1013
			if (IS_ERR(new)) {
				error = PTR_ERR(new);
				break;
			}
D
David Teigland 已提交
1014 1015 1016

			new->de_inum = dent->de_inum; /* No endian worries */
			new->de_type = dent->de_type; /* No endian worries */
1017
			nleaf->lf_entries = cpu_to_be16(be16_to_cpu(nleaf->lf_entries)+1);
D
David Teigland 已提交
1018 1019 1020 1021 1022

			dirent_del(dip, obh, prev, dent);

			if (!oleaf->lf_entries)
				gfs2_consist_inode(dip);
1023
			oleaf->lf_entries = cpu_to_be16(be16_to_cpu(oleaf->lf_entries)-1);
D
David Teigland 已提交
1024 1025 1026 1027 1028

			if (!prev)
				prev = dent;

			moved = 1;
1029
		} else {
D
David Teigland 已提交
1030
			prev = dent;
1031
		}
D
David Teigland 已提交
1032
		dent = next;
1033
	} while (dent);
D
David Teigland 已提交
1034

1035
	oleaf->lf_depth = nleaf->lf_depth;
D
David Teigland 已提交
1036 1037

	error = gfs2_meta_inode_buffer(dip, &dibh);
1038
	if (!gfs2_assert_withdraw(GFS2_SB(&dip->i_inode), !error)) {
D
David Teigland 已提交
1039 1040 1041 1042 1043 1044 1045 1046 1047 1048
		dip->i_di.di_blocks++;
		gfs2_dinode_out(&dip->i_di, dibh->b_data);
		brelse(dibh);
	}

	brelse(obh);
	brelse(nbh);

	return error;

1049
fail_lpfree:
D
David Teigland 已提交
1050 1051
	kfree(lp);

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

	hsize = 1 << dip->i_di.di_depth;
1077
	if (hsize * sizeof(u64) != dip->i_di.di_size) {
D
David Teigland 已提交
1078 1079 1080 1081 1082 1083 1084 1085 1086
		gfs2_consist_inode(dip);
		return -EIO;
	}

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

	buf = kcalloc(3, sdp->sd_hash_bsize, GFP_KERNEL | __GFP_NOFAIL);

	for (block = dip->i_di.di_size >> sdp->sd_hash_bsize_shift; block--;) {
1087
		error = gfs2_dir_read_data(dip, (char *)buf,
D
David Teigland 已提交
1088
					    block * sdp->sd_hash_bsize,
S
Steven Whitehouse 已提交
1089
					    sdp->sd_hash_bsize, 1);
D
David Teigland 已提交
1090 1091 1092 1093 1094 1095 1096
		if (error != sdp->sd_hash_bsize) {
			if (error >= 0)
				error = -EIO;
			goto fail;
		}

		from = buf;
1097
		to = (u64 *)((char *)buf + sdp->sd_hash_bsize);
D
David Teigland 已提交
1098 1099 1100 1101 1102 1103

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

1104
		error = gfs2_dir_write_data(dip,
D
David Teigland 已提交
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125
					     (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)) {
		dip->i_di.di_depth++;
		gfs2_dinode_out(&dip->i_di, dibh->b_data);
		brelse(dibh);
	}

	return error;

1126
fail:
D
David Teigland 已提交
1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143
	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)
{
1144
	const struct gfs2_dirent *dent_a, *dent_b;
1145
	u32 hash_a, hash_b;
D
David Teigland 已提交
1146 1147
	int ret = 0;

1148
	dent_a = *(const struct gfs2_dirent **)a;
1149
	hash_a = be32_to_cpu(dent_a->de_hash);
D
David Teigland 已提交
1150

1151
	dent_b = *(const struct gfs2_dirent **)b;
1152
	hash_b = be32_to_cpu(dent_b->de_hash);
D
David Teigland 已提交
1153 1154 1155 1156 1157 1158

	if (hash_a > hash_b)
		ret = 1;
	else if (hash_a < hash_b)
		ret = -1;
	else {
1159 1160
		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 已提交
1161 1162 1163 1164 1165 1166

		if (len_a > len_b)
			ret = 1;
		else if (len_a < len_b)
			ret = -1;
		else
1167
			ret = memcmp(dent_a + 1, dent_b + 1, len_a);
D
David Teigland 已提交
1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190
	}

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

1191
static int do_filldir_main(struct gfs2_inode *dip, u64 *offset,
D
David Teigland 已提交
1192
			   void *opaque, gfs2_filldir_t filldir,
1193
			   const struct gfs2_dirent **darr, u32 entries,
D
David Teigland 已提交
1194 1195
			   int *copied)
{
1196
	const struct gfs2_dirent *dent, *dent_next;
D
David Teigland 已提交
1197
	struct gfs2_inum inum;
1198
	u64 off, off_next;
D
David Teigland 已提交
1199 1200 1201 1202 1203 1204 1205 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
	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;
		}

		gfs2_inum_in(&inum, (char *)&dent->de_inum);

1236
		error = filldir(opaque, (const char *)(dent + 1),
1237
				be16_to_cpu(dent->de_name_len),
D
David Teigland 已提交
1238
				off, &inum,
1239
				be16_to_cpu(dent->de_type));
D
David Teigland 已提交
1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254
		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;
}

1255 1256 1257
static int gfs2_dir_read_leaf(struct inode *inode, u64 *offset, void *opaque,
			      gfs2_filldir_t filldir, int *copied,
			      unsigned *depth, u64 leaf_no)
D
David Teigland 已提交
1258
{
1259
	struct gfs2_inode *ip = GFS2_I(inode);
1260 1261 1262 1263 1264 1265 1266 1267 1268 1269
	struct buffer_head *bh;
	struct gfs2_leaf *lf;
	unsigned entries = 0;
	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 已提交
1270 1271

	do {
1272
		error = get_leaf(ip, lfn, &bh);
D
David Teigland 已提交
1273
		if (error)
1274 1275 1276 1277 1278 1279 1280 1281 1282
			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 已提交
1283 1284 1285 1286

	if (!entries)
		return 0;

1287
	error = -ENOMEM;
1288
	larr = vmalloc((leaves + entries) * sizeof(void *));
1289 1290 1291 1292 1293 1294
	if (!larr)
		goto out;
	darr = (const struct gfs2_dirent **)(larr + leaves);
	g.pdent = darr;
	g.offset = 0;
	lfn = leaf_no;
D
David Teigland 已提交
1295

1296 1297
	do {
		error = get_leaf(ip, lfn, &bh);
D
David Teigland 已提交
1298
		if (error)
1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310
			goto out_kfree;
		lf = (struct gfs2_leaf *)bh->b_data;
		lfn = be64_to_cpu(lf->lf_next);
		if (lf->lf_entries) {
			dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size,
						gfs2_dirent_gather, NULL, &g);
			error = PTR_ERR(dent);
			if (IS_ERR(dent)) {
				goto out_kfree;
			}
			error = 0;
			larr[leaf++] = bh;
D
David Teigland 已提交
1311
		} else {
1312
			brelse(bh);
D
David Teigland 已提交
1313
		}
1314
	} while(lfn);
D
David Teigland 已提交
1315

1316
	error = do_filldir_main(ip, offset, opaque, filldir, darr,
D
David Teigland 已提交
1317
				entries, copied);
1318 1319 1320
out_kfree:
	for(i = 0; i < leaf; i++)
		brelse(larr[i]);
1321
	vfree(larr);
1322
out:
D
David Teigland 已提交
1323 1324 1325 1326
	return error;
}

/**
1327 1328 1329 1330 1331
 * 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 已提交
1332
 *
1333
 * Returns: errno
D
David Teigland 已提交
1334 1335
 */

1336
static int dir_e_read(struct inode *inode, u64 *offset, void *opaque,
1337
		      gfs2_filldir_t filldir)
D
David Teigland 已提交
1338
{
1339 1340
	struct gfs2_inode *dip = GFS2_I(inode);
	struct gfs2_sbd *sdp = GFS2_SB(inode);
1341 1342 1343 1344
	u32 hsize, len = 0;
	u32 ht_offset, lp_offset, ht_offset_cur = -1;
	u32 hash, index;
	u64 *lp;
1345 1346
	int copied = 0;
	int error = 0;
1347
	unsigned depth = 0;
D
David Teigland 已提交
1348 1349

	hsize = 1 << dip->i_di.di_depth;
1350
	if (hsize * sizeof(u64) != dip->i_di.di_size) {
D
David Teigland 已提交
1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366
		gfs2_consist_inode(dip);
		return -EIO;
	}

	hash = gfs2_dir_offset2hash(*offset);
	index = hash >> (32 - dip->i_di.di_depth);

	lp = kmalloc(sdp->sd_hash_bsize, GFP_KERNEL);
	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) {
1367
			error = gfs2_dir_read_data(dip, (char *)lp,
1368
						ht_offset * sizeof(u64),
S
Steven Whitehouse 已提交
1369
						sdp->sd_hash_bsize, 1);
D
David Teigland 已提交
1370 1371 1372 1373 1374 1375 1376 1377
			if (error != sdp->sd_hash_bsize) {
				if (error >= 0)
					error = -EIO;
				goto out;
			}
			ht_offset_cur = ht_offset;
		}

1378 1379 1380
		error = gfs2_dir_read_leaf(inode, offset, opaque, filldir,
					   &copied, &depth,
					   be64_to_cpu(lp[lp_offset]));
D
David Teigland 已提交
1381
		if (error)
1382
			break;
D
David Teigland 已提交
1383

1384
		len = 1 << (dip->i_di.di_depth - depth);
D
David Teigland 已提交
1385 1386 1387
		index = (index & ~(len - 1)) + len;
	}

1388
out:
D
David Teigland 已提交
1389
	kfree(lp);
1390 1391
	if (error > 0)
		error = 0;
D
David Teigland 已提交
1392 1393 1394
	return error;
}

1395
int gfs2_dir_read(struct inode *inode, u64 *offset, void *opaque,
1396
		  gfs2_filldir_t filldir)
D
David Teigland 已提交
1397
{
1398
	struct gfs2_inode *dip = GFS2_I(inode);
1399 1400
	struct dirent_gather g;
	const struct gfs2_dirent **darr, *dent;
D
David Teigland 已提交
1401 1402 1403 1404
	struct buffer_head *dibh;
	int copied = 0;
	int error;

1405 1406 1407 1408 1409 1410
	if (!dip->i_di.di_entries)
		return 0;

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

D
David Teigland 已提交
1411 1412 1413 1414 1415 1416 1417 1418 1419
	if (!gfs2_is_stuffed(dip)) {
		gfs2_consist_inode(dip);
		return -EIO;
	}

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

1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437
	error = -ENOMEM;
	darr = kmalloc(dip->i_di.di_entries * sizeof(struct gfs2_dirent *),
		       GFP_KERNEL);
	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;
		}
		error = do_filldir_main(dip, offset, opaque, filldir, darr,
					dip->i_di.di_entries, &copied);
out:
		kfree(darr);
	}

D
David Teigland 已提交
1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457
	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
 */

1458
int gfs2_dir_search(struct inode *dir, const struct qstr *name,
D
David Teigland 已提交
1459 1460
		    struct gfs2_inum *inum, unsigned int *type)
{
1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480
	struct buffer_head *bh;
	struct gfs2_dirent *dent;

	dent = gfs2_dirent_search(dir, name, gfs2_dirent_find, &bh);
	if (dent) {
		if (IS_ERR(dent))
			return PTR_ERR(dent);
		if (inum)
			gfs2_inum_in(inum, (char *)&dent->de_inum);
		if (type)
			*type = be16_to_cpu(dent->de_type);
		brelse(bh);
		return 0;
	}
	return -ENOENT;
}

static int dir_new_leaf(struct inode *inode, const struct qstr *name)
{
	struct buffer_head *bh, *obh;
1481
	struct gfs2_inode *ip = GFS2_I(inode);
1482
	struct gfs2_leaf *leaf, *oleaf;
D
David Teigland 已提交
1483
	int error;
1484 1485
	u32 index;
	u64 bn;
D
David Teigland 已提交
1486

1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500
	index = name->hash >> (32 - ip->i_di.di_depth);
	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 已提交
1501

1502 1503 1504 1505 1506 1507 1508
	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;
	}
1509
	oleaf->lf_next = cpu_to_be64(bh->b_blocknr);
1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520
	brelse(bh);
	brelse(obh);

	error = gfs2_meta_inode_buffer(ip, &bh);
	if (error)
		return error;
	gfs2_trans_add_bh(ip->i_gl, bh, 1);
	ip->i_di.di_blocks++;
	gfs2_dinode_out(&ip->i_di, bh->b_data);
	brelse(bh);
	return 0;
D
David Teigland 已提交
1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532
}

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

1533 1534
int gfs2_dir_add(struct inode *inode, const struct qstr *name,
		 const struct gfs2_inum *inum, unsigned type)
D
David Teigland 已提交
1535
{
1536
	struct gfs2_inode *ip = GFS2_I(inode);
1537 1538 1539
	struct buffer_head *bh;
	struct gfs2_dirent *dent;
	struct gfs2_leaf *leaf;
D
David Teigland 已提交
1540 1541
	int error;

1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575
	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);
			gfs2_inum_out(inum, (char *)&dent->de_inum);
			dent->de_type = cpu_to_be16(type);
			if (ip->i_di.di_flags & GFS2_DIF_EXHASH) {
				leaf = (struct gfs2_leaf *)bh->b_data;
				leaf->lf_entries = cpu_to_be16(be16_to_cpu(leaf->lf_entries) + 1);
			}
			brelse(bh);
			error = gfs2_meta_inode_buffer(ip, &bh);
			if (error)
				break;
			gfs2_trans_add_bh(ip->i_gl, bh, 1);
			ip->i_di.di_entries++;
			ip->i_di.di_mtime = ip->i_di.di_ctime = get_seconds();
			gfs2_dinode_out(&ip->i_di, bh->b_data);
			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;
1576
		if (error < 0)
1577 1578 1579 1580 1581 1582
			break;
		if (ip->i_di.di_depth < GFS2_DIR_MAX_DEPTH) {
			error = dir_double_exhash(ip);
			if (error)
				break;
			error = dir_split_leaf(inode, name);
1583
			if (error < 0)
1584
				break;
1585 1586
			if (error == 0)
				continue;
1587 1588 1589 1590 1591 1592 1593
		}
		error = dir_new_leaf(inode, name);
		if (!error)
			continue;
		error = -ENOSPC;
		break;
	}
D
David Teigland 已提交
1594 1595 1596
	return error;
}

1597

D
David Teigland 已提交
1598 1599 1600 1601 1602 1603 1604 1605
/**
 * gfs2_dir_del - Delete a directory entry
 * @dip: The GFS2 inode
 * @filename: The filename
 *
 * Returns: 0 on success, error code on failure
 */

1606
int gfs2_dir_del(struct gfs2_inode *dip, const struct qstr *name)
D
David Teigland 已提交
1607
{
1608 1609
	struct gfs2_dirent *dent, *prev = NULL;
	struct buffer_head *bh;
D
David Teigland 已提交
1610 1611
	int error;

1612 1613
	/* Returns _either_ the entry (if its first in block) or the
	   previous entry otherwise */
1614
	dent = gfs2_dirent_search(&dip->i_inode, name, gfs2_dirent_prev, &bh);
1615 1616 1617 1618 1619 1620 1621 1622 1623
	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 */
1624
	if (gfs2_dirent_find(dent, name, NULL) == 0) {
1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636
		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);
	}
1637
	brelse(bh);
1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649

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

	if (!dip->i_di.di_entries)
		gfs2_consist_inode(dip);
	gfs2_trans_add_bh(dip->i_gl, bh, 1);
	dip->i_di.di_entries--;
	dip->i_di.di_mtime = dip->i_di.di_ctime = get_seconds();
	gfs2_dinode_out(&dip->i_di, bh->b_data);
	brelse(bh);
1650
	mark_inode_dirty(&dip->i_inode);
D
David Teigland 已提交
1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667

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

1668
int gfs2_dir_mvino(struct gfs2_inode *dip, const struct qstr *filename,
D
David Teigland 已提交
1669 1670
		   struct gfs2_inum *inum, unsigned int new_type)
{
1671 1672
	struct buffer_head *bh;
	struct gfs2_dirent *dent;
D
David Teigland 已提交
1673 1674
	int error;

1675
	dent = gfs2_dirent_search(&dip->i_inode, filename, gfs2_dirent_find, &bh);
1676 1677 1678 1679 1680 1681
	if (!dent) {
		gfs2_consist_inode(dip);
		return -EIO;
	}
	if (IS_ERR(dent))
		return PTR_ERR(dent);
D
David Teigland 已提交
1682

1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698
	gfs2_trans_add_bh(dip->i_gl, bh, 1);
	gfs2_inum_out(inum, (char *)&dent->de_inum);
	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);
	}

	dip->i_di.di_mtime = dip->i_di.di_ctime = get_seconds();
	gfs2_dinode_out(&dip->i_di, bh->b_data);
	brelse(bh);
	return 0;
D
David Teigland 已提交
1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711
}

/**
 * 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)
{
1712
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
D
David Teigland 已提交
1713
	struct buffer_head *bh;
1714
	struct gfs2_leaf *leaf;
1715 1716 1717 1718 1719
	u32 hsize, len;
	u32 ht_offset, lp_offset, ht_offset_cur = -1;
	u32 index = 0;
	u64 *lp;
	u64 leaf_no;
D
David Teigland 已提交
1720 1721 1722
	int error = 0;

	hsize = 1 << dip->i_di.di_depth;
1723
	if (hsize * sizeof(u64) != dip->i_di.di_size) {
D
David Teigland 已提交
1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736
		gfs2_consist_inode(dip);
		return -EIO;
	}

	lp = kmalloc(sdp->sd_hash_bsize, GFP_KERNEL);
	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) {
1737
			error = gfs2_dir_read_data(dip, (char *)lp,
1738
						ht_offset * sizeof(u64),
S
Steven Whitehouse 已提交
1739
						sdp->sd_hash_bsize, 1);
D
David Teigland 已提交
1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752
			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;
1753 1754
			leaf = (struct gfs2_leaf *)bh->b_data;
			len = 1 << (dip->i_di.di_depth - be16_to_cpu(leaf->lf_depth));
1755
			brelse(bh);
D
David Teigland 已提交
1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770

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

1771
out:
D
David Teigland 已提交
1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787
	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
 */

1788 1789
static int leaf_dealloc(struct gfs2_inode *dip, u32 index, u32 len,
			u64 leaf_no, void *data)
D
David Teigland 已提交
1790
{
1791
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
1792
	struct gfs2_leaf *tmp_leaf;
D
David Teigland 已提交
1793 1794
	struct gfs2_rgrp_list rlist;
	struct buffer_head *bh, *dibh;
1795
	u64 blk, nblk;
D
David Teigland 已提交
1796 1797
	unsigned int rg_blocks = 0, l_blocks = 0;
	char *ht;
1798
	unsigned int x, size = len * sizeof(u64);
D
David Teigland 已提交
1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818
	int error;

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

	ht = kzalloc(size, GFP_KERNEL);
	if (!ht)
		return -ENOMEM;

	gfs2_alloc_get(dip);

	error = gfs2_quota_hold(dip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
	if (error)
		goto out;

	error = gfs2_rindex_hold(sdp, &dip->i_alloc.al_ri_gh);
	if (error)
		goto out_qs;

	/*  Count the number of leaves  */

1819
	for (blk = leaf_no; blk; blk = nblk) {
D
David Teigland 已提交
1820 1821 1822
		error = get_leaf(dip, blk, &bh);
		if (error)
			goto out_rlist;
1823 1824
		tmp_leaf = (struct gfs2_leaf *)bh->b_data;
		nblk = be64_to_cpu(tmp_leaf->lf_next);
D
David Teigland 已提交
1825 1826 1827 1828 1829 1830 1831 1832 1833 1834
		brelse(bh);

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

	gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE, 0);

	for (x = 0; x < rlist.rl_rgrps; x++) {
		struct gfs2_rgrpd *rgd;
1835
		rgd = rlist.rl_ghs[x].gh_gl->gl_object;
D
David Teigland 已提交
1836 1837 1838 1839 1840 1841 1842 1843
		rg_blocks += rgd->rd_ri.ri_length;
	}

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

	error = gfs2_trans_begin(sdp,
1844
			rg_blocks + (DIV_ROUND_UP(size, sdp->sd_jbsize) + 1) +
D
David Teigland 已提交
1845 1846 1847 1848
			RES_DINODE + RES_STATFS + RES_QUOTA, l_blocks);
	if (error)
		goto out_rg_gunlock;

1849
	for (blk = leaf_no; blk; blk = nblk) {
D
David Teigland 已提交
1850 1851 1852
		error = get_leaf(dip, blk, &bh);
		if (error)
			goto out_end_trans;
1853 1854
		tmp_leaf = (struct gfs2_leaf *)bh->b_data;
		nblk = be64_to_cpu(tmp_leaf->lf_next);
D
David Teigland 已提交
1855 1856 1857 1858 1859 1860 1861 1862 1863
		brelse(bh);

		gfs2_free_meta(dip, blk, 1);

		if (!dip->i_di.di_blocks)
			gfs2_consist_inode(dip);
		dip->i_di.di_blocks--;
	}

1864
	error = gfs2_dir_write_data(dip, ht, index * sizeof(u64), size);
D
David Teigland 已提交
1865 1866 1867 1868 1869 1870 1871 1872 1873 1874
	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;

1875
	gfs2_trans_add_bh(dip->i_gl, dibh, 1);
D
David Teigland 已提交
1876 1877 1878
	gfs2_dinode_out(&dip->i_di, dibh->b_data);
	brelse(dibh);

1879
out_end_trans:
D
David Teigland 已提交
1880
	gfs2_trans_end(sdp);
1881
out_rg_gunlock:
D
David Teigland 已提交
1882
	gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);
1883
out_rlist:
D
David Teigland 已提交
1884 1885
	gfs2_rlist_free(&rlist);
	gfs2_glock_dq_uninit(&dip->i_alloc.al_ri_gh);
1886
out_qs:
D
David Teigland 已提交
1887
	gfs2_quota_unhold(dip);
1888
out:
D
David Teigland 已提交
1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905
	gfs2_alloc_put(dip);
	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)
{
1906
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
D
David Teigland 已提交
1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923
	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) {
1924
		gfs2_trans_add_bh(dip->i_gl, bh, 1);
1925 1926
		((struct gfs2_dinode *)bh->b_data)->di_mode =
						cpu_to_be32(S_IFREG);
D
David Teigland 已提交
1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939
		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
 *
1940
 * Returns: 1 if alloc required, 0 if not, -ve on error
D
David Teigland 已提交
1941 1942
 */

1943
int gfs2_diradd_alloc_required(struct inode *inode, const struct qstr *name)
D
David Teigland 已提交
1944
{
1945 1946
	struct gfs2_dirent *dent;
	struct buffer_head *bh;
D
David Teigland 已提交
1947

1948
	dent = gfs2_dirent_search(inode, name, gfs2_dirent_find_space, &bh);
1949
	if (!dent) {
1950
		return 1;
1951
	}
1952 1953 1954 1955
	if (IS_ERR(dent))
		return PTR_ERR(dent);
	brelse(bh);
	return 0;
D
David Teigland 已提交
1956 1957
}