xref: /openbmc/linux/fs/nilfs2/dir.c (revision d37cf9b63113f13d742713881ce691fc615d8b3b)
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * NILFS directory entry operations
4  *
5  * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
6  *
7  * Modified for NILFS by Amagai Yoshiji.
8  */
9 /*
10  *  linux/fs/ext2/dir.c
11  *
12  * Copyright (C) 1992, 1993, 1994, 1995
13  * Remy Card (card@masi.ibp.fr)
14  * Laboratoire MASI - Institut Blaise Pascal
15  * Universite Pierre et Marie Curie (Paris VI)
16  *
17  *  from
18  *
19  *  linux/fs/minix/dir.c
20  *
21  *  Copyright (C) 1991, 1992  Linus Torvalds
22  *
23  *  ext2 directory handling functions
24  *
25  *  Big-endian to little-endian byte-swapping/bitmaps by
26  *        David S. Miller (davem@caip.rutgers.edu), 1995
27  *
28  * All code that works with directory layout had been switched to pagecache
29  * and moved here. AV
30  */
31 
32 #include <linux/pagemap.h>
33 #include "nilfs.h"
34 #include "page.h"
35 
nilfs_rec_len_from_disk(__le16 dlen)36 static inline unsigned int nilfs_rec_len_from_disk(__le16 dlen)
37 {
38 	unsigned int len = le16_to_cpu(dlen);
39 
40 #if (PAGE_SIZE >= 65536)
41 	if (len == NILFS_MAX_REC_LEN)
42 		return 1 << 16;
43 #endif
44 	return len;
45 }
46 
nilfs_rec_len_to_disk(unsigned int len)47 static inline __le16 nilfs_rec_len_to_disk(unsigned int len)
48 {
49 #if (PAGE_SIZE >= 65536)
50 	if (len == (1 << 16))
51 		return cpu_to_le16(NILFS_MAX_REC_LEN);
52 
53 	BUG_ON(len > (1 << 16));
54 #endif
55 	return cpu_to_le16(len);
56 }
57 
58 /*
59  * nilfs uses block-sized chunks. Arguably, sector-sized ones would be
60  * more robust, but we have what we have
61  */
nilfs_chunk_size(struct inode * inode)62 static inline unsigned int nilfs_chunk_size(struct inode *inode)
63 {
64 	return inode->i_sb->s_blocksize;
65 }
66 
67 /*
68  * Return the offset into page `page_nr' of the last valid
69  * byte in that page, plus one.
70  */
nilfs_last_byte(struct inode * inode,unsigned long page_nr)71 static unsigned int nilfs_last_byte(struct inode *inode, unsigned long page_nr)
72 {
73 	u64 last_byte = inode->i_size;
74 
75 	last_byte -= page_nr << PAGE_SHIFT;
76 	if (last_byte > PAGE_SIZE)
77 		last_byte = PAGE_SIZE;
78 	return last_byte;
79 }
80 
nilfs_prepare_chunk(struct page * page,unsigned int from,unsigned int to)81 static int nilfs_prepare_chunk(struct page *page, unsigned int from,
82 			       unsigned int to)
83 {
84 	loff_t pos = page_offset(page) + from;
85 
86 	return __block_write_begin(page, pos, to - from, nilfs_get_block);
87 }
88 
nilfs_commit_chunk(struct page * page,struct address_space * mapping,unsigned int from,unsigned int to)89 static void nilfs_commit_chunk(struct page *page,
90 			       struct address_space *mapping,
91 			       unsigned int from, unsigned int to)
92 {
93 	struct inode *dir = mapping->host;
94 	loff_t pos = page_offset(page) + from;
95 	unsigned int len = to - from;
96 	unsigned int nr_dirty, copied;
97 	int err;
98 
99 	nr_dirty = nilfs_page_count_clean_buffers(page, from, to);
100 	copied = block_write_end(NULL, mapping, pos, len, len, page, NULL);
101 	if (pos + copied > dir->i_size)
102 		i_size_write(dir, pos + copied);
103 	if (IS_DIRSYNC(dir))
104 		nilfs_set_transaction_flag(NILFS_TI_SYNC);
105 	err = nilfs_set_file_dirty(dir, nr_dirty);
106 	WARN_ON(err); /* do not happen */
107 	unlock_page(page);
108 }
109 
nilfs_check_page(struct page * page)110 static bool nilfs_check_page(struct page *page)
111 {
112 	struct inode *dir = page->mapping->host;
113 	struct super_block *sb = dir->i_sb;
114 	unsigned int chunk_size = nilfs_chunk_size(dir);
115 	char *kaddr = page_address(page);
116 	unsigned int offs, rec_len;
117 	unsigned int limit = PAGE_SIZE;
118 	struct nilfs_dir_entry *p;
119 	char *error;
120 
121 	if ((dir->i_size >> PAGE_SHIFT) == page->index) {
122 		limit = dir->i_size & ~PAGE_MASK;
123 		if (limit & (chunk_size - 1))
124 			goto Ebadsize;
125 		if (!limit)
126 			goto out;
127 	}
128 	for (offs = 0; offs <= limit - NILFS_DIR_REC_LEN(1); offs += rec_len) {
129 		p = (struct nilfs_dir_entry *)(kaddr + offs);
130 		rec_len = nilfs_rec_len_from_disk(p->rec_len);
131 
132 		if (rec_len < NILFS_DIR_REC_LEN(1))
133 			goto Eshort;
134 		if (rec_len & 3)
135 			goto Ealign;
136 		if (rec_len < NILFS_DIR_REC_LEN(p->name_len))
137 			goto Enamelen;
138 		if (((offs + rec_len - 1) ^ offs) & ~(chunk_size-1))
139 			goto Espan;
140 		if (unlikely(p->inode &&
141 			     NILFS_PRIVATE_INODE(le64_to_cpu(p->inode))))
142 			goto Einumber;
143 	}
144 	if (offs != limit)
145 		goto Eend;
146 out:
147 	SetPageChecked(page);
148 	return true;
149 
150 	/* Too bad, we had an error */
151 
152 Ebadsize:
153 	nilfs_error(sb,
154 		    "size of directory #%lu is not a multiple of chunk size",
155 		    dir->i_ino);
156 	goto fail;
157 Eshort:
158 	error = "rec_len is smaller than minimal";
159 	goto bad_entry;
160 Ealign:
161 	error = "unaligned directory entry";
162 	goto bad_entry;
163 Enamelen:
164 	error = "rec_len is too small for name_len";
165 	goto bad_entry;
166 Espan:
167 	error = "directory entry across blocks";
168 	goto bad_entry;
169 Einumber:
170 	error = "disallowed inode number";
171 bad_entry:
172 	nilfs_error(sb,
173 		    "bad entry in directory #%lu: %s - offset=%lu, inode=%lu, rec_len=%d, name_len=%d",
174 		    dir->i_ino, error, (page->index << PAGE_SHIFT) + offs,
175 		    (unsigned long)le64_to_cpu(p->inode),
176 		    rec_len, p->name_len);
177 	goto fail;
178 Eend:
179 	p = (struct nilfs_dir_entry *)(kaddr + offs);
180 	nilfs_error(sb,
181 		    "entry in directory #%lu spans the page boundary offset=%lu, inode=%lu",
182 		    dir->i_ino, (page->index << PAGE_SHIFT) + offs,
183 		    (unsigned long)le64_to_cpu(p->inode));
184 fail:
185 	SetPageError(page);
186 	return false;
187 }
188 
nilfs_get_page(struct inode * dir,unsigned long n,struct page ** pagep)189 static void *nilfs_get_page(struct inode *dir, unsigned long n,
190 		struct page **pagep)
191 {
192 	struct address_space *mapping = dir->i_mapping;
193 	struct page *page = read_mapping_page(mapping, n, NULL);
194 	void *kaddr;
195 
196 	if (IS_ERR(page))
197 		return page;
198 
199 	kaddr = kmap(page);
200 	if (unlikely(!PageChecked(page))) {
201 		if (!nilfs_check_page(page))
202 			goto fail;
203 	}
204 
205 	*pagep = page;
206 	return kaddr;
207 
208 fail:
209 	nilfs_put_page(page);
210 	return ERR_PTR(-EIO);
211 }
212 
213 /*
214  * NOTE! unlike strncmp, nilfs_match returns 1 for success, 0 for failure.
215  *
216  * len <= NILFS_NAME_LEN and de != NULL are guaranteed by caller.
217  */
218 static int
nilfs_match(int len,const unsigned char * name,struct nilfs_dir_entry * de)219 nilfs_match(int len, const unsigned char *name, struct nilfs_dir_entry *de)
220 {
221 	if (len != de->name_len)
222 		return 0;
223 	if (!de->inode)
224 		return 0;
225 	return !memcmp(name, de->name, len);
226 }
227 
228 /*
229  * p is at least 6 bytes before the end of page
230  */
nilfs_next_entry(struct nilfs_dir_entry * p)231 static struct nilfs_dir_entry *nilfs_next_entry(struct nilfs_dir_entry *p)
232 {
233 	return (struct nilfs_dir_entry *)((char *)p +
234 					  nilfs_rec_len_from_disk(p->rec_len));
235 }
236 
237 static unsigned char
238 nilfs_filetype_table[NILFS_FT_MAX] = {
239 	[NILFS_FT_UNKNOWN]	= DT_UNKNOWN,
240 	[NILFS_FT_REG_FILE]	= DT_REG,
241 	[NILFS_FT_DIR]		= DT_DIR,
242 	[NILFS_FT_CHRDEV]	= DT_CHR,
243 	[NILFS_FT_BLKDEV]	= DT_BLK,
244 	[NILFS_FT_FIFO]		= DT_FIFO,
245 	[NILFS_FT_SOCK]		= DT_SOCK,
246 	[NILFS_FT_SYMLINK]	= DT_LNK,
247 };
248 
249 #define S_SHIFT 12
250 static unsigned char
251 nilfs_type_by_mode[(S_IFMT >> S_SHIFT) + 1] = {
252 	[S_IFREG >> S_SHIFT]	= NILFS_FT_REG_FILE,
253 	[S_IFDIR >> S_SHIFT]	= NILFS_FT_DIR,
254 	[S_IFCHR >> S_SHIFT]	= NILFS_FT_CHRDEV,
255 	[S_IFBLK >> S_SHIFT]	= NILFS_FT_BLKDEV,
256 	[S_IFIFO >> S_SHIFT]	= NILFS_FT_FIFO,
257 	[S_IFSOCK >> S_SHIFT]	= NILFS_FT_SOCK,
258 	[S_IFLNK >> S_SHIFT]	= NILFS_FT_SYMLINK,
259 };
260 
nilfs_set_de_type(struct nilfs_dir_entry * de,struct inode * inode)261 static void nilfs_set_de_type(struct nilfs_dir_entry *de, struct inode *inode)
262 {
263 	umode_t mode = inode->i_mode;
264 
265 	de->file_type = nilfs_type_by_mode[(mode & S_IFMT)>>S_SHIFT];
266 }
267 
nilfs_readdir(struct file * file,struct dir_context * ctx)268 static int nilfs_readdir(struct file *file, struct dir_context *ctx)
269 {
270 	loff_t pos = ctx->pos;
271 	struct inode *inode = file_inode(file);
272 	struct super_block *sb = inode->i_sb;
273 	unsigned int offset = pos & ~PAGE_MASK;
274 	unsigned long n = pos >> PAGE_SHIFT;
275 	unsigned long npages = dir_pages(inode);
276 
277 	if (pos > inode->i_size - NILFS_DIR_REC_LEN(1))
278 		return 0;
279 
280 	for ( ; n < npages; n++, offset = 0) {
281 		char *kaddr, *limit;
282 		struct nilfs_dir_entry *de;
283 		struct page *page;
284 
285 		kaddr = nilfs_get_page(inode, n, &page);
286 		if (IS_ERR(kaddr)) {
287 			nilfs_error(sb, "bad page in #%lu", inode->i_ino);
288 			ctx->pos += PAGE_SIZE - offset;
289 			return -EIO;
290 		}
291 		de = (struct nilfs_dir_entry *)(kaddr + offset);
292 		limit = kaddr + nilfs_last_byte(inode, n) -
293 			NILFS_DIR_REC_LEN(1);
294 		for ( ; (char *)de <= limit; de = nilfs_next_entry(de)) {
295 			if (de->rec_len == 0) {
296 				nilfs_error(sb, "zero-length directory entry");
297 				nilfs_put_page(page);
298 				return -EIO;
299 			}
300 			if (de->inode) {
301 				unsigned char t;
302 
303 				if (de->file_type < NILFS_FT_MAX)
304 					t = nilfs_filetype_table[de->file_type];
305 				else
306 					t = DT_UNKNOWN;
307 
308 				if (!dir_emit(ctx, de->name, de->name_len,
309 						le64_to_cpu(de->inode), t)) {
310 					nilfs_put_page(page);
311 					return 0;
312 				}
313 			}
314 			ctx->pos += nilfs_rec_len_from_disk(de->rec_len);
315 		}
316 		nilfs_put_page(page);
317 	}
318 	return 0;
319 }
320 
321 /*
322  *	nilfs_find_entry()
323  *
324  * finds an entry in the specified directory with the wanted name. It
325  * returns the page in which the entry was found, and the entry itself
326  * (as a parameter - res_dir). Page is returned mapped and unlocked.
327  * Entry is guaranteed to be valid.
328  *
329  * On failure, returns an error pointer and the caller should ignore res_page.
330  */
331 struct nilfs_dir_entry *
nilfs_find_entry(struct inode * dir,const struct qstr * qstr,struct page ** res_page)332 nilfs_find_entry(struct inode *dir, const struct qstr *qstr,
333 		 struct page **res_page)
334 {
335 	const unsigned char *name = qstr->name;
336 	int namelen = qstr->len;
337 	unsigned int reclen = NILFS_DIR_REC_LEN(namelen);
338 	unsigned long start, n;
339 	unsigned long npages = dir_pages(dir);
340 	struct page *page = NULL;
341 	struct nilfs_inode_info *ei = NILFS_I(dir);
342 	struct nilfs_dir_entry *de;
343 
344 	if (npages == 0)
345 		goto out;
346 
347 	/* OFFSET_CACHE */
348 	*res_page = NULL;
349 
350 	start = ei->i_dir_start_lookup;
351 	if (start >= npages)
352 		start = 0;
353 	n = start;
354 	do {
355 		char *kaddr = nilfs_get_page(dir, n, &page);
356 
357 		if (IS_ERR(kaddr))
358 			return ERR_CAST(kaddr);
359 
360 		de = (struct nilfs_dir_entry *)kaddr;
361 		kaddr += nilfs_last_byte(dir, n) - reclen;
362 		while ((char *)de <= kaddr) {
363 			if (de->rec_len == 0) {
364 				nilfs_error(dir->i_sb,
365 					    "zero-length directory entry");
366 				nilfs_put_page(page);
367 				goto out;
368 			}
369 			if (nilfs_match(namelen, name, de))
370 				goto found;
371 			de = nilfs_next_entry(de);
372 		}
373 		nilfs_put_page(page);
374 
375 		if (++n >= npages)
376 			n = 0;
377 		/* next page is past the blocks we've got */
378 		if (unlikely(n > (dir->i_blocks >> (PAGE_SHIFT - 9)))) {
379 			nilfs_error(dir->i_sb,
380 			       "dir %lu size %lld exceeds block count %llu",
381 			       dir->i_ino, dir->i_size,
382 			       (unsigned long long)dir->i_blocks);
383 			goto out;
384 		}
385 	} while (n != start);
386 out:
387 	return ERR_PTR(-ENOENT);
388 
389 found:
390 	*res_page = page;
391 	ei->i_dir_start_lookup = n;
392 	return de;
393 }
394 
nilfs_dotdot(struct inode * dir,struct page ** p)395 struct nilfs_dir_entry *nilfs_dotdot(struct inode *dir, struct page **p)
396 {
397 	struct page *page;
398 	struct nilfs_dir_entry *de, *next_de;
399 	size_t limit;
400 	char *msg;
401 
402 	de = nilfs_get_page(dir, 0, &page);
403 	if (IS_ERR(de))
404 		return NULL;
405 
406 	limit = nilfs_last_byte(dir, 0);  /* is a multiple of chunk size */
407 	if (unlikely(!limit || le64_to_cpu(de->inode) != dir->i_ino ||
408 		     !nilfs_match(1, ".", de))) {
409 		msg = "missing '.'";
410 		goto fail;
411 	}
412 
413 	next_de = nilfs_next_entry(de);
414 	/*
415 	 * If "next_de" has not reached the end of the chunk, there is
416 	 * at least one more record.  Check whether it matches "..".
417 	 */
418 	if (unlikely((char *)next_de == (char *)de + nilfs_chunk_size(dir) ||
419 		     !nilfs_match(2, "..", next_de))) {
420 		msg = "missing '..'";
421 		goto fail;
422 	}
423 	*p = page;
424 	return next_de;
425 
426 fail:
427 	nilfs_error(dir->i_sb, "directory #%lu %s", dir->i_ino, msg);
428 	nilfs_put_page(page);
429 	return NULL;
430 }
431 
nilfs_inode_by_name(struct inode * dir,const struct qstr * qstr,ino_t * ino)432 int nilfs_inode_by_name(struct inode *dir, const struct qstr *qstr, ino_t *ino)
433 {
434 	struct nilfs_dir_entry *de;
435 	struct page *page;
436 
437 	de = nilfs_find_entry(dir, qstr, &page);
438 	if (IS_ERR(de))
439 		return PTR_ERR(de);
440 
441 	*ino = le64_to_cpu(de->inode);
442 	kunmap(page);
443 	put_page(page);
444 	return 0;
445 }
446 
nilfs_set_link(struct inode * dir,struct nilfs_dir_entry * de,struct page * page,struct inode * inode)447 int nilfs_set_link(struct inode *dir, struct nilfs_dir_entry *de,
448 		    struct page *page, struct inode *inode)
449 {
450 	unsigned int from = (char *)de - (char *)page_address(page);
451 	unsigned int to = from + nilfs_rec_len_from_disk(de->rec_len);
452 	struct address_space *mapping = page->mapping;
453 	int err;
454 
455 	lock_page(page);
456 	err = nilfs_prepare_chunk(page, from, to);
457 	if (unlikely(err)) {
458 		unlock_page(page);
459 		return err;
460 	}
461 	de->inode = cpu_to_le64(inode->i_ino);
462 	nilfs_set_de_type(de, inode);
463 	nilfs_commit_chunk(page, mapping, from, to);
464 	dir->i_mtime = inode_set_ctime_current(dir);
465 	return 0;
466 }
467 
468 /*
469  *	Parent is locked.
470  */
nilfs_add_link(struct dentry * dentry,struct inode * inode)471 int nilfs_add_link(struct dentry *dentry, struct inode *inode)
472 {
473 	struct inode *dir = d_inode(dentry->d_parent);
474 	const unsigned char *name = dentry->d_name.name;
475 	int namelen = dentry->d_name.len;
476 	unsigned int chunk_size = nilfs_chunk_size(dir);
477 	unsigned int reclen = NILFS_DIR_REC_LEN(namelen);
478 	unsigned short rec_len, name_len;
479 	struct page *page = NULL;
480 	struct nilfs_dir_entry *de;
481 	unsigned long npages = dir_pages(dir);
482 	unsigned long n;
483 	char *kaddr;
484 	unsigned int from, to;
485 	int err;
486 
487 	/*
488 	 * We take care of directory expansion in the same loop.
489 	 * This code plays outside i_size, so it locks the page
490 	 * to protect that region.
491 	 */
492 	for (n = 0; n <= npages; n++) {
493 		char *dir_end;
494 
495 		kaddr = nilfs_get_page(dir, n, &page);
496 		err = PTR_ERR(kaddr);
497 		if (IS_ERR(kaddr))
498 			goto out;
499 		lock_page(page);
500 		dir_end = kaddr + nilfs_last_byte(dir, n);
501 		de = (struct nilfs_dir_entry *)kaddr;
502 		kaddr += PAGE_SIZE - reclen;
503 		while ((char *)de <= kaddr) {
504 			if ((char *)de == dir_end) {
505 				/* We hit i_size */
506 				name_len = 0;
507 				rec_len = chunk_size;
508 				de->rec_len = nilfs_rec_len_to_disk(chunk_size);
509 				de->inode = 0;
510 				goto got_it;
511 			}
512 			if (de->rec_len == 0) {
513 				nilfs_error(dir->i_sb,
514 					    "zero-length directory entry");
515 				err = -EIO;
516 				goto out_unlock;
517 			}
518 			err = -EEXIST;
519 			if (nilfs_match(namelen, name, de))
520 				goto out_unlock;
521 			name_len = NILFS_DIR_REC_LEN(de->name_len);
522 			rec_len = nilfs_rec_len_from_disk(de->rec_len);
523 			if (!de->inode && rec_len >= reclen)
524 				goto got_it;
525 			if (rec_len >= name_len + reclen)
526 				goto got_it;
527 			de = (struct nilfs_dir_entry *)((char *)de + rec_len);
528 		}
529 		unlock_page(page);
530 		nilfs_put_page(page);
531 	}
532 	BUG();
533 	return -EINVAL;
534 
535 got_it:
536 	from = (char *)de - (char *)page_address(page);
537 	to = from + rec_len;
538 	err = nilfs_prepare_chunk(page, from, to);
539 	if (err)
540 		goto out_unlock;
541 	if (de->inode) {
542 		struct nilfs_dir_entry *de1;
543 
544 		de1 = (struct nilfs_dir_entry *)((char *)de + name_len);
545 		de1->rec_len = nilfs_rec_len_to_disk(rec_len - name_len);
546 		de->rec_len = nilfs_rec_len_to_disk(name_len);
547 		de = de1;
548 	}
549 	de->name_len = namelen;
550 	memcpy(de->name, name, namelen);
551 	de->inode = cpu_to_le64(inode->i_ino);
552 	nilfs_set_de_type(de, inode);
553 	nilfs_commit_chunk(page, page->mapping, from, to);
554 	dir->i_mtime = inode_set_ctime_current(dir);
555 	nilfs_mark_inode_dirty(dir);
556 	/* OFFSET_CACHE */
557 out_put:
558 	nilfs_put_page(page);
559 out:
560 	return err;
561 out_unlock:
562 	unlock_page(page);
563 	goto out_put;
564 }
565 
566 /*
567  * nilfs_delete_entry deletes a directory entry by merging it with the
568  * previous entry. Page is up-to-date.
569  */
nilfs_delete_entry(struct nilfs_dir_entry * dir,struct page * page)570 int nilfs_delete_entry(struct nilfs_dir_entry *dir, struct page *page)
571 {
572 	struct address_space *mapping = page->mapping;
573 	struct inode *inode = mapping->host;
574 	char *kaddr = page_address(page);
575 	unsigned int from, to;
576 	struct nilfs_dir_entry *de, *pde = NULL;
577 	int err;
578 
579 	from = ((char *)dir - kaddr) & ~(nilfs_chunk_size(inode) - 1);
580 	to = ((char *)dir - kaddr) + nilfs_rec_len_from_disk(dir->rec_len);
581 	de = (struct nilfs_dir_entry *)(kaddr + from);
582 
583 	while ((char *)de < (char *)dir) {
584 		if (de->rec_len == 0) {
585 			nilfs_error(inode->i_sb,
586 				    "zero-length directory entry");
587 			err = -EIO;
588 			goto out;
589 		}
590 		pde = de;
591 		de = nilfs_next_entry(de);
592 	}
593 	if (pde)
594 		from = (char *)pde - (char *)page_address(page);
595 	lock_page(page);
596 	err = nilfs_prepare_chunk(page, from, to);
597 	if (unlikely(err)) {
598 		unlock_page(page);
599 		goto out;
600 	}
601 	if (pde)
602 		pde->rec_len = nilfs_rec_len_to_disk(to - from);
603 	dir->inode = 0;
604 	nilfs_commit_chunk(page, mapping, from, to);
605 	inode->i_mtime = inode_set_ctime_current(inode);
606 out:
607 	return err;
608 }
609 
610 /*
611  * Set the first fragment of directory.
612  */
nilfs_make_empty(struct inode * inode,struct inode * parent)613 int nilfs_make_empty(struct inode *inode, struct inode *parent)
614 {
615 	struct address_space *mapping = inode->i_mapping;
616 	struct page *page = grab_cache_page(mapping, 0);
617 	unsigned int chunk_size = nilfs_chunk_size(inode);
618 	struct nilfs_dir_entry *de;
619 	int err;
620 	void *kaddr;
621 
622 	if (!page)
623 		return -ENOMEM;
624 
625 	err = nilfs_prepare_chunk(page, 0, chunk_size);
626 	if (unlikely(err)) {
627 		unlock_page(page);
628 		goto fail;
629 	}
630 	kaddr = kmap_atomic(page);
631 	memset(kaddr, 0, chunk_size);
632 	de = (struct nilfs_dir_entry *)kaddr;
633 	de->name_len = 1;
634 	de->rec_len = nilfs_rec_len_to_disk(NILFS_DIR_REC_LEN(1));
635 	memcpy(de->name, ".\0\0", 4);
636 	de->inode = cpu_to_le64(inode->i_ino);
637 	nilfs_set_de_type(de, inode);
638 
639 	de = (struct nilfs_dir_entry *)(kaddr + NILFS_DIR_REC_LEN(1));
640 	de->name_len = 2;
641 	de->rec_len = nilfs_rec_len_to_disk(chunk_size - NILFS_DIR_REC_LEN(1));
642 	de->inode = cpu_to_le64(parent->i_ino);
643 	memcpy(de->name, "..\0", 4);
644 	nilfs_set_de_type(de, inode);
645 	kunmap_atomic(kaddr);
646 	nilfs_commit_chunk(page, mapping, 0, chunk_size);
647 fail:
648 	put_page(page);
649 	return err;
650 }
651 
652 /*
653  * routine to check that the specified directory is empty (for rmdir)
654  */
nilfs_empty_dir(struct inode * inode)655 int nilfs_empty_dir(struct inode *inode)
656 {
657 	struct page *page = NULL;
658 	unsigned long i, npages = dir_pages(inode);
659 
660 	for (i = 0; i < npages; i++) {
661 		char *kaddr;
662 		struct nilfs_dir_entry *de;
663 
664 		kaddr = nilfs_get_page(inode, i, &page);
665 		if (IS_ERR(kaddr))
666 			return 0;
667 
668 		de = (struct nilfs_dir_entry *)kaddr;
669 		kaddr += nilfs_last_byte(inode, i) - NILFS_DIR_REC_LEN(1);
670 
671 		while ((char *)de <= kaddr) {
672 			if (de->rec_len == 0) {
673 				nilfs_error(inode->i_sb,
674 					    "zero-length directory entry (kaddr=%p, de=%p)",
675 					    kaddr, de);
676 				goto not_empty;
677 			}
678 			if (de->inode != 0) {
679 				/* check for . and .. */
680 				if (de->name[0] != '.')
681 					goto not_empty;
682 				if (de->name_len > 2)
683 					goto not_empty;
684 				if (de->name_len < 2) {
685 					if (de->inode !=
686 					    cpu_to_le64(inode->i_ino))
687 						goto not_empty;
688 				} else if (de->name[1] != '.')
689 					goto not_empty;
690 			}
691 			de = nilfs_next_entry(de);
692 		}
693 		nilfs_put_page(page);
694 	}
695 	return 1;
696 
697 not_empty:
698 	nilfs_put_page(page);
699 	return 0;
700 }
701 
702 const struct file_operations nilfs_dir_operations = {
703 	.llseek		= generic_file_llseek,
704 	.read		= generic_read_dir,
705 	.iterate_shared	= nilfs_readdir,
706 	.unlocked_ioctl	= nilfs_ioctl,
707 #ifdef CONFIG_COMPAT
708 	.compat_ioctl	= nilfs_compat_ioctl,
709 #endif	/* CONFIG_COMPAT */
710 	.fsync		= nilfs_sync_file,
711 
712 };
713