dir.c 16.5 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13
/*
 *  linux/fs/ufs/ufs_dir.c
 *
 * Copyright (C) 1996
 * Adrian Rodriguez (adrian@franklins-tower.rutgers.edu)
 * Laboratory for Computer Science Research Computing Facility
 * Rutgers, The State University of New Jersey
 *
 * swab support by Francois-Rene Rideau <fare@tunes.org> 19970406
 *
 * 4.4BSD (FreeBSD) support added on February 1st 1998 by
 * Niels Kristian Bech Jensen <nkbj@image.dk> partially based
 * on code by Martin von Loewis <martin@mira.isdn.cs.tu-berlin.de>.
14 15 16
 *
 * Migration to usage of "page cache" on May 2006 by
 * Evgeniy Dushistov <dushistov@mail.ru> based on ext2 code base.
L
Linus Torvalds 已提交
17 18 19 20
 */

#include <linux/time.h>
#include <linux/fs.h>
N
Nick Piggin 已提交
21
#include <linux/swap.h>
L
Linus Torvalds 已提交
22

23
#include "ufs_fs.h"
24
#include "ufs.h"
L
Linus Torvalds 已提交
25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42
#include "swab.h"
#include "util.h"

/*
 * NOTE! unlike strncmp, ufs_match returns 1 for success, 0 for failure.
 *
 * len <= UFS_MAXNAMLEN and de != NULL are guaranteed by caller.
 */
static inline int ufs_match(struct super_block *sb, int len,
		const char * const name, struct ufs_dir_entry * de)
{
	if (len != ufs_get_de_namlen(sb, de))
		return 0;
	if (!de->d_ino)
		return 0;
	return !memcmp(name, de->d_name, len);
}

N
Nick Piggin 已提交
43
static int ufs_commit_chunk(struct page *page, loff_t pos, unsigned len)
L
Linus Torvalds 已提交
44
{
N
Nick Piggin 已提交
45 46
	struct address_space *mapping = page->mapping;
	struct inode *dir = mapping->host;
47
	int err = 0;
N
Nick Piggin 已提交
48

49
	dir->i_version++;
N
Nick Piggin 已提交
50 51 52 53 54
	block_write_end(NULL, mapping, pos, len, len, page, NULL);
	if (pos+len > dir->i_size) {
		i_size_write(dir, pos+len);
		mark_inode_dirty(dir);
	}
55 56 57 58 59 60
	if (IS_DIRSYNC(dir))
		err = write_one_page(page, 1);
	else
		unlock_page(page);
	return err;
}
L
Linus Torvalds 已提交
61

62 63 64 65 66
static inline void ufs_put_page(struct page *page)
{
	kunmap(page);
	page_cache_release(page);
}
L
Linus Torvalds 已提交
67

