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 389487 : static struct buffer_head *ext4_append(handle_t *handle,
54 : struct inode *inode,
55 : ext4_lblk_t *block)
56 : {
57 389487 : struct ext4_map_blocks map;
58 389487 : struct buffer_head *bh;
59 389487 : int err;
60 :
61 389487 : 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 389487 : *block = inode->i_size >> inode->i_sb->s_blocksize_bits;
67 389487 : map.m_lblk = *block;
68 389487 : 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 389487 : err = ext4_map_blocks(NULL, inode, &map, 0);
76 389441 : if (err < 0)
77 0 : return ERR_PTR(err);
78 389441 : if (err) {
79 0 : EXT4_ERROR_INODE(inode, "Logical block already allocated");
80 0 : return ERR_PTR(-EFSCORRUPTED);
81 : }
82 :
83 389441 : bh = ext4_bread(handle, inode, *block, EXT4_GET_BLOCKS_CREATE);
84 389563 : if (IS_ERR(bh))
85 : return bh;
86 376419 : inode->i_size += inode->i_sb->s_blocksize;
87 376419 : EXT4_I(inode)->i_disksize = inode->i_size;
88 376419 : err = ext4_mark_inode_dirty(handle, inode);
89 376412 : if (err)
90 0 : goto out;
91 376412 : BUFFER_TRACE(bh, "get_write_access");
92 376412 : err = ext4_journal_get_write_access(handle, inode->i_sb, bh,
93 : EXT4_JTR_NONE);
94 376360 : 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 15446343 : 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 15446343 : struct buffer_head *bh;
131 15446343 : struct ext4_dir_entry *dirent;
132 15446343 : int is_dx_block = 0;
133 :
134 15446343 : 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 15446343 : if (ext4_simulate_fail(inode->i_sb, EXT4_SIM_DIRBLOCK_EIO))
142 : bh = ERR_PTR(-EIO);
143 : else
144 15446343 : bh = ext4_bread(NULL, inode, block, 0);
145 15458648 : 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 15458647 : 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 15458647 : if (!bh)
161 : return NULL;
162 15458647 : dirent = (struct ext4_dir_entry *) bh->b_data;
163 : /* Determine whether or not we have an index block */
164 15458647 : if (is_dx(inode)) {
165 13900685 : if (block == 0)
166 : is_dx_block = 1;
167 7613040 : else if (ext4_rec_len_from_disk(dirent->rec_len,
168 7613040 : inode->i_sb->s_blocksize) ==
169 : inode->i_sb->s_blocksize)
170 1351112 : is_dx_block = 1;
171 : }
172 15458647 : 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 30915028 : 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 62696 : if (is_dx_block && type == INDEX) {
188 701 : if (ext4_dx_csum_verify(inode, dirent) &&
189 699 : !ext4_simulate_fail(inode->i_sb, EXT4_SIM_DIRBLOCK_CRC))
190 699 : 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 62694 : if (!is_dx_block) {
200 61995 : if (ext4_dirblock_csum_verify(inode, bh) &&
201 61994 : !ext4_simulate_fail(inode->i_sb, EXT4_SIM_DIRBLOCK_CRC))
202 61994 : 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 404556 : void ext4_initialize_dirent_tail(struct buffer_head *bh,
331 : unsigned int blocksize)
332 : {
333 404556 : struct ext4_dir_entry_tail *t = EXT4_DIRENT_TAIL(bh->b_data, blocksize);
334 :
335 404556 : memset(t, 0, sizeof(struct ext4_dir_entry_tail));
336 404556 : t->det_rec_len = ext4_rec_len_to_disk(
337 : sizeof(struct ext4_dir_entry_tail), blocksize);
338 404556 : t->det_reserved_ft = EXT4_FT_DIR_CSUM;
339 404556 : }
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 5669449 : 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 5669449 : t = EXT4_DIRENT_TAIL(bh->b_data, EXT4_BLOCK_SIZE(inode->i_sb));
364 : #endif
365 :
366 5669449 : if (t->det_reserved_zero1 ||
367 : le16_to_cpu(t->det_rec_len) != sizeof(struct ext4_dir_entry_tail) ||
368 5669449 : 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 5669319 : struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
378 5669319 : struct ext4_inode_info *ei = EXT4_I(inode);
379 5669319 : __u32 csum;
380 :
381 5669319 : csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)dirent, size);
382 5667665 : 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 63799 : int ext4_dirblock_csum_verify(struct inode *inode, struct buffer_head *bh)
396 : {
397 63799 : struct ext4_dir_entry_tail *t;
398 :
399 63799 : if (!ext4_has_metadata_csum(inode->i_sb))
400 : return 1;
401 :
402 63740 : t = get_dirent_tail(inode, bh);
403 63610 : if (!t) {
404 130 : warn_no_space_for_csum(inode);
405 130 : return 0;
406 : }
407 :
408 63610 : if (t->det_checksum != ext4_dirblock_csum(inode, bh->b_data,
409 63610 : (char *)t - bh->b_data))
410 0 : return 0;
411 :
412 : return 1;
413 : }
414 :
415 5606923 : static void ext4_dirblock_csum_set(struct inode *inode,
416 : struct buffer_head *bh)
417 : {
418 5606923 : struct ext4_dir_entry_tail *t;
419 :
420 5606923 : if (!ext4_has_metadata_csum(inode->i_sb))
421 : return;
422 :
423 5605709 : t = get_dirent_tail(inode, bh);
424 5605709 : if (!t) {
425 0 : warn_no_space_for_csum(inode);
426 0 : return;
427 : }
428 :
429 5604055 : t->det_checksum = ext4_dirblock_csum(inode, bh->b_data,
430 5605709 : (char *)t - bh->b_data);
431 : }
432 :
433 5607246 : int ext4_handle_dirty_dirblock(handle_t *handle,
434 : struct inode *inode,
435 : struct buffer_head *bh)
436 : {
437 5607246 : ext4_dirblock_csum_set(inode, bh);
438 5605141 : return ext4_handle_dirty_metadata(handle, inode, bh);
439 : }
440 :
441 73280 : static struct dx_countlimit *get_dx_countlimit(struct inode *inode,
442 : struct ext4_dir_entry *dirent,
443 : int *offset)
444 : {
445 73280 : struct ext4_dir_entry *dp;
446 73280 : struct dx_root_info *root;
447 73280 : int count_offset;
448 :
449 73280 : if (le16_to_cpu(dirent->rec_len) == EXT4_BLOCK_SIZE(inode->i_sb))
450 : count_offset = 8;
451 50662 : else if (le16_to_cpu(dirent->rec_len) == 12) {
452 50660 : dp = (struct ext4_dir_entry *)(((void *)dirent) + 12);
453 50660 : if (le16_to_cpu(dp->rec_len) !=
454 50660 : EXT4_BLOCK_SIZE(inode->i_sb) - 12)
455 : return NULL;
456 50660 : root = (struct dx_root_info *)(((void *)dp + 12));
457 50660 : if (root->reserved_zero ||
458 50660 : root->info_length != sizeof(struct dx_root_info))
459 : return NULL;
460 : count_offset = 32;
461 : } else
462 : return NULL;
463 :
464 73278 : if (offset)
465 73278 : *offset = count_offset;
466 73278 : return (struct dx_countlimit *)(((void *)dirent) + count_offset);
467 : }
468 :
469 73278 : 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 73278 : struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
473 73278 : struct ext4_inode_info *ei = EXT4_I(inode);
474 73278 : __u32 csum;
475 73278 : int size;
476 73278 : __u32 dummy_csum = 0;
477 73278 : int offset = offsetof(struct dx_tail, dt_checksum);
478 :
479 73278 : size = count_offset + (count * sizeof(struct dx_entry));
480 73278 : csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)dirent, size);
481 73279 : csum = ext4_chksum(sbi, csum, (__u8 *)t, offset);
482 73278 : csum = ext4_chksum(sbi, csum, (__u8 *)&dummy_csum, sizeof(dummy_csum));
483 :
484 73278 : return cpu_to_le32(csum);
485 : }
486 :
487 701 : static int ext4_dx_csum_verify(struct inode *inode,
488 : struct ext4_dir_entry *dirent)
489 : {
490 701 : struct dx_countlimit *c;
491 701 : struct dx_tail *t;
492 701 : int count_offset, limit, count;
493 :
494 701 : if (!ext4_has_metadata_csum(inode->i_sb))
495 : return 1;
496 :
497 701 : c = get_dx_countlimit(inode, dirent, &count_offset);
498 701 : if (!c) {
499 2 : EXT4_ERROR_INODE(inode, "dir seems corrupt? Run e2fsck -D.");
500 2 : return 0;
501 : }
502 699 : limit = le16_to_cpu(c->limit);
503 699 : count = le16_to_cpu(c->count);
504 699 : if (count_offset + (limit * sizeof(struct dx_entry)) >
505 699 : EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) {
506 0 : warn_no_space_for_csum(inode);
507 0 : return 0;
508 : }
509 699 : t = (struct dx_tail *)(((struct dx_entry *)c) + limit);
510 :
511 699 : if (t->dt_checksum != ext4_dx_csum(inode, dirent, count_offset,
512 : count, t))
513 0 : return 0;
514 : return 1;
515 : }
516 :
517 72579 : static void ext4_dx_csum_set(struct inode *inode, struct ext4_dir_entry *dirent)
518 : {
519 72579 : struct dx_countlimit *c;
520 72579 : struct dx_tail *t;
521 72579 : int count_offset, limit, count;
522 :
523 72579 : if (!ext4_has_metadata_csum(inode->i_sb))
524 0 : return;
525 :
526 72579 : c = get_dx_countlimit(inode, dirent, &count_offset);
527 72579 : if (!c) {
528 0 : EXT4_ERROR_INODE(inode, "dir seems corrupt? Run e2fsck -D.");
529 0 : return;
530 : }
531 72579 : limit = le16_to_cpu(c->limit);
532 72579 : count = le16_to_cpu(c->count);
533 72579 : if (count_offset + (limit * sizeof(struct dx_entry)) >
534 72579 : EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) {
535 0 : warn_no_space_for_csum(inode);
536 0 : return;
537 : }
538 72579 : t = (struct dx_tail *)(((struct dx_entry *)c) + limit);
539 :
540 72579 : t->dt_checksum = ext4_dx_csum(inode, dirent, count_offset, count, t);
541 : }
542 :
543 72580 : static inline int ext4_handle_dirty_dx_node(handle_t *handle,
544 : struct inode *inode,
545 : struct buffer_head *bh)
546 : {
547 72580 : ext4_dx_csum_set(inode, (struct ext4_dir_entry *)bh->b_data);
548 72579 : 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 220030669 : return (struct ext4_dir_entry_2 *)((char *)p +
558 220030669 : 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 13828458 : 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 30514 : entry->block = cpu_to_le32(value);
574 : }
575 :
576 : static inline unsigned dx_get_hash(struct dx_entry *entry)
577 : {
578 30701501 : return le32_to_cpu(entry->hash);
579 : }
580 :
581 : static inline void dx_set_hash(struct dx_entry *entry, unsigned value)
582 : {
583 29230 : entry->hash = cpu_to_le32(value);
584 : }
585 :
586 : static inline unsigned dx_get_count(struct dx_entry *entries)
587 : {
588 10512578 : return le16_to_cpu(((struct dx_countlimit *) entries)->count);
589 : }
590 :
591 : static inline unsigned dx_get_limit(struct dx_entry *entries)
592 : {
593 15231821 : 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 30712 : ((struct dx_countlimit *) entries)->count = cpu_to_le16(value);
599 : }
600 :
601 : static inline void dx_set_limit(struct dx_entry *entries, unsigned value)
602 : {
603 1482 : ((struct dx_countlimit *) entries)->limit = cpu_to_le16(value);
604 : }
605 :
606 6233969 : static inline unsigned dx_root_limit(struct inode *dir, unsigned infosize)
607 : {
608 6233969 : unsigned int entry_space = dir->i_sb->s_blocksize -
609 6233969 : ext4_dir_rec_len(1, NULL) -
610 : ext4_dir_rec_len(2, NULL) - infosize;
611 :
612 6233969 : if (ext4_has_metadata_csum(dir->i_sb))
613 6234502 : entry_space -= sizeof(struct dx_tail);
614 6234699 : return entry_space / sizeof(struct dx_entry);
615 : }
616 :
617 1351296 : static inline unsigned dx_node_limit(struct inode *dir)
618 : {
619 1351296 : unsigned int entry_space = dir->i_sb->s_blocksize -
620 : ext4_dir_rec_len(0, dir);
621 :
622 1351296 : if (ext4_has_metadata_csum(dir->i_sb))
623 1351296 : entry_space -= sizeof(struct dx_tail);
624 1351296 : 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 6247833 : dx_probe(struct ext4_filename *fname, struct inode *dir,
808 : struct dx_hash_info *hinfo, struct dx_frame *frame_in)
809 : {
810 6247833 : unsigned count, indirect, level, i;
811 6247833 : struct dx_entry *at, *entries, *p, *q, *m;
812 6247833 : struct dx_root *root;
813 6247833 : struct dx_frame *frame = frame_in;
814 6247833 : struct dx_frame *ret_err = ERR_PTR(ERR_BAD_DX_DIR);
815 6247833 : u32 hash;
816 6247833 : ext4_lblk_t block;
817 6247833 : ext4_lblk_t blocks[EXT4_HTREE_LEVEL];
818 :
819 6247833 : memset(frame_in, 0, EXT4_HTREE_LEVEL * sizeof(frame_in[0]));
820 6247833 : frame->bh = ext4_read_dirblock(dir, 0, INDEX);
821 6239672 : if (IS_ERR(frame->bh))
822 : return (struct dx_frame *) frame->bh;
823 :
824 6239670 : root = (struct dx_root *) frame->bh->b_data;
825 6239670 : if (root->info.hash_version != DX_HASH_TEA &&
826 : root->info.hash_version != DX_HASH_HALF_MD4 &&
827 6239670 : 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 6239670 : 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 6239670 : 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 6239670 : if (fname)
847 5535091 : hinfo = &fname->hinfo;
848 6239670 : hinfo->hash_version = root->info.hash_version;
849 6239670 : if (hinfo->hash_version <= DX_HASH_TEA)
850 6244582 : hinfo->hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
851 6239670 : hinfo->seed = EXT4_SB(dir->i_sb)->s_hash_seed;
852 : /* hash is already computed for encrypted casefolded directory */
853 6239670 : if (fname && fname_name(fname) &&
854 5538700 : !(IS_ENCRYPTED(dir) && IS_CASEFOLDED(dir))) {
855 5537785 : int ret = ext4fs_dirhash(dir, fname_name(fname),
856 5537785 : fname_len(fname), hinfo);
857 5534703 : if (ret < 0) {
858 0 : ret_err = ERR_PTR(ret);
859 0 : goto fail;
860 : }
861 : }
862 6236588 : hash = hinfo->hash;
863 :
864 6236588 : 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 6236588 : indirect = root->info.indirect_levels;
871 11674880 : 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 6236588 : entries = (struct dx_entry *)(((char *)&root->info) +
884 6236588 : root->info.info_length);
885 :
886 6236588 : 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 6235619 : dxtrace(printk("Look up %x", hash));
895 6235619 : level = 0;
896 6235619 : blocks[0] = 0;
897 7586713 : while (1) {
898 7586713 : count = dx_get_count(entries);
899 7586713 : 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 7586713 : p = entries + 1;
907 7586713 : q = entries + count - 1;
908 35884885 : while (p <= q) {
909 28298172 : m = p + (q - p) / 2;
910 28298172 : dxtrace(printk(KERN_CONT "."));
911 28298172 : if (dx_get_hash(m) > hash)
912 14115275 : q = m - 1;
913 : else
914 14182897 : p = m + 1;
915 : }
916 :
917 7586713 : htree_rep_invariant_check(entries, p, hash, count - 1);
918 :
919 7586713 : at = p - 1;
920 : dxtrace(printk(KERN_CONT " %x->%u\n",
921 : at == entries ? 0 : dx_get_hash(at),
922 7586713 : dx_get_block(at)));
923 7586713 : frame->entries = entries;
924 7586713 : frame->at = at;
925 :
926 7586713 : block = dx_get_block(at);
927 16862352 : for (i = 0; i <= level; i++) {
928 9273713 : 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 7588639 : if (++level > indirect)
936 6237545 : return frame;
937 1351094 : blocks[level] = block;
938 1351094 : frame++;
939 1351094 : frame->bh = ext4_read_dirblock(dir, block, INDEX);
940 1351094 : 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 1351094 : entries = ((struct dx_node *) frame->bh->b_data)->entries;
947 :
948 1351094 : 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 6257496 : static void dx_release(struct dx_frame *frames)
968 : {
969 6257496 : struct dx_root_info *info;
970 6257496 : int i;
971 6257496 : unsigned int indirect_levels;
972 :
973 6257496 : if (frames[0].bh == NULL)
974 : return;
975 :
976 6257496 : info = &((struct dx_root *)frames[0].bh->b_data)->info;
977 : /* save local copy, "info" may be freed after brelse() */
978 6257496 : indirect_levels = info->indirect_levels;
979 13866490 : for (i = 0; i <= indirect_levels; i++) {
980 7608408 : if (frames[i].bh == NULL)
981 : break;
982 7608404 : brelse(frames[i].bh);
983 7608994 : 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 2863248 : 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 2863248 : struct dx_frame *p;
1010 2863248 : struct buffer_head *bh;
1011 2863248 : int num_frames = 0;
1012 2863248 : __u32 bhash;
1013 :
1014 2863248 : 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 2873226 : while (1) {
1023 2868237 : if (++(p->at) < p->entries + dx_get_count(p->entries))
1024 : break;
1025 465106 : if (p == frames)
1026 : return 0;
1027 4989 : num_frames++;
1028 4989 : 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 2403131 : bhash = dx_get_hash(p->at);
1039 2403131 : if (start_hash)
1040 683814 : *start_hash = bhash;
1041 2403131 : if ((hash & 1) == 0) {
1042 1719258 : 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 683889 : while (num_frames--) {
1050 76 : 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 812062 : 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 812062 : struct buffer_head *bh;
1073 812062 : struct ext4_dir_entry_2 *de, *top;
1074 812062 : int err = 0, count = 0;
1075 812062 : struct fscrypt_str fname_crypto_str = FSTR_INIT(NULL, 0), tmp_str;
1076 812062 : int csum = ext4_has_metadata_csum(dir->i_sb);
1077 :
1078 : dxtrace(printk(KERN_INFO "In htree dirblock_to_tree: block %lu\n",
1079 812021 : (unsigned long)block));
1080 812021 : bh = ext4_read_dirblock(dir, block, DIRENT_HTREE);
1081 812080 : if (IS_ERR(bh))
1082 1 : return PTR_ERR(bh);
1083 :
1084 812079 : de = (struct ext4_dir_entry_2 *) bh->b_data;
1085 : /* csum entries are not larger in the casefolded encrypted case */
1086 1624158 : top = (struct ext4_dir_entry_2 *) ((char *) de +
1087 1624158 : dir->i_sb->s_blocksize -
1088 812079 : ext4_dir_rec_len(0,
1089 : csum ? NULL : dir));
1090 : /* Check if the directory is encrypted */
1091 812079 : 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 152270476 : for (; de < top; de = ext4_next_entry(de, dir->i_sb->s_blocksize)) {
1106 151458403 : 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 151458770 : 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 151458770 : err = ext4fs_dirhash(dir, de->name,
1123 151458770 : de->name_len, hinfo);
1124 151459104 : if (err < 0) {
1125 0 : count = err;
1126 0 : goto errout;
1127 : }
1128 : }
1129 151459104 : if ((hinfo->hash < start_hash) ||
1130 631143 : ((hinfo->hash == start_hash) &&
1131 631143 : (hinfo->minor_hash < start_minor_hash)))
1132 641627 : continue;
1133 150817477 : if (de->inode == 0)
1134 687309 : continue;
1135 150130168 : if (!IS_ENCRYPTED(dir)) {
1136 150130168 : tmp_str.name = de->name;
1137 150130168 : tmp_str.len = de->name_len;
1138 150130168 : 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 150129461 : if (err != 0) {
1160 0 : count = err;
1161 0 : goto errout;
1162 : }
1163 150129461 : count++;
1164 : }
1165 812073 : errout:
1166 812073 : 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 812074 : int ext4_htree_fill_tree(struct file *dir_file, __u32 start_hash,
1181 : __u32 start_minor_hash, __u32 *next_hash)
1182 : {
1183 812074 : struct dx_hash_info hinfo;
1184 812074 : struct ext4_dir_entry_2 *de;
1185 812074 : struct dx_frame frames[EXT4_HTREE_LEVEL], *frame;
1186 812074 : struct inode *dir;
1187 812074 : ext4_lblk_t block;
1188 812074 : int count = 0;
1189 812074 : int ret, err;
1190 812074 : __u32 hashval;
1191 812074 : struct fscrypt_str tmp_str;
1192 :
1193 : dxtrace(printk(KERN_DEBUG "In htree_fill_tree, start hash: %x:%x\n",
1194 812074 : start_hash, start_minor_hash));
1195 812074 : dir = file_inode(dir_file);
1196 812074 : if (!(ext4_test_inode_flag(dir, EXT4_INODE_INDEX))) {
1197 107492 : if (ext4_hash_in_dirent(dir))
1198 0 : hinfo.hash_version = DX_HASH_SIPHASH;
1199 : else
1200 107492 : hinfo.hash_version =
1201 107492 : EXT4_SB(dir->i_sb)->s_def_hash_version;
1202 107492 : if (hinfo.hash_version <= DX_HASH_TEA)
1203 107480 : hinfo.hash_version +=
1204 107480 : EXT4_SB(dir->i_sb)->s_hash_unsigned;
1205 107492 : hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
1206 107492 : 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 107492 : count = htree_dirblock_to_tree(dir_file, dir, 0, &hinfo,
1218 : start_hash, start_minor_hash);
1219 107515 : *next_hash = ~0;
1220 107515 : return count;
1221 : }
1222 704582 : hinfo.hash = start_hash;
1223 704582 : hinfo.minor_hash = 0;
1224 704582 : frame = dx_probe(NULL, dir, &hinfo, frames);
1225 704580 : if (IS_ERR(frame))
1226 0 : return PTR_ERR(frame);
1227 :
1228 : /* Add '.' and '..' from the htree header */
1229 704580 : if (!start_hash && !start_minor_hash) {
1230 25420 : de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data;
1231 25420 : tmp_str.name = de->name;
1232 25420 : tmp_str.len = de->name_len;
1233 25420 : err = ext4_htree_store_dirent(dir_file, 0, 0,
1234 : de, &tmp_str);
1235 25414 : if (err != 0)
1236 0 : goto errout;
1237 : count++;
1238 : }
1239 704574 : if (start_hash < 2 || (start_hash ==2 && start_minor_hash==0)) {
1240 74575 : de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data;
1241 74575 : de = ext4_next_entry(de, dir->i_sb->s_blocksize);
1242 74575 : tmp_str.name = de->name;
1243 74575 : tmp_str.len = de->name_len;
1244 74575 : err = ext4_htree_store_dirent(dir_file, 2, 0,
1245 : de, &tmp_str);
1246 74580 : if (err != 0)
1247 0 : goto errout;
1248 74580 : count++;
1249 : }
1250 :
1251 704585 : while (1) {
1252 704585 : if (fatal_signal_pending(current)) {
1253 0 : err = -ERESTARTSYS;
1254 0 : goto errout;
1255 : }
1256 704583 : cond_resched();
1257 704583 : block = dx_get_block(frame->at);
1258 704583 : ret = htree_dirblock_to_tree(dir_file, dir, block, &hinfo,
1259 : start_hash, start_minor_hash);
1260 704590 : if (ret < 0) {
1261 0 : err = ret;
1262 0 : goto errout;
1263 : }
1264 704590 : count += ret;
1265 704590 : hashval = ~0;
1266 704590 : ret = ext4_htree_next_block(dir, HASH_NB_ALWAYS,
1267 : frame, frames, &hashval);
1268 704588 : *next_hash = hashval;
1269 704588 : 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 704588 : if ((ret == 0) ||
1279 683806 : (count && ((hashval & 1) == 0)))
1280 : break;
1281 : }
1282 704582 : dx_release(frames);
1283 : dxtrace(printk(KERN_DEBUG "Fill tree: returned %d entries, "
1284 704582 : "next hash: %x\n", count, *next_hash));
1285 704582 : return count;
1286 0 : errout:
1287 0 : dx_release(frames);
1288 0 : return (err);
1289 : }
1290 :
1291 5909011 : 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 5909011 : 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 29032 : 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 29032 : int count = 0;
1314 29032 : struct ext4_dir_entry_2 *de = (struct ext4_dir_entry_2 *)bh->b_data;
1315 29032 : unsigned int buflen = bh->b_size;
1316 29032 : char *base = bh->b_data;
1317 29032 : struct dx_hash_info h = *hinfo;
1318 :
1319 29032 : if (ext4_has_metadata_csum(dir->i_sb))
1320 29032 : buflen -= sizeof(struct ext4_dir_entry_tail);
1321 :
1322 2253167 : while ((char *) de < base + buflen) {
1323 2224135 : if (ext4_check_dir_entry(dir, NULL, de, bh, base, buflen,
1324 : ((char *)de) - base))
1325 : return -EFSCORRUPTED;
1326 2224114 : if (de->name_len && de->inode) {
1327 2224114 : if (ext4_hash_in_dirent(dir))
1328 0 : h.hash = EXT4_DIRENT_HASH(de);
1329 : else {
1330 2224114 : int err = ext4fs_dirhash(dir, de->name,
1331 : de->name_len, &h);
1332 2224135 : if (err < 0)
1333 0 : return err;
1334 : }
1335 2224135 : map_tail--;
1336 2224135 : map_tail->hash = h.hash;
1337 2224135 : map_tail->offs = ((char *) de - base)>>2;
1338 2224135 : map_tail->size = le16_to_cpu(de->rec_len);
1339 2224135 : count++;
1340 2224135 : cond_resched();
1341 : }
1342 2224135 : de = ext4_next_entry(de, dir->i_sb->s_blocksize);
1343 : }
1344 : return count;
1345 : }
1346 :
1347 : /* Sort map by hash value */
1348 29032 : static void dx_sort_map (struct dx_map_entry *map, unsigned count)
1349 : {
1350 29032 : struct dx_map_entry *p, *q, *top = map + count - 1;
1351 29032 : int more;
1352 : /* Combsort until bubble sort doesn't suck */
1353 314317 : while (count > 2) {
1354 285285 : count = count*10/13;
1355 285285 : if (count - 9 < 2) /* 9, 10 -> 11 */
1356 5343 : count = 11;
1357 25377266 : for (p = top, q = p - count; q >= map; p--, q--)
1358 25091981 : if (p->hash < q->hash)
1359 25091981 : swap(*p, *q);
1360 : }
1361 : /* Garden variety bubble sort */
1362 63046 : do {
1363 63046 : more = 0;
1364 63046 : q = top;
1365 5621250 : while (q-- > map) {
1366 5558204 : if (q[1].hash >= q[0].hash)
1367 4981433 : continue;
1368 576771 : swap(*(q+1), *q);
1369 576771 : more = 1;
1370 : }
1371 63046 : } while(more);
1372 29032 : }
1373 :
1374 29230 : static void dx_insert_block(struct dx_frame *frame, u32 hash, ext4_lblk_t block)
1375 : {
1376 29230 : struct dx_entry *entries = frame->entries;
1377 29230 : struct dx_entry *old = frame->at, *new = old + 1;
1378 29230 : int count = dx_get_count(entries);
1379 :
1380 29230 : ASSERT(count < dx_get_limit(entries));
1381 29230 : ASSERT(old < entries + count);
1382 58460 : memmove(new + 1, new, (char *)(entries + count) - (char *)(new));
1383 29230 : dx_set_hash(new, hash);
1384 29230 : dx_set_block(new, block);
1385 29230 : dx_set_count(entries, count + 1);
1386 29230 : }
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 622863247 : static bool ext4_match(struct inode *parent,
1484 : const struct ext4_filename *fname,
1485 : struct ext4_dir_entry_2 *de)
1486 : {
1487 622863247 : struct fscrypt_name f;
1488 :
1489 622863247 : if (!de->inode)
1490 : return false;
1491 :
1492 618434737 : f.usr_fname = fname->usr_fname;
1493 618434737 : 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 618434737 : 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 5906202 : 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 5906202 : struct ext4_dir_entry_2 * de;
1531 5906202 : char * dlimit;
1532 5906202 : int de_len;
1533 :
1534 5906202 : de = (struct ext4_dir_entry_2 *)search_buf;
1535 5906202 : dlimit = search_buf + buf_size;
1536 361059157 : while ((char *) de < dlimit - EXT4_BASE_DIR_LEN) {
1537 : /* this code is executed quadratically often */
1538 : /* do minimal checking `by hand' */
1539 715254770 : if (de->name + de->name_len <= dlimit &&
1540 357652429 : ext4_match(dir, fname, de)) {
1541 : /* found a match - just to be sure, do
1542 : * a full check */
1543 2449386 : if (ext4_check_dir_entry(dir, NULL, de, bh, search_buf,
1544 : buf_size, offset))
1545 : return -1;
1546 2449126 : *res_dir = de;
1547 2449126 : return 1;
1548 : }
1549 : /* prevent looping on a bad block */
1550 355152955 : de_len = ext4_rec_len_from_disk(de->rec_len,
1551 : dir->i_sb->s_blocksize);
1552 355152955 : if (de_len <= 0)
1553 : return -1;
1554 355152955 : offset += de_len;
1555 355152955 : de = (struct ext4_dir_entry_2 *) ((char *) de + de_len);
1556 : }
1557 : return 0;
1558 : }
1559 :
1560 1380 : static int is_dx_internal_node(struct inode *dir, ext4_lblk_t block,
1561 : struct ext4_dir_entry *de)
1562 : {
1563 1380 : struct super_block *sb = dir->i_sb;
1564 :
1565 1380 : 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 5904394 : 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 5904394 : struct super_block *sb;
1593 5904394 : struct buffer_head *bh_use[NAMEI_RA_SIZE];
1594 5904394 : struct buffer_head *bh, *ret = NULL;
1595 5904394 : ext4_lblk_t start, block;
1596 5904394 : const u8 *name = fname->usr_fname->name;
1597 5904394 : size_t ra_max = 0; /* Number of bh's in the readahead
1598 : buffer, bh_use[] */
1599 5904394 : size_t ra_ptr = 0; /* Current index into readahead
1600 : buffer */
1601 5904394 : ext4_lblk_t nblocks;
1602 5904394 : int i, namelen, retval;
1603 :
1604 5904394 : *res_dir = NULL;
1605 5904394 : sb = dir->i_sb;
1606 5904394 : namelen = fname->usr_fname->len;
1607 5904394 : if (namelen > EXT4_NAME_LEN)
1608 : return NULL;
1609 :
1610 5904394 : 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 5904394 : 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 5904385 : if (is_dx(dir)) {
1631 3755708 : 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 3761383 : if (!IS_ERR(ret) || PTR_ERR(ret) != ERR_BAD_DX_DIR)
1638 3761383 : goto cleanup_and_exit;
1639 : dxtrace(printk(KERN_DEBUG "ext4_find_entry: dx failed, "
1640 : "falling back\n"));
1641 : ret = NULL;
1642 : }
1643 2148677 : nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
1644 2148677 : if (!nblocks) {
1645 0 : ret = NULL;
1646 0 : goto cleanup_and_exit;
1647 : }
1648 2148677 : start = EXT4_I(dir)->i_dir_start_lookup;
1649 2148677 : if (start >= nblocks)
1650 0 : start = 0;
1651 : block = start;
1652 2148686 : restart:
1653 2148844 : do {
1654 : /*
1655 : * We deal with the read-ahead logic here.
1656 : */
1657 2148844 : cond_resched();
1658 2148964 : if (ra_ptr >= ra_max) {
1659 : /* Refill the readahead buffer */
1660 2149166 : ra_ptr = 0;
1661 2149166 : if (block < start)
1662 0 : ra_max = start - block;
1663 : else
1664 2149166 : ra_max = nblocks - block;
1665 2149166 : ra_max = min(ra_max, ARRAY_SIZE(bh_use));
1666 2149166 : retval = ext4_bread_batch(dir, block, ra_max,
1667 : false /* wait */, bh_use);
1668 2148505 : if (retval) {
1669 0 : ret = ERR_PTR(retval);
1670 0 : ra_max = 0;
1671 0 : goto cleanup_and_exit;
1672 : }
1673 : }
1674 2148303 : if ((bh = bh_use[ra_ptr++]) == NULL)
1675 0 : goto next;
1676 2148415 : wait_on_buffer(bh);
1677 4298860 : 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 4300424 : if (!buffer_verified(bh) &&
1686 1380 : !is_dx_internal_node(dir, block,
1687 2760 : (struct ext4_dir_entry *)bh->b_data) &&
1688 1380 : !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 2149392 : set_buffer_verified(bh);
1697 4298784 : i = search_dirblock(bh, dir, fname,
1698 2149392 : block << EXT4_BLOCK_SIZE_BITS(sb), res_dir);
1699 2153089 : if (i == 1) {
1700 846711 : EXT4_I(dir)->i_dir_start_lookup = block;
1701 846711 : ret = bh;
1702 846711 : goto cleanup_and_exit;
1703 : } else {
1704 1306378 : brelse(bh);
1705 1306653 : if (i < 0)
1706 0 : goto cleanup_and_exit;
1707 : }
1708 1306653 : next:
1709 1306653 : if (++block >= nblocks)
1710 1306610 : block = 0;
1711 1306653 : } 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 1306495 : block = nblocks;
1718 1306495 : nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
1719 1306495 : if (block < nblocks) {
1720 0 : start = 0;
1721 0 : goto restart;
1722 : }
1723 :
1724 5914720 : cleanup_and_exit:
1725 : /* Clean up the read-ahead blocks */
1726 5914732 : for (; ra_ptr < ra_max; ra_ptr++)
1727 347 : brelse(bh_use[ra_ptr]);
1728 : return ret;
1729 : }
1730 :
1731 2837141 : 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 2837141 : int err;
1737 2837141 : struct ext4_filename fname;
1738 2837141 : struct buffer_head *bh;
1739 :
1740 2837141 : err = ext4_fname_setup_filename(dir, d_name, 1, &fname);
1741 2837141 : if (err == -ENOENT)
1742 : return NULL;
1743 2837141 : if (err)
1744 : return ERR_PTR(err);
1745 :
1746 2837141 : bh = __ext4_find_entry(dir, &fname, res_dir, inlined);
1747 :
1748 2838586 : ext4_fname_free_filename(&fname);
1749 2838586 : return bh;
1750 : }
1751 :
1752 3066925 : static struct buffer_head *ext4_lookup_entry(struct inode *dir,
1753 : struct dentry *dentry,
1754 : struct ext4_dir_entry_2 **res_dir)
1755 : {
1756 3066925 : int err;
1757 3066925 : struct ext4_filename fname;
1758 3066925 : struct buffer_head *bh;
1759 :
1760 3066925 : err = ext4_fname_prepare_lookup(dir, dentry, &fname);
1761 3066925 : generic_set_encrypted_ci_d_ops(dentry);
1762 3064716 : if (err == -ENOENT)
1763 : return NULL;
1764 3064716 : if (err)
1765 : return ERR_PTR(err);
1766 :
1767 3064716 : bh = __ext4_find_entry(dir, &fname, res_dir, NULL);
1768 :
1769 3075874 : ext4_fname_free_filename(&fname);
1770 3075874 : return bh;
1771 : }
1772 :
1773 3753890 : 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 3753890 : struct super_block * sb = dir->i_sb;
1778 3753890 : struct dx_frame frames[EXT4_HTREE_LEVEL], *frame;
1779 3753890 : struct buffer_head *bh;
1780 3753890 : ext4_lblk_t block;
1781 3753890 : int retval;
1782 :
1783 : #ifdef CONFIG_FS_ENCRYPTION
1784 : *res_dir = NULL;
1785 : #endif
1786 3753890 : frame = dx_probe(fname, dir, NULL, frames);
1787 3749759 : if (IS_ERR(frame))
1788 : return (struct buffer_head *) frame;
1789 3749753 : do {
1790 3749753 : block = dx_get_block(frame->at);
1791 3749753 : bh = ext4_read_dirblock(dir, block, DIRENT_HTREE);
1792 3760550 : if (IS_ERR(bh))
1793 0 : goto errout;
1794 :
1795 7521100 : retval = search_dirblock(bh, dir, fname,
1796 3760550 : block << EXT4_BLOCK_SIZE_BITS(sb),
1797 : res_dir);
1798 3760966 : if (retval == 1)
1799 1602483 : goto success;
1800 2158483 : brelse(bh);
1801 2158694 : 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 2158694 : retval = ext4_htree_next_block(dir, fname->hinfo.hash, frame,
1808 : frames, NULL);
1809 2158483 : 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 2158483 : } while (retval == 1);
1817 :
1818 : bh = NULL;
1819 3760970 : errout:
1820 3760970 : dxtrace(printk(KERN_DEBUG "%s not found\n", fname->usr_fname->name));
1821 3760970 : success:
1822 3760970 : dx_release(frames);
1823 3760970 : return bh;
1824 : }
1825 :
1826 3069955 : static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
1827 : {
1828 3069955 : struct inode *inode;
1829 3069955 : struct ext4_dir_entry_2 *de;
1830 3069955 : struct buffer_head *bh;
1831 :
1832 3069955 : if (dentry->d_name.len > EXT4_NAME_LEN)
1833 : return ERR_PTR(-ENAMETOOLONG);
1834 :
1835 3068795 : bh = ext4_lookup_entry(dir, dentry, &de);
1836 3075774 : if (IS_ERR(bh))
1837 : return ERR_CAST(bh);
1838 3075641 : inode = NULL;
1839 3075641 : if (bh) {
1840 193031 : __u32 ino = le32_to_cpu(de->inode);
1841 193031 : brelse(bh);
1842 193036 : 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 193037 : 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 193037 : inode = ext4_iget(dir->i_sb, ino, EXT4_IGET_NORMAL);
1852 193033 : 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 193033 : 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 3075643 : 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 29032 : dx_move_dirents(struct inode *dir, char *from, char *to,
1912 : struct dx_map_entry *map, int count,
1913 : unsigned blocksize)
1914 : {
1915 29032 : unsigned rec_len = 0;
1916 :
1917 1146091 : while (count--) {
1918 1117059 : struct ext4_dir_entry_2 *de = (struct ext4_dir_entry_2 *)
1919 1117059 : (from + (map->offs<<2));
1920 1117059 : rec_len = ext4_dir_rec_len(de->name_len, dir);
1921 :
1922 2234118 : memcpy (to, de, rec_len);
1923 1117059 : ((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 1117059 : de->inode = 0;
1928 1117059 : 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 1117059 : map++;
1934 1117059 : to += rec_len;
1935 : }
1936 29032 : 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 29032 : static struct ext4_dir_entry_2 *dx_pack_dirents(struct inode *dir, char *base,
1944 : unsigned int blocksize)
1945 : {
1946 29032 : struct ext4_dir_entry_2 *next, *to, *prev, *de = (struct ext4_dir_entry_2 *) base;
1947 29032 : unsigned rec_len = 0;
1948 :
1949 29032 : prev = to = de;
1950 2282003 : while ((char*)de < base + blocksize) {
1951 2252971 : next = ext4_next_entry(de, blocksize);
1952 2252971 : if (de->inode && de->name_len) {
1953 1106912 : rec_len = ext4_dir_rec_len(de->name_len, dir);
1954 1106912 : if (de > to)
1955 1598310 : memmove(to, de, rec_len);
1956 1106912 : to->rec_len = ext4_rec_len_to_disk(rec_len, blocksize);
1957 1106912 : prev = to;
1958 1106912 : to = (struct ext4_dir_entry_2 *) (((char *) to) + rec_len);
1959 : }
1960 : de = next;
1961 : }
1962 29032 : 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 29271 : 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 29271 : unsigned blocksize = dir->i_sb->s_blocksize;
1975 29271 : unsigned continued;
1976 29271 : int count;
1977 29271 : struct buffer_head *bh2;
1978 29271 : ext4_lblk_t newblock;
1979 29271 : u32 hash2;
1980 29271 : struct dx_map_entry *map;
1981 29271 : char *data1 = (*bh)->b_data, *data2;
1982 29271 : unsigned split, move, size;
1983 29271 : struct ext4_dir_entry_2 *de = NULL, *de2;
1984 29271 : int csum_size = 0;
1985 29271 : int err = 0, i;
1986 :
1987 29271 : if (ext4_has_metadata_csum(dir->i_sb))
1988 29271 : csum_size = sizeof(struct ext4_dir_entry_tail);
1989 :
1990 29271 : bh2 = ext4_append(handle, dir, &newblock);
1991 29271 : if (IS_ERR(bh2)) {
1992 239 : brelse(*bh);
1993 239 : *bh = NULL;
1994 239 : return (struct ext4_dir_entry_2 *) bh2;
1995 : }
1996 :
1997 29032 : BUFFER_TRACE(*bh, "get_write_access");
1998 29032 : err = ext4_journal_get_write_access(handle, dir->i_sb, *bh,
1999 : EXT4_JTR_NONE);
2000 29032 : if (err)
2001 0 : goto journal_error;
2002 :
2003 29032 : BUFFER_TRACE(frame->bh, "get_write_access");
2004 29032 : err = ext4_journal_get_write_access(handle, dir->i_sb, frame->bh,
2005 : EXT4_JTR_NONE);
2006 29032 : if (err)
2007 0 : goto journal_error;
2008 :
2009 29032 : data2 = bh2->b_data;
2010 :
2011 : /* create map in the end of data2 block */
2012 29032 : map = (struct dx_map_entry *) (data2 + blocksize);
2013 29032 : count = dx_make_map(dir, *bh, hinfo, map);
2014 29032 : if (count < 0) {
2015 0 : err = count;
2016 0 : goto journal_error;
2017 : }
2018 29032 : map -= count;
2019 29032 : dx_sort_map(map, count);
2020 : /* Ensure that neither split block is over half full */
2021 29032 : size = 0;
2022 29032 : move = 0;
2023 1146197 : for (i = count-1; i >= 0; i--) {
2024 : /* is more than half of this entry in 2nd half of the block? */
2025 1146197 : if (size + map[i].size/2 > blocksize/2)
2026 : break;
2027 1117165 : size += map[i].size;
2028 1117165 : 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 29032 : if (i > 0)
2038 29032 : split = count - move;
2039 : else
2040 0 : split = count/2;
2041 :
2042 29032 : hash2 = map[split].hash;
2043 29032 : 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 29032 : hash2, split, count-split));
2047 :
2048 : /* Fancy dance to stay within two buffers */
2049 29032 : de2 = dx_move_dirents(dir, data1, data2, map + split, count - split,
2050 : blocksize);
2051 29032 : de = dx_pack_dirents(dir, data1, blocksize);
2052 29032 : de->rec_len = ext4_rec_len_to_disk(data1 + (blocksize - csum_size) -
2053 : (char *) de,
2054 : blocksize);
2055 29032 : de2->rec_len = ext4_rec_len_to_disk(data2 + (blocksize - csum_size) -
2056 : (char *) de2,
2057 : blocksize);
2058 29032 : if (csum_size) {
2059 29032 : ext4_initialize_dirent_tail(*bh, blocksize);
2060 29032 : ext4_initialize_dirent_tail(bh2, blocksize);
2061 : }
2062 :
2063 : dxtrace(dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *) data1,
2064 29032 : blocksize, 1));
2065 : dxtrace(dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *) data2,
2066 29032 : blocksize, 1));
2067 :
2068 : /* Which block gets the new entry? */
2069 29032 : if (hinfo->hash >= hash2) {
2070 14482 : swap(*bh, bh2);
2071 14482 : de = de2;
2072 : }
2073 29032 : dx_insert_block(frame, hash2 + continued, newblock);
2074 29032 : err = ext4_handle_dirty_dirblock(handle, dir, bh2);
2075 29032 : if (err)
2076 0 : goto journal_error;
2077 29032 : err = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
2078 29032 : if (err)
2079 0 : goto journal_error;
2080 29032 : 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 2917010 : 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 2917010 : struct ext4_dir_entry_2 *de;
2099 2917010 : unsigned short reclen = ext4_dir_rec_len(fname_len(fname), dir);
2100 2917010 : int nlen, rlen;
2101 2917010 : unsigned int offset = 0;
2102 2917010 : char *top;
2103 :
2104 2917010 : de = buf;
2105 2917010 : top = buf + buf_size - reclen;
2106 267414002 : while ((char *) de <= top) {
2107 267384731 : if (ext4_check_dir_entry(dir, NULL, de, bh,
2108 : buf, buf_size, offset))
2109 : return -EFSCORRUPTED;
2110 267527966 : if (ext4_match(dir, fname, de))
2111 : return -EEXIST;
2112 267390381 : nlen = ext4_dir_rec_len(de->name_len, dir);
2113 267390381 : rlen = ext4_rec_len_from_disk(de->rec_len, buf_size);
2114 267390381 : if ((de->inode ? rlen - nlen : rlen) >= reclen)
2115 : break;
2116 264496992 : de = (struct ext4_dir_entry_2 *)((char *)de + rlen);
2117 264496992 : offset += rlen;
2118 : }
2119 2922660 : if ((char *) de > top)
2120 : return -ENOSPC;
2121 :
2122 2893380 : *dest_de = de;
2123 2893380 : return 0;
2124 : }
2125 :
2126 2922668 : 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 2922668 : int nlen, rlen;
2134 :
2135 2922668 : nlen = ext4_dir_rec_len(de->name_len, dir);
2136 2922668 : rlen = ext4_rec_len_from_disk(de->rec_len, buf_size);
2137 2922668 : if (de->inode) {
2138 2922550 : struct ext4_dir_entry_2 *de1 =
2139 2922550 : (struct ext4_dir_entry_2 *)((char *)de + nlen);
2140 2922550 : de1->rec_len = ext4_rec_len_to_disk(rlen - nlen, buf_size);
2141 2922550 : de->rec_len = ext4_rec_len_to_disk(nlen, buf_size);
2142 2922550 : de = de1;
2143 : }
2144 2922668 : de->file_type = EXT4_FT_UNKNOWN;
2145 2922668 : de->inode = cpu_to_le32(inode->i_ino);
2146 2922668 : ext4_set_de_type(inode->i_sb, de, inode->i_mode);
2147 2922585 : de->name_len = fname_len(fname);
2148 5845170 : memcpy(de->name, fname_name(fname), fname_len(fname));
2149 2922585 : 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 2922585 : }
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 2946943 : 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 2946943 : unsigned int blocksize = dir->i_sb->s_blocksize;
2172 2946943 : int csum_size = 0;
2173 2946943 : int err, err2;
2174 :
2175 2946943 : if (ext4_has_metadata_csum(inode->i_sb))
2176 2945224 : csum_size = sizeof(struct ext4_dir_entry_tail);
2177 :
2178 2944086 : if (!de) {
2179 2917082 : err = ext4_find_dest_de(dir, inode, bh, bh->b_data,
2180 2917082 : blocksize - csum_size, fname, &de);
2181 2922714 : if (err)
2182 : return err;
2183 : }
2184 2920438 : BUFFER_TRACE(bh, "get_write_access");
2185 2920438 : err = ext4_journal_get_write_access(handle, dir->i_sb, bh,
2186 : EXT4_JTR_NONE);
2187 2922810 : 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 2922810 : 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 2921758 : dir->i_mtime = dir->i_ctime = current_time(dir);
2207 2921872 : ext4_update_dx_flag(dir);
2208 2921840 : inode_inc_iversion(dir);
2209 2922496 : err2 = ext4_mark_inode_dirty(handle, dir);
2210 2922860 : BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
2211 2922860 : err = ext4_handle_dirty_dirblock(handle, dir, bh);
2212 2921875 : if (err)
2213 0 : ext4_std_error(dir->i_sb, err);
2214 2921875 : 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 1284 : 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 1284 : struct buffer_head *bh2;
2226 1284 : struct dx_root *root;
2227 1284 : struct dx_frame frames[EXT4_HTREE_LEVEL], *frame;
2228 1284 : struct dx_entry *entries;
2229 1284 : struct ext4_dir_entry_2 *de, *de2;
2230 1284 : char *data2, *top;
2231 1284 : unsigned len;
2232 1284 : int retval;
2233 1284 : unsigned blocksize;
2234 1284 : ext4_lblk_t block;
2235 1284 : struct fake_dirent *fde;
2236 1284 : int csum_size = 0;
2237 :
2238 1284 : if (ext4_has_metadata_csum(inode->i_sb))
2239 1284 : csum_size = sizeof(struct ext4_dir_entry_tail);
2240 :
2241 1284 : blocksize = dir->i_sb->s_blocksize;
2242 1284 : dxtrace(printk(KERN_DEBUG "Creating index: inode %lu\n", dir->i_ino));
2243 1284 : BUFFER_TRACE(bh, "get_write_access");
2244 1284 : retval = ext4_journal_get_write_access(handle, dir->i_sb, bh,
2245 : EXT4_JTR_NONE);
2246 1284 : if (retval) {
2247 0 : ext4_std_error(dir->i_sb, retval);
2248 0 : brelse(bh);
2249 0 : return retval;
2250 : }
2251 1284 : root = (struct dx_root *) bh->b_data;
2252 :
2253 : /* The 0th block becomes the root, move the dirents out */
2254 1284 : fde = &root->dotdot;
2255 1284 : de = (struct ext4_dir_entry_2 *)((char *)fde +
2256 1284 : ext4_rec_len_from_disk(fde->rec_len, blocksize));
2257 1284 : 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 1284 : len = ((char *) root) + (blocksize - csum_size) - (char *) de;
2263 :
2264 : /* Allocate new block for the 0th block's dirents */
2265 1284 : bh2 = ext4_append(handle, dir, &block);
2266 1283 : if (IS_ERR(bh2)) {
2267 4 : brelse(bh);
2268 4 : return PTR_ERR(bh2);
2269 : }
2270 1279 : ext4_set_inode_flag(dir, EXT4_INODE_INDEX);
2271 1280 : data2 = bh2->b_data;
2272 :
2273 2560 : memcpy(data2, de, len);
2274 1280 : memset(de, 0, len); /* wipe old data */
2275 1280 : de = (struct ext4_dir_entry_2 *) data2;
2276 1280 : top = data2 + len;
2277 315260 : while ((char *)(de2 = ext4_next_entry(de, blocksize)) < top) {
2278 313980 : 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 1280 : de->rec_len = ext4_rec_len_to_disk(data2 + (blocksize - csum_size) -
2288 : (char *) de, blocksize);
2289 :
2290 1280 : if (csum_size)
2291 1280 : ext4_initialize_dirent_tail(bh2, blocksize);
2292 :
2293 : /* Initialize the root; the dot dirents already exist */
2294 1280 : de = (struct ext4_dir_entry_2 *) (&root->dotdot);
2295 1280 : de->rec_len = ext4_rec_len_to_disk(
2296 : blocksize - ext4_dir_rec_len(2, NULL), blocksize);
2297 1280 : memset (&root->info, 0, sizeof(root->info));
2298 1280 : root->info.info_length = sizeof(root->info);
2299 1280 : if (ext4_hash_in_dirent(dir))
2300 0 : root->info.hash_version = DX_HASH_SIPHASH;
2301 : else
2302 1280 : root->info.hash_version =
2303 1280 : EXT4_SB(dir->i_sb)->s_def_hash_version;
2304 :
2305 1280 : entries = root->entries;
2306 1280 : dx_set_block(entries, 1);
2307 1280 : dx_set_count(entries, 1);
2308 1280 : dx_set_limit(entries, dx_root_limit(dir, sizeof(root->info)));
2309 :
2310 : /* Initialize as for dx_probe */
2311 1280 : fname->hinfo.hash_version = root->info.hash_version;
2312 1280 : if (fname->hinfo.hash_version <= DX_HASH_TEA)
2313 1280 : fname->hinfo.hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
2314 1280 : fname->hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
2315 :
2316 : /* casefolded encrypted hashes are computed on fname setup */
2317 1280 : if (!ext4_hash_in_dirent(dir)) {
2318 1280 : int err = ext4fs_dirhash(dir, fname_name(fname),
2319 1280 : fname_len(fname), &fname->hinfo);
2320 1280 : if (err < 0) {
2321 0 : brelse(bh2);
2322 0 : brelse(bh);
2323 0 : return err;
2324 : }
2325 : }
2326 1280 : memset(frames, 0, sizeof(frames));
2327 1280 : frame = frames;
2328 1280 : frame->entries = entries;
2329 1280 : frame->at = entries;
2330 1280 : frame->bh = bh;
2331 :
2332 1280 : retval = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
2333 1280 : if (retval)
2334 0 : goto out_frames;
2335 1280 : retval = ext4_handle_dirty_dirblock(handle, dir, bh2);
2336 1280 : if (retval)
2337 0 : goto out_frames;
2338 :
2339 1280 : de = do_split(handle,dir, &bh2, frame, &fname->hinfo);
2340 1280 : if (IS_ERR(de)) {
2341 0 : retval = PTR_ERR(de);
2342 0 : goto out_frames;
2343 : }
2344 :
2345 1280 : retval = add_dirent_to_buf(handle, fname, dir, inode, de, bh2);
2346 1280 : 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 1280 : if (retval)
2353 0 : ext4_mark_inode_dirty(handle, dir);
2354 1280 : dx_release(frames);
2355 1280 : 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 2920153 : static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
2370 : struct inode *inode)
2371 : {
2372 2920153 : struct inode *dir = d_inode(dentry->d_parent);
2373 2920153 : struct buffer_head *bh = NULL;
2374 2920153 : struct ext4_dir_entry_2 *de;
2375 2920153 : struct super_block *sb;
2376 2920153 : struct ext4_filename fname;
2377 2920153 : int retval;
2378 2920153 : int dx_fallback=0;
2379 2920153 : unsigned blocksize;
2380 2920153 : ext4_lblk_t block, blocks;
2381 2920153 : int csum_size = 0;
2382 :
2383 2920153 : if (ext4_has_metadata_csum(inode->i_sb))
2384 2916302 : csum_size = sizeof(struct ext4_dir_entry_tail);
2385 :
2386 2917491 : sb = dir->i_sb;
2387 2917491 : blocksize = sb->s_blocksize;
2388 2917491 : if (!dentry->d_name.len)
2389 : return -EINVAL;
2390 :
2391 2917491 : 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 2917491 : retval = ext4_fname_setup_filename(dir, &dentry->d_name, 0, &fname);
2401 2917491 : if (retval)
2402 : return retval;
2403 :
2404 2917491 : 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 2917491 : if (is_dx(dir)) {
2415 1788406 : retval = ext4_dx_add_entry(handle, &fname, dir, inode);
2416 1790786 : if (!retval || (retval != ERR_BAD_DX_DIR))
2417 1790786 : 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 1129085 : blocks = dir->i_size >> sb->s_blocksize_bits;
2432 1129085 : for (block = 0; block < blocks; block++) {
2433 1129085 : bh = ext4_read_dirblock(dir, block, DIRENT);
2434 1128515 : 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 1128515 : if (IS_ERR(bh)) {
2440 0 : retval = PTR_ERR(bh);
2441 0 : bh = NULL;
2442 0 : goto out;
2443 : }
2444 1128515 : retval = add_dirent_to_buf(handle, &fname, dir, inode,
2445 : NULL, bh);
2446 1131088 : if (retval != -ENOSPC)
2447 1129804 : goto out;
2448 :
2449 1284 : if (blocks == 1 && !dx_fallback &&
2450 : ext4_has_feature_dir_index(sb)) {
2451 1284 : retval = make_indexed_dir(handle, &fname, dir,
2452 : inode, bh);
2453 1284 : bh = NULL; /* make_indexed_dir releases bh */
2454 1284 : 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 1129701 : out:
2474 2921771 : ext4_fname_free_filename(&fname);
2475 2921771 : brelse(bh);
2476 2922549 : if (retval == 0)
2477 2922150 : 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 1789154 : static int ext4_dx_add_entry(handle_t *handle, struct ext4_filename *fname,
2485 : struct inode *dir, struct inode *inode)
2486 : {
2487 1789154 : struct dx_frame frames[EXT4_HTREE_LEVEL], *frame;
2488 1789154 : struct dx_entry *entries, *at;
2489 1789154 : struct buffer_head *bh;
2490 1789154 : struct super_block *sb = dir->i_sb;
2491 1789159 : struct ext4_dir_entry_2 *de;
2492 1789159 : int restart;
2493 1789159 : int err;
2494 :
2495 1789159 : again:
2496 1789159 : restart = 0;
2497 1789159 : frame = dx_probe(fname, dir, NULL, frames);
2498 1787333 : if (IS_ERR(frame))
2499 0 : return PTR_ERR(frame);
2500 1787333 : entries = frame->entries;
2501 1787333 : at = frame->at;
2502 1787333 : bh = ext4_read_dirblock(dir, dx_get_block(frame->at), DIRENT_HTREE);
2503 1790771 : if (IS_ERR(bh)) {
2504 0 : err = PTR_ERR(bh);
2505 0 : bh = NULL;
2506 0 : goto cleanup;
2507 : }
2508 :
2509 1790771 : BUFFER_TRACE(bh, "get_write_access");
2510 1790771 : err = ext4_journal_get_write_access(handle, sb, bh, EXT4_JTR_NONE);
2511 1790728 : if (err)
2512 0 : goto journal_error;
2513 :
2514 1790728 : err = add_dirent_to_buf(handle, fname, dir, inode, NULL, bh);
2515 1790839 : if (err != -ENOSPC)
2516 1762843 : goto cleanup;
2517 :
2518 27996 : 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 27996 : dx_get_count(entries), dx_get_limit(entries)));
2522 : /* Need to split index? */
2523 27996 : if (dx_get_count(entries) == dx_get_limit(entries)) {
2524 202 : ext4_lblk_t newblock;
2525 202 : int levels = frame - frames + 1;
2526 202 : unsigned int icount;
2527 202 : int add_level = 1;
2528 202 : struct dx_entry *entries2;
2529 202 : struct dx_node *node2;
2530 202 : struct buffer_head *bh2;
2531 :
2532 204 : while (frame > frames) {
2533 200 : 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 206 : 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 202 : icount = dx_get_count(entries);
2556 202 : bh2 = ext4_append(handle, dir, &newblock);
2557 202 : if (IS_ERR(bh2)) {
2558 0 : err = PTR_ERR(bh2);
2559 0 : goto cleanup;
2560 : }
2561 202 : node2 = (struct dx_node *)(bh2->b_data);
2562 202 : entries2 = node2->entries;
2563 202 : memset(&node2->fake, 0, sizeof(struct fake_dirent));
2564 404 : node2->fake.rec_len = ext4_rec_len_to_disk(sb->s_blocksize,
2565 202 : sb->s_blocksize);
2566 202 : BUFFER_TRACE(frame->bh, "get_write_access");
2567 202 : err = ext4_journal_get_write_access(handle, sb, frame->bh,
2568 : EXT4_JTR_NONE);
2569 202 : if (err)
2570 5 : goto journal_error;
2571 202 : if (!add_level) {
2572 198 : unsigned icount1 = icount/2, icount2 = icount - icount1;
2573 198 : unsigned hash2 = dx_get_hash(entries + icount1);
2574 : dxtrace(printk(KERN_DEBUG "Split index %i/%i\n",
2575 198 : icount1, icount2));
2576 :
2577 198 : BUFFER_TRACE(frame->bh, "get_write_access"); /* index root */
2578 198 : err = ext4_journal_get_write_access(handle, sb,
2579 : (frame - 1)->bh,
2580 : EXT4_JTR_NONE);
2581 198 : if (err)
2582 0 : goto journal_error;
2583 :
2584 396 : memcpy((char *) entries2, (char *) (entries + icount1),
2585 : icount2 * sizeof(struct dx_entry));
2586 198 : dx_set_count(entries, icount1);
2587 198 : dx_set_count(entries2, icount2);
2588 198 : dx_set_limit(entries2, dx_node_limit(dir));
2589 :
2590 : /* Which index block gets the new entry? */
2591 198 : if (at - entries >= icount1) {
2592 104 : frame->at = at - entries - icount1 + entries2;
2593 104 : frame->entries = entries = entries2;
2594 104 : swap(frame->bh, bh2);
2595 : }
2596 198 : dx_insert_block((frame - 1), hash2, newblock);
2597 198 : dxtrace(dx_show_index("node", frame->entries));
2598 : dxtrace(dx_show_index("node",
2599 198 : ((struct dx_node *) bh2->b_data)->entries));
2600 198 : err = ext4_handle_dirty_dx_node(handle, dir, bh2);
2601 198 : if (err)
2602 0 : goto journal_error;
2603 198 : brelse (bh2);
2604 198 : err = ext4_handle_dirty_dx_node(handle, dir,
2605 : (frame - 1)->bh);
2606 198 : if (err)
2607 0 : goto journal_error;
2608 198 : err = ext4_handle_dirty_dx_node(handle, dir,
2609 : frame->bh);
2610 198 : 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 27991 : de = do_split(handle, dir, &bh, frame, &fname->hinfo);
2636 27991 : if (IS_ERR(de)) {
2637 239 : err = PTR_ERR(de);
2638 239 : goto cleanup;
2639 : }
2640 27752 : err = add_dirent_to_buf(handle, fname, dir, inode, de, bh);
2641 27752 : 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 1790839 : brelse(bh);
2647 1791397 : 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 1790805 : 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 2089070 : 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 2089070 : struct ext4_dir_entry_2 *de, *pde;
2668 2089070 : unsigned int blocksize = dir->i_sb->s_blocksize;
2669 2089070 : int i;
2670 :
2671 2089070 : i = 0;
2672 2089070 : pde = NULL;
2673 2089070 : de = entry_buf;
2674 64739641 : while (i < buf_size - csum_size) {
2675 64739641 : if (ext4_check_dir_entry(dir, NULL, de, bh,
2676 : entry_buf, buf_size, i))
2677 : return -EFSCORRUPTED;
2678 64740474 : if (de == de_del) {
2679 2089903 : if (pde) {
2680 4153356 : pde->rec_len = ext4_rec_len_to_disk(
2681 2076678 : ext4_rec_len_from_disk(pde->rec_len,
2682 : blocksize) +
2683 2076678 : ext4_rec_len_from_disk(de->rec_len,
2684 : blocksize),
2685 : blocksize);
2686 :
2687 : /* wipe entire dir_entry */
2688 4153356 : 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 13225 : de->inode = 0;
2693 26450 : 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 2089903 : inode_inc_iversion(dir);
2701 2089903 : return 0;
2702 : }
2703 62650571 : i += ext4_rec_len_from_disk(de->rec_len, blocksize);
2704 62650571 : pde = de;
2705 62650571 : de = ext4_next_entry(de, blocksize);
2706 : }
2707 : return -ENOENT;
2708 : }
2709 :
2710 2089666 : 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 2089666 : int err, csum_size = 0;
2716 :
2717 2089666 : 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 2089666 : if (ext4_has_metadata_csum(dir->i_sb))
2726 2088696 : csum_size = sizeof(struct ext4_dir_entry_tail);
2727 :
2728 2088627 : BUFFER_TRACE(bh, "get_write_access");
2729 2088627 : err = ext4_journal_get_write_access(handle, dir->i_sb, bh,
2730 : EXT4_JTR_NONE);
2731 2089407 : if (unlikely(err))
2732 0 : goto out;
2733 :
2734 2089407 : err = ext4_generic_delete_entry(dir, de_del, bh, bh->b_data,
2735 2089407 : dir->i_sb->s_blocksize, csum_size);
2736 2090175 : if (err)
2737 0 : goto out;
2738 :
2739 2090175 : BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
2740 2090175 : err = ext4_handle_dirty_dirblock(handle, dir, bh);
2741 2089426 : 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 548652 : static void ext4_inc_count(struct inode *inode)
2763 : {
2764 548652 : inc_nlink(inode);
2765 548580 : if (is_dx(inode) &&
2766 245484 : (inode->i_nlink > EXT4_LINK_MAX || inode->i_nlink == 2))
2767 36080 : set_nlink(inode, 1);
2768 548580 : }
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 354695 : static void ext4_dec_count(struct inode *inode)
2775 : {
2776 354695 : if (!S_ISDIR(inode->i_mode) || inode->i_nlink > 2)
2777 223399 : drop_nlink(inode);
2778 354681 : }
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 1919604 : static int ext4_add_nondir(handle_t *handle,
2788 : struct dentry *dentry, struct inode **inodep)
2789 : {
2790 1919604 : struct inode *dir = d_inode(dentry->d_parent);
2791 1919604 : struct inode *inode = *inodep;
2792 1919604 : int err = ext4_add_entry(handle, dentry, inode);
2793 1922370 : if (!err) {
2794 1922369 : err = ext4_mark_inode_dirty(handle, inode);
2795 1922689 : if (IS_DIRSYNC(dir))
2796 0 : ext4_handle_sync(handle);
2797 1922689 : d_instantiate_new(dentry, inode);
2798 1921656 : *inodep = NULL;
2799 1921656 : return err;
2800 : }
2801 1 : drop_nlink(inode);
2802 1 : ext4_orphan_add(handle, inode);
2803 1 : unlock_new_inode(inode);
2804 1 : return err;
2805 : }
2806 :
2807 : /*
2808 : * By the time this is called, we already have created
2809 : * the directory cache entry for the new file, but it
2810 : * is so far negative - it has no inode.
2811 : *
2812 : * If the create succeeds, we fill in the inode information
2813 : * with d_instantiate().
2814 : */
2815 1691469 : static int ext4_create(struct mnt_idmap *idmap, struct inode *dir,
2816 : struct dentry *dentry, umode_t mode, bool excl)
2817 : {
2818 1691469 : handle_t *handle;
2819 1691469 : struct inode *inode;
2820 1691469 : int err, credits, retries = 0;
2821 :
2822 1691469 : err = dquot_initialize(dir);
2823 1688665 : if (err)
2824 : return err;
2825 :
2826 1688760 : credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2827 1688664 : EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
2828 1803630 : retry:
2829 1803630 : inode = ext4_new_inode_start_handle(idmap, dir, mode, &dentry->d_name,
2830 : 0, NULL, EXT4_HT_DIR, credits);
2831 1813828 : handle = ext4_journal_current_handle();
2832 1813828 : err = PTR_ERR(inode);
2833 1813828 : if (!IS_ERR(inode)) {
2834 1660069 : inode->i_op = &ext4_file_inode_operations;
2835 1660069 : inode->i_fop = &ext4_file_operations;
2836 1660069 : ext4_set_aops(inode);
2837 1658622 : err = ext4_add_nondir(handle, dentry, &inode);
2838 1659537 : if (!err)
2839 1659443 : ext4_fc_track_create(handle, dentry);
2840 : }
2841 1812305 : if (handle)
2842 1658815 : ext4_journal_stop(handle);
2843 1966484 : if (!IS_ERR_OR_NULL(inode))
2844 1 : iput(inode);
2845 1812724 : if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2846 114966 : goto retry;
2847 : return err;
2848 : }
2849 :
2850 134642 : static int ext4_mknod(struct mnt_idmap *idmap, struct inode *dir,
2851 : struct dentry *dentry, umode_t mode, dev_t rdev)
2852 : {
2853 134642 : handle_t *handle;
2854 134642 : struct inode *inode;
2855 134642 : int err, credits, retries = 0;
2856 :
2857 134642 : err = dquot_initialize(dir);
2858 134627 : if (err)
2859 : return err;
2860 :
2861 134672 : credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
2862 134627 : EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
2863 134627 : retry:
2864 134627 : inode = ext4_new_inode_start_handle(idmap, dir, mode, &dentry->d_name,
2865 : 0, NULL, EXT4_HT_DIR, credits);
2866 134677 : handle = ext4_journal_current_handle();
2867 134677 : err = PTR_ERR(inode);
2868 134677 : if (!IS_ERR(inode)) {
2869 134667 : init_special_inode(inode, inode->i_mode, rdev);
2870 134661 : inode->i_op = &ext4_special_inode_operations;
2871 134661 : err = ext4_add_nondir(handle, dentry, &inode);
2872 134654 : if (!err)
2873 134652 : ext4_fc_track_create(handle, dentry);
2874 : }
2875 134648 : if (handle)
2876 134634 : ext4_journal_stop(handle);
2877 134653 : if (!IS_ERR_OR_NULL(inode))
2878 0 : iput(inode);
2879 134643 : if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2880 0 : goto retry;
2881 : return err;
2882 : }
2883 :
2884 430767 : static int ext4_tmpfile(struct mnt_idmap *idmap, struct inode *dir,
2885 : struct file *file, umode_t mode)
2886 : {
2887 430767 : handle_t *handle;
2888 430767 : struct inode *inode;
2889 430767 : int err, retries = 0;
2890 :
2891 430767 : err = dquot_initialize(dir);
2892 429610 : if (err)
2893 : return err;
2894 :
2895 429610 : retry:
2896 429610 : 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 448230 : handle = ext4_journal_current_handle();
2902 448230 : err = PTR_ERR(inode);
2903 448230 : if (!IS_ERR(inode)) {
2904 448230 : inode->i_op = &ext4_file_inode_operations;
2905 448230 : inode->i_fop = &ext4_file_operations;
2906 448230 : ext4_set_aops(inode);
2907 446830 : d_tmpfile(file, inode);
2908 435121 : err = ext4_orphan_add(handle, inode);
2909 453969 : if (err)
2910 0 : goto err_unlock_inode;
2911 453969 : mark_inode_dirty(inode);
2912 452312 : unlock_new_inode(inode);
2913 : }
2914 452083 : if (handle)
2915 452083 : ext4_journal_stop(handle);
2916 449967 : if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2917 0 : goto retry;
2918 449967 : 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 345633 : 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 345633 : de->inode = cpu_to_le32(inode->i_ino);
2931 345633 : de->name_len = 1;
2932 345633 : de->rec_len = ext4_rec_len_to_disk(ext4_dir_rec_len(de->name_len, NULL),
2933 : blocksize);
2934 345633 : strcpy(de->name, ".");
2935 345633 : ext4_set_de_type(inode->i_sb, de, S_IFDIR);
2936 :
2937 345633 : de = ext4_next_entry(de, blocksize);
2938 345633 : de->inode = cpu_to_le32(parent_ino);
2939 345633 : de->name_len = 2;
2940 345633 : if (!dotdot_real_len)
2941 345633 : de->rec_len = ext4_rec_len_to_disk(blocksize -
2942 345633 : (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 345633 : strcpy(de->name, "..");
2949 345633 : ext4_set_de_type(inode->i_sb, de, S_IFDIR);
2950 :
2951 345633 : return ext4_next_entry(de, blocksize);
2952 : }
2953 :
2954 358776 : int ext4_init_new_dir(handle_t *handle, struct inode *dir,
2955 : struct inode *inode)
2956 : {
2957 358776 : struct buffer_head *dir_block = NULL;
2958 358776 : struct ext4_dir_entry_2 *de;
2959 358776 : ext4_lblk_t block = 0;
2960 358776 : unsigned int blocksize = dir->i_sb->s_blocksize;
2961 358776 : int csum_size = 0;
2962 358776 : int err;
2963 :
2964 358776 : if (ext4_has_metadata_csum(dir->i_sb))
2965 358606 : csum_size = sizeof(struct ext4_dir_entry_tail);
2966 :
2967 358738 : 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 358738 : inode->i_size = 0;
2976 358738 : dir_block = ext4_append(handle, inode, &block);
2977 358724 : if (IS_ERR(dir_block))
2978 12896 : return PTR_ERR(dir_block);
2979 345828 : de = (struct ext4_dir_entry_2 *)dir_block->b_data;
2980 345828 : ext4_init_dot_dotdot(inode, de, blocksize, csum_size, dir->i_ino, 0);
2981 345599 : set_nlink(inode, 2);
2982 345450 : if (csum_size)
2983 345347 : ext4_initialize_dirent_tail(dir_block, blocksize);
2984 :
2985 345276 : BUFFER_TRACE(dir_block, "call ext4_handle_dirty_metadata");
2986 345276 : err = ext4_handle_dirty_dirblock(handle, inode, dir_block);
2987 345667 : if (err)
2988 0 : goto out;
2989 345667 : set_buffer_verified(dir_block);
2990 345824 : out:
2991 345824 : brelse(dir_block);
2992 : return err;
2993 : }
2994 :
2995 351871 : static int ext4_mkdir(struct mnt_idmap *idmap, struct inode *dir,
2996 : struct dentry *dentry, umode_t mode)
2997 : {
2998 351871 : handle_t *handle;
2999 351871 : struct inode *inode;
3000 351871 : int err, err2 = 0, credits, retries = 0;
3001 :
3002 351871 : if (EXT4_DIR_LINK_MAX(dir))
3003 : return -EMLINK;
3004 :
3005 351871 : err = dquot_initialize(dir);
3006 351852 : if (err)
3007 : return err;
3008 :
3009 351927 : credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
3010 351852 : EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
3011 359309 : retry:
3012 359309 : inode = ext4_new_inode_start_handle(idmap, dir, S_IFDIR | mode,
3013 : &dentry->d_name,
3014 : 0, NULL, EXT4_HT_DIR, credits);
3015 359373 : handle = ext4_journal_current_handle();
3016 359373 : err = PTR_ERR(inode);
3017 359373 : if (IS_ERR(inode))
3018 571 : goto out_stop;
3019 :
3020 358802 : inode->i_op = &ext4_dir_inode_operations;
3021 358802 : inode->i_fop = &ext4_dir_operations;
3022 358802 : err = ext4_init_new_dir(handle, dir, inode);
3023 358731 : if (err)
3024 12890 : goto out_clear_inode;
3025 345841 : err = ext4_mark_inode_dirty(handle, inode);
3026 345896 : if (!err)
3027 345894 : err = ext4_add_entry(handle, dentry, inode);
3028 345896 : if (err) {
3029 4 : out_clear_inode:
3030 12894 : clear_nlink(inode);
3031 12901 : ext4_orphan_add(handle, inode);
3032 12910 : unlock_new_inode(inode);
3033 12909 : err2 = ext4_mark_inode_dirty(handle, inode);
3034 12910 : if (unlikely(err2))
3035 0 : err = err2;
3036 12910 : ext4_journal_stop(handle);
3037 12908 : iput(inode);
3038 12875 : goto out_retry;
3039 : }
3040 345892 : ext4_inc_count(dir);
3041 :
3042 345810 : ext4_update_dx_flag(dir);
3043 345806 : err = ext4_mark_inode_dirty(handle, dir);
3044 345895 : if (err)
3045 0 : goto out_clear_inode;
3046 345895 : d_instantiate_new(dentry, inode);
3047 345812 : ext4_fc_track_create(handle, dentry);
3048 345752 : if (IS_DIRSYNC(dir))
3049 0 : ext4_handle_sync(handle);
3050 :
3051 345752 : out_stop:
3052 346323 : if (handle)
3053 346247 : ext4_journal_stop(handle);
3054 76 : out_retry:
3055 359232 : if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
3056 7457 : goto retry;
3057 : return err;
3058 : }
3059 :
3060 : /*
3061 : * routine to check that the specified directory is empty (for rmdir)
3062 : */
3063 227399 : bool ext4_empty_dir(struct inode *inode)
3064 : {
3065 227399 : unsigned int offset;
3066 227399 : struct buffer_head *bh;
3067 227399 : struct ext4_dir_entry_2 *de;
3068 227399 : struct super_block *sb;
3069 :
3070 227399 : 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 227399 : sb = inode->i_sb;
3080 227399 : 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 227399 : bh = ext4_read_dirblock(inode, 0, DIRENT_HTREE);
3089 227411 : if (IS_ERR(bh))
3090 : return false;
3091 :
3092 227411 : de = (struct ext4_dir_entry_2 *) bh->b_data;
3093 227411 : if (ext4_check_dir_entry(inode, NULL, de, bh, bh->b_data, bh->b_size,
3094 227413 : 0) ||
3095 227413 : le32_to_cpu(de->inode) != inode->i_ino || strcmp(".", de->name)) {
3096 5 : ext4_warning_inode(inode, "directory missing '.'");
3097 0 : brelse(bh);
3098 0 : return false;
3099 : }
3100 227408 : offset = ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize);
3101 227408 : de = ext4_next_entry(de, sb->s_blocksize);
3102 227408 : if (ext4_check_dir_entry(inode, NULL, de, bh, bh->b_data, bh->b_size,
3103 227405 : offset) ||
3104 227405 : 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 227405 : offset += ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize);
3110 425179 : while (offset < inode->i_size) {
3111 239520 : if (!(offset & (sb->s_blocksize - 1))) {
3112 6527 : unsigned int lblock;
3113 6527 : brelse(bh);
3114 6527 : lblock = offset >> EXT4_BLOCK_SIZE_BITS(sb);
3115 6527 : bh = ext4_read_dirblock(inode, lblock, EITHER);
3116 6527 : if (bh == NULL) {
3117 0 : offset += sb->s_blocksize;
3118 0 : continue;
3119 : }
3120 6527 : if (IS_ERR(bh))
3121 : return false;
3122 : }
3123 239520 : de = (struct ext4_dir_entry_2 *) (bh->b_data +
3124 239520 : (offset & (sb->s_blocksize - 1)));
3125 239520 : if (ext4_check_dir_entry(inode, NULL, de, bh,
3126 239527 : bh->b_data, bh->b_size, offset) ||
3127 239527 : le32_to_cpu(de->inode)) {
3128 41752 : brelse(bh);
3129 41754 : return false;
3130 : }
3131 197774 : offset += ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize);
3132 : }
3133 185659 : brelse(bh);
3134 : return true;
3135 : }
3136 :
3137 227172 : static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
3138 : {
3139 227172 : int retval;
3140 227172 : struct inode *inode;
3141 227172 : struct buffer_head *bh;
3142 227172 : struct ext4_dir_entry_2 *de;
3143 227172 : handle_t *handle = NULL;
3144 :
3145 454344 : 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 227167 : retval = dquot_initialize(dir);
3151 227171 : if (retval)
3152 : return retval;
3153 227165 : retval = dquot_initialize(d_inode(dentry));
3154 227162 : if (retval)
3155 : return retval;
3156 :
3157 227159 : retval = -ENOENT;
3158 227159 : bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
3159 227173 : if (IS_ERR(bh))
3160 0 : return PTR_ERR(bh);
3161 227173 : if (!bh)
3162 0 : goto end_rmdir;
3163 :
3164 227173 : inode = d_inode(dentry);
3165 :
3166 227173 : retval = -EFSCORRUPTED;
3167 227173 : if (le32_to_cpu(de->inode) != inode->i_ino)
3168 0 : goto end_rmdir;
3169 :
3170 227173 : retval = -ENOTEMPTY;
3171 227173 : if (!ext4_empty_dir(inode))
3172 41739 : goto end_rmdir;
3173 :
3174 370091 : handle = ext4_journal_start(dir, EXT4_HT_DIR,
3175 : EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
3176 185437 : if (IS_ERR(handle)) {
3177 0 : retval = PTR_ERR(handle);
3178 0 : handle = NULL;
3179 0 : goto end_rmdir;
3180 : }
3181 :
3182 185437 : if (IS_DIRSYNC(dir))
3183 0 : ext4_handle_sync(handle);
3184 :
3185 185437 : retval = ext4_delete_entry(handle, dir, de, bh);
3186 185440 : if (retval)
3187 0 : goto end_rmdir;
3188 185440 : 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 185440 : inode_inc_iversion(inode);
3194 185444 : 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 185444 : inode->i_size = 0;
3199 185444 : ext4_orphan_add(handle, inode);
3200 185444 : inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode);
3201 185443 : retval = ext4_mark_inode_dirty(handle, inode);
3202 185443 : if (retval)
3203 0 : goto end_rmdir;
3204 185443 : ext4_dec_count(dir);
3205 185441 : ext4_update_dx_flag(dir);
3206 185442 : ext4_fc_track_unlink(handle, dentry);
3207 185440 : 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 227183 : end_rmdir:
3221 227183 : brelse(bh);
3222 227186 : if (handle)
3223 185443 : ext4_journal_stop(handle);
3224 : return retval;
3225 : }
3226 :
3227 1322209 : 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 1322209 : int retval = -ENOENT;
3232 1322209 : struct buffer_head *bh;
3233 1322209 : struct ext4_dir_entry_2 *de;
3234 1322209 : handle_t *handle;
3235 1322209 : 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 1322209 : bh = ext4_find_entry(dir, d_name, &de, NULL);
3242 1322947 : if (IS_ERR(bh))
3243 0 : return PTR_ERR(bh);
3244 :
3245 1322947 : if (!bh)
3246 : return -ENOENT;
3247 :
3248 1322947 : 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 2638187 : handle = ext4_journal_start(dir, EXT4_HT_DIR,
3261 : EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
3262 1322269 : if (IS_ERR(handle)) {
3263 0 : retval = PTR_ERR(handle);
3264 0 : goto out_bh;
3265 : }
3266 :
3267 1322269 : if (IS_DIRSYNC(dir))
3268 0 : ext4_handle_sync(handle);
3269 :
3270 1322269 : if (!skip_remove_dentry) {
3271 1322389 : retval = ext4_delete_entry(handle, dir, de, bh);
3272 1322375 : if (retval)
3273 0 : goto out_handle;
3274 1322375 : dir->i_ctime = dir->i_mtime = current_time(dir);
3275 1322210 : ext4_update_dx_flag(dir);
3276 1322542 : retval = ext4_mark_inode_dirty(handle, dir);
3277 1323086 : if (retval)
3278 0 : goto out_handle;
3279 : } else {
3280 : retval = 0;
3281 : }
3282 1322966 : 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 1322966 : drop_nlink(inode);
3287 1323055 : if (!inode->i_nlink)
3288 1262720 : ext4_orphan_add(handle, inode);
3289 1323219 : inode->i_ctime = current_time(inode);
3290 1323226 : retval = ext4_mark_inode_dirty(handle, inode);
3291 1323227 : if (dentry && !retval)
3292 1323227 : ext4_fc_track_unlink(handle, dentry);
3293 0 : out_handle:
3294 1323199 : ext4_journal_stop(handle);
3295 1322898 : out_bh:
3296 1322898 : brelse(bh);
3297 1322898 : return retval;
3298 : }
3299 :
3300 1322293 : static int ext4_unlink(struct inode *dir, struct dentry *dentry)
3301 : {
3302 1322293 : int retval;
3303 :
3304 2644586 : if (unlikely(ext4_forced_shutdown(EXT4_SB(dir->i_sb))))
3305 : return -EIO;
3306 :
3307 1322284 : trace_ext4_unlink_enter(dir, dentry);
3308 : /*
3309 : * Initialize quotas before so that eventual writes go
3310 : * in separate transaction
3311 : */
3312 1322297 : retval = dquot_initialize(dir);
3313 1322251 : if (retval)
3314 0 : goto out_trace;
3315 1322251 : retval = dquot_initialize(d_inode(dentry));
3316 1322514 : if (retval)
3317 0 : goto out_trace;
3318 :
3319 1322514 : 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 1323133 : out_trace:
3332 1323133 : trace_ext4_unlink_exit(dentry, retval);
3333 1323133 : return retval;
3334 : }
3335 :
3336 35715 : static int ext4_init_symlink_block(handle_t *handle, struct inode *inode,
3337 : struct fscrypt_str *disk_link)
3338 : {
3339 35715 : struct buffer_head *bh;
3340 35715 : char *kaddr;
3341 35715 : int err = 0;
3342 :
3343 35715 : bh = ext4_bread(handle, inode, 0, EXT4_GET_BLOCKS_CREATE);
3344 35720 : if (IS_ERR(bh))
3345 12572 : return PTR_ERR(bh);
3346 :
3347 23148 : BUFFER_TRACE(bh, "get_write_access");
3348 23148 : err = ext4_journal_get_write_access(handle, inode->i_sb, bh, EXT4_JTR_NONE);
3349 23145 : if (err)
3350 0 : goto out;
3351 :
3352 23145 : kaddr = (char *)bh->b_data;
3353 46290 : memcpy(kaddr, disk_link->name, disk_link->len);
3354 23145 : inode->i_size = disk_link->len - 1;
3355 23145 : EXT4_I(inode)->i_disksize = inode->i_size;
3356 23145 : err = ext4_handle_dirty_metadata(handle, inode, bh);
3357 23143 : out:
3358 23143 : brelse(bh);
3359 : return err;
3360 : }
3361 :
3362 132822 : static int ext4_symlink(struct mnt_idmap *idmap, struct inode *dir,
3363 : struct dentry *dentry, const char *symname)
3364 : {
3365 132822 : handle_t *handle;
3366 132822 : struct inode *inode;
3367 132822 : int err, len = strlen(symname);
3368 132822 : int credits;
3369 132822 : struct fscrypt_str disk_link;
3370 132822 : int retries = 0;
3371 :
3372 265644 : if (unlikely(ext4_forced_shutdown(EXT4_SB(dir->i_sb))))
3373 : return -EIO;
3374 :
3375 132808 : err = fscrypt_prepare_symlink(dir, symname, len, dir->i_sb->s_blocksize,
3376 : &disk_link);
3377 132808 : if (err)
3378 0 : return err;
3379 :
3380 132808 : err = dquot_initialize(dir);
3381 132792 : 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 132831 : credits = EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
3391 132792 : EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3;
3392 140142 : retry:
3393 140142 : inode = ext4_new_inode_start_handle(idmap, dir, S_IFLNK|S_IRWXUGO,
3394 : &dentry->d_name, 0, NULL,
3395 : EXT4_HT_DIR, credits);
3396 140165 : handle = ext4_journal_current_handle();
3397 140165 : if (IS_ERR(inode)) {
3398 524 : if (handle)
3399 524 : ext4_journal_stop(handle);
3400 524 : err = PTR_ERR(inode);
3401 524 : goto out_retry;
3402 : }
3403 :
3404 139641 : 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 139641 : if ((disk_link.len > EXT4_N_BLOCKS * 4)) {
3411 35718 : inode->i_op = &ext4_symlink_inode_operations;
3412 : } else {
3413 103923 : inode->i_op = &ext4_fast_symlink_inode_operations;
3414 103923 : inode->i_link = (char *)&EXT4_I(inode)->i_data;
3415 : }
3416 : }
3417 :
3418 139641 : if ((disk_link.len > EXT4_N_BLOCKS * 4)) {
3419 : /* alloc symlink block and fill it */
3420 35719 : err = ext4_init_symlink_block(handle, inode, &disk_link);
3421 35714 : if (err)
3422 12566 : goto err_drop_inode;
3423 : } else {
3424 : /* clear the extent format for fast symlink */
3425 103922 : ext4_clear_inode_flag(inode, EXT4_INODE_EXTENTS);
3426 103923 : memcpy((char *)&EXT4_I(inode)->i_data, disk_link.name,
3427 : disk_link.len);
3428 103923 : inode->i_size = disk_link.len - 1;
3429 103923 : EXT4_I(inode)->i_disksize = inode->i_size;
3430 : }
3431 127071 : err = ext4_add_nondir(handle, dentry, &inode);
3432 127061 : if (handle)
3433 127061 : ext4_journal_stop(handle);
3434 127066 : iput(inode);
3435 127051 : goto out_retry;
3436 :
3437 12566 : err_drop_inode:
3438 12566 : clear_nlink(inode);
3439 12572 : ext4_orphan_add(handle, inode);
3440 12576 : unlock_new_inode(inode);
3441 12576 : if (handle)
3442 12576 : ext4_journal_stop(handle);
3443 12576 : iput(inode);
3444 140120 : out_retry:
3445 140120 : if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
3446 7350 : goto retry;
3447 132795 : if (disk_link.name != (unsigned char *)symname)
3448 0 : kfree(disk_link.name);
3449 : return err;
3450 : }
3451 :
3452 72533 : int __ext4_link(struct inode *dir, struct inode *inode, struct dentry *dentry)
3453 : {
3454 72533 : handle_t *handle;
3455 72533 : int err, retries = 0;
3456 72533 : retry:
3457 140511 : handle = ext4_journal_start(dir, EXT4_HT_DIR,
3458 : (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
3459 : EXT4_INDEX_EXTRA_TRANS_BLOCKS) + 1);
3460 72539 : if (IS_ERR(handle))
3461 10 : return PTR_ERR(handle);
3462 :
3463 72529 : if (IS_DIRSYNC(dir))
3464 0 : ext4_handle_sync(handle);
3465 :
3466 72529 : inode->i_ctime = current_time(inode);
3467 72517 : ext4_inc_count(inode);
3468 72523 : ihold(inode);
3469 :
3470 72529 : err = ext4_add_entry(handle, dentry, inode);
3471 72534 : if (!err) {
3472 72533 : err = ext4_mark_inode_dirty(handle, inode);
3473 : /* this can happen only for tmpfile being
3474 : * linked the first time
3475 : */
3476 72534 : if (inode->i_nlink == 1)
3477 2240 : ext4_orphan_del(handle, inode);
3478 72534 : d_instantiate(dentry, inode);
3479 72533 : ext4_fc_track_link(handle, dentry);
3480 : } else {
3481 1 : drop_nlink(inode);
3482 1 : iput(inode);
3483 : }
3484 72527 : ext4_journal_stop(handle);
3485 72528 : if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
3486 0 : goto retry;
3487 : return err;
3488 : }
3489 :
3490 72535 : static int ext4_link(struct dentry *old_dentry,
3491 : struct inode *dir, struct dentry *dentry)
3492 : {
3493 72535 : struct inode *inode = d_inode(old_dentry);
3494 72535 : int err;
3495 :
3496 72535 : if (inode->i_nlink >= EXT4_LINK_MAX)
3497 : return -EMLINK;
3498 :
3499 72535 : err = fscrypt_prepare_link(old_dentry, dir, dentry);
3500 72535 : if (err)
3501 : return err;
3502 :
3503 72535 : 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 72535 : err = dquot_initialize(dir);
3509 72533 : if (err)
3510 : return err;
3511 72530 : 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 136086 : 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 136086 : struct buffer_head *bh;
3526 :
3527 136086 : if (!ext4_has_inline_data(inode)) {
3528 136086 : struct ext4_dir_entry_2 *de;
3529 136086 : unsigned int offset;
3530 :
3531 : /* The first directory block must not be a hole, so
3532 : * treat it as DIRENT_HTREE
3533 : */
3534 136086 : bh = ext4_read_dirblock(inode, 0, DIRENT_HTREE);
3535 136086 : if (IS_ERR(bh)) {
3536 0 : *retval = PTR_ERR(bh);
3537 0 : return NULL;
3538 : }
3539 :
3540 136086 : de = (struct ext4_dir_entry_2 *) bh->b_data;
3541 136086 : if (ext4_check_dir_entry(inode, NULL, de, bh, bh->b_data,
3542 136086 : bh->b_size, 0) ||
3543 136086 : le32_to_cpu(de->inode) != inode->i_ino ||
3544 136086 : 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 136086 : offset = ext4_rec_len_from_disk(de->rec_len,
3551 : inode->i_sb->s_blocksize);
3552 136086 : de = ext4_next_entry(de, inode->i_sb->s_blocksize);
3553 136086 : if (ext4_check_dir_entry(inode, NULL, de, bh, bh->b_data,
3554 136087 : bh->b_size, offset) ||
3555 136087 : 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 136087 : *parent_de = de;
3562 :
3563 136087 : 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 136086 : static int ext4_rename_dir_prepare(handle_t *handle, struct ext4_renament *ent)
3589 : {
3590 136086 : int retval;
3591 :
3592 136086 : ent->dir_bh = ext4_get_first_dir_block(handle, ent->inode,
3593 : &retval, &ent->parent_de,
3594 : &ent->dir_inlined);
3595 136087 : if (!ent->dir_bh)
3596 0 : return retval;
3597 136087 : if (le32_to_cpu(ent->parent_de->inode) != ent->dir->i_ino)
3598 : return -EFSCORRUPTED;
3599 136087 : BUFFER_TRACE(ent->dir_bh, "get_write_access");
3600 136087 : return ext4_journal_get_write_access(handle, ent->dir->i_sb,
3601 : ent->dir_bh, EXT4_JTR_NONE);
3602 : }
3603 :
3604 136086 : static int ext4_rename_dir_finish(handle_t *handle, struct ext4_renament *ent,
3605 : unsigned dir_ino)
3606 : {
3607 136086 : int retval;
3608 :
3609 136086 : ent->parent_de->inode = cpu_to_le32(dir_ino);
3610 136086 : BUFFER_TRACE(ent->dir_bh, "call ext4_handle_dirty_metadata");
3611 136086 : if (!ent->dir_inlined) {
3612 136086 : if (is_dx(ent->inode)) {
3613 41666 : retval = ext4_handle_dirty_dx_node(handle,
3614 : ent->inode,
3615 : ent->dir_bh);
3616 : } else {
3617 94420 : 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 136087 : if (retval) {
3624 0 : ext4_std_error(ent->dir->i_sb, retval);
3625 0 : return retval;
3626 : }
3627 : return 0;
3628 : }
3629 :
3630 124659 : static int ext4_setent(handle_t *handle, struct ext4_renament *ent,
3631 : unsigned ino, unsigned file_type)
3632 : {
3633 124659 : int retval, retval2;
3634 :
3635 124659 : BUFFER_TRACE(ent->bh, "get write access");
3636 124659 : retval = ext4_journal_get_write_access(handle, ent->dir->i_sb, ent->bh,
3637 : EXT4_JTR_NONE);
3638 124671 : if (retval)
3639 : return retval;
3640 124671 : ent->de->inode = cpu_to_le32(ino);
3641 124671 : if (ext4_has_feature_filetype(ent->dir->i_sb))
3642 124671 : ent->de->file_type = file_type;
3643 124671 : inode_inc_iversion(ent->dir);
3644 249344 : ent->dir->i_ctime = ent->dir->i_mtime =
3645 124676 : current_time(ent->dir);
3646 124668 : retval = ext4_mark_inode_dirty(handle, ent->dir);
3647 124677 : BUFFER_TRACE(ent->bh, "call ext4_handle_dirty_metadata");
3648 124677 : if (!ent->inlined) {
3649 124677 : retval2 = ext4_handle_dirty_dirblock(handle, ent->dir, ent->bh);
3650 124663 : 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 240 : static void ext4_resetent(handle_t *handle, struct ext4_renament *ent,
3659 : unsigned ino, unsigned file_type)
3660 : {
3661 240 : struct ext4_renament old = *ent;
3662 240 : 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 240 : old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de,
3670 : &old.inlined);
3671 240 : if (IS_ERR(old.bh))
3672 0 : retval = PTR_ERR(old.bh);
3673 240 : if (!old.bh)
3674 : retval = -ENOENT;
3675 240 : if (retval) {
3676 0 : ext4_std_error(old.dir->i_sb, retval);
3677 0 : return;
3678 : }
3679 :
3680 240 : ext4_setent(handle, &old, ino, file_type);
3681 240 : 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 581713 : static void ext4_rename_delete(handle_t *handle, struct ext4_renament *ent,
3702 : int force_reread)
3703 : {
3704 581713 : 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 581713 : if (le32_to_cpu(ent->de->inode) != ent->inode->i_ino ||
3712 581713 : ent->de->name_len != ent->dentry->d_name.len ||
3713 581712 : strncmp(ent->de->name, ent->dentry->d_name.name,
3714 581712 : ent->de->name_len) ||
3715 : force_reread) {
3716 1 : retval = ext4_find_delete_entry(handle, ent->dir,
3717 1 : &ent->dentry->d_name);
3718 : } else {
3719 581712 : retval = ext4_delete_entry(handle, ent->dir, ent->de, ent->bh);
3720 581709 : if (retval == -ENOENT) {
3721 0 : retval = ext4_find_delete_entry(handle, ent->dir,
3722 0 : &ent->dentry->d_name);
3723 : }
3724 : }
3725 :
3726 581710 : 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 581710 : }
3732 :
3733 46616 : static void ext4_update_dir_count(handle_t *handle, struct ext4_renament *ent)
3734 : {
3735 46616 : 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 46616 : }
3743 :
3744 39061 : static struct inode *ext4_whiteout_for_rename(struct mnt_idmap *idmap,
3745 : struct ext4_renament *ent,
3746 : int credits, handle_t **h)
3747 : {
3748 39061 : struct inode *wh;
3749 39061 : handle_t *handle;
3750 39061 : int retries = 0;
3751 :
3752 : /*
3753 : * for inode block, sb block, group summaries,
3754 : * and inode bitmap
3755 : */
3756 39061 : credits += (EXT4_MAXQUOTAS_TRANS_BLOCKS(ent->dir->i_sb) +
3757 39061 : EXT4_XATTR_TRANS_BLOCKS + 4);
3758 39061 : retry:
3759 39061 : 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 39074 : handle = ext4_journal_current_handle();
3765 39074 : 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 39074 : *h = handle;
3773 39074 : init_special_inode(wh, wh->i_mode, WHITEOUT_DEV);
3774 39057 : wh->i_op = &ext4_special_inode_operations;
3775 : }
3776 39057 : 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 620742 : 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 620742 : handle_t *handle = NULL;
3792 620742 : struct ext4_renament old = {
3793 : .dir = old_dir,
3794 : .dentry = old_dentry,
3795 : .inode = d_inode(old_dentry),
3796 : };
3797 620742 : struct ext4_renament new = {
3798 : .dir = new_dir,
3799 : .dentry = new_dentry,
3800 : .inode = d_inode(new_dentry),
3801 : };
3802 620742 : int force_reread;
3803 620742 : int retval;
3804 620742 : struct inode *whiteout = NULL;
3805 620742 : int credits;
3806 620742 : u8 old_file_type;
3807 :
3808 620742 : 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 620742 : 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 620742 : retval = dquot_initialize(old.dir);
3820 620729 : if (retval)
3821 : return retval;
3822 620735 : retval = dquot_initialize(old.inode);
3823 620727 : if (retval)
3824 : return retval;
3825 620731 : retval = dquot_initialize(new.dir);
3826 620747 : if (retval)
3827 : return retval;
3828 :
3829 : /* Initialize quotas before so that eventual writes go
3830 : * in separate transaction */
3831 620747 : if (new.inode) {
3832 38751 : retval = dquot_initialize(new.inode);
3833 38755 : if (retval)
3834 : return retval;
3835 : }
3836 :
3837 620751 : old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de,
3838 : &old.inlined);
3839 620776 : 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 620776 : retval = -ENOENT;
3849 620776 : if (!old.bh || le32_to_cpu(old.de->inode) != old.inode->i_ino)
3850 0 : goto release_bh;
3851 :
3852 620776 : new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
3853 : &new.de, &new.inlined);
3854 620767 : if (IS_ERR(new.bh)) {
3855 0 : retval = PTR_ERR(new.bh);
3856 0 : new.bh = NULL;
3857 0 : goto release_bh;
3858 : }
3859 620767 : if (new.bh) {
3860 38738 : if (!new.inode) {
3861 0 : brelse(new.bh);
3862 0 : new.bh = NULL;
3863 : }
3864 : }
3865 620767 : if (new.inode && !test_opt(new.dir->i_sb, NO_AUTO_DA_ALLOC))
3866 38755 : ext4_alloc_da_blocks(old.inode);
3867 :
3868 620858 : credits = (2 * EXT4_DATA_TRANS_BLOCKS(old.dir->i_sb) +
3869 620763 : EXT4_INDEX_EXTRA_TRANS_BLOCKS + 2);
3870 620763 : if (!(flags & RENAME_WHITEOUT)) {
3871 581713 : handle = ext4_journal_start(old.dir, EXT4_HT_DIR, credits);
3872 581714 : if (IS_ERR(handle)) {
3873 0 : retval = PTR_ERR(handle);
3874 0 : goto release_bh;
3875 : }
3876 : } else {
3877 39050 : whiteout = ext4_whiteout_for_rename(idmap, &old, credits, &handle);
3878 39054 : if (IS_ERR(whiteout)) {
3879 0 : retval = PTR_ERR(whiteout);
3880 0 : goto release_bh;
3881 : }
3882 : }
3883 :
3884 620768 : old_file_type = old.de->file_type;
3885 620768 : if (IS_DIRSYNC(old.dir) || IS_DIRSYNC(new.dir))
3886 0 : ext4_handle_sync(handle);
3887 :
3888 620768 : if (S_ISDIR(old.inode->i_mode)) {
3889 130513 : if (new.inode) {
3890 231 : retval = -ENOTEMPTY;
3891 231 : if (!ext4_empty_dir(new.inode))
3892 9 : goto end_rename;
3893 : } else {
3894 130282 : retval = -EMLINK;
3895 130282 : if (new.dir != old.dir && EXT4_DIR_LINK_MAX(new.dir))
3896 0 : goto end_rename;
3897 : }
3898 130504 : retval = ext4_rename_dir_prepare(handle, &old);
3899 130505 : 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 620760 : force_reread = (new.dir->i_ino == old.dir->i_ino &&
3910 : ext4_test_inode_flag(new.dir, EXT4_INODE_INLINE_DATA));
3911 :
3912 620760 : 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 39049 : retval = ext4_setent(handle, &old, whiteout->i_ino,
3918 : EXT4_FT_CHRDEV);
3919 39035 : if (retval)
3920 0 : goto end_rename;
3921 39035 : retval = ext4_mark_inode_dirty(handle, whiteout);
3922 39072 : if (unlikely(retval))
3923 0 : goto end_rename;
3924 :
3925 : }
3926 620783 : if (!new.bh) {
3927 582034 : retval = ext4_add_entry(handle, new.dentry, old.inode);
3928 582032 : if (retval)
3929 237 : goto end_rename;
3930 : } else {
3931 38749 : retval = ext4_setent(handle, &new,
3932 38749 : old.inode->i_ino, old_file_type);
3933 38743 : if (retval)
3934 0 : goto end_rename;
3935 : }
3936 620538 : 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 620538 : old.inode->i_ctime = current_time(old.inode);
3945 620533 : retval = ext4_mark_inode_dirty(handle, old.inode);
3946 620543 : if (unlikely(retval))
3947 0 : goto end_rename;
3948 :
3949 620543 : if (!whiteout) {
3950 : /*
3951 : * ok, that's it
3952 : */
3953 581712 : ext4_rename_delete(handle, &old, force_reread);
3954 : }
3955 :
3956 620541 : if (new.inode) {
3957 38749 : ext4_dec_count(new.inode);
3958 38746 : new.inode->i_ctime = current_time(new.inode);
3959 : }
3960 620539 : old.dir->i_ctime = old.dir->i_mtime = current_time(old.dir);
3961 620533 : ext4_update_dx_flag(old.dir);
3962 620534 : if (old.dir_bh) {
3963 130504 : retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
3964 130505 : if (retval)
3965 0 : goto end_rename;
3966 :
3967 130505 : ext4_dec_count(old.dir);
3968 130502 : 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 222 : clear_nlink(new.inode);
3973 : } else {
3974 130280 : ext4_inc_count(new.dir);
3975 130279 : ext4_update_dx_flag(new.dir);
3976 130281 : retval = ext4_mark_inode_dirty(handle, new.dir);
3977 130283 : if (unlikely(retval))
3978 0 : goto end_rename;
3979 : }
3980 : }
3981 620535 : retval = ext4_mark_inode_dirty(handle, old.dir);
3982 620544 : if (unlikely(retval))
3983 0 : goto end_rename;
3984 :
3985 620544 : 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 130505 : ext4_fc_mark_ineligible(old.inode->i_sb,
3992 : EXT4_FC_REASON_RENAME_DIR, handle);
3993 : } else {
3994 490039 : struct super_block *sb = old.inode->i_sb;
3995 :
3996 490039 : if (new.inode)
3997 38527 : ext4_fc_track_unlink(handle, new.dentry);
3998 490038 : 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 620543 : if (new.inode) {
4010 38747 : retval = ext4_mark_inode_dirty(handle, new.inode);
4011 38749 : if (unlikely(retval))
4012 0 : goto end_rename;
4013 38749 : if (!new.inode->i_nlink)
4014 38725 : ext4_orphan_add(handle, new.inode);
4015 : }
4016 : retval = 0;
4017 :
4018 620792 : end_rename:
4019 620792 : if (whiteout) {
4020 39074 : if (retval) {
4021 240 : ext4_resetent(handle, &old,
4022 240 : old.inode->i_ino, old_file_type);
4023 240 : drop_nlink(whiteout);
4024 240 : ext4_orphan_add(handle, whiteout);
4025 : }
4026 39074 : unlock_new_inode(whiteout);
4027 39064 : ext4_journal_stop(handle);
4028 39064 : iput(whiteout);
4029 : } else {
4030 581718 : ext4_journal_stop(handle);
4031 : }
4032 620798 : release_bh:
4033 620798 : brelse(old.dir_bh);
4034 620798 : brelse(old.bh);
4035 620799 : brelse(new.bh);
4036 :
4037 : return retval;
4038 : }
4039 :
4040 23308 : static int ext4_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
4041 : struct inode *new_dir, struct dentry *new_dentry)
4042 : {
4043 23308 : handle_t *handle = NULL;
4044 23308 : struct ext4_renament old = {
4045 : .dir = old_dir,
4046 : .dentry = old_dentry,
4047 : .inode = d_inode(old_dentry),
4048 : };
4049 23308 : struct ext4_renament new = {
4050 : .dir = new_dir,
4051 : .dentry = new_dentry,
4052 : .inode = d_inode(new_dentry),
4053 : };
4054 23308 : u8 new_file_type;
4055 23308 : int retval;
4056 23308 : struct timespec64 ctime;
4057 :
4058 23308 : if ((ext4_test_inode_flag(new_dir, EXT4_INODE_PROJINHERIT) &&
4059 0 : !projid_eq(EXT4_I(new_dir)->i_projid,
4060 23308 : 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 23308 : retval = dquot_initialize(old.dir);
4067 23308 : if (retval)
4068 : return retval;
4069 23308 : retval = dquot_initialize(new.dir);
4070 23308 : if (retval)
4071 : return retval;
4072 :
4073 23308 : old.bh = ext4_find_entry(old.dir, &old.dentry->d_name,
4074 : &old.de, &old.inlined);
4075 23308 : 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 23308 : retval = -ENOENT;
4084 23308 : if (!old.bh || le32_to_cpu(old.de->inode) != old.inode->i_ino)
4085 0 : goto end_rename;
4086 :
4087 23308 : new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
4088 : &new.de, &new.inlined);
4089 23308 : 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 23308 : if (!new.bh || le32_to_cpu(new.de->inode) != new.inode->i_ino)
4097 0 : goto end_rename;
4098 :
4099 43583 : 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 23308 : if (IS_ERR(handle)) {
4103 0 : retval = PTR_ERR(handle);
4104 0 : handle = NULL;
4105 0 : goto end_rename;
4106 : }
4107 :
4108 23308 : if (IS_DIRSYNC(old.dir) || IS_DIRSYNC(new.dir))
4109 0 : ext4_handle_sync(handle);
4110 :
4111 23308 : if (S_ISDIR(old.inode->i_mode)) {
4112 2791 : old.is_dir = true;
4113 2791 : retval = ext4_rename_dir_prepare(handle, &old);
4114 2791 : if (retval)
4115 0 : goto end_rename;
4116 : }
4117 23308 : if (S_ISDIR(new.inode->i_mode)) {
4118 2791 : new.is_dir = true;
4119 2791 : retval = ext4_rename_dir_prepare(handle, &new);
4120 2791 : 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 23308 : 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 23308 : new_file_type = new.de->file_type;
4138 23308 : retval = ext4_setent(handle, &new, old.inode->i_ino, old.de->file_type);
4139 23308 : if (retval)
4140 0 : goto end_rename;
4141 :
4142 23308 : retval = ext4_setent(handle, &old, new.inode->i_ino, new_file_type);
4143 23308 : 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 23308 : ctime = current_time(old.inode);
4151 23308 : old.inode->i_ctime = ctime;
4152 23308 : new.inode->i_ctime = ctime;
4153 23308 : retval = ext4_mark_inode_dirty(handle, old.inode);
4154 23308 : if (unlikely(retval))
4155 0 : goto end_rename;
4156 23308 : retval = ext4_mark_inode_dirty(handle, new.inode);
4157 23308 : if (unlikely(retval))
4158 0 : goto end_rename;
4159 23308 : ext4_fc_mark_ineligible(new.inode->i_sb,
4160 : EXT4_FC_REASON_CROSS_RENAME, handle);
4161 23308 : if (old.dir_bh) {
4162 2791 : retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
4163 2791 : if (retval)
4164 0 : goto end_rename;
4165 : }
4166 23308 : if (new.dir_bh) {
4167 2791 : retval = ext4_rename_dir_finish(handle, &new, old.dir->i_ino);
4168 2791 : if (retval)
4169 0 : goto end_rename;
4170 : }
4171 23308 : ext4_update_dir_count(handle, &old);
4172 23308 : ext4_update_dir_count(handle, &new);
4173 23308 : retval = 0;
4174 :
4175 23308 : end_rename:
4176 23308 : brelse(old.dir_bh);
4177 23308 : brelse(new.dir_bh);
4178 23308 : brelse(old.bh);
4179 23308 : brelse(new.bh);
4180 23308 : if (handle)
4181 23308 : ext4_journal_stop(handle);
4182 : return retval;
4183 : }
4184 :
4185 644140 : 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 644140 : int err;
4191 :
4192 1288280 : if (unlikely(ext4_forced_shutdown(EXT4_SB(old_dir->i_sb))))
4193 : return -EIO;
4194 :
4195 644082 : if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
4196 : return -EINVAL;
4197 :
4198 644082 : err = fscrypt_prepare_rename(old_dir, old_dentry, new_dir, new_dentry,
4199 : flags);
4200 644082 : if (err)
4201 : return err;
4202 :
4203 644082 : if (flags & RENAME_EXCHANGE) {
4204 23307 : return ext4_cross_rename(old_dir, old_dentry,
4205 : new_dir, new_dentry);
4206 : }
4207 :
4208 620775 : 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 : };
|
