?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ocfs2: fix locking for res->tracking and dlm->tracking_list
[linux/fpc-iii.git] / fs / ext4 / namei.c
bloba1f1e53d0e25c641168928c8a62ad5b847f4c0ef
1 /*
2 * linux/fs/ext4/namei.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/namei.c
12 *
13 * Copyright (C) 1991, 1992 Linus Torvalds
14 *
15 * Big-endian to little-endian byte-swapping/bitmaps by
16 * David S. Miller (davem@caip.rutgers.edu), 1995
17 * Directory entry file type support and forward compatibility hooks
18 * for B-tree directories by Theodore Ts'o (tytso@mit.edu), 1998
19 * Hash Tree Directory indexing (c)
20 * Daniel Phillips, 2001
21 * Hash Tree Directory indexing porting
22 * Christopher Li, 2002
23 * Hash Tree Directory indexing cleanup
24 * Theodore Ts'o, 2002
25 */
26
27 #include <linux/fs.h>
28 #include <linux/pagemap.h>
29 #include <linux/time.h>
30 #include <linux/fcntl.h>
31 #include <linux/stat.h>
32 #include <linux/string.h>
33 #include <linux/quotaops.h>
34 #include <linux/buffer_head.h>
35 #include <linux/bio.h>
36 #include "ext4.h"
37 #include "ext4_jbd2.h"
38
39 #include "xattr.h"
40 #include "acl.h"
41
42 #include <trace/events/ext4.h>
43 /*
44 * define how far ahead to read directories while searching them.
45 */
46 #define NAMEI_RA_CHUNKS 2
47 #define NAMEI_RA_BLOCKS 4
48 #define NAMEI_RA_SIZE (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)
49
50 static struct buffer_head *ext4_append(handle_t *handle,
51 struct inode *inode,
52 ext4_lblk_t *block)
53 {
54 struct buffer_head *bh;
55 int err;
56
57 if (unlikely(EXT4_SB(inode->i_sb)->s_max_dir_size_kb &&
58 ((inode->i_size >> 10) >=
59 EXT4_SB(inode->i_sb)->s_max_dir_size_kb)))
60 return ERR_PTR(-ENOSPC);
61
62 *block = inode->i_size >> inode->i_sb->s_blocksize_bits;
63
64 bh = ext4_bread(handle, inode, *block, EXT4_GET_BLOCKS_CREATE);
65 if (IS_ERR(bh))
66 return bh;
67 inode->i_size += inode->i_sb->s_blocksize;
68 EXT4_I(inode)->i_disksize = inode->i_size;
69 BUFFER_TRACE(bh, "get_write_access");
70 err = ext4_journal_get_write_access(handle, bh);
71 if (err) {
72 brelse(bh);
73 ext4_std_error(inode->i_sb, err);
74 return ERR_PTR(err);
75 }
76 return bh;
77 }
78
79 static int ext4_dx_csum_verify(struct inode *inode,
80 struct ext4_dir_entry *dirent);
81
82 typedef enum {
83 EITHER, INDEX, DIRENT
84 } dirblock_type_t;
85
86 #define ext4_read_dirblock(inode, block, type) \
87 __ext4_read_dirblock((inode), (block), (type), __func__, __LINE__)
88
89 static struct buffer_head *__ext4_read_dirblock(struct inode *inode,
90 ext4_lblk_t block,
91 dirblock_type_t type,
92 const char *func,
93 unsigned int line)
94 {
95 struct buffer_head *bh;
96 struct ext4_dir_entry *dirent;
97 int is_dx_block = 0;
98
99 bh = ext4_bread(NULL, inode, block, 0);
100 if (IS_ERR(bh)) {
101 __ext4_warning(inode->i_sb, func, line,
102 "inode #%lu: lblock %lu: comm %s: "
103 "error %ld reading directory block",
104 inode->i_ino, (unsigned long)block,
105 current->comm, PTR_ERR(bh));
106
107 return bh;
108 }
109 if (!bh) {
110 ext4_error_inode(inode, func, line, block,
111 "Directory hole found");
112 return ERR_PTR(-EFSCORRUPTED);
113 }
114 dirent = (struct ext4_dir_entry *) bh->b_data;
115 /* Determine whether or not we have an index block */
116 if (is_dx(inode)) {
117 if (block == 0)
118 is_dx_block = 1;
119 else if (ext4_rec_len_from_disk(dirent->rec_len,
120 inode->i_sb->s_blocksize) ==
121 inode->i_sb->s_blocksize)
122 is_dx_block = 1;
123 }
124 if (!is_dx_block && type == INDEX) {
125 ext4_error_inode(inode, func, line, block,
126 "directory leaf block found instead of index block");
127 return ERR_PTR(-EFSCORRUPTED);
128 }
129 if (!ext4_has_metadata_csum(inode->i_sb) ||
130 buffer_verified(bh))
131 return bh;
132
133 /*
134 * An empty leaf block can get mistaken for a index block; for
135 * this reason, we can only check the index checksum when the
136 * caller is sure it should be an index block.
137 */
138 if (is_dx_block && type == INDEX) {
139 if (ext4_dx_csum_verify(inode, dirent))
140 set_buffer_verified(bh);
141 else {
142 ext4_error_inode(inode, func, line, block,
143 "Directory index failed checksum");
144 brelse(bh);
145 return ERR_PTR(-EFSBADCRC);
146 }
147 }
148 if (!is_dx_block) {
149 if (ext4_dirent_csum_verify(inode, dirent))
150 set_buffer_verified(bh);
151 else {
152 ext4_error_inode(inode, func, line, block,
153 "Directory block failed checksum");
154 brelse(bh);
155 return ERR_PTR(-EFSBADCRC);
156 }
157 }
158 return bh;
159 }
160
161 #ifndef assert
162 #define assert(test) J_ASSERT(test)
163 #endif
164
165 #ifdef DX_DEBUG
166 #define dxtrace(command) command
167 #else
168 #define dxtrace(command)
169 #endif
170
171 struct fake_dirent
172 {
173 __le32 inode;
174 __le16 rec_len;
175 u8 name_len;
176 u8 file_type;
177 };
178
179 struct dx_countlimit
180 {
181 __le16 limit;
182 __le16 count;
183 };
184
185 struct dx_entry
186 {
187 __le32 hash;
188 __le32 block;
189 };
190
191 /*
192 * dx_root_info is laid out so that if it should somehow get overlaid by a
193 * dirent the two low bits of the hash version will be zero. Therefore, the
194 * hash version mod 4 should never be 0. Sincerely, the paranoia department.
195 */
196
197 struct dx_root
198 {
199 struct fake_dirent dot;
200 char dot_name[4];
201 struct fake_dirent dotdot;
202 char dotdot_name[4];
203 struct dx_root_info
204 {
205 __le32 reserved_zero;
206 u8 hash_version;
207 u8 info_length; /* 8 */
208 u8 indirect_levels;
209 u8 unused_flags;
210 }
211 info;
212 struct dx_entry entries[0];
213 };
214
215 struct dx_node
216 {
217 struct fake_dirent fake;
218 struct dx_entry entries[0];
219 };
220
221
222 struct dx_frame
223 {
224 struct buffer_head *bh;
225 struct dx_entry *entries;
226 struct dx_entry *at;
227 };
228
229 struct dx_map_entry
230 {
231 u32 hash;
232 u16 offs;
233 u16 size;
234 };
235
236 /*
237 * This goes at the end of each htree block.
238 */
239 struct dx_tail {
240 u32 dt_reserved;
241 __le32 dt_checksum; /* crc32c(uuid+inum+dirblock) */
242 };
243
244 static inline ext4_lblk_t dx_get_block(struct dx_entry *entry);
245 static void dx_set_block(struct dx_entry *entry, ext4_lblk_t value);
246 static inline unsigned dx_get_hash(struct dx_entry *entry);
247 static void dx_set_hash(struct dx_entry *entry, unsigned value);
248 static unsigned dx_get_count(struct dx_entry *entries);
249 static unsigned dx_get_limit(struct dx_entry *entries);
250 static void dx_set_count(struct dx_entry *entries, unsigned value);
251 static void dx_set_limit(struct dx_entry *entries, unsigned value);
252 static unsigned dx_root_limit(struct inode *dir, unsigned infosize);
253 static unsigned dx_node_limit(struct inode *dir);
254 static struct dx_frame *dx_probe(struct ext4_filename *fname,
255 struct inode *dir,
256 struct dx_hash_info *hinfo,
257 struct dx_frame *frame);
258 static void dx_release(struct dx_frame *frames);
259 static int dx_make_map(struct inode *dir, struct ext4_dir_entry_2 *de,
260 unsigned blocksize, struct dx_hash_info *hinfo,
261 struct dx_map_entry map[]);
262 static void dx_sort_map(struct dx_map_entry *map, unsigned count);
263 static struct ext4_dir_entry_2 *dx_move_dirents(char *from, char *to,
264 struct dx_map_entry *offsets, int count, unsigned blocksize);
265 static struct ext4_dir_entry_2* dx_pack_dirents(char *base, unsigned blocksize);
266 static void dx_insert_block(struct dx_frame *frame,
267 u32 hash, ext4_lblk_t block);
268 static int ext4_htree_next_block(struct inode *dir, __u32 hash,
269 struct dx_frame *frame,
270 struct dx_frame *frames,
271 __u32 *start_hash);
272 static struct buffer_head * ext4_dx_find_entry(struct inode *dir,
273 struct ext4_filename *fname,
274 struct ext4_dir_entry_2 **res_dir);
275 static int ext4_dx_add_entry(handle_t *handle, struct ext4_filename *fname,
276 struct dentry *dentry, struct inode *inode);
277
278 /* checksumming functions */
279 void initialize_dirent_tail(struct ext4_dir_entry_tail *t,
280 unsigned int blocksize)
281 {
282 memset(t, 0, sizeof(struct ext4_dir_entry_tail));
283 t->det_rec_len = ext4_rec_len_to_disk(
284 sizeof(struct ext4_dir_entry_tail), blocksize);
285 t->det_reserved_ft = EXT4_FT_DIR_CSUM;
286 }
287
288 /* Walk through a dirent block to find a checksum "dirent" at the tail */
289 static struct ext4_dir_entry_tail *get_dirent_tail(struct inode *inode,
290 struct ext4_dir_entry *de)
291 {
292 struct ext4_dir_entry_tail *t;
293
294 #ifdef PARANOID
295 struct ext4_dir_entry *d, *top;
296
297 d = de;
298 top = (struct ext4_dir_entry *)(((void *)de) +
299 (EXT4_BLOCK_SIZE(inode->i_sb) -
300 sizeof(struct ext4_dir_entry_tail)));
301 while (d < top && d->rec_len)
302 d = (struct ext4_dir_entry *)(((void *)d) +
303 le16_to_cpu(d->rec_len));
304
305 if (d != top)
306 return NULL;
307
308 t = (struct ext4_dir_entry_tail *)d;
309 #else
310 t = EXT4_DIRENT_TAIL(de, EXT4_BLOCK_SIZE(inode->i_sb));
311 #endif
312
313 if (t->det_reserved_zero1 ||
314 le16_to_cpu(t->det_rec_len) != sizeof(struct ext4_dir_entry_tail) ||
315 t->det_reserved_zero2 ||
316 t->det_reserved_ft != EXT4_FT_DIR_CSUM)
317 return NULL;
318
319 return t;
320 }
321
322 static __le32 ext4_dirent_csum(struct inode *inode,
323 struct ext4_dir_entry *dirent, int size)
324 {
325 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
326 struct ext4_inode_info *ei = EXT4_I(inode);
327 __u32 csum;
328
329 csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)dirent, size);
330 return cpu_to_le32(csum);
331 }
332
333 #define warn_no_space_for_csum(inode) \
334 __warn_no_space_for_csum((inode), __func__, __LINE__)
335
336 static void __warn_no_space_for_csum(struct inode *inode, const char *func,
337 unsigned int line)
338 {
339 __ext4_warning_inode(inode, func, line,
340 "No space for directory leaf checksum. Please run e2fsck -D.");
341 }
342
343 int ext4_dirent_csum_verify(struct inode *inode, struct ext4_dir_entry *dirent)
344 {
345 struct ext4_dir_entry_tail *t;
346
347 if (!ext4_has_metadata_csum(inode->i_sb))
348 return 1;
349
350 t = get_dirent_tail(inode, dirent);
351 if (!t) {
352 warn_no_space_for_csum(inode);
353 return 0;
354 }
355
356 if (t->det_checksum != ext4_dirent_csum(inode, dirent,
357 (void *)t - (void *)dirent))
358 return 0;
359
360 return 1;
361 }
362
363 static void ext4_dirent_csum_set(struct inode *inode,
364 struct ext4_dir_entry *dirent)
365 {
366 struct ext4_dir_entry_tail *t;
367
368 if (!ext4_has_metadata_csum(inode->i_sb))
369 return;
370
371 t = get_dirent_tail(inode, dirent);
372 if (!t) {
373 warn_no_space_for_csum(inode);
374 return;
375 }
376
377 t->det_checksum = ext4_dirent_csum(inode, dirent,
378 (void *)t - (void *)dirent);
379 }
380
381 int ext4_handle_dirty_dirent_node(handle_t *handle,
382 struct inode *inode,
383 struct buffer_head *bh)
384 {
385 ext4_dirent_csum_set(inode, (struct ext4_dir_entry *)bh->b_data);
386 return ext4_handle_dirty_metadata(handle, inode, bh);
387 }
388
389 static struct dx_countlimit *get_dx_countlimit(struct inode *inode,
390 struct ext4_dir_entry *dirent,
391 int *offset)
392 {
393 struct ext4_dir_entry *dp;
394 struct dx_root_info *root;
395 int count_offset;
396
397 if (le16_to_cpu(dirent->rec_len) == EXT4_BLOCK_SIZE(inode->i_sb))
398 count_offset = 8;
399 else if (le16_to_cpu(dirent->rec_len) == 12) {
400 dp = (struct ext4_dir_entry *)(((void *)dirent) + 12);
401 if (le16_to_cpu(dp->rec_len) !=
402 EXT4_BLOCK_SIZE(inode->i_sb) - 12)
403 return NULL;
404 root = (struct dx_root_info *)(((void *)dp + 12));
405 if (root->reserved_zero ||
406 root->info_length != sizeof(struct dx_root_info))
407 return NULL;
408 count_offset = 32;
409 } else
410 return NULL;
411
412 if (offset)
413 *offset = count_offset;
414 return (struct dx_countlimit *)(((void *)dirent) + count_offset);
415 }
416
417 static __le32 ext4_dx_csum(struct inode *inode, struct ext4_dir_entry *dirent,
418 int count_offset, int count, struct dx_tail *t)
419 {
420 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
421 struct ext4_inode_info *ei = EXT4_I(inode);
422 __u32 csum;
423 int size;
424 __u32 dummy_csum = 0;
425 int offset = offsetof(struct dx_tail, dt_checksum);
426
427 size = count_offset + (count * sizeof(struct dx_entry));
428 csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)dirent, size);
429 csum = ext4_chksum(sbi, csum, (__u8 *)t, offset);
430 csum = ext4_chksum(sbi, csum, (__u8 *)&dummy_csum, sizeof(dummy_csum));
431
432 return cpu_to_le32(csum);
433 }
434
435 static int ext4_dx_csum_verify(struct inode *inode,
436 struct ext4_dir_entry *dirent)
437 {
438 struct dx_countlimit *c;
439 struct dx_tail *t;
440 int count_offset, limit, count;
441
442 if (!ext4_has_metadata_csum(inode->i_sb))
443 return 1;
444
445 c = get_dx_countlimit(inode, dirent, &count_offset);
446 if (!c) {
447 EXT4_ERROR_INODE(inode, "dir seems corrupt? Run e2fsck -D.");
448 return 1;
449 }
450 limit = le16_to_cpu(c->limit);
451 count = le16_to_cpu(c->count);
452 if (count_offset + (limit * sizeof(struct dx_entry)) >
453 EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) {
454 warn_no_space_for_csum(inode);
455 return 1;
456 }
457 t = (struct dx_tail *)(((struct dx_entry *)c) + limit);
458
459 if (t->dt_checksum != ext4_dx_csum(inode, dirent, count_offset,
460 count, t))
461 return 0;
462 return 1;
463 }
464
465 static void ext4_dx_csum_set(struct inode *inode, struct ext4_dir_entry *dirent)
466 {
467 struct dx_countlimit *c;
468 struct dx_tail *t;
469 int count_offset, limit, count;
470
471 if (!ext4_has_metadata_csum(inode->i_sb))
472 return;
473
474 c = get_dx_countlimit(inode, dirent, &count_offset);
475 if (!c) {
476 EXT4_ERROR_INODE(inode, "dir seems corrupt? Run e2fsck -D.");
477 return;
478 }
479 limit = le16_to_cpu(c->limit);
480 count = le16_to_cpu(c->count);
481 if (count_offset + (limit * sizeof(struct dx_entry)) >
482 EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) {
483 warn_no_space_for_csum(inode);
484 return;
485 }
486 t = (struct dx_tail *)(((struct dx_entry *)c) + limit);
487
488 t->dt_checksum = ext4_dx_csum(inode, dirent, count_offset, count, t);
489 }
490
491 static inline int ext4_handle_dirty_dx_node(handle_t *handle,
492 struct inode *inode,
493 struct buffer_head *bh)
494 {
495 ext4_dx_csum_set(inode, (struct ext4_dir_entry *)bh->b_data);
496 return ext4_handle_dirty_metadata(handle, inode, bh);
497 }
498
499 /*
500 * p is at least 6 bytes before the end of page
501 */
502 static inline struct ext4_dir_entry_2 *
503 ext4_next_entry(struct ext4_dir_entry_2 *p, unsigned long blocksize)
504 {
505 return (struct ext4_dir_entry_2 *)((char *)p +
506 ext4_rec_len_from_disk(p->rec_len, blocksize));
507 }
508
509 /*
510 * Future: use high four bits of block for coalesce-on-delete flags
511 * Mask them off for now.
512 */
513
514 static inline ext4_lblk_t dx_get_block(struct dx_entry *entry)
515 {
516 return le32_to_cpu(entry->block) & 0x00ffffff;
517 }
518
519 static inline void dx_set_block(struct dx_entry *entry, ext4_lblk_t value)
520 {
521 entry->block = cpu_to_le32(value);
522 }
523
524 static inline unsigned dx_get_hash(struct dx_entry *entry)
525 {
526 return le32_to_cpu(entry->hash);
527 }
528
529 static inline void dx_set_hash(struct dx_entry *entry, unsigned value)
530 {
531 entry->hash = cpu_to_le32(value);
532 }
533
534 static inline unsigned dx_get_count(struct dx_entry *entries)
535 {
536 return le16_to_cpu(((struct dx_countlimit *) entries)->count);
537 }
538
539 static inline unsigned dx_get_limit(struct dx_entry *entries)
540 {
541 return le16_to_cpu(((struct dx_countlimit *) entries)->limit);
542 }
543
544 static inline void dx_set_count(struct dx_entry *entries, unsigned value)
545 {
546 ((struct dx_countlimit *) entries)->count = cpu_to_le16(value);
547 }
548
549 static inline void dx_set_limit(struct dx_entry *entries, unsigned value)
550 {
551 ((struct dx_countlimit *) entries)->limit = cpu_to_le16(value);
552 }
553
554 static inline unsigned dx_root_limit(struct inode *dir, unsigned infosize)
555 {
556 unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(1) -
557 EXT4_DIR_REC_LEN(2) - infosize;
558
559 if (ext4_has_metadata_csum(dir->i_sb))
560 entry_space -= sizeof(struct dx_tail);
561 return entry_space / sizeof(struct dx_entry);
562 }
563
564 static inline unsigned dx_node_limit(struct inode *dir)
565 {
566 unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(0);
567
568 if (ext4_has_metadata_csum(dir->i_sb))
569 entry_space -= sizeof(struct dx_tail);
570 return entry_space / sizeof(struct dx_entry);
571 }
572
573 /*
574 * Debug
575 */
576 #ifdef DX_DEBUG
577 static void dx_show_index(char * label, struct dx_entry *entries)
578 {
579 int i, n = dx_get_count (entries);
580 printk(KERN_DEBUG "%s index ", label);
581 for (i = 0; i < n; i++) {
582 printk("%x->%lu ", i ? dx_get_hash(entries + i) :
583 0, (unsigned long)dx_get_block(entries + i));
584 }
585 printk("\n");
586 }
587
588 struct stats
589 {
590 unsigned names;
591 unsigned space;
592 unsigned bcount;
593 };
594
595 static struct stats dx_show_leaf(struct inode *dir,
596 struct dx_hash_info *hinfo,
597 struct ext4_dir_entry_2 *de,
598 int size, int show_names)
599 {
600 unsigned names = 0, space = 0;
601 char *base = (char *) de;
602 struct dx_hash_info h = *hinfo;
603
604 printk("names: ");
605 while ((char *) de < base + size)
606 {
607 if (de->inode)
608 {
609 if (show_names)
610 {
611 #ifdef CONFIG_EXT4_FS_ENCRYPTION
612 int len;
613 char *name;
614 struct ext4_str fname_crypto_str
615 = {.name = NULL, .len = 0};
616 int res = 0;
617
618 name = de->name;
619 len = de->name_len;
620 if (ext4_encrypted_inode(inode))
621 res = ext4_get_encryption_info(dir);
622 if (res) {
623 printk(KERN_WARNING "Error setting up"
624 " fname crypto: %d\n", res);
625 }
626 if (ctx == NULL) {
627 /* Directory is not encrypted */
628 ext4fs_dirhash(de->name,
629 de->name_len, &h);
630 printk("%*.s:(U)%x.%u ", len,
631 name, h.hash,
632 (unsigned) ((char *) de
633 - base));
634 } else {
635 /* Directory is encrypted */
636 res = ext4_fname_crypto_alloc_buffer(
637 ctx, de->name_len,
638 &fname_crypto_str);
639 if (res < 0) {
640 printk(KERN_WARNING "Error "
641 "allocating crypto "
642 "buffer--skipping "
643 "crypto\n");
644 ctx = NULL;
645 }
646 res = ext4_fname_disk_to_usr(ctx, NULL, de,
647 &fname_crypto_str);
648 if (res < 0) {
649 printk(KERN_WARNING "Error "
650 "converting filename "
651 "from disk to usr"
652 "\n");
653 name = "??";
654 len = 2;
655 } else {
656 name = fname_crypto_str.name;
657 len = fname_crypto_str.len;
658 }
659 ext4fs_dirhash(de->name, de->name_len,
660 &h);
661 printk("%*.s:(E)%x.%u ", len, name,
662 h.hash, (unsigned) ((char *) de
663 - base));
664 ext4_fname_crypto_free_buffer(
665 &fname_crypto_str);
666 }
667 #else
668 int len = de->name_len;
669 char *name = de->name;
670 ext4fs_dirhash(de->name, de->name_len, &h);
671 printk("%*.s:%x.%u ", len, name, h.hash,
672 (unsigned) ((char *) de - base));
673 #endif
674 }
675 space += EXT4_DIR_REC_LEN(de->name_len);
676 names++;
677 }
678 de = ext4_next_entry(de, size);
679 }
680 printk("(%i)\n", names);
681 return (struct stats) { names, space, 1 };
682 }
683
684 struct stats dx_show_entries(struct dx_hash_info *hinfo, struct inode *dir,
685 struct dx_entry *entries, int levels)
686 {
687 unsigned blocksize = dir->i_sb->s_blocksize;
688 unsigned count = dx_get_count(entries), names = 0, space = 0, i;
689 unsigned bcount = 0;
690 struct buffer_head *bh;
691 printk("%i indexed blocks...\n", count);
692 for (i = 0; i < count; i++, entries++)
693 {
694 ext4_lblk_t block = dx_get_block(entries);
695 ext4_lblk_t hash = i ? dx_get_hash(entries): 0;
696 u32 range = i < count - 1? (dx_get_hash(entries + 1) - hash): ~hash;
697 struct stats stats;
698 printk("%s%3u:%03u hash %8x/%8x ",levels?"":" ", i, block, hash, range);
699 bh = ext4_bread(NULL,dir, block, 0);
700 if (!bh || IS_ERR(bh))
701 continue;
702 stats = levels?
703 dx_show_entries(hinfo, dir, ((struct dx_node *) bh->b_data)->entries, levels - 1):
704 dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *)
705 bh->b_data, blocksize, 0);
706 names += stats.names;
707 space += stats.space;
708 bcount += stats.bcount;
709 brelse(bh);
710 }
711 if (bcount)
712 printk(KERN_DEBUG "%snames %u, fullness %u (%u%%)\n",
713 levels ? "" : " ", names, space/bcount,
714 (space/bcount)*100/blocksize);
715 return (struct stats) { names, space, bcount};
716 }
717 #endif /* DX_DEBUG */
718
719 /*
720 * Probe for a directory leaf block to search.
721 *
722 * dx_probe can return ERR_BAD_DX_DIR, which means there was a format
723 * error in the directory index, and the caller should fall back to
724 * searching the directory normally. The callers of dx_probe **MUST**
725 * check for this error code, and make sure it never gets reflected
726 * back to userspace.
727 */
728 static struct dx_frame *
729 dx_probe(struct ext4_filename *fname, struct inode *dir,
730 struct dx_hash_info *hinfo, struct dx_frame *frame_in)
731 {
732 unsigned count, indirect;
733 struct dx_entry *at, *entries, *p, *q, *m;
734 struct dx_root *root;
735 struct dx_frame *frame = frame_in;
736 struct dx_frame *ret_err = ERR_PTR(ERR_BAD_DX_DIR);
737 u32 hash;
738
739 frame->bh = ext4_read_dirblock(dir, 0, INDEX);
740 if (IS_ERR(frame->bh))
741 return (struct dx_frame *) frame->bh;
742
743 root = (struct dx_root *) frame->bh->b_data;
744 if (root->info.hash_version != DX_HASH_TEA &&
745 root->info.hash_version != DX_HASH_HALF_MD4 &&
746 root->info.hash_version != DX_HASH_LEGACY) {
747 ext4_warning_inode(dir, "Unrecognised inode hash code %u",
748 root->info.hash_version);
749 goto fail;
750 }
751 if (fname)
752 hinfo = &fname->hinfo;
753 hinfo->hash_version = root->info.hash_version;
754 if (hinfo->hash_version <= DX_HASH_TEA)
755 hinfo->hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
756 hinfo->seed = EXT4_SB(dir->i_sb)->s_hash_seed;
757 if (fname && fname_name(fname))
758 ext4fs_dirhash(fname_name(fname), fname_len(fname), hinfo);
759 hash = hinfo->hash;
760
761 if (root->info.unused_flags & 1) {
762 ext4_warning_inode(dir, "Unimplemented hash flags: %#06x",
763 root->info.unused_flags);
764 goto fail;
765 }
766
767 indirect = root->info.indirect_levels;
768 if (indirect > 1) {
769 ext4_warning_inode(dir, "Unimplemented hash depth: %#06x",
770 root->info.indirect_levels);
771 goto fail;
772 }
773
774 entries = (struct dx_entry *)(((char *)&root->info) +
775 root->info.info_length);
776
777 if (dx_get_limit(entries) != dx_root_limit(dir,
778 root->info.info_length)) {
779 ext4_warning_inode(dir, "dx entry: limit %u != root limit %u",
780 dx_get_limit(entries),
781 dx_root_limit(dir, root->info.info_length));
782 goto fail;
783 }
784
785 dxtrace(printk("Look up %x", hash));
786 while (1) {
787 count = dx_get_count(entries);
788 if (!count || count > dx_get_limit(entries)) {
789 ext4_warning_inode(dir,
790 "dx entry: count %u beyond limit %u",
791 count, dx_get_limit(entries));
792 goto fail;
793 }
794
795 p = entries + 1;
796 q = entries + count - 1;
797 while (p <= q) {
798 m = p + (q - p) / 2;
799 dxtrace(printk("."));
800 if (dx_get_hash(m) > hash)
801 q = m - 1;
802 else
803 p = m + 1;
804 }
805
806 if (0) { // linear search cross check
807 unsigned n = count - 1;
808 at = entries;
809 while (n--)
810 {
811 dxtrace(printk(","));
812 if (dx_get_hash(++at) > hash)
813 {
814 at--;
815 break;
816 }
817 }
818 assert (at == p - 1);
819 }
820
821 at = p - 1;
822 dxtrace(printk(" %x->%u\n", at == entries ? 0 : dx_get_hash(at),
823 dx_get_block(at)));
824 frame->entries = entries;
825 frame->at = at;
826 if (!indirect--)
827 return frame;
828 frame++;
829 frame->bh = ext4_read_dirblock(dir, dx_get_block(at), INDEX);
830 if (IS_ERR(frame->bh)) {
831 ret_err = (struct dx_frame *) frame->bh;
832 frame->bh = NULL;
833 goto fail;
834 }
835 entries = ((struct dx_node *) frame->bh->b_data)->entries;
836
837 if (dx_get_limit(entries) != dx_node_limit(dir)) {
838 ext4_warning_inode(dir,
839 "dx entry: limit %u != node limit %u",
840 dx_get_limit(entries), dx_node_limit(dir));
841 goto fail;
842 }
843 }
844 fail:
845 while (frame >= frame_in) {
846 brelse(frame->bh);
847 frame--;
848 }
849
850 if (ret_err == ERR_PTR(ERR_BAD_DX_DIR))
851 ext4_warning_inode(dir,
852 "Corrupt directory, running e2fsck is recommended");
853 return ret_err;
854 }
855
856 static void dx_release(struct dx_frame *frames)
857 {
858 if (frames[0].bh == NULL)
859 return;
860
861 if (((struct dx_root *)frames[0].bh->b_data)->info.indirect_levels)
862 brelse(frames[1].bh);
863 brelse(frames[0].bh);
864 }
865
866 /*
867 * This function increments the frame pointer to search the next leaf
868 * block, and reads in the necessary intervening nodes if the search
869 * should be necessary. Whether or not the search is necessary is
870 * controlled by the hash parameter. If the hash value is even, then
871 * the search is only continued if the next block starts with that
872 * hash value. This is used if we are searching for a specific file.
873 *
874 * If the hash value is HASH_NB_ALWAYS, then always go to the next block.
875 *
876 * This function returns 1 if the caller should continue to search,
877 * or 0 if it should not. If there is an error reading one of the
878 * index blocks, it will a negative error code.
879 *
880 * If start_hash is non-null, it will be filled in with the starting
881 * hash of the next page.
882 */
883 static int ext4_htree_next_block(struct inode *dir, __u32 hash,
884 struct dx_frame *frame,
885 struct dx_frame *frames,
886 __u32 *start_hash)
887 {
888 struct dx_frame *p;
889 struct buffer_head *bh;
890 int num_frames = 0;
891 __u32 bhash;
892
893 p = frame;
894 /*
895 * Find the next leaf page by incrementing the frame pointer.
896 * If we run out of entries in the interior node, loop around and
897 * increment pointer in the parent node. When we break out of
898 * this loop, num_frames indicates the number of interior
899 * nodes need to be read.
900 */
901 while (1) {
902 if (++(p->at) < p->entries + dx_get_count(p->entries))
903 break;
904 if (p == frames)
905 return 0;
906 num_frames++;
907 p--;
908 }
909
910 /*
911 * If the hash is 1, then continue only if the next page has a
912 * continuation hash of any value. This is used for readdir
913 * handling. Otherwise, check to see if the hash matches the
914 * desired contiuation hash. If it doesn't, return since
915 * there's no point to read in the successive index pages.
916 */
917 bhash = dx_get_hash(p->at);
918 if (start_hash)
919 *start_hash = bhash;
920 if ((hash & 1) == 0) {
921 if ((bhash & ~1) != hash)
922 return 0;
923 }
924 /*
925 * If the hash is HASH_NB_ALWAYS, we always go to the next
926 * block so no check is necessary
927 */
928 while (num_frames--) {
929 bh = ext4_read_dirblock(dir, dx_get_block(p->at), INDEX);
930 if (IS_ERR(bh))
931 return PTR_ERR(bh);
932 p++;
933 brelse(p->bh);
934 p->bh = bh;
935 p->at = p->entries = ((struct dx_node *) bh->b_data)->entries;
936 }
937 return 1;
938 }
939
940
941 /*
942 * This function fills a red-black tree with information from a
943 * directory block. It returns the number directory entries loaded
944 * into the tree. If there is an error it is returned in err.
945 */
946 static int htree_dirblock_to_tree(struct file *dir_file,
947 struct inode *dir, ext4_lblk_t block,
948 struct dx_hash_info *hinfo,
949 __u32 start_hash, __u32 start_minor_hash)
950 {
951 struct buffer_head *bh;
952 struct ext4_dir_entry_2 *de, *top;
953 int err = 0, count = 0;
954 struct ext4_str fname_crypto_str = {.name = NULL, .len = 0}, tmp_str;
955
956 dxtrace(printk(KERN_INFO "In htree dirblock_to_tree: block %lu\n",
957 (unsigned long)block));
958 bh = ext4_read_dirblock(dir, block, DIRENT);
959 if (IS_ERR(bh))
960 return PTR_ERR(bh);
961
962 de = (struct ext4_dir_entry_2 *) bh->b_data;
963 top = (struct ext4_dir_entry_2 *) ((char *) de +
964 dir->i_sb->s_blocksize -
965 EXT4_DIR_REC_LEN(0));
966 #ifdef CONFIG_EXT4_FS_ENCRYPTION
967 /* Check if the directory is encrypted */
968 if (ext4_encrypted_inode(dir)) {
969 err = ext4_get_encryption_info(dir);
970 if (err < 0) {
971 brelse(bh);
972 return err;
973 }
974 err = ext4_fname_crypto_alloc_buffer(dir, EXT4_NAME_LEN,
975 &fname_crypto_str);
976 if (err < 0) {
977 brelse(bh);
978 return err;
979 }
980 }
981 #endif
982 for (; de < top; de = ext4_next_entry(de, dir->i_sb->s_blocksize)) {
983 if (ext4_check_dir_entry(dir, NULL, de, bh,
984 bh->b_data, bh->b_size,
985 (block<<EXT4_BLOCK_SIZE_BITS(dir->i_sb))
986 + ((char *)de - bh->b_data))) {
987 /* silently ignore the rest of the block */
988 break;
989 }
990 ext4fs_dirhash(de->name, de->name_len, hinfo);
991 if ((hinfo->hash < start_hash) ||
992 ((hinfo->hash == start_hash) &&
993 (hinfo->minor_hash < start_minor_hash)))
994 continue;
995 if (de->inode == 0)
996 continue;
997 if (!ext4_encrypted_inode(dir)) {
998 tmp_str.name = de->name;
999 tmp_str.len = de->name_len;
1000 err = ext4_htree_store_dirent(dir_file,
1001 hinfo->hash, hinfo->minor_hash, de,
1002 &tmp_str);
1003 } else {
1004 int save_len = fname_crypto_str.len;
1005
1006 /* Directory is encrypted */
1007 err = ext4_fname_disk_to_usr(dir, hinfo, de,
1008 &fname_crypto_str);
1009 if (err < 0) {
1010 count = err;
1011 goto errout;
1012 }
1013 err = ext4_htree_store_dirent(dir_file,
1014 hinfo->hash, hinfo->minor_hash, de,
1015 &fname_crypto_str);
1016 fname_crypto_str.len = save_len;
1017 }
1018 if (err != 0) {
1019 count = err;
1020 goto errout;
1021 }
1022 count++;
1023 }
1024 errout:
1025 brelse(bh);
1026 #ifdef CONFIG_EXT4_FS_ENCRYPTION
1027 ext4_fname_crypto_free_buffer(&fname_crypto_str);
1028 #endif
1029 return count;
1030 }
1031
1032
1033 /*
1034 * This function fills a red-black tree with information from a
1035 * directory. We start scanning the directory in hash order, starting
1036 * at start_hash and start_minor_hash.
1037 *
1038 * This function returns the number of entries inserted into the tree,
1039 * or a negative error code.
1040 */
1041 int ext4_htree_fill_tree(struct file *dir_file, __u32 start_hash,
1042 __u32 start_minor_hash, __u32 *next_hash)
1043 {
1044 struct dx_hash_info hinfo;
1045 struct ext4_dir_entry_2 *de;
1046 struct dx_frame frames[2], *frame;
1047 struct inode *dir;
1048 ext4_lblk_t block;
1049 int count = 0;
1050 int ret, err;
1051 __u32 hashval;
1052 struct ext4_str tmp_str;
1053
1054 dxtrace(printk(KERN_DEBUG "In htree_fill_tree, start hash: %x:%x\n",
1055 start_hash, start_minor_hash));
1056 dir = file_inode(dir_file);
1057 if (!(ext4_test_inode_flag(dir, EXT4_INODE_INDEX))) {
1058 hinfo.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version;
1059 if (hinfo.hash_version <= DX_HASH_TEA)
1060 hinfo.hash_version +=
1061 EXT4_SB(dir->i_sb)->s_hash_unsigned;
1062 hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
1063 if (ext4_has_inline_data(dir)) {
1064 int has_inline_data = 1;
1065 count = htree_inlinedir_to_tree(dir_file, dir, 0,
1066 &hinfo, start_hash,
1067 start_minor_hash,
1068 &has_inline_data);
1069 if (has_inline_data) {
1070 *next_hash = ~0;
1071 return count;
1072 }
1073 }
1074 count = htree_dirblock_to_tree(dir_file, dir, 0, &hinfo,
1075 start_hash, start_minor_hash);
1076 *next_hash = ~0;
1077 return count;
1078 }
1079 hinfo.hash = start_hash;
1080 hinfo.minor_hash = 0;
1081 frame = dx_probe(NULL, dir, &hinfo, frames);
1082 if (IS_ERR(frame))
1083 return PTR_ERR(frame);
1084
1085 /* Add '.' and '..' from the htree header */
1086 if (!start_hash && !start_minor_hash) {
1087 de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data;
1088 tmp_str.name = de->name;
1089 tmp_str.len = de->name_len;
1090 err = ext4_htree_store_dirent(dir_file, 0, 0,
1091 de, &tmp_str);
1092 if (err != 0)
1093 goto errout;
1094 count++;
1095 }
1096 if (start_hash < 2 || (start_hash ==2 && start_minor_hash==0)) {
1097 de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data;
1098 de = ext4_next_entry(de, dir->i_sb->s_blocksize);
1099 tmp_str.name = de->name;
1100 tmp_str.len = de->name_len;
1101 err = ext4_htree_store_dirent(dir_file, 2, 0,
1102 de, &tmp_str);
1103 if (err != 0)
1104 goto errout;
1105 count++;
1106 }
1107
1108 while (1) {
1109 block = dx_get_block(frame->at);
1110 ret = htree_dirblock_to_tree(dir_file, dir, block, &hinfo,
1111 start_hash, start_minor_hash);
1112 if (ret < 0) {
1113 err = ret;
1114 goto errout;
1115 }
1116 count += ret;
1117 hashval = ~0;
1118 ret = ext4_htree_next_block(dir, HASH_NB_ALWAYS,
1119 frame, frames, &hashval);
1120 *next_hash = hashval;
1121 if (ret < 0) {
1122 err = ret;
1123 goto errout;
1124 }
1125 /*
1126 * Stop if: (a) there are no more entries, or
1127 * (b) we have inserted at least one entry and the
1128 * next hash value is not a continuation
1129 */
1130 if ((ret == 0) ||
1131 (count && ((hashval & 1) == 0)))
1132 break;
1133 }
1134 dx_release(frames);
1135 dxtrace(printk(KERN_DEBUG "Fill tree: returned %d entries, "
1136 "next hash: %x\n", count, *next_hash));
1137 return count;
1138 errout:
1139 dx_release(frames);
1140 return (err);
1141 }
1142
1143 static inline int search_dirblock(struct buffer_head *bh,
1144 struct inode *dir,
1145 struct ext4_filename *fname,
1146 const struct qstr *d_name,
1147 unsigned int offset,
1148 struct ext4_dir_entry_2 **res_dir)
1149 {
1150 return ext4_search_dir(bh, bh->b_data, dir->i_sb->s_blocksize, dir,
1151 fname, d_name, offset, res_dir);
1152 }
1153
1154 /*
1155 * Directory block splitting, compacting
1156 */
1157
1158 /*
1159 * Create map of hash values, offsets, and sizes, stored at end of block.
1160 * Returns number of entries mapped.
1161 */
1162 static int dx_make_map(struct inode *dir, struct ext4_dir_entry_2 *de,
1163 unsigned blocksize, struct dx_hash_info *hinfo,
1164 struct dx_map_entry *map_tail)
1165 {
1166 int count = 0;
1167 char *base = (char *) de;
1168 struct dx_hash_info h = *hinfo;
1169
1170 while ((char *) de < base + blocksize) {
1171 if (de->name_len && de->inode) {
1172 ext4fs_dirhash(de->name, de->name_len, &h);
1173 map_tail--;
1174 map_tail->hash = h.hash;
1175 map_tail->offs = ((char *) de - base)>>2;
1176 map_tail->size = le16_to_cpu(de->rec_len);
1177 count++;
1178 cond_resched();
1179 }
1180 /* XXX: do we need to check rec_len == 0 case? -Chris */
1181 de = ext4_next_entry(de, blocksize);
1182 }
1183 return count;
1184 }
1185
1186 /* Sort map by hash value */
1187 static void dx_sort_map (struct dx_map_entry *map, unsigned count)
1188 {
1189 struct dx_map_entry *p, *q, *top = map + count - 1;
1190 int more;
1191 /* Combsort until bubble sort doesn't suck */
1192 while (count > 2) {
1193 count = count*10/13;
1194 if (count - 9 < 2) /* 9, 10 -> 11 */
1195 count = 11;
1196 for (p = top, q = p - count; q >= map; p--, q--)
1197 if (p->hash < q->hash)
1198 swap(*p, *q);
1199 }
1200 /* Garden variety bubble sort */
1201 do {
1202 more = 0;
1203 q = top;
1204 while (q-- > map) {
1205 if (q[1].hash >= q[0].hash)
1206 continue;
1207 swap(*(q+1), *q);
1208 more = 1;
1209 }
1210 } while(more);
1211 }
1212
1213 static void dx_insert_block(struct dx_frame *frame, u32 hash, ext4_lblk_t block)
1214 {
1215 struct dx_entry *entries = frame->entries;
1216 struct dx_entry *old = frame->at, *new = old + 1;
1217 int count = dx_get_count(entries);
1218
1219 assert(count < dx_get_limit(entries));
1220 assert(old < entries + count);
1221 memmove(new + 1, new, (char *)(entries + count) - (char *)(new));
1222 dx_set_hash(new, hash);
1223 dx_set_block(new, block);
1224 dx_set_count(entries, count + 1);
1225 }
1226
1227 /*
1228 * NOTE! unlike strncmp, ext4_match returns 1 for success, 0 for failure.
1229 *
1230 * `len <= EXT4_NAME_LEN' is guaranteed by caller.
1231 * `de != NULL' is guaranteed by caller.
1232 */
1233 static inline int ext4_match(struct ext4_filename *fname,
1234 struct ext4_dir_entry_2 *de)
1235 {
1236 const void *name = fname_name(fname);
1237 u32 len = fname_len(fname);
1238
1239 if (!de->inode)
1240 return 0;
1241
1242 #ifdef CONFIG_EXT4_FS_ENCRYPTION
1243 if (unlikely(!name)) {
1244 if (fname->usr_fname->name[0] == '_') {
1245 int ret;
1246 if (de->name_len <= 32)
1247 return 0;
1248 ret = memcmp(de->name + ((de->name_len - 17) & ~15),
1249 fname->crypto_buf.name + 8, 16);
1250 return (ret == 0) ? 1 : 0;
1251 }
1252 name = fname->crypto_buf.name;
1253 len = fname->crypto_buf.len;
1254 }
1255 #endif
1256 if (de->name_len != len)
1257 return 0;
1258 return (memcmp(de->name, name, len) == 0) ? 1 : 0;
1259 }
1260
1261 /*
1262 * Returns 0 if not found, -1 on failure, and 1 on success
1263 */
1264 int ext4_search_dir(struct buffer_head *bh, char *search_buf, int buf_size,
1265 struct inode *dir, struct ext4_filename *fname,
1266 const struct qstr *d_name,
1267 unsigned int offset, struct ext4_dir_entry_2 **res_dir)
1268 {
1269 struct ext4_dir_entry_2 * de;
1270 char * dlimit;
1271 int de_len;
1272 int res;
1273
1274 de = (struct ext4_dir_entry_2 *)search_buf;
1275 dlimit = search_buf + buf_size;
1276 while ((char *) de < dlimit) {
1277 /* this code is executed quadratically often */
1278 /* do minimal checking `by hand' */
1279 if ((char *) de + de->name_len <= dlimit) {
1280 res = ext4_match(fname, de);
1281 if (res < 0) {
1282 res = -1;
1283 goto return_result;
1284 }
1285 if (res > 0) {
1286 /* found a match - just to be sure, do
1287 * a full check */
1288 if (ext4_check_dir_entry(dir, NULL, de, bh,
1289 bh->b_data,
1290 bh->b_size, offset)) {
1291 res = -1;
1292 goto return_result;
1293 }
1294 *res_dir = de;
1295 res = 1;
1296 goto return_result;
1297 }
1298
1299 }
1300 /* prevent looping on a bad block */
1301 de_len = ext4_rec_len_from_disk(de->rec_len,
1302 dir->i_sb->s_blocksize);
1303 if (de_len <= 0) {
1304 res = -1;
1305 goto return_result;
1306 }
1307 offset += de_len;
1308 de = (struct ext4_dir_entry_2 *) ((char *) de + de_len);
1309 }
1310
1311 res = 0;
1312 return_result:
1313 return res;
1314 }
1315
1316 static int is_dx_internal_node(struct inode *dir, ext4_lblk_t block,
1317 struct ext4_dir_entry *de)
1318 {
1319 struct super_block *sb = dir->i_sb;
1320
1321 if (!is_dx(dir))
1322 return 0;
1323 if (block == 0)
1324 return 1;
1325 if (de->inode == 0 &&
1326 ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize) ==
1327 sb->s_blocksize)
1328 return 1;
1329 return 0;
1330 }
1331
1332 /*
1333 * ext4_find_entry()
1334 *
1335 * finds an entry in the specified directory with the wanted name. It
1336 * returns the cache buffer in which the entry was found, and the entry
1337 * itself (as a parameter - res_dir). It does NOT read the inode of the
1338 * entry - you'll have to do that yourself if you want to.
1339 *
1340 * The returned buffer_head has ->b_count elevated. The caller is expected
1341 * to brelse() it when appropriate.
1342 */
1343 static struct buffer_head * ext4_find_entry (struct inode *dir,
1344 const struct qstr *d_name,
1345 struct ext4_dir_entry_2 **res_dir,
1346 int *inlined)
1347 {
1348 struct super_block *sb;
1349 struct buffer_head *bh_use[NAMEI_RA_SIZE];
1350 struct buffer_head *bh, *ret = NULL;
1351 ext4_lblk_t start, block, b;
1352 const u8 *name = d_name->name;
1353 int ra_max = 0; /* Number of bh's in the readahead
1354 buffer, bh_use[] */
1355 int ra_ptr = 0; /* Current index into readahead
1356 buffer */
1357 int num = 0;
1358 ext4_lblk_t nblocks;
1359 int i, namelen, retval;
1360 struct ext4_filename fname;
1361
1362 *res_dir = NULL;
1363 sb = dir->i_sb;
1364 namelen = d_name->len;
1365 if (namelen > EXT4_NAME_LEN)
1366 return NULL;
1367
1368 retval = ext4_fname_setup_filename(dir, d_name, 1, &fname);
1369 if (retval)
1370 return ERR_PTR(retval);
1371
1372 if (ext4_has_inline_data(dir)) {
1373 int has_inline_data = 1;
1374 ret = ext4_find_inline_entry(dir, &fname, d_name, res_dir,
1375 &has_inline_data);
1376 if (has_inline_data) {
1377 if (inlined)
1378 *inlined = 1;
1379 goto cleanup_and_exit;
1380 }
1381 }
1382
1383 if ((namelen <= 2) && (name[0] == '.') &&
1384 (name[1] == '.' || name[1] == '\0')) {
1385 /*
1386 * "." or ".." will only be in the first block
1387 * NFS may look up ".."; "." should be handled by the VFS
1388 */
1389 block = start = 0;
1390 nblocks = 1;
1391 goto restart;
1392 }
1393 if (is_dx(dir)) {
1394 ret = ext4_dx_find_entry(dir, &fname, res_dir);
1395 /*
1396 * On success, or if the error was file not found,
1397 * return. Otherwise, fall back to doing a search the
1398 * old fashioned way.
1399 */
1400 if (!IS_ERR(ret) || PTR_ERR(ret) != ERR_BAD_DX_DIR)
1401 goto cleanup_and_exit;
1402 dxtrace(printk(KERN_DEBUG "ext4_find_entry: dx failed, "
1403 "falling back\n"));
1404 ret = NULL;
1405 }
1406 nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
1407 if (!nblocks) {
1408 ret = NULL;
1409 goto cleanup_and_exit;
1410 }
1411 start = EXT4_I(dir)->i_dir_start_lookup;
1412 if (start >= nblocks)
1413 start = 0;
1414 block = start;
1415 restart:
1416 do {
1417 /*
1418 * We deal with the read-ahead logic here.
1419 */
1420 if (ra_ptr >= ra_max) {
1421 /* Refill the readahead buffer */
1422 ra_ptr = 0;
1423 b = block;
1424 for (ra_max = 0; ra_max < NAMEI_RA_SIZE; ra_max++) {
1425 /*
1426 * Terminate if we reach the end of the
1427 * directory and must wrap, or if our
1428 * search has finished at this block.
1429 */
1430 if (b >= nblocks || (num && block == start)) {
1431 bh_use[ra_max] = NULL;
1432 break;
1433 }
1434 num++;
1435 bh = ext4_getblk(NULL, dir, b++, 0);
1436 if (IS_ERR(bh)) {
1437 if (ra_max == 0) {
1438 ret = bh;
1439 goto cleanup_and_exit;
1440 }
1441 break;
1442 }
1443 bh_use[ra_max] = bh;
1444 if (bh)
1445 ll_rw_block(READ | REQ_META | REQ_PRIO,
1446 1, &bh);
1447 }
1448 }
1449 if ((bh = bh_use[ra_ptr++]) == NULL)
1450 goto next;
1451 wait_on_buffer(bh);
1452 if (!buffer_uptodate(bh)) {
1453 /* read error, skip block & hope for the best */
1454 EXT4_ERROR_INODE(dir, "reading directory lblock %lu",
1455 (unsigned long) block);
1456 brelse(bh);
1457 goto next;
1458 }
1459 if (!buffer_verified(bh) &&
1460 !is_dx_internal_node(dir, block,
1461 (struct ext4_dir_entry *)bh->b_data) &&
1462 !ext4_dirent_csum_verify(dir,
1463 (struct ext4_dir_entry *)bh->b_data)) {
1464 EXT4_ERROR_INODE(dir, "checksumming directory "
1465 "block %lu", (unsigned long)block);
1466 brelse(bh);
1467 goto next;
1468 }
1469 set_buffer_verified(bh);
1470 i = search_dirblock(bh, dir, &fname, d_name,
1471 block << EXT4_BLOCK_SIZE_BITS(sb), res_dir);
1472 if (i == 1) {
1473 EXT4_I(dir)->i_dir_start_lookup = block;
1474 ret = bh;
1475 goto cleanup_and_exit;
1476 } else {
1477 brelse(bh);
1478 if (i < 0)
1479 goto cleanup_and_exit;
1480 }
1481 next:
1482 if (++block >= nblocks)
1483 block = 0;
1484 } while (block != start);
1485
1486 /*
1487 * If the directory has grown while we were searching, then
1488 * search the last part of the directory before giving up.
1489 */
1490 block = nblocks;
1491 nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
1492 if (block < nblocks) {
1493 start = 0;
1494 goto restart;
1495 }
1496
1497 cleanup_and_exit:
1498 /* Clean up the read-ahead blocks */
1499 for (; ra_ptr < ra_max; ra_ptr++)
1500 brelse(bh_use[ra_ptr]);
1501 ext4_fname_free_filename(&fname);
1502 return ret;
1503 }
1504
1505 static struct buffer_head * ext4_dx_find_entry(struct inode *dir,
1506 struct ext4_filename *fname,
1507 struct ext4_dir_entry_2 **res_dir)
1508 {
1509 struct super_block * sb = dir->i_sb;
1510 struct dx_frame frames[2], *frame;
1511 const struct qstr *d_name = fname->usr_fname;
1512 struct buffer_head *bh;
1513 ext4_lblk_t block;
1514 int retval;
1515
1516 #ifdef CONFIG_EXT4_FS_ENCRYPTION
1517 *res_dir = NULL;
1518 #endif
1519 frame = dx_probe(fname, dir, NULL, frames);
1520 if (IS_ERR(frame))
1521 return (struct buffer_head *) frame;
1522 do {
1523 block = dx_get_block(frame->at);
1524 bh = ext4_read_dirblock(dir, block, DIRENT);
1525 if (IS_ERR(bh))
1526 goto errout;
1527
1528 retval = search_dirblock(bh, dir, fname, d_name,
1529 block << EXT4_BLOCK_SIZE_BITS(sb),
1530 res_dir);
1531 if (retval == 1)
1532 goto success;
1533 brelse(bh);
1534 if (retval == -1) {
1535 bh = ERR_PTR(ERR_BAD_DX_DIR);
1536 goto errout;
1537 }
1538
1539 /* Check to see if we should continue to search */
1540 retval = ext4_htree_next_block(dir, fname->hinfo.hash, frame,
1541 frames, NULL);
1542 if (retval < 0) {
1543 ext4_warning_inode(dir,
1544 "error %d reading directory index block",
1545 retval);
1546 bh = ERR_PTR(retval);
1547 goto errout;
1548 }
1549 } while (retval == 1);
1550
1551 bh = NULL;
1552 errout:
1553 dxtrace(printk(KERN_DEBUG "%s not found\n", d_name->name));
1554 success:
1555 dx_release(frames);
1556 return bh;
1557 }
1558
1559 static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
1560 {
1561 struct inode *inode;
1562 struct ext4_dir_entry_2 *de;
1563 struct buffer_head *bh;
1564
1565 if (ext4_encrypted_inode(dir)) {
1566 int res = ext4_get_encryption_info(dir);
1567
1568 /*
1569 * This should be a properly defined flag for
1570 * dentry->d_flags when we uplift this to the VFS.
1571 * d_fsdata is set to (void *) 1 if if the dentry is
1572 * created while the directory was encrypted and we
1573 * don't have access to the key.
1574 */
1575 dentry->d_fsdata = NULL;
1576 if (ext4_encryption_info(dir))
1577 dentry->d_fsdata = (void *) 1;
1578 d_set_d_op(dentry, &ext4_encrypted_d_ops);
1579 if (res && res != -ENOKEY)
1580 return ERR_PTR(res);
1581 }
1582
1583 if (dentry->d_name.len > EXT4_NAME_LEN)
1584 return ERR_PTR(-ENAMETOOLONG);
1585
1586 bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
1587 if (IS_ERR(bh))
1588 return (struct dentry *) bh;
1589 inode = NULL;
1590 if (bh) {
1591 __u32 ino = le32_to_cpu(de->inode);
1592 brelse(bh);
1593 if (!ext4_valid_inum(dir->i_sb, ino)) {
1594 EXT4_ERROR_INODE(dir, "bad inode number: %u", ino);
1595 return ERR_PTR(-EFSCORRUPTED);
1596 }
1597 if (unlikely(ino == dir->i_ino)) {
1598 EXT4_ERROR_INODE(dir, "'%pd' linked to parent dir",
1599 dentry);
1600 return ERR_PTR(-EFSCORRUPTED);
1601 }
1602 inode = ext4_iget_normal(dir->i_sb, ino);
1603 if (inode == ERR_PTR(-ESTALE)) {
1604 EXT4_ERROR_INODE(dir,
1605 "deleted inode referenced: %u",
1606 ino);
1607 return ERR_PTR(-EFSCORRUPTED);
1608 }
1609 if (!IS_ERR(inode) && ext4_encrypted_inode(dir) &&
1610 (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
1611 S_ISLNK(inode->i_mode)) &&
1612 !ext4_is_child_context_consistent_with_parent(dir,
1613 inode)) {
1614 iput(inode);
1615 ext4_warning(inode->i_sb,
1616 "Inconsistent encryption contexts: %lu/%lu\n",
1617 (unsigned long) dir->i_ino,
1618 (unsigned long) inode->i_ino);
1619 return ERR_PTR(-EPERM);
1620 }
1621 }
1622 return d_splice_alias(inode, dentry);
1623 }
1624
1625
1626 struct dentry *ext4_get_parent(struct dentry *child)
1627 {
1628 __u32 ino;
1629 static const struct qstr dotdot = QSTR_INIT("..", 2);
1630 struct ext4_dir_entry_2 * de;
1631 struct buffer_head *bh;
1632
1633 bh = ext4_find_entry(d_inode(child), &dotdot, &de, NULL);
1634 if (IS_ERR(bh))
1635 return (struct dentry *) bh;
1636 if (!bh)
1637 return ERR_PTR(-ENOENT);
1638 ino = le32_to_cpu(de->inode);
1639 brelse(bh);
1640
1641 if (!ext4_valid_inum(d_inode(child)->i_sb, ino)) {
1642 EXT4_ERROR_INODE(d_inode(child),
1643 "bad parent inode number: %u", ino);
1644 return ERR_PTR(-EFSCORRUPTED);
1645 }
1646
1647 return d_obtain_alias(ext4_iget_normal(d_inode(child)->i_sb, ino));
1648 }
1649
1650 /*
1651 * Move count entries from end of map between two memory locations.
1652 * Returns pointer to last entry moved.
1653 */
1654 static struct ext4_dir_entry_2 *
1655 dx_move_dirents(char *from, char *to, struct dx_map_entry *map, int count,
1656 unsigned blocksize)
1657 {
1658 unsigned rec_len = 0;
1659
1660 while (count--) {
1661 struct ext4_dir_entry_2 *de = (struct ext4_dir_entry_2 *)
1662 (from + (map->offs<<2));
1663 rec_len = EXT4_DIR_REC_LEN(de->name_len);
1664 memcpy (to, de, rec_len);
1665 ((struct ext4_dir_entry_2 *) to)->rec_len =
1666 ext4_rec_len_to_disk(rec_len, blocksize);
1667 de->inode = 0;
1668 map++;
1669 to += rec_len;
1670 }
1671 return (struct ext4_dir_entry_2 *) (to - rec_len);
1672 }
1673
1674 /*
1675 * Compact each dir entry in the range to the minimal rec_len.
1676 * Returns pointer to last entry in range.
1677 */
1678 static struct ext4_dir_entry_2* dx_pack_dirents(char *base, unsigned blocksize)
1679 {
1680 struct ext4_dir_entry_2 *next, *to, *prev, *de = (struct ext4_dir_entry_2 *) base;
1681 unsigned rec_len = 0;
1682
1683 prev = to = de;
1684 while ((char*)de < base + blocksize) {
1685 next = ext4_next_entry(de, blocksize);
1686 if (de->inode && de->name_len) {
1687 rec_len = EXT4_DIR_REC_LEN(de->name_len);
1688 if (de > to)
1689 memmove(to, de, rec_len);
1690 to->rec_len = ext4_rec_len_to_disk(rec_len, blocksize);
1691 prev = to;
1692 to = (struct ext4_dir_entry_2 *) (((char *) to) + rec_len);
1693 }
1694 de = next;
1695 }
1696 return prev;
1697 }
1698
1699 /*
1700 * Split a full leaf block to make room for a new dir entry.
1701 * Allocate a new block, and move entries so that they are approx. equally full.
1702 * Returns pointer to de in block into which the new entry will be inserted.
1703 */
1704 static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
1705 struct buffer_head **bh,struct dx_frame *frame,
1706 struct dx_hash_info *hinfo)
1707 {
1708 unsigned blocksize = dir->i_sb->s_blocksize;
1709 unsigned count, continued;
1710 struct buffer_head *bh2;
1711 ext4_lblk_t newblock;
1712 u32 hash2;
1713 struct dx_map_entry *map;
1714 char *data1 = (*bh)->b_data, *data2;
1715 unsigned split, move, size;
1716 struct ext4_dir_entry_2 *de = NULL, *de2;
1717 struct ext4_dir_entry_tail *t;
1718 int csum_size = 0;
1719 int err = 0, i;
1720
1721 if (ext4_has_metadata_csum(dir->i_sb))
1722 csum_size = sizeof(struct ext4_dir_entry_tail);
1723
1724 bh2 = ext4_append(handle, dir, &newblock);
1725 if (IS_ERR(bh2)) {
1726 brelse(*bh);
1727 *bh = NULL;
1728 return (struct ext4_dir_entry_2 *) bh2;
1729 }
1730
1731 BUFFER_TRACE(*bh, "get_write_access");
1732 err = ext4_journal_get_write_access(handle, *bh);
1733 if (err)
1734 goto journal_error;
1735
1736 BUFFER_TRACE(frame->bh, "get_write_access");
1737 err = ext4_journal_get_write_access(handle, frame->bh);
1738 if (err)
1739 goto journal_error;
1740
1741 data2 = bh2->b_data;
1742
1743 /* create map in the end of data2 block */
1744 map = (struct dx_map_entry *) (data2 + blocksize);
1745 count = dx_make_map(dir, (struct ext4_dir_entry_2 *) data1,
1746 blocksize, hinfo, map);
1747 map -= count;
1748 dx_sort_map(map, count);
1749 /* Split the existing block in the middle, size-wise */
1750 size = 0;
1751 move = 0;
1752 for (i = count-1; i >= 0; i--) {
1753 /* is more than half of this entry in 2nd half of the block? */
1754 if (size + map[i].size/2 > blocksize/2)
1755 break;
1756 size += map[i].size;
1757 move++;
1758 }
1759 /* map index at which we will split */
1760 split = count - move;
1761 hash2 = map[split].hash;
1762 continued = hash2 == map[split - 1].hash;
1763 dxtrace(printk(KERN_INFO "Split block %lu at %x, %i/%i\n",
1764 (unsigned long)dx_get_block(frame->at),
1765 hash2, split, count-split));
1766
1767 /* Fancy dance to stay within two buffers */
1768 de2 = dx_move_dirents(data1, data2, map + split, count - split,
1769 blocksize);
1770 de = dx_pack_dirents(data1, blocksize);
1771 de->rec_len = ext4_rec_len_to_disk(data1 + (blocksize - csum_size) -
1772 (char *) de,
1773 blocksize);
1774 de2->rec_len = ext4_rec_len_to_disk(data2 + (blocksize - csum_size) -
1775 (char *) de2,
1776 blocksize);
1777 if (csum_size) {
1778 t = EXT4_DIRENT_TAIL(data2, blocksize);
1779 initialize_dirent_tail(t, blocksize);
1780
1781 t = EXT4_DIRENT_TAIL(data1, blocksize);
1782 initialize_dirent_tail(t, blocksize);
1783 }
1784
1785 dxtrace(dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *) data1,
1786 blocksize, 1));
1787 dxtrace(dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *) data2,
1788 blocksize, 1));
1789
1790 /* Which block gets the new entry? */
1791 if (hinfo->hash >= hash2) {
1792 swap(*bh, bh2);
1793 de = de2;
1794 }
1795 dx_insert_block(frame, hash2 + continued, newblock);
1796 err = ext4_handle_dirty_dirent_node(handle, dir, bh2);
1797 if (err)
1798 goto journal_error;
1799 err = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
1800 if (err)
1801 goto journal_error;
1802 brelse(bh2);
1803 dxtrace(dx_show_index("frame", frame->entries));
1804 return de;
1805
1806 journal_error:
1807 brelse(*bh);
1808 brelse(bh2);
1809 *bh = NULL;
1810 ext4_std_error(dir->i_sb, err);
1811 return ERR_PTR(err);
1812 }
1813
1814 int ext4_find_dest_de(struct inode *dir, struct inode *inode,
1815 struct buffer_head *bh,
1816 void *buf, int buf_size,
1817 struct ext4_filename *fname,
1818 struct ext4_dir_entry_2 **dest_de)
1819 {
1820 struct ext4_dir_entry_2 *de;
1821 unsigned short reclen = EXT4_DIR_REC_LEN(fname_len(fname));
1822 int nlen, rlen;
1823 unsigned int offset = 0;
1824 char *top;
1825 int res;
1826
1827 de = (struct ext4_dir_entry_2 *)buf;
1828 top = buf + buf_size - reclen;
1829 while ((char *) de <= top) {
1830 if (ext4_check_dir_entry(dir, NULL, de, bh,
1831 buf, buf_size, offset)) {
1832 res = -EFSCORRUPTED;
1833 goto return_result;
1834 }
1835 /* Provide crypto context and crypto buffer to ext4 match */
1836 res = ext4_match(fname, de);
1837 if (res < 0)
1838 goto return_result;
1839 if (res > 0) {
1840 res = -EEXIST;
1841 goto return_result;
1842 }
1843 nlen = EXT4_DIR_REC_LEN(de->name_len);
1844 rlen = ext4_rec_len_from_disk(de->rec_len, buf_size);
1845 if ((de->inode ? rlen - nlen : rlen) >= reclen)
1846 break;
1847 de = (struct ext4_dir_entry_2 *)((char *)de + rlen);
1848 offset += rlen;
1849 }
1850
1851 if ((char *) de > top)
1852 res = -ENOSPC;
1853 else {
1854 *dest_de = de;
1855 res = 0;
1856 }
1857 return_result:
1858 return res;
1859 }
1860
1861 int ext4_insert_dentry(struct inode *dir,
1862 struct inode *inode,
1863 struct ext4_dir_entry_2 *de,
1864 int buf_size,
1865 struct ext4_filename *fname)
1866 {
1867
1868 int nlen, rlen;
1869
1870 nlen = EXT4_DIR_REC_LEN(de->name_len);
1871 rlen = ext4_rec_len_from_disk(de->rec_len, buf_size);
1872 if (de->inode) {
1873 struct ext4_dir_entry_2 *de1 =
1874 (struct ext4_dir_entry_2 *)((char *)de + nlen);
1875 de1->rec_len = ext4_rec_len_to_disk(rlen - nlen, buf_size);
1876 de->rec_len = ext4_rec_len_to_disk(nlen, buf_size);
1877 de = de1;
1878 }
1879 de->file_type = EXT4_FT_UNKNOWN;
1880 de->inode = cpu_to_le32(inode->i_ino);
1881 ext4_set_de_type(inode->i_sb, de, inode->i_mode);
1882 de->name_len = fname_len(fname);
1883 memcpy(de->name, fname_name(fname), fname_len(fname));
1884 return 0;
1885 }
1886
1887 /*
1888 * Add a new entry into a directory (leaf) block. If de is non-NULL,
1889 * it points to a directory entry which is guaranteed to be large
1890 * enough for new directory entry. If de is NULL, then
1891 * add_dirent_to_buf will attempt search the directory block for
1892 * space. It will return -ENOSPC if no space is available, and -EIO
1893 * and -EEXIST if directory entry already exists.
1894 */
1895 static int add_dirent_to_buf(handle_t *handle, struct ext4_filename *fname,
1896 struct inode *dir,
1897 struct inode *inode, struct ext4_dir_entry_2 *de,
1898 struct buffer_head *bh)
1899 {
1900 unsigned int blocksize = dir->i_sb->s_blocksize;
1901 int csum_size = 0;
1902 int err;
1903
1904 if (ext4_has_metadata_csum(inode->i_sb))
1905 csum_size = sizeof(struct ext4_dir_entry_tail);
1906
1907 if (!de) {
1908 err = ext4_find_dest_de(dir, inode, bh, bh->b_data,
1909 blocksize - csum_size, fname, &de);
1910 if (err)
1911 return err;
1912 }
1913 BUFFER_TRACE(bh, "get_write_access");
1914 err = ext4_journal_get_write_access(handle, bh);
1915 if (err) {
1916 ext4_std_error(dir->i_sb, err);
1917 return err;
1918 }
1919
1920 /* By now the buffer is marked for journaling. Due to crypto operations,
1921 * the following function call may fail */
1922 err = ext4_insert_dentry(dir, inode, de, blocksize, fname);
1923 if (err < 0)
1924 return err;
1925
1926 /*
1927 * XXX shouldn't update any times until successful
1928 * completion of syscall, but too many callers depend
1929 * on this.
1930 *
1931 * XXX similarly, too many callers depend on
1932 * ext4_new_inode() setting the times, but error
1933 * recovery deletes the inode, so the worst that can
1934 * happen is that the times are slightly out of date
1935 * and/or different from the directory change time.
1936 */
1937 dir->i_mtime = dir->i_ctime = ext4_current_time(dir);
1938 ext4_update_dx_flag(dir);
1939 dir->i_version++;
1940 ext4_mark_inode_dirty(handle, dir);
1941 BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
1942 err = ext4_handle_dirty_dirent_node(handle, dir, bh);
1943 if (err)
1944 ext4_std_error(dir->i_sb, err);
1945 return 0;
1946 }
1947
1948 /*
1949 * This converts a one block unindexed directory to a 3 block indexed
1950 * directory, and adds the dentry to the indexed directory.
1951 */
1952 static int make_indexed_dir(handle_t *handle, struct ext4_filename *fname,
1953 struct dentry *dentry,
1954 struct inode *inode, struct buffer_head *bh)
1955 {
1956 struct inode *dir = d_inode(dentry->d_parent);
1957 struct buffer_head *bh2;
1958 struct dx_root *root;
1959 struct dx_frame frames[2], *frame;
1960 struct dx_entry *entries;
1961 struct ext4_dir_entry_2 *de, *de2;
1962 struct ext4_dir_entry_tail *t;
1963 char *data1, *top;
1964 unsigned len;
1965 int retval;
1966 unsigned blocksize;
1967 ext4_lblk_t block;
1968 struct fake_dirent *fde;
1969 int csum_size = 0;
1970
1971 if (ext4_has_metadata_csum(inode->i_sb))
1972 csum_size = sizeof(struct ext4_dir_entry_tail);
1973
1974 blocksize = dir->i_sb->s_blocksize;
1975 dxtrace(printk(KERN_DEBUG "Creating index: inode %lu\n", dir->i_ino));
1976 BUFFER_TRACE(bh, "get_write_access");
1977 retval = ext4_journal_get_write_access(handle, bh);
1978 if (retval) {
1979 ext4_std_error(dir->i_sb, retval);
1980 brelse(bh);
1981 return retval;
1982 }
1983 root = (struct dx_root *) bh->b_data;
1984
1985 /* The 0th block becomes the root, move the dirents out */
1986 fde = &root->dotdot;
1987 de = (struct ext4_dir_entry_2 *)((char *)fde +
1988 ext4_rec_len_from_disk(fde->rec_len, blocksize));
1989 if ((char *) de >= (((char *) root) + blocksize)) {
1990 EXT4_ERROR_INODE(dir, "invalid rec_len for '..'");
1991 brelse(bh);
1992 return -EFSCORRUPTED;
1993 }
1994 len = ((char *) root) + (blocksize - csum_size) - (char *) de;
1995
1996 /* Allocate new block for the 0th block's dirents */
1997 bh2 = ext4_append(handle, dir, &block);
1998 if (IS_ERR(bh2)) {
1999 brelse(bh);
2000 return PTR_ERR(bh2);
2001 }
2002 ext4_set_inode_flag(dir, EXT4_INODE_INDEX);
2003 data1 = bh2->b_data;
2004
2005 memcpy (data1, de, len);
2006 de = (struct ext4_dir_entry_2 *) data1;
2007 top = data1 + len;
2008 while ((char *)(de2 = ext4_next_entry(de, blocksize)) < top)
2009 de = de2;
2010 de->rec_len = ext4_rec_len_to_disk(data1 + (blocksize - csum_size) -
2011 (char *) de,
2012 blocksize);
2013
2014 if (csum_size) {
2015 t = EXT4_DIRENT_TAIL(data1, blocksize);
2016 initialize_dirent_tail(t, blocksize);
2017 }
2018
2019 /* Initialize the root; the dot dirents already exist */
2020 de = (struct ext4_dir_entry_2 *) (&root->dotdot);
2021 de->rec_len = ext4_rec_len_to_disk(blocksize - EXT4_DIR_REC_LEN(2),
2022 blocksize);
2023 memset (&root->info, 0, sizeof(root->info));
2024 root->info.info_length = sizeof(root->info);
2025 root->info.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version;
2026 entries = root->entries;
2027 dx_set_block(entries, 1);
2028 dx_set_count(entries, 1);
2029 dx_set_limit(entries, dx_root_limit(dir, sizeof(root->info)));
2030
2031 /* Initialize as for dx_probe */
2032 fname->hinfo.hash_version = root->info.hash_version;
2033 if (fname->hinfo.hash_version <= DX_HASH_TEA)
2034 fname->hinfo.hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
2035 fname->hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
2036 ext4fs_dirhash(fname_name(fname), fname_len(fname), &fname->hinfo);
2037
2038 memset(frames, 0, sizeof(frames));
2039 frame = frames;
2040 frame->entries = entries;
2041 frame->at = entries;
2042 frame->bh = bh;
2043
2044 retval = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
2045 if (retval)
2046 goto out_frames;
2047 retval = ext4_handle_dirty_dirent_node(handle, dir, bh2);
2048 if (retval)
2049 goto out_frames;
2050
2051 de = do_split(handle,dir, &bh2, frame, &fname->hinfo);
2052 if (IS_ERR(de)) {
2053 retval = PTR_ERR(de);
2054 goto out_frames;
2055 }
2056
2057 retval = add_dirent_to_buf(handle, fname, dir, inode, de, bh2);
2058 out_frames:
2059 /*
2060 * Even if the block split failed, we have to properly write
2061 * out all the changes we did so far. Otherwise we can end up
2062 * with corrupted filesystem.
2063 */
2064 if (retval)
2065 ext4_mark_inode_dirty(handle, dir);
2066 dx_release(frames);
2067 brelse(bh2);
2068 return retval;
2069 }
2070
2071 /*
2072 * ext4_add_entry()
2073 *
2074 * adds a file entry to the specified directory, using the same
2075 * semantics as ext4_find_entry(). It returns NULL if it failed.
2076 *
2077 * NOTE!! The inode part of 'de' is left at 0 - which means you
2078 * may not sleep between calling this and putting something into
2079 * the entry, as someone else might have used it while you slept.
2080 */
2081 static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
2082 struct inode *inode)
2083 {
2084 struct inode *dir = d_inode(dentry->d_parent);
2085 struct buffer_head *bh = NULL;
2086 struct ext4_dir_entry_2 *de;
2087 struct ext4_dir_entry_tail *t;
2088 struct super_block *sb;
2089 struct ext4_filename fname;
2090 int retval;
2091 int dx_fallback=0;
2092 unsigned blocksize;
2093 ext4_lblk_t block, blocks;
2094 int csum_size = 0;
2095
2096 if (ext4_has_metadata_csum(inode->i_sb))
2097 csum_size = sizeof(struct ext4_dir_entry_tail);
2098
2099 sb = dir->i_sb;
2100 blocksize = sb->s_blocksize;
2101 if (!dentry->d_name.len)
2102 return -EINVAL;
2103
2104 retval = ext4_fname_setup_filename(dir, &dentry->d_name, 0, &fname);
2105 if (retval)
2106 return retval;
2107
2108 if (ext4_has_inline_data(dir)) {
2109 retval = ext4_try_add_inline_entry(handle, &fname,
2110 dentry, inode);
2111 if (retval < 0)
2112 goto out;
2113 if (retval == 1) {
2114 retval = 0;
2115 goto out;
2116 }
2117 }
2118
2119 if (is_dx(dir)) {
2120 retval = ext4_dx_add_entry(handle, &fname, dentry, inode);
2121 if (!retval || (retval != ERR_BAD_DX_DIR))
2122 goto out;
2123 ext4_clear_inode_flag(dir, EXT4_INODE_INDEX);
2124 dx_fallback++;
2125 ext4_mark_inode_dirty(handle, dir);
2126 }
2127 blocks = dir->i_size >> sb->s_blocksize_bits;
2128 for (block = 0; block < blocks; block++) {
2129 bh = ext4_read_dirblock(dir, block, DIRENT);
2130 if (IS_ERR(bh)) {
2131 retval = PTR_ERR(bh);
2132 bh = NULL;
2133 goto out;
2134 }
2135 retval = add_dirent_to_buf(handle, &fname, dir, inode,
2136 NULL, bh);
2137 if (retval != -ENOSPC)
2138 goto out;
2139
2140 if (blocks == 1 && !dx_fallback &&
2141 ext4_has_feature_dir_index(sb)) {
2142 retval = make_indexed_dir(handle, &fname, dentry,
2143 inode, bh);
2144 bh = NULL; /* make_indexed_dir releases bh */
2145 goto out;
2146 }
2147 brelse(bh);
2148 }
2149 bh = ext4_append(handle, dir, &block);
2150 if (IS_ERR(bh)) {
2151 retval = PTR_ERR(bh);
2152 bh = NULL;
2153 goto out;
2154 }
2155 de = (struct ext4_dir_entry_2 *) bh->b_data;
2156 de->inode = 0;
2157 de->rec_len = ext4_rec_len_to_disk(blocksize - csum_size, blocksize);
2158
2159 if (csum_size) {
2160 t = EXT4_DIRENT_TAIL(bh->b_data, blocksize);
2161 initialize_dirent_tail(t, blocksize);
2162 }
2163
2164 retval = add_dirent_to_buf(handle, &fname, dir, inode, de, bh);
2165 out:
2166 ext4_fname_free_filename(&fname);
2167 brelse(bh);
2168 if (retval == 0)
2169 ext4_set_inode_state(inode, EXT4_STATE_NEWENTRY);
2170 return retval;
2171 }
2172
2173 /*
2174 * Returns 0 for success, or a negative error value
2175 */
2176 static int ext4_dx_add_entry(handle_t *handle, struct ext4_filename *fname,
2177 struct dentry *dentry, struct inode *inode)
2178 {
2179 struct dx_frame frames[2], *frame;
2180 struct dx_entry *entries, *at;
2181 struct buffer_head *bh;
2182 struct inode *dir = d_inode(dentry->d_parent);
2183 struct super_block *sb = dir->i_sb;
2184 struct ext4_dir_entry_2 *de;
2185 int err;
2186
2187 frame = dx_probe(fname, dir, NULL, frames);
2188 if (IS_ERR(frame))
2189 return PTR_ERR(frame);
2190 entries = frame->entries;
2191 at = frame->at;
2192 bh = ext4_read_dirblock(dir, dx_get_block(frame->at), DIRENT);
2193 if (IS_ERR(bh)) {
2194 err = PTR_ERR(bh);
2195 bh = NULL;
2196 goto cleanup;
2197 }
2198
2199 BUFFER_TRACE(bh, "get_write_access");
2200 err = ext4_journal_get_write_access(handle, bh);
2201 if (err)
2202 goto journal_error;
2203
2204 err = add_dirent_to_buf(handle, fname, dir, inode, NULL, bh);
2205 if (err != -ENOSPC)
2206 goto cleanup;
2207
2208 /* Block full, should compress but for now just split */
2209 dxtrace(printk(KERN_DEBUG "using %u of %u node entries\n",
2210 dx_get_count(entries), dx_get_limit(entries)));
2211 /* Need to split index? */
2212 if (dx_get_count(entries) == dx_get_limit(entries)) {
2213 ext4_lblk_t newblock;
2214 unsigned icount = dx_get_count(entries);
2215 int levels = frame - frames;
2216 struct dx_entry *entries2;
2217 struct dx_node *node2;
2218 struct buffer_head *bh2;
2219
2220 if (levels && (dx_get_count(frames->entries) ==
2221 dx_get_limit(frames->entries))) {
2222 ext4_warning_inode(dir, "Directory index full!");
2223 err = -ENOSPC;
2224 goto cleanup;
2225 }
2226 bh2 = ext4_append(handle, dir, &newblock);
2227 if (IS_ERR(bh2)) {
2228 err = PTR_ERR(bh2);
2229 goto cleanup;
2230 }
2231 node2 = (struct dx_node *)(bh2->b_data);
2232 entries2 = node2->entries;
2233 memset(&node2->fake, 0, sizeof(struct fake_dirent));
2234 node2->fake.rec_len = ext4_rec_len_to_disk(sb->s_blocksize,
2235 sb->s_blocksize);
2236 BUFFER_TRACE(frame->bh, "get_write_access");
2237 err = ext4_journal_get_write_access(handle, frame->bh);
2238 if (err)
2239 goto journal_error;
2240 if (levels) {
2241 unsigned icount1 = icount/2, icount2 = icount - icount1;
2242 unsigned hash2 = dx_get_hash(entries + icount1);
2243 dxtrace(printk(KERN_DEBUG "Split index %i/%i\n",
2244 icount1, icount2));
2245
2246 BUFFER_TRACE(frame->bh, "get_write_access"); /* index root */
2247 err = ext4_journal_get_write_access(handle,
2248 frames[0].bh);
2249 if (err)
2250 goto journal_error;
2251
2252 memcpy((char *) entries2, (char *) (entries + icount1),
2253 icount2 * sizeof(struct dx_entry));
2254 dx_set_count(entries, icount1);
2255 dx_set_count(entries2, icount2);
2256 dx_set_limit(entries2, dx_node_limit(dir));
2257
2258 /* Which index block gets the new entry? */
2259 if (at - entries >= icount1) {
2260 frame->at = at = at - entries - icount1 + entries2;
2261 frame->entries = entries = entries2;
2262 swap(frame->bh, bh2);
2263 }
2264 dx_insert_block(frames + 0, hash2, newblock);
2265 dxtrace(dx_show_index("node", frames[1].entries));
2266 dxtrace(dx_show_index("node",
2267 ((struct dx_node *) bh2->b_data)->entries));
2268 err = ext4_handle_dirty_dx_node(handle, dir, bh2);
2269 if (err)
2270 goto journal_error;
2271 brelse (bh2);
2272 } else {
2273 dxtrace(printk(KERN_DEBUG
2274 "Creating second level index...\n"));
2275 memcpy((char *) entries2, (char *) entries,
2276 icount * sizeof(struct dx_entry));
2277 dx_set_limit(entries2, dx_node_limit(dir));
2278
2279 /* Set up root */
2280 dx_set_count(entries, 1);
2281 dx_set_block(entries + 0, newblock);
2282 ((struct dx_root *) frames[0].bh->b_data)->info.indirect_levels = 1;
2283
2284 /* Add new access path frame */
2285 frame = frames + 1;
2286 frame->at = at = at - entries + entries2;
2287 frame->entries = entries = entries2;
2288 frame->bh = bh2;
2289 err = ext4_journal_get_write_access(handle,
2290 frame->bh);
2291 if (err)
2292 goto journal_error;
2293 }
2294 err = ext4_handle_dirty_dx_node(handle, dir, frames[0].bh);
2295 if (err) {
2296 ext4_std_error(inode->i_sb, err);
2297 goto cleanup;
2298 }
2299 }
2300 de = do_split(handle, dir, &bh, frame, &fname->hinfo);
2301 if (IS_ERR(de)) {
2302 err = PTR_ERR(de);
2303 goto cleanup;
2304 }
2305 err = add_dirent_to_buf(handle, fname, dir, inode, de, bh);
2306 goto cleanup;
2307
2308 journal_error:
2309 ext4_std_error(dir->i_sb, err);
2310 cleanup:
2311 brelse(bh);
2312 dx_release(frames);
2313 return err;
2314 }
2315
2316 /*
2317 * ext4_generic_delete_entry deletes a directory entry by merging it
2318 * with the previous entry
2319 */
2320 int ext4_generic_delete_entry(handle_t *handle,
2321 struct inode *dir,
2322 struct ext4_dir_entry_2 *de_del,
2323 struct buffer_head *bh,
2324 void *entry_buf,
2325 int buf_size,
2326 int csum_size)
2327 {
2328 struct ext4_dir_entry_2 *de, *pde;
2329 unsigned int blocksize = dir->i_sb->s_blocksize;
2330 int i;
2331
2332 i = 0;
2333 pde = NULL;
2334 de = (struct ext4_dir_entry_2 *)entry_buf;
2335 while (i < buf_size - csum_size) {
2336 if (ext4_check_dir_entry(dir, NULL, de, bh,
2337 bh->b_data, bh->b_size, i))
2338 return -EFSCORRUPTED;
2339 if (de == de_del) {
2340 if (pde)
2341 pde->rec_len = ext4_rec_len_to_disk(
2342 ext4_rec_len_from_disk(pde->rec_len,
2343 blocksize) +
2344 ext4_rec_len_from_disk(de->rec_len,
2345 blocksize),
2346 blocksize);
2347 else
2348 de->inode = 0;
2349 dir->i_version++;
2350 return 0;
2351 }
2352 i += ext4_rec_len_from_disk(de->rec_len, blocksize);
2353 pde = de;
2354 de = ext4_next_entry(de, blocksize);
2355 }
2356 return -ENOENT;
2357 }
2358
2359 static int ext4_delete_entry(handle_t *handle,
2360 struct inode *dir,
2361 struct ext4_dir_entry_2 *de_del,
2362 struct buffer_head *bh)
2363 {
2364 int err, csum_size = 0;
2365
2366 if (ext4_has_inline_data(dir)) {
2367 int has_inline_data = 1;
2368 err = ext4_delete_inline_entry(handle, dir, de_del, bh,
2369 &has_inline_data);
2370 if (has_inline_data)
2371 return err;
2372 }
2373
2374 if (ext4_has_metadata_csum(dir->i_sb))
2375 csum_size = sizeof(struct ext4_dir_entry_tail);
2376
2377 BUFFER_TRACE(bh, "get_write_access");
2378 err = ext4_journal_get_write_access(handle, bh);
2379 if (unlikely(err))
2380 goto out;
2381
2382 err = ext4_generic_delete_entry(handle, dir, de_del,
2383 bh, bh->b_data,
2384 dir->i_sb->s_blocksize, csum_size);
2385 if (err)
2386 goto out;
2387
2388 BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
2389 err = ext4_handle_dirty_dirent_node(handle, dir, bh);
2390 if (unlikely(err))
2391 goto out;
2392
2393 return 0;
2394 out:
2395 if (err != -ENOENT)
2396 ext4_std_error(dir->i_sb, err);
2397 return err;
2398 }
2399
2400 /*
2401 * DIR_NLINK feature is set if 1) nlinks > EXT4_LINK_MAX or 2) nlinks == 2,
2402 * since this indicates that nlinks count was previously 1.
2403 */
2404 static void ext4_inc_count(handle_t *handle, struct inode *inode)
2405 {
2406 inc_nlink(inode);
2407 if (is_dx(inode) && inode->i_nlink > 1) {
2408 /* limit is 16-bit i_links_count */
2409 if (inode->i_nlink >= EXT4_LINK_MAX || inode->i_nlink == 2) {
2410 set_nlink(inode, 1);
2411 ext4_set_feature_dir_nlink(inode->i_sb);
2412 }
2413 }
2414 }
2415
2416 /*
2417 * If a directory had nlink == 1, then we should let it be 1. This indicates
2418 * directory has >EXT4_LINK_MAX subdirs.
2419 */
2420 static void ext4_dec_count(handle_t *handle, struct inode *inode)
2421 {
2422 if (!S_ISDIR(inode->i_mode) || inode->i_nlink > 2)
2423 drop_nlink(inode);
2424 }
2425
2426
2427 static int ext4_add_nondir(handle_t *handle,
2428 struct dentry *dentry, struct inode *inode)
2429 {
2430 int err = ext4_add_entry(handle, dentry, inode);
2431 if (!err) {
2432 ext4_mark_inode_dirty(handle, inode);
2433 d_instantiate_new(dentry, inode);
2434 return 0;
2435 }
2436 drop_nlink(inode);
2437 unlock_new_inode(inode);
2438 iput(inode);
2439 return err;
2440 }
2441
2442 /*
2443 * By the time this is called, we already have created
2444 * the directory cache entry for the new file, but it
2445 * is so far negative - it has no inode.
2446 *
2447 * If the create succeeds, we fill in the inode information
2448 * with d_instantiate().
2449 */
2450 static int ext4_create(struct inode *dir, struct dentry *dentry, umode_t mode,
2451 bool excl)
2452 {
2453 handle_t *handle;
2454 struct inode *inode;
2455 int err, credits, retries = 0;
2456
2457 err = dquot_initialize(dir);
2458 if (err)
2459 return err;
2460
2461 credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2462 EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
2463 retry:
2464 inode = ext4_new_inode_start_handle(dir, mode, &dentry->d_name, 0,
2465 NULL, EXT4_HT_DIR, credits);
2466 handle = ext4_journal_current_handle();
2467 err = PTR_ERR(inode);
2468 if (!IS_ERR(inode)) {
2469 inode->i_op = &ext4_file_inode_operations;
2470 inode->i_fop = &ext4_file_operations;
2471 ext4_set_aops(inode);
2472 err = ext4_add_nondir(handle, dentry, inode);
2473 if (!err && IS_DIRSYNC(dir))
2474 ext4_handle_sync(handle);
2475 }
2476 if (handle)
2477 ext4_journal_stop(handle);
2478 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2479 goto retry;
2480 return err;
2481 }
2482
2483 static int ext4_mknod(struct inode *dir, struct dentry *dentry,
2484 umode_t mode, dev_t rdev)
2485 {
2486 handle_t *handle;
2487 struct inode *inode;
2488 int err, credits, retries = 0;
2489
2490 err = dquot_initialize(dir);
2491 if (err)
2492 return err;
2493
2494 credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2495 EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
2496 retry:
2497 inode = ext4_new_inode_start_handle(dir, mode, &dentry->d_name, 0,
2498 NULL, EXT4_HT_DIR, credits);
2499 handle = ext4_journal_current_handle();
2500 err = PTR_ERR(inode);
2501 if (!IS_ERR(inode)) {
2502 init_special_inode(inode, inode->i_mode, rdev);
2503 inode->i_op = &ext4_special_inode_operations;
2504 err = ext4_add_nondir(handle, dentry, inode);
2505 if (!err && IS_DIRSYNC(dir))
2506 ext4_handle_sync(handle);
2507 }
2508 if (handle)
2509 ext4_journal_stop(handle);
2510 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2511 goto retry;
2512 return err;
2513 }
2514
2515 static int ext4_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
2516 {
2517 handle_t *handle;
2518 struct inode *inode;
2519 int err, retries = 0;
2520
2521 err = dquot_initialize(dir);
2522 if (err)
2523 return err;
2524
2525 retry:
2526 inode = ext4_new_inode_start_handle(dir, mode,
2527 NULL, 0, NULL,
2528 EXT4_HT_DIR,
2529 EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) +
2530 4 + EXT4_XATTR_TRANS_BLOCKS);
2531 handle = ext4_journal_current_handle();
2532 err = PTR_ERR(inode);
2533 if (!IS_ERR(inode)) {
2534 inode->i_op = &ext4_file_inode_operations;
2535 inode->i_fop = &ext4_file_operations;
2536 ext4_set_aops(inode);
2537 d_tmpfile(dentry, inode);
2538 err = ext4_orphan_add(handle, inode);
2539 if (err)
2540 goto err_unlock_inode;
2541 mark_inode_dirty(inode);
2542 unlock_new_inode(inode);
2543 }
2544 if (handle)
2545 ext4_journal_stop(handle);
2546 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2547 goto retry;
2548 return err;
2549 err_unlock_inode:
2550 ext4_journal_stop(handle);
2551 unlock_new_inode(inode);
2552 return err;
2553 }
2554
2555 struct ext4_dir_entry_2 *ext4_init_dot_dotdot(struct inode *inode,
2556 struct ext4_dir_entry_2 *de,
2557 int blocksize, int csum_size,
2558 unsigned int parent_ino, int dotdot_real_len)
2559 {
2560 de->inode = cpu_to_le32(inode->i_ino);
2561 de->name_len = 1;
2562 de->rec_len = ext4_rec_len_to_disk(EXT4_DIR_REC_LEN(de->name_len),
2563 blocksize);
2564 strcpy(de->name, ".");
2565 ext4_set_de_type(inode->i_sb, de, S_IFDIR);
2566
2567 de = ext4_next_entry(de, blocksize);
2568 de->inode = cpu_to_le32(parent_ino);
2569 de->name_len = 2;
2570 if (!dotdot_real_len)
2571 de->rec_len = ext4_rec_len_to_disk(blocksize -
2572 (csum_size + EXT4_DIR_REC_LEN(1)),
2573 blocksize);
2574 else
2575 de->rec_len = ext4_rec_len_to_disk(
2576 EXT4_DIR_REC_LEN(de->name_len), blocksize);
2577 strcpy(de->name, "..");
2578 ext4_set_de_type(inode->i_sb, de, S_IFDIR);
2579
2580 return ext4_next_entry(de, blocksize);
2581 }
2582
2583 static int ext4_init_new_dir(handle_t *handle, struct inode *dir,
2584 struct inode *inode)
2585 {
2586 struct buffer_head *dir_block = NULL;
2587 struct ext4_dir_entry_2 *de;
2588 struct ext4_dir_entry_tail *t;
2589 ext4_lblk_t block = 0;
2590 unsigned int blocksize = dir->i_sb->s_blocksize;
2591 int csum_size = 0;
2592 int err;
2593
2594 if (ext4_has_metadata_csum(dir->i_sb))
2595 csum_size = sizeof(struct ext4_dir_entry_tail);
2596
2597 if (ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA)) {
2598 err = ext4_try_create_inline_dir(handle, dir, inode);
2599 if (err < 0 && err != -ENOSPC)
2600 goto out;
2601 if (!err)
2602 goto out;
2603 }
2604
2605 inode->i_size = 0;
2606 dir_block = ext4_append(handle, inode, &block);
2607 if (IS_ERR(dir_block))
2608 return PTR_ERR(dir_block);
2609 de = (struct ext4_dir_entry_2 *)dir_block->b_data;
2610 ext4_init_dot_dotdot(inode, de, blocksize, csum_size, dir->i_ino, 0);
2611 set_nlink(inode, 2);
2612 if (csum_size) {
2613 t = EXT4_DIRENT_TAIL(dir_block->b_data, blocksize);
2614 initialize_dirent_tail(t, blocksize);
2615 }
2616
2617 BUFFER_TRACE(dir_block, "call ext4_handle_dirty_metadata");
2618 err = ext4_handle_dirty_dirent_node(handle, inode, dir_block);
2619 if (err)
2620 goto out;
2621 set_buffer_verified(dir_block);
2622 out:
2623 brelse(dir_block);
2624 return err;
2625 }
2626
2627 static int ext4_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
2628 {
2629 handle_t *handle;
2630 struct inode *inode;
2631 int err, credits, retries = 0;
2632
2633 if (EXT4_DIR_LINK_MAX(dir))
2634 return -EMLINK;
2635
2636 err = dquot_initialize(dir);
2637 if (err)
2638 return err;
2639
2640 credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2641 EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
2642 retry:
2643 inode = ext4_new_inode_start_handle(dir, S_IFDIR | mode,
2644 &dentry->d_name,
2645 0, NULL, EXT4_HT_DIR, credits);
2646 handle = ext4_journal_current_handle();
2647 err = PTR_ERR(inode);
2648 if (IS_ERR(inode))
2649 goto out_stop;
2650
2651 inode->i_op = &ext4_dir_inode_operations;
2652 inode->i_fop = &ext4_dir_operations;
2653 err = ext4_init_new_dir(handle, dir, inode);
2654 if (err)
2655 goto out_clear_inode;
2656 err = ext4_mark_inode_dirty(handle, inode);
2657 if (!err)
2658 err = ext4_add_entry(handle, dentry, inode);
2659 if (err) {
2660 out_clear_inode:
2661 clear_nlink(inode);
2662 unlock_new_inode(inode);
2663 ext4_mark_inode_dirty(handle, inode);
2664 iput(inode);
2665 goto out_stop;
2666 }
2667 ext4_inc_count(handle, dir);
2668 ext4_update_dx_flag(dir);
2669 err = ext4_mark_inode_dirty(handle, dir);
2670 if (err)
2671 goto out_clear_inode;
2672 d_instantiate_new(dentry, inode);
2673 if (IS_DIRSYNC(dir))
2674 ext4_handle_sync(handle);
2675
2676 out_stop:
2677 if (handle)
2678 ext4_journal_stop(handle);
2679 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2680 goto retry;
2681 return err;
2682 }
2683
2684 /*
2685 * routine to check that the specified directory is empty (for rmdir)
2686 */
2687 int ext4_empty_dir(struct inode *inode)
2688 {
2689 unsigned int offset;
2690 struct buffer_head *bh;
2691 struct ext4_dir_entry_2 *de, *de1;
2692 struct super_block *sb;
2693 int err = 0;
2694
2695 if (ext4_has_inline_data(inode)) {
2696 int has_inline_data = 1;
2697
2698 err = empty_inline_dir(inode, &has_inline_data);
2699 if (has_inline_data)
2700 return err;
2701 }
2702
2703 sb = inode->i_sb;
2704 if (inode->i_size < EXT4_DIR_REC_LEN(1) + EXT4_DIR_REC_LEN(2)) {
2705 EXT4_ERROR_INODE(inode, "invalid size");
2706 return 1;
2707 }
2708 bh = ext4_read_dirblock(inode, 0, EITHER);
2709 if (IS_ERR(bh))
2710 return 1;
2711
2712 de = (struct ext4_dir_entry_2 *) bh->b_data;
2713 de1 = ext4_next_entry(de, sb->s_blocksize);
2714 if (le32_to_cpu(de->inode) != inode->i_ino ||
2715 le32_to_cpu(de1->inode) == 0 ||
2716 strcmp(".", de->name) || strcmp("..", de1->name)) {
2717 ext4_warning_inode(inode, "directory missing '.' and/or '..'");
2718 brelse(bh);
2719 return 1;
2720 }
2721 offset = ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize) +
2722 ext4_rec_len_from_disk(de1->rec_len, sb->s_blocksize);
2723 de = ext4_next_entry(de1, sb->s_blocksize);
2724 while (offset < inode->i_size) {
2725 if ((void *) de >= (void *) (bh->b_data+sb->s_blocksize)) {
2726 unsigned int lblock;
2727 err = 0;
2728 brelse(bh);
2729 lblock = offset >> EXT4_BLOCK_SIZE_BITS(sb);
2730 bh = ext4_read_dirblock(inode, lblock, EITHER);
2731 if (IS_ERR(bh))
2732 return 1;
2733 de = (struct ext4_dir_entry_2 *) bh->b_data;
2734 }
2735 if (ext4_check_dir_entry(inode, NULL, de, bh,
2736 bh->b_data, bh->b_size, offset)) {
2737 de = (struct ext4_dir_entry_2 *)(bh->b_data +
2738 sb->s_blocksize);
2739 offset = (offset | (sb->s_blocksize - 1)) + 1;
2740 continue;
2741 }
2742 if (le32_to_cpu(de->inode)) {
2743 brelse(bh);
2744 return 0;
2745 }
2746 offset += ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize);
2747 de = ext4_next_entry(de, sb->s_blocksize);
2748 }
2749 brelse(bh);
2750 return 1;
2751 }
2752
2753 /*
2754 * ext4_orphan_add() links an unlinked or truncated inode into a list of
2755 * such inodes, starting at the superblock, in case we crash before the
2756 * file is closed/deleted, or in case the inode truncate spans multiple
2757 * transactions and the last transaction is not recovered after a crash.
2758 *
2759 * At filesystem recovery time, we walk this list deleting unlinked
2760 * inodes and truncating linked inodes in ext4_orphan_cleanup().
2761 *
2762 * Orphan list manipulation functions must be called under i_mutex unless
2763 * we are just creating the inode or deleting it.
2764 */
2765 int ext4_orphan_add(handle_t *handle, struct inode *inode)
2766 {
2767 struct super_block *sb = inode->i_sb;
2768 struct ext4_sb_info *sbi = EXT4_SB(sb);
2769 struct ext4_iloc iloc;
2770 int err = 0, rc;
2771 bool dirty = false;
2772
2773 if (!sbi->s_journal || is_bad_inode(inode))
2774 return 0;
2775
2776 WARN_ON_ONCE(!(inode->i_state & (I_NEW | I_FREEING)) &&
2777 !mutex_is_locked(&inode->i_mutex));
2778 /*
2779 * Exit early if inode already is on orphan list. This is a big speedup
2780 * since we don't have to contend on the global s_orphan_lock.
2781 */
2782 if (!list_empty(&EXT4_I(inode)->i_orphan))
2783 return 0;
2784
2785 /*
2786 * Orphan handling is only valid for files with data blocks
2787 * being truncated, or files being unlinked. Note that we either
2788 * hold i_mutex, or the inode can not be referenced from outside,
2789 * so i_nlink should not be bumped due to race
2790 */
2791 J_ASSERT((S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
2792 S_ISLNK(inode->i_mode)) || inode->i_nlink == 0);
2793
2794 BUFFER_TRACE(sbi->s_sbh, "get_write_access");
2795 err = ext4_journal_get_write_access(handle, sbi->s_sbh);
2796 if (err)
2797 goto out;
2798
2799 err = ext4_reserve_inode_write(handle, inode, &iloc);
2800 if (err)
2801 goto out;
2802
2803 mutex_lock(&sbi->s_orphan_lock);
2804 /*
2805 * Due to previous errors inode may be already a part of on-disk
2806 * orphan list. If so skip on-disk list modification.
2807 */
2808 if (!NEXT_ORPHAN(inode) || NEXT_ORPHAN(inode) >
2809 (le32_to_cpu(sbi->s_es->s_inodes_count))) {
2810 /* Insert this inode at the head of the on-disk orphan list */
2811 NEXT_ORPHAN(inode) = le32_to_cpu(sbi->s_es->s_last_orphan);
2812 sbi->s_es->s_last_orphan = cpu_to_le32(inode->i_ino);
2813 dirty = true;
2814 }
2815 list_add(&EXT4_I(inode)->i_orphan, &sbi->s_orphan);
2816 mutex_unlock(&sbi->s_orphan_lock);
2817
2818 if (dirty) {
2819 err = ext4_handle_dirty_super(handle, sb);
2820 rc = ext4_mark_iloc_dirty(handle, inode, &iloc);
2821 if (!err)
2822 err = rc;
2823 if (err) {
2824 /*
2825 * We have to remove inode from in-memory list if
2826 * addition to on disk orphan list failed. Stray orphan
2827 * list entries can cause panics at unmount time.
2828 */
2829 mutex_lock(&sbi->s_orphan_lock);
2830 list_del_init(&EXT4_I(inode)->i_orphan);
2831 mutex_unlock(&sbi->s_orphan_lock);
2832 }
2833 }
2834 jbd_debug(4, "superblock will point to %lu\n", inode->i_ino);
2835 jbd_debug(4, "orphan inode %lu will point to %d\n",
2836 inode->i_ino, NEXT_ORPHAN(inode));
2837 out:
2838 ext4_std_error(sb, err);
2839 return err;
2840 }
2841
2842 /*
2843 * ext4_orphan_del() removes an unlinked or truncated inode from the list
2844 * of such inodes stored on disk, because it is finally being cleaned up.
2845 */
2846 int ext4_orphan_del(handle_t *handle, struct inode *inode)
2847 {
2848 struct list_head *prev;
2849 struct ext4_inode_info *ei = EXT4_I(inode);
2850 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
2851 __u32 ino_next;
2852 struct ext4_iloc iloc;
2853 int err = 0;
2854
2855 if (!sbi->s_journal && !(sbi->s_mount_state & EXT4_ORPHAN_FS))
2856 return 0;
2857
2858 WARN_ON_ONCE(!(inode->i_state & (I_NEW | I_FREEING)) &&
2859 !mutex_is_locked(&inode->i_mutex));
2860 /* Do this quick check before taking global s_orphan_lock. */
2861 if (list_empty(&ei->i_orphan))
2862 return 0;
2863
2864 if (handle) {
2865 /* Grab inode buffer early before taking global s_orphan_lock */
2866 err = ext4_reserve_inode_write(handle, inode, &iloc);
2867 }
2868
2869 mutex_lock(&sbi->s_orphan_lock);
2870 jbd_debug(4, "remove inode %lu from orphan list\n", inode->i_ino);
2871
2872 prev = ei->i_orphan.prev;
2873 list_del_init(&ei->i_orphan);
2874
2875 /* If we're on an error path, we may not have a valid
2876 * transaction handle with which to update the orphan list on
2877 * disk, but we still need to remove the inode from the linked
2878 * list in memory. */
2879 if (!handle || err) {
2880 mutex_unlock(&sbi->s_orphan_lock);
2881 goto out_err;
2882 }
2883
2884 ino_next = NEXT_ORPHAN(inode);
2885 if (prev == &sbi->s_orphan) {
2886 jbd_debug(4, "superblock will point to %u\n", ino_next);
2887 BUFFER_TRACE(sbi->s_sbh, "get_write_access");
2888 err = ext4_journal_get_write_access(handle, sbi->s_sbh);
2889 if (err) {
2890 mutex_unlock(&sbi->s_orphan_lock);
2891 goto out_brelse;
2892 }
2893 sbi->s_es->s_last_orphan = cpu_to_le32(ino_next);
2894 mutex_unlock(&sbi->s_orphan_lock);
2895 err = ext4_handle_dirty_super(handle, inode->i_sb);
2896 } else {
2897 struct ext4_iloc iloc2;
2898 struct inode *i_prev =
2899 &list_entry(prev, struct ext4_inode_info, i_orphan)->vfs_inode;
2900
2901 jbd_debug(4, "orphan inode %lu will point to %u\n",
2902 i_prev->i_ino, ino_next);
2903 err = ext4_reserve_inode_write(handle, i_prev, &iloc2);
2904 if (err) {
2905 mutex_unlock(&sbi->s_orphan_lock);
2906 goto out_brelse;
2907 }
2908 NEXT_ORPHAN(i_prev) = ino_next;
2909 err = ext4_mark_iloc_dirty(handle, i_prev, &iloc2);
2910 mutex_unlock(&sbi->s_orphan_lock);
2911 }
2912 if (err)
2913 goto out_brelse;
2914 NEXT_ORPHAN(inode) = 0;
2915 err = ext4_mark_iloc_dirty(handle, inode, &iloc);
2916 out_err:
2917 ext4_std_error(inode->i_sb, err);
2918 return err;
2919
2920 out_brelse:
2921 brelse(iloc.bh);
2922 goto out_err;
2923 }
2924
2925 static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
2926 {
2927 int retval;
2928 struct inode *inode;
2929 struct buffer_head *bh;
2930 struct ext4_dir_entry_2 *de;
2931 handle_t *handle = NULL;
2932
2933 /* Initialize quotas before so that eventual writes go in
2934 * separate transaction */
2935 retval = dquot_initialize(dir);
2936 if (retval)
2937 return retval;
2938 retval = dquot_initialize(d_inode(dentry));
2939 if (retval)
2940 return retval;
2941
2942 retval = -ENOENT;
2943 bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
2944 if (IS_ERR(bh))
2945 return PTR_ERR(bh);
2946 if (!bh)
2947 goto end_rmdir;
2948
2949 inode = d_inode(dentry);
2950
2951 retval = -EFSCORRUPTED;
2952 if (le32_to_cpu(de->inode) != inode->i_ino)
2953 goto end_rmdir;
2954
2955 retval = -ENOTEMPTY;
2956 if (!ext4_empty_dir(inode))
2957 goto end_rmdir;
2958
2959 handle = ext4_journal_start(dir, EXT4_HT_DIR,
2960 EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
2961 if (IS_ERR(handle)) {
2962 retval = PTR_ERR(handle);
2963 handle = NULL;
2964 goto end_rmdir;
2965 }
2966
2967 if (IS_DIRSYNC(dir))
2968 ext4_handle_sync(handle);
2969
2970 retval = ext4_delete_entry(handle, dir, de, bh);
2971 if (retval)
2972 goto end_rmdir;
2973 if (!EXT4_DIR_LINK_EMPTY(inode))
2974 ext4_warning_inode(inode,
2975 "empty directory '%.*s' has too many links (%u)",
2976 dentry->d_name.len, dentry->d_name.name,
2977 inode->i_nlink);
2978 inode->i_version++;
2979 clear_nlink(inode);
2980 /* There's no need to set i_disksize: the fact that i_nlink is
2981 * zero will ensure that the right thing happens during any
2982 * recovery. */
2983 inode->i_size = 0;
2984 ext4_orphan_add(handle, inode);
2985 inode->i_ctime = dir->i_ctime = dir->i_mtime = ext4_current_time(inode);
2986 ext4_mark_inode_dirty(handle, inode);
2987 ext4_dec_count(handle, dir);
2988 ext4_update_dx_flag(dir);
2989 ext4_mark_inode_dirty(handle, dir);
2990
2991 end_rmdir:
2992 brelse(bh);
2993 if (handle)
2994 ext4_journal_stop(handle);
2995 return retval;
2996 }
2997
2998 static int ext4_unlink(struct inode *dir, struct dentry *dentry)
2999 {
3000 int retval;
3001 struct inode *inode;
3002 struct buffer_head *bh;
3003 struct ext4_dir_entry_2 *de;
3004 handle_t *handle = NULL;
3005
3006 trace_ext4_unlink_enter(dir, dentry);
3007 /* Initialize quotas before so that eventual writes go
3008 * in separate transaction */
3009 retval = dquot_initialize(dir);
3010 if (retval)
3011 return retval;
3012 retval = dquot_initialize(d_inode(dentry));
3013 if (retval)
3014 return retval;
3015
3016 retval = -ENOENT;
3017 bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
3018 if (IS_ERR(bh))
3019 return PTR_ERR(bh);
3020 if (!bh)
3021 goto end_unlink;
3022
3023 inode = d_inode(dentry);
3024
3025 retval = -EFSCORRUPTED;
3026 if (le32_to_cpu(de->inode) != inode->i_ino)
3027 goto end_unlink;
3028
3029 handle = ext4_journal_start(dir, EXT4_HT_DIR,
3030 EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
3031 if (IS_ERR(handle)) {
3032 retval = PTR_ERR(handle);
3033 handle = NULL;
3034 goto end_unlink;
3035 }
3036
3037 if (IS_DIRSYNC(dir))
3038 ext4_handle_sync(handle);
3039
3040 if (inode->i_nlink == 0) {
3041 ext4_warning_inode(inode, "Deleting file '%.*s' with no links",
3042 dentry->d_name.len, dentry->d_name.name);
3043 set_nlink(inode, 1);
3044 }
3045 retval = ext4_delete_entry(handle, dir, de, bh);
3046 if (retval)
3047 goto end_unlink;
3048 dir->i_ctime = dir->i_mtime = ext4_current_time(dir);
3049 ext4_update_dx_flag(dir);
3050 ext4_mark_inode_dirty(handle, dir);
3051 drop_nlink(inode);
3052 if (!inode->i_nlink)
3053 ext4_orphan_add(handle, inode);
3054 inode->i_ctime = ext4_current_time(inode);
3055 ext4_mark_inode_dirty(handle, inode);
3056
3057 end_unlink:
3058 brelse(bh);
3059 if (handle)
3060 ext4_journal_stop(handle);
3061 trace_ext4_unlink_exit(dentry, retval);
3062 return retval;
3063 }
3064
3065 static int ext4_symlink(struct inode *dir,
3066 struct dentry *dentry, const char *symname)
3067 {
3068 handle_t *handle;
3069 struct inode *inode;
3070 int err, len = strlen(symname);
3071 int credits;
3072 bool encryption_required;
3073 struct ext4_str disk_link;
3074 struct ext4_encrypted_symlink_data *sd = NULL;
3075
3076 disk_link.len = len + 1;
3077 disk_link.name = (char *) symname;
3078
3079 encryption_required = (ext4_encrypted_inode(dir) ||
3080 DUMMY_ENCRYPTION_ENABLED(EXT4_SB(dir->i_sb)));
3081 if (encryption_required) {
3082 err = ext4_get_encryption_info(dir);
3083 if (err)
3084 return err;
3085 if (ext4_encryption_info(dir) == NULL)
3086 return -EPERM;
3087 disk_link.len = (ext4_fname_encrypted_size(dir, len) +
3088 sizeof(struct ext4_encrypted_symlink_data));
3089 sd = kzalloc(disk_link.len, GFP_KERNEL);
3090 if (!sd)
3091 return -ENOMEM;
3092 }
3093
3094 if (disk_link.len > dir->i_sb->s_blocksize) {
3095 err = -ENAMETOOLONG;
3096 goto err_free_sd;
3097 }
3098
3099 err = dquot_initialize(dir);
3100 if (err)
3101 goto err_free_sd;
3102
3103 if ((disk_link.len > EXT4_N_BLOCKS * 4)) {
3104 /*
3105 * For non-fast symlinks, we just allocate inode and put it on
3106 * orphan list in the first transaction => we need bitmap,
3107 * group descriptor, sb, inode block, quota blocks, and
3108 * possibly selinux xattr blocks.
3109 */
3110 credits = 4 + EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) +
3111 EXT4_XATTR_TRANS_BLOCKS;
3112 } else {
3113 /*
3114 * Fast symlink. We have to add entry to directory
3115 * (EXT4_DATA_TRANS_BLOCKS + EXT4_INDEX_EXTRA_TRANS_BLOCKS),
3116 * allocate new inode (bitmap, group descriptor, inode block,
3117 * quota blocks, sb is already counted in previous macros).
3118 */
3119 credits = EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
3120 EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3;
3121 }
3122
3123 inode = ext4_new_inode_start_handle(dir, S_IFLNK|S_IRWXUGO,
3124 &dentry->d_name, 0, NULL,
3125 EXT4_HT_DIR, credits);
3126 handle = ext4_journal_current_handle();
3127 if (IS_ERR(inode)) {
3128 if (handle)
3129 ext4_journal_stop(handle);
3130 err = PTR_ERR(inode);
3131 goto err_free_sd;
3132 }
3133
3134 if (encryption_required) {
3135 struct qstr istr;
3136 struct ext4_str ostr;
3137
3138 istr.name = (const unsigned char *) symname;
3139 istr.len = len;
3140 ostr.name = sd->encrypted_path;
3141 ostr.len = disk_link.len;
3142 err = ext4_fname_usr_to_disk(inode, &istr, &ostr);
3143 if (err < 0)
3144 goto err_drop_inode;
3145 sd->len = cpu_to_le16(ostr.len);
3146 disk_link.name = (char *) sd;
3147 inode->i_op = &ext4_encrypted_symlink_inode_operations;
3148 }
3149
3150 if ((disk_link.len > EXT4_N_BLOCKS * 4)) {
3151 if (!encryption_required)
3152 inode->i_op = &ext4_symlink_inode_operations;
3153 inode_nohighmem(inode);
3154 ext4_set_aops(inode);
3155 /*
3156 * We cannot call page_symlink() with transaction started
3157 * because it calls into ext4_write_begin() which can wait
3158 * for transaction commit if we are running out of space
3159 * and thus we deadlock. So we have to stop transaction now
3160 * and restart it when symlink contents is written.
3161 *
3162 * To keep fs consistent in case of crash, we have to put inode
3163 * to orphan list in the mean time.
3164 */
3165 drop_nlink(inode);
3166 err = ext4_orphan_add(handle, inode);
3167 ext4_journal_stop(handle);
3168 handle = NULL;
3169 if (err)
3170 goto err_drop_inode;
3171 err = __page_symlink(inode, disk_link.name, disk_link.len, 1);
3172 if (err)
3173 goto err_drop_inode;
3174 /*
3175 * Now inode is being linked into dir (EXT4_DATA_TRANS_BLOCKS
3176 * + EXT4_INDEX_EXTRA_TRANS_BLOCKS), inode is also modified
3177 */
3178 handle = ext4_journal_start(dir, EXT4_HT_DIR,
3179 EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
3180 EXT4_INDEX_EXTRA_TRANS_BLOCKS + 1);
3181 if (IS_ERR(handle)) {
3182 err = PTR_ERR(handle);
3183 handle = NULL;
3184 goto err_drop_inode;
3185 }
3186 set_nlink(inode, 1);
3187 err = ext4_orphan_del(handle, inode);
3188 if (err)
3189 goto err_drop_inode;
3190 } else {
3191 /* clear the extent format for fast symlink */
3192 ext4_clear_inode_flag(inode, EXT4_INODE_EXTENTS);
3193 if (!encryption_required) {
3194 inode->i_op = &ext4_fast_symlink_inode_operations;
3195 inode->i_link = (char *)&EXT4_I(inode)->i_data;
3196 }
3197 memcpy((char *)&EXT4_I(inode)->i_data, disk_link.name,
3198 disk_link.len);
3199 inode->i_size = disk_link.len - 1;
3200 }
3201 EXT4_I(inode)->i_disksize = inode->i_size;
3202 err = ext4_add_nondir(handle, dentry, inode);
3203 if (!err && IS_DIRSYNC(dir))
3204 ext4_handle_sync(handle);
3205
3206 if (handle)
3207 ext4_journal_stop(handle);
3208 kfree(sd);
3209 return err;
3210 err_drop_inode:
3211 if (handle)
3212 ext4_journal_stop(handle);
3213 clear_nlink(inode);
3214 unlock_new_inode(inode);
3215 iput(inode);
3216 err_free_sd:
3217 kfree(sd);
3218 return err;
3219 }
3220
3221 static int ext4_link(struct dentry *old_dentry,
3222 struct inode *dir, struct dentry *dentry)
3223 {
3224 handle_t *handle;
3225 struct inode *inode = d_inode(old_dentry);
3226 int err, retries = 0;
3227
3228 if (inode->i_nlink >= EXT4_LINK_MAX)
3229 return -EMLINK;
3230 if (ext4_encrypted_inode(dir) &&
3231 !ext4_is_child_context_consistent_with_parent(dir, inode))
3232 return -EPERM;
3233 err = dquot_initialize(dir);
3234 if (err)
3235 return err;
3236
3237 retry:
3238 handle = ext4_journal_start(dir, EXT4_HT_DIR,
3239 (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
3240 EXT4_INDEX_EXTRA_TRANS_BLOCKS) + 1);
3241 if (IS_ERR(handle))
3242 return PTR_ERR(handle);
3243
3244 if (IS_DIRSYNC(dir))
3245 ext4_handle_sync(handle);
3246
3247 inode->i_ctime = ext4_current_time(inode);
3248 ext4_inc_count(handle, inode);
3249 ihold(inode);
3250
3251 err = ext4_add_entry(handle, dentry, inode);
3252 if (!err) {
3253 ext4_mark_inode_dirty(handle, inode);
3254 /* this can happen only for tmpfile being
3255 * linked the first time
3256 */
3257 if (inode->i_nlink == 1)
3258 ext4_orphan_del(handle, inode);
3259 d_instantiate(dentry, inode);
3260 } else {
3261 drop_nlink(inode);
3262 iput(inode);
3263 }
3264 ext4_journal_stop(handle);
3265 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
3266 goto retry;
3267 return err;
3268 }
3269
3270
3271 /*
3272 * Try to find buffer head where contains the parent block.
3273 * It should be the inode block if it is inlined or the 1st block
3274 * if it is a normal dir.
3275 */
3276 static struct buffer_head *ext4_get_first_dir_block(handle_t *handle,
3277 struct inode *inode,
3278 int *retval,
3279 struct ext4_dir_entry_2 **parent_de,
3280 int *inlined)
3281 {
3282 struct buffer_head *bh;
3283
3284 if (!ext4_has_inline_data(inode)) {
3285 bh = ext4_read_dirblock(inode, 0, EITHER);
3286 if (IS_ERR(bh)) {
3287 *retval = PTR_ERR(bh);
3288 return NULL;
3289 }
3290 *parent_de = ext4_next_entry(
3291 (struct ext4_dir_entry_2 *)bh->b_data,
3292 inode->i_sb->s_blocksize);
3293 return bh;
3294 }
3295
3296 *inlined = 1;
3297 return ext4_get_first_inline_block(inode, parent_de, retval);
3298 }
3299
3300 struct ext4_renament {
3301 struct inode *dir;
3302 struct dentry *dentry;
3303 struct inode *inode;
3304 bool is_dir;
3305 int dir_nlink_delta;
3306
3307 /* entry for "dentry" */
3308 struct buffer_head *bh;
3309 struct ext4_dir_entry_2 *de;
3310 int inlined;
3311
3312 /* entry for ".." in inode if it's a directory */
3313 struct buffer_head *dir_bh;
3314 struct ext4_dir_entry_2 *parent_de;
3315 int dir_inlined;
3316 };
3317
3318 static int ext4_rename_dir_prepare(handle_t *handle, struct ext4_renament *ent)
3319 {
3320 int retval;
3321
3322 ent->dir_bh = ext4_get_first_dir_block(handle, ent->inode,
3323 &retval, &ent->parent_de,
3324 &ent->dir_inlined);
3325 if (!ent->dir_bh)
3326 return retval;
3327 if (le32_to_cpu(ent->parent_de->inode) != ent->dir->i_ino)
3328 return -EFSCORRUPTED;
3329 BUFFER_TRACE(ent->dir_bh, "get_write_access");
3330 return ext4_journal_get_write_access(handle, ent->dir_bh);
3331 }
3332
3333 static int ext4_rename_dir_finish(handle_t *handle, struct ext4_renament *ent,
3334 unsigned dir_ino)
3335 {
3336 int retval;
3337
3338 ent->parent_de->inode = cpu_to_le32(dir_ino);
3339 BUFFER_TRACE(ent->dir_bh, "call ext4_handle_dirty_metadata");
3340 if (!ent->dir_inlined) {
3341 if (is_dx(ent->inode)) {
3342 retval = ext4_handle_dirty_dx_node(handle,
3343 ent->inode,
3344 ent->dir_bh);
3345 } else {
3346 retval = ext4_handle_dirty_dirent_node(handle,
3347 ent->inode,
3348 ent->dir_bh);
3349 }
3350 } else {
3351 retval = ext4_mark_inode_dirty(handle, ent->inode);
3352 }
3353 if (retval) {
3354 ext4_std_error(ent->dir->i_sb, retval);
3355 return retval;
3356 }
3357 return 0;
3358 }
3359
3360 static int ext4_setent(handle_t *handle, struct ext4_renament *ent,
3361 unsigned ino, unsigned file_type)
3362 {
3363 int retval;
3364
3365 BUFFER_TRACE(ent->bh, "get write access");
3366 retval = ext4_journal_get_write_access(handle, ent->bh);
3367 if (retval)
3368 return retval;
3369 ent->de->inode = cpu_to_le32(ino);
3370 if (ext4_has_feature_filetype(ent->dir->i_sb))
3371 ent->de->file_type = file_type;
3372 ent->dir->i_version++;
3373 ent->dir->i_ctime = ent->dir->i_mtime =
3374 ext4_current_time(ent->dir);
3375 ext4_mark_inode_dirty(handle, ent->dir);
3376 BUFFER_TRACE(ent->bh, "call ext4_handle_dirty_metadata");
3377 if (!ent->inlined) {
3378 retval = ext4_handle_dirty_dirent_node(handle,
3379 ent->dir, ent->bh);
3380 if (unlikely(retval)) {
3381 ext4_std_error(ent->dir->i_sb, retval);
3382 return retval;
3383 }
3384 }
3385 brelse(ent->bh);
3386 ent->bh = NULL;
3387
3388 return 0;
3389 }
3390
3391 static int ext4_find_delete_entry(handle_t *handle, struct inode *dir,
3392 const struct qstr *d_name)
3393 {
3394 int retval = -ENOENT;
3395 struct buffer_head *bh;
3396 struct ext4_dir_entry_2 *de;
3397
3398 bh = ext4_find_entry(dir, d_name, &de, NULL);
3399 if (IS_ERR(bh))
3400 return PTR_ERR(bh);
3401 if (bh) {
3402 retval = ext4_delete_entry(handle, dir, de, bh);
3403 brelse(bh);
3404 }
3405 return retval;
3406 }
3407
3408 static void ext4_rename_delete(handle_t *handle, struct ext4_renament *ent,
3409 int force_reread)
3410 {
3411 int retval;
3412 /*
3413 * ent->de could have moved from under us during htree split, so make
3414 * sure that we are deleting the right entry. We might also be pointing
3415 * to a stale entry in the unused part of ent->bh so just checking inum
3416 * and the name isn't enough.
3417 */
3418 if (le32_to_cpu(ent->de->inode) != ent->inode->i_ino ||
3419 ent->de->name_len != ent->dentry->d_name.len ||
3420 strncmp(ent->de->name, ent->dentry->d_name.name,
3421 ent->de->name_len) ||
3422 force_reread) {
3423 retval = ext4_find_delete_entry(handle, ent->dir,
3424 &ent->dentry->d_name);
3425 } else {
3426 retval = ext4_delete_entry(handle, ent->dir, ent->de, ent->bh);
3427 if (retval == -ENOENT) {
3428 retval = ext4_find_delete_entry(handle, ent->dir,
3429 &ent->dentry->d_name);
3430 }
3431 }
3432
3433 if (retval) {
3434 ext4_warning_inode(ent->dir,
3435 "Deleting old file: nlink %d, error=%d",
3436 ent->dir->i_nlink, retval);
3437 }
3438 }
3439
3440 static void ext4_update_dir_count(handle_t *handle, struct ext4_renament *ent)
3441 {
3442 if (ent->dir_nlink_delta) {
3443 if (ent->dir_nlink_delta == -1)
3444 ext4_dec_count(handle, ent->dir);
3445 else
3446 ext4_inc_count(handle, ent->dir);
3447 ext4_mark_inode_dirty(handle, ent->dir);
3448 }
3449 }
3450
3451 static struct inode *ext4_whiteout_for_rename(struct ext4_renament *ent,
3452 int credits, handle_t **h)
3453 {
3454 struct inode *wh;
3455 handle_t *handle;
3456 int retries = 0;
3457
3458 /*
3459 * for inode block, sb block, group summaries,
3460 * and inode bitmap
3461 */
3462 credits += (EXT4_MAXQUOTAS_TRANS_BLOCKS(ent->dir->i_sb) +
3463 EXT4_XATTR_TRANS_BLOCKS + 4);
3464 retry:
3465 wh = ext4_new_inode_start_handle(ent->dir, S_IFCHR | WHITEOUT_MODE,
3466 &ent->dentry->d_name, 0, NULL,
3467 EXT4_HT_DIR, credits);
3468
3469 handle = ext4_journal_current_handle();
3470 if (IS_ERR(wh)) {
3471 if (handle)
3472 ext4_journal_stop(handle);
3473 if (PTR_ERR(wh) == -ENOSPC &&
3474 ext4_should_retry_alloc(ent->dir->i_sb, &retries))
3475 goto retry;
3476 } else {
3477 *h = handle;
3478 init_special_inode(wh, wh->i_mode, WHITEOUT_DEV);
3479 wh->i_op = &ext4_special_inode_operations;
3480 }
3481 return wh;
3482 }
3483
3484 /*
3485 * Anybody can rename anything with this: the permission checks are left to the
3486 * higher-level routines.
3487 *
3488 * n.b. old_{dentry,inode) refers to the source dentry/inode
3489 * while new_{dentry,inode) refers to the destination dentry/inode
3490 * This comes from rename(const char *oldpath, const char *newpath)
3491 */
3492 static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
3493 struct inode *new_dir, struct dentry *new_dentry,
3494 unsigned int flags)
3495 {
3496 handle_t *handle = NULL;
3497 struct ext4_renament old = {
3498 .dir = old_dir,
3499 .dentry = old_dentry,
3500 .inode = d_inode(old_dentry),
3501 };
3502 struct ext4_renament new = {
3503 .dir = new_dir,
3504 .dentry = new_dentry,
3505 .inode = d_inode(new_dentry),
3506 };
3507 int force_reread;
3508 int retval;
3509 struct inode *whiteout = NULL;
3510 int credits;
3511 u8 old_file_type;
3512
3513 if ((ext4_encrypted_inode(old_dir) &&
3514 !ext4_has_encryption_key(old_dir)) ||
3515 (ext4_encrypted_inode(new_dir) &&
3516 !ext4_has_encryption_key(new_dir)))
3517 return -ENOKEY;
3518
3519 retval = dquot_initialize(old.dir);
3520 if (retval)
3521 return retval;
3522 retval = dquot_initialize(new.dir);
3523 if (retval)
3524 return retval;
3525
3526 /* Initialize quotas before so that eventual writes go
3527 * in separate transaction */
3528 if (new.inode) {
3529 retval = dquot_initialize(new.inode);
3530 if (retval)
3531 return retval;
3532 }
3533
3534 old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de, NULL);
3535 if (IS_ERR(old.bh))
3536 return PTR_ERR(old.bh);
3537 /*
3538 * Check for inode number is _not_ due to possible IO errors.
3539 * We might rmdir the source, keep it as pwd of some process
3540 * and merrily kill the link to whatever was created under the
3541 * same name. Goodbye sticky bit ;-<
3542 */
3543 retval = -ENOENT;
3544 if (!old.bh || le32_to_cpu(old.de->inode) != old.inode->i_ino)
3545 goto end_rename;
3546
3547 if ((old.dir != new.dir) &&
3548 ext4_encrypted_inode(new.dir) &&
3549 !ext4_is_child_context_consistent_with_parent(new.dir,
3550 old.inode)) {
3551 retval = -EPERM;
3552 goto end_rename;
3553 }
3554
3555 new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
3556 &new.de, &new.inlined);
3557 if (IS_ERR(new.bh)) {
3558 retval = PTR_ERR(new.bh);
3559 new.bh = NULL;
3560 goto end_rename;
3561 }
3562 if (new.bh) {
3563 if (!new.inode) {
3564 brelse(new.bh);
3565 new.bh = NULL;
3566 }
3567 }
3568 if (new.inode && !test_opt(new.dir->i_sb, NO_AUTO_DA_ALLOC))
3569 ext4_alloc_da_blocks(old.inode);
3570
3571 credits = (2 * EXT4_DATA_TRANS_BLOCKS(old.dir->i_sb) +
3572 EXT4_INDEX_EXTRA_TRANS_BLOCKS + 2);
3573 if (!(flags & RENAME_WHITEOUT)) {
3574 handle = ext4_journal_start(old.dir, EXT4_HT_DIR, credits);
3575 if (IS_ERR(handle)) {
3576 retval = PTR_ERR(handle);
3577 handle = NULL;
3578 goto end_rename;
3579 }
3580 } else {
3581 whiteout = ext4_whiteout_for_rename(&old, credits, &handle);
3582 if (IS_ERR(whiteout)) {
3583 retval = PTR_ERR(whiteout);
3584 whiteout = NULL;
3585 goto end_rename;
3586 }
3587 }
3588
3589 if (IS_DIRSYNC(old.dir) || IS_DIRSYNC(new.dir))
3590 ext4_handle_sync(handle);
3591
3592 if (S_ISDIR(old.inode->i_mode)) {
3593 if (new.inode) {
3594 retval = -ENOTEMPTY;
3595 if (!ext4_empty_dir(new.inode))
3596 goto end_rename;
3597 } else {
3598 retval = -EMLINK;
3599 if (new.dir != old.dir && EXT4_DIR_LINK_MAX(new.dir))
3600 goto end_rename;
3601 }
3602 retval = ext4_rename_dir_prepare(handle, &old);
3603 if (retval)
3604 goto end_rename;
3605 }
3606 /*
3607 * If we're renaming a file within an inline_data dir and adding or
3608 * setting the new dirent causes a conversion from inline_data to
3609 * extents/blockmap, we need to force the dirent delete code to
3610 * re-read the directory, or else we end up trying to delete a dirent
3611 * from what is now the extent tree root (or a block map).
3612 */
3613 force_reread = (new.dir->i_ino == old.dir->i_ino &&
3614 ext4_test_inode_flag(new.dir, EXT4_INODE_INLINE_DATA));
3615
3616 old_file_type = old.de->file_type;
3617 if (whiteout) {
3618 /*
3619 * Do this before adding a new entry, so the old entry is sure
3620 * to be still pointing to the valid old entry.
3621 */
3622 retval = ext4_setent(handle, &old, whiteout->i_ino,
3623 EXT4_FT_CHRDEV);
3624 if (retval)
3625 goto end_rename;
3626 ext4_mark_inode_dirty(handle, whiteout);
3627 }
3628 if (!new.bh) {
3629 retval = ext4_add_entry(handle, new.dentry, old.inode);
3630 if (retval)
3631 goto end_rename;
3632 } else {
3633 retval = ext4_setent(handle, &new,
3634 old.inode->i_ino, old_file_type);
3635 if (retval)
3636 goto end_rename;
3637 }
3638 if (force_reread)
3639 force_reread = !ext4_test_inode_flag(new.dir,
3640 EXT4_INODE_INLINE_DATA);
3641
3642 /*
3643 * Like most other Unix systems, set the ctime for inodes on a
3644 * rename.
3645 */
3646 old.inode->i_ctime = ext4_current_time(old.inode);
3647 ext4_mark_inode_dirty(handle, old.inode);
3648
3649 if (!whiteout) {
3650 /*
3651 * ok, that's it
3652 */
3653 ext4_rename_delete(handle, &old, force_reread);
3654 }
3655
3656 if (new.inode) {
3657 ext4_dec_count(handle, new.inode);
3658 new.inode->i_ctime = ext4_current_time(new.inode);
3659 }
3660 old.dir->i_ctime = old.dir->i_mtime = ext4_current_time(old.dir);
3661 ext4_update_dx_flag(old.dir);
3662 if (old.dir_bh) {
3663 retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
3664 if (retval)
3665 goto end_rename;
3666
3667 ext4_dec_count(handle, old.dir);
3668 if (new.inode) {
3669 /* checked ext4_empty_dir above, can't have another
3670 * parent, ext4_dec_count() won't work for many-linked
3671 * dirs */
3672 clear_nlink(new.inode);
3673 } else {
3674 ext4_inc_count(handle, new.dir);
3675 ext4_update_dx_flag(new.dir);
3676 ext4_mark_inode_dirty(handle, new.dir);
3677 }
3678 }
3679 ext4_mark_inode_dirty(handle, old.dir);
3680 if (new.inode) {
3681 ext4_mark_inode_dirty(handle, new.inode);
3682 if (!new.inode->i_nlink)
3683 ext4_orphan_add(handle, new.inode);
3684 }
3685 retval = 0;
3686
3687 end_rename:
3688 brelse(old.dir_bh);
3689 brelse(old.bh);
3690 brelse(new.bh);
3691 if (whiteout) {
3692 if (retval)
3693 drop_nlink(whiteout);
3694 unlock_new_inode(whiteout);
3695 iput(whiteout);
3696 }
3697 if (handle)
3698 ext4_journal_stop(handle);
3699 return retval;
3700 }
3701
3702 static int ext4_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
3703 struct inode *new_dir, struct dentry *new_dentry)
3704 {
3705 handle_t *handle = NULL;
3706 struct ext4_renament old = {
3707 .dir = old_dir,
3708 .dentry = old_dentry,
3709 .inode = d_inode(old_dentry),
3710 };
3711 struct ext4_renament new = {
3712 .dir = new_dir,
3713 .dentry = new_dentry,
3714 .inode = d_inode(new_dentry),
3715 };
3716 u8 new_file_type;
3717 int retval;
3718
3719 if ((ext4_encrypted_inode(old_dir) &&
3720 !ext4_has_encryption_key(old_dir)) ||
3721 (ext4_encrypted_inode(new_dir) &&
3722 !ext4_has_encryption_key(new_dir)))
3723 return -ENOKEY;
3724
3725 if ((ext4_encrypted_inode(old_dir) ||
3726 ext4_encrypted_inode(new_dir)) &&
3727 (old_dir != new_dir) &&
3728 (!ext4_is_child_context_consistent_with_parent(new_dir,
3729 old.inode) ||
3730 !ext4_is_child_context_consistent_with_parent(old_dir,
3731 new.inode)))
3732 return -EPERM;
3733
3734 retval = dquot_initialize(old.dir);
3735 if (retval)
3736 return retval;
3737 retval = dquot_initialize(new.dir);
3738 if (retval)
3739 return retval;
3740
3741 old.bh = ext4_find_entry(old.dir, &old.dentry->d_name,
3742 &old.de, &old.inlined);
3743 if (IS_ERR(old.bh))
3744 return PTR_ERR(old.bh);
3745 /*
3746 * Check for inode number is _not_ due to possible IO errors.
3747 * We might rmdir the source, keep it as pwd of some process
3748 * and merrily kill the link to whatever was created under the
3749 * same name. Goodbye sticky bit ;-<
3750 */
3751 retval = -ENOENT;
3752 if (!old.bh || le32_to_cpu(old.de->inode) != old.inode->i_ino)
3753 goto end_rename;
3754
3755 new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
3756 &new.de, &new.inlined);
3757 if (IS_ERR(new.bh)) {
3758 retval = PTR_ERR(new.bh);
3759 new.bh = NULL;
3760 goto end_rename;
3761 }
3762
3763 /* RENAME_EXCHANGE case: old *and* new must both exist */
3764 if (!new.bh || le32_to_cpu(new.de->inode) != new.inode->i_ino)
3765 goto end_rename;
3766
3767 handle = ext4_journal_start(old.dir, EXT4_HT_DIR,
3768 (2 * EXT4_DATA_TRANS_BLOCKS(old.dir->i_sb) +
3769 2 * EXT4_INDEX_EXTRA_TRANS_BLOCKS + 2));
3770 if (IS_ERR(handle)) {
3771 retval = PTR_ERR(handle);
3772 handle = NULL;
3773 goto end_rename;
3774 }
3775
3776 if (IS_DIRSYNC(old.dir) || IS_DIRSYNC(new.dir))
3777 ext4_handle_sync(handle);
3778
3779 if (S_ISDIR(old.inode->i_mode)) {
3780 old.is_dir = true;
3781 retval = ext4_rename_dir_prepare(handle, &old);
3782 if (retval)
3783 goto end_rename;
3784 }
3785 if (S_ISDIR(new.inode->i_mode)) {
3786 new.is_dir = true;
3787 retval = ext4_rename_dir_prepare(handle, &new);
3788 if (retval)
3789 goto end_rename;
3790 }
3791
3792 /*
3793 * Other than the special case of overwriting a directory, parents'
3794 * nlink only needs to be modified if this is a cross directory rename.
3795 */
3796 if (old.dir != new.dir && old.is_dir != new.is_dir) {
3797 old.dir_nlink_delta = old.is_dir ? -1 : 1;
3798 new.dir_nlink_delta = -old.dir_nlink_delta;
3799 retval = -EMLINK;
3800 if ((old.dir_nlink_delta > 0 && EXT4_DIR_LINK_MAX(old.dir)) ||
3801 (new.dir_nlink_delta > 0 && EXT4_DIR_LINK_MAX(new.dir)))
3802 goto end_rename;
3803 }
3804
3805 new_file_type = new.de->file_type;
3806 retval = ext4_setent(handle, &new, old.inode->i_ino, old.de->file_type);
3807 if (retval)
3808 goto end_rename;
3809
3810 retval = ext4_setent(handle, &old, new.inode->i_ino, new_file_type);
3811 if (retval)
3812 goto end_rename;
3813
3814 /*
3815 * Like most other Unix systems, set the ctime for inodes on a
3816 * rename.
3817 */
3818 old.inode->i_ctime = ext4_current_time(old.inode);
3819 new.inode->i_ctime = ext4_current_time(new.inode);
3820 ext4_mark_inode_dirty(handle, old.inode);
3821 ext4_mark_inode_dirty(handle, new.inode);
3822
3823 if (old.dir_bh) {
3824 retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
3825 if (retval)
3826 goto end_rename;
3827 }
3828 if (new.dir_bh) {
3829 retval = ext4_rename_dir_finish(handle, &new, old.dir->i_ino);
3830 if (retval)
3831 goto end_rename;
3832 }
3833 ext4_update_dir_count(handle, &old);
3834 ext4_update_dir_count(handle, &new);
3835 retval = 0;
3836
3837 end_rename:
3838 brelse(old.dir_bh);
3839 brelse(new.dir_bh);
3840 brelse(old.bh);
3841 brelse(new.bh);
3842 if (handle)
3843 ext4_journal_stop(handle);
3844 return retval;
3845 }
3846
3847 static int ext4_rename2(struct inode *old_dir, struct dentry *old_dentry,
3848 struct inode *new_dir, struct dentry *new_dentry,
3849 unsigned int flags)
3850 {
3851 if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
3852 return -EINVAL;
3853
3854 if (flags & RENAME_EXCHANGE) {
3855 return ext4_cross_rename(old_dir, old_dentry,
3856 new_dir, new_dentry);
3857 }
3858
3859 return ext4_rename(old_dir, old_dentry, new_dir, new_dentry, flags);
3860 }
3861
3862 /*
3863 * directories can handle most operations...
3864 */
3865 const struct inode_operations ext4_dir_inode_operations = {
3866 .create = ext4_create,
3867 .lookup = ext4_lookup,
3868 .link = ext4_link,
3869 .unlink = ext4_unlink,
3870 .symlink = ext4_symlink,
3871 .mkdir = ext4_mkdir,
3872 .rmdir = ext4_rmdir,
3873 .mknod = ext4_mknod,
3874 .tmpfile = ext4_tmpfile,
3875 .rename2 = ext4_rename2,
3876 .setattr = ext4_setattr,
3877 .setxattr = generic_setxattr,
3878 .getxattr = generic_getxattr,
3879 .listxattr = ext4_listxattr,
3880 .removexattr = generic_removexattr,
3881 .get_acl = ext4_get_acl,
3882 .set_acl = ext4_set_acl,
3883 .fiemap = ext4_fiemap,
3884 };
3885
3886 const struct inode_operations ext4_special_inode_operations = {
3887 .setattr = ext4_setattr,
3888 .setxattr = generic_setxattr,
3889 .getxattr = generic_getxattr,
3890 .listxattr = ext4_listxattr,
3891 .removexattr = generic_removexattr,
3892 .get_acl = ext4_get_acl,
3893 .set_acl = ext4_set_acl,
3894 };
Linux with added FPC-III support