68 69 70 71
static inline unsigned long ufs_dir_pages(struct inode *inode)
{
	return (inode->i_size+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT;
}
L
Linus Torvalds 已提交
72

73 74 75 76 77 78 79 80 81 82
ino_t ufs_inode_by_name(struct inode *dir, struct dentry *dentry)
{
	ino_t res = 0;
	struct ufs_dir_entry *de;
	struct page *page;
	
	de = ufs_find_entry(dir, dentry, &page);
	if (de) {
		res = fs32_to_cpu(dir->i_sb, de->d_ino);
		ufs_put_page(page);
L
Linus Torvalds 已提交
83
	}
84
	return res;
L
Linus Torvalds 已提交
85 86 87
}


88 89 90
/* Releases the page */
void ufs_set_link(struct inode *dir, struct ufs_dir_entry *de,
		  struct page *page, struct inode *inode)
L
Linus Torvalds 已提交
91
{
N
Nick Piggin 已提交
92 93 94
	loff_t pos = page_offset(page) +
			(char *) de - (char *) page_address(page);
	unsigned len = fs16_to_cpu(dir->i_sb, de->d_reclen);
95
	int err;
L
Linus Torvalds 已提交
96

97
	lock_page(page);
N
Nick Piggin 已提交
98 99
	err = __ufs_write_begin(NULL, page->mapping, pos, len,
				AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
100
	BUG_ON(err);
N
Nick Piggin 已提交
101

102 103
	de->d_ino = cpu_to_fs32(dir->i_sb, inode->i_ino);
	ufs_set_de_type(dir->i_sb, de, inode->i_mode);
N
Nick Piggin 已提交
104 105

	err = ufs_commit_chunk(page, pos, len);
106 107 108 109
	ufs_put_page(page);
	dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
	mark_inode_dirty(dir);
}
L
Linus Torvalds 已提交
110 111


112 113 114 115 116 117 118
static void ufs_check_page(struct page *page)
{
	struct inode *dir = page->mapping->host;
	struct super_block *sb = dir->i_sb;
	char *kaddr = page_address(page);
	unsigned offs, rec_len;
	unsigned limit = PAGE_CACHE_SIZE;
119
	const unsigned chunk_mask = UFS_SB(sb)->s_uspi->s_dirblksize - 1;
120 121 122 123 124
	struct ufs_dir_entry *p;
	char *error;

	if ((dir->i_size >> PAGE_CACHE_SHIFT) == page->index) {
		limit = dir->i_size & ~PAGE_CACHE_MASK;
125
		if (limit & chunk_mask)
126 127 128
			goto Ebadsize;
		if (!limit)
			goto out;
L
Linus Torvalds 已提交
129
	}
130 131 132 133 134 135 136 137 138 139
	for (offs = 0; offs <= limit - UFS_DIR_REC_LEN(1); offs += rec_len) {
		p = (struct ufs_dir_entry *)(kaddr + offs);
		rec_len = fs16_to_cpu(sb, p->d_reclen);

		if (rec_len < UFS_DIR_REC_LEN(1))
			goto Eshort;
		if (rec_len & 3)
			goto Ealign;
		if (rec_len < UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, p)))
			goto Enamelen;
140
		if (((offs + rec_len - 1) ^ offs) & ~chunk_mask)
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
			goto Espan;
		if (fs32_to_cpu(sb, p->d_ino) > (UFS_SB(sb)->s_uspi->s_ipg *
						  UFS_SB(sb)->s_uspi->s_ncg))
			goto Einumber;
	}
	if (offs != limit)
		goto Eend;
out:
	SetPageChecked(page);
	return;

	/* Too bad, we had an error */

Ebadsize:
	ufs_error(sb, "ufs_check_page",
		  "size of directory #%lu is not a multiple of chunk size",
		  dir->i_ino
	);
	goto fail;
Eshort:
	error = "rec_len is smaller than minimal";
	goto bad_entry;
Ealign:
	error = "unaligned directory entry";
	goto bad_entry;
Enamelen:
	error = "rec_len is too small for name_len";
	goto bad_entry;
Espan:
	error = "directory entry across blocks";
	goto bad_entry;
Einumber:
	error = "inode out of bounds";
bad_entry:
	ufs_error (sb, "ufs_check_page", "bad entry in directory #%lu: %s - "
		   "offset=%lu, rec_len=%d, name_len=%d",
		   dir->i_ino, error, (page->index<<PAGE_CACHE_SHIFT)+offs,
		   rec_len, ufs_get_de_namlen(sb, p));
	goto fail;
Eend:
	p = (struct ufs_dir_entry *)(kaddr + offs);
182
	ufs_error(sb, __func__,
183 184 185 186 187 188 189
		   "entry in directory #%lu spans the page boundary"
		   "offset=%lu",
		   dir->i_ino, (page->index<<PAGE_CACHE_SHIFT)+offs);
fail:
	SetPageChecked(page);
	SetPageError(page);
}
L
Linus Torvalds 已提交
190

