1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * linux/fs/ext2/namei.c
4  *
5  * Rewrite to pagecache. Almost all code had been changed, so blame me
6  * if the things go wrong. Please, send bug reports to
7  * viro@parcelfarce.linux.theplanet.co.uk
8  *
9  * Stuff here is basically a glue between the VFS and generic UNIXish
10  * filesystem that keeps everything in pagecache. All knowledge of the
11  * directory layout is in fs/ext2/dir.c - it turned out to be easily separatable
12  * and it's easier to debug that way. In principle we might want to
13  * generalize that a bit and turn it into a library. Or not.
14  *
15  * The only non-static object here is ext2_dir_inode_operations.
16  *
17  * TODO: get rid of kmap() use, add readahead.
18  *
19  * Copyright (C) 1992, 1993, 1994, 1995
20  * Remy Card (card@masi.ibp.fr)
21  * Laboratoire MASI - Institut Blaise Pascal
22  * Universite Pierre et Marie Curie (Paris VI)
23  *
24  *  from
25  *
26  *  linux/fs/minix/namei.c
27  *
28  *  Copyright (C) 1991, 1992  Linus Torvalds
29  *
30  *  Big-endian to little-endian byte-swapping/bitmaps by
31  *        David S. Miller (davem@caip.rutgers.edu), 1995
32  */
33 
34 #include <linux/pagemap.h>
35 #include <linux/quotaops.h>
36 #include "ext2.h"
37 #include "xattr.h"
38 #include "acl.h"
39 
ext2_add_nondir(struct dentry * dentry,struct inode * inode)40 static inline int ext2_add_nondir(struct dentry *dentry, struct inode *inode)
41 {
42 	int err = ext2_add_link(dentry, inode);
43 	if (!err) {
44 		d_instantiate_new(dentry, inode);
45 		return 0;
46 	}
47 	inode_dec_link_count(inode);
48 	discard_new_inode(inode);
49 	return err;
50 }
51 
52 /*
53  * Methods themselves.
54  */
55 
ext2_lookup(struct inode * dir,struct dentry * dentry,unsigned int flags)56 static struct dentry *ext2_lookup(struct inode * dir, struct dentry *dentry, unsigned int flags)
57 {
58 	struct inode * inode;
59 	ino_t ino;
60 	int res;
61 
62 	if (dentry->d_name.len > EXT2_NAME_LEN)
63 		return ERR_PTR(-ENAMETOOLONG);
64 
65 	res = ext2_inode_by_name(dir, &dentry->d_name, &ino);
66 	if (res) {
67 		if (res != -ENOENT)
68 			return ERR_PTR(res);
69 		inode = NULL;
70 	} else {
71 		inode = ext2_iget(dir->i_sb, ino);
72 		if (inode == ERR_PTR(-ESTALE)) {
73 			ext2_error(dir->i_sb, __func__,
74 					"deleted inode referenced: %lu",
75 					(unsigned long) ino);
76 			return ERR_PTR(-EIO);
77 		}
78 	}
79 	return d_splice_alias(inode, dentry);
80 }
81 
ext2_get_parent(struct dentry * child)82 struct dentry *ext2_get_parent(struct dentry *child)
83 {
84 	ino_t ino;
85 	int res;
86 
87 	res = ext2_inode_by_name(d_inode(child), &dotdot_name, &ino);
88 	if (res)
89 		return ERR_PTR(res);
90 
91 	return d_obtain_alias(ext2_iget(child->d_sb, ino));
92 }
93 
94 /*
95  * By the time this is called, we already have created
96  * the directory cache entry for the new file, but it
97  * is so far negative - it has no inode.
98  *
99  * If the create succeeds, we fill in the inode information
100  * with d_instantiate().
101  */
ext2_create(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry,umode_t mode,bool excl)102 static int ext2_create (struct mnt_idmap * idmap,
103 			struct inode * dir, struct dentry * dentry,
104 			umode_t mode, bool excl)
105 {
106 	struct inode *inode;
107 	int err;
108 
109 	err = dquot_initialize(dir);
110 	if (err)
111 		return err;
112 
113 	inode = ext2_new_inode(dir, mode, &dentry->d_name);
114 	if (IS_ERR(inode))
115 		return PTR_ERR(inode);
116 
117 	ext2_set_file_ops(inode);
118 	mark_inode_dirty(inode);
119 	return ext2_add_nondir(dentry, inode);
120 }
121 
ext2_tmpfile(struct mnt_idmap * idmap,struct inode * dir,struct file * file,umode_t mode)122 static int ext2_tmpfile(struct mnt_idmap *idmap, struct inode *dir,
123 			struct file *file, umode_t mode)
124 {
125 	struct inode *inode = ext2_new_inode(dir, mode, NULL);
126 	if (IS_ERR(inode))
127 		return PTR_ERR(inode);
128 
129 	ext2_set_file_ops(inode);
130 	mark_inode_dirty(inode);
131 	d_tmpfile(file, inode);
132 	unlock_new_inode(inode);
133 	return finish_open_simple(file, 0);
134 }
135 
ext2_mknod(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry,umode_t mode,dev_t rdev)136 static int ext2_mknod (struct mnt_idmap * idmap, struct inode * dir,
137 	struct dentry *dentry, umode_t mode, dev_t rdev)
138 {
139 	struct inode * inode;
140 	int err;
141 
142 	err = dquot_initialize(dir);
143 	if (err)
144 		return err;
145 
146 	inode = ext2_new_inode (dir, mode, &dentry->d_name);
147 	err = PTR_ERR(inode);
148 	if (!IS_ERR(inode)) {
149 		init_special_inode(inode, inode->i_mode, rdev);
150 		inode->i_op = &ext2_special_inode_operations;
151 		mark_inode_dirty(inode);
152 		err = ext2_add_nondir(dentry, inode);
153 	}
154 	return err;
155 }
156 
ext2_symlink(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry,const char * symname)157 static int ext2_symlink (struct mnt_idmap * idmap, struct inode * dir,
158 	struct dentry * dentry, const char * symname)
159 {
160 	struct super_block * sb = dir->i_sb;
161 	int err = -ENAMETOOLONG;
162 	unsigned l = strlen(symname)+1;
163 	struct inode * inode;
164 
165 	if (l > sb->s_blocksize)
166 		goto out;
167 
168 	err = dquot_initialize(dir);
169 	if (err)
170 		goto out;
171 
172 	inode = ext2_new_inode (dir, S_IFLNK | S_IRWXUGO, &dentry->d_name);
173 	err = PTR_ERR(inode);
174 	if (IS_ERR(inode))
175 		goto out;
176 
177 	if (l > sizeof (EXT2_I(inode)->i_data)) {
178 		/* slow symlink */
179 		inode->i_op = &ext2_symlink_inode_operations;
180 		inode_nohighmem(inode);
181 		inode->i_mapping->a_ops = &ext2_aops;
182 		err = page_symlink(inode, symname, l);
183 		if (err)
184 			goto out_fail;
185 	} else {
186 		/* fast symlink */
187 		inode->i_op = &ext2_fast_symlink_inode_operations;
188 		inode->i_link = (char*)EXT2_I(inode)->i_data;
189 		memcpy(inode->i_link, symname, l);
190 		inode->i_size = l-1;
191 	}
192 	mark_inode_dirty(inode);
193 
194 	err = ext2_add_nondir(dentry, inode);
195 out:
196 	return err;
197 
198 out_fail:
199 	inode_dec_link_count(inode);
200 	discard_new_inode(inode);
201 	goto out;
202 }
203 
ext2_link(struct dentry * old_dentry,struct inode * dir,struct dentry * dentry)204 static int ext2_link (struct dentry * old_dentry, struct inode * dir,
205 	struct dentry *dentry)
206 {
207 	struct inode *inode = d_inode(old_dentry);
208 	int err;
209 
210 	err = dquot_initialize(dir);
211 	if (err)
212 		return err;
213 
214 	inode_set_ctime_current(inode);
215 	inode_inc_link_count(inode);
216 	ihold(inode);
217 
218 	err = ext2_add_link(dentry, inode);
219 	if (!err) {
220 		d_instantiate(dentry, inode);
221 		return 0;
222 	}
223 	inode_dec_link_count(inode);
224 	iput(inode);
225 	return err;
226 }
227 
ext2_mkdir(struct mnt_idmap * idmap,struct inode * dir,struct dentry * dentry,umode_t mode)228 static struct dentry *ext2_mkdir(struct mnt_idmap * idmap,
229 				 struct inode * dir, struct dentry * dentry,
230 				 umode_t mode)
231 {
232 	struct inode * inode;
233 	int err;
234 
235 	err = dquot_initialize(dir);
236 	if (err)
237 		return ERR_PTR(err);
238 
239 	inode_inc_link_count(dir);
240 
241 	inode = ext2_new_inode(dir, S_IFDIR | mode, &dentry->d_name);
242 	err = PTR_ERR(inode);
243 	if (IS_ERR(inode))
244 		goto out_dir;
245 
246 	inode->i_op = &ext2_dir_inode_operations;
247 	inode->i_fop = &ext2_dir_operations;
248 	inode->i_mapping->a_ops = &ext2_aops;
249 
250 	inode_inc_link_count(inode);
251 
252 	err = ext2_make_empty(inode, dir);
253 	if (err)
254 		goto out_fail;
255 
256 	err = ext2_add_link(dentry, inode);
257 	if (err)
258 		goto out_fail;
259 
260 	d_instantiate_new(dentry, inode);
261 out:
262 	return ERR_PTR(err);
263 
264 out_fail:
265 	inode_dec_link_count(inode);
266 	inode_dec_link_count(inode);
267 	discard_new_inode(inode);
268 out_dir:
269 	inode_dec_link_count(dir);
270 	goto out;
271 }
272 
ext2_unlink(struct inode * dir,struct dentry * dentry)273 static int ext2_unlink(struct inode *dir, struct dentry *dentry)
274 {
275 	struct inode *inode = d_inode(dentry);
276 	struct ext2_dir_entry_2 *de;
277 	struct folio *folio;
278 	int err;
279 
280 	err = dquot_initialize(dir);
281 	if (err)
282 		goto out;
283 
284 	de = ext2_find_entry(dir, &dentry->d_name, &folio);
285 	if (IS_ERR(de)) {
286 		err = PTR_ERR(de);
287 		goto out;
288 	}
289 
290 	err = ext2_delete_entry(de, folio);
291 	folio_release_kmap(folio, de);
292 	if (err)
293 		goto out;
294 
295 	inode_set_ctime_to_ts(inode, inode_get_ctime(dir));
296 	inode_dec_link_count(inode);
297 	err = 0;
298 out:
299 	return err;
300 }
301 
ext2_rmdir(struct inode * dir,struct dentry * dentry)302 static int ext2_rmdir (struct inode * dir, struct dentry *dentry)
303 {
304 	struct inode * inode = d_inode(dentry);
305 	int err = -ENOTEMPTY;
306 
307 	if (ext2_empty_dir(inode)) {
308 		err = ext2_unlink(dir, dentry);
309 		if (!err) {
310 			inode->i_size = 0;
311 			inode_dec_link_count(inode);
312 			inode_dec_link_count(dir);
313 		}
314 	}
315 	return err;
316 }
317 
ext2_rename(struct mnt_idmap * idmap,struct inode * old_dir,struct dentry * old_dentry,struct inode * new_dir,struct dentry * new_dentry,unsigned int flags)318 static int ext2_rename (struct mnt_idmap * idmap,
319 			struct inode * old_dir, struct dentry * old_dentry,
320 			struct inode * new_dir, struct dentry * new_dentry,
321 			unsigned int flags)
322 {
323 	struct inode * old_inode = d_inode(old_dentry);
324 	struct inode * new_inode = d_inode(new_dentry);
325 	struct folio *dir_folio = NULL;
326 	struct ext2_dir_entry_2 * dir_de = NULL;
327 	struct folio * old_folio;
328 	struct ext2_dir_entry_2 * old_de;
329 	bool old_is_dir = S_ISDIR(old_inode->i_mode);
330 	int err;
331 
332 	if (flags & ~RENAME_NOREPLACE)
333 		return -EINVAL;
334 
335 	err = dquot_initialize(old_dir);
336 	if (err)
337 		return err;
338 
339 	err = dquot_initialize(new_dir);
340 	if (err)
341 		return err;
342 
343 	old_de = ext2_find_entry(old_dir, &old_dentry->d_name, &old_folio);
344 	if (IS_ERR(old_de))
345 		return PTR_ERR(old_de);
346 
347 	if (old_is_dir && old_dir != new_dir) {
348 		err = -EIO;
349 		dir_de = ext2_dotdot(old_inode, &dir_folio);
350 		if (!dir_de)
351 			goto out_old;
352 	}
353 
354 	if (new_inode) {
355 		struct folio *new_folio;
356 		struct ext2_dir_entry_2 *new_de;
357 
358 		err = -ENOTEMPTY;
359 		if (old_is_dir && !ext2_empty_dir(new_inode))
360 			goto out_dir;
361 
362 		new_de = ext2_find_entry(new_dir, &new_dentry->d_name,
363 					 &new_folio);
364 		if (IS_ERR(new_de)) {
365 			err = PTR_ERR(new_de);
366 			goto out_dir;
367 		}
368 		err = ext2_set_link(new_dir, new_de, new_folio, old_inode, true);
369 		folio_release_kmap(new_folio, new_de);
370 		if (err)
371 			goto out_dir;
372 		inode_set_ctime_current(new_inode);
373 		if (old_is_dir)
374 			drop_nlink(new_inode);
375 		inode_dec_link_count(new_inode);
376 	} else {
377 		err = ext2_add_link(new_dentry, old_inode);
378 		if (err)
379 			goto out_dir;
380 		if (old_is_dir)
381 			inode_inc_link_count(new_dir);
382 	}
383 
384 	/*
385 	 * Like most other Unix systems, set the ctime for inodes on a
386  	 * rename.
387 	 */
388 	inode_set_ctime_current(old_inode);
389 	mark_inode_dirty(old_inode);
390 
391 	err = ext2_delete_entry(old_de, old_folio);
392 	if (!err && old_is_dir) {
393 		if (old_dir != new_dir)
394 			err = ext2_set_link(old_inode, dir_de, dir_folio,
395 					    new_dir, false);
396 
397 		inode_dec_link_count(old_dir);
398 	}
399 out_dir:
400 	if (dir_de)
401 		folio_release_kmap(dir_folio, dir_de);
402 out_old:
403 	folio_release_kmap(old_folio, old_de);
404 	return err;
405 }
406 
407 const struct inode_operations ext2_dir_inode_operations = {
408 	.create		= ext2_create,
409 	.lookup		= ext2_lookup,
410 	.link		= ext2_link,
411 	.unlink		= ext2_unlink,
412 	.symlink	= ext2_symlink,
413 	.mkdir		= ext2_mkdir,
414 	.rmdir		= ext2_rmdir,
415 	.mknod		= ext2_mknod,
416 	.rename		= ext2_rename,
417 	.listxattr	= ext2_listxattr,
418 	.getattr	= ext2_getattr,
419 	.setattr	= ext2_setattr,
420 	.get_inode_acl	= ext2_get_acl,
421 	.set_acl	= ext2_set_acl,
422 	.tmpfile	= ext2_tmpfile,
423 	.fileattr_get	= ext2_fileattr_get,
424 	.fileattr_set	= ext2_fileattr_set,
425 };
426 
427 const struct inode_operations ext2_special_inode_operations = {
428 	.listxattr	= ext2_listxattr,
429 	.getattr	= ext2_getattr,
430 	.setattr	= ext2_setattr,
431 	.get_inode_acl	= ext2_get_acl,
432 	.set_acl	= ext2_set_acl,
433 };
434