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