191 192 193
static struct page *ufs_get_page(struct inode *dir, unsigned long n)
{
	struct address_space *mapping = dir->i_mapping;
194
	struct page *page = read_mapping_page(mapping, n, NULL);
195 196 197 198 199 200
	if (!IS_ERR(page)) {
		kmap(page);
		if (!PageChecked(page))
			ufs_check_page(page);
		if (PageError(page))
			goto fail;
L
Linus Torvalds 已提交
201
	}
202
	return page;
L
Linus Torvalds 已提交
203

204 205 206
fail:
	ufs_put_page(page);
	return ERR_PTR(-EIO);
L
Linus Torvalds 已提交
207 208
}

209 210 211 212 213 214
/*
 * Return the offset into page `page_nr' of the last valid
 * byte in that page, plus one.
 */
static unsigned
ufs_last_byte(struct inode *inode, unsigned long page_nr)
L
Linus Torvalds 已提交
215
{
216 217 218 219 220 221
	unsigned last_byte = inode->i_size;

	last_byte -= page_nr << PAGE_CACHE_SHIFT;
	if (last_byte > PAGE_CACHE_SIZE)
		last_byte = PAGE_CACHE_SIZE;
	return last_byte;
L
Linus Torvalds 已提交
222 223
}

224 225
static inline struct ufs_dir_entry *
ufs_next_entry(struct super_block *sb, struct ufs_dir_entry *p)
L
Linus Torvalds 已提交
226
{
227 228
	return (struct ufs_dir_entry *)((char *)p +
					fs16_to_cpu(sb, p->d_reclen));
L
Linus Torvalds 已提交
229
}
230 231

struct ufs_dir_entry *ufs_dotdot(struct inode *dir, struct page **p)
L
Linus Torvalds 已提交
232
{
233 234
	struct page *page = ufs_get_page(dir, 0);
	struct ufs_dir_entry *de = NULL;
L
Linus Torvalds 已提交
235

236 237 238 239
	if (!IS_ERR(page)) {
		de = ufs_next_entry(dir->i_sb,
				    (struct ufs_dir_entry *)page_address(page));
		*p = page;
L
Linus Torvalds 已提交
240
	}
241
	return de;
L
Linus Torvalds 已提交
242 243
}

244 245 246 247 248 249 250 251 252 253
/*
 *	ufs_find_entry()
 *
 * finds an entry in the specified directory with the wanted name. It
 * returns the page in which the entry was found, and the entry itself
 * (as a parameter - res_dir). Page is returned mapped and unlocked.
 * Entry is guaranteed to be valid.
 */
struct ufs_dir_entry *ufs_find_entry(struct inode *dir, struct dentry *dentry,
				     struct page **res_page)
L
Linus Torvalds 已提交
254
{
255 256 257 258 259 260 261
	struct super_block *sb = dir->i_sb;
	const char *name = dentry->d_name.name;
	int namelen = dentry->d_name.len;
	unsigned reclen = UFS_DIR_REC_LEN(namelen);
	unsigned long start, n;
	unsigned long npages = ufs_dir_pages(dir);
	struct page *page = NULL;
262
	struct ufs_inode_info *ui = UFS_I(dir);
263 264
	struct ufs_dir_entry *de;

265
	UFSD("ENTER, dir_ino %lu, name %s, namlen %u\n", dir->i_ino, name, namelen);
266 267 268 269 270 271 272

	if (npages == 0 || namelen > UFS_MAXNAMLEN)
		goto out;

	/* OFFSET_CACHE */
	*res_page = NULL;

273 274
	start = ui->i_dir_start_lookup;

275 276 277 278 279 280 281 282 283 284 285 286
	if (start >= npages)
		start = 0;
	n = start;
	do {
		char *kaddr;
		page = ufs_get_page(dir, n);
		if (!IS_ERR(page)) {
			kaddr = page_address(page);
			de = (struct ufs_dir_entry *) kaddr;
			kaddr += ufs_last_byte(dir, n) - reclen;
			while ((char *) de <= kaddr) {
				if (de->d_reclen == 0) {
287
					ufs_error(dir->i_sb, __func__,
288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305
						  "zero-length directory entry");
					ufs_put_page(page);
					goto out;
				}
				if (ufs_match(sb, namelen, name, de))
					goto found;
				de = ufs_next_entry(sb, de);
			}
			ufs_put_page(page);
		}
		if (++n >= npages)
			n = 0;
	} while (n != start);
out:
	return NULL;

found:
	*res_page = page;
306
	ui->i_dir_start_lookup = n;
307
	return de;
L
Linus Torvalds 已提交
308 309 310
}

