4 * Client-side procedure declarations for NFSv4.
6 * Copyright (c) 2002 The Regents of the University of Michigan.
9 * Kendrick Smith <kmsmith@umich.edu>
10 * Andy Adamson <andros@umich.edu>
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
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.
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.
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/xattr.h>
55 #include <linux/utsname.h>
56 #include <linux/freezer.h>
59 #include "delegation.h"
65 #include "nfs4idmap.h"
66 #include "nfs4session.h"
69 #include "nfs4trace.h"
71 #define NFSDBG_FACILITY NFSDBG_PROC
73 #define NFS4_POLL_RETRY_MIN (HZ/10)
74 #define NFS4_POLL_RETRY_MAX (15*HZ)
76 /* file attributes which can be mapped to nfs attributes */
77 #define NFS4_VALID_ATTRS (ATTR_MODE \
88 static int _nfs4_proc_open(struct nfs4_opendata *data);
89 static int _nfs4_recover_proc_open(struct nfs4_opendata *data);
90 static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *);
91 static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr);
92 static int nfs4_proc_getattr(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *, struct nfs4_label *label);
93 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr, struct nfs4_label *label);
94 static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
95 struct nfs_fattr *fattr, struct iattr *sattr,
96 struct nfs4_state *state, struct nfs4_label *ilabel,
97 struct nfs4_label *olabel);
98 #ifdef CONFIG_NFS_V4_1
99 static int nfs41_test_stateid(struct nfs_server *, nfs4_stateid *,
101 static int nfs41_free_stateid(struct nfs_server *, const nfs4_stateid *,
102 struct rpc_cred *, bool);
105 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
106 static inline struct nfs4_label *
107 nfs4_label_init_security(struct inode *dir, struct dentry *dentry,
108 struct iattr *sattr, struct nfs4_label *label)
115 if (nfs_server_capable(dir, NFS_CAP_SECURITY_LABEL) == 0)
118 err = security_dentry_init_security(dentry, sattr->ia_mode,
119 &dentry->d_name, (void **)&label->label, &label->len);
126 nfs4_label_release_security(struct nfs4_label *label)
129 security_release_secctx(label->label, label->len);
131 static inline u32 *nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label)
134 return server->attr_bitmask;
136 return server->attr_bitmask_nl;
139 static inline struct nfs4_label *
140 nfs4_label_init_security(struct inode *dir, struct dentry *dentry,
141 struct iattr *sattr, struct nfs4_label *l)
144 nfs4_label_release_security(struct nfs4_label *label)
147 nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label)
148 { return server->attr_bitmask; }
151 /* Prevent leaks of NFSv4 errors into userland */
152 static int nfs4_map_errors(int err)
157 case -NFS4ERR_RESOURCE:
158 case -NFS4ERR_LAYOUTTRYLATER:
159 case -NFS4ERR_RECALLCONFLICT:
161 case -NFS4ERR_WRONGSEC:
162 case -NFS4ERR_WRONG_CRED:
164 case -NFS4ERR_BADOWNER:
165 case -NFS4ERR_BADNAME:
167 case -NFS4ERR_SHARE_DENIED:
169 case -NFS4ERR_MINOR_VERS_MISMATCH:
170 return -EPROTONOSUPPORT;
171 case -NFS4ERR_FILE_OPEN:
174 dprintk("%s could not handle NFSv4 error %d\n",
182 * This is our standard bitmap for GETATTR requests.
184 const u32 nfs4_fattr_bitmap[3] = {
186 | FATTR4_WORD0_CHANGE
189 | FATTR4_WORD0_FILEID,
191 | FATTR4_WORD1_NUMLINKS
193 | FATTR4_WORD1_OWNER_GROUP
194 | FATTR4_WORD1_RAWDEV
195 | FATTR4_WORD1_SPACE_USED
196 | FATTR4_WORD1_TIME_ACCESS
197 | FATTR4_WORD1_TIME_METADATA
198 | FATTR4_WORD1_TIME_MODIFY
199 | FATTR4_WORD1_MOUNTED_ON_FILEID,
200 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
201 FATTR4_WORD2_SECURITY_LABEL
205 static const u32 nfs4_pnfs_open_bitmap[3] = {
207 | FATTR4_WORD0_CHANGE
210 | FATTR4_WORD0_FILEID,
212 | FATTR4_WORD1_NUMLINKS
214 | FATTR4_WORD1_OWNER_GROUP
215 | FATTR4_WORD1_RAWDEV
216 | FATTR4_WORD1_SPACE_USED
217 | FATTR4_WORD1_TIME_ACCESS
218 | FATTR4_WORD1_TIME_METADATA
219 | FATTR4_WORD1_TIME_MODIFY,
220 FATTR4_WORD2_MDSTHRESHOLD
221 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
222 | FATTR4_WORD2_SECURITY_LABEL
226 static const u32 nfs4_open_noattr_bitmap[3] = {
228 | FATTR4_WORD0_CHANGE
229 | FATTR4_WORD0_FILEID,
232 const u32 nfs4_statfs_bitmap[3] = {
233 FATTR4_WORD0_FILES_AVAIL
234 | FATTR4_WORD0_FILES_FREE
235 | FATTR4_WORD0_FILES_TOTAL,
236 FATTR4_WORD1_SPACE_AVAIL
237 | FATTR4_WORD1_SPACE_FREE
238 | FATTR4_WORD1_SPACE_TOTAL
241 const u32 nfs4_pathconf_bitmap[3] = {
243 | FATTR4_WORD0_MAXNAME,
247 const u32 nfs4_fsinfo_bitmap[3] = { FATTR4_WORD0_MAXFILESIZE
248 | FATTR4_WORD0_MAXREAD
249 | FATTR4_WORD0_MAXWRITE
250 | FATTR4_WORD0_LEASE_TIME,
251 FATTR4_WORD1_TIME_DELTA
252 | FATTR4_WORD1_FS_LAYOUT_TYPES,
253 FATTR4_WORD2_LAYOUT_BLKSIZE
254 | FATTR4_WORD2_CLONE_BLKSIZE
257 const u32 nfs4_fs_locations_bitmap[3] = {
261 | FATTR4_WORD0_FILEID
262 | FATTR4_WORD0_FS_LOCATIONS,
264 | FATTR4_WORD1_OWNER_GROUP
265 | FATTR4_WORD1_RAWDEV
266 | FATTR4_WORD1_SPACE_USED
267 | FATTR4_WORD1_TIME_ACCESS
268 | FATTR4_WORD1_TIME_METADATA
269 | FATTR4_WORD1_TIME_MODIFY
270 | FATTR4_WORD1_MOUNTED_ON_FILEID,
273 static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dentry,
274 struct nfs4_readdir_arg *readdir)
279 readdir->cookie = cookie;
280 memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier));
285 memset(&readdir->verifier, 0, sizeof(readdir->verifier));
290 * NFSv4 servers do not return entries for '.' and '..'
291 * Therefore, we fake these entries here. We let '.'
292 * have cookie 0 and '..' have cookie 1. Note that
293 * when talking to the server, we always send cookie 0
296 start = p = kmap_atomic(*readdir->pages);
299 *p++ = xdr_one; /* next */
300 *p++ = xdr_zero; /* cookie, first word */
301 *p++ = xdr_one; /* cookie, second word */
302 *p++ = xdr_one; /* entry len */
303 memcpy(p, ".\0\0\0", 4); /* entry */
305 *p++ = xdr_one; /* bitmap length */
306 *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */
307 *p++ = htonl(8); /* attribute buffer length */
308 p = xdr_encode_hyper(p, NFS_FILEID(d_inode(dentry)));
311 *p++ = xdr_one; /* next */
312 *p++ = xdr_zero; /* cookie, first word */
313 *p++ = xdr_two; /* cookie, second word */
314 *p++ = xdr_two; /* entry len */
315 memcpy(p, "..\0\0", 4); /* entry */
317 *p++ = xdr_one; /* bitmap length */
318 *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */
319 *p++ = htonl(8); /* attribute buffer length */
320 p = xdr_encode_hyper(p, NFS_FILEID(d_inode(dentry->d_parent)));
322 readdir->pgbase = (char *)p - (char *)start;
323 readdir->count -= readdir->pgbase;
324 kunmap_atomic(start);
327 static void nfs4_test_and_free_stateid(struct nfs_server *server,
328 nfs4_stateid *stateid,
329 struct rpc_cred *cred)
331 const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops;
333 ops->test_and_free_expired(server, stateid, cred);
336 static void __nfs4_free_revoked_stateid(struct nfs_server *server,
337 nfs4_stateid *stateid,
338 struct rpc_cred *cred)
340 stateid->type = NFS4_REVOKED_STATEID_TYPE;
341 nfs4_test_and_free_stateid(server, stateid, cred);
344 static void nfs4_free_revoked_stateid(struct nfs_server *server,
345 const nfs4_stateid *stateid,
346 struct rpc_cred *cred)
350 nfs4_stateid_copy(&tmp, stateid);
351 __nfs4_free_revoked_stateid(server, &tmp, cred);
354 static long nfs4_update_delay(long *timeout)
358 return NFS4_POLL_RETRY_MAX;
360 *timeout = NFS4_POLL_RETRY_MIN;
361 if (*timeout > NFS4_POLL_RETRY_MAX)
362 *timeout = NFS4_POLL_RETRY_MAX;
368 static int nfs4_delay(struct rpc_clnt *clnt, long *timeout)
374 freezable_schedule_timeout_killable_unsafe(
375 nfs4_update_delay(timeout));
376 if (fatal_signal_pending(current))
381 /* This is the error handling routine for processes that are allowed
384 static int nfs4_do_handle_exception(struct nfs_server *server,
385 int errorcode, struct nfs4_exception *exception)
387 struct nfs_client *clp = server->nfs_client;
388 struct nfs4_state *state = exception->state;
389 const nfs4_stateid *stateid = exception->stateid;
390 struct inode *inode = exception->inode;
393 exception->delay = 0;
394 exception->recovering = 0;
395 exception->retry = 0;
397 if (stateid == NULL && state != NULL)
398 stateid = &state->stateid;
403 case -NFS4ERR_DELEG_REVOKED:
404 case -NFS4ERR_ADMIN_REVOKED:
405 case -NFS4ERR_EXPIRED:
406 case -NFS4ERR_BAD_STATEID:
407 if (inode != NULL && stateid != NULL) {
408 nfs_inode_find_state_and_recover(inode,
410 goto wait_on_recovery;
412 case -NFS4ERR_OPENMODE:
416 err = nfs_async_inode_return_delegation(inode,
419 goto wait_on_recovery;
420 if (stateid != NULL && stateid->type == NFS4_DELEGATION_STATEID_TYPE) {
421 exception->retry = 1;
427 ret = nfs4_schedule_stateid_recovery(server, state);
430 goto wait_on_recovery;
431 case -NFS4ERR_STALE_STATEID:
432 case -NFS4ERR_STALE_CLIENTID:
433 nfs4_schedule_lease_recovery(clp);
434 goto wait_on_recovery;
436 ret = nfs4_schedule_migration_recovery(server);
439 goto wait_on_recovery;
440 case -NFS4ERR_LEASE_MOVED:
441 nfs4_schedule_lease_moved_recovery(clp);
442 goto wait_on_recovery;
443 #if defined(CONFIG_NFS_V4_1)
444 case -NFS4ERR_BADSESSION:
445 case -NFS4ERR_BADSLOT:
446 case -NFS4ERR_BAD_HIGH_SLOT:
447 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
448 case -NFS4ERR_DEADSESSION:
449 case -NFS4ERR_SEQ_FALSE_RETRY:
450 case -NFS4ERR_SEQ_MISORDERED:
451 dprintk("%s ERROR: %d Reset session\n", __func__,
453 nfs4_schedule_session_recovery(clp->cl_session, errorcode);
454 goto wait_on_recovery;
455 #endif /* defined(CONFIG_NFS_V4_1) */
456 case -NFS4ERR_FILE_OPEN:
457 if (exception->timeout > HZ) {
458 /* We have retried a decent amount, time to
465 nfs_inc_server_stats(server, NFSIOS_DELAY);
467 case -NFS4ERR_LAYOUTTRYLATER:
468 case -NFS4ERR_RECALLCONFLICT:
469 exception->delay = 1;
472 case -NFS4ERR_RETRY_UNCACHED_REP:
473 case -NFS4ERR_OLD_STATEID:
474 exception->retry = 1;
476 case -NFS4ERR_BADOWNER:
477 /* The following works around a Linux server bug! */
478 case -NFS4ERR_BADNAME:
479 if (server->caps & NFS_CAP_UIDGID_NOMAP) {
480 server->caps &= ~NFS_CAP_UIDGID_NOMAP;
481 exception->retry = 1;
482 printk(KERN_WARNING "NFS: v4 server %s "
483 "does not accept raw "
485 "Reenabling the idmapper.\n",
486 server->nfs_client->cl_hostname);
489 /* We failed to handle the error */
490 return nfs4_map_errors(ret);
492 exception->recovering = 1;
496 /* This is the error handling routine for processes that are allowed
499 int nfs4_handle_exception(struct nfs_server *server, int errorcode, struct nfs4_exception *exception)
501 struct nfs_client *clp = server->nfs_client;
504 ret = nfs4_do_handle_exception(server, errorcode, exception);
505 if (exception->delay) {
506 ret = nfs4_delay(server->client, &exception->timeout);
509 if (exception->recovering) {
510 ret = nfs4_wait_clnt_recover(clp);
511 if (test_bit(NFS_MIG_FAILED, &server->mig_status))
518 exception->retry = 1;
523 nfs4_async_handle_exception(struct rpc_task *task, struct nfs_server *server,
524 int errorcode, struct nfs4_exception *exception)
526 struct nfs_client *clp = server->nfs_client;
529 ret = nfs4_do_handle_exception(server, errorcode, exception);
530 if (exception->delay) {
531 rpc_delay(task, nfs4_update_delay(&exception->timeout));
534 if (exception->recovering) {
535 rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL);
536 if (test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) == 0)
537 rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task);
540 if (test_bit(NFS_MIG_FAILED, &server->mig_status))
545 exception->retry = 1;
547 * For NFS4ERR_MOVED, the client transport will need to
548 * be recomputed after migration recovery has completed.
550 if (errorcode == -NFS4ERR_MOVED)
551 rpc_task_release_transport(task);
557 nfs4_async_handle_error(struct rpc_task *task, struct nfs_server *server,
558 struct nfs4_state *state, long *timeout)
560 struct nfs4_exception exception = {
564 if (task->tk_status >= 0)
567 exception.timeout = *timeout;
568 task->tk_status = nfs4_async_handle_exception(task, server,
571 if (exception.delay && timeout)
572 *timeout = exception.timeout;
579 * Return 'true' if 'clp' is using an rpc_client that is integrity protected
580 * or 'false' otherwise.
582 static bool _nfs4_is_integrity_protected(struct nfs_client *clp)
584 rpc_authflavor_t flavor = clp->cl_rpcclient->cl_auth->au_flavor;
586 if (flavor == RPC_AUTH_GSS_KRB5I ||
587 flavor == RPC_AUTH_GSS_KRB5P)
593 static void do_renew_lease(struct nfs_client *clp, unsigned long timestamp)
595 spin_lock(&clp->cl_lock);
596 if (time_before(clp->cl_last_renewal,timestamp))
597 clp->cl_last_renewal = timestamp;
598 spin_unlock(&clp->cl_lock);
601 static void renew_lease(const struct nfs_server *server, unsigned long timestamp)
603 struct nfs_client *clp = server->nfs_client;
605 if (!nfs4_has_session(clp))
606 do_renew_lease(clp, timestamp);
609 struct nfs4_call_sync_data {
610 const struct nfs_server *seq_server;
611 struct nfs4_sequence_args *seq_args;
612 struct nfs4_sequence_res *seq_res;
615 void nfs4_init_sequence(struct nfs4_sequence_args *args,
616 struct nfs4_sequence_res *res, int cache_reply)
618 args->sa_slot = NULL;
619 args->sa_cache_this = cache_reply;
620 args->sa_privileged = 0;
625 static void nfs4_set_sequence_privileged(struct nfs4_sequence_args *args)
627 args->sa_privileged = 1;
630 int nfs40_setup_sequence(struct nfs4_slot_table *tbl,
631 struct nfs4_sequence_args *args,
632 struct nfs4_sequence_res *res,
633 struct rpc_task *task)
635 struct nfs4_slot *slot;
637 /* slot already allocated? */
638 if (res->sr_slot != NULL)
641 spin_lock(&tbl->slot_tbl_lock);
642 if (nfs4_slot_tbl_draining(tbl) && !args->sa_privileged)
645 slot = nfs4_alloc_slot(tbl);
647 if (slot == ERR_PTR(-ENOMEM))
648 task->tk_timeout = HZ >> 2;
651 spin_unlock(&tbl->slot_tbl_lock);
653 slot->privileged = args->sa_privileged ? 1 : 0;
654 args->sa_slot = slot;
658 rpc_call_start(task);
662 if (args->sa_privileged)
663 rpc_sleep_on_priority(&tbl->slot_tbl_waitq, task,
664 NULL, RPC_PRIORITY_PRIVILEGED);
666 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);
667 spin_unlock(&tbl->slot_tbl_lock);
670 EXPORT_SYMBOL_GPL(nfs40_setup_sequence);
672 static void nfs40_sequence_free_slot(struct nfs4_sequence_res *res)
674 struct nfs4_slot *slot = res->sr_slot;
675 struct nfs4_slot_table *tbl;
678 spin_lock(&tbl->slot_tbl_lock);
679 if (!nfs41_wake_and_assign_slot(tbl, slot))
680 nfs4_free_slot(tbl, slot);
681 spin_unlock(&tbl->slot_tbl_lock);
686 static int nfs40_sequence_done(struct rpc_task *task,
687 struct nfs4_sequence_res *res)
689 if (res->sr_slot != NULL)
690 nfs40_sequence_free_slot(res);
694 #if defined(CONFIG_NFS_V4_1)
696 static void nfs41_sequence_free_slot(struct nfs4_sequence_res *res)
698 struct nfs4_session *session;
699 struct nfs4_slot_table *tbl;
700 struct nfs4_slot *slot = res->sr_slot;
701 bool send_new_highest_used_slotid = false;
704 session = tbl->session;
706 /* Bump the slot sequence number */
711 spin_lock(&tbl->slot_tbl_lock);
712 /* Be nice to the server: try to ensure that the last transmitted
713 * value for highest_user_slotid <= target_highest_slotid
715 if (tbl->highest_used_slotid > tbl->target_highest_slotid)
716 send_new_highest_used_slotid = true;
718 if (nfs41_wake_and_assign_slot(tbl, slot)) {
719 send_new_highest_used_slotid = false;
722 nfs4_free_slot(tbl, slot);
724 if (tbl->highest_used_slotid != NFS4_NO_SLOT)
725 send_new_highest_used_slotid = false;
727 spin_unlock(&tbl->slot_tbl_lock);
729 if (send_new_highest_used_slotid)
730 nfs41_notify_server(session->clp);
731 if (waitqueue_active(&tbl->slot_waitq))
732 wake_up_all(&tbl->slot_waitq);
735 static int nfs41_sequence_process(struct rpc_task *task,
736 struct nfs4_sequence_res *res)
738 struct nfs4_session *session;
739 struct nfs4_slot *slot = res->sr_slot;
740 struct nfs_client *clp;
741 bool interrupted = false;
746 /* don't increment the sequence number if the task wasn't sent */
747 if (!RPC_WAS_SENT(task))
750 session = slot->table->session;
752 if (slot->interrupted) {
753 slot->interrupted = 0;
757 trace_nfs4_sequence_done(session, res);
758 /* Check the SEQUENCE operation status */
759 switch (res->sr_status) {
761 /* If previous op on slot was interrupted and we reused
762 * the seq# and got a reply from the cache, then retry
764 if (task->tk_status == -EREMOTEIO && interrupted) {
768 /* Update the slot's sequence and clientid lease timer */
771 do_renew_lease(clp, res->sr_timestamp);
772 /* Check sequence flags */
773 nfs41_handle_sequence_flag_errors(clp, res->sr_status_flags,
775 nfs41_update_target_slotid(slot->table, slot, res);
779 * sr_status remains 1 if an RPC level error occurred.
780 * The server may or may not have processed the sequence
782 * Mark the slot as having hosted an interrupted RPC call.
784 slot->interrupted = 1;
787 /* The server detected a resend of the RPC call and
788 * returned NFS4ERR_DELAY as per Section 2.10.6.2
791 dprintk("%s: slot=%u seq=%u: Operation in progress\n",
796 case -NFS4ERR_BADSLOT:
798 * The slot id we used was probably retired. Try again
799 * using a different slot id.
802 case -NFS4ERR_SEQ_MISORDERED:
804 * Was the last operation on this sequence interrupted?
805 * If so, retry after bumping the sequence number.
812 * Could this slot have been previously retired?
813 * If so, then the server may be expecting seq_nr = 1!
815 if (slot->seq_nr != 1) {
820 case -NFS4ERR_SEQ_FALSE_RETRY:
824 /* Just update the slot sequence no. */
828 /* The session may be reset by one of the error handlers. */
829 dprintk("%s: Error %d free the slot \n", __func__, res->sr_status);
833 if (rpc_restart_call_prepare(task)) {
834 nfs41_sequence_free_slot(res);
840 if (!rpc_restart_call(task))
842 rpc_delay(task, NFS4_POLL_RETRY_MAX);
846 int nfs41_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res)
848 if (!nfs41_sequence_process(task, res))
850 if (res->sr_slot != NULL)
851 nfs41_sequence_free_slot(res);
855 EXPORT_SYMBOL_GPL(nfs41_sequence_done);
857 static int nfs4_sequence_process(struct rpc_task *task, struct nfs4_sequence_res *res)
859 if (res->sr_slot == NULL)
861 if (res->sr_slot->table->session != NULL)
862 return nfs41_sequence_process(task, res);
863 return nfs40_sequence_done(task, res);
866 static void nfs4_sequence_free_slot(struct nfs4_sequence_res *res)
868 if (res->sr_slot != NULL) {
869 if (res->sr_slot->table->session != NULL)
870 nfs41_sequence_free_slot(res);
872 nfs40_sequence_free_slot(res);
876 int nfs4_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res)
878 if (res->sr_slot == NULL)
880 if (!res->sr_slot->table->session)
881 return nfs40_sequence_done(task, res);
882 return nfs41_sequence_done(task, res);
884 EXPORT_SYMBOL_GPL(nfs4_sequence_done);
886 int nfs41_setup_sequence(struct nfs4_session *session,
887 struct nfs4_sequence_args *args,
888 struct nfs4_sequence_res *res,
889 struct rpc_task *task)
891 struct nfs4_slot *slot;
892 struct nfs4_slot_table *tbl;
894 dprintk("--> %s\n", __func__);
895 /* slot already allocated? */
896 if (res->sr_slot != NULL)
899 tbl = &session->fc_slot_table;
901 task->tk_timeout = 0;
903 spin_lock(&tbl->slot_tbl_lock);
904 if (test_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state) &&
905 !args->sa_privileged) {
906 /* The state manager will wait until the slot table is empty */
907 dprintk("%s session is draining\n", __func__);
911 slot = nfs4_alloc_slot(tbl);
913 /* If out of memory, try again in 1/4 second */
914 if (slot == ERR_PTR(-ENOMEM))
915 task->tk_timeout = HZ >> 2;
916 dprintk("<-- %s: no free slots\n", __func__);
919 spin_unlock(&tbl->slot_tbl_lock);
921 slot->privileged = args->sa_privileged ? 1 : 0;
922 args->sa_slot = slot;
924 dprintk("<-- %s slotid=%u seqid=%u\n", __func__,
925 slot->slot_nr, slot->seq_nr);
928 res->sr_timestamp = jiffies;
929 res->sr_status_flags = 0;
931 * sr_status is only set in decode_sequence, and so will remain
932 * set to 1 if an rpc level failure occurs.
935 trace_nfs4_setup_sequence(session, args);
937 rpc_call_start(task);
940 /* Privileged tasks are queued with top priority */
941 if (args->sa_privileged)
942 rpc_sleep_on_priority(&tbl->slot_tbl_waitq, task,
943 NULL, RPC_PRIORITY_PRIVILEGED);
945 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);
946 spin_unlock(&tbl->slot_tbl_lock);
949 EXPORT_SYMBOL_GPL(nfs41_setup_sequence);
951 static int nfs4_setup_sequence(const struct nfs_server *server,
952 struct nfs4_sequence_args *args,
953 struct nfs4_sequence_res *res,
954 struct rpc_task *task)
956 struct nfs4_session *session = nfs4_get_session(server);
960 return nfs40_setup_sequence(server->nfs_client->cl_slot_tbl,
963 dprintk("--> %s clp %p session %p sr_slot %u\n",
964 __func__, session->clp, session, res->sr_slot ?
965 res->sr_slot->slot_nr : NFS4_NO_SLOT);
967 ret = nfs41_setup_sequence(session, args, res, task);
969 dprintk("<-- %s status=%d\n", __func__, ret);
973 static void nfs41_call_sync_prepare(struct rpc_task *task, void *calldata)
975 struct nfs4_call_sync_data *data = calldata;
976 struct nfs4_session *session = nfs4_get_session(data->seq_server);
978 dprintk("--> %s data->seq_server %p\n", __func__, data->seq_server);
980 nfs41_setup_sequence(session, data->seq_args, data->seq_res, task);
983 static void nfs41_call_sync_done(struct rpc_task *task, void *calldata)
985 struct nfs4_call_sync_data *data = calldata;
987 nfs41_sequence_done(task, data->seq_res);
990 static const struct rpc_call_ops nfs41_call_sync_ops = {
991 .rpc_call_prepare = nfs41_call_sync_prepare,
992 .rpc_call_done = nfs41_call_sync_done,
995 #else /* !CONFIG_NFS_V4_1 */
997 static int nfs4_setup_sequence(const struct nfs_server *server,
998 struct nfs4_sequence_args *args,
999 struct nfs4_sequence_res *res,
1000 struct rpc_task *task)
1002 return nfs40_setup_sequence(server->nfs_client->cl_slot_tbl,
1006 static int nfs4_sequence_process(struct rpc_task *task, struct nfs4_sequence_res *res)
1008 return nfs40_sequence_done(task, res);
1011 static void nfs4_sequence_free_slot(struct nfs4_sequence_res *res)
1013 if (res->sr_slot != NULL)
1014 nfs40_sequence_free_slot(res);
1017 int nfs4_sequence_done(struct rpc_task *task,
1018 struct nfs4_sequence_res *res)
1020 return nfs40_sequence_done(task, res);
1022 EXPORT_SYMBOL_GPL(nfs4_sequence_done);
1024 #endif /* !CONFIG_NFS_V4_1 */
1026 static void nfs40_call_sync_prepare(struct rpc_task *task, void *calldata)
1028 struct nfs4_call_sync_data *data = calldata;
1029 nfs4_setup_sequence(data->seq_server,
1030 data->seq_args, data->seq_res, task);
1033 static void nfs40_call_sync_done(struct rpc_task *task, void *calldata)
1035 struct nfs4_call_sync_data *data = calldata;
1036 nfs4_sequence_done(task, data->seq_res);
1039 static const struct rpc_call_ops nfs40_call_sync_ops = {
1040 .rpc_call_prepare = nfs40_call_sync_prepare,
1041 .rpc_call_done = nfs40_call_sync_done,
1044 static int nfs4_call_sync_sequence(struct rpc_clnt *clnt,
1045 struct nfs_server *server,
1046 struct rpc_message *msg,
1047 struct nfs4_sequence_args *args,
1048 struct nfs4_sequence_res *res)
1051 struct rpc_task *task;
1052 struct nfs_client *clp = server->nfs_client;
1053 struct nfs4_call_sync_data data = {
1054 .seq_server = server,
1058 struct rpc_task_setup task_setup = {
1061 .callback_ops = clp->cl_mvops->call_sync_ops,
1062 .callback_data = &data
1065 task = rpc_run_task(&task_setup);
1067 ret = PTR_ERR(task);
1069 ret = task->tk_status;
1075 int nfs4_call_sync(struct rpc_clnt *clnt,
1076 struct nfs_server *server,
1077 struct rpc_message *msg,
1078 struct nfs4_sequence_args *args,
1079 struct nfs4_sequence_res *res,
1082 nfs4_init_sequence(args, res, cache_reply);
1083 return nfs4_call_sync_sequence(clnt, server, msg, args, res);
1086 static void update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo)
1088 struct nfs_inode *nfsi = NFS_I(dir);
1090 spin_lock(&dir->i_lock);
1091 nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
1092 if (!cinfo->atomic || cinfo->before != dir->i_version)
1093 nfs_force_lookup_revalidate(dir);
1094 dir->i_version = cinfo->after;
1095 nfsi->attr_gencount = nfs_inc_attr_generation_counter();
1096 nfs_fscache_invalidate(dir);
1097 spin_unlock(&dir->i_lock);
1100 struct nfs4_opendata {
1102 struct nfs_openargs o_arg;
1103 struct nfs_openres o_res;
1104 struct nfs_open_confirmargs c_arg;
1105 struct nfs_open_confirmres c_res;
1106 struct nfs4_string owner_name;
1107 struct nfs4_string group_name;
1108 struct nfs4_label *a_label;
1109 struct nfs_fattr f_attr;
1110 struct nfs4_label *f_label;
1112 struct dentry *dentry;
1113 struct nfs4_state_owner *owner;
1114 struct nfs4_state *state;
1116 unsigned long timestamp;
1117 unsigned int rpc_done : 1;
1118 unsigned int file_created : 1;
1119 unsigned int is_recover : 1;
1124 struct nfs4_open_createattrs {
1125 struct nfs4_label *label;
1126 struct iattr *sattr;
1127 const __u32 verf[2];
1130 static bool nfs4_clear_cap_atomic_open_v1(struct nfs_server *server,
1131 int err, struct nfs4_exception *exception)
1135 if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1))
1137 server->caps &= ~NFS_CAP_ATOMIC_OPEN_V1;
1138 exception->retry = 1;
1143 nfs4_map_atomic_open_share(struct nfs_server *server,
1144 fmode_t fmode, int openflags)
1148 switch (fmode & (FMODE_READ | FMODE_WRITE)) {
1150 res = NFS4_SHARE_ACCESS_READ;
1153 res = NFS4_SHARE_ACCESS_WRITE;
1155 case FMODE_READ|FMODE_WRITE:
1156 res = NFS4_SHARE_ACCESS_BOTH;
1158 if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1))
1160 /* Want no delegation if we're using O_DIRECT */
1161 if (openflags & O_DIRECT)
1162 res |= NFS4_SHARE_WANT_NO_DELEG;
1167 static enum open_claim_type4
1168 nfs4_map_atomic_open_claim(struct nfs_server *server,
1169 enum open_claim_type4 claim)
1171 if (server->caps & NFS_CAP_ATOMIC_OPEN_V1)
1176 case NFS4_OPEN_CLAIM_FH:
1177 return NFS4_OPEN_CLAIM_NULL;
1178 case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
1179 return NFS4_OPEN_CLAIM_DELEGATE_CUR;
1180 case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
1181 return NFS4_OPEN_CLAIM_DELEGATE_PREV;
1185 static void nfs4_init_opendata_res(struct nfs4_opendata *p)
1187 p->o_res.f_attr = &p->f_attr;
1188 p->o_res.f_label = p->f_label;
1189 p->o_res.seqid = p->o_arg.seqid;
1190 p->c_res.seqid = p->c_arg.seqid;
1191 p->o_res.server = p->o_arg.server;
1192 p->o_res.access_request = p->o_arg.access;
1193 nfs_fattr_init(&p->f_attr);
1194 nfs_fattr_init_names(&p->f_attr, &p->owner_name, &p->group_name);
1197 static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
1198 struct nfs4_state_owner *sp, fmode_t fmode, int flags,
1199 const struct nfs4_open_createattrs *c,
1200 enum open_claim_type4 claim,
1203 struct dentry *parent = dget_parent(dentry);
1204 struct inode *dir = d_inode(parent);
1205 struct nfs_server *server = NFS_SERVER(dir);
1206 struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
1207 struct nfs4_label *label = (c != NULL) ? c->label : NULL;
1208 struct nfs4_opendata *p;
1210 p = kzalloc(sizeof(*p), gfp_mask);
1214 p->f_label = nfs4_label_alloc(server, gfp_mask);
1215 if (IS_ERR(p->f_label))
1218 p->a_label = nfs4_label_alloc(server, gfp_mask);
1219 if (IS_ERR(p->a_label))
1222 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;
1223 p->o_arg.seqid = alloc_seqid(&sp->so_seqid, gfp_mask);
1224 if (IS_ERR(p->o_arg.seqid))
1225 goto err_free_label;
1226 nfs_sb_active(dentry->d_sb);
1227 p->dentry = dget(dentry);
1230 atomic_inc(&sp->so_count);
1231 p->o_arg.open_flags = flags;
1232 p->o_arg.fmode = fmode & (FMODE_READ|FMODE_WRITE);
1233 p->o_arg.share_access = nfs4_map_atomic_open_share(server,
1235 /* don't put an ACCESS op in OPEN compound if O_EXCL, because ACCESS
1236 * will return permission denied for all bits until close */
1237 if (!(flags & O_EXCL)) {
1238 /* ask server to check for all possible rights as results
1240 p->o_arg.access = NFS4_ACCESS_READ | NFS4_ACCESS_MODIFY |
1241 NFS4_ACCESS_EXTEND | NFS4_ACCESS_EXECUTE;
1243 p->o_arg.clientid = server->nfs_client->cl_clientid;
1244 p->o_arg.id.create_time = ktime_to_ns(sp->so_seqid.create_time);
1245 p->o_arg.id.uniquifier = sp->so_seqid.owner_id;
1246 p->o_arg.name = &dentry->d_name;
1247 p->o_arg.server = server;
1248 p->o_arg.bitmask = nfs4_bitmask(server, label);
1249 p->o_arg.open_bitmap = &nfs4_fattr_bitmap[0];
1250 p->o_arg.label = nfs4_label_copy(p->a_label, label);
1251 p->o_arg.claim = nfs4_map_atomic_open_claim(server, claim);
1252 switch (p->o_arg.claim) {
1253 case NFS4_OPEN_CLAIM_NULL:
1254 case NFS4_OPEN_CLAIM_DELEGATE_CUR:
1255 case NFS4_OPEN_CLAIM_DELEGATE_PREV:
1256 p->o_arg.fh = NFS_FH(dir);
1258 case NFS4_OPEN_CLAIM_PREVIOUS:
1259 case NFS4_OPEN_CLAIM_FH:
1260 case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
1261 case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
1262 p->o_arg.fh = NFS_FH(d_inode(dentry));
1264 if (c != NULL && c->sattr != NULL && c->sattr->ia_valid != 0) {
1265 p->o_arg.u.attrs = &p->attrs;
1266 memcpy(&p->attrs, c->sattr, sizeof(p->attrs));
1268 memcpy(p->o_arg.u.verifier.data, c->verf,
1269 sizeof(p->o_arg.u.verifier.data));
1271 p->c_arg.fh = &p->o_res.fh;
1272 p->c_arg.stateid = &p->o_res.stateid;
1273 p->c_arg.seqid = p->o_arg.seqid;
1274 nfs4_init_opendata_res(p);
1275 kref_init(&p->kref);
1279 nfs4_label_free(p->a_label);
1281 nfs4_label_free(p->f_label);
1289 static void nfs4_opendata_free(struct kref *kref)
1291 struct nfs4_opendata *p = container_of(kref,
1292 struct nfs4_opendata, kref);
1293 struct super_block *sb = p->dentry->d_sb;
1295 nfs_free_seqid(p->o_arg.seqid);
1296 nfs4_sequence_free_slot(&p->o_res.seq_res);
1297 if (p->state != NULL)
1298 nfs4_put_open_state(p->state);
1299 nfs4_put_state_owner(p->owner);
1301 nfs4_label_free(p->a_label);
1302 nfs4_label_free(p->f_label);
1306 nfs_sb_deactive(sb);
1307 nfs_fattr_free_names(&p->f_attr);
1308 kfree(p->f_attr.mdsthreshold);
1312 static void nfs4_opendata_put(struct nfs4_opendata *p)
1315 kref_put(&p->kref, nfs4_opendata_free);
1318 static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task)
1322 ret = rpc_wait_for_completion_task(task);
1326 static bool nfs4_mode_match_open_stateid(struct nfs4_state *state,
1329 switch(fmode & (FMODE_READ|FMODE_WRITE)) {
1330 case FMODE_READ|FMODE_WRITE:
1331 return state->n_rdwr != 0;
1333 return state->n_wronly != 0;
1335 return state->n_rdonly != 0;
1341 static int can_open_cached(struct nfs4_state *state, fmode_t mode, int open_mode)
1345 if (open_mode & (O_EXCL|O_TRUNC))
1347 switch (mode & (FMODE_READ|FMODE_WRITE)) {
1349 ret |= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0
1350 && state->n_rdonly != 0;
1353 ret |= test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0
1354 && state->n_wronly != 0;
1356 case FMODE_READ|FMODE_WRITE:
1357 ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0
1358 && state->n_rdwr != 0;
1364 static int can_open_delegated(struct nfs_delegation *delegation, fmode_t fmode,
1365 enum open_claim_type4 claim)
1367 if (delegation == NULL)
1369 if ((delegation->type & fmode) != fmode)
1372 case NFS4_OPEN_CLAIM_NULL:
1373 case NFS4_OPEN_CLAIM_FH:
1375 case NFS4_OPEN_CLAIM_PREVIOUS:
1376 if (!test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags))
1381 nfs_mark_delegation_referenced(delegation);
1385 static void update_open_stateflags(struct nfs4_state *state, fmode_t fmode)
1394 case FMODE_READ|FMODE_WRITE:
1397 nfs4_state_set_mode_locked(state, state->state | fmode);
1400 #ifdef CONFIG_NFS_V4_1
1401 static bool nfs_open_stateid_recover_openmode(struct nfs4_state *state)
1403 if (state->n_rdonly && !test_bit(NFS_O_RDONLY_STATE, &state->flags))
1405 if (state->n_wronly && !test_bit(NFS_O_WRONLY_STATE, &state->flags))
1407 if (state->n_rdwr && !test_bit(NFS_O_RDWR_STATE, &state->flags))
1411 #endif /* CONFIG_NFS_V4_1 */
1413 static void nfs_test_and_clear_all_open_stateid(struct nfs4_state *state)
1415 struct nfs_client *clp = state->owner->so_server->nfs_client;
1416 bool need_recover = false;
1418 if (test_and_clear_bit(NFS_O_RDONLY_STATE, &state->flags) && state->n_rdonly)
1419 need_recover = true;
1420 if (test_and_clear_bit(NFS_O_WRONLY_STATE, &state->flags) && state->n_wronly)
1421 need_recover = true;
1422 if (test_and_clear_bit(NFS_O_RDWR_STATE, &state->flags) && state->n_rdwr)
1423 need_recover = true;
1425 nfs4_state_mark_reclaim_nograce(clp, state);
1428 static bool nfs_need_update_open_stateid(struct nfs4_state *state,
1429 const nfs4_stateid *stateid, nfs4_stateid *freeme)
1431 if (test_and_set_bit(NFS_OPEN_STATE, &state->flags) == 0)
1433 if (!nfs4_stateid_match_other(stateid, &state->open_stateid)) {
1434 nfs4_stateid_copy(freeme, &state->open_stateid);
1435 nfs_test_and_clear_all_open_stateid(state);
1438 if (nfs4_stateid_is_newer(stateid, &state->open_stateid))
1443 static void nfs_resync_open_stateid_locked(struct nfs4_state *state)
1445 if (!(state->n_wronly || state->n_rdonly || state->n_rdwr))
1447 if (state->n_wronly)
1448 set_bit(NFS_O_WRONLY_STATE, &state->flags);
1449 if (state->n_rdonly)
1450 set_bit(NFS_O_RDONLY_STATE, &state->flags);
1452 set_bit(NFS_O_RDWR_STATE, &state->flags);
1453 set_bit(NFS_OPEN_STATE, &state->flags);
1456 static void nfs_clear_open_stateid_locked(struct nfs4_state *state,
1457 nfs4_stateid *stateid, fmode_t fmode)
1459 clear_bit(NFS_O_RDWR_STATE, &state->flags);
1460 switch (fmode & (FMODE_READ|FMODE_WRITE)) {
1462 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1465 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1468 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1469 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1470 clear_bit(NFS_OPEN_STATE, &state->flags);
1472 if (stateid == NULL)
1474 /* Handle OPEN+OPEN_DOWNGRADE races */
1475 if (nfs4_stateid_match_other(stateid, &state->open_stateid) &&
1476 !nfs4_stateid_is_newer(stateid, &state->open_stateid)) {
1477 nfs_resync_open_stateid_locked(state);
1480 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
1481 nfs4_stateid_copy(&state->stateid, stateid);
1482 nfs4_stateid_copy(&state->open_stateid, stateid);
1485 static void nfs_clear_open_stateid(struct nfs4_state *state,
1486 nfs4_stateid *arg_stateid,
1487 nfs4_stateid *stateid, fmode_t fmode)
1489 write_seqlock(&state->seqlock);
1490 /* Ignore, if the CLOSE argment doesn't match the current stateid */
1491 if (nfs4_state_match_open_stateid_other(state, arg_stateid))
1492 nfs_clear_open_stateid_locked(state, stateid, fmode);
1493 write_sequnlock(&state->seqlock);
1494 if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags))
1495 nfs4_schedule_state_manager(state->owner->so_server->nfs_client);
1498 static void nfs_set_open_stateid_locked(struct nfs4_state *state,
1499 const nfs4_stateid *stateid, fmode_t fmode,
1500 nfs4_stateid *freeme)
1504 set_bit(NFS_O_RDONLY_STATE, &state->flags);
1507 set_bit(NFS_O_WRONLY_STATE, &state->flags);
1509 case FMODE_READ|FMODE_WRITE:
1510 set_bit(NFS_O_RDWR_STATE, &state->flags);
1512 if (!nfs_need_update_open_stateid(state, stateid, freeme))
1514 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
1515 nfs4_stateid_copy(&state->stateid, stateid);
1516 nfs4_stateid_copy(&state->open_stateid, stateid);
1519 static void __update_open_stateid(struct nfs4_state *state,
1520 const nfs4_stateid *open_stateid,
1521 const nfs4_stateid *deleg_stateid,
1523 nfs4_stateid *freeme)
1526 * Protect the call to nfs4_state_set_mode_locked and
1527 * serialise the stateid update
1529 spin_lock(&state->owner->so_lock);
1530 write_seqlock(&state->seqlock);
1531 if (deleg_stateid != NULL) {
1532 nfs4_stateid_copy(&state->stateid, deleg_stateid);
1533 set_bit(NFS_DELEGATED_STATE, &state->flags);
1535 if (open_stateid != NULL)
1536 nfs_set_open_stateid_locked(state, open_stateid, fmode, freeme);
1537 write_sequnlock(&state->seqlock);
1538 update_open_stateflags(state, fmode);
1539 spin_unlock(&state->owner->so_lock);
1542 static int update_open_stateid(struct nfs4_state *state,
1543 const nfs4_stateid *open_stateid,
1544 const nfs4_stateid *delegation,
1547 struct nfs_server *server = NFS_SERVER(state->inode);
1548 struct nfs_client *clp = server->nfs_client;
1549 struct nfs_inode *nfsi = NFS_I(state->inode);
1550 struct nfs_delegation *deleg_cur;
1551 nfs4_stateid freeme = { };
1554 fmode &= (FMODE_READ|FMODE_WRITE);
1557 deleg_cur = rcu_dereference(nfsi->delegation);
1558 if (deleg_cur == NULL)
1561 spin_lock(&deleg_cur->lock);
1562 if (rcu_dereference(nfsi->delegation) != deleg_cur ||
1563 test_bit(NFS_DELEGATION_RETURNING, &deleg_cur->flags) ||
1564 (deleg_cur->type & fmode) != fmode)
1565 goto no_delegation_unlock;
1567 if (delegation == NULL)
1568 delegation = &deleg_cur->stateid;
1569 else if (!nfs4_stateid_match(&deleg_cur->stateid, delegation))
1570 goto no_delegation_unlock;
1572 nfs_mark_delegation_referenced(deleg_cur);
1573 __update_open_stateid(state, open_stateid, &deleg_cur->stateid,
1576 no_delegation_unlock:
1577 spin_unlock(&deleg_cur->lock);
1581 if (!ret && open_stateid != NULL) {
1582 __update_open_stateid(state, open_stateid, NULL, fmode, &freeme);
1585 if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags))
1586 nfs4_schedule_state_manager(clp);
1587 if (freeme.type != 0)
1588 nfs4_test_and_free_stateid(server, &freeme,
1589 state->owner->so_cred);
1594 static bool nfs4_update_lock_stateid(struct nfs4_lock_state *lsp,
1595 const nfs4_stateid *stateid)
1597 struct nfs4_state *state = lsp->ls_state;
1600 spin_lock(&state->state_lock);
1601 if (!nfs4_stateid_match_other(stateid, &lsp->ls_stateid))
1603 if (!nfs4_stateid_is_newer(stateid, &lsp->ls_stateid))
1605 nfs4_stateid_copy(&lsp->ls_stateid, stateid);
1608 spin_unlock(&state->state_lock);
1612 static void nfs4_return_incompatible_delegation(struct inode *inode, fmode_t fmode)
1614 struct nfs_delegation *delegation;
1617 delegation = rcu_dereference(NFS_I(inode)->delegation);
1618 if (delegation == NULL || (delegation->type & fmode) == fmode) {
1623 nfs4_inode_return_delegation(inode);
1626 static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata)
1628 struct nfs4_state *state = opendata->state;
1629 struct nfs_delegation *delegation;
1630 int open_mode = opendata->o_arg.open_flags;
1631 fmode_t fmode = opendata->o_arg.fmode;
1632 enum open_claim_type4 claim = opendata->o_arg.claim;
1633 nfs4_stateid stateid;
1637 spin_lock(&state->owner->so_lock);
1638 if (can_open_cached(state, fmode, open_mode)) {
1639 update_open_stateflags(state, fmode);
1640 spin_unlock(&state->owner->so_lock);
1641 goto out_return_state;
1643 spin_unlock(&state->owner->so_lock);
1645 delegation = nfs4_get_valid_delegation(state->inode);
1646 if (!can_open_delegated(delegation, fmode, claim)) {
1650 /* Save the delegation */
1651 nfs4_stateid_copy(&stateid, &delegation->stateid);
1653 nfs_release_seqid(opendata->o_arg.seqid);
1654 if (!opendata->is_recover) {
1655 ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode);
1661 /* Try to update the stateid using the delegation */
1662 if (update_open_stateid(state, NULL, &stateid, fmode))
1663 goto out_return_state;
1666 return ERR_PTR(ret);
1668 atomic_inc(&state->count);
1673 nfs4_opendata_check_deleg(struct nfs4_opendata *data, struct nfs4_state *state)
1675 struct nfs_client *clp = NFS_SERVER(state->inode)->nfs_client;
1676 struct nfs_delegation *delegation;
1677 int delegation_flags = 0;
1680 delegation = rcu_dereference(NFS_I(state->inode)->delegation);
1682 delegation_flags = delegation->flags;
1684 switch (data->o_arg.claim) {
1687 case NFS4_OPEN_CLAIM_DELEGATE_CUR:
1688 case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
1689 pr_err_ratelimited("NFS: Broken NFSv4 server %s is "
1690 "returning a delegation for "
1691 "OPEN(CLAIM_DELEGATE_CUR)\n",
1695 if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0)
1696 nfs_inode_set_delegation(state->inode,
1697 data->owner->so_cred,
1700 nfs_inode_reclaim_delegation(state->inode,
1701 data->owner->so_cred,
1706 * Check the inode attributes against the CLAIM_PREVIOUS returned attributes
1707 * and update the nfs4_state.
1709 static struct nfs4_state *
1710 _nfs4_opendata_reclaim_to_nfs4_state(struct nfs4_opendata *data)
1712 struct inode *inode = data->state->inode;
1713 struct nfs4_state *state = data->state;
1716 if (!data->rpc_done) {
1717 if (data->rpc_status) {
1718 ret = data->rpc_status;
1721 /* cached opens have already been processed */
1725 ret = nfs_refresh_inode(inode, &data->f_attr);
1729 if (data->o_res.delegation_type != 0)
1730 nfs4_opendata_check_deleg(data, state);
1732 update_open_stateid(state, &data->o_res.stateid, NULL,
1734 atomic_inc(&state->count);
1738 return ERR_PTR(ret);
1742 static struct nfs4_state *
1743 _nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
1745 struct inode *inode;
1746 struct nfs4_state *state = NULL;
1749 if (!data->rpc_done) {
1750 state = nfs4_try_open_cached(data);
1751 trace_nfs4_cached_open(data->state);
1756 if (!(data->f_attr.valid & NFS_ATTR_FATTR))
1758 inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr, data->f_label);
1759 ret = PTR_ERR(inode);
1763 state = nfs4_get_open_state(inode, data->owner);
1766 if (data->o_res.delegation_type != 0)
1767 nfs4_opendata_check_deleg(data, state);
1768 update_open_stateid(state, &data->o_res.stateid, NULL,
1772 nfs_release_seqid(data->o_arg.seqid);
1777 return ERR_PTR(ret);
1780 static struct nfs4_state *
1781 nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
1783 struct nfs4_state *ret;
1785 if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS)
1786 ret =_nfs4_opendata_reclaim_to_nfs4_state(data);
1788 ret = _nfs4_opendata_to_nfs4_state(data);
1789 nfs4_sequence_free_slot(&data->o_res.seq_res);
1793 static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *state)
1795 struct nfs_inode *nfsi = NFS_I(state->inode);
1796 struct nfs_open_context *ctx;
1798 spin_lock(&state->inode->i_lock);
1799 list_for_each_entry(ctx, &nfsi->open_files, list) {
1800 if (ctx->state != state)
1802 get_nfs_open_context(ctx);
1803 spin_unlock(&state->inode->i_lock);
1806 spin_unlock(&state->inode->i_lock);
1807 return ERR_PTR(-ENOENT);
1810 static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context *ctx,
1811 struct nfs4_state *state, enum open_claim_type4 claim)
1813 struct nfs4_opendata *opendata;
1815 opendata = nfs4_opendata_alloc(ctx->dentry, state->owner, 0, 0,
1816 NULL, claim, GFP_NOFS);
1817 if (opendata == NULL)
1818 return ERR_PTR(-ENOMEM);
1819 opendata->state = state;
1820 atomic_inc(&state->count);
1824 static int nfs4_open_recover_helper(struct nfs4_opendata *opendata,
1827 struct nfs4_state *newstate;
1830 if (!nfs4_mode_match_open_stateid(opendata->state, fmode))
1832 opendata->o_arg.open_flags = 0;
1833 opendata->o_arg.fmode = fmode;
1834 opendata->o_arg.share_access = nfs4_map_atomic_open_share(
1835 NFS_SB(opendata->dentry->d_sb),
1837 memset(&opendata->o_res, 0, sizeof(opendata->o_res));
1838 memset(&opendata->c_res, 0, sizeof(opendata->c_res));
1839 nfs4_init_opendata_res(opendata);
1840 ret = _nfs4_recover_proc_open(opendata);
1843 newstate = nfs4_opendata_to_nfs4_state(opendata);
1844 if (IS_ERR(newstate))
1845 return PTR_ERR(newstate);
1846 if (newstate != opendata->state)
1848 nfs4_close_state(newstate, fmode);
1852 static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *state)
1856 /* Don't trigger recovery in nfs_test_and_clear_all_open_stateid */
1857 clear_bit(NFS_O_RDWR_STATE, &state->flags);
1858 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1859 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1860 /* memory barrier prior to reading state->n_* */
1861 clear_bit(NFS_DELEGATED_STATE, &state->flags);
1862 clear_bit(NFS_OPEN_STATE, &state->flags);
1864 ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE);
1867 ret = nfs4_open_recover_helper(opendata, FMODE_WRITE);
1870 ret = nfs4_open_recover_helper(opendata, FMODE_READ);
1874 * We may have performed cached opens for all three recoveries.
1875 * Check if we need to update the current stateid.
1877 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 &&
1878 !nfs4_stateid_match(&state->stateid, &state->open_stateid)) {
1879 write_seqlock(&state->seqlock);
1880 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
1881 nfs4_stateid_copy(&state->stateid, &state->open_stateid);
1882 write_sequnlock(&state->seqlock);
1889 * reclaim state on the server after a reboot.
1891 static int _nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
1893 struct nfs_delegation *delegation;
1894 struct nfs4_opendata *opendata;
1895 fmode_t delegation_type = 0;
1898 opendata = nfs4_open_recoverdata_alloc(ctx, state,
1899 NFS4_OPEN_CLAIM_PREVIOUS);
1900 if (IS_ERR(opendata))
1901 return PTR_ERR(opendata);
1903 delegation = rcu_dereference(NFS_I(state->inode)->delegation);
1904 if (delegation != NULL && test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) != 0)
1905 delegation_type = delegation->type;
1907 opendata->o_arg.u.delegation_type = delegation_type;
1908 status = nfs4_open_recover(opendata, state);
1909 nfs4_opendata_put(opendata);
1913 static int nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
1915 struct nfs_server *server = NFS_SERVER(state->inode);
1916 struct nfs4_exception exception = { };
1919 err = _nfs4_do_open_reclaim(ctx, state);
1920 trace_nfs4_open_reclaim(ctx, 0, err);
1921 if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))
1923 if (err != -NFS4ERR_DELAY)
1925 nfs4_handle_exception(server, err, &exception);
1926 } while (exception.retry);
1930 static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state)
1932 struct nfs_open_context *ctx;
1935 ctx = nfs4_state_find_open_context(state);
1938 ret = nfs4_do_open_reclaim(ctx, state);
1939 put_nfs_open_context(ctx);
1943 static int nfs4_handle_delegation_recall_error(struct nfs_server *server, struct nfs4_state *state, const nfs4_stateid *stateid, struct file_lock *fl, int err)
1947 printk(KERN_ERR "NFS: %s: unhandled error "
1948 "%d.\n", __func__, err);
1954 case -NFS4ERR_BADSESSION:
1955 case -NFS4ERR_BADSLOT:
1956 case -NFS4ERR_BAD_HIGH_SLOT:
1957 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1958 case -NFS4ERR_DEADSESSION:
1959 set_bit(NFS_DELEGATED_STATE, &state->flags);
1960 nfs4_schedule_session_recovery(server->nfs_client->cl_session, err);
1962 case -NFS4ERR_STALE_CLIENTID:
1963 case -NFS4ERR_STALE_STATEID:
1964 set_bit(NFS_DELEGATED_STATE, &state->flags);
1965 /* Don't recall a delegation if it was lost */
1966 nfs4_schedule_lease_recovery(server->nfs_client);
1968 case -NFS4ERR_MOVED:
1969 nfs4_schedule_migration_recovery(server);
1971 case -NFS4ERR_LEASE_MOVED:
1972 nfs4_schedule_lease_moved_recovery(server->nfs_client);
1974 case -NFS4ERR_DELEG_REVOKED:
1975 case -NFS4ERR_ADMIN_REVOKED:
1976 case -NFS4ERR_EXPIRED:
1977 case -NFS4ERR_BAD_STATEID:
1978 case -NFS4ERR_OPENMODE:
1979 nfs_inode_find_state_and_recover(state->inode,
1981 nfs4_schedule_stateid_recovery(server, state);
1983 case -NFS4ERR_DELAY:
1984 case -NFS4ERR_GRACE:
1985 set_bit(NFS_DELEGATED_STATE, &state->flags);
1989 case -NFS4ERR_DENIED:
1991 struct nfs4_lock_state *lsp = fl->fl_u.nfs4_fl.owner;
1993 set_bit(NFS_LOCK_LOST, &lsp->ls_flags);
2000 int nfs4_open_delegation_recall(struct nfs_open_context *ctx,
2001 struct nfs4_state *state, const nfs4_stateid *stateid,
2004 struct nfs_server *server = NFS_SERVER(state->inode);
2005 struct nfs4_opendata *opendata;
2008 opendata = nfs4_open_recoverdata_alloc(ctx, state,
2009 NFS4_OPEN_CLAIM_DELEG_CUR_FH);
2010 if (IS_ERR(opendata))
2011 return PTR_ERR(opendata);
2012 nfs4_stateid_copy(&opendata->o_arg.u.delegation, stateid);
2013 write_seqlock(&state->seqlock);
2014 nfs4_stateid_copy(&state->stateid, &state->open_stateid);
2015 write_sequnlock(&state->seqlock);
2016 clear_bit(NFS_DELEGATED_STATE, &state->flags);
2017 switch (type & (FMODE_READ|FMODE_WRITE)) {
2018 case FMODE_READ|FMODE_WRITE:
2020 err = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE);
2023 err = nfs4_open_recover_helper(opendata, FMODE_WRITE);
2027 err = nfs4_open_recover_helper(opendata, FMODE_READ);
2029 nfs4_opendata_put(opendata);
2030 return nfs4_handle_delegation_recall_error(server, state, stateid, NULL, err);
2033 static void nfs4_open_confirm_prepare(struct rpc_task *task, void *calldata)
2035 struct nfs4_opendata *data = calldata;
2037 nfs40_setup_sequence(data->o_arg.server->nfs_client->cl_slot_tbl,
2038 &data->c_arg.seq_args, &data->c_res.seq_res, task);
2041 static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata)
2043 struct nfs4_opendata *data = calldata;
2045 nfs40_sequence_done(task, &data->c_res.seq_res);
2047 data->rpc_status = task->tk_status;
2048 if (data->rpc_status == 0) {
2049 nfs4_stateid_copy(&data->o_res.stateid, &data->c_res.stateid);
2050 nfs_confirm_seqid(&data->owner->so_seqid, 0);
2051 renew_lease(data->o_res.server, data->timestamp);
2056 static void nfs4_open_confirm_release(void *calldata)
2058 struct nfs4_opendata *data = calldata;
2059 struct nfs4_state *state = NULL;
2061 /* If this request hasn't been cancelled, do nothing */
2062 if (data->cancelled == 0)
2064 /* In case of error, no cleanup! */
2065 if (!data->rpc_done)
2067 state = nfs4_opendata_to_nfs4_state(data);
2069 nfs4_close_state(state, data->o_arg.fmode);
2071 nfs4_opendata_put(data);
2074 static const struct rpc_call_ops nfs4_open_confirm_ops = {
2075 .rpc_call_prepare = nfs4_open_confirm_prepare,
2076 .rpc_call_done = nfs4_open_confirm_done,
2077 .rpc_release = nfs4_open_confirm_release,
2081 * Note: On error, nfs4_proc_open_confirm will free the struct nfs4_opendata
2083 static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)
2085 struct nfs_server *server = NFS_SERVER(d_inode(data->dir));
2086 struct rpc_task *task;
2087 struct rpc_message msg = {
2088 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM],
2089 .rpc_argp = &data->c_arg,
2090 .rpc_resp = &data->c_res,
2091 .rpc_cred = data->owner->so_cred,
2093 struct rpc_task_setup task_setup_data = {
2094 .rpc_client = server->client,
2095 .rpc_message = &msg,
2096 .callback_ops = &nfs4_open_confirm_ops,
2097 .callback_data = data,
2098 .workqueue = nfsiod_workqueue,
2099 .flags = RPC_TASK_ASYNC,
2103 nfs4_init_sequence(&data->c_arg.seq_args, &data->c_res.seq_res, 1);
2104 kref_get(&data->kref);
2106 data->rpc_status = 0;
2107 data->timestamp = jiffies;
2108 if (data->is_recover)
2109 nfs4_set_sequence_privileged(&data->c_arg.seq_args);
2110 task = rpc_run_task(&task_setup_data);
2112 return PTR_ERR(task);
2113 status = nfs4_wait_for_completion_rpc_task(task);
2115 data->cancelled = 1;
2118 status = data->rpc_status;
2123 static void nfs4_open_prepare(struct rpc_task *task, void *calldata)
2125 struct nfs4_opendata *data = calldata;
2126 struct nfs4_state_owner *sp = data->owner;
2127 struct nfs_client *clp = sp->so_server->nfs_client;
2128 enum open_claim_type4 claim = data->o_arg.claim;
2130 if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0)
2133 * Check if we still need to send an OPEN call, or if we can use
2134 * a delegation instead.
2136 if (data->state != NULL) {
2137 struct nfs_delegation *delegation;
2139 if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags))
2142 delegation = nfs4_get_valid_delegation(data->state->inode);
2143 if (can_open_delegated(delegation, data->o_arg.fmode, claim))
2144 goto unlock_no_action;
2147 /* Update client id. */
2148 data->o_arg.clientid = clp->cl_clientid;
2152 case NFS4_OPEN_CLAIM_PREVIOUS:
2153 case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
2154 case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
2155 data->o_arg.open_bitmap = &nfs4_open_noattr_bitmap[0];
2156 case NFS4_OPEN_CLAIM_FH:
2157 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR];
2158 nfs_copy_fh(&data->o_res.fh, data->o_arg.fh);
2160 data->timestamp = jiffies;
2161 if (nfs4_setup_sequence(data->o_arg.server,
2162 &data->o_arg.seq_args,
2163 &data->o_res.seq_res,
2165 nfs_release_seqid(data->o_arg.seqid);
2167 /* Set the create mode (note dependency on the session type) */
2168 data->o_arg.createmode = NFS4_CREATE_UNCHECKED;
2169 if (data->o_arg.open_flags & O_EXCL) {
2170 data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE;
2171 if (nfs4_has_persistent_session(clp))
2172 data->o_arg.createmode = NFS4_CREATE_GUARDED;
2173 else if (clp->cl_mvops->minor_version > 0)
2174 data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE4_1;
2178 trace_nfs4_cached_open(data->state);
2181 task->tk_action = NULL;
2183 nfs4_sequence_done(task, &data->o_res.seq_res);
2186 static void nfs4_open_done(struct rpc_task *task, void *calldata)
2188 struct nfs4_opendata *data = calldata;
2190 data->rpc_status = task->tk_status;
2192 if (!nfs4_sequence_process(task, &data->o_res.seq_res))
2195 if (task->tk_status == 0) {
2196 if (data->o_res.f_attr->valid & NFS_ATTR_FATTR_TYPE) {
2197 switch (data->o_res.f_attr->mode & S_IFMT) {
2201 data->rpc_status = -ELOOP;
2204 data->rpc_status = -EISDIR;
2207 data->rpc_status = -ENOTDIR;
2210 renew_lease(data->o_res.server, data->timestamp);
2211 if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM))
2212 nfs_confirm_seqid(&data->owner->so_seqid, 0);
2217 static void nfs4_open_release(void *calldata)
2219 struct nfs4_opendata *data = calldata;
2220 struct nfs4_state *state = NULL;
2222 /* If this request hasn't been cancelled, do nothing */
2223 if (data->cancelled == 0)
2225 /* In case of error, no cleanup! */
2226 if (data->rpc_status != 0 || !data->rpc_done)
2228 /* In case we need an open_confirm, no cleanup! */
2229 if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)
2231 state = nfs4_opendata_to_nfs4_state(data);
2233 nfs4_close_state(state, data->o_arg.fmode);
2235 nfs4_opendata_put(data);
2238 static const struct rpc_call_ops nfs4_open_ops = {
2239 .rpc_call_prepare = nfs4_open_prepare,
2240 .rpc_call_done = nfs4_open_done,
2241 .rpc_release = nfs4_open_release,
2244 static int nfs4_run_open_task(struct nfs4_opendata *data, int isrecover)
2246 struct inode *dir = d_inode(data->dir);
2247 struct nfs_server *server = NFS_SERVER(dir);
2248 struct nfs_openargs *o_arg = &data->o_arg;
2249 struct nfs_openres *o_res = &data->o_res;
2250 struct rpc_task *task;
2251 struct rpc_message msg = {
2252 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN],
2255 .rpc_cred = data->owner->so_cred,
2257 struct rpc_task_setup task_setup_data = {
2258 .rpc_client = server->client,
2259 .rpc_message = &msg,
2260 .callback_ops = &nfs4_open_ops,
2261 .callback_data = data,
2262 .workqueue = nfsiod_workqueue,
2263 .flags = RPC_TASK_ASYNC,
2267 nfs4_init_sequence(&o_arg->seq_args, &o_res->seq_res, 1);
2268 kref_get(&data->kref);
2270 data->rpc_status = 0;
2271 data->cancelled = 0;
2272 data->is_recover = 0;
2274 nfs4_set_sequence_privileged(&o_arg->seq_args);
2275 data->is_recover = 1;
2277 task = rpc_run_task(&task_setup_data);
2279 return PTR_ERR(task);
2280 status = nfs4_wait_for_completion_rpc_task(task);
2282 data->cancelled = 1;
2285 status = data->rpc_status;
2291 static int _nfs4_recover_proc_open(struct nfs4_opendata *data)
2293 struct inode *dir = d_inode(data->dir);
2294 struct nfs_openres *o_res = &data->o_res;
2297 status = nfs4_run_open_task(data, 1);
2298 if (status != 0 || !data->rpc_done)
2301 nfs_fattr_map_and_free_names(NFS_SERVER(dir), &data->f_attr);
2303 if (o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {
2304 status = _nfs4_proc_open_confirm(data);
2313 * Additional permission checks in order to distinguish between an
2314 * open for read, and an open for execute. This works around the
2315 * fact that NFSv4 OPEN treats read and execute permissions as being
2317 * Note that in the non-execute case, we want to turn off permission
2318 * checking if we just created a new file (POSIX open() semantics).
2320 static int nfs4_opendata_access(struct rpc_cred *cred,
2321 struct nfs4_opendata *opendata,
2322 struct nfs4_state *state, fmode_t fmode,
2325 struct nfs_access_entry cache;
2328 /* access call failed or for some reason the server doesn't
2329 * support any access modes -- defer access call until later */
2330 if (opendata->o_res.access_supported == 0)
2335 * Use openflags to check for exec, because fmode won't
2336 * always have FMODE_EXEC set when file open for exec.
2338 if (openflags & __FMODE_EXEC) {
2339 /* ONLY check for exec rights */
2341 } else if ((fmode & FMODE_READ) && !opendata->file_created)
2345 cache.jiffies = jiffies;
2346 nfs_access_set_mask(&cache, opendata->o_res.access_result);
2347 nfs_access_add_cache(state->inode, &cache);
2349 if ((mask & ~cache.mask & (MAY_READ | MAY_EXEC)) == 0)
2356 * Note: On error, nfs4_proc_open will free the struct nfs4_opendata
2358 static int _nfs4_proc_open(struct nfs4_opendata *data)
2360 struct inode *dir = d_inode(data->dir);
2361 struct nfs_server *server = NFS_SERVER(dir);
2362 struct nfs_openargs *o_arg = &data->o_arg;
2363 struct nfs_openres *o_res = &data->o_res;
2366 status = nfs4_run_open_task(data, 0);
2367 if (!data->rpc_done)
2370 if (status == -NFS4ERR_BADNAME &&
2371 !(o_arg->open_flags & O_CREAT))
2376 nfs_fattr_map_and_free_names(server, &data->f_attr);
2378 if (o_arg->open_flags & O_CREAT) {
2379 update_changeattr(dir, &o_res->cinfo);
2380 if (o_arg->open_flags & O_EXCL)
2381 data->file_created = 1;
2382 else if (o_res->cinfo.before != o_res->cinfo.after)
2383 data->file_created = 1;
2385 if ((o_res->rflags & NFS4_OPEN_RESULT_LOCKTYPE_POSIX) == 0)
2386 server->caps &= ~NFS_CAP_POSIX_LOCK;
2387 if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {
2388 status = _nfs4_proc_open_confirm(data);
2392 if (!(o_res->f_attr->valid & NFS_ATTR_FATTR)) {
2393 nfs4_sequence_free_slot(&o_res->seq_res);
2394 nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr, o_res->f_label);
2399 static int nfs4_recover_expired_lease(struct nfs_server *server)
2401 return nfs4_client_recover_expired_lease(server->nfs_client);
2406 * reclaim state on the server after a network partition.
2407 * Assumes caller holds the appropriate lock
2409 static int _nfs4_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
2411 struct nfs4_opendata *opendata;
2414 opendata = nfs4_open_recoverdata_alloc(ctx, state,
2415 NFS4_OPEN_CLAIM_FH);
2416 if (IS_ERR(opendata))
2417 return PTR_ERR(opendata);
2418 ret = nfs4_open_recover(opendata, state);
2420 d_drop(ctx->dentry);
2421 nfs4_opendata_put(opendata);
2425 static int nfs4_do_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
2427 struct nfs_server *server = NFS_SERVER(state->inode);
2428 struct nfs4_exception exception = { };
2432 err = _nfs4_open_expired(ctx, state);
2433 trace_nfs4_open_expired(ctx, 0, err);
2434 if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))
2439 case -NFS4ERR_GRACE:
2440 case -NFS4ERR_DELAY:
2441 nfs4_handle_exception(server, err, &exception);
2444 } while (exception.retry);
2449 static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
2451 struct nfs_open_context *ctx;
2454 ctx = nfs4_state_find_open_context(state);
2457 ret = nfs4_do_open_expired(ctx, state);
2458 put_nfs_open_context(ctx);
2462 static void nfs_finish_clear_delegation_stateid(struct nfs4_state *state,
2463 const nfs4_stateid *stateid)
2465 nfs_remove_bad_delegation(state->inode, stateid);
2466 write_seqlock(&state->seqlock);
2467 nfs4_stateid_copy(&state->stateid, &state->open_stateid);
2468 write_sequnlock(&state->seqlock);
2469 clear_bit(NFS_DELEGATED_STATE, &state->flags);
2472 static void nfs40_clear_delegation_stateid(struct nfs4_state *state)
2474 if (rcu_access_pointer(NFS_I(state->inode)->delegation) != NULL)
2475 nfs_finish_clear_delegation_stateid(state, NULL);
2478 static int nfs40_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
2480 /* NFSv4.0 doesn't allow for delegation recovery on open expire */
2481 nfs40_clear_delegation_stateid(state);
2482 return nfs4_open_expired(sp, state);
2485 static int nfs40_test_and_free_expired_stateid(struct nfs_server *server,
2486 nfs4_stateid *stateid,
2487 struct rpc_cred *cred)
2489 return -NFS4ERR_BAD_STATEID;
2492 #if defined(CONFIG_NFS_V4_1)
2493 static int nfs41_test_and_free_expired_stateid(struct nfs_server *server,
2494 nfs4_stateid *stateid,
2495 struct rpc_cred *cred)
2499 switch (stateid->type) {
2502 case NFS4_INVALID_STATEID_TYPE:
2503 case NFS4_SPECIAL_STATEID_TYPE:
2504 return -NFS4ERR_BAD_STATEID;
2505 case NFS4_REVOKED_STATEID_TYPE:
2509 status = nfs41_test_stateid(server, stateid, cred);
2511 case -NFS4ERR_EXPIRED:
2512 case -NFS4ERR_ADMIN_REVOKED:
2513 case -NFS4ERR_DELEG_REVOKED:
2519 /* Ack the revoked state to the server */
2520 nfs41_free_stateid(server, stateid, cred, true);
2521 return -NFS4ERR_EXPIRED;
2524 static void nfs41_check_delegation_stateid(struct nfs4_state *state)
2526 struct nfs_server *server = NFS_SERVER(state->inode);
2527 nfs4_stateid stateid;
2528 struct nfs_delegation *delegation;
2529 struct rpc_cred *cred;
2532 /* Get the delegation credential for use by test/free_stateid */
2534 delegation = rcu_dereference(NFS_I(state->inode)->delegation);
2535 if (delegation == NULL) {
2540 nfs4_stateid_copy(&stateid, &delegation->stateid);
2541 if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
2543 nfs_finish_clear_delegation_stateid(state, &stateid);
2547 if (!test_and_clear_bit(NFS_DELEGATION_TEST_EXPIRED,
2548 &delegation->flags)) {
2553 cred = get_rpccred(delegation->cred);
2555 status = nfs41_test_and_free_expired_stateid(server, &stateid, cred);
2556 trace_nfs4_test_delegation_stateid(state, NULL, status);
2557 if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID)
2558 nfs_finish_clear_delegation_stateid(state, &stateid);
2564 * nfs41_check_expired_locks - possibly free a lock stateid
2566 * @state: NFSv4 state for an inode
2568 * Returns NFS_OK if recovery for this stateid is now finished.
2569 * Otherwise a negative NFS4ERR value is returned.
2571 static int nfs41_check_expired_locks(struct nfs4_state *state)
2573 int status, ret = NFS_OK;
2574 struct nfs4_lock_state *lsp, *prev = NULL;
2575 struct nfs_server *server = NFS_SERVER(state->inode);
2577 if (!test_bit(LK_STATE_IN_USE, &state->flags))
2580 spin_lock(&state->state_lock);
2581 list_for_each_entry(lsp, &state->lock_states, ls_locks) {
2582 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) {
2583 struct rpc_cred *cred = lsp->ls_state->owner->so_cred;
2585 atomic_inc(&lsp->ls_count);
2586 spin_unlock(&state->state_lock);
2588 nfs4_put_lock_state(prev);
2591 status = nfs41_test_and_free_expired_stateid(server,
2594 trace_nfs4_test_lock_stateid(state, lsp, status);
2595 if (status == -NFS4ERR_EXPIRED ||
2596 status == -NFS4ERR_BAD_STATEID) {
2597 clear_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags);
2598 lsp->ls_stateid.type = NFS4_INVALID_STATEID_TYPE;
2599 if (!recover_lost_locks)
2600 set_bit(NFS_LOCK_LOST, &lsp->ls_flags);
2601 } else if (status != NFS_OK) {
2603 nfs4_put_lock_state(prev);
2606 spin_lock(&state->state_lock);
2609 spin_unlock(&state->state_lock);
2610 nfs4_put_lock_state(prev);
2616 * nfs41_check_open_stateid - possibly free an open stateid
2618 * @state: NFSv4 state for an inode
2620 * Returns NFS_OK if recovery for this stateid is now finished.
2621 * Otherwise a negative NFS4ERR value is returned.
2623 static int nfs41_check_open_stateid(struct nfs4_state *state)
2625 struct nfs_server *server = NFS_SERVER(state->inode);
2626 nfs4_stateid *stateid = &state->open_stateid;
2627 struct rpc_cred *cred = state->owner->so_cred;
2630 if (test_bit(NFS_OPEN_STATE, &state->flags) == 0) {
2631 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) {
2632 if (nfs4_have_delegation(state->inode, state->state))
2634 return -NFS4ERR_OPENMODE;
2636 return -NFS4ERR_BAD_STATEID;
2638 status = nfs41_test_and_free_expired_stateid(server, stateid, cred);
2639 trace_nfs4_test_open_stateid(state, NULL, status);
2640 if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID) {
2641 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
2642 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
2643 clear_bit(NFS_O_RDWR_STATE, &state->flags);
2644 clear_bit(NFS_OPEN_STATE, &state->flags);
2645 stateid->type = NFS4_INVALID_STATEID_TYPE;
2647 if (status != NFS_OK)
2649 if (nfs_open_stateid_recover_openmode(state))
2650 return -NFS4ERR_OPENMODE;
2654 static int nfs41_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
2658 nfs41_check_delegation_stateid(state);
2659 status = nfs41_check_expired_locks(state);
2660 if (status != NFS_OK)
2662 status = nfs41_check_open_stateid(state);
2663 if (status != NFS_OK)
2664 status = nfs4_open_expired(sp, state);
2670 * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-*
2671 * fields corresponding to attributes that were used to store the verifier.
2672 * Make sure we clobber those fields in the later setattr call
2674 static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata,
2675 struct iattr *sattr, struct nfs4_label **label)
2677 const u32 *attrset = opendata->o_res.attrset;
2679 if ((attrset[1] & FATTR4_WORD1_TIME_ACCESS) &&
2680 !(sattr->ia_valid & ATTR_ATIME_SET))
2681 sattr->ia_valid |= ATTR_ATIME;
2683 if ((attrset[1] & FATTR4_WORD1_TIME_MODIFY) &&
2684 !(sattr->ia_valid & ATTR_MTIME_SET))
2685 sattr->ia_valid |= ATTR_MTIME;
2687 /* Except MODE, it seems harmless of setting twice. */
2688 if (opendata->o_arg.createmode != NFS4_CREATE_EXCLUSIVE &&
2689 attrset[1] & FATTR4_WORD1_MODE)
2690 sattr->ia_valid &= ~ATTR_MODE;
2692 if (attrset[2] & FATTR4_WORD2_SECURITY_LABEL)
2696 static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata,
2699 struct nfs_open_context *ctx)
2701 struct nfs4_state_owner *sp = opendata->owner;
2702 struct nfs_server *server = sp->so_server;
2703 struct dentry *dentry;
2704 struct nfs4_state *state;
2708 seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
2710 ret = _nfs4_proc_open(opendata);
2714 state = _nfs4_opendata_to_nfs4_state(opendata);
2715 ret = PTR_ERR(state);
2719 if (server->caps & NFS_CAP_POSIX_LOCK)
2720 set_bit(NFS_STATE_POSIX_LOCKS, &state->flags);
2721 if (opendata->o_res.rflags & NFS4_OPEN_RESULT_MAY_NOTIFY_LOCK)
2722 set_bit(NFS_STATE_MAY_NOTIFY_LOCK, &state->flags);
2724 dentry = opendata->dentry;
2725 if (d_really_is_negative(dentry)) {
2726 struct dentry *alias;
2728 alias = d_exact_alias(dentry, state->inode);
2730 alias = d_splice_alias(igrab(state->inode), dentry);
2731 /* d_splice_alias() can't fail here - it's a non-directory */
2734 ctx->dentry = dentry = alias;
2736 nfs_set_verifier(dentry,
2737 nfs_save_change_attribute(d_inode(opendata->dir)));
2740 ret = nfs4_opendata_access(sp->so_cred, opendata, state, fmode, flags);
2744 if (d_inode(dentry) == state->inode) {
2745 nfs_inode_attach_open_context(ctx);
2746 if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
2747 nfs4_schedule_stateid_recovery(server, state);
2750 if (!opendata->cancelled)
2751 nfs4_sequence_free_slot(&opendata->o_res.seq_res);
2756 * Returns a referenced nfs4_state
2758 static int _nfs4_do_open(struct inode *dir,
2759 struct nfs_open_context *ctx,
2761 const struct nfs4_open_createattrs *c,
2764 struct nfs4_state_owner *sp;
2765 struct nfs4_state *state = NULL;
2766 struct nfs_server *server = NFS_SERVER(dir);
2767 struct nfs4_opendata *opendata;
2768 struct dentry *dentry = ctx->dentry;
2769 struct rpc_cred *cred = ctx->cred;
2770 struct nfs4_threshold **ctx_th = &ctx->mdsthreshold;
2771 fmode_t fmode = ctx->mode & (FMODE_READ|FMODE_WRITE|FMODE_EXEC);
2772 enum open_claim_type4 claim = NFS4_OPEN_CLAIM_NULL;
2773 struct iattr *sattr = c->sattr;
2774 struct nfs4_label *label = c->label;
2775 struct nfs4_label *olabel = NULL;
2778 /* Protect against reboot recovery conflicts */
2780 sp = nfs4_get_state_owner(server, cred, GFP_KERNEL);
2782 dprintk("nfs4_do_open: nfs4_get_state_owner failed!\n");
2785 status = nfs4_recover_expired_lease(server);
2787 goto err_put_state_owner;
2788 if (d_really_is_positive(dentry))
2789 nfs4_return_incompatible_delegation(d_inode(dentry), fmode);
2791 if (d_really_is_positive(dentry))
2792 claim = NFS4_OPEN_CLAIM_FH;
2793 opendata = nfs4_opendata_alloc(dentry, sp, fmode, flags,
2794 c, claim, GFP_KERNEL);
2795 if (opendata == NULL)
2796 goto err_put_state_owner;
2799 olabel = nfs4_label_alloc(server, GFP_KERNEL);
2800 if (IS_ERR(olabel)) {
2801 status = PTR_ERR(olabel);
2802 goto err_opendata_put;
2806 if (server->attr_bitmask[2] & FATTR4_WORD2_MDSTHRESHOLD) {
2807 if (!opendata->f_attr.mdsthreshold) {
2808 opendata->f_attr.mdsthreshold = pnfs_mdsthreshold_alloc();
2809 if (!opendata->f_attr.mdsthreshold)
2810 goto err_free_label;
2812 opendata->o_arg.open_bitmap = &nfs4_pnfs_open_bitmap[0];
2814 if (d_really_is_positive(dentry))
2815 opendata->state = nfs4_get_open_state(d_inode(dentry), sp);
2817 status = _nfs4_open_and_get_state(opendata, fmode, flags, ctx);
2819 goto err_free_label;
2822 if ((opendata->o_arg.open_flags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL) &&
2823 (opendata->o_arg.createmode != NFS4_CREATE_GUARDED)) {
2824 nfs4_exclusive_attrset(opendata, sattr, &label);
2826 * send create attributes which was not set by open
2827 * with an extra setattr.
2829 if (sattr->ia_valid & NFS4_VALID_ATTRS) {
2830 nfs_fattr_init(opendata->o_res.f_attr);
2831 status = nfs4_do_setattr(state->inode, cred,
2832 opendata->o_res.f_attr, sattr,
2833 state, label, olabel);
2835 nfs_setattr_update_inode(state->inode, sattr,
2836 opendata->o_res.f_attr);
2837 nfs_setsecurity(state->inode, opendata->o_res.f_attr, olabel);
2841 if (opened && opendata->file_created)
2842 *opened |= FILE_CREATED;
2844 if (pnfs_use_threshold(ctx_th, opendata->f_attr.mdsthreshold, server)) {
2845 *ctx_th = opendata->f_attr.mdsthreshold;
2846 opendata->f_attr.mdsthreshold = NULL;
2849 nfs4_label_free(olabel);
2851 nfs4_opendata_put(opendata);
2852 nfs4_put_state_owner(sp);
2855 nfs4_label_free(olabel);
2857 nfs4_opendata_put(opendata);
2858 err_put_state_owner:
2859 nfs4_put_state_owner(sp);
2865 static struct nfs4_state *nfs4_do_open(struct inode *dir,
2866 struct nfs_open_context *ctx,
2868 struct iattr *sattr,
2869 struct nfs4_label *label,
2872 struct nfs_server *server = NFS_SERVER(dir);
2873 struct nfs4_exception exception = { };
2874 struct nfs4_state *res;
2875 struct nfs4_open_createattrs c = {
2879 [0] = (__u32)jiffies,
2880 [1] = (__u32)current->pid,
2886 status = _nfs4_do_open(dir, ctx, flags, &c, opened);
2888 trace_nfs4_open_file(ctx, flags, status);
2891 /* NOTE: BAD_SEQID means the server and client disagree about the
2892 * book-keeping w.r.t. state-changing operations
2893 * (OPEN/CLOSE/LOCK/LOCKU...)
2894 * It is actually a sign of a bug on the client or on the server.
2896 * If we receive a BAD_SEQID error in the particular case of
2897 * doing an OPEN, we assume that nfs_increment_open_seqid() will
2898 * have unhashed the old state_owner for us, and that we can
2899 * therefore safely retry using a new one. We should still warn
2900 * the user though...
2902 if (status == -NFS4ERR_BAD_SEQID) {
2903 pr_warn_ratelimited("NFS: v4 server %s "
2904 " returned a bad sequence-id error!\n",
2905 NFS_SERVER(dir)->nfs_client->cl_hostname);
2906 exception.retry = 1;
2910 * BAD_STATEID on OPEN means that the server cancelled our
2911 * state before it received the OPEN_CONFIRM.
2912 * Recover by retrying the request as per the discussion
2913 * on Page 181 of RFC3530.
2915 if (status == -NFS4ERR_BAD_STATEID) {
2916 exception.retry = 1;
2919 if (status == -NFS4ERR_EXPIRED) {
2920 nfs4_schedule_lease_recovery(server->nfs_client);
2921 exception.retry = 1;
2924 if (status == -EAGAIN) {
2925 /* We must have found a delegation */
2926 exception.retry = 1;
2929 if (nfs4_clear_cap_atomic_open_v1(server, status, &exception))
2931 res = ERR_PTR(nfs4_handle_exception(server,
2932 status, &exception));
2933 } while (exception.retry);
2937 static int _nfs4_do_setattr(struct inode *inode,
2938 struct nfs_setattrargs *arg,
2939 struct nfs_setattrres *res,
2940 struct rpc_cred *cred,
2941 struct nfs4_state *state)
2943 struct nfs_server *server = NFS_SERVER(inode);
2944 struct rpc_message msg = {
2945 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
2950 struct rpc_cred *delegation_cred = NULL;
2951 unsigned long timestamp = jiffies;
2956 nfs_fattr_init(res->fattr);
2958 /* Servers should only apply open mode checks for file size changes */
2959 truncate = (arg->iap->ia_valid & ATTR_SIZE) ? true : false;
2960 fmode = truncate ? FMODE_WRITE : FMODE_READ;
2962 if (nfs4_copy_delegation_stateid(inode, fmode, &arg->stateid, &delegation_cred)) {
2963 /* Use that stateid */
2964 } else if (truncate && state != NULL) {
2965 struct nfs_lockowner lockowner = {
2966 .l_owner = current->files,
2967 .l_pid = current->tgid,
2969 if (!nfs4_valid_open_stateid(state))
2971 if (nfs4_select_rw_stateid(state, FMODE_WRITE, &lockowner,
2972 &arg->stateid, &delegation_cred) == -EIO)
2975 nfs4_stateid_copy(&arg->stateid, &zero_stateid);
2976 if (delegation_cred)
2977 msg.rpc_cred = delegation_cred;
2979 status = nfs4_call_sync(server->client, server, &msg, &arg->seq_args, &res->seq_res, 1);
2981 put_rpccred(delegation_cred);
2982 if (status == 0 && state != NULL)
2983 renew_lease(server, timestamp);
2984 trace_nfs4_setattr(inode, &arg->stateid, status);
2988 static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
2989 struct nfs_fattr *fattr, struct iattr *sattr,
2990 struct nfs4_state *state, struct nfs4_label *ilabel,
2991 struct nfs4_label *olabel)
2993 struct nfs_server *server = NFS_SERVER(inode);
2994 struct nfs_setattrargs arg = {
2995 .fh = NFS_FH(inode),
2998 .bitmask = server->attr_bitmask,
3001 struct nfs_setattrres res = {
3006 struct nfs4_exception exception = {
3009 .stateid = &arg.stateid,
3013 arg.bitmask = nfs4_bitmask(server, ilabel);
3015 arg.bitmask = nfs4_bitmask(server, olabel);
3018 err = _nfs4_do_setattr(inode, &arg, &res, cred, state);
3020 case -NFS4ERR_OPENMODE:
3021 if (!(sattr->ia_valid & ATTR_SIZE)) {
3022 pr_warn_once("NFSv4: server %s is incorrectly "
3023 "applying open mode checks to "
3024 "a SETATTR that is not "
3025 "changing file size.\n",
3026 server->nfs_client->cl_hostname);
3028 if (state && !(state->state & FMODE_WRITE)) {
3030 if (sattr->ia_valid & ATTR_OPEN)
3035 err = nfs4_handle_exception(server, err, &exception);
3036 } while (exception.retry);
3042 nfs4_wait_on_layoutreturn(struct inode *inode, struct rpc_task *task)
3044 if (inode == NULL || !nfs_have_layout(inode))
3047 return pnfs_wait_on_layoutreturn(inode, task);
3050 struct nfs4_closedata {
3051 struct inode *inode;
3052 struct nfs4_state *state;
3053 struct nfs_closeargs arg;
3054 struct nfs_closeres res;
3055 struct nfs_fattr fattr;
3056 unsigned long timestamp;
3061 static void nfs4_free_closedata(void *data)
3063 struct nfs4_closedata *calldata = data;
3064 struct nfs4_state_owner *sp = calldata->state->owner;
3065 struct super_block *sb = calldata->state->inode->i_sb;
3068 pnfs_roc_release(calldata->state->inode);
3069 nfs4_put_open_state(calldata->state);
3070 nfs_free_seqid(calldata->arg.seqid);
3071 nfs4_put_state_owner(sp);
3072 nfs_sb_deactive(sb);
3076 static void nfs4_close_done(struct rpc_task *task, void *data)
3078 struct nfs4_closedata *calldata = data;
3079 struct nfs4_state *state = calldata->state;
3080 struct nfs_server *server = NFS_SERVER(calldata->inode);
3081 nfs4_stateid *res_stateid = NULL;
3083 dprintk("%s: begin!\n", __func__);
3084 if (!nfs4_sequence_done(task, &calldata->res.seq_res))
3086 trace_nfs4_close(state, &calldata->arg, &calldata->res, task->tk_status);
3087 /* hmm. we are done with the inode, and in the process of freeing
3088 * the state_owner. we keep this around to process errors
3090 switch (task->tk_status) {
3092 res_stateid = &calldata->res.stateid;
3094 pnfs_roc_set_barrier(state->inode,
3095 calldata->roc_barrier);
3096 renew_lease(server, calldata->timestamp);
3098 case -NFS4ERR_ADMIN_REVOKED:
3099 case -NFS4ERR_STALE_STATEID:
3100 case -NFS4ERR_EXPIRED:
3101 nfs4_free_revoked_stateid(server,
3102 &calldata->arg.stateid,
3103 task->tk_msg.rpc_cred);
3104 case -NFS4ERR_OLD_STATEID:
3105 case -NFS4ERR_BAD_STATEID:
3106 if (!nfs4_stateid_match(&calldata->arg.stateid,
3107 &state->open_stateid)) {
3108 rpc_restart_call_prepare(task);
3111 if (calldata->arg.fmode == 0)
3114 if (nfs4_async_handle_error(task, server, state, NULL) == -EAGAIN) {
3115 rpc_restart_call_prepare(task);
3119 nfs_clear_open_stateid(state, &calldata->arg.stateid,
3120 res_stateid, calldata->arg.fmode);
3122 nfs_release_seqid(calldata->arg.seqid);
3123 nfs_refresh_inode(calldata->inode, calldata->res.fattr);
3124 dprintk("%s: done, ret = %d!\n", __func__, task->tk_status);
3127 static void nfs4_close_prepare(struct rpc_task *task, void *data)
3129 struct nfs4_closedata *calldata = data;
3130 struct nfs4_state *state = calldata->state;
3131 struct inode *inode = calldata->inode;
3132 bool is_rdonly, is_wronly, is_rdwr;
3135 dprintk("%s: begin!\n", __func__);
3136 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
3139 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE];
3140 spin_lock(&state->owner->so_lock);
3141 is_rdwr = test_bit(NFS_O_RDWR_STATE, &state->flags);
3142 is_rdonly = test_bit(NFS_O_RDONLY_STATE, &state->flags);
3143 is_wronly = test_bit(NFS_O_WRONLY_STATE, &state->flags);
3144 nfs4_stateid_copy(&calldata->arg.stateid, &state->open_stateid);
3145 /* Calculate the change in open mode */
3146 calldata->arg.fmode = 0;
3147 if (state->n_rdwr == 0) {
3148 if (state->n_rdonly == 0)
3149 call_close |= is_rdonly;
3151 calldata->arg.fmode |= FMODE_READ;
3152 if (state->n_wronly == 0)
3153 call_close |= is_wronly;
3155 calldata->arg.fmode |= FMODE_WRITE;
3156 if (calldata->arg.fmode != (FMODE_READ|FMODE_WRITE))
3157 call_close |= is_rdwr;
3159 calldata->arg.fmode |= FMODE_READ|FMODE_WRITE;
3161 if (!nfs4_valid_open_stateid(state) ||
3162 test_bit(NFS_OPEN_STATE, &state->flags) == 0)
3164 spin_unlock(&state->owner->so_lock);
3167 /* Note: exit _without_ calling nfs4_close_done */
3171 if (nfs4_wait_on_layoutreturn(inode, task)) {
3172 nfs_release_seqid(calldata->arg.seqid);
3176 if (calldata->arg.fmode == 0)
3177 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE];
3179 pnfs_roc_get_barrier(inode, &calldata->roc_barrier);
3181 calldata->arg.share_access =
3182 nfs4_map_atomic_open_share(NFS_SERVER(inode),
3183 calldata->arg.fmode, 0);
3185 nfs_fattr_init(calldata->res.fattr);
3186 calldata->timestamp = jiffies;
3187 if (nfs4_setup_sequence(NFS_SERVER(inode),
3188 &calldata->arg.seq_args,
3189 &calldata->res.seq_res,
3191 nfs_release_seqid(calldata->arg.seqid);
3192 dprintk("%s: done!\n", __func__);
3195 task->tk_action = NULL;
3197 nfs4_sequence_done(task, &calldata->res.seq_res);
3200 static const struct rpc_call_ops nfs4_close_ops = {
3201 .rpc_call_prepare = nfs4_close_prepare,
3202 .rpc_call_done = nfs4_close_done,
3203 .rpc_release = nfs4_free_closedata,
3206 static bool nfs4_roc(struct inode *inode)
3208 if (!nfs_have_layout(inode))
3210 return pnfs_roc(inode);
3214 * It is possible for data to be read/written from a mem-mapped file
3215 * after the sys_close call (which hits the vfs layer as a flush).
3216 * This means that we can't safely call nfsv4 close on a file until
3217 * the inode is cleared. This in turn means that we are not good
3218 * NFSv4 citizens - we do not indicate to the server to update the file's
3219 * share state even when we are done with one of the three share
3220 * stateid's in the inode.
3222 * NOTE: Caller must be holding the sp->so_owner semaphore!
3224 int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait)
3226 struct nfs_server *server = NFS_SERVER(state->inode);
3227 struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
3228 struct nfs4_closedata *calldata;
3229 struct nfs4_state_owner *sp = state->owner;
3230 struct rpc_task *task;
3231 struct rpc_message msg = {
3232 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE],
3233 .rpc_cred = state->owner->so_cred,
3235 struct rpc_task_setup task_setup_data = {
3236 .rpc_client = server->client,
3237 .rpc_message = &msg,
3238 .callback_ops = &nfs4_close_ops,
3239 .workqueue = nfsiod_workqueue,
3240 .flags = RPC_TASK_ASYNC,
3242 int status = -ENOMEM;
3244 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_CLEANUP,
3245 &task_setup_data.rpc_client, &msg);
3247 calldata = kzalloc(sizeof(*calldata), gfp_mask);
3248 if (calldata == NULL)
3250 nfs4_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 1);
3251 calldata->inode = state->inode;
3252 calldata->state = state;
3253 calldata->arg.fh = NFS_FH(state->inode);
3254 /* Serialization for the sequence id */
3255 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;
3256 calldata->arg.seqid = alloc_seqid(&state->owner->so_seqid, gfp_mask);
3257 if (IS_ERR(calldata->arg.seqid))
3258 goto out_free_calldata;
3259 calldata->arg.fmode = 0;
3260 calldata->arg.bitmask = server->cache_consistency_bitmask;
3261 calldata->res.fattr = &calldata->fattr;
3262 calldata->res.seqid = calldata->arg.seqid;
3263 calldata->res.server = server;
3264 calldata->roc = nfs4_roc(state->inode);
3265 nfs_sb_active(calldata->inode->i_sb);
3267 msg.rpc_argp = &calldata->arg;
3268 msg.rpc_resp = &calldata->res;
3269 task_setup_data.callback_data = calldata;
3270 task = rpc_run_task(&task_setup_data);
3272 return PTR_ERR(task);
3275 status = rpc_wait_for_completion_task(task);
3281 nfs4_put_open_state(state);
3282 nfs4_put_state_owner(sp);
3286 static struct inode *
3287 nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx,
3288 int open_flags, struct iattr *attr, int *opened)
3290 struct nfs4_state *state;
3291 struct nfs4_label l = {0, 0, 0, NULL}, *label = NULL;
3293 label = nfs4_label_init_security(dir, ctx->dentry, attr, &l);
3295 /* Protect against concurrent sillydeletes */
3296 state = nfs4_do_open(dir, ctx, open_flags, attr, label, opened);
3298 nfs4_label_release_security(label);
3301 return ERR_CAST(state);
3302 return state->inode;
3305 static void nfs4_close_context(struct nfs_open_context *ctx, int is_sync)
3307 if (ctx->state == NULL)
3310 nfs4_close_sync(ctx->state, ctx->mode);
3312 nfs4_close_state(ctx->state, ctx->mode);
3315 #define FATTR4_WORD1_NFS40_MASK (2*FATTR4_WORD1_MOUNTED_ON_FILEID - 1UL)
3316 #define FATTR4_WORD2_NFS41_MASK (2*FATTR4_WORD2_SUPPATTR_EXCLCREAT - 1UL)
3317 #define FATTR4_WORD2_NFS42_MASK (2*FATTR4_WORD2_SECURITY_LABEL - 1UL)
3319 static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
3321 u32 bitmask[3] = {}, minorversion = server->nfs_client->cl_minorversion;
3322 struct nfs4_server_caps_arg args = {
3326 struct nfs4_server_caps_res res = {};
3327 struct rpc_message msg = {
3328 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SERVER_CAPS],
3335 bitmask[0] = FATTR4_WORD0_SUPPORTED_ATTRS |
3336 FATTR4_WORD0_FH_EXPIRE_TYPE |
3337 FATTR4_WORD0_LINK_SUPPORT |
3338 FATTR4_WORD0_SYMLINK_SUPPORT |
3339 FATTR4_WORD0_ACLSUPPORT;
3341 bitmask[2] = FATTR4_WORD2_SUPPATTR_EXCLCREAT;
3343 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3345 /* Sanity check the server answers */
3346 switch (minorversion) {
3348 res.attr_bitmask[1] &= FATTR4_WORD1_NFS40_MASK;
3349 res.attr_bitmask[2] = 0;
3352 res.attr_bitmask[2] &= FATTR4_WORD2_NFS41_MASK;
3355 res.attr_bitmask[2] &= FATTR4_WORD2_NFS42_MASK;
3357 memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask));
3358 server->caps &= ~(NFS_CAP_ACLS|NFS_CAP_HARDLINKS|
3359 NFS_CAP_SYMLINKS|NFS_CAP_FILEID|
3360 NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER|
3361 NFS_CAP_OWNER_GROUP|NFS_CAP_ATIME|
3362 NFS_CAP_CTIME|NFS_CAP_MTIME|
3363 NFS_CAP_SECURITY_LABEL);
3364 if (res.attr_bitmask[0] & FATTR4_WORD0_ACL &&
3365 res.acl_bitmask & ACL4_SUPPORT_ALLOW_ACL)
3366 server->caps |= NFS_CAP_ACLS;
3367 if (res.has_links != 0)
3368 server->caps |= NFS_CAP_HARDLINKS;
3369 if (res.has_symlinks != 0)
3370 server->caps |= NFS_CAP_SYMLINKS;
3371 if (res.attr_bitmask[0] & FATTR4_WORD0_FILEID)
3372 server->caps |= NFS_CAP_FILEID;
3373 if (res.attr_bitmask[1] & FATTR4_WORD1_MODE)
3374 server->caps |= NFS_CAP_MODE;
3375 if (res.attr_bitmask[1] & FATTR4_WORD1_NUMLINKS)
3376 server->caps |= NFS_CAP_NLINK;
3377 if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER)
3378 server->caps |= NFS_CAP_OWNER;
3379 if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER_GROUP)
3380 server->caps |= NFS_CAP_OWNER_GROUP;
3381 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_ACCESS)
3382 server->caps |= NFS_CAP_ATIME;
3383 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_METADATA)
3384 server->caps |= NFS_CAP_CTIME;
3385 if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY)
3386 server->caps |= NFS_CAP_MTIME;
3387 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
3388 if (res.attr_bitmask[2] & FATTR4_WORD2_SECURITY_LABEL)
3389 server->caps |= NFS_CAP_SECURITY_LABEL;
3391 memcpy(server->attr_bitmask_nl, res.attr_bitmask,
3392 sizeof(server->attr_bitmask));
3393 server->attr_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
3395 memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask));
3396 server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE;
3397 server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY;
3398 server->cache_consistency_bitmask[2] = 0;
3400 /* Avoid a regression due to buggy server */
3401 for (i = 0; i < ARRAY_SIZE(res.exclcreat_bitmask); i++)
3402 res.exclcreat_bitmask[i] &= res.attr_bitmask[i];
3403 memcpy(server->exclcreat_bitmask, res.exclcreat_bitmask,
3404 sizeof(server->exclcreat_bitmask));
3406 server->acl_bitmask = res.acl_bitmask;
3407 server->fh_expire_type = res.fh_expire_type;
3413 int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
3415 struct nfs4_exception exception = { };
3418 err = nfs4_handle_exception(server,
3419 _nfs4_server_capabilities(server, fhandle),
3421 } while (exception.retry);
3425 static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
3426 struct nfs_fsinfo *info)
3429 struct nfs4_lookup_root_arg args = {
3432 struct nfs4_lookup_res res = {
3434 .fattr = info->fattr,
3437 struct rpc_message msg = {
3438 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP_ROOT],
3443 bitmask[0] = nfs4_fattr_bitmap[0];
3444 bitmask[1] = nfs4_fattr_bitmap[1];
3446 * Process the label in the upcoming getfattr
3448 bitmask[2] = nfs4_fattr_bitmap[2] & ~FATTR4_WORD2_SECURITY_LABEL;
3450 nfs_fattr_init(info->fattr);
3451 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3454 static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
3455 struct nfs_fsinfo *info)
3457 struct nfs4_exception exception = { };
3460 err = _nfs4_lookup_root(server, fhandle, info);
3461 trace_nfs4_lookup_root(server, fhandle, info->fattr, err);
3464 case -NFS4ERR_WRONGSEC:
3467 err = nfs4_handle_exception(server, err, &exception);
3469 } while (exception.retry);
3474 static int nfs4_lookup_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
3475 struct nfs_fsinfo *info, rpc_authflavor_t flavor)
3477 struct rpc_auth_create_args auth_args = {
3478 .pseudoflavor = flavor,
3480 struct rpc_auth *auth;
3483 auth = rpcauth_create(&auth_args, server->client);
3488 ret = nfs4_lookup_root(server, fhandle, info);
3494 * Retry pseudoroot lookup with various security flavors. We do this when:
3496 * NFSv4.0: the PUTROOTFH operation returns NFS4ERR_WRONGSEC
3497 * NFSv4.1: the server does not support the SECINFO_NO_NAME operation
3499 * Returns zero on success, or a negative NFS4ERR value, or a
3500 * negative errno value.
3502 static int nfs4_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
3503 struct nfs_fsinfo *info)
3505 /* Per 3530bis 15.33.5 */
3506 static const rpc_authflavor_t flav_array[] = {
3510 RPC_AUTH_UNIX, /* courtesy */
3513 int status = -EPERM;
3516 if (server->auth_info.flavor_len > 0) {
3517 /* try each flavor specified by user */
3518 for (i = 0; i < server->auth_info.flavor_len; i++) {
3519 status = nfs4_lookup_root_sec(server, fhandle, info,
3520 server->auth_info.flavors[i]);
3521 if (status == -NFS4ERR_WRONGSEC || status == -EACCES)
3526 /* no flavors specified by user, try default list */
3527 for (i = 0; i < ARRAY_SIZE(flav_array); i++) {
3528 status = nfs4_lookup_root_sec(server, fhandle, info,
3530 if (status == -NFS4ERR_WRONGSEC || status == -EACCES)
3537 * -EACCESS could mean that the user doesn't have correct permissions
3538 * to access the mount. It could also mean that we tried to mount
3539 * with a gss auth flavor, but rpc.gssd isn't running. Either way,
3540 * existing mount programs don't handle -EACCES very well so it should
3541 * be mapped to -EPERM instead.
3543 if (status == -EACCES)
3549 * nfs4_proc_get_rootfh - get file handle for server's pseudoroot
3550 * @server: initialized nfs_server handle
3551 * @fhandle: we fill in the pseudo-fs root file handle
3552 * @info: we fill in an FSINFO struct
3553 * @auth_probe: probe the auth flavours
3555 * Returns zero on success, or a negative errno.
3557 int nfs4_proc_get_rootfh(struct nfs_server *server, struct nfs_fh *fhandle,
3558 struct nfs_fsinfo *info,
3564 status = nfs4_lookup_root(server, fhandle, info);
3566 if (auth_probe || status == NFS4ERR_WRONGSEC)
3567 status = server->nfs_client->cl_mvops->find_root_sec(server,
3571 status = nfs4_server_capabilities(server, fhandle);
3573 status = nfs4_do_fsinfo(server, fhandle, info);
3575 return nfs4_map_errors(status);
3578 static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *mntfh,
3579 struct nfs_fsinfo *info)
3582 struct nfs_fattr *fattr = info->fattr;
3583 struct nfs4_label *label = NULL;
3585 error = nfs4_server_capabilities(server, mntfh);
3587 dprintk("nfs4_get_root: getcaps error = %d\n", -error);
3591 label = nfs4_label_alloc(server, GFP_KERNEL);
3593 return PTR_ERR(label);
3595 error = nfs4_proc_getattr(server, mntfh, fattr, label);
3597 dprintk("nfs4_get_root: getattr error = %d\n", -error);
3598 goto err_free_label;
3601 if (fattr->valid & NFS_ATTR_FATTR_FSID &&
3602 !nfs_fsid_equal(&server->fsid, &fattr->fsid))
3603 memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));
3606 nfs4_label_free(label);
3612 * Get locations and (maybe) other attributes of a referral.
3613 * Note that we'll actually follow the referral later when
3614 * we detect fsid mismatch in inode revalidation
3616 static int nfs4_get_referral(struct rpc_clnt *client, struct inode *dir,
3617 const struct qstr *name, struct nfs_fattr *fattr,
3618 struct nfs_fh *fhandle)
3620 int status = -ENOMEM;
3621 struct page *page = NULL;
3622 struct nfs4_fs_locations *locations = NULL;
3624 page = alloc_page(GFP_KERNEL);
3627 locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
3628 if (locations == NULL)
3631 status = nfs4_proc_fs_locations(client, dir, name, locations, page);
3636 * If the fsid didn't change, this is a migration event, not a
3637 * referral. Cause us to drop into the exception handler, which
3638 * will kick off migration recovery.
3640 if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) {
3641 dprintk("%s: server did not return a different fsid for"
3642 " a referral at %s\n", __func__, name->name);
3643 status = -NFS4ERR_MOVED;
3646 /* Fixup attributes for the nfs_lookup() call to nfs_fhget() */
3647 nfs_fixup_referral_attributes(&locations->fattr);
3649 /* replace the lookup nfs_fattr with the locations nfs_fattr */
3650 memcpy(fattr, &locations->fattr, sizeof(struct nfs_fattr));
3651 memset(fhandle, 0, sizeof(struct nfs_fh));
3659 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
3660 struct nfs_fattr *fattr, struct nfs4_label *label)
3662 struct nfs4_getattr_arg args = {
3664 .bitmask = server->attr_bitmask,
3666 struct nfs4_getattr_res res = {
3671 struct rpc_message msg = {
3672 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
3677 args.bitmask = nfs4_bitmask(server, label);
3679 nfs_fattr_init(fattr);
3680 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3683 static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
3684 struct nfs_fattr *fattr, struct nfs4_label *label)
3686 struct nfs4_exception exception = { };
3689 err = _nfs4_proc_getattr(server, fhandle, fattr, label);
3690 trace_nfs4_getattr(server, fhandle, fattr, err);
3691 err = nfs4_handle_exception(server, err,
3693 } while (exception.retry);
3698 * The file is not closed if it is opened due to the a request to change
3699 * the size of the file. The open call will not be needed once the
3700 * VFS layer lookup-intents are implemented.
3702 * Close is called when the inode is destroyed.
3703 * If we haven't opened the file for O_WRONLY, we
3704 * need to in the size_change case to obtain a stateid.
3707 * Because OPEN is always done by name in nfsv4, it is
3708 * possible that we opened a different file by the same
3709 * name. We can recognize this race condition, but we
3710 * can't do anything about it besides returning an error.
3712 * This will be fixed with VFS changes (lookup-intent).
3715 nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
3716 struct iattr *sattr)
3718 struct inode *inode = d_inode(dentry);
3719 struct rpc_cred *cred = NULL;
3720 struct nfs4_state *state = NULL;
3721 struct nfs4_label *label = NULL;
3724 if (pnfs_ld_layoutret_on_setattr(inode) &&
3725 sattr->ia_valid & ATTR_SIZE &&
3726 sattr->ia_size < i_size_read(inode))
3727 pnfs_commit_and_return_layout(inode);
3729 nfs_fattr_init(fattr);
3731 /* Deal with open(O_TRUNC) */
3732 if (sattr->ia_valid & ATTR_OPEN)
3733 sattr->ia_valid &= ~(ATTR_MTIME|ATTR_CTIME);
3735 /* Optimization: if the end result is no change, don't RPC */
3736 if ((sattr->ia_valid & ~(ATTR_FILE|ATTR_OPEN)) == 0)
3739 /* Search for an existing open(O_WRITE) file */
3740 if (sattr->ia_valid & ATTR_FILE) {
3741 struct nfs_open_context *ctx;
3743 ctx = nfs_file_open_context(sattr->ia_file);
3750 label = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
3752 return PTR_ERR(label);
3754 status = nfs4_do_setattr(inode, cred, fattr, sattr, state, NULL, label);
3756 nfs_setattr_update_inode(inode, sattr, fattr);
3757 nfs_setsecurity(inode, fattr, label);
3759 nfs4_label_free(label);
3763 static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir,
3764 const struct qstr *name, struct nfs_fh *fhandle,
3765 struct nfs_fattr *fattr, struct nfs4_label *label)
3767 struct nfs_server *server = NFS_SERVER(dir);
3769 struct nfs4_lookup_arg args = {
3770 .bitmask = server->attr_bitmask,
3771 .dir_fh = NFS_FH(dir),
3774 struct nfs4_lookup_res res = {
3780 struct rpc_message msg = {
3781 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP],
3786 args.bitmask = nfs4_bitmask(server, label);
3788 nfs_fattr_init(fattr);
3790 dprintk("NFS call lookup %s\n", name->name);
3791 status = nfs4_call_sync(clnt, server, &msg, &args.seq_args, &res.seq_res, 0);
3792 dprintk("NFS reply lookup: %d\n", status);
3796 static void nfs_fixup_secinfo_attributes(struct nfs_fattr *fattr)
3798 fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |
3799 NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_MOUNTPOINT;
3800 fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;
3804 static int nfs4_proc_lookup_common(struct rpc_clnt **clnt, struct inode *dir,
3805 const struct qstr *name, struct nfs_fh *fhandle,
3806 struct nfs_fattr *fattr, struct nfs4_label *label)
3808 struct nfs4_exception exception = { };
3809 struct rpc_clnt *client = *clnt;
3812 err = _nfs4_proc_lookup(client, dir, name, fhandle, fattr, label);
3813 trace_nfs4_lookup(dir, name, err);
3815 case -NFS4ERR_BADNAME:
3818 case -NFS4ERR_MOVED:
3819 err = nfs4_get_referral(client, dir, name, fattr, fhandle);
3820 if (err == -NFS4ERR_MOVED)
3821 err = nfs4_handle_exception(NFS_SERVER(dir), err, &exception);
3823 case -NFS4ERR_WRONGSEC:
3825 if (client != *clnt)
3827 client = nfs4_negotiate_security(client, dir, name);
3829 return PTR_ERR(client);
3831 exception.retry = 1;
3834 err = nfs4_handle_exception(NFS_SERVER(dir), err, &exception);
3836 } while (exception.retry);
3841 else if (client != *clnt)
3842 rpc_shutdown_client(client);
3847 static int nfs4_proc_lookup(struct inode *dir, const struct qstr *name,
3848 struct nfs_fh *fhandle, struct nfs_fattr *fattr,
3849 struct nfs4_label *label)
3852 struct rpc_clnt *client = NFS_CLIENT(dir);
3854 status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr, label);
3855 if (client != NFS_CLIENT(dir)) {
3856 rpc_shutdown_client(client);
3857 nfs_fixup_secinfo_attributes(fattr);
3863 nfs4_proc_lookup_mountpoint(struct inode *dir, const struct qstr *name,
3864 struct nfs_fh *fhandle, struct nfs_fattr *fattr)
3866 struct rpc_clnt *client = NFS_CLIENT(dir);
3869 status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr, NULL);
3871 return ERR_PTR(status);
3872 return (client == NFS_CLIENT(dir)) ? rpc_clone_client(client) : client;
3875 static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
3877 struct nfs_server *server = NFS_SERVER(inode);
3878 struct nfs4_accessargs args = {
3879 .fh = NFS_FH(inode),
3880 .bitmask = server->cache_consistency_bitmask,
3882 struct nfs4_accessres res = {
3885 struct rpc_message msg = {
3886 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS],
3889 .rpc_cred = entry->cred,
3891 int mode = entry->mask;
3895 * Determine which access bits we want to ask for...
3897 if (mode & MAY_READ)
3898 args.access |= NFS4_ACCESS_READ;
3899 if (S_ISDIR(inode->i_mode)) {
3900 if (mode & MAY_WRITE)
3901 args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE;
3902 if (mode & MAY_EXEC)
3903 args.access |= NFS4_ACCESS_LOOKUP;
3905 if (mode & MAY_WRITE)
3906 args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND;
3907 if (mode & MAY_EXEC)
3908 args.access |= NFS4_ACCESS_EXECUTE;
3911 res.fattr = nfs_alloc_fattr();
3912 if (res.fattr == NULL)
3915 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3917 nfs_access_set_mask(entry, res.access);
3918 nfs_refresh_inode(inode, res.fattr);
3920 nfs_free_fattr(res.fattr);
3924 static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
3926 struct nfs4_exception exception = { };
3929 err = _nfs4_proc_access(inode, entry);
3930 trace_nfs4_access(inode, err);
3931 err = nfs4_handle_exception(NFS_SERVER(inode), err,
3933 } while (exception.retry);
3938 * TODO: For the time being, we don't try to get any attributes
3939 * along with any of the zero-copy operations READ, READDIR,
3942 * In the case of the first three, we want to put the GETATTR
3943 * after the read-type operation -- this is because it is hard
3944 * to predict the length of a GETATTR response in v4, and thus
3945 * align the READ data correctly. This means that the GETATTR
3946 * may end up partially falling into the page cache, and we should
3947 * shift it into the 'tail' of the xdr_buf before processing.
3948 * To do this efficiently, we need to know the total length
3949 * of data received, which doesn't seem to be available outside
3952 * In the case of WRITE, we also want to put the GETATTR after
3953 * the operation -- in this case because we want to make sure
3954 * we get the post-operation mtime and size.
3956 * Both of these changes to the XDR layer would in fact be quite
3957 * minor, but I decided to leave them for a subsequent patch.
3959 static int _nfs4_proc_readlink(struct inode *inode, struct page *page,
3960 unsigned int pgbase, unsigned int pglen)
3962 struct nfs4_readlink args = {
3963 .fh = NFS_FH(inode),
3968 struct nfs4_readlink_res res;
3969 struct rpc_message msg = {
3970 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READLINK],
3975 return nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), &msg, &args.seq_args, &res.seq_res, 0);
3978 static int nfs4_proc_readlink(struct inode *inode, struct page *page,
3979 unsigned int pgbase, unsigned int pglen)
3981 struct nfs4_exception exception = { };
3984 err = _nfs4_proc_readlink(inode, page, pgbase, pglen);
3985 trace_nfs4_readlink(inode, err);
3986 err = nfs4_handle_exception(NFS_SERVER(inode), err,
3988 } while (exception.retry);
3993 * This is just for mknod. open(O_CREAT) will always do ->open_context().
3996 nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
3999 struct nfs4_label l, *ilabel = NULL;
4000 struct nfs_open_context *ctx;
4001 struct nfs4_state *state;
4004 ctx = alloc_nfs_open_context(dentry, FMODE_READ);
4006 return PTR_ERR(ctx);
4008 ilabel = nfs4_label_init_security(dir, dentry, sattr, &l);
4010 sattr->ia_mode &= ~current_umask();
4011 state = nfs4_do_open(dir, ctx, flags, sattr, ilabel, NULL);
4012 if (IS_ERR(state)) {
4013 status = PTR_ERR(state);
4017 nfs4_label_release_security(ilabel);
4018 put_nfs_open_context(ctx);
4022 static int _nfs4_proc_remove(struct inode *dir, const struct qstr *name)
4024 struct nfs_server *server = NFS_SERVER(dir);
4025 struct nfs_removeargs args = {
4029 struct nfs_removeres res = {
4032 struct rpc_message msg = {
4033 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE],
4039 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1);
4041 update_changeattr(dir, &res.cinfo);
4045 static int nfs4_proc_remove(struct inode *dir, const struct qstr *name)
4047 struct nfs4_exception exception = { };
4050 err = _nfs4_proc_remove(dir, name);
4051 trace_nfs4_remove(dir, name, err);
4052 err = nfs4_handle_exception(NFS_SERVER(dir), err,
4054 } while (exception.retry);
4058 static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
4060 struct nfs_server *server = NFS_SERVER(dir);
4061 struct nfs_removeargs *args = msg->rpc_argp;
4062 struct nfs_removeres *res = msg->rpc_resp;
4064 res->server = server;
4065 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE];
4066 nfs4_init_sequence(&args->seq_args, &res->seq_res, 1);
4068 nfs_fattr_init(res->dir_attr);
4071 static void nfs4_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
4073 nfs4_setup_sequence(NFS_SB(data->dentry->d_sb),
4074 &data->args.seq_args,
4079 static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir)
4081 struct nfs_unlinkdata *data = task->tk_calldata;
4082 struct nfs_removeres *res = &data->res;
4084 if (!nfs4_sequence_done(task, &res->seq_res))
4086 if (nfs4_async_handle_error(task, res->server, NULL,
4087 &data->timeout) == -EAGAIN)
4089 update_changeattr(dir, &res->cinfo);
4093 static void nfs4_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
4095 struct nfs_server *server = NFS_SERVER(dir);
4096 struct nfs_renameargs *arg = msg->rpc_argp;
4097 struct nfs_renameres *res = msg->rpc_resp;
4099 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME];
4100 res->server = server;
4101 nfs4_init_sequence(&arg->seq_args, &res->seq_res, 1);
4104 static void nfs4_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
4106 nfs4_setup_sequence(NFS_SERVER(data->old_dir),
4107 &data->args.seq_args,
4112 static int nfs4_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
4113 struct inode *new_dir)
4115 struct nfs_renamedata *data = task->tk_calldata;
4116 struct nfs_renameres *res = &data->res;
4118 if (!nfs4_sequence_done(task, &res->seq_res))
4120 if (nfs4_async_handle_error(task, res->server, NULL, &data->timeout) == -EAGAIN)
4123 update_changeattr(old_dir, &res->old_cinfo);
4124 update_changeattr(new_dir, &res->new_cinfo);
4128 static int _nfs4_proc_link(struct inode *inode, struct inode *dir, const struct qstr *name)
4130 struct nfs_server *server = NFS_SERVER(inode);
4131 struct nfs4_link_arg arg = {
4132 .fh = NFS_FH(inode),
4133 .dir_fh = NFS_FH(dir),
4135 .bitmask = server->attr_bitmask,
4137 struct nfs4_link_res res = {
4141 struct rpc_message msg = {
4142 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK],
4146 int status = -ENOMEM;
4148 res.fattr = nfs_alloc_fattr();
4149 if (res.fattr == NULL)
4152 res.label = nfs4_label_alloc(server, GFP_KERNEL);
4153 if (IS_ERR(res.label)) {
4154 status = PTR_ERR(res.label);
4157 arg.bitmask = nfs4_bitmask(server, res.label);
4159 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
4161 update_changeattr(dir, &res.cinfo);
4162 status = nfs_post_op_update_inode(inode, res.fattr);
4164 nfs_setsecurity(inode, res.fattr, res.label);
4168 nfs4_label_free(res.label);
4171 nfs_free_fattr(res.fattr);
4175 static int nfs4_proc_link(struct inode *inode, struct inode *dir, const struct qstr *name)
4177 struct nfs4_exception exception = { };
4180 err = nfs4_handle_exception(NFS_SERVER(inode),
4181 _nfs4_proc_link(inode, dir, name),
4183 } while (exception.retry);
4187 struct nfs4_createdata {
4188 struct rpc_message msg;
4189 struct nfs4_create_arg arg;
4190 struct nfs4_create_res res;
4192 struct nfs_fattr fattr;
4193 struct nfs4_label *label;
4196 static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,
4197 const struct qstr *name, struct iattr *sattr, u32 ftype)
4199 struct nfs4_createdata *data;
4201 data = kzalloc(sizeof(*data), GFP_KERNEL);
4203 struct nfs_server *server = NFS_SERVER(dir);
4205 data->label = nfs4_label_alloc(server, GFP_KERNEL);
4206 if (IS_ERR(data->label))
4209 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE];
4210 data->msg.rpc_argp = &data->arg;
4211 data->msg.rpc_resp = &data->res;
4212 data->arg.dir_fh = NFS_FH(dir);
4213 data->arg.server = server;
4214 data->arg.name = name;
4215 data->arg.attrs = sattr;
4216 data->arg.ftype = ftype;
4217 data->arg.bitmask = nfs4_bitmask(server, data->label);
4218 data->res.server = server;
4219 data->res.fh = &data->fh;
4220 data->res.fattr = &data->fattr;
4221 data->res.label = data->label;
4222 nfs_fattr_init(data->res.fattr);
4230 static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data)
4232 int status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &data->msg,
4233 &data->arg.seq_args, &data->res.seq_res, 1);
4235 update_changeattr(dir, &data->res.dir_cinfo);
4236 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, data->res.label);
4241 static void nfs4_free_createdata(struct nfs4_createdata *data)
4243 nfs4_label_free(data->label);
4247 static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
4248 struct page *page, unsigned int len, struct iattr *sattr,
4249 struct nfs4_label *label)
4251 struct nfs4_createdata *data;
4252 int status = -ENAMETOOLONG;
4254 if (len > NFS4_MAXPATHLEN)
4258 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4LNK);
4262 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK];
4263 data->arg.u.symlink.pages = &page;
4264 data->arg.u.symlink.len = len;
4265 data->arg.label = label;
4267 status = nfs4_do_create(dir, dentry, data);
4269 nfs4_free_createdata(data);
4274 static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
4275 struct page *page, unsigned int len, struct iattr *sattr)
4277 struct nfs4_exception exception = { };
4278 struct nfs4_label l, *label = NULL;
4281 label = nfs4_label_init_security(dir, dentry, sattr, &l);
4284 err = _nfs4_proc_symlink(dir, dentry, page, len, sattr, label);
4285 trace_nfs4_symlink(dir, &dentry->d_name, err);
4286 err = nfs4_handle_exception(NFS_SERVER(dir), err,
4288 } while (exception.retry);
4290 nfs4_label_release_security(label);
4294 static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
4295 struct iattr *sattr, struct nfs4_label *label)
4297 struct nfs4_createdata *data;
4298 int status = -ENOMEM;
4300 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4DIR);
4304 data->arg.label = label;
4305 status = nfs4_do_create(dir, dentry, data);
4307 nfs4_free_createdata(data);
4312 static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
4313 struct iattr *sattr)
4315 struct nfs4_exception exception = { };
4316 struct nfs4_label l, *label = NULL;
4319 label = nfs4_label_init_security(dir, dentry, sattr, &l);
4321 sattr->ia_mode &= ~current_umask();
4323 err = _nfs4_proc_mkdir(dir, dentry, sattr, label);
4324 trace_nfs4_mkdir(dir, &dentry->d_name, err);
4325 err = nfs4_handle_exception(NFS_SERVER(dir), err,
4327 } while (exception.retry);
4328 nfs4_label_release_security(label);
4333 static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
4334 u64 cookie, struct page **pages, unsigned int count, int plus)
4336 struct inode *dir = d_inode(dentry);
4337 struct nfs_server *server = NFS_SERVER(dir);
4338 struct nfs4_readdir_arg args = {
4345 struct nfs4_readdir_res res;
4346 struct rpc_message msg = {
4347 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR],
4354 dprintk("%s: dentry = %pd2, cookie = %Lu\n", __func__,
4356 (unsigned long long)cookie);
4357 if (!(server->caps & NFS_CAP_SECURITY_LABEL))
4358 args.bitmask = server->attr_bitmask_nl;
4360 args.bitmask = server->attr_bitmask;
4362 nfs4_setup_readdir(cookie, NFS_I(dir)->cookieverf, dentry, &args);
4363 res.pgbase = args.pgbase;
4364 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args,
4367 memcpy(NFS_I(dir)->cookieverf, res.verifier.data, NFS4_VERIFIER_SIZE);
4368 status += args.pgbase;
4371 nfs_invalidate_atime(dir);
4373 dprintk("%s: returns %d\n", __func__, status);
4377 static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
4378 u64 cookie, struct page **pages, unsigned int count, int plus)
4380 struct nfs4_exception exception = { };
4383 err = _nfs4_proc_readdir(dentry, cred, cookie,
4384 pages, count, plus);
4385 trace_nfs4_readdir(d_inode(dentry), err);
4386 err = nfs4_handle_exception(NFS_SERVER(d_inode(dentry)), err,
4388 } while (exception.retry);
4392 static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
4393 struct iattr *sattr, struct nfs4_label *label, dev_t rdev)
4395 struct nfs4_createdata *data;
4396 int mode = sattr->ia_mode;
4397 int status = -ENOMEM;
4399 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4SOCK);
4404 data->arg.ftype = NF4FIFO;
4405 else if (S_ISBLK(mode)) {
4406 data->arg.ftype = NF4BLK;
4407 data->arg.u.device.specdata1 = MAJOR(rdev);
4408 data->arg.u.device.specdata2 = MINOR(rdev);
4410 else if (S_ISCHR(mode)) {
4411 data->arg.ftype = NF4CHR;
4412 data->arg.u.device.specdata1 = MAJOR(rdev);
4413 data->arg.u.device.specdata2 = MINOR(rdev);
4414 } else if (!S_ISSOCK(mode)) {
4419 data->arg.label = label;
4420 status = nfs4_do_create(dir, dentry, data);
4422 nfs4_free_createdata(data);
4427 static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
4428 struct iattr *sattr, dev_t rdev)
4430 struct nfs4_exception exception = { };
4431 struct nfs4_label l, *label = NULL;
4434 label = nfs4_label_init_security(dir, dentry, sattr, &l);
4436 sattr->ia_mode &= ~current_umask();
4438 err = _nfs4_proc_mknod(dir, dentry, sattr, label, rdev);
4439 trace_nfs4_mknod(dir, &dentry->d_name, err);
4440 err = nfs4_handle_exception(NFS_SERVER(dir), err,
4442 } while (exception.retry);
4444 nfs4_label_release_security(label);
4449 static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
4450 struct nfs_fsstat *fsstat)
4452 struct nfs4_statfs_arg args = {
4454 .bitmask = server->attr_bitmask,
4456 struct nfs4_statfs_res res = {
4459 struct rpc_message msg = {
4460 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_STATFS],
4465 nfs_fattr_init(fsstat->fattr);
4466 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
4469 static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *fsstat)
4471 struct nfs4_exception exception = { };
4474 err = nfs4_handle_exception(server,
4475 _nfs4_proc_statfs(server, fhandle, fsstat),
4477 } while (exception.retry);
4481 static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
4482 struct nfs_fsinfo *fsinfo)
4484 struct nfs4_fsinfo_arg args = {
4486 .bitmask = server->attr_bitmask,
4488 struct nfs4_fsinfo_res res = {
4491 struct rpc_message msg = {
4492 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSINFO],
4497 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
4500 static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
4502 struct nfs4_exception exception = { };
4503 unsigned long now = jiffies;
4507 err = _nfs4_do_fsinfo(server, fhandle, fsinfo);
4508 trace_nfs4_fsinfo(server, fhandle, fsinfo->fattr, err);
4510 nfs4_set_lease_period(server->nfs_client,
4511 fsinfo->lease_time * HZ,
4515 err = nfs4_handle_exception(server, err, &exception);
4516 } while (exception.retry);
4520 static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
4524 nfs_fattr_init(fsinfo->fattr);
4525 error = nfs4_do_fsinfo(server, fhandle, fsinfo);
4527 /* block layout checks this! */
4528 server->pnfs_blksize = fsinfo->blksize;
4529 set_pnfs_layoutdriver(server, fhandle, fsinfo);
4535 static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
4536 struct nfs_pathconf *pathconf)
4538 struct nfs4_pathconf_arg args = {
4540 .bitmask = server->attr_bitmask,
4542 struct nfs4_pathconf_res res = {
4543 .pathconf = pathconf,
4545 struct rpc_message msg = {
4546 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_PATHCONF],
4551 /* None of the pathconf attributes are mandatory to implement */
4552 if ((args.bitmask[0] & nfs4_pathconf_bitmap[0]) == 0) {
4553 memset(pathconf, 0, sizeof(*pathconf));
4557 nfs_fattr_init(pathconf->fattr);
4558 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
4561 static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
4562 struct nfs_pathconf *pathconf)
4564 struct nfs4_exception exception = { };
4568 err = nfs4_handle_exception(server,
4569 _nfs4_proc_pathconf(server, fhandle, pathconf),
4571 } while (exception.retry);
4575 int nfs4_set_rw_stateid(nfs4_stateid *stateid,
4576 const struct nfs_open_context *ctx,
4577 const struct nfs_lock_context *l_ctx,
4580 const struct nfs_lockowner *lockowner = NULL;
4583 lockowner = &l_ctx->lockowner;
4584 return nfs4_select_rw_stateid(ctx->state, fmode, lockowner, stateid, NULL);
4586 EXPORT_SYMBOL_GPL(nfs4_set_rw_stateid);
4588 static bool nfs4_stateid_is_current(nfs4_stateid *stateid,
4589 const struct nfs_open_context *ctx,
4590 const struct nfs_lock_context *l_ctx,
4593 nfs4_stateid current_stateid;
4595 /* If the current stateid represents a lost lock, then exit */
4596 if (nfs4_set_rw_stateid(¤t_stateid, ctx, l_ctx, fmode) == -EIO)
4598 return nfs4_stateid_match(stateid, ¤t_stateid);
4601 static bool nfs4_error_stateid_expired(int err)
4604 case -NFS4ERR_DELEG_REVOKED:
4605 case -NFS4ERR_ADMIN_REVOKED:
4606 case -NFS4ERR_BAD_STATEID:
4607 case -NFS4ERR_STALE_STATEID:
4608 case -NFS4ERR_OLD_STATEID:
4609 case -NFS4ERR_OPENMODE:
4610 case -NFS4ERR_EXPIRED:
4616 static int nfs4_read_done_cb(struct rpc_task *task, struct nfs_pgio_header *hdr)
4618 struct nfs_server *server = NFS_SERVER(hdr->inode);
4620 trace_nfs4_read(hdr, task->tk_status);
4621 if (task->tk_status < 0) {
4622 struct nfs4_exception exception = {
4623 .inode = hdr->inode,
4624 .state = hdr->args.context->state,
4625 .stateid = &hdr->args.stateid,
4627 task->tk_status = nfs4_async_handle_exception(task,
4628 server, task->tk_status, &exception);
4629 if (exception.retry) {
4630 rpc_restart_call_prepare(task);
4635 if (task->tk_status > 0)
4636 renew_lease(server, hdr->timestamp);
4640 static bool nfs4_read_stateid_changed(struct rpc_task *task,
4641 struct nfs_pgio_args *args)
4644 if (!nfs4_error_stateid_expired(task->tk_status) ||
4645 nfs4_stateid_is_current(&args->stateid,
4650 rpc_restart_call_prepare(task);
4654 static int nfs4_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
4657 dprintk("--> %s\n", __func__);
4659 if (!nfs4_sequence_done(task, &hdr->res.seq_res))
4661 if (nfs4_read_stateid_changed(task, &hdr->args))
4663 if (task->tk_status > 0)
4664 nfs_invalidate_atime(hdr->inode);
4665 return hdr->pgio_done_cb ? hdr->pgio_done_cb(task, hdr) :
4666 nfs4_read_done_cb(task, hdr);
4669 static void nfs4_proc_read_setup(struct nfs_pgio_header *hdr,
4670 struct rpc_message *msg)
4672 hdr->timestamp = jiffies;
4673 if (!hdr->pgio_done_cb)
4674 hdr->pgio_done_cb = nfs4_read_done_cb;
4675 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ];
4676 nfs4_init_sequence(&hdr->args.seq_args, &hdr->res.seq_res, 0);
4679 static int nfs4_proc_pgio_rpc_prepare(struct rpc_task *task,
4680 struct nfs_pgio_header *hdr)
4682 if (nfs4_setup_sequence(NFS_SERVER(hdr->inode),
4683 &hdr->args.seq_args,
4687 if (nfs4_set_rw_stateid(&hdr->args.stateid, hdr->args.context,
4688 hdr->args.lock_context,
4689 hdr->rw_ops->rw_mode) == -EIO)
4691 if (unlikely(test_bit(NFS_CONTEXT_BAD, &hdr->args.context->flags)))
4696 static int nfs4_write_done_cb(struct rpc_task *task,
4697 struct nfs_pgio_header *hdr)
4699 struct inode *inode = hdr->inode;
4701 trace_nfs4_write(hdr, task->tk_status);
4702 if (task->tk_status < 0) {
4703 struct nfs4_exception exception = {
4704 .inode = hdr->inode,
4705 .state = hdr->args.context->state,
4706 .stateid = &hdr->args.stateid,
4708 task->tk_status = nfs4_async_handle_exception(task,
4709 NFS_SERVER(inode), task->tk_status,
4711 if (exception.retry) {
4712 rpc_restart_call_prepare(task);
4716 if (task->tk_status >= 0) {
4717 renew_lease(NFS_SERVER(inode), hdr->timestamp);
4718 nfs_writeback_update_inode(hdr);
4723 static bool nfs4_write_stateid_changed(struct rpc_task *task,
4724 struct nfs_pgio_args *args)
4727 if (!nfs4_error_stateid_expired(task->tk_status) ||
4728 nfs4_stateid_is_current(&args->stateid,
4733 rpc_restart_call_prepare(task);
4737 static int nfs4_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
4739 if (!nfs4_sequence_done(task, &hdr->res.seq_res))
4741 if (nfs4_write_stateid_changed(task, &hdr->args))
4743 return hdr->pgio_done_cb ? hdr->pgio_done_cb(task, hdr) :
4744 nfs4_write_done_cb(task, hdr);
4748 bool nfs4_write_need_cache_consistency_data(struct nfs_pgio_header *hdr)
4750 /* Don't request attributes for pNFS or O_DIRECT writes */
4751 if (hdr->ds_clp != NULL || hdr->dreq != NULL)
4753 /* Otherwise, request attributes if and only if we don't hold
4756 return nfs4_have_delegation(hdr->inode, FMODE_READ) == 0;
4759 static void nfs4_proc_write_setup(struct nfs_pgio_header *hdr,
4760 struct rpc_message *msg)
4762 struct nfs_server *server = NFS_SERVER(hdr->inode);
4764 if (!nfs4_write_need_cache_consistency_data(hdr)) {
4765 hdr->args.bitmask = NULL;
4766 hdr->res.fattr = NULL;
4768 hdr->args.bitmask = server->cache_consistency_bitmask;
4770 if (!hdr->pgio_done_cb)
4771 hdr->pgio_done_cb = nfs4_write_done_cb;
4772 hdr->res.server = server;
4773 hdr->timestamp = jiffies;
4775 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE];
4776 nfs4_init_sequence(&hdr->args.seq_args, &hdr->res.seq_res, 1);
4779 static void nfs4_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
4781 nfs4_setup_sequence(NFS_SERVER(data->inode),
4782 &data->args.seq_args,
4787 static int nfs4_commit_done_cb(struct rpc_task *task, struct nfs_commit_data *data)
4789 struct inode *inode = data->inode;
4791 trace_nfs4_commit(data, task->tk_status);
4792 if (nfs4_async_handle_error(task, NFS_SERVER(inode),
4793 NULL, NULL) == -EAGAIN) {
4794 rpc_restart_call_prepare(task);
4800 static int nfs4_commit_done(struct rpc_task *task, struct nfs_commit_data *data)
4802 if (!nfs4_sequence_done(task, &data->res.seq_res))
4804 return data->commit_done_cb(task, data);
4807 static void nfs4_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
4809 struct nfs_server *server = NFS_SERVER(data->inode);
4811 if (data->commit_done_cb == NULL)
4812 data->commit_done_cb = nfs4_commit_done_cb;
4813 data->res.server = server;
4814 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT];
4815 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
4818 struct nfs4_renewdata {
4819 struct nfs_client *client;
4820 unsigned long timestamp;
4824 * nfs4_proc_async_renew(): This is not one of the nfs_rpc_ops; it is a special
4825 * standalone procedure for queueing an asynchronous RENEW.
4827 static void nfs4_renew_release(void *calldata)
4829 struct nfs4_renewdata *data = calldata;
4830 struct nfs_client *clp = data->client;
4832 if (atomic_read(&clp->cl_count) > 1)
4833 nfs4_schedule_state_renewal(clp);
4834 nfs_put_client(clp);
4838 static void nfs4_renew_done(struct rpc_task *task, void *calldata)
4840 struct nfs4_renewdata *data = calldata;
4841 struct nfs_client *clp = data->client;
4842 unsigned long timestamp = data->timestamp;
4844 trace_nfs4_renew_async(clp, task->tk_status);
4845 switch (task->tk_status) {
4848 case -NFS4ERR_LEASE_MOVED:
4849 nfs4_schedule_lease_moved_recovery(clp);
4852 /* Unless we're shutting down, schedule state recovery! */
4853 if (test_bit(NFS_CS_RENEWD, &clp->cl_res_state) == 0)
4855 if (task->tk_status != NFS4ERR_CB_PATH_DOWN) {
4856 nfs4_schedule_lease_recovery(clp);
4859 nfs4_schedule_path_down_recovery(clp);
4861 do_renew_lease(clp, timestamp);
4864 static const struct rpc_call_ops nfs4_renew_ops = {
4865 .rpc_call_done = nfs4_renew_done,
4866 .rpc_release = nfs4_renew_release,
4869 static int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags)
4871 struct rpc_message msg = {
4872 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
4876 struct nfs4_renewdata *data;
4878 if (renew_flags == 0)
4880 if (!atomic_inc_not_zero(&clp->cl_count))
4882 data = kmalloc(sizeof(*data), GFP_NOFS);
4886 data->timestamp = jiffies;
4887 return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT,
4888 &nfs4_renew_ops, data);
4891 static int nfs4_proc_renew(struct nfs_client *clp, struct rpc_cred *cred)
4893 struct rpc_message msg = {
4894 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
4898 unsigned long now = jiffies;
4901 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
4904 do_renew_lease(clp, now);
4908 static inline int nfs4_server_supports_acls(struct nfs_server *server)
4910 return server->caps & NFS_CAP_ACLS;
4913 /* Assuming that XATTR_SIZE_MAX is a multiple of PAGE_SIZE, and that
4914 * it's OK to put sizeof(void) * (XATTR_SIZE_MAX/PAGE_SIZE) bytes on
4917 #define NFS4ACL_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE)
4919 static int buf_to_pages_noslab(const void *buf, size_t buflen,
4920 struct page **pages)
4922 struct page *newpage, **spages;
4928 len = min_t(size_t, PAGE_SIZE, buflen);
4929 newpage = alloc_page(GFP_KERNEL);
4931 if (newpage == NULL)
4933 memcpy(page_address(newpage), buf, len);
4938 } while (buflen != 0);
4944 __free_page(spages[rc-1]);
4948 struct nfs4_cached_acl {
4954 static void nfs4_set_cached_acl(struct inode *inode, struct nfs4_cached_acl *acl)
4956 struct nfs_inode *nfsi = NFS_I(inode);
4958 spin_lock(&inode->i_lock);
4959 kfree(nfsi->nfs4_acl);
4960 nfsi->nfs4_acl = acl;
4961 spin_unlock(&inode->i_lock);
4964 static void nfs4_zap_acl_attr(struct inode *inode)
4966 nfs4_set_cached_acl(inode, NULL);
4969 static inline ssize_t nfs4_read_cached_acl(struct inode *inode, char *buf, size_t buflen)
4971 struct nfs_inode *nfsi = NFS_I(inode);
4972 struct nfs4_cached_acl *acl;
4975 spin_lock(&inode->i_lock);
4976 acl = nfsi->nfs4_acl;
4979 if (buf == NULL) /* user is just asking for length */
4981 if (acl->cached == 0)
4983 ret = -ERANGE; /* see getxattr(2) man page */
4984 if (acl->len > buflen)
4986 memcpy(buf, acl->data, acl->len);
4990 spin_unlock(&inode->i_lock);
4994 static void nfs4_write_cached_acl(struct inode *inode, struct page **pages, size_t pgbase, size_t acl_len)
4996 struct nfs4_cached_acl *acl;
4997 size_t buflen = sizeof(*acl) + acl_len;
4999 if (buflen <= PAGE_SIZE) {
5000 acl = kmalloc(buflen, GFP_KERNEL);
5004 _copy_from_pages(acl->data, pages, pgbase, acl_len);
5006 acl = kmalloc(sizeof(*acl), GFP_KERNEL);
5013 nfs4_set_cached_acl(inode, acl);
5017 * The getxattr API returns the required buffer length when called with a
5018 * NULL buf. The NFSv4 acl tool then calls getxattr again after allocating
5019 * the required buf. On a NULL buf, we send a page of data to the server
5020 * guessing that the ACL request can be serviced by a page. If so, we cache
5021 * up to the page of ACL data, and the 2nd call to getxattr is serviced by
5022 * the cache. If not so, we throw away the page, and cache the required
5023 * length. The next getxattr call will then produce another round trip to
5024 * the server, this time with the input buf of the required size.
5026 static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
5028 struct page *pages[NFS4ACL_MAXPAGES + 1] = {NULL, };
5029 struct nfs_getaclargs args = {
5030 .fh = NFS_FH(inode),
5034 struct nfs_getaclres res = {
5037 struct rpc_message msg = {
5038 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETACL],
5042 unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE) + 1;
5043 int ret = -ENOMEM, i;
5045 if (npages > ARRAY_SIZE(pages))
5048 for (i = 0; i < npages; i++) {
5049 pages[i] = alloc_page(GFP_KERNEL);
5054 /* for decoding across pages */
5055 res.acl_scratch = alloc_page(GFP_KERNEL);
5056 if (!res.acl_scratch)
5059 args.acl_len = npages * PAGE_SIZE;
5061 dprintk("%s buf %p buflen %zu npages %d args.acl_len %zu\n",
5062 __func__, buf, buflen, npages, args.acl_len);
5063 ret = nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode),
5064 &msg, &args.seq_args, &res.seq_res, 0);
5068 /* Handle the case where the passed-in buffer is too short */
5069 if (res.acl_flags & NFS4_ACL_TRUNC) {
5070 /* Did the user only issue a request for the acl length? */
5076 nfs4_write_cached_acl(inode, pages, res.acl_data_offset, res.acl_len);
5078 if (res.acl_len > buflen) {
5082 _copy_from_pages(buf, pages, res.acl_data_offset, res.acl_len);
5087 for (i = 0; i < npages; i++)
5089 __free_page(pages[i]);
5090 if (res.acl_scratch)
5091 __free_page(res.acl_scratch);
5095 static ssize_t nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
5097 struct nfs4_exception exception = { };
5100 ret = __nfs4_get_acl_uncached(inode, buf, buflen);
5101 trace_nfs4_get_acl(inode, ret);
5104 ret = nfs4_handle_exception(NFS_SERVER(inode), ret, &exception);
5105 } while (exception.retry);
5109 static ssize_t nfs4_proc_get_acl(struct inode *inode, void *buf, size_t buflen)
5111 struct nfs_server *server = NFS_SERVER(inode);
5114 if (!nfs4_server_supports_acls(server))
5116 ret = nfs_revalidate_inode(server, inode);
5119 if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL)
5120 nfs_zap_acl_cache(inode);
5121 ret = nfs4_read_cached_acl(inode, buf, buflen);
5123 /* -ENOENT is returned if there is no ACL or if there is an ACL
5124 * but no cached acl data, just the acl length */
5126 return nfs4_get_acl_uncached(inode, buf, buflen);
5129 static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
5131 struct nfs_server *server = NFS_SERVER(inode);
5132 struct page *pages[NFS4ACL_MAXPAGES];
5133 struct nfs_setaclargs arg = {
5134 .fh = NFS_FH(inode),
5138 struct nfs_setaclres res;
5139 struct rpc_message msg = {
5140 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETACL],
5144 unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE);
5147 /* You can't remove system.nfs4_acl: */
5150 if (!nfs4_server_supports_acls(server))
5152 if (npages > ARRAY_SIZE(pages))
5154 i = buf_to_pages_noslab(buf, buflen, arg.acl_pages);
5157 nfs4_inode_return_delegation(inode);
5158 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
5161 * Free each page after tx, so the only ref left is
5162 * held by the network stack
5165 put_page(pages[i-1]);
5168 * Acl update can result in inode attribute update.
5169 * so mark the attribute cache invalid.
5171 spin_lock(&inode->i_lock);
5172 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR;
5173 spin_unlock(&inode->i_lock);
5174 nfs_access_zap_cache(inode);
5175 nfs_zap_acl_cache(inode);
5179 static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
5181 struct nfs4_exception exception = { };
5184 err = __nfs4_proc_set_acl(inode, buf, buflen);
5185 trace_nfs4_set_acl(inode, err);
5186 if (err == -NFS4ERR_BADOWNER || err == -NFS4ERR_BADNAME) {
5188 * no need to retry since the kernel
5189 * isn't involved in encoding the ACEs.
5194 err = nfs4_handle_exception(NFS_SERVER(inode), err,
5196 } while (exception.retry);
5200 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
5201 static int _nfs4_get_security_label(struct inode *inode, void *buf,
5204 struct nfs_server *server = NFS_SERVER(inode);
5205 struct nfs_fattr fattr;
5206 struct nfs4_label label = {0, 0, buflen, buf};
5208 u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL };
5209 struct nfs4_getattr_arg arg = {
5210 .fh = NFS_FH(inode),
5213 struct nfs4_getattr_res res = {
5218 struct rpc_message msg = {
5219 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
5225 nfs_fattr_init(&fattr);
5227 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 0);
5230 if (!(fattr.valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL))
5235 static int nfs4_get_security_label(struct inode *inode, void *buf,
5238 struct nfs4_exception exception = { };
5241 if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
5245 err = _nfs4_get_security_label(inode, buf, buflen);
5246 trace_nfs4_get_security_label(inode, err);
5247 err = nfs4_handle_exception(NFS_SERVER(inode), err,
5249 } while (exception.retry);
5253 static int _nfs4_do_set_security_label(struct inode *inode,
5254 struct nfs4_label *ilabel,
5255 struct nfs_fattr *fattr,
5256 struct nfs4_label *olabel)
5259 struct iattr sattr = {0};
5260 struct nfs_server *server = NFS_SERVER(inode);
5261 const u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL };
5262 struct nfs_setattrargs arg = {
5263 .fh = NFS_FH(inode),
5269 struct nfs_setattrres res = {
5274 struct rpc_message msg = {
5275 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
5281 nfs4_stateid_copy(&arg.stateid, &zero_stateid);
5283 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
5285 dprintk("%s failed: %d\n", __func__, status);
5290 static int nfs4_do_set_security_label(struct inode *inode,
5291 struct nfs4_label *ilabel,
5292 struct nfs_fattr *fattr,
5293 struct nfs4_label *olabel)
5295 struct nfs4_exception exception = { };
5299 err = _nfs4_do_set_security_label(inode, ilabel,
5301 trace_nfs4_set_security_label(inode, err);
5302 err = nfs4_handle_exception(NFS_SERVER(inode), err,
5304 } while (exception.retry);
5309 nfs4_set_security_label(struct inode *inode, const void *buf, size_t buflen)
5311 struct nfs4_label ilabel, *olabel = NULL;
5312 struct nfs_fattr fattr;
5313 struct rpc_cred *cred;
5316 if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
5319 nfs_fattr_init(&fattr);
5323 ilabel.label = (char *)buf;
5324 ilabel.len = buflen;
5326 cred = rpc_lookup_cred();
5328 return PTR_ERR(cred);
5330 olabel = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
5331 if (IS_ERR(olabel)) {
5332 status = -PTR_ERR(olabel);
5336 status = nfs4_do_set_security_label(inode, &ilabel, &fattr, olabel);
5338 nfs_setsecurity(inode, &fattr, olabel);
5340 nfs4_label_free(olabel);
5345 #endif /* CONFIG_NFS_V4_SECURITY_LABEL */
5348 static void nfs4_init_boot_verifier(const struct nfs_client *clp,
5349 nfs4_verifier *bootverf)
5353 if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
5354 /* An impossible timestamp guarantees this value
5355 * will never match a generated boot time. */
5356 verf[0] = cpu_to_be32(U32_MAX);
5357 verf[1] = cpu_to_be32(U32_MAX);
5359 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
5360 u64 ns = ktime_to_ns(nn->boot_time);
5362 verf[0] = cpu_to_be32(ns >> 32);
5363 verf[1] = cpu_to_be32(ns);
5365 memcpy(bootverf->data, verf, sizeof(bootverf->data));
5369 nfs4_init_nonuniform_client_string(struct nfs_client *clp)
5374 if (clp->cl_owner_id != NULL)
5378 len = 14 + strlen(clp->cl_ipaddr) + 1 +
5379 strlen(rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR)) +
5381 strlen(rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_PROTO)) +
5385 if (len > NFS4_OPAQUE_LIMIT + 1)
5389 * Since this string is allocated at mount time, and held until the
5390 * nfs_client is destroyed, we can use GFP_KERNEL here w/o worrying
5391 * about a memory-reclaim deadlock.
5393 str = kmalloc(len, GFP_KERNEL);
5398 scnprintf(str, len, "Linux NFSv4.0 %s/%s %s",
5400 rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR),
5401 rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_PROTO));
5404 clp->cl_owner_id = str;
5409 nfs4_init_uniquifier_client_string(struct nfs_client *clp)
5414 len = 10 + 10 + 1 + 10 + 1 +
5415 strlen(nfs4_client_id_uniquifier) + 1 +
5416 strlen(clp->cl_rpcclient->cl_nodename) + 1;
5418 if (len > NFS4_OPAQUE_LIMIT + 1)
5422 * Since this string is allocated at mount time, and held until the
5423 * nfs_client is destroyed, we can use GFP_KERNEL here w/o worrying
5424 * about a memory-reclaim deadlock.
5426 str = kmalloc(len, GFP_KERNEL);
5430 scnprintf(str, len, "Linux NFSv%u.%u %s/%s",
5431 clp->rpc_ops->version, clp->cl_minorversion,
5432 nfs4_client_id_uniquifier,
5433 clp->cl_rpcclient->cl_nodename);
5434 clp->cl_owner_id = str;
5439 nfs4_init_uniform_client_string(struct nfs_client *clp)
5444 if (clp->cl_owner_id != NULL)
5447 if (nfs4_client_id_uniquifier[0] != '\0')
5448 return nfs4_init_uniquifier_client_string(clp);
5450 len = 10 + 10 + 1 + 10 + 1 +
5451 strlen(clp->cl_rpcclient->cl_nodename) + 1;
5453 if (len > NFS4_OPAQUE_LIMIT + 1)
5457 * Since this string is allocated at mount time, and held until the
5458 * nfs_client is destroyed, we can use GFP_KERNEL here w/o worrying
5459 * about a memory-reclaim deadlock.
5461 str = kmalloc(len, GFP_KERNEL);
5465 scnprintf(str, len, "Linux NFSv%u.%u %s",
5466 clp->rpc_ops->version, clp->cl_minorversion,
5467 clp->cl_rpcclient->cl_nodename);
5468 clp->cl_owner_id = str;
5473 * nfs4_callback_up_net() starts only "tcp" and "tcp6" callback
5474 * services. Advertise one based on the address family of the
5478 nfs4_init_callback_netid(const struct nfs_client *clp, char *buf, size_t len)
5480 if (strchr(clp->cl_ipaddr, ':') != NULL)
5481 return scnprintf(buf, len, "tcp6");
5483 return scnprintf(buf, len, "tcp");
5486 static void nfs4_setclientid_done(struct rpc_task *task, void *calldata)
5488 struct nfs4_setclientid *sc = calldata;
5490 if (task->tk_status == 0)
5491 sc->sc_cred = get_rpccred(task->tk_rqstp->rq_cred);
5494 static const struct rpc_call_ops nfs4_setclientid_ops = {
5495 .rpc_call_done = nfs4_setclientid_done,
5499 * nfs4_proc_setclientid - Negotiate client ID
5500 * @clp: state data structure
5501 * @program: RPC program for NFSv4 callback service
5502 * @port: IP port number for NFS4 callback service
5503 * @cred: RPC credential to use for this call
5504 * @res: where to place the result
5506 * Returns zero, a negative errno, or a negative NFS4ERR status code.
5508 int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,
5509 unsigned short port, struct rpc_cred *cred,
5510 struct nfs4_setclientid_res *res)
5512 nfs4_verifier sc_verifier;
5513 struct nfs4_setclientid setclientid = {
5514 .sc_verifier = &sc_verifier,
5518 struct rpc_message msg = {
5519 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID],
5520 .rpc_argp = &setclientid,
5524 struct rpc_task *task;
5525 struct rpc_task_setup task_setup_data = {
5526 .rpc_client = clp->cl_rpcclient,
5527 .rpc_message = &msg,
5528 .callback_ops = &nfs4_setclientid_ops,
5529 .callback_data = &setclientid,
5530 .flags = RPC_TASK_TIMEOUT,
5534 /* nfs_client_id4 */
5535 nfs4_init_boot_verifier(clp, &sc_verifier);
5537 if (test_bit(NFS_CS_MIGRATION, &clp->cl_flags))
5538 status = nfs4_init_uniform_client_string(clp);
5540 status = nfs4_init_nonuniform_client_string(clp);
5546 setclientid.sc_netid_len =
5547 nfs4_init_callback_netid(clp,
5548 setclientid.sc_netid,
5549 sizeof(setclientid.sc_netid));
5550 setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr,
5551 sizeof(setclientid.sc_uaddr), "%s.%u.%u",
5552 clp->cl_ipaddr, port >> 8, port & 255);
5554 dprintk("NFS call setclientid auth=%s, '%s'\n",
5555 clp->cl_rpcclient->cl_auth->au_ops->au_name,
5557 task = rpc_run_task(&task_setup_data);
5559 status = PTR_ERR(task);
5562 status = task->tk_status;
5563 if (setclientid.sc_cred) {
5564 kfree(clp->cl_acceptor);
5565 clp->cl_acceptor = rpcauth_stringify_acceptor(setclientid.sc_cred);
5566 put_rpccred(setclientid.sc_cred);
5570 trace_nfs4_setclientid(clp, status);
5571 dprintk("NFS reply setclientid: %d\n", status);
5576 * nfs4_proc_setclientid_confirm - Confirm client ID
5577 * @clp: state data structure
5578 * @res: result of a previous SETCLIENTID
5579 * @cred: RPC credential to use for this call
5581 * Returns zero, a negative errno, or a negative NFS4ERR status code.
5583 int nfs4_proc_setclientid_confirm(struct nfs_client *clp,
5584 struct nfs4_setclientid_res *arg,
5585 struct rpc_cred *cred)
5587 struct rpc_message msg = {
5588 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM],
5594 dprintk("NFS call setclientid_confirm auth=%s, (client ID %llx)\n",
5595 clp->cl_rpcclient->cl_auth->au_ops->au_name,
5597 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
5598 trace_nfs4_setclientid_confirm(clp, status);
5599 dprintk("NFS reply setclientid_confirm: %d\n", status);
5603 struct nfs4_delegreturndata {
5604 struct nfs4_delegreturnargs args;
5605 struct nfs4_delegreturnres res;
5607 nfs4_stateid stateid;
5608 unsigned long timestamp;
5609 struct nfs_fattr fattr;
5611 struct inode *inode;
5616 static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata)
5618 struct nfs4_delegreturndata *data = calldata;
5620 if (!nfs4_sequence_done(task, &data->res.seq_res))
5623 trace_nfs4_delegreturn_exit(&data->args, &data->res, task->tk_status);
5624 switch (task->tk_status) {
5626 renew_lease(data->res.server, data->timestamp);
5628 case -NFS4ERR_ADMIN_REVOKED:
5629 case -NFS4ERR_DELEG_REVOKED:
5630 case -NFS4ERR_EXPIRED:
5631 nfs4_free_revoked_stateid(data->res.server,
5633 task->tk_msg.rpc_cred);
5634 case -NFS4ERR_BAD_STATEID:
5635 case -NFS4ERR_OLD_STATEID:
5636 case -NFS4ERR_STALE_STATEID:
5637 task->tk_status = 0;
5640 if (nfs4_async_handle_error(task, data->res.server,
5641 NULL, NULL) == -EAGAIN) {
5642 rpc_restart_call_prepare(task);
5646 data->rpc_status = task->tk_status;
5647 if (data->roc && data->rpc_status == 0)
5648 pnfs_roc_set_barrier(data->inode, data->roc_barrier);
5651 static void nfs4_delegreturn_release(void *calldata)
5653 struct nfs4_delegreturndata *data = calldata;
5654 struct inode *inode = data->inode;
5658 pnfs_roc_release(inode);
5659 nfs_iput_and_deactive(inode);
5664 static void nfs4_delegreturn_prepare(struct rpc_task *task, void *data)
5666 struct nfs4_delegreturndata *d_data;
5668 d_data = (struct nfs4_delegreturndata *)data;
5670 if (nfs4_wait_on_layoutreturn(d_data->inode, task))
5674 pnfs_roc_get_barrier(d_data->inode, &d_data->roc_barrier);
5676 nfs4_setup_sequence(d_data->res.server,
5677 &d_data->args.seq_args,
5678 &d_data->res.seq_res,
5682 static const struct rpc_call_ops nfs4_delegreturn_ops = {
5683 .rpc_call_prepare = nfs4_delegreturn_prepare,
5684 .rpc_call_done = nfs4_delegreturn_done,
5685 .rpc_release = nfs4_delegreturn_release,
5688 static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)
5690 struct nfs4_delegreturndata *data;
5691 struct nfs_server *server = NFS_SERVER(inode);
5692 struct rpc_task *task;
5693 struct rpc_message msg = {
5694 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN],
5697 struct rpc_task_setup task_setup_data = {
5698 .rpc_client = server->client,
5699 .rpc_message = &msg,
5700 .callback_ops = &nfs4_delegreturn_ops,
5701 .flags = RPC_TASK_ASYNC,
5705 data = kzalloc(sizeof(*data), GFP_NOFS);
5708 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
5710 nfs4_state_protect(server->nfs_client,
5711 NFS_SP4_MACH_CRED_CLEANUP,
5712 &task_setup_data.rpc_client, &msg);
5714 data->args.fhandle = &data->fh;
5715 data->args.stateid = &data->stateid;
5716 data->args.bitmask = server->cache_consistency_bitmask;
5717 nfs_copy_fh(&data->fh, NFS_FH(inode));
5718 nfs4_stateid_copy(&data->stateid, stateid);
5719 data->res.fattr = &data->fattr;
5720 data->res.server = server;
5721 nfs_fattr_init(data->res.fattr);
5722 data->timestamp = jiffies;
5723 data->rpc_status = 0;
5724 data->inode = nfs_igrab_and_active(inode);
5726 data->roc = nfs4_roc(inode);
5728 task_setup_data.callback_data = data;
5729 msg.rpc_argp = &data->args;
5730 msg.rpc_resp = &data->res;
5731 task = rpc_run_task(&task_setup_data);
5733 return PTR_ERR(task);
5736 status = nfs4_wait_for_completion_rpc_task(task);
5739 status = data->rpc_status;
5741 nfs_post_op_update_inode_force_wcc(inode, &data->fattr);
5743 nfs_refresh_inode(inode, &data->fattr);
5749 int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)
5751 struct nfs_server *server = NFS_SERVER(inode);
5752 struct nfs4_exception exception = { };
5755 err = _nfs4_proc_delegreturn(inode, cred, stateid, issync);
5756 trace_nfs4_delegreturn(inode, stateid, err);
5758 case -NFS4ERR_STALE_STATEID:
5759 case -NFS4ERR_EXPIRED:
5763 err = nfs4_handle_exception(server, err, &exception);
5764 } while (exception.retry);
5768 static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
5770 struct inode *inode = state->inode;
5771 struct nfs_server *server = NFS_SERVER(inode);
5772 struct nfs_client *clp = server->nfs_client;
5773 struct nfs_lockt_args arg = {
5774 .fh = NFS_FH(inode),
5777 struct nfs_lockt_res res = {
5780 struct rpc_message msg = {
5781 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKT],
5784 .rpc_cred = state->owner->so_cred,
5786 struct nfs4_lock_state *lsp;
5789 arg.lock_owner.clientid = clp->cl_clientid;
5790 status = nfs4_set_lock_state(state, request);
5793 lsp = request->fl_u.nfs4_fl.owner;
5794 arg.lock_owner.id = lsp->ls_seqid.owner_id;
5795 arg.lock_owner.s_dev = server->s_dev;
5796 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
5799 request->fl_type = F_UNLCK;
5801 case -NFS4ERR_DENIED:
5804 request->fl_ops->fl_release_private(request);
5805 request->fl_ops = NULL;
5810 static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
5812 struct nfs4_exception exception = { };
5816 err = _nfs4_proc_getlk(state, cmd, request);
5817 trace_nfs4_get_lock(request, state, cmd, err);
5818 err = nfs4_handle_exception(NFS_SERVER(state->inode), err,
5820 } while (exception.retry);
5824 struct nfs4_unlockdata {
5825 struct nfs_locku_args arg;
5826 struct nfs_locku_res res;
5827 struct nfs4_lock_state *lsp;
5828 struct nfs_open_context *ctx;
5829 struct file_lock fl;
5830 struct nfs_server *server;
5831 unsigned long timestamp;
5834 static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,
5835 struct nfs_open_context *ctx,
5836 struct nfs4_lock_state *lsp,
5837 struct nfs_seqid *seqid)
5839 struct nfs4_unlockdata *p;
5840 struct inode *inode = lsp->ls_state->inode;
5842 p = kzalloc(sizeof(*p), GFP_NOFS);
5845 p->arg.fh = NFS_FH(inode);
5847 p->arg.seqid = seqid;
5848 p->res.seqid = seqid;
5850 atomic_inc(&lsp->ls_count);
5851 /* Ensure we don't close file until we're done freeing locks! */
5852 p->ctx = get_nfs_open_context(ctx);
5853 memcpy(&p->fl, fl, sizeof(p->fl));
5854 p->server = NFS_SERVER(inode);
5858 static void nfs4_locku_release_calldata(void *data)
5860 struct nfs4_unlockdata *calldata = data;
5861 nfs_free_seqid(calldata->arg.seqid);
5862 nfs4_put_lock_state(calldata->lsp);
5863 put_nfs_open_context(calldata->ctx);
5867 static void nfs4_locku_done(struct rpc_task *task, void *data)
5869 struct nfs4_unlockdata *calldata = data;
5871 if (!nfs4_sequence_done(task, &calldata->res.seq_res))
5873 switch (task->tk_status) {
5875 renew_lease(calldata->server, calldata->timestamp);
5876 locks_lock_inode_wait(calldata->lsp->ls_state->inode, &calldata->fl);
5877 if (nfs4_update_lock_stateid(calldata->lsp,
5878 &calldata->res.stateid))
5880 case -NFS4ERR_ADMIN_REVOKED:
5881 case -NFS4ERR_EXPIRED:
5882 nfs4_free_revoked_stateid(calldata->server,
5883 &calldata->arg.stateid,
5884 task->tk_msg.rpc_cred);
5885 case -NFS4ERR_BAD_STATEID:
5886 case -NFS4ERR_OLD_STATEID:
5887 case -NFS4ERR_STALE_STATEID:
5888 if (!nfs4_stateid_match(&calldata->arg.stateid,
5889 &calldata->lsp->ls_stateid))
5890 rpc_restart_call_prepare(task);
5893 if (nfs4_async_handle_error(task, calldata->server,
5894 NULL, NULL) == -EAGAIN)
5895 rpc_restart_call_prepare(task);
5897 nfs_release_seqid(calldata->arg.seqid);
5900 static void nfs4_locku_prepare(struct rpc_task *task, void *data)
5902 struct nfs4_unlockdata *calldata = data;
5904 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
5906 nfs4_stateid_copy(&calldata->arg.stateid, &calldata->lsp->ls_stateid);
5907 if (test_bit(NFS_LOCK_INITIALIZED, &calldata->lsp->ls_flags) == 0) {
5908 /* Note: exit _without_ running nfs4_locku_done */
5911 calldata->timestamp = jiffies;
5912 if (nfs4_setup_sequence(calldata->server,
5913 &calldata->arg.seq_args,
5914 &calldata->res.seq_res,
5916 nfs_release_seqid(calldata->arg.seqid);
5919 task->tk_action = NULL;
5921 nfs4_sequence_done(task, &calldata->res.seq_res);
5924 static const struct rpc_call_ops nfs4_locku_ops = {
5925 .rpc_call_prepare = nfs4_locku_prepare,
5926 .rpc_call_done = nfs4_locku_done,
5927 .rpc_release = nfs4_locku_release_calldata,
5930 static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,
5931 struct nfs_open_context *ctx,
5932 struct nfs4_lock_state *lsp,
5933 struct nfs_seqid *seqid)
5935 struct nfs4_unlockdata *data;
5936 struct rpc_message msg = {
5937 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKU],
5938 .rpc_cred = ctx->cred,
5940 struct rpc_task_setup task_setup_data = {
5941 .rpc_client = NFS_CLIENT(lsp->ls_state->inode),
5942 .rpc_message = &msg,
5943 .callback_ops = &nfs4_locku_ops,
5944 .workqueue = nfsiod_workqueue,
5945 .flags = RPC_TASK_ASYNC,
5948 nfs4_state_protect(NFS_SERVER(lsp->ls_state->inode)->nfs_client,
5949 NFS_SP4_MACH_CRED_CLEANUP, &task_setup_data.rpc_client, &msg);
5951 /* Ensure this is an unlock - when canceling a lock, the
5952 * canceled lock is passed in, and it won't be an unlock.
5954 fl->fl_type = F_UNLCK;
5956 data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid);
5958 nfs_free_seqid(seqid);
5959 return ERR_PTR(-ENOMEM);
5962 nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1);
5963 msg.rpc_argp = &data->arg;
5964 msg.rpc_resp = &data->res;
5965 task_setup_data.callback_data = data;
5966 return rpc_run_task(&task_setup_data);
5969 static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *request)
5971 struct inode *inode = state->inode;
5972 struct nfs4_state_owner *sp = state->owner;
5973 struct nfs_inode *nfsi = NFS_I(inode);
5974 struct nfs_seqid *seqid;
5975 struct nfs4_lock_state *lsp;
5976 struct rpc_task *task;
5977 struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
5979 unsigned char fl_flags = request->fl_flags;
5981 status = nfs4_set_lock_state(state, request);
5982 /* Unlock _before_ we do the RPC call */
5983 request->fl_flags |= FL_EXISTS;
5984 /* Exclude nfs_delegation_claim_locks() */
5985 mutex_lock(&sp->so_delegreturn_mutex);
5986 /* Exclude nfs4_reclaim_open_stateid() - note nesting! */
5987 down_read(&nfsi->rwsem);
5988 if (locks_lock_inode_wait(inode, request) == -ENOENT) {
5989 up_read(&nfsi->rwsem);
5990 mutex_unlock(&sp->so_delegreturn_mutex);
5993 up_read(&nfsi->rwsem);
5994 mutex_unlock(&sp->so_delegreturn_mutex);
5997 /* Is this a delegated lock? */
5998 lsp = request->fl_u.nfs4_fl.owner;
5999 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) == 0)
6001 alloc_seqid = NFS_SERVER(inode)->nfs_client->cl_mvops->alloc_seqid;
6002 seqid = alloc_seqid(&lsp->ls_seqid, GFP_KERNEL);
6006 task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid);
6007 status = PTR_ERR(task);
6010 status = nfs4_wait_for_completion_rpc_task(task);
6013 request->fl_flags = fl_flags;
6014 trace_nfs4_unlock(request, state, F_SETLK, status);
6018 struct nfs4_lockdata {
6019 struct nfs_lock_args arg;
6020 struct nfs_lock_res res;
6021 struct nfs4_lock_state *lsp;
6022 struct nfs_open_context *ctx;
6023 struct file_lock fl;
6024 unsigned long timestamp;
6027 struct nfs_server *server;
6030 static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl,
6031 struct nfs_open_context *ctx, struct nfs4_lock_state *lsp,
6034 struct nfs4_lockdata *p;
6035 struct inode *inode = lsp->ls_state->inode;
6036 struct nfs_server *server = NFS_SERVER(inode);
6037 struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
6039 p = kzalloc(sizeof(*p), gfp_mask);
6043 p->arg.fh = NFS_FH(inode);
6045 p->arg.open_seqid = nfs_alloc_seqid(&lsp->ls_state->owner->so_seqid, gfp_mask);
6046 if (IS_ERR(p->arg.open_seqid))
6048 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;
6049 p->arg.lock_seqid = alloc_seqid(&lsp->ls_seqid, gfp_mask);
6050 if (IS_ERR(p->arg.lock_seqid))
6051 goto out_free_seqid;
6052 p->arg.lock_owner.clientid = server->nfs_client->cl_clientid;
6053 p->arg.lock_owner.id = lsp->ls_seqid.owner_id;
6054 p->arg.lock_owner.s_dev = server->s_dev;
6055 p->res.lock_seqid = p->arg.lock_seqid;
6058 atomic_inc(&lsp->ls_count);
6059 p->ctx = get_nfs_open_context(ctx);
6060 memcpy(&p->fl, fl, sizeof(p->fl));
6063 nfs_free_seqid(p->arg.open_seqid);
6069 static void nfs4_lock_prepare(struct rpc_task *task, void *calldata)
6071 struct nfs4_lockdata *data = calldata;
6072 struct nfs4_state *state = data->lsp->ls_state;
6074 dprintk("%s: begin!\n", __func__);
6075 if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0)
6077 /* Do we need to do an open_to_lock_owner? */
6078 if (!test_bit(NFS_LOCK_INITIALIZED, &data->lsp->ls_flags)) {
6079 if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0) {
6080 goto out_release_lock_seqid;
6082 nfs4_stateid_copy(&data->arg.open_stateid,
6083 &state->open_stateid);
6084 data->arg.new_lock_owner = 1;
6085 data->res.open_seqid = data->arg.open_seqid;
6087 data->arg.new_lock_owner = 0;
6088 nfs4_stateid_copy(&data->arg.lock_stateid,
6089 &data->lsp->ls_stateid);
6091 if (!nfs4_valid_open_stateid(state)) {
6092 data->rpc_status = -EBADF;
6093 task->tk_action = NULL;
6094 goto out_release_open_seqid;
6096 data->timestamp = jiffies;
6097 if (nfs4_setup_sequence(data->server,
6098 &data->arg.seq_args,
6102 out_release_open_seqid:
6103 nfs_release_seqid(data->arg.open_seqid);
6104 out_release_lock_seqid:
6105 nfs_release_seqid(data->arg.lock_seqid);
6107 nfs4_sequence_done(task, &data->res.seq_res);
6108 dprintk("%s: done!, ret = %d\n", __func__, data->rpc_status);
6111 static void nfs4_lock_done(struct rpc_task *task, void *calldata)
6113 struct nfs4_lockdata *data = calldata;
6114 struct nfs4_lock_state *lsp = data->lsp;
6116 dprintk("%s: begin!\n", __func__);
6118 if (!nfs4_sequence_done(task, &data->res.seq_res))
6121 data->rpc_status = task->tk_status;
6122 switch (task->tk_status) {
6124 renew_lease(NFS_SERVER(d_inode(data->ctx->dentry)),
6126 if (data->arg.new_lock) {
6127 data->fl.fl_flags &= ~(FL_SLEEP | FL_ACCESS);
6128 if (locks_lock_inode_wait(lsp->ls_state->inode, &data->fl) < 0) {
6129 rpc_restart_call_prepare(task);
6133 if (data->arg.new_lock_owner != 0) {
6134 nfs_confirm_seqid(&lsp->ls_seqid, 0);
6135 nfs4_stateid_copy(&lsp->ls_stateid, &data->res.stateid);
6136 set_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags);
6137 } else if (!nfs4_update_lock_stateid(lsp, &data->res.stateid))
6138 rpc_restart_call_prepare(task);
6140 case -NFS4ERR_BAD_STATEID:
6141 case -NFS4ERR_OLD_STATEID:
6142 case -NFS4ERR_STALE_STATEID:
6143 case -NFS4ERR_EXPIRED:
6144 if (data->arg.new_lock_owner != 0) {
6145 if (!nfs4_stateid_match(&data->arg.open_stateid,
6146 &lsp->ls_state->open_stateid))
6147 rpc_restart_call_prepare(task);
6148 } else if (!nfs4_stateid_match(&data->arg.lock_stateid,
6150 rpc_restart_call_prepare(task);
6152 dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status);
6155 static void nfs4_lock_release(void *calldata)
6157 struct nfs4_lockdata *data = calldata;
6159 dprintk("%s: begin!\n", __func__);
6160 nfs_free_seqid(data->arg.open_seqid);
6161 if (data->cancelled != 0) {
6162 struct rpc_task *task;
6163 task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp,
6164 data->arg.lock_seqid);
6166 rpc_put_task_async(task);
6167 dprintk("%s: cancelling lock!\n", __func__);
6169 nfs_free_seqid(data->arg.lock_seqid);
6170 nfs4_put_lock_state(data->lsp);
6171 put_nfs_open_context(data->ctx);
6173 dprintk("%s: done!\n", __func__);
6176 static const struct rpc_call_ops nfs4_lock_ops = {
6177 .rpc_call_prepare = nfs4_lock_prepare,
6178 .rpc_call_done = nfs4_lock_done,
6179 .rpc_release = nfs4_lock_release,
6182 static void nfs4_handle_setlk_error(struct nfs_server *server, struct nfs4_lock_state *lsp, int new_lock_owner, int error)
6185 case -NFS4ERR_ADMIN_REVOKED:
6186 case -NFS4ERR_EXPIRED:
6187 case -NFS4ERR_BAD_STATEID:
6188 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;
6189 if (new_lock_owner != 0 ||
6190 test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0)
6191 nfs4_schedule_stateid_recovery(server, lsp->ls_state);
6193 case -NFS4ERR_STALE_STATEID:
6194 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;
6195 nfs4_schedule_lease_recovery(server->nfs_client);
6199 static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int recovery_type)
6201 struct nfs4_lockdata *data;
6202 struct rpc_task *task;
6203 struct rpc_message msg = {
6204 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCK],
6205 .rpc_cred = state->owner->so_cred,
6207 struct rpc_task_setup task_setup_data = {
6208 .rpc_client = NFS_CLIENT(state->inode),
6209 .rpc_message = &msg,
6210 .callback_ops = &nfs4_lock_ops,
6211 .workqueue = nfsiod_workqueue,
6212 .flags = RPC_TASK_ASYNC,
6216 dprintk("%s: begin!\n", __func__);
6217 data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file),
6218 fl->fl_u.nfs4_fl.owner,
6219 recovery_type == NFS_LOCK_NEW ? GFP_KERNEL : GFP_NOFS);
6223 data->arg.block = 1;
6224 nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1);
6225 msg.rpc_argp = &data->arg;
6226 msg.rpc_resp = &data->res;
6227 task_setup_data.callback_data = data;
6228 if (recovery_type > NFS_LOCK_NEW) {
6229 if (recovery_type == NFS_LOCK_RECLAIM)
6230 data->arg.reclaim = NFS_LOCK_RECLAIM;
6231 nfs4_set_sequence_privileged(&data->arg.seq_args);
6233 data->arg.new_lock = 1;
6234 task = rpc_run_task(&task_setup_data);
6236 return PTR_ERR(task);
6237 ret = nfs4_wait_for_completion_rpc_task(task);
6239 ret = data->rpc_status;
6241 nfs4_handle_setlk_error(data->server, data->lsp,
6242 data->arg.new_lock_owner, ret);
6244 data->cancelled = 1;
6246 dprintk("%s: done, ret = %d!\n", __func__, ret);
6247 trace_nfs4_set_lock(fl, state, &data->res.stateid, cmd, ret);
6251 static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request)
6253 struct nfs_server *server = NFS_SERVER(state->inode);
6254 struct nfs4_exception exception = {
6255 .inode = state->inode,
6260 /* Cache the lock if possible... */
6261 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
6263 err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_RECLAIM);
6264 if (err != -NFS4ERR_DELAY)
6266 nfs4_handle_exception(server, err, &exception);
6267 } while (exception.retry);
6271 static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request)
6273 struct nfs_server *server = NFS_SERVER(state->inode);
6274 struct nfs4_exception exception = {
6275 .inode = state->inode,
6279 err = nfs4_set_lock_state(state, request);
6282 if (!recover_lost_locks) {
6283 set_bit(NFS_LOCK_LOST, &request->fl_u.nfs4_fl.owner->ls_flags);
6287 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
6289 err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_EXPIRED);
6293 case -NFS4ERR_GRACE:
6294 case -NFS4ERR_DELAY:
6295 nfs4_handle_exception(server, err, &exception);
6298 } while (exception.retry);
6303 #if defined(CONFIG_NFS_V4_1)
6304 static int nfs41_lock_expired(struct nfs4_state *state, struct file_lock *request)
6306 struct nfs4_lock_state *lsp;
6309 status = nfs4_set_lock_state(state, request);
6312 lsp = request->fl_u.nfs4_fl.owner;
6313 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) ||
6314 test_bit(NFS_LOCK_LOST, &lsp->ls_flags))
6316 status = nfs4_lock_expired(state, request);
6321 static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
6323 struct nfs_inode *nfsi = NFS_I(state->inode);
6324 struct nfs4_state_owner *sp = state->owner;
6325 unsigned char fl_flags = request->fl_flags;
6328 request->fl_flags |= FL_ACCESS;
6329 status = locks_lock_inode_wait(state->inode, request);
6332 mutex_lock(&sp->so_delegreturn_mutex);
6333 down_read(&nfsi->rwsem);
6334 if (test_bit(NFS_DELEGATED_STATE, &state->flags)) {
6335 /* Yes: cache locks! */
6336 /* ...but avoid races with delegation recall... */
6337 request->fl_flags = fl_flags & ~FL_SLEEP;
6338 status = locks_lock_inode_wait(state->inode, request);
6339 up_read(&nfsi->rwsem);
6340 mutex_unlock(&sp->so_delegreturn_mutex);
6343 up_read(&nfsi->rwsem);
6344 mutex_unlock(&sp->so_delegreturn_mutex);
6345 status = _nfs4_do_setlk(state, cmd, request, NFS_LOCK_NEW);
6347 request->fl_flags = fl_flags;
6351 static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
6353 struct nfs4_exception exception = {
6355 .inode = state->inode,
6360 err = _nfs4_proc_setlk(state, cmd, request);
6361 if (err == -NFS4ERR_DENIED)
6363 err = nfs4_handle_exception(NFS_SERVER(state->inode),
6365 } while (exception.retry);
6369 #define NFS4_LOCK_MINTIMEOUT (1 * HZ)
6370 #define NFS4_LOCK_MAXTIMEOUT (30 * HZ)
6373 nfs4_retry_setlk_simple(struct nfs4_state *state, int cmd,
6374 struct file_lock *request)
6376 int status = -ERESTARTSYS;
6377 unsigned long timeout = NFS4_LOCK_MINTIMEOUT;
6379 while(!signalled()) {
6380 status = nfs4_proc_setlk(state, cmd, request);
6381 if ((status != -EAGAIN) || IS_SETLK(cmd))
6383 freezable_schedule_timeout_interruptible(timeout);
6385 timeout = min_t(unsigned long, NFS4_LOCK_MAXTIMEOUT, timeout);
6386 status = -ERESTARTSYS;
6391 #ifdef CONFIG_NFS_V4_1
6392 struct nfs4_lock_waiter {
6393 struct task_struct *task;
6394 struct inode *inode;
6395 struct nfs_lowner *owner;
6400 nfs4_wake_lock_waiter(wait_queue_t *wait, unsigned int mode, int flags, void *key)
6403 struct cb_notify_lock_args *cbnl = key;
6404 struct nfs4_lock_waiter *waiter = wait->private;
6405 struct nfs_lowner *lowner = &cbnl->cbnl_owner,
6406 *wowner = waiter->owner;
6408 /* Only wake if the callback was for the same owner */
6409 if (lowner->clientid != wowner->clientid ||
6410 lowner->id != wowner->id ||
6411 lowner->s_dev != wowner->s_dev)
6414 /* Make sure it's for the right inode */
6415 if (nfs_compare_fh(NFS_FH(waiter->inode), &cbnl->cbnl_fh))
6418 waiter->notified = true;
6420 /* override "private" so we can use default_wake_function */
6421 wait->private = waiter->task;
6422 ret = autoremove_wake_function(wait, mode, flags, key);
6423 wait->private = waiter;
6428 nfs4_retry_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
6430 int status = -ERESTARTSYS;
6431 unsigned long flags;
6432 struct nfs4_lock_state *lsp = request->fl_u.nfs4_fl.owner;
6433 struct nfs_server *server = NFS_SERVER(state->inode);
6434 struct nfs_client *clp = server->nfs_client;
6435 wait_queue_head_t *q = &clp->cl_lock_waitq;
6436 struct nfs_lowner owner = { .clientid = clp->cl_clientid,
6437 .id = lsp->ls_seqid.owner_id,
6438 .s_dev = server->s_dev };
6439 struct nfs4_lock_waiter waiter = { .task = current,
6440 .inode = state->inode,
6442 .notified = false };
6445 /* Don't bother with waitqueue if we don't expect a callback */
6446 if (!test_bit(NFS_STATE_MAY_NOTIFY_LOCK, &state->flags))
6447 return nfs4_retry_setlk_simple(state, cmd, request);
6450 wait.private = &waiter;
6451 wait.func = nfs4_wake_lock_waiter;
6452 add_wait_queue(q, &wait);
6454 while(!signalled()) {
6455 status = nfs4_proc_setlk(state, cmd, request);
6456 if ((status != -EAGAIN) || IS_SETLK(cmd))
6459 status = -ERESTARTSYS;
6460 spin_lock_irqsave(&q->lock, flags);
6461 if (waiter.notified) {
6462 spin_unlock_irqrestore(&q->lock, flags);
6465 set_current_state(TASK_INTERRUPTIBLE);
6466 spin_unlock_irqrestore(&q->lock, flags);
6468 freezable_schedule_timeout(NFS4_LOCK_MAXTIMEOUT);
6471 finish_wait(q, &wait);
6474 #else /* !CONFIG_NFS_V4_1 */
6476 nfs4_retry_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
6478 return nfs4_retry_setlk_simple(state, cmd, request);
6483 nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request)
6485 struct nfs_open_context *ctx;
6486 struct nfs4_state *state;
6489 /* verify open state */
6490 ctx = nfs_file_open_context(filp);
6493 if (request->fl_start < 0 || request->fl_end < 0)
6496 if (IS_GETLK(cmd)) {
6498 return nfs4_proc_getlk(state, F_GETLK, request);
6502 if (!(IS_SETLK(cmd) || IS_SETLKW(cmd)))
6505 if (request->fl_type == F_UNLCK) {
6507 return nfs4_proc_unlck(state, cmd, request);
6514 if ((request->fl_flags & FL_POSIX) &&
6515 !test_bit(NFS_STATE_POSIX_LOCKS, &state->flags))
6519 * Don't rely on the VFS having checked the file open mode,
6520 * since it won't do this for flock() locks.
6522 switch (request->fl_type) {
6524 if (!(filp->f_mode & FMODE_READ))
6528 if (!(filp->f_mode & FMODE_WRITE))
6532 status = nfs4_set_lock_state(state, request);
6536 return nfs4_retry_setlk(state, cmd, request);
6539 int nfs4_lock_delegation_recall(struct file_lock *fl, struct nfs4_state *state, const nfs4_stateid *stateid)
6541 struct nfs_server *server = NFS_SERVER(state->inode);
6544 err = nfs4_set_lock_state(state, fl);
6548 err = _nfs4_do_setlk(state, F_SETLK, fl, NFS_LOCK_NEW);
6549 if (err != -NFS4ERR_DELAY)
6552 } while (err == -NFS4ERR_DELAY);
6553 return nfs4_handle_delegation_recall_error(server, state, stateid, fl, err);
6556 struct nfs_release_lockowner_data {
6557 struct nfs4_lock_state *lsp;
6558 struct nfs_server *server;
6559 struct nfs_release_lockowner_args args;
6560 struct nfs_release_lockowner_res res;
6561 unsigned long timestamp;
6564 static void nfs4_release_lockowner_prepare(struct rpc_task *task, void *calldata)
6566 struct nfs_release_lockowner_data *data = calldata;
6567 struct nfs_server *server = data->server;
6568 nfs40_setup_sequence(server->nfs_client->cl_slot_tbl,
6569 &data->args.seq_args, &data->res.seq_res, task);
6570 data->args.lock_owner.clientid = server->nfs_client->cl_clientid;
6571 data->timestamp = jiffies;
6574 static void nfs4_release_lockowner_done(struct rpc_task *task, void *calldata)
6576 struct nfs_release_lockowner_data *data = calldata;
6577 struct nfs_server *server = data->server;
6579 nfs40_sequence_done(task, &data->res.seq_res);
6581 switch (task->tk_status) {
6583 renew_lease(server, data->timestamp);
6585 case -NFS4ERR_STALE_CLIENTID:
6586 case -NFS4ERR_EXPIRED:
6587 nfs4_schedule_lease_recovery(server->nfs_client);
6589 case -NFS4ERR_LEASE_MOVED:
6590 case -NFS4ERR_DELAY:
6591 if (nfs4_async_handle_error(task, server,
6592 NULL, NULL) == -EAGAIN)
6593 rpc_restart_call_prepare(task);
6597 static void nfs4_release_lockowner_release(void *calldata)
6599 struct nfs_release_lockowner_data *data = calldata;
6600 nfs4_free_lock_state(data->server, data->lsp);
6604 static const struct rpc_call_ops nfs4_release_lockowner_ops = {
6605 .rpc_call_prepare = nfs4_release_lockowner_prepare,
6606 .rpc_call_done = nfs4_release_lockowner_done,
6607 .rpc_release = nfs4_release_lockowner_release,
6611 nfs4_release_lockowner(struct nfs_server *server, struct nfs4_lock_state *lsp)
6613 struct nfs_release_lockowner_data *data;
6614 struct rpc_message msg = {
6615 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RELEASE_LOCKOWNER],
6618 if (server->nfs_client->cl_mvops->minor_version != 0)
6621 data = kmalloc(sizeof(*data), GFP_NOFS);
6625 data->server = server;
6626 data->args.lock_owner.clientid = server->nfs_client->cl_clientid;
6627 data->args.lock_owner.id = lsp->ls_seqid.owner_id;
6628 data->args.lock_owner.s_dev = server->s_dev;
6630 msg.rpc_argp = &data->args;
6631 msg.rpc_resp = &data->res;
6632 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0);
6633 rpc_call_async(server->client, &msg, 0, &nfs4_release_lockowner_ops, data);
6636 #define XATTR_NAME_NFSV4_ACL "system.nfs4_acl"
6638 static int nfs4_xattr_set_nfs4_acl(const struct xattr_handler *handler,
6639 struct dentry *unused, struct inode *inode,
6640 const char *key, const void *buf,
6641 size_t buflen, int flags)
6643 return nfs4_proc_set_acl(inode, buf, buflen);
6646 static int nfs4_xattr_get_nfs4_acl(const struct xattr_handler *handler,
6647 struct dentry *unused, struct inode *inode,
6648 const char *key, void *buf, size_t buflen)
6650 return nfs4_proc_get_acl(inode, buf, buflen);
6653 static bool nfs4_xattr_list_nfs4_acl(struct dentry *dentry)
6655 return nfs4_server_supports_acls(NFS_SERVER(d_inode(dentry)));
6658 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
6660 static int nfs4_xattr_set_nfs4_label(const struct xattr_handler *handler,
6661 struct dentry *unused, struct inode *inode,
6662 const char *key, const void *buf,
6663 size_t buflen, int flags)
6665 if (security_ismaclabel(key))
6666 return nfs4_set_security_label(inode, buf, buflen);
6671 static int nfs4_xattr_get_nfs4_label(const struct xattr_handler *handler,
6672 struct dentry *unused, struct inode *inode,
6673 const char *key, void *buf, size_t buflen)
6675 if (security_ismaclabel(key))
6676 return nfs4_get_security_label(inode, buf, buflen);
6681 nfs4_listxattr_nfs4_label(struct inode *inode, char *list, size_t list_len)
6685 if (nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL)) {
6686 len = security_inode_listsecurity(inode, list, list_len);
6687 if (list_len && len > list_len)
6693 static const struct xattr_handler nfs4_xattr_nfs4_label_handler = {
6694 .prefix = XATTR_SECURITY_PREFIX,
6695 .get = nfs4_xattr_get_nfs4_label,
6696 .set = nfs4_xattr_set_nfs4_label,
6702 nfs4_listxattr_nfs4_label(struct inode *inode, char *list, size_t list_len)
6710 * nfs_fhget will use either the mounted_on_fileid or the fileid
6712 static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr)
6714 if (!(((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) ||
6715 (fattr->valid & NFS_ATTR_FATTR_FILEID)) &&
6716 (fattr->valid & NFS_ATTR_FATTR_FSID) &&
6717 (fattr->valid & NFS_ATTR_FATTR_V4_LOCATIONS)))
6720 fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |
6721 NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_V4_REFERRAL;
6722 fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;
6726 static int _nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir,
6727 const struct qstr *name,
6728 struct nfs4_fs_locations *fs_locations,
6731 struct nfs_server *server = NFS_SERVER(dir);
6733 struct nfs4_fs_locations_arg args = {
6734 .dir_fh = NFS_FH(dir),
6739 struct nfs4_fs_locations_res res = {
6740 .fs_locations = fs_locations,
6742 struct rpc_message msg = {
6743 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
6749 dprintk("%s: start\n", __func__);
6751 bitmask[0] = nfs4_fattr_bitmap[0] | FATTR4_WORD0_FS_LOCATIONS;
6752 bitmask[1] = nfs4_fattr_bitmap[1];
6754 /* Ask for the fileid of the absent filesystem if mounted_on_fileid
6755 * is not supported */
6756 if (NFS_SERVER(dir)->attr_bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)
6757 bitmask[0] &= ~FATTR4_WORD0_FILEID;
6759 bitmask[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID;
6761 nfs_fattr_init(&fs_locations->fattr);
6762 fs_locations->server = server;
6763 fs_locations->nlocations = 0;
6764 status = nfs4_call_sync(client, server, &msg, &args.seq_args, &res.seq_res, 0);
6765 dprintk("%s: returned status = %d\n", __func__, status);
6769 int nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir,
6770 const struct qstr *name,
6771 struct nfs4_fs_locations *fs_locations,
6774 struct nfs4_exception exception = { };
6777 err = _nfs4_proc_fs_locations(client, dir, name,
6778 fs_locations, page);
6779 trace_nfs4_get_fs_locations(dir, name, err);
6780 err = nfs4_handle_exception(NFS_SERVER(dir), err,
6782 } while (exception.retry);
6787 * This operation also signals the server that this client is
6788 * performing migration recovery. The server can stop returning
6789 * NFS4ERR_LEASE_MOVED to this client. A RENEW operation is
6790 * appended to this compound to identify the client ID which is
6791 * performing recovery.
6793 static int _nfs40_proc_get_locations(struct inode *inode,
6794 struct nfs4_fs_locations *locations,
6795 struct page *page, struct rpc_cred *cred)
6797 struct nfs_server *server = NFS_SERVER(inode);
6798 struct rpc_clnt *clnt = server->client;
6800 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
6802 struct nfs4_fs_locations_arg args = {
6803 .clientid = server->nfs_client->cl_clientid,
6804 .fh = NFS_FH(inode),
6807 .migration = 1, /* skip LOOKUP */
6808 .renew = 1, /* append RENEW */
6810 struct nfs4_fs_locations_res res = {
6811 .fs_locations = locations,
6815 struct rpc_message msg = {
6816 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
6821 unsigned long now = jiffies;
6824 nfs_fattr_init(&locations->fattr);
6825 locations->server = server;
6826 locations->nlocations = 0;
6828 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
6829 nfs4_set_sequence_privileged(&args.seq_args);
6830 status = nfs4_call_sync_sequence(clnt, server, &msg,
6831 &args.seq_args, &res.seq_res);
6835 renew_lease(server, now);
6839 #ifdef CONFIG_NFS_V4_1
6842 * This operation also signals the server that this client is
6843 * performing migration recovery. The server can stop asserting
6844 * SEQ4_STATUS_LEASE_MOVED for this client. The client ID
6845 * performing this operation is identified in the SEQUENCE
6846 * operation in this compound.
6848 * When the client supports GETATTR(fs_locations_info), it can
6849 * be plumbed in here.
6851 static int _nfs41_proc_get_locations(struct inode *inode,
6852 struct nfs4_fs_locations *locations,
6853 struct page *page, struct rpc_cred *cred)
6855 struct nfs_server *server = NFS_SERVER(inode);
6856 struct rpc_clnt *clnt = server->client;
6858 [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
6860 struct nfs4_fs_locations_arg args = {
6861 .fh = NFS_FH(inode),
6864 .migration = 1, /* skip LOOKUP */
6866 struct nfs4_fs_locations_res res = {
6867 .fs_locations = locations,
6870 struct rpc_message msg = {
6871 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
6878 nfs_fattr_init(&locations->fattr);
6879 locations->server = server;
6880 locations->nlocations = 0;
6882 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
6883 nfs4_set_sequence_privileged(&args.seq_args);
6884 status = nfs4_call_sync_sequence(clnt, server, &msg,
6885 &args.seq_args, &res.seq_res);
6886 if (status == NFS4_OK &&
6887 res.seq_res.sr_status_flags & SEQ4_STATUS_LEASE_MOVED)
6888 status = -NFS4ERR_LEASE_MOVED;
6892 #endif /* CONFIG_NFS_V4_1 */
6895 * nfs4_proc_get_locations - discover locations for a migrated FSID
6896 * @inode: inode on FSID that is migrating
6897 * @locations: result of query
6899 * @cred: credential to use for this operation
6901 * Returns NFS4_OK on success, a negative NFS4ERR status code if the
6902 * operation failed, or a negative errno if a local error occurred.
6904 * On success, "locations" is filled in, but if the server has
6905 * no locations information, NFS_ATTR_FATTR_V4_LOCATIONS is not
6908 * -NFS4ERR_LEASE_MOVED is returned if the server still has leases
6909 * from this client that require migration recovery.
6911 int nfs4_proc_get_locations(struct inode *inode,
6912 struct nfs4_fs_locations *locations,
6913 struct page *page, struct rpc_cred *cred)
6915 struct nfs_server *server = NFS_SERVER(inode);
6916 struct nfs_client *clp = server->nfs_client;
6917 const struct nfs4_mig_recovery_ops *ops =
6918 clp->cl_mvops->mig_recovery_ops;
6919 struct nfs4_exception exception = { };
6922 dprintk("%s: FSID %llx:%llx on \"%s\"\n", __func__,
6923 (unsigned long long)server->fsid.major,
6924 (unsigned long long)server->fsid.minor,
6926 nfs_display_fhandle(NFS_FH(inode), __func__);
6929 status = ops->get_locations(inode, locations, page, cred);
6930 if (status != -NFS4ERR_DELAY)
6932 nfs4_handle_exception(server, status, &exception);
6933 } while (exception.retry);
6938 * This operation also signals the server that this client is
6939 * performing "lease moved" recovery. The server can stop
6940 * returning NFS4ERR_LEASE_MOVED to this client. A RENEW operation
6941 * is appended to this compound to identify the client ID which is
6942 * performing recovery.
6944 static int _nfs40_proc_fsid_present(struct inode *inode, struct rpc_cred *cred)
6946 struct nfs_server *server = NFS_SERVER(inode);
6947 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
6948 struct rpc_clnt *clnt = server->client;
6949 struct nfs4_fsid_present_arg args = {
6950 .fh = NFS_FH(inode),
6951 .clientid = clp->cl_clientid,
6952 .renew = 1, /* append RENEW */
6954 struct nfs4_fsid_present_res res = {
6957 struct rpc_message msg = {
6958 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSID_PRESENT],
6963 unsigned long now = jiffies;
6966 res.fh = nfs_alloc_fhandle();
6970 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
6971 nfs4_set_sequence_privileged(&args.seq_args);
6972 status = nfs4_call_sync_sequence(clnt, server, &msg,
6973 &args.seq_args, &res.seq_res);
6974 nfs_free_fhandle(res.fh);
6978 do_renew_lease(clp, now);
6982 #ifdef CONFIG_NFS_V4_1
6985 * This operation also signals the server that this client is
6986 * performing "lease moved" recovery. The server can stop asserting
6987 * SEQ4_STATUS_LEASE_MOVED for this client. The client ID performing
6988 * this operation is identified in the SEQUENCE operation in this
6991 static int _nfs41_proc_fsid_present(struct inode *inode, struct rpc_cred *cred)
6993 struct nfs_server *server = NFS_SERVER(inode);
6994 struct rpc_clnt *clnt = server->client;
6995 struct nfs4_fsid_present_arg args = {
6996 .fh = NFS_FH(inode),
6998 struct nfs4_fsid_present_res res = {
7000 struct rpc_message msg = {
7001 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSID_PRESENT],
7008 res.fh = nfs_alloc_fhandle();
7012 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
7013 nfs4_set_sequence_privileged(&args.seq_args);
7014 status = nfs4_call_sync_sequence(clnt, server, &msg,
7015 &args.seq_args, &res.seq_res);
7016 nfs_free_fhandle(res.fh);
7017 if (status == NFS4_OK &&
7018 res.seq_res.sr_status_flags & SEQ4_STATUS_LEASE_MOVED)
7019 status = -NFS4ERR_LEASE_MOVED;
7023 #endif /* CONFIG_NFS_V4_1 */
7026 * nfs4_proc_fsid_present - Is this FSID present or absent on server?
7027 * @inode: inode on FSID to check
7028 * @cred: credential to use for this operation
7030 * Server indicates whether the FSID is present, moved, or not
7031 * recognized. This operation is necessary to clear a LEASE_MOVED
7032 * condition for this client ID.
7034 * Returns NFS4_OK if the FSID is present on this server,
7035 * -NFS4ERR_MOVED if the FSID is no longer present, a negative
7036 * NFS4ERR code if some error occurred on the server, or a
7037 * negative errno if a local failure occurred.
7039 int nfs4_proc_fsid_present(struct inode *inode, struct rpc_cred *cred)
7041 struct nfs_server *server = NFS_SERVER(inode);
7042 struct nfs_client *clp = server->nfs_client;
7043 const struct nfs4_mig_recovery_ops *ops =
7044 clp->cl_mvops->mig_recovery_ops;
7045 struct nfs4_exception exception = { };
7048 dprintk("%s: FSID %llx:%llx on \"%s\"\n", __func__,
7049 (unsigned long long)server->fsid.major,
7050 (unsigned long long)server->fsid.minor,
7052 nfs_display_fhandle(NFS_FH(inode), __func__);
7055 status = ops->fsid_present(inode, cred);
7056 if (status != -NFS4ERR_DELAY)
7058 nfs4_handle_exception(server, status, &exception);
7059 } while (exception.retry);
7064 * If 'use_integrity' is true and the state managment nfs_client
7065 * cl_rpcclient is using krb5i/p, use the integrity protected cl_rpcclient
7066 * and the machine credential as per RFC3530bis and RFC5661 Security
7067 * Considerations sections. Otherwise, just use the user cred with the
7068 * filesystem's rpc_client.
7070 static int _nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct nfs4_secinfo_flavors *flavors, bool use_integrity)
7073 struct nfs4_secinfo_arg args = {
7074 .dir_fh = NFS_FH(dir),
7077 struct nfs4_secinfo_res res = {
7080 struct rpc_message msg = {
7081 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO],
7085 struct rpc_clnt *clnt = NFS_SERVER(dir)->client;
7086 struct rpc_cred *cred = NULL;
7088 if (use_integrity) {
7089 clnt = NFS_SERVER(dir)->nfs_client->cl_rpcclient;
7090 cred = nfs4_get_clid_cred(NFS_SERVER(dir)->nfs_client);
7091 msg.rpc_cred = cred;
7094 dprintk("NFS call secinfo %s\n", name->name);
7096 nfs4_state_protect(NFS_SERVER(dir)->nfs_client,
7097 NFS_SP4_MACH_CRED_SECINFO, &clnt, &msg);
7099 status = nfs4_call_sync(clnt, NFS_SERVER(dir), &msg, &args.seq_args,
7101 dprintk("NFS reply secinfo: %d\n", status);
7109 int nfs4_proc_secinfo(struct inode *dir, const struct qstr *name,
7110 struct nfs4_secinfo_flavors *flavors)
7112 struct nfs4_exception exception = { };
7115 err = -NFS4ERR_WRONGSEC;
7117 /* try to use integrity protection with machine cred */
7118 if (_nfs4_is_integrity_protected(NFS_SERVER(dir)->nfs_client))
7119 err = _nfs4_proc_secinfo(dir, name, flavors, true);
7122 * if unable to use integrity protection, or SECINFO with
7123 * integrity protection returns NFS4ERR_WRONGSEC (which is
7124 * disallowed by spec, but exists in deployed servers) use
7125 * the current filesystem's rpc_client and the user cred.
7127 if (err == -NFS4ERR_WRONGSEC)
7128 err = _nfs4_proc_secinfo(dir, name, flavors, false);
7130 trace_nfs4_secinfo(dir, name, err);
7131 err = nfs4_handle_exception(NFS_SERVER(dir), err,
7133 } while (exception.retry);
7137 #ifdef CONFIG_NFS_V4_1
7139 * Check the exchange flags returned by the server for invalid flags, having
7140 * both PNFS and NON_PNFS flags set, and not having one of NON_PNFS, PNFS, or
7143 static int nfs4_check_cl_exchange_flags(u32 flags)
7145 if (flags & ~EXCHGID4_FLAG_MASK_R)
7147 if ((flags & EXCHGID4_FLAG_USE_PNFS_MDS) &&
7148 (flags & EXCHGID4_FLAG_USE_NON_PNFS))
7150 if (!(flags & (EXCHGID4_FLAG_MASK_PNFS)))
7154 return -NFS4ERR_INVAL;
7158 nfs41_same_server_scope(struct nfs41_server_scope *a,
7159 struct nfs41_server_scope *b)
7161 if (a->server_scope_sz == b->server_scope_sz &&
7162 memcmp(a->server_scope, b->server_scope, a->server_scope_sz) == 0)
7169 nfs4_bind_one_conn_to_session_done(struct rpc_task *task, void *calldata)
7173 static const struct rpc_call_ops nfs4_bind_one_conn_to_session_ops = {
7174 .rpc_call_done = nfs4_bind_one_conn_to_session_done,
7178 * nfs4_proc_bind_one_conn_to_session()
7180 * The 4.1 client currently uses the same TCP connection for the
7181 * fore and backchannel.
7184 int nfs4_proc_bind_one_conn_to_session(struct rpc_clnt *clnt,
7185 struct rpc_xprt *xprt,
7186 struct nfs_client *clp,
7187 struct rpc_cred *cred)
7190 struct nfs41_bind_conn_to_session_args args = {
7192 .dir = NFS4_CDFC4_FORE_OR_BOTH,
7194 struct nfs41_bind_conn_to_session_res res;
7195 struct rpc_message msg = {
7197 &nfs4_procedures[NFSPROC4_CLNT_BIND_CONN_TO_SESSION],
7202 struct rpc_task_setup task_setup_data = {
7205 .callback_ops = &nfs4_bind_one_conn_to_session_ops,
7206 .rpc_message = &msg,
7207 .flags = RPC_TASK_TIMEOUT,
7209 struct rpc_task *task;
7211 dprintk("--> %s\n", __func__);
7213 nfs4_copy_sessionid(&args.sessionid, &clp->cl_session->sess_id);
7214 if (!(clp->cl_session->flags & SESSION4_BACK_CHAN))
7215 args.dir = NFS4_CDFC4_FORE;
7217 /* Do not set the backchannel flag unless this is clnt->cl_xprt */
7218 if (xprt != rcu_access_pointer(clnt->cl_xprt))
7219 args.dir = NFS4_CDFC4_FORE;
7221 task = rpc_run_task(&task_setup_data);
7222 if (!IS_ERR(task)) {
7223 status = task->tk_status;
7226 status = PTR_ERR(task);
7227 trace_nfs4_bind_conn_to_session(clp, status);
7229 if (memcmp(res.sessionid.data,
7230 clp->cl_session->sess_id.data, NFS4_MAX_SESSIONID_LEN)) {
7231 dprintk("NFS: %s: Session ID mismatch\n", __func__);
7235 if ((res.dir & args.dir) != res.dir || res.dir == 0) {
7236 dprintk("NFS: %s: Unexpected direction from server\n",
7241 if (res.use_conn_in_rdma_mode != args.use_conn_in_rdma_mode) {
7242 dprintk("NFS: %s: Server returned RDMA mode = true\n",
7249 dprintk("<-- %s status= %d\n", __func__, status);
7253 struct rpc_bind_conn_calldata {
7254 struct nfs_client *clp;
7255 struct rpc_cred *cred;
7259 nfs4_proc_bind_conn_to_session_callback(struct rpc_clnt *clnt,
7260 struct rpc_xprt *xprt,
7263 struct rpc_bind_conn_calldata *p = calldata;
7265 return nfs4_proc_bind_one_conn_to_session(clnt, xprt, p->clp, p->cred);
7268 int nfs4_proc_bind_conn_to_session(struct nfs_client *clp, struct rpc_cred *cred)
7270 struct rpc_bind_conn_calldata data = {
7274 return rpc_clnt_iterate_for_each_xprt(clp->cl_rpcclient,
7275 nfs4_proc_bind_conn_to_session_callback, &data);
7279 * Minimum set of SP4_MACH_CRED operations from RFC 5661 in the enforce map
7280 * and operations we'd like to see to enable certain features in the allow map
7282 static const struct nfs41_state_protection nfs4_sp4_mach_cred_request = {
7283 .how = SP4_MACH_CRED,
7284 .enforce.u.words = {
7285 [1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) |
7286 1 << (OP_EXCHANGE_ID - 32) |
7287 1 << (OP_CREATE_SESSION - 32) |
7288 1 << (OP_DESTROY_SESSION - 32) |
7289 1 << (OP_DESTROY_CLIENTID - 32)
7292 [0] = 1 << (OP_CLOSE) |
7293 1 << (OP_OPEN_DOWNGRADE) |
7295 1 << (OP_DELEGRETURN) |
7297 [1] = 1 << (OP_SECINFO - 32) |
7298 1 << (OP_SECINFO_NO_NAME - 32) |
7299 1 << (OP_LAYOUTRETURN - 32) |
7300 1 << (OP_TEST_STATEID - 32) |
7301 1 << (OP_FREE_STATEID - 32) |
7302 1 << (OP_WRITE - 32)
7307 * Select the state protection mode for client `clp' given the server results
7308 * from exchange_id in `sp'.
7310 * Returns 0 on success, negative errno otherwise.
7312 static int nfs4_sp4_select_mode(struct nfs_client *clp,
7313 struct nfs41_state_protection *sp)
7315 static const u32 supported_enforce[NFS4_OP_MAP_NUM_WORDS] = {
7316 [1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) |
7317 1 << (OP_EXCHANGE_ID - 32) |
7318 1 << (OP_CREATE_SESSION - 32) |
7319 1 << (OP_DESTROY_SESSION - 32) |
7320 1 << (OP_DESTROY_CLIENTID - 32)
7324 if (sp->how == SP4_MACH_CRED) {
7325 /* Print state protect result */
7326 dfprintk(MOUNT, "Server SP4_MACH_CRED support:\n");
7327 for (i = 0; i <= LAST_NFS4_OP; i++) {
7328 if (test_bit(i, sp->enforce.u.longs))
7329 dfprintk(MOUNT, " enforce op %d\n", i);
7330 if (test_bit(i, sp->allow.u.longs))
7331 dfprintk(MOUNT, " allow op %d\n", i);
7334 /* make sure nothing is on enforce list that isn't supported */
7335 for (i = 0; i < NFS4_OP_MAP_NUM_WORDS; i++) {
7336 if (sp->enforce.u.words[i] & ~supported_enforce[i]) {
7337 dfprintk(MOUNT, "sp4_mach_cred: disabled\n");
7343 * Minimal mode - state operations are allowed to use machine
7344 * credential. Note this already happens by default, so the
7345 * client doesn't have to do anything more than the negotiation.
7347 * NOTE: we don't care if EXCHANGE_ID is in the list -
7348 * we're already using the machine cred for exchange_id
7349 * and will never use a different cred.
7351 if (test_bit(OP_BIND_CONN_TO_SESSION, sp->enforce.u.longs) &&
7352 test_bit(OP_CREATE_SESSION, sp->enforce.u.longs) &&
7353 test_bit(OP_DESTROY_SESSION, sp->enforce.u.longs) &&
7354 test_bit(OP_DESTROY_CLIENTID, sp->enforce.u.longs)) {
7355 dfprintk(MOUNT, "sp4_mach_cred:\n");
7356 dfprintk(MOUNT, " minimal mode enabled\n");
7357 set_bit(NFS_SP4_MACH_CRED_MINIMAL, &clp->cl_sp4_flags);
7359 dfprintk(MOUNT, "sp4_mach_cred: disabled\n");
7363 if (test_bit(OP_CLOSE, sp->allow.u.longs) &&
7364 test_bit(OP_OPEN_DOWNGRADE, sp->allow.u.longs) &&
7365 test_bit(OP_DELEGRETURN, sp->allow.u.longs) &&
7366 test_bit(OP_LOCKU, sp->allow.u.longs)) {
7367 dfprintk(MOUNT, " cleanup mode enabled\n");
7368 set_bit(NFS_SP4_MACH_CRED_CLEANUP, &clp->cl_sp4_flags);
7371 if (test_bit(OP_LAYOUTRETURN, sp->allow.u.longs)) {
7372 dfprintk(MOUNT, " pnfs cleanup mode enabled\n");
7373 set_bit(NFS_SP4_MACH_CRED_PNFS_CLEANUP,
7374 &clp->cl_sp4_flags);
7377 if (test_bit(OP_SECINFO, sp->allow.u.longs) &&
7378 test_bit(OP_SECINFO_NO_NAME, sp->allow.u.longs)) {
7379 dfprintk(MOUNT, " secinfo mode enabled\n");
7380 set_bit(NFS_SP4_MACH_CRED_SECINFO, &clp->cl_sp4_flags);
7383 if (test_bit(OP_TEST_STATEID, sp->allow.u.longs) &&
7384 test_bit(OP_FREE_STATEID, sp->allow.u.longs)) {
7385 dfprintk(MOUNT, " stateid mode enabled\n");
7386 set_bit(NFS_SP4_MACH_CRED_STATEID, &clp->cl_sp4_flags);
7389 if (test_bit(OP_WRITE, sp->allow.u.longs)) {
7390 dfprintk(MOUNT, " write mode enabled\n");
7391 set_bit(NFS_SP4_MACH_CRED_WRITE, &clp->cl_sp4_flags);
7394 if (test_bit(OP_COMMIT, sp->allow.u.longs)) {
7395 dfprintk(MOUNT, " commit mode enabled\n");
7396 set_bit(NFS_SP4_MACH_CRED_COMMIT, &clp->cl_sp4_flags);
7403 struct nfs41_exchange_id_data {
7404 struct nfs41_exchange_id_res res;
7405 struct nfs41_exchange_id_args args;
7406 struct rpc_xprt *xprt;
7410 static void nfs4_exchange_id_done(struct rpc_task *task, void *data)
7412 struct nfs41_exchange_id_data *cdata =
7413 (struct nfs41_exchange_id_data *)data;
7414 struct nfs_client *clp = cdata->args.client;
7415 int status = task->tk_status;
7417 trace_nfs4_exchange_id(clp, status);
7420 status = nfs4_check_cl_exchange_flags(cdata->res.flags);
7422 if (cdata->xprt && status == 0) {
7423 status = nfs4_detect_session_trunking(clp, &cdata->res,
7429 status = nfs4_sp4_select_mode(clp, &cdata->res.state_protect);
7432 clp->cl_clientid = cdata->res.clientid;
7433 clp->cl_exchange_flags = cdata->res.flags;
7434 /* Client ID is not confirmed */
7435 if (!(cdata->res.flags & EXCHGID4_FLAG_CONFIRMED_R)) {
7436 clear_bit(NFS4_SESSION_ESTABLISHED,
7437 &clp->cl_session->session_state);
7438 clp->cl_seqid = cdata->res.seqid;
7441 kfree(clp->cl_serverowner);
7442 clp->cl_serverowner = cdata->res.server_owner;
7443 cdata->res.server_owner = NULL;
7445 /* use the most recent implementation id */
7446 kfree(clp->cl_implid);
7447 clp->cl_implid = cdata->res.impl_id;
7448 cdata->res.impl_id = NULL;
7450 if (clp->cl_serverscope != NULL &&
7451 !nfs41_same_server_scope(clp->cl_serverscope,
7452 cdata->res.server_scope)) {
7453 dprintk("%s: server_scope mismatch detected\n",
7455 set_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state);
7456 kfree(clp->cl_serverscope);
7457 clp->cl_serverscope = NULL;
7460 if (clp->cl_serverscope == NULL) {
7461 clp->cl_serverscope = cdata->res.server_scope;
7462 cdata->res.server_scope = NULL;
7464 /* Save the EXCHANGE_ID verifier session trunk tests */
7465 memcpy(clp->cl_confirm.data, cdata->args.verifier.data,
7466 sizeof(clp->cl_confirm.data));
7469 cdata->rpc_status = status;
7473 static void nfs4_exchange_id_release(void *data)
7475 struct nfs41_exchange_id_data *cdata =
7476 (struct nfs41_exchange_id_data *)data;
7479 xprt_put(cdata->xprt);
7480 rpc_clnt_xprt_switch_put(cdata->args.client->cl_rpcclient);
7482 nfs_put_client(cdata->args.client);
7483 kfree(cdata->res.impl_id);
7484 kfree(cdata->res.server_scope);
7485 kfree(cdata->res.server_owner);
7489 static const struct rpc_call_ops nfs4_exchange_id_call_ops = {
7490 .rpc_call_done = nfs4_exchange_id_done,
7491 .rpc_release = nfs4_exchange_id_release,
7495 * _nfs4_proc_exchange_id()
7497 * Wrapper for EXCHANGE_ID operation.
7499 static int _nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred,
7500 u32 sp4_how, struct rpc_xprt *xprt)
7502 struct rpc_message msg = {
7503 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_EXCHANGE_ID],
7506 struct rpc_task_setup task_setup_data = {
7507 .rpc_client = clp->cl_rpcclient,
7508 .callback_ops = &nfs4_exchange_id_call_ops,
7509 .rpc_message = &msg,
7510 .flags = RPC_TASK_ASYNC | RPC_TASK_TIMEOUT,
7512 struct nfs41_exchange_id_data *calldata;
7513 struct rpc_task *task;
7516 if (!atomic_inc_not_zero(&clp->cl_count))
7520 calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
7524 nfs4_init_boot_verifier(clp, &calldata->args.verifier);
7526 status = nfs4_init_uniform_client_string(clp);
7530 dprintk("NFS call exchange_id auth=%s, '%s'\n",
7531 clp->cl_rpcclient->cl_auth->au_ops->au_name,
7534 calldata->res.server_owner = kzalloc(sizeof(struct nfs41_server_owner),
7537 if (unlikely(calldata->res.server_owner == NULL))
7540 calldata->res.server_scope = kzalloc(sizeof(struct nfs41_server_scope),
7542 if (unlikely(calldata->res.server_scope == NULL))
7543 goto out_server_owner;
7545 calldata->res.impl_id = kzalloc(sizeof(struct nfs41_impl_id), GFP_NOFS);
7546 if (unlikely(calldata->res.impl_id == NULL))
7547 goto out_server_scope;
7551 calldata->args.state_protect.how = SP4_NONE;
7555 calldata->args.state_protect = nfs4_sp4_mach_cred_request;
7565 calldata->xprt = xprt;
7566 task_setup_data.rpc_xprt = xprt;
7567 task_setup_data.flags =
7568 RPC_TASK_SOFT|RPC_TASK_SOFTCONN|RPC_TASK_ASYNC;
7569 memcpy(calldata->args.verifier.data, clp->cl_confirm.data,
7570 sizeof(calldata->args.verifier.data));
7572 calldata->args.client = clp;
7573 #ifdef CONFIG_NFS_V4_1_MIGRATION
7574 calldata->args.flags = EXCHGID4_FLAG_SUPP_MOVED_REFER |
7575 EXCHGID4_FLAG_BIND_PRINC_STATEID |
7576 EXCHGID4_FLAG_SUPP_MOVED_MIGR,
7578 calldata->args.flags = EXCHGID4_FLAG_SUPP_MOVED_REFER |
7579 EXCHGID4_FLAG_BIND_PRINC_STATEID,
7581 msg.rpc_argp = &calldata->args;
7582 msg.rpc_resp = &calldata->res;
7583 task_setup_data.callback_data = calldata;
7585 task = rpc_run_task(&task_setup_data);
7587 return PTR_ERR(task);
7590 status = rpc_wait_for_completion_task(task);
7592 status = calldata->rpc_status;
7593 } else /* session trunking test */
7594 status = calldata->rpc_status;
7598 if (clp->cl_implid != NULL)
7599 dprintk("NFS reply exchange_id: Server Implementation ID: "
7600 "domain: %s, name: %s, date: %llu,%u\n",
7601 clp->cl_implid->domain, clp->cl_implid->name,
7602 clp->cl_implid->date.seconds,
7603 clp->cl_implid->date.nseconds);
7604 dprintk("NFS reply exchange_id: %d\n", status);
7608 kfree(calldata->res.impl_id);
7610 kfree(calldata->res.server_scope);
7612 kfree(calldata->res.server_owner);
7615 nfs_put_client(clp);
7620 * nfs4_proc_exchange_id()
7622 * Returns zero, a negative errno, or a negative NFS4ERR status code.
7624 * Since the clientid has expired, all compounds using sessions
7625 * associated with the stale clientid will be returning
7626 * NFS4ERR_BADSESSION in the sequence operation, and will therefore
7627 * be in some phase of session reset.
7629 * Will attempt to negotiate SP4_MACH_CRED if krb5i / krb5p auth is used.
7631 int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)
7633 rpc_authflavor_t authflavor = clp->cl_rpcclient->cl_auth->au_flavor;
7636 /* try SP4_MACH_CRED if krb5i/p */
7637 if (authflavor == RPC_AUTH_GSS_KRB5I ||
7638 authflavor == RPC_AUTH_GSS_KRB5P) {
7639 status = _nfs4_proc_exchange_id(clp, cred, SP4_MACH_CRED, NULL);
7645 return _nfs4_proc_exchange_id(clp, cred, SP4_NONE, NULL);
7649 * nfs4_test_session_trunk
7651 * This is an add_xprt_test() test function called from
7652 * rpc_clnt_setup_test_and_add_xprt.
7654 * The rpc_xprt_switch is referrenced by rpc_clnt_setup_test_and_add_xprt
7655 * and is dereferrenced in nfs4_exchange_id_release
7657 * Upon success, add the new transport to the rpc_clnt
7659 * @clnt: struct rpc_clnt to get new transport
7660 * @xprt: the rpc_xprt to test
7661 * @data: call data for _nfs4_proc_exchange_id.
7663 int nfs4_test_session_trunk(struct rpc_clnt *clnt, struct rpc_xprt *xprt,
7666 struct nfs4_add_xprt_data *adata = (struct nfs4_add_xprt_data *)data;
7669 dprintk("--> %s try %s\n", __func__,
7670 xprt->address_strings[RPC_DISPLAY_ADDR]);
7672 sp4_how = (adata->clp->cl_sp4_flags == 0 ? SP4_NONE : SP4_MACH_CRED);
7674 /* Test connection for session trunking. Async exchange_id call */
7675 return _nfs4_proc_exchange_id(adata->clp, adata->cred, sp4_how, xprt);
7677 EXPORT_SYMBOL_GPL(nfs4_test_session_trunk);
7679 static int _nfs4_proc_destroy_clientid(struct nfs_client *clp,
7680 struct rpc_cred *cred)
7682 struct rpc_message msg = {
7683 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_CLIENTID],
7689 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
7690 trace_nfs4_destroy_clientid(clp, status);
7692 dprintk("NFS: Got error %d from the server %s on "
7693 "DESTROY_CLIENTID.", status, clp->cl_hostname);
7697 static int nfs4_proc_destroy_clientid(struct nfs_client *clp,
7698 struct rpc_cred *cred)
7703 for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) {
7704 ret = _nfs4_proc_destroy_clientid(clp, cred);
7706 case -NFS4ERR_DELAY:
7707 case -NFS4ERR_CLIENTID_BUSY:
7717 int nfs4_destroy_clientid(struct nfs_client *clp)
7719 struct rpc_cred *cred;
7722 if (clp->cl_mvops->minor_version < 1)
7724 if (clp->cl_exchange_flags == 0)
7726 if (clp->cl_preserve_clid)
7728 cred = nfs4_get_clid_cred(clp);
7729 ret = nfs4_proc_destroy_clientid(clp, cred);
7734 case -NFS4ERR_STALE_CLIENTID:
7735 clp->cl_exchange_flags = 0;
7741 struct nfs4_get_lease_time_data {
7742 struct nfs4_get_lease_time_args *args;
7743 struct nfs4_get_lease_time_res *res;
7744 struct nfs_client *clp;
7747 static void nfs4_get_lease_time_prepare(struct rpc_task *task,
7750 struct nfs4_get_lease_time_data *data =
7751 (struct nfs4_get_lease_time_data *)calldata;
7753 dprintk("--> %s\n", __func__);
7754 /* just setup sequence, do not trigger session recovery
7755 since we're invoked within one */
7756 nfs41_setup_sequence(data->clp->cl_session,
7757 &data->args->la_seq_args,
7758 &data->res->lr_seq_res,
7760 dprintk("<-- %s\n", __func__);
7764 * Called from nfs4_state_manager thread for session setup, so don't recover
7765 * from sequence operation or clientid errors.
7767 static void nfs4_get_lease_time_done(struct rpc_task *task, void *calldata)
7769 struct nfs4_get_lease_time_data *data =
7770 (struct nfs4_get_lease_time_data *)calldata;
7772 dprintk("--> %s\n", __func__);
7773 if (!nfs41_sequence_done(task, &data->res->lr_seq_res))
7775 switch (task->tk_status) {
7776 case -NFS4ERR_DELAY:
7777 case -NFS4ERR_GRACE:
7778 dprintk("%s Retry: tk_status %d\n", __func__, task->tk_status);
7779 rpc_delay(task, NFS4_POLL_RETRY_MIN);
7780 task->tk_status = 0;
7782 case -NFS4ERR_RETRY_UNCACHED_REP:
7783 rpc_restart_call_prepare(task);
7786 dprintk("<-- %s\n", __func__);
7789 static const struct rpc_call_ops nfs4_get_lease_time_ops = {
7790 .rpc_call_prepare = nfs4_get_lease_time_prepare,
7791 .rpc_call_done = nfs4_get_lease_time_done,
7794 int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo)
7796 struct rpc_task *task;
7797 struct nfs4_get_lease_time_args args;
7798 struct nfs4_get_lease_time_res res = {
7799 .lr_fsinfo = fsinfo,
7801 struct nfs4_get_lease_time_data data = {
7806 struct rpc_message msg = {
7807 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GET_LEASE_TIME],
7811 struct rpc_task_setup task_setup = {
7812 .rpc_client = clp->cl_rpcclient,
7813 .rpc_message = &msg,
7814 .callback_ops = &nfs4_get_lease_time_ops,
7815 .callback_data = &data,
7816 .flags = RPC_TASK_TIMEOUT,
7820 nfs4_init_sequence(&args.la_seq_args, &res.lr_seq_res, 0);
7821 nfs4_set_sequence_privileged(&args.la_seq_args);
7822 dprintk("--> %s\n", __func__);
7823 task = rpc_run_task(&task_setup);
7826 status = PTR_ERR(task);
7828 status = task->tk_status;
7831 dprintk("<-- %s return %d\n", __func__, status);
7837 * Initialize the values to be used by the client in CREATE_SESSION
7838 * If nfs4_init_session set the fore channel request and response sizes,
7841 * Set the back channel max_resp_sz_cached to zero to force the client to
7842 * always set csa_cachethis to FALSE because the current implementation
7843 * of the back channel DRC only supports caching the CB_SEQUENCE operation.
7845 static void nfs4_init_channel_attrs(struct nfs41_create_session_args *args,
7846 struct rpc_clnt *clnt)
7848 unsigned int max_rqst_sz, max_resp_sz;
7849 unsigned int max_bc_payload = rpc_max_bc_payload(clnt);
7851 max_rqst_sz = NFS_MAX_FILE_IO_SIZE + nfs41_maxwrite_overhead;
7852 max_resp_sz = NFS_MAX_FILE_IO_SIZE + nfs41_maxread_overhead;
7854 /* Fore channel attributes */
7855 args->fc_attrs.max_rqst_sz = max_rqst_sz;
7856 args->fc_attrs.max_resp_sz = max_resp_sz;
7857 args->fc_attrs.max_ops = NFS4_MAX_OPS;
7858 args->fc_attrs.max_reqs = max_session_slots;
7860 dprintk("%s: Fore Channel : max_rqst_sz=%u max_resp_sz=%u "
7861 "max_ops=%u max_reqs=%u\n",
7863 args->fc_attrs.max_rqst_sz, args->fc_attrs.max_resp_sz,
7864 args->fc_attrs.max_ops, args->fc_attrs.max_reqs);
7866 /* Back channel attributes */
7867 args->bc_attrs.max_rqst_sz = max_bc_payload;
7868 args->bc_attrs.max_resp_sz = max_bc_payload;
7869 args->bc_attrs.max_resp_sz_cached = 0;
7870 args->bc_attrs.max_ops = NFS4_MAX_BACK_CHANNEL_OPS;
7871 args->bc_attrs.max_reqs = min_t(unsigned short, max_session_cb_slots, 1);
7873 dprintk("%s: Back Channel : max_rqst_sz=%u max_resp_sz=%u "
7874 "max_resp_sz_cached=%u max_ops=%u max_reqs=%u\n",
7876 args->bc_attrs.max_rqst_sz, args->bc_attrs.max_resp_sz,
7877 args->bc_attrs.max_resp_sz_cached, args->bc_attrs.max_ops,
7878 args->bc_attrs.max_reqs);
7881 static int nfs4_verify_fore_channel_attrs(struct nfs41_create_session_args *args,
7882 struct nfs41_create_session_res *res)
7884 struct nfs4_channel_attrs *sent = &args->fc_attrs;
7885 struct nfs4_channel_attrs *rcvd = &res->fc_attrs;
7887 if (rcvd->max_resp_sz > sent->max_resp_sz)
7890 * Our requested max_ops is the minimum we need; we're not
7891 * prepared to break up compounds into smaller pieces than that.
7892 * So, no point even trying to continue if the server won't
7895 if (rcvd->max_ops < sent->max_ops)
7897 if (rcvd->max_reqs == 0)
7899 if (rcvd->max_reqs > NFS4_MAX_SLOT_TABLE)
7900 rcvd->max_reqs = NFS4_MAX_SLOT_TABLE;
7904 static int nfs4_verify_back_channel_attrs(struct nfs41_create_session_args *args,
7905 struct nfs41_create_session_res *res)
7907 struct nfs4_channel_attrs *sent = &args->bc_attrs;
7908 struct nfs4_channel_attrs *rcvd = &res->bc_attrs;
7910 if (!(res->flags & SESSION4_BACK_CHAN))
7912 if (rcvd->max_rqst_sz > sent->max_rqst_sz)
7914 if (rcvd->max_resp_sz < sent->max_resp_sz)
7916 if (rcvd->max_resp_sz_cached > sent->max_resp_sz_cached)
7918 if (rcvd->max_ops > sent->max_ops)
7920 if (rcvd->max_reqs > sent->max_reqs)
7926 static int nfs4_verify_channel_attrs(struct nfs41_create_session_args *args,
7927 struct nfs41_create_session_res *res)
7931 ret = nfs4_verify_fore_channel_attrs(args, res);
7934 return nfs4_verify_back_channel_attrs(args, res);
7937 static void nfs4_update_session(struct nfs4_session *session,
7938 struct nfs41_create_session_res *res)
7940 nfs4_copy_sessionid(&session->sess_id, &res->sessionid);
7941 /* Mark client id and session as being confirmed */
7942 session->clp->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R;
7943 set_bit(NFS4_SESSION_ESTABLISHED, &session->session_state);
7944 session->flags = res->flags;
7945 memcpy(&session->fc_attrs, &res->fc_attrs, sizeof(session->fc_attrs));
7946 if (res->flags & SESSION4_BACK_CHAN)
7947 memcpy(&session->bc_attrs, &res->bc_attrs,
7948 sizeof(session->bc_attrs));
7951 static int _nfs4_proc_create_session(struct nfs_client *clp,
7952 struct rpc_cred *cred)
7954 struct nfs4_session *session = clp->cl_session;
7955 struct nfs41_create_session_args args = {
7957 .clientid = clp->cl_clientid,
7958 .seqid = clp->cl_seqid,
7959 .cb_program = NFS4_CALLBACK,
7961 struct nfs41_create_session_res res;
7963 struct rpc_message msg = {
7964 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE_SESSION],
7971 nfs4_init_channel_attrs(&args, clp->cl_rpcclient);
7972 args.flags = (SESSION4_PERSIST | SESSION4_BACK_CHAN);
7974 status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
7975 trace_nfs4_create_session(clp, status);
7978 case -NFS4ERR_STALE_CLIENTID:
7979 case -NFS4ERR_DELAY:
7988 /* Verify the session's negotiated channel_attrs values */
7989 status = nfs4_verify_channel_attrs(&args, &res);
7990 /* Increment the clientid slot sequence id */
7993 nfs4_update_session(session, &res);
8000 * Issues a CREATE_SESSION operation to the server.
8001 * It is the responsibility of the caller to verify the session is
8002 * expired before calling this routine.
8004 int nfs4_proc_create_session(struct nfs_client *clp, struct rpc_cred *cred)
8008 struct nfs4_session *session = clp->cl_session;
8010 dprintk("--> %s clp=%p session=%p\n", __func__, clp, session);
8012 status = _nfs4_proc_create_session(clp, cred);
8016 /* Init or reset the session slot tables */
8017 status = nfs4_setup_session_slot_tables(session);
8018 dprintk("slot table setup returned %d\n", status);
8022 ptr = (unsigned *)&session->sess_id.data[0];
8023 dprintk("%s client>seqid %d sessionid %u:%u:%u:%u\n", __func__,
8024 clp->cl_seqid, ptr[0], ptr[1], ptr[2], ptr[3]);
8026 dprintk("<-- %s\n", __func__);
8031 * Issue the over-the-wire RPC DESTROY_SESSION.
8032 * The caller must serialize access to this routine.
8034 int nfs4_proc_destroy_session(struct nfs4_session *session,
8035 struct rpc_cred *cred)
8037 struct rpc_message msg = {
8038 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_SESSION],
8039 .rpc_argp = session,
8044 dprintk("--> nfs4_proc_destroy_session\n");
8046 /* session is still being setup */
8047 if (!test_and_clear_bit(NFS4_SESSION_ESTABLISHED, &session->session_state))
8050 status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
8051 trace_nfs4_destroy_session(session->clp, status);
8054 dprintk("NFS: Got error %d from the server on DESTROY_SESSION. "
8055 "Session has been destroyed regardless...\n", status);
8057 dprintk("<-- nfs4_proc_destroy_session\n");
8062 * Renew the cl_session lease.
8064 struct nfs4_sequence_data {
8065 struct nfs_client *clp;
8066 struct nfs4_sequence_args args;
8067 struct nfs4_sequence_res res;
8070 static void nfs41_sequence_release(void *data)
8072 struct nfs4_sequence_data *calldata = data;
8073 struct nfs_client *clp = calldata->clp;
8075 if (atomic_read(&clp->cl_count) > 1)
8076 nfs4_schedule_state_renewal(clp);
8077 nfs_put_client(clp);
8081 static int nfs41_sequence_handle_errors(struct rpc_task *task, struct nfs_client *clp)
8083 switch(task->tk_status) {
8084 case -NFS4ERR_DELAY:
8085 rpc_delay(task, NFS4_POLL_RETRY_MAX);
8088 nfs4_schedule_lease_recovery(clp);
8093 static void nfs41_sequence_call_done(struct rpc_task *task, void *data)
8095 struct nfs4_sequence_data *calldata = data;
8096 struct nfs_client *clp = calldata->clp;
8098 if (!nfs41_sequence_done(task, task->tk_msg.rpc_resp))
8101 trace_nfs4_sequence(clp, task->tk_status);
8102 if (task->tk_status < 0) {
8103 dprintk("%s ERROR %d\n", __func__, task->tk_status);
8104 if (atomic_read(&clp->cl_count) == 1)
8107 if (nfs41_sequence_handle_errors(task, clp) == -EAGAIN) {
8108 rpc_restart_call_prepare(task);
8112 dprintk("%s rpc_cred %p\n", __func__, task->tk_msg.rpc_cred);
8114 dprintk("<-- %s\n", __func__);
8117 static void nfs41_sequence_prepare(struct rpc_task *task, void *data)
8119 struct nfs4_sequence_data *calldata = data;
8120 struct nfs_client *clp = calldata->clp;
8121 struct nfs4_sequence_args *args;
8122 struct nfs4_sequence_res *res;
8124 args = task->tk_msg.rpc_argp;
8125 res = task->tk_msg.rpc_resp;
8127 nfs41_setup_sequence(clp->cl_session, args, res, task);
8130 static const struct rpc_call_ops nfs41_sequence_ops = {
8131 .rpc_call_done = nfs41_sequence_call_done,
8132 .rpc_call_prepare = nfs41_sequence_prepare,
8133 .rpc_release = nfs41_sequence_release,
8136 static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp,
8137 struct rpc_cred *cred,
8140 struct nfs4_sequence_data *calldata;
8141 struct rpc_message msg = {
8142 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEQUENCE],
8145 struct rpc_task_setup task_setup_data = {
8146 .rpc_client = clp->cl_rpcclient,
8147 .rpc_message = &msg,
8148 .callback_ops = &nfs41_sequence_ops,
8149 .flags = RPC_TASK_ASYNC | RPC_TASK_TIMEOUT,
8152 if (!atomic_inc_not_zero(&clp->cl_count))
8153 return ERR_PTR(-EIO);
8154 calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
8155 if (calldata == NULL) {
8156 nfs_put_client(clp);
8157 return ERR_PTR(-ENOMEM);
8159 nfs4_init_sequence(&calldata->args, &calldata->res, 0);
8161 nfs4_set_sequence_privileged(&calldata->args);
8162 msg.rpc_argp = &calldata->args;
8163 msg.rpc_resp = &calldata->res;
8164 calldata->clp = clp;
8165 task_setup_data.callback_data = calldata;
8167 return rpc_run_task(&task_setup_data);
8170 static int nfs41_proc_async_sequence(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags)
8172 struct rpc_task *task;
8175 if ((renew_flags & NFS4_RENEW_TIMEOUT) == 0)
8177 task = _nfs41_proc_sequence(clp, cred, false);
8179 ret = PTR_ERR(task);
8181 rpc_put_task_async(task);
8182 dprintk("<-- %s status=%d\n", __func__, ret);
8186 static int nfs4_proc_sequence(struct nfs_client *clp, struct rpc_cred *cred)
8188 struct rpc_task *task;
8191 task = _nfs41_proc_sequence(clp, cred, true);
8193 ret = PTR_ERR(task);
8196 ret = rpc_wait_for_completion_task(task);
8198 ret = task->tk_status;
8201 dprintk("<-- %s status=%d\n", __func__, ret);
8205 struct nfs4_reclaim_complete_data {
8206 struct nfs_client *clp;
8207 struct nfs41_reclaim_complete_args arg;
8208 struct nfs41_reclaim_complete_res res;
8211 static void nfs4_reclaim_complete_prepare(struct rpc_task *task, void *data)
8213 struct nfs4_reclaim_complete_data *calldata = data;
8215 nfs41_setup_sequence(calldata->clp->cl_session,
8216 &calldata->arg.seq_args,
8217 &calldata->res.seq_res,
8221 static int nfs41_reclaim_complete_handle_errors(struct rpc_task *task, struct nfs_client *clp)
8223 switch(task->tk_status) {
8225 case -NFS4ERR_COMPLETE_ALREADY:
8226 case -NFS4ERR_WRONG_CRED: /* What to do here? */
8228 case -NFS4ERR_DELAY:
8229 rpc_delay(task, NFS4_POLL_RETRY_MAX);
8231 case -NFS4ERR_RETRY_UNCACHED_REP:
8233 case -NFS4ERR_BADSESSION:
8234 case -NFS4ERR_DEADSESSION:
8235 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
8236 nfs4_schedule_session_recovery(clp->cl_session,
8240 nfs4_schedule_lease_recovery(clp);
8245 static void nfs4_reclaim_complete_done(struct rpc_task *task, void *data)
8247 struct nfs4_reclaim_complete_data *calldata = data;
8248 struct nfs_client *clp = calldata->clp;
8249 struct nfs4_sequence_res *res = &calldata->res.seq_res;
8251 dprintk("--> %s\n", __func__);
8252 if (!nfs41_sequence_done(task, res))
8255 trace_nfs4_reclaim_complete(clp, task->tk_status);
8256 if (nfs41_reclaim_complete_handle_errors(task, clp) == -EAGAIN) {
8257 rpc_restart_call_prepare(task);
8260 dprintk("<-- %s\n", __func__);
8263 static void nfs4_free_reclaim_complete_data(void *data)
8265 struct nfs4_reclaim_complete_data *calldata = data;
8270 static const struct rpc_call_ops nfs4_reclaim_complete_call_ops = {
8271 .rpc_call_prepare = nfs4_reclaim_complete_prepare,
8272 .rpc_call_done = nfs4_reclaim_complete_done,
8273 .rpc_release = nfs4_free_reclaim_complete_data,
8277 * Issue a global reclaim complete.
8279 static int nfs41_proc_reclaim_complete(struct nfs_client *clp,
8280 struct rpc_cred *cred)
8282 struct nfs4_reclaim_complete_data *calldata;
8283 struct rpc_task *task;
8284 struct rpc_message msg = {
8285 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RECLAIM_COMPLETE],
8288 struct rpc_task_setup task_setup_data = {
8289 .rpc_client = clp->cl_rpcclient,
8290 .rpc_message = &msg,
8291 .callback_ops = &nfs4_reclaim_complete_call_ops,
8292 .flags = RPC_TASK_ASYNC,
8294 int status = -ENOMEM;
8296 dprintk("--> %s\n", __func__);
8297 calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
8298 if (calldata == NULL)
8300 calldata->clp = clp;
8301 calldata->arg.one_fs = 0;
8303 nfs4_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 0);
8304 nfs4_set_sequence_privileged(&calldata->arg.seq_args);
8305 msg.rpc_argp = &calldata->arg;
8306 msg.rpc_resp = &calldata->res;
8307 task_setup_data.callback_data = calldata;
8308 task = rpc_run_task(&task_setup_data);
8310 status = PTR_ERR(task);
8313 status = nfs4_wait_for_completion_rpc_task(task);
8315 status = task->tk_status;
8318 dprintk("<-- %s status=%d\n", __func__, status);
8323 nfs4_layoutget_prepare(struct rpc_task *task, void *calldata)
8325 struct nfs4_layoutget *lgp = calldata;
8326 struct nfs_server *server = NFS_SERVER(lgp->args.inode);
8327 struct nfs4_session *session = nfs4_get_session(server);
8329 dprintk("--> %s\n", __func__);
8330 nfs41_setup_sequence(session, &lgp->args.seq_args,
8331 &lgp->res.seq_res, task);
8332 dprintk("<-- %s\n", __func__);
8335 static void nfs4_layoutget_done(struct rpc_task *task, void *calldata)
8337 struct nfs4_layoutget *lgp = calldata;
8339 dprintk("--> %s\n", __func__);
8340 nfs41_sequence_process(task, &lgp->res.seq_res);
8341 dprintk("<-- %s\n", __func__);
8345 nfs4_layoutget_handle_exception(struct rpc_task *task,
8346 struct nfs4_layoutget *lgp, struct nfs4_exception *exception)
8348 struct inode *inode = lgp->args.inode;
8349 struct nfs_server *server = NFS_SERVER(inode);
8350 struct pnfs_layout_hdr *lo;
8351 int nfs4err = task->tk_status;
8352 int err, status = 0;
8355 dprintk("--> %s tk_status => %d\n", __func__, -task->tk_status);
8362 * NFS4ERR_LAYOUTUNAVAILABLE means we are not supposed to use pnfs
8363 * on the file. set tk_status to -ENODATA to tell upper layer to
8366 case -NFS4ERR_LAYOUTUNAVAILABLE:
8370 * NFS4ERR_BADLAYOUT means the MDS cannot return a layout of
8371 * length lgp->args.minlength != 0 (see RFC5661 section 18.43.3).
8373 case -NFS4ERR_BADLAYOUT:
8374 status = -EOVERFLOW;
8377 * NFS4ERR_LAYOUTTRYLATER is a conflict with another client
8378 * (or clients) writing to the same RAID stripe except when
8379 * the minlength argument is 0 (see RFC5661 section 18.43.3).
8381 * Treat it like we would RECALLCONFLICT -- we retry for a little
8382 * while, and then eventually give up.
8384 case -NFS4ERR_LAYOUTTRYLATER:
8385 if (lgp->args.minlength == 0) {
8386 status = -EOVERFLOW;
8391 case -NFS4ERR_RECALLCONFLICT:
8392 status = -ERECALLCONFLICT;
8394 case -NFS4ERR_DELEG_REVOKED:
8395 case -NFS4ERR_ADMIN_REVOKED:
8396 case -NFS4ERR_EXPIRED:
8397 case -NFS4ERR_BAD_STATEID:
8398 exception->timeout = 0;
8399 spin_lock(&inode->i_lock);
8400 lo = NFS_I(inode)->layout;
8401 /* If the open stateid was bad, then recover it. */
8402 if (!lo || test_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags) ||
8403 nfs4_stateid_match_other(&lgp->args.stateid,
8404 &lgp->args.ctx->state->stateid)) {
8405 spin_unlock(&inode->i_lock);
8406 exception->state = lgp->args.ctx->state;
8407 exception->stateid = &lgp->args.stateid;
8412 * Mark the bad layout state as invalid, then retry
8414 pnfs_mark_layout_stateid_invalid(lo, &head);
8415 spin_unlock(&inode->i_lock);
8416 pnfs_free_lseg_list(&head);
8421 nfs4_sequence_free_slot(&lgp->res.seq_res);
8422 err = nfs4_handle_exception(server, nfs4err, exception);
8424 if (exception->retry)
8430 dprintk("<-- %s\n", __func__);
8434 static size_t max_response_pages(struct nfs_server *server)
8436 u32 max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz;
8437 return nfs_page_array_len(0, max_resp_sz);
8440 static void nfs4_free_pages(struct page **pages, size_t size)
8447 for (i = 0; i < size; i++) {
8450 __free_page(pages[i]);
8455 static struct page **nfs4_alloc_pages(size_t size, gfp_t gfp_flags)
8457 struct page **pages;
8460 pages = kcalloc(size, sizeof(struct page *), gfp_flags);
8462 dprintk("%s: can't alloc array of %zu pages\n", __func__, size);
8466 for (i = 0; i < size; i++) {
8467 pages[i] = alloc_page(gfp_flags);
8469 dprintk("%s: failed to allocate page\n", __func__);
8470 nfs4_free_pages(pages, size);
8478 static void nfs4_layoutget_release(void *calldata)
8480 struct nfs4_layoutget *lgp = calldata;
8481 struct inode *inode = lgp->args.inode;
8482 struct nfs_server *server = NFS_SERVER(inode);
8483 size_t max_pages = max_response_pages(server);
8485 dprintk("--> %s\n", __func__);
8486 nfs4_sequence_free_slot(&lgp->res.seq_res);
8487 nfs4_free_pages(lgp->args.layout.pages, max_pages);
8488 pnfs_put_layout_hdr(NFS_I(inode)->layout);
8489 put_nfs_open_context(lgp->args.ctx);
8491 dprintk("<-- %s\n", __func__);
8494 static const struct rpc_call_ops nfs4_layoutget_call_ops = {
8495 .rpc_call_prepare = nfs4_layoutget_prepare,
8496 .rpc_call_done = nfs4_layoutget_done,
8497 .rpc_release = nfs4_layoutget_release,
8500 struct pnfs_layout_segment *
8501 nfs4_proc_layoutget(struct nfs4_layoutget *lgp, long *timeout, gfp_t gfp_flags)
8503 struct inode *inode = lgp->args.inode;
8504 struct nfs_server *server = NFS_SERVER(inode);
8505 size_t max_pages = max_response_pages(server);
8506 struct rpc_task *task;
8507 struct rpc_message msg = {
8508 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTGET],
8509 .rpc_argp = &lgp->args,
8510 .rpc_resp = &lgp->res,
8511 .rpc_cred = lgp->cred,
8513 struct rpc_task_setup task_setup_data = {
8514 .rpc_client = server->client,
8515 .rpc_message = &msg,
8516 .callback_ops = &nfs4_layoutget_call_ops,
8517 .callback_data = lgp,
8518 .flags = RPC_TASK_ASYNC,
8520 struct pnfs_layout_segment *lseg = NULL;
8521 struct nfs4_exception exception = {
8523 .timeout = *timeout,
8527 dprintk("--> %s\n", __func__);
8529 /* nfs4_layoutget_release calls pnfs_put_layout_hdr */
8530 pnfs_get_layout_hdr(NFS_I(inode)->layout);
8532 lgp->args.layout.pages = nfs4_alloc_pages(max_pages, gfp_flags);
8533 if (!lgp->args.layout.pages) {
8534 nfs4_layoutget_release(lgp);
8535 return ERR_PTR(-ENOMEM);
8537 lgp->args.layout.pglen = max_pages * PAGE_SIZE;
8539 lgp->res.layoutp = &lgp->args.layout;
8540 lgp->res.seq_res.sr_slot = NULL;
8541 nfs4_init_sequence(&lgp->args.seq_args, &lgp->res.seq_res, 0);
8543 task = rpc_run_task(&task_setup_data);
8545 return ERR_CAST(task);
8546 status = nfs4_wait_for_completion_rpc_task(task);
8548 status = nfs4_layoutget_handle_exception(task, lgp, &exception);
8549 *timeout = exception.timeout;
8552 trace_nfs4_layoutget(lgp->args.ctx,
8558 /* if layoutp->len is 0, nfs4_layoutget_prepare called rpc_exit */
8559 if (status == 0 && lgp->res.layoutp->len)
8560 lseg = pnfs_layout_process(lgp);
8562 dprintk("<-- %s status=%d\n", __func__, status);
8564 return ERR_PTR(status);
8569 nfs4_layoutreturn_prepare(struct rpc_task *task, void *calldata)
8571 struct nfs4_layoutreturn *lrp = calldata;
8573 dprintk("--> %s\n", __func__);
8574 nfs41_setup_sequence(lrp->clp->cl_session,
8575 &lrp->args.seq_args,
8580 static void nfs4_layoutreturn_done(struct rpc_task *task, void *calldata)
8582 struct nfs4_layoutreturn *lrp = calldata;
8583 struct nfs_server *server;
8585 dprintk("--> %s\n", __func__);
8587 if (!nfs41_sequence_process(task, &lrp->res.seq_res))
8590 server = NFS_SERVER(lrp->args.inode);
8591 switch (task->tk_status) {
8593 task->tk_status = 0;
8596 case -NFS4ERR_DELAY:
8597 if (nfs4_async_handle_error(task, server, NULL, NULL) != -EAGAIN)
8599 nfs4_sequence_free_slot(&lrp->res.seq_res);
8600 rpc_restart_call_prepare(task);
8603 dprintk("<-- %s\n", __func__);
8606 static void nfs4_layoutreturn_release(void *calldata)
8608 struct nfs4_layoutreturn *lrp = calldata;
8609 struct pnfs_layout_hdr *lo = lrp->args.layout;
8612 dprintk("--> %s\n", __func__);
8613 spin_lock(&lo->plh_inode->i_lock);
8614 if (lrp->res.lrs_present) {
8615 pnfs_mark_matching_lsegs_invalid(lo, &freeme,
8617 be32_to_cpu(lrp->args.stateid.seqid));
8618 pnfs_set_layout_stateid(lo, &lrp->res.stateid, true);
8620 pnfs_mark_layout_stateid_invalid(lo, &freeme);
8621 pnfs_clear_layoutreturn_waitbit(lo);
8622 spin_unlock(&lo->plh_inode->i_lock);
8623 nfs4_sequence_free_slot(&lrp->res.seq_res);
8624 pnfs_free_lseg_list(&freeme);
8625 pnfs_put_layout_hdr(lrp->args.layout);
8626 nfs_iput_and_deactive(lrp->inode);
8628 dprintk("<-- %s\n", __func__);
8631 static const struct rpc_call_ops nfs4_layoutreturn_call_ops = {
8632 .rpc_call_prepare = nfs4_layoutreturn_prepare,
8633 .rpc_call_done = nfs4_layoutreturn_done,
8634 .rpc_release = nfs4_layoutreturn_release,
8637 int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp, bool sync)
8639 struct rpc_task *task;
8640 struct rpc_message msg = {
8641 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTRETURN],
8642 .rpc_argp = &lrp->args,
8643 .rpc_resp = &lrp->res,
8644 .rpc_cred = lrp->cred,
8646 struct rpc_task_setup task_setup_data = {
8647 .rpc_client = NFS_SERVER(lrp->args.inode)->client,
8648 .rpc_message = &msg,
8649 .callback_ops = &nfs4_layoutreturn_call_ops,
8650 .callback_data = lrp,
8654 nfs4_state_protect(NFS_SERVER(lrp->args.inode)->nfs_client,
8655 NFS_SP4_MACH_CRED_PNFS_CLEANUP,
8656 &task_setup_data.rpc_client, &msg);
8658 dprintk("--> %s\n", __func__);
8660 lrp->inode = nfs_igrab_and_active(lrp->args.inode);
8662 nfs4_layoutreturn_release(lrp);
8665 task_setup_data.flags |= RPC_TASK_ASYNC;
8667 nfs4_init_sequence(&lrp->args.seq_args, &lrp->res.seq_res, 1);
8668 task = rpc_run_task(&task_setup_data);
8670 return PTR_ERR(task);
8672 status = task->tk_status;
8673 trace_nfs4_layoutreturn(lrp->args.inode, &lrp->args.stateid, status);
8674 dprintk("<-- %s status=%d\n", __func__, status);
8680 _nfs4_proc_getdeviceinfo(struct nfs_server *server,
8681 struct pnfs_device *pdev,
8682 struct rpc_cred *cred)
8684 struct nfs4_getdeviceinfo_args args = {
8686 .notify_types = NOTIFY_DEVICEID4_CHANGE |
8687 NOTIFY_DEVICEID4_DELETE,
8689 struct nfs4_getdeviceinfo_res res = {
8692 struct rpc_message msg = {
8693 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICEINFO],
8700 dprintk("--> %s\n", __func__);
8701 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
8702 if (res.notification & ~args.notify_types)
8703 dprintk("%s: unsupported notification\n", __func__);
8704 if (res.notification != args.notify_types)
8707 dprintk("<-- %s status=%d\n", __func__, status);
8712 int nfs4_proc_getdeviceinfo(struct nfs_server *server,
8713 struct pnfs_device *pdev,
8714 struct rpc_cred *cred)
8716 struct nfs4_exception exception = { };
8720 err = nfs4_handle_exception(server,
8721 _nfs4_proc_getdeviceinfo(server, pdev, cred),
8723 } while (exception.retry);
8726 EXPORT_SYMBOL_GPL(nfs4_proc_getdeviceinfo);
8728 static void nfs4_layoutcommit_prepare(struct rpc_task *task, void *calldata)
8730 struct nfs4_layoutcommit_data *data = calldata;
8731 struct nfs_server *server = NFS_SERVER(data->args.inode);
8732 struct nfs4_session *session = nfs4_get_session(server);
8734 nfs41_setup_sequence(session,
8735 &data->args.seq_args,
8741 nfs4_layoutcommit_done(struct rpc_task *task, void *calldata)
8743 struct nfs4_layoutcommit_data *data = calldata;
8744 struct nfs_server *server = NFS_SERVER(data->args.inode);
8746 if (!nfs41_sequence_done(task, &data->res.seq_res))
8749 switch (task->tk_status) { /* Just ignore these failures */
8750 case -NFS4ERR_DELEG_REVOKED: /* layout was recalled */
8751 case -NFS4ERR_BADIOMODE: /* no IOMODE_RW layout for range */
8752 case -NFS4ERR_BADLAYOUT: /* no layout */
8753 case -NFS4ERR_GRACE: /* loca_recalim always false */
8754 task->tk_status = 0;
8758 if (nfs4_async_handle_error(task, server, NULL, NULL) == -EAGAIN) {
8759 rpc_restart_call_prepare(task);
8765 static void nfs4_layoutcommit_release(void *calldata)
8767 struct nfs4_layoutcommit_data *data = calldata;
8769 pnfs_cleanup_layoutcommit(data);
8770 nfs_post_op_update_inode_force_wcc(data->args.inode,
8772 put_rpccred(data->cred);
8773 nfs_iput_and_deactive(data->inode);
8777 static const struct rpc_call_ops nfs4_layoutcommit_ops = {
8778 .rpc_call_prepare = nfs4_layoutcommit_prepare,
8779 .rpc_call_done = nfs4_layoutcommit_done,
8780 .rpc_release = nfs4_layoutcommit_release,
8784 nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data, bool sync)
8786 struct rpc_message msg = {
8787 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTCOMMIT],
8788 .rpc_argp = &data->args,
8789 .rpc_resp = &data->res,
8790 .rpc_cred = data->cred,
8792 struct rpc_task_setup task_setup_data = {
8793 .task = &data->task,
8794 .rpc_client = NFS_CLIENT(data->args.inode),
8795 .rpc_message = &msg,
8796 .callback_ops = &nfs4_layoutcommit_ops,
8797 .callback_data = data,
8799 struct rpc_task *task;
8802 dprintk("NFS: initiating layoutcommit call. sync %d "
8803 "lbw: %llu inode %lu\n", sync,
8804 data->args.lastbytewritten,
8805 data->args.inode->i_ino);
8808 data->inode = nfs_igrab_and_active(data->args.inode);
8809 if (data->inode == NULL) {
8810 nfs4_layoutcommit_release(data);
8813 task_setup_data.flags = RPC_TASK_ASYNC;
8815 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
8816 task = rpc_run_task(&task_setup_data);
8818 return PTR_ERR(task);
8820 status = task->tk_status;
8821 trace_nfs4_layoutcommit(data->args.inode, &data->args.stateid, status);
8822 dprintk("%s: status %d\n", __func__, status);
8828 * Use the state managment nfs_client cl_rpcclient, which uses krb5i (if
8829 * possible) as per RFC3530bis and RFC5661 Security Considerations sections
8832 _nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
8833 struct nfs_fsinfo *info,
8834 struct nfs4_secinfo_flavors *flavors, bool use_integrity)
8836 struct nfs41_secinfo_no_name_args args = {
8837 .style = SECINFO_STYLE_CURRENT_FH,
8839 struct nfs4_secinfo_res res = {
8842 struct rpc_message msg = {
8843 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO_NO_NAME],
8847 struct rpc_clnt *clnt = server->client;
8848 struct rpc_cred *cred = NULL;
8851 if (use_integrity) {
8852 clnt = server->nfs_client->cl_rpcclient;
8853 cred = nfs4_get_clid_cred(server->nfs_client);
8854 msg.rpc_cred = cred;
8857 dprintk("--> %s\n", __func__);
8858 status = nfs4_call_sync(clnt, server, &msg, &args.seq_args,
8860 dprintk("<-- %s status=%d\n", __func__, status);
8869 nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
8870 struct nfs_fsinfo *info, struct nfs4_secinfo_flavors *flavors)
8872 struct nfs4_exception exception = { };
8875 /* first try using integrity protection */
8876 err = -NFS4ERR_WRONGSEC;
8878 /* try to use integrity protection with machine cred */
8879 if (_nfs4_is_integrity_protected(server->nfs_client))
8880 err = _nfs41_proc_secinfo_no_name(server, fhandle, info,
8884 * if unable to use integrity protection, or SECINFO with
8885 * integrity protection returns NFS4ERR_WRONGSEC (which is
8886 * disallowed by spec, but exists in deployed servers) use
8887 * the current filesystem's rpc_client and the user cred.
8889 if (err == -NFS4ERR_WRONGSEC)
8890 err = _nfs41_proc_secinfo_no_name(server, fhandle, info,
8895 case -NFS4ERR_WRONGSEC:
8899 err = nfs4_handle_exception(server, err, &exception);
8901 } while (exception.retry);
8907 nfs41_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
8908 struct nfs_fsinfo *info)
8912 rpc_authflavor_t flavor = RPC_AUTH_MAXFLAVOR;
8913 struct nfs4_secinfo_flavors *flavors;
8914 struct nfs4_secinfo4 *secinfo;
8917 page = alloc_page(GFP_KERNEL);
8923 flavors = page_address(page);
8924 err = nfs41_proc_secinfo_no_name(server, fhandle, info, flavors);
8927 * Fall back on "guess and check" method if
8928 * the server doesn't support SECINFO_NO_NAME
8930 if (err == -NFS4ERR_WRONGSEC || err == -ENOTSUPP) {
8931 err = nfs4_find_root_sec(server, fhandle, info);
8937 for (i = 0; i < flavors->num_flavors; i++) {
8938 secinfo = &flavors->flavors[i];
8940 switch (secinfo->flavor) {
8944 flavor = rpcauth_get_pseudoflavor(secinfo->flavor,
8945 &secinfo->flavor_info);
8948 flavor = RPC_AUTH_MAXFLAVOR;
8952 if (!nfs_auth_info_match(&server->auth_info, flavor))
8953 flavor = RPC_AUTH_MAXFLAVOR;
8955 if (flavor != RPC_AUTH_MAXFLAVOR) {
8956 err = nfs4_lookup_root_sec(server, fhandle,
8963 if (flavor == RPC_AUTH_MAXFLAVOR)
8974 static int _nfs41_test_stateid(struct nfs_server *server,
8975 nfs4_stateid *stateid,
8976 struct rpc_cred *cred)
8979 struct nfs41_test_stateid_args args = {
8982 struct nfs41_test_stateid_res res;
8983 struct rpc_message msg = {
8984 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_TEST_STATEID],
8989 struct rpc_clnt *rpc_client = server->client;
8991 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID,
8994 dprintk("NFS call test_stateid %p\n", stateid);
8995 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
8996 nfs4_set_sequence_privileged(&args.seq_args);
8997 status = nfs4_call_sync_sequence(rpc_client, server, &msg,
8998 &args.seq_args, &res.seq_res);
8999 if (status != NFS_OK) {
9000 dprintk("NFS reply test_stateid: failed, %d\n", status);
9003 dprintk("NFS reply test_stateid: succeeded, %d\n", -res.status);
9007 static void nfs4_handle_delay_or_session_error(struct nfs_server *server,
9008 int err, struct nfs4_exception *exception)
9010 exception->retry = 0;
9012 case -NFS4ERR_DELAY:
9013 case -NFS4ERR_RETRY_UNCACHED_REP:
9014 nfs4_handle_exception(server, err, exception);
9016 case -NFS4ERR_BADSESSION:
9017 case -NFS4ERR_BADSLOT:
9018 case -NFS4ERR_BAD_HIGH_SLOT:
9019 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
9020 case -NFS4ERR_DEADSESSION:
9021 nfs4_do_handle_exception(server, err, exception);
9026 * nfs41_test_stateid - perform a TEST_STATEID operation
9028 * @server: server / transport on which to perform the operation
9029 * @stateid: state ID to test
9032 * Returns NFS_OK if the server recognizes that "stateid" is valid.
9033 * Otherwise a negative NFS4ERR value is returned if the operation
9034 * failed or the state ID is not currently valid.
9036 static int nfs41_test_stateid(struct nfs_server *server,
9037 nfs4_stateid *stateid,
9038 struct rpc_cred *cred)
9040 struct nfs4_exception exception = { };
9043 err = _nfs41_test_stateid(server, stateid, cred);
9044 nfs4_handle_delay_or_session_error(server, err, &exception);
9045 } while (exception.retry);
9049 struct nfs_free_stateid_data {
9050 struct nfs_server *server;
9051 struct nfs41_free_stateid_args args;
9052 struct nfs41_free_stateid_res res;
9055 static void nfs41_free_stateid_prepare(struct rpc_task *task, void *calldata)
9057 struct nfs_free_stateid_data *data = calldata;
9058 nfs41_setup_sequence(nfs4_get_session(data->server),
9059 &data->args.seq_args,
9064 static void nfs41_free_stateid_done(struct rpc_task *task, void *calldata)
9066 struct nfs_free_stateid_data *data = calldata;
9068 nfs41_sequence_done(task, &data->res.seq_res);
9070 switch (task->tk_status) {
9071 case -NFS4ERR_DELAY:
9072 if (nfs4_async_handle_error(task, data->server, NULL, NULL) == -EAGAIN)
9073 rpc_restart_call_prepare(task);
9077 static void nfs41_free_stateid_release(void *calldata)
9082 static const struct rpc_call_ops nfs41_free_stateid_ops = {
9083 .rpc_call_prepare = nfs41_free_stateid_prepare,
9084 .rpc_call_done = nfs41_free_stateid_done,
9085 .rpc_release = nfs41_free_stateid_release,
9088 static struct rpc_task *_nfs41_free_stateid(struct nfs_server *server,
9089 const nfs4_stateid *stateid,
9090 struct rpc_cred *cred,
9093 struct rpc_message msg = {
9094 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FREE_STATEID],
9097 struct rpc_task_setup task_setup = {
9098 .rpc_client = server->client,
9099 .rpc_message = &msg,
9100 .callback_ops = &nfs41_free_stateid_ops,
9101 .flags = RPC_TASK_ASYNC,
9103 struct nfs_free_stateid_data *data;
9105 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID,
9106 &task_setup.rpc_client, &msg);
9108 dprintk("NFS call free_stateid %p\n", stateid);
9109 data = kmalloc(sizeof(*data), GFP_NOFS);
9111 return ERR_PTR(-ENOMEM);
9112 data->server = server;
9113 nfs4_stateid_copy(&data->args.stateid, stateid);
9115 task_setup.callback_data = data;
9117 msg.rpc_argp = &data->args;
9118 msg.rpc_resp = &data->res;
9119 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
9121 nfs4_set_sequence_privileged(&data->args.seq_args);
9123 return rpc_run_task(&task_setup);
9127 * nfs41_free_stateid - perform a FREE_STATEID operation
9129 * @server: server / transport on which to perform the operation
9130 * @stateid: state ID to release
9132 * @is_recovery: set to true if this call needs to be privileged
9134 * Note: this function is always asynchronous.
9136 static int nfs41_free_stateid(struct nfs_server *server,
9137 const nfs4_stateid *stateid,
9138 struct rpc_cred *cred,
9141 struct rpc_task *task;
9143 task = _nfs41_free_stateid(server, stateid, cred, is_recovery);
9145 return PTR_ERR(task);
9151 nfs41_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
9153 struct rpc_cred *cred = lsp->ls_state->owner->so_cred;
9155 nfs41_free_stateid(server, &lsp->ls_stateid, cred, false);
9156 nfs4_free_lock_state(server, lsp);
9159 static bool nfs41_match_stateid(const nfs4_stateid *s1,
9160 const nfs4_stateid *s2)
9162 if (s1->type != s2->type)
9165 if (memcmp(s1->other, s2->other, sizeof(s1->other)) != 0)
9168 if (s1->seqid == s2->seqid)
9170 if (s1->seqid == 0 || s2->seqid == 0)
9176 #endif /* CONFIG_NFS_V4_1 */
9178 static bool nfs4_match_stateid(const nfs4_stateid *s1,
9179 const nfs4_stateid *s2)
9181 return nfs4_stateid_match(s1, s2);
9185 static const struct nfs4_state_recovery_ops nfs40_reboot_recovery_ops = {
9186 .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,
9187 .state_flag_bit = NFS_STATE_RECLAIM_REBOOT,
9188 .recover_open = nfs4_open_reclaim,
9189 .recover_lock = nfs4_lock_reclaim,
9190 .establish_clid = nfs4_init_clientid,
9191 .detect_trunking = nfs40_discover_server_trunking,
9194 #if defined(CONFIG_NFS_V4_1)
9195 static const struct nfs4_state_recovery_ops nfs41_reboot_recovery_ops = {
9196 .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,
9197 .state_flag_bit = NFS_STATE_RECLAIM_REBOOT,
9198 .recover_open = nfs4_open_reclaim,
9199 .recover_lock = nfs4_lock_reclaim,
9200 .establish_clid = nfs41_init_clientid,
9201 .reclaim_complete = nfs41_proc_reclaim_complete,
9202 .detect_trunking = nfs41_discover_server_trunking,
9204 #endif /* CONFIG_NFS_V4_1 */
9206 static const struct nfs4_state_recovery_ops nfs40_nograce_recovery_ops = {
9207 .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,
9208 .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE,
9209 .recover_open = nfs40_open_expired,
9210 .recover_lock = nfs4_lock_expired,
9211 .establish_clid = nfs4_init_clientid,
9214 #if defined(CONFIG_NFS_V4_1)
9215 static const struct nfs4_state_recovery_ops nfs41_nograce_recovery_ops = {
9216 .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,
9217 .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE,
9218 .recover_open = nfs41_open_expired,
9219 .recover_lock = nfs41_lock_expired,
9220 .establish_clid = nfs41_init_clientid,
9222 #endif /* CONFIG_NFS_V4_1 */
9224 static const struct nfs4_state_maintenance_ops nfs40_state_renewal_ops = {
9225 .sched_state_renewal = nfs4_proc_async_renew,
9226 .get_state_renewal_cred_locked = nfs4_get_renew_cred_locked,
9227 .renew_lease = nfs4_proc_renew,
9230 #if defined(CONFIG_NFS_V4_1)
9231 static const struct nfs4_state_maintenance_ops nfs41_state_renewal_ops = {
9232 .sched_state_renewal = nfs41_proc_async_sequence,
9233 .get_state_renewal_cred_locked = nfs4_get_machine_cred_locked,
9234 .renew_lease = nfs4_proc_sequence,
9238 static const struct nfs4_mig_recovery_ops nfs40_mig_recovery_ops = {
9239 .get_locations = _nfs40_proc_get_locations,
9240 .fsid_present = _nfs40_proc_fsid_present,
9243 #if defined(CONFIG_NFS_V4_1)
9244 static const struct nfs4_mig_recovery_ops nfs41_mig_recovery_ops = {
9245 .get_locations = _nfs41_proc_get_locations,
9246 .fsid_present = _nfs41_proc_fsid_present,
9248 #endif /* CONFIG_NFS_V4_1 */
9250 static const struct nfs4_minor_version_ops nfs_v4_0_minor_ops = {
9252 .init_caps = NFS_CAP_READDIRPLUS
9253 | NFS_CAP_ATOMIC_OPEN
9254 | NFS_CAP_POSIX_LOCK,
9255 .init_client = nfs40_init_client,
9256 .shutdown_client = nfs40_shutdown_client,
9257 .match_stateid = nfs4_match_stateid,
9258 .find_root_sec = nfs4_find_root_sec,
9259 .free_lock_state = nfs4_release_lockowner,
9260 .test_and_free_expired = nfs40_test_and_free_expired_stateid,
9261 .alloc_seqid = nfs_alloc_seqid,
9262 .call_sync_ops = &nfs40_call_sync_ops,
9263 .reboot_recovery_ops = &nfs40_reboot_recovery_ops,
9264 .nograce_recovery_ops = &nfs40_nograce_recovery_ops,
9265 .state_renewal_ops = &nfs40_state_renewal_ops,
9266 .mig_recovery_ops = &nfs40_mig_recovery_ops,
9269 #if defined(CONFIG_NFS_V4_1)
9270 static struct nfs_seqid *
9271 nfs_alloc_no_seqid(struct nfs_seqid_counter *arg1, gfp_t arg2)
9276 static const struct nfs4_minor_version_ops nfs_v4_1_minor_ops = {
9278 .init_caps = NFS_CAP_READDIRPLUS
9279 | NFS_CAP_ATOMIC_OPEN
9280 | NFS_CAP_POSIX_LOCK
9281 | NFS_CAP_STATEID_NFSV41
9282 | NFS_CAP_ATOMIC_OPEN_V1,
9283 .init_client = nfs41_init_client,
9284 .shutdown_client = nfs41_shutdown_client,
9285 .match_stateid = nfs41_match_stateid,
9286 .find_root_sec = nfs41_find_root_sec,
9287 .free_lock_state = nfs41_free_lock_state,
9288 .test_and_free_expired = nfs41_test_and_free_expired_stateid,
9289 .alloc_seqid = nfs_alloc_no_seqid,
9290 .session_trunk = nfs4_test_session_trunk,
9291 .call_sync_ops = &nfs41_call_sync_ops,
9292 .reboot_recovery_ops = &nfs41_reboot_recovery_ops,
9293 .nograce_recovery_ops = &nfs41_nograce_recovery_ops,
9294 .state_renewal_ops = &nfs41_state_renewal_ops,
9295 .mig_recovery_ops = &nfs41_mig_recovery_ops,
9299 #if defined(CONFIG_NFS_V4_2)
9300 static const struct nfs4_minor_version_ops nfs_v4_2_minor_ops = {
9302 .init_caps = NFS_CAP_READDIRPLUS
9303 | NFS_CAP_ATOMIC_OPEN
9304 | NFS_CAP_POSIX_LOCK
9305 | NFS_CAP_STATEID_NFSV41
9306 | NFS_CAP_ATOMIC_OPEN_V1
9309 | NFS_CAP_DEALLOCATE
9311 | NFS_CAP_LAYOUTSTATS
9313 .init_client = nfs41_init_client,
9314 .shutdown_client = nfs41_shutdown_client,
9315 .match_stateid = nfs41_match_stateid,
9316 .find_root_sec = nfs41_find_root_sec,
9317 .free_lock_state = nfs41_free_lock_state,
9318 .call_sync_ops = &nfs41_call_sync_ops,
9319 .test_and_free_expired = nfs41_test_and_free_expired_stateid,
9320 .alloc_seqid = nfs_alloc_no_seqid,
9321 .session_trunk = nfs4_test_session_trunk,
9322 .reboot_recovery_ops = &nfs41_reboot_recovery_ops,
9323 .nograce_recovery_ops = &nfs41_nograce_recovery_ops,
9324 .state_renewal_ops = &nfs41_state_renewal_ops,
9325 .mig_recovery_ops = &nfs41_mig_recovery_ops,
9329 const struct nfs4_minor_version_ops *nfs_v4_minor_ops[] = {
9330 [0] = &nfs_v4_0_minor_ops,
9331 #if defined(CONFIG_NFS_V4_1)
9332 [1] = &nfs_v4_1_minor_ops,
9334 #if defined(CONFIG_NFS_V4_2)
9335 [2] = &nfs_v4_2_minor_ops,
9339 static ssize_t nfs4_listxattr(struct dentry *dentry, char *list, size_t size)
9341 ssize_t error, error2;
9343 error = generic_listxattr(dentry, list, size);
9351 error2 = nfs4_listxattr_nfs4_label(d_inode(dentry), list, size);
9354 return error + error2;
9357 static const struct inode_operations nfs4_dir_inode_operations = {
9358 .create = nfs_create,
9359 .lookup = nfs_lookup,
9360 .atomic_open = nfs_atomic_open,
9362 .unlink = nfs_unlink,
9363 .symlink = nfs_symlink,
9367 .rename = nfs_rename,
9368 .permission = nfs_permission,
9369 .getattr = nfs_getattr,
9370 .setattr = nfs_setattr,
9371 .listxattr = nfs4_listxattr,
9374 static const struct inode_operations nfs4_file_inode_operations = {
9375 .permission = nfs_permission,
9376 .getattr = nfs_getattr,
9377 .setattr = nfs_setattr,
9378 .listxattr = nfs4_listxattr,
9381 const struct nfs_rpc_ops nfs_v4_clientops = {
9382 .version = 4, /* protocol version */
9383 .dentry_ops = &nfs4_dentry_operations,
9384 .dir_inode_ops = &nfs4_dir_inode_operations,
9385 .file_inode_ops = &nfs4_file_inode_operations,
9386 .file_ops = &nfs4_file_operations,
9387 .getroot = nfs4_proc_get_root,
9388 .submount = nfs4_submount,
9389 .try_mount = nfs4_try_mount,
9390 .getattr = nfs4_proc_getattr,
9391 .setattr = nfs4_proc_setattr,
9392 .lookup = nfs4_proc_lookup,
9393 .access = nfs4_proc_access,
9394 .readlink = nfs4_proc_readlink,
9395 .create = nfs4_proc_create,
9396 .remove = nfs4_proc_remove,
9397 .unlink_setup = nfs4_proc_unlink_setup,
9398 .unlink_rpc_prepare = nfs4_proc_unlink_rpc_prepare,
9399 .unlink_done = nfs4_proc_unlink_done,
9400 .rename_setup = nfs4_proc_rename_setup,
9401 .rename_rpc_prepare = nfs4_proc_rename_rpc_prepare,
9402 .rename_done = nfs4_proc_rename_done,
9403 .link = nfs4_proc_link,
9404 .symlink = nfs4_proc_symlink,
9405 .mkdir = nfs4_proc_mkdir,
9406 .rmdir = nfs4_proc_remove,
9407 .readdir = nfs4_proc_readdir,
9408 .mknod = nfs4_proc_mknod,
9409 .statfs = nfs4_proc_statfs,
9410 .fsinfo = nfs4_proc_fsinfo,
9411 .pathconf = nfs4_proc_pathconf,
9412 .set_capabilities = nfs4_server_capabilities,
9413 .decode_dirent = nfs4_decode_dirent,
9414 .pgio_rpc_prepare = nfs4_proc_pgio_rpc_prepare,
9415 .read_setup = nfs4_proc_read_setup,
9416 .read_done = nfs4_read_done,
9417 .write_setup = nfs4_proc_write_setup,
9418 .write_done = nfs4_write_done,
9419 .commit_setup = nfs4_proc_commit_setup,
9420 .commit_rpc_prepare = nfs4_proc_commit_rpc_prepare,
9421 .commit_done = nfs4_commit_done,
9422 .lock = nfs4_proc_lock,
9423 .clear_acl_cache = nfs4_zap_acl_attr,
9424 .close_context = nfs4_close_context,
9425 .open_context = nfs4_atomic_open,
9426 .have_delegation = nfs4_have_delegation,
9427 .return_delegation = nfs4_inode_return_delegation,
9428 .alloc_client = nfs4_alloc_client,
9429 .init_client = nfs4_init_client,
9430 .free_client = nfs4_free_client,
9431 .create_server = nfs4_create_server,
9432 .clone_server = nfs_clone_server,
9435 static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = {
9436 .name = XATTR_NAME_NFSV4_ACL,
9437 .list = nfs4_xattr_list_nfs4_acl,
9438 .get = nfs4_xattr_get_nfs4_acl,
9439 .set = nfs4_xattr_set_nfs4_acl,
9442 const struct xattr_handler *nfs4_xattr_handlers[] = {
9443 &nfs4_xattr_nfs4_acl_handler,
9444 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
9445 &nfs4_xattr_nfs4_label_handler,