blob: 883e2a7cd4ab5e277c1bf22e5cd9b89473ff7170 [file] [log] [blame]
Greg Kroah-Hartmanb2441312017-11-01 15:07:57 +01001// SPDX-License-Identifier: GPL-2.0
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002/*
Mingming Cao617ba132006-10-11 01:20:53 -07003 * linux/fs/ext4/namei.c
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004 *
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>
Dave Kleikampac27a0e2006-10-11 01:20:50 -070030#include <linux/time.h>
Dave Kleikampac27a0e2006-10-11 01:20:50 -070031#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>
Jeff Laytonae5e1652018-01-29 06:41:30 -050037#include <linux/iversion.h>
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -040038#include <linux/unicode.h>
Christoph Hellwig3dcf5452008-04-29 18:13:32 -040039#include "ext4.h"
40#include "ext4_jbd2.h"
Dave Kleikampac27a0e2006-10-11 01:20:50 -070041
Dave Kleikampac27a0e2006-10-11 01:20:50 -070042#include "xattr.h"
43#include "acl.h"
44
Jiaying Zhang0562e0b2011-03-21 21:38:05 -040045#include <trace/events/ext4.h>
Dave Kleikampac27a0e2006-10-11 01:20:50 -070046/*
47 * define how far ahead to read directories while searching them.
48 */
49#define NAMEI_RA_CHUNKS 2
50#define NAMEI_RA_BLOCKS 4
Dave Kleikamp8c55e202007-05-24 13:04:54 -040051#define NAMEI_RA_SIZE (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)
Dave Kleikampac27a0e2006-10-11 01:20:50 -070052
Mingming Cao617ba132006-10-11 01:20:53 -070053static struct buffer_head *ext4_append(handle_t *handle,
Dave Kleikampac27a0e2006-10-11 01:20:50 -070054 struct inode *inode,
Theodore Ts'o0f70b402013-02-15 03:35:57 -050055 ext4_lblk_t *block)
Dave Kleikampac27a0e2006-10-11 01:20:50 -070056{
57 struct buffer_head *bh;
Theodore Ts'o1c215022014-08-29 20:52:15 -040058 int err;
Dave Kleikampac27a0e2006-10-11 01:20:50 -070059
Theodore Ts'odf981d02012-08-17 09:48:17 -040060 if (unlikely(EXT4_SB(inode->i_sb)->s_max_dir_size_kb &&
61 ((inode->i_size >> 10) >=
Theodore Ts'o0f70b402013-02-15 03:35:57 -050062 EXT4_SB(inode->i_sb)->s_max_dir_size_kb)))
63 return ERR_PTR(-ENOSPC);
Theodore Ts'odf981d02012-08-17 09:48:17 -040064
Dave Kleikampac27a0e2006-10-11 01:20:50 -070065 *block = inode->i_size >> inode->i_sb->s_blocksize_bits;
66
Theodore Ts'oc5e298a2015-06-21 01:25:29 -040067 bh = ext4_bread(handle, inode, *block, EXT4_GET_BLOCKS_CREATE);
Theodore Ts'o1c215022014-08-29 20:52:15 -040068 if (IS_ERR(bh))
69 return bh;
Theodore Ts'o0f70b402013-02-15 03:35:57 -050070 inode->i_size += inode->i_sb->s_blocksize;
71 EXT4_I(inode)->i_disksize = inode->i_size;
liang xie5d601252014-05-12 22:06:43 -040072 BUFFER_TRACE(bh, "get_write_access");
Theodore Ts'o0f70b402013-02-15 03:35:57 -050073 err = ext4_journal_get_write_access(handle, bh);
74 if (err) {
75 brelse(bh);
76 ext4_std_error(inode->i_sb, err);
77 return ERR_PTR(err);
Carlos Maiolino6d1ab102012-09-27 09:31:33 -040078 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -070079 return bh;
80}
81
Theodore Ts'odc6982ff2013-02-14 23:59:26 -050082static int ext4_dx_csum_verify(struct inode *inode,
83 struct ext4_dir_entry *dirent);
84
Theodore Ts'o4e19d6b2019-06-20 21:19:02 -040085/*
86 * Hints to ext4_read_dirblock regarding whether we expect a directory
87 * block being read to be an index block, or a block containing
88 * directory entries (and if the latter, whether it was found via a
89 * logical block in an htree index block). This is used to control
90 * what sort of sanity checkinig ext4_read_dirblock() will do on the
91 * directory block read from the storage device. EITHER will means
92 * the caller doesn't know what kind of directory block will be read,
93 * so no specific verification will be done.
94 */
Theodore Ts'odc6982ff2013-02-14 23:59:26 -050095typedef enum {
Theodore Ts'o4e19d6b2019-06-20 21:19:02 -040096 EITHER, INDEX, DIRENT, DIRENT_HTREE
Theodore Ts'odc6982ff2013-02-14 23:59:26 -050097} dirblock_type_t;
98
99#define ext4_read_dirblock(inode, block, type) \
Andreas Dilgerb03a2f72015-06-15 14:50:26 -0400100 __ext4_read_dirblock((inode), (block), (type), __func__, __LINE__)
Theodore Ts'odc6982ff2013-02-14 23:59:26 -0500101
102static struct buffer_head *__ext4_read_dirblock(struct inode *inode,
Andreas Dilgerb03a2f72015-06-15 14:50:26 -0400103 ext4_lblk_t block,
104 dirblock_type_t type,
105 const char *func,
106 unsigned int line)
Theodore Ts'odc6982ff2013-02-14 23:59:26 -0500107{
108 struct buffer_head *bh;
109 struct ext4_dir_entry *dirent;
Theodore Ts'o1c215022014-08-29 20:52:15 -0400110 int is_dx_block = 0;
Theodore Ts'odc6982ff2013-02-14 23:59:26 -0500111
Theodore Ts'o46f870d62019-11-21 13:09:43 -0500112 if (ext4_simulate_fail(inode->i_sb, EXT4_SIM_DIRBLOCK_EIO))
113 bh = ERR_PTR(-EIO);
114 else
115 bh = ext4_bread(NULL, inode, block, 0);
Theodore Ts'o1c215022014-08-29 20:52:15 -0400116 if (IS_ERR(bh)) {
Andreas Dilgerb03a2f72015-06-15 14:50:26 -0400117 __ext4_warning(inode->i_sb, func, line,
118 "inode #%lu: lblock %lu: comm %s: "
119 "error %ld reading directory block",
120 inode->i_ino, (unsigned long)block,
121 current->comm, PTR_ERR(bh));
Theodore Ts'o1c215022014-08-29 20:52:15 -0400122
123 return bh;
124 }
Theodore Ts'o4e19d6b2019-06-20 21:19:02 -0400125 if (!bh && (type == INDEX || type == DIRENT_HTREE)) {
Andreas Dilgerb03a2f72015-06-15 14:50:26 -0400126 ext4_error_inode(inode, func, line, block,
Theodore Ts'o4e19d6b2019-06-20 21:19:02 -0400127 "Directory hole found for htree %s block",
128 (type == INDEX) ? "index" : "leaf");
Darrick J. Wong6a797d22015-10-17 16:16:04 -0400129 return ERR_PTR(-EFSCORRUPTED);
Theodore Ts'odc6982ff2013-02-14 23:59:26 -0500130 }
Theodore Ts'o4e19d6b2019-06-20 21:19:02 -0400131 if (!bh)
132 return NULL;
Theodore Ts'odc6982ff2013-02-14 23:59:26 -0500133 dirent = (struct ext4_dir_entry *) bh->b_data;
134 /* Determine whether or not we have an index block */
135 if (is_dx(inode)) {
136 if (block == 0)
137 is_dx_block = 1;
138 else if (ext4_rec_len_from_disk(dirent->rec_len,
139 inode->i_sb->s_blocksize) ==
140 inode->i_sb->s_blocksize)
141 is_dx_block = 1;
142 }
143 if (!is_dx_block && type == INDEX) {
Andreas Dilgerb03a2f72015-06-15 14:50:26 -0400144 ext4_error_inode(inode, func, line, block,
Theodore Ts'odc6982ff2013-02-14 23:59:26 -0500145 "directory leaf block found instead of index block");
Vasily Averinde59fae2018-11-07 22:36:23 -0500146 brelse(bh);
Darrick J. Wong6a797d22015-10-17 16:16:04 -0400147 return ERR_PTR(-EFSCORRUPTED);
Theodore Ts'odc6982ff2013-02-14 23:59:26 -0500148 }
Dmitry Monakhov9aa5d32b2014-10-13 03:36:16 -0400149 if (!ext4_has_metadata_csum(inode->i_sb) ||
Theodore Ts'odc6982ff2013-02-14 23:59:26 -0500150 buffer_verified(bh))
151 return bh;
152
153 /*
154 * An empty leaf block can get mistaken for a index block; for
155 * this reason, we can only check the index checksum when the
156 * caller is sure it should be an index block.
157 */
158 if (is_dx_block && type == INDEX) {
Theodore Ts'o46f870d62019-11-21 13:09:43 -0500159 if (ext4_dx_csum_verify(inode, dirent) &&
160 !ext4_simulate_fail(inode->i_sb, EXT4_SIM_DIRBLOCK_CRC))
Theodore Ts'odc6982ff2013-02-14 23:59:26 -0500161 set_buffer_verified(bh);
162 else {
Theodore Ts'o54d3adb2020-03-28 19:33:43 -0400163 ext4_error_inode_err(inode, func, line, block,
164 EFSBADCRC,
165 "Directory index failed checksum");
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700166 brelse(bh);
Darrick J. Wong6a797d22015-10-17 16:16:04 -0400167 return ERR_PTR(-EFSBADCRC);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700168 }
169 }
Theodore Ts'odc6982ff2013-02-14 23:59:26 -0500170 if (!is_dx_block) {
Theodore Ts'o46f870d62019-11-21 13:09:43 -0500171 if (ext4_dirblock_csum_verify(inode, bh) &&
172 !ext4_simulate_fail(inode->i_sb, EXT4_SIM_DIRBLOCK_CRC))
Theodore Ts'odc6982ff2013-02-14 23:59:26 -0500173 set_buffer_verified(bh);
174 else {
Theodore Ts'o54d3adb2020-03-28 19:33:43 -0400175 ext4_error_inode_err(inode, func, line, block,
176 EFSBADCRC,
177 "Directory block failed checksum");
Theodore Ts'odc6982ff2013-02-14 23:59:26 -0500178 brelse(bh);
Darrick J. Wong6a797d22015-10-17 16:16:04 -0400179 return ERR_PTR(-EFSBADCRC);
Theodore Ts'odc6982ff2013-02-14 23:59:26 -0500180 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700181 }
182 return bh;
183}
184
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700185#ifdef DX_DEBUG
186#define dxtrace(command) command
187#else
188#define dxtrace(command)
189#endif
190
191struct fake_dirent
192{
193 __le32 inode;
194 __le16 rec_len;
195 u8 name_len;
196 u8 file_type;
197};
198
199struct dx_countlimit
200{
201 __le16 limit;
202 __le16 count;
203};
204
205struct dx_entry
206{
207 __le32 hash;
208 __le32 block;
209};
210
211/*
212 * dx_root_info is laid out so that if it should somehow get overlaid by a
213 * dirent the two low bits of the hash version will be zero. Therefore, the
214 * hash version mod 4 should never be 0. Sincerely, the paranoia department.
215 */
216
217struct dx_root
218{
219 struct fake_dirent dot;
220 char dot_name[4];
221 struct fake_dirent dotdot;
222 char dotdot_name[4];
223 struct dx_root_info
224 {
225 __le32 reserved_zero;
226 u8 hash_version;
227 u8 info_length; /* 8 */
228 u8 indirect_levels;
229 u8 unused_flags;
230 }
231 info;
Gustavo A. R. Silva6cfb0612020-02-13 10:06:48 -0600232 struct dx_entry entries[];
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700233};
234
235struct dx_node
236{
237 struct fake_dirent fake;
Gustavo A. R. Silva6cfb0612020-02-13 10:06:48 -0600238 struct dx_entry entries[];
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700239};
240
241
242struct dx_frame
243{
244 struct buffer_head *bh;
245 struct dx_entry *entries;
246 struct dx_entry *at;
247};
248
249struct dx_map_entry
250{
251 u32 hash;
Eric Sandeenef2b02d2007-09-18 22:46:42 -0700252 u16 offs;
253 u16 size;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700254};
255
Darrick J. Wonge6153912012-04-29 18:23:10 -0400256/*
257 * This goes at the end of each htree block.
258 */
259struct dx_tail {
260 u32 dt_reserved;
261 __le32 dt_checksum; /* crc32c(uuid+inum+dirblock) */
262};
263
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -0500264static inline ext4_lblk_t dx_get_block(struct dx_entry *entry);
265static void dx_set_block(struct dx_entry *entry, ext4_lblk_t value);
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400266static inline unsigned dx_get_hash(struct dx_entry *entry);
267static void dx_set_hash(struct dx_entry *entry, unsigned value);
268static unsigned dx_get_count(struct dx_entry *entries);
269static unsigned dx_get_limit(struct dx_entry *entries);
270static void dx_set_count(struct dx_entry *entries, unsigned value);
271static void dx_set_limit(struct dx_entry *entries, unsigned value);
272static unsigned dx_root_limit(struct inode *dir, unsigned infosize);
273static unsigned dx_node_limit(struct inode *dir);
Theodore Ts'o5b643f92015-05-18 13:14:47 -0400274static struct dx_frame *dx_probe(struct ext4_filename *fname,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700275 struct inode *dir,
276 struct dx_hash_info *hinfo,
Theodore Ts'odd73b5d2014-08-29 20:52:17 -0400277 struct dx_frame *frame);
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400278static void dx_release(struct dx_frame *frames);
Michael Halcrow1f3862b2015-04-12 01:09:03 -0400279static int dx_make_map(struct inode *dir, struct ext4_dir_entry_2 *de,
280 unsigned blocksize, struct dx_hash_info *hinfo,
281 struct dx_map_entry map[]);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700282static void dx_sort_map(struct dx_map_entry *map, unsigned count);
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400283static struct ext4_dir_entry_2 *dx_move_dirents(char *from, char *to,
Wei Yongjun3d0518f2009-02-14 23:01:36 -0500284 struct dx_map_entry *offsets, int count, unsigned blocksize);
Theodore Ts'o8bad4592009-02-14 21:46:54 -0500285static struct ext4_dir_entry_2* dx_pack_dirents(char *base, unsigned blocksize);
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -0500286static void dx_insert_block(struct dx_frame *frame,
287 u32 hash, ext4_lblk_t block);
Mingming Cao617ba132006-10-11 01:20:53 -0700288static int ext4_htree_next_block(struct inode *dir, __u32 hash,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700289 struct dx_frame *frame,
290 struct dx_frame *frames,
291 __u32 *start_hash);
Theodore Ts'of702ba02008-09-22 15:21:01 -0400292static struct buffer_head * ext4_dx_find_entry(struct inode *dir,
Theodore Ts'o5b643f92015-05-18 13:14:47 -0400293 struct ext4_filename *fname,
Theodore Ts'o537d8f92014-08-29 20:49:51 -0400294 struct ext4_dir_entry_2 **res_dir);
Theodore Ts'o5b643f92015-05-18 13:14:47 -0400295static int ext4_dx_add_entry(handle_t *handle, struct ext4_filename *fname,
Theodore Ts'o56a04912016-01-08 16:00:31 -0500296 struct inode *dir, struct inode *inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700297
Darrick J. Wongdbe89442012-04-29 18:39:10 -0400298/* checksumming functions */
Theodore Ts'oddce3b92019-06-21 16:31:47 -0400299void ext4_initialize_dirent_tail(struct buffer_head *bh,
300 unsigned int blocksize)
Darrick J. Wongb0336e82012-04-29 18:41:10 -0400301{
Theodore Ts'oddce3b92019-06-21 16:31:47 -0400302 struct ext4_dir_entry_tail *t = EXT4_DIRENT_TAIL(bh->b_data, blocksize);
303
Darrick J. Wongb0336e82012-04-29 18:41:10 -0400304 memset(t, 0, sizeof(struct ext4_dir_entry_tail));
305 t->det_rec_len = ext4_rec_len_to_disk(
306 sizeof(struct ext4_dir_entry_tail), blocksize);
307 t->det_reserved_ft = EXT4_FT_DIR_CSUM;
308}
309
310/* Walk through a dirent block to find a checksum "dirent" at the tail */
311static struct ext4_dir_entry_tail *get_dirent_tail(struct inode *inode,
Theodore Ts'of036adb2019-06-21 15:49:26 -0400312 struct buffer_head *bh)
Darrick J. Wongb0336e82012-04-29 18:41:10 -0400313{
314 struct ext4_dir_entry_tail *t;
315
316#ifdef PARANOID
317 struct ext4_dir_entry *d, *top;
318
Theodore Ts'of036adb2019-06-21 15:49:26 -0400319 d = (struct ext4_dir_entry *)bh->b_data;
320 top = (struct ext4_dir_entry *)(bh->b_data +
Darrick J. Wongb0336e82012-04-29 18:41:10 -0400321 (EXT4_BLOCK_SIZE(inode->i_sb) -
Theodore Ts'of036adb2019-06-21 15:49:26 -0400322 sizeof(struct ext4_dir_entry_tail)));
Darrick J. Wongb0336e82012-04-29 18:41:10 -0400323 while (d < top && d->rec_len)
324 d = (struct ext4_dir_entry *)(((void *)d) +
325 le16_to_cpu(d->rec_len));
326
327 if (d != top)
328 return NULL;
329
330 t = (struct ext4_dir_entry_tail *)d;
331#else
Theodore Ts'of036adb2019-06-21 15:49:26 -0400332 t = EXT4_DIRENT_TAIL(bh->b_data, EXT4_BLOCK_SIZE(inode->i_sb));
Darrick J. Wongb0336e82012-04-29 18:41:10 -0400333#endif
334
335 if (t->det_reserved_zero1 ||
336 le16_to_cpu(t->det_rec_len) != sizeof(struct ext4_dir_entry_tail) ||
337 t->det_reserved_zero2 ||
338 t->det_reserved_ft != EXT4_FT_DIR_CSUM)
339 return NULL;
340
341 return t;
342}
343
Theodore Ts'of036adb2019-06-21 15:49:26 -0400344static __le32 ext4_dirblock_csum(struct inode *inode, void *dirent, int size)
Darrick J. Wongb0336e82012-04-29 18:41:10 -0400345{
346 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
347 struct ext4_inode_info *ei = EXT4_I(inode);
348 __u32 csum;
349
350 csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)dirent, size);
351 return cpu_to_le32(csum);
352}
353
Andreas Dilgerb03a2f72015-06-15 14:50:26 -0400354#define warn_no_space_for_csum(inode) \
355 __warn_no_space_for_csum((inode), __func__, __LINE__)
356
357static void __warn_no_space_for_csum(struct inode *inode, const char *func,
358 unsigned int line)
Theodore Ts'odffe9d82012-11-10 22:20:05 -0500359{
Andreas Dilgerb03a2f72015-06-15 14:50:26 -0400360 __ext4_warning_inode(inode, func, line,
361 "No space for directory leaf checksum. Please run e2fsck -D.");
Theodore Ts'odffe9d82012-11-10 22:20:05 -0500362}
363
Theodore Ts'of036adb2019-06-21 15:49:26 -0400364int ext4_dirblock_csum_verify(struct inode *inode, struct buffer_head *bh)
Darrick J. Wongb0336e82012-04-29 18:41:10 -0400365{
366 struct ext4_dir_entry_tail *t;
367
Dmitry Monakhov9aa5d32b2014-10-13 03:36:16 -0400368 if (!ext4_has_metadata_csum(inode->i_sb))
Darrick J. Wongb0336e82012-04-29 18:41:10 -0400369 return 1;
370
Theodore Ts'of036adb2019-06-21 15:49:26 -0400371 t = get_dirent_tail(inode, bh);
Darrick J. Wongb0336e82012-04-29 18:41:10 -0400372 if (!t) {
Theodore Ts'odffe9d82012-11-10 22:20:05 -0500373 warn_no_space_for_csum(inode);
Darrick J. Wongb0336e82012-04-29 18:41:10 -0400374 return 0;
375 }
376
Theodore Ts'of036adb2019-06-21 15:49:26 -0400377 if (t->det_checksum != ext4_dirblock_csum(inode, bh->b_data,
Theodore Ts'oddce3b92019-06-21 16:31:47 -0400378 (char *)t - bh->b_data))
Darrick J. Wongb0336e82012-04-29 18:41:10 -0400379 return 0;
380
381 return 1;
382}
383
Theodore Ts'of036adb2019-06-21 15:49:26 -0400384static void ext4_dirblock_csum_set(struct inode *inode,
385 struct buffer_head *bh)
Darrick J. Wongb0336e82012-04-29 18:41:10 -0400386{
387 struct ext4_dir_entry_tail *t;
388
Dmitry Monakhov9aa5d32b2014-10-13 03:36:16 -0400389 if (!ext4_has_metadata_csum(inode->i_sb))
Darrick J. Wongb0336e82012-04-29 18:41:10 -0400390 return;
391
Theodore Ts'of036adb2019-06-21 15:49:26 -0400392 t = get_dirent_tail(inode, bh);
Darrick J. Wongb0336e82012-04-29 18:41:10 -0400393 if (!t) {
Theodore Ts'odffe9d82012-11-10 22:20:05 -0500394 warn_no_space_for_csum(inode);
Darrick J. Wongb0336e82012-04-29 18:41:10 -0400395 return;
396 }
397
Theodore Ts'of036adb2019-06-21 15:49:26 -0400398 t->det_checksum = ext4_dirblock_csum(inode, bh->b_data,
Theodore Ts'oddce3b92019-06-21 16:31:47 -0400399 (char *)t - bh->b_data);
Darrick J. Wongb0336e82012-04-29 18:41:10 -0400400}
401
Theodore Ts'of036adb2019-06-21 15:49:26 -0400402int ext4_handle_dirty_dirblock(handle_t *handle,
403 struct inode *inode,
404 struct buffer_head *bh)
Darrick J. Wongb0336e82012-04-29 18:41:10 -0400405{
Theodore Ts'of036adb2019-06-21 15:49:26 -0400406 ext4_dirblock_csum_set(inode, bh);
Darrick J. Wongb0336e82012-04-29 18:41:10 -0400407 return ext4_handle_dirty_metadata(handle, inode, bh);
408}
409
Darrick J. Wongdbe89442012-04-29 18:39:10 -0400410static struct dx_countlimit *get_dx_countlimit(struct inode *inode,
411 struct ext4_dir_entry *dirent,
412 int *offset)
413{
414 struct ext4_dir_entry *dp;
415 struct dx_root_info *root;
416 int count_offset;
417
418 if (le16_to_cpu(dirent->rec_len) == EXT4_BLOCK_SIZE(inode->i_sb))
419 count_offset = 8;
420 else if (le16_to_cpu(dirent->rec_len) == 12) {
421 dp = (struct ext4_dir_entry *)(((void *)dirent) + 12);
422 if (le16_to_cpu(dp->rec_len) !=
423 EXT4_BLOCK_SIZE(inode->i_sb) - 12)
424 return NULL;
425 root = (struct dx_root_info *)(((void *)dp + 12));
426 if (root->reserved_zero ||
427 root->info_length != sizeof(struct dx_root_info))
428 return NULL;
429 count_offset = 32;
430 } else
431 return NULL;
432
433 if (offset)
434 *offset = count_offset;
435 return (struct dx_countlimit *)(((void *)dirent) + count_offset);
436}
437
438static __le32 ext4_dx_csum(struct inode *inode, struct ext4_dir_entry *dirent,
439 int count_offset, int count, struct dx_tail *t)
440{
441 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
442 struct ext4_inode_info *ei = EXT4_I(inode);
Theodore Ts'od6a77102013-04-09 23:59:55 -0400443 __u32 csum;
Darrick J. Wongdbe89442012-04-29 18:39:10 -0400444 int size;
Daeho Jeongb47820e2016-07-03 17:51:39 -0400445 __u32 dummy_csum = 0;
446 int offset = offsetof(struct dx_tail, dt_checksum);
Darrick J. Wongdbe89442012-04-29 18:39:10 -0400447
448 size = count_offset + (count * sizeof(struct dx_entry));
Darrick J. Wongdbe89442012-04-29 18:39:10 -0400449 csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)dirent, size);
Daeho Jeongb47820e2016-07-03 17:51:39 -0400450 csum = ext4_chksum(sbi, csum, (__u8 *)t, offset);
451 csum = ext4_chksum(sbi, csum, (__u8 *)&dummy_csum, sizeof(dummy_csum));
Darrick J. Wongdbe89442012-04-29 18:39:10 -0400452
453 return cpu_to_le32(csum);
454}
455
456static int ext4_dx_csum_verify(struct inode *inode,
457 struct ext4_dir_entry *dirent)
458{
459 struct dx_countlimit *c;
460 struct dx_tail *t;
461 int count_offset, limit, count;
462
Dmitry Monakhov9aa5d32b2014-10-13 03:36:16 -0400463 if (!ext4_has_metadata_csum(inode->i_sb))
Darrick J. Wongdbe89442012-04-29 18:39:10 -0400464 return 1;
465
466 c = get_dx_countlimit(inode, dirent, &count_offset);
467 if (!c) {
468 EXT4_ERROR_INODE(inode, "dir seems corrupt? Run e2fsck -D.");
Daeho Jeongfa964542016-07-03 21:11:08 -0400469 return 0;
Darrick J. Wongdbe89442012-04-29 18:39:10 -0400470 }
471 limit = le16_to_cpu(c->limit);
472 count = le16_to_cpu(c->count);
473 if (count_offset + (limit * sizeof(struct dx_entry)) >
474 EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) {
Theodore Ts'odffe9d82012-11-10 22:20:05 -0500475 warn_no_space_for_csum(inode);
Daeho Jeongfa964542016-07-03 21:11:08 -0400476 return 0;
Darrick J. Wongdbe89442012-04-29 18:39:10 -0400477 }
478 t = (struct dx_tail *)(((struct dx_entry *)c) + limit);
479
480 if (t->dt_checksum != ext4_dx_csum(inode, dirent, count_offset,
481 count, t))
482 return 0;
483 return 1;
484}
485
486static void ext4_dx_csum_set(struct inode *inode, struct ext4_dir_entry *dirent)
487{
488 struct dx_countlimit *c;
489 struct dx_tail *t;
490 int count_offset, limit, count;
491
Dmitry Monakhov9aa5d32b2014-10-13 03:36:16 -0400492 if (!ext4_has_metadata_csum(inode->i_sb))
Darrick J. Wongdbe89442012-04-29 18:39:10 -0400493 return;
494
495 c = get_dx_countlimit(inode, dirent, &count_offset);
496 if (!c) {
497 EXT4_ERROR_INODE(inode, "dir seems corrupt? Run e2fsck -D.");
498 return;
499 }
500 limit = le16_to_cpu(c->limit);
501 count = le16_to_cpu(c->count);
502 if (count_offset + (limit * sizeof(struct dx_entry)) >
503 EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) {
Theodore Ts'odffe9d82012-11-10 22:20:05 -0500504 warn_no_space_for_csum(inode);
Darrick J. Wongdbe89442012-04-29 18:39:10 -0400505 return;
506 }
507 t = (struct dx_tail *)(((struct dx_entry *)c) + limit);
508
509 t->dt_checksum = ext4_dx_csum(inode, dirent, count_offset, count, t);
510}
511
512static inline int ext4_handle_dirty_dx_node(handle_t *handle,
513 struct inode *inode,
514 struct buffer_head *bh)
515{
516 ext4_dx_csum_set(inode, (struct ext4_dir_entry *)bh->b_data);
517 return ext4_handle_dirty_metadata(handle, inode, bh);
518}
519
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700520/*
Li Zefanf795e142008-07-11 19:27:31 -0400521 * p is at least 6 bytes before the end of page
522 */
523static inline struct ext4_dir_entry_2 *
Wei Yongjun3d0518f2009-02-14 23:01:36 -0500524ext4_next_entry(struct ext4_dir_entry_2 *p, unsigned long blocksize)
Li Zefanf795e142008-07-11 19:27:31 -0400525{
526 return (struct ext4_dir_entry_2 *)((char *)p +
Wei Yongjun3d0518f2009-02-14 23:01:36 -0500527 ext4_rec_len_from_disk(p->rec_len, blocksize));
Li Zefanf795e142008-07-11 19:27:31 -0400528}
529
530/*
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700531 * Future: use high four bits of block for coalesce-on-delete flags
532 * Mask them off for now.
533 */
534
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -0500535static inline ext4_lblk_t dx_get_block(struct dx_entry *entry)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700536{
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -0400537 return le32_to_cpu(entry->block) & 0x0fffffff;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700538}
539
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -0500540static inline void dx_set_block(struct dx_entry *entry, ext4_lblk_t value)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700541{
542 entry->block = cpu_to_le32(value);
543}
544
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400545static inline unsigned dx_get_hash(struct dx_entry *entry)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700546{
547 return le32_to_cpu(entry->hash);
548}
549
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400550static inline void dx_set_hash(struct dx_entry *entry, unsigned value)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700551{
552 entry->hash = cpu_to_le32(value);
553}
554
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400555static inline unsigned dx_get_count(struct dx_entry *entries)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700556{
557 return le16_to_cpu(((struct dx_countlimit *) entries)->count);
558}
559
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400560static inline unsigned dx_get_limit(struct dx_entry *entries)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700561{
562 return le16_to_cpu(((struct dx_countlimit *) entries)->limit);
563}
564
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400565static inline void dx_set_count(struct dx_entry *entries, unsigned value)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700566{
567 ((struct dx_countlimit *) entries)->count = cpu_to_le16(value);
568}
569
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400570static inline void dx_set_limit(struct dx_entry *entries, unsigned value)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700571{
572 ((struct dx_countlimit *) entries)->limit = cpu_to_le16(value);
573}
574
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400575static inline unsigned dx_root_limit(struct inode *dir, unsigned infosize)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700576{
Mingming Cao617ba132006-10-11 01:20:53 -0700577 unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(1) -
578 EXT4_DIR_REC_LEN(2) - infosize;
Darrick J. Wongdbe89442012-04-29 18:39:10 -0400579
Dmitry Monakhov9aa5d32b2014-10-13 03:36:16 -0400580 if (ext4_has_metadata_csum(dir->i_sb))
Darrick J. Wongdbe89442012-04-29 18:39:10 -0400581 entry_space -= sizeof(struct dx_tail);
Li Zefand9c769b2008-07-11 19:27:31 -0400582 return entry_space / sizeof(struct dx_entry);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700583}
584
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400585static inline unsigned dx_node_limit(struct inode *dir)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700586{
Mingming Cao617ba132006-10-11 01:20:53 -0700587 unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(0);
Darrick J. Wongdbe89442012-04-29 18:39:10 -0400588
Dmitry Monakhov9aa5d32b2014-10-13 03:36:16 -0400589 if (ext4_has_metadata_csum(dir->i_sb))
Darrick J. Wongdbe89442012-04-29 18:39:10 -0400590 entry_space -= sizeof(struct dx_tail);
Li Zefand9c769b2008-07-11 19:27:31 -0400591 return entry_space / sizeof(struct dx_entry);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700592}
593
594/*
595 * Debug
596 */
597#ifdef DX_DEBUG
Theodore Ts'o4776004f2008-09-08 23:00:52 -0400598static void dx_show_index(char * label, struct dx_entry *entries)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700599{
Andrew Morton63f57932006-10-11 01:21:24 -0700600 int i, n = dx_get_count (entries);
Joe Perchesd74f3d22016-10-15 09:57:31 -0400601 printk(KERN_DEBUG "%s index", label);
Andrew Morton63f57932006-10-11 01:21:24 -0700602 for (i = 0; i < n; i++) {
Joe Perchesd74f3d22016-10-15 09:57:31 -0400603 printk(KERN_CONT " %x->%lu",
604 i ? dx_get_hash(entries + i) : 0,
605 (unsigned long)dx_get_block(entries + i));
Andrew Morton63f57932006-10-11 01:21:24 -0700606 }
Joe Perchesd74f3d22016-10-15 09:57:31 -0400607 printk(KERN_CONT "\n");
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700608}
609
610struct stats
611{
612 unsigned names;
613 unsigned space;
614 unsigned bcount;
615};
616
Michael Halcrowb3098482015-04-12 01:07:01 -0400617static struct stats dx_show_leaf(struct inode *dir,
618 struct dx_hash_info *hinfo,
619 struct ext4_dir_entry_2 *de,
620 int size, int show_names)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700621{
622 unsigned names = 0, space = 0;
623 char *base = (char *) de;
624 struct dx_hash_info h = *hinfo;
625
626 printk("names: ");
627 while ((char *) de < base + size)
628 {
629 if (de->inode)
630 {
631 if (show_names)
632 {
Chandan Rajendra643fa962018-12-12 15:20:12 +0530633#ifdef CONFIG_FS_ENCRYPTION
Michael Halcrowb3098482015-04-12 01:07:01 -0400634 int len;
635 char *name;
Jaegeuk Kima7550b32016-07-10 14:01:03 -0400636 struct fscrypt_str fname_crypto_str =
637 FSTR_INIT(NULL, 0);
Theodore Ts'oc936e1e2015-05-31 13:34:22 -0400638 int res = 0;
Michael Halcrowb3098482015-04-12 01:07:01 -0400639
640 name = de->name;
641 len = de->name_len;
Eric Biggers91d0d892020-12-02 18:20:36 -0800642 if (!IS_ENCRYPTED(dir)) {
Michael Halcrowb3098482015-04-12 01:07:01 -0400643 /* Directory is not encrypted */
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -0400644 ext4fs_dirhash(dir, de->name,
Michael Halcrowb3098482015-04-12 01:07:01 -0400645 de->name_len, &h);
646 printk("%*.s:(U)%x.%u ", len,
647 name, h.hash,
648 (unsigned) ((char *) de
649 - base));
650 } else {
Jaegeuk Kima7550b32016-07-10 14:01:03 -0400651 struct fscrypt_str de_name =
652 FSTR_INIT(name, len);
653
Michael Halcrowb3098482015-04-12 01:07:01 -0400654 /* Directory is encrypted */
Jaegeuk Kima7550b32016-07-10 14:01:03 -0400655 res = fscrypt_fname_alloc_buffer(
Jeff Layton8b10fe62020-08-10 10:21:39 -0400656 len, &fname_crypto_str);
Eric Biggersef1eb3a2016-09-15 17:25:55 -0400657 if (res)
Michael Halcrowb3098482015-04-12 01:07:01 -0400658 printk(KERN_WARNING "Error "
659 "allocating crypto "
660 "buffer--skipping "
661 "crypto\n");
Jaegeuk Kima7550b32016-07-10 14:01:03 -0400662 res = fscrypt_fname_disk_to_usr(dir,
663 0, 0, &de_name,
664 &fname_crypto_str);
Eric Biggersef1eb3a2016-09-15 17:25:55 -0400665 if (res) {
Michael Halcrowb3098482015-04-12 01:07:01 -0400666 printk(KERN_WARNING "Error "
667 "converting filename "
668 "from disk to usr"
669 "\n");
670 name = "??";
671 len = 2;
672 } else {
673 name = fname_crypto_str.name;
674 len = fname_crypto_str.len;
675 }
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -0400676 ext4fs_dirhash(dir, de->name,
677 de->name_len, &h);
Michael Halcrowb3098482015-04-12 01:07:01 -0400678 printk("%*.s:(E)%x.%u ", len, name,
679 h.hash, (unsigned) ((char *) de
680 - base));
Jaegeuk Kima7550b32016-07-10 14:01:03 -0400681 fscrypt_fname_free_buffer(
682 &fname_crypto_str);
Michael Halcrowb3098482015-04-12 01:07:01 -0400683 }
684#else
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700685 int len = de->name_len;
686 char *name = de->name;
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -0400687 ext4fs_dirhash(dir, de->name, de->name_len, &h);
Michael Halcrowb3098482015-04-12 01:07:01 -0400688 printk("%*.s:%x.%u ", len, name, h.hash,
Bernd Schubert265c6a02011-07-16 19:41:23 -0400689 (unsigned) ((char *) de - base));
Michael Halcrowb3098482015-04-12 01:07:01 -0400690#endif
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700691 }
Mingming Cao617ba132006-10-11 01:20:53 -0700692 space += EXT4_DIR_REC_LEN(de->name_len);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700693 names++;
694 }
Wei Yongjun3d0518f2009-02-14 23:01:36 -0500695 de = ext4_next_entry(de, size);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700696 }
Joe Perchesd74f3d22016-10-15 09:57:31 -0400697 printk(KERN_CONT "(%i)\n", names);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700698 return (struct stats) { names, space, 1 };
699}
700
701struct stats dx_show_entries(struct dx_hash_info *hinfo, struct inode *dir,
702 struct dx_entry *entries, int levels)
703{
704 unsigned blocksize = dir->i_sb->s_blocksize;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400705 unsigned count = dx_get_count(entries), names = 0, space = 0, i;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700706 unsigned bcount = 0;
707 struct buffer_head *bh;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700708 printk("%i indexed blocks...\n", count);
709 for (i = 0; i < count; i++, entries++)
710 {
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -0500711 ext4_lblk_t block = dx_get_block(entries);
712 ext4_lblk_t hash = i ? dx_get_hash(entries): 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700713 u32 range = i < count - 1? (dx_get_hash(entries + 1) - hash): ~hash;
714 struct stats stats;
715 printk("%s%3u:%03u hash %8x/%8x ",levels?"":" ", i, block, hash, range);
Theodore Ts'o1c215022014-08-29 20:52:15 -0400716 bh = ext4_bread(NULL,dir, block, 0);
717 if (!bh || IS_ERR(bh))
718 continue;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700719 stats = levels?
720 dx_show_entries(hinfo, dir, ((struct dx_node *) bh->b_data)->entries, levels - 1):
Michael Halcrowb3098482015-04-12 01:07:01 -0400721 dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *)
722 bh->b_data, blocksize, 0);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700723 names += stats.names;
724 space += stats.space;
725 bcount += stats.bcount;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400726 brelse(bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700727 }
728 if (bcount)
Theodore Ts'o60e66792010-05-17 07:00:00 -0400729 printk(KERN_DEBUG "%snames %u, fullness %u (%u%%)\n",
Theodore Ts'o4776004f2008-09-08 23:00:52 -0400730 levels ? "" : " ", names, space/bcount,
731 (space/bcount)*100/blocksize);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700732 return (struct stats) { names, space, bcount};
733}
Vinicius Tintic6c818e2021-02-02 16:28:37 +0000734
735/*
736 * Linear search cross check
737 */
738static inline void htree_rep_invariant_check(struct dx_entry *at,
739 struct dx_entry *target,
740 u32 hash, unsigned int n)
741{
742 while (n--) {
743 dxtrace(printk(KERN_CONT ","));
744 if (dx_get_hash(++at) > hash) {
745 at--;
746 break;
747 }
748 }
749 ASSERT(at == target - 1);
750}
751#else /* DX_DEBUG */
752static inline void htree_rep_invariant_check(struct dx_entry *at,
753 struct dx_entry *target,
754 u32 hash, unsigned int n)
755{
756}
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700757#endif /* DX_DEBUG */
758
759/*
760 * Probe for a directory leaf block to search.
761 *
762 * dx_probe can return ERR_BAD_DX_DIR, which means there was a format
763 * error in the directory index, and the caller should fall back to
764 * searching the directory normally. The callers of dx_probe **MUST**
765 * check for this error code, and make sure it never gets reflected
766 * back to userspace.
767 */
768static struct dx_frame *
Theodore Ts'o5b643f92015-05-18 13:14:47 -0400769dx_probe(struct ext4_filename *fname, struct inode *dir,
Theodore Ts'odd73b5d2014-08-29 20:52:17 -0400770 struct dx_hash_info *hinfo, struct dx_frame *frame_in)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700771{
772 unsigned count, indirect;
773 struct dx_entry *at, *entries, *p, *q, *m;
774 struct dx_root *root;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700775 struct dx_frame *frame = frame_in;
Theodore Ts'odd73b5d2014-08-29 20:52:17 -0400776 struct dx_frame *ret_err = ERR_PTR(ERR_BAD_DX_DIR);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700777 u32 hash;
778
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -0400779 memset(frame_in, 0, EXT4_HTREE_LEVEL * sizeof(frame_in[0]));
Theodore Ts'odd73b5d2014-08-29 20:52:17 -0400780 frame->bh = ext4_read_dirblock(dir, 0, INDEX);
781 if (IS_ERR(frame->bh))
782 return (struct dx_frame *) frame->bh;
783
784 root = (struct dx_root *) frame->bh->b_data;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700785 if (root->info.hash_version != DX_HASH_TEA &&
786 root->info.hash_version != DX_HASH_HALF_MD4 &&
787 root->info.hash_version != DX_HASH_LEGACY) {
Andreas Dilgerb03a2f72015-06-15 14:50:26 -0400788 ext4_warning_inode(dir, "Unrecognised inode hash code %u",
789 root->info.hash_version);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700790 goto fail;
791 }
Theodore Ts'o5b643f92015-05-18 13:14:47 -0400792 if (fname)
793 hinfo = &fname->hinfo;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700794 hinfo->hash_version = root->info.hash_version;
Theodore Ts'of99b2582008-10-28 13:21:44 -0400795 if (hinfo->hash_version <= DX_HASH_TEA)
796 hinfo->hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
Mingming Cao617ba132006-10-11 01:20:53 -0700797 hinfo->seed = EXT4_SB(dir->i_sb)->s_hash_seed;
Theodore Ts'o5b643f92015-05-18 13:14:47 -0400798 if (fname && fname_name(fname))
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -0400799 ext4fs_dirhash(dir, fname_name(fname), fname_len(fname), hinfo);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700800 hash = hinfo->hash;
801
802 if (root->info.unused_flags & 1) {
Andreas Dilgerb03a2f72015-06-15 14:50:26 -0400803 ext4_warning_inode(dir, "Unimplemented hash flags: %#06x",
804 root->info.unused_flags);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700805 goto fail;
806 }
807
Andreas Dilgerb03a2f72015-06-15 14:50:26 -0400808 indirect = root->info.indirect_levels;
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -0400809 if (indirect >= ext4_dir_htree_level(dir->i_sb)) {
810 ext4_warning(dir->i_sb,
811 "Directory (ino: %lu) htree depth %#06x exceed"
812 "supported value", dir->i_ino,
813 ext4_dir_htree_level(dir->i_sb));
814 if (ext4_dir_htree_level(dir->i_sb) < EXT4_HTREE_LEVEL) {
815 ext4_warning(dir->i_sb, "Enable large directory "
816 "feature to access it");
817 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700818 goto fail;
819 }
820
Andreas Dilgerb03a2f72015-06-15 14:50:26 -0400821 entries = (struct dx_entry *)(((char *)&root->info) +
822 root->info.info_length);
Eric Sandeen3d82aba2007-09-18 22:46:38 -0700823
824 if (dx_get_limit(entries) != dx_root_limit(dir,
825 root->info.info_length)) {
Andreas Dilgerb03a2f72015-06-15 14:50:26 -0400826 ext4_warning_inode(dir, "dx entry: limit %u != root limit %u",
827 dx_get_limit(entries),
828 dx_root_limit(dir, root->info.info_length));
Eric Sandeen3d82aba2007-09-18 22:46:38 -0700829 goto fail;
830 }
831
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400832 dxtrace(printk("Look up %x", hash));
Theodore Ts'odd73b5d2014-08-29 20:52:17 -0400833 while (1) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700834 count = dx_get_count(entries);
Eric Sandeen3d82aba2007-09-18 22:46:38 -0700835 if (!count || count > dx_get_limit(entries)) {
Andreas Dilgerb03a2f72015-06-15 14:50:26 -0400836 ext4_warning_inode(dir,
837 "dx entry: count %u beyond limit %u",
838 count, dx_get_limit(entries));
Theodore Ts'odd73b5d2014-08-29 20:52:17 -0400839 goto fail;
Eric Sandeen3d82aba2007-09-18 22:46:38 -0700840 }
841
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700842 p = entries + 1;
843 q = entries + count - 1;
Theodore Ts'odd73b5d2014-08-29 20:52:17 -0400844 while (p <= q) {
Andreas Dilgerb03a2f72015-06-15 14:50:26 -0400845 m = p + (q - p) / 2;
Joe Perchesd74f3d22016-10-15 09:57:31 -0400846 dxtrace(printk(KERN_CONT "."));
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700847 if (dx_get_hash(m) > hash)
848 q = m - 1;
849 else
850 p = m + 1;
851 }
852
Vinicius Tintic6c818e2021-02-02 16:28:37 +0000853 htree_rep_invariant_check(entries, p, hash, count - 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700854
855 at = p - 1;
Joe Perchesd74f3d22016-10-15 09:57:31 -0400856 dxtrace(printk(KERN_CONT " %x->%u\n",
857 at == entries ? 0 : dx_get_hash(at),
Andreas Dilgerb03a2f72015-06-15 14:50:26 -0400858 dx_get_block(at)));
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700859 frame->entries = entries;
860 frame->at = at;
Theodore Ts'odd73b5d2014-08-29 20:52:17 -0400861 if (!indirect--)
862 return frame;
863 frame++;
864 frame->bh = ext4_read_dirblock(dir, dx_get_block(at), INDEX);
865 if (IS_ERR(frame->bh)) {
866 ret_err = (struct dx_frame *) frame->bh;
867 frame->bh = NULL;
868 goto fail;
Carlos Maiolino6d1ab102012-09-27 09:31:33 -0400869 }
Theodore Ts'odd73b5d2014-08-29 20:52:17 -0400870 entries = ((struct dx_node *) frame->bh->b_data)->entries;
Darrick J. Wongdbe89442012-04-29 18:39:10 -0400871
Andreas Dilgerb03a2f72015-06-15 14:50:26 -0400872 if (dx_get_limit(entries) != dx_node_limit(dir)) {
873 ext4_warning_inode(dir,
874 "dx entry: limit %u != node limit %u",
875 dx_get_limit(entries), dx_node_limit(dir));
Theodore Ts'odd73b5d2014-08-29 20:52:17 -0400876 goto fail;
Eric Sandeen3d82aba2007-09-18 22:46:38 -0700877 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700878 }
Theodore Ts'odd73b5d2014-08-29 20:52:17 -0400879fail:
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700880 while (frame >= frame_in) {
881 brelse(frame->bh);
882 frame--;
883 }
Michael Halcrowb3098482015-04-12 01:07:01 -0400884
Theodore Ts'odd73b5d2014-08-29 20:52:17 -0400885 if (ret_err == ERR_PTR(ERR_BAD_DX_DIR))
Andreas Dilgerb03a2f72015-06-15 14:50:26 -0400886 ext4_warning_inode(dir,
887 "Corrupt directory, running e2fsck is recommended");
Theodore Ts'odd73b5d2014-08-29 20:52:17 -0400888 return ret_err;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700889}
890
Andreas Dilgerb03a2f72015-06-15 14:50:26 -0400891static void dx_release(struct dx_frame *frames)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700892{
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -0400893 struct dx_root_info *info;
894 int i;
Sahitya Tummala08fc98a2019-05-10 22:00:33 -0400895 unsigned int indirect_levels;
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -0400896
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700897 if (frames[0].bh == NULL)
898 return;
899
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -0400900 info = &((struct dx_root *)frames[0].bh->b_data)->info;
Sahitya Tummala08fc98a2019-05-10 22:00:33 -0400901 /* save local copy, "info" may be freed after brelse() */
902 indirect_levels = info->indirect_levels;
903 for (i = 0; i <= indirect_levels; i++) {
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -0400904 if (frames[i].bh == NULL)
905 break;
906 brelse(frames[i].bh);
907 frames[i].bh = NULL;
908 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700909}
910
911/*
912 * This function increments the frame pointer to search the next leaf
913 * block, and reads in the necessary intervening nodes if the search
914 * should be necessary. Whether or not the search is necessary is
915 * controlled by the hash parameter. If the hash value is even, then
916 * the search is only continued if the next block starts with that
917 * hash value. This is used if we are searching for a specific file.
918 *
919 * If the hash value is HASH_NB_ALWAYS, then always go to the next block.
920 *
921 * This function returns 1 if the caller should continue to search,
922 * or 0 if it should not. If there is an error reading one of the
923 * index blocks, it will a negative error code.
924 *
925 * If start_hash is non-null, it will be filled in with the starting
926 * hash of the next page.
927 */
Mingming Cao617ba132006-10-11 01:20:53 -0700928static int ext4_htree_next_block(struct inode *dir, __u32 hash,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700929 struct dx_frame *frame,
930 struct dx_frame *frames,
931 __u32 *start_hash)
932{
933 struct dx_frame *p;
934 struct buffer_head *bh;
Theodore Ts'odc6982ff2013-02-14 23:59:26 -0500935 int num_frames = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700936 __u32 bhash;
937
938 p = frame;
939 /*
940 * Find the next leaf page by incrementing the frame pointer.
941 * If we run out of entries in the interior node, loop around and
942 * increment pointer in the parent node. When we break out of
943 * this loop, num_frames indicates the number of interior
944 * nodes need to be read.
945 */
946 while (1) {
947 if (++(p->at) < p->entries + dx_get_count(p->entries))
948 break;
949 if (p == frames)
950 return 0;
951 num_frames++;
952 p--;
953 }
954
955 /*
956 * If the hash is 1, then continue only if the next page has a
957 * continuation hash of any value. This is used for readdir
958 * handling. Otherwise, check to see if the hash matches the
959 * desired contiuation hash. If it doesn't, return since
960 * there's no point to read in the successive index pages.
961 */
962 bhash = dx_get_hash(p->at);
963 if (start_hash)
964 *start_hash = bhash;
965 if ((hash & 1) == 0) {
966 if ((bhash & ~1) != hash)
967 return 0;
968 }
969 /*
970 * If the hash is HASH_NB_ALWAYS, we always go to the next
971 * block so no check is necessary
972 */
973 while (num_frames--) {
Theodore Ts'odc6982ff2013-02-14 23:59:26 -0500974 bh = ext4_read_dirblock(dir, dx_get_block(p->at), INDEX);
975 if (IS_ERR(bh))
976 return PTR_ERR(bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700977 p++;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400978 brelse(p->bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700979 p->bh = bh;
980 p->at = p->entries = ((struct dx_node *) bh->b_data)->entries;
981 }
982 return 1;
983}
984
985
986/*
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700987 * This function fills a red-black tree with information from a
988 * directory block. It returns the number directory entries loaded
989 * into the tree. If there is an error it is returned in err.
990 */
991static int htree_dirblock_to_tree(struct file *dir_file,
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -0500992 struct inode *dir, ext4_lblk_t block,
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700993 struct dx_hash_info *hinfo,
994 __u32 start_hash, __u32 start_minor_hash)
995{
996 struct buffer_head *bh;
Mingming Cao617ba132006-10-11 01:20:53 -0700997 struct ext4_dir_entry_2 *de, *top;
Carlos Maiolino90b0a972012-09-17 23:39:12 -0400998 int err = 0, count = 0;
Jaegeuk Kima7550b32016-07-10 14:01:03 -0400999 struct fscrypt_str fname_crypto_str = FSTR_INIT(NULL, 0), tmp_str;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001000
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05001001 dxtrace(printk(KERN_INFO "In htree dirblock_to_tree: block %lu\n",
1002 (unsigned long)block));
Theodore Ts'o4e19d6b2019-06-20 21:19:02 -04001003 bh = ext4_read_dirblock(dir, block, DIRENT_HTREE);
Theodore Ts'odc6982ff2013-02-14 23:59:26 -05001004 if (IS_ERR(bh))
1005 return PTR_ERR(bh);
Darrick J. Wongb0336e82012-04-29 18:41:10 -04001006
Mingming Cao617ba132006-10-11 01:20:53 -07001007 de = (struct ext4_dir_entry_2 *) bh->b_data;
1008 top = (struct ext4_dir_entry_2 *) ((char *) de +
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001009 dir->i_sb->s_blocksize -
Mingming Cao617ba132006-10-11 01:20:53 -07001010 EXT4_DIR_REC_LEN(0));
Michael Halcrow1f3862b2015-04-12 01:09:03 -04001011 /* Check if the directory is encrypted */
Chandan Rajendra592ddec2018-12-12 15:20:10 +05301012 if (IS_ENCRYPTED(dir)) {
Eric Biggersec0caa972020-12-02 18:20:37 -08001013 err = fscrypt_prepare_readdir(dir);
Theodore Ts'oc936e1e2015-05-31 13:34:22 -04001014 if (err < 0) {
1015 brelse(bh);
1016 return err;
1017 }
Jeff Layton8b10fe62020-08-10 10:21:39 -04001018 err = fscrypt_fname_alloc_buffer(EXT4_NAME_LEN,
1019 &fname_crypto_str);
Michael Halcrow1f3862b2015-04-12 01:09:03 -04001020 if (err < 0) {
Michael Halcrow1f3862b2015-04-12 01:09:03 -04001021 brelse(bh);
1022 return err;
1023 }
1024 }
Eric Biggers64c314f2019-12-09 13:32:25 -08001025
Wei Yongjun3d0518f2009-02-14 23:01:36 -05001026 for (; de < top; de = ext4_next_entry(de, dir->i_sb->s_blocksize)) {
Theodore Ts'of7c21172011-01-10 12:10:55 -05001027 if (ext4_check_dir_entry(dir, NULL, de, bh,
Tao Ma226ba972012-12-10 14:05:58 -05001028 bh->b_data, bh->b_size,
Theodore Ts'ocad3f002010-12-19 22:07:02 -05001029 (block<<EXT4_BLOCK_SIZE_BITS(dir->i_sb))
1030 + ((char *)de - bh->b_data))) {
Al Viro64cb9272013-07-01 08:12:38 -04001031 /* silently ignore the rest of the block */
1032 break;
Eric Sandeene6c40212006-12-06 20:36:28 -08001033 }
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -04001034 ext4fs_dirhash(dir, de->name, de->name_len, hinfo);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001035 if ((hinfo->hash < start_hash) ||
1036 ((hinfo->hash == start_hash) &&
1037 (hinfo->minor_hash < start_minor_hash)))
1038 continue;
1039 if (de->inode == 0)
1040 continue;
Chandan Rajendra592ddec2018-12-12 15:20:10 +05301041 if (!IS_ENCRYPTED(dir)) {
Michael Halcrow1f3862b2015-04-12 01:09:03 -04001042 tmp_str.name = de->name;
1043 tmp_str.len = de->name_len;
1044 err = ext4_htree_store_dirent(dir_file,
1045 hinfo->hash, hinfo->minor_hash, de,
1046 &tmp_str);
1047 } else {
Theodore Ts'od2299592015-05-18 13:15:47 -04001048 int save_len = fname_crypto_str.len;
Jaegeuk Kima7550b32016-07-10 14:01:03 -04001049 struct fscrypt_str de_name = FSTR_INIT(de->name,
1050 de->name_len);
Theodore Ts'od2299592015-05-18 13:15:47 -04001051
Michael Halcrow1f3862b2015-04-12 01:09:03 -04001052 /* Directory is encrypted */
Jaegeuk Kima7550b32016-07-10 14:01:03 -04001053 err = fscrypt_fname_disk_to_usr(dir, hinfo->hash,
1054 hinfo->minor_hash, &de_name,
1055 &fname_crypto_str);
Eric Biggersef1eb3a2016-09-15 17:25:55 -04001056 if (err) {
Michael Halcrow1f3862b2015-04-12 01:09:03 -04001057 count = err;
1058 goto errout;
1059 }
1060 err = ext4_htree_store_dirent(dir_file,
1061 hinfo->hash, hinfo->minor_hash, de,
1062 &fname_crypto_str);
Theodore Ts'od2299592015-05-18 13:15:47 -04001063 fname_crypto_str.len = save_len;
Michael Halcrow1f3862b2015-04-12 01:09:03 -04001064 }
Theodore Ts'o2f61830a2015-04-12 00:56:26 -04001065 if (err != 0) {
Michael Halcrow1f3862b2015-04-12 01:09:03 -04001066 count = err;
1067 goto errout;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001068 }
1069 count++;
1070 }
Michael Halcrow1f3862b2015-04-12 01:09:03 -04001071errout:
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001072 brelse(bh);
Jaegeuk Kima7550b32016-07-10 14:01:03 -04001073 fscrypt_fname_free_buffer(&fname_crypto_str);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001074 return count;
1075}
1076
1077
1078/*
1079 * This function fills a red-black tree with information from a
1080 * directory. We start scanning the directory in hash order, starting
1081 * at start_hash and start_minor_hash.
1082 *
1083 * This function returns the number of entries inserted into the tree,
1084 * or a negative error code.
1085 */
Mingming Cao617ba132006-10-11 01:20:53 -07001086int ext4_htree_fill_tree(struct file *dir_file, __u32 start_hash,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001087 __u32 start_minor_hash, __u32 *next_hash)
1088{
1089 struct dx_hash_info hinfo;
Mingming Cao617ba132006-10-11 01:20:53 -07001090 struct ext4_dir_entry_2 *de;
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04001091 struct dx_frame frames[EXT4_HTREE_LEVEL], *frame;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001092 struct inode *dir;
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05001093 ext4_lblk_t block;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001094 int count = 0;
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05001095 int ret, err;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001096 __u32 hashval;
Jaegeuk Kima7550b32016-07-10 14:01:03 -04001097 struct fscrypt_str tmp_str;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001098
Theodore Ts'o60e66792010-05-17 07:00:00 -04001099 dxtrace(printk(KERN_DEBUG "In htree_fill_tree, start hash: %x:%x\n",
Theodore Ts'o4776004f2008-09-08 23:00:52 -04001100 start_hash, start_minor_hash));
Al Viro496ad9a2013-01-23 17:07:38 -05001101 dir = file_inode(dir_file);
Dmitry Monakhov12e9b892010-05-16 22:00:00 -04001102 if (!(ext4_test_inode_flag(dir, EXT4_INODE_INDEX))) {
Mingming Cao617ba132006-10-11 01:20:53 -07001103 hinfo.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version;
Theodore Ts'of99b2582008-10-28 13:21:44 -04001104 if (hinfo.hash_version <= DX_HASH_TEA)
1105 hinfo.hash_version +=
1106 EXT4_SB(dir->i_sb)->s_hash_unsigned;
Mingming Cao617ba132006-10-11 01:20:53 -07001107 hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
Tao Ma8af0f082013-04-19 17:53:09 -04001108 if (ext4_has_inline_data(dir)) {
1109 int has_inline_data = 1;
Theodore Ts'o7633b082019-06-21 21:57:00 -04001110 count = ext4_inlinedir_to_tree(dir_file, dir, 0,
1111 &hinfo, start_hash,
1112 start_minor_hash,
1113 &has_inline_data);
Tao Ma8af0f082013-04-19 17:53:09 -04001114 if (has_inline_data) {
1115 *next_hash = ~0;
1116 return count;
1117 }
1118 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001119 count = htree_dirblock_to_tree(dir_file, dir, 0, &hinfo,
1120 start_hash, start_minor_hash);
1121 *next_hash = ~0;
1122 return count;
1123 }
1124 hinfo.hash = start_hash;
1125 hinfo.minor_hash = 0;
Theodore Ts'odd73b5d2014-08-29 20:52:17 -04001126 frame = dx_probe(NULL, dir, &hinfo, frames);
1127 if (IS_ERR(frame))
1128 return PTR_ERR(frame);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001129
1130 /* Add '.' and '..' from the htree header */
1131 if (!start_hash && !start_minor_hash) {
Mingming Cao617ba132006-10-11 01:20:53 -07001132 de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data;
Theodore Ts'o2f61830a2015-04-12 00:56:26 -04001133 tmp_str.name = de->name;
1134 tmp_str.len = de->name_len;
1135 err = ext4_htree_store_dirent(dir_file, 0, 0,
1136 de, &tmp_str);
1137 if (err != 0)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001138 goto errout;
1139 count++;
1140 }
1141 if (start_hash < 2 || (start_hash ==2 && start_minor_hash==0)) {
Mingming Cao617ba132006-10-11 01:20:53 -07001142 de = (struct ext4_dir_entry_2 *) frames[0].bh->b_data;
Wei Yongjun3d0518f2009-02-14 23:01:36 -05001143 de = ext4_next_entry(de, dir->i_sb->s_blocksize);
Theodore Ts'o2f61830a2015-04-12 00:56:26 -04001144 tmp_str.name = de->name;
1145 tmp_str.len = de->name_len;
1146 err = ext4_htree_store_dirent(dir_file, 2, 0,
1147 de, &tmp_str);
1148 if (err != 0)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001149 goto errout;
1150 count++;
1151 }
1152
1153 while (1) {
Theodore Ts'o1f60fbe2016-04-23 22:50:07 -04001154 if (fatal_signal_pending(current)) {
1155 err = -ERESTARTSYS;
1156 goto errout;
1157 }
1158 cond_resched();
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001159 block = dx_get_block(frame->at);
1160 ret = htree_dirblock_to_tree(dir_file, dir, block, &hinfo,
1161 start_hash, start_minor_hash);
1162 if (ret < 0) {
1163 err = ret;
1164 goto errout;
1165 }
1166 count += ret;
1167 hashval = ~0;
Mingming Cao617ba132006-10-11 01:20:53 -07001168 ret = ext4_htree_next_block(dir, HASH_NB_ALWAYS,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001169 frame, frames, &hashval);
1170 *next_hash = hashval;
1171 if (ret < 0) {
1172 err = ret;
1173 goto errout;
1174 }
1175 /*
1176 * Stop if: (a) there are no more entries, or
1177 * (b) we have inserted at least one entry and the
1178 * next hash value is not a continuation
1179 */
1180 if ((ret == 0) ||
1181 (count && ((hashval & 1) == 0)))
1182 break;
1183 }
1184 dx_release(frames);
Theodore Ts'o4776004f2008-09-08 23:00:52 -04001185 dxtrace(printk(KERN_DEBUG "Fill tree: returned %d entries, "
1186 "next hash: %x\n", count, *next_hash));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001187 return count;
1188errout:
1189 dx_release(frames);
1190 return (err);
1191}
1192
Tao Ma7335cd32012-12-10 14:05:59 -05001193static inline int search_dirblock(struct buffer_head *bh,
1194 struct inode *dir,
Theodore Ts'o5b643f92015-05-18 13:14:47 -04001195 struct ext4_filename *fname,
Tao Ma7335cd32012-12-10 14:05:59 -05001196 unsigned int offset,
1197 struct ext4_dir_entry_2 **res_dir)
1198{
Theodore Ts'o5b643f92015-05-18 13:14:47 -04001199 return ext4_search_dir(bh, bh->b_data, dir->i_sb->s_blocksize, dir,
Eric Biggersd6b97552017-05-24 18:10:49 -04001200 fname, offset, res_dir);
Tao Ma7335cd32012-12-10 14:05:59 -05001201}
1202
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001203/*
1204 * Directory block splitting, compacting
1205 */
1206
Eric Sandeenef2b02d2007-09-18 22:46:42 -07001207/*
1208 * Create map of hash values, offsets, and sizes, stored at end of block.
1209 * Returns number of entries mapped.
1210 */
Michael Halcrow1f3862b2015-04-12 01:09:03 -04001211static int dx_make_map(struct inode *dir, struct ext4_dir_entry_2 *de,
1212 unsigned blocksize, struct dx_hash_info *hinfo,
Theodore Ts'o8bad4592009-02-14 21:46:54 -05001213 struct dx_map_entry *map_tail)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001214{
1215 int count = 0;
1216 char *base = (char *) de;
1217 struct dx_hash_info h = *hinfo;
1218
Theodore Ts'o8bad4592009-02-14 21:46:54 -05001219 while ((char *) de < base + blocksize) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001220 if (de->name_len && de->inode) {
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -04001221 ext4fs_dirhash(dir, de->name, de->name_len, &h);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001222 map_tail--;
1223 map_tail->hash = h.hash;
Toshiyuki Okajima9aee2282009-06-08 12:41:35 -04001224 map_tail->offs = ((char *) de - base)>>2;
Eric Sandeenef2b02d2007-09-18 22:46:42 -07001225 map_tail->size = le16_to_cpu(de->rec_len);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001226 count++;
1227 cond_resched();
1228 }
1229 /* XXX: do we need to check rec_len == 0 case? -Chris */
Wei Yongjun3d0518f2009-02-14 23:01:36 -05001230 de = ext4_next_entry(de, blocksize);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001231 }
1232 return count;
1233}
1234
Eric Sandeenef2b02d2007-09-18 22:46:42 -07001235/* Sort map by hash value */
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001236static void dx_sort_map (struct dx_map_entry *map, unsigned count)
1237{
Andrew Morton63f57932006-10-11 01:21:24 -07001238 struct dx_map_entry *p, *q, *top = map + count - 1;
1239 int more;
1240 /* Combsort until bubble sort doesn't suck */
1241 while (count > 2) {
1242 count = count*10/13;
1243 if (count - 9 < 2) /* 9, 10 -> 11 */
1244 count = 11;
1245 for (p = top, q = p - count; q >= map; p--, q--)
1246 if (p->hash < q->hash)
1247 swap(*p, *q);
1248 }
1249 /* Garden variety bubble sort */
1250 do {
1251 more = 0;
1252 q = top;
1253 while (q-- > map) {
1254 if (q[1].hash >= q[0].hash)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001255 continue;
Andrew Morton63f57932006-10-11 01:21:24 -07001256 swap(*(q+1), *q);
1257 more = 1;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001258 }
1259 } while(more);
1260}
1261
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05001262static void dx_insert_block(struct dx_frame *frame, u32 hash, ext4_lblk_t block)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001263{
1264 struct dx_entry *entries = frame->entries;
1265 struct dx_entry *old = frame->at, *new = old + 1;
1266 int count = dx_get_count(entries);
1267
Chunguang Xu837c23f2020-11-07 23:58:11 +08001268 ASSERT(count < dx_get_limit(entries));
1269 ASSERT(old < entries + count);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001270 memmove(new + 1, new, (char *)(entries + count) - (char *)(new));
1271 dx_set_hash(new, hash);
1272 dx_set_block(new, block);
1273 dx_set_count(entries, count + 1);
1274}
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001275
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -04001276#ifdef CONFIG_UNICODE
1277/*
1278 * Test whether a case-insensitive directory entry matches the filename
Gabriel Krisman Bertazi3ae72562019-06-19 23:45:09 -04001279 * being searched for. If quick is set, assume the name being looked up
1280 * is already in the casefolded form.
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -04001281 *
1282 * Returns: 0 if the directory entry matches, more than 0 if it
1283 * doesn't match or less than zero on error.
1284 */
1285int ext4_ci_compare(const struct inode *parent, const struct qstr *name,
Gabriel Krisman Bertazi3ae72562019-06-19 23:45:09 -04001286 const struct qstr *entry, bool quick)
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -04001287{
Daniel Rosenbergf8f4acb2020-10-28 05:08:20 +00001288 const struct super_block *sb = parent->i_sb;
1289 const struct unicode_map *um = sb->s_encoding;
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -04001290 int ret;
1291
Gabriel Krisman Bertazi3ae72562019-06-19 23:45:09 -04001292 if (quick)
1293 ret = utf8_strncasecmp_folded(um, name, entry);
1294 else
1295 ret = utf8_strncasecmp(um, name, entry);
1296
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -04001297 if (ret < 0) {
1298 /* Handle invalid character sequence as either an error
1299 * or as an opaque byte sequence.
1300 */
Daniel Rosenbergf8f4acb2020-10-28 05:08:20 +00001301 if (sb_has_strict_encoding(sb))
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -04001302 return -EINVAL;
1303
1304 if (name->len != entry->len)
1305 return 1;
1306
1307 return !!memcmp(name->name, entry->name, name->len);
1308 }
1309
1310 return ret;
1311}
Gabriel Krisman Bertazi3ae72562019-06-19 23:45:09 -04001312
1313void ext4_fname_setup_ci_filename(struct inode *dir, const struct qstr *iname,
1314 struct fscrypt_str *cf_name)
1315{
Gabriel Krisman Bertazi96fcaf82019-07-02 17:53:22 -04001316 int len;
1317
Daniel Rosenbergf8f4acb2020-10-28 05:08:20 +00001318 if (!IS_CASEFOLDED(dir) || !dir->i_sb->s_encoding) {
Gabriel Krisman Bertazi3ae72562019-06-19 23:45:09 -04001319 cf_name->name = NULL;
1320 return;
1321 }
1322
1323 cf_name->name = kmalloc(EXT4_NAME_LEN, GFP_NOFS);
1324 if (!cf_name->name)
1325 return;
1326
Daniel Rosenbergf8f4acb2020-10-28 05:08:20 +00001327 len = utf8_casefold(dir->i_sb->s_encoding,
Gabriel Krisman Bertazi96fcaf82019-07-02 17:53:22 -04001328 iname, cf_name->name,
1329 EXT4_NAME_LEN);
1330 if (len <= 0) {
Gabriel Krisman Bertazi3ae72562019-06-19 23:45:09 -04001331 kfree(cf_name->name);
1332 cf_name->name = NULL;
Gabriel Krisman Bertazi96fcaf82019-07-02 17:53:22 -04001333 return;
Gabriel Krisman Bertazi3ae72562019-06-19 23:45:09 -04001334 }
Gabriel Krisman Bertazi96fcaf82019-07-02 17:53:22 -04001335 cf_name->len = (unsigned) len;
1336
Gabriel Krisman Bertazi3ae72562019-06-19 23:45:09 -04001337}
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -04001338#endif
1339
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001340/*
Eric Biggersd9b9f8d2017-04-24 10:00:13 -07001341 * Test whether a directory entry matches the filename being searched for.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001342 *
Eric Biggersd9b9f8d2017-04-24 10:00:13 -07001343 * Return: %true if the directory entry matches, otherwise %false.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001344 */
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -04001345static inline bool ext4_match(const struct inode *parent,
1346 const struct ext4_filename *fname,
Eric Biggersd9b9f8d2017-04-24 10:00:13 -07001347 const struct ext4_dir_entry_2 *de)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001348{
Eric Biggers067d1022017-04-24 10:00:11 -07001349 struct fscrypt_name f;
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -04001350#ifdef CONFIG_UNICODE
1351 const struct qstr entry = {.name = de->name, .len = de->name_len};
1352#endif
Michael Halcrow1f3862b2015-04-12 01:09:03 -04001353
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001354 if (!de->inode)
Eric Biggersd9b9f8d2017-04-24 10:00:13 -07001355 return false;
Michael Halcrow1f3862b2015-04-12 01:09:03 -04001356
Eric Biggers067d1022017-04-24 10:00:11 -07001357 f.usr_fname = fname->usr_fname;
1358 f.disk_name = fname->disk_name;
Chandan Rajendra643fa962018-12-12 15:20:12 +05301359#ifdef CONFIG_FS_ENCRYPTION
Eric Biggers067d1022017-04-24 10:00:11 -07001360 f.crypto_buf = fname->crypto_buf;
Michael Halcrow1f3862b2015-04-12 01:09:03 -04001361#endif
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -04001362
1363#ifdef CONFIG_UNICODE
Daniel Rosenbergf8f4acb2020-10-28 05:08:20 +00001364 if (parent->i_sb->s_encoding && IS_CASEFOLDED(parent)) {
Gabriel Krisman Bertazi3ae72562019-06-19 23:45:09 -04001365 if (fname->cf_name.name) {
1366 struct qstr cf = {.name = fname->cf_name.name,
1367 .len = fname->cf_name.len};
1368 return !ext4_ci_compare(parent, &cf, &entry, true);
1369 }
1370 return !ext4_ci_compare(parent, fname->usr_fname, &entry,
1371 false);
1372 }
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -04001373#endif
1374
Eric Biggers067d1022017-04-24 10:00:11 -07001375 return fscrypt_match_name(&f, de->name, de->name_len);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001376}
1377
1378/*
1379 * Returns 0 if not found, -1 on failure, and 1 on success
1380 */
Theodore Ts'o5b643f92015-05-18 13:14:47 -04001381int ext4_search_dir(struct buffer_head *bh, char *search_buf, int buf_size,
1382 struct inode *dir, struct ext4_filename *fname,
Theodore Ts'o5b643f92015-05-18 13:14:47 -04001383 unsigned int offset, struct ext4_dir_entry_2 **res_dir)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001384{
Mingming Cao617ba132006-10-11 01:20:53 -07001385 struct ext4_dir_entry_2 * de;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001386 char * dlimit;
1387 int de_len;
Michael Halcrow1f3862b2015-04-12 01:09:03 -04001388
Tao Ma7335cd32012-12-10 14:05:59 -05001389 de = (struct ext4_dir_entry_2 *)search_buf;
1390 dlimit = search_buf + buf_size;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001391 while ((char *) de < dlimit) {
1392 /* this code is executed quadratically often */
1393 /* do minimal checking `by hand' */
Eric Biggersd9b9f8d2017-04-24 10:00:13 -07001394 if ((char *) de + de->name_len <= dlimit &&
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -04001395 ext4_match(dir, fname, de)) {
Eric Biggersd9b9f8d2017-04-24 10:00:13 -07001396 /* found a match - just to be sure, do
1397 * a full check */
Jan Kara7303cb52020-07-31 18:21:35 +02001398 if (ext4_check_dir_entry(dir, NULL, de, bh, search_buf,
1399 buf_size, offset))
Eric Biggersd9b9f8d2017-04-24 10:00:13 -07001400 return -1;
1401 *res_dir = de;
1402 return 1;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001403 }
1404 /* prevent looping on a bad block */
Wei Yongjun3d0518f2009-02-14 23:01:36 -05001405 de_len = ext4_rec_len_from_disk(de->rec_len,
1406 dir->i_sb->s_blocksize);
Eric Biggersd9b9f8d2017-04-24 10:00:13 -07001407 if (de_len <= 0)
1408 return -1;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001409 offset += de_len;
Mingming Cao617ba132006-10-11 01:20:53 -07001410 de = (struct ext4_dir_entry_2 *) ((char *) de + de_len);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001411 }
Eric Biggersd9b9f8d2017-04-24 10:00:13 -07001412 return 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001413}
1414
Darrick J. Wongc6af88032012-11-12 23:51:02 -05001415static int is_dx_internal_node(struct inode *dir, ext4_lblk_t block,
1416 struct ext4_dir_entry *de)
1417{
1418 struct super_block *sb = dir->i_sb;
1419
1420 if (!is_dx(dir))
1421 return 0;
1422 if (block == 0)
1423 return 1;
1424 if (de->inode == 0 &&
1425 ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize) ==
1426 sb->s_blocksize)
1427 return 1;
1428 return 0;
1429}
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001430
1431/*
Eric Biggersb01531d2019-03-20 11:39:13 -07001432 * __ext4_find_entry()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001433 *
1434 * finds an entry in the specified directory with the wanted name. It
1435 * returns the cache buffer in which the entry was found, and the entry
1436 * itself (as a parameter - res_dir). It does NOT read the inode of the
1437 * entry - you'll have to do that yourself if you want to.
1438 *
1439 * The returned buffer_head has ->b_count elevated. The caller is expected
1440 * to brelse() it when appropriate.
1441 */
Eric Biggersb01531d2019-03-20 11:39:13 -07001442static struct buffer_head *__ext4_find_entry(struct inode *dir,
1443 struct ext4_filename *fname,
1444 struct ext4_dir_entry_2 **res_dir,
1445 int *inlined)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001446{
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04001447 struct super_block *sb;
1448 struct buffer_head *bh_use[NAMEI_RA_SIZE];
1449 struct buffer_head *bh, *ret = NULL;
Tahsin Erdogan9699d4f2017-08-06 00:07:01 -04001450 ext4_lblk_t start, block;
Eric Biggersb01531d2019-03-20 11:39:13 -07001451 const u8 *name = fname->usr_fname->name;
Tahsin Erdogan9699d4f2017-08-06 00:07:01 -04001452 size_t ra_max = 0; /* Number of bh's in the readahead
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001453 buffer, bh_use[] */
Tahsin Erdogan9699d4f2017-08-06 00:07:01 -04001454 size_t ra_ptr = 0; /* Current index into readahead
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001455 buffer */
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05001456 ext4_lblk_t nblocks;
Theodore Ts'o5b643f92015-05-18 13:14:47 -04001457 int i, namelen, retval;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001458
1459 *res_dir = NULL;
1460 sb = dir->i_sb;
Eric Biggersb01531d2019-03-20 11:39:13 -07001461 namelen = fname->usr_fname->len;
Mingming Cao617ba132006-10-11 01:20:53 -07001462 if (namelen > EXT4_NAME_LEN)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001463 return NULL;
Tao Mae8e948e2012-12-10 14:06:00 -05001464
1465 if (ext4_has_inline_data(dir)) {
1466 int has_inline_data = 1;
Eric Biggersb01531d2019-03-20 11:39:13 -07001467 ret = ext4_find_inline_entry(dir, fname, res_dir,
Tao Mae8e948e2012-12-10 14:06:00 -05001468 &has_inline_data);
Tao Ma32f7f222012-12-10 14:06:01 -05001469 if (has_inline_data) {
1470 if (inlined)
1471 *inlined = 1;
Theodore Ts'o5b643f92015-05-18 13:14:47 -04001472 goto cleanup_and_exit;
Tao Ma32f7f222012-12-10 14:06:01 -05001473 }
Tao Mae8e948e2012-12-10 14:06:00 -05001474 }
1475
Theodore Ts'o8941ec82010-10-27 21:30:08 -04001476 if ((namelen <= 2) && (name[0] == '.') &&
Aaro Koskinen6d5c3aa2010-12-14 21:45:31 -05001477 (name[1] == '.' || name[1] == '\0')) {
Theodore Ts'o8941ec82010-10-27 21:30:08 -04001478 /*
1479 * "." or ".." will only be in the first block
1480 * NFS may look up ".."; "." should be handled by the VFS
1481 */
1482 block = start = 0;
1483 nblocks = 1;
1484 goto restart;
1485 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001486 if (is_dx(dir)) {
Eric Biggersb01531d2019-03-20 11:39:13 -07001487 ret = ext4_dx_find_entry(dir, fname, res_dir);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001488 /*
1489 * On success, or if the error was file not found,
1490 * return. Otherwise, fall back to doing a search the
1491 * old fashioned way.
1492 */
Theodore Ts'o5b643f92015-05-18 13:14:47 -04001493 if (!IS_ERR(ret) || PTR_ERR(ret) != ERR_BAD_DX_DIR)
1494 goto cleanup_and_exit;
Theodore Ts'o4776004f2008-09-08 23:00:52 -04001495 dxtrace(printk(KERN_DEBUG "ext4_find_entry: dx failed, "
1496 "falling back\n"));
Eric Sandeenf39b3f42018-07-29 17:13:42 -04001497 ret = NULL;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001498 }
Mingming Cao617ba132006-10-11 01:20:53 -07001499 nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
Chandan Rajendra9d5afec2017-12-11 15:00:57 -05001500 if (!nblocks) {
1501 ret = NULL;
1502 goto cleanup_and_exit;
1503 }
Mingming Cao617ba132006-10-11 01:20:53 -07001504 start = EXT4_I(dir)->i_dir_start_lookup;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001505 if (start >= nblocks)
1506 start = 0;
1507 block = start;
1508restart:
1509 do {
1510 /*
1511 * We deal with the read-ahead logic here.
1512 */
Shijie Luo9424ef52020-02-15 03:02:06 -05001513 cond_resched();
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001514 if (ra_ptr >= ra_max) {
1515 /* Refill the readahead buffer */
1516 ra_ptr = 0;
Tahsin Erdogan9699d4f2017-08-06 00:07:01 -04001517 if (block < start)
1518 ra_max = start - block;
1519 else
1520 ra_max = nblocks - block;
1521 ra_max = min(ra_max, ARRAY_SIZE(bh_use));
1522 retval = ext4_bread_batch(dir, block, ra_max,
1523 false /* wait */, bh_use);
1524 if (retval) {
1525 ret = ERR_PTR(retval);
1526 ra_max = 0;
1527 goto cleanup_and_exit;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001528 }
1529 }
1530 if ((bh = bh_use[ra_ptr++]) == NULL)
1531 goto next;
1532 wait_on_buffer(bh);
1533 if (!buffer_uptodate(bh)) {
Theodore Ts'o54d3adb2020-03-28 19:33:43 -04001534 EXT4_ERROR_INODE_ERR(dir, EIO,
1535 "reading directory lblock %lu",
1536 (unsigned long) block);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001537 brelse(bh);
Khazhismel Kumykov6febe6f2017-06-23 00:29:05 -04001538 ret = ERR_PTR(-EIO);
1539 goto cleanup_and_exit;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001540 }
Darrick J. Wongb0336e82012-04-29 18:41:10 -04001541 if (!buffer_verified(bh) &&
Darrick J. Wongc6af88032012-11-12 23:51:02 -05001542 !is_dx_internal_node(dir, block,
1543 (struct ext4_dir_entry *)bh->b_data) &&
Theodore Ts'of036adb2019-06-21 15:49:26 -04001544 !ext4_dirblock_csum_verify(dir, bh)) {
Theodore Ts'o54d3adb2020-03-28 19:33:43 -04001545 EXT4_ERROR_INODE_ERR(dir, EFSBADCRC,
1546 "checksumming directory "
1547 "block %lu", (unsigned long)block);
Darrick J. Wongb0336e82012-04-29 18:41:10 -04001548 brelse(bh);
Theodore Ts'obdddf342017-06-23 00:47:05 -04001549 ret = ERR_PTR(-EFSBADCRC);
1550 goto cleanup_and_exit;
Darrick J. Wongb0336e82012-04-29 18:41:10 -04001551 }
1552 set_buffer_verified(bh);
Eric Biggersb01531d2019-03-20 11:39:13 -07001553 i = search_dirblock(bh, dir, fname,
Mingming Cao617ba132006-10-11 01:20:53 -07001554 block << EXT4_BLOCK_SIZE_BITS(sb), res_dir);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001555 if (i == 1) {
Mingming Cao617ba132006-10-11 01:20:53 -07001556 EXT4_I(dir)->i_dir_start_lookup = block;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001557 ret = bh;
1558 goto cleanup_and_exit;
1559 } else {
1560 brelse(bh);
1561 if (i < 0)
1562 goto cleanup_and_exit;
1563 }
1564 next:
1565 if (++block >= nblocks)
1566 block = 0;
1567 } while (block != start);
1568
1569 /*
1570 * If the directory has grown while we were searching, then
1571 * search the last part of the directory before giving up.
1572 */
1573 block = nblocks;
Mingming Cao617ba132006-10-11 01:20:53 -07001574 nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001575 if (block < nblocks) {
1576 start = 0;
1577 goto restart;
1578 }
1579
1580cleanup_and_exit:
1581 /* Clean up the read-ahead blocks */
1582 for (; ra_ptr < ra_max; ra_ptr++)
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04001583 brelse(bh_use[ra_ptr]);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001584 return ret;
1585}
1586
Eric Biggersb01531d2019-03-20 11:39:13 -07001587static struct buffer_head *ext4_find_entry(struct inode *dir,
1588 const struct qstr *d_name,
1589 struct ext4_dir_entry_2 **res_dir,
1590 int *inlined)
1591{
1592 int err;
1593 struct ext4_filename fname;
1594 struct buffer_head *bh;
1595
1596 err = ext4_fname_setup_filename(dir, d_name, 1, &fname);
1597 if (err == -ENOENT)
1598 return NULL;
1599 if (err)
1600 return ERR_PTR(err);
1601
1602 bh = __ext4_find_entry(dir, &fname, res_dir, inlined);
1603
1604 ext4_fname_free_filename(&fname);
1605 return bh;
1606}
1607
1608static struct buffer_head *ext4_lookup_entry(struct inode *dir,
1609 struct dentry *dentry,
1610 struct ext4_dir_entry_2 **res_dir)
1611{
1612 int err;
1613 struct ext4_filename fname;
1614 struct buffer_head *bh;
1615
1616 err = ext4_fname_prepare_lookup(dir, dentry, &fname);
Daniel Rosenbergbb9cd912020-11-19 06:09:03 +00001617 generic_set_encrypted_ci_d_ops(dentry);
Eric Biggersb01531d2019-03-20 11:39:13 -07001618 if (err == -ENOENT)
1619 return NULL;
1620 if (err)
1621 return ERR_PTR(err);
1622
1623 bh = __ext4_find_entry(dir, &fname, res_dir, NULL);
1624
1625 ext4_fname_free_filename(&fname);
1626 return bh;
1627}
1628
Theodore Ts'o5b643f92015-05-18 13:14:47 -04001629static struct buffer_head * ext4_dx_find_entry(struct inode *dir,
1630 struct ext4_filename *fname,
1631 struct ext4_dir_entry_2 **res_dir)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001632{
Theodore Ts'o8941ec82010-10-27 21:30:08 -04001633 struct super_block * sb = dir->i_sb;
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04001634 struct dx_frame frames[EXT4_HTREE_LEVEL], *frame;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001635 struct buffer_head *bh;
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05001636 ext4_lblk_t block;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001637 int retval;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001638
Chandan Rajendra643fa962018-12-12 15:20:12 +05301639#ifdef CONFIG_FS_ENCRYPTION
Michael Halcrow1f3862b2015-04-12 01:09:03 -04001640 *res_dir = NULL;
1641#endif
Theodore Ts'o5b643f92015-05-18 13:14:47 -04001642 frame = dx_probe(fname, dir, NULL, frames);
Theodore Ts'odd73b5d2014-08-29 20:52:17 -04001643 if (IS_ERR(frame))
1644 return (struct buffer_head *) frame;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001645 do {
1646 block = dx_get_block(frame->at);
Theodore Ts'o4e19d6b2019-06-20 21:19:02 -04001647 bh = ext4_read_dirblock(dir, block, DIRENT_HTREE);
Theodore Ts'o537d8f92014-08-29 20:49:51 -04001648 if (IS_ERR(bh))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001649 goto errout;
Theodore Ts'o537d8f92014-08-29 20:49:51 -04001650
Eric Biggersd6b97552017-05-24 18:10:49 -04001651 retval = search_dirblock(bh, dir, fname,
Theodore Ts'o7845c042010-10-27 21:30:08 -04001652 block << EXT4_BLOCK_SIZE_BITS(sb),
1653 res_dir);
Theodore Ts'o537d8f92014-08-29 20:49:51 -04001654 if (retval == 1)
1655 goto success;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04001656 brelse(bh);
Theodore Ts'o7845c042010-10-27 21:30:08 -04001657 if (retval == -1) {
Theodore Ts'o537d8f92014-08-29 20:49:51 -04001658 bh = ERR_PTR(ERR_BAD_DX_DIR);
Theodore Ts'o7845c042010-10-27 21:30:08 -04001659 goto errout;
1660 }
1661
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001662 /* Check to see if we should continue to search */
Theodore Ts'o5b643f92015-05-18 13:14:47 -04001663 retval = ext4_htree_next_block(dir, fname->hinfo.hash, frame,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001664 frames, NULL);
1665 if (retval < 0) {
Andreas Dilgerb03a2f72015-06-15 14:50:26 -04001666 ext4_warning_inode(dir,
1667 "error %d reading directory index block",
1668 retval);
Theodore Ts'o537d8f92014-08-29 20:49:51 -04001669 bh = ERR_PTR(retval);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001670 goto errout;
1671 }
1672 } while (retval == 1);
1673
Theodore Ts'o537d8f92014-08-29 20:49:51 -04001674 bh = NULL;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001675errout:
Eric Biggersd6b97552017-05-24 18:10:49 -04001676 dxtrace(printk(KERN_DEBUG "%s not found\n", fname->usr_fname->name));
Theodore Ts'o537d8f92014-08-29 20:49:51 -04001677success:
1678 dx_release(frames);
1679 return bh;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001680}
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001681
Al Viro00cd8dd2012-06-10 17:13:09 -04001682static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001683{
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04001684 struct inode *inode;
1685 struct ext4_dir_entry_2 *de;
1686 struct buffer_head *bh;
Theodore Ts'o28b4c262016-02-07 19:35:05 -05001687
Eric Biggers89904272017-10-18 20:21:58 -04001688 if (dentry->d_name.len > EXT4_NAME_LEN)
1689 return ERR_PTR(-ENAMETOOLONG);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001690
Eric Biggersb01531d2019-03-20 11:39:13 -07001691 bh = ext4_lookup_entry(dir, dentry, &de);
Theodore Ts'o36de9282014-08-23 17:47:19 -04001692 if (IS_ERR(bh))
Al Viroe884bce2018-10-10 16:41:40 -04001693 return ERR_CAST(bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001694 inode = NULL;
1695 if (bh) {
Theodore Ts'o498e5f22008-11-05 00:14:04 -05001696 __u32 ino = le32_to_cpu(de->inode);
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04001697 brelse(bh);
Mingming Cao617ba132006-10-11 01:20:53 -07001698 if (!ext4_valid_inum(dir->i_sb, ino)) {
Theodore Ts'o24676da2010-05-16 21:00:00 -04001699 EXT4_ERROR_INODE(dir, "bad inode number: %u", ino);
Darrick J. Wong6a797d22015-10-17 16:16:04 -04001700 return ERR_PTR(-EFSCORRUPTED);
Vasily Averina6c15c22007-07-15 23:40:46 -07001701 }
Andreas Dilger7e936b72012-05-28 17:02:25 -04001702 if (unlikely(ino == dir->i_ino)) {
David Howellsa34e15c2014-01-06 14:04:23 -05001703 EXT4_ERROR_INODE(dir, "'%pd' linked to parent dir",
1704 dentry);
Darrick J. Wong6a797d22015-10-17 16:16:04 -04001705 return ERR_PTR(-EFSCORRUPTED);
Andreas Dilger7e936b72012-05-28 17:02:25 -04001706 }
Theodore Ts'o8a363972018-12-19 12:29:13 -05001707 inode = ext4_iget(dir->i_sb, ino, EXT4_IGET_NORMAL);
Al Viroa9049372011-07-08 21:20:11 -04001708 if (inode == ERR_PTR(-ESTALE)) {
1709 EXT4_ERROR_INODE(dir,
1710 "deleted inode referenced: %u",
1711 ino);
Darrick J. Wong6a797d22015-10-17 16:16:04 -04001712 return ERR_PTR(-EFSCORRUPTED);
Bryan Donlane6f009b2009-02-22 21:20:25 -05001713 }
Chandan Rajendra592ddec2018-12-12 15:20:10 +05301714 if (!IS_ERR(inode) && IS_ENCRYPTED(dir) &&
Theodore Ts'off978b02016-02-08 00:54:26 -05001715 (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
Jaegeuk Kima7550b32016-07-10 14:01:03 -04001716 !fscrypt_has_permitted_context(dir, inode)) {
Theodore Ts'od9cdc9032015-04-12 00:55:08 -04001717 ext4_warning(inode->i_sb,
Jakub Wilk8d2ae1c2016-04-27 01:11:21 -04001718 "Inconsistent encryption contexts: %lu/%lu",
Eric Biggers8c680842017-04-07 10:58:38 -07001719 dir->i_ino, inode->i_ino);
Eric Biggersdd01b692017-02-01 21:07:11 -05001720 iput(inode);
Theodore Ts'od9cdc9032015-04-12 00:55:08 -04001721 return ERR_PTR(-EPERM);
1722 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001723 }
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -04001724
1725#ifdef CONFIG_UNICODE
1726 if (!inode && IS_CASEFOLDED(dir)) {
1727 /* Eventually we want to call d_add_ci(dentry, NULL)
1728 * for negative dentries in the encoding case as
1729 * well. For now, prevent the negative dentry
1730 * from being cached.
1731 */
1732 return NULL;
1733 }
1734#endif
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001735 return d_splice_alias(inode, dentry);
1736}
1737
1738
Mingming Cao617ba132006-10-11 01:20:53 -07001739struct dentry *ext4_get_parent(struct dentry *child)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001740{
Theodore Ts'o498e5f22008-11-05 00:14:04 -05001741 __u32 ino;
Linus Torvalds26fe5752012-05-10 13:14:12 -07001742 static const struct qstr dotdot = QSTR_INIT("..", 2);
Mingming Cao617ba132006-10-11 01:20:53 -07001743 struct ext4_dir_entry_2 * de;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001744 struct buffer_head *bh;
1745
David Howells2b0143b2015-03-17 22:25:59 +00001746 bh = ext4_find_entry(d_inode(child), &dotdot, &de, NULL);
Theodore Ts'o36de9282014-08-23 17:47:19 -04001747 if (IS_ERR(bh))
Al Viroe884bce2018-10-10 16:41:40 -04001748 return ERR_CAST(bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001749 if (!bh)
1750 return ERR_PTR(-ENOENT);
1751 ino = le32_to_cpu(de->inode);
1752 brelse(bh);
1753
Al Virofc640052016-04-10 01:33:30 -04001754 if (!ext4_valid_inum(child->d_sb, ino)) {
David Howells2b0143b2015-03-17 22:25:59 +00001755 EXT4_ERROR_INODE(d_inode(child),
Theodore Ts'o24676da2010-05-16 21:00:00 -04001756 "bad parent inode number: %u", ino);
Darrick J. Wong6a797d22015-10-17 16:16:04 -04001757 return ERR_PTR(-EFSCORRUPTED);
Vasily Averina6c15c22007-07-15 23:40:46 -07001758 }
1759
Theodore Ts'o8a363972018-12-19 12:29:13 -05001760 return d_obtain_alias(ext4_iget(child->d_sb, ino, EXT4_IGET_NORMAL));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001761}
1762
Eric Sandeenef2b02d2007-09-18 22:46:42 -07001763/*
1764 * Move count entries from end of map between two memory locations.
1765 * Returns pointer to last entry moved.
1766 */
Mingming Cao617ba132006-10-11 01:20:53 -07001767static struct ext4_dir_entry_2 *
Wei Yongjun3d0518f2009-02-14 23:01:36 -05001768dx_move_dirents(char *from, char *to, struct dx_map_entry *map, int count,
1769 unsigned blocksize)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001770{
1771 unsigned rec_len = 0;
1772
1773 while (count--) {
Theodore Ts'o60e66792010-05-17 07:00:00 -04001774 struct ext4_dir_entry_2 *de = (struct ext4_dir_entry_2 *)
Toshiyuki Okajima9aee2282009-06-08 12:41:35 -04001775 (from + (map->offs<<2));
Mingming Cao617ba132006-10-11 01:20:53 -07001776 rec_len = EXT4_DIR_REC_LEN(de->name_len);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001777 memcpy (to, de, rec_len);
Mingming Cao617ba132006-10-11 01:20:53 -07001778 ((struct ext4_dir_entry_2 *) to)->rec_len =
Wei Yongjun3d0518f2009-02-14 23:01:36 -05001779 ext4_rec_len_to_disk(rec_len, blocksize);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001780 de->inode = 0;
1781 map++;
1782 to += rec_len;
1783 }
Mingming Cao617ba132006-10-11 01:20:53 -07001784 return (struct ext4_dir_entry_2 *) (to - rec_len);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001785}
1786
Eric Sandeenef2b02d2007-09-18 22:46:42 -07001787/*
1788 * Compact each dir entry in the range to the minimal rec_len.
1789 * Returns pointer to last entry in range.
1790 */
Theodore Ts'o8bad4592009-02-14 21:46:54 -05001791static struct ext4_dir_entry_2* dx_pack_dirents(char *base, unsigned blocksize)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001792{
Mingming Cao617ba132006-10-11 01:20:53 -07001793 struct ext4_dir_entry_2 *next, *to, *prev, *de = (struct ext4_dir_entry_2 *) base;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001794 unsigned rec_len = 0;
1795
1796 prev = to = de;
Theodore Ts'o8bad4592009-02-14 21:46:54 -05001797 while ((char*)de < base + blocksize) {
Wei Yongjun3d0518f2009-02-14 23:01:36 -05001798 next = ext4_next_entry(de, blocksize);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001799 if (de->inode && de->name_len) {
Mingming Cao617ba132006-10-11 01:20:53 -07001800 rec_len = EXT4_DIR_REC_LEN(de->name_len);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001801 if (de > to)
1802 memmove(to, de, rec_len);
Wei Yongjun3d0518f2009-02-14 23:01:36 -05001803 to->rec_len = ext4_rec_len_to_disk(rec_len, blocksize);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001804 prev = to;
Mingming Cao617ba132006-10-11 01:20:53 -07001805 to = (struct ext4_dir_entry_2 *) (((char *) to) + rec_len);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001806 }
1807 de = next;
1808 }
1809 return prev;
1810}
1811
Eric Sandeenef2b02d2007-09-18 22:46:42 -07001812/*
1813 * Split a full leaf block to make room for a new dir entry.
1814 * Allocate a new block, and move entries so that they are approx. equally full.
1815 * Returns pointer to de in block into which the new entry will be inserted.
1816 */
Mingming Cao617ba132006-10-11 01:20:53 -07001817static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001818 struct buffer_head **bh,struct dx_frame *frame,
Theodore Ts'of8b3b592014-08-29 20:52:18 -04001819 struct dx_hash_info *hinfo)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001820{
1821 unsigned blocksize = dir->i_sb->s_blocksize;
1822 unsigned count, continued;
1823 struct buffer_head *bh2;
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05001824 ext4_lblk_t newblock;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001825 u32 hash2;
1826 struct dx_map_entry *map;
1827 char *data1 = (*bh)->b_data, *data2;
Theodore Ts'o59e315b2008-12-06 16:58:39 -05001828 unsigned split, move, size;
Mingming Cao617ba132006-10-11 01:20:53 -07001829 struct ext4_dir_entry_2 *de = NULL, *de2;
Darrick J. Wongb0336e82012-04-29 18:41:10 -04001830 int csum_size = 0;
Theodore Ts'o59e315b2008-12-06 16:58:39 -05001831 int err = 0, i;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001832
Dmitry Monakhov9aa5d32b2014-10-13 03:36:16 -04001833 if (ext4_has_metadata_csum(dir->i_sb))
Darrick J. Wongb0336e82012-04-29 18:41:10 -04001834 csum_size = sizeof(struct ext4_dir_entry_tail);
1835
Theodore Ts'o0f70b402013-02-15 03:35:57 -05001836 bh2 = ext4_append(handle, dir, &newblock);
1837 if (IS_ERR(bh2)) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001838 brelse(*bh);
1839 *bh = NULL;
Theodore Ts'of8b3b592014-08-29 20:52:18 -04001840 return (struct ext4_dir_entry_2 *) bh2;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001841 }
1842
1843 BUFFER_TRACE(*bh, "get_write_access");
Mingming Cao617ba132006-10-11 01:20:53 -07001844 err = ext4_journal_get_write_access(handle, *bh);
Dmitriy Monakhovfedee542007-05-08 00:25:34 -07001845 if (err)
1846 goto journal_error;
1847
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001848 BUFFER_TRACE(frame->bh, "get_write_access");
Mingming Cao617ba132006-10-11 01:20:53 -07001849 err = ext4_journal_get_write_access(handle, frame->bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001850 if (err)
1851 goto journal_error;
1852
1853 data2 = bh2->b_data;
1854
1855 /* create map in the end of data2 block */
1856 map = (struct dx_map_entry *) (data2 + blocksize);
Michael Halcrow1f3862b2015-04-12 01:09:03 -04001857 count = dx_make_map(dir, (struct ext4_dir_entry_2 *) data1,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001858 blocksize, hinfo, map);
1859 map -= count;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04001860 dx_sort_map(map, count);
Eric Sandeen58723312020-06-17 14:19:04 -05001861 /* Ensure that neither split block is over half full */
Eric Sandeenef2b02d2007-09-18 22:46:42 -07001862 size = 0;
1863 move = 0;
1864 for (i = count-1; i >= 0; i--) {
1865 /* is more than half of this entry in 2nd half of the block? */
1866 if (size + map[i].size/2 > blocksize/2)
1867 break;
1868 size += map[i].size;
1869 move++;
1870 }
Eric Sandeen58723312020-06-17 14:19:04 -05001871 /*
1872 * map index at which we will split
1873 *
1874 * If the sum of active entries didn't exceed half the block size, just
1875 * split it in half by count; each resulting block will have at least
1876 * half the space free.
1877 */
1878 if (i > 0)
1879 split = count - move;
1880 else
1881 split = count/2;
1882
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001883 hash2 = map[split].hash;
1884 continued = hash2 == map[split - 1].hash;
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05001885 dxtrace(printk(KERN_INFO "Split block %lu at %x, %i/%i\n",
1886 (unsigned long)dx_get_block(frame->at),
1887 hash2, split, count-split));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001888
1889 /* Fancy dance to stay within two buffers */
Michael Halcrow1f3862b2015-04-12 01:09:03 -04001890 de2 = dx_move_dirents(data1, data2, map + split, count - split,
1891 blocksize);
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04001892 de = dx_pack_dirents(data1, blocksize);
Darrick J. Wongb0336e82012-04-29 18:41:10 -04001893 de->rec_len = ext4_rec_len_to_disk(data1 + (blocksize - csum_size) -
1894 (char *) de,
Wei Yongjun3d0518f2009-02-14 23:01:36 -05001895 blocksize);
Darrick J. Wongb0336e82012-04-29 18:41:10 -04001896 de2->rec_len = ext4_rec_len_to_disk(data2 + (blocksize - csum_size) -
1897 (char *) de2,
Wei Yongjun3d0518f2009-02-14 23:01:36 -05001898 blocksize);
Darrick J. Wongb0336e82012-04-29 18:41:10 -04001899 if (csum_size) {
Theodore Ts'oddce3b92019-06-21 16:31:47 -04001900 ext4_initialize_dirent_tail(*bh, blocksize);
1901 ext4_initialize_dirent_tail(bh2, blocksize);
Darrick J. Wongb0336e82012-04-29 18:41:10 -04001902 }
1903
Michael Halcrowb3098482015-04-12 01:07:01 -04001904 dxtrace(dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *) data1,
1905 blocksize, 1));
1906 dxtrace(dx_show_leaf(dir, hinfo, (struct ext4_dir_entry_2 *) data2,
1907 blocksize, 1));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001908
1909 /* Which block gets the new entry? */
Theodore Ts'of8b3b592014-08-29 20:52:18 -04001910 if (hinfo->hash >= hash2) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001911 swap(*bh, bh2);
1912 de = de2;
1913 }
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04001914 dx_insert_block(frame, hash2 + continued, newblock);
Theodore Ts'of036adb2019-06-21 15:49:26 -04001915 err = ext4_handle_dirty_dirblock(handle, dir, bh2);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001916 if (err)
1917 goto journal_error;
Darrick J. Wongdbe89442012-04-29 18:39:10 -04001918 err = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001919 if (err)
1920 goto journal_error;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04001921 brelse(bh2);
1922 dxtrace(dx_show_index("frame", frame->entries));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001923 return de;
Dmitriy Monakhovfedee542007-05-08 00:25:34 -07001924
1925journal_error:
1926 brelse(*bh);
1927 brelse(bh2);
1928 *bh = NULL;
1929 ext4_std_error(dir->i_sb, err);
Theodore Ts'of8b3b592014-08-29 20:52:18 -04001930 return ERR_PTR(err);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001931}
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001932
Tao Ma978fef92012-12-10 14:05:58 -05001933int ext4_find_dest_de(struct inode *dir, struct inode *inode,
1934 struct buffer_head *bh,
1935 void *buf, int buf_size,
Theodore Ts'o5b643f92015-05-18 13:14:47 -04001936 struct ext4_filename *fname,
Tao Ma978fef92012-12-10 14:05:58 -05001937 struct ext4_dir_entry_2 **dest_de)
1938{
1939 struct ext4_dir_entry_2 *de;
Theodore Ts'o5b643f92015-05-18 13:14:47 -04001940 unsigned short reclen = EXT4_DIR_REC_LEN(fname_len(fname));
Tao Ma978fef92012-12-10 14:05:58 -05001941 int nlen, rlen;
1942 unsigned int offset = 0;
1943 char *top;
Michael Halcrow1f3862b2015-04-12 01:09:03 -04001944
Tao Ma978fef92012-12-10 14:05:58 -05001945 de = (struct ext4_dir_entry_2 *)buf;
1946 top = buf + buf_size - reclen;
1947 while ((char *) de <= top) {
1948 if (ext4_check_dir_entry(dir, NULL, de, bh,
Eric Biggersd9b9f8d2017-04-24 10:00:13 -07001949 buf, buf_size, offset))
1950 return -EFSCORRUPTED;
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -04001951 if (ext4_match(dir, fname, de))
Eric Biggersd9b9f8d2017-04-24 10:00:13 -07001952 return -EEXIST;
Tao Ma978fef92012-12-10 14:05:58 -05001953 nlen = EXT4_DIR_REC_LEN(de->name_len);
1954 rlen = ext4_rec_len_from_disk(de->rec_len, buf_size);
1955 if ((de->inode ? rlen - nlen : rlen) >= reclen)
1956 break;
1957 de = (struct ext4_dir_entry_2 *)((char *)de + rlen);
1958 offset += rlen;
1959 }
Michael Halcrow1f3862b2015-04-12 01:09:03 -04001960 if ((char *) de > top)
Eric Biggersd9b9f8d2017-04-24 10:00:13 -07001961 return -ENOSPC;
1962
1963 *dest_de = de;
1964 return 0;
Tao Ma978fef92012-12-10 14:05:58 -05001965}
1966
Eric Biggers1bc0af62017-04-29 23:27:26 -04001967void ext4_insert_dentry(struct inode *inode,
1968 struct ext4_dir_entry_2 *de,
1969 int buf_size,
1970 struct ext4_filename *fname)
Tao Ma978fef92012-12-10 14:05:58 -05001971{
1972
1973 int nlen, rlen;
1974
1975 nlen = EXT4_DIR_REC_LEN(de->name_len);
1976 rlen = ext4_rec_len_from_disk(de->rec_len, buf_size);
1977 if (de->inode) {
1978 struct ext4_dir_entry_2 *de1 =
Michael Halcrow4bdfc872015-04-12 00:56:28 -04001979 (struct ext4_dir_entry_2 *)((char *)de + nlen);
Tao Ma978fef92012-12-10 14:05:58 -05001980 de1->rec_len = ext4_rec_len_to_disk(rlen - nlen, buf_size);
1981 de->rec_len = ext4_rec_len_to_disk(nlen, buf_size);
1982 de = de1;
1983 }
1984 de->file_type = EXT4_FT_UNKNOWN;
1985 de->inode = cpu_to_le32(inode->i_ino);
1986 ext4_set_de_type(inode->i_sb, de, inode->i_mode);
Theodore Ts'o5b643f92015-05-18 13:14:47 -04001987 de->name_len = fname_len(fname);
1988 memcpy(de->name, fname_name(fname), fname_len(fname));
Tao Ma978fef92012-12-10 14:05:58 -05001989}
Michael Halcrow4bdfc872015-04-12 00:56:28 -04001990
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001991/*
1992 * Add a new entry into a directory (leaf) block. If de is non-NULL,
1993 * it points to a directory entry which is guaranteed to be large
1994 * enough for new directory entry. If de is NULL, then
1995 * add_dirent_to_buf will attempt search the directory block for
1996 * space. It will return -ENOSPC if no space is available, and -EIO
1997 * and -EEXIST if directory entry already exists.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001998 */
Theodore Ts'o5b643f92015-05-18 13:14:47 -04001999static int add_dirent_to_buf(handle_t *handle, struct ext4_filename *fname,
2000 struct inode *dir,
Mingming Cao617ba132006-10-11 01:20:53 -07002001 struct inode *inode, struct ext4_dir_entry_2 *de,
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04002002 struct buffer_head *bh)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002003{
Wei Yongjun3d0518f2009-02-14 23:01:36 -05002004 unsigned int blocksize = dir->i_sb->s_blocksize;
Darrick J. Wongb0336e82012-04-29 18:41:10 -04002005 int csum_size = 0;
Harshad Shirwadkar4209ae12020-04-26 18:34:37 -07002006 int err, err2;
Darrick J. Wongb0336e82012-04-29 18:41:10 -04002007
Dmitry Monakhov9aa5d32b2014-10-13 03:36:16 -04002008 if (ext4_has_metadata_csum(inode->i_sb))
Darrick J. Wongb0336e82012-04-29 18:41:10 -04002009 csum_size = sizeof(struct ext4_dir_entry_tail);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002010
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002011 if (!de) {
Theodore Ts'o5b643f92015-05-18 13:14:47 -04002012 err = ext4_find_dest_de(dir, inode, bh, bh->b_data,
2013 blocksize - csum_size, fname, &de);
Tao Ma978fef92012-12-10 14:05:58 -05002014 if (err)
2015 return err;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002016 }
2017 BUFFER_TRACE(bh, "get_write_access");
Mingming Cao617ba132006-10-11 01:20:53 -07002018 err = ext4_journal_get_write_access(handle, bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002019 if (err) {
Mingming Cao617ba132006-10-11 01:20:53 -07002020 ext4_std_error(dir->i_sb, err);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002021 return err;
2022 }
2023
Eric Biggers1bc0af62017-04-29 23:27:26 -04002024 /* By now the buffer is marked for journaling */
2025 ext4_insert_dentry(inode, de, blocksize, fname);
Tao Ma978fef92012-12-10 14:05:58 -05002026
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002027 /*
2028 * XXX shouldn't update any times until successful
2029 * completion of syscall, but too many callers depend
2030 * on this.
2031 *
2032 * XXX similarly, too many callers depend on
Mingming Cao617ba132006-10-11 01:20:53 -07002033 * ext4_new_inode() setting the times, but error
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002034 * recovery deletes the inode, so the worst that can
2035 * happen is that the times are slightly out of date
2036 * and/or different from the directory change time.
2037 */
Deepa Dinamanieeca7ea2016-11-14 21:40:10 -05002038 dir->i_mtime = dir->i_ctime = current_time(dir);
Mingming Cao617ba132006-10-11 01:20:53 -07002039 ext4_update_dx_flag(dir);
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04002040 inode_inc_iversion(dir);
Harshad Shirwadkar4209ae12020-04-26 18:34:37 -07002041 err2 = ext4_mark_inode_dirty(handle, dir);
Frank Mayhar03901312009-01-07 00:06:22 -05002042 BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
Theodore Ts'of036adb2019-06-21 15:49:26 -04002043 err = ext4_handle_dirty_dirblock(handle, dir, bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002044 if (err)
Mingming Cao617ba132006-10-11 01:20:53 -07002045 ext4_std_error(dir->i_sb, err);
Harshad Shirwadkar4209ae12020-04-26 18:34:37 -07002046 return err ? err : err2;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002047}
2048
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002049/*
2050 * This converts a one block unindexed directory to a 3 block indexed
2051 * directory, and adds the dentry to the indexed directory.
2052 */
Theodore Ts'o5b643f92015-05-18 13:14:47 -04002053static int make_indexed_dir(handle_t *handle, struct ext4_filename *fname,
Theodore Ts'o56a04912016-01-08 16:00:31 -05002054 struct inode *dir,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002055 struct inode *inode, struct buffer_head *bh)
2056{
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002057 struct buffer_head *bh2;
2058 struct dx_root *root;
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04002059 struct dx_frame frames[EXT4_HTREE_LEVEL], *frame;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002060 struct dx_entry *entries;
Mingming Cao617ba132006-10-11 01:20:53 -07002061 struct ext4_dir_entry_2 *de, *de2;
Theodore Ts'oddce3b92019-06-21 16:31:47 -04002062 char *data2, *top;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002063 unsigned len;
2064 int retval;
2065 unsigned blocksize;
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05002066 ext4_lblk_t block;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002067 struct fake_dirent *fde;
Michael Halcrow4bdfc872015-04-12 00:56:28 -04002068 int csum_size = 0;
2069
Dmitry Monakhov9aa5d32b2014-10-13 03:36:16 -04002070 if (ext4_has_metadata_csum(inode->i_sb))
Darrick J. Wongb0336e82012-04-29 18:41:10 -04002071 csum_size = sizeof(struct ext4_dir_entry_tail);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002072
2073 blocksize = dir->i_sb->s_blocksize;
Theodore Ts'oe6b8bc02009-01-16 11:13:40 -05002074 dxtrace(printk(KERN_DEBUG "Creating index: inode %lu\n", dir->i_ino));
liang xie5d601252014-05-12 22:06:43 -04002075 BUFFER_TRACE(bh, "get_write_access");
Mingming Cao617ba132006-10-11 01:20:53 -07002076 retval = ext4_journal_get_write_access(handle, bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002077 if (retval) {
Mingming Cao617ba132006-10-11 01:20:53 -07002078 ext4_std_error(dir->i_sb, retval);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002079 brelse(bh);
2080 return retval;
2081 }
2082 root = (struct dx_root *) bh->b_data;
2083
Theodore Ts'oe6b8bc02009-01-16 11:13:40 -05002084 /* The 0th block becomes the root, move the dirents out */
2085 fde = &root->dotdot;
2086 de = (struct ext4_dir_entry_2 *)((char *)fde +
Wei Yongjun3d0518f2009-02-14 23:01:36 -05002087 ext4_rec_len_from_disk(fde->rec_len, blocksize));
Theodore Ts'oe6b8bc02009-01-16 11:13:40 -05002088 if ((char *) de >= (((char *) root) + blocksize)) {
Theodore Ts'o24676da2010-05-16 21:00:00 -04002089 EXT4_ERROR_INODE(dir, "invalid rec_len for '..'");
Theodore Ts'oe6b8bc02009-01-16 11:13:40 -05002090 brelse(bh);
Darrick J. Wong6a797d22015-10-17 16:16:04 -04002091 return -EFSCORRUPTED;
Theodore Ts'oe6b8bc02009-01-16 11:13:40 -05002092 }
Darrick J. Wongb0336e82012-04-29 18:41:10 -04002093 len = ((char *) root) + (blocksize - csum_size) - (char *) de;
Theodore Ts'oe6b8bc02009-01-16 11:13:40 -05002094
2095 /* Allocate new block for the 0th block's dirents */
Theodore Ts'o0f70b402013-02-15 03:35:57 -05002096 bh2 = ext4_append(handle, dir, &block);
2097 if (IS_ERR(bh2)) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002098 brelse(bh);
Theodore Ts'o0f70b402013-02-15 03:35:57 -05002099 return PTR_ERR(bh2);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002100 }
Dmitry Monakhov12e9b892010-05-16 22:00:00 -04002101 ext4_set_inode_flag(dir, EXT4_INODE_INDEX);
Theodore Ts'oddce3b92019-06-21 16:31:47 -04002102 data2 = bh2->b_data;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002103
Theodore Ts'oddce3b92019-06-21 16:31:47 -04002104 memcpy(data2, de, len);
2105 de = (struct ext4_dir_entry_2 *) data2;
2106 top = data2 + len;
Wei Yongjun3d0518f2009-02-14 23:01:36 -05002107 while ((char *)(de2 = ext4_next_entry(de, blocksize)) < top)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002108 de = de2;
Theodore Ts'oddce3b92019-06-21 16:31:47 -04002109 de->rec_len = ext4_rec_len_to_disk(data2 + (blocksize - csum_size) -
2110 (char *) de, blocksize);
Darrick J. Wongb0336e82012-04-29 18:41:10 -04002111
Theodore Ts'oddce3b92019-06-21 16:31:47 -04002112 if (csum_size)
2113 ext4_initialize_dirent_tail(bh2, blocksize);
Darrick J. Wongb0336e82012-04-29 18:41:10 -04002114
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002115 /* Initialize the root; the dot dirents already exist */
Mingming Cao617ba132006-10-11 01:20:53 -07002116 de = (struct ext4_dir_entry_2 *) (&root->dotdot);
Wei Yongjun3d0518f2009-02-14 23:01:36 -05002117 de->rec_len = ext4_rec_len_to_disk(blocksize - EXT4_DIR_REC_LEN(2),
2118 blocksize);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002119 memset (&root->info, 0, sizeof(root->info));
2120 root->info.info_length = sizeof(root->info);
Mingming Cao617ba132006-10-11 01:20:53 -07002121 root->info.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002122 entries = root->entries;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04002123 dx_set_block(entries, 1);
2124 dx_set_count(entries, 1);
2125 dx_set_limit(entries, dx_root_limit(dir, sizeof(root->info)));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002126
2127 /* Initialize as for dx_probe */
Theodore Ts'o5b643f92015-05-18 13:14:47 -04002128 fname->hinfo.hash_version = root->info.hash_version;
2129 if (fname->hinfo.hash_version <= DX_HASH_TEA)
2130 fname->hinfo.hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned;
2131 fname->hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed;
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -04002132 ext4fs_dirhash(dir, fname_name(fname), fname_len(fname), &fname->hinfo);
Theodore Ts'o5b643f92015-05-18 13:14:47 -04002133
Jan Kara6050d472014-10-30 10:53:17 -04002134 memset(frames, 0, sizeof(frames));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002135 frame = frames;
2136 frame->entries = entries;
2137 frame->at = entries;
2138 frame->bh = bh;
Allison Henderson6976a6f2011-05-15 00:19:41 -04002139
Jan Kara6050d472014-10-30 10:53:17 -04002140 retval = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
2141 if (retval)
2142 goto out_frames;
Theodore Ts'of036adb2019-06-21 15:49:26 -04002143 retval = ext4_handle_dirty_dirblock(handle, dir, bh2);
Jan Kara6050d472014-10-30 10:53:17 -04002144 if (retval)
2145 goto out_frames;
Allison Henderson6976a6f2011-05-15 00:19:41 -04002146
gmaile81d4472016-09-30 01:33:37 -04002147 de = do_split(handle,dir, &bh2, frame, &fname->hinfo);
Theodore Ts'of8b3b592014-08-29 20:52:18 -04002148 if (IS_ERR(de)) {
Jan Kara6050d472014-10-30 10:53:17 -04002149 retval = PTR_ERR(de);
2150 goto out_frames;
Jan Kara7ad8e4e2011-05-03 11:05:55 -04002151 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002152
gmaile81d4472016-09-30 01:33:37 -04002153 retval = add_dirent_to_buf(handle, fname, dir, inode, de, bh2);
Jan Kara6050d472014-10-30 10:53:17 -04002154out_frames:
2155 /*
2156 * Even if the block split failed, we have to properly write
2157 * out all the changes we did so far. Otherwise we can end up
2158 * with corrupted filesystem.
2159 */
gmaile81d4472016-09-30 01:33:37 -04002160 if (retval)
2161 ext4_mark_inode_dirty(handle, dir);
Jan Kara6050d472014-10-30 10:53:17 -04002162 dx_release(frames);
gmaile81d4472016-09-30 01:33:37 -04002163 brelse(bh2);
Jan Kara6050d472014-10-30 10:53:17 -04002164 return retval;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002165}
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002166
2167/*
Mingming Cao617ba132006-10-11 01:20:53 -07002168 * ext4_add_entry()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002169 *
2170 * adds a file entry to the specified directory, using the same
Mingming Cao617ba132006-10-11 01:20:53 -07002171 * semantics as ext4_find_entry(). It returns NULL if it failed.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002172 *
2173 * NOTE!! The inode part of 'de' is left at 0 - which means you
2174 * may not sleep between calling this and putting something into
2175 * the entry, as someone else might have used it while you slept.
2176 */
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04002177static int ext4_add_entry(handle_t *handle, struct dentry *dentry,
2178 struct inode *inode)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002179{
David Howells2b0143b2015-03-17 22:25:59 +00002180 struct inode *dir = d_inode(dentry->d_parent);
Lukas Czernere12fb972015-04-03 10:46:58 -04002181 struct buffer_head *bh = NULL;
Mingming Cao617ba132006-10-11 01:20:53 -07002182 struct ext4_dir_entry_2 *de;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04002183 struct super_block *sb;
Theodore Ts'o5b643f92015-05-18 13:14:47 -04002184 struct ext4_filename fname;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002185 int retval;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002186 int dx_fallback=0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002187 unsigned blocksize;
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05002188 ext4_lblk_t block, blocks;
Darrick J. Wongb0336e82012-04-29 18:41:10 -04002189 int csum_size = 0;
2190
Dmitry Monakhov9aa5d32b2014-10-13 03:36:16 -04002191 if (ext4_has_metadata_csum(inode->i_sb))
Darrick J. Wongb0336e82012-04-29 18:41:10 -04002192 csum_size = sizeof(struct ext4_dir_entry_tail);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002193
2194 sb = dir->i_sb;
2195 blocksize = sb->s_blocksize;
2196 if (!dentry->d_name.len)
2197 return -EINVAL;
Tao Ma3c47d542012-12-10 14:05:59 -05002198
Eric Biggers75d18cd2020-11-17 23:56:06 -08002199 if (fscrypt_is_nokey_name(dentry))
2200 return -ENOKEY;
2201
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -04002202#ifdef CONFIG_UNICODE
Daniel Rosenbergf8f4acb2020-10-28 05:08:20 +00002203 if (sb_has_strict_encoding(sb) && IS_CASEFOLDED(dir) &&
2204 sb->s_encoding && utf8_validate(sb->s_encoding, &dentry->d_name))
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -04002205 return -EINVAL;
2206#endif
2207
Theodore Ts'o5b643f92015-05-18 13:14:47 -04002208 retval = ext4_fname_setup_filename(dir, &dentry->d_name, 0, &fname);
2209 if (retval)
2210 return retval;
2211
Tao Ma3c47d542012-12-10 14:05:59 -05002212 if (ext4_has_inline_data(dir)) {
Theodore Ts'o56a04912016-01-08 16:00:31 -05002213 retval = ext4_try_add_inline_entry(handle, &fname, dir, inode);
Tao Ma3c47d542012-12-10 14:05:59 -05002214 if (retval < 0)
Theodore Ts'o5b643f92015-05-18 13:14:47 -04002215 goto out;
Tao Ma3c47d542012-12-10 14:05:59 -05002216 if (retval == 1) {
2217 retval = 0;
Lukas Czernere12fb972015-04-03 10:46:58 -04002218 goto out;
Tao Ma3c47d542012-12-10 14:05:59 -05002219 }
2220 }
2221
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002222 if (is_dx(dir)) {
Theodore Ts'o56a04912016-01-08 16:00:31 -05002223 retval = ext4_dx_add_entry(handle, &fname, dir, inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002224 if (!retval || (retval != ERR_BAD_DX_DIR))
Lukas Czernere12fb972015-04-03 10:46:58 -04002225 goto out;
Jan Kara48a34312020-02-10 15:43:16 +01002226 /* Can we just ignore htree data? */
2227 if (ext4_has_metadata_csum(sb)) {
2228 EXT4_ERROR_INODE(dir,
2229 "Directory has corrupted htree index.");
2230 retval = -EFSCORRUPTED;
2231 goto out;
2232 }
Dmitry Monakhov12e9b892010-05-16 22:00:00 -04002233 ext4_clear_inode_flag(dir, EXT4_INODE_INDEX);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002234 dx_fallback++;
Harshad Shirwadkar4209ae12020-04-26 18:34:37 -07002235 retval = ext4_mark_inode_dirty(handle, dir);
2236 if (unlikely(retval))
2237 goto out;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002238 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002239 blocks = dir->i_size >> sb->s_blocksize_bits;
Theodore Ts'o498e5f22008-11-05 00:14:04 -05002240 for (block = 0; block < blocks; block++) {
Theodore Ts'odc6982ff2013-02-14 23:59:26 -05002241 bh = ext4_read_dirblock(dir, block, DIRENT);
Theodore Ts'o4e19d6b2019-06-20 21:19:02 -04002242 if (bh == NULL) {
2243 bh = ext4_bread(handle, dir, block,
2244 EXT4_GET_BLOCKS_CREATE);
2245 goto add_to_new_block;
2246 }
Theodore Ts'o5b643f92015-05-18 13:14:47 -04002247 if (IS_ERR(bh)) {
2248 retval = PTR_ERR(bh);
2249 bh = NULL;
2250 goto out;
2251 }
2252 retval = add_dirent_to_buf(handle, &fname, dir, inode,
2253 NULL, bh);
Lukas Czernere12fb972015-04-03 10:46:58 -04002254 if (retval != -ENOSPC)
2255 goto out;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002256
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002257 if (blocks == 1 && !dx_fallback &&
Darrick J. Wonge2b911c2015-10-17 16:18:43 -04002258 ext4_has_feature_dir_index(sb)) {
Theodore Ts'o56a04912016-01-08 16:00:31 -05002259 retval = make_indexed_dir(handle, &fname, dir,
Theodore Ts'o5b643f92015-05-18 13:14:47 -04002260 inode, bh);
Lukas Czernere12fb972015-04-03 10:46:58 -04002261 bh = NULL; /* make_indexed_dir releases bh */
2262 goto out;
2263 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002264 brelse(bh);
2265 }
Theodore Ts'o0f70b402013-02-15 03:35:57 -05002266 bh = ext4_append(handle, dir, &block);
Theodore Ts'o4e19d6b2019-06-20 21:19:02 -04002267add_to_new_block:
Theodore Ts'o5b643f92015-05-18 13:14:47 -04002268 if (IS_ERR(bh)) {
2269 retval = PTR_ERR(bh);
2270 bh = NULL;
2271 goto out;
2272 }
Mingming Cao617ba132006-10-11 01:20:53 -07002273 de = (struct ext4_dir_entry_2 *) bh->b_data;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002274 de->inode = 0;
Darrick J. Wongb0336e82012-04-29 18:41:10 -04002275 de->rec_len = ext4_rec_len_to_disk(blocksize - csum_size, blocksize);
2276
Theodore Ts'oddce3b92019-06-21 16:31:47 -04002277 if (csum_size)
2278 ext4_initialize_dirent_tail(bh, blocksize);
Darrick J. Wongb0336e82012-04-29 18:41:10 -04002279
Theodore Ts'o5b643f92015-05-18 13:14:47 -04002280 retval = add_dirent_to_buf(handle, &fname, dir, inode, de, bh);
Lukas Czernere12fb972015-04-03 10:46:58 -04002281out:
Theodore Ts'o5b643f92015-05-18 13:14:47 -04002282 ext4_fname_free_filename(&fname);
Theodore Ts'o2de770a2009-11-23 07:25:49 -05002283 brelse(bh);
Frank Mayhar14ece102010-05-17 08:00:00 -04002284 if (retval == 0)
2285 ext4_set_inode_state(inode, EXT4_STATE_NEWENTRY);
Theodore Ts'o2de770a2009-11-23 07:25:49 -05002286 return retval;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002287}
2288
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002289/*
2290 * Returns 0 for success, or a negative error value
2291 */
Theodore Ts'o5b643f92015-05-18 13:14:47 -04002292static int ext4_dx_add_entry(handle_t *handle, struct ext4_filename *fname,
Theodore Ts'o56a04912016-01-08 16:00:31 -05002293 struct inode *dir, struct inode *inode)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002294{
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04002295 struct dx_frame frames[EXT4_HTREE_LEVEL], *frame;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002296 struct dx_entry *entries, *at;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04002297 struct buffer_head *bh;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04002298 struct super_block *sb = dir->i_sb;
Mingming Cao617ba132006-10-11 01:20:53 -07002299 struct ext4_dir_entry_2 *de;
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04002300 int restart;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002301 int err;
2302
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04002303again:
2304 restart = 0;
Theodore Ts'o5b643f92015-05-18 13:14:47 -04002305 frame = dx_probe(fname, dir, NULL, frames);
Theodore Ts'odd73b5d2014-08-29 20:52:17 -04002306 if (IS_ERR(frame))
2307 return PTR_ERR(frame);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002308 entries = frame->entries;
2309 at = frame->at;
Theodore Ts'o4e19d6b2019-06-20 21:19:02 -04002310 bh = ext4_read_dirblock(dir, dx_get_block(frame->at), DIRENT_HTREE);
Theodore Ts'odc6982ff2013-02-14 23:59:26 -05002311 if (IS_ERR(bh)) {
2312 err = PTR_ERR(bh);
2313 bh = NULL;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002314 goto cleanup;
Carlos Maiolino6d1ab102012-09-27 09:31:33 -04002315 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002316
2317 BUFFER_TRACE(bh, "get_write_access");
Mingming Cao617ba132006-10-11 01:20:53 -07002318 err = ext4_journal_get_write_access(handle, bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002319 if (err)
2320 goto journal_error;
2321
Theodore Ts'o5b643f92015-05-18 13:14:47 -04002322 err = add_dirent_to_buf(handle, fname, dir, inode, NULL, bh);
Theodore Ts'o2de770a2009-11-23 07:25:49 -05002323 if (err != -ENOSPC)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002324 goto cleanup;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002325
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04002326 err = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002327 /* Block full, should compress but for now just split */
Theodore Ts'o4776004f2008-09-08 23:00:52 -04002328 dxtrace(printk(KERN_DEBUG "using %u of %u node entries\n",
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002329 dx_get_count(entries), dx_get_limit(entries)));
2330 /* Need to split index? */
2331 if (dx_get_count(entries) == dx_get_limit(entries)) {
Aneesh Kumar K.V725d26d2008-01-28 23:58:27 -05002332 ext4_lblk_t newblock;
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04002333 int levels = frame - frames + 1;
2334 unsigned int icount;
2335 int add_level = 1;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002336 struct dx_entry *entries2;
2337 struct dx_node *node2;
2338 struct buffer_head *bh2;
2339
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04002340 while (frame > frames) {
2341 if (dx_get_count((frame - 1)->entries) <
2342 dx_get_limit((frame - 1)->entries)) {
2343 add_level = 0;
2344 break;
2345 }
2346 frame--; /* split higher index block */
2347 at = frame->at;
2348 entries = frame->entries;
2349 restart = 1;
2350 }
2351 if (add_level && levels == ext4_dir_htree_level(sb)) {
2352 ext4_warning(sb, "Directory (ino: %lu) index full, "
2353 "reach max htree level :%d",
2354 dir->i_ino, levels);
2355 if (ext4_dir_htree_level(sb) < EXT4_HTREE_LEVEL) {
2356 ext4_warning(sb, "Large directory feature is "
2357 "not enabled on this "
2358 "filesystem");
2359 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002360 err = -ENOSPC;
2361 goto cleanup;
2362 }
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04002363 icount = dx_get_count(entries);
Theodore Ts'o0f70b402013-02-15 03:35:57 -05002364 bh2 = ext4_append(handle, dir, &newblock);
2365 if (IS_ERR(bh2)) {
2366 err = PTR_ERR(bh2);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002367 goto cleanup;
Theodore Ts'o0f70b402013-02-15 03:35:57 -05002368 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002369 node2 = (struct dx_node *)(bh2->b_data);
2370 entries2 = node2->entries;
Andreas Schlick1f7bebb2009-09-10 23:16:07 -04002371 memset(&node2->fake, 0, sizeof(struct fake_dirent));
Wei Yongjun3d0518f2009-02-14 23:01:36 -05002372 node2->fake.rec_len = ext4_rec_len_to_disk(sb->s_blocksize,
2373 sb->s_blocksize);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002374 BUFFER_TRACE(frame->bh, "get_write_access");
Mingming Cao617ba132006-10-11 01:20:53 -07002375 err = ext4_journal_get_write_access(handle, frame->bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002376 if (err)
2377 goto journal_error;
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04002378 if (!add_level) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002379 unsigned icount1 = icount/2, icount2 = icount - icount1;
2380 unsigned hash2 = dx_get_hash(entries + icount1);
Theodore Ts'o4776004f2008-09-08 23:00:52 -04002381 dxtrace(printk(KERN_DEBUG "Split index %i/%i\n",
2382 icount1, icount2));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002383
2384 BUFFER_TRACE(frame->bh, "get_write_access"); /* index root */
Mingming Cao617ba132006-10-11 01:20:53 -07002385 err = ext4_journal_get_write_access(handle,
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04002386 (frame - 1)->bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002387 if (err)
2388 goto journal_error;
2389
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04002390 memcpy((char *) entries2, (char *) (entries + icount1),
2391 icount2 * sizeof(struct dx_entry));
2392 dx_set_count(entries, icount1);
2393 dx_set_count(entries2, icount2);
2394 dx_set_limit(entries2, dx_node_limit(dir));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002395
2396 /* Which index block gets the new entry? */
2397 if (at - entries >= icount1) {
2398 frame->at = at = at - entries - icount1 + entries2;
2399 frame->entries = entries = entries2;
2400 swap(frame->bh, bh2);
2401 }
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04002402 dx_insert_block((frame - 1), hash2, newblock);
2403 dxtrace(dx_show_index("node", frame->entries));
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04002404 dxtrace(dx_show_index("node",
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002405 ((struct dx_node *) bh2->b_data)->entries));
Darrick J. Wongdbe89442012-04-29 18:39:10 -04002406 err = ext4_handle_dirty_dx_node(handle, dir, bh2);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002407 if (err)
2408 goto journal_error;
2409 brelse (bh2);
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04002410 err = ext4_handle_dirty_dx_node(handle, dir,
2411 (frame - 1)->bh);
2412 if (err)
2413 goto journal_error;
Theodore Ts'ob5776e72021-02-04 00:05:20 -05002414 err = ext4_handle_dirty_dx_node(handle, dir,
2415 frame->bh);
2416 if (err)
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04002417 goto journal_error;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002418 } else {
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04002419 struct dx_root *dxroot;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002420 memcpy((char *) entries2, (char *) entries,
2421 icount * sizeof(struct dx_entry));
2422 dx_set_limit(entries2, dx_node_limit(dir));
2423
2424 /* Set up root */
2425 dx_set_count(entries, 1);
2426 dx_set_block(entries + 0, newblock);
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04002427 dxroot = (struct dx_root *)frames[0].bh->b_data;
2428 dxroot->info.indirect_levels += 1;
2429 dxtrace(printk(KERN_DEBUG
2430 "Creating %d level index...\n",
Gabriel Krisman Bertazi799578ab2018-10-02 12:43:51 -04002431 dxroot->info.indirect_levels));
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04002432 err = ext4_handle_dirty_dx_node(handle, dir, frame->bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002433 if (err)
2434 goto journal_error;
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04002435 err = ext4_handle_dirty_dx_node(handle, dir, bh2);
2436 brelse(bh2);
2437 restart = 1;
2438 goto journal_error;
Theodore Ts'ob4097142011-01-10 12:46:59 -05002439 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002440 }
Theodore Ts'o5b643f92015-05-18 13:14:47 -04002441 de = do_split(handle, dir, &bh, frame, &fname->hinfo);
Theodore Ts'of8b3b592014-08-29 20:52:18 -04002442 if (IS_ERR(de)) {
2443 err = PTR_ERR(de);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002444 goto cleanup;
Theodore Ts'of8b3b592014-08-29 20:52:18 -04002445 }
Theodore Ts'o5b643f92015-05-18 13:14:47 -04002446 err = add_dirent_to_buf(handle, fname, dir, inode, de, bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002447 goto cleanup;
2448
2449journal_error:
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04002450 ext4_std_error(dir->i_sb, err); /* this is a no-op if err == 0 */
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002451cleanup:
Guo Chaob1deefc2013-01-28 21:41:02 -05002452 brelse(bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002453 dx_release(frames);
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04002454 /* @restart is true means htree-path has been changed, we need to
2455 * repeat dx_probe() to find out valid htree-path
2456 */
2457 if (restart && err == 0)
2458 goto again;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002459 return err;
2460}
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002461
2462/*
Tao Ma05019a92012-12-10 14:06:00 -05002463 * ext4_generic_delete_entry deletes a directory entry by merging it
2464 * with the previous entry
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002465 */
Kyoungho Koo2fe34d292020-08-10 17:07:05 +09002466int ext4_generic_delete_entry(struct inode *dir,
Tao Ma05019a92012-12-10 14:06:00 -05002467 struct ext4_dir_entry_2 *de_del,
2468 struct buffer_head *bh,
2469 void *entry_buf,
2470 int buf_size,
2471 int csum_size)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002472{
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04002473 struct ext4_dir_entry_2 *de, *pde;
Wei Yongjun3d0518f2009-02-14 23:01:36 -05002474 unsigned int blocksize = dir->i_sb->s_blocksize;
Tao Ma05019a92012-12-10 14:06:00 -05002475 int i;
Darrick J. Wongb0336e82012-04-29 18:41:10 -04002476
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002477 i = 0;
2478 pde = NULL;
Tao Ma05019a92012-12-10 14:06:00 -05002479 de = (struct ext4_dir_entry_2 *)entry_buf;
2480 while (i < buf_size - csum_size) {
Tao Ma226ba972012-12-10 14:05:58 -05002481 if (ext4_check_dir_entry(dir, NULL, de, bh,
Jan Kara7303cb52020-07-31 18:21:35 +02002482 entry_buf, buf_size, i))
Darrick J. Wong6a797d22015-10-17 16:16:04 -04002483 return -EFSCORRUPTED;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002484 if (de == de_del) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002485 if (pde)
Jan Karaa72d7f82008-01-28 23:58:27 -05002486 pde->rec_len = ext4_rec_len_to_disk(
Wei Yongjun3d0518f2009-02-14 23:01:36 -05002487 ext4_rec_len_from_disk(pde->rec_len,
2488 blocksize) +
2489 ext4_rec_len_from_disk(de->rec_len,
2490 blocksize),
2491 blocksize);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002492 else
2493 de->inode = 0;
Artem Blagodarenkoe08ac992017-06-21 21:09:57 -04002494 inode_inc_iversion(dir);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002495 return 0;
2496 }
Wei Yongjun3d0518f2009-02-14 23:01:36 -05002497 i += ext4_rec_len_from_disk(de->rec_len, blocksize);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002498 pde = de;
Wei Yongjun3d0518f2009-02-14 23:01:36 -05002499 de = ext4_next_entry(de, blocksize);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002500 }
2501 return -ENOENT;
2502}
2503
Tao Ma05019a92012-12-10 14:06:00 -05002504static int ext4_delete_entry(handle_t *handle,
2505 struct inode *dir,
2506 struct ext4_dir_entry_2 *de_del,
2507 struct buffer_head *bh)
2508{
2509 int err, csum_size = 0;
2510
Tao Ma9f40fe52012-12-10 14:06:00 -05002511 if (ext4_has_inline_data(dir)) {
2512 int has_inline_data = 1;
2513 err = ext4_delete_inline_entry(handle, dir, de_del, bh,
2514 &has_inline_data);
2515 if (has_inline_data)
2516 return err;
2517 }
2518
Dmitry Monakhov9aa5d32b2014-10-13 03:36:16 -04002519 if (ext4_has_metadata_csum(dir->i_sb))
Tao Ma05019a92012-12-10 14:06:00 -05002520 csum_size = sizeof(struct ext4_dir_entry_tail);
2521
2522 BUFFER_TRACE(bh, "get_write_access");
2523 err = ext4_journal_get_write_access(handle, bh);
2524 if (unlikely(err))
2525 goto out;
2526
Kyoungho Koo2fe34d292020-08-10 17:07:05 +09002527 err = ext4_generic_delete_entry(dir, de_del, bh, bh->b_data,
Tao Ma05019a92012-12-10 14:06:00 -05002528 dir->i_sb->s_blocksize, csum_size);
2529 if (err)
2530 goto out;
2531
2532 BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
Theodore Ts'of036adb2019-06-21 15:49:26 -04002533 err = ext4_handle_dirty_dirblock(handle, dir, bh);
Tao Ma05019a92012-12-10 14:06:00 -05002534 if (unlikely(err))
2535 goto out;
2536
2537 return 0;
2538out:
2539 if (err != -ENOENT)
2540 ext4_std_error(dir->i_sb, err);
2541 return err;
2542}
2543
Andreas Dilgerf8628a12007-07-18 08:38:01 -04002544/*
Andreas Dilgerc7414892017-08-05 19:47:34 -04002545 * Set directory link count to 1 if nlinks > EXT4_LINK_MAX, or if nlinks == 2
2546 * since this indicates that nlinks count was previously 1 to avoid overflowing
2547 * the 16-bit i_links_count field on disk. Directories with i_nlink == 1 mean
2548 * that subdirectory link counts are not being maintained accurately.
2549 *
2550 * The caller has already checked for i_nlink overflow in case the DIR_LINK
2551 * feature is not enabled and returned -EMLINK. The is_dx() check is a proxy
2552 * for checking S_ISDIR(inode) (since the INODE_INDEX feature will not be set
2553 * on regular files) and to avoid creating huge/slow non-HTREE directories.
Andreas Dilgerf8628a12007-07-18 08:38:01 -04002554 */
Nikolay Borisov15ed2852020-08-26 16:31:16 +03002555static void ext4_inc_count(struct inode *inode)
Andreas Dilgerf8628a12007-07-18 08:38:01 -04002556{
2557 inc_nlink(inode);
Andreas Dilgerc7414892017-08-05 19:47:34 -04002558 if (is_dx(inode) &&
2559 (inode->i_nlink > EXT4_LINK_MAX || inode->i_nlink == 2))
2560 set_nlink(inode, 1);
Andreas Dilgerf8628a12007-07-18 08:38:01 -04002561}
2562
2563/*
2564 * If a directory had nlink == 1, then we should let it be 1. This indicates
2565 * directory has >EXT4_LINK_MAX subdirs.
2566 */
Nikolay Borisov15ed2852020-08-26 16:31:16 +03002567static void ext4_dec_count(struct inode *inode)
Andreas Dilgerf8628a12007-07-18 08:38:01 -04002568{
Andreas Dilger909a4cf2011-10-26 03:22:31 -04002569 if (!S_ISDIR(inode->i_mode) || inode->i_nlink > 2)
2570 drop_nlink(inode);
Andreas Dilgerf8628a12007-07-18 08:38:01 -04002571}
2572
2573
Jan Kara9b88f9f2019-11-05 17:44:11 +01002574/*
2575 * Add non-directory inode to a directory. On success, the inode reference is
2576 * consumed by dentry is instantiation. This is also indicated by clearing of
2577 * *inodep pointer. On failure, the caller is responsible for dropping the
2578 * inode reference in the safe context.
2579 */
Mingming Cao617ba132006-10-11 01:20:53 -07002580static int ext4_add_nondir(handle_t *handle,
Jan Kara9b88f9f2019-11-05 17:44:11 +01002581 struct dentry *dentry, struct inode **inodep)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002582{
Jan Karaa9e26322019-11-05 17:44:10 +01002583 struct inode *dir = d_inode(dentry->d_parent);
Jan Kara9b88f9f2019-11-05 17:44:11 +01002584 struct inode *inode = *inodep;
Mingming Cao617ba132006-10-11 01:20:53 -07002585 int err = ext4_add_entry(handle, dentry, inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002586 if (!err) {
Harshad Shirwadkar4209ae12020-04-26 18:34:37 -07002587 err = ext4_mark_inode_dirty(handle, inode);
Jan Karaa9e26322019-11-05 17:44:10 +01002588 if (IS_DIRSYNC(dir))
2589 ext4_handle_sync(handle);
Al Viro1e2e5472018-05-04 08:23:01 -04002590 d_instantiate_new(dentry, inode);
Jan Kara9b88f9f2019-11-05 17:44:11 +01002591 *inodep = NULL;
Harshad Shirwadkar4209ae12020-04-26 18:34:37 -07002592 return err;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002593 }
Eric Sandeen731b9a52007-02-10 01:46:16 -08002594 drop_nlink(inode);
Jan Kara9b88f9f2019-11-05 17:44:11 +01002595 ext4_orphan_add(handle, inode);
Al Viro6b38e842008-12-30 02:03:31 -05002596 unlock_new_inode(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002597 return err;
2598}
2599
2600/*
2601 * By the time this is called, we already have created
2602 * the directory cache entry for the new file, but it
2603 * is so far negative - it has no inode.
2604 *
2605 * If the create succeeds, we fill in the inode information
2606 * with d_instantiate().
2607 */
Christian Brauner549c7292021-01-21 14:19:43 +01002608static int ext4_create(struct user_namespace *mnt_userns, struct inode *dir,
2609 struct dentry *dentry, umode_t mode, bool excl)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002610{
2611 handle_t *handle;
Harshad Shirwadkara80f7fc2020-11-05 19:58:53 -08002612 struct inode *inode;
Theodore Ts'o11395752013-02-09 16:27:09 -05002613 int err, credits, retries = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002614
Jan Karaa7cdade2015-06-29 16:22:54 +02002615 err = dquot_initialize(dir);
2616 if (err)
2617 return err;
Christoph Hellwig907f4552010-03-03 09:05:06 -05002618
Theodore Ts'o11395752013-02-09 16:27:09 -05002619 credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
Jan Karaeb9cc7e2013-04-19 13:38:14 -04002620 EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002621retry:
Christian Brauner14f3db52021-01-21 14:19:57 +01002622 inode = ext4_new_inode_start_handle(mnt_userns, dir, mode, &dentry->d_name,
2623 0, NULL, EXT4_HT_DIR, credits);
Theodore Ts'o11395752013-02-09 16:27:09 -05002624 handle = ext4_journal_current_handle();
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002625 err = PTR_ERR(inode);
2626 if (!IS_ERR(inode)) {
Mingming Cao617ba132006-10-11 01:20:53 -07002627 inode->i_op = &ext4_file_inode_operations;
Boaz Harroshbe64f882015-04-15 16:15:17 -07002628 inode->i_fop = &ext4_file_operations;
Mingming Cao617ba132006-10-11 01:20:53 -07002629 ext4_set_aops(inode);
Jan Kara9b88f9f2019-11-05 17:44:11 +01002630 err = ext4_add_nondir(handle, dentry, &inode);
Harshad Shirwadkara80f7fc2020-11-05 19:58:53 -08002631 if (!err)
2632 ext4_fc_track_create(handle, dentry);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002633 }
Theodore Ts'o11395752013-02-09 16:27:09 -05002634 if (handle)
2635 ext4_journal_stop(handle);
Jan Kara9b88f9f2019-11-05 17:44:11 +01002636 if (!IS_ERR_OR_NULL(inode))
2637 iput(inode);
Mingming Cao617ba132006-10-11 01:20:53 -07002638 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002639 goto retry;
2640 return err;
2641}
2642
Christian Brauner549c7292021-01-21 14:19:43 +01002643static int ext4_mknod(struct user_namespace *mnt_userns, struct inode *dir,
2644 struct dentry *dentry, umode_t mode, dev_t rdev)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002645{
2646 handle_t *handle;
Harshad Shirwadkara80f7fc2020-11-05 19:58:53 -08002647 struct inode *inode;
Theodore Ts'o11395752013-02-09 16:27:09 -05002648 int err, credits, retries = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002649
Jan Karaa7cdade2015-06-29 16:22:54 +02002650 err = dquot_initialize(dir);
2651 if (err)
2652 return err;
Christoph Hellwig907f4552010-03-03 09:05:06 -05002653
Theodore Ts'o11395752013-02-09 16:27:09 -05002654 credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
Jan Karaeb9cc7e2013-04-19 13:38:14 -04002655 EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002656retry:
Christian Brauner14f3db52021-01-21 14:19:57 +01002657 inode = ext4_new_inode_start_handle(mnt_userns, dir, mode, &dentry->d_name,
2658 0, NULL, EXT4_HT_DIR, credits);
Theodore Ts'o11395752013-02-09 16:27:09 -05002659 handle = ext4_journal_current_handle();
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002660 err = PTR_ERR(inode);
2661 if (!IS_ERR(inode)) {
2662 init_special_inode(inode, inode->i_mode, rdev);
Mingming Cao617ba132006-10-11 01:20:53 -07002663 inode->i_op = &ext4_special_inode_operations;
Jan Kara9b88f9f2019-11-05 17:44:11 +01002664 err = ext4_add_nondir(handle, dentry, &inode);
Harshad Shirwadkaraa75f4d2020-10-15 13:37:57 -07002665 if (!err)
Harshad Shirwadkara80f7fc2020-11-05 19:58:53 -08002666 ext4_fc_track_create(handle, dentry);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002667 }
Theodore Ts'o11395752013-02-09 16:27:09 -05002668 if (handle)
2669 ext4_journal_stop(handle);
Jan Kara9b88f9f2019-11-05 17:44:11 +01002670 if (!IS_ERR_OR_NULL(inode))
2671 iput(inode);
Mingming Cao617ba132006-10-11 01:20:53 -07002672 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002673 goto retry;
2674 return err;
2675}
2676
Christian Brauner549c7292021-01-21 14:19:43 +01002677static int ext4_tmpfile(struct user_namespace *mnt_userns, struct inode *dir,
2678 struct dentry *dentry, umode_t mode)
Al Viroaf51a2a2013-06-29 13:23:08 +04002679{
2680 handle_t *handle;
2681 struct inode *inode;
2682 int err, retries = 0;
2683
Jan Karaa7cdade2015-06-29 16:22:54 +02002684 err = dquot_initialize(dir);
2685 if (err)
2686 return err;
Al Viroaf51a2a2013-06-29 13:23:08 +04002687
2688retry:
Christian Brauner14f3db52021-01-21 14:19:57 +01002689 inode = ext4_new_inode_start_handle(mnt_userns, dir, mode,
Al Viroaf51a2a2013-06-29 13:23:08 +04002690 NULL, 0, NULL,
2691 EXT4_HT_DIR,
2692 EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) +
2693 4 + EXT4_XATTR_TRANS_BLOCKS);
2694 handle = ext4_journal_current_handle();
2695 err = PTR_ERR(inode);
2696 if (!IS_ERR(inode)) {
2697 inode->i_op = &ext4_file_inode_operations;
Boaz Harroshbe64f882015-04-15 16:15:17 -07002698 inode->i_fop = &ext4_file_operations;
Al Viroaf51a2a2013-06-29 13:23:08 +04002699 ext4_set_aops(inode);
Zheng Liue94bd342013-07-20 21:58:38 -04002700 d_tmpfile(dentry, inode);
Al Viroaf51a2a2013-06-29 13:23:08 +04002701 err = ext4_orphan_add(handle, inode);
2702 if (err)
Miklos Szeredi43ae9e32013-10-10 16:48:19 +02002703 goto err_unlock_inode;
Al Viroaf51a2a2013-06-29 13:23:08 +04002704 mark_inode_dirty(inode);
Al Viroaf51a2a2013-06-29 13:23:08 +04002705 unlock_new_inode(inode);
2706 }
2707 if (handle)
2708 ext4_journal_stop(handle);
2709 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
2710 goto retry;
2711 return err;
Miklos Szeredi43ae9e32013-10-10 16:48:19 +02002712err_unlock_inode:
Al Viroaf51a2a2013-06-29 13:23:08 +04002713 ext4_journal_stop(handle);
2714 unlock_new_inode(inode);
Al Viroaf51a2a2013-06-29 13:23:08 +04002715 return err;
2716}
2717
Tao Maa774f9c2012-12-10 14:05:57 -05002718struct ext4_dir_entry_2 *ext4_init_dot_dotdot(struct inode *inode,
2719 struct ext4_dir_entry_2 *de,
2720 int blocksize, int csum_size,
2721 unsigned int parent_ino, int dotdot_real_len)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002722{
Tao Maa774f9c2012-12-10 14:05:57 -05002723 de->inode = cpu_to_le32(inode->i_ino);
2724 de->name_len = 1;
2725 de->rec_len = ext4_rec_len_to_disk(EXT4_DIR_REC_LEN(de->name_len),
2726 blocksize);
2727 strcpy(de->name, ".");
2728 ext4_set_de_type(inode->i_sb, de, S_IFDIR);
2729
2730 de = ext4_next_entry(de, blocksize);
2731 de->inode = cpu_to_le32(parent_ino);
2732 de->name_len = 2;
2733 if (!dotdot_real_len)
2734 de->rec_len = ext4_rec_len_to_disk(blocksize -
2735 (csum_size + EXT4_DIR_REC_LEN(1)),
2736 blocksize);
2737 else
2738 de->rec_len = ext4_rec_len_to_disk(
2739 EXT4_DIR_REC_LEN(de->name_len), blocksize);
2740 strcpy(de->name, "..");
2741 ext4_set_de_type(inode->i_sb, de, S_IFDIR);
2742
2743 return ext4_next_entry(de, blocksize);
2744}
2745
Harshad Shirwadkar8016e292020-10-15 13:37:59 -07002746int ext4_init_new_dir(handle_t *handle, struct inode *dir,
Tao Maa774f9c2012-12-10 14:05:57 -05002747 struct inode *inode)
2748{
Namhyung Kimdabd9912011-01-10 12:11:16 -05002749 struct buffer_head *dir_block = NULL;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04002750 struct ext4_dir_entry_2 *de;
Theodore Ts'odc6982ff2013-02-14 23:59:26 -05002751 ext4_lblk_t block = 0;
Wei Yongjun3d0518f2009-02-14 23:01:36 -05002752 unsigned int blocksize = dir->i_sb->s_blocksize;
Darrick J. Wongb0336e82012-04-29 18:41:10 -04002753 int csum_size = 0;
Tao Maa774f9c2012-12-10 14:05:57 -05002754 int err;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002755
Dmitry Monakhov9aa5d32b2014-10-13 03:36:16 -04002756 if (ext4_has_metadata_csum(dir->i_sb))
Darrick J. Wongb0336e82012-04-29 18:41:10 -04002757 csum_size = sizeof(struct ext4_dir_entry_tail);
2758
Tao Ma3c47d542012-12-10 14:05:59 -05002759 if (ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA)) {
2760 err = ext4_try_create_inline_dir(handle, dir, inode);
2761 if (err < 0 && err != -ENOSPC)
2762 goto out;
2763 if (!err)
2764 goto out;
2765 }
2766
Theodore Ts'odc6982ff2013-02-14 23:59:26 -05002767 inode->i_size = 0;
Theodore Ts'o0f70b402013-02-15 03:35:57 -05002768 dir_block = ext4_append(handle, inode, &block);
2769 if (IS_ERR(dir_block))
2770 return PTR_ERR(dir_block);
Tao Maa774f9c2012-12-10 14:05:57 -05002771 de = (struct ext4_dir_entry_2 *)dir_block->b_data;
2772 ext4_init_dot_dotdot(inode, de, blocksize, csum_size, dir->i_ino, 0);
2773 set_nlink(inode, 2);
Theodore Ts'oddce3b92019-06-21 16:31:47 -04002774 if (csum_size)
2775 ext4_initialize_dirent_tail(dir_block, blocksize);
Tao Maa774f9c2012-12-10 14:05:57 -05002776
2777 BUFFER_TRACE(dir_block, "call ext4_handle_dirty_metadata");
Theodore Ts'of036adb2019-06-21 15:49:26 -04002778 err = ext4_handle_dirty_dirblock(handle, inode, dir_block);
Tao Maa774f9c2012-12-10 14:05:57 -05002779 if (err)
2780 goto out;
2781 set_buffer_verified(dir_block);
2782out:
2783 brelse(dir_block);
2784 return err;
2785}
2786
Christian Brauner549c7292021-01-21 14:19:43 +01002787static int ext4_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
2788 struct dentry *dentry, umode_t mode)
Tao Maa774f9c2012-12-10 14:05:57 -05002789{
2790 handle_t *handle;
2791 struct inode *inode;
Harshad Shirwadkar4209ae12020-04-26 18:34:37 -07002792 int err, err2 = 0, credits, retries = 0;
Tao Maa774f9c2012-12-10 14:05:57 -05002793
Andreas Dilgerf8628a12007-07-18 08:38:01 -04002794 if (EXT4_DIR_LINK_MAX(dir))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002795 return -EMLINK;
2796
Jan Karaa7cdade2015-06-29 16:22:54 +02002797 err = dquot_initialize(dir);
2798 if (err)
2799 return err;
Christoph Hellwig907f4552010-03-03 09:05:06 -05002800
Theodore Ts'o11395752013-02-09 16:27:09 -05002801 credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
Jan Karaeb9cc7e2013-04-19 13:38:14 -04002802 EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002803retry:
Christian Brauner14f3db52021-01-21 14:19:57 +01002804 inode = ext4_new_inode_start_handle(mnt_userns, dir, S_IFDIR | mode,
Theodore Ts'o11395752013-02-09 16:27:09 -05002805 &dentry->d_name,
2806 0, NULL, EXT4_HT_DIR, credits);
2807 handle = ext4_journal_current_handle();
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002808 err = PTR_ERR(inode);
2809 if (IS_ERR(inode))
2810 goto out_stop;
2811
Mingming Cao617ba132006-10-11 01:20:53 -07002812 inode->i_op = &ext4_dir_inode_operations;
2813 inode->i_fop = &ext4_dir_operations;
Tao Maa774f9c2012-12-10 14:05:57 -05002814 err = ext4_init_new_dir(handle, dir, inode);
Namhyung Kimdabd9912011-01-10 12:11:16 -05002815 if (err)
2816 goto out_clear_inode;
Namhyung Kimdabd9912011-01-10 12:11:16 -05002817 err = ext4_mark_inode_dirty(handle, inode);
2818 if (!err)
2819 err = ext4_add_entry(handle, dentry, inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002820 if (err) {
Aneesh Kumar K.V4cdeed82008-02-22 06:17:31 -05002821out_clear_inode:
2822 clear_nlink(inode);
Jan Kara9b88f9f2019-11-05 17:44:11 +01002823 ext4_orphan_add(handle, inode);
Al Viro6b38e842008-12-30 02:03:31 -05002824 unlock_new_inode(inode);
Harshad Shirwadkar4209ae12020-04-26 18:34:37 -07002825 err2 = ext4_mark_inode_dirty(handle, inode);
2826 if (unlikely(err2))
2827 err = err2;
Jan Kara9b88f9f2019-11-05 17:44:11 +01002828 ext4_journal_stop(handle);
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04002829 iput(inode);
Jan Kara9b88f9f2019-11-05 17:44:11 +01002830 goto out_retry;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002831 }
Nikolay Borisov15ed2852020-08-26 16:31:16 +03002832 ext4_inc_count(dir);
Harshad Shirwadkaraa75f4d2020-10-15 13:37:57 -07002833
Mingming Cao617ba132006-10-11 01:20:53 -07002834 ext4_update_dx_flag(dir);
Namhyung Kimdabd9912011-01-10 12:11:16 -05002835 err = ext4_mark_inode_dirty(handle, dir);
2836 if (err)
2837 goto out_clear_inode;
Al Viro1e2e5472018-05-04 08:23:01 -04002838 d_instantiate_new(dentry, inode);
Harshad Shirwadkara80f7fc2020-11-05 19:58:53 -08002839 ext4_fc_track_create(handle, dentry);
Theodore Ts'o11395752013-02-09 16:27:09 -05002840 if (IS_DIRSYNC(dir))
2841 ext4_handle_sync(handle);
2842
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002843out_stop:
Theodore Ts'o11395752013-02-09 16:27:09 -05002844 if (handle)
2845 ext4_journal_stop(handle);
Jan Kara9b88f9f2019-11-05 17:44:11 +01002846out_retry:
Mingming Cao617ba132006-10-11 01:20:53 -07002847 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002848 goto retry;
2849 return err;
2850}
2851
2852/*
2853 * routine to check that the specified directory is empty (for rmdir)
2854 */
Jaegeuk Kima7550b32016-07-10 14:01:03 -04002855bool ext4_empty_dir(struct inode *inode)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002856{
Theodore Ts'o498e5f22008-11-05 00:14:04 -05002857 unsigned int offset;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04002858 struct buffer_head *bh;
Jan Kara64d4ce82019-12-02 18:02:12 +01002859 struct ext4_dir_entry_2 *de;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04002860 struct super_block *sb;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002861
Tao Ma61f86632012-12-10 14:06:01 -05002862 if (ext4_has_inline_data(inode)) {
2863 int has_inline_data = 1;
Jaegeuk Kima7550b32016-07-10 14:01:03 -04002864 int ret;
Tao Ma61f86632012-12-10 14:06:01 -05002865
Jaegeuk Kima7550b32016-07-10 14:01:03 -04002866 ret = empty_inline_dir(inode, &has_inline_data);
Tao Ma61f86632012-12-10 14:06:01 -05002867 if (has_inline_data)
Jaegeuk Kima7550b32016-07-10 14:01:03 -04002868 return ret;
Tao Ma61f86632012-12-10 14:06:01 -05002869 }
2870
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002871 sb = inode->i_sb;
Theodore Ts'odc6982ff2013-02-14 23:59:26 -05002872 if (inode->i_size < EXT4_DIR_REC_LEN(1) + EXT4_DIR_REC_LEN(2)) {
2873 EXT4_ERROR_INODE(inode, "invalid size");
Jaegeuk Kima7550b32016-07-10 14:01:03 -04002874 return true;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002875 }
Theodore Ts'o4e19d6b2019-06-20 21:19:02 -04002876 /* The first directory block must not be a hole,
2877 * so treat it as DIRENT_HTREE
2878 */
2879 bh = ext4_read_dirblock(inode, 0, DIRENT_HTREE);
Theodore Ts'odc6982ff2013-02-14 23:59:26 -05002880 if (IS_ERR(bh))
Jaegeuk Kima7550b32016-07-10 14:01:03 -04002881 return true;
Theodore Ts'odc6982ff2013-02-14 23:59:26 -05002882
Mingming Cao617ba132006-10-11 01:20:53 -07002883 de = (struct ext4_dir_entry_2 *) bh->b_data;
Jan Kara64d4ce82019-12-02 18:02:12 +01002884 if (ext4_check_dir_entry(inode, NULL, de, bh, bh->b_data, bh->b_size,
2885 0) ||
2886 le32_to_cpu(de->inode) != inode->i_ino || strcmp(".", de->name)) {
2887 ext4_warning_inode(inode, "directory missing '.'");
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04002888 brelse(bh);
Jaegeuk Kima7550b32016-07-10 14:01:03 -04002889 return true;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002890 }
Jan Kara64d4ce82019-12-02 18:02:12 +01002891 offset = ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize);
2892 de = ext4_next_entry(de, sb->s_blocksize);
2893 if (ext4_check_dir_entry(inode, NULL, de, bh, bh->b_data, bh->b_size,
2894 offset) ||
2895 le32_to_cpu(de->inode) == 0 || strcmp("..", de->name)) {
2896 ext4_warning_inode(inode, "directory missing '..'");
2897 brelse(bh);
2898 return true;
2899 }
2900 offset += ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize);
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04002901 while (offset < inode->i_size) {
Jan Kara64d4ce82019-12-02 18:02:12 +01002902 if (!(offset & (sb->s_blocksize - 1))) {
Theodore Ts'o24676da2010-05-16 21:00:00 -04002903 unsigned int lblock;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04002904 brelse(bh);
Theodore Ts'o24676da2010-05-16 21:00:00 -04002905 lblock = offset >> EXT4_BLOCK_SIZE_BITS(sb);
Theodore Ts'odc6982ff2013-02-14 23:59:26 -05002906 bh = ext4_read_dirblock(inode, lblock, EITHER);
Theodore Ts'o4e19d6b2019-06-20 21:19:02 -04002907 if (bh == NULL) {
2908 offset += sb->s_blocksize;
2909 continue;
2910 }
Theodore Ts'odc6982ff2013-02-14 23:59:26 -05002911 if (IS_ERR(bh))
Jaegeuk Kima7550b32016-07-10 14:01:03 -04002912 return true;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002913 }
Jan Kara64d4ce82019-12-02 18:02:12 +01002914 de = (struct ext4_dir_entry_2 *) (bh->b_data +
2915 (offset & (sb->s_blocksize - 1)));
Tao Ma226ba972012-12-10 14:05:58 -05002916 if (ext4_check_dir_entry(inode, NULL, de, bh,
2917 bh->b_data, bh->b_size, offset)) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002918 offset = (offset | (sb->s_blocksize - 1)) + 1;
2919 continue;
2920 }
2921 if (le32_to_cpu(de->inode)) {
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04002922 brelse(bh);
Jaegeuk Kima7550b32016-07-10 14:01:03 -04002923 return false;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002924 }
Wei Yongjun3d0518f2009-02-14 23:01:36 -05002925 offset += ext4_rec_len_from_disk(de->rec_len, sb->s_blocksize);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002926 }
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04002927 brelse(bh);
Jaegeuk Kima7550b32016-07-10 14:01:03 -04002928 return true;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002929}
2930
Jan Karad745a8c2014-05-26 11:56:53 -04002931/*
2932 * ext4_orphan_add() links an unlinked or truncated inode into a list of
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002933 * such inodes, starting at the superblock, in case we crash before the
2934 * file is closed/deleted, or in case the inode truncate spans multiple
2935 * transactions and the last transaction is not recovered after a crash.
2936 *
2937 * At filesystem recovery time, we walk this list deleting unlinked
Mingming Cao617ba132006-10-11 01:20:53 -07002938 * inodes and truncating linked inodes in ext4_orphan_cleanup().
Jan Karad745a8c2014-05-26 11:56:53 -04002939 *
2940 * Orphan list manipulation functions must be called under i_mutex unless
2941 * we are just creating the inode or deleting it.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002942 */
Mingming Cao617ba132006-10-11 01:20:53 -07002943int ext4_orphan_add(handle_t *handle, struct inode *inode)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002944{
2945 struct super_block *sb = inode->i_sb;
Jan Karacd2c0802014-05-26 11:39:17 -04002946 struct ext4_sb_info *sbi = EXT4_SB(sb);
Mingming Cao617ba132006-10-11 01:20:53 -07002947 struct ext4_iloc iloc;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002948 int err = 0, rc;
Jan Karad745a8c2014-05-26 11:56:53 -04002949 bool dirty = false;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002950
Theodore Ts'oe2bfb082014-10-05 22:47:07 -04002951 if (!sbi->s_journal || is_bad_inode(inode))
Frank Mayhar03901312009-01-07 00:06:22 -05002952 return 0;
2953
Jan Karad745a8c2014-05-26 11:56:53 -04002954 WARN_ON_ONCE(!(inode->i_state & (I_NEW | I_FREEING)) &&
Al Viro59551022016-01-22 15:40:57 -05002955 !inode_is_locked(inode));
Jan Karad745a8c2014-05-26 11:56:53 -04002956 /*
2957 * Exit early if inode already is on orphan list. This is a big speedup
2958 * since we don't have to contend on the global s_orphan_lock.
2959 */
Mingming Cao617ba132006-10-11 01:20:53 -07002960 if (!list_empty(&EXT4_I(inode)->i_orphan))
Jan Karad745a8c2014-05-26 11:56:53 -04002961 return 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002962
Lukas Czernerafb86172011-07-11 18:47:04 -04002963 /*
2964 * Orphan handling is only valid for files with data blocks
2965 * being truncated, or files being unlinked. Note that we either
2966 * hold i_mutex, or the inode can not be referenced from outside,
2967 * so i_nlink should not be bumped due to race
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002968 */
Chunguang Xu837c23f2020-11-07 23:58:11 +08002969 ASSERT((S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04002970 S_ISLNK(inode->i_mode)) || inode->i_nlink == 0);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002971
Jan Karacd2c0802014-05-26 11:39:17 -04002972 BUFFER_TRACE(sbi->s_sbh, "get_write_access");
2973 err = ext4_journal_get_write_access(handle, sbi->s_sbh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002974 if (err)
Jan Karad745a8c2014-05-26 11:56:53 -04002975 goto out;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002976
Mingming Cao617ba132006-10-11 01:20:53 -07002977 err = ext4_reserve_inode_write(handle, inode, &iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002978 if (err)
Jan Karad745a8c2014-05-26 11:56:53 -04002979 goto out;
2980
2981 mutex_lock(&sbi->s_orphan_lock);
Dmitry Monakhov6e3617e2010-03-01 23:29:39 -05002982 /*
2983 * Due to previous errors inode may be already a part of on-disk
2984 * orphan list. If so skip on-disk list modification.
2985 */
Jan Karad745a8c2014-05-26 11:56:53 -04002986 if (!NEXT_ORPHAN(inode) || NEXT_ORPHAN(inode) >
2987 (le32_to_cpu(sbi->s_es->s_inodes_count))) {
2988 /* Insert this inode at the head of the on-disk orphan list */
2989 NEXT_ORPHAN(inode) = le32_to_cpu(sbi->s_es->s_last_orphan);
Jan Kara05c2c002020-12-16 11:18:39 +01002990 lock_buffer(sbi->s_sbh);
Jan Karad745a8c2014-05-26 11:56:53 -04002991 sbi->s_es->s_last_orphan = cpu_to_le32(inode->i_ino);
Jan Kara05c2c002020-12-16 11:18:39 +01002992 ext4_superblock_csum_set(sb);
2993 unlock_buffer(sbi->s_sbh);
Jan Karad745a8c2014-05-26 11:56:53 -04002994 dirty = true;
2995 }
2996 list_add(&EXT4_I(inode)->i_orphan, &sbi->s_orphan);
2997 mutex_unlock(&sbi->s_orphan_lock);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002998
Jan Karad745a8c2014-05-26 11:56:53 -04002999 if (dirty) {
Jan Karaa3f5cf12020-12-16 11:18:44 +01003000 err = ext4_handle_dirty_metadata(handle, NULL, sbi->s_sbh);
Jan Karad745a8c2014-05-26 11:56:53 -04003001 rc = ext4_mark_iloc_dirty(handle, inode, &iloc);
3002 if (!err)
3003 err = rc;
3004 if (err) {
3005 /*
3006 * We have to remove inode from in-memory list if
3007 * addition to on disk orphan list failed. Stray orphan
3008 * list entries can cause panics at unmount time.
3009 */
3010 mutex_lock(&sbi->s_orphan_lock);
Jan Kara74177f552016-05-05 11:10:15 -04003011 list_del_init(&EXT4_I(inode)->i_orphan);
Jan Karad745a8c2014-05-26 11:56:53 -04003012 mutex_unlock(&sbi->s_orphan_lock);
3013 }
Vasily Averinfeaf2642018-11-06 17:01:36 -05003014 } else
3015 brelse(iloc.bh);
3016
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003017 jbd_debug(4, "superblock will point to %lu\n", inode->i_ino);
3018 jbd_debug(4, "orphan inode %lu will point to %d\n",
3019 inode->i_ino, NEXT_ORPHAN(inode));
Jan Karad745a8c2014-05-26 11:56:53 -04003020out:
Jan Karacd2c0802014-05-26 11:39:17 -04003021 ext4_std_error(sb, err);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003022 return err;
3023}
3024
3025/*
Mingming Cao617ba132006-10-11 01:20:53 -07003026 * ext4_orphan_del() removes an unlinked or truncated inode from the list
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003027 * of such inodes stored on disk, because it is finally being cleaned up.
3028 */
Mingming Cao617ba132006-10-11 01:20:53 -07003029int ext4_orphan_del(handle_t *handle, struct inode *inode)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003030{
3031 struct list_head *prev;
Mingming Cao617ba132006-10-11 01:20:53 -07003032 struct ext4_inode_info *ei = EXT4_I(inode);
Jan Karacd2c0802014-05-26 11:39:17 -04003033 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
Theodore Ts'o498e5f22008-11-05 00:14:04 -05003034 __u32 ino_next;
Mingming Cao617ba132006-10-11 01:20:53 -07003035 struct ext4_iloc iloc;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003036 int err = 0;
3037
Jan Karacd2c0802014-05-26 11:39:17 -04003038 if (!sbi->s_journal && !(sbi->s_mount_state & EXT4_ORPHAN_FS))
Frank Mayhar03901312009-01-07 00:06:22 -05003039 return 0;
3040
Jan Karad745a8c2014-05-26 11:56:53 -04003041 WARN_ON_ONCE(!(inode->i_state & (I_NEW | I_FREEING)) &&
Al Viro59551022016-01-22 15:40:57 -05003042 !inode_is_locked(inode));
Jan Karad745a8c2014-05-26 11:56:53 -04003043 /* Do this quick check before taking global s_orphan_lock. */
Theodore Ts'o3b9d4ed2009-04-25 22:54:04 -04003044 if (list_empty(&ei->i_orphan))
Jan Karad745a8c2014-05-26 11:56:53 -04003045 return 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003046
Jan Karad745a8c2014-05-26 11:56:53 -04003047 if (handle) {
3048 /* Grab inode buffer early before taking global s_orphan_lock */
3049 err = ext4_reserve_inode_write(handle, inode, &iloc);
3050 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003051
Jan Karad745a8c2014-05-26 11:56:53 -04003052 mutex_lock(&sbi->s_orphan_lock);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003053 jbd_debug(4, "remove inode %lu from orphan list\n", inode->i_ino);
3054
Jan Karad745a8c2014-05-26 11:56:53 -04003055 prev = ei->i_orphan.prev;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003056 list_del_init(&ei->i_orphan);
3057
3058 /* If we're on an error path, we may not have a valid
3059 * transaction handle with which to update the orphan list on
3060 * disk, but we still need to remove the inode from the linked
3061 * list in memory. */
Jan Karad745a8c2014-05-26 11:56:53 -04003062 if (!handle || err) {
3063 mutex_unlock(&sbi->s_orphan_lock);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003064 goto out_err;
Jan Karad745a8c2014-05-26 11:56:53 -04003065 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003066
Jan Karad745a8c2014-05-26 11:56:53 -04003067 ino_next = NEXT_ORPHAN(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003068 if (prev == &sbi->s_orphan) {
Theodore Ts'o498e5f22008-11-05 00:14:04 -05003069 jbd_debug(4, "superblock will point to %u\n", ino_next);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003070 BUFFER_TRACE(sbi->s_sbh, "get_write_access");
Mingming Cao617ba132006-10-11 01:20:53 -07003071 err = ext4_journal_get_write_access(handle, sbi->s_sbh);
Jan Karad745a8c2014-05-26 11:56:53 -04003072 if (err) {
3073 mutex_unlock(&sbi->s_orphan_lock);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003074 goto out_brelse;
Jan Karad745a8c2014-05-26 11:56:53 -04003075 }
Jan Kara05c2c002020-12-16 11:18:39 +01003076 lock_buffer(sbi->s_sbh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003077 sbi->s_es->s_last_orphan = cpu_to_le32(ino_next);
Jan Kara05c2c002020-12-16 11:18:39 +01003078 ext4_superblock_csum_set(inode->i_sb);
3079 unlock_buffer(sbi->s_sbh);
Jan Karad745a8c2014-05-26 11:56:53 -04003080 mutex_unlock(&sbi->s_orphan_lock);
Jan Karaa3f5cf12020-12-16 11:18:44 +01003081 err = ext4_handle_dirty_metadata(handle, NULL, sbi->s_sbh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003082 } else {
Mingming Cao617ba132006-10-11 01:20:53 -07003083 struct ext4_iloc iloc2;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003084 struct inode *i_prev =
Mingming Cao617ba132006-10-11 01:20:53 -07003085 &list_entry(prev, struct ext4_inode_info, i_orphan)->vfs_inode;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003086
Theodore Ts'o498e5f22008-11-05 00:14:04 -05003087 jbd_debug(4, "orphan inode %lu will point to %u\n",
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003088 i_prev->i_ino, ino_next);
Mingming Cao617ba132006-10-11 01:20:53 -07003089 err = ext4_reserve_inode_write(handle, i_prev, &iloc2);
Jan Karad745a8c2014-05-26 11:56:53 -04003090 if (err) {
3091 mutex_unlock(&sbi->s_orphan_lock);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003092 goto out_brelse;
Jan Karad745a8c2014-05-26 11:56:53 -04003093 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003094 NEXT_ORPHAN(i_prev) = ino_next;
Mingming Cao617ba132006-10-11 01:20:53 -07003095 err = ext4_mark_iloc_dirty(handle, i_prev, &iloc2);
Jan Karad745a8c2014-05-26 11:56:53 -04003096 mutex_unlock(&sbi->s_orphan_lock);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003097 }
3098 if (err)
3099 goto out_brelse;
3100 NEXT_ORPHAN(inode) = 0;
Mingming Cao617ba132006-10-11 01:20:53 -07003101 err = ext4_mark_iloc_dirty(handle, inode, &iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003102out_err:
Mingming Cao617ba132006-10-11 01:20:53 -07003103 ext4_std_error(inode->i_sb, err);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003104 return err;
3105
3106out_brelse:
3107 brelse(iloc.bh);
3108 goto out_err;
3109}
3110
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04003111static int ext4_rmdir(struct inode *dir, struct dentry *dentry)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003112{
3113 int retval;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04003114 struct inode *inode;
3115 struct buffer_head *bh;
3116 struct ext4_dir_entry_2 *de;
Theodore Ts'o8dcfaad2013-02-09 09:45:11 -05003117 handle_t *handle = NULL;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003118
Theodore Ts'o0db1ff22017-02-05 01:28:48 -05003119 if (unlikely(ext4_forced_shutdown(EXT4_SB(dir->i_sb))))
3120 return -EIO;
3121
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003122 /* Initialize quotas before so that eventual writes go in
3123 * separate transaction */
Jan Karaa7cdade2015-06-29 16:22:54 +02003124 retval = dquot_initialize(dir);
3125 if (retval)
3126 return retval;
3127 retval = dquot_initialize(d_inode(dentry));
3128 if (retval)
3129 return retval;
Christoph Hellwig907f4552010-03-03 09:05:06 -05003130
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003131 retval = -ENOENT;
Tao Ma32f7f222012-12-10 14:06:01 -05003132 bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL);
Theodore Ts'o36de9282014-08-23 17:47:19 -04003133 if (IS_ERR(bh))
3134 return PTR_ERR(bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003135 if (!bh)
3136 goto end_rmdir;
3137
David Howells2b0143b2015-03-17 22:25:59 +00003138 inode = d_inode(dentry);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003139
Darrick J. Wong6a797d22015-10-17 16:16:04 -04003140 retval = -EFSCORRUPTED;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003141 if (le32_to_cpu(de->inode) != inode->i_ino)
3142 goto end_rmdir;
3143
3144 retval = -ENOTEMPTY;
Michael Halcrowe875a2d2015-04-11 07:46:49 -04003145 if (!ext4_empty_dir(inode))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003146 goto end_rmdir;
3147
Theodore Ts'o8dcfaad2013-02-09 09:45:11 -05003148 handle = ext4_journal_start(dir, EXT4_HT_DIR,
Theodore Ts'o64044ab2013-02-09 15:06:24 -05003149 EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
Theodore Ts'o8dcfaad2013-02-09 09:45:11 -05003150 if (IS_ERR(handle)) {
3151 retval = PTR_ERR(handle);
3152 handle = NULL;
3153 goto end_rmdir;
3154 }
3155
3156 if (IS_DIRSYNC(dir))
3157 ext4_handle_sync(handle);
3158
Mingming Cao617ba132006-10-11 01:20:53 -07003159 retval = ext4_delete_entry(handle, dir, de, bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003160 if (retval)
3161 goto end_rmdir;
Andreas Dilgerf8628a12007-07-18 08:38:01 -04003162 if (!EXT4_DIR_LINK_EMPTY(inode))
Andreas Dilgerb03a2f72015-06-15 14:50:26 -04003163 ext4_warning_inode(inode,
3164 "empty directory '%.*s' has too many links (%u)",
3165 dentry->d_name.len, dentry->d_name.name,
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04003166 inode->i_nlink);
Jeff Laytonee73f9a2018-01-09 08:21:39 -05003167 inode_inc_iversion(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003168 clear_nlink(inode);
3169 /* There's no need to set i_disksize: the fact that i_nlink is
3170 * zero will ensure that the right thing happens during any
3171 * recovery. */
3172 inode->i_size = 0;
Mingming Cao617ba132006-10-11 01:20:53 -07003173 ext4_orphan_add(handle, inode);
Deepa Dinamanieeca7ea2016-11-14 21:40:10 -05003174 inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode);
Harshad Shirwadkar4209ae12020-04-26 18:34:37 -07003175 retval = ext4_mark_inode_dirty(handle, inode);
3176 if (retval)
3177 goto end_rmdir;
Nikolay Borisov15ed2852020-08-26 16:31:16 +03003178 ext4_dec_count(dir);
Mingming Cao617ba132006-10-11 01:20:53 -07003179 ext4_update_dx_flag(dir);
Harshad Shirwadkara80f7fc2020-11-05 19:58:53 -08003180 ext4_fc_track_unlink(handle, dentry);
Harshad Shirwadkar4209ae12020-04-26 18:34:37 -07003181 retval = ext4_mark_inode_dirty(handle, dir);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003182
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -04003183#ifdef CONFIG_UNICODE
3184 /* VFS negative dentries are incompatible with Encoding and
3185 * Case-insensitiveness. Eventually we'll want avoid
3186 * invalidating the dentries here, alongside with returning the
3187 * negative dentries at ext4_lookup(), when it is better
3188 * supported by the VFS for the CI case.
3189 */
3190 if (IS_CASEFOLDED(dir))
3191 d_invalidate(dentry);
3192#endif
3193
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003194end_rmdir:
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04003195 brelse(bh);
Theodore Ts'o8dcfaad2013-02-09 09:45:11 -05003196 if (handle)
3197 ext4_journal_stop(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003198 return retval;
3199}
3200
Harshad Shirwadkara80f7fc2020-11-05 19:58:53 -08003201int __ext4_unlink(handle_t *handle, struct inode *dir, const struct qstr *d_name,
Harshad Shirwadkar8016e292020-10-15 13:37:59 -07003202 struct inode *inode)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003203{
Harshad Shirwadkar8016e292020-10-15 13:37:59 -07003204 int retval = -ENOENT;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04003205 struct buffer_head *bh;
3206 struct ext4_dir_entry_2 *de;
Harshad Shirwadkar8016e292020-10-15 13:37:59 -07003207 int skip_remove_dentry = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003208
Harshad Shirwadkar8016e292020-10-15 13:37:59 -07003209 bh = ext4_find_entry(dir, d_name, &de, NULL);
3210 if (IS_ERR(bh))
3211 return PTR_ERR(bh);
Theodore Ts'o0db1ff22017-02-05 01:28:48 -05003212
Harshad Shirwadkar8016e292020-10-15 13:37:59 -07003213 if (!bh)
3214 return -ENOENT;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003215
Yi Zhuange5f78152020-06-29 20:26:21 +08003216 if (le32_to_cpu(de->inode) != inode->i_ino) {
Harshad Shirwadkar8016e292020-10-15 13:37:59 -07003217 /*
3218 * It's okay if we find dont find dentry which matches
3219 * the inode. That's because it might have gotten
3220 * renamed to a different inode number
3221 */
3222 if (EXT4_SB(inode->i_sb)->s_mount_state & EXT4_FC_REPLAY)
3223 skip_remove_dentry = 1;
3224 else
Harshad Shirwadkara80f7fc2020-11-05 19:58:53 -08003225 goto out;
Theodore Ts'o931b6862013-02-09 09:43:39 -05003226 }
3227
3228 if (IS_DIRSYNC(dir))
3229 ext4_handle_sync(handle);
3230
Harshad Shirwadkar8016e292020-10-15 13:37:59 -07003231 if (!skip_remove_dentry) {
3232 retval = ext4_delete_entry(handle, dir, de, bh);
3233 if (retval)
Harshad Shirwadkara80f7fc2020-11-05 19:58:53 -08003234 goto out;
Harshad Shirwadkar8016e292020-10-15 13:37:59 -07003235 dir->i_ctime = dir->i_mtime = current_time(dir);
3236 ext4_update_dx_flag(dir);
3237 retval = ext4_mark_inode_dirty(handle, dir);
3238 if (retval)
Harshad Shirwadkara80f7fc2020-11-05 19:58:53 -08003239 goto out;
Harshad Shirwadkar8016e292020-10-15 13:37:59 -07003240 } else {
3241 retval = 0;
3242 }
Theodore Ts'oc7df4a12019-11-11 22:18:13 -05003243 if (inode->i_nlink == 0)
3244 ext4_warning_inode(inode, "Deleting file '%.*s' with no links",
Harshad Shirwadkar8016e292020-10-15 13:37:59 -07003245 d_name->len, d_name->name);
Theodore Ts'oc7df4a12019-11-11 22:18:13 -05003246 else
3247 drop_nlink(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003248 if (!inode->i_nlink)
Mingming Cao617ba132006-10-11 01:20:53 -07003249 ext4_orphan_add(handle, inode);
Deepa Dinamanieeca7ea2016-11-14 21:40:10 -05003250 inode->i_ctime = current_time(inode);
Harshad Shirwadkar4209ae12020-04-26 18:34:37 -07003251 retval = ext4_mark_inode_dirty(handle, inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003252
Harshad Shirwadkara80f7fc2020-11-05 19:58:53 -08003253out:
Harshad Shirwadkar8016e292020-10-15 13:37:59 -07003254 brelse(bh);
3255 return retval;
3256}
3257
3258static int ext4_unlink(struct inode *dir, struct dentry *dentry)
3259{
Harshad Shirwadkara80f7fc2020-11-05 19:58:53 -08003260 handle_t *handle;
Harshad Shirwadkar8016e292020-10-15 13:37:59 -07003261 int retval;
3262
3263 if (unlikely(ext4_forced_shutdown(EXT4_SB(dir->i_sb))))
3264 return -EIO;
3265
3266 trace_ext4_unlink_enter(dir, dentry);
3267 /*
3268 * Initialize quotas before so that eventual writes go
3269 * in separate transaction
3270 */
3271 retval = dquot_initialize(dir);
3272 if (retval)
3273 goto out_trace;
3274 retval = dquot_initialize(d_inode(dentry));
3275 if (retval)
3276 goto out_trace;
3277
Harshad Shirwadkara80f7fc2020-11-05 19:58:53 -08003278 handle = ext4_journal_start(dir, EXT4_HT_DIR,
3279 EXT4_DATA_TRANS_BLOCKS(dir->i_sb));
3280 if (IS_ERR(handle)) {
3281 retval = PTR_ERR(handle);
3282 goto out_trace;
3283 }
3284
3285 retval = __ext4_unlink(handle, dir, &dentry->d_name, d_inode(dentry));
Harshad Shirwadkaraa75f4d2020-10-15 13:37:57 -07003286 if (!retval)
Harshad Shirwadkara80f7fc2020-11-05 19:58:53 -08003287 ext4_fc_track_unlink(handle, dentry);
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -04003288#ifdef CONFIG_UNICODE
3289 /* VFS negative dentries are incompatible with Encoding and
3290 * Case-insensitiveness. Eventually we'll want avoid
3291 * invalidating the dentries here, alongside with returning the
3292 * negative dentries at ext4_lookup(), when it is better
3293 * supported by the VFS for the CI case.
3294 */
3295 if (IS_CASEFOLDED(dir))
3296 d_invalidate(dentry);
3297#endif
Harshad Shirwadkara80f7fc2020-11-05 19:58:53 -08003298 if (handle)
3299 ext4_journal_stop(handle);
Gabriel Krisman Bertazib886ee32019-04-25 14:12:08 -04003300
Yi Zhuange5f78152020-06-29 20:26:21 +08003301out_trace:
Jiaying Zhang0562e0b2011-03-21 21:38:05 -04003302 trace_ext4_unlink_exit(dentry, retval);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003303 return retval;
3304}
3305
Christian Brauner549c7292021-01-21 14:19:43 +01003306static int ext4_symlink(struct user_namespace *mnt_userns, struct inode *dir,
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04003307 struct dentry *dentry, const char *symname)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003308{
3309 handle_t *handle;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04003310 struct inode *inode;
Theodore Ts'of348c252015-04-16 01:55:00 -04003311 int err, len = strlen(symname);
Jan Karadf5e6222011-05-03 11:12:58 -04003312 int credits;
Jaegeuk Kima7550b32016-07-10 14:01:03 -04003313 struct fscrypt_str disk_link;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003314
Theodore Ts'o0db1ff22017-02-05 01:28:48 -05003315 if (unlikely(ext4_forced_shutdown(EXT4_SB(dir->i_sb))))
3316 return -EIO;
3317
Eric Biggers78e10602018-01-11 22:10:40 -05003318 err = fscrypt_prepare_symlink(dir, symname, len, dir->i_sb->s_blocksize,
3319 &disk_link);
3320 if (err)
3321 return err;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003322
Jan Karaa7cdade2015-06-29 16:22:54 +02003323 err = dquot_initialize(dir);
3324 if (err)
Eric Biggers78e10602018-01-11 22:10:40 -05003325 return err;
Christoph Hellwig907f4552010-03-03 09:05:06 -05003326
Theodore Ts'of348c252015-04-16 01:55:00 -04003327 if ((disk_link.len > EXT4_N_BLOCKS * 4)) {
Jan Karadf5e6222011-05-03 11:12:58 -04003328 /*
3329 * For non-fast symlinks, we just allocate inode and put it on
3330 * orphan list in the first transaction => we need bitmap,
Eric Sandeen8c208712011-08-11 09:54:31 -05003331 * group descriptor, sb, inode block, quota blocks, and
3332 * possibly selinux xattr blocks.
Jan Karadf5e6222011-05-03 11:12:58 -04003333 */
Eric Sandeen8c208712011-08-11 09:54:31 -05003334 credits = 4 + EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) +
3335 EXT4_XATTR_TRANS_BLOCKS;
Jan Karadf5e6222011-05-03 11:12:58 -04003336 } else {
3337 /*
3338 * Fast symlink. We have to add entry to directory
3339 * (EXT4_DATA_TRANS_BLOCKS + EXT4_INDEX_EXTRA_TRANS_BLOCKS),
3340 * allocate new inode (bitmap, group descriptor, inode block,
3341 * quota blocks, sb is already counted in previous macros).
3342 */
3343 credits = EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
Jan Karaeb9cc7e2013-04-19 13:38:14 -04003344 EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3;
Jan Karadf5e6222011-05-03 11:12:58 -04003345 }
Theodore Ts'of348c252015-04-16 01:55:00 -04003346
Christian Brauner14f3db52021-01-21 14:19:57 +01003347 inode = ext4_new_inode_start_handle(mnt_userns, dir, S_IFLNK|S_IRWXUGO,
Theodore Ts'o11395752013-02-09 16:27:09 -05003348 &dentry->d_name, 0, NULL,
3349 EXT4_HT_DIR, credits);
3350 handle = ext4_journal_current_handle();
Theodore Ts'of348c252015-04-16 01:55:00 -04003351 if (IS_ERR(inode)) {
3352 if (handle)
3353 ext4_journal_stop(handle);
Eric Biggers78e10602018-01-11 22:10:40 -05003354 return PTR_ERR(inode);
Theodore Ts'of348c252015-04-16 01:55:00 -04003355 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003356
Eric Biggers78e10602018-01-11 22:10:40 -05003357 if (IS_ENCRYPTED(inode)) {
3358 err = fscrypt_encrypt_symlink(inode, symname, len, &disk_link);
Eric Biggersef1eb3a2016-09-15 17:25:55 -04003359 if (err)
Theodore Ts'of348c252015-04-16 01:55:00 -04003360 goto err_drop_inode;
Al Viroa7a67e82015-04-27 17:51:30 -04003361 inode->i_op = &ext4_encrypted_symlink_inode_operations;
Theodore Ts'of348c252015-04-16 01:55:00 -04003362 }
3363
3364 if ((disk_link.len > EXT4_N_BLOCKS * 4)) {
Eric Biggers78e10602018-01-11 22:10:40 -05003365 if (!IS_ENCRYPTED(inode))
Al Viroa7a67e82015-04-27 17:51:30 -04003366 inode->i_op = &ext4_symlink_inode_operations;
Al Viro21fc61c2015-11-17 01:07:57 -05003367 inode_nohighmem(inode);
Mingming Cao617ba132006-10-11 01:20:53 -07003368 ext4_set_aops(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003369 /*
Jan Karadf5e6222011-05-03 11:12:58 -04003370 * We cannot call page_symlink() with transaction started
3371 * because it calls into ext4_write_begin() which can wait
3372 * for transaction commit if we are running out of space
3373 * and thus we deadlock. So we have to stop transaction now
3374 * and restart it when symlink contents is written.
3375 *
3376 * To keep fs consistent in case of crash, we have to put inode
3377 * to orphan list in the mean time.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003378 */
Jan Karadf5e6222011-05-03 11:12:58 -04003379 drop_nlink(inode);
3380 err = ext4_orphan_add(handle, inode);
Harshad Shirwadkar8016e292020-10-15 13:37:59 -07003381 if (handle)
3382 ext4_journal_stop(handle);
Theodore Ts'of348c252015-04-16 01:55:00 -04003383 handle = NULL;
Jan Karadf5e6222011-05-03 11:12:58 -04003384 if (err)
3385 goto err_drop_inode;
Theodore Ts'of348c252015-04-16 01:55:00 -04003386 err = __page_symlink(inode, disk_link.name, disk_link.len, 1);
Jan Karadf5e6222011-05-03 11:12:58 -04003387 if (err)
3388 goto err_drop_inode;
3389 /*
3390 * Now inode is being linked into dir (EXT4_DATA_TRANS_BLOCKS
3391 * + EXT4_INDEX_EXTRA_TRANS_BLOCKS), inode is also modified
3392 */
Theodore Ts'o9924a922013-02-08 21:59:22 -05003393 handle = ext4_journal_start(dir, EXT4_HT_DIR,
Jan Karadf5e6222011-05-03 11:12:58 -04003394 EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
3395 EXT4_INDEX_EXTRA_TRANS_BLOCKS + 1);
3396 if (IS_ERR(handle)) {
3397 err = PTR_ERR(handle);
Theodore Ts'of348c252015-04-16 01:55:00 -04003398 handle = NULL;
Jan Karadf5e6222011-05-03 11:12:58 -04003399 goto err_drop_inode;
3400 }
Al Viro0ce8c0102012-01-08 19:50:23 -05003401 set_nlink(inode, 1);
Jan Karadf5e6222011-05-03 11:12:58 -04003402 err = ext4_orphan_del(handle, inode);
Theodore Ts'of348c252015-04-16 01:55:00 -04003403 if (err)
Jan Karadf5e6222011-05-03 11:12:58 -04003404 goto err_drop_inode;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003405 } else {
Aneesh Kumar K.Ve65187e2008-04-29 08:11:12 -04003406 /* clear the extent format for fast symlink */
Dmitry Monakhov12e9b892010-05-16 22:00:00 -04003407 ext4_clear_inode_flag(inode, EXT4_INODE_EXTENTS);
Eric Biggers78e10602018-01-11 22:10:40 -05003408 if (!IS_ENCRYPTED(inode)) {
Al Viroa7a67e82015-04-27 17:51:30 -04003409 inode->i_op = &ext4_fast_symlink_inode_operations;
Al Viro75e75662015-05-02 10:13:58 -04003410 inode->i_link = (char *)&EXT4_I(inode)->i_data;
3411 }
Theodore Ts'of348c252015-04-16 01:55:00 -04003412 memcpy((char *)&EXT4_I(inode)->i_data, disk_link.name,
3413 disk_link.len);
3414 inode->i_size = disk_link.len - 1;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003415 }
Mingming Cao617ba132006-10-11 01:20:53 -07003416 EXT4_I(inode)->i_disksize = inode->i_size;
Jan Kara9b88f9f2019-11-05 17:44:11 +01003417 err = ext4_add_nondir(handle, dentry, &inode);
Theodore Ts'o11395752013-02-09 16:27:09 -05003418 if (handle)
3419 ext4_journal_stop(handle);
Jan Kara9b88f9f2019-11-05 17:44:11 +01003420 if (inode)
3421 iput(inode);
Eric Biggers78e10602018-01-11 22:10:40 -05003422 goto out_free_encrypted_link;
3423
Jan Karadf5e6222011-05-03 11:12:58 -04003424err_drop_inode:
Theodore Ts'of348c252015-04-16 01:55:00 -04003425 if (handle)
3426 ext4_journal_stop(handle);
Theodore Ts'of348c252015-04-16 01:55:00 -04003427 clear_nlink(inode);
Jan Karadf5e6222011-05-03 11:12:58 -04003428 unlock_new_inode(inode);
3429 iput(inode);
Eric Biggers78e10602018-01-11 22:10:40 -05003430out_free_encrypted_link:
3431 if (disk_link.name != (unsigned char *)symname)
3432 kfree(disk_link.name);
Jan Karadf5e6222011-05-03 11:12:58 -04003433 return err;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003434}
3435
Harshad Shirwadkar8016e292020-10-15 13:37:59 -07003436int __ext4_link(struct inode *dir, struct inode *inode, struct dentry *dentry)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003437{
3438 handle_t *handle;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003439 int err, retries = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003440retry:
Theodore Ts'o9924a922013-02-08 21:59:22 -05003441 handle = ext4_journal_start(dir, EXT4_HT_DIR,
3442 (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
Al Viroaf51a2a2013-06-29 13:23:08 +04003443 EXT4_INDEX_EXTRA_TRANS_BLOCKS) + 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003444 if (IS_ERR(handle))
3445 return PTR_ERR(handle);
3446
3447 if (IS_DIRSYNC(dir))
Frank Mayhar03901312009-01-07 00:06:22 -05003448 ext4_handle_sync(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003449
Deepa Dinamanieeca7ea2016-11-14 21:40:10 -05003450 inode->i_ctime = current_time(inode);
Nikolay Borisov15ed2852020-08-26 16:31:16 +03003451 ext4_inc_count(inode);
Al Viro7de9c6ee2010-10-23 11:11:40 -04003452 ihold(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003453
Al Viro6b38e842008-12-30 02:03:31 -05003454 err = ext4_add_entry(handle, dentry, inode);
3455 if (!err) {
Harshad Shirwadkar4209ae12020-04-26 18:34:37 -07003456 err = ext4_mark_inode_dirty(handle, inode);
Al Viroaf51a2a2013-06-29 13:23:08 +04003457 /* this can happen only for tmpfile being
3458 * linked the first time
3459 */
3460 if (inode->i_nlink == 1)
3461 ext4_orphan_del(handle, inode);
Al Viro6b38e842008-12-30 02:03:31 -05003462 d_instantiate(dentry, inode);
Harshad Shirwadkara80f7fc2020-11-05 19:58:53 -08003463 ext4_fc_track_link(handle, dentry);
Al Viro6b38e842008-12-30 02:03:31 -05003464 } else {
3465 drop_nlink(inode);
3466 iput(inode);
3467 }
Mingming Cao617ba132006-10-11 01:20:53 -07003468 ext4_journal_stop(handle);
3469 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003470 goto retry;
3471 return err;
3472}
3473
Harshad Shirwadkar8016e292020-10-15 13:37:59 -07003474static int ext4_link(struct dentry *old_dentry,
3475 struct inode *dir, struct dentry *dentry)
3476{
3477 struct inode *inode = d_inode(old_dentry);
3478 int err;
3479
3480 if (inode->i_nlink >= EXT4_LINK_MAX)
3481 return -EMLINK;
3482
3483 err = fscrypt_prepare_link(old_dentry, dir, dentry);
3484 if (err)
3485 return err;
3486
3487 if ((ext4_test_inode_flag(dir, EXT4_INODE_PROJINHERIT)) &&
3488 (!projid_eq(EXT4_I(dir)->i_projid,
3489 EXT4_I(old_dentry->d_inode)->i_projid)))
3490 return -EXDEV;
3491
3492 err = dquot_initialize(dir);
3493 if (err)
3494 return err;
3495 return __ext4_link(dir, inode, dentry);
3496}
Tao Ma32f7f222012-12-10 14:06:01 -05003497
3498/*
3499 * Try to find buffer head where contains the parent block.
3500 * It should be the inode block if it is inlined or the 1st block
3501 * if it is a normal dir.
3502 */
3503static struct buffer_head *ext4_get_first_dir_block(handle_t *handle,
3504 struct inode *inode,
3505 int *retval,
3506 struct ext4_dir_entry_2 **parent_de,
3507 int *inlined)
3508{
3509 struct buffer_head *bh;
3510
3511 if (!ext4_has_inline_data(inode)) {
Theodore Ts'o4e19d6b2019-06-20 21:19:02 -04003512 /* The first directory block must not be a hole, so
3513 * treat it as DIRENT_HTREE
3514 */
3515 bh = ext4_read_dirblock(inode, 0, DIRENT_HTREE);
Theodore Ts'odc6982ff2013-02-14 23:59:26 -05003516 if (IS_ERR(bh)) {
3517 *retval = PTR_ERR(bh);
Tao Ma32f7f222012-12-10 14:06:01 -05003518 return NULL;
3519 }
3520 *parent_de = ext4_next_entry(
3521 (struct ext4_dir_entry_2 *)bh->b_data,
3522 inode->i_sb->s_blocksize);
3523 return bh;
3524 }
3525
3526 *inlined = 1;
3527 return ext4_get_first_inline_block(inode, parent_de, retval);
3528}
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003529
Miklos Szeredic0d268c2014-04-01 17:08:43 +02003530struct ext4_renament {
3531 struct inode *dir;
3532 struct dentry *dentry;
3533 struct inode *inode;
Miklos Szeredibd429982014-04-01 17:08:44 +02003534 bool is_dir;
3535 int dir_nlink_delta;
Miklos Szeredic0d268c2014-04-01 17:08:43 +02003536
3537 /* entry for "dentry" */
3538 struct buffer_head *bh;
3539 struct ext4_dir_entry_2 *de;
3540 int inlined;
3541
3542 /* entry for ".." in inode if it's a directory */
3543 struct buffer_head *dir_bh;
3544 struct ext4_dir_entry_2 *parent_de;
3545 int dir_inlined;
3546};
3547
Miklos Szeredibd1af142014-04-01 17:08:44 +02003548static int ext4_rename_dir_prepare(handle_t *handle, struct ext4_renament *ent)
3549{
3550 int retval;
3551
3552 ent->dir_bh = ext4_get_first_dir_block(handle, ent->inode,
3553 &retval, &ent->parent_de,
3554 &ent->dir_inlined);
3555 if (!ent->dir_bh)
3556 return retval;
3557 if (le32_to_cpu(ent->parent_de->inode) != ent->dir->i_ino)
Darrick J. Wong6a797d22015-10-17 16:16:04 -04003558 return -EFSCORRUPTED;
Miklos Szeredibd1af142014-04-01 17:08:44 +02003559 BUFFER_TRACE(ent->dir_bh, "get_write_access");
3560 return ext4_journal_get_write_access(handle, ent->dir_bh);
3561}
3562
3563static int ext4_rename_dir_finish(handle_t *handle, struct ext4_renament *ent,
3564 unsigned dir_ino)
3565{
3566 int retval;
3567
3568 ent->parent_de->inode = cpu_to_le32(dir_ino);
3569 BUFFER_TRACE(ent->dir_bh, "call ext4_handle_dirty_metadata");
3570 if (!ent->dir_inlined) {
3571 if (is_dx(ent->inode)) {
3572 retval = ext4_handle_dirty_dx_node(handle,
3573 ent->inode,
3574 ent->dir_bh);
3575 } else {
Theodore Ts'of036adb2019-06-21 15:49:26 -04003576 retval = ext4_handle_dirty_dirblock(handle, ent->inode,
3577 ent->dir_bh);
Miklos Szeredibd1af142014-04-01 17:08:44 +02003578 }
3579 } else {
3580 retval = ext4_mark_inode_dirty(handle, ent->inode);
3581 }
3582 if (retval) {
3583 ext4_std_error(ent->dir->i_sb, retval);
3584 return retval;
3585 }
3586 return 0;
3587}
3588
3589static int ext4_setent(handle_t *handle, struct ext4_renament *ent,
3590 unsigned ino, unsigned file_type)
3591{
Harshad Shirwadkar4209ae12020-04-26 18:34:37 -07003592 int retval, retval2;
Miklos Szeredibd1af142014-04-01 17:08:44 +02003593
3594 BUFFER_TRACE(ent->bh, "get write access");
3595 retval = ext4_journal_get_write_access(handle, ent->bh);
3596 if (retval)
3597 return retval;
3598 ent->de->inode = cpu_to_le32(ino);
Darrick J. Wonge2b911c2015-10-17 16:18:43 -04003599 if (ext4_has_feature_filetype(ent->dir->i_sb))
Miklos Szeredibd1af142014-04-01 17:08:44 +02003600 ent->de->file_type = file_type;
Jeff Laytonee73f9a2018-01-09 08:21:39 -05003601 inode_inc_iversion(ent->dir);
Miklos Szeredibd1af142014-04-01 17:08:44 +02003602 ent->dir->i_ctime = ent->dir->i_mtime =
Deepa Dinamanieeca7ea2016-11-14 21:40:10 -05003603 current_time(ent->dir);
Harshad Shirwadkar4209ae12020-04-26 18:34:37 -07003604 retval = ext4_mark_inode_dirty(handle, ent->dir);
Miklos Szeredibd1af142014-04-01 17:08:44 +02003605 BUFFER_TRACE(ent->bh, "call ext4_handle_dirty_metadata");
3606 if (!ent->inlined) {
Harshad Shirwadkar4209ae12020-04-26 18:34:37 -07003607 retval2 = ext4_handle_dirty_dirblock(handle, ent->dir, ent->bh);
3608 if (unlikely(retval2)) {
3609 ext4_std_error(ent->dir->i_sb, retval2);
3610 return retval2;
Miklos Szeredibd1af142014-04-01 17:08:44 +02003611 }
3612 }
Harshad Shirwadkar4209ae12020-04-26 18:34:37 -07003613 return retval;
Miklos Szeredibd1af142014-04-01 17:08:44 +02003614}
3615
zhangyi (F)b7ff91f2021-03-03 21:17:02 +08003616static void ext4_resetent(handle_t *handle, struct ext4_renament *ent,
3617 unsigned ino, unsigned file_type)
3618{
3619 struct ext4_renament old = *ent;
3620 int retval = 0;
3621
3622 /*
3623 * old->de could have moved from under us during make indexed dir,
3624 * so the old->de may no longer valid and need to find it again
3625 * before reset old inode info.
3626 */
3627 old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de, NULL);
3628 if (IS_ERR(old.bh))
3629 retval = PTR_ERR(old.bh);
3630 if (!old.bh)
3631 retval = -ENOENT;
3632 if (retval) {
3633 ext4_std_error(old.dir->i_sb, retval);
3634 return;
3635 }
3636
3637 ext4_setent(handle, &old, ino, file_type);
3638 brelse(old.bh);
3639}
3640
Miklos Szeredibd1af142014-04-01 17:08:44 +02003641static int ext4_find_delete_entry(handle_t *handle, struct inode *dir,
3642 const struct qstr *d_name)
3643{
3644 int retval = -ENOENT;
3645 struct buffer_head *bh;
3646 struct ext4_dir_entry_2 *de;
3647
3648 bh = ext4_find_entry(dir, d_name, &de, NULL);
Theodore Ts'o36de9282014-08-23 17:47:19 -04003649 if (IS_ERR(bh))
3650 return PTR_ERR(bh);
Miklos Szeredibd1af142014-04-01 17:08:44 +02003651 if (bh) {
3652 retval = ext4_delete_entry(handle, dir, de, bh);
3653 brelse(bh);
3654 }
3655 return retval;
3656}
3657
Darrick J. Wongd80d4482014-08-27 18:40:09 -04003658static void ext4_rename_delete(handle_t *handle, struct ext4_renament *ent,
3659 int force_reread)
Miklos Szeredibd1af142014-04-01 17:08:44 +02003660{
3661 int retval;
3662 /*
3663 * ent->de could have moved from under us during htree split, so make
3664 * sure that we are deleting the right entry. We might also be pointing
3665 * to a stale entry in the unused part of ent->bh so just checking inum
3666 * and the name isn't enough.
3667 */
3668 if (le32_to_cpu(ent->de->inode) != ent->inode->i_ino ||
3669 ent->de->name_len != ent->dentry->d_name.len ||
3670 strncmp(ent->de->name, ent->dentry->d_name.name,
Darrick J. Wongd80d4482014-08-27 18:40:09 -04003671 ent->de->name_len) ||
3672 force_reread) {
Miklos Szeredibd1af142014-04-01 17:08:44 +02003673 retval = ext4_find_delete_entry(handle, ent->dir,
3674 &ent->dentry->d_name);
3675 } else {
3676 retval = ext4_delete_entry(handle, ent->dir, ent->de, ent->bh);
3677 if (retval == -ENOENT) {
3678 retval = ext4_find_delete_entry(handle, ent->dir,
3679 &ent->dentry->d_name);
3680 }
3681 }
3682
3683 if (retval) {
Andreas Dilgerb03a2f72015-06-15 14:50:26 -04003684 ext4_warning_inode(ent->dir,
3685 "Deleting old file: nlink %d, error=%d",
3686 ent->dir->i_nlink, retval);
Miklos Szeredibd1af142014-04-01 17:08:44 +02003687 }
3688}
3689
Miklos Szeredibd429982014-04-01 17:08:44 +02003690static void ext4_update_dir_count(handle_t *handle, struct ext4_renament *ent)
3691{
3692 if (ent->dir_nlink_delta) {
3693 if (ent->dir_nlink_delta == -1)
Nikolay Borisov15ed2852020-08-26 16:31:16 +03003694 ext4_dec_count(ent->dir);
Miklos Szeredibd429982014-04-01 17:08:44 +02003695 else
Nikolay Borisov15ed2852020-08-26 16:31:16 +03003696 ext4_inc_count(ent->dir);
Miklos Szeredibd429982014-04-01 17:08:44 +02003697 ext4_mark_inode_dirty(handle, ent->dir);
3698 }
3699}
3700
Christian Brauner14f3db52021-01-21 14:19:57 +01003701static struct inode *ext4_whiteout_for_rename(struct user_namespace *mnt_userns,
3702 struct ext4_renament *ent,
Miklos Szeredicd808de2014-10-24 00:14:37 +02003703 int credits, handle_t **h)
3704{
3705 struct inode *wh;
3706 handle_t *handle;
3707 int retries = 0;
3708
3709 /*
3710 * for inode block, sb block, group summaries,
3711 * and inode bitmap
3712 */
3713 credits += (EXT4_MAXQUOTAS_TRANS_BLOCKS(ent->dir->i_sb) +
3714 EXT4_XATTR_TRANS_BLOCKS + 4);
3715retry:
Christian Brauner14f3db52021-01-21 14:19:57 +01003716 wh = ext4_new_inode_start_handle(mnt_userns, ent->dir,
3717 S_IFCHR | WHITEOUT_MODE,
Miklos Szeredicd808de2014-10-24 00:14:37 +02003718 &ent->dentry->d_name, 0, NULL,
3719 EXT4_HT_DIR, credits);
3720
3721 handle = ext4_journal_current_handle();
3722 if (IS_ERR(wh)) {
3723 if (handle)
3724 ext4_journal_stop(handle);
3725 if (PTR_ERR(wh) == -ENOSPC &&
3726 ext4_should_retry_alloc(ent->dir->i_sb, &retries))
3727 goto retry;
3728 } else {
3729 *h = handle;
3730 init_special_inode(wh, wh->i_mode, WHITEOUT_DEV);
3731 wh->i_op = &ext4_special_inode_operations;
3732 }
3733 return wh;
3734}
3735
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003736/*
3737 * Anybody can rename anything with this: the permission checks are left to the
3738 * higher-level routines.
Theodore Ts'o0e202702013-08-16 22:06:53 -04003739 *
3740 * n.b. old_{dentry,inode) refers to the source dentry/inode
3741 * while new_{dentry,inode) refers to the destination dentry/inode
3742 * This comes from rename(const char *oldpath, const char *newpath)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003743 */
Christian Brauner14f3db52021-01-21 14:19:57 +01003744static int ext4_rename(struct user_namespace *mnt_userns, struct inode *old_dir,
3745 struct dentry *old_dentry, struct inode *new_dir,
3746 struct dentry *new_dentry, unsigned int flags)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003747{
Theodore Ts'o5b61de72013-08-16 22:06:14 -04003748 handle_t *handle = NULL;
Miklos Szeredic0d268c2014-04-01 17:08:43 +02003749 struct ext4_renament old = {
3750 .dir = old_dir,
3751 .dentry = old_dentry,
David Howells2b0143b2015-03-17 22:25:59 +00003752 .inode = d_inode(old_dentry),
Miklos Szeredic0d268c2014-04-01 17:08:43 +02003753 };
3754 struct ext4_renament new = {
3755 .dir = new_dir,
3756 .dentry = new_dentry,
David Howells2b0143b2015-03-17 22:25:59 +00003757 .inode = d_inode(new_dentry),
Miklos Szeredic0d268c2014-04-01 17:08:43 +02003758 };
Darrick J. Wongd80d4482014-08-27 18:40:09 -04003759 int force_reread;
Theodore Ts'o0e202702013-08-16 22:06:53 -04003760 int retval;
Miklos Szeredicd808de2014-10-24 00:14:37 +02003761 struct inode *whiteout = NULL;
3762 int credits;
3763 u8 old_file_type;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003764
Theodore Ts'ob50282f2018-08-27 01:47:09 -04003765 if (new.inode && new.inode->i_nlink == 0) {
3766 EXT4_ERROR_INODE(new.inode,
3767 "target of rename is already freed");
3768 return -EFSCORRUPTED;
3769 }
3770
Li Xi040cb372016-01-08 16:01:21 -05003771 if ((ext4_test_inode_flag(new_dir, EXT4_INODE_PROJINHERIT)) &&
3772 (!projid_eq(EXT4_I(new_dir)->i_projid,
3773 EXT4_I(old_dentry->d_inode)->i_projid)))
3774 return -EXDEV;
3775
Jan Karaa7cdade2015-06-29 16:22:54 +02003776 retval = dquot_initialize(old.dir);
3777 if (retval)
3778 return retval;
3779 retval = dquot_initialize(new.dir);
3780 if (retval)
3781 return retval;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003782
3783 /* Initialize quotas before so that eventual writes go
3784 * in separate transaction */
Jan Karaa7cdade2015-06-29 16:22:54 +02003785 if (new.inode) {
3786 retval = dquot_initialize(new.inode);
3787 if (retval)
3788 return retval;
3789 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003790
Miklos Szeredic0d268c2014-04-01 17:08:43 +02003791 old.bh = ext4_find_entry(old.dir, &old.dentry->d_name, &old.de, NULL);
Theodore Ts'o36de9282014-08-23 17:47:19 -04003792 if (IS_ERR(old.bh))
3793 return PTR_ERR(old.bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003794 /*
3795 * Check for inode number is _not_ due to possible IO errors.
3796 * We might rmdir the source, keep it as pwd of some process
3797 * and merrily kill the link to whatever was created under the
3798 * same name. Goodbye sticky bit ;-<
3799 */
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003800 retval = -ENOENT;
Miklos Szeredic0d268c2014-04-01 17:08:43 +02003801 if (!old.bh || le32_to_cpu(old.de->inode) != old.inode->i_ino)
zhangyi (F)5dccdc52021-03-03 21:17:03 +08003802 goto release_bh;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003803
Miklos Szeredic0d268c2014-04-01 17:08:43 +02003804 new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
3805 &new.de, &new.inlined);
Theodore Ts'o36de9282014-08-23 17:47:19 -04003806 if (IS_ERR(new.bh)) {
3807 retval = PTR_ERR(new.bh);
Theodore Ts'oa9cfcd62014-09-03 09:33:00 -04003808 new.bh = NULL;
zhangyi (F)5dccdc52021-03-03 21:17:03 +08003809 goto release_bh;
Theodore Ts'o36de9282014-08-23 17:47:19 -04003810 }
Miklos Szeredic0d268c2014-04-01 17:08:43 +02003811 if (new.bh) {
3812 if (!new.inode) {
3813 brelse(new.bh);
3814 new.bh = NULL;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003815 }
3816 }
Miklos Szeredic0d268c2014-04-01 17:08:43 +02003817 if (new.inode && !test_opt(new.dir->i_sb, NO_AUTO_DA_ALLOC))
3818 ext4_alloc_da_blocks(old.inode);
Theodore Ts'o5b61de72013-08-16 22:06:14 -04003819
Miklos Szeredicd808de2014-10-24 00:14:37 +02003820 credits = (2 * EXT4_DATA_TRANS_BLOCKS(old.dir->i_sb) +
3821 EXT4_INDEX_EXTRA_TRANS_BLOCKS + 2);
3822 if (!(flags & RENAME_WHITEOUT)) {
3823 handle = ext4_journal_start(old.dir, EXT4_HT_DIR, credits);
Konstantin Khlebnikov7071b712015-04-02 16:32:15 -04003824 if (IS_ERR(handle)) {
3825 retval = PTR_ERR(handle);
zhangyi (F)5dccdc52021-03-03 21:17:03 +08003826 goto release_bh;
Konstantin Khlebnikov7071b712015-04-02 16:32:15 -04003827 }
Miklos Szeredicd808de2014-10-24 00:14:37 +02003828 } else {
Christian Brauner14f3db52021-01-21 14:19:57 +01003829 whiteout = ext4_whiteout_for_rename(mnt_userns, &old, credits, &handle);
Konstantin Khlebnikov7071b712015-04-02 16:32:15 -04003830 if (IS_ERR(whiteout)) {
3831 retval = PTR_ERR(whiteout);
zhangyi (F)5dccdc52021-03-03 21:17:03 +08003832 goto release_bh;
Konstantin Khlebnikov7071b712015-04-02 16:32:15 -04003833 }
Miklos Szeredicd808de2014-10-24 00:14:37 +02003834 }
Theodore Ts'o5b61de72013-08-16 22:06:14 -04003835
yangerkun6b4b8e62021-01-05 14:28:57 +08003836 old_file_type = old.de->file_type;
Miklos Szeredic0d268c2014-04-01 17:08:43 +02003837 if (IS_DIRSYNC(old.dir) || IS_DIRSYNC(new.dir))
Theodore Ts'o5b61de72013-08-16 22:06:14 -04003838 ext4_handle_sync(handle);
3839
Miklos Szeredic0d268c2014-04-01 17:08:43 +02003840 if (S_ISDIR(old.inode->i_mode)) {
3841 if (new.inode) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003842 retval = -ENOTEMPTY;
Michael Halcrowe875a2d2015-04-11 07:46:49 -04003843 if (!ext4_empty_dir(new.inode))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003844 goto end_rename;
Miklos Szeredi0d7d5d62014-04-01 17:08:44 +02003845 } else {
3846 retval = -EMLINK;
3847 if (new.dir != old.dir && EXT4_DIR_LINK_MAX(new.dir))
3848 goto end_rename;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003849 }
Miklos Szeredibd1af142014-04-01 17:08:44 +02003850 retval = ext4_rename_dir_prepare(handle, &old);
Amir Goldsteinef607892011-03-20 21:18:44 -04003851 if (retval)
3852 goto end_rename;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003853 }
Darrick J. Wongd80d4482014-08-27 18:40:09 -04003854 /*
3855 * If we're renaming a file within an inline_data dir and adding or
3856 * setting the new dirent causes a conversion from inline_data to
3857 * extents/blockmap, we need to force the dirent delete code to
3858 * re-read the directory, or else we end up trying to delete a dirent
3859 * from what is now the extent tree root (or a block map).
3860 */
3861 force_reread = (new.dir->i_ino == old.dir->i_ino &&
3862 ext4_test_inode_flag(new.dir, EXT4_INODE_INLINE_DATA));
Miklos Szeredicd808de2014-10-24 00:14:37 +02003863
Miklos Szeredicd808de2014-10-24 00:14:37 +02003864 if (whiteout) {
3865 /*
3866 * Do this before adding a new entry, so the old entry is sure
3867 * to be still pointing to the valid old entry.
3868 */
3869 retval = ext4_setent(handle, &old, whiteout->i_ino,
3870 EXT4_FT_CHRDEV);
3871 if (retval)
3872 goto end_rename;
Harshad Shirwadkar4209ae12020-04-26 18:34:37 -07003873 retval = ext4_mark_inode_dirty(handle, whiteout);
3874 if (unlikely(retval))
3875 goto end_rename;
Harshad Shirwadkar8210bb22021-03-16 15:19:21 -07003876
Miklos Szeredicd808de2014-10-24 00:14:37 +02003877 }
Miklos Szeredic0d268c2014-04-01 17:08:43 +02003878 if (!new.bh) {
3879 retval = ext4_add_entry(handle, new.dentry, old.inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003880 if (retval)
3881 goto end_rename;
3882 } else {
Miklos Szeredibd1af142014-04-01 17:08:44 +02003883 retval = ext4_setent(handle, &new,
Miklos Szeredicd808de2014-10-24 00:14:37 +02003884 old.inode->i_ino, old_file_type);
Amir Goldsteinef607892011-03-20 21:18:44 -04003885 if (retval)
3886 goto end_rename;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003887 }
Darrick J. Wongd80d4482014-08-27 18:40:09 -04003888 if (force_reread)
3889 force_reread = !ext4_test_inode_flag(new.dir,
3890 EXT4_INODE_INLINE_DATA);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003891
3892 /*
3893 * Like most other Unix systems, set the ctime for inodes on a
3894 * rename.
3895 */
Deepa Dinamanieeca7ea2016-11-14 21:40:10 -05003896 old.inode->i_ctime = current_time(old.inode);
Harshad Shirwadkar4209ae12020-04-26 18:34:37 -07003897 retval = ext4_mark_inode_dirty(handle, old.inode);
3898 if (unlikely(retval))
3899 goto end_rename;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003900
Miklos Szeredicd808de2014-10-24 00:14:37 +02003901 if (!whiteout) {
3902 /*
3903 * ok, that's it
3904 */
3905 ext4_rename_delete(handle, &old, force_reread);
3906 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003907
Miklos Szeredic0d268c2014-04-01 17:08:43 +02003908 if (new.inode) {
Nikolay Borisov15ed2852020-08-26 16:31:16 +03003909 ext4_dec_count(new.inode);
Deepa Dinamanieeca7ea2016-11-14 21:40:10 -05003910 new.inode->i_ctime = current_time(new.inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003911 }
Deepa Dinamanieeca7ea2016-11-14 21:40:10 -05003912 old.dir->i_ctime = old.dir->i_mtime = current_time(old.dir);
Miklos Szeredic0d268c2014-04-01 17:08:43 +02003913 ext4_update_dx_flag(old.dir);
3914 if (old.dir_bh) {
Miklos Szeredibd1af142014-04-01 17:08:44 +02003915 retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
3916 if (retval)
Theodore Ts'ob4097142011-01-10 12:46:59 -05003917 goto end_rename;
Miklos Szeredibd1af142014-04-01 17:08:44 +02003918
Nikolay Borisov15ed2852020-08-26 16:31:16 +03003919 ext4_dec_count(old.dir);
Miklos Szeredic0d268c2014-04-01 17:08:43 +02003920 if (new.inode) {
Michael Halcrowe875a2d2015-04-11 07:46:49 -04003921 /* checked ext4_empty_dir above, can't have another
3922 * parent, ext4_dec_count() won't work for many-linked
3923 * dirs */
Miklos Szeredic0d268c2014-04-01 17:08:43 +02003924 clear_nlink(new.inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003925 } else {
Nikolay Borisov15ed2852020-08-26 16:31:16 +03003926 ext4_inc_count(new.dir);
Miklos Szeredic0d268c2014-04-01 17:08:43 +02003927 ext4_update_dx_flag(new.dir);
Harshad Shirwadkar4209ae12020-04-26 18:34:37 -07003928 retval = ext4_mark_inode_dirty(handle, new.dir);
3929 if (unlikely(retval))
3930 goto end_rename;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003931 }
3932 }
Harshad Shirwadkar4209ae12020-04-26 18:34:37 -07003933 retval = ext4_mark_inode_dirty(handle, old.dir);
3934 if (unlikely(retval))
3935 goto end_rename;
Harshad Shirwadkaraa75f4d2020-10-15 13:37:57 -07003936
3937 if (S_ISDIR(old.inode->i_mode)) {
3938 /*
3939 * We disable fast commits here that's because the
3940 * replay code is not yet capable of changing dot dot
3941 * dirents in directories.
3942 */
3943 ext4_fc_mark_ineligible(old.inode->i_sb,
3944 EXT4_FC_REASON_RENAME_DIR);
3945 } else {
3946 if (new.inode)
Harshad Shirwadkara80f7fc2020-11-05 19:58:53 -08003947 ext4_fc_track_unlink(handle, new.dentry);
3948 __ext4_fc_track_link(handle, old.inode, new.dentry);
3949 __ext4_fc_track_unlink(handle, old.inode, old.dentry);
Harshad Shirwadkar8210bb22021-03-16 15:19:21 -07003950 if (whiteout)
3951 __ext4_fc_track_create(handle, whiteout, old.dentry);
Harshad Shirwadkaraa75f4d2020-10-15 13:37:57 -07003952 }
3953
Miklos Szeredic0d268c2014-04-01 17:08:43 +02003954 if (new.inode) {
Harshad Shirwadkar4209ae12020-04-26 18:34:37 -07003955 retval = ext4_mark_inode_dirty(handle, new.inode);
3956 if (unlikely(retval))
3957 goto end_rename;
Miklos Szeredic0d268c2014-04-01 17:08:43 +02003958 if (!new.inode->i_nlink)
3959 ext4_orphan_add(handle, new.inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003960 }
3961 retval = 0;
3962
3963end_rename:
yangerkun6b4b8e62021-01-05 14:28:57 +08003964 if (whiteout) {
3965 if (retval) {
zhangyi (F)b7ff91f2021-03-03 21:17:02 +08003966 ext4_resetent(handle, &old,
3967 old.inode->i_ino, old_file_type);
yangerkun6b4b8e62021-01-05 14:28:57 +08003968 drop_nlink(whiteout);
zhangyi (F)5dccdc52021-03-03 21:17:03 +08003969 ext4_orphan_add(handle, whiteout);
yangerkun6b4b8e62021-01-05 14:28:57 +08003970 }
3971 unlock_new_inode(whiteout);
zhangyi (F)5dccdc52021-03-03 21:17:03 +08003972 ext4_journal_stop(handle);
yangerkun6b4b8e62021-01-05 14:28:57 +08003973 iput(whiteout);
zhangyi (F)5dccdc52021-03-03 21:17:03 +08003974 } else {
3975 ext4_journal_stop(handle);
yangerkun6b4b8e62021-01-05 14:28:57 +08003976 }
zhangyi (F)5dccdc52021-03-03 21:17:03 +08003977release_bh:
Miklos Szeredic0d268c2014-04-01 17:08:43 +02003978 brelse(old.dir_bh);
3979 brelse(old.bh);
3980 brelse(new.bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003981 return retval;
3982}
3983
Miklos Szeredibd429982014-04-01 17:08:44 +02003984static int ext4_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
3985 struct inode *new_dir, struct dentry *new_dentry)
3986{
3987 handle_t *handle = NULL;
3988 struct ext4_renament old = {
3989 .dir = old_dir,
3990 .dentry = old_dentry,
David Howells2b0143b2015-03-17 22:25:59 +00003991 .inode = d_inode(old_dentry),
Miklos Szeredibd429982014-04-01 17:08:44 +02003992 };
3993 struct ext4_renament new = {
3994 .dir = new_dir,
3995 .dentry = new_dentry,
David Howells2b0143b2015-03-17 22:25:59 +00003996 .inode = d_inode(new_dentry),
Miklos Szeredibd429982014-04-01 17:08:44 +02003997 };
3998 u8 new_file_type;
3999 int retval;
Deepa Dinamani95582b02018-05-08 19:36:02 -07004000 struct timespec64 ctime;
Miklos Szeredibd429982014-04-01 17:08:44 +02004001
Li Xi040cb372016-01-08 16:01:21 -05004002 if ((ext4_test_inode_flag(new_dir, EXT4_INODE_PROJINHERIT) &&
4003 !projid_eq(EXT4_I(new_dir)->i_projid,
4004 EXT4_I(old_dentry->d_inode)->i_projid)) ||
4005 (ext4_test_inode_flag(old_dir, EXT4_INODE_PROJINHERIT) &&
4006 !projid_eq(EXT4_I(old_dir)->i_projid,
4007 EXT4_I(new_dentry->d_inode)->i_projid)))
4008 return -EXDEV;
4009
Jan Karaa7cdade2015-06-29 16:22:54 +02004010 retval = dquot_initialize(old.dir);
4011 if (retval)
4012 return retval;
4013 retval = dquot_initialize(new.dir);
4014 if (retval)
4015 return retval;
Miklos Szeredibd429982014-04-01 17:08:44 +02004016
4017 old.bh = ext4_find_entry(old.dir, &old.dentry->d_name,
4018 &old.de, &old.inlined);
Theodore Ts'o36de9282014-08-23 17:47:19 -04004019 if (IS_ERR(old.bh))
4020 return PTR_ERR(old.bh);
Miklos Szeredibd429982014-04-01 17:08:44 +02004021 /*
4022 * Check for inode number is _not_ due to possible IO errors.
4023 * We might rmdir the source, keep it as pwd of some process
4024 * and merrily kill the link to whatever was created under the
4025 * same name. Goodbye sticky bit ;-<
4026 */
4027 retval = -ENOENT;
4028 if (!old.bh || le32_to_cpu(old.de->inode) != old.inode->i_ino)
4029 goto end_rename;
4030
4031 new.bh = ext4_find_entry(new.dir, &new.dentry->d_name,
4032 &new.de, &new.inlined);
Theodore Ts'o36de9282014-08-23 17:47:19 -04004033 if (IS_ERR(new.bh)) {
4034 retval = PTR_ERR(new.bh);
Theodore Ts'oa9cfcd62014-09-03 09:33:00 -04004035 new.bh = NULL;
Theodore Ts'o36de9282014-08-23 17:47:19 -04004036 goto end_rename;
4037 }
Miklos Szeredibd429982014-04-01 17:08:44 +02004038
4039 /* RENAME_EXCHANGE case: old *and* new must both exist */
4040 if (!new.bh || le32_to_cpu(new.de->inode) != new.inode->i_ino)
4041 goto end_rename;
4042
4043 handle = ext4_journal_start(old.dir, EXT4_HT_DIR,
4044 (2 * EXT4_DATA_TRANS_BLOCKS(old.dir->i_sb) +
4045 2 * EXT4_INDEX_EXTRA_TRANS_BLOCKS + 2));
Konstantin Khlebnikov7071b712015-04-02 16:32:15 -04004046 if (IS_ERR(handle)) {
4047 retval = PTR_ERR(handle);
4048 handle = NULL;
4049 goto end_rename;
4050 }
Miklos Szeredibd429982014-04-01 17:08:44 +02004051
4052 if (IS_DIRSYNC(old.dir) || IS_DIRSYNC(new.dir))
4053 ext4_handle_sync(handle);
4054
4055 if (S_ISDIR(old.inode->i_mode)) {
4056 old.is_dir = true;
4057 retval = ext4_rename_dir_prepare(handle, &old);
4058 if (retval)
4059 goto end_rename;
4060 }
4061 if (S_ISDIR(new.inode->i_mode)) {
4062 new.is_dir = true;
4063 retval = ext4_rename_dir_prepare(handle, &new);
4064 if (retval)
4065 goto end_rename;
4066 }
4067
4068 /*
4069 * Other than the special case of overwriting a directory, parents'
4070 * nlink only needs to be modified if this is a cross directory rename.
4071 */
4072 if (old.dir != new.dir && old.is_dir != new.is_dir) {
4073 old.dir_nlink_delta = old.is_dir ? -1 : 1;
4074 new.dir_nlink_delta = -old.dir_nlink_delta;
4075 retval = -EMLINK;
4076 if ((old.dir_nlink_delta > 0 && EXT4_DIR_LINK_MAX(old.dir)) ||
4077 (new.dir_nlink_delta > 0 && EXT4_DIR_LINK_MAX(new.dir)))
4078 goto end_rename;
4079 }
4080
4081 new_file_type = new.de->file_type;
4082 retval = ext4_setent(handle, &new, old.inode->i_ino, old.de->file_type);
4083 if (retval)
4084 goto end_rename;
4085
4086 retval = ext4_setent(handle, &old, new.inode->i_ino, new_file_type);
4087 if (retval)
4088 goto end_rename;
4089
4090 /*
4091 * Like most other Unix systems, set the ctime for inodes on a
4092 * rename.
4093 */
Deepa Dinamanieeca7ea2016-11-14 21:40:10 -05004094 ctime = current_time(old.inode);
4095 old.inode->i_ctime = ctime;
4096 new.inode->i_ctime = ctime;
Harshad Shirwadkar4209ae12020-04-26 18:34:37 -07004097 retval = ext4_mark_inode_dirty(handle, old.inode);
4098 if (unlikely(retval))
4099 goto end_rename;
4100 retval = ext4_mark_inode_dirty(handle, new.inode);
4101 if (unlikely(retval))
4102 goto end_rename;
Harshad Shirwadkaraa75f4d2020-10-15 13:37:57 -07004103 ext4_fc_mark_ineligible(new.inode->i_sb,
4104 EXT4_FC_REASON_CROSS_RENAME);
Miklos Szeredibd429982014-04-01 17:08:44 +02004105 if (old.dir_bh) {
4106 retval = ext4_rename_dir_finish(handle, &old, new.dir->i_ino);
4107 if (retval)
4108 goto end_rename;
4109 }
4110 if (new.dir_bh) {
4111 retval = ext4_rename_dir_finish(handle, &new, old.dir->i_ino);
4112 if (retval)
4113 goto end_rename;
4114 }
4115 ext4_update_dir_count(handle, &old);
4116 ext4_update_dir_count(handle, &new);
4117 retval = 0;
4118
4119end_rename:
4120 brelse(old.dir_bh);
4121 brelse(new.dir_bh);
4122 brelse(old.bh);
4123 brelse(new.bh);
4124 if (handle)
4125 ext4_journal_stop(handle);
4126 return retval;
4127}
4128
Christian Brauner549c7292021-01-21 14:19:43 +01004129static int ext4_rename2(struct user_namespace *mnt_userns,
4130 struct inode *old_dir, struct dentry *old_dentry,
Miklos Szeredi0a7c3932014-04-01 17:08:43 +02004131 struct inode *new_dir, struct dentry *new_dentry,
4132 unsigned int flags)
4133{
Eric Biggers07543d12017-10-18 20:21:57 -04004134 int err;
4135
Theodore Ts'o0db1ff22017-02-05 01:28:48 -05004136 if (unlikely(ext4_forced_shutdown(EXT4_SB(old_dir->i_sb))))
4137 return -EIO;
4138
Miklos Szeredicd808de2014-10-24 00:14:37 +02004139 if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
Miklos Szeredi0a7c3932014-04-01 17:08:43 +02004140 return -EINVAL;
4141
Eric Biggers07543d12017-10-18 20:21:57 -04004142 err = fscrypt_prepare_rename(old_dir, old_dentry, new_dir, new_dentry,
4143 flags);
4144 if (err)
4145 return err;
4146
Miklos Szeredibd429982014-04-01 17:08:44 +02004147 if (flags & RENAME_EXCHANGE) {
4148 return ext4_cross_rename(old_dir, old_dentry,
4149 new_dir, new_dentry);
4150 }
Miklos Szeredicd808de2014-10-24 00:14:37 +02004151
Christian Brauner14f3db52021-01-21 14:19:57 +01004152 return ext4_rename(mnt_userns, old_dir, old_dentry, new_dir, new_dentry, flags);
Miklos Szeredi0a7c3932014-04-01 17:08:43 +02004153}
4154
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004155/*
4156 * directories can handle most operations...
4157 */
Arjan van de Ven754661f2007-02-12 00:55:38 -08004158const struct inode_operations ext4_dir_inode_operations = {
Mingming Cao617ba132006-10-11 01:20:53 -07004159 .create = ext4_create,
4160 .lookup = ext4_lookup,
4161 .link = ext4_link,
4162 .unlink = ext4_unlink,
4163 .symlink = ext4_symlink,
4164 .mkdir = ext4_mkdir,
4165 .rmdir = ext4_rmdir,
4166 .mknod = ext4_mknod,
Al Viroaf51a2a2013-06-29 13:23:08 +04004167 .tmpfile = ext4_tmpfile,
Miklos Szeredi2773bf02016-09-27 11:03:58 +02004168 .rename = ext4_rename2,
Mingming Cao617ba132006-10-11 01:20:53 -07004169 .setattr = ext4_setattr,
David Howells99652ea2017-03-31 18:31:56 +01004170 .getattr = ext4_getattr,
Mingming Cao617ba132006-10-11 01:20:53 -07004171 .listxattr = ext4_listxattr,
Christoph Hellwig4e34e712011-07-23 17:37:31 +02004172 .get_acl = ext4_get_acl,
Christoph Hellwig64e178a2013-12-20 05:16:44 -08004173 .set_acl = ext4_set_acl,
Aneesh Kumar K.Vabc87462009-05-02 22:54:32 -04004174 .fiemap = ext4_fiemap,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004175};
4176
Arjan van de Ven754661f2007-02-12 00:55:38 -08004177const struct inode_operations ext4_special_inode_operations = {
Mingming Cao617ba132006-10-11 01:20:53 -07004178 .setattr = ext4_setattr,
David Howells99652ea2017-03-31 18:31:56 +01004179 .getattr = ext4_getattr,
Mingming Cao617ba132006-10-11 01:20:53 -07004180 .listxattr = ext4_listxattr,
Christoph Hellwig4e34e712011-07-23 17:37:31 +02004181 .get_acl = ext4_get_acl,
Christoph Hellwig64e178a2013-12-20 05:16:44 -08004182 .set_acl = ext4_set_acl,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004183};