1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * linux/fs/nfs/nfs3proc.c |
4 | * |
5 | * Client-side NFSv3 procedures stubs. |
6 | * |
7 | * Copyright (C) 1997, Olaf Kirch |
8 | */ |
9 | |
10 | #include <linux/mm.h> |
11 | #include <linux/errno.h> |
12 | #include <linux/string.h> |
13 | #include <linux/sunrpc/clnt.h> |
14 | #include <linux/slab.h> |
15 | #include <linux/nfs.h> |
16 | #include <linux/nfs3.h> |
17 | #include <linux/nfs_fs.h> |
18 | #include <linux/nfs_page.h> |
19 | #include <linux/lockd/bind.h> |
20 | #include <linux/nfs_mount.h> |
21 | #include <linux/freezer.h> |
22 | #include <linux/xattr.h> |
23 | |
24 | #include "iostat.h" |
25 | #include "internal.h" |
26 | #include "nfs3_fs.h" |
27 | |
28 | #define NFSDBG_FACILITY NFSDBG_PROC |
29 | |
30 | /* A wrapper to handle the EJUKEBOX error messages */ |
31 | static int |
32 | nfs3_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags) |
33 | { |
34 | int res; |
35 | do { |
36 | res = rpc_call_sync(clnt, msg, flags); |
37 | if (res != -EJUKEBOX) |
38 | break; |
39 | __set_current_state(TASK_KILLABLE|TASK_FREEZABLE_UNSAFE); |
40 | schedule_timeout(NFS_JUKEBOX_RETRY_TIME); |
41 | res = -ERESTARTSYS; |
42 | } while (!fatal_signal_pending(current)); |
43 | return res; |
44 | } |
45 | |
46 | #define rpc_call_sync(clnt, msg, flags) nfs3_rpc_wrapper(clnt, msg, flags) |
47 | |
48 | static int |
49 | nfs3_async_handle_jukebox(struct rpc_task *task, struct inode *inode) |
50 | { |
51 | if (task->tk_status != -EJUKEBOX) |
52 | return 0; |
53 | nfs_inc_stats(inode, stat: NFSIOS_DELAY); |
54 | task->tk_status = 0; |
55 | rpc_restart_call(task); |
56 | rpc_delay(task, NFS_JUKEBOX_RETRY_TIME); |
57 | return 1; |
58 | } |
59 | |
60 | static int |
61 | do_proc_get_root(struct rpc_clnt *client, struct nfs_fh *fhandle, |
62 | struct nfs_fsinfo *info) |
63 | { |
64 | struct rpc_message msg = { |
65 | .rpc_proc = &nfs3_procedures[NFS3PROC_FSINFO], |
66 | .rpc_argp = fhandle, |
67 | .rpc_resp = info, |
68 | }; |
69 | int status; |
70 | |
71 | dprintk("%s: call fsinfo\n" , __func__); |
72 | nfs_fattr_init(fattr: info->fattr); |
73 | status = rpc_call_sync(client, &msg, 0); |
74 | dprintk("%s: reply fsinfo: %d\n" , __func__, status); |
75 | if (status == 0 && !(info->fattr->valid & NFS_ATTR_FATTR)) { |
76 | msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR]; |
77 | msg.rpc_resp = info->fattr; |
78 | status = rpc_call_sync(client, &msg, 0); |
79 | dprintk("%s: reply getattr: %d\n" , __func__, status); |
80 | } |
81 | return status; |
82 | } |
83 | |
84 | /* |
85 | * Bare-bones access to getattr: this is for nfs_get_root/nfs_get_sb |
86 | */ |
87 | static int |
88 | nfs3_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle, |
89 | struct nfs_fsinfo *info) |
90 | { |
91 | int status; |
92 | |
93 | status = do_proc_get_root(client: server->client, fhandle, info); |
94 | if (status && server->nfs_client->cl_rpcclient != server->client) |
95 | status = do_proc_get_root(client: server->nfs_client->cl_rpcclient, fhandle, info); |
96 | return status; |
97 | } |
98 | |
99 | /* |
100 | * One function for each procedure in the NFS protocol. |
101 | */ |
102 | static int |
103 | nfs3_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, |
104 | struct nfs_fattr *fattr, struct inode *inode) |
105 | { |
106 | struct rpc_message msg = { |
107 | .rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR], |
108 | .rpc_argp = fhandle, |
109 | .rpc_resp = fattr, |
110 | }; |
111 | int status; |
112 | unsigned short task_flags = 0; |
113 | |
114 | /* Is this is an attribute revalidation, subject to softreval? */ |
115 | if (inode && (server->flags & NFS_MOUNT_SOFTREVAL)) |
116 | task_flags |= RPC_TASK_TIMEOUT; |
117 | |
118 | dprintk("NFS call getattr\n" ); |
119 | nfs_fattr_init(fattr); |
120 | status = rpc_call_sync(server->client, &msg, task_flags); |
121 | dprintk("NFS reply getattr: %d\n" , status); |
122 | return status; |
123 | } |
124 | |
125 | static int |
126 | nfs3_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr, |
127 | struct iattr *sattr) |
128 | { |
129 | struct inode *inode = d_inode(dentry); |
130 | struct nfs3_sattrargs arg = { |
131 | .fh = NFS_FH(inode), |
132 | .sattr = sattr, |
133 | }; |
134 | struct rpc_message msg = { |
135 | .rpc_proc = &nfs3_procedures[NFS3PROC_SETATTR], |
136 | .rpc_argp = &arg, |
137 | .rpc_resp = fattr, |
138 | }; |
139 | int status; |
140 | |
141 | dprintk("NFS call setattr\n" ); |
142 | if (sattr->ia_valid & ATTR_FILE) |
143 | msg.rpc_cred = nfs_file_cred(file: sattr->ia_file); |
144 | nfs_fattr_init(fattr); |
145 | status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); |
146 | if (status == 0) { |
147 | nfs_setattr_update_inode(inode, attr: sattr, fattr); |
148 | if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL) |
149 | nfs_zap_acl_cache(inode); |
150 | } |
151 | dprintk("NFS reply setattr: %d\n" , status); |
152 | return status; |
153 | } |
154 | |
155 | static int |
156 | __nfs3_proc_lookup(struct inode *dir, const char *name, size_t len, |
157 | struct nfs_fh *fhandle, struct nfs_fattr *fattr, |
158 | unsigned short task_flags) |
159 | { |
160 | struct nfs3_diropargs arg = { |
161 | .fh = NFS_FH(inode: dir), |
162 | .name = name, |
163 | .len = len |
164 | }; |
165 | struct nfs3_diropres res = { |
166 | .fh = fhandle, |
167 | .fattr = fattr |
168 | }; |
169 | struct rpc_message msg = { |
170 | .rpc_proc = &nfs3_procedures[NFS3PROC_LOOKUP], |
171 | .rpc_argp = &arg, |
172 | .rpc_resp = &res, |
173 | }; |
174 | int status; |
175 | |
176 | res.dir_attr = nfs_alloc_fattr(); |
177 | if (res.dir_attr == NULL) |
178 | return -ENOMEM; |
179 | |
180 | nfs_fattr_init(fattr); |
181 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, task_flags); |
182 | nfs_refresh_inode(dir, res.dir_attr); |
183 | if (status >= 0 && !(fattr->valid & NFS_ATTR_FATTR)) { |
184 | msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR]; |
185 | msg.rpc_argp = fhandle; |
186 | msg.rpc_resp = fattr; |
187 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, task_flags); |
188 | } |
189 | nfs_free_fattr(fattr: res.dir_attr); |
190 | dprintk("NFS reply lookup: %d\n" , status); |
191 | return status; |
192 | } |
193 | |
194 | static int |
195 | nfs3_proc_lookup(struct inode *dir, struct dentry *dentry, |
196 | struct nfs_fh *fhandle, struct nfs_fattr *fattr) |
197 | { |
198 | unsigned short task_flags = 0; |
199 | |
200 | /* Is this is an attribute revalidation, subject to softreval? */ |
201 | if (nfs_lookup_is_soft_revalidate(dentry)) |
202 | task_flags |= RPC_TASK_TIMEOUT; |
203 | |
204 | dprintk("NFS call lookup %pd2\n" , dentry); |
205 | return __nfs3_proc_lookup(dir, name: dentry->d_name.name, |
206 | len: dentry->d_name.len, fhandle, fattr, |
207 | task_flags); |
208 | } |
209 | |
210 | static int nfs3_proc_lookupp(struct inode *inode, struct nfs_fh *fhandle, |
211 | struct nfs_fattr *fattr) |
212 | { |
213 | const char dotdot[] = ".." ; |
214 | const size_t len = strlen(dotdot); |
215 | unsigned short task_flags = 0; |
216 | |
217 | if (NFS_SERVER(inode)->flags & NFS_MOUNT_SOFTREVAL) |
218 | task_flags |= RPC_TASK_TIMEOUT; |
219 | |
220 | return __nfs3_proc_lookup(dir: inode, name: dotdot, len, fhandle, fattr, |
221 | task_flags); |
222 | } |
223 | |
224 | static int nfs3_proc_access(struct inode *inode, struct nfs_access_entry *entry, |
225 | const struct cred *cred) |
226 | { |
227 | struct nfs3_accessargs arg = { |
228 | .fh = NFS_FH(inode), |
229 | .access = entry->mask, |
230 | }; |
231 | struct nfs3_accessres res; |
232 | struct rpc_message msg = { |
233 | .rpc_proc = &nfs3_procedures[NFS3PROC_ACCESS], |
234 | .rpc_argp = &arg, |
235 | .rpc_resp = &res, |
236 | .rpc_cred = cred, |
237 | }; |
238 | int status = -ENOMEM; |
239 | |
240 | dprintk("NFS call access\n" ); |
241 | res.fattr = nfs_alloc_fattr(); |
242 | if (res.fattr == NULL) |
243 | goto out; |
244 | |
245 | status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); |
246 | nfs_refresh_inode(inode, res.fattr); |
247 | if (status == 0) |
248 | nfs_access_set_mask(entry, res.access); |
249 | nfs_free_fattr(fattr: res.fattr); |
250 | out: |
251 | dprintk("NFS reply access: %d\n" , status); |
252 | return status; |
253 | } |
254 | |
255 | static int nfs3_proc_readlink(struct inode *inode, struct page *page, |
256 | unsigned int pgbase, unsigned int pglen) |
257 | { |
258 | struct nfs_fattr *fattr; |
259 | struct nfs3_readlinkargs args = { |
260 | .fh = NFS_FH(inode), |
261 | .pgbase = pgbase, |
262 | .pglen = pglen, |
263 | .pages = &page |
264 | }; |
265 | struct rpc_message msg = { |
266 | .rpc_proc = &nfs3_procedures[NFS3PROC_READLINK], |
267 | .rpc_argp = &args, |
268 | }; |
269 | int status = -ENOMEM; |
270 | |
271 | dprintk("NFS call readlink\n" ); |
272 | fattr = nfs_alloc_fattr(); |
273 | if (fattr == NULL) |
274 | goto out; |
275 | msg.rpc_resp = fattr; |
276 | |
277 | status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); |
278 | nfs_refresh_inode(inode, fattr); |
279 | nfs_free_fattr(fattr); |
280 | out: |
281 | dprintk("NFS reply readlink: %d\n" , status); |
282 | return status; |
283 | } |
284 | |
285 | struct nfs3_createdata { |
286 | struct rpc_message msg; |
287 | union { |
288 | struct nfs3_createargs create; |
289 | struct nfs3_mkdirargs mkdir; |
290 | struct nfs3_symlinkargs symlink; |
291 | struct nfs3_mknodargs mknod; |
292 | } arg; |
293 | struct nfs3_diropres res; |
294 | struct nfs_fh fh; |
295 | struct nfs_fattr fattr; |
296 | struct nfs_fattr dir_attr; |
297 | }; |
298 | |
299 | static struct nfs3_createdata *nfs3_alloc_createdata(void) |
300 | { |
301 | struct nfs3_createdata *data; |
302 | |
303 | data = kzalloc(size: sizeof(*data), GFP_KERNEL); |
304 | if (data != NULL) { |
305 | data->msg.rpc_argp = &data->arg; |
306 | data->msg.rpc_resp = &data->res; |
307 | data->res.fh = &data->fh; |
308 | data->res.fattr = &data->fattr; |
309 | data->res.dir_attr = &data->dir_attr; |
310 | nfs_fattr_init(fattr: data->res.fattr); |
311 | nfs_fattr_init(fattr: data->res.dir_attr); |
312 | } |
313 | return data; |
314 | } |
315 | |
316 | static struct dentry * |
317 | nfs3_do_create(struct inode *dir, struct dentry *dentry, struct nfs3_createdata *data) |
318 | { |
319 | int status; |
320 | |
321 | status = rpc_call_sync(NFS_CLIENT(dir), &data->msg, 0); |
322 | nfs_post_op_update_inode(inode: dir, fattr: data->res.dir_attr); |
323 | if (status != 0) |
324 | return ERR_PTR(error: status); |
325 | |
326 | return nfs_add_or_obtain(dentry, fh: data->res.fh, fattr: data->res.fattr); |
327 | } |
328 | |
329 | static void nfs3_free_createdata(struct nfs3_createdata *data) |
330 | { |
331 | kfree(objp: data); |
332 | } |
333 | |
334 | /* |
335 | * Create a regular file. |
336 | */ |
337 | static int |
338 | nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr, |
339 | int flags) |
340 | { |
341 | struct posix_acl *default_acl, *acl; |
342 | struct nfs3_createdata *data; |
343 | struct dentry *d_alias; |
344 | int status = -ENOMEM; |
345 | |
346 | dprintk("NFS call create %pd\n" , dentry); |
347 | |
348 | data = nfs3_alloc_createdata(); |
349 | if (data == NULL) |
350 | goto out; |
351 | |
352 | data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_CREATE]; |
353 | data->arg.create.fh = NFS_FH(inode: dir); |
354 | data->arg.create.name = dentry->d_name.name; |
355 | data->arg.create.len = dentry->d_name.len; |
356 | data->arg.create.sattr = sattr; |
357 | |
358 | data->arg.create.createmode = NFS3_CREATE_UNCHECKED; |
359 | if (flags & O_EXCL) { |
360 | data->arg.create.createmode = NFS3_CREATE_EXCLUSIVE; |
361 | data->arg.create.verifier[0] = cpu_to_be32(jiffies); |
362 | data->arg.create.verifier[1] = cpu_to_be32(current->pid); |
363 | } |
364 | |
365 | status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl); |
366 | if (status) |
367 | goto out; |
368 | |
369 | for (;;) { |
370 | d_alias = nfs3_do_create(dir, dentry, data); |
371 | status = PTR_ERR_OR_ZERO(ptr: d_alias); |
372 | |
373 | if (status != -ENOTSUPP) |
374 | break; |
375 | /* If the server doesn't support the exclusive creation |
376 | * semantics, try again with simple 'guarded' mode. */ |
377 | switch (data->arg.create.createmode) { |
378 | case NFS3_CREATE_EXCLUSIVE: |
379 | data->arg.create.createmode = NFS3_CREATE_GUARDED; |
380 | break; |
381 | |
382 | case NFS3_CREATE_GUARDED: |
383 | data->arg.create.createmode = NFS3_CREATE_UNCHECKED; |
384 | break; |
385 | |
386 | case NFS3_CREATE_UNCHECKED: |
387 | goto out_release_acls; |
388 | } |
389 | nfs_fattr_init(fattr: data->res.dir_attr); |
390 | nfs_fattr_init(fattr: data->res.fattr); |
391 | } |
392 | |
393 | if (status != 0) |
394 | goto out_release_acls; |
395 | |
396 | if (d_alias) |
397 | dentry = d_alias; |
398 | |
399 | /* When we created the file with exclusive semantics, make |
400 | * sure we set the attributes afterwards. */ |
401 | if (data->arg.create.createmode == NFS3_CREATE_EXCLUSIVE) { |
402 | dprintk("NFS call setattr (post-create)\n" ); |
403 | |
404 | if (!(sattr->ia_valid & ATTR_ATIME_SET)) |
405 | sattr->ia_valid |= ATTR_ATIME; |
406 | if (!(sattr->ia_valid & ATTR_MTIME_SET)) |
407 | sattr->ia_valid |= ATTR_MTIME; |
408 | |
409 | /* Note: we could use a guarded setattr here, but I'm |
410 | * not sure this buys us anything (and I'd have |
411 | * to revamp the NFSv3 XDR code) */ |
412 | status = nfs3_proc_setattr(dentry, fattr: data->res.fattr, sattr); |
413 | nfs_post_op_update_inode(inode: d_inode(dentry), fattr: data->res.fattr); |
414 | dprintk("NFS reply setattr (post-create): %d\n" , status); |
415 | if (status != 0) |
416 | goto out_dput; |
417 | } |
418 | |
419 | status = nfs3_proc_setacls(inode: d_inode(dentry), acl, dfacl: default_acl); |
420 | |
421 | out_dput: |
422 | dput(d_alias); |
423 | out_release_acls: |
424 | posix_acl_release(acl); |
425 | posix_acl_release(acl: default_acl); |
426 | out: |
427 | nfs3_free_createdata(data); |
428 | dprintk("NFS reply create: %d\n" , status); |
429 | return status; |
430 | } |
431 | |
432 | static int |
433 | nfs3_proc_remove(struct inode *dir, struct dentry *dentry) |
434 | { |
435 | struct nfs_removeargs arg = { |
436 | .fh = NFS_FH(inode: dir), |
437 | .name = dentry->d_name, |
438 | }; |
439 | struct nfs_removeres res; |
440 | struct rpc_message msg = { |
441 | .rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE], |
442 | .rpc_argp = &arg, |
443 | .rpc_resp = &res, |
444 | }; |
445 | int status = -ENOMEM; |
446 | |
447 | dprintk("NFS call remove %pd2\n" , dentry); |
448 | res.dir_attr = nfs_alloc_fattr(); |
449 | if (res.dir_attr == NULL) |
450 | goto out; |
451 | |
452 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
453 | nfs_post_op_update_inode(inode: dir, fattr: res.dir_attr); |
454 | nfs_free_fattr(fattr: res.dir_attr); |
455 | out: |
456 | dprintk("NFS reply remove: %d\n" , status); |
457 | return status; |
458 | } |
459 | |
460 | static void |
461 | nfs3_proc_unlink_setup(struct rpc_message *msg, |
462 | struct dentry *dentry, |
463 | struct inode *inode) |
464 | { |
465 | msg->rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE]; |
466 | } |
467 | |
468 | static void nfs3_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data) |
469 | { |
470 | rpc_call_start(task); |
471 | } |
472 | |
473 | static int |
474 | nfs3_proc_unlink_done(struct rpc_task *task, struct inode *dir) |
475 | { |
476 | struct nfs_removeres *res; |
477 | if (nfs3_async_handle_jukebox(task, inode: dir)) |
478 | return 0; |
479 | res = task->tk_msg.rpc_resp; |
480 | nfs_post_op_update_inode(inode: dir, fattr: res->dir_attr); |
481 | return 1; |
482 | } |
483 | |
484 | static void |
485 | nfs3_proc_rename_setup(struct rpc_message *msg, |
486 | struct dentry *old_dentry, |
487 | struct dentry *new_dentry) |
488 | { |
489 | msg->rpc_proc = &nfs3_procedures[NFS3PROC_RENAME]; |
490 | } |
491 | |
492 | static void nfs3_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data) |
493 | { |
494 | rpc_call_start(task); |
495 | } |
496 | |
497 | static int |
498 | nfs3_proc_rename_done(struct rpc_task *task, struct inode *old_dir, |
499 | struct inode *new_dir) |
500 | { |
501 | struct nfs_renameres *res; |
502 | |
503 | if (nfs3_async_handle_jukebox(task, inode: old_dir)) |
504 | return 0; |
505 | res = task->tk_msg.rpc_resp; |
506 | |
507 | nfs_post_op_update_inode(inode: old_dir, fattr: res->old_fattr); |
508 | nfs_post_op_update_inode(inode: new_dir, fattr: res->new_fattr); |
509 | return 1; |
510 | } |
511 | |
512 | static int |
513 | nfs3_proc_link(struct inode *inode, struct inode *dir, const struct qstr *name) |
514 | { |
515 | struct nfs3_linkargs arg = { |
516 | .fromfh = NFS_FH(inode), |
517 | .tofh = NFS_FH(inode: dir), |
518 | .toname = name->name, |
519 | .tolen = name->len |
520 | }; |
521 | struct nfs3_linkres res; |
522 | struct rpc_message msg = { |
523 | .rpc_proc = &nfs3_procedures[NFS3PROC_LINK], |
524 | .rpc_argp = &arg, |
525 | .rpc_resp = &res, |
526 | }; |
527 | int status = -ENOMEM; |
528 | |
529 | dprintk("NFS call link %s\n" , name->name); |
530 | res.fattr = nfs_alloc_fattr(); |
531 | res.dir_attr = nfs_alloc_fattr(); |
532 | if (res.fattr == NULL || res.dir_attr == NULL) |
533 | goto out; |
534 | |
535 | status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0); |
536 | nfs_post_op_update_inode(inode: dir, fattr: res.dir_attr); |
537 | nfs_post_op_update_inode(inode, fattr: res.fattr); |
538 | out: |
539 | nfs_free_fattr(fattr: res.dir_attr); |
540 | nfs_free_fattr(fattr: res.fattr); |
541 | dprintk("NFS reply link: %d\n" , status); |
542 | return status; |
543 | } |
544 | |
545 | static int |
546 | nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct folio *folio, |
547 | unsigned int len, struct iattr *sattr) |
548 | { |
549 | struct page *page = &folio->page; |
550 | struct nfs3_createdata *data; |
551 | struct dentry *d_alias; |
552 | int status = -ENOMEM; |
553 | |
554 | if (len > NFS3_MAXPATHLEN) |
555 | return -ENAMETOOLONG; |
556 | |
557 | dprintk("NFS call symlink %pd\n" , dentry); |
558 | |
559 | data = nfs3_alloc_createdata(); |
560 | if (data == NULL) |
561 | goto out; |
562 | data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_SYMLINK]; |
563 | data->arg.symlink.fromfh = NFS_FH(inode: dir); |
564 | data->arg.symlink.fromname = dentry->d_name.name; |
565 | data->arg.symlink.fromlen = dentry->d_name.len; |
566 | data->arg.symlink.pages = &page; |
567 | data->arg.symlink.pathlen = len; |
568 | data->arg.symlink.sattr = sattr; |
569 | |
570 | d_alias = nfs3_do_create(dir, dentry, data); |
571 | status = PTR_ERR_OR_ZERO(ptr: d_alias); |
572 | |
573 | if (status == 0) |
574 | dput(d_alias); |
575 | |
576 | nfs3_free_createdata(data); |
577 | out: |
578 | dprintk("NFS reply symlink: %d\n" , status); |
579 | return status; |
580 | } |
581 | |
582 | static int |
583 | nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr) |
584 | { |
585 | struct posix_acl *default_acl, *acl; |
586 | struct nfs3_createdata *data; |
587 | struct dentry *d_alias; |
588 | int status = -ENOMEM; |
589 | |
590 | dprintk("NFS call mkdir %pd\n" , dentry); |
591 | |
592 | data = nfs3_alloc_createdata(); |
593 | if (data == NULL) |
594 | goto out; |
595 | |
596 | status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl); |
597 | if (status) |
598 | goto out; |
599 | |
600 | data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKDIR]; |
601 | data->arg.mkdir.fh = NFS_FH(inode: dir); |
602 | data->arg.mkdir.name = dentry->d_name.name; |
603 | data->arg.mkdir.len = dentry->d_name.len; |
604 | data->arg.mkdir.sattr = sattr; |
605 | |
606 | d_alias = nfs3_do_create(dir, dentry, data); |
607 | status = PTR_ERR_OR_ZERO(ptr: d_alias); |
608 | |
609 | if (status != 0) |
610 | goto out_release_acls; |
611 | |
612 | if (d_alias) |
613 | dentry = d_alias; |
614 | |
615 | status = nfs3_proc_setacls(inode: d_inode(dentry), acl, dfacl: default_acl); |
616 | |
617 | dput(d_alias); |
618 | out_release_acls: |
619 | posix_acl_release(acl); |
620 | posix_acl_release(acl: default_acl); |
621 | out: |
622 | nfs3_free_createdata(data); |
623 | dprintk("NFS reply mkdir: %d\n" , status); |
624 | return status; |
625 | } |
626 | |
627 | static int |
628 | nfs3_proc_rmdir(struct inode *dir, const struct qstr *name) |
629 | { |
630 | struct nfs_fattr *dir_attr; |
631 | struct nfs3_diropargs arg = { |
632 | .fh = NFS_FH(inode: dir), |
633 | .name = name->name, |
634 | .len = name->len |
635 | }; |
636 | struct rpc_message msg = { |
637 | .rpc_proc = &nfs3_procedures[NFS3PROC_RMDIR], |
638 | .rpc_argp = &arg, |
639 | }; |
640 | int status = -ENOMEM; |
641 | |
642 | dprintk("NFS call rmdir %s\n" , name->name); |
643 | dir_attr = nfs_alloc_fattr(); |
644 | if (dir_attr == NULL) |
645 | goto out; |
646 | |
647 | msg.rpc_resp = dir_attr; |
648 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
649 | nfs_post_op_update_inode(inode: dir, fattr: dir_attr); |
650 | nfs_free_fattr(fattr: dir_attr); |
651 | out: |
652 | dprintk("NFS reply rmdir: %d\n" , status); |
653 | return status; |
654 | } |
655 | |
656 | /* |
657 | * The READDIR implementation is somewhat hackish - we pass the user buffer |
658 | * to the encode function, which installs it in the receive iovec. |
659 | * The decode function itself doesn't perform any decoding, it just makes |
660 | * sure the reply is syntactically correct. |
661 | * |
662 | * Also note that this implementation handles both plain readdir and |
663 | * readdirplus. |
664 | */ |
665 | static int nfs3_proc_readdir(struct nfs_readdir_arg *nr_arg, |
666 | struct nfs_readdir_res *nr_res) |
667 | { |
668 | struct inode *dir = d_inode(dentry: nr_arg->dentry); |
669 | struct nfs3_readdirargs arg = { |
670 | .fh = NFS_FH(inode: dir), |
671 | .cookie = nr_arg->cookie, |
672 | .plus = nr_arg->plus, |
673 | .count = nr_arg->page_len, |
674 | .pages = nr_arg->pages |
675 | }; |
676 | struct nfs3_readdirres res = { |
677 | .verf = nr_res->verf, |
678 | .plus = nr_arg->plus, |
679 | }; |
680 | struct rpc_message msg = { |
681 | .rpc_proc = &nfs3_procedures[NFS3PROC_READDIR], |
682 | .rpc_argp = &arg, |
683 | .rpc_resp = &res, |
684 | .rpc_cred = nr_arg->cred, |
685 | }; |
686 | int status = -ENOMEM; |
687 | |
688 | if (nr_arg->plus) |
689 | msg.rpc_proc = &nfs3_procedures[NFS3PROC_READDIRPLUS]; |
690 | if (arg.cookie) |
691 | memcpy(arg.verf, nr_arg->verf, sizeof(arg.verf)); |
692 | |
693 | dprintk("NFS call readdir%s %llu\n" , nr_arg->plus ? "plus" : "" , |
694 | (unsigned long long)nr_arg->cookie); |
695 | |
696 | res.dir_attr = nfs_alloc_fattr(); |
697 | if (res.dir_attr == NULL) |
698 | goto out; |
699 | |
700 | status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0); |
701 | |
702 | nfs_invalidate_atime(dir); |
703 | nfs_refresh_inode(dir, res.dir_attr); |
704 | |
705 | nfs_free_fattr(fattr: res.dir_attr); |
706 | out: |
707 | dprintk("NFS reply readdir%s: %d\n" , nr_arg->plus ? "plus" : "" , |
708 | status); |
709 | return status; |
710 | } |
711 | |
712 | static int |
713 | nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr, |
714 | dev_t rdev) |
715 | { |
716 | struct posix_acl *default_acl, *acl; |
717 | struct nfs3_createdata *data; |
718 | struct dentry *d_alias; |
719 | int status = -ENOMEM; |
720 | |
721 | dprintk("NFS call mknod %pd %u:%u\n" , dentry, |
722 | MAJOR(rdev), MINOR(rdev)); |
723 | |
724 | data = nfs3_alloc_createdata(); |
725 | if (data == NULL) |
726 | goto out; |
727 | |
728 | status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl); |
729 | if (status) |
730 | goto out; |
731 | |
732 | data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKNOD]; |
733 | data->arg.mknod.fh = NFS_FH(inode: dir); |
734 | data->arg.mknod.name = dentry->d_name.name; |
735 | data->arg.mknod.len = dentry->d_name.len; |
736 | data->arg.mknod.sattr = sattr; |
737 | data->arg.mknod.rdev = rdev; |
738 | |
739 | switch (sattr->ia_mode & S_IFMT) { |
740 | case S_IFBLK: |
741 | data->arg.mknod.type = NF3BLK; |
742 | break; |
743 | case S_IFCHR: |
744 | data->arg.mknod.type = NF3CHR; |
745 | break; |
746 | case S_IFIFO: |
747 | data->arg.mknod.type = NF3FIFO; |
748 | break; |
749 | case S_IFSOCK: |
750 | data->arg.mknod.type = NF3SOCK; |
751 | break; |
752 | default: |
753 | status = -EINVAL; |
754 | goto out_release_acls; |
755 | } |
756 | |
757 | d_alias = nfs3_do_create(dir, dentry, data); |
758 | status = PTR_ERR_OR_ZERO(ptr: d_alias); |
759 | if (status != 0) |
760 | goto out_release_acls; |
761 | |
762 | if (d_alias) |
763 | dentry = d_alias; |
764 | |
765 | status = nfs3_proc_setacls(inode: d_inode(dentry), acl, dfacl: default_acl); |
766 | |
767 | dput(d_alias); |
768 | out_release_acls: |
769 | posix_acl_release(acl); |
770 | posix_acl_release(acl: default_acl); |
771 | out: |
772 | nfs3_free_createdata(data); |
773 | dprintk("NFS reply mknod: %d\n" , status); |
774 | return status; |
775 | } |
776 | |
777 | static int |
778 | nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, |
779 | struct nfs_fsstat *stat) |
780 | { |
781 | struct rpc_message msg = { |
782 | .rpc_proc = &nfs3_procedures[NFS3PROC_FSSTAT], |
783 | .rpc_argp = fhandle, |
784 | .rpc_resp = stat, |
785 | }; |
786 | int status; |
787 | |
788 | dprintk("NFS call fsstat\n" ); |
789 | nfs_fattr_init(fattr: stat->fattr); |
790 | status = rpc_call_sync(server->client, &msg, 0); |
791 | dprintk("NFS reply fsstat: %d\n" , status); |
792 | return status; |
793 | } |
794 | |
795 | static int |
796 | do_proc_fsinfo(struct rpc_clnt *client, struct nfs_fh *fhandle, |
797 | struct nfs_fsinfo *info) |
798 | { |
799 | struct rpc_message msg = { |
800 | .rpc_proc = &nfs3_procedures[NFS3PROC_FSINFO], |
801 | .rpc_argp = fhandle, |
802 | .rpc_resp = info, |
803 | }; |
804 | int status; |
805 | |
806 | dprintk("NFS call fsinfo\n" ); |
807 | nfs_fattr_init(fattr: info->fattr); |
808 | status = rpc_call_sync(client, &msg, 0); |
809 | dprintk("NFS reply fsinfo: %d\n" , status); |
810 | return status; |
811 | } |
812 | |
813 | /* |
814 | * Bare-bones access to fsinfo: this is for nfs_get_root/nfs_get_sb via |
815 | * nfs_create_server |
816 | */ |
817 | static int |
818 | nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, |
819 | struct nfs_fsinfo *info) |
820 | { |
821 | int status; |
822 | |
823 | status = do_proc_fsinfo(client: server->client, fhandle, info); |
824 | if (status && server->nfs_client->cl_rpcclient != server->client) |
825 | status = do_proc_fsinfo(client: server->nfs_client->cl_rpcclient, fhandle, info); |
826 | return status; |
827 | } |
828 | |
829 | static int |
830 | nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle, |
831 | struct nfs_pathconf *info) |
832 | { |
833 | struct rpc_message msg = { |
834 | .rpc_proc = &nfs3_procedures[NFS3PROC_PATHCONF], |
835 | .rpc_argp = fhandle, |
836 | .rpc_resp = info, |
837 | }; |
838 | int status; |
839 | |
840 | dprintk("NFS call pathconf\n" ); |
841 | nfs_fattr_init(fattr: info->fattr); |
842 | status = rpc_call_sync(server->client, &msg, 0); |
843 | dprintk("NFS reply pathconf: %d\n" , status); |
844 | return status; |
845 | } |
846 | |
847 | static int nfs3_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr) |
848 | { |
849 | struct inode *inode = hdr->inode; |
850 | struct nfs_server *server = NFS_SERVER(inode); |
851 | |
852 | if (hdr->pgio_done_cb != NULL) |
853 | return hdr->pgio_done_cb(task, hdr); |
854 | |
855 | if (nfs3_async_handle_jukebox(task, inode)) |
856 | return -EAGAIN; |
857 | |
858 | if (task->tk_status >= 0 && !server->read_hdrsize) |
859 | cmpxchg(&server->read_hdrsize, 0, hdr->res.replen); |
860 | |
861 | nfs_invalidate_atime(inode); |
862 | nfs_refresh_inode(inode, &hdr->fattr); |
863 | return 0; |
864 | } |
865 | |
866 | static void nfs3_proc_read_setup(struct nfs_pgio_header *hdr, |
867 | struct rpc_message *msg) |
868 | { |
869 | msg->rpc_proc = &nfs3_procedures[NFS3PROC_READ]; |
870 | hdr->args.replen = NFS_SERVER(inode: hdr->inode)->read_hdrsize; |
871 | } |
872 | |
873 | static int nfs3_proc_pgio_rpc_prepare(struct rpc_task *task, |
874 | struct nfs_pgio_header *hdr) |
875 | { |
876 | rpc_call_start(task); |
877 | return 0; |
878 | } |
879 | |
880 | static int nfs3_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr) |
881 | { |
882 | struct inode *inode = hdr->inode; |
883 | |
884 | if (hdr->pgio_done_cb != NULL) |
885 | return hdr->pgio_done_cb(task, hdr); |
886 | |
887 | if (nfs3_async_handle_jukebox(task, inode)) |
888 | return -EAGAIN; |
889 | if (task->tk_status >= 0) |
890 | nfs_writeback_update_inode(hdr); |
891 | return 0; |
892 | } |
893 | |
894 | static void nfs3_proc_write_setup(struct nfs_pgio_header *hdr, |
895 | struct rpc_message *msg, |
896 | struct rpc_clnt **clnt) |
897 | { |
898 | msg->rpc_proc = &nfs3_procedures[NFS3PROC_WRITE]; |
899 | } |
900 | |
901 | static void nfs3_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data) |
902 | { |
903 | rpc_call_start(task); |
904 | } |
905 | |
906 | static int nfs3_commit_done(struct rpc_task *task, struct nfs_commit_data *data) |
907 | { |
908 | if (data->commit_done_cb != NULL) |
909 | return data->commit_done_cb(task, data); |
910 | |
911 | if (nfs3_async_handle_jukebox(task, inode: data->inode)) |
912 | return -EAGAIN; |
913 | nfs_refresh_inode(data->inode, data->res.fattr); |
914 | return 0; |
915 | } |
916 | |
917 | static void nfs3_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg, |
918 | struct rpc_clnt **clnt) |
919 | { |
920 | msg->rpc_proc = &nfs3_procedures[NFS3PROC_COMMIT]; |
921 | } |
922 | |
923 | static void nfs3_nlm_alloc_call(void *data) |
924 | { |
925 | struct nfs_lock_context *l_ctx = data; |
926 | if (l_ctx && test_bit(NFS_CONTEXT_UNLOCK, &l_ctx->open_context->flags)) { |
927 | get_nfs_open_context(ctx: l_ctx->open_context); |
928 | nfs_get_lock_context(ctx: l_ctx->open_context); |
929 | } |
930 | } |
931 | |
932 | static bool nfs3_nlm_unlock_prepare(struct rpc_task *task, void *data) |
933 | { |
934 | struct nfs_lock_context *l_ctx = data; |
935 | if (l_ctx && test_bit(NFS_CONTEXT_UNLOCK, &l_ctx->open_context->flags)) |
936 | return nfs_async_iocounter_wait(task, l_ctx); |
937 | return false; |
938 | |
939 | } |
940 | |
941 | static void nfs3_nlm_release_call(void *data) |
942 | { |
943 | struct nfs_lock_context *l_ctx = data; |
944 | struct nfs_open_context *ctx; |
945 | if (l_ctx && test_bit(NFS_CONTEXT_UNLOCK, &l_ctx->open_context->flags)) { |
946 | ctx = l_ctx->open_context; |
947 | nfs_put_lock_context(l_ctx); |
948 | put_nfs_open_context(ctx); |
949 | } |
950 | } |
951 | |
952 | static const struct nlmclnt_operations nlmclnt_fl_close_lock_ops = { |
953 | .nlmclnt_alloc_call = nfs3_nlm_alloc_call, |
954 | .nlmclnt_unlock_prepare = nfs3_nlm_unlock_prepare, |
955 | .nlmclnt_release_call = nfs3_nlm_release_call, |
956 | }; |
957 | |
958 | static int |
959 | nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl) |
960 | { |
961 | struct inode *inode = file_inode(f: filp); |
962 | struct nfs_lock_context *l_ctx = NULL; |
963 | struct nfs_open_context *ctx = nfs_file_open_context(filp); |
964 | int status; |
965 | |
966 | if (fl->fl_flags & FL_CLOSE) { |
967 | l_ctx = nfs_get_lock_context(ctx); |
968 | if (IS_ERR(ptr: l_ctx)) |
969 | l_ctx = NULL; |
970 | else |
971 | set_bit(NFS_CONTEXT_UNLOCK, addr: &ctx->flags); |
972 | } |
973 | |
974 | status = nlmclnt_proc(host: NFS_SERVER(inode)->nlm_host, cmd, fl, data: l_ctx); |
975 | |
976 | if (l_ctx) |
977 | nfs_put_lock_context(l_ctx); |
978 | |
979 | return status; |
980 | } |
981 | |
982 | static int nfs3_have_delegation(struct inode *inode, fmode_t flags) |
983 | { |
984 | return 0; |
985 | } |
986 | |
987 | static const struct inode_operations nfs3_dir_inode_operations = { |
988 | .create = nfs_create, |
989 | .lookup = nfs_lookup, |
990 | .link = nfs_link, |
991 | .unlink = nfs_unlink, |
992 | .symlink = nfs_symlink, |
993 | .mkdir = nfs_mkdir, |
994 | .rmdir = nfs_rmdir, |
995 | .mknod = nfs_mknod, |
996 | .rename = nfs_rename, |
997 | .permission = nfs_permission, |
998 | .getattr = nfs_getattr, |
999 | .setattr = nfs_setattr, |
1000 | #ifdef CONFIG_NFS_V3_ACL |
1001 | .listxattr = nfs3_listxattr, |
1002 | .get_inode_acl = nfs3_get_acl, |
1003 | .set_acl = nfs3_set_acl, |
1004 | #endif |
1005 | }; |
1006 | |
1007 | static const struct inode_operations nfs3_file_inode_operations = { |
1008 | .permission = nfs_permission, |
1009 | .getattr = nfs_getattr, |
1010 | .setattr = nfs_setattr, |
1011 | #ifdef CONFIG_NFS_V3_ACL |
1012 | .listxattr = nfs3_listxattr, |
1013 | .get_inode_acl = nfs3_get_acl, |
1014 | .set_acl = nfs3_set_acl, |
1015 | #endif |
1016 | }; |
1017 | |
1018 | const struct nfs_rpc_ops nfs_v3_clientops = { |
1019 | .version = 3, /* protocol version */ |
1020 | .dentry_ops = &nfs_dentry_operations, |
1021 | .dir_inode_ops = &nfs3_dir_inode_operations, |
1022 | .file_inode_ops = &nfs3_file_inode_operations, |
1023 | .file_ops = &nfs_file_operations, |
1024 | .nlmclnt_ops = &nlmclnt_fl_close_lock_ops, |
1025 | .getroot = nfs3_proc_get_root, |
1026 | .submount = nfs_submount, |
1027 | .try_get_tree = nfs_try_get_tree, |
1028 | .getattr = nfs3_proc_getattr, |
1029 | .setattr = nfs3_proc_setattr, |
1030 | .lookup = nfs3_proc_lookup, |
1031 | .lookupp = nfs3_proc_lookupp, |
1032 | .access = nfs3_proc_access, |
1033 | .readlink = nfs3_proc_readlink, |
1034 | .create = nfs3_proc_create, |
1035 | .remove = nfs3_proc_remove, |
1036 | .unlink_setup = nfs3_proc_unlink_setup, |
1037 | .unlink_rpc_prepare = nfs3_proc_unlink_rpc_prepare, |
1038 | .unlink_done = nfs3_proc_unlink_done, |
1039 | .rename_setup = nfs3_proc_rename_setup, |
1040 | .rename_rpc_prepare = nfs3_proc_rename_rpc_prepare, |
1041 | .rename_done = nfs3_proc_rename_done, |
1042 | .link = nfs3_proc_link, |
1043 | .symlink = nfs3_proc_symlink, |
1044 | .mkdir = nfs3_proc_mkdir, |
1045 | .rmdir = nfs3_proc_rmdir, |
1046 | .readdir = nfs3_proc_readdir, |
1047 | .mknod = nfs3_proc_mknod, |
1048 | .statfs = nfs3_proc_statfs, |
1049 | .fsinfo = nfs3_proc_fsinfo, |
1050 | .pathconf = nfs3_proc_pathconf, |
1051 | .decode_dirent = nfs3_decode_dirent, |
1052 | .pgio_rpc_prepare = nfs3_proc_pgio_rpc_prepare, |
1053 | .read_setup = nfs3_proc_read_setup, |
1054 | .read_done = nfs3_read_done, |
1055 | .write_setup = nfs3_proc_write_setup, |
1056 | .write_done = nfs3_write_done, |
1057 | .commit_setup = nfs3_proc_commit_setup, |
1058 | .commit_rpc_prepare = nfs3_proc_commit_rpc_prepare, |
1059 | .commit_done = nfs3_commit_done, |
1060 | .lock = nfs3_proc_lock, |
1061 | .clear_acl_cache = forget_all_cached_acls, |
1062 | .close_context = nfs_close_context, |
1063 | .have_delegation = nfs3_have_delegation, |
1064 | .alloc_client = nfs_alloc_client, |
1065 | .init_client = nfs_init_client, |
1066 | .free_client = nfs_free_client, |
1067 | .create_server = nfs3_create_server, |
1068 | .clone_server = nfs3_clone_server, |
1069 | }; |
1070 | |