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 403994 : static struct buffer_head *ext4_append(handle_t *handle,
54 : struct inode *inode,
55 : ext4_lblk_t *block)
56 : {
57 403994 : struct ext4_map_blocks map;
58 403994 : struct buffer_head *bh;
59 403994 : int err;
60 :
61 403994 : 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 403994 : *block = inode->i_size >> inode->i_sb->s_blocksize_bits;
67 403994 : map.m_lblk = *block;
68 403994 : 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 403994 : err = ext4_map_blocks(NULL, inode, &map, 0);
76 403903 : if (err < 0)
77 0 : return ERR_PTR(err);
78 403903 : if (err) {
79 0 : EXT4_ERROR_INODE(inode, "Logical block already allocated");
80 0 : return ERR_PTR(-EFSCORRUPTED);
81 : }
82 :
83 403903 : bh = ext4_bread(handle, inode, *block, EXT4_GET_BLOCKS_CREATE);
84 404091 : if (IS_ERR(bh))
85 : return bh;
86 381225 : inode->i_size += inode->i_sb->s_blocksize;
87 381225 : EXT4_I(inode)->i_disksize = inode->i_size;
88 381225 : err = ext4_mark_inode_dirty(handle, inode);
89 381197 : if (err)
90 0 : goto out;
91 381197 : BUFFER_TRACE(bh, "get_write_access");
92 381197 : err = ext4_journal_get_write_access(handle, inode->i_sb, bh,
93 : EXT4_JTR_NONE);
94 381156 : 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 15376515 : 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 15376515 : struct buffer_head *bh;
131 15376515 : struct ext4_dir_entry *dirent;
132 15376515 : int is_dx_block = 0;
133 :
134 15376515 : 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 15376515 : if (ext4_simulate_fail(inode->i_sb, EXT4_SIM_DIRBLOCK_EIO))
142 : bh = ERR_PTR(-EIO);
143 : else
144 15376515 : bh = ext4_bread(NULL, inode, block, 0);
145 15388465 : 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 15388464 : 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 15388464 : if (!bh)
161 : return NULL;
162 15388464 : dirent = (struct ext4_dir_entry *) bh->b_data;
163 : /* Determine whether or not we have an index block */
164 15388464 : if (is_dx(inode)) {
165 13745375 : if (block == 0)
166 : is_dx_block = 1;
167 7537282 : else if (ext4_rec_len_from_disk(dirent->rec_len,
168 7537282 : inode->i_sb->s_blocksize) ==
169 : inode->i_sb->s_blocksize)
170 1356267 : is_dx_block = 1;
171 : }
172 15388464 : 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 30774703 : 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 65750 : if (is_dx_block && type == INDEX) {
188 711 : if (ext4_dx_csum_verify(inode, dirent) &&
189 709 : !ext4_simulate_fail(inode->i_sb, EXT4_SIM_DIRBLOCK_CRC))
190 709 : 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 65748 : if (!is_dx_block) {
200 65038 : if (ext4_dirblock_csum_verify(inode, bh) &&
201 65036 : !ext4_simulate_fail(inode->i_sb, EXT4_SIM_DIRBLOCK_CRC))
202 65036 : 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 409178 : void ext4_initialize_dirent_tail(struct buffer_head *bh,
331 : unsigned int blocksize)
332 : {
333 409178 : struct ext4_dir_entry_tail *t = EXT4_DIRENT_TAIL(bh->b_data, blocksize);
334 :
335 409178 : memset(t, 0, sizeof(struct ext4_dir_entry_tail));
336 409178 : t->det_rec_len = ext4_rec_len_to_disk(
337 : sizeof(struct ext4_dir_entry_tail), blocksize);
338 409178 : t->det_reserved_ft = EXT4_FT_DIR_CSUM;
339 409178 : }
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 5760318 : 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 5760318 : t = EXT4_DIRENT_TAIL(bh->b_data, EXT4_BLOCK_SIZE(inode->i_sb));
364 : #endif
365 :
366 5760318 : if (t->det_reserved_zero1 ||
367 : le16_to_cpu(t->det_rec_len) != sizeof(struct ext4_dir_entry_tail) ||
368 5760318 : 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 5760188 : struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
378 5760188 : struct ext4_inode_info *ei = EXT4_I(inode);
379 5760188 : __u32 csum;
380 :
381 5760188 : csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)dirent, size);
382 5756752 : 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 66837 : int ext4_dirblock_csum_verify(struct inode *inode, struct buffer_head *bh)
396 : {
397 66837 : struct ext4_dir_entry_tail *t;
398 :
399 66837 : if (!ext4_has_metadata_csum(inode->i_sb))
400 : return 1;
401 :
402 66785 : t = get_dirent_tail(inode, bh);
403 66655 : if (!t) {
404 130 : warn_no_space_for_csum(inode);
405 130 : return 0;
406 : }
407 :
408 66652 : if (t->det_checksum != ext4_dirblock_csum(inode, bh->b_data,
409 66655 : (char *)t - bh->b_data))
410 0 : return 0;
411 :
412 : return 1;
413 : }
414 :
415 5694993 : static void ext4_dirblock_csum_set(struct inode *inode,
416 : struct buffer_head *bh)
417 : {
418 5694993 : struct ext4_dir_entry_tail *t;
419 :
420 5694993 : if (!ext4_has_metadata_csum(inode->i_sb))
421 : return;
422 :
423 5693533 : t = get_dirent_tail(inode, bh);
424 5693533 : if (!t) {
425 0 : warn_no_space_for_csum(inode);
426 0 : return;
427 : }
428 :
429 5690100 : t->det_checksum = ext4_dirblock_csum(inode, bh->b_data,
430 5693533 : (char *)t - bh->b_data);
431 : }
432 :
433 5695285 : int ext4_handle_dirty_dirblock(handle_t *handle,
434 : struct inode *inode,
435 : struct buffer_head *bh)
436 : {
437 5695285 : ext4_dirblock_csum_set(inode, bh);
438 5691117 : return ext4_handle_dirty_metadata(handle, inode, bh);
439 : }
440 :
441 73066 : static struct dx_countlimit *get_dx_countlimit(struct inode *inode,
442 : struct ext4_dir_entry *dirent,
443 : int *offset)
444 : {
445 73066 : struct ext4_dir_entry *dp;
446 73066 : struct dx_root_info *root;
447 73066 : int count_offset;
448 :
449 73066 : if (le16_to_cpu(dirent->rec_len) == EXT4_BLOCK_SIZE(inode->i_sb))
450 : count_offset = 8;
451 50358 : else if (le16_to_cpu(dirent->rec_len) == 12) {
452 50356 : dp = (struct ext4_dir_entry *)(((void *)dirent) + 12);
453 50356 : if (le16_to_cpu(dp->rec_len) !=
454 50356 : EXT4_BLOCK_SIZE(inode->i_sb) - 12)
455 : return NULL;
456 50356 : root = (struct dx_root_info *)(((void *)dp + 12));
457 50356 : if (root->reserved_zero ||
458 50356 : root->info_length != sizeof(struct dx_root_info))
459 : return NULL;
460 : count_offset = 32;
461 : } else
462 : return NULL;
463 :
464 73064 : if (offset)
465 73064 : *offset = count_offset;
466 73064 : return (struct dx_countlimit *)(((void *)dirent) + count_offset);
467 : }
468 :
469 73064 : 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 73064 : struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
473 73064 : struct ext4_inode_info *ei = EXT4_I(inode);
474 73064 : __u32 csum;
475 73064 : int size;
476 73064 : __u32 dummy_csum = 0;
477 73064 : int offset = offsetof(struct dx_tail, dt_checksum);
478 :
479 73064 : size = count_offset + (count * sizeof(struct dx_entry));
480 73064 : csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)dirent, size);
481 73064 : csum = ext4_chksum(sbi, csum, (__u8 *)t, offset);
482 73064 : csum = ext4_chksum(sbi, csum, (__u8 *)&dummy_csum, sizeof(dummy_csum));
483 :
484 73064 : return cpu_to_le32(csum);
485 : }
486 :
487 711 : static int ext4_dx_csum_verify(struct inode *inode,
488 : struct ext4_dir_entry *dirent)
489 : {
490 711 : struct dx_countlimit *c;
491 711 : struct dx_tail *t;
492 711 : int count_offset, limit, count;
493 :
494 711 : if (!ext4_has_metadata_csum(inode->i_sb))
495 : return 1;
496 :
497 711 : c = get_dx_countlimit(inode, dirent, &count_offset);
498 711 : if (!c) {
499 2 : EXT4_ERROR_INODE(inode, "dir seems corrupt? Run e2fsck -D.");
500 2 : return 0;
501 : }
502 709 : limit = le16_to_cpu(c->limit);
503 709 : count = le16_to_cpu(c->count);
504 709 : if (count_offset + (limit * sizeof(struct dx_entry)) >
505 709 : EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) {
506 0 : warn_no_space_for_csum(inode);
507 0 : return 0;
508 : }
509 709 : t = (struct dx_tail *)(((struct dx_entry *)c) + limit);
510 :
511 709 : if (t->dt_checksum != ext4_dx_csum(inode, dirent, count_offset,
512 : count, t))
513 0 : return 0;
514 : return 1;
515 : }
516 :
517 72355 : static void ext4_dx_csum_set(struct inode *inode, struct ext4_dir_entry *dirent)
518 : {
519 72355 : struct dx_countlimit *c;
520 72355 : struct dx_tail *t;
521 72355 : int count_offset, limit, count;
522 :
523 72355 : if (!ext4_has_metadata_csum(inode->i_sb))
524 0 : return;
525 :
526 72355 : c = get_dx_countlimit(inode, dirent, &count_offset);
527 72355 : if (!c) {
528 0 : EXT4_ERROR_INODE(inode, "dir seems corrupt? Run e2fsck -D.");
529 0 : return;
530 : }
531 72355 : limit = le16_to_cpu(c->limit);
532 72355 : count = le16_to_cpu(c->count);
533 72355 : if (count_offset + (limit * sizeof(struct dx_entry)) >
534 72355 : EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) {
535 0 : warn_no_space_for_csum(inode);
536 0 : return;
537 : }
538 72355 : t = (struct dx_tail *)(((struct dx_entry *)c) + limit);
539 :
540 72355 : t->dt_checksum = ext4_dx_csum(inode, dirent, count_offset, count, t);
541 : }
542 :
543 72355 : static inline int ext4_handle_dirty_dx_node(handle_t *handle,
544 : struct inode *inode,
545 : struct buffer_head *bh)
546 : {
547 72355 : ext4_dx_csum_set(inode, (struct ext4_dir_entry *)bh->b_data);
548 72355 : 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 230921391 : return (struct ext4_dir_entry_2 *)((char *)p +
558 230921391 : 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 13676682 : 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 30381 : entry->block = cpu_to_le32(value);
574 : }
575 :
576 : static inline unsigned dx_get_hash(struct dx_entry *entry)
577 : {
578 29906197 : return le32_to_cpu(entry->hash);
579 : }
580 :
581 : static inline void dx_set_hash(struct dx_entry *entry, unsigned value)
582 : {
583 29098 : entry->hash = cpu_to_le32(value);
584 : }
585 :
586 : static inline unsigned dx_get_count(struct dx_entry *entries)
587 : {
588 10404312 : return le16_to_cpu(((struct dx_countlimit *) entries)->count);
589 : }
590 :
591 : static inline unsigned dx_get_limit(struct dx_entry *entries)
592 : {
593 15087958 : 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 30584 : ((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 1486 : ((struct dx_countlimit *) entries)->limit = cpu_to_le16(value);
604 : }
605 :
606 6156683 : static inline unsigned dx_root_limit(struct inode *dir, unsigned infosize)
607 : {
608 6156683 : unsigned int entry_space = dir->i_sb->s_blocksize -
609 6156683 : ext4_dir_rec_len(1, NULL) -
610 : ext4_dir_rec_len(2, NULL) - infosize;
611 :
612 6156683 : if (ext4_has_metadata_csum(dir->i_sb))
613 6156164 : entry_space -= sizeof(struct dx_tail);
614 6156679 : return entry_space / sizeof(struct dx_entry);
615 : }
616 :
617 1356456 : static inline unsigned dx_node_limit(struct inode *dir)
618 : {
619 1356456 : unsigned int entry_space = dir->i_sb->s_blocksize -
620 : ext4_dir_rec_len(0, dir);
621 :
622 1356456 : if (ext4_has_metadata_csum(dir->i_sb))
623 1356456 : entry_space -= sizeof(struct dx_tail);
624 1356456 : 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 6168412 : dx_probe(struct ext4_filename *fname, struct inode *dir,
808 : struct dx_hash_info *hinfo, struct dx_frame *frame_in)
809 : {
810 6168412 : unsigned count, indirect, level, i;
811 6168412 : struct dx_entry *at, *entries, *p, *q, *m;
812 6168412 : struct dx_root *root;
813 6168412 : struct dx_frame *frame = frame_in;
814 6168412 : struct dx_frame *ret_err = ERR_PTR(ERR_BAD_DX_DIR);
815 6168412 : u32 hash;
816 6168412 : ext4_lblk_t block;
817 6168412 : ext4_lblk_t blocks[EXT4_HTREE_LEVEL];
818 :
819 6168412 : memset(frame_in, 0, EXT4_HTREE_LEVEL * sizeof(frame_in[0]));
820 6168412 : frame->bh = ext4_read_dirblock(dir, 0, INDEX);
821 6166959 : if (IS_ERR(frame->bh))
822 : return (struct dx_frame *) frame->bh;
823 :
824 6166957 : root = (struct dx_root *) frame->bh->b_data;
825 6166957 : if (root->info.hash_version != DX_HASH_TEA &&
826 : root->info.hash_version != DX_HASH_HALF_MD4 &&
827 6166957 : 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 6166957 : 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 6166957 : 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 6166957 : if (fname)
847 5448230 : hinfo = &fname->hinfo;
848 6166957 : hinfo->hash_version = root->info.hash_version;
849 6166957 : if (hinfo->hash_version <= DX_HASH_TEA)
850 6165619 : hinfo->hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
851 6166957 : hinfo->seed = EXT4_SB(dir->i_sb)->s_hash_seed;
852 : /* hash is already computed for encrypted casefolded directory */
853 6166957 : if (fname && fname_name(fname) &&
854 5445958 : !(IS_ENCRYPTED(dir) && IS_CASEFOLDED(dir))) {
855 5445359 : int ret = ext4fs_dirhash(dir, fname_name(fname),
856 5445359 : fname_len(fname), hinfo);
857 5439570 : if (ret < 0) {
858 0 : ret_err = ERR_PTR(ret);
859 0 : goto fail;
860 : }
861 : }
862 6161168 : hash = hinfo->hash;
863 :
864 6161168 : 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 6161168 : indirect = root->info.indirect_levels;
871 11523907 : 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 6161168 : entries = (struct dx_entry *)(((char *)&root->info) +
884 6161168 : root->info.info_length);
885 :
886 6161168 : 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 6157138 : dxtrace(printk("Look up %x", hash));
895 6157138 : level = 0;
896 6157138 : blocks[0] = 0;
897 7513387 : while (1) {
898 7513387 : count = dx_get_count(entries);
899 7513387 : 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 7513387 : p = entries + 1;
907 7513387 : q = entries + count - 1;
908 35066490 : while (p <= q) {
909 27553103 : m = p + (q - p) / 2;
910 27553103 : dxtrace(printk(KERN_CONT "."));
911 27553103 : if (dx_get_hash(m) > hash)
912 13583454 : q = m - 1;
913 : else
914 13969649 : p = m + 1;
915 : }
916 :
917 7513387 : htree_rep_invariant_check(entries, p, hash, count - 1);
918 :
919 7513387 : at = p - 1;
920 : dxtrace(printk(KERN_CONT " %x->%u\n",
921 : at == entries ? 0 : dx_get_hash(at),
922 7513387 : dx_get_block(at)));
923 7513387 : frame->entries = entries;
924 7513387 : frame->at = at;
925 :
926 7513387 : block = dx_get_block(at);
927 16726167 : for (i = 0; i <= level; i++) {
928 9209935 : 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 7516232 : if (++level > indirect)
936 6159983 : return frame;
937 1356249 : blocks[level] = block;
938 1356249 : frame++;
939 1356249 : frame->bh = ext4_read_dirblock(dir, block, INDEX);
940 1356249 : 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 1356249 : entries = ((struct dx_node *) frame->bh->b_data)->entries;
947 :
948 1356249 : 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 6176235 : static void dx_release(struct dx_frame *frames)
968 : {
969 6176235 : struct dx_root_info *info;
970 6176235 : int i;
971 6176235 : unsigned int indirect_levels;
972 :
973 6176235 : if (frames[0].bh == NULL)
974 : return;
975 :
976 6176235 : info = &((struct dx_root *)frames[0].bh->b_data)->info;
977 : /* save local copy, "info" may be freed after brelse() */
978 6176235 : indirect_levels = info->indirect_levels;
979 13709238 : for (i = 0; i <= indirect_levels; i++) {
980 7532287 : if (frames[i].bh == NULL)
981 : break;
982 7532283 : brelse(frames[i].bh);
983 7533003 : 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 2828726 : 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 2828726 : struct dx_frame *p;
1010 2828726 : struct buffer_head *bh;
1011 2828726 : int num_frames = 0;
1012 2828726 : __u32 bhash;
1013 :
1014 2828726 : 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 2838402 : while (1) {
1023 2833564 : if (++(p->at) < p->entries + dx_get_count(p->entries))
1024 : break;
1025 480673 : if (p == frames)
1026 : return 0;
1027 4838 : num_frames++;
1028 4838 : 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 2352891 : bhash = dx_get_hash(p->at);
1039 2352891 : if (start_hash)
1040 697519 : *start_hash = bhash;
1041 2352891 : if ((hash & 1) == 0) {
1042 1655292 : 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 697615 : while (num_frames--) {
1050 96 : 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 836332 : 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 836332 : struct buffer_head *bh;
1073 836332 : struct ext4_dir_entry_2 *de, *top;
1074 836332 : int err = 0, count = 0;
1075 836332 : struct fscrypt_str fname_crypto_str = FSTR_INIT(NULL, 0), tmp_str;
1076 836332 : int csum = ext4_has_metadata_csum(dir->i_sb);
1077 :
1078 : dxtrace(printk(KERN_INFO "In htree dirblock_to_tree: block %lu\n",
1079 836304 : (unsigned long)block));
1080 836304 : bh = ext4_read_dirblock(dir, block, DIRENT_HTREE);
1081 836352 : if (IS_ERR(bh))
1082 1 : return PTR_ERR(bh);
1083 :
1084 836351 : de = (struct ext4_dir_entry_2 *) bh->b_data;
1085 : /* csum entries are not larger in the casefolded encrypted case */
1086 1672702 : top = (struct ext4_dir_entry_2 *) ((char *) de +
1087 1672702 : dir->i_sb->s_blocksize -
1088 836351 : ext4_dir_rec_len(0,
1089 : csum ? NULL : dir));
1090 : /* Check if the directory is encrypted */
1091 836351 : 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 158046148 : for (; de < top; de = ext4_next_entry(de, dir->i_sb->s_blocksize)) {
1106 157209812 : 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 157210036 : 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 157210036 : err = ext4fs_dirhash(dir, de->name,
1123 157210036 : de->name_len, hinfo);
1124 157210260 : if (err < 0) {
1125 0 : count = err;
1126 0 : goto errout;
1127 : }
1128 : }
1129 157210260 : if ((hinfo->hash < start_hash) ||
1130 643579 : ((hinfo->hash == start_hash) &&
1131 643579 : (hinfo->minor_hash < start_minor_hash)))
1132 620372 : continue;
1133 156589888 : if (de->inode == 0)
1134 752336 : continue;
1135 155837552 : if (!IS_ENCRYPTED(dir)) {
1136 155837552 : tmp_str.name = de->name;
1137 155837552 : tmp_str.len = de->name_len;
1138 155837552 : 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 155837089 : if (err != 0) {
1160 0 : count = err;
1161 0 : goto errout;
1162 : }
1163 155837089 : count++;
1164 : }
1165 836336 : errout:
1166 836336 : 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 836335 : int ext4_htree_fill_tree(struct file *dir_file, __u32 start_hash,
1181 : __u32 start_minor_hash, __u32 *next_hash)
1182 : {
1183 836335 : struct dx_hash_info hinfo;
1184 836335 : struct ext4_dir_entry_2 *de;
1185 836335 : struct dx_frame frames[EXT4_HTREE_LEVEL], *frame;
1186 836335 : struct inode *dir;
1187 836335 : ext4_lblk_t block;
1188 836335 : int count = 0;
1189 836335 : int ret, err;
1190 836335 : __u32 hashval;
1191 836335 : struct fscrypt_str tmp_str;
1192 :
1193 : dxtrace(printk(KERN_DEBUG "In htree_fill_tree, start hash: %x:%x\n",
1194 836335 : start_hash, start_minor_hash));
1195 836335 : dir = file_inode(dir_file);
1196 836335 : if (!(ext4_test_inode_flag(dir, EXT4_INODE_INDEX))) {
1197 117609 : if (ext4_hash_in_dirent(dir))
1198 0 : hinfo.hash_version = DX_HASH_SIPHASH;
1199 : else
1200 117609 : hinfo.hash_version =
1201 117609 : EXT4_SB(dir->i_sb)->s_def_hash_version;
1202 117609 : if (hinfo.hash_version <= DX_HASH_TEA)
1203 117600 : hinfo.hash_version +=
1204 117600 : EXT4_SB(dir->i_sb)->s_hash_unsigned;
1205 117609 : hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
1206 117609 : 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 117609 : count = htree_dirblock_to_tree(dir_file, dir, 0, &hinfo,
1218 : start_hash, start_minor_hash);
1219 117639 : *next_hash = ~0;
1220 117639 : return count;
1221 : }
1222 718726 : hinfo.hash = start_hash;
1223 718726 : hinfo.minor_hash = 0;
1224 718726 : frame = dx_probe(NULL, dir, &hinfo, frames);
1225 718726 : if (IS_ERR(frame))
1226 0 : return PTR_ERR(frame);
1227 :
1228 : /* Add '.' and '..' from the htree header */
1229 718726 : if (!start_hash && !start_minor_hash) {
1230 26341 : de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data;
1231 26341 : tmp_str.name = de->name;
1232 26341 : tmp_str.len = de->name_len;
1233 26341 : err = ext4_htree_store_dirent(dir_file, 0, 0,
1234 : de, &tmp_str);
1235 26339 : if (err != 0)
1236 0 : goto errout;
1237 : count++;
1238 : }
1239 718724 : if (start_hash < 2 || (start_hash ==2 && start_minor_hash==0)) {
1240 76289 : de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data;
1241 76289 : de = ext4_next_entry(de, dir->i_sb->s_blocksize);
1242 76289 : tmp_str.name = de->name;
1243 76289 : tmp_str.len = de->name_len;
1244 76289 : err = ext4_htree_store_dirent(dir_file, 2, 0,
1245 : de, &tmp_str);
1246 76289 : if (err != 0)
1247 0 : goto errout;
1248 76289 : count++;
1249 : }
1250 :
1251 718730 : while (1) {
1252 718730 : if (fatal_signal_pending(current)) {
1253 0 : err = -ERESTARTSYS;
1254 0 : goto errout;
1255 : }
1256 718729 : cond_resched();
1257 718730 : block = dx_get_block(frame->at);
1258 718730 : ret = htree_dirblock_to_tree(dir_file, dir, block, &hinfo,
1259 : start_hash, start_minor_hash);
1260 718734 : if (ret < 0) {
1261 0 : err = ret;
1262 0 : goto errout;
1263 : }
1264 718734 : count += ret;
1265 718734 : hashval = ~0;
1266 718734 : ret = ext4_htree_next_block(dir, HASH_NB_ALWAYS,
1267 : frame, frames, &hashval);
1268 718733 : *next_hash = hashval;
1269 718733 : 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 718733 : if ((ret == 0) ||
1279 697511 : (count && ((hashval & 1) == 0)))
1280 : break;
1281 : }
1282 718727 : dx_release(frames);
1283 : dxtrace(printk(KERN_DEBUG "Fill tree: returned %d entries, "
1284 718727 : "next hash: %x\n", count, *next_hash));
1285 718727 : return count;
1286 0 : errout:
1287 0 : dx_release(frames);
1288 0 : return (err);
1289 : }
1290 :
1291 6036096 : 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 6036096 : 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 28895 : 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 28895 : int count = 0;
1314 28895 : struct ext4_dir_entry_2 *de = (struct ext4_dir_entry_2 *)bh->b_data;
1315 28895 : unsigned int buflen = bh->b_size;
1316 28895 : char *base = bh->b_data;
1317 28895 : struct dx_hash_info h = *hinfo;
1318 :
1319 28895 : if (ext4_has_metadata_csum(dir->i_sb))
1320 28895 : buflen -= sizeof(struct ext4_dir_entry_tail);
1321 :
1322 2195481 : while ((char *) de < base + buflen) {
1323 2166586 : if (ext4_check_dir_entry(dir, NULL, de, bh, base, buflen,
1324 : ((char *)de) - base))
1325 : return -EFSCORRUPTED;
1326 2166507 : if (de->name_len && de->inode) {
1327 2166504 : if (ext4_hash_in_dirent(dir))
1328 0 : h.hash = EXT4_DIRENT_HASH(de);
1329 : else {
1330 2166504 : int err = ext4fs_dirhash(dir, de->name,
1331 : de->name_len, &h);
1332 2166580 : if (err < 0)
1333 0 : return err;
1334 : }
1335 2166580 : map_tail--;
1336 2166580 : map_tail->hash = h.hash;
1337 2166580 : map_tail->offs = ((char *) de - base)>>2;
1338 2166580 : map_tail->size = le16_to_cpu(de->rec_len);
1339 2166580 : count++;
1340 2166580 : cond_resched();
1341 : }
1342 2166586 : de = ext4_next_entry(de, dir->i_sb->s_blocksize);
1343 : }
1344 : return count;
1345 : }
1346 :
1347 : /* Sort map by hash value */
1348 28895 : static void dx_sort_map (struct dx_map_entry *map, unsigned count)
1349 : {
1350 28895 : struct dx_map_entry *p, *q, *top = map + count - 1;
1351 28895 : int more;
1352 : /* Combsort until bubble sort doesn't suck */
1353 311259 : while (count > 2) {
1354 282364 : count = count*10/13;
1355 282364 : if (count - 9 < 2) /* 9, 10 -> 11 */
1356 5949 : count = 11;
1357 24570701 : for (p = top, q = p - count; q >= map; p--, q--)
1358 24288337 : if (p->hash < q->hash)
1359 24288337 : swap(*p, *q);
1360 : }
1361 : /* Garden variety bubble sort */
1362 62759 : do {
1363 62759 : more = 0;
1364 62759 : q = top;
1365 5539584 : while (q-- > map) {
1366 5476825 : if (q[1].hash >= q[0].hash)
1367 4927426 : continue;
1368 549399 : swap(*(q+1), *q);
1369 549399 : more = 1;
1370 : }
1371 62759 : } while(more);
1372 28895 : }
1373 :
1374 29098 : static void dx_insert_block(struct dx_frame *frame, u32 hash, ext4_lblk_t block)
1375 : {
1376 29098 : struct dx_entry *entries = frame->entries;
1377 29098 : struct dx_entry *old = frame->at, *new = old + 1;
1378 29098 : int count = dx_get_count(entries);
1379 :
1380 29098 : ASSERT(count < dx_get_limit(entries));
1381 29098 : ASSERT(old < entries + count);
1382 58196 : memmove(new + 1, new, (char *)(entries + count) - (char *)(new));
1383 29098 : dx_set_hash(new, hash);
1384 29098 : dx_set_block(new, block);
1385 29098 : dx_set_count(entries, count + 1);
1386 29098 : }
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 : 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 : const struct super_block *sb = parent->i_sb;
1401 : const struct unicode_map *um = sb->s_encoding;
1402 : struct fscrypt_str decrypted_name = FSTR_INIT(NULL, de_name_len);
1403 : struct qstr entry = QSTR_INIT(de_name, de_name_len);
1404 : int ret;
1405 :
1406 : if (IS_ENCRYPTED(parent)) {
1407 : const struct fscrypt_str encrypted_name =
1408 : FSTR_INIT(de_name, de_name_len);
1409 :
1410 : decrypted_name.name = kmalloc(de_name_len, GFP_KERNEL);
1411 : if (!decrypted_name.name)
1412 : return -ENOMEM;
1413 : ret = fscrypt_fname_disk_to_usr(parent, 0, 0, &encrypted_name,
1414 : &decrypted_name);
1415 : if (ret < 0)
1416 : goto out;
1417 : entry.name = decrypted_name.name;
1418 : entry.len = decrypted_name.len;
1419 : }
1420 :
1421 : if (quick)
1422 : ret = utf8_strncasecmp_folded(um, name, &entry);
1423 : else
1424 : ret = utf8_strncasecmp(um, name, &entry);
1425 : if (ret < 0) {
1426 : /* Handle invalid character sequence as either an error
1427 : * or as an opaque byte sequence.
1428 : */
1429 : if (sb_has_strict_encoding(sb))
1430 : ret = -EINVAL;
1431 : else if (name->len != entry.len)
1432 : ret = 1;
1433 : else
1434 : ret = !!memcmp(name->name, entry.name, entry.len);
1435 : }
1436 : out:
1437 : kfree(decrypted_name.name);
1438 : return ret;
1439 : }
1440 :
1441 : int ext4_fname_setup_ci_filename(struct inode *dir, const struct qstr *iname,
1442 : struct ext4_filename *name)
1443 : {
1444 : struct fscrypt_str *cf_name = &name->cf_name;
1445 : struct dx_hash_info *hinfo = &name->hinfo;
1446 : int len;
1447 :
1448 : if (!IS_CASEFOLDED(dir) || !dir->i_sb->s_encoding ||
1449 : (IS_ENCRYPTED(dir) && !fscrypt_has_encryption_key(dir))) {
1450 : cf_name->name = NULL;
1451 : return 0;
1452 : }
1453 :
1454 : cf_name->name = kmalloc(EXT4_NAME_LEN, GFP_NOFS);
1455 : if (!cf_name->name)
1456 : return -ENOMEM;
1457 :
1458 : len = utf8_casefold(dir->i_sb->s_encoding,
1459 : iname, cf_name->name,
1460 : EXT4_NAME_LEN);
1461 : if (len <= 0) {
1462 : kfree(cf_name->name);
1463 : cf_name->name = NULL;
1464 : }
1465 : cf_name->len = (unsigned) len;
1466 : if (!IS_ENCRYPTED(dir))
1467 : return 0;
1468 :
1469 : hinfo->hash_version = DX_HASH_SIPHASH;
1470 : hinfo->seed = NULL;
1471 : if (cf_name->name)
1472 : return ext4fs_dirhash(dir, cf_name->name, cf_name->len, hinfo);
1473 : else
1474 : 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 640839212 : static bool ext4_match(struct inode *parent,
1484 : const struct ext4_filename *fname,
1485 : struct ext4_dir_entry_2 *de)
1486 : {
1487 640839212 : struct fscrypt_name f;
1488 :
1489 640839212 : if (!de->inode)
1490 : return false;
1491 :
1492 636376475 : f.usr_fname = fname->usr_fname;
1493 636376475 : 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 : if (parent->i_sb->s_encoding && IS_CASEFOLDED(parent) &&
1500 : (!IS_ENCRYPTED(parent) || fscrypt_has_encryption_key(parent))) {
1501 : if (fname->cf_name.name) {
1502 : struct qstr cf = {.name = fname->cf_name.name,
1503 : .len = fname->cf_name.len};
1504 : 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 : return !ext4_ci_compare(parent, &cf, de->name,
1513 : de->name_len, true);
1514 : }
1515 : return !ext4_ci_compare(parent, fname->usr_fname, de->name,
1516 : de->name_len, false);
1517 : }
1518 : #endif
1519 :
1520 636376475 : 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 6033554 : 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 6033554 : struct ext4_dir_entry_2 * de;
1531 6033554 : char * dlimit;
1532 6033554 : int de_len;
1533 :
1534 6033554 : de = (struct ext4_dir_entry_2 *)search_buf;
1535 6033554 : dlimit = search_buf + buf_size;
1536 375681735 : while ((char *) de < dlimit - EXT4_BASE_DIR_LEN) {
1537 : /* this code is executed quadratically often */
1538 : /* do minimal checking `by hand' */
1539 744405474 : if (de->name + de->name_len <= dlimit &&
1540 372230638 : ext4_match(dir, fname, de)) {
1541 : /* found a match - just to be sure, do
1542 : * a full check */
1543 2526655 : if (ext4_check_dir_entry(dir, NULL, de, bh, search_buf,
1544 : buf_size, offset))
1545 : return -1;
1546 2526375 : *res_dir = de;
1547 2526375 : return 1;
1548 : }
1549 : /* prevent looping on a bad block */
1550 369648181 : de_len = ext4_rec_len_from_disk(de->rec_len,
1551 : dir->i_sb->s_blocksize);
1552 369648181 : if (de_len <= 0)
1553 : return -1;
1554 369648181 : offset += de_len;
1555 369648181 : de = (struct ext4_dir_entry_2 *) ((char *) de + de_len);
1556 : }
1557 : return 0;
1558 : }
1559 :
1560 1375 : static int is_dx_internal_node(struct inode *dir, ext4_lblk_t block,
1561 : struct ext4_dir_entry *de)
1562 : {
1563 1375 : struct super_block *sb = dir->i_sb;
1564 :
1565 1375 : 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 6033977 : 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 6033977 : struct super_block *sb;
1593 6033977 : struct buffer_head *bh_use[NAMEI_RA_SIZE];
1594 6033977 : struct buffer_head *bh, *ret = NULL;
1595 6033977 : ext4_lblk_t start, block;
1596 6033977 : const u8 *name = fname->usr_fname->name;
1597 6033977 : size_t ra_max = 0; /* Number of bh's in the readahead
1598 : buffer, bh_use[] */
1599 6033977 : size_t ra_ptr = 0; /* Current index into readahead
1600 : buffer */
1601 6033977 : ext4_lblk_t nblocks;
1602 6033977 : int i, namelen, retval;
1603 :
1604 6033977 : *res_dir = NULL;
1605 6033977 : sb = dir->i_sb;
1606 6033977 : namelen = fname->usr_fname->len;
1607 6033977 : if (namelen > EXT4_NAME_LEN)
1608 : return NULL;
1609 :
1610 6033977 : 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 6033977 : 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 6033968 : if (is_dx(dir)) {
1631 3685064 : 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 3690049 : if (!IS_ERR(ret) || PTR_ERR(ret) != ERR_BAD_DX_DIR)
1638 3690049 : goto cleanup_and_exit;
1639 : dxtrace(printk(KERN_DEBUG "ext4_find_entry: dx failed, "
1640 : "falling back\n"));
1641 : ret = NULL;
1642 : }
1643 2348904 : nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
1644 2348904 : if (!nblocks) {
1645 0 : ret = NULL;
1646 0 : goto cleanup_and_exit;
1647 : }
1648 2348904 : start = EXT4_I(dir)->i_dir_start_lookup;
1649 2348904 : if (start >= nblocks)
1650 0 : start = 0;
1651 : block = start;
1652 2348913 : restart:
1653 2348964 : do {
1654 : /*
1655 : * We deal with the read-ahead logic here.
1656 : */
1657 2348964 : cond_resched();
1658 2349083 : if (ra_ptr >= ra_max) {
1659 : /* Refill the readahead buffer */
1660 2349229 : ra_ptr = 0;
1661 2349229 : if (block < start)
1662 0 : ra_max = start - block;
1663 : else
1664 2349229 : ra_max = nblocks - block;
1665 2349229 : ra_max = min(ra_max, ARRAY_SIZE(bh_use));
1666 2349229 : retval = ext4_bread_batch(dir, block, ra_max,
1667 : false /* wait */, bh_use);
1668 2346886 : if (retval) {
1669 0 : ret = ERR_PTR(retval);
1670 0 : ra_max = 0;
1671 0 : goto cleanup_and_exit;
1672 : }
1673 : }
1674 2346740 : if ((bh = bh_use[ra_ptr++]) == NULL)
1675 0 : goto next;
1676 2346749 : wait_on_buffer(bh);
1677 4695003 : 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 4696431 : if (!buffer_verified(bh) &&
1686 1375 : !is_dx_internal_node(dir, block,
1687 2750 : (struct ext4_dir_entry *)bh->b_data) &&
1688 1375 : !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 2347398 : set_buffer_verified(bh);
1697 4694796 : i = search_dirblock(bh, dir, fname,
1698 2347398 : block << EXT4_BLOCK_SIZE_BITS(sb), res_dir);
1699 2351819 : if (i == 1) {
1700 946604 : EXT4_I(dir)->i_dir_start_lookup = block;
1701 946604 : ret = bh;
1702 946604 : goto cleanup_and_exit;
1703 : } else {
1704 1405215 : brelse(bh);
1705 1405538 : if (i < 0)
1706 0 : goto cleanup_and_exit;
1707 : }
1708 1405538 : next:
1709 1405538 : if (++block >= nblocks)
1710 1405512 : block = 0;
1711 1405538 : } 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 1405487 : block = nblocks;
1718 1405487 : nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
1719 1405487 : if (block < nblocks) {
1720 0 : start = 0;
1721 0 : goto restart;
1722 : }
1723 :
1724 6042271 : cleanup_and_exit:
1725 : /* Clean up the read-ahead blocks */
1726 6042277 : for (; ra_ptr < ra_max; ra_ptr++)
1727 331 : brelse(bh_use[ra_ptr]);
1728 : return ret;
1729 : }
1730 :
1731 2881466 : 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 2881466 : int err;
1737 2881466 : struct ext4_filename fname;
1738 2881466 : struct buffer_head *bh;
1739 :
1740 2881466 : err = ext4_fname_setup_filename(dir, d_name, 1, &fname);
1741 2881466 : if (err == -ENOENT)
1742 : return NULL;
1743 2881466 : if (err)
1744 : return ERR_PTR(err);
1745 :
1746 2881466 : bh = __ext4_find_entry(dir, &fname, res_dir, inlined);
1747 :
1748 2883179 : ext4_fname_free_filename(&fname);
1749 2883179 : return bh;
1750 : }
1751 :
1752 3150348 : static struct buffer_head *ext4_lookup_entry(struct inode *dir,
1753 : struct dentry *dentry,
1754 : struct ext4_dir_entry_2 **res_dir)
1755 : {
1756 3150348 : int err;
1757 3150348 : struct ext4_filename fname;
1758 3150348 : struct buffer_head *bh;
1759 :
1760 3150348 : err = ext4_fname_prepare_lookup(dir, dentry, &fname);
1761 3150348 : generic_set_encrypted_ci_d_ops(dentry);
1762 3149609 : if (err == -ENOENT)
1763 : return NULL;
1764 3149609 : if (err)
1765 : return ERR_PTR(err);
1766 :
1767 3149609 : bh = __ext4_find_entry(dir, &fname, res_dir, NULL);
1768 :
1769 3158880 : ext4_fname_free_filename(&fname);
1770 3158880 : return bh;
1771 : }
1772 :
1773 3681887 : 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 3681887 : struct super_block * sb = dir->i_sb;
1778 3681887 : struct dx_frame frames[EXT4_HTREE_LEVEL], *frame;
1779 3681887 : struct buffer_head *bh;
1780 3681887 : ext4_lblk_t block;
1781 3681887 : int retval;
1782 :
1783 : #ifdef CONFIG_FS_ENCRYPTION
1784 : *res_dir = NULL;
1785 : #endif
1786 3681887 : frame = dx_probe(fname, dir, NULL, frames);
1787 3680930 : if (IS_ERR(frame))
1788 : return (struct buffer_head *) frame;
1789 3680932 : do {
1790 3680932 : block = dx_get_block(frame->at);
1791 3680932 : bh = ext4_read_dirblock(dir, block, DIRENT_HTREE);
1792 3689515 : if (IS_ERR(bh))
1793 0 : goto errout;
1794 :
1795 7379030 : retval = search_dirblock(bh, dir, fname,
1796 3689515 : block << EXT4_BLOCK_SIZE_BITS(sb),
1797 : res_dir);
1798 3689656 : if (retval == 1)
1799 1579835 : goto success;
1800 2109821 : brelse(bh);
1801 2110044 : 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 2110044 : retval = ext4_htree_next_block(dir, fname->hinfo.hash, frame,
1808 : frames, NULL);
1809 2109817 : 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 2109817 : } while (retval == 1);
1817 :
1818 : bh = NULL;
1819 3689648 : errout:
1820 3689648 : dxtrace(printk(KERN_DEBUG "%s not found\n", fname->usr_fname->name));
1821 3689648 : success:
1822 3689648 : dx_release(frames);
1823 3689648 : return bh;
1824 : }
1825 :
1826 3152438 : static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
1827 : {
1828 3152438 : struct inode *inode;
1829 3152438 : struct ext4_dir_entry_2 *de;
1830 3152438 : struct buffer_head *bh;
1831 :
1832 3152438 : if (dentry->d_name.len > EXT4_NAME_LEN)
1833 : return ERR_PTR(-ENAMETOOLONG);
1834 :
1835 3151623 : bh = ext4_lookup_entry(dir, dentry, &de);
1836 3158824 : if (IS_ERR(bh))
1837 : return ERR_CAST(bh);
1838 3158691 : inode = NULL;
1839 3158691 : if (bh) {
1840 227463 : __u32 ino = le32_to_cpu(de->inode);
1841 227463 : brelse(bh);
1842 227467 : 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 227467 : 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 227467 : inode = ext4_iget(dir->i_sb, ino, EXT4_IGET_NORMAL);
1852 227458 : 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 227458 : 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 : 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 3158686 : 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 28895 : dx_move_dirents(struct inode *dir, char *from, char *to,
1912 : struct dx_map_entry *map, int count,
1913 : unsigned blocksize)
1914 : {
1915 28895 : unsigned rec_len = 0;
1916 :
1917 1116254 : while (count--) {
1918 1087359 : struct ext4_dir_entry_2 *de = (struct ext4_dir_entry_2 *)
1919 1087359 : (from + (map->offs<<2));
1920 1087359 : rec_len = ext4_dir_rec_len(de->name_len, dir);
1921 :
1922 2174718 : memcpy (to, de, rec_len);
1923 1087359 : ((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 1087359 : de->inode = 0;
1928 1087359 : 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 1087359 : map++;
1934 1087359 : to += rec_len;
1935 : }
1936 28895 : 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 28895 : static struct ext4_dir_entry_2 *dx_pack_dirents(struct inode *dir, char *base,
1944 : unsigned int blocksize)
1945 : {
1946 28895 : struct ext4_dir_entry_2 *next, *to, *prev, *de = (struct ext4_dir_entry_2 *) base;
1947 28895 : unsigned rec_len = 0;
1948 :
1949 28895 : prev = to = de;
1950 2224297 : while ((char*)de < base + blocksize) {
1951 2195402 : next = ext4_next_entry(de, blocksize);
1952 2195402 : if (de->inode && de->name_len) {
1953 1079197 : rec_len = ext4_dir_rec_len(de->name_len, dir);
1954 1079197 : if (de > to)
1955 1537320 : memmove(to, de, rec_len);
1956 1079197 : to->rec_len = ext4_rec_len_to_disk(rec_len, blocksize);
1957 1079197 : prev = to;
1958 1079197 : to = (struct ext4_dir_entry_2 *) (((char *) to) + rec_len);
1959 : }
1960 : de = next;
1961 : }
1962 28895 : 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 29125 : 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 29125 : unsigned blocksize = dir->i_sb->s_blocksize;
1975 29125 : unsigned continued;
1976 29125 : int count;
1977 29125 : struct buffer_head *bh2;
1978 29125 : ext4_lblk_t newblock;
1979 29125 : u32 hash2;
1980 29125 : struct dx_map_entry *map;
1981 29125 : char *data1 = (*bh)->b_data, *data2;
1982 29125 : unsigned split, move, size;
1983 29125 : struct ext4_dir_entry_2 *de = NULL, *de2;
1984 29125 : int csum_size = 0;
1985 29125 : int err = 0, i;
1986 :
1987 29125 : if (ext4_has_metadata_csum(dir->i_sb))
1988 29125 : csum_size = sizeof(struct ext4_dir_entry_tail);
1989 :
1990 29125 : bh2 = ext4_append(handle, dir, &newblock);
1991 29125 : if (IS_ERR(bh2)) {
1992 230 : brelse(*bh);
1993 230 : *bh = NULL;
1994 230 : return (struct ext4_dir_entry_2 *) bh2;
1995 : }
1996 :
1997 28895 : BUFFER_TRACE(*bh, "get_write_access");
1998 28895 : err = ext4_journal_get_write_access(handle, dir->i_sb, *bh,
1999 : EXT4_JTR_NONE);
2000 28895 : if (err)
2001 0 : goto journal_error;
2002 :
2003 28895 : BUFFER_TRACE(frame->bh, "get_write_access");
2004 28895 : err = ext4_journal_get_write_access(handle, dir->i_sb, frame->bh,
2005 : EXT4_JTR_NONE);
2006 28895 : if (err)
2007 0 : goto journal_error;
2008 :
2009 28895 : data2 = bh2->b_data;
2010 :
2011 : /* create map in the end of data2 block */
2012 28895 : map = (struct dx_map_entry *) (data2 + blocksize);
2013 28895 : count = dx_make_map(dir, *bh, hinfo, map);
2014 28895 : if (count < 0) {
2015 0 : err = count;
2016 0 : goto journal_error;
2017 : }
2018 28895 : map -= count;
2019 28895 : dx_sort_map(map, count);
2020 : /* Ensure that neither split block is over half full */
2021 28895 : size = 0;
2022 28895 : move = 0;
2023 1116267 : for (i = count-1; i >= 0; i--) {
2024 : /* is more than half of this entry in 2nd half of the block? */
2025 1116267 : if (size + map[i].size/2 > blocksize/2)
2026 : break;
2027 1087372 : size += map[i].size;
2028 1087372 : 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 28895 : if (i > 0)
2038 28895 : split = count - move;
2039 : else
2040 0 : split = count/2;
2041 :
2042 28895 : hash2 = map[split].hash;
2043 28895 : 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 28895 : hash2, split, count-split));
2047 :
2048 : /* Fancy dance to stay within two buffers */
2049 28895 : de2 = dx_move_dirents(dir, data1, data2, map + split, count - split,
2050 : blocksize);
2051 28895 : de = dx_pack_dirents(dir, data1, blocksize);
2052 28895 : de->rec_len = ext4_rec_len_to_disk(data1 + (blocksize - csum_size) -
2053 : (char *) de,
2054 : blocksize);
2055 28895 : de2->rec_len = ext4_rec_len_to_disk(data2 + (blocksize - csum_size) -
2056 : (char *) de2,
2057 : blocksize);
2058 28895 : if (csum_size) {
2059 28895 : ext4_initialize_dirent_tail(*bh, blocksize);
2060 28895 : ext4_initialize_dirent_tail(bh2, blocksize);
2061 : }
2062 :
2063 : dxtrace(dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *) data1,
2064 28895 : blocksize, 1));
2065 : dxtrace(dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *) data2,
2066 28895 : blocksize, 1));
2067 :
2068 : /* Which block gets the new entry? */
2069 28895 : if (hinfo->hash >= hash2) {
2070 14857 : swap(*bh, bh2);
2071 14857 : de = de2;
2072 : }
2073 28895 : dx_insert_block(frame, hash2 + continued, newblock);
2074 28895 : err = ext4_handle_dirty_dirblock(handle, dir, bh2);
2075 28895 : if (err)
2076 0 : goto journal_error;
2077 28895 : err = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
2078 28895 : if (err)
2079 0 : goto journal_error;
2080 28895 : 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 2958726 : 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 2958726 : struct ext4_dir_entry_2 *de;
2099 2958726 : unsigned short reclen = ext4_dir_rec_len(fname_len(fname), dir);
2100 2958726 : int nlen, rlen;
2101 2958726 : unsigned int offset = 0;
2102 2958726 : char *top;
2103 :
2104 2958726 : de = buf;
2105 2958726 : top = buf + buf_size - reclen;
2106 270654470 : while ((char *) de <= top) {
2107 270625146 : if (ext4_check_dir_entry(dir, NULL, de, bh,
2108 : buf, buf_size, offset))
2109 : return -EFSCORRUPTED;
2110 270761796 : if (ext4_match(dir, fname, de))
2111 : return -EEXIST;
2112 270628920 : nlen = ext4_dir_rec_len(de->name_len, dir);
2113 270628920 : rlen = ext4_rec_len_from_disk(de->rec_len, buf_size);
2114 270628920 : if ((de->inode ? rlen - nlen : rlen) >= reclen)
2115 : break;
2116 267695744 : de = (struct ext4_dir_entry_2 *)((char *)de + rlen);
2117 267695744 : offset += rlen;
2118 : }
2119 2962500 : if ((char *) de > top)
2120 : return -ENOSPC;
2121 :
2122 2933062 : *dest_de = de;
2123 2933062 : return 0;
2124 : }
2125 :
2126 2962335 : 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 2962335 : int nlen, rlen;
2134 :
2135 2962335 : nlen = ext4_dir_rec_len(de->name_len, dir);
2136 2962335 : rlen = ext4_rec_len_from_disk(de->rec_len, buf_size);
2137 2962335 : if (de->inode) {
2138 2962238 : struct ext4_dir_entry_2 *de1 =
2139 2962238 : (struct ext4_dir_entry_2 *)((char *)de + nlen);
2140 2962238 : de1->rec_len = ext4_rec_len_to_disk(rlen - nlen, buf_size);
2141 2962238 : de->rec_len = ext4_rec_len_to_disk(nlen, buf_size);
2142 2962238 : de = de1;
2143 : }
2144 2962335 : de->file_type = EXT4_FT_UNKNOWN;
2145 2962335 : de->inode = cpu_to_le32(inode->i_ino);
2146 2962335 : ext4_set_de_type(inode->i_sb, de, inode->i_mode);
2147 2962277 : de->name_len = fname_len(fname);
2148 5924554 : memcpy(de->name, fname_name(fname), fname_len(fname));
2149 2962277 : 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 2962277 : }
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 2988105 : 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 2988105 : unsigned int blocksize = dir->i_sb->s_blocksize;
2172 2988105 : int csum_size = 0;
2173 2988105 : int err, err2;
2174 :
2175 2988105 : if (ext4_has_metadata_csum(inode->i_sb))
2176 2987119 : csum_size = sizeof(struct ext4_dir_entry_tail);
2177 :
2178 2986037 : if (!de) {
2179 2959020 : err = ext4_find_dest_de(dir, inode, bh, bh->b_data,
2180 2959020 : blocksize - csum_size, fname, &de);
2181 2962634 : if (err)
2182 : return err;
2183 : }
2184 2960213 : BUFFER_TRACE(bh, "get_write_access");
2185 2960213 : err = ext4_journal_get_write_access(handle, dir->i_sb, bh,
2186 : EXT4_JTR_NONE);
2187 2962485 : 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 2962485 : 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 2961326 : dir->i_mtime = dir->i_ctime = current_time(dir);
2207 2961258 : ext4_update_dx_flag(dir);
2208 2961194 : inode_inc_iversion(dir);
2209 2962177 : err2 = ext4_mark_inode_dirty(handle, dir);
2210 2962491 : BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
2211 2962491 : err = ext4_handle_dirty_dirblock(handle, dir, bh);
2212 2960960 : if (err)
2213 0 : ext4_std_error(dir->i_sb, err);
2214 2960960 : 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 1587 : 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 1587 : struct buffer_head *bh2;
2226 1587 : struct dx_root *root;
2227 1587 : struct dx_frame frames[EXT4_HTREE_LEVEL], *frame;
2228 1587 : struct dx_entry *entries;
2229 1587 : struct ext4_dir_entry_2 *de, *de2;
2230 1587 : char *data2, *top;
2231 1587 : unsigned len;
2232 1587 : int retval;
2233 1587 : unsigned blocksize;
2234 1587 : ext4_lblk_t block;
2235 1587 : struct fake_dirent *fde;
2236 1587 : int csum_size = 0;
2237 :
2238 1587 : if (ext4_has_metadata_csum(inode->i_sb))
2239 1587 : csum_size = sizeof(struct ext4_dir_entry_tail);
2240 :
2241 1587 : blocksize = dir->i_sb->s_blocksize;
2242 1587 : dxtrace(printk(KERN_DEBUG "Creating index: inode %lu\n", dir->i_ino));
2243 1587 : BUFFER_TRACE(bh, "get_write_access");
2244 1587 : retval = ext4_journal_get_write_access(handle, dir->i_sb, bh,
2245 : EXT4_JTR_NONE);
2246 1587 : if (retval) {
2247 0 : ext4_std_error(dir->i_sb, retval);
2248 0 : brelse(bh);
2249 0 : return retval;
2250 : }
2251 1587 : root = (struct dx_root *) bh->b_data;
2252 :
2253 : /* The 0th block becomes the root, move the dirents out */
2254 1587 : fde = &root->dotdot;
2255 1587 : de = (struct ext4_dir_entry_2 *)((char *)fde +
2256 1587 : ext4_rec_len_from_disk(fde->rec_len, blocksize));
2257 1587 : 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 1587 : len = ((char *) root) + (blocksize - csum_size) - (char *) de;
2263 :
2264 : /* Allocate new block for the 0th block's dirents */
2265 1587 : bh2 = ext4_append(handle, dir, &block);
2266 1587 : if (IS_ERR(bh2)) {
2267 308 : brelse(bh);
2268 308 : return PTR_ERR(bh2);
2269 : }
2270 1279 : ext4_set_inode_flag(dir, EXT4_INODE_INDEX);
2271 1279 : data2 = bh2->b_data;
2272 :
2273 2558 : memcpy(data2, de, len);
2274 1279 : memset(de, 0, len); /* wipe old data */
2275 1279 : de = (struct ext4_dir_entry_2 *) data2;
2276 1279 : top = data2 + len;
2277 315112 : while ((char *)(de2 = ext4_next_entry(de, blocksize)) < top) {
2278 313833 : 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 1279 : de->rec_len = ext4_rec_len_to_disk(data2 + (blocksize - csum_size) -
2288 : (char *) de, blocksize);
2289 :
2290 1279 : if (csum_size)
2291 1279 : ext4_initialize_dirent_tail(bh2, blocksize);
2292 :
2293 : /* Initialize the root; the dot dirents already exist */
2294 1279 : de = (struct ext4_dir_entry_2 *) (&root->dotdot);
2295 1279 : de->rec_len = ext4_rec_len_to_disk(
2296 : blocksize - ext4_dir_rec_len(2, NULL), blocksize);
2297 1279 : memset (&root->info, 0, sizeof(root->info));
2298 1279 : root->info.info_length = sizeof(root->info);
2299 1279 : if (ext4_hash_in_dirent(dir))
2300 0 : root->info.hash_version = DX_HASH_SIPHASH;
2301 : else
2302 1279 : root->info.hash_version =
2303 1279 : EXT4_SB(dir->i_sb)->s_def_hash_version;
2304 :
2305 1279 : entries = root->entries;
2306 1279 : dx_set_block(entries, 1);
2307 1279 : dx_set_count(entries, 1);
2308 1279 : dx_set_limit(entries, dx_root_limit(dir, sizeof(root->info)));
2309 :
2310 : /* Initialize as for dx_probe */
2311 1279 : fname->hinfo.hash_version = root->info.hash_version;
2312 1279 : if (fname->hinfo.hash_version <= DX_HASH_TEA)
2313 1279 : fname->hinfo.hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
2314 1279 : fname->hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
2315 :
2316 : /* casefolded encrypted hashes are computed on fname setup */
2317 1279 : if (!ext4_hash_in_dirent(dir)) {
2318 1279 : int err = ext4fs_dirhash(dir, fname_name(fname),
2319 1279 : fname_len(fname), &fname->hinfo);
2320 1279 : if (err < 0) {
2321 0 : brelse(bh2);
2322 0 : brelse(bh);
2323 0 : return err;
2324 : }
2325 : }
2326 1279 : memset(frames, 0, sizeof(frames));
2327 1279 : frame = frames;
2328 1279 : frame->entries = entries;
2329 1279 : frame->at = entries;
2330 1279 : frame->bh = bh;
2331 :
2332 1279 : retval = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
2333 1279 : if (retval)
2334 0 : goto out_frames;
2335 1279 : retval = ext4_handle_dirty_dirblock(handle, dir, bh2);
2336 1279 : if (retval)
2337 0 : goto out_frames;
2338 :
2339 1279 : de = do_split(handle,dir, &bh2, frame, &fname->hinfo);
2340 1279 : if (IS_ERR(de)) {
2341 0 : retval = PTR_ERR(de);
2342 0 : goto out_frames;
2343 : }
2344 :
2345 1279 : retval = add_dirent_to_buf(handle, fname, dir, inode, de, bh2);
2346 1279 : 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 1279 : if (retval)
2353 0 : ext4_mark_inode_dirty(handle, dir);
2354 1279 : dx_release(frames);
2355 1279 : 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 2959316 : static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
2370 : struct inode *inode)
2371 : {
2372 2959316 : struct inode *dir = d_inode(dentry->d_parent);
2373 2959316 : struct buffer_head *bh = NULL;
2374 2959316 : struct ext4_dir_entry_2 *de;
2375 2959316 : struct super_block *sb;
2376 2959316 : struct ext4_filename fname;
2377 2959316 : int retval;
2378 2959316 : int dx_fallback=0;
2379 2959316 : unsigned blocksize;
2380 2959316 : ext4_lblk_t block, blocks;
2381 2959316 : int csum_size = 0;
2382 :
2383 2959316 : if (ext4_has_metadata_csum(inode->i_sb))
2384 2956021 : csum_size = sizeof(struct ext4_dir_entry_tail);
2385 :
2386 2957748 : sb = dir->i_sb;
2387 2957748 : blocksize = sb->s_blocksize;
2388 2957748 : if (!dentry->d_name.len)
2389 : return -EINVAL;
2390 :
2391 2957748 : if (fscrypt_is_nokey_name(dentry))
2392 : return -ENOKEY;
2393 :
2394 : #if IS_ENABLED(CONFIG_UNICODE)
2395 : if (sb_has_strict_encoding(sb) && IS_CASEFOLDED(dir) &&
2396 : sb->s_encoding && utf8_validate(sb->s_encoding, &dentry->d_name))
2397 : return -EINVAL;
2398 : #endif
2399 :
2400 2957748 : retval = ext4_fname_setup_filename(dir, &dentry->d_name, 0, &fname);
2401 2957748 : if (retval)
2402 : return retval;
2403 :
2404 2957748 : 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 2957748 : if (is_dx(dir)) {
2415 1764934 : retval = ext4_dx_add_entry(handle, &fname, dir, inode);
2416 1766796 : if (!retval || (retval != ERR_BAD_DX_DIR))
2417 1766796 : 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 1192814 : blocks = dir->i_size >> sb->s_blocksize_bits;
2432 1192814 : for (block = 0; block < blocks; block++) {
2433 1192814 : bh = ext4_read_dirblock(dir, block, DIRENT);
2434 1193239 : 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 1193239 : if (IS_ERR(bh)) {
2440 0 : retval = PTR_ERR(bh);
2441 0 : bh = NULL;
2442 0 : goto out;
2443 : }
2444 1193239 : retval = add_dirent_to_buf(handle, &fname, dir, inode,
2445 : NULL, bh);
2446 1194739 : if (retval != -ENOSPC)
2447 1193152 : goto out;
2448 :
2449 1587 : if (blocks == 1 && !dx_fallback &&
2450 : ext4_has_feature_dir_index(sb)) {
2451 1587 : retval = make_indexed_dir(handle, &fname, dir,
2452 : inode, bh);
2453 1587 : bh = NULL; /* make_indexed_dir releases bh */
2454 1587 : 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 1193157 : out:
2474 2961540 : ext4_fname_free_filename(&fname);
2475 2961540 : brelse(bh);
2476 2962349 : if (retval == 0)
2477 2961606 : 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 1765300 : static int ext4_dx_add_entry(handle_t *handle, struct ext4_filename *fname,
2485 : struct inode *dir, struct inode *inode)
2486 : {
2487 1765300 : struct dx_frame frames[EXT4_HTREE_LEVEL], *frame;
2488 1765300 : struct dx_entry *entries, *at;
2489 1765300 : struct buffer_head *bh;
2490 1765300 : struct super_block *sb = dir->i_sb;
2491 1765305 : struct ext4_dir_entry_2 *de;
2492 1765305 : int restart;
2493 1765305 : int err;
2494 :
2495 1765305 : again:
2496 1765305 : restart = 0;
2497 1765305 : frame = dx_probe(fname, dir, NULL, frames);
2498 1763537 : if (IS_ERR(frame))
2499 0 : return PTR_ERR(frame);
2500 1763537 : entries = frame->entries;
2501 1763537 : at = frame->at;
2502 1763537 : bh = ext4_read_dirblock(dir, dx_get_block(frame->at), DIRENT_HTREE);
2503 1766900 : if (IS_ERR(bh)) {
2504 0 : err = PTR_ERR(bh);
2505 0 : bh = NULL;
2506 0 : goto cleanup;
2507 : }
2508 :
2509 1766900 : BUFFER_TRACE(bh, "get_write_access");
2510 1766900 : err = ext4_journal_get_write_access(handle, sb, bh, EXT4_JTR_NONE);
2511 1766823 : if (err)
2512 0 : goto journal_error;
2513 :
2514 1766823 : err = add_dirent_to_buf(handle, fname, dir, inode, NULL, bh);
2515 1766709 : if (err != -ENOSPC)
2516 1738858 : goto cleanup;
2517 :
2518 27851 : 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 27851 : dx_get_count(entries), dx_get_limit(entries)));
2522 : /* Need to split index? */
2523 27851 : if (dx_get_count(entries) == dx_get_limit(entries)) {
2524 207 : ext4_lblk_t newblock;
2525 207 : int levels = frame - frames + 1;
2526 207 : unsigned int icount;
2527 207 : int add_level = 1;
2528 207 : struct dx_entry *entries2;
2529 207 : struct dx_node *node2;
2530 207 : struct buffer_head *bh2;
2531 :
2532 209 : while (frame > frames) {
2533 205 : 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 211 : 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 207 : icount = dx_get_count(entries);
2556 207 : bh2 = ext4_append(handle, dir, &newblock);
2557 207 : if (IS_ERR(bh2)) {
2558 0 : err = PTR_ERR(bh2);
2559 0 : goto cleanup;
2560 : }
2561 207 : node2 = (struct dx_node *)(bh2->b_data);
2562 207 : entries2 = node2->entries;
2563 207 : memset(&node2->fake, 0, sizeof(struct fake_dirent));
2564 414 : node2->fake.rec_len = ext4_rec_len_to_disk(sb->s_blocksize,
2565 207 : sb->s_blocksize);
2566 207 : BUFFER_TRACE(frame->bh, "get_write_access");
2567 207 : err = ext4_journal_get_write_access(handle, sb, frame->bh,
2568 : EXT4_JTR_NONE);
2569 207 : if (err)
2570 5 : goto journal_error;
2571 207 : if (!add_level) {
2572 203 : unsigned icount1 = icount/2, icount2 = icount - icount1;
2573 203 : unsigned hash2 = dx_get_hash(entries + icount1);
2574 : dxtrace(printk(KERN_DEBUG "Split index %i/%i\n",
2575 203 : icount1, icount2));
2576 :
2577 203 : BUFFER_TRACE(frame->bh, "get_write_access"); /* index root */
2578 203 : err = ext4_journal_get_write_access(handle, sb,
2579 : (frame - 1)->bh,
2580 : EXT4_JTR_NONE);
2581 203 : if (err)
2582 0 : goto journal_error;
2583 :
2584 406 : memcpy((char *) entries2, (char *) (entries + icount1),
2585 : icount2 * sizeof(struct dx_entry));
2586 203 : dx_set_count(entries, icount1);
2587 203 : dx_set_count(entries2, icount2);
2588 203 : dx_set_limit(entries2, dx_node_limit(dir));
2589 :
2590 : /* Which index block gets the new entry? */
2591 203 : if (at - entries >= icount1) {
2592 106 : frame->at = at - entries - icount1 + entries2;
2593 106 : frame->entries = entries = entries2;
2594 106 : swap(frame->bh, bh2);
2595 : }
2596 203 : dx_insert_block((frame - 1), hash2, newblock);
2597 203 : dxtrace(dx_show_index("node", frame->entries));
2598 : dxtrace(dx_show_index("node",
2599 203 : ((struct dx_node *) bh2->b_data)->entries));
2600 203 : err = ext4_handle_dirty_dx_node(handle, dir, bh2);
2601 203 : if (err)
2602 0 : goto journal_error;
2603 203 : brelse (bh2);
2604 203 : err = ext4_handle_dirty_dx_node(handle, dir,
2605 : (frame - 1)->bh);
2606 203 : if (err)
2607 0 : goto journal_error;
2608 203 : err = ext4_handle_dirty_dx_node(handle, dir,
2609 : frame->bh);
2610 203 : 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 27846 : de = do_split(handle, dir, &bh, frame, &fname->hinfo);
2636 27846 : if (IS_ERR(de)) {
2637 230 : err = PTR_ERR(de);
2638 230 : goto cleanup;
2639 : }
2640 27616 : err = add_dirent_to_buf(handle, fname, dir, inode, de, bh);
2641 27616 : 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 1766709 : brelse(bh);
2647 1767541 : 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 1766854 : 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 2103612 : 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 2103612 : struct ext4_dir_entry_2 *de, *pde;
2668 2103612 : unsigned int blocksize = dir->i_sb->s_blocksize;
2669 2103612 : int i;
2670 :
2671 2103612 : i = 0;
2672 2103612 : pde = NULL;
2673 2103612 : de = entry_buf;
2674 69986862 : while (i < buf_size - csum_size) {
2675 69986862 : if (ext4_check_dir_entry(dir, NULL, de, bh,
2676 : entry_buf, buf_size, i))
2677 : return -EFSCORRUPTED;
2678 69987673 : if (de == de_del) {
2679 2104423 : if (pde) {
2680 4182784 : pde->rec_len = ext4_rec_len_to_disk(
2681 2091392 : ext4_rec_len_from_disk(pde->rec_len,
2682 : blocksize) +
2683 2091392 : ext4_rec_len_from_disk(de->rec_len,
2684 : blocksize),
2685 : blocksize);
2686 :
2687 : /* wipe entire dir_entry */
2688 4182784 : 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 13031 : de->inode = 0;
2693 26062 : 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 2104423 : inode_inc_iversion(dir);
2701 2104423 : return 0;
2702 : }
2703 67883250 : i += ext4_rec_len_from_disk(de->rec_len, blocksize);
2704 67883250 : pde = de;
2705 67883250 : de = ext4_next_entry(de, blocksize);
2706 : }
2707 : return -ENOENT;
2708 : }
2709 :
2710 2103865 : 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 2103865 : int err, csum_size = 0;
2716 :
2717 2103865 : 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 2103865 : if (ext4_has_metadata_csum(dir->i_sb))
2726 2102852 : csum_size = sizeof(struct ext4_dir_entry_tail);
2727 :
2728 2102763 : BUFFER_TRACE(bh, "get_write_access");
2729 2102763 : err = ext4_journal_get_write_access(handle, dir->i_sb, bh,
2730 : EXT4_JTR_NONE);
2731 2103908 : if (unlikely(err))
2732 0 : goto out;
2733 :
2734 2103908 : err = ext4_generic_delete_entry(dir, de_del, bh, bh->b_data,
2735 2103908 : dir->i_sb->s_blocksize, csum_size);
2736 2104601 : if (err)
2737 0 : goto out;
2738 :
2739 2104601 : BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
2740 2104601 : err = ext4_handle_dirty_dirblock(handle, dir, bh);
2741 2103705 : 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 559826 : static void ext4_inc_count(struct inode *inode)
2763 : {
2764 559826 : inc_nlink(inode);
2765 559774 : if (is_dx(inode) &&
2766 245600 : (inode->i_nlink > EXT4_LINK_MAX || inode->i_nlink == 2))
2767 36080 : set_nlink(inode, 1);
2768 559774 : }
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 359710 : static void ext4_dec_count(struct inode *inode)
2775 : {
2776 359710 : if (!S_ISDIR(inode->i_mode) || inode->i_nlink > 2)
2777 228457 : drop_nlink(inode);
2778 359713 : }
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 1948452 : static int ext4_add_nondir(handle_t *handle,
2788 : struct dentry *dentry, struct inode **inodep)
2789 : {
2790 1948452 : struct inode *dir = d_inode(dentry->d_parent);
2791 1948452 : struct inode *inode = *inodep;
2792 1948452 : int err = ext4_add_entry(handle, dentry, inode);
2793 1951396 : if (!err) {
2794 1951091 : err = ext4_mark_inode_dirty(handle, inode);
2795 1951546 : if (IS_DIRSYNC(dir))
2796 0 : ext4_handle_sync(handle);
2797 1951546 : d_instantiate_new(dentry, inode);
2798 1950503 : *inodep = NULL;
2799 1950503 : return err;
2800 : }
2801 305 : drop_nlink(inode);
2802 305 : ext4_orphan_add(handle, inode);
2803 305 : unlock_new_inode(inode);
2804 305 : 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 1709135 : static int ext4_create(struct mnt_idmap *idmap, struct inode *dir,
2816 : struct dentry *dentry, umode_t mode, bool excl)
2817 : {
2818 1709135 : handle_t *handle;
2819 1709135 : struct inode *inode;
2820 1709135 : int err, credits, retries = 0;
2821 :
2822 1709135 : err = dquot_initialize(dir);
2823 1705709 : if (err)
2824 : return err;
2825 :
2826 1705790 : credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2827 1705708 : EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
2828 1820758 : retry:
2829 1820758 : inode = ext4_new_inode_start_handle(idmap, dir, mode, &dentry->d_name,
2830 : 0, NULL, EXT4_HT_DIR, credits);
2831 1831380 : handle = ext4_journal_current_handle();
2832 1831380 : err = PTR_ERR(inode);
2833 1831380 : if (!IS_ERR(inode)) {
2834 1677324 : inode->i_op = &ext4_file_inode_operations;
2835 1677324 : inode->i_fop = &ext4_file_operations;
2836 1677324 : ext4_set_aops(inode);
2837 1675856 : err = ext4_add_nondir(handle, dentry, &inode);
2838 1676721 : if (!err)
2839 1676387 : ext4_fc_track_create(handle, dentry);
2840 : }
2841 1829637 : if (handle)
2842 1676009 : ext4_journal_stop(handle);
2843 1983752 : if (!IS_ERR_OR_NULL(inode))
2844 251 : iput(inode);
2845 1829445 : if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2846 115050 : goto retry;
2847 : return err;
2848 : }
2849 :
2850 142692 : static int ext4_mknod(struct mnt_idmap *idmap, struct inode *dir,
2851 : struct dentry *dentry, umode_t mode, dev_t rdev)
2852 : {
2853 142692 : handle_t *handle;
2854 142692 : struct inode *inode;
2855 142692 : int err, credits, retries = 0;
2856 :
2857 142692 : err = dquot_initialize(dir);
2858 142676 : if (err)
2859 : return err;
2860 :
2861 142723 : credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2862 142676 : EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
2863 142676 : retry:
2864 142676 : inode = ext4_new_inode_start_handle(idmap, dir, mode, &dentry->d_name,
2865 : 0, NULL, EXT4_HT_DIR, credits);
2866 142725 : handle = ext4_journal_current_handle();
2867 142725 : err = PTR_ERR(inode);
2868 142725 : if (!IS_ERR(inode)) {
2869 142685 : init_special_inode(inode, inode->i_mode, rdev);
2870 142682 : inode->i_op = &ext4_special_inode_operations;
2871 142682 : err = ext4_add_nondir(handle, dentry, &inode);
2872 142679 : if (!err)
2873 142678 : ext4_fc_track_create(handle, dentry);
2874 : }
2875 142694 : if (handle)
2876 142653 : ext4_journal_stop(handle);
2877 142722 : if (!IS_ERR_OR_NULL(inode))
2878 0 : iput(inode);
2879 142682 : if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2880 0 : goto retry;
2881 : return err;
2882 : }
2883 :
2884 429114 : static int ext4_tmpfile(struct mnt_idmap *idmap, struct inode *dir,
2885 : struct file *file, umode_t mode)
2886 : {
2887 429114 : handle_t *handle;
2888 429114 : struct inode *inode;
2889 429114 : int err, retries = 0;
2890 :
2891 429114 : err = dquot_initialize(dir);
2892 426512 : if (err)
2893 : return err;
2894 :
2895 426512 : retry:
2896 426512 : 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 447351 : handle = ext4_journal_current_handle();
2902 447351 : err = PTR_ERR(inode);
2903 447351 : if (!IS_ERR(inode)) {
2904 447351 : inode->i_op = &ext4_file_inode_operations;
2905 447351 : inode->i_fop = &ext4_file_operations;
2906 447351 : ext4_set_aops(inode);
2907 446592 : d_tmpfile(file, inode);
2908 435178 : err = ext4_orphan_add(handle, inode);
2909 453750 : if (err)
2910 0 : goto err_unlock_inode;
2911 453750 : mark_inode_dirty(inode);
2912 452140 : unlock_new_inode(inode);
2913 : }
2914 452148 : if (handle)
2915 452148 : ext4_journal_stop(handle);
2916 449506 : if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2917 0 : goto retry;
2918 449506 : 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 350557 : 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 350557 : de->inode = cpu_to_le32(inode->i_ino);
2931 350557 : de->name_len = 1;
2932 350557 : de->rec_len = ext4_rec_len_to_disk(ext4_dir_rec_len(de->name_len, NULL),
2933 : blocksize);
2934 350557 : strcpy(de->name, ".");
2935 350557 : ext4_set_de_type(inode->i_sb, de, S_IFDIR);
2936 :
2937 350557 : de = ext4_next_entry(de, blocksize);
2938 350557 : de->inode = cpu_to_le32(parent_ino);
2939 350557 : de->name_len = 2;
2940 350557 : if (!dotdot_real_len)
2941 350557 : de->rec_len = ext4_rec_len_to_disk(blocksize -
2942 350557 : (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 350557 : strcpy(de->name, "..");
2949 350557 : ext4_set_de_type(inode->i_sb, de, S_IFDIR);
2950 :
2951 350557 : return ext4_next_entry(de, blocksize);
2952 : }
2953 :
2954 373152 : int ext4_init_new_dir(handle_t *handle, struct inode *dir,
2955 : struct inode *inode)
2956 : {
2957 373152 : struct buffer_head *dir_block = NULL;
2958 373152 : struct ext4_dir_entry_2 *de;
2959 373152 : ext4_lblk_t block = 0;
2960 373152 : unsigned int blocksize = dir->i_sb->s_blocksize;
2961 373152 : int csum_size = 0;
2962 373152 : int err;
2963 :
2964 373152 : if (ext4_has_metadata_csum(dir->i_sb))
2965 372976 : csum_size = sizeof(struct ext4_dir_entry_tail);
2966 :
2967 373091 : 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 373091 : inode->i_size = 0;
2976 373091 : dir_block = ext4_append(handle, inode, &block);
2977 373079 : if (IS_ERR(dir_block))
2978 22332 : return PTR_ERR(dir_block);
2979 350747 : de = (struct ext4_dir_entry_2 *)dir_block->b_data;
2980 350747 : ext4_init_dot_dotdot(inode, de, blocksize, csum_size, dir->i_ino, 0);
2981 350549 : set_nlink(inode, 2);
2982 350457 : if (csum_size)
2983 350345 : ext4_initialize_dirent_tail(dir_block, blocksize);
2984 :
2985 350196 : BUFFER_TRACE(dir_block, "call ext4_handle_dirty_metadata");
2986 350196 : err = ext4_handle_dirty_dirblock(handle, inode, dir_block);
2987 350496 : if (err)
2988 0 : goto out;
2989 350496 : set_buffer_verified(dir_block);
2990 350748 : out:
2991 350748 : brelse(dir_block);
2992 : return err;
2993 : }
2994 :
2995 360856 : static int ext4_mkdir(struct mnt_idmap *idmap, struct inode *dir,
2996 : struct dentry *dentry, umode_t mode)
2997 : {
2998 360856 : handle_t *handle;
2999 360856 : struct inode *inode;
3000 360856 : int err, err2 = 0, credits, retries = 0;
3001 :
3002 360856 : if (EXT4_DIR_LINK_MAX(dir))
3003 : return -EMLINK;
3004 :
3005 360856 : err = dquot_initialize(dir);
3006 360838 : if (err)
3007 : return err;
3008 :
3009 360897 : credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
3010 360838 : EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
3011 373786 : retry:
3012 373786 : inode = ext4_new_inode_start_handle(idmap, dir, S_IFDIR | mode,
3013 : &dentry->d_name,
3014 : 0, NULL, EXT4_HT_DIR, credits);
3015 373840 : handle = ext4_journal_current_handle();
3016 373840 : err = PTR_ERR(inode);
3017 373840 : if (IS_ERR(inode))
3018 687 : goto out_stop;
3019 :
3020 373153 : inode->i_op = &ext4_dir_inode_operations;
3021 373153 : inode->i_fop = &ext4_dir_operations;
3022 373153 : err = ext4_init_new_dir(handle, dir, inode);
3023 373036 : if (err)
3024 22315 : goto out_clear_inode;
3025 350721 : err = ext4_mark_inode_dirty(handle, inode);
3026 350813 : if (!err)
3027 350812 : err = ext4_add_entry(handle, dentry, inode);
3028 350824 : if (err) {
3029 4 : out_clear_inode:
3030 22319 : clear_nlink(inode);
3031 22331 : ext4_orphan_add(handle, inode);
3032 22341 : unlock_new_inode(inode);
3033 22341 : err2 = ext4_mark_inode_dirty(handle, inode);
3034 22341 : if (unlikely(err2))
3035 0 : err = err2;
3036 22341 : ext4_journal_stop(handle);
3037 22334 : iput(inode);
3038 22299 : goto out_retry;
3039 : }
3040 350820 : ext4_inc_count(dir);
3041 :
3042 350731 : ext4_update_dx_flag(dir);
3043 350723 : err = ext4_mark_inode_dirty(handle, dir);
3044 350835 : if (err)
3045 0 : goto out_clear_inode;
3046 350835 : d_instantiate_new(dentry, inode);
3047 350750 : ext4_fc_track_create(handle, dentry);
3048 350601 : if (IS_DIRSYNC(dir))
3049 0 : ext4_handle_sync(handle);
3050 :
3051 350601 : out_stop:
3052 351288 : if (handle)
3053 351172 : ext4_journal_stop(handle);
3054 116 : out_retry:
3055 373697 : if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
3056 12948 : goto retry;
3057 : return err;
3058 : }
3059 :
3060 : /*
3061 : * routine to check that the specified directory is empty (for rmdir)
3062 : */
3063 233780 : bool ext4_empty_dir(struct inode *inode)
3064 : {
3065 233780 : unsigned int offset;
3066 233780 : struct buffer_head *bh;
3067 233780 : struct ext4_dir_entry_2 *de;
3068 233780 : struct super_block *sb;
3069 :
3070 233780 : 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 233780 : sb = inode->i_sb;
3080 233780 : 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 233780 : bh = ext4_read_dirblock(inode, 0, DIRENT_HTREE);
3089 233809 : if (IS_ERR(bh))
3090 : return false;
3091 :
3092 233809 : de = (struct ext4_dir_entry_2 *) bh->b_data;
3093 233809 : if (ext4_check_dir_entry(inode, NULL, de, bh, bh->b_data, bh->b_size,
3094 233809 : 0) ||
3095 233809 : 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 233809 : offset = ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize);
3101 233809 : de = ext4_next_entry(de, sb->s_blocksize);
3102 233809 : if (ext4_check_dir_entry(inode, NULL, de, bh, bh->b_data, bh->b_size,
3103 233800 : offset) ||
3104 233800 : 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 233800 : offset += ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize);
3110 434195 : while (offset < inode->i_size) {
3111 245550 : if (!(offset & (sb->s_blocksize - 1))) {
3112 6341 : unsigned int lblock;
3113 6341 : brelse(bh);
3114 6341 : lblock = offset >> EXT4_BLOCK_SIZE_BITS(sb);
3115 6341 : bh = ext4_read_dirblock(inode, lblock, EITHER);
3116 6341 : if (bh == NULL) {
3117 0 : offset += sb->s_blocksize;
3118 0 : continue;
3119 : }
3120 6341 : if (IS_ERR(bh))
3121 : return false;
3122 : }
3123 245550 : de = (struct ext4_dir_entry_2 *) (bh->b_data +
3124 245550 : (offset & (sb->s_blocksize - 1)));
3125 245550 : if (ext4_check_dir_entry(inode, NULL, de, bh,
3126 245553 : bh->b_data, bh->b_size, offset) ||
3127 245553 : le32_to_cpu(de->inode)) {
3128 45158 : brelse(bh);
3129 45162 : return false;
3130 : }
3131 200395 : offset += ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize);
3132 : }
3133 188645 : brelse(bh);
3134 : return true;
3135 : }
3136 :
3137 233636 : static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
3138 : {
3139 233636 : int retval;
3140 233636 : struct inode *inode;
3141 233636 : struct buffer_head *bh;
3142 233636 : struct ext4_dir_entry_2 *de;
3143 233636 : handle_t *handle = NULL;
3144 :
3145 467272 : 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 233606 : retval = dquot_initialize(dir);
3151 233597 : if (retval)
3152 : return retval;
3153 233592 : retval = dquot_initialize(d_inode(dentry));
3154 233597 : if (retval)
3155 : return retval;
3156 :
3157 233597 : retval = -ENOENT;
3158 233597 : bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
3159 233614 : if (IS_ERR(bh))
3160 0 : return PTR_ERR(bh);
3161 233614 : if (!bh)
3162 0 : goto end_rmdir;
3163 :
3164 233614 : inode = d_inode(dentry);
3165 :
3166 233614 : retval = -EFSCORRUPTED;
3167 233614 : if (le32_to_cpu(de->inode) != inode->i_ino)
3168 0 : goto end_rmdir;
3169 :
3170 233614 : retval = -ENOTEMPTY;
3171 233614 : if (!ext4_empty_dir(inode))
3172 45148 : goto end_rmdir;
3173 :
3174 376104 : handle = ext4_journal_start(dir, EXT4_HT_DIR,
3175 : EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
3176 188469 : if (IS_ERR(handle)) {
3177 0 : retval = PTR_ERR(handle);
3178 0 : handle = NULL;
3179 0 : goto end_rmdir;
3180 : }
3181 :
3182 188469 : if (IS_DIRSYNC(dir))
3183 0 : ext4_handle_sync(handle);
3184 :
3185 188469 : retval = ext4_delete_entry(handle, dir, de, bh);
3186 188475 : if (retval)
3187 0 : goto end_rmdir;
3188 188475 : 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 188475 : inode_inc_iversion(inode);
3194 188476 : 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 188477 : inode->i_size = 0;
3199 188477 : ext4_orphan_add(handle, inode);
3200 188477 : inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode);
3201 188478 : retval = ext4_mark_inode_dirty(handle, inode);
3202 188479 : if (retval)
3203 0 : goto end_rmdir;
3204 188479 : ext4_dec_count(dir);
3205 188476 : ext4_update_dx_flag(dir);
3206 188478 : ext4_fc_track_unlink(handle, dentry);
3207 188476 : 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 : if (IS_CASEFOLDED(dir))
3217 : d_invalidate(dentry);
3218 : #endif
3219 :
3220 233624 : end_rmdir:
3221 233624 : brelse(bh);
3222 233628 : if (handle)
3223 188477 : ext4_journal_stop(handle);
3224 : return retval;
3225 : }
3226 :
3227 1340505 : 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 1340505 : int retval = -ENOENT;
3232 1340505 : struct buffer_head *bh;
3233 1340505 : struct ext4_dir_entry_2 *de;
3234 1340505 : handle_t *handle;
3235 1340505 : 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 1340505 : bh = ext4_find_entry(dir, d_name, &de, NULL);
3242 1341508 : if (IS_ERR(bh))
3243 0 : return PTR_ERR(bh);
3244 :
3245 1341508 : if (!bh)
3246 : return -ENOENT;
3247 :
3248 1341508 : 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 2673702 : handle = ext4_journal_start(dir, EXT4_HT_DIR,
3261 : EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
3262 1340584 : if (IS_ERR(handle)) {
3263 0 : retval = PTR_ERR(handle);
3264 0 : goto out_bh;
3265 : }
3266 :
3267 1340584 : if (IS_DIRSYNC(dir))
3268 0 : ext4_handle_sync(handle);
3269 :
3270 1340584 : if (!skip_remove_dentry) {
3271 1340725 : retval = ext4_delete_entry(handle, dir, de, bh);
3272 1340718 : if (retval)
3273 0 : goto out_handle;
3274 1340718 : dir->i_ctime = dir->i_mtime = current_time(dir);
3275 1340589 : ext4_update_dx_flag(dir);
3276 1340917 : retval = ext4_mark_inode_dirty(handle, dir);
3277 1341682 : if (retval)
3278 0 : goto out_handle;
3279 : } else {
3280 : retval = 0;
3281 : }
3282 1341541 : 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 1341541 : drop_nlink(inode);
3287 1341618 : if (!inode->i_nlink)
3288 1278881 : ext4_orphan_add(handle, inode);
3289 1341853 : inode->i_ctime = current_time(inode);
3290 1341862 : retval = ext4_mark_inode_dirty(handle, inode);
3291 1341837 : if (dentry && !retval)
3292 1341837 : ext4_fc_track_unlink(handle, dentry);
3293 0 : out_handle:
3294 1341795 : ext4_journal_stop(handle);
3295 1341496 : out_bh:
3296 1341496 : brelse(bh);
3297 1341496 : return retval;
3298 : }
3299 :
3300 1341130 : static int ext4_unlink(struct inode *dir, struct dentry *dentry)
3301 : {
3302 1341130 : int retval;
3303 :
3304 2682260 : if (unlikely(ext4_forced_shutdown(EXT4_SB(dir->i_sb))))
3305 : return -EIO;
3306 :
3307 1341105 : trace_ext4_unlink_enter(dir, dentry);
3308 : /*
3309 : * Initialize quotas before so that eventual writes go
3310 : * in separate transaction
3311 : */
3312 1341109 : retval = dquot_initialize(dir);
3313 1341130 : if (retval)
3314 0 : goto out_trace;
3315 1341130 : retval = dquot_initialize(d_inode(dentry));
3316 1341052 : if (retval)
3317 0 : goto out_trace;
3318 :
3319 1341052 : 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 : if (IS_CASEFOLDED(dir))
3328 : d_invalidate(dentry);
3329 : #endif
3330 :
3331 1341776 : out_trace:
3332 1341776 : trace_ext4_unlink_exit(dentry, retval);
3333 1341776 : return retval;
3334 : }
3335 :
3336 48677 : static int ext4_init_symlink_block(handle_t *handle, struct inode *inode,
3337 : struct fscrypt_str *disk_link)
3338 : {
3339 48677 : struct buffer_head *bh;
3340 48677 : char *kaddr;
3341 48677 : int err = 0;
3342 :
3343 48677 : bh = ext4_bread(handle, inode, 0, EXT4_GET_BLOCKS_CREATE);
3344 48682 : if (IS_ERR(bh))
3345 21633 : return PTR_ERR(bh);
3346 :
3347 27049 : BUFFER_TRACE(bh, "get_write_access");
3348 27049 : err = ext4_journal_get_write_access(handle, inode->i_sb, bh, EXT4_JTR_NONE);
3349 27044 : if (err)
3350 0 : goto out;
3351 :
3352 27044 : kaddr = (char *)bh->b_data;
3353 54088 : memcpy(kaddr, disk_link->name, disk_link->len);
3354 27044 : inode->i_size = disk_link->len - 1;
3355 27044 : EXT4_I(inode)->i_disksize = inode->i_size;
3356 27044 : err = ext4_handle_dirty_metadata(handle, inode, bh);
3357 27047 : out:
3358 27047 : brelse(bh);
3359 : return err;
3360 : }
3361 :
3362 140665 : static int ext4_symlink(struct mnt_idmap *idmap, struct inode *dir,
3363 : struct dentry *dentry, const char *symname)
3364 : {
3365 140665 : handle_t *handle;
3366 140665 : struct inode *inode;
3367 140665 : int err, len = strlen(symname);
3368 140665 : int credits;
3369 140665 : struct fscrypt_str disk_link;
3370 140665 : int retries = 0;
3371 :
3372 281330 : if (unlikely(ext4_forced_shutdown(EXT4_SB(dir->i_sb))))
3373 : return -EIO;
3374 :
3375 140629 : err = fscrypt_prepare_symlink(dir, symname, len, dir->i_sb->s_blocksize,
3376 : &disk_link);
3377 140629 : if (err)
3378 0 : return err;
3379 :
3380 140629 : err = dquot_initialize(dir);
3381 140616 : 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 140659 : credits = EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
3391 140616 : EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3;
3392 153208 : retry:
3393 153208 : inode = ext4_new_inode_start_handle(idmap, dir, S_IFLNK|S_IRWXUGO,
3394 : &dentry->d_name, 0, NULL,
3395 : EXT4_HT_DIR, credits);
3396 153230 : handle = ext4_journal_current_handle();
3397 153230 : if (IS_ERR(inode)) {
3398 597 : if (handle)
3399 597 : ext4_journal_stop(handle);
3400 596 : err = PTR_ERR(inode);
3401 596 : goto out_retry;
3402 : }
3403 :
3404 152633 : 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 152633 : if ((disk_link.len > EXT4_N_BLOCKS * 4)) {
3411 48678 : inode->i_op = &ext4_symlink_inode_operations;
3412 : } else {
3413 103955 : inode->i_op = &ext4_fast_symlink_inode_operations;
3414 103955 : inode->i_link = (char *)&EXT4_I(inode)->i_data;
3415 : }
3416 : }
3417 :
3418 152633 : if ((disk_link.len > EXT4_N_BLOCKS * 4)) {
3419 : /* alloc symlink block and fill it */
3420 48677 : err = ext4_init_symlink_block(handle, inode, &disk_link);
3421 48682 : if (err)
3422 21632 : goto err_drop_inode;
3423 : } else {
3424 : /* clear the extent format for fast symlink */
3425 103956 : ext4_clear_inode_flag(inode, EXT4_INODE_EXTENTS);
3426 103957 : memcpy((char *)&EXT4_I(inode)->i_data, disk_link.name,
3427 : disk_link.len);
3428 103957 : inode->i_size = disk_link.len - 1;
3429 103957 : EXT4_I(inode)->i_disksize = inode->i_size;
3430 : }
3431 131007 : err = ext4_add_nondir(handle, dentry, &inode);
3432 131005 : if (handle)
3433 131005 : ext4_journal_stop(handle);
3434 130999 : iput(inode);
3435 130990 : goto out_retry;
3436 :
3437 21632 : err_drop_inode:
3438 21632 : clear_nlink(inode);
3439 21631 : ext4_orphan_add(handle, inode);
3440 21636 : unlock_new_inode(inode);
3441 21636 : if (handle)
3442 21636 : ext4_journal_stop(handle);
3443 21631 : iput(inode);
3444 153197 : out_retry:
3445 153197 : if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
3446 12592 : goto retry;
3447 140624 : if (disk_link.name != (unsigned char *)symname)
3448 0 : kfree(disk_link.name);
3449 : return err;
3450 : }
3451 :
3452 76634 : int __ext4_link(struct inode *dir, struct inode *inode, struct dentry *dentry)
3453 : {
3454 76634 : handle_t *handle;
3455 76634 : int err, retries = 0;
3456 76634 : retry:
3457 147438 : handle = ext4_journal_start(dir, EXT4_HT_DIR,
3458 : (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
3459 : EXT4_INDEX_EXTRA_TRANS_BLOCKS) + 1);
3460 76634 : if (IS_ERR(handle))
3461 20 : return PTR_ERR(handle);
3462 :
3463 76614 : if (IS_DIRSYNC(dir))
3464 0 : ext4_handle_sync(handle);
3465 :
3466 76614 : inode->i_ctime = current_time(inode);
3467 76605 : ext4_inc_count(inode);
3468 76611 : ihold(inode);
3469 :
3470 76618 : err = ext4_add_entry(handle, dentry, inode);
3471 76622 : if (!err) {
3472 76621 : err = ext4_mark_inode_dirty(handle, inode);
3473 : /* this can happen only for tmpfile being
3474 : * linked the first time
3475 : */
3476 76623 : if (inode->i_nlink == 1)
3477 2189 : ext4_orphan_del(handle, inode);
3478 76623 : d_instantiate(dentry, inode);
3479 76622 : ext4_fc_track_link(handle, dentry);
3480 : } else {
3481 1 : drop_nlink(inode);
3482 1 : iput(inode);
3483 : }
3484 76611 : ext4_journal_stop(handle);
3485 76615 : if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
3486 0 : goto retry;
3487 : return err;
3488 : }
3489 :
3490 76638 : static int ext4_link(struct dentry *old_dentry,
3491 : struct inode *dir, struct dentry *dentry)
3492 : {
3493 76638 : struct inode *inode = d_inode(old_dentry);
3494 76638 : int err;
3495 :
3496 76638 : if (inode->i_nlink >= EXT4_LINK_MAX)
3497 : return -EMLINK;
3498 :
3499 76638 : err = fscrypt_prepare_link(old_dentry, dir, dentry);
3500 76638 : if (err)
3501 : return err;
3502 :
3503 76638 : 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 76638 : err = dquot_initialize(dir);
3509 76635 : if (err)
3510 : return err;
3511 76633 : 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 140027 : 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 140027 : struct buffer_head *bh;
3526 :
3527 140027 : if (!ext4_has_inline_data(inode)) {
3528 140027 : struct ext4_dir_entry_2 *de;
3529 140027 : unsigned int offset;
3530 :
3531 : /* The first directory block must not be a hole, so
3532 : * treat it as DIRENT_HTREE
3533 : */
3534 140027 : bh = ext4_read_dirblock(inode, 0, DIRENT_HTREE);
3535 140031 : if (IS_ERR(bh)) {
3536 0 : *retval = PTR_ERR(bh);
3537 0 : return NULL;
3538 : }
3539 :
3540 140031 : de = (struct ext4_dir_entry_2 *) bh->b_data;
3541 140031 : if (ext4_check_dir_entry(inode, NULL, de, bh, bh->b_data,
3542 140032 : bh->b_size, 0) ||
3543 140032 : le32_to_cpu(de->inode) != inode->i_ino ||
3544 140032 : 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 140032 : offset = ext4_rec_len_from_disk(de->rec_len,
3551 : inode->i_sb->s_blocksize);
3552 140032 : de = ext4_next_entry(de, inode->i_sb->s_blocksize);
3553 140032 : if (ext4_check_dir_entry(inode, NULL, de, bh, bh->b_data,
3554 140032 : bh->b_size, offset) ||
3555 140032 : 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 140032 : *parent_de = de;
3562 :
3563 140032 : 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 140029 : static int ext4_rename_dir_prepare(handle_t *handle, struct ext4_renament *ent)
3589 : {
3590 140029 : int retval;
3591 :
3592 140029 : ent->dir_bh = ext4_get_first_dir_block(handle, ent->inode,
3593 : &retval, &ent->parent_de,
3594 : &ent->dir_inlined);
3595 140032 : if (!ent->dir_bh)
3596 0 : return retval;
3597 140032 : if (le32_to_cpu(ent->parent_de->inode) != ent->dir->i_ino)
3598 : return -EFSCORRUPTED;
3599 140032 : BUFFER_TRACE(ent->dir_bh, "get_write_access");
3600 140032 : return ext4_journal_get_write_access(handle, ent->dir->i_sb,
3601 : ent->dir_bh, EXT4_JTR_NONE);
3602 : }
3603 :
3604 140031 : static int ext4_rename_dir_finish(handle_t *handle, struct ext4_renament *ent,
3605 : unsigned dir_ino)
3606 : {
3607 140031 : int retval;
3608 :
3609 140031 : ent->parent_de->inode = cpu_to_le32(dir_ino);
3610 140031 : BUFFER_TRACE(ent->dir_bh, "call ext4_handle_dirty_metadata");
3611 140031 : if (!ent->dir_inlined) {
3612 140031 : if (is_dx(ent->inode)) {
3613 41564 : retval = ext4_handle_dirty_dx_node(handle,
3614 : ent->inode,
3615 : ent->dir_bh);
3616 : } else {
3617 98467 : 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 140031 : if (retval) {
3624 0 : ext4_std_error(ent->dir->i_sb, retval);
3625 0 : return retval;
3626 : }
3627 : return 0;
3628 : }
3629 :
3630 149607 : static int ext4_setent(handle_t *handle, struct ext4_renament *ent,
3631 : unsigned ino, unsigned file_type)
3632 : {
3633 149607 : int retval, retval2;
3634 :
3635 149607 : BUFFER_TRACE(ent->bh, "get write access");
3636 149607 : retval = ext4_journal_get_write_access(handle, ent->dir->i_sb, ent->bh,
3637 : EXT4_JTR_NONE);
3638 149615 : if (retval)
3639 : return retval;
3640 149615 : ent->de->inode = cpu_to_le32(ino);
3641 149615 : if (ext4_has_feature_filetype(ent->dir->i_sb))
3642 149618 : ent->de->file_type = file_type;
3643 149615 : inode_inc_iversion(ent->dir);
3644 299226 : ent->dir->i_ctime = ent->dir->i_mtime =
3645 149614 : current_time(ent->dir);
3646 149612 : retval = ext4_mark_inode_dirty(handle, ent->dir);
3647 149622 : BUFFER_TRACE(ent->bh, "call ext4_handle_dirty_metadata");
3648 149622 : if (!ent->inlined) {
3649 149622 : retval2 = ext4_handle_dirty_dirblock(handle, ent->dir, ent->bh);
3650 149585 : 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 231 : static void ext4_resetent(handle_t *handle, struct ext4_renament *ent,
3659 : unsigned ino, unsigned file_type)
3660 : {
3661 231 : struct ext4_renament old = *ent;
3662 231 : 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 231 : old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de,
3670 : &old.inlined);
3671 231 : if (IS_ERR(old.bh))
3672 0 : retval = PTR_ERR(old.bh);
3673 231 : if (!old.bh)
3674 : retval = -ENOENT;
3675 231 : if (retval) {
3676 0 : ext4_std_error(old.dir->i_sb, retval);
3677 0 : return;
3678 : }
3679 :
3680 231 : ext4_setent(handle, &old, ino, file_type);
3681 231 : 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 574571 : static void ext4_rename_delete(handle_t *handle, struct ext4_renament *ent,
3702 : int force_reread)
3703 : {
3704 574571 : 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 574571 : if (le32_to_cpu(ent->de->inode) != ent->inode->i_ino ||
3712 574571 : ent->de->name_len != ent->dentry->d_name.len ||
3713 574571 : strncmp(ent->de->name, ent->dentry->d_name.name,
3714 574571 : 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 574568 : retval = ext4_delete_entry(handle, ent->dir, ent->de, ent->bh);
3720 574569 : if (retval == -ENOENT) {
3721 0 : retval = ext4_find_delete_entry(handle, ent->dir,
3722 0 : &ent->dentry->d_name);
3723 : }
3724 : }
3725 :
3726 574570 : 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 574570 : }
3732 :
3733 62984 : static void ext4_update_dir_count(handle_t *handle, struct ext4_renament *ent)
3734 : {
3735 62984 : 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 62984 : }
3743 :
3744 47815 : static struct inode *ext4_whiteout_for_rename(struct mnt_idmap *idmap,
3745 : struct ext4_renament *ent,
3746 : int credits, handle_t **h)
3747 : {
3748 47815 : struct inode *wh;
3749 47815 : handle_t *handle;
3750 47815 : int retries = 0;
3751 :
3752 : /*
3753 : * for inode block, sb block, group summaries,
3754 : * and inode bitmap
3755 : */
3756 47815 : credits += (EXT4_MAXQUOTAS_TRANS_BLOCKS(ent->dir->i_sb) +
3757 47815 : EXT4_XATTR_TRANS_BLOCKS + 4);
3758 47815 : retry:
3759 47815 : 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 47822 : handle = ext4_journal_current_handle();
3765 47822 : 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 47822 : *h = handle;
3773 47822 : init_special_inode(wh, wh->i_mode, WHITEOUT_DEV);
3774 47816 : wh->i_op = &ext4_special_inode_operations;
3775 : }
3776 47816 : 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 622364 : 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 622364 : handle_t *handle = NULL;
3792 622364 : struct ext4_renament old = {
3793 : .dir = old_dir,
3794 : .dentry = old_dentry,
3795 : .inode = d_inode(old_dentry),
3796 : };
3797 622364 : struct ext4_renament new = {
3798 : .dir = new_dir,
3799 : .dentry = new_dentry,
3800 : .inode = d_inode(new_dentry),
3801 : };
3802 622364 : int force_reread;
3803 622364 : int retval;
3804 622364 : struct inode *whiteout = NULL;
3805 622364 : int credits;
3806 622364 : u8 old_file_type;
3807 :
3808 622364 : 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 622364 : 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 622364 : retval = dquot_initialize(old.dir);
3820 622351 : if (retval)
3821 : return retval;
3822 622352 : retval = dquot_initialize(old.inode);
3823 622355 : if (retval)
3824 : return retval;
3825 622357 : retval = dquot_initialize(new.dir);
3826 622372 : if (retval)
3827 : return retval;
3828 :
3829 : /* Initialize quotas before so that eventual writes go
3830 : * in separate transaction */
3831 622372 : if (new.inode) {
3832 38588 : retval = dquot_initialize(new.inode);
3833 38591 : if (retval)
3834 : return retval;
3835 : }
3836 :
3837 622375 : old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de,
3838 : &old.inlined);
3839 622392 : 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 622392 : retval = -ENOENT;
3849 622392 : if (!old.bh || le32_to_cpu(old.de->inode) != old.inode->i_ino)
3850 0 : goto release_bh;
3851 :
3852 622392 : new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
3853 : &new.de, &new.inlined);
3854 622391 : if (IS_ERR(new.bh)) {
3855 0 : retval = PTR_ERR(new.bh);
3856 0 : new.bh = NULL;
3857 0 : goto release_bh;
3858 : }
3859 622391 : if (new.bh) {
3860 38584 : if (!new.inode) {
3861 0 : brelse(new.bh);
3862 0 : new.bh = NULL;
3863 : }
3864 : }
3865 622391 : if (new.inode && !test_opt(new.dir->i_sb, NO_AUTO_DA_ALLOC))
3866 38591 : ext4_alloc_da_blocks(old.inode);
3867 :
3868 622496 : credits = (2 * EXT4_DATA_TRANS_BLOCKS(old.dir->i_sb) +
3869 622388 : EXT4_INDEX_EXTRA_TRANS_BLOCKS + 2);
3870 622388 : if (!(flags & RENAME_WHITEOUT)) {
3871 574578 : handle = ext4_journal_start(old.dir, EXT4_HT_DIR, credits);
3872 574574 : if (IS_ERR(handle)) {
3873 0 : retval = PTR_ERR(handle);
3874 0 : goto release_bh;
3875 : }
3876 : } else {
3877 47810 : whiteout = ext4_whiteout_for_rename(idmap, &old, credits, &handle);
3878 47814 : if (IS_ERR(whiteout)) {
3879 0 : retval = PTR_ERR(whiteout);
3880 0 : goto release_bh;
3881 : }
3882 : }
3883 :
3884 622388 : old_file_type = old.de->file_type;
3885 622388 : if (IS_DIRSYNC(old.dir) || IS_DIRSYNC(new.dir))
3886 0 : ext4_handle_sync(handle);
3887 :
3888 622388 : if (S_ISDIR(old.inode->i_mode)) {
3889 132667 : if (new.inode) {
3890 188 : retval = -ENOTEMPTY;
3891 188 : if (!ext4_empty_dir(new.inode))
3892 9 : goto end_rename;
3893 : } else {
3894 132479 : retval = -EMLINK;
3895 132479 : if (new.dir != old.dir && EXT4_DIR_LINK_MAX(new.dir))
3896 0 : goto end_rename;
3897 : }
3898 132658 : retval = ext4_rename_dir_prepare(handle, &old);
3899 132658 : 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 622379 : force_reread = (new.dir->i_ino == old.dir->i_ino &&
3910 : ext4_test_inode_flag(new.dir, EXT4_INODE_INLINE_DATA));
3911 :
3912 622379 : 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 47808 : retval = ext4_setent(handle, &old, whiteout->i_ino,
3918 : EXT4_FT_CHRDEV);
3919 47773 : if (retval)
3920 0 : goto end_rename;
3921 47773 : retval = ext4_mark_inode_dirty(handle, whiteout);
3922 47820 : if (unlikely(retval))
3923 0 : goto end_rename;
3924 :
3925 : }
3926 622391 : if (!new.bh) {
3927 583807 : retval = ext4_add_entry(handle, new.dentry, old.inode);
3928 583806 : if (retval)
3929 228 : goto end_rename;
3930 : } else {
3931 38584 : retval = ext4_setent(handle, &new,
3932 38584 : old.inode->i_ino, old_file_type);
3933 38583 : if (retval)
3934 0 : goto end_rename;
3935 : }
3936 622161 : 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 622161 : old.inode->i_ctime = current_time(old.inode);
3945 622164 : retval = ext4_mark_inode_dirty(handle, old.inode);
3946 622165 : if (unlikely(retval))
3947 0 : goto end_rename;
3948 :
3949 622165 : if (!whiteout) {
3950 : /*
3951 : * ok, that's it
3952 : */
3953 574572 : ext4_rename_delete(handle, &old, force_reread);
3954 : }
3955 :
3956 622161 : if (new.inode) {
3957 38582 : ext4_dec_count(new.inode);
3958 38581 : new.inode->i_ctime = current_time(new.inode);
3959 : }
3960 622159 : old.dir->i_ctime = old.dir->i_mtime = current_time(old.dir);
3961 622153 : ext4_update_dx_flag(old.dir);
3962 622157 : if (old.dir_bh) {
3963 132657 : retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
3964 132657 : if (retval)
3965 0 : goto end_rename;
3966 :
3967 132657 : ext4_dec_count(old.dir);
3968 132656 : 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 179 : clear_nlink(new.inode);
3973 : } else {
3974 132477 : ext4_inc_count(new.dir);
3975 132477 : ext4_update_dx_flag(new.dir);
3976 132477 : retval = ext4_mark_inode_dirty(handle, new.dir);
3977 132478 : if (unlikely(retval))
3978 0 : goto end_rename;
3979 : }
3980 : }
3981 622157 : retval = ext4_mark_inode_dirty(handle, old.dir);
3982 622166 : if (unlikely(retval))
3983 0 : goto end_rename;
3984 :
3985 622166 : 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 132658 : ext4_fc_mark_ineligible(old.inode->i_sb,
3992 : EXT4_FC_REASON_RENAME_DIR, handle);
3993 : } else {
3994 489508 : struct super_block *sb = old.inode->i_sb;
3995 :
3996 489508 : if (new.inode)
3997 38405 : ext4_fc_track_unlink(handle, new.dentry);
3998 489508 : 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 622166 : if (new.inode) {
4010 38583 : retval = ext4_mark_inode_dirty(handle, new.inode);
4011 38584 : if (unlikely(retval))
4012 0 : goto end_rename;
4013 38584 : if (!new.inode->i_nlink)
4014 38551 : ext4_orphan_add(handle, new.inode);
4015 : }
4016 : retval = 0;
4017 :
4018 622406 : end_rename:
4019 622406 : if (whiteout) {
4020 47828 : if (retval) {
4021 231 : ext4_resetent(handle, &old,
4022 231 : old.inode->i_ino, old_file_type);
4023 231 : drop_nlink(whiteout);
4024 231 : ext4_orphan_add(handle, whiteout);
4025 : }
4026 47828 : unlock_new_inode(whiteout);
4027 47822 : ext4_journal_stop(handle);
4028 47811 : iput(whiteout);
4029 : } else {
4030 574578 : ext4_journal_stop(handle);
4031 : }
4032 622407 : release_bh:
4033 622407 : brelse(old.dir_bh);
4034 622407 : brelse(old.bh);
4035 622409 : brelse(new.bh);
4036 :
4037 : return retval;
4038 : }
4039 :
4040 31492 : static int ext4_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
4041 : struct inode *new_dir, struct dentry *new_dentry)
4042 : {
4043 31492 : handle_t *handle = NULL;
4044 31492 : struct ext4_renament old = {
4045 : .dir = old_dir,
4046 : .dentry = old_dentry,
4047 : .inode = d_inode(old_dentry),
4048 : };
4049 31492 : struct ext4_renament new = {
4050 : .dir = new_dir,
4051 : .dentry = new_dentry,
4052 : .inode = d_inode(new_dentry),
4053 : };
4054 31492 : u8 new_file_type;
4055 31492 : int retval;
4056 31492 : struct timespec64 ctime;
4057 :
4058 31492 : if ((ext4_test_inode_flag(new_dir, EXT4_INODE_PROJINHERIT) &&
4059 0 : !projid_eq(EXT4_I(new_dir)->i_projid,
4060 31492 : 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 31492 : retval = dquot_initialize(old.dir);
4067 31492 : if (retval)
4068 : return retval;
4069 31492 : retval = dquot_initialize(new.dir);
4070 31492 : if (retval)
4071 : return retval;
4072 :
4073 31492 : old.bh = ext4_find_entry(old.dir, &old.dentry->d_name,
4074 : &old.de, &old.inlined);
4075 31492 : 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 31492 : retval = -ENOENT;
4084 31492 : if (!old.bh || le32_to_cpu(old.de->inode) != old.inode->i_ino)
4085 0 : goto end_rename;
4086 :
4087 31492 : new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
4088 : &new.de, &new.inlined);
4089 31492 : 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 31492 : if (!new.bh || le32_to_cpu(new.de->inode) != new.inode->i_ino)
4097 0 : goto end_rename;
4098 :
4099 57190 : 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 31492 : if (IS_ERR(handle)) {
4103 0 : retval = PTR_ERR(handle);
4104 0 : handle = NULL;
4105 0 : goto end_rename;
4106 : }
4107 :
4108 31492 : if (IS_DIRSYNC(old.dir) || IS_DIRSYNC(new.dir))
4109 0 : ext4_handle_sync(handle);
4110 :
4111 31492 : if (S_ISDIR(old.inode->i_mode)) {
4112 3687 : old.is_dir = true;
4113 3687 : retval = ext4_rename_dir_prepare(handle, &old);
4114 3687 : if (retval)
4115 0 : goto end_rename;
4116 : }
4117 31492 : if (S_ISDIR(new.inode->i_mode)) {
4118 3687 : new.is_dir = true;
4119 3687 : retval = ext4_rename_dir_prepare(handle, &new);
4120 3687 : 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 31492 : 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 31492 : new_file_type = new.de->file_type;
4138 31492 : retval = ext4_setent(handle, &new, old.inode->i_ino, old.de->file_type);
4139 31492 : if (retval)
4140 0 : goto end_rename;
4141 :
4142 31492 : retval = ext4_setent(handle, &old, new.inode->i_ino, new_file_type);
4143 31492 : 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 31492 : ctime = current_time(old.inode);
4151 31492 : old.inode->i_ctime = ctime;
4152 31492 : new.inode->i_ctime = ctime;
4153 31492 : retval = ext4_mark_inode_dirty(handle, old.inode);
4154 31492 : if (unlikely(retval))
4155 0 : goto end_rename;
4156 31492 : retval = ext4_mark_inode_dirty(handle, new.inode);
4157 31492 : if (unlikely(retval))
4158 0 : goto end_rename;
4159 31492 : ext4_fc_mark_ineligible(new.inode->i_sb,
4160 : EXT4_FC_REASON_CROSS_RENAME, handle);
4161 31492 : if (old.dir_bh) {
4162 3687 : retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
4163 3687 : if (retval)
4164 0 : goto end_rename;
4165 : }
4166 31492 : if (new.dir_bh) {
4167 3687 : retval = ext4_rename_dir_finish(handle, &new, old.dir->i_ino);
4168 3687 : if (retval)
4169 0 : goto end_rename;
4170 : }
4171 31492 : ext4_update_dir_count(handle, &old);
4172 31492 : ext4_update_dir_count(handle, &new);
4173 31492 : retval = 0;
4174 :
4175 31492 : end_rename:
4176 31492 : brelse(old.dir_bh);
4177 31492 : brelse(new.dir_bh);
4178 31492 : brelse(old.bh);
4179 31492 : brelse(new.bh);
4180 31492 : if (handle)
4181 31492 : ext4_journal_stop(handle);
4182 : return retval;
4183 : }
4184 :
4185 654054 : 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 654054 : int err;
4191 :
4192 1308108 : if (unlikely(ext4_forced_shutdown(EXT4_SB(old_dir->i_sb))))
4193 : return -EIO;
4194 :
4195 653875 : if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
4196 : return -EINVAL;
4197 :
4198 653875 : err = fscrypt_prepare_rename(old_dir, old_dentry, new_dir, new_dentry,
4199 : flags);
4200 653875 : if (err)
4201 : return err;
4202 :
4203 653875 : if (flags & RENAME_EXCHANGE) {
4204 31492 : return ext4_cross_rename(old_dir, old_dentry,
4205 : new_dir, new_dentry);
4206 : }
4207 :
4208 622383 : 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 : };
|