/*
311
 *	Parent is locked.
L
Linus Torvalds 已提交
312 313 314 315 316 317
 */
int ufs_add_link(struct dentry *dentry, struct inode *inode)
{
	struct inode *dir = dentry->d_parent->d_inode;
	const char *name = dentry->d_name.name;
	int namelen = dentry->d_name.len;
318 319
	struct super_block *sb = dir->i_sb;
	unsigned reclen = UFS_DIR_REC_LEN(namelen);
320
	const unsigned int chunk_size = UFS_SB(sb)->s_uspi->s_dirblksize;
321 322 323 324 325 326
	unsigned short rec_len, name_len;
	struct page *page = NULL;
	struct ufs_dir_entry *de;
	unsigned long npages = ufs_dir_pages(dir);
	unsigned long n;
	char *kaddr;
N
Nick Piggin 已提交
327
	loff_t pos;
L
Linus Torvalds 已提交
328 329
	int err;

330
	UFSD("ENTER, name %s, namelen %u\n", name, namelen);
331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352

	/*
	 * We take care of directory expansion in the same loop.
	 * This code plays outside i_size, so it locks the page
	 * to protect that region.
	 */
	for (n = 0; n <= npages; n++) {
		char *dir_end;

		page = ufs_get_page(dir, n);
		err = PTR_ERR(page);
		if (IS_ERR(page))
			goto out;
		lock_page(page);
		kaddr = page_address(page);
		dir_end = kaddr + ufs_last_byte(dir, n);
		de = (struct ufs_dir_entry *)kaddr;
		kaddr += PAGE_CACHE_SIZE - reclen;
		while ((char *)de <= kaddr) {
			if ((char *)de == dir_end) {
				/* We hit i_size */
				name_len = 0;
353 354
				rec_len = chunk_size;
				de->d_reclen = cpu_to_fs16(sb, chunk_size);
355 356
				de->d_ino = 0;
				goto got_it;
L
Linus Torvalds 已提交
357
			}
358
			if (de->d_reclen == 0) {
359
				ufs_error(dir->i_sb, __func__,
360 361 362 363 364 365 366 367 368 369 370 371 372 373
					  "zero-length directory entry");
				err = -EIO;
				goto out_unlock;
			}
			err = -EEXIST;
			if (ufs_match(sb, namelen, name, de))
				goto out_unlock;
			name_len = UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de));
			rec_len = fs16_to_cpu(sb, de->d_reclen);
			if (!de->d_ino && rec_len >= reclen)
				goto got_it;
			if (rec_len >= name_len + reclen)
				goto got_it;
			de = (struct ufs_dir_entry *) ((char *) de + rec_len);
L
Linus Torvalds 已提交
374
		}
375 376
		unlock_page(page);
		ufs_put_page(page);
L
Linus Torvalds 已提交
377
	}
378 379 380 381
	BUG();
	return -EINVAL;

