Lines Matching +full:skip +full:- +full:recall
4 * Client-side procedure declarations for NFSv4.
126 label->lfs = 0; in nfs4_label_init_security()
127 label->pi = 0; in nfs4_label_init_security()
128 label->len = 0; in nfs4_label_init_security()
129 label->label = NULL; in nfs4_label_init_security()
131 err = security_dentry_init_security(dentry, sattr->ia_mode, in nfs4_label_init_security()
132 &dentry->d_name, NULL, &shim); in nfs4_label_init_security()
136 label->lsmid = shim.id; in nfs4_label_init_security()
137 label->label = shim.context; in nfs4_label_init_security()
138 label->len = shim.len; in nfs4_label_init_security()
147 shim.context = label->label; in nfs4_label_release_security()
148 shim.len = label->len; in nfs4_label_release_security()
149 shim.id = label->lsmid; in nfs4_label_release_security()
156 return server->attr_bitmask; in nfs4_bitmask()
158 return server->attr_bitmask_nl; in nfs4_bitmask()
170 { return server->attr_bitmask; } in nfs4_bitmask()
176 if (err >= -1000) in nfs4_map_errors()
179 case -NFS4ERR_RESOURCE: in nfs4_map_errors()
180 case -NFS4ERR_LAYOUTTRYLATER: in nfs4_map_errors()
181 case -NFS4ERR_RECALLCONFLICT: in nfs4_map_errors()
182 case -NFS4ERR_RETURNCONFLICT: in nfs4_map_errors()
183 return -EREMOTEIO; in nfs4_map_errors()
184 case -NFS4ERR_WRONGSEC: in nfs4_map_errors()
185 case -NFS4ERR_WRONG_CRED: in nfs4_map_errors()
186 return -EPERM; in nfs4_map_errors()
187 case -NFS4ERR_BADOWNER: in nfs4_map_errors()
188 case -NFS4ERR_BADNAME: in nfs4_map_errors()
189 return -EINVAL; in nfs4_map_errors()
190 case -NFS4ERR_SHARE_DENIED: in nfs4_map_errors()
191 return -EACCES; in nfs4_map_errors()
192 case -NFS4ERR_MINOR_VERS_MISMATCH: in nfs4_map_errors()
193 return -EPROTONOSUPPORT; in nfs4_map_errors()
194 case -NFS4ERR_FILE_OPEN: in nfs4_map_errors()
195 return -EBUSY; in nfs4_map_errors()
196 case -NFS4ERR_NOT_SAME: in nfs4_map_errors()
197 return -ENOTSYNC; in nfs4_map_errors()
198 case -ENETDOWN: in nfs4_map_errors()
199 case -ENETUNREACH: in nfs4_map_errors()
203 __func__, -err); in nfs4_map_errors()
206 return -EIO; in nfs4_map_errors()
313 cache_validity = READ_ONCE(NFS_I(inode)->cache_validity) | flags; in nfs4_bitmap_copy_adjust()
351 readdir->cookie = cookie; in nfs4_setup_readdir()
352 memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier)); in nfs4_setup_readdir()
356 readdir->cookie = 0; in nfs4_setup_readdir()
357 memset(&readdir->verifier, 0, sizeof(readdir->verifier)); in nfs4_setup_readdir()
368 start = p = kmap_atomic(*readdir->pages); in nfs4_setup_readdir()
394 spin_lock(&dentry->d_lock); in nfs4_setup_readdir()
395 p = xdr_encode_hyper(p, NFS_FILEID(d_inode(dentry->d_parent))); in nfs4_setup_readdir()
396 spin_unlock(&dentry->d_lock); in nfs4_setup_readdir()
398 readdir->pgbase = (char *)p - (char *)start; in nfs4_setup_readdir()
399 readdir->count -= readdir->pgbase; in nfs4_setup_readdir()
405 if (!(fattr->valid & NFS_ATTR_FATTR_PRECHANGE)) { in nfs4_fattr_set_prechange()
406 fattr->pre_change_attr = version; in nfs4_fattr_set_prechange()
407 fattr->valid |= NFS_ATTR_FATTR_PRECHANGE; in nfs4_fattr_set_prechange()
415 const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops; in nfs4_test_and_free_stateid()
417 ops->test_and_free_expired(server, stateid, cred); in nfs4_test_and_free_stateid()
424 stateid->type = NFS4_REVOKED_STATEID_TYPE; in __nfs4_free_revoked_stateid()
457 return -EINTR; in nfs4_delay_killable()
462 return -EINTR; in nfs4_delay_killable()
470 return -EINTR; in nfs4_delay_interruptible()
475 return __fatal_signal_pending(current) ? -EINTR :-ERESTARTSYS; in nfs4_delay_interruptible()
490 switch (stateid->type) { in nfs4_recoverable_stateid()
507 struct nfs_client *clp = server->nfs_client; in nfs4_do_handle_exception()
508 struct nfs4_state *state = exception->state; in nfs4_do_handle_exception()
510 struct inode *inode = exception->inode; in nfs4_do_handle_exception()
513 exception->delay = 0; in nfs4_do_handle_exception()
514 exception->recovering = 0; in nfs4_do_handle_exception()
515 exception->retry = 0; in nfs4_do_handle_exception()
517 stateid = nfs4_recoverable_stateid(exception->stateid); in nfs4_do_handle_exception()
519 stateid = nfs4_recoverable_stateid(&state->stateid); in nfs4_do_handle_exception()
524 case -NFS4ERR_BADHANDLE: in nfs4_do_handle_exception()
525 case -ESTALE: in nfs4_do_handle_exception()
526 if (inode != NULL && S_ISREG(inode->i_mode)) in nfs4_do_handle_exception()
529 case -NFS4ERR_DELEG_REVOKED: in nfs4_do_handle_exception()
530 case -NFS4ERR_ADMIN_REVOKED: in nfs4_do_handle_exception()
531 case -NFS4ERR_EXPIRED: in nfs4_do_handle_exception()
532 case -NFS4ERR_BAD_STATEID: in nfs4_do_handle_exception()
533 case -NFS4ERR_PARTNER_NO_AUTH: in nfs4_do_handle_exception()
540 case -NFS4ERR_OPENMODE: in nfs4_do_handle_exception()
548 if (stateid != NULL && stateid->type == NFS4_DELEGATION_STATEID_TYPE) { in nfs4_do_handle_exception()
549 exception->retry = 1; in nfs4_do_handle_exception()
559 case -NFS4ERR_STALE_STATEID: in nfs4_do_handle_exception()
560 case -NFS4ERR_STALE_CLIENTID: in nfs4_do_handle_exception()
563 case -NFS4ERR_MOVED: in nfs4_do_handle_exception()
568 case -NFS4ERR_LEASE_MOVED: in nfs4_do_handle_exception()
572 case -NFS4ERR_BADSESSION: in nfs4_do_handle_exception()
573 case -NFS4ERR_BADSLOT: in nfs4_do_handle_exception()
574 case -NFS4ERR_BAD_HIGH_SLOT: in nfs4_do_handle_exception()
575 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: in nfs4_do_handle_exception()
576 case -NFS4ERR_DEADSESSION: in nfs4_do_handle_exception()
577 case -NFS4ERR_SEQ_FALSE_RETRY: in nfs4_do_handle_exception()
578 case -NFS4ERR_SEQ_MISORDERED: in nfs4_do_handle_exception()
582 case -NFS4ERR_FILE_OPEN: in nfs4_do_handle_exception()
583 if (exception->timeout > HZ) { in nfs4_do_handle_exception()
587 ret = -EBUSY; in nfs4_do_handle_exception()
591 case -NFS4ERR_DELAY: in nfs4_do_handle_exception()
594 case -NFS4ERR_GRACE: in nfs4_do_handle_exception()
595 case -NFS4ERR_LAYOUTTRYLATER: in nfs4_do_handle_exception()
596 case -NFS4ERR_RECALLCONFLICT: in nfs4_do_handle_exception()
597 case -NFS4ERR_RETURNCONFLICT: in nfs4_do_handle_exception()
598 exception->delay = 1; in nfs4_do_handle_exception()
601 case -NFS4ERR_RETRY_UNCACHED_REP: in nfs4_do_handle_exception()
602 case -NFS4ERR_OLD_STATEID: in nfs4_do_handle_exception()
603 exception->retry = 1; in nfs4_do_handle_exception()
605 case -NFS4ERR_BADOWNER: in nfs4_do_handle_exception()
607 case -NFS4ERR_BADNAME: in nfs4_do_handle_exception()
608 if (server->caps & NFS_CAP_UIDGID_NOMAP) { in nfs4_do_handle_exception()
609 server->caps &= ~NFS_CAP_UIDGID_NOMAP; in nfs4_do_handle_exception()
610 exception->retry = 1; in nfs4_do_handle_exception()
615 server->nfs_client->cl_hostname); in nfs4_do_handle_exception()
621 exception->recovering = 1; in nfs4_do_handle_exception()
633 if (server->flags & NFS_MOUNT_SOFTERR && nfs_delay_retrans >= 0) { in nfs4_exception_should_retrans()
634 if (exception->retrans++ >= (unsigned short)nfs_delay_retrans) in nfs4_exception_should_retrans()
635 return -EAGAIN; in nfs4_exception_should_retrans()
645 struct nfs_client *clp = server->nfs_client; in nfs4_handle_exception()
649 if (exception->delay) { in nfs4_handle_exception()
652 exception->retry = 0; in nfs4_handle_exception()
655 ret = nfs4_delay(&exception->timeout, in nfs4_handle_exception()
656 exception->interruptible); in nfs4_handle_exception()
659 if (exception->recovering) { in nfs4_handle_exception()
660 if (exception->task_is_privileged) in nfs4_handle_exception()
661 return -EDEADLOCK; in nfs4_handle_exception()
663 if (test_bit(NFS_MIG_FAILED, &server->mig_status)) in nfs4_handle_exception()
664 return -EIO; in nfs4_handle_exception()
670 exception->retry = 1; in nfs4_handle_exception()
678 struct nfs_client *clp = server->nfs_client; in nfs4_async_handle_exception()
681 if ((task->tk_rpc_status == -ENETDOWN || in nfs4_async_handle_exception()
682 task->tk_rpc_status == -ENETUNREACH) && in nfs4_async_handle_exception()
683 task->tk_flags & RPC_TASK_NETUNREACH_FATAL) { in nfs4_async_handle_exception()
684 exception->delay = 0; in nfs4_async_handle_exception()
685 exception->recovering = 0; in nfs4_async_handle_exception()
686 exception->retry = 0; in nfs4_async_handle_exception()
687 return -EIO; in nfs4_async_handle_exception()
691 if (exception->delay) { in nfs4_async_handle_exception()
694 exception->retry = 0; in nfs4_async_handle_exception()
697 rpc_delay(task, nfs4_update_delay(&exception->timeout)); in nfs4_async_handle_exception()
700 if (exception->recovering) { in nfs4_async_handle_exception()
701 if (exception->task_is_privileged) in nfs4_async_handle_exception()
702 return -EDEADLOCK; in nfs4_async_handle_exception()
703 rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL); in nfs4_async_handle_exception()
704 if (test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) == 0) in nfs4_async_handle_exception()
705 rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task); in nfs4_async_handle_exception()
708 if (test_bit(NFS_MIG_FAILED, &server->mig_status)) in nfs4_async_handle_exception()
709 ret = -EIO; in nfs4_async_handle_exception()
713 exception->retry = 1; in nfs4_async_handle_exception()
718 if (errorcode == -NFS4ERR_MOVED) in nfs4_async_handle_exception()
732 if (task->tk_status >= 0) in nfs4_async_handle_error()
736 task->tk_status = nfs4_async_handle_exception(task, server, in nfs4_async_handle_error()
737 task->tk_status, in nfs4_async_handle_error()
742 return -EAGAIN; in nfs4_async_handle_error()
752 rpc_authflavor_t flavor = clp->cl_rpcclient->cl_auth->au_flavor; in _nfs4_is_integrity_protected()
758 spin_lock(&clp->cl_lock); in do_renew_lease()
759 if (time_before(clp->cl_last_renewal,timestamp)) in do_renew_lease()
760 clp->cl_last_renewal = timestamp; in do_renew_lease()
761 spin_unlock(&clp->cl_lock); in do_renew_lease()
766 struct nfs_client *clp = server->nfs_client; in renew_lease()
782 args->sa_slot = NULL; in nfs4_init_sequence()
783 args->sa_cache_this = cache_reply; in nfs4_init_sequence()
784 args->sa_privileged = privileged; in nfs4_init_sequence()
786 res->sr_slot = NULL; in nfs4_init_sequence()
791 struct nfs4_slot *slot = res->sr_slot; in nfs40_sequence_free_slot()
794 tbl = slot->table; in nfs40_sequence_free_slot()
795 spin_lock(&tbl->slot_tbl_lock); in nfs40_sequence_free_slot()
798 spin_unlock(&tbl->slot_tbl_lock); in nfs40_sequence_free_slot()
800 res->sr_slot = NULL; in nfs40_sequence_free_slot()
806 if (res->sr_slot != NULL) in nfs40_sequence_done()
821 tbl = slot->table; in nfs41_release_slot()
822 session = tbl->session; in nfs41_release_slot()
825 if (slot->seq_done) in nfs41_release_slot()
826 slot->seq_nr++; in nfs41_release_slot()
827 slot->seq_done = 0; in nfs41_release_slot()
829 spin_lock(&tbl->slot_tbl_lock); in nfs41_release_slot()
833 if (tbl->highest_used_slotid > tbl->target_highest_slotid) in nfs41_release_slot()
842 if (tbl->highest_used_slotid != NFS4_NO_SLOT) in nfs41_release_slot()
845 spin_unlock(&tbl->slot_tbl_lock); in nfs41_release_slot()
847 nfs41_notify_server(session->clp); in nfs41_release_slot()
848 if (waitqueue_active(&tbl->slot_waitq)) in nfs41_release_slot()
849 wake_up_all(&tbl->slot_waitq); in nfs41_release_slot()
854 nfs41_release_slot(res->sr_slot); in nfs41_sequence_free_slot()
855 res->sr_slot = NULL; in nfs41_sequence_free_slot()
861 if ((s32)(seqnr - slot->seq_nr_highest_sent) > 0) in nfs4_slot_sequence_record_sent()
862 slot->seq_nr_highest_sent = seqnr; in nfs4_slot_sequence_record_sent()
867 slot->seq_nr_last_acked = seqnr; in nfs4_slot_sequence_acked()
882 struct nfs4_slot *slot = res->sr_slot; in nfs41_sequence_process()
890 if (!RPC_WAS_SENT(task) || slot->seq_done) in nfs41_sequence_process()
893 session = slot->table->session; in nfs41_sequence_process()
894 clp = session->clp; in nfs41_sequence_process()
898 status = res->sr_status; in nfs41_sequence_process()
899 if (task->tk_status == -NFS4ERR_DEADSESSION) in nfs41_sequence_process()
900 status = -NFS4ERR_DEADSESSION; in nfs41_sequence_process()
906 nfs4_slot_sequence_acked(slot, slot->seq_nr); in nfs41_sequence_process()
908 slot->seq_done = 1; in nfs41_sequence_process()
909 do_renew_lease(clp, res->sr_timestamp); in nfs41_sequence_process()
911 nfs41_handle_sequence_flag_errors(clp, res->sr_status_flags, in nfs41_sequence_process()
912 !!slot->privileged); in nfs41_sequence_process()
913 nfs41_update_target_slotid(slot->table, slot, res); in nfs41_sequence_process()
921 nfs4_slot_sequence_record_sent(slot, slot->seq_nr); in nfs41_sequence_process()
922 slot->seq_done = 1; in nfs41_sequence_process()
924 case -NFS4ERR_DELAY: in nfs41_sequence_process()
931 slot->slot_nr, in nfs41_sequence_process()
932 slot->seq_nr); in nfs41_sequence_process()
934 case -NFS4ERR_RETRY_UNCACHED_REP: in nfs41_sequence_process()
935 case -NFS4ERR_SEQ_FALSE_RETRY: in nfs41_sequence_process()
940 nfs4_slot_sequence_acked(slot, slot->seq_nr); in nfs41_sequence_process()
942 case -NFS4ERR_BADSLOT: in nfs41_sequence_process()
947 if (slot->slot_nr < slot->table->target_highest_slotid) in nfs41_sequence_process()
950 case -NFS4ERR_SEQ_MISORDERED: in nfs41_sequence_process()
951 nfs4_slot_sequence_record_sent(slot, slot->seq_nr); in nfs41_sequence_process()
961 if ((s32)(slot->seq_nr - slot->seq_nr_last_acked) > 1) { in nfs41_sequence_process()
962 slot->seq_nr--; in nfs41_sequence_process()
963 if (task->tk_msg.rpc_proc != &nfs4_procedures[NFSPROC4_CLNT_SEQUENCE]) { in nfs41_sequence_process()
964 nfs4_probe_sequence(clp, task->tk_msg.rpc_cred, slot); in nfs41_sequence_process()
965 res->sr_slot = NULL; in nfs41_sequence_process()
979 slot->seq_nr = slot->seq_nr_highest_sent; in nfs41_sequence_process()
981 case -NFS4ERR_BADSESSION: in nfs41_sequence_process()
982 case -NFS4ERR_DEADSESSION: in nfs41_sequence_process()
983 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: in nfs41_sequence_process()
987 slot->seq_done = 1; in nfs41_sequence_process()
991 dprintk("%s: Error %d free the slot \n", __func__, res->sr_status); in nfs41_sequence_process()
995 set_bit(NFS4_SLOT_TBL_DRAINING, &session->fc_slot_table.slot_tbl_state); in nfs41_sequence_process()
1001 ++slot->seq_nr; in nfs41_sequence_process()
1005 task->tk_status = 0; in nfs41_sequence_process()
1020 if (res->sr_slot != NULL) in nfs41_sequence_done()
1029 if (res->sr_slot == NULL) in nfs4_sequence_process()
1031 if (res->sr_slot->table->session != NULL) in nfs4_sequence_process()
1038 if (res->sr_slot != NULL) { in nfs4_sequence_free_slot()
1039 if (res->sr_slot->table->session != NULL) in nfs4_sequence_free_slot()
1048 if (res->sr_slot == NULL) in nfs4_sequence_done()
1050 if (!res->sr_slot->table->session) in nfs4_sequence_done()
1060 dprintk("--> %s data->seq_server %p\n", __func__, data->seq_server); in nfs41_call_sync_prepare()
1062 nfs4_setup_sequence(data->seq_server->nfs_client, in nfs41_call_sync_prepare()
1063 data->seq_args, data->seq_res, task); in nfs41_call_sync_prepare()
1070 nfs41_sequence_done(task, data->seq_res); in nfs41_call_sync_done()
1087 if (res->sr_slot != NULL) in nfs4_sequence_free_slot()
1102 res->sr_timestamp = jiffies; in nfs41_sequence_res_init()
1103 res->sr_status_flags = 0; in nfs41_sequence_res_init()
1104 res->sr_status = 1; in nfs41_sequence_res_init()
1114 slot->privileged = args->sa_privileged ? 1 : 0; in nfs4_sequence_attach_slot()
1115 args->sa_slot = slot; in nfs4_sequence_attach_slot()
1117 res->sr_slot = slot; in nfs4_sequence_attach_slot()
1126 struct nfs4_slot_table *tbl = client->cl_slot_tbl; in nfs4_setup_sequence()
1130 if (res->sr_slot != NULL) in nfs4_setup_sequence()
1134 tbl = &session->fc_slot_table; in nfs4_setup_sequence()
1136 spin_lock(&tbl->slot_tbl_lock); in nfs4_setup_sequence()
1138 if (nfs4_slot_tbl_draining(tbl) && !args->sa_privileged) in nfs4_setup_sequence()
1143 if (slot == ERR_PTR(-ENOMEM)) in nfs4_setup_sequence()
1147 spin_unlock(&tbl->slot_tbl_lock); in nfs4_setup_sequence()
1158 if (args->sa_privileged) in nfs4_setup_sequence()
1159 rpc_sleep_on_priority_timeout(&tbl->slot_tbl_waitq, task, in nfs4_setup_sequence()
1162 rpc_sleep_on_timeout(&tbl->slot_tbl_waitq, task, in nfs4_setup_sequence()
1164 spin_unlock(&tbl->slot_tbl_lock); in nfs4_setup_sequence()
1165 return -EAGAIN; in nfs4_setup_sequence()
1167 if (args->sa_privileged) in nfs4_setup_sequence()
1168 rpc_sleep_on_priority(&tbl->slot_tbl_waitq, task, in nfs4_setup_sequence()
1171 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL); in nfs4_setup_sequence()
1172 spin_unlock(&tbl->slot_tbl_lock); in nfs4_setup_sequence()
1173 return -EAGAIN; in nfs4_setup_sequence()
1180 nfs4_setup_sequence(data->seq_server->nfs_client, in nfs40_call_sync_prepare()
1181 data->seq_args, data->seq_res, task); in nfs40_call_sync_prepare()
1187 nfs4_sequence_done(task, data->seq_res); in nfs40_call_sync_done()
1204 ret = task->tk_status; in nfs4_call_sync_custom()
1216 struct nfs_client *clp = server->nfs_client; in nfs4_do_call_sync()
1225 .callback_ops = clp->cl_mvops->call_sync_ops, in nfs4_do_call_sync()
1241 if (server->caps & NFS_CAP_MOVEABLE) in nfs4_call_sync_sequence()
1270 spin_lock(&inode->i_lock); in nfs4_inc_nlink()
1272 spin_unlock(&inode->i_lock); in nfs4_inc_nlink()
1294 if (S_ISDIR(inode->i_mode)) in nfs4_update_changeattr_locked()
1297 switch (NFS_SERVER(inode)->change_attr_type) { in nfs4_update_changeattr_locked()
1299 if (cinfo->after == change_attr) in nfs4_update_changeattr_locked()
1303 if ((s64)(change_attr - cinfo->after) >= 0) in nfs4_update_changeattr_locked()
1307 inode_set_iversion_raw(inode, cinfo->after); in nfs4_update_changeattr_locked()
1308 if (!cinfo->atomic || cinfo->before != change_attr) { in nfs4_update_changeattr_locked()
1309 if (S_ISDIR(inode->i_mode)) in nfs4_update_changeattr_locked()
1319 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode); in nfs4_update_changeattr_locked()
1321 nfsi->attrtimeo_timestamp = jiffies; in nfs4_update_changeattr_locked()
1322 nfsi->read_cache_jiffies = timestamp; in nfs4_update_changeattr_locked()
1323 nfsi->attr_gencount = nfs_inc_attr_generation_counter(); in nfs4_update_changeattr_locked()
1324 nfsi->cache_validity &= ~NFS_INO_INVALID_CHANGE; in nfs4_update_changeattr_locked()
1333 spin_lock(&dir->i_lock); in nfs4_update_changeattr()
1335 spin_unlock(&dir->i_lock); in nfs4_update_changeattr()
1347 if (err != -EINVAL) in nfs4_clear_cap_atomic_open_v1()
1349 if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1)) in nfs4_clear_cap_atomic_open_v1()
1351 server->caps &= ~NFS_CAP_ATOMIC_OPEN_V1; in nfs4_clear_cap_atomic_open_v1()
1352 exception->retry = 1; in nfs4_clear_cap_atomic_open_v1()
1358 return ctx->mode & (FMODE_READ|FMODE_WRITE|FMODE_EXEC); in _nfs4_ctx_to_accessmode()
1363 fmode_t ret = ctx->mode & (FMODE_READ|FMODE_WRITE); in _nfs4_ctx_to_openmode()
1365 return (ctx->mode & FMODE_EXEC) ? FMODE_READ | ret : ret; in _nfs4_ctx_to_openmode()
1392 if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1)) in nfs4_map_atomic_open_share()
1400 if (server->caps & NFS_CAP_DELEGTIME) in nfs4_map_atomic_open_share()
1402 if (server->caps & NFS_CAP_OPEN_XOR) in nfs4_map_atomic_open_share()
1412 if (server->caps & NFS_CAP_ATOMIC_OPEN_V1) in nfs4_map_atomic_open_claim()
1428 p->o_res.f_attr = &p->f_attr; in nfs4_init_opendata_res()
1429 p->o_res.seqid = p->o_arg.seqid; in nfs4_init_opendata_res()
1430 p->c_res.seqid = p->c_arg.seqid; in nfs4_init_opendata_res()
1431 p->o_res.server = p->o_arg.server; in nfs4_init_opendata_res()
1432 p->o_res.access_request = p->o_arg.access; in nfs4_init_opendata_res()
1433 nfs_fattr_init(&p->f_attr); in nfs4_init_opendata_res()
1434 nfs_fattr_init_names(&p->f_attr, &p->owner_name, &p->group_name); in nfs4_init_opendata_res()
1447 struct nfs4_label *label = (c != NULL) ? c->label : NULL; in nfs4_opendata_alloc()
1454 p->f_attr.label = nfs4_label_alloc(server, gfp_mask); in nfs4_opendata_alloc()
1455 if (IS_ERR(p->f_attr.label)) in nfs4_opendata_alloc()
1458 p->a_label = nfs4_label_alloc(server, gfp_mask); in nfs4_opendata_alloc()
1459 if (IS_ERR(p->a_label)) in nfs4_opendata_alloc()
1462 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid; in nfs4_opendata_alloc()
1463 p->o_arg.seqid = alloc_seqid(&sp->so_seqid, gfp_mask); in nfs4_opendata_alloc()
1464 if (IS_ERR(p->o_arg.seqid)) in nfs4_opendata_alloc()
1466 nfs_sb_active(dentry->d_sb); in nfs4_opendata_alloc()
1467 p->dentry = dget(dentry); in nfs4_opendata_alloc()
1468 p->dir = parent; in nfs4_opendata_alloc()
1469 p->owner = sp; in nfs4_opendata_alloc()
1470 atomic_inc(&sp->so_count); in nfs4_opendata_alloc()
1471 p->o_arg.open_flags = flags; in nfs4_opendata_alloc()
1472 p->o_arg.fmode = fmode & (FMODE_READ|FMODE_WRITE); in nfs4_opendata_alloc()
1473 p->o_arg.claim = nfs4_map_atomic_open_claim(server, claim); in nfs4_opendata_alloc()
1474 p->o_arg.share_access = nfs4_map_atomic_open_share(server, in nfs4_opendata_alloc()
1477 p->o_arg.umask = current_umask(); in nfs4_opendata_alloc()
1478 p->o_arg.label = nfs4_label_copy(p->a_label, label); in nfs4_opendata_alloc()
1479 if (c->sattr != NULL && c->sattr->ia_valid != 0) { in nfs4_opendata_alloc()
1480 p->o_arg.u.attrs = &p->attrs; in nfs4_opendata_alloc()
1481 memcpy(&p->attrs, c->sattr, sizeof(p->attrs)); in nfs4_opendata_alloc()
1483 memcpy(p->o_arg.u.verifier.data, c->verf, in nfs4_opendata_alloc()
1484 sizeof(p->o_arg.u.verifier.data)); in nfs4_opendata_alloc()
1489 switch (p->o_arg.claim) { in nfs4_opendata_alloc()
1494 p->o_arg.access = NFS4_ACCESS_READ | NFS4_ACCESS_MODIFY | in nfs4_opendata_alloc()
1499 p->o_arg.clientid = server->nfs_client->cl_clientid; in nfs4_opendata_alloc()
1500 p->o_arg.id.create_time = ktime_to_ns(sp->so_seqid.create_time); in nfs4_opendata_alloc()
1501 p->o_arg.id.uniquifier = sp->so_seqid.owner_id; in nfs4_opendata_alloc()
1502 p->o_arg.name = &dentry->d_name; in nfs4_opendata_alloc()
1503 p->o_arg.server = server; in nfs4_opendata_alloc()
1504 p->o_arg.bitmask = nfs4_bitmask(server, label); in nfs4_opendata_alloc()
1505 p->o_arg.open_bitmap = &nfs4_fattr_bitmap[0]; in nfs4_opendata_alloc()
1506 switch (p->o_arg.claim) { in nfs4_opendata_alloc()
1510 p->o_arg.fh = NFS_FH(dir); in nfs4_opendata_alloc()
1516 p->o_arg.fh = NFS_FH(d_inode(dentry)); in nfs4_opendata_alloc()
1518 p->c_arg.fh = &p->o_res.fh; in nfs4_opendata_alloc()
1519 p->c_arg.stateid = &p->o_res.stateid; in nfs4_opendata_alloc()
1520 p->c_arg.seqid = p->o_arg.seqid; in nfs4_opendata_alloc()
1522 kref_init(&p->kref); in nfs4_opendata_alloc()
1526 nfs4_label_free(p->a_label); in nfs4_opendata_alloc()
1528 nfs4_label_free(p->f_attr.label); in nfs4_opendata_alloc()
1540 struct super_block *sb = p->dentry->d_sb; in nfs4_opendata_free()
1542 nfs4_lgopen_release(p->lgp); in nfs4_opendata_free()
1543 nfs_free_seqid(p->o_arg.seqid); in nfs4_opendata_free()
1544 nfs4_sequence_free_slot(&p->o_res.seq_res); in nfs4_opendata_free()
1545 if (p->state != NULL) in nfs4_opendata_free()
1546 nfs4_put_open_state(p->state); in nfs4_opendata_free()
1547 nfs4_put_state_owner(p->owner); in nfs4_opendata_free()
1549 nfs4_label_free(p->a_label); in nfs4_opendata_free()
1550 nfs4_label_free(p->f_attr.label); in nfs4_opendata_free()
1552 dput(p->dir); in nfs4_opendata_free()
1553 dput(p->dentry); in nfs4_opendata_free()
1555 nfs_fattr_free_names(&p->f_attr); in nfs4_opendata_free()
1556 kfree(p->f_attr.mdsthreshold); in nfs4_opendata_free()
1563 kref_put(&p->kref, nfs4_opendata_free); in nfs4_opendata_put()
1571 return state->n_rdwr != 0; in nfs4_mode_match_open_stateid()
1573 return state->n_wronly != 0; in nfs4_mode_match_open_stateid()
1575 return state->n_rdonly != 0; in nfs4_mode_match_open_stateid()
1597 ret |= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0 in can_open_cached()
1598 && state->n_rdonly != 0; in can_open_cached()
1601 ret |= test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0 in can_open_cached()
1602 && state->n_wronly != 0; in can_open_cached()
1605 ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0 in can_open_cached()
1606 && state->n_rdwr != 0; in can_open_cached()
1617 if ((delegation->type & fmode) != fmode) in can_open_delegated()
1624 if (!test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) in can_open_delegated()
1638 state->n_wronly++; in update_open_stateflags()
1641 state->n_rdonly++; in update_open_stateflags()
1644 state->n_rdwr++; in update_open_stateflags()
1646 nfs4_state_set_mode_locked(state, state->state | fmode); in update_open_stateflags()
1652 if (state->n_rdonly && !test_bit(NFS_O_RDONLY_STATE, &state->flags)) in nfs_open_stateid_recover_openmode()
1654 if (state->n_wronly && !test_bit(NFS_O_WRONLY_STATE, &state->flags)) in nfs_open_stateid_recover_openmode()
1656 if (state->n_rdwr && !test_bit(NFS_O_RDWR_STATE, &state->flags)) in nfs_open_stateid_recover_openmode()
1664 if (test_and_clear_bit(NFS_STATE_CHANGE_WAIT, &state->flags)) in nfs_state_log_update_open_stateid()
1665 wake_up_all(&state->waitq); in nfs_state_log_update_open_stateid()
1670 struct nfs_client *clp = state->owner->so_server->nfs_client; in nfs_test_and_clear_all_open_stateid()
1673 if (test_and_clear_bit(NFS_O_RDONLY_STATE, &state->flags) && state->n_rdonly) in nfs_test_and_clear_all_open_stateid()
1675 if (test_and_clear_bit(NFS_O_WRONLY_STATE, &state->flags) && state->n_wronly) in nfs_test_and_clear_all_open_stateid()
1677 if (test_and_clear_bit(NFS_O_RDWR_STATE, &state->flags) && state->n_rdwr) in nfs_test_and_clear_all_open_stateid()
1696 if (test_bit(NFS_OPEN_STATE, &state->flags)) { in nfs_stateid_is_sequential()
1697 /* The common case - we're updating to a new sequence number */ in nfs_stateid_is_sequential()
1698 if (nfs4_stateid_match_other(stateid, &state->open_stateid)) { in nfs_stateid_is_sequential()
1699 if (nfs4_stateid_is_next(&state->open_stateid, stateid)) in nfs_stateid_is_sequential()
1706 if (stateid->seqid == cpu_to_be32(1)) in nfs_stateid_is_sequential()
1713 if (!(state->n_wronly || state->n_rdonly || state->n_rdwr)) in nfs_resync_open_stateid_locked()
1715 if (state->n_wronly) in nfs_resync_open_stateid_locked()
1716 set_bit(NFS_O_WRONLY_STATE, &state->flags); in nfs_resync_open_stateid_locked()
1717 if (state->n_rdonly) in nfs_resync_open_stateid_locked()
1718 set_bit(NFS_O_RDONLY_STATE, &state->flags); in nfs_resync_open_stateid_locked()
1719 if (state->n_rdwr) in nfs_resync_open_stateid_locked()
1720 set_bit(NFS_O_RDWR_STATE, &state->flags); in nfs_resync_open_stateid_locked()
1721 set_bit(NFS_OPEN_STATE, &state->flags); in nfs_resync_open_stateid_locked()
1727 clear_bit(NFS_O_RDWR_STATE, &state->flags); in nfs_clear_open_stateid_locked()
1730 clear_bit(NFS_O_RDONLY_STATE, &state->flags); in nfs_clear_open_stateid_locked()
1733 clear_bit(NFS_O_WRONLY_STATE, &state->flags); in nfs_clear_open_stateid_locked()
1736 clear_bit(NFS_O_RDONLY_STATE, &state->flags); in nfs_clear_open_stateid_locked()
1737 clear_bit(NFS_O_WRONLY_STATE, &state->flags); in nfs_clear_open_stateid_locked()
1738 clear_bit(NFS_OPEN_STATE, &state->flags); in nfs_clear_open_stateid_locked()
1743 if (nfs4_stateid_match_other(stateid, &state->open_stateid) && in nfs_clear_open_stateid_locked()
1744 !nfs4_stateid_is_newer(stateid, &state->open_stateid)) { in nfs_clear_open_stateid_locked()
1748 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) in nfs_clear_open_stateid_locked()
1749 nfs4_stateid_copy(&state->stateid, stateid); in nfs_clear_open_stateid_locked()
1750 nfs4_stateid_copy(&state->open_stateid, stateid); in nfs_clear_open_stateid_locked()
1751 trace_nfs4_open_stateid_update(state->inode, stateid, 0); in nfs_clear_open_stateid_locked()
1760 write_seqlock(&state->seqlock); in nfs_clear_open_stateid()
1764 write_sequnlock(&state->seqlock); in nfs_clear_open_stateid()
1765 if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) in nfs_clear_open_stateid()
1766 nfs4_schedule_state_manager(state->owner->so_server->nfs_client); in nfs_clear_open_stateid()
1771 __must_hold(&state->owner->so_lock) in nfs_set_open_stateid_locked()
1772 __must_hold(&state->seqlock) in nfs_set_open_stateid_locked()
1786 if (!nfs4_has_session(NFS_SERVER(state->inode)->nfs_client)) in nfs_set_open_stateid_locked()
1789 set_bit(NFS_STATE_CHANGE_WAIT, &state->flags); in nfs_set_open_stateid_locked()
1790 prepare_to_wait(&state->waitq, &wait, TASK_KILLABLE); in nfs_set_open_stateid_locked()
1796 write_sequnlock(&state->seqlock); in nfs_set_open_stateid_locked()
1797 spin_unlock(&state->owner->so_lock); in nfs_set_open_stateid_locked()
1799 trace_nfs4_open_stateid_update_wait(state->inode, stateid, 0); in nfs_set_open_stateid_locked()
1804 status = -EAGAIN; in nfs_set_open_stateid_locked()
1808 status = -EINTR; in nfs_set_open_stateid_locked()
1809 finish_wait(&state->waitq, &wait); in nfs_set_open_stateid_locked()
1811 spin_lock(&state->owner->so_lock); in nfs_set_open_stateid_locked()
1812 write_seqlock(&state->seqlock); in nfs_set_open_stateid_locked()
1815 if (test_bit(NFS_OPEN_STATE, &state->flags) && in nfs_set_open_stateid_locked()
1816 !nfs4_stateid_match_other(stateid, &state->open_stateid)) { in nfs_set_open_stateid_locked()
1817 nfs4_stateid_copy(freeme, &state->open_stateid); in nfs_set_open_stateid_locked()
1821 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) in nfs_set_open_stateid_locked()
1822 nfs4_stateid_copy(&state->stateid, stateid); in nfs_set_open_stateid_locked()
1823 nfs4_stateid_copy(&state->open_stateid, stateid); in nfs_set_open_stateid_locked()
1824 trace_nfs4_open_stateid_update(state->inode, stateid, status); in nfs_set_open_stateid_locked()
1837 write_seqlock(&state->seqlock); in nfs_state_set_open_stateid()
1841 set_bit(NFS_O_RDONLY_STATE, &state->flags); in nfs_state_set_open_stateid()
1844 set_bit(NFS_O_WRONLY_STATE, &state->flags); in nfs_state_set_open_stateid()
1847 set_bit(NFS_O_RDWR_STATE, &state->flags); in nfs_state_set_open_stateid()
1849 set_bit(NFS_OPEN_STATE, &state->flags); in nfs_state_set_open_stateid()
1850 write_sequnlock(&state->seqlock); in nfs_state_set_open_stateid()
1855 clear_bit(NFS_O_RDWR_STATE, &state->flags); in nfs_state_clear_open_state_flags()
1856 clear_bit(NFS_O_WRONLY_STATE, &state->flags); in nfs_state_clear_open_state_flags()
1857 clear_bit(NFS_O_RDONLY_STATE, &state->flags); in nfs_state_clear_open_state_flags()
1858 clear_bit(NFS_OPEN_STATE, &state->flags); in nfs_state_clear_open_state_flags()
1869 write_seqlock(&state->seqlock); in nfs_state_set_delegation()
1870 nfs4_stateid_copy(&state->stateid, deleg_stateid); in nfs_state_set_delegation()
1871 set_bit(NFS_DELEGATED_STATE, &state->flags); in nfs_state_set_delegation()
1872 write_sequnlock(&state->seqlock); in nfs_state_set_delegation()
1877 write_seqlock(&state->seqlock); in nfs_state_clear_delegation()
1878 nfs4_stateid_copy(&state->stateid, &state->open_stateid); in nfs_state_clear_delegation()
1879 clear_bit(NFS_DELEGATED_STATE, &state->flags); in nfs_state_clear_delegation()
1880 write_sequnlock(&state->seqlock); in nfs_state_clear_delegation()
1888 struct nfs_server *server = NFS_SERVER(state->inode); in update_open_stateid()
1889 struct nfs_client *clp = server->nfs_client; in update_open_stateid()
1890 struct nfs_inode *nfsi = NFS_I(state->inode); in update_open_stateid()
1898 spin_lock(&state->owner->so_lock); in update_open_stateid()
1904 deleg_cur = nfs4_get_valid_delegation(state->inode); in update_open_stateid()
1908 spin_lock(&deleg_cur->lock); in update_open_stateid()
1909 if (rcu_dereference(nfsi->delegation) != deleg_cur || in update_open_stateid()
1910 test_bit(NFS_DELEGATION_RETURNING, &deleg_cur->flags) || in update_open_stateid()
1911 (deleg_cur->type & fmode) != fmode) in update_open_stateid()
1915 delegation = &deleg_cur->stateid; in update_open_stateid()
1916 else if (!nfs4_stateid_match_other(&deleg_cur->stateid, delegation)) in update_open_stateid()
1920 nfs_state_set_delegation(state, &deleg_cur->stateid, fmode); in update_open_stateid()
1923 spin_unlock(&deleg_cur->lock); in update_open_stateid()
1927 spin_unlock(&state->owner->so_lock); in update_open_stateid()
1930 if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) in update_open_stateid()
1934 state->owner->so_cred); in update_open_stateid()
1942 struct nfs4_state *state = lsp->ls_state; in nfs4_update_lock_stateid()
1945 spin_lock(&state->state_lock); in nfs4_update_lock_stateid()
1946 if (!nfs4_stateid_match_other(stateid, &lsp->ls_stateid)) in nfs4_update_lock_stateid()
1948 if (!nfs4_stateid_is_newer(stateid, &lsp->ls_stateid)) in nfs4_update_lock_stateid()
1950 nfs4_stateid_copy(&lsp->ls_stateid, stateid); in nfs4_update_lock_stateid()
1953 spin_unlock(&state->state_lock); in nfs4_update_lock_stateid()
1964 if (delegation == NULL || (delegation->type & fmode) == fmode) { in nfs4_return_incompatible_delegation()
1974 struct nfs4_state *state = opendata->state; in nfs4_try_open_cached()
1976 int open_mode = opendata->o_arg.open_flags; in nfs4_try_open_cached()
1977 fmode_t fmode = opendata->o_arg.fmode; in nfs4_try_open_cached()
1978 enum open_claim_type4 claim = opendata->o_arg.claim; in nfs4_try_open_cached()
1980 int ret = -EAGAIN; in nfs4_try_open_cached()
1983 spin_lock(&state->owner->so_lock); in nfs4_try_open_cached()
1986 spin_unlock(&state->owner->so_lock); in nfs4_try_open_cached()
1989 spin_unlock(&state->owner->so_lock); in nfs4_try_open_cached()
1991 delegation = nfs4_get_valid_delegation(state->inode); in nfs4_try_open_cached()
1997 nfs4_stateid_copy(&stateid, &delegation->stateid); in nfs4_try_open_cached()
1999 nfs_release_seqid(opendata->o_arg.seqid); in nfs4_try_open_cached()
2000 if (!opendata->is_recover) { in nfs4_try_open_cached()
2001 ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode); in nfs4_try_open_cached()
2005 ret = -EAGAIN; in nfs4_try_open_cached()
2014 refcount_inc(&state->count); in nfs4_try_open_cached()
2023 switch (delegation->open_delegation_type) { in nfs4_process_delegation()
2038 NFS_SERVER(inode)->nfs_client->cl_hostname); in nfs4_process_delegation()
2041 nfs_inode_reclaim_delegation(inode, cred, delegation->type, in nfs4_process_delegation()
2042 &delegation->stateid, in nfs4_process_delegation()
2043 delegation->pagemod_limit, in nfs4_process_delegation()
2044 delegation->open_delegation_type); in nfs4_process_delegation()
2047 nfs_inode_set_delegation(inode, cred, delegation->type, in nfs4_process_delegation()
2048 &delegation->stateid, in nfs4_process_delegation()
2049 delegation->pagemod_limit, in nfs4_process_delegation()
2050 delegation->open_delegation_type); in nfs4_process_delegation()
2052 if (delegation->do_recall) in nfs4_process_delegation()
2053 nfs_async_inode_return_delegation(inode, &delegation->stateid); in nfs4_process_delegation()
2063 struct inode *inode = data->state->inode; in _nfs4_opendata_reclaim_to_nfs4_state()
2064 struct nfs4_state *state = data->state; in _nfs4_opendata_reclaim_to_nfs4_state()
2067 if (!data->rpc_done) { in _nfs4_opendata_reclaim_to_nfs4_state()
2068 if (data->rpc_status) in _nfs4_opendata_reclaim_to_nfs4_state()
2069 return ERR_PTR(data->rpc_status); in _nfs4_opendata_reclaim_to_nfs4_state()
2073 ret = nfs_refresh_inode(inode, &data->f_attr); in _nfs4_opendata_reclaim_to_nfs4_state()
2077 nfs4_process_delegation(state->inode, in _nfs4_opendata_reclaim_to_nfs4_state()
2078 data->owner->so_cred, in _nfs4_opendata_reclaim_to_nfs4_state()
2079 data->o_arg.claim, in _nfs4_opendata_reclaim_to_nfs4_state()
2080 &data->o_res.delegation); in _nfs4_opendata_reclaim_to_nfs4_state()
2082 if (!(data->o_res.rflags & NFS4_OPEN_RESULT_NO_OPEN_STATEID)) { in _nfs4_opendata_reclaim_to_nfs4_state()
2083 if (!update_open_stateid(state, &data->o_res.stateid, in _nfs4_opendata_reclaim_to_nfs4_state()
2084 NULL, data->o_arg.fmode)) in _nfs4_opendata_reclaim_to_nfs4_state()
2085 return ERR_PTR(-EAGAIN); in _nfs4_opendata_reclaim_to_nfs4_state()
2086 } else if (!update_open_stateid(state, NULL, NULL, data->o_arg.fmode)) in _nfs4_opendata_reclaim_to_nfs4_state()
2087 return ERR_PTR(-EAGAIN); in _nfs4_opendata_reclaim_to_nfs4_state()
2088 refcount_inc(&state->count); in _nfs4_opendata_reclaim_to_nfs4_state()
2098 switch (data->o_arg.claim) { in nfs4_opendata_get_inode()
2102 if (!(data->f_attr.valid & NFS_ATTR_FATTR)) in nfs4_opendata_get_inode()
2103 return ERR_PTR(-EAGAIN); in nfs4_opendata_get_inode()
2104 inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, in nfs4_opendata_get_inode()
2105 &data->f_attr); in nfs4_opendata_get_inode()
2108 inode = d_inode(data->dentry); in nfs4_opendata_get_inode()
2110 nfs_refresh_inode(inode, &data->f_attr); in nfs4_opendata_get_inode()
2124 if (data->state != NULL && data->state->inode == inode) { in nfs4_opendata_find_nfs4_state()
2125 state = data->state; in nfs4_opendata_find_nfs4_state()
2126 refcount_inc(&state->count); in nfs4_opendata_find_nfs4_state()
2128 state = nfs4_get_open_state(inode, data->owner); in nfs4_opendata_find_nfs4_state()
2131 state = ERR_PTR(-ENOMEM); in nfs4_opendata_find_nfs4_state()
2140 if (!data->rpc_done) { in _nfs4_opendata_to_nfs4_state()
2142 trace_nfs4_cached_open(data->state); in _nfs4_opendata_to_nfs4_state()
2150 nfs4_process_delegation(state->inode, in _nfs4_opendata_to_nfs4_state()
2151 data->owner->so_cred, in _nfs4_opendata_to_nfs4_state()
2152 data->o_arg.claim, in _nfs4_opendata_to_nfs4_state()
2153 &data->o_res.delegation); in _nfs4_opendata_to_nfs4_state()
2155 if (!(data->o_res.rflags & NFS4_OPEN_RESULT_NO_OPEN_STATEID)) { in _nfs4_opendata_to_nfs4_state()
2156 if (!update_open_stateid(state, &data->o_res.stateid, in _nfs4_opendata_to_nfs4_state()
2157 NULL, data->o_arg.fmode)) { in _nfs4_opendata_to_nfs4_state()
2159 state = ERR_PTR(-EAGAIN); in _nfs4_opendata_to_nfs4_state()
2161 } else if (!update_open_stateid(state, NULL, NULL, data->o_arg.fmode)) { in _nfs4_opendata_to_nfs4_state()
2163 state = ERR_PTR(-EAGAIN); in _nfs4_opendata_to_nfs4_state()
2166 nfs_release_seqid(data->o_arg.seqid); in _nfs4_opendata_to_nfs4_state()
2175 if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS) in nfs4_opendata_to_nfs4_state()
2179 nfs4_sequence_free_slot(&data->o_res.seq_res); in nfs4_opendata_to_nfs4_state()
2186 struct nfs_inode *nfsi = NFS_I(state->inode); in nfs4_state_find_open_context_mode()
2190 list_for_each_entry_rcu(ctx, &nfsi->open_files, list) { in nfs4_state_find_open_context_mode()
2191 if (ctx->state != state) in nfs4_state_find_open_context_mode()
2193 if ((ctx->mode & mode) != mode) in nfs4_state_find_open_context_mode()
2201 return ERR_PTR(-ENOENT); in nfs4_state_find_open_context_mode()
2223 opendata = nfs4_opendata_alloc(ctx->dentry, state->owner, 0, 0, in nfs4_open_recoverdata_alloc()
2226 return ERR_PTR(-ENOMEM); in nfs4_open_recoverdata_alloc()
2227 opendata->state = state; in nfs4_open_recoverdata_alloc()
2228 refcount_inc(&state->count); in nfs4_open_recoverdata_alloc()
2236 struct nfs_server *server = NFS_SB(opendata->dentry->d_sb); in nfs4_open_recover_helper()
2237 int openflags = opendata->o_arg.open_flags; in nfs4_open_recover_helper()
2240 if (!nfs4_mode_match_open_stateid(opendata->state, fmode)) in nfs4_open_recover_helper()
2242 opendata->o_arg.fmode = fmode; in nfs4_open_recover_helper()
2243 opendata->o_arg.share_access = in nfs4_open_recover_helper()
2245 memset(&opendata->o_res, 0, sizeof(opendata->o_res)); in nfs4_open_recover_helper()
2246 memset(&opendata->c_res, 0, sizeof(opendata->c_res)); in nfs4_open_recover_helper()
2254 if (newstate != opendata->state) in nfs4_open_recover_helper()
2255 ret = -ESTALE; in nfs4_open_recover_helper()
2264 /* memory barrier prior to reading state->n_* */ in nfs4_open_recover()
2279 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 && in nfs4_open_recover()
2280 !nfs4_stateid_match(&state->stateid, &state->open_stateid)) { in nfs4_open_recover()
2281 write_seqlock(&state->seqlock); in nfs4_open_recover()
2282 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) in nfs4_open_recover()
2283 nfs4_stateid_copy(&state->stateid, &state->open_stateid); in nfs4_open_recover()
2284 write_sequnlock(&state->seqlock); in nfs4_open_recover()
2305 delegation = rcu_dereference(NFS_I(state->inode)->delegation); in _nfs4_do_open_reclaim()
2306 if (delegation != NULL && test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) != 0) { in _nfs4_do_open_reclaim()
2307 switch(delegation->type) { in _nfs4_do_open_reclaim()
2310 if (test_bit(NFS_DELEGATION_DELEGTIME, &delegation->flags)) in _nfs4_do_open_reclaim()
2316 if (test_bit(NFS_DELEGATION_DELEGTIME, &delegation->flags)) in _nfs4_do_open_reclaim()
2321 opendata->o_arg.u.delegation_type = delegation_type; in _nfs4_do_open_reclaim()
2329 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_do_open_reclaim()
2337 if (err != -NFS4ERR_DELAY) in nfs4_do_open_reclaim()
2351 return -EAGAIN; in nfs4_open_reclaim()
2352 clear_bit(NFS_DELEGATED_STATE, &state->flags); in nfs4_open_reclaim()
2367 case -ENOENT: in nfs4_handle_delegation_recall_error()
2368 case -EAGAIN: in nfs4_handle_delegation_recall_error()
2369 case -ESTALE: in nfs4_handle_delegation_recall_error()
2370 case -ETIMEDOUT: in nfs4_handle_delegation_recall_error()
2372 case -NFS4ERR_BADSESSION: in nfs4_handle_delegation_recall_error()
2373 case -NFS4ERR_BADSLOT: in nfs4_handle_delegation_recall_error()
2374 case -NFS4ERR_BAD_HIGH_SLOT: in nfs4_handle_delegation_recall_error()
2375 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: in nfs4_handle_delegation_recall_error()
2376 case -NFS4ERR_DEADSESSION: in nfs4_handle_delegation_recall_error()
2377 return -EAGAIN; in nfs4_handle_delegation_recall_error()
2378 case -NFS4ERR_STALE_CLIENTID: in nfs4_handle_delegation_recall_error()
2379 case -NFS4ERR_STALE_STATEID: in nfs4_handle_delegation_recall_error()
2380 /* Don't recall a delegation if it was lost */ in nfs4_handle_delegation_recall_error()
2381 nfs4_schedule_lease_recovery(server->nfs_client); in nfs4_handle_delegation_recall_error()
2382 return -EAGAIN; in nfs4_handle_delegation_recall_error()
2383 case -NFS4ERR_MOVED: in nfs4_handle_delegation_recall_error()
2385 return -EAGAIN; in nfs4_handle_delegation_recall_error()
2386 case -NFS4ERR_LEASE_MOVED: in nfs4_handle_delegation_recall_error()
2387 nfs4_schedule_lease_moved_recovery(server->nfs_client); in nfs4_handle_delegation_recall_error()
2388 return -EAGAIN; in nfs4_handle_delegation_recall_error()
2389 case -NFS4ERR_DELEG_REVOKED: in nfs4_handle_delegation_recall_error()
2390 case -NFS4ERR_ADMIN_REVOKED: in nfs4_handle_delegation_recall_error()
2391 case -NFS4ERR_EXPIRED: in nfs4_handle_delegation_recall_error()
2392 case -NFS4ERR_BAD_STATEID: in nfs4_handle_delegation_recall_error()
2393 case -NFS4ERR_OPENMODE: in nfs4_handle_delegation_recall_error()
2394 nfs_inode_find_state_and_recover(state->inode, in nfs4_handle_delegation_recall_error()
2397 return -EAGAIN; in nfs4_handle_delegation_recall_error()
2398 case -NFS4ERR_DELAY: in nfs4_handle_delegation_recall_error()
2399 case -NFS4ERR_GRACE: in nfs4_handle_delegation_recall_error()
2401 return -EAGAIN; in nfs4_handle_delegation_recall_error()
2402 case -ENOMEM: in nfs4_handle_delegation_recall_error()
2403 case -NFS4ERR_DENIED: in nfs4_handle_delegation_recall_error()
2405 struct nfs4_lock_state *lsp = fl->fl_u.nfs4_fl.owner; in nfs4_handle_delegation_recall_error()
2407 set_bit(NFS_LOCK_LOST, &lsp->ls_flags); in nfs4_handle_delegation_recall_error()
2417 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_open_delegation_recall()
2425 nfs4_stateid_copy(&opendata->o_arg.u.delegation, stateid); in nfs4_open_delegation_recall()
2426 if (!test_bit(NFS_O_RDWR_STATE, &state->flags)) { in nfs4_open_delegation_recall()
2431 if (!test_bit(NFS_O_WRONLY_STATE, &state->flags)) { in nfs4_open_delegation_recall()
2436 if (!test_bit(NFS_O_RDONLY_STATE, &state->flags)) { in nfs4_open_delegation_recall()
2451 nfs4_setup_sequence(data->o_arg.server->nfs_client, in nfs4_open_confirm_prepare()
2452 &data->c_arg.seq_args, &data->c_res.seq_res, task); in nfs4_open_confirm_prepare()
2459 nfs40_sequence_done(task, &data->c_res.seq_res); in nfs4_open_confirm_done()
2461 data->rpc_status = task->tk_status; in nfs4_open_confirm_done()
2462 if (data->rpc_status == 0) { in nfs4_open_confirm_done()
2463 nfs4_stateid_copy(&data->o_res.stateid, &data->c_res.stateid); in nfs4_open_confirm_done()
2464 nfs_confirm_seqid(&data->owner->so_seqid, 0); in nfs4_open_confirm_done()
2465 renew_lease(data->o_res.server, data->timestamp); in nfs4_open_confirm_done()
2466 data->rpc_done = true; in nfs4_open_confirm_done()
2476 if (!data->cancelled) in nfs4_open_confirm_release()
2479 if (!data->rpc_done) in nfs4_open_confirm_release()
2483 nfs4_close_state(state, data->o_arg.fmode); in nfs4_open_confirm_release()
2499 struct nfs_server *server = NFS_SERVER(d_inode(data->dir)); in _nfs4_proc_open_confirm()
2503 .rpc_argp = &data->c_arg, in _nfs4_proc_open_confirm()
2504 .rpc_resp = &data->c_res, in _nfs4_proc_open_confirm()
2505 .rpc_cred = data->owner->so_cred, in _nfs4_proc_open_confirm()
2508 .rpc_client = server->client, in _nfs4_proc_open_confirm()
2517 nfs4_init_sequence(&data->c_arg.seq_args, &data->c_res.seq_res, 1, in _nfs4_proc_open_confirm()
2518 data->is_recover); in _nfs4_proc_open_confirm()
2519 kref_get(&data->kref); in _nfs4_proc_open_confirm()
2520 data->rpc_done = false; in _nfs4_proc_open_confirm()
2521 data->rpc_status = 0; in _nfs4_proc_open_confirm()
2522 data->timestamp = jiffies; in _nfs4_proc_open_confirm()
2528 data->cancelled = true; in _nfs4_proc_open_confirm()
2531 status = data->rpc_status; in _nfs4_proc_open_confirm()
2539 struct nfs4_state_owner *sp = data->owner; in nfs4_open_prepare()
2540 struct nfs_client *clp = sp->so_server->nfs_client; in nfs4_open_prepare()
2541 enum open_claim_type4 claim = data->o_arg.claim; in nfs4_open_prepare()
2543 if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0) in nfs4_open_prepare()
2549 if (data->state != NULL) { in nfs4_open_prepare()
2552 if (can_open_cached(data->state, data->o_arg.fmode, in nfs4_open_prepare()
2553 data->o_arg.open_flags, claim)) in nfs4_open_prepare()
2556 delegation = nfs4_get_valid_delegation(data->state->inode); in nfs4_open_prepare()
2557 if (can_open_delegated(delegation, data->o_arg.fmode, claim)) in nfs4_open_prepare()
2562 data->o_arg.clientid = clp->cl_clientid; in nfs4_open_prepare()
2569 data->o_arg.open_bitmap = &nfs4_open_noattr_bitmap[0]; in nfs4_open_prepare()
2572 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR]; in nfs4_open_prepare()
2574 data->timestamp = jiffies; in nfs4_open_prepare()
2575 if (nfs4_setup_sequence(data->o_arg.server->nfs_client, in nfs4_open_prepare()
2576 &data->o_arg.seq_args, in nfs4_open_prepare()
2577 &data->o_res.seq_res, in nfs4_open_prepare()
2579 nfs_release_seqid(data->o_arg.seqid); in nfs4_open_prepare()
2582 data->o_arg.createmode = NFS4_CREATE_UNCHECKED; in nfs4_open_prepare()
2583 if (data->o_arg.open_flags & O_EXCL) { in nfs4_open_prepare()
2584 data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE4_1; in nfs4_open_prepare()
2585 if (clp->cl_mvops->minor_version == 0) { in nfs4_open_prepare()
2586 data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE; in nfs4_open_prepare()
2590 data->o_res.access_request = data->o_arg.access = 0; in nfs4_open_prepare()
2592 data->o_arg.createmode = NFS4_CREATE_GUARDED; in nfs4_open_prepare()
2596 trace_nfs4_cached_open(data->state); in nfs4_open_prepare()
2599 task->tk_action = NULL; in nfs4_open_prepare()
2601 nfs4_sequence_done(task, &data->o_res.seq_res); in nfs4_open_prepare()
2608 data->rpc_status = task->tk_status; in nfs4_open_done()
2610 if (!nfs4_sequence_process(task, &data->o_res.seq_res)) in nfs4_open_done()
2613 if (task->tk_status == 0) { in nfs4_open_done()
2614 if (data->o_res.f_attr->valid & NFS_ATTR_FATTR_TYPE) { in nfs4_open_done()
2615 switch (data->o_res.f_attr->mode & S_IFMT) { in nfs4_open_done()
2619 data->rpc_status = -ELOOP; in nfs4_open_done()
2622 data->rpc_status = -EISDIR; in nfs4_open_done()
2625 data->rpc_status = -ENOTDIR; in nfs4_open_done()
2628 renew_lease(data->o_res.server, data->timestamp); in nfs4_open_done()
2629 if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)) in nfs4_open_done()
2630 nfs_confirm_seqid(&data->owner->so_seqid, 0); in nfs4_open_done()
2632 data->rpc_done = true; in nfs4_open_done()
2641 if (data->rpc_status != 0 || !data->rpc_done) { in nfs4_open_release()
2642 nfs_release_seqid(data->o_arg.seqid); in nfs4_open_release()
2646 if (!data->cancelled) in nfs4_open_release()
2649 if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM) in nfs4_open_release()
2653 nfs4_close_state(state, data->o_arg.fmode); in nfs4_open_release()
2667 struct inode *dir = d_inode(data->dir); in nfs4_run_open_task()
2669 struct nfs_openargs *o_arg = &data->o_arg; in nfs4_run_open_task()
2670 struct nfs_openres *o_res = &data->o_res; in nfs4_run_open_task()
2676 .rpc_cred = data->owner->so_cred, in nfs4_run_open_task()
2679 .rpc_client = server->client, in nfs4_run_open_task()
2691 kref_get(&data->kref); in nfs4_run_open_task()
2692 data->rpc_done = false; in nfs4_run_open_task()
2693 data->rpc_status = 0; in nfs4_run_open_task()
2694 data->cancelled = false; in nfs4_run_open_task()
2695 data->is_recover = false; in nfs4_run_open_task()
2697 nfs4_init_sequence(&o_arg->seq_args, &o_res->seq_res, 1, 1); in nfs4_run_open_task()
2698 data->is_recover = true; in nfs4_run_open_task()
2701 nfs4_init_sequence(&o_arg->seq_args, &o_res->seq_res, 1, 0); in nfs4_run_open_task()
2709 data->cancelled = true; in nfs4_run_open_task()
2712 status = data->rpc_status; in nfs4_run_open_task()
2720 struct inode *dir = d_inode(data->dir); in _nfs4_recover_proc_open()
2721 struct nfs_openres *o_res = &data->o_res; in _nfs4_recover_proc_open()
2725 if (status != 0 || !data->rpc_done) in _nfs4_recover_proc_open()
2728 nfs_fattr_map_and_free_names(NFS_SERVER(dir), &data->f_attr); in _nfs4_recover_proc_open()
2730 if (o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) in _nfs4_recover_proc_open()
2741 * Note that in the non-execute case, we want to turn off permission
2752 * support any access modes -- defer access call until later */ in nfs4_opendata_access()
2753 if (opendata->o_res.access_supported == 0) in nfs4_opendata_access()
2759 if (S_ISDIR(state->inode->i_mode)) in nfs4_opendata_access()
2763 } else if ((fmode & FMODE_READ) && !opendata->file_created) in nfs4_opendata_access()
2766 nfs_access_set_mask(&cache, opendata->o_res.access_result); in nfs4_opendata_access()
2767 nfs_access_add_cache(state->inode, &cache, cred); in nfs4_opendata_access()
2773 return -EACCES; in nfs4_opendata_access()
2782 struct inode *dir = d_inode(data->dir); in _nfs4_proc_open()
2784 struct nfs_openargs *o_arg = &data->o_arg; in _nfs4_proc_open()
2785 struct nfs_openres *o_res = &data->o_res; in _nfs4_proc_open()
2789 if (!data->rpc_done) in _nfs4_proc_open()
2792 if (status == -NFS4ERR_BADNAME && in _nfs4_proc_open()
2793 !(o_arg->open_flags & O_CREAT)) in _nfs4_proc_open()
2794 return -ENOENT; in _nfs4_proc_open()
2798 nfs_fattr_map_and_free_names(server, &data->f_attr); in _nfs4_proc_open()
2800 if (o_arg->open_flags & O_CREAT) { in _nfs4_proc_open()
2801 if (o_arg->open_flags & O_EXCL) in _nfs4_proc_open()
2802 data->file_created = true; in _nfs4_proc_open()
2803 else if (o_res->cinfo.before != o_res->cinfo.after) in _nfs4_proc_open()
2804 data->file_created = true; in _nfs4_proc_open()
2805 if (data->file_created || in _nfs4_proc_open()
2806 inode_peek_iversion_raw(dir) != o_res->cinfo.after) in _nfs4_proc_open()
2807 nfs4_update_changeattr(dir, &o_res->cinfo, in _nfs4_proc_open()
2808 o_res->f_attr->time_start, in _nfs4_proc_open()
2811 if ((o_res->rflags & NFS4_OPEN_RESULT_LOCKTYPE_POSIX) == 0) in _nfs4_proc_open()
2812 server->caps &= ~NFS_CAP_POSIX_LOCK; in _nfs4_proc_open()
2813 if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) { in _nfs4_proc_open()
2818 if (!(o_res->f_attr->valid & NFS_ATTR_FATTR)) { in _nfs4_proc_open()
2819 struct nfs_fh *fh = &o_res->fh; in _nfs4_proc_open()
2821 nfs4_sequence_free_slot(&o_res->seq_res); in _nfs4_proc_open()
2822 if (o_arg->claim == NFS4_OPEN_CLAIM_FH) in _nfs4_proc_open()
2823 fh = NFS_FH(d_inode(data->dentry)); in _nfs4_proc_open()
2824 nfs4_proc_getattr(server, fh, o_res->f_attr, NULL); in _nfs4_proc_open()
2847 opendata->o_arg.open_flags = O_DIRECT; in _nfs4_open_expired()
2849 if (ret == -ESTALE) in _nfs4_open_expired()
2850 d_drop(ctx->dentry); in _nfs4_open_expired()
2857 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_do_open_expired()
2869 case -NFS4ERR_GRACE: in nfs4_do_open_expired()
2870 case -NFS4ERR_DELAY: in nfs4_do_open_expired()
2886 return -EAGAIN; in nfs4_open_expired()
2895 nfs_remove_bad_delegation(state->inode, stateid); in nfs_finish_clear_delegation_stateid()
2901 if (rcu_access_pointer(NFS_I(state->inode)->delegation) != NULL) in nfs40_clear_delegation_stateid()
2916 return -NFS4ERR_BAD_STATEID; in nfs40_test_and_free_expired_stateid()
2925 switch (stateid->type) { in nfs41_test_and_free_expired_stateid()
2931 return -NFS4ERR_BAD_STATEID; in nfs41_test_and_free_expired_stateid()
2938 case -NFS4ERR_EXPIRED: in nfs41_test_and_free_expired_stateid()
2939 case -NFS4ERR_ADMIN_REVOKED: in nfs41_test_and_free_expired_stateid()
2940 case -NFS4ERR_DELEG_REVOKED: in nfs41_test_and_free_expired_stateid()
2948 return -NFS4ERR_EXPIRED; in nfs41_test_and_free_expired_stateid()
2953 struct nfs_server *server = NFS_SERVER(state->inode); in nfs41_check_delegation_stateid()
2961 delegation = rcu_dereference(NFS_I(state->inode)->delegation); in nfs41_check_delegation_stateid()
2968 spin_lock(&delegation->lock); in nfs41_check_delegation_stateid()
2969 nfs4_stateid_copy(&stateid, &delegation->stateid); in nfs41_check_delegation_stateid()
2972 &delegation->flags)) { in nfs41_check_delegation_stateid()
2973 spin_unlock(&delegation->lock); in nfs41_check_delegation_stateid()
2978 if (delegation->cred) in nfs41_check_delegation_stateid()
2979 cred = get_cred(delegation->cred); in nfs41_check_delegation_stateid()
2980 spin_unlock(&delegation->lock); in nfs41_check_delegation_stateid()
2984 if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID) in nfs41_check_delegation_stateid()
2997 if (test_bit(NFS_DELEGATED_STATE, &state->flags) && in nfs41_delegation_recover_stateid()
2998 nfs4_copy_delegation_stateid(state->inode, state->state, in nfs41_delegation_recover_stateid()
3000 nfs4_stateid_match_other(&state->stateid, &tmp)) in nfs41_delegation_recover_stateid()
3001 nfs_state_set_delegation(state, &tmp, state->state); in nfs41_delegation_recover_stateid()
3007 * nfs41_check_expired_locks - possibly free a lock stateid
3018 struct nfs_server *server = NFS_SERVER(state->inode); in nfs41_check_expired_locks()
3020 if (!test_bit(LK_STATE_IN_USE, &state->flags)) in nfs41_check_expired_locks()
3023 spin_lock(&state->state_lock); in nfs41_check_expired_locks()
3024 list_for_each_entry(lsp, &state->lock_states, ls_locks) { in nfs41_check_expired_locks()
3025 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) { in nfs41_check_expired_locks()
3026 const struct cred *cred = lsp->ls_state->owner->so_cred; in nfs41_check_expired_locks()
3028 refcount_inc(&lsp->ls_count); in nfs41_check_expired_locks()
3029 spin_unlock(&state->state_lock); in nfs41_check_expired_locks()
3035 &lsp->ls_stateid, in nfs41_check_expired_locks()
3038 if (status == -NFS4ERR_EXPIRED || in nfs41_check_expired_locks()
3039 status == -NFS4ERR_BAD_STATEID) { in nfs41_check_expired_locks()
3040 clear_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags); in nfs41_check_expired_locks()
3041 lsp->ls_stateid.type = NFS4_INVALID_STATEID_TYPE; in nfs41_check_expired_locks()
3043 set_bit(NFS_LOCK_LOST, &lsp->ls_flags); in nfs41_check_expired_locks()
3049 spin_lock(&state->state_lock); in nfs41_check_expired_locks()
3052 spin_unlock(&state->state_lock); in nfs41_check_expired_locks()
3059 * nfs41_check_open_stateid - possibly free an open stateid
3068 struct nfs_server *server = NFS_SERVER(state->inode); in nfs41_check_open_stateid()
3069 nfs4_stateid *stateid = &state->open_stateid; in nfs41_check_open_stateid()
3070 const struct cred *cred = state->owner->so_cred; in nfs41_check_open_stateid()
3073 if (test_bit(NFS_OPEN_STATE, &state->flags) == 0) in nfs41_check_open_stateid()
3074 return -NFS4ERR_BAD_STATEID; in nfs41_check_open_stateid()
3077 if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID) { in nfs41_check_open_stateid()
3079 stateid->type = NFS4_INVALID_STATEID_TYPE; in nfs41_check_open_stateid()
3083 return -NFS4ERR_OPENMODE; in nfs41_check_open_stateid()
3107 * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-*
3114 const __u32 *bitmask = opendata->o_arg.server->exclcreat_bitmask; in nfs4_exclusive_attrset()
3120 attrset[i] = opendata->o_res.attrset[i]; in nfs4_exclusive_attrset()
3121 if (opendata->o_arg.createmode == NFS4_CREATE_EXCLUSIVE4_1) in nfs4_exclusive_attrset()
3125 ret = (opendata->o_arg.createmode == NFS4_CREATE_EXCLUSIVE) ? in nfs4_exclusive_attrset()
3126 sattr->ia_valid : 0; in nfs4_exclusive_attrset()
3129 if (sattr->ia_valid & ATTR_ATIME_SET) in nfs4_exclusive_attrset()
3136 if (sattr->ia_valid & ATTR_MTIME_SET) in nfs4_exclusive_attrset()
3150 struct nfs4_state_owner *sp = opendata->owner; in _nfs4_open_and_get_state()
3151 struct nfs_server *server = sp->so_server; in _nfs4_open_and_get_state()
3155 struct inode *dir = d_inode(opendata->dir); in _nfs4_open_and_get_state()
3169 ctx->state = state; in _nfs4_open_and_get_state()
3170 if (server->caps & NFS_CAP_POSIX_LOCK) in _nfs4_open_and_get_state()
3171 set_bit(NFS_STATE_POSIX_LOCKS, &state->flags); in _nfs4_open_and_get_state()
3172 if (opendata->o_res.rflags & NFS4_OPEN_RESULT_MAY_NOTIFY_LOCK) in _nfs4_open_and_get_state()
3173 set_bit(NFS_STATE_MAY_NOTIFY_LOCK, &state->flags); in _nfs4_open_and_get_state()
3174 if (opendata->o_res.rflags & NFS4_OPEN_RESULT_PRESERVE_UNLINKED) in _nfs4_open_and_get_state()
3175 set_bit(NFS_INO_PRESERVE_UNLINKED, &NFS_I(state->inode)->flags); in _nfs4_open_and_get_state()
3177 dentry = opendata->dentry; in _nfs4_open_and_get_state()
3181 alias = d_splice_alias(igrab(state->inode), dentry); in _nfs4_open_and_get_state()
3182 /* d_splice_alias() can't fail here - it's a non-directory */ in _nfs4_open_and_get_state()
3184 dput(ctx->dentry); in _nfs4_open_and_get_state()
3185 ctx->dentry = dentry = alias; in _nfs4_open_and_get_state()
3189 switch(opendata->o_arg.claim) { in _nfs4_open_and_get_state()
3195 if (!opendata->rpc_done) in _nfs4_open_and_get_state()
3197 if (opendata->o_res.delegation.type != 0) in _nfs4_open_and_get_state()
3203 pnfs_parse_lgopen(state->inode, opendata->lgp, ctx); in _nfs4_open_and_get_state()
3205 ret = nfs4_opendata_access(sp->so_cred, opendata, state, acc_mode); in _nfs4_open_and_get_state()
3209 if (d_inode(dentry) == state->inode) in _nfs4_open_and_get_state()
3213 if (!opendata->cancelled) { in _nfs4_open_and_get_state()
3214 if (opendata->lgp) { in _nfs4_open_and_get_state()
3215 nfs4_lgopen_release(opendata->lgp); in _nfs4_open_and_get_state()
3216 opendata->lgp = NULL; in _nfs4_open_and_get_state()
3218 nfs4_sequence_free_slot(&opendata->o_res.seq_res); in _nfs4_open_and_get_state()
3236 struct dentry *dentry = ctx->dentry; in _nfs4_do_open()
3237 const struct cred *cred = ctx->cred; in _nfs4_do_open()
3238 struct nfs4_threshold **ctx_th = &ctx->mdsthreshold; in _nfs4_do_open()
3241 struct iattr *sattr = c->sattr; in _nfs4_do_open()
3242 struct nfs4_label *label = c->label; in _nfs4_do_open()
3246 status = -ENOMEM; in _nfs4_do_open()
3252 status = nfs4_client_recover_expired_lease(server->nfs_client); in _nfs4_do_open()
3257 status = -ENOMEM; in _nfs4_do_open()
3265 if (server->attr_bitmask[2] & FATTR4_WORD2_MDSTHRESHOLD) { in _nfs4_do_open()
3266 if (!opendata->f_attr.mdsthreshold) { in _nfs4_do_open()
3267 opendata->f_attr.mdsthreshold = pnfs_mdsthreshold_alloc(); in _nfs4_do_open()
3268 if (!opendata->f_attr.mdsthreshold) in _nfs4_do_open()
3271 opendata->o_arg.open_bitmap = &nfs4_pnfs_open_bitmap[0]; in _nfs4_do_open()
3274 opendata->state = nfs4_get_open_state(d_inode(dentry), sp); in _nfs4_do_open()
3279 state = ctx->state; in _nfs4_do_open()
3281 if ((opendata->o_arg.open_flags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL) && in _nfs4_do_open()
3282 (opendata->o_arg.createmode != NFS4_CREATE_GUARDED)) { in _nfs4_do_open()
3289 unsigned ia_old = sattr->ia_valid; in _nfs4_do_open()
3291 sattr->ia_valid = attrs; in _nfs4_do_open()
3292 nfs_fattr_init(opendata->o_res.f_attr); in _nfs4_do_open()
3293 status = nfs4_do_setattr(state->inode, cred, in _nfs4_do_open()
3294 opendata->o_res.f_attr, sattr, in _nfs4_do_open()
3297 nfs_setattr_update_inode(state->inode, sattr, in _nfs4_do_open()
3298 opendata->o_res.f_attr); in _nfs4_do_open()
3299 nfs_setsecurity(state->inode, opendata->o_res.f_attr); in _nfs4_do_open()
3301 sattr->ia_valid = ia_old; in _nfs4_do_open()
3304 if (opened && opendata->file_created) in _nfs4_do_open()
3307 if (pnfs_use_threshold(ctx_th, opendata->f_attr.mdsthreshold, server)) { in _nfs4_do_open()
3308 *ctx_th = opendata->f_attr.mdsthreshold; in _nfs4_do_open()
3309 opendata->f_attr.mdsthreshold = NULL; in _nfs4_do_open()
3341 [1] = (__u32)current->pid, in nfs4_do_open()
3348 res = ctx->state; in nfs4_do_open()
3353 * book-keeping w.r.t. state-changing operations in nfs4_do_open()
3363 if (status == -NFS4ERR_BAD_SEQID) { in nfs4_do_open()
3365 " returned a bad sequence-id error!\n", in nfs4_do_open()
3366 NFS_SERVER(dir)->nfs_client->cl_hostname); in nfs4_do_open()
3376 if (status == -NFS4ERR_BAD_STATEID) { in nfs4_do_open()
3380 if (status == -NFS4ERR_EXPIRED) { in nfs4_do_open()
3381 nfs4_schedule_lease_recovery(server->nfs_client); in nfs4_do_open()
3385 if (status == -EAGAIN) { in nfs4_do_open()
3416 nfs_fattr_init(res->fattr); in _nfs4_do_setattr()
3419 truncate = (arg->iap->ia_valid & ATTR_SIZE) ? true : false; in _nfs4_do_setattr()
3425 if (nfs4_copy_delegation_stateid(inode, FMODE_WRITE, &arg->stateid, &delegation_cred)) { in _nfs4_do_setattr()
3427 } else if (ctx != NULL && ctx->state) { in _nfs4_do_setattr()
3429 if (!nfs4_valid_open_stateid(ctx->state)) in _nfs4_do_setattr()
3430 return -EBADF; in _nfs4_do_setattr()
3434 status = nfs4_select_rw_stateid(ctx->state, FMODE_WRITE, l_ctx, in _nfs4_do_setattr()
3435 &arg->stateid, &delegation_cred); in _nfs4_do_setattr()
3437 if (status == -EIO) in _nfs4_do_setattr()
3438 return -EBADF; in _nfs4_do_setattr()
3439 else if (status == -EAGAIN) in _nfs4_do_setattr()
3443 nfs4_stateid_copy(&arg->stateid, &zero_stateid); in _nfs4_do_setattr()
3448 status = nfs4_call_sync(server->client, server, &msg, &arg->seq_args, &res->seq_res, 1); in _nfs4_do_setattr()
3453 trace_nfs4_setattr(inode, &arg->stateid, status); in _nfs4_do_setattr()
3463 struct nfs4_state *state = ctx ? ctx->state : NULL; in nfs4_do_setattr()
3484 if (sattr->ia_valid & (ATTR_MODE | ATTR_KILL_SUID | ATTR_KILL_SGID)) in nfs4_do_setattr()
3486 if (sattr->ia_valid & (ATTR_UID | ATTR_GID)) in nfs4_do_setattr()
3488 if (sattr->ia_valid & ATTR_ATIME) in nfs4_do_setattr()
3490 if (sattr->ia_valid & ATTR_MTIME) in nfs4_do_setattr()
3494 nfs4_bitmap_copy_adjust(bitmask, nfs4_bitmask(server, fattr->label), in nfs4_do_setattr()
3499 case -NFS4ERR_OPENMODE: in nfs4_do_setattr()
3500 if (!(sattr->ia_valid & ATTR_SIZE)) { in nfs4_do_setattr()
3505 server->nfs_client->cl_hostname); in nfs4_do_setattr()
3507 if (state && !(state->state & FMODE_WRITE)) { in nfs4_do_setattr()
3508 err = -EBADF; in nfs4_do_setattr()
3509 if (sattr->ia_valid & ATTR_OPEN) in nfs4_do_setattr()
3510 err = -EACCES; in nfs4_do_setattr()
3542 seq = read_seqbegin(&state->seqlock); in nfs4_sync_open_stateid()
3544 nfs4_stateid_copy(dst, &state->open_stateid); in nfs4_sync_open_stateid()
3545 if (read_seqretry(&state->seqlock, seq)) in nfs4_sync_open_stateid()
3549 seqid_open = state->open_stateid.seqid; in nfs4_sync_open_stateid()
3550 if (read_seqretry(&state->seqlock, seq)) in nfs4_sync_open_stateid()
3553 dst_seqid = be32_to_cpu(dst->seqid); in nfs4_sync_open_stateid()
3554 if ((s32)(dst_seqid - be32_to_cpu(seqid_open)) < 0) in nfs4_sync_open_stateid()
3555 dst->seqid = seqid_open; in nfs4_sync_open_stateid()
3570 int seq, status = -EAGAIN; in nfs4_refresh_open_old_stateid()
3577 seq = read_seqbegin(&state->seqlock); in nfs4_refresh_open_old_stateid()
3579 if (read_seqretry(&state->seqlock, seq)) in nfs4_refresh_open_old_stateid()
3584 write_seqlock(&state->seqlock); in nfs4_refresh_open_old_stateid()
3585 seqid_open = state->open_stateid.seqid; in nfs4_refresh_open_old_stateid()
3587 dst_seqid = be32_to_cpu(dst->seqid); in nfs4_refresh_open_old_stateid()
3590 if ((s32)(be32_to_cpu(seqid_open) - dst_seqid) > 0) { in nfs4_refresh_open_old_stateid()
3591 dst->seqid = seqid_open; in nfs4_refresh_open_old_stateid()
3592 write_sequnlock(&state->seqlock); in nfs4_refresh_open_old_stateid()
3598 set_bit(NFS_STATE_CHANGE_WAIT, &state->flags); in nfs4_refresh_open_old_stateid()
3599 prepare_to_wait(&state->waitq, &wait, TASK_KILLABLE); in nfs4_refresh_open_old_stateid()
3600 write_sequnlock(&state->seqlock); in nfs4_refresh_open_old_stateid()
3601 trace_nfs4_close_stateid_update_wait(state->inode, dst, 0); in nfs4_refresh_open_old_stateid()
3604 status = -EINTR; in nfs4_refresh_open_old_stateid()
3609 finish_wait(&state->waitq, &wait); in nfs4_refresh_open_old_stateid()
3613 if (status == -EINTR) in nfs4_refresh_open_old_stateid()
3617 dst->seqid = cpu_to_be32(dst_seqid + 1); in nfs4_refresh_open_old_stateid()
3645 struct nfs4_state_owner *sp = calldata->state->owner; in nfs4_free_closedata()
3646 struct super_block *sb = calldata->state->inode->i_sb; in nfs4_free_closedata()
3648 if (calldata->lr.roc) in nfs4_free_closedata()
3649 pnfs_roc_release(&calldata->lr.arg, &calldata->lr.res, in nfs4_free_closedata()
3650 calldata->res.lr_ret); in nfs4_free_closedata()
3651 nfs4_put_open_state(calldata->state); in nfs4_free_closedata()
3652 nfs_free_seqid(calldata->arg.seqid); in nfs4_free_closedata()
3661 struct nfs4_state *state = calldata->state; in nfs4_close_done()
3662 struct nfs_server *server = NFS_SERVER(calldata->inode); in nfs4_close_done()
3666 .inode = calldata->inode, in nfs4_close_done()
3667 .stateid = &calldata->arg.stateid, in nfs4_close_done()
3668 .retrans = calldata->retrans, in nfs4_close_done()
3671 if (!nfs4_sequence_done(task, &calldata->res.seq_res)) in nfs4_close_done()
3673 trace_nfs4_close(state, &calldata->arg, &calldata->res, task->tk_status); in nfs4_close_done()
3676 if (pnfs_roc_done(task, &calldata->arg.lr_args, &calldata->res.lr_res, in nfs4_close_done()
3677 &calldata->res.lr_ret) == -EAGAIN) in nfs4_close_done()
3683 switch (task->tk_status) { in nfs4_close_done()
3685 res_stateid = &calldata->res.stateid; in nfs4_close_done()
3686 renew_lease(server, calldata->timestamp); in nfs4_close_done()
3688 case -NFS4ERR_ACCESS: in nfs4_close_done()
3689 if (calldata->arg.bitmask != NULL) { in nfs4_close_done()
3690 calldata->arg.bitmask = NULL; in nfs4_close_done()
3691 calldata->res.fattr = NULL; in nfs4_close_done()
3696 case -NFS4ERR_OLD_STATEID: in nfs4_close_done()
3698 if (nfs4_refresh_open_old_stateid(&calldata->arg.stateid, in nfs4_close_done()
3702 case -NFS4ERR_ADMIN_REVOKED: in nfs4_close_done()
3703 case -NFS4ERR_STALE_STATEID: in nfs4_close_done()
3704 case -NFS4ERR_EXPIRED: in nfs4_close_done()
3706 &calldata->arg.stateid, in nfs4_close_done()
3707 task->tk_msg.rpc_cred); in nfs4_close_done()
3709 case -NFS4ERR_BAD_STATEID: in nfs4_close_done()
3710 if (calldata->arg.fmode == 0) in nfs4_close_done()
3714 task->tk_status = nfs4_async_handle_exception(task, in nfs4_close_done()
3715 server, task->tk_status, &exception); in nfs4_close_done()
3716 calldata->retrans = exception.retrans; in nfs4_close_done()
3720 nfs_clear_open_stateid(state, &calldata->arg.stateid, in nfs4_close_done()
3721 res_stateid, calldata->arg.fmode); in nfs4_close_done()
3723 task->tk_status = 0; in nfs4_close_done()
3724 nfs_release_seqid(calldata->arg.seqid); in nfs4_close_done()
3725 nfs_refresh_inode(calldata->inode, &calldata->fattr); in nfs4_close_done()
3726 dprintk("%s: ret = %d\n", __func__, task->tk_status); in nfs4_close_done()
3729 task->tk_status = 0; in nfs4_close_done()
3737 struct nfs4_state *state = calldata->state; in nfs4_close_prepare()
3738 struct inode *inode = calldata->inode; in nfs4_close_prepare()
3744 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0) in nfs4_close_prepare()
3747 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; in nfs4_close_prepare()
3748 spin_lock(&state->owner->so_lock); in nfs4_close_prepare()
3749 is_rdwr = test_bit(NFS_O_RDWR_STATE, &state->flags); in nfs4_close_prepare()
3750 is_rdonly = test_bit(NFS_O_RDONLY_STATE, &state->flags); in nfs4_close_prepare()
3751 is_wronly = test_bit(NFS_O_WRONLY_STATE, &state->flags); in nfs4_close_prepare()
3753 calldata->arg.fmode = 0; in nfs4_close_prepare()
3754 if (state->n_rdwr == 0) { in nfs4_close_prepare()
3755 if (state->n_rdonly == 0) in nfs4_close_prepare()
3758 calldata->arg.fmode |= FMODE_READ; in nfs4_close_prepare()
3759 if (state->n_wronly == 0) in nfs4_close_prepare()
3762 calldata->arg.fmode |= FMODE_WRITE; in nfs4_close_prepare()
3763 if (calldata->arg.fmode != (FMODE_READ|FMODE_WRITE)) in nfs4_close_prepare()
3766 calldata->arg.fmode |= FMODE_READ|FMODE_WRITE; in nfs4_close_prepare()
3768 nfs4_sync_open_stateid(&calldata->arg.stateid, state); in nfs4_close_prepare()
3771 spin_unlock(&state->owner->so_lock); in nfs4_close_prepare()
3778 if (!calldata->lr.roc && nfs4_wait_on_layoutreturn(inode, task)) { in nfs4_close_prepare()
3779 nfs_release_seqid(calldata->arg.seqid); in nfs4_close_prepare()
3783 lo = calldata->arg.lr_args ? calldata->arg.lr_args->layout : NULL; in nfs4_close_prepare()
3785 calldata->arg.lr_args = NULL; in nfs4_close_prepare()
3786 calldata->res.lr_res = NULL; in nfs4_close_prepare()
3789 if (calldata->arg.fmode == 0) in nfs4_close_prepare()
3790 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE]; in nfs4_close_prepare()
3792 if (calldata->arg.fmode == 0 || calldata->arg.fmode == FMODE_READ) { in nfs4_close_prepare()
3793 /* Close-to-open cache consistency revalidation */ in nfs4_close_prepare()
3795 nfs4_bitmask_set(calldata->arg.bitmask_store, in nfs4_close_prepare()
3796 server->cache_consistency_bitmask, in nfs4_close_prepare()
3798 calldata->arg.bitmask = calldata->arg.bitmask_store; in nfs4_close_prepare()
3800 calldata->arg.bitmask = NULL; in nfs4_close_prepare()
3803 calldata->arg.share_access = in nfs4_close_prepare()
3804 nfs4_fmode_to_share_access(calldata->arg.fmode); in nfs4_close_prepare()
3806 if (calldata->res.fattr == NULL) in nfs4_close_prepare()
3807 calldata->arg.bitmask = NULL; in nfs4_close_prepare()
3808 else if (calldata->arg.bitmask == NULL) in nfs4_close_prepare()
3809 calldata->res.fattr = NULL; in nfs4_close_prepare()
3810 calldata->timestamp = jiffies; in nfs4_close_prepare()
3811 if (nfs4_setup_sequence(NFS_SERVER(inode)->nfs_client, in nfs4_close_prepare()
3812 &calldata->arg.seq_args, in nfs4_close_prepare()
3813 &calldata->res.seq_res, in nfs4_close_prepare()
3815 nfs_release_seqid(calldata->arg.seqid); in nfs4_close_prepare()
3818 task->tk_action = NULL; in nfs4_close_prepare()
3820 nfs4_sequence_done(task, &calldata->res.seq_res); in nfs4_close_prepare()
3830 * It is possible for data to be read/written from a mem-mapped file
3834 * NFSv4 citizens - we do not indicate to the server to update the file's
3838 * NOTE: Caller must be holding the sp->so_owner semaphore!
3842 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_do_close()
3845 struct nfs4_state_owner *sp = state->owner; in nfs4_do_close()
3849 .rpc_cred = state->owner->so_cred, in nfs4_do_close()
3852 .rpc_client = server->client, in nfs4_do_close()
3858 int status = -ENOMEM; in nfs4_do_close()
3860 if (nfs_server_capable(state->inode, NFS_CAP_MOVEABLE)) in nfs4_do_close()
3863 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_CLEANUP, in nfs4_do_close()
3869 nfs4_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 1, 0); in nfs4_do_close()
3870 calldata->inode = state->inode; in nfs4_do_close()
3871 calldata->state = state; in nfs4_do_close()
3872 calldata->arg.fh = NFS_FH(state->inode); in nfs4_do_close()
3873 if (!nfs4_copy_open_stateid(&calldata->arg.stateid, state)) in nfs4_do_close()
3876 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid; in nfs4_do_close()
3877 calldata->arg.seqid = alloc_seqid(&state->owner->so_seqid, gfp_mask); in nfs4_do_close()
3878 if (IS_ERR(calldata->arg.seqid)) in nfs4_do_close()
3880 nfs_fattr_init(&calldata->fattr); in nfs4_do_close()
3881 calldata->arg.fmode = 0; in nfs4_do_close()
3882 calldata->lr.arg.ld_private = &calldata->lr.ld_private; in nfs4_do_close()
3883 calldata->res.fattr = &calldata->fattr; in nfs4_do_close()
3884 calldata->res.seqid = calldata->arg.seqid; in nfs4_do_close()
3885 calldata->res.server = server; in nfs4_do_close()
3886 calldata->res.lr_ret = -NFS4ERR_NOMATCHING_LAYOUT; in nfs4_do_close()
3887 calldata->lr.roc = pnfs_roc(state->inode, in nfs4_do_close()
3888 &calldata->lr.arg, &calldata->lr.res, msg.rpc_cred); in nfs4_do_close()
3889 if (calldata->lr.roc) { in nfs4_do_close()
3890 calldata->arg.lr_args = &calldata->lr.arg; in nfs4_do_close()
3891 calldata->res.lr_res = &calldata->lr.res; in nfs4_do_close()
3893 nfs_sb_active(calldata->inode->i_sb); in nfs4_do_close()
3895 msg.rpc_argp = &calldata->arg; in nfs4_do_close()
3896 msg.rpc_resp = &calldata->res; in nfs4_do_close()
3921 label = nfs4_label_init_security(dir, ctx->dentry, attr, &l); in nfs4_atomic_open()
3930 return state->inode; in nfs4_atomic_open()
3935 struct dentry *dentry = ctx->dentry; in nfs4_close_context()
3936 if (ctx->state == NULL) in nfs4_close_context()
3938 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) in nfs4_close_context()
3941 nfs4_close_sync(ctx->state, _nfs4_ctx_to_openmode(ctx)); in nfs4_close_context()
3943 nfs4_close_state(ctx->state, _nfs4_ctx_to_openmode(ctx)); in nfs4_close_context()
3946 #define FATTR4_WORD1_NFS40_MASK (2*FATTR4_WORD1_MOUNTED_ON_FILEID - 1UL)
3947 #define FATTR4_WORD2_NFS41_MASK (2*FATTR4_WORD2_SUPPATTR_EXCLCREAT - 1UL)
3948 #define FATTR4_WORD2_NFS42_MASK (2*FATTR4_WORD2_OPEN_ARGUMENTS - 1UL)
3954 u32 share_access_want = res->open_caps.oa_share_access_want[0]; in nfs4_server_delegtime_capable()
3955 u32 attr_bitmask = res->attr_bitmask[2]; in nfs4_server_delegtime_capable()
3964 u32 minorversion = server->nfs_client->cl_minorversion; in _nfs4_server_capabilities()
3993 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_server_capabilities()
4020 memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask)); in _nfs4_server_capabilities()
4021 server->caps &= in _nfs4_server_capabilities()
4025 server->fattr_valid = NFS_ATTR_FATTR_V4; in _nfs4_server_capabilities()
4028 server->caps |= NFS_CAP_ACLS; in _nfs4_server_capabilities()
4030 server->caps |= NFS_CAP_HARDLINKS; in _nfs4_server_capabilities()
4032 server->caps |= NFS_CAP_SYMLINKS; in _nfs4_server_capabilities()
4034 server->caps |= NFS_CAP_CASE_INSENSITIVE; in _nfs4_server_capabilities()
4036 server->caps |= NFS_CAP_CASE_PRESERVING; in _nfs4_server_capabilities()
4039 server->caps |= NFS_CAP_SECURITY_LABEL; in _nfs4_server_capabilities()
4042 server->caps |= NFS_CAP_FS_LOCATIONS; in _nfs4_server_capabilities()
4044 server->fattr_valid &= ~NFS_ATTR_FATTR_FILEID; in _nfs4_server_capabilities()
4046 server->fattr_valid &= ~NFS_ATTR_FATTR_MODE; in _nfs4_server_capabilities()
4048 server->fattr_valid &= ~NFS_ATTR_FATTR_NLINK; in _nfs4_server_capabilities()
4050 server->fattr_valid &= ~(NFS_ATTR_FATTR_OWNER | in _nfs4_server_capabilities()
4053 server->fattr_valid &= ~(NFS_ATTR_FATTR_GROUP | in _nfs4_server_capabilities()
4056 server->fattr_valid &= ~NFS_ATTR_FATTR_SPACE_USED; in _nfs4_server_capabilities()
4058 server->fattr_valid &= ~NFS_ATTR_FATTR_ATIME; in _nfs4_server_capabilities()
4060 server->fattr_valid &= ~NFS_ATTR_FATTR_CTIME; in _nfs4_server_capabilities()
4062 server->fattr_valid &= ~NFS_ATTR_FATTR_MTIME; in _nfs4_server_capabilities()
4064 server->fattr_valid &= ~NFS_ATTR_FATTR_MTIME; in _nfs4_server_capabilities()
4066 server->fattr_valid &= ~NFS_ATTR_FATTR_BTIME; in _nfs4_server_capabilities()
4067 memcpy(server->attr_bitmask_nl, res.attr_bitmask, in _nfs4_server_capabilities()
4068 sizeof(server->attr_bitmask)); in _nfs4_server_capabilities()
4069 server->attr_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL; in _nfs4_server_capabilities()
4073 server->caps |= NFS_CAP_OPEN_XOR; in _nfs4_server_capabilities()
4075 server->caps |= NFS_CAP_DELEGTIME; in _nfs4_server_capabilities()
4077 …memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitma… in _nfs4_server_capabilities()
4078 server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE; in _nfs4_server_capabilities()
4079 server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY; in _nfs4_server_capabilities()
4080 server->cache_consistency_bitmask[2] = 0; in _nfs4_server_capabilities()
4085 memcpy(server->exclcreat_bitmask, res.exclcreat_bitmask, in _nfs4_server_capabilities()
4086 sizeof(server->exclcreat_bitmask)); in _nfs4_server_capabilities()
4088 server->acl_bitmask = res.acl_bitmask; in _nfs4_server_capabilities()
4089 server->fh_expire_type = res.fh_expire_type; in _nfs4_server_capabilities()
4116 for (i = 0; i < location->nservers; i++) { in test_fs_location_for_trunking()
4117 struct nfs4_string *srv_loc = &location->servers[i]; in test_fs_location_for_trunking()
4122 .net = clp->cl_net, in test_fs_location_for_trunking()
4128 .add_xprt_test = clp->cl_mvops->session_trunk, in test_fs_location_for_trunking()
4133 if (!srv_loc->len) in test_fs_location_for_trunking()
4136 addrlen = nfs_parse_server_name(srv_loc->data, srv_loc->len, in test_fs_location_for_trunking()
4138 clp->cl_net, server->port); in test_fs_location_for_trunking()
4143 servername = kmalloc(srv_loc->len + 1, GFP_KERNEL); in test_fs_location_for_trunking()
4146 memcpy(servername, srv_loc->data, srv_loc->len); in test_fs_location_for_trunking()
4147 servername[srv_loc->len] = '\0'; in test_fs_location_for_trunking()
4151 rpc_clnt_add_xprt(clp->cl_rpcclient, &xprt_args, in test_fs_location_for_trunking()
4165 if (path1->ncomponents != path2->ncomponents) in _is_same_nfs4_pathname()
4167 for (i = 0; i < path1->ncomponents; i++) { in _is_same_nfs4_pathname()
4168 if (path1->components[i].len != path2->components[i].len) in _is_same_nfs4_pathname()
4170 if (memcmp(path1->components[i].data, path2->components[i].data, in _is_same_nfs4_pathname()
4171 path1->components[i].len)) in _is_same_nfs4_pathname()
4183 struct nfs_client *clp = server->nfs_client; in _nfs4_discover_trunking()
4185 clp->cl_mvops->state_renewal_ops; in _nfs4_discover_trunking()
4186 int status = -ENOMEM, i; in _nfs4_discover_trunking()
4188 cred = ops->get_state_renewal_cred(clp); in _nfs4_discover_trunking()
4192 return -ENOKEY; in _nfs4_discover_trunking()
4201 locations->fattr = nfs_alloc_fattr(); in _nfs4_discover_trunking()
4202 if (!locations->fattr) in _nfs4_discover_trunking()
4210 for (i = 0; i < locations->nlocations; i++) { in _nfs4_discover_trunking()
4211 if (!_is_same_nfs4_pathname(&locations->fs_path, in _nfs4_discover_trunking()
4212 &locations->locations[i].rootpath)) in _nfs4_discover_trunking()
4214 test_fs_location_for_trunking(&locations->locations[i], clp, in _nfs4_discover_trunking()
4218 kfree(locations->fattr); in _nfs4_discover_trunking()
4234 struct nfs_client *clp = server->nfs_client; in nfs4_discover_trunking()
4270 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_lookup_root()
4285 case -NFS4ERR_WRONGSEC: in nfs4_lookup_root()
4304 auth = rpcauth_create(&auth_args, server->client); in nfs4_lookup_root_sec()
4306 return -EACCES; in nfs4_lookup_root_sec()
4330 int status = -EPERM; in nfs4_find_root_sec()
4333 if (server->auth_info.flavor_len > 0) { in nfs4_find_root_sec()
4335 for (i = 0; i < server->auth_info.flavor_len; i++) { in nfs4_find_root_sec()
4338 server->auth_info.flavors[i]); in nfs4_find_root_sec()
4339 if (status == -NFS4ERR_WRONGSEC || status == -EACCES) in nfs4_find_root_sec()
4348 if (status == -NFS4ERR_WRONGSEC || status == -EACCES) in nfs4_find_root_sec()
4355 * -EACCES could mean that the user doesn't have correct permissions in nfs4_find_root_sec()
4358 * existing mount programs don't handle -EACCES very well so it should in nfs4_find_root_sec()
4359 * be mapped to -EPERM instead. in nfs4_find_root_sec()
4361 if (status == -EACCES) in nfs4_find_root_sec()
4362 status = -EPERM; in nfs4_find_root_sec()
4367 * nfs4_proc_get_rootfh - get file handle for server's pseudoroot
4369 * @fhandle: we fill in the pseudo-fs root file handle
4384 status = server->nfs_client->cl_mvops->find_root_sec( in nfs4_proc_get_rootfh()
4394 struct nfs_fattr *fattr = info->fattr; in nfs4_proc_get_root()
4398 dprintk("nfs4_get_root: getcaps error = %d\n", -error); in nfs4_proc_get_root()
4404 dprintk("nfs4_get_root: getattr error = %d\n", -error); in nfs4_proc_get_root()
4408 if (fattr->valid & NFS_ATTR_FATTR_FSID && in nfs4_proc_get_root()
4409 !nfs_fsid_equal(&server->fsid, &fattr->fsid)) in nfs4_proc_get_root()
4410 memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid)); in nfs4_proc_get_root()
4425 int status = -ENOMEM; in nfs4_get_referral()
4436 locations->fattr = fattr; in nfs4_get_referral()
4447 if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &fattr->fsid)) { in nfs4_get_referral()
4449 " a referral at %s\n", __func__, name->name); in nfs4_get_referral()
4450 status = -NFS4ERR_MOVED; in nfs4_get_referral()
4482 if (nfs4_has_session(server->nfs_client)) in _nfs4_proc_getattr()
4486 if (inode && (server->flags & NFS_MOUNT_SOFTREVAL)) in _nfs4_proc_getattr()
4489 nfs4_bitmap_copy_adjust(bitmask, nfs4_bitmask(server, fattr->label), inode, 0); in _nfs4_proc_getattr()
4492 return nfs4_do_call_sync(server->client, server, &msg, in _nfs4_proc_getattr()
4515 * VFS layer lookup-intents are implemented.
4527 * This will be fixed with VFS changes (lookup-intent).
4539 sattr->ia_valid & ATTR_SIZE && in nfs4_proc_setattr()
4540 sattr->ia_size < i_size_read(inode)) in nfs4_proc_setattr()
4546 if (sattr->ia_valid & ATTR_OPEN) in nfs4_proc_setattr()
4547 sattr->ia_valid &= ~(ATTR_MTIME|ATTR_CTIME); in nfs4_proc_setattr()
4550 if ((sattr->ia_valid & ~(ATTR_FILE|ATTR_OPEN)) == 0) in nfs4_proc_setattr()
4554 if (sattr->ia_valid & ATTR_FILE) { in nfs4_proc_setattr()
4556 ctx = nfs_file_open_context(sattr->ia_file); in nfs4_proc_setattr()
4558 cred = ctx->cred; in nfs4_proc_setattr()
4562 if ((sattr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) in nfs4_proc_setattr()
4580 .bitmask = server->attr_bitmask, in _nfs4_proc_lookup()
4603 args.bitmask = nfs4_bitmask(server, fattr->label); in _nfs4_proc_lookup()
4617 fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE | in nfs_fixup_secinfo_attributes()
4619 fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO; in nfs_fixup_secinfo_attributes()
4620 fattr->nlink = 2; in nfs_fixup_secinfo_attributes()
4636 case -NFS4ERR_BADNAME: in nfs4_proc_lookup_common()
4637 err = -ENOENT; in nfs4_proc_lookup_common()
4639 case -NFS4ERR_MOVED: in nfs4_proc_lookup_common()
4641 if (err == -NFS4ERR_MOVED) in nfs4_proc_lookup_common()
4644 case -NFS4ERR_WRONGSEC: in nfs4_proc_lookup_common()
4645 err = -EPERM; in nfs4_proc_lookup_common()
4689 status = nfs4_proc_lookup_common(&client, dir, dentry, &dentry->d_name, in nfs4_proc_lookup_mountpoint()
4703 .bitmask = server->attr_bitmask, in _nfs4_proc_lookupp()
4718 if (NFS_SERVER(inode)->flags & NFS_MOUNT_SOFTREVAL) in _nfs4_proc_lookupp()
4721 args.bitmask = nfs4_bitmask(server, fattr->label); in _nfs4_proc_lookupp()
4725 dprintk("NFS call lookupp ino=0x%lx\n", inode->i_ino); in _nfs4_proc_lookupp()
4754 .access = entry->mask, in _nfs4_proc_access()
4770 return -ENOMEM; in _nfs4_proc_access()
4771 args.bitmask = server->cache_consistency_bitmask; in _nfs4_proc_access()
4773 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_proc_access()
4801 * along with any of the zero-copy operations READ, READDIR,
4805 * after the read-type operation -- this is because it is hard
4815 * the operation -- in this case because we want to make sure
4816 * we get the post-operation mtime and size.
4837 …return nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), &msg, &args.seq_args, &res.seq… in _nfs4_proc_readlink()
4857 * This is just for mknod. open(O_CREAT) will always do ->open_context().
4875 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK)) in nfs4_proc_create()
4876 sattr->ia_mode &= ~current_umask(); in nfs4_proc_create()
4907 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1); in _nfs4_proc_remove()
4909 spin_lock(&dir->i_lock); in _nfs4_proc_remove()
4911 if (ftype == NF4DIR && dir->i_nlink > 2) in _nfs4_proc_remove()
4915 spin_unlock(&dir->i_lock); in _nfs4_proc_remove()
4929 if (inode->i_nlink == 1) in nfs4_proc_remove()
4935 err = _nfs4_proc_remove(dir, &dentry->d_name, NF4REG); in nfs4_proc_remove()
4936 trace_nfs4_remove(dir, &dentry->d_name, err); in nfs4_proc_remove()
4963 struct nfs_removeargs *args = msg->rpc_argp; in nfs4_proc_unlink_setup()
4964 struct nfs_removeres *res = msg->rpc_resp; in nfs4_proc_unlink_setup()
4966 res->server = NFS_SB(dentry->d_sb); in nfs4_proc_unlink_setup()
4967 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE]; in nfs4_proc_unlink_setup()
4968 nfs4_init_sequence(&args->seq_args, &res->seq_res, 1, 0); in nfs4_proc_unlink_setup()
4970 nfs_fattr_init(res->dir_attr); in nfs4_proc_unlink_setup()
4980 nfs4_setup_sequence(NFS_SB(data->dentry->d_sb)->nfs_client, in nfs4_proc_unlink_rpc_prepare()
4981 &data->args.seq_args, in nfs4_proc_unlink_rpc_prepare()
4982 &data->res.seq_res, in nfs4_proc_unlink_rpc_prepare()
4988 struct nfs_unlinkdata *data = task->tk_calldata; in nfs4_proc_unlink_done()
4989 struct nfs_removeres *res = &data->res; in nfs4_proc_unlink_done()
4991 if (!nfs4_sequence_done(task, &res->seq_res)) in nfs4_proc_unlink_done()
4993 if (nfs4_async_handle_error(task, res->server, NULL, in nfs4_proc_unlink_done()
4994 &data->timeout) == -EAGAIN) in nfs4_proc_unlink_done()
4996 if (task->tk_status == 0) in nfs4_proc_unlink_done()
4997 nfs4_update_changeattr(dir, &res->cinfo, in nfs4_proc_unlink_done()
4998 res->dir_attr->time_start, in nfs4_proc_unlink_done()
5007 struct nfs_renameargs *arg = msg->rpc_argp; in nfs4_proc_rename_setup()
5008 struct nfs_renameres *res = msg->rpc_resp; in nfs4_proc_rename_setup()
5016 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME]; in nfs4_proc_rename_setup()
5017 res->server = NFS_SB(old_dentry->d_sb); in nfs4_proc_rename_setup()
5018 nfs4_init_sequence(&arg->seq_args, &res->seq_res, 1, 0); in nfs4_proc_rename_setup()
5023 nfs4_setup_sequence(NFS_SERVER(data->old_dir)->nfs_client, in nfs4_proc_rename_rpc_prepare()
5024 &data->args.seq_args, in nfs4_proc_rename_rpc_prepare()
5025 &data->res.seq_res, in nfs4_proc_rename_rpc_prepare()
5032 struct nfs_renamedata *data = task->tk_calldata; in nfs4_proc_rename_done()
5033 struct nfs_renameres *res = &data->res; in nfs4_proc_rename_done()
5035 if (!nfs4_sequence_done(task, &res->seq_res)) in nfs4_proc_rename_done()
5037 if (nfs4_async_handle_error(task, res->server, NULL, &data->timeout) == -EAGAIN) in nfs4_proc_rename_done()
5040 if (task->tk_status == 0) { in nfs4_proc_rename_done()
5041 nfs_d_prune_case_insensitive_aliases(d_inode(data->old_dentry)); in nfs4_proc_rename_done()
5044 nfs4_update_changeattr(old_dir, &res->old_cinfo, in nfs4_proc_rename_done()
5045 res->old_fattr->time_start, in nfs4_proc_rename_done()
5048 nfs4_update_changeattr(new_dir, &res->new_cinfo, in nfs4_proc_rename_done()
5049 res->new_fattr->time_start, in nfs4_proc_rename_done()
5053 nfs4_update_changeattr(old_dir, &res->old_cinfo, in nfs4_proc_rename_done()
5054 res->old_fattr->time_start, in nfs4_proc_rename_done()
5078 int status = -ENOMEM; in _nfs4_proc_link()
5085 nfs4_bitmap_copy_adjust(bitmask, nfs4_bitmask(server, res.fattr->label), in _nfs4_proc_link()
5088 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); in _nfs4_proc_link()
5090 nfs4_update_changeattr(dir, &res.cinfo, res.fattr->time_start, in _nfs4_proc_link()
5134 data->fattr.label = nfs4_label_alloc(server, GFP_KERNEL); in nfs4_alloc_createdata()
5135 if (IS_ERR(data->fattr.label)) in nfs4_alloc_createdata()
5138 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE]; in nfs4_alloc_createdata()
5139 data->msg.rpc_argp = &data->arg; in nfs4_alloc_createdata()
5140 data->msg.rpc_resp = &data->res; in nfs4_alloc_createdata()
5141 data->arg.dir_fh = NFS_FH(dir); in nfs4_alloc_createdata()
5142 data->arg.server = server; in nfs4_alloc_createdata()
5143 data->arg.name = name; in nfs4_alloc_createdata()
5144 data->arg.attrs = sattr; in nfs4_alloc_createdata()
5145 data->arg.ftype = ftype; in nfs4_alloc_createdata()
5146 data->arg.bitmask = nfs4_bitmask(server, data->fattr.label); in nfs4_alloc_createdata()
5147 data->arg.umask = current_umask(); in nfs4_alloc_createdata()
5148 data->res.server = server; in nfs4_alloc_createdata()
5149 data->res.fh = &data->fh; in nfs4_alloc_createdata()
5150 data->res.fattr = &data->fattr; in nfs4_alloc_createdata()
5151 nfs_fattr_init(data->res.fattr); in nfs4_alloc_createdata()
5161 int status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &data->msg, in nfs4_do_create()
5162 &data->arg.seq_args, &data->res.seq_res, 1); in nfs4_do_create()
5164 spin_lock(&dir->i_lock); in nfs4_do_create()
5165 nfs4_update_changeattr_locked(dir, &data->res.dir_cinfo, in nfs4_do_create()
5166 data->res.fattr->time_start, in nfs4_do_create()
5168 spin_unlock(&dir->i_lock); in nfs4_do_create()
5169 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr); in nfs4_do_create()
5179 *statusp = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &data->msg, in nfs4_do_mkdir()
5180 &data->arg.seq_args, &data->res.seq_res, 1); in nfs4_do_mkdir()
5185 spin_lock(&dir->i_lock); in nfs4_do_mkdir()
5188 nfs4_update_changeattr_locked(dir, &data->res.dir_cinfo, in nfs4_do_mkdir()
5189 data->res.fattr->time_start, in nfs4_do_mkdir()
5191 spin_unlock(&dir->i_lock); in nfs4_do_mkdir()
5192 ret = nfs_add_or_obtain(dentry, data->res.fh, data->res.fattr); in nfs4_do_mkdir()
5201 nfs4_label_free(data->fattr.label); in nfs4_free_createdata()
5209 struct page *page = &folio->page; in _nfs4_proc_symlink()
5211 int status = -ENAMETOOLONG; in _nfs4_proc_symlink()
5216 status = -ENOMEM; in _nfs4_proc_symlink()
5217 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4LNK); in _nfs4_proc_symlink()
5221 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK]; in _nfs4_proc_symlink()
5222 data->arg.u.symlink.pages = &page; in _nfs4_proc_symlink()
5223 data->arg.u.symlink.len = len; in _nfs4_proc_symlink()
5224 data->arg.label = label; in _nfs4_proc_symlink()
5246 trace_nfs4_symlink(dir, &dentry->d_name, err); in nfs4_proc_symlink()
5262 *statusp = -ENOMEM; in _nfs4_proc_mkdir()
5263 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4DIR); in _nfs4_proc_mkdir()
5267 data->arg.label = label; in _nfs4_proc_mkdir()
5288 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK)) in nfs4_proc_mkdir()
5289 sattr->ia_mode &= ~current_umask(); in nfs4_proc_mkdir()
5292 trace_nfs4_mkdir(dir, &dentry->d_name, err); in nfs4_proc_mkdir()
5306 struct inode *dir = d_inode(nr_arg->dentry); in _nfs4_proc_readdir()
5310 .pages = nr_arg->pages, in _nfs4_proc_readdir()
5312 .count = nr_arg->page_len, in _nfs4_proc_readdir()
5313 .plus = nr_arg->plus, in _nfs4_proc_readdir()
5320 .rpc_cred = nr_arg->cred, in _nfs4_proc_readdir()
5325 nr_arg->dentry, (unsigned long long)nr_arg->cookie); in _nfs4_proc_readdir()
5326 if (!(server->caps & NFS_CAP_SECURITY_LABEL)) in _nfs4_proc_readdir()
5327 args.bitmask = server->attr_bitmask_nl; in _nfs4_proc_readdir()
5329 args.bitmask = server->attr_bitmask; in _nfs4_proc_readdir()
5331 nfs4_setup_readdir(nr_arg->cookie, nr_arg->verf, nr_arg->dentry, &args); in _nfs4_proc_readdir()
5333 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, in _nfs4_proc_readdir()
5336 memcpy(nr_res->verf, res.verifier.data, NFS4_VERIFIER_SIZE); in _nfs4_proc_readdir()
5355 trace_nfs4_readdir(d_inode(arg->dentry), err); in nfs4_proc_readdir()
5356 err = nfs4_handle_exception(NFS_SERVER(d_inode(arg->dentry)), in nfs4_proc_readdir()
5366 int mode = sattr->ia_mode; in _nfs4_proc_mknod()
5367 int status = -ENOMEM; in _nfs4_proc_mknod()
5369 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4SOCK); in _nfs4_proc_mknod()
5374 data->arg.ftype = NF4FIFO; in _nfs4_proc_mknod()
5376 data->arg.ftype = NF4BLK; in _nfs4_proc_mknod()
5377 data->arg.u.device.specdata1 = MAJOR(rdev); in _nfs4_proc_mknod()
5378 data->arg.u.device.specdata2 = MINOR(rdev); in _nfs4_proc_mknod()
5381 data->arg.ftype = NF4CHR; in _nfs4_proc_mknod()
5382 data->arg.u.device.specdata1 = MAJOR(rdev); in _nfs4_proc_mknod()
5383 data->arg.u.device.specdata2 = MINOR(rdev); in _nfs4_proc_mknod()
5385 status = -EINVAL; in _nfs4_proc_mknod()
5389 data->arg.label = label; in _nfs4_proc_mknod()
5409 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK)) in nfs4_proc_mknod()
5410 sattr->ia_mode &= ~current_umask(); in nfs4_proc_mknod()
5413 trace_nfs4_mknod(dir, &dentry->d_name, err); in nfs4_proc_mknod()
5428 .bitmask = server->attr_bitmask, in _nfs4_proc_statfs()
5439 nfs_fattr_init(fsstat->fattr); in _nfs4_proc_statfs()
5440 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_proc_statfs()
5462 .bitmask = server->attr_bitmask, in _nfs4_do_fsinfo()
5473 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_do_fsinfo()
5485 trace_nfs4_fsinfo(server, fhandle, fsinfo->fattr, err); in nfs4_do_fsinfo()
5487 nfs4_set_lease_period(server->nfs_client, fsinfo->lease_time * HZ); in nfs4_do_fsinfo()
5499 nfs_fattr_init(fsinfo->fattr); in nfs4_proc_fsinfo()
5503 server->pnfs_blksize = fsinfo->blksize; in nfs4_proc_fsinfo()
5515 .bitmask = server->attr_bitmask, in _nfs4_proc_pathconf()
5532 nfs_fattr_init(pathconf->fattr); in _nfs4_proc_pathconf()
5533 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_proc_pathconf()
5557 return nfs4_select_rw_stateid(ctx->state, fmode, l_ctx, stateid, NULL); in nfs4_set_rw_stateid()
5569 if (nfs4_set_rw_stateid(&_current_stateid, ctx, l_ctx, fmode) == -EIO) in nfs4_stateid_is_current()
5577 case -NFS4ERR_DELEG_REVOKED: in nfs4_error_stateid_expired()
5578 case -NFS4ERR_ADMIN_REVOKED: in nfs4_error_stateid_expired()
5579 case -NFS4ERR_BAD_STATEID: in nfs4_error_stateid_expired()
5580 case -NFS4ERR_STALE_STATEID: in nfs4_error_stateid_expired()
5581 case -NFS4ERR_OLD_STATEID: in nfs4_error_stateid_expired()
5582 case -NFS4ERR_OPENMODE: in nfs4_error_stateid_expired()
5583 case -NFS4ERR_EXPIRED: in nfs4_error_stateid_expired()
5591 struct nfs_server *server = NFS_SERVER(hdr->inode); in nfs4_read_done_cb()
5593 trace_nfs4_read(hdr, task->tk_status); in nfs4_read_done_cb()
5594 if (task->tk_status < 0) { in nfs4_read_done_cb()
5596 .inode = hdr->inode, in nfs4_read_done_cb()
5597 .state = hdr->args.context->state, in nfs4_read_done_cb()
5598 .stateid = &hdr->args.stateid, in nfs4_read_done_cb()
5599 .retrans = hdr->retrans, in nfs4_read_done_cb()
5601 task->tk_status = nfs4_async_handle_exception(task, in nfs4_read_done_cb()
5602 server, task->tk_status, &exception); in nfs4_read_done_cb()
5603 hdr->retrans = exception.retrans; in nfs4_read_done_cb()
5606 return -EAGAIN; in nfs4_read_done_cb()
5610 if (task->tk_status > 0) in nfs4_read_done_cb()
5611 renew_lease(server, hdr->timestamp); in nfs4_read_done_cb()
5619 if (!nfs4_error_stateid_expired(task->tk_status) || in nfs4_read_stateid_changed()
5620 nfs4_stateid_is_current(&args->stateid, in nfs4_read_stateid_changed()
5621 args->context, in nfs4_read_stateid_changed()
5622 args->lock_context, in nfs4_read_stateid_changed()
5632 struct nfs_server *server = NFS_SERVER(hdr->inode); in nfs4_read_plus_not_supported()
5633 struct rpc_message *msg = &task->tk_msg; in nfs4_read_plus_not_supported()
5635 if (msg->rpc_proc == &nfs4_procedures[NFSPROC4_CLNT_READ_PLUS] && in nfs4_read_plus_not_supported()
5636 task->tk_status == -ENOTSUPP) { in nfs4_read_plus_not_supported()
5637 server->caps &= ~NFS_CAP_READ_PLUS; in nfs4_read_plus_not_supported()
5638 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ]; in nfs4_read_plus_not_supported()
5647 if (!nfs4_sequence_done(task, &hdr->res.seq_res)) in nfs4_read_done()
5648 return -EAGAIN; in nfs4_read_done()
5649 if (nfs4_read_stateid_changed(task, &hdr->args)) in nfs4_read_done()
5650 return -EAGAIN; in nfs4_read_done()
5652 return -EAGAIN; in nfs4_read_done()
5653 if (task->tk_status > 0) in nfs4_read_done()
5654 nfs_invalidate_atime(hdr->inode); in nfs4_read_done()
5655 return hdr->pgio_done_cb ? hdr->pgio_done_cb(task, hdr) : in nfs4_read_done()
5664 if (nfs_server_capable(hdr->inode, NFS_CAP_READ_PLUS) && !hdr->ds_clp) { in nfs42_read_plus_support()
5665 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ_PLUS]; in nfs42_read_plus_support()
5681 hdr->timestamp = jiffies; in nfs4_proc_read_setup()
5682 if (!hdr->pgio_done_cb) in nfs4_proc_read_setup()
5683 hdr->pgio_done_cb = nfs4_read_done_cb; in nfs4_proc_read_setup()
5685 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ]; in nfs4_proc_read_setup()
5686 nfs4_init_sequence(&hdr->args.seq_args, &hdr->res.seq_res, 0, 0); in nfs4_proc_read_setup()
5692 if (nfs4_setup_sequence(NFS_SERVER(hdr->inode)->nfs_client, in nfs4_proc_pgio_rpc_prepare()
5693 &hdr->args.seq_args, in nfs4_proc_pgio_rpc_prepare()
5694 &hdr->res.seq_res, in nfs4_proc_pgio_rpc_prepare()
5697 if (nfs4_set_rw_stateid(&hdr->args.stateid, hdr->args.context, in nfs4_proc_pgio_rpc_prepare()
5698 hdr->args.lock_context, in nfs4_proc_pgio_rpc_prepare()
5699 hdr->rw_mode) == -EIO) in nfs4_proc_pgio_rpc_prepare()
5700 return -EIO; in nfs4_proc_pgio_rpc_prepare()
5701 if (unlikely(test_bit(NFS_CONTEXT_BAD, &hdr->args.context->flags))) in nfs4_proc_pgio_rpc_prepare()
5702 return -EIO; in nfs4_proc_pgio_rpc_prepare()
5709 struct inode *inode = hdr->inode; in nfs4_write_done_cb()
5711 trace_nfs4_write(hdr, task->tk_status); in nfs4_write_done_cb()
5712 if (task->tk_status < 0) { in nfs4_write_done_cb()
5714 .inode = hdr->inode, in nfs4_write_done_cb()
5715 .state = hdr->args.context->state, in nfs4_write_done_cb()
5716 .stateid = &hdr->args.stateid, in nfs4_write_done_cb()
5717 .retrans = hdr->retrans, in nfs4_write_done_cb()
5719 task->tk_status = nfs4_async_handle_exception(task, in nfs4_write_done_cb()
5720 NFS_SERVER(inode), task->tk_status, in nfs4_write_done_cb()
5722 hdr->retrans = exception.retrans; in nfs4_write_done_cb()
5725 return -EAGAIN; in nfs4_write_done_cb()
5728 if (task->tk_status >= 0) { in nfs4_write_done_cb()
5729 renew_lease(NFS_SERVER(inode), hdr->timestamp); in nfs4_write_done_cb()
5739 if (!nfs4_error_stateid_expired(task->tk_status) || in nfs4_write_stateid_changed()
5740 nfs4_stateid_is_current(&args->stateid, in nfs4_write_stateid_changed()
5741 args->context, in nfs4_write_stateid_changed()
5742 args->lock_context, in nfs4_write_stateid_changed()
5751 if (!nfs4_sequence_done(task, &hdr->res.seq_res)) in nfs4_write_done()
5752 return -EAGAIN; in nfs4_write_done()
5753 if (nfs4_write_stateid_changed(task, &hdr->args)) in nfs4_write_done()
5754 return -EAGAIN; in nfs4_write_done()
5755 return hdr->pgio_done_cb ? hdr->pgio_done_cb(task, hdr) : in nfs4_write_done()
5763 if (hdr->ds_clp != NULL || hdr->dreq != NULL) in nfs4_write_need_cache_consistency_data()
5768 return nfs4_have_delegation(hdr->inode, FMODE_READ, 0) == 0; in nfs4_write_need_cache_consistency_data()
5778 cache_validity |= READ_ONCE(NFS_I(inode)->cache_validity); in nfs4_bitmask_set()
5803 bitmask[i] &= server->attr_bitmask[i]; in nfs4_bitmask_set()
5810 struct nfs_server *server = NFS_SERVER(hdr->inode); in nfs4_proc_write_setup()
5813 hdr->args.bitmask = NULL; in nfs4_proc_write_setup()
5814 hdr->res.fattr = NULL; in nfs4_proc_write_setup()
5816 nfs4_bitmask_set(hdr->args.bitmask_store, in nfs4_proc_write_setup()
5817 server->cache_consistency_bitmask, in nfs4_proc_write_setup()
5818 hdr->inode, NFS_INO_INVALID_BLOCKS); in nfs4_proc_write_setup()
5819 hdr->args.bitmask = hdr->args.bitmask_store; in nfs4_proc_write_setup()
5822 if (!hdr->pgio_done_cb) in nfs4_proc_write_setup()
5823 hdr->pgio_done_cb = nfs4_write_done_cb; in nfs4_proc_write_setup()
5824 hdr->res.server = server; in nfs4_proc_write_setup()
5825 hdr->timestamp = jiffies; in nfs4_proc_write_setup()
5827 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE]; in nfs4_proc_write_setup()
5828 nfs4_init_sequence(&hdr->args.seq_args, &hdr->res.seq_res, 0, 0); in nfs4_proc_write_setup()
5829 nfs4_state_protect_write(hdr->ds_clp ? hdr->ds_clp : server->nfs_client, clnt, msg, hdr); in nfs4_proc_write_setup()
5834 nfs4_setup_sequence(NFS_SERVER(data->inode)->nfs_client, in nfs4_proc_commit_rpc_prepare()
5835 &data->args.seq_args, in nfs4_proc_commit_rpc_prepare()
5836 &data->res.seq_res, in nfs4_proc_commit_rpc_prepare()
5842 struct inode *inode = data->inode; in nfs4_commit_done_cb()
5844 trace_nfs4_commit(data, task->tk_status); in nfs4_commit_done_cb()
5846 NULL, NULL) == -EAGAIN) { in nfs4_commit_done_cb()
5848 return -EAGAIN; in nfs4_commit_done_cb()
5855 if (!nfs4_sequence_done(task, &data->res.seq_res)) in nfs4_commit_done()
5856 return -EAGAIN; in nfs4_commit_done()
5857 return data->commit_done_cb(task, data); in nfs4_commit_done()
5863 struct nfs_server *server = NFS_SERVER(data->inode); in nfs4_proc_commit_setup()
5865 if (data->commit_done_cb == NULL) in nfs4_proc_commit_setup()
5866 data->commit_done_cb = nfs4_commit_done_cb; in nfs4_proc_commit_setup()
5867 data->res.server = server; in nfs4_proc_commit_setup()
5868 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT]; in nfs4_proc_commit_setup()
5869 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1, 0); in nfs4_proc_commit_setup()
5870 nfs4_state_protect(data->ds_clp ? data->ds_clp : server->nfs_client, in nfs4_proc_commit_setup()
5885 args->fh = NFS_FH(dst_inode); in _nfs4_proc_commit()
5886 return nfs4_call_sync(server->client, server, &msg, in _nfs4_proc_commit()
5887 &args->seq_args, &res->seq_res, 1); in _nfs4_proc_commit()
5920 struct nfs_client *clp = data->client; in nfs4_renew_release()
5922 if (refcount_read(&clp->cl_count) > 1) in nfs4_renew_release()
5931 struct nfs_client *clp = data->client; in nfs4_renew_done()
5932 unsigned long timestamp = data->timestamp; in nfs4_renew_done()
5934 trace_nfs4_renew_async(clp, task->tk_status); in nfs4_renew_done()
5935 switch (task->tk_status) { in nfs4_renew_done()
5938 case -NFS4ERR_LEASE_MOVED: in nfs4_renew_done()
5943 if (test_bit(NFS_CS_RENEWD, &clp->cl_res_state) == 0) in nfs4_renew_done()
5945 if (task->tk_status != NFS4ERR_CB_PATH_DOWN) { in nfs4_renew_done()
5970 if (!refcount_inc_not_zero(&clp->cl_count)) in nfs4_proc_async_renew()
5971 return -EIO; in nfs4_proc_async_renew()
5975 return -ENOMEM; in nfs4_proc_async_renew()
5977 data->client = clp; in nfs4_proc_async_renew()
5978 data->timestamp = jiffies; in nfs4_proc_async_renew()
5979 return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT, in nfs4_proc_async_renew()
5993 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); in nfs4_proc_renew()
6005 return server->attr_bitmask[0] & FATTR4_WORD0_ACL; in nfs4_server_supports_acls()
6007 return server->attr_bitmask[1] & FATTR4_WORD1_DACL; in nfs4_server_supports_acls()
6009 return server->attr_bitmask[1] & FATTR4_WORD1_SACL; in nfs4_server_supports_acls()
6035 buflen -= len; in nfs4_buf_to_pages_noslab()
6043 for(; rc > 0; rc--) in nfs4_buf_to_pages_noslab()
6044 __free_page(spages[rc-1]); in nfs4_buf_to_pages_noslab()
6045 return -ENOMEM; in nfs4_buf_to_pages_noslab()
6059 spin_lock(&inode->i_lock); in nfs4_set_cached_acl()
6060 kfree(nfsi->nfs4_acl); in nfs4_set_cached_acl()
6061 nfsi->nfs4_acl = acl; in nfs4_set_cached_acl()
6062 spin_unlock(&inode->i_lock); in nfs4_set_cached_acl()
6075 int ret = -ENOENT; in nfs4_read_cached_acl()
6077 spin_lock(&inode->i_lock); in nfs4_read_cached_acl()
6078 acl = nfsi->nfs4_acl; in nfs4_read_cached_acl()
6081 if (acl->type != type) in nfs4_read_cached_acl()
6085 if (acl->cached == 0) in nfs4_read_cached_acl()
6087 ret = -ERANGE; /* see getxattr(2) man page */ in nfs4_read_cached_acl()
6088 if (acl->len > buflen) in nfs4_read_cached_acl()
6090 memcpy(buf, acl->data, acl->len); in nfs4_read_cached_acl()
6092 ret = acl->len; in nfs4_read_cached_acl()
6094 spin_unlock(&inode->i_lock); in nfs4_read_cached_acl()
6109 acl->cached = 1; in nfs4_write_cached_acl()
6110 _copy_from_pages(acl->data, pages, pgbase, acl_len); in nfs4_write_cached_acl()
6115 acl->cached = 0; in nfs4_write_cached_acl()
6117 acl->type = type; in nfs4_write_cached_acl()
6118 acl->len = acl_len; in nfs4_write_cached_acl()
6152 int ret = -ENOMEM, i; in __nfs4_get_acl_uncached()
6156 buflen = server->rsize; in __nfs4_get_acl_uncached()
6161 return -ENOMEM; in __nfs4_get_acl_uncached()
6180 ret = nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), in __nfs4_get_acl_uncached()
6185 /* Handle the case where the passed-in buffer is too short */ in __nfs4_get_acl_uncached()
6190 ret = -ERANGE; in __nfs4_get_acl_uncached()
6197 ret = -ERANGE; in __nfs4_get_acl_uncached()
6205 while (--i >= 0) in __nfs4_get_acl_uncached()
6236 if (unlikely(NFS_FH(inode)->size == 0)) in nfs4_proc_get_acl()
6237 return -ENODATA; in nfs4_proc_get_acl()
6239 return -EOPNOTSUPP; in nfs4_proc_get_acl()
6243 if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL) in nfs4_proc_get_acl()
6246 if (ret != -ENOENT) in nfs4_proc_get_acl()
6247 /* -ENOENT is returned if there is no ACL or if there is an ACL in nfs4_proc_get_acl()
6275 return -EINVAL; in __nfs4_proc_set_acl()
6277 return -EOPNOTSUPP; in __nfs4_proc_set_acl()
6279 return -ERANGE; in __nfs4_proc_set_acl()
6284 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); in __nfs4_proc_set_acl()
6290 for (; i > 0; i--) in __nfs4_proc_set_acl()
6291 put_page(pages[i-1]); in __nfs4_proc_set_acl()
6297 spin_lock(&inode->i_lock); in __nfs4_proc_set_acl()
6301 spin_unlock(&inode->i_lock); in __nfs4_proc_set_acl()
6313 if (unlikely(NFS_FH(inode)->size == 0)) in nfs4_proc_set_acl()
6314 return -ENODATA; in nfs4_proc_set_acl()
6318 if (err == -NFS4ERR_BADOWNER || err == -NFS4ERR_BADNAME) { in nfs4_proc_set_acl()
6323 err = -EINVAL; in nfs4_proc_set_acl()
6360 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 0); in _nfs4_get_security_label()
6364 return -ENOENT; in _nfs4_get_security_label()
6377 return -EOPNOTSUPP; in nfs4_get_security_label()
6416 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); in _nfs4_do_set_security_label()
6447 return -EOPNOTSUPP; in nfs4_set_security_label()
6451 return -ENOMEM; in nfs4_set_security_label()
6468 if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) { in nfs4_init_boot_verifier()
6474 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); in nfs4_init_boot_verifier()
6475 u64 ns = ktime_to_ns(nn->boot_time); in nfs4_init_boot_verifier()
6480 memcpy(bootverf->data, verf, sizeof(bootverf->data)); in nfs4_init_boot_verifier()
6486 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); in nfs4_get_uniquifier()
6487 struct nfs_netns_client *nn_clp = nn->nfs_client; in nfs4_get_uniquifier()
6494 id = rcu_dereference(nn_clp->identifier); in nfs4_get_uniquifier()
6514 if (clp->cl_owner_id != NULL) in nfs4_init_nonuniform_client_string()
6519 strlen(clp->cl_rpcclient->cl_nodename) + in nfs4_init_nonuniform_client_string()
6521 strlen(rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR)) + in nfs4_init_nonuniform_client_string()
6530 return -EINVAL; in nfs4_init_nonuniform_client_string()
6535 * about a memory-reclaim deadlock. in nfs4_init_nonuniform_client_string()
6539 return -ENOMEM; in nfs4_init_nonuniform_client_string()
6544 clp->cl_rpcclient->cl_nodename, buf, in nfs4_init_nonuniform_client_string()
6545 rpc_peeraddr2str(clp->cl_rpcclient, in nfs4_init_nonuniform_client_string()
6549 clp->cl_rpcclient->cl_nodename, in nfs4_init_nonuniform_client_string()
6550 rpc_peeraddr2str(clp->cl_rpcclient, in nfs4_init_nonuniform_client_string()
6554 clp->cl_owner_id = str; in nfs4_init_nonuniform_client_string()
6566 if (clp->cl_owner_id != NULL) in nfs4_init_uniform_client_string()
6570 strlen(clp->cl_rpcclient->cl_nodename) + 1; in nfs4_init_uniform_client_string()
6577 return -EINVAL; in nfs4_init_uniform_client_string()
6582 * about a memory-reclaim deadlock. in nfs4_init_uniform_client_string()
6586 return -ENOMEM; in nfs4_init_uniform_client_string()
6590 clp->rpc_ops->version, clp->cl_minorversion, in nfs4_init_uniform_client_string()
6591 buf, clp->cl_rpcclient->cl_nodename); in nfs4_init_uniform_client_string()
6594 clp->rpc_ops->version, clp->cl_minorversion, in nfs4_init_uniform_client_string()
6595 clp->cl_rpcclient->cl_nodename); in nfs4_init_uniform_client_string()
6596 clp->cl_owner_id = str; in nfs4_init_uniform_client_string()
6608 if (strchr(clp->cl_ipaddr, ':') != NULL) in nfs4_init_callback_netid()
6618 if (task->tk_status == 0) in nfs4_setclientid_done()
6619 sc->sc_cred = get_rpccred(task->tk_rqstp->rq_cred); in nfs4_setclientid_done()
6627 * nfs4_proc_setclientid - Negotiate client ID
6653 .rpc_client = clp->cl_rpcclient, in nfs4_proc_setclientid()
6665 if (test_bit(NFS_CS_MIGRATION, &clp->cl_flags)) in nfs4_proc_setclientid()
6680 clp->cl_ipaddr, port >> 8, port & 255); in nfs4_proc_setclientid()
6683 clp->cl_rpcclient->cl_auth->au_ops->au_name, in nfs4_proc_setclientid()
6684 clp->cl_owner_id); in nfs4_proc_setclientid()
6688 kfree(clp->cl_acceptor); in nfs4_proc_setclientid()
6689 clp->cl_acceptor = rpcauth_stringify_acceptor(setclientid.sc_cred); in nfs4_proc_setclientid()
6702 * nfs4_proc_setclientid_confirm - Confirm client ID
6721 clp->cl_rpcclient->cl_auth->au_ops->au_name, in nfs4_proc_setclientid_confirm()
6722 clp->cl_clientid); in nfs4_proc_setclientid_confirm()
6723 status = rpc_call_sync(clp->cl_rpcclient, &msg, in nfs4_proc_setclientid_confirm()
6754 .inode = data->inode, in nfs4_delegreturn_done()
6755 .stateid = &data->stateid, in nfs4_delegreturn_done()
6756 .task_is_privileged = data->args.seq_args.sa_privileged, in nfs4_delegreturn_done()
6757 .retrans = data->retrans, in nfs4_delegreturn_done()
6760 if (!nfs4_sequence_done(task, &data->res.seq_res)) in nfs4_delegreturn_done()
6763 trace_nfs4_delegreturn_exit(&data->args, &data->res, task->tk_status); in nfs4_delegreturn_done()
6766 if (pnfs_roc_done(task, &data->args.lr_args, &data->res.lr_res, in nfs4_delegreturn_done()
6767 &data->res.lr_ret) == -EAGAIN) in nfs4_delegreturn_done()
6770 if (data->args.sattr_args && task->tk_status != 0) { in nfs4_delegreturn_done()
6771 switch(data->res.sattr_ret) { in nfs4_delegreturn_done()
6773 data->args.sattr_args = NULL; in nfs4_delegreturn_done()
6774 data->res.sattr_res = false; in nfs4_delegreturn_done()
6776 case -NFS4ERR_ADMIN_REVOKED: in nfs4_delegreturn_done()
6777 case -NFS4ERR_DELEG_REVOKED: in nfs4_delegreturn_done()
6778 case -NFS4ERR_EXPIRED: in nfs4_delegreturn_done()
6779 case -NFS4ERR_BAD_STATEID: in nfs4_delegreturn_done()
6782 case -NFS4ERR_OLD_STATEID: in nfs4_delegreturn_done()
6783 if (nfs4_refresh_delegation_stateid(&data->stateid, in nfs4_delegreturn_done()
6784 data->inode)) in nfs4_delegreturn_done()
6788 data->args.sattr_args = NULL; in nfs4_delegreturn_done()
6789 data->res.sattr_res = false; in nfs4_delegreturn_done()
6794 switch (task->tk_status) { in nfs4_delegreturn_done()
6796 renew_lease(data->res.server, data->timestamp); in nfs4_delegreturn_done()
6798 case -NFS4ERR_ADMIN_REVOKED: in nfs4_delegreturn_done()
6799 case -NFS4ERR_DELEG_REVOKED: in nfs4_delegreturn_done()
6800 case -NFS4ERR_EXPIRED: in nfs4_delegreturn_done()
6801 nfs4_free_revoked_stateid(data->res.server, in nfs4_delegreturn_done()
6802 data->args.stateid, in nfs4_delegreturn_done()
6803 task->tk_msg.rpc_cred); in nfs4_delegreturn_done()
6805 case -NFS4ERR_BAD_STATEID: in nfs4_delegreturn_done()
6806 case -NFS4ERR_STALE_STATEID: in nfs4_delegreturn_done()
6807 case -ETIMEDOUT: in nfs4_delegreturn_done()
6808 task->tk_status = 0; in nfs4_delegreturn_done()
6810 case -NFS4ERR_OLD_STATEID: in nfs4_delegreturn_done()
6811 if (!nfs4_refresh_delegation_stateid(&data->stateid, data->inode)) in nfs4_delegreturn_done()
6812 nfs4_stateid_seqid_inc(&data->stateid); in nfs4_delegreturn_done()
6813 if (data->args.bitmask) { in nfs4_delegreturn_done()
6814 data->args.bitmask = NULL; in nfs4_delegreturn_done()
6815 data->res.fattr = NULL; in nfs4_delegreturn_done()
6818 case -NFS4ERR_ACCESS: in nfs4_delegreturn_done()
6819 if (data->args.bitmask) { in nfs4_delegreturn_done()
6820 data->args.bitmask = NULL; in nfs4_delegreturn_done()
6821 data->res.fattr = NULL; in nfs4_delegreturn_done()
6826 task->tk_status = nfs4_async_handle_exception(task, in nfs4_delegreturn_done()
6827 data->res.server, task->tk_status, in nfs4_delegreturn_done()
6829 data->retrans = exception.retrans; in nfs4_delegreturn_done()
6833 nfs_delegation_mark_returned(data->inode, data->args.stateid); in nfs4_delegreturn_done()
6834 data->rpc_status = task->tk_status; in nfs4_delegreturn_done()
6837 task->tk_status = 0; in nfs4_delegreturn_done()
6844 struct inode *inode = data->inode; in nfs4_delegreturn_release()
6846 if (data->lr.roc) in nfs4_delegreturn_release()
6847 pnfs_roc_release(&data->lr.arg, &data->lr.res, in nfs4_delegreturn_release()
6848 data->res.lr_ret); in nfs4_delegreturn_release()
6850 nfs4_fattr_set_prechange(&data->fattr, in nfs4_delegreturn_release()
6852 nfs_refresh_inode(inode, &data->fattr); in nfs4_delegreturn_release()
6865 if (!d_data->lr.roc && nfs4_wait_on_layoutreturn(d_data->inode, task)) { in nfs4_delegreturn_prepare()
6866 nfs4_sequence_done(task, &d_data->res.seq_res); in nfs4_delegreturn_prepare()
6870 lo = d_data->args.lr_args ? d_data->args.lr_args->layout : NULL; in nfs4_delegreturn_prepare()
6872 d_data->args.lr_args = NULL; in nfs4_delegreturn_prepare()
6873 d_data->res.lr_res = NULL; in nfs4_delegreturn_prepare()
6876 nfs4_setup_sequence(d_data->res.server->nfs_client, in nfs4_delegreturn_prepare()
6877 &d_data->args.seq_args, in nfs4_delegreturn_prepare()
6878 &d_data->res.seq_res, in nfs4_delegreturn_prepare()
6901 .rpc_client = server->client, in _nfs4_proc_delegreturn()
6913 return -ENOMEM; in _nfs4_proc_delegreturn()
6915 nfs4_state_protect(server->nfs_client, in _nfs4_proc_delegreturn()
6919 data->args.fhandle = &data->fh; in _nfs4_proc_delegreturn()
6920 data->args.stateid = &data->stateid; in _nfs4_proc_delegreturn()
6921 nfs4_bitmask_set(data->args.bitmask_store, in _nfs4_proc_delegreturn()
6922 server->cache_consistency_bitmask, inode, 0); in _nfs4_proc_delegreturn()
6923 data->args.bitmask = data->args.bitmask_store; in _nfs4_proc_delegreturn()
6924 nfs_copy_fh(&data->fh, NFS_FH(inode)); in _nfs4_proc_delegreturn()
6925 nfs4_stateid_copy(&data->stateid, stateid); in _nfs4_proc_delegreturn()
6926 data->res.fattr = &data->fattr; in _nfs4_proc_delegreturn()
6927 data->res.server = server; in _nfs4_proc_delegreturn()
6928 data->res.lr_ret = -NFS4ERR_NOMATCHING_LAYOUT; in _nfs4_proc_delegreturn()
6929 data->lr.arg.ld_private = &data->lr.ld_private; in _nfs4_proc_delegreturn()
6930 nfs_fattr_init(data->res.fattr); in _nfs4_proc_delegreturn()
6931 data->timestamp = jiffies; in _nfs4_proc_delegreturn()
6932 data->rpc_status = 0; in _nfs4_proc_delegreturn()
6933 data->inode = nfs_igrab_and_active(inode); in _nfs4_proc_delegreturn()
6934 if (data->inode || issync) { in _nfs4_proc_delegreturn()
6935 data->lr.roc = pnfs_roc(inode, &data->lr.arg, &data->lr.res, in _nfs4_proc_delegreturn()
6937 if (data->lr.roc) { in _nfs4_proc_delegreturn()
6938 data->args.lr_args = &data->lr.arg; in _nfs4_proc_delegreturn()
6939 data->res.lr_res = &data->lr.res; in _nfs4_proc_delegreturn()
6944 test_bit(NFS_DELEGATION_DELEGTIME, &delegation->flags)) { in _nfs4_proc_delegreturn()
6945 if (delegation->type & FMODE_READ) { in _nfs4_proc_delegreturn()
6946 data->sattr.atime = inode_get_atime(inode); in _nfs4_proc_delegreturn()
6947 data->sattr.atime_set = true; in _nfs4_proc_delegreturn()
6949 if (delegation->type & FMODE_WRITE) { in _nfs4_proc_delegreturn()
6950 data->sattr.mtime = inode_get_mtime(inode); in _nfs4_proc_delegreturn()
6951 data->sattr.mtime_set = true; in _nfs4_proc_delegreturn()
6953 data->args.sattr_args = &data->sattr; in _nfs4_proc_delegreturn()
6954 data->res.sattr_res = true; in _nfs4_proc_delegreturn()
6957 if (!data->inode) in _nfs4_proc_delegreturn()
6958 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1, in _nfs4_proc_delegreturn()
6961 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1, in _nfs4_proc_delegreturn()
6965 msg.rpc_argp = &data->args; in _nfs4_proc_delegreturn()
6966 msg.rpc_resp = &data->res; in _nfs4_proc_delegreturn()
6975 status = data->rpc_status; in _nfs4_proc_delegreturn()
6993 case -NFS4ERR_STALE_STATEID: in nfs4_proc_delegreturn()
6994 case -NFS4ERR_EXPIRED: in nfs4_proc_delegreturn()
7005 struct inode *inode = state->inode; in _nfs4_proc_getlk()
7007 struct nfs_client *clp = server->nfs_client; in _nfs4_proc_getlk()
7019 .rpc_cred = state->owner->so_cred, in _nfs4_proc_getlk()
7024 arg.lock_owner.clientid = clp->cl_clientid; in _nfs4_proc_getlk()
7028 lsp = request->fl_u.nfs4_fl.owner; in _nfs4_proc_getlk()
7029 arg.lock_owner.id = lsp->ls_seqid.owner_id; in _nfs4_proc_getlk()
7030 arg.lock_owner.s_dev = server->s_dev; in _nfs4_proc_getlk()
7031 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); in _nfs4_proc_getlk()
7034 request->c.flc_type = F_UNLCK; in _nfs4_proc_getlk()
7036 case -NFS4ERR_DENIED: in _nfs4_proc_getlk()
7039 request->fl_ops->fl_release_private(request); in _nfs4_proc_getlk()
7040 request->fl_ops = NULL; in _nfs4_proc_getlk()
7055 err = nfs4_handle_exception(NFS_SERVER(state->inode), err, in nfs4_proc_getlk()
7068 struct nfs4_state *state = lsp->ls_state; in nfs4_refresh_lock_old_stateid()
7071 spin_lock(&state->state_lock); in nfs4_refresh_lock_old_stateid()
7072 if (!nfs4_stateid_match_other(dst, &lsp->ls_stateid)) in nfs4_refresh_lock_old_stateid()
7074 if (!nfs4_stateid_is_newer(&lsp->ls_stateid, dst)) in nfs4_refresh_lock_old_stateid()
7077 dst->seqid = lsp->ls_stateid.seqid; in nfs4_refresh_lock_old_stateid()
7080 spin_unlock(&state->state_lock); in nfs4_refresh_lock_old_stateid()
7087 struct nfs4_state *state = lsp->ls_state; in nfs4_sync_lock_stateid()
7090 spin_lock(&state->state_lock); in nfs4_sync_lock_stateid()
7091 ret = !nfs4_stateid_match_other(dst, &lsp->ls_stateid); in nfs4_sync_lock_stateid()
7092 nfs4_stateid_copy(dst, &lsp->ls_stateid); in nfs4_sync_lock_stateid()
7093 spin_unlock(&state->state_lock); in nfs4_sync_lock_stateid()
7115 struct nfs4_state *state = lsp->ls_state; in nfs4_alloc_unlockdata()
7116 struct inode *inode = state->inode; in nfs4_alloc_unlockdata()
7124 p->l_ctx = l_ctx; in nfs4_alloc_unlockdata()
7129 p->arg.fh = NFS_FH(inode); in nfs4_alloc_unlockdata()
7130 p->arg.fl = &p->fl; in nfs4_alloc_unlockdata()
7131 p->arg.seqid = seqid; in nfs4_alloc_unlockdata()
7132 p->res.seqid = seqid; in nfs4_alloc_unlockdata()
7133 p->lsp = lsp; in nfs4_alloc_unlockdata()
7135 p->ctx = get_nfs_open_context(ctx); in nfs4_alloc_unlockdata()
7136 locks_init_lock(&p->fl); in nfs4_alloc_unlockdata()
7137 locks_copy_lock(&p->fl, fl); in nfs4_alloc_unlockdata()
7138 p->server = NFS_SERVER(inode); in nfs4_alloc_unlockdata()
7139 spin_lock(&state->state_lock); in nfs4_alloc_unlockdata()
7140 nfs4_stateid_copy(&p->arg.stateid, &lsp->ls_stateid); in nfs4_alloc_unlockdata()
7141 spin_unlock(&state->state_lock); in nfs4_alloc_unlockdata()
7148 nfs_free_seqid(calldata->arg.seqid); in nfs4_locku_release_calldata()
7149 nfs4_put_lock_state(calldata->lsp); in nfs4_locku_release_calldata()
7150 nfs_put_lock_context(calldata->l_ctx); in nfs4_locku_release_calldata()
7151 put_nfs_open_context(calldata->ctx); in nfs4_locku_release_calldata()
7159 .inode = calldata->lsp->ls_state->inode, in nfs4_locku_done()
7160 .stateid = &calldata->arg.stateid, in nfs4_locku_done()
7161 .retrans = calldata->retrans, in nfs4_locku_done()
7164 if (!nfs4_sequence_done(task, &calldata->res.seq_res)) in nfs4_locku_done()
7166 switch (task->tk_status) { in nfs4_locku_done()
7168 renew_lease(calldata->server, calldata->timestamp); in nfs4_locku_done()
7169 locks_lock_inode_wait(calldata->lsp->ls_state->inode, &calldata->fl); in nfs4_locku_done()
7170 if (nfs4_update_lock_stateid(calldata->lsp, in nfs4_locku_done()
7171 &calldata->res.stateid)) in nfs4_locku_done()
7174 case -NFS4ERR_ADMIN_REVOKED: in nfs4_locku_done()
7175 case -NFS4ERR_EXPIRED: in nfs4_locku_done()
7176 nfs4_free_revoked_stateid(calldata->server, in nfs4_locku_done()
7177 &calldata->arg.stateid, in nfs4_locku_done()
7178 task->tk_msg.rpc_cred); in nfs4_locku_done()
7180 case -NFS4ERR_BAD_STATEID: in nfs4_locku_done()
7181 case -NFS4ERR_STALE_STATEID: in nfs4_locku_done()
7182 if (nfs4_sync_lock_stateid(&calldata->arg.stateid, in nfs4_locku_done()
7183 calldata->lsp)) in nfs4_locku_done()
7186 case -NFS4ERR_OLD_STATEID: in nfs4_locku_done()
7187 if (nfs4_refresh_lock_old_stateid(&calldata->arg.stateid, in nfs4_locku_done()
7188 calldata->lsp)) in nfs4_locku_done()
7192 task->tk_status = nfs4_async_handle_exception(task, in nfs4_locku_done()
7193 calldata->server, task->tk_status, in nfs4_locku_done()
7195 calldata->retrans = exception.retrans; in nfs4_locku_done()
7199 nfs_release_seqid(calldata->arg.seqid); in nfs4_locku_done()
7206 if (test_bit(NFS_CONTEXT_UNLOCK, &calldata->l_ctx->open_context->flags) && in nfs4_locku_prepare()
7207 nfs_async_iocounter_wait(task, calldata->l_ctx)) in nfs4_locku_prepare()
7210 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0) in nfs4_locku_prepare()
7212 if (test_bit(NFS_LOCK_INITIALIZED, &calldata->lsp->ls_flags) == 0) { in nfs4_locku_prepare()
7216 calldata->timestamp = jiffies; in nfs4_locku_prepare()
7217 if (nfs4_setup_sequence(calldata->server->nfs_client, in nfs4_locku_prepare()
7218 &calldata->arg.seq_args, in nfs4_locku_prepare()
7219 &calldata->res.seq_res, in nfs4_locku_prepare()
7221 nfs_release_seqid(calldata->arg.seqid); in nfs4_locku_prepare()
7224 task->tk_action = NULL; in nfs4_locku_prepare()
7226 nfs4_sequence_done(task, &calldata->res.seq_res); in nfs4_locku_prepare()
7243 .rpc_cred = ctx->cred, in nfs4_do_unlck()
7246 .rpc_client = NFS_CLIENT(lsp->ls_state->inode), in nfs4_do_unlck()
7253 if (nfs_server_capable(lsp->ls_state->inode, NFS_CAP_MOVEABLE)) in nfs4_do_unlck()
7256 nfs4_state_protect(NFS_SERVER(lsp->ls_state->inode)->nfs_client, in nfs4_do_unlck()
7259 /* Ensure this is an unlock - when canceling a lock, the in nfs4_do_unlck()
7262 fl->c.flc_type = F_UNLCK; in nfs4_do_unlck()
7263 if (fl->c.flc_flags & FL_CLOSE) in nfs4_do_unlck()
7264 set_bit(NFS_CONTEXT_UNLOCK, &ctx->flags); in nfs4_do_unlck()
7269 return ERR_PTR(-ENOMEM); in nfs4_do_unlck()
7272 nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1, 0); in nfs4_do_unlck()
7273 msg.rpc_argp = &data->arg; in nfs4_do_unlck()
7274 msg.rpc_resp = &data->res; in nfs4_do_unlck()
7281 struct inode *inode = state->inode; in nfs4_proc_unlck()
7282 struct nfs4_state_owner *sp = state->owner; in nfs4_proc_unlck()
7289 unsigned char saved_flags = request->c.flc_flags; in nfs4_proc_unlck()
7293 request->c.flc_flags |= FL_EXISTS; in nfs4_proc_unlck()
7295 mutex_lock(&sp->so_delegreturn_mutex); in nfs4_proc_unlck()
7296 /* Exclude nfs4_reclaim_open_stateid() - note nesting! */ in nfs4_proc_unlck()
7297 down_read(&nfsi->rwsem); in nfs4_proc_unlck()
7298 if (locks_lock_inode_wait(inode, request) == -ENOENT) { in nfs4_proc_unlck()
7299 up_read(&nfsi->rwsem); in nfs4_proc_unlck()
7300 mutex_unlock(&sp->so_delegreturn_mutex); in nfs4_proc_unlck()
7303 lsp = request->fl_u.nfs4_fl.owner; in nfs4_proc_unlck()
7304 set_bit(NFS_LOCK_UNLOCKING, &lsp->ls_flags); in nfs4_proc_unlck()
7305 up_read(&nfsi->rwsem); in nfs4_proc_unlck()
7306 mutex_unlock(&sp->so_delegreturn_mutex); in nfs4_proc_unlck()
7310 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) == 0) in nfs4_proc_unlck()
7312 alloc_seqid = NFS_SERVER(inode)->nfs_client->cl_mvops->alloc_seqid; in nfs4_proc_unlck()
7313 seqid = alloc_seqid(&lsp->ls_seqid, GFP_KERNEL); in nfs4_proc_unlck()
7314 status = -ENOMEM; in nfs4_proc_unlck()
7318 nfs_file_open_context(request->c.flc_file), in nfs4_proc_unlck()
7326 request->c.flc_flags = saved_flags; in nfs4_proc_unlck()
7348 struct inode *inode = lsp->ls_state->inode; in nfs4_alloc_lockdata()
7356 p->arg.fh = NFS_FH(inode); in nfs4_alloc_lockdata()
7357 p->arg.fl = &p->fl; in nfs4_alloc_lockdata()
7358 p->arg.open_seqid = nfs_alloc_seqid(&lsp->ls_state->owner->so_seqid, gfp_mask); in nfs4_alloc_lockdata()
7359 if (IS_ERR(p->arg.open_seqid)) in nfs4_alloc_lockdata()
7361 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid; in nfs4_alloc_lockdata()
7362 p->arg.lock_seqid = alloc_seqid(&lsp->ls_seqid, gfp_mask); in nfs4_alloc_lockdata()
7363 if (IS_ERR(p->arg.lock_seqid)) in nfs4_alloc_lockdata()
7365 p->arg.lock_owner.clientid = server->nfs_client->cl_clientid; in nfs4_alloc_lockdata()
7366 p->arg.lock_owner.id = lsp->ls_seqid.owner_id; in nfs4_alloc_lockdata()
7367 p->arg.lock_owner.s_dev = server->s_dev; in nfs4_alloc_lockdata()
7368 p->res.lock_seqid = p->arg.lock_seqid; in nfs4_alloc_lockdata()
7369 p->lsp = lsp; in nfs4_alloc_lockdata()
7370 p->server = server; in nfs4_alloc_lockdata()
7371 p->ctx = get_nfs_open_context(ctx); in nfs4_alloc_lockdata()
7372 locks_init_lock(&p->fl); in nfs4_alloc_lockdata()
7373 locks_copy_lock(&p->fl, fl); in nfs4_alloc_lockdata()
7376 nfs_free_seqid(p->arg.open_seqid); in nfs4_alloc_lockdata()
7385 struct nfs4_state *state = data->lsp->ls_state; in nfs4_lock_prepare()
7387 if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0) in nfs4_lock_prepare()
7390 if (!test_bit(NFS_LOCK_INITIALIZED, &data->lsp->ls_flags)) { in nfs4_lock_prepare()
7391 if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0) { in nfs4_lock_prepare()
7394 nfs4_stateid_copy(&data->arg.open_stateid, in nfs4_lock_prepare()
7395 &state->open_stateid); in nfs4_lock_prepare()
7396 data->arg.new_lock_owner = 1; in nfs4_lock_prepare()
7397 data->res.open_seqid = data->arg.open_seqid; in nfs4_lock_prepare()
7399 data->arg.new_lock_owner = 0; in nfs4_lock_prepare()
7400 nfs4_stateid_copy(&data->arg.lock_stateid, in nfs4_lock_prepare()
7401 &data->lsp->ls_stateid); in nfs4_lock_prepare()
7404 data->rpc_status = -EBADF; in nfs4_lock_prepare()
7405 task->tk_action = NULL; in nfs4_lock_prepare()
7408 data->timestamp = jiffies; in nfs4_lock_prepare()
7409 if (nfs4_setup_sequence(data->server->nfs_client, in nfs4_lock_prepare()
7410 &data->arg.seq_args, in nfs4_lock_prepare()
7411 &data->res.seq_res, in nfs4_lock_prepare()
7415 nfs_release_seqid(data->arg.open_seqid); in nfs4_lock_prepare()
7417 nfs_release_seqid(data->arg.lock_seqid); in nfs4_lock_prepare()
7419 nfs4_sequence_done(task, &data->res.seq_res); in nfs4_lock_prepare()
7420 dprintk("%s: ret = %d\n", __func__, data->rpc_status); in nfs4_lock_prepare()
7426 struct nfs4_lock_state *lsp = data->lsp; in nfs4_lock_done()
7428 if (!nfs4_sequence_done(task, &data->res.seq_res)) in nfs4_lock_done()
7431 data->rpc_status = task->tk_status; in nfs4_lock_done()
7432 switch (task->tk_status) { in nfs4_lock_done()
7434 renew_lease(NFS_SERVER(d_inode(data->ctx->dentry)), in nfs4_lock_done()
7435 data->timestamp); in nfs4_lock_done()
7436 if (data->arg.new_lock && !data->cancelled) { in nfs4_lock_done()
7437 data->fl.c.flc_flags &= ~(FL_SLEEP | FL_ACCESS); in nfs4_lock_done()
7438 if (locks_lock_inode_wait(lsp->ls_state->inode, &data->fl) < 0) in nfs4_lock_done()
7441 if (data->arg.new_lock_owner != 0) { in nfs4_lock_done()
7442 nfs_confirm_seqid(&lsp->ls_seqid, 0); in nfs4_lock_done()
7443 nfs4_stateid_copy(&lsp->ls_stateid, &data->res.stateid); in nfs4_lock_done()
7444 set_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags); in nfs4_lock_done()
7445 } else if (!nfs4_update_lock_stateid(lsp, &data->res.stateid)) in nfs4_lock_done()
7448 case -NFS4ERR_OLD_STATEID: in nfs4_lock_done()
7449 if (data->arg.new_lock_owner != 0 && in nfs4_lock_done()
7450 nfs4_refresh_open_old_stateid(&data->arg.open_stateid, in nfs4_lock_done()
7451 lsp->ls_state)) in nfs4_lock_done()
7453 if (nfs4_refresh_lock_old_stateid(&data->arg.lock_stateid, lsp)) in nfs4_lock_done()
7456 case -NFS4ERR_BAD_STATEID: in nfs4_lock_done()
7457 case -NFS4ERR_STALE_STATEID: in nfs4_lock_done()
7458 case -NFS4ERR_EXPIRED: in nfs4_lock_done()
7459 if (data->arg.new_lock_owner != 0) { in nfs4_lock_done()
7460 if (!nfs4_stateid_match(&data->arg.open_stateid, in nfs4_lock_done()
7461 &lsp->ls_state->open_stateid)) in nfs4_lock_done()
7463 } else if (!nfs4_stateid_match(&data->arg.lock_stateid, in nfs4_lock_done()
7464 &lsp->ls_stateid)) in nfs4_lock_done()
7468 dprintk("%s: ret = %d!\n", __func__, data->rpc_status); in nfs4_lock_done()
7471 if (!data->cancelled) in nfs4_lock_done()
7480 nfs_free_seqid(data->arg.open_seqid); in nfs4_lock_release()
7481 if (data->cancelled && data->rpc_status == 0) { in nfs4_lock_release()
7483 task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp, in nfs4_lock_release()
7484 data->arg.lock_seqid); in nfs4_lock_release()
7489 nfs_free_seqid(data->arg.lock_seqid); in nfs4_lock_release()
7490 nfs4_put_lock_state(data->lsp); in nfs4_lock_release()
7491 put_nfs_open_context(data->ctx); in nfs4_lock_release()
7504 case -NFS4ERR_ADMIN_REVOKED: in nfs4_handle_setlk_error()
7505 case -NFS4ERR_EXPIRED: in nfs4_handle_setlk_error()
7506 case -NFS4ERR_BAD_STATEID: in nfs4_handle_setlk_error()
7507 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED; in nfs4_handle_setlk_error()
7509 test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0) in nfs4_handle_setlk_error()
7510 nfs4_schedule_stateid_recovery(server, lsp->ls_state); in nfs4_handle_setlk_error()
7512 case -NFS4ERR_STALE_STATEID: in nfs4_handle_setlk_error()
7513 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED; in nfs4_handle_setlk_error()
7514 nfs4_schedule_lease_recovery(server->nfs_client); in nfs4_handle_setlk_error()
7524 .rpc_cred = state->owner->so_cred, in _nfs4_do_setlk()
7527 .rpc_client = NFS_CLIENT(state->inode), in _nfs4_do_setlk()
7535 if (nfs_server_capable(state->inode, NFS_CAP_MOVEABLE)) in _nfs4_do_setlk()
7539 nfs_file_open_context(fl->c.flc_file), in _nfs4_do_setlk()
7540 fl->fl_u.nfs4_fl.owner, GFP_KERNEL); in _nfs4_do_setlk()
7542 return -ENOMEM; in _nfs4_do_setlk()
7544 data->arg.block = 1; in _nfs4_do_setlk()
7545 nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1, in _nfs4_do_setlk()
7547 msg.rpc_argp = &data->arg; in _nfs4_do_setlk()
7548 msg.rpc_resp = &data->res; in _nfs4_do_setlk()
7552 data->arg.reclaim = NFS_LOCK_RECLAIM; in _nfs4_do_setlk()
7554 data->arg.new_lock = 1; in _nfs4_do_setlk()
7560 ret = data->rpc_status; in _nfs4_do_setlk()
7562 nfs4_handle_setlk_error(data->server, data->lsp, in _nfs4_do_setlk()
7563 data->arg.new_lock_owner, ret); in _nfs4_do_setlk()
7565 data->cancelled = true; in _nfs4_do_setlk()
7566 trace_nfs4_set_lock(fl, state, &data->res.stateid, cmd, ret); in _nfs4_do_setlk()
7574 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_lock_reclaim()
7576 .inode = state->inode, in nfs4_lock_reclaim()
7582 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0) in nfs4_lock_reclaim()
7585 if (err != -NFS4ERR_DELAY) in nfs4_lock_reclaim()
7594 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_lock_expired()
7596 .inode = state->inode, in nfs4_lock_expired()
7604 set_bit(NFS_LOCK_LOST, &request->fl_u.nfs4_fl.owner->ls_flags); in nfs4_lock_expired()
7608 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0) in nfs4_lock_expired()
7614 case -NFS4ERR_GRACE: in nfs4_lock_expired()
7615 case -NFS4ERR_DELAY: in nfs4_lock_expired()
7633 lsp = request->fl_u.nfs4_fl.owner; in nfs41_lock_expired()
7634 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) || in nfs41_lock_expired()
7635 test_bit(NFS_LOCK_LOST, &lsp->ls_flags)) in nfs41_lock_expired()
7643 struct nfs_inode *nfsi = NFS_I(state->inode); in _nfs4_proc_setlk()
7644 struct nfs4_state_owner *sp = state->owner; in _nfs4_proc_setlk()
7645 unsigned char flags = request->c.flc_flags; in _nfs4_proc_setlk()
7648 request->c.flc_flags |= FL_ACCESS; in _nfs4_proc_setlk()
7649 status = locks_lock_inode_wait(state->inode, request); in _nfs4_proc_setlk()
7652 mutex_lock(&sp->so_delegreturn_mutex); in _nfs4_proc_setlk()
7653 down_read(&nfsi->rwsem); in _nfs4_proc_setlk()
7654 if (test_bit(NFS_DELEGATED_STATE, &state->flags)) { in _nfs4_proc_setlk()
7656 /* ...but avoid races with delegation recall... */ in _nfs4_proc_setlk()
7657 request->c.flc_flags = flags & ~FL_SLEEP; in _nfs4_proc_setlk()
7658 status = locks_lock_inode_wait(state->inode, request); in _nfs4_proc_setlk()
7659 up_read(&nfsi->rwsem); in _nfs4_proc_setlk()
7660 mutex_unlock(&sp->so_delegreturn_mutex); in _nfs4_proc_setlk()
7663 up_read(&nfsi->rwsem); in _nfs4_proc_setlk()
7664 mutex_unlock(&sp->so_delegreturn_mutex); in _nfs4_proc_setlk()
7667 request->c.flc_flags = flags; in _nfs4_proc_setlk()
7675 .inode = state->inode, in nfs4_proc_setlk()
7682 if (err == -NFS4ERR_DENIED) in nfs4_proc_setlk()
7683 err = -EAGAIN; in nfs4_proc_setlk()
7684 err = nfs4_handle_exception(NFS_SERVER(state->inode), in nfs4_proc_setlk()
7697 int status = -ERESTARTSYS; in nfs4_retry_setlk_simple()
7702 if ((status != -EAGAIN) || IS_SETLK(cmd)) in nfs4_retry_setlk_simple()
7708 status = -ERESTARTSYS; in nfs4_retry_setlk_simple()
7729 struct nfs_lowner *lowner = &cbnl->cbnl_owner, in nfs4_wake_lock_waiter()
7730 *wowner = &waiter->owner; in nfs4_wake_lock_waiter()
7733 if (lowner->id != wowner->id || lowner->s_dev != wowner->s_dev) in nfs4_wake_lock_waiter()
7737 if (nfs_compare_fh(NFS_FH(waiter->inode), &cbnl->cbnl_fh)) in nfs4_wake_lock_waiter()
7747 struct nfs4_lock_state *lsp = request->fl_u.nfs4_fl.owner; in nfs4_retry_setlk()
7748 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_retry_setlk()
7749 struct nfs_client *clp = server->nfs_client; in nfs4_retry_setlk()
7750 wait_queue_head_t *q = &clp->cl_lock_waitq; in nfs4_retry_setlk()
7752 .inode = state->inode, in nfs4_retry_setlk()
7753 .owner = { .clientid = clp->cl_clientid, in nfs4_retry_setlk()
7754 .id = lsp->ls_seqid.owner_id, in nfs4_retry_setlk()
7755 .s_dev = server->s_dev }, in nfs4_retry_setlk()
7760 if (!test_bit(NFS_STATE_MAY_NOTIFY_LOCK, &state->flags)) in nfs4_retry_setlk()
7769 if (status != -EAGAIN || IS_SETLK(cmd)) in nfs4_retry_setlk()
7772 status = -ERESTARTSYS; in nfs4_retry_setlk()
7798 state = ctx->state; in nfs4_proc_lock()
7807 return -EINVAL; in nfs4_proc_lock()
7816 return -ENOLCK; in nfs4_proc_lock()
7818 if ((request->c.flc_flags & FL_POSIX) && in nfs4_proc_lock()
7819 !test_bit(NFS_STATE_POSIX_LOCKS, &state->flags)) in nfs4_proc_lock()
7820 return -ENOLCK; in nfs4_proc_lock()
7826 switch (request->c.flc_type) { in nfs4_proc_lock()
7828 if (!(filp->f_mode & FMODE_READ)) in nfs4_proc_lock()
7829 return -EBADF; in nfs4_proc_lock()
7832 if (!(filp->f_mode & FMODE_WRITE)) in nfs4_proc_lock()
7833 return -EBADF; in nfs4_proc_lock()
7857 return -EAGAIN; in nfs4_add_lease()
7863 return -EAGAIN; in nfs4_add_lease()
7876 return -EINVAL; in nfs4_proc_setlease()
7882 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_lock_delegation_recall()
7890 if (err != -NFS4ERR_DELAY && err != -NFS4ERR_GRACE) in nfs4_lock_delegation_recall()
7893 } while (err == -NFS4ERR_DELAY || err == -NFSERR_GRACE); in nfs4_lock_delegation_recall()
7908 struct nfs_server *server = data->server; in nfs4_release_lockowner_prepare()
7909 nfs4_setup_sequence(server->nfs_client, &data->args.seq_args, in nfs4_release_lockowner_prepare()
7910 &data->res.seq_res, task); in nfs4_release_lockowner_prepare()
7911 data->args.lock_owner.clientid = server->nfs_client->cl_clientid; in nfs4_release_lockowner_prepare()
7912 data->timestamp = jiffies; in nfs4_release_lockowner_prepare()
7918 struct nfs_server *server = data->server; in nfs4_release_lockowner_done()
7920 nfs40_sequence_done(task, &data->res.seq_res); in nfs4_release_lockowner_done()
7922 switch (task->tk_status) { in nfs4_release_lockowner_done()
7924 renew_lease(server, data->timestamp); in nfs4_release_lockowner_done()
7926 case -NFS4ERR_STALE_CLIENTID: in nfs4_release_lockowner_done()
7927 case -NFS4ERR_EXPIRED: in nfs4_release_lockowner_done()
7928 nfs4_schedule_lease_recovery(server->nfs_client); in nfs4_release_lockowner_done()
7930 case -NFS4ERR_LEASE_MOVED: in nfs4_release_lockowner_done()
7931 case -NFS4ERR_DELAY: in nfs4_release_lockowner_done()
7933 NULL, NULL) == -EAGAIN) in nfs4_release_lockowner_done()
7941 nfs4_free_lock_state(data->server, data->lsp); in nfs4_release_lockowner_release()
7959 if (server->nfs_client->cl_mvops->minor_version != 0) in nfs4_release_lockowner()
7965 data->lsp = lsp; in nfs4_release_lockowner()
7966 data->server = server; in nfs4_release_lockowner()
7967 data->args.lock_owner.clientid = server->nfs_client->cl_clientid; in nfs4_release_lockowner()
7968 data->args.lock_owner.id = lsp->ls_seqid.owner_id; in nfs4_release_lockowner()
7969 data->args.lock_owner.s_dev = server->s_dev; in nfs4_release_lockowner()
7971 msg.rpc_argp = &data->args; in nfs4_release_lockowner()
7972 msg.rpc_resp = &data->res; in nfs4_release_lockowner()
7973 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0, 0); in nfs4_release_lockowner()
7974 rpc_call_async(server->client, &msg, 0, &nfs4_release_lockowner_ops, data); in nfs4_release_lockowner()
7997 return nfs4_server_supports_acls(NFS_SB(dentry->d_sb), NFS4ACL_ACL); in nfs4_xattr_list_nfs4_acl()
8021 return nfs4_server_supports_acls(NFS_SB(dentry->d_sb), NFS4ACL_DACL); in nfs4_xattr_list_nfs4_dacl()
8044 return nfs4_server_supports_acls(NFS_SB(dentry->d_sb), NFS4ACL_SACL); in nfs4_xattr_list_nfs4_sacl()
8060 return -EOPNOTSUPP; in nfs4_xattr_set_nfs4_label()
8069 return -EOPNOTSUPP; in nfs4_xattr_get_nfs4_label()
8080 return -ERANGE; in nfs4_listxattr_nfs4_label()
8112 return -EOPNOTSUPP; in nfs4_xattr_set_nfs4_user()
8125 return -EACCES; in nfs4_xattr_set_nfs4_user()
8149 return -EOPNOTSUPP; in nfs4_xattr_get_nfs4_user()
8153 return -EACCES; in nfs4_xattr_get_nfs4_user()
8161 if (ret >= 0 || (ret < 0 && ret != -ENOENT)) in nfs4_xattr_get_nfs4_user()
8192 if (ret >= 0 || (ret < 0 && ret != -ENOENT)) in nfs4_listxattr_nfs4_user()
8209 buflen -= ret; in nfs4_listxattr_nfs4_user()
8234 if (!(((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) || in nfs_fixup_referral_attributes()
8235 (fattr->valid & NFS_ATTR_FATTR_FILEID)) && in nfs_fixup_referral_attributes()
8236 (fattr->valid & NFS_ATTR_FATTR_FSID) && in nfs_fixup_referral_attributes()
8237 (fattr->valid & NFS_ATTR_FATTR_V4_LOCATIONS))) in nfs_fixup_referral_attributes()
8240 fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE | in nfs_fixup_referral_attributes()
8242 fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO; in nfs_fixup_referral_attributes()
8243 fattr->nlink = 2; in nfs_fixup_referral_attributes()
8276 if (NFS_SERVER(dir)->attr_bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID) in _nfs4_proc_fs_locations()
8281 nfs_fattr_init(fs_locations->fattr); in _nfs4_proc_fs_locations()
8282 fs_locations->server = server; in _nfs4_proc_fs_locations()
8283 fs_locations->nlocations = 0; in _nfs4_proc_fs_locations()
8320 struct rpc_clnt *clnt = server->client; in _nfs40_proc_get_locations()
8325 .clientid = server->nfs_client->cl_clientid, in _nfs40_proc_get_locations()
8329 .migration = 1, /* skip LOOKUP */ in _nfs40_proc_get_locations()
8346 nfs_fattr_init(locations->fattr); in _nfs40_proc_get_locations()
8347 locations->server = server; in _nfs40_proc_get_locations()
8348 locations->nlocations = 0; in _nfs40_proc_get_locations()
8377 struct rpc_clnt *clnt = server->client; in _nfs41_proc_get_locations()
8385 .migration = 1, /* skip LOOKUP */ in _nfs41_proc_get_locations()
8405 .callback_ops = server->nfs_client->cl_mvops->call_sync_ops, in _nfs41_proc_get_locations()
8411 nfs_fattr_init(locations->fattr); in _nfs41_proc_get_locations()
8412 locations->server = server; in _nfs41_proc_get_locations()
8413 locations->nlocations = 0; in _nfs41_proc_get_locations()
8419 status = -NFS4ERR_LEASE_MOVED; in _nfs41_proc_get_locations()
8426 * nfs4_proc_get_locations - discover locations for a migrated FSID
8440 * -NFS4ERR_LEASE_MOVED is returned if the server still has leases
8448 struct nfs_client *clp = server->nfs_client; in nfs4_proc_get_locations()
8450 clp->cl_mvops->mig_recovery_ops; in nfs4_proc_get_locations()
8457 (unsigned long long)server->fsid.major, in nfs4_proc_get_locations()
8458 (unsigned long long)server->fsid.minor, in nfs4_proc_get_locations()
8459 clp->cl_hostname); in nfs4_proc_get_locations()
8463 status = ops->get_locations(server, fhandle, locations, page, in nfs4_proc_get_locations()
8465 if (status != -NFS4ERR_DELAY) in nfs4_proc_get_locations()
8482 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client; in _nfs40_proc_fsid_present()
8483 struct rpc_clnt *clnt = server->client; in _nfs40_proc_fsid_present()
8486 .clientid = clp->cl_clientid, in _nfs40_proc_fsid_present()
8503 return -ENOMEM; in _nfs40_proc_fsid_present()
8528 struct rpc_clnt *clnt = server->client; in _nfs41_proc_fsid_present()
8544 return -ENOMEM; in _nfs41_proc_fsid_present()
8552 status = -NFS4ERR_LEASE_MOVED; in _nfs41_proc_fsid_present()
8559 * nfs4_proc_fsid_present - Is this FSID present or absent on server?
8568 * -NFS4ERR_MOVED if the FSID is no longer present, a negative
8575 struct nfs_client *clp = server->nfs_client; in nfs4_proc_fsid_present()
8577 clp->cl_mvops->mig_recovery_ops; in nfs4_proc_fsid_present()
8584 (unsigned long long)server->fsid.major, in nfs4_proc_fsid_present()
8585 (unsigned long long)server->fsid.minor, in nfs4_proc_fsid_present()
8586 clp->cl_hostname); in nfs4_proc_fsid_present()
8590 status = ops->fsid_present(inode, cred); in nfs4_proc_fsid_present()
8591 if (status != -NFS4ERR_DELAY) in nfs4_proc_fsid_present()
8608 struct rpc_clnt *clnt = NFS_SERVER(dir)->client; in _nfs4_proc_secinfo()
8609 struct nfs_client *clp = NFS_SERVER(dir)->nfs_client; in _nfs4_proc_secinfo()
8630 .callback_ops = clp->cl_mvops->call_sync_ops, in _nfs4_proc_secinfo()
8637 clnt = clp->cl_rpcclient; in _nfs4_proc_secinfo()
8644 dprintk("NFS call secinfo %s\n", name->name); in _nfs4_proc_secinfo()
8664 err = -NFS4ERR_WRONGSEC; in nfs4_proc_secinfo()
8667 if (_nfs4_is_integrity_protected(NFS_SERVER(dir)->nfs_client)) in nfs4_proc_secinfo()
8676 if (err == -NFS4ERR_WRONGSEC) in nfs4_proc_secinfo()
8705 return -NFS4ERR_INVAL; in nfs4_check_cl_exchange_flags()
8712 if (a->server_scope_sz != b->server_scope_sz) in nfs41_same_server_scope()
8714 return memcmp(a->server_scope, b->server_scope, a->server_scope_sz) == 0; in nfs41_same_server_scope()
8720 struct nfs41_bind_conn_to_session_args *args = task->tk_msg.rpc_argp; in nfs4_bind_one_conn_to_session_done()
8721 struct nfs41_bind_conn_to_session_res *res = task->tk_msg.rpc_resp; in nfs4_bind_one_conn_to_session_done()
8722 struct nfs_client *clp = args->client; in nfs4_bind_one_conn_to_session_done()
8724 switch (task->tk_status) { in nfs4_bind_one_conn_to_session_done()
8725 case -NFS4ERR_BADSESSION: in nfs4_bind_one_conn_to_session_done()
8726 case -NFS4ERR_DEADSESSION: in nfs4_bind_one_conn_to_session_done()
8727 nfs4_schedule_session_recovery(clp->cl_session, in nfs4_bind_one_conn_to_session_done()
8728 task->tk_status); in nfs4_bind_one_conn_to_session_done()
8731 if (args->dir == NFS4_CDFC4_FORE_OR_BOTH && in nfs4_bind_one_conn_to_session_done()
8732 res->dir != NFS4_CDFS4_BOTH) { in nfs4_bind_one_conn_to_session_done()
8734 if (args->retries++ < MAX_BIND_CONN_TO_SESSION_RETRIES) in nfs4_bind_one_conn_to_session_done()
8778 nfs4_copy_sessionid(&args.sessionid, &clp->cl_session->sess_id); in nfs4_proc_bind_one_conn_to_session()
8779 if (!(clp->cl_session->flags & SESSION4_BACK_CHAN)) in nfs4_proc_bind_one_conn_to_session()
8782 /* Do not set the backchannel flag unless this is clnt->cl_xprt */ in nfs4_proc_bind_one_conn_to_session()
8783 if (xprt != rcu_access_pointer(clnt->cl_xprt)) in nfs4_proc_bind_one_conn_to_session()
8788 status = task->tk_status; in nfs4_proc_bind_one_conn_to_session()
8795 clp->cl_session->sess_id.data, NFS4_MAX_SESSIONID_LEN)) { in nfs4_proc_bind_one_conn_to_session()
8797 return -EIO; in nfs4_proc_bind_one_conn_to_session()
8802 return -EIO; in nfs4_proc_bind_one_conn_to_session()
8807 return -EIO; in nfs4_proc_bind_one_conn_to_session()
8826 return nfs4_proc_bind_one_conn_to_session(clnt, xprt, p->clp, p->cred); in nfs4_proc_bind_conn_to_session_callback()
8835 return rpc_clnt_iterate_for_each_xprt(clp->cl_rpcclient, in nfs4_proc_bind_conn_to_session()
8846 [1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) |
8847 1 << (OP_EXCHANGE_ID - 32) |
8848 1 << (OP_CREATE_SESSION - 32) |
8849 1 << (OP_DESTROY_SESSION - 32) |
8850 1 << (OP_DESTROY_CLIENTID - 32)
8858 [1] = 1 << (OP_SECINFO - 32) |
8859 1 << (OP_SECINFO_NO_NAME - 32) |
8860 1 << (OP_LAYOUTRETURN - 32) |
8861 1 << (OP_TEST_STATEID - 32) |
8862 1 << (OP_FREE_STATEID - 32) |
8863 1 << (OP_WRITE - 32)
8877 [1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) | in nfs4_sp4_select_mode()
8878 1 << (OP_EXCHANGE_ID - 32) | in nfs4_sp4_select_mode()
8879 1 << (OP_CREATE_SESSION - 32) | in nfs4_sp4_select_mode()
8880 1 << (OP_DESTROY_SESSION - 32) | in nfs4_sp4_select_mode()
8881 1 << (OP_DESTROY_CLIENTID - 32) in nfs4_sp4_select_mode()
8887 if (sp->how == SP4_MACH_CRED) { in nfs4_sp4_select_mode()
8891 if (test_bit(i, sp->enforce.u.longs)) in nfs4_sp4_select_mode()
8893 if (test_bit(i, sp->allow.u.longs)) in nfs4_sp4_select_mode()
8899 if (sp->enforce.u.words[i] & ~supported_enforce[i]) { in nfs4_sp4_select_mode()
8901 ret = -EINVAL; in nfs4_sp4_select_mode()
8907 * Minimal mode - state operations are allowed to use machine in nfs4_sp4_select_mode()
8911 * NOTE: we don't care if EXCHANGE_ID is in the list - in nfs4_sp4_select_mode()
8915 if (test_bit(OP_BIND_CONN_TO_SESSION, sp->enforce.u.longs) && in nfs4_sp4_select_mode()
8916 test_bit(OP_CREATE_SESSION, sp->enforce.u.longs) && in nfs4_sp4_select_mode()
8917 test_bit(OP_DESTROY_SESSION, sp->enforce.u.longs) && in nfs4_sp4_select_mode()
8918 test_bit(OP_DESTROY_CLIENTID, sp->enforce.u.longs)) { in nfs4_sp4_select_mode()
8924 ret = -EINVAL; in nfs4_sp4_select_mode()
8928 if (test_bit(OP_CLOSE, sp->allow.u.longs) && in nfs4_sp4_select_mode()
8929 test_bit(OP_OPEN_DOWNGRADE, sp->allow.u.longs) && in nfs4_sp4_select_mode()
8930 test_bit(OP_DELEGRETURN, sp->allow.u.longs) && in nfs4_sp4_select_mode()
8931 test_bit(OP_LOCKU, sp->allow.u.longs)) { in nfs4_sp4_select_mode()
8936 if (test_bit(OP_LAYOUTRETURN, sp->allow.u.longs)) { in nfs4_sp4_select_mode()
8941 if (test_bit(OP_SECINFO, sp->allow.u.longs) && in nfs4_sp4_select_mode()
8942 test_bit(OP_SECINFO_NO_NAME, sp->allow.u.longs)) { in nfs4_sp4_select_mode()
8947 if (test_bit(OP_TEST_STATEID, sp->allow.u.longs) && in nfs4_sp4_select_mode()
8948 test_bit(OP_FREE_STATEID, sp->allow.u.longs)) { in nfs4_sp4_select_mode()
8953 if (test_bit(OP_WRITE, sp->allow.u.longs)) { in nfs4_sp4_select_mode()
8958 if (test_bit(OP_COMMIT, sp->allow.u.longs)) { in nfs4_sp4_select_mode()
8964 clp->cl_sp4_flags = flags; in nfs4_sp4_select_mode()
8978 nfs_put_client(cdata->args.client); in nfs4_exchange_id_release()
8979 kfree(cdata->res.impl_id); in nfs4_exchange_id_release()
8980 kfree(cdata->res.server_scope); in nfs4_exchange_id_release()
8981 kfree(cdata->res.server_owner); in nfs4_exchange_id_release()
9003 .rpc_client = clp->cl_rpcclient, in nfs4_run_exchange_id()
9011 if (!refcount_inc_not_zero(&clp->cl_count)) in nfs4_run_exchange_id()
9012 return ERR_PTR(-EIO); in nfs4_run_exchange_id()
9014 status = -ENOMEM; in nfs4_run_exchange_id()
9019 nfs4_init_boot_verifier(clp, &calldata->args.verifier); in nfs4_run_exchange_id()
9025 calldata->res.server_owner = kzalloc(sizeof(struct nfs41_server_owner), in nfs4_run_exchange_id()
9027 status = -ENOMEM; in nfs4_run_exchange_id()
9028 if (unlikely(calldata->res.server_owner == NULL)) in nfs4_run_exchange_id()
9031 calldata->res.server_scope = kzalloc(sizeof(struct nfs41_server_scope), in nfs4_run_exchange_id()
9033 if (unlikely(calldata->res.server_scope == NULL)) in nfs4_run_exchange_id()
9036 calldata->res.impl_id = kzalloc(sizeof(struct nfs41_impl_id), GFP_NOFS); in nfs4_run_exchange_id()
9037 if (unlikely(calldata->res.impl_id == NULL)) in nfs4_run_exchange_id()
9042 calldata->args.state_protect.how = SP4_NONE; in nfs4_run_exchange_id()
9046 calldata->args.state_protect = nfs4_sp4_mach_cred_request; in nfs4_run_exchange_id()
9052 status = -EINVAL; in nfs4_run_exchange_id()
9058 memcpy(calldata->args.verifier.data, clp->cl_confirm.data, in nfs4_run_exchange_id()
9059 sizeof(calldata->args.verifier.data)); in nfs4_run_exchange_id()
9061 calldata->args.client = clp; in nfs4_run_exchange_id()
9062 calldata->args.flags = EXCHGID4_FLAG_SUPP_MOVED_REFER | in nfs4_run_exchange_id()
9065 calldata->args.flags |= EXCHGID4_FLAG_SUPP_MOVED_MIGR; in nfs4_run_exchange_id()
9067 if (test_bit(NFS_CS_PNFS, &clp->cl_flags)) in nfs4_run_exchange_id()
9068 calldata->args.flags |= EXCHGID4_FLAG_USE_PNFS_DS; in nfs4_run_exchange_id()
9069 msg.rpc_argp = &calldata->args; in nfs4_run_exchange_id()
9070 msg.rpc_resp = &calldata->res; in nfs4_run_exchange_id()
9076 kfree(calldata->res.impl_id); in nfs4_run_exchange_id()
9078 kfree(calldata->res.server_scope); in nfs4_run_exchange_id()
9080 kfree(calldata->res.server_owner); in nfs4_run_exchange_id()
9106 argp = task->tk_msg.rpc_argp; in _nfs4_proc_exchange_id()
9107 resp = task->tk_msg.rpc_resp; in _nfs4_proc_exchange_id()
9108 status = task->tk_status; in _nfs4_proc_exchange_id()
9112 status = nfs4_check_cl_exchange_flags(resp->flags, in _nfs4_proc_exchange_id()
9113 clp->cl_mvops->minor_version); in _nfs4_proc_exchange_id()
9117 status = nfs4_sp4_select_mode(clp, &resp->state_protect); in _nfs4_proc_exchange_id()
9123 clp->cl_clientid = resp->clientid; in _nfs4_proc_exchange_id()
9124 clp->cl_exchange_flags = resp->flags; in _nfs4_proc_exchange_id()
9125 clp->cl_seqid = resp->seqid; in _nfs4_proc_exchange_id()
9127 if (!(resp->flags & EXCHGID4_FLAG_CONFIRMED_R)) in _nfs4_proc_exchange_id()
9129 &clp->cl_session->session_state); in _nfs4_proc_exchange_id()
9131 if (clp->cl_serverscope != NULL && in _nfs4_proc_exchange_id()
9132 !nfs41_same_server_scope(clp->cl_serverscope, in _nfs4_proc_exchange_id()
9133 resp->server_scope)) { in _nfs4_proc_exchange_id()
9136 set_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state); in _nfs4_proc_exchange_id()
9139 swap(clp->cl_serverowner, resp->server_owner); in _nfs4_proc_exchange_id()
9140 swap(clp->cl_serverscope, resp->server_scope); in _nfs4_proc_exchange_id()
9141 swap(clp->cl_implid, resp->impl_id); in _nfs4_proc_exchange_id()
9144 memcpy(clp->cl_confirm.data, argp->verifier.data, in _nfs4_proc_exchange_id()
9145 sizeof(clp->cl_confirm.data)); in _nfs4_proc_exchange_id()
9166 rpc_authflavor_t authflavor = clp->cl_rpcclient->cl_auth->au_flavor; in nfs4_proc_exchange_id()
9205 dprintk("--> %s try %s\n", __func__, in nfs4_test_session_trunk()
9206 xprt->address_strings[RPC_DISPLAY_ADDR]); in nfs4_test_session_trunk()
9208 sp4_how = (adata->clp->cl_sp4_flags == 0 ? SP4_NONE : SP4_MACH_CRED); in nfs4_test_session_trunk()
9212 task = nfs4_run_exchange_id(adata->clp, adata->cred, sp4_how, xprt); in nfs4_test_session_trunk()
9216 status = task->tk_status; in nfs4_test_session_trunk()
9218 status = nfs4_detect_session_trunking(adata->clp, in nfs4_test_session_trunk()
9219 task->tk_msg.rpc_resp, xprt); in nfs4_test_session_trunk()
9220 trace_nfs4_trunked_exchange_id(adata->clp, in nfs4_test_session_trunk()
9221 xprt->address_strings[RPC_DISPLAY_ADDR], status); in nfs4_test_session_trunk()
9225 else if (status != -NFS4ERR_DELAY && rpc_clnt_xprt_switch_has_addr(clnt, in nfs4_test_session_trunk()
9226 (struct sockaddr *)&xprt->addr)) in nfs4_test_session_trunk()
9230 if (status == -NFS4ERR_DELAY) { in nfs4_test_session_trunk()
9247 status = rpc_call_sync(clp->cl_rpcclient, &msg, in _nfs4_proc_destroy_clientid()
9252 "DESTROY_CLIENTID.", status, clp->cl_hostname); in _nfs4_proc_destroy_clientid()
9262 for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) { in nfs4_proc_destroy_clientid()
9265 case -NFS4ERR_DELAY: in nfs4_proc_destroy_clientid()
9266 case -NFS4ERR_CLIENTID_BUSY: in nfs4_proc_destroy_clientid()
9281 if (clp->cl_mvops->minor_version < 1) in nfs4_destroy_clientid()
9283 if (clp->cl_exchange_flags == 0) in nfs4_destroy_clientid()
9285 if (clp->cl_preserve_clid) in nfs4_destroy_clientid()
9292 case -NFS4ERR_STALE_CLIENTID: in nfs4_destroy_clientid()
9293 clp->cl_exchange_flags = 0; in nfs4_destroy_clientid()
9315 nfs4_setup_sequence(data->clp, in nfs4_get_lease_time_prepare()
9316 &data->args->la_seq_args, in nfs4_get_lease_time_prepare()
9317 &data->res->lr_seq_res, in nfs4_get_lease_time_prepare()
9330 if (!nfs4_sequence_done(task, &data->res->lr_seq_res)) in nfs4_get_lease_time_done()
9332 switch (task->tk_status) { in nfs4_get_lease_time_done()
9333 case -NFS4ERR_DELAY: in nfs4_get_lease_time_done()
9334 case -NFS4ERR_GRACE: in nfs4_get_lease_time_done()
9336 task->tk_status = 0; in nfs4_get_lease_time_done()
9338 case -NFS4ERR_RETRY_UNCACHED_REP: in nfs4_get_lease_time_done()
9366 .rpc_client = clp->cl_rpcclient, in nfs4_proc_get_lease_time()
9399 args->fc_attrs.max_rqst_sz = max_rqst_sz; in nfs4_init_channel_attrs()
9400 args->fc_attrs.max_resp_sz = max_resp_sz; in nfs4_init_channel_attrs()
9401 args->fc_attrs.max_ops = NFS4_MAX_OPS; in nfs4_init_channel_attrs()
9402 args->fc_attrs.max_reqs = max_session_slots; in nfs4_init_channel_attrs()
9407 args->fc_attrs.max_rqst_sz, args->fc_attrs.max_resp_sz, in nfs4_init_channel_attrs()
9408 args->fc_attrs.max_ops, args->fc_attrs.max_reqs); in nfs4_init_channel_attrs()
9411 args->bc_attrs.max_rqst_sz = max_bc_payload; in nfs4_init_channel_attrs()
9412 args->bc_attrs.max_resp_sz = max_bc_payload; in nfs4_init_channel_attrs()
9413 args->bc_attrs.max_resp_sz_cached = 0; in nfs4_init_channel_attrs()
9414 args->bc_attrs.max_ops = NFS4_MAX_BACK_CHANNEL_OPS; in nfs4_init_channel_attrs()
9415 args->bc_attrs.max_reqs = max_t(unsigned short, max_session_cb_slots, 1); in nfs4_init_channel_attrs()
9416 if (args->bc_attrs.max_reqs > max_bc_slots) in nfs4_init_channel_attrs()
9417 args->bc_attrs.max_reqs = max_bc_slots; in nfs4_init_channel_attrs()
9422 args->bc_attrs.max_rqst_sz, args->bc_attrs.max_resp_sz, in nfs4_init_channel_attrs()
9423 args->bc_attrs.max_resp_sz_cached, args->bc_attrs.max_ops, in nfs4_init_channel_attrs()
9424 args->bc_attrs.max_reqs); in nfs4_init_channel_attrs()
9430 struct nfs4_channel_attrs *sent = &args->fc_attrs; in nfs4_verify_fore_channel_attrs()
9431 struct nfs4_channel_attrs *rcvd = &res->fc_attrs; in nfs4_verify_fore_channel_attrs()
9433 if (rcvd->max_resp_sz > sent->max_resp_sz) in nfs4_verify_fore_channel_attrs()
9434 return -EINVAL; in nfs4_verify_fore_channel_attrs()
9441 if (rcvd->max_ops < sent->max_ops) in nfs4_verify_fore_channel_attrs()
9442 return -EINVAL; in nfs4_verify_fore_channel_attrs()
9443 if (rcvd->max_reqs == 0) in nfs4_verify_fore_channel_attrs()
9444 return -EINVAL; in nfs4_verify_fore_channel_attrs()
9445 if (rcvd->max_reqs > NFS4_MAX_SLOT_TABLE) in nfs4_verify_fore_channel_attrs()
9446 rcvd->max_reqs = NFS4_MAX_SLOT_TABLE; in nfs4_verify_fore_channel_attrs()
9453 struct nfs4_channel_attrs *sent = &args->bc_attrs; in nfs4_verify_back_channel_attrs()
9454 struct nfs4_channel_attrs *rcvd = &res->bc_attrs; in nfs4_verify_back_channel_attrs()
9456 if (!(res->flags & SESSION4_BACK_CHAN)) in nfs4_verify_back_channel_attrs()
9458 if (rcvd->max_rqst_sz > sent->max_rqst_sz) in nfs4_verify_back_channel_attrs()
9459 return -EINVAL; in nfs4_verify_back_channel_attrs()
9460 if (rcvd->max_resp_sz > sent->max_resp_sz) in nfs4_verify_back_channel_attrs()
9461 return -EINVAL; in nfs4_verify_back_channel_attrs()
9462 if (rcvd->max_resp_sz_cached > sent->max_resp_sz_cached) in nfs4_verify_back_channel_attrs()
9463 return -EINVAL; in nfs4_verify_back_channel_attrs()
9464 if (rcvd->max_ops > sent->max_ops) in nfs4_verify_back_channel_attrs()
9465 return -EINVAL; in nfs4_verify_back_channel_attrs()
9466 if (rcvd->max_reqs > sent->max_reqs) in nfs4_verify_back_channel_attrs()
9467 return -EINVAL; in nfs4_verify_back_channel_attrs()
9486 nfs4_copy_sessionid(&session->sess_id, &res->sessionid); in nfs4_update_session()
9488 session->clp->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R; in nfs4_update_session()
9489 set_bit(NFS4_SESSION_ESTABLISHED, &session->session_state); in nfs4_update_session()
9490 session->flags = res->flags; in nfs4_update_session()
9491 memcpy(&session->fc_attrs, &res->fc_attrs, sizeof(session->fc_attrs)); in nfs4_update_session()
9492 if (res->flags & SESSION4_BACK_CHAN) in nfs4_update_session()
9493 memcpy(&session->bc_attrs, &res->bc_attrs, in nfs4_update_session()
9494 sizeof(session->bc_attrs)); in nfs4_update_session()
9500 struct nfs4_session *session = clp->cl_session; in _nfs4_proc_create_session()
9503 .clientid = clp->cl_clientid, in _nfs4_proc_create_session()
9504 .seqid = clp->cl_seqid, in _nfs4_proc_create_session()
9517 nfs4_init_channel_attrs(&args, clp->cl_rpcclient); in _nfs4_proc_create_session()
9520 status = rpc_call_sync(session->clp->cl_rpcclient, &msg, in _nfs4_proc_create_session()
9525 case -NFS4ERR_STALE_CLIENTID: in _nfs4_proc_create_session()
9526 case -NFS4ERR_DELAY: in _nfs4_proc_create_session()
9527 case -ETIMEDOUT: in _nfs4_proc_create_session()
9528 case -EACCES: in _nfs4_proc_create_session()
9529 case -EAGAIN: in _nfs4_proc_create_session()
9533 clp->cl_seqid++; in _nfs4_proc_create_session()
9555 struct nfs4_session *session = clp->cl_session; in nfs4_proc_create_session()
9560 .add_xprt_test = clp->cl_mvops->session_trunk, in nfs4_proc_create_session()
9564 dprintk("--> %s clp=%p session=%p\n", __func__, clp, session); in nfs4_proc_create_session()
9576 ptr = (unsigned *)&session->sess_id.data[0]; in nfs4_proc_create_session()
9578 clp->cl_seqid, ptr[0], ptr[1], ptr[2], ptr[3]); in nfs4_proc_create_session()
9579 rpc_clnt_probe_trunked_xprts(clp->cl_rpcclient, &rpcdata); in nfs4_proc_create_session()
9585 * Issue the over-the-wire RPC DESTROY_SESSION.
9599 if (!test_and_clear_bit(NFS4_SESSION_ESTABLISHED, &session->session_state)) in nfs4_proc_destroy_session()
9602 status = rpc_call_sync(session->clp->cl_rpcclient, &msg, in nfs4_proc_destroy_session()
9604 trace_nfs4_destroy_session(session->clp, status); in nfs4_proc_destroy_session()
9609 rpc_clnt_manage_trunked_xprts(session->clp->cl_rpcclient); in nfs4_proc_destroy_session()
9625 struct nfs_client *clp = calldata->clp; in nfs41_sequence_release()
9627 if (refcount_read(&clp->cl_count) > 1) in nfs41_sequence_release()
9635 switch(task->tk_status) { in nfs41_sequence_handle_errors()
9636 case -NFS4ERR_DELAY: in nfs41_sequence_handle_errors()
9638 return -EAGAIN; in nfs41_sequence_handle_errors()
9648 struct nfs_client *clp = calldata->clp; in nfs41_sequence_call_done()
9650 if (!nfs41_sequence_done(task, task->tk_msg.rpc_resp)) in nfs41_sequence_call_done()
9653 trace_nfs4_sequence(clp, task->tk_status); in nfs41_sequence_call_done()
9654 if (task->tk_status < 0 && clp->cl_cons_state >= 0) { in nfs41_sequence_call_done()
9655 dprintk("%s ERROR %d\n", __func__, task->tk_status); in nfs41_sequence_call_done()
9656 if (refcount_read(&clp->cl_count) == 1) in nfs41_sequence_call_done()
9659 if (nfs41_sequence_handle_errors(task, clp) == -EAGAIN) { in nfs41_sequence_call_done()
9664 dprintk("%s rpc_cred %p\n", __func__, task->tk_msg.rpc_cred); in nfs41_sequence_call_done()
9670 struct nfs_client *clp = calldata->clp; in nfs41_sequence_prepare()
9674 args = task->tk_msg.rpc_argp; in nfs41_sequence_prepare()
9675 res = task->tk_msg.rpc_resp; in nfs41_sequence_prepare()
9697 .rpc_client = clp->cl_rpcclient, in _nfs41_proc_sequence()
9704 ret = ERR_PTR(-EIO); in _nfs41_proc_sequence()
9705 if (!refcount_inc_not_zero(&clp->cl_count)) in _nfs41_proc_sequence()
9708 ret = ERR_PTR(-ENOMEM); in _nfs41_proc_sequence()
9712 nfs4_init_sequence(&calldata->args, &calldata->res, 0, is_privileged); in _nfs41_proc_sequence()
9713 nfs4_sequence_attach_slot(&calldata->args, &calldata->res, slot); in _nfs41_proc_sequence()
9714 msg.rpc_argp = &calldata->args; in _nfs41_proc_sequence()
9715 msg.rpc_resp = &calldata->res; in _nfs41_proc_sequence()
9716 calldata->clp = clp; in _nfs41_proc_sequence()
9736 return -EAGAIN; in nfs41_proc_async_sequence()
9742 dprintk("<-- %s status=%d\n", __func__, ret); in nfs41_proc_async_sequence()
9758 ret = task->tk_status; in nfs4_proc_sequence()
9761 dprintk("<-- %s status=%d\n", __func__, ret); in nfs4_proc_sequence()
9775 nfs4_setup_sequence(calldata->clp, in nfs4_reclaim_complete_prepare()
9776 &calldata->arg.seq_args, in nfs4_reclaim_complete_prepare()
9777 &calldata->res.seq_res, in nfs4_reclaim_complete_prepare()
9783 switch(task->tk_status) { in nfs41_reclaim_complete_handle_errors()
9785 wake_up_all(&clp->cl_lock_waitq); in nfs41_reclaim_complete_handle_errors()
9787 case -NFS4ERR_COMPLETE_ALREADY: in nfs41_reclaim_complete_handle_errors()
9788 case -NFS4ERR_WRONG_CRED: /* What to do here? */ in nfs41_reclaim_complete_handle_errors()
9790 case -NFS4ERR_DELAY: in nfs41_reclaim_complete_handle_errors()
9793 case -NFS4ERR_RETRY_UNCACHED_REP: in nfs41_reclaim_complete_handle_errors()
9794 case -EACCES: in nfs41_reclaim_complete_handle_errors()
9796 __func__, task->tk_status, clp->cl_hostname); in nfs41_reclaim_complete_handle_errors()
9797 return -EAGAIN; in nfs41_reclaim_complete_handle_errors()
9798 case -NFS4ERR_BADSESSION: in nfs41_reclaim_complete_handle_errors()
9799 case -NFS4ERR_DEADSESSION: in nfs41_reclaim_complete_handle_errors()
9800 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: in nfs41_reclaim_complete_handle_errors()
9811 struct nfs_client *clp = calldata->clp; in nfs4_reclaim_complete_done()
9812 struct nfs4_sequence_res *res = &calldata->res.seq_res; in nfs4_reclaim_complete_done()
9817 trace_nfs4_reclaim_complete(clp, task->tk_status); in nfs4_reclaim_complete_done()
9818 if (nfs41_reclaim_complete_handle_errors(task, clp) == -EAGAIN) { in nfs4_reclaim_complete_done()
9849 .rpc_client = clp->cl_rpcclient, in nfs41_proc_reclaim_complete()
9854 int status = -ENOMEM; in nfs41_proc_reclaim_complete()
9859 calldata->clp = clp; in nfs41_proc_reclaim_complete()
9860 calldata->arg.one_fs = 0; in nfs41_proc_reclaim_complete()
9862 nfs4_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 0, 1); in nfs41_proc_reclaim_complete()
9863 msg.rpc_argp = &calldata->arg; in nfs41_proc_reclaim_complete()
9864 msg.rpc_resp = &calldata->res; in nfs41_proc_reclaim_complete()
9868 dprintk("<-- %s status=%d\n", __func__, status); in nfs41_proc_reclaim_complete()
9876 struct nfs_server *server = NFS_SERVER(lgp->args.inode); in nfs4_layoutget_prepare()
9878 nfs4_setup_sequence(server->nfs_client, &lgp->args.seq_args, in nfs4_layoutget_prepare()
9879 &lgp->res.seq_res, task); in nfs4_layoutget_prepare()
9886 nfs41_sequence_process(task, &lgp->res.seq_res); in nfs4_layoutget_done()
9893 struct inode *inode = lgp->args.inode; in nfs4_layoutget_handle_exception()
9895 struct pnfs_layout_hdr *lo = lgp->lo; in nfs4_layoutget_handle_exception()
9896 int nfs4err = task->tk_status; in nfs4_layoutget_handle_exception()
9900 dprintk("--> %s tk_status => %d\n", __func__, -task->tk_status); in nfs4_layoutget_handle_exception()
9902 nfs4_sequence_free_slot(&lgp->res.seq_res); in nfs4_layoutget_handle_exception()
9904 exception->state = NULL; in nfs4_layoutget_handle_exception()
9905 exception->stateid = NULL; in nfs4_layoutget_handle_exception()
9913 * on the file. set tk_status to -ENODATA to tell upper layer to in nfs4_layoutget_handle_exception()
9916 case -NFS4ERR_LAYOUTUNAVAILABLE: in nfs4_layoutget_handle_exception()
9917 status = -ENODATA; in nfs4_layoutget_handle_exception()
9921 * length lgp->args.minlength != 0 (see RFC5661 section 18.43.3). in nfs4_layoutget_handle_exception()
9923 case -NFS4ERR_BADLAYOUT: in nfs4_layoutget_handle_exception()
9924 status = -EOVERFLOW; in nfs4_layoutget_handle_exception()
9931 * Treat it like we would RECALLCONFLICT -- we retry for a little in nfs4_layoutget_handle_exception()
9934 case -NFS4ERR_LAYOUTTRYLATER: in nfs4_layoutget_handle_exception()
9935 if (lgp->args.minlength == 0) { in nfs4_layoutget_handle_exception()
9936 status = -EOVERFLOW; in nfs4_layoutget_handle_exception()
9939 status = -EBUSY; in nfs4_layoutget_handle_exception()
9941 case -NFS4ERR_RECALLCONFLICT: in nfs4_layoutget_handle_exception()
9942 case -NFS4ERR_RETURNCONFLICT: in nfs4_layoutget_handle_exception()
9943 status = -ERECALLCONFLICT; in nfs4_layoutget_handle_exception()
9945 case -NFS4ERR_DELEG_REVOKED: in nfs4_layoutget_handle_exception()
9946 case -NFS4ERR_ADMIN_REVOKED: in nfs4_layoutget_handle_exception()
9947 case -NFS4ERR_EXPIRED: in nfs4_layoutget_handle_exception()
9948 case -NFS4ERR_BAD_STATEID: in nfs4_layoutget_handle_exception()
9949 exception->timeout = 0; in nfs4_layoutget_handle_exception()
9950 spin_lock(&inode->i_lock); in nfs4_layoutget_handle_exception()
9952 if (!lo || test_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags) || in nfs4_layoutget_handle_exception()
9953 !nfs4_stateid_match_other(&lgp->args.stateid, &lo->plh_stateid)) { in nfs4_layoutget_handle_exception()
9954 spin_unlock(&inode->i_lock); in nfs4_layoutget_handle_exception()
9955 exception->state = lgp->args.ctx->state; in nfs4_layoutget_handle_exception()
9956 exception->stateid = &lgp->args.stateid; in nfs4_layoutget_handle_exception()
9964 spin_unlock(&inode->i_lock); in nfs4_layoutget_handle_exception()
9967 status = -EAGAIN; in nfs4_layoutget_handle_exception()
9973 if (exception->retry) in nfs4_layoutget_handle_exception()
9974 status = -EAGAIN; in nfs4_layoutget_handle_exception()
9984 u32 max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz; in max_response_pages()
9992 nfs4_sequence_free_slot(&lgp->res.seq_res); in nfs4_layoutget_release()
10006 struct inode *inode = lgp->args.inode; in nfs4_proc_layoutget()
10011 .rpc_argp = &lgp->args, in nfs4_proc_layoutget()
10012 .rpc_resp = &lgp->res, in nfs4_proc_layoutget()
10013 .rpc_cred = lgp->cred, in nfs4_proc_layoutget()
10016 .rpc_client = server->client, in nfs4_proc_layoutget()
10026 nfs4_init_sequence(&lgp->args.seq_args, &lgp->res.seq_res, 0, 0); in nfs4_proc_layoutget()
10027 exception->retry = 0; in nfs4_proc_layoutget()
10037 if (task->tk_status < 0) { in nfs4_proc_layoutget()
10038 exception->retry = 1; in nfs4_proc_layoutget()
10040 } else if (lgp->res.layoutp->len == 0) { in nfs4_proc_layoutget()
10041 exception->retry = 1; in nfs4_proc_layoutget()
10042 status = -EAGAIN; in nfs4_proc_layoutget()
10043 nfs4_update_delay(&exception->timeout); in nfs4_proc_layoutget()
10047 trace_nfs4_layoutget(lgp->args.ctx, in nfs4_proc_layoutget()
10048 &lgp->args.range, in nfs4_proc_layoutget()
10049 &lgp->res.range, in nfs4_proc_layoutget()
10050 &lgp->res.stateid, in nfs4_proc_layoutget()
10054 dprintk("<-- %s status=%d\n", __func__, status); in nfs4_proc_layoutget()
10065 nfs4_setup_sequence(lrp->clp, in nfs4_layoutreturn_prepare()
10066 &lrp->args.seq_args, in nfs4_layoutreturn_prepare()
10067 &lrp->res.seq_res, in nfs4_layoutreturn_prepare()
10069 if (!pnfs_layout_is_valid(lrp->args.layout)) in nfs4_layoutreturn_prepare()
10078 if (!nfs41_sequence_process(task, &lrp->res.seq_res)) in nfs4_layoutreturn_done()
10081 if (task->tk_rpc_status == -ETIMEDOUT) { in nfs4_layoutreturn_done()
10082 lrp->rpc_status = -EAGAIN; in nfs4_layoutreturn_done()
10083 lrp->res.lrs_present = 0; in nfs4_layoutreturn_done()
10090 if (task->tk_rpc_status != 0 && RPC_WAS_SENT(task)) { in nfs4_layoutreturn_done()
10091 lrp->res.lrs_present = 0; in nfs4_layoutreturn_done()
10095 server = NFS_SERVER(lrp->args.inode); in nfs4_layoutreturn_done()
10096 switch (task->tk_status) { in nfs4_layoutreturn_done()
10097 case -NFS4ERR_OLD_STATEID: in nfs4_layoutreturn_done()
10098 if (nfs4_layout_refresh_old_stateid(&lrp->args.stateid, in nfs4_layoutreturn_done()
10099 &lrp->args.range, in nfs4_layoutreturn_done()
10100 lrp->args.inode)) in nfs4_layoutreturn_done()
10104 task->tk_status = 0; in nfs4_layoutreturn_done()
10105 lrp->res.lrs_present = 0; in nfs4_layoutreturn_done()
10109 case -NFS4ERR_BADSESSION: in nfs4_layoutreturn_done()
10110 case -NFS4ERR_DEADSESSION: in nfs4_layoutreturn_done()
10111 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: in nfs4_layoutreturn_done()
10112 nfs4_schedule_session_recovery(server->nfs_client->cl_session, in nfs4_layoutreturn_done()
10113 task->tk_status); in nfs4_layoutreturn_done()
10114 lrp->res.lrs_present = 0; in nfs4_layoutreturn_done()
10115 lrp->rpc_status = -EAGAIN; in nfs4_layoutreturn_done()
10116 task->tk_status = 0; in nfs4_layoutreturn_done()
10118 case -NFS4ERR_DELAY: in nfs4_layoutreturn_done()
10120 -EAGAIN) in nfs4_layoutreturn_done()
10122 lrp->res.lrs_present = 0; in nfs4_layoutreturn_done()
10127 task->tk_status = 0; in nfs4_layoutreturn_done()
10128 nfs4_sequence_free_slot(&lrp->res.seq_res); in nfs4_layoutreturn_done()
10135 struct pnfs_layout_hdr *lo = lrp->args.layout; in nfs4_layoutreturn_release()
10137 if (lrp->rpc_status == 0 || !lrp->inode) in nfs4_layoutreturn_release()
10139 lo, &lrp->args.stateid, &lrp->args.range, in nfs4_layoutreturn_release()
10140 lrp->res.lrs_present ? &lrp->res.stateid : NULL); in nfs4_layoutreturn_release()
10142 pnfs_layoutreturn_retry_later(lo, &lrp->args.stateid, in nfs4_layoutreturn_release()
10143 &lrp->args.range); in nfs4_layoutreturn_release()
10144 nfs4_sequence_free_slot(&lrp->res.seq_res); in nfs4_layoutreturn_release()
10145 if (lrp->ld_private.ops && lrp->ld_private.ops->free) in nfs4_layoutreturn_release()
10146 lrp->ld_private.ops->free(&lrp->ld_private); in nfs4_layoutreturn_release()
10147 pnfs_put_layout_hdr(lrp->args.layout); in nfs4_layoutreturn_release()
10148 nfs_iput_and_deactive(lrp->inode); in nfs4_layoutreturn_release()
10149 put_cred(lrp->cred); in nfs4_layoutreturn_release()
10164 .rpc_argp = &lrp->args, in nfs4_proc_layoutreturn()
10165 .rpc_resp = &lrp->res, in nfs4_proc_layoutreturn()
10166 .rpc_cred = lrp->cred, in nfs4_proc_layoutreturn()
10169 .rpc_client = NFS_SERVER(lrp->args.inode)->client, in nfs4_proc_layoutreturn()
10177 nfs4_state_protect(NFS_SERVER(lrp->args.inode)->nfs_client, in nfs4_proc_layoutreturn()
10181 lrp->inode = nfs_igrab_and_active(lrp->args.inode); in nfs4_proc_layoutreturn()
10183 if (!lrp->inode) { in nfs4_proc_layoutreturn()
10185 return -EAGAIN; in nfs4_proc_layoutreturn()
10189 if (!lrp->inode) in nfs4_proc_layoutreturn()
10192 nfs4_init_sequence(&lrp->args.seq_args, &lrp->res.seq_res, 1, in nfs4_proc_layoutreturn()
10195 nfs4_init_sequence(&lrp->args.seq_args, &lrp->res.seq_res, 1, in nfs4_proc_layoutreturn()
10201 status = task->tk_status; in nfs4_proc_layoutreturn()
10202 trace_nfs4_layoutreturn(lrp->args.inode, &lrp->args.stateid, status); in nfs4_proc_layoutreturn()
10203 dprintk("<-- %s status=%d\n", __func__, status); in nfs4_proc_layoutreturn()
10229 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_proc_getdeviceinfo()
10233 pdev->nocache = 1; in _nfs4_proc_getdeviceinfo()
10235 trace_nfs4_getdeviceinfo(server, &pdev->dev_id, status); in _nfs4_proc_getdeviceinfo()
10237 dprintk("<-- %s status=%d\n", __func__, status); in _nfs4_proc_getdeviceinfo()
10261 struct nfs_server *server = NFS_SERVER(data->args.inode); in nfs4_layoutcommit_prepare()
10263 nfs4_setup_sequence(server->nfs_client, in nfs4_layoutcommit_prepare()
10264 &data->args.seq_args, in nfs4_layoutcommit_prepare()
10265 &data->res.seq_res, in nfs4_layoutcommit_prepare()
10273 struct nfs_server *server = NFS_SERVER(data->args.inode); in nfs4_layoutcommit_done()
10275 if (!nfs41_sequence_done(task, &data->res.seq_res)) in nfs4_layoutcommit_done()
10278 switch (task->tk_status) { /* Just ignore these failures */ in nfs4_layoutcommit_done()
10279 case -NFS4ERR_DELEG_REVOKED: /* layout was recalled */ in nfs4_layoutcommit_done()
10280 case -NFS4ERR_BADIOMODE: /* no IOMODE_RW layout for range */ in nfs4_layoutcommit_done()
10281 case -NFS4ERR_BADLAYOUT: /* no layout */ in nfs4_layoutcommit_done()
10282 case -NFS4ERR_GRACE: /* loca_recalim always false */ in nfs4_layoutcommit_done()
10283 task->tk_status = 0; in nfs4_layoutcommit_done()
10288 if (nfs4_async_handle_error(task, server, NULL, NULL) == -EAGAIN) { in nfs4_layoutcommit_done()
10300 nfs_post_op_update_inode_force_wcc(data->args.inode, in nfs4_layoutcommit_release()
10301 data->res.fattr); in nfs4_layoutcommit_release()
10302 put_cred(data->cred); in nfs4_layoutcommit_release()
10303 nfs_iput_and_deactive(data->inode); in nfs4_layoutcommit_release()
10318 .rpc_argp = &data->args, in nfs4_proc_layoutcommit()
10319 .rpc_resp = &data->res, in nfs4_proc_layoutcommit()
10320 .rpc_cred = data->cred, in nfs4_proc_layoutcommit()
10323 .task = &data->task, in nfs4_proc_layoutcommit()
10324 .rpc_client = NFS_CLIENT(data->args.inode), in nfs4_proc_layoutcommit()
10335 data->args.lastbytewritten, in nfs4_proc_layoutcommit()
10336 data->args.inode->i_ino); in nfs4_proc_layoutcommit()
10339 data->inode = nfs_igrab_and_active(data->args.inode); in nfs4_proc_layoutcommit()
10340 if (data->inode == NULL) { in nfs4_proc_layoutcommit()
10342 return -EAGAIN; in nfs4_proc_layoutcommit()
10346 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1, 0); in nfs4_proc_layoutcommit()
10351 status = task->tk_status; in nfs4_proc_layoutcommit()
10352 trace_nfs4_layoutcommit(data->args.inode, &data->args.stateid, status); in nfs4_proc_layoutcommit()
10384 .rpc_client = server->client, in _nfs41_proc_secinfo_no_name()
10386 .callback_ops = server->nfs_client->cl_mvops->call_sync_ops, in _nfs41_proc_secinfo_no_name()
10394 task_setup.rpc_client = server->nfs_client->cl_rpcclient; in _nfs41_proc_secinfo_no_name()
10396 cred = nfs4_get_clid_cred(server->nfs_client); in _nfs41_proc_secinfo_no_name()
10402 dprintk("<-- %s status=%d\n", __func__, status); in _nfs41_proc_secinfo_no_name()
10419 err = -NFS4ERR_WRONGSEC; in nfs41_proc_secinfo_no_name()
10422 if (_nfs4_is_integrity_protected(server->nfs_client)) in nfs41_proc_secinfo_no_name()
10432 if (err == -NFS4ERR_WRONGSEC) in nfs41_proc_secinfo_no_name()
10438 case -NFS4ERR_WRONGSEC: in nfs41_proc_secinfo_no_name()
10439 case -ENOTSUPP: in nfs41_proc_secinfo_no_name()
10461 err = -ENOMEM; in nfs41_find_root_sec()
10472 if (err == -NFS4ERR_WRONGSEC || err == -ENOTSUPP) { in nfs41_find_root_sec()
10479 for (i = 0; i < flavors->num_flavors; i++) { in nfs41_find_root_sec()
10480 secinfo = &flavors->flavors[i]; in nfs41_find_root_sec()
10482 switch (secinfo->flavor) { in nfs41_find_root_sec()
10486 flavor = rpcauth_get_pseudoflavor(secinfo->flavor, in nfs41_find_root_sec()
10487 &secinfo->flavor_info); in nfs41_find_root_sec()
10494 if (!nfs_auth_info_match(&server->auth_info, flavor)) in nfs41_find_root_sec()
10506 err = -EPERM; in nfs41_find_root_sec()
10510 if (err == -EACCES) in nfs41_find_root_sec()
10511 return -EPERM; in nfs41_find_root_sec()
10531 struct rpc_clnt *rpc_client = server->client; in _nfs41_test_stateid()
10533 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID, in _nfs41_test_stateid()
10544 dprintk("NFS reply test_stateid: succeeded, %d\n", -res.status); in _nfs41_test_stateid()
10545 return -res.status; in _nfs41_test_stateid()
10551 exception->retry = 0; in nfs4_handle_delay_or_session_error()
10553 case -NFS4ERR_DELAY: in nfs4_handle_delay_or_session_error()
10554 case -NFS4ERR_RETRY_UNCACHED_REP: in nfs4_handle_delay_or_session_error()
10557 case -NFS4ERR_BADSESSION: in nfs4_handle_delay_or_session_error()
10558 case -NFS4ERR_BADSLOT: in nfs4_handle_delay_or_session_error()
10559 case -NFS4ERR_BAD_HIGH_SLOT: in nfs4_handle_delay_or_session_error()
10560 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: in nfs4_handle_delay_or_session_error()
10561 case -NFS4ERR_DEADSESSION: in nfs4_handle_delay_or_session_error()
10567 * nfs41_test_stateid - perform a TEST_STATEID operation
10601 nfs4_setup_sequence(data->server->nfs_client, in nfs41_free_stateid_prepare()
10602 &data->args.seq_args, in nfs41_free_stateid_prepare()
10603 &data->res.seq_res, in nfs41_free_stateid_prepare()
10611 nfs41_sequence_done(task, &data->res.seq_res); in nfs41_free_stateid_done()
10613 switch (task->tk_status) { in nfs41_free_stateid_done()
10614 case -NFS4ERR_DELAY: in nfs41_free_stateid_done()
10615 if (nfs4_async_handle_error(task, data->server, NULL, NULL) == -EAGAIN) in nfs41_free_stateid_done()
10623 struct nfs_client *clp = data->server->nfs_client; in nfs41_free_stateid_release()
10636 * nfs41_free_stateid - perform a FREE_STATEID operation
10655 .rpc_client = server->client, in nfs41_free_stateid()
10662 struct nfs_client *clp = server->nfs_client; in nfs41_free_stateid()
10664 if (!refcount_inc_not_zero(&clp->cl_count)) in nfs41_free_stateid()
10665 return -EIO; in nfs41_free_stateid()
10667 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID, in nfs41_free_stateid()
10673 return -ENOMEM; in nfs41_free_stateid()
10674 data->server = server; in nfs41_free_stateid()
10675 nfs4_stateid_copy(&data->args.stateid, stateid); in nfs41_free_stateid()
10679 msg.rpc_argp = &data->args; in nfs41_free_stateid()
10680 msg.rpc_resp = &data->res; in nfs41_free_stateid()
10681 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1, privileged); in nfs41_free_stateid()
10686 stateid->type = NFS4_FREED_STATEID_TYPE; in nfs41_free_stateid()
10693 const struct cred *cred = lsp->ls_state->owner->so_cred; in nfs41_free_lock_state()
10695 nfs41_free_stateid(server, &lsp->ls_stateid, cred, false); in nfs41_free_lock_state()
10704 if (s1->type != s2->type) in nfs41_match_stateid()
10707 if (memcmp(s1->other, s2->other, sizeof(s1->other)) != 0) in nfs41_match_stateid()
10710 if (s1->seqid == s2->seqid) in nfs41_match_stateid()
10713 return s1->seqid == 0 || s2->seqid == 0; in nfs41_match_stateid()
10901 left -= error; in nfs4_listxattr()
10910 left -= error2; in nfs4_listxattr()
10918 left -= error3; in nfs4_listxattr()
10929 return -ERANGE; in nfs4_listxattr()
10938 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client; in nfs4_enable_swap()
10948 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client; in nfs4_disable_swap()
10950 set_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state); in nfs4_disable_swap()
10951 clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state); in nfs4_disable_swap()
10952 wake_up_var(&clp->cl_state); in nfs4_disable_swap()