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/nfs_idmap.h>
55 #include <linux/xattr.h>
56 #include <linux/utsname.h>
57 #include <linux/freezer.h>
60 #include "delegation.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)
77 static int _nfs4_proc_open(struct nfs4_opendata
*data
);
78 static int _nfs4_recover_proc_open(struct nfs4_opendata
*data
);
79 static int nfs4_do_fsinfo(struct nfs_server
*, struct nfs_fh
*, struct nfs_fsinfo
*);
80 static int nfs4_async_handle_error(struct rpc_task
*, const struct nfs_server
*, struct nfs4_state
*, long *);
81 static void nfs_fixup_referral_attributes(struct nfs_fattr
*fattr
);
82 static int nfs4_proc_getattr(struct nfs_server
*, struct nfs_fh
*, struct nfs_fattr
*, struct nfs4_label
*label
);
83 static int _nfs4_proc_getattr(struct nfs_server
*server
, struct nfs_fh
*fhandle
, struct nfs_fattr
*fattr
, struct nfs4_label
*label
);
84 static int nfs4_do_setattr(struct inode
*inode
, struct rpc_cred
*cred
,
85 struct nfs_fattr
*fattr
, struct iattr
*sattr
,
86 struct nfs4_state
*state
, struct nfs4_label
*ilabel
,
87 struct nfs4_label
*olabel
);
88 #ifdef CONFIG_NFS_V4_1
89 static int nfs41_test_stateid(struct nfs_server
*, nfs4_stateid
*,
91 static int nfs41_free_stateid(struct nfs_server
*, nfs4_stateid
*,
95 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
96 static inline struct nfs4_label
*
97 nfs4_label_init_security(struct inode
*dir
, struct dentry
*dentry
,
98 struct iattr
*sattr
, struct nfs4_label
*label
)
105 if (nfs_server_capable(dir
, NFS_CAP_SECURITY_LABEL
) == 0)
108 err
= security_dentry_init_security(dentry
, sattr
->ia_mode
,
109 &dentry
->d_name
, (void **)&label
->label
, &label
->len
);
116 nfs4_label_release_security(struct nfs4_label
*label
)
119 security_release_secctx(label
->label
, label
->len
);
121 static inline u32
*nfs4_bitmask(struct nfs_server
*server
, struct nfs4_label
*label
)
124 return server
->attr_bitmask
;
126 return server
->attr_bitmask_nl
;
129 static inline struct nfs4_label
*
130 nfs4_label_init_security(struct inode
*dir
, struct dentry
*dentry
,
131 struct iattr
*sattr
, struct nfs4_label
*l
)
134 nfs4_label_release_security(struct nfs4_label
*label
)
137 nfs4_bitmask(struct nfs_server
*server
, struct nfs4_label
*label
)
138 { return server
->attr_bitmask
; }
141 /* Prevent leaks of NFSv4 errors into userland */
142 static int nfs4_map_errors(int err
)
147 case -NFS4ERR_RESOURCE
:
148 case -NFS4ERR_LAYOUTTRYLATER
:
149 case -NFS4ERR_RECALLCONFLICT
:
151 case -NFS4ERR_WRONGSEC
:
152 case -NFS4ERR_WRONG_CRED
:
154 case -NFS4ERR_BADOWNER
:
155 case -NFS4ERR_BADNAME
:
157 case -NFS4ERR_SHARE_DENIED
:
159 case -NFS4ERR_MINOR_VERS_MISMATCH
:
160 return -EPROTONOSUPPORT
;
161 case -NFS4ERR_FILE_OPEN
:
164 dprintk("%s could not handle NFSv4 error %d\n",
172 * This is our standard bitmap for GETATTR requests.
174 const u32 nfs4_fattr_bitmap
[3] = {
176 | FATTR4_WORD0_CHANGE
179 | FATTR4_WORD0_FILEID
,
181 | FATTR4_WORD1_NUMLINKS
183 | FATTR4_WORD1_OWNER_GROUP
184 | FATTR4_WORD1_RAWDEV
185 | FATTR4_WORD1_SPACE_USED
186 | FATTR4_WORD1_TIME_ACCESS
187 | FATTR4_WORD1_TIME_METADATA
188 | FATTR4_WORD1_TIME_MODIFY
,
189 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
190 FATTR4_WORD2_SECURITY_LABEL
194 static const u32 nfs4_pnfs_open_bitmap
[3] = {
196 | FATTR4_WORD0_CHANGE
199 | FATTR4_WORD0_FILEID
,
201 | FATTR4_WORD1_NUMLINKS
203 | FATTR4_WORD1_OWNER_GROUP
204 | FATTR4_WORD1_RAWDEV
205 | FATTR4_WORD1_SPACE_USED
206 | FATTR4_WORD1_TIME_ACCESS
207 | FATTR4_WORD1_TIME_METADATA
208 | FATTR4_WORD1_TIME_MODIFY
,
209 FATTR4_WORD2_MDSTHRESHOLD
212 static const u32 nfs4_open_noattr_bitmap
[3] = {
214 | FATTR4_WORD0_CHANGE
215 | FATTR4_WORD0_FILEID
,
218 const u32 nfs4_statfs_bitmap
[3] = {
219 FATTR4_WORD0_FILES_AVAIL
220 | FATTR4_WORD0_FILES_FREE
221 | FATTR4_WORD0_FILES_TOTAL
,
222 FATTR4_WORD1_SPACE_AVAIL
223 | FATTR4_WORD1_SPACE_FREE
224 | FATTR4_WORD1_SPACE_TOTAL
227 const u32 nfs4_pathconf_bitmap
[3] = {
229 | FATTR4_WORD0_MAXNAME
,
233 const u32 nfs4_fsinfo_bitmap
[3] = { FATTR4_WORD0_MAXFILESIZE
234 | FATTR4_WORD0_MAXREAD
235 | FATTR4_WORD0_MAXWRITE
236 | FATTR4_WORD0_LEASE_TIME
,
237 FATTR4_WORD1_TIME_DELTA
238 | FATTR4_WORD1_FS_LAYOUT_TYPES
,
239 FATTR4_WORD2_LAYOUT_BLKSIZE
242 const u32 nfs4_fs_locations_bitmap
[3] = {
244 | FATTR4_WORD0_CHANGE
247 | FATTR4_WORD0_FILEID
248 | FATTR4_WORD0_FS_LOCATIONS
,
250 | FATTR4_WORD1_NUMLINKS
252 | FATTR4_WORD1_OWNER_GROUP
253 | FATTR4_WORD1_RAWDEV
254 | FATTR4_WORD1_SPACE_USED
255 | FATTR4_WORD1_TIME_ACCESS
256 | FATTR4_WORD1_TIME_METADATA
257 | FATTR4_WORD1_TIME_MODIFY
258 | FATTR4_WORD1_MOUNTED_ON_FILEID
,
261 static void nfs4_setup_readdir(u64 cookie
, __be32
*verifier
, struct dentry
*dentry
,
262 struct nfs4_readdir_arg
*readdir
)
267 readdir
->cookie
= cookie
;
268 memcpy(&readdir
->verifier
, verifier
, sizeof(readdir
->verifier
));
273 memset(&readdir
->verifier
, 0, sizeof(readdir
->verifier
));
278 * NFSv4 servers do not return entries for '.' and '..'
279 * Therefore, we fake these entries here. We let '.'
280 * have cookie 0 and '..' have cookie 1. Note that
281 * when talking to the server, we always send cookie 0
284 start
= p
= kmap_atomic(*readdir
->pages
);
287 *p
++ = xdr_one
; /* next */
288 *p
++ = xdr_zero
; /* cookie, first word */
289 *p
++ = xdr_one
; /* cookie, second word */
290 *p
++ = xdr_one
; /* entry len */
291 memcpy(p
, ".\0\0\0", 4); /* entry */
293 *p
++ = xdr_one
; /* bitmap length */
294 *p
++ = htonl(FATTR4_WORD0_FILEID
); /* bitmap */
295 *p
++ = htonl(8); /* attribute buffer length */
296 p
= xdr_encode_hyper(p
, NFS_FILEID(dentry
->d_inode
));
299 *p
++ = xdr_one
; /* next */
300 *p
++ = xdr_zero
; /* cookie, first word */
301 *p
++ = xdr_two
; /* cookie, second word */
302 *p
++ = xdr_two
; /* entry len */
303 memcpy(p
, "..\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(dentry
->d_parent
->d_inode
));
310 readdir
->pgbase
= (char *)p
- (char *)start
;
311 readdir
->count
-= readdir
->pgbase
;
312 kunmap_atomic(start
);
315 static long nfs4_update_delay(long *timeout
)
319 return NFS4_POLL_RETRY_MAX
;
321 *timeout
= NFS4_POLL_RETRY_MIN
;
322 if (*timeout
> NFS4_POLL_RETRY_MAX
)
323 *timeout
= NFS4_POLL_RETRY_MAX
;
329 static int nfs4_delay(struct rpc_clnt
*clnt
, long *timeout
)
335 freezable_schedule_timeout_killable_unsafe(
336 nfs4_update_delay(timeout
));
337 if (fatal_signal_pending(current
))
342 /* This is the error handling routine for processes that are allowed
345 int nfs4_handle_exception(struct nfs_server
*server
, int errorcode
, struct nfs4_exception
*exception
)
347 struct nfs_client
*clp
= server
->nfs_client
;
348 struct nfs4_state
*state
= exception
->state
;
349 struct inode
*inode
= exception
->inode
;
352 exception
->retry
= 0;
356 case -NFS4ERR_OPENMODE
:
357 if (inode
&& nfs4_have_delegation(inode
, FMODE_READ
)) {
358 nfs4_inode_return_delegation(inode
);
359 exception
->retry
= 1;
364 ret
= nfs4_schedule_stateid_recovery(server
, state
);
367 goto wait_on_recovery
;
368 case -NFS4ERR_DELEG_REVOKED
:
369 case -NFS4ERR_ADMIN_REVOKED
:
370 case -NFS4ERR_BAD_STATEID
:
373 ret
= nfs4_schedule_stateid_recovery(server
, state
);
376 goto wait_on_recovery
;
377 case -NFS4ERR_EXPIRED
:
379 ret
= nfs4_schedule_stateid_recovery(server
, state
);
383 case -NFS4ERR_STALE_STATEID
:
384 case -NFS4ERR_STALE_CLIENTID
:
385 nfs4_schedule_lease_recovery(clp
);
386 goto wait_on_recovery
;
388 ret
= nfs4_schedule_migration_recovery(server
);
391 goto wait_on_recovery
;
392 case -NFS4ERR_LEASE_MOVED
:
393 nfs4_schedule_lease_moved_recovery(clp
);
394 goto wait_on_recovery
;
395 #if defined(CONFIG_NFS_V4_1)
396 case -NFS4ERR_BADSESSION
:
397 case -NFS4ERR_BADSLOT
:
398 case -NFS4ERR_BAD_HIGH_SLOT
:
399 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION
:
400 case -NFS4ERR_DEADSESSION
:
401 case -NFS4ERR_SEQ_FALSE_RETRY
:
402 case -NFS4ERR_SEQ_MISORDERED
:
403 dprintk("%s ERROR: %d Reset session\n", __func__
,
405 nfs4_schedule_session_recovery(clp
->cl_session
, errorcode
);
406 goto wait_on_recovery
;
407 #endif /* defined(CONFIG_NFS_V4_1) */
408 case -NFS4ERR_FILE_OPEN
:
409 if (exception
->timeout
> HZ
) {
410 /* We have retried a decent amount, time to
418 ret
= nfs4_delay(server
->client
, &exception
->timeout
);
421 case -NFS4ERR_RETRY_UNCACHED_REP
:
422 case -NFS4ERR_OLD_STATEID
:
423 exception
->retry
= 1;
425 case -NFS4ERR_BADOWNER
:
426 /* The following works around a Linux server bug! */
427 case -NFS4ERR_BADNAME
:
428 if (server
->caps
& NFS_CAP_UIDGID_NOMAP
) {
429 server
->caps
&= ~NFS_CAP_UIDGID_NOMAP
;
430 exception
->retry
= 1;
431 printk(KERN_WARNING
"NFS: v4 server %s "
432 "does not accept raw "
434 "Reenabling the idmapper.\n",
435 server
->nfs_client
->cl_hostname
);
438 /* We failed to handle the error */
439 return nfs4_map_errors(ret
);
441 ret
= nfs4_wait_clnt_recover(clp
);
442 if (test_bit(NFS_MIG_FAILED
, &server
->mig_status
))
445 exception
->retry
= 1;
450 * Return 'true' if 'clp' is using an rpc_client that is integrity protected
451 * or 'false' otherwise.
453 static bool _nfs4_is_integrity_protected(struct nfs_client
*clp
)
455 rpc_authflavor_t flavor
= clp
->cl_rpcclient
->cl_auth
->au_flavor
;
457 if (flavor
== RPC_AUTH_GSS_KRB5I
||
458 flavor
== RPC_AUTH_GSS_KRB5P
)
464 static void do_renew_lease(struct nfs_client
*clp
, unsigned long timestamp
)
466 spin_lock(&clp
->cl_lock
);
467 if (time_before(clp
->cl_last_renewal
,timestamp
))
468 clp
->cl_last_renewal
= timestamp
;
469 spin_unlock(&clp
->cl_lock
);
472 static void renew_lease(const struct nfs_server
*server
, unsigned long timestamp
)
474 do_renew_lease(server
->nfs_client
, timestamp
);
477 struct nfs4_call_sync_data
{
478 const struct nfs_server
*seq_server
;
479 struct nfs4_sequence_args
*seq_args
;
480 struct nfs4_sequence_res
*seq_res
;
483 static void nfs4_init_sequence(struct nfs4_sequence_args
*args
,
484 struct nfs4_sequence_res
*res
, int cache_reply
)
486 args
->sa_slot
= NULL
;
487 args
->sa_cache_this
= cache_reply
;
488 args
->sa_privileged
= 0;
493 static void nfs4_set_sequence_privileged(struct nfs4_sequence_args
*args
)
495 args
->sa_privileged
= 1;
498 int nfs40_setup_sequence(struct nfs4_slot_table
*tbl
,
499 struct nfs4_sequence_args
*args
,
500 struct nfs4_sequence_res
*res
,
501 struct rpc_task
*task
)
503 struct nfs4_slot
*slot
;
505 /* slot already allocated? */
506 if (res
->sr_slot
!= NULL
)
509 spin_lock(&tbl
->slot_tbl_lock
);
510 if (nfs4_slot_tbl_draining(tbl
) && !args
->sa_privileged
)
513 slot
= nfs4_alloc_slot(tbl
);
515 if (slot
== ERR_PTR(-ENOMEM
))
516 task
->tk_timeout
= HZ
>> 2;
519 spin_unlock(&tbl
->slot_tbl_lock
);
521 args
->sa_slot
= slot
;
525 rpc_call_start(task
);
529 if (args
->sa_privileged
)
530 rpc_sleep_on_priority(&tbl
->slot_tbl_waitq
, task
,
531 NULL
, RPC_PRIORITY_PRIVILEGED
);
533 rpc_sleep_on(&tbl
->slot_tbl_waitq
, task
, NULL
);
534 spin_unlock(&tbl
->slot_tbl_lock
);
537 EXPORT_SYMBOL_GPL(nfs40_setup_sequence
);
539 static int nfs40_sequence_done(struct rpc_task
*task
,
540 struct nfs4_sequence_res
*res
)
542 struct nfs4_slot
*slot
= res
->sr_slot
;
543 struct nfs4_slot_table
*tbl
;
549 spin_lock(&tbl
->slot_tbl_lock
);
550 if (!nfs41_wake_and_assign_slot(tbl
, slot
))
551 nfs4_free_slot(tbl
, slot
);
552 spin_unlock(&tbl
->slot_tbl_lock
);
559 #if defined(CONFIG_NFS_V4_1)
561 static void nfs41_sequence_free_slot(struct nfs4_sequence_res
*res
)
563 struct nfs4_session
*session
;
564 struct nfs4_slot_table
*tbl
;
565 struct nfs4_slot
*slot
= res
->sr_slot
;
566 bool send_new_highest_used_slotid
= false;
569 session
= tbl
->session
;
571 spin_lock(&tbl
->slot_tbl_lock
);
572 /* Be nice to the server: try to ensure that the last transmitted
573 * value for highest_user_slotid <= target_highest_slotid
575 if (tbl
->highest_used_slotid
> tbl
->target_highest_slotid
)
576 send_new_highest_used_slotid
= true;
578 if (nfs41_wake_and_assign_slot(tbl
, slot
)) {
579 send_new_highest_used_slotid
= false;
582 nfs4_free_slot(tbl
, slot
);
584 if (tbl
->highest_used_slotid
!= NFS4_NO_SLOT
)
585 send_new_highest_used_slotid
= false;
587 spin_unlock(&tbl
->slot_tbl_lock
);
589 if (send_new_highest_used_slotid
)
590 nfs41_server_notify_highest_slotid_update(session
->clp
);
593 int nfs41_sequence_done(struct rpc_task
*task
, struct nfs4_sequence_res
*res
)
595 struct nfs4_session
*session
;
596 struct nfs4_slot
*slot
= res
->sr_slot
;
597 struct nfs_client
*clp
;
598 bool interrupted
= false;
603 /* don't increment the sequence number if the task wasn't sent */
604 if (!RPC_WAS_SENT(task
))
607 session
= slot
->table
->session
;
609 if (slot
->interrupted
) {
610 slot
->interrupted
= 0;
614 trace_nfs4_sequence_done(session
, res
);
615 /* Check the SEQUENCE operation status */
616 switch (res
->sr_status
) {
618 /* Update the slot's sequence and clientid lease timer */
621 do_renew_lease(clp
, res
->sr_timestamp
);
622 /* Check sequence flags */
623 if (res
->sr_status_flags
!= 0)
624 nfs4_schedule_lease_recovery(clp
);
625 nfs41_update_target_slotid(slot
->table
, slot
, res
);
629 * sr_status remains 1 if an RPC level error occurred.
630 * The server may or may not have processed the sequence
632 * Mark the slot as having hosted an interrupted RPC call.
634 slot
->interrupted
= 1;
637 /* The server detected a resend of the RPC call and
638 * returned NFS4ERR_DELAY as per Section 2.10.6.2
641 dprintk("%s: slot=%u seq=%u: Operation in progress\n",
646 case -NFS4ERR_BADSLOT
:
648 * The slot id we used was probably retired. Try again
649 * using a different slot id.
652 case -NFS4ERR_SEQ_MISORDERED
:
654 * Was the last operation on this sequence interrupted?
655 * If so, retry after bumping the sequence number.
662 * Could this slot have been previously retired?
663 * If so, then the server may be expecting seq_nr = 1!
665 if (slot
->seq_nr
!= 1) {
670 case -NFS4ERR_SEQ_FALSE_RETRY
:
674 /* Just update the slot sequence no. */
678 /* The session may be reset by one of the error handlers. */
679 dprintk("%s: Error %d free the slot \n", __func__
, res
->sr_status
);
680 nfs41_sequence_free_slot(res
);
684 if (rpc_restart_call_prepare(task
)) {
690 if (!rpc_restart_call(task
))
692 rpc_delay(task
, NFS4_POLL_RETRY_MAX
);
695 EXPORT_SYMBOL_GPL(nfs41_sequence_done
);
697 int nfs4_sequence_done(struct rpc_task
*task
, struct nfs4_sequence_res
*res
)
699 if (res
->sr_slot
== NULL
)
701 if (!res
->sr_slot
->table
->session
)
702 return nfs40_sequence_done(task
, res
);
703 return nfs41_sequence_done(task
, res
);
705 EXPORT_SYMBOL_GPL(nfs4_sequence_done
);
707 int nfs41_setup_sequence(struct nfs4_session
*session
,
708 struct nfs4_sequence_args
*args
,
709 struct nfs4_sequence_res
*res
,
710 struct rpc_task
*task
)
712 struct nfs4_slot
*slot
;
713 struct nfs4_slot_table
*tbl
;
715 dprintk("--> %s\n", __func__
);
716 /* slot already allocated? */
717 if (res
->sr_slot
!= NULL
)
720 tbl
= &session
->fc_slot_table
;
722 task
->tk_timeout
= 0;
724 spin_lock(&tbl
->slot_tbl_lock
);
725 if (test_bit(NFS4_SLOT_TBL_DRAINING
, &tbl
->slot_tbl_state
) &&
726 !args
->sa_privileged
) {
727 /* The state manager will wait until the slot table is empty */
728 dprintk("%s session is draining\n", __func__
);
732 slot
= nfs4_alloc_slot(tbl
);
734 /* If out of memory, try again in 1/4 second */
735 if (slot
== ERR_PTR(-ENOMEM
))
736 task
->tk_timeout
= HZ
>> 2;
737 dprintk("<-- %s: no free slots\n", __func__
);
740 spin_unlock(&tbl
->slot_tbl_lock
);
742 args
->sa_slot
= slot
;
744 dprintk("<-- %s slotid=%u seqid=%u\n", __func__
,
745 slot
->slot_nr
, slot
->seq_nr
);
748 res
->sr_timestamp
= jiffies
;
749 res
->sr_status_flags
= 0;
751 * sr_status is only set in decode_sequence, and so will remain
752 * set to 1 if an rpc level failure occurs.
755 trace_nfs4_setup_sequence(session
, args
);
757 rpc_call_start(task
);
760 /* Privileged tasks are queued with top priority */
761 if (args
->sa_privileged
)
762 rpc_sleep_on_priority(&tbl
->slot_tbl_waitq
, task
,
763 NULL
, RPC_PRIORITY_PRIVILEGED
);
765 rpc_sleep_on(&tbl
->slot_tbl_waitq
, task
, NULL
);
766 spin_unlock(&tbl
->slot_tbl_lock
);
769 EXPORT_SYMBOL_GPL(nfs41_setup_sequence
);
771 static int nfs4_setup_sequence(const struct nfs_server
*server
,
772 struct nfs4_sequence_args
*args
,
773 struct nfs4_sequence_res
*res
,
774 struct rpc_task
*task
)
776 struct nfs4_session
*session
= nfs4_get_session(server
);
780 return nfs40_setup_sequence(server
->nfs_client
->cl_slot_tbl
,
783 dprintk("--> %s clp %p session %p sr_slot %u\n",
784 __func__
, session
->clp
, session
, res
->sr_slot
?
785 res
->sr_slot
->slot_nr
: NFS4_NO_SLOT
);
787 ret
= nfs41_setup_sequence(session
, args
, res
, task
);
789 dprintk("<-- %s status=%d\n", __func__
, ret
);
793 static void nfs41_call_sync_prepare(struct rpc_task
*task
, void *calldata
)
795 struct nfs4_call_sync_data
*data
= calldata
;
796 struct nfs4_session
*session
= nfs4_get_session(data
->seq_server
);
798 dprintk("--> %s data->seq_server %p\n", __func__
, data
->seq_server
);
800 nfs41_setup_sequence(session
, data
->seq_args
, data
->seq_res
, task
);
803 static void nfs41_call_sync_done(struct rpc_task
*task
, void *calldata
)
805 struct nfs4_call_sync_data
*data
= calldata
;
807 nfs41_sequence_done(task
, data
->seq_res
);
810 static const struct rpc_call_ops nfs41_call_sync_ops
= {
811 .rpc_call_prepare
= nfs41_call_sync_prepare
,
812 .rpc_call_done
= nfs41_call_sync_done
,
815 #else /* !CONFIG_NFS_V4_1 */
817 static int nfs4_setup_sequence(const struct nfs_server
*server
,
818 struct nfs4_sequence_args
*args
,
819 struct nfs4_sequence_res
*res
,
820 struct rpc_task
*task
)
822 return nfs40_setup_sequence(server
->nfs_client
->cl_slot_tbl
,
826 int nfs4_sequence_done(struct rpc_task
*task
,
827 struct nfs4_sequence_res
*res
)
829 return nfs40_sequence_done(task
, res
);
831 EXPORT_SYMBOL_GPL(nfs4_sequence_done
);
833 #endif /* !CONFIG_NFS_V4_1 */
835 static void nfs40_call_sync_prepare(struct rpc_task
*task
, void *calldata
)
837 struct nfs4_call_sync_data
*data
= calldata
;
838 nfs4_setup_sequence(data
->seq_server
,
839 data
->seq_args
, data
->seq_res
, task
);
842 static void nfs40_call_sync_done(struct rpc_task
*task
, void *calldata
)
844 struct nfs4_call_sync_data
*data
= calldata
;
845 nfs4_sequence_done(task
, data
->seq_res
);
848 static const struct rpc_call_ops nfs40_call_sync_ops
= {
849 .rpc_call_prepare
= nfs40_call_sync_prepare
,
850 .rpc_call_done
= nfs40_call_sync_done
,
853 static int nfs4_call_sync_sequence(struct rpc_clnt
*clnt
,
854 struct nfs_server
*server
,
855 struct rpc_message
*msg
,
856 struct nfs4_sequence_args
*args
,
857 struct nfs4_sequence_res
*res
)
860 struct rpc_task
*task
;
861 struct nfs_client
*clp
= server
->nfs_client
;
862 struct nfs4_call_sync_data data
= {
863 .seq_server
= server
,
867 struct rpc_task_setup task_setup
= {
870 .callback_ops
= clp
->cl_mvops
->call_sync_ops
,
871 .callback_data
= &data
874 task
= rpc_run_task(&task_setup
);
878 ret
= task
->tk_status
;
884 int nfs4_call_sync(struct rpc_clnt
*clnt
,
885 struct nfs_server
*server
,
886 struct rpc_message
*msg
,
887 struct nfs4_sequence_args
*args
,
888 struct nfs4_sequence_res
*res
,
891 nfs4_init_sequence(args
, res
, cache_reply
);
892 return nfs4_call_sync_sequence(clnt
, server
, msg
, args
, res
);
895 static void update_changeattr(struct inode
*dir
, struct nfs4_change_info
*cinfo
)
897 struct nfs_inode
*nfsi
= NFS_I(dir
);
899 spin_lock(&dir
->i_lock
);
900 nfsi
->cache_validity
|= NFS_INO_INVALID_ATTR
|NFS_INO_INVALID_DATA
;
901 if (!cinfo
->atomic
|| cinfo
->before
!= dir
->i_version
)
902 nfs_force_lookup_revalidate(dir
);
903 dir
->i_version
= cinfo
->after
;
904 nfs_fscache_invalidate(dir
);
905 spin_unlock(&dir
->i_lock
);
908 struct nfs4_opendata
{
910 struct nfs_openargs o_arg
;
911 struct nfs_openres o_res
;
912 struct nfs_open_confirmargs c_arg
;
913 struct nfs_open_confirmres c_res
;
914 struct nfs4_string owner_name
;
915 struct nfs4_string group_name
;
916 struct nfs_fattr f_attr
;
917 struct nfs4_label
*f_label
;
919 struct dentry
*dentry
;
920 struct nfs4_state_owner
*owner
;
921 struct nfs4_state
*state
;
923 unsigned long timestamp
;
924 unsigned int rpc_done
: 1;
925 unsigned int file_created
: 1;
926 unsigned int is_recover
: 1;
931 static bool nfs4_clear_cap_atomic_open_v1(struct nfs_server
*server
,
932 int err
, struct nfs4_exception
*exception
)
936 if (!(server
->caps
& NFS_CAP_ATOMIC_OPEN_V1
))
938 server
->caps
&= ~NFS_CAP_ATOMIC_OPEN_V1
;
939 exception
->retry
= 1;
944 nfs4_map_atomic_open_share(struct nfs_server
*server
,
945 fmode_t fmode
, int openflags
)
949 switch (fmode
& (FMODE_READ
| FMODE_WRITE
)) {
951 res
= NFS4_SHARE_ACCESS_READ
;
954 res
= NFS4_SHARE_ACCESS_WRITE
;
956 case FMODE_READ
|FMODE_WRITE
:
957 res
= NFS4_SHARE_ACCESS_BOTH
;
959 if (!(server
->caps
& NFS_CAP_ATOMIC_OPEN_V1
))
961 /* Want no delegation if we're using O_DIRECT */
962 if (openflags
& O_DIRECT
)
963 res
|= NFS4_SHARE_WANT_NO_DELEG
;
968 static enum open_claim_type4
969 nfs4_map_atomic_open_claim(struct nfs_server
*server
,
970 enum open_claim_type4 claim
)
972 if (server
->caps
& NFS_CAP_ATOMIC_OPEN_V1
)
977 case NFS4_OPEN_CLAIM_FH
:
978 return NFS4_OPEN_CLAIM_NULL
;
979 case NFS4_OPEN_CLAIM_DELEG_CUR_FH
:
980 return NFS4_OPEN_CLAIM_DELEGATE_CUR
;
981 case NFS4_OPEN_CLAIM_DELEG_PREV_FH
:
982 return NFS4_OPEN_CLAIM_DELEGATE_PREV
;
986 static void nfs4_init_opendata_res(struct nfs4_opendata
*p
)
988 p
->o_res
.f_attr
= &p
->f_attr
;
989 p
->o_res
.f_label
= p
->f_label
;
990 p
->o_res
.seqid
= p
->o_arg
.seqid
;
991 p
->c_res
.seqid
= p
->c_arg
.seqid
;
992 p
->o_res
.server
= p
->o_arg
.server
;
993 p
->o_res
.access_request
= p
->o_arg
.access
;
994 nfs_fattr_init(&p
->f_attr
);
995 nfs_fattr_init_names(&p
->f_attr
, &p
->owner_name
, &p
->group_name
);
998 static struct nfs4_opendata
*nfs4_opendata_alloc(struct dentry
*dentry
,
999 struct nfs4_state_owner
*sp
, fmode_t fmode
, int flags
,
1000 const struct iattr
*attrs
,
1001 struct nfs4_label
*label
,
1002 enum open_claim_type4 claim
,
1005 struct dentry
*parent
= dget_parent(dentry
);
1006 struct inode
*dir
= parent
->d_inode
;
1007 struct nfs_server
*server
= NFS_SERVER(dir
);
1008 struct nfs_seqid
*(*alloc_seqid
)(struct nfs_seqid_counter
*, gfp_t
);
1009 struct nfs4_opendata
*p
;
1011 p
= kzalloc(sizeof(*p
), gfp_mask
);
1015 p
->f_label
= nfs4_label_alloc(server
, gfp_mask
);
1016 if (IS_ERR(p
->f_label
))
1019 alloc_seqid
= server
->nfs_client
->cl_mvops
->alloc_seqid
;
1020 p
->o_arg
.seqid
= alloc_seqid(&sp
->so_seqid
, gfp_mask
);
1021 if (IS_ERR(p
->o_arg
.seqid
))
1022 goto err_free_label
;
1023 nfs_sb_active(dentry
->d_sb
);
1024 p
->dentry
= dget(dentry
);
1027 atomic_inc(&sp
->so_count
);
1028 p
->o_arg
.open_flags
= flags
;
1029 p
->o_arg
.fmode
= fmode
& (FMODE_READ
|FMODE_WRITE
);
1030 p
->o_arg
.share_access
= nfs4_map_atomic_open_share(server
,
1032 /* don't put an ACCESS op in OPEN compound if O_EXCL, because ACCESS
1033 * will return permission denied for all bits until close */
1034 if (!(flags
& O_EXCL
)) {
1035 /* ask server to check for all possible rights as results
1037 p
->o_arg
.access
= NFS4_ACCESS_READ
| NFS4_ACCESS_MODIFY
|
1038 NFS4_ACCESS_EXTEND
| NFS4_ACCESS_EXECUTE
;
1040 p
->o_arg
.clientid
= server
->nfs_client
->cl_clientid
;
1041 p
->o_arg
.id
.create_time
= ktime_to_ns(sp
->so_seqid
.create_time
);
1042 p
->o_arg
.id
.uniquifier
= sp
->so_seqid
.owner_id
;
1043 p
->o_arg
.name
= &dentry
->d_name
;
1044 p
->o_arg
.server
= server
;
1045 p
->o_arg
.bitmask
= nfs4_bitmask(server
, label
);
1046 p
->o_arg
.open_bitmap
= &nfs4_fattr_bitmap
[0];
1047 p
->o_arg
.label
= label
;
1048 p
->o_arg
.claim
= nfs4_map_atomic_open_claim(server
, claim
);
1049 switch (p
->o_arg
.claim
) {
1050 case NFS4_OPEN_CLAIM_NULL
:
1051 case NFS4_OPEN_CLAIM_DELEGATE_CUR
:
1052 case NFS4_OPEN_CLAIM_DELEGATE_PREV
:
1053 p
->o_arg
.fh
= NFS_FH(dir
);
1055 case NFS4_OPEN_CLAIM_PREVIOUS
:
1056 case NFS4_OPEN_CLAIM_FH
:
1057 case NFS4_OPEN_CLAIM_DELEG_CUR_FH
:
1058 case NFS4_OPEN_CLAIM_DELEG_PREV_FH
:
1059 p
->o_arg
.fh
= NFS_FH(dentry
->d_inode
);
1061 if (attrs
!= NULL
&& attrs
->ia_valid
!= 0) {
1064 p
->o_arg
.u
.attrs
= &p
->attrs
;
1065 memcpy(&p
->attrs
, attrs
, sizeof(p
->attrs
));
1068 verf
[1] = current
->pid
;
1069 memcpy(p
->o_arg
.u
.verifier
.data
, verf
,
1070 sizeof(p
->o_arg
.u
.verifier
.data
));
1072 p
->c_arg
.fh
= &p
->o_res
.fh
;
1073 p
->c_arg
.stateid
= &p
->o_res
.stateid
;
1074 p
->c_arg
.seqid
= p
->o_arg
.seqid
;
1075 nfs4_init_opendata_res(p
);
1076 kref_init(&p
->kref
);
1080 nfs4_label_free(p
->f_label
);
1088 static void nfs4_opendata_free(struct kref
*kref
)
1090 struct nfs4_opendata
*p
= container_of(kref
,
1091 struct nfs4_opendata
, kref
);
1092 struct super_block
*sb
= p
->dentry
->d_sb
;
1094 nfs_free_seqid(p
->o_arg
.seqid
);
1095 if (p
->state
!= NULL
)
1096 nfs4_put_open_state(p
->state
);
1097 nfs4_put_state_owner(p
->owner
);
1099 nfs4_label_free(p
->f_label
);
1103 nfs_sb_deactive(sb
);
1104 nfs_fattr_free_names(&p
->f_attr
);
1105 kfree(p
->f_attr
.mdsthreshold
);
1109 static void nfs4_opendata_put(struct nfs4_opendata
*p
)
1112 kref_put(&p
->kref
, nfs4_opendata_free
);
1115 static int nfs4_wait_for_completion_rpc_task(struct rpc_task
*task
)
1119 ret
= rpc_wait_for_completion_task(task
);
1123 static int can_open_cached(struct nfs4_state
*state
, fmode_t mode
, int open_mode
)
1127 if (open_mode
& (O_EXCL
|O_TRUNC
))
1129 switch (mode
& (FMODE_READ
|FMODE_WRITE
)) {
1131 ret
|= test_bit(NFS_O_RDONLY_STATE
, &state
->flags
) != 0
1132 && state
->n_rdonly
!= 0;
1135 ret
|= test_bit(NFS_O_WRONLY_STATE
, &state
->flags
) != 0
1136 && state
->n_wronly
!= 0;
1138 case FMODE_READ
|FMODE_WRITE
:
1139 ret
|= test_bit(NFS_O_RDWR_STATE
, &state
->flags
) != 0
1140 && state
->n_rdwr
!= 0;
1146 static int can_open_delegated(struct nfs_delegation
*delegation
, fmode_t fmode
)
1148 if (delegation
== NULL
)
1150 if ((delegation
->type
& fmode
) != fmode
)
1152 if (test_bit(NFS_DELEGATION_RETURNING
, &delegation
->flags
))
1154 nfs_mark_delegation_referenced(delegation
);
1158 static void update_open_stateflags(struct nfs4_state
*state
, fmode_t fmode
)
1167 case FMODE_READ
|FMODE_WRITE
:
1170 nfs4_state_set_mode_locked(state
, state
->state
| fmode
);
1173 static void nfs_test_and_clear_all_open_stateid(struct nfs4_state
*state
)
1175 struct nfs_client
*clp
= state
->owner
->so_server
->nfs_client
;
1176 bool need_recover
= false;
1178 if (test_and_clear_bit(NFS_O_RDONLY_STATE
, &state
->flags
) && state
->n_rdonly
)
1179 need_recover
= true;
1180 if (test_and_clear_bit(NFS_O_WRONLY_STATE
, &state
->flags
) && state
->n_wronly
)
1181 need_recover
= true;
1182 if (test_and_clear_bit(NFS_O_RDWR_STATE
, &state
->flags
) && state
->n_rdwr
)
1183 need_recover
= true;
1185 nfs4_state_mark_reclaim_nograce(clp
, state
);
1188 static bool nfs_need_update_open_stateid(struct nfs4_state
*state
,
1189 nfs4_stateid
*stateid
)
1191 if (test_and_set_bit(NFS_OPEN_STATE
, &state
->flags
) == 0)
1193 if (!nfs4_stateid_match_other(stateid
, &state
->open_stateid
)) {
1194 nfs_test_and_clear_all_open_stateid(state
);
1197 if (nfs4_stateid_is_newer(stateid
, &state
->open_stateid
))
1202 static void nfs_resync_open_stateid_locked(struct nfs4_state
*state
)
1204 if (state
->n_wronly
)
1205 set_bit(NFS_O_WRONLY_STATE
, &state
->flags
);
1206 if (state
->n_rdonly
)
1207 set_bit(NFS_O_RDONLY_STATE
, &state
->flags
);
1209 set_bit(NFS_O_RDWR_STATE
, &state
->flags
);
1212 static void nfs_clear_open_stateid_locked(struct nfs4_state
*state
,
1213 nfs4_stateid
*stateid
, fmode_t fmode
)
1215 clear_bit(NFS_O_RDWR_STATE
, &state
->flags
);
1216 switch (fmode
& (FMODE_READ
|FMODE_WRITE
)) {
1218 clear_bit(NFS_O_RDONLY_STATE
, &state
->flags
);
1221 clear_bit(NFS_O_WRONLY_STATE
, &state
->flags
);
1224 clear_bit(NFS_O_RDONLY_STATE
, &state
->flags
);
1225 clear_bit(NFS_O_WRONLY_STATE
, &state
->flags
);
1226 clear_bit(NFS_OPEN_STATE
, &state
->flags
);
1228 if (stateid
== NULL
)
1230 /* Handle races with OPEN */
1231 if (!nfs4_stateid_match_other(stateid
, &state
->open_stateid
) ||
1232 !nfs4_stateid_is_newer(stateid
, &state
->open_stateid
)) {
1233 nfs_resync_open_stateid_locked(state
);
1236 if (test_bit(NFS_DELEGATED_STATE
, &state
->flags
) == 0)
1237 nfs4_stateid_copy(&state
->stateid
, stateid
);
1238 nfs4_stateid_copy(&state
->open_stateid
, stateid
);
1241 static void nfs_clear_open_stateid(struct nfs4_state
*state
, nfs4_stateid
*stateid
, fmode_t fmode
)
1243 write_seqlock(&state
->seqlock
);
1244 nfs_clear_open_stateid_locked(state
, stateid
, fmode
);
1245 write_sequnlock(&state
->seqlock
);
1246 if (test_bit(NFS_STATE_RECLAIM_NOGRACE
, &state
->flags
))
1247 nfs4_schedule_state_manager(state
->owner
->so_server
->nfs_client
);
1250 static void nfs_set_open_stateid_locked(struct nfs4_state
*state
, nfs4_stateid
*stateid
, fmode_t fmode
)
1254 set_bit(NFS_O_RDONLY_STATE
, &state
->flags
);
1257 set_bit(NFS_O_WRONLY_STATE
, &state
->flags
);
1259 case FMODE_READ
|FMODE_WRITE
:
1260 set_bit(NFS_O_RDWR_STATE
, &state
->flags
);
1262 if (!nfs_need_update_open_stateid(state
, stateid
))
1264 if (test_bit(NFS_DELEGATED_STATE
, &state
->flags
) == 0)
1265 nfs4_stateid_copy(&state
->stateid
, stateid
);
1266 nfs4_stateid_copy(&state
->open_stateid
, stateid
);
1269 static void __update_open_stateid(struct nfs4_state
*state
, nfs4_stateid
*open_stateid
, const nfs4_stateid
*deleg_stateid
, fmode_t fmode
)
1272 * Protect the call to nfs4_state_set_mode_locked and
1273 * serialise the stateid update
1275 write_seqlock(&state
->seqlock
);
1276 if (deleg_stateid
!= NULL
) {
1277 nfs4_stateid_copy(&state
->stateid
, deleg_stateid
);
1278 set_bit(NFS_DELEGATED_STATE
, &state
->flags
);
1280 if (open_stateid
!= NULL
)
1281 nfs_set_open_stateid_locked(state
, open_stateid
, fmode
);
1282 write_sequnlock(&state
->seqlock
);
1283 spin_lock(&state
->owner
->so_lock
);
1284 update_open_stateflags(state
, fmode
);
1285 spin_unlock(&state
->owner
->so_lock
);
1288 static int update_open_stateid(struct nfs4_state
*state
, nfs4_stateid
*open_stateid
, nfs4_stateid
*delegation
, fmode_t fmode
)
1290 struct nfs_inode
*nfsi
= NFS_I(state
->inode
);
1291 struct nfs_delegation
*deleg_cur
;
1294 fmode
&= (FMODE_READ
|FMODE_WRITE
);
1297 deleg_cur
= rcu_dereference(nfsi
->delegation
);
1298 if (deleg_cur
== NULL
)
1301 spin_lock(&deleg_cur
->lock
);
1302 if (rcu_dereference(nfsi
->delegation
) != deleg_cur
||
1303 test_bit(NFS_DELEGATION_RETURNING
, &deleg_cur
->flags
) ||
1304 (deleg_cur
->type
& fmode
) != fmode
)
1305 goto no_delegation_unlock
;
1307 if (delegation
== NULL
)
1308 delegation
= &deleg_cur
->stateid
;
1309 else if (!nfs4_stateid_match(&deleg_cur
->stateid
, delegation
))
1310 goto no_delegation_unlock
;
1312 nfs_mark_delegation_referenced(deleg_cur
);
1313 __update_open_stateid(state
, open_stateid
, &deleg_cur
->stateid
, fmode
);
1315 no_delegation_unlock
:
1316 spin_unlock(&deleg_cur
->lock
);
1320 if (!ret
&& open_stateid
!= NULL
) {
1321 __update_open_stateid(state
, open_stateid
, NULL
, fmode
);
1324 if (test_bit(NFS_STATE_RECLAIM_NOGRACE
, &state
->flags
))
1325 nfs4_schedule_state_manager(state
->owner
->so_server
->nfs_client
);
1330 static bool nfs4_update_lock_stateid(struct nfs4_lock_state
*lsp
,
1331 const nfs4_stateid
*stateid
)
1333 struct nfs4_state
*state
= lsp
->ls_state
;
1336 spin_lock(&state
->state_lock
);
1337 if (!nfs4_stateid_match_other(stateid
, &lsp
->ls_stateid
))
1339 if (!nfs4_stateid_is_newer(stateid
, &lsp
->ls_stateid
))
1341 nfs4_stateid_copy(&lsp
->ls_stateid
, stateid
);
1344 spin_unlock(&state
->state_lock
);
1348 static void nfs4_return_incompatible_delegation(struct inode
*inode
, fmode_t fmode
)
1350 struct nfs_delegation
*delegation
;
1353 delegation
= rcu_dereference(NFS_I(inode
)->delegation
);
1354 if (delegation
== NULL
|| (delegation
->type
& fmode
) == fmode
) {
1359 nfs4_inode_return_delegation(inode
);
1362 static struct nfs4_state
*nfs4_try_open_cached(struct nfs4_opendata
*opendata
)
1364 struct nfs4_state
*state
= opendata
->state
;
1365 struct nfs_inode
*nfsi
= NFS_I(state
->inode
);
1366 struct nfs_delegation
*delegation
;
1367 int open_mode
= opendata
->o_arg
.open_flags
;
1368 fmode_t fmode
= opendata
->o_arg
.fmode
;
1369 nfs4_stateid stateid
;
1373 spin_lock(&state
->owner
->so_lock
);
1374 if (can_open_cached(state
, fmode
, open_mode
)) {
1375 update_open_stateflags(state
, fmode
);
1376 spin_unlock(&state
->owner
->so_lock
);
1377 goto out_return_state
;
1379 spin_unlock(&state
->owner
->so_lock
);
1381 delegation
= rcu_dereference(nfsi
->delegation
);
1382 if (!can_open_delegated(delegation
, fmode
)) {
1386 /* Save the delegation */
1387 nfs4_stateid_copy(&stateid
, &delegation
->stateid
);
1389 nfs_release_seqid(opendata
->o_arg
.seqid
);
1390 if (!opendata
->is_recover
) {
1391 ret
= nfs_may_open(state
->inode
, state
->owner
->so_cred
, open_mode
);
1397 /* Try to update the stateid using the delegation */
1398 if (update_open_stateid(state
, NULL
, &stateid
, fmode
))
1399 goto out_return_state
;
1402 return ERR_PTR(ret
);
1404 atomic_inc(&state
->count
);
1409 nfs4_opendata_check_deleg(struct nfs4_opendata
*data
, struct nfs4_state
*state
)
1411 struct nfs_client
*clp
= NFS_SERVER(state
->inode
)->nfs_client
;
1412 struct nfs_delegation
*delegation
;
1413 int delegation_flags
= 0;
1416 delegation
= rcu_dereference(NFS_I(state
->inode
)->delegation
);
1418 delegation_flags
= delegation
->flags
;
1420 if (data
->o_arg
.claim
== NFS4_OPEN_CLAIM_DELEGATE_CUR
) {
1421 pr_err_ratelimited("NFS: Broken NFSv4 server %s is "
1422 "returning a delegation for "
1423 "OPEN(CLAIM_DELEGATE_CUR)\n",
1425 } else if ((delegation_flags
& 1UL<<NFS_DELEGATION_NEED_RECLAIM
) == 0)
1426 nfs_inode_set_delegation(state
->inode
,
1427 data
->owner
->so_cred
,
1430 nfs_inode_reclaim_delegation(state
->inode
,
1431 data
->owner
->so_cred
,
1436 * Check the inode attributes against the CLAIM_PREVIOUS returned attributes
1437 * and update the nfs4_state.
1439 static struct nfs4_state
*
1440 _nfs4_opendata_reclaim_to_nfs4_state(struct nfs4_opendata
*data
)
1442 struct inode
*inode
= data
->state
->inode
;
1443 struct nfs4_state
*state
= data
->state
;
1446 if (!data
->rpc_done
) {
1447 if (data
->rpc_status
) {
1448 ret
= data
->rpc_status
;
1451 /* cached opens have already been processed */
1455 ret
= nfs_refresh_inode(inode
, &data
->f_attr
);
1459 if (data
->o_res
.delegation_type
!= 0)
1460 nfs4_opendata_check_deleg(data
, state
);
1462 update_open_stateid(state
, &data
->o_res
.stateid
, NULL
,
1464 atomic_inc(&state
->count
);
1468 return ERR_PTR(ret
);
1472 static struct nfs4_state
*
1473 _nfs4_opendata_to_nfs4_state(struct nfs4_opendata
*data
)
1475 struct inode
*inode
;
1476 struct nfs4_state
*state
= NULL
;
1479 if (!data
->rpc_done
) {
1480 state
= nfs4_try_open_cached(data
);
1485 if (!(data
->f_attr
.valid
& NFS_ATTR_FATTR
))
1487 inode
= nfs_fhget(data
->dir
->d_sb
, &data
->o_res
.fh
, &data
->f_attr
, data
->f_label
);
1488 ret
= PTR_ERR(inode
);
1492 state
= nfs4_get_open_state(inode
, data
->owner
);
1495 if (data
->o_res
.delegation_type
!= 0)
1496 nfs4_opendata_check_deleg(data
, state
);
1497 update_open_stateid(state
, &data
->o_res
.stateid
, NULL
,
1501 nfs_release_seqid(data
->o_arg
.seqid
);
1506 return ERR_PTR(ret
);
1509 static struct nfs4_state
*
1510 nfs4_opendata_to_nfs4_state(struct nfs4_opendata
*data
)
1512 if (data
->o_arg
.claim
== NFS4_OPEN_CLAIM_PREVIOUS
)
1513 return _nfs4_opendata_reclaim_to_nfs4_state(data
);
1514 return _nfs4_opendata_to_nfs4_state(data
);
1517 static struct nfs_open_context
*nfs4_state_find_open_context(struct nfs4_state
*state
)
1519 struct nfs_inode
*nfsi
= NFS_I(state
->inode
);
1520 struct nfs_open_context
*ctx
;
1522 spin_lock(&state
->inode
->i_lock
);
1523 list_for_each_entry(ctx
, &nfsi
->open_files
, list
) {
1524 if (ctx
->state
!= state
)
1526 get_nfs_open_context(ctx
);
1527 spin_unlock(&state
->inode
->i_lock
);
1530 spin_unlock(&state
->inode
->i_lock
);
1531 return ERR_PTR(-ENOENT
);
1534 static struct nfs4_opendata
*nfs4_open_recoverdata_alloc(struct nfs_open_context
*ctx
,
1535 struct nfs4_state
*state
, enum open_claim_type4 claim
)
1537 struct nfs4_opendata
*opendata
;
1539 opendata
= nfs4_opendata_alloc(ctx
->dentry
, state
->owner
, 0, 0,
1540 NULL
, NULL
, claim
, GFP_NOFS
);
1541 if (opendata
== NULL
)
1542 return ERR_PTR(-ENOMEM
);
1543 opendata
->state
= state
;
1544 atomic_inc(&state
->count
);
1548 static int nfs4_open_recover_helper(struct nfs4_opendata
*opendata
, fmode_t fmode
, struct nfs4_state
**res
)
1550 struct nfs4_state
*newstate
;
1553 opendata
->o_arg
.open_flags
= 0;
1554 opendata
->o_arg
.fmode
= fmode
;
1555 memset(&opendata
->o_res
, 0, sizeof(opendata
->o_res
));
1556 memset(&opendata
->c_res
, 0, sizeof(opendata
->c_res
));
1557 nfs4_init_opendata_res(opendata
);
1558 ret
= _nfs4_recover_proc_open(opendata
);
1561 newstate
= nfs4_opendata_to_nfs4_state(opendata
);
1562 if (IS_ERR(newstate
))
1563 return PTR_ERR(newstate
);
1564 nfs4_close_state(newstate
, fmode
);
1569 static int nfs4_open_recover(struct nfs4_opendata
*opendata
, struct nfs4_state
*state
)
1571 struct nfs4_state
*newstate
;
1574 /* Don't trigger recovery in nfs_test_and_clear_all_open_stateid */
1575 clear_bit(NFS_O_RDWR_STATE
, &state
->flags
);
1576 clear_bit(NFS_O_WRONLY_STATE
, &state
->flags
);
1577 clear_bit(NFS_O_RDONLY_STATE
, &state
->flags
);
1578 /* memory barrier prior to reading state->n_* */
1579 clear_bit(NFS_DELEGATED_STATE
, &state
->flags
);
1580 clear_bit(NFS_OPEN_STATE
, &state
->flags
);
1582 if (state
->n_rdwr
!= 0) {
1583 ret
= nfs4_open_recover_helper(opendata
, FMODE_READ
|FMODE_WRITE
, &newstate
);
1586 if (newstate
!= state
)
1589 if (state
->n_wronly
!= 0) {
1590 ret
= nfs4_open_recover_helper(opendata
, FMODE_WRITE
, &newstate
);
1593 if (newstate
!= state
)
1596 if (state
->n_rdonly
!= 0) {
1597 ret
= nfs4_open_recover_helper(opendata
, FMODE_READ
, &newstate
);
1600 if (newstate
!= state
)
1604 * We may have performed cached opens for all three recoveries.
1605 * Check if we need to update the current stateid.
1607 if (test_bit(NFS_DELEGATED_STATE
, &state
->flags
) == 0 &&
1608 !nfs4_stateid_match(&state
->stateid
, &state
->open_stateid
)) {
1609 write_seqlock(&state
->seqlock
);
1610 if (test_bit(NFS_DELEGATED_STATE
, &state
->flags
) == 0)
1611 nfs4_stateid_copy(&state
->stateid
, &state
->open_stateid
);
1612 write_sequnlock(&state
->seqlock
);
1619 * reclaim state on the server after a reboot.
1621 static int _nfs4_do_open_reclaim(struct nfs_open_context
*ctx
, struct nfs4_state
*state
)
1623 struct nfs_delegation
*delegation
;
1624 struct nfs4_opendata
*opendata
;
1625 fmode_t delegation_type
= 0;
1628 opendata
= nfs4_open_recoverdata_alloc(ctx
, state
,
1629 NFS4_OPEN_CLAIM_PREVIOUS
);
1630 if (IS_ERR(opendata
))
1631 return PTR_ERR(opendata
);
1633 delegation
= rcu_dereference(NFS_I(state
->inode
)->delegation
);
1634 if (delegation
!= NULL
&& test_bit(NFS_DELEGATION_NEED_RECLAIM
, &delegation
->flags
) != 0)
1635 delegation_type
= delegation
->type
;
1637 opendata
->o_arg
.u
.delegation_type
= delegation_type
;
1638 status
= nfs4_open_recover(opendata
, state
);
1639 nfs4_opendata_put(opendata
);
1643 static int nfs4_do_open_reclaim(struct nfs_open_context
*ctx
, struct nfs4_state
*state
)
1645 struct nfs_server
*server
= NFS_SERVER(state
->inode
);
1646 struct nfs4_exception exception
= { };
1649 err
= _nfs4_do_open_reclaim(ctx
, state
);
1650 trace_nfs4_open_reclaim(ctx
, 0, err
);
1651 if (nfs4_clear_cap_atomic_open_v1(server
, err
, &exception
))
1653 if (err
!= -NFS4ERR_DELAY
)
1655 nfs4_handle_exception(server
, err
, &exception
);
1656 } while (exception
.retry
);
1660 static int nfs4_open_reclaim(struct nfs4_state_owner
*sp
, struct nfs4_state
*state
)
1662 struct nfs_open_context
*ctx
;
1665 ctx
= nfs4_state_find_open_context(state
);
1668 ret
= nfs4_do_open_reclaim(ctx
, state
);
1669 put_nfs_open_context(ctx
);
1673 static int nfs4_handle_delegation_recall_error(struct nfs_server
*server
, struct nfs4_state
*state
, const nfs4_stateid
*stateid
, int err
)
1677 printk(KERN_ERR
"NFS: %s: unhandled error "
1678 "%d.\n", __func__
, err
);
1683 case -NFS4ERR_BADSESSION
:
1684 case -NFS4ERR_BADSLOT
:
1685 case -NFS4ERR_BAD_HIGH_SLOT
:
1686 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION
:
1687 case -NFS4ERR_DEADSESSION
:
1688 set_bit(NFS_DELEGATED_STATE
, &state
->flags
);
1689 nfs4_schedule_session_recovery(server
->nfs_client
->cl_session
, err
);
1691 case -NFS4ERR_STALE_CLIENTID
:
1692 case -NFS4ERR_STALE_STATEID
:
1693 set_bit(NFS_DELEGATED_STATE
, &state
->flags
);
1694 case -NFS4ERR_EXPIRED
:
1695 /* Don't recall a delegation if it was lost */
1696 nfs4_schedule_lease_recovery(server
->nfs_client
);
1698 case -NFS4ERR_MOVED
:
1699 nfs4_schedule_migration_recovery(server
);
1701 case -NFS4ERR_LEASE_MOVED
:
1702 nfs4_schedule_lease_moved_recovery(server
->nfs_client
);
1704 case -NFS4ERR_DELEG_REVOKED
:
1705 case -NFS4ERR_ADMIN_REVOKED
:
1706 case -NFS4ERR_BAD_STATEID
:
1707 case -NFS4ERR_OPENMODE
:
1708 nfs_inode_find_state_and_recover(state
->inode
,
1710 nfs4_schedule_stateid_recovery(server
, state
);
1712 case -NFS4ERR_DELAY
:
1713 case -NFS4ERR_GRACE
:
1714 set_bit(NFS_DELEGATED_STATE
, &state
->flags
);
1718 case -NFS4ERR_DENIED
:
1719 /* kill_proc(fl->fl_pid, SIGLOST, 1); */
1725 int nfs4_open_delegation_recall(struct nfs_open_context
*ctx
, struct nfs4_state
*state
, const nfs4_stateid
*stateid
)
1727 struct nfs_server
*server
= NFS_SERVER(state
->inode
);
1728 struct nfs4_opendata
*opendata
;
1731 opendata
= nfs4_open_recoverdata_alloc(ctx
, state
,
1732 NFS4_OPEN_CLAIM_DELEG_CUR_FH
);
1733 if (IS_ERR(opendata
))
1734 return PTR_ERR(opendata
);
1735 nfs4_stateid_copy(&opendata
->o_arg
.u
.delegation
, stateid
);
1736 err
= nfs4_open_recover(opendata
, state
);
1737 nfs4_opendata_put(opendata
);
1738 return nfs4_handle_delegation_recall_error(server
, state
, stateid
, err
);
1741 static void nfs4_open_confirm_prepare(struct rpc_task
*task
, void *calldata
)
1743 struct nfs4_opendata
*data
= calldata
;
1745 nfs40_setup_sequence(data
->o_arg
.server
->nfs_client
->cl_slot_tbl
,
1746 &data
->c_arg
.seq_args
, &data
->c_res
.seq_res
, task
);
1749 static void nfs4_open_confirm_done(struct rpc_task
*task
, void *calldata
)
1751 struct nfs4_opendata
*data
= calldata
;
1753 nfs40_sequence_done(task
, &data
->c_res
.seq_res
);
1755 data
->rpc_status
= task
->tk_status
;
1756 if (data
->rpc_status
== 0) {
1757 nfs4_stateid_copy(&data
->o_res
.stateid
, &data
->c_res
.stateid
);
1758 nfs_confirm_seqid(&data
->owner
->so_seqid
, 0);
1759 renew_lease(data
->o_res
.server
, data
->timestamp
);
1764 static void nfs4_open_confirm_release(void *calldata
)
1766 struct nfs4_opendata
*data
= calldata
;
1767 struct nfs4_state
*state
= NULL
;
1769 /* If this request hasn't been cancelled, do nothing */
1770 if (data
->cancelled
== 0)
1772 /* In case of error, no cleanup! */
1773 if (!data
->rpc_done
)
1775 state
= nfs4_opendata_to_nfs4_state(data
);
1777 nfs4_close_state(state
, data
->o_arg
.fmode
);
1779 nfs4_opendata_put(data
);
1782 static const struct rpc_call_ops nfs4_open_confirm_ops
= {
1783 .rpc_call_prepare
= nfs4_open_confirm_prepare
,
1784 .rpc_call_done
= nfs4_open_confirm_done
,
1785 .rpc_release
= nfs4_open_confirm_release
,
1789 * Note: On error, nfs4_proc_open_confirm will free the struct nfs4_opendata
1791 static int _nfs4_proc_open_confirm(struct nfs4_opendata
*data
)
1793 struct nfs_server
*server
= NFS_SERVER(data
->dir
->d_inode
);
1794 struct rpc_task
*task
;
1795 struct rpc_message msg
= {
1796 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_OPEN_CONFIRM
],
1797 .rpc_argp
= &data
->c_arg
,
1798 .rpc_resp
= &data
->c_res
,
1799 .rpc_cred
= data
->owner
->so_cred
,
1801 struct rpc_task_setup task_setup_data
= {
1802 .rpc_client
= server
->client
,
1803 .rpc_message
= &msg
,
1804 .callback_ops
= &nfs4_open_confirm_ops
,
1805 .callback_data
= data
,
1806 .workqueue
= nfsiod_workqueue
,
1807 .flags
= RPC_TASK_ASYNC
,
1811 nfs4_init_sequence(&data
->c_arg
.seq_args
, &data
->c_res
.seq_res
, 1);
1812 kref_get(&data
->kref
);
1814 data
->rpc_status
= 0;
1815 data
->timestamp
= jiffies
;
1816 task
= rpc_run_task(&task_setup_data
);
1818 return PTR_ERR(task
);
1819 status
= nfs4_wait_for_completion_rpc_task(task
);
1821 data
->cancelled
= 1;
1824 status
= data
->rpc_status
;
1829 static void nfs4_open_prepare(struct rpc_task
*task
, void *calldata
)
1831 struct nfs4_opendata
*data
= calldata
;
1832 struct nfs4_state_owner
*sp
= data
->owner
;
1833 struct nfs_client
*clp
= sp
->so_server
->nfs_client
;
1835 if (nfs_wait_on_sequence(data
->o_arg
.seqid
, task
) != 0)
1838 * Check if we still need to send an OPEN call, or if we can use
1839 * a delegation instead.
1841 if (data
->state
!= NULL
) {
1842 struct nfs_delegation
*delegation
;
1844 if (can_open_cached(data
->state
, data
->o_arg
.fmode
, data
->o_arg
.open_flags
))
1847 delegation
= rcu_dereference(NFS_I(data
->state
->inode
)->delegation
);
1848 if (data
->o_arg
.claim
!= NFS4_OPEN_CLAIM_DELEGATE_CUR
&&
1849 data
->o_arg
.claim
!= NFS4_OPEN_CLAIM_DELEG_CUR_FH
&&
1850 can_open_delegated(delegation
, data
->o_arg
.fmode
))
1851 goto unlock_no_action
;
1854 /* Update client id. */
1855 data
->o_arg
.clientid
= clp
->cl_clientid
;
1856 switch (data
->o_arg
.claim
) {
1857 case NFS4_OPEN_CLAIM_PREVIOUS
:
1858 case NFS4_OPEN_CLAIM_DELEG_CUR_FH
:
1859 case NFS4_OPEN_CLAIM_DELEG_PREV_FH
:
1860 data
->o_arg
.open_bitmap
= &nfs4_open_noattr_bitmap
[0];
1861 case NFS4_OPEN_CLAIM_FH
:
1862 task
->tk_msg
.rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_OPEN_NOATTR
];
1863 nfs_copy_fh(&data
->o_res
.fh
, data
->o_arg
.fh
);
1865 data
->timestamp
= jiffies
;
1866 if (nfs4_setup_sequence(data
->o_arg
.server
,
1867 &data
->o_arg
.seq_args
,
1868 &data
->o_res
.seq_res
,
1870 nfs_release_seqid(data
->o_arg
.seqid
);
1872 /* Set the create mode (note dependency on the session type) */
1873 data
->o_arg
.createmode
= NFS4_CREATE_UNCHECKED
;
1874 if (data
->o_arg
.open_flags
& O_EXCL
) {
1875 data
->o_arg
.createmode
= NFS4_CREATE_EXCLUSIVE
;
1876 if (nfs4_has_persistent_session(clp
))
1877 data
->o_arg
.createmode
= NFS4_CREATE_GUARDED
;
1878 else if (clp
->cl_mvops
->minor_version
> 0)
1879 data
->o_arg
.createmode
= NFS4_CREATE_EXCLUSIVE4_1
;
1885 task
->tk_action
= NULL
;
1887 nfs4_sequence_done(task
, &data
->o_res
.seq_res
);
1890 static void nfs4_open_done(struct rpc_task
*task
, void *calldata
)
1892 struct nfs4_opendata
*data
= calldata
;
1894 data
->rpc_status
= task
->tk_status
;
1896 if (!nfs4_sequence_done(task
, &data
->o_res
.seq_res
))
1899 if (task
->tk_status
== 0) {
1900 if (data
->o_res
.f_attr
->valid
& NFS_ATTR_FATTR_TYPE
) {
1901 switch (data
->o_res
.f_attr
->mode
& S_IFMT
) {
1905 data
->rpc_status
= -ELOOP
;
1908 data
->rpc_status
= -EISDIR
;
1911 data
->rpc_status
= -ENOTDIR
;
1914 renew_lease(data
->o_res
.server
, data
->timestamp
);
1915 if (!(data
->o_res
.rflags
& NFS4_OPEN_RESULT_CONFIRM
))
1916 nfs_confirm_seqid(&data
->owner
->so_seqid
, 0);
1921 static void nfs4_open_release(void *calldata
)
1923 struct nfs4_opendata
*data
= calldata
;
1924 struct nfs4_state
*state
= NULL
;
1926 /* If this request hasn't been cancelled, do nothing */
1927 if (data
->cancelled
== 0)
1929 /* In case of error, no cleanup! */
1930 if (data
->rpc_status
!= 0 || !data
->rpc_done
)
1932 /* In case we need an open_confirm, no cleanup! */
1933 if (data
->o_res
.rflags
& NFS4_OPEN_RESULT_CONFIRM
)
1935 state
= nfs4_opendata_to_nfs4_state(data
);
1937 nfs4_close_state(state
, data
->o_arg
.fmode
);
1939 nfs4_opendata_put(data
);
1942 static const struct rpc_call_ops nfs4_open_ops
= {
1943 .rpc_call_prepare
= nfs4_open_prepare
,
1944 .rpc_call_done
= nfs4_open_done
,
1945 .rpc_release
= nfs4_open_release
,
1948 static int nfs4_run_open_task(struct nfs4_opendata
*data
, int isrecover
)
1950 struct inode
*dir
= data
->dir
->d_inode
;
1951 struct nfs_server
*server
= NFS_SERVER(dir
);
1952 struct nfs_openargs
*o_arg
= &data
->o_arg
;
1953 struct nfs_openres
*o_res
= &data
->o_res
;
1954 struct rpc_task
*task
;
1955 struct rpc_message msg
= {
1956 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_OPEN
],
1959 .rpc_cred
= data
->owner
->so_cred
,
1961 struct rpc_task_setup task_setup_data
= {
1962 .rpc_client
= server
->client
,
1963 .rpc_message
= &msg
,
1964 .callback_ops
= &nfs4_open_ops
,
1965 .callback_data
= data
,
1966 .workqueue
= nfsiod_workqueue
,
1967 .flags
= RPC_TASK_ASYNC
,
1971 nfs4_init_sequence(&o_arg
->seq_args
, &o_res
->seq_res
, 1);
1972 kref_get(&data
->kref
);
1974 data
->rpc_status
= 0;
1975 data
->cancelled
= 0;
1976 data
->is_recover
= 0;
1978 nfs4_set_sequence_privileged(&o_arg
->seq_args
);
1979 data
->is_recover
= 1;
1981 task
= rpc_run_task(&task_setup_data
);
1983 return PTR_ERR(task
);
1984 status
= nfs4_wait_for_completion_rpc_task(task
);
1986 data
->cancelled
= 1;
1989 status
= data
->rpc_status
;
1995 static int _nfs4_recover_proc_open(struct nfs4_opendata
*data
)
1997 struct inode
*dir
= data
->dir
->d_inode
;
1998 struct nfs_openres
*o_res
= &data
->o_res
;
2001 status
= nfs4_run_open_task(data
, 1);
2002 if (status
!= 0 || !data
->rpc_done
)
2005 nfs_fattr_map_and_free_names(NFS_SERVER(dir
), &data
->f_attr
);
2007 if (o_res
->rflags
& NFS4_OPEN_RESULT_CONFIRM
) {
2008 status
= _nfs4_proc_open_confirm(data
);
2017 * Additional permission checks in order to distinguish between an
2018 * open for read, and an open for execute. This works around the
2019 * fact that NFSv4 OPEN treats read and execute permissions as being
2021 * Note that in the non-execute case, we want to turn off permission
2022 * checking if we just created a new file (POSIX open() semantics).
2024 static int nfs4_opendata_access(struct rpc_cred
*cred
,
2025 struct nfs4_opendata
*opendata
,
2026 struct nfs4_state
*state
, fmode_t fmode
,
2029 struct nfs_access_entry cache
;
2032 /* access call failed or for some reason the server doesn't
2033 * support any access modes -- defer access call until later */
2034 if (opendata
->o_res
.access_supported
== 0)
2039 * Use openflags to check for exec, because fmode won't
2040 * always have FMODE_EXEC set when file open for exec.
2042 if (openflags
& __FMODE_EXEC
) {
2043 /* ONLY check for exec rights */
2045 } else if ((fmode
& FMODE_READ
) && !opendata
->file_created
)
2049 cache
.jiffies
= jiffies
;
2050 nfs_access_set_mask(&cache
, opendata
->o_res
.access_result
);
2051 nfs_access_add_cache(state
->inode
, &cache
);
2053 if ((mask
& ~cache
.mask
& (MAY_READ
| MAY_EXEC
)) == 0)
2056 /* even though OPEN succeeded, access is denied. Close the file */
2057 nfs4_close_state(state
, fmode
);
2062 * Note: On error, nfs4_proc_open will free the struct nfs4_opendata
2064 static int _nfs4_proc_open(struct nfs4_opendata
*data
)
2066 struct inode
*dir
= data
->dir
->d_inode
;
2067 struct nfs_server
*server
= NFS_SERVER(dir
);
2068 struct nfs_openargs
*o_arg
= &data
->o_arg
;
2069 struct nfs_openres
*o_res
= &data
->o_res
;
2072 status
= nfs4_run_open_task(data
, 0);
2073 if (!data
->rpc_done
)
2076 if (status
== -NFS4ERR_BADNAME
&&
2077 !(o_arg
->open_flags
& O_CREAT
))
2082 nfs_fattr_map_and_free_names(server
, &data
->f_attr
);
2084 if (o_arg
->open_flags
& O_CREAT
) {
2085 update_changeattr(dir
, &o_res
->cinfo
);
2086 if (o_arg
->open_flags
& O_EXCL
)
2087 data
->file_created
= 1;
2088 else if (o_res
->cinfo
.before
!= o_res
->cinfo
.after
)
2089 data
->file_created
= 1;
2091 if ((o_res
->rflags
& NFS4_OPEN_RESULT_LOCKTYPE_POSIX
) == 0)
2092 server
->caps
&= ~NFS_CAP_POSIX_LOCK
;
2093 if(o_res
->rflags
& NFS4_OPEN_RESULT_CONFIRM
) {
2094 status
= _nfs4_proc_open_confirm(data
);
2098 if (!(o_res
->f_attr
->valid
& NFS_ATTR_FATTR
))
2099 nfs4_proc_getattr(server
, &o_res
->fh
, o_res
->f_attr
, o_res
->f_label
);
2103 static int nfs4_recover_expired_lease(struct nfs_server
*server
)
2105 return nfs4_client_recover_expired_lease(server
->nfs_client
);
2110 * reclaim state on the server after a network partition.
2111 * Assumes caller holds the appropriate lock
2113 static int _nfs4_open_expired(struct nfs_open_context
*ctx
, struct nfs4_state
*state
)
2115 struct nfs4_opendata
*opendata
;
2118 opendata
= nfs4_open_recoverdata_alloc(ctx
, state
,
2119 NFS4_OPEN_CLAIM_FH
);
2120 if (IS_ERR(opendata
))
2121 return PTR_ERR(opendata
);
2122 ret
= nfs4_open_recover(opendata
, state
);
2124 d_drop(ctx
->dentry
);
2125 nfs4_opendata_put(opendata
);
2129 static int nfs4_do_open_expired(struct nfs_open_context
*ctx
, struct nfs4_state
*state
)
2131 struct nfs_server
*server
= NFS_SERVER(state
->inode
);
2132 struct nfs4_exception exception
= { };
2136 err
= _nfs4_open_expired(ctx
, state
);
2137 trace_nfs4_open_expired(ctx
, 0, err
);
2138 if (nfs4_clear_cap_atomic_open_v1(server
, err
, &exception
))
2143 case -NFS4ERR_GRACE
:
2144 case -NFS4ERR_DELAY
:
2145 nfs4_handle_exception(server
, err
, &exception
);
2148 } while (exception
.retry
);
2153 static int nfs4_open_expired(struct nfs4_state_owner
*sp
, struct nfs4_state
*state
)
2155 struct nfs_open_context
*ctx
;
2158 ctx
= nfs4_state_find_open_context(state
);
2161 ret
= nfs4_do_open_expired(ctx
, state
);
2162 put_nfs_open_context(ctx
);
2166 static void nfs_finish_clear_delegation_stateid(struct nfs4_state
*state
)
2168 nfs_remove_bad_delegation(state
->inode
);
2169 write_seqlock(&state
->seqlock
);
2170 nfs4_stateid_copy(&state
->stateid
, &state
->open_stateid
);
2171 write_sequnlock(&state
->seqlock
);
2172 clear_bit(NFS_DELEGATED_STATE
, &state
->flags
);
2175 static void nfs40_clear_delegation_stateid(struct nfs4_state
*state
)
2177 if (rcu_access_pointer(NFS_I(state
->inode
)->delegation
) != NULL
)
2178 nfs_finish_clear_delegation_stateid(state
);
2181 static int nfs40_open_expired(struct nfs4_state_owner
*sp
, struct nfs4_state
*state
)
2183 /* NFSv4.0 doesn't allow for delegation recovery on open expire */
2184 nfs40_clear_delegation_stateid(state
);
2185 return nfs4_open_expired(sp
, state
);
2188 #if defined(CONFIG_NFS_V4_1)
2189 static void nfs41_check_delegation_stateid(struct nfs4_state
*state
)
2191 struct nfs_server
*server
= NFS_SERVER(state
->inode
);
2192 nfs4_stateid stateid
;
2193 struct nfs_delegation
*delegation
;
2194 struct rpc_cred
*cred
;
2197 /* Get the delegation credential for use by test/free_stateid */
2199 delegation
= rcu_dereference(NFS_I(state
->inode
)->delegation
);
2200 if (delegation
== NULL
) {
2205 nfs4_stateid_copy(&stateid
, &delegation
->stateid
);
2206 cred
= get_rpccred(delegation
->cred
);
2208 status
= nfs41_test_stateid(server
, &stateid
, cred
);
2209 trace_nfs4_test_delegation_stateid(state
, NULL
, status
);
2211 if (status
!= NFS_OK
) {
2212 /* Free the stateid unless the server explicitly
2213 * informs us the stateid is unrecognized. */
2214 if (status
!= -NFS4ERR_BAD_STATEID
)
2215 nfs41_free_stateid(server
, &stateid
, cred
);
2216 nfs_finish_clear_delegation_stateid(state
);
2223 * nfs41_check_open_stateid - possibly free an open stateid
2225 * @state: NFSv4 state for an inode
2227 * Returns NFS_OK if recovery for this stateid is now finished.
2228 * Otherwise a negative NFS4ERR value is returned.
2230 static int nfs41_check_open_stateid(struct nfs4_state
*state
)
2232 struct nfs_server
*server
= NFS_SERVER(state
->inode
);
2233 nfs4_stateid
*stateid
= &state
->open_stateid
;
2234 struct rpc_cred
*cred
= state
->owner
->so_cred
;
2237 /* If a state reset has been done, test_stateid is unneeded */
2238 if ((test_bit(NFS_O_RDONLY_STATE
, &state
->flags
) == 0) &&
2239 (test_bit(NFS_O_WRONLY_STATE
, &state
->flags
) == 0) &&
2240 (test_bit(NFS_O_RDWR_STATE
, &state
->flags
) == 0))
2241 return -NFS4ERR_BAD_STATEID
;
2243 status
= nfs41_test_stateid(server
, stateid
, cred
);
2244 trace_nfs4_test_open_stateid(state
, NULL
, status
);
2245 if (status
!= NFS_OK
) {
2246 /* Free the stateid unless the server explicitly
2247 * informs us the stateid is unrecognized. */
2248 if (status
!= -NFS4ERR_BAD_STATEID
)
2249 nfs41_free_stateid(server
, stateid
, cred
);
2251 clear_bit(NFS_O_RDONLY_STATE
, &state
->flags
);
2252 clear_bit(NFS_O_WRONLY_STATE
, &state
->flags
);
2253 clear_bit(NFS_O_RDWR_STATE
, &state
->flags
);
2254 clear_bit(NFS_OPEN_STATE
, &state
->flags
);
2259 static int nfs41_open_expired(struct nfs4_state_owner
*sp
, struct nfs4_state
*state
)
2263 nfs41_check_delegation_stateid(state
);
2264 status
= nfs41_check_open_stateid(state
);
2265 if (status
!= NFS_OK
)
2266 status
= nfs4_open_expired(sp
, state
);
2272 * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-*
2273 * fields corresponding to attributes that were used to store the verifier.
2274 * Make sure we clobber those fields in the later setattr call
2276 static inline void nfs4_exclusive_attrset(struct nfs4_opendata
*opendata
, struct iattr
*sattr
)
2278 if ((opendata
->o_res
.attrset
[1] & FATTR4_WORD1_TIME_ACCESS
) &&
2279 !(sattr
->ia_valid
& ATTR_ATIME_SET
))
2280 sattr
->ia_valid
|= ATTR_ATIME
;
2282 if ((opendata
->o_res
.attrset
[1] & FATTR4_WORD1_TIME_MODIFY
) &&
2283 !(sattr
->ia_valid
& ATTR_MTIME_SET
))
2284 sattr
->ia_valid
|= ATTR_MTIME
;
2287 static int _nfs4_open_and_get_state(struct nfs4_opendata
*opendata
,
2290 struct nfs_open_context
*ctx
)
2292 struct nfs4_state_owner
*sp
= opendata
->owner
;
2293 struct nfs_server
*server
= sp
->so_server
;
2294 struct dentry
*dentry
;
2295 struct nfs4_state
*state
;
2299 seq
= raw_seqcount_begin(&sp
->so_reclaim_seqcount
);
2301 ret
= _nfs4_proc_open(opendata
);
2305 state
= nfs4_opendata_to_nfs4_state(opendata
);
2306 ret
= PTR_ERR(state
);
2309 if (server
->caps
& NFS_CAP_POSIX_LOCK
)
2310 set_bit(NFS_STATE_POSIX_LOCKS
, &state
->flags
);
2312 dentry
= opendata
->dentry
;
2313 if (dentry
->d_inode
== NULL
) {
2314 /* FIXME: Is this d_drop() ever needed? */
2316 dentry
= d_add_unique(dentry
, igrab(state
->inode
));
2317 if (dentry
== NULL
) {
2318 dentry
= opendata
->dentry
;
2319 } else if (dentry
!= ctx
->dentry
) {
2321 ctx
->dentry
= dget(dentry
);
2323 nfs_set_verifier(dentry
,
2324 nfs_save_change_attribute(opendata
->dir
->d_inode
));
2327 ret
= nfs4_opendata_access(sp
->so_cred
, opendata
, state
, fmode
, flags
);
2332 if (dentry
->d_inode
== state
->inode
) {
2333 nfs_inode_attach_open_context(ctx
);
2334 if (read_seqcount_retry(&sp
->so_reclaim_seqcount
, seq
))
2335 nfs4_schedule_stateid_recovery(server
, state
);
2342 * Returns a referenced nfs4_state
2344 static int _nfs4_do_open(struct inode
*dir
,
2345 struct nfs_open_context
*ctx
,
2347 struct iattr
*sattr
,
2348 struct nfs4_label
*label
,
2351 struct nfs4_state_owner
*sp
;
2352 struct nfs4_state
*state
= NULL
;
2353 struct nfs_server
*server
= NFS_SERVER(dir
);
2354 struct nfs4_opendata
*opendata
;
2355 struct dentry
*dentry
= ctx
->dentry
;
2356 struct rpc_cred
*cred
= ctx
->cred
;
2357 struct nfs4_threshold
**ctx_th
= &ctx
->mdsthreshold
;
2358 fmode_t fmode
= ctx
->mode
& (FMODE_READ
|FMODE_WRITE
|FMODE_EXEC
);
2359 enum open_claim_type4 claim
= NFS4_OPEN_CLAIM_NULL
;
2360 struct nfs4_label
*olabel
= NULL
;
2363 /* Protect against reboot recovery conflicts */
2365 sp
= nfs4_get_state_owner(server
, cred
, GFP_KERNEL
);
2367 dprintk("nfs4_do_open: nfs4_get_state_owner failed!\n");
2370 status
= nfs4_recover_expired_lease(server
);
2372 goto err_put_state_owner
;
2373 if (dentry
->d_inode
!= NULL
)
2374 nfs4_return_incompatible_delegation(dentry
->d_inode
, fmode
);
2376 if (dentry
->d_inode
)
2377 claim
= NFS4_OPEN_CLAIM_FH
;
2378 opendata
= nfs4_opendata_alloc(dentry
, sp
, fmode
, flags
, sattr
,
2379 label
, claim
, GFP_KERNEL
);
2380 if (opendata
== NULL
)
2381 goto err_put_state_owner
;
2384 olabel
= nfs4_label_alloc(server
, GFP_KERNEL
);
2385 if (IS_ERR(olabel
)) {
2386 status
= PTR_ERR(olabel
);
2387 goto err_opendata_put
;
2391 if (server
->attr_bitmask
[2] & FATTR4_WORD2_MDSTHRESHOLD
) {
2392 if (!opendata
->f_attr
.mdsthreshold
) {
2393 opendata
->f_attr
.mdsthreshold
= pnfs_mdsthreshold_alloc();
2394 if (!opendata
->f_attr
.mdsthreshold
)
2395 goto err_free_label
;
2397 opendata
->o_arg
.open_bitmap
= &nfs4_pnfs_open_bitmap
[0];
2399 if (dentry
->d_inode
!= NULL
)
2400 opendata
->state
= nfs4_get_open_state(dentry
->d_inode
, sp
);
2402 status
= _nfs4_open_and_get_state(opendata
, fmode
, flags
, ctx
);
2404 goto err_free_label
;
2407 if ((opendata
->o_arg
.open_flags
& O_EXCL
) &&
2408 (opendata
->o_arg
.createmode
!= NFS4_CREATE_GUARDED
)) {
2409 nfs4_exclusive_attrset(opendata
, sattr
);
2411 nfs_fattr_init(opendata
->o_res
.f_attr
);
2412 status
= nfs4_do_setattr(state
->inode
, cred
,
2413 opendata
->o_res
.f_attr
, sattr
,
2414 state
, label
, olabel
);
2416 nfs_setattr_update_inode(state
->inode
, sattr
);
2417 nfs_post_op_update_inode(state
->inode
, opendata
->o_res
.f_attr
);
2418 nfs_setsecurity(state
->inode
, opendata
->o_res
.f_attr
, olabel
);
2421 if (opendata
->file_created
)
2422 *opened
|= FILE_CREATED
;
2424 if (pnfs_use_threshold(ctx_th
, opendata
->f_attr
.mdsthreshold
, server
)) {
2425 *ctx_th
= opendata
->f_attr
.mdsthreshold
;
2426 opendata
->f_attr
.mdsthreshold
= NULL
;
2429 nfs4_label_free(olabel
);
2431 nfs4_opendata_put(opendata
);
2432 nfs4_put_state_owner(sp
);
2435 nfs4_label_free(olabel
);
2437 nfs4_opendata_put(opendata
);
2438 err_put_state_owner
:
2439 nfs4_put_state_owner(sp
);
2445 static struct nfs4_state
*nfs4_do_open(struct inode
*dir
,
2446 struct nfs_open_context
*ctx
,
2448 struct iattr
*sattr
,
2449 struct nfs4_label
*label
,
2452 struct nfs_server
*server
= NFS_SERVER(dir
);
2453 struct nfs4_exception exception
= { };
2454 struct nfs4_state
*res
;
2458 status
= _nfs4_do_open(dir
, ctx
, flags
, sattr
, label
, opened
);
2460 trace_nfs4_open_file(ctx
, flags
, status
);
2463 /* NOTE: BAD_SEQID means the server and client disagree about the
2464 * book-keeping w.r.t. state-changing operations
2465 * (OPEN/CLOSE/LOCK/LOCKU...)
2466 * It is actually a sign of a bug on the client or on the server.
2468 * If we receive a BAD_SEQID error in the particular case of
2469 * doing an OPEN, we assume that nfs_increment_open_seqid() will
2470 * have unhashed the old state_owner for us, and that we can
2471 * therefore safely retry using a new one. We should still warn
2472 * the user though...
2474 if (status
== -NFS4ERR_BAD_SEQID
) {
2475 pr_warn_ratelimited("NFS: v4 server %s "
2476 " returned a bad sequence-id error!\n",
2477 NFS_SERVER(dir
)->nfs_client
->cl_hostname
);
2478 exception
.retry
= 1;
2482 * BAD_STATEID on OPEN means that the server cancelled our
2483 * state before it received the OPEN_CONFIRM.
2484 * Recover by retrying the request as per the discussion
2485 * on Page 181 of RFC3530.
2487 if (status
== -NFS4ERR_BAD_STATEID
) {
2488 exception
.retry
= 1;
2491 if (status
== -EAGAIN
) {
2492 /* We must have found a delegation */
2493 exception
.retry
= 1;
2496 if (nfs4_clear_cap_atomic_open_v1(server
, status
, &exception
))
2498 res
= ERR_PTR(nfs4_handle_exception(server
,
2499 status
, &exception
));
2500 } while (exception
.retry
);
2504 static int _nfs4_do_setattr(struct inode
*inode
, struct rpc_cred
*cred
,
2505 struct nfs_fattr
*fattr
, struct iattr
*sattr
,
2506 struct nfs4_state
*state
, struct nfs4_label
*ilabel
,
2507 struct nfs4_label
*olabel
)
2509 struct nfs_server
*server
= NFS_SERVER(inode
);
2510 struct nfs_setattrargs arg
= {
2511 .fh
= NFS_FH(inode
),
2514 .bitmask
= server
->attr_bitmask
,
2517 struct nfs_setattrres res
= {
2522 struct rpc_message msg
= {
2523 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_SETATTR
],
2528 unsigned long timestamp
= jiffies
;
2533 arg
.bitmask
= nfs4_bitmask(server
, ilabel
);
2535 arg
.bitmask
= nfs4_bitmask(server
, olabel
);
2537 nfs_fattr_init(fattr
);
2539 /* Servers should only apply open mode checks for file size changes */
2540 truncate
= (sattr
->ia_valid
& ATTR_SIZE
) ? true : false;
2541 fmode
= truncate
? FMODE_WRITE
: FMODE_READ
;
2543 if (nfs4_copy_delegation_stateid(&arg
.stateid
, inode
, fmode
)) {
2544 /* Use that stateid */
2545 } else if (truncate
&& state
!= NULL
) {
2546 struct nfs_lockowner lockowner
= {
2547 .l_owner
= current
->files
,
2548 .l_pid
= current
->tgid
,
2550 if (!nfs4_valid_open_stateid(state
))
2552 if (nfs4_select_rw_stateid(&arg
.stateid
, state
, FMODE_WRITE
,
2553 &lockowner
) == -EIO
)
2556 nfs4_stateid_copy(&arg
.stateid
, &zero_stateid
);
2558 status
= nfs4_call_sync(server
->client
, server
, &msg
, &arg
.seq_args
, &res
.seq_res
, 1);
2559 if (status
== 0 && state
!= NULL
)
2560 renew_lease(server
, timestamp
);
2564 static int nfs4_do_setattr(struct inode
*inode
, struct rpc_cred
*cred
,
2565 struct nfs_fattr
*fattr
, struct iattr
*sattr
,
2566 struct nfs4_state
*state
, struct nfs4_label
*ilabel
,
2567 struct nfs4_label
*olabel
)
2569 struct nfs_server
*server
= NFS_SERVER(inode
);
2570 struct nfs4_exception exception
= {
2576 err
= _nfs4_do_setattr(inode
, cred
, fattr
, sattr
, state
, ilabel
, olabel
);
2577 trace_nfs4_setattr(inode
, err
);
2579 case -NFS4ERR_OPENMODE
:
2580 if (!(sattr
->ia_valid
& ATTR_SIZE
)) {
2581 pr_warn_once("NFSv4: server %s is incorrectly "
2582 "applying open mode checks to "
2583 "a SETATTR that is not "
2584 "changing file size.\n",
2585 server
->nfs_client
->cl_hostname
);
2587 if (state
&& !(state
->state
& FMODE_WRITE
)) {
2589 if (sattr
->ia_valid
& ATTR_OPEN
)
2594 err
= nfs4_handle_exception(server
, err
, &exception
);
2595 } while (exception
.retry
);
2600 struct nfs4_closedata
{
2601 struct inode
*inode
;
2602 struct nfs4_state
*state
;
2603 struct nfs_closeargs arg
;
2604 struct nfs_closeres res
;
2605 struct nfs_fattr fattr
;
2606 unsigned long timestamp
;
2611 static void nfs4_free_closedata(void *data
)
2613 struct nfs4_closedata
*calldata
= data
;
2614 struct nfs4_state_owner
*sp
= calldata
->state
->owner
;
2615 struct super_block
*sb
= calldata
->state
->inode
->i_sb
;
2618 pnfs_roc_release(calldata
->state
->inode
);
2619 nfs4_put_open_state(calldata
->state
);
2620 nfs_free_seqid(calldata
->arg
.seqid
);
2621 nfs4_put_state_owner(sp
);
2622 nfs_sb_deactive(sb
);
2626 static void nfs4_close_done(struct rpc_task
*task
, void *data
)
2628 struct nfs4_closedata
*calldata
= data
;
2629 struct nfs4_state
*state
= calldata
->state
;
2630 struct nfs_server
*server
= NFS_SERVER(calldata
->inode
);
2631 nfs4_stateid
*res_stateid
= NULL
;
2633 dprintk("%s: begin!\n", __func__
);
2634 if (!nfs4_sequence_done(task
, &calldata
->res
.seq_res
))
2636 trace_nfs4_close(state
, &calldata
->arg
, &calldata
->res
, task
->tk_status
);
2637 /* hmm. we are done with the inode, and in the process of freeing
2638 * the state_owner. we keep this around to process errors
2640 switch (task
->tk_status
) {
2642 res_stateid
= &calldata
->res
.stateid
;
2643 if (calldata
->arg
.fmode
== 0 && calldata
->roc
)
2644 pnfs_roc_set_barrier(state
->inode
,
2645 calldata
->roc_barrier
);
2646 renew_lease(server
, calldata
->timestamp
);
2648 case -NFS4ERR_ADMIN_REVOKED
:
2649 case -NFS4ERR_STALE_STATEID
:
2650 case -NFS4ERR_OLD_STATEID
:
2651 case -NFS4ERR_BAD_STATEID
:
2652 case -NFS4ERR_EXPIRED
:
2653 if (!nfs4_stateid_match(&calldata
->arg
.stateid
,
2655 rpc_restart_call_prepare(task
);
2658 if (calldata
->arg
.fmode
== 0)
2661 if (nfs4_async_handle_error(task
, server
, state
, NULL
) == -EAGAIN
) {
2662 rpc_restart_call_prepare(task
);
2666 nfs_clear_open_stateid(state
, res_stateid
, calldata
->arg
.fmode
);
2668 nfs_release_seqid(calldata
->arg
.seqid
);
2669 nfs_refresh_inode(calldata
->inode
, calldata
->res
.fattr
);
2670 dprintk("%s: done, ret = %d!\n", __func__
, task
->tk_status
);
2673 static void nfs4_close_prepare(struct rpc_task
*task
, void *data
)
2675 struct nfs4_closedata
*calldata
= data
;
2676 struct nfs4_state
*state
= calldata
->state
;
2677 struct inode
*inode
= calldata
->inode
;
2678 bool is_rdonly
, is_wronly
, is_rdwr
;
2681 dprintk("%s: begin!\n", __func__
);
2682 if (nfs_wait_on_sequence(calldata
->arg
.seqid
, task
) != 0)
2685 task
->tk_msg
.rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_OPEN_DOWNGRADE
];
2686 spin_lock(&state
->owner
->so_lock
);
2687 is_rdwr
= test_bit(NFS_O_RDWR_STATE
, &state
->flags
);
2688 is_rdonly
= test_bit(NFS_O_RDONLY_STATE
, &state
->flags
);
2689 is_wronly
= test_bit(NFS_O_WRONLY_STATE
, &state
->flags
);
2690 nfs4_stateid_copy(&calldata
->arg
.stateid
, &state
->stateid
);
2691 /* Calculate the change in open mode */
2692 calldata
->arg
.fmode
= 0;
2693 if (state
->n_rdwr
== 0) {
2694 if (state
->n_rdonly
== 0)
2695 call_close
|= is_rdonly
;
2697 calldata
->arg
.fmode
|= FMODE_READ
;
2698 if (state
->n_wronly
== 0)
2699 call_close
|= is_wronly
;
2701 calldata
->arg
.fmode
|= FMODE_WRITE
;
2703 calldata
->arg
.fmode
|= FMODE_READ
|FMODE_WRITE
;
2705 if (calldata
->arg
.fmode
== 0)
2706 call_close
|= is_rdwr
;
2708 if (!nfs4_valid_open_stateid(state
))
2710 spin_unlock(&state
->owner
->so_lock
);
2713 /* Note: exit _without_ calling nfs4_close_done */
2717 if (calldata
->arg
.fmode
== 0) {
2718 task
->tk_msg
.rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_CLOSE
];
2719 if (calldata
->roc
&&
2720 pnfs_roc_drain(inode
, &calldata
->roc_barrier
, task
)) {
2721 nfs_release_seqid(calldata
->arg
.seqid
);
2725 calldata
->arg
.share_access
=
2726 nfs4_map_atomic_open_share(NFS_SERVER(inode
),
2727 calldata
->arg
.fmode
, 0);
2729 nfs_fattr_init(calldata
->res
.fattr
);
2730 calldata
->timestamp
= jiffies
;
2731 if (nfs4_setup_sequence(NFS_SERVER(inode
),
2732 &calldata
->arg
.seq_args
,
2733 &calldata
->res
.seq_res
,
2735 nfs_release_seqid(calldata
->arg
.seqid
);
2736 dprintk("%s: done!\n", __func__
);
2739 task
->tk_action
= NULL
;
2741 nfs4_sequence_done(task
, &calldata
->res
.seq_res
);
2744 static const struct rpc_call_ops nfs4_close_ops
= {
2745 .rpc_call_prepare
= nfs4_close_prepare
,
2746 .rpc_call_done
= nfs4_close_done
,
2747 .rpc_release
= nfs4_free_closedata
,
2750 static bool nfs4_roc(struct inode
*inode
)
2752 if (!nfs_have_layout(inode
))
2754 return pnfs_roc(inode
);
2758 * It is possible for data to be read/written from a mem-mapped file
2759 * after the sys_close call (which hits the vfs layer as a flush).
2760 * This means that we can't safely call nfsv4 close on a file until
2761 * the inode is cleared. This in turn means that we are not good
2762 * NFSv4 citizens - we do not indicate to the server to update the file's
2763 * share state even when we are done with one of the three share
2764 * stateid's in the inode.
2766 * NOTE: Caller must be holding the sp->so_owner semaphore!
2768 int nfs4_do_close(struct nfs4_state
*state
, gfp_t gfp_mask
, int wait
)
2770 struct nfs_server
*server
= NFS_SERVER(state
->inode
);
2771 struct nfs_seqid
*(*alloc_seqid
)(struct nfs_seqid_counter
*, gfp_t
);
2772 struct nfs4_closedata
*calldata
;
2773 struct nfs4_state_owner
*sp
= state
->owner
;
2774 struct rpc_task
*task
;
2775 struct rpc_message msg
= {
2776 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_CLOSE
],
2777 .rpc_cred
= state
->owner
->so_cred
,
2779 struct rpc_task_setup task_setup_data
= {
2780 .rpc_client
= server
->client
,
2781 .rpc_message
= &msg
,
2782 .callback_ops
= &nfs4_close_ops
,
2783 .workqueue
= nfsiod_workqueue
,
2784 .flags
= RPC_TASK_ASYNC
,
2786 int status
= -ENOMEM
;
2788 nfs4_state_protect(server
->nfs_client
, NFS_SP4_MACH_CRED_CLEANUP
,
2789 &task_setup_data
.rpc_client
, &msg
);
2791 calldata
= kzalloc(sizeof(*calldata
), gfp_mask
);
2792 if (calldata
== NULL
)
2794 nfs4_init_sequence(&calldata
->arg
.seq_args
, &calldata
->res
.seq_res
, 1);
2795 calldata
->inode
= state
->inode
;
2796 calldata
->state
= state
;
2797 calldata
->arg
.fh
= NFS_FH(state
->inode
);
2798 /* Serialization for the sequence id */
2799 alloc_seqid
= server
->nfs_client
->cl_mvops
->alloc_seqid
;
2800 calldata
->arg
.seqid
= alloc_seqid(&state
->owner
->so_seqid
, gfp_mask
);
2801 if (IS_ERR(calldata
->arg
.seqid
))
2802 goto out_free_calldata
;
2803 calldata
->arg
.fmode
= 0;
2804 calldata
->arg
.bitmask
= server
->cache_consistency_bitmask
;
2805 calldata
->res
.fattr
= &calldata
->fattr
;
2806 calldata
->res
.seqid
= calldata
->arg
.seqid
;
2807 calldata
->res
.server
= server
;
2808 calldata
->roc
= nfs4_roc(state
->inode
);
2809 nfs_sb_active(calldata
->inode
->i_sb
);
2811 msg
.rpc_argp
= &calldata
->arg
;
2812 msg
.rpc_resp
= &calldata
->res
;
2813 task_setup_data
.callback_data
= calldata
;
2814 task
= rpc_run_task(&task_setup_data
);
2816 return PTR_ERR(task
);
2819 status
= rpc_wait_for_completion_task(task
);
2825 nfs4_put_open_state(state
);
2826 nfs4_put_state_owner(sp
);
2830 static struct inode
*
2831 nfs4_atomic_open(struct inode
*dir
, struct nfs_open_context
*ctx
,
2832 int open_flags
, struct iattr
*attr
, int *opened
)
2834 struct nfs4_state
*state
;
2835 struct nfs4_label l
= {0, 0, 0, NULL
}, *label
= NULL
;
2837 label
= nfs4_label_init_security(dir
, ctx
->dentry
, attr
, &l
);
2839 /* Protect against concurrent sillydeletes */
2840 state
= nfs4_do_open(dir
, ctx
, open_flags
, attr
, label
, opened
);
2842 nfs4_label_release_security(label
);
2845 return ERR_CAST(state
);
2846 return state
->inode
;
2849 static void nfs4_close_context(struct nfs_open_context
*ctx
, int is_sync
)
2851 if (ctx
->state
== NULL
)
2854 nfs4_close_sync(ctx
->state
, ctx
->mode
);
2856 nfs4_close_state(ctx
->state
, ctx
->mode
);
2859 #define FATTR4_WORD1_NFS40_MASK (2*FATTR4_WORD1_MOUNTED_ON_FILEID - 1UL)
2860 #define FATTR4_WORD2_NFS41_MASK (2*FATTR4_WORD2_SUPPATTR_EXCLCREAT - 1UL)
2861 #define FATTR4_WORD2_NFS42_MASK (2*FATTR4_WORD2_SECURITY_LABEL - 1UL)
2863 static int _nfs4_server_capabilities(struct nfs_server
*server
, struct nfs_fh
*fhandle
)
2865 struct nfs4_server_caps_arg args
= {
2868 struct nfs4_server_caps_res res
= {};
2869 struct rpc_message msg
= {
2870 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_SERVER_CAPS
],
2876 status
= nfs4_call_sync(server
->client
, server
, &msg
, &args
.seq_args
, &res
.seq_res
, 0);
2878 /* Sanity check the server answers */
2879 switch (server
->nfs_client
->cl_minorversion
) {
2881 res
.attr_bitmask
[1] &= FATTR4_WORD1_NFS40_MASK
;
2882 res
.attr_bitmask
[2] = 0;
2885 res
.attr_bitmask
[2] &= FATTR4_WORD2_NFS41_MASK
;
2888 res
.attr_bitmask
[2] &= FATTR4_WORD2_NFS42_MASK
;
2890 memcpy(server
->attr_bitmask
, res
.attr_bitmask
, sizeof(server
->attr_bitmask
));
2891 server
->caps
&= ~(NFS_CAP_ACLS
|NFS_CAP_HARDLINKS
|
2892 NFS_CAP_SYMLINKS
|NFS_CAP_FILEID
|
2893 NFS_CAP_MODE
|NFS_CAP_NLINK
|NFS_CAP_OWNER
|
2894 NFS_CAP_OWNER_GROUP
|NFS_CAP_ATIME
|
2895 NFS_CAP_CTIME
|NFS_CAP_MTIME
|
2896 NFS_CAP_SECURITY_LABEL
);
2897 if (res
.attr_bitmask
[0] & FATTR4_WORD0_ACL
&&
2898 res
.acl_bitmask
& ACL4_SUPPORT_ALLOW_ACL
)
2899 server
->caps
|= NFS_CAP_ACLS
;
2900 if (res
.has_links
!= 0)
2901 server
->caps
|= NFS_CAP_HARDLINKS
;
2902 if (res
.has_symlinks
!= 0)
2903 server
->caps
|= NFS_CAP_SYMLINKS
;
2904 if (res
.attr_bitmask
[0] & FATTR4_WORD0_FILEID
)
2905 server
->caps
|= NFS_CAP_FILEID
;
2906 if (res
.attr_bitmask
[1] & FATTR4_WORD1_MODE
)
2907 server
->caps
|= NFS_CAP_MODE
;
2908 if (res
.attr_bitmask
[1] & FATTR4_WORD1_NUMLINKS
)
2909 server
->caps
|= NFS_CAP_NLINK
;
2910 if (res
.attr_bitmask
[1] & FATTR4_WORD1_OWNER
)
2911 server
->caps
|= NFS_CAP_OWNER
;
2912 if (res
.attr_bitmask
[1] & FATTR4_WORD1_OWNER_GROUP
)
2913 server
->caps
|= NFS_CAP_OWNER_GROUP
;
2914 if (res
.attr_bitmask
[1] & FATTR4_WORD1_TIME_ACCESS
)
2915 server
->caps
|= NFS_CAP_ATIME
;
2916 if (res
.attr_bitmask
[1] & FATTR4_WORD1_TIME_METADATA
)
2917 server
->caps
|= NFS_CAP_CTIME
;
2918 if (res
.attr_bitmask
[1] & FATTR4_WORD1_TIME_MODIFY
)
2919 server
->caps
|= NFS_CAP_MTIME
;
2920 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
2921 if (res
.attr_bitmask
[2] & FATTR4_WORD2_SECURITY_LABEL
)
2922 server
->caps
|= NFS_CAP_SECURITY_LABEL
;
2924 memcpy(server
->attr_bitmask_nl
, res
.attr_bitmask
,
2925 sizeof(server
->attr_bitmask
));
2926 server
->attr_bitmask_nl
[2] &= ~FATTR4_WORD2_SECURITY_LABEL
;
2928 memcpy(server
->cache_consistency_bitmask
, res
.attr_bitmask
, sizeof(server
->cache_consistency_bitmask
));
2929 server
->cache_consistency_bitmask
[0] &= FATTR4_WORD0_CHANGE
|FATTR4_WORD0_SIZE
;
2930 server
->cache_consistency_bitmask
[1] &= FATTR4_WORD1_TIME_METADATA
|FATTR4_WORD1_TIME_MODIFY
;
2931 server
->cache_consistency_bitmask
[2] = 0;
2932 server
->acl_bitmask
= res
.acl_bitmask
;
2933 server
->fh_expire_type
= res
.fh_expire_type
;
2939 int nfs4_server_capabilities(struct nfs_server
*server
, struct nfs_fh
*fhandle
)
2941 struct nfs4_exception exception
= { };
2944 err
= nfs4_handle_exception(server
,
2945 _nfs4_server_capabilities(server
, fhandle
),
2947 } while (exception
.retry
);
2951 static int _nfs4_lookup_root(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
2952 struct nfs_fsinfo
*info
)
2955 struct nfs4_lookup_root_arg args
= {
2958 struct nfs4_lookup_res res
= {
2960 .fattr
= info
->fattr
,
2963 struct rpc_message msg
= {
2964 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_LOOKUP_ROOT
],
2969 bitmask
[0] = nfs4_fattr_bitmap
[0];
2970 bitmask
[1] = nfs4_fattr_bitmap
[1];
2972 * Process the label in the upcoming getfattr
2974 bitmask
[2] = nfs4_fattr_bitmap
[2] & ~FATTR4_WORD2_SECURITY_LABEL
;
2976 nfs_fattr_init(info
->fattr
);
2977 return nfs4_call_sync(server
->client
, server
, &msg
, &args
.seq_args
, &res
.seq_res
, 0);
2980 static int nfs4_lookup_root(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
2981 struct nfs_fsinfo
*info
)
2983 struct nfs4_exception exception
= { };
2986 err
= _nfs4_lookup_root(server
, fhandle
, info
);
2987 trace_nfs4_lookup_root(server
, fhandle
, info
->fattr
, err
);
2990 case -NFS4ERR_WRONGSEC
:
2993 err
= nfs4_handle_exception(server
, err
, &exception
);
2995 } while (exception
.retry
);
3000 static int nfs4_lookup_root_sec(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
3001 struct nfs_fsinfo
*info
, rpc_authflavor_t flavor
)
3003 struct rpc_auth_create_args auth_args
= {
3004 .pseudoflavor
= flavor
,
3006 struct rpc_auth
*auth
;
3009 auth
= rpcauth_create(&auth_args
, server
->client
);
3014 ret
= nfs4_lookup_root(server
, fhandle
, info
);
3020 * Retry pseudoroot lookup with various security flavors. We do this when:
3022 * NFSv4.0: the PUTROOTFH operation returns NFS4ERR_WRONGSEC
3023 * NFSv4.1: the server does not support the SECINFO_NO_NAME operation
3025 * Returns zero on success, or a negative NFS4ERR value, or a
3026 * negative errno value.
3028 static int nfs4_find_root_sec(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
3029 struct nfs_fsinfo
*info
)
3031 /* Per 3530bis 15.33.5 */
3032 static const rpc_authflavor_t flav_array
[] = {
3036 RPC_AUTH_UNIX
, /* courtesy */
3039 int status
= -EPERM
;
3042 if (server
->auth_info
.flavor_len
> 0) {
3043 /* try each flavor specified by user */
3044 for (i
= 0; i
< server
->auth_info
.flavor_len
; i
++) {
3045 status
= nfs4_lookup_root_sec(server
, fhandle
, info
,
3046 server
->auth_info
.flavors
[i
]);
3047 if (status
== -NFS4ERR_WRONGSEC
|| status
== -EACCES
)
3052 /* no flavors specified by user, try default list */
3053 for (i
= 0; i
< ARRAY_SIZE(flav_array
); i
++) {
3054 status
= nfs4_lookup_root_sec(server
, fhandle
, info
,
3056 if (status
== -NFS4ERR_WRONGSEC
|| status
== -EACCES
)
3063 * -EACCESS could mean that the user doesn't have correct permissions
3064 * to access the mount. It could also mean that we tried to mount
3065 * with a gss auth flavor, but rpc.gssd isn't running. Either way,
3066 * existing mount programs don't handle -EACCES very well so it should
3067 * be mapped to -EPERM instead.
3069 if (status
== -EACCES
)
3074 static int nfs4_do_find_root_sec(struct nfs_server
*server
,
3075 struct nfs_fh
*fhandle
, struct nfs_fsinfo
*info
)
3077 int mv
= server
->nfs_client
->cl_minorversion
;
3078 return nfs_v4_minor_ops
[mv
]->find_root_sec(server
, fhandle
, info
);
3082 * nfs4_proc_get_rootfh - get file handle for server's pseudoroot
3083 * @server: initialized nfs_server handle
3084 * @fhandle: we fill in the pseudo-fs root file handle
3085 * @info: we fill in an FSINFO struct
3086 * @auth_probe: probe the auth flavours
3088 * Returns zero on success, or a negative errno.
3090 int nfs4_proc_get_rootfh(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
3091 struct nfs_fsinfo
*info
,
3096 switch (auth_probe
) {
3098 status
= nfs4_lookup_root(server
, fhandle
, info
);
3099 if (status
!= -NFS4ERR_WRONGSEC
)
3102 status
= nfs4_do_find_root_sec(server
, fhandle
, info
);
3106 status
= nfs4_server_capabilities(server
, fhandle
);
3108 status
= nfs4_do_fsinfo(server
, fhandle
, info
);
3110 return nfs4_map_errors(status
);
3113 static int nfs4_proc_get_root(struct nfs_server
*server
, struct nfs_fh
*mntfh
,
3114 struct nfs_fsinfo
*info
)
3117 struct nfs_fattr
*fattr
= info
->fattr
;
3118 struct nfs4_label
*label
= NULL
;
3120 error
= nfs4_server_capabilities(server
, mntfh
);
3122 dprintk("nfs4_get_root: getcaps error = %d\n", -error
);
3126 label
= nfs4_label_alloc(server
, GFP_KERNEL
);
3128 return PTR_ERR(label
);
3130 error
= nfs4_proc_getattr(server
, mntfh
, fattr
, label
);
3132 dprintk("nfs4_get_root: getattr error = %d\n", -error
);
3133 goto err_free_label
;
3136 if (fattr
->valid
& NFS_ATTR_FATTR_FSID
&&
3137 !nfs_fsid_equal(&server
->fsid
, &fattr
->fsid
))
3138 memcpy(&server
->fsid
, &fattr
->fsid
, sizeof(server
->fsid
));
3141 nfs4_label_free(label
);
3147 * Get locations and (maybe) other attributes of a referral.
3148 * Note that we'll actually follow the referral later when
3149 * we detect fsid mismatch in inode revalidation
3151 static int nfs4_get_referral(struct rpc_clnt
*client
, struct inode
*dir
,
3152 const struct qstr
*name
, struct nfs_fattr
*fattr
,
3153 struct nfs_fh
*fhandle
)
3155 int status
= -ENOMEM
;
3156 struct page
*page
= NULL
;
3157 struct nfs4_fs_locations
*locations
= NULL
;
3159 page
= alloc_page(GFP_KERNEL
);
3162 locations
= kmalloc(sizeof(struct nfs4_fs_locations
), GFP_KERNEL
);
3163 if (locations
== NULL
)
3166 status
= nfs4_proc_fs_locations(client
, dir
, name
, locations
, page
);
3171 * If the fsid didn't change, this is a migration event, not a
3172 * referral. Cause us to drop into the exception handler, which
3173 * will kick off migration recovery.
3175 if (nfs_fsid_equal(&NFS_SERVER(dir
)->fsid
, &locations
->fattr
.fsid
)) {
3176 dprintk("%s: server did not return a different fsid for"
3177 " a referral at %s\n", __func__
, name
->name
);
3178 status
= -NFS4ERR_MOVED
;
3181 /* Fixup attributes for the nfs_lookup() call to nfs_fhget() */
3182 nfs_fixup_referral_attributes(&locations
->fattr
);
3184 /* replace the lookup nfs_fattr with the locations nfs_fattr */
3185 memcpy(fattr
, &locations
->fattr
, sizeof(struct nfs_fattr
));
3186 memset(fhandle
, 0, sizeof(struct nfs_fh
));
3194 static int _nfs4_proc_getattr(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
3195 struct nfs_fattr
*fattr
, struct nfs4_label
*label
)
3197 struct nfs4_getattr_arg args
= {
3199 .bitmask
= server
->attr_bitmask
,
3201 struct nfs4_getattr_res res
= {
3206 struct rpc_message msg
= {
3207 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_GETATTR
],
3212 args
.bitmask
= nfs4_bitmask(server
, label
);
3214 nfs_fattr_init(fattr
);
3215 return nfs4_call_sync(server
->client
, server
, &msg
, &args
.seq_args
, &res
.seq_res
, 0);
3218 static int nfs4_proc_getattr(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
3219 struct nfs_fattr
*fattr
, struct nfs4_label
*label
)
3221 struct nfs4_exception exception
= { };
3224 err
= _nfs4_proc_getattr(server
, fhandle
, fattr
, label
);
3225 trace_nfs4_getattr(server
, fhandle
, fattr
, err
);
3226 err
= nfs4_handle_exception(server
, err
,
3228 } while (exception
.retry
);
3233 * The file is not closed if it is opened due to the a request to change
3234 * the size of the file. The open call will not be needed once the
3235 * VFS layer lookup-intents are implemented.
3237 * Close is called when the inode is destroyed.
3238 * If we haven't opened the file for O_WRONLY, we
3239 * need to in the size_change case to obtain a stateid.
3242 * Because OPEN is always done by name in nfsv4, it is
3243 * possible that we opened a different file by the same
3244 * name. We can recognize this race condition, but we
3245 * can't do anything about it besides returning an error.
3247 * This will be fixed with VFS changes (lookup-intent).
3250 nfs4_proc_setattr(struct dentry
*dentry
, struct nfs_fattr
*fattr
,
3251 struct iattr
*sattr
)
3253 struct inode
*inode
= dentry
->d_inode
;
3254 struct rpc_cred
*cred
= NULL
;
3255 struct nfs4_state
*state
= NULL
;
3256 struct nfs4_label
*label
= NULL
;
3259 if (pnfs_ld_layoutret_on_setattr(inode
) &&
3260 sattr
->ia_valid
& ATTR_SIZE
&&
3261 sattr
->ia_size
< i_size_read(inode
))
3262 pnfs_commit_and_return_layout(inode
);
3264 nfs_fattr_init(fattr
);
3266 /* Deal with open(O_TRUNC) */
3267 if (sattr
->ia_valid
& ATTR_OPEN
)
3268 sattr
->ia_valid
&= ~(ATTR_MTIME
|ATTR_CTIME
);
3270 /* Optimization: if the end result is no change, don't RPC */
3271 if ((sattr
->ia_valid
& ~(ATTR_FILE
|ATTR_OPEN
)) == 0)
3274 /* Search for an existing open(O_WRITE) file */
3275 if (sattr
->ia_valid
& ATTR_FILE
) {
3276 struct nfs_open_context
*ctx
;
3278 ctx
= nfs_file_open_context(sattr
->ia_file
);
3285 label
= nfs4_label_alloc(NFS_SERVER(inode
), GFP_KERNEL
);
3287 return PTR_ERR(label
);
3289 status
= nfs4_do_setattr(inode
, cred
, fattr
, sattr
, state
, NULL
, label
);
3291 nfs_setattr_update_inode(inode
, sattr
);
3292 nfs_setsecurity(inode
, fattr
, label
);
3294 nfs4_label_free(label
);
3298 static int _nfs4_proc_lookup(struct rpc_clnt
*clnt
, struct inode
*dir
,
3299 const struct qstr
*name
, struct nfs_fh
*fhandle
,
3300 struct nfs_fattr
*fattr
, struct nfs4_label
*label
)
3302 struct nfs_server
*server
= NFS_SERVER(dir
);
3304 struct nfs4_lookup_arg args
= {
3305 .bitmask
= server
->attr_bitmask
,
3306 .dir_fh
= NFS_FH(dir
),
3309 struct nfs4_lookup_res res
= {
3315 struct rpc_message msg
= {
3316 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_LOOKUP
],
3321 args
.bitmask
= nfs4_bitmask(server
, label
);
3323 nfs_fattr_init(fattr
);
3325 dprintk("NFS call lookup %s\n", name
->name
);
3326 status
= nfs4_call_sync(clnt
, server
, &msg
, &args
.seq_args
, &res
.seq_res
, 0);
3327 dprintk("NFS reply lookup: %d\n", status
);
3331 static void nfs_fixup_secinfo_attributes(struct nfs_fattr
*fattr
)
3333 fattr
->valid
|= NFS_ATTR_FATTR_TYPE
| NFS_ATTR_FATTR_MODE
|
3334 NFS_ATTR_FATTR_NLINK
| NFS_ATTR_FATTR_MOUNTPOINT
;
3335 fattr
->mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
;
3339 static int nfs4_proc_lookup_common(struct rpc_clnt
**clnt
, struct inode
*dir
,
3340 struct qstr
*name
, struct nfs_fh
*fhandle
,
3341 struct nfs_fattr
*fattr
, struct nfs4_label
*label
)
3343 struct nfs4_exception exception
= { };
3344 struct rpc_clnt
*client
= *clnt
;
3347 err
= _nfs4_proc_lookup(client
, dir
, name
, fhandle
, fattr
, label
);
3348 trace_nfs4_lookup(dir
, name
, err
);
3350 case -NFS4ERR_BADNAME
:
3353 case -NFS4ERR_MOVED
:
3354 err
= nfs4_get_referral(client
, dir
, name
, fattr
, fhandle
);
3356 case -NFS4ERR_WRONGSEC
:
3358 if (client
!= *clnt
)
3360 client
= nfs4_negotiate_security(client
, dir
, name
);
3362 return PTR_ERR(client
);
3364 exception
.retry
= 1;
3367 err
= nfs4_handle_exception(NFS_SERVER(dir
), err
, &exception
);
3369 } while (exception
.retry
);
3374 else if (client
!= *clnt
)
3375 rpc_shutdown_client(client
);
3380 static int nfs4_proc_lookup(struct inode
*dir
, struct qstr
*name
,
3381 struct nfs_fh
*fhandle
, struct nfs_fattr
*fattr
,
3382 struct nfs4_label
*label
)
3385 struct rpc_clnt
*client
= NFS_CLIENT(dir
);
3387 status
= nfs4_proc_lookup_common(&client
, dir
, name
, fhandle
, fattr
, label
);
3388 if (client
!= NFS_CLIENT(dir
)) {
3389 rpc_shutdown_client(client
);
3390 nfs_fixup_secinfo_attributes(fattr
);
3396 nfs4_proc_lookup_mountpoint(struct inode
*dir
, struct qstr
*name
,
3397 struct nfs_fh
*fhandle
, struct nfs_fattr
*fattr
)
3399 struct rpc_clnt
*client
= NFS_CLIENT(dir
);
3402 status
= nfs4_proc_lookup_common(&client
, dir
, name
, fhandle
, fattr
, NULL
);
3404 return ERR_PTR(status
);
3405 return (client
== NFS_CLIENT(dir
)) ? rpc_clone_client(client
) : client
;
3408 static int _nfs4_proc_access(struct inode
*inode
, struct nfs_access_entry
*entry
)
3410 struct nfs_server
*server
= NFS_SERVER(inode
);
3411 struct nfs4_accessargs args
= {
3412 .fh
= NFS_FH(inode
),
3413 .bitmask
= server
->cache_consistency_bitmask
,
3415 struct nfs4_accessres res
= {
3418 struct rpc_message msg
= {
3419 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_ACCESS
],
3422 .rpc_cred
= entry
->cred
,
3424 int mode
= entry
->mask
;
3428 * Determine which access bits we want to ask for...
3430 if (mode
& MAY_READ
)
3431 args
.access
|= NFS4_ACCESS_READ
;
3432 if (S_ISDIR(inode
->i_mode
)) {
3433 if (mode
& MAY_WRITE
)
3434 args
.access
|= NFS4_ACCESS_MODIFY
| NFS4_ACCESS_EXTEND
| NFS4_ACCESS_DELETE
;
3435 if (mode
& MAY_EXEC
)
3436 args
.access
|= NFS4_ACCESS_LOOKUP
;
3438 if (mode
& MAY_WRITE
)
3439 args
.access
|= NFS4_ACCESS_MODIFY
| NFS4_ACCESS_EXTEND
;
3440 if (mode
& MAY_EXEC
)
3441 args
.access
|= NFS4_ACCESS_EXECUTE
;
3444 res
.fattr
= nfs_alloc_fattr();
3445 if (res
.fattr
== NULL
)
3448 status
= nfs4_call_sync(server
->client
, server
, &msg
, &args
.seq_args
, &res
.seq_res
, 0);
3450 nfs_access_set_mask(entry
, res
.access
);
3451 nfs_refresh_inode(inode
, res
.fattr
);
3453 nfs_free_fattr(res
.fattr
);
3457 static int nfs4_proc_access(struct inode
*inode
, struct nfs_access_entry
*entry
)
3459 struct nfs4_exception exception
= { };
3462 err
= _nfs4_proc_access(inode
, entry
);
3463 trace_nfs4_access(inode
, err
);
3464 err
= nfs4_handle_exception(NFS_SERVER(inode
), err
,
3466 } while (exception
.retry
);
3471 * TODO: For the time being, we don't try to get any attributes
3472 * along with any of the zero-copy operations READ, READDIR,
3475 * In the case of the first three, we want to put the GETATTR
3476 * after the read-type operation -- this is because it is hard
3477 * to predict the length of a GETATTR response in v4, and thus
3478 * align the READ data correctly. This means that the GETATTR
3479 * may end up partially falling into the page cache, and we should
3480 * shift it into the 'tail' of the xdr_buf before processing.
3481 * To do this efficiently, we need to know the total length
3482 * of data received, which doesn't seem to be available outside
3485 * In the case of WRITE, we also want to put the GETATTR after
3486 * the operation -- in this case because we want to make sure
3487 * we get the post-operation mtime and size.
3489 * Both of these changes to the XDR layer would in fact be quite
3490 * minor, but I decided to leave them for a subsequent patch.
3492 static int _nfs4_proc_readlink(struct inode
*inode
, struct page
*page
,
3493 unsigned int pgbase
, unsigned int pglen
)
3495 struct nfs4_readlink args
= {
3496 .fh
= NFS_FH(inode
),
3501 struct nfs4_readlink_res res
;
3502 struct rpc_message msg
= {
3503 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_READLINK
],
3508 return nfs4_call_sync(NFS_SERVER(inode
)->client
, NFS_SERVER(inode
), &msg
, &args
.seq_args
, &res
.seq_res
, 0);
3511 static int nfs4_proc_readlink(struct inode
*inode
, struct page
*page
,
3512 unsigned int pgbase
, unsigned int pglen
)
3514 struct nfs4_exception exception
= { };
3517 err
= _nfs4_proc_readlink(inode
, page
, pgbase
, pglen
);
3518 trace_nfs4_readlink(inode
, err
);
3519 err
= nfs4_handle_exception(NFS_SERVER(inode
), err
,
3521 } while (exception
.retry
);
3526 * This is just for mknod. open(O_CREAT) will always do ->open_context().
3529 nfs4_proc_create(struct inode
*dir
, struct dentry
*dentry
, struct iattr
*sattr
,
3532 struct nfs4_label l
, *ilabel
= NULL
;
3533 struct nfs_open_context
*ctx
;
3534 struct nfs4_state
*state
;
3538 ctx
= alloc_nfs_open_context(dentry
, FMODE_READ
);
3540 return PTR_ERR(ctx
);
3542 ilabel
= nfs4_label_init_security(dir
, dentry
, sattr
, &l
);
3544 sattr
->ia_mode
&= ~current_umask();
3545 state
= nfs4_do_open(dir
, ctx
, flags
, sattr
, ilabel
, &opened
);
3546 if (IS_ERR(state
)) {
3547 status
= PTR_ERR(state
);
3551 nfs4_label_release_security(ilabel
);
3552 put_nfs_open_context(ctx
);
3556 static int _nfs4_proc_remove(struct inode
*dir
, struct qstr
*name
)
3558 struct nfs_server
*server
= NFS_SERVER(dir
);
3559 struct nfs_removeargs args
= {
3563 struct nfs_removeres res
= {
3566 struct rpc_message msg
= {
3567 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_REMOVE
],
3573 status
= nfs4_call_sync(server
->client
, server
, &msg
, &args
.seq_args
, &res
.seq_res
, 1);
3575 update_changeattr(dir
, &res
.cinfo
);
3579 static int nfs4_proc_remove(struct inode
*dir
, struct qstr
*name
)
3581 struct nfs4_exception exception
= { };
3584 err
= _nfs4_proc_remove(dir
, name
);
3585 trace_nfs4_remove(dir
, name
, err
);
3586 err
= nfs4_handle_exception(NFS_SERVER(dir
), err
,
3588 } while (exception
.retry
);
3592 static void nfs4_proc_unlink_setup(struct rpc_message
*msg
, struct inode
*dir
)
3594 struct nfs_server
*server
= NFS_SERVER(dir
);
3595 struct nfs_removeargs
*args
= msg
->rpc_argp
;
3596 struct nfs_removeres
*res
= msg
->rpc_resp
;
3598 res
->server
= server
;
3599 msg
->rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_REMOVE
];
3600 nfs4_init_sequence(&args
->seq_args
, &res
->seq_res
, 1);
3602 nfs_fattr_init(res
->dir_attr
);
3605 static void nfs4_proc_unlink_rpc_prepare(struct rpc_task
*task
, struct nfs_unlinkdata
*data
)
3607 nfs4_setup_sequence(NFS_SERVER(data
->dir
),
3608 &data
->args
.seq_args
,
3613 static int nfs4_proc_unlink_done(struct rpc_task
*task
, struct inode
*dir
)
3615 struct nfs_unlinkdata
*data
= task
->tk_calldata
;
3616 struct nfs_removeres
*res
= &data
->res
;
3618 if (!nfs4_sequence_done(task
, &res
->seq_res
))
3620 if (nfs4_async_handle_error(task
, res
->server
, NULL
,
3621 &data
->timeout
) == -EAGAIN
)
3623 update_changeattr(dir
, &res
->cinfo
);
3627 static void nfs4_proc_rename_setup(struct rpc_message
*msg
, struct inode
*dir
)
3629 struct nfs_server
*server
= NFS_SERVER(dir
);
3630 struct nfs_renameargs
*arg
= msg
->rpc_argp
;
3631 struct nfs_renameres
*res
= msg
->rpc_resp
;
3633 msg
->rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_RENAME
];
3634 res
->server
= server
;
3635 nfs4_init_sequence(&arg
->seq_args
, &res
->seq_res
, 1);
3638 static void nfs4_proc_rename_rpc_prepare(struct rpc_task
*task
, struct nfs_renamedata
*data
)
3640 nfs4_setup_sequence(NFS_SERVER(data
->old_dir
),
3641 &data
->args
.seq_args
,
3646 static int nfs4_proc_rename_done(struct rpc_task
*task
, struct inode
*old_dir
,
3647 struct inode
*new_dir
)
3649 struct nfs_renamedata
*data
= task
->tk_calldata
;
3650 struct nfs_renameres
*res
= &data
->res
;
3652 if (!nfs4_sequence_done(task
, &res
->seq_res
))
3654 if (nfs4_async_handle_error(task
, res
->server
, NULL
, &data
->timeout
) == -EAGAIN
)
3657 update_changeattr(old_dir
, &res
->old_cinfo
);
3658 update_changeattr(new_dir
, &res
->new_cinfo
);
3662 static int _nfs4_proc_link(struct inode
*inode
, struct inode
*dir
, struct qstr
*name
)
3664 struct nfs_server
*server
= NFS_SERVER(inode
);
3665 struct nfs4_link_arg arg
= {
3666 .fh
= NFS_FH(inode
),
3667 .dir_fh
= NFS_FH(dir
),
3669 .bitmask
= server
->attr_bitmask
,
3671 struct nfs4_link_res res
= {
3675 struct rpc_message msg
= {
3676 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_LINK
],
3680 int status
= -ENOMEM
;
3682 res
.fattr
= nfs_alloc_fattr();
3683 if (res
.fattr
== NULL
)
3686 res
.label
= nfs4_label_alloc(server
, GFP_KERNEL
);
3687 if (IS_ERR(res
.label
)) {
3688 status
= PTR_ERR(res
.label
);
3691 arg
.bitmask
= nfs4_bitmask(server
, res
.label
);
3693 status
= nfs4_call_sync(server
->client
, server
, &msg
, &arg
.seq_args
, &res
.seq_res
, 1);
3695 update_changeattr(dir
, &res
.cinfo
);
3696 status
= nfs_post_op_update_inode(inode
, res
.fattr
);
3698 nfs_setsecurity(inode
, res
.fattr
, res
.label
);
3702 nfs4_label_free(res
.label
);
3705 nfs_free_fattr(res
.fattr
);
3709 static int nfs4_proc_link(struct inode
*inode
, struct inode
*dir
, struct qstr
*name
)
3711 struct nfs4_exception exception
= { };
3714 err
= nfs4_handle_exception(NFS_SERVER(inode
),
3715 _nfs4_proc_link(inode
, dir
, name
),
3717 } while (exception
.retry
);
3721 struct nfs4_createdata
{
3722 struct rpc_message msg
;
3723 struct nfs4_create_arg arg
;
3724 struct nfs4_create_res res
;
3726 struct nfs_fattr fattr
;
3727 struct nfs4_label
*label
;
3730 static struct nfs4_createdata
*nfs4_alloc_createdata(struct inode
*dir
,
3731 struct qstr
*name
, struct iattr
*sattr
, u32 ftype
)
3733 struct nfs4_createdata
*data
;
3735 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
3737 struct nfs_server
*server
= NFS_SERVER(dir
);
3739 data
->label
= nfs4_label_alloc(server
, GFP_KERNEL
);
3740 if (IS_ERR(data
->label
))
3743 data
->msg
.rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_CREATE
];
3744 data
->msg
.rpc_argp
= &data
->arg
;
3745 data
->msg
.rpc_resp
= &data
->res
;
3746 data
->arg
.dir_fh
= NFS_FH(dir
);
3747 data
->arg
.server
= server
;
3748 data
->arg
.name
= name
;
3749 data
->arg
.attrs
= sattr
;
3750 data
->arg
.ftype
= ftype
;
3751 data
->arg
.bitmask
= nfs4_bitmask(server
, data
->label
);
3752 data
->res
.server
= server
;
3753 data
->res
.fh
= &data
->fh
;
3754 data
->res
.fattr
= &data
->fattr
;
3755 data
->res
.label
= data
->label
;
3756 nfs_fattr_init(data
->res
.fattr
);
3764 static int nfs4_do_create(struct inode
*dir
, struct dentry
*dentry
, struct nfs4_createdata
*data
)
3766 int status
= nfs4_call_sync(NFS_SERVER(dir
)->client
, NFS_SERVER(dir
), &data
->msg
,
3767 &data
->arg
.seq_args
, &data
->res
.seq_res
, 1);
3769 update_changeattr(dir
, &data
->res
.dir_cinfo
);
3770 status
= nfs_instantiate(dentry
, data
->res
.fh
, data
->res
.fattr
, data
->res
.label
);
3775 static void nfs4_free_createdata(struct nfs4_createdata
*data
)
3777 nfs4_label_free(data
->label
);
3781 static int _nfs4_proc_symlink(struct inode
*dir
, struct dentry
*dentry
,
3782 struct page
*page
, unsigned int len
, struct iattr
*sattr
,
3783 struct nfs4_label
*label
)
3785 struct nfs4_createdata
*data
;
3786 int status
= -ENAMETOOLONG
;
3788 if (len
> NFS4_MAXPATHLEN
)
3792 data
= nfs4_alloc_createdata(dir
, &dentry
->d_name
, sattr
, NF4LNK
);
3796 data
->msg
.rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_SYMLINK
];
3797 data
->arg
.u
.symlink
.pages
= &page
;
3798 data
->arg
.u
.symlink
.len
= len
;
3799 data
->arg
.label
= label
;
3801 status
= nfs4_do_create(dir
, dentry
, data
);
3803 nfs4_free_createdata(data
);
3808 static int nfs4_proc_symlink(struct inode
*dir
, struct dentry
*dentry
,
3809 struct page
*page
, unsigned int len
, struct iattr
*sattr
)
3811 struct nfs4_exception exception
= { };
3812 struct nfs4_label l
, *label
= NULL
;
3815 label
= nfs4_label_init_security(dir
, dentry
, sattr
, &l
);
3818 err
= _nfs4_proc_symlink(dir
, dentry
, page
, len
, sattr
, label
);
3819 trace_nfs4_symlink(dir
, &dentry
->d_name
, err
);
3820 err
= nfs4_handle_exception(NFS_SERVER(dir
), err
,
3822 } while (exception
.retry
);
3824 nfs4_label_release_security(label
);
3828 static int _nfs4_proc_mkdir(struct inode
*dir
, struct dentry
*dentry
,
3829 struct iattr
*sattr
, struct nfs4_label
*label
)
3831 struct nfs4_createdata
*data
;
3832 int status
= -ENOMEM
;
3834 data
= nfs4_alloc_createdata(dir
, &dentry
->d_name
, sattr
, NF4DIR
);
3838 data
->arg
.label
= label
;
3839 status
= nfs4_do_create(dir
, dentry
, data
);
3841 nfs4_free_createdata(data
);
3846 static int nfs4_proc_mkdir(struct inode
*dir
, struct dentry
*dentry
,
3847 struct iattr
*sattr
)
3849 struct nfs4_exception exception
= { };
3850 struct nfs4_label l
, *label
= NULL
;
3853 label
= nfs4_label_init_security(dir
, dentry
, sattr
, &l
);
3855 sattr
->ia_mode
&= ~current_umask();
3857 err
= _nfs4_proc_mkdir(dir
, dentry
, sattr
, label
);
3858 trace_nfs4_mkdir(dir
, &dentry
->d_name
, err
);
3859 err
= nfs4_handle_exception(NFS_SERVER(dir
), err
,
3861 } while (exception
.retry
);
3862 nfs4_label_release_security(label
);
3867 static int _nfs4_proc_readdir(struct dentry
*dentry
, struct rpc_cred
*cred
,
3868 u64 cookie
, struct page
**pages
, unsigned int count
, int plus
)
3870 struct inode
*dir
= dentry
->d_inode
;
3871 struct nfs4_readdir_arg args
= {
3876 .bitmask
= NFS_SERVER(dentry
->d_inode
)->attr_bitmask
,
3879 struct nfs4_readdir_res res
;
3880 struct rpc_message msg
= {
3881 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_READDIR
],
3888 dprintk("%s: dentry = %pd2, cookie = %Lu\n", __func__
,
3890 (unsigned long long)cookie
);
3891 nfs4_setup_readdir(cookie
, NFS_I(dir
)->cookieverf
, dentry
, &args
);
3892 res
.pgbase
= args
.pgbase
;
3893 status
= nfs4_call_sync(NFS_SERVER(dir
)->client
, NFS_SERVER(dir
), &msg
, &args
.seq_args
, &res
.seq_res
, 0);
3895 memcpy(NFS_I(dir
)->cookieverf
, res
.verifier
.data
, NFS4_VERIFIER_SIZE
);
3896 status
+= args
.pgbase
;
3899 nfs_invalidate_atime(dir
);
3901 dprintk("%s: returns %d\n", __func__
, status
);
3905 static int nfs4_proc_readdir(struct dentry
*dentry
, struct rpc_cred
*cred
,
3906 u64 cookie
, struct page
**pages
, unsigned int count
, int plus
)
3908 struct nfs4_exception exception
= { };
3911 err
= _nfs4_proc_readdir(dentry
, cred
, cookie
,
3912 pages
, count
, plus
);
3913 trace_nfs4_readdir(dentry
->d_inode
, err
);
3914 err
= nfs4_handle_exception(NFS_SERVER(dentry
->d_inode
), err
,
3916 } while (exception
.retry
);
3920 static int _nfs4_proc_mknod(struct inode
*dir
, struct dentry
*dentry
,
3921 struct iattr
*sattr
, struct nfs4_label
*label
, dev_t rdev
)
3923 struct nfs4_createdata
*data
;
3924 int mode
= sattr
->ia_mode
;
3925 int status
= -ENOMEM
;
3927 data
= nfs4_alloc_createdata(dir
, &dentry
->d_name
, sattr
, NF4SOCK
);
3932 data
->arg
.ftype
= NF4FIFO
;
3933 else if (S_ISBLK(mode
)) {
3934 data
->arg
.ftype
= NF4BLK
;
3935 data
->arg
.u
.device
.specdata1
= MAJOR(rdev
);
3936 data
->arg
.u
.device
.specdata2
= MINOR(rdev
);
3938 else if (S_ISCHR(mode
)) {
3939 data
->arg
.ftype
= NF4CHR
;
3940 data
->arg
.u
.device
.specdata1
= MAJOR(rdev
);
3941 data
->arg
.u
.device
.specdata2
= MINOR(rdev
);
3942 } else if (!S_ISSOCK(mode
)) {
3947 data
->arg
.label
= label
;
3948 status
= nfs4_do_create(dir
, dentry
, data
);
3950 nfs4_free_createdata(data
);
3955 static int nfs4_proc_mknod(struct inode
*dir
, struct dentry
*dentry
,
3956 struct iattr
*sattr
, dev_t rdev
)
3958 struct nfs4_exception exception
= { };
3959 struct nfs4_label l
, *label
= NULL
;
3962 label
= nfs4_label_init_security(dir
, dentry
, sattr
, &l
);
3964 sattr
->ia_mode
&= ~current_umask();
3966 err
= _nfs4_proc_mknod(dir
, dentry
, sattr
, label
, rdev
);
3967 trace_nfs4_mknod(dir
, &dentry
->d_name
, err
);
3968 err
= nfs4_handle_exception(NFS_SERVER(dir
), err
,
3970 } while (exception
.retry
);
3972 nfs4_label_release_security(label
);
3977 static int _nfs4_proc_statfs(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
3978 struct nfs_fsstat
*fsstat
)
3980 struct nfs4_statfs_arg args
= {
3982 .bitmask
= server
->attr_bitmask
,
3984 struct nfs4_statfs_res res
= {
3987 struct rpc_message msg
= {
3988 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_STATFS
],
3993 nfs_fattr_init(fsstat
->fattr
);
3994 return nfs4_call_sync(server
->client
, server
, &msg
, &args
.seq_args
, &res
.seq_res
, 0);
3997 static int nfs4_proc_statfs(struct nfs_server
*server
, struct nfs_fh
*fhandle
, struct nfs_fsstat
*fsstat
)
3999 struct nfs4_exception exception
= { };
4002 err
= nfs4_handle_exception(server
,
4003 _nfs4_proc_statfs(server
, fhandle
, fsstat
),
4005 } while (exception
.retry
);
4009 static int _nfs4_do_fsinfo(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
4010 struct nfs_fsinfo
*fsinfo
)
4012 struct nfs4_fsinfo_arg args
= {
4014 .bitmask
= server
->attr_bitmask
,
4016 struct nfs4_fsinfo_res res
= {
4019 struct rpc_message msg
= {
4020 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_FSINFO
],
4025 return nfs4_call_sync(server
->client
, server
, &msg
, &args
.seq_args
, &res
.seq_res
, 0);
4028 static int nfs4_do_fsinfo(struct nfs_server
*server
, struct nfs_fh
*fhandle
, struct nfs_fsinfo
*fsinfo
)
4030 struct nfs4_exception exception
= { };
4031 unsigned long now
= jiffies
;
4035 err
= _nfs4_do_fsinfo(server
, fhandle
, fsinfo
);
4036 trace_nfs4_fsinfo(server
, fhandle
, fsinfo
->fattr
, err
);
4038 struct nfs_client
*clp
= server
->nfs_client
;
4040 spin_lock(&clp
->cl_lock
);
4041 clp
->cl_lease_time
= fsinfo
->lease_time
* HZ
;
4042 clp
->cl_last_renewal
= now
;
4043 spin_unlock(&clp
->cl_lock
);
4046 err
= nfs4_handle_exception(server
, err
, &exception
);
4047 } while (exception
.retry
);
4051 static int nfs4_proc_fsinfo(struct nfs_server
*server
, struct nfs_fh
*fhandle
, struct nfs_fsinfo
*fsinfo
)
4055 nfs_fattr_init(fsinfo
->fattr
);
4056 error
= nfs4_do_fsinfo(server
, fhandle
, fsinfo
);
4058 /* block layout checks this! */
4059 server
->pnfs_blksize
= fsinfo
->blksize
;
4060 set_pnfs_layoutdriver(server
, fhandle
, fsinfo
->layouttype
);
4066 static int _nfs4_proc_pathconf(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
4067 struct nfs_pathconf
*pathconf
)
4069 struct nfs4_pathconf_arg args
= {
4071 .bitmask
= server
->attr_bitmask
,
4073 struct nfs4_pathconf_res res
= {
4074 .pathconf
= pathconf
,
4076 struct rpc_message msg
= {
4077 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_PATHCONF
],
4082 /* None of the pathconf attributes are mandatory to implement */
4083 if ((args
.bitmask
[0] & nfs4_pathconf_bitmap
[0]) == 0) {
4084 memset(pathconf
, 0, sizeof(*pathconf
));
4088 nfs_fattr_init(pathconf
->fattr
);
4089 return nfs4_call_sync(server
->client
, server
, &msg
, &args
.seq_args
, &res
.seq_res
, 0);
4092 static int nfs4_proc_pathconf(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
4093 struct nfs_pathconf
*pathconf
)
4095 struct nfs4_exception exception
= { };
4099 err
= nfs4_handle_exception(server
,
4100 _nfs4_proc_pathconf(server
, fhandle
, pathconf
),
4102 } while (exception
.retry
);
4106 int nfs4_set_rw_stateid(nfs4_stateid
*stateid
,
4107 const struct nfs_open_context
*ctx
,
4108 const struct nfs_lock_context
*l_ctx
,
4111 const struct nfs_lockowner
*lockowner
= NULL
;
4114 lockowner
= &l_ctx
->lockowner
;
4115 return nfs4_select_rw_stateid(stateid
, ctx
->state
, fmode
, lockowner
);
4117 EXPORT_SYMBOL_GPL(nfs4_set_rw_stateid
);
4119 static bool nfs4_stateid_is_current(nfs4_stateid
*stateid
,
4120 const struct nfs_open_context
*ctx
,
4121 const struct nfs_lock_context
*l_ctx
,
4124 nfs4_stateid current_stateid
;
4126 /* If the current stateid represents a lost lock, then exit */
4127 if (nfs4_set_rw_stateid(¤t_stateid
, ctx
, l_ctx
, fmode
) == -EIO
)
4129 return nfs4_stateid_match(stateid
, ¤t_stateid
);
4132 static bool nfs4_error_stateid_expired(int err
)
4135 case -NFS4ERR_DELEG_REVOKED
:
4136 case -NFS4ERR_ADMIN_REVOKED
:
4137 case -NFS4ERR_BAD_STATEID
:
4138 case -NFS4ERR_STALE_STATEID
:
4139 case -NFS4ERR_OLD_STATEID
:
4140 case -NFS4ERR_OPENMODE
:
4141 case -NFS4ERR_EXPIRED
:
4147 void __nfs4_read_done_cb(struct nfs_pgio_header
*hdr
)
4149 nfs_invalidate_atime(hdr
->inode
);
4152 static int nfs4_read_done_cb(struct rpc_task
*task
, struct nfs_pgio_header
*hdr
)
4154 struct nfs_server
*server
= NFS_SERVER(hdr
->inode
);
4156 trace_nfs4_read(hdr
, task
->tk_status
);
4157 if (nfs4_async_handle_error(task
, server
,
4158 hdr
->args
.context
->state
,
4160 rpc_restart_call_prepare(task
);
4164 __nfs4_read_done_cb(hdr
);
4165 if (task
->tk_status
> 0)
4166 renew_lease(server
, hdr
->timestamp
);
4170 static bool nfs4_read_stateid_changed(struct rpc_task
*task
,
4171 struct nfs_pgio_args
*args
)
4174 if (!nfs4_error_stateid_expired(task
->tk_status
) ||
4175 nfs4_stateid_is_current(&args
->stateid
,
4180 rpc_restart_call_prepare(task
);
4184 static int nfs4_read_done(struct rpc_task
*task
, struct nfs_pgio_header
*hdr
)
4187 dprintk("--> %s\n", __func__
);
4189 if (!nfs4_sequence_done(task
, &hdr
->res
.seq_res
))
4191 if (nfs4_read_stateid_changed(task
, &hdr
->args
))
4193 return hdr
->pgio_done_cb
? hdr
->pgio_done_cb(task
, hdr
) :
4194 nfs4_read_done_cb(task
, hdr
);
4197 static void nfs4_proc_read_setup(struct nfs_pgio_header
*hdr
,
4198 struct rpc_message
*msg
)
4200 hdr
->timestamp
= jiffies
;
4201 hdr
->pgio_done_cb
= nfs4_read_done_cb
;
4202 msg
->rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_READ
];
4203 nfs4_init_sequence(&hdr
->args
.seq_args
, &hdr
->res
.seq_res
, 0);
4206 static int nfs4_proc_pgio_rpc_prepare(struct rpc_task
*task
,
4207 struct nfs_pgio_header
*hdr
)
4209 if (nfs4_setup_sequence(NFS_SERVER(hdr
->inode
),
4210 &hdr
->args
.seq_args
,
4214 if (nfs4_set_rw_stateid(&hdr
->args
.stateid
, hdr
->args
.context
,
4215 hdr
->args
.lock_context
,
4216 hdr
->rw_ops
->rw_mode
) == -EIO
)
4218 if (unlikely(test_bit(NFS_CONTEXT_BAD
, &hdr
->args
.context
->flags
)))
4223 static int nfs4_write_done_cb(struct rpc_task
*task
,
4224 struct nfs_pgio_header
*hdr
)
4226 struct inode
*inode
= hdr
->inode
;
4228 trace_nfs4_write(hdr
, task
->tk_status
);
4229 if (nfs4_async_handle_error(task
, NFS_SERVER(inode
),
4230 hdr
->args
.context
->state
,
4232 rpc_restart_call_prepare(task
);
4235 if (task
->tk_status
>= 0) {
4236 renew_lease(NFS_SERVER(inode
), hdr
->timestamp
);
4237 nfs_post_op_update_inode_force_wcc(inode
, &hdr
->fattr
);
4242 static bool nfs4_write_stateid_changed(struct rpc_task
*task
,
4243 struct nfs_pgio_args
*args
)
4246 if (!nfs4_error_stateid_expired(task
->tk_status
) ||
4247 nfs4_stateid_is_current(&args
->stateid
,
4252 rpc_restart_call_prepare(task
);
4256 static int nfs4_write_done(struct rpc_task
*task
, struct nfs_pgio_header
*hdr
)
4258 if (!nfs4_sequence_done(task
, &hdr
->res
.seq_res
))
4260 if (nfs4_write_stateid_changed(task
, &hdr
->args
))
4262 return hdr
->pgio_done_cb
? hdr
->pgio_done_cb(task
, hdr
) :
4263 nfs4_write_done_cb(task
, hdr
);
4267 bool nfs4_write_need_cache_consistency_data(struct nfs_pgio_header
*hdr
)
4269 /* Don't request attributes for pNFS or O_DIRECT writes */
4270 if (hdr
->ds_clp
!= NULL
|| hdr
->dreq
!= NULL
)
4272 /* Otherwise, request attributes if and only if we don't hold
4275 return nfs4_have_delegation(hdr
->inode
, FMODE_READ
) == 0;
4278 static void nfs4_proc_write_setup(struct nfs_pgio_header
*hdr
,
4279 struct rpc_message
*msg
)
4281 struct nfs_server
*server
= NFS_SERVER(hdr
->inode
);
4283 if (!nfs4_write_need_cache_consistency_data(hdr
)) {
4284 hdr
->args
.bitmask
= NULL
;
4285 hdr
->res
.fattr
= NULL
;
4287 hdr
->args
.bitmask
= server
->cache_consistency_bitmask
;
4289 if (!hdr
->pgio_done_cb
)
4290 hdr
->pgio_done_cb
= nfs4_write_done_cb
;
4291 hdr
->res
.server
= server
;
4292 hdr
->timestamp
= jiffies
;
4294 msg
->rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_WRITE
];
4295 nfs4_init_sequence(&hdr
->args
.seq_args
, &hdr
->res
.seq_res
, 1);
4298 static void nfs4_proc_commit_rpc_prepare(struct rpc_task
*task
, struct nfs_commit_data
*data
)
4300 nfs4_setup_sequence(NFS_SERVER(data
->inode
),
4301 &data
->args
.seq_args
,
4306 static int nfs4_commit_done_cb(struct rpc_task
*task
, struct nfs_commit_data
*data
)
4308 struct inode
*inode
= data
->inode
;
4310 trace_nfs4_commit(data
, task
->tk_status
);
4311 if (nfs4_async_handle_error(task
, NFS_SERVER(inode
),
4312 NULL
, NULL
) == -EAGAIN
) {
4313 rpc_restart_call_prepare(task
);
4319 static int nfs4_commit_done(struct rpc_task
*task
, struct nfs_commit_data
*data
)
4321 if (!nfs4_sequence_done(task
, &data
->res
.seq_res
))
4323 return data
->commit_done_cb(task
, data
);
4326 static void nfs4_proc_commit_setup(struct nfs_commit_data
*data
, struct rpc_message
*msg
)
4328 struct nfs_server
*server
= NFS_SERVER(data
->inode
);
4330 if (data
->commit_done_cb
== NULL
)
4331 data
->commit_done_cb
= nfs4_commit_done_cb
;
4332 data
->res
.server
= server
;
4333 msg
->rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_COMMIT
];
4334 nfs4_init_sequence(&data
->args
.seq_args
, &data
->res
.seq_res
, 1);
4337 struct nfs4_renewdata
{
4338 struct nfs_client
*client
;
4339 unsigned long timestamp
;
4343 * nfs4_proc_async_renew(): This is not one of the nfs_rpc_ops; it is a special
4344 * standalone procedure for queueing an asynchronous RENEW.
4346 static void nfs4_renew_release(void *calldata
)
4348 struct nfs4_renewdata
*data
= calldata
;
4349 struct nfs_client
*clp
= data
->client
;
4351 if (atomic_read(&clp
->cl_count
) > 1)
4352 nfs4_schedule_state_renewal(clp
);
4353 nfs_put_client(clp
);
4357 static void nfs4_renew_done(struct rpc_task
*task
, void *calldata
)
4359 struct nfs4_renewdata
*data
= calldata
;
4360 struct nfs_client
*clp
= data
->client
;
4361 unsigned long timestamp
= data
->timestamp
;
4363 trace_nfs4_renew_async(clp
, task
->tk_status
);
4364 switch (task
->tk_status
) {
4367 case -NFS4ERR_LEASE_MOVED
:
4368 nfs4_schedule_lease_moved_recovery(clp
);
4371 /* Unless we're shutting down, schedule state recovery! */
4372 if (test_bit(NFS_CS_RENEWD
, &clp
->cl_res_state
) == 0)
4374 if (task
->tk_status
!= NFS4ERR_CB_PATH_DOWN
) {
4375 nfs4_schedule_lease_recovery(clp
);
4378 nfs4_schedule_path_down_recovery(clp
);
4380 do_renew_lease(clp
, timestamp
);
4383 static const struct rpc_call_ops nfs4_renew_ops
= {
4384 .rpc_call_done
= nfs4_renew_done
,
4385 .rpc_release
= nfs4_renew_release
,
4388 static int nfs4_proc_async_renew(struct nfs_client
*clp
, struct rpc_cred
*cred
, unsigned renew_flags
)
4390 struct rpc_message msg
= {
4391 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_RENEW
],
4395 struct nfs4_renewdata
*data
;
4397 if (renew_flags
== 0)
4399 if (!atomic_inc_not_zero(&clp
->cl_count
))
4401 data
= kmalloc(sizeof(*data
), GFP_NOFS
);
4405 data
->timestamp
= jiffies
;
4406 return rpc_call_async(clp
->cl_rpcclient
, &msg
, RPC_TASK_TIMEOUT
,
4407 &nfs4_renew_ops
, data
);
4410 static int nfs4_proc_renew(struct nfs_client
*clp
, struct rpc_cred
*cred
)
4412 struct rpc_message msg
= {
4413 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_RENEW
],
4417 unsigned long now
= jiffies
;
4420 status
= rpc_call_sync(clp
->cl_rpcclient
, &msg
, RPC_TASK_TIMEOUT
);
4423 do_renew_lease(clp
, now
);
4427 static inline int nfs4_server_supports_acls(struct nfs_server
*server
)
4429 return server
->caps
& NFS_CAP_ACLS
;
4432 /* Assuming that XATTR_SIZE_MAX is a multiple of PAGE_SIZE, and that
4433 * it's OK to put sizeof(void) * (XATTR_SIZE_MAX/PAGE_SIZE) bytes on
4436 #define NFS4ACL_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE)
4438 static int buf_to_pages_noslab(const void *buf
, size_t buflen
,
4439 struct page
**pages
, unsigned int *pgbase
)
4441 struct page
*newpage
, **spages
;
4447 len
= min_t(size_t, PAGE_SIZE
, buflen
);
4448 newpage
= alloc_page(GFP_KERNEL
);
4450 if (newpage
== NULL
)
4452 memcpy(page_address(newpage
), buf
, len
);
4457 } while (buflen
!= 0);
4463 __free_page(spages
[rc
-1]);
4467 struct nfs4_cached_acl
{
4473 static void nfs4_set_cached_acl(struct inode
*inode
, struct nfs4_cached_acl
*acl
)
4475 struct nfs_inode
*nfsi
= NFS_I(inode
);
4477 spin_lock(&inode
->i_lock
);
4478 kfree(nfsi
->nfs4_acl
);
4479 nfsi
->nfs4_acl
= acl
;
4480 spin_unlock(&inode
->i_lock
);
4483 static void nfs4_zap_acl_attr(struct inode
*inode
)
4485 nfs4_set_cached_acl(inode
, NULL
);
4488 static inline ssize_t
nfs4_read_cached_acl(struct inode
*inode
, char *buf
, size_t buflen
)
4490 struct nfs_inode
*nfsi
= NFS_I(inode
);
4491 struct nfs4_cached_acl
*acl
;
4494 spin_lock(&inode
->i_lock
);
4495 acl
= nfsi
->nfs4_acl
;
4498 if (buf
== NULL
) /* user is just asking for length */
4500 if (acl
->cached
== 0)
4502 ret
= -ERANGE
; /* see getxattr(2) man page */
4503 if (acl
->len
> buflen
)
4505 memcpy(buf
, acl
->data
, acl
->len
);
4509 spin_unlock(&inode
->i_lock
);
4513 static void nfs4_write_cached_acl(struct inode
*inode
, struct page
**pages
, size_t pgbase
, size_t acl_len
)
4515 struct nfs4_cached_acl
*acl
;
4516 size_t buflen
= sizeof(*acl
) + acl_len
;
4518 if (buflen
<= PAGE_SIZE
) {
4519 acl
= kmalloc(buflen
, GFP_KERNEL
);
4523 _copy_from_pages(acl
->data
, pages
, pgbase
, acl_len
);
4525 acl
= kmalloc(sizeof(*acl
), GFP_KERNEL
);
4532 nfs4_set_cached_acl(inode
, acl
);
4536 * The getxattr API returns the required buffer length when called with a
4537 * NULL buf. The NFSv4 acl tool then calls getxattr again after allocating
4538 * the required buf. On a NULL buf, we send a page of data to the server
4539 * guessing that the ACL request can be serviced by a page. If so, we cache
4540 * up to the page of ACL data, and the 2nd call to getxattr is serviced by
4541 * the cache. If not so, we throw away the page, and cache the required
4542 * length. The next getxattr call will then produce another round trip to
4543 * the server, this time with the input buf of the required size.
4545 static ssize_t
__nfs4_get_acl_uncached(struct inode
*inode
, void *buf
, size_t buflen
)
4547 struct page
*pages
[NFS4ACL_MAXPAGES
] = {NULL
, };
4548 struct nfs_getaclargs args
= {
4549 .fh
= NFS_FH(inode
),
4553 struct nfs_getaclres res
= {
4556 struct rpc_message msg
= {
4557 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_GETACL
],
4561 unsigned int npages
= DIV_ROUND_UP(buflen
, PAGE_SIZE
);
4562 int ret
= -ENOMEM
, i
;
4564 /* As long as we're doing a round trip to the server anyway,
4565 * let's be prepared for a page of acl data. */
4568 if (npages
> ARRAY_SIZE(pages
))
4571 for (i
= 0; i
< npages
; i
++) {
4572 pages
[i
] = alloc_page(GFP_KERNEL
);
4577 /* for decoding across pages */
4578 res
.acl_scratch
= alloc_page(GFP_KERNEL
);
4579 if (!res
.acl_scratch
)
4582 args
.acl_len
= npages
* PAGE_SIZE
;
4583 args
.acl_pgbase
= 0;
4585 dprintk("%s buf %p buflen %zu npages %d args.acl_len %zu\n",
4586 __func__
, buf
, buflen
, npages
, args
.acl_len
);
4587 ret
= nfs4_call_sync(NFS_SERVER(inode
)->client
, NFS_SERVER(inode
),
4588 &msg
, &args
.seq_args
, &res
.seq_res
, 0);
4592 /* Handle the case where the passed-in buffer is too short */
4593 if (res
.acl_flags
& NFS4_ACL_TRUNC
) {
4594 /* Did the user only issue a request for the acl length? */
4600 nfs4_write_cached_acl(inode
, pages
, res
.acl_data_offset
, res
.acl_len
);
4602 if (res
.acl_len
> buflen
) {
4606 _copy_from_pages(buf
, pages
, res
.acl_data_offset
, res
.acl_len
);
4611 for (i
= 0; i
< npages
; i
++)
4613 __free_page(pages
[i
]);
4614 if (res
.acl_scratch
)
4615 __free_page(res
.acl_scratch
);
4619 static ssize_t
nfs4_get_acl_uncached(struct inode
*inode
, void *buf
, size_t buflen
)
4621 struct nfs4_exception exception
= { };
4624 ret
= __nfs4_get_acl_uncached(inode
, buf
, buflen
);
4625 trace_nfs4_get_acl(inode
, ret
);
4628 ret
= nfs4_handle_exception(NFS_SERVER(inode
), ret
, &exception
);
4629 } while (exception
.retry
);
4633 static ssize_t
nfs4_proc_get_acl(struct inode
*inode
, void *buf
, size_t buflen
)
4635 struct nfs_server
*server
= NFS_SERVER(inode
);
4638 if (!nfs4_server_supports_acls(server
))
4640 ret
= nfs_revalidate_inode(server
, inode
);
4643 if (NFS_I(inode
)->cache_validity
& NFS_INO_INVALID_ACL
)
4644 nfs_zap_acl_cache(inode
);
4645 ret
= nfs4_read_cached_acl(inode
, buf
, buflen
);
4647 /* -ENOENT is returned if there is no ACL or if there is an ACL
4648 * but no cached acl data, just the acl length */
4650 return nfs4_get_acl_uncached(inode
, buf
, buflen
);
4653 static int __nfs4_proc_set_acl(struct inode
*inode
, const void *buf
, size_t buflen
)
4655 struct nfs_server
*server
= NFS_SERVER(inode
);
4656 struct page
*pages
[NFS4ACL_MAXPAGES
];
4657 struct nfs_setaclargs arg
= {
4658 .fh
= NFS_FH(inode
),
4662 struct nfs_setaclres res
;
4663 struct rpc_message msg
= {
4664 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_SETACL
],
4668 unsigned int npages
= DIV_ROUND_UP(buflen
, PAGE_SIZE
);
4671 if (!nfs4_server_supports_acls(server
))
4673 if (npages
> ARRAY_SIZE(pages
))
4675 i
= buf_to_pages_noslab(buf
, buflen
, arg
.acl_pages
, &arg
.acl_pgbase
);
4678 nfs4_inode_return_delegation(inode
);
4679 ret
= nfs4_call_sync(server
->client
, server
, &msg
, &arg
.seq_args
, &res
.seq_res
, 1);
4682 * Free each page after tx, so the only ref left is
4683 * held by the network stack
4686 put_page(pages
[i
-1]);
4689 * Acl update can result in inode attribute update.
4690 * so mark the attribute cache invalid.
4692 spin_lock(&inode
->i_lock
);
4693 NFS_I(inode
)->cache_validity
|= NFS_INO_INVALID_ATTR
;
4694 spin_unlock(&inode
->i_lock
);
4695 nfs_access_zap_cache(inode
);
4696 nfs_zap_acl_cache(inode
);
4700 static int nfs4_proc_set_acl(struct inode
*inode
, const void *buf
, size_t buflen
)
4702 struct nfs4_exception exception
= { };
4705 err
= __nfs4_proc_set_acl(inode
, buf
, buflen
);
4706 trace_nfs4_set_acl(inode
, err
);
4707 err
= nfs4_handle_exception(NFS_SERVER(inode
), err
,
4709 } while (exception
.retry
);
4713 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
4714 static int _nfs4_get_security_label(struct inode
*inode
, void *buf
,
4717 struct nfs_server
*server
= NFS_SERVER(inode
);
4718 struct nfs_fattr fattr
;
4719 struct nfs4_label label
= {0, 0, buflen
, buf
};
4721 u32 bitmask
[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL
};
4722 struct nfs4_getattr_arg arg
= {
4723 .fh
= NFS_FH(inode
),
4726 struct nfs4_getattr_res res
= {
4731 struct rpc_message msg
= {
4732 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_GETATTR
],
4738 nfs_fattr_init(&fattr
);
4740 ret
= nfs4_call_sync(server
->client
, server
, &msg
, &arg
.seq_args
, &res
.seq_res
, 0);
4743 if (!(fattr
.valid
& NFS_ATTR_FATTR_V4_SECURITY_LABEL
))
4745 if (buflen
< label
.len
)
4750 static int nfs4_get_security_label(struct inode
*inode
, void *buf
,
4753 struct nfs4_exception exception
= { };
4756 if (!nfs_server_capable(inode
, NFS_CAP_SECURITY_LABEL
))
4760 err
= _nfs4_get_security_label(inode
, buf
, buflen
);
4761 trace_nfs4_get_security_label(inode
, err
);
4762 err
= nfs4_handle_exception(NFS_SERVER(inode
), err
,
4764 } while (exception
.retry
);
4768 static int _nfs4_do_set_security_label(struct inode
*inode
,
4769 struct nfs4_label
*ilabel
,
4770 struct nfs_fattr
*fattr
,
4771 struct nfs4_label
*olabel
)
4774 struct iattr sattr
= {0};
4775 struct nfs_server
*server
= NFS_SERVER(inode
);
4776 const u32 bitmask
[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL
};
4777 struct nfs_setattrargs arg
= {
4778 .fh
= NFS_FH(inode
),
4784 struct nfs_setattrres res
= {
4789 struct rpc_message msg
= {
4790 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_SETATTR
],
4796 nfs4_stateid_copy(&arg
.stateid
, &zero_stateid
);
4798 status
= nfs4_call_sync(server
->client
, server
, &msg
, &arg
.seq_args
, &res
.seq_res
, 1);
4800 dprintk("%s failed: %d\n", __func__
, status
);
4805 static int nfs4_do_set_security_label(struct inode
*inode
,
4806 struct nfs4_label
*ilabel
,
4807 struct nfs_fattr
*fattr
,
4808 struct nfs4_label
*olabel
)
4810 struct nfs4_exception exception
= { };
4814 err
= _nfs4_do_set_security_label(inode
, ilabel
,
4816 trace_nfs4_set_security_label(inode
, err
);
4817 err
= nfs4_handle_exception(NFS_SERVER(inode
), err
,
4819 } while (exception
.retry
);
4824 nfs4_set_security_label(struct dentry
*dentry
, const void *buf
, size_t buflen
)
4826 struct nfs4_label ilabel
, *olabel
= NULL
;
4827 struct nfs_fattr fattr
;
4828 struct rpc_cred
*cred
;
4829 struct inode
*inode
= dentry
->d_inode
;
4832 if (!nfs_server_capable(inode
, NFS_CAP_SECURITY_LABEL
))
4835 nfs_fattr_init(&fattr
);
4839 ilabel
.label
= (char *)buf
;
4840 ilabel
.len
= buflen
;
4842 cred
= rpc_lookup_cred();
4844 return PTR_ERR(cred
);
4846 olabel
= nfs4_label_alloc(NFS_SERVER(inode
), GFP_KERNEL
);
4847 if (IS_ERR(olabel
)) {
4848 status
= -PTR_ERR(olabel
);
4852 status
= nfs4_do_set_security_label(inode
, &ilabel
, &fattr
, olabel
);
4854 nfs_setsecurity(inode
, &fattr
, olabel
);
4856 nfs4_label_free(olabel
);
4861 #endif /* CONFIG_NFS_V4_SECURITY_LABEL */
4865 nfs4_async_handle_error(struct rpc_task
*task
, const struct nfs_server
*server
,
4866 struct nfs4_state
*state
, long *timeout
)
4868 struct nfs_client
*clp
= server
->nfs_client
;
4870 if (task
->tk_status
>= 0)
4872 switch(task
->tk_status
) {
4873 case -NFS4ERR_DELEG_REVOKED
:
4874 case -NFS4ERR_ADMIN_REVOKED
:
4875 case -NFS4ERR_BAD_STATEID
:
4876 case -NFS4ERR_OPENMODE
:
4879 if (nfs4_schedule_stateid_recovery(server
, state
) < 0)
4880 goto recovery_failed
;
4881 goto wait_on_recovery
;
4882 case -NFS4ERR_EXPIRED
:
4883 if (state
!= NULL
) {
4884 if (nfs4_schedule_stateid_recovery(server
, state
) < 0)
4885 goto recovery_failed
;
4887 case -NFS4ERR_STALE_STATEID
:
4888 case -NFS4ERR_STALE_CLIENTID
:
4889 nfs4_schedule_lease_recovery(clp
);
4890 goto wait_on_recovery
;
4891 case -NFS4ERR_MOVED
:
4892 if (nfs4_schedule_migration_recovery(server
) < 0)
4893 goto recovery_failed
;
4894 goto wait_on_recovery
;
4895 case -NFS4ERR_LEASE_MOVED
:
4896 nfs4_schedule_lease_moved_recovery(clp
);
4897 goto wait_on_recovery
;
4898 #if defined(CONFIG_NFS_V4_1)
4899 case -NFS4ERR_BADSESSION
:
4900 case -NFS4ERR_BADSLOT
:
4901 case -NFS4ERR_BAD_HIGH_SLOT
:
4902 case -NFS4ERR_DEADSESSION
:
4903 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION
:
4904 case -NFS4ERR_SEQ_FALSE_RETRY
:
4905 case -NFS4ERR_SEQ_MISORDERED
:
4906 dprintk("%s ERROR %d, Reset session\n", __func__
,
4908 nfs4_schedule_session_recovery(clp
->cl_session
, task
->tk_status
);
4909 goto wait_on_recovery
;
4910 #endif /* CONFIG_NFS_V4_1 */
4911 case -NFS4ERR_DELAY
:
4912 nfs_inc_server_stats(server
, NFSIOS_DELAY
);
4913 rpc_delay(task
, nfs4_update_delay(timeout
));
4915 case -NFS4ERR_GRACE
:
4916 rpc_delay(task
, NFS4_POLL_RETRY_MAX
);
4917 case -NFS4ERR_RETRY_UNCACHED_REP
:
4918 case -NFS4ERR_OLD_STATEID
:
4921 task
->tk_status
= nfs4_map_errors(task
->tk_status
);
4924 task
->tk_status
= -EIO
;
4927 rpc_sleep_on(&clp
->cl_rpcwaitq
, task
, NULL
);
4928 if (test_bit(NFS4CLNT_MANAGER_RUNNING
, &clp
->cl_state
) == 0)
4929 rpc_wake_up_queued_task(&clp
->cl_rpcwaitq
, task
);
4930 if (test_bit(NFS_MIG_FAILED
, &server
->mig_status
))
4931 goto recovery_failed
;
4933 task
->tk_status
= 0;
4937 static void nfs4_init_boot_verifier(const struct nfs_client
*clp
,
4938 nfs4_verifier
*bootverf
)
4942 if (test_bit(NFS4CLNT_PURGE_STATE
, &clp
->cl_state
)) {
4943 /* An impossible timestamp guarantees this value
4944 * will never match a generated boot time. */
4946 verf
[1] = cpu_to_be32(NSEC_PER_SEC
+ 1);
4948 struct nfs_net
*nn
= net_generic(clp
->cl_net
, nfs_net_id
);
4949 verf
[0] = cpu_to_be32(nn
->boot_time
.tv_sec
);
4950 verf
[1] = cpu_to_be32(nn
->boot_time
.tv_nsec
);
4952 memcpy(bootverf
->data
, verf
, sizeof(bootverf
->data
));
4956 nfs4_init_nonuniform_client_string(struct nfs_client
*clp
,
4957 char *buf
, size_t len
)
4959 unsigned int result
;
4961 if (clp
->cl_owner_id
!= NULL
)
4962 return strlcpy(buf
, clp
->cl_owner_id
, len
);
4965 result
= scnprintf(buf
, len
, "Linux NFSv4.0 %s/%s %s",
4967 rpc_peeraddr2str(clp
->cl_rpcclient
,
4969 rpc_peeraddr2str(clp
->cl_rpcclient
,
4970 RPC_DISPLAY_PROTO
));
4972 clp
->cl_owner_id
= kstrdup(buf
, GFP_KERNEL
);
4977 nfs4_init_uniform_client_string(struct nfs_client
*clp
,
4978 char *buf
, size_t len
)
4980 const char *nodename
= clp
->cl_rpcclient
->cl_nodename
;
4981 unsigned int result
;
4983 if (clp
->cl_owner_id
!= NULL
)
4984 return strlcpy(buf
, clp
->cl_owner_id
, len
);
4986 if (nfs4_client_id_uniquifier
[0] != '\0')
4987 result
= scnprintf(buf
, len
, "Linux NFSv%u.%u %s/%s",
4988 clp
->rpc_ops
->version
,
4989 clp
->cl_minorversion
,
4990 nfs4_client_id_uniquifier
,
4993 result
= scnprintf(buf
, len
, "Linux NFSv%u.%u %s",
4994 clp
->rpc_ops
->version
, clp
->cl_minorversion
,
4996 clp
->cl_owner_id
= kstrdup(buf
, GFP_KERNEL
);
5001 * nfs4_callback_up_net() starts only "tcp" and "tcp6" callback
5002 * services. Advertise one based on the address family of the
5006 nfs4_init_callback_netid(const struct nfs_client
*clp
, char *buf
, size_t len
)
5008 if (strchr(clp
->cl_ipaddr
, ':') != NULL
)
5009 return scnprintf(buf
, len
, "tcp6");
5011 return scnprintf(buf
, len
, "tcp");
5014 static void nfs4_setclientid_done(struct rpc_task
*task
, void *calldata
)
5016 struct nfs4_setclientid
*sc
= calldata
;
5018 if (task
->tk_status
== 0)
5019 sc
->sc_cred
= get_rpccred(task
->tk_rqstp
->rq_cred
);
5022 static const struct rpc_call_ops nfs4_setclientid_ops
= {
5023 .rpc_call_done
= nfs4_setclientid_done
,
5027 * nfs4_proc_setclientid - Negotiate client ID
5028 * @clp: state data structure
5029 * @program: RPC program for NFSv4 callback service
5030 * @port: IP port number for NFS4 callback service
5031 * @cred: RPC credential to use for this call
5032 * @res: where to place the result
5034 * Returns zero, a negative errno, or a negative NFS4ERR status code.
5036 int nfs4_proc_setclientid(struct nfs_client
*clp
, u32 program
,
5037 unsigned short port
, struct rpc_cred
*cred
,
5038 struct nfs4_setclientid_res
*res
)
5040 nfs4_verifier sc_verifier
;
5041 struct nfs4_setclientid setclientid
= {
5042 .sc_verifier
= &sc_verifier
,
5044 .sc_cb_ident
= clp
->cl_cb_ident
,
5046 struct rpc_message msg
= {
5047 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_SETCLIENTID
],
5048 .rpc_argp
= &setclientid
,
5052 struct rpc_task
*task
;
5053 struct rpc_task_setup task_setup_data
= {
5054 .rpc_client
= clp
->cl_rpcclient
,
5055 .rpc_message
= &msg
,
5056 .callback_ops
= &nfs4_setclientid_ops
,
5057 .callback_data
= &setclientid
,
5058 .flags
= RPC_TASK_TIMEOUT
,
5062 /* nfs_client_id4 */
5063 nfs4_init_boot_verifier(clp
, &sc_verifier
);
5064 if (test_bit(NFS_CS_MIGRATION
, &clp
->cl_flags
))
5065 setclientid
.sc_name_len
=
5066 nfs4_init_uniform_client_string(clp
,
5067 setclientid
.sc_name
,
5068 sizeof(setclientid
.sc_name
));
5070 setclientid
.sc_name_len
=
5071 nfs4_init_nonuniform_client_string(clp
,
5072 setclientid
.sc_name
,
5073 sizeof(setclientid
.sc_name
));
5075 setclientid
.sc_netid_len
=
5076 nfs4_init_callback_netid(clp
,
5077 setclientid
.sc_netid
,
5078 sizeof(setclientid
.sc_netid
));
5079 setclientid
.sc_uaddr_len
= scnprintf(setclientid
.sc_uaddr
,
5080 sizeof(setclientid
.sc_uaddr
), "%s.%u.%u",
5081 clp
->cl_ipaddr
, port
>> 8, port
& 255);
5083 dprintk("NFS call setclientid auth=%s, '%.*s'\n",
5084 clp
->cl_rpcclient
->cl_auth
->au_ops
->au_name
,
5085 setclientid
.sc_name_len
, setclientid
.sc_name
);
5086 task
= rpc_run_task(&task_setup_data
);
5088 status
= PTR_ERR(task
);
5091 status
= task
->tk_status
;
5092 if (setclientid
.sc_cred
) {
5093 clp
->cl_acceptor
= rpcauth_stringify_acceptor(setclientid
.sc_cred
);
5094 put_rpccred(setclientid
.sc_cred
);
5098 trace_nfs4_setclientid(clp
, status
);
5099 dprintk("NFS reply setclientid: %d\n", status
);
5104 * nfs4_proc_setclientid_confirm - Confirm client ID
5105 * @clp: state data structure
5106 * @res: result of a previous SETCLIENTID
5107 * @cred: RPC credential to use for this call
5109 * Returns zero, a negative errno, or a negative NFS4ERR status code.
5111 int nfs4_proc_setclientid_confirm(struct nfs_client
*clp
,
5112 struct nfs4_setclientid_res
*arg
,
5113 struct rpc_cred
*cred
)
5115 struct rpc_message msg
= {
5116 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_SETCLIENTID_CONFIRM
],
5122 dprintk("NFS call setclientid_confirm auth=%s, (client ID %llx)\n",
5123 clp
->cl_rpcclient
->cl_auth
->au_ops
->au_name
,
5125 status
= rpc_call_sync(clp
->cl_rpcclient
, &msg
, RPC_TASK_TIMEOUT
);
5126 trace_nfs4_setclientid_confirm(clp
, status
);
5127 dprintk("NFS reply setclientid_confirm: %d\n", status
);
5131 struct nfs4_delegreturndata
{
5132 struct nfs4_delegreturnargs args
;
5133 struct nfs4_delegreturnres res
;
5135 nfs4_stateid stateid
;
5136 unsigned long timestamp
;
5137 struct nfs_fattr fattr
;
5139 struct inode
*inode
;
5144 static void nfs4_delegreturn_done(struct rpc_task
*task
, void *calldata
)
5146 struct nfs4_delegreturndata
*data
= calldata
;
5148 if (!nfs4_sequence_done(task
, &data
->res
.seq_res
))
5151 trace_nfs4_delegreturn_exit(&data
->args
, &data
->res
, task
->tk_status
);
5152 switch (task
->tk_status
) {
5154 renew_lease(data
->res
.server
, data
->timestamp
);
5155 case -NFS4ERR_ADMIN_REVOKED
:
5156 case -NFS4ERR_DELEG_REVOKED
:
5157 case -NFS4ERR_BAD_STATEID
:
5158 case -NFS4ERR_OLD_STATEID
:
5159 case -NFS4ERR_STALE_STATEID
:
5160 case -NFS4ERR_EXPIRED
:
5161 task
->tk_status
= 0;
5163 pnfs_roc_set_barrier(data
->inode
, data
->roc_barrier
);
5166 if (nfs4_async_handle_error(task
, data
->res
.server
,
5167 NULL
, NULL
) == -EAGAIN
) {
5168 rpc_restart_call_prepare(task
);
5172 data
->rpc_status
= task
->tk_status
;
5175 static void nfs4_delegreturn_release(void *calldata
)
5177 struct nfs4_delegreturndata
*data
= calldata
;
5178 struct inode
*inode
= data
->inode
;
5182 pnfs_roc_release(inode
);
5183 nfs_iput_and_deactive(inode
);
5188 static void nfs4_delegreturn_prepare(struct rpc_task
*task
, void *data
)
5190 struct nfs4_delegreturndata
*d_data
;
5192 d_data
= (struct nfs4_delegreturndata
*)data
;
5195 pnfs_roc_drain(d_data
->inode
, &d_data
->roc_barrier
, task
))
5198 nfs4_setup_sequence(d_data
->res
.server
,
5199 &d_data
->args
.seq_args
,
5200 &d_data
->res
.seq_res
,
5204 static const struct rpc_call_ops nfs4_delegreturn_ops
= {
5205 .rpc_call_prepare
= nfs4_delegreturn_prepare
,
5206 .rpc_call_done
= nfs4_delegreturn_done
,
5207 .rpc_release
= nfs4_delegreturn_release
,
5210 static int _nfs4_proc_delegreturn(struct inode
*inode
, struct rpc_cred
*cred
, const nfs4_stateid
*stateid
, int issync
)
5212 struct nfs4_delegreturndata
*data
;
5213 struct nfs_server
*server
= NFS_SERVER(inode
);
5214 struct rpc_task
*task
;
5215 struct rpc_message msg
= {
5216 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_DELEGRETURN
],
5219 struct rpc_task_setup task_setup_data
= {
5220 .rpc_client
= server
->client
,
5221 .rpc_message
= &msg
,
5222 .callback_ops
= &nfs4_delegreturn_ops
,
5223 .flags
= RPC_TASK_ASYNC
,
5227 data
= kzalloc(sizeof(*data
), GFP_NOFS
);
5230 nfs4_init_sequence(&data
->args
.seq_args
, &data
->res
.seq_res
, 1);
5231 data
->args
.fhandle
= &data
->fh
;
5232 data
->args
.stateid
= &data
->stateid
;
5233 data
->args
.bitmask
= server
->cache_consistency_bitmask
;
5234 nfs_copy_fh(&data
->fh
, NFS_FH(inode
));
5235 nfs4_stateid_copy(&data
->stateid
, stateid
);
5236 data
->res
.fattr
= &data
->fattr
;
5237 data
->res
.server
= server
;
5238 nfs_fattr_init(data
->res
.fattr
);
5239 data
->timestamp
= jiffies
;
5240 data
->rpc_status
= 0;
5241 data
->inode
= nfs_igrab_and_active(inode
);
5243 data
->roc
= nfs4_roc(inode
);
5245 task_setup_data
.callback_data
= data
;
5246 msg
.rpc_argp
= &data
->args
;
5247 msg
.rpc_resp
= &data
->res
;
5248 task
= rpc_run_task(&task_setup_data
);
5250 return PTR_ERR(task
);
5253 status
= nfs4_wait_for_completion_rpc_task(task
);
5256 status
= data
->rpc_status
;
5258 nfs_post_op_update_inode_force_wcc(inode
, &data
->fattr
);
5260 nfs_refresh_inode(inode
, &data
->fattr
);
5266 int nfs4_proc_delegreturn(struct inode
*inode
, struct rpc_cred
*cred
, const nfs4_stateid
*stateid
, int issync
)
5268 struct nfs_server
*server
= NFS_SERVER(inode
);
5269 struct nfs4_exception exception
= { };
5272 err
= _nfs4_proc_delegreturn(inode
, cred
, stateid
, issync
);
5273 trace_nfs4_delegreturn(inode
, err
);
5275 case -NFS4ERR_STALE_STATEID
:
5276 case -NFS4ERR_EXPIRED
:
5280 err
= nfs4_handle_exception(server
, err
, &exception
);
5281 } while (exception
.retry
);
5285 #define NFS4_LOCK_MINTIMEOUT (1 * HZ)
5286 #define NFS4_LOCK_MAXTIMEOUT (30 * HZ)
5289 * sleep, with exponential backoff, and retry the LOCK operation.
5291 static unsigned long
5292 nfs4_set_lock_task_retry(unsigned long timeout
)
5294 freezable_schedule_timeout_killable_unsafe(timeout
);
5296 if (timeout
> NFS4_LOCK_MAXTIMEOUT
)
5297 return NFS4_LOCK_MAXTIMEOUT
;
5301 static int _nfs4_proc_getlk(struct nfs4_state
*state
, int cmd
, struct file_lock
*request
)
5303 struct inode
*inode
= state
->inode
;
5304 struct nfs_server
*server
= NFS_SERVER(inode
);
5305 struct nfs_client
*clp
= server
->nfs_client
;
5306 struct nfs_lockt_args arg
= {
5307 .fh
= NFS_FH(inode
),
5310 struct nfs_lockt_res res
= {
5313 struct rpc_message msg
= {
5314 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_LOCKT
],
5317 .rpc_cred
= state
->owner
->so_cred
,
5319 struct nfs4_lock_state
*lsp
;
5322 arg
.lock_owner
.clientid
= clp
->cl_clientid
;
5323 status
= nfs4_set_lock_state(state
, request
);
5326 lsp
= request
->fl_u
.nfs4_fl
.owner
;
5327 arg
.lock_owner
.id
= lsp
->ls_seqid
.owner_id
;
5328 arg
.lock_owner
.s_dev
= server
->s_dev
;
5329 status
= nfs4_call_sync(server
->client
, server
, &msg
, &arg
.seq_args
, &res
.seq_res
, 1);
5332 request
->fl_type
= F_UNLCK
;
5334 case -NFS4ERR_DENIED
:
5337 request
->fl_ops
->fl_release_private(request
);
5338 request
->fl_ops
= NULL
;
5343 static int nfs4_proc_getlk(struct nfs4_state
*state
, int cmd
, struct file_lock
*request
)
5345 struct nfs4_exception exception
= { };
5349 err
= _nfs4_proc_getlk(state
, cmd
, request
);
5350 trace_nfs4_get_lock(request
, state
, cmd
, err
);
5351 err
= nfs4_handle_exception(NFS_SERVER(state
->inode
), err
,
5353 } while (exception
.retry
);
5357 static int do_vfs_lock(struct file
*file
, struct file_lock
*fl
)
5360 switch (fl
->fl_flags
& (FL_POSIX
|FL_FLOCK
)) {
5362 res
= posix_lock_file_wait(file
, fl
);
5365 res
= flock_lock_file_wait(file
, fl
);
5373 struct nfs4_unlockdata
{
5374 struct nfs_locku_args arg
;
5375 struct nfs_locku_res res
;
5376 struct nfs4_lock_state
*lsp
;
5377 struct nfs_open_context
*ctx
;
5378 struct file_lock fl
;
5379 const struct nfs_server
*server
;
5380 unsigned long timestamp
;
5383 static struct nfs4_unlockdata
*nfs4_alloc_unlockdata(struct file_lock
*fl
,
5384 struct nfs_open_context
*ctx
,
5385 struct nfs4_lock_state
*lsp
,
5386 struct nfs_seqid
*seqid
)
5388 struct nfs4_unlockdata
*p
;
5389 struct inode
*inode
= lsp
->ls_state
->inode
;
5391 p
= kzalloc(sizeof(*p
), GFP_NOFS
);
5394 p
->arg
.fh
= NFS_FH(inode
);
5396 p
->arg
.seqid
= seqid
;
5397 p
->res
.seqid
= seqid
;
5399 atomic_inc(&lsp
->ls_count
);
5400 /* Ensure we don't close file until we're done freeing locks! */
5401 p
->ctx
= get_nfs_open_context(ctx
);
5402 memcpy(&p
->fl
, fl
, sizeof(p
->fl
));
5403 p
->server
= NFS_SERVER(inode
);
5407 static void nfs4_locku_release_calldata(void *data
)
5409 struct nfs4_unlockdata
*calldata
= data
;
5410 nfs_free_seqid(calldata
->arg
.seqid
);
5411 nfs4_put_lock_state(calldata
->lsp
);
5412 put_nfs_open_context(calldata
->ctx
);
5416 static void nfs4_locku_done(struct rpc_task
*task
, void *data
)
5418 struct nfs4_unlockdata
*calldata
= data
;
5420 if (!nfs4_sequence_done(task
, &calldata
->res
.seq_res
))
5422 switch (task
->tk_status
) {
5424 renew_lease(calldata
->server
, calldata
->timestamp
);
5425 do_vfs_lock(calldata
->fl
.fl_file
, &calldata
->fl
);
5426 if (nfs4_update_lock_stateid(calldata
->lsp
,
5427 &calldata
->res
.stateid
))
5429 case -NFS4ERR_BAD_STATEID
:
5430 case -NFS4ERR_OLD_STATEID
:
5431 case -NFS4ERR_STALE_STATEID
:
5432 case -NFS4ERR_EXPIRED
:
5433 if (!nfs4_stateid_match(&calldata
->arg
.stateid
,
5434 &calldata
->lsp
->ls_stateid
))
5435 rpc_restart_call_prepare(task
);
5438 if (nfs4_async_handle_error(task
, calldata
->server
,
5439 NULL
, NULL
) == -EAGAIN
)
5440 rpc_restart_call_prepare(task
);
5442 nfs_release_seqid(calldata
->arg
.seqid
);
5445 static void nfs4_locku_prepare(struct rpc_task
*task
, void *data
)
5447 struct nfs4_unlockdata
*calldata
= data
;
5449 if (nfs_wait_on_sequence(calldata
->arg
.seqid
, task
) != 0)
5451 nfs4_stateid_copy(&calldata
->arg
.stateid
, &calldata
->lsp
->ls_stateid
);
5452 if (test_bit(NFS_LOCK_INITIALIZED
, &calldata
->lsp
->ls_flags
) == 0) {
5453 /* Note: exit _without_ running nfs4_locku_done */
5456 calldata
->timestamp
= jiffies
;
5457 if (nfs4_setup_sequence(calldata
->server
,
5458 &calldata
->arg
.seq_args
,
5459 &calldata
->res
.seq_res
,
5461 nfs_release_seqid(calldata
->arg
.seqid
);
5464 task
->tk_action
= NULL
;
5466 nfs4_sequence_done(task
, &calldata
->res
.seq_res
);
5469 static const struct rpc_call_ops nfs4_locku_ops
= {
5470 .rpc_call_prepare
= nfs4_locku_prepare
,
5471 .rpc_call_done
= nfs4_locku_done
,
5472 .rpc_release
= nfs4_locku_release_calldata
,
5475 static struct rpc_task
*nfs4_do_unlck(struct file_lock
*fl
,
5476 struct nfs_open_context
*ctx
,
5477 struct nfs4_lock_state
*lsp
,
5478 struct nfs_seqid
*seqid
)
5480 struct nfs4_unlockdata
*data
;
5481 struct rpc_message msg
= {
5482 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_LOCKU
],
5483 .rpc_cred
= ctx
->cred
,
5485 struct rpc_task_setup task_setup_data
= {
5486 .rpc_client
= NFS_CLIENT(lsp
->ls_state
->inode
),
5487 .rpc_message
= &msg
,
5488 .callback_ops
= &nfs4_locku_ops
,
5489 .workqueue
= nfsiod_workqueue
,
5490 .flags
= RPC_TASK_ASYNC
,
5493 nfs4_state_protect(NFS_SERVER(lsp
->ls_state
->inode
)->nfs_client
,
5494 NFS_SP4_MACH_CRED_CLEANUP
, &task_setup_data
.rpc_client
, &msg
);
5496 /* Ensure this is an unlock - when canceling a lock, the
5497 * canceled lock is passed in, and it won't be an unlock.
5499 fl
->fl_type
= F_UNLCK
;
5501 data
= nfs4_alloc_unlockdata(fl
, ctx
, lsp
, seqid
);
5503 nfs_free_seqid(seqid
);
5504 return ERR_PTR(-ENOMEM
);
5507 nfs4_init_sequence(&data
->arg
.seq_args
, &data
->res
.seq_res
, 1);
5508 msg
.rpc_argp
= &data
->arg
;
5509 msg
.rpc_resp
= &data
->res
;
5510 task_setup_data
.callback_data
= data
;
5511 return rpc_run_task(&task_setup_data
);
5514 static int nfs4_proc_unlck(struct nfs4_state
*state
, int cmd
, struct file_lock
*request
)
5516 struct inode
*inode
= state
->inode
;
5517 struct nfs4_state_owner
*sp
= state
->owner
;
5518 struct nfs_inode
*nfsi
= NFS_I(inode
);
5519 struct nfs_seqid
*seqid
;
5520 struct nfs4_lock_state
*lsp
;
5521 struct rpc_task
*task
;
5522 struct nfs_seqid
*(*alloc_seqid
)(struct nfs_seqid_counter
*, gfp_t
);
5524 unsigned char fl_flags
= request
->fl_flags
;
5526 status
= nfs4_set_lock_state(state
, request
);
5527 /* Unlock _before_ we do the RPC call */
5528 request
->fl_flags
|= FL_EXISTS
;
5529 /* Exclude nfs_delegation_claim_locks() */
5530 mutex_lock(&sp
->so_delegreturn_mutex
);
5531 /* Exclude nfs4_reclaim_open_stateid() - note nesting! */
5532 down_read(&nfsi
->rwsem
);
5533 if (do_vfs_lock(request
->fl_file
, request
) == -ENOENT
) {
5534 up_read(&nfsi
->rwsem
);
5535 mutex_unlock(&sp
->so_delegreturn_mutex
);
5538 up_read(&nfsi
->rwsem
);
5539 mutex_unlock(&sp
->so_delegreturn_mutex
);
5542 /* Is this a delegated lock? */
5543 lsp
= request
->fl_u
.nfs4_fl
.owner
;
5544 if (test_bit(NFS_LOCK_INITIALIZED
, &lsp
->ls_flags
) == 0)
5546 alloc_seqid
= NFS_SERVER(inode
)->nfs_client
->cl_mvops
->alloc_seqid
;
5547 seqid
= alloc_seqid(&lsp
->ls_seqid
, GFP_KERNEL
);
5551 task
= nfs4_do_unlck(request
, nfs_file_open_context(request
->fl_file
), lsp
, seqid
);
5552 status
= PTR_ERR(task
);
5555 status
= nfs4_wait_for_completion_rpc_task(task
);
5558 request
->fl_flags
= fl_flags
;
5559 trace_nfs4_unlock(request
, state
, F_SETLK
, status
);
5563 struct nfs4_lockdata
{
5564 struct nfs_lock_args arg
;
5565 struct nfs_lock_res res
;
5566 struct nfs4_lock_state
*lsp
;
5567 struct nfs_open_context
*ctx
;
5568 struct file_lock fl
;
5569 unsigned long timestamp
;
5572 struct nfs_server
*server
;
5575 static struct nfs4_lockdata
*nfs4_alloc_lockdata(struct file_lock
*fl
,
5576 struct nfs_open_context
*ctx
, struct nfs4_lock_state
*lsp
,
5579 struct nfs4_lockdata
*p
;
5580 struct inode
*inode
= lsp
->ls_state
->inode
;
5581 struct nfs_server
*server
= NFS_SERVER(inode
);
5582 struct nfs_seqid
*(*alloc_seqid
)(struct nfs_seqid_counter
*, gfp_t
);
5584 p
= kzalloc(sizeof(*p
), gfp_mask
);
5588 p
->arg
.fh
= NFS_FH(inode
);
5590 p
->arg
.open_seqid
= nfs_alloc_seqid(&lsp
->ls_state
->owner
->so_seqid
, gfp_mask
);
5591 if (IS_ERR(p
->arg
.open_seqid
))
5593 alloc_seqid
= server
->nfs_client
->cl_mvops
->alloc_seqid
;
5594 p
->arg
.lock_seqid
= alloc_seqid(&lsp
->ls_seqid
, gfp_mask
);
5595 if (IS_ERR(p
->arg
.lock_seqid
))
5596 goto out_free_seqid
;
5597 p
->arg
.lock_owner
.clientid
= server
->nfs_client
->cl_clientid
;
5598 p
->arg
.lock_owner
.id
= lsp
->ls_seqid
.owner_id
;
5599 p
->arg
.lock_owner
.s_dev
= server
->s_dev
;
5600 p
->res
.lock_seqid
= p
->arg
.lock_seqid
;
5603 atomic_inc(&lsp
->ls_count
);
5604 p
->ctx
= get_nfs_open_context(ctx
);
5605 memcpy(&p
->fl
, fl
, sizeof(p
->fl
));
5608 nfs_free_seqid(p
->arg
.open_seqid
);
5614 static void nfs4_lock_prepare(struct rpc_task
*task
, void *calldata
)
5616 struct nfs4_lockdata
*data
= calldata
;
5617 struct nfs4_state
*state
= data
->lsp
->ls_state
;
5619 dprintk("%s: begin!\n", __func__
);
5620 if (nfs_wait_on_sequence(data
->arg
.lock_seqid
, task
) != 0)
5622 /* Do we need to do an open_to_lock_owner? */
5623 if (!test_bit(NFS_LOCK_INITIALIZED
, &data
->lsp
->ls_flags
)) {
5624 if (nfs_wait_on_sequence(data
->arg
.open_seqid
, task
) != 0) {
5625 goto out_release_lock_seqid
;
5627 nfs4_stateid_copy(&data
->arg
.open_stateid
,
5628 &state
->open_stateid
);
5629 data
->arg
.new_lock_owner
= 1;
5630 data
->res
.open_seqid
= data
->arg
.open_seqid
;
5632 data
->arg
.new_lock_owner
= 0;
5633 nfs4_stateid_copy(&data
->arg
.lock_stateid
,
5634 &data
->lsp
->ls_stateid
);
5636 if (!nfs4_valid_open_stateid(state
)) {
5637 data
->rpc_status
= -EBADF
;
5638 task
->tk_action
= NULL
;
5639 goto out_release_open_seqid
;
5641 data
->timestamp
= jiffies
;
5642 if (nfs4_setup_sequence(data
->server
,
5643 &data
->arg
.seq_args
,
5647 out_release_open_seqid
:
5648 nfs_release_seqid(data
->arg
.open_seqid
);
5649 out_release_lock_seqid
:
5650 nfs_release_seqid(data
->arg
.lock_seqid
);
5652 nfs4_sequence_done(task
, &data
->res
.seq_res
);
5653 dprintk("%s: done!, ret = %d\n", __func__
, data
->rpc_status
);
5656 static void nfs4_lock_done(struct rpc_task
*task
, void *calldata
)
5658 struct nfs4_lockdata
*data
= calldata
;
5659 struct nfs4_lock_state
*lsp
= data
->lsp
;
5661 dprintk("%s: begin!\n", __func__
);
5663 if (!nfs4_sequence_done(task
, &data
->res
.seq_res
))
5666 data
->rpc_status
= task
->tk_status
;
5667 switch (task
->tk_status
) {
5669 renew_lease(NFS_SERVER(data
->ctx
->dentry
->d_inode
),
5671 if (data
->arg
.new_lock
) {
5672 data
->fl
.fl_flags
&= ~(FL_SLEEP
| FL_ACCESS
);
5673 if (do_vfs_lock(data
->fl
.fl_file
, &data
->fl
) < 0) {
5674 rpc_restart_call_prepare(task
);
5678 if (data
->arg
.new_lock_owner
!= 0) {
5679 nfs_confirm_seqid(&lsp
->ls_seqid
, 0);
5680 nfs4_stateid_copy(&lsp
->ls_stateid
, &data
->res
.stateid
);
5681 set_bit(NFS_LOCK_INITIALIZED
, &lsp
->ls_flags
);
5682 } else if (!nfs4_update_lock_stateid(lsp
, &data
->res
.stateid
))
5683 rpc_restart_call_prepare(task
);
5685 case -NFS4ERR_BAD_STATEID
:
5686 case -NFS4ERR_OLD_STATEID
:
5687 case -NFS4ERR_STALE_STATEID
:
5688 case -NFS4ERR_EXPIRED
:
5689 if (data
->arg
.new_lock_owner
!= 0) {
5690 if (!nfs4_stateid_match(&data
->arg
.open_stateid
,
5691 &lsp
->ls_state
->open_stateid
))
5692 rpc_restart_call_prepare(task
);
5693 } else if (!nfs4_stateid_match(&data
->arg
.lock_stateid
,
5695 rpc_restart_call_prepare(task
);
5697 dprintk("%s: done, ret = %d!\n", __func__
, data
->rpc_status
);
5700 static void nfs4_lock_release(void *calldata
)
5702 struct nfs4_lockdata
*data
= calldata
;
5704 dprintk("%s: begin!\n", __func__
);
5705 nfs_free_seqid(data
->arg
.open_seqid
);
5706 if (data
->cancelled
!= 0) {
5707 struct rpc_task
*task
;
5708 task
= nfs4_do_unlck(&data
->fl
, data
->ctx
, data
->lsp
,
5709 data
->arg
.lock_seqid
);
5711 rpc_put_task_async(task
);
5712 dprintk("%s: cancelling lock!\n", __func__
);
5714 nfs_free_seqid(data
->arg
.lock_seqid
);
5715 nfs4_put_lock_state(data
->lsp
);
5716 put_nfs_open_context(data
->ctx
);
5718 dprintk("%s: done!\n", __func__
);
5721 static const struct rpc_call_ops nfs4_lock_ops
= {
5722 .rpc_call_prepare
= nfs4_lock_prepare
,
5723 .rpc_call_done
= nfs4_lock_done
,
5724 .rpc_release
= nfs4_lock_release
,
5727 static void nfs4_handle_setlk_error(struct nfs_server
*server
, struct nfs4_lock_state
*lsp
, int new_lock_owner
, int error
)
5730 case -NFS4ERR_ADMIN_REVOKED
:
5731 case -NFS4ERR_BAD_STATEID
:
5732 lsp
->ls_seqid
.flags
&= ~NFS_SEQID_CONFIRMED
;
5733 if (new_lock_owner
!= 0 ||
5734 test_bit(NFS_LOCK_INITIALIZED
, &lsp
->ls_flags
) != 0)
5735 nfs4_schedule_stateid_recovery(server
, lsp
->ls_state
);
5737 case -NFS4ERR_STALE_STATEID
:
5738 lsp
->ls_seqid
.flags
&= ~NFS_SEQID_CONFIRMED
;
5739 case -NFS4ERR_EXPIRED
:
5740 nfs4_schedule_lease_recovery(server
->nfs_client
);
5744 static int _nfs4_do_setlk(struct nfs4_state
*state
, int cmd
, struct file_lock
*fl
, int recovery_type
)
5746 struct nfs4_lockdata
*data
;
5747 struct rpc_task
*task
;
5748 struct rpc_message msg
= {
5749 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_LOCK
],
5750 .rpc_cred
= state
->owner
->so_cred
,
5752 struct rpc_task_setup task_setup_data
= {
5753 .rpc_client
= NFS_CLIENT(state
->inode
),
5754 .rpc_message
= &msg
,
5755 .callback_ops
= &nfs4_lock_ops
,
5756 .workqueue
= nfsiod_workqueue
,
5757 .flags
= RPC_TASK_ASYNC
,
5761 dprintk("%s: begin!\n", __func__
);
5762 data
= nfs4_alloc_lockdata(fl
, nfs_file_open_context(fl
->fl_file
),
5763 fl
->fl_u
.nfs4_fl
.owner
,
5764 recovery_type
== NFS_LOCK_NEW
? GFP_KERNEL
: GFP_NOFS
);
5768 data
->arg
.block
= 1;
5769 nfs4_init_sequence(&data
->arg
.seq_args
, &data
->res
.seq_res
, 1);
5770 msg
.rpc_argp
= &data
->arg
;
5771 msg
.rpc_resp
= &data
->res
;
5772 task_setup_data
.callback_data
= data
;
5773 if (recovery_type
> NFS_LOCK_NEW
) {
5774 if (recovery_type
== NFS_LOCK_RECLAIM
)
5775 data
->arg
.reclaim
= NFS_LOCK_RECLAIM
;
5776 nfs4_set_sequence_privileged(&data
->arg
.seq_args
);
5778 data
->arg
.new_lock
= 1;
5779 task
= rpc_run_task(&task_setup_data
);
5781 return PTR_ERR(task
);
5782 ret
= nfs4_wait_for_completion_rpc_task(task
);
5784 ret
= data
->rpc_status
;
5786 nfs4_handle_setlk_error(data
->server
, data
->lsp
,
5787 data
->arg
.new_lock_owner
, ret
);
5789 data
->cancelled
= 1;
5791 dprintk("%s: done, ret = %d!\n", __func__
, ret
);
5795 static int nfs4_lock_reclaim(struct nfs4_state
*state
, struct file_lock
*request
)
5797 struct nfs_server
*server
= NFS_SERVER(state
->inode
);
5798 struct nfs4_exception exception
= {
5799 .inode
= state
->inode
,
5804 /* Cache the lock if possible... */
5805 if (test_bit(NFS_DELEGATED_STATE
, &state
->flags
) != 0)
5807 err
= _nfs4_do_setlk(state
, F_SETLK
, request
, NFS_LOCK_RECLAIM
);
5808 trace_nfs4_lock_reclaim(request
, state
, F_SETLK
, err
);
5809 if (err
!= -NFS4ERR_DELAY
)
5811 nfs4_handle_exception(server
, err
, &exception
);
5812 } while (exception
.retry
);
5816 static int nfs4_lock_expired(struct nfs4_state
*state
, struct file_lock
*request
)
5818 struct nfs_server
*server
= NFS_SERVER(state
->inode
);
5819 struct nfs4_exception exception
= {
5820 .inode
= state
->inode
,
5824 err
= nfs4_set_lock_state(state
, request
);
5827 if (!recover_lost_locks
) {
5828 set_bit(NFS_LOCK_LOST
, &request
->fl_u
.nfs4_fl
.owner
->ls_flags
);
5832 if (test_bit(NFS_DELEGATED_STATE
, &state
->flags
) != 0)
5834 err
= _nfs4_do_setlk(state
, F_SETLK
, request
, NFS_LOCK_EXPIRED
);
5835 trace_nfs4_lock_expired(request
, state
, F_SETLK
, err
);
5839 case -NFS4ERR_GRACE
:
5840 case -NFS4ERR_DELAY
:
5841 nfs4_handle_exception(server
, err
, &exception
);
5844 } while (exception
.retry
);
5849 #if defined(CONFIG_NFS_V4_1)
5851 * nfs41_check_expired_locks - possibly free a lock stateid
5853 * @state: NFSv4 state for an inode
5855 * Returns NFS_OK if recovery for this stateid is now finished.
5856 * Otherwise a negative NFS4ERR value is returned.
5858 static int nfs41_check_expired_locks(struct nfs4_state
*state
)
5860 int status
, ret
= -NFS4ERR_BAD_STATEID
;
5861 struct nfs4_lock_state
*lsp
;
5862 struct nfs_server
*server
= NFS_SERVER(state
->inode
);
5864 list_for_each_entry(lsp
, &state
->lock_states
, ls_locks
) {
5865 if (test_bit(NFS_LOCK_INITIALIZED
, &lsp
->ls_flags
)) {
5866 struct rpc_cred
*cred
= lsp
->ls_state
->owner
->so_cred
;
5868 status
= nfs41_test_stateid(server
,
5871 trace_nfs4_test_lock_stateid(state
, lsp
, status
);
5872 if (status
!= NFS_OK
) {
5873 /* Free the stateid unless the server
5874 * informs us the stateid is unrecognized. */
5875 if (status
!= -NFS4ERR_BAD_STATEID
)
5876 nfs41_free_stateid(server
,
5879 clear_bit(NFS_LOCK_INITIALIZED
, &lsp
->ls_flags
);
5888 static int nfs41_lock_expired(struct nfs4_state
*state
, struct file_lock
*request
)
5890 int status
= NFS_OK
;
5892 if (test_bit(LK_STATE_IN_USE
, &state
->flags
))
5893 status
= nfs41_check_expired_locks(state
);
5894 if (status
!= NFS_OK
)
5895 status
= nfs4_lock_expired(state
, request
);
5900 static int _nfs4_proc_setlk(struct nfs4_state
*state
, int cmd
, struct file_lock
*request
)
5902 struct nfs_inode
*nfsi
= NFS_I(state
->inode
);
5903 unsigned char fl_flags
= request
->fl_flags
;
5904 int status
= -ENOLCK
;
5906 if ((fl_flags
& FL_POSIX
) &&
5907 !test_bit(NFS_STATE_POSIX_LOCKS
, &state
->flags
))
5909 /* Is this a delegated open? */
5910 status
= nfs4_set_lock_state(state
, request
);
5913 request
->fl_flags
|= FL_ACCESS
;
5914 status
= do_vfs_lock(request
->fl_file
, request
);
5917 down_read(&nfsi
->rwsem
);
5918 if (test_bit(NFS_DELEGATED_STATE
, &state
->flags
)) {
5919 /* Yes: cache locks! */
5920 /* ...but avoid races with delegation recall... */
5921 request
->fl_flags
= fl_flags
& ~FL_SLEEP
;
5922 status
= do_vfs_lock(request
->fl_file
, request
);
5923 up_read(&nfsi
->rwsem
);
5926 up_read(&nfsi
->rwsem
);
5927 status
= _nfs4_do_setlk(state
, cmd
, request
, NFS_LOCK_NEW
);
5929 request
->fl_flags
= fl_flags
;
5933 static int nfs4_proc_setlk(struct nfs4_state
*state
, int cmd
, struct file_lock
*request
)
5935 struct nfs4_exception exception
= {
5937 .inode
= state
->inode
,
5942 err
= _nfs4_proc_setlk(state
, cmd
, request
);
5943 trace_nfs4_set_lock(request
, state
, cmd
, err
);
5944 if (err
== -NFS4ERR_DENIED
)
5946 err
= nfs4_handle_exception(NFS_SERVER(state
->inode
),
5948 } while (exception
.retry
);
5953 nfs4_proc_lock(struct file
*filp
, int cmd
, struct file_lock
*request
)
5955 struct nfs_open_context
*ctx
;
5956 struct nfs4_state
*state
;
5957 unsigned long timeout
= NFS4_LOCK_MINTIMEOUT
;
5960 /* verify open state */
5961 ctx
= nfs_file_open_context(filp
);
5964 if (request
->fl_start
< 0 || request
->fl_end
< 0)
5967 if (IS_GETLK(cmd
)) {
5969 return nfs4_proc_getlk(state
, F_GETLK
, request
);
5973 if (!(IS_SETLK(cmd
) || IS_SETLKW(cmd
)))
5976 if (request
->fl_type
== F_UNLCK
) {
5978 return nfs4_proc_unlck(state
, cmd
, request
);
5985 * Don't rely on the VFS having checked the file open mode,
5986 * since it won't do this for flock() locks.
5988 switch (request
->fl_type
) {
5990 if (!(filp
->f_mode
& FMODE_READ
))
5994 if (!(filp
->f_mode
& FMODE_WRITE
))
5999 status
= nfs4_proc_setlk(state
, cmd
, request
);
6000 if ((status
!= -EAGAIN
) || IS_SETLK(cmd
))
6002 timeout
= nfs4_set_lock_task_retry(timeout
);
6003 status
= -ERESTARTSYS
;
6006 } while(status
< 0);
6010 int nfs4_lock_delegation_recall(struct file_lock
*fl
, struct nfs4_state
*state
, const nfs4_stateid
*stateid
)
6012 struct nfs_server
*server
= NFS_SERVER(state
->inode
);
6015 err
= nfs4_set_lock_state(state
, fl
);
6018 err
= _nfs4_do_setlk(state
, F_SETLK
, fl
, NFS_LOCK_NEW
);
6019 return nfs4_handle_delegation_recall_error(server
, state
, stateid
, err
);
6022 struct nfs_release_lockowner_data
{
6023 struct nfs4_lock_state
*lsp
;
6024 struct nfs_server
*server
;
6025 struct nfs_release_lockowner_args args
;
6026 struct nfs_release_lockowner_res res
;
6027 unsigned long timestamp
;
6030 static void nfs4_release_lockowner_prepare(struct rpc_task
*task
, void *calldata
)
6032 struct nfs_release_lockowner_data
*data
= calldata
;
6033 struct nfs_server
*server
= data
->server
;
6034 nfs40_setup_sequence(server
->nfs_client
->cl_slot_tbl
,
6035 &data
->args
.seq_args
, &data
->res
.seq_res
, task
);
6036 data
->args
.lock_owner
.clientid
= server
->nfs_client
->cl_clientid
;
6037 data
->timestamp
= jiffies
;
6040 static void nfs4_release_lockowner_done(struct rpc_task
*task
, void *calldata
)
6042 struct nfs_release_lockowner_data
*data
= calldata
;
6043 struct nfs_server
*server
= data
->server
;
6045 nfs40_sequence_done(task
, &data
->res
.seq_res
);
6047 switch (task
->tk_status
) {
6049 renew_lease(server
, data
->timestamp
);
6051 case -NFS4ERR_STALE_CLIENTID
:
6052 case -NFS4ERR_EXPIRED
:
6053 nfs4_schedule_lease_recovery(server
->nfs_client
);
6055 case -NFS4ERR_LEASE_MOVED
:
6056 case -NFS4ERR_DELAY
:
6057 if (nfs4_async_handle_error(task
, server
,
6058 NULL
, NULL
) == -EAGAIN
)
6059 rpc_restart_call_prepare(task
);
6063 static void nfs4_release_lockowner_release(void *calldata
)
6065 struct nfs_release_lockowner_data
*data
= calldata
;
6066 nfs4_free_lock_state(data
->server
, data
->lsp
);
6070 static const struct rpc_call_ops nfs4_release_lockowner_ops
= {
6071 .rpc_call_prepare
= nfs4_release_lockowner_prepare
,
6072 .rpc_call_done
= nfs4_release_lockowner_done
,
6073 .rpc_release
= nfs4_release_lockowner_release
,
6077 nfs4_release_lockowner(struct nfs_server
*server
, struct nfs4_lock_state
*lsp
)
6079 struct nfs_release_lockowner_data
*data
;
6080 struct rpc_message msg
= {
6081 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_RELEASE_LOCKOWNER
],
6084 if (server
->nfs_client
->cl_mvops
->minor_version
!= 0)
6087 data
= kmalloc(sizeof(*data
), GFP_NOFS
);
6091 data
->server
= server
;
6092 data
->args
.lock_owner
.clientid
= server
->nfs_client
->cl_clientid
;
6093 data
->args
.lock_owner
.id
= lsp
->ls_seqid
.owner_id
;
6094 data
->args
.lock_owner
.s_dev
= server
->s_dev
;
6096 msg
.rpc_argp
= &data
->args
;
6097 msg
.rpc_resp
= &data
->res
;
6098 nfs4_init_sequence(&data
->args
.seq_args
, &data
->res
.seq_res
, 0);
6099 rpc_call_async(server
->client
, &msg
, 0, &nfs4_release_lockowner_ops
, data
);
6102 #define XATTR_NAME_NFSV4_ACL "system.nfs4_acl"
6104 static int nfs4_xattr_set_nfs4_acl(struct dentry
*dentry
, const char *key
,
6105 const void *buf
, size_t buflen
,
6106 int flags
, int type
)
6108 if (strcmp(key
, "") != 0)
6111 return nfs4_proc_set_acl(dentry
->d_inode
, buf
, buflen
);
6114 static int nfs4_xattr_get_nfs4_acl(struct dentry
*dentry
, const char *key
,
6115 void *buf
, size_t buflen
, int type
)
6117 if (strcmp(key
, "") != 0)
6120 return nfs4_proc_get_acl(dentry
->d_inode
, buf
, buflen
);
6123 static size_t nfs4_xattr_list_nfs4_acl(struct dentry
*dentry
, char *list
,
6124 size_t list_len
, const char *name
,
6125 size_t name_len
, int type
)
6127 size_t len
= sizeof(XATTR_NAME_NFSV4_ACL
);
6129 if (!nfs4_server_supports_acls(NFS_SERVER(dentry
->d_inode
)))
6132 if (list
&& len
<= list_len
)
6133 memcpy(list
, XATTR_NAME_NFSV4_ACL
, len
);
6137 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
6138 static inline int nfs4_server_supports_labels(struct nfs_server
*server
)
6140 return server
->caps
& NFS_CAP_SECURITY_LABEL
;
6143 static int nfs4_xattr_set_nfs4_label(struct dentry
*dentry
, const char *key
,
6144 const void *buf
, size_t buflen
,
6145 int flags
, int type
)
6147 if (security_ismaclabel(key
))
6148 return nfs4_set_security_label(dentry
, buf
, buflen
);
6153 static int nfs4_xattr_get_nfs4_label(struct dentry
*dentry
, const char *key
,
6154 void *buf
, size_t buflen
, int type
)
6156 if (security_ismaclabel(key
))
6157 return nfs4_get_security_label(dentry
->d_inode
, buf
, buflen
);
6161 static size_t nfs4_xattr_list_nfs4_label(struct dentry
*dentry
, char *list
,
6162 size_t list_len
, const char *name
,
6163 size_t name_len
, int type
)
6167 if (nfs_server_capable(dentry
->d_inode
, NFS_CAP_SECURITY_LABEL
)) {
6168 len
= security_inode_listsecurity(dentry
->d_inode
, NULL
, 0);
6169 if (list
&& len
<= list_len
)
6170 security_inode_listsecurity(dentry
->d_inode
, list
, len
);
6175 static const struct xattr_handler nfs4_xattr_nfs4_label_handler
= {
6176 .prefix
= XATTR_SECURITY_PREFIX
,
6177 .list
= nfs4_xattr_list_nfs4_label
,
6178 .get
= nfs4_xattr_get_nfs4_label
,
6179 .set
= nfs4_xattr_set_nfs4_label
,
6185 * nfs_fhget will use either the mounted_on_fileid or the fileid
6187 static void nfs_fixup_referral_attributes(struct nfs_fattr
*fattr
)
6189 if (!(((fattr
->valid
& NFS_ATTR_FATTR_MOUNTED_ON_FILEID
) ||
6190 (fattr
->valid
& NFS_ATTR_FATTR_FILEID
)) &&
6191 (fattr
->valid
& NFS_ATTR_FATTR_FSID
) &&
6192 (fattr
->valid
& NFS_ATTR_FATTR_V4_LOCATIONS
)))
6195 fattr
->valid
|= NFS_ATTR_FATTR_TYPE
| NFS_ATTR_FATTR_MODE
|
6196 NFS_ATTR_FATTR_NLINK
| NFS_ATTR_FATTR_V4_REFERRAL
;
6197 fattr
->mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
;
6201 static int _nfs4_proc_fs_locations(struct rpc_clnt
*client
, struct inode
*dir
,
6202 const struct qstr
*name
,
6203 struct nfs4_fs_locations
*fs_locations
,
6206 struct nfs_server
*server
= NFS_SERVER(dir
);
6208 [0] = FATTR4_WORD0_FSID
| FATTR4_WORD0_FS_LOCATIONS
,
6210 struct nfs4_fs_locations_arg args
= {
6211 .dir_fh
= NFS_FH(dir
),
6216 struct nfs4_fs_locations_res res
= {
6217 .fs_locations
= fs_locations
,
6219 struct rpc_message msg
= {
6220 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_FS_LOCATIONS
],
6226 dprintk("%s: start\n", __func__
);
6228 /* Ask for the fileid of the absent filesystem if mounted_on_fileid
6229 * is not supported */
6230 if (NFS_SERVER(dir
)->attr_bitmask
[1] & FATTR4_WORD1_MOUNTED_ON_FILEID
)
6231 bitmask
[1] |= FATTR4_WORD1_MOUNTED_ON_FILEID
;
6233 bitmask
[0] |= FATTR4_WORD0_FILEID
;
6235 nfs_fattr_init(&fs_locations
->fattr
);
6236 fs_locations
->server
= server
;
6237 fs_locations
->nlocations
= 0;
6238 status
= nfs4_call_sync(client
, server
, &msg
, &args
.seq_args
, &res
.seq_res
, 0);
6239 dprintk("%s: returned status = %d\n", __func__
, status
);
6243 int nfs4_proc_fs_locations(struct rpc_clnt
*client
, struct inode
*dir
,
6244 const struct qstr
*name
,
6245 struct nfs4_fs_locations
*fs_locations
,
6248 struct nfs4_exception exception
= { };
6251 err
= _nfs4_proc_fs_locations(client
, dir
, name
,
6252 fs_locations
, page
);
6253 trace_nfs4_get_fs_locations(dir
, name
, err
);
6254 err
= nfs4_handle_exception(NFS_SERVER(dir
), err
,
6256 } while (exception
.retry
);
6261 * This operation also signals the server that this client is
6262 * performing migration recovery. The server can stop returning
6263 * NFS4ERR_LEASE_MOVED to this client. A RENEW operation is
6264 * appended to this compound to identify the client ID which is
6265 * performing recovery.
6267 static int _nfs40_proc_get_locations(struct inode
*inode
,
6268 struct nfs4_fs_locations
*locations
,
6269 struct page
*page
, struct rpc_cred
*cred
)
6271 struct nfs_server
*server
= NFS_SERVER(inode
);
6272 struct rpc_clnt
*clnt
= server
->client
;
6274 [0] = FATTR4_WORD0_FSID
| FATTR4_WORD0_FS_LOCATIONS
,
6276 struct nfs4_fs_locations_arg args
= {
6277 .clientid
= server
->nfs_client
->cl_clientid
,
6278 .fh
= NFS_FH(inode
),
6281 .migration
= 1, /* skip LOOKUP */
6282 .renew
= 1, /* append RENEW */
6284 struct nfs4_fs_locations_res res
= {
6285 .fs_locations
= locations
,
6289 struct rpc_message msg
= {
6290 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_FS_LOCATIONS
],
6295 unsigned long now
= jiffies
;
6298 nfs_fattr_init(&locations
->fattr
);
6299 locations
->server
= server
;
6300 locations
->nlocations
= 0;
6302 nfs4_init_sequence(&args
.seq_args
, &res
.seq_res
, 0);
6303 nfs4_set_sequence_privileged(&args
.seq_args
);
6304 status
= nfs4_call_sync_sequence(clnt
, server
, &msg
,
6305 &args
.seq_args
, &res
.seq_res
);
6309 renew_lease(server
, now
);
6313 #ifdef CONFIG_NFS_V4_1
6316 * This operation also signals the server that this client is
6317 * performing migration recovery. The server can stop asserting
6318 * SEQ4_STATUS_LEASE_MOVED for this client. The client ID
6319 * performing this operation is identified in the SEQUENCE
6320 * operation in this compound.
6322 * When the client supports GETATTR(fs_locations_info), it can
6323 * be plumbed in here.
6325 static int _nfs41_proc_get_locations(struct inode
*inode
,
6326 struct nfs4_fs_locations
*locations
,
6327 struct page
*page
, struct rpc_cred
*cred
)
6329 struct nfs_server
*server
= NFS_SERVER(inode
);
6330 struct rpc_clnt
*clnt
= server
->client
;
6332 [0] = FATTR4_WORD0_FSID
| FATTR4_WORD0_FS_LOCATIONS
,
6334 struct nfs4_fs_locations_arg args
= {
6335 .fh
= NFS_FH(inode
),
6338 .migration
= 1, /* skip LOOKUP */
6340 struct nfs4_fs_locations_res res
= {
6341 .fs_locations
= locations
,
6344 struct rpc_message msg
= {
6345 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_FS_LOCATIONS
],
6352 nfs_fattr_init(&locations
->fattr
);
6353 locations
->server
= server
;
6354 locations
->nlocations
= 0;
6356 nfs4_init_sequence(&args
.seq_args
, &res
.seq_res
, 0);
6357 nfs4_set_sequence_privileged(&args
.seq_args
);
6358 status
= nfs4_call_sync_sequence(clnt
, server
, &msg
,
6359 &args
.seq_args
, &res
.seq_res
);
6360 if (status
== NFS4_OK
&&
6361 res
.seq_res
.sr_status_flags
& SEQ4_STATUS_LEASE_MOVED
)
6362 status
= -NFS4ERR_LEASE_MOVED
;
6366 #endif /* CONFIG_NFS_V4_1 */
6369 * nfs4_proc_get_locations - discover locations for a migrated FSID
6370 * @inode: inode on FSID that is migrating
6371 * @locations: result of query
6373 * @cred: credential to use for this operation
6375 * Returns NFS4_OK on success, a negative NFS4ERR status code if the
6376 * operation failed, or a negative errno if a local error occurred.
6378 * On success, "locations" is filled in, but if the server has
6379 * no locations information, NFS_ATTR_FATTR_V4_LOCATIONS is not
6382 * -NFS4ERR_LEASE_MOVED is returned if the server still has leases
6383 * from this client that require migration recovery.
6385 int nfs4_proc_get_locations(struct inode
*inode
,
6386 struct nfs4_fs_locations
*locations
,
6387 struct page
*page
, struct rpc_cred
*cred
)
6389 struct nfs_server
*server
= NFS_SERVER(inode
);
6390 struct nfs_client
*clp
= server
->nfs_client
;
6391 const struct nfs4_mig_recovery_ops
*ops
=
6392 clp
->cl_mvops
->mig_recovery_ops
;
6393 struct nfs4_exception exception
= { };
6396 dprintk("%s: FSID %llx:%llx on \"%s\"\n", __func__
,
6397 (unsigned long long)server
->fsid
.major
,
6398 (unsigned long long)server
->fsid
.minor
,
6400 nfs_display_fhandle(NFS_FH(inode
), __func__
);
6403 status
= ops
->get_locations(inode
, locations
, page
, cred
);
6404 if (status
!= -NFS4ERR_DELAY
)
6406 nfs4_handle_exception(server
, status
, &exception
);
6407 } while (exception
.retry
);
6412 * This operation also signals the server that this client is
6413 * performing "lease moved" recovery. The server can stop
6414 * returning NFS4ERR_LEASE_MOVED to this client. A RENEW operation
6415 * is appended to this compound to identify the client ID which is
6416 * performing recovery.
6418 static int _nfs40_proc_fsid_present(struct inode
*inode
, struct rpc_cred
*cred
)
6420 struct nfs_server
*server
= NFS_SERVER(inode
);
6421 struct nfs_client
*clp
= NFS_SERVER(inode
)->nfs_client
;
6422 struct rpc_clnt
*clnt
= server
->client
;
6423 struct nfs4_fsid_present_arg args
= {
6424 .fh
= NFS_FH(inode
),
6425 .clientid
= clp
->cl_clientid
,
6426 .renew
= 1, /* append RENEW */
6428 struct nfs4_fsid_present_res res
= {
6431 struct rpc_message msg
= {
6432 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_FSID_PRESENT
],
6437 unsigned long now
= jiffies
;
6440 res
.fh
= nfs_alloc_fhandle();
6444 nfs4_init_sequence(&args
.seq_args
, &res
.seq_res
, 0);
6445 nfs4_set_sequence_privileged(&args
.seq_args
);
6446 status
= nfs4_call_sync_sequence(clnt
, server
, &msg
,
6447 &args
.seq_args
, &res
.seq_res
);
6448 nfs_free_fhandle(res
.fh
);
6452 do_renew_lease(clp
, now
);
6456 #ifdef CONFIG_NFS_V4_1
6459 * This operation also signals the server that this client is
6460 * performing "lease moved" recovery. The server can stop asserting
6461 * SEQ4_STATUS_LEASE_MOVED for this client. The client ID performing
6462 * this operation is identified in the SEQUENCE operation in this
6465 static int _nfs41_proc_fsid_present(struct inode
*inode
, struct rpc_cred
*cred
)
6467 struct nfs_server
*server
= NFS_SERVER(inode
);
6468 struct rpc_clnt
*clnt
= server
->client
;
6469 struct nfs4_fsid_present_arg args
= {
6470 .fh
= NFS_FH(inode
),
6472 struct nfs4_fsid_present_res res
= {
6474 struct rpc_message msg
= {
6475 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_FSID_PRESENT
],
6482 res
.fh
= nfs_alloc_fhandle();
6486 nfs4_init_sequence(&args
.seq_args
, &res
.seq_res
, 0);
6487 nfs4_set_sequence_privileged(&args
.seq_args
);
6488 status
= nfs4_call_sync_sequence(clnt
, server
, &msg
,
6489 &args
.seq_args
, &res
.seq_res
);
6490 nfs_free_fhandle(res
.fh
);
6491 if (status
== NFS4_OK
&&
6492 res
.seq_res
.sr_status_flags
& SEQ4_STATUS_LEASE_MOVED
)
6493 status
= -NFS4ERR_LEASE_MOVED
;
6497 #endif /* CONFIG_NFS_V4_1 */
6500 * nfs4_proc_fsid_present - Is this FSID present or absent on server?
6501 * @inode: inode on FSID to check
6502 * @cred: credential to use for this operation
6504 * Server indicates whether the FSID is present, moved, or not
6505 * recognized. This operation is necessary to clear a LEASE_MOVED
6506 * condition for this client ID.
6508 * Returns NFS4_OK if the FSID is present on this server,
6509 * -NFS4ERR_MOVED if the FSID is no longer present, a negative
6510 * NFS4ERR code if some error occurred on the server, or a
6511 * negative errno if a local failure occurred.
6513 int nfs4_proc_fsid_present(struct inode
*inode
, struct rpc_cred
*cred
)
6515 struct nfs_server
*server
= NFS_SERVER(inode
);
6516 struct nfs_client
*clp
= server
->nfs_client
;
6517 const struct nfs4_mig_recovery_ops
*ops
=
6518 clp
->cl_mvops
->mig_recovery_ops
;
6519 struct nfs4_exception exception
= { };
6522 dprintk("%s: FSID %llx:%llx on \"%s\"\n", __func__
,
6523 (unsigned long long)server
->fsid
.major
,
6524 (unsigned long long)server
->fsid
.minor
,
6526 nfs_display_fhandle(NFS_FH(inode
), __func__
);
6529 status
= ops
->fsid_present(inode
, cred
);
6530 if (status
!= -NFS4ERR_DELAY
)
6532 nfs4_handle_exception(server
, status
, &exception
);
6533 } while (exception
.retry
);
6538 * If 'use_integrity' is true and the state managment nfs_client
6539 * cl_rpcclient is using krb5i/p, use the integrity protected cl_rpcclient
6540 * and the machine credential as per RFC3530bis and RFC5661 Security
6541 * Considerations sections. Otherwise, just use the user cred with the
6542 * filesystem's rpc_client.
6544 static int _nfs4_proc_secinfo(struct inode
*dir
, const struct qstr
*name
, struct nfs4_secinfo_flavors
*flavors
, bool use_integrity
)
6547 struct nfs4_secinfo_arg args
= {
6548 .dir_fh
= NFS_FH(dir
),
6551 struct nfs4_secinfo_res res
= {
6554 struct rpc_message msg
= {
6555 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_SECINFO
],
6559 struct rpc_clnt
*clnt
= NFS_SERVER(dir
)->client
;
6560 struct rpc_cred
*cred
= NULL
;
6562 if (use_integrity
) {
6563 clnt
= NFS_SERVER(dir
)->nfs_client
->cl_rpcclient
;
6564 cred
= nfs4_get_clid_cred(NFS_SERVER(dir
)->nfs_client
);
6565 msg
.rpc_cred
= cred
;
6568 dprintk("NFS call secinfo %s\n", name
->name
);
6570 nfs4_state_protect(NFS_SERVER(dir
)->nfs_client
,
6571 NFS_SP4_MACH_CRED_SECINFO
, &clnt
, &msg
);
6573 status
= nfs4_call_sync(clnt
, NFS_SERVER(dir
), &msg
, &args
.seq_args
,
6575 dprintk("NFS reply secinfo: %d\n", status
);
6583 int nfs4_proc_secinfo(struct inode
*dir
, const struct qstr
*name
,
6584 struct nfs4_secinfo_flavors
*flavors
)
6586 struct nfs4_exception exception
= { };
6589 err
= -NFS4ERR_WRONGSEC
;
6591 /* try to use integrity protection with machine cred */
6592 if (_nfs4_is_integrity_protected(NFS_SERVER(dir
)->nfs_client
))
6593 err
= _nfs4_proc_secinfo(dir
, name
, flavors
, true);
6596 * if unable to use integrity protection, or SECINFO with
6597 * integrity protection returns NFS4ERR_WRONGSEC (which is
6598 * disallowed by spec, but exists in deployed servers) use
6599 * the current filesystem's rpc_client and the user cred.
6601 if (err
== -NFS4ERR_WRONGSEC
)
6602 err
= _nfs4_proc_secinfo(dir
, name
, flavors
, false);
6604 trace_nfs4_secinfo(dir
, name
, err
);
6605 err
= nfs4_handle_exception(NFS_SERVER(dir
), err
,
6607 } while (exception
.retry
);
6611 #ifdef CONFIG_NFS_V4_1
6613 * Check the exchange flags returned by the server for invalid flags, having
6614 * both PNFS and NON_PNFS flags set, and not having one of NON_PNFS, PNFS, or
6617 static int nfs4_check_cl_exchange_flags(u32 flags
)
6619 if (flags
& ~EXCHGID4_FLAG_MASK_R
)
6621 if ((flags
& EXCHGID4_FLAG_USE_PNFS_MDS
) &&
6622 (flags
& EXCHGID4_FLAG_USE_NON_PNFS
))
6624 if (!(flags
& (EXCHGID4_FLAG_MASK_PNFS
)))
6628 return -NFS4ERR_INVAL
;
6632 nfs41_same_server_scope(struct nfs41_server_scope
*a
,
6633 struct nfs41_server_scope
*b
)
6635 if (a
->server_scope_sz
== b
->server_scope_sz
&&
6636 memcmp(a
->server_scope
, b
->server_scope
, a
->server_scope_sz
) == 0)
6643 * nfs4_proc_bind_conn_to_session()
6645 * The 4.1 client currently uses the same TCP connection for the
6646 * fore and backchannel.
6648 int nfs4_proc_bind_conn_to_session(struct nfs_client
*clp
, struct rpc_cred
*cred
)
6651 struct nfs41_bind_conn_to_session_res res
;
6652 struct rpc_message msg
= {
6654 &nfs4_procedures
[NFSPROC4_CLNT_BIND_CONN_TO_SESSION
],
6660 dprintk("--> %s\n", __func__
);
6662 res
.session
= kzalloc(sizeof(struct nfs4_session
), GFP_NOFS
);
6663 if (unlikely(res
.session
== NULL
)) {
6668 status
= rpc_call_sync(clp
->cl_rpcclient
, &msg
, RPC_TASK_TIMEOUT
);
6669 trace_nfs4_bind_conn_to_session(clp
, status
);
6671 if (memcmp(res
.session
->sess_id
.data
,
6672 clp
->cl_session
->sess_id
.data
, NFS4_MAX_SESSIONID_LEN
)) {
6673 dprintk("NFS: %s: Session ID mismatch\n", __func__
);
6677 if (res
.dir
!= NFS4_CDFS4_BOTH
) {
6678 dprintk("NFS: %s: Unexpected direction from server\n",
6683 if (res
.use_conn_in_rdma_mode
) {
6684 dprintk("NFS: %s: Server returned RDMA mode = true\n",
6693 dprintk("<-- %s status= %d\n", __func__
, status
);
6698 * Minimum set of SP4_MACH_CRED operations from RFC 5661 in the enforce map
6699 * and operations we'd like to see to enable certain features in the allow map
6701 static const struct nfs41_state_protection nfs4_sp4_mach_cred_request
= {
6702 .how
= SP4_MACH_CRED
,
6703 .enforce
.u
.words
= {
6704 [1] = 1 << (OP_BIND_CONN_TO_SESSION
- 32) |
6705 1 << (OP_EXCHANGE_ID
- 32) |
6706 1 << (OP_CREATE_SESSION
- 32) |
6707 1 << (OP_DESTROY_SESSION
- 32) |
6708 1 << (OP_DESTROY_CLIENTID
- 32)
6711 [0] = 1 << (OP_CLOSE
) |
6714 [1] = 1 << (OP_SECINFO
- 32) |
6715 1 << (OP_SECINFO_NO_NAME
- 32) |
6716 1 << (OP_TEST_STATEID
- 32) |
6717 1 << (OP_FREE_STATEID
- 32) |
6718 1 << (OP_WRITE
- 32)
6723 * Select the state protection mode for client `clp' given the server results
6724 * from exchange_id in `sp'.
6726 * Returns 0 on success, negative errno otherwise.
6728 static int nfs4_sp4_select_mode(struct nfs_client
*clp
,
6729 struct nfs41_state_protection
*sp
)
6731 static const u32 supported_enforce
[NFS4_OP_MAP_NUM_WORDS
] = {
6732 [1] = 1 << (OP_BIND_CONN_TO_SESSION
- 32) |
6733 1 << (OP_EXCHANGE_ID
- 32) |
6734 1 << (OP_CREATE_SESSION
- 32) |
6735 1 << (OP_DESTROY_SESSION
- 32) |
6736 1 << (OP_DESTROY_CLIENTID
- 32)
6740 if (sp
->how
== SP4_MACH_CRED
) {
6741 /* Print state protect result */
6742 dfprintk(MOUNT
, "Server SP4_MACH_CRED support:\n");
6743 for (i
= 0; i
<= LAST_NFS4_OP
; i
++) {
6744 if (test_bit(i
, sp
->enforce
.u
.longs
))
6745 dfprintk(MOUNT
, " enforce op %d\n", i
);
6746 if (test_bit(i
, sp
->allow
.u
.longs
))
6747 dfprintk(MOUNT
, " allow op %d\n", i
);
6750 /* make sure nothing is on enforce list that isn't supported */
6751 for (i
= 0; i
< NFS4_OP_MAP_NUM_WORDS
; i
++) {
6752 if (sp
->enforce
.u
.words
[i
] & ~supported_enforce
[i
]) {
6753 dfprintk(MOUNT
, "sp4_mach_cred: disabled\n");
6759 * Minimal mode - state operations are allowed to use machine
6760 * credential. Note this already happens by default, so the
6761 * client doesn't have to do anything more than the negotiation.
6763 * NOTE: we don't care if EXCHANGE_ID is in the list -
6764 * we're already using the machine cred for exchange_id
6765 * and will never use a different cred.
6767 if (test_bit(OP_BIND_CONN_TO_SESSION
, sp
->enforce
.u
.longs
) &&
6768 test_bit(OP_CREATE_SESSION
, sp
->enforce
.u
.longs
) &&
6769 test_bit(OP_DESTROY_SESSION
, sp
->enforce
.u
.longs
) &&
6770 test_bit(OP_DESTROY_CLIENTID
, sp
->enforce
.u
.longs
)) {
6771 dfprintk(MOUNT
, "sp4_mach_cred:\n");
6772 dfprintk(MOUNT
, " minimal mode enabled\n");
6773 set_bit(NFS_SP4_MACH_CRED_MINIMAL
, &clp
->cl_sp4_flags
);
6775 dfprintk(MOUNT
, "sp4_mach_cred: disabled\n");
6779 if (test_bit(OP_CLOSE
, sp
->allow
.u
.longs
) &&
6780 test_bit(OP_LOCKU
, sp
->allow
.u
.longs
)) {
6781 dfprintk(MOUNT
, " cleanup mode enabled\n");
6782 set_bit(NFS_SP4_MACH_CRED_CLEANUP
, &clp
->cl_sp4_flags
);
6785 if (test_bit(OP_SECINFO
, sp
->allow
.u
.longs
) &&
6786 test_bit(OP_SECINFO_NO_NAME
, sp
->allow
.u
.longs
)) {
6787 dfprintk(MOUNT
, " secinfo mode enabled\n");
6788 set_bit(NFS_SP4_MACH_CRED_SECINFO
, &clp
->cl_sp4_flags
);
6791 if (test_bit(OP_TEST_STATEID
, sp
->allow
.u
.longs
) &&
6792 test_bit(OP_FREE_STATEID
, sp
->allow
.u
.longs
)) {
6793 dfprintk(MOUNT
, " stateid mode enabled\n");
6794 set_bit(NFS_SP4_MACH_CRED_STATEID
, &clp
->cl_sp4_flags
);
6797 if (test_bit(OP_WRITE
, sp
->allow
.u
.longs
)) {
6798 dfprintk(MOUNT
, " write mode enabled\n");
6799 set_bit(NFS_SP4_MACH_CRED_WRITE
, &clp
->cl_sp4_flags
);
6802 if (test_bit(OP_COMMIT
, sp
->allow
.u
.longs
)) {
6803 dfprintk(MOUNT
, " commit mode enabled\n");
6804 set_bit(NFS_SP4_MACH_CRED_COMMIT
, &clp
->cl_sp4_flags
);
6812 * _nfs4_proc_exchange_id()
6814 * Wrapper for EXCHANGE_ID operation.
6816 static int _nfs4_proc_exchange_id(struct nfs_client
*clp
, struct rpc_cred
*cred
,
6819 nfs4_verifier verifier
;
6820 struct nfs41_exchange_id_args args
= {
6821 .verifier
= &verifier
,
6823 #ifdef CONFIG_NFS_V4_1_MIGRATION
6824 .flags
= EXCHGID4_FLAG_SUPP_MOVED_REFER
|
6825 EXCHGID4_FLAG_BIND_PRINC_STATEID
|
6826 EXCHGID4_FLAG_SUPP_MOVED_MIGR
,
6828 .flags
= EXCHGID4_FLAG_SUPP_MOVED_REFER
|
6829 EXCHGID4_FLAG_BIND_PRINC_STATEID
,
6832 struct nfs41_exchange_id_res res
= {
6836 struct rpc_message msg
= {
6837 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_EXCHANGE_ID
],
6843 nfs4_init_boot_verifier(clp
, &verifier
);
6844 args
.id_len
= nfs4_init_uniform_client_string(clp
, args
.id
,
6846 dprintk("NFS call exchange_id auth=%s, '%.*s'\n",
6847 clp
->cl_rpcclient
->cl_auth
->au_ops
->au_name
,
6848 args
.id_len
, args
.id
);
6850 res
.server_owner
= kzalloc(sizeof(struct nfs41_server_owner
),
6852 if (unlikely(res
.server_owner
== NULL
)) {
6857 res
.server_scope
= kzalloc(sizeof(struct nfs41_server_scope
),
6859 if (unlikely(res
.server_scope
== NULL
)) {
6861 goto out_server_owner
;
6864 res
.impl_id
= kzalloc(sizeof(struct nfs41_impl_id
), GFP_NOFS
);
6865 if (unlikely(res
.impl_id
== NULL
)) {
6867 goto out_server_scope
;
6872 args
.state_protect
.how
= SP4_NONE
;
6876 args
.state_protect
= nfs4_sp4_mach_cred_request
;
6883 goto out_server_scope
;
6886 status
= rpc_call_sync(clp
->cl_rpcclient
, &msg
, RPC_TASK_TIMEOUT
);
6887 trace_nfs4_exchange_id(clp
, status
);
6889 status
= nfs4_check_cl_exchange_flags(res
.flags
);
6892 status
= nfs4_sp4_select_mode(clp
, &res
.state_protect
);
6895 clp
->cl_clientid
= res
.clientid
;
6896 clp
->cl_exchange_flags
= (res
.flags
& ~EXCHGID4_FLAG_CONFIRMED_R
);
6897 if (!(res
.flags
& EXCHGID4_FLAG_CONFIRMED_R
))
6898 clp
->cl_seqid
= res
.seqid
;
6900 kfree(clp
->cl_serverowner
);
6901 clp
->cl_serverowner
= res
.server_owner
;
6902 res
.server_owner
= NULL
;
6904 /* use the most recent implementation id */
6905 kfree(clp
->cl_implid
);
6906 clp
->cl_implid
= res
.impl_id
;
6908 if (clp
->cl_serverscope
!= NULL
&&
6909 !nfs41_same_server_scope(clp
->cl_serverscope
,
6910 res
.server_scope
)) {
6911 dprintk("%s: server_scope mismatch detected\n",
6913 set_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH
, &clp
->cl_state
);
6914 kfree(clp
->cl_serverscope
);
6915 clp
->cl_serverscope
= NULL
;
6918 if (clp
->cl_serverscope
== NULL
) {
6919 clp
->cl_serverscope
= res
.server_scope
;
6926 kfree(res
.server_owner
);
6928 kfree(res
.server_scope
);
6930 if (clp
->cl_implid
!= NULL
)
6931 dprintk("NFS reply exchange_id: Server Implementation ID: "
6932 "domain: %s, name: %s, date: %llu,%u\n",
6933 clp
->cl_implid
->domain
, clp
->cl_implid
->name
,
6934 clp
->cl_implid
->date
.seconds
,
6935 clp
->cl_implid
->date
.nseconds
);
6936 dprintk("NFS reply exchange_id: %d\n", status
);
6941 * nfs4_proc_exchange_id()
6943 * Returns zero, a negative errno, or a negative NFS4ERR status code.
6945 * Since the clientid has expired, all compounds using sessions
6946 * associated with the stale clientid will be returning
6947 * NFS4ERR_BADSESSION in the sequence operation, and will therefore
6948 * be in some phase of session reset.
6950 * Will attempt to negotiate SP4_MACH_CRED if krb5i / krb5p auth is used.
6952 int nfs4_proc_exchange_id(struct nfs_client
*clp
, struct rpc_cred
*cred
)
6954 rpc_authflavor_t authflavor
= clp
->cl_rpcclient
->cl_auth
->au_flavor
;
6957 /* try SP4_MACH_CRED if krb5i/p */
6958 if (authflavor
== RPC_AUTH_GSS_KRB5I
||
6959 authflavor
== RPC_AUTH_GSS_KRB5P
) {
6960 status
= _nfs4_proc_exchange_id(clp
, cred
, SP4_MACH_CRED
);
6966 return _nfs4_proc_exchange_id(clp
, cred
, SP4_NONE
);
6969 static int _nfs4_proc_destroy_clientid(struct nfs_client
*clp
,
6970 struct rpc_cred
*cred
)
6972 struct rpc_message msg
= {
6973 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_DESTROY_CLIENTID
],
6979 status
= rpc_call_sync(clp
->cl_rpcclient
, &msg
, RPC_TASK_TIMEOUT
);
6980 trace_nfs4_destroy_clientid(clp
, status
);
6982 dprintk("NFS: Got error %d from the server %s on "
6983 "DESTROY_CLIENTID.", status
, clp
->cl_hostname
);
6987 static int nfs4_proc_destroy_clientid(struct nfs_client
*clp
,
6988 struct rpc_cred
*cred
)
6993 for (loop
= NFS4_MAX_LOOP_ON_RECOVER
; loop
!= 0; loop
--) {
6994 ret
= _nfs4_proc_destroy_clientid(clp
, cred
);
6996 case -NFS4ERR_DELAY
:
6997 case -NFS4ERR_CLIENTID_BUSY
:
7007 int nfs4_destroy_clientid(struct nfs_client
*clp
)
7009 struct rpc_cred
*cred
;
7012 if (clp
->cl_mvops
->minor_version
< 1)
7014 if (clp
->cl_exchange_flags
== 0)
7016 if (clp
->cl_preserve_clid
)
7018 cred
= nfs4_get_clid_cred(clp
);
7019 ret
= nfs4_proc_destroy_clientid(clp
, cred
);
7024 case -NFS4ERR_STALE_CLIENTID
:
7025 clp
->cl_exchange_flags
= 0;
7031 struct nfs4_get_lease_time_data
{
7032 struct nfs4_get_lease_time_args
*args
;
7033 struct nfs4_get_lease_time_res
*res
;
7034 struct nfs_client
*clp
;
7037 static void nfs4_get_lease_time_prepare(struct rpc_task
*task
,
7040 struct nfs4_get_lease_time_data
*data
=
7041 (struct nfs4_get_lease_time_data
*)calldata
;
7043 dprintk("--> %s\n", __func__
);
7044 /* just setup sequence, do not trigger session recovery
7045 since we're invoked within one */
7046 nfs41_setup_sequence(data
->clp
->cl_session
,
7047 &data
->args
->la_seq_args
,
7048 &data
->res
->lr_seq_res
,
7050 dprintk("<-- %s\n", __func__
);
7054 * Called from nfs4_state_manager thread for session setup, so don't recover
7055 * from sequence operation or clientid errors.
7057 static void nfs4_get_lease_time_done(struct rpc_task
*task
, void *calldata
)
7059 struct nfs4_get_lease_time_data
*data
=
7060 (struct nfs4_get_lease_time_data
*)calldata
;
7062 dprintk("--> %s\n", __func__
);
7063 if (!nfs41_sequence_done(task
, &data
->res
->lr_seq_res
))
7065 switch (task
->tk_status
) {
7066 case -NFS4ERR_DELAY
:
7067 case -NFS4ERR_GRACE
:
7068 dprintk("%s Retry: tk_status %d\n", __func__
, task
->tk_status
);
7069 rpc_delay(task
, NFS4_POLL_RETRY_MIN
);
7070 task
->tk_status
= 0;
7072 case -NFS4ERR_RETRY_UNCACHED_REP
:
7073 rpc_restart_call_prepare(task
);
7076 dprintk("<-- %s\n", __func__
);
7079 static const struct rpc_call_ops nfs4_get_lease_time_ops
= {
7080 .rpc_call_prepare
= nfs4_get_lease_time_prepare
,
7081 .rpc_call_done
= nfs4_get_lease_time_done
,
7084 int nfs4_proc_get_lease_time(struct nfs_client
*clp
, struct nfs_fsinfo
*fsinfo
)
7086 struct rpc_task
*task
;
7087 struct nfs4_get_lease_time_args args
;
7088 struct nfs4_get_lease_time_res res
= {
7089 .lr_fsinfo
= fsinfo
,
7091 struct nfs4_get_lease_time_data data
= {
7096 struct rpc_message msg
= {
7097 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_GET_LEASE_TIME
],
7101 struct rpc_task_setup task_setup
= {
7102 .rpc_client
= clp
->cl_rpcclient
,
7103 .rpc_message
= &msg
,
7104 .callback_ops
= &nfs4_get_lease_time_ops
,
7105 .callback_data
= &data
,
7106 .flags
= RPC_TASK_TIMEOUT
,
7110 nfs4_init_sequence(&args
.la_seq_args
, &res
.lr_seq_res
, 0);
7111 nfs4_set_sequence_privileged(&args
.la_seq_args
);
7112 dprintk("--> %s\n", __func__
);
7113 task
= rpc_run_task(&task_setup
);
7116 status
= PTR_ERR(task
);
7118 status
= task
->tk_status
;
7121 dprintk("<-- %s return %d\n", __func__
, status
);
7127 * Initialize the values to be used by the client in CREATE_SESSION
7128 * If nfs4_init_session set the fore channel request and response sizes,
7131 * Set the back channel max_resp_sz_cached to zero to force the client to
7132 * always set csa_cachethis to FALSE because the current implementation
7133 * of the back channel DRC only supports caching the CB_SEQUENCE operation.
7135 static void nfs4_init_channel_attrs(struct nfs41_create_session_args
*args
)
7137 unsigned int max_rqst_sz
, max_resp_sz
;
7139 max_rqst_sz
= NFS_MAX_FILE_IO_SIZE
+ nfs41_maxwrite_overhead
;
7140 max_resp_sz
= NFS_MAX_FILE_IO_SIZE
+ nfs41_maxread_overhead
;
7142 /* Fore channel attributes */
7143 args
->fc_attrs
.max_rqst_sz
= max_rqst_sz
;
7144 args
->fc_attrs
.max_resp_sz
= max_resp_sz
;
7145 args
->fc_attrs
.max_ops
= NFS4_MAX_OPS
;
7146 args
->fc_attrs
.max_reqs
= max_session_slots
;
7148 dprintk("%s: Fore Channel : max_rqst_sz=%u max_resp_sz=%u "
7149 "max_ops=%u max_reqs=%u\n",
7151 args
->fc_attrs
.max_rqst_sz
, args
->fc_attrs
.max_resp_sz
,
7152 args
->fc_attrs
.max_ops
, args
->fc_attrs
.max_reqs
);
7154 /* Back channel attributes */
7155 args
->bc_attrs
.max_rqst_sz
= PAGE_SIZE
;
7156 args
->bc_attrs
.max_resp_sz
= PAGE_SIZE
;
7157 args
->bc_attrs
.max_resp_sz_cached
= 0;
7158 args
->bc_attrs
.max_ops
= NFS4_MAX_BACK_CHANNEL_OPS
;
7159 args
->bc_attrs
.max_reqs
= 1;
7161 dprintk("%s: Back Channel : max_rqst_sz=%u max_resp_sz=%u "
7162 "max_resp_sz_cached=%u max_ops=%u max_reqs=%u\n",
7164 args
->bc_attrs
.max_rqst_sz
, args
->bc_attrs
.max_resp_sz
,
7165 args
->bc_attrs
.max_resp_sz_cached
, args
->bc_attrs
.max_ops
,
7166 args
->bc_attrs
.max_reqs
);
7169 static int nfs4_verify_fore_channel_attrs(struct nfs41_create_session_args
*args
, struct nfs4_session
*session
)
7171 struct nfs4_channel_attrs
*sent
= &args
->fc_attrs
;
7172 struct nfs4_channel_attrs
*rcvd
= &session
->fc_attrs
;
7174 if (rcvd
->max_resp_sz
> sent
->max_resp_sz
)
7177 * Our requested max_ops is the minimum we need; we're not
7178 * prepared to break up compounds into smaller pieces than that.
7179 * So, no point even trying to continue if the server won't
7182 if (rcvd
->max_ops
< sent
->max_ops
)
7184 if (rcvd
->max_reqs
== 0)
7186 if (rcvd
->max_reqs
> NFS4_MAX_SLOT_TABLE
)
7187 rcvd
->max_reqs
= NFS4_MAX_SLOT_TABLE
;
7191 static int nfs4_verify_back_channel_attrs(struct nfs41_create_session_args
*args
, struct nfs4_session
*session
)
7193 struct nfs4_channel_attrs
*sent
= &args
->bc_attrs
;
7194 struct nfs4_channel_attrs
*rcvd
= &session
->bc_attrs
;
7196 if (rcvd
->max_rqst_sz
> sent
->max_rqst_sz
)
7198 if (rcvd
->max_resp_sz
< sent
->max_resp_sz
)
7200 if (rcvd
->max_resp_sz_cached
> sent
->max_resp_sz_cached
)
7202 /* These would render the backchannel useless: */
7203 if (rcvd
->max_ops
!= sent
->max_ops
)
7205 if (rcvd
->max_reqs
!= sent
->max_reqs
)
7210 static int nfs4_verify_channel_attrs(struct nfs41_create_session_args
*args
,
7211 struct nfs4_session
*session
)
7215 ret
= nfs4_verify_fore_channel_attrs(args
, session
);
7218 return nfs4_verify_back_channel_attrs(args
, session
);
7221 static int _nfs4_proc_create_session(struct nfs_client
*clp
,
7222 struct rpc_cred
*cred
)
7224 struct nfs4_session
*session
= clp
->cl_session
;
7225 struct nfs41_create_session_args args
= {
7227 .cb_program
= NFS4_CALLBACK
,
7229 struct nfs41_create_session_res res
= {
7232 struct rpc_message msg
= {
7233 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_CREATE_SESSION
],
7240 nfs4_init_channel_attrs(&args
);
7241 args
.flags
= (SESSION4_PERSIST
| SESSION4_BACK_CHAN
);
7243 status
= rpc_call_sync(session
->clp
->cl_rpcclient
, &msg
, RPC_TASK_TIMEOUT
);
7244 trace_nfs4_create_session(clp
, status
);
7247 /* Verify the session's negotiated channel_attrs values */
7248 status
= nfs4_verify_channel_attrs(&args
, session
);
7249 /* Increment the clientid slot sequence id */
7257 * Issues a CREATE_SESSION operation to the server.
7258 * It is the responsibility of the caller to verify the session is
7259 * expired before calling this routine.
7261 int nfs4_proc_create_session(struct nfs_client
*clp
, struct rpc_cred
*cred
)
7265 struct nfs4_session
*session
= clp
->cl_session
;
7267 dprintk("--> %s clp=%p session=%p\n", __func__
, clp
, session
);
7269 status
= _nfs4_proc_create_session(clp
, cred
);
7273 /* Init or reset the session slot tables */
7274 status
= nfs4_setup_session_slot_tables(session
);
7275 dprintk("slot table setup returned %d\n", status
);
7279 ptr
= (unsigned *)&session
->sess_id
.data
[0];
7280 dprintk("%s client>seqid %d sessionid %u:%u:%u:%u\n", __func__
,
7281 clp
->cl_seqid
, ptr
[0], ptr
[1], ptr
[2], ptr
[3]);
7283 dprintk("<-- %s\n", __func__
);
7288 * Issue the over-the-wire RPC DESTROY_SESSION.
7289 * The caller must serialize access to this routine.
7291 int nfs4_proc_destroy_session(struct nfs4_session
*session
,
7292 struct rpc_cred
*cred
)
7294 struct rpc_message msg
= {
7295 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_DESTROY_SESSION
],
7296 .rpc_argp
= session
,
7301 dprintk("--> nfs4_proc_destroy_session\n");
7303 /* session is still being setup */
7304 if (session
->clp
->cl_cons_state
!= NFS_CS_READY
)
7307 status
= rpc_call_sync(session
->clp
->cl_rpcclient
, &msg
, RPC_TASK_TIMEOUT
);
7308 trace_nfs4_destroy_session(session
->clp
, status
);
7311 dprintk("NFS: Got error %d from the server on DESTROY_SESSION. "
7312 "Session has been destroyed regardless...\n", status
);
7314 dprintk("<-- nfs4_proc_destroy_session\n");
7319 * Renew the cl_session lease.
7321 struct nfs4_sequence_data
{
7322 struct nfs_client
*clp
;
7323 struct nfs4_sequence_args args
;
7324 struct nfs4_sequence_res res
;
7327 static void nfs41_sequence_release(void *data
)
7329 struct nfs4_sequence_data
*calldata
= data
;
7330 struct nfs_client
*clp
= calldata
->clp
;
7332 if (atomic_read(&clp
->cl_count
) > 1)
7333 nfs4_schedule_state_renewal(clp
);
7334 nfs_put_client(clp
);
7338 static int nfs41_sequence_handle_errors(struct rpc_task
*task
, struct nfs_client
*clp
)
7340 switch(task
->tk_status
) {
7341 case -NFS4ERR_DELAY
:
7342 rpc_delay(task
, NFS4_POLL_RETRY_MAX
);
7345 nfs4_schedule_lease_recovery(clp
);
7350 static void nfs41_sequence_call_done(struct rpc_task
*task
, void *data
)
7352 struct nfs4_sequence_data
*calldata
= data
;
7353 struct nfs_client
*clp
= calldata
->clp
;
7355 if (!nfs41_sequence_done(task
, task
->tk_msg
.rpc_resp
))
7358 trace_nfs4_sequence(clp
, task
->tk_status
);
7359 if (task
->tk_status
< 0) {
7360 dprintk("%s ERROR %d\n", __func__
, task
->tk_status
);
7361 if (atomic_read(&clp
->cl_count
) == 1)
7364 if (nfs41_sequence_handle_errors(task
, clp
) == -EAGAIN
) {
7365 rpc_restart_call_prepare(task
);
7369 dprintk("%s rpc_cred %p\n", __func__
, task
->tk_msg
.rpc_cred
);
7371 dprintk("<-- %s\n", __func__
);
7374 static void nfs41_sequence_prepare(struct rpc_task
*task
, void *data
)
7376 struct nfs4_sequence_data
*calldata
= data
;
7377 struct nfs_client
*clp
= calldata
->clp
;
7378 struct nfs4_sequence_args
*args
;
7379 struct nfs4_sequence_res
*res
;
7381 args
= task
->tk_msg
.rpc_argp
;
7382 res
= task
->tk_msg
.rpc_resp
;
7384 nfs41_setup_sequence(clp
->cl_session
, args
, res
, task
);
7387 static const struct rpc_call_ops nfs41_sequence_ops
= {
7388 .rpc_call_done
= nfs41_sequence_call_done
,
7389 .rpc_call_prepare
= nfs41_sequence_prepare
,
7390 .rpc_release
= nfs41_sequence_release
,
7393 static struct rpc_task
*_nfs41_proc_sequence(struct nfs_client
*clp
,
7394 struct rpc_cred
*cred
,
7397 struct nfs4_sequence_data
*calldata
;
7398 struct rpc_message msg
= {
7399 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_SEQUENCE
],
7402 struct rpc_task_setup task_setup_data
= {
7403 .rpc_client
= clp
->cl_rpcclient
,
7404 .rpc_message
= &msg
,
7405 .callback_ops
= &nfs41_sequence_ops
,
7406 .flags
= RPC_TASK_ASYNC
| RPC_TASK_TIMEOUT
,
7409 if (!atomic_inc_not_zero(&clp
->cl_count
))
7410 return ERR_PTR(-EIO
);
7411 calldata
= kzalloc(sizeof(*calldata
), GFP_NOFS
);
7412 if (calldata
== NULL
) {
7413 nfs_put_client(clp
);
7414 return ERR_PTR(-ENOMEM
);
7416 nfs4_init_sequence(&calldata
->args
, &calldata
->res
, 0);
7418 nfs4_set_sequence_privileged(&calldata
->args
);
7419 msg
.rpc_argp
= &calldata
->args
;
7420 msg
.rpc_resp
= &calldata
->res
;
7421 calldata
->clp
= clp
;
7422 task_setup_data
.callback_data
= calldata
;
7424 return rpc_run_task(&task_setup_data
);
7427 static int nfs41_proc_async_sequence(struct nfs_client
*clp
, struct rpc_cred
*cred
, unsigned renew_flags
)
7429 struct rpc_task
*task
;
7432 if ((renew_flags
& NFS4_RENEW_TIMEOUT
) == 0)
7434 task
= _nfs41_proc_sequence(clp
, cred
, false);
7436 ret
= PTR_ERR(task
);
7438 rpc_put_task_async(task
);
7439 dprintk("<-- %s status=%d\n", __func__
, ret
);
7443 static int nfs4_proc_sequence(struct nfs_client
*clp
, struct rpc_cred
*cred
)
7445 struct rpc_task
*task
;
7448 task
= _nfs41_proc_sequence(clp
, cred
, true);
7450 ret
= PTR_ERR(task
);
7453 ret
= rpc_wait_for_completion_task(task
);
7455 struct nfs4_sequence_res
*res
= task
->tk_msg
.rpc_resp
;
7457 if (task
->tk_status
== 0)
7458 nfs41_handle_sequence_flag_errors(clp
, res
->sr_status_flags
);
7459 ret
= task
->tk_status
;
7463 dprintk("<-- %s status=%d\n", __func__
, ret
);
7467 struct nfs4_reclaim_complete_data
{
7468 struct nfs_client
*clp
;
7469 struct nfs41_reclaim_complete_args arg
;
7470 struct nfs41_reclaim_complete_res res
;
7473 static void nfs4_reclaim_complete_prepare(struct rpc_task
*task
, void *data
)
7475 struct nfs4_reclaim_complete_data
*calldata
= data
;
7477 nfs41_setup_sequence(calldata
->clp
->cl_session
,
7478 &calldata
->arg
.seq_args
,
7479 &calldata
->res
.seq_res
,
7483 static int nfs41_reclaim_complete_handle_errors(struct rpc_task
*task
, struct nfs_client
*clp
)
7485 switch(task
->tk_status
) {
7487 case -NFS4ERR_COMPLETE_ALREADY
:
7488 case -NFS4ERR_WRONG_CRED
: /* What to do here? */
7490 case -NFS4ERR_DELAY
:
7491 rpc_delay(task
, NFS4_POLL_RETRY_MAX
);
7493 case -NFS4ERR_RETRY_UNCACHED_REP
:
7496 nfs4_schedule_lease_recovery(clp
);
7501 static void nfs4_reclaim_complete_done(struct rpc_task
*task
, void *data
)
7503 struct nfs4_reclaim_complete_data
*calldata
= data
;
7504 struct nfs_client
*clp
= calldata
->clp
;
7505 struct nfs4_sequence_res
*res
= &calldata
->res
.seq_res
;
7507 dprintk("--> %s\n", __func__
);
7508 if (!nfs41_sequence_done(task
, res
))
7511 trace_nfs4_reclaim_complete(clp
, task
->tk_status
);
7512 if (nfs41_reclaim_complete_handle_errors(task
, clp
) == -EAGAIN
) {
7513 rpc_restart_call_prepare(task
);
7516 dprintk("<-- %s\n", __func__
);
7519 static void nfs4_free_reclaim_complete_data(void *data
)
7521 struct nfs4_reclaim_complete_data
*calldata
= data
;
7526 static const struct rpc_call_ops nfs4_reclaim_complete_call_ops
= {
7527 .rpc_call_prepare
= nfs4_reclaim_complete_prepare
,
7528 .rpc_call_done
= nfs4_reclaim_complete_done
,
7529 .rpc_release
= nfs4_free_reclaim_complete_data
,
7533 * Issue a global reclaim complete.
7535 static int nfs41_proc_reclaim_complete(struct nfs_client
*clp
,
7536 struct rpc_cred
*cred
)
7538 struct nfs4_reclaim_complete_data
*calldata
;
7539 struct rpc_task
*task
;
7540 struct rpc_message msg
= {
7541 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_RECLAIM_COMPLETE
],
7544 struct rpc_task_setup task_setup_data
= {
7545 .rpc_client
= clp
->cl_rpcclient
,
7546 .rpc_message
= &msg
,
7547 .callback_ops
= &nfs4_reclaim_complete_call_ops
,
7548 .flags
= RPC_TASK_ASYNC
,
7550 int status
= -ENOMEM
;
7552 dprintk("--> %s\n", __func__
);
7553 calldata
= kzalloc(sizeof(*calldata
), GFP_NOFS
);
7554 if (calldata
== NULL
)
7556 calldata
->clp
= clp
;
7557 calldata
->arg
.one_fs
= 0;
7559 nfs4_init_sequence(&calldata
->arg
.seq_args
, &calldata
->res
.seq_res
, 0);
7560 nfs4_set_sequence_privileged(&calldata
->arg
.seq_args
);
7561 msg
.rpc_argp
= &calldata
->arg
;
7562 msg
.rpc_resp
= &calldata
->res
;
7563 task_setup_data
.callback_data
= calldata
;
7564 task
= rpc_run_task(&task_setup_data
);
7566 status
= PTR_ERR(task
);
7569 status
= nfs4_wait_for_completion_rpc_task(task
);
7571 status
= task
->tk_status
;
7575 dprintk("<-- %s status=%d\n", __func__
, status
);
7580 nfs4_layoutget_prepare(struct rpc_task
*task
, void *calldata
)
7582 struct nfs4_layoutget
*lgp
= calldata
;
7583 struct nfs_server
*server
= NFS_SERVER(lgp
->args
.inode
);
7584 struct nfs4_session
*session
= nfs4_get_session(server
);
7586 dprintk("--> %s\n", __func__
);
7587 /* Note the is a race here, where a CB_LAYOUTRECALL can come in
7588 * right now covering the LAYOUTGET we are about to send.
7589 * However, that is not so catastrophic, and there seems
7590 * to be no way to prevent it completely.
7592 if (nfs41_setup_sequence(session
, &lgp
->args
.seq_args
,
7593 &lgp
->res
.seq_res
, task
))
7595 if (pnfs_choose_layoutget_stateid(&lgp
->args
.stateid
,
7596 NFS_I(lgp
->args
.inode
)->layout
,
7598 lgp
->args
.ctx
->state
)) {
7599 rpc_exit(task
, NFS4_OK
);
7603 static void nfs4_layoutget_done(struct rpc_task
*task
, void *calldata
)
7605 struct nfs4_layoutget
*lgp
= calldata
;
7606 struct inode
*inode
= lgp
->args
.inode
;
7607 struct nfs_server
*server
= NFS_SERVER(inode
);
7608 struct pnfs_layout_hdr
*lo
;
7609 struct nfs4_state
*state
= NULL
;
7610 unsigned long timeo
, now
, giveup
;
7612 dprintk("--> %s tk_status => %d\n", __func__
, -task
->tk_status
);
7614 if (!nfs41_sequence_done(task
, &lgp
->res
.seq_res
))
7617 switch (task
->tk_status
) {
7621 * NFS4ERR_LAYOUTTRYLATER is a conflict with another client
7622 * (or clients) writing to the same RAID stripe
7624 case -NFS4ERR_LAYOUTTRYLATER
:
7626 * NFS4ERR_RECALLCONFLICT is when conflict with self (must recall
7627 * existing layout before getting a new one).
7629 case -NFS4ERR_RECALLCONFLICT
:
7630 timeo
= rpc_get_timeout(task
->tk_client
);
7631 giveup
= lgp
->args
.timestamp
+ timeo
;
7633 if (time_after(giveup
, now
)) {
7634 unsigned long delay
;
7637 * - Not less then NFS4_POLL_RETRY_MIN.
7638 * - One last time a jiffie before we give up
7639 * - exponential backoff (time_now minus start_attempt)
7641 delay
= max_t(unsigned long, NFS4_POLL_RETRY_MIN
,
7642 min((giveup
- now
- 1),
7643 now
- lgp
->args
.timestamp
));
7645 dprintk("%s: NFS4ERR_RECALLCONFLICT waiting %lu\n",
7647 rpc_delay(task
, delay
);
7648 task
->tk_status
= 0;
7649 rpc_restart_call_prepare(task
);
7650 goto out
; /* Do not call nfs4_async_handle_error() */
7653 case -NFS4ERR_EXPIRED
:
7654 case -NFS4ERR_BAD_STATEID
:
7655 spin_lock(&inode
->i_lock
);
7656 lo
= NFS_I(inode
)->layout
;
7657 if (!lo
|| list_empty(&lo
->plh_segs
)) {
7658 spin_unlock(&inode
->i_lock
);
7659 /* If the open stateid was bad, then recover it. */
7660 state
= lgp
->args
.ctx
->state
;
7665 * Mark the bad layout state as invalid, then retry
7666 * with the current stateid.
7668 pnfs_mark_matching_lsegs_invalid(lo
, &head
, NULL
);
7669 spin_unlock(&inode
->i_lock
);
7670 pnfs_free_lseg_list(&head
);
7672 task
->tk_status
= 0;
7673 rpc_restart_call_prepare(task
);
7676 if (nfs4_async_handle_error(task
, server
, state
, NULL
) == -EAGAIN
)
7677 rpc_restart_call_prepare(task
);
7679 dprintk("<-- %s\n", __func__
);
7682 static size_t max_response_pages(struct nfs_server
*server
)
7684 u32 max_resp_sz
= server
->nfs_client
->cl_session
->fc_attrs
.max_resp_sz
;
7685 return nfs_page_array_len(0, max_resp_sz
);
7688 static void nfs4_free_pages(struct page
**pages
, size_t size
)
7695 for (i
= 0; i
< size
; i
++) {
7698 __free_page(pages
[i
]);
7703 static struct page
**nfs4_alloc_pages(size_t size
, gfp_t gfp_flags
)
7705 struct page
**pages
;
7708 pages
= kcalloc(size
, sizeof(struct page
*), gfp_flags
);
7710 dprintk("%s: can't alloc array of %zu pages\n", __func__
, size
);
7714 for (i
= 0; i
< size
; i
++) {
7715 pages
[i
] = alloc_page(gfp_flags
);
7717 dprintk("%s: failed to allocate page\n", __func__
);
7718 nfs4_free_pages(pages
, size
);
7726 static void nfs4_layoutget_release(void *calldata
)
7728 struct nfs4_layoutget
*lgp
= calldata
;
7729 struct inode
*inode
= lgp
->args
.inode
;
7730 struct nfs_server
*server
= NFS_SERVER(inode
);
7731 size_t max_pages
= max_response_pages(server
);
7733 dprintk("--> %s\n", __func__
);
7734 nfs4_free_pages(lgp
->args
.layout
.pages
, max_pages
);
7735 pnfs_put_layout_hdr(NFS_I(inode
)->layout
);
7736 put_nfs_open_context(lgp
->args
.ctx
);
7738 dprintk("<-- %s\n", __func__
);
7741 static const struct rpc_call_ops nfs4_layoutget_call_ops
= {
7742 .rpc_call_prepare
= nfs4_layoutget_prepare
,
7743 .rpc_call_done
= nfs4_layoutget_done
,
7744 .rpc_release
= nfs4_layoutget_release
,
7747 struct pnfs_layout_segment
*
7748 nfs4_proc_layoutget(struct nfs4_layoutget
*lgp
, gfp_t gfp_flags
)
7750 struct inode
*inode
= lgp
->args
.inode
;
7751 struct nfs_server
*server
= NFS_SERVER(inode
);
7752 size_t max_pages
= max_response_pages(server
);
7753 struct rpc_task
*task
;
7754 struct rpc_message msg
= {
7755 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_LAYOUTGET
],
7756 .rpc_argp
= &lgp
->args
,
7757 .rpc_resp
= &lgp
->res
,
7758 .rpc_cred
= lgp
->cred
,
7760 struct rpc_task_setup task_setup_data
= {
7761 .rpc_client
= server
->client
,
7762 .rpc_message
= &msg
,
7763 .callback_ops
= &nfs4_layoutget_call_ops
,
7764 .callback_data
= lgp
,
7765 .flags
= RPC_TASK_ASYNC
,
7767 struct pnfs_layout_segment
*lseg
= NULL
;
7770 dprintk("--> %s\n", __func__
);
7772 /* nfs4_layoutget_release calls pnfs_put_layout_hdr */
7773 pnfs_get_layout_hdr(NFS_I(inode
)->layout
);
7775 lgp
->args
.layout
.pages
= nfs4_alloc_pages(max_pages
, gfp_flags
);
7776 if (!lgp
->args
.layout
.pages
) {
7777 nfs4_layoutget_release(lgp
);
7778 return ERR_PTR(-ENOMEM
);
7780 lgp
->args
.layout
.pglen
= max_pages
* PAGE_SIZE
;
7781 lgp
->args
.timestamp
= jiffies
;
7783 lgp
->res
.layoutp
= &lgp
->args
.layout
;
7784 lgp
->res
.seq_res
.sr_slot
= NULL
;
7785 nfs4_init_sequence(&lgp
->args
.seq_args
, &lgp
->res
.seq_res
, 0);
7787 task
= rpc_run_task(&task_setup_data
);
7789 return ERR_CAST(task
);
7790 status
= nfs4_wait_for_completion_rpc_task(task
);
7792 status
= task
->tk_status
;
7793 trace_nfs4_layoutget(lgp
->args
.ctx
,
7797 /* if layoutp->len is 0, nfs4_layoutget_prepare called rpc_exit */
7798 if (status
== 0 && lgp
->res
.layoutp
->len
)
7799 lseg
= pnfs_layout_process(lgp
);
7801 dprintk("<-- %s status=%d\n", __func__
, status
);
7803 return ERR_PTR(status
);
7808 nfs4_layoutreturn_prepare(struct rpc_task
*task
, void *calldata
)
7810 struct nfs4_layoutreturn
*lrp
= calldata
;
7812 dprintk("--> %s\n", __func__
);
7813 nfs41_setup_sequence(lrp
->clp
->cl_session
,
7814 &lrp
->args
.seq_args
,
7819 static void nfs4_layoutreturn_done(struct rpc_task
*task
, void *calldata
)
7821 struct nfs4_layoutreturn
*lrp
= calldata
;
7822 struct nfs_server
*server
;
7824 dprintk("--> %s\n", __func__
);
7826 if (!nfs41_sequence_done(task
, &lrp
->res
.seq_res
))
7829 server
= NFS_SERVER(lrp
->args
.inode
);
7830 switch (task
->tk_status
) {
7832 task
->tk_status
= 0;
7835 case -NFS4ERR_DELAY
:
7836 if (nfs4_async_handle_error(task
, server
, NULL
, NULL
) != -EAGAIN
)
7838 rpc_restart_call_prepare(task
);
7841 dprintk("<-- %s\n", __func__
);
7844 static void nfs4_layoutreturn_release(void *calldata
)
7846 struct nfs4_layoutreturn
*lrp
= calldata
;
7847 struct pnfs_layout_hdr
*lo
= lrp
->args
.layout
;
7849 dprintk("--> %s\n", __func__
);
7850 spin_lock(&lo
->plh_inode
->i_lock
);
7851 if (lrp
->res
.lrs_present
)
7852 pnfs_set_layout_stateid(lo
, &lrp
->res
.stateid
, true);
7853 pnfs_clear_layoutreturn_waitbit(lo
);
7854 clear_bit(NFS_LAYOUT_RETURN_BEFORE_CLOSE
, &lo
->plh_flags
);
7855 rpc_wake_up(&NFS_SERVER(lo
->plh_inode
)->roc_rpcwaitq
);
7856 lo
->plh_block_lgets
--;
7857 spin_unlock(&lo
->plh_inode
->i_lock
);
7858 pnfs_put_layout_hdr(lrp
->args
.layout
);
7859 nfs_iput_and_deactive(lrp
->inode
);
7861 dprintk("<-- %s\n", __func__
);
7864 static const struct rpc_call_ops nfs4_layoutreturn_call_ops
= {
7865 .rpc_call_prepare
= nfs4_layoutreturn_prepare
,
7866 .rpc_call_done
= nfs4_layoutreturn_done
,
7867 .rpc_release
= nfs4_layoutreturn_release
,
7870 int nfs4_proc_layoutreturn(struct nfs4_layoutreturn
*lrp
, bool sync
)
7872 struct rpc_task
*task
;
7873 struct rpc_message msg
= {
7874 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_LAYOUTRETURN
],
7875 .rpc_argp
= &lrp
->args
,
7876 .rpc_resp
= &lrp
->res
,
7877 .rpc_cred
= lrp
->cred
,
7879 struct rpc_task_setup task_setup_data
= {
7880 .rpc_client
= NFS_SERVER(lrp
->args
.inode
)->client
,
7881 .rpc_message
= &msg
,
7882 .callback_ops
= &nfs4_layoutreturn_call_ops
,
7883 .callback_data
= lrp
,
7887 dprintk("--> %s\n", __func__
);
7889 lrp
->inode
= nfs_igrab_and_active(lrp
->args
.inode
);
7891 nfs4_layoutreturn_release(lrp
);
7894 task_setup_data
.flags
|= RPC_TASK_ASYNC
;
7896 nfs4_init_sequence(&lrp
->args
.seq_args
, &lrp
->res
.seq_res
, 1);
7897 task
= rpc_run_task(&task_setup_data
);
7899 return PTR_ERR(task
);
7901 status
= task
->tk_status
;
7902 trace_nfs4_layoutreturn(lrp
->args
.inode
, status
);
7903 dprintk("<-- %s status=%d\n", __func__
, status
);
7909 _nfs4_proc_getdeviceinfo(struct nfs_server
*server
,
7910 struct pnfs_device
*pdev
,
7911 struct rpc_cred
*cred
)
7913 struct nfs4_getdeviceinfo_args args
= {
7916 struct nfs4_getdeviceinfo_res res
= {
7919 struct rpc_message msg
= {
7920 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_GETDEVICEINFO
],
7927 dprintk("--> %s\n", __func__
);
7928 status
= nfs4_call_sync(server
->client
, server
, &msg
, &args
.seq_args
, &res
.seq_res
, 0);
7929 dprintk("<-- %s status=%d\n", __func__
, status
);
7934 int nfs4_proc_getdeviceinfo(struct nfs_server
*server
,
7935 struct pnfs_device
*pdev
,
7936 struct rpc_cred
*cred
)
7938 struct nfs4_exception exception
= { };
7942 err
= nfs4_handle_exception(server
,
7943 _nfs4_proc_getdeviceinfo(server
, pdev
, cred
),
7945 } while (exception
.retry
);
7948 EXPORT_SYMBOL_GPL(nfs4_proc_getdeviceinfo
);
7950 static void nfs4_layoutcommit_prepare(struct rpc_task
*task
, void *calldata
)
7952 struct nfs4_layoutcommit_data
*data
= calldata
;
7953 struct nfs_server
*server
= NFS_SERVER(data
->args
.inode
);
7954 struct nfs4_session
*session
= nfs4_get_session(server
);
7956 nfs41_setup_sequence(session
,
7957 &data
->args
.seq_args
,
7963 nfs4_layoutcommit_done(struct rpc_task
*task
, void *calldata
)
7965 struct nfs4_layoutcommit_data
*data
= calldata
;
7966 struct nfs_server
*server
= NFS_SERVER(data
->args
.inode
);
7968 if (!nfs41_sequence_done(task
, &data
->res
.seq_res
))
7971 switch (task
->tk_status
) { /* Just ignore these failures */
7972 case -NFS4ERR_DELEG_REVOKED
: /* layout was recalled */
7973 case -NFS4ERR_BADIOMODE
: /* no IOMODE_RW layout for range */
7974 case -NFS4ERR_BADLAYOUT
: /* no layout */
7975 case -NFS4ERR_GRACE
: /* loca_recalim always false */
7976 task
->tk_status
= 0;
7980 if (nfs4_async_handle_error(task
, server
, NULL
, NULL
) == -EAGAIN
) {
7981 rpc_restart_call_prepare(task
);
7987 static void nfs4_layoutcommit_release(void *calldata
)
7989 struct nfs4_layoutcommit_data
*data
= calldata
;
7991 pnfs_cleanup_layoutcommit(data
);
7992 nfs_post_op_update_inode_force_wcc(data
->args
.inode
,
7994 put_rpccred(data
->cred
);
7995 nfs_iput_and_deactive(data
->inode
);
7999 static const struct rpc_call_ops nfs4_layoutcommit_ops
= {
8000 .rpc_call_prepare
= nfs4_layoutcommit_prepare
,
8001 .rpc_call_done
= nfs4_layoutcommit_done
,
8002 .rpc_release
= nfs4_layoutcommit_release
,
8006 nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data
*data
, bool sync
)
8008 struct rpc_message msg
= {
8009 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_LAYOUTCOMMIT
],
8010 .rpc_argp
= &data
->args
,
8011 .rpc_resp
= &data
->res
,
8012 .rpc_cred
= data
->cred
,
8014 struct rpc_task_setup task_setup_data
= {
8015 .task
= &data
->task
,
8016 .rpc_client
= NFS_CLIENT(data
->args
.inode
),
8017 .rpc_message
= &msg
,
8018 .callback_ops
= &nfs4_layoutcommit_ops
,
8019 .callback_data
= data
,
8021 struct rpc_task
*task
;
8024 dprintk("NFS: %4d initiating layoutcommit call. sync %d "
8025 "lbw: %llu inode %lu\n",
8026 data
->task
.tk_pid
, sync
,
8027 data
->args
.lastbytewritten
,
8028 data
->args
.inode
->i_ino
);
8031 data
->inode
= nfs_igrab_and_active(data
->args
.inode
);
8032 if (data
->inode
== NULL
) {
8033 nfs4_layoutcommit_release(data
);
8036 task_setup_data
.flags
= RPC_TASK_ASYNC
;
8038 nfs4_init_sequence(&data
->args
.seq_args
, &data
->res
.seq_res
, 1);
8039 task
= rpc_run_task(&task_setup_data
);
8041 return PTR_ERR(task
);
8043 status
= task
->tk_status
;
8044 trace_nfs4_layoutcommit(data
->args
.inode
, status
);
8045 dprintk("%s: status %d\n", __func__
, status
);
8051 * Use the state managment nfs_client cl_rpcclient, which uses krb5i (if
8052 * possible) as per RFC3530bis and RFC5661 Security Considerations sections
8055 _nfs41_proc_secinfo_no_name(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
8056 struct nfs_fsinfo
*info
,
8057 struct nfs4_secinfo_flavors
*flavors
, bool use_integrity
)
8059 struct nfs41_secinfo_no_name_args args
= {
8060 .style
= SECINFO_STYLE_CURRENT_FH
,
8062 struct nfs4_secinfo_res res
= {
8065 struct rpc_message msg
= {
8066 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_SECINFO_NO_NAME
],
8070 struct rpc_clnt
*clnt
= server
->client
;
8071 struct rpc_cred
*cred
= NULL
;
8074 if (use_integrity
) {
8075 clnt
= server
->nfs_client
->cl_rpcclient
;
8076 cred
= nfs4_get_clid_cred(server
->nfs_client
);
8077 msg
.rpc_cred
= cred
;
8080 dprintk("--> %s\n", __func__
);
8081 status
= nfs4_call_sync(clnt
, server
, &msg
, &args
.seq_args
,
8083 dprintk("<-- %s status=%d\n", __func__
, status
);
8092 nfs41_proc_secinfo_no_name(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
8093 struct nfs_fsinfo
*info
, struct nfs4_secinfo_flavors
*flavors
)
8095 struct nfs4_exception exception
= { };
8098 /* first try using integrity protection */
8099 err
= -NFS4ERR_WRONGSEC
;
8101 /* try to use integrity protection with machine cred */
8102 if (_nfs4_is_integrity_protected(server
->nfs_client
))
8103 err
= _nfs41_proc_secinfo_no_name(server
, fhandle
, info
,
8107 * if unable to use integrity protection, or SECINFO with
8108 * integrity protection returns NFS4ERR_WRONGSEC (which is
8109 * disallowed by spec, but exists in deployed servers) use
8110 * the current filesystem's rpc_client and the user cred.
8112 if (err
== -NFS4ERR_WRONGSEC
)
8113 err
= _nfs41_proc_secinfo_no_name(server
, fhandle
, info
,
8118 case -NFS4ERR_WRONGSEC
:
8122 err
= nfs4_handle_exception(server
, err
, &exception
);
8124 } while (exception
.retry
);
8130 nfs41_find_root_sec(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
8131 struct nfs_fsinfo
*info
)
8135 rpc_authflavor_t flavor
= RPC_AUTH_MAXFLAVOR
;
8136 struct nfs4_secinfo_flavors
*flavors
;
8137 struct nfs4_secinfo4
*secinfo
;
8140 page
= alloc_page(GFP_KERNEL
);
8146 flavors
= page_address(page
);
8147 err
= nfs41_proc_secinfo_no_name(server
, fhandle
, info
, flavors
);
8150 * Fall back on "guess and check" method if
8151 * the server doesn't support SECINFO_NO_NAME
8153 if (err
== -NFS4ERR_WRONGSEC
|| err
== -ENOTSUPP
) {
8154 err
= nfs4_find_root_sec(server
, fhandle
, info
);
8160 for (i
= 0; i
< flavors
->num_flavors
; i
++) {
8161 secinfo
= &flavors
->flavors
[i
];
8163 switch (secinfo
->flavor
) {
8167 flavor
= rpcauth_get_pseudoflavor(secinfo
->flavor
,
8168 &secinfo
->flavor_info
);
8171 flavor
= RPC_AUTH_MAXFLAVOR
;
8175 if (!nfs_auth_info_match(&server
->auth_info
, flavor
))
8176 flavor
= RPC_AUTH_MAXFLAVOR
;
8178 if (flavor
!= RPC_AUTH_MAXFLAVOR
) {
8179 err
= nfs4_lookup_root_sec(server
, fhandle
,
8186 if (flavor
== RPC_AUTH_MAXFLAVOR
)
8197 static int _nfs41_test_stateid(struct nfs_server
*server
,
8198 nfs4_stateid
*stateid
,
8199 struct rpc_cred
*cred
)
8202 struct nfs41_test_stateid_args args
= {
8205 struct nfs41_test_stateid_res res
;
8206 struct rpc_message msg
= {
8207 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_TEST_STATEID
],
8212 struct rpc_clnt
*rpc_client
= server
->client
;
8214 nfs4_state_protect(server
->nfs_client
, NFS_SP4_MACH_CRED_STATEID
,
8217 dprintk("NFS call test_stateid %p\n", stateid
);
8218 nfs4_init_sequence(&args
.seq_args
, &res
.seq_res
, 0);
8219 nfs4_set_sequence_privileged(&args
.seq_args
);
8220 status
= nfs4_call_sync_sequence(rpc_client
, server
, &msg
,
8221 &args
.seq_args
, &res
.seq_res
);
8222 if (status
!= NFS_OK
) {
8223 dprintk("NFS reply test_stateid: failed, %d\n", status
);
8226 dprintk("NFS reply test_stateid: succeeded, %d\n", -res
.status
);
8231 * nfs41_test_stateid - perform a TEST_STATEID operation
8233 * @server: server / transport on which to perform the operation
8234 * @stateid: state ID to test
8237 * Returns NFS_OK if the server recognizes that "stateid" is valid.
8238 * Otherwise a negative NFS4ERR value is returned if the operation
8239 * failed or the state ID is not currently valid.
8241 static int nfs41_test_stateid(struct nfs_server
*server
,
8242 nfs4_stateid
*stateid
,
8243 struct rpc_cred
*cred
)
8245 struct nfs4_exception exception
= { };
8248 err
= _nfs41_test_stateid(server
, stateid
, cred
);
8249 if (err
!= -NFS4ERR_DELAY
)
8251 nfs4_handle_exception(server
, err
, &exception
);
8252 } while (exception
.retry
);
8256 struct nfs_free_stateid_data
{
8257 struct nfs_server
*server
;
8258 struct nfs41_free_stateid_args args
;
8259 struct nfs41_free_stateid_res res
;
8262 static void nfs41_free_stateid_prepare(struct rpc_task
*task
, void *calldata
)
8264 struct nfs_free_stateid_data
*data
= calldata
;
8265 nfs41_setup_sequence(nfs4_get_session(data
->server
),
8266 &data
->args
.seq_args
,
8271 static void nfs41_free_stateid_done(struct rpc_task
*task
, void *calldata
)
8273 struct nfs_free_stateid_data
*data
= calldata
;
8275 nfs41_sequence_done(task
, &data
->res
.seq_res
);
8277 switch (task
->tk_status
) {
8278 case -NFS4ERR_DELAY
:
8279 if (nfs4_async_handle_error(task
, data
->server
, NULL
, NULL
) == -EAGAIN
)
8280 rpc_restart_call_prepare(task
);
8284 static void nfs41_free_stateid_release(void *calldata
)
8289 static const struct rpc_call_ops nfs41_free_stateid_ops
= {
8290 .rpc_call_prepare
= nfs41_free_stateid_prepare
,
8291 .rpc_call_done
= nfs41_free_stateid_done
,
8292 .rpc_release
= nfs41_free_stateid_release
,
8295 static struct rpc_task
*_nfs41_free_stateid(struct nfs_server
*server
,
8296 nfs4_stateid
*stateid
,
8297 struct rpc_cred
*cred
,
8300 struct rpc_message msg
= {
8301 .rpc_proc
= &nfs4_procedures
[NFSPROC4_CLNT_FREE_STATEID
],
8304 struct rpc_task_setup task_setup
= {
8305 .rpc_client
= server
->client
,
8306 .rpc_message
= &msg
,
8307 .callback_ops
= &nfs41_free_stateid_ops
,
8308 .flags
= RPC_TASK_ASYNC
,
8310 struct nfs_free_stateid_data
*data
;
8312 nfs4_state_protect(server
->nfs_client
, NFS_SP4_MACH_CRED_STATEID
,
8313 &task_setup
.rpc_client
, &msg
);
8315 dprintk("NFS call free_stateid %p\n", stateid
);
8316 data
= kmalloc(sizeof(*data
), GFP_NOFS
);
8318 return ERR_PTR(-ENOMEM
);
8319 data
->server
= server
;
8320 nfs4_stateid_copy(&data
->args
.stateid
, stateid
);
8322 task_setup
.callback_data
= data
;
8324 msg
.rpc_argp
= &data
->args
;
8325 msg
.rpc_resp
= &data
->res
;
8326 nfs4_init_sequence(&data
->args
.seq_args
, &data
->res
.seq_res
, 0);
8328 nfs4_set_sequence_privileged(&data
->args
.seq_args
);
8330 return rpc_run_task(&task_setup
);
8334 * nfs41_free_stateid - perform a FREE_STATEID operation
8336 * @server: server / transport on which to perform the operation
8337 * @stateid: state ID to release
8340 * Returns NFS_OK if the server freed "stateid". Otherwise a
8341 * negative NFS4ERR value is returned.
8343 static int nfs41_free_stateid(struct nfs_server
*server
,
8344 nfs4_stateid
*stateid
,
8345 struct rpc_cred
*cred
)
8347 struct rpc_task
*task
;
8350 task
= _nfs41_free_stateid(server
, stateid
, cred
, true);
8352 return PTR_ERR(task
);
8353 ret
= rpc_wait_for_completion_task(task
);
8355 ret
= task
->tk_status
;
8361 nfs41_free_lock_state(struct nfs_server
*server
, struct nfs4_lock_state
*lsp
)
8363 struct rpc_task
*task
;
8364 struct rpc_cred
*cred
= lsp
->ls_state
->owner
->so_cred
;
8366 task
= _nfs41_free_stateid(server
, &lsp
->ls_stateid
, cred
, false);
8367 nfs4_free_lock_state(server
, lsp
);
8373 static bool nfs41_match_stateid(const nfs4_stateid
*s1
,
8374 const nfs4_stateid
*s2
)
8376 if (memcmp(s1
->other
, s2
->other
, sizeof(s1
->other
)) != 0)
8379 if (s1
->seqid
== s2
->seqid
)
8381 if (s1
->seqid
== 0 || s2
->seqid
== 0)
8387 #endif /* CONFIG_NFS_V4_1 */
8389 static bool nfs4_match_stateid(const nfs4_stateid
*s1
,
8390 const nfs4_stateid
*s2
)
8392 return nfs4_stateid_match(s1
, s2
);
8396 static const struct nfs4_state_recovery_ops nfs40_reboot_recovery_ops
= {
8397 .owner_flag_bit
= NFS_OWNER_RECLAIM_REBOOT
,
8398 .state_flag_bit
= NFS_STATE_RECLAIM_REBOOT
,
8399 .recover_open
= nfs4_open_reclaim
,
8400 .recover_lock
= nfs4_lock_reclaim
,
8401 .establish_clid
= nfs4_init_clientid
,
8402 .detect_trunking
= nfs40_discover_server_trunking
,
8405 #if defined(CONFIG_NFS_V4_1)
8406 static const struct nfs4_state_recovery_ops nfs41_reboot_recovery_ops
= {
8407 .owner_flag_bit
= NFS_OWNER_RECLAIM_REBOOT
,
8408 .state_flag_bit
= NFS_STATE_RECLAIM_REBOOT
,
8409 .recover_open
= nfs4_open_reclaim
,
8410 .recover_lock
= nfs4_lock_reclaim
,
8411 .establish_clid
= nfs41_init_clientid
,
8412 .reclaim_complete
= nfs41_proc_reclaim_complete
,
8413 .detect_trunking
= nfs41_discover_server_trunking
,
8415 #endif /* CONFIG_NFS_V4_1 */
8417 static const struct nfs4_state_recovery_ops nfs40_nograce_recovery_ops
= {
8418 .owner_flag_bit
= NFS_OWNER_RECLAIM_NOGRACE
,
8419 .state_flag_bit
= NFS_STATE_RECLAIM_NOGRACE
,
8420 .recover_open
= nfs40_open_expired
,
8421 .recover_lock
= nfs4_lock_expired
,
8422 .establish_clid
= nfs4_init_clientid
,
8425 #if defined(CONFIG_NFS_V4_1)
8426 static const struct nfs4_state_recovery_ops nfs41_nograce_recovery_ops
= {
8427 .owner_flag_bit
= NFS_OWNER_RECLAIM_NOGRACE
,
8428 .state_flag_bit
= NFS_STATE_RECLAIM_NOGRACE
,
8429 .recover_open
= nfs41_open_expired
,
8430 .recover_lock
= nfs41_lock_expired
,
8431 .establish_clid
= nfs41_init_clientid
,
8433 #endif /* CONFIG_NFS_V4_1 */
8435 static const struct nfs4_state_maintenance_ops nfs40_state_renewal_ops
= {
8436 .sched_state_renewal
= nfs4_proc_async_renew
,
8437 .get_state_renewal_cred_locked
= nfs4_get_renew_cred_locked
,
8438 .renew_lease
= nfs4_proc_renew
,
8441 #if defined(CONFIG_NFS_V4_1)
8442 static const struct nfs4_state_maintenance_ops nfs41_state_renewal_ops
= {
8443 .sched_state_renewal
= nfs41_proc_async_sequence
,
8444 .get_state_renewal_cred_locked
= nfs4_get_machine_cred_locked
,
8445 .renew_lease
= nfs4_proc_sequence
,
8449 static const struct nfs4_mig_recovery_ops nfs40_mig_recovery_ops
= {
8450 .get_locations
= _nfs40_proc_get_locations
,
8451 .fsid_present
= _nfs40_proc_fsid_present
,
8454 #if defined(CONFIG_NFS_V4_1)
8455 static const struct nfs4_mig_recovery_ops nfs41_mig_recovery_ops
= {
8456 .get_locations
= _nfs41_proc_get_locations
,
8457 .fsid_present
= _nfs41_proc_fsid_present
,
8459 #endif /* CONFIG_NFS_V4_1 */
8461 static const struct nfs4_minor_version_ops nfs_v4_0_minor_ops
= {
8463 .init_caps
= NFS_CAP_READDIRPLUS
8464 | NFS_CAP_ATOMIC_OPEN
8465 | NFS_CAP_CHANGE_ATTR
8466 | NFS_CAP_POSIX_LOCK
,
8467 .init_client
= nfs40_init_client
,
8468 .shutdown_client
= nfs40_shutdown_client
,
8469 .match_stateid
= nfs4_match_stateid
,
8470 .find_root_sec
= nfs4_find_root_sec
,
8471 .free_lock_state
= nfs4_release_lockowner
,
8472 .alloc_seqid
= nfs_alloc_seqid
,
8473 .call_sync_ops
= &nfs40_call_sync_ops
,
8474 .reboot_recovery_ops
= &nfs40_reboot_recovery_ops
,
8475 .nograce_recovery_ops
= &nfs40_nograce_recovery_ops
,
8476 .state_renewal_ops
= &nfs40_state_renewal_ops
,
8477 .mig_recovery_ops
= &nfs40_mig_recovery_ops
,
8480 #if defined(CONFIG_NFS_V4_1)
8481 static struct nfs_seqid
*
8482 nfs_alloc_no_seqid(struct nfs_seqid_counter
*arg1
, gfp_t arg2
)
8487 static const struct nfs4_minor_version_ops nfs_v4_1_minor_ops
= {
8489 .init_caps
= NFS_CAP_READDIRPLUS
8490 | NFS_CAP_ATOMIC_OPEN
8491 | NFS_CAP_CHANGE_ATTR
8492 | NFS_CAP_POSIX_LOCK
8493 | NFS_CAP_STATEID_NFSV41
8494 | NFS_CAP_ATOMIC_OPEN_V1
,
8495 .init_client
= nfs41_init_client
,
8496 .shutdown_client
= nfs41_shutdown_client
,
8497 .match_stateid
= nfs41_match_stateid
,
8498 .find_root_sec
= nfs41_find_root_sec
,
8499 .free_lock_state
= nfs41_free_lock_state
,
8500 .alloc_seqid
= nfs_alloc_no_seqid
,
8501 .call_sync_ops
= &nfs41_call_sync_ops
,
8502 .reboot_recovery_ops
= &nfs41_reboot_recovery_ops
,
8503 .nograce_recovery_ops
= &nfs41_nograce_recovery_ops
,
8504 .state_renewal_ops
= &nfs41_state_renewal_ops
,
8505 .mig_recovery_ops
= &nfs41_mig_recovery_ops
,
8509 #if defined(CONFIG_NFS_V4_2)
8510 static const struct nfs4_minor_version_ops nfs_v4_2_minor_ops
= {
8512 .init_caps
= NFS_CAP_READDIRPLUS
8513 | NFS_CAP_ATOMIC_OPEN
8514 | NFS_CAP_CHANGE_ATTR
8515 | NFS_CAP_POSIX_LOCK
8516 | NFS_CAP_STATEID_NFSV41
8517 | NFS_CAP_ATOMIC_OPEN_V1
8519 | NFS_CAP_DEALLOCATE
8521 .init_client
= nfs41_init_client
,
8522 .shutdown_client
= nfs41_shutdown_client
,
8523 .match_stateid
= nfs41_match_stateid
,
8524 .find_root_sec
= nfs41_find_root_sec
,
8525 .free_lock_state
= nfs41_free_lock_state
,
8526 .call_sync_ops
= &nfs41_call_sync_ops
,
8527 .alloc_seqid
= nfs_alloc_no_seqid
,
8528 .reboot_recovery_ops
= &nfs41_reboot_recovery_ops
,
8529 .nograce_recovery_ops
= &nfs41_nograce_recovery_ops
,
8530 .state_renewal_ops
= &nfs41_state_renewal_ops
,
8534 const struct nfs4_minor_version_ops
*nfs_v4_minor_ops
[] = {
8535 [0] = &nfs_v4_0_minor_ops
,
8536 #if defined(CONFIG_NFS_V4_1)
8537 [1] = &nfs_v4_1_minor_ops
,
8539 #if defined(CONFIG_NFS_V4_2)
8540 [2] = &nfs_v4_2_minor_ops
,
8544 static const struct inode_operations nfs4_dir_inode_operations
= {
8545 .create
= nfs_create
,
8546 .lookup
= nfs_lookup
,
8547 .atomic_open
= nfs_atomic_open
,
8549 .unlink
= nfs_unlink
,
8550 .symlink
= nfs_symlink
,
8554 .rename
= nfs_rename
,
8555 .permission
= nfs_permission
,
8556 .getattr
= nfs_getattr
,
8557 .setattr
= nfs_setattr
,
8558 .getxattr
= generic_getxattr
,
8559 .setxattr
= generic_setxattr
,
8560 .listxattr
= generic_listxattr
,
8561 .removexattr
= generic_removexattr
,
8564 static const struct inode_operations nfs4_file_inode_operations
= {
8565 .permission
= nfs_permission
,
8566 .getattr
= nfs_getattr
,
8567 .setattr
= nfs_setattr
,
8568 .getxattr
= generic_getxattr
,
8569 .setxattr
= generic_setxattr
,
8570 .listxattr
= generic_listxattr
,
8571 .removexattr
= generic_removexattr
,
8574 const struct nfs_rpc_ops nfs_v4_clientops
= {
8575 .version
= 4, /* protocol version */
8576 .dentry_ops
= &nfs4_dentry_operations
,
8577 .dir_inode_ops
= &nfs4_dir_inode_operations
,
8578 .file_inode_ops
= &nfs4_file_inode_operations
,
8579 .file_ops
= &nfs4_file_operations
,
8580 .getroot
= nfs4_proc_get_root
,
8581 .submount
= nfs4_submount
,
8582 .try_mount
= nfs4_try_mount
,
8583 .getattr
= nfs4_proc_getattr
,
8584 .setattr
= nfs4_proc_setattr
,
8585 .lookup
= nfs4_proc_lookup
,
8586 .access
= nfs4_proc_access
,
8587 .readlink
= nfs4_proc_readlink
,
8588 .create
= nfs4_proc_create
,
8589 .remove
= nfs4_proc_remove
,
8590 .unlink_setup
= nfs4_proc_unlink_setup
,
8591 .unlink_rpc_prepare
= nfs4_proc_unlink_rpc_prepare
,
8592 .unlink_done
= nfs4_proc_unlink_done
,
8593 .rename_setup
= nfs4_proc_rename_setup
,
8594 .rename_rpc_prepare
= nfs4_proc_rename_rpc_prepare
,
8595 .rename_done
= nfs4_proc_rename_done
,
8596 .link
= nfs4_proc_link
,
8597 .symlink
= nfs4_proc_symlink
,
8598 .mkdir
= nfs4_proc_mkdir
,
8599 .rmdir
= nfs4_proc_remove
,
8600 .readdir
= nfs4_proc_readdir
,
8601 .mknod
= nfs4_proc_mknod
,
8602 .statfs
= nfs4_proc_statfs
,
8603 .fsinfo
= nfs4_proc_fsinfo
,
8604 .pathconf
= nfs4_proc_pathconf
,
8605 .set_capabilities
= nfs4_server_capabilities
,
8606 .decode_dirent
= nfs4_decode_dirent
,
8607 .pgio_rpc_prepare
= nfs4_proc_pgio_rpc_prepare
,
8608 .read_setup
= nfs4_proc_read_setup
,
8609 .read_done
= nfs4_read_done
,
8610 .write_setup
= nfs4_proc_write_setup
,
8611 .write_done
= nfs4_write_done
,
8612 .commit_setup
= nfs4_proc_commit_setup
,
8613 .commit_rpc_prepare
= nfs4_proc_commit_rpc_prepare
,
8614 .commit_done
= nfs4_commit_done
,
8615 .lock
= nfs4_proc_lock
,
8616 .clear_acl_cache
= nfs4_zap_acl_attr
,
8617 .close_context
= nfs4_close_context
,
8618 .open_context
= nfs4_atomic_open
,
8619 .have_delegation
= nfs4_have_delegation
,
8620 .return_delegation
= nfs4_inode_return_delegation
,
8621 .alloc_client
= nfs4_alloc_client
,
8622 .init_client
= nfs4_init_client
,
8623 .free_client
= nfs4_free_client
,
8624 .create_server
= nfs4_create_server
,
8625 .clone_server
= nfs_clone_server
,
8628 static const struct xattr_handler nfs4_xattr_nfs4_acl_handler
= {
8629 .prefix
= XATTR_NAME_NFSV4_ACL
,
8630 .list
= nfs4_xattr_list_nfs4_acl
,
8631 .get
= nfs4_xattr_get_nfs4_acl
,
8632 .set
= nfs4_xattr_set_nfs4_acl
,
8635 const struct xattr_handler
*nfs4_xattr_handlers
[] = {
8636 &nfs4_xattr_nfs4_acl_handler
,
8637 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
8638 &nfs4_xattr_nfs4_label_handler
,