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 | |
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 | |
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(error: -ENAMETOOLONG); |
64 | |
65 | res = ext2_inode_by_name(dir, child: &dentry->d_name, ino: &ino); |
66 | if (res) { |
67 | if (res != -ENOENT) |
68 | return ERR_PTR(error: res); |
69 | inode = NULL; |
70 | } else { |
71 | inode = ext2_iget(dir->i_sb, ino); |
72 | if (inode == ERR_PTR(error: -ESTALE)) { |
73 | ext2_error(dir->i_sb, __func__, |
74 | "deleted inode referenced: %lu" , |
75 | (unsigned long) ino); |
76 | return ERR_PTR(error: -EIO); |
77 | } |
78 | } |
79 | return d_splice_alias(inode, dentry); |
80 | } |
81 | |
82 | struct dentry *ext2_get_parent(struct dentry *child) |
83 | { |
84 | ino_t ino; |
85 | int res; |
86 | |
87 | res = ext2_inode_by_name(dir: d_inode(dentry: child), child: &dotdot_name, ino: &ino); |
88 | if (res) |
89 | return ERR_PTR(error: 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 | */ |
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(inode: dir); |
110 | if (err) |
111 | return err; |
112 | |
113 | inode = ext2_new_inode(dir, mode, &dentry->d_name); |
114 | if (IS_ERR(ptr: inode)) |
115 | return PTR_ERR(ptr: inode); |
116 | |
117 | ext2_set_file_ops(inode); |
118 | mark_inode_dirty(inode); |
119 | return ext2_add_nondir(dentry, inode); |
120 | } |
121 | |
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(ptr: inode)) |
127 | return PTR_ERR(ptr: 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, error: 0); |
134 | } |
135 | |
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(inode: dir); |
143 | if (err) |
144 | return err; |
145 | |
146 | inode = ext2_new_inode (dir, mode, &dentry->d_name); |
147 | err = PTR_ERR(ptr: inode); |
148 | if (!IS_ERR(ptr: 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 | |
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(inode: 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(ptr: inode); |
174 | if (IS_ERR(ptr: 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, len: 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 | |
204 | static int ext2_link (struct dentry * old_dentry, struct inode * dir, |
205 | struct dentry *dentry) |
206 | { |
207 | struct inode *inode = d_inode(dentry: old_dentry); |
208 | int err; |
209 | |
210 | err = dquot_initialize(inode: 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 | |
228 | static int ext2_mkdir(struct mnt_idmap * idmap, |
229 | struct inode * dir, struct dentry * dentry, umode_t mode) |
230 | { |
231 | struct inode * inode; |
232 | int err; |
233 | |
234 | err = dquot_initialize(inode: dir); |
235 | if (err) |
236 | return err; |
237 | |
238 | inode_inc_link_count(inode: dir); |
239 | |
240 | inode = ext2_new_inode(dir, S_IFDIR | mode, &dentry->d_name); |
241 | err = PTR_ERR(ptr: inode); |
242 | if (IS_ERR(ptr: inode)) |
243 | goto out_dir; |
244 | |
245 | inode->i_op = &ext2_dir_inode_operations; |
246 | inode->i_fop = &ext2_dir_operations; |
247 | inode->i_mapping->a_ops = &ext2_aops; |
248 | |
249 | inode_inc_link_count(inode); |
250 | |
251 | err = ext2_make_empty(inode, dir); |
252 | if (err) |
253 | goto out_fail; |
254 | |
255 | err = ext2_add_link(dentry, inode); |
256 | if (err) |
257 | goto out_fail; |
258 | |
259 | d_instantiate_new(dentry, inode); |
260 | out: |
261 | return err; |
262 | |
263 | out_fail: |
264 | inode_dec_link_count(inode); |
265 | inode_dec_link_count(inode); |
266 | discard_new_inode(inode); |
267 | out_dir: |
268 | inode_dec_link_count(inode: dir); |
269 | goto out; |
270 | } |
271 | |
272 | static int ext2_unlink(struct inode *dir, struct dentry *dentry) |
273 | { |
274 | struct inode *inode = d_inode(dentry); |
275 | struct ext2_dir_entry_2 *de; |
276 | struct folio *folio; |
277 | int err; |
278 | |
279 | err = dquot_initialize(inode: dir); |
280 | if (err) |
281 | goto out; |
282 | |
283 | de = ext2_find_entry(dir, &dentry->d_name, foliop: &folio); |
284 | if (IS_ERR(ptr: de)) { |
285 | err = PTR_ERR(ptr: de); |
286 | goto out; |
287 | } |
288 | |
289 | err = ext2_delete_entry(dir: de, folio); |
290 | folio_release_kmap(folio, addr: de); |
291 | if (err) |
292 | goto out; |
293 | |
294 | inode_set_ctime_to_ts(inode, ts: inode_get_ctime(inode: dir)); |
295 | inode_dec_link_count(inode); |
296 | err = 0; |
297 | out: |
298 | return err; |
299 | } |
300 | |
301 | static int ext2_rmdir (struct inode * dir, struct dentry *dentry) |
302 | { |
303 | struct inode * inode = d_inode(dentry); |
304 | int err = -ENOTEMPTY; |
305 | |
306 | if (ext2_empty_dir(inode)) { |
307 | err = ext2_unlink(dir, dentry); |
308 | if (!err) { |
309 | inode->i_size = 0; |
310 | inode_dec_link_count(inode); |
311 | inode_dec_link_count(inode: dir); |
312 | } |
313 | } |
314 | return err; |
315 | } |
316 | |
317 | static int ext2_rename (struct mnt_idmap * idmap, |
318 | struct inode * old_dir, struct dentry * old_dentry, |
319 | struct inode * new_dir, struct dentry * new_dentry, |
320 | unsigned int flags) |
321 | { |
322 | struct inode * old_inode = d_inode(dentry: old_dentry); |
323 | struct inode * new_inode = d_inode(dentry: new_dentry); |
324 | struct folio *dir_folio = NULL; |
325 | struct ext2_dir_entry_2 * dir_de = NULL; |
326 | struct folio * old_folio; |
327 | struct ext2_dir_entry_2 * old_de; |
328 | int err; |
329 | |
330 | if (flags & ~RENAME_NOREPLACE) |
331 | return -EINVAL; |
332 | |
333 | err = dquot_initialize(inode: old_dir); |
334 | if (err) |
335 | return err; |
336 | |
337 | err = dquot_initialize(inode: new_dir); |
338 | if (err) |
339 | return err; |
340 | |
341 | old_de = ext2_find_entry(old_dir, &old_dentry->d_name, foliop: &old_folio); |
342 | if (IS_ERR(ptr: old_de)) |
343 | return PTR_ERR(ptr: old_de); |
344 | |
345 | if (S_ISDIR(old_inode->i_mode)) { |
346 | err = -EIO; |
347 | dir_de = ext2_dotdot(dir: old_inode, foliop: &dir_folio); |
348 | if (!dir_de) |
349 | goto out_old; |
350 | } |
351 | |
352 | if (new_inode) { |
353 | struct folio *new_folio; |
354 | struct ext2_dir_entry_2 *new_de; |
355 | |
356 | err = -ENOTEMPTY; |
357 | if (dir_de && !ext2_empty_dir (new_inode)) |
358 | goto out_dir; |
359 | |
360 | new_de = ext2_find_entry(new_dir, &new_dentry->d_name, |
361 | foliop: &new_folio); |
362 | if (IS_ERR(ptr: new_de)) { |
363 | err = PTR_ERR(ptr: new_de); |
364 | goto out_dir; |
365 | } |
366 | err = ext2_set_link(dir: new_dir, de: new_de, folio: new_folio, inode: old_inode, update_times: true); |
367 | folio_release_kmap(folio: new_folio, addr: new_de); |
368 | if (err) |
369 | goto out_dir; |
370 | inode_set_ctime_current(inode: new_inode); |
371 | if (dir_de) |
372 | drop_nlink(inode: new_inode); |
373 | inode_dec_link_count(inode: new_inode); |
374 | } else { |
375 | err = ext2_add_link(new_dentry, old_inode); |
376 | if (err) |
377 | goto out_dir; |
378 | if (dir_de) |
379 | inode_inc_link_count(inode: new_dir); |
380 | } |
381 | |
382 | /* |
383 | * Like most other Unix systems, set the ctime for inodes on a |
384 | * rename. |
385 | */ |
386 | inode_set_ctime_current(inode: old_inode); |
387 | mark_inode_dirty(inode: old_inode); |
388 | |
389 | err = ext2_delete_entry(dir: old_de, folio: old_folio); |
390 | if (!err && dir_de) { |
391 | if (old_dir != new_dir) |
392 | err = ext2_set_link(dir: old_inode, de: dir_de, folio: dir_folio, |
393 | inode: new_dir, update_times: false); |
394 | |
395 | inode_dec_link_count(inode: old_dir); |
396 | } |
397 | out_dir: |
398 | if (dir_de) |
399 | folio_release_kmap(folio: dir_folio, addr: dir_de); |
400 | out_old: |
401 | folio_release_kmap(folio: old_folio, addr: old_de); |
402 | return err; |
403 | } |
404 | |
405 | const struct inode_operations ext2_dir_inode_operations = { |
406 | .create = ext2_create, |
407 | .lookup = ext2_lookup, |
408 | .link = ext2_link, |
409 | .unlink = ext2_unlink, |
410 | .symlink = ext2_symlink, |
411 | .mkdir = ext2_mkdir, |
412 | .rmdir = ext2_rmdir, |
413 | .mknod = ext2_mknod, |
414 | .rename = ext2_rename, |
415 | .listxattr = ext2_listxattr, |
416 | .getattr = ext2_getattr, |
417 | .setattr = ext2_setattr, |
418 | .get_inode_acl = ext2_get_acl, |
419 | .set_acl = ext2_set_acl, |
420 | .tmpfile = ext2_tmpfile, |
421 | .fileattr_get = ext2_fileattr_get, |
422 | .fileattr_set = ext2_fileattr_set, |
423 | }; |
424 | |
425 | const struct inode_operations ext2_special_inode_operations = { |
426 | .listxattr = ext2_listxattr, |
427 | .getattr = ext2_getattr, |
428 | .setattr = ext2_setattr, |
429 | .get_inode_acl = ext2_get_acl, |
430 | .set_acl = ext2_set_acl, |
431 | }; |
432 | |