got_it:
N
Nick Piggin 已提交
382 383 384 385
	pos = page_offset(page) +
			(char*)de - (char*)page_address(page);
	err = __ufs_write_begin(NULL, page->mapping, pos, rec_len,
				AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
386 387
	if (err)
		goto out_unlock;
L
Linus Torvalds 已提交
388
	if (de->d_ino) {
389 390 391 392 393
		struct ufs_dir_entry *de1 =
			(struct ufs_dir_entry *) ((char *) de + name_len);
		de1->d_reclen = cpu_to_fs16(sb, rec_len - name_len);
		de->d_reclen = cpu_to_fs16(sb, name_len);

L
Linus Torvalds 已提交
394 395
		de = de1;
	}
396

L
Linus Torvalds 已提交
397
	ufs_set_de_namlen(sb, de, namelen);
398
	memcpy(de->d_name, name, namelen + 1);
L
Linus Torvalds 已提交
399 400
	de->d_ino = cpu_to_fs32(sb, inode->i_ino);
	ufs_set_de_type(sb, de, inode->i_mode);
401

N
Nick Piggin 已提交
402
	err = ufs_commit_chunk(page, pos, rec_len);
L
Linus Torvalds 已提交
403
	dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
404

L
Linus Torvalds 已提交
405
	mark_inode_dirty(dir);
406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428
	/* OFFSET_CACHE */
out_put:
	ufs_put_page(page);
out:
	return err;
out_unlock:
	unlock_page(page);
	goto out_put;
}

static inline unsigned
ufs_validate_entry(struct super_block *sb, char *base,
		   unsigned offset, unsigned mask)
{
	struct ufs_dir_entry *de = (struct ufs_dir_entry*)(base + offset);
	struct ufs_dir_entry *p = (struct ufs_dir_entry*)(base + (offset&mask));
	while ((char*)p < (char*)de) {
		if (p->d_reclen == 0)
			break;
		p = ufs_next_entry(sb, p);
	}
	return (char *)p - base;
}
L
Linus Torvalds 已提交
429

430 431 432 433 434 435 436 437

/*
 * This is blatantly stolen from ext2fs
 */
static int
ufs_readdir(struct file *filp, void *dirent, filldir_t filldir)
{
	loff_t pos = filp->f_pos;
438
	struct inode *inode = filp->f_path.dentry->d_inode;
439 440 441 442
	struct super_block *sb = inode->i_sb;
	unsigned int offset = pos & ~PAGE_CACHE_MASK;
	unsigned long n = pos >> PAGE_CACHE_SHIFT;
	unsigned long npages = ufs_dir_pages(inode);
443
	unsigned chunk_mask = ~(UFS_SB(sb)->s_uspi->s_dirblksize - 1);
444 445 446
	int need_revalidate = filp->f_version != inode->i_version;
	unsigned flags = UFS_SB(sb)->s_flags;

447
	UFSD("BEGIN\n");
448 449 450 451 452 453 454 455 456 457 458

	if (pos > inode->i_size - UFS_DIR_REC_LEN(1))
		return 0;

	for ( ; n < npages; n++, offset = 0) {
		char *kaddr, *limit;
		struct ufs_dir_entry *de;

		struct page *page = ufs_get_page(inode, n);

		if (IS_ERR(page)) {
459
			ufs_error(sb, __func__,
460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477
				  "bad page in #%lu",
				  inode->i_ino);
			filp->f_pos += PAGE_CACHE_SIZE - offset;
			return -EIO;
		}
		kaddr = page_address(page);
		if (unlikely(need_revalidate)) {
			if (offset) {
				offset = ufs_validate_entry(sb, kaddr, offset, chunk_mask);
				filp->f_pos = (n<<PAGE_CACHE_SHIFT) + offset;
			}
			filp->f_version = inode->i_version;
			need_revalidate = 0;
		}
		de = (struct ufs_dir_entry *)(kaddr+offset);
		limit = kaddr + ufs_last_byte(inode, n) - UFS_DIR_REC_LEN(1);
		for ( ;(char*)de <= limit; de = ufs_next_entry(sb, de)) {
			if (de->d_reclen == 0) {
478
				ufs_error(sb, __func__,
479 480 481 482 483 484 485 486 487 488
					"zero-length directory entry");
				ufs_put_page(page);
				return -EIO;
			}
			if (de->d_ino) {
				int over;
				unsigned char d_type = DT_UNKNOWN;

				offset = (char *)de - kaddr;

489 490 491
				UFSD("filldir(%s,%u)\n", de->d_name,
				      fs32_to_cpu(sb, de->d_ino));
				UFSD("namlen %u\n", ufs_get_de_namlen(sb, de));
492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508

				if ((flags & UFS_DE_MASK) == UFS_DE_44BSD)
					d_type = de->d_u.d_44.d_type;

				over = filldir(dirent, de->d_name,
					       ufs_get_de_namlen(sb, de),
						(n<<PAGE_CACHE_SHIFT) | offset,
					       fs32_to_cpu(sb, de->d_ino), d_type);
				if (over) {
					ufs_put_page(page);
					return 0;
				}
			}
			filp->f_pos += fs16_to_cpu(sb, de->d_reclen);
		}
		ufs_put_page(page);
	}
L
Linus Torvalds 已提交
509 510 511
	return 0;
}

