Branch data Line data Source code
1 : : /*
2 : : * fs/nfs/nfs4proc.c
3 : : *
4 : : * Client-side procedure declarations for NFSv4.
5 : : *
6 : : * Copyright (c) 2002 The Regents of the University of Michigan.
7 : : * All rights reserved.
8 : : *
9 : : * Kendrick Smith <kmsmith@umich.edu>
10 : : * Andy Adamson <andros@umich.edu>
11 : : *
12 : : * Redistribution and use in source and binary forms, with or without
13 : : * modification, are permitted provided that the following conditions
14 : : * are met:
15 : : *
16 : : * 1. Redistributions of source code must retain the above copyright
17 : : * notice, this list of conditions and the following disclaimer.
18 : : * 2. Redistributions in binary form must reproduce the above copyright
19 : : * notice, this list of conditions and the following disclaimer in the
20 : : * documentation and/or other materials provided with the distribution.
21 : : * 3. Neither the name of the University nor the names of its
22 : : * contributors may be used to endorse or promote products derived
23 : : * from this software without specific prior written permission.
24 : : *
25 : : * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
26 : : * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
27 : : * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
28 : : * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29 : : * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30 : : * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31 : : * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
32 : : * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33 : : * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34 : : * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35 : : * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 : : */
37 : :
38 : : #include <linux/mm.h>
39 : : #include <linux/delay.h>
40 : : #include <linux/errno.h>
41 : : #include <linux/string.h>
42 : : #include <linux/ratelimit.h>
43 : : #include <linux/printk.h>
44 : : #include <linux/slab.h>
45 : : #include <linux/sunrpc/clnt.h>
46 : : #include <linux/nfs.h>
47 : : #include <linux/nfs4.h>
48 : : #include <linux/nfs_fs.h>
49 : : #include <linux/nfs_page.h>
50 : : #include <linux/nfs_mount.h>
51 : : #include <linux/namei.h>
52 : : #include <linux/mount.h>
53 : : #include <linux/module.h>
54 : : #include <linux/nfs_idmap.h>
55 : : #include <linux/xattr.h>
56 : : #include <linux/utsname.h>
57 : : #include <linux/freezer.h>
58 : :
59 : : #include "nfs4_fs.h"
60 : : #include "delegation.h"
61 : : #include "internal.h"
62 : : #include "iostat.h"
63 : : #include "callback.h"
64 : : #include "pnfs.h"
65 : : #include "netns.h"
66 : : #include "nfs4session.h"
67 : : #include "fscache.h"
68 : :
69 : : #include "nfs4trace.h"
70 : :
71 : : #define NFSDBG_FACILITY NFSDBG_PROC
72 : :
73 : : #define NFS4_POLL_RETRY_MIN (HZ/10)
74 : : #define NFS4_POLL_RETRY_MAX (15*HZ)
75 : :
76 : : struct nfs4_opendata;
77 : : static int _nfs4_proc_open(struct nfs4_opendata *data);
78 : : static int _nfs4_recover_proc_open(struct nfs4_opendata *data);
79 : : static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *);
80 : : static int nfs4_async_handle_error(struct rpc_task *, const struct nfs_server *, struct nfs4_state *);
81 : : static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr);
82 : : static int nfs4_proc_getattr(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *, struct nfs4_label *label);
83 : : static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr, struct nfs4_label *label);
84 : : static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
85 : : struct nfs_fattr *fattr, struct iattr *sattr,
86 : : struct nfs4_state *state, struct nfs4_label *ilabel,
87 : : struct nfs4_label *olabel);
88 : : #ifdef CONFIG_NFS_V4_1
89 : : static int nfs41_test_stateid(struct nfs_server *, nfs4_stateid *,
90 : : struct rpc_cred *);
91 : : static int nfs41_free_stateid(struct nfs_server *, nfs4_stateid *,
92 : : struct rpc_cred *);
93 : : #endif
94 : :
95 : : #ifdef CONFIG_NFS_V4_SECURITY_LABEL
96 : : static inline struct nfs4_label *
97 : : nfs4_label_init_security(struct inode *dir, struct dentry *dentry,
98 : : struct iattr *sattr, struct nfs4_label *label)
99 : : {
100 : : int err;
101 : :
102 : : if (label == NULL)
103 : : return NULL;
104 : :
105 : : if (nfs_server_capable(dir, NFS_CAP_SECURITY_LABEL) == 0)
106 : : return NULL;
107 : :
108 : : err = security_dentry_init_security(dentry, sattr->ia_mode,
109 : : &dentry->d_name, (void **)&label->label, &label->len);
110 : : if (err == 0)
111 : : return label;
112 : :
113 : : return NULL;
114 : : }
115 : : static inline void
116 : : nfs4_label_release_security(struct nfs4_label *label)
117 : : {
118 : : if (label)
119 : : security_release_secctx(label->label, label->len);
120 : : }
121 : : static inline u32 *nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label)
122 : : {
123 : : if (label)
124 : : return server->attr_bitmask;
125 : :
126 : : return server->attr_bitmask_nl;
127 : : }
128 : : #else
129 : : static inline struct nfs4_label *
130 : : nfs4_label_init_security(struct inode *dir, struct dentry *dentry,
131 : : struct iattr *sattr, struct nfs4_label *l)
132 : : { return NULL; }
133 : : static inline void
134 : : nfs4_label_release_security(struct nfs4_label *label)
135 : : { return; }
136 : : static inline u32 *
137 : : nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label)
138 : : { return server->attr_bitmask; }
139 : : #endif
140 : :
141 : : /* Prevent leaks of NFSv4 errors into userland */
142 : 0 : static int nfs4_map_errors(int err)
143 : : {
144 [ # # ]: 0 : if (err >= -1000)
145 : : return err;
146 [ # # # # : 0 : switch (err) {
# # # # ]
147 : : case -NFS4ERR_RESOURCE:
148 : : case -NFS4ERR_LAYOUTTRYLATER:
149 : : case -NFS4ERR_RECALLCONFLICT:
150 : : return -EREMOTEIO;
151 : : case -NFS4ERR_WRONGSEC:
152 : : case -NFS4ERR_WRONG_CRED:
153 : 0 : return -EPERM;
154 : : case -NFS4ERR_BADOWNER:
155 : : case -NFS4ERR_BADNAME:
156 : 0 : return -EINVAL;
157 : : case -NFS4ERR_SHARE_DENIED:
158 : 0 : return -EACCES;
159 : : case -NFS4ERR_MINOR_VERS_MISMATCH:
160 : 0 : return -EPROTONOSUPPORT;
161 : : case -NFS4ERR_ACCESS:
162 : 0 : return -EACCES;
163 : : case -NFS4ERR_FILE_OPEN:
164 : 0 : return -EBUSY;
165 : : default:
166 : : dprintk("%s could not handle NFSv4 error %d\n",
167 : : __func__, -err);
168 : : break;
169 : : }
170 : 0 : return -EIO;
171 : : }
172 : :
173 : : /*
174 : : * This is our standard bitmap for GETATTR requests.
175 : : */
176 : : const u32 nfs4_fattr_bitmap[3] = {
177 : : FATTR4_WORD0_TYPE
178 : : | FATTR4_WORD0_CHANGE
179 : : | FATTR4_WORD0_SIZE
180 : : | FATTR4_WORD0_FSID
181 : : | FATTR4_WORD0_FILEID,
182 : : FATTR4_WORD1_MODE
183 : : | FATTR4_WORD1_NUMLINKS
184 : : | FATTR4_WORD1_OWNER
185 : : | FATTR4_WORD1_OWNER_GROUP
186 : : | FATTR4_WORD1_RAWDEV
187 : : | FATTR4_WORD1_SPACE_USED
188 : : | FATTR4_WORD1_TIME_ACCESS
189 : : | FATTR4_WORD1_TIME_METADATA
190 : : | FATTR4_WORD1_TIME_MODIFY,
191 : : #ifdef CONFIG_NFS_V4_SECURITY_LABEL
192 : : FATTR4_WORD2_SECURITY_LABEL
193 : : #endif
194 : : };
195 : :
196 : : static const u32 nfs4_pnfs_open_bitmap[3] = {
197 : : FATTR4_WORD0_TYPE
198 : : | FATTR4_WORD0_CHANGE
199 : : | FATTR4_WORD0_SIZE
200 : : | FATTR4_WORD0_FSID
201 : : | FATTR4_WORD0_FILEID,
202 : : FATTR4_WORD1_MODE
203 : : | FATTR4_WORD1_NUMLINKS
204 : : | FATTR4_WORD1_OWNER
205 : : | FATTR4_WORD1_OWNER_GROUP
206 : : | FATTR4_WORD1_RAWDEV
207 : : | FATTR4_WORD1_SPACE_USED
208 : : | FATTR4_WORD1_TIME_ACCESS
209 : : | FATTR4_WORD1_TIME_METADATA
210 : : | FATTR4_WORD1_TIME_MODIFY,
211 : : FATTR4_WORD2_MDSTHRESHOLD
212 : : };
213 : :
214 : : static const u32 nfs4_open_noattr_bitmap[3] = {
215 : : FATTR4_WORD0_TYPE
216 : : | FATTR4_WORD0_CHANGE
217 : : | FATTR4_WORD0_FILEID,
218 : : };
219 : :
220 : : const u32 nfs4_statfs_bitmap[3] = {
221 : : FATTR4_WORD0_FILES_AVAIL
222 : : | FATTR4_WORD0_FILES_FREE
223 : : | FATTR4_WORD0_FILES_TOTAL,
224 : : FATTR4_WORD1_SPACE_AVAIL
225 : : | FATTR4_WORD1_SPACE_FREE
226 : : | FATTR4_WORD1_SPACE_TOTAL
227 : : };
228 : :
229 : : const u32 nfs4_pathconf_bitmap[3] = {
230 : : FATTR4_WORD0_MAXLINK
231 : : | FATTR4_WORD0_MAXNAME,
232 : : 0
233 : : };
234 : :
235 : : const u32 nfs4_fsinfo_bitmap[3] = { FATTR4_WORD0_MAXFILESIZE
236 : : | FATTR4_WORD0_MAXREAD
237 : : | FATTR4_WORD0_MAXWRITE
238 : : | FATTR4_WORD0_LEASE_TIME,
239 : : FATTR4_WORD1_TIME_DELTA
240 : : | FATTR4_WORD1_FS_LAYOUT_TYPES,
241 : : FATTR4_WORD2_LAYOUT_BLKSIZE
242 : : };
243 : :
244 : : const u32 nfs4_fs_locations_bitmap[3] = {
245 : : FATTR4_WORD0_TYPE
246 : : | FATTR4_WORD0_CHANGE
247 : : | FATTR4_WORD0_SIZE
248 : : | FATTR4_WORD0_FSID
249 : : | FATTR4_WORD0_FILEID
250 : : | FATTR4_WORD0_FS_LOCATIONS,
251 : : FATTR4_WORD1_MODE
252 : : | FATTR4_WORD1_NUMLINKS
253 : : | FATTR4_WORD1_OWNER
254 : : | FATTR4_WORD1_OWNER_GROUP
255 : : | FATTR4_WORD1_RAWDEV
256 : : | FATTR4_WORD1_SPACE_USED
257 : : | FATTR4_WORD1_TIME_ACCESS
258 : : | FATTR4_WORD1_TIME_METADATA
259 : : | FATTR4_WORD1_TIME_MODIFY
260 : : | FATTR4_WORD1_MOUNTED_ON_FILEID,
261 : : };
262 : :
263 : 0 : static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dentry,
264 : : struct nfs4_readdir_arg *readdir)
265 : : {
266 : : __be32 *start, *p;
267 : :
268 [ # # ]: 0 : if (cookie > 2) {
269 : 0 : readdir->cookie = cookie;
270 : 0 : memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier));
271 : : return;
272 : : }
273 : :
274 : 0 : readdir->cookie = 0;
275 : 0 : memset(&readdir->verifier, 0, sizeof(readdir->verifier));
276 [ # # ]: 0 : if (cookie == 2)
277 : : return;
278 : :
279 : : /*
280 : : * NFSv4 servers do not return entries for '.' and '..'
281 : : * Therefore, we fake these entries here. We let '.'
282 : : * have cookie 0 and '..' have cookie 1. Note that
283 : : * when talking to the server, we always send cookie 0
284 : : * instead of 1 or 2.
285 : : */
286 : 0 : start = p = kmap_atomic(*readdir->pages);
287 : :
288 [ # # ]: 0 : if (cookie == 0) {
289 : 0 : *p++ = xdr_one; /* next */
290 : 0 : *p++ = xdr_zero; /* cookie, first word */
291 : 0 : *p++ = xdr_one; /* cookie, second word */
292 : 0 : *p++ = xdr_one; /* entry len */
293 : 0 : memcpy(p, ".\0\0\0", 4); /* entry */
294 : : p++;
295 : 0 : *p++ = xdr_one; /* bitmap length */
296 : 0 : *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */
297 : 0 : *p++ = htonl(8); /* attribute buffer length */
298 : 0 : p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_inode));
299 : : }
300 : :
301 : 0 : *p++ = xdr_one; /* next */
302 : 0 : *p++ = xdr_zero; /* cookie, first word */
303 : 0 : *p++ = xdr_two; /* cookie, second word */
304 : 0 : *p++ = xdr_two; /* entry len */
305 : 0 : memcpy(p, "..\0\0", 4); /* entry */
306 : : p++;
307 : 0 : *p++ = xdr_one; /* bitmap length */
308 : 0 : *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */
309 : 0 : *p++ = htonl(8); /* attribute buffer length */
310 : 0 : p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_parent->d_inode));
311 : :
312 : 0 : readdir->pgbase = (char *)p - (char *)start;
313 : 0 : readdir->count -= readdir->pgbase;
314 : 0 : kunmap_atomic(start);
315 : : }
316 : :
317 : 0 : static int nfs4_delay(struct rpc_clnt *clnt, long *timeout)
318 : : {
319 : : int res = 0;
320 : :
321 : : might_sleep();
322 : :
323 [ # # ]: 0 : if (*timeout <= 0)
324 : 0 : *timeout = NFS4_POLL_RETRY_MIN;
325 [ # # ]: 0 : if (*timeout > NFS4_POLL_RETRY_MAX)
326 : 0 : *timeout = NFS4_POLL_RETRY_MAX;
327 : 0 : freezable_schedule_timeout_killable_unsafe(*timeout);
328 [ # # ]: 0 : if (fatal_signal_pending(current))
329 : : res = -ERESTARTSYS;
330 : 0 : *timeout <<= 1;
331 : 0 : return res;
332 : : }
333 : :
334 : : /* This is the error handling routine for processes that are allowed
335 : : * to sleep.
336 : : */
337 : 0 : static int nfs4_handle_exception(struct nfs_server *server, int errorcode, struct nfs4_exception *exception)
338 : : {
339 : 0 : struct nfs_client *clp = server->nfs_client;
340 : 0 : struct nfs4_state *state = exception->state;
341 : 0 : struct inode *inode = exception->inode;
342 : : int ret = errorcode;
343 : :
344 : 0 : exception->retry = 0;
345 [ # # # # : 0 : switch(errorcode) {
# # # # #
# # # ]
346 : : case 0:
347 : : return 0;
348 : : case -NFS4ERR_OPENMODE:
349 [ # # ][ # # ]: 0 : if (inode && nfs4_have_delegation(inode, FMODE_READ)) {
350 : 0 : nfs4_inode_return_delegation(inode);
351 : 0 : exception->retry = 1;
352 : 0 : return 0;
353 : : }
354 [ # # ]: 0 : if (state == NULL)
355 : : break;
356 : 0 : ret = nfs4_schedule_stateid_recovery(server, state);
357 [ # # ]: 0 : if (ret < 0)
358 : : break;
359 : : goto wait_on_recovery;
360 : : case -NFS4ERR_DELEG_REVOKED:
361 : : case -NFS4ERR_ADMIN_REVOKED:
362 : : case -NFS4ERR_BAD_STATEID:
363 [ # # ][ # # ]: 0 : if (inode != NULL && nfs4_have_delegation(inode, FMODE_READ)) {
364 : 0 : nfs_remove_bad_delegation(inode);
365 : 0 : exception->retry = 1;
366 : 0 : break;
367 : : }
368 [ # # ]: 0 : if (state == NULL)
369 : : break;
370 : 0 : ret = nfs4_schedule_stateid_recovery(server, state);
371 [ # # ]: 0 : if (ret < 0)
372 : : break;
373 : : goto wait_on_recovery;
374 : : case -NFS4ERR_EXPIRED:
375 [ # # ]: 0 : if (state != NULL) {
376 : 0 : ret = nfs4_schedule_stateid_recovery(server, state);
377 [ # # ]: 0 : if (ret < 0)
378 : : break;
379 : : }
380 : : case -NFS4ERR_STALE_STATEID:
381 : : case -NFS4ERR_STALE_CLIENTID:
382 : 0 : nfs4_schedule_lease_recovery(clp);
383 : 0 : goto wait_on_recovery;
384 : : case -NFS4ERR_MOVED:
385 : 0 : ret = nfs4_schedule_migration_recovery(server);
386 [ # # ]: 0 : if (ret < 0)
387 : : break;
388 : : goto wait_on_recovery;
389 : : case -NFS4ERR_LEASE_MOVED:
390 : 0 : nfs4_schedule_lease_moved_recovery(clp);
391 : 0 : goto wait_on_recovery;
392 : : #if defined(CONFIG_NFS_V4_1)
393 : : case -NFS4ERR_BADSESSION:
394 : : case -NFS4ERR_BADSLOT:
395 : : case -NFS4ERR_BAD_HIGH_SLOT:
396 : : case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
397 : : case -NFS4ERR_DEADSESSION:
398 : : case -NFS4ERR_SEQ_FALSE_RETRY:
399 : : case -NFS4ERR_SEQ_MISORDERED:
400 : : dprintk("%s ERROR: %d Reset session\n", __func__,
401 : : errorcode);
402 : : nfs4_schedule_session_recovery(clp->cl_session, errorcode);
403 : : goto wait_on_recovery;
404 : : #endif /* defined(CONFIG_NFS_V4_1) */
405 : : case -NFS4ERR_FILE_OPEN:
406 [ # # ]: 0 : if (exception->timeout > HZ) {
407 : : /* We have retried a decent amount, time to
408 : : * fail
409 : : */
410 : : ret = -EBUSY;
411 : : break;
412 : : }
413 : : case -NFS4ERR_GRACE:
414 : : case -NFS4ERR_DELAY:
415 : 0 : ret = nfs4_delay(server->client, &exception->timeout);
416 [ # # ]: 0 : if (ret != 0)
417 : : break;
418 : : case -NFS4ERR_RETRY_UNCACHED_REP:
419 : : case -NFS4ERR_OLD_STATEID:
420 : 0 : exception->retry = 1;
421 : 0 : break;
422 : : case -NFS4ERR_BADOWNER:
423 : : /* The following works around a Linux server bug! */
424 : : case -NFS4ERR_BADNAME:
425 [ # # ]: 0 : if (server->caps & NFS_CAP_UIDGID_NOMAP) {
426 : 0 : server->caps &= ~NFS_CAP_UIDGID_NOMAP;
427 : 0 : exception->retry = 1;
428 : 0 : printk(KERN_WARNING "NFS: v4 server %s "
429 : : "does not accept raw "
430 : : "uid/gids. "
431 : : "Reenabling the idmapper.\n",
432 : 0 : server->nfs_client->cl_hostname);
433 : : }
434 : : }
435 : : /* We failed to handle the error */
436 : 0 : return nfs4_map_errors(ret);
437 : : wait_on_recovery:
438 : 0 : ret = nfs4_wait_clnt_recover(clp);
439 [ # # ]: 0 : if (test_bit(NFS_MIG_FAILED, &server->mig_status))
440 : : return -EIO;
441 [ # # ]: 0 : if (ret == 0)
442 : 0 : exception->retry = 1;
443 : 0 : return ret;
444 : : }
445 : :
446 : : /*
447 : : * Return 'true' if 'clp' is using an rpc_client that is integrity protected
448 : : * or 'false' otherwise.
449 : : */
450 : : static bool _nfs4_is_integrity_protected(struct nfs_client *clp)
451 : : {
452 : 0 : rpc_authflavor_t flavor = clp->cl_rpcclient->cl_auth->au_flavor;
453 : :
454 [ # # ]: 0 : if (flavor == RPC_AUTH_GSS_KRB5I ||
455 : : flavor == RPC_AUTH_GSS_KRB5P)
456 : : return true;
457 : :
458 : : return false;
459 : : }
460 : :
461 : 0 : static void do_renew_lease(struct nfs_client *clp, unsigned long timestamp)
462 : : {
463 : : spin_lock(&clp->cl_lock);
464 [ # # ]: 0 : if (time_before(clp->cl_last_renewal,timestamp))
465 : 0 : clp->cl_last_renewal = timestamp;
466 : : spin_unlock(&clp->cl_lock);
467 : 0 : }
468 : :
469 : : static void renew_lease(const struct nfs_server *server, unsigned long timestamp)
470 : : {
471 : 0 : do_renew_lease(server->nfs_client, timestamp);
472 : : }
473 : :
474 : : struct nfs4_call_sync_data {
475 : : const struct nfs_server *seq_server;
476 : : struct nfs4_sequence_args *seq_args;
477 : : struct nfs4_sequence_res *seq_res;
478 : : };
479 : :
480 : : static void nfs4_init_sequence(struct nfs4_sequence_args *args,
481 : : struct nfs4_sequence_res *res, int cache_reply)
482 : : {
483 : 0 : args->sa_slot = NULL;
484 : 0 : args->sa_cache_this = cache_reply;
485 : 0 : args->sa_privileged = 0;
486 : :
487 : 0 : res->sr_slot = NULL;
488 : : }
489 : :
490 : : static void nfs4_set_sequence_privileged(struct nfs4_sequence_args *args)
491 : : {
492 : 0 : args->sa_privileged = 1;
493 : : }
494 : :
495 : 0 : static int nfs40_setup_sequence(const struct nfs_server *server,
496 : : struct nfs4_sequence_args *args,
497 : : struct nfs4_sequence_res *res,
498 : : struct rpc_task *task)
499 : : {
500 : 0 : struct nfs4_slot_table *tbl = server->nfs_client->cl_slot_tbl;
501 : : struct nfs4_slot *slot;
502 : :
503 : : /* slot already allocated? */
504 [ # # ]: 0 : if (res->sr_slot != NULL)
505 : : goto out_start;
506 : :
507 : : spin_lock(&tbl->slot_tbl_lock);
508 [ # # ][ # # ]: 0 : if (nfs4_slot_tbl_draining(tbl) && !args->sa_privileged)
509 : : goto out_sleep;
510 : :
511 : 0 : slot = nfs4_alloc_slot(tbl);
512 [ # # ]: 0 : if (IS_ERR(slot)) {
513 [ # # ]: 0 : if (slot == ERR_PTR(-ENOMEM))
514 : 0 : task->tk_timeout = HZ >> 2;
515 : : goto out_sleep;
516 : : }
517 : : spin_unlock(&tbl->slot_tbl_lock);
518 : :
519 : 0 : args->sa_slot = slot;
520 : 0 : res->sr_slot = slot;
521 : :
522 : : out_start:
523 : 0 : rpc_call_start(task);
524 : : return 0;
525 : :
526 : : out_sleep:
527 [ # # ]: 0 : if (args->sa_privileged)
528 : 0 : rpc_sleep_on_priority(&tbl->slot_tbl_waitq, task,
529 : : NULL, RPC_PRIORITY_PRIVILEGED);
530 : : else
531 : 0 : rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);
532 : : spin_unlock(&tbl->slot_tbl_lock);
533 : : return -EAGAIN;
534 : : }
535 : :
536 : 0 : static int nfs40_sequence_done(struct rpc_task *task,
537 : : struct nfs4_sequence_res *res)
538 : : {
539 : 0 : struct nfs4_slot *slot = res->sr_slot;
540 : : struct nfs4_slot_table *tbl;
541 : :
542 [ # # ]: 0 : if (slot == NULL)
543 : : goto out;
544 : :
545 : 0 : tbl = slot->table;
546 : : spin_lock(&tbl->slot_tbl_lock);
547 [ # # ]: 0 : if (!nfs41_wake_and_assign_slot(tbl, slot))
548 : 0 : nfs4_free_slot(tbl, slot);
549 : : spin_unlock(&tbl->slot_tbl_lock);
550 : :
551 : 0 : res->sr_slot = NULL;
552 : : out:
553 : 0 : return 1;
554 : : }
555 : :
556 : : #if defined(CONFIG_NFS_V4_1)
557 : :
558 : : static void nfs41_sequence_free_slot(struct nfs4_sequence_res *res)
559 : : {
560 : : struct nfs4_session *session;
561 : : struct nfs4_slot_table *tbl;
562 : : struct nfs4_slot *slot = res->sr_slot;
563 : : bool send_new_highest_used_slotid = false;
564 : :
565 : : tbl = slot->table;
566 : : session = tbl->session;
567 : :
568 : : spin_lock(&tbl->slot_tbl_lock);
569 : : /* Be nice to the server: try to ensure that the last transmitted
570 : : * value for highest_user_slotid <= target_highest_slotid
571 : : */
572 : : if (tbl->highest_used_slotid > tbl->target_highest_slotid)
573 : : send_new_highest_used_slotid = true;
574 : :
575 : : if (nfs41_wake_and_assign_slot(tbl, slot)) {
576 : : send_new_highest_used_slotid = false;
577 : : goto out_unlock;
578 : : }
579 : : nfs4_free_slot(tbl, slot);
580 : :
581 : : if (tbl->highest_used_slotid != NFS4_NO_SLOT)
582 : : send_new_highest_used_slotid = false;
583 : : out_unlock:
584 : : spin_unlock(&tbl->slot_tbl_lock);
585 : : res->sr_slot = NULL;
586 : : if (send_new_highest_used_slotid)
587 : : nfs41_server_notify_highest_slotid_update(session->clp);
588 : : }
589 : :
590 : : int nfs41_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res)
591 : : {
592 : : struct nfs4_session *session;
593 : : struct nfs4_slot *slot = res->sr_slot;
594 : : struct nfs_client *clp;
595 : : bool interrupted = false;
596 : : int ret = 1;
597 : :
598 : : if (slot == NULL)
599 : : goto out_noaction;
600 : : /* don't increment the sequence number if the task wasn't sent */
601 : : if (!RPC_WAS_SENT(task))
602 : : goto out;
603 : :
604 : : session = slot->table->session;
605 : :
606 : : if (slot->interrupted) {
607 : : slot->interrupted = 0;
608 : : interrupted = true;
609 : : }
610 : :
611 : : trace_nfs4_sequence_done(session, res);
612 : : /* Check the SEQUENCE operation status */
613 : : switch (res->sr_status) {
614 : : case 0:
615 : : /* Update the slot's sequence and clientid lease timer */
616 : : ++slot->seq_nr;
617 : : clp = session->clp;
618 : : do_renew_lease(clp, res->sr_timestamp);
619 : : /* Check sequence flags */
620 : : if (res->sr_status_flags != 0)
621 : : nfs4_schedule_lease_recovery(clp);
622 : : nfs41_update_target_slotid(slot->table, slot, res);
623 : : break;
624 : : case 1:
625 : : /*
626 : : * sr_status remains 1 if an RPC level error occurred.
627 : : * The server may or may not have processed the sequence
628 : : * operation..
629 : : * Mark the slot as having hosted an interrupted RPC call.
630 : : */
631 : : slot->interrupted = 1;
632 : : goto out;
633 : : case -NFS4ERR_DELAY:
634 : : /* The server detected a resend of the RPC call and
635 : : * returned NFS4ERR_DELAY as per Section 2.10.6.2
636 : : * of RFC5661.
637 : : */
638 : : dprintk("%s: slot=%u seq=%u: Operation in progress\n",
639 : : __func__,
640 : : slot->slot_nr,
641 : : slot->seq_nr);
642 : : goto out_retry;
643 : : case -NFS4ERR_BADSLOT:
644 : : /*
645 : : * The slot id we used was probably retired. Try again
646 : : * using a different slot id.
647 : : */
648 : : goto retry_nowait;
649 : : case -NFS4ERR_SEQ_MISORDERED:
650 : : /*
651 : : * Was the last operation on this sequence interrupted?
652 : : * If so, retry after bumping the sequence number.
653 : : */
654 : : if (interrupted) {
655 : : ++slot->seq_nr;
656 : : goto retry_nowait;
657 : : }
658 : : /*
659 : : * Could this slot have been previously retired?
660 : : * If so, then the server may be expecting seq_nr = 1!
661 : : */
662 : : if (slot->seq_nr != 1) {
663 : : slot->seq_nr = 1;
664 : : goto retry_nowait;
665 : : }
666 : : break;
667 : : case -NFS4ERR_SEQ_FALSE_RETRY:
668 : : ++slot->seq_nr;
669 : : goto retry_nowait;
670 : : default:
671 : : /* Just update the slot sequence no. */
672 : : ++slot->seq_nr;
673 : : }
674 : : out:
675 : : /* The session may be reset by one of the error handlers. */
676 : : dprintk("%s: Error %d free the slot \n", __func__, res->sr_status);
677 : : nfs41_sequence_free_slot(res);
678 : : out_noaction:
679 : : return ret;
680 : : retry_nowait:
681 : : if (rpc_restart_call_prepare(task)) {
682 : : task->tk_status = 0;
683 : : ret = 0;
684 : : }
685 : : goto out;
686 : : out_retry:
687 : : if (!rpc_restart_call(task))
688 : : goto out;
689 : : rpc_delay(task, NFS4_POLL_RETRY_MAX);
690 : : return 0;
691 : : }
692 : : EXPORT_SYMBOL_GPL(nfs41_sequence_done);
693 : :
694 : : static int nfs4_sequence_done(struct rpc_task *task,
695 : : struct nfs4_sequence_res *res)
696 : : {
697 : : if (res->sr_slot == NULL)
698 : : return 1;
699 : : if (!res->sr_slot->table->session)
700 : : return nfs40_sequence_done(task, res);
701 : : return nfs41_sequence_done(task, res);
702 : : }
703 : :
704 : : int nfs41_setup_sequence(struct nfs4_session *session,
705 : : struct nfs4_sequence_args *args,
706 : : struct nfs4_sequence_res *res,
707 : : struct rpc_task *task)
708 : : {
709 : : struct nfs4_slot *slot;
710 : : struct nfs4_slot_table *tbl;
711 : :
712 : : dprintk("--> %s\n", __func__);
713 : : /* slot already allocated? */
714 : : if (res->sr_slot != NULL)
715 : : goto out_success;
716 : :
717 : : tbl = &session->fc_slot_table;
718 : :
719 : : task->tk_timeout = 0;
720 : :
721 : : spin_lock(&tbl->slot_tbl_lock);
722 : : if (test_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state) &&
723 : : !args->sa_privileged) {
724 : : /* The state manager will wait until the slot table is empty */
725 : : dprintk("%s session is draining\n", __func__);
726 : : goto out_sleep;
727 : : }
728 : :
729 : : slot = nfs4_alloc_slot(tbl);
730 : : if (IS_ERR(slot)) {
731 : : /* If out of memory, try again in 1/4 second */
732 : : if (slot == ERR_PTR(-ENOMEM))
733 : : task->tk_timeout = HZ >> 2;
734 : : dprintk("<-- %s: no free slots\n", __func__);
735 : : goto out_sleep;
736 : : }
737 : : spin_unlock(&tbl->slot_tbl_lock);
738 : :
739 : : args->sa_slot = slot;
740 : :
741 : : dprintk("<-- %s slotid=%u seqid=%u\n", __func__,
742 : : slot->slot_nr, slot->seq_nr);
743 : :
744 : : res->sr_slot = slot;
745 : : res->sr_timestamp = jiffies;
746 : : res->sr_status_flags = 0;
747 : : /*
748 : : * sr_status is only set in decode_sequence, and so will remain
749 : : * set to 1 if an rpc level failure occurs.
750 : : */
751 : : res->sr_status = 1;
752 : : trace_nfs4_setup_sequence(session, args);
753 : : out_success:
754 : : rpc_call_start(task);
755 : : return 0;
756 : : out_sleep:
757 : : /* Privileged tasks are queued with top priority */
758 : : if (args->sa_privileged)
759 : : rpc_sleep_on_priority(&tbl->slot_tbl_waitq, task,
760 : : NULL, RPC_PRIORITY_PRIVILEGED);
761 : : else
762 : : rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);
763 : : spin_unlock(&tbl->slot_tbl_lock);
764 : : return -EAGAIN;
765 : : }
766 : : EXPORT_SYMBOL_GPL(nfs41_setup_sequence);
767 : :
768 : : static int nfs4_setup_sequence(const struct nfs_server *server,
769 : : struct nfs4_sequence_args *args,
770 : : struct nfs4_sequence_res *res,
771 : : struct rpc_task *task)
772 : : {
773 : : struct nfs4_session *session = nfs4_get_session(server);
774 : : int ret = 0;
775 : :
776 : : if (!session)
777 : : return nfs40_setup_sequence(server, args, res, task);
778 : :
779 : : dprintk("--> %s clp %p session %p sr_slot %u\n",
780 : : __func__, session->clp, session, res->sr_slot ?
781 : : res->sr_slot->slot_nr : NFS4_NO_SLOT);
782 : :
783 : : ret = nfs41_setup_sequence(session, args, res, task);
784 : :
785 : : dprintk("<-- %s status=%d\n", __func__, ret);
786 : : return ret;
787 : : }
788 : :
789 : : static void nfs41_call_sync_prepare(struct rpc_task *task, void *calldata)
790 : : {
791 : : struct nfs4_call_sync_data *data = calldata;
792 : : struct nfs4_session *session = nfs4_get_session(data->seq_server);
793 : :
794 : : dprintk("--> %s data->seq_server %p\n", __func__, data->seq_server);
795 : :
796 : : nfs41_setup_sequence(session, data->seq_args, data->seq_res, task);
797 : : }
798 : :
799 : : static void nfs41_call_sync_done(struct rpc_task *task, void *calldata)
800 : : {
801 : : struct nfs4_call_sync_data *data = calldata;
802 : :
803 : : nfs41_sequence_done(task, data->seq_res);
804 : : }
805 : :
806 : : static const struct rpc_call_ops nfs41_call_sync_ops = {
807 : : .rpc_call_prepare = nfs41_call_sync_prepare,
808 : : .rpc_call_done = nfs41_call_sync_done,
809 : : };
810 : :
811 : : #else /* !CONFIG_NFS_V4_1 */
812 : :
813 : 0 : static int nfs4_setup_sequence(const struct nfs_server *server,
814 : : struct nfs4_sequence_args *args,
815 : : struct nfs4_sequence_res *res,
816 : : struct rpc_task *task)
817 : : {
818 : 0 : return nfs40_setup_sequence(server, args, res, task);
819 : : }
820 : :
821 : : static int nfs4_sequence_done(struct rpc_task *task,
822 : : struct nfs4_sequence_res *res)
823 : : {
824 : 0 : return nfs40_sequence_done(task, res);
825 : : }
826 : :
827 : : #endif /* !CONFIG_NFS_V4_1 */
828 : :
829 : 0 : static void nfs40_call_sync_prepare(struct rpc_task *task, void *calldata)
830 : : {
831 : : struct nfs4_call_sync_data *data = calldata;
832 : 0 : nfs4_setup_sequence(data->seq_server,
833 : : data->seq_args, data->seq_res, task);
834 : 0 : }
835 : :
836 : 0 : static void nfs40_call_sync_done(struct rpc_task *task, void *calldata)
837 : : {
838 : : struct nfs4_call_sync_data *data = calldata;
839 : 0 : nfs4_sequence_done(task, data->seq_res);
840 : 0 : }
841 : :
842 : : static const struct rpc_call_ops nfs40_call_sync_ops = {
843 : : .rpc_call_prepare = nfs40_call_sync_prepare,
844 : : .rpc_call_done = nfs40_call_sync_done,
845 : : };
846 : :
847 : 0 : static int nfs4_call_sync_sequence(struct rpc_clnt *clnt,
848 : : struct nfs_server *server,
849 : : struct rpc_message *msg,
850 : : struct nfs4_sequence_args *args,
851 : : struct nfs4_sequence_res *res)
852 : : {
853 : : int ret;
854 : : struct rpc_task *task;
855 : 0 : struct nfs_client *clp = server->nfs_client;
856 : 0 : struct nfs4_call_sync_data data = {
857 : : .seq_server = server,
858 : : .seq_args = args,
859 : : .seq_res = res,
860 : : };
861 : 0 : struct rpc_task_setup task_setup = {
862 : : .rpc_client = clnt,
863 : : .rpc_message = msg,
864 : 0 : .callback_ops = clp->cl_mvops->call_sync_ops,
865 : : .callback_data = &data
866 : : };
867 : :
868 : 0 : task = rpc_run_task(&task_setup);
869 [ # # ]: 0 : if (IS_ERR(task))
870 : : ret = PTR_ERR(task);
871 : : else {
872 : 0 : ret = task->tk_status;
873 : 0 : rpc_put_task(task);
874 : : }
875 : 0 : return ret;
876 : : }
877 : :
878 : : static
879 : : int nfs4_call_sync(struct rpc_clnt *clnt,
880 : : struct nfs_server *server,
881 : : struct rpc_message *msg,
882 : : struct nfs4_sequence_args *args,
883 : : struct nfs4_sequence_res *res,
884 : : int cache_reply)
885 : : {
886 : : nfs4_init_sequence(args, res, cache_reply);
887 : 0 : return nfs4_call_sync_sequence(clnt, server, msg, args, res);
888 : : }
889 : :
890 : 0 : static void update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo)
891 : : {
892 : : struct nfs_inode *nfsi = NFS_I(dir);
893 : :
894 : : spin_lock(&dir->i_lock);
895 : 0 : nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
896 [ # # ][ # # ]: 0 : if (!cinfo->atomic || cinfo->before != dir->i_version)
897 : 0 : nfs_force_lookup_revalidate(dir);
898 : 0 : dir->i_version = cinfo->after;
899 : : nfs_fscache_invalidate(dir);
900 : : spin_unlock(&dir->i_lock);
901 : 0 : }
902 : :
903 : : struct nfs4_opendata {
904 : : struct kref kref;
905 : : struct nfs_openargs o_arg;
906 : : struct nfs_openres o_res;
907 : : struct nfs_open_confirmargs c_arg;
908 : : struct nfs_open_confirmres c_res;
909 : : struct nfs4_string owner_name;
910 : : struct nfs4_string group_name;
911 : : struct nfs_fattr f_attr;
912 : : struct nfs4_label *f_label;
913 : : struct dentry *dir;
914 : : struct dentry *dentry;
915 : : struct nfs4_state_owner *owner;
916 : : struct nfs4_state *state;
917 : : struct iattr attrs;
918 : : unsigned long timestamp;
919 : : unsigned int rpc_done : 1;
920 : : unsigned int file_created : 1;
921 : : unsigned int is_recover : 1;
922 : : int rpc_status;
923 : : int cancelled;
924 : : };
925 : :
926 : : static bool nfs4_clear_cap_atomic_open_v1(struct nfs_server *server,
927 : : int err, struct nfs4_exception *exception)
928 : : {
929 [ # # ][ # # ]: 0 : if (err != -EINVAL)
[ # # ]
930 : : return false;
931 [ # # ][ # # ]: 0 : if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1))
[ # # ]
932 : : return false;
933 : 0 : server->caps &= ~NFS_CAP_ATOMIC_OPEN_V1;
934 : 0 : exception->retry = 1;
935 : : return true;
936 : : }
937 : :
938 : : static enum open_claim_type4
939 : : nfs4_map_atomic_open_claim(struct nfs_server *server,
940 : : enum open_claim_type4 claim)
941 : : {
942 [ # # ]: 0 : if (server->caps & NFS_CAP_ATOMIC_OPEN_V1)
943 : : return claim;
944 [ # # # # ]: 0 : switch (claim) {
945 : : default:
946 : : return claim;
947 : : case NFS4_OPEN_CLAIM_FH:
948 : : return NFS4_OPEN_CLAIM_NULL;
949 : : case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
950 : : return NFS4_OPEN_CLAIM_DELEGATE_CUR;
951 : : case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
952 : : return NFS4_OPEN_CLAIM_DELEGATE_PREV;
953 : : }
954 : : }
955 : :
956 : 0 : static void nfs4_init_opendata_res(struct nfs4_opendata *p)
957 : : {
958 : 0 : p->o_res.f_attr = &p->f_attr;
959 : 0 : p->o_res.f_label = p->f_label;
960 : 0 : p->o_res.seqid = p->o_arg.seqid;
961 : 0 : p->c_res.seqid = p->c_arg.seqid;
962 : 0 : p->o_res.server = p->o_arg.server;
963 : 0 : p->o_res.access_request = p->o_arg.access;
964 : 0 : nfs_fattr_init(&p->f_attr);
965 : 0 : nfs_fattr_init_names(&p->f_attr, &p->owner_name, &p->group_name);
966 : 0 : }
967 : :
968 : 0 : static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
969 : : struct nfs4_state_owner *sp, fmode_t fmode, int flags,
970 : : const struct iattr *attrs,
971 : : struct nfs4_label *label,
972 : : enum open_claim_type4 claim,
973 : : gfp_t gfp_mask)
974 : : {
975 : 0 : struct dentry *parent = dget_parent(dentry);
976 : 0 : struct inode *dir = parent->d_inode;
977 : 0 : struct nfs_server *server = NFS_SERVER(dir);
978 : : struct nfs4_opendata *p;
979 : :
980 : : p = kzalloc(sizeof(*p), gfp_mask);
981 [ # # ]: 0 : if (p == NULL)
982 : : goto err;
983 : :
984 : 0 : p->f_label = nfs4_label_alloc(server, gfp_mask);
985 [ # # ]: 0 : if (IS_ERR(p->f_label))
986 : : goto err_free_p;
987 : :
988 : 0 : p->o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid, gfp_mask);
989 [ # # ]: 0 : if (p->o_arg.seqid == NULL)
990 : : goto err_free_label;
991 : 0 : nfs_sb_active(dentry->d_sb);
992 : 0 : p->dentry = dget(dentry);
993 : 0 : p->dir = parent;
994 : 0 : p->owner = sp;
995 : 0 : atomic_inc(&sp->so_count);
996 : 0 : p->o_arg.open_flags = flags;
997 : 0 : p->o_arg.fmode = fmode & (FMODE_READ|FMODE_WRITE);
998 : : /* don't put an ACCESS op in OPEN compound if O_EXCL, because ACCESS
999 : : * will return permission denied for all bits until close */
1000 [ # # ]: 0 : if (!(flags & O_EXCL)) {
1001 : : /* ask server to check for all possible rights as results
1002 : : * are cached */
1003 : 0 : p->o_arg.access = NFS4_ACCESS_READ | NFS4_ACCESS_MODIFY |
1004 : : NFS4_ACCESS_EXTEND | NFS4_ACCESS_EXECUTE;
1005 : : }
1006 : 0 : p->o_arg.clientid = server->nfs_client->cl_clientid;
1007 : 0 : p->o_arg.id.create_time = ktime_to_ns(sp->so_seqid.create_time);
1008 : 0 : p->o_arg.id.uniquifier = sp->so_seqid.owner_id;
1009 : 0 : p->o_arg.name = &dentry->d_name;
1010 : 0 : p->o_arg.server = server;
1011 : 0 : p->o_arg.bitmask = nfs4_bitmask(server, label);
1012 : 0 : p->o_arg.open_bitmap = &nfs4_fattr_bitmap[0];
1013 : 0 : p->o_arg.label = label;
1014 [ # # ][ # # ]: 0 : p->o_arg.claim = nfs4_map_atomic_open_claim(server, claim);
[ # # ]
1015 : : switch (p->o_arg.claim) {
1016 : : case NFS4_OPEN_CLAIM_NULL:
1017 : : case NFS4_OPEN_CLAIM_DELEGATE_CUR:
1018 : : case NFS4_OPEN_CLAIM_DELEGATE_PREV:
1019 : 0 : p->o_arg.fh = NFS_FH(dir);
1020 : 0 : break;
1021 : : case NFS4_OPEN_CLAIM_PREVIOUS:
1022 : : case NFS4_OPEN_CLAIM_FH:
1023 : : case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
1024 : : case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
1025 : 0 : p->o_arg.fh = NFS_FH(dentry->d_inode);
1026 : : }
1027 [ # # ][ # # ]: 0 : if (attrs != NULL && attrs->ia_valid != 0) {
1028 : : __u32 verf[2];
1029 : :
1030 : 0 : p->o_arg.u.attrs = &p->attrs;
1031 : 0 : memcpy(&p->attrs, attrs, sizeof(p->attrs));
1032 : :
1033 : 0 : verf[0] = jiffies;
1034 : 0 : verf[1] = current->pid;
1035 : 0 : memcpy(p->o_arg.u.verifier.data, verf,
1036 : : sizeof(p->o_arg.u.verifier.data));
1037 : : }
1038 : 0 : p->c_arg.fh = &p->o_res.fh;
1039 : 0 : p->c_arg.stateid = &p->o_res.stateid;
1040 : 0 : p->c_arg.seqid = p->o_arg.seqid;
1041 : 0 : nfs4_init_opendata_res(p);
1042 : : kref_init(&p->kref);
1043 : 0 : return p;
1044 : :
1045 : : err_free_label:
1046 : : nfs4_label_free(p->f_label);
1047 : : err_free_p:
1048 : 0 : kfree(p);
1049 : : err:
1050 : 0 : dput(parent);
1051 : 0 : return NULL;
1052 : : }
1053 : :
1054 : 0 : static void nfs4_opendata_free(struct kref *kref)
1055 : : {
1056 : : struct nfs4_opendata *p = container_of(kref,
1057 : : struct nfs4_opendata, kref);
1058 : 0 : struct super_block *sb = p->dentry->d_sb;
1059 : :
1060 : 0 : nfs_free_seqid(p->o_arg.seqid);
1061 [ # # ]: 0 : if (p->state != NULL)
1062 : 0 : nfs4_put_open_state(p->state);
1063 : 0 : nfs4_put_state_owner(p->owner);
1064 : :
1065 : : nfs4_label_free(p->f_label);
1066 : :
1067 : 0 : dput(p->dir);
1068 : 0 : dput(p->dentry);
1069 : 0 : nfs_sb_deactive(sb);
1070 : 0 : nfs_fattr_free_names(&p->f_attr);
1071 : 0 : kfree(p);
1072 : 0 : }
1073 : :
1074 : 0 : static void nfs4_opendata_put(struct nfs4_opendata *p)
1075 : : {
1076 [ # # ]: 0 : if (p != NULL)
1077 : 0 : kref_put(&p->kref, nfs4_opendata_free);
1078 : 0 : }
1079 : :
1080 : : static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task)
1081 : : {
1082 : : int ret;
1083 : :
1084 : : ret = rpc_wait_for_completion_task(task);
1085 : : return ret;
1086 : : }
1087 : :
1088 : 0 : static int can_open_cached(struct nfs4_state *state, fmode_t mode, int open_mode)
1089 : : {
1090 : : int ret = 0;
1091 : :
1092 [ # # ]: 0 : if (open_mode & (O_EXCL|O_TRUNC))
1093 : : goto out;
1094 [ # # # # ]: 0 : switch (mode & (FMODE_READ|FMODE_WRITE)) {
1095 : : case FMODE_READ:
1096 : : ret |= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0
1097 [ # # ][ # # ]: 0 : && state->n_rdonly != 0;
1098 : 0 : break;
1099 : : case FMODE_WRITE:
1100 : : ret |= test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0
1101 [ # # ][ # # ]: 0 : && state->n_wronly != 0;
1102 : 0 : break;
1103 : : case FMODE_READ|FMODE_WRITE:
1104 : : ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0
1105 [ # # ][ # # ]: 0 : && state->n_rdwr != 0;
1106 : : }
1107 : : out:
1108 : 0 : return ret;
1109 : : }
1110 : :
1111 : 0 : static int can_open_delegated(struct nfs_delegation *delegation, fmode_t fmode)
1112 : : {
1113 [ # # ]: 0 : if (delegation == NULL)
1114 : : return 0;
1115 [ # # ]: 0 : if ((delegation->type & fmode) != fmode)
1116 : : return 0;
1117 [ # # ]: 0 : if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags))
1118 : : return 0;
1119 [ # # ]: 0 : if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
1120 : : return 0;
1121 : 0 : nfs_mark_delegation_referenced(delegation);
1122 : 0 : return 1;
1123 : : }
1124 : :
1125 : 0 : static void update_open_stateflags(struct nfs4_state *state, fmode_t fmode)
1126 : : {
1127 [ # # # # ]: 0 : switch (fmode) {
1128 : : case FMODE_WRITE:
1129 : 0 : state->n_wronly++;
1130 : 0 : break;
1131 : : case FMODE_READ:
1132 : 0 : state->n_rdonly++;
1133 : 0 : break;
1134 : : case FMODE_READ|FMODE_WRITE:
1135 : 0 : state->n_rdwr++;
1136 : : }
1137 : 0 : nfs4_state_set_mode_locked(state, state->state | fmode);
1138 : 0 : }
1139 : :
1140 : 0 : static void nfs_set_open_stateid_locked(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode)
1141 : : {
1142 [ # # ]: 0 : if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
1143 : 0 : nfs4_stateid_copy(&state->stateid, stateid);
1144 : 0 : nfs4_stateid_copy(&state->open_stateid, stateid);
1145 : 0 : set_bit(NFS_OPEN_STATE, &state->flags);
1146 [ # # # # ]: 0 : switch (fmode) {
1147 : : case FMODE_READ:
1148 : 0 : set_bit(NFS_O_RDONLY_STATE, &state->flags);
1149 : 0 : break;
1150 : : case FMODE_WRITE:
1151 : 0 : set_bit(NFS_O_WRONLY_STATE, &state->flags);
1152 : 0 : break;
1153 : : case FMODE_READ|FMODE_WRITE:
1154 : 0 : set_bit(NFS_O_RDWR_STATE, &state->flags);
1155 : : }
1156 : 0 : }
1157 : :
1158 : 0 : static void nfs_set_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode)
1159 : : {
1160 : : write_seqlock(&state->seqlock);
1161 : 0 : nfs_set_open_stateid_locked(state, stateid, fmode);
1162 : : write_sequnlock(&state->seqlock);
1163 : 0 : }
1164 : :
1165 : 0 : static void __update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, const nfs4_stateid *deleg_stateid, fmode_t fmode)
1166 : : {
1167 : : /*
1168 : : * Protect the call to nfs4_state_set_mode_locked and
1169 : : * serialise the stateid update
1170 : : */
1171 : : write_seqlock(&state->seqlock);
1172 [ # # ]: 0 : if (deleg_stateid != NULL) {
1173 : 0 : nfs4_stateid_copy(&state->stateid, deleg_stateid);
1174 : 0 : set_bit(NFS_DELEGATED_STATE, &state->flags);
1175 : : }
1176 [ # # ]: 0 : if (open_stateid != NULL)
1177 : 0 : nfs_set_open_stateid_locked(state, open_stateid, fmode);
1178 : : write_sequnlock(&state->seqlock);
1179 : 0 : spin_lock(&state->owner->so_lock);
1180 : 0 : update_open_stateflags(state, fmode);
1181 : 0 : spin_unlock(&state->owner->so_lock);
1182 : 0 : }
1183 : :
1184 : 0 : static int update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, nfs4_stateid *delegation, fmode_t fmode)
1185 : : {
1186 : 0 : struct nfs_inode *nfsi = NFS_I(state->inode);
1187 : : struct nfs_delegation *deleg_cur;
1188 : : int ret = 0;
1189 : :
1190 : 0 : fmode &= (FMODE_READ|FMODE_WRITE);
1191 : :
1192 : : rcu_read_lock();
1193 : 0 : deleg_cur = rcu_dereference(nfsi->delegation);
1194 [ # # ]: 0 : if (deleg_cur == NULL)
1195 : : goto no_delegation;
1196 : :
1197 : : spin_lock(&deleg_cur->lock);
1198 [ # # ][ # # ]: 0 : if (rcu_dereference(nfsi->delegation) != deleg_cur ||
1199 [ # # ]: 0 : test_bit(NFS_DELEGATION_RETURNING, &deleg_cur->flags) ||
1200 : 0 : (deleg_cur->type & fmode) != fmode)
1201 : : goto no_delegation_unlock;
1202 : :
1203 [ # # ]: 0 : if (delegation == NULL)
1204 : : delegation = &deleg_cur->stateid;
1205 [ # # ]: 0 : else if (!nfs4_stateid_match(&deleg_cur->stateid, delegation))
1206 : : goto no_delegation_unlock;
1207 : :
1208 : 0 : nfs_mark_delegation_referenced(deleg_cur);
1209 : 0 : __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode);
1210 : : ret = 1;
1211 : : no_delegation_unlock:
1212 : : spin_unlock(&deleg_cur->lock);
1213 : : no_delegation:
1214 : : rcu_read_unlock();
1215 : :
1216 [ # # ]: 0 : if (!ret && open_stateid != NULL) {
1217 : 0 : __update_open_stateid(state, open_stateid, NULL, fmode);
1218 : : ret = 1;
1219 : : }
1220 : :
1221 : 0 : return ret;
1222 : : }
1223 : :
1224 : :
1225 : 0 : static void nfs4_return_incompatible_delegation(struct inode *inode, fmode_t fmode)
1226 : : {
1227 : : struct nfs_delegation *delegation;
1228 : :
1229 : : rcu_read_lock();
1230 : 0 : delegation = rcu_dereference(NFS_I(inode)->delegation);
1231 [ # # ][ # # ]: 0 : if (delegation == NULL || (delegation->type & fmode) == fmode) {
1232 : : rcu_read_unlock();
1233 : 0 : return;
1234 : : }
1235 : : rcu_read_unlock();
1236 : 0 : nfs4_inode_return_delegation(inode);
1237 : : }
1238 : :
1239 : 0 : static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata)
1240 : : {
1241 : 0 : struct nfs4_state *state = opendata->state;
1242 : 0 : struct nfs_inode *nfsi = NFS_I(state->inode);
1243 : : struct nfs_delegation *delegation;
1244 : 0 : int open_mode = opendata->o_arg.open_flags;
1245 : 0 : fmode_t fmode = opendata->o_arg.fmode;
1246 : : nfs4_stateid stateid;
1247 : : int ret = -EAGAIN;
1248 : :
1249 : : for (;;) {
1250 [ # # ]: 0 : if (can_open_cached(state, fmode, open_mode)) {
1251 : 0 : spin_lock(&state->owner->so_lock);
1252 [ # # ]: 0 : if (can_open_cached(state, fmode, open_mode)) {
1253 : 0 : update_open_stateflags(state, fmode);
1254 : 0 : spin_unlock(&state->owner->so_lock);
1255 : : goto out_return_state;
1256 : : }
1257 : 0 : spin_unlock(&state->owner->so_lock);
1258 : : }
1259 : : rcu_read_lock();
1260 : 0 : delegation = rcu_dereference(nfsi->delegation);
1261 [ # # ]: 0 : if (!can_open_delegated(delegation, fmode)) {
1262 : : rcu_read_unlock();
1263 : : break;
1264 : : }
1265 : : /* Save the delegation */
1266 : : nfs4_stateid_copy(&stateid, &delegation->stateid);
1267 : : rcu_read_unlock();
1268 : 0 : nfs_release_seqid(opendata->o_arg.seqid);
1269 [ # # ]: 0 : if (!opendata->is_recover) {
1270 : 0 : ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode);
1271 [ # # ]: 0 : if (ret != 0)
1272 : : goto out;
1273 : : }
1274 : : ret = -EAGAIN;
1275 : :
1276 : : /* Try to update the stateid using the delegation */
1277 [ # # ]: 0 : if (update_open_stateid(state, NULL, &stateid, fmode))
1278 : : goto out_return_state;
1279 : : }
1280 : : out:
1281 : 0 : return ERR_PTR(ret);
1282 : : out_return_state:
1283 : 0 : atomic_inc(&state->count);
1284 : 0 : return state;
1285 : : }
1286 : :
1287 : : static void
1288 : 0 : nfs4_opendata_check_deleg(struct nfs4_opendata *data, struct nfs4_state *state)
1289 : : {
1290 : 0 : struct nfs_client *clp = NFS_SERVER(state->inode)->nfs_client;
1291 : : struct nfs_delegation *delegation;
1292 : : int delegation_flags = 0;
1293 : :
1294 : : rcu_read_lock();
1295 : 0 : delegation = rcu_dereference(NFS_I(state->inode)->delegation);
1296 [ # # ]: 0 : if (delegation)
1297 : 0 : delegation_flags = delegation->flags;
1298 : : rcu_read_unlock();
1299 [ # # ]: 0 : if (data->o_arg.claim == NFS4_OPEN_CLAIM_DELEGATE_CUR) {
1300 [ # # ]: 0 : pr_err_ratelimited("NFS: Broken NFSv4 server %s is "
1301 : : "returning a delegation for "
1302 : : "OPEN(CLAIM_DELEGATE_CUR)\n",
1303 : : clp->cl_hostname);
1304 [ # # ]: 0 : } else if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0)
1305 : 0 : nfs_inode_set_delegation(state->inode,
1306 : 0 : data->owner->so_cred,
1307 : : &data->o_res);
1308 : : else
1309 : 0 : nfs_inode_reclaim_delegation(state->inode,
1310 : 0 : data->owner->so_cred,
1311 : : &data->o_res);
1312 : 0 : }
1313 : :
1314 : : /*
1315 : : * Check the inode attributes against the CLAIM_PREVIOUS returned attributes
1316 : : * and update the nfs4_state.
1317 : : */
1318 : : static struct nfs4_state *
1319 : 0 : _nfs4_opendata_reclaim_to_nfs4_state(struct nfs4_opendata *data)
1320 : : {
1321 : 0 : struct inode *inode = data->state->inode;
1322 : : struct nfs4_state *state = data->state;
1323 : : int ret;
1324 : :
1325 [ # # ]: 0 : if (!data->rpc_done) {
1326 [ # # ]: 0 : if (data->rpc_status) {
1327 : : ret = data->rpc_status;
1328 : : goto err;
1329 : : }
1330 : : /* cached opens have already been processed */
1331 : : goto update;
1332 : : }
1333 : :
1334 : 0 : ret = nfs_refresh_inode(inode, &data->f_attr);
1335 [ # # ]: 0 : if (ret)
1336 : : goto err;
1337 : :
1338 [ # # ]: 0 : if (data->o_res.delegation_type != 0)
1339 : 0 : nfs4_opendata_check_deleg(data, state);
1340 : : update:
1341 : 0 : update_open_stateid(state, &data->o_res.stateid, NULL,
1342 : : data->o_arg.fmode);
1343 : 0 : atomic_inc(&state->count);
1344 : :
1345 : 0 : return state;
1346 : : err:
1347 : 0 : return ERR_PTR(ret);
1348 : :
1349 : : }
1350 : :
1351 : : static struct nfs4_state *
1352 : 0 : _nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
1353 : : {
1354 : : struct inode *inode;
1355 : : struct nfs4_state *state = NULL;
1356 : : int ret;
1357 : :
1358 [ # # ]: 0 : if (!data->rpc_done) {
1359 : 0 : state = nfs4_try_open_cached(data);
1360 : 0 : goto out;
1361 : : }
1362 : :
1363 : : ret = -EAGAIN;
1364 [ # # ]: 0 : if (!(data->f_attr.valid & NFS_ATTR_FATTR))
1365 : : goto err;
1366 : 0 : inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr, data->f_label);
1367 : : ret = PTR_ERR(inode);
1368 [ # # ]: 0 : if (IS_ERR(inode))
1369 : : goto err;
1370 : : ret = -ENOMEM;
1371 : 0 : state = nfs4_get_open_state(inode, data->owner);
1372 [ # # ]: 0 : if (state == NULL)
1373 : : goto err_put_inode;
1374 [ # # ]: 0 : if (data->o_res.delegation_type != 0)
1375 : 0 : nfs4_opendata_check_deleg(data, state);
1376 : 0 : update_open_stateid(state, &data->o_res.stateid, NULL,
1377 : : data->o_arg.fmode);
1378 : 0 : iput(inode);
1379 : : out:
1380 : 0 : nfs_release_seqid(data->o_arg.seqid);
1381 : 0 : return state;
1382 : : err_put_inode:
1383 : 0 : iput(inode);
1384 : : err:
1385 : 0 : return ERR_PTR(ret);
1386 : : }
1387 : :
1388 : : static struct nfs4_state *
1389 : 0 : nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
1390 : : {
1391 [ # # ]: 0 : if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS)
1392 : 0 : return _nfs4_opendata_reclaim_to_nfs4_state(data);
1393 : 0 : return _nfs4_opendata_to_nfs4_state(data);
1394 : : }
1395 : :
1396 : 0 : static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *state)
1397 : : {
1398 : 0 : struct nfs_inode *nfsi = NFS_I(state->inode);
1399 : : struct nfs_open_context *ctx;
1400 : :
1401 : : spin_lock(&state->inode->i_lock);
1402 [ # # ]: 0 : list_for_each_entry(ctx, &nfsi->open_files, list) {
1403 [ # # ]: 0 : if (ctx->state != state)
1404 : 0 : continue;
1405 : 0 : get_nfs_open_context(ctx);
1406 : 0 : spin_unlock(&state->inode->i_lock);
1407 : 0 : return ctx;
1408 : : }
1409 : 0 : spin_unlock(&state->inode->i_lock);
1410 : 0 : return ERR_PTR(-ENOENT);
1411 : : }
1412 : :
1413 : 0 : static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context *ctx,
1414 : : struct nfs4_state *state, enum open_claim_type4 claim)
1415 : : {
1416 : : struct nfs4_opendata *opendata;
1417 : :
1418 : 0 : opendata = nfs4_opendata_alloc(ctx->dentry, state->owner, 0, 0,
1419 : : NULL, NULL, claim, GFP_NOFS);
1420 [ # # ]: 0 : if (opendata == NULL)
1421 : : return ERR_PTR(-ENOMEM);
1422 : 0 : opendata->state = state;
1423 : 0 : atomic_inc(&state->count);
1424 : : return opendata;
1425 : : }
1426 : :
1427 : 0 : static int nfs4_open_recover_helper(struct nfs4_opendata *opendata, fmode_t fmode, struct nfs4_state **res)
1428 : : {
1429 : : struct nfs4_state *newstate;
1430 : : int ret;
1431 : :
1432 : 0 : opendata->o_arg.open_flags = 0;
1433 : 0 : opendata->o_arg.fmode = fmode;
1434 : 0 : memset(&opendata->o_res, 0, sizeof(opendata->o_res));
1435 : 0 : memset(&opendata->c_res, 0, sizeof(opendata->c_res));
1436 : 0 : nfs4_init_opendata_res(opendata);
1437 : 0 : ret = _nfs4_recover_proc_open(opendata);
1438 [ # # ]: 0 : if (ret != 0)
1439 : : return ret;
1440 : 0 : newstate = nfs4_opendata_to_nfs4_state(opendata);
1441 [ # # ]: 0 : if (IS_ERR(newstate))
1442 : 0 : return PTR_ERR(newstate);
1443 : 0 : nfs4_close_state(newstate, fmode);
1444 : 0 : *res = newstate;
1445 : 0 : return 0;
1446 : : }
1447 : :
1448 : 0 : static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *state)
1449 : : {
1450 : : struct nfs4_state *newstate;
1451 : : int ret;
1452 : :
1453 : : /* memory barrier prior to reading state->n_* */
1454 : 0 : clear_bit(NFS_DELEGATED_STATE, &state->flags);
1455 : 0 : clear_bit(NFS_OPEN_STATE, &state->flags);
1456 : 0 : smp_rmb();
1457 [ # # ]: 0 : if (state->n_rdwr != 0) {
1458 : 0 : clear_bit(NFS_O_RDWR_STATE, &state->flags);
1459 : 0 : ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE, &newstate);
1460 [ # # ]: 0 : if (ret != 0)
1461 : : return ret;
1462 [ # # ]: 0 : if (newstate != state)
1463 : : return -ESTALE;
1464 : : }
1465 [ # # ]: 0 : if (state->n_wronly != 0) {
1466 : 0 : clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1467 : 0 : ret = nfs4_open_recover_helper(opendata, FMODE_WRITE, &newstate);
1468 [ # # ]: 0 : if (ret != 0)
1469 : : return ret;
1470 [ # # ]: 0 : if (newstate != state)
1471 : : return -ESTALE;
1472 : : }
1473 [ # # ]: 0 : if (state->n_rdonly != 0) {
1474 : 0 : clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1475 : 0 : ret = nfs4_open_recover_helper(opendata, FMODE_READ, &newstate);
1476 [ # # ]: 0 : if (ret != 0)
1477 : : return ret;
1478 [ # # ]: 0 : if (newstate != state)
1479 : : return -ESTALE;
1480 : : }
1481 : : /*
1482 : : * We may have performed cached opens for all three recoveries.
1483 : : * Check if we need to update the current stateid.
1484 : : */
1485 [ # # ][ # # ]: 0 : if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 &&
1486 : 0 : !nfs4_stateid_match(&state->stateid, &state->open_stateid)) {
1487 : : write_seqlock(&state->seqlock);
1488 [ # # ]: 0 : if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
1489 : : nfs4_stateid_copy(&state->stateid, &state->open_stateid);
1490 : : write_sequnlock(&state->seqlock);
1491 : : }
1492 : : return 0;
1493 : : }
1494 : :
1495 : : /*
1496 : : * OPEN_RECLAIM:
1497 : : * reclaim state on the server after a reboot.
1498 : : */
1499 : 0 : static int _nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
1500 : : {
1501 : : struct nfs_delegation *delegation;
1502 : : struct nfs4_opendata *opendata;
1503 : : fmode_t delegation_type = 0;
1504 : : int status;
1505 : :
1506 : 0 : opendata = nfs4_open_recoverdata_alloc(ctx, state,
1507 : : NFS4_OPEN_CLAIM_PREVIOUS);
1508 [ # # ]: 0 : if (IS_ERR(opendata))
1509 : 0 : return PTR_ERR(opendata);
1510 : : rcu_read_lock();
1511 : 0 : delegation = rcu_dereference(NFS_I(state->inode)->delegation);
1512 [ # # ][ # # ]: 0 : if (delegation != NULL && test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) != 0)
1513 : 0 : delegation_type = delegation->type;
1514 : : rcu_read_unlock();
1515 : 0 : opendata->o_arg.u.delegation_type = delegation_type;
1516 : 0 : status = nfs4_open_recover(opendata, state);
1517 : 0 : nfs4_opendata_put(opendata);
1518 : 0 : return status;
1519 : : }
1520 : :
1521 : 0 : static int nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
1522 : : {
1523 : 0 : struct nfs_server *server = NFS_SERVER(state->inode);
1524 : 0 : struct nfs4_exception exception = { };
1525 : : int err;
1526 : : do {
1527 : 0 : err = _nfs4_do_open_reclaim(ctx, state);
1528 : : trace_nfs4_open_reclaim(ctx, 0, err);
1529 [ # # ]: 0 : if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))
1530 : 0 : continue;
1531 [ # # ]: 0 : if (err != -NFS4ERR_DELAY)
1532 : : break;
1533 : 0 : nfs4_handle_exception(server, err, &exception);
1534 [ # # ]: 0 : } while (exception.retry);
1535 : 0 : return err;
1536 : : }
1537 : :
1538 : 0 : static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state)
1539 : : {
1540 : : struct nfs_open_context *ctx;
1541 : : int ret;
1542 : :
1543 : 0 : ctx = nfs4_state_find_open_context(state);
1544 [ # # ]: 0 : if (IS_ERR(ctx))
1545 : : return -EAGAIN;
1546 : 0 : ret = nfs4_do_open_reclaim(ctx, state);
1547 : 0 : put_nfs_open_context(ctx);
1548 : 0 : return ret;
1549 : : }
1550 : :
1551 : 0 : static int nfs4_handle_delegation_recall_error(struct nfs_server *server, struct nfs4_state *state, const nfs4_stateid *stateid, int err)
1552 : : {
1553 [ # # # # : 0 : switch (err) {
# # # # #
# ]
1554 : : default:
1555 : 0 : printk(KERN_ERR "NFS: %s: unhandled error "
1556 : : "%d.\n", __func__, err);
1557 : : case 0:
1558 : : case -ENOENT:
1559 : : case -ESTALE:
1560 : : break;
1561 : : case -NFS4ERR_BADSESSION:
1562 : : case -NFS4ERR_BADSLOT:
1563 : : case -NFS4ERR_BAD_HIGH_SLOT:
1564 : : case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1565 : : case -NFS4ERR_DEADSESSION:
1566 : 0 : set_bit(NFS_DELEGATED_STATE, &state->flags);
1567 : : nfs4_schedule_session_recovery(server->nfs_client->cl_session, err);
1568 : 0 : return -EAGAIN;
1569 : : case -NFS4ERR_STALE_CLIENTID:
1570 : : case -NFS4ERR_STALE_STATEID:
1571 : 0 : set_bit(NFS_DELEGATED_STATE, &state->flags);
1572 : : case -NFS4ERR_EXPIRED:
1573 : : /* Don't recall a delegation if it was lost */
1574 : 0 : nfs4_schedule_lease_recovery(server->nfs_client);
1575 : 0 : return -EAGAIN;
1576 : : case -NFS4ERR_MOVED:
1577 : 0 : nfs4_schedule_migration_recovery(server);
1578 : 0 : return -EAGAIN;
1579 : : case -NFS4ERR_LEASE_MOVED:
1580 : 0 : nfs4_schedule_lease_moved_recovery(server->nfs_client);
1581 : 0 : return -EAGAIN;
1582 : : case -NFS4ERR_DELEG_REVOKED:
1583 : : case -NFS4ERR_ADMIN_REVOKED:
1584 : : case -NFS4ERR_BAD_STATEID:
1585 : : case -NFS4ERR_OPENMODE:
1586 : 0 : nfs_inode_find_state_and_recover(state->inode,
1587 : : stateid);
1588 : 0 : nfs4_schedule_stateid_recovery(server, state);
1589 : 0 : return 0;
1590 : : case -NFS4ERR_DELAY:
1591 : : case -NFS4ERR_GRACE:
1592 : 0 : set_bit(NFS_DELEGATED_STATE, &state->flags);
1593 : : ssleep(1);
1594 : 0 : return -EAGAIN;
1595 : : case -ENOMEM:
1596 : : case -NFS4ERR_DENIED:
1597 : : /* kill_proc(fl->fl_pid, SIGLOST, 1); */
1598 : : return 0;
1599 : : }
1600 : 0 : return err;
1601 : : }
1602 : :
1603 : 0 : int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)
1604 : : {
1605 : 0 : struct nfs_server *server = NFS_SERVER(state->inode);
1606 : : struct nfs4_opendata *opendata;
1607 : : int err;
1608 : :
1609 : 0 : opendata = nfs4_open_recoverdata_alloc(ctx, state,
1610 : : NFS4_OPEN_CLAIM_DELEG_CUR_FH);
1611 [ # # ]: 0 : if (IS_ERR(opendata))
1612 : 0 : return PTR_ERR(opendata);
1613 : 0 : nfs4_stateid_copy(&opendata->o_arg.u.delegation, stateid);
1614 : 0 : err = nfs4_open_recover(opendata, state);
1615 : 0 : nfs4_opendata_put(opendata);
1616 : 0 : return nfs4_handle_delegation_recall_error(server, state, stateid, err);
1617 : : }
1618 : :
1619 : 0 : static void nfs4_open_confirm_prepare(struct rpc_task *task, void *calldata)
1620 : : {
1621 : : struct nfs4_opendata *data = calldata;
1622 : :
1623 : 0 : nfs40_setup_sequence(data->o_arg.server, &data->c_arg.seq_args,
1624 : : &data->c_res.seq_res, task);
1625 : 0 : }
1626 : :
1627 : 0 : static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata)
1628 : : {
1629 : : struct nfs4_opendata *data = calldata;
1630 : :
1631 : 0 : nfs40_sequence_done(task, &data->c_res.seq_res);
1632 : :
1633 : 0 : data->rpc_status = task->tk_status;
1634 [ # # ]: 0 : if (data->rpc_status == 0) {
1635 : 0 : nfs4_stateid_copy(&data->o_res.stateid, &data->c_res.stateid);
1636 : 0 : nfs_confirm_seqid(&data->owner->so_seqid, 0);
1637 : 0 : renew_lease(data->o_res.server, data->timestamp);
1638 : 0 : data->rpc_done = 1;
1639 : : }
1640 : 0 : }
1641 : :
1642 : 0 : static void nfs4_open_confirm_release(void *calldata)
1643 : : {
1644 : : struct nfs4_opendata *data = calldata;
1645 : : struct nfs4_state *state = NULL;
1646 : :
1647 : : /* If this request hasn't been cancelled, do nothing */
1648 [ # # ]: 0 : if (data->cancelled == 0)
1649 : : goto out_free;
1650 : : /* In case of error, no cleanup! */
1651 [ # # ]: 0 : if (!data->rpc_done)
1652 : : goto out_free;
1653 : 0 : state = nfs4_opendata_to_nfs4_state(data);
1654 [ # # ]: 0 : if (!IS_ERR(state))
1655 : 0 : nfs4_close_state(state, data->o_arg.fmode);
1656 : : out_free:
1657 : 0 : nfs4_opendata_put(data);
1658 : 0 : }
1659 : :
1660 : : static const struct rpc_call_ops nfs4_open_confirm_ops = {
1661 : : .rpc_call_prepare = nfs4_open_confirm_prepare,
1662 : : .rpc_call_done = nfs4_open_confirm_done,
1663 : : .rpc_release = nfs4_open_confirm_release,
1664 : : };
1665 : :
1666 : : /*
1667 : : * Note: On error, nfs4_proc_open_confirm will free the struct nfs4_opendata
1668 : : */
1669 : 0 : static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)
1670 : : {
1671 : 0 : struct nfs_server *server = NFS_SERVER(data->dir->d_inode);
1672 : : struct rpc_task *task;
1673 : 0 : struct rpc_message msg = {
1674 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM],
1675 : 0 : .rpc_argp = &data->c_arg,
1676 : 0 : .rpc_resp = &data->c_res,
1677 : 0 : .rpc_cred = data->owner->so_cred,
1678 : : };
1679 : 0 : struct rpc_task_setup task_setup_data = {
1680 : 0 : .rpc_client = server->client,
1681 : : .rpc_message = &msg,
1682 : : .callback_ops = &nfs4_open_confirm_ops,
1683 : : .callback_data = data,
1684 : : .workqueue = nfsiod_workqueue,
1685 : : .flags = RPC_TASK_ASYNC,
1686 : : };
1687 : : int status;
1688 : :
1689 : : nfs4_init_sequence(&data->c_arg.seq_args, &data->c_res.seq_res, 1);
1690 : : kref_get(&data->kref);
1691 : 0 : data->rpc_done = 0;
1692 : 0 : data->rpc_status = 0;
1693 : 0 : data->timestamp = jiffies;
1694 : 0 : task = rpc_run_task(&task_setup_data);
1695 [ # # ]: 0 : if (IS_ERR(task))
1696 : 0 : return PTR_ERR(task);
1697 : : status = nfs4_wait_for_completion_rpc_task(task);
1698 [ # # ]: 0 : if (status != 0) {
1699 : 0 : data->cancelled = 1;
1700 : 0 : smp_wmb();
1701 : : } else
1702 : 0 : status = data->rpc_status;
1703 : 0 : rpc_put_task(task);
1704 : 0 : return status;
1705 : : }
1706 : :
1707 : 0 : static void nfs4_open_prepare(struct rpc_task *task, void *calldata)
1708 : : {
1709 : : struct nfs4_opendata *data = calldata;
1710 : 0 : struct nfs4_state_owner *sp = data->owner;
1711 : 0 : struct nfs_client *clp = sp->so_server->nfs_client;
1712 : :
1713 [ # # ]: 0 : if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0)
1714 : : goto out_wait;
1715 : : /*
1716 : : * Check if we still need to send an OPEN call, or if we can use
1717 : : * a delegation instead.
1718 : : */
1719 [ # # ]: 0 : if (data->state != NULL) {
1720 : : struct nfs_delegation *delegation;
1721 : :
1722 [ # # ]: 0 : if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags))
1723 : : goto out_no_action;
1724 : : rcu_read_lock();
1725 : 0 : delegation = rcu_dereference(NFS_I(data->state->inode)->delegation);
1726 [ # # ]: 0 : if (data->o_arg.claim != NFS4_OPEN_CLAIM_DELEGATE_CUR &&
1727 [ # # ]: 0 : data->o_arg.claim != NFS4_OPEN_CLAIM_DELEG_CUR_FH &&
1728 : 0 : can_open_delegated(delegation, data->o_arg.fmode))
1729 : : goto unlock_no_action;
1730 : : rcu_read_unlock();
1731 : : }
1732 : : /* Update client id. */
1733 : 0 : data->o_arg.clientid = clp->cl_clientid;
1734 [ # # # ]: 0 : switch (data->o_arg.claim) {
1735 : : case NFS4_OPEN_CLAIM_PREVIOUS:
1736 : : case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
1737 : : case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
1738 : 0 : data->o_arg.open_bitmap = &nfs4_open_noattr_bitmap[0];
1739 : : case NFS4_OPEN_CLAIM_FH:
1740 : 0 : task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR];
1741 : 0 : nfs_copy_fh(&data->o_res.fh, data->o_arg.fh);
1742 : : }
1743 : 0 : data->timestamp = jiffies;
1744 [ # # ]: 0 : if (nfs4_setup_sequence(data->o_arg.server,
1745 : : &data->o_arg.seq_args,
1746 : : &data->o_res.seq_res,
1747 : : task) != 0)
1748 : 0 : nfs_release_seqid(data->o_arg.seqid);
1749 : :
1750 : : /* Set the create mode (note dependency on the session type) */
1751 : 0 : data->o_arg.createmode = NFS4_CREATE_UNCHECKED;
1752 [ # # ]: 0 : if (data->o_arg.open_flags & O_EXCL) {
1753 : 0 : data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE;
1754 : : if (nfs4_has_persistent_session(clp))
1755 : : data->o_arg.createmode = NFS4_CREATE_GUARDED;
1756 [ # # ]: 0 : else if (clp->cl_mvops->minor_version > 0)
1757 : 0 : data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE4_1;
1758 : : }
1759 : 0 : return;
1760 : : unlock_no_action:
1761 : : rcu_read_unlock();
1762 : : out_no_action:
1763 : 0 : task->tk_action = NULL;
1764 : : out_wait:
1765 : 0 : nfs4_sequence_done(task, &data->o_res.seq_res);
1766 : : }
1767 : :
1768 : 0 : static void nfs4_open_done(struct rpc_task *task, void *calldata)
1769 : : {
1770 : : struct nfs4_opendata *data = calldata;
1771 : :
1772 : 0 : data->rpc_status = task->tk_status;
1773 : :
1774 [ # # ]: 0 : if (!nfs4_sequence_done(task, &data->o_res.seq_res))
1775 : 0 : return;
1776 : :
1777 [ # # ]: 0 : if (task->tk_status == 0) {
1778 [ # # ]: 0 : if (data->o_res.f_attr->valid & NFS_ATTR_FATTR_TYPE) {
1779 [ # # # # ]: 0 : switch (data->o_res.f_attr->mode & S_IFMT) {
1780 : : case S_IFREG:
1781 : : break;
1782 : : case S_IFLNK:
1783 : 0 : data->rpc_status = -ELOOP;
1784 : 0 : break;
1785 : : case S_IFDIR:
1786 : 0 : data->rpc_status = -EISDIR;
1787 : 0 : break;
1788 : : default:
1789 : 0 : data->rpc_status = -ENOTDIR;
1790 : : }
1791 : : }
1792 : 0 : renew_lease(data->o_res.server, data->timestamp);
1793 [ # # ]: 0 : if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM))
1794 : 0 : nfs_confirm_seqid(&data->owner->so_seqid, 0);
1795 : : }
1796 : 0 : data->rpc_done = 1;
1797 : : }
1798 : :
1799 : 0 : static void nfs4_open_release(void *calldata)
1800 : : {
1801 : : struct nfs4_opendata *data = calldata;
1802 : : struct nfs4_state *state = NULL;
1803 : :
1804 : : /* If this request hasn't been cancelled, do nothing */
1805 [ # # ]: 0 : if (data->cancelled == 0)
1806 : : goto out_free;
1807 : : /* In case of error, no cleanup! */
1808 [ # # ][ # # ]: 0 : if (data->rpc_status != 0 || !data->rpc_done)
1809 : : goto out_free;
1810 : : /* In case we need an open_confirm, no cleanup! */
1811 [ # # ]: 0 : if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)
1812 : : goto out_free;
1813 : 0 : state = nfs4_opendata_to_nfs4_state(data);
1814 [ # # ]: 0 : if (!IS_ERR(state))
1815 : 0 : nfs4_close_state(state, data->o_arg.fmode);
1816 : : out_free:
1817 : 0 : nfs4_opendata_put(data);
1818 : 0 : }
1819 : :
1820 : : static const struct rpc_call_ops nfs4_open_ops = {
1821 : : .rpc_call_prepare = nfs4_open_prepare,
1822 : : .rpc_call_done = nfs4_open_done,
1823 : : .rpc_release = nfs4_open_release,
1824 : : };
1825 : :
1826 : 0 : static int nfs4_run_open_task(struct nfs4_opendata *data, int isrecover)
1827 : : {
1828 : 0 : struct inode *dir = data->dir->d_inode;
1829 : : struct nfs_server *server = NFS_SERVER(dir);
1830 : 0 : struct nfs_openargs *o_arg = &data->o_arg;
1831 : 0 : struct nfs_openres *o_res = &data->o_res;
1832 : : struct rpc_task *task;
1833 : 0 : struct rpc_message msg = {
1834 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN],
1835 : : .rpc_argp = o_arg,
1836 : : .rpc_resp = o_res,
1837 : 0 : .rpc_cred = data->owner->so_cred,
1838 : : };
1839 : 0 : struct rpc_task_setup task_setup_data = {
1840 : 0 : .rpc_client = server->client,
1841 : : .rpc_message = &msg,
1842 : : .callback_ops = &nfs4_open_ops,
1843 : : .callback_data = data,
1844 : : .workqueue = nfsiod_workqueue,
1845 : : .flags = RPC_TASK_ASYNC,
1846 : : };
1847 : : int status;
1848 : :
1849 : : nfs4_init_sequence(&o_arg->seq_args, &o_res->seq_res, 1);
1850 : : kref_get(&data->kref);
1851 : 0 : data->rpc_done = 0;
1852 : 0 : data->rpc_status = 0;
1853 : 0 : data->cancelled = 0;
1854 : 0 : data->is_recover = 0;
1855 [ # # ]: 0 : if (isrecover) {
1856 : : nfs4_set_sequence_privileged(&o_arg->seq_args);
1857 : 0 : data->is_recover = 1;
1858 : : }
1859 : 0 : task = rpc_run_task(&task_setup_data);
1860 [ # # ]: 0 : if (IS_ERR(task))
1861 : 0 : return PTR_ERR(task);
1862 : : status = nfs4_wait_for_completion_rpc_task(task);
1863 [ # # ]: 0 : if (status != 0) {
1864 : 0 : data->cancelled = 1;
1865 : 0 : smp_wmb();
1866 : : } else
1867 : 0 : status = data->rpc_status;
1868 : 0 : rpc_put_task(task);
1869 : :
1870 : 0 : return status;
1871 : : }
1872 : :
1873 : 0 : static int _nfs4_recover_proc_open(struct nfs4_opendata *data)
1874 : : {
1875 : 0 : struct inode *dir = data->dir->d_inode;
1876 : : struct nfs_openres *o_res = &data->o_res;
1877 : : int status;
1878 : :
1879 : 0 : status = nfs4_run_open_task(data, 1);
1880 [ # # ][ # # ]: 0 : if (status != 0 || !data->rpc_done)
1881 : : return status;
1882 : :
1883 : 0 : nfs_fattr_map_and_free_names(NFS_SERVER(dir), &data->f_attr);
1884 : :
1885 [ # # ]: 0 : if (o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {
1886 : 0 : status = _nfs4_proc_open_confirm(data);
1887 [ # # ]: 0 : if (status != 0)
1888 : : return status;
1889 : : }
1890 : :
1891 : 0 : return status;
1892 : : }
1893 : :
1894 : 0 : static int nfs4_opendata_access(struct rpc_cred *cred,
1895 : : struct nfs4_opendata *opendata,
1896 : : struct nfs4_state *state, fmode_t fmode,
1897 : : int openflags)
1898 : : {
1899 : : struct nfs_access_entry cache;
1900 : : u32 mask;
1901 : :
1902 : : /* access call failed or for some reason the server doesn't
1903 : : * support any access modes -- defer access call until later */
1904 [ # # ]: 0 : if (opendata->o_res.access_supported == 0)
1905 : : return 0;
1906 : :
1907 : : mask = 0;
1908 : : /* don't check MAY_WRITE - a newly created file may not have
1909 : : * write mode bits, but POSIX allows the creating process to write.
1910 : : * use openflags to check for exec, because fmode won't
1911 : : * always have FMODE_EXEC set when file open for exec. */
1912 [ # # ]: 0 : if (openflags & __FMODE_EXEC) {
1913 : : /* ONLY check for exec rights */
1914 : : mask = MAY_EXEC;
1915 [ # # ]: 0 : } else if (fmode & FMODE_READ)
1916 : : mask = MAY_READ;
1917 : :
1918 : 0 : cache.cred = cred;
1919 : 0 : cache.jiffies = jiffies;
1920 : 0 : nfs_access_set_mask(&cache, opendata->o_res.access_result);
1921 : 0 : nfs_access_add_cache(state->inode, &cache);
1922 : :
1923 [ # # ]: 0 : if ((mask & ~cache.mask & (MAY_READ | MAY_EXEC)) == 0)
1924 : : return 0;
1925 : :
1926 : : /* even though OPEN succeeded, access is denied. Close the file */
1927 : 0 : nfs4_close_state(state, fmode);
1928 : : return -EACCES;
1929 : : }
1930 : :
1931 : : /*
1932 : : * Note: On error, nfs4_proc_open will free the struct nfs4_opendata
1933 : : */
1934 : 0 : static int _nfs4_proc_open(struct nfs4_opendata *data)
1935 : : {
1936 : 0 : struct inode *dir = data->dir->d_inode;
1937 : : struct nfs_server *server = NFS_SERVER(dir);
1938 : : struct nfs_openargs *o_arg = &data->o_arg;
1939 : : struct nfs_openres *o_res = &data->o_res;
1940 : : int status;
1941 : :
1942 : 0 : status = nfs4_run_open_task(data, 0);
1943 [ # # ]: 0 : if (!data->rpc_done)
1944 : : return status;
1945 [ # # ]: 0 : if (status != 0) {
1946 [ # # ][ # # ]: 0 : if (status == -NFS4ERR_BADNAME &&
1947 : 0 : !(o_arg->open_flags & O_CREAT))
1948 : : return -ENOENT;
1949 : 0 : return status;
1950 : : }
1951 : :
1952 : 0 : nfs_fattr_map_and_free_names(server, &data->f_attr);
1953 : :
1954 [ # # ]: 0 : if (o_arg->open_flags & O_CREAT) {
1955 : 0 : update_changeattr(dir, &o_res->cinfo);
1956 [ # # ]: 0 : if (o_arg->open_flags & O_EXCL)
1957 : 0 : data->file_created = 1;
1958 [ # # ]: 0 : else if (o_res->cinfo.before != o_res->cinfo.after)
1959 : 0 : data->file_created = 1;
1960 : : }
1961 [ # # ]: 0 : if ((o_res->rflags & NFS4_OPEN_RESULT_LOCKTYPE_POSIX) == 0)
1962 : 0 : server->caps &= ~NFS_CAP_POSIX_LOCK;
1963 [ # # ]: 0 : if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {
1964 : 0 : status = _nfs4_proc_open_confirm(data);
1965 [ # # ]: 0 : if (status != 0)
1966 : : return status;
1967 : : }
1968 [ # # ]: 0 : if (!(o_res->f_attr->valid & NFS_ATTR_FATTR))
1969 : 0 : _nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr, o_res->f_label);
1970 : : return 0;
1971 : : }
1972 : :
1973 : : static int nfs4_recover_expired_lease(struct nfs_server *server)
1974 : : {
1975 : 0 : return nfs4_client_recover_expired_lease(server->nfs_client);
1976 : : }
1977 : :
1978 : : /*
1979 : : * OPEN_EXPIRED:
1980 : : * reclaim state on the server after a network partition.
1981 : : * Assumes caller holds the appropriate lock
1982 : : */
1983 : 0 : static int _nfs4_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
1984 : : {
1985 : : struct nfs4_opendata *opendata;
1986 : : int ret;
1987 : :
1988 : 0 : opendata = nfs4_open_recoverdata_alloc(ctx, state,
1989 : : NFS4_OPEN_CLAIM_FH);
1990 [ # # ]: 0 : if (IS_ERR(opendata))
1991 : 0 : return PTR_ERR(opendata);
1992 : 0 : ret = nfs4_open_recover(opendata, state);
1993 [ # # ]: 0 : if (ret == -ESTALE)
1994 : 0 : d_drop(ctx->dentry);
1995 : 0 : nfs4_opendata_put(opendata);
1996 : 0 : return ret;
1997 : : }
1998 : :
1999 : 0 : static int nfs4_do_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
2000 : : {
2001 : 0 : struct nfs_server *server = NFS_SERVER(state->inode);
2002 : 0 : struct nfs4_exception exception = { };
2003 : : int err;
2004 : :
2005 : : do {
2006 : 0 : err = _nfs4_open_expired(ctx, state);
2007 : : trace_nfs4_open_expired(ctx, 0, err);
2008 [ # # ]: 0 : if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))
2009 : 0 : continue;
2010 [ # # ]: 0 : switch (err) {
2011 : : default:
2012 : : goto out;
2013 : : case -NFS4ERR_GRACE:
2014 : : case -NFS4ERR_DELAY:
2015 : 0 : nfs4_handle_exception(server, err, &exception);
2016 : : err = 0;
2017 : : }
2018 [ # # ]: 0 : } while (exception.retry);
2019 : : out:
2020 : 0 : return err;
2021 : : }
2022 : :
2023 : 0 : static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
2024 : : {
2025 : : struct nfs_open_context *ctx;
2026 : : int ret;
2027 : :
2028 : 0 : ctx = nfs4_state_find_open_context(state);
2029 [ # # ]: 0 : if (IS_ERR(ctx))
2030 : : return -EAGAIN;
2031 : 0 : ret = nfs4_do_open_expired(ctx, state);
2032 : 0 : put_nfs_open_context(ctx);
2033 : 0 : return ret;
2034 : : }
2035 : :
2036 : : #if defined(CONFIG_NFS_V4_1)
2037 : : static void nfs41_clear_delegation_stateid(struct nfs4_state *state)
2038 : : {
2039 : : struct nfs_server *server = NFS_SERVER(state->inode);
2040 : : nfs4_stateid *stateid = &state->stateid;
2041 : : struct nfs_delegation *delegation;
2042 : : struct rpc_cred *cred = NULL;
2043 : : int status = -NFS4ERR_BAD_STATEID;
2044 : :
2045 : : /* If a state reset has been done, test_stateid is unneeded */
2046 : : if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
2047 : : return;
2048 : :
2049 : : /* Get the delegation credential for use by test/free_stateid */
2050 : : rcu_read_lock();
2051 : : delegation = rcu_dereference(NFS_I(state->inode)->delegation);
2052 : : if (delegation != NULL &&
2053 : : nfs4_stateid_match(&delegation->stateid, stateid)) {
2054 : : cred = get_rpccred(delegation->cred);
2055 : : rcu_read_unlock();
2056 : : status = nfs41_test_stateid(server, stateid, cred);
2057 : : trace_nfs4_test_delegation_stateid(state, NULL, status);
2058 : : } else
2059 : : rcu_read_unlock();
2060 : :
2061 : : if (status != NFS_OK) {
2062 : : /* Free the stateid unless the server explicitly
2063 : : * informs us the stateid is unrecognized. */
2064 : : if (status != -NFS4ERR_BAD_STATEID)
2065 : : nfs41_free_stateid(server, stateid, cred);
2066 : : nfs_remove_bad_delegation(state->inode);
2067 : :
2068 : : write_seqlock(&state->seqlock);
2069 : : nfs4_stateid_copy(&state->stateid, &state->open_stateid);
2070 : : write_sequnlock(&state->seqlock);
2071 : : clear_bit(NFS_DELEGATED_STATE, &state->flags);
2072 : : }
2073 : :
2074 : : if (cred != NULL)
2075 : : put_rpccred(cred);
2076 : : }
2077 : :
2078 : : /**
2079 : : * nfs41_check_open_stateid - possibly free an open stateid
2080 : : *
2081 : : * @state: NFSv4 state for an inode
2082 : : *
2083 : : * Returns NFS_OK if recovery for this stateid is now finished.
2084 : : * Otherwise a negative NFS4ERR value is returned.
2085 : : */
2086 : : static int nfs41_check_open_stateid(struct nfs4_state *state)
2087 : : {
2088 : : struct nfs_server *server = NFS_SERVER(state->inode);
2089 : : nfs4_stateid *stateid = &state->open_stateid;
2090 : : struct rpc_cred *cred = state->owner->so_cred;
2091 : : int status;
2092 : :
2093 : : /* If a state reset has been done, test_stateid is unneeded */
2094 : : if ((test_bit(NFS_O_RDONLY_STATE, &state->flags) == 0) &&
2095 : : (test_bit(NFS_O_WRONLY_STATE, &state->flags) == 0) &&
2096 : : (test_bit(NFS_O_RDWR_STATE, &state->flags) == 0))
2097 : : return -NFS4ERR_BAD_STATEID;
2098 : :
2099 : : status = nfs41_test_stateid(server, stateid, cred);
2100 : : trace_nfs4_test_open_stateid(state, NULL, status);
2101 : : if (status != NFS_OK) {
2102 : : /* Free the stateid unless the server explicitly
2103 : : * informs us the stateid is unrecognized. */
2104 : : if (status != -NFS4ERR_BAD_STATEID)
2105 : : nfs41_free_stateid(server, stateid, cred);
2106 : :
2107 : : clear_bit(NFS_O_RDONLY_STATE, &state->flags);
2108 : : clear_bit(NFS_O_WRONLY_STATE, &state->flags);
2109 : : clear_bit(NFS_O_RDWR_STATE, &state->flags);
2110 : : clear_bit(NFS_OPEN_STATE, &state->flags);
2111 : : }
2112 : : return status;
2113 : : }
2114 : :
2115 : : static int nfs41_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
2116 : : {
2117 : : int status;
2118 : :
2119 : : nfs41_clear_delegation_stateid(state);
2120 : : status = nfs41_check_open_stateid(state);
2121 : : if (status != NFS_OK)
2122 : : status = nfs4_open_expired(sp, state);
2123 : : return status;
2124 : : }
2125 : : #endif
2126 : :
2127 : : /*
2128 : : * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-*
2129 : : * fields corresponding to attributes that were used to store the verifier.
2130 : : * Make sure we clobber those fields in the later setattr call
2131 : : */
2132 : : static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata, struct iattr *sattr)
2133 : : {
2134 [ # # ][ # # ]: 0 : if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_ACCESS) &&
2135 : 0 : !(sattr->ia_valid & ATTR_ATIME_SET))
2136 : 0 : sattr->ia_valid |= ATTR_ATIME;
2137 : :
2138 [ # # ][ # # ]: 0 : if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_MODIFY) &&
2139 : 0 : !(sattr->ia_valid & ATTR_MTIME_SET))
2140 : 0 : sattr->ia_valid |= ATTR_MTIME;
2141 : : }
2142 : :
2143 : 0 : static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata,
2144 : : fmode_t fmode,
2145 : : int flags,
2146 : : struct nfs_open_context *ctx)
2147 : : {
2148 : 0 : struct nfs4_state_owner *sp = opendata->owner;
2149 : 0 : struct nfs_server *server = sp->so_server;
2150 : : struct dentry *dentry;
2151 : : struct nfs4_state *state;
2152 : : unsigned int seq;
2153 : : int ret;
2154 : :
2155 : : seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
2156 : :
2157 : 0 : ret = _nfs4_proc_open(opendata);
2158 [ # # ]: 0 : if (ret != 0)
2159 : : goto out;
2160 : :
2161 : 0 : state = nfs4_opendata_to_nfs4_state(opendata);
2162 : : ret = PTR_ERR(state);
2163 [ # # ]: 0 : if (IS_ERR(state))
2164 : : goto out;
2165 [ # # ]: 0 : if (server->caps & NFS_CAP_POSIX_LOCK)
2166 : 0 : set_bit(NFS_STATE_POSIX_LOCKS, &state->flags);
2167 : :
2168 : 0 : dentry = opendata->dentry;
2169 [ # # ]: 0 : if (dentry->d_inode == NULL) {
2170 : : /* FIXME: Is this d_drop() ever needed? */
2171 : 0 : d_drop(dentry);
2172 : 0 : dentry = d_add_unique(dentry, igrab(state->inode));
2173 [ # # ]: 0 : if (dentry == NULL) {
2174 : 0 : dentry = opendata->dentry;
2175 [ # # ]: 0 : } else if (dentry != ctx->dentry) {
2176 : 0 : dput(ctx->dentry);
2177 : 0 : ctx->dentry = dget(dentry);
2178 : : }
2179 : 0 : nfs_set_verifier(dentry,
2180 : 0 : nfs_save_change_attribute(opendata->dir->d_inode));
2181 : : }
2182 : :
2183 : 0 : ret = nfs4_opendata_access(sp->so_cred, opendata, state, fmode, flags);
2184 [ # # ]: 0 : if (ret != 0)
2185 : : goto out;
2186 : :
2187 : 0 : ctx->state = state;
2188 [ # # ]: 0 : if (dentry->d_inode == state->inode) {
2189 : 0 : nfs_inode_attach_open_context(ctx);
2190 [ # # ]: 0 : if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
2191 : 0 : nfs4_schedule_stateid_recovery(server, state);
2192 : : }
2193 : : out:
2194 : 0 : return ret;
2195 : : }
2196 : :
2197 : : /*
2198 : : * Returns a referenced nfs4_state
2199 : : */
2200 : 0 : static int _nfs4_do_open(struct inode *dir,
2201 : : struct nfs_open_context *ctx,
2202 : : int flags,
2203 : : struct iattr *sattr,
2204 : : struct nfs4_label *label,
2205 : : int *opened)
2206 : : {
2207 : : struct nfs4_state_owner *sp;
2208 : : struct nfs4_state *state = NULL;
2209 : 0 : struct nfs_server *server = NFS_SERVER(dir);
2210 : : struct nfs4_opendata *opendata;
2211 : 0 : struct dentry *dentry = ctx->dentry;
2212 : 0 : struct rpc_cred *cred = ctx->cred;
2213 : 0 : struct nfs4_threshold **ctx_th = &ctx->mdsthreshold;
2214 : 0 : fmode_t fmode = ctx->mode & (FMODE_READ|FMODE_WRITE|FMODE_EXEC);
2215 : : enum open_claim_type4 claim = NFS4_OPEN_CLAIM_NULL;
2216 : : struct nfs4_label *olabel = NULL;
2217 : : int status;
2218 : :
2219 : : /* Protect against reboot recovery conflicts */
2220 : : status = -ENOMEM;
2221 : 0 : sp = nfs4_get_state_owner(server, cred, GFP_KERNEL);
2222 [ # # ]: 0 : if (sp == NULL) {
2223 : : dprintk("nfs4_do_open: nfs4_get_state_owner failed!\n");
2224 : : goto out_err;
2225 : : }
2226 : : status = nfs4_recover_expired_lease(server);
2227 [ # # ]: 0 : if (status != 0)
2228 : : goto err_put_state_owner;
2229 [ # # ]: 0 : if (dentry->d_inode != NULL)
2230 : 0 : nfs4_return_incompatible_delegation(dentry->d_inode, fmode);
2231 : : status = -ENOMEM;
2232 [ # # ]: 0 : if (dentry->d_inode)
2233 : : claim = NFS4_OPEN_CLAIM_FH;
2234 : 0 : opendata = nfs4_opendata_alloc(dentry, sp, fmode, flags, sattr,
2235 : : label, claim, GFP_KERNEL);
2236 [ # # ]: 0 : if (opendata == NULL)
2237 : : goto err_put_state_owner;
2238 : :
2239 : : if (label) {
2240 : : olabel = nfs4_label_alloc(server, GFP_KERNEL);
2241 : : if (IS_ERR(olabel)) {
2242 : : status = PTR_ERR(olabel);
2243 : : goto err_opendata_put;
2244 : : }
2245 : : }
2246 : :
2247 [ # # ][ # # ]: 0 : if (ctx_th && server->attr_bitmask[2] & FATTR4_WORD2_MDSTHRESHOLD) {
2248 : 0 : opendata->f_attr.mdsthreshold = pnfs_mdsthreshold_alloc();
2249 : : if (!opendata->f_attr.mdsthreshold)
2250 : : goto err_free_label;
2251 : : opendata->o_arg.open_bitmap = &nfs4_pnfs_open_bitmap[0];
2252 : : }
2253 [ # # ]: 0 : if (dentry->d_inode != NULL)
2254 : 0 : opendata->state = nfs4_get_open_state(dentry->d_inode, sp);
2255 : :
2256 : 0 : status = _nfs4_open_and_get_state(opendata, fmode, flags, ctx);
2257 [ # # ]: 0 : if (status != 0)
2258 : : goto err_free_label;
2259 : 0 : state = ctx->state;
2260 : :
2261 [ # # ][ # # ]: 0 : if ((opendata->o_arg.open_flags & O_EXCL) &&
2262 : 0 : (opendata->o_arg.createmode != NFS4_CREATE_GUARDED)) {
2263 : : nfs4_exclusive_attrset(opendata, sattr);
2264 : :
2265 : 0 : nfs_fattr_init(opendata->o_res.f_attr);
2266 : 0 : status = nfs4_do_setattr(state->inode, cred,
2267 : : opendata->o_res.f_attr, sattr,
2268 : : state, label, olabel);
2269 [ # # ]: 0 : if (status == 0) {
2270 : 0 : nfs_setattr_update_inode(state->inode, sattr);
2271 : 0 : nfs_post_op_update_inode(state->inode, opendata->o_res.f_attr);
2272 : 0 : nfs_setsecurity(state->inode, opendata->o_res.f_attr, olabel);
2273 : : }
2274 : : }
2275 [ # # ]: 0 : if (opendata->file_created)
2276 : 0 : *opened |= FILE_CREATED;
2277 : :
2278 : : if (pnfs_use_threshold(ctx_th, opendata->f_attr.mdsthreshold, server))
2279 : : *ctx_th = opendata->f_attr.mdsthreshold;
2280 : : else
2281 : 0 : kfree(opendata->f_attr.mdsthreshold);
2282 : 0 : opendata->f_attr.mdsthreshold = NULL;
2283 : :
2284 : : nfs4_label_free(olabel);
2285 : :
2286 : 0 : nfs4_opendata_put(opendata);
2287 : 0 : nfs4_put_state_owner(sp);
2288 : 0 : return 0;
2289 : : err_free_label:
2290 : : nfs4_label_free(olabel);
2291 : : err_opendata_put:
2292 : 0 : kfree(opendata->f_attr.mdsthreshold);
2293 : 0 : nfs4_opendata_put(opendata);
2294 : : err_put_state_owner:
2295 : 0 : nfs4_put_state_owner(sp);
2296 : : out_err:
2297 : 0 : return status;
2298 : : }
2299 : :
2300 : :
2301 : 0 : static struct nfs4_state *nfs4_do_open(struct inode *dir,
2302 : : struct nfs_open_context *ctx,
2303 : : int flags,
2304 : : struct iattr *sattr,
2305 : : struct nfs4_label *label,
2306 : : int *opened)
2307 : : {
2308 : : struct nfs_server *server = NFS_SERVER(dir);
2309 : 0 : struct nfs4_exception exception = { };
2310 : : struct nfs4_state *res;
2311 : : int status;
2312 : :
2313 : : do {
2314 : 0 : status = _nfs4_do_open(dir, ctx, flags, sattr, label, opened);
2315 : 0 : res = ctx->state;
2316 : : trace_nfs4_open_file(ctx, flags, status);
2317 [ # # ]: 0 : if (status == 0)
2318 : : break;
2319 : : /* NOTE: BAD_SEQID means the server and client disagree about the
2320 : : * book-keeping w.r.t. state-changing operations
2321 : : * (OPEN/CLOSE/LOCK/LOCKU...)
2322 : : * It is actually a sign of a bug on the client or on the server.
2323 : : *
2324 : : * If we receive a BAD_SEQID error in the particular case of
2325 : : * doing an OPEN, we assume that nfs_increment_open_seqid() will
2326 : : * have unhashed the old state_owner for us, and that we can
2327 : : * therefore safely retry using a new one. We should still warn
2328 : : * the user though...
2329 : : */
2330 [ # # ]: 0 : if (status == -NFS4ERR_BAD_SEQID) {
2331 [ # # ]: 0 : pr_warn_ratelimited("NFS: v4 server %s "
2332 : : " returned a bad sequence-id error!\n",
2333 : : NFS_SERVER(dir)->nfs_client->cl_hostname);
2334 : 0 : exception.retry = 1;
2335 : 0 : continue;
2336 : : }
2337 : : /*
2338 : : * BAD_STATEID on OPEN means that the server cancelled our
2339 : : * state before it received the OPEN_CONFIRM.
2340 : : * Recover by retrying the request as per the discussion
2341 : : * on Page 181 of RFC3530.
2342 : : */
2343 [ # # ]: 0 : if (status == -NFS4ERR_BAD_STATEID) {
2344 : 0 : exception.retry = 1;
2345 : 0 : continue;
2346 : : }
2347 [ # # ]: 0 : if (status == -EAGAIN) {
2348 : : /* We must have found a delegation */
2349 : 0 : exception.retry = 1;
2350 : 0 : continue;
2351 : : }
2352 [ # # ]: 0 : if (nfs4_clear_cap_atomic_open_v1(server, status, &exception))
2353 : 0 : continue;
2354 : 0 : res = ERR_PTR(nfs4_handle_exception(server,
2355 : : status, &exception));
2356 [ # # ]: 0 : } while (exception.retry);
2357 : 0 : return res;
2358 : : }
2359 : :
2360 : 0 : static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
2361 : : struct nfs_fattr *fattr, struct iattr *sattr,
2362 : : struct nfs4_state *state, struct nfs4_label *ilabel,
2363 : : struct nfs4_label *olabel)
2364 : : {
2365 : 0 : struct nfs_server *server = NFS_SERVER(inode);
2366 : 0 : struct nfs_setattrargs arg = {
2367 : 0 : .fh = NFS_FH(inode),
2368 : : .iap = sattr,
2369 : : .server = server,
2370 : 0 : .bitmask = server->attr_bitmask,
2371 : : .label = ilabel,
2372 : : };
2373 : 0 : struct nfs_setattrres res = {
2374 : : .fattr = fattr,
2375 : : .label = olabel,
2376 : : .server = server,
2377 : : };
2378 : 0 : struct rpc_message msg = {
2379 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
2380 : : .rpc_argp = &arg,
2381 : : .rpc_resp = &res,
2382 : : .rpc_cred = cred,
2383 : : };
2384 : 0 : unsigned long timestamp = jiffies;
2385 : : fmode_t fmode;
2386 : : bool truncate;
2387 : : int status;
2388 : :
2389 : : arg.bitmask = nfs4_bitmask(server, ilabel);
2390 : : if (ilabel)
2391 : : arg.bitmask = nfs4_bitmask(server, olabel);
2392 : :
2393 : 0 : nfs_fattr_init(fattr);
2394 : :
2395 : : /* Servers should only apply open mode checks for file size changes */
2396 : 0 : truncate = (sattr->ia_valid & ATTR_SIZE) ? true : false;
2397 [ # # ]: 0 : fmode = truncate ? FMODE_WRITE : FMODE_READ;
2398 : :
2399 [ # # ]: 0 : if (nfs4_copy_delegation_stateid(&arg.stateid, inode, fmode)) {
2400 : : /* Use that stateid */
2401 [ # # ]: 0 : } else if (truncate && state != NULL) {
2402 : 0 : struct nfs_lockowner lockowner = {
2403 : 0 : .l_owner = current->files,
2404 : 0 : .l_pid = current->tgid,
2405 : : };
2406 [ # # ]: 0 : if (!nfs4_valid_open_stateid(state))
2407 : 0 : return -EBADF;
2408 [ # # ]: 0 : if (nfs4_select_rw_stateid(&arg.stateid, state, FMODE_WRITE,
2409 : : &lockowner) == -EIO)
2410 : : return -EBADF;
2411 : : } else
2412 : : nfs4_stateid_copy(&arg.stateid, &zero_stateid);
2413 : :
2414 : 0 : status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
2415 [ # # ]: 0 : if (status == 0 && state != NULL)
2416 : : renew_lease(server, timestamp);
2417 : 0 : return status;
2418 : : }
2419 : :
2420 : 0 : static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
2421 : : struct nfs_fattr *fattr, struct iattr *sattr,
2422 : : struct nfs4_state *state, struct nfs4_label *ilabel,
2423 : : struct nfs4_label *olabel)
2424 : : {
2425 : : struct nfs_server *server = NFS_SERVER(inode);
2426 : 0 : struct nfs4_exception exception = {
2427 : : .state = state,
2428 : : .inode = inode,
2429 : : };
2430 : : int err;
2431 : : do {
2432 : 0 : err = _nfs4_do_setattr(inode, cred, fattr, sattr, state, ilabel, olabel);
2433 : : trace_nfs4_setattr(inode, err);
2434 [ # # ]: 0 : switch (err) {
2435 : : case -NFS4ERR_OPENMODE:
2436 [ # # ]: 0 : if (!(sattr->ia_valid & ATTR_SIZE)) {
2437 [ # # ]: 0 : pr_warn_once("NFSv4: server %s is incorrectly "
2438 : : "applying open mode checks to "
2439 : : "a SETATTR that is not "
2440 : : "changing file size.\n",
2441 : : server->nfs_client->cl_hostname);
2442 : : }
2443 [ # # ][ # # ]: 0 : if (state && !(state->state & FMODE_WRITE)) {
2444 : : err = -EBADF;
2445 [ # # ]: 0 : if (sattr->ia_valid & ATTR_OPEN)
2446 : : err = -EACCES;
2447 : : goto out;
2448 : : }
2449 : : }
2450 : 0 : err = nfs4_handle_exception(server, err, &exception);
2451 [ # # ]: 0 : } while (exception.retry);
2452 : : out:
2453 : 0 : return err;
2454 : : }
2455 : :
2456 : : struct nfs4_closedata {
2457 : : struct inode *inode;
2458 : : struct nfs4_state *state;
2459 : : struct nfs_closeargs arg;
2460 : : struct nfs_closeres res;
2461 : : struct nfs_fattr fattr;
2462 : : unsigned long timestamp;
2463 : : bool roc;
2464 : : u32 roc_barrier;
2465 : : };
2466 : :
2467 : 0 : static void nfs4_free_closedata(void *data)
2468 : : {
2469 : : struct nfs4_closedata *calldata = data;
2470 : 0 : struct nfs4_state_owner *sp = calldata->state->owner;
2471 : 0 : struct super_block *sb = calldata->state->inode->i_sb;
2472 : :
2473 : : if (calldata->roc)
2474 : : pnfs_roc_release(calldata->state->inode);
2475 : 0 : nfs4_put_open_state(calldata->state);
2476 : 0 : nfs_free_seqid(calldata->arg.seqid);
2477 : 0 : nfs4_put_state_owner(sp);
2478 : 0 : nfs_sb_deactive(sb);
2479 : 0 : kfree(calldata);
2480 : 0 : }
2481 : :
2482 : 0 : static void nfs4_close_clear_stateid_flags(struct nfs4_state *state,
2483 : : fmode_t fmode)
2484 : : {
2485 : 0 : spin_lock(&state->owner->so_lock);
2486 : 0 : clear_bit(NFS_O_RDWR_STATE, &state->flags);
2487 [ # # # # ]: 0 : switch (fmode & (FMODE_READ|FMODE_WRITE)) {
2488 : : case FMODE_WRITE:
2489 : 0 : clear_bit(NFS_O_RDONLY_STATE, &state->flags);
2490 : 0 : break;
2491 : : case FMODE_READ:
2492 : 0 : clear_bit(NFS_O_WRONLY_STATE, &state->flags);
2493 : 0 : break;
2494 : : case 0:
2495 : 0 : clear_bit(NFS_O_RDONLY_STATE, &state->flags);
2496 : 0 : clear_bit(NFS_O_WRONLY_STATE, &state->flags);
2497 : 0 : clear_bit(NFS_OPEN_STATE, &state->flags);
2498 : : }
2499 : 0 : spin_unlock(&state->owner->so_lock);
2500 : 0 : }
2501 : :
2502 : 0 : static void nfs4_close_done(struct rpc_task *task, void *data)
2503 : : {
2504 : : struct nfs4_closedata *calldata = data;
2505 : 0 : struct nfs4_state *state = calldata->state;
2506 : 0 : struct nfs_server *server = NFS_SERVER(calldata->inode);
2507 : :
2508 : : dprintk("%s: begin!\n", __func__);
2509 [ # # ]: 0 : if (!nfs4_sequence_done(task, &calldata->res.seq_res))
2510 : 0 : return;
2511 : 0 : trace_nfs4_close(state, &calldata->arg, &calldata->res, task->tk_status);
2512 : : /* hmm. we are done with the inode, and in the process of freeing
2513 : : * the state_owner. we keep this around to process errors
2514 : : */
2515 [ # # # ]: 0 : switch (task->tk_status) {
2516 : : case 0:
2517 : : if (calldata->roc)
2518 : : pnfs_roc_set_barrier(state->inode,
2519 : : calldata->roc_barrier);
2520 : 0 : nfs_set_open_stateid(state, &calldata->res.stateid, 0);
2521 : 0 : renew_lease(server, calldata->timestamp);
2522 : : break;
2523 : : case -NFS4ERR_ADMIN_REVOKED:
2524 : : case -NFS4ERR_STALE_STATEID:
2525 : : case -NFS4ERR_OLD_STATEID:
2526 : : case -NFS4ERR_BAD_STATEID:
2527 : : case -NFS4ERR_EXPIRED:
2528 [ # # ]: 0 : if (calldata->arg.fmode == 0)
2529 : : break;
2530 : : default:
2531 [ # # ]: 0 : if (nfs4_async_handle_error(task, server, state) == -EAGAIN) {
2532 : 0 : rpc_restart_call_prepare(task);
2533 : 0 : goto out_release;
2534 : : }
2535 : : }
2536 : 0 : nfs4_close_clear_stateid_flags(state, calldata->arg.fmode);
2537 : : out_release:
2538 : 0 : nfs_release_seqid(calldata->arg.seqid);
2539 : 0 : nfs_refresh_inode(calldata->inode, calldata->res.fattr);
2540 : : dprintk("%s: done, ret = %d!\n", __func__, task->tk_status);
2541 : : }
2542 : :
2543 : 0 : static void nfs4_close_prepare(struct rpc_task *task, void *data)
2544 : : {
2545 : : struct nfs4_closedata *calldata = data;
2546 : 0 : struct nfs4_state *state = calldata->state;
2547 : 0 : struct inode *inode = calldata->inode;
2548 : : int call_close = 0;
2549 : :
2550 : : dprintk("%s: begin!\n", __func__);
2551 [ # # ]: 0 : if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
2552 : : goto out_wait;
2553 : :
2554 : 0 : task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE];
2555 : 0 : calldata->arg.fmode = FMODE_READ|FMODE_WRITE;
2556 : 0 : spin_lock(&state->owner->so_lock);
2557 : : /* Calculate the change in open mode */
2558 [ # # ]: 0 : if (state->n_rdwr == 0) {
2559 [ # # ]: 0 : if (state->n_rdonly == 0) {
2560 : : call_close |= test_bit(NFS_O_RDONLY_STATE, &state->flags);
2561 : 0 : call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
2562 : 0 : calldata->arg.fmode &= ~FMODE_READ;
2563 : : }
2564 [ # # ]: 0 : if (state->n_wronly == 0) {
2565 : 0 : call_close |= test_bit(NFS_O_WRONLY_STATE, &state->flags);
2566 : 0 : call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
2567 : 0 : calldata->arg.fmode &= ~FMODE_WRITE;
2568 : : }
2569 : : }
2570 [ # # ]: 0 : if (!nfs4_valid_open_stateid(state))
2571 : : call_close = 0;
2572 : 0 : spin_unlock(&state->owner->so_lock);
2573 : :
2574 [ # # ]: 0 : if (!call_close) {
2575 : : /* Note: exit _without_ calling nfs4_close_done */
2576 : : goto out_no_action;
2577 : : }
2578 : :
2579 [ # # ]: 0 : if (calldata->arg.fmode == 0) {
2580 : 0 : task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE];
2581 : : if (calldata->roc &&
2582 : : pnfs_roc_drain(inode, &calldata->roc_barrier, task)) {
2583 : : nfs_release_seqid(calldata->arg.seqid);
2584 : : goto out_wait;
2585 : : }
2586 : : }
2587 : :
2588 : 0 : nfs_fattr_init(calldata->res.fattr);
2589 : 0 : calldata->timestamp = jiffies;
2590 [ # # ]: 0 : if (nfs4_setup_sequence(NFS_SERVER(inode),
2591 : : &calldata->arg.seq_args,
2592 : : &calldata->res.seq_res,
2593 : : task) != 0)
2594 : 0 : nfs_release_seqid(calldata->arg.seqid);
2595 : : dprintk("%s: done!\n", __func__);
2596 : 0 : return;
2597 : : out_no_action:
2598 : 0 : task->tk_action = NULL;
2599 : : out_wait:
2600 : 0 : nfs4_sequence_done(task, &calldata->res.seq_res);
2601 : : }
2602 : :
2603 : : static const struct rpc_call_ops nfs4_close_ops = {
2604 : : .rpc_call_prepare = nfs4_close_prepare,
2605 : : .rpc_call_done = nfs4_close_done,
2606 : : .rpc_release = nfs4_free_closedata,
2607 : : };
2608 : :
2609 : : /*
2610 : : * It is possible for data to be read/written from a mem-mapped file
2611 : : * after the sys_close call (which hits the vfs layer as a flush).
2612 : : * This means that we can't safely call nfsv4 close on a file until
2613 : : * the inode is cleared. This in turn means that we are not good
2614 : : * NFSv4 citizens - we do not indicate to the server to update the file's
2615 : : * share state even when we are done with one of the three share
2616 : : * stateid's in the inode.
2617 : : *
2618 : : * NOTE: Caller must be holding the sp->so_owner semaphore!
2619 : : */
2620 : 0 : int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait)
2621 : : {
2622 : 0 : struct nfs_server *server = NFS_SERVER(state->inode);
2623 : : struct nfs4_closedata *calldata;
2624 : 0 : struct nfs4_state_owner *sp = state->owner;
2625 : : struct rpc_task *task;
2626 : 0 : struct rpc_message msg = {
2627 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE],
2628 : 0 : .rpc_cred = state->owner->so_cred,
2629 : : };
2630 : 0 : struct rpc_task_setup task_setup_data = {
2631 : 0 : .rpc_client = server->client,
2632 : : .rpc_message = &msg,
2633 : : .callback_ops = &nfs4_close_ops,
2634 : : .workqueue = nfsiod_workqueue,
2635 : : .flags = RPC_TASK_ASYNC,
2636 : : };
2637 : : int status = -ENOMEM;
2638 : :
2639 : : nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_CLEANUP,
2640 : : &task_setup_data.rpc_client, &msg);
2641 : :
2642 : : calldata = kzalloc(sizeof(*calldata), gfp_mask);
2643 [ # # ]: 0 : if (calldata == NULL)
2644 : : goto out;
2645 : : nfs4_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 1);
2646 : 0 : calldata->inode = state->inode;
2647 : 0 : calldata->state = state;
2648 : 0 : calldata->arg.fh = NFS_FH(state->inode);
2649 : 0 : calldata->arg.stateid = &state->open_stateid;
2650 : : /* Serialization for the sequence id */
2651 : 0 : calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid, gfp_mask);
2652 [ # # ]: 0 : if (calldata->arg.seqid == NULL)
2653 : : goto out_free_calldata;
2654 : 0 : calldata->arg.fmode = 0;
2655 : 0 : calldata->arg.bitmask = server->cache_consistency_bitmask;
2656 : 0 : calldata->res.fattr = &calldata->fattr;
2657 : 0 : calldata->res.seqid = calldata->arg.seqid;
2658 : 0 : calldata->res.server = server;
2659 : 0 : calldata->roc = pnfs_roc(state->inode);
2660 : 0 : nfs_sb_active(calldata->inode->i_sb);
2661 : :
2662 : 0 : msg.rpc_argp = &calldata->arg;
2663 : 0 : msg.rpc_resp = &calldata->res;
2664 : 0 : task_setup_data.callback_data = calldata;
2665 : 0 : task = rpc_run_task(&task_setup_data);
2666 [ # # ]: 0 : if (IS_ERR(task))
2667 : 0 : return PTR_ERR(task);
2668 : : status = 0;
2669 [ # # ]: 0 : if (wait)
2670 : : status = rpc_wait_for_completion_task(task);
2671 : 0 : rpc_put_task(task);
2672 : 0 : return status;
2673 : : out_free_calldata:
2674 : 0 : kfree(calldata);
2675 : : out:
2676 : 0 : nfs4_put_open_state(state);
2677 : 0 : nfs4_put_state_owner(sp);
2678 : 0 : return status;
2679 : : }
2680 : :
2681 : : static struct inode *
2682 : 0 : nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx,
2683 : : int open_flags, struct iattr *attr, int *opened)
2684 : : {
2685 : : struct nfs4_state *state;
2686 : : struct nfs4_label l = {0, 0, 0, NULL}, *label = NULL;
2687 : :
2688 : : label = nfs4_label_init_security(dir, ctx->dentry, attr, &l);
2689 : :
2690 : : /* Protect against concurrent sillydeletes */
2691 : 0 : state = nfs4_do_open(dir, ctx, open_flags, attr, label, opened);
2692 : :
2693 : : nfs4_label_release_security(label);
2694 : :
2695 [ # # ]: 0 : if (IS_ERR(state))
2696 : : return ERR_CAST(state);
2697 : 0 : return state->inode;
2698 : : }
2699 : :
2700 : 0 : static void nfs4_close_context(struct nfs_open_context *ctx, int is_sync)
2701 : : {
2702 [ # # ]: 0 : if (ctx->state == NULL)
2703 : 0 : return;
2704 [ # # ]: 0 : if (is_sync)
2705 : 0 : nfs4_close_sync(ctx->state, ctx->mode);
2706 : : else
2707 : 0 : nfs4_close_state(ctx->state, ctx->mode);
2708 : : }
2709 : :
2710 : : #define FATTR4_WORD1_NFS40_MASK (2*FATTR4_WORD1_MOUNTED_ON_FILEID - 1UL)
2711 : : #define FATTR4_WORD2_NFS41_MASK (2*FATTR4_WORD2_SUPPATTR_EXCLCREAT - 1UL)
2712 : : #define FATTR4_WORD2_NFS42_MASK (2*FATTR4_WORD2_CHANGE_SECURITY_LABEL - 1UL)
2713 : :
2714 : 0 : static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
2715 : : {
2716 : 0 : struct nfs4_server_caps_arg args = {
2717 : : .fhandle = fhandle,
2718 : : };
2719 : 0 : struct nfs4_server_caps_res res = {};
2720 : 0 : struct rpc_message msg = {
2721 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SERVER_CAPS],
2722 : : .rpc_argp = &args,
2723 : : .rpc_resp = &res,
2724 : : };
2725 : : int status;
2726 : :
2727 : 0 : status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
2728 [ # # ]: 0 : if (status == 0) {
2729 : : /* Sanity check the server answers */
2730 [ # # # # ]: 0 : switch (server->nfs_client->cl_minorversion) {
2731 : : case 0:
2732 : 0 : res.attr_bitmask[1] &= FATTR4_WORD1_NFS40_MASK;
2733 : 0 : res.attr_bitmask[2] = 0;
2734 : 0 : break;
2735 : : case 1:
2736 : 0 : res.attr_bitmask[2] &= FATTR4_WORD2_NFS41_MASK;
2737 : 0 : break;
2738 : : case 2:
2739 : 0 : res.attr_bitmask[2] &= FATTR4_WORD2_NFS42_MASK;
2740 : : }
2741 : 0 : memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask));
2742 : 0 : server->caps &= ~(NFS_CAP_ACLS|NFS_CAP_HARDLINKS|
2743 : : NFS_CAP_SYMLINKS|NFS_CAP_FILEID|
2744 : : NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER|
2745 : : NFS_CAP_OWNER_GROUP|NFS_CAP_ATIME|
2746 : : NFS_CAP_CTIME|NFS_CAP_MTIME|
2747 : : NFS_CAP_SECURITY_LABEL);
2748 [ # # ][ # # ]: 0 : if (res.attr_bitmask[0] & FATTR4_WORD0_ACL &&
2749 : 0 : res.acl_bitmask & ACL4_SUPPORT_ALLOW_ACL)
2750 : 0 : server->caps |= NFS_CAP_ACLS;
2751 [ # # ]: 0 : if (res.has_links != 0)
2752 : 0 : server->caps |= NFS_CAP_HARDLINKS;
2753 [ # # ]: 0 : if (res.has_symlinks != 0)
2754 : 0 : server->caps |= NFS_CAP_SYMLINKS;
2755 [ # # ]: 0 : if (res.attr_bitmask[0] & FATTR4_WORD0_FILEID)
2756 : 0 : server->caps |= NFS_CAP_FILEID;
2757 [ # # ]: 0 : if (res.attr_bitmask[1] & FATTR4_WORD1_MODE)
2758 : 0 : server->caps |= NFS_CAP_MODE;
2759 [ # # ]: 0 : if (res.attr_bitmask[1] & FATTR4_WORD1_NUMLINKS)
2760 : 0 : server->caps |= NFS_CAP_NLINK;
2761 [ # # ]: 0 : if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER)
2762 : 0 : server->caps |= NFS_CAP_OWNER;
2763 [ # # ]: 0 : if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER_GROUP)
2764 : 0 : server->caps |= NFS_CAP_OWNER_GROUP;
2765 [ # # ]: 0 : if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_ACCESS)
2766 : 0 : server->caps |= NFS_CAP_ATIME;
2767 [ # # ]: 0 : if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_METADATA)
2768 : 0 : server->caps |= NFS_CAP_CTIME;
2769 [ # # ]: 0 : if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY)
2770 : 0 : server->caps |= NFS_CAP_MTIME;
2771 : : #ifdef CONFIG_NFS_V4_SECURITY_LABEL
2772 : : if (res.attr_bitmask[2] & FATTR4_WORD2_SECURITY_LABEL)
2773 : : server->caps |= NFS_CAP_SECURITY_LABEL;
2774 : : #endif
2775 : 0 : memcpy(server->attr_bitmask_nl, res.attr_bitmask,
2776 : : sizeof(server->attr_bitmask));
2777 : 0 : server->attr_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
2778 : :
2779 : 0 : memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask));
2780 : 0 : server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE;
2781 : 0 : server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY;
2782 : 0 : server->cache_consistency_bitmask[2] = 0;
2783 : 0 : server->acl_bitmask = res.acl_bitmask;
2784 : 0 : server->fh_expire_type = res.fh_expire_type;
2785 : : }
2786 : :
2787 : 0 : return status;
2788 : : }
2789 : :
2790 : 0 : int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
2791 : : {
2792 : 0 : struct nfs4_exception exception = { };
2793 : : int err;
2794 : : do {
2795 : 0 : err = nfs4_handle_exception(server,
2796 : : _nfs4_server_capabilities(server, fhandle),
2797 : : &exception);
2798 [ # # ]: 0 : } while (exception.retry);
2799 : 0 : return err;
2800 : : }
2801 : :
2802 : 0 : static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
2803 : : struct nfs_fsinfo *info)
2804 : : {
2805 : : u32 bitmask[3];
2806 : 0 : struct nfs4_lookup_root_arg args = {
2807 : : .bitmask = bitmask,
2808 : : };
2809 : 0 : struct nfs4_lookup_res res = {
2810 : : .server = server,
2811 : 0 : .fattr = info->fattr,
2812 : : .fh = fhandle,
2813 : : };
2814 : 0 : struct rpc_message msg = {
2815 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP_ROOT],
2816 : : .rpc_argp = &args,
2817 : : .rpc_resp = &res,
2818 : : };
2819 : :
2820 : 0 : bitmask[0] = nfs4_fattr_bitmap[0];
2821 : 0 : bitmask[1] = nfs4_fattr_bitmap[1];
2822 : : /*
2823 : : * Process the label in the upcoming getfattr
2824 : : */
2825 : 0 : bitmask[2] = nfs4_fattr_bitmap[2] & ~FATTR4_WORD2_SECURITY_LABEL;
2826 : :
2827 : 0 : nfs_fattr_init(info->fattr);
2828 : 0 : return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
2829 : : }
2830 : :
2831 : 0 : static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
2832 : 0 : struct nfs_fsinfo *info)
2833 : : {
2834 : 0 : struct nfs4_exception exception = { };
2835 : : int err;
2836 : : do {
2837 : 0 : err = _nfs4_lookup_root(server, fhandle, info);
2838 : 0 : trace_nfs4_lookup_root(server, fhandle, info->fattr, err);
2839 [ # # ]: 0 : switch (err) {
2840 : : case 0:
2841 : : case -NFS4ERR_WRONGSEC:
2842 : : goto out;
2843 : : default:
2844 : 0 : err = nfs4_handle_exception(server, err, &exception);
2845 : : }
2846 [ # # ]: 0 : } while (exception.retry);
2847 : : out:
2848 : 0 : return err;
2849 : : }
2850 : :
2851 : 0 : static int nfs4_lookup_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
2852 : : struct nfs_fsinfo *info, rpc_authflavor_t flavor)
2853 : : {
2854 : 0 : struct rpc_auth_create_args auth_args = {
2855 : : .pseudoflavor = flavor,
2856 : : };
2857 : : struct rpc_auth *auth;
2858 : : int ret;
2859 : :
2860 : 0 : auth = rpcauth_create(&auth_args, server->client);
2861 [ # # ]: 0 : if (IS_ERR(auth)) {
2862 : : ret = -EACCES;
2863 : : goto out;
2864 : : }
2865 : 0 : ret = nfs4_lookup_root(server, fhandle, info);
2866 : : out:
2867 : 0 : return ret;
2868 : : }
2869 : :
2870 : : /*
2871 : : * Retry pseudoroot lookup with various security flavors. We do this when:
2872 : : *
2873 : : * NFSv4.0: the PUTROOTFH operation returns NFS4ERR_WRONGSEC
2874 : : * NFSv4.1: the server does not support the SECINFO_NO_NAME operation
2875 : : *
2876 : : * Returns zero on success, or a negative NFS4ERR value, or a
2877 : : * negative errno value.
2878 : : */
2879 : 0 : static int nfs4_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
2880 : : struct nfs_fsinfo *info)
2881 : : {
2882 : : /* Per 3530bis 15.33.5 */
2883 : : static const rpc_authflavor_t flav_array[] = {
2884 : : RPC_AUTH_GSS_KRB5P,
2885 : : RPC_AUTH_GSS_KRB5I,
2886 : : RPC_AUTH_GSS_KRB5,
2887 : : RPC_AUTH_UNIX, /* courtesy */
2888 : : RPC_AUTH_NULL,
2889 : : };
2890 : : int status = -EPERM;
2891 : : size_t i;
2892 : :
2893 [ # # ]: 0 : if (server->auth_info.flavor_len > 0) {
2894 : : /* try each flavor specified by user */
2895 [ # # ]: 0 : for (i = 0; i < server->auth_info.flavor_len; i++) {
2896 : 0 : status = nfs4_lookup_root_sec(server, fhandle, info,
2897 : : server->auth_info.flavors[i]);
2898 [ # # ]: 0 : if (status == -NFS4ERR_WRONGSEC || status == -EACCES)
2899 : 0 : continue;
2900 : : break;
2901 : : }
2902 : : } else {
2903 : : /* no flavors specified by user, try default list */
2904 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(flav_array); i++) {
2905 : 0 : status = nfs4_lookup_root_sec(server, fhandle, info,
2906 : : flav_array[i]);
2907 [ # # ]: 0 : if (status == -NFS4ERR_WRONGSEC || status == -EACCES)
2908 : 0 : continue;
2909 : : break;
2910 : : }
2911 : : }
2912 : :
2913 : : /*
2914 : : * -EACCESS could mean that the user doesn't have correct permissions
2915 : : * to access the mount. It could also mean that we tried to mount
2916 : : * with a gss auth flavor, but rpc.gssd isn't running. Either way,
2917 : : * existing mount programs don't handle -EACCES very well so it should
2918 : : * be mapped to -EPERM instead.
2919 : : */
2920 [ # # ]: 0 : if (status == -EACCES)
2921 : : status = -EPERM;
2922 : 0 : return status;
2923 : : }
2924 : :
2925 : : static int nfs4_do_find_root_sec(struct nfs_server *server,
2926 : : struct nfs_fh *fhandle, struct nfs_fsinfo *info)
2927 : : {
2928 : 0 : int mv = server->nfs_client->cl_minorversion;
2929 : 0 : return nfs_v4_minor_ops[mv]->find_root_sec(server, fhandle, info);
2930 : : }
2931 : :
2932 : : /**
2933 : : * nfs4_proc_get_rootfh - get file handle for server's pseudoroot
2934 : : * @server: initialized nfs_server handle
2935 : : * @fhandle: we fill in the pseudo-fs root file handle
2936 : : * @info: we fill in an FSINFO struct
2937 : : * @auth_probe: probe the auth flavours
2938 : : *
2939 : : * Returns zero on success, or a negative errno.
2940 : : */
2941 : 0 : int nfs4_proc_get_rootfh(struct nfs_server *server, struct nfs_fh *fhandle,
2942 : : struct nfs_fsinfo *info,
2943 : : bool auth_probe)
2944 : : {
2945 : : int status;
2946 : :
2947 [ # # ]: 0 : switch (auth_probe) {
2948 : : case false:
2949 : 0 : status = nfs4_lookup_root(server, fhandle, info);
2950 [ # # ]: 0 : if (status != -NFS4ERR_WRONGSEC)
2951 : : break;
2952 : : default:
2953 : : status = nfs4_do_find_root_sec(server, fhandle, info);
2954 : : }
2955 : :
2956 [ # # ]: 0 : if (status == 0)
2957 : 0 : status = nfs4_server_capabilities(server, fhandle);
2958 [ # # ]: 0 : if (status == 0)
2959 : 0 : status = nfs4_do_fsinfo(server, fhandle, info);
2960 : :
2961 : 0 : return nfs4_map_errors(status);
2962 : : }
2963 : :
2964 : 0 : static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *mntfh,
2965 : : struct nfs_fsinfo *info)
2966 : : {
2967 : : int error;
2968 : 0 : struct nfs_fattr *fattr = info->fattr;
2969 : : struct nfs4_label *label = NULL;
2970 : :
2971 : 0 : error = nfs4_server_capabilities(server, mntfh);
2972 [ # # ]: 0 : if (error < 0) {
2973 : : dprintk("nfs4_get_root: getcaps error = %d\n", -error);
2974 : : return error;
2975 : : }
2976 : :
2977 : : label = nfs4_label_alloc(server, GFP_KERNEL);
2978 : : if (IS_ERR(label))
2979 : : return PTR_ERR(label);
2980 : :
2981 : 0 : error = nfs4_proc_getattr(server, mntfh, fattr, label);
2982 [ # # ]: 0 : if (error < 0) {
2983 : : dprintk("nfs4_get_root: getattr error = %d\n", -error);
2984 : : goto err_free_label;
2985 : : }
2986 : :
2987 [ # # ][ # # ]: 0 : if (fattr->valid & NFS_ATTR_FATTR_FSID &&
2988 : : !nfs_fsid_equal(&server->fsid, &fattr->fsid))
2989 : 0 : memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));
2990 : :
2991 : : err_free_label:
2992 : : nfs4_label_free(label);
2993 : :
2994 : 0 : return error;
2995 : : }
2996 : :
2997 : : /*
2998 : : * Get locations and (maybe) other attributes of a referral.
2999 : : * Note that we'll actually follow the referral later when
3000 : : * we detect fsid mismatch in inode revalidation
3001 : : */
3002 : 0 : static int nfs4_get_referral(struct rpc_clnt *client, struct inode *dir,
3003 : : const struct qstr *name, struct nfs_fattr *fattr,
3004 : : struct nfs_fh *fhandle)
3005 : : {
3006 : : int status = -ENOMEM;
3007 : : struct page *page = NULL;
3008 : : struct nfs4_fs_locations *locations = NULL;
3009 : :
3010 : : page = alloc_page(GFP_KERNEL);
3011 [ # # ]: 0 : if (page == NULL)
3012 : : goto out;
3013 : : locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
3014 [ # # ]: 0 : if (locations == NULL)
3015 : : goto out;
3016 : :
3017 : 0 : status = nfs4_proc_fs_locations(client, dir, name, locations, page);
3018 [ # # ]: 0 : if (status != 0)
3019 : : goto out;
3020 : :
3021 : : /*
3022 : : * If the fsid didn't change, this is a migration event, not a
3023 : : * referral. Cause us to drop into the exception handler, which
3024 : : * will kick off migration recovery.
3025 : : */
3026 [ # # ]: 0 : if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) {
3027 : : dprintk("%s: server did not return a different fsid for"
3028 : : " a referral at %s\n", __func__, name->name);
3029 : : status = -NFS4ERR_MOVED;
3030 : : goto out;
3031 : : }
3032 : : /* Fixup attributes for the nfs_lookup() call to nfs_fhget() */
3033 : : nfs_fixup_referral_attributes(&locations->fattr);
3034 : :
3035 : : /* replace the lookup nfs_fattr with the locations nfs_fattr */
3036 : 0 : memcpy(fattr, &locations->fattr, sizeof(struct nfs_fattr));
3037 : 0 : memset(fhandle, 0, sizeof(struct nfs_fh));
3038 : : out:
3039 [ # # ]: 0 : if (page)
3040 : 0 : __free_page(page);
3041 : 0 : kfree(locations);
3042 : 0 : return status;
3043 : : }
3044 : :
3045 : 0 : static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
3046 : : struct nfs_fattr *fattr, struct nfs4_label *label)
3047 : : {
3048 : 0 : struct nfs4_getattr_arg args = {
3049 : : .fh = fhandle,
3050 : 0 : .bitmask = server->attr_bitmask,
3051 : : };
3052 : 0 : struct nfs4_getattr_res res = {
3053 : : .fattr = fattr,
3054 : : .label = label,
3055 : : .server = server,
3056 : : };
3057 : 0 : struct rpc_message msg = {
3058 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
3059 : : .rpc_argp = &args,
3060 : : .rpc_resp = &res,
3061 : : };
3062 : :
3063 : : args.bitmask = nfs4_bitmask(server, label);
3064 : :
3065 : 0 : nfs_fattr_init(fattr);
3066 : 0 : return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3067 : : }
3068 : :
3069 : 0 : static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
3070 : : struct nfs_fattr *fattr, struct nfs4_label *label)
3071 : : {
3072 : 0 : struct nfs4_exception exception = { };
3073 : : int err;
3074 : : do {
3075 : 0 : err = _nfs4_proc_getattr(server, fhandle, fattr, label);
3076 : : trace_nfs4_getattr(server, fhandle, fattr, err);
3077 : 0 : err = nfs4_handle_exception(server, err,
3078 : : &exception);
3079 [ # # ]: 0 : } while (exception.retry);
3080 : 0 : return err;
3081 : : }
3082 : :
3083 : : /*
3084 : : * The file is not closed if it is opened due to the a request to change
3085 : : * the size of the file. The open call will not be needed once the
3086 : : * VFS layer lookup-intents are implemented.
3087 : : *
3088 : : * Close is called when the inode is destroyed.
3089 : : * If we haven't opened the file for O_WRONLY, we
3090 : : * need to in the size_change case to obtain a stateid.
3091 : : *
3092 : : * Got race?
3093 : : * Because OPEN is always done by name in nfsv4, it is
3094 : : * possible that we opened a different file by the same
3095 : : * name. We can recognize this race condition, but we
3096 : : * can't do anything about it besides returning an error.
3097 : : *
3098 : : * This will be fixed with VFS changes (lookup-intent).
3099 : : */
3100 : : static int
3101 : 0 : nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
3102 : : struct iattr *sattr)
3103 : : {
3104 : 0 : struct inode *inode = dentry->d_inode;
3105 : : struct rpc_cred *cred = NULL;
3106 : : struct nfs4_state *state = NULL;
3107 : : struct nfs4_label *label = NULL;
3108 : : int status;
3109 : :
3110 : : if (pnfs_ld_layoutret_on_setattr(inode))
3111 : : pnfs_commit_and_return_layout(inode);
3112 : :
3113 : 0 : nfs_fattr_init(fattr);
3114 : :
3115 : : /* Deal with open(O_TRUNC) */
3116 [ # # ]: 0 : if (sattr->ia_valid & ATTR_OPEN)
3117 : 0 : sattr->ia_valid &= ~(ATTR_MTIME|ATTR_CTIME);
3118 : :
3119 : : /* Optimization: if the end result is no change, don't RPC */
3120 [ # # ]: 0 : if ((sattr->ia_valid & ~(ATTR_FILE|ATTR_OPEN)) == 0)
3121 : : return 0;
3122 : :
3123 : : /* Search for an existing open(O_WRITE) file */
3124 [ # # ]: 0 : if (sattr->ia_valid & ATTR_FILE) {
3125 : : struct nfs_open_context *ctx;
3126 : :
3127 : 0 : ctx = nfs_file_open_context(sattr->ia_file);
3128 [ # # ]: 0 : if (ctx) {
3129 : 0 : cred = ctx->cred;
3130 : 0 : state = ctx->state;
3131 : : }
3132 : : }
3133 : :
3134 : : label = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
3135 : : if (IS_ERR(label))
3136 : : return PTR_ERR(label);
3137 : :
3138 : 0 : status = nfs4_do_setattr(inode, cred, fattr, sattr, state, NULL, label);
3139 [ # # ]: 0 : if (status == 0) {
3140 : 0 : nfs_setattr_update_inode(inode, sattr);
3141 : 0 : nfs_setsecurity(inode, fattr, label);
3142 : : }
3143 : : nfs4_label_free(label);
3144 : 0 : return status;
3145 : : }
3146 : :
3147 : 0 : static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir,
3148 : : const struct qstr *name, struct nfs_fh *fhandle,
3149 : : struct nfs_fattr *fattr, struct nfs4_label *label)
3150 : : {
3151 : : struct nfs_server *server = NFS_SERVER(dir);
3152 : : int status;
3153 : 0 : struct nfs4_lookup_arg args = {
3154 : 0 : .bitmask = server->attr_bitmask,
3155 : 0 : .dir_fh = NFS_FH(dir),
3156 : : .name = name,
3157 : : };
3158 : 0 : struct nfs4_lookup_res res = {
3159 : : .server = server,
3160 : : .fattr = fattr,
3161 : : .label = label,
3162 : : .fh = fhandle,
3163 : : };
3164 : 0 : struct rpc_message msg = {
3165 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP],
3166 : : .rpc_argp = &args,
3167 : : .rpc_resp = &res,
3168 : : };
3169 : :
3170 : : args.bitmask = nfs4_bitmask(server, label);
3171 : :
3172 : 0 : nfs_fattr_init(fattr);
3173 : :
3174 : : dprintk("NFS call lookup %s\n", name->name);
3175 : : status = nfs4_call_sync(clnt, server, &msg, &args.seq_args, &res.seq_res, 0);
3176 : : dprintk("NFS reply lookup: %d\n", status);
3177 : 0 : return status;
3178 : : }
3179 : :
3180 : : static void nfs_fixup_secinfo_attributes(struct nfs_fattr *fattr)
3181 : : {
3182 : 0 : fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |
3183 : : NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_MOUNTPOINT;
3184 : 0 : fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;
3185 : 0 : fattr->nlink = 2;
3186 : : }
3187 : :
3188 : 0 : static int nfs4_proc_lookup_common(struct rpc_clnt **clnt, struct inode *dir,
3189 : : struct qstr *name, struct nfs_fh *fhandle,
3190 : : struct nfs_fattr *fattr, struct nfs4_label *label)
3191 : : {
3192 : 0 : struct nfs4_exception exception = { };
3193 : 0 : struct rpc_clnt *client = *clnt;
3194 : : int err;
3195 : : do {
3196 : 0 : err = _nfs4_proc_lookup(client, dir, name, fhandle, fattr, label);
3197 : : trace_nfs4_lookup(dir, name, err);
3198 [ # # # # ]: 0 : switch (err) {
3199 : : case -NFS4ERR_BADNAME:
3200 : : err = -ENOENT;
3201 : : goto out;
3202 : : case -NFS4ERR_MOVED:
3203 : 0 : err = nfs4_get_referral(client, dir, name, fattr, fhandle);
3204 : 0 : goto out;
3205 : : case -NFS4ERR_WRONGSEC:
3206 : : err = -EPERM;
3207 [ # # ]: 0 : if (client != *clnt)
3208 : : goto out;
3209 : 0 : client = nfs4_create_sec_client(client, dir, name);
3210 [ # # ]: 0 : if (IS_ERR(client))
3211 : 0 : return PTR_ERR(client);
3212 : :
3213 : 0 : exception.retry = 1;
3214 : 0 : break;
3215 : : default:
3216 : 0 : err = nfs4_handle_exception(NFS_SERVER(dir), err, &exception);
3217 : : }
3218 [ # # ]: 0 : } while (exception.retry);
3219 : :
3220 : : out:
3221 [ # # ]: 0 : if (err == 0)
3222 : 0 : *clnt = client;
3223 [ # # ]: 0 : else if (client != *clnt)
3224 : 0 : rpc_shutdown_client(client);
3225 : :
3226 : 0 : return err;
3227 : : }
3228 : :
3229 : 0 : static int nfs4_proc_lookup(struct inode *dir, struct qstr *name,
3230 : : struct nfs_fh *fhandle, struct nfs_fattr *fattr,
3231 : : struct nfs4_label *label)
3232 : : {
3233 : : int status;
3234 : 0 : struct rpc_clnt *client = NFS_CLIENT(dir);
3235 : :
3236 : 0 : status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr, label);
3237 [ # # ]: 0 : if (client != NFS_CLIENT(dir)) {
3238 : 0 : rpc_shutdown_client(client);
3239 : : nfs_fixup_secinfo_attributes(fattr);
3240 : : }
3241 : 0 : return status;
3242 : : }
3243 : :
3244 : : struct rpc_clnt *
3245 : 0 : nfs4_proc_lookup_mountpoint(struct inode *dir, struct qstr *name,
3246 : : struct nfs_fh *fhandle, struct nfs_fattr *fattr)
3247 : : {
3248 : 0 : struct rpc_clnt *client = NFS_CLIENT(dir);
3249 : : int status;
3250 : :
3251 : 0 : status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr, NULL);
3252 [ # # ]: 0 : if (status < 0)
3253 : 0 : return ERR_PTR(status);
3254 [ # # ]: 0 : return (client == NFS_CLIENT(dir)) ? rpc_clone_client(client) : client;
3255 : : }
3256 : :
3257 : 0 : static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
3258 : : {
3259 : : struct nfs_server *server = NFS_SERVER(inode);
3260 : 0 : struct nfs4_accessargs args = {
3261 : 0 : .fh = NFS_FH(inode),
3262 : 0 : .bitmask = server->cache_consistency_bitmask,
3263 : : };
3264 : 0 : struct nfs4_accessres res = {
3265 : : .server = server,
3266 : : };
3267 : 0 : struct rpc_message msg = {
3268 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS],
3269 : : .rpc_argp = &args,
3270 : : .rpc_resp = &res,
3271 : 0 : .rpc_cred = entry->cred,
3272 : : };
3273 : 0 : int mode = entry->mask;
3274 : : int status = 0;
3275 : :
3276 : : /*
3277 : : * Determine which access bits we want to ask for...
3278 : : */
3279 [ # # ]: 0 : if (mode & MAY_READ)
3280 : 0 : args.access |= NFS4_ACCESS_READ;
3281 [ # # ]: 0 : if (S_ISDIR(inode->i_mode)) {
3282 [ # # ]: 0 : if (mode & MAY_WRITE)
3283 : 0 : args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE;
3284 [ # # ]: 0 : if (mode & MAY_EXEC)
3285 : 0 : args.access |= NFS4_ACCESS_LOOKUP;
3286 : : } else {
3287 [ # # ]: 0 : if (mode & MAY_WRITE)
3288 : 0 : args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND;
3289 [ # # ]: 0 : if (mode & MAY_EXEC)
3290 : 0 : args.access |= NFS4_ACCESS_EXECUTE;
3291 : : }
3292 : :
3293 : 0 : res.fattr = nfs_alloc_fattr();
3294 [ # # ]: 0 : if (res.fattr == NULL)
3295 : : return -ENOMEM;
3296 : :
3297 : 0 : status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3298 [ # # ]: 0 : if (!status) {
3299 : 0 : nfs_access_set_mask(entry, res.access);
3300 : 0 : nfs_refresh_inode(inode, res.fattr);
3301 : : }
3302 : 0 : nfs_free_fattr(res.fattr);
3303 : 0 : return status;
3304 : : }
3305 : :
3306 : 0 : static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
3307 : : {
3308 : 0 : struct nfs4_exception exception = { };
3309 : : int err;
3310 : : do {
3311 : 0 : err = _nfs4_proc_access(inode, entry);
3312 : : trace_nfs4_access(inode, err);
3313 : 0 : err = nfs4_handle_exception(NFS_SERVER(inode), err,
3314 : : &exception);
3315 [ # # ]: 0 : } while (exception.retry);
3316 : 0 : return err;
3317 : : }
3318 : :
3319 : : /*
3320 : : * TODO: For the time being, we don't try to get any attributes
3321 : : * along with any of the zero-copy operations READ, READDIR,
3322 : : * READLINK, WRITE.
3323 : : *
3324 : : * In the case of the first three, we want to put the GETATTR
3325 : : * after the read-type operation -- this is because it is hard
3326 : : * to predict the length of a GETATTR response in v4, and thus
3327 : : * align the READ data correctly. This means that the GETATTR
3328 : : * may end up partially falling into the page cache, and we should
3329 : : * shift it into the 'tail' of the xdr_buf before processing.
3330 : : * To do this efficiently, we need to know the total length
3331 : : * of data received, which doesn't seem to be available outside
3332 : : * of the RPC layer.
3333 : : *
3334 : : * In the case of WRITE, we also want to put the GETATTR after
3335 : : * the operation -- in this case because we want to make sure
3336 : : * we get the post-operation mtime and size.
3337 : : *
3338 : : * Both of these changes to the XDR layer would in fact be quite
3339 : : * minor, but I decided to leave them for a subsequent patch.
3340 : : */
3341 : 0 : static int _nfs4_proc_readlink(struct inode *inode, struct page *page,
3342 : : unsigned int pgbase, unsigned int pglen)
3343 : : {
3344 : 0 : struct nfs4_readlink args = {
3345 : 0 : .fh = NFS_FH(inode),
3346 : : .pgbase = pgbase,
3347 : : .pglen = pglen,
3348 : : .pages = &page,
3349 : : };
3350 : : struct nfs4_readlink_res res;
3351 : 0 : struct rpc_message msg = {
3352 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READLINK],
3353 : : .rpc_argp = &args,
3354 : : .rpc_resp = &res,
3355 : : };
3356 : :
3357 : 0 : return nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), &msg, &args.seq_args, &res.seq_res, 0);
3358 : : }
3359 : :
3360 : 0 : static int nfs4_proc_readlink(struct inode *inode, struct page *page,
3361 : : unsigned int pgbase, unsigned int pglen)
3362 : : {
3363 : 0 : struct nfs4_exception exception = { };
3364 : : int err;
3365 : : do {
3366 : 0 : err = _nfs4_proc_readlink(inode, page, pgbase, pglen);
3367 : : trace_nfs4_readlink(inode, err);
3368 : 0 : err = nfs4_handle_exception(NFS_SERVER(inode), err,
3369 : : &exception);
3370 [ # # ]: 0 : } while (exception.retry);
3371 : 0 : return err;
3372 : : }
3373 : :
3374 : : /*
3375 : : * This is just for mknod. open(O_CREAT) will always do ->open_context().
3376 : : */
3377 : : static int
3378 : 0 : nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
3379 : : int flags)
3380 : : {
3381 : : struct nfs4_label l, *ilabel = NULL;
3382 : : struct nfs_open_context *ctx;
3383 : : struct nfs4_state *state;
3384 : 0 : int opened = 0;
3385 : : int status = 0;
3386 : :
3387 : 0 : ctx = alloc_nfs_open_context(dentry, FMODE_READ);
3388 [ # # ]: 0 : if (IS_ERR(ctx))
3389 : 0 : return PTR_ERR(ctx);
3390 : :
3391 : : ilabel = nfs4_label_init_security(dir, dentry, sattr, &l);
3392 : :
3393 : 0 : sattr->ia_mode &= ~current_umask();
3394 : 0 : state = nfs4_do_open(dir, ctx, flags, sattr, ilabel, &opened);
3395 [ # # ]: 0 : if (IS_ERR(state)) {
3396 : : status = PTR_ERR(state);
3397 : 0 : goto out;
3398 : : }
3399 : : out:
3400 : : nfs4_label_release_security(ilabel);
3401 : 0 : put_nfs_open_context(ctx);
3402 : 0 : return status;
3403 : : }
3404 : :
3405 : 0 : static int _nfs4_proc_remove(struct inode *dir, struct qstr *name)
3406 : : {
3407 : : struct nfs_server *server = NFS_SERVER(dir);
3408 : 0 : struct nfs_removeargs args = {
3409 : 0 : .fh = NFS_FH(dir),
3410 : : .name = *name,
3411 : : };
3412 : 0 : struct nfs_removeres res = {
3413 : : .server = server,
3414 : : };
3415 : 0 : struct rpc_message msg = {
3416 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE],
3417 : : .rpc_argp = &args,
3418 : : .rpc_resp = &res,
3419 : : };
3420 : : int status;
3421 : :
3422 : 0 : status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1);
3423 [ # # ]: 0 : if (status == 0)
3424 : 0 : update_changeattr(dir, &res.cinfo);
3425 : 0 : return status;
3426 : : }
3427 : :
3428 : 0 : static int nfs4_proc_remove(struct inode *dir, struct qstr *name)
3429 : : {
3430 : 0 : struct nfs4_exception exception = { };
3431 : : int err;
3432 : : do {
3433 : 0 : err = _nfs4_proc_remove(dir, name);
3434 : : trace_nfs4_remove(dir, name, err);
3435 : 0 : err = nfs4_handle_exception(NFS_SERVER(dir), err,
3436 : : &exception);
3437 [ # # ]: 0 : } while (exception.retry);
3438 : 0 : return err;
3439 : : }
3440 : :
3441 : 0 : static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
3442 : : {
3443 : : struct nfs_server *server = NFS_SERVER(dir);
3444 : 0 : struct nfs_removeargs *args = msg->rpc_argp;
3445 : 0 : struct nfs_removeres *res = msg->rpc_resp;
3446 : :
3447 : 0 : res->server = server;
3448 : 0 : msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE];
3449 : : nfs4_init_sequence(&args->seq_args, &res->seq_res, 1);
3450 : :
3451 : 0 : nfs_fattr_init(res->dir_attr);
3452 : 0 : }
3453 : :
3454 : 0 : static void nfs4_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
3455 : : {
3456 : 0 : nfs4_setup_sequence(NFS_SERVER(data->dir),
3457 : : &data->args.seq_args,
3458 : : &data->res.seq_res,
3459 : : task);
3460 : 0 : }
3461 : :
3462 : 0 : static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir)
3463 : : {
3464 : 0 : struct nfs_unlinkdata *data = task->tk_calldata;
3465 : : struct nfs_removeres *res = &data->res;
3466 : :
3467 [ # # ]: 0 : if (!nfs4_sequence_done(task, &res->seq_res))
3468 : : return 0;
3469 [ # # ]: 0 : if (nfs4_async_handle_error(task, res->server, NULL) == -EAGAIN)
3470 : : return 0;
3471 : 0 : update_changeattr(dir, &res->cinfo);
3472 : 0 : return 1;
3473 : : }
3474 : :
3475 : 0 : static void nfs4_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
3476 : : {
3477 : : struct nfs_server *server = NFS_SERVER(dir);
3478 : 0 : struct nfs_renameargs *arg = msg->rpc_argp;
3479 : 0 : struct nfs_renameres *res = msg->rpc_resp;
3480 : :
3481 : 0 : msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME];
3482 : 0 : res->server = server;
3483 : : nfs4_init_sequence(&arg->seq_args, &res->seq_res, 1);
3484 : 0 : }
3485 : :
3486 : 0 : static void nfs4_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
3487 : : {
3488 : 0 : nfs4_setup_sequence(NFS_SERVER(data->old_dir),
3489 : : &data->args.seq_args,
3490 : : &data->res.seq_res,
3491 : : task);
3492 : 0 : }
3493 : :
3494 : 0 : static int nfs4_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
3495 : : struct inode *new_dir)
3496 : : {
3497 : 0 : struct nfs_renamedata *data = task->tk_calldata;
3498 : : struct nfs_renameres *res = &data->res;
3499 : :
3500 [ # # ]: 0 : if (!nfs4_sequence_done(task, &res->seq_res))
3501 : : return 0;
3502 [ # # ]: 0 : if (nfs4_async_handle_error(task, res->server, NULL) == -EAGAIN)
3503 : : return 0;
3504 : :
3505 : 0 : update_changeattr(old_dir, &res->old_cinfo);
3506 : 0 : update_changeattr(new_dir, &res->new_cinfo);
3507 : 0 : return 1;
3508 : : }
3509 : :
3510 : 0 : static int _nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,
3511 : : struct inode *new_dir, struct qstr *new_name)
3512 : : {
3513 : : struct nfs_server *server = NFS_SERVER(old_dir);
3514 : 0 : struct nfs_renameargs arg = {
3515 : 0 : .old_dir = NFS_FH(old_dir),
3516 : 0 : .new_dir = NFS_FH(new_dir),
3517 : : .old_name = old_name,
3518 : : .new_name = new_name,
3519 : : };
3520 : 0 : struct nfs_renameres res = {
3521 : : .server = server,
3522 : : };
3523 : 0 : struct rpc_message msg = {
3524 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME],
3525 : : .rpc_argp = &arg,
3526 : : .rpc_resp = &res,
3527 : : };
3528 : : int status = -ENOMEM;
3529 : :
3530 : 0 : status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
3531 [ # # ]: 0 : if (!status) {
3532 : 0 : update_changeattr(old_dir, &res.old_cinfo);
3533 : 0 : update_changeattr(new_dir, &res.new_cinfo);
3534 : : }
3535 : 0 : return status;
3536 : : }
3537 : :
3538 : 0 : static int nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,
3539 : : struct inode *new_dir, struct qstr *new_name)
3540 : : {
3541 : 0 : struct nfs4_exception exception = { };
3542 : : int err;
3543 : : do {
3544 : 0 : err = _nfs4_proc_rename(old_dir, old_name,
3545 : : new_dir, new_name);
3546 : : trace_nfs4_rename(old_dir, old_name, new_dir, new_name, err);
3547 : 0 : err = nfs4_handle_exception(NFS_SERVER(old_dir), err,
3548 : : &exception);
3549 [ # # ]: 0 : } while (exception.retry);
3550 : 0 : return err;
3551 : : }
3552 : :
3553 : 0 : static int _nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
3554 : : {
3555 : : struct nfs_server *server = NFS_SERVER(inode);
3556 : 0 : struct nfs4_link_arg arg = {
3557 : 0 : .fh = NFS_FH(inode),
3558 : 0 : .dir_fh = NFS_FH(dir),
3559 : : .name = name,
3560 : 0 : .bitmask = server->attr_bitmask,
3561 : : };
3562 : 0 : struct nfs4_link_res res = {
3563 : : .server = server,
3564 : : .label = NULL,
3565 : : };
3566 : 0 : struct rpc_message msg = {
3567 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK],
3568 : : .rpc_argp = &arg,
3569 : : .rpc_resp = &res,
3570 : : };
3571 : : int status = -ENOMEM;
3572 : :
3573 : 0 : res.fattr = nfs_alloc_fattr();
3574 [ # # ]: 0 : if (res.fattr == NULL)
3575 : : goto out;
3576 : :
3577 : 0 : res.label = nfs4_label_alloc(server, GFP_KERNEL);
3578 [ # # ]: 0 : if (IS_ERR(res.label)) {
3579 : : status = PTR_ERR(res.label);
3580 : : goto out;
3581 : : }
3582 : 0 : arg.bitmask = nfs4_bitmask(server, res.label);
3583 : :
3584 : 0 : status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
3585 [ # # ]: 0 : if (!status) {
3586 : 0 : update_changeattr(dir, &res.cinfo);
3587 : 0 : status = nfs_post_op_update_inode(inode, res.fattr);
3588 [ # # ]: 0 : if (!status)
3589 : 0 : nfs_setsecurity(inode, res.fattr, res.label);
3590 : : }
3591 : :
3592 : :
3593 : : nfs4_label_free(res.label);
3594 : :
3595 : : out:
3596 : 0 : nfs_free_fattr(res.fattr);
3597 : 0 : return status;
3598 : : }
3599 : :
3600 : 0 : static int nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
3601 : : {
3602 : 0 : struct nfs4_exception exception = { };
3603 : : int err;
3604 : : do {
3605 : 0 : err = nfs4_handle_exception(NFS_SERVER(inode),
3606 : : _nfs4_proc_link(inode, dir, name),
3607 : : &exception);
3608 [ # # ]: 0 : } while (exception.retry);
3609 : 0 : return err;
3610 : : }
3611 : :
3612 : : struct nfs4_createdata {
3613 : : struct rpc_message msg;
3614 : : struct nfs4_create_arg arg;
3615 : : struct nfs4_create_res res;
3616 : : struct nfs_fh fh;
3617 : : struct nfs_fattr fattr;
3618 : : struct nfs4_label *label;
3619 : : };
3620 : :
3621 : 0 : static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,
3622 : : struct qstr *name, struct iattr *sattr, u32 ftype)
3623 : : {
3624 : : struct nfs4_createdata *data;
3625 : :
3626 : : data = kzalloc(sizeof(*data), GFP_KERNEL);
3627 [ # # ]: 0 : if (data != NULL) {
3628 : : struct nfs_server *server = NFS_SERVER(dir);
3629 : :
3630 : 0 : data->label = nfs4_label_alloc(server, GFP_KERNEL);
3631 [ # # ]: 0 : if (IS_ERR(data->label))
3632 : : goto out_free;
3633 : :
3634 : 0 : data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE];
3635 : 0 : data->msg.rpc_argp = &data->arg;
3636 : 0 : data->msg.rpc_resp = &data->res;
3637 : 0 : data->arg.dir_fh = NFS_FH(dir);
3638 : 0 : data->arg.server = server;
3639 : 0 : data->arg.name = name;
3640 : 0 : data->arg.attrs = sattr;
3641 : 0 : data->arg.ftype = ftype;
3642 : 0 : data->arg.bitmask = nfs4_bitmask(server, data->label);
3643 : 0 : data->res.server = server;
3644 : 0 : data->res.fh = &data->fh;
3645 : 0 : data->res.fattr = &data->fattr;
3646 : 0 : data->res.label = data->label;
3647 : 0 : nfs_fattr_init(data->res.fattr);
3648 : : }
3649 : 0 : return data;
3650 : : out_free:
3651 : 0 : kfree(data);
3652 : 0 : return NULL;
3653 : : }
3654 : :
3655 : 0 : static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data)
3656 : : {
3657 : 0 : int status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &data->msg,
3658 : : &data->arg.seq_args, &data->res.seq_res, 1);
3659 [ # # ]: 0 : if (status == 0) {
3660 : 0 : update_changeattr(dir, &data->res.dir_cinfo);
3661 : 0 : status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, data->res.label);
3662 : : }
3663 : 0 : return status;
3664 : : }
3665 : :
3666 : : static void nfs4_free_createdata(struct nfs4_createdata *data)
3667 : : {
3668 : : nfs4_label_free(data->label);
3669 : 0 : kfree(data);
3670 : : }
3671 : :
3672 : 0 : static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
3673 : : struct page *page, unsigned int len, struct iattr *sattr,
3674 : : struct nfs4_label *label)
3675 : : {
3676 : : struct nfs4_createdata *data;
3677 : : int status = -ENAMETOOLONG;
3678 : :
3679 [ # # ]: 0 : if (len > NFS4_MAXPATHLEN)
3680 : : goto out;
3681 : :
3682 : : status = -ENOMEM;
3683 : 0 : data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4LNK);
3684 [ # # ]: 0 : if (data == NULL)
3685 : : goto out;
3686 : :
3687 : 0 : data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK];
3688 : 0 : data->arg.u.symlink.pages = &page;
3689 : 0 : data->arg.u.symlink.len = len;
3690 : 0 : data->arg.label = label;
3691 : :
3692 : 0 : status = nfs4_do_create(dir, dentry, data);
3693 : :
3694 : : nfs4_free_createdata(data);
3695 : : out:
3696 : 0 : return status;
3697 : : }
3698 : :
3699 : 0 : static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
3700 : : struct page *page, unsigned int len, struct iattr *sattr)
3701 : : {
3702 : 0 : struct nfs4_exception exception = { };
3703 : : struct nfs4_label l, *label = NULL;
3704 : : int err;
3705 : :
3706 : : label = nfs4_label_init_security(dir, dentry, sattr, &l);
3707 : :
3708 : : do {
3709 : 0 : err = _nfs4_proc_symlink(dir, dentry, page, len, sattr, label);
3710 : 0 : trace_nfs4_symlink(dir, &dentry->d_name, err);
3711 : 0 : err = nfs4_handle_exception(NFS_SERVER(dir), err,
3712 : : &exception);
3713 [ # # ]: 0 : } while (exception.retry);
3714 : :
3715 : : nfs4_label_release_security(label);
3716 : 0 : return err;
3717 : : }
3718 : :
3719 : 0 : static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
3720 : : struct iattr *sattr, struct nfs4_label *label)
3721 : : {
3722 : : struct nfs4_createdata *data;
3723 : : int status = -ENOMEM;
3724 : :
3725 : 0 : data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4DIR);
3726 [ # # ]: 0 : if (data == NULL)
3727 : : goto out;
3728 : :
3729 : 0 : data->arg.label = label;
3730 : 0 : status = nfs4_do_create(dir, dentry, data);
3731 : :
3732 : : nfs4_free_createdata(data);
3733 : : out:
3734 : 0 : return status;
3735 : : }
3736 : :
3737 : 0 : static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
3738 : : struct iattr *sattr)
3739 : : {
3740 : 0 : struct nfs4_exception exception = { };
3741 : : struct nfs4_label l, *label = NULL;
3742 : : int err;
3743 : :
3744 : : label = nfs4_label_init_security(dir, dentry, sattr, &l);
3745 : :
3746 : 0 : sattr->ia_mode &= ~current_umask();
3747 : : do {
3748 : 0 : err = _nfs4_proc_mkdir(dir, dentry, sattr, label);
3749 : 0 : trace_nfs4_mkdir(dir, &dentry->d_name, err);
3750 : 0 : err = nfs4_handle_exception(NFS_SERVER(dir), err,
3751 : : &exception);
3752 [ # # ]: 0 : } while (exception.retry);
3753 : : nfs4_label_release_security(label);
3754 : :
3755 : 0 : return err;
3756 : : }
3757 : :
3758 : 0 : static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
3759 : : u64 cookie, struct page **pages, unsigned int count, int plus)
3760 : : {
3761 : 0 : struct inode *dir = dentry->d_inode;
3762 : 0 : struct nfs4_readdir_arg args = {
3763 : 0 : .fh = NFS_FH(dir),
3764 : : .pages = pages,
3765 : : .pgbase = 0,
3766 : : .count = count,
3767 : 0 : .bitmask = NFS_SERVER(dentry->d_inode)->attr_bitmask,
3768 : : .plus = plus,
3769 : : };
3770 : : struct nfs4_readdir_res res;
3771 : 0 : struct rpc_message msg = {
3772 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR],
3773 : : .rpc_argp = &args,
3774 : : .rpc_resp = &res,
3775 : : .rpc_cred = cred,
3776 : : };
3777 : : int status;
3778 : :
3779 : : dprintk("%s: dentry = %pd2, cookie = %Lu\n", __func__,
3780 : : dentry,
3781 : : (unsigned long long)cookie);
3782 : 0 : nfs4_setup_readdir(cookie, NFS_I(dir)->cookieverf, dentry, &args);
3783 : 0 : res.pgbase = args.pgbase;
3784 : 0 : status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &msg, &args.seq_args, &res.seq_res, 0);
3785 [ # # ]: 0 : if (status >= 0) {
3786 : 0 : memcpy(NFS_I(dir)->cookieverf, res.verifier.data, NFS4_VERIFIER_SIZE);
3787 : 0 : status += args.pgbase;
3788 : : }
3789 : :
3790 : 0 : nfs_invalidate_atime(dir);
3791 : :
3792 : : dprintk("%s: returns %d\n", __func__, status);
3793 : 0 : return status;
3794 : : }
3795 : :
3796 : 0 : static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
3797 : : u64 cookie, struct page **pages, unsigned int count, int plus)
3798 : : {
3799 : 0 : struct nfs4_exception exception = { };
3800 : : int err;
3801 : : do {
3802 : 0 : err = _nfs4_proc_readdir(dentry, cred, cookie,
3803 : : pages, count, plus);
3804 : 0 : trace_nfs4_readdir(dentry->d_inode, err);
3805 : 0 : err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode), err,
3806 : : &exception);
3807 [ # # ]: 0 : } while (exception.retry);
3808 : 0 : return err;
3809 : : }
3810 : :
3811 : 0 : static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
3812 : : struct iattr *sattr, struct nfs4_label *label, dev_t rdev)
3813 : : {
3814 : : struct nfs4_createdata *data;
3815 : 0 : int mode = sattr->ia_mode;
3816 : : int status = -ENOMEM;
3817 : :
3818 : 0 : data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4SOCK);
3819 [ # # ]: 0 : if (data == NULL)
3820 : : goto out;
3821 : :
3822 [ # # ]: 0 : if (S_ISFIFO(mode))
3823 : 0 : data->arg.ftype = NF4FIFO;
3824 [ # # ]: 0 : else if (S_ISBLK(mode)) {
3825 : 0 : data->arg.ftype = NF4BLK;
3826 : 0 : data->arg.u.device.specdata1 = MAJOR(rdev);
3827 : 0 : data->arg.u.device.specdata2 = MINOR(rdev);
3828 : : }
3829 [ # # ]: 0 : else if (S_ISCHR(mode)) {
3830 : 0 : data->arg.ftype = NF4CHR;
3831 : 0 : data->arg.u.device.specdata1 = MAJOR(rdev);
3832 : 0 : data->arg.u.device.specdata2 = MINOR(rdev);
3833 [ # # ]: 0 : } else if (!S_ISSOCK(mode)) {
3834 : : status = -EINVAL;
3835 : : goto out_free;
3836 : : }
3837 : :
3838 : 0 : data->arg.label = label;
3839 : 0 : status = nfs4_do_create(dir, dentry, data);
3840 : : out_free:
3841 : : nfs4_free_createdata(data);
3842 : : out:
3843 : 0 : return status;
3844 : : }
3845 : :
3846 : 0 : static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
3847 : : struct iattr *sattr, dev_t rdev)
3848 : : {
3849 : 0 : struct nfs4_exception exception = { };
3850 : : struct nfs4_label l, *label = NULL;
3851 : : int err;
3852 : :
3853 : : label = nfs4_label_init_security(dir, dentry, sattr, &l);
3854 : :
3855 : 0 : sattr->ia_mode &= ~current_umask();
3856 : : do {
3857 : 0 : err = _nfs4_proc_mknod(dir, dentry, sattr, label, rdev);
3858 : 0 : trace_nfs4_mknod(dir, &dentry->d_name, err);
3859 : 0 : err = nfs4_handle_exception(NFS_SERVER(dir), err,
3860 : : &exception);
3861 [ # # ]: 0 : } while (exception.retry);
3862 : :
3863 : : nfs4_label_release_security(label);
3864 : :
3865 : 0 : return err;
3866 : : }
3867 : :
3868 : 0 : static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
3869 : : struct nfs_fsstat *fsstat)
3870 : : {
3871 : 0 : struct nfs4_statfs_arg args = {
3872 : : .fh = fhandle,
3873 : 0 : .bitmask = server->attr_bitmask,
3874 : : };
3875 : 0 : struct nfs4_statfs_res res = {
3876 : : .fsstat = fsstat,
3877 : : };
3878 : 0 : struct rpc_message msg = {
3879 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_STATFS],
3880 : : .rpc_argp = &args,
3881 : : .rpc_resp = &res,
3882 : : };
3883 : :
3884 : 0 : nfs_fattr_init(fsstat->fattr);
3885 : 0 : return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3886 : : }
3887 : :
3888 : 0 : static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *fsstat)
3889 : : {
3890 : 0 : struct nfs4_exception exception = { };
3891 : : int err;
3892 : : do {
3893 : 0 : err = nfs4_handle_exception(server,
3894 : : _nfs4_proc_statfs(server, fhandle, fsstat),
3895 : : &exception);
3896 [ # # ]: 0 : } while (exception.retry);
3897 : 0 : return err;
3898 : : }
3899 : :
3900 : 0 : static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
3901 : : struct nfs_fsinfo *fsinfo)
3902 : : {
3903 : 0 : struct nfs4_fsinfo_arg args = {
3904 : : .fh = fhandle,
3905 : 0 : .bitmask = server->attr_bitmask,
3906 : : };
3907 : 0 : struct nfs4_fsinfo_res res = {
3908 : : .fsinfo = fsinfo,
3909 : : };
3910 : 0 : struct rpc_message msg = {
3911 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSINFO],
3912 : : .rpc_argp = &args,
3913 : : .rpc_resp = &res,
3914 : : };
3915 : :
3916 : 0 : return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3917 : : }
3918 : :
3919 : 0 : static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
3920 : : {
3921 : 0 : struct nfs4_exception exception = { };
3922 : 0 : unsigned long now = jiffies;
3923 : : int err;
3924 : :
3925 : : do {
3926 : 0 : err = _nfs4_do_fsinfo(server, fhandle, fsinfo);
3927 : 0 : trace_nfs4_fsinfo(server, fhandle, fsinfo->fattr, err);
3928 [ # # ]: 0 : if (err == 0) {
3929 : 0 : struct nfs_client *clp = server->nfs_client;
3930 : :
3931 : : spin_lock(&clp->cl_lock);
3932 : 0 : clp->cl_lease_time = fsinfo->lease_time * HZ;
3933 : 0 : clp->cl_last_renewal = now;
3934 : : spin_unlock(&clp->cl_lock);
3935 : : break;
3936 : : }
3937 : 0 : err = nfs4_handle_exception(server, err, &exception);
3938 [ # # ]: 0 : } while (exception.retry);
3939 : 0 : return err;
3940 : : }
3941 : :
3942 : 0 : static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
3943 : : {
3944 : : int error;
3945 : :
3946 : 0 : nfs_fattr_init(fsinfo->fattr);
3947 : 0 : error = nfs4_do_fsinfo(server, fhandle, fsinfo);
3948 [ # # ]: 0 : if (error == 0) {
3949 : : /* block layout checks this! */
3950 : 0 : server->pnfs_blksize = fsinfo->blksize;
3951 : : set_pnfs_layoutdriver(server, fhandle, fsinfo->layouttype);
3952 : : }
3953 : :
3954 : 0 : return error;
3955 : : }
3956 : :
3957 : 0 : static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
3958 : : struct nfs_pathconf *pathconf)
3959 : : {
3960 : 0 : struct nfs4_pathconf_arg args = {
3961 : : .fh = fhandle,
3962 : 0 : .bitmask = server->attr_bitmask,
3963 : : };
3964 : 0 : struct nfs4_pathconf_res res = {
3965 : : .pathconf = pathconf,
3966 : : };
3967 : 0 : struct rpc_message msg = {
3968 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_PATHCONF],
3969 : : .rpc_argp = &args,
3970 : : .rpc_resp = &res,
3971 : : };
3972 : :
3973 : : /* None of the pathconf attributes are mandatory to implement */
3974 [ # # ]: 0 : if ((args.bitmask[0] & nfs4_pathconf_bitmap[0]) == 0) {
3975 : 0 : memset(pathconf, 0, sizeof(*pathconf));
3976 : 0 : return 0;
3977 : : }
3978 : :
3979 : 0 : nfs_fattr_init(pathconf->fattr);
3980 : 0 : return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3981 : : }
3982 : :
3983 : 0 : static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
3984 : : struct nfs_pathconf *pathconf)
3985 : : {
3986 : 0 : struct nfs4_exception exception = { };
3987 : : int err;
3988 : :
3989 : : do {
3990 : 0 : err = nfs4_handle_exception(server,
3991 : : _nfs4_proc_pathconf(server, fhandle, pathconf),
3992 : : &exception);
3993 [ # # ]: 0 : } while (exception.retry);
3994 : 0 : return err;
3995 : : }
3996 : :
3997 : 0 : int nfs4_set_rw_stateid(nfs4_stateid *stateid,
3998 : : const struct nfs_open_context *ctx,
3999 : : const struct nfs_lock_context *l_ctx,
4000 : : fmode_t fmode)
4001 : : {
4002 : : const struct nfs_lockowner *lockowner = NULL;
4003 : :
4004 [ # # ][ # # ]: 0 : if (l_ctx != NULL)
[ # # ][ # # ]
4005 : 0 : lockowner = &l_ctx->lockowner;
4006 : 0 : return nfs4_select_rw_stateid(stateid, ctx->state, fmode, lockowner);
4007 : : }
4008 : : EXPORT_SYMBOL_GPL(nfs4_set_rw_stateid);
4009 : :
4010 : 0 : static bool nfs4_stateid_is_current(nfs4_stateid *stateid,
4011 : : const struct nfs_open_context *ctx,
4012 : : const struct nfs_lock_context *l_ctx,
4013 : : fmode_t fmode)
4014 : : {
4015 : : nfs4_stateid current_stateid;
4016 : :
4017 : : /* If the current stateid represents a lost lock, then exit */
4018 [ # # ]: 0 : if (nfs4_set_rw_stateid(¤t_stateid, ctx, l_ctx, fmode) == -EIO)
4019 : : return true;
4020 : : return nfs4_stateid_match(stateid, ¤t_stateid);
4021 : : }
4022 : :
4023 : : static bool nfs4_error_stateid_expired(int err)
4024 : : {
4025 [ # # ][ # # ]: 0 : switch (err) {
4026 : : case -NFS4ERR_DELEG_REVOKED:
4027 : : case -NFS4ERR_ADMIN_REVOKED:
4028 : : case -NFS4ERR_BAD_STATEID:
4029 : : case -NFS4ERR_STALE_STATEID:
4030 : : case -NFS4ERR_OLD_STATEID:
4031 : : case -NFS4ERR_OPENMODE:
4032 : : case -NFS4ERR_EXPIRED:
4033 : : return true;
4034 : : }
4035 : : return false;
4036 : : }
4037 : :
4038 : 0 : void __nfs4_read_done_cb(struct nfs_read_data *data)
4039 : : {
4040 : 0 : nfs_invalidate_atime(data->header->inode);
4041 : 0 : }
4042 : :
4043 : 0 : static int nfs4_read_done_cb(struct rpc_task *task, struct nfs_read_data *data)
4044 : : {
4045 : 0 : struct nfs_server *server = NFS_SERVER(data->header->inode);
4046 : :
4047 : 0 : trace_nfs4_read(data, task->tk_status);
4048 [ # # ]: 0 : if (nfs4_async_handle_error(task, server, data->args.context->state) == -EAGAIN) {
4049 : 0 : rpc_restart_call_prepare(task);
4050 : 0 : return -EAGAIN;
4051 : : }
4052 : :
4053 : : __nfs4_read_done_cb(data);
4054 [ # # ]: 0 : if (task->tk_status > 0)
4055 : 0 : renew_lease(server, data->timestamp);
4056 : : return 0;
4057 : : }
4058 : :
4059 : 0 : static bool nfs4_read_stateid_changed(struct rpc_task *task,
4060 : : struct nfs_readargs *args)
4061 : : {
4062 : :
4063 [ # # # # ]: 0 : if (!nfs4_error_stateid_expired(task->tk_status) ||
4064 : 0 : nfs4_stateid_is_current(&args->stateid,
4065 : 0 : args->context,
4066 : 0 : args->lock_context,
4067 : : FMODE_READ))
4068 : : return false;
4069 : 0 : rpc_restart_call_prepare(task);
4070 : 0 : return true;
4071 : : }
4072 : :
4073 : 0 : static int nfs4_read_done(struct rpc_task *task, struct nfs_read_data *data)
4074 : : {
4075 : :
4076 : : dprintk("--> %s\n", __func__);
4077 : :
4078 [ # # ]: 0 : if (!nfs4_sequence_done(task, &data->res.seq_res))
4079 : : return -EAGAIN;
4080 [ # # ]: 0 : if (nfs4_read_stateid_changed(task, &data->args))
4081 : : return -EAGAIN;
4082 [ # # ]: 0 : return data->read_done_cb ? data->read_done_cb(task, data) :
4083 : : nfs4_read_done_cb(task, data);
4084 : : }
4085 : :
4086 : 0 : static void nfs4_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg)
4087 : : {
4088 : 0 : data->timestamp = jiffies;
4089 : 0 : data->read_done_cb = nfs4_read_done_cb;
4090 : 0 : msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ];
4091 : : nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0);
4092 : 0 : }
4093 : :
4094 : 0 : static int nfs4_proc_read_rpc_prepare(struct rpc_task *task, struct nfs_read_data *data)
4095 : : {
4096 [ # # ]: 0 : if (nfs4_setup_sequence(NFS_SERVER(data->header->inode),
4097 : : &data->args.seq_args,
4098 : : &data->res.seq_res,
4099 : : task))
4100 : : return 0;
4101 [ # # ]: 0 : if (nfs4_set_rw_stateid(&data->args.stateid, data->args.context,
4102 : 0 : data->args.lock_context, FMODE_READ) == -EIO)
4103 : : return -EIO;
4104 [ # # ]: 0 : if (unlikely(test_bit(NFS_CONTEXT_BAD, &data->args.context->flags)))
4105 : : return -EIO;
4106 : 0 : return 0;
4107 : : }
4108 : :
4109 : 0 : static int nfs4_write_done_cb(struct rpc_task *task, struct nfs_write_data *data)
4110 : : {
4111 : 0 : struct inode *inode = data->header->inode;
4112 : :
4113 : 0 : trace_nfs4_write(data, task->tk_status);
4114 [ # # ]: 0 : if (nfs4_async_handle_error(task, NFS_SERVER(inode), data->args.context->state) == -EAGAIN) {
4115 : 0 : rpc_restart_call_prepare(task);
4116 : 0 : return -EAGAIN;
4117 : : }
4118 [ # # ]: 0 : if (task->tk_status >= 0) {
4119 : 0 : renew_lease(NFS_SERVER(inode), data->timestamp);
4120 : 0 : nfs_post_op_update_inode_force_wcc(inode, &data->fattr);
4121 : : }
4122 : : return 0;
4123 : : }
4124 : :
4125 : 0 : static bool nfs4_write_stateid_changed(struct rpc_task *task,
4126 : : struct nfs_writeargs *args)
4127 : : {
4128 : :
4129 [ # # # # ]: 0 : if (!nfs4_error_stateid_expired(task->tk_status) ||
4130 : 0 : nfs4_stateid_is_current(&args->stateid,
4131 : 0 : args->context,
4132 : 0 : args->lock_context,
4133 : : FMODE_WRITE))
4134 : : return false;
4135 : 0 : rpc_restart_call_prepare(task);
4136 : 0 : return true;
4137 : : }
4138 : :
4139 : 0 : static int nfs4_write_done(struct rpc_task *task, struct nfs_write_data *data)
4140 : : {
4141 [ # # ]: 0 : if (!nfs4_sequence_done(task, &data->res.seq_res))
4142 : : return -EAGAIN;
4143 [ # # ]: 0 : if (nfs4_write_stateid_changed(task, &data->args))
4144 : : return -EAGAIN;
4145 [ # # ]: 0 : return data->write_done_cb ? data->write_done_cb(task, data) :
4146 : : nfs4_write_done_cb(task, data);
4147 : : }
4148 : :
4149 : : static
4150 : 0 : bool nfs4_write_need_cache_consistency_data(const struct nfs_write_data *data)
4151 : : {
4152 : 0 : const struct nfs_pgio_header *hdr = data->header;
4153 : :
4154 : : /* Don't request attributes for pNFS or O_DIRECT writes */
4155 [ # # ][ # # ]: 0 : if (data->ds_clp != NULL || hdr->dreq != NULL)
4156 : : return false;
4157 : : /* Otherwise, request attributes if and only if we don't hold
4158 : : * a delegation
4159 : : */
4160 : 0 : return nfs4_have_delegation(hdr->inode, FMODE_READ) == 0;
4161 : : }
4162 : :
4163 : 0 : static void nfs4_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg)
4164 : : {
4165 : 0 : struct nfs_server *server = NFS_SERVER(data->header->inode);
4166 : :
4167 [ # # ]: 0 : if (!nfs4_write_need_cache_consistency_data(data)) {
4168 : 0 : data->args.bitmask = NULL;
4169 : 0 : data->res.fattr = NULL;
4170 : : } else
4171 : 0 : data->args.bitmask = server->cache_consistency_bitmask;
4172 : :
4173 [ # # ]: 0 : if (!data->write_done_cb)
4174 : 0 : data->write_done_cb = nfs4_write_done_cb;
4175 : 0 : data->res.server = server;
4176 : 0 : data->timestamp = jiffies;
4177 : :
4178 : 0 : msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE];
4179 : : nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
4180 : 0 : }
4181 : :
4182 : 0 : static int nfs4_proc_write_rpc_prepare(struct rpc_task *task, struct nfs_write_data *data)
4183 : : {
4184 [ # # ]: 0 : if (nfs4_setup_sequence(NFS_SERVER(data->header->inode),
4185 : : &data->args.seq_args,
4186 : : &data->res.seq_res,
4187 : : task))
4188 : : return 0;
4189 [ # # ]: 0 : if (nfs4_set_rw_stateid(&data->args.stateid, data->args.context,
4190 : 0 : data->args.lock_context, FMODE_WRITE) == -EIO)
4191 : : return -EIO;
4192 [ # # ]: 0 : if (unlikely(test_bit(NFS_CONTEXT_BAD, &data->args.context->flags)))
4193 : : return -EIO;
4194 : 0 : return 0;
4195 : : }
4196 : :
4197 : 0 : static void nfs4_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
4198 : : {
4199 : 0 : nfs4_setup_sequence(NFS_SERVER(data->inode),
4200 : : &data->args.seq_args,
4201 : : &data->res.seq_res,
4202 : : task);
4203 : 0 : }
4204 : :
4205 : 0 : static int nfs4_commit_done_cb(struct rpc_task *task, struct nfs_commit_data *data)
4206 : : {
4207 : 0 : struct inode *inode = data->inode;
4208 : :
4209 : 0 : trace_nfs4_commit(data, task->tk_status);
4210 [ # # ]: 0 : if (nfs4_async_handle_error(task, NFS_SERVER(inode), NULL) == -EAGAIN) {
4211 : 0 : rpc_restart_call_prepare(task);
4212 : 0 : return -EAGAIN;
4213 : : }
4214 : : return 0;
4215 : : }
4216 : :
4217 : 0 : static int nfs4_commit_done(struct rpc_task *task, struct nfs_commit_data *data)
4218 : : {
4219 [ # # ]: 0 : if (!nfs4_sequence_done(task, &data->res.seq_res))
4220 : : return -EAGAIN;
4221 : 0 : return data->commit_done_cb(task, data);
4222 : : }
4223 : :
4224 : 0 : static void nfs4_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
4225 : : {
4226 : 0 : struct nfs_server *server = NFS_SERVER(data->inode);
4227 : :
4228 [ # # ]: 0 : if (data->commit_done_cb == NULL)
4229 : 0 : data->commit_done_cb = nfs4_commit_done_cb;
4230 : 0 : data->res.server = server;
4231 : 0 : msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT];
4232 : : nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
4233 : 0 : }
4234 : :
4235 : : struct nfs4_renewdata {
4236 : : struct nfs_client *client;
4237 : : unsigned long timestamp;
4238 : : };
4239 : :
4240 : : /*
4241 : : * nfs4_proc_async_renew(): This is not one of the nfs_rpc_ops; it is a special
4242 : : * standalone procedure for queueing an asynchronous RENEW.
4243 : : */
4244 : 0 : static void nfs4_renew_release(void *calldata)
4245 : : {
4246 : : struct nfs4_renewdata *data = calldata;
4247 : 0 : struct nfs_client *clp = data->client;
4248 : :
4249 [ # # ]: 0 : if (atomic_read(&clp->cl_count) > 1)
4250 : 0 : nfs4_schedule_state_renewal(clp);
4251 : 0 : nfs_put_client(clp);
4252 : 0 : kfree(data);
4253 : 0 : }
4254 : :
4255 : 0 : static void nfs4_renew_done(struct rpc_task *task, void *calldata)
4256 : : {
4257 : : struct nfs4_renewdata *data = calldata;
4258 : 0 : struct nfs_client *clp = data->client;
4259 : 0 : unsigned long timestamp = data->timestamp;
4260 : :
4261 : 0 : trace_nfs4_renew_async(clp, task->tk_status);
4262 [ # # # ]: 0 : switch (task->tk_status) {
4263 : : case 0:
4264 : : break;
4265 : : case -NFS4ERR_LEASE_MOVED:
4266 : 0 : nfs4_schedule_lease_moved_recovery(clp);
4267 : 0 : break;
4268 : : default:
4269 : : /* Unless we're shutting down, schedule state recovery! */
4270 [ # # ]: 0 : if (test_bit(NFS_CS_RENEWD, &clp->cl_res_state) == 0)
4271 : : return;
4272 [ # # ]: 0 : if (task->tk_status != NFS4ERR_CB_PATH_DOWN) {
4273 : 0 : nfs4_schedule_lease_recovery(clp);
4274 : 0 : return;
4275 : : }
4276 : 0 : nfs4_schedule_path_down_recovery(clp);
4277 : : }
4278 : 0 : do_renew_lease(clp, timestamp);
4279 : : }
4280 : :
4281 : : static const struct rpc_call_ops nfs4_renew_ops = {
4282 : : .rpc_call_done = nfs4_renew_done,
4283 : : .rpc_release = nfs4_renew_release,
4284 : : };
4285 : :
4286 : 0 : static int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags)
4287 : : {
4288 : 0 : struct rpc_message msg = {
4289 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
4290 : : .rpc_argp = clp,
4291 : : .rpc_cred = cred,
4292 : : };
4293 : : struct nfs4_renewdata *data;
4294 : :
4295 [ # # ]: 0 : if (renew_flags == 0)
4296 : : return 0;
4297 [ # # ]: 0 : if (!atomic_inc_not_zero(&clp->cl_count))
4298 : : return -EIO;
4299 : : data = kmalloc(sizeof(*data), GFP_NOFS);
4300 [ # # ]: 0 : if (data == NULL)
4301 : : return -ENOMEM;
4302 : 0 : data->client = clp;
4303 : 0 : data->timestamp = jiffies;
4304 : 0 : return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT,
4305 : : &nfs4_renew_ops, data);
4306 : : }
4307 : :
4308 : 0 : static int nfs4_proc_renew(struct nfs_client *clp, struct rpc_cred *cred)
4309 : : {
4310 : 0 : struct rpc_message msg = {
4311 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
4312 : : .rpc_argp = clp,
4313 : : .rpc_cred = cred,
4314 : : };
4315 : 0 : unsigned long now = jiffies;
4316 : : int status;
4317 : :
4318 : 0 : status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
4319 [ # # ]: 0 : if (status < 0)
4320 : : return status;
4321 : 0 : do_renew_lease(clp, now);
4322 : 0 : return 0;
4323 : : }
4324 : :
4325 : : static inline int nfs4_server_supports_acls(struct nfs_server *server)
4326 : : {
4327 : 0 : return server->caps & NFS_CAP_ACLS;
4328 : : }
4329 : :
4330 : : /* Assuming that XATTR_SIZE_MAX is a multiple of PAGE_SIZE, and that
4331 : : * it's OK to put sizeof(void) * (XATTR_SIZE_MAX/PAGE_SIZE) bytes on
4332 : : * the stack.
4333 : : */
4334 : : #define NFS4ACL_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE)
4335 : :
4336 : 0 : static int buf_to_pages_noslab(const void *buf, size_t buflen,
4337 : : struct page **pages, unsigned int *pgbase)
4338 : : {
4339 : : struct page *newpage, **spages;
4340 : : int rc = 0;
4341 : : size_t len;
4342 : : spages = pages;
4343 : :
4344 : : do {
4345 : 0 : len = min_t(size_t, PAGE_SIZE, buflen);
4346 : : newpage = alloc_page(GFP_KERNEL);
4347 : :
4348 [ # # ]: 0 : if (newpage == NULL)
4349 : : goto unwind;
4350 : 0 : memcpy(page_address(newpage), buf, len);
4351 : 0 : buf += len;
4352 : 0 : buflen -= len;
4353 : 0 : *pages++ = newpage;
4354 : 0 : rc++;
4355 [ # # ]: 0 : } while (buflen != 0);
4356 : :
4357 : : return rc;
4358 : :
4359 : : unwind:
4360 [ # # ]: 0 : for(; rc > 0; rc--)
4361 : 0 : __free_page(spages[rc-1]);
4362 : : return -ENOMEM;
4363 : : }
4364 : :
4365 : : struct nfs4_cached_acl {
4366 : : int cached;
4367 : : size_t len;
4368 : : char data[0];
4369 : : };
4370 : :
4371 : 0 : static void nfs4_set_cached_acl(struct inode *inode, struct nfs4_cached_acl *acl)
4372 : : {
4373 : : struct nfs_inode *nfsi = NFS_I(inode);
4374 : :
4375 : : spin_lock(&inode->i_lock);
4376 : 0 : kfree(nfsi->nfs4_acl);
4377 : 0 : nfsi->nfs4_acl = acl;
4378 : : spin_unlock(&inode->i_lock);
4379 : 0 : }
4380 : :
4381 : 0 : static void nfs4_zap_acl_attr(struct inode *inode)
4382 : : {
4383 : 0 : nfs4_set_cached_acl(inode, NULL);
4384 : 0 : }
4385 : :
4386 : : static inline ssize_t nfs4_read_cached_acl(struct inode *inode, char *buf, size_t buflen)
4387 : : {
4388 : : struct nfs_inode *nfsi = NFS_I(inode);
4389 : : struct nfs4_cached_acl *acl;
4390 : : int ret = -ENOENT;
4391 : :
4392 : : spin_lock(&inode->i_lock);
4393 : 0 : acl = nfsi->nfs4_acl;
4394 [ # # ]: 0 : if (acl == NULL)
4395 : : goto out;
4396 [ # # ]: 0 : if (buf == NULL) /* user is just asking for length */
4397 : : goto out_len;
4398 [ # # ]: 0 : if (acl->cached == 0)
4399 : : goto out;
4400 : : ret = -ERANGE; /* see getxattr(2) man page */
4401 [ # # ]: 0 : if (acl->len > buflen)
4402 : : goto out;
4403 : 0 : memcpy(buf, acl->data, acl->len);
4404 : : out_len:
4405 : 0 : ret = acl->len;
4406 : : out:
4407 : : spin_unlock(&inode->i_lock);
4408 : : return ret;
4409 : : }
4410 : :
4411 : 0 : static void nfs4_write_cached_acl(struct inode *inode, struct page **pages, size_t pgbase, size_t acl_len)
4412 : : {
4413 : : struct nfs4_cached_acl *acl;
4414 : 0 : size_t buflen = sizeof(*acl) + acl_len;
4415 : :
4416 [ # # ]: 0 : if (buflen <= PAGE_SIZE) {
4417 : : acl = kmalloc(buflen, GFP_KERNEL);
4418 [ # # ]: 0 : if (acl == NULL)
4419 : : goto out;
4420 : 0 : acl->cached = 1;
4421 : 0 : _copy_from_pages(acl->data, pages, pgbase, acl_len);
4422 : : } else {
4423 : : acl = kmalloc(sizeof(*acl), GFP_KERNEL);
4424 [ # # ]: 0 : if (acl == NULL)
4425 : : goto out;
4426 : 0 : acl->cached = 0;
4427 : : }
4428 : 0 : acl->len = acl_len;
4429 : : out:
4430 : 0 : nfs4_set_cached_acl(inode, acl);
4431 : 0 : }
4432 : :
4433 : : /*
4434 : : * The getxattr API returns the required buffer length when called with a
4435 : : * NULL buf. The NFSv4 acl tool then calls getxattr again after allocating
4436 : : * the required buf. On a NULL buf, we send a page of data to the server
4437 : : * guessing that the ACL request can be serviced by a page. If so, we cache
4438 : : * up to the page of ACL data, and the 2nd call to getxattr is serviced by
4439 : : * the cache. If not so, we throw away the page, and cache the required
4440 : : * length. The next getxattr call will then produce another round trip to
4441 : : * the server, this time with the input buf of the required size.
4442 : : */
4443 : 0 : static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
4444 : : {
4445 : 0 : struct page *pages[NFS4ACL_MAXPAGES] = {NULL, };
4446 : 0 : struct nfs_getaclargs args = {
4447 : 0 : .fh = NFS_FH(inode),
4448 : : .acl_pages = pages,
4449 : : .acl_len = buflen,
4450 : : };
4451 : 0 : struct nfs_getaclres res = {
4452 : : .acl_len = buflen,
4453 : : };
4454 : 0 : struct rpc_message msg = {
4455 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETACL],
4456 : : .rpc_argp = &args,
4457 : : .rpc_resp = &res,
4458 : : };
4459 : 0 : unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE);
4460 : : int ret = -ENOMEM, i;
4461 : :
4462 : : /* As long as we're doing a round trip to the server anyway,
4463 : : * let's be prepared for a page of acl data. */
4464 [ # # ]: 0 : if (npages == 0)
4465 : : npages = 1;
4466 [ # # ]: 0 : if (npages > ARRAY_SIZE(pages))
4467 : : return -ERANGE;
4468 : :
4469 [ # # ]: 0 : for (i = 0; i < npages; i++) {
4470 : 0 : pages[i] = alloc_page(GFP_KERNEL);
4471 [ # # ]: 0 : if (!pages[i])
4472 : : goto out_free;
4473 : : }
4474 : :
4475 : : /* for decoding across pages */
4476 : 0 : res.acl_scratch = alloc_page(GFP_KERNEL);
4477 [ # # ]: 0 : if (!res.acl_scratch)
4478 : : goto out_free;
4479 : :
4480 : 0 : args.acl_len = npages * PAGE_SIZE;
4481 : 0 : args.acl_pgbase = 0;
4482 : :
4483 : : dprintk("%s buf %p buflen %zu npages %d args.acl_len %zu\n",
4484 : : __func__, buf, buflen, npages, args.acl_len);
4485 : 0 : ret = nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode),
4486 : : &msg, &args.seq_args, &res.seq_res, 0);
4487 [ # # ]: 0 : if (ret)
4488 : : goto out_free;
4489 : :
4490 : : /* Handle the case where the passed-in buffer is too short */
4491 [ # # ]: 0 : if (res.acl_flags & NFS4_ACL_TRUNC) {
4492 : : /* Did the user only issue a request for the acl length? */
4493 [ # # ]: 0 : if (buf == NULL)
4494 : : goto out_ok;
4495 : : ret = -ERANGE;
4496 : : goto out_free;
4497 : : }
4498 : 0 : nfs4_write_cached_acl(inode, pages, res.acl_data_offset, res.acl_len);
4499 [ # # ]: 0 : if (buf) {
4500 [ # # ]: 0 : if (res.acl_len > buflen) {
4501 : : ret = -ERANGE;
4502 : : goto out_free;
4503 : : }
4504 : 0 : _copy_from_pages(buf, pages, res.acl_data_offset, res.acl_len);
4505 : : }
4506 : : out_ok:
4507 : 0 : ret = res.acl_len;
4508 : : out_free:
4509 [ # # ]: 0 : for (i = 0; i < npages; i++)
4510 [ # # ]: 0 : if (pages[i])
4511 : 0 : __free_page(pages[i]);
4512 [ # # ]: 0 : if (res.acl_scratch)
4513 : 0 : __free_page(res.acl_scratch);
4514 : 0 : return ret;
4515 : : }
4516 : :
4517 : 0 : static ssize_t nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
4518 : : {
4519 : 0 : struct nfs4_exception exception = { };
4520 : : ssize_t ret;
4521 : : do {
4522 : 0 : ret = __nfs4_get_acl_uncached(inode, buf, buflen);
4523 : : trace_nfs4_get_acl(inode, ret);
4524 [ # # ]: 0 : if (ret >= 0)
4525 : : break;
4526 : 0 : ret = nfs4_handle_exception(NFS_SERVER(inode), ret, &exception);
4527 [ # # ]: 0 : } while (exception.retry);
4528 : 0 : return ret;
4529 : : }
4530 : :
4531 : 0 : static ssize_t nfs4_proc_get_acl(struct inode *inode, void *buf, size_t buflen)
4532 : : {
4533 : 0 : struct nfs_server *server = NFS_SERVER(inode);
4534 : : int ret;
4535 : :
4536 [ # # ]: 0 : if (!nfs4_server_supports_acls(server))
4537 : : return -EOPNOTSUPP;
4538 : 0 : ret = nfs_revalidate_inode(server, inode);
4539 [ # # ]: 0 : if (ret < 0)
4540 : : return ret;
4541 [ # # ]: 0 : if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL)
4542 : 0 : nfs_zap_acl_cache(inode);
4543 : : ret = nfs4_read_cached_acl(inode, buf, buflen);
4544 [ # # ]: 0 : if (ret != -ENOENT)
4545 : : /* -ENOENT is returned if there is no ACL or if there is an ACL
4546 : : * but no cached acl data, just the acl length */
4547 : : return ret;
4548 : 0 : return nfs4_get_acl_uncached(inode, buf, buflen);
4549 : : }
4550 : :
4551 : 0 : static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
4552 : : {
4553 : 0 : struct nfs_server *server = NFS_SERVER(inode);
4554 : : struct page *pages[NFS4ACL_MAXPAGES];
4555 : 0 : struct nfs_setaclargs arg = {
4556 : 0 : .fh = NFS_FH(inode),
4557 : : .acl_pages = pages,
4558 : : .acl_len = buflen,
4559 : : };
4560 : : struct nfs_setaclres res;
4561 : 0 : struct rpc_message msg = {
4562 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETACL],
4563 : : .rpc_argp = &arg,
4564 : : .rpc_resp = &res,
4565 : : };
4566 : 0 : unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE);
4567 : : int ret, i;
4568 : :
4569 [ # # ]: 0 : if (!nfs4_server_supports_acls(server))
4570 : : return -EOPNOTSUPP;
4571 [ # # ]: 0 : if (npages > ARRAY_SIZE(pages))
4572 : : return -ERANGE;
4573 : 0 : i = buf_to_pages_noslab(buf, buflen, arg.acl_pages, &arg.acl_pgbase);
4574 [ # # ]: 0 : if (i < 0)
4575 : : return i;
4576 : 0 : nfs4_inode_return_delegation(inode);
4577 : 0 : ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
4578 : :
4579 : : /*
4580 : : * Free each page after tx, so the only ref left is
4581 : : * held by the network stack
4582 : : */
4583 [ # # ]: 0 : for (; i > 0; i--)
4584 : 0 : put_page(pages[i-1]);
4585 : :
4586 : : /*
4587 : : * Acl update can result in inode attribute update.
4588 : : * so mark the attribute cache invalid.
4589 : : */
4590 : : spin_lock(&inode->i_lock);
4591 : 0 : NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR;
4592 : : spin_unlock(&inode->i_lock);
4593 : 0 : nfs_access_zap_cache(inode);
4594 : 0 : nfs_zap_acl_cache(inode);
4595 : 0 : return ret;
4596 : : }
4597 : :
4598 : 0 : static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
4599 : : {
4600 : 0 : struct nfs4_exception exception = { };
4601 : : int err;
4602 : : do {
4603 : 0 : err = __nfs4_proc_set_acl(inode, buf, buflen);
4604 : : trace_nfs4_set_acl(inode, err);
4605 : 0 : err = nfs4_handle_exception(NFS_SERVER(inode), err,
4606 : : &exception);
4607 [ # # ]: 0 : } while (exception.retry);
4608 : 0 : return err;
4609 : : }
4610 : :
4611 : : #ifdef CONFIG_NFS_V4_SECURITY_LABEL
4612 : : static int _nfs4_get_security_label(struct inode *inode, void *buf,
4613 : : size_t buflen)
4614 : : {
4615 : : struct nfs_server *server = NFS_SERVER(inode);
4616 : : struct nfs_fattr fattr;
4617 : : struct nfs4_label label = {0, 0, buflen, buf};
4618 : :
4619 : : u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL };
4620 : : struct nfs4_getattr_arg arg = {
4621 : : .fh = NFS_FH(inode),
4622 : : .bitmask = bitmask,
4623 : : };
4624 : : struct nfs4_getattr_res res = {
4625 : : .fattr = &fattr,
4626 : : .label = &label,
4627 : : .server = server,
4628 : : };
4629 : : struct rpc_message msg = {
4630 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
4631 : : .rpc_argp = &arg,
4632 : : .rpc_resp = &res,
4633 : : };
4634 : : int ret;
4635 : :
4636 : : nfs_fattr_init(&fattr);
4637 : :
4638 : : ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 0);
4639 : : if (ret)
4640 : : return ret;
4641 : : if (!(fattr.valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL))
4642 : : return -ENOENT;
4643 : : if (buflen < label.len)
4644 : : return -ERANGE;
4645 : : return 0;
4646 : : }
4647 : :
4648 : : static int nfs4_get_security_label(struct inode *inode, void *buf,
4649 : : size_t buflen)
4650 : : {
4651 : : struct nfs4_exception exception = { };
4652 : : int err;
4653 : :
4654 : : if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
4655 : : return -EOPNOTSUPP;
4656 : :
4657 : : do {
4658 : : err = _nfs4_get_security_label(inode, buf, buflen);
4659 : : trace_nfs4_get_security_label(inode, err);
4660 : : err = nfs4_handle_exception(NFS_SERVER(inode), err,
4661 : : &exception);
4662 : : } while (exception.retry);
4663 : : return err;
4664 : : }
4665 : :
4666 : : static int _nfs4_do_set_security_label(struct inode *inode,
4667 : : struct nfs4_label *ilabel,
4668 : : struct nfs_fattr *fattr,
4669 : : struct nfs4_label *olabel)
4670 : : {
4671 : :
4672 : : struct iattr sattr = {0};
4673 : : struct nfs_server *server = NFS_SERVER(inode);
4674 : : const u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL };
4675 : : struct nfs_setattrargs arg = {
4676 : : .fh = NFS_FH(inode),
4677 : : .iap = &sattr,
4678 : : .server = server,
4679 : : .bitmask = bitmask,
4680 : : .label = ilabel,
4681 : : };
4682 : : struct nfs_setattrres res = {
4683 : : .fattr = fattr,
4684 : : .label = olabel,
4685 : : .server = server,
4686 : : };
4687 : : struct rpc_message msg = {
4688 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
4689 : : .rpc_argp = &arg,
4690 : : .rpc_resp = &res,
4691 : : };
4692 : : int status;
4693 : :
4694 : : nfs4_stateid_copy(&arg.stateid, &zero_stateid);
4695 : :
4696 : : status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
4697 : : if (status)
4698 : : dprintk("%s failed: %d\n", __func__, status);
4699 : :
4700 : : return status;
4701 : : }
4702 : :
4703 : : static int nfs4_do_set_security_label(struct inode *inode,
4704 : : struct nfs4_label *ilabel,
4705 : : struct nfs_fattr *fattr,
4706 : : struct nfs4_label *olabel)
4707 : : {
4708 : : struct nfs4_exception exception = { };
4709 : : int err;
4710 : :
4711 : : do {
4712 : : err = _nfs4_do_set_security_label(inode, ilabel,
4713 : : fattr, olabel);
4714 : : trace_nfs4_set_security_label(inode, err);
4715 : : err = nfs4_handle_exception(NFS_SERVER(inode), err,
4716 : : &exception);
4717 : : } while (exception.retry);
4718 : : return err;
4719 : : }
4720 : :
4721 : : static int
4722 : : nfs4_set_security_label(struct dentry *dentry, const void *buf, size_t buflen)
4723 : : {
4724 : : struct nfs4_label ilabel, *olabel = NULL;
4725 : : struct nfs_fattr fattr;
4726 : : struct rpc_cred *cred;
4727 : : struct inode *inode = dentry->d_inode;
4728 : : int status;
4729 : :
4730 : : if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
4731 : : return -EOPNOTSUPP;
4732 : :
4733 : : nfs_fattr_init(&fattr);
4734 : :
4735 : : ilabel.pi = 0;
4736 : : ilabel.lfs = 0;
4737 : : ilabel.label = (char *)buf;
4738 : : ilabel.len = buflen;
4739 : :
4740 : : cred = rpc_lookup_cred();
4741 : : if (IS_ERR(cred))
4742 : : return PTR_ERR(cred);
4743 : :
4744 : : olabel = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
4745 : : if (IS_ERR(olabel)) {
4746 : : status = -PTR_ERR(olabel);
4747 : : goto out;
4748 : : }
4749 : :
4750 : : status = nfs4_do_set_security_label(inode, &ilabel, &fattr, olabel);
4751 : : if (status == 0)
4752 : : nfs_setsecurity(inode, &fattr, olabel);
4753 : :
4754 : : nfs4_label_free(olabel);
4755 : : out:
4756 : : put_rpccred(cred);
4757 : : return status;
4758 : : }
4759 : : #endif /* CONFIG_NFS_V4_SECURITY_LABEL */
4760 : :
4761 : :
4762 : : static int
4763 : 0 : nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server, struct nfs4_state *state)
4764 : : {
4765 : 0 : struct nfs_client *clp = server->nfs_client;
4766 : :
4767 [ # # ]: 0 : if (task->tk_status >= 0)
4768 : : return 0;
4769 [ # # # # : 0 : switch(task->tk_status) {
# # # # #
# ]
4770 : : case -NFS4ERR_DELEG_REVOKED:
4771 : : case -NFS4ERR_ADMIN_REVOKED:
4772 : : case -NFS4ERR_BAD_STATEID:
4773 [ # # ]: 0 : if (state == NULL)
4774 : : break;
4775 : 0 : nfs_remove_bad_delegation(state->inode);
4776 : : case -NFS4ERR_OPENMODE:
4777 [ # # ]: 0 : if (state == NULL)
4778 : : break;
4779 [ # # ]: 0 : if (nfs4_schedule_stateid_recovery(server, state) < 0)
4780 : : goto recovery_failed;
4781 : : goto wait_on_recovery;
4782 : : case -NFS4ERR_EXPIRED:
4783 [ # # ]: 0 : if (state != NULL) {
4784 [ # # ]: 0 : if (nfs4_schedule_stateid_recovery(server, state) < 0)
4785 : : goto recovery_failed;
4786 : : }
4787 : : case -NFS4ERR_STALE_STATEID:
4788 : : case -NFS4ERR_STALE_CLIENTID:
4789 : 0 : nfs4_schedule_lease_recovery(clp);
4790 : 0 : goto wait_on_recovery;
4791 : : case -NFS4ERR_MOVED:
4792 [ # # ]: 0 : if (nfs4_schedule_migration_recovery(server) < 0)
4793 : : goto recovery_failed;
4794 : : goto wait_on_recovery;
4795 : : case -NFS4ERR_LEASE_MOVED:
4796 : 0 : nfs4_schedule_lease_moved_recovery(clp);
4797 : 0 : goto wait_on_recovery;
4798 : : #if defined(CONFIG_NFS_V4_1)
4799 : : case -NFS4ERR_BADSESSION:
4800 : : case -NFS4ERR_BADSLOT:
4801 : : case -NFS4ERR_BAD_HIGH_SLOT:
4802 : : case -NFS4ERR_DEADSESSION:
4803 : : case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
4804 : : case -NFS4ERR_SEQ_FALSE_RETRY:
4805 : : case -NFS4ERR_SEQ_MISORDERED:
4806 : : dprintk("%s ERROR %d, Reset session\n", __func__,
4807 : : task->tk_status);
4808 : : nfs4_schedule_session_recovery(clp->cl_session, task->tk_status);
4809 : : goto wait_on_recovery;
4810 : : #endif /* CONFIG_NFS_V4_1 */
4811 : : case -NFS4ERR_DELAY:
4812 : : nfs_inc_server_stats(server, NFSIOS_DELAY);
4813 : : case -NFS4ERR_GRACE:
4814 : 0 : rpc_delay(task, NFS4_POLL_RETRY_MAX);
4815 : : case -NFS4ERR_RETRY_UNCACHED_REP:
4816 : : case -NFS4ERR_OLD_STATEID:
4817 : : goto restart_call;
4818 : : }
4819 : 0 : task->tk_status = nfs4_map_errors(task->tk_status);
4820 : 0 : return 0;
4821 : : recovery_failed:
4822 : 0 : task->tk_status = -EIO;
4823 : 0 : return 0;
4824 : : wait_on_recovery:
4825 : 0 : rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL);
4826 [ # # ]: 0 : if (test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) == 0)
4827 : 0 : rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task);
4828 [ # # ]: 0 : if (test_bit(NFS_MIG_FAILED, &server->mig_status))
4829 : : goto recovery_failed;
4830 : : restart_call:
4831 : 0 : task->tk_status = 0;
4832 : 0 : return -EAGAIN;
4833 : : }
4834 : :
4835 : 0 : static void nfs4_init_boot_verifier(const struct nfs_client *clp,
4836 : : nfs4_verifier *bootverf)
4837 : : {
4838 : : __be32 verf[2];
4839 : :
4840 [ # # ]: 0 : if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
4841 : : /* An impossible timestamp guarantees this value
4842 : : * will never match a generated boot time. */
4843 : 0 : verf[0] = 0;
4844 : 0 : verf[1] = cpu_to_be32(NSEC_PER_SEC + 1);
4845 : : } else {
4846 : 0 : struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
4847 [ # # ]: 0 : verf[0] = cpu_to_be32(nn->boot_time.tv_sec);
4848 [ # # ]: 0 : verf[1] = cpu_to_be32(nn->boot_time.tv_nsec);
4849 : : }
4850 : 0 : memcpy(bootverf->data, verf, sizeof(bootverf->data));
4851 : 0 : }
4852 : :
4853 : : static unsigned int
4854 : 0 : nfs4_init_nonuniform_client_string(const struct nfs_client *clp,
4855 : : char *buf, size_t len)
4856 : : {
4857 : : unsigned int result;
4858 : :
4859 : : rcu_read_lock();
4860 : 0 : result = scnprintf(buf, len, "Linux NFSv4.0 %s/%s %s",
4861 : 0 : clp->cl_ipaddr,
4862 : : rpc_peeraddr2str(clp->cl_rpcclient,
4863 : : RPC_DISPLAY_ADDR),
4864 : : rpc_peeraddr2str(clp->cl_rpcclient,
4865 : : RPC_DISPLAY_PROTO));
4866 : : rcu_read_unlock();
4867 : 0 : return result;
4868 : : }
4869 : :
4870 : : static unsigned int
4871 : 0 : nfs4_init_uniform_client_string(const struct nfs_client *clp,
4872 : : char *buf, size_t len)
4873 : : {
4874 : 0 : const char *nodename = clp->cl_rpcclient->cl_nodename;
4875 : :
4876 [ # # ]: 0 : if (nfs4_client_id_uniquifier[0] != '\0')
4877 : 0 : return scnprintf(buf, len, "Linux NFSv%u.%u %s/%s",
4878 : 0 : clp->rpc_ops->version,
4879 : : clp->cl_minorversion,
4880 : : nfs4_client_id_uniquifier,
4881 : : nodename);
4882 : 0 : return scnprintf(buf, len, "Linux NFSv%u.%u %s",
4883 : 0 : clp->rpc_ops->version, clp->cl_minorversion,
4884 : : nodename);
4885 : : }
4886 : :
4887 : : /**
4888 : : * nfs4_proc_setclientid - Negotiate client ID
4889 : : * @clp: state data structure
4890 : : * @program: RPC program for NFSv4 callback service
4891 : : * @port: IP port number for NFS4 callback service
4892 : : * @cred: RPC credential to use for this call
4893 : : * @res: where to place the result
4894 : : *
4895 : : * Returns zero, a negative errno, or a negative NFS4ERR status code.
4896 : : */
4897 : 0 : int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,
4898 : : unsigned short port, struct rpc_cred *cred,
4899 : : struct nfs4_setclientid_res *res)
4900 : : {
4901 : : nfs4_verifier sc_verifier;
4902 : 0 : struct nfs4_setclientid setclientid = {
4903 : : .sc_verifier = &sc_verifier,
4904 : : .sc_prog = program,
4905 : 0 : .sc_cb_ident = clp->cl_cb_ident,
4906 : : };
4907 : 0 : struct rpc_message msg = {
4908 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID],
4909 : : .rpc_argp = &setclientid,
4910 : : .rpc_resp = res,
4911 : : .rpc_cred = cred,
4912 : : };
4913 : : int status;
4914 : :
4915 : : /* nfs_client_id4 */
4916 : 0 : nfs4_init_boot_verifier(clp, &sc_verifier);
4917 [ # # ]: 0 : if (test_bit(NFS_CS_MIGRATION, &clp->cl_flags))
4918 : 0 : setclientid.sc_name_len =
4919 : 0 : nfs4_init_uniform_client_string(clp,
4920 : : setclientid.sc_name,
4921 : : sizeof(setclientid.sc_name));
4922 : : else
4923 : 0 : setclientid.sc_name_len =
4924 : 0 : nfs4_init_nonuniform_client_string(clp,
4925 : : setclientid.sc_name,
4926 : : sizeof(setclientid.sc_name));
4927 : : /* cb_client4 */
4928 : : rcu_read_lock();
4929 : 0 : setclientid.sc_netid_len = scnprintf(setclientid.sc_netid,
4930 : : sizeof(setclientid.sc_netid), "%s",
4931 : : rpc_peeraddr2str(clp->cl_rpcclient,
4932 : : RPC_DISPLAY_NETID));
4933 : : rcu_read_unlock();
4934 : 0 : setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr,
4935 : : sizeof(setclientid.sc_uaddr), "%s.%u.%u",
4936 : 0 : clp->cl_ipaddr, port >> 8, port & 255);
4937 : :
4938 : : dprintk("NFS call setclientid auth=%s, '%.*s'\n",
4939 : : clp->cl_rpcclient->cl_auth->au_ops->au_name,
4940 : : setclientid.sc_name_len, setclientid.sc_name);
4941 : 0 : status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
4942 : : trace_nfs4_setclientid(clp, status);
4943 : : dprintk("NFS reply setclientid: %d\n", status);
4944 : 0 : return status;
4945 : : }
4946 : :
4947 : : /**
4948 : : * nfs4_proc_setclientid_confirm - Confirm client ID
4949 : : * @clp: state data structure
4950 : : * @res: result of a previous SETCLIENTID
4951 : : * @cred: RPC credential to use for this call
4952 : : *
4953 : : * Returns zero, a negative errno, or a negative NFS4ERR status code.
4954 : : */
4955 : 0 : int nfs4_proc_setclientid_confirm(struct nfs_client *clp,
4956 : : struct nfs4_setclientid_res *arg,
4957 : : struct rpc_cred *cred)
4958 : : {
4959 : 0 : struct rpc_message msg = {
4960 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM],
4961 : : .rpc_argp = arg,
4962 : : .rpc_cred = cred,
4963 : : };
4964 : : int status;
4965 : :
4966 : : dprintk("NFS call setclientid_confirm auth=%s, (client ID %llx)\n",
4967 : : clp->cl_rpcclient->cl_auth->au_ops->au_name,
4968 : : clp->cl_clientid);
4969 : 0 : status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
4970 : : trace_nfs4_setclientid_confirm(clp, status);
4971 : : dprintk("NFS reply setclientid_confirm: %d\n", status);
4972 : 0 : return status;
4973 : : }
4974 : :
4975 : : struct nfs4_delegreturndata {
4976 : : struct nfs4_delegreturnargs args;
4977 : : struct nfs4_delegreturnres res;
4978 : : struct nfs_fh fh;
4979 : : nfs4_stateid stateid;
4980 : : unsigned long timestamp;
4981 : : struct nfs_fattr fattr;
4982 : : int rpc_status;
4983 : : };
4984 : :
4985 : 0 : static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata)
4986 : : {
4987 : : struct nfs4_delegreturndata *data = calldata;
4988 : :
4989 [ # # ]: 0 : if (!nfs4_sequence_done(task, &data->res.seq_res))
4990 : : return;
4991 : :
4992 : 0 : trace_nfs4_delegreturn_exit(&data->args, &data->res, task->tk_status);
4993 [ # # # ]: 0 : switch (task->tk_status) {
4994 : : case 0:
4995 : 0 : renew_lease(data->res.server, data->timestamp);
4996 : : break;
4997 : : case -NFS4ERR_ADMIN_REVOKED:
4998 : : case -NFS4ERR_DELEG_REVOKED:
4999 : : case -NFS4ERR_BAD_STATEID:
5000 : : case -NFS4ERR_OLD_STATEID:
5001 : : case -NFS4ERR_STALE_STATEID:
5002 : : case -NFS4ERR_EXPIRED:
5003 : 0 : task->tk_status = 0;
5004 : 0 : break;
5005 : : default:
5006 [ # # ]: 0 : if (nfs4_async_handle_error(task, data->res.server, NULL) ==
5007 : : -EAGAIN) {
5008 : 0 : rpc_restart_call_prepare(task);
5009 : 0 : return;
5010 : : }
5011 : : }
5012 : 0 : data->rpc_status = task->tk_status;
5013 : : }
5014 : :
5015 : 0 : static void nfs4_delegreturn_release(void *calldata)
5016 : : {
5017 : 0 : kfree(calldata);
5018 : 0 : }
5019 : :
5020 : 0 : static void nfs4_delegreturn_prepare(struct rpc_task *task, void *data)
5021 : : {
5022 : : struct nfs4_delegreturndata *d_data;
5023 : :
5024 : : d_data = (struct nfs4_delegreturndata *)data;
5025 : :
5026 : 0 : nfs4_setup_sequence(d_data->res.server,
5027 : : &d_data->args.seq_args,
5028 : : &d_data->res.seq_res,
5029 : : task);
5030 : 0 : }
5031 : :
5032 : : static const struct rpc_call_ops nfs4_delegreturn_ops = {
5033 : : .rpc_call_prepare = nfs4_delegreturn_prepare,
5034 : : .rpc_call_done = nfs4_delegreturn_done,
5035 : : .rpc_release = nfs4_delegreturn_release,
5036 : : };
5037 : :
5038 : 0 : static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)
5039 : : {
5040 : : struct nfs4_delegreturndata *data;
5041 : : struct nfs_server *server = NFS_SERVER(inode);
5042 : : struct rpc_task *task;
5043 : 0 : struct rpc_message msg = {
5044 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN],
5045 : : .rpc_cred = cred,
5046 : : };
5047 : 0 : struct rpc_task_setup task_setup_data = {
5048 : 0 : .rpc_client = server->client,
5049 : : .rpc_message = &msg,
5050 : : .callback_ops = &nfs4_delegreturn_ops,
5051 : : .flags = RPC_TASK_ASYNC,
5052 : : };
5053 : : int status = 0;
5054 : :
5055 : : data = kzalloc(sizeof(*data), GFP_NOFS);
5056 [ # # ]: 0 : if (data == NULL)
5057 : : return -ENOMEM;
5058 : : nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
5059 : 0 : data->args.fhandle = &data->fh;
5060 : 0 : data->args.stateid = &data->stateid;
5061 : 0 : data->args.bitmask = server->cache_consistency_bitmask;
5062 : : nfs_copy_fh(&data->fh, NFS_FH(inode));
5063 : : nfs4_stateid_copy(&data->stateid, stateid);
5064 : 0 : data->res.fattr = &data->fattr;
5065 : 0 : data->res.server = server;
5066 : 0 : nfs_fattr_init(data->res.fattr);
5067 : 0 : data->timestamp = jiffies;
5068 : 0 : data->rpc_status = 0;
5069 : :
5070 : 0 : task_setup_data.callback_data = data;
5071 : 0 : msg.rpc_argp = &data->args;
5072 : 0 : msg.rpc_resp = &data->res;
5073 : 0 : task = rpc_run_task(&task_setup_data);
5074 [ # # ]: 0 : if (IS_ERR(task))
5075 : 0 : return PTR_ERR(task);
5076 [ # # ]: 0 : if (!issync)
5077 : : goto out;
5078 : : status = nfs4_wait_for_completion_rpc_task(task);
5079 [ # # ]: 0 : if (status != 0)
5080 : : goto out;
5081 : 0 : status = data->rpc_status;
5082 [ # # ]: 0 : if (status == 0)
5083 : 0 : nfs_post_op_update_inode_force_wcc(inode, &data->fattr);
5084 : : else
5085 : 0 : nfs_refresh_inode(inode, &data->fattr);
5086 : : out:
5087 : 0 : rpc_put_task(task);
5088 : 0 : return status;
5089 : : }
5090 : :
5091 : 0 : int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)
5092 : : {
5093 : : struct nfs_server *server = NFS_SERVER(inode);
5094 : 0 : struct nfs4_exception exception = { };
5095 : : int err;
5096 : : do {
5097 : 0 : err = _nfs4_proc_delegreturn(inode, cred, stateid, issync);
5098 : : trace_nfs4_delegreturn(inode, err);
5099 [ # # ]: 0 : switch (err) {
5100 : : case -NFS4ERR_STALE_STATEID:
5101 : : case -NFS4ERR_EXPIRED:
5102 : : case 0:
5103 : : return 0;
5104 : : }
5105 : 0 : err = nfs4_handle_exception(server, err, &exception);
5106 [ # # ]: 0 : } while (exception.retry);
5107 : : return err;
5108 : : }
5109 : :
5110 : : #define NFS4_LOCK_MINTIMEOUT (1 * HZ)
5111 : : #define NFS4_LOCK_MAXTIMEOUT (30 * HZ)
5112 : :
5113 : : /*
5114 : : * sleep, with exponential backoff, and retry the LOCK operation.
5115 : : */
5116 : : static unsigned long
5117 : 0 : nfs4_set_lock_task_retry(unsigned long timeout)
5118 : : {
5119 : 0 : freezable_schedule_timeout_killable_unsafe(timeout);
5120 : 0 : timeout <<= 1;
5121 [ # # ]: 0 : if (timeout > NFS4_LOCK_MAXTIMEOUT)
5122 : : return NFS4_LOCK_MAXTIMEOUT;
5123 : 0 : return timeout;
5124 : : }
5125 : :
5126 : 0 : static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
5127 : : {
5128 : 0 : struct inode *inode = state->inode;
5129 : : struct nfs_server *server = NFS_SERVER(inode);
5130 : 0 : struct nfs_client *clp = server->nfs_client;
5131 : 0 : struct nfs_lockt_args arg = {
5132 : 0 : .fh = NFS_FH(inode),
5133 : : .fl = request,
5134 : : };
5135 : 0 : struct nfs_lockt_res res = {
5136 : : .denied = request,
5137 : : };
5138 : 0 : struct rpc_message msg = {
5139 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKT],
5140 : : .rpc_argp = &arg,
5141 : : .rpc_resp = &res,
5142 : 0 : .rpc_cred = state->owner->so_cred,
5143 : : };
5144 : : struct nfs4_lock_state *lsp;
5145 : : int status;
5146 : :
5147 : 0 : arg.lock_owner.clientid = clp->cl_clientid;
5148 : 0 : status = nfs4_set_lock_state(state, request);
5149 [ # # ]: 0 : if (status != 0)
5150 : : goto out;
5151 : 0 : lsp = request->fl_u.nfs4_fl.owner;
5152 : 0 : arg.lock_owner.id = lsp->ls_seqid.owner_id;
5153 : 0 : arg.lock_owner.s_dev = server->s_dev;
5154 : 0 : status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
5155 [ # # # ]: 0 : switch (status) {
5156 : : case 0:
5157 : 0 : request->fl_type = F_UNLCK;
5158 : : break;
5159 : : case -NFS4ERR_DENIED:
5160 : : status = 0;
5161 : : }
5162 : 0 : request->fl_ops->fl_release_private(request);
5163 : 0 : request->fl_ops = NULL;
5164 : : out:
5165 : 0 : return status;
5166 : : }
5167 : :
5168 : 0 : static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
5169 : : {
5170 : 0 : struct nfs4_exception exception = { };
5171 : : int err;
5172 : :
5173 : : do {
5174 : 0 : err = _nfs4_proc_getlk(state, cmd, request);
5175 : : trace_nfs4_get_lock(request, state, cmd, err);
5176 : 0 : err = nfs4_handle_exception(NFS_SERVER(state->inode), err,
5177 : : &exception);
5178 [ # # ]: 0 : } while (exception.retry);
5179 : 0 : return err;
5180 : : }
5181 : :
5182 : 0 : static int do_vfs_lock(struct file *file, struct file_lock *fl)
5183 : : {
5184 : : int res = 0;
5185 [ # # # ]: 0 : switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
5186 : : case FL_POSIX:
5187 : 0 : res = posix_lock_file_wait(file, fl);
5188 : 0 : break;
5189 : : case FL_FLOCK:
5190 : 0 : res = flock_lock_file_wait(file, fl);
5191 : 0 : break;
5192 : : default:
5193 : 0 : BUG();
5194 : : }
5195 : 0 : return res;
5196 : : }
5197 : :
5198 : : struct nfs4_unlockdata {
5199 : : struct nfs_locku_args arg;
5200 : : struct nfs_locku_res res;
5201 : : struct nfs4_lock_state *lsp;
5202 : : struct nfs_open_context *ctx;
5203 : : struct file_lock fl;
5204 : : const struct nfs_server *server;
5205 : : unsigned long timestamp;
5206 : : };
5207 : :
5208 : 0 : static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,
5209 : : struct nfs_open_context *ctx,
5210 : : struct nfs4_lock_state *lsp,
5211 : : struct nfs_seqid *seqid)
5212 : : {
5213 : : struct nfs4_unlockdata *p;
5214 : 0 : struct inode *inode = lsp->ls_state->inode;
5215 : :
5216 : : p = kzalloc(sizeof(*p), GFP_NOFS);
5217 [ # # ]: 0 : if (p == NULL)
5218 : : return NULL;
5219 : 0 : p->arg.fh = NFS_FH(inode);
5220 : 0 : p->arg.fl = &p->fl;
5221 : 0 : p->arg.seqid = seqid;
5222 : 0 : p->res.seqid = seqid;
5223 : 0 : p->arg.stateid = &lsp->ls_stateid;
5224 : 0 : p->lsp = lsp;
5225 : 0 : atomic_inc(&lsp->ls_count);
5226 : : /* Ensure we don't close file until we're done freeing locks! */
5227 : 0 : p->ctx = get_nfs_open_context(ctx);
5228 : 0 : memcpy(&p->fl, fl, sizeof(p->fl));
5229 : 0 : p->server = NFS_SERVER(inode);
5230 : 0 : return p;
5231 : : }
5232 : :
5233 : 0 : static void nfs4_locku_release_calldata(void *data)
5234 : : {
5235 : : struct nfs4_unlockdata *calldata = data;
5236 : 0 : nfs_free_seqid(calldata->arg.seqid);
5237 : 0 : nfs4_put_lock_state(calldata->lsp);
5238 : 0 : put_nfs_open_context(calldata->ctx);
5239 : 0 : kfree(calldata);
5240 : 0 : }
5241 : :
5242 : 0 : static void nfs4_locku_done(struct rpc_task *task, void *data)
5243 : : {
5244 : : struct nfs4_unlockdata *calldata = data;
5245 : :
5246 [ # # ]: 0 : if (!nfs4_sequence_done(task, &calldata->res.seq_res))
5247 : 0 : return;
5248 [ # # # ]: 0 : switch (task->tk_status) {
5249 : : case 0:
5250 : 0 : nfs4_stateid_copy(&calldata->lsp->ls_stateid,
5251 : 0 : &calldata->res.stateid);
5252 : 0 : renew_lease(calldata->server, calldata->timestamp);
5253 : : break;
5254 : : case -NFS4ERR_BAD_STATEID:
5255 : : case -NFS4ERR_OLD_STATEID:
5256 : : case -NFS4ERR_STALE_STATEID:
5257 : : case -NFS4ERR_EXPIRED:
5258 : : break;
5259 : : default:
5260 [ # # ]: 0 : if (nfs4_async_handle_error(task, calldata->server, NULL) == -EAGAIN)
5261 : 0 : rpc_restart_call_prepare(task);
5262 : : }
5263 : 0 : nfs_release_seqid(calldata->arg.seqid);
5264 : : }
5265 : :
5266 : 0 : static void nfs4_locku_prepare(struct rpc_task *task, void *data)
5267 : : {
5268 : : struct nfs4_unlockdata *calldata = data;
5269 : :
5270 [ # # ]: 0 : if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
5271 : : goto out_wait;
5272 [ # # ]: 0 : if (test_bit(NFS_LOCK_INITIALIZED, &calldata->lsp->ls_flags) == 0) {
5273 : : /* Note: exit _without_ running nfs4_locku_done */
5274 : : goto out_no_action;
5275 : : }
5276 : 0 : calldata->timestamp = jiffies;
5277 [ # # ]: 0 : if (nfs4_setup_sequence(calldata->server,
5278 : : &calldata->arg.seq_args,
5279 : : &calldata->res.seq_res,
5280 : : task) != 0)
5281 : 0 : nfs_release_seqid(calldata->arg.seqid);
5282 : 0 : return;
5283 : : out_no_action:
5284 : 0 : task->tk_action = NULL;
5285 : : out_wait:
5286 : 0 : nfs4_sequence_done(task, &calldata->res.seq_res);
5287 : : }
5288 : :
5289 : : static const struct rpc_call_ops nfs4_locku_ops = {
5290 : : .rpc_call_prepare = nfs4_locku_prepare,
5291 : : .rpc_call_done = nfs4_locku_done,
5292 : : .rpc_release = nfs4_locku_release_calldata,
5293 : : };
5294 : :
5295 : 0 : static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,
5296 : : struct nfs_open_context *ctx,
5297 : : struct nfs4_lock_state *lsp,
5298 : : struct nfs_seqid *seqid)
5299 : : {
5300 : : struct nfs4_unlockdata *data;
5301 : 0 : struct rpc_message msg = {
5302 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKU],
5303 : 0 : .rpc_cred = ctx->cred,
5304 : : };
5305 : 0 : struct rpc_task_setup task_setup_data = {
5306 : 0 : .rpc_client = NFS_CLIENT(lsp->ls_state->inode),
5307 : : .rpc_message = &msg,
5308 : : .callback_ops = &nfs4_locku_ops,
5309 : : .workqueue = nfsiod_workqueue,
5310 : : .flags = RPC_TASK_ASYNC,
5311 : : };
5312 : :
5313 : : nfs4_state_protect(NFS_SERVER(lsp->ls_state->inode)->nfs_client,
5314 : : NFS_SP4_MACH_CRED_CLEANUP, &task_setup_data.rpc_client, &msg);
5315 : :
5316 : : /* Ensure this is an unlock - when canceling a lock, the
5317 : : * canceled lock is passed in, and it won't be an unlock.
5318 : : */
5319 : 0 : fl->fl_type = F_UNLCK;
5320 : :
5321 : 0 : data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid);
5322 [ # # ]: 0 : if (data == NULL) {
5323 : 0 : nfs_free_seqid(seqid);
5324 : 0 : return ERR_PTR(-ENOMEM);
5325 : : }
5326 : :
5327 : : nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1);
5328 : 0 : msg.rpc_argp = &data->arg;
5329 : 0 : msg.rpc_resp = &data->res;
5330 : 0 : task_setup_data.callback_data = data;
5331 : 0 : return rpc_run_task(&task_setup_data);
5332 : : }
5333 : :
5334 : 0 : static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *request)
5335 : : {
5336 : 0 : struct inode *inode = state->inode;
5337 : 0 : struct nfs4_state_owner *sp = state->owner;
5338 : : struct nfs_inode *nfsi = NFS_I(inode);
5339 : : struct nfs_seqid *seqid;
5340 : : struct nfs4_lock_state *lsp;
5341 : : struct rpc_task *task;
5342 : : int status = 0;
5343 : 0 : unsigned char fl_flags = request->fl_flags;
5344 : :
5345 : 0 : status = nfs4_set_lock_state(state, request);
5346 : : /* Unlock _before_ we do the RPC call */
5347 : 0 : request->fl_flags |= FL_EXISTS;
5348 : : /* Exclude nfs_delegation_claim_locks() */
5349 : 0 : mutex_lock(&sp->so_delegreturn_mutex);
5350 : : /* Exclude nfs4_reclaim_open_stateid() - note nesting! */
5351 : 0 : down_read(&nfsi->rwsem);
5352 [ # # ]: 0 : if (do_vfs_lock(request->fl_file, request) == -ENOENT) {
5353 : 0 : up_read(&nfsi->rwsem);
5354 : 0 : mutex_unlock(&sp->so_delegreturn_mutex);
5355 : : goto out;
5356 : : }
5357 : 0 : up_read(&nfsi->rwsem);
5358 : 0 : mutex_unlock(&sp->so_delegreturn_mutex);
5359 [ # # ]: 0 : if (status != 0)
5360 : : goto out;
5361 : : /* Is this a delegated lock? */
5362 : 0 : lsp = request->fl_u.nfs4_fl.owner;
5363 [ # # ]: 0 : if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) == 0)
5364 : : goto out;
5365 : 0 : seqid = nfs_alloc_seqid(&lsp->ls_seqid, GFP_KERNEL);
5366 : : status = -ENOMEM;
5367 [ # # ]: 0 : if (seqid == NULL)
5368 : : goto out;
5369 : 0 : task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid);
5370 : : status = PTR_ERR(task);
5371 [ # # ]: 0 : if (IS_ERR(task))
5372 : : goto out;
5373 : : status = nfs4_wait_for_completion_rpc_task(task);
5374 : 0 : rpc_put_task(task);
5375 : : out:
5376 : 0 : request->fl_flags = fl_flags;
5377 : : trace_nfs4_unlock(request, state, F_SETLK, status);
5378 : 0 : return status;
5379 : : }
5380 : :
5381 : : struct nfs4_lockdata {
5382 : : struct nfs_lock_args arg;
5383 : : struct nfs_lock_res res;
5384 : : struct nfs4_lock_state *lsp;
5385 : : struct nfs_open_context *ctx;
5386 : : struct file_lock fl;
5387 : : unsigned long timestamp;
5388 : : int rpc_status;
5389 : : int cancelled;
5390 : : struct nfs_server *server;
5391 : : };
5392 : :
5393 : 0 : static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl,
5394 : : struct nfs_open_context *ctx, struct nfs4_lock_state *lsp,
5395 : : gfp_t gfp_mask)
5396 : : {
5397 : : struct nfs4_lockdata *p;
5398 : 0 : struct inode *inode = lsp->ls_state->inode;
5399 : : struct nfs_server *server = NFS_SERVER(inode);
5400 : :
5401 : : p = kzalloc(sizeof(*p), gfp_mask);
5402 [ # # ]: 0 : if (p == NULL)
5403 : : return NULL;
5404 : :
5405 : 0 : p->arg.fh = NFS_FH(inode);
5406 : 0 : p->arg.fl = &p->fl;
5407 : 0 : p->arg.open_seqid = nfs_alloc_seqid(&lsp->ls_state->owner->so_seqid, gfp_mask);
5408 [ # # ]: 0 : if (p->arg.open_seqid == NULL)
5409 : : goto out_free;
5410 : 0 : p->arg.lock_seqid = nfs_alloc_seqid(&lsp->ls_seqid, gfp_mask);
5411 [ # # ]: 0 : if (p->arg.lock_seqid == NULL)
5412 : : goto out_free_seqid;
5413 : 0 : p->arg.lock_stateid = &lsp->ls_stateid;
5414 : 0 : p->arg.lock_owner.clientid = server->nfs_client->cl_clientid;
5415 : 0 : p->arg.lock_owner.id = lsp->ls_seqid.owner_id;
5416 : 0 : p->arg.lock_owner.s_dev = server->s_dev;
5417 : 0 : p->res.lock_seqid = p->arg.lock_seqid;
5418 : 0 : p->lsp = lsp;
5419 : 0 : p->server = server;
5420 : 0 : atomic_inc(&lsp->ls_count);
5421 : 0 : p->ctx = get_nfs_open_context(ctx);
5422 : 0 : memcpy(&p->fl, fl, sizeof(p->fl));
5423 : 0 : return p;
5424 : : out_free_seqid:
5425 : 0 : nfs_free_seqid(p->arg.open_seqid);
5426 : : out_free:
5427 : 0 : kfree(p);
5428 : 0 : return NULL;
5429 : : }
5430 : :
5431 : 0 : static void nfs4_lock_prepare(struct rpc_task *task, void *calldata)
5432 : : {
5433 : : struct nfs4_lockdata *data = calldata;
5434 : 0 : struct nfs4_state *state = data->lsp->ls_state;
5435 : :
5436 : : dprintk("%s: begin!\n", __func__);
5437 [ # # ]: 0 : if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0)
5438 : : goto out_wait;
5439 : : /* Do we need to do an open_to_lock_owner? */
5440 [ # # ]: 0 : if (!(data->arg.lock_seqid->sequence->flags & NFS_SEQID_CONFIRMED)) {
5441 [ # # ]: 0 : if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0) {
5442 : : goto out_release_lock_seqid;
5443 : : }
5444 : 0 : data->arg.open_stateid = &state->open_stateid;
5445 : 0 : data->arg.new_lock_owner = 1;
5446 : 0 : data->res.open_seqid = data->arg.open_seqid;
5447 : : } else
5448 : 0 : data->arg.new_lock_owner = 0;
5449 [ # # ]: 0 : if (!nfs4_valid_open_stateid(state)) {
5450 : 0 : data->rpc_status = -EBADF;
5451 : 0 : task->tk_action = NULL;
5452 : 0 : goto out_release_open_seqid;
5453 : : }
5454 : 0 : data->timestamp = jiffies;
5455 [ # # ]: 0 : if (nfs4_setup_sequence(data->server,
5456 : : &data->arg.seq_args,
5457 : : &data->res.seq_res,
5458 : : task) == 0)
5459 : 0 : return;
5460 : : out_release_open_seqid:
5461 : 0 : nfs_release_seqid(data->arg.open_seqid);
5462 : : out_release_lock_seqid:
5463 : 0 : nfs_release_seqid(data->arg.lock_seqid);
5464 : : out_wait:
5465 : 0 : nfs4_sequence_done(task, &data->res.seq_res);
5466 : : dprintk("%s: done!, ret = %d\n", __func__, data->rpc_status);
5467 : : }
5468 : :
5469 : 0 : static void nfs4_lock_done(struct rpc_task *task, void *calldata)
5470 : : {
5471 : : struct nfs4_lockdata *data = calldata;
5472 : :
5473 : : dprintk("%s: begin!\n", __func__);
5474 : :
5475 [ # # ]: 0 : if (!nfs4_sequence_done(task, &data->res.seq_res))
5476 : 0 : return;
5477 : :
5478 : 0 : data->rpc_status = task->tk_status;
5479 [ # # ]: 0 : if (data->arg.new_lock_owner != 0) {
5480 [ # # ]: 0 : if (data->rpc_status == 0)
5481 : 0 : nfs_confirm_seqid(&data->lsp->ls_seqid, 0);
5482 : : else
5483 : : goto out;
5484 : : }
5485 [ # # ]: 0 : if (data->rpc_status == 0) {
5486 : 0 : nfs4_stateid_copy(&data->lsp->ls_stateid, &data->res.stateid);
5487 : 0 : set_bit(NFS_LOCK_INITIALIZED, &data->lsp->ls_flags);
5488 : 0 : renew_lease(NFS_SERVER(data->ctx->dentry->d_inode), data->timestamp);
5489 : : }
5490 : : out:
5491 : : dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status);
5492 : : }
5493 : :
5494 : 0 : static void nfs4_lock_release(void *calldata)
5495 : : {
5496 : : struct nfs4_lockdata *data = calldata;
5497 : :
5498 : : dprintk("%s: begin!\n", __func__);
5499 : 0 : nfs_free_seqid(data->arg.open_seqid);
5500 [ # # ]: 0 : if (data->cancelled != 0) {
5501 : : struct rpc_task *task;
5502 : 0 : task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp,
5503 : : data->arg.lock_seqid);
5504 [ # # ]: 0 : if (!IS_ERR(task))
5505 : 0 : rpc_put_task_async(task);
5506 : : dprintk("%s: cancelling lock!\n", __func__);
5507 : : } else
5508 : 0 : nfs_free_seqid(data->arg.lock_seqid);
5509 : 0 : nfs4_put_lock_state(data->lsp);
5510 : 0 : put_nfs_open_context(data->ctx);
5511 : 0 : kfree(data);
5512 : : dprintk("%s: done!\n", __func__);
5513 : 0 : }
5514 : :
5515 : : static const struct rpc_call_ops nfs4_lock_ops = {
5516 : : .rpc_call_prepare = nfs4_lock_prepare,
5517 : : .rpc_call_done = nfs4_lock_done,
5518 : : .rpc_release = nfs4_lock_release,
5519 : : };
5520 : :
5521 : 0 : static void nfs4_handle_setlk_error(struct nfs_server *server, struct nfs4_lock_state *lsp, int new_lock_owner, int error)
5522 : : {
5523 [ # # # # ]: 0 : switch (error) {
5524 : : case -NFS4ERR_ADMIN_REVOKED:
5525 : : case -NFS4ERR_BAD_STATEID:
5526 : 0 : lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;
5527 [ # # ][ # # ]: 0 : if (new_lock_owner != 0 ||
5528 : : test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0)
5529 : 0 : nfs4_schedule_stateid_recovery(server, lsp->ls_state);
5530 : : break;
5531 : : case -NFS4ERR_STALE_STATEID:
5532 : 0 : lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;
5533 : : case -NFS4ERR_EXPIRED:
5534 : 0 : nfs4_schedule_lease_recovery(server->nfs_client);
5535 : : };
5536 : 0 : }
5537 : :
5538 : 0 : static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int recovery_type)
5539 : : {
5540 : : struct nfs4_lockdata *data;
5541 : : struct rpc_task *task;
5542 : 0 : struct rpc_message msg = {
5543 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCK],
5544 : 0 : .rpc_cred = state->owner->so_cred,
5545 : : };
5546 : 0 : struct rpc_task_setup task_setup_data = {
5547 : 0 : .rpc_client = NFS_CLIENT(state->inode),
5548 : : .rpc_message = &msg,
5549 : : .callback_ops = &nfs4_lock_ops,
5550 : : .workqueue = nfsiod_workqueue,
5551 : : .flags = RPC_TASK_ASYNC,
5552 : : };
5553 : : int ret;
5554 : :
5555 : : dprintk("%s: begin!\n", __func__);
5556 [ # # ]: 0 : data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file),
5557 : : fl->fl_u.nfs4_fl.owner,
5558 : : recovery_type == NFS_LOCK_NEW ? GFP_KERNEL : GFP_NOFS);
5559 [ # # ]: 0 : if (data == NULL)
5560 : : return -ENOMEM;
5561 [ # # ]: 0 : if (IS_SETLKW(cmd))
5562 : 0 : data->arg.block = 1;
5563 : : nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1);
5564 : 0 : msg.rpc_argp = &data->arg;
5565 : 0 : msg.rpc_resp = &data->res;
5566 : 0 : task_setup_data.callback_data = data;
5567 [ # # ]: 0 : if (recovery_type > NFS_LOCK_NEW) {
5568 [ # # ]: 0 : if (recovery_type == NFS_LOCK_RECLAIM)
5569 : 0 : data->arg.reclaim = NFS_LOCK_RECLAIM;
5570 : : nfs4_set_sequence_privileged(&data->arg.seq_args);
5571 : : }
5572 : 0 : task = rpc_run_task(&task_setup_data);
5573 [ # # ]: 0 : if (IS_ERR(task))
5574 : : return PTR_ERR(task);
5575 : : ret = nfs4_wait_for_completion_rpc_task(task);
5576 [ # # ]: 0 : if (ret == 0) {
5577 : 0 : ret = data->rpc_status;
5578 [ # # ]: 0 : if (ret)
5579 : 0 : nfs4_handle_setlk_error(data->server, data->lsp,
5580 : 0 : data->arg.new_lock_owner, ret);
5581 : : } else
5582 : 0 : data->cancelled = 1;
5583 : 0 : rpc_put_task(task);
5584 : : dprintk("%s: done, ret = %d!\n", __func__, ret);
5585 : : return ret;
5586 : : }
5587 : :
5588 : 0 : static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request)
5589 : : {
5590 : 0 : struct nfs_server *server = NFS_SERVER(state->inode);
5591 : 0 : struct nfs4_exception exception = {
5592 : : .inode = state->inode,
5593 : : };
5594 : : int err;
5595 : :
5596 : : do {
5597 : : /* Cache the lock if possible... */
5598 [ # # ]: 0 : if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
5599 : : return 0;
5600 : 0 : err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_RECLAIM);
5601 : : trace_nfs4_lock_reclaim(request, state, F_SETLK, err);
5602 [ # # ]: 0 : if (err != -NFS4ERR_DELAY)
5603 : : break;
5604 : 0 : nfs4_handle_exception(server, err, &exception);
5605 [ # # ]: 0 : } while (exception.retry);
5606 : 0 : return err;
5607 : : }
5608 : :
5609 : 0 : static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request)
5610 : : {
5611 : 0 : struct nfs_server *server = NFS_SERVER(state->inode);
5612 : 0 : struct nfs4_exception exception = {
5613 : : .inode = state->inode,
5614 : : };
5615 : : int err;
5616 : :
5617 : 0 : err = nfs4_set_lock_state(state, request);
5618 [ # # ]: 0 : if (err != 0)
5619 : : return err;
5620 [ # # ]: 0 : if (!recover_lost_locks) {
5621 : 0 : set_bit(NFS_LOCK_LOST, &request->fl_u.nfs4_fl.owner->ls_flags);
5622 : 0 : return 0;
5623 : : }
5624 : : do {
5625 [ # # ]: 0 : if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
5626 : : return 0;
5627 : 0 : err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_EXPIRED);
5628 : : trace_nfs4_lock_expired(request, state, F_SETLK, err);
5629 [ # # ]: 0 : switch (err) {
5630 : : default:
5631 : : goto out;
5632 : : case -NFS4ERR_GRACE:
5633 : : case -NFS4ERR_DELAY:
5634 : 0 : nfs4_handle_exception(server, err, &exception);
5635 : : err = 0;
5636 : : }
5637 [ # # ]: 0 : } while (exception.retry);
5638 : : out:
5639 : 0 : return err;
5640 : : }
5641 : :
5642 : : #if defined(CONFIG_NFS_V4_1)
5643 : : /**
5644 : : * nfs41_check_expired_locks - possibly free a lock stateid
5645 : : *
5646 : : * @state: NFSv4 state for an inode
5647 : : *
5648 : : * Returns NFS_OK if recovery for this stateid is now finished.
5649 : : * Otherwise a negative NFS4ERR value is returned.
5650 : : */
5651 : : static int nfs41_check_expired_locks(struct nfs4_state *state)
5652 : : {
5653 : : int status, ret = -NFS4ERR_BAD_STATEID;
5654 : : struct nfs4_lock_state *lsp;
5655 : : struct nfs_server *server = NFS_SERVER(state->inode);
5656 : :
5657 : : list_for_each_entry(lsp, &state->lock_states, ls_locks) {
5658 : : if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) {
5659 : : struct rpc_cred *cred = lsp->ls_state->owner->so_cred;
5660 : :
5661 : : status = nfs41_test_stateid(server,
5662 : : &lsp->ls_stateid,
5663 : : cred);
5664 : : trace_nfs4_test_lock_stateid(state, lsp, status);
5665 : : if (status != NFS_OK) {
5666 : : /* Free the stateid unless the server
5667 : : * informs us the stateid is unrecognized. */
5668 : : if (status != -NFS4ERR_BAD_STATEID)
5669 : : nfs41_free_stateid(server,
5670 : : &lsp->ls_stateid,
5671 : : cred);
5672 : : clear_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags);
5673 : : ret = status;
5674 : : }
5675 : : }
5676 : : };
5677 : :
5678 : : return ret;
5679 : : }
5680 : :
5681 : : static int nfs41_lock_expired(struct nfs4_state *state, struct file_lock *request)
5682 : : {
5683 : : int status = NFS_OK;
5684 : :
5685 : : if (test_bit(LK_STATE_IN_USE, &state->flags))
5686 : : status = nfs41_check_expired_locks(state);
5687 : : if (status != NFS_OK)
5688 : : status = nfs4_lock_expired(state, request);
5689 : : return status;
5690 : : }
5691 : : #endif
5692 : :
5693 : 0 : static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
5694 : : {
5695 : 0 : struct nfs4_state_owner *sp = state->owner;
5696 : 0 : struct nfs_inode *nfsi = NFS_I(state->inode);
5697 : 0 : unsigned char fl_flags = request->fl_flags;
5698 : : unsigned int seq;
5699 : : int status = -ENOLCK;
5700 : :
5701 [ # # ][ # # ]: 0 : if ((fl_flags & FL_POSIX) &&
5702 : : !test_bit(NFS_STATE_POSIX_LOCKS, &state->flags))
5703 : : goto out;
5704 : : /* Is this a delegated open? */
5705 : 0 : status = nfs4_set_lock_state(state, request);
5706 [ # # ]: 0 : if (status != 0)
5707 : : goto out;
5708 : 0 : request->fl_flags |= FL_ACCESS;
5709 : 0 : status = do_vfs_lock(request->fl_file, request);
5710 [ # # ]: 0 : if (status < 0)
5711 : : goto out;
5712 : 0 : down_read(&nfsi->rwsem);
5713 [ # # ]: 0 : if (test_bit(NFS_DELEGATED_STATE, &state->flags)) {
5714 : : /* Yes: cache locks! */
5715 : : /* ...but avoid races with delegation recall... */
5716 : 0 : request->fl_flags = fl_flags & ~FL_SLEEP;
5717 : 0 : status = do_vfs_lock(request->fl_file, request);
5718 : 0 : goto out_unlock;
5719 : : }
5720 : : seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
5721 : 0 : up_read(&nfsi->rwsem);
5722 : 0 : status = _nfs4_do_setlk(state, cmd, request, NFS_LOCK_NEW);
5723 [ # # ]: 0 : if (status != 0)
5724 : : goto out;
5725 : 0 : down_read(&nfsi->rwsem);
5726 [ # # ]: 0 : if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq)) {
5727 : : status = -NFS4ERR_DELAY;
5728 : : goto out_unlock;
5729 : : }
5730 : : /* Note: we always want to sleep here! */
5731 : 0 : request->fl_flags = fl_flags | FL_SLEEP;
5732 [ # # ]: 0 : if (do_vfs_lock(request->fl_file, request) < 0)
5733 : 0 : printk(KERN_WARNING "NFS: %s: VFS is out of sync with lock "
5734 : : "manager!\n", __func__);
5735 : : out_unlock:
5736 : 0 : up_read(&nfsi->rwsem);
5737 : : out:
5738 : 0 : request->fl_flags = fl_flags;
5739 : 0 : return status;
5740 : : }
5741 : :
5742 : 0 : static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
5743 : : {
5744 : 0 : struct nfs4_exception exception = {
5745 : : .state = state,
5746 : 0 : .inode = state->inode,
5747 : : };
5748 : : int err;
5749 : :
5750 : : do {
5751 : 0 : err = _nfs4_proc_setlk(state, cmd, request);
5752 : : trace_nfs4_set_lock(request, state, cmd, err);
5753 [ # # ]: 0 : if (err == -NFS4ERR_DENIED)
5754 : : err = -EAGAIN;
5755 : 0 : err = nfs4_handle_exception(NFS_SERVER(state->inode),
5756 : : err, &exception);
5757 [ # # ]: 0 : } while (exception.retry);
5758 : 0 : return err;
5759 : : }
5760 : :
5761 : : static int
5762 : 0 : nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request)
5763 : : {
5764 : : struct nfs_open_context *ctx;
5765 : : struct nfs4_state *state;
5766 : : unsigned long timeout = NFS4_LOCK_MINTIMEOUT;
5767 : : int status;
5768 : :
5769 : : /* verify open state */
5770 : : ctx = nfs_file_open_context(filp);
5771 : 0 : state = ctx->state;
5772 : :
5773 [ # # ][ # # ]: 0 : if (request->fl_start < 0 || request->fl_end < 0)
5774 : : return -EINVAL;
5775 : :
5776 [ # # ]: 0 : if (IS_GETLK(cmd)) {
5777 [ # # ]: 0 : if (state != NULL)
5778 : 0 : return nfs4_proc_getlk(state, F_GETLK, request);
5779 : : return 0;
5780 : : }
5781 : :
5782 [ # # ][ # # ]: 0 : if (!(IS_SETLK(cmd) || IS_SETLKW(cmd)))
5783 : : return -EINVAL;
5784 : :
5785 [ # # ]: 0 : if (request->fl_type == F_UNLCK) {
5786 [ # # ]: 0 : if (state != NULL)
5787 : 0 : return nfs4_proc_unlck(state, cmd, request);
5788 : : return 0;
5789 : : }
5790 : :
5791 [ # # ]: 0 : if (state == NULL)
5792 : : return -ENOLCK;
5793 : : /*
5794 : : * Don't rely on the VFS having checked the file open mode,
5795 : : * since it won't do this for flock() locks.
5796 : : */
5797 [ # # # ]: 0 : switch (request->fl_type) {
5798 : : case F_RDLCK:
5799 [ # # ]: 0 : if (!(filp->f_mode & FMODE_READ))
5800 : : return -EBADF;
5801 : : break;
5802 : : case F_WRLCK:
5803 [ # # ]: 0 : if (!(filp->f_mode & FMODE_WRITE))
5804 : : return -EBADF;
5805 : : }
5806 : :
5807 : : do {
5808 : 0 : status = nfs4_proc_setlk(state, cmd, request);
5809 [ # # ][ # # ]: 0 : if ((status != -EAGAIN) || IS_SETLK(cmd))
5810 : : break;
5811 : 0 : timeout = nfs4_set_lock_task_retry(timeout);
5812 : : status = -ERESTARTSYS;
5813 [ # # ]: 0 : if (signalled())
5814 : : break;
5815 : : } while(status < 0);
5816 : 0 : return status;
5817 : : }
5818 : :
5819 : 0 : int nfs4_lock_delegation_recall(struct file_lock *fl, struct nfs4_state *state, const nfs4_stateid *stateid)
5820 : : {
5821 : 0 : struct nfs_server *server = NFS_SERVER(state->inode);
5822 : : int err;
5823 : :
5824 : 0 : err = nfs4_set_lock_state(state, fl);
5825 [ # # ]: 0 : if (err != 0)
5826 : : return err;
5827 : 0 : err = _nfs4_do_setlk(state, F_SETLK, fl, NFS_LOCK_NEW);
5828 : 0 : return nfs4_handle_delegation_recall_error(server, state, stateid, err);
5829 : : }
5830 : :
5831 : : struct nfs_release_lockowner_data {
5832 : : struct nfs4_lock_state *lsp;
5833 : : struct nfs_server *server;
5834 : : struct nfs_release_lockowner_args args;
5835 : : struct nfs_release_lockowner_res res;
5836 : : unsigned long timestamp;
5837 : : };
5838 : :
5839 : 0 : static void nfs4_release_lockowner_prepare(struct rpc_task *task, void *calldata)
5840 : : {
5841 : : struct nfs_release_lockowner_data *data = calldata;
5842 : 0 : nfs40_setup_sequence(data->server,
5843 : : &data->args.seq_args, &data->res.seq_res, task);
5844 : 0 : data->timestamp = jiffies;
5845 : 0 : }
5846 : :
5847 : 0 : static void nfs4_release_lockowner_done(struct rpc_task *task, void *calldata)
5848 : : {
5849 : : struct nfs_release_lockowner_data *data = calldata;
5850 : 0 : struct nfs_server *server = data->server;
5851 : :
5852 : 0 : nfs40_sequence_done(task, &data->res.seq_res);
5853 : :
5854 [ # # # ]: 0 : switch (task->tk_status) {
5855 : : case 0:
5856 : 0 : renew_lease(server, data->timestamp);
5857 : : break;
5858 : : case -NFS4ERR_STALE_CLIENTID:
5859 : : case -NFS4ERR_EXPIRED:
5860 : : case -NFS4ERR_LEASE_MOVED:
5861 : : case -NFS4ERR_DELAY:
5862 [ # # ]: 0 : if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN)
5863 : 0 : rpc_restart_call_prepare(task);
5864 : : }
5865 : 0 : }
5866 : :
5867 : 0 : static void nfs4_release_lockowner_release(void *calldata)
5868 : : {
5869 : : struct nfs_release_lockowner_data *data = calldata;
5870 : 0 : nfs4_free_lock_state(data->server, data->lsp);
5871 : 0 : kfree(calldata);
5872 : 0 : }
5873 : :
5874 : : static const struct rpc_call_ops nfs4_release_lockowner_ops = {
5875 : : .rpc_call_prepare = nfs4_release_lockowner_prepare,
5876 : : .rpc_call_done = nfs4_release_lockowner_done,
5877 : : .rpc_release = nfs4_release_lockowner_release,
5878 : : };
5879 : :
5880 : 0 : static int nfs4_release_lockowner(struct nfs_server *server, struct nfs4_lock_state *lsp)
5881 : : {
5882 : : struct nfs_release_lockowner_data *data;
5883 : 0 : struct rpc_message msg = {
5884 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RELEASE_LOCKOWNER],
5885 : : };
5886 : :
5887 [ # # ]: 0 : if (server->nfs_client->cl_mvops->minor_version != 0)
5888 : : return -EINVAL;
5889 : :
5890 : : data = kmalloc(sizeof(*data), GFP_NOFS);
5891 [ # # ]: 0 : if (!data)
5892 : : return -ENOMEM;
5893 : 0 : data->lsp = lsp;
5894 : 0 : data->server = server;
5895 : 0 : data->args.lock_owner.clientid = server->nfs_client->cl_clientid;
5896 : 0 : data->args.lock_owner.id = lsp->ls_seqid.owner_id;
5897 : 0 : data->args.lock_owner.s_dev = server->s_dev;
5898 : :
5899 : 0 : msg.rpc_argp = &data->args;
5900 : 0 : msg.rpc_resp = &data->res;
5901 : : nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0);
5902 : 0 : rpc_call_async(server->client, &msg, 0, &nfs4_release_lockowner_ops, data);
5903 : 0 : return 0;
5904 : : }
5905 : :
5906 : : #define XATTR_NAME_NFSV4_ACL "system.nfs4_acl"
5907 : :
5908 : 0 : static int nfs4_xattr_set_nfs4_acl(struct dentry *dentry, const char *key,
5909 : : const void *buf, size_t buflen,
5910 : : int flags, int type)
5911 : : {
5912 [ # # ]: 0 : if (strcmp(key, "") != 0)
5913 : : return -EINVAL;
5914 : :
5915 : 0 : return nfs4_proc_set_acl(dentry->d_inode, buf, buflen);
5916 : : }
5917 : :
5918 : 0 : static int nfs4_xattr_get_nfs4_acl(struct dentry *dentry, const char *key,
5919 : : void *buf, size_t buflen, int type)
5920 : : {
5921 [ # # ]: 0 : if (strcmp(key, "") != 0)
5922 : : return -EINVAL;
5923 : :
5924 : 0 : return nfs4_proc_get_acl(dentry->d_inode, buf, buflen);
5925 : : }
5926 : :
5927 : 0 : static size_t nfs4_xattr_list_nfs4_acl(struct dentry *dentry, char *list,
5928 : : size_t list_len, const char *name,
5929 : : size_t name_len, int type)
5930 : : {
5931 : : size_t len = sizeof(XATTR_NAME_NFSV4_ACL);
5932 : :
5933 [ # # ]: 0 : if (!nfs4_server_supports_acls(NFS_SERVER(dentry->d_inode)))
5934 : : return 0;
5935 : :
5936 [ # # ]: 0 : if (list && len <= list_len)
5937 : 0 : memcpy(list, XATTR_NAME_NFSV4_ACL, len);
5938 : : return len;
5939 : : }
5940 : :
5941 : : #ifdef CONFIG_NFS_V4_SECURITY_LABEL
5942 : : static inline int nfs4_server_supports_labels(struct nfs_server *server)
5943 : : {
5944 : : return server->caps & NFS_CAP_SECURITY_LABEL;
5945 : : }
5946 : :
5947 : : static int nfs4_xattr_set_nfs4_label(struct dentry *dentry, const char *key,
5948 : : const void *buf, size_t buflen,
5949 : : int flags, int type)
5950 : : {
5951 : : if (security_ismaclabel(key))
5952 : : return nfs4_set_security_label(dentry, buf, buflen);
5953 : :
5954 : : return -EOPNOTSUPP;
5955 : : }
5956 : :
5957 : : static int nfs4_xattr_get_nfs4_label(struct dentry *dentry, const char *key,
5958 : : void *buf, size_t buflen, int type)
5959 : : {
5960 : : if (security_ismaclabel(key))
5961 : : return nfs4_get_security_label(dentry->d_inode, buf, buflen);
5962 : : return -EOPNOTSUPP;
5963 : : }
5964 : :
5965 : : static size_t nfs4_xattr_list_nfs4_label(struct dentry *dentry, char *list,
5966 : : size_t list_len, const char *name,
5967 : : size_t name_len, int type)
5968 : : {
5969 : : size_t len = 0;
5970 : :
5971 : : if (nfs_server_capable(dentry->d_inode, NFS_CAP_SECURITY_LABEL)) {
5972 : : len = security_inode_listsecurity(dentry->d_inode, NULL, 0);
5973 : : if (list && len <= list_len)
5974 : : security_inode_listsecurity(dentry->d_inode, list, len);
5975 : : }
5976 : : return len;
5977 : : }
5978 : :
5979 : : static const struct xattr_handler nfs4_xattr_nfs4_label_handler = {
5980 : : .prefix = XATTR_SECURITY_PREFIX,
5981 : : .list = nfs4_xattr_list_nfs4_label,
5982 : : .get = nfs4_xattr_get_nfs4_label,
5983 : : .set = nfs4_xattr_set_nfs4_label,
5984 : : };
5985 : : #endif
5986 : :
5987 : :
5988 : : /*
5989 : : * nfs_fhget will use either the mounted_on_fileid or the fileid
5990 : : */
5991 : : static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr)
5992 : : {
5993 [ # # ][ # # ]: 0 : if (!(((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) ||
5994 : : (fattr->valid & NFS_ATTR_FATTR_FILEID)) &&
5995 : : (fattr->valid & NFS_ATTR_FATTR_FSID) &&
5996 : : (fattr->valid & NFS_ATTR_FATTR_V4_LOCATIONS)))
5997 : : return;
5998 : :
5999 : 0 : fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |
6000 : : NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_V4_REFERRAL;
6001 : 0 : fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;
6002 : 0 : fattr->nlink = 2;
6003 : : }
6004 : :
6005 : 0 : static int _nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir,
6006 : : const struct qstr *name,
6007 : : struct nfs4_fs_locations *fs_locations,
6008 : : struct page *page)
6009 : : {
6010 : : struct nfs_server *server = NFS_SERVER(dir);
6011 : 0 : u32 bitmask[3] = {
6012 : : [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
6013 : : };
6014 : 0 : struct nfs4_fs_locations_arg args = {
6015 : 0 : .dir_fh = NFS_FH(dir),
6016 : : .name = name,
6017 : : .page = page,
6018 : : .bitmask = bitmask,
6019 : : };
6020 : 0 : struct nfs4_fs_locations_res res = {
6021 : : .fs_locations = fs_locations,
6022 : : };
6023 : 0 : struct rpc_message msg = {
6024 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
6025 : : .rpc_argp = &args,
6026 : : .rpc_resp = &res,
6027 : : };
6028 : : int status;
6029 : :
6030 : : dprintk("%s: start\n", __func__);
6031 : :
6032 : : /* Ask for the fileid of the absent filesystem if mounted_on_fileid
6033 : : * is not supported */
6034 [ # # ]: 0 : if (NFS_SERVER(dir)->attr_bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)
6035 : 0 : bitmask[1] |= FATTR4_WORD1_MOUNTED_ON_FILEID;
6036 : : else
6037 : 0 : bitmask[0] |= FATTR4_WORD0_FILEID;
6038 : :
6039 : 0 : nfs_fattr_init(&fs_locations->fattr);
6040 : 0 : fs_locations->server = server;
6041 : 0 : fs_locations->nlocations = 0;
6042 : : status = nfs4_call_sync(client, server, &msg, &args.seq_args, &res.seq_res, 0);
6043 : : dprintk("%s: returned status = %d\n", __func__, status);
6044 : 0 : return status;
6045 : : }
6046 : :
6047 : 0 : int nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir,
6048 : : const struct qstr *name,
6049 : : struct nfs4_fs_locations *fs_locations,
6050 : : struct page *page)
6051 : : {
6052 : 0 : struct nfs4_exception exception = { };
6053 : : int err;
6054 : : do {
6055 : 0 : err = _nfs4_proc_fs_locations(client, dir, name,
6056 : : fs_locations, page);
6057 : : trace_nfs4_get_fs_locations(dir, name, err);
6058 : 0 : err = nfs4_handle_exception(NFS_SERVER(dir), err,
6059 : : &exception);
6060 [ # # ]: 0 : } while (exception.retry);
6061 : 0 : return err;
6062 : : }
6063 : :
6064 : : /*
6065 : : * This operation also signals the server that this client is
6066 : : * performing migration recovery. The server can stop returning
6067 : : * NFS4ERR_LEASE_MOVED to this client. A RENEW operation is
6068 : : * appended to this compound to identify the client ID which is
6069 : : * performing recovery.
6070 : : */
6071 : 0 : static int _nfs40_proc_get_locations(struct inode *inode,
6072 : : struct nfs4_fs_locations *locations,
6073 : : struct page *page, struct rpc_cred *cred)
6074 : : {
6075 : 0 : struct nfs_server *server = NFS_SERVER(inode);
6076 : 0 : struct rpc_clnt *clnt = server->client;
6077 : 0 : u32 bitmask[2] = {
6078 : : [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
6079 : : };
6080 : 0 : struct nfs4_fs_locations_arg args = {
6081 : 0 : .clientid = server->nfs_client->cl_clientid,
6082 : 0 : .fh = NFS_FH(inode),
6083 : : .page = page,
6084 : : .bitmask = bitmask,
6085 : : .migration = 1, /* skip LOOKUP */
6086 : : .renew = 1, /* append RENEW */
6087 : : };
6088 : 0 : struct nfs4_fs_locations_res res = {
6089 : : .fs_locations = locations,
6090 : : .migration = 1,
6091 : : .renew = 1,
6092 : : };
6093 : 0 : struct rpc_message msg = {
6094 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
6095 : : .rpc_argp = &args,
6096 : : .rpc_resp = &res,
6097 : : .rpc_cred = cred,
6098 : : };
6099 : 0 : unsigned long now = jiffies;
6100 : : int status;
6101 : :
6102 : 0 : nfs_fattr_init(&locations->fattr);
6103 : 0 : locations->server = server;
6104 : 0 : locations->nlocations = 0;
6105 : :
6106 : : nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
6107 : : nfs4_set_sequence_privileged(&args.seq_args);
6108 : 0 : status = nfs4_call_sync_sequence(clnt, server, &msg,
6109 : : &args.seq_args, &res.seq_res);
6110 [ # # ]: 0 : if (status)
6111 : : return status;
6112 : :
6113 : : renew_lease(server, now);
6114 : 0 : return 0;
6115 : : }
6116 : :
6117 : : #ifdef CONFIG_NFS_V4_1
6118 : :
6119 : : /*
6120 : : * This operation also signals the server that this client is
6121 : : * performing migration recovery. The server can stop asserting
6122 : : * SEQ4_STATUS_LEASE_MOVED for this client. The client ID
6123 : : * performing this operation is identified in the SEQUENCE
6124 : : * operation in this compound.
6125 : : *
6126 : : * When the client supports GETATTR(fs_locations_info), it can
6127 : : * be plumbed in here.
6128 : : */
6129 : : static int _nfs41_proc_get_locations(struct inode *inode,
6130 : : struct nfs4_fs_locations *locations,
6131 : : struct page *page, struct rpc_cred *cred)
6132 : : {
6133 : : struct nfs_server *server = NFS_SERVER(inode);
6134 : : struct rpc_clnt *clnt = server->client;
6135 : : u32 bitmask[2] = {
6136 : : [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
6137 : : };
6138 : : struct nfs4_fs_locations_arg args = {
6139 : : .fh = NFS_FH(inode),
6140 : : .page = page,
6141 : : .bitmask = bitmask,
6142 : : .migration = 1, /* skip LOOKUP */
6143 : : };
6144 : : struct nfs4_fs_locations_res res = {
6145 : : .fs_locations = locations,
6146 : : .migration = 1,
6147 : : };
6148 : : struct rpc_message msg = {
6149 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
6150 : : .rpc_argp = &args,
6151 : : .rpc_resp = &res,
6152 : : .rpc_cred = cred,
6153 : : };
6154 : : int status;
6155 : :
6156 : : nfs_fattr_init(&locations->fattr);
6157 : : locations->server = server;
6158 : : locations->nlocations = 0;
6159 : :
6160 : : nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
6161 : : nfs4_set_sequence_privileged(&args.seq_args);
6162 : : status = nfs4_call_sync_sequence(clnt, server, &msg,
6163 : : &args.seq_args, &res.seq_res);
6164 : : if (status == NFS4_OK &&
6165 : : res.seq_res.sr_status_flags & SEQ4_STATUS_LEASE_MOVED)
6166 : : status = -NFS4ERR_LEASE_MOVED;
6167 : : return status;
6168 : : }
6169 : :
6170 : : #endif /* CONFIG_NFS_V4_1 */
6171 : :
6172 : : /**
6173 : : * nfs4_proc_get_locations - discover locations for a migrated FSID
6174 : : * @inode: inode on FSID that is migrating
6175 : : * @locations: result of query
6176 : : * @page: buffer
6177 : : * @cred: credential to use for this operation
6178 : : *
6179 : : * Returns NFS4_OK on success, a negative NFS4ERR status code if the
6180 : : * operation failed, or a negative errno if a local error occurred.
6181 : : *
6182 : : * On success, "locations" is filled in, but if the server has
6183 : : * no locations information, NFS_ATTR_FATTR_V4_LOCATIONS is not
6184 : : * asserted.
6185 : : *
6186 : : * -NFS4ERR_LEASE_MOVED is returned if the server still has leases
6187 : : * from this client that require migration recovery.
6188 : : */
6189 : 0 : int nfs4_proc_get_locations(struct inode *inode,
6190 : : struct nfs4_fs_locations *locations,
6191 : : struct page *page, struct rpc_cred *cred)
6192 : : {
6193 : : struct nfs_server *server = NFS_SERVER(inode);
6194 : 0 : struct nfs_client *clp = server->nfs_client;
6195 : 0 : const struct nfs4_mig_recovery_ops *ops =
6196 : 0 : clp->cl_mvops->mig_recovery_ops;
6197 : 0 : struct nfs4_exception exception = { };
6198 : : int status;
6199 : :
6200 : : dprintk("%s: FSID %llx:%llx on \"%s\"\n", __func__,
6201 : : (unsigned long long)server->fsid.major,
6202 : : (unsigned long long)server->fsid.minor,
6203 : : clp->cl_hostname);
6204 : : nfs_display_fhandle(NFS_FH(inode), __func__);
6205 : :
6206 : : do {
6207 : 0 : status = ops->get_locations(inode, locations, page, cred);
6208 [ # # ]: 0 : if (status != -NFS4ERR_DELAY)
6209 : : break;
6210 : 0 : nfs4_handle_exception(server, status, &exception);
6211 [ # # ]: 0 : } while (exception.retry);
6212 : 0 : return status;
6213 : : }
6214 : :
6215 : : /*
6216 : : * This operation also signals the server that this client is
6217 : : * performing "lease moved" recovery. The server can stop
6218 : : * returning NFS4ERR_LEASE_MOVED to this client. A RENEW operation
6219 : : * is appended to this compound to identify the client ID which is
6220 : : * performing recovery.
6221 : : */
6222 : 0 : static int _nfs40_proc_fsid_present(struct inode *inode, struct rpc_cred *cred)
6223 : : {
6224 : : struct nfs_server *server = NFS_SERVER(inode);
6225 : 0 : struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
6226 : 0 : struct rpc_clnt *clnt = server->client;
6227 : 0 : struct nfs4_fsid_present_arg args = {
6228 : 0 : .fh = NFS_FH(inode),
6229 : 0 : .clientid = clp->cl_clientid,
6230 : : .renew = 1, /* append RENEW */
6231 : : };
6232 : 0 : struct nfs4_fsid_present_res res = {
6233 : : .renew = 1,
6234 : : };
6235 : 0 : struct rpc_message msg = {
6236 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSID_PRESENT],
6237 : : .rpc_argp = &args,
6238 : : .rpc_resp = &res,
6239 : : .rpc_cred = cred,
6240 : : };
6241 : 0 : unsigned long now = jiffies;
6242 : : int status;
6243 : :
6244 : 0 : res.fh = nfs_alloc_fhandle();
6245 [ # # ]: 0 : if (res.fh == NULL)
6246 : : return -ENOMEM;
6247 : :
6248 : : nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
6249 : : nfs4_set_sequence_privileged(&args.seq_args);
6250 : 0 : status = nfs4_call_sync_sequence(clnt, server, &msg,
6251 : : &args.seq_args, &res.seq_res);
6252 : 0 : nfs_free_fhandle(res.fh);
6253 [ # # ]: 0 : if (status)
6254 : : return status;
6255 : :
6256 : 0 : do_renew_lease(clp, now);
6257 : 0 : return 0;
6258 : : }
6259 : :
6260 : : #ifdef CONFIG_NFS_V4_1
6261 : :
6262 : : /*
6263 : : * This operation also signals the server that this client is
6264 : : * performing "lease moved" recovery. The server can stop asserting
6265 : : * SEQ4_STATUS_LEASE_MOVED for this client. The client ID performing
6266 : : * this operation is identified in the SEQUENCE operation in this
6267 : : * compound.
6268 : : */
6269 : : static int _nfs41_proc_fsid_present(struct inode *inode, struct rpc_cred *cred)
6270 : : {
6271 : : struct nfs_server *server = NFS_SERVER(inode);
6272 : : struct rpc_clnt *clnt = server->client;
6273 : : struct nfs4_fsid_present_arg args = {
6274 : : .fh = NFS_FH(inode),
6275 : : };
6276 : : struct nfs4_fsid_present_res res = {
6277 : : };
6278 : : struct rpc_message msg = {
6279 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSID_PRESENT],
6280 : : .rpc_argp = &args,
6281 : : .rpc_resp = &res,
6282 : : .rpc_cred = cred,
6283 : : };
6284 : : int status;
6285 : :
6286 : : res.fh = nfs_alloc_fhandle();
6287 : : if (res.fh == NULL)
6288 : : return -ENOMEM;
6289 : :
6290 : : nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
6291 : : nfs4_set_sequence_privileged(&args.seq_args);
6292 : : status = nfs4_call_sync_sequence(clnt, server, &msg,
6293 : : &args.seq_args, &res.seq_res);
6294 : : nfs_free_fhandle(res.fh);
6295 : : if (status == NFS4_OK &&
6296 : : res.seq_res.sr_status_flags & SEQ4_STATUS_LEASE_MOVED)
6297 : : status = -NFS4ERR_LEASE_MOVED;
6298 : : return status;
6299 : : }
6300 : :
6301 : : #endif /* CONFIG_NFS_V4_1 */
6302 : :
6303 : : /**
6304 : : * nfs4_proc_fsid_present - Is this FSID present or absent on server?
6305 : : * @inode: inode on FSID to check
6306 : : * @cred: credential to use for this operation
6307 : : *
6308 : : * Server indicates whether the FSID is present, moved, or not
6309 : : * recognized. This operation is necessary to clear a LEASE_MOVED
6310 : : * condition for this client ID.
6311 : : *
6312 : : * Returns NFS4_OK if the FSID is present on this server,
6313 : : * -NFS4ERR_MOVED if the FSID is no longer present, a negative
6314 : : * NFS4ERR code if some error occurred on the server, or a
6315 : : * negative errno if a local failure occurred.
6316 : : */
6317 : 0 : int nfs4_proc_fsid_present(struct inode *inode, struct rpc_cred *cred)
6318 : : {
6319 : : struct nfs_server *server = NFS_SERVER(inode);
6320 : 0 : struct nfs_client *clp = server->nfs_client;
6321 : 0 : const struct nfs4_mig_recovery_ops *ops =
6322 : 0 : clp->cl_mvops->mig_recovery_ops;
6323 : 0 : struct nfs4_exception exception = { };
6324 : : int status;
6325 : :
6326 : : dprintk("%s: FSID %llx:%llx on \"%s\"\n", __func__,
6327 : : (unsigned long long)server->fsid.major,
6328 : : (unsigned long long)server->fsid.minor,
6329 : : clp->cl_hostname);
6330 : : nfs_display_fhandle(NFS_FH(inode), __func__);
6331 : :
6332 : : do {
6333 : 0 : status = ops->fsid_present(inode, cred);
6334 [ # # ]: 0 : if (status != -NFS4ERR_DELAY)
6335 : : break;
6336 : 0 : nfs4_handle_exception(server, status, &exception);
6337 [ # # ]: 0 : } while (exception.retry);
6338 : 0 : return status;
6339 : : }
6340 : :
6341 : : /**
6342 : : * If 'use_integrity' is true and the state managment nfs_client
6343 : : * cl_rpcclient is using krb5i/p, use the integrity protected cl_rpcclient
6344 : : * and the machine credential as per RFC3530bis and RFC5661 Security
6345 : : * Considerations sections. Otherwise, just use the user cred with the
6346 : : * filesystem's rpc_client.
6347 : : */
6348 : 0 : static int _nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct nfs4_secinfo_flavors *flavors, bool use_integrity)
6349 : : {
6350 : : int status;
6351 : 0 : struct nfs4_secinfo_arg args = {
6352 : 0 : .dir_fh = NFS_FH(dir),
6353 : : .name = name,
6354 : : };
6355 : 0 : struct nfs4_secinfo_res res = {
6356 : : .flavors = flavors,
6357 : : };
6358 : 0 : struct rpc_message msg = {
6359 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO],
6360 : : .rpc_argp = &args,
6361 : : .rpc_resp = &res,
6362 : : };
6363 : 0 : struct rpc_clnt *clnt = NFS_SERVER(dir)->client;
6364 : : struct rpc_cred *cred = NULL;
6365 : :
6366 [ # # ]: 0 : if (use_integrity) {
6367 : 0 : clnt = NFS_SERVER(dir)->nfs_client->cl_rpcclient;
6368 : 0 : cred = nfs4_get_clid_cred(NFS_SERVER(dir)->nfs_client);
6369 : 0 : msg.rpc_cred = cred;
6370 : : }
6371 : :
6372 : : dprintk("NFS call secinfo %s\n", name->name);
6373 : :
6374 : : nfs4_state_protect(NFS_SERVER(dir)->nfs_client,
6375 : : NFS_SP4_MACH_CRED_SECINFO, &clnt, &msg);
6376 : :
6377 : : status = nfs4_call_sync(clnt, NFS_SERVER(dir), &msg, &args.seq_args,
6378 : : &res.seq_res, 0);
6379 : : dprintk("NFS reply secinfo: %d\n", status);
6380 : :
6381 [ # # ]: 0 : if (cred)
6382 : 0 : put_rpccred(cred);
6383 : :
6384 : 0 : return status;
6385 : : }
6386 : :
6387 : 0 : int nfs4_proc_secinfo(struct inode *dir, const struct qstr *name,
6388 : : struct nfs4_secinfo_flavors *flavors)
6389 : : {
6390 : 0 : struct nfs4_exception exception = { };
6391 : : int err;
6392 : : do {
6393 : : err = -NFS4ERR_WRONGSEC;
6394 : :
6395 : : /* try to use integrity protection with machine cred */
6396 [ # # ]: 0 : if (_nfs4_is_integrity_protected(NFS_SERVER(dir)->nfs_client))
6397 : 0 : err = _nfs4_proc_secinfo(dir, name, flavors, true);
6398 : :
6399 : : /*
6400 : : * if unable to use integrity protection, or SECINFO with
6401 : : * integrity protection returns NFS4ERR_WRONGSEC (which is
6402 : : * disallowed by spec, but exists in deployed servers) use
6403 : : * the current filesystem's rpc_client and the user cred.
6404 : : */
6405 [ # # ]: 0 : if (err == -NFS4ERR_WRONGSEC)
6406 : 0 : err = _nfs4_proc_secinfo(dir, name, flavors, false);
6407 : :
6408 : : trace_nfs4_secinfo(dir, name, err);
6409 : 0 : err = nfs4_handle_exception(NFS_SERVER(dir), err,
6410 : : &exception);
6411 [ # # ]: 0 : } while (exception.retry);
6412 : 0 : return err;
6413 : : }
6414 : :
6415 : : #ifdef CONFIG_NFS_V4_1
6416 : : /*
6417 : : * Check the exchange flags returned by the server for invalid flags, having
6418 : : * both PNFS and NON_PNFS flags set, and not having one of NON_PNFS, PNFS, or
6419 : : * DS flags set.
6420 : : */
6421 : : static int nfs4_check_cl_exchange_flags(u32 flags)
6422 : : {
6423 : : if (flags & ~EXCHGID4_FLAG_MASK_R)
6424 : : goto out_inval;
6425 : : if ((flags & EXCHGID4_FLAG_USE_PNFS_MDS) &&
6426 : : (flags & EXCHGID4_FLAG_USE_NON_PNFS))
6427 : : goto out_inval;
6428 : : if (!(flags & (EXCHGID4_FLAG_MASK_PNFS)))
6429 : : goto out_inval;
6430 : : return NFS_OK;
6431 : : out_inval:
6432 : : return -NFS4ERR_INVAL;
6433 : : }
6434 : :
6435 : : static bool
6436 : : nfs41_same_server_scope(struct nfs41_server_scope *a,
6437 : : struct nfs41_server_scope *b)
6438 : : {
6439 : : if (a->server_scope_sz == b->server_scope_sz &&
6440 : : memcmp(a->server_scope, b->server_scope, a->server_scope_sz) == 0)
6441 : : return true;
6442 : :
6443 : : return false;
6444 : : }
6445 : :
6446 : : /*
6447 : : * nfs4_proc_bind_conn_to_session()
6448 : : *
6449 : : * The 4.1 client currently uses the same TCP connection for the
6450 : : * fore and backchannel.
6451 : : */
6452 : : int nfs4_proc_bind_conn_to_session(struct nfs_client *clp, struct rpc_cred *cred)
6453 : : {
6454 : : int status;
6455 : : struct nfs41_bind_conn_to_session_res res;
6456 : : struct rpc_message msg = {
6457 : : .rpc_proc =
6458 : : &nfs4_procedures[NFSPROC4_CLNT_BIND_CONN_TO_SESSION],
6459 : : .rpc_argp = clp,
6460 : : .rpc_resp = &res,
6461 : : .rpc_cred = cred,
6462 : : };
6463 : :
6464 : : dprintk("--> %s\n", __func__);
6465 : :
6466 : : res.session = kzalloc(sizeof(struct nfs4_session), GFP_NOFS);
6467 : : if (unlikely(res.session == NULL)) {
6468 : : status = -ENOMEM;
6469 : : goto out;
6470 : : }
6471 : :
6472 : : status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
6473 : : trace_nfs4_bind_conn_to_session(clp, status);
6474 : : if (status == 0) {
6475 : : if (memcmp(res.session->sess_id.data,
6476 : : clp->cl_session->sess_id.data, NFS4_MAX_SESSIONID_LEN)) {
6477 : : dprintk("NFS: %s: Session ID mismatch\n", __func__);
6478 : : status = -EIO;
6479 : : goto out_session;
6480 : : }
6481 : : if (res.dir != NFS4_CDFS4_BOTH) {
6482 : : dprintk("NFS: %s: Unexpected direction from server\n",
6483 : : __func__);
6484 : : status = -EIO;
6485 : : goto out_session;
6486 : : }
6487 : : if (res.use_conn_in_rdma_mode) {
6488 : : dprintk("NFS: %s: Server returned RDMA mode = true\n",
6489 : : __func__);
6490 : : status = -EIO;
6491 : : goto out_session;
6492 : : }
6493 : : }
6494 : : out_session:
6495 : : kfree(res.session);
6496 : : out:
6497 : : dprintk("<-- %s status= %d\n", __func__, status);
6498 : : return status;
6499 : : }
6500 : :
6501 : : /*
6502 : : * Minimum set of SP4_MACH_CRED operations from RFC 5661 in the enforce map
6503 : : * and operations we'd like to see to enable certain features in the allow map
6504 : : */
6505 : : static const struct nfs41_state_protection nfs4_sp4_mach_cred_request = {
6506 : : .how = SP4_MACH_CRED,
6507 : : .enforce.u.words = {
6508 : : [1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) |
6509 : : 1 << (OP_EXCHANGE_ID - 32) |
6510 : : 1 << (OP_CREATE_SESSION - 32) |
6511 : : 1 << (OP_DESTROY_SESSION - 32) |
6512 : : 1 << (OP_DESTROY_CLIENTID - 32)
6513 : : },
6514 : : .allow.u.words = {
6515 : : [0] = 1 << (OP_CLOSE) |
6516 : : 1 << (OP_LOCKU) |
6517 : : 1 << (OP_COMMIT),
6518 : : [1] = 1 << (OP_SECINFO - 32) |
6519 : : 1 << (OP_SECINFO_NO_NAME - 32) |
6520 : : 1 << (OP_TEST_STATEID - 32) |
6521 : : 1 << (OP_FREE_STATEID - 32) |
6522 : : 1 << (OP_WRITE - 32)
6523 : : }
6524 : : };
6525 : :
6526 : : /*
6527 : : * Select the state protection mode for client `clp' given the server results
6528 : : * from exchange_id in `sp'.
6529 : : *
6530 : : * Returns 0 on success, negative errno otherwise.
6531 : : */
6532 : : static int nfs4_sp4_select_mode(struct nfs_client *clp,
6533 : : struct nfs41_state_protection *sp)
6534 : : {
6535 : : static const u32 supported_enforce[NFS4_OP_MAP_NUM_WORDS] = {
6536 : : [1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) |
6537 : : 1 << (OP_EXCHANGE_ID - 32) |
6538 : : 1 << (OP_CREATE_SESSION - 32) |
6539 : : 1 << (OP_DESTROY_SESSION - 32) |
6540 : : 1 << (OP_DESTROY_CLIENTID - 32)
6541 : : };
6542 : : unsigned int i;
6543 : :
6544 : : if (sp->how == SP4_MACH_CRED) {
6545 : : /* Print state protect result */
6546 : : dfprintk(MOUNT, "Server SP4_MACH_CRED support:\n");
6547 : : for (i = 0; i <= LAST_NFS4_OP; i++) {
6548 : : if (test_bit(i, sp->enforce.u.longs))
6549 : : dfprintk(MOUNT, " enforce op %d\n", i);
6550 : : if (test_bit(i, sp->allow.u.longs))
6551 : : dfprintk(MOUNT, " allow op %d\n", i);
6552 : : }
6553 : :
6554 : : /* make sure nothing is on enforce list that isn't supported */
6555 : : for (i = 0; i < NFS4_OP_MAP_NUM_WORDS; i++) {
6556 : : if (sp->enforce.u.words[i] & ~supported_enforce[i]) {
6557 : : dfprintk(MOUNT, "sp4_mach_cred: disabled\n");
6558 : : return -EINVAL;
6559 : : }
6560 : : }
6561 : :
6562 : : /*
6563 : : * Minimal mode - state operations are allowed to use machine
6564 : : * credential. Note this already happens by default, so the
6565 : : * client doesn't have to do anything more than the negotiation.
6566 : : *
6567 : : * NOTE: we don't care if EXCHANGE_ID is in the list -
6568 : : * we're already using the machine cred for exchange_id
6569 : : * and will never use a different cred.
6570 : : */
6571 : : if (test_bit(OP_BIND_CONN_TO_SESSION, sp->enforce.u.longs) &&
6572 : : test_bit(OP_CREATE_SESSION, sp->enforce.u.longs) &&
6573 : : test_bit(OP_DESTROY_SESSION, sp->enforce.u.longs) &&
6574 : : test_bit(OP_DESTROY_CLIENTID, sp->enforce.u.longs)) {
6575 : : dfprintk(MOUNT, "sp4_mach_cred:\n");
6576 : : dfprintk(MOUNT, " minimal mode enabled\n");
6577 : : set_bit(NFS_SP4_MACH_CRED_MINIMAL, &clp->cl_sp4_flags);
6578 : : } else {
6579 : : dfprintk(MOUNT, "sp4_mach_cred: disabled\n");
6580 : : return -EINVAL;
6581 : : }
6582 : :
6583 : : if (test_bit(OP_CLOSE, sp->allow.u.longs) &&
6584 : : test_bit(OP_LOCKU, sp->allow.u.longs)) {
6585 : : dfprintk(MOUNT, " cleanup mode enabled\n");
6586 : : set_bit(NFS_SP4_MACH_CRED_CLEANUP, &clp->cl_sp4_flags);
6587 : : }
6588 : :
6589 : : if (test_bit(OP_SECINFO, sp->allow.u.longs) &&
6590 : : test_bit(OP_SECINFO_NO_NAME, sp->allow.u.longs)) {
6591 : : dfprintk(MOUNT, " secinfo mode enabled\n");
6592 : : set_bit(NFS_SP4_MACH_CRED_SECINFO, &clp->cl_sp4_flags);
6593 : : }
6594 : :
6595 : : if (test_bit(OP_TEST_STATEID, sp->allow.u.longs) &&
6596 : : test_bit(OP_FREE_STATEID, sp->allow.u.longs)) {
6597 : : dfprintk(MOUNT, " stateid mode enabled\n");
6598 : : set_bit(NFS_SP4_MACH_CRED_STATEID, &clp->cl_sp4_flags);
6599 : : }
6600 : :
6601 : : if (test_bit(OP_WRITE, sp->allow.u.longs)) {
6602 : : dfprintk(MOUNT, " write mode enabled\n");
6603 : : set_bit(NFS_SP4_MACH_CRED_WRITE, &clp->cl_sp4_flags);
6604 : : }
6605 : :
6606 : : if (test_bit(OP_COMMIT, sp->allow.u.longs)) {
6607 : : dfprintk(MOUNT, " commit mode enabled\n");
6608 : : set_bit(NFS_SP4_MACH_CRED_COMMIT, &clp->cl_sp4_flags);
6609 : : }
6610 : : }
6611 : :
6612 : : return 0;
6613 : : }
6614 : :
6615 : : /*
6616 : : * _nfs4_proc_exchange_id()
6617 : : *
6618 : : * Wrapper for EXCHANGE_ID operation.
6619 : : */
6620 : : static int _nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred,
6621 : : u32 sp4_how)
6622 : : {
6623 : : nfs4_verifier verifier;
6624 : : struct nfs41_exchange_id_args args = {
6625 : : .verifier = &verifier,
6626 : : .client = clp,
6627 : : #ifdef CONFIG_NFS_V4_1_MIGRATION
6628 : : .flags = EXCHGID4_FLAG_SUPP_MOVED_REFER |
6629 : : EXCHGID4_FLAG_BIND_PRINC_STATEID |
6630 : : EXCHGID4_FLAG_SUPP_MOVED_MIGR,
6631 : : #else
6632 : : .flags = EXCHGID4_FLAG_SUPP_MOVED_REFER |
6633 : : EXCHGID4_FLAG_BIND_PRINC_STATEID,
6634 : : #endif
6635 : : };
6636 : : struct nfs41_exchange_id_res res = {
6637 : : 0
6638 : : };
6639 : : int status;
6640 : : struct rpc_message msg = {
6641 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_EXCHANGE_ID],
6642 : : .rpc_argp = &args,
6643 : : .rpc_resp = &res,
6644 : : .rpc_cred = cred,
6645 : : };
6646 : :
6647 : : nfs4_init_boot_verifier(clp, &verifier);
6648 : : args.id_len = nfs4_init_uniform_client_string(clp, args.id,
6649 : : sizeof(args.id));
6650 : : dprintk("NFS call exchange_id auth=%s, '%.*s'\n",
6651 : : clp->cl_rpcclient->cl_auth->au_ops->au_name,
6652 : : args.id_len, args.id);
6653 : :
6654 : : res.server_owner = kzalloc(sizeof(struct nfs41_server_owner),
6655 : : GFP_NOFS);
6656 : : if (unlikely(res.server_owner == NULL)) {
6657 : : status = -ENOMEM;
6658 : : goto out;
6659 : : }
6660 : :
6661 : : res.server_scope = kzalloc(sizeof(struct nfs41_server_scope),
6662 : : GFP_NOFS);
6663 : : if (unlikely(res.server_scope == NULL)) {
6664 : : status = -ENOMEM;
6665 : : goto out_server_owner;
6666 : : }
6667 : :
6668 : : res.impl_id = kzalloc(sizeof(struct nfs41_impl_id), GFP_NOFS);
6669 : : if (unlikely(res.impl_id == NULL)) {
6670 : : status = -ENOMEM;
6671 : : goto out_server_scope;
6672 : : }
6673 : :
6674 : : switch (sp4_how) {
6675 : : case SP4_NONE:
6676 : : args.state_protect.how = SP4_NONE;
6677 : : break;
6678 : :
6679 : : case SP4_MACH_CRED:
6680 : : args.state_protect = nfs4_sp4_mach_cred_request;
6681 : : break;
6682 : :
6683 : : default:
6684 : : /* unsupported! */
6685 : : WARN_ON_ONCE(1);
6686 : : status = -EINVAL;
6687 : : goto out_server_scope;
6688 : : }
6689 : :
6690 : : status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
6691 : : trace_nfs4_exchange_id(clp, status);
6692 : : if (status == 0)
6693 : : status = nfs4_check_cl_exchange_flags(res.flags);
6694 : :
6695 : : if (status == 0)
6696 : : status = nfs4_sp4_select_mode(clp, &res.state_protect);
6697 : :
6698 : : if (status == 0) {
6699 : : clp->cl_clientid = res.clientid;
6700 : : clp->cl_exchange_flags = (res.flags & ~EXCHGID4_FLAG_CONFIRMED_R);
6701 : : if (!(res.flags & EXCHGID4_FLAG_CONFIRMED_R))
6702 : : clp->cl_seqid = res.seqid;
6703 : :
6704 : : kfree(clp->cl_serverowner);
6705 : : clp->cl_serverowner = res.server_owner;
6706 : : res.server_owner = NULL;
6707 : :
6708 : : /* use the most recent implementation id */
6709 : : kfree(clp->cl_implid);
6710 : : clp->cl_implid = res.impl_id;
6711 : :
6712 : : if (clp->cl_serverscope != NULL &&
6713 : : !nfs41_same_server_scope(clp->cl_serverscope,
6714 : : res.server_scope)) {
6715 : : dprintk("%s: server_scope mismatch detected\n",
6716 : : __func__);
6717 : : set_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state);
6718 : : kfree(clp->cl_serverscope);
6719 : : clp->cl_serverscope = NULL;
6720 : : }
6721 : :
6722 : : if (clp->cl_serverscope == NULL) {
6723 : : clp->cl_serverscope = res.server_scope;
6724 : : goto out;
6725 : : }
6726 : : } else
6727 : : kfree(res.impl_id);
6728 : :
6729 : : out_server_owner:
6730 : : kfree(res.server_owner);
6731 : : out_server_scope:
6732 : : kfree(res.server_scope);
6733 : : out:
6734 : : if (clp->cl_implid != NULL)
6735 : : dprintk("NFS reply exchange_id: Server Implementation ID: "
6736 : : "domain: %s, name: %s, date: %llu,%u\n",
6737 : : clp->cl_implid->domain, clp->cl_implid->name,
6738 : : clp->cl_implid->date.seconds,
6739 : : clp->cl_implid->date.nseconds);
6740 : : dprintk("NFS reply exchange_id: %d\n", status);
6741 : : return status;
6742 : : }
6743 : :
6744 : : /*
6745 : : * nfs4_proc_exchange_id()
6746 : : *
6747 : : * Returns zero, a negative errno, or a negative NFS4ERR status code.
6748 : : *
6749 : : * Since the clientid has expired, all compounds using sessions
6750 : : * associated with the stale clientid will be returning
6751 : : * NFS4ERR_BADSESSION in the sequence operation, and will therefore
6752 : : * be in some phase of session reset.
6753 : : *
6754 : : * Will attempt to negotiate SP4_MACH_CRED if krb5i / krb5p auth is used.
6755 : : */
6756 : : int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)
6757 : : {
6758 : : rpc_authflavor_t authflavor = clp->cl_rpcclient->cl_auth->au_flavor;
6759 : : int status;
6760 : :
6761 : : /* try SP4_MACH_CRED if krb5i/p */
6762 : : if (authflavor == RPC_AUTH_GSS_KRB5I ||
6763 : : authflavor == RPC_AUTH_GSS_KRB5P) {
6764 : : status = _nfs4_proc_exchange_id(clp, cred, SP4_MACH_CRED);
6765 : : if (!status)
6766 : : return 0;
6767 : : }
6768 : :
6769 : : /* try SP4_NONE */
6770 : : return _nfs4_proc_exchange_id(clp, cred, SP4_NONE);
6771 : : }
6772 : :
6773 : : static int _nfs4_proc_destroy_clientid(struct nfs_client *clp,
6774 : : struct rpc_cred *cred)
6775 : : {
6776 : : struct rpc_message msg = {
6777 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_CLIENTID],
6778 : : .rpc_argp = clp,
6779 : : .rpc_cred = cred,
6780 : : };
6781 : : int status;
6782 : :
6783 : : status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
6784 : : trace_nfs4_destroy_clientid(clp, status);
6785 : : if (status)
6786 : : dprintk("NFS: Got error %d from the server %s on "
6787 : : "DESTROY_CLIENTID.", status, clp->cl_hostname);
6788 : : return status;
6789 : : }
6790 : :
6791 : : static int nfs4_proc_destroy_clientid(struct nfs_client *clp,
6792 : : struct rpc_cred *cred)
6793 : : {
6794 : : unsigned int loop;
6795 : : int ret;
6796 : :
6797 : : for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) {
6798 : : ret = _nfs4_proc_destroy_clientid(clp, cred);
6799 : : switch (ret) {
6800 : : case -NFS4ERR_DELAY:
6801 : : case -NFS4ERR_CLIENTID_BUSY:
6802 : : ssleep(1);
6803 : : break;
6804 : : default:
6805 : : return ret;
6806 : : }
6807 : : }
6808 : : return 0;
6809 : : }
6810 : :
6811 : : int nfs4_destroy_clientid(struct nfs_client *clp)
6812 : : {
6813 : : struct rpc_cred *cred;
6814 : : int ret = 0;
6815 : :
6816 : : if (clp->cl_mvops->minor_version < 1)
6817 : : goto out;
6818 : : if (clp->cl_exchange_flags == 0)
6819 : : goto out;
6820 : : if (clp->cl_preserve_clid)
6821 : : goto out;
6822 : : cred = nfs4_get_clid_cred(clp);
6823 : : ret = nfs4_proc_destroy_clientid(clp, cred);
6824 : : if (cred)
6825 : : put_rpccred(cred);
6826 : : switch (ret) {
6827 : : case 0:
6828 : : case -NFS4ERR_STALE_CLIENTID:
6829 : : clp->cl_exchange_flags = 0;
6830 : : }
6831 : : out:
6832 : : return ret;
6833 : : }
6834 : :
6835 : : struct nfs4_get_lease_time_data {
6836 : : struct nfs4_get_lease_time_args *args;
6837 : : struct nfs4_get_lease_time_res *res;
6838 : : struct nfs_client *clp;
6839 : : };
6840 : :
6841 : : static void nfs4_get_lease_time_prepare(struct rpc_task *task,
6842 : : void *calldata)
6843 : : {
6844 : : struct nfs4_get_lease_time_data *data =
6845 : : (struct nfs4_get_lease_time_data *)calldata;
6846 : :
6847 : : dprintk("--> %s\n", __func__);
6848 : : /* just setup sequence, do not trigger session recovery
6849 : : since we're invoked within one */
6850 : : nfs41_setup_sequence(data->clp->cl_session,
6851 : : &data->args->la_seq_args,
6852 : : &data->res->lr_seq_res,
6853 : : task);
6854 : : dprintk("<-- %s\n", __func__);
6855 : : }
6856 : :
6857 : : /*
6858 : : * Called from nfs4_state_manager thread for session setup, so don't recover
6859 : : * from sequence operation or clientid errors.
6860 : : */
6861 : : static void nfs4_get_lease_time_done(struct rpc_task *task, void *calldata)
6862 : : {
6863 : : struct nfs4_get_lease_time_data *data =
6864 : : (struct nfs4_get_lease_time_data *)calldata;
6865 : :
6866 : : dprintk("--> %s\n", __func__);
6867 : : if (!nfs41_sequence_done(task, &data->res->lr_seq_res))
6868 : : return;
6869 : : switch (task->tk_status) {
6870 : : case -NFS4ERR_DELAY:
6871 : : case -NFS4ERR_GRACE:
6872 : : dprintk("%s Retry: tk_status %d\n", __func__, task->tk_status);
6873 : : rpc_delay(task, NFS4_POLL_RETRY_MIN);
6874 : : task->tk_status = 0;
6875 : : /* fall through */
6876 : : case -NFS4ERR_RETRY_UNCACHED_REP:
6877 : : rpc_restart_call_prepare(task);
6878 : : return;
6879 : : }
6880 : : dprintk("<-- %s\n", __func__);
6881 : : }
6882 : :
6883 : : static const struct rpc_call_ops nfs4_get_lease_time_ops = {
6884 : : .rpc_call_prepare = nfs4_get_lease_time_prepare,
6885 : : .rpc_call_done = nfs4_get_lease_time_done,
6886 : : };
6887 : :
6888 : : int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo)
6889 : : {
6890 : : struct rpc_task *task;
6891 : : struct nfs4_get_lease_time_args args;
6892 : : struct nfs4_get_lease_time_res res = {
6893 : : .lr_fsinfo = fsinfo,
6894 : : };
6895 : : struct nfs4_get_lease_time_data data = {
6896 : : .args = &args,
6897 : : .res = &res,
6898 : : .clp = clp,
6899 : : };
6900 : : struct rpc_message msg = {
6901 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GET_LEASE_TIME],
6902 : : .rpc_argp = &args,
6903 : : .rpc_resp = &res,
6904 : : };
6905 : : struct rpc_task_setup task_setup = {
6906 : : .rpc_client = clp->cl_rpcclient,
6907 : : .rpc_message = &msg,
6908 : : .callback_ops = &nfs4_get_lease_time_ops,
6909 : : .callback_data = &data,
6910 : : .flags = RPC_TASK_TIMEOUT,
6911 : : };
6912 : : int status;
6913 : :
6914 : : nfs4_init_sequence(&args.la_seq_args, &res.lr_seq_res, 0);
6915 : : nfs4_set_sequence_privileged(&args.la_seq_args);
6916 : : dprintk("--> %s\n", __func__);
6917 : : task = rpc_run_task(&task_setup);
6918 : :
6919 : : if (IS_ERR(task))
6920 : : status = PTR_ERR(task);
6921 : : else {
6922 : : status = task->tk_status;
6923 : : rpc_put_task(task);
6924 : : }
6925 : : dprintk("<-- %s return %d\n", __func__, status);
6926 : :
6927 : : return status;
6928 : : }
6929 : :
6930 : : /*
6931 : : * Initialize the values to be used by the client in CREATE_SESSION
6932 : : * If nfs4_init_session set the fore channel request and response sizes,
6933 : : * use them.
6934 : : *
6935 : : * Set the back channel max_resp_sz_cached to zero to force the client to
6936 : : * always set csa_cachethis to FALSE because the current implementation
6937 : : * of the back channel DRC only supports caching the CB_SEQUENCE operation.
6938 : : */
6939 : : static void nfs4_init_channel_attrs(struct nfs41_create_session_args *args)
6940 : : {
6941 : : unsigned int max_rqst_sz, max_resp_sz;
6942 : :
6943 : : max_rqst_sz = NFS_MAX_FILE_IO_SIZE + nfs41_maxwrite_overhead;
6944 : : max_resp_sz = NFS_MAX_FILE_IO_SIZE + nfs41_maxread_overhead;
6945 : :
6946 : : /* Fore channel attributes */
6947 : : args->fc_attrs.max_rqst_sz = max_rqst_sz;
6948 : : args->fc_attrs.max_resp_sz = max_resp_sz;
6949 : : args->fc_attrs.max_ops = NFS4_MAX_OPS;
6950 : : args->fc_attrs.max_reqs = max_session_slots;
6951 : :
6952 : : dprintk("%s: Fore Channel : max_rqst_sz=%u max_resp_sz=%u "
6953 : : "max_ops=%u max_reqs=%u\n",
6954 : : __func__,
6955 : : args->fc_attrs.max_rqst_sz, args->fc_attrs.max_resp_sz,
6956 : : args->fc_attrs.max_ops, args->fc_attrs.max_reqs);
6957 : :
6958 : : /* Back channel attributes */
6959 : : args->bc_attrs.max_rqst_sz = PAGE_SIZE;
6960 : : args->bc_attrs.max_resp_sz = PAGE_SIZE;
6961 : : args->bc_attrs.max_resp_sz_cached = 0;
6962 : : args->bc_attrs.max_ops = NFS4_MAX_BACK_CHANNEL_OPS;
6963 : : args->bc_attrs.max_reqs = 1;
6964 : :
6965 : : dprintk("%s: Back Channel : max_rqst_sz=%u max_resp_sz=%u "
6966 : : "max_resp_sz_cached=%u max_ops=%u max_reqs=%u\n",
6967 : : __func__,
6968 : : args->bc_attrs.max_rqst_sz, args->bc_attrs.max_resp_sz,
6969 : : args->bc_attrs.max_resp_sz_cached, args->bc_attrs.max_ops,
6970 : : args->bc_attrs.max_reqs);
6971 : : }
6972 : :
6973 : : static int nfs4_verify_fore_channel_attrs(struct nfs41_create_session_args *args, struct nfs4_session *session)
6974 : : {
6975 : : struct nfs4_channel_attrs *sent = &args->fc_attrs;
6976 : : struct nfs4_channel_attrs *rcvd = &session->fc_attrs;
6977 : :
6978 : : if (rcvd->max_resp_sz > sent->max_resp_sz)
6979 : : return -EINVAL;
6980 : : /*
6981 : : * Our requested max_ops is the minimum we need; we're not
6982 : : * prepared to break up compounds into smaller pieces than that.
6983 : : * So, no point even trying to continue if the server won't
6984 : : * cooperate:
6985 : : */
6986 : : if (rcvd->max_ops < sent->max_ops)
6987 : : return -EINVAL;
6988 : : if (rcvd->max_reqs == 0)
6989 : : return -EINVAL;
6990 : : if (rcvd->max_reqs > NFS4_MAX_SLOT_TABLE)
6991 : : rcvd->max_reqs = NFS4_MAX_SLOT_TABLE;
6992 : : return 0;
6993 : : }
6994 : :
6995 : : static int nfs4_verify_back_channel_attrs(struct nfs41_create_session_args *args, struct nfs4_session *session)
6996 : : {
6997 : : struct nfs4_channel_attrs *sent = &args->bc_attrs;
6998 : : struct nfs4_channel_attrs *rcvd = &session->bc_attrs;
6999 : :
7000 : : if (rcvd->max_rqst_sz > sent->max_rqst_sz)
7001 : : return -EINVAL;
7002 : : if (rcvd->max_resp_sz < sent->max_resp_sz)
7003 : : return -EINVAL;
7004 : : if (rcvd->max_resp_sz_cached > sent->max_resp_sz_cached)
7005 : : return -EINVAL;
7006 : : /* These would render the backchannel useless: */
7007 : : if (rcvd->max_ops != sent->max_ops)
7008 : : return -EINVAL;
7009 : : if (rcvd->max_reqs != sent->max_reqs)
7010 : : return -EINVAL;
7011 : : return 0;
7012 : : }
7013 : :
7014 : : static int nfs4_verify_channel_attrs(struct nfs41_create_session_args *args,
7015 : : struct nfs4_session *session)
7016 : : {
7017 : : int ret;
7018 : :
7019 : : ret = nfs4_verify_fore_channel_attrs(args, session);
7020 : : if (ret)
7021 : : return ret;
7022 : : return nfs4_verify_back_channel_attrs(args, session);
7023 : : }
7024 : :
7025 : : static int _nfs4_proc_create_session(struct nfs_client *clp,
7026 : : struct rpc_cred *cred)
7027 : : {
7028 : : struct nfs4_session *session = clp->cl_session;
7029 : : struct nfs41_create_session_args args = {
7030 : : .client = clp,
7031 : : .cb_program = NFS4_CALLBACK,
7032 : : };
7033 : : struct nfs41_create_session_res res = {
7034 : : .client = clp,
7035 : : };
7036 : : struct rpc_message msg = {
7037 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE_SESSION],
7038 : : .rpc_argp = &args,
7039 : : .rpc_resp = &res,
7040 : : .rpc_cred = cred,
7041 : : };
7042 : : int status;
7043 : :
7044 : : nfs4_init_channel_attrs(&args);
7045 : : args.flags = (SESSION4_PERSIST | SESSION4_BACK_CHAN);
7046 : :
7047 : : status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
7048 : : trace_nfs4_create_session(clp, status);
7049 : :
7050 : : if (!status) {
7051 : : /* Verify the session's negotiated channel_attrs values */
7052 : : status = nfs4_verify_channel_attrs(&args, session);
7053 : : /* Increment the clientid slot sequence id */
7054 : : clp->cl_seqid++;
7055 : : }
7056 : :
7057 : : return status;
7058 : : }
7059 : :
7060 : : /*
7061 : : * Issues a CREATE_SESSION operation to the server.
7062 : : * It is the responsibility of the caller to verify the session is
7063 : : * expired before calling this routine.
7064 : : */
7065 : : int nfs4_proc_create_session(struct nfs_client *clp, struct rpc_cred *cred)
7066 : : {
7067 : : int status;
7068 : : unsigned *ptr;
7069 : : struct nfs4_session *session = clp->cl_session;
7070 : :
7071 : : dprintk("--> %s clp=%p session=%p\n", __func__, clp, session);
7072 : :
7073 : : status = _nfs4_proc_create_session(clp, cred);
7074 : : if (status)
7075 : : goto out;
7076 : :
7077 : : /* Init or reset the session slot tables */
7078 : : status = nfs4_setup_session_slot_tables(session);
7079 : : dprintk("slot table setup returned %d\n", status);
7080 : : if (status)
7081 : : goto out;
7082 : :
7083 : : ptr = (unsigned *)&session->sess_id.data[0];
7084 : : dprintk("%s client>seqid %d sessionid %u:%u:%u:%u\n", __func__,
7085 : : clp->cl_seqid, ptr[0], ptr[1], ptr[2], ptr[3]);
7086 : : out:
7087 : : dprintk("<-- %s\n", __func__);
7088 : : return status;
7089 : : }
7090 : :
7091 : : /*
7092 : : * Issue the over-the-wire RPC DESTROY_SESSION.
7093 : : * The caller must serialize access to this routine.
7094 : : */
7095 : : int nfs4_proc_destroy_session(struct nfs4_session *session,
7096 : : struct rpc_cred *cred)
7097 : : {
7098 : : struct rpc_message msg = {
7099 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_SESSION],
7100 : : .rpc_argp = session,
7101 : : .rpc_cred = cred,
7102 : : };
7103 : : int status = 0;
7104 : :
7105 : : dprintk("--> nfs4_proc_destroy_session\n");
7106 : :
7107 : : /* session is still being setup */
7108 : : if (session->clp->cl_cons_state != NFS_CS_READY)
7109 : : return status;
7110 : :
7111 : : status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
7112 : : trace_nfs4_destroy_session(session->clp, status);
7113 : :
7114 : : if (status)
7115 : : dprintk("NFS: Got error %d from the server on DESTROY_SESSION. "
7116 : : "Session has been destroyed regardless...\n", status);
7117 : :
7118 : : dprintk("<-- nfs4_proc_destroy_session\n");
7119 : : return status;
7120 : : }
7121 : :
7122 : : /*
7123 : : * Renew the cl_session lease.
7124 : : */
7125 : : struct nfs4_sequence_data {
7126 : : struct nfs_client *clp;
7127 : : struct nfs4_sequence_args args;
7128 : : struct nfs4_sequence_res res;
7129 : : };
7130 : :
7131 : : static void nfs41_sequence_release(void *data)
7132 : : {
7133 : : struct nfs4_sequence_data *calldata = data;
7134 : : struct nfs_client *clp = calldata->clp;
7135 : :
7136 : : if (atomic_read(&clp->cl_count) > 1)
7137 : : nfs4_schedule_state_renewal(clp);
7138 : : nfs_put_client(clp);
7139 : : kfree(calldata);
7140 : : }
7141 : :
7142 : : static int nfs41_sequence_handle_errors(struct rpc_task *task, struct nfs_client *clp)
7143 : : {
7144 : : switch(task->tk_status) {
7145 : : case -NFS4ERR_DELAY:
7146 : : rpc_delay(task, NFS4_POLL_RETRY_MAX);
7147 : : return -EAGAIN;
7148 : : default:
7149 : : nfs4_schedule_lease_recovery(clp);
7150 : : }
7151 : : return 0;
7152 : : }
7153 : :
7154 : : static void nfs41_sequence_call_done(struct rpc_task *task, void *data)
7155 : : {
7156 : : struct nfs4_sequence_data *calldata = data;
7157 : : struct nfs_client *clp = calldata->clp;
7158 : :
7159 : : if (!nfs41_sequence_done(task, task->tk_msg.rpc_resp))
7160 : : return;
7161 : :
7162 : : trace_nfs4_sequence(clp, task->tk_status);
7163 : : if (task->tk_status < 0) {
7164 : : dprintk("%s ERROR %d\n", __func__, task->tk_status);
7165 : : if (atomic_read(&clp->cl_count) == 1)
7166 : : goto out;
7167 : :
7168 : : if (nfs41_sequence_handle_errors(task, clp) == -EAGAIN) {
7169 : : rpc_restart_call_prepare(task);
7170 : : return;
7171 : : }
7172 : : }
7173 : : dprintk("%s rpc_cred %p\n", __func__, task->tk_msg.rpc_cred);
7174 : : out:
7175 : : dprintk("<-- %s\n", __func__);
7176 : : }
7177 : :
7178 : : static void nfs41_sequence_prepare(struct rpc_task *task, void *data)
7179 : : {
7180 : : struct nfs4_sequence_data *calldata = data;
7181 : : struct nfs_client *clp = calldata->clp;
7182 : : struct nfs4_sequence_args *args;
7183 : : struct nfs4_sequence_res *res;
7184 : :
7185 : : args = task->tk_msg.rpc_argp;
7186 : : res = task->tk_msg.rpc_resp;
7187 : :
7188 : : nfs41_setup_sequence(clp->cl_session, args, res, task);
7189 : : }
7190 : :
7191 : : static const struct rpc_call_ops nfs41_sequence_ops = {
7192 : : .rpc_call_done = nfs41_sequence_call_done,
7193 : : .rpc_call_prepare = nfs41_sequence_prepare,
7194 : : .rpc_release = nfs41_sequence_release,
7195 : : };
7196 : :
7197 : : static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp,
7198 : : struct rpc_cred *cred,
7199 : : bool is_privileged)
7200 : : {
7201 : : struct nfs4_sequence_data *calldata;
7202 : : struct rpc_message msg = {
7203 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEQUENCE],
7204 : : .rpc_cred = cred,
7205 : : };
7206 : : struct rpc_task_setup task_setup_data = {
7207 : : .rpc_client = clp->cl_rpcclient,
7208 : : .rpc_message = &msg,
7209 : : .callback_ops = &nfs41_sequence_ops,
7210 : : .flags = RPC_TASK_ASYNC | RPC_TASK_TIMEOUT,
7211 : : };
7212 : :
7213 : : if (!atomic_inc_not_zero(&clp->cl_count))
7214 : : return ERR_PTR(-EIO);
7215 : : calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
7216 : : if (calldata == NULL) {
7217 : : nfs_put_client(clp);
7218 : : return ERR_PTR(-ENOMEM);
7219 : : }
7220 : : nfs4_init_sequence(&calldata->args, &calldata->res, 0);
7221 : : if (is_privileged)
7222 : : nfs4_set_sequence_privileged(&calldata->args);
7223 : : msg.rpc_argp = &calldata->args;
7224 : : msg.rpc_resp = &calldata->res;
7225 : : calldata->clp = clp;
7226 : : task_setup_data.callback_data = calldata;
7227 : :
7228 : : return rpc_run_task(&task_setup_data);
7229 : : }
7230 : :
7231 : : static int nfs41_proc_async_sequence(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags)
7232 : : {
7233 : : struct rpc_task *task;
7234 : : int ret = 0;
7235 : :
7236 : : if ((renew_flags & NFS4_RENEW_TIMEOUT) == 0)
7237 : : return 0;
7238 : : task = _nfs41_proc_sequence(clp, cred, false);
7239 : : if (IS_ERR(task))
7240 : : ret = PTR_ERR(task);
7241 : : else
7242 : : rpc_put_task_async(task);
7243 : : dprintk("<-- %s status=%d\n", __func__, ret);
7244 : : return ret;
7245 : : }
7246 : :
7247 : : static int nfs4_proc_sequence(struct nfs_client *clp, struct rpc_cred *cred)
7248 : : {
7249 : : struct rpc_task *task;
7250 : : int ret;
7251 : :
7252 : : task = _nfs41_proc_sequence(clp, cred, true);
7253 : : if (IS_ERR(task)) {
7254 : : ret = PTR_ERR(task);
7255 : : goto out;
7256 : : }
7257 : : ret = rpc_wait_for_completion_task(task);
7258 : : if (!ret) {
7259 : : struct nfs4_sequence_res *res = task->tk_msg.rpc_resp;
7260 : :
7261 : : if (task->tk_status == 0)
7262 : : nfs41_handle_sequence_flag_errors(clp, res->sr_status_flags);
7263 : : ret = task->tk_status;
7264 : : }
7265 : : rpc_put_task(task);
7266 : : out:
7267 : : dprintk("<-- %s status=%d\n", __func__, ret);
7268 : : return ret;
7269 : : }
7270 : :
7271 : : struct nfs4_reclaim_complete_data {
7272 : : struct nfs_client *clp;
7273 : : struct nfs41_reclaim_complete_args arg;
7274 : : struct nfs41_reclaim_complete_res res;
7275 : : };
7276 : :
7277 : : static void nfs4_reclaim_complete_prepare(struct rpc_task *task, void *data)
7278 : : {
7279 : : struct nfs4_reclaim_complete_data *calldata = data;
7280 : :
7281 : : nfs41_setup_sequence(calldata->clp->cl_session,
7282 : : &calldata->arg.seq_args,
7283 : : &calldata->res.seq_res,
7284 : : task);
7285 : : }
7286 : :
7287 : : static int nfs41_reclaim_complete_handle_errors(struct rpc_task *task, struct nfs_client *clp)
7288 : : {
7289 : : switch(task->tk_status) {
7290 : : case 0:
7291 : : case -NFS4ERR_COMPLETE_ALREADY:
7292 : : case -NFS4ERR_WRONG_CRED: /* What to do here? */
7293 : : break;
7294 : : case -NFS4ERR_DELAY:
7295 : : rpc_delay(task, NFS4_POLL_RETRY_MAX);
7296 : : /* fall through */
7297 : : case -NFS4ERR_RETRY_UNCACHED_REP:
7298 : : return -EAGAIN;
7299 : : default:
7300 : : nfs4_schedule_lease_recovery(clp);
7301 : : }
7302 : : return 0;
7303 : : }
7304 : :
7305 : : static void nfs4_reclaim_complete_done(struct rpc_task *task, void *data)
7306 : : {
7307 : : struct nfs4_reclaim_complete_data *calldata = data;
7308 : : struct nfs_client *clp = calldata->clp;
7309 : : struct nfs4_sequence_res *res = &calldata->res.seq_res;
7310 : :
7311 : : dprintk("--> %s\n", __func__);
7312 : : if (!nfs41_sequence_done(task, res))
7313 : : return;
7314 : :
7315 : : trace_nfs4_reclaim_complete(clp, task->tk_status);
7316 : : if (nfs41_reclaim_complete_handle_errors(task, clp) == -EAGAIN) {
7317 : : rpc_restart_call_prepare(task);
7318 : : return;
7319 : : }
7320 : : dprintk("<-- %s\n", __func__);
7321 : : }
7322 : :
7323 : : static void nfs4_free_reclaim_complete_data(void *data)
7324 : : {
7325 : : struct nfs4_reclaim_complete_data *calldata = data;
7326 : :
7327 : : kfree(calldata);
7328 : : }
7329 : :
7330 : : static const struct rpc_call_ops nfs4_reclaim_complete_call_ops = {
7331 : : .rpc_call_prepare = nfs4_reclaim_complete_prepare,
7332 : : .rpc_call_done = nfs4_reclaim_complete_done,
7333 : : .rpc_release = nfs4_free_reclaim_complete_data,
7334 : : };
7335 : :
7336 : : /*
7337 : : * Issue a global reclaim complete.
7338 : : */
7339 : : static int nfs41_proc_reclaim_complete(struct nfs_client *clp,
7340 : : struct rpc_cred *cred)
7341 : : {
7342 : : struct nfs4_reclaim_complete_data *calldata;
7343 : : struct rpc_task *task;
7344 : : struct rpc_message msg = {
7345 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RECLAIM_COMPLETE],
7346 : : .rpc_cred = cred,
7347 : : };
7348 : : struct rpc_task_setup task_setup_data = {
7349 : : .rpc_client = clp->cl_rpcclient,
7350 : : .rpc_message = &msg,
7351 : : .callback_ops = &nfs4_reclaim_complete_call_ops,
7352 : : .flags = RPC_TASK_ASYNC,
7353 : : };
7354 : : int status = -ENOMEM;
7355 : :
7356 : : dprintk("--> %s\n", __func__);
7357 : : calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
7358 : : if (calldata == NULL)
7359 : : goto out;
7360 : : calldata->clp = clp;
7361 : : calldata->arg.one_fs = 0;
7362 : :
7363 : : nfs4_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 0);
7364 : : nfs4_set_sequence_privileged(&calldata->arg.seq_args);
7365 : : msg.rpc_argp = &calldata->arg;
7366 : : msg.rpc_resp = &calldata->res;
7367 : : task_setup_data.callback_data = calldata;
7368 : : task = rpc_run_task(&task_setup_data);
7369 : : if (IS_ERR(task)) {
7370 : : status = PTR_ERR(task);
7371 : : goto out;
7372 : : }
7373 : : status = nfs4_wait_for_completion_rpc_task(task);
7374 : : if (status == 0)
7375 : : status = task->tk_status;
7376 : : rpc_put_task(task);
7377 : : return 0;
7378 : : out:
7379 : : dprintk("<-- %s status=%d\n", __func__, status);
7380 : : return status;
7381 : : }
7382 : :
7383 : : static void
7384 : : nfs4_layoutget_prepare(struct rpc_task *task, void *calldata)
7385 : : {
7386 : : struct nfs4_layoutget *lgp = calldata;
7387 : : struct nfs_server *server = NFS_SERVER(lgp->args.inode);
7388 : : struct nfs4_session *session = nfs4_get_session(server);
7389 : :
7390 : : dprintk("--> %s\n", __func__);
7391 : : /* Note the is a race here, where a CB_LAYOUTRECALL can come in
7392 : : * right now covering the LAYOUTGET we are about to send.
7393 : : * However, that is not so catastrophic, and there seems
7394 : : * to be no way to prevent it completely.
7395 : : */
7396 : : if (nfs41_setup_sequence(session, &lgp->args.seq_args,
7397 : : &lgp->res.seq_res, task))
7398 : : return;
7399 : : if (pnfs_choose_layoutget_stateid(&lgp->args.stateid,
7400 : : NFS_I(lgp->args.inode)->layout,
7401 : : lgp->args.ctx->state)) {
7402 : : rpc_exit(task, NFS4_OK);
7403 : : }
7404 : : }
7405 : :
7406 : : static void nfs4_layoutget_done(struct rpc_task *task, void *calldata)
7407 : : {
7408 : : struct nfs4_layoutget *lgp = calldata;
7409 : : struct inode *inode = lgp->args.inode;
7410 : : struct nfs_server *server = NFS_SERVER(inode);
7411 : : struct pnfs_layout_hdr *lo;
7412 : : struct nfs4_state *state = NULL;
7413 : : unsigned long timeo, now, giveup;
7414 : :
7415 : : dprintk("--> %s tk_status => %d\n", __func__, -task->tk_status);
7416 : :
7417 : : if (!nfs41_sequence_done(task, &lgp->res.seq_res))
7418 : : goto out;
7419 : :
7420 : : switch (task->tk_status) {
7421 : : case 0:
7422 : : goto out;
7423 : : /*
7424 : : * NFS4ERR_LAYOUTTRYLATER is a conflict with another client
7425 : : * (or clients) writing to the same RAID stripe
7426 : : */
7427 : : case -NFS4ERR_LAYOUTTRYLATER:
7428 : : /*
7429 : : * NFS4ERR_RECALLCONFLICT is when conflict with self (must recall
7430 : : * existing layout before getting a new one).
7431 : : */
7432 : : case -NFS4ERR_RECALLCONFLICT:
7433 : : timeo = rpc_get_timeout(task->tk_client);
7434 : : giveup = lgp->args.timestamp + timeo;
7435 : : now = jiffies;
7436 : : if (time_after(giveup, now)) {
7437 : : unsigned long delay;
7438 : :
7439 : : /* Delay for:
7440 : : * - Not less then NFS4_POLL_RETRY_MIN.
7441 : : * - One last time a jiffie before we give up
7442 : : * - exponential backoff (time_now minus start_attempt)
7443 : : */
7444 : : delay = max_t(unsigned long, NFS4_POLL_RETRY_MIN,
7445 : : min((giveup - now - 1),
7446 : : now - lgp->args.timestamp));
7447 : :
7448 : : dprintk("%s: NFS4ERR_RECALLCONFLICT waiting %lu\n",
7449 : : __func__, delay);
7450 : : rpc_delay(task, delay);
7451 : : task->tk_status = 0;
7452 : : rpc_restart_call_prepare(task);
7453 : : goto out; /* Do not call nfs4_async_handle_error() */
7454 : : }
7455 : : break;
7456 : : case -NFS4ERR_EXPIRED:
7457 : : case -NFS4ERR_BAD_STATEID:
7458 : : spin_lock(&inode->i_lock);
7459 : : lo = NFS_I(inode)->layout;
7460 : : if (!lo || list_empty(&lo->plh_segs)) {
7461 : : spin_unlock(&inode->i_lock);
7462 : : /* If the open stateid was bad, then recover it. */
7463 : : state = lgp->args.ctx->state;
7464 : : } else {
7465 : : LIST_HEAD(head);
7466 : :
7467 : : pnfs_mark_matching_lsegs_invalid(lo, &head, NULL);
7468 : : spin_unlock(&inode->i_lock);
7469 : : /* Mark the bad layout state as invalid, then
7470 : : * retry using the open stateid. */
7471 : : pnfs_free_lseg_list(&head);
7472 : : }
7473 : : }
7474 : : if (nfs4_async_handle_error(task, server, state) == -EAGAIN)
7475 : : rpc_restart_call_prepare(task);
7476 : : out:
7477 : : dprintk("<-- %s\n", __func__);
7478 : : }
7479 : :
7480 : : static size_t max_response_pages(struct nfs_server *server)
7481 : : {
7482 : : u32 max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz;
7483 : : return nfs_page_array_len(0, max_resp_sz);
7484 : : }
7485 : :
7486 : : static void nfs4_free_pages(struct page **pages, size_t size)
7487 : : {
7488 : : int i;
7489 : :
7490 : : if (!pages)
7491 : : return;
7492 : :
7493 : : for (i = 0; i < size; i++) {
7494 : : if (!pages[i])
7495 : : break;
7496 : : __free_page(pages[i]);
7497 : : }
7498 : : kfree(pages);
7499 : : }
7500 : :
7501 : : static struct page **nfs4_alloc_pages(size_t size, gfp_t gfp_flags)
7502 : : {
7503 : : struct page **pages;
7504 : : int i;
7505 : :
7506 : : pages = kcalloc(size, sizeof(struct page *), gfp_flags);
7507 : : if (!pages) {
7508 : : dprintk("%s: can't alloc array of %zu pages\n", __func__, size);
7509 : : return NULL;
7510 : : }
7511 : :
7512 : : for (i = 0; i < size; i++) {
7513 : : pages[i] = alloc_page(gfp_flags);
7514 : : if (!pages[i]) {
7515 : : dprintk("%s: failed to allocate page\n", __func__);
7516 : : nfs4_free_pages(pages, size);
7517 : : return NULL;
7518 : : }
7519 : : }
7520 : :
7521 : : return pages;
7522 : : }
7523 : :
7524 : : static void nfs4_layoutget_release(void *calldata)
7525 : : {
7526 : : struct nfs4_layoutget *lgp = calldata;
7527 : : struct inode *inode = lgp->args.inode;
7528 : : struct nfs_server *server = NFS_SERVER(inode);
7529 : : size_t max_pages = max_response_pages(server);
7530 : :
7531 : : dprintk("--> %s\n", __func__);
7532 : : nfs4_free_pages(lgp->args.layout.pages, max_pages);
7533 : : pnfs_put_layout_hdr(NFS_I(inode)->layout);
7534 : : put_nfs_open_context(lgp->args.ctx);
7535 : : kfree(calldata);
7536 : : dprintk("<-- %s\n", __func__);
7537 : : }
7538 : :
7539 : : static const struct rpc_call_ops nfs4_layoutget_call_ops = {
7540 : : .rpc_call_prepare = nfs4_layoutget_prepare,
7541 : : .rpc_call_done = nfs4_layoutget_done,
7542 : : .rpc_release = nfs4_layoutget_release,
7543 : : };
7544 : :
7545 : : struct pnfs_layout_segment *
7546 : : nfs4_proc_layoutget(struct nfs4_layoutget *lgp, gfp_t gfp_flags)
7547 : : {
7548 : : struct inode *inode = lgp->args.inode;
7549 : : struct nfs_server *server = NFS_SERVER(inode);
7550 : : size_t max_pages = max_response_pages(server);
7551 : : struct rpc_task *task;
7552 : : struct rpc_message msg = {
7553 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTGET],
7554 : : .rpc_argp = &lgp->args,
7555 : : .rpc_resp = &lgp->res,
7556 : : .rpc_cred = lgp->cred,
7557 : : };
7558 : : struct rpc_task_setup task_setup_data = {
7559 : : .rpc_client = server->client,
7560 : : .rpc_message = &msg,
7561 : : .callback_ops = &nfs4_layoutget_call_ops,
7562 : : .callback_data = lgp,
7563 : : .flags = RPC_TASK_ASYNC,
7564 : : };
7565 : : struct pnfs_layout_segment *lseg = NULL;
7566 : : int status = 0;
7567 : :
7568 : : dprintk("--> %s\n", __func__);
7569 : :
7570 : : lgp->args.layout.pages = nfs4_alloc_pages(max_pages, gfp_flags);
7571 : : if (!lgp->args.layout.pages) {
7572 : : nfs4_layoutget_release(lgp);
7573 : : return ERR_PTR(-ENOMEM);
7574 : : }
7575 : : lgp->args.layout.pglen = max_pages * PAGE_SIZE;
7576 : : lgp->args.timestamp = jiffies;
7577 : :
7578 : : lgp->res.layoutp = &lgp->args.layout;
7579 : : lgp->res.seq_res.sr_slot = NULL;
7580 : : nfs4_init_sequence(&lgp->args.seq_args, &lgp->res.seq_res, 0);
7581 : :
7582 : : /* nfs4_layoutget_release calls pnfs_put_layout_hdr */
7583 : : pnfs_get_layout_hdr(NFS_I(inode)->layout);
7584 : :
7585 : : task = rpc_run_task(&task_setup_data);
7586 : : if (IS_ERR(task))
7587 : : return ERR_CAST(task);
7588 : : status = nfs4_wait_for_completion_rpc_task(task);
7589 : : if (status == 0)
7590 : : status = task->tk_status;
7591 : : trace_nfs4_layoutget(lgp->args.ctx,
7592 : : &lgp->args.range,
7593 : : &lgp->res.range,
7594 : : status);
7595 : : /* if layoutp->len is 0, nfs4_layoutget_prepare called rpc_exit */
7596 : : if (status == 0 && lgp->res.layoutp->len)
7597 : : lseg = pnfs_layout_process(lgp);
7598 : : rpc_put_task(task);
7599 : : dprintk("<-- %s status=%d\n", __func__, status);
7600 : : if (status)
7601 : : return ERR_PTR(status);
7602 : : return lseg;
7603 : : }
7604 : :
7605 : : static void
7606 : : nfs4_layoutreturn_prepare(struct rpc_task *task, void *calldata)
7607 : : {
7608 : : struct nfs4_layoutreturn *lrp = calldata;
7609 : :
7610 : : dprintk("--> %s\n", __func__);
7611 : : nfs41_setup_sequence(lrp->clp->cl_session,
7612 : : &lrp->args.seq_args,
7613 : : &lrp->res.seq_res,
7614 : : task);
7615 : : }
7616 : :
7617 : : static void nfs4_layoutreturn_done(struct rpc_task *task, void *calldata)
7618 : : {
7619 : : struct nfs4_layoutreturn *lrp = calldata;
7620 : : struct nfs_server *server;
7621 : :
7622 : : dprintk("--> %s\n", __func__);
7623 : :
7624 : : if (!nfs41_sequence_done(task, &lrp->res.seq_res))
7625 : : return;
7626 : :
7627 : : server = NFS_SERVER(lrp->args.inode);
7628 : : switch (task->tk_status) {
7629 : : default:
7630 : : task->tk_status = 0;
7631 : : case 0:
7632 : : break;
7633 : : case -NFS4ERR_DELAY:
7634 : : if (nfs4_async_handle_error(task, server, NULL) != -EAGAIN)
7635 : : break;
7636 : : rpc_restart_call_prepare(task);
7637 : : return;
7638 : : }
7639 : : dprintk("<-- %s\n", __func__);
7640 : : }
7641 : :
7642 : : static void nfs4_layoutreturn_release(void *calldata)
7643 : : {
7644 : : struct nfs4_layoutreturn *lrp = calldata;
7645 : : struct pnfs_layout_hdr *lo = lrp->args.layout;
7646 : :
7647 : : dprintk("--> %s\n", __func__);
7648 : : spin_lock(&lo->plh_inode->i_lock);
7649 : : if (lrp->res.lrs_present)
7650 : : pnfs_set_layout_stateid(lo, &lrp->res.stateid, true);
7651 : : lo->plh_block_lgets--;
7652 : : spin_unlock(&lo->plh_inode->i_lock);
7653 : : pnfs_put_layout_hdr(lrp->args.layout);
7654 : : kfree(calldata);
7655 : : dprintk("<-- %s\n", __func__);
7656 : : }
7657 : :
7658 : : static const struct rpc_call_ops nfs4_layoutreturn_call_ops = {
7659 : : .rpc_call_prepare = nfs4_layoutreturn_prepare,
7660 : : .rpc_call_done = nfs4_layoutreturn_done,
7661 : : .rpc_release = nfs4_layoutreturn_release,
7662 : : };
7663 : :
7664 : : int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp)
7665 : : {
7666 : : struct rpc_task *task;
7667 : : struct rpc_message msg = {
7668 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTRETURN],
7669 : : .rpc_argp = &lrp->args,
7670 : : .rpc_resp = &lrp->res,
7671 : : .rpc_cred = lrp->cred,
7672 : : };
7673 : : struct rpc_task_setup task_setup_data = {
7674 : : .rpc_client = NFS_SERVER(lrp->args.inode)->client,
7675 : : .rpc_message = &msg,
7676 : : .callback_ops = &nfs4_layoutreturn_call_ops,
7677 : : .callback_data = lrp,
7678 : : };
7679 : : int status;
7680 : :
7681 : : dprintk("--> %s\n", __func__);
7682 : : nfs4_init_sequence(&lrp->args.seq_args, &lrp->res.seq_res, 1);
7683 : : task = rpc_run_task(&task_setup_data);
7684 : : if (IS_ERR(task))
7685 : : return PTR_ERR(task);
7686 : : status = task->tk_status;
7687 : : trace_nfs4_layoutreturn(lrp->args.inode, status);
7688 : : dprintk("<-- %s status=%d\n", __func__, status);
7689 : : rpc_put_task(task);
7690 : : return status;
7691 : : }
7692 : :
7693 : : /*
7694 : : * Retrieve the list of Data Server devices from the MDS.
7695 : : */
7696 : : static int _nfs4_getdevicelist(struct nfs_server *server,
7697 : : const struct nfs_fh *fh,
7698 : : struct pnfs_devicelist *devlist)
7699 : : {
7700 : : struct nfs4_getdevicelist_args args = {
7701 : : .fh = fh,
7702 : : .layoutclass = server->pnfs_curr_ld->id,
7703 : : };
7704 : : struct nfs4_getdevicelist_res res = {
7705 : : .devlist = devlist,
7706 : : };
7707 : : struct rpc_message msg = {
7708 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICELIST],
7709 : : .rpc_argp = &args,
7710 : : .rpc_resp = &res,
7711 : : };
7712 : : int status;
7713 : :
7714 : : dprintk("--> %s\n", __func__);
7715 : : status = nfs4_call_sync(server->client, server, &msg, &args.seq_args,
7716 : : &res.seq_res, 0);
7717 : : dprintk("<-- %s status=%d\n", __func__, status);
7718 : : return status;
7719 : : }
7720 : :
7721 : : int nfs4_proc_getdevicelist(struct nfs_server *server,
7722 : : const struct nfs_fh *fh,
7723 : : struct pnfs_devicelist *devlist)
7724 : : {
7725 : : struct nfs4_exception exception = { };
7726 : : int err;
7727 : :
7728 : : do {
7729 : : err = nfs4_handle_exception(server,
7730 : : _nfs4_getdevicelist(server, fh, devlist),
7731 : : &exception);
7732 : : } while (exception.retry);
7733 : :
7734 : : dprintk("%s: err=%d, num_devs=%u\n", __func__,
7735 : : err, devlist->num_devs);
7736 : :
7737 : : return err;
7738 : : }
7739 : : EXPORT_SYMBOL_GPL(nfs4_proc_getdevicelist);
7740 : :
7741 : : static int
7742 : : _nfs4_proc_getdeviceinfo(struct nfs_server *server,
7743 : : struct pnfs_device *pdev,
7744 : : struct rpc_cred *cred)
7745 : : {
7746 : : struct nfs4_getdeviceinfo_args args = {
7747 : : .pdev = pdev,
7748 : : };
7749 : : struct nfs4_getdeviceinfo_res res = {
7750 : : .pdev = pdev,
7751 : : };
7752 : : struct rpc_message msg = {
7753 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICEINFO],
7754 : : .rpc_argp = &args,
7755 : : .rpc_resp = &res,
7756 : : .rpc_cred = cred,
7757 : : };
7758 : : int status;
7759 : :
7760 : : dprintk("--> %s\n", __func__);
7761 : : status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
7762 : : dprintk("<-- %s status=%d\n", __func__, status);
7763 : :
7764 : : return status;
7765 : : }
7766 : :
7767 : : int nfs4_proc_getdeviceinfo(struct nfs_server *server,
7768 : : struct pnfs_device *pdev,
7769 : : struct rpc_cred *cred)
7770 : : {
7771 : : struct nfs4_exception exception = { };
7772 : : int err;
7773 : :
7774 : : do {
7775 : : err = nfs4_handle_exception(server,
7776 : : _nfs4_proc_getdeviceinfo(server, pdev, cred),
7777 : : &exception);
7778 : : } while (exception.retry);
7779 : : return err;
7780 : : }
7781 : : EXPORT_SYMBOL_GPL(nfs4_proc_getdeviceinfo);
7782 : :
7783 : : static void nfs4_layoutcommit_prepare(struct rpc_task *task, void *calldata)
7784 : : {
7785 : : struct nfs4_layoutcommit_data *data = calldata;
7786 : : struct nfs_server *server = NFS_SERVER(data->args.inode);
7787 : : struct nfs4_session *session = nfs4_get_session(server);
7788 : :
7789 : : nfs41_setup_sequence(session,
7790 : : &data->args.seq_args,
7791 : : &data->res.seq_res,
7792 : : task);
7793 : : }
7794 : :
7795 : : static void
7796 : : nfs4_layoutcommit_done(struct rpc_task *task, void *calldata)
7797 : : {
7798 : : struct nfs4_layoutcommit_data *data = calldata;
7799 : : struct nfs_server *server = NFS_SERVER(data->args.inode);
7800 : :
7801 : : if (!nfs41_sequence_done(task, &data->res.seq_res))
7802 : : return;
7803 : :
7804 : : switch (task->tk_status) { /* Just ignore these failures */
7805 : : case -NFS4ERR_DELEG_REVOKED: /* layout was recalled */
7806 : : case -NFS4ERR_BADIOMODE: /* no IOMODE_RW layout for range */
7807 : : case -NFS4ERR_BADLAYOUT: /* no layout */
7808 : : case -NFS4ERR_GRACE: /* loca_recalim always false */
7809 : : task->tk_status = 0;
7810 : : case 0:
7811 : : break;
7812 : : default:
7813 : : if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN) {
7814 : : rpc_restart_call_prepare(task);
7815 : : return;
7816 : : }
7817 : : }
7818 : : }
7819 : :
7820 : : static void nfs4_layoutcommit_release(void *calldata)
7821 : : {
7822 : : struct nfs4_layoutcommit_data *data = calldata;
7823 : :
7824 : : pnfs_cleanup_layoutcommit(data);
7825 : : nfs_post_op_update_inode_force_wcc(data->args.inode,
7826 : : data->res.fattr);
7827 : : put_rpccred(data->cred);
7828 : : kfree(data);
7829 : : }
7830 : :
7831 : : static const struct rpc_call_ops nfs4_layoutcommit_ops = {
7832 : : .rpc_call_prepare = nfs4_layoutcommit_prepare,
7833 : : .rpc_call_done = nfs4_layoutcommit_done,
7834 : : .rpc_release = nfs4_layoutcommit_release,
7835 : : };
7836 : :
7837 : : int
7838 : : nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data, bool sync)
7839 : : {
7840 : : struct rpc_message msg = {
7841 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTCOMMIT],
7842 : : .rpc_argp = &data->args,
7843 : : .rpc_resp = &data->res,
7844 : : .rpc_cred = data->cred,
7845 : : };
7846 : : struct rpc_task_setup task_setup_data = {
7847 : : .task = &data->task,
7848 : : .rpc_client = NFS_CLIENT(data->args.inode),
7849 : : .rpc_message = &msg,
7850 : : .callback_ops = &nfs4_layoutcommit_ops,
7851 : : .callback_data = data,
7852 : : .flags = RPC_TASK_ASYNC,
7853 : : };
7854 : : struct rpc_task *task;
7855 : : int status = 0;
7856 : :
7857 : : dprintk("NFS: %4d initiating layoutcommit call. sync %d "
7858 : : "lbw: %llu inode %lu\n",
7859 : : data->task.tk_pid, sync,
7860 : : data->args.lastbytewritten,
7861 : : data->args.inode->i_ino);
7862 : :
7863 : : nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
7864 : : task = rpc_run_task(&task_setup_data);
7865 : : if (IS_ERR(task))
7866 : : return PTR_ERR(task);
7867 : : if (sync == false)
7868 : : goto out;
7869 : : status = nfs4_wait_for_completion_rpc_task(task);
7870 : : if (status != 0)
7871 : : goto out;
7872 : : status = task->tk_status;
7873 : : trace_nfs4_layoutcommit(data->args.inode, status);
7874 : : out:
7875 : : dprintk("%s: status %d\n", __func__, status);
7876 : : rpc_put_task(task);
7877 : : return status;
7878 : : }
7879 : :
7880 : : /**
7881 : : * Use the state managment nfs_client cl_rpcclient, which uses krb5i (if
7882 : : * possible) as per RFC3530bis and RFC5661 Security Considerations sections
7883 : : */
7884 : : static int
7885 : : _nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
7886 : : struct nfs_fsinfo *info,
7887 : : struct nfs4_secinfo_flavors *flavors, bool use_integrity)
7888 : : {
7889 : : struct nfs41_secinfo_no_name_args args = {
7890 : : .style = SECINFO_STYLE_CURRENT_FH,
7891 : : };
7892 : : struct nfs4_secinfo_res res = {
7893 : : .flavors = flavors,
7894 : : };
7895 : : struct rpc_message msg = {
7896 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO_NO_NAME],
7897 : : .rpc_argp = &args,
7898 : : .rpc_resp = &res,
7899 : : };
7900 : : struct rpc_clnt *clnt = server->client;
7901 : : struct rpc_cred *cred = NULL;
7902 : : int status;
7903 : :
7904 : : if (use_integrity) {
7905 : : clnt = server->nfs_client->cl_rpcclient;
7906 : : cred = nfs4_get_clid_cred(server->nfs_client);
7907 : : msg.rpc_cred = cred;
7908 : : }
7909 : :
7910 : : dprintk("--> %s\n", __func__);
7911 : : status = nfs4_call_sync(clnt, server, &msg, &args.seq_args,
7912 : : &res.seq_res, 0);
7913 : : dprintk("<-- %s status=%d\n", __func__, status);
7914 : :
7915 : : if (cred)
7916 : : put_rpccred(cred);
7917 : :
7918 : : return status;
7919 : : }
7920 : :
7921 : : static int
7922 : : nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
7923 : : struct nfs_fsinfo *info, struct nfs4_secinfo_flavors *flavors)
7924 : : {
7925 : : struct nfs4_exception exception = { };
7926 : : int err;
7927 : : do {
7928 : : /* first try using integrity protection */
7929 : : err = -NFS4ERR_WRONGSEC;
7930 : :
7931 : : /* try to use integrity protection with machine cred */
7932 : : if (_nfs4_is_integrity_protected(server->nfs_client))
7933 : : err = _nfs41_proc_secinfo_no_name(server, fhandle, info,
7934 : : flavors, true);
7935 : :
7936 : : /*
7937 : : * if unable to use integrity protection, or SECINFO with
7938 : : * integrity protection returns NFS4ERR_WRONGSEC (which is
7939 : : * disallowed by spec, but exists in deployed servers) use
7940 : : * the current filesystem's rpc_client and the user cred.
7941 : : */
7942 : : if (err == -NFS4ERR_WRONGSEC)
7943 : : err = _nfs41_proc_secinfo_no_name(server, fhandle, info,
7944 : : flavors, false);
7945 : :
7946 : : switch (err) {
7947 : : case 0:
7948 : : case -NFS4ERR_WRONGSEC:
7949 : : case -ENOTSUPP:
7950 : : goto out;
7951 : : default:
7952 : : err = nfs4_handle_exception(server, err, &exception);
7953 : : }
7954 : : } while (exception.retry);
7955 : : out:
7956 : : return err;
7957 : : }
7958 : :
7959 : : static int
7960 : : nfs41_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
7961 : : struct nfs_fsinfo *info)
7962 : : {
7963 : : int err;
7964 : : struct page *page;
7965 : : rpc_authflavor_t flavor = RPC_AUTH_MAXFLAVOR;
7966 : : struct nfs4_secinfo_flavors *flavors;
7967 : : struct nfs4_secinfo4 *secinfo;
7968 : : int i;
7969 : :
7970 : : page = alloc_page(GFP_KERNEL);
7971 : : if (!page) {
7972 : : err = -ENOMEM;
7973 : : goto out;
7974 : : }
7975 : :
7976 : : flavors = page_address(page);
7977 : : err = nfs41_proc_secinfo_no_name(server, fhandle, info, flavors);
7978 : :
7979 : : /*
7980 : : * Fall back on "guess and check" method if
7981 : : * the server doesn't support SECINFO_NO_NAME
7982 : : */
7983 : : if (err == -NFS4ERR_WRONGSEC || err == -ENOTSUPP) {
7984 : : err = nfs4_find_root_sec(server, fhandle, info);
7985 : : goto out_freepage;
7986 : : }
7987 : : if (err)
7988 : : goto out_freepage;
7989 : :
7990 : : for (i = 0; i < flavors->num_flavors; i++) {
7991 : : secinfo = &flavors->flavors[i];
7992 : :
7993 : : switch (secinfo->flavor) {
7994 : : case RPC_AUTH_NULL:
7995 : : case RPC_AUTH_UNIX:
7996 : : case RPC_AUTH_GSS:
7997 : : flavor = rpcauth_get_pseudoflavor(secinfo->flavor,
7998 : : &secinfo->flavor_info);
7999 : : break;
8000 : : default:
8001 : : flavor = RPC_AUTH_MAXFLAVOR;
8002 : : break;
8003 : : }
8004 : :
8005 : : if (!nfs_auth_info_match(&server->auth_info, flavor))
8006 : : flavor = RPC_AUTH_MAXFLAVOR;
8007 : :
8008 : : if (flavor != RPC_AUTH_MAXFLAVOR) {
8009 : : err = nfs4_lookup_root_sec(server, fhandle,
8010 : : info, flavor);
8011 : : if (!err)
8012 : : break;
8013 : : }
8014 : : }
8015 : :
8016 : : if (flavor == RPC_AUTH_MAXFLAVOR)
8017 : : err = -EPERM;
8018 : :
8019 : : out_freepage:
8020 : : put_page(page);
8021 : : if (err == -EACCES)
8022 : : return -EPERM;
8023 : : out:
8024 : : return err;
8025 : : }
8026 : :
8027 : : static int _nfs41_test_stateid(struct nfs_server *server,
8028 : : nfs4_stateid *stateid,
8029 : : struct rpc_cred *cred)
8030 : : {
8031 : : int status;
8032 : : struct nfs41_test_stateid_args args = {
8033 : : .stateid = stateid,
8034 : : };
8035 : : struct nfs41_test_stateid_res res;
8036 : : struct rpc_message msg = {
8037 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_TEST_STATEID],
8038 : : .rpc_argp = &args,
8039 : : .rpc_resp = &res,
8040 : : .rpc_cred = cred,
8041 : : };
8042 : : struct rpc_clnt *rpc_client = server->client;
8043 : :
8044 : : nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID,
8045 : : &rpc_client, &msg);
8046 : :
8047 : : dprintk("NFS call test_stateid %p\n", stateid);
8048 : : nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
8049 : : nfs4_set_sequence_privileged(&args.seq_args);
8050 : : status = nfs4_call_sync_sequence(rpc_client, server, &msg,
8051 : : &args.seq_args, &res.seq_res);
8052 : : if (status != NFS_OK) {
8053 : : dprintk("NFS reply test_stateid: failed, %d\n", status);
8054 : : return status;
8055 : : }
8056 : : dprintk("NFS reply test_stateid: succeeded, %d\n", -res.status);
8057 : : return -res.status;
8058 : : }
8059 : :
8060 : : /**
8061 : : * nfs41_test_stateid - perform a TEST_STATEID operation
8062 : : *
8063 : : * @server: server / transport on which to perform the operation
8064 : : * @stateid: state ID to test
8065 : : * @cred: credential
8066 : : *
8067 : : * Returns NFS_OK if the server recognizes that "stateid" is valid.
8068 : : * Otherwise a negative NFS4ERR value is returned if the operation
8069 : : * failed or the state ID is not currently valid.
8070 : : */
8071 : : static int nfs41_test_stateid(struct nfs_server *server,
8072 : : nfs4_stateid *stateid,
8073 : : struct rpc_cred *cred)
8074 : : {
8075 : : struct nfs4_exception exception = { };
8076 : : int err;
8077 : : do {
8078 : : err = _nfs41_test_stateid(server, stateid, cred);
8079 : : if (err != -NFS4ERR_DELAY)
8080 : : break;
8081 : : nfs4_handle_exception(server, err, &exception);
8082 : : } while (exception.retry);
8083 : : return err;
8084 : : }
8085 : :
8086 : : struct nfs_free_stateid_data {
8087 : : struct nfs_server *server;
8088 : : struct nfs41_free_stateid_args args;
8089 : : struct nfs41_free_stateid_res res;
8090 : : };
8091 : :
8092 : : static void nfs41_free_stateid_prepare(struct rpc_task *task, void *calldata)
8093 : : {
8094 : : struct nfs_free_stateid_data *data = calldata;
8095 : : nfs41_setup_sequence(nfs4_get_session(data->server),
8096 : : &data->args.seq_args,
8097 : : &data->res.seq_res,
8098 : : task);
8099 : : }
8100 : :
8101 : : static void nfs41_free_stateid_done(struct rpc_task *task, void *calldata)
8102 : : {
8103 : : struct nfs_free_stateid_data *data = calldata;
8104 : :
8105 : : nfs41_sequence_done(task, &data->res.seq_res);
8106 : :
8107 : : switch (task->tk_status) {
8108 : : case -NFS4ERR_DELAY:
8109 : : if (nfs4_async_handle_error(task, data->server, NULL) == -EAGAIN)
8110 : : rpc_restart_call_prepare(task);
8111 : : }
8112 : : }
8113 : :
8114 : : static void nfs41_free_stateid_release(void *calldata)
8115 : : {
8116 : : kfree(calldata);
8117 : : }
8118 : :
8119 : : static const struct rpc_call_ops nfs41_free_stateid_ops = {
8120 : : .rpc_call_prepare = nfs41_free_stateid_prepare,
8121 : : .rpc_call_done = nfs41_free_stateid_done,
8122 : : .rpc_release = nfs41_free_stateid_release,
8123 : : };
8124 : :
8125 : : static struct rpc_task *_nfs41_free_stateid(struct nfs_server *server,
8126 : : nfs4_stateid *stateid,
8127 : : struct rpc_cred *cred,
8128 : : bool privileged)
8129 : : {
8130 : : struct rpc_message msg = {
8131 : : .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FREE_STATEID],
8132 : : .rpc_cred = cred,
8133 : : };
8134 : : struct rpc_task_setup task_setup = {
8135 : : .rpc_client = server->client,
8136 : : .rpc_message = &msg,
8137 : : .callback_ops = &nfs41_free_stateid_ops,
8138 : : .flags = RPC_TASK_ASYNC,
8139 : : };
8140 : : struct nfs_free_stateid_data *data;
8141 : :
8142 : : nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID,
8143 : : &task_setup.rpc_client, &msg);
8144 : :
8145 : : dprintk("NFS call free_stateid %p\n", stateid);
8146 : : data = kmalloc(sizeof(*data), GFP_NOFS);
8147 : : if (!data)
8148 : : return ERR_PTR(-ENOMEM);
8149 : : data->server = server;
8150 : : nfs4_stateid_copy(&data->args.stateid, stateid);
8151 : :
8152 : : task_setup.callback_data = data;
8153 : :
8154 : : msg.rpc_argp = &data->args;
8155 : : msg.rpc_resp = &data->res;
8156 : : nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0);
8157 : : if (privileged)
8158 : : nfs4_set_sequence_privileged(&data->args.seq_args);
8159 : :
8160 : : return rpc_run_task(&task_setup);
8161 : : }
8162 : :
8163 : : /**
8164 : : * nfs41_free_stateid - perform a FREE_STATEID operation
8165 : : *
8166 : : * @server: server / transport on which to perform the operation
8167 : : * @stateid: state ID to release
8168 : : * @cred: credential
8169 : : *
8170 : : * Returns NFS_OK if the server freed "stateid". Otherwise a
8171 : : * negative NFS4ERR value is returned.
8172 : : */
8173 : : static int nfs41_free_stateid(struct nfs_server *server,
8174 : : nfs4_stateid *stateid,
8175 : : struct rpc_cred *cred)
8176 : : {
8177 : : struct rpc_task *task;
8178 : : int ret;
8179 : :
8180 : : task = _nfs41_free_stateid(server, stateid, cred, true);
8181 : : if (IS_ERR(task))
8182 : : return PTR_ERR(task);
8183 : : ret = rpc_wait_for_completion_task(task);
8184 : : if (!ret)
8185 : : ret = task->tk_status;
8186 : : rpc_put_task(task);
8187 : : return ret;
8188 : : }
8189 : :
8190 : : static int nfs41_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
8191 : : {
8192 : : struct rpc_task *task;
8193 : : struct rpc_cred *cred = lsp->ls_state->owner->so_cred;
8194 : :
8195 : : task = _nfs41_free_stateid(server, &lsp->ls_stateid, cred, false);
8196 : : nfs4_free_lock_state(server, lsp);
8197 : : if (IS_ERR(task))
8198 : : return PTR_ERR(task);
8199 : : rpc_put_task(task);
8200 : : return 0;
8201 : : }
8202 : :
8203 : : static bool nfs41_match_stateid(const nfs4_stateid *s1,
8204 : : const nfs4_stateid *s2)
8205 : : {
8206 : : if (memcmp(s1->other, s2->other, sizeof(s1->other)) != 0)
8207 : : return false;
8208 : :
8209 : : if (s1->seqid == s2->seqid)
8210 : : return true;
8211 : : if (s1->seqid == 0 || s2->seqid == 0)
8212 : : return true;
8213 : :
8214 : : return false;
8215 : : }
8216 : :
8217 : : #endif /* CONFIG_NFS_V4_1 */
8218 : :
8219 : 0 : static bool nfs4_match_stateid(const nfs4_stateid *s1,
8220 : : const nfs4_stateid *s2)
8221 : : {
8222 : 0 : return nfs4_stateid_match(s1, s2);
8223 : : }
8224 : :
8225 : :
8226 : : static const struct nfs4_state_recovery_ops nfs40_reboot_recovery_ops = {
8227 : : .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,
8228 : : .state_flag_bit = NFS_STATE_RECLAIM_REBOOT,
8229 : : .recover_open = nfs4_open_reclaim,
8230 : : .recover_lock = nfs4_lock_reclaim,
8231 : : .establish_clid = nfs4_init_clientid,
8232 : : .detect_trunking = nfs40_discover_server_trunking,
8233 : : };
8234 : :
8235 : : #if defined(CONFIG_NFS_V4_1)
8236 : : static const struct nfs4_state_recovery_ops nfs41_reboot_recovery_ops = {
8237 : : .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,
8238 : : .state_flag_bit = NFS_STATE_RECLAIM_REBOOT,
8239 : : .recover_open = nfs4_open_reclaim,
8240 : : .recover_lock = nfs4_lock_reclaim,
8241 : : .establish_clid = nfs41_init_clientid,
8242 : : .reclaim_complete = nfs41_proc_reclaim_complete,
8243 : : .detect_trunking = nfs41_discover_server_trunking,
8244 : : };
8245 : : #endif /* CONFIG_NFS_V4_1 */
8246 : :
8247 : : static const struct nfs4_state_recovery_ops nfs40_nograce_recovery_ops = {
8248 : : .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,
8249 : : .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE,
8250 : : .recover_open = nfs4_open_expired,
8251 : : .recover_lock = nfs4_lock_expired,
8252 : : .establish_clid = nfs4_init_clientid,
8253 : : };
8254 : :
8255 : : #if defined(CONFIG_NFS_V4_1)
8256 : : static const struct nfs4_state_recovery_ops nfs41_nograce_recovery_ops = {
8257 : : .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,
8258 : : .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE,
8259 : : .recover_open = nfs41_open_expired,
8260 : : .recover_lock = nfs41_lock_expired,
8261 : : .establish_clid = nfs41_init_clientid,
8262 : : };
8263 : : #endif /* CONFIG_NFS_V4_1 */
8264 : :
8265 : : static const struct nfs4_state_maintenance_ops nfs40_state_renewal_ops = {
8266 : : .sched_state_renewal = nfs4_proc_async_renew,
8267 : : .get_state_renewal_cred_locked = nfs4_get_renew_cred_locked,
8268 : : .renew_lease = nfs4_proc_renew,
8269 : : };
8270 : :
8271 : : #if defined(CONFIG_NFS_V4_1)
8272 : : static const struct nfs4_state_maintenance_ops nfs41_state_renewal_ops = {
8273 : : .sched_state_renewal = nfs41_proc_async_sequence,
8274 : : .get_state_renewal_cred_locked = nfs4_get_machine_cred_locked,
8275 : : .renew_lease = nfs4_proc_sequence,
8276 : : };
8277 : : #endif
8278 : :
8279 : : static const struct nfs4_mig_recovery_ops nfs40_mig_recovery_ops = {
8280 : : .get_locations = _nfs40_proc_get_locations,
8281 : : .fsid_present = _nfs40_proc_fsid_present,
8282 : : };
8283 : :
8284 : : #if defined(CONFIG_NFS_V4_1)
8285 : : static const struct nfs4_mig_recovery_ops nfs41_mig_recovery_ops = {
8286 : : .get_locations = _nfs41_proc_get_locations,
8287 : : .fsid_present = _nfs41_proc_fsid_present,
8288 : : };
8289 : : #endif /* CONFIG_NFS_V4_1 */
8290 : :
8291 : : static const struct nfs4_minor_version_ops nfs_v4_0_minor_ops = {
8292 : : .minor_version = 0,
8293 : : .init_caps = NFS_CAP_READDIRPLUS
8294 : : | NFS_CAP_ATOMIC_OPEN
8295 : : | NFS_CAP_CHANGE_ATTR
8296 : : | NFS_CAP_POSIX_LOCK,
8297 : : .init_client = nfs40_init_client,
8298 : : .shutdown_client = nfs40_shutdown_client,
8299 : : .match_stateid = nfs4_match_stateid,
8300 : : .find_root_sec = nfs4_find_root_sec,
8301 : : .free_lock_state = nfs4_release_lockowner,
8302 : : .call_sync_ops = &nfs40_call_sync_ops,
8303 : : .reboot_recovery_ops = &nfs40_reboot_recovery_ops,
8304 : : .nograce_recovery_ops = &nfs40_nograce_recovery_ops,
8305 : : .state_renewal_ops = &nfs40_state_renewal_ops,
8306 : : .mig_recovery_ops = &nfs40_mig_recovery_ops,
8307 : : };
8308 : :
8309 : : #if defined(CONFIG_NFS_V4_1)
8310 : : static const struct nfs4_minor_version_ops nfs_v4_1_minor_ops = {
8311 : : .minor_version = 1,
8312 : : .init_caps = NFS_CAP_READDIRPLUS
8313 : : | NFS_CAP_ATOMIC_OPEN
8314 : : | NFS_CAP_CHANGE_ATTR
8315 : : | NFS_CAP_POSIX_LOCK
8316 : : | NFS_CAP_STATEID_NFSV41
8317 : : | NFS_CAP_ATOMIC_OPEN_V1,
8318 : : .init_client = nfs41_init_client,
8319 : : .shutdown_client = nfs41_shutdown_client,
8320 : : .match_stateid = nfs41_match_stateid,
8321 : : .find_root_sec = nfs41_find_root_sec,
8322 : : .free_lock_state = nfs41_free_lock_state,
8323 : : .call_sync_ops = &nfs41_call_sync_ops,
8324 : : .reboot_recovery_ops = &nfs41_reboot_recovery_ops,
8325 : : .nograce_recovery_ops = &nfs41_nograce_recovery_ops,
8326 : : .state_renewal_ops = &nfs41_state_renewal_ops,
8327 : : .mig_recovery_ops = &nfs41_mig_recovery_ops,
8328 : : };
8329 : : #endif
8330 : :
8331 : : #if defined(CONFIG_NFS_V4_2)
8332 : : static const struct nfs4_minor_version_ops nfs_v4_2_minor_ops = {
8333 : : .minor_version = 2,
8334 : : .init_caps = NFS_CAP_READDIRPLUS
8335 : : | NFS_CAP_ATOMIC_OPEN
8336 : : | NFS_CAP_CHANGE_ATTR
8337 : : | NFS_CAP_POSIX_LOCK
8338 : : | NFS_CAP_STATEID_NFSV41
8339 : : | NFS_CAP_ATOMIC_OPEN_V1,
8340 : : .init_client = nfs41_init_client,
8341 : : .shutdown_client = nfs41_shutdown_client,
8342 : : .match_stateid = nfs41_match_stateid,
8343 : : .find_root_sec = nfs41_find_root_sec,
8344 : : .free_lock_state = nfs41_free_lock_state,
8345 : : .call_sync_ops = &nfs41_call_sync_ops,
8346 : : .reboot_recovery_ops = &nfs41_reboot_recovery_ops,
8347 : : .nograce_recovery_ops = &nfs41_nograce_recovery_ops,
8348 : : .state_renewal_ops = &nfs41_state_renewal_ops,
8349 : : };
8350 : : #endif
8351 : :
8352 : : const struct nfs4_minor_version_ops *nfs_v4_minor_ops[] = {
8353 : : [0] = &nfs_v4_0_minor_ops,
8354 : : #if defined(CONFIG_NFS_V4_1)
8355 : : [1] = &nfs_v4_1_minor_ops,
8356 : : #endif
8357 : : #if defined(CONFIG_NFS_V4_2)
8358 : : [2] = &nfs_v4_2_minor_ops,
8359 : : #endif
8360 : : };
8361 : :
8362 : : static const struct inode_operations nfs4_dir_inode_operations = {
8363 : : .create = nfs_create,
8364 : : .lookup = nfs_lookup,
8365 : : .atomic_open = nfs_atomic_open,
8366 : : .link = nfs_link,
8367 : : .unlink = nfs_unlink,
8368 : : .symlink = nfs_symlink,
8369 : : .mkdir = nfs_mkdir,
8370 : : .rmdir = nfs_rmdir,
8371 : : .mknod = nfs_mknod,
8372 : : .rename = nfs_rename,
8373 : : .permission = nfs_permission,
8374 : : .getattr = nfs_getattr,
8375 : : .setattr = nfs_setattr,
8376 : : .getxattr = generic_getxattr,
8377 : : .setxattr = generic_setxattr,
8378 : : .listxattr = generic_listxattr,
8379 : : .removexattr = generic_removexattr,
8380 : : };
8381 : :
8382 : : static const struct inode_operations nfs4_file_inode_operations = {
8383 : : .permission = nfs_permission,
8384 : : .getattr = nfs_getattr,
8385 : : .setattr = nfs_setattr,
8386 : : .getxattr = generic_getxattr,
8387 : : .setxattr = generic_setxattr,
8388 : : .listxattr = generic_listxattr,
8389 : : .removexattr = generic_removexattr,
8390 : : };
8391 : :
8392 : : const struct nfs_rpc_ops nfs_v4_clientops = {
8393 : : .version = 4, /* protocol version */
8394 : : .dentry_ops = &nfs4_dentry_operations,
8395 : : .dir_inode_ops = &nfs4_dir_inode_operations,
8396 : : .file_inode_ops = &nfs4_file_inode_operations,
8397 : : .file_ops = &nfs4_file_operations,
8398 : : .getroot = nfs4_proc_get_root,
8399 : : .submount = nfs4_submount,
8400 : : .try_mount = nfs4_try_mount,
8401 : : .getattr = nfs4_proc_getattr,
8402 : : .setattr = nfs4_proc_setattr,
8403 : : .lookup = nfs4_proc_lookup,
8404 : : .access = nfs4_proc_access,
8405 : : .readlink = nfs4_proc_readlink,
8406 : : .create = nfs4_proc_create,
8407 : : .remove = nfs4_proc_remove,
8408 : : .unlink_setup = nfs4_proc_unlink_setup,
8409 : : .unlink_rpc_prepare = nfs4_proc_unlink_rpc_prepare,
8410 : : .unlink_done = nfs4_proc_unlink_done,
8411 : : .rename = nfs4_proc_rename,
8412 : : .rename_setup = nfs4_proc_rename_setup,
8413 : : .rename_rpc_prepare = nfs4_proc_rename_rpc_prepare,
8414 : : .rename_done = nfs4_proc_rename_done,
8415 : : .link = nfs4_proc_link,
8416 : : .symlink = nfs4_proc_symlink,
8417 : : .mkdir = nfs4_proc_mkdir,
8418 : : .rmdir = nfs4_proc_remove,
8419 : : .readdir = nfs4_proc_readdir,
8420 : : .mknod = nfs4_proc_mknod,
8421 : : .statfs = nfs4_proc_statfs,
8422 : : .fsinfo = nfs4_proc_fsinfo,
8423 : : .pathconf = nfs4_proc_pathconf,
8424 : : .set_capabilities = nfs4_server_capabilities,
8425 : : .decode_dirent = nfs4_decode_dirent,
8426 : : .read_setup = nfs4_proc_read_setup,
8427 : : .read_pageio_init = pnfs_pageio_init_read,
8428 : : .read_rpc_prepare = nfs4_proc_read_rpc_prepare,
8429 : : .read_done = nfs4_read_done,
8430 : : .write_setup = nfs4_proc_write_setup,
8431 : : .write_pageio_init = pnfs_pageio_init_write,
8432 : : .write_rpc_prepare = nfs4_proc_write_rpc_prepare,
8433 : : .write_done = nfs4_write_done,
8434 : : .commit_setup = nfs4_proc_commit_setup,
8435 : : .commit_rpc_prepare = nfs4_proc_commit_rpc_prepare,
8436 : : .commit_done = nfs4_commit_done,
8437 : : .lock = nfs4_proc_lock,
8438 : : .clear_acl_cache = nfs4_zap_acl_attr,
8439 : : .close_context = nfs4_close_context,
8440 : : .open_context = nfs4_atomic_open,
8441 : : .have_delegation = nfs4_have_delegation,
8442 : : .return_delegation = nfs4_inode_return_delegation,
8443 : : .alloc_client = nfs4_alloc_client,
8444 : : .init_client = nfs4_init_client,
8445 : : .free_client = nfs4_free_client,
8446 : : .create_server = nfs4_create_server,
8447 : : .clone_server = nfs_clone_server,
8448 : : };
8449 : :
8450 : : static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = {
8451 : : .prefix = XATTR_NAME_NFSV4_ACL,
8452 : : .list = nfs4_xattr_list_nfs4_acl,
8453 : : .get = nfs4_xattr_get_nfs4_acl,
8454 : : .set = nfs4_xattr_set_nfs4_acl,
8455 : : };
8456 : :
8457 : : const struct xattr_handler *nfs4_xattr_handlers[] = {
8458 : : &nfs4_xattr_nfs4_acl_handler,
8459 : : #ifdef CONFIG_NFS_V4_SECURITY_LABEL
8460 : : &nfs4_xattr_nfs4_label_handler,
8461 : : #endif
8462 : : NULL
8463 : : };
8464 : :
8465 : : /*
8466 : : * Local variables:
8467 : : * c-basic-offset: 8
8468 : : * End:
8469 : : */
|
