Lines Matching +full:set +full:- +full:aces
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()
200 __func__, -err); in nfs4_map_errors()
203 return -EIO; in nfs4_map_errors()
308 cache_validity = READ_ONCE(NFS_I(inode)->cache_validity) | flags; in nfs4_bitmap_copy_adjust()
343 readdir->cookie = cookie; in nfs4_setup_readdir()
344 memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier)); in nfs4_setup_readdir()
348 readdir->cookie = 0; in nfs4_setup_readdir()
349 memset(&readdir->verifier, 0, sizeof(readdir->verifier)); in nfs4_setup_readdir()
360 start = p = kmap_atomic(*readdir->pages); in nfs4_setup_readdir()
386 p = xdr_encode_hyper(p, NFS_FILEID(d_inode(dentry->d_parent))); in nfs4_setup_readdir()
388 readdir->pgbase = (char *)p - (char *)start; in nfs4_setup_readdir()
389 readdir->count -= readdir->pgbase; in nfs4_setup_readdir()
395 if (!(fattr->valid & NFS_ATTR_FATTR_PRECHANGE)) { in nfs4_fattr_set_prechange()
396 fattr->pre_change_attr = version; in nfs4_fattr_set_prechange()
397 fattr->valid |= NFS_ATTR_FATTR_PRECHANGE; in nfs4_fattr_set_prechange()
405 const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops; in nfs4_test_and_free_stateid()
407 ops->test_and_free_expired(server, stateid, cred); in nfs4_test_and_free_stateid()
414 stateid->type = NFS4_REVOKED_STATEID_TYPE; in __nfs4_free_revoked_stateid()
450 return -EINTR; in nfs4_delay_killable()
461 return __fatal_signal_pending(current) ? -EINTR :-ERESTARTSYS; in nfs4_delay_interruptible()
476 switch (stateid->type) { in nfs4_recoverable_stateid()
493 struct nfs_client *clp = server->nfs_client; in nfs4_do_handle_exception()
494 struct nfs4_state *state = exception->state; in nfs4_do_handle_exception()
496 struct inode *inode = exception->inode; in nfs4_do_handle_exception()
499 exception->delay = 0; in nfs4_do_handle_exception()
500 exception->recovering = 0; in nfs4_do_handle_exception()
501 exception->retry = 0; in nfs4_do_handle_exception()
503 stateid = nfs4_recoverable_stateid(exception->stateid); in nfs4_do_handle_exception()
505 stateid = nfs4_recoverable_stateid(&state->stateid); in nfs4_do_handle_exception()
510 case -NFS4ERR_BADHANDLE: in nfs4_do_handle_exception()
511 case -ESTALE: in nfs4_do_handle_exception()
512 if (inode != NULL && S_ISREG(inode->i_mode)) in nfs4_do_handle_exception()
515 case -NFS4ERR_DELEG_REVOKED: in nfs4_do_handle_exception()
516 case -NFS4ERR_ADMIN_REVOKED: in nfs4_do_handle_exception()
517 case -NFS4ERR_EXPIRED: in nfs4_do_handle_exception()
518 case -NFS4ERR_BAD_STATEID: in nfs4_do_handle_exception()
519 case -NFS4ERR_PARTNER_NO_AUTH: in nfs4_do_handle_exception()
526 case -NFS4ERR_OPENMODE: in nfs4_do_handle_exception()
534 if (stateid != NULL && stateid->type == NFS4_DELEGATION_STATEID_TYPE) { in nfs4_do_handle_exception()
535 exception->retry = 1; in nfs4_do_handle_exception()
545 case -NFS4ERR_STALE_STATEID: in nfs4_do_handle_exception()
546 case -NFS4ERR_STALE_CLIENTID: in nfs4_do_handle_exception()
549 case -NFS4ERR_MOVED: in nfs4_do_handle_exception()
554 case -NFS4ERR_LEASE_MOVED: in nfs4_do_handle_exception()
558 case -NFS4ERR_BADSESSION: in nfs4_do_handle_exception()
559 case -NFS4ERR_BADSLOT: in nfs4_do_handle_exception()
560 case -NFS4ERR_BAD_HIGH_SLOT: in nfs4_do_handle_exception()
561 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: in nfs4_do_handle_exception()
562 case -NFS4ERR_DEADSESSION: in nfs4_do_handle_exception()
563 case -NFS4ERR_SEQ_FALSE_RETRY: in nfs4_do_handle_exception()
564 case -NFS4ERR_SEQ_MISORDERED: in nfs4_do_handle_exception()
568 case -NFS4ERR_FILE_OPEN: in nfs4_do_handle_exception()
569 if (exception->timeout > HZ) { in nfs4_do_handle_exception()
573 ret = -EBUSY; in nfs4_do_handle_exception()
577 case -NFS4ERR_DELAY: in nfs4_do_handle_exception()
580 case -NFS4ERR_GRACE: in nfs4_do_handle_exception()
581 case -NFS4ERR_LAYOUTTRYLATER: in nfs4_do_handle_exception()
582 case -NFS4ERR_RECALLCONFLICT: in nfs4_do_handle_exception()
583 case -NFS4ERR_RETURNCONFLICT: in nfs4_do_handle_exception()
584 exception->delay = 1; in nfs4_do_handle_exception()
587 case -NFS4ERR_RETRY_UNCACHED_REP: in nfs4_do_handle_exception()
588 case -NFS4ERR_OLD_STATEID: in nfs4_do_handle_exception()
589 exception->retry = 1; in nfs4_do_handle_exception()
591 case -NFS4ERR_BADOWNER: in nfs4_do_handle_exception()
593 case -NFS4ERR_BADNAME: in nfs4_do_handle_exception()
594 if (server->caps & NFS_CAP_UIDGID_NOMAP) { in nfs4_do_handle_exception()
595 server->caps &= ~NFS_CAP_UIDGID_NOMAP; in nfs4_do_handle_exception()
596 exception->retry = 1; in nfs4_do_handle_exception()
601 server->nfs_client->cl_hostname); in nfs4_do_handle_exception()
607 exception->recovering = 1; in nfs4_do_handle_exception()
613 * EAGAIN if the 'softerr' mount option is set, and we've exceeded the limit
614 * set by 'nfs_delay_retrans'.
619 if (server->flags & NFS_MOUNT_SOFTERR && nfs_delay_retrans >= 0) { in nfs4_exception_should_retrans()
620 if (exception->retrans++ >= (unsigned short)nfs_delay_retrans) in nfs4_exception_should_retrans()
621 return -EAGAIN; in nfs4_exception_should_retrans()
631 struct nfs_client *clp = server->nfs_client; in nfs4_handle_exception()
635 if (exception->delay) { in nfs4_handle_exception()
638 exception->retry = 0; in nfs4_handle_exception()
641 ret = nfs4_delay(&exception->timeout, in nfs4_handle_exception()
642 exception->interruptible); in nfs4_handle_exception()
645 if (exception->recovering) { in nfs4_handle_exception()
646 if (exception->task_is_privileged) in nfs4_handle_exception()
647 return -EDEADLOCK; in nfs4_handle_exception()
649 if (test_bit(NFS_MIG_FAILED, &server->mig_status)) in nfs4_handle_exception()
650 return -EIO; in nfs4_handle_exception()
656 exception->retry = 1; in nfs4_handle_exception()
664 struct nfs_client *clp = server->nfs_client; in nfs4_async_handle_exception()
668 if (exception->delay) { in nfs4_async_handle_exception()
671 exception->retry = 0; in nfs4_async_handle_exception()
674 rpc_delay(task, nfs4_update_delay(&exception->timeout)); in nfs4_async_handle_exception()
677 if (exception->recovering) { in nfs4_async_handle_exception()
678 if (exception->task_is_privileged) in nfs4_async_handle_exception()
679 return -EDEADLOCK; in nfs4_async_handle_exception()
680 rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL); in nfs4_async_handle_exception()
681 if (test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) == 0) in nfs4_async_handle_exception()
682 rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task); in nfs4_async_handle_exception()
685 if (test_bit(NFS_MIG_FAILED, &server->mig_status)) in nfs4_async_handle_exception()
686 ret = -EIO; in nfs4_async_handle_exception()
690 exception->retry = 1; in nfs4_async_handle_exception()
695 if (errorcode == -NFS4ERR_MOVED) in nfs4_async_handle_exception()
709 if (task->tk_status >= 0) in nfs4_async_handle_error()
713 task->tk_status = nfs4_async_handle_exception(task, server, in nfs4_async_handle_error()
714 task->tk_status, in nfs4_async_handle_error()
719 return -EAGAIN; in nfs4_async_handle_error()
729 rpc_authflavor_t flavor = clp->cl_rpcclient->cl_auth->au_flavor; in _nfs4_is_integrity_protected()
735 spin_lock(&clp->cl_lock); in do_renew_lease()
736 if (time_before(clp->cl_last_renewal,timestamp)) in do_renew_lease()
737 clp->cl_last_renewal = timestamp; in do_renew_lease()
738 spin_unlock(&clp->cl_lock); in do_renew_lease()
743 struct nfs_client *clp = server->nfs_client; in renew_lease()
759 args->sa_slot = NULL; in nfs4_init_sequence()
760 args->sa_cache_this = cache_reply; in nfs4_init_sequence()
761 args->sa_privileged = privileged; in nfs4_init_sequence()
763 res->sr_slot = NULL; in nfs4_init_sequence()
768 struct nfs4_slot *slot = res->sr_slot; in nfs40_sequence_free_slot()
771 tbl = slot->table; in nfs40_sequence_free_slot()
772 spin_lock(&tbl->slot_tbl_lock); in nfs40_sequence_free_slot()
775 spin_unlock(&tbl->slot_tbl_lock); in nfs40_sequence_free_slot()
777 res->sr_slot = NULL; in nfs40_sequence_free_slot()
783 if (res->sr_slot != NULL) in nfs40_sequence_done()
798 tbl = slot->table; in nfs41_release_slot()
799 session = tbl->session; in nfs41_release_slot()
802 if (slot->seq_done) in nfs41_release_slot()
803 slot->seq_nr++; in nfs41_release_slot()
804 slot->seq_done = 0; in nfs41_release_slot()
806 spin_lock(&tbl->slot_tbl_lock); in nfs41_release_slot()
810 if (tbl->highest_used_slotid > tbl->target_highest_slotid) in nfs41_release_slot()
819 if (tbl->highest_used_slotid != NFS4_NO_SLOT) in nfs41_release_slot()
822 spin_unlock(&tbl->slot_tbl_lock); in nfs41_release_slot()
824 nfs41_notify_server(session->clp); in nfs41_release_slot()
825 if (waitqueue_active(&tbl->slot_waitq)) in nfs41_release_slot()
826 wake_up_all(&tbl->slot_waitq); in nfs41_release_slot()
831 nfs41_release_slot(res->sr_slot); in nfs41_sequence_free_slot()
832 res->sr_slot = NULL; in nfs41_sequence_free_slot()
838 if ((s32)(seqnr - slot->seq_nr_highest_sent) > 0) in nfs4_slot_sequence_record_sent()
839 slot->seq_nr_highest_sent = seqnr; in nfs4_slot_sequence_record_sent()
844 slot->seq_nr_last_acked = seqnr; in nfs4_slot_sequence_acked()
859 struct nfs4_slot *slot = res->sr_slot; in nfs41_sequence_process()
867 if (!RPC_WAS_SENT(task) || slot->seq_done) in nfs41_sequence_process()
870 session = slot->table->session; in nfs41_sequence_process()
871 clp = session->clp; in nfs41_sequence_process()
875 status = res->sr_status; in nfs41_sequence_process()
876 if (task->tk_status == -NFS4ERR_DEADSESSION) in nfs41_sequence_process()
877 status = -NFS4ERR_DEADSESSION; in nfs41_sequence_process()
883 nfs4_slot_sequence_acked(slot, slot->seq_nr); in nfs41_sequence_process()
885 slot->seq_done = 1; in nfs41_sequence_process()
886 do_renew_lease(clp, res->sr_timestamp); in nfs41_sequence_process()
888 nfs41_handle_sequence_flag_errors(clp, res->sr_status_flags, in nfs41_sequence_process()
889 !!slot->privileged); in nfs41_sequence_process()
890 nfs41_update_target_slotid(slot->table, slot, res); in nfs41_sequence_process()
898 nfs4_slot_sequence_record_sent(slot, slot->seq_nr); in nfs41_sequence_process()
899 slot->seq_done = 1; in nfs41_sequence_process()
901 case -NFS4ERR_DELAY: in nfs41_sequence_process()
908 slot->slot_nr, in nfs41_sequence_process()
909 slot->seq_nr); in nfs41_sequence_process()
911 case -NFS4ERR_RETRY_UNCACHED_REP: in nfs41_sequence_process()
912 case -NFS4ERR_SEQ_FALSE_RETRY: in nfs41_sequence_process()
917 nfs4_slot_sequence_acked(slot, slot->seq_nr); in nfs41_sequence_process()
919 case -NFS4ERR_BADSLOT: in nfs41_sequence_process()
924 if (slot->slot_nr < slot->table->target_highest_slotid) in nfs41_sequence_process()
927 case -NFS4ERR_SEQ_MISORDERED: in nfs41_sequence_process()
928 nfs4_slot_sequence_record_sent(slot, slot->seq_nr); in nfs41_sequence_process()
938 if ((s32)(slot->seq_nr - slot->seq_nr_last_acked) > 1) { in nfs41_sequence_process()
939 slot->seq_nr--; in nfs41_sequence_process()
940 if (task->tk_msg.rpc_proc != &nfs4_procedures[NFSPROC4_CLNT_SEQUENCE]) { in nfs41_sequence_process()
941 nfs4_probe_sequence(clp, task->tk_msg.rpc_cred, slot); in nfs41_sequence_process()
942 res->sr_slot = NULL; in nfs41_sequence_process()
956 slot->seq_nr = slot->seq_nr_highest_sent; in nfs41_sequence_process()
958 case -NFS4ERR_BADSESSION: in nfs41_sequence_process()
959 case -NFS4ERR_DEADSESSION: in nfs41_sequence_process()
960 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: in nfs41_sequence_process()
964 slot->seq_done = 1; in nfs41_sequence_process()
968 dprintk("%s: Error %d free the slot \n", __func__, res->sr_status); in nfs41_sequence_process()
972 set_bit(NFS4_SLOT_TBL_DRAINING, &session->fc_slot_table.slot_tbl_state); in nfs41_sequence_process()
978 ++slot->seq_nr; in nfs41_sequence_process()
982 task->tk_status = 0; in nfs41_sequence_process()
997 if (res->sr_slot != NULL) in nfs41_sequence_done()
1006 if (res->sr_slot == NULL) in nfs4_sequence_process()
1008 if (res->sr_slot->table->session != NULL) in nfs4_sequence_process()
1015 if (res->sr_slot != NULL) { in nfs4_sequence_free_slot()
1016 if (res->sr_slot->table->session != NULL) in nfs4_sequence_free_slot()
1025 if (res->sr_slot == NULL) in nfs4_sequence_done()
1027 if (!res->sr_slot->table->session) in nfs4_sequence_done()
1037 dprintk("--> %s data->seq_server %p\n", __func__, data->seq_server); in nfs41_call_sync_prepare()
1039 nfs4_setup_sequence(data->seq_server->nfs_client, in nfs41_call_sync_prepare()
1040 data->seq_args, data->seq_res, task); in nfs41_call_sync_prepare()
1047 nfs41_sequence_done(task, data->seq_res); in nfs41_call_sync_done()
1064 if (res->sr_slot != NULL) in nfs4_sequence_free_slot()
1079 res->sr_timestamp = jiffies; in nfs41_sequence_res_init()
1080 res->sr_status_flags = 0; in nfs41_sequence_res_init()
1081 res->sr_status = 1; in nfs41_sequence_res_init()
1091 slot->privileged = args->sa_privileged ? 1 : 0; in nfs4_sequence_attach_slot()
1092 args->sa_slot = slot; in nfs4_sequence_attach_slot()
1094 res->sr_slot = slot; in nfs4_sequence_attach_slot()
1103 struct nfs4_slot_table *tbl = client->cl_slot_tbl; in nfs4_setup_sequence()
1107 if (res->sr_slot != NULL) in nfs4_setup_sequence()
1111 tbl = &session->fc_slot_table; in nfs4_setup_sequence()
1113 spin_lock(&tbl->slot_tbl_lock); in nfs4_setup_sequence()
1115 if (nfs4_slot_tbl_draining(tbl) && !args->sa_privileged) in nfs4_setup_sequence()
1120 if (slot == ERR_PTR(-ENOMEM)) in nfs4_setup_sequence()
1124 spin_unlock(&tbl->slot_tbl_lock); in nfs4_setup_sequence()
1135 if (args->sa_privileged) in nfs4_setup_sequence()
1136 rpc_sleep_on_priority_timeout(&tbl->slot_tbl_waitq, task, in nfs4_setup_sequence()
1139 rpc_sleep_on_timeout(&tbl->slot_tbl_waitq, task, in nfs4_setup_sequence()
1141 spin_unlock(&tbl->slot_tbl_lock); in nfs4_setup_sequence()
1142 return -EAGAIN; in nfs4_setup_sequence()
1144 if (args->sa_privileged) in nfs4_setup_sequence()
1145 rpc_sleep_on_priority(&tbl->slot_tbl_waitq, task, in nfs4_setup_sequence()
1148 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL); in nfs4_setup_sequence()
1149 spin_unlock(&tbl->slot_tbl_lock); in nfs4_setup_sequence()
1150 return -EAGAIN; in nfs4_setup_sequence()
1157 nfs4_setup_sequence(data->seq_server->nfs_client, in nfs40_call_sync_prepare()
1158 data->seq_args, data->seq_res, task); in nfs40_call_sync_prepare()
1164 nfs4_sequence_done(task, data->seq_res); in nfs40_call_sync_done()
1181 ret = task->tk_status; in nfs4_call_sync_custom()
1193 struct nfs_client *clp = server->nfs_client; in nfs4_do_call_sync()
1202 .callback_ops = clp->cl_mvops->call_sync_ops, in nfs4_do_call_sync()
1218 if (server->caps & NFS_CAP_MOVEABLE) in nfs4_call_sync_sequence()
1247 spin_lock(&inode->i_lock); in nfs4_inc_nlink()
1249 spin_unlock(&inode->i_lock); in nfs4_inc_nlink()
1271 if (S_ISDIR(inode->i_mode)) in nfs4_update_changeattr_locked()
1274 switch (NFS_SERVER(inode)->change_attr_type) { in nfs4_update_changeattr_locked()
1276 if (cinfo->after == change_attr) in nfs4_update_changeattr_locked()
1280 if ((s64)(change_attr - cinfo->after) >= 0) in nfs4_update_changeattr_locked()
1284 inode_set_iversion_raw(inode, cinfo->after); in nfs4_update_changeattr_locked()
1285 if (!cinfo->atomic || cinfo->before != change_attr) { in nfs4_update_changeattr_locked()
1286 if (S_ISDIR(inode->i_mode)) in nfs4_update_changeattr_locked()
1295 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode); in nfs4_update_changeattr_locked()
1297 nfsi->attrtimeo_timestamp = jiffies; in nfs4_update_changeattr_locked()
1298 nfsi->read_cache_jiffies = timestamp; in nfs4_update_changeattr_locked()
1299 nfsi->attr_gencount = nfs_inc_attr_generation_counter(); in nfs4_update_changeattr_locked()
1300 nfsi->cache_validity &= ~NFS_INO_INVALID_CHANGE; in nfs4_update_changeattr_locked()
1309 spin_lock(&dir->i_lock); in nfs4_update_changeattr()
1311 spin_unlock(&dir->i_lock); in nfs4_update_changeattr()
1323 if (err != -EINVAL) in nfs4_clear_cap_atomic_open_v1()
1325 if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1)) in nfs4_clear_cap_atomic_open_v1()
1327 server->caps &= ~NFS_CAP_ATOMIC_OPEN_V1; in nfs4_clear_cap_atomic_open_v1()
1328 exception->retry = 1; in nfs4_clear_cap_atomic_open_v1()
1334 return ctx->mode & (FMODE_READ|FMODE_WRITE|FMODE_EXEC); in _nfs4_ctx_to_accessmode()
1339 fmode_t ret = ctx->mode & (FMODE_READ|FMODE_WRITE); in _nfs4_ctx_to_openmode()
1341 return (ctx->mode & FMODE_EXEC) ? FMODE_READ | ret : ret; in _nfs4_ctx_to_openmode()
1368 if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1)) in nfs4_map_atomic_open_share()
1376 if (server->caps & NFS_CAP_DELEGTIME) in nfs4_map_atomic_open_share()
1378 if (server->caps & NFS_CAP_OPEN_XOR) in nfs4_map_atomic_open_share()
1388 if (server->caps & NFS_CAP_ATOMIC_OPEN_V1) in nfs4_map_atomic_open_claim()
1404 p->o_res.f_attr = &p->f_attr; in nfs4_init_opendata_res()
1405 p->o_res.seqid = p->o_arg.seqid; in nfs4_init_opendata_res()
1406 p->c_res.seqid = p->c_arg.seqid; in nfs4_init_opendata_res()
1407 p->o_res.server = p->o_arg.server; in nfs4_init_opendata_res()
1408 p->o_res.access_request = p->o_arg.access; in nfs4_init_opendata_res()
1409 nfs_fattr_init(&p->f_attr); in nfs4_init_opendata_res()
1410 nfs_fattr_init_names(&p->f_attr, &p->owner_name, &p->group_name); in nfs4_init_opendata_res()
1423 struct nfs4_label *label = (c != NULL) ? c->label : NULL; in nfs4_opendata_alloc()
1430 p->f_attr.label = nfs4_label_alloc(server, gfp_mask); in nfs4_opendata_alloc()
1431 if (IS_ERR(p->f_attr.label)) in nfs4_opendata_alloc()
1434 p->a_label = nfs4_label_alloc(server, gfp_mask); in nfs4_opendata_alloc()
1435 if (IS_ERR(p->a_label)) in nfs4_opendata_alloc()
1438 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid; in nfs4_opendata_alloc()
1439 p->o_arg.seqid = alloc_seqid(&sp->so_seqid, gfp_mask); in nfs4_opendata_alloc()
1440 if (IS_ERR(p->o_arg.seqid)) in nfs4_opendata_alloc()
1442 nfs_sb_active(dentry->d_sb); in nfs4_opendata_alloc()
1443 p->dentry = dget(dentry); in nfs4_opendata_alloc()
1444 p->dir = parent; in nfs4_opendata_alloc()
1445 p->owner = sp; in nfs4_opendata_alloc()
1446 atomic_inc(&sp->so_count); in nfs4_opendata_alloc()
1447 p->o_arg.open_flags = flags; in nfs4_opendata_alloc()
1448 p->o_arg.fmode = fmode & (FMODE_READ|FMODE_WRITE); in nfs4_opendata_alloc()
1449 p->o_arg.claim = nfs4_map_atomic_open_claim(server, claim); in nfs4_opendata_alloc()
1450 p->o_arg.share_access = nfs4_map_atomic_open_share(server, in nfs4_opendata_alloc()
1453 p->o_arg.umask = current_umask(); in nfs4_opendata_alloc()
1454 p->o_arg.label = nfs4_label_copy(p->a_label, label); in nfs4_opendata_alloc()
1455 if (c->sattr != NULL && c->sattr->ia_valid != 0) { in nfs4_opendata_alloc()
1456 p->o_arg.u.attrs = &p->attrs; in nfs4_opendata_alloc()
1457 memcpy(&p->attrs, c->sattr, sizeof(p->attrs)); in nfs4_opendata_alloc()
1459 memcpy(p->o_arg.u.verifier.data, c->verf, in nfs4_opendata_alloc()
1460 sizeof(p->o_arg.u.verifier.data)); in nfs4_opendata_alloc()
1465 switch (p->o_arg.claim) { in nfs4_opendata_alloc()
1470 p->o_arg.access = NFS4_ACCESS_READ | NFS4_ACCESS_MODIFY | in nfs4_opendata_alloc()
1475 p->o_arg.clientid = server->nfs_client->cl_clientid; in nfs4_opendata_alloc()
1476 p->o_arg.id.create_time = ktime_to_ns(sp->so_seqid.create_time); in nfs4_opendata_alloc()
1477 p->o_arg.id.uniquifier = sp->so_seqid.owner_id; in nfs4_opendata_alloc()
1478 p->o_arg.name = &dentry->d_name; in nfs4_opendata_alloc()
1479 p->o_arg.server = server; in nfs4_opendata_alloc()
1480 p->o_arg.bitmask = nfs4_bitmask(server, label); in nfs4_opendata_alloc()
1481 p->o_arg.open_bitmap = &nfs4_fattr_bitmap[0]; in nfs4_opendata_alloc()
1482 switch (p->o_arg.claim) { in nfs4_opendata_alloc()
1486 p->o_arg.fh = NFS_FH(dir); in nfs4_opendata_alloc()
1492 p->o_arg.fh = NFS_FH(d_inode(dentry)); in nfs4_opendata_alloc()
1494 p->c_arg.fh = &p->o_res.fh; in nfs4_opendata_alloc()
1495 p->c_arg.stateid = &p->o_res.stateid; in nfs4_opendata_alloc()
1496 p->c_arg.seqid = p->o_arg.seqid; in nfs4_opendata_alloc()
1498 kref_init(&p->kref); in nfs4_opendata_alloc()
1502 nfs4_label_free(p->a_label); in nfs4_opendata_alloc()
1504 nfs4_label_free(p->f_attr.label); in nfs4_opendata_alloc()
1516 struct super_block *sb = p->dentry->d_sb; in nfs4_opendata_free()
1518 nfs4_lgopen_release(p->lgp); in nfs4_opendata_free()
1519 nfs_free_seqid(p->o_arg.seqid); in nfs4_opendata_free()
1520 nfs4_sequence_free_slot(&p->o_res.seq_res); in nfs4_opendata_free()
1521 if (p->state != NULL) in nfs4_opendata_free()
1522 nfs4_put_open_state(p->state); in nfs4_opendata_free()
1523 nfs4_put_state_owner(p->owner); in nfs4_opendata_free()
1525 nfs4_label_free(p->a_label); in nfs4_opendata_free()
1526 nfs4_label_free(p->f_attr.label); in nfs4_opendata_free()
1528 dput(p->dir); in nfs4_opendata_free()
1529 dput(p->dentry); in nfs4_opendata_free()
1531 nfs_fattr_free_names(&p->f_attr); in nfs4_opendata_free()
1532 kfree(p->f_attr.mdsthreshold); in nfs4_opendata_free()
1539 kref_put(&p->kref, nfs4_opendata_free); in nfs4_opendata_put()
1547 return state->n_rdwr != 0; in nfs4_mode_match_open_stateid()
1549 return state->n_wronly != 0; in nfs4_mode_match_open_stateid()
1551 return state->n_rdonly != 0; in nfs4_mode_match_open_stateid()
1573 ret |= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0 in can_open_cached()
1574 && state->n_rdonly != 0; in can_open_cached()
1577 ret |= test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0 in can_open_cached()
1578 && state->n_wronly != 0; in can_open_cached()
1581 ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0 in can_open_cached()
1582 && state->n_rdwr != 0; in can_open_cached()
1593 if ((delegation->type & fmode) != fmode) in can_open_delegated()
1600 if (!test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags)) in can_open_delegated()
1614 state->n_wronly++; in update_open_stateflags()
1617 state->n_rdonly++; in update_open_stateflags()
1620 state->n_rdwr++; in update_open_stateflags()
1622 nfs4_state_set_mode_locked(state, state->state | fmode); in update_open_stateflags()
1628 if (state->n_rdonly && !test_bit(NFS_O_RDONLY_STATE, &state->flags)) in nfs_open_stateid_recover_openmode()
1630 if (state->n_wronly && !test_bit(NFS_O_WRONLY_STATE, &state->flags)) in nfs_open_stateid_recover_openmode()
1632 if (state->n_rdwr && !test_bit(NFS_O_RDWR_STATE, &state->flags)) in nfs_open_stateid_recover_openmode()
1640 if (test_and_clear_bit(NFS_STATE_CHANGE_WAIT, &state->flags)) in nfs_state_log_update_open_stateid()
1641 wake_up_all(&state->waitq); in nfs_state_log_update_open_stateid()
1646 struct nfs_client *clp = state->owner->so_server->nfs_client; in nfs_test_and_clear_all_open_stateid()
1649 if (test_and_clear_bit(NFS_O_RDONLY_STATE, &state->flags) && state->n_rdonly) in nfs_test_and_clear_all_open_stateid()
1651 if (test_and_clear_bit(NFS_O_WRONLY_STATE, &state->flags) && state->n_wronly) in nfs_test_and_clear_all_open_stateid()
1653 if (test_and_clear_bit(NFS_O_RDWR_STATE, &state->flags) && state->n_rdwr) in nfs_test_and_clear_all_open_stateid()
1672 if (test_bit(NFS_OPEN_STATE, &state->flags)) { in nfs_stateid_is_sequential()
1673 /* The common case - we're updating to a new sequence number */ in nfs_stateid_is_sequential()
1674 if (nfs4_stateid_match_other(stateid, &state->open_stateid)) { in nfs_stateid_is_sequential()
1675 if (nfs4_stateid_is_next(&state->open_stateid, stateid)) in nfs_stateid_is_sequential()
1682 if (stateid->seqid == cpu_to_be32(1)) in nfs_stateid_is_sequential()
1689 if (!(state->n_wronly || state->n_rdonly || state->n_rdwr)) in nfs_resync_open_stateid_locked()
1691 if (state->n_wronly) in nfs_resync_open_stateid_locked()
1692 set_bit(NFS_O_WRONLY_STATE, &state->flags); in nfs_resync_open_stateid_locked()
1693 if (state->n_rdonly) in nfs_resync_open_stateid_locked()
1694 set_bit(NFS_O_RDONLY_STATE, &state->flags); in nfs_resync_open_stateid_locked()
1695 if (state->n_rdwr) in nfs_resync_open_stateid_locked()
1696 set_bit(NFS_O_RDWR_STATE, &state->flags); in nfs_resync_open_stateid_locked()
1697 set_bit(NFS_OPEN_STATE, &state->flags); in nfs_resync_open_stateid_locked()
1703 clear_bit(NFS_O_RDWR_STATE, &state->flags); in nfs_clear_open_stateid_locked()
1706 clear_bit(NFS_O_RDONLY_STATE, &state->flags); in nfs_clear_open_stateid_locked()
1709 clear_bit(NFS_O_WRONLY_STATE, &state->flags); in nfs_clear_open_stateid_locked()
1712 clear_bit(NFS_O_RDONLY_STATE, &state->flags); in nfs_clear_open_stateid_locked()
1713 clear_bit(NFS_O_WRONLY_STATE, &state->flags); in nfs_clear_open_stateid_locked()
1714 clear_bit(NFS_OPEN_STATE, &state->flags); in nfs_clear_open_stateid_locked()
1719 if (nfs4_stateid_match_other(stateid, &state->open_stateid) && in nfs_clear_open_stateid_locked()
1720 !nfs4_stateid_is_newer(stateid, &state->open_stateid)) { in nfs_clear_open_stateid_locked()
1724 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) in nfs_clear_open_stateid_locked()
1725 nfs4_stateid_copy(&state->stateid, stateid); in nfs_clear_open_stateid_locked()
1726 nfs4_stateid_copy(&state->open_stateid, stateid); in nfs_clear_open_stateid_locked()
1727 trace_nfs4_open_stateid_update(state->inode, stateid, 0); in nfs_clear_open_stateid_locked()
1736 write_seqlock(&state->seqlock); in nfs_clear_open_stateid()
1740 write_sequnlock(&state->seqlock); in nfs_clear_open_stateid()
1741 if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) in nfs_clear_open_stateid()
1742 nfs4_schedule_state_manager(state->owner->so_server->nfs_client); in nfs_clear_open_stateid()
1747 __must_hold(&state->owner->so_lock) in nfs_set_open_stateid_locked()
1748 __must_hold(&state->seqlock) in nfs_set_open_stateid_locked()
1762 if (!nfs4_has_session(NFS_SERVER(state->inode)->nfs_client)) in nfs_set_open_stateid_locked()
1765 set_bit(NFS_STATE_CHANGE_WAIT, &state->flags); in nfs_set_open_stateid_locked()
1766 prepare_to_wait(&state->waitq, &wait, TASK_KILLABLE); in nfs_set_open_stateid_locked()
1772 write_sequnlock(&state->seqlock); in nfs_set_open_stateid_locked()
1773 spin_unlock(&state->owner->so_lock); in nfs_set_open_stateid_locked()
1775 trace_nfs4_open_stateid_update_wait(state->inode, stateid, 0); in nfs_set_open_stateid_locked()
1779 status = -EAGAIN; in nfs_set_open_stateid_locked()
1783 status = -EINTR; in nfs_set_open_stateid_locked()
1784 finish_wait(&state->waitq, &wait); in nfs_set_open_stateid_locked()
1786 spin_lock(&state->owner->so_lock); in nfs_set_open_stateid_locked()
1787 write_seqlock(&state->seqlock); in nfs_set_open_stateid_locked()
1790 if (test_bit(NFS_OPEN_STATE, &state->flags) && in nfs_set_open_stateid_locked()
1791 !nfs4_stateid_match_other(stateid, &state->open_stateid)) { in nfs_set_open_stateid_locked()
1792 nfs4_stateid_copy(freeme, &state->open_stateid); in nfs_set_open_stateid_locked()
1796 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) in nfs_set_open_stateid_locked()
1797 nfs4_stateid_copy(&state->stateid, stateid); in nfs_set_open_stateid_locked()
1798 nfs4_stateid_copy(&state->open_stateid, stateid); in nfs_set_open_stateid_locked()
1799 trace_nfs4_open_stateid_update(state->inode, stateid, status); in nfs_set_open_stateid_locked()
1812 write_seqlock(&state->seqlock); in nfs_state_set_open_stateid()
1816 set_bit(NFS_O_RDONLY_STATE, &state->flags); in nfs_state_set_open_stateid()
1819 set_bit(NFS_O_WRONLY_STATE, &state->flags); in nfs_state_set_open_stateid()
1822 set_bit(NFS_O_RDWR_STATE, &state->flags); in nfs_state_set_open_stateid()
1824 set_bit(NFS_OPEN_STATE, &state->flags); in nfs_state_set_open_stateid()
1825 write_sequnlock(&state->seqlock); in nfs_state_set_open_stateid()
1830 clear_bit(NFS_O_RDWR_STATE, &state->flags); in nfs_state_clear_open_state_flags()
1831 clear_bit(NFS_O_WRONLY_STATE, &state->flags); in nfs_state_clear_open_state_flags()
1832 clear_bit(NFS_O_RDONLY_STATE, &state->flags); in nfs_state_clear_open_state_flags()
1833 clear_bit(NFS_OPEN_STATE, &state->flags); in nfs_state_clear_open_state_flags()
1844 write_seqlock(&state->seqlock); in nfs_state_set_delegation()
1845 nfs4_stateid_copy(&state->stateid, deleg_stateid); in nfs_state_set_delegation()
1846 set_bit(NFS_DELEGATED_STATE, &state->flags); in nfs_state_set_delegation()
1847 write_sequnlock(&state->seqlock); in nfs_state_set_delegation()
1852 write_seqlock(&state->seqlock); in nfs_state_clear_delegation()
1853 nfs4_stateid_copy(&state->stateid, &state->open_stateid); in nfs_state_clear_delegation()
1854 clear_bit(NFS_DELEGATED_STATE, &state->flags); in nfs_state_clear_delegation()
1855 write_sequnlock(&state->seqlock); in nfs_state_clear_delegation()
1863 struct nfs_server *server = NFS_SERVER(state->inode); in update_open_stateid()
1864 struct nfs_client *clp = server->nfs_client; in update_open_stateid()
1865 struct nfs_inode *nfsi = NFS_I(state->inode); in update_open_stateid()
1873 spin_lock(&state->owner->so_lock); in update_open_stateid()
1879 deleg_cur = nfs4_get_valid_delegation(state->inode); in update_open_stateid()
1883 spin_lock(&deleg_cur->lock); in update_open_stateid()
1884 if (rcu_dereference(nfsi->delegation) != deleg_cur || in update_open_stateid()
1885 test_bit(NFS_DELEGATION_RETURNING, &deleg_cur->flags) || in update_open_stateid()
1886 (deleg_cur->type & fmode) != fmode) in update_open_stateid()
1890 delegation = &deleg_cur->stateid; in update_open_stateid()
1891 else if (!nfs4_stateid_match_other(&deleg_cur->stateid, delegation)) in update_open_stateid()
1895 nfs_state_set_delegation(state, &deleg_cur->stateid, fmode); in update_open_stateid()
1898 spin_unlock(&deleg_cur->lock); in update_open_stateid()
1902 spin_unlock(&state->owner->so_lock); in update_open_stateid()
1905 if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) in update_open_stateid()
1909 state->owner->so_cred); in update_open_stateid()
1917 struct nfs4_state *state = lsp->ls_state; in nfs4_update_lock_stateid()
1920 spin_lock(&state->state_lock); in nfs4_update_lock_stateid()
1921 if (!nfs4_stateid_match_other(stateid, &lsp->ls_stateid)) in nfs4_update_lock_stateid()
1923 if (!nfs4_stateid_is_newer(stateid, &lsp->ls_stateid)) in nfs4_update_lock_stateid()
1925 nfs4_stateid_copy(&lsp->ls_stateid, stateid); in nfs4_update_lock_stateid()
1928 spin_unlock(&state->state_lock); in nfs4_update_lock_stateid()
1939 if (delegation == NULL || (delegation->type & fmode) == fmode) { in nfs4_return_incompatible_delegation()
1949 struct nfs4_state *state = opendata->state; in nfs4_try_open_cached()
1951 int open_mode = opendata->o_arg.open_flags; in nfs4_try_open_cached()
1952 fmode_t fmode = opendata->o_arg.fmode; in nfs4_try_open_cached()
1953 enum open_claim_type4 claim = opendata->o_arg.claim; in nfs4_try_open_cached()
1955 int ret = -EAGAIN; in nfs4_try_open_cached()
1958 spin_lock(&state->owner->so_lock); in nfs4_try_open_cached()
1961 spin_unlock(&state->owner->so_lock); in nfs4_try_open_cached()
1964 spin_unlock(&state->owner->so_lock); in nfs4_try_open_cached()
1966 delegation = nfs4_get_valid_delegation(state->inode); in nfs4_try_open_cached()
1972 nfs4_stateid_copy(&stateid, &delegation->stateid); in nfs4_try_open_cached()
1974 nfs_release_seqid(opendata->o_arg.seqid); in nfs4_try_open_cached()
1975 if (!opendata->is_recover) { in nfs4_try_open_cached()
1976 ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode); in nfs4_try_open_cached()
1980 ret = -EAGAIN; in nfs4_try_open_cached()
1989 refcount_inc(&state->count); in nfs4_try_open_cached()
1998 switch (delegation->open_delegation_type) { in nfs4_process_delegation()
2013 NFS_SERVER(inode)->nfs_client->cl_hostname); in nfs4_process_delegation()
2016 nfs_inode_reclaim_delegation(inode, cred, delegation->type, in nfs4_process_delegation()
2017 &delegation->stateid, in nfs4_process_delegation()
2018 delegation->pagemod_limit, in nfs4_process_delegation()
2019 delegation->open_delegation_type); in nfs4_process_delegation()
2022 nfs_inode_set_delegation(inode, cred, delegation->type, in nfs4_process_delegation()
2023 &delegation->stateid, in nfs4_process_delegation()
2024 delegation->pagemod_limit, in nfs4_process_delegation()
2025 delegation->open_delegation_type); in nfs4_process_delegation()
2027 if (delegation->do_recall) in nfs4_process_delegation()
2028 nfs_async_inode_return_delegation(inode, &delegation->stateid); in nfs4_process_delegation()
2038 struct inode *inode = data->state->inode; in _nfs4_opendata_reclaim_to_nfs4_state()
2039 struct nfs4_state *state = data->state; in _nfs4_opendata_reclaim_to_nfs4_state()
2042 if (!data->rpc_done) { in _nfs4_opendata_reclaim_to_nfs4_state()
2043 if (data->rpc_status) in _nfs4_opendata_reclaim_to_nfs4_state()
2044 return ERR_PTR(data->rpc_status); in _nfs4_opendata_reclaim_to_nfs4_state()
2048 ret = nfs_refresh_inode(inode, &data->f_attr); in _nfs4_opendata_reclaim_to_nfs4_state()
2052 nfs4_process_delegation(state->inode, in _nfs4_opendata_reclaim_to_nfs4_state()
2053 data->owner->so_cred, in _nfs4_opendata_reclaim_to_nfs4_state()
2054 data->o_arg.claim, in _nfs4_opendata_reclaim_to_nfs4_state()
2055 &data->o_res.delegation); in _nfs4_opendata_reclaim_to_nfs4_state()
2057 if (!(data->o_res.rflags & NFS4_OPEN_RESULT_NO_OPEN_STATEID)) { in _nfs4_opendata_reclaim_to_nfs4_state()
2058 if (!update_open_stateid(state, &data->o_res.stateid, in _nfs4_opendata_reclaim_to_nfs4_state()
2059 NULL, data->o_arg.fmode)) in _nfs4_opendata_reclaim_to_nfs4_state()
2060 return ERR_PTR(-EAGAIN); in _nfs4_opendata_reclaim_to_nfs4_state()
2061 } else if (!update_open_stateid(state, NULL, NULL, data->o_arg.fmode)) in _nfs4_opendata_reclaim_to_nfs4_state()
2062 return ERR_PTR(-EAGAIN); in _nfs4_opendata_reclaim_to_nfs4_state()
2063 refcount_inc(&state->count); in _nfs4_opendata_reclaim_to_nfs4_state()
2073 switch (data->o_arg.claim) { in nfs4_opendata_get_inode()
2077 if (!(data->f_attr.valid & NFS_ATTR_FATTR)) in nfs4_opendata_get_inode()
2078 return ERR_PTR(-EAGAIN); in nfs4_opendata_get_inode()
2079 inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, in nfs4_opendata_get_inode()
2080 &data->f_attr); in nfs4_opendata_get_inode()
2083 inode = d_inode(data->dentry); in nfs4_opendata_get_inode()
2085 nfs_refresh_inode(inode, &data->f_attr); in nfs4_opendata_get_inode()
2099 if (data->state != NULL && data->state->inode == inode) { in nfs4_opendata_find_nfs4_state()
2100 state = data->state; in nfs4_opendata_find_nfs4_state()
2101 refcount_inc(&state->count); in nfs4_opendata_find_nfs4_state()
2103 state = nfs4_get_open_state(inode, data->owner); in nfs4_opendata_find_nfs4_state()
2106 state = ERR_PTR(-ENOMEM); in nfs4_opendata_find_nfs4_state()
2115 if (!data->rpc_done) { in _nfs4_opendata_to_nfs4_state()
2117 trace_nfs4_cached_open(data->state); in _nfs4_opendata_to_nfs4_state()
2125 nfs4_process_delegation(state->inode, in _nfs4_opendata_to_nfs4_state()
2126 data->owner->so_cred, in _nfs4_opendata_to_nfs4_state()
2127 data->o_arg.claim, in _nfs4_opendata_to_nfs4_state()
2128 &data->o_res.delegation); in _nfs4_opendata_to_nfs4_state()
2130 if (!(data->o_res.rflags & NFS4_OPEN_RESULT_NO_OPEN_STATEID)) { in _nfs4_opendata_to_nfs4_state()
2131 if (!update_open_stateid(state, &data->o_res.stateid, in _nfs4_opendata_to_nfs4_state()
2132 NULL, data->o_arg.fmode)) { in _nfs4_opendata_to_nfs4_state()
2134 state = ERR_PTR(-EAGAIN); in _nfs4_opendata_to_nfs4_state()
2136 } else if (!update_open_stateid(state, NULL, NULL, data->o_arg.fmode)) { in _nfs4_opendata_to_nfs4_state()
2138 state = ERR_PTR(-EAGAIN); in _nfs4_opendata_to_nfs4_state()
2141 nfs_release_seqid(data->o_arg.seqid); in _nfs4_opendata_to_nfs4_state()
2150 if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS) in nfs4_opendata_to_nfs4_state()
2154 nfs4_sequence_free_slot(&data->o_res.seq_res); in nfs4_opendata_to_nfs4_state()
2161 struct nfs_inode *nfsi = NFS_I(state->inode); in nfs4_state_find_open_context_mode()
2165 list_for_each_entry_rcu(ctx, &nfsi->open_files, list) { in nfs4_state_find_open_context_mode()
2166 if (ctx->state != state) in nfs4_state_find_open_context_mode()
2168 if ((ctx->mode & mode) != mode) in nfs4_state_find_open_context_mode()
2176 return ERR_PTR(-ENOENT); in nfs4_state_find_open_context_mode()
2198 opendata = nfs4_opendata_alloc(ctx->dentry, state->owner, 0, 0, in nfs4_open_recoverdata_alloc()
2201 return ERR_PTR(-ENOMEM); in nfs4_open_recoverdata_alloc()
2202 opendata->state = state; in nfs4_open_recoverdata_alloc()
2203 refcount_inc(&state->count); in nfs4_open_recoverdata_alloc()
2211 struct nfs_server *server = NFS_SB(opendata->dentry->d_sb); in nfs4_open_recover_helper()
2212 int openflags = opendata->o_arg.open_flags; in nfs4_open_recover_helper()
2215 if (!nfs4_mode_match_open_stateid(opendata->state, fmode)) in nfs4_open_recover_helper()
2217 opendata->o_arg.fmode = fmode; in nfs4_open_recover_helper()
2218 opendata->o_arg.share_access = in nfs4_open_recover_helper()
2220 memset(&opendata->o_res, 0, sizeof(opendata->o_res)); in nfs4_open_recover_helper()
2221 memset(&opendata->c_res, 0, sizeof(opendata->c_res)); in nfs4_open_recover_helper()
2229 if (newstate != opendata->state) in nfs4_open_recover_helper()
2230 ret = -ESTALE; in nfs4_open_recover_helper()
2239 /* memory barrier prior to reading state->n_* */ in nfs4_open_recover()
2254 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 && in nfs4_open_recover()
2255 !nfs4_stateid_match(&state->stateid, &state->open_stateid)) { in nfs4_open_recover()
2256 write_seqlock(&state->seqlock); in nfs4_open_recover()
2257 if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0) in nfs4_open_recover()
2258 nfs4_stateid_copy(&state->stateid, &state->open_stateid); in nfs4_open_recover()
2259 write_sequnlock(&state->seqlock); in nfs4_open_recover()
2280 delegation = rcu_dereference(NFS_I(state->inode)->delegation); in _nfs4_do_open_reclaim()
2281 if (delegation != NULL && test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) != 0) { in _nfs4_do_open_reclaim()
2282 switch(delegation->type) { in _nfs4_do_open_reclaim()
2285 if (test_bit(NFS_DELEGATION_DELEGTIME, &delegation->flags)) in _nfs4_do_open_reclaim()
2291 if (test_bit(NFS_DELEGATION_DELEGTIME, &delegation->flags)) in _nfs4_do_open_reclaim()
2296 opendata->o_arg.u.delegation_type = delegation_type; in _nfs4_do_open_reclaim()
2304 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_do_open_reclaim()
2312 if (err != -NFS4ERR_DELAY) in nfs4_do_open_reclaim()
2326 return -EAGAIN; in nfs4_open_reclaim()
2327 clear_bit(NFS_DELEGATED_STATE, &state->flags); in nfs4_open_reclaim()
2342 case -ENOENT: in nfs4_handle_delegation_recall_error()
2343 case -EAGAIN: in nfs4_handle_delegation_recall_error()
2344 case -ESTALE: in nfs4_handle_delegation_recall_error()
2345 case -ETIMEDOUT: in nfs4_handle_delegation_recall_error()
2347 case -NFS4ERR_BADSESSION: in nfs4_handle_delegation_recall_error()
2348 case -NFS4ERR_BADSLOT: in nfs4_handle_delegation_recall_error()
2349 case -NFS4ERR_BAD_HIGH_SLOT: in nfs4_handle_delegation_recall_error()
2350 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: in nfs4_handle_delegation_recall_error()
2351 case -NFS4ERR_DEADSESSION: in nfs4_handle_delegation_recall_error()
2352 return -EAGAIN; in nfs4_handle_delegation_recall_error()
2353 case -NFS4ERR_STALE_CLIENTID: in nfs4_handle_delegation_recall_error()
2354 case -NFS4ERR_STALE_STATEID: in nfs4_handle_delegation_recall_error()
2356 nfs4_schedule_lease_recovery(server->nfs_client); in nfs4_handle_delegation_recall_error()
2357 return -EAGAIN; in nfs4_handle_delegation_recall_error()
2358 case -NFS4ERR_MOVED: in nfs4_handle_delegation_recall_error()
2360 return -EAGAIN; in nfs4_handle_delegation_recall_error()
2361 case -NFS4ERR_LEASE_MOVED: in nfs4_handle_delegation_recall_error()
2362 nfs4_schedule_lease_moved_recovery(server->nfs_client); in nfs4_handle_delegation_recall_error()
2363 return -EAGAIN; in nfs4_handle_delegation_recall_error()
2364 case -NFS4ERR_DELEG_REVOKED: in nfs4_handle_delegation_recall_error()
2365 case -NFS4ERR_ADMIN_REVOKED: in nfs4_handle_delegation_recall_error()
2366 case -NFS4ERR_EXPIRED: in nfs4_handle_delegation_recall_error()
2367 case -NFS4ERR_BAD_STATEID: in nfs4_handle_delegation_recall_error()
2368 case -NFS4ERR_OPENMODE: in nfs4_handle_delegation_recall_error()
2369 nfs_inode_find_state_and_recover(state->inode, in nfs4_handle_delegation_recall_error()
2372 return -EAGAIN; in nfs4_handle_delegation_recall_error()
2373 case -NFS4ERR_DELAY: in nfs4_handle_delegation_recall_error()
2374 case -NFS4ERR_GRACE: in nfs4_handle_delegation_recall_error()
2376 return -EAGAIN; in nfs4_handle_delegation_recall_error()
2377 case -ENOMEM: in nfs4_handle_delegation_recall_error()
2378 case -NFS4ERR_DENIED: in nfs4_handle_delegation_recall_error()
2380 struct nfs4_lock_state *lsp = fl->fl_u.nfs4_fl.owner; in nfs4_handle_delegation_recall_error()
2382 set_bit(NFS_LOCK_LOST, &lsp->ls_flags); in nfs4_handle_delegation_recall_error()
2392 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_open_delegation_recall()
2400 nfs4_stateid_copy(&opendata->o_arg.u.delegation, stateid); in nfs4_open_delegation_recall()
2401 if (!test_bit(NFS_O_RDWR_STATE, &state->flags)) { in nfs4_open_delegation_recall()
2406 if (!test_bit(NFS_O_WRONLY_STATE, &state->flags)) { in nfs4_open_delegation_recall()
2411 if (!test_bit(NFS_O_RDONLY_STATE, &state->flags)) { in nfs4_open_delegation_recall()
2426 nfs4_setup_sequence(data->o_arg.server->nfs_client, in nfs4_open_confirm_prepare()
2427 &data->c_arg.seq_args, &data->c_res.seq_res, task); in nfs4_open_confirm_prepare()
2434 nfs40_sequence_done(task, &data->c_res.seq_res); in nfs4_open_confirm_done()
2436 data->rpc_status = task->tk_status; in nfs4_open_confirm_done()
2437 if (data->rpc_status == 0) { in nfs4_open_confirm_done()
2438 nfs4_stateid_copy(&data->o_res.stateid, &data->c_res.stateid); in nfs4_open_confirm_done()
2439 nfs_confirm_seqid(&data->owner->so_seqid, 0); in nfs4_open_confirm_done()
2440 renew_lease(data->o_res.server, data->timestamp); in nfs4_open_confirm_done()
2441 data->rpc_done = true; in nfs4_open_confirm_done()
2451 if (!data->cancelled) in nfs4_open_confirm_release()
2454 if (!data->rpc_done) in nfs4_open_confirm_release()
2458 nfs4_close_state(state, data->o_arg.fmode); in nfs4_open_confirm_release()
2474 struct nfs_server *server = NFS_SERVER(d_inode(data->dir)); in _nfs4_proc_open_confirm()
2478 .rpc_argp = &data->c_arg, in _nfs4_proc_open_confirm()
2479 .rpc_resp = &data->c_res, in _nfs4_proc_open_confirm()
2480 .rpc_cred = data->owner->so_cred, in _nfs4_proc_open_confirm()
2483 .rpc_client = server->client, in _nfs4_proc_open_confirm()
2492 nfs4_init_sequence(&data->c_arg.seq_args, &data->c_res.seq_res, 1, in _nfs4_proc_open_confirm()
2493 data->is_recover); in _nfs4_proc_open_confirm()
2494 kref_get(&data->kref); in _nfs4_proc_open_confirm()
2495 data->rpc_done = false; in _nfs4_proc_open_confirm()
2496 data->rpc_status = 0; in _nfs4_proc_open_confirm()
2497 data->timestamp = jiffies; in _nfs4_proc_open_confirm()
2503 data->cancelled = true; in _nfs4_proc_open_confirm()
2506 status = data->rpc_status; in _nfs4_proc_open_confirm()
2514 struct nfs4_state_owner *sp = data->owner; in nfs4_open_prepare()
2515 struct nfs_client *clp = sp->so_server->nfs_client; in nfs4_open_prepare()
2516 enum open_claim_type4 claim = data->o_arg.claim; in nfs4_open_prepare()
2518 if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0) in nfs4_open_prepare()
2524 if (data->state != NULL) { in nfs4_open_prepare()
2527 if (can_open_cached(data->state, data->o_arg.fmode, in nfs4_open_prepare()
2528 data->o_arg.open_flags, claim)) in nfs4_open_prepare()
2531 delegation = nfs4_get_valid_delegation(data->state->inode); in nfs4_open_prepare()
2532 if (can_open_delegated(delegation, data->o_arg.fmode, claim)) in nfs4_open_prepare()
2537 data->o_arg.clientid = clp->cl_clientid; in nfs4_open_prepare()
2544 data->o_arg.open_bitmap = &nfs4_open_noattr_bitmap[0]; in nfs4_open_prepare()
2547 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR]; in nfs4_open_prepare()
2549 data->timestamp = jiffies; in nfs4_open_prepare()
2550 if (nfs4_setup_sequence(data->o_arg.server->nfs_client, in nfs4_open_prepare()
2551 &data->o_arg.seq_args, in nfs4_open_prepare()
2552 &data->o_res.seq_res, in nfs4_open_prepare()
2554 nfs_release_seqid(data->o_arg.seqid); in nfs4_open_prepare()
2556 /* Set the create mode (note dependency on the session type) */ in nfs4_open_prepare()
2557 data->o_arg.createmode = NFS4_CREATE_UNCHECKED; in nfs4_open_prepare()
2558 if (data->o_arg.open_flags & O_EXCL) { in nfs4_open_prepare()
2559 data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE4_1; in nfs4_open_prepare()
2560 if (clp->cl_mvops->minor_version == 0) { in nfs4_open_prepare()
2561 data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE; in nfs4_open_prepare()
2565 data->o_res.access_request = data->o_arg.access = 0; in nfs4_open_prepare()
2567 data->o_arg.createmode = NFS4_CREATE_GUARDED; in nfs4_open_prepare()
2571 trace_nfs4_cached_open(data->state); in nfs4_open_prepare()
2574 task->tk_action = NULL; in nfs4_open_prepare()
2576 nfs4_sequence_done(task, &data->o_res.seq_res); in nfs4_open_prepare()
2583 data->rpc_status = task->tk_status; in nfs4_open_done()
2585 if (!nfs4_sequence_process(task, &data->o_res.seq_res)) in nfs4_open_done()
2588 if (task->tk_status == 0) { in nfs4_open_done()
2589 if (data->o_res.f_attr->valid & NFS_ATTR_FATTR_TYPE) { in nfs4_open_done()
2590 switch (data->o_res.f_attr->mode & S_IFMT) { in nfs4_open_done()
2594 data->rpc_status = -ELOOP; in nfs4_open_done()
2597 data->rpc_status = -EISDIR; in nfs4_open_done()
2600 data->rpc_status = -ENOTDIR; in nfs4_open_done()
2603 renew_lease(data->o_res.server, data->timestamp); in nfs4_open_done()
2604 if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)) in nfs4_open_done()
2605 nfs_confirm_seqid(&data->owner->so_seqid, 0); in nfs4_open_done()
2607 data->rpc_done = true; in nfs4_open_done()
2616 if (data->rpc_status != 0 || !data->rpc_done) { in nfs4_open_release()
2617 nfs_release_seqid(data->o_arg.seqid); in nfs4_open_release()
2621 if (!data->cancelled) in nfs4_open_release()
2624 if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM) in nfs4_open_release()
2628 nfs4_close_state(state, data->o_arg.fmode); in nfs4_open_release()
2642 struct inode *dir = d_inode(data->dir); in nfs4_run_open_task()
2644 struct nfs_openargs *o_arg = &data->o_arg; in nfs4_run_open_task()
2645 struct nfs_openres *o_res = &data->o_res; in nfs4_run_open_task()
2651 .rpc_cred = data->owner->so_cred, in nfs4_run_open_task()
2654 .rpc_client = server->client, in nfs4_run_open_task()
2666 kref_get(&data->kref); in nfs4_run_open_task()
2667 data->rpc_done = false; in nfs4_run_open_task()
2668 data->rpc_status = 0; in nfs4_run_open_task()
2669 data->cancelled = false; in nfs4_run_open_task()
2670 data->is_recover = false; in nfs4_run_open_task()
2672 nfs4_init_sequence(&o_arg->seq_args, &o_res->seq_res, 1, 1); in nfs4_run_open_task()
2673 data->is_recover = true; in nfs4_run_open_task()
2676 nfs4_init_sequence(&o_arg->seq_args, &o_res->seq_res, 1, 0); in nfs4_run_open_task()
2684 data->cancelled = true; in nfs4_run_open_task()
2687 status = data->rpc_status; in nfs4_run_open_task()
2695 struct inode *dir = d_inode(data->dir); in _nfs4_recover_proc_open()
2696 struct nfs_openres *o_res = &data->o_res; in _nfs4_recover_proc_open()
2700 if (status != 0 || !data->rpc_done) in _nfs4_recover_proc_open()
2703 nfs_fattr_map_and_free_names(NFS_SERVER(dir), &data->f_attr); in _nfs4_recover_proc_open()
2705 if (o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) in _nfs4_recover_proc_open()
2716 * Note that in the non-execute case, we want to turn off permission
2727 * support any access modes -- defer access call until later */ in nfs4_opendata_access()
2728 if (opendata->o_res.access_supported == 0) in nfs4_opendata_access()
2734 if (S_ISDIR(state->inode->i_mode)) in nfs4_opendata_access()
2738 } else if ((fmode & FMODE_READ) && !opendata->file_created) in nfs4_opendata_access()
2741 nfs_access_set_mask(&cache, opendata->o_res.access_result); in nfs4_opendata_access()
2742 nfs_access_add_cache(state->inode, &cache, cred); in nfs4_opendata_access()
2748 return -EACCES; in nfs4_opendata_access()
2757 struct inode *dir = d_inode(data->dir); in _nfs4_proc_open()
2759 struct nfs_openargs *o_arg = &data->o_arg; in _nfs4_proc_open()
2760 struct nfs_openres *o_res = &data->o_res; in _nfs4_proc_open()
2764 if (!data->rpc_done) in _nfs4_proc_open()
2767 if (status == -NFS4ERR_BADNAME && in _nfs4_proc_open()
2768 !(o_arg->open_flags & O_CREAT)) in _nfs4_proc_open()
2769 return -ENOENT; in _nfs4_proc_open()
2773 nfs_fattr_map_and_free_names(server, &data->f_attr); in _nfs4_proc_open()
2775 if (o_arg->open_flags & O_CREAT) { in _nfs4_proc_open()
2776 if (o_arg->open_flags & O_EXCL) in _nfs4_proc_open()
2777 data->file_created = true; in _nfs4_proc_open()
2778 else if (o_res->cinfo.before != o_res->cinfo.after) in _nfs4_proc_open()
2779 data->file_created = true; in _nfs4_proc_open()
2780 if (data->file_created || in _nfs4_proc_open()
2781 inode_peek_iversion_raw(dir) != o_res->cinfo.after) in _nfs4_proc_open()
2782 nfs4_update_changeattr(dir, &o_res->cinfo, in _nfs4_proc_open()
2783 o_res->f_attr->time_start, in _nfs4_proc_open()
2786 if ((o_res->rflags & NFS4_OPEN_RESULT_LOCKTYPE_POSIX) == 0) in _nfs4_proc_open()
2787 server->caps &= ~NFS_CAP_POSIX_LOCK; in _nfs4_proc_open()
2788 if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) { in _nfs4_proc_open()
2793 if (!(o_res->f_attr->valid & NFS_ATTR_FATTR)) { in _nfs4_proc_open()
2794 struct nfs_fh *fh = &o_res->fh; in _nfs4_proc_open()
2796 nfs4_sequence_free_slot(&o_res->seq_res); in _nfs4_proc_open()
2797 if (o_arg->claim == NFS4_OPEN_CLAIM_FH) in _nfs4_proc_open()
2798 fh = NFS_FH(d_inode(data->dentry)); in _nfs4_proc_open()
2799 nfs4_proc_getattr(server, fh, o_res->f_attr, NULL); in _nfs4_proc_open()
2822 opendata->o_arg.open_flags = O_DIRECT; in _nfs4_open_expired()
2824 if (ret == -ESTALE) in _nfs4_open_expired()
2825 d_drop(ctx->dentry); in _nfs4_open_expired()
2832 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_do_open_expired()
2844 case -NFS4ERR_GRACE: in nfs4_do_open_expired()
2845 case -NFS4ERR_DELAY: in nfs4_do_open_expired()
2861 return -EAGAIN; in nfs4_open_expired()
2870 nfs_remove_bad_delegation(state->inode, stateid); in nfs_finish_clear_delegation_stateid()
2876 if (rcu_access_pointer(NFS_I(state->inode)->delegation) != NULL) in nfs40_clear_delegation_stateid()
2892 return -NFS4ERR_BAD_STATEID; in nfs40_test_and_free_expired_stateid()
2902 switch (stateid->type) { in nfs41_test_and_free_expired_stateid()
2907 return -NFS4ERR_BAD_STATEID; in nfs41_test_and_free_expired_stateid()
2914 case -NFS4ERR_EXPIRED: in nfs41_test_and_free_expired_stateid()
2915 case -NFS4ERR_ADMIN_REVOKED: in nfs41_test_and_free_expired_stateid()
2916 case -NFS4ERR_DELEG_REVOKED: in nfs41_test_and_free_expired_stateid()
2924 return -NFS4ERR_EXPIRED; in nfs41_test_and_free_expired_stateid()
2929 struct nfs_server *server = NFS_SERVER(state->inode); in nfs41_check_delegation_stateid()
2937 delegation = rcu_dereference(NFS_I(state->inode)->delegation); in nfs41_check_delegation_stateid()
2944 spin_lock(&delegation->lock); in nfs41_check_delegation_stateid()
2945 nfs4_stateid_copy(&stateid, &delegation->stateid); in nfs41_check_delegation_stateid()
2948 &delegation->flags)) { in nfs41_check_delegation_stateid()
2949 spin_unlock(&delegation->lock); in nfs41_check_delegation_stateid()
2954 if (delegation->cred) in nfs41_check_delegation_stateid()
2955 cred = get_cred(delegation->cred); in nfs41_check_delegation_stateid()
2956 spin_unlock(&delegation->lock); in nfs41_check_delegation_stateid()
2960 if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID) in nfs41_check_delegation_stateid()
2973 if (test_bit(NFS_DELEGATED_STATE, &state->flags) && in nfs41_delegation_recover_stateid()
2974 nfs4_copy_delegation_stateid(state->inode, state->state, in nfs41_delegation_recover_stateid()
2976 nfs4_stateid_match_other(&state->stateid, &tmp)) in nfs41_delegation_recover_stateid()
2977 nfs_state_set_delegation(state, &tmp, state->state); in nfs41_delegation_recover_stateid()
2983 * nfs41_check_expired_locks - possibly free a lock stateid
2994 struct nfs_server *server = NFS_SERVER(state->inode); in nfs41_check_expired_locks()
2996 if (!test_bit(LK_STATE_IN_USE, &state->flags)) in nfs41_check_expired_locks()
2999 spin_lock(&state->state_lock); in nfs41_check_expired_locks()
3000 list_for_each_entry(lsp, &state->lock_states, ls_locks) { in nfs41_check_expired_locks()
3001 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) { in nfs41_check_expired_locks()
3002 const struct cred *cred = lsp->ls_state->owner->so_cred; in nfs41_check_expired_locks()
3004 refcount_inc(&lsp->ls_count); in nfs41_check_expired_locks()
3005 spin_unlock(&state->state_lock); in nfs41_check_expired_locks()
3011 &lsp->ls_stateid, in nfs41_check_expired_locks()
3014 if (status == -NFS4ERR_EXPIRED || in nfs41_check_expired_locks()
3015 status == -NFS4ERR_BAD_STATEID) { in nfs41_check_expired_locks()
3016 clear_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags); in nfs41_check_expired_locks()
3017 lsp->ls_stateid.type = NFS4_INVALID_STATEID_TYPE; in nfs41_check_expired_locks()
3019 set_bit(NFS_LOCK_LOST, &lsp->ls_flags); in nfs41_check_expired_locks()
3025 spin_lock(&state->state_lock); in nfs41_check_expired_locks()
3028 spin_unlock(&state->state_lock); in nfs41_check_expired_locks()
3035 * nfs41_check_open_stateid - possibly free an open stateid
3044 struct nfs_server *server = NFS_SERVER(state->inode); in nfs41_check_open_stateid()
3045 nfs4_stateid *stateid = &state->open_stateid; in nfs41_check_open_stateid()
3046 const struct cred *cred = state->owner->so_cred; in nfs41_check_open_stateid()
3049 if (test_bit(NFS_OPEN_STATE, &state->flags) == 0) in nfs41_check_open_stateid()
3050 return -NFS4ERR_BAD_STATEID; in nfs41_check_open_stateid()
3053 if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID) { in nfs41_check_open_stateid()
3055 stateid->type = NFS4_INVALID_STATEID_TYPE; in nfs41_check_open_stateid()
3059 return -NFS4ERR_OPENMODE; in nfs41_check_open_stateid()
3083 * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-*
3090 const __u32 *bitmask = opendata->o_arg.server->exclcreat_bitmask; in nfs4_exclusive_attrset()
3096 attrset[i] = opendata->o_res.attrset[i]; in nfs4_exclusive_attrset()
3097 if (opendata->o_arg.createmode == NFS4_CREATE_EXCLUSIVE4_1) in nfs4_exclusive_attrset()
3101 ret = (opendata->o_arg.createmode == NFS4_CREATE_EXCLUSIVE) ? in nfs4_exclusive_attrset()
3102 sattr->ia_valid : 0; in nfs4_exclusive_attrset()
3105 if (sattr->ia_valid & ATTR_ATIME_SET) in nfs4_exclusive_attrset()
3112 if (sattr->ia_valid & ATTR_MTIME_SET) in nfs4_exclusive_attrset()
3126 struct nfs4_state_owner *sp = opendata->owner; in _nfs4_open_and_get_state()
3127 struct nfs_server *server = sp->so_server; in _nfs4_open_and_get_state()
3131 struct inode *dir = d_inode(opendata->dir); in _nfs4_open_and_get_state()
3145 ctx->state = state; in _nfs4_open_and_get_state()
3146 if (server->caps & NFS_CAP_POSIX_LOCK) in _nfs4_open_and_get_state()
3147 set_bit(NFS_STATE_POSIX_LOCKS, &state->flags); in _nfs4_open_and_get_state()
3148 if (opendata->o_res.rflags & NFS4_OPEN_RESULT_MAY_NOTIFY_LOCK) in _nfs4_open_and_get_state()
3149 set_bit(NFS_STATE_MAY_NOTIFY_LOCK, &state->flags); in _nfs4_open_and_get_state()
3150 if (opendata->o_res.rflags & NFS4_OPEN_RESULT_PRESERVE_UNLINKED) in _nfs4_open_and_get_state()
3151 set_bit(NFS_INO_PRESERVE_UNLINKED, &NFS_I(state->inode)->flags); in _nfs4_open_and_get_state()
3153 dentry = opendata->dentry; in _nfs4_open_and_get_state()
3157 alias = d_exact_alias(dentry, state->inode); in _nfs4_open_and_get_state()
3159 alias = d_splice_alias(igrab(state->inode), dentry); in _nfs4_open_and_get_state()
3160 /* d_splice_alias() can't fail here - it's a non-directory */ in _nfs4_open_and_get_state()
3162 dput(ctx->dentry); in _nfs4_open_and_get_state()
3163 ctx->dentry = dentry = alias; in _nfs4_open_and_get_state()
3167 switch(opendata->o_arg.claim) { in _nfs4_open_and_get_state()
3173 if (!opendata->rpc_done) in _nfs4_open_and_get_state()
3175 if (opendata->o_res.delegation.type != 0) in _nfs4_open_and_get_state()
3181 pnfs_parse_lgopen(state->inode, opendata->lgp, ctx); in _nfs4_open_and_get_state()
3183 ret = nfs4_opendata_access(sp->so_cred, opendata, state, acc_mode); in _nfs4_open_and_get_state()
3187 if (d_inode(dentry) == state->inode) in _nfs4_open_and_get_state()
3191 if (!opendata->cancelled) { in _nfs4_open_and_get_state()
3192 if (opendata->lgp) { in _nfs4_open_and_get_state()
3193 nfs4_lgopen_release(opendata->lgp); in _nfs4_open_and_get_state()
3194 opendata->lgp = NULL; in _nfs4_open_and_get_state()
3196 nfs4_sequence_free_slot(&opendata->o_res.seq_res); in _nfs4_open_and_get_state()
3214 struct dentry *dentry = ctx->dentry; in _nfs4_do_open()
3215 const struct cred *cred = ctx->cred; in _nfs4_do_open()
3216 struct nfs4_threshold **ctx_th = &ctx->mdsthreshold; in _nfs4_do_open()
3219 struct iattr *sattr = c->sattr; in _nfs4_do_open()
3220 struct nfs4_label *label = c->label; in _nfs4_do_open()
3224 status = -ENOMEM; in _nfs4_do_open()
3230 status = nfs4_client_recover_expired_lease(server->nfs_client); in _nfs4_do_open()
3235 status = -ENOMEM; in _nfs4_do_open()
3243 if (server->attr_bitmask[2] & FATTR4_WORD2_MDSTHRESHOLD) { in _nfs4_do_open()
3244 if (!opendata->f_attr.mdsthreshold) { in _nfs4_do_open()
3245 opendata->f_attr.mdsthreshold = pnfs_mdsthreshold_alloc(); in _nfs4_do_open()
3246 if (!opendata->f_attr.mdsthreshold) in _nfs4_do_open()
3249 opendata->o_arg.open_bitmap = &nfs4_pnfs_open_bitmap[0]; in _nfs4_do_open()
3252 opendata->state = nfs4_get_open_state(d_inode(dentry), sp); in _nfs4_do_open()
3257 state = ctx->state; in _nfs4_do_open()
3259 if ((opendata->o_arg.open_flags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL) && in _nfs4_do_open()
3260 (opendata->o_arg.createmode != NFS4_CREATE_GUARDED)) { in _nfs4_do_open()
3263 * send create attributes which was not set by open in _nfs4_do_open()
3267 unsigned ia_old = sattr->ia_valid; in _nfs4_do_open()
3269 sattr->ia_valid = attrs; in _nfs4_do_open()
3270 nfs_fattr_init(opendata->o_res.f_attr); in _nfs4_do_open()
3271 status = nfs4_do_setattr(state->inode, cred, in _nfs4_do_open()
3272 opendata->o_res.f_attr, sattr, in _nfs4_do_open()
3275 nfs_setattr_update_inode(state->inode, sattr, in _nfs4_do_open()
3276 opendata->o_res.f_attr); in _nfs4_do_open()
3277 nfs_setsecurity(state->inode, opendata->o_res.f_attr); in _nfs4_do_open()
3279 sattr->ia_valid = ia_old; in _nfs4_do_open()
3282 if (opened && opendata->file_created) in _nfs4_do_open()
3285 if (pnfs_use_threshold(ctx_th, opendata->f_attr.mdsthreshold, server)) { in _nfs4_do_open()
3286 *ctx_th = opendata->f_attr.mdsthreshold; in _nfs4_do_open()
3287 opendata->f_attr.mdsthreshold = NULL; in _nfs4_do_open()
3319 [1] = (__u32)current->pid, in nfs4_do_open()
3326 res = ctx->state; in nfs4_do_open()
3331 * book-keeping w.r.t. state-changing operations in nfs4_do_open()
3341 if (status == -NFS4ERR_BAD_SEQID) { in nfs4_do_open()
3343 " returned a bad sequence-id error!\n", in nfs4_do_open()
3344 NFS_SERVER(dir)->nfs_client->cl_hostname); in nfs4_do_open()
3354 if (status == -NFS4ERR_BAD_STATEID) { in nfs4_do_open()
3358 if (status == -NFS4ERR_EXPIRED) { in nfs4_do_open()
3359 nfs4_schedule_lease_recovery(server->nfs_client); in nfs4_do_open()
3363 if (status == -EAGAIN) { in nfs4_do_open()
3394 nfs_fattr_init(res->fattr); in _nfs4_do_setattr()
3397 truncate = (arg->iap->ia_valid & ATTR_SIZE) ? true : false; in _nfs4_do_setattr()
3403 if (nfs4_copy_delegation_stateid(inode, FMODE_WRITE, &arg->stateid, &delegation_cred)) { in _nfs4_do_setattr()
3405 } else if (ctx != NULL && ctx->state) { in _nfs4_do_setattr()
3407 if (!nfs4_valid_open_stateid(ctx->state)) in _nfs4_do_setattr()
3408 return -EBADF; in _nfs4_do_setattr()
3412 status = nfs4_select_rw_stateid(ctx->state, FMODE_WRITE, l_ctx, in _nfs4_do_setattr()
3413 &arg->stateid, &delegation_cred); in _nfs4_do_setattr()
3415 if (status == -EIO) in _nfs4_do_setattr()
3416 return -EBADF; in _nfs4_do_setattr()
3417 else if (status == -EAGAIN) in _nfs4_do_setattr()
3421 nfs4_stateid_copy(&arg->stateid, &zero_stateid); in _nfs4_do_setattr()
3426 status = nfs4_call_sync(server->client, server, &msg, &arg->seq_args, &res->seq_res, 1); in _nfs4_do_setattr()
3431 trace_nfs4_setattr(inode, &arg->stateid, status); in _nfs4_do_setattr()
3441 struct nfs4_state *state = ctx ? ctx->state : NULL; in nfs4_do_setattr()
3462 if (sattr->ia_valid & (ATTR_MODE | ATTR_KILL_SUID | ATTR_KILL_SGID)) in nfs4_do_setattr()
3464 if (sattr->ia_valid & (ATTR_UID | ATTR_GID)) in nfs4_do_setattr()
3466 if (sattr->ia_valid & ATTR_ATIME) in nfs4_do_setattr()
3468 if (sattr->ia_valid & ATTR_MTIME) in nfs4_do_setattr()
3472 nfs4_bitmap_copy_adjust(bitmask, nfs4_bitmask(server, fattr->label), in nfs4_do_setattr()
3477 case -NFS4ERR_OPENMODE: in nfs4_do_setattr()
3478 if (!(sattr->ia_valid & ATTR_SIZE)) { in nfs4_do_setattr()
3483 server->nfs_client->cl_hostname); in nfs4_do_setattr()
3485 if (state && !(state->state & FMODE_WRITE)) { in nfs4_do_setattr()
3486 err = -EBADF; in nfs4_do_setattr()
3487 if (sattr->ia_valid & ATTR_OPEN) in nfs4_do_setattr()
3488 err = -EACCES; in nfs4_do_setattr()
3520 seq = read_seqbegin(&state->seqlock); in nfs4_sync_open_stateid()
3522 nfs4_stateid_copy(dst, &state->open_stateid); in nfs4_sync_open_stateid()
3523 if (read_seqretry(&state->seqlock, seq)) in nfs4_sync_open_stateid()
3527 seqid_open = state->open_stateid.seqid; in nfs4_sync_open_stateid()
3528 if (read_seqretry(&state->seqlock, seq)) in nfs4_sync_open_stateid()
3531 dst_seqid = be32_to_cpu(dst->seqid); in nfs4_sync_open_stateid()
3532 if ((s32)(dst_seqid - be32_to_cpu(seqid_open)) < 0) in nfs4_sync_open_stateid()
3533 dst->seqid = seqid_open; in nfs4_sync_open_stateid()
3548 int seq, status = -EAGAIN; in nfs4_refresh_open_old_stateid()
3555 seq = read_seqbegin(&state->seqlock); in nfs4_refresh_open_old_stateid()
3557 if (read_seqretry(&state->seqlock, seq)) in nfs4_refresh_open_old_stateid()
3562 write_seqlock(&state->seqlock); in nfs4_refresh_open_old_stateid()
3563 seqid_open = state->open_stateid.seqid; in nfs4_refresh_open_old_stateid()
3565 dst_seqid = be32_to_cpu(dst->seqid); in nfs4_refresh_open_old_stateid()
3568 if ((s32)(be32_to_cpu(seqid_open) - dst_seqid) > 0) { in nfs4_refresh_open_old_stateid()
3569 dst->seqid = seqid_open; in nfs4_refresh_open_old_stateid()
3570 write_sequnlock(&state->seqlock); in nfs4_refresh_open_old_stateid()
3576 set_bit(NFS_STATE_CHANGE_WAIT, &state->flags); in nfs4_refresh_open_old_stateid()
3577 prepare_to_wait(&state->waitq, &wait, TASK_KILLABLE); in nfs4_refresh_open_old_stateid()
3578 write_sequnlock(&state->seqlock); in nfs4_refresh_open_old_stateid()
3579 trace_nfs4_close_stateid_update_wait(state->inode, dst, 0); in nfs4_refresh_open_old_stateid()
3582 status = -EINTR; in nfs4_refresh_open_old_stateid()
3587 finish_wait(&state->waitq, &wait); in nfs4_refresh_open_old_stateid()
3591 if (status == -EINTR) in nfs4_refresh_open_old_stateid()
3595 dst->seqid = cpu_to_be32(dst_seqid + 1); in nfs4_refresh_open_old_stateid()
3622 struct nfs4_state_owner *sp = calldata->state->owner; in nfs4_free_closedata()
3623 struct super_block *sb = calldata->state->inode->i_sb; in nfs4_free_closedata()
3625 if (calldata->lr.roc) in nfs4_free_closedata()
3626 pnfs_roc_release(&calldata->lr.arg, &calldata->lr.res, in nfs4_free_closedata()
3627 calldata->res.lr_ret); in nfs4_free_closedata()
3628 nfs4_put_open_state(calldata->state); in nfs4_free_closedata()
3629 nfs_free_seqid(calldata->arg.seqid); in nfs4_free_closedata()
3638 struct nfs4_state *state = calldata->state; in nfs4_close_done()
3639 struct nfs_server *server = NFS_SERVER(calldata->inode); in nfs4_close_done()
3643 .inode = calldata->inode, in nfs4_close_done()
3644 .stateid = &calldata->arg.stateid, in nfs4_close_done()
3647 if (!nfs4_sequence_done(task, &calldata->res.seq_res)) in nfs4_close_done()
3649 trace_nfs4_close(state, &calldata->arg, &calldata->res, task->tk_status); in nfs4_close_done()
3652 if (pnfs_roc_done(task, &calldata->arg.lr_args, &calldata->res.lr_res, in nfs4_close_done()
3653 &calldata->res.lr_ret) == -EAGAIN) in nfs4_close_done()
3659 switch (task->tk_status) { in nfs4_close_done()
3661 res_stateid = &calldata->res.stateid; in nfs4_close_done()
3662 renew_lease(server, calldata->timestamp); in nfs4_close_done()
3664 case -NFS4ERR_ACCESS: in nfs4_close_done()
3665 if (calldata->arg.bitmask != NULL) { in nfs4_close_done()
3666 calldata->arg.bitmask = NULL; in nfs4_close_done()
3667 calldata->res.fattr = NULL; in nfs4_close_done()
3672 case -NFS4ERR_OLD_STATEID: in nfs4_close_done()
3674 if (nfs4_refresh_open_old_stateid(&calldata->arg.stateid, in nfs4_close_done()
3678 case -NFS4ERR_ADMIN_REVOKED: in nfs4_close_done()
3679 case -NFS4ERR_STALE_STATEID: in nfs4_close_done()
3680 case -NFS4ERR_EXPIRED: in nfs4_close_done()
3682 &calldata->arg.stateid, in nfs4_close_done()
3683 task->tk_msg.rpc_cred); in nfs4_close_done()
3685 case -NFS4ERR_BAD_STATEID: in nfs4_close_done()
3686 if (calldata->arg.fmode == 0) in nfs4_close_done()
3690 task->tk_status = nfs4_async_handle_exception(task, in nfs4_close_done()
3691 server, task->tk_status, &exception); in nfs4_close_done()
3695 nfs_clear_open_stateid(state, &calldata->arg.stateid, in nfs4_close_done()
3696 res_stateid, calldata->arg.fmode); in nfs4_close_done()
3698 task->tk_status = 0; in nfs4_close_done()
3699 nfs_release_seqid(calldata->arg.seqid); in nfs4_close_done()
3700 nfs_refresh_inode(calldata->inode, &calldata->fattr); in nfs4_close_done()
3701 dprintk("%s: ret = %d\n", __func__, task->tk_status); in nfs4_close_done()
3704 task->tk_status = 0; in nfs4_close_done()
3712 struct nfs4_state *state = calldata->state; in nfs4_close_prepare()
3713 struct inode *inode = calldata->inode; in nfs4_close_prepare()
3719 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0) in nfs4_close_prepare()
3722 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE]; in nfs4_close_prepare()
3723 spin_lock(&state->owner->so_lock); in nfs4_close_prepare()
3724 is_rdwr = test_bit(NFS_O_RDWR_STATE, &state->flags); in nfs4_close_prepare()
3725 is_rdonly = test_bit(NFS_O_RDONLY_STATE, &state->flags); in nfs4_close_prepare()
3726 is_wronly = test_bit(NFS_O_WRONLY_STATE, &state->flags); in nfs4_close_prepare()
3728 calldata->arg.fmode = 0; in nfs4_close_prepare()
3729 if (state->n_rdwr == 0) { in nfs4_close_prepare()
3730 if (state->n_rdonly == 0) in nfs4_close_prepare()
3733 calldata->arg.fmode |= FMODE_READ; in nfs4_close_prepare()
3734 if (state->n_wronly == 0) in nfs4_close_prepare()
3737 calldata->arg.fmode |= FMODE_WRITE; in nfs4_close_prepare()
3738 if (calldata->arg.fmode != (FMODE_READ|FMODE_WRITE)) in nfs4_close_prepare()
3741 calldata->arg.fmode |= FMODE_READ|FMODE_WRITE; in nfs4_close_prepare()
3743 nfs4_sync_open_stateid(&calldata->arg.stateid, state); in nfs4_close_prepare()
3746 spin_unlock(&state->owner->so_lock); in nfs4_close_prepare()
3753 if (!calldata->lr.roc && nfs4_wait_on_layoutreturn(inode, task)) { in nfs4_close_prepare()
3754 nfs_release_seqid(calldata->arg.seqid); in nfs4_close_prepare()
3758 lo = calldata->arg.lr_args ? calldata->arg.lr_args->layout : NULL; in nfs4_close_prepare()
3760 calldata->arg.lr_args = NULL; in nfs4_close_prepare()
3761 calldata->res.lr_res = NULL; in nfs4_close_prepare()
3764 if (calldata->arg.fmode == 0) in nfs4_close_prepare()
3765 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE]; in nfs4_close_prepare()
3767 if (calldata->arg.fmode == 0 || calldata->arg.fmode == FMODE_READ) { in nfs4_close_prepare()
3768 /* Close-to-open cache consistency revalidation */ in nfs4_close_prepare()
3770 nfs4_bitmask_set(calldata->arg.bitmask_store, in nfs4_close_prepare()
3771 server->cache_consistency_bitmask, in nfs4_close_prepare()
3773 calldata->arg.bitmask = calldata->arg.bitmask_store; in nfs4_close_prepare()
3775 calldata->arg.bitmask = NULL; in nfs4_close_prepare()
3778 calldata->arg.share_access = in nfs4_close_prepare()
3779 nfs4_fmode_to_share_access(calldata->arg.fmode); in nfs4_close_prepare()
3781 if (calldata->res.fattr == NULL) in nfs4_close_prepare()
3782 calldata->arg.bitmask = NULL; in nfs4_close_prepare()
3783 else if (calldata->arg.bitmask == NULL) in nfs4_close_prepare()
3784 calldata->res.fattr = NULL; in nfs4_close_prepare()
3785 calldata->timestamp = jiffies; in nfs4_close_prepare()
3786 if (nfs4_setup_sequence(NFS_SERVER(inode)->nfs_client, in nfs4_close_prepare()
3787 &calldata->arg.seq_args, in nfs4_close_prepare()
3788 &calldata->res.seq_res, in nfs4_close_prepare()
3790 nfs_release_seqid(calldata->arg.seqid); in nfs4_close_prepare()
3793 task->tk_action = NULL; in nfs4_close_prepare()
3795 nfs4_sequence_done(task, &calldata->res.seq_res); in nfs4_close_prepare()
3805 * It is possible for data to be read/written from a mem-mapped file
3809 * NFSv4 citizens - we do not indicate to the server to update the file's
3813 * NOTE: Caller must be holding the sp->so_owner semaphore!
3817 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_do_close()
3820 struct nfs4_state_owner *sp = state->owner; in nfs4_do_close()
3824 .rpc_cred = state->owner->so_cred, in nfs4_do_close()
3827 .rpc_client = server->client, in nfs4_do_close()
3833 int status = -ENOMEM; in nfs4_do_close()
3835 if (nfs_server_capable(state->inode, NFS_CAP_MOVEABLE)) in nfs4_do_close()
3838 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_CLEANUP, in nfs4_do_close()
3844 nfs4_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 1, 0); in nfs4_do_close()
3845 calldata->inode = state->inode; in nfs4_do_close()
3846 calldata->state = state; in nfs4_do_close()
3847 calldata->arg.fh = NFS_FH(state->inode); in nfs4_do_close()
3848 if (!nfs4_copy_open_stateid(&calldata->arg.stateid, state)) in nfs4_do_close()
3851 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid; in nfs4_do_close()
3852 calldata->arg.seqid = alloc_seqid(&state->owner->so_seqid, gfp_mask); in nfs4_do_close()
3853 if (IS_ERR(calldata->arg.seqid)) in nfs4_do_close()
3855 nfs_fattr_init(&calldata->fattr); in nfs4_do_close()
3856 calldata->arg.fmode = 0; in nfs4_do_close()
3857 calldata->lr.arg.ld_private = &calldata->lr.ld_private; in nfs4_do_close()
3858 calldata->res.fattr = &calldata->fattr; in nfs4_do_close()
3859 calldata->res.seqid = calldata->arg.seqid; in nfs4_do_close()
3860 calldata->res.server = server; in nfs4_do_close()
3861 calldata->res.lr_ret = -NFS4ERR_NOMATCHING_LAYOUT; in nfs4_do_close()
3862 calldata->lr.roc = pnfs_roc(state->inode, in nfs4_do_close()
3863 &calldata->lr.arg, &calldata->lr.res, msg.rpc_cred); in nfs4_do_close()
3864 if (calldata->lr.roc) { in nfs4_do_close()
3865 calldata->arg.lr_args = &calldata->lr.arg; in nfs4_do_close()
3866 calldata->res.lr_res = &calldata->lr.res; in nfs4_do_close()
3868 nfs_sb_active(calldata->inode->i_sb); in nfs4_do_close()
3870 msg.rpc_argp = &calldata->arg; in nfs4_do_close()
3871 msg.rpc_resp = &calldata->res; in nfs4_do_close()
3896 label = nfs4_label_init_security(dir, ctx->dentry, attr, &l); in nfs4_atomic_open()
3905 return state->inode; in nfs4_atomic_open()
3910 struct dentry *dentry = ctx->dentry; in nfs4_close_context()
3911 if (ctx->state == NULL) in nfs4_close_context()
3913 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) in nfs4_close_context()
3916 nfs4_close_sync(ctx->state, _nfs4_ctx_to_openmode(ctx)); in nfs4_close_context()
3918 nfs4_close_state(ctx->state, _nfs4_ctx_to_openmode(ctx)); in nfs4_close_context()
3921 #define FATTR4_WORD1_NFS40_MASK (2*FATTR4_WORD1_MOUNTED_ON_FILEID - 1UL)
3922 #define FATTR4_WORD2_NFS41_MASK (2*FATTR4_WORD2_SUPPATTR_EXCLCREAT - 1UL)
3923 #define FATTR4_WORD2_NFS42_MASK (2*FATTR4_WORD2_OPEN_ARGUMENTS - 1UL)
3929 u32 share_access_want = res->open_caps.oa_share_access_want[0]; in nfs4_server_delegtime_capable()
3930 u32 attr_bitmask = res->attr_bitmask[2]; in nfs4_server_delegtime_capable()
3939 u32 minorversion = server->nfs_client->cl_minorversion; in _nfs4_server_capabilities()
3967 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_server_capabilities()
3994 memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask)); in _nfs4_server_capabilities()
3995 server->caps &= ~(NFS_CAP_ACLS | NFS_CAP_HARDLINKS | in _nfs4_server_capabilities()
3997 server->fattr_valid = NFS_ATTR_FATTR_V4; in _nfs4_server_capabilities()
4000 server->caps |= NFS_CAP_ACLS; in _nfs4_server_capabilities()
4002 server->caps |= NFS_CAP_HARDLINKS; in _nfs4_server_capabilities()
4004 server->caps |= NFS_CAP_SYMLINKS; in _nfs4_server_capabilities()
4006 server->caps |= NFS_CAP_CASE_INSENSITIVE; in _nfs4_server_capabilities()
4008 server->caps |= NFS_CAP_CASE_PRESERVING; in _nfs4_server_capabilities()
4011 server->caps |= NFS_CAP_SECURITY_LABEL; in _nfs4_server_capabilities()
4014 server->caps |= NFS_CAP_FS_LOCATIONS; in _nfs4_server_capabilities()
4016 server->fattr_valid &= ~NFS_ATTR_FATTR_FILEID; in _nfs4_server_capabilities()
4018 server->fattr_valid &= ~NFS_ATTR_FATTR_MODE; in _nfs4_server_capabilities()
4020 server->fattr_valid &= ~NFS_ATTR_FATTR_NLINK; in _nfs4_server_capabilities()
4022 server->fattr_valid &= ~(NFS_ATTR_FATTR_OWNER | in _nfs4_server_capabilities()
4025 server->fattr_valid &= ~(NFS_ATTR_FATTR_GROUP | in _nfs4_server_capabilities()
4028 server->fattr_valid &= ~NFS_ATTR_FATTR_SPACE_USED; in _nfs4_server_capabilities()
4030 server->fattr_valid &= ~NFS_ATTR_FATTR_ATIME; in _nfs4_server_capabilities()
4032 server->fattr_valid &= ~NFS_ATTR_FATTR_CTIME; in _nfs4_server_capabilities()
4034 server->fattr_valid &= ~NFS_ATTR_FATTR_MTIME; in _nfs4_server_capabilities()
4035 memcpy(server->attr_bitmask_nl, res.attr_bitmask, in _nfs4_server_capabilities()
4036 sizeof(server->attr_bitmask)); in _nfs4_server_capabilities()
4037 server->attr_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL; in _nfs4_server_capabilities()
4041 server->caps |= NFS_CAP_OPEN_XOR; in _nfs4_server_capabilities()
4043 server->caps |= NFS_CAP_DELEGTIME; in _nfs4_server_capabilities()
4045 …memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitma… in _nfs4_server_capabilities()
4046 server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE; in _nfs4_server_capabilities()
4047 server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY; in _nfs4_server_capabilities()
4048 server->cache_consistency_bitmask[2] = 0; in _nfs4_server_capabilities()
4053 memcpy(server->exclcreat_bitmask, res.exclcreat_bitmask, in _nfs4_server_capabilities()
4054 sizeof(server->exclcreat_bitmask)); in _nfs4_server_capabilities()
4056 server->acl_bitmask = res.acl_bitmask; in _nfs4_server_capabilities()
4057 server->fh_expire_type = res.fh_expire_type; in _nfs4_server_capabilities()
4085 for (i = 0; i < location->nservers; i++) { in test_fs_location_for_trunking()
4086 struct nfs4_string *srv_loc = &location->servers[i]; in test_fs_location_for_trunking()
4091 .net = clp->cl_net, in test_fs_location_for_trunking()
4097 .add_xprt_test = clp->cl_mvops->session_trunk, in test_fs_location_for_trunking()
4102 if (!srv_loc->len) in test_fs_location_for_trunking()
4105 addrlen = nfs_parse_server_name(srv_loc->data, srv_loc->len, in test_fs_location_for_trunking()
4107 clp->cl_net, server->port); in test_fs_location_for_trunking()
4112 servername = kmalloc(srv_loc->len + 1, GFP_KERNEL); in test_fs_location_for_trunking()
4115 memcpy(servername, srv_loc->data, srv_loc->len); in test_fs_location_for_trunking()
4116 servername[srv_loc->len] = '\0'; in test_fs_location_for_trunking()
4120 rpc_clnt_add_xprt(clp->cl_rpcclient, &xprt_args, in test_fs_location_for_trunking()
4134 if (path1->ncomponents != path2->ncomponents) in _is_same_nfs4_pathname()
4136 for (i = 0; i < path1->ncomponents; i++) { in _is_same_nfs4_pathname()
4137 if (path1->components[i].len != path2->components[i].len) in _is_same_nfs4_pathname()
4139 if (memcmp(path1->components[i].data, path2->components[i].data, in _is_same_nfs4_pathname()
4140 path1->components[i].len)) in _is_same_nfs4_pathname()
4152 struct nfs_client *clp = server->nfs_client; in _nfs4_discover_trunking()
4154 clp->cl_mvops->state_renewal_ops; in _nfs4_discover_trunking()
4155 int status = -ENOMEM, i; in _nfs4_discover_trunking()
4157 cred = ops->get_state_renewal_cred(clp); in _nfs4_discover_trunking()
4161 return -ENOKEY; in _nfs4_discover_trunking()
4170 locations->fattr = nfs_alloc_fattr(); in _nfs4_discover_trunking()
4171 if (!locations->fattr) in _nfs4_discover_trunking()
4179 for (i = 0; i < locations->nlocations; i++) { in _nfs4_discover_trunking()
4180 if (!_is_same_nfs4_pathname(&locations->fs_path, in _nfs4_discover_trunking()
4181 &locations->locations[i].rootpath)) in _nfs4_discover_trunking()
4183 test_fs_location_for_trunking(&locations->locations[i], clp, in _nfs4_discover_trunking()
4187 kfree(locations->fattr); in _nfs4_discover_trunking()
4203 struct nfs_client *clp = server->nfs_client; in nfs4_discover_trunking()
4226 .fattr = info->fattr, in _nfs4_lookup_root()
4242 nfs_fattr_init(info->fattr); in _nfs4_lookup_root()
4243 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_lookup_root()
4255 trace_nfs4_lookup_root(server, fhandle, info->fattr, err); in nfs4_lookup_root()
4258 case -NFS4ERR_WRONGSEC: in nfs4_lookup_root()
4276 auth = rpcauth_create(&auth_args, server->client); in nfs4_lookup_root_sec()
4278 return -EACCES; in nfs4_lookup_root_sec()
4302 int status = -EPERM; in nfs4_find_root_sec()
4305 if (server->auth_info.flavor_len > 0) { in nfs4_find_root_sec()
4307 for (i = 0; i < server->auth_info.flavor_len; i++) { in nfs4_find_root_sec()
4309 server->auth_info.flavors[i]); in nfs4_find_root_sec()
4310 if (status == -NFS4ERR_WRONGSEC || status == -EACCES) in nfs4_find_root_sec()
4319 if (status == -NFS4ERR_WRONGSEC || status == -EACCES) in nfs4_find_root_sec()
4326 * -EACCES could mean that the user doesn't have correct permissions in nfs4_find_root_sec()
4329 * existing mount programs don't handle -EACCES very well so it should in nfs4_find_root_sec()
4330 * be mapped to -EPERM instead. in nfs4_find_root_sec()
4332 if (status == -EACCES) in nfs4_find_root_sec()
4333 status = -EPERM; in nfs4_find_root_sec()
4338 * nfs4_proc_get_rootfh - get file handle for server's pseudoroot
4340 * @fhandle: we fill in the pseudo-fs root file handle
4356 status = server->nfs_client->cl_mvops->find_root_sec(server, in nfs4_proc_get_rootfh()
4371 struct nfs_fattr *fattr = info->fattr; in nfs4_proc_get_root()
4375 dprintk("nfs4_get_root: getcaps error = %d\n", -error); in nfs4_proc_get_root()
4381 dprintk("nfs4_get_root: getattr error = %d\n", -error); in nfs4_proc_get_root()
4385 if (fattr->valid & NFS_ATTR_FATTR_FSID && in nfs4_proc_get_root()
4386 !nfs_fsid_equal(&server->fsid, &fattr->fsid)) in nfs4_proc_get_root()
4387 memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid)); in nfs4_proc_get_root()
4402 int status = -ENOMEM; in nfs4_get_referral()
4413 locations->fattr = fattr; in nfs4_get_referral()
4424 if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &fattr->fsid)) { in nfs4_get_referral()
4426 " a referral at %s\n", __func__, name->name); in nfs4_get_referral()
4427 status = -NFS4ERR_MOVED; in nfs4_get_referral()
4459 if (nfs4_has_session(server->nfs_client)) in _nfs4_proc_getattr()
4463 if (inode && (server->flags & NFS_MOUNT_SOFTREVAL)) in _nfs4_proc_getattr()
4466 nfs4_bitmap_copy_adjust(bitmask, nfs4_bitmask(server, fattr->label), inode, 0); in _nfs4_proc_getattr()
4469 return nfs4_do_call_sync(server->client, server, &msg, in _nfs4_proc_getattr()
4492 * VFS layer lookup-intents are implemented.
4504 * This will be fixed with VFS changes (lookup-intent).
4516 sattr->ia_valid & ATTR_SIZE && in nfs4_proc_setattr()
4517 sattr->ia_size < i_size_read(inode)) in nfs4_proc_setattr()
4523 if (sattr->ia_valid & ATTR_OPEN) in nfs4_proc_setattr()
4524 sattr->ia_valid &= ~(ATTR_MTIME|ATTR_CTIME); in nfs4_proc_setattr()
4527 if ((sattr->ia_valid & ~(ATTR_FILE|ATTR_OPEN)) == 0) in nfs4_proc_setattr()
4531 if (sattr->ia_valid & ATTR_FILE) { in nfs4_proc_setattr()
4533 ctx = nfs_file_open_context(sattr->ia_file); in nfs4_proc_setattr()
4535 cred = ctx->cred; in nfs4_proc_setattr()
4539 if ((sattr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) in nfs4_proc_setattr()
4557 .bitmask = server->attr_bitmask, in _nfs4_proc_lookup()
4580 args.bitmask = nfs4_bitmask(server, fattr->label); in _nfs4_proc_lookup()
4594 fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE | in nfs_fixup_secinfo_attributes()
4596 fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO; in nfs_fixup_secinfo_attributes()
4597 fattr->nlink = 2; in nfs_fixup_secinfo_attributes()
4613 case -NFS4ERR_BADNAME: in nfs4_proc_lookup_common()
4614 err = -ENOENT; in nfs4_proc_lookup_common()
4616 case -NFS4ERR_MOVED: in nfs4_proc_lookup_common()
4618 if (err == -NFS4ERR_MOVED) in nfs4_proc_lookup_common()
4621 case -NFS4ERR_WRONGSEC: in nfs4_proc_lookup_common()
4622 err = -EPERM; in nfs4_proc_lookup_common()
4666 status = nfs4_proc_lookup_common(&client, dir, dentry, &dentry->d_name, in nfs4_proc_lookup_mountpoint()
4680 .bitmask = server->attr_bitmask, in _nfs4_proc_lookupp()
4695 if (NFS_SERVER(inode)->flags & NFS_MOUNT_SOFTREVAL) in _nfs4_proc_lookupp()
4698 args.bitmask = nfs4_bitmask(server, fattr->label); in _nfs4_proc_lookupp()
4702 dprintk("NFS call lookupp ino=0x%lx\n", inode->i_ino); in _nfs4_proc_lookupp()
4731 .access = entry->mask, in _nfs4_proc_access()
4747 return -ENOMEM; in _nfs4_proc_access()
4748 args.bitmask = server->cache_consistency_bitmask; in _nfs4_proc_access()
4750 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_proc_access()
4778 * along with any of the zero-copy operations READ, READDIR,
4782 * after the read-type operation -- this is because it is hard
4792 * the operation -- in this case because we want to make sure
4793 * we get the post-operation mtime and size.
4814 …return nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), &msg, &args.seq_args, &res.seq… in _nfs4_proc_readlink()
4834 * This is just for mknod. open(O_CREAT) will always do ->open_context().
4852 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK)) in nfs4_proc_create()
4853 sattr->ia_mode &= ~current_umask(); in nfs4_proc_create()
4884 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1); in _nfs4_proc_remove()
4886 spin_lock(&dir->i_lock); in _nfs4_proc_remove()
4888 if (ftype == NF4DIR && dir->i_nlink > 2) in _nfs4_proc_remove()
4892 spin_unlock(&dir->i_lock); in _nfs4_proc_remove()
4906 if (inode->i_nlink == 1) in nfs4_proc_remove()
4912 err = _nfs4_proc_remove(dir, &dentry->d_name, NF4REG); in nfs4_proc_remove()
4913 trace_nfs4_remove(dir, &dentry->d_name, err); in nfs4_proc_remove()
4940 struct nfs_removeargs *args = msg->rpc_argp; in nfs4_proc_unlink_setup()
4941 struct nfs_removeres *res = msg->rpc_resp; in nfs4_proc_unlink_setup()
4943 res->server = NFS_SB(dentry->d_sb); in nfs4_proc_unlink_setup()
4944 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE]; in nfs4_proc_unlink_setup()
4945 nfs4_init_sequence(&args->seq_args, &res->seq_res, 1, 0); in nfs4_proc_unlink_setup()
4947 nfs_fattr_init(res->dir_attr); in nfs4_proc_unlink_setup()
4957 nfs4_setup_sequence(NFS_SB(data->dentry->d_sb)->nfs_client, in nfs4_proc_unlink_rpc_prepare()
4958 &data->args.seq_args, in nfs4_proc_unlink_rpc_prepare()
4959 &data->res.seq_res, in nfs4_proc_unlink_rpc_prepare()
4965 struct nfs_unlinkdata *data = task->tk_calldata; in nfs4_proc_unlink_done()
4966 struct nfs_removeres *res = &data->res; in nfs4_proc_unlink_done()
4968 if (!nfs4_sequence_done(task, &res->seq_res)) in nfs4_proc_unlink_done()
4970 if (nfs4_async_handle_error(task, res->server, NULL, in nfs4_proc_unlink_done()
4971 &data->timeout) == -EAGAIN) in nfs4_proc_unlink_done()
4973 if (task->tk_status == 0) in nfs4_proc_unlink_done()
4974 nfs4_update_changeattr(dir, &res->cinfo, in nfs4_proc_unlink_done()
4975 res->dir_attr->time_start, in nfs4_proc_unlink_done()
4984 struct nfs_renameargs *arg = msg->rpc_argp; in nfs4_proc_rename_setup()
4985 struct nfs_renameres *res = msg->rpc_resp; in nfs4_proc_rename_setup()
4993 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME]; in nfs4_proc_rename_setup()
4994 res->server = NFS_SB(old_dentry->d_sb); in nfs4_proc_rename_setup()
4995 nfs4_init_sequence(&arg->seq_args, &res->seq_res, 1, 0); in nfs4_proc_rename_setup()
5000 nfs4_setup_sequence(NFS_SERVER(data->old_dir)->nfs_client, in nfs4_proc_rename_rpc_prepare()
5001 &data->args.seq_args, in nfs4_proc_rename_rpc_prepare()
5002 &data->res.seq_res, in nfs4_proc_rename_rpc_prepare()
5009 struct nfs_renamedata *data = task->tk_calldata; in nfs4_proc_rename_done()
5010 struct nfs_renameres *res = &data->res; in nfs4_proc_rename_done()
5012 if (!nfs4_sequence_done(task, &res->seq_res)) in nfs4_proc_rename_done()
5014 if (nfs4_async_handle_error(task, res->server, NULL, &data->timeout) == -EAGAIN) in nfs4_proc_rename_done()
5017 if (task->tk_status == 0) { in nfs4_proc_rename_done()
5018 nfs_d_prune_case_insensitive_aliases(d_inode(data->old_dentry)); in nfs4_proc_rename_done()
5021 nfs4_update_changeattr(old_dir, &res->old_cinfo, in nfs4_proc_rename_done()
5022 res->old_fattr->time_start, in nfs4_proc_rename_done()
5025 nfs4_update_changeattr(new_dir, &res->new_cinfo, in nfs4_proc_rename_done()
5026 res->new_fattr->time_start, in nfs4_proc_rename_done()
5030 nfs4_update_changeattr(old_dir, &res->old_cinfo, in nfs4_proc_rename_done()
5031 res->old_fattr->time_start, in nfs4_proc_rename_done()
5055 int status = -ENOMEM; in _nfs4_proc_link()
5062 nfs4_bitmap_copy_adjust(bitmask, nfs4_bitmask(server, res.fattr->label), in _nfs4_proc_link()
5065 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); in _nfs4_proc_link()
5067 nfs4_update_changeattr(dir, &res.cinfo, res.fattr->time_start, in _nfs4_proc_link()
5111 data->fattr.label = nfs4_label_alloc(server, GFP_KERNEL); in nfs4_alloc_createdata()
5112 if (IS_ERR(data->fattr.label)) in nfs4_alloc_createdata()
5115 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE]; in nfs4_alloc_createdata()
5116 data->msg.rpc_argp = &data->arg; in nfs4_alloc_createdata()
5117 data->msg.rpc_resp = &data->res; in nfs4_alloc_createdata()
5118 data->arg.dir_fh = NFS_FH(dir); in nfs4_alloc_createdata()
5119 data->arg.server = server; in nfs4_alloc_createdata()
5120 data->arg.name = name; in nfs4_alloc_createdata()
5121 data->arg.attrs = sattr; in nfs4_alloc_createdata()
5122 data->arg.ftype = ftype; in nfs4_alloc_createdata()
5123 data->arg.bitmask = nfs4_bitmask(server, data->fattr.label); in nfs4_alloc_createdata()
5124 data->arg.umask = current_umask(); in nfs4_alloc_createdata()
5125 data->res.server = server; in nfs4_alloc_createdata()
5126 data->res.fh = &data->fh; in nfs4_alloc_createdata()
5127 data->res.fattr = &data->fattr; in nfs4_alloc_createdata()
5128 nfs_fattr_init(data->res.fattr); in nfs4_alloc_createdata()
5138 int status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &data->msg, in nfs4_do_create()
5139 &data->arg.seq_args, &data->res.seq_res, 1); in nfs4_do_create()
5141 spin_lock(&dir->i_lock); in nfs4_do_create()
5143 if (data->arg.ftype == NF4DIR) in nfs4_do_create()
5145 nfs4_update_changeattr_locked(dir, &data->res.dir_cinfo, in nfs4_do_create()
5146 data->res.fattr->time_start, in nfs4_do_create()
5148 spin_unlock(&dir->i_lock); in nfs4_do_create()
5149 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr); in nfs4_do_create()
5156 nfs4_label_free(data->fattr.label); in nfs4_free_createdata()
5164 struct page *page = &folio->page; in _nfs4_proc_symlink()
5166 int status = -ENAMETOOLONG; in _nfs4_proc_symlink()
5171 status = -ENOMEM; in _nfs4_proc_symlink()
5172 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4LNK); in _nfs4_proc_symlink()
5176 data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK]; in _nfs4_proc_symlink()
5177 data->arg.u.symlink.pages = &page; in _nfs4_proc_symlink()
5178 data->arg.u.symlink.len = len; in _nfs4_proc_symlink()
5179 data->arg.label = label; in _nfs4_proc_symlink()
5201 trace_nfs4_symlink(dir, &dentry->d_name, err); in nfs4_proc_symlink()
5214 int status = -ENOMEM; in _nfs4_proc_mkdir()
5216 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4DIR); in _nfs4_proc_mkdir()
5220 data->arg.label = label; in _nfs4_proc_mkdir()
5240 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK)) in nfs4_proc_mkdir()
5241 sattr->ia_mode &= ~current_umask(); in nfs4_proc_mkdir()
5244 trace_nfs4_mkdir(dir, &dentry->d_name, err); in nfs4_proc_mkdir()
5256 struct inode *dir = d_inode(nr_arg->dentry); in _nfs4_proc_readdir()
5260 .pages = nr_arg->pages, in _nfs4_proc_readdir()
5262 .count = nr_arg->page_len, in _nfs4_proc_readdir()
5263 .plus = nr_arg->plus, in _nfs4_proc_readdir()
5270 .rpc_cred = nr_arg->cred, in _nfs4_proc_readdir()
5275 nr_arg->dentry, (unsigned long long)nr_arg->cookie); in _nfs4_proc_readdir()
5276 if (!(server->caps & NFS_CAP_SECURITY_LABEL)) in _nfs4_proc_readdir()
5277 args.bitmask = server->attr_bitmask_nl; in _nfs4_proc_readdir()
5279 args.bitmask = server->attr_bitmask; in _nfs4_proc_readdir()
5281 nfs4_setup_readdir(nr_arg->cookie, nr_arg->verf, nr_arg->dentry, &args); in _nfs4_proc_readdir()
5283 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, in _nfs4_proc_readdir()
5286 memcpy(nr_res->verf, res.verifier.data, NFS4_VERIFIER_SIZE); in _nfs4_proc_readdir()
5305 trace_nfs4_readdir(d_inode(arg->dentry), err); in nfs4_proc_readdir()
5306 err = nfs4_handle_exception(NFS_SERVER(d_inode(arg->dentry)), in nfs4_proc_readdir()
5316 int mode = sattr->ia_mode; in _nfs4_proc_mknod()
5317 int status = -ENOMEM; in _nfs4_proc_mknod()
5319 data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4SOCK); in _nfs4_proc_mknod()
5324 data->arg.ftype = NF4FIFO; in _nfs4_proc_mknod()
5326 data->arg.ftype = NF4BLK; in _nfs4_proc_mknod()
5327 data->arg.u.device.specdata1 = MAJOR(rdev); in _nfs4_proc_mknod()
5328 data->arg.u.device.specdata2 = MINOR(rdev); in _nfs4_proc_mknod()
5331 data->arg.ftype = NF4CHR; in _nfs4_proc_mknod()
5332 data->arg.u.device.specdata1 = MAJOR(rdev); in _nfs4_proc_mknod()
5333 data->arg.u.device.specdata2 = MINOR(rdev); in _nfs4_proc_mknod()
5335 status = -EINVAL; in _nfs4_proc_mknod()
5339 data->arg.label = label; in _nfs4_proc_mknod()
5359 if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK)) in nfs4_proc_mknod()
5360 sattr->ia_mode &= ~current_umask(); in nfs4_proc_mknod()
5363 trace_nfs4_mknod(dir, &dentry->d_name, err); in nfs4_proc_mknod()
5378 .bitmask = server->attr_bitmask, in _nfs4_proc_statfs()
5389 nfs_fattr_init(fsstat->fattr); in _nfs4_proc_statfs()
5390 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_proc_statfs()
5412 .bitmask = server->attr_bitmask, in _nfs4_do_fsinfo()
5423 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_do_fsinfo()
5435 trace_nfs4_fsinfo(server, fhandle, fsinfo->fattr, err); in nfs4_do_fsinfo()
5437 nfs4_set_lease_period(server->nfs_client, fsinfo->lease_time * HZ); in nfs4_do_fsinfo()
5449 nfs_fattr_init(fsinfo->fattr); in nfs4_proc_fsinfo()
5453 server->pnfs_blksize = fsinfo->blksize; in nfs4_proc_fsinfo()
5465 .bitmask = server->attr_bitmask, in _nfs4_proc_pathconf()
5482 nfs_fattr_init(pathconf->fattr); in _nfs4_proc_pathconf()
5483 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_proc_pathconf()
5507 return nfs4_select_rw_stateid(ctx->state, fmode, l_ctx, stateid, NULL); in nfs4_set_rw_stateid()
5519 if (nfs4_set_rw_stateid(&_current_stateid, ctx, l_ctx, fmode) == -EIO) in nfs4_stateid_is_current()
5527 case -NFS4ERR_DELEG_REVOKED: in nfs4_error_stateid_expired()
5528 case -NFS4ERR_ADMIN_REVOKED: in nfs4_error_stateid_expired()
5529 case -NFS4ERR_BAD_STATEID: in nfs4_error_stateid_expired()
5530 case -NFS4ERR_STALE_STATEID: in nfs4_error_stateid_expired()
5531 case -NFS4ERR_OLD_STATEID: in nfs4_error_stateid_expired()
5532 case -NFS4ERR_OPENMODE: in nfs4_error_stateid_expired()
5533 case -NFS4ERR_EXPIRED: in nfs4_error_stateid_expired()
5541 struct nfs_server *server = NFS_SERVER(hdr->inode); in nfs4_read_done_cb()
5543 trace_nfs4_read(hdr, task->tk_status); in nfs4_read_done_cb()
5544 if (task->tk_status < 0) { in nfs4_read_done_cb()
5546 .inode = hdr->inode, in nfs4_read_done_cb()
5547 .state = hdr->args.context->state, in nfs4_read_done_cb()
5548 .stateid = &hdr->args.stateid, in nfs4_read_done_cb()
5550 task->tk_status = nfs4_async_handle_exception(task, in nfs4_read_done_cb()
5551 server, task->tk_status, &exception); in nfs4_read_done_cb()
5554 return -EAGAIN; in nfs4_read_done_cb()
5558 if (task->tk_status > 0) in nfs4_read_done_cb()
5559 renew_lease(server, hdr->timestamp); in nfs4_read_done_cb()
5567 if (!nfs4_error_stateid_expired(task->tk_status) || in nfs4_read_stateid_changed()
5568 nfs4_stateid_is_current(&args->stateid, in nfs4_read_stateid_changed()
5569 args->context, in nfs4_read_stateid_changed()
5570 args->lock_context, in nfs4_read_stateid_changed()
5580 struct nfs_server *server = NFS_SERVER(hdr->inode); in nfs4_read_plus_not_supported()
5581 struct rpc_message *msg = &task->tk_msg; in nfs4_read_plus_not_supported()
5583 if (msg->rpc_proc == &nfs4_procedures[NFSPROC4_CLNT_READ_PLUS] && in nfs4_read_plus_not_supported()
5584 task->tk_status == -ENOTSUPP) { in nfs4_read_plus_not_supported()
5585 server->caps &= ~NFS_CAP_READ_PLUS; in nfs4_read_plus_not_supported()
5586 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ]; in nfs4_read_plus_not_supported()
5595 if (!nfs4_sequence_done(task, &hdr->res.seq_res)) in nfs4_read_done()
5596 return -EAGAIN; in nfs4_read_done()
5597 if (nfs4_read_stateid_changed(task, &hdr->args)) in nfs4_read_done()
5598 return -EAGAIN; in nfs4_read_done()
5600 return -EAGAIN; in nfs4_read_done()
5601 if (task->tk_status > 0) in nfs4_read_done()
5602 nfs_invalidate_atime(hdr->inode); in nfs4_read_done()
5603 return hdr->pgio_done_cb ? hdr->pgio_done_cb(task, hdr) : in nfs4_read_done()
5612 if (nfs_server_capable(hdr->inode, NFS_CAP_READ_PLUS) && !hdr->ds_clp) { in nfs42_read_plus_support()
5613 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ_PLUS]; in nfs42_read_plus_support()
5629 hdr->timestamp = jiffies; in nfs4_proc_read_setup()
5630 if (!hdr->pgio_done_cb) in nfs4_proc_read_setup()
5631 hdr->pgio_done_cb = nfs4_read_done_cb; in nfs4_proc_read_setup()
5633 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ]; in nfs4_proc_read_setup()
5634 nfs4_init_sequence(&hdr->args.seq_args, &hdr->res.seq_res, 0, 0); in nfs4_proc_read_setup()
5640 if (nfs4_setup_sequence(NFS_SERVER(hdr->inode)->nfs_client, in nfs4_proc_pgio_rpc_prepare()
5641 &hdr->args.seq_args, in nfs4_proc_pgio_rpc_prepare()
5642 &hdr->res.seq_res, in nfs4_proc_pgio_rpc_prepare()
5645 if (nfs4_set_rw_stateid(&hdr->args.stateid, hdr->args.context, in nfs4_proc_pgio_rpc_prepare()
5646 hdr->args.lock_context, in nfs4_proc_pgio_rpc_prepare()
5647 hdr->rw_mode) == -EIO) in nfs4_proc_pgio_rpc_prepare()
5648 return -EIO; in nfs4_proc_pgio_rpc_prepare()
5649 if (unlikely(test_bit(NFS_CONTEXT_BAD, &hdr->args.context->flags))) in nfs4_proc_pgio_rpc_prepare()
5650 return -EIO; in nfs4_proc_pgio_rpc_prepare()
5657 struct inode *inode = hdr->inode; in nfs4_write_done_cb()
5659 trace_nfs4_write(hdr, task->tk_status); in nfs4_write_done_cb()
5660 if (task->tk_status < 0) { in nfs4_write_done_cb()
5662 .inode = hdr->inode, in nfs4_write_done_cb()
5663 .state = hdr->args.context->state, in nfs4_write_done_cb()
5664 .stateid = &hdr->args.stateid, in nfs4_write_done_cb()
5666 task->tk_status = nfs4_async_handle_exception(task, in nfs4_write_done_cb()
5667 NFS_SERVER(inode), task->tk_status, in nfs4_write_done_cb()
5671 return -EAGAIN; in nfs4_write_done_cb()
5674 if (task->tk_status >= 0) { in nfs4_write_done_cb()
5675 renew_lease(NFS_SERVER(inode), hdr->timestamp); in nfs4_write_done_cb()
5685 if (!nfs4_error_stateid_expired(task->tk_status) || in nfs4_write_stateid_changed()
5686 nfs4_stateid_is_current(&args->stateid, in nfs4_write_stateid_changed()
5687 args->context, in nfs4_write_stateid_changed()
5688 args->lock_context, in nfs4_write_stateid_changed()
5697 if (!nfs4_sequence_done(task, &hdr->res.seq_res)) in nfs4_write_done()
5698 return -EAGAIN; in nfs4_write_done()
5699 if (nfs4_write_stateid_changed(task, &hdr->args)) in nfs4_write_done()
5700 return -EAGAIN; in nfs4_write_done()
5701 return hdr->pgio_done_cb ? hdr->pgio_done_cb(task, hdr) : in nfs4_write_done()
5709 if (hdr->ds_clp != NULL || hdr->dreq != NULL) in nfs4_write_need_cache_consistency_data()
5714 return nfs4_have_delegation(hdr->inode, FMODE_READ, 0) == 0; in nfs4_write_need_cache_consistency_data()
5724 cache_validity |= READ_ONCE(NFS_I(inode)->cache_validity); in nfs4_bitmask_set()
5747 bitmask[i] &= server->attr_bitmask[i]; in nfs4_bitmask_set()
5754 struct nfs_server *server = NFS_SERVER(hdr->inode); in nfs4_proc_write_setup()
5757 hdr->args.bitmask = NULL; in nfs4_proc_write_setup()
5758 hdr->res.fattr = NULL; in nfs4_proc_write_setup()
5760 nfs4_bitmask_set(hdr->args.bitmask_store, in nfs4_proc_write_setup()
5761 server->cache_consistency_bitmask, in nfs4_proc_write_setup()
5762 hdr->inode, NFS_INO_INVALID_BLOCKS); in nfs4_proc_write_setup()
5763 hdr->args.bitmask = hdr->args.bitmask_store; in nfs4_proc_write_setup()
5766 if (!hdr->pgio_done_cb) in nfs4_proc_write_setup()
5767 hdr->pgio_done_cb = nfs4_write_done_cb; in nfs4_proc_write_setup()
5768 hdr->res.server = server; in nfs4_proc_write_setup()
5769 hdr->timestamp = jiffies; in nfs4_proc_write_setup()
5771 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE]; in nfs4_proc_write_setup()
5772 nfs4_init_sequence(&hdr->args.seq_args, &hdr->res.seq_res, 0, 0); in nfs4_proc_write_setup()
5773 nfs4_state_protect_write(hdr->ds_clp ? hdr->ds_clp : server->nfs_client, clnt, msg, hdr); in nfs4_proc_write_setup()
5778 nfs4_setup_sequence(NFS_SERVER(data->inode)->nfs_client, in nfs4_proc_commit_rpc_prepare()
5779 &data->args.seq_args, in nfs4_proc_commit_rpc_prepare()
5780 &data->res.seq_res, in nfs4_proc_commit_rpc_prepare()
5786 struct inode *inode = data->inode; in nfs4_commit_done_cb()
5788 trace_nfs4_commit(data, task->tk_status); in nfs4_commit_done_cb()
5790 NULL, NULL) == -EAGAIN) { in nfs4_commit_done_cb()
5792 return -EAGAIN; in nfs4_commit_done_cb()
5799 if (!nfs4_sequence_done(task, &data->res.seq_res)) in nfs4_commit_done()
5800 return -EAGAIN; in nfs4_commit_done()
5801 return data->commit_done_cb(task, data); in nfs4_commit_done()
5807 struct nfs_server *server = NFS_SERVER(data->inode); in nfs4_proc_commit_setup()
5809 if (data->commit_done_cb == NULL) in nfs4_proc_commit_setup()
5810 data->commit_done_cb = nfs4_commit_done_cb; in nfs4_proc_commit_setup()
5811 data->res.server = server; in nfs4_proc_commit_setup()
5812 msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT]; in nfs4_proc_commit_setup()
5813 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1, 0); in nfs4_proc_commit_setup()
5814 nfs4_state_protect(data->ds_clp ? data->ds_clp : server->nfs_client, in nfs4_proc_commit_setup()
5829 args->fh = NFS_FH(dst_inode); in _nfs4_proc_commit()
5830 return nfs4_call_sync(server->client, server, &msg, in _nfs4_proc_commit()
5831 &args->seq_args, &res->seq_res, 1); in _nfs4_proc_commit()
5864 struct nfs_client *clp = data->client; in nfs4_renew_release()
5866 if (refcount_read(&clp->cl_count) > 1) in nfs4_renew_release()
5875 struct nfs_client *clp = data->client; in nfs4_renew_done()
5876 unsigned long timestamp = data->timestamp; in nfs4_renew_done()
5878 trace_nfs4_renew_async(clp, task->tk_status); in nfs4_renew_done()
5879 switch (task->tk_status) { in nfs4_renew_done()
5882 case -NFS4ERR_LEASE_MOVED: in nfs4_renew_done()
5887 if (test_bit(NFS_CS_RENEWD, &clp->cl_res_state) == 0) in nfs4_renew_done()
5889 if (task->tk_status != NFS4ERR_CB_PATH_DOWN) { in nfs4_renew_done()
5914 if (!refcount_inc_not_zero(&clp->cl_count)) in nfs4_proc_async_renew()
5915 return -EIO; in nfs4_proc_async_renew()
5919 return -ENOMEM; in nfs4_proc_async_renew()
5921 data->client = clp; in nfs4_proc_async_renew()
5922 data->timestamp = jiffies; in nfs4_proc_async_renew()
5923 return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT, in nfs4_proc_async_renew()
5937 status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT); in nfs4_proc_renew()
5949 return server->attr_bitmask[0] & FATTR4_WORD0_ACL; in nfs4_server_supports_acls()
5951 return server->attr_bitmask[1] & FATTR4_WORD1_DACL; in nfs4_server_supports_acls()
5953 return server->attr_bitmask[1] & FATTR4_WORD1_SACL; in nfs4_server_supports_acls()
5979 buflen -= len; in nfs4_buf_to_pages_noslab()
5987 for(; rc > 0; rc--) in nfs4_buf_to_pages_noslab()
5988 __free_page(spages[rc-1]); in nfs4_buf_to_pages_noslab()
5989 return -ENOMEM; in nfs4_buf_to_pages_noslab()
6003 spin_lock(&inode->i_lock); in nfs4_set_cached_acl()
6004 kfree(nfsi->nfs4_acl); in nfs4_set_cached_acl()
6005 nfsi->nfs4_acl = acl; in nfs4_set_cached_acl()
6006 spin_unlock(&inode->i_lock); in nfs4_set_cached_acl()
6019 int ret = -ENOENT; in nfs4_read_cached_acl()
6021 spin_lock(&inode->i_lock); in nfs4_read_cached_acl()
6022 acl = nfsi->nfs4_acl; in nfs4_read_cached_acl()
6025 if (acl->type != type) in nfs4_read_cached_acl()
6029 if (acl->cached == 0) in nfs4_read_cached_acl()
6031 ret = -ERANGE; /* see getxattr(2) man page */ in nfs4_read_cached_acl()
6032 if (acl->len > buflen) in nfs4_read_cached_acl()
6034 memcpy(buf, acl->data, acl->len); in nfs4_read_cached_acl()
6036 ret = acl->len; in nfs4_read_cached_acl()
6038 spin_unlock(&inode->i_lock); in nfs4_read_cached_acl()
6053 acl->cached = 1; in nfs4_write_cached_acl()
6054 _copy_from_pages(acl->data, pages, pgbase, acl_len); in nfs4_write_cached_acl()
6059 acl->cached = 0; in nfs4_write_cached_acl()
6061 acl->type = type; in nfs4_write_cached_acl()
6062 acl->len = acl_len; in nfs4_write_cached_acl()
6096 int ret = -ENOMEM, i; in __nfs4_get_acl_uncached()
6100 buflen = server->rsize; in __nfs4_get_acl_uncached()
6105 return -ENOMEM; in __nfs4_get_acl_uncached()
6124 ret = nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), in __nfs4_get_acl_uncached()
6129 /* Handle the case where the passed-in buffer is too short */ in __nfs4_get_acl_uncached()
6134 ret = -ERANGE; in __nfs4_get_acl_uncached()
6141 ret = -ERANGE; in __nfs4_get_acl_uncached()
6149 while (--i >= 0) in __nfs4_get_acl_uncached()
6181 return -EOPNOTSUPP; in nfs4_proc_get_acl()
6185 if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL) in nfs4_proc_get_acl()
6188 if (ret != -ENOENT) in nfs4_proc_get_acl()
6189 /* -ENOENT is returned if there is no ACL or if there is an ACL in nfs4_proc_get_acl()
6217 return -EINVAL; in __nfs4_proc_set_acl()
6219 return -EOPNOTSUPP; in __nfs4_proc_set_acl()
6221 return -ERANGE; in __nfs4_proc_set_acl()
6226 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); in __nfs4_proc_set_acl()
6232 for (; i > 0; i--) in __nfs4_proc_set_acl()
6233 put_page(pages[i-1]); in __nfs4_proc_set_acl()
6239 spin_lock(&inode->i_lock); in __nfs4_proc_set_acl()
6243 spin_unlock(&inode->i_lock); in __nfs4_proc_set_acl()
6257 if (err == -NFS4ERR_BADOWNER || err == -NFS4ERR_BADNAME) { in nfs4_proc_set_acl()
6260 * isn't involved in encoding the ACEs. in nfs4_proc_set_acl()
6262 err = -EINVAL; in nfs4_proc_set_acl()
6299 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 0); in _nfs4_get_security_label()
6303 return -ENOENT; in _nfs4_get_security_label()
6316 return -EOPNOTSUPP; in nfs4_get_security_label()
6355 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); in _nfs4_do_set_security_label()
6386 return -EOPNOTSUPP; in nfs4_set_security_label()
6390 return -ENOMEM; in nfs4_set_security_label()
6407 if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) { in nfs4_init_boot_verifier()
6413 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); in nfs4_init_boot_verifier()
6414 u64 ns = ktime_to_ns(nn->boot_time); in nfs4_init_boot_verifier()
6419 memcpy(bootverf->data, verf, sizeof(bootverf->data)); in nfs4_init_boot_verifier()
6425 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); in nfs4_get_uniquifier()
6426 struct nfs_netns_client *nn_clp = nn->nfs_client; in nfs4_get_uniquifier()
6433 id = rcu_dereference(nn_clp->identifier); in nfs4_get_uniquifier()
6453 if (clp->cl_owner_id != NULL) in nfs4_init_nonuniform_client_string()
6458 strlen(clp->cl_rpcclient->cl_nodename) + in nfs4_init_nonuniform_client_string()
6460 strlen(rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR)) + in nfs4_init_nonuniform_client_string()
6469 return -EINVAL; in nfs4_init_nonuniform_client_string()
6474 * about a memory-reclaim deadlock. in nfs4_init_nonuniform_client_string()
6478 return -ENOMEM; in nfs4_init_nonuniform_client_string()
6483 clp->cl_rpcclient->cl_nodename, buf, in nfs4_init_nonuniform_client_string()
6484 rpc_peeraddr2str(clp->cl_rpcclient, in nfs4_init_nonuniform_client_string()
6488 clp->cl_rpcclient->cl_nodename, in nfs4_init_nonuniform_client_string()
6489 rpc_peeraddr2str(clp->cl_rpcclient, in nfs4_init_nonuniform_client_string()
6493 clp->cl_owner_id = str; in nfs4_init_nonuniform_client_string()
6505 if (clp->cl_owner_id != NULL) in nfs4_init_uniform_client_string()
6509 strlen(clp->cl_rpcclient->cl_nodename) + 1; in nfs4_init_uniform_client_string()
6516 return -EINVAL; in nfs4_init_uniform_client_string()
6521 * about a memory-reclaim deadlock. in nfs4_init_uniform_client_string()
6525 return -ENOMEM; in nfs4_init_uniform_client_string()
6529 clp->rpc_ops->version, clp->cl_minorversion, in nfs4_init_uniform_client_string()
6530 buf, clp->cl_rpcclient->cl_nodename); in nfs4_init_uniform_client_string()
6533 clp->rpc_ops->version, clp->cl_minorversion, in nfs4_init_uniform_client_string()
6534 clp->cl_rpcclient->cl_nodename); in nfs4_init_uniform_client_string()
6535 clp->cl_owner_id = str; in nfs4_init_uniform_client_string()
6547 if (strchr(clp->cl_ipaddr, ':') != NULL) in nfs4_init_callback_netid()
6557 if (task->tk_status == 0) in nfs4_setclientid_done()
6558 sc->sc_cred = get_rpccred(task->tk_rqstp->rq_cred); in nfs4_setclientid_done()
6566 * nfs4_proc_setclientid - Negotiate client ID
6592 .rpc_client = clp->cl_rpcclient, in nfs4_proc_setclientid()
6604 if (test_bit(NFS_CS_MIGRATION, &clp->cl_flags)) in nfs4_proc_setclientid()
6619 clp->cl_ipaddr, port >> 8, port & 255); in nfs4_proc_setclientid()
6622 clp->cl_rpcclient->cl_auth->au_ops->au_name, in nfs4_proc_setclientid()
6623 clp->cl_owner_id); in nfs4_proc_setclientid()
6627 kfree(clp->cl_acceptor); in nfs4_proc_setclientid()
6628 clp->cl_acceptor = rpcauth_stringify_acceptor(setclientid.sc_cred); in nfs4_proc_setclientid()
6641 * nfs4_proc_setclientid_confirm - Confirm client ID
6660 clp->cl_rpcclient->cl_auth->au_ops->au_name, in nfs4_proc_setclientid_confirm()
6661 clp->cl_clientid); in nfs4_proc_setclientid_confirm()
6662 status = rpc_call_sync(clp->cl_rpcclient, &msg, in nfs4_proc_setclientid_confirm()
6692 .inode = data->inode, in nfs4_delegreturn_done()
6693 .stateid = &data->stateid, in nfs4_delegreturn_done()
6694 .task_is_privileged = data->args.seq_args.sa_privileged, in nfs4_delegreturn_done()
6697 if (!nfs4_sequence_done(task, &data->res.seq_res)) in nfs4_delegreturn_done()
6700 trace_nfs4_delegreturn_exit(&data->args, &data->res, task->tk_status); in nfs4_delegreturn_done()
6703 if (pnfs_roc_done(task, &data->args.lr_args, &data->res.lr_res, in nfs4_delegreturn_done()
6704 &data->res.lr_ret) == -EAGAIN) in nfs4_delegreturn_done()
6707 if (data->args.sattr_args && task->tk_status != 0) { in nfs4_delegreturn_done()
6708 switch(data->res.sattr_ret) { in nfs4_delegreturn_done()
6710 data->args.sattr_args = NULL; in nfs4_delegreturn_done()
6711 data->res.sattr_res = false; in nfs4_delegreturn_done()
6713 case -NFS4ERR_ADMIN_REVOKED: in nfs4_delegreturn_done()
6714 case -NFS4ERR_DELEG_REVOKED: in nfs4_delegreturn_done()
6715 case -NFS4ERR_EXPIRED: in nfs4_delegreturn_done()
6716 case -NFS4ERR_BAD_STATEID: in nfs4_delegreturn_done()
6719 case -NFS4ERR_OLD_STATEID: in nfs4_delegreturn_done()
6720 if (nfs4_refresh_delegation_stateid(&data->stateid, in nfs4_delegreturn_done()
6721 data->inode)) in nfs4_delegreturn_done()
6725 data->args.sattr_args = NULL; in nfs4_delegreturn_done()
6726 data->res.sattr_res = false; in nfs4_delegreturn_done()
6731 switch (task->tk_status) { in nfs4_delegreturn_done()
6733 renew_lease(data->res.server, data->timestamp); in nfs4_delegreturn_done()
6735 case -NFS4ERR_ADMIN_REVOKED: in nfs4_delegreturn_done()
6736 case -NFS4ERR_DELEG_REVOKED: in nfs4_delegreturn_done()
6737 case -NFS4ERR_EXPIRED: in nfs4_delegreturn_done()
6738 nfs4_free_revoked_stateid(data->res.server, in nfs4_delegreturn_done()
6739 data->args.stateid, in nfs4_delegreturn_done()
6740 task->tk_msg.rpc_cred); in nfs4_delegreturn_done()
6742 case -NFS4ERR_BAD_STATEID: in nfs4_delegreturn_done()
6743 case -NFS4ERR_STALE_STATEID: in nfs4_delegreturn_done()
6744 case -ETIMEDOUT: in nfs4_delegreturn_done()
6745 task->tk_status = 0; in nfs4_delegreturn_done()
6747 case -NFS4ERR_OLD_STATEID: in nfs4_delegreturn_done()
6748 if (!nfs4_refresh_delegation_stateid(&data->stateid, data->inode)) in nfs4_delegreturn_done()
6749 nfs4_stateid_seqid_inc(&data->stateid); in nfs4_delegreturn_done()
6750 if (data->args.bitmask) { in nfs4_delegreturn_done()
6751 data->args.bitmask = NULL; in nfs4_delegreturn_done()
6752 data->res.fattr = NULL; in nfs4_delegreturn_done()
6755 case -NFS4ERR_ACCESS: in nfs4_delegreturn_done()
6756 if (data->args.bitmask) { in nfs4_delegreturn_done()
6757 data->args.bitmask = NULL; in nfs4_delegreturn_done()
6758 data->res.fattr = NULL; in nfs4_delegreturn_done()
6763 task->tk_status = nfs4_async_handle_exception(task, in nfs4_delegreturn_done()
6764 data->res.server, task->tk_status, in nfs4_delegreturn_done()
6769 nfs_delegation_mark_returned(data->inode, data->args.stateid); in nfs4_delegreturn_done()
6770 data->rpc_status = task->tk_status; in nfs4_delegreturn_done()
6773 task->tk_status = 0; in nfs4_delegreturn_done()
6780 struct inode *inode = data->inode; in nfs4_delegreturn_release()
6782 if (data->lr.roc) in nfs4_delegreturn_release()
6783 pnfs_roc_release(&data->lr.arg, &data->lr.res, in nfs4_delegreturn_release()
6784 data->res.lr_ret); in nfs4_delegreturn_release()
6786 nfs4_fattr_set_prechange(&data->fattr, in nfs4_delegreturn_release()
6788 nfs_refresh_inode(inode, &data->fattr); in nfs4_delegreturn_release()
6801 if (!d_data->lr.roc && nfs4_wait_on_layoutreturn(d_data->inode, task)) { in nfs4_delegreturn_prepare()
6802 nfs4_sequence_done(task, &d_data->res.seq_res); in nfs4_delegreturn_prepare()
6806 lo = d_data->args.lr_args ? d_data->args.lr_args->layout : NULL; in nfs4_delegreturn_prepare()
6808 d_data->args.lr_args = NULL; in nfs4_delegreturn_prepare()
6809 d_data->res.lr_res = NULL; in nfs4_delegreturn_prepare()
6812 nfs4_setup_sequence(d_data->res.server->nfs_client, in nfs4_delegreturn_prepare()
6813 &d_data->args.seq_args, in nfs4_delegreturn_prepare()
6814 &d_data->res.seq_res, in nfs4_delegreturn_prepare()
6837 .rpc_client = server->client, in _nfs4_proc_delegreturn()
6849 return -ENOMEM; in _nfs4_proc_delegreturn()
6851 nfs4_state_protect(server->nfs_client, in _nfs4_proc_delegreturn()
6855 data->args.fhandle = &data->fh; in _nfs4_proc_delegreturn()
6856 data->args.stateid = &data->stateid; in _nfs4_proc_delegreturn()
6857 nfs4_bitmask_set(data->args.bitmask_store, in _nfs4_proc_delegreturn()
6858 server->cache_consistency_bitmask, inode, 0); in _nfs4_proc_delegreturn()
6859 data->args.bitmask = data->args.bitmask_store; in _nfs4_proc_delegreturn()
6860 nfs_copy_fh(&data->fh, NFS_FH(inode)); in _nfs4_proc_delegreturn()
6861 nfs4_stateid_copy(&data->stateid, stateid); in _nfs4_proc_delegreturn()
6862 data->res.fattr = &data->fattr; in _nfs4_proc_delegreturn()
6863 data->res.server = server; in _nfs4_proc_delegreturn()
6864 data->res.lr_ret = -NFS4ERR_NOMATCHING_LAYOUT; in _nfs4_proc_delegreturn()
6865 data->lr.arg.ld_private = &data->lr.ld_private; in _nfs4_proc_delegreturn()
6866 nfs_fattr_init(data->res.fattr); in _nfs4_proc_delegreturn()
6867 data->timestamp = jiffies; in _nfs4_proc_delegreturn()
6868 data->rpc_status = 0; in _nfs4_proc_delegreturn()
6869 data->inode = nfs_igrab_and_active(inode); in _nfs4_proc_delegreturn()
6870 if (data->inode || issync) { in _nfs4_proc_delegreturn()
6871 data->lr.roc = pnfs_roc(inode, &data->lr.arg, &data->lr.res, in _nfs4_proc_delegreturn()
6873 if (data->lr.roc) { in _nfs4_proc_delegreturn()
6874 data->args.lr_args = &data->lr.arg; in _nfs4_proc_delegreturn()
6875 data->res.lr_res = &data->lr.res; in _nfs4_proc_delegreturn()
6880 test_bit(NFS_DELEGATION_DELEGTIME, &delegation->flags)) { in _nfs4_proc_delegreturn()
6881 if (delegation->type & FMODE_READ) { in _nfs4_proc_delegreturn()
6882 data->sattr.atime = inode_get_atime(inode); in _nfs4_proc_delegreturn()
6883 data->sattr.atime_set = true; in _nfs4_proc_delegreturn()
6885 if (delegation->type & FMODE_WRITE) { in _nfs4_proc_delegreturn()
6886 data->sattr.mtime = inode_get_mtime(inode); in _nfs4_proc_delegreturn()
6887 data->sattr.mtime_set = true; in _nfs4_proc_delegreturn()
6889 data->args.sattr_args = &data->sattr; in _nfs4_proc_delegreturn()
6890 data->res.sattr_res = true; in _nfs4_proc_delegreturn()
6893 if (!data->inode) in _nfs4_proc_delegreturn()
6894 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1, in _nfs4_proc_delegreturn()
6897 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1, in _nfs4_proc_delegreturn()
6901 msg.rpc_argp = &data->args; in _nfs4_proc_delegreturn()
6902 msg.rpc_resp = &data->res; in _nfs4_proc_delegreturn()
6911 status = data->rpc_status; in _nfs4_proc_delegreturn()
6929 case -NFS4ERR_STALE_STATEID: in nfs4_proc_delegreturn()
6930 case -NFS4ERR_EXPIRED: in nfs4_proc_delegreturn()
6941 struct inode *inode = state->inode; in _nfs4_proc_getlk()
6943 struct nfs_client *clp = server->nfs_client; in _nfs4_proc_getlk()
6955 .rpc_cred = state->owner->so_cred, in _nfs4_proc_getlk()
6960 arg.lock_owner.clientid = clp->cl_clientid; in _nfs4_proc_getlk()
6964 lsp = request->fl_u.nfs4_fl.owner; in _nfs4_proc_getlk()
6965 arg.lock_owner.id = lsp->ls_seqid.owner_id; in _nfs4_proc_getlk()
6966 arg.lock_owner.s_dev = server->s_dev; in _nfs4_proc_getlk()
6967 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1); in _nfs4_proc_getlk()
6970 request->c.flc_type = F_UNLCK; in _nfs4_proc_getlk()
6972 case -NFS4ERR_DENIED: in _nfs4_proc_getlk()
6975 request->fl_ops->fl_release_private(request); in _nfs4_proc_getlk()
6976 request->fl_ops = NULL; in _nfs4_proc_getlk()
6991 err = nfs4_handle_exception(NFS_SERVER(state->inode), err, in nfs4_proc_getlk()
7004 struct nfs4_state *state = lsp->ls_state; in nfs4_refresh_lock_old_stateid()
7007 spin_lock(&state->state_lock); in nfs4_refresh_lock_old_stateid()
7008 if (!nfs4_stateid_match_other(dst, &lsp->ls_stateid)) in nfs4_refresh_lock_old_stateid()
7010 if (!nfs4_stateid_is_newer(&lsp->ls_stateid, dst)) in nfs4_refresh_lock_old_stateid()
7013 dst->seqid = lsp->ls_stateid.seqid; in nfs4_refresh_lock_old_stateid()
7016 spin_unlock(&state->state_lock); in nfs4_refresh_lock_old_stateid()
7023 struct nfs4_state *state = lsp->ls_state; in nfs4_sync_lock_stateid()
7026 spin_lock(&state->state_lock); in nfs4_sync_lock_stateid()
7027 ret = !nfs4_stateid_match_other(dst, &lsp->ls_stateid); in nfs4_sync_lock_stateid()
7028 nfs4_stateid_copy(dst, &lsp->ls_stateid); in nfs4_sync_lock_stateid()
7029 spin_unlock(&state->state_lock); in nfs4_sync_lock_stateid()
7050 struct nfs4_state *state = lsp->ls_state; in nfs4_alloc_unlockdata()
7051 struct inode *inode = state->inode; in nfs4_alloc_unlockdata()
7056 p->arg.fh = NFS_FH(inode); in nfs4_alloc_unlockdata()
7057 p->arg.fl = &p->fl; in nfs4_alloc_unlockdata()
7058 p->arg.seqid = seqid; in nfs4_alloc_unlockdata()
7059 p->res.seqid = seqid; in nfs4_alloc_unlockdata()
7060 p->lsp = lsp; in nfs4_alloc_unlockdata()
7062 p->ctx = get_nfs_open_context(ctx); in nfs4_alloc_unlockdata()
7063 p->l_ctx = nfs_get_lock_context(ctx); in nfs4_alloc_unlockdata()
7064 locks_init_lock(&p->fl); in nfs4_alloc_unlockdata()
7065 locks_copy_lock(&p->fl, fl); in nfs4_alloc_unlockdata()
7066 p->server = NFS_SERVER(inode); in nfs4_alloc_unlockdata()
7067 spin_lock(&state->state_lock); in nfs4_alloc_unlockdata()
7068 nfs4_stateid_copy(&p->arg.stateid, &lsp->ls_stateid); in nfs4_alloc_unlockdata()
7069 spin_unlock(&state->state_lock); in nfs4_alloc_unlockdata()
7076 nfs_free_seqid(calldata->arg.seqid); in nfs4_locku_release_calldata()
7077 nfs4_put_lock_state(calldata->lsp); in nfs4_locku_release_calldata()
7078 nfs_put_lock_context(calldata->l_ctx); in nfs4_locku_release_calldata()
7079 put_nfs_open_context(calldata->ctx); in nfs4_locku_release_calldata()
7087 .inode = calldata->lsp->ls_state->inode, in nfs4_locku_done()
7088 .stateid = &calldata->arg.stateid, in nfs4_locku_done()
7091 if (!nfs4_sequence_done(task, &calldata->res.seq_res)) in nfs4_locku_done()
7093 switch (task->tk_status) { in nfs4_locku_done()
7095 renew_lease(calldata->server, calldata->timestamp); in nfs4_locku_done()
7096 locks_lock_inode_wait(calldata->lsp->ls_state->inode, &calldata->fl); in nfs4_locku_done()
7097 if (nfs4_update_lock_stateid(calldata->lsp, in nfs4_locku_done()
7098 &calldata->res.stateid)) in nfs4_locku_done()
7101 case -NFS4ERR_ADMIN_REVOKED: in nfs4_locku_done()
7102 case -NFS4ERR_EXPIRED: in nfs4_locku_done()
7103 nfs4_free_revoked_stateid(calldata->server, in nfs4_locku_done()
7104 &calldata->arg.stateid, in nfs4_locku_done()
7105 task->tk_msg.rpc_cred); in nfs4_locku_done()
7107 case -NFS4ERR_BAD_STATEID: in nfs4_locku_done()
7108 case -NFS4ERR_STALE_STATEID: in nfs4_locku_done()
7109 if (nfs4_sync_lock_stateid(&calldata->arg.stateid, in nfs4_locku_done()
7110 calldata->lsp)) in nfs4_locku_done()
7113 case -NFS4ERR_OLD_STATEID: in nfs4_locku_done()
7114 if (nfs4_refresh_lock_old_stateid(&calldata->arg.stateid, in nfs4_locku_done()
7115 calldata->lsp)) in nfs4_locku_done()
7119 task->tk_status = nfs4_async_handle_exception(task, in nfs4_locku_done()
7120 calldata->server, task->tk_status, in nfs4_locku_done()
7125 nfs_release_seqid(calldata->arg.seqid); in nfs4_locku_done()
7132 if (test_bit(NFS_CONTEXT_UNLOCK, &calldata->l_ctx->open_context->flags) && in nfs4_locku_prepare()
7133 nfs_async_iocounter_wait(task, calldata->l_ctx)) in nfs4_locku_prepare()
7136 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0) in nfs4_locku_prepare()
7138 if (test_bit(NFS_LOCK_INITIALIZED, &calldata->lsp->ls_flags) == 0) { in nfs4_locku_prepare()
7142 calldata->timestamp = jiffies; in nfs4_locku_prepare()
7143 if (nfs4_setup_sequence(calldata->server->nfs_client, in nfs4_locku_prepare()
7144 &calldata->arg.seq_args, in nfs4_locku_prepare()
7145 &calldata->res.seq_res, in nfs4_locku_prepare()
7147 nfs_release_seqid(calldata->arg.seqid); in nfs4_locku_prepare()
7150 task->tk_action = NULL; in nfs4_locku_prepare()
7152 nfs4_sequence_done(task, &calldata->res.seq_res); in nfs4_locku_prepare()
7169 .rpc_cred = ctx->cred, in nfs4_do_unlck()
7172 .rpc_client = NFS_CLIENT(lsp->ls_state->inode), in nfs4_do_unlck()
7179 if (nfs_server_capable(lsp->ls_state->inode, NFS_CAP_MOVEABLE)) in nfs4_do_unlck()
7182 nfs4_state_protect(NFS_SERVER(lsp->ls_state->inode)->nfs_client, in nfs4_do_unlck()
7185 /* Ensure this is an unlock - when canceling a lock, the in nfs4_do_unlck()
7188 fl->c.flc_type = F_UNLCK; in nfs4_do_unlck()
7189 if (fl->c.flc_flags & FL_CLOSE) in nfs4_do_unlck()
7190 set_bit(NFS_CONTEXT_UNLOCK, &ctx->flags); in nfs4_do_unlck()
7195 return ERR_PTR(-ENOMEM); in nfs4_do_unlck()
7198 nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1, 0); in nfs4_do_unlck()
7199 msg.rpc_argp = &data->arg; in nfs4_do_unlck()
7200 msg.rpc_resp = &data->res; in nfs4_do_unlck()
7207 struct inode *inode = state->inode; in nfs4_proc_unlck()
7208 struct nfs4_state_owner *sp = state->owner; in nfs4_proc_unlck()
7215 unsigned char saved_flags = request->c.flc_flags; in nfs4_proc_unlck()
7219 request->c.flc_flags |= FL_EXISTS; in nfs4_proc_unlck()
7221 mutex_lock(&sp->so_delegreturn_mutex); in nfs4_proc_unlck()
7222 /* Exclude nfs4_reclaim_open_stateid() - note nesting! */ in nfs4_proc_unlck()
7223 down_read(&nfsi->rwsem); in nfs4_proc_unlck()
7224 if (locks_lock_inode_wait(inode, request) == -ENOENT) { in nfs4_proc_unlck()
7225 up_read(&nfsi->rwsem); in nfs4_proc_unlck()
7226 mutex_unlock(&sp->so_delegreturn_mutex); in nfs4_proc_unlck()
7229 lsp = request->fl_u.nfs4_fl.owner; in nfs4_proc_unlck()
7230 set_bit(NFS_LOCK_UNLOCKING, &lsp->ls_flags); in nfs4_proc_unlck()
7231 up_read(&nfsi->rwsem); in nfs4_proc_unlck()
7232 mutex_unlock(&sp->so_delegreturn_mutex); in nfs4_proc_unlck()
7236 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) == 0) in nfs4_proc_unlck()
7238 alloc_seqid = NFS_SERVER(inode)->nfs_client->cl_mvops->alloc_seqid; in nfs4_proc_unlck()
7239 seqid = alloc_seqid(&lsp->ls_seqid, GFP_KERNEL); in nfs4_proc_unlck()
7240 status = -ENOMEM; in nfs4_proc_unlck()
7244 nfs_file_open_context(request->c.flc_file), in nfs4_proc_unlck()
7252 request->c.flc_flags = saved_flags; in nfs4_proc_unlck()
7274 struct inode *inode = lsp->ls_state->inode; in nfs4_alloc_lockdata()
7282 p->arg.fh = NFS_FH(inode); in nfs4_alloc_lockdata()
7283 p->arg.fl = &p->fl; in nfs4_alloc_lockdata()
7284 p->arg.open_seqid = nfs_alloc_seqid(&lsp->ls_state->owner->so_seqid, gfp_mask); in nfs4_alloc_lockdata()
7285 if (IS_ERR(p->arg.open_seqid)) in nfs4_alloc_lockdata()
7287 alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid; in nfs4_alloc_lockdata()
7288 p->arg.lock_seqid = alloc_seqid(&lsp->ls_seqid, gfp_mask); in nfs4_alloc_lockdata()
7289 if (IS_ERR(p->arg.lock_seqid)) in nfs4_alloc_lockdata()
7291 p->arg.lock_owner.clientid = server->nfs_client->cl_clientid; in nfs4_alloc_lockdata()
7292 p->arg.lock_owner.id = lsp->ls_seqid.owner_id; in nfs4_alloc_lockdata()
7293 p->arg.lock_owner.s_dev = server->s_dev; in nfs4_alloc_lockdata()
7294 p->res.lock_seqid = p->arg.lock_seqid; in nfs4_alloc_lockdata()
7295 p->lsp = lsp; in nfs4_alloc_lockdata()
7296 p->server = server; in nfs4_alloc_lockdata()
7297 p->ctx = get_nfs_open_context(ctx); in nfs4_alloc_lockdata()
7298 locks_init_lock(&p->fl); in nfs4_alloc_lockdata()
7299 locks_copy_lock(&p->fl, fl); in nfs4_alloc_lockdata()
7302 nfs_free_seqid(p->arg.open_seqid); in nfs4_alloc_lockdata()
7311 struct nfs4_state *state = data->lsp->ls_state; in nfs4_lock_prepare()
7313 if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0) in nfs4_lock_prepare()
7316 if (!test_bit(NFS_LOCK_INITIALIZED, &data->lsp->ls_flags)) { in nfs4_lock_prepare()
7317 if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0) { in nfs4_lock_prepare()
7320 nfs4_stateid_copy(&data->arg.open_stateid, in nfs4_lock_prepare()
7321 &state->open_stateid); in nfs4_lock_prepare()
7322 data->arg.new_lock_owner = 1; in nfs4_lock_prepare()
7323 data->res.open_seqid = data->arg.open_seqid; in nfs4_lock_prepare()
7325 data->arg.new_lock_owner = 0; in nfs4_lock_prepare()
7326 nfs4_stateid_copy(&data->arg.lock_stateid, in nfs4_lock_prepare()
7327 &data->lsp->ls_stateid); in nfs4_lock_prepare()
7330 data->rpc_status = -EBADF; in nfs4_lock_prepare()
7331 task->tk_action = NULL; in nfs4_lock_prepare()
7334 data->timestamp = jiffies; in nfs4_lock_prepare()
7335 if (nfs4_setup_sequence(data->server->nfs_client, in nfs4_lock_prepare()
7336 &data->arg.seq_args, in nfs4_lock_prepare()
7337 &data->res.seq_res, in nfs4_lock_prepare()
7341 nfs_release_seqid(data->arg.open_seqid); in nfs4_lock_prepare()
7343 nfs_release_seqid(data->arg.lock_seqid); in nfs4_lock_prepare()
7345 nfs4_sequence_done(task, &data->res.seq_res); in nfs4_lock_prepare()
7346 dprintk("%s: ret = %d\n", __func__, data->rpc_status); in nfs4_lock_prepare()
7352 struct nfs4_lock_state *lsp = data->lsp; in nfs4_lock_done()
7354 if (!nfs4_sequence_done(task, &data->res.seq_res)) in nfs4_lock_done()
7357 data->rpc_status = task->tk_status; in nfs4_lock_done()
7358 switch (task->tk_status) { in nfs4_lock_done()
7360 renew_lease(NFS_SERVER(d_inode(data->ctx->dentry)), in nfs4_lock_done()
7361 data->timestamp); in nfs4_lock_done()
7362 if (data->arg.new_lock && !data->cancelled) { in nfs4_lock_done()
7363 data->fl.c.flc_flags &= ~(FL_SLEEP | FL_ACCESS); in nfs4_lock_done()
7364 if (locks_lock_inode_wait(lsp->ls_state->inode, &data->fl) < 0) in nfs4_lock_done()
7367 if (data->arg.new_lock_owner != 0) { in nfs4_lock_done()
7368 nfs_confirm_seqid(&lsp->ls_seqid, 0); in nfs4_lock_done()
7369 nfs4_stateid_copy(&lsp->ls_stateid, &data->res.stateid); in nfs4_lock_done()
7370 set_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags); in nfs4_lock_done()
7371 } else if (!nfs4_update_lock_stateid(lsp, &data->res.stateid)) in nfs4_lock_done()
7374 case -NFS4ERR_OLD_STATEID: in nfs4_lock_done()
7375 if (data->arg.new_lock_owner != 0 && in nfs4_lock_done()
7376 nfs4_refresh_open_old_stateid(&data->arg.open_stateid, in nfs4_lock_done()
7377 lsp->ls_state)) in nfs4_lock_done()
7379 if (nfs4_refresh_lock_old_stateid(&data->arg.lock_stateid, lsp)) in nfs4_lock_done()
7382 case -NFS4ERR_BAD_STATEID: in nfs4_lock_done()
7383 case -NFS4ERR_STALE_STATEID: in nfs4_lock_done()
7384 case -NFS4ERR_EXPIRED: in nfs4_lock_done()
7385 if (data->arg.new_lock_owner != 0) { in nfs4_lock_done()
7386 if (!nfs4_stateid_match(&data->arg.open_stateid, in nfs4_lock_done()
7387 &lsp->ls_state->open_stateid)) in nfs4_lock_done()
7389 } else if (!nfs4_stateid_match(&data->arg.lock_stateid, in nfs4_lock_done()
7390 &lsp->ls_stateid)) in nfs4_lock_done()
7394 dprintk("%s: ret = %d!\n", __func__, data->rpc_status); in nfs4_lock_done()
7397 if (!data->cancelled) in nfs4_lock_done()
7406 nfs_free_seqid(data->arg.open_seqid); in nfs4_lock_release()
7407 if (data->cancelled && data->rpc_status == 0) { in nfs4_lock_release()
7409 task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp, in nfs4_lock_release()
7410 data->arg.lock_seqid); in nfs4_lock_release()
7415 nfs_free_seqid(data->arg.lock_seqid); in nfs4_lock_release()
7416 nfs4_put_lock_state(data->lsp); in nfs4_lock_release()
7417 put_nfs_open_context(data->ctx); in nfs4_lock_release()
7430 case -NFS4ERR_ADMIN_REVOKED: in nfs4_handle_setlk_error()
7431 case -NFS4ERR_EXPIRED: in nfs4_handle_setlk_error()
7432 case -NFS4ERR_BAD_STATEID: in nfs4_handle_setlk_error()
7433 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED; in nfs4_handle_setlk_error()
7435 test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0) in nfs4_handle_setlk_error()
7436 nfs4_schedule_stateid_recovery(server, lsp->ls_state); in nfs4_handle_setlk_error()
7438 case -NFS4ERR_STALE_STATEID: in nfs4_handle_setlk_error()
7439 lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED; in nfs4_handle_setlk_error()
7440 nfs4_schedule_lease_recovery(server->nfs_client); in nfs4_handle_setlk_error()
7450 .rpc_cred = state->owner->so_cred, in _nfs4_do_setlk()
7453 .rpc_client = NFS_CLIENT(state->inode), in _nfs4_do_setlk()
7461 if (nfs_server_capable(state->inode, NFS_CAP_MOVEABLE)) in _nfs4_do_setlk()
7465 nfs_file_open_context(fl->c.flc_file), in _nfs4_do_setlk()
7466 fl->fl_u.nfs4_fl.owner, GFP_KERNEL); in _nfs4_do_setlk()
7468 return -ENOMEM; in _nfs4_do_setlk()
7470 data->arg.block = 1; in _nfs4_do_setlk()
7471 nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1, in _nfs4_do_setlk()
7473 msg.rpc_argp = &data->arg; in _nfs4_do_setlk()
7474 msg.rpc_resp = &data->res; in _nfs4_do_setlk()
7478 data->arg.reclaim = NFS_LOCK_RECLAIM; in _nfs4_do_setlk()
7480 data->arg.new_lock = 1; in _nfs4_do_setlk()
7486 ret = data->rpc_status; in _nfs4_do_setlk()
7488 nfs4_handle_setlk_error(data->server, data->lsp, in _nfs4_do_setlk()
7489 data->arg.new_lock_owner, ret); in _nfs4_do_setlk()
7491 data->cancelled = true; in _nfs4_do_setlk()
7492 trace_nfs4_set_lock(fl, state, &data->res.stateid, cmd, ret); in _nfs4_do_setlk()
7500 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_lock_reclaim()
7502 .inode = state->inode, in nfs4_lock_reclaim()
7508 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0) in nfs4_lock_reclaim()
7511 if (err != -NFS4ERR_DELAY) in nfs4_lock_reclaim()
7520 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_lock_expired()
7522 .inode = state->inode, in nfs4_lock_expired()
7530 set_bit(NFS_LOCK_LOST, &request->fl_u.nfs4_fl.owner->ls_flags); in nfs4_lock_expired()
7534 if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0) in nfs4_lock_expired()
7540 case -NFS4ERR_GRACE: in nfs4_lock_expired()
7541 case -NFS4ERR_DELAY: in nfs4_lock_expired()
7559 lsp = request->fl_u.nfs4_fl.owner; in nfs41_lock_expired()
7560 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) || in nfs41_lock_expired()
7561 test_bit(NFS_LOCK_LOST, &lsp->ls_flags)) in nfs41_lock_expired()
7569 struct nfs_inode *nfsi = NFS_I(state->inode); in _nfs4_proc_setlk()
7570 struct nfs4_state_owner *sp = state->owner; in _nfs4_proc_setlk()
7571 unsigned char flags = request->c.flc_flags; in _nfs4_proc_setlk()
7574 request->c.flc_flags |= FL_ACCESS; in _nfs4_proc_setlk()
7575 status = locks_lock_inode_wait(state->inode, request); in _nfs4_proc_setlk()
7578 mutex_lock(&sp->so_delegreturn_mutex); in _nfs4_proc_setlk()
7579 down_read(&nfsi->rwsem); in _nfs4_proc_setlk()
7580 if (test_bit(NFS_DELEGATED_STATE, &state->flags)) { in _nfs4_proc_setlk()
7583 request->c.flc_flags = flags & ~FL_SLEEP; in _nfs4_proc_setlk()
7584 status = locks_lock_inode_wait(state->inode, request); in _nfs4_proc_setlk()
7585 up_read(&nfsi->rwsem); in _nfs4_proc_setlk()
7586 mutex_unlock(&sp->so_delegreturn_mutex); in _nfs4_proc_setlk()
7589 up_read(&nfsi->rwsem); in _nfs4_proc_setlk()
7590 mutex_unlock(&sp->so_delegreturn_mutex); in _nfs4_proc_setlk()
7593 request->c.flc_flags = flags; in _nfs4_proc_setlk()
7601 .inode = state->inode, in nfs4_proc_setlk()
7608 if (err == -NFS4ERR_DENIED) in nfs4_proc_setlk()
7609 err = -EAGAIN; in nfs4_proc_setlk()
7610 err = nfs4_handle_exception(NFS_SERVER(state->inode), in nfs4_proc_setlk()
7623 int status = -ERESTARTSYS; in nfs4_retry_setlk_simple()
7628 if ((status != -EAGAIN) || IS_SETLK(cmd)) in nfs4_retry_setlk_simple()
7634 status = -ERESTARTSYS; in nfs4_retry_setlk_simple()
7655 struct nfs_lowner *lowner = &cbnl->cbnl_owner, in nfs4_wake_lock_waiter()
7656 *wowner = &waiter->owner; in nfs4_wake_lock_waiter()
7659 if (lowner->id != wowner->id || lowner->s_dev != wowner->s_dev) in nfs4_wake_lock_waiter()
7663 if (nfs_compare_fh(NFS_FH(waiter->inode), &cbnl->cbnl_fh)) in nfs4_wake_lock_waiter()
7673 struct nfs4_lock_state *lsp = request->fl_u.nfs4_fl.owner; in nfs4_retry_setlk()
7674 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_retry_setlk()
7675 struct nfs_client *clp = server->nfs_client; in nfs4_retry_setlk()
7676 wait_queue_head_t *q = &clp->cl_lock_waitq; in nfs4_retry_setlk()
7678 .inode = state->inode, in nfs4_retry_setlk()
7679 .owner = { .clientid = clp->cl_clientid, in nfs4_retry_setlk()
7680 .id = lsp->ls_seqid.owner_id, in nfs4_retry_setlk()
7681 .s_dev = server->s_dev }, in nfs4_retry_setlk()
7686 if (!test_bit(NFS_STATE_MAY_NOTIFY_LOCK, &state->flags)) in nfs4_retry_setlk()
7695 if (status != -EAGAIN || IS_SETLK(cmd)) in nfs4_retry_setlk()
7698 status = -ERESTARTSYS; in nfs4_retry_setlk()
7724 state = ctx->state; in nfs4_proc_lock()
7733 return -EINVAL; in nfs4_proc_lock()
7742 return -ENOLCK; in nfs4_proc_lock()
7744 if ((request->c.flc_flags & FL_POSIX) && in nfs4_proc_lock()
7745 !test_bit(NFS_STATE_POSIX_LOCKS, &state->flags)) in nfs4_proc_lock()
7746 return -ENOLCK; in nfs4_proc_lock()
7752 switch (request->c.flc_type) { in nfs4_proc_lock()
7754 if (!(filp->f_mode & FMODE_READ)) in nfs4_proc_lock()
7755 return -EBADF; in nfs4_proc_lock()
7758 if (!(filp->f_mode & FMODE_WRITE)) in nfs4_proc_lock()
7759 return -EBADF; in nfs4_proc_lock()
7783 return -EAGAIN; in nfs4_add_lease()
7789 return -EAGAIN; in nfs4_add_lease()
7802 return -EINVAL; in nfs4_proc_setlease()
7808 struct nfs_server *server = NFS_SERVER(state->inode); in nfs4_lock_delegation_recall()
7816 if (err != -NFS4ERR_DELAY) in nfs4_lock_delegation_recall()
7819 } while (err == -NFS4ERR_DELAY); in nfs4_lock_delegation_recall()
7834 struct nfs_server *server = data->server; in nfs4_release_lockowner_prepare()
7835 nfs4_setup_sequence(server->nfs_client, &data->args.seq_args, in nfs4_release_lockowner_prepare()
7836 &data->res.seq_res, task); in nfs4_release_lockowner_prepare()
7837 data->args.lock_owner.clientid = server->nfs_client->cl_clientid; in nfs4_release_lockowner_prepare()
7838 data->timestamp = jiffies; in nfs4_release_lockowner_prepare()
7844 struct nfs_server *server = data->server; in nfs4_release_lockowner_done()
7846 nfs40_sequence_done(task, &data->res.seq_res); in nfs4_release_lockowner_done()
7848 switch (task->tk_status) { in nfs4_release_lockowner_done()
7850 renew_lease(server, data->timestamp); in nfs4_release_lockowner_done()
7852 case -NFS4ERR_STALE_CLIENTID: in nfs4_release_lockowner_done()
7853 case -NFS4ERR_EXPIRED: in nfs4_release_lockowner_done()
7854 nfs4_schedule_lease_recovery(server->nfs_client); in nfs4_release_lockowner_done()
7856 case -NFS4ERR_LEASE_MOVED: in nfs4_release_lockowner_done()
7857 case -NFS4ERR_DELAY: in nfs4_release_lockowner_done()
7859 NULL, NULL) == -EAGAIN) in nfs4_release_lockowner_done()
7867 nfs4_free_lock_state(data->server, data->lsp); in nfs4_release_lockowner_release()
7885 if (server->nfs_client->cl_mvops->minor_version != 0) in nfs4_release_lockowner()
7891 data->lsp = lsp; in nfs4_release_lockowner()
7892 data->server = server; in nfs4_release_lockowner()
7893 data->args.lock_owner.clientid = server->nfs_client->cl_clientid; in nfs4_release_lockowner()
7894 data->args.lock_owner.id = lsp->ls_seqid.owner_id; in nfs4_release_lockowner()
7895 data->args.lock_owner.s_dev = server->s_dev; in nfs4_release_lockowner()
7897 msg.rpc_argp = &data->args; in nfs4_release_lockowner()
7898 msg.rpc_resp = &data->res; in nfs4_release_lockowner()
7899 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0, 0); in nfs4_release_lockowner()
7900 rpc_call_async(server->client, &msg, 0, &nfs4_release_lockowner_ops, data); in nfs4_release_lockowner()
7923 return nfs4_server_supports_acls(NFS_SB(dentry->d_sb), NFS4ACL_ACL); in nfs4_xattr_list_nfs4_acl()
7947 return nfs4_server_supports_acls(NFS_SB(dentry->d_sb), NFS4ACL_DACL); in nfs4_xattr_list_nfs4_dacl()
7970 return nfs4_server_supports_acls(NFS_SB(dentry->d_sb), NFS4ACL_SACL); in nfs4_xattr_list_nfs4_sacl()
7986 return -EOPNOTSUPP; in nfs4_xattr_set_nfs4_label()
7995 return -EOPNOTSUPP; in nfs4_xattr_get_nfs4_label()
8006 return -ERANGE; in nfs4_listxattr_nfs4_label()
8014 .set = nfs4_xattr_set_nfs4_label,
8038 return -EOPNOTSUPP; in nfs4_xattr_set_nfs4_user()
8051 return -EACCES; in nfs4_xattr_set_nfs4_user()
8075 return -EOPNOTSUPP; in nfs4_xattr_get_nfs4_user()
8079 return -EACCES; in nfs4_xattr_get_nfs4_user()
8087 if (ret >= 0 || (ret < 0 && ret != -ENOENT)) in nfs4_xattr_get_nfs4_user()
8118 if (ret >= 0 || (ret < 0 && ret != -ENOENT)) in nfs4_listxattr_nfs4_user()
8135 buflen -= ret; in nfs4_listxattr_nfs4_user()
8160 if (!(((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) || in nfs_fixup_referral_attributes()
8161 (fattr->valid & NFS_ATTR_FATTR_FILEID)) && in nfs_fixup_referral_attributes()
8162 (fattr->valid & NFS_ATTR_FATTR_FSID) && in nfs_fixup_referral_attributes()
8163 (fattr->valid & NFS_ATTR_FATTR_V4_LOCATIONS))) in nfs_fixup_referral_attributes()
8166 fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE | in nfs_fixup_referral_attributes()
8168 fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO; in nfs_fixup_referral_attributes()
8169 fattr->nlink = 2; in nfs_fixup_referral_attributes()
8202 if (NFS_SERVER(dir)->attr_bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID) in _nfs4_proc_fs_locations()
8207 nfs_fattr_init(fs_locations->fattr); in _nfs4_proc_fs_locations()
8208 fs_locations->server = server; in _nfs4_proc_fs_locations()
8209 fs_locations->nlocations = 0; in _nfs4_proc_fs_locations()
8246 struct rpc_clnt *clnt = server->client; in _nfs40_proc_get_locations()
8251 .clientid = server->nfs_client->cl_clientid, in _nfs40_proc_get_locations()
8272 nfs_fattr_init(locations->fattr); in _nfs40_proc_get_locations()
8273 locations->server = server; in _nfs40_proc_get_locations()
8274 locations->nlocations = 0; in _nfs40_proc_get_locations()
8303 struct rpc_clnt *clnt = server->client; in _nfs41_proc_get_locations()
8331 .callback_ops = server->nfs_client->cl_mvops->call_sync_ops, in _nfs41_proc_get_locations()
8337 nfs_fattr_init(locations->fattr); in _nfs41_proc_get_locations()
8338 locations->server = server; in _nfs41_proc_get_locations()
8339 locations->nlocations = 0; in _nfs41_proc_get_locations()
8345 status = -NFS4ERR_LEASE_MOVED; in _nfs41_proc_get_locations()
8352 * nfs4_proc_get_locations - discover locations for a migrated FSID
8366 * -NFS4ERR_LEASE_MOVED is returned if the server still has leases
8374 struct nfs_client *clp = server->nfs_client; in nfs4_proc_get_locations()
8376 clp->cl_mvops->mig_recovery_ops; in nfs4_proc_get_locations()
8383 (unsigned long long)server->fsid.major, in nfs4_proc_get_locations()
8384 (unsigned long long)server->fsid.minor, in nfs4_proc_get_locations()
8385 clp->cl_hostname); in nfs4_proc_get_locations()
8389 status = ops->get_locations(server, fhandle, locations, page, in nfs4_proc_get_locations()
8391 if (status != -NFS4ERR_DELAY) in nfs4_proc_get_locations()
8408 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client; in _nfs40_proc_fsid_present()
8409 struct rpc_clnt *clnt = server->client; in _nfs40_proc_fsid_present()
8412 .clientid = clp->cl_clientid, in _nfs40_proc_fsid_present()
8429 return -ENOMEM; in _nfs40_proc_fsid_present()
8454 struct rpc_clnt *clnt = server->client; in _nfs41_proc_fsid_present()
8470 return -ENOMEM; in _nfs41_proc_fsid_present()
8478 status = -NFS4ERR_LEASE_MOVED; in _nfs41_proc_fsid_present()
8485 * nfs4_proc_fsid_present - Is this FSID present or absent on server?
8494 * -NFS4ERR_MOVED if the FSID is no longer present, a negative
8501 struct nfs_client *clp = server->nfs_client; in nfs4_proc_fsid_present()
8503 clp->cl_mvops->mig_recovery_ops; in nfs4_proc_fsid_present()
8510 (unsigned long long)server->fsid.major, in nfs4_proc_fsid_present()
8511 (unsigned long long)server->fsid.minor, in nfs4_proc_fsid_present()
8512 clp->cl_hostname); in nfs4_proc_fsid_present()
8516 status = ops->fsid_present(inode, cred); in nfs4_proc_fsid_present()
8517 if (status != -NFS4ERR_DELAY) in nfs4_proc_fsid_present()
8534 struct rpc_clnt *clnt = NFS_SERVER(dir)->client; in _nfs4_proc_secinfo()
8535 struct nfs_client *clp = NFS_SERVER(dir)->nfs_client; in _nfs4_proc_secinfo()
8556 .callback_ops = clp->cl_mvops->call_sync_ops, in _nfs4_proc_secinfo()
8563 clnt = clp->cl_rpcclient; in _nfs4_proc_secinfo()
8570 dprintk("NFS call secinfo %s\n", name->name); in _nfs4_proc_secinfo()
8590 err = -NFS4ERR_WRONGSEC; in nfs4_proc_secinfo()
8593 if (_nfs4_is_integrity_protected(NFS_SERVER(dir)->nfs_client)) in nfs4_proc_secinfo()
8602 if (err == -NFS4ERR_WRONGSEC) in nfs4_proc_secinfo()
8615 * both PNFS and NON_PNFS flags set, and not having one of NON_PNFS, PNFS, or
8616 * DS flags set.
8631 return -NFS4ERR_INVAL; in nfs4_check_cl_exchange_flags()
8638 if (a->server_scope_sz != b->server_scope_sz) in nfs41_same_server_scope()
8640 return memcmp(a->server_scope, b->server_scope, a->server_scope_sz) == 0; in nfs41_same_server_scope()
8646 struct nfs41_bind_conn_to_session_args *args = task->tk_msg.rpc_argp; in nfs4_bind_one_conn_to_session_done()
8647 struct nfs41_bind_conn_to_session_res *res = task->tk_msg.rpc_resp; in nfs4_bind_one_conn_to_session_done()
8648 struct nfs_client *clp = args->client; in nfs4_bind_one_conn_to_session_done()
8650 switch (task->tk_status) { in nfs4_bind_one_conn_to_session_done()
8651 case -NFS4ERR_BADSESSION: in nfs4_bind_one_conn_to_session_done()
8652 case -NFS4ERR_DEADSESSION: in nfs4_bind_one_conn_to_session_done()
8653 nfs4_schedule_session_recovery(clp->cl_session, in nfs4_bind_one_conn_to_session_done()
8654 task->tk_status); in nfs4_bind_one_conn_to_session_done()
8657 if (args->dir == NFS4_CDFC4_FORE_OR_BOTH && in nfs4_bind_one_conn_to_session_done()
8658 res->dir != NFS4_CDFS4_BOTH) { in nfs4_bind_one_conn_to_session_done()
8660 if (args->retries++ < MAX_BIND_CONN_TO_SESSION_RETRIES) in nfs4_bind_one_conn_to_session_done()
8704 nfs4_copy_sessionid(&args.sessionid, &clp->cl_session->sess_id); in nfs4_proc_bind_one_conn_to_session()
8705 if (!(clp->cl_session->flags & SESSION4_BACK_CHAN)) in nfs4_proc_bind_one_conn_to_session()
8708 /* Do not set the backchannel flag unless this is clnt->cl_xprt */ in nfs4_proc_bind_one_conn_to_session()
8709 if (xprt != rcu_access_pointer(clnt->cl_xprt)) in nfs4_proc_bind_one_conn_to_session()
8714 status = task->tk_status; in nfs4_proc_bind_one_conn_to_session()
8721 clp->cl_session->sess_id.data, NFS4_MAX_SESSIONID_LEN)) { in nfs4_proc_bind_one_conn_to_session()
8723 return -EIO; in nfs4_proc_bind_one_conn_to_session()
8728 return -EIO; in nfs4_proc_bind_one_conn_to_session()
8733 return -EIO; in nfs4_proc_bind_one_conn_to_session()
8752 return nfs4_proc_bind_one_conn_to_session(clnt, xprt, p->clp, p->cred); in nfs4_proc_bind_conn_to_session_callback()
8761 return rpc_clnt_iterate_for_each_xprt(clp->cl_rpcclient, in nfs4_proc_bind_conn_to_session()
8766 * Minimum set of SP4_MACH_CRED operations from RFC 5661 in the enforce map
8772 [1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) |
8773 1 << (OP_EXCHANGE_ID - 32) |
8774 1 << (OP_CREATE_SESSION - 32) |
8775 1 << (OP_DESTROY_SESSION - 32) |
8776 1 << (OP_DESTROY_CLIENTID - 32)
8784 [1] = 1 << (OP_SECINFO - 32) |
8785 1 << (OP_SECINFO_NO_NAME - 32) |
8786 1 << (OP_LAYOUTRETURN - 32) |
8787 1 << (OP_TEST_STATEID - 32) |
8788 1 << (OP_FREE_STATEID - 32) |
8789 1 << (OP_WRITE - 32)
8803 [1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) | in nfs4_sp4_select_mode()
8804 1 << (OP_EXCHANGE_ID - 32) | in nfs4_sp4_select_mode()
8805 1 << (OP_CREATE_SESSION - 32) | in nfs4_sp4_select_mode()
8806 1 << (OP_DESTROY_SESSION - 32) | in nfs4_sp4_select_mode()
8807 1 << (OP_DESTROY_CLIENTID - 32) in nfs4_sp4_select_mode()
8813 if (sp->how == SP4_MACH_CRED) { in nfs4_sp4_select_mode()
8817 if (test_bit(i, sp->enforce.u.longs)) in nfs4_sp4_select_mode()
8819 if (test_bit(i, sp->allow.u.longs)) in nfs4_sp4_select_mode()
8825 if (sp->enforce.u.words[i] & ~supported_enforce[i]) { in nfs4_sp4_select_mode()
8827 ret = -EINVAL; in nfs4_sp4_select_mode()
8833 * Minimal mode - state operations are allowed to use machine in nfs4_sp4_select_mode()
8837 * NOTE: we don't care if EXCHANGE_ID is in the list - in nfs4_sp4_select_mode()
8841 if (test_bit(OP_BIND_CONN_TO_SESSION, sp->enforce.u.longs) && in nfs4_sp4_select_mode()
8842 test_bit(OP_CREATE_SESSION, sp->enforce.u.longs) && in nfs4_sp4_select_mode()
8843 test_bit(OP_DESTROY_SESSION, sp->enforce.u.longs) && in nfs4_sp4_select_mode()
8844 test_bit(OP_DESTROY_CLIENTID, sp->enforce.u.longs)) { in nfs4_sp4_select_mode()
8850 ret = -EINVAL; in nfs4_sp4_select_mode()
8854 if (test_bit(OP_CLOSE, sp->allow.u.longs) && in nfs4_sp4_select_mode()
8855 test_bit(OP_OPEN_DOWNGRADE, sp->allow.u.longs) && in nfs4_sp4_select_mode()
8856 test_bit(OP_DELEGRETURN, sp->allow.u.longs) && in nfs4_sp4_select_mode()
8857 test_bit(OP_LOCKU, sp->allow.u.longs)) { in nfs4_sp4_select_mode()
8862 if (test_bit(OP_LAYOUTRETURN, sp->allow.u.longs)) { in nfs4_sp4_select_mode()
8867 if (test_bit(OP_SECINFO, sp->allow.u.longs) && in nfs4_sp4_select_mode()
8868 test_bit(OP_SECINFO_NO_NAME, sp->allow.u.longs)) { in nfs4_sp4_select_mode()
8873 if (test_bit(OP_TEST_STATEID, sp->allow.u.longs) && in nfs4_sp4_select_mode()
8874 test_bit(OP_FREE_STATEID, sp->allow.u.longs)) { in nfs4_sp4_select_mode()
8879 if (test_bit(OP_WRITE, sp->allow.u.longs)) { in nfs4_sp4_select_mode()
8884 if (test_bit(OP_COMMIT, sp->allow.u.longs)) { in nfs4_sp4_select_mode()
8890 clp->cl_sp4_flags = flags; in nfs4_sp4_select_mode()
8904 nfs_put_client(cdata->args.client); in nfs4_exchange_id_release()
8905 kfree(cdata->res.impl_id); in nfs4_exchange_id_release()
8906 kfree(cdata->res.server_scope); in nfs4_exchange_id_release()
8907 kfree(cdata->res.server_owner); in nfs4_exchange_id_release()
8929 .rpc_client = clp->cl_rpcclient, in nfs4_run_exchange_id()
8937 if (!refcount_inc_not_zero(&clp->cl_count)) in nfs4_run_exchange_id()
8938 return ERR_PTR(-EIO); in nfs4_run_exchange_id()
8940 status = -ENOMEM; in nfs4_run_exchange_id()
8945 nfs4_init_boot_verifier(clp, &calldata->args.verifier); in nfs4_run_exchange_id()
8951 calldata->res.server_owner = kzalloc(sizeof(struct nfs41_server_owner), in nfs4_run_exchange_id()
8953 status = -ENOMEM; in nfs4_run_exchange_id()
8954 if (unlikely(calldata->res.server_owner == NULL)) in nfs4_run_exchange_id()
8957 calldata->res.server_scope = kzalloc(sizeof(struct nfs41_server_scope), in nfs4_run_exchange_id()
8959 if (unlikely(calldata->res.server_scope == NULL)) in nfs4_run_exchange_id()
8962 calldata->res.impl_id = kzalloc(sizeof(struct nfs41_impl_id), GFP_NOFS); in nfs4_run_exchange_id()
8963 if (unlikely(calldata->res.impl_id == NULL)) in nfs4_run_exchange_id()
8968 calldata->args.state_protect.how = SP4_NONE; in nfs4_run_exchange_id()
8972 calldata->args.state_protect = nfs4_sp4_mach_cred_request; in nfs4_run_exchange_id()
8978 status = -EINVAL; in nfs4_run_exchange_id()
8984 memcpy(calldata->args.verifier.data, clp->cl_confirm.data, in nfs4_run_exchange_id()
8985 sizeof(calldata->args.verifier.data)); in nfs4_run_exchange_id()
8987 calldata->args.client = clp; in nfs4_run_exchange_id()
8988 calldata->args.flags = EXCHGID4_FLAG_SUPP_MOVED_REFER | in nfs4_run_exchange_id()
8991 calldata->args.flags |= EXCHGID4_FLAG_SUPP_MOVED_MIGR; in nfs4_run_exchange_id()
8993 if (test_bit(NFS_CS_PNFS, &clp->cl_flags)) in nfs4_run_exchange_id()
8994 calldata->args.flags |= EXCHGID4_FLAG_USE_PNFS_DS; in nfs4_run_exchange_id()
8995 msg.rpc_argp = &calldata->args; in nfs4_run_exchange_id()
8996 msg.rpc_resp = &calldata->res; in nfs4_run_exchange_id()
9002 kfree(calldata->res.impl_id); in nfs4_run_exchange_id()
9004 kfree(calldata->res.server_scope); in nfs4_run_exchange_id()
9006 kfree(calldata->res.server_owner); in nfs4_run_exchange_id()
9032 argp = task->tk_msg.rpc_argp; in _nfs4_proc_exchange_id()
9033 resp = task->tk_msg.rpc_resp; in _nfs4_proc_exchange_id()
9034 status = task->tk_status; in _nfs4_proc_exchange_id()
9038 status = nfs4_check_cl_exchange_flags(resp->flags, in _nfs4_proc_exchange_id()
9039 clp->cl_mvops->minor_version); in _nfs4_proc_exchange_id()
9043 status = nfs4_sp4_select_mode(clp, &resp->state_protect); in _nfs4_proc_exchange_id()
9049 clp->cl_clientid = resp->clientid; in _nfs4_proc_exchange_id()
9050 clp->cl_exchange_flags = resp->flags; in _nfs4_proc_exchange_id()
9051 clp->cl_seqid = resp->seqid; in _nfs4_proc_exchange_id()
9053 if (!(resp->flags & EXCHGID4_FLAG_CONFIRMED_R)) in _nfs4_proc_exchange_id()
9055 &clp->cl_session->session_state); in _nfs4_proc_exchange_id()
9057 if (clp->cl_serverscope != NULL && in _nfs4_proc_exchange_id()
9058 !nfs41_same_server_scope(clp->cl_serverscope, in _nfs4_proc_exchange_id()
9059 resp->server_scope)) { in _nfs4_proc_exchange_id()
9062 set_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state); in _nfs4_proc_exchange_id()
9065 swap(clp->cl_serverowner, resp->server_owner); in _nfs4_proc_exchange_id()
9066 swap(clp->cl_serverscope, resp->server_scope); in _nfs4_proc_exchange_id()
9067 swap(clp->cl_implid, resp->impl_id); in _nfs4_proc_exchange_id()
9070 memcpy(clp->cl_confirm.data, argp->verifier.data, in _nfs4_proc_exchange_id()
9071 sizeof(clp->cl_confirm.data)); in _nfs4_proc_exchange_id()
9092 rpc_authflavor_t authflavor = clp->cl_rpcclient->cl_auth->au_flavor; in nfs4_proc_exchange_id()
9131 dprintk("--> %s try %s\n", __func__, in nfs4_test_session_trunk()
9132 xprt->address_strings[RPC_DISPLAY_ADDR]); in nfs4_test_session_trunk()
9134 sp4_how = (adata->clp->cl_sp4_flags == 0 ? SP4_NONE : SP4_MACH_CRED); in nfs4_test_session_trunk()
9138 task = nfs4_run_exchange_id(adata->clp, adata->cred, sp4_how, xprt); in nfs4_test_session_trunk()
9142 status = task->tk_status; in nfs4_test_session_trunk()
9144 status = nfs4_detect_session_trunking(adata->clp, in nfs4_test_session_trunk()
9145 task->tk_msg.rpc_resp, xprt); in nfs4_test_session_trunk()
9146 trace_nfs4_trunked_exchange_id(adata->clp, in nfs4_test_session_trunk()
9147 xprt->address_strings[RPC_DISPLAY_ADDR], status); in nfs4_test_session_trunk()
9151 else if (status != -NFS4ERR_DELAY && rpc_clnt_xprt_switch_has_addr(clnt, in nfs4_test_session_trunk()
9152 (struct sockaddr *)&xprt->addr)) in nfs4_test_session_trunk()
9156 if (status == -NFS4ERR_DELAY) { in nfs4_test_session_trunk()
9173 status = rpc_call_sync(clp->cl_rpcclient, &msg, in _nfs4_proc_destroy_clientid()
9178 "DESTROY_CLIENTID.", status, clp->cl_hostname); in _nfs4_proc_destroy_clientid()
9188 for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) { in nfs4_proc_destroy_clientid()
9191 case -NFS4ERR_DELAY: in nfs4_proc_destroy_clientid()
9192 case -NFS4ERR_CLIENTID_BUSY: in nfs4_proc_destroy_clientid()
9207 if (clp->cl_mvops->minor_version < 1) in nfs4_destroy_clientid()
9209 if (clp->cl_exchange_flags == 0) in nfs4_destroy_clientid()
9211 if (clp->cl_preserve_clid) in nfs4_destroy_clientid()
9218 case -NFS4ERR_STALE_CLIENTID: in nfs4_destroy_clientid()
9219 clp->cl_exchange_flags = 0; in nfs4_destroy_clientid()
9241 nfs4_setup_sequence(data->clp, in nfs4_get_lease_time_prepare()
9242 &data->args->la_seq_args, in nfs4_get_lease_time_prepare()
9243 &data->res->lr_seq_res, in nfs4_get_lease_time_prepare()
9256 if (!nfs4_sequence_done(task, &data->res->lr_seq_res)) in nfs4_get_lease_time_done()
9258 switch (task->tk_status) { in nfs4_get_lease_time_done()
9259 case -NFS4ERR_DELAY: in nfs4_get_lease_time_done()
9260 case -NFS4ERR_GRACE: in nfs4_get_lease_time_done()
9262 task->tk_status = 0; in nfs4_get_lease_time_done()
9264 case -NFS4ERR_RETRY_UNCACHED_REP: in nfs4_get_lease_time_done()
9292 .rpc_client = clp->cl_rpcclient, in nfs4_proc_get_lease_time()
9307 * If nfs4_init_session set the fore channel request and response sizes,
9310 * Set the back channel max_resp_sz_cached to zero to force the client to
9311 * always set csa_cachethis to FALSE because the current implementation
9325 args->fc_attrs.max_rqst_sz = max_rqst_sz; in nfs4_init_channel_attrs()
9326 args->fc_attrs.max_resp_sz = max_resp_sz; in nfs4_init_channel_attrs()
9327 args->fc_attrs.max_ops = NFS4_MAX_OPS; in nfs4_init_channel_attrs()
9328 args->fc_attrs.max_reqs = max_session_slots; in nfs4_init_channel_attrs()
9333 args->fc_attrs.max_rqst_sz, args->fc_attrs.max_resp_sz, in nfs4_init_channel_attrs()
9334 args->fc_attrs.max_ops, args->fc_attrs.max_reqs); in nfs4_init_channel_attrs()
9337 args->bc_attrs.max_rqst_sz = max_bc_payload; in nfs4_init_channel_attrs()
9338 args->bc_attrs.max_resp_sz = max_bc_payload; in nfs4_init_channel_attrs()
9339 args->bc_attrs.max_resp_sz_cached = 0; in nfs4_init_channel_attrs()
9340 args->bc_attrs.max_ops = NFS4_MAX_BACK_CHANNEL_OPS; in nfs4_init_channel_attrs()
9341 args->bc_attrs.max_reqs = max_t(unsigned short, max_session_cb_slots, 1); in nfs4_init_channel_attrs()
9342 if (args->bc_attrs.max_reqs > max_bc_slots) in nfs4_init_channel_attrs()
9343 args->bc_attrs.max_reqs = max_bc_slots; in nfs4_init_channel_attrs()
9348 args->bc_attrs.max_rqst_sz, args->bc_attrs.max_resp_sz, in nfs4_init_channel_attrs()
9349 args->bc_attrs.max_resp_sz_cached, args->bc_attrs.max_ops, in nfs4_init_channel_attrs()
9350 args->bc_attrs.max_reqs); in nfs4_init_channel_attrs()
9356 struct nfs4_channel_attrs *sent = &args->fc_attrs; in nfs4_verify_fore_channel_attrs()
9357 struct nfs4_channel_attrs *rcvd = &res->fc_attrs; in nfs4_verify_fore_channel_attrs()
9359 if (rcvd->max_resp_sz > sent->max_resp_sz) in nfs4_verify_fore_channel_attrs()
9360 return -EINVAL; in nfs4_verify_fore_channel_attrs()
9367 if (rcvd->max_ops < sent->max_ops) in nfs4_verify_fore_channel_attrs()
9368 return -EINVAL; in nfs4_verify_fore_channel_attrs()
9369 if (rcvd->max_reqs == 0) in nfs4_verify_fore_channel_attrs()
9370 return -EINVAL; in nfs4_verify_fore_channel_attrs()
9371 if (rcvd->max_reqs > NFS4_MAX_SLOT_TABLE) in nfs4_verify_fore_channel_attrs()
9372 rcvd->max_reqs = NFS4_MAX_SLOT_TABLE; in nfs4_verify_fore_channel_attrs()
9379 struct nfs4_channel_attrs *sent = &args->bc_attrs; in nfs4_verify_back_channel_attrs()
9380 struct nfs4_channel_attrs *rcvd = &res->bc_attrs; in nfs4_verify_back_channel_attrs()
9382 if (!(res->flags & SESSION4_BACK_CHAN)) in nfs4_verify_back_channel_attrs()
9384 if (rcvd->max_rqst_sz > sent->max_rqst_sz) in nfs4_verify_back_channel_attrs()
9385 return -EINVAL; in nfs4_verify_back_channel_attrs()
9386 if (rcvd->max_resp_sz < sent->max_resp_sz) in nfs4_verify_back_channel_attrs()
9387 return -EINVAL; in nfs4_verify_back_channel_attrs()
9388 if (rcvd->max_resp_sz_cached > sent->max_resp_sz_cached) in nfs4_verify_back_channel_attrs()
9389 return -EINVAL; in nfs4_verify_back_channel_attrs()
9390 if (rcvd->max_ops > sent->max_ops) in nfs4_verify_back_channel_attrs()
9391 return -EINVAL; in nfs4_verify_back_channel_attrs()
9392 if (rcvd->max_reqs > sent->max_reqs) in nfs4_verify_back_channel_attrs()
9393 return -EINVAL; in nfs4_verify_back_channel_attrs()
9412 nfs4_copy_sessionid(&session->sess_id, &res->sessionid); in nfs4_update_session()
9414 session->clp->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R; in nfs4_update_session()
9415 set_bit(NFS4_SESSION_ESTABLISHED, &session->session_state); in nfs4_update_session()
9416 session->flags = res->flags; in nfs4_update_session()
9417 memcpy(&session->fc_attrs, &res->fc_attrs, sizeof(session->fc_attrs)); in nfs4_update_session()
9418 if (res->flags & SESSION4_BACK_CHAN) in nfs4_update_session()
9419 memcpy(&session->bc_attrs, &res->bc_attrs, in nfs4_update_session()
9420 sizeof(session->bc_attrs)); in nfs4_update_session()
9426 struct nfs4_session *session = clp->cl_session; in _nfs4_proc_create_session()
9429 .clientid = clp->cl_clientid, in _nfs4_proc_create_session()
9430 .seqid = clp->cl_seqid, in _nfs4_proc_create_session()
9443 nfs4_init_channel_attrs(&args, clp->cl_rpcclient); in _nfs4_proc_create_session()
9446 status = rpc_call_sync(session->clp->cl_rpcclient, &msg, in _nfs4_proc_create_session()
9451 case -NFS4ERR_STALE_CLIENTID: in _nfs4_proc_create_session()
9452 case -NFS4ERR_DELAY: in _nfs4_proc_create_session()
9453 case -ETIMEDOUT: in _nfs4_proc_create_session()
9454 case -EACCES: in _nfs4_proc_create_session()
9455 case -EAGAIN: in _nfs4_proc_create_session()
9459 clp->cl_seqid++; in _nfs4_proc_create_session()
9481 struct nfs4_session *session = clp->cl_session; in nfs4_proc_create_session()
9486 .add_xprt_test = clp->cl_mvops->session_trunk, in nfs4_proc_create_session()
9490 dprintk("--> %s clp=%p session=%p\n", __func__, clp, session); in nfs4_proc_create_session()
9502 ptr = (unsigned *)&session->sess_id.data[0]; in nfs4_proc_create_session()
9504 clp->cl_seqid, ptr[0], ptr[1], ptr[2], ptr[3]); in nfs4_proc_create_session()
9505 rpc_clnt_probe_trunked_xprts(clp->cl_rpcclient, &rpcdata); in nfs4_proc_create_session()
9511 * Issue the over-the-wire RPC DESTROY_SESSION.
9525 if (!test_and_clear_bit(NFS4_SESSION_ESTABLISHED, &session->session_state)) in nfs4_proc_destroy_session()
9528 status = rpc_call_sync(session->clp->cl_rpcclient, &msg, in nfs4_proc_destroy_session()
9530 trace_nfs4_destroy_session(session->clp, status); in nfs4_proc_destroy_session()
9535 rpc_clnt_manage_trunked_xprts(session->clp->cl_rpcclient); in nfs4_proc_destroy_session()
9551 struct nfs_client *clp = calldata->clp; in nfs41_sequence_release()
9553 if (refcount_read(&clp->cl_count) > 1) in nfs41_sequence_release()
9561 switch(task->tk_status) { in nfs41_sequence_handle_errors()
9562 case -NFS4ERR_DELAY: in nfs41_sequence_handle_errors()
9564 return -EAGAIN; in nfs41_sequence_handle_errors()
9574 struct nfs_client *clp = calldata->clp; in nfs41_sequence_call_done()
9576 if (!nfs41_sequence_done(task, task->tk_msg.rpc_resp)) in nfs41_sequence_call_done()
9579 trace_nfs4_sequence(clp, task->tk_status); in nfs41_sequence_call_done()
9580 if (task->tk_status < 0 && !task->tk_client->cl_shutdown) { in nfs41_sequence_call_done()
9581 dprintk("%s ERROR %d\n", __func__, task->tk_status); in nfs41_sequence_call_done()
9582 if (refcount_read(&clp->cl_count) == 1) in nfs41_sequence_call_done()
9585 if (nfs41_sequence_handle_errors(task, clp) == -EAGAIN) { in nfs41_sequence_call_done()
9590 dprintk("%s rpc_cred %p\n", __func__, task->tk_msg.rpc_cred); in nfs41_sequence_call_done()
9596 struct nfs_client *clp = calldata->clp; in nfs41_sequence_prepare()
9600 args = task->tk_msg.rpc_argp; in nfs41_sequence_prepare()
9601 res = task->tk_msg.rpc_resp; in nfs41_sequence_prepare()
9623 .rpc_client = clp->cl_rpcclient, in _nfs41_proc_sequence()
9630 ret = ERR_PTR(-EIO); in _nfs41_proc_sequence()
9631 if (!refcount_inc_not_zero(&clp->cl_count)) in _nfs41_proc_sequence()
9634 ret = ERR_PTR(-ENOMEM); in _nfs41_proc_sequence()
9638 nfs4_init_sequence(&calldata->args, &calldata->res, 0, is_privileged); in _nfs41_proc_sequence()
9639 nfs4_sequence_attach_slot(&calldata->args, &calldata->res, slot); in _nfs41_proc_sequence()
9640 msg.rpc_argp = &calldata->args; in _nfs41_proc_sequence()
9641 msg.rpc_resp = &calldata->res; in _nfs41_proc_sequence()
9642 calldata->clp = clp; in _nfs41_proc_sequence()
9662 return -EAGAIN; in nfs41_proc_async_sequence()
9668 dprintk("<-- %s status=%d\n", __func__, ret); in nfs41_proc_async_sequence()
9684 ret = task->tk_status; in nfs4_proc_sequence()
9687 dprintk("<-- %s status=%d\n", __func__, ret); in nfs4_proc_sequence()
9701 nfs4_setup_sequence(calldata->clp, in nfs4_reclaim_complete_prepare()
9702 &calldata->arg.seq_args, in nfs4_reclaim_complete_prepare()
9703 &calldata->res.seq_res, in nfs4_reclaim_complete_prepare()
9709 switch(task->tk_status) { in nfs41_reclaim_complete_handle_errors()
9711 wake_up_all(&clp->cl_lock_waitq); in nfs41_reclaim_complete_handle_errors()
9713 case -NFS4ERR_COMPLETE_ALREADY: in nfs41_reclaim_complete_handle_errors()
9714 case -NFS4ERR_WRONG_CRED: /* What to do here? */ in nfs41_reclaim_complete_handle_errors()
9716 case -NFS4ERR_DELAY: in nfs41_reclaim_complete_handle_errors()
9719 case -NFS4ERR_RETRY_UNCACHED_REP: in nfs41_reclaim_complete_handle_errors()
9720 case -EACCES: in nfs41_reclaim_complete_handle_errors()
9722 __func__, task->tk_status, clp->cl_hostname); in nfs41_reclaim_complete_handle_errors()
9723 return -EAGAIN; in nfs41_reclaim_complete_handle_errors()
9724 case -NFS4ERR_BADSESSION: in nfs41_reclaim_complete_handle_errors()
9725 case -NFS4ERR_DEADSESSION: in nfs41_reclaim_complete_handle_errors()
9726 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: in nfs41_reclaim_complete_handle_errors()
9737 struct nfs_client *clp = calldata->clp; in nfs4_reclaim_complete_done()
9738 struct nfs4_sequence_res *res = &calldata->res.seq_res; in nfs4_reclaim_complete_done()
9743 trace_nfs4_reclaim_complete(clp, task->tk_status); in nfs4_reclaim_complete_done()
9744 if (nfs41_reclaim_complete_handle_errors(task, clp) == -EAGAIN) { in nfs4_reclaim_complete_done()
9775 .rpc_client = clp->cl_rpcclient, in nfs41_proc_reclaim_complete()
9780 int status = -ENOMEM; in nfs41_proc_reclaim_complete()
9785 calldata->clp = clp; in nfs41_proc_reclaim_complete()
9786 calldata->arg.one_fs = 0; in nfs41_proc_reclaim_complete()
9788 nfs4_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 0, 1); in nfs41_proc_reclaim_complete()
9789 msg.rpc_argp = &calldata->arg; in nfs41_proc_reclaim_complete()
9790 msg.rpc_resp = &calldata->res; in nfs41_proc_reclaim_complete()
9794 dprintk("<-- %s status=%d\n", __func__, status); in nfs41_proc_reclaim_complete()
9802 struct nfs_server *server = NFS_SERVER(lgp->args.inode); in nfs4_layoutget_prepare()
9804 nfs4_setup_sequence(server->nfs_client, &lgp->args.seq_args, in nfs4_layoutget_prepare()
9805 &lgp->res.seq_res, task); in nfs4_layoutget_prepare()
9812 nfs41_sequence_process(task, &lgp->res.seq_res); in nfs4_layoutget_done()
9819 struct inode *inode = lgp->args.inode; in nfs4_layoutget_handle_exception()
9821 struct pnfs_layout_hdr *lo = lgp->lo; in nfs4_layoutget_handle_exception()
9822 int nfs4err = task->tk_status; in nfs4_layoutget_handle_exception()
9826 dprintk("--> %s tk_status => %d\n", __func__, -task->tk_status); in nfs4_layoutget_handle_exception()
9828 nfs4_sequence_free_slot(&lgp->res.seq_res); in nfs4_layoutget_handle_exception()
9830 exception->state = NULL; in nfs4_layoutget_handle_exception()
9831 exception->stateid = NULL; in nfs4_layoutget_handle_exception()
9839 * on the file. set tk_status to -ENODATA to tell upper layer to in nfs4_layoutget_handle_exception()
9842 case -NFS4ERR_LAYOUTUNAVAILABLE: in nfs4_layoutget_handle_exception()
9843 status = -ENODATA; in nfs4_layoutget_handle_exception()
9847 * length lgp->args.minlength != 0 (see RFC5661 section 18.43.3). in nfs4_layoutget_handle_exception()
9849 case -NFS4ERR_BADLAYOUT: in nfs4_layoutget_handle_exception()
9850 status = -EOVERFLOW; in nfs4_layoutget_handle_exception()
9857 * Treat it like we would RECALLCONFLICT -- we retry for a little in nfs4_layoutget_handle_exception()
9860 case -NFS4ERR_LAYOUTTRYLATER: in nfs4_layoutget_handle_exception()
9861 if (lgp->args.minlength == 0) { in nfs4_layoutget_handle_exception()
9862 status = -EOVERFLOW; in nfs4_layoutget_handle_exception()
9865 status = -EBUSY; in nfs4_layoutget_handle_exception()
9867 case -NFS4ERR_RECALLCONFLICT: in nfs4_layoutget_handle_exception()
9868 case -NFS4ERR_RETURNCONFLICT: in nfs4_layoutget_handle_exception()
9869 status = -ERECALLCONFLICT; in nfs4_layoutget_handle_exception()
9871 case -NFS4ERR_DELEG_REVOKED: in nfs4_layoutget_handle_exception()
9872 case -NFS4ERR_ADMIN_REVOKED: in nfs4_layoutget_handle_exception()
9873 case -NFS4ERR_EXPIRED: in nfs4_layoutget_handle_exception()
9874 case -NFS4ERR_BAD_STATEID: in nfs4_layoutget_handle_exception()
9875 exception->timeout = 0; in nfs4_layoutget_handle_exception()
9876 spin_lock(&inode->i_lock); in nfs4_layoutget_handle_exception()
9878 if (!lo || test_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags) || in nfs4_layoutget_handle_exception()
9879 !nfs4_stateid_match_other(&lgp->args.stateid, &lo->plh_stateid)) { in nfs4_layoutget_handle_exception()
9880 spin_unlock(&inode->i_lock); in nfs4_layoutget_handle_exception()
9881 exception->state = lgp->args.ctx->state; in nfs4_layoutget_handle_exception()
9882 exception->stateid = &lgp->args.stateid; in nfs4_layoutget_handle_exception()
9890 spin_unlock(&inode->i_lock); in nfs4_layoutget_handle_exception()
9893 status = -EAGAIN; in nfs4_layoutget_handle_exception()
9899 if (exception->retry) in nfs4_layoutget_handle_exception()
9900 status = -EAGAIN; in nfs4_layoutget_handle_exception()
9910 u32 max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz; in max_response_pages()
9918 nfs4_sequence_free_slot(&lgp->res.seq_res); in nfs4_layoutget_release()
9932 struct inode *inode = lgp->args.inode; in nfs4_proc_layoutget()
9937 .rpc_argp = &lgp->args, in nfs4_proc_layoutget()
9938 .rpc_resp = &lgp->res, in nfs4_proc_layoutget()
9939 .rpc_cred = lgp->cred, in nfs4_proc_layoutget()
9942 .rpc_client = server->client, in nfs4_proc_layoutget()
9952 nfs4_init_sequence(&lgp->args.seq_args, &lgp->res.seq_res, 0, 0); in nfs4_proc_layoutget()
9953 exception->retry = 0; in nfs4_proc_layoutget()
9963 if (task->tk_status < 0) { in nfs4_proc_layoutget()
9964 exception->retry = 1; in nfs4_proc_layoutget()
9966 } else if (lgp->res.layoutp->len == 0) { in nfs4_proc_layoutget()
9967 exception->retry = 1; in nfs4_proc_layoutget()
9968 status = -EAGAIN; in nfs4_proc_layoutget()
9969 nfs4_update_delay(&exception->timeout); in nfs4_proc_layoutget()
9973 trace_nfs4_layoutget(lgp->args.ctx, in nfs4_proc_layoutget()
9974 &lgp->args.range, in nfs4_proc_layoutget()
9975 &lgp->res.range, in nfs4_proc_layoutget()
9976 &lgp->res.stateid, in nfs4_proc_layoutget()
9980 dprintk("<-- %s status=%d\n", __func__, status); in nfs4_proc_layoutget()
9991 nfs4_setup_sequence(lrp->clp, in nfs4_layoutreturn_prepare()
9992 &lrp->args.seq_args, in nfs4_layoutreturn_prepare()
9993 &lrp->res.seq_res, in nfs4_layoutreturn_prepare()
9995 if (!pnfs_layout_is_valid(lrp->args.layout)) in nfs4_layoutreturn_prepare()
10004 if (!nfs41_sequence_process(task, &lrp->res.seq_res)) in nfs4_layoutreturn_done()
10007 if (task->tk_rpc_status == -ETIMEDOUT) { in nfs4_layoutreturn_done()
10008 lrp->rpc_status = -EAGAIN; in nfs4_layoutreturn_done()
10009 lrp->res.lrs_present = 0; in nfs4_layoutreturn_done()
10016 if (task->tk_rpc_status != 0 && RPC_WAS_SENT(task)) { in nfs4_layoutreturn_done()
10017 lrp->res.lrs_present = 0; in nfs4_layoutreturn_done()
10021 server = NFS_SERVER(lrp->args.inode); in nfs4_layoutreturn_done()
10022 switch (task->tk_status) { in nfs4_layoutreturn_done()
10023 case -NFS4ERR_OLD_STATEID: in nfs4_layoutreturn_done()
10024 if (nfs4_layout_refresh_old_stateid(&lrp->args.stateid, in nfs4_layoutreturn_done()
10025 &lrp->args.range, in nfs4_layoutreturn_done()
10026 lrp->args.inode)) in nfs4_layoutreturn_done()
10030 task->tk_status = 0; in nfs4_layoutreturn_done()
10031 lrp->res.lrs_present = 0; in nfs4_layoutreturn_done()
10035 case -NFS4ERR_BADSESSION: in nfs4_layoutreturn_done()
10036 case -NFS4ERR_DEADSESSION: in nfs4_layoutreturn_done()
10037 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: in nfs4_layoutreturn_done()
10038 nfs4_schedule_session_recovery(server->nfs_client->cl_session, in nfs4_layoutreturn_done()
10039 task->tk_status); in nfs4_layoutreturn_done()
10040 lrp->res.lrs_present = 0; in nfs4_layoutreturn_done()
10041 lrp->rpc_status = -EAGAIN; in nfs4_layoutreturn_done()
10042 task->tk_status = 0; in nfs4_layoutreturn_done()
10044 case -NFS4ERR_DELAY: in nfs4_layoutreturn_done()
10046 -EAGAIN) in nfs4_layoutreturn_done()
10048 lrp->res.lrs_present = 0; in nfs4_layoutreturn_done()
10053 task->tk_status = 0; in nfs4_layoutreturn_done()
10054 nfs4_sequence_free_slot(&lrp->res.seq_res); in nfs4_layoutreturn_done()
10061 struct pnfs_layout_hdr *lo = lrp->args.layout; in nfs4_layoutreturn_release()
10063 if (lrp->rpc_status == 0 || !lrp->inode) in nfs4_layoutreturn_release()
10065 lo, &lrp->args.stateid, &lrp->args.range, in nfs4_layoutreturn_release()
10066 lrp->res.lrs_present ? &lrp->res.stateid : NULL); in nfs4_layoutreturn_release()
10068 pnfs_layoutreturn_retry_later(lo, &lrp->args.stateid, in nfs4_layoutreturn_release()
10069 &lrp->args.range); in nfs4_layoutreturn_release()
10070 nfs4_sequence_free_slot(&lrp->res.seq_res); in nfs4_layoutreturn_release()
10071 if (lrp->ld_private.ops && lrp->ld_private.ops->free) in nfs4_layoutreturn_release()
10072 lrp->ld_private.ops->free(&lrp->ld_private); in nfs4_layoutreturn_release()
10073 pnfs_put_layout_hdr(lrp->args.layout); in nfs4_layoutreturn_release()
10074 nfs_iput_and_deactive(lrp->inode); in nfs4_layoutreturn_release()
10075 put_cred(lrp->cred); in nfs4_layoutreturn_release()
10090 .rpc_argp = &lrp->args, in nfs4_proc_layoutreturn()
10091 .rpc_resp = &lrp->res, in nfs4_proc_layoutreturn()
10092 .rpc_cred = lrp->cred, in nfs4_proc_layoutreturn()
10095 .rpc_client = NFS_SERVER(lrp->args.inode)->client, in nfs4_proc_layoutreturn()
10103 nfs4_state_protect(NFS_SERVER(lrp->args.inode)->nfs_client, in nfs4_proc_layoutreturn()
10107 lrp->inode = nfs_igrab_and_active(lrp->args.inode); in nfs4_proc_layoutreturn()
10109 if (!lrp->inode) { in nfs4_proc_layoutreturn()
10111 return -EAGAIN; in nfs4_proc_layoutreturn()
10115 if (!lrp->inode) in nfs4_proc_layoutreturn()
10118 nfs4_init_sequence(&lrp->args.seq_args, &lrp->res.seq_res, 1, in nfs4_proc_layoutreturn()
10121 nfs4_init_sequence(&lrp->args.seq_args, &lrp->res.seq_res, 1, in nfs4_proc_layoutreturn()
10127 status = task->tk_status; in nfs4_proc_layoutreturn()
10128 trace_nfs4_layoutreturn(lrp->args.inode, &lrp->args.stateid, status); in nfs4_proc_layoutreturn()
10129 dprintk("<-- %s status=%d\n", __func__, status); in nfs4_proc_layoutreturn()
10155 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0); in _nfs4_proc_getdeviceinfo()
10159 pdev->nocache = 1; in _nfs4_proc_getdeviceinfo()
10161 trace_nfs4_getdeviceinfo(server, &pdev->dev_id, status); in _nfs4_proc_getdeviceinfo()
10163 dprintk("<-- %s status=%d\n", __func__, status); in _nfs4_proc_getdeviceinfo()
10187 struct nfs_server *server = NFS_SERVER(data->args.inode); in nfs4_layoutcommit_prepare()
10189 nfs4_setup_sequence(server->nfs_client, in nfs4_layoutcommit_prepare()
10190 &data->args.seq_args, in nfs4_layoutcommit_prepare()
10191 &data->res.seq_res, in nfs4_layoutcommit_prepare()
10199 struct nfs_server *server = NFS_SERVER(data->args.inode); in nfs4_layoutcommit_done()
10201 if (!nfs41_sequence_done(task, &data->res.seq_res)) in nfs4_layoutcommit_done()
10204 switch (task->tk_status) { /* Just ignore these failures */ in nfs4_layoutcommit_done()
10205 case -NFS4ERR_DELEG_REVOKED: /* layout was recalled */ in nfs4_layoutcommit_done()
10206 case -NFS4ERR_BADIOMODE: /* no IOMODE_RW layout for range */ in nfs4_layoutcommit_done()
10207 case -NFS4ERR_BADLAYOUT: /* no layout */ in nfs4_layoutcommit_done()
10208 case -NFS4ERR_GRACE: /* loca_recalim always false */ in nfs4_layoutcommit_done()
10209 task->tk_status = 0; in nfs4_layoutcommit_done()
10214 if (nfs4_async_handle_error(task, server, NULL, NULL) == -EAGAIN) { in nfs4_layoutcommit_done()
10226 nfs_post_op_update_inode_force_wcc(data->args.inode, in nfs4_layoutcommit_release()
10227 data->res.fattr); in nfs4_layoutcommit_release()
10228 put_cred(data->cred); in nfs4_layoutcommit_release()
10229 nfs_iput_and_deactive(data->inode); in nfs4_layoutcommit_release()
10244 .rpc_argp = &data->args, in nfs4_proc_layoutcommit()
10245 .rpc_resp = &data->res, in nfs4_proc_layoutcommit()
10246 .rpc_cred = data->cred, in nfs4_proc_layoutcommit()
10249 .task = &data->task, in nfs4_proc_layoutcommit()
10250 .rpc_client = NFS_CLIENT(data->args.inode), in nfs4_proc_layoutcommit()
10261 data->args.lastbytewritten, in nfs4_proc_layoutcommit()
10262 data->args.inode->i_ino); in nfs4_proc_layoutcommit()
10265 data->inode = nfs_igrab_and_active(data->args.inode); in nfs4_proc_layoutcommit()
10266 if (data->inode == NULL) { in nfs4_proc_layoutcommit()
10268 return -EAGAIN; in nfs4_proc_layoutcommit()
10272 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1, 0); in nfs4_proc_layoutcommit()
10277 status = task->tk_status; in nfs4_proc_layoutcommit()
10278 trace_nfs4_layoutcommit(data->args.inode, &data->args.stateid, status); in nfs4_proc_layoutcommit()
10310 .rpc_client = server->client, in _nfs41_proc_secinfo_no_name()
10312 .callback_ops = server->nfs_client->cl_mvops->call_sync_ops, in _nfs41_proc_secinfo_no_name()
10320 task_setup.rpc_client = server->nfs_client->cl_rpcclient; in _nfs41_proc_secinfo_no_name()
10322 cred = nfs4_get_clid_cred(server->nfs_client); in _nfs41_proc_secinfo_no_name()
10328 dprintk("<-- %s status=%d\n", __func__, status); in _nfs41_proc_secinfo_no_name()
10345 err = -NFS4ERR_WRONGSEC; in nfs41_proc_secinfo_no_name()
10348 if (_nfs4_is_integrity_protected(server->nfs_client)) in nfs41_proc_secinfo_no_name()
10358 if (err == -NFS4ERR_WRONGSEC) in nfs41_proc_secinfo_no_name()
10364 case -NFS4ERR_WRONGSEC: in nfs41_proc_secinfo_no_name()
10365 case -ENOTSUPP: in nfs41_proc_secinfo_no_name()
10388 err = -ENOMEM; in nfs41_find_root_sec()
10399 if (err == -NFS4ERR_WRONGSEC || err == -ENOTSUPP) { in nfs41_find_root_sec()
10406 for (i = 0; i < flavors->num_flavors; i++) { in nfs41_find_root_sec()
10407 secinfo = &flavors->flavors[i]; in nfs41_find_root_sec()
10409 switch (secinfo->flavor) { in nfs41_find_root_sec()
10413 flavor = rpcauth_get_pseudoflavor(secinfo->flavor, in nfs41_find_root_sec()
10414 &secinfo->flavor_info); in nfs41_find_root_sec()
10421 if (!nfs_auth_info_match(&server->auth_info, flavor)) in nfs41_find_root_sec()
10433 err = -EPERM; in nfs41_find_root_sec()
10437 if (err == -EACCES) in nfs41_find_root_sec()
10438 return -EPERM; in nfs41_find_root_sec()
10458 struct rpc_clnt *rpc_client = server->client; in _nfs41_test_stateid()
10460 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID, in _nfs41_test_stateid()
10471 dprintk("NFS reply test_stateid: succeeded, %d\n", -res.status); in _nfs41_test_stateid()
10472 return -res.status; in _nfs41_test_stateid()
10478 exception->retry = 0; in nfs4_handle_delay_or_session_error()
10480 case -NFS4ERR_DELAY: in nfs4_handle_delay_or_session_error()
10481 case -NFS4ERR_RETRY_UNCACHED_REP: in nfs4_handle_delay_or_session_error()
10484 case -NFS4ERR_BADSESSION: in nfs4_handle_delay_or_session_error()
10485 case -NFS4ERR_BADSLOT: in nfs4_handle_delay_or_session_error()
10486 case -NFS4ERR_BAD_HIGH_SLOT: in nfs4_handle_delay_or_session_error()
10487 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: in nfs4_handle_delay_or_session_error()
10488 case -NFS4ERR_DEADSESSION: in nfs4_handle_delay_or_session_error()
10494 * nfs41_test_stateid - perform a TEST_STATEID operation
10528 nfs4_setup_sequence(data->server->nfs_client, in nfs41_free_stateid_prepare()
10529 &data->args.seq_args, in nfs41_free_stateid_prepare()
10530 &data->res.seq_res, in nfs41_free_stateid_prepare()
10538 nfs41_sequence_done(task, &data->res.seq_res); in nfs41_free_stateid_done()
10540 switch (task->tk_status) { in nfs41_free_stateid_done()
10541 case -NFS4ERR_DELAY: in nfs41_free_stateid_done()
10542 if (nfs4_async_handle_error(task, data->server, NULL, NULL) == -EAGAIN) in nfs41_free_stateid_done()
10550 struct nfs_client *clp = data->server->nfs_client; in nfs41_free_stateid_release()
10563 * nfs41_free_stateid - perform a FREE_STATEID operation
10568 * @privileged: set to true if this call needs to be privileged
10582 .rpc_client = server->client, in nfs41_free_stateid()
10589 struct nfs_client *clp = server->nfs_client; in nfs41_free_stateid()
10591 if (!refcount_inc_not_zero(&clp->cl_count)) in nfs41_free_stateid()
10592 return -EIO; in nfs41_free_stateid()
10594 nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID, in nfs41_free_stateid()
10600 return -ENOMEM; in nfs41_free_stateid()
10601 data->server = server; in nfs41_free_stateid()
10602 nfs4_stateid_copy(&data->args.stateid, stateid); in nfs41_free_stateid()
10606 msg.rpc_argp = &data->args; in nfs41_free_stateid()
10607 msg.rpc_resp = &data->res; in nfs41_free_stateid()
10608 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1, privileged); in nfs41_free_stateid()
10619 const struct cred *cred = lsp->ls_state->owner->so_cred; in nfs41_free_lock_state()
10621 nfs41_free_stateid(server, &lsp->ls_stateid, cred, false); in nfs41_free_lock_state()
10628 if (s1->type != s2->type) in nfs41_match_stateid()
10631 if (memcmp(s1->other, s2->other, sizeof(s1->other)) != 0) in nfs41_match_stateid()
10634 if (s1->seqid == s2->seqid) in nfs41_match_stateid()
10637 return s1->seqid == 0 || s2->seqid == 0; in nfs41_match_stateid()
10821 left -= error; in nfs4_listxattr()
10830 left -= error2; in nfs4_listxattr()
10839 return -ERANGE; in nfs4_listxattr()
10848 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client; in nfs4_enable_swap()
10858 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client; in nfs4_disable_swap()
10860 set_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state); in nfs4_disable_swap()
10861 clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state); in nfs4_disable_swap()
10862 wake_up_var(&clp->cl_state); in nfs4_disable_swap()
10951 .set = nfs4_xattr_set_nfs4_acl,
10959 .set = nfs4_xattr_set_nfs4_dacl,
10966 .set = nfs4_xattr_set_nfs4_sacl,
10974 .set = nfs4_xattr_set_nfs4_user,