Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
274dcf55 MM |
2 | /* |
3 | * (C) 2001 Clemson University and The University of Chicago | |
4 | * | |
5 | * See COPYING in top-level directory. | |
6 | */ | |
7 | ||
8 | /* | |
9 | * Linux VFS namei operations. | |
10 | */ | |
11 | ||
12 | #include "protocol.h" | |
575e9461 | 13 | #include "orangefs-kernel.h" |
274dcf55 MM |
14 | |
15 | /* | |
16 | * Get a newly allocated inode to go with a negative dentry. | |
17 | */ | |
8bb8aefd | 18 | static int orangefs_create(struct inode *dir, |
274dcf55 MM |
19 | struct dentry *dentry, |
20 | umode_t mode, | |
21 | bool exclusive) | |
22 | { | |
8bb8aefd YL |
23 | struct orangefs_inode_s *parent = ORANGEFS_I(dir); |
24 | struct orangefs_kernel_op_s *new_op; | |
274dcf55 MM |
25 | struct inode *inode; |
26 | int ret; | |
27 | ||
f66debf1 | 28 | gossip_debug(GOSSIP_NAME_DEBUG, "%s: %pd\n", |
5253487e | 29 | __func__, |
f66debf1 | 30 | dentry); |
274dcf55 | 31 | |
8bb8aefd | 32 | new_op = op_alloc(ORANGEFS_VFS_OP_CREATE); |
274dcf55 MM |
33 | if (!new_op) |
34 | return -ENOMEM; | |
35 | ||
36 | new_op->upcall.req.create.parent_refn = parent->refn; | |
37 | ||
38 | fill_default_sys_attrs(new_op->upcall.req.create.attributes, | |
8bb8aefd | 39 | ORANGEFS_TYPE_METAFILE, mode); |
274dcf55 MM |
40 | |
41 | strncpy(new_op->upcall.req.create.d_name, | |
47b4948f | 42 | dentry->d_name.name, ORANGEFS_NAME_MAX); |
274dcf55 MM |
43 | |
44 | ret = service_operation(new_op, __func__, get_interruptible_flag(dir)); | |
45 | ||
46 | gossip_debug(GOSSIP_NAME_DEBUG, | |
f66debf1 | 47 | "%s: %pd: handle:%pU: fsid:%d: new_op:%p: ret:%d:\n", |
5253487e | 48 | __func__, |
f66debf1 | 49 | dentry, |
274dcf55 | 50 | &new_op->downcall.resp.create.refn.khandle, |
5253487e MM |
51 | new_op->downcall.resp.create.refn.fs_id, |
52 | new_op, | |
53 | ret); | |
274dcf55 | 54 | |
5253487e | 55 | if (ret < 0) |
274dcf55 | 56 | goto out; |
274dcf55 | 57 | |
8bb8aefd | 58 | inode = orangefs_new_inode(dir->i_sb, dir, S_IFREG | mode, 0, |
274dcf55 MM |
59 | &new_op->downcall.resp.create.refn); |
60 | if (IS_ERR(inode)) { | |
f66debf1 | 61 | gossip_err("%s: Failed to allocate inode for file :%pd:\n", |
5253487e | 62 | __func__, |
f66debf1 | 63 | dentry); |
274dcf55 MM |
64 | ret = PTR_ERR(inode); |
65 | goto out; | |
66 | } | |
67 | ||
68 | gossip_debug(GOSSIP_NAME_DEBUG, | |
f66debf1 | 69 | "%s: Assigned inode :%pU: for file :%pd:\n", |
5253487e MM |
70 | __func__, |
71 | get_khandle_from_ino(inode), | |
f66debf1 | 72 | dentry); |
274dcf55 MM |
73 | |
74 | d_instantiate(dentry, inode); | |
75 | unlock_new_inode(inode); | |
804b1737 | 76 | orangefs_set_timeout(dentry); |
8bbb20a8 | 77 | ORANGEFS_I(inode)->getattr_time = jiffies - 1; |
68a24a6c | 78 | ORANGEFS_I(inode)->getattr_mask = STATX_BASIC_STATS; |
274dcf55 MM |
79 | |
80 | gossip_debug(GOSSIP_NAME_DEBUG, | |
f66debf1 | 81 | "%s: dentry instantiated for %pd\n", |
5253487e | 82 | __func__, |
f66debf1 | 83 | dentry); |
274dcf55 MM |
84 | |
85 | SetMtimeFlag(parent); | |
c2050a45 | 86 | dir->i_mtime = dir->i_ctime = current_time(dir); |
274dcf55 MM |
87 | mark_inode_dirty_sync(dir); |
88 | ret = 0; | |
89 | out: | |
90 | op_release(new_op); | |
5253487e | 91 | gossip_debug(GOSSIP_NAME_DEBUG, |
f66debf1 | 92 | "%s: %pd: returning %d\n", |
5253487e | 93 | __func__, |
f66debf1 | 94 | dentry, |
5253487e | 95 | ret); |
274dcf55 MM |
96 | return ret; |
97 | } | |
98 | ||
99 | /* | |
100 | * Attempt to resolve an object name (dentry->d_name), parent handle, and | |
101 | * fsid into a handle for the object. | |
102 | */ | |
8bb8aefd | 103 | static struct dentry *orangefs_lookup(struct inode *dir, struct dentry *dentry, |
274dcf55 MM |
104 | unsigned int flags) |
105 | { | |
8bb8aefd YL |
106 | struct orangefs_inode_s *parent = ORANGEFS_I(dir); |
107 | struct orangefs_kernel_op_s *new_op; | |
274dcf55 MM |
108 | struct inode *inode; |
109 | struct dentry *res; | |
110 | int ret = -EINVAL; | |
111 | ||
112 | /* | |
113 | * in theory we could skip a lookup here (if the intent is to | |
114 | * create) in order to avoid a potentially failed lookup, but | |
115 | * leaving it in can skip a valid lookup and try to create a file | |
116 | * that already exists (e.g. the vfs already handles checking for | |
117 | * -EEXIST on O_EXCL opens, which is broken if we skip this lookup | |
118 | * in the create path) | |
119 | */ | |
f66debf1 AV |
120 | gossip_debug(GOSSIP_NAME_DEBUG, "%s called on %pd\n", |
121 | __func__, dentry); | |
274dcf55 | 122 | |
47b4948f | 123 | if (dentry->d_name.len > (ORANGEFS_NAME_MAX - 1)) |
274dcf55 MM |
124 | return ERR_PTR(-ENAMETOOLONG); |
125 | ||
8bb8aefd | 126 | new_op = op_alloc(ORANGEFS_VFS_OP_LOOKUP); |
274dcf55 MM |
127 | if (!new_op) |
128 | return ERR_PTR(-ENOMEM); | |
129 | ||
7cec28e9 | 130 | new_op->upcall.req.lookup.sym_follow = ORANGEFS_LOOKUP_LINK_NO_FOLLOW; |
274dcf55 MM |
131 | |
132 | gossip_debug(GOSSIP_NAME_DEBUG, "%s:%s:%d using parent %pU\n", | |
133 | __FILE__, | |
134 | __func__, | |
135 | __LINE__, | |
136 | &parent->refn.khandle); | |
137 | new_op->upcall.req.lookup.parent_refn = parent->refn; | |
138 | ||
139 | strncpy(new_op->upcall.req.lookup.d_name, dentry->d_name.name, | |
47b4948f | 140 | ORANGEFS_NAME_MAX); |
274dcf55 MM |
141 | |
142 | gossip_debug(GOSSIP_NAME_DEBUG, | |
6ceaf781 | 143 | "%s: doing lookup on %s under %pU,%d\n", |
274dcf55 MM |
144 | __func__, |
145 | new_op->upcall.req.lookup.d_name, | |
146 | &new_op->upcall.req.lookup.parent_refn.khandle, | |
6ceaf781 | 147 | new_op->upcall.req.lookup.parent_refn.fs_id); |
274dcf55 MM |
148 | |
149 | ret = service_operation(new_op, __func__, get_interruptible_flag(dir)); | |
150 | ||
151 | gossip_debug(GOSSIP_NAME_DEBUG, | |
152 | "Lookup Got %pU, fsid %d (ret=%d)\n", | |
153 | &new_op->downcall.resp.lookup.refn.khandle, | |
154 | new_op->downcall.resp.lookup.refn.fs_id, | |
155 | ret); | |
156 | ||
157 | if (ret < 0) { | |
158 | if (ret == -ENOENT) { | |
159 | /* | |
160 | * if no inode was found, add a negative dentry to | |
161 | * dcache anyway; if we don't, we don't hold expected | |
162 | * lookup semantics and we most noticeably break | |
163 | * during directory renames. | |
164 | * | |
165 | * however, if the operation failed or exited, do not | |
166 | * add the dentry (e.g. in the case that a touch is | |
167 | * issued on a file that already exists that was | |
168 | * interrupted during this lookup -- no need to add | |
169 | * another negative dentry for an existing file) | |
170 | */ | |
171 | ||
172 | gossip_debug(GOSSIP_NAME_DEBUG, | |
8bb8aefd | 173 | "orangefs_lookup: Adding *negative* dentry " |
f66debf1 | 174 | "%p for %pd\n", |
274dcf55 | 175 | dentry, |
f66debf1 | 176 | dentry); |
274dcf55 MM |
177 | |
178 | d_add(dentry, NULL); | |
179 | res = NULL; | |
180 | goto out; | |
181 | } | |
182 | ||
183 | /* must be a non-recoverable error */ | |
184 | res = ERR_PTR(ret); | |
185 | goto out; | |
186 | } | |
187 | ||
804b1737 | 188 | orangefs_set_timeout(dentry); |
31b7c1ab | 189 | |
8bb8aefd | 190 | inode = orangefs_iget(dir->i_sb, &new_op->downcall.resp.lookup.refn); |
274dcf55 MM |
191 | if (IS_ERR(inode)) { |
192 | gossip_debug(GOSSIP_NAME_DEBUG, | |
193 | "error %ld from iget\n", PTR_ERR(inode)); | |
194 | res = ERR_CAST(inode); | |
195 | goto out; | |
196 | } | |
197 | ||
198 | gossip_debug(GOSSIP_NAME_DEBUG, | |
199 | "%s:%s:%d " | |
200 | "Found good inode [%lu] with count [%d]\n", | |
201 | __FILE__, | |
202 | __func__, | |
203 | __LINE__, | |
204 | inode->i_ino, | |
205 | (int)atomic_read(&inode->i_count)); | |
206 | ||
207 | /* update dentry/inode pair into dcache */ | |
208 | res = d_splice_alias(inode, dentry); | |
209 | ||
210 | gossip_debug(GOSSIP_NAME_DEBUG, | |
211 | "Lookup success (inode ct = %d)\n", | |
212 | (int)atomic_read(&inode->i_count)); | |
213 | out: | |
214 | op_release(new_op); | |
215 | return res; | |
216 | } | |
217 | ||
218 | /* return 0 on success; non-zero otherwise */ | |
8bb8aefd | 219 | static int orangefs_unlink(struct inode *dir, struct dentry *dentry) |
274dcf55 MM |
220 | { |
221 | struct inode *inode = dentry->d_inode; | |
8bb8aefd YL |
222 | struct orangefs_inode_s *parent = ORANGEFS_I(dir); |
223 | struct orangefs_kernel_op_s *new_op; | |
274dcf55 MM |
224 | int ret; |
225 | ||
226 | gossip_debug(GOSSIP_NAME_DEBUG, | |
f66debf1 | 227 | "%s: called on %pd\n" |
274dcf55 MM |
228 | " (inode %pU): Parent is %pU | fs_id %d\n", |
229 | __func__, | |
f66debf1 | 230 | dentry, |
274dcf55 MM |
231 | get_khandle_from_ino(inode), |
232 | &parent->refn.khandle, | |
233 | parent->refn.fs_id); | |
234 | ||
8bb8aefd | 235 | new_op = op_alloc(ORANGEFS_VFS_OP_REMOVE); |
274dcf55 MM |
236 | if (!new_op) |
237 | return -ENOMEM; | |
238 | ||
239 | new_op->upcall.req.remove.parent_refn = parent->refn; | |
240 | strncpy(new_op->upcall.req.remove.d_name, dentry->d_name.name, | |
47b4948f | 241 | ORANGEFS_NAME_MAX); |
274dcf55 | 242 | |
8bb8aefd | 243 | ret = service_operation(new_op, "orangefs_unlink", |
274dcf55 MM |
244 | get_interruptible_flag(inode)); |
245 | ||
5253487e MM |
246 | gossip_debug(GOSSIP_NAME_DEBUG, |
247 | "%s: service_operation returned:%d:\n", | |
248 | __func__, | |
249 | ret); | |
250 | ||
274dcf55 MM |
251 | op_release(new_op); |
252 | ||
253 | if (!ret) { | |
254 | drop_nlink(inode); | |
255 | ||
256 | SetMtimeFlag(parent); | |
c2050a45 | 257 | dir->i_mtime = dir->i_ctime = current_time(dir); |
274dcf55 MM |
258 | mark_inode_dirty_sync(dir); |
259 | } | |
260 | return ret; | |
261 | } | |
262 | ||
8bb8aefd | 263 | static int orangefs_symlink(struct inode *dir, |
274dcf55 MM |
264 | struct dentry *dentry, |
265 | const char *symname) | |
266 | { | |
8bb8aefd YL |
267 | struct orangefs_inode_s *parent = ORANGEFS_I(dir); |
268 | struct orangefs_kernel_op_s *new_op; | |
274dcf55 MM |
269 | struct inode *inode; |
270 | int mode = 755; | |
271 | int ret; | |
272 | ||
273 | gossip_debug(GOSSIP_NAME_DEBUG, "%s: called\n", __func__); | |
274 | ||
275 | if (!symname) | |
276 | return -EINVAL; | |
277 | ||
c62da585 MB |
278 | if (strlen(symname)+1 > ORANGEFS_NAME_MAX) |
279 | return -ENAMETOOLONG; | |
280 | ||
8bb8aefd | 281 | new_op = op_alloc(ORANGEFS_VFS_OP_SYMLINK); |
274dcf55 MM |
282 | if (!new_op) |
283 | return -ENOMEM; | |
284 | ||
285 | new_op->upcall.req.sym.parent_refn = parent->refn; | |
286 | ||
287 | fill_default_sys_attrs(new_op->upcall.req.sym.attributes, | |
8bb8aefd | 288 | ORANGEFS_TYPE_SYMLINK, |
274dcf55 MM |
289 | mode); |
290 | ||
291 | strncpy(new_op->upcall.req.sym.entry_name, | |
292 | dentry->d_name.name, | |
47b4948f MB |
293 | ORANGEFS_NAME_MAX); |
294 | strncpy(new_op->upcall.req.sym.target, symname, ORANGEFS_NAME_MAX); | |
274dcf55 MM |
295 | |
296 | ret = service_operation(new_op, __func__, get_interruptible_flag(dir)); | |
297 | ||
298 | gossip_debug(GOSSIP_NAME_DEBUG, | |
8bb8aefd | 299 | "Symlink Got ORANGEFS handle %pU on fsid %d (ret=%d)\n", |
274dcf55 MM |
300 | &new_op->downcall.resp.sym.refn.khandle, |
301 | new_op->downcall.resp.sym.refn.fs_id, ret); | |
302 | ||
303 | if (ret < 0) { | |
304 | gossip_debug(GOSSIP_NAME_DEBUG, | |
305 | "%s: failed with error code %d\n", | |
306 | __func__, ret); | |
307 | goto out; | |
308 | } | |
309 | ||
8bb8aefd | 310 | inode = orangefs_new_inode(dir->i_sb, dir, S_IFLNK | mode, 0, |
274dcf55 MM |
311 | &new_op->downcall.resp.sym.refn); |
312 | if (IS_ERR(inode)) { | |
313 | gossip_err | |
8bb8aefd | 314 | ("*** Failed to allocate orangefs symlink inode\n"); |
274dcf55 MM |
315 | ret = PTR_ERR(inode); |
316 | goto out; | |
317 | } | |
318 | ||
319 | gossip_debug(GOSSIP_NAME_DEBUG, | |
320 | "Assigned symlink inode new number of %pU\n", | |
321 | get_khandle_from_ino(inode)); | |
322 | ||
323 | d_instantiate(dentry, inode); | |
324 | unlock_new_inode(inode); | |
804b1737 | 325 | orangefs_set_timeout(dentry); |
8bbb20a8 | 326 | ORANGEFS_I(inode)->getattr_time = jiffies - 1; |
68a24a6c | 327 | ORANGEFS_I(inode)->getattr_mask = STATX_BASIC_STATS; |
274dcf55 MM |
328 | |
329 | gossip_debug(GOSSIP_NAME_DEBUG, | |
f66debf1 | 330 | "Inode (Symlink) %pU -> %pd\n", |
274dcf55 | 331 | get_khandle_from_ino(inode), |
f66debf1 | 332 | dentry); |
274dcf55 MM |
333 | |
334 | SetMtimeFlag(parent); | |
c2050a45 | 335 | dir->i_mtime = dir->i_ctime = current_time(dir); |
274dcf55 MM |
336 | mark_inode_dirty_sync(dir); |
337 | ret = 0; | |
338 | out: | |
339 | op_release(new_op); | |
340 | return ret; | |
341 | } | |
342 | ||
8bb8aefd | 343 | static int orangefs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) |
274dcf55 | 344 | { |
8bb8aefd YL |
345 | struct orangefs_inode_s *parent = ORANGEFS_I(dir); |
346 | struct orangefs_kernel_op_s *new_op; | |
274dcf55 MM |
347 | struct inode *inode; |
348 | int ret; | |
349 | ||
8bb8aefd | 350 | new_op = op_alloc(ORANGEFS_VFS_OP_MKDIR); |
274dcf55 MM |
351 | if (!new_op) |
352 | return -ENOMEM; | |
353 | ||
354 | new_op->upcall.req.mkdir.parent_refn = parent->refn; | |
355 | ||
356 | fill_default_sys_attrs(new_op->upcall.req.mkdir.attributes, | |
8bb8aefd | 357 | ORANGEFS_TYPE_DIRECTORY, mode); |
274dcf55 MM |
358 | |
359 | strncpy(new_op->upcall.req.mkdir.d_name, | |
47b4948f | 360 | dentry->d_name.name, ORANGEFS_NAME_MAX); |
274dcf55 MM |
361 | |
362 | ret = service_operation(new_op, __func__, get_interruptible_flag(dir)); | |
363 | ||
364 | gossip_debug(GOSSIP_NAME_DEBUG, | |
8bb8aefd | 365 | "Mkdir Got ORANGEFS handle %pU on fsid %d\n", |
274dcf55 MM |
366 | &new_op->downcall.resp.mkdir.refn.khandle, |
367 | new_op->downcall.resp.mkdir.refn.fs_id); | |
368 | ||
369 | if (ret < 0) { | |
370 | gossip_debug(GOSSIP_NAME_DEBUG, | |
371 | "%s: failed with error code %d\n", | |
372 | __func__, ret); | |
373 | goto out; | |
374 | } | |
375 | ||
8bb8aefd | 376 | inode = orangefs_new_inode(dir->i_sb, dir, S_IFDIR | mode, 0, |
274dcf55 MM |
377 | &new_op->downcall.resp.mkdir.refn); |
378 | if (IS_ERR(inode)) { | |
8bb8aefd | 379 | gossip_err("*** Failed to allocate orangefs dir inode\n"); |
274dcf55 MM |
380 | ret = PTR_ERR(inode); |
381 | goto out; | |
382 | } | |
383 | ||
384 | gossip_debug(GOSSIP_NAME_DEBUG, | |
385 | "Assigned dir inode new number of %pU\n", | |
386 | get_khandle_from_ino(inode)); | |
387 | ||
388 | d_instantiate(dentry, inode); | |
389 | unlock_new_inode(inode); | |
804b1737 | 390 | orangefs_set_timeout(dentry); |
8bbb20a8 | 391 | ORANGEFS_I(inode)->getattr_time = jiffies - 1; |
68a24a6c | 392 | ORANGEFS_I(inode)->getattr_mask = STATX_BASIC_STATS; |
274dcf55 MM |
393 | |
394 | gossip_debug(GOSSIP_NAME_DEBUG, | |
f66debf1 | 395 | "Inode (Directory) %pU -> %pd\n", |
274dcf55 | 396 | get_khandle_from_ino(inode), |
f66debf1 | 397 | dentry); |
274dcf55 MM |
398 | |
399 | /* | |
400 | * NOTE: we have no good way to keep nlink consistent for directories | |
401 | * across clients; keep constant at 1. | |
402 | */ | |
403 | SetMtimeFlag(parent); | |
c2050a45 | 404 | dir->i_mtime = dir->i_ctime = current_time(dir); |
274dcf55 MM |
405 | mark_inode_dirty_sync(dir); |
406 | out: | |
407 | op_release(new_op); | |
408 | return ret; | |
409 | } | |
410 | ||
8bb8aefd | 411 | static int orangefs_rename(struct inode *old_dir, |
274dcf55 MM |
412 | struct dentry *old_dentry, |
413 | struct inode *new_dir, | |
1cd66c93 MS |
414 | struct dentry *new_dentry, |
415 | unsigned int flags) | |
274dcf55 | 416 | { |
8bb8aefd | 417 | struct orangefs_kernel_op_s *new_op; |
274dcf55 MM |
418 | int ret; |
419 | ||
1cd66c93 MS |
420 | if (flags) |
421 | return -EINVAL; | |
422 | ||
274dcf55 | 423 | gossip_debug(GOSSIP_NAME_DEBUG, |
96b0cffb AV |
424 | "orangefs_rename: called (%pd2 => %pd2) ct=%d\n", |
425 | old_dentry, new_dentry, d_count(new_dentry)); | |
274dcf55 | 426 | |
8bbb20a8 | 427 | ORANGEFS_I(new_dentry->d_parent->d_inode)->getattr_time = jiffies - 1; |
71680c18 | 428 | |
8bb8aefd | 429 | new_op = op_alloc(ORANGEFS_VFS_OP_RENAME); |
274dcf55 MM |
430 | if (!new_op) |
431 | return -EINVAL; | |
432 | ||
8bb8aefd YL |
433 | new_op->upcall.req.rename.old_parent_refn = ORANGEFS_I(old_dir)->refn; |
434 | new_op->upcall.req.rename.new_parent_refn = ORANGEFS_I(new_dir)->refn; | |
274dcf55 MM |
435 | |
436 | strncpy(new_op->upcall.req.rename.d_old_name, | |
437 | old_dentry->d_name.name, | |
47b4948f | 438 | ORANGEFS_NAME_MAX); |
274dcf55 MM |
439 | strncpy(new_op->upcall.req.rename.d_new_name, |
440 | new_dentry->d_name.name, | |
47b4948f | 441 | ORANGEFS_NAME_MAX); |
274dcf55 MM |
442 | |
443 | ret = service_operation(new_op, | |
8bb8aefd | 444 | "orangefs_rename", |
274dcf55 MM |
445 | get_interruptible_flag(old_dentry->d_inode)); |
446 | ||
447 | gossip_debug(GOSSIP_NAME_DEBUG, | |
8bb8aefd | 448 | "orangefs_rename: got downcall status %d\n", |
274dcf55 MM |
449 | ret); |
450 | ||
451 | if (new_dentry->d_inode) | |
c2050a45 | 452 | new_dentry->d_inode->i_ctime = current_time(new_dentry->d_inode); |
274dcf55 MM |
453 | |
454 | op_release(new_op); | |
455 | return ret; | |
456 | } | |
457 | ||
8bb8aefd | 458 | /* ORANGEFS implementation of VFS inode operations for directories */ |
6f3fc107 | 459 | const struct inode_operations orangefs_dir_inode_operations = { |
8bb8aefd YL |
460 | .lookup = orangefs_lookup, |
461 | .get_acl = orangefs_get_acl, | |
462 | .set_acl = orangefs_set_acl, | |
463 | .create = orangefs_create, | |
464 | .unlink = orangefs_unlink, | |
465 | .symlink = orangefs_symlink, | |
466 | .mkdir = orangefs_mkdir, | |
467 | .rmdir = orangefs_unlink, | |
468 | .rename = orangefs_rename, | |
469 | .setattr = orangefs_setattr, | |
470 | .getattr = orangefs_getattr, | |
8bb8aefd | 471 | .listxattr = orangefs_listxattr, |
933287da | 472 | .permission = orangefs_permission, |
274dcf55 | 473 | }; |