Line data Source code
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 <linux/unicode.h>
39 : #include "ext4.h"
40 : #include "ext4_jbd2.h"
41 :
42 : #include "xattr.h"
43 : #include "acl.h"
44 :
45 : #include <trace/events/ext4.h>
46 : /*
47 : * define how far ahead to read directories while searching them.
48 : */
49 : #define NAMEI_RA_CHUNKS 2
50 : #define NAMEI_RA_BLOCKS 4
51 : #define NAMEI_RA_SIZE (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)
52 :
53 388124 : static struct buffer_head *ext4_append(handle_t *handle,
54 : struct inode *inode,
55 : ext4_lblk_t *block)
56 : {
57 388124 : struct ext4_map_blocks map;
58 388124 : struct buffer_head *bh;
59 388124 : int err;
60 :
61 388124 : if (unlikely(EXT4_SB(inode->i_sb)->s_max_dir_size_kb &&
62 : ((inode->i_size >> 10) >=
63 : EXT4_SB(inode->i_sb)->s_max_dir_size_kb)))
64 : return ERR_PTR(-ENOSPC);
65 :
66 388124 : *block = inode->i_size >> inode->i_sb->s_blocksize_bits;
67 388124 : map.m_lblk = *block;
68 388124 : map.m_len = 1;
69 :
70 : /*
71 : * We're appending new directory block. Make sure the block is not
72 : * allocated yet, otherwise we will end up corrupting the
73 : * directory.
74 : */
75 388124 : err = ext4_map_blocks(NULL, inode, &map, 0);
76 388047 : if (err < 0)
77 0 : return ERR_PTR(err);
78 388047 : if (err) {
79 0 : EXT4_ERROR_INODE(inode, "Logical block already allocated");
80 0 : return ERR_PTR(-EFSCORRUPTED);
81 : }
82 :
83 388047 : bh = ext4_bread(handle, inode, *block, EXT4_GET_BLOCKS_CREATE);
84 388217 : if (IS_ERR(bh))
85 : return bh;
86 374872 : inode->i_size += inode->i_sb->s_blocksize;
87 374872 : EXT4_I(inode)->i_disksize = inode->i_size;
88 374872 : err = ext4_mark_inode_dirty(handle, inode);
89 374843 : if (err)
90 0 : goto out;
91 374843 : BUFFER_TRACE(bh, "get_write_access");
92 374843 : err = ext4_journal_get_write_access(handle, inode->i_sb, bh,
93 : EXT4_JTR_NONE);
94 374840 : if (err)
95 0 : goto out;
96 : return bh;
97 :
98 0 : out:
99 0 : brelse(bh);
100 0 : ext4_std_error(inode->i_sb, err);
101 0 : return ERR_PTR(err);
102 : }
103 :
104 : static int ext4_dx_csum_verify(struct inode *inode,
105 : struct ext4_dir_entry *dirent);
106 :
107 : /*
108 : * Hints to ext4_read_dirblock regarding whether we expect a directory
109 : * block being read to be an index block, or a block containing
110 : * directory entries (and if the latter, whether it was found via a
111 : * logical block in an htree index block). This is used to control
112 : * what sort of sanity checkinig ext4_read_dirblock() will do on the
113 : * directory block read from the storage device. EITHER will means
114 : * the caller doesn't know what kind of directory block will be read,
115 : * so no specific verification will be done.
116 : */
117 : typedef enum {
118 : EITHER, INDEX, DIRENT, DIRENT_HTREE
119 : } dirblock_type_t;
120 :
121 : #define ext4_read_dirblock(inode, block, type) \
122 : __ext4_read_dirblock((inode), (block), (type), __func__, __LINE__)
123 :
124 15330813 : static struct buffer_head *__ext4_read_dirblock(struct inode *inode,
125 : ext4_lblk_t block,
126 : dirblock_type_t type,
127 : const char *func,
128 : unsigned int line)
129 : {
130 15330813 : struct buffer_head *bh;
131 15330813 : struct ext4_dir_entry *dirent;
132 15330813 : int is_dx_block = 0;
133 :
134 15330813 : if (block >= inode->i_size >> inode->i_blkbits) {
135 0 : ext4_error_inode(inode, func, line, block,
136 : "Attempting to read directory block (%u) that is past i_size (%llu)",
137 : block, inode->i_size);
138 0 : return ERR_PTR(-EFSCORRUPTED);
139 : }
140 :
141 15330813 : if (ext4_simulate_fail(inode->i_sb, EXT4_SIM_DIRBLOCK_EIO))
142 : bh = ERR_PTR(-EIO);
143 : else
144 15330813 : bh = ext4_bread(NULL, inode, block, 0);
145 15342588 : if (IS_ERR(bh)) {
146 1 : __ext4_warning(inode->i_sb, func, line,
147 : "inode #%lu: lblock %lu: comm %s: "
148 : "error %ld reading directory block",
149 : inode->i_ino, (unsigned long)block,
150 1 : current->comm, PTR_ERR(bh));
151 :
152 1 : return bh;
153 : }
154 15342587 : if (!bh && (type == INDEX || type == DIRENT_HTREE)) {
155 0 : ext4_error_inode(inode, func, line, block,
156 : "Directory hole found for htree %s block",
157 : (type == INDEX) ? "index" : "leaf");
158 0 : return ERR_PTR(-EFSCORRUPTED);
159 : }
160 15342587 : if (!bh)
161 : return NULL;
162 15342587 : dirent = (struct ext4_dir_entry *) bh->b_data;
163 : /* Determine whether or not we have an index block */
164 15342587 : if (is_dx(inode)) {
165 13794269 : if (block == 0)
166 : is_dx_block = 1;
167 7569857 : else if (ext4_rec_len_from_disk(dirent->rec_len,
168 7569857 : inode->i_sb->s_blocksize) ==
169 : inode->i_sb->s_blocksize)
170 1369843 : is_dx_block = 1;
171 : }
172 15342587 : if (!is_dx_block && type == INDEX) {
173 0 : ext4_error_inode(inode, func, line, block,
174 : "directory leaf block found instead of index block");
175 0 : brelse(bh);
176 0 : return ERR_PTR(-EFSCORRUPTED);
177 : }
178 30682095 : if (!ext4_has_metadata_csum(inode->i_sb) ||
179 : buffer_verified(bh))
180 : return bh;
181 :
182 : /*
183 : * An empty leaf block can get mistaken for a index block; for
184 : * this reason, we can only check the index checksum when the
185 : * caller is sure it should be an index block.
186 : */
187 62282 : if (is_dx_block && type == INDEX) {
188 707 : if (ext4_dx_csum_verify(inode, dirent) &&
189 705 : !ext4_simulate_fail(inode->i_sb, EXT4_SIM_DIRBLOCK_CRC))
190 705 : set_buffer_verified(bh);
191 : else {
192 2 : ext4_error_inode_err(inode, func, line, block,
193 : EFSBADCRC,
194 : "Directory index failed checksum");
195 2 : brelse(bh);
196 2 : return ERR_PTR(-EFSBADCRC);
197 : }
198 : }
199 62280 : if (!is_dx_block) {
200 61575 : if (ext4_dirblock_csum_verify(inode, bh) &&
201 61573 : !ext4_simulate_fail(inode->i_sb, EXT4_SIM_DIRBLOCK_CRC))
202 61573 : set_buffer_verified(bh);
203 : else {
204 0 : ext4_error_inode_err(inode, func, line, block,
205 : EFSBADCRC,
206 : "Directory block failed checksum");
207 0 : brelse(bh);
208 0 : return ERR_PTR(-EFSBADCRC);
209 : }
210 : }
211 : return bh;
212 : }
213 :
214 : #ifdef DX_DEBUG
215 : #define dxtrace(command) command
216 : #else
217 : #define dxtrace(command)
218 : #endif
219 :
220 : struct fake_dirent
221 : {
222 : __le32 inode;
223 : __le16 rec_len;
224 : u8 name_len;
225 : u8 file_type;
226 : };
227 :
228 : struct dx_countlimit
229 : {
230 : __le16 limit;
231 : __le16 count;
232 : };
233 :
234 : struct dx_entry
235 : {
236 : __le32 hash;
237 : __le32 block;
238 : };
239 :
240 : /*
241 : * dx_root_info is laid out so that if it should somehow get overlaid by a
242 : * dirent the two low bits of the hash version will be zero. Therefore, the
243 : * hash version mod 4 should never be 0. Sincerely, the paranoia department.
244 : */
245 :
246 : struct dx_root
247 : {
248 : struct fake_dirent dot;
249 : char dot_name[4];
250 : struct fake_dirent dotdot;
251 : char dotdot_name[4];
252 : struct dx_root_info
253 : {
254 : __le32 reserved_zero;
255 : u8 hash_version;
256 : u8 info_length; /* 8 */
257 : u8 indirect_levels;
258 : u8 unused_flags;
259 : }
260 : info;
261 : struct dx_entry entries[];
262 : };
263 :
264 : struct dx_node
265 : {
266 : struct fake_dirent fake;
267 : struct dx_entry entries[];
268 : };
269 :
270 :
271 : struct dx_frame
272 : {
273 : struct buffer_head *bh;
274 : struct dx_entry *entries;
275 : struct dx_entry *at;
276 : };
277 :
278 : struct dx_map_entry
279 : {
280 : u32 hash;
281 : u16 offs;
282 : u16 size;
283 : };
284 :
285 : /*
286 : * This goes at the end of each htree block.
287 : */
288 : struct dx_tail {
289 : u32 dt_reserved;
290 : __le32 dt_checksum; /* crc32c(uuid+inum+dirblock) */
291 : };
292 :
293 : static inline ext4_lblk_t dx_get_block(struct dx_entry *entry);
294 : static void dx_set_block(struct dx_entry *entry, ext4_lblk_t value);
295 : static inline unsigned dx_get_hash(struct dx_entry *entry);
296 : static void dx_set_hash(struct dx_entry *entry, unsigned value);
297 : static unsigned dx_get_count(struct dx_entry *entries);
298 : static unsigned dx_get_limit(struct dx_entry *entries);
299 : static void dx_set_count(struct dx_entry *entries, unsigned value);
300 : static void dx_set_limit(struct dx_entry *entries, unsigned value);
301 : static unsigned dx_root_limit(struct inode *dir, unsigned infosize);
302 : static unsigned dx_node_limit(struct inode *dir);
303 : static struct dx_frame *dx_probe(struct ext4_filename *fname,
304 : struct inode *dir,
305 : struct dx_hash_info *hinfo,
306 : struct dx_frame *frame);
307 : static void dx_release(struct dx_frame *frames);
308 : static int dx_make_map(struct inode *dir, struct buffer_head *bh,
309 : struct dx_hash_info *hinfo,
310 : struct dx_map_entry *map_tail);
311 : static void dx_sort_map(struct dx_map_entry *map, unsigned count);
312 : static struct ext4_dir_entry_2 *dx_move_dirents(struct inode *dir, char *from,
313 : char *to, struct dx_map_entry *offsets,
314 : int count, unsigned int blocksize);
315 : static struct ext4_dir_entry_2 *dx_pack_dirents(struct inode *dir, char *base,
316 : unsigned int blocksize);
317 : static void dx_insert_block(struct dx_frame *frame,
318 : u32 hash, ext4_lblk_t block);
319 : static int ext4_htree_next_block(struct inode *dir, __u32 hash,
320 : struct dx_frame *frame,
321 : struct dx_frame *frames,
322 : __u32 *start_hash);
323 : static struct buffer_head * ext4_dx_find_entry(struct inode *dir,
324 : struct ext4_filename *fname,
325 : struct ext4_dir_entry_2 **res_dir);
326 : static int ext4_dx_add_entry(handle_t *handle, struct ext4_filename *fname,
327 : struct inode *dir, struct inode *inode);
328 :
329 : /* checksumming functions */
330 402854 : void ext4_initialize_dirent_tail(struct buffer_head *bh,
331 : unsigned int blocksize)
332 : {
333 402854 : struct ext4_dir_entry_tail *t = EXT4_DIRENT_TAIL(bh->b_data, blocksize);
334 :
335 402854 : memset(t, 0, sizeof(struct ext4_dir_entry_tail));
336 402854 : t->det_rec_len = ext4_rec_len_to_disk(
337 : sizeof(struct ext4_dir_entry_tail), blocksize);
338 402854 : t->det_reserved_ft = EXT4_FT_DIR_CSUM;
339 402854 : }
340 :
341 : /* Walk through a dirent block to find a checksum "dirent" at the tail */
342 : static struct ext4_dir_entry_tail *get_dirent_tail(struct inode *inode,
343 : struct buffer_head *bh)
344 : {
345 5626159 : struct ext4_dir_entry_tail *t;
346 :
347 : #ifdef PARANOID
348 : struct ext4_dir_entry *d, *top;
349 :
350 : d = (struct ext4_dir_entry *)bh->b_data;
351 : top = (struct ext4_dir_entry *)(bh->b_data +
352 : (EXT4_BLOCK_SIZE(inode->i_sb) -
353 : sizeof(struct ext4_dir_entry_tail)));
354 : while (d < top && d->rec_len)
355 : d = (struct ext4_dir_entry *)(((void *)d) +
356 : le16_to_cpu(d->rec_len));
357 :
358 : if (d != top)
359 : return NULL;
360 :
361 : t = (struct ext4_dir_entry_tail *)d;
362 : #else
363 5626159 : t = EXT4_DIRENT_TAIL(bh->b_data, EXT4_BLOCK_SIZE(inode->i_sb));
364 : #endif
365 :
366 5626159 : if (t->det_reserved_zero1 ||
367 : le16_to_cpu(t->det_rec_len) != sizeof(struct ext4_dir_entry_tail) ||
368 5626159 : t->det_reserved_zero2 ||
369 : t->det_reserved_ft != EXT4_FT_DIR_CSUM)
370 : return NULL;
371 :
372 : return t;
373 : }
374 :
375 : static __le32 ext4_dirblock_csum(struct inode *inode, void *dirent, int size)
376 : {
377 5626029 : struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
378 5626029 : struct ext4_inode_info *ei = EXT4_I(inode);
379 5626029 : __u32 csum;
380 :
381 5626029 : csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)dirent, size);
382 5621719 : return cpu_to_le32(csum);
383 : }
384 :
385 : #define warn_no_space_for_csum(inode) \
386 : __warn_no_space_for_csum((inode), __func__, __LINE__)
387 :
388 : static void __warn_no_space_for_csum(struct inode *inode, const char *func,
389 : unsigned int line)
390 : {
391 130 : __ext4_warning_inode(inode, func, line,
392 : "No space for directory leaf checksum. Please run e2fsck -D.");
393 : }
394 :
395 63367 : int ext4_dirblock_csum_verify(struct inode *inode, struct buffer_head *bh)
396 : {
397 63367 : struct ext4_dir_entry_tail *t;
398 :
399 63367 : if (!ext4_has_metadata_csum(inode->i_sb))
400 : return 1;
401 :
402 63318 : t = get_dirent_tail(inode, bh);
403 63188 : if (!t) {
404 130 : warn_no_space_for_csum(inode);
405 130 : return 0;
406 : }
407 :
408 63187 : if (t->det_checksum != ext4_dirblock_csum(inode, bh->b_data,
409 63188 : (char *)t - bh->b_data))
410 0 : return 0;
411 :
412 : return 1;
413 : }
414 :
415 5564047 : static void ext4_dirblock_csum_set(struct inode *inode,
416 : struct buffer_head *bh)
417 : {
418 5564047 : struct ext4_dir_entry_tail *t;
419 :
420 5564047 : if (!ext4_has_metadata_csum(inode->i_sb))
421 : return;
422 :
423 5562841 : t = get_dirent_tail(inode, bh);
424 5562841 : if (!t) {
425 0 : warn_no_space_for_csum(inode);
426 0 : return;
427 : }
428 :
429 5558532 : t->det_checksum = ext4_dirblock_csum(inode, bh->b_data,
430 5562841 : (char *)t - bh->b_data);
431 : }
432 :
433 5564333 : int ext4_handle_dirty_dirblock(handle_t *handle,
434 : struct inode *inode,
435 : struct buffer_head *bh)
436 : {
437 5564333 : ext4_dirblock_csum_set(inode, bh);
438 5559564 : return ext4_handle_dirty_metadata(handle, inode, bh);
439 : }
440 :
441 73091 : static struct dx_countlimit *get_dx_countlimit(struct inode *inode,
442 : struct ext4_dir_entry *dirent,
443 : int *offset)
444 : {
445 73091 : struct ext4_dir_entry *dp;
446 73091 : struct dx_root_info *root;
447 73091 : int count_offset;
448 :
449 73091 : if (le16_to_cpu(dirent->rec_len) == EXT4_BLOCK_SIZE(inode->i_sb))
450 : count_offset = 8;
451 50475 : else if (le16_to_cpu(dirent->rec_len) == 12) {
452 50473 : dp = (struct ext4_dir_entry *)(((void *)dirent) + 12);
453 50473 : if (le16_to_cpu(dp->rec_len) !=
454 50473 : EXT4_BLOCK_SIZE(inode->i_sb) - 12)
455 : return NULL;
456 50473 : root = (struct dx_root_info *)(((void *)dp + 12));
457 50473 : if (root->reserved_zero ||
458 50473 : root->info_length != sizeof(struct dx_root_info))
459 : return NULL;
460 : count_offset = 32;
461 : } else
462 : return NULL;
463 :
464 73089 : if (offset)
465 73089 : *offset = count_offset;
466 73089 : return (struct dx_countlimit *)(((void *)dirent) + count_offset);
467 : }
468 :
469 73089 : static __le32 ext4_dx_csum(struct inode *inode, struct ext4_dir_entry *dirent,
470 : int count_offset, int count, struct dx_tail *t)
471 : {
472 73089 : struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
473 73089 : struct ext4_inode_info *ei = EXT4_I(inode);
474 73089 : __u32 csum;
475 73089 : int size;
476 73089 : __u32 dummy_csum = 0;
477 73089 : int offset = offsetof(struct dx_tail, dt_checksum);
478 :
479 73089 : size = count_offset + (count * sizeof(struct dx_entry));
480 73089 : csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)dirent, size);
481 73089 : csum = ext4_chksum(sbi, csum, (__u8 *)t, offset);
482 73089 : csum = ext4_chksum(sbi, csum, (__u8 *)&dummy_csum, sizeof(dummy_csum));
483 :
484 73089 : return cpu_to_le32(csum);
485 : }
486 :
487 707 : static int ext4_dx_csum_verify(struct inode *inode,
488 : struct ext4_dir_entry *dirent)
489 : {
490 707 : struct dx_countlimit *c;
491 707 : struct dx_tail *t;
492 707 : int count_offset, limit, count;
493 :
494 707 : if (!ext4_has_metadata_csum(inode->i_sb))
495 : return 1;
496 :
497 707 : c = get_dx_countlimit(inode, dirent, &count_offset);
498 707 : if (!c) {
499 2 : EXT4_ERROR_INODE(inode, "dir seems corrupt? Run e2fsck -D.");
500 2 : return 0;
501 : }
502 705 : limit = le16_to_cpu(c->limit);
503 705 : count = le16_to_cpu(c->count);
504 705 : if (count_offset + (limit * sizeof(struct dx_entry)) >
505 705 : EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) {
506 0 : warn_no_space_for_csum(inode);
507 0 : return 0;
508 : }
509 705 : t = (struct dx_tail *)(((struct dx_entry *)c) + limit);
510 :
511 705 : if (t->dt_checksum != ext4_dx_csum(inode, dirent, count_offset,
512 : count, t))
513 0 : return 0;
514 : return 1;
515 : }
516 :
517 72384 : static void ext4_dx_csum_set(struct inode *inode, struct ext4_dir_entry *dirent)
518 : {
519 72384 : struct dx_countlimit *c;
520 72384 : struct dx_tail *t;
521 72384 : int count_offset, limit, count;
522 :
523 72384 : if (!ext4_has_metadata_csum(inode->i_sb))
524 0 : return;
525 :
526 72384 : c = get_dx_countlimit(inode, dirent, &count_offset);
527 72384 : if (!c) {
528 0 : EXT4_ERROR_INODE(inode, "dir seems corrupt? Run e2fsck -D.");
529 0 : return;
530 : }
531 72384 : limit = le16_to_cpu(c->limit);
532 72384 : count = le16_to_cpu(c->count);
533 72384 : if (count_offset + (limit * sizeof(struct dx_entry)) >
534 72384 : EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) {
535 0 : warn_no_space_for_csum(inode);
536 0 : return;
537 : }
538 72384 : t = (struct dx_tail *)(((struct dx_entry *)c) + limit);
539 :
540 72384 : t->dt_checksum = ext4_dx_csum(inode, dirent, count_offset, count, t);
541 : }
542 :
543 72384 : static inline int ext4_handle_dirty_dx_node(handle_t *handle,
544 : struct inode *inode,
545 : struct buffer_head *bh)
546 : {
547 72384 : ext4_dx_csum_set(inode, (struct ext4_dir_entry *)bh->b_data);
548 72384 : return ext4_handle_dirty_metadata(handle, inode, bh);
549 : }
550 :
551 : /*
552 : * p is at least 6 bytes before the end of page
553 : */
554 : static inline struct ext4_dir_entry_2 *
555 : ext4_next_entry(struct ext4_dir_entry_2 *p, unsigned long blocksize)
556 : {
557 224279184 : return (struct ext4_dir_entry_2 *)((char *)p +
558 224279184 : ext4_rec_len_from_disk(p->rec_len, blocksize));
559 : }
560 :
561 : /*
562 : * Future: use high four bits of block for coalesce-on-delete flags
563 : * Mask them off for now.
564 : */
565 :
566 : static inline ext4_lblk_t dx_get_block(struct dx_entry *entry)
567 : {
568 13723241 : return le32_to_cpu(entry->block) & 0x0fffffff;
569 : }
570 :
571 : static inline void dx_set_block(struct dx_entry *entry, ext4_lblk_t value)
572 : {
573 30415 : entry->block = cpu_to_le32(value);
574 : }
575 :
576 : static inline unsigned dx_get_hash(struct dx_entry *entry)
577 : {
578 30053134 : return le32_to_cpu(entry->hash);
579 : }
580 :
581 : static inline void dx_set_hash(struct dx_entry *entry, unsigned value)
582 : {
583 29130 : entry->hash = cpu_to_le32(value);
584 : }
585 :
586 : static inline unsigned dx_get_count(struct dx_entry *entries)
587 : {
588 10434931 : return le16_to_cpu(((struct dx_countlimit *) entries)->count);
589 : }
590 :
591 : static inline unsigned dx_get_limit(struct dx_entry *entries)
592 : {
593 15146042 : return le16_to_cpu(((struct dx_countlimit *) entries)->limit);
594 : }
595 :
596 : static inline void dx_set_count(struct dx_entry *entries, unsigned value)
597 : {
598 30612 : ((struct dx_countlimit *) entries)->count = cpu_to_le16(value);
599 : }
600 :
601 : static inline void dx_set_limit(struct dx_entry *entries, unsigned value)
602 : {
603 1482 : ((struct dx_countlimit *) entries)->limit = cpu_to_le16(value);
604 : }
605 :
606 6174214 : static inline unsigned dx_root_limit(struct inode *dir, unsigned infosize)
607 : {
608 6174214 : unsigned int entry_space = dir->i_sb->s_blocksize -
609 6174214 : ext4_dir_rec_len(1, NULL) -
610 : ext4_dir_rec_len(2, NULL) - infosize;
611 :
612 6174214 : if (ext4_has_metadata_csum(dir->i_sb))
613 6173020 : entry_space -= sizeof(struct dx_tail);
614 6173651 : return entry_space / sizeof(struct dx_entry);
615 : }
616 :
617 1370026 : static inline unsigned dx_node_limit(struct inode *dir)
618 : {
619 1370026 : unsigned int entry_space = dir->i_sb->s_blocksize -
620 : ext4_dir_rec_len(0, dir);
621 :
622 1370026 : if (ext4_has_metadata_csum(dir->i_sb))
623 1370026 : entry_space -= sizeof(struct dx_tail);
624 1370026 : return entry_space / sizeof(struct dx_entry);
625 : }
626 :
627 : /*
628 : * Debug
629 : */
630 : #ifdef DX_DEBUG
631 : static void dx_show_index(char * label, struct dx_entry *entries)
632 : {
633 : int i, n = dx_get_count (entries);
634 : printk(KERN_DEBUG "%s index", label);
635 : for (i = 0; i < n; i++) {
636 : printk(KERN_CONT " %x->%lu",
637 : i ? dx_get_hash(entries + i) : 0,
638 : (unsigned long)dx_get_block(entries + i));
639 : }
640 : printk(KERN_CONT "\n");
641 : }
642 :
643 : struct stats
644 : {
645 : unsigned names;
646 : unsigned space;
647 : unsigned bcount;
648 : };
649 :
650 : static struct stats dx_show_leaf(struct inode *dir,
651 : struct dx_hash_info *hinfo,
652 : struct ext4_dir_entry_2 *de,
653 : int size, int show_names)
654 : {
655 : unsigned names = 0, space = 0;
656 : char *base = (char *) de;
657 : struct dx_hash_info h = *hinfo;
658 :
659 : printk("names: ");
660 : while ((char *) de < base + size)
661 : {
662 : if (de->inode)
663 : {
664 : if (show_names)
665 : {
666 : #ifdef CONFIG_FS_ENCRYPTION
667 : int len;
668 : char *name;
669 : struct fscrypt_str fname_crypto_str =
670 : FSTR_INIT(NULL, 0);
671 : int res = 0;
672 :
673 : name = de->name;
674 : len = de->name_len;
675 : if (!IS_ENCRYPTED(dir)) {
676 : /* Directory is not encrypted */
677 : (void) ext4fs_dirhash(dir, de->name,
678 : de->name_len, &h);
679 : printk("%*.s:(U)%x.%u ", len,
680 : name, h.hash,
681 : (unsigned) ((char *) de
682 : - base));
683 : } else {
684 : struct fscrypt_str de_name =
685 : FSTR_INIT(name, len);
686 :
687 : /* Directory is encrypted */
688 : res = fscrypt_fname_alloc_buffer(
689 : len, &fname_crypto_str);
690 : if (res)
691 : printk(KERN_WARNING "Error "
692 : "allocating crypto "
693 : "buffer--skipping "
694 : "crypto\n");
695 : res = fscrypt_fname_disk_to_usr(dir,
696 : 0, 0, &de_name,
697 : &fname_crypto_str);
698 : if (res) {
699 : printk(KERN_WARNING "Error "
700 : "converting filename "
701 : "from disk to usr"
702 : "\n");
703 : name = "??";
704 : len = 2;
705 : } else {
706 : name = fname_crypto_str.name;
707 : len = fname_crypto_str.len;
708 : }
709 : if (IS_CASEFOLDED(dir))
710 : h.hash = EXT4_DIRENT_HASH(de);
711 : else
712 : (void) ext4fs_dirhash(dir,
713 : de->name,
714 : de->name_len, &h);
715 : printk("%*.s:(E)%x.%u ", len, name,
716 : h.hash, (unsigned) ((char *) de
717 : - base));
718 : fscrypt_fname_free_buffer(
719 : &fname_crypto_str);
720 : }
721 : #else
722 : int len = de->name_len;
723 : char *name = de->name;
724 : (void) ext4fs_dirhash(dir, de->name,
725 : de->name_len, &h);
726 : printk("%*.s:%x.%u ", len, name, h.hash,
727 : (unsigned) ((char *) de - base));
728 : #endif
729 : }
730 : space += ext4_dir_rec_len(de->name_len, dir);
731 : names++;
732 : }
733 : de = ext4_next_entry(de, size);
734 : }
735 : printk(KERN_CONT "(%i)\n", names);
736 : return (struct stats) { names, space, 1 };
737 : }
738 :
739 : struct stats dx_show_entries(struct dx_hash_info *hinfo, struct inode *dir,
740 : struct dx_entry *entries, int levels)
741 : {
742 : unsigned blocksize = dir->i_sb->s_blocksize;
743 : unsigned count = dx_get_count(entries), names = 0, space = 0, i;
744 : unsigned bcount = 0;
745 : struct buffer_head *bh;
746 : printk("%i indexed blocks...\n", count);
747 : for (i = 0; i < count; i++, entries++)
748 : {
749 : ext4_lblk_t block = dx_get_block(entries);
750 : ext4_lblk_t hash = i ? dx_get_hash(entries): 0;
751 : u32 range = i < count - 1? (dx_get_hash(entries + 1) - hash): ~hash;
752 : struct stats stats;
753 : printk("%s%3u:%03u hash %8x/%8x ",levels?"":" ", i, block, hash, range);
754 : bh = ext4_bread(NULL,dir, block, 0);
755 : if (!bh || IS_ERR(bh))
756 : continue;
757 : stats = levels?
758 : dx_show_entries(hinfo, dir, ((struct dx_node *) bh->b_data)->entries, levels - 1):
759 : dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *)
760 : bh->b_data, blocksize, 0);
761 : names += stats.names;
762 : space += stats.space;
763 : bcount += stats.bcount;
764 : brelse(bh);
765 : }
766 : if (bcount)
767 : printk(KERN_DEBUG "%snames %u, fullness %u (%u%%)\n",
768 : levels ? "" : " ", names, space/bcount,
769 : (space/bcount)*100/blocksize);
770 : return (struct stats) { names, space, bcount};
771 : }
772 :
773 : /*
774 : * Linear search cross check
775 : */
776 : static inline void htree_rep_invariant_check(struct dx_entry *at,
777 : struct dx_entry *target,
778 : u32 hash, unsigned int n)
779 : {
780 : while (n--) {
781 : dxtrace(printk(KERN_CONT ","));
782 : if (dx_get_hash(++at) > hash) {
783 : at--;
784 : break;
785 : }
786 : }
787 : ASSERT(at == target - 1);
788 : }
789 : #else /* DX_DEBUG */
790 : static inline void htree_rep_invariant_check(struct dx_entry *at,
791 : struct dx_entry *target,
792 : u32 hash, unsigned int n)
793 : {
794 : }
795 : #endif /* DX_DEBUG */
796 :
797 : /*
798 : * Probe for a directory leaf block to search.
799 : *
800 : * dx_probe can return ERR_BAD_DX_DIR, which means there was a format
801 : * error in the directory index, and the caller should fall back to
802 : * searching the directory normally. The callers of dx_probe **MUST**
803 : * check for this error code, and make sure it never gets reflected
804 : * back to userspace.
805 : */
806 : static struct dx_frame *
807 6182495 : dx_probe(struct ext4_filename *fname, struct inode *dir,
808 : struct dx_hash_info *hinfo, struct dx_frame *frame_in)
809 : {
810 6182495 : unsigned count, indirect, level, i;
811 6182495 : struct dx_entry *at, *entries, *p, *q, *m;
812 6182495 : struct dx_root *root;
813 6182495 : struct dx_frame *frame = frame_in;
814 6182495 : struct dx_frame *ret_err = ERR_PTR(ERR_BAD_DX_DIR);
815 6182495 : u32 hash;
816 6182495 : ext4_lblk_t block;
817 6182495 : ext4_lblk_t blocks[EXT4_HTREE_LEVEL];
818 :
819 6182495 : memset(frame_in, 0, EXT4_HTREE_LEVEL * sizeof(frame_in[0]));
820 6182495 : frame->bh = ext4_read_dirblock(dir, 0, INDEX);
821 6177431 : if (IS_ERR(frame->bh))
822 : return (struct dx_frame *) frame->bh;
823 :
824 6177429 : root = (struct dx_root *) frame->bh->b_data;
825 6177429 : if (root->info.hash_version != DX_HASH_TEA &&
826 : root->info.hash_version != DX_HASH_HALF_MD4 &&
827 6177429 : root->info.hash_version != DX_HASH_LEGACY &&
828 : root->info.hash_version != DX_HASH_SIPHASH) {
829 0 : ext4_warning_inode(dir, "Unrecognised inode hash code %u",
830 : root->info.hash_version);
831 0 : goto fail;
832 : }
833 6177429 : if (ext4_hash_in_dirent(dir)) {
834 0 : if (root->info.hash_version != DX_HASH_SIPHASH) {
835 0 : ext4_warning_inode(dir,
836 : "Hash in dirent, but hash is not SIPHASH");
837 0 : goto fail;
838 : }
839 : } else {
840 6177429 : if (root->info.hash_version == DX_HASH_SIPHASH) {
841 0 : ext4_warning_inode(dir,
842 : "Hash code is SIPHASH, but hash not in dirent");
843 0 : goto fail;
844 : }
845 : }
846 6177429 : if (fname)
847 5475764 : hinfo = &fname->hinfo;
848 6177429 : hinfo->hash_version = root->info.hash_version;
849 6177429 : if (hinfo->hash_version <= DX_HASH_TEA)
850 6181861 : hinfo->hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
851 6177429 : hinfo->seed = EXT4_SB(dir->i_sb)->s_hash_seed;
852 : /* hash is already computed for encrypted casefolded directory */
853 6177429 : if (fname && fname_name(fname) &&
854 5479961 : !(IS_ENCRYPTED(dir) && IS_CASEFOLDED(dir))) {
855 5479776 : int ret = ext4fs_dirhash(dir, fname_name(fname),
856 5479776 : fname_len(fname), hinfo);
857 5478017 : if (ret < 0) {
858 0 : ret_err = ERR_PTR(ret);
859 0 : goto fail;
860 : }
861 : }
862 6175670 : hash = hinfo->hash;
863 :
864 6175670 : if (root->info.unused_flags & 1) {
865 0 : ext4_warning_inode(dir, "Unimplemented hash flags: %#06x",
866 : root->info.unused_flags);
867 0 : goto fail;
868 : }
869 :
870 6175670 : indirect = root->info.indirect_levels;
871 11552537 : if (indirect >= ext4_dir_htree_level(dir->i_sb)) {
872 0 : ext4_warning(dir->i_sb,
873 : "Directory (ino: %lu) htree depth %#06x exceed"
874 : "supported value", dir->i_ino,
875 : ext4_dir_htree_level(dir->i_sb));
876 0 : if (ext4_dir_htree_level(dir->i_sb) < EXT4_HTREE_LEVEL) {
877 0 : ext4_warning(dir->i_sb, "Enable large directory "
878 : "feature to access it");
879 : }
880 0 : goto fail;
881 : }
882 :
883 6175670 : entries = (struct dx_entry *)(((char *)&root->info) +
884 6175670 : root->info.info_length);
885 :
886 6175670 : if (dx_get_limit(entries) != dx_root_limit(dir,
887 : root->info.info_length)) {
888 0 : ext4_warning_inode(dir, "dx entry: limit %u != root limit %u",
889 : dx_get_limit(entries),
890 : dx_root_limit(dir, root->info.info_length));
891 0 : goto fail;
892 : }
893 :
894 6173489 : dxtrace(printk("Look up %x", hash));
895 6173489 : level = 0;
896 6173489 : blocks[0] = 0;
897 7543314 : while (1) {
898 7543314 : count = dx_get_count(entries);
899 7543314 : if (!count || count > dx_get_limit(entries)) {
900 0 : ext4_warning_inode(dir,
901 : "dx entry: count %u beyond limit %u",
902 : count, dx_get_limit(entries));
903 0 : goto fail;
904 : }
905 :
906 7543314 : p = entries + 1;
907 7543314 : q = entries + count - 1;
908 35323427 : while (p <= q) {
909 27780113 : m = p + (q - p) / 2;
910 27780113 : dxtrace(printk(KERN_CONT "."));
911 27780113 : if (dx_get_hash(m) > hash)
912 13344677 : q = m - 1;
913 : else
914 14435436 : p = m + 1;
915 : }
916 :
917 7543314 : htree_rep_invariant_check(entries, p, hash, count - 1);
918 :
919 7543314 : at = p - 1;
920 : dxtrace(printk(KERN_CONT " %x->%u\n",
921 : at == entries ? 0 : dx_get_hash(at),
922 7543314 : dx_get_block(at)));
923 7543314 : frame->entries = entries;
924 7543314 : frame->at = at;
925 :
926 7543314 : block = dx_get_block(at);
927 16813188 : for (i = 0; i <= level; i++) {
928 9268259 : if (blocks[i] == block) {
929 0 : ext4_warning_inode(dir,
930 : "dx entry: tree cycle block %u points back to block %u",
931 : blocks[level], block);
932 0 : goto fail;
933 : }
934 : }
935 7544929 : if (++level > indirect)
936 6175104 : return frame;
937 1369825 : blocks[level] = block;
938 1369825 : frame++;
939 1369825 : frame->bh = ext4_read_dirblock(dir, block, INDEX);
940 1369825 : if (IS_ERR(frame->bh)) {
941 0 : ret_err = (struct dx_frame *) frame->bh;
942 0 : frame->bh = NULL;
943 0 : goto fail;
944 : }
945 :
946 1369825 : entries = ((struct dx_node *) frame->bh->b_data)->entries;
947 :
948 1369825 : if (dx_get_limit(entries) != dx_node_limit(dir)) {
949 0 : ext4_warning_inode(dir,
950 : "dx entry: limit %u != node limit %u",
951 : dx_get_limit(entries), dx_node_limit(dir));
952 0 : goto fail;
953 : }
954 : }
955 0 : fail:
956 0 : while (frame >= frame_in) {
957 0 : brelse(frame->bh);
958 0 : frame--;
959 : }
960 :
961 0 : if (ret_err == ERR_PTR(ERR_BAD_DX_DIR))
962 0 : ext4_warning_inode(dir,
963 : "Corrupt directory, running e2fsck is recommended");
964 : return ret_err;
965 : }
966 :
967 6195571 : static void dx_release(struct dx_frame *frames)
968 : {
969 6195571 : struct dx_root_info *info;
970 6195571 : int i;
971 6195571 : unsigned int indirect_levels;
972 :
973 6195571 : if (frames[0].bh == NULL)
974 : return;
975 :
976 6195571 : info = &((struct dx_root *)frames[0].bh->b_data)->info;
977 : /* save local copy, "info" may be freed after brelse() */
978 6195571 : indirect_levels = info->indirect_levels;
979 13762008 : for (i = 0; i <= indirect_levels; i++) {
980 7565284 : if (frames[i].bh == NULL)
981 : break;
982 7565280 : brelse(frames[i].bh);
983 7566437 : frames[i].bh = NULL;
984 : }
985 : }
986 :
987 : /*
988 : * This function increments the frame pointer to search the next leaf
989 : * block, and reads in the necessary intervening nodes if the search
990 : * should be necessary. Whether or not the search is necessary is
991 : * controlled by the hash parameter. If the hash value is even, then
992 : * the search is only continued if the next block starts with that
993 : * hash value. This is used if we are searching for a specific file.
994 : *
995 : * If the hash value is HASH_NB_ALWAYS, then always go to the next block.
996 : *
997 : * This function returns 1 if the caller should continue to search,
998 : * or 0 if it should not. If there is an error reading one of the
999 : * index blocks, it will a negative error code.
1000 : *
1001 : * If start_hash is non-null, it will be filled in with the starting
1002 : * hash of the next page.
1003 : */
1004 2829291 : static int ext4_htree_next_block(struct inode *dir, __u32 hash,
1005 : struct dx_frame *frame,
1006 : struct dx_frame *frames,
1007 : __u32 *start_hash)
1008 : {
1009 2829291 : struct dx_frame *p;
1010 2829291 : struct buffer_head *bh;
1011 2829291 : int num_frames = 0;
1012 2829291 : __u32 bhash;
1013 :
1014 2829291 : p = frame;
1015 : /*
1016 : * Find the next leaf page by incrementing the frame pointer.
1017 : * If we run out of entries in the interior node, loop around and
1018 : * increment pointer in the parent node. When we break out of
1019 : * this loop, num_frames indicates the number of interior
1020 : * nodes need to be read.
1021 : */
1022 2839075 : while (1) {
1023 2834183 : if (++(p->at) < p->entries + dx_get_count(p->entries))
1024 : break;
1025 561359 : if (p == frames)
1026 : return 0;
1027 4892 : num_frames++;
1028 4892 : p--;
1029 : }
1030 :
1031 : /*
1032 : * If the hash is 1, then continue only if the next page has a
1033 : * continuation hash of any value. This is used for readdir
1034 : * handling. Otherwise, check to see if the hash matches the
1035 : * desired continuation hash. If it doesn't, return since
1036 : * there's no point to read in the successive index pages.
1037 : */
1038 2272824 : bhash = dx_get_hash(p->at);
1039 2272824 : if (start_hash)
1040 680627 : *start_hash = bhash;
1041 2272824 : if ((hash & 1) == 0) {
1042 1592115 : if ((bhash & ~1) != hash)
1043 : return 0;
1044 : }
1045 : /*
1046 : * If the hash is HASH_NB_ALWAYS, we always go to the next
1047 : * block so no check is necessary
1048 : */
1049 680725 : while (num_frames--) {
1050 98 : bh = ext4_read_dirblock(dir, dx_get_block(p->at), INDEX);
1051 16 : if (IS_ERR(bh))
1052 0 : return PTR_ERR(bh);
1053 16 : p++;
1054 16 : brelse(p->bh);
1055 16 : p->bh = bh;
1056 16 : p->at = p->entries = ((struct dx_node *) bh->b_data)->entries;
1057 : }
1058 : return 1;
1059 : }
1060 :
1061 :
1062 : /*
1063 : * This function fills a red-black tree with information from a
1064 : * directory block. It returns the number directory entries loaded
1065 : * into the tree. If there is an error it is returned in err.
1066 : */
1067 805722 : static int htree_dirblock_to_tree(struct file *dir_file,
1068 : struct inode *dir, ext4_lblk_t block,
1069 : struct dx_hash_info *hinfo,
1070 : __u32 start_hash, __u32 start_minor_hash)
1071 : {
1072 805722 : struct buffer_head *bh;
1073 805722 : struct ext4_dir_entry_2 *de, *top;
1074 805722 : int err = 0, count = 0;
1075 805722 : struct fscrypt_str fname_crypto_str = FSTR_INIT(NULL, 0), tmp_str;
1076 805722 : int csum = ext4_has_metadata_csum(dir->i_sb);
1077 :
1078 : dxtrace(printk(KERN_INFO "In htree dirblock_to_tree: block %lu\n",
1079 805697 : (unsigned long)block));
1080 805697 : bh = ext4_read_dirblock(dir, block, DIRENT_HTREE);
1081 805732 : if (IS_ERR(bh))
1082 1 : return PTR_ERR(bh);
1083 :
1084 805731 : de = (struct ext4_dir_entry_2 *) bh->b_data;
1085 : /* csum entries are not larger in the casefolded encrypted case */
1086 1611462 : top = (struct ext4_dir_entry_2 *) ((char *) de +
1087 1611462 : dir->i_sb->s_blocksize -
1088 805731 : ext4_dir_rec_len(0,
1089 : csum ? NULL : dir));
1090 : /* Check if the directory is encrypted */
1091 805731 : if (IS_ENCRYPTED(dir)) {
1092 0 : err = fscrypt_prepare_readdir(dir);
1093 0 : if (err < 0) {
1094 0 : brelse(bh);
1095 0 : return err;
1096 : }
1097 : err = fscrypt_fname_alloc_buffer(EXT4_NAME_LEN,
1098 : &fname_crypto_str);
1099 : if (err < 0) {
1100 : brelse(bh);
1101 : return err;
1102 : }
1103 : }
1104 :
1105 155714774 : for (; de < top; de = ext4_next_entry(de, dir->i_sb->s_blocksize)) {
1106 154909059 : if (ext4_check_dir_entry(dir, NULL, de, bh,
1107 : bh->b_data, bh->b_size,
1108 : (block<<EXT4_BLOCK_SIZE_BITS(dir->i_sb))
1109 : + ((char *)de - bh->b_data))) {
1110 : /* silently ignore the rest of the block */
1111 : break;
1112 : }
1113 154909312 : if (ext4_hash_in_dirent(dir)) {
1114 0 : if (de->name_len && de->inode) {
1115 0 : hinfo->hash = EXT4_DIRENT_HASH(de);
1116 0 : hinfo->minor_hash = EXT4_DIRENT_MINOR_HASH(de);
1117 : } else {
1118 0 : hinfo->hash = 0;
1119 0 : hinfo->minor_hash = 0;
1120 : }
1121 : } else {
1122 154909312 : err = ext4fs_dirhash(dir, de->name,
1123 154909312 : de->name_len, hinfo);
1124 154909098 : if (err < 0) {
1125 0 : count = err;
1126 0 : goto errout;
1127 : }
1128 : }
1129 154909098 : if ((hinfo->hash < start_hash) ||
1130 628149 : ((hinfo->hash == start_hash) &&
1131 628149 : (hinfo->minor_hash < start_minor_hash)))
1132 741611 : continue;
1133 154167487 : if (de->inode == 0)
1134 608492 : continue;
1135 153558995 : if (!IS_ENCRYPTED(dir)) {
1136 153558995 : tmp_str.name = de->name;
1137 153558995 : tmp_str.len = de->name_len;
1138 153558995 : err = ext4_htree_store_dirent(dir_file,
1139 : hinfo->hash, hinfo->minor_hash, de,
1140 : &tmp_str);
1141 : } else {
1142 0 : int save_len = fname_crypto_str.len;
1143 0 : struct fscrypt_str de_name = FSTR_INIT(de->name,
1144 : de->name_len);
1145 :
1146 : /* Directory is encrypted */
1147 0 : err = fscrypt_fname_disk_to_usr(dir, hinfo->hash,
1148 : hinfo->minor_hash, &de_name,
1149 : &fname_crypto_str);
1150 0 : if (err) {
1151 0 : count = err;
1152 0 : goto errout;
1153 : }
1154 : err = ext4_htree_store_dirent(dir_file,
1155 : hinfo->hash, hinfo->minor_hash, de,
1156 : &fname_crypto_str);
1157 : fname_crypto_str.len = save_len;
1158 : }
1159 153558940 : if (err != 0) {
1160 0 : count = err;
1161 0 : goto errout;
1162 : }
1163 153558940 : count++;
1164 : }
1165 805715 : errout:
1166 805715 : brelse(bh);
1167 : fscrypt_fname_free_buffer(&fname_crypto_str);
1168 : return count;
1169 : }
1170 :
1171 :
1172 : /*
1173 : * This function fills a red-black tree with information from a
1174 : * directory. We start scanning the directory in hash order, starting
1175 : * at start_hash and start_minor_hash.
1176 : *
1177 : * This function returns the number of entries inserted into the tree,
1178 : * or a negative error code.
1179 : */
1180 805724 : int ext4_htree_fill_tree(struct file *dir_file, __u32 start_hash,
1181 : __u32 start_minor_hash, __u32 *next_hash)
1182 : {
1183 805724 : struct dx_hash_info hinfo;
1184 805724 : struct ext4_dir_entry_2 *de;
1185 805724 : struct dx_frame frames[EXT4_HTREE_LEVEL], *frame;
1186 805724 : struct inode *dir;
1187 805724 : ext4_lblk_t block;
1188 805724 : int count = 0;
1189 805724 : int ret, err;
1190 805724 : __u32 hashval;
1191 805724 : struct fscrypt_str tmp_str;
1192 :
1193 : dxtrace(printk(KERN_DEBUG "In htree_fill_tree, start hash: %x:%x\n",
1194 805724 : start_hash, start_minor_hash));
1195 805724 : dir = file_inode(dir_file);
1196 805724 : if (!(ext4_test_inode_flag(dir, EXT4_INODE_INDEX))) {
1197 104055 : if (ext4_hash_in_dirent(dir))
1198 0 : hinfo.hash_version = DX_HASH_SIPHASH;
1199 : else
1200 104055 : hinfo.hash_version =
1201 104055 : EXT4_SB(dir->i_sb)->s_def_hash_version;
1202 104055 : if (hinfo.hash_version <= DX_HASH_TEA)
1203 104050 : hinfo.hash_version +=
1204 104050 : EXT4_SB(dir->i_sb)->s_hash_unsigned;
1205 104055 : hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
1206 104055 : if (ext4_has_inline_data(dir)) {
1207 0 : int has_inline_data = 1;
1208 0 : count = ext4_inlinedir_to_tree(dir_file, dir, 0,
1209 : &hinfo, start_hash,
1210 : start_minor_hash,
1211 : &has_inline_data);
1212 0 : if (has_inline_data) {
1213 0 : *next_hash = ~0;
1214 0 : return count;
1215 : }
1216 : }
1217 104055 : count = htree_dirblock_to_tree(dir_file, dir, 0, &hinfo,
1218 : start_hash, start_minor_hash);
1219 104072 : *next_hash = ~0;
1220 104072 : return count;
1221 : }
1222 701669 : hinfo.hash = start_hash;
1223 701669 : hinfo.minor_hash = 0;
1224 701669 : frame = dx_probe(NULL, dir, &hinfo, frames);
1225 701665 : if (IS_ERR(frame))
1226 0 : return PTR_ERR(frame);
1227 :
1228 : /* Add '.' and '..' from the htree header */
1229 701665 : if (!start_hash && !start_minor_hash) {
1230 25746 : de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data;
1231 25746 : tmp_str.name = de->name;
1232 25746 : tmp_str.len = de->name_len;
1233 25746 : err = ext4_htree_store_dirent(dir_file, 0, 0,
1234 : de, &tmp_str);
1235 25747 : if (err != 0)
1236 0 : goto errout;
1237 : count++;
1238 : }
1239 701666 : if (start_hash < 2 || (start_hash ==2 && start_minor_hash==0)) {
1240 74664 : de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data;
1241 74664 : de = ext4_next_entry(de, dir->i_sb->s_blocksize);
1242 74664 : tmp_str.name = de->name;
1243 74664 : tmp_str.len = de->name_len;
1244 74664 : err = ext4_htree_store_dirent(dir_file, 2, 0,
1245 : de, &tmp_str);
1246 74663 : if (err != 0)
1247 0 : goto errout;
1248 74663 : count++;
1249 : }
1250 :
1251 701671 : while (1) {
1252 701671 : if (fatal_signal_pending(current)) {
1253 0 : err = -ERESTARTSYS;
1254 0 : goto errout;
1255 : }
1256 701670 : cond_resched();
1257 701672 : block = dx_get_block(frame->at);
1258 701672 : ret = htree_dirblock_to_tree(dir_file, dir, block, &hinfo,
1259 : start_hash, start_minor_hash);
1260 701677 : if (ret < 0) {
1261 0 : err = ret;
1262 0 : goto errout;
1263 : }
1264 701677 : count += ret;
1265 701677 : hashval = ~0;
1266 701677 : ret = ext4_htree_next_block(dir, HASH_NB_ALWAYS,
1267 : frame, frames, &hashval);
1268 701675 : *next_hash = hashval;
1269 701675 : if (ret < 0) {
1270 0 : err = ret;
1271 0 : goto errout;
1272 : }
1273 : /*
1274 : * Stop if: (a) there are no more entries, or
1275 : * (b) we have inserted at least one entry and the
1276 : * next hash value is not a continuation
1277 : */
1278 701675 : if ((ret == 0) ||
1279 680620 : (count && ((hashval & 1) == 0)))
1280 : break;
1281 : }
1282 701669 : dx_release(frames);
1283 : dxtrace(printk(KERN_DEBUG "Fill tree: returned %d entries, "
1284 701669 : "next hash: %x\n", count, *next_hash));
1285 701669 : return count;
1286 0 : errout:
1287 0 : dx_release(frames);
1288 0 : return (err);
1289 : }
1290 :
1291 5847565 : static inline int search_dirblock(struct buffer_head *bh,
1292 : struct inode *dir,
1293 : struct ext4_filename *fname,
1294 : unsigned int offset,
1295 : struct ext4_dir_entry_2 **res_dir)
1296 : {
1297 5847565 : return ext4_search_dir(bh, bh->b_data, dir->i_sb->s_blocksize, dir,
1298 : fname, offset, res_dir);
1299 : }
1300 :
1301 : /*
1302 : * Directory block splitting, compacting
1303 : */
1304 :
1305 : /*
1306 : * Create map of hash values, offsets, and sizes, stored at end of block.
1307 : * Returns number of entries mapped.
1308 : */
1309 28933 : static int dx_make_map(struct inode *dir, struct buffer_head *bh,
1310 : struct dx_hash_info *hinfo,
1311 : struct dx_map_entry *map_tail)
1312 : {
1313 28933 : int count = 0;
1314 28933 : struct ext4_dir_entry_2 *de = (struct ext4_dir_entry_2 *)bh->b_data;
1315 28933 : unsigned int buflen = bh->b_size;
1316 28933 : char *base = bh->b_data;
1317 28933 : struct dx_hash_info h = *hinfo;
1318 :
1319 28933 : if (ext4_has_metadata_csum(dir->i_sb))
1320 28933 : buflen -= sizeof(struct ext4_dir_entry_tail);
1321 :
1322 2208183 : while ((char *) de < base + buflen) {
1323 2179250 : if (ext4_check_dir_entry(dir, NULL, de, bh, base, buflen,
1324 : ((char *)de) - base))
1325 : return -EFSCORRUPTED;
1326 2179234 : if (de->name_len && de->inode) {
1327 2179230 : if (ext4_hash_in_dirent(dir))
1328 0 : h.hash = EXT4_DIRENT_HASH(de);
1329 : else {
1330 2179230 : int err = ext4fs_dirhash(dir, de->name,
1331 : de->name_len, &h);
1332 2179248 : if (err < 0)
1333 0 : return err;
1334 : }
1335 2179248 : map_tail--;
1336 2179248 : map_tail->hash = h.hash;
1337 2179248 : map_tail->offs = ((char *) de - base)>>2;
1338 2179248 : map_tail->size = le16_to_cpu(de->rec_len);
1339 2179248 : count++;
1340 2179248 : cond_resched();
1341 : }
1342 2179250 : de = ext4_next_entry(de, dir->i_sb->s_blocksize);
1343 : }
1344 : return count;
1345 : }
1346 :
1347 : /* Sort map by hash value */
1348 28933 : static void dx_sort_map (struct dx_map_entry *map, unsigned count)
1349 : {
1350 28933 : struct dx_map_entry *p, *q, *top = map + count - 1;
1351 28933 : int more;
1352 : /* Combsort until bubble sort doesn't suck */
1353 312329 : while (count > 2) {
1354 283396 : count = count*10/13;
1355 283396 : if (count - 9 < 2) /* 9, 10 -> 11 */
1356 5253 : count = 11;
1357 24718217 : for (p = top, q = p - count; q >= map; p--, q--)
1358 24434821 : if (p->hash < q->hash)
1359 24434821 : swap(*p, *q);
1360 : }
1361 : /* Garden variety bubble sort */
1362 62788 : do {
1363 62788 : more = 0;
1364 62788 : q = top;
1365 5570971 : while (q-- > map) {
1366 5508183 : if (q[1].hash >= q[0].hash)
1367 4949806 : continue;
1368 558377 : swap(*(q+1), *q);
1369 558377 : more = 1;
1370 : }
1371 62788 : } while(more);
1372 28933 : }
1373 :
1374 29130 : static void dx_insert_block(struct dx_frame *frame, u32 hash, ext4_lblk_t block)
1375 : {
1376 29130 : struct dx_entry *entries = frame->entries;
1377 29130 : struct dx_entry *old = frame->at, *new = old + 1;
1378 29130 : int count = dx_get_count(entries);
1379 :
1380 29130 : ASSERT(count < dx_get_limit(entries));
1381 29130 : ASSERT(old < entries + count);
1382 58260 : memmove(new + 1, new, (char *)(entries + count) - (char *)(new));
1383 29130 : dx_set_hash(new, hash);
1384 29130 : dx_set_block(new, block);
1385 29130 : dx_set_count(entries, count + 1);
1386 29130 : }
1387 :
1388 : #if IS_ENABLED(CONFIG_UNICODE)
1389 : /*
1390 : * Test whether a case-insensitive directory entry matches the filename
1391 : * being searched for. If quick is set, assume the name being looked up
1392 : * is already in the casefolded form.
1393 : *
1394 : * Returns: 0 if the directory entry matches, more than 0 if it
1395 : * doesn't match or less than zero on error.
1396 : */
1397 910036 : static int ext4_ci_compare(const struct inode *parent, const struct qstr *name,
1398 : u8 *de_name, size_t de_name_len, bool quick)
1399 : {
1400 910036 : const struct super_block *sb = parent->i_sb;
1401 910036 : const struct unicode_map *um = sb->s_encoding;
1402 910036 : struct fscrypt_str decrypted_name = FSTR_INIT(NULL, de_name_len);
1403 910036 : struct qstr entry = QSTR_INIT(de_name, de_name_len);
1404 910036 : int ret;
1405 :
1406 910036 : if (IS_ENCRYPTED(parent)) {
1407 0 : const struct fscrypt_str encrypted_name =
1408 : FSTR_INIT(de_name, de_name_len);
1409 :
1410 0 : decrypted_name.name = kmalloc(de_name_len, GFP_KERNEL);
1411 0 : if (!decrypted_name.name)
1412 : return -ENOMEM;
1413 0 : ret = fscrypt_fname_disk_to_usr(parent, 0, 0, &encrypted_name,
1414 : &decrypted_name);
1415 0 : if (ret < 0)
1416 0 : goto out;
1417 : entry.name = decrypted_name.name;
1418 : entry.len = decrypted_name.len;
1419 : }
1420 :
1421 910036 : if (quick)
1422 910014 : ret = utf8_strncasecmp_folded(um, name, &entry);
1423 : else
1424 22 : ret = utf8_strncasecmp(um, name, &entry);
1425 910036 : if (ret < 0) {
1426 : /* Handle invalid character sequence as either an error
1427 : * or as an opaque byte sequence.
1428 : */
1429 4 : if (sb_has_strict_encoding(sb))
1430 : ret = -EINVAL;
1431 4 : else if (name->len != entry.len)
1432 : ret = 1;
1433 : else
1434 0 : ret = !!memcmp(name->name, entry.name, entry.len);
1435 : }
1436 910032 : out:
1437 910036 : kfree(decrypted_name.name);
1438 910036 : return ret;
1439 : }
1440 :
1441 8732678 : int ext4_fname_setup_ci_filename(struct inode *dir, const struct qstr *iname,
1442 : struct ext4_filename *name)
1443 : {
1444 8732678 : struct fscrypt_str *cf_name = &name->cf_name;
1445 8732678 : struct dx_hash_info *hinfo = &name->hinfo;
1446 8732678 : int len;
1447 :
1448 8732678 : if (!IS_CASEFOLDED(dir) || !dir->i_sb->s_encoding ||
1449 6199 : (IS_ENCRYPTED(dir) && !fscrypt_has_encryption_key(dir))) {
1450 8726479 : cf_name->name = NULL;
1451 8726479 : return 0;
1452 : }
1453 :
1454 6199 : cf_name->name = kmalloc(EXT4_NAME_LEN, GFP_NOFS);
1455 6199 : if (!cf_name->name)
1456 : return -ENOMEM;
1457 :
1458 6199 : len = utf8_casefold(dir->i_sb->s_encoding,
1459 : iname, cf_name->name,
1460 : EXT4_NAME_LEN);
1461 6199 : if (len <= 0) {
1462 3 : kfree(cf_name->name);
1463 3 : cf_name->name = NULL;
1464 : }
1465 6199 : cf_name->len = (unsigned) len;
1466 6199 : if (!IS_ENCRYPTED(dir))
1467 : return 0;
1468 :
1469 0 : hinfo->hash_version = DX_HASH_SIPHASH;
1470 0 : hinfo->seed = NULL;
1471 0 : if (cf_name->name)
1472 0 : return ext4fs_dirhash(dir, cf_name->name, cf_name->len, hinfo);
1473 : else
1474 0 : return ext4fs_dirhash(dir, iname->name, iname->len, hinfo);
1475 : }
1476 : #endif
1477 :
1478 : /*
1479 : * Test whether a directory entry matches the filename being searched for.
1480 : *
1481 : * Return: %true if the directory entry matches, otherwise %false.
1482 : */
1483 622560147 : static bool ext4_match(struct inode *parent,
1484 : const struct ext4_filename *fname,
1485 : struct ext4_dir_entry_2 *de)
1486 : {
1487 622560147 : struct fscrypt_name f;
1488 :
1489 622560147 : if (!de->inode)
1490 : return false;
1491 :
1492 618109557 : f.usr_fname = fname->usr_fname;
1493 618109557 : f.disk_name = fname->disk_name;
1494 : #ifdef CONFIG_FS_ENCRYPTION
1495 : f.crypto_buf = fname->crypto_buf;
1496 : #endif
1497 :
1498 : #if IS_ENABLED(CONFIG_UNICODE)
1499 618109557 : if (parent->i_sb->s_encoding && IS_CASEFOLDED(parent) &&
1500 910036 : (!IS_ENCRYPTED(parent) || fscrypt_has_encryption_key(parent))) {
1501 910036 : if (fname->cf_name.name) {
1502 910014 : struct qstr cf = {.name = fname->cf_name.name,
1503 910014 : .len = fname->cf_name.len};
1504 910014 : if (IS_ENCRYPTED(parent)) {
1505 : if (fname->hinfo.hash != EXT4_DIRENT_HASH(de) ||
1506 : fname->hinfo.minor_hash !=
1507 : EXT4_DIRENT_MINOR_HASH(de)) {
1508 :
1509 : return false;
1510 : }
1511 : }
1512 910014 : return !ext4_ci_compare(parent, &cf, de->name,
1513 910014 : de->name_len, true);
1514 : }
1515 22 : return !ext4_ci_compare(parent, fname->usr_fname, de->name,
1516 22 : de->name_len, false);
1517 : }
1518 : #endif
1519 :
1520 617199521 : return fscrypt_match_name(&f, de->name, de->name_len);
1521 : }
1522 :
1523 : /*
1524 : * Returns 0 if not found, -1 on failure, and 1 on success
1525 : */
1526 5845159 : int ext4_search_dir(struct buffer_head *bh, char *search_buf, int buf_size,
1527 : struct inode *dir, struct ext4_filename *fname,
1528 : unsigned int offset, struct ext4_dir_entry_2 **res_dir)
1529 : {
1530 5845159 : struct ext4_dir_entry_2 * de;
1531 5845159 : char * dlimit;
1532 5845159 : int de_len;
1533 :
1534 5845159 : de = (struct ext4_dir_entry_2 *)search_buf;
1535 5845159 : dlimit = search_buf + buf_size;
1536 360891140 : while ((char *) de < dlimit - EXT4_BASE_DIR_LEN) {
1537 : /* this code is executed quadratically often */
1538 : /* do minimal checking `by hand' */
1539 714922690 : if (de->name + de->name_len <= dlimit &&
1540 357451851 : ext4_match(dir, fname, de)) {
1541 : /* found a match - just to be sure, do
1542 : * a full check */
1543 2424858 : if (ext4_check_dir_entry(dir, NULL, de, bh, search_buf,
1544 : buf_size, offset))
1545 : return -1;
1546 2424574 : *res_dir = de;
1547 2424574 : return 1;
1548 : }
1549 : /* prevent looping on a bad block */
1550 355045981 : de_len = ext4_rec_len_from_disk(de->rec_len,
1551 : dir->i_sb->s_blocksize);
1552 355045981 : if (de_len <= 0)
1553 : return -1;
1554 355045981 : offset += de_len;
1555 355045981 : de = (struct ext4_dir_entry_2 *) ((char *) de + de_len);
1556 : }
1557 : return 0;
1558 : }
1559 :
1560 1369 : static int is_dx_internal_node(struct inode *dir, ext4_lblk_t block,
1561 : struct ext4_dir_entry *de)
1562 : {
1563 1369 : struct super_block *sb = dir->i_sb;
1564 :
1565 1369 : if (!is_dx(dir))
1566 : return 0;
1567 0 : if (block == 0)
1568 : return 1;
1569 0 : if (de->inode == 0 &&
1570 0 : ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize) ==
1571 : sb->s_blocksize)
1572 0 : return 1;
1573 : return 0;
1574 : }
1575 :
1576 : /*
1577 : * __ext4_find_entry()
1578 : *
1579 : * finds an entry in the specified directory with the wanted name. It
1580 : * returns the cache buffer in which the entry was found, and the entry
1581 : * itself (as a parameter - res_dir). It does NOT read the inode of the
1582 : * entry - you'll have to do that yourself if you want to.
1583 : *
1584 : * The returned buffer_head has ->b_count elevated. The caller is expected
1585 : * to brelse() it when appropriate.
1586 : */
1587 5838446 : static struct buffer_head *__ext4_find_entry(struct inode *dir,
1588 : struct ext4_filename *fname,
1589 : struct ext4_dir_entry_2 **res_dir,
1590 : int *inlined)
1591 : {
1592 5838446 : struct super_block *sb;
1593 5838446 : struct buffer_head *bh_use[NAMEI_RA_SIZE];
1594 5838446 : struct buffer_head *bh, *ret = NULL;
1595 5838446 : ext4_lblk_t start, block;
1596 5838446 : const u8 *name = fname->usr_fname->name;
1597 5838446 : size_t ra_max = 0; /* Number of bh's in the readahead
1598 : buffer, bh_use[] */
1599 5838446 : size_t ra_ptr = 0; /* Current index into readahead
1600 : buffer */
1601 5838446 : ext4_lblk_t nblocks;
1602 5838446 : int i, namelen, retval;
1603 :
1604 5838446 : *res_dir = NULL;
1605 5838446 : sb = dir->i_sb;
1606 5838446 : namelen = fname->usr_fname->len;
1607 5838446 : if (namelen > EXT4_NAME_LEN)
1608 : return NULL;
1609 :
1610 5838446 : if (ext4_has_inline_data(dir)) {
1611 0 : int has_inline_data = 1;
1612 0 : ret = ext4_find_inline_entry(dir, fname, res_dir,
1613 : &has_inline_data);
1614 0 : if (inlined)
1615 0 : *inlined = has_inline_data;
1616 0 : if (has_inline_data)
1617 0 : goto cleanup_and_exit;
1618 : }
1619 :
1620 5838446 : if ((namelen <= 2) && (name[0] == '.') &&
1621 9 : (name[1] == '.' || name[1] == '\0')) {
1622 : /*
1623 : * "." or ".." will only be in the first block
1624 : * NFS may look up ".."; "." should be handled by the VFS
1625 : */
1626 9 : block = start = 0;
1627 9 : nblocks = 1;
1628 9 : goto restart;
1629 : }
1630 5838437 : if (is_dx(dir)) {
1631 3707254 : ret = ext4_dx_find_entry(dir, fname, res_dir);
1632 : /*
1633 : * On success, or if the error was file not found,
1634 : * return. Otherwise, fall back to doing a search the
1635 : * old fashioned way.
1636 : */
1637 3717274 : if (!IS_ERR(ret) || PTR_ERR(ret) != ERR_BAD_DX_DIR)
1638 3717274 : goto cleanup_and_exit;
1639 : dxtrace(printk(KERN_DEBUG "ext4_find_entry: dx failed, "
1640 : "falling back\n"));
1641 : ret = NULL;
1642 : }
1643 2131183 : nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
1644 2131183 : if (!nblocks) {
1645 0 : ret = NULL;
1646 0 : goto cleanup_and_exit;
1647 : }
1648 2131183 : start = EXT4_I(dir)->i_dir_start_lookup;
1649 2131183 : if (start >= nblocks)
1650 0 : start = 0;
1651 : block = start;
1652 2131192 : restart:
1653 2131266 : do {
1654 : /*
1655 : * We deal with the read-ahead logic here.
1656 : */
1657 2131266 : cond_resched();
1658 2131461 : if (ra_ptr >= ra_max) {
1659 : /* Refill the readahead buffer */
1660 2132020 : ra_ptr = 0;
1661 2132020 : if (block < start)
1662 0 : ra_max = start - block;
1663 : else
1664 2132020 : ra_max = nblocks - block;
1665 2132020 : ra_max = min(ra_max, ARRAY_SIZE(bh_use));
1666 2132020 : retval = ext4_bread_batch(dir, block, ra_max,
1667 : false /* wait */, bh_use);
1668 2131070 : if (retval) {
1669 0 : ret = ERR_PTR(retval);
1670 0 : ra_max = 0;
1671 0 : goto cleanup_and_exit;
1672 : }
1673 : }
1674 2130511 : if ((bh = bh_use[ra_ptr++]) == NULL)
1675 0 : goto next;
1676 2131356 : wait_on_buffer(bh);
1677 4264253 : if (!buffer_uptodate(bh)) {
1678 1 : EXT4_ERROR_INODE_ERR(dir, EIO,
1679 : "reading directory lblock %lu",
1680 : (unsigned long) block);
1681 1 : brelse(bh);
1682 1 : ret = ERR_PTR(-EIO);
1683 1 : goto cleanup_and_exit;
1684 : }
1685 4266005 : if (!buffer_verified(bh) &&
1686 1369 : !is_dx_internal_node(dir, block,
1687 2738 : (struct ext4_dir_entry *)bh->b_data) &&
1688 1369 : !ext4_dirblock_csum_verify(dir, bh)) {
1689 130 : EXT4_ERROR_INODE_ERR(dir, EFSBADCRC,
1690 : "checksumming directory "
1691 : "block %lu", (unsigned long)block);
1692 130 : brelse(bh);
1693 130 : ret = ERR_PTR(-EFSBADCRC);
1694 130 : goto cleanup_and_exit;
1695 : }
1696 2132188 : set_buffer_verified(bh);
1697 4264376 : i = search_dirblock(bh, dir, fname,
1698 2132188 : block << EXT4_BLOCK_SIZE_BITS(sb), res_dir);
1699 2137230 : if (i == 1) {
1700 835673 : EXT4_I(dir)->i_dir_start_lookup = block;
1701 835673 : ret = bh;
1702 835673 : goto cleanup_and_exit;
1703 : } else {
1704 1301557 : brelse(bh);
1705 1301883 : if (i < 0)
1706 0 : goto cleanup_and_exit;
1707 : }
1708 1301883 : next:
1709 1301883 : if (++block >= nblocks)
1710 1301850 : block = 0;
1711 1301883 : } while (block != start);
1712 :
1713 : /*
1714 : * If the directory has grown while we were searching, then
1715 : * search the last part of the directory before giving up.
1716 : */
1717 1301809 : block = nblocks;
1718 1301809 : nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
1719 1301809 : if (block < nblocks) {
1720 0 : start = 0;
1721 0 : goto restart;
1722 : }
1723 :
1724 5854887 : cleanup_and_exit:
1725 : /* Clean up the read-ahead blocks */
1726 5854926 : for (; ra_ptr < ra_max; ra_ptr++)
1727 523 : brelse(bh_use[ra_ptr]);
1728 : return ret;
1729 : }
1730 :
1731 2795574 : static struct buffer_head *ext4_find_entry(struct inode *dir,
1732 : const struct qstr *d_name,
1733 : struct ext4_dir_entry_2 **res_dir,
1734 : int *inlined)
1735 : {
1736 2795574 : int err;
1737 2795574 : struct ext4_filename fname;
1738 2795574 : struct buffer_head *bh;
1739 :
1740 2795574 : err = ext4_fname_setup_filename(dir, d_name, 1, &fname);
1741 2793307 : if (err == -ENOENT)
1742 : return NULL;
1743 2793307 : if (err)
1744 0 : return ERR_PTR(err);
1745 :
1746 2793307 : bh = __ext4_find_entry(dir, &fname, res_dir, inlined);
1747 :
1748 2797928 : ext4_fname_free_filename(&fname);
1749 2797928 : return bh;
1750 : }
1751 :
1752 3043071 : static struct buffer_head *ext4_lookup_entry(struct inode *dir,
1753 : struct dentry *dentry,
1754 : struct ext4_dir_entry_2 **res_dir)
1755 : {
1756 3043071 : int err;
1757 3043071 : struct ext4_filename fname;
1758 3043071 : struct buffer_head *bh;
1759 :
1760 3043071 : err = ext4_fname_prepare_lookup(dir, dentry, &fname);
1761 3043842 : generic_set_encrypted_ci_d_ops(dentry);
1762 3044017 : if (err == -ENOENT)
1763 : return NULL;
1764 3044017 : if (err)
1765 0 : return ERR_PTR(err);
1766 :
1767 3044017 : bh = __ext4_find_entry(dir, &fname, res_dir, NULL);
1768 :
1769 3056524 : ext4_fname_free_filename(&fname);
1770 3056524 : return bh;
1771 : }
1772 :
1773 3704598 : static struct buffer_head * ext4_dx_find_entry(struct inode *dir,
1774 : struct ext4_filename *fname,
1775 : struct ext4_dir_entry_2 **res_dir)
1776 : {
1777 3704598 : struct super_block * sb = dir->i_sb;
1778 3704598 : struct dx_frame frames[EXT4_HTREE_LEVEL], *frame;
1779 3704598 : struct buffer_head *bh;
1780 3704598 : ext4_lblk_t block;
1781 3704598 : int retval;
1782 :
1783 : #ifdef CONFIG_FS_ENCRYPTION
1784 : *res_dir = NULL;
1785 : #endif
1786 3704598 : frame = dx_probe(fname, dir, NULL, frames);
1787 3705477 : if (IS_ERR(frame))
1788 : return (struct buffer_head *) frame;
1789 3705529 : do {
1790 3705529 : block = dx_get_block(frame->at);
1791 3705529 : bh = ext4_read_dirblock(dir, block, DIRENT_HTREE);
1792 3716087 : if (IS_ERR(bh))
1793 0 : goto errout;
1794 :
1795 7432174 : retval = search_dirblock(bh, dir, fname,
1796 3716087 : block << EXT4_BLOCK_SIZE_BITS(sb),
1797 : res_dir);
1798 3716488 : if (retval == 1)
1799 1589072 : goto success;
1800 2127416 : brelse(bh);
1801 2127614 : if (retval == -1) {
1802 0 : bh = ERR_PTR(ERR_BAD_DX_DIR);
1803 0 : goto errout;
1804 : }
1805 :
1806 : /* Check to see if we should continue to search */
1807 2127614 : retval = ext4_htree_next_block(dir, fname->hinfo.hash, frame,
1808 : frames, NULL);
1809 2127436 : if (retval < 0) {
1810 0 : ext4_warning_inode(dir,
1811 : "error %d reading directory index block",
1812 : retval);
1813 0 : bh = ERR_PTR(retval);
1814 0 : goto errout;
1815 : }
1816 2127436 : } while (retval == 1);
1817 :
1818 : bh = NULL;
1819 3716454 : errout:
1820 3716454 : dxtrace(printk(KERN_DEBUG "%s not found\n", fname->usr_fname->name));
1821 3716454 : success:
1822 3716454 : dx_release(frames);
1823 3716454 : return bh;
1824 : }
1825 :
1826 3048685 : static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
1827 : {
1828 3048685 : struct inode *inode;
1829 3048685 : struct ext4_dir_entry_2 *de;
1830 3048685 : struct buffer_head *bh;
1831 :
1832 3048685 : if (dentry->d_name.len > EXT4_NAME_LEN)
1833 : return ERR_PTR(-ENAMETOOLONG);
1834 :
1835 3045900 : bh = ext4_lookup_entry(dir, dentry, &de);
1836 3056052 : if (IS_ERR(bh))
1837 : return ERR_CAST(bh);
1838 3055919 : inode = NULL;
1839 3055919 : if (bh) {
1840 192412 : __u32 ino = le32_to_cpu(de->inode);
1841 192412 : brelse(bh);
1842 192418 : if (!ext4_valid_inum(dir->i_sb, ino)) {
1843 0 : EXT4_ERROR_INODE(dir, "bad inode number: %u", ino);
1844 0 : return ERR_PTR(-EFSCORRUPTED);
1845 : }
1846 192418 : if (unlikely(ino == dir->i_ino)) {
1847 0 : EXT4_ERROR_INODE(dir, "'%pd' linked to parent dir",
1848 : dentry);
1849 0 : return ERR_PTR(-EFSCORRUPTED);
1850 : }
1851 192418 : inode = ext4_iget(dir->i_sb, ino, EXT4_IGET_NORMAL);
1852 192411 : if (inode == ERR_PTR(-ESTALE)) {
1853 0 : EXT4_ERROR_INODE(dir,
1854 : "deleted inode referenced: %u",
1855 : ino);
1856 0 : return ERR_PTR(-EFSCORRUPTED);
1857 : }
1858 192411 : if (!IS_ERR(inode) && IS_ENCRYPTED(dir) &&
1859 0 : (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
1860 : !fscrypt_has_permitted_context(dir, inode)) {
1861 0 : ext4_warning(inode->i_sb,
1862 : "Inconsistent encryption contexts: %lu/%lu",
1863 : dir->i_ino, inode->i_ino);
1864 0 : iput(inode);
1865 0 : return ERR_PTR(-EPERM);
1866 : }
1867 : }
1868 :
1869 : #if IS_ENABLED(CONFIG_UNICODE)
1870 3055918 : if (!inode && IS_CASEFOLDED(dir)) {
1871 : /* Eventually we want to call d_add_ci(dentry, NULL)
1872 : * for negative dentries in the encoding case as
1873 : * well. For now, prevent the negative dentry
1874 : * from being cached.
1875 : */
1876 : return NULL;
1877 : }
1878 : #endif
1879 3053850 : return d_splice_alias(inode, dentry);
1880 : }
1881 :
1882 :
1883 9 : struct dentry *ext4_get_parent(struct dentry *child)
1884 : {
1885 9 : __u32 ino;
1886 9 : struct ext4_dir_entry_2 * de;
1887 9 : struct buffer_head *bh;
1888 :
1889 9 : bh = ext4_find_entry(d_inode(child), &dotdot_name, &de, NULL);
1890 9 : if (IS_ERR(bh))
1891 : return ERR_CAST(bh);
1892 9 : if (!bh)
1893 : return ERR_PTR(-ENOENT);
1894 9 : ino = le32_to_cpu(de->inode);
1895 9 : brelse(bh);
1896 :
1897 9 : if (!ext4_valid_inum(child->d_sb, ino)) {
1898 0 : EXT4_ERROR_INODE(d_inode(child),
1899 : "bad parent inode number: %u", ino);
1900 0 : return ERR_PTR(-EFSCORRUPTED);
1901 : }
1902 :
1903 9 : return d_obtain_alias(ext4_iget(child->d_sb, ino, EXT4_IGET_NORMAL));
1904 : }
1905 :
1906 : /*
1907 : * Move count entries from end of map between two memory locations.
1908 : * Returns pointer to last entry moved.
1909 : */
1910 : static struct ext4_dir_entry_2 *
1911 28933 : dx_move_dirents(struct inode *dir, char *from, char *to,
1912 : struct dx_map_entry *map, int count,
1913 : unsigned blocksize)
1914 : {
1915 28933 : unsigned rec_len = 0;
1916 :
1917 1123882 : while (count--) {
1918 1094949 : struct ext4_dir_entry_2 *de = (struct ext4_dir_entry_2 *)
1919 1094949 : (from + (map->offs<<2));
1920 1094949 : rec_len = ext4_dir_rec_len(de->name_len, dir);
1921 :
1922 2189898 : memcpy (to, de, rec_len);
1923 1094949 : ((struct ext4_dir_entry_2 *) to)->rec_len =
1924 : ext4_rec_len_to_disk(rec_len, blocksize);
1925 :
1926 : /* wipe dir_entry excluding the rec_len field */
1927 1094949 : de->inode = 0;
1928 1094949 : memset(&de->name_len, 0, ext4_rec_len_from_disk(de->rec_len,
1929 : blocksize) -
1930 : offsetof(struct ext4_dir_entry_2,
1931 : name_len));
1932 :
1933 1094949 : map++;
1934 1094949 : to += rec_len;
1935 : }
1936 28933 : return (struct ext4_dir_entry_2 *) (to - rec_len);
1937 : }
1938 :
1939 : /*
1940 : * Compact each dir entry in the range to the minimal rec_len.
1941 : * Returns pointer to last entry in range.
1942 : */
1943 28933 : static struct ext4_dir_entry_2 *dx_pack_dirents(struct inode *dir, char *base,
1944 : unsigned int blocksize)
1945 : {
1946 28933 : struct ext4_dir_entry_2 *next, *to, *prev, *de = (struct ext4_dir_entry_2 *) base;
1947 28933 : unsigned rec_len = 0;
1948 :
1949 28933 : prev = to = de;
1950 2237074 : while ((char*)de < base + blocksize) {
1951 2208141 : next = ext4_next_entry(de, blocksize);
1952 2208141 : if (de->inode && de->name_len) {
1953 1084304 : rec_len = ext4_dir_rec_len(de->name_len, dir);
1954 1084304 : if (de > to)
1955 1572490 : memmove(to, de, rec_len);
1956 1084304 : to->rec_len = ext4_rec_len_to_disk(rec_len, blocksize);
1957 1084304 : prev = to;
1958 1084304 : to = (struct ext4_dir_entry_2 *) (((char *) to) + rec_len);
1959 : }
1960 : de = next;
1961 : }
1962 28933 : return prev;
1963 : }
1964 :
1965 : /*
1966 : * Split a full leaf block to make room for a new dir entry.
1967 : * Allocate a new block, and move entries so that they are approx. equally full.
1968 : * Returns pointer to de in block into which the new entry will be inserted.
1969 : */
1970 29180 : static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
1971 : struct buffer_head **bh,struct dx_frame *frame,
1972 : struct dx_hash_info *hinfo)
1973 : {
1974 29180 : unsigned blocksize = dir->i_sb->s_blocksize;
1975 29180 : unsigned continued;
1976 29180 : int count;
1977 29180 : struct buffer_head *bh2;
1978 29180 : ext4_lblk_t newblock;
1979 29180 : u32 hash2;
1980 29180 : struct dx_map_entry *map;
1981 29180 : char *data1 = (*bh)->b_data, *data2;
1982 29180 : unsigned split, move, size;
1983 29180 : struct ext4_dir_entry_2 *de = NULL, *de2;
1984 29180 : int csum_size = 0;
1985 29180 : int err = 0, i;
1986 :
1987 29180 : if (ext4_has_metadata_csum(dir->i_sb))
1988 29180 : csum_size = sizeof(struct ext4_dir_entry_tail);
1989 :
1990 29180 : bh2 = ext4_append(handle, dir, &newblock);
1991 29180 : if (IS_ERR(bh2)) {
1992 247 : brelse(*bh);
1993 247 : *bh = NULL;
1994 247 : return (struct ext4_dir_entry_2 *) bh2;
1995 : }
1996 :
1997 28933 : BUFFER_TRACE(*bh, "get_write_access");
1998 28933 : err = ext4_journal_get_write_access(handle, dir->i_sb, *bh,
1999 : EXT4_JTR_NONE);
2000 28933 : if (err)
2001 0 : goto journal_error;
2002 :
2003 28933 : BUFFER_TRACE(frame->bh, "get_write_access");
2004 28933 : err = ext4_journal_get_write_access(handle, dir->i_sb, frame->bh,
2005 : EXT4_JTR_NONE);
2006 28933 : if (err)
2007 0 : goto journal_error;
2008 :
2009 28933 : data2 = bh2->b_data;
2010 :
2011 : /* create map in the end of data2 block */
2012 28933 : map = (struct dx_map_entry *) (data2 + blocksize);
2013 28933 : count = dx_make_map(dir, *bh, hinfo, map);
2014 28933 : if (count < 0) {
2015 0 : err = count;
2016 0 : goto journal_error;
2017 : }
2018 28933 : map -= count;
2019 28933 : dx_sort_map(map, count);
2020 : /* Ensure that neither split block is over half full */
2021 28933 : size = 0;
2022 28933 : move = 0;
2023 1123901 : for (i = count-1; i >= 0; i--) {
2024 : /* is more than half of this entry in 2nd half of the block? */
2025 1123901 : if (size + map[i].size/2 > blocksize/2)
2026 : break;
2027 1094968 : size += map[i].size;
2028 1094968 : move++;
2029 : }
2030 : /*
2031 : * map index at which we will split
2032 : *
2033 : * If the sum of active entries didn't exceed half the block size, just
2034 : * split it in half by count; each resulting block will have at least
2035 : * half the space free.
2036 : */
2037 28933 : if (i > 0)
2038 28933 : split = count - move;
2039 : else
2040 0 : split = count/2;
2041 :
2042 28933 : hash2 = map[split].hash;
2043 28933 : continued = hash2 == map[split - 1].hash;
2044 : dxtrace(printk(KERN_INFO "Split block %lu at %x, %i/%i\n",
2045 : (unsigned long)dx_get_block(frame->at),
2046 28933 : hash2, split, count-split));
2047 :
2048 : /* Fancy dance to stay within two buffers */
2049 28933 : de2 = dx_move_dirents(dir, data1, data2, map + split, count - split,
2050 : blocksize);
2051 28933 : de = dx_pack_dirents(dir, data1, blocksize);
2052 28933 : de->rec_len = ext4_rec_len_to_disk(data1 + (blocksize - csum_size) -
2053 : (char *) de,
2054 : blocksize);
2055 28933 : de2->rec_len = ext4_rec_len_to_disk(data2 + (blocksize - csum_size) -
2056 : (char *) de2,
2057 : blocksize);
2058 28933 : if (csum_size) {
2059 28933 : ext4_initialize_dirent_tail(*bh, blocksize);
2060 28933 : ext4_initialize_dirent_tail(bh2, blocksize);
2061 : }
2062 :
2063 : dxtrace(dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *) data1,
2064 28933 : blocksize, 1));
2065 : dxtrace(dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *) data2,
2066 28933 : blocksize, 1));
2067 :
2068 : /* Which block gets the new entry? */
2069 28933 : if (hinfo->hash >= hash2) {
2070 14438 : swap(*bh, bh2);
2071 14438 : de = de2;
2072 : }
2073 28933 : dx_insert_block(frame, hash2 + continued, newblock);
2074 28933 : err = ext4_handle_dirty_dirblock(handle, dir, bh2);
2075 28933 : if (err)
2076 0 : goto journal_error;
2077 28933 : err = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
2078 28933 : if (err)
2079 0 : goto journal_error;
2080 28933 : brelse(bh2);
2081 : dxtrace(dx_show_index("frame", frame->entries));
2082 : return de;
2083 :
2084 0 : journal_error:
2085 0 : brelse(*bh);
2086 0 : brelse(bh2);
2087 0 : *bh = NULL;
2088 0 : ext4_std_error(dir->i_sb, err);
2089 0 : return ERR_PTR(err);
2090 : }
2091 :
2092 2899308 : int ext4_find_dest_de(struct inode *dir, struct inode *inode,
2093 : struct buffer_head *bh,
2094 : void *buf, int buf_size,
2095 : struct ext4_filename *fname,
2096 : struct ext4_dir_entry_2 **dest_de)
2097 : {
2098 2899308 : struct ext4_dir_entry_2 *de;
2099 2899308 : unsigned short reclen = ext4_dir_rec_len(fname_len(fname), dir);
2100 2899308 : int nlen, rlen;
2101 2899308 : unsigned int offset = 0;
2102 2899308 : char *top;
2103 :
2104 2899308 : de = buf;
2105 2899308 : top = buf + buf_size - reclen;
2106 266917807 : while ((char *) de <= top) {
2107 266888587 : if (ext4_check_dir_entry(dir, NULL, de, bh,
2108 : buf, buf_size, offset))
2109 : return -EFSCORRUPTED;
2110 267068388 : if (ext4_match(dir, fname, de))
2111 : return -EEXIST;
2112 266893660 : nlen = ext4_dir_rec_len(de->name_len, dir);
2113 266893660 : rlen = ext4_rec_len_from_disk(de->rec_len, buf_size);
2114 266893660 : if ((de->inode ? rlen - nlen : rlen) >= reclen)
2115 : break;
2116 264018499 : de = (struct ext4_dir_entry_2 *)((char *)de + rlen);
2117 264018499 : offset += rlen;
2118 : }
2119 2904381 : if ((char *) de > top)
2120 : return -ENOSPC;
2121 :
2122 2875192 : *dest_de = de;
2123 2875192 : return 0;
2124 : }
2125 :
2126 2904347 : void ext4_insert_dentry(struct inode *dir,
2127 : struct inode *inode,
2128 : struct ext4_dir_entry_2 *de,
2129 : int buf_size,
2130 : struct ext4_filename *fname)
2131 : {
2132 :
2133 2904347 : int nlen, rlen;
2134 :
2135 2904347 : nlen = ext4_dir_rec_len(de->name_len, dir);
2136 2904347 : rlen = ext4_rec_len_from_disk(de->rec_len, buf_size);
2137 2904347 : if (de->inode) {
2138 2904190 : struct ext4_dir_entry_2 *de1 =
2139 2904190 : (struct ext4_dir_entry_2 *)((char *)de + nlen);
2140 2904190 : de1->rec_len = ext4_rec_len_to_disk(rlen - nlen, buf_size);
2141 2904190 : de->rec_len = ext4_rec_len_to_disk(nlen, buf_size);
2142 2904190 : de = de1;
2143 : }
2144 2904347 : de->file_type = EXT4_FT_UNKNOWN;
2145 2904347 : de->inode = cpu_to_le32(inode->i_ino);
2146 2904347 : ext4_set_de_type(inode->i_sb, de, inode->i_mode);
2147 2904335 : de->name_len = fname_len(fname);
2148 5808670 : memcpy(de->name, fname_name(fname), fname_len(fname));
2149 2904335 : if (ext4_hash_in_dirent(dir)) {
2150 0 : struct dx_hash_info *hinfo = &fname->hinfo;
2151 :
2152 0 : EXT4_DIRENT_HASHES(de)->hash = cpu_to_le32(hinfo->hash);
2153 0 : EXT4_DIRENT_HASHES(de)->minor_hash =
2154 0 : cpu_to_le32(hinfo->minor_hash);
2155 : }
2156 2904335 : }
2157 :
2158 : /*
2159 : * Add a new entry into a directory (leaf) block. If de is non-NULL,
2160 : * it points to a directory entry which is guaranteed to be large
2161 : * enough for new directory entry. If de is NULL, then
2162 : * add_dirent_to_buf will attempt search the directory block for
2163 : * space. It will return -ENOSPC if no space is available, and -EIO
2164 : * and -EEXIST if directory entry already exists.
2165 : */
2166 2928732 : static int add_dirent_to_buf(handle_t *handle, struct ext4_filename *fname,
2167 : struct inode *dir,
2168 : struct inode *inode, struct ext4_dir_entry_2 *de,
2169 : struct buffer_head *bh)
2170 : {
2171 2928732 : unsigned int blocksize = dir->i_sb->s_blocksize;
2172 2928732 : int csum_size = 0;
2173 2928732 : int err, err2;
2174 :
2175 2928732 : if (ext4_has_metadata_csum(inode->i_sb))
2176 2927695 : csum_size = sizeof(struct ext4_dir_entry_tail);
2177 :
2178 2926912 : if (!de) {
2179 2899644 : err = ext4_find_dest_de(dir, inode, bh, bh->b_data,
2180 2899644 : blocksize - csum_size, fname, &de);
2181 2903978 : if (err)
2182 : return err;
2183 : }
2184 2902057 : BUFFER_TRACE(bh, "get_write_access");
2185 2902057 : err = ext4_journal_get_write_access(handle, dir->i_sb, bh,
2186 : EXT4_JTR_NONE);
2187 2904360 : if (err) {
2188 0 : ext4_std_error(dir->i_sb, err);
2189 0 : return err;
2190 : }
2191 :
2192 : /* By now the buffer is marked for journaling */
2193 2904360 : ext4_insert_dentry(dir, inode, de, blocksize, fname);
2194 :
2195 : /*
2196 : * XXX shouldn't update any times until successful
2197 : * completion of syscall, but too many callers depend
2198 : * on this.
2199 : *
2200 : * XXX similarly, too many callers depend on
2201 : * ext4_new_inode() setting the times, but error
2202 : * recovery deletes the inode, so the worst that can
2203 : * happen is that the times are slightly out of date
2204 : * and/or different from the directory change time.
2205 : */
2206 2903815 : dir->i_mtime = dir->i_ctime = current_time(dir);
2207 2903364 : ext4_update_dx_flag(dir);
2208 2903480 : inode_inc_iversion(dir);
2209 2903742 : err2 = ext4_mark_inode_dirty(handle, dir);
2210 2904429 : BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
2211 2904429 : err = ext4_handle_dirty_dirblock(handle, dir, bh);
2212 2902841 : if (err)
2213 0 : ext4_std_error(dir->i_sb, err);
2214 2902841 : return err ? err : err2;
2215 : }
2216 :
2217 : /*
2218 : * This converts a one block unindexed directory to a 3 block indexed
2219 : * directory, and adds the dentry to the indexed directory.
2220 : */
2221 1285 : static int make_indexed_dir(handle_t *handle, struct ext4_filename *fname,
2222 : struct inode *dir,
2223 : struct inode *inode, struct buffer_head *bh)
2224 : {
2225 1285 : struct buffer_head *bh2;
2226 1285 : struct dx_root *root;
2227 1285 : struct dx_frame frames[EXT4_HTREE_LEVEL], *frame;
2228 1285 : struct dx_entry *entries;
2229 1285 : struct ext4_dir_entry_2 *de, *de2;
2230 1285 : char *data2, *top;
2231 1285 : unsigned len;
2232 1285 : int retval;
2233 1285 : unsigned blocksize;
2234 1285 : ext4_lblk_t block;
2235 1285 : struct fake_dirent *fde;
2236 1285 : int csum_size = 0;
2237 :
2238 1285 : if (ext4_has_metadata_csum(inode->i_sb))
2239 1285 : csum_size = sizeof(struct ext4_dir_entry_tail);
2240 :
2241 1285 : blocksize = dir->i_sb->s_blocksize;
2242 1285 : dxtrace(printk(KERN_DEBUG "Creating index: inode %lu\n", dir->i_ino));
2243 1285 : BUFFER_TRACE(bh, "get_write_access");
2244 1285 : retval = ext4_journal_get_write_access(handle, dir->i_sb, bh,
2245 : EXT4_JTR_NONE);
2246 1285 : if (retval) {
2247 0 : ext4_std_error(dir->i_sb, retval);
2248 0 : brelse(bh);
2249 0 : return retval;
2250 : }
2251 1285 : root = (struct dx_root *) bh->b_data;
2252 :
2253 : /* The 0th block becomes the root, move the dirents out */
2254 1285 : fde = &root->dotdot;
2255 1285 : de = (struct ext4_dir_entry_2 *)((char *)fde +
2256 1285 : ext4_rec_len_from_disk(fde->rec_len, blocksize));
2257 1285 : if ((char *) de >= (((char *) root) + blocksize)) {
2258 0 : EXT4_ERROR_INODE(dir, "invalid rec_len for '..'");
2259 0 : brelse(bh);
2260 0 : return -EFSCORRUPTED;
2261 : }
2262 1285 : len = ((char *) root) + (blocksize - csum_size) - (char *) de;
2263 :
2264 : /* Allocate new block for the 0th block's dirents */
2265 1285 : bh2 = ext4_append(handle, dir, &block);
2266 1285 : if (IS_ERR(bh2)) {
2267 4 : brelse(bh);
2268 4 : return PTR_ERR(bh2);
2269 : }
2270 1281 : ext4_set_inode_flag(dir, EXT4_INODE_INDEX);
2271 1281 : data2 = bh2->b_data;
2272 :
2273 2562 : memcpy(data2, de, len);
2274 1281 : memset(de, 0, len); /* wipe old data */
2275 1281 : de = (struct ext4_dir_entry_2 *) data2;
2276 1281 : top = data2 + len;
2277 315565 : while ((char *)(de2 = ext4_next_entry(de, blocksize)) < top) {
2278 314284 : if (ext4_check_dir_entry(dir, NULL, de, bh2, data2, len,
2279 : (data2 + (blocksize - csum_size) -
2280 : (char *) de))) {
2281 0 : brelse(bh2);
2282 0 : brelse(bh);
2283 0 : return -EFSCORRUPTED;
2284 : }
2285 : de = de2;
2286 : }
2287 1281 : de->rec_len = ext4_rec_len_to_disk(data2 + (blocksize - csum_size) -
2288 : (char *) de, blocksize);
2289 :
2290 1281 : if (csum_size)
2291 1281 : ext4_initialize_dirent_tail(bh2, blocksize);
2292 :
2293 : /* Initialize the root; the dot dirents already exist */
2294 1281 : de = (struct ext4_dir_entry_2 *) (&root->dotdot);
2295 1281 : de->rec_len = ext4_rec_len_to_disk(
2296 : blocksize - ext4_dir_rec_len(2, NULL), blocksize);
2297 1281 : memset (&root->info, 0, sizeof(root->info));
2298 1281 : root->info.info_length = sizeof(root->info);
2299 1281 : if (ext4_hash_in_dirent(dir))
2300 0 : root->info.hash_version = DX_HASH_SIPHASH;
2301 : else
2302 1281 : root->info.hash_version =
2303 1281 : EXT4_SB(dir->i_sb)->s_def_hash_version;
2304 :
2305 1281 : entries = root->entries;
2306 1281 : dx_set_block(entries, 1);
2307 1281 : dx_set_count(entries, 1);
2308 1281 : dx_set_limit(entries, dx_root_limit(dir, sizeof(root->info)));
2309 :
2310 : /* Initialize as for dx_probe */
2311 1281 : fname->hinfo.hash_version = root->info.hash_version;
2312 1281 : if (fname->hinfo.hash_version <= DX_HASH_TEA)
2313 1281 : fname->hinfo.hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
2314 1281 : fname->hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
2315 :
2316 : /* casefolded encrypted hashes are computed on fname setup */
2317 1281 : if (!ext4_hash_in_dirent(dir)) {
2318 1281 : int err = ext4fs_dirhash(dir, fname_name(fname),
2319 1281 : fname_len(fname), &fname->hinfo);
2320 1281 : if (err < 0) {
2321 0 : brelse(bh2);
2322 0 : brelse(bh);
2323 0 : return err;
2324 : }
2325 : }
2326 1281 : memset(frames, 0, sizeof(frames));
2327 1281 : frame = frames;
2328 1281 : frame->entries = entries;
2329 1281 : frame->at = entries;
2330 1281 : frame->bh = bh;
2331 :
2332 1281 : retval = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
2333 1281 : if (retval)
2334 0 : goto out_frames;
2335 1281 : retval = ext4_handle_dirty_dirblock(handle, dir, bh2);
2336 1281 : if (retval)
2337 0 : goto out_frames;
2338 :
2339 1281 : de = do_split(handle,dir, &bh2, frame, &fname->hinfo);
2340 1281 : if (IS_ERR(de)) {
2341 0 : retval = PTR_ERR(de);
2342 0 : goto out_frames;
2343 : }
2344 :
2345 1281 : retval = add_dirent_to_buf(handle, fname, dir, inode, de, bh2);
2346 1281 : out_frames:
2347 : /*
2348 : * Even if the block split failed, we have to properly write
2349 : * out all the changes we did so far. Otherwise we can end up
2350 : * with corrupted filesystem.
2351 : */
2352 1281 : if (retval)
2353 0 : ext4_mark_inode_dirty(handle, dir);
2354 1281 : dx_release(frames);
2355 1281 : brelse(bh2);
2356 : return retval;
2357 : }
2358 :
2359 : /*
2360 : * ext4_add_entry()
2361 : *
2362 : * adds a file entry to the specified directory, using the same
2363 : * semantics as ext4_find_entry(). It returns NULL if it failed.
2364 : *
2365 : * NOTE!! The inode part of 'de' is left at 0 - which means you
2366 : * may not sleep between calling this and putting something into
2367 : * the entry, as someone else might have used it while you slept.
2368 : */
2369 2900091 : static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
2370 : struct inode *inode)
2371 : {
2372 2900091 : struct inode *dir = d_inode(dentry->d_parent);
2373 2900091 : struct buffer_head *bh = NULL;
2374 2900091 : struct ext4_dir_entry_2 *de;
2375 2900091 : struct super_block *sb;
2376 2900091 : struct ext4_filename fname;
2377 2900091 : int retval;
2378 2900091 : int dx_fallback=0;
2379 2900091 : unsigned blocksize;
2380 2900091 : ext4_lblk_t block, blocks;
2381 2900091 : int csum_size = 0;
2382 :
2383 2900091 : if (ext4_has_metadata_csum(inode->i_sb))
2384 2895522 : csum_size = sizeof(struct ext4_dir_entry_tail);
2385 :
2386 2897748 : sb = dir->i_sb;
2387 2897748 : blocksize = sb->s_blocksize;
2388 2897748 : if (!dentry->d_name.len)
2389 : return -EINVAL;
2390 :
2391 2897748 : if (fscrypt_is_nokey_name(dentry))
2392 : return -ENOKEY;
2393 :
2394 : #if IS_ENABLED(CONFIG_UNICODE)
2395 2897748 : if (sb_has_strict_encoding(sb) && IS_CASEFOLDED(dir) &&
2396 0 : sb->s_encoding && utf8_validate(sb->s_encoding, &dentry->d_name))
2397 : return -EINVAL;
2398 : #endif
2399 :
2400 2897748 : retval = ext4_fname_setup_filename(dir, &dentry->d_name, 0, &fname);
2401 2897580 : if (retval)
2402 : return retval;
2403 :
2404 2897580 : if (ext4_has_inline_data(dir)) {
2405 0 : retval = ext4_try_add_inline_entry(handle, &fname, dir, inode);
2406 0 : if (retval < 0)
2407 0 : goto out;
2408 0 : if (retval == 1) {
2409 0 : retval = 0;
2410 0 : goto out;
2411 : }
2412 : }
2413 :
2414 2897580 : if (is_dx(dir)) {
2415 1772930 : retval = ext4_dx_add_entry(handle, &fname, dir, inode);
2416 1776480 : if (!retval || (retval != ERR_BAD_DX_DIR))
2417 1776480 : goto out;
2418 : /* Can we just ignore htree data? */
2419 0 : if (ext4_has_metadata_csum(sb)) {
2420 0 : EXT4_ERROR_INODE(dir,
2421 : "Directory has corrupted htree index.");
2422 0 : retval = -EFSCORRUPTED;
2423 0 : goto out;
2424 : }
2425 0 : ext4_clear_inode_flag(dir, EXT4_INODE_INDEX);
2426 0 : dx_fallback++;
2427 0 : retval = ext4_mark_inode_dirty(handle, dir);
2428 0 : if (unlikely(retval))
2429 0 : goto out;
2430 : }
2431 1124650 : blocks = dir->i_size >> sb->s_blocksize_bits;
2432 1124650 : for (block = 0; block < blocks; block++) {
2433 1124650 : bh = ext4_read_dirblock(dir, block, DIRENT);
2434 1124061 : if (bh == NULL) {
2435 0 : bh = ext4_bread(handle, dir, block,
2436 : EXT4_GET_BLOCKS_CREATE);
2437 0 : goto add_to_new_block;
2438 : }
2439 1124061 : if (IS_ERR(bh)) {
2440 0 : retval = PTR_ERR(bh);
2441 0 : bh = NULL;
2442 0 : goto out;
2443 : }
2444 1124061 : retval = add_dirent_to_buf(handle, &fname, dir, inode,
2445 : NULL, bh);
2446 1126603 : if (retval != -ENOSPC)
2447 1125318 : goto out;
2448 :
2449 1285 : if (blocks == 1 && !dx_fallback &&
2450 : ext4_has_feature_dir_index(sb)) {
2451 1285 : retval = make_indexed_dir(handle, &fname, dir,
2452 : inode, bh);
2453 1285 : bh = NULL; /* make_indexed_dir releases bh */
2454 1285 : goto out;
2455 : }
2456 0 : brelse(bh);
2457 : }
2458 0 : bh = ext4_append(handle, dir, &block);
2459 0 : add_to_new_block:
2460 0 : if (IS_ERR(bh)) {
2461 0 : retval = PTR_ERR(bh);
2462 0 : bh = NULL;
2463 0 : goto out;
2464 : }
2465 0 : de = (struct ext4_dir_entry_2 *) bh->b_data;
2466 0 : de->inode = 0;
2467 0 : de->rec_len = ext4_rec_len_to_disk(blocksize - csum_size, blocksize);
2468 :
2469 0 : if (csum_size)
2470 0 : ext4_initialize_dirent_tail(bh, blocksize);
2471 :
2472 0 : retval = add_dirent_to_buf(handle, &fname, dir, inode, de, bh);
2473 2903083 : out:
2474 2903083 : ext4_fname_free_filename(&fname);
2475 2902718 : brelse(bh);
2476 2903121 : if (retval == 0)
2477 2902870 : ext4_set_inode_state(inode, EXT4_STATE_NEWENTRY);
2478 : return retval;
2479 : }
2480 :
2481 : /*
2482 : * Returns 0 for success, or a negative error value
2483 : */
2484 1773883 : static int ext4_dx_add_entry(handle_t *handle, struct ext4_filename *fname,
2485 : struct inode *dir, struct inode *inode)
2486 : {
2487 1773883 : struct dx_frame frames[EXT4_HTREE_LEVEL], *frame;
2488 1773883 : struct dx_entry *entries, *at;
2489 1773883 : struct buffer_head *bh;
2490 1773883 : struct super_block *sb = dir->i_sb;
2491 1773888 : struct ext4_dir_entry_2 *de;
2492 1773888 : int restart;
2493 1773888 : int err;
2494 :
2495 1773888 : again:
2496 1773888 : restart = 0;
2497 1773888 : frame = dx_probe(fname, dir, NULL, frames);
2498 1772628 : if (IS_ERR(frame))
2499 0 : return PTR_ERR(frame);
2500 1772628 : entries = frame->entries;
2501 1772628 : at = frame->at;
2502 1772628 : bh = ext4_read_dirblock(dir, dx_get_block(frame->at), DIRENT_HTREE);
2503 1776435 : if (IS_ERR(bh)) {
2504 0 : err = PTR_ERR(bh);
2505 0 : bh = NULL;
2506 0 : goto cleanup;
2507 : }
2508 :
2509 1776435 : BUFFER_TRACE(bh, "get_write_access");
2510 1776435 : err = ext4_journal_get_write_access(handle, sb, bh, EXT4_JTR_NONE);
2511 1776728 : if (err)
2512 0 : goto journal_error;
2513 :
2514 1776728 : err = add_dirent_to_buf(handle, fname, dir, inode, NULL, bh);
2515 1776227 : if (err != -ENOSPC)
2516 1748323 : goto cleanup;
2517 :
2518 27904 : err = 0;
2519 : /* Block full, should compress but for now just split */
2520 : dxtrace(printk(KERN_DEBUG "using %u of %u node entries\n",
2521 27904 : dx_get_count(entries), dx_get_limit(entries)));
2522 : /* Need to split index? */
2523 27904 : if (dx_get_count(entries) == dx_get_limit(entries)) {
2524 201 : ext4_lblk_t newblock;
2525 201 : int levels = frame - frames + 1;
2526 201 : unsigned int icount;
2527 201 : int add_level = 1;
2528 201 : struct dx_entry *entries2;
2529 201 : struct dx_node *node2;
2530 201 : struct buffer_head *bh2;
2531 :
2532 203 : while (frame > frames) {
2533 199 : if (dx_get_count((frame - 1)->entries) <
2534 : dx_get_limit((frame - 1)->entries)) {
2535 : add_level = 0;
2536 : break;
2537 : }
2538 2 : frame--; /* split higher index block */
2539 2 : at = frame->at;
2540 2 : entries = frame->entries;
2541 2 : restart = 1;
2542 : }
2543 205 : if (add_level && levels == ext4_dir_htree_level(sb)) {
2544 0 : ext4_warning(sb, "Directory (ino: %lu) index full, "
2545 : "reach max htree level :%d",
2546 : dir->i_ino, levels);
2547 0 : if (ext4_dir_htree_level(sb) < EXT4_HTREE_LEVEL) {
2548 0 : ext4_warning(sb, "Large directory feature is "
2549 : "not enabled on this "
2550 : "filesystem");
2551 : }
2552 0 : err = -ENOSPC;
2553 0 : goto cleanup;
2554 : }
2555 201 : icount = dx_get_count(entries);
2556 201 : bh2 = ext4_append(handle, dir, &newblock);
2557 201 : if (IS_ERR(bh2)) {
2558 0 : err = PTR_ERR(bh2);
2559 0 : goto cleanup;
2560 : }
2561 201 : node2 = (struct dx_node *)(bh2->b_data);
2562 201 : entries2 = node2->entries;
2563 201 : memset(&node2->fake, 0, sizeof(struct fake_dirent));
2564 402 : node2->fake.rec_len = ext4_rec_len_to_disk(sb->s_blocksize,
2565 201 : sb->s_blocksize);
2566 201 : BUFFER_TRACE(frame->bh, "get_write_access");
2567 201 : err = ext4_journal_get_write_access(handle, sb, frame->bh,
2568 : EXT4_JTR_NONE);
2569 201 : if (err)
2570 5 : goto journal_error;
2571 201 : if (!add_level) {
2572 197 : unsigned icount1 = icount/2, icount2 = icount - icount1;
2573 197 : unsigned hash2 = dx_get_hash(entries + icount1);
2574 : dxtrace(printk(KERN_DEBUG "Split index %i/%i\n",
2575 197 : icount1, icount2));
2576 :
2577 197 : BUFFER_TRACE(frame->bh, "get_write_access"); /* index root */
2578 197 : err = ext4_journal_get_write_access(handle, sb,
2579 : (frame - 1)->bh,
2580 : EXT4_JTR_NONE);
2581 197 : if (err)
2582 0 : goto journal_error;
2583 :
2584 394 : memcpy((char *) entries2, (char *) (entries + icount1),
2585 : icount2 * sizeof(struct dx_entry));
2586 197 : dx_set_count(entries, icount1);
2587 197 : dx_set_count(entries2, icount2);
2588 197 : dx_set_limit(entries2, dx_node_limit(dir));
2589 :
2590 : /* Which index block gets the new entry? */
2591 197 : if (at - entries >= icount1) {
2592 97 : frame->at = at - entries - icount1 + entries2;
2593 97 : frame->entries = entries = entries2;
2594 97 : swap(frame->bh, bh2);
2595 : }
2596 197 : dx_insert_block((frame - 1), hash2, newblock);
2597 197 : dxtrace(dx_show_index("node", frame->entries));
2598 : dxtrace(dx_show_index("node",
2599 197 : ((struct dx_node *) bh2->b_data)->entries));
2600 197 : err = ext4_handle_dirty_dx_node(handle, dir, bh2);
2601 197 : if (err)
2602 0 : goto journal_error;
2603 197 : brelse (bh2);
2604 197 : err = ext4_handle_dirty_dx_node(handle, dir,
2605 : (frame - 1)->bh);
2606 197 : if (err)
2607 0 : goto journal_error;
2608 197 : err = ext4_handle_dirty_dx_node(handle, dir,
2609 : frame->bh);
2610 197 : if (restart || err)
2611 1 : goto journal_error;
2612 : } else {
2613 4 : struct dx_root *dxroot;
2614 8 : memcpy((char *) entries2, (char *) entries,
2615 : icount * sizeof(struct dx_entry));
2616 4 : dx_set_limit(entries2, dx_node_limit(dir));
2617 :
2618 : /* Set up root */
2619 4 : dx_set_count(entries, 1);
2620 4 : dx_set_block(entries + 0, newblock);
2621 4 : dxroot = (struct dx_root *)frames[0].bh->b_data;
2622 4 : dxroot->info.indirect_levels += 1;
2623 : dxtrace(printk(KERN_DEBUG
2624 : "Creating %d level index...\n",
2625 4 : dxroot->info.indirect_levels));
2626 4 : err = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
2627 4 : if (err)
2628 0 : goto journal_error;
2629 4 : err = ext4_handle_dirty_dx_node(handle, dir, bh2);
2630 4 : brelse(bh2);
2631 4 : restart = 1;
2632 4 : goto journal_error;
2633 : }
2634 : }
2635 27899 : de = do_split(handle, dir, &bh, frame, &fname->hinfo);
2636 27899 : if (IS_ERR(de)) {
2637 247 : err = PTR_ERR(de);
2638 247 : goto cleanup;
2639 : }
2640 27652 : err = add_dirent_to_buf(handle, fname, dir, inode, de, bh);
2641 27652 : goto cleanup;
2642 :
2643 5 : journal_error:
2644 5 : ext4_std_error(dir->i_sb, err); /* this is a no-op if err == 0 */
2645 5 : cleanup:
2646 1776227 : brelse(bh);
2647 1777112 : dx_release(frames);
2648 : /* @restart is true means htree-path has been changed, we need to
2649 : * repeat dx_probe() to find out valid htree-path
2650 : */
2651 1776469 : if (restart && err == 0)
2652 5 : goto again;
2653 : return err;
2654 : }
2655 :
2656 : /*
2657 : * ext4_generic_delete_entry deletes a directory entry by merging it
2658 : * with the previous entry
2659 : */
2660 2067855 : int ext4_generic_delete_entry(struct inode *dir,
2661 : struct ext4_dir_entry_2 *de_del,
2662 : struct buffer_head *bh,
2663 : void *entry_buf,
2664 : int buf_size,
2665 : int csum_size)
2666 : {
2667 2067855 : struct ext4_dir_entry_2 *de, *pde;
2668 2067855 : unsigned int blocksize = dir->i_sb->s_blocksize;
2669 2067855 : int i;
2670 :
2671 2067855 : i = 0;
2672 2067855 : pde = NULL;
2673 2067855 : de = entry_buf;
2674 65610480 : while (i < buf_size - csum_size) {
2675 65610480 : if (ext4_check_dir_entry(dir, NULL, de, bh,
2676 : entry_buf, buf_size, i))
2677 : return -EFSCORRUPTED;
2678 65610975 : if (de == de_del) {
2679 2068350 : if (pde) {
2680 4110438 : pde->rec_len = ext4_rec_len_to_disk(
2681 2055219 : ext4_rec_len_from_disk(pde->rec_len,
2682 : blocksize) +
2683 2055219 : ext4_rec_len_from_disk(de->rec_len,
2684 : blocksize),
2685 : blocksize);
2686 :
2687 : /* wipe entire dir_entry */
2688 4110438 : memset(de, 0, ext4_rec_len_from_disk(de->rec_len,
2689 : blocksize));
2690 : } else {
2691 : /* wipe dir_entry excluding the rec_len field */
2692 13131 : de->inode = 0;
2693 26262 : memset(&de->name_len, 0,
2694 : ext4_rec_len_from_disk(de->rec_len,
2695 : blocksize) -
2696 : offsetof(struct ext4_dir_entry_2,
2697 : name_len));
2698 : }
2699 :
2700 2068350 : inode_inc_iversion(dir);
2701 2068350 : return 0;
2702 : }
2703 63542625 : i += ext4_rec_len_from_disk(de->rec_len, blocksize);
2704 63542625 : pde = de;
2705 63542625 : de = ext4_next_entry(de, blocksize);
2706 : }
2707 : return -ENOENT;
2708 : }
2709 :
2710 2067342 : static int ext4_delete_entry(handle_t *handle,
2711 : struct inode *dir,
2712 : struct ext4_dir_entry_2 *de_del,
2713 : struct buffer_head *bh)
2714 : {
2715 2067342 : int err, csum_size = 0;
2716 :
2717 2067342 : if (ext4_has_inline_data(dir)) {
2718 0 : int has_inline_data = 1;
2719 0 : err = ext4_delete_inline_entry(handle, dir, de_del, bh,
2720 : &has_inline_data);
2721 0 : if (has_inline_data)
2722 0 : return err;
2723 : }
2724 :
2725 2067342 : if (ext4_has_metadata_csum(dir->i_sb))
2726 2066544 : csum_size = sizeof(struct ext4_dir_entry_tail);
2727 :
2728 2066415 : BUFFER_TRACE(bh, "get_write_access");
2729 2066415 : err = ext4_journal_get_write_access(handle, dir->i_sb, bh,
2730 : EXT4_JTR_NONE);
2731 2068394 : if (unlikely(err))
2732 0 : goto out;
2733 :
2734 2068394 : err = ext4_generic_delete_entry(dir, de_del, bh, bh->b_data,
2735 2068394 : dir->i_sb->s_blocksize, csum_size);
2736 2068613 : if (err)
2737 0 : goto out;
2738 :
2739 2068613 : BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
2740 2068613 : err = ext4_handle_dirty_dirblock(handle, dir, bh);
2741 2067073 : if (unlikely(err))
2742 0 : goto out;
2743 :
2744 : return 0;
2745 0 : out:
2746 0 : if (err != -ENOENT)
2747 0 : ext4_std_error(dir->i_sb, err);
2748 : return err;
2749 : }
2750 :
2751 : /*
2752 : * Set directory link count to 1 if nlinks > EXT4_LINK_MAX, or if nlinks == 2
2753 : * since this indicates that nlinks count was previously 1 to avoid overflowing
2754 : * the 16-bit i_links_count field on disk. Directories with i_nlink == 1 mean
2755 : * that subdirectory link counts are not being maintained accurately.
2756 : *
2757 : * The caller has already checked for i_nlink overflow in case the DIR_LINK
2758 : * feature is not enabled and returned -EMLINK. The is_dx() check is a proxy
2759 : * for checking S_ISDIR(inode) (since the INODE_INDEX feature will not be set
2760 : * on regular files) and to avoid creating huge/slow non-HTREE directories.
2761 : */
2762 546519 : static void ext4_inc_count(struct inode *inode)
2763 : {
2764 546519 : inc_nlink(inode);
2765 546421 : if (is_dx(inode) &&
2766 245610 : (inode->i_nlink > EXT4_LINK_MAX || inode->i_nlink == 2))
2767 36080 : set_nlink(inode, 1);
2768 546421 : }
2769 :
2770 : /*
2771 : * If a directory had nlink == 1, then we should let it be 1. This indicates
2772 : * directory has >EXT4_LINK_MAX subdirs.
2773 : */
2774 351663 : static void ext4_dec_count(struct inode *inode)
2775 : {
2776 351663 : if (!S_ISDIR(inode->i_mode) || inode->i_nlink > 2)
2777 220430 : drop_nlink(inode);
2778 351662 : }
2779 :
2780 :
2781 : /*
2782 : * Add non-directory inode to a directory. On success, the inode reference is
2783 : * consumed by dentry is instantiation. This is also indicated by clearing of
2784 : * *inodep pointer. On failure, the caller is responsible for dropping the
2785 : * inode reference in the safe context.
2786 : */
2787 1919704 : static int ext4_add_nondir(handle_t *handle,
2788 : struct dentry *dentry, struct inode **inodep)
2789 : {
2790 1919704 : struct inode *dir = d_inode(dentry->d_parent);
2791 1919704 : struct inode *inode = *inodep;
2792 1919704 : int err = ext4_add_entry(handle, dentry, inode);
2793 1922360 : if (!err) {
2794 1922359 : err = ext4_mark_inode_dirty(handle, inode);
2795 1923181 : if (IS_DIRSYNC(dir))
2796 0 : ext4_handle_sync(handle);
2797 1923181 : d_instantiate_new(dentry, inode);
2798 1922825 : *inodep = NULL;
2799 1922825 : return err;
2800 : }
2801 1 : drop_nlink(inode);
2802 1 : ext4_orphan_add(handle, inode);
2803 1 : unlock_new_inode(inode);
2804 1 : return err;
2805 : }
2806 :
2807 : /*
2808 : * By the time this is called, we already have created
2809 : * the directory cache entry for the new file, but it
2810 : * is so far negative - it has no inode.
2811 : *
2812 : * If the create succeeds, we fill in the inode information
2813 : * with d_instantiate().
2814 : */
2815 1690457 : static int ext4_create(struct mnt_idmap *idmap, struct inode *dir,
2816 : struct dentry *dentry, umode_t mode, bool excl)
2817 : {
2818 1690457 : handle_t *handle;
2819 1690457 : struct inode *inode;
2820 1690457 : int err, credits, retries = 0;
2821 :
2822 1690457 : err = dquot_initialize(dir);
2823 1686717 : if (err)
2824 : return err;
2825 :
2826 1686821 : credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2827 1686716 : EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
2828 1801640 : retry:
2829 1801640 : inode = ext4_new_inode_start_handle(idmap, dir, mode, &dentry->d_name,
2830 : 0, NULL, EXT4_HT_DIR, credits);
2831 1815099 : handle = ext4_journal_current_handle();
2832 1815099 : err = PTR_ERR(inode);
2833 1815099 : if (!IS_ERR(inode)) {
2834 1661296 : inode->i_op = &ext4_file_inode_operations;
2835 1661296 : inode->i_fop = &ext4_file_operations;
2836 1661296 : ext4_set_aops(inode);
2837 1659615 : err = ext4_add_nondir(handle, dentry, &inode);
2838 1661479 : if (!err)
2839 1661413 : ext4_fc_track_create(handle, dentry);
2840 : }
2841 1813923 : if (handle)
2842 1660472 : ext4_journal_stop(handle);
2843 1967743 : if (!IS_ERR_OR_NULL(inode))
2844 1 : iput(inode);
2845 1813939 : if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2846 114924 : goto retry;
2847 : return err;
2848 : }
2849 :
2850 134450 : static int ext4_mknod(struct mnt_idmap *idmap, struct inode *dir,
2851 : struct dentry *dentry, umode_t mode, dev_t rdev)
2852 : {
2853 134450 : handle_t *handle;
2854 134450 : struct inode *inode;
2855 134450 : int err, credits, retries = 0;
2856 :
2857 134450 : err = dquot_initialize(dir);
2858 134441 : if (err)
2859 : return err;
2860 :
2861 134490 : credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2862 134441 : EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
2863 134441 : retry:
2864 134441 : inode = ext4_new_inode_start_handle(idmap, dir, mode, &dentry->d_name,
2865 : 0, NULL, EXT4_HT_DIR, credits);
2866 134471 : handle = ext4_journal_current_handle();
2867 134471 : err = PTR_ERR(inode);
2868 134471 : if (!IS_ERR(inode)) {
2869 134404 : init_special_inode(inode, inode->i_mode, rdev);
2870 134399 : inode->i_op = &ext4_special_inode_operations;
2871 134399 : err = ext4_add_nondir(handle, dentry, &inode);
2872 134397 : if (!err)
2873 134397 : ext4_fc_track_create(handle, dentry);
2874 : }
2875 134458 : if (handle)
2876 134388 : ext4_journal_stop(handle);
2877 134520 : if (!IS_ERR_OR_NULL(inode))
2878 0 : iput(inode);
2879 134453 : if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2880 0 : goto retry;
2881 : return err;
2882 : }
2883 :
2884 431164 : static int ext4_tmpfile(struct mnt_idmap *idmap, struct inode *dir,
2885 : struct file *file, umode_t mode)
2886 : {
2887 431164 : handle_t *handle;
2888 431164 : struct inode *inode;
2889 431164 : int err, retries = 0;
2890 :
2891 431164 : err = dquot_initialize(dir);
2892 424767 : if (err)
2893 : return err;
2894 :
2895 424767 : retry:
2896 424767 : inode = ext4_new_inode_start_handle(idmap, dir, mode,
2897 : NULL, 0, NULL,
2898 : EXT4_HT_DIR,
2899 : EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) +
2900 : 4 + EXT4_XATTR_TRANS_BLOCKS);
2901 448316 : handle = ext4_journal_current_handle();
2902 448316 : err = PTR_ERR(inode);
2903 448316 : if (!IS_ERR(inode)) {
2904 448316 : inode->i_op = &ext4_file_inode_operations;
2905 448316 : inode->i_fop = &ext4_file_operations;
2906 448316 : ext4_set_aops(inode);
2907 447698 : d_tmpfile(file, inode);
2908 439160 : err = ext4_orphan_add(handle, inode);
2909 453568 : if (err)
2910 0 : goto err_unlock_inode;
2911 453568 : mark_inode_dirty(inode);
2912 450185 : unlock_new_inode(inode);
2913 : }
2914 451615 : if (handle)
2915 451615 : ext4_journal_stop(handle);
2916 450494 : if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2917 0 : goto retry;
2918 450494 : return finish_open_simple(file, err);
2919 : err_unlock_inode:
2920 0 : ext4_journal_stop(handle);
2921 0 : unlock_new_inode(inode);
2922 0 : return err;
2923 : }
2924 :
2925 344146 : struct ext4_dir_entry_2 *ext4_init_dot_dotdot(struct inode *inode,
2926 : struct ext4_dir_entry_2 *de,
2927 : int blocksize, int csum_size,
2928 : unsigned int parent_ino, int dotdot_real_len)
2929 : {
2930 344146 : de->inode = cpu_to_le32(inode->i_ino);
2931 344146 : de->name_len = 1;
2932 344146 : de->rec_len = ext4_rec_len_to_disk(ext4_dir_rec_len(de->name_len, NULL),
2933 : blocksize);
2934 344146 : strcpy(de->name, ".");
2935 344146 : ext4_set_de_type(inode->i_sb, de, S_IFDIR);
2936 :
2937 344146 : de = ext4_next_entry(de, blocksize);
2938 344146 : de->inode = cpu_to_le32(parent_ino);
2939 344146 : de->name_len = 2;
2940 344146 : if (!dotdot_real_len)
2941 344146 : de->rec_len = ext4_rec_len_to_disk(blocksize -
2942 344146 : (csum_size + ext4_dir_rec_len(1, NULL)),
2943 : blocksize);
2944 : else
2945 0 : de->rec_len = ext4_rec_len_to_disk(
2946 : ext4_dir_rec_len(de->name_len, NULL),
2947 : blocksize);
2948 344146 : strcpy(de->name, "..");
2949 344146 : ext4_set_de_type(inode->i_sb, de, S_IFDIR);
2950 :
2951 344146 : return ext4_next_entry(de, blocksize);
2952 : }
2953 :
2954 357507 : int ext4_init_new_dir(handle_t *handle, struct inode *dir,
2955 : struct inode *inode)
2956 : {
2957 357507 : struct buffer_head *dir_block = NULL;
2958 357507 : struct ext4_dir_entry_2 *de;
2959 357507 : ext4_lblk_t block = 0;
2960 357507 : unsigned int blocksize = dir->i_sb->s_blocksize;
2961 357507 : int csum_size = 0;
2962 357507 : int err;
2963 :
2964 357507 : if (ext4_has_metadata_csum(dir->i_sb))
2965 357359 : csum_size = sizeof(struct ext4_dir_entry_tail);
2966 :
2967 357477 : if (ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA)) {
2968 0 : err = ext4_try_create_inline_dir(handle, dir, inode);
2969 0 : if (err < 0 && err != -ENOSPC)
2970 0 : goto out;
2971 0 : if (!err)
2972 0 : goto out;
2973 : }
2974 :
2975 357477 : inode->i_size = 0;
2976 357477 : dir_block = ext4_append(handle, inode, &block);
2977 357489 : if (IS_ERR(dir_block))
2978 13095 : return PTR_ERR(dir_block);
2979 344394 : de = (struct ext4_dir_entry_2 *)dir_block->b_data;
2980 344394 : ext4_init_dot_dotdot(inode, de, blocksize, csum_size, dir->i_ino, 0);
2981 344125 : set_nlink(inode, 2);
2982 343920 : if (csum_size)
2983 343830 : ext4_initialize_dirent_tail(dir_block, blocksize);
2984 :
2985 343843 : BUFFER_TRACE(dir_block, "call ext4_handle_dirty_metadata");
2986 343843 : err = ext4_handle_dirty_dirblock(handle, inode, dir_block);
2987 343979 : if (err)
2988 0 : goto out;
2989 343979 : set_buffer_verified(dir_block);
2990 344335 : out:
2991 344335 : brelse(dir_block);
2992 : return err;
2993 : }
2994 :
2995 350549 : static int ext4_mkdir(struct mnt_idmap *idmap, struct inode *dir,
2996 : struct dentry *dentry, umode_t mode)
2997 : {
2998 350549 : handle_t *handle;
2999 350549 : struct inode *inode;
3000 350549 : int err, err2 = 0, credits, retries = 0;
3001 :
3002 350549 : if (EXT4_DIR_LINK_MAX(dir))
3003 : return -EMLINK;
3004 :
3005 350549 : err = dquot_initialize(dir);
3006 350517 : if (err)
3007 : return err;
3008 :
3009 350575 : credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
3010 350517 : EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
3011 358077 : retry:
3012 358077 : inode = ext4_new_inode_start_handle(idmap, dir, S_IFDIR | mode,
3013 : &dentry->d_name,
3014 : 0, NULL, EXT4_HT_DIR, credits);
3015 358146 : handle = ext4_journal_current_handle();
3016 358146 : err = PTR_ERR(inode);
3017 358146 : if (IS_ERR(inode))
3018 607 : goto out_stop;
3019 :
3020 357539 : inode->i_op = &ext4_dir_inode_operations;
3021 357539 : inode->i_fop = &ext4_dir_operations;
3022 357539 : err = ext4_init_new_dir(handle, dir, inode);
3023 357387 : if (err)
3024 13080 : goto out_clear_inode;
3025 344307 : err = ext4_mark_inode_dirty(handle, inode);
3026 344417 : if (!err)
3027 344437 : err = ext4_add_entry(handle, dentry, inode);
3028 344369 : if (err) {
3029 4 : out_clear_inode:
3030 13084 : clear_nlink(inode);
3031 13099 : ext4_orphan_add(handle, inode);
3032 13105 : unlock_new_inode(inode);
3033 13106 : err2 = ext4_mark_inode_dirty(handle, inode);
3034 13106 : if (unlikely(err2))
3035 0 : err = err2;
3036 13106 : ext4_journal_stop(handle);
3037 13103 : iput(inode);
3038 13078 : goto out_retry;
3039 : }
3040 344365 : ext4_inc_count(dir);
3041 :
3042 344282 : ext4_update_dx_flag(dir);
3043 344273 : err = ext4_mark_inode_dirty(handle, dir);
3044 344444 : if (err)
3045 0 : goto out_clear_inode;
3046 344444 : d_instantiate_new(dentry, inode);
3047 344394 : ext4_fc_track_create(handle, dentry);
3048 344270 : if (IS_DIRSYNC(dir))
3049 0 : ext4_handle_sync(handle);
3050 :
3051 344270 : out_stop:
3052 344877 : if (handle)
3053 344762 : ext4_journal_stop(handle);
3054 115 : out_retry:
3055 358039 : if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
3056 7560 : goto retry;
3057 : return err;
3058 : }
3059 :
3060 : /*
3061 : * routine to check that the specified directory is empty (for rmdir)
3062 : */
3063 225443 : bool ext4_empty_dir(struct inode *inode)
3064 : {
3065 225443 : unsigned int offset;
3066 225443 : struct buffer_head *bh;
3067 225443 : struct ext4_dir_entry_2 *de;
3068 225443 : struct super_block *sb;
3069 :
3070 225443 : if (ext4_has_inline_data(inode)) {
3071 0 : int has_inline_data = 1;
3072 0 : int ret;
3073 :
3074 0 : ret = empty_inline_dir(inode, &has_inline_data);
3075 0 : if (has_inline_data)
3076 0 : return ret;
3077 : }
3078 :
3079 225443 : sb = inode->i_sb;
3080 225443 : if (inode->i_size < ext4_dir_rec_len(1, NULL) +
3081 : ext4_dir_rec_len(2, NULL)) {
3082 0 : EXT4_ERROR_INODE(inode, "invalid size");
3083 0 : return false;
3084 : }
3085 : /* The first directory block must not be a hole,
3086 : * so treat it as DIRENT_HTREE
3087 : */
3088 225443 : bh = ext4_read_dirblock(inode, 0, DIRENT_HTREE);
3089 225458 : if (IS_ERR(bh))
3090 : return false;
3091 :
3092 225458 : de = (struct ext4_dir_entry_2 *) bh->b_data;
3093 225458 : if (ext4_check_dir_entry(inode, NULL, de, bh, bh->b_data, bh->b_size,
3094 225459 : 0) ||
3095 225459 : le32_to_cpu(de->inode) != inode->i_ino || strcmp(".", de->name)) {
3096 0 : ext4_warning_inode(inode, "directory missing '.'");
3097 0 : brelse(bh);
3098 0 : return false;
3099 : }
3100 225460 : offset = ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize);
3101 225460 : de = ext4_next_entry(de, sb->s_blocksize);
3102 225460 : if (ext4_check_dir_entry(inode, NULL, de, bh, bh->b_data, bh->b_size,
3103 225458 : offset) ||
3104 225458 : le32_to_cpu(de->inode) == 0 || strcmp("..", de->name)) {
3105 0 : ext4_warning_inode(inode, "directory missing '..'");
3106 0 : brelse(bh);
3107 0 : return false;
3108 : }
3109 225458 : offset += ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize);
3110 421330 : while (offset < inode->i_size) {
3111 237394 : if (!(offset & (sb->s_blocksize - 1))) {
3112 6438 : unsigned int lblock;
3113 6438 : brelse(bh);
3114 6438 : lblock = offset >> EXT4_BLOCK_SIZE_BITS(sb);
3115 6438 : bh = ext4_read_dirblock(inode, lblock, EITHER);
3116 6438 : if (bh == NULL) {
3117 0 : offset += sb->s_blocksize;
3118 0 : continue;
3119 : }
3120 6438 : if (IS_ERR(bh))
3121 : return false;
3122 : }
3123 237394 : de = (struct ext4_dir_entry_2 *) (bh->b_data +
3124 237394 : (offset & (sb->s_blocksize - 1)));
3125 237394 : if (ext4_check_dir_entry(inode, NULL, de, bh,
3126 237397 : bh->b_data, bh->b_size, offset) ||
3127 237397 : le32_to_cpu(de->inode)) {
3128 41527 : brelse(bh);
3129 41530 : return false;
3130 : }
3131 195872 : offset += ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize);
3132 : }
3133 183936 : brelse(bh);
3134 : return true;
3135 : }
3136 :
3137 225277 : static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
3138 : {
3139 225277 : int retval;
3140 225277 : struct inode *inode;
3141 225277 : struct buffer_head *bh;
3142 225277 : struct ext4_dir_entry_2 *de;
3143 225277 : handle_t *handle = NULL;
3144 :
3145 450554 : if (unlikely(ext4_forced_shutdown(EXT4_SB(dir->i_sb))))
3146 : return -EIO;
3147 :
3148 : /* Initialize quotas before so that eventual writes go in
3149 : * separate transaction */
3150 225249 : retval = dquot_initialize(dir);
3151 225251 : if (retval)
3152 : return retval;
3153 225251 : retval = dquot_initialize(d_inode(dentry));
3154 225254 : if (retval)
3155 : return retval;
3156 :
3157 225256 : retval = -ENOENT;
3158 225256 : bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
3159 225248 : if (IS_ERR(bh))
3160 0 : return PTR_ERR(bh);
3161 225248 : if (!bh)
3162 0 : goto end_rmdir;
3163 :
3164 225248 : inode = d_inode(dentry);
3165 :
3166 225248 : retval = -EFSCORRUPTED;
3167 225248 : if (le32_to_cpu(de->inode) != inode->i_ino)
3168 0 : goto end_rmdir;
3169 :
3170 225248 : retval = -ENOTEMPTY;
3171 225248 : if (!ext4_empty_dir(inode))
3172 41517 : goto end_rmdir;
3173 :
3174 366678 : handle = ext4_journal_start(dir, EXT4_HT_DIR,
3175 : EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
3176 183743 : if (IS_ERR(handle)) {
3177 0 : retval = PTR_ERR(handle);
3178 0 : handle = NULL;
3179 0 : goto end_rmdir;
3180 : }
3181 :
3182 183743 : if (IS_DIRSYNC(dir))
3183 0 : ext4_handle_sync(handle);
3184 :
3185 183743 : retval = ext4_delete_entry(handle, dir, de, bh);
3186 183747 : if (retval)
3187 0 : goto end_rmdir;
3188 183747 : if (!EXT4_DIR_LINK_EMPTY(inode))
3189 0 : ext4_warning_inode(inode,
3190 : "empty directory '%.*s' has too many links (%u)",
3191 : dentry->d_name.len, dentry->d_name.name,
3192 : inode->i_nlink);
3193 183747 : inode_inc_iversion(inode);
3194 183749 : clear_nlink(inode);
3195 : /* There's no need to set i_disksize: the fact that i_nlink is
3196 : * zero will ensure that the right thing happens during any
3197 : * recovery. */
3198 183747 : inode->i_size = 0;
3199 183747 : ext4_orphan_add(handle, inode);
3200 183752 : inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode);
3201 183751 : retval = ext4_mark_inode_dirty(handle, inode);
3202 183751 : if (retval)
3203 0 : goto end_rmdir;
3204 183751 : ext4_dec_count(dir);
3205 183749 : ext4_update_dx_flag(dir);
3206 183748 : ext4_fc_track_unlink(handle, dentry);
3207 183746 : retval = ext4_mark_inode_dirty(handle, dir);
3208 :
3209 : #if IS_ENABLED(CONFIG_UNICODE)
3210 : /* VFS negative dentries are incompatible with Encoding and
3211 : * Case-insensitiveness. Eventually we'll want avoid
3212 : * invalidating the dentries here, alongside with returning the
3213 : * negative dentries at ext4_lookup(), when it is better
3214 : * supported by the VFS for the CI case.
3215 : */
3216 183752 : if (IS_CASEFOLDED(dir))
3217 5 : d_invalidate(dentry);
3218 : #endif
3219 :
3220 183747 : end_rmdir:
3221 225269 : brelse(bh);
3222 225269 : if (handle)
3223 183753 : ext4_journal_stop(handle);
3224 : return retval;
3225 : }
3226 :
3227 1319337 : int __ext4_unlink(struct inode *dir, const struct qstr *d_name,
3228 : struct inode *inode,
3229 : struct dentry *dentry /* NULL during fast_commit recovery */)
3230 : {
3231 1319337 : int retval = -ENOENT;
3232 1319337 : struct buffer_head *bh;
3233 1319337 : struct ext4_dir_entry_2 *de;
3234 1319337 : handle_t *handle;
3235 1319337 : int skip_remove_dentry = 0;
3236 :
3237 : /*
3238 : * Keep this outside the transaction; it may have to set up the
3239 : * directory's encryption key, which isn't GFP_NOFS-safe.
3240 : */
3241 1319337 : bh = ext4_find_entry(dir, d_name, &de, NULL);
3242 1320409 : if (IS_ERR(bh))
3243 0 : return PTR_ERR(bh);
3244 :
3245 1320409 : if (!bh)
3246 : return -ENOENT;
3247 :
3248 1320409 : if (le32_to_cpu(de->inode) != inode->i_ino) {
3249 : /*
3250 : * It's okay if we find dont find dentry which matches
3251 : * the inode. That's because it might have gotten
3252 : * renamed to a different inode number
3253 : */
3254 0 : if (EXT4_SB(inode->i_sb)->s_mount_state & EXT4_FC_REPLAY)
3255 : skip_remove_dentry = 1;
3256 : else
3257 0 : goto out_bh;
3258 : }
3259 :
3260 2632652 : handle = ext4_journal_start(dir, EXT4_HT_DIR,
3261 : EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
3262 1319339 : if (IS_ERR(handle)) {
3263 0 : retval = PTR_ERR(handle);
3264 0 : goto out_bh;
3265 : }
3266 :
3267 1319339 : if (IS_DIRSYNC(dir))
3268 0 : ext4_handle_sync(handle);
3269 :
3270 1319339 : if (!skip_remove_dentry) {
3271 1319465 : retval = ext4_delete_entry(handle, dir, de, bh);
3272 1319147 : if (retval)
3273 0 : goto out_handle;
3274 1319147 : dir->i_ctime = dir->i_mtime = current_time(dir);
3275 1319337 : ext4_update_dx_flag(dir);
3276 1319743 : retval = ext4_mark_inode_dirty(handle, dir);
3277 1320609 : if (retval)
3278 0 : goto out_handle;
3279 : } else {
3280 : retval = 0;
3281 : }
3282 1320483 : if (inode->i_nlink == 0)
3283 0 : ext4_warning_inode(inode, "Deleting file '%.*s' with no links",
3284 : d_name->len, d_name->name);
3285 : else
3286 1320483 : drop_nlink(inode);
3287 1320615 : if (!inode->i_nlink)
3288 1260566 : ext4_orphan_add(handle, inode);
3289 1320761 : inode->i_ctime = current_time(inode);
3290 1320763 : retval = ext4_mark_inode_dirty(handle, inode);
3291 1320758 : if (dentry && !retval)
3292 1320758 : ext4_fc_track_unlink(handle, dentry);
3293 0 : out_handle:
3294 1320720 : ext4_journal_stop(handle);
3295 1320562 : out_bh:
3296 1320562 : brelse(bh);
3297 1320562 : return retval;
3298 : }
3299 :
3300 1319632 : static int ext4_unlink(struct inode *dir, struct dentry *dentry)
3301 : {
3302 1319632 : int retval;
3303 :
3304 2639264 : if (unlikely(ext4_forced_shutdown(EXT4_SB(dir->i_sb))))
3305 : return -EIO;
3306 :
3307 1319599 : trace_ext4_unlink_enter(dir, dentry);
3308 : /*
3309 : * Initialize quotas before so that eventual writes go
3310 : * in separate transaction
3311 : */
3312 1319656 : retval = dquot_initialize(dir);
3313 1319663 : if (retval)
3314 0 : goto out_trace;
3315 1319663 : retval = dquot_initialize(d_inode(dentry));
3316 1319748 : if (retval)
3317 0 : goto out_trace;
3318 :
3319 1319748 : retval = __ext4_unlink(dir, &dentry->d_name, d_inode(dentry), dentry);
3320 : #if IS_ENABLED(CONFIG_UNICODE)
3321 : /* VFS negative dentries are incompatible with Encoding and
3322 : * Case-insensitiveness. Eventually we'll want avoid
3323 : * invalidating the dentries here, alongside with returning the
3324 : * negative dentries at ext4_lookup(), when it is better
3325 : * supported by the VFS for the CI case.
3326 : */
3327 1320722 : if (IS_CASEFOLDED(dir))
3328 15 : d_invalidate(dentry);
3329 : #endif
3330 :
3331 1320707 : out_trace:
3332 1320722 : trace_ext4_unlink_exit(dentry, retval);
3333 1320722 : return retval;
3334 : }
3335 :
3336 35766 : static int ext4_init_symlink_block(handle_t *handle, struct inode *inode,
3337 : struct fscrypt_str *disk_link)
3338 : {
3339 35766 : struct buffer_head *bh;
3340 35766 : char *kaddr;
3341 35766 : int err = 0;
3342 :
3343 35766 : bh = ext4_bread(handle, inode, 0, EXT4_GET_BLOCKS_CREATE);
3344 35771 : if (IS_ERR(bh))
3345 12741 : return PTR_ERR(bh);
3346 :
3347 23030 : BUFFER_TRACE(bh, "get_write_access");
3348 23030 : err = ext4_journal_get_write_access(handle, inode->i_sb, bh, EXT4_JTR_NONE);
3349 23026 : if (err)
3350 0 : goto out;
3351 :
3352 23026 : kaddr = (char *)bh->b_data;
3353 46052 : memcpy(kaddr, disk_link->name, disk_link->len);
3354 23026 : inode->i_size = disk_link->len - 1;
3355 23026 : EXT4_I(inode)->i_disksize = inode->i_size;
3356 23026 : err = ext4_handle_dirty_metadata(handle, inode, bh);
3357 23026 : out:
3358 23026 : brelse(bh);
3359 : return err;
3360 : }
3361 :
3362 132650 : static int ext4_symlink(struct mnt_idmap *idmap, struct inode *dir,
3363 : struct dentry *dentry, const char *symname)
3364 : {
3365 132650 : handle_t *handle;
3366 132650 : struct inode *inode;
3367 132650 : int err, len = strlen(symname);
3368 132650 : int credits;
3369 132650 : struct fscrypt_str disk_link;
3370 132650 : int retries = 0;
3371 :
3372 265300 : if (unlikely(ext4_forced_shutdown(EXT4_SB(dir->i_sb))))
3373 : return -EIO;
3374 :
3375 132583 : err = fscrypt_prepare_symlink(dir, symname, len, dir->i_sb->s_blocksize,
3376 : &disk_link);
3377 132583 : if (err)
3378 0 : return err;
3379 :
3380 132583 : err = dquot_initialize(dir);
3381 132568 : if (err)
3382 : return err;
3383 :
3384 : /*
3385 : * EXT4_INDEX_EXTRA_TRANS_BLOCKS for addition of entry into the
3386 : * directory. +3 for inode, inode bitmap, group descriptor allocation.
3387 : * EXT4_DATA_TRANS_BLOCKS for the data block allocation and
3388 : * modification.
3389 : */
3390 132620 : credits = EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
3391 132568 : EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3;
3392 140064 : retry:
3393 140064 : inode = ext4_new_inode_start_handle(idmap, dir, S_IFLNK|S_IRWXUGO,
3394 : &dentry->d_name, 0, NULL,
3395 : EXT4_HT_DIR, credits);
3396 140079 : handle = ext4_journal_current_handle();
3397 140079 : if (IS_ERR(inode)) {
3398 440 : if (handle)
3399 440 : ext4_journal_stop(handle);
3400 440 : err = PTR_ERR(inode);
3401 440 : goto out_retry;
3402 : }
3403 :
3404 139639 : if (IS_ENCRYPTED(inode)) {
3405 0 : err = fscrypt_encrypt_symlink(inode, symname, len, &disk_link);
3406 0 : if (err)
3407 0 : goto err_drop_inode;
3408 : inode->i_op = &ext4_encrypted_symlink_inode_operations;
3409 : } else {
3410 139639 : if ((disk_link.len > EXT4_N_BLOCKS * 4)) {
3411 35773 : inode->i_op = &ext4_symlink_inode_operations;
3412 : } else {
3413 103866 : inode->i_op = &ext4_fast_symlink_inode_operations;
3414 103866 : inode->i_link = (char *)&EXT4_I(inode)->i_data;
3415 : }
3416 : }
3417 :
3418 139639 : if ((disk_link.len > EXT4_N_BLOCKS * 4)) {
3419 : /* alloc symlink block and fill it */
3420 35772 : err = ext4_init_symlink_block(handle, inode, &disk_link);
3421 35766 : if (err)
3422 12735 : goto err_drop_inode;
3423 : } else {
3424 : /* clear the extent format for fast symlink */
3425 103867 : ext4_clear_inode_flag(inode, EXT4_INODE_EXTENTS);
3426 103867 : memcpy((char *)&EXT4_I(inode)->i_data, disk_link.name,
3427 : disk_link.len);
3428 103867 : inode->i_size = disk_link.len - 1;
3429 103867 : EXT4_I(inode)->i_disksize = inode->i_size;
3430 : }
3431 126898 : err = ext4_add_nondir(handle, dentry, &inode);
3432 126894 : if (handle)
3433 126894 : ext4_journal_stop(handle);
3434 126887 : iput(inode);
3435 126884 : goto out_retry;
3436 :
3437 12735 : err_drop_inode:
3438 12735 : clear_nlink(inode);
3439 12745 : ext4_orphan_add(handle, inode);
3440 12749 : unlock_new_inode(inode);
3441 12750 : if (handle)
3442 12750 : ext4_journal_stop(handle);
3443 12746 : iput(inode);
3444 140045 : out_retry:
3445 140045 : if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
3446 7496 : goto retry;
3447 132576 : if (disk_link.name != (unsigned char *)symname)
3448 0 : kfree(disk_link.name);
3449 : return err;
3450 : }
3451 :
3452 72187 : int __ext4_link(struct inode *dir, struct inode *inode, struct dentry *dentry)
3453 : {
3454 72187 : handle_t *handle;
3455 72187 : int err, retries = 0;
3456 72187 : retry:
3457 139782 : handle = ext4_journal_start(dir, EXT4_HT_DIR,
3458 : (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
3459 : EXT4_INDEX_EXTRA_TRANS_BLOCKS) + 1);
3460 72187 : if (IS_ERR(handle))
3461 28 : return PTR_ERR(handle);
3462 :
3463 72159 : if (IS_DIRSYNC(dir))
3464 0 : ext4_handle_sync(handle);
3465 :
3466 72159 : inode->i_ctime = current_time(inode);
3467 72160 : ext4_inc_count(inode);
3468 72152 : ihold(inode);
3469 :
3470 72170 : err = ext4_add_entry(handle, dentry, inode);
3471 72167 : if (!err) {
3472 72166 : err = ext4_mark_inode_dirty(handle, inode);
3473 : /* this can happen only for tmpfile being
3474 : * linked the first time
3475 : */
3476 72170 : if (inode->i_nlink == 1)
3477 1892 : ext4_orphan_del(handle, inode);
3478 72170 : d_instantiate(dentry, inode);
3479 72166 : ext4_fc_track_link(handle, dentry);
3480 : } else {
3481 1 : drop_nlink(inode);
3482 1 : iput(inode);
3483 : }
3484 72165 : ext4_journal_stop(handle);
3485 72165 : if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
3486 0 : goto retry;
3487 : return err;
3488 : }
3489 :
3490 72184 : static int ext4_link(struct dentry *old_dentry,
3491 : struct inode *dir, struct dentry *dentry)
3492 : {
3493 72184 : struct inode *inode = d_inode(old_dentry);
3494 72184 : int err;
3495 :
3496 72184 : if (inode->i_nlink >= EXT4_LINK_MAX)
3497 : return -EMLINK;
3498 :
3499 72184 : err = fscrypt_prepare_link(old_dentry, dir, dentry);
3500 72184 : if (err)
3501 : return err;
3502 :
3503 72184 : if ((ext4_test_inode_flag(dir, EXT4_INODE_PROJINHERIT)) &&
3504 0 : (!projid_eq(EXT4_I(dir)->i_projid,
3505 0 : EXT4_I(old_dentry->d_inode)->i_projid)))
3506 : return -EXDEV;
3507 :
3508 72184 : err = dquot_initialize(dir);
3509 72171 : if (err)
3510 : return err;
3511 72174 : return __ext4_link(dir, inode, dentry);
3512 : }
3513 :
3514 : /*
3515 : * Try to find buffer head where contains the parent block.
3516 : * It should be the inode block if it is inlined or the 1st block
3517 : * if it is a normal dir.
3518 : */
3519 136144 : static struct buffer_head *ext4_get_first_dir_block(handle_t *handle,
3520 : struct inode *inode,
3521 : int *retval,
3522 : struct ext4_dir_entry_2 **parent_de,
3523 : int *inlined)
3524 : {
3525 136144 : struct buffer_head *bh;
3526 :
3527 136144 : if (!ext4_has_inline_data(inode)) {
3528 136144 : struct ext4_dir_entry_2 *de;
3529 136144 : unsigned int offset;
3530 :
3531 : /* The first directory block must not be a hole, so
3532 : * treat it as DIRENT_HTREE
3533 : */
3534 136144 : bh = ext4_read_dirblock(inode, 0, DIRENT_HTREE);
3535 136144 : if (IS_ERR(bh)) {
3536 0 : *retval = PTR_ERR(bh);
3537 0 : return NULL;
3538 : }
3539 :
3540 136144 : de = (struct ext4_dir_entry_2 *) bh->b_data;
3541 136144 : if (ext4_check_dir_entry(inode, NULL, de, bh, bh->b_data,
3542 136144 : bh->b_size, 0) ||
3543 136144 : le32_to_cpu(de->inode) != inode->i_ino ||
3544 136144 : strcmp(".", de->name)) {
3545 0 : EXT4_ERROR_INODE(inode, "directory missing '.'");
3546 0 : brelse(bh);
3547 0 : *retval = -EFSCORRUPTED;
3548 0 : return NULL;
3549 : }
3550 136144 : offset = ext4_rec_len_from_disk(de->rec_len,
3551 : inode->i_sb->s_blocksize);
3552 136144 : de = ext4_next_entry(de, inode->i_sb->s_blocksize);
3553 136144 : if (ext4_check_dir_entry(inode, NULL, de, bh, bh->b_data,
3554 136144 : bh->b_size, offset) ||
3555 136144 : le32_to_cpu(de->inode) == 0 || strcmp("..", de->name)) {
3556 0 : EXT4_ERROR_INODE(inode, "directory missing '..'");
3557 0 : brelse(bh);
3558 0 : *retval = -EFSCORRUPTED;
3559 0 : return NULL;
3560 : }
3561 136144 : *parent_de = de;
3562 :
3563 136144 : return bh;
3564 : }
3565 :
3566 0 : *inlined = 1;
3567 0 : return ext4_get_first_inline_block(inode, parent_de, retval);
3568 : }
3569 :
3570 : struct ext4_renament {
3571 : struct inode *dir;
3572 : struct dentry *dentry;
3573 : struct inode *inode;
3574 : bool is_dir;
3575 : int dir_nlink_delta;
3576 :
3577 : /* entry for "dentry" */
3578 : struct buffer_head *bh;
3579 : struct ext4_dir_entry_2 *de;
3580 : int inlined;
3581 :
3582 : /* entry for ".." in inode if it's a directory */
3583 : struct buffer_head *dir_bh;
3584 : struct ext4_dir_entry_2 *parent_de;
3585 : int dir_inlined;
3586 : };
3587 :
3588 136144 : static int ext4_rename_dir_prepare(handle_t *handle, struct ext4_renament *ent)
3589 : {
3590 136144 : int retval;
3591 :
3592 136144 : ent->dir_bh = ext4_get_first_dir_block(handle, ent->inode,
3593 : &retval, &ent->parent_de,
3594 : &ent->dir_inlined);
3595 136144 : if (!ent->dir_bh)
3596 0 : return retval;
3597 136144 : if (le32_to_cpu(ent->parent_de->inode) != ent->dir->i_ino)
3598 : return -EFSCORRUPTED;
3599 136144 : BUFFER_TRACE(ent->dir_bh, "get_write_access");
3600 136144 : return ext4_journal_get_write_access(handle, ent->dir->i_sb,
3601 : ent->dir_bh, EXT4_JTR_NONE);
3602 : }
3603 :
3604 136144 : static int ext4_rename_dir_finish(handle_t *handle, struct ext4_renament *ent,
3605 : unsigned dir_ino)
3606 : {
3607 136144 : int retval;
3608 :
3609 136144 : ent->parent_de->inode = cpu_to_le32(dir_ino);
3610 136144 : BUFFER_TRACE(ent->dir_bh, "call ext4_handle_dirty_metadata");
3611 136144 : if (!ent->dir_inlined) {
3612 136144 : if (is_dx(ent->inode)) {
3613 41571 : retval = ext4_handle_dirty_dx_node(handle,
3614 : ent->inode,
3615 : ent->dir_bh);
3616 : } else {
3617 94573 : retval = ext4_handle_dirty_dirblock(handle, ent->inode,
3618 : ent->dir_bh);
3619 : }
3620 : } else {
3621 0 : retval = ext4_mark_inode_dirty(handle, ent->inode);
3622 : }
3623 136144 : if (retval) {
3624 0 : ext4_std_error(ent->dir->i_sb, retval);
3625 0 : return retval;
3626 : }
3627 : return 0;
3628 : }
3629 :
3630 122924 : static int ext4_setent(handle_t *handle, struct ext4_renament *ent,
3631 : unsigned ino, unsigned file_type)
3632 : {
3633 122924 : int retval, retval2;
3634 :
3635 122924 : BUFFER_TRACE(ent->bh, "get write access");
3636 122924 : retval = ext4_journal_get_write_access(handle, ent->dir->i_sb, ent->bh,
3637 : EXT4_JTR_NONE);
3638 122945 : if (retval)
3639 : return retval;
3640 122945 : ent->de->inode = cpu_to_le32(ino);
3641 122945 : if (ext4_has_feature_filetype(ent->dir->i_sb))
3642 122947 : ent->de->file_type = file_type;
3643 122945 : inode_inc_iversion(ent->dir);
3644 245875 : ent->dir->i_ctime = ent->dir->i_mtime =
3645 122940 : current_time(ent->dir);
3646 122935 : retval = ext4_mark_inode_dirty(handle, ent->dir);
3647 122947 : BUFFER_TRACE(ent->bh, "call ext4_handle_dirty_metadata");
3648 122947 : if (!ent->inlined) {
3649 122947 : retval2 = ext4_handle_dirty_dirblock(handle, ent->dir, ent->bh);
3650 122914 : if (unlikely(retval2)) {
3651 0 : ext4_std_error(ent->dir->i_sb, retval2);
3652 0 : return retval2;
3653 : }
3654 : }
3655 : return retval;
3656 : }
3657 :
3658 248 : static void ext4_resetent(handle_t *handle, struct ext4_renament *ent,
3659 : unsigned ino, unsigned file_type)
3660 : {
3661 248 : struct ext4_renament old = *ent;
3662 248 : int retval = 0;
3663 :
3664 : /*
3665 : * old->de could have moved from under us during make indexed dir,
3666 : * so the old->de may no longer valid and need to find it again
3667 : * before reset old inode info.
3668 : */
3669 248 : old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de,
3670 : &old.inlined);
3671 248 : if (IS_ERR(old.bh))
3672 0 : retval = PTR_ERR(old.bh);
3673 248 : if (!old.bh)
3674 : retval = -ENOENT;
3675 248 : if (retval) {
3676 0 : ext4_std_error(old.dir->i_sb, retval);
3677 0 : return;
3678 : }
3679 :
3680 248 : ext4_setent(handle, &old, ino, file_type);
3681 248 : brelse(old.bh);
3682 : }
3683 :
3684 0 : static int ext4_find_delete_entry(handle_t *handle, struct inode *dir,
3685 : const struct qstr *d_name)
3686 : {
3687 0 : int retval = -ENOENT;
3688 0 : struct buffer_head *bh;
3689 0 : struct ext4_dir_entry_2 *de;
3690 :
3691 0 : bh = ext4_find_entry(dir, d_name, &de, NULL);
3692 0 : if (IS_ERR(bh))
3693 0 : return PTR_ERR(bh);
3694 0 : if (bh) {
3695 0 : retval = ext4_delete_entry(handle, dir, de, bh);
3696 0 : brelse(bh);
3697 : }
3698 : return retval;
3699 : }
3700 :
3701 564311 : static void ext4_rename_delete(handle_t *handle, struct ext4_renament *ent,
3702 : int force_reread)
3703 : {
3704 564311 : int retval;
3705 : /*
3706 : * ent->de could have moved from under us during htree split, so make
3707 : * sure that we are deleting the right entry. We might also be pointing
3708 : * to a stale entry in the unused part of ent->bh so just checking inum
3709 : * and the name isn't enough.
3710 : */
3711 564311 : if (le32_to_cpu(ent->de->inode) != ent->inode->i_ino ||
3712 564311 : ent->de->name_len != ent->dentry->d_name.len ||
3713 564311 : strncmp(ent->de->name, ent->dentry->d_name.name,
3714 564311 : ent->de->name_len) ||
3715 : force_reread) {
3716 3 : retval = ext4_find_delete_entry(handle, ent->dir,
3717 3 : &ent->dentry->d_name);
3718 : } else {
3719 564308 : retval = ext4_delete_entry(handle, ent->dir, ent->de, ent->bh);
3720 564308 : if (retval == -ENOENT) {
3721 0 : retval = ext4_find_delete_entry(handle, ent->dir,
3722 0 : &ent->dentry->d_name);
3723 : }
3724 : }
3725 :
3726 564310 : if (retval) {
3727 0 : ext4_warning_inode(ent->dir,
3728 : "Deleting old file: nlink %d, error=%d",
3729 : ent->dir->i_nlink, retval);
3730 : }
3731 564310 : }
3732 :
3733 46724 : static void ext4_update_dir_count(handle_t *handle, struct ext4_renament *ent)
3734 : {
3735 46724 : if (ent->dir_nlink_delta) {
3736 16 : if (ent->dir_nlink_delta == -1)
3737 8 : ext4_dec_count(ent->dir);
3738 : else
3739 8 : ext4_inc_count(ent->dir);
3740 16 : ext4_mark_inode_dirty(handle, ent->dir);
3741 : }
3742 46724 : }
3743 :
3744 38270 : static struct inode *ext4_whiteout_for_rename(struct mnt_idmap *idmap,
3745 : struct ext4_renament *ent,
3746 : int credits, handle_t **h)
3747 : {
3748 38270 : struct inode *wh;
3749 38270 : handle_t *handle;
3750 38270 : int retries = 0;
3751 :
3752 : /*
3753 : * for inode block, sb block, group summaries,
3754 : * and inode bitmap
3755 : */
3756 38270 : credits += (EXT4_MAXQUOTAS_TRANS_BLOCKS(ent->dir->i_sb) +
3757 38270 : EXT4_XATTR_TRANS_BLOCKS + 4);
3758 38270 : retry:
3759 38270 : wh = ext4_new_inode_start_handle(idmap, ent->dir,
3760 : S_IFCHR | WHITEOUT_MODE,
3761 : &ent->dentry->d_name, 0, NULL,
3762 : EXT4_HT_DIR, credits);
3763 :
3764 38274 : handle = ext4_journal_current_handle();
3765 38274 : if (IS_ERR(wh)) {
3766 0 : if (handle)
3767 0 : ext4_journal_stop(handle);
3768 0 : if (PTR_ERR(wh) == -ENOSPC &&
3769 0 : ext4_should_retry_alloc(ent->dir->i_sb, &retries))
3770 0 : goto retry;
3771 : } else {
3772 38274 : *h = handle;
3773 38274 : init_special_inode(wh, wh->i_mode, WHITEOUT_DEV);
3774 38265 : wh->i_op = &ext4_special_inode_operations;
3775 : }
3776 38265 : return wh;
3777 : }
3778 :
3779 : /*
3780 : * Anybody can rename anything with this: the permission checks are left to the
3781 : * higher-level routines.
3782 : *
3783 : * n.b. old_{dentry,inode) refers to the source dentry/inode
3784 : * while new_{dentry,inode) refers to the destination dentry/inode
3785 : * This comes from rename(const char *oldpath, const char *newpath)
3786 : */
3787 602569 : static int ext4_rename(struct mnt_idmap *idmap, struct inode *old_dir,
3788 : struct dentry *old_dentry, struct inode *new_dir,
3789 : struct dentry *new_dentry, unsigned int flags)
3790 : {
3791 602569 : handle_t *handle = NULL;
3792 602569 : struct ext4_renament old = {
3793 : .dir = old_dir,
3794 : .dentry = old_dentry,
3795 : .inode = d_inode(old_dentry),
3796 : };
3797 602569 : struct ext4_renament new = {
3798 : .dir = new_dir,
3799 : .dentry = new_dentry,
3800 : .inode = d_inode(new_dentry),
3801 : };
3802 602569 : int force_reread;
3803 602569 : int retval;
3804 602569 : struct inode *whiteout = NULL;
3805 602569 : int credits;
3806 602569 : u8 old_file_type;
3807 :
3808 602569 : if (new.inode && new.inode->i_nlink == 0) {
3809 0 : EXT4_ERROR_INODE(new.inode,
3810 : "target of rename is already freed");
3811 0 : return -EFSCORRUPTED;
3812 : }
3813 :
3814 602569 : if ((ext4_test_inode_flag(new_dir, EXT4_INODE_PROJINHERIT)) &&
3815 0 : (!projid_eq(EXT4_I(new_dir)->i_projid,
3816 0 : EXT4_I(old_dentry->d_inode)->i_projid)))
3817 : return -EXDEV;
3818 :
3819 602569 : retval = dquot_initialize(old.dir);
3820 602542 : if (retval)
3821 : return retval;
3822 602541 : retval = dquot_initialize(old.inode);
3823 602559 : if (retval)
3824 : return retval;
3825 602560 : retval = dquot_initialize(new.dir);
3826 602548 : if (retval)
3827 : return retval;
3828 :
3829 : /* Initialize quotas before so that eventual writes go
3830 : * in separate transaction */
3831 602548 : if (new.inode) {
3832 37701 : retval = dquot_initialize(new.inode);
3833 37702 : if (retval)
3834 : return retval;
3835 : }
3836 :
3837 602549 : old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de,
3838 : &old.inlined);
3839 602589 : if (IS_ERR(old.bh))
3840 0 : return PTR_ERR(old.bh);
3841 :
3842 : /*
3843 : * Check for inode number is _not_ due to possible IO errors.
3844 : * We might rmdir the source, keep it as pwd of some process
3845 : * and merrily kill the link to whatever was created under the
3846 : * same name. Goodbye sticky bit ;-<
3847 : */
3848 602589 : retval = -ENOENT;
3849 602589 : if (!old.bh || le32_to_cpu(old.de->inode) != old.inode->i_ino)
3850 0 : goto release_bh;
3851 :
3852 602589 : new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
3853 : &new.de, &new.inlined);
3854 602581 : if (IS_ERR(new.bh)) {
3855 0 : retval = PTR_ERR(new.bh);
3856 0 : new.bh = NULL;
3857 0 : goto release_bh;
3858 : }
3859 602581 : if (new.bh) {
3860 37695 : if (!new.inode) {
3861 0 : brelse(new.bh);
3862 0 : new.bh = NULL;
3863 : }
3864 : }
3865 602581 : if (new.inode && !test_opt(new.dir->i_sb, NO_AUTO_DA_ALLOC))
3866 37703 : ext4_alloc_da_blocks(old.inode);
3867 :
3868 602654 : credits = (2 * EXT4_DATA_TRANS_BLOCKS(old.dir->i_sb) +
3869 602580 : EXT4_INDEX_EXTRA_TRANS_BLOCKS + 2);
3870 602580 : if (!(flags & RENAME_WHITEOUT)) {
3871 564316 : handle = ext4_journal_start(old.dir, EXT4_HT_DIR, credits);
3872 564315 : if (IS_ERR(handle)) {
3873 0 : retval = PTR_ERR(handle);
3874 0 : goto release_bh;
3875 : }
3876 : } else {
3877 38264 : whiteout = ext4_whiteout_for_rename(idmap, &old, credits, &handle);
3878 38260 : if (IS_ERR(whiteout)) {
3879 0 : retval = PTR_ERR(whiteout);
3880 0 : goto release_bh;
3881 : }
3882 : }
3883 :
3884 602575 : old_file_type = old.de->file_type;
3885 602575 : if (IS_DIRSYNC(old.dir) || IS_DIRSYNC(new.dir))
3886 1 : ext4_handle_sync(handle);
3887 :
3888 602575 : if (S_ISDIR(old.inode->i_mode)) {
3889 130227 : if (new.inode) {
3890 168 : retval = -ENOTEMPTY;
3891 168 : if (!ext4_empty_dir(new.inode))
3892 9 : goto end_rename;
3893 : } else {
3894 130059 : retval = -EMLINK;
3895 130059 : if (new.dir != old.dir && EXT4_DIR_LINK_MAX(new.dir))
3896 0 : goto end_rename;
3897 : }
3898 130218 : retval = ext4_rename_dir_prepare(handle, &old);
3899 130217 : if (retval)
3900 0 : goto end_rename;
3901 : }
3902 : /*
3903 : * If we're renaming a file within an inline_data dir and adding or
3904 : * setting the new dirent causes a conversion from inline_data to
3905 : * extents/blockmap, we need to force the dirent delete code to
3906 : * re-read the directory, or else we end up trying to delete a dirent
3907 : * from what is now the extent tree root (or a block map).
3908 : */
3909 602565 : force_reread = (new.dir->i_ino == old.dir->i_ino &&
3910 : ext4_test_inode_flag(new.dir, EXT4_INODE_INLINE_DATA));
3911 :
3912 602565 : if (whiteout) {
3913 : /*
3914 : * Do this before adding a new entry, so the old entry is sure
3915 : * to be still pointing to the valid old entry.
3916 : */
3917 38255 : retval = ext4_setent(handle, &old, whiteout->i_ino,
3918 : EXT4_FT_CHRDEV);
3919 38236 : if (retval)
3920 0 : goto end_rename;
3921 38236 : retval = ext4_mark_inode_dirty(handle, whiteout);
3922 38274 : if (unlikely(retval))
3923 0 : goto end_rename;
3924 :
3925 : }
3926 602584 : if (!new.bh) {
3927 564889 : retval = ext4_add_entry(handle, new.dentry, old.inode);
3928 564879 : if (retval)
3929 245 : goto end_rename;
3930 : } else {
3931 37695 : retval = ext4_setent(handle, &new,
3932 37695 : old.inode->i_ino, old_file_type);
3933 37693 : if (retval)
3934 0 : goto end_rename;
3935 : }
3936 602327 : if (force_reread)
3937 0 : force_reread = !ext4_test_inode_flag(new.dir,
3938 : EXT4_INODE_INLINE_DATA);
3939 :
3940 : /*
3941 : * Like most other Unix systems, set the ctime for inodes on a
3942 : * rename.
3943 : */
3944 602327 : old.inode->i_ctime = current_time(old.inode);
3945 602328 : retval = ext4_mark_inode_dirty(handle, old.inode);
3946 602345 : if (unlikely(retval))
3947 0 : goto end_rename;
3948 :
3949 602345 : if (!whiteout) {
3950 : /*
3951 : * ok, that's it
3952 : */
3953 564311 : ext4_rename_delete(handle, &old, force_reread);
3954 : }
3955 :
3956 602343 : if (new.inode) {
3957 37695 : ext4_dec_count(new.inode);
3958 37695 : new.inode->i_ctime = current_time(new.inode);
3959 : }
3960 602343 : old.dir->i_ctime = old.dir->i_mtime = current_time(old.dir);
3961 602344 : ext4_update_dx_flag(old.dir);
3962 602343 : if (old.dir_bh) {
3963 130218 : retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
3964 130218 : if (retval)
3965 0 : goto end_rename;
3966 :
3967 130218 : ext4_dec_count(old.dir);
3968 130217 : if (new.inode) {
3969 : /* checked ext4_empty_dir above, can't have another
3970 : * parent, ext4_dec_count() won't work for many-linked
3971 : * dirs */
3972 159 : clear_nlink(new.inode);
3973 : } else {
3974 130058 : ext4_inc_count(new.dir);
3975 130058 : ext4_update_dx_flag(new.dir);
3976 130059 : retval = ext4_mark_inode_dirty(handle, new.dir);
3977 130058 : if (unlikely(retval))
3978 0 : goto end_rename;
3979 : }
3980 : }
3981 602342 : retval = ext4_mark_inode_dirty(handle, old.dir);
3982 602342 : if (unlikely(retval))
3983 0 : goto end_rename;
3984 :
3985 602342 : if (S_ISDIR(old.inode->i_mode)) {
3986 : /*
3987 : * We disable fast commits here that's because the
3988 : * replay code is not yet capable of changing dot dot
3989 : * dirents in directories.
3990 : */
3991 130217 : ext4_fc_mark_ineligible(old.inode->i_sb,
3992 : EXT4_FC_REASON_RENAME_DIR, handle);
3993 : } else {
3994 472125 : struct super_block *sb = old.inode->i_sb;
3995 :
3996 472125 : if (new.inode)
3997 37535 : ext4_fc_track_unlink(handle, new.dentry);
3998 472125 : if (test_opt2(sb, JOURNAL_FAST_COMMIT) &&
3999 0 : !(EXT4_SB(sb)->s_mount_state & EXT4_FC_REPLAY) &&
4000 : !(ext4_test_mount_flag(sb, EXT4_MF_FC_INELIGIBLE))) {
4001 0 : __ext4_fc_track_link(handle, old.inode, new.dentry);
4002 0 : __ext4_fc_track_unlink(handle, old.inode, old.dentry);
4003 0 : if (whiteout)
4004 0 : __ext4_fc_track_create(handle, whiteout,
4005 : old.dentry);
4006 : }
4007 : }
4008 :
4009 602342 : if (new.inode) {
4010 37693 : retval = ext4_mark_inode_dirty(handle, new.inode);
4011 37695 : if (unlikely(retval))
4012 0 : goto end_rename;
4013 37695 : if (!new.inode->i_nlink)
4014 37659 : ext4_orphan_add(handle, new.inode);
4015 : }
4016 : retval = 0;
4017 :
4018 602599 : end_rename:
4019 602599 : if (whiteout) {
4020 38283 : if (retval) {
4021 248 : ext4_resetent(handle, &old,
4022 248 : old.inode->i_ino, old_file_type);
4023 248 : drop_nlink(whiteout);
4024 248 : ext4_orphan_add(handle, whiteout);
4025 : }
4026 38283 : unlock_new_inode(whiteout);
4027 38279 : ext4_journal_stop(handle);
4028 38269 : iput(whiteout);
4029 : } else {
4030 564316 : ext4_journal_stop(handle);
4031 : }
4032 602600 : release_bh:
4033 602600 : brelse(old.dir_bh);
4034 602599 : brelse(old.bh);
4035 602600 : brelse(new.bh);
4036 :
4037 : return retval;
4038 : }
4039 :
4040 23362 : static int ext4_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
4041 : struct inode *new_dir, struct dentry *new_dentry)
4042 : {
4043 23362 : handle_t *handle = NULL;
4044 23362 : struct ext4_renament old = {
4045 : .dir = old_dir,
4046 : .dentry = old_dentry,
4047 : .inode = d_inode(old_dentry),
4048 : };
4049 23362 : struct ext4_renament new = {
4050 : .dir = new_dir,
4051 : .dentry = new_dentry,
4052 : .inode = d_inode(new_dentry),
4053 : };
4054 23362 : u8 new_file_type;
4055 23362 : int retval;
4056 23362 : struct timespec64 ctime;
4057 :
4058 23362 : if ((ext4_test_inode_flag(new_dir, EXT4_INODE_PROJINHERIT) &&
4059 0 : !projid_eq(EXT4_I(new_dir)->i_projid,
4060 23362 : EXT4_I(old_dentry->d_inode)->i_projid)) ||
4061 0 : (ext4_test_inode_flag(old_dir, EXT4_INODE_PROJINHERIT) &&
4062 0 : !projid_eq(EXT4_I(old_dir)->i_projid,
4063 0 : EXT4_I(new_dentry->d_inode)->i_projid)))
4064 : return -EXDEV;
4065 :
4066 23362 : retval = dquot_initialize(old.dir);
4067 23362 : if (retval)
4068 : return retval;
4069 23362 : retval = dquot_initialize(new.dir);
4070 23362 : if (retval)
4071 : return retval;
4072 :
4073 23362 : old.bh = ext4_find_entry(old.dir, &old.dentry->d_name,
4074 : &old.de, &old.inlined);
4075 23362 : if (IS_ERR(old.bh))
4076 0 : return PTR_ERR(old.bh);
4077 : /*
4078 : * Check for inode number is _not_ due to possible IO errors.
4079 : * We might rmdir the source, keep it as pwd of some process
4080 : * and merrily kill the link to whatever was created under the
4081 : * same name. Goodbye sticky bit ;-<
4082 : */
4083 23362 : retval = -ENOENT;
4084 23362 : if (!old.bh || le32_to_cpu(old.de->inode) != old.inode->i_ino)
4085 0 : goto end_rename;
4086 :
4087 23362 : new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
4088 : &new.de, &new.inlined);
4089 23362 : if (IS_ERR(new.bh)) {
4090 0 : retval = PTR_ERR(new.bh);
4091 0 : new.bh = NULL;
4092 0 : goto end_rename;
4093 : }
4094 :
4095 : /* RENAME_EXCHANGE case: old *and* new must both exist */
4096 23362 : if (!new.bh || le32_to_cpu(new.de->inode) != new.inode->i_ino)
4097 0 : goto end_rename;
4098 :
4099 43748 : handle = ext4_journal_start(old.dir, EXT4_HT_DIR,
4100 : (2 * EXT4_DATA_TRANS_BLOCKS(old.dir->i_sb) +
4101 : 2 * EXT4_INDEX_EXTRA_TRANS_BLOCKS + 2));
4102 23362 : if (IS_ERR(handle)) {
4103 0 : retval = PTR_ERR(handle);
4104 0 : handle = NULL;
4105 0 : goto end_rename;
4106 : }
4107 :
4108 23362 : if (IS_DIRSYNC(old.dir) || IS_DIRSYNC(new.dir))
4109 0 : ext4_handle_sync(handle);
4110 :
4111 23362 : if (S_ISDIR(old.inode->i_mode)) {
4112 2963 : old.is_dir = true;
4113 2963 : retval = ext4_rename_dir_prepare(handle, &old);
4114 2963 : if (retval)
4115 0 : goto end_rename;
4116 : }
4117 23362 : if (S_ISDIR(new.inode->i_mode)) {
4118 2963 : new.is_dir = true;
4119 2963 : retval = ext4_rename_dir_prepare(handle, &new);
4120 2963 : if (retval)
4121 0 : goto end_rename;
4122 : }
4123 :
4124 : /*
4125 : * Other than the special case of overwriting a directory, parents'
4126 : * nlink only needs to be modified if this is a cross directory rename.
4127 : */
4128 23362 : if (old.dir != new.dir && old.is_dir != new.is_dir) {
4129 8 : old.dir_nlink_delta = old.is_dir ? -1 : 1;
4130 8 : new.dir_nlink_delta = -old.dir_nlink_delta;
4131 8 : retval = -EMLINK;
4132 8 : if ((old.dir_nlink_delta > 0 && EXT4_DIR_LINK_MAX(old.dir)) ||
4133 4 : (new.dir_nlink_delta > 0 && EXT4_DIR_LINK_MAX(new.dir)))
4134 0 : goto end_rename;
4135 : }
4136 :
4137 23362 : new_file_type = new.de->file_type;
4138 23362 : retval = ext4_setent(handle, &new, old.inode->i_ino, old.de->file_type);
4139 23362 : if (retval)
4140 0 : goto end_rename;
4141 :
4142 23362 : retval = ext4_setent(handle, &old, new.inode->i_ino, new_file_type);
4143 23362 : if (retval)
4144 0 : goto end_rename;
4145 :
4146 : /*
4147 : * Like most other Unix systems, set the ctime for inodes on a
4148 : * rename.
4149 : */
4150 23362 : ctime = current_time(old.inode);
4151 23362 : old.inode->i_ctime = ctime;
4152 23362 : new.inode->i_ctime = ctime;
4153 23362 : retval = ext4_mark_inode_dirty(handle, old.inode);
4154 23362 : if (unlikely(retval))
4155 0 : goto end_rename;
4156 23362 : retval = ext4_mark_inode_dirty(handle, new.inode);
4157 23362 : if (unlikely(retval))
4158 0 : goto end_rename;
4159 23362 : ext4_fc_mark_ineligible(new.inode->i_sb,
4160 : EXT4_FC_REASON_CROSS_RENAME, handle);
4161 23362 : if (old.dir_bh) {
4162 2963 : retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
4163 2963 : if (retval)
4164 0 : goto end_rename;
4165 : }
4166 23362 : if (new.dir_bh) {
4167 2963 : retval = ext4_rename_dir_finish(handle, &new, old.dir->i_ino);
4168 2963 : if (retval)
4169 0 : goto end_rename;
4170 : }
4171 23362 : ext4_update_dir_count(handle, &old);
4172 23362 : ext4_update_dir_count(handle, &new);
4173 23362 : retval = 0;
4174 :
4175 23362 : end_rename:
4176 23362 : brelse(old.dir_bh);
4177 23362 : brelse(new.dir_bh);
4178 23362 : brelse(old.bh);
4179 23362 : brelse(new.bh);
4180 23362 : if (handle)
4181 23362 : ext4_journal_stop(handle);
4182 : return retval;
4183 : }
4184 :
4185 626172 : static int ext4_rename2(struct mnt_idmap *idmap,
4186 : struct inode *old_dir, struct dentry *old_dentry,
4187 : struct inode *new_dir, struct dentry *new_dentry,
4188 : unsigned int flags)
4189 : {
4190 626172 : int err;
4191 :
4192 1252344 : if (unlikely(ext4_forced_shutdown(EXT4_SB(old_dir->i_sb))))
4193 : return -EIO;
4194 :
4195 625936 : if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
4196 : return -EINVAL;
4197 :
4198 625936 : err = fscrypt_prepare_rename(old_dir, old_dentry, new_dir, new_dentry,
4199 : flags);
4200 625936 : if (err)
4201 : return err;
4202 :
4203 625936 : if (flags & RENAME_EXCHANGE) {
4204 23362 : return ext4_cross_rename(old_dir, old_dentry,
4205 : new_dir, new_dentry);
4206 : }
4207 :
4208 602574 : return ext4_rename(idmap, old_dir, old_dentry, new_dir, new_dentry, flags);
4209 : }
4210 :
4211 : /*
4212 : * directories can handle most operations...
4213 : */
4214 : const struct inode_operations ext4_dir_inode_operations = {
4215 : .create = ext4_create,
4216 : .lookup = ext4_lookup,
4217 : .link = ext4_link,
4218 : .unlink = ext4_unlink,
4219 : .symlink = ext4_symlink,
4220 : .mkdir = ext4_mkdir,
4221 : .rmdir = ext4_rmdir,
4222 : .mknod = ext4_mknod,
4223 : .tmpfile = ext4_tmpfile,
4224 : .rename = ext4_rename2,
4225 : .setattr = ext4_setattr,
4226 : .getattr = ext4_getattr,
4227 : .listxattr = ext4_listxattr,
4228 : .get_inode_acl = ext4_get_acl,
4229 : .set_acl = ext4_set_acl,
4230 : .fiemap = ext4_fiemap,
4231 : .fileattr_get = ext4_fileattr_get,
4232 : .fileattr_set = ext4_fileattr_set,
4233 : };
4234 :
4235 : const struct inode_operations ext4_special_inode_operations = {
4236 : .setattr = ext4_setattr,
4237 : .getattr = ext4_getattr,
4238 : .listxattr = ext4_listxattr,
4239 : .get_inode_acl = ext4_get_acl,
4240 : .set_acl = ext4_set_acl,
4241 : };
|