512

L
Linus Torvalds 已提交
513 514 515 516
/*
 * ufs_delete_entry deletes a directory entry by merging it with the
 * previous entry.
 */
517 518
int ufs_delete_entry(struct inode *inode, struct ufs_dir_entry *dir,
		     struct page * page)
L
Linus Torvalds 已提交
519
{
520 521 522
	struct super_block *sb = inode->i_sb;
	struct address_space *mapping = page->mapping;
	char *kaddr = page_address(page);
523
	unsigned from = ((char*)dir - kaddr) & ~(UFS_SB(sb)->s_uspi->s_dirblksize - 1);
524
	unsigned to = ((char*)dir - kaddr) + fs16_to_cpu(sb, dir->d_reclen);
N
Nick Piggin 已提交
525
	loff_t pos;
526 527 528
	struct ufs_dir_entry *pde = NULL;
	struct ufs_dir_entry *de = (struct ufs_dir_entry *) (kaddr + from);
	int err;
L
Linus Torvalds 已提交
529

530
	UFSD("ENTER\n");
L
Linus Torvalds 已提交
531

532
	UFSD("ino %u, reclen %u, namlen %u, name %s\n",
533 534
	      fs32_to_cpu(sb, de->d_ino),
	      fs16_to_cpu(sb, de->d_reclen),
535
	      ufs_get_de_namlen(sb, de), de->d_name);
536 537 538

	while ((char*)de < (char*)dir) {
		if (de->d_reclen == 0) {
539
			ufs_error(inode->i_sb, __func__,
540 541 542
				  "zero-length directory entry");
			err = -EIO;
			goto out;
L
Linus Torvalds 已提交
543
		}
544 545
		pde = de;
		de = ufs_next_entry(sb, de);
L
Linus Torvalds 已提交
546
	}
547 548
	if (pde)
		from = (char*)pde - (char*)page_address(page);
N
Nick Piggin 已提交
549 550

	pos = page_offset(page) + from;
551
	lock_page(page);
N
Nick Piggin 已提交
552 553
	err = __ufs_write_begin(NULL, mapping, pos, to - from,
				AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
554 555
	BUG_ON(err);
	if (pde)
N
Nick Piggin 已提交
556
		pde->d_reclen = cpu_to_fs16(sb, to - from);
557
	dir->d_ino = 0;
N
Nick Piggin 已提交
558
	err = ufs_commit_chunk(page, pos, to - from);
559 560 561 562
	inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
	mark_inode_dirty(inode);
out:
	ufs_put_page(page);
563
	UFSD("EXIT\n");
564
	return err;
L
Linus Torvalds 已提交
565 566 567 568 569
}

int ufs_make_empty(struct inode * inode, struct inode *dir)
{
	struct super_block * sb = dir->i_sb;
570 571
	struct address_space *mapping = inode->i_mapping;
	struct page *page = grab_cache_page(mapping, 0);
572
	const unsigned int chunk_size = UFS_SB(sb)->s_uspi->s_dirblksize;
L
Linus Torvalds 已提交
573
	struct ufs_dir_entry * de;
574
	char *base;
L
Linus Torvalds 已提交
575 576
	int err;

577 578
	if (!page)
		return -ENOMEM;
N
Nick Piggin 已提交
579 580 581

	err = __ufs_write_begin(NULL, mapping, 0, chunk_size,
				AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
582 583 584 585 586
	if (err) {
		unlock_page(page);
		goto fail;
	}

N
Nick Piggin 已提交
587
	kmap(page);
588 589 590 591
	base = (char*)page_address(page);
	memset(base, 0, PAGE_CACHE_SIZE);

	de = (struct ufs_dir_entry *) base;
L
Linus Torvalds 已提交
592 593 594 595 596 597 598 599 600 601

	de->d_ino = cpu_to_fs32(sb, inode->i_ino);
	ufs_set_de_type(sb, de, inode->i_mode);
	ufs_set_de_namlen(sb, de, 1);
	de->d_reclen = cpu_to_fs16(sb, UFS_DIR_REC_LEN(1));
	strcpy (de->d_name, ".");
	de = (struct ufs_dir_entry *)
		((char *)de + fs16_to_cpu(sb, de->d_reclen));
	de->d_ino = cpu_to_fs32(sb, dir->i_ino);
	ufs_set_de_type(sb, de, dir->i_mode);
602
	de->d_reclen = cpu_to_fs16(sb, chunk_size - UFS_DIR_REC_LEN(1));
L
Linus Torvalds 已提交
603 604
	ufs_set_de_namlen(sb, de, 2);
	strcpy (de->d_name, "..");
N
Nick Piggin 已提交
605
	kunmap(page);
606

607
	err = ufs_commit_chunk(page, 0, chunk_size);
608 609 610
fail:
	page_cache_release(page);
	return err;
L
Linus Torvalds 已提交
611 612 613 614 615
}

/*
 * routine to check that the specified directory is empty (for rmdir)
 */
616
int ufs_empty_dir(struct inode * inode)
L
Linus Torvalds 已提交
617
{
618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635
	struct super_block *sb = inode->i_sb;
	struct page *page = NULL;
	unsigned long i, npages = ufs_dir_pages(inode);

	for (i = 0; i < npages; i++) {
		char *kaddr;
		struct ufs_dir_entry *de;
		page = ufs_get_page(inode, i);

		if (IS_ERR(page))
			continue;

		kaddr = page_address(page);
		de = (struct ufs_dir_entry *)kaddr;
		kaddr += ufs_last_byte(inode, i) - UFS_DIR_REC_LEN(1);

		while ((char *)de <= kaddr) {
			if (de->d_reclen == 0) {
636
				ufs_error(inode->i_sb, __func__,
637 638 639
					"zero-length directory entry: "
					"kaddr=%p, de=%p\n", kaddr, de);
				goto not_empty;
L
Linus Torvalds 已提交
640
			}
641 642 643 644 645 646 647 648 649 650 651 652 653 654 655
			if (de->d_ino) {
				u16 namelen=ufs_get_de_namlen(sb, de);
				/* check for . and .. */
				if (de->d_name[0] != '.')
					goto not_empty;
				if (namelen > 2)
					goto not_empty;
				if (namelen < 2) {
					if (inode->i_ino !=
					    fs32_to_cpu(sb, de->d_ino))
						goto not_empty;
				} else if (de->d_name[1] != '.')
					goto not_empty;
			}
			de = ufs_next_entry(sb, de);
L
Linus Torvalds 已提交
656
		}
657
		ufs_put_page(page);
L
Linus Torvalds 已提交
658 659
	}
	return 1;
660 661 662 663

not_empty:
	ufs_put_page(page);
	return 0;
L
Linus Torvalds 已提交
664 665
}

666
const struct file_operations ufs_dir_operations = {
L
Linus Torvalds 已提交
667 668 669
	.read		= generic_read_dir,
	.readdir	= ufs_readdir,
	.fsync		= file_fsync,
670
	.llseek		= generic_file_llseek,
L
Linus Torvalds 已提交
671
};
新手
引导
客服 返回
顶部