blob: 373fa90c796a0821c23cd441c0a238a1a52cfb69 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/ext3/dir.c
3 *
4 * Copyright (C) 1992, 1993, 1994, 1995
5 * Remy Card (card@masi.ibp.fr)
6 * Laboratoire MASI - Institut Blaise Pascal
7 * Universite Pierre et Marie Curie (Paris VI)
8 *
9 * from
10 *
11 * linux/fs/minix/dir.c
12 *
13 * Copyright (C) 1991, 1992 Linus Torvalds
14 *
15 * ext3 directory handling functions
16 *
17 * Big-endian to little-endian byte-swapping/bitmaps by
18 * David S. Miller (davem@caip.rutgers.edu), 1995
19 *
20 * Hash Tree Directory indexing (c) 2001 Daniel Phillips
21 *
22 */
23
24#include <linux/fs.h>
25#include <linux/jbd.h>
26#include <linux/ext3_fs.h>
27#include <linux/buffer_head.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/slab.h>
29#include <linux/rbtree.h>
30
31static unsigned char ext3_filetype_table[] = {
32 DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
33};
34
35static int ext3_readdir(struct file *, void *, filldir_t);
36static int ext3_dx_readdir(struct file * filp,
37 void * dirent, filldir_t filldir);
38static int ext3_release_dir (struct inode * inode,
39 struct file * filp);
40
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -080041const struct file_operations ext3_dir_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 .llseek = generic_file_llseek,
43 .read = generic_read_dir,
44 .readdir = ext3_readdir, /* we take BKL. needed?*/
Cyrus Massoumi039fd8c2009-04-02 16:57:12 -070045 .unlocked_ioctl = ext3_ioctl,
David Howells52a700c2006-08-29 19:06:23 +010046#ifdef CONFIG_COMPAT
47 .compat_ioctl = ext3_compat_ioctl,
48#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 .fsync = ext3_sync_file, /* BKL held */
Linus Torvalds1da177e2005-04-16 15:20:36 -070050 .release = ext3_release_dir,
Linus Torvalds1da177e2005-04-16 15:20:36 -070051};
52
53
54static unsigned char get_dtype(struct super_block *sb, int filetype)
55{
56 if (!EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_FILETYPE) ||
57 (filetype >= EXT3_FT_MAX))
58 return DT_UNKNOWN;
59
60 return (ext3_filetype_table[filetype]);
61}
Mingming Caoae6ddcc2006-09-27 01:49:27 -070062
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
64int ext3_check_dir_entry (const char * function, struct inode * dir,
65 struct ext3_dir_entry_2 * de,
66 struct buffer_head * bh,
67 unsigned long offset)
68{
69 const char * error_msg = NULL;
Jan Kara7c06a8d2007-11-14 17:00:19 -080070 const int rlen = ext3_rec_len_from_disk(de->rec_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -070071
72 if (rlen < EXT3_DIR_REC_LEN(1))
73 error_msg = "rec_len is smaller than minimal";
74 else if (rlen % 4 != 0)
75 error_msg = "rec_len % 4 != 0";
76 else if (rlen < EXT3_DIR_REC_LEN(de->name_len))
77 error_msg = "rec_len is too small for name_len";
78 else if (((char *) de - bh->b_data) + rlen > dir->i_sb->s_blocksize)
79 error_msg = "directory entry across blocks";
80 else if (le32_to_cpu(de->inode) >
81 le32_to_cpu(EXT3_SB(dir->i_sb)->s_es->s_inodes_count))
82 error_msg = "inode out of bounds";
83
84 if (error_msg != NULL)
85 ext3_error (dir->i_sb, function,
86 "bad entry in directory #%lu: %s - "
87 "offset=%lu, inode=%lu, rec_len=%d, name_len=%d",
88 dir->i_ino, error_msg, offset,
89 (unsigned long) le32_to_cpu(de->inode),
90 rlen, de->name_len);
91 return error_msg == NULL ? 1 : 0;
92}
93
94static int ext3_readdir(struct file * filp,
95 void * dirent, filldir_t filldir)
96{
97 int error = 0;
Andrew Mortond8733c22006-03-23 03:00:11 -080098 unsigned long offset;
99 int i, stored;
100 struct ext3_dir_entry_2 *de;
101 struct super_block *sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 int err;
Josef "Jeff" Sipekfe21a692006-12-08 02:36:38 -0800103 struct inode *inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 int ret = 0;
Eric Sandeencdbf6db2008-10-18 20:28:00 -0700105 int dir_has_error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106
107 sb = inode->i_sb;
108
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 if (EXT3_HAS_COMPAT_FEATURE(inode->i_sb,
110 EXT3_FEATURE_COMPAT_DIR_INDEX) &&
111 ((EXT3_I(inode)->i_flags & EXT3_INDEX_FL) ||
112 ((inode->i_size >> sb->s_blocksize_bits) == 1))) {
113 err = ext3_dx_readdir(filp, dirent, filldir);
114 if (err != ERR_BAD_DX_DIR) {
115 ret = err;
116 goto out;
117 }
118 /*
119 * We don't set the inode dirty flag since it's not
120 * critical that it get flushed back to the disk.
121 */
Josef "Jeff" Sipekfe21a692006-12-08 02:36:38 -0800122 EXT3_I(filp->f_path.dentry->d_inode)->i_flags &= ~EXT3_INDEX_FL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 stored = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 offset = filp->f_pos & (sb->s_blocksize - 1);
126
127 while (!error && !stored && filp->f_pos < inode->i_size) {
Andrew Mortond8733c22006-03-23 03:00:11 -0800128 unsigned long blk = filp->f_pos >> EXT3_BLOCK_SIZE_BITS(sb);
129 struct buffer_head map_bh;
130 struct buffer_head *bh = NULL;
131
132 map_bh.b_state = 0;
Jan Kara43237b52009-05-20 18:41:58 +0200133 err = ext3_get_blocks_handle(NULL, inode, blk, 1, &map_bh, 0);
Mingming Cao89747d32006-03-26 01:37:55 -0800134 if (err > 0) {
Fengguang Wudc7868f2007-07-19 01:48:04 -0700135 pgoff_t index = map_bh.b_blocknr >>
136 (PAGE_CACHE_SHIFT - inode->i_blkbits);
137 if (!ra_has_index(&filp->f_ra, index))
Rusty Russellcf914a72007-07-19 01:48:08 -0700138 page_cache_sync_readahead(
Fengguang Wudc7868f2007-07-19 01:48:04 -0700139 sb->s_bdev->bd_inode->i_mapping,
140 &filp->f_ra, filp,
Rusty Russellcf914a72007-07-19 01:48:08 -0700141 index, 1);
Fengguang Wuf4e6b492007-10-16 01:24:33 -0700142 filp->f_ra.prev_pos = (loff_t)index << PAGE_CACHE_SHIFT;
Andrew Mortond8733c22006-03-23 03:00:11 -0800143 bh = ext3_bread(NULL, inode, blk, 0, &err);
144 }
145
146 /*
147 * We ignore I/O errors on directories so users have a chance
148 * of recovering data when there's a bad sector
149 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 if (!bh) {
Eric Sandeencdbf6db2008-10-18 20:28:00 -0700151 if (!dir_has_error) {
152 ext3_error(sb, __func__, "directory #%lu "
153 "contains a hole at offset %lld",
154 inode->i_ino, filp->f_pos);
155 dir_has_error = 1;
156 }
Eric Sandeen40b85132006-12-06 20:36:26 -0800157 /* corrupt size? Maybe no more blocks to read */
158 if (filp->f_pos > inode->i_blocks << 9)
159 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 filp->f_pos += sb->s_blocksize - offset;
161 continue;
162 }
163
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164revalidate:
165 /* If the dir block has changed since the last call to
166 * readdir(2), then we might be pointing to an invalid
167 * dirent right now. Scan from the start of the block
168 * to make sure. */
169 if (filp->f_version != inode->i_version) {
170 for (i = 0; i < sb->s_blocksize && i < offset; ) {
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700171 de = (struct ext3_dir_entry_2 *)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 (bh->b_data + i);
173 /* It's too expensive to do a full
174 * dirent test each time round this
175 * loop, but we do have to test at
176 * least that it is non-zero. A
177 * failure will be detected in the
178 * dirent test below. */
Jan Kara7c06a8d2007-11-14 17:00:19 -0800179 if (ext3_rec_len_from_disk(de->rec_len) <
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 EXT3_DIR_REC_LEN(1))
181 break;
Jan Kara7c06a8d2007-11-14 17:00:19 -0800182 i += ext3_rec_len_from_disk(de->rec_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 }
184 offset = i;
185 filp->f_pos = (filp->f_pos & ~(sb->s_blocksize - 1))
186 | offset;
187 filp->f_version = inode->i_version;
188 }
189
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700190 while (!error && filp->f_pos < inode->i_size
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 && offset < sb->s_blocksize) {
192 de = (struct ext3_dir_entry_2 *) (bh->b_data + offset);
193 if (!ext3_check_dir_entry ("ext3_readdir", inode, de,
194 bh, offset)) {
195 /* On error, skip the f_pos to the
196 next block. */
197 filp->f_pos = (filp->f_pos |
198 (sb->s_blocksize - 1)) + 1;
199 brelse (bh);
200 ret = stored;
201 goto out;
202 }
Jan Kara7c06a8d2007-11-14 17:00:19 -0800203 offset += ext3_rec_len_from_disk(de->rec_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 if (le32_to_cpu(de->inode)) {
205 /* We might block in the next section
206 * if the data destination is
207 * currently swapped out. So, use a
208 * version stamp to detect whether or
209 * not the directory has been modified
210 * during the copy operation.
211 */
Mathieu Desnoyers2b47c362007-10-16 23:27:21 -0700212 u64 version = filp->f_version;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
214 error = filldir(dirent, de->name,
215 de->name_len,
216 filp->f_pos,
217 le32_to_cpu(de->inode),
218 get_dtype(sb, de->file_type));
219 if (error)
220 break;
221 if (version != filp->f_version)
222 goto revalidate;
223 stored ++;
224 }
Jan Kara7c06a8d2007-11-14 17:00:19 -0800225 filp->f_pos += ext3_rec_len_from_disk(de->rec_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 }
227 offset = 0;
228 brelse (bh);
229 }
230out:
231 return ret;
232}
233
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234/*
235 * These functions convert from the major/minor hash to an f_pos
236 * value.
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700237 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 * Currently we only use major hash numer. This is unfortunate, but
239 * on 32-bit machines, the same VFS interface is used for lseek and
240 * llseek, so if we use the 64 bit offset, then the 32-bit versions of
241 * lseek/telldir/seekdir will blow out spectacularly, and from within
242 * the ext2 low-level routine, we don't know if we're being called by
243 * a 64-bit version of the system call or the 32-bit version of the
244 * system call. Worse yet, NFSv2 only allows for a 32-bit readdir
245 * cookie. Sigh.
246 */
247#define hash2pos(major, minor) (major >> 1)
248#define pos2maj_hash(pos) ((pos << 1) & 0xffffffff)
249#define pos2min_hash(pos) (0)
250
251/*
252 * This structure holds the nodes of the red-black tree used to store
253 * the directory entry in hash order.
254 */
255struct fname {
256 __u32 hash;
257 __u32 minor_hash;
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700258 struct rb_node rb_hash;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 struct fname *next;
260 __u32 inode;
261 __u8 name_len;
262 __u8 file_type;
263 char name[0];
264};
265
266/*
267 * This functoin implements a non-recursive way of freeing all of the
268 * nodes in the red-black tree.
269 */
270static void free_rb_tree_fname(struct rb_root *root)
271{
272 struct rb_node *n = root->rb_node;
273 struct rb_node *parent;
274 struct fname *fname;
275
276 while (n) {
277 /* Do the node's children first */
Shen Feng9ebfbe92008-07-25 01:46:21 -0700278 if (n->rb_left) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 n = n->rb_left;
280 continue;
281 }
282 if (n->rb_right) {
283 n = n->rb_right;
284 continue;
285 }
286 /*
287 * The node has no children; free it, and then zero
288 * out parent's link to it. Finally go to the
289 * beginning of the loop and try to free the parent
290 * node.
291 */
David Woodhouse52b51082006-04-21 13:15:57 +0100292 parent = rb_parent(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 fname = rb_entry(n, struct fname, rb_hash);
294 while (fname) {
295 struct fname * old = fname;
296 fname = fname->next;
297 kfree (old);
298 }
299 if (!parent)
300 root->rb_node = NULL;
301 else if (parent->rb_left == n)
302 parent->rb_left = NULL;
303 else if (parent->rb_right == n)
304 parent->rb_right = NULL;
305 n = parent;
306 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307}
308
309
Shen Feng9ebfbe92008-07-25 01:46:21 -0700310static struct dir_private_info *ext3_htree_create_dir_info(loff_t pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311{
312 struct dir_private_info *p;
313
Shen Feng9ebfbe92008-07-25 01:46:21 -0700314 p = kzalloc(sizeof(struct dir_private_info), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 if (!p)
316 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 p->curr_hash = pos2maj_hash(pos);
318 p->curr_minor_hash = pos2min_hash(pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 return p;
320}
321
322void ext3_htree_free_dir_info(struct dir_private_info *p)
323{
324 free_rb_tree_fname(&p->root);
325 kfree(p);
326}
327
328/*
329 * Given a directory entry, enter it into the fname rb tree.
330 */
331int ext3_htree_store_dirent(struct file *dir_file, __u32 hash,
332 __u32 minor_hash,
333 struct ext3_dir_entry_2 *dirent)
334{
335 struct rb_node **p, *parent = NULL;
336 struct fname * fname, *new_fn;
337 struct dir_private_info *info;
338 int len;
339
340 info = (struct dir_private_info *) dir_file->private_data;
341 p = &info->root.rb_node;
342
343 /* Create and allocate the fname structure */
344 len = sizeof(struct fname) + dirent->name_len + 1;
Panagiotis Issarisf8314dc2006-09-27 01:49:37 -0700345 new_fn = kzalloc(len, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 if (!new_fn)
347 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 new_fn->hash = hash;
349 new_fn->minor_hash = minor_hash;
350 new_fn->inode = le32_to_cpu(dirent->inode);
351 new_fn->name_len = dirent->name_len;
352 new_fn->file_type = dirent->file_type;
353 memcpy(new_fn->name, dirent->name, dirent->name_len);
354 new_fn->name[dirent->name_len] = 0;
355
356 while (*p) {
357 parent = *p;
358 fname = rb_entry(parent, struct fname, rb_hash);
359
360 /*
361 * If the hash and minor hash match up, then we put
362 * them on a linked list. This rarely happens...
363 */
364 if ((new_fn->hash == fname->hash) &&
365 (new_fn->minor_hash == fname->minor_hash)) {
366 new_fn->next = fname->next;
367 fname->next = new_fn;
368 return 0;
369 }
370
371 if (new_fn->hash < fname->hash)
372 p = &(*p)->rb_left;
373 else if (new_fn->hash > fname->hash)
374 p = &(*p)->rb_right;
375 else if (new_fn->minor_hash < fname->minor_hash)
376 p = &(*p)->rb_left;
377 else /* if (new_fn->minor_hash > fname->minor_hash) */
378 p = &(*p)->rb_right;
379 }
380
381 rb_link_node(&new_fn->rb_hash, parent, p);
382 rb_insert_color(&new_fn->rb_hash, &info->root);
383 return 0;
384}
385
386
387
388/*
389 * This is a helper function for ext3_dx_readdir. It calls filldir
390 * for all entres on the fname linked list. (Normally there is only
391 * one entry on the linked list, unless there are 62 bit hash collisions.)
392 */
393static int call_filldir(struct file * filp, void * dirent,
394 filldir_t filldir, struct fname *fname)
395{
396 struct dir_private_info *info = filp->private_data;
397 loff_t curr_pos;
Josef "Jeff" Sipekfe21a692006-12-08 02:36:38 -0800398 struct inode *inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 struct super_block * sb;
400 int error;
401
402 sb = inode->i_sb;
403
404 if (!fname) {
405 printk("call_filldir: called with null fname?!?\n");
406 return 0;
407 }
408 curr_pos = hash2pos(fname->hash, fname->minor_hash);
409 while (fname) {
410 error = filldir(dirent, fname->name,
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700411 fname->name_len, curr_pos,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 fname->inode,
413 get_dtype(sb, fname->file_type));
414 if (error) {
415 filp->f_pos = curr_pos;
Eugene Dashevsky6a897cf2008-10-18 20:27:59 -0700416 info->extra_fname = fname;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 return error;
418 }
419 fname = fname->next;
420 }
421 return 0;
422}
423
424static int ext3_dx_readdir(struct file * filp,
425 void * dirent, filldir_t filldir)
426{
427 struct dir_private_info *info = filp->private_data;
Josef "Jeff" Sipekfe21a692006-12-08 02:36:38 -0800428 struct inode *inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 struct fname *fname;
430 int ret;
431
432 if (!info) {
Shen Feng9ebfbe92008-07-25 01:46:21 -0700433 info = ext3_htree_create_dir_info(filp->f_pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 if (!info)
435 return -ENOMEM;
436 filp->private_data = info;
437 }
438
439 if (filp->f_pos == EXT3_HTREE_EOF)
440 return 0; /* EOF */
441
442 /* Some one has messed with f_pos; reset the world */
443 if (info->last_pos != filp->f_pos) {
444 free_rb_tree_fname(&info->root);
445 info->curr_node = NULL;
446 info->extra_fname = NULL;
447 info->curr_hash = pos2maj_hash(filp->f_pos);
448 info->curr_minor_hash = pos2min_hash(filp->f_pos);
449 }
450
451 /*
452 * If there are any leftover names on the hash collision
453 * chain, return them first.
454 */
Eugene Dashevsky6a897cf2008-10-18 20:27:59 -0700455 if (info->extra_fname) {
456 if (call_filldir(filp, dirent, filldir, info->extra_fname))
457 goto finished;
Eugene Dashevsky6a897cf2008-10-18 20:27:59 -0700458 info->extra_fname = NULL;
Theodore Ts'o8c9fa932008-10-25 11:38:37 -0400459 goto next_node;
Eugene Dashevsky6a897cf2008-10-18 20:27:59 -0700460 } else if (!info->curr_node)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 info->curr_node = rb_first(&info->root);
462
463 while (1) {
464 /*
465 * Fill the rbtree if we have no more entries,
466 * or the inode has changed since we last read in the
Mingming Caoae6ddcc2006-09-27 01:49:27 -0700467 * cached entries.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 */
469 if ((!info->curr_node) ||
470 (filp->f_version != inode->i_version)) {
471 info->curr_node = NULL;
472 free_rb_tree_fname(&info->root);
473 filp->f_version = inode->i_version;
474 ret = ext3_htree_fill_tree(filp, info->curr_hash,
475 info->curr_minor_hash,
476 &info->next_hash);
477 if (ret < 0)
478 return ret;
479 if (ret == 0) {
480 filp->f_pos = EXT3_HTREE_EOF;
481 break;
482 }
483 info->curr_node = rb_first(&info->root);
484 }
485
486 fname = rb_entry(info->curr_node, struct fname, rb_hash);
487 info->curr_hash = fname->hash;
488 info->curr_minor_hash = fname->minor_hash;
489 if (call_filldir(filp, dirent, filldir, fname))
490 break;
Theodore Ts'o8c9fa932008-10-25 11:38:37 -0400491 next_node:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 info->curr_node = rb_next(info->curr_node);
Theodore Ts'o8c9fa932008-10-25 11:38:37 -0400493 if (info->curr_node) {
494 fname = rb_entry(info->curr_node, struct fname,
495 rb_hash);
496 info->curr_hash = fname->hash;
497 info->curr_minor_hash = fname->minor_hash;
498 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 if (info->next_hash == ~0) {
500 filp->f_pos = EXT3_HTREE_EOF;
501 break;
502 }
503 info->curr_hash = info->next_hash;
504 info->curr_minor_hash = 0;
505 }
506 }
507finished:
508 info->last_pos = filp->f_pos;
509 return 0;
510}
511
512static int ext3_release_dir (struct inode * inode, struct file * filp)
513{
514 if (filp->private_data)
515 ext3_htree_free_dir_info(filp->private_data);
516
517 return 0;
518}