#include <sys/param.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/signalvar.h>
#include <sys/kauth.h>
#include <sys/mount_internal.h>
#include <sys/kernel.h>
#include <sys/kpi_mbuf.h>
#include <sys/malloc.h>
#include <sys/vnode.h>
#include <sys/domain.h>
#include <sys/protosw.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/syslog.h>
#include <sys/tprintf.h>
#include <libkern/OSAtomic.h>
#include <sys/time.h>
#include <kern/clock.h>
#include <kern/task.h>
#include <kern/thread.h>
#include <kern/thread_call.h>
#include <sys/user.h>
#include <sys/acct.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <nfs/rpcv2.h>
#include <nfs/krpc.h>
#include <nfs/nfsproto.h>
#include <nfs/nfs.h>
#include <nfs/xdr_subs.h>
#include <nfs/nfsm_subs.h>
#include <nfs/nfs_gss.h>
#include <nfs/nfsmount.h>
#include <nfs/nfsnode.h>
#define NFS_SOCK_DBG(...) NFS_DBG(NFS_FAC_SOCK, 7, ## __VA_ARGS__)
#define NFS_SOCK_DUMP_MBUF(msg, mb) if (NFS_IS_DBG(NFS_FAC_SOCK, 15)) nfs_dump_mbuf(__func__, __LINE__, (msg), (mb))
boolean_t current_thread_aborted(void);
kern_return_t thread_terminate(thread_t);
#if NFSSERVER
int nfsrv_sock_max_rec_queue_length = 128;
int nfsrv_getstream(struct nfsrv_sock *, int);
int nfsrv_getreq(struct nfsrv_descript *);
extern int nfsv3_procid[NFS_NPROCS];
#endif
int
nfs_sockaddr_cmp(struct sockaddr *sa1, struct sockaddr *sa2)
{
if (!sa1) {
return -1;
}
if (!sa2) {
return 1;
}
if (sa1->sa_family != sa2->sa_family) {
return (sa1->sa_family < sa2->sa_family) ? -1 : 1;
}
if (sa1->sa_len != sa2->sa_len) {
return (sa1->sa_len < sa2->sa_len) ? -1 : 1;
}
if (sa1->sa_family == AF_INET) {
return bcmp(&((struct sockaddr_in*)sa1)->sin_addr,
&((struct sockaddr_in*)sa2)->sin_addr, sizeof(((struct sockaddr_in*)sa1)->sin_addr));
}
if (sa1->sa_family == AF_INET6) {
return bcmp(&((struct sockaddr_in6*)sa1)->sin6_addr,
&((struct sockaddr_in6*)sa2)->sin6_addr, sizeof(((struct sockaddr_in6*)sa1)->sin6_addr));
}
return -1;
}
#if NFSCLIENT
int nfs_connect_search_new_socket(struct nfsmount *, struct nfs_socket_search *, struct timeval *);
int nfs_connect_search_socket_connect(struct nfsmount *, struct nfs_socket *, int);
int nfs_connect_search_ping(struct nfsmount *, struct nfs_socket *, struct timeval *);
void nfs_connect_search_socket_found(struct nfsmount *, struct nfs_socket_search *, struct nfs_socket *);
void nfs_connect_search_socket_reap(struct nfsmount *, struct nfs_socket_search *, struct timeval *);
int nfs_connect_search_check(struct nfsmount *, struct nfs_socket_search *, struct timeval *);
int nfs_reconnect(struct nfsmount *);
int nfs_connect_setup(struct nfsmount *);
void nfs_mount_sock_thread(void *, wait_result_t);
void nfs_udp_rcv(socket_t, void*, int);
void nfs_tcp_rcv(socket_t, void*, int);
void nfs_sock_poke(struct nfsmount *);
void nfs_request_match_reply(struct nfsmount *, mbuf_t);
void nfs_reqdequeue(struct nfsreq *);
void nfs_reqbusy(struct nfsreq *);
struct nfsreq *nfs_reqnext(struct nfsreq *);
int nfs_wait_reply(struct nfsreq *);
void nfs_softterm(struct nfsreq *);
int nfs_can_squish(struct nfsmount *);
int nfs_is_squishy(struct nfsmount *);
int nfs_is_dead(int, struct nfsmount *);
#define NFS_RTO(n, t) \
((t) == 0 ? (n)->nm_timeo : \
((t) < 3 ? \
(((((n)->nm_srtt[t-1] + 3) >> 2) + (n)->nm_sdrtt[t-1] + 1) >> 1) : \
((((n)->nm_srtt[t-1] + 7) >> 3) + (n)->nm_sdrtt[t-1] + 1)))
#define NFS_SRTT(r) (r)->r_nmp->nm_srtt[proct[(r)->r_procnum] - 1]
#define NFS_SDRTT(r) (r)->r_nmp->nm_sdrtt[proct[(r)->r_procnum] - 1]
static const int proct[] = {
[NFSPROC_NULL] = 0,
[NFSPROC_GETATTR] = 1,
[NFSPROC_SETATTR] = 0,
[NFSPROC_LOOKUP] = 2,
[NFSPROC_ACCESS] = 1,
[NFSPROC_READLINK] = 3,
[NFSPROC_READ] = 3,
[NFSPROC_WRITE] = 4,
[NFSPROC_CREATE] = 0,
[NFSPROC_MKDIR] = 0,
[NFSPROC_SYMLINK] = 0,
[NFSPROC_MKNOD] = 0,
[NFSPROC_REMOVE] = 0,
[NFSPROC_RMDIR] = 0,
[NFSPROC_RENAME] = 0,
[NFSPROC_LINK] = 0,
[NFSPROC_READDIR] = 3,
[NFSPROC_READDIRPLUS] = 3,
[NFSPROC_FSSTAT] = 0,
[NFSPROC_FSINFO] = 0,
[NFSPROC_PATHCONF] = 0,
[NFSPROC_COMMIT] = 0,
[NFSPROC_NOOP] = 0,
};
#define NFS_CWNDSCALE 256
#define NFS_MAXCWND (NFS_CWNDSCALE * 32)
static int nfs_backoff[8] = { 2, 4, 8, 16, 32, 64, 128, 256, };
void
nfs_location_next(struct nfs_fs_locations *nlp, struct nfs_location_index *nlip)
{
uint8_t loc = nlip->nli_loc;
uint8_t serv = nlip->nli_serv;
uint8_t addr = nlip->nli_addr;
addr++;
if (addr >= nlp->nl_locations[loc]->nl_servers[serv]->ns_addrcount) {
next_server:
addr = 0;
serv++;
if (serv >= nlp->nl_locations[loc]->nl_servcount) {
serv = 0;
loc++;
if (loc >= nlp->nl_numlocs) {
loc = 0;
}
}
}
if ((loc == nlip->nli_loc) && (serv == nlip->nli_serv) && (addr == nlip->nli_addr)) {
return;
}
if (addr >= nlp->nl_locations[loc]->nl_servers[serv]->ns_addrcount) {
goto next_server;
}
nlip->nli_loc = loc;
nlip->nli_serv = serv;
nlip->nli_addr = addr;
}
int
nfs_location_index_cmp(struct nfs_location_index *nlip1, struct nfs_location_index *nlip2)
{
if (nlip1->nli_loc != nlip2->nli_loc) {
return nlip1->nli_loc - nlip2->nli_loc;
}
if (nlip1->nli_serv != nlip2->nli_serv) {
return nlip1->nli_serv - nlip2->nli_serv;
}
return nlip1->nli_addr - nlip2->nli_addr;
}
void
nfs_location_mntfromname(struct nfs_fs_locations *locs, struct nfs_location_index idx, char *s, int size, int pathonly)
{
struct nfs_fs_location *fsl = locs->nl_locations[idx.nli_loc];
char *p;
int cnt, i;
p = s;
if (!pathonly) {
char *name = fsl->nl_servers[idx.nli_serv]->ns_name;
if (name == NULL) {
name = "";
}
if (*name == '\0') {
if (*fsl->nl_servers[idx.nli_serv]->ns_addresses[idx.nli_addr]) {
name = fsl->nl_servers[idx.nli_serv]->ns_addresses[idx.nli_addr];
}
cnt = scnprintf(p, size, "<%s>:", name);
} else {
cnt = scnprintf(p, size, "%s:", name);
}
p += cnt;
size -= cnt;
}
if (fsl->nl_path.np_compcount == 0) {
if (size > 0) {
*p++ = '/';
*p++ = '\0';
}
return;
}
for (i = 0; (size > 0) && (i < (int)fsl->nl_path.np_compcount); i++) {
cnt = scnprintf(p, size, "/%s", fsl->nl_path.np_components[i]);
p += cnt;
size -= cnt;
}
}
void
nfs_connect_upcall(socket_t so, void *arg, __unused int waitflag)
{
struct nfs_socket *nso = arg;
size_t rcvlen;
mbuf_t m;
int error = 0, recv = 1;
if (nso->nso_flags & NSO_CONNECTING) {
NFS_SOCK_DBG("nfs connect - socket %p upcall - connecting flags = %8.8x\n", nso, nso->nso_flags);
wakeup(nso->nso_wake);
return;
}
lck_mtx_lock(&nso->nso_lock);
if ((nso->nso_flags & (NSO_UPCALL | NSO_DISCONNECTING | NSO_DEAD)) || !(nso->nso_flags & NSO_PINGING)) {
NFS_SOCK_DBG("nfs connect - socket %p upcall - nevermind\n", nso);
lck_mtx_unlock(&nso->nso_lock);
return;
}
NFS_SOCK_DBG("nfs connect - socket %p upcall %8.8x\n", nso, nso->nso_flags);
nso->nso_flags |= NSO_UPCALL;
while (!error && recv) {
if (nso->nso_flags & (NSO_DISCONNECTING | NSO_DEAD)) {
break;
}
lck_mtx_unlock(&nso->nso_lock);
m = NULL;
if (nso->nso_sotype == SOCK_STREAM) {
error = nfs_rpc_record_read(so, &nso->nso_rrs, MSG_DONTWAIT, &recv, &m);
NFS_SOCK_DBG("nfs_rpc_record_read returned %d recv = %d\n", error, recv);
} else {
rcvlen = 1000000;
error = sock_receivembuf(so, NULL, &m, MSG_DONTWAIT, &rcvlen);
recv = m ? 1 : 0;
}
lck_mtx_lock(&nso->nso_lock);
if (m) {
struct nfsm_chain nmrep;
uint32_t reply = 0, rxid = 0, verf_type, verf_len;
uint32_t reply_status, rejected_status, accepted_status;
NFS_SOCK_DUMP_MBUF("Got mbuf from ping", m);
nfsm_chain_dissect_init(error, &nmrep, m);
nfsm_chain_get_32(error, &nmrep, rxid);
nfsm_chain_get_32(error, &nmrep, reply);
if (!error && ((reply != RPC_REPLY) || (rxid != nso->nso_pingxid))) {
error = EBADRPC;
}
nfsm_chain_get_32(error, &nmrep, reply_status);
if (!error && (reply_status == RPC_MSGDENIED)) {
nfsm_chain_get_32(error, &nmrep, rejected_status);
if (!error) {
error = (rejected_status == RPC_MISMATCH) ? ERPCMISMATCH : EACCES;
}
}
nfsm_chain_get_32(error, &nmrep, verf_type);
nfsm_chain_get_32(error, &nmrep, verf_len);
nfsmout_if(error);
if (verf_len) {
nfsm_chain_adv(error, &nmrep, nfsm_rndup(verf_len));
}
nfsm_chain_get_32(error, &nmrep, accepted_status);
nfsmout_if(error);
NFS_SOCK_DBG("Recevied accepted_status of %d nso_version = %d\n", accepted_status, nso->nso_version);
if ((accepted_status == RPC_PROGMISMATCH) && !nso->nso_version) {
uint32_t minvers, maxvers;
nfsm_chain_get_32(error, &nmrep, minvers);
nfsm_chain_get_32(error, &nmrep, maxvers);
nfsmout_if(error);
if (nso->nso_protocol == PMAPPROG) {
if ((minvers > RPCBVERS4) || (maxvers < PMAPVERS)) {
error = EPROGMISMATCH;
} else if ((nso->nso_saddr->sa_family == AF_INET) &&
(PMAPVERS >= minvers) && (PMAPVERS <= maxvers)) {
nso->nso_version = PMAPVERS;
} else if (nso->nso_saddr->sa_family == AF_INET6) {
if ((RPCBVERS4 >= minvers) && (RPCBVERS4 <= maxvers)) {
nso->nso_version = RPCBVERS4;
} else if ((RPCBVERS3 >= minvers) && (RPCBVERS3 <= maxvers)) {
nso->nso_version = RPCBVERS3;
}
}
} else if (nso->nso_protocol == NFS_PROG) {
int vers;
for (vers = nso->nso_nfs_max_vers; vers >= (int)nso->nso_nfs_min_vers; vers--) {
if (vers >= (int)minvers && vers <= (int)maxvers) {
break;
}
}
nso->nso_version = (vers < (int)nso->nso_nfs_min_vers) ? 0 : vers;
}
if (!error && nso->nso_version) {
accepted_status = RPC_SUCCESS;
}
}
if (!error) {
switch (accepted_status) {
case RPC_SUCCESS:
error = 0;
break;
case RPC_PROGUNAVAIL:
error = EPROGUNAVAIL;
break;
case RPC_PROGMISMATCH:
error = EPROGMISMATCH;
break;
case RPC_PROCUNAVAIL:
error = EPROCUNAVAIL;
break;
case RPC_GARBAGE:
error = EBADRPC;
break;
case RPC_SYSTEM_ERR:
default:
error = EIO;
break;
}
}
nfsmout:
nso->nso_flags &= ~NSO_PINGING;
if (error) {
NFS_SOCK_DBG("nfs upcalled failed for %d program %d vers error = %d\n",
nso->nso_protocol, nso->nso_version, error);
nso->nso_error = error;
nso->nso_flags |= NSO_DEAD;
} else {
nso->nso_flags |= NSO_VERIFIED;
}
mbuf_freem(m);
wakeup(nso->nso_wake);
break;
}
}
nso->nso_flags &= ~NSO_UPCALL;
if ((error != EWOULDBLOCK) && (error || !recv)) {
NFS_SOCK_DBG("connect upcall failed %d\n", error);
nso->nso_error = error ? error : EPIPE;
nso->nso_flags |= NSO_DEAD;
wakeup(nso->nso_wake);
}
if (nso->nso_flags & NSO_DISCONNECTING) {
wakeup(&nso->nso_flags);
}
lck_mtx_unlock(&nso->nso_lock);
}
int
nfs_socket_create(
struct nfsmount *nmp,
struct sockaddr *sa,
int sotype,
in_port_t port,
uint32_t protocol,
uint32_t vers,
int resvport,
struct nfs_socket **nsop)
{
struct nfs_socket *nso;
struct timeval now;
int error;
#define NFS_SOCKET_DEBUGGING
#ifdef NFS_SOCKET_DEBUGGING
char naddr[sizeof((struct sockaddr_un *)0)->sun_path];
void *sinaddr;
switch (sa->sa_family) {
case AF_INET:
case AF_INET6:
if (sa->sa_family == AF_INET) {
sinaddr = &((struct sockaddr_in*)sa)->sin_addr;
} else {
sinaddr = &((struct sockaddr_in6*)sa)->sin6_addr;
}
if (inet_ntop(sa->sa_family, sinaddr, naddr, sizeof(naddr)) != naddr) {
strlcpy(naddr, "<unknown>", sizeof(naddr));
}
break;
case AF_LOCAL:
strlcpy(naddr, ((struct sockaddr_un *)sa)->sun_path, sizeof(naddr));
break;
default:
strlcpy(naddr, "<unsupported address family>", sizeof(naddr));
break;
}
#else
char naddr[1] = { 0 };
#endif
*nsop = NULL;
MALLOC(nso, struct nfs_socket *, sizeof(struct nfs_socket), M_TEMP, M_WAITOK | M_ZERO);
if (nso) {
MALLOC(nso->nso_saddr, struct sockaddr *, sa->sa_len, M_SONAME, M_WAITOK | M_ZERO);
}
if (!nso || !nso->nso_saddr) {
if (nso) {
FREE(nso, M_TEMP);
}
return ENOMEM;
}
lck_mtx_init(&nso->nso_lock, nfs_request_grp, LCK_ATTR_NULL);
nso->nso_sotype = sotype;
if (nso->nso_sotype == SOCK_STREAM) {
nfs_rpc_record_state_init(&nso->nso_rrs);
}
microuptime(&now);
nso->nso_timestamp = now.tv_sec;
bcopy(sa, nso->nso_saddr, sa->sa_len);
switch (sa->sa_family) {
case AF_INET:
case AF_INET6:
if (sa->sa_family == AF_INET) {
((struct sockaddr_in*)nso->nso_saddr)->sin_port = htons(port);
} else if (sa->sa_family == AF_INET6) {
((struct sockaddr_in6*)nso->nso_saddr)->sin6_port = htons(port);
}
break;
case AF_LOCAL:
break;
}
nso->nso_protocol = protocol;
nso->nso_version = vers;
nso->nso_nfs_min_vers = PVER2MAJOR(nmp->nm_min_vers);
nso->nso_nfs_max_vers = PVER2MAJOR(nmp->nm_max_vers);
error = sock_socket(sa->sa_family, nso->nso_sotype, 0, NULL, NULL, &nso->nso_so);
if (!error && resvport && ((sa->sa_family == AF_INET) || (sa->sa_family == AF_INET6))) {
struct sockaddr_storage ss;
int level = (sa->sa_family == AF_INET) ? IPPROTO_IP : IPPROTO_IPV6;
int optname = (sa->sa_family == AF_INET) ? IP_PORTRANGE : IPV6_PORTRANGE;
int portrange = IP_PORTRANGE_LOW;
error = sock_setsockopt(nso->nso_so, level, optname, &portrange, sizeof(portrange));
if (!error) {
ss.ss_len = sa->sa_len;
ss.ss_family = sa->sa_family;
if (ss.ss_family == AF_INET) {
((struct sockaddr_in*)&ss)->sin_addr.s_addr = INADDR_ANY;
((struct sockaddr_in*)&ss)->sin_port = htons(0);
} else if (ss.ss_family == AF_INET6) {
((struct sockaddr_in6*)&ss)->sin6_addr = in6addr_any;
((struct sockaddr_in6*)&ss)->sin6_port = htons(0);
} else {
error = EINVAL;
}
if (!error) {
error = sock_bind(nso->nso_so, (struct sockaddr*)&ss);
}
}
}
if (error) {
NFS_SOCK_DBG("nfs connect %s error %d creating socket %p %s type %d%s port %d prot %d %d\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname, error, nso, naddr, sotype,
resvport ? "r" : "", port, protocol, vers);
nfs_socket_destroy(nso);
} else {
NFS_SOCK_DBG("nfs connect %s created socket %p <%s> type %d%s port %d prot %d %d\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname, nso, naddr,
sotype, resvport ? "r" : "", port, protocol, vers);
*nsop = nso;
}
return error;
}
void
nfs_socket_destroy(struct nfs_socket *nso)
{
struct timespec ts = { .tv_sec = 4, .tv_nsec = 0 };
NFS_SOCK_DBG("Destoring socket %p flags = %8.8x error = %d\n", nso, nso->nso_flags, nso->nso_error);
lck_mtx_lock(&nso->nso_lock);
nso->nso_flags |= NSO_DISCONNECTING;
if (nso->nso_flags & NSO_UPCALL) {
msleep(&nso->nso_flags, &nso->nso_lock, PZERO - 1, "nfswaitupcall", &ts);
}
lck_mtx_unlock(&nso->nso_lock);
sock_shutdown(nso->nso_so, SHUT_RDWR);
sock_close(nso->nso_so);
if (nso->nso_sotype == SOCK_STREAM) {
nfs_rpc_record_state_cleanup(&nso->nso_rrs);
}
lck_mtx_destroy(&nso->nso_lock, nfs_request_grp);
if (nso->nso_saddr) {
FREE(nso->nso_saddr, M_SONAME);
}
if (nso->nso_saddr2) {
FREE(nso->nso_saddr2, M_SONAME);
}
NFS_SOCK_DBG("nfs connect - socket %p destroyed\n", nso);
FREE(nso, M_TEMP);
}
void
nfs_socket_options(struct nfsmount *nmp, struct nfs_socket *nso)
{
struct timeval timeo;
int on = 1, proto;
timeo.tv_usec = 0;
timeo.tv_sec = (NMFLAG(nmp, SOFT) || nfs_can_squish(nmp)) ? 5 : 60;
sock_setsockopt(nso->nso_so, SOL_SOCKET, SO_RCVTIMEO, &timeo, sizeof(timeo));
sock_setsockopt(nso->nso_so, SOL_SOCKET, SO_SNDTIMEO, &timeo, sizeof(timeo));
if (nso->nso_sotype == SOCK_STREAM) {
sock_setsockopt(nso->nso_so, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on));
sock_gettype(nso->nso_so, NULL, NULL, &proto);
if (proto == IPPROTO_TCP) {
sock_setsockopt(nso->nso_so, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on));
}
}
if (nso->nso_sotype == SOCK_DGRAM || nso->nso_saddr->sa_family == AF_LOCAL) {
int reserve = (nso->nso_sotype == SOCK_DGRAM) ? NFS_UDPSOCKBUF : (2 * 1024 * 1024);
sock_setsockopt(nso->nso_so, SOL_SOCKET, SO_SNDBUF, &reserve, sizeof(reserve));
sock_setsockopt(nso->nso_so, SOL_SOCKET, SO_RCVBUF, &reserve, sizeof(reserve));
}
sock_setsockopt(nso->nso_so, SOL_SOCKET, SO_NOADDRERR, &on, sizeof(on));
sock_setsockopt(nso->nso_so, SOL_SOCKET, SO_UPCALLCLOSEWAIT, &on, sizeof(on));
if (!NMFLAG(nmp, INTR)) {
sock_nointerrupt(nso->nso_so, 1);
}
}
void
nfs_socket_search_cleanup(struct nfs_socket_search *nss)
{
struct nfs_socket *nso, *nsonext;
TAILQ_FOREACH_SAFE(nso, &nss->nss_socklist, nso_link, nsonext) {
TAILQ_REMOVE(&nss->nss_socklist, nso, nso_link);
nss->nss_sockcnt--;
nfs_socket_destroy(nso);
}
if (nss->nss_sock) {
nfs_socket_destroy(nss->nss_sock);
nss->nss_sock = NULL;
}
}
int
nfs_connect_error_class(int error)
{
switch (error) {
case 0:
return 0;
case ETIMEDOUT:
case EAGAIN:
return 1;
case EPIPE:
case EADDRNOTAVAIL:
case ENETDOWN:
case ENETUNREACH:
case ENETRESET:
case ECONNABORTED:
case ECONNRESET:
case EISCONN:
case ENOTCONN:
case ESHUTDOWN:
case ECONNREFUSED:
case EHOSTDOWN:
case EHOSTUNREACH:
return 2;
case ERPCMISMATCH:
case EPROCUNAVAIL:
case EPROGMISMATCH:
case EPROGUNAVAIL:
return 3;
case EBADRPC:
return 4;
default:
return 5;
}
}
void
nfs_socket_search_update_error(struct nfs_socket_search *nss, int error)
{
if (nfs_connect_error_class(error) >= nfs_connect_error_class(nss->nss_error)) {
nss->nss_error = error;
}
}
int
nfs_connect_search_new_socket(struct nfsmount *nmp, struct nfs_socket_search *nss, struct timeval *now)
{
struct nfs_fs_location *fsl;
struct nfs_fs_server *fss;
struct sockaddr_storage ss;
struct nfs_socket *nso;
char *addrstr;
int error = 0;
NFS_SOCK_DBG("nfs connect %s nss_addrcnt = %d\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname, nss->nss_addrcnt);
while (nss->nss_addrcnt > 0 && ((nss->nss_last < 0) || (nss->nss_sockcnt == 0) ||
((nss->nss_sockcnt < 4) && (now->tv_sec >= (nss->nss_last + 2))))) {
if (nmp->nm_sockflags & NMSOCK_UNMOUNT) {
return EINTR;
}
fsl = nmp->nm_locations.nl_locations[nss->nss_nextloc.nli_loc];
fss = fsl->nl_servers[nss->nss_nextloc.nli_serv];
addrstr = fss->ns_addresses[nss->nss_nextloc.nli_addr];
NFS_SOCK_DBG("Trying address %s for program %d on port %d\n", addrstr, nss->nss_protocol, nss->nss_port);
if (*addrstr == '\0') {
if (nss->nss_protocol == PMAPPROG) {
addrstr = (nss->nss_sotype == SOCK_DGRAM) ? RPCB_TICLTS_PATH : RPCB_TICOTSORD_PATH;
} else if (nss->nss_protocol == NFS_PROG) {
addrstr = nmp->nm_nfs_localport;
if (!addrstr || *addrstr == '\0') {
addrstr = (nss->nss_sotype == SOCK_DGRAM) ? NFS_TICLTS_PATH : NFS_TICOTSORD_PATH;
}
}
NFS_SOCK_DBG("Calling prog %d with <%s>\n", nss->nss_protocol, addrstr);
}
if (!nfs_uaddr2sockaddr(addrstr, (struct sockaddr*)&ss)) {
NFS_SOCK_DBG("Could not convert address %s to socket\n", addrstr);
nfs_location_next(&nmp->nm_locations, &nss->nss_nextloc);
nss->nss_addrcnt -= 1;
nss->nss_last = -2;
continue;
}
if (nmp->nm_sofamily && (ss.ss_family != nmp->nm_sofamily)) {
NFS_SOCK_DBG("Skipping socket family %d, want mount family %d\n", ss.ss_family, nmp->nm_sofamily);
nfs_location_next(&nmp->nm_locations, &nss->nss_nextloc);
nss->nss_addrcnt -= 1;
nss->nss_last = -2;
continue;
}
error = nfs_socket_create(nmp, (struct sockaddr*)&ss, nss->nss_sotype,
nss->nss_port, nss->nss_protocol, nss->nss_version,
((nss->nss_protocol == NFS_PROG) && NMFLAG(nmp, RESVPORT)), &nso);
if (error) {
return error;
}
nso->nso_location = nss->nss_nextloc;
nso->nso_wake = nss;
error = sock_setupcall(nso->nso_so, nfs_connect_upcall, nso);
if (error) {
NFS_SOCK_DBG("sock_setupcall failed for socket %p setting nfs_connect_upcall error = %d\n", nso, error);
lck_mtx_lock(&nso->nso_lock);
nso->nso_error = error;
nso->nso_flags |= NSO_DEAD;
lck_mtx_unlock(&nso->nso_lock);
}
TAILQ_INSERT_TAIL(&nss->nss_socklist, nso, nso_link);
nss->nss_sockcnt++;
nfs_location_next(&nmp->nm_locations, &nss->nss_nextloc);
nss->nss_addrcnt -= 1;
nss->nss_last = now->tv_sec;
}
if (nss->nss_addrcnt == 0 && nss->nss_last < 0) {
nss->nss_last = now->tv_sec;
}
return error;
}
int
nfs_connect_search_socket_connect(struct nfsmount *nmp, struct nfs_socket *nso, int verbose)
{
int error;
if ((nso->nso_sotype != SOCK_STREAM) && NMFLAG(nmp, NOCONNECT)) {
NFS_SOCK_DBG("nfs connect %s UDP socket %p noconnect\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname, nso);
nso->nso_flags |= NSO_CONNECTED;
nfs_socket_options(nmp, nso);
return 1;
} else if (!(nso->nso_flags & NSO_CONNECTING)) {
nso->nso_flags |= NSO_CONNECTING;
lck_mtx_unlock(&nso->nso_lock);
NFS_SOCK_DBG("nfs connect %s connecting socket %p %s\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname, nso,
nso->nso_saddr->sa_family == AF_LOCAL ? ((struct sockaddr_un*)nso->nso_saddr)->sun_path : "");
error = sock_connect(nso->nso_so, nso->nso_saddr, MSG_DONTWAIT);
if (error) {
NFS_SOCK_DBG("nfs connect %s connecting socket %p returned %d\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname, nso, error);
}
lck_mtx_lock(&nso->nso_lock);
if (error && (error != EINPROGRESS)) {
nso->nso_error = error;
nso->nso_flags |= NSO_DEAD;
return 0;
}
}
if (nso->nso_flags & NSO_CONNECTING) {
if (sock_isconnected(nso->nso_so)) {
NFS_SOCK_DBG("nfs connect %s socket %p is connected\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname, nso);
nso->nso_flags &= ~NSO_CONNECTING;
nso->nso_flags |= NSO_CONNECTED;
nfs_socket_options(nmp, nso);
return 1;
} else {
int optlen = sizeof(error);
error = 0;
sock_getsockopt(nso->nso_so, SOL_SOCKET, SO_ERROR, &error, &optlen);
if (error) {
NFS_SOCK_DBG("nfs connect %s socket %p connection error %d\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname, nso, error);
if (verbose) {
printf("nfs connect socket error %d for %s\n",
error, vfs_statfs(nmp->nm_mountp)->f_mntfromname);
}
nso->nso_error = error;
nso->nso_flags |= NSO_DEAD;
return 0;
}
}
}
return 0;
}
int
nfs_connect_search_ping(struct nfsmount *nmp, struct nfs_socket *nso, struct timeval *now)
{
uint64_t xid = nso->nso_pingxid;
mbuf_t m, mreq = NULL;
struct msghdr msg;
size_t reqlen, sentlen;
uint32_t vers = nso->nso_version;
int error;
if (!vers) {
if (nso->nso_protocol == PMAPPROG) {
vers = (nso->nso_saddr->sa_family == AF_INET) ? PMAPVERS : RPCBVERS4;
} else if (nso->nso_protocol == NFS_PROG) {
vers = PVER2MAJOR(nmp->nm_max_vers);
}
}
lck_mtx_unlock(&nso->nso_lock);
NFS_SOCK_DBG("Pinging socket %p %d %d %d\n", nso, nso->nso_sotype, nso->nso_protocol, vers);
error = nfsm_rpchead2(nmp, nso->nso_sotype, nso->nso_protocol, vers, 0, RPCAUTH_SYS,
vfs_context_ucred(vfs_context_kernel()), NULL, NULL, &xid, &mreq);
lck_mtx_lock(&nso->nso_lock);
if (!error) {
nso->nso_flags |= NSO_PINGING;
nso->nso_pingxid = R_XID32(xid);
nso->nso_reqtimestamp = now->tv_sec;
bzero(&msg, sizeof(msg));
if ((nso->nso_sotype != SOCK_STREAM) && !sock_isconnected(nso->nso_so)) {
msg.msg_name = nso->nso_saddr;
msg.msg_namelen = nso->nso_saddr->sa_len;
}
for (reqlen = 0, m = mreq; m; m = mbuf_next(m)) {
reqlen += mbuf_len(m);
}
lck_mtx_unlock(&nso->nso_lock);
NFS_SOCK_DUMP_MBUF("Sending ping packet", mreq);
error = sock_sendmbuf(nso->nso_so, &msg, mreq, 0, &sentlen);
NFS_SOCK_DBG("nfs connect %s verifying socket %p send rv %d\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname, nso, error);
lck_mtx_lock(&nso->nso_lock);
if (!error && (sentlen != reqlen)) {
error = ETIMEDOUT;
}
}
if (error) {
nso->nso_error = error;
nso->nso_flags |= NSO_DEAD;
return 0;
}
return 1;
}
void
nfs_connect_search_socket_found(struct nfsmount *nmp, struct nfs_socket_search *nss, struct nfs_socket *nso)
{
NFS_SOCK_DBG("nfs connect %s socket %p verified\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname, nso);
if (!nso->nso_version) {
if (nso->nso_protocol == PMAPPROG) {
nso->nso_version = (nso->nso_saddr->sa_family == AF_INET) ? PMAPVERS : RPCBVERS4;
}
if (nso->nso_protocol == NFS_PROG) {
nso->nso_version = PVER2MAJOR(nmp->nm_max_vers);
}
}
TAILQ_REMOVE(&nss->nss_socklist, nso, nso_link);
nss->nss_sockcnt--;
nss->nss_sock = nso;
}
void
nfs_connect_search_socket_reap(struct nfsmount *nmp __unused, struct nfs_socket_search *nss, struct timeval *now)
{
struct nfs_socket *nso, *nsonext;
TAILQ_FOREACH_SAFE(nso, &nss->nss_socklist, nso_link, nsonext) {
lck_mtx_lock(&nso->nso_lock);
if (now->tv_sec >= (nso->nso_timestamp + nss->nss_timeo)) {
NFS_SOCK_DBG("nfs connect %s socket %p timed out\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname, nso);
nso->nso_error = ETIMEDOUT;
nso->nso_flags |= NSO_DEAD;
}
if (!(nso->nso_flags & NSO_DEAD)) {
lck_mtx_unlock(&nso->nso_lock);
continue;
}
lck_mtx_unlock(&nso->nso_lock);
NFS_SOCK_DBG("nfs connect %s reaping socket %p error = %d flags = %8.8x\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname, nso, nso->nso_error, nso->nso_flags);
nfs_socket_search_update_error(nss, nso->nso_error);
TAILQ_REMOVE(&nss->nss_socklist, nso, nso_link);
nss->nss_sockcnt--;
nfs_socket_destroy(nso);
if (nss->nss_addrcnt > 0) {
nss->nss_last = -2;
}
}
}
int
nfs_connect_search_check(struct nfsmount *nmp, struct nfs_socket_search *nss, struct timeval *now)
{
int error;
if (((now->tv_sec - nss->nss_timestamp) >= 8) && ((nss->nss_flags & (NSS_VERBOSE | NSS_WARNED)) == NSS_VERBOSE)) {
printf("nfs_connect: socket connect taking a while for %s\n", vfs_statfs(nmp->nm_mountp)->f_mntfromname);
nss->nss_flags |= NSS_WARNED;
}
if (nmp->nm_sockflags & NMSOCK_UNMOUNT) {
return EINTR;
}
if ((error = nfs_sigintr(nmp, NULL, current_thread(), 0))) {
return error;
}
if (nss->nss_last >= 0) {
tsleep(nss, PSOCK, "nfs_connect_search_wait", hz);
}
return 0;
}
int
nfs_connect_search_loop(struct nfsmount *nmp, struct nfs_socket_search *nss)
{
struct nfs_socket *nso;
struct timeval now;
int error;
int verbose = (nss->nss_flags & NSS_VERBOSE);
loop:
microuptime(&now);
NFS_SOCK_DBG("nfs connect %s search %ld\n", vfs_statfs(nmp->nm_mountp)->f_mntfromname, now.tv_sec);
error = nfs_connect_search_new_socket(nmp, nss, &now);
if (error) {
NFS_SOCK_DBG("nfs connect returned %d\n", error);
return error;
}
TAILQ_FOREACH(nso, &nss->nss_socklist, nso_link) {
lck_mtx_lock(&nso->nso_lock);
if (!(nso->nso_flags & NSO_CONNECTED)) {
if (!nfs_connect_search_socket_connect(nmp, nso, verbose)) {
lck_mtx_unlock(&nso->nso_lock);
continue;
}
}
if (!(nso->nso_flags & (NSO_PINGING | NSO_VERIFIED)) ||
((nso->nso_sotype == SOCK_DGRAM) && (now.tv_sec >= nso->nso_reqtimestamp + 2))) {
if (!nfs_connect_search_ping(nmp, nso, &now)) {
lck_mtx_unlock(&nso->nso_lock);
continue;
}
}
if (nso->nso_flags & NSO_VERIFIED) {
nfs_connect_search_socket_found(nmp, nss, nso);
lck_mtx_unlock(&nso->nso_lock);
break;
}
lck_mtx_unlock(&nso->nso_lock);
}
nfs_connect_search_socket_reap(nmp, nss, &now);
error = 0;
if (!nss->nss_sock && (!TAILQ_EMPTY(&nss->nss_socklist) || nss->nss_addrcnt)) {
error = nfs_connect_search_check(nmp, nss, &now);
if (!error) {
goto loop;
}
}
NFS_SOCK_DBG("nfs connect %s returning %d\n", vfs_statfs(nmp->nm_mountp)->f_mntfromname, error);
return error;
}
int
nfs_connect(struct nfsmount *nmp, int verbose, int timeo)
{
struct nfs_socket_search nss;
struct nfs_socket *nso, *nsonfs;
struct sockaddr_storage ss;
struct sockaddr *saddr, *oldsaddr;
sock_upcall upcall;
#if CONFIG_NFS4
struct timeval now;
#endif
struct timeval start;
int error, savederror, nfsvers;
int tryv4 = 1;
uint8_t sotype = nmp->nm_sotype ? nmp->nm_sotype : SOCK_STREAM;
fhandle_t *fh = NULL;
char *path = NULL;
in_port_t port;
int addrtotal = 0;
uint32_t loc, serv;
for (loc = 0; loc < nmp->nm_locations.nl_numlocs; loc++) {
for (serv = 0; serv < nmp->nm_locations.nl_locations[loc]->nl_servcount; serv++) {
addrtotal += nmp->nm_locations.nl_locations[loc]->nl_servers[serv]->ns_addrcount;
if (nmp->nm_locations.nl_locations[loc]->nl_servers[serv]->ns_addrcount == 0) {
NFS_SOCK_DBG("nfs connect %s search, server %s has no addresses\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname,
nmp->nm_locations.nl_locations[loc]->nl_servers[serv]->ns_name);
}
}
}
if (addrtotal == 0) {
NFS_SOCK_DBG("nfs connect %s search failed, no addresses\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname);
return EINVAL;
} else {
NFS_SOCK_DBG("nfs connect %s has %d addresses\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname, addrtotal);
}
lck_mtx_lock(&nmp->nm_lock);
nmp->nm_sockflags |= NMSOCK_CONNECTING;
nmp->nm_nss = &nss;
lck_mtx_unlock(&nmp->nm_lock);
microuptime(&start);
savederror = error = 0;
tryagain:
bzero(&nss, sizeof(nss));
nss.nss_addrcnt = addrtotal;
nss.nss_error = savederror;
TAILQ_INIT(&nss.nss_socklist);
nss.nss_sotype = sotype;
nss.nss_startloc = nmp->nm_locations.nl_current;
nss.nss_timestamp = start.tv_sec;
nss.nss_timeo = timeo;
if (verbose) {
nss.nss_flags |= NSS_VERBOSE;
}
if (!(nmp->nm_sockflags & NMSOCK_HASCONNECTED)) {
NFS_SOCK_DBG("so_family = %d\n", nmp->nm_sofamily);
NFS_SOCK_DBG("nfs port = %d local: <%s>\n", nmp->nm_nfsport, nmp->nm_nfs_localport ? nmp->nm_nfs_localport : "");
NFS_SOCK_DBG("mount port = %d local: <%s>\n", nmp->nm_mountport, nmp->nm_mount_localport ? nmp->nm_mount_localport : "");
if (!nmp->nm_vers) {
if (!nmp->nm_nfsport || (!NM_OMATTR_GIVEN(nmp, FH) && !nmp->nm_mountport)) {
#if CONFIG_NFS4
if (PVER2MAJOR(nmp->nm_max_vers) >= NFS_VER4 && tryv4) {
nss.nss_port = NFS_PORT;
nss.nss_protocol = NFS_PROG;
nss.nss_version = 4;
nss.nss_flags |= NSS_FALLBACK2PMAP;
} else {
#endif
nss.nss_port = PMAPPORT;
nss.nss_protocol = PMAPPROG;
nss.nss_version = 0;
#if CONFIG_NFS4
}
#endif
} else {
nss.nss_port = nmp->nm_nfsport;
nss.nss_protocol = NFS_PROG;
nss.nss_version = 0;
}
#if CONFIG_NFS4
} else if (nmp->nm_vers >= NFS_VER4) {
if (tryv4) {
nss.nss_port = nmp->nm_nfsport ? nmp->nm_nfsport : NFS_PORT;
nss.nss_protocol = NFS_PROG;
nss.nss_version = 4;
if (!nmp->nm_nfsport) {
nss.nss_flags |= NSS_FALLBACK2PMAP;
}
} else {
nss.nss_port = PMAPPORT;
nss.nss_protocol = PMAPPROG;
nss.nss_version = 0;
}
#endif
} else {
if (!nmp->nm_nfsport || (!NM_OMATTR_GIVEN(nmp, FH) && !nmp->nm_mountport)) {
nss.nss_port = PMAPPORT;
nss.nss_protocol = PMAPPROG;
nss.nss_version = 0;
} else {
nss.nss_port = nmp->nm_nfsport;
nss.nss_protocol = NFS_PROG;
nss.nss_version = nmp->nm_vers;
}
}
NFS_SOCK_DBG("nfs connect first %s, so type %d port %d prot %d %d\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname, nss.nss_sotype, nss.nss_port,
nss.nss_protocol, nss.nss_version);
} else {
if (!nmp->nm_nfsport) {
nss.nss_port = PMAPPORT;
nss.nss_protocol = PMAPPROG;
nss.nss_version = 0;
} else {
nss.nss_port = nmp->nm_nfsport;
nss.nss_protocol = NFS_PROG;
nss.nss_version = nmp->nm_vers;
}
NFS_SOCK_DBG("nfs connect %s, so type %d port %d prot %d %d\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname, nss.nss_sotype, nss.nss_port,
nss.nss_protocol, nss.nss_version);
}
nss.nss_nextloc = nss.nss_startloc;
if ((nss.nss_nextloc.nli_serv >= nmp->nm_locations.nl_locations[nss.nss_nextloc.nli_loc]->nl_servcount) ||
(nss.nss_nextloc.nli_addr >= nmp->nm_locations.nl_locations[nss.nss_nextloc.nli_loc]->nl_servers[nss.nss_nextloc.nli_serv]->ns_addrcount)) {
nfs_location_next(&nmp->nm_locations, &nss.nss_nextloc);
if (!nfs_location_index_cmp(&nss.nss_nextloc, &nss.nss_startloc)) {
NFS_SOCK_DBG("nfs connect %s search failed, couldn't find a valid location index\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname);
return ENOENT;
}
}
nss.nss_last = -1;
keepsearching:
error = nfs_connect_search_loop(nmp, &nss);
if (error || !nss.nss_sock) {
nfs_socket_search_cleanup(&nss);
if (nss.nss_flags & NSS_FALLBACK2PMAP) {
tryv4 = 0;
NFS_SOCK_DBG("nfs connect %s TCP failed for V4 %d %d, trying PORTMAP\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname, error, nss.nss_error);
goto tryagain;
}
if (!error && (nss.nss_sotype == SOCK_STREAM) && !nmp->nm_sotype && (nmp->nm_vers < NFS_VER4)) {
sotype = SOCK_DGRAM;
savederror = nss.nss_error;
NFS_SOCK_DBG("nfs connect %s TCP failed %d %d, trying UDP\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname, error, nss.nss_error);
goto tryagain;
}
if (!error) {
error = nss.nss_error ? nss.nss_error : ETIMEDOUT;
}
lck_mtx_lock(&nmp->nm_lock);
nmp->nm_sockflags &= ~NMSOCK_CONNECTING;
nmp->nm_nss = NULL;
lck_mtx_unlock(&nmp->nm_lock);
if (nss.nss_flags & NSS_WARNED) {
log(LOG_INFO, "nfs_connect: socket connect aborted for %s\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname);
}
if (fh) {
FREE(fh, M_TEMP);
}
if (path) {
FREE_ZONE(path, MAXPATHLEN, M_NAMEI);
}
NFS_SOCK_DBG("nfs connect %s search failed, returning %d\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname, error);
return error;
}
nso = nss.nss_sock;
nss.nss_sock = NULL;
if (nso->nso_saddr->sa_family == AF_INET) {
port = ntohs(((struct sockaddr_in*)nso->nso_saddr)->sin_port);
} else if (nso->nso_saddr->sa_family == AF_INET6) {
port = ntohs(((struct sockaddr_in6*)nso->nso_saddr)->sin6_port);
} else if (nso->nso_saddr->sa_family == AF_LOCAL) {
if (nso->nso_protocol == PMAPPROG) {
port = PMAPPORT;
}
}
if (port == PMAPPORT) {
NFS_SOCK_DBG("nfs connect %s got portmapper socket %p\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname, nso);
sock_setupcall(nso->nso_so, NULL, NULL);
bcopy(nso->nso_saddr, &ss, nso->nso_saddr->sa_len);
nfsvers = nmp->nm_vers ? nmp->nm_vers : PVER2MAJOR(nmp->nm_max_vers);
if (!(port = nmp->nm_nfsport)) {
if (ss.ss_family == AF_INET) {
((struct sockaddr_in*)&ss)->sin_port = htons(0);
} else if (ss.ss_family == AF_INET6) {
((struct sockaddr_in6*)&ss)->sin6_port = htons(0);
} else if (ss.ss_family == AF_LOCAL) {
if (((struct sockaddr_un*)&ss)->sun_path[0] == '/') {
NFS_SOCK_DBG("Looking up NFS socket over %s\n", ((struct sockaddr_un*)&ss)->sun_path);
}
}
for (; nfsvers >= (int)PVER2MAJOR(nmp->nm_min_vers); nfsvers--) {
if (nmp->nm_vers && nmp->nm_vers != nfsvers) {
continue;
}
#if CONFIG_NFS4
if (nfsvers == NFS_VER4 && nso->nso_sotype == SOCK_DGRAM) {
continue;
}
#endif
if (ss.ss_family == AF_LOCAL && nmp->nm_nfs_localport) {
struct sockaddr_un *sun = (struct sockaddr_un *)&ss;
NFS_SOCK_DBG("Using supplied local address %s for NFS_PROG\n", nmp->nm_nfs_localport);
strlcpy(sun->sun_path, nmp->nm_nfs_localport, sizeof(sun->sun_path));
error = 0;
} else {
NFS_SOCK_DBG("Calling Portmap/Rpcbind for NFS_PROG");
error = nfs_portmap_lookup(nmp, vfs_context_current(), (struct sockaddr*)&ss,
nso->nso_so, NFS_PROG, nfsvers, nso->nso_sotype, timeo);
}
if (!error) {
if (ss.ss_family == AF_INET) {
port = ntohs(((struct sockaddr_in*)&ss)->sin_port);
} else if (ss.ss_family == AF_INET6) {
port = ntohs(((struct sockaddr_in6*)&ss)->sin6_port);
} else if (ss.ss_family == AF_LOCAL) {
port = ((struct sockaddr_un *)&ss)->sun_path[0] ? NFS_PORT : 0;
}
if (!port) {
error = EPROGUNAVAIL;
}
#if CONFIG_NFS4
if (port == NFS_PORT && nfsvers == NFS_VER4 && tryv4 == 0) {
continue;
}
#endif
}
if (!error) {
break;
}
}
if (nfsvers < (int)PVER2MAJOR(nmp->nm_min_vers) && error == 0) {
error = EPROGUNAVAIL;
}
if (error) {
nfs_socket_search_update_error(&nss, error);
nfs_socket_destroy(nso);
NFS_SOCK_DBG("Could not lookup NFS socket address for version %d error = %d\n", nfsvers, error);
goto keepsearching;
}
} else if (nmp->nm_nfs_localport) {
strlcpy(((struct sockaddr_un*)&ss)->sun_path, nmp->nm_nfs_localport, sizeof(((struct sockaddr_un*)&ss)->sun_path));
NFS_SOCK_DBG("Using supplied nfs_local_port %s for NFS_PROG\n", nmp->nm_nfs_localport);
}
if (ss.ss_family == AF_LOCAL) {
NFS_SOCK_DBG("Creating NFS socket for %s port = %d\n", ((struct sockaddr_un*)&ss)->sun_path, port);
}
error = nfs_socket_create(nmp, (struct sockaddr*)&ss, nso->nso_sotype, port,
NFS_PROG, nfsvers, NMFLAG(nmp, RESVPORT), &nsonfs);
if (error) {
nfs_socket_search_update_error(&nss, error);
nfs_socket_destroy(nso);
NFS_SOCK_DBG("Could not create NFS socket: %d\n", error);
goto keepsearching;
}
nsonfs->nso_location = nso->nso_location;
nsonfs->nso_wake = &nss;
error = sock_setupcall(nsonfs->nso_so, nfs_connect_upcall, nsonfs);
if (error) {
nfs_socket_search_update_error(&nss, error);
nfs_socket_destroy(nsonfs);
nfs_socket_destroy(nso);
NFS_SOCK_DBG("Could not nfs_connect_upcall: %d", error);
goto keepsearching;
}
TAILQ_INSERT_TAIL(&nss.nss_socklist, nsonfs, nso_link);
nss.nss_sockcnt++;
if ((nfsvers < NFS_VER4) && !(nmp->nm_sockflags & NMSOCK_HASCONNECTED) && !NM_OMATTR_GIVEN(nmp, FH)) {
error = 0;
bcopy(nso->nso_saddr, &ss, nso->nso_saddr->sa_len);
port = nmp->nm_mountport;
NFS_SOCK_DBG("mount port = %d\n", port);
if (ss.ss_family == AF_INET) {
((struct sockaddr_in*)&ss)->sin_port = htons(port);
} else if (ss.ss_family == AF_INET6) {
((struct sockaddr_in6*)&ss)->sin6_port = htons(port);
} else if (ss.ss_family == AF_LOCAL && nmp->nm_mount_localport) {
NFS_SOCK_DBG("Setting mount address to %s port = %d\n", nmp->nm_mount_localport, nmp->nm_mountport);
strlcpy(((struct sockaddr_un*)&ss)->sun_path, nmp->nm_mount_localport, sizeof(((struct sockaddr_un*)&ss)->sun_path));
}
if (!port) {
int mntvers = (nfsvers == NFS_VER2) ? RPCMNT_VER1 : RPCMNT_VER3;
int mntproto = (NM_OMFLAG(nmp, MNTUDP) || (nso->nso_sotype == SOCK_DGRAM)) ? IPPROTO_UDP : IPPROTO_TCP;
NFS_SOCK_DBG("Looking up mount port with socket %p\n", nso->nso_so);
error = nfs_portmap_lookup(nmp, vfs_context_current(), (struct sockaddr*)&ss,
nso->nso_so, RPCPROG_MNT, mntvers, mntproto == IPPROTO_UDP ? SOCK_DGRAM : SOCK_STREAM, timeo);
}
if (!error) {
if (ss.ss_family == AF_INET) {
port = ntohs(((struct sockaddr_in*)&ss)->sin_port);
} else if (ss.ss_family == AF_INET6) {
port = ntohs(((struct sockaddr_in6*)&ss)->sin6_port);
} else if (ss.ss_family == AF_LOCAL) {
port = (((struct sockaddr_un*)&ss)->sun_path[0] != '\0');
}
if (!port) {
error = EPROGUNAVAIL;
}
}
if (!error) {
MALLOC(nsonfs->nso_saddr2, struct sockaddr *, ss.ss_len, M_SONAME, M_WAITOK | M_ZERO);
}
if (!error && !nsonfs->nso_saddr2) {
error = ENOMEM;
}
if (!error) {
bcopy(&ss, nsonfs->nso_saddr2, ss.ss_len);
}
if (error) {
NFS_SOCK_DBG("Could not create mount sockaet address %d", error);
lck_mtx_lock(&nsonfs->nso_lock);
nsonfs->nso_error = error;
nsonfs->nso_flags |= NSO_DEAD;
lck_mtx_unlock(&nsonfs->nso_lock);
}
}
NFS_SOCK_DBG("Destroying socket %p so %p\n", nso, nso->nso_so);
nfs_socket_destroy(nso);
goto keepsearching;
}
NFS_SOCK_DBG("nfs connect %s got NFS socket %p\n", vfs_statfs(nmp->nm_mountp)->f_mntfromname, nso);
nfsvers = nmp->nm_vers ? nmp->nm_vers : (int)nso->nso_version;
if ((nfsvers < NFS_VER4) && !(nmp->nm_sockflags & NMSOCK_HASCONNECTED) && !NM_OMATTR_GIVEN(nmp, FH)) {
error = 0;
saddr = nso->nso_saddr2;
if (!saddr) {
NFS_SOCK_DBG("Getting mount address mountport = %d, mount_localport = %s\n", nmp->nm_mountport, nmp->nm_mount_localport);
bcopy(nso->nso_saddr, &ss, nso->nso_saddr->sa_len);
port = nmp->nm_mountport;
if (ss.ss_family == AF_INET) {
((struct sockaddr_in*)&ss)->sin_port = htons(port);
} else if (ss.ss_family == AF_INET6) {
((struct sockaddr_in6*)&ss)->sin6_port = htons(port);
} else if (ss.ss_family == AF_LOCAL && nmp->nm_mount_localport) {
NFS_SOCK_DBG("Setting mount address to %s port = %d\n", nmp->nm_mount_localport, nmp->nm_mountport);
strlcpy(((struct sockaddr_un*)&ss)->sun_path, nmp->nm_mount_localport, sizeof(((struct sockaddr_un*)&ss)->sun_path));
}
if (!port) {
int mntvers = (nfsvers == NFS_VER2) ? RPCMNT_VER1 : RPCMNT_VER3;
int so_type = NM_OMFLAG(nmp, MNTUDP) ? SOCK_DGRAM : nso->nso_sotype;
error = nfs_portmap_lookup(nmp, vfs_context_current(), (struct sockaddr*)&ss,
NULL, RPCPROG_MNT, mntvers, so_type, timeo);
if (ss.ss_family == AF_INET) {
port = ntohs(((struct sockaddr_in*)&ss)->sin_port);
} else if (ss.ss_family == AF_INET6) {
port = ntohs(((struct sockaddr_in6*)&ss)->sin6_port);
}
}
if (!error) {
if (port) {
saddr = (struct sockaddr*)&ss;
} else {
error = EPROGUNAVAIL;
}
}
}
if (saddr) {
MALLOC(fh, fhandle_t *, sizeof(fhandle_t), M_TEMP, M_WAITOK | M_ZERO);
}
if (saddr && fh) {
MALLOC_ZONE(path, char *, MAXPATHLEN, M_NAMEI, M_WAITOK);
}
if (!saddr || !fh || !path) {
if (!error) {
error = ENOMEM;
}
if (fh) {
FREE(fh, M_TEMP);
}
if (path) {
FREE_ZONE(path, MAXPATHLEN, M_NAMEI);
}
fh = NULL;
path = NULL;
nfs_socket_search_update_error(&nss, error);
nfs_socket_destroy(nso);
goto keepsearching;
}
nfs_location_mntfromname(&nmp->nm_locations, nso->nso_location, path, MAXPATHLEN, 1);
error = nfs3_mount_rpc(nmp, saddr, nso->nso_sotype, nfsvers,
path, vfs_context_current(), timeo, fh, &nmp->nm_servsec);
NFS_SOCK_DBG("nfs connect %s socket %p mount %d\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname, nso, error);
if (!error) {
int o, s;
int found = 0;
if ((nfsvers == NFS_VER3) && !nmp->nm_servsec.count) {
nmp->nm_servsec.count = 1;
nmp->nm_servsec.flavors[0] = RPCAUTH_SYS;
}
if (nmp->nm_sec.count) {
if (!nmp->nm_servsec.count) {
nmp->nm_auth = nmp->nm_sec.flavors[0];
found = 1;
}
for (o = 0; !found && (o < nmp->nm_sec.count); o++) {
for (s = 0; !found && (s < nmp->nm_servsec.count); s++) {
if (nmp->nm_sec.flavors[o] == nmp->nm_servsec.flavors[s]) {
nmp->nm_auth = nmp->nm_sec.flavors[o];
found = 1;
}
}
}
} else {
if (!nmp->nm_servsec.count) {
nmp->nm_auth = RPCAUTH_SYS;
found = 1;
}
for (s = 0; s < nmp->nm_servsec.count; s++) {
switch (nmp->nm_servsec.flavors[s]) {
case RPCAUTH_SYS:
if (found && (nmp->nm_auth == RPCAUTH_NONE)) {
found = 0;
}
case RPCAUTH_NONE:
case RPCAUTH_KRB5:
case RPCAUTH_KRB5I:
case RPCAUTH_KRB5P:
if (!found) {
nmp->nm_auth = nmp->nm_servsec.flavors[s];
found = 1;
}
break;
}
}
}
error = !found ? EAUTH : 0;
}
FREE_ZONE(path, MAXPATHLEN, M_NAMEI);
path = NULL;
if (error) {
nfs_socket_search_update_error(&nss, error);
FREE(fh, M_TEMP);
fh = NULL;
nfs_socket_destroy(nso);
goto keepsearching;
}
if (nmp->nm_fh) {
FREE(nmp->nm_fh, M_TEMP);
}
nmp->nm_fh = fh;
fh = NULL;
NFS_BITMAP_SET(nmp->nm_flags, NFS_MFLAG_CALLUMNT);
}
upcall = (nso->nso_sotype == SOCK_STREAM) ? nfs_tcp_rcv : nfs_udp_rcv;
error = sock_setupcall(nso->nso_so, upcall, nmp);
if (error) {
nfs_socket_search_update_error(&nss, error);
nfs_socket_destroy(nso);
goto keepsearching;
}
if (!(nmp->nm_sockflags & NMSOCK_HASCONNECTED)) {
if (!NM_OMATTR_GIVEN(nmp, MNTFROM)) {
nfs_location_mntfromname(&nmp->nm_locations, nso->nso_location,
vfs_statfs(nmp->nm_mountp)->f_mntfromname,
sizeof(vfs_statfs(nmp->nm_mountp)->f_mntfromname), 0);
}
if (!nmp->nm_sotype) {
nmp->nm_sotype = nso->nso_sotype;
}
if (!nmp->nm_vers) {
nmp->nm_vers = nfsvers;
#if CONFIG_NFS4
if ((nfsvers >= NFS_VER4) && !NFS_BITMAP_ISSET(nmp->nm_mattrs, NFS_MATTR_NFS_PORT)) {
if (nso->nso_saddr->sa_family == AF_INET) {
port = ((struct sockaddr_in*)nso->nso_saddr)->sin_port = htons(port);
} else if (nso->nso_saddr->sa_family == AF_INET6) {
port = ((struct sockaddr_in6*)nso->nso_saddr)->sin6_port = htons(port);
} else {
port = 0;
}
if (port == NFS_PORT) {
nmp->nm_nfsport = NFS_PORT;
}
}
#endif
}
#if CONFIG_NFS4
if (nmp->nm_vers >= NFS_VER4) {
microtime(&now);
nmp->nm_mounttime = ((uint64_t)now.tv_sec << 32) | now.tv_usec;
if (!NMFLAG(nmp, NOCALLBACK)) {
nfs4_mount_callback_setup(nmp);
}
}
#endif
}
lck_mtx_lock(&nmp->nm_lock);
nmp->nm_srtt[0] = nmp->nm_srtt[1] = nmp->nm_srtt[2] =
nmp->nm_srtt[3] = (NFS_TIMEO << 3);
nmp->nm_sdrtt[0] = nmp->nm_sdrtt[1] = nmp->nm_sdrtt[2] =
nmp->nm_sdrtt[3] = 0;
if (nso->nso_sotype == SOCK_DGRAM) {
nmp->nm_cwnd = NFS_MAXCWND / 2;
nmp->nm_sent = 0;
} else if (nso->nso_sotype == SOCK_STREAM) {
nmp->nm_timeouts = 0;
}
nmp->nm_sockflags &= ~NMSOCK_CONNECTING;
nmp->nm_sockflags |= NMSOCK_SETUP;
nmp->nm_nso = nso;
oldsaddr = nmp->nm_saddr;
nmp->nm_saddr = nso->nso_saddr;
lck_mtx_unlock(&nmp->nm_lock);
error = nfs_connect_setup(nmp);
lck_mtx_lock(&nmp->nm_lock);
nmp->nm_sockflags &= ~NMSOCK_SETUP;
if (!error) {
nmp->nm_sockflags |= NMSOCK_READY;
wakeup(&nmp->nm_sockflags);
}
if (error) {
NFS_SOCK_DBG("nfs connect %s socket %p setup failed %d\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname, nso, error);
nfs_socket_search_update_error(&nss, error);
nmp->nm_saddr = oldsaddr;
if (!(nmp->nm_sockflags & NMSOCK_HASCONNECTED)) {
if (!NFS_BITMAP_ISSET(nmp->nm_mattrs, NFS_MATTR_SOCKET_TYPE)) {
nmp->nm_sotype = 0;
}
if (!NFS_BITMAP_ISSET(nmp->nm_mattrs, NFS_MATTR_NFS_VERSION)) {
#if CONFIG_NFS4
if (nmp->nm_vers >= NFS_VER4) {
if (!NFS_BITMAP_ISSET(nmp->nm_mattrs, NFS_MATTR_NFS_PORT)) {
nmp->nm_nfsport = 0;
}
if (nmp->nm_cbid) {
nfs4_mount_callback_shutdown(nmp);
}
if (IS_VALID_CRED(nmp->nm_mcred)) {
kauth_cred_unref(&nmp->nm_mcred);
}
bzero(&nmp->nm_un, sizeof(nmp->nm_un));
}
#endif
nmp->nm_vers = 0;
}
}
lck_mtx_unlock(&nmp->nm_lock);
nmp->nm_nso = NULL;
nfs_socket_destroy(nso);
goto keepsearching;
}
if ((nmp->nm_locations.nl_current.nli_flags & NLI_VALID) &&
(nmp->nm_locations.nl_current.nli_serv != nso->nso_location.nli_serv)) {
}
nmp->nm_locations.nl_current = nso->nso_location;
nmp->nm_locations.nl_current.nli_flags |= NLI_VALID;
if (!(nmp->nm_sockflags & NMSOCK_HASCONNECTED)) {
nmp->nm_sockflags |= NMSOCK_HASCONNECTED;
}
lck_mtx_unlock(&nmp->nm_lock);
if (oldsaddr) {
FREE(oldsaddr, M_SONAME);
}
if (nss.nss_flags & NSS_WARNED) {
log(LOG_INFO, "nfs_connect: socket connect completed for %s\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname);
}
nmp->nm_nss = NULL;
nfs_socket_search_cleanup(&nss);
if (fh) {
FREE(fh, M_TEMP);
}
if (path) {
FREE_ZONE(path, MAXPATHLEN, M_NAMEI);
}
NFS_SOCK_DBG("nfs connect %s success\n", vfs_statfs(nmp->nm_mountp)->f_mntfromname);
return 0;
}
int
nfs_connect_setup(
#if !CONFIG_NFS4
__unused
#endif
struct nfsmount *nmp)
{
int error = 0;
#if CONFIG_NFS4
if (nmp->nm_vers >= NFS_VER4) {
if (nmp->nm_state & NFSSTA_CLIENTID) {
error = nfs4_renew(nmp, R_SETUP);
if ((error == NFSERR_ADMIN_REVOKED) ||
(error == NFSERR_CB_PATH_DOWN) ||
(error == NFSERR_EXPIRED) ||
(error == NFSERR_LEASE_MOVED) ||
(error == NFSERR_STALE_CLIENTID)) {
lck_mtx_lock(&nmp->nm_lock);
nfs_need_recover(nmp, error);
lck_mtx_unlock(&nmp->nm_lock);
}
}
error = nfs4_setclientid(nmp);
}
#endif
return error;
}
int
nfs_reconnect(struct nfsmount *nmp)
{
struct nfsreq *rq;
struct timeval now;
thread_t thd = current_thread();
int error, wentdown = 0, verbose = 1;
time_t lastmsg;
int timeo;
microuptime(&now);
lastmsg = now.tv_sec - (nmp->nm_tprintf_delay - nmp->nm_tprintf_initial_delay);
nfs_disconnect(nmp);
lck_mtx_lock(&nmp->nm_lock);
timeo = nfs_is_squishy(nmp) ? 8 : 30;
lck_mtx_unlock(&nmp->nm_lock);
while ((error = nfs_connect(nmp, verbose, timeo))) {
verbose = 0;
nfs_disconnect(nmp);
if ((error == EINTR) || (error == ERESTART)) {
return EINTR;
}
if (error == EIO) {
return EIO;
}
microuptime(&now);
if ((lastmsg + nmp->nm_tprintf_delay) < now.tv_sec) {
lastmsg = now.tv_sec;
nfs_down(nmp, thd, error, NFSSTA_TIMEO, "can not connect", 0);
wentdown = 1;
}
lck_mtx_lock(&nmp->nm_lock);
if (!(nmp->nm_state & NFSSTA_MOUNTED)) {
lck_mtx_unlock(&nmp->nm_lock);
NFS_SOCK_DBG("Not mounted returning %d\n", error);
return error;
}
if (nfs_mount_check_dead_timeout(nmp)) {
nfs_mount_make_zombie(nmp);
lck_mtx_unlock(&nmp->nm_lock);
return ENXIO;
}
if ((error = nfs_sigintr(nmp, NULL, thd, 1))) {
lck_mtx_unlock(&nmp->nm_lock);
return error;
}
lck_mtx_unlock(&nmp->nm_lock);
tsleep(nfs_reconnect, PSOCK, "nfs_reconnect_delay", 2 * hz);
if ((error = nfs_sigintr(nmp, NULL, thd, 0))) {
return error;
}
}
if (wentdown) {
nfs_up(nmp, thd, NFSSTA_TIMEO, "connected");
}
lck_mtx_lock(nfs_request_mutex);
TAILQ_FOREACH(rq, &nfs_reqq, r_chain) {
if (rq->r_nmp == nmp) {
lck_mtx_lock(&rq->r_mtx);
if (!rq->r_error && !rq->r_nmrep.nmc_mhead && !(rq->r_flags & R_MUSTRESEND)) {
rq->r_flags |= R_MUSTRESEND;
rq->r_rtt = -1;
wakeup(rq);
if ((rq->r_flags & (R_IOD | R_ASYNC | R_ASYNCWAIT | R_SENDING)) == R_ASYNC) {
nfs_asyncio_resend(rq);
}
}
lck_mtx_unlock(&rq->r_mtx);
}
}
lck_mtx_unlock(nfs_request_mutex);
return 0;
}
void
nfs_disconnect(struct nfsmount *nmp)
{
struct nfs_socket *nso;
lck_mtx_lock(&nmp->nm_lock);
tryagain:
if (nmp->nm_nso) {
struct timespec ts = { .tv_sec = 1, .tv_nsec = 0 };
if (nmp->nm_state & NFSSTA_SENDING) {
nmp->nm_state |= NFSSTA_WANTSND;
msleep(&nmp->nm_state, &nmp->nm_lock, PZERO - 1, "nfswaitsending", &ts);
goto tryagain;
}
if (nmp->nm_sockflags & NMSOCK_POKE) {
msleep(&nmp->nm_sockflags, &nmp->nm_lock, PZERO - 1, "nfswaitpoke", &ts);
goto tryagain;
}
nmp->nm_sockflags |= NMSOCK_DISCONNECTING;
nmp->nm_sockflags &= ~NMSOCK_READY;
nso = nmp->nm_nso;
nmp->nm_nso = NULL;
if (nso->nso_saddr == nmp->nm_saddr) {
nso->nso_saddr = NULL;
}
lck_mtx_unlock(&nmp->nm_lock);
nfs_socket_destroy(nso);
lck_mtx_lock(&nmp->nm_lock);
nmp->nm_sockflags &= ~NMSOCK_DISCONNECTING;
lck_mtx_unlock(&nmp->nm_lock);
} else {
lck_mtx_unlock(&nmp->nm_lock);
}
}
void
nfs_need_reconnect(struct nfsmount *nmp)
{
struct nfsreq *rq;
lck_mtx_lock(&nmp->nm_lock);
nmp->nm_sockflags &= ~(NMSOCK_READY | NMSOCK_SETUP);
lck_mtx_unlock(&nmp->nm_lock);
lck_mtx_lock(nfs_request_mutex);
TAILQ_FOREACH(rq, &nfs_reqq, r_chain) {
if (rq->r_nmp == nmp) {
lck_mtx_lock(&rq->r_mtx);
if (!rq->r_error && !rq->r_nmrep.nmc_mhead && !(rq->r_flags & R_MUSTRESEND)) {
rq->r_flags |= R_MUSTRESEND;
rq->r_rtt = -1;
wakeup(rq);
if ((rq->r_flags & (R_IOD | R_ASYNC | R_ASYNCWAIT | R_SENDING)) == R_ASYNC) {
nfs_asyncio_resend(rq);
}
}
lck_mtx_unlock(&rq->r_mtx);
}
}
lck_mtx_unlock(nfs_request_mutex);
}
void
nfs_mount_sock_thread(void *arg, __unused wait_result_t wr)
{
struct nfsmount *nmp = arg;
struct timespec ts = { .tv_sec = 30, .tv_nsec = 0 };
thread_t thd = current_thread();
struct nfsreq *req;
struct timeval now;
int error, dofinish;
nfsnode_t np;
int do_reconnect_sleep = 0;
lck_mtx_lock(&nmp->nm_lock);
while (!(nmp->nm_sockflags & NMSOCK_READY) ||
!TAILQ_EMPTY(&nmp->nm_resendq) ||
!LIST_EMPTY(&nmp->nm_monlist) ||
nmp->nm_deadto_start ||
(nmp->nm_state & NFSSTA_RECOVER) ||
((nmp->nm_vers >= NFS_VER4) && !TAILQ_EMPTY(&nmp->nm_dreturnq))) {
if (nmp->nm_sockflags & NMSOCK_UNMOUNT) {
break;
}
if (!(nmp->nm_sockflags & NMSOCK_READY) && !(nmp->nm_state & (NFSSTA_FORCE | NFSSTA_DEAD))) {
if (nmp->nm_reconnect_start <= 0) {
microuptime(&now);
nmp->nm_reconnect_start = now.tv_sec;
}
lck_mtx_unlock(&nmp->nm_lock);
NFS_SOCK_DBG("nfs reconnect %s\n", vfs_statfs(nmp->nm_mountp)->f_mntfromname);
if (do_reconnect_sleep) {
tsleep(nfs_mount_sock_thread, PSOCK, "nfs_reconnect_sock_thread_delay", hz);
}
error = nfs_reconnect(nmp);
if (error) {
int lvl = 7;
if (error == EIO || error == EINTR) {
lvl = (do_reconnect_sleep++ % 600) ? 7 : 0;
}
NFS_DBG(NFS_FAC_SOCK, lvl, "nfs reconnect %s: returned %d\n",
vfs_statfs(nmp->nm_mountp)->f_mntfromname, error);
} else {
nmp->nm_reconnect_start = 0;
do_reconnect_sleep = 0;
}
lck_mtx_lock(&nmp->nm_lock);
}
if ((nmp->nm_sockflags & NMSOCK_READY) &&
(nmp->nm_state & NFSSTA_RECOVER) &&
!(nmp->nm_sockflags & NMSOCK_UNMOUNT) &&
!(nmp->nm_state & (NFSSTA_FORCE | NFSSTA_DEAD))) {
lck_mtx_unlock(&nmp->nm_lock);
nfs_recover(nmp);
lck_mtx_lock(&nmp->nm_lock);
}
#if CONFIG_NFS4
while ((nmp->nm_vers >= NFS_VER4) && !(nmp->nm_state & (NFSSTA_FORCE | NFSSTA_DEAD)) &&
(nmp->nm_sockflags & NMSOCK_READY) && !(nmp->nm_state & NFSSTA_RECOVER) &&
((np = TAILQ_FIRST(&nmp->nm_dreturnq)))) {
lck_mtx_unlock(&nmp->nm_lock);
nfs4_delegation_return(np, R_RECOVER, thd, nmp->nm_mcred);
lck_mtx_lock(&nmp->nm_lock);
}
#endif
while ((((nmp->nm_sockflags & NMSOCK_READY) && !(nmp->nm_state & NFSSTA_RECOVER)) ||
(nmp->nm_state & (NFSSTA_FORCE | NFSSTA_DEAD))) &&
((req = TAILQ_FIRST(&nmp->nm_resendq)))) {
if (req->r_resendtime) {
microuptime(&now);
}
while (req && !(nmp->nm_state & (NFSSTA_FORCE | NFSSTA_DEAD)) && req->r_resendtime && (now.tv_sec < req->r_resendtime)) {
req = TAILQ_NEXT(req, r_rchain);
}
if (!req) {
break;
}
TAILQ_REMOVE(&nmp->nm_resendq, req, r_rchain);
req->r_rchain.tqe_next = NFSREQNOLIST;
lck_mtx_unlock(&nmp->nm_lock);
lck_mtx_lock(&req->r_mtx);
if (req->r_error || req->r_nmrep.nmc_mhead) {
dofinish = req->r_callback.rcb_func && !(req->r_flags & R_WAITSENT);
req->r_flags &= ~R_RESENDQ;
wakeup(req);
lck_mtx_unlock(&req->r_mtx);
if (dofinish) {
nfs_asyncio_finish(req);
}
nfs_request_rele(req);
lck_mtx_lock(&nmp->nm_lock);
continue;
}
if ((req->r_flags & R_RESTART) || nfs_request_using_gss(req)) {
req->r_flags &= ~R_RESTART;
req->r_resendtime = 0;
lck_mtx_unlock(&req->r_mtx);
nfs_reqdequeue(req);
#if CONFIG_NFS_GSS
if (nfs_request_using_gss(req)) {
nfs_gss_clnt_rpcdone(req);
error = nfs_gss_clnt_args_restore(req);
if (error == ENEEDAUTH) {
req->r_xid = 0;
}
}
#endif
NFS_SOCK_DBG("nfs async%s restart: p %d x 0x%llx f 0x%x rtt %d\n",
nfs_request_using_gss(req) ? " gss" : "", req->r_procnum, req->r_xid,
req->r_flags, req->r_rtt);
error = nfs_sigintr(nmp, req, req->r_thread, 0);
if (!error) {
error = nfs_request_add_header(req);
}
if (!error) {
error = nfs_request_send(req, 0);
}
lck_mtx_lock(&req->r_mtx);
if (req->r_flags & R_RESENDQ) {
req->r_flags &= ~R_RESENDQ;
}
if (error) {
req->r_error = error;
}
wakeup(req);
dofinish = error && req->r_callback.rcb_func && !(req->r_flags & R_WAITSENT);
lck_mtx_unlock(&req->r_mtx);
if (dofinish) {
nfs_asyncio_finish(req);
}
nfs_request_rele(req);
lck_mtx_lock(&nmp->nm_lock);
error = 0;
continue;
}
NFS_SOCK_DBG("nfs async resend: p %d x 0x%llx f 0x%x rtt %d\n",
req->r_procnum, req->r_xid, req->r_flags, req->r_rtt);
error = nfs_sigintr(nmp, req, req->r_thread, 0);
if (!error) {
req->r_flags |= R_SENDING;
lck_mtx_unlock(&req->r_mtx);
error = nfs_send(req, 0);
lck_mtx_lock(&req->r_mtx);
if (!error) {
if (req->r_flags & R_RESENDQ) {
req->r_flags &= ~R_RESENDQ;
}
wakeup(req);
lck_mtx_unlock(&req->r_mtx);
nfs_request_rele(req);
lck_mtx_lock(&nmp->nm_lock);
continue;
}
}
req->r_error = error;
if (req->r_flags & R_RESENDQ) {
req->r_flags &= ~R_RESENDQ;
}
wakeup(req);
dofinish = req->r_callback.rcb_func && !(req->r_flags & R_WAITSENT);
lck_mtx_unlock(&req->r_mtx);
if (dofinish) {
nfs_asyncio_finish(req);
}
nfs_request_rele(req);
lck_mtx_lock(&nmp->nm_lock);
}
if (nfs_mount_check_dead_timeout(nmp)) {
nfs_mount_make_zombie(nmp);
break;
}
if (nmp->nm_state & (NFSSTA_FORCE | NFSSTA_DEAD)) {
break;
}
if (!LIST_EMPTY(&nmp->nm_monlist)) {
nmp->nm_state |= NFSSTA_MONITOR_SCAN;
LIST_FOREACH(np, &nmp->nm_monlist, n_monlink) {
if (!(nmp->nm_sockflags & NMSOCK_READY) ||
(nmp->nm_state & (NFSSTA_RECOVER | NFSSTA_UNMOUNTING | NFSSTA_FORCE | NFSSTA_DEAD))) {
break;
}
np->n_mflag |= NMMONSCANINPROG;
lck_mtx_unlock(&nmp->nm_lock);
error = nfs_getattr(np, NULL, vfs_context_kernel(), (NGA_UNCACHED | NGA_MONITOR));
if (!error && ISSET(np->n_flag, NUPDATESIZE)) {
nfs_data_update_size(np, 0);
}
lck_mtx_lock(&nmp->nm_lock);
np->n_mflag &= ~NMMONSCANINPROG;
if (np->n_mflag & NMMONSCANWANT) {
np->n_mflag &= ~NMMONSCANWANT;
wakeup(&np->n_mflag);
}
if (error || !(nmp->nm_sockflags & NMSOCK_READY) ||
(nmp->nm_state & (NFSSTA_RECOVER | NFSSTA_UNMOUNTING | NFSSTA_FORCE | NFSSTA_DEAD))) {
break;
}
}
nmp->nm_state &= ~NFSSTA_MONITOR_SCAN;
if (nmp->nm_state & NFSSTA_UNMOUNTING) {
wakeup(&nmp->nm_state);
}
}
if ((nmp->nm_sockflags & NMSOCK_READY) || (nmp->nm_state & (NFSSTA_RECOVER | NFSSTA_UNMOUNTING))) {
if (nmp->nm_deadto_start || !TAILQ_EMPTY(&nmp->nm_resendq) ||
(nmp->nm_state & NFSSTA_RECOVER)) {
ts.tv_sec = 1;
} else {
ts.tv_sec = 5;
}
msleep(&nmp->nm_sockthd, &nmp->nm_lock, PSOCK, "nfssockthread", &ts);
}
}
if ((nmp->nm_sockflags & NMSOCK_UNMOUNT) &&
(nmp->nm_state & NFSSTA_MOUNTED) && NMFLAG(nmp, CALLUMNT) &&
(nmp->nm_vers < NFS_VER4) && !(nmp->nm_state & (NFSSTA_FORCE | NFSSTA_DEAD))) {
lck_mtx_unlock(&nmp->nm_lock);
nfs3_umount_rpc(nmp, vfs_context_kernel(),
(nmp->nm_sockflags & NMSOCK_READY) ? 6 : 2);
lck_mtx_lock(&nmp->nm_lock);
}
if (nmp->nm_sockthd == thd) {
nmp->nm_sockthd = NULL;
}
lck_mtx_unlock(&nmp->nm_lock);
wakeup(&nmp->nm_sockthd);
thread_terminate(thd);
}
void
nfs_mount_sock_thread_wake(struct nfsmount *nmp)
{
if (nmp->nm_sockthd) {
wakeup(&nmp->nm_sockthd);
} else if (kernel_thread_start(nfs_mount_sock_thread, nmp, &nmp->nm_sockthd) == KERN_SUCCESS) {
thread_deallocate(nmp->nm_sockthd);
}
}
int
nfs_mount_check_dead_timeout(struct nfsmount *nmp)
{
struct timeval now;
if (nmp->nm_state & NFSSTA_DEAD) {
return 1;
}
if (nmp->nm_deadto_start == 0) {
return 0;
}
nfs_is_squishy(nmp);
if (nmp->nm_curdeadtimeout <= 0) {
return 0;
}
microuptime(&now);
if ((now.tv_sec - nmp->nm_deadto_start) < nmp->nm_curdeadtimeout) {
return 0;
}
return 1;
}
void
nfs_mount_make_zombie(struct nfsmount *nmp)
{
fsid_t fsid;
if (!nmp) {
return;
}
if (nmp->nm_state & NFSSTA_DEAD) {
return;
}
printf("nfs server %s: %sdead\n", vfs_statfs(nmp->nm_mountp)->f_mntfromname,
(nmp->nm_curdeadtimeout != nmp->nm_deadtimeout) ? "squished " : "");
fsid = vfs_statfs(nmp->nm_mountp)->f_fsid;
lck_mtx_unlock(&nmp->nm_lock);
nfs_mount_zombie(nmp, NFSSTA_DEAD);
vfs_event_signal(&fsid, VQ_DEAD, 0);
lck_mtx_lock(&nmp->nm_lock);
}
struct nfs_callback_socket {
TAILQ_ENTRY(nfs_callback_socket) ncbs_link;
socket_t ncbs_so;
struct sockaddr_storage ncbs_saddr;
struct nfs_rpc_record_state ncbs_rrs;
time_t ncbs_stamp;
uint32_t ncbs_flags;
};
#define NCBSOCK_UPCALL 0x0001
#define NCBSOCK_UPCALLWANT 0x0002
#define NCBSOCK_DEAD 0x0004
#if CONFIG_NFS4
socket_t nfs4_cb_so = NULL;
socket_t nfs4_cb_so6 = NULL;
in_port_t nfs4_cb_port = 0;
in_port_t nfs4_cb_port6 = 0;
uint32_t nfs4_cb_id = 0;
uint32_t nfs4_cb_so_usecount = 0;
TAILQ_HEAD(nfs4_cb_sock_list, nfs_callback_socket) nfs4_cb_socks;
TAILQ_HEAD(nfs4_cb_mount_list, nfsmount) nfs4_cb_mounts;
int nfs4_cb_handler(struct nfs_callback_socket *, mbuf_t);
void
nfs4_mount_callback_setup(struct nfsmount *nmp)
{
struct sockaddr_in sin;
struct sockaddr_in6 sin6;
socket_t so = NULL;
socket_t so6 = NULL;
struct timeval timeo;
int error, on = 1;
in_port_t port;
lck_mtx_lock(nfs_global_mutex);
if (nfs4_cb_id == 0) {
TAILQ_INIT(&nfs4_cb_mounts);
TAILQ_INIT(&nfs4_cb_socks);
nfs4_cb_id++;
}
nmp->nm_cbid = nfs4_cb_id++;
if (nmp->nm_cbid == 0) {
nmp->nm_cbid = nfs4_cb_id++;
}
nfs4_cb_so_usecount++;
TAILQ_INSERT_HEAD(&nfs4_cb_mounts, nmp, nm_cblink);
if (nfs4_cb_so) {
lck_mtx_unlock(nfs_global_mutex);
return;
}
error = sock_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP, nfs4_cb_accept, NULL, &nfs4_cb_so);
if (error) {
log(LOG_INFO, "nfs callback setup: error %d creating listening IPv4 socket\n", error);
goto fail;
}
so = nfs4_cb_so;
sock_setsockopt(so, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
sin.sin_len = sizeof(struct sockaddr_in);
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(INADDR_ANY);
sin.sin_port = htons(nfs_callback_port);
error = sock_bind(so, (struct sockaddr *)&sin);
if (error) {
log(LOG_INFO, "nfs callback setup: error %d binding listening IPv4 socket\n", error);
goto fail;
}
error = sock_getsockname(so, (struct sockaddr *)&sin, sin.sin_len);
if (error) {
log(LOG_INFO, "nfs callback setup: error %d getting listening IPv4 socket port\n", error);
goto fail;
}
nfs4_cb_port = ntohs(sin.sin_port);
error = sock_listen(so, 32);
if (error) {
log(LOG_INFO, "nfs callback setup: error %d on IPv4 listen\n", error);
goto fail;
}
timeo.tv_usec = 0;
timeo.tv_sec = 60;
error = sock_setsockopt(so, SOL_SOCKET, SO_RCVTIMEO, &timeo, sizeof(timeo));
if (error) {
log(LOG_INFO, "nfs callback setup: error %d setting IPv4 socket rx timeout\n", error);
}
error = sock_setsockopt(so, SOL_SOCKET, SO_SNDTIMEO, &timeo, sizeof(timeo));
if (error) {
log(LOG_INFO, "nfs callback setup: error %d setting IPv4 socket tx timeout\n", error);
}
sock_setsockopt(so, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on));
sock_setsockopt(so, SOL_SOCKET, SO_NOADDRERR, &on, sizeof(on));
sock_setsockopt(so, SOL_SOCKET, SO_UPCALLCLOSEWAIT, &on, sizeof(on));
error = 0;
error = sock_socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, nfs4_cb_accept, NULL, &nfs4_cb_so6);
if (error) {
log(LOG_INFO, "nfs callback setup: error %d creating listening IPv6 socket\n", error);
goto fail;
}
so6 = nfs4_cb_so6;
sock_setsockopt(so6, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
sock_setsockopt(so6, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on));
port = nfs_callback_port ? nfs_callback_port : nfs4_cb_port;
ipv6_bind_again:
sin6.sin6_len = sizeof(struct sockaddr_in6);
sin6.sin6_family = AF_INET6;
sin6.sin6_addr = in6addr_any;
sin6.sin6_port = htons(port);
error = sock_bind(so6, (struct sockaddr *)&sin6);
if (error) {
if (port != nfs_callback_port) {
port = 0;
goto ipv6_bind_again;
}
log(LOG_INFO, "nfs callback setup: error %d binding listening IPv6 socket\n", error);
goto fail;
}
error = sock_getsockname(so6, (struct sockaddr *)&sin6, sin6.sin6_len);
if (error) {
log(LOG_INFO, "nfs callback setup: error %d getting listening IPv6 socket port\n", error);
goto fail;
}
nfs4_cb_port6 = ntohs(sin6.sin6_port);
error = sock_listen(so6, 32);
if (error) {
log(LOG_INFO, "nfs callback setup: error %d on IPv6 listen\n", error);
goto fail;
}
timeo.tv_usec = 0;
timeo.tv_sec = 60;
error = sock_setsockopt(so6, SOL_SOCKET, SO_RCVTIMEO, &timeo, sizeof(timeo));
if (error) {
log(LOG_INFO, "nfs callback setup: error %d setting IPv6 socket rx timeout\n", error);
}
error = sock_setsockopt(so6, SOL_SOCKET, SO_SNDTIMEO, &timeo, sizeof(timeo));
if (error) {
log(LOG_INFO, "nfs callback setup: error %d setting IPv6 socket tx timeout\n", error);
}
sock_setsockopt(so6, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on));
sock_setsockopt(so6, SOL_SOCKET, SO_NOADDRERR, &on, sizeof(on));
sock_setsockopt(so6, SOL_SOCKET, SO_UPCALLCLOSEWAIT, &on, sizeof(on));
error = 0;
fail:
if (error) {
nfs4_cb_so = nfs4_cb_so6 = NULL;
lck_mtx_unlock(nfs_global_mutex);
if (so) {
sock_shutdown(so, SHUT_RDWR);
sock_close(so);
}
if (so6) {
sock_shutdown(so6, SHUT_RDWR);
sock_close(so6);
}
} else {
lck_mtx_unlock(nfs_global_mutex);
}
}
void
nfs4_mount_callback_shutdown(struct nfsmount *nmp)
{
struct nfs_callback_socket *ncbsp;
socket_t so, so6;
struct nfs4_cb_sock_list cb_socks;
struct timespec ts = { .tv_sec = 1, .tv_nsec = 0 };
lck_mtx_lock(nfs_global_mutex);
TAILQ_REMOVE(&nfs4_cb_mounts, nmp, nm_cblink);
while (nmp->nm_cbrefs) {
msleep(&nmp->nm_cbrefs, nfs_global_mutex, PSOCK, "cbshutwait", &ts);
}
nmp->nm_cbid = 0;
if (--nfs4_cb_so_usecount) {
lck_mtx_unlock(nfs_global_mutex);
return;
}
so = nfs4_cb_so;
so6 = nfs4_cb_so6;
nfs4_cb_so = nfs4_cb_so6 = NULL;
TAILQ_INIT(&cb_socks);
TAILQ_CONCAT(&cb_socks, &nfs4_cb_socks, ncbs_link);
lck_mtx_unlock(nfs_global_mutex);
if (so) {
sock_shutdown(so, SHUT_RDWR);
sock_close(so);
}
if (so6) {
sock_shutdown(so6, SHUT_RDWR);
sock_close(so6);
}
while ((ncbsp = TAILQ_FIRST(&cb_socks))) {
TAILQ_REMOVE(&cb_socks, ncbsp, ncbs_link);
sock_shutdown(ncbsp->ncbs_so, SHUT_RDWR);
sock_close(ncbsp->ncbs_so);
nfs_rpc_record_state_cleanup(&ncbsp->ncbs_rrs);
FREE(ncbsp, M_TEMP);
}
}
#define NFS4_CB_TIMER_PERIOD 30
#define NFS4_CB_IDLE_MAX 300
void
nfs4_callback_timer(__unused void *param0, __unused void *param1)
{
struct nfs_callback_socket *ncbsp, *nextncbsp;
struct timeval now;
loop:
lck_mtx_lock(nfs_global_mutex);
if (TAILQ_EMPTY(&nfs4_cb_socks)) {
nfs4_callback_timer_on = 0;
lck_mtx_unlock(nfs_global_mutex);
return;
}
microuptime(&now);
TAILQ_FOREACH_SAFE(ncbsp, &nfs4_cb_socks, ncbs_link, nextncbsp) {
if (!(ncbsp->ncbs_flags & NCBSOCK_DEAD) &&
(now.tv_sec < (ncbsp->ncbs_stamp + NFS4_CB_IDLE_MAX))) {
continue;
}
TAILQ_REMOVE(&nfs4_cb_socks, ncbsp, ncbs_link);
lck_mtx_unlock(nfs_global_mutex);
sock_shutdown(ncbsp->ncbs_so, SHUT_RDWR);
sock_close(ncbsp->ncbs_so);
nfs_rpc_record_state_cleanup(&ncbsp->ncbs_rrs);
FREE(ncbsp, M_TEMP);
goto loop;
}
nfs4_callback_timer_on = 1;
nfs_interval_timer_start(nfs4_callback_timer_call,
NFS4_CB_TIMER_PERIOD * 1000);
lck_mtx_unlock(nfs_global_mutex);
}
void
nfs4_cb_accept(socket_t so, __unused void *arg, __unused int waitflag)
{
socket_t newso = NULL;
struct nfs_callback_socket *ncbsp;
struct nfsmount *nmp;
struct timeval timeo, now;
int error, on = 1, ip;
if (so == nfs4_cb_so) {
ip = 4;
} else if (so == nfs4_cb_so6) {
ip = 6;
} else {
return;
}
MALLOC(ncbsp, struct nfs_callback_socket *, sizeof(struct nfs_callback_socket), M_TEMP, M_WAITOK);
if (!ncbsp) {
log(LOG_ERR, "nfs callback accept: no memory for new socket\n");
return;
}
bzero(ncbsp, sizeof(*ncbsp));
ncbsp->ncbs_saddr.ss_len = (ip == 4) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6);
nfs_rpc_record_state_init(&ncbsp->ncbs_rrs);
error = sock_accept(so, (struct sockaddr*)&ncbsp->ncbs_saddr,
ncbsp->ncbs_saddr.ss_len, MSG_DONTWAIT,
nfs4_cb_rcv, ncbsp, &newso);
if (error) {
log(LOG_INFO, "nfs callback accept: error %d accepting IPv%d socket\n", error, ip);
FREE(ncbsp, M_TEMP);
return;
}
timeo.tv_usec = 0;
timeo.tv_sec = 60;
error = sock_setsockopt(newso, SOL_SOCKET, SO_RCVTIMEO, &timeo, sizeof(timeo));
if (error) {
log(LOG_INFO, "nfs callback socket: error %d setting IPv%d socket rx timeout\n", error, ip);
}
error = sock_setsockopt(newso, SOL_SOCKET, SO_SNDTIMEO, &timeo, sizeof(timeo));
if (error) {
log(LOG_INFO, "nfs callback socket: error %d setting IPv%d socket tx timeout\n", error, ip);
}
sock_setsockopt(newso, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on));
sock_setsockopt(newso, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
sock_setsockopt(newso, SOL_SOCKET, SO_NOADDRERR, &on, sizeof(on));
sock_setsockopt(newso, SOL_SOCKET, SO_UPCALLCLOSEWAIT, &on, sizeof(on));
ncbsp->ncbs_so = newso;
microuptime(&now);
ncbsp->ncbs_stamp = now.tv_sec;
lck_mtx_lock(nfs_global_mutex);
TAILQ_INSERT_HEAD(&nfs4_cb_socks, ncbsp, ncbs_link);
TAILQ_FOREACH(nmp, &nfs4_cb_mounts, nm_cblink) {
if (!nmp->nm_saddr) {
continue;
}
if (nfs_sockaddr_cmp((struct sockaddr*)&ncbsp->ncbs_saddr, nmp->nm_saddr) == 0) {
break;
}
}
if (!nmp) {
ncbsp->ncbs_flags |= NCBSOCK_DEAD;
}
if (!nfs4_callback_timer_on) {
nfs4_callback_timer_on = 1;
nfs_interval_timer_start(nfs4_callback_timer_call,
!nmp ? 500 : (NFS4_CB_TIMER_PERIOD * 1000));
} else if (!nmp && (nfs4_callback_timer_on < 2)) {
nfs4_callback_timer_on = 2;
thread_call_cancel(nfs4_callback_timer_call);
nfs_interval_timer_start(nfs4_callback_timer_call, 500);
}
lck_mtx_unlock(nfs_global_mutex);
}
void
nfs4_cb_rcv(socket_t so, void *arg, __unused int waitflag)
{
struct nfs_callback_socket *ncbsp = arg;
struct timespec ts = { .tv_sec = 1, .tv_nsec = 0 };
struct timeval now;
mbuf_t m;
int error = 0, recv = 1;
lck_mtx_lock(nfs_global_mutex);
while (ncbsp->ncbs_flags & NCBSOCK_UPCALL) {
ncbsp->ncbs_flags |= NCBSOCK_UPCALLWANT;
msleep(ncbsp, nfs_global_mutex, PSOCK, "cbupcall", &ts);
}
ncbsp->ncbs_flags |= NCBSOCK_UPCALL;
lck_mtx_unlock(nfs_global_mutex);
while (!error && recv) {
error = nfs_rpc_record_read(so, &ncbsp->ncbs_rrs, MSG_DONTWAIT, &recv, &m);
if (m) {
error = nfs4_cb_handler(ncbsp, m);
}
}
if ((error != EWOULDBLOCK) && (error || !recv)) {
ncbsp->ncbs_stamp = 0;
ncbsp->ncbs_flags |= NCBSOCK_DEAD;
} else {
microuptime(&now);
ncbsp->ncbs_stamp = now.tv_sec;
}
lck_mtx_lock(nfs_global_mutex);
ncbsp->ncbs_flags &= ~NCBSOCK_UPCALL;
lck_mtx_unlock(nfs_global_mutex);
wakeup(ncbsp);
}
int
nfs4_cb_handler(struct nfs_callback_socket *ncbsp, mbuf_t mreq)
{
socket_t so = ncbsp->ncbs_so;
struct nfsm_chain nmreq, nmrep;
mbuf_t mhead = NULL, mrest = NULL, m;
struct msghdr msg;
struct nfsmount *nmp;
fhandle_t fh;
nfsnode_t np;
nfs_stateid stateid;
uint32_t bitmap[NFS_ATTR_BITMAP_LEN], rbitmap[NFS_ATTR_BITMAP_LEN], bmlen, truncate, attrbytes;
uint32_t val, xid, procnum, taglen, cbid, numops, op, status;
uint32_t auth_type, auth_len;
uint32_t numres, *pnumres;
int error = 0, replen, len;
size_t sentlen = 0;
xid = numops = op = status = procnum = taglen = cbid = 0;
nfsm_chain_dissect_init(error, &nmreq, mreq);
nfsm_chain_get_32(error, &nmreq, xid); nfsm_chain_get_32(error, &nmreq, val); nfsm_assert(error, (val == RPC_CALL), EBADRPC);
nfsm_chain_get_32(error, &nmreq, val); nfsm_assert(error, (val == RPC_VER2), ERPCMISMATCH);
nfsm_chain_get_32(error, &nmreq, val); nfsm_assert(error, (val == NFS4_CALLBACK_PROG), EPROGUNAVAIL);
nfsm_chain_get_32(error, &nmreq, val); nfsm_assert(error, (val == NFS4_CALLBACK_PROG_VERSION), EPROGMISMATCH);
nfsm_chain_get_32(error, &nmreq, procnum); nfsm_assert(error, (procnum <= NFSPROC4_CB_COMPOUND), EPROCUNAVAIL);
nfsm_chain_get_32(error, &nmreq, auth_type); nfsm_chain_get_32(error, &nmreq, auth_len); nfsm_assert(error, (auth_len <= RPCAUTH_MAXSIZ), EBADRPC);
if (!error && (auth_len > 0)) {
nfsm_chain_adv(error, &nmreq, nfsm_rndup(auth_len));
}
nfsm_chain_adv(error, &nmreq, NFSX_UNSIGNED); nfsm_chain_get_32(error, &nmreq, auth_len); nfsm_assert(error, (auth_len <= RPCAUTH_MAXSIZ), EBADRPC);
if (!error && (auth_len > 0)) {
nfsm_chain_adv(error, &nmreq, nfsm_rndup(auth_len));
}
if (error) {
status = error;
error = 0;
goto nfsmout;
}
switch (procnum) {
case NFSPROC4_CB_NULL:
status = NFSERR_RETVOID;
break;
case NFSPROC4_CB_COMPOUND:
nfsm_chain_get_32(error, &nmreq, taglen);
nfsm_assert(error, (val <= NFS4_OPAQUE_LIMIT), EBADRPC);
nfsm_mbuf_get(error, &mrest, nfsm_rndup(taglen) + 5 * NFSX_UNSIGNED);
nfsm_chain_init(&nmrep, mrest);
nfsm_chain_add_32(error, &nmrep, taglen);
for (len = (int)taglen; !error && (len > 0); len -= NFSX_UNSIGNED) {
nfsm_chain_get_32(error, &nmreq, val);
nfsm_chain_add_32(error, &nmrep, val);
}
numres = 0;
nfsm_chain_add_32(error, &nmrep, numres);
pnumres = (uint32_t*)(nmrep.nmc_ptr - NFSX_UNSIGNED);
nfsm_chain_get_32(error, &nmreq, val);
nfsm_assert(error, (val == 0), NFSERR_MINOR_VERS_MISMATCH);
nfsm_chain_get_32(error, &nmreq, cbid);
nfsm_chain_get_32(error, &nmreq, numops);
if (error) {
if ((error == EBADRPC) || (error == NFSERR_MINOR_VERS_MISMATCH)) {
status = error;
} else if ((error == ENOBUFS) || (error == ENOMEM)) {
status = NFSERR_RESOURCE;
} else {
status = NFSERR_SERVERFAULT;
}
error = 0;
nfsm_chain_null(&nmrep);
goto nfsmout;
}
lck_mtx_lock(nfs_global_mutex);
TAILQ_FOREACH(nmp, &nfs4_cb_mounts, nm_cblink) {
if (nmp->nm_cbid != cbid) {
continue;
}
if (!nmp->nm_saddr) {
continue;
}
if (nfs_sockaddr_cmp((struct sockaddr*)&ncbsp->ncbs_saddr, nmp->nm_saddr) == 0) {
break;
}
}
if (nmp) {
nmp->nm_cbrefs++;
}
lck_mtx_unlock(nfs_global_mutex);
if (!nmp) {
error = EPERM;
nfsm_chain_null(&nmrep);
goto out;
}
while (numops > 0) {
numops--;
nfsm_chain_get_32(error, &nmreq, op);
if (error) {
break;
}
switch (op) {
case NFS_OP_CB_GETATTR:
np = NULL;
nfsm_chain_get_fh(error, &nmreq, NFS_VER4, &fh);
bmlen = NFS_ATTR_BITMAP_LEN;
nfsm_chain_get_bitmap(error, &nmreq, bitmap, bmlen);
if (error) {
status = error;
error = 0;
numops = 0;
} else {
error = nfs_nget(nmp->nm_mountp, NULL, NULL, fh.fh_data, fh.fh_len, NULL, NULL, RPCAUTH_UNKNOWN, NG_NOCREATE, &np);
if (error || !np) {
status = NFSERR_BADHANDLE;
error = 0;
np = NULL;
numops = 0;
}
}
nfsm_chain_add_32(error, &nmrep, op);
nfsm_chain_add_32(error, &nmrep, status);
if (!error && (status == EBADRPC)) {
error = status;
}
if (np) {
NFS_CLEAR_ATTRIBUTES(&rbitmap);
attrbytes = 0;
if (NFS_BITMAP_ISSET(&bitmap, NFS_FATTR_CHANGE)) {
NFS_BITMAP_SET(&rbitmap, NFS_FATTR_CHANGE);
attrbytes += 2 * NFSX_UNSIGNED;
}
if (NFS_BITMAP_ISSET(&bitmap, NFS_FATTR_SIZE)) {
NFS_BITMAP_SET(&rbitmap, NFS_FATTR_SIZE);
attrbytes += 2 * NFSX_UNSIGNED;
}
if (NFS_BITMAP_ISSET(&bitmap, NFS_FATTR_TIME_MODIFY)) {
NFS_BITMAP_SET(&rbitmap, NFS_FATTR_TIME_MODIFY);
attrbytes += 3 * NFSX_UNSIGNED;
}
nfsm_chain_add_bitmap(error, &nmrep, rbitmap, NFS_ATTR_BITMAP_LEN);
nfsm_chain_add_32(error, &nmrep, attrbytes);
if (NFS_BITMAP_ISSET(&bitmap, NFS_FATTR_CHANGE)) {
nfsm_chain_add_64(error, &nmrep,
np->n_vattr.nva_change + ((np->n_flag & NMODIFIED) ? 1 : 0));
}
if (NFS_BITMAP_ISSET(&bitmap, NFS_FATTR_SIZE)) {
nfsm_chain_add_64(error, &nmrep, np->n_size);
}
if (NFS_BITMAP_ISSET(&bitmap, NFS_FATTR_TIME_MODIFY)) {
nfsm_chain_add_64(error, &nmrep, np->n_vattr.nva_timesec[NFSTIME_MODIFY]);
nfsm_chain_add_32(error, &nmrep, np->n_vattr.nva_timensec[NFSTIME_MODIFY]);
}
nfs_node_unlock(np);
vnode_put(NFSTOV(np));
np = NULL;
}
break;
case NFS_OP_CB_RECALL:
np = NULL;
nfsm_chain_get_stateid(error, &nmreq, &stateid);
nfsm_chain_get_32(error, &nmreq, truncate);
nfsm_chain_get_fh(error, &nmreq, NFS_VER4, &fh);
if (error) {
status = error;
error = 0;
numops = 0;
} else {
error = nfs_nget(nmp->nm_mountp, NULL, NULL, fh.fh_data, fh.fh_len, NULL, NULL, RPCAUTH_UNKNOWN, NG_NOCREATE, &np);
if (error || !np) {
status = NFSERR_BADHANDLE;
error = 0;
np = NULL;
numops = 0;
} else if (!(np->n_openflags & N_DELEG_MASK) ||
bcmp(&np->n_dstateid, &stateid, sizeof(stateid))) {
status = NFSERR_BAD_STATEID;
numops = 0;
}
if (!status) {
nfs4_delegation_return_enqueue(np);
}
if (np) {
nfs_node_unlock(np);
vnode_put(NFSTOV(np));
}
}
nfsm_chain_add_32(error, &nmrep, op);
nfsm_chain_add_32(error, &nmrep, status);
if (!error && (status == EBADRPC)) {
error = status;
}
break;
case NFS_OP_CB_ILLEGAL:
default:
nfsm_chain_add_32(error, &nmrep, NFS_OP_CB_ILLEGAL);
status = NFSERR_OP_ILLEGAL;
nfsm_chain_add_32(error, &nmrep, status);
numops = 0;
break;
}
numres++;
}
if (!status && error) {
if (error == EBADRPC) {
status = error;
} else if ((error == ENOBUFS) || (error == ENOMEM)) {
status = NFSERR_RESOURCE;
} else {
status = NFSERR_SERVERFAULT;
}
error = 0;
}
*pnumres = txdr_unsigned(numres);
nfsm_chain_build_done(error, &nmrep);
nfsm_chain_null(&nmrep);
lck_mtx_lock(nfs_global_mutex);
nmp->nm_cbrefs--;
if (!nmp->nm_cbid) {
wakeup(&nmp->nm_cbrefs);
}
lck_mtx_unlock(nfs_global_mutex);
break;
}
nfsmout:
if (status == EBADRPC) {
OSAddAtomic64(1, &nfsstats.rpcinvalid);
}
error = mbuf_gethdr(MBUF_WAITOK, MBUF_TYPE_DATA, &mhead);
nfsm_chain_init(&nmrep, mhead);
nfsm_chain_add_32(error, &nmrep, 0);
nfsm_chain_add_32(error, &nmrep, xid);
nfsm_chain_add_32(error, &nmrep, RPC_REPLY);
if ((status == ERPCMISMATCH) || (status & NFSERR_AUTHERR)) {
nfsm_chain_add_32(error, &nmrep, RPC_MSGDENIED);
if (status & NFSERR_AUTHERR) {
nfsm_chain_add_32(error, &nmrep, RPC_AUTHERR);
nfsm_chain_add_32(error, &nmrep, (status & ~NFSERR_AUTHERR));
} else {
nfsm_chain_add_32(error, &nmrep, RPC_MISMATCH);
nfsm_chain_add_32(error, &nmrep, RPC_VER2);
nfsm_chain_add_32(error, &nmrep, RPC_VER2);
}
} else {
nfsm_chain_add_32(error, &nmrep, RPC_MSGACCEPTED);
nfsm_chain_add_32(error, &nmrep, RPCAUTH_NULL);
nfsm_chain_add_32(error, &nmrep, 0);
switch (status) {
case EPROGUNAVAIL:
nfsm_chain_add_32(error, &nmrep, RPC_PROGUNAVAIL);
break;
case EPROGMISMATCH:
nfsm_chain_add_32(error, &nmrep, RPC_PROGMISMATCH);
nfsm_chain_add_32(error, &nmrep, NFS4_CALLBACK_PROG_VERSION);
nfsm_chain_add_32(error, &nmrep, NFS4_CALLBACK_PROG_VERSION);
break;
case EPROCUNAVAIL:
nfsm_chain_add_32(error, &nmrep, RPC_PROCUNAVAIL);
break;
case EBADRPC:
nfsm_chain_add_32(error, &nmrep, RPC_GARBAGE);
break;
default:
nfsm_chain_add_32(error, &nmrep, RPC_SUCCESS);
if (status != NFSERR_RETVOID) {
nfsm_chain_add_32(error, &nmrep, status);
}
break;
}
}
nfsm_chain_build_done(error, &nmrep);
if (error) {
nfsm_chain_null(&nmrep);
goto out;
}
error = mbuf_setnext(nmrep.nmc_mcur, mrest);
if (error) {
printf("nfs cb: mbuf_setnext failed %d\n", error);
goto out;
}
mrest = NULL;
replen = 0;
for (m = nmrep.nmc_mhead; m; m = mbuf_next(m)) {
replen += mbuf_len(m);
}
mbuf_pkthdr_setlen(mhead, replen);
error = mbuf_pkthdr_setrcvif(mhead, NULL);
nfsm_chain_set_recmark(error, &nmrep, (replen - NFSX_UNSIGNED) | 0x80000000);
nfsm_chain_null(&nmrep);
bzero(&msg, sizeof(msg));
error = sock_sendmbuf(so, &msg, mhead, 0, &sentlen);
mhead = NULL;
if (!error && ((int)sentlen != replen)) {
error = EWOULDBLOCK;
}
if (error == EWOULDBLOCK) {
error = ETIMEDOUT;
}
out:
if (error) {
nfsm_chain_cleanup(&nmrep);
}
if (mhead) {
mbuf_freem(mhead);
}
if (mrest) {
mbuf_freem(mrest);
}
if (mreq) {
mbuf_freem(mreq);
}
return error;
}
#endif
void
nfs_rpc_record_state_init(struct nfs_rpc_record_state *nrrsp)
{
bzero(nrrsp, sizeof(*nrrsp));
nrrsp->nrrs_markerleft = sizeof(nrrsp->nrrs_fragleft);
}
void
nfs_rpc_record_state_cleanup(struct nfs_rpc_record_state *nrrsp)
{
if (nrrsp->nrrs_m) {
mbuf_freem(nrrsp->nrrs_m);
nrrsp->nrrs_m = nrrsp->nrrs_mlast = NULL;
}
}
int
nfs_rpc_record_read(socket_t so, struct nfs_rpc_record_state *nrrsp, int flags, int *recvp, mbuf_t *mp)
{
struct iovec aio;
struct msghdr msg;
size_t rcvlen;
int error = 0;
mbuf_t m;
*recvp = 0;
*mp = NULL;
while (!error && nrrsp->nrrs_markerleft) {
aio.iov_base = ((char*)&nrrsp->nrrs_fragleft +
sizeof(nrrsp->nrrs_fragleft) - nrrsp->nrrs_markerleft);
aio.iov_len = nrrsp->nrrs_markerleft;
bzero(&msg, sizeof(msg));
msg.msg_iov = &aio;
msg.msg_iovlen = 1;
error = sock_receive(so, &msg, flags, &rcvlen);
if (error || !rcvlen) {
break;
}
*recvp = 1;
nrrsp->nrrs_markerleft -= rcvlen;
if (nrrsp->nrrs_markerleft) {
continue;
}
nrrsp->nrrs_fragleft = ntohl(nrrsp->nrrs_fragleft);
if (nrrsp->nrrs_fragleft & 0x80000000) {
nrrsp->nrrs_lastfrag = 1;
nrrsp->nrrs_fragleft &= ~0x80000000;
}
nrrsp->nrrs_reclen += nrrsp->nrrs_fragleft;
if (nrrsp->nrrs_reclen > NFS_MAXPACKET) {
log(LOG_ERR, "impossible RPC record length (%d) on callback", nrrsp->nrrs_reclen);
error = EFBIG;
}
}
while (!error && !nrrsp->nrrs_markerleft && nrrsp->nrrs_fragleft) {
m = NULL;
rcvlen = nrrsp->nrrs_fragleft;
error = sock_receivembuf(so, NULL, &m, flags, &rcvlen);
if (error || !rcvlen || !m) {
break;
}
*recvp = 1;
nrrsp->nrrs_fragleft -= rcvlen;
if (!nrrsp->nrrs_m) {
nrrsp->nrrs_m = m;
} else {
error = mbuf_setnext(nrrsp->nrrs_mlast, m);
if (error) {
printf("nfs tcp rcv: mbuf_setnext failed %d\n", error);
mbuf_freem(m);
break;
}
}
while (mbuf_next(m)) {
m = mbuf_next(m);
}
nrrsp->nrrs_mlast = m;
}
if (!error && !nrrsp->nrrs_markerleft && !nrrsp->nrrs_fragleft) {
nrrsp->nrrs_markerleft = sizeof(nrrsp->nrrs_fragleft);
if (nrrsp->nrrs_lastfrag) {
*mp = nrrsp->nrrs_m;
nrrsp->nrrs_reclen = 0;
nrrsp->nrrs_m = nrrsp->nrrs_mlast = NULL;
nrrsp->nrrs_lastfrag = 0;
}
}
return error;
}
int
nfs_send(struct nfsreq *req, int wait)
{
struct nfsmount *nmp;
struct nfs_socket *nso;
int error, error2, sotype, rexmit, slpflag = 0, needrecon;
struct msghdr msg;
struct sockaddr *sendnam;
mbuf_t mreqcopy;
size_t sentlen = 0;
struct timespec ts = { .tv_sec = 2, .tv_nsec = 0 };
again:
error = nfs_sndlock(req);
if (error) {
lck_mtx_lock(&req->r_mtx);
req->r_error = error;
req->r_flags &= ~R_SENDING;
lck_mtx_unlock(&req->r_mtx);
return error;
}
error = nfs_sigintr(req->r_nmp, req, NULL, 0);
if (error) {
nfs_sndunlock(req);
lck_mtx_lock(&req->r_mtx);
req->r_error = error;
req->r_flags &= ~R_SENDING;
lck_mtx_unlock(&req->r_mtx);
return error;
}
nmp = req->r_nmp;
sotype = nmp->nm_sotype;
if (((req->r_flags & R_SETUP) && !(nmp->nm_sockflags & NMSOCK_SETUP)) ||
((req->r_flags & R_RECOVER) && !(nmp->nm_sockflags & NMSOCK_READY))) {
error = ETIMEDOUT;
nfs_sndunlock(req);
lck_mtx_lock(&req->r_mtx);
req->r_error = error;
req->r_flags &= ~R_SENDING;
lck_mtx_unlock(&req->r_mtx);
return error;
}
lck_mtx_lock(&nmp->nm_lock);
if (!(nmp->nm_sockflags & NMSOCK_READY) &&
!((nmp->nm_sockflags & NMSOCK_SETUP) && (req->r_flags & R_SETUP))) {
if (NMFLAG(nmp, INTR) && !(req->r_flags & R_NOINTR)) {
slpflag |= PCATCH;
}
lck_mtx_unlock(&nmp->nm_lock);
nfs_sndunlock(req);
if (!wait) {
lck_mtx_lock(&req->r_mtx);
req->r_flags &= ~R_SENDING;
req->r_flags |= R_MUSTRESEND;
req->r_rtt = 0;
lck_mtx_unlock(&req->r_mtx);
return 0;
}
NFS_SOCK_DBG("nfs_send: 0x%llx wait reconnect\n", req->r_xid);
lck_mtx_lock(&req->r_mtx);
req->r_flags &= ~R_MUSTRESEND;
req->r_rtt = 0;
lck_mtx_unlock(&req->r_mtx);
lck_mtx_lock(&nmp->nm_lock);
while (!(nmp->nm_sockflags & NMSOCK_READY)) {
if (nmp->nm_state & (NFSSTA_FORCE | NFSSTA_DEAD)) {
error = EIO;
break;
}
if ((NMFLAG(nmp, SOFT) || (req->r_flags & R_SOFT)) && (nmp->nm_reconnect_start > 0)) {
struct timeval now;
microuptime(&now);
if ((now.tv_sec - nmp->nm_reconnect_start) >= 8) {
OSAddAtomic64(1, &nfsstats.rpctimeouts);
req->r_flags |= R_SOFTTERM;
req->r_error = error = ETIMEDOUT;
break;
}
}
nfs_mount_sock_thread_wake(nmp);
if ((error = nfs_sigintr(req->r_nmp, req, req->r_thread, 1))) {
break;
}
msleep(req, &nmp->nm_lock, slpflag | PSOCK, "nfsconnectwait", &ts);
slpflag = 0;
}
lck_mtx_unlock(&nmp->nm_lock);
if (error) {
lck_mtx_lock(&req->r_mtx);
req->r_error = error;
req->r_flags &= ~R_SENDING;
lck_mtx_unlock(&req->r_mtx);
return error;
}
goto again;
}
nso = nmp->nm_nso;
nmp->nm_state |= NFSSTA_SENDING;
lck_mtx_unlock(&nmp->nm_lock);
if (!nso) {
nfs_sndunlock(req);
lck_mtx_lock(&req->r_mtx);
req->r_flags &= ~R_SENDING;
req->r_flags |= R_MUSTRESEND;
req->r_rtt = 0;
lck_mtx_unlock(&req->r_mtx);
return 0;
}
lck_mtx_lock(&req->r_mtx);
rexmit = (req->r_flags & R_SENT);
if (sotype == SOCK_DGRAM) {
lck_mtx_lock(&nmp->nm_lock);
if (!(req->r_flags & R_CWND) && (nmp->nm_sent >= nmp->nm_cwnd)) {
slpflag = (NMFLAG(nmp, INTR) && req->r_thread) ? PCATCH : 0;
lck_mtx_unlock(&nmp->nm_lock);
nfs_sndunlock(req);
req->r_flags &= ~R_SENDING;
req->r_flags |= R_MUSTRESEND;
lck_mtx_unlock(&req->r_mtx);
if (!wait) {
req->r_rtt = 0;
return 0;
}
lck_mtx_lock(&nmp->nm_lock);
while (nmp->nm_sent >= nmp->nm_cwnd) {
if ((error = nfs_sigintr(req->r_nmp, req, req->r_thread, 1))) {
break;
}
TAILQ_INSERT_TAIL(&nmp->nm_cwndq, req, r_cchain);
msleep(req, &nmp->nm_lock, slpflag | (PZERO - 1), "nfswaitcwnd", &ts);
slpflag = 0;
if ((req->r_cchain.tqe_next != NFSREQNOLIST)) {
TAILQ_REMOVE(&nmp->nm_cwndq, req, r_cchain);
req->r_cchain.tqe_next = NFSREQNOLIST;
}
}
lck_mtx_unlock(&nmp->nm_lock);
goto again;
}
if (!rexmit) {
req->r_flags |= R_CWND;
nmp->nm_sent += NFS_CWNDSCALE;
} else {
req->r_flags &= ~R_TIMING;
nmp->nm_cwnd >>= 1;
if (nmp->nm_cwnd < NFS_CWNDSCALE) {
nmp->nm_cwnd = NFS_CWNDSCALE;
}
}
lck_mtx_unlock(&nmp->nm_lock);
}
req->r_flags &= ~R_MUSTRESEND;
lck_mtx_unlock(&req->r_mtx);
error = mbuf_copym(req->r_mhead, 0, MBUF_COPYALL,
wait ? MBUF_WAITOK : MBUF_DONTWAIT, &mreqcopy);
if (error) {
if (wait) {
log(LOG_INFO, "nfs_send: mbuf copy failed %d\n", error);
}
nfs_sndunlock(req);
lck_mtx_lock(&req->r_mtx);
req->r_flags &= ~R_SENDING;
req->r_flags |= R_MUSTRESEND;
req->r_rtt = 0;
lck_mtx_unlock(&req->r_mtx);
return 0;
}
bzero(&msg, sizeof(msg));
if ((sotype != SOCK_STREAM) && !sock_isconnected(nso->nso_so) && ((sendnam = nmp->nm_saddr))) {
msg.msg_name = (caddr_t)sendnam;
msg.msg_namelen = sendnam->sa_len;
}
NFS_SOCK_DUMP_MBUF("Sending mbuf\n", mreqcopy);
error = sock_sendmbuf(nso->nso_so, &msg, mreqcopy, 0, &sentlen);
if (error || (sentlen != req->r_mreqlen)) {
NFS_SOCK_DBG("nfs_send: 0x%llx sent %d/%d error %d\n",
req->r_xid, (int)sentlen, (int)req->r_mreqlen, error);
}
if (!error && (sentlen != req->r_mreqlen)) {
error = EWOULDBLOCK;
}
needrecon = ((sotype == SOCK_STREAM) && sentlen && (sentlen != req->r_mreqlen));
lck_mtx_lock(&req->r_mtx);
req->r_flags &= ~R_SENDING;
req->r_rtt = 0;
if (rexmit && (++req->r_rexmit > NFS_MAXREXMIT)) {
req->r_rexmit = NFS_MAXREXMIT;
}
if (!error) {
req->r_flags &= ~R_RESENDERR;
if (rexmit) {
OSAddAtomic64(1, &nfsstats.rpcretries);
}
req->r_flags |= R_SENT;
if (req->r_flags & R_WAITSENT) {
req->r_flags &= ~R_WAITSENT;
wakeup(req);
}
nfs_sndunlock(req);
lck_mtx_unlock(&req->r_mtx);
return 0;
}
req->r_flags |= R_MUSTRESEND;
if (rexmit) {
req->r_flags |= R_RESENDERR;
}
if ((error == EINTR) || (error == ERESTART)) {
req->r_error = error;
}
lck_mtx_unlock(&req->r_mtx);
if (sotype == SOCK_DGRAM) {
if ((error != EINTR) && (error != ERESTART) &&
(error != EWOULDBLOCK) && (error != EIO) && (nso == nmp->nm_nso)) {
int clearerror = 0, optlen = sizeof(clearerror);
sock_getsockopt(nso->nso_so, SOL_SOCKET, SO_ERROR, &clearerror, &optlen);
#ifdef NFS_SOCKET_DEBUGGING
if (clearerror) {
NFS_SOCK_DBG("nfs_send: ignoring UDP socket error %d so %d\n",
error, clearerror);
}
#endif
}
}
switch (error) {
case EWOULDBLOCK:
if (sotype != SOCK_STREAM) {
break;
}
case EPIPE:
case EADDRNOTAVAIL:
case ENETDOWN:
case ENETUNREACH:
case ENETRESET:
case ECONNABORTED:
case ECONNRESET:
case ENOTCONN:
case ESHUTDOWN:
case ECONNREFUSED:
case EHOSTDOWN:
case EHOSTUNREACH:
needrecon = 1;
break;
}
if (needrecon && (nso == nmp->nm_nso)) {
NFS_SOCK_DBG("nfs_send: 0x%llx need reconnect %d\n", req->r_xid, error);
nfs_need_reconnect(nmp);
}
nfs_sndunlock(req);
if (nfs_is_dead(error, nmp)) {
error = EIO;
}
if ((error == EPIPE) || (error == EADDRNOTAVAIL) || (error == ENOTCONN)) {
error = 0;
}
if (error && (error != EINTR) && (error != ERESTART)) {
log(LOG_INFO, "nfs send error %d for server %s\n", error,
!req->r_nmp ? "<unmounted>" :
vfs_statfs(req->r_nmp->nm_mountp)->f_mntfromname);
}
error2 = nfs_sigintr(req->r_nmp, req, req->r_thread, 0);
if (error2) {
error = error2;
}
if ((error != EINTR) && (error != ERESTART) && (error != EIO) &&
(error != ENXIO) && (error != ETIMEDOUT)) {
error = needrecon ? 0 : EIO;
}
return error;
}
void
nfs_udp_rcv(socket_t so, void *arg, __unused int waitflag)
{
struct nfsmount *nmp = arg;
struct nfs_socket *nso = nmp->nm_nso;
size_t rcvlen;
mbuf_t m;
int error = 0;
if (nmp->nm_sockflags & NMSOCK_CONNECTING) {
return;
}
do {
if (!nso || (nso->nso_so != so)) {
return;
}
m = NULL;
rcvlen = 1000000;
error = sock_receivembuf(so, NULL, &m, MSG_DONTWAIT, &rcvlen);
if (m) {
nfs_request_match_reply(nmp, m);
}
} while (m && !error);
if (error && (error != EWOULDBLOCK)) {
NFS_SOCK_DBG("nfs_udp_rcv: need reconnect %d\n", error);
nfs_need_reconnect(nmp);
}
}
void
nfs_tcp_rcv(socket_t so, void *arg, __unused int waitflag)
{
struct nfsmount *nmp = arg;
struct nfs_socket *nso = nmp->nm_nso;
struct nfs_rpc_record_state nrrs;
mbuf_t m;
int error = 0;
int recv = 1;
int wup = 0;
if (nmp->nm_sockflags & NMSOCK_CONNECTING) {
return;
}
lck_mtx_lock(&nmp->nm_lock);
nso = nmp->nm_nso;
if (!nso || (nso->nso_so != so) || (nmp->nm_sockflags & (NMSOCK_DISCONNECTING))) {
lck_mtx_unlock(&nmp->nm_lock);
return;
}
lck_mtx_unlock(&nmp->nm_lock);
lck_mtx_lock(&nso->nso_lock);
if (nso->nso_flags & (NSO_UPCALL | NSO_DISCONNECTING | NSO_DEAD)) {
lck_mtx_unlock(&nso->nso_lock);
return;
}
nso->nso_flags |= NSO_UPCALL;
nrrs = nso->nso_rrs;
lck_mtx_unlock(&nso->nso_lock);
while (!error && recv) {
error = nfs_rpc_record_read(so, &nrrs, MSG_DONTWAIT, &recv, &m);
if (m) {
nfs_request_match_reply(nmp, m);
}
}
lck_mtx_lock(&nso->nso_lock);
nso->nso_rrs = nrrs;
if (nso->nso_flags & NSO_DISCONNECTING) {
wup = 1;
}
nso->nso_flags &= ~NSO_UPCALL;
lck_mtx_unlock(&nso->nso_lock);
if (wup) {
wakeup(&nso->nso_flags);
}
#ifdef NFS_SOCKET_DEBUGGING
if (!recv && (error != EWOULDBLOCK)) {
NFS_SOCK_DBG("nfs_tcp_rcv: got nothing, error %d, got FIN?\n", error);
}
#endif
if ((error != EWOULDBLOCK) && (error || !recv)) {
NFS_SOCK_DBG("nfs_tcp_rcv: need reconnect %d\n", error);
nfs_need_reconnect(nmp);
}
}
void
nfs_sock_poke(struct nfsmount *nmp)
{
struct iovec aio;
struct msghdr msg;
size_t len;
int error = 0;
int dummy;
lck_mtx_lock(&nmp->nm_lock);
if ((nmp->nm_sockflags & NMSOCK_UNMOUNT) ||
!(nmp->nm_sockflags & NMSOCK_READY) || !nmp->nm_nso || !nmp->nm_nso->nso_so) {
nmp->nm_sockflags &= ~NMSOCK_POKE;
wakeup(&nmp->nm_sockflags);
lck_mtx_unlock(&nmp->nm_lock);
return;
}
lck_mtx_unlock(&nmp->nm_lock);
aio.iov_base = &dummy;
aio.iov_len = 0;
len = 0;
bzero(&msg, sizeof(msg));
msg.msg_iov = &aio;
msg.msg_iovlen = 1;
error = sock_send(nmp->nm_nso->nso_so, &msg, MSG_DONTWAIT, &len);
NFS_SOCK_DBG("nfs_sock_poke: error %d\n", error);
lck_mtx_lock(&nmp->nm_lock);
nmp->nm_sockflags &= ~NMSOCK_POKE;
wakeup(&nmp->nm_sockflags);
lck_mtx_unlock(&nmp->nm_lock);
nfs_is_dead(error, nmp);
}
void
nfs_request_match_reply(struct nfsmount *nmp, mbuf_t mrep)
{
struct nfsreq *req;
struct nfsm_chain nmrep;
u_int32_t reply = 0, rxid = 0;
int error = 0, asyncioq, t1;
nfsm_chain_dissect_init(error, &nmrep, mrep);
nfsm_chain_get_32(error, &nmrep, rxid);
nfsm_chain_get_32(error, &nmrep, reply);
if (error || (reply != RPC_REPLY)) {
OSAddAtomic64(1, &nfsstats.rpcinvalid);
mbuf_freem(mrep);
return;
}
lck_mtx_lock(nfs_request_mutex);
TAILQ_FOREACH(req, &nfs_reqq, r_chain) {
if (req->r_nmrep.nmc_mhead || (rxid != R_XID32(req->r_xid))) {
continue;
}
lck_mtx_lock(&req->r_mtx);
if (req->r_nmrep.nmc_mhead || (rxid != R_XID32(req->r_xid))) {
lck_mtx_unlock(&req->r_mtx);
continue;
}
req->r_nmrep = nmrep;
lck_mtx_lock(&nmp->nm_lock);
if (nmp->nm_sotype == SOCK_DGRAM) {
FSDBG(530, R_XID32(req->r_xid), req, nmp->nm_sent, nmp->nm_cwnd);
if (nmp->nm_cwnd <= nmp->nm_sent) {
nmp->nm_cwnd +=
((NFS_CWNDSCALE * NFS_CWNDSCALE) +
(nmp->nm_cwnd >> 1)) / nmp->nm_cwnd;
if (nmp->nm_cwnd > NFS_MAXCWND) {
nmp->nm_cwnd = NFS_MAXCWND;
}
}
if (req->r_flags & R_CWND) {
nmp->nm_sent -= NFS_CWNDSCALE;
req->r_flags &= ~R_CWND;
}
if ((nmp->nm_sent < nmp->nm_cwnd) && !TAILQ_EMPTY(&nmp->nm_cwndq)) {
struct nfsreq *req2 = TAILQ_FIRST(&nmp->nm_cwndq);
TAILQ_REMOVE(&nmp->nm_cwndq, req2, r_cchain);
req2->r_cchain.tqe_next = NFSREQNOLIST;
wakeup(req2);
}
}
if (req->r_flags & R_TIMING) {
if (proct[req->r_procnum] == 0) {
panic("nfs_request_match_reply: proct[%d] is zero", req->r_procnum);
}
t1 = req->r_rtt + 1;
t1 -= (NFS_SRTT(req) >> 3);
NFS_SRTT(req) += t1;
if (t1 < 0) {
t1 = -t1;
}
t1 -= (NFS_SDRTT(req) >> 2);
NFS_SDRTT(req) += t1;
}
nmp->nm_timeouts = 0;
lck_mtx_unlock(&nmp->nm_lock);
wakeup(req);
asyncioq = (req->r_callback.rcb_func != NULL);
#if CONFIG_NFS_GSS
if (nfs_request_using_gss(req)) {
nfs_gss_clnt_rpcdone(req);
}
#endif
lck_mtx_unlock(&req->r_mtx);
lck_mtx_unlock(nfs_request_mutex);
if (asyncioq) {
nfs_asyncio_finish(req);
}
break;
}
if (!req) {
lck_mtx_unlock(nfs_request_mutex);
OSAddAtomic64(1, &nfsstats.rpcunexpected);
mbuf_freem(mrep);
}
}
int
nfs_wait_reply(struct nfsreq *req)
{
struct timespec ts = { .tv_sec = 2, .tv_nsec = 0 };
int error = 0, slpflag, first = 1;
if (req->r_nmp && NMFLAG(req->r_nmp, INTR) && req->r_thread && !(req->r_flags & R_NOINTR)) {
slpflag = PCATCH;
} else {
slpflag = 0;
}
lck_mtx_lock(&req->r_mtx);
while (!req->r_nmrep.nmc_mhead) {
if ((error = nfs_sigintr(req->r_nmp, req, first ? NULL : req->r_thread, 0))) {
break;
}
if (((error = req->r_error)) || req->r_nmrep.nmc_mhead) {
break;
}
if (req->r_flags & R_MUSTRESEND) {
NFS_SOCK_DBG("nfs wait resend: p %d x 0x%llx f 0x%x rtt %d\n",
req->r_procnum, req->r_xid, req->r_flags, req->r_rtt);
req->r_flags |= R_SENDING;
lck_mtx_unlock(&req->r_mtx);
if (nfs_request_using_gss(req)) {
lck_mtx_lock(&req->r_mtx);
req->r_flags &= ~R_SENDING;
lck_mtx_unlock(&req->r_mtx);
return EAGAIN;
}
error = nfs_send(req, 1);
lck_mtx_lock(&req->r_mtx);
NFS_SOCK_DBG("nfs wait resend: p %d x 0x%llx f 0x%x rtt %d err %d\n",
req->r_procnum, req->r_xid, req->r_flags, req->r_rtt, error);
if (error) {
break;
}
if (((error = req->r_error)) || req->r_nmrep.nmc_mhead) {
break;
}
}
if (nfs_noremotehang(req->r_thread)) {
ts.tv_sec = 1;
}
msleep(req, &req->r_mtx, slpflag | (PZERO - 1), "nfswaitreply", &ts);
first = slpflag = 0;
}
lck_mtx_unlock(&req->r_mtx);
return error;
}
int
nfs_request_create(
nfsnode_t np,
mount_t mp,
struct nfsm_chain *nmrest,
int procnum,
thread_t thd,
kauth_cred_t cred,
struct nfsreq **reqp)
{
struct nfsreq *req, *newreq = NULL;
struct nfsmount *nmp;
req = *reqp;
if (!req) {
MALLOC_ZONE(newreq, struct nfsreq*, sizeof(*newreq), M_NFSREQ, M_WAITOK);
if (!newreq) {
mbuf_freem(nmrest->nmc_mhead);
nmrest->nmc_mhead = NULL;
return ENOMEM;
}
req = newreq;
}
bzero(req, sizeof(*req));
if (req == newreq) {
req->r_flags = R_ALLOCATED;
}
nmp = VFSTONFS(np ? NFSTOMP(np) : mp);
if (nfs_mount_gone(nmp)) {
if (newreq) {
FREE_ZONE(newreq, sizeof(*newreq), M_NFSREQ);
}
return ENXIO;
}
lck_mtx_lock(&nmp->nm_lock);
if ((nmp->nm_state & (NFSSTA_FORCE | NFSSTA_DEAD)) &&
(nmp->nm_state & NFSSTA_TIMEO)) {
lck_mtx_unlock(&nmp->nm_lock);
mbuf_freem(nmrest->nmc_mhead);
nmrest->nmc_mhead = NULL;
if (newreq) {
FREE_ZONE(newreq, sizeof(*newreq), M_NFSREQ);
}
return ENXIO;
}
if ((nmp->nm_vers != NFS_VER4) && (procnum >= 0) && (procnum < NFS_NPROCS)) {
OSAddAtomic64(1, &nfsstats.rpccnt[procnum]);
}
if ((nmp->nm_vers == NFS_VER4) && (procnum != NFSPROC4_COMPOUND) && (procnum != NFSPROC4_NULL)) {
panic("nfs_request: invalid NFSv4 RPC request %d\n", procnum);
}
lck_mtx_init(&req->r_mtx, nfs_request_grp, LCK_ATTR_NULL);
req->r_nmp = nmp;
nmp->nm_ref++;
req->r_np = np;
req->r_thread = thd;
if (!thd) {
req->r_flags |= R_NOINTR;
}
if (IS_VALID_CRED(cred)) {
kauth_cred_ref(cred);
req->r_cred = cred;
}
req->r_procnum = procnum;
if (proct[procnum] > 0) {
req->r_flags |= R_TIMING;
}
req->r_nmrep.nmc_mhead = NULL;
SLIST_INIT(&req->r_gss_seqlist);
req->r_achain.tqe_next = NFSREQNOLIST;
req->r_rchain.tqe_next = NFSREQNOLIST;
req->r_cchain.tqe_next = NFSREQNOLIST;
if (!req->r_cred) {
req->r_auth = RPCAUTH_NONE;
} else if (req->r_np && (req->r_np->n_auth != RPCAUTH_INVALID)) {
req->r_auth = req->r_np->n_auth;
} else {
req->r_auth = nmp->nm_auth;
}
lck_mtx_unlock(&nmp->nm_lock);
req->r_mrest = nmrest->nmc_mhead;
nmrest->nmc_mhead = NULL;
req->r_flags |= R_INITTED;
req->r_refs = 1;
if (newreq) {
*reqp = req;
}
return 0;
}
void
nfs_request_destroy(struct nfsreq *req)
{
struct nfsmount *nmp;
int clearjbtimeo = 0;
#if CONFIG_NFS_GSS
struct gss_seq *gsp, *ngsp;
#endif
if (!req || !(req->r_flags & R_INITTED)) {
return;
}
nmp = req->r_nmp;
req->r_flags &= ~R_INITTED;
if (req->r_lflags & RL_QUEUED) {
nfs_reqdequeue(req);
}
if (req->r_achain.tqe_next != NFSREQNOLIST) {
lck_mtx_lock(nfsiod_mutex);
if (nmp && req->r_achain.tqe_next != NFSREQNOLIST) {
TAILQ_REMOVE(&nmp->nm_iodq, req, r_achain);
req->r_achain.tqe_next = NFSREQNOLIST;
}
lck_mtx_unlock(nfsiod_mutex);
}
lck_mtx_lock(&req->r_mtx);
if (nmp) {
lck_mtx_lock(&nmp->nm_lock);
if (req->r_flags & R_CWND) {
req->r_flags &= ~R_CWND;
nmp->nm_sent -= NFS_CWNDSCALE;
if ((nmp->nm_sent < nmp->nm_cwnd) && !TAILQ_EMPTY(&nmp->nm_cwndq)) {
struct nfsreq *req2 = TAILQ_FIRST(&nmp->nm_cwndq);
TAILQ_REMOVE(&nmp->nm_cwndq, req2, r_cchain);
req2->r_cchain.tqe_next = NFSREQNOLIST;
wakeup(req2);
}
}
assert((req->r_flags & R_RESENDQ) == 0);
if (req->r_rchain.tqe_next != NFSREQNOLIST) {
TAILQ_REMOVE(&nmp->nm_resendq, req, r_rchain);
req->r_rchain.tqe_next = NFSREQNOLIST;
if (req->r_flags & R_RESENDQ) {
req->r_flags &= ~R_RESENDQ;
}
}
if (req->r_cchain.tqe_next != NFSREQNOLIST) {
TAILQ_REMOVE(&nmp->nm_cwndq, req, r_cchain);
req->r_cchain.tqe_next = NFSREQNOLIST;
}
if (req->r_flags & R_JBTPRINTFMSG) {
req->r_flags &= ~R_JBTPRINTFMSG;
nmp->nm_jbreqs--;
clearjbtimeo = (nmp->nm_jbreqs == 0) ? NFSSTA_JUKEBOXTIMEO : 0;
}
lck_mtx_unlock(&nmp->nm_lock);
}
lck_mtx_unlock(&req->r_mtx);
if (clearjbtimeo) {
nfs_up(nmp, req->r_thread, clearjbtimeo, NULL);
}
if (req->r_mhead) {
mbuf_freem(req->r_mhead);
} else if (req->r_mrest) {
mbuf_freem(req->r_mrest);
}
if (req->r_nmrep.nmc_mhead) {
mbuf_freem(req->r_nmrep.nmc_mhead);
}
if (IS_VALID_CRED(req->r_cred)) {
kauth_cred_unref(&req->r_cred);
}
#if CONFIG_NFS_GSS
if (nfs_request_using_gss(req)) {
nfs_gss_clnt_rpcdone(req);
}
SLIST_FOREACH_SAFE(gsp, &req->r_gss_seqlist, gss_seqnext, ngsp)
FREE(gsp, M_TEMP);
if (req->r_gss_ctx) {
nfs_gss_clnt_ctx_unref(req);
}
#endif
if (req->r_wrongsec) {
FREE(req->r_wrongsec, M_TEMP);
}
if (nmp) {
nfs_mount_rele(nmp);
}
lck_mtx_destroy(&req->r_mtx, nfs_request_grp);
if (req->r_flags & R_ALLOCATED) {
FREE_ZONE(req, sizeof(*req), M_NFSREQ);
}
}
void
nfs_request_ref(struct nfsreq *req, int locked)
{
if (!locked) {
lck_mtx_lock(&req->r_mtx);
}
if (req->r_refs <= 0) {
panic("nfsreq reference error");
}
req->r_refs++;
if (!locked) {
lck_mtx_unlock(&req->r_mtx);
}
}
void
nfs_request_rele(struct nfsreq *req)
{
int destroy;
lck_mtx_lock(&req->r_mtx);
if (req->r_refs <= 0) {
panic("nfsreq reference underflow");
}
req->r_refs--;
destroy = (req->r_refs == 0);
lck_mtx_unlock(&req->r_mtx);
if (destroy) {
nfs_request_destroy(req);
}
}
int
nfs_request_add_header(struct nfsreq *req)
{
struct nfsmount *nmp;
int error = 0;
mbuf_t m;
if ((m = req->r_mhead)) {
while (m && (m != req->r_mrest)) {
m = mbuf_free(m);
}
req->r_mhead = NULL;
}
nmp = req->r_nmp;
if (nfs_mount_gone(nmp)) {
return ENXIO;
}
error = nfsm_rpchead(req, req->r_mrest, &req->r_xid, &req->r_mhead);
if (error) {
return error;
}
req->r_mreqlen = mbuf_pkthdr_len(req->r_mhead);
nmp = req->r_nmp;
if (nfs_mount_gone(nmp)) {
return ENXIO;
}
lck_mtx_lock(&nmp->nm_lock);
if (NMFLAG(nmp, SOFT) || (req->r_flags & R_SOFT)) {
req->r_retry = nmp->nm_retry;
} else {
req->r_retry = NFS_MAXREXMIT + 1;
}
lck_mtx_unlock(&nmp->nm_lock);
return error;
}
int
nfs_request_send(struct nfsreq *req, int wait)
{
struct nfsmount *nmp;
struct timeval now;
lck_mtx_lock(&req->r_mtx);
req->r_flags |= R_SENDING;
lck_mtx_unlock(&req->r_mtx);
lck_mtx_lock(nfs_request_mutex);
nmp = req->r_nmp;
if (nfs_mount_gone(nmp)) {
lck_mtx_unlock(nfs_request_mutex);
return ENXIO;
}
microuptime(&now);
if (!req->r_start) {
req->r_start = now.tv_sec;
req->r_lastmsg = now.tv_sec -
((nmp->nm_tprintf_delay) - (nmp->nm_tprintf_initial_delay));
}
OSAddAtomic64(1, &nfsstats.rpcrequests);
TAILQ_INSERT_TAIL(&nfs_reqq, req, r_chain);
req->r_lflags |= RL_QUEUED;
if (!nfs_request_timer_on) {
nfs_request_timer_on = 1;
nfs_interval_timer_start(nfs_request_timer_call,
NFS_REQUESTDELAY);
}
lck_mtx_unlock(nfs_request_mutex);
return nfs_send(req, wait);
}
void
nfs_request_wait(struct nfsreq *req)
{
req->r_error = nfs_wait_reply(req);
}
int
nfs_request_finish(
struct nfsreq *req,
struct nfsm_chain *nmrepp,
int *status)
{
struct nfsmount *nmp;
mbuf_t mrep;
int verf_type = 0;
uint32_t verf_len = 0;
uint32_t reply_status = 0;
uint32_t rejected_status = 0;
uint32_t auth_status = 0;
uint32_t accepted_status = 0;
struct nfsm_chain nmrep;
int error, clearjbtimeo;
error = req->r_error;
if (nmrepp) {
nmrepp->nmc_mhead = NULL;
}
nfs_reqdequeue(req);
mrep = req->r_nmrep.nmc_mhead;
nmp = req->r_nmp;
if ((req->r_flags & R_CWND) && nmp) {
req->r_flags &= ~R_CWND;
lck_mtx_lock(&nmp->nm_lock);
FSDBG(273, R_XID32(req->r_xid), req, nmp->nm_sent, nmp->nm_cwnd);
nmp->nm_sent -= NFS_CWNDSCALE;
if ((nmp->nm_sent < nmp->nm_cwnd) && !TAILQ_EMPTY(&nmp->nm_cwndq)) {
struct nfsreq *req2 = TAILQ_FIRST(&nmp->nm_cwndq);
TAILQ_REMOVE(&nmp->nm_cwndq, req2, r_cchain);
req2->r_cchain.tqe_next = NFSREQNOLIST;
wakeup(req2);
}
lck_mtx_unlock(&nmp->nm_lock);
}
#if CONFIG_NFS_GSS
if (nfs_request_using_gss(req)) {
nfs_gss_clnt_rpcdone(req);
if (error == EAGAIN) {
req->r_error = 0;
if (mrep) {
mbuf_freem(mrep);
}
error = nfs_gss_clnt_args_restore(req); req->r_nmrep.nmc_mhead = NULL;
req->r_flags |= R_RESTART;
if (error == ENEEDAUTH) {
req->r_xid = 0; error = 0;
}
goto nfsmout;
}
}
#endif
if (!error) {
if ((req->r_flags & R_TPRINTFMSG) ||
(nmp && (NMFLAG(nmp, SOFT) || (req->r_flags & R_SOFT)) &&
((nmp->nm_state & (NFSSTA_TIMEO | NFSSTA_FORCE | NFSSTA_DEAD)) == NFSSTA_TIMEO))) {
nfs_up(nmp, req->r_thread, NFSSTA_TIMEO, "is alive again");
} else {
nfs_up(nmp, req->r_thread, NFSSTA_TIMEO, NULL);
}
}
if (!error && !nmp) {
error = ENXIO;
}
nfsmout_if(error);
nmrep = req->r_nmrep;
nfsm_chain_get_32(error, &nmrep, reply_status);
nfsmout_if(error);
if (reply_status == RPC_MSGDENIED) {
nfsm_chain_get_32(error, &nmrep, rejected_status);
nfsmout_if(error);
if (rejected_status == RPC_MISMATCH) {
error = ENOTSUP;
goto nfsmout;
}
nfsm_chain_get_32(error, &nmrep, auth_status);
nfsmout_if(error);
switch (auth_status) {
#if CONFIG_NFS_GSS
case RPCSEC_GSS_CREDPROBLEM:
case RPCSEC_GSS_CTXPROBLEM:
error = nfs_gss_clnt_args_restore(req);
if (error && error != ENEEDAUTH) {
break;
}
if (!error) {
error = nfs_gss_clnt_ctx_renew(req);
if (error) {
break;
}
}
mbuf_freem(mrep);
req->r_nmrep.nmc_mhead = NULL;
req->r_xid = 0; req->r_flags |= R_RESTART;
goto nfsmout;
#endif
default:
error = EACCES;
break;
}
goto nfsmout;
}
nfsm_chain_get_32(error, &nmrep, verf_type); nfsm_chain_get_32(error, &nmrep, verf_len); nfsmout_if(error);
switch (req->r_auth) {
case RPCAUTH_NONE:
case RPCAUTH_SYS:
if (verf_len > 0) {
nfsm_chain_adv(error, &nmrep, nfsm_rndup(verf_len));
}
nfsm_chain_get_32(error, &nmrep, accepted_status);
break;
#if CONFIG_NFS_GSS
case RPCAUTH_KRB5:
case RPCAUTH_KRB5I:
case RPCAUTH_KRB5P:
error = nfs_gss_clnt_verf_get(req, &nmrep,
verf_type, verf_len, &accepted_status);
break;
#endif
}
nfsmout_if(error);
switch (accepted_status) {
case RPC_SUCCESS:
if (req->r_procnum == NFSPROC_NULL) {
*status = NFS_OK;
} else {
nfsm_chain_get_32(error, &nmrep, *status);
nfsmout_if(error);
}
if ((nmp->nm_vers != NFS_VER2) && (*status == NFSERR_TRYLATER)) {
int delay, slpflag = (NMFLAG(nmp, INTR) && !(req->r_flags & R_NOINTR)) ? PCATCH : 0;
mbuf_freem(mrep);
req->r_nmrep.nmc_mhead = NULL;
if ((req->r_delay >= 30) && !(nmp->nm_state & NFSSTA_MOUNTED)) {
OSAddAtomic64(1, &nfsstats.rpctimeouts);
nfs_softterm(req);
error = req->r_error;
goto nfsmout;
}
req->r_delay = !req->r_delay ? NFS_TRYLATERDEL : (req->r_delay * 2);
if (req->r_delay > 30) {
req->r_delay = 30;
}
if (nmp->nm_tprintf_initial_delay && (req->r_delay >= nmp->nm_tprintf_initial_delay)) {
if (!(req->r_flags & R_JBTPRINTFMSG)) {
req->r_flags |= R_JBTPRINTFMSG;
lck_mtx_lock(&nmp->nm_lock);
nmp->nm_jbreqs++;
lck_mtx_unlock(&nmp->nm_lock);
}
nfs_down(req->r_nmp, req->r_thread, 0, NFSSTA_JUKEBOXTIMEO,
"resource temporarily unavailable (jukebox)", 0);
}
if ((NMFLAG(nmp, SOFT) || (req->r_flags & R_SOFT)) && (req->r_delay == 30) &&
!(req->r_flags & R_NOINTR)) {
OSAddAtomic64(1, &nfsstats.rpctimeouts);
nfs_softterm(req);
error = req->r_error;
goto nfsmout;
}
delay = req->r_delay;
if (req->r_callback.rcb_func) {
struct timeval now;
microuptime(&now);
req->r_resendtime = now.tv_sec + delay;
} else {
do {
if ((error = nfs_sigintr(req->r_nmp, req, req->r_thread, 0))) {
goto nfsmout;
}
tsleep(nfs_request_finish, PSOCK | slpflag, "nfs_jukebox_trylater", hz);
slpflag = 0;
} while (--delay > 0);
}
req->r_xid = 0; req->r_flags |= R_RESTART;
req->r_start = 0;
FSDBG(273, R_XID32(req->r_xid), nmp, req, NFSERR_TRYLATER);
return 0;
}
if (req->r_flags & R_JBTPRINTFMSG) {
req->r_flags &= ~R_JBTPRINTFMSG;
lck_mtx_lock(&nmp->nm_lock);
nmp->nm_jbreqs--;
clearjbtimeo = (nmp->nm_jbreqs == 0) ? NFSSTA_JUKEBOXTIMEO : 0;
lck_mtx_unlock(&nmp->nm_lock);
nfs_up(nmp, req->r_thread, clearjbtimeo, "resource available again");
}
#if CONFIG_NFS4
if ((nmp->nm_vers >= NFS_VER4) && (*status == NFSERR_WRONGSEC)) {
uint32_t srvflavors[NX_MAX_SEC_FLAVORS];
int srvcount, i, j;
srvcount = NX_MAX_SEC_FLAVORS;
nfs4_secinfo_rpc(nmp, &req->r_secinfo, req->r_cred, srvflavors, &srvcount);
if (!req->r_wrongsec) {
MALLOC(req->r_wrongsec, uint32_t*, NX_MAX_SEC_FLAVORS * sizeof(uint32_t), M_TEMP, M_WAITOK);
if (!req->r_wrongsec) {
error = EACCES;
goto nfsmout;
}
i = 0;
if (nmp->nm_sec.count) {
for (; i < nmp->nm_sec.count; i++) {
req->r_wrongsec[i] = nmp->nm_sec.flavors[i];
}
} else if (srvcount) {
for (; i < srvcount; i++) {
req->r_wrongsec[i] = srvflavors[i];
}
} else {
req->r_wrongsec[i++] = RPCAUTH_KRB5P;
req->r_wrongsec[i++] = RPCAUTH_KRB5I;
req->r_wrongsec[i++] = RPCAUTH_KRB5;
req->r_wrongsec[i++] = RPCAUTH_SYS;
req->r_wrongsec[i++] = RPCAUTH_NONE;
}
for (; i < NX_MAX_SEC_FLAVORS; i++) {
req->r_wrongsec[i] = RPCAUTH_INVALID;
}
}
for (i = 0; i < NX_MAX_SEC_FLAVORS; i++) {
if (req->r_wrongsec[i] == req->r_auth) {
req->r_wrongsec[i] = RPCAUTH_INVALID;
}
}
for (i = 0; i < NX_MAX_SEC_FLAVORS; i++) {
if (req->r_wrongsec[i] != RPCAUTH_INVALID) {
if (!srvcount) {
break;
}
for (j = 0; j < srvcount; j++) {
if (req->r_wrongsec[i] == srvflavors[j]) {
break;
}
}
if (j < srvcount) {
break;
}
req->r_wrongsec[i] = RPCAUTH_INVALID;
}
}
if (i == NX_MAX_SEC_FLAVORS) {
error = EACCES;
goto nfsmout;
}
req->r_auth = req->r_wrongsec[i];
req->r_xid = 0; req->r_flags |= R_RESTART;
req->r_start = 0;
FSDBG(273, R_XID32(req->r_xid), nmp, req, NFSERR_WRONGSEC);
return 0;
}
if ((nmp->nm_vers >= NFS_VER4) && req->r_wrongsec) {
if (req->r_np) {
req->r_np->n_auth = req->r_auth;
}
}
#endif
if (*status == NFS_OK) {
*nmrepp = nmrep;
req->r_nmrep.nmc_mhead = NULL;
break;
}
if ((*status == ESTALE) && req->r_np) {
cache_purge(NFSTOV(req->r_np));
if (vnode_ismonitored(NFSTOV(req->r_np))) {
nfs_vnode_notify(req->r_np, (VNODE_EVENT_ATTRIB | VNODE_EVENT_DELETE));
}
}
if (nmp->nm_vers == NFS_VER2) {
mbuf_freem(mrep);
} else {
*nmrepp = nmrep;
}
req->r_nmrep.nmc_mhead = NULL;
error = 0;
break;
case RPC_PROGUNAVAIL:
error = EPROGUNAVAIL;
break;
case RPC_PROGMISMATCH:
error = ERPCMISMATCH;
break;
case RPC_PROCUNAVAIL:
error = EPROCUNAVAIL;
break;
case RPC_GARBAGE:
error = EBADRPC;
break;
case RPC_SYSTEM_ERR:
default:
error = EIO;
break;
}
nfsmout:
if (req->r_flags & R_JBTPRINTFMSG) {
req->r_flags &= ~R_JBTPRINTFMSG;
lck_mtx_lock(&nmp->nm_lock);
nmp->nm_jbreqs--;
clearjbtimeo = (nmp->nm_jbreqs == 0) ? NFSSTA_JUKEBOXTIMEO : 0;
lck_mtx_unlock(&nmp->nm_lock);
if (clearjbtimeo) {
nfs_up(nmp, req->r_thread, clearjbtimeo, NULL);
}
}
FSDBG(273, R_XID32(req->r_xid), nmp, req,
(!error && (*status == NFS_OK)) ? 0xf0f0f0f0 : error);
return error;
}
int
nfs_request_using_gss(struct nfsreq *req)
{
if (!req->r_gss_ctx) {
return 0;
}
switch (req->r_auth) {
case RPCAUTH_KRB5:
case RPCAUTH_KRB5I:
case RPCAUTH_KRB5P:
return 1;
}
return 0;
}
int
nfs_request(
nfsnode_t np,
mount_t mp,
struct nfsm_chain *nmrest,
int procnum,
vfs_context_t ctx,
struct nfsreq_secinfo_args *si,
struct nfsm_chain *nmrepp,
u_int64_t *xidp,
int *status)
{
return nfs_request2(np, mp, nmrest, procnum,
vfs_context_thread(ctx), vfs_context_ucred(ctx),
si, 0, nmrepp, xidp, status);
}
int
nfs_request2(
nfsnode_t np,
mount_t mp,
struct nfsm_chain *nmrest,
int procnum,
thread_t thd,
kauth_cred_t cred,
struct nfsreq_secinfo_args *si,
int flags,
struct nfsm_chain *nmrepp,
u_int64_t *xidp,
int *status)
{
struct nfsreq rq, *req = &rq;
int error;
if ((error = nfs_request_create(np, mp, nmrest, procnum, thd, cred, &req))) {
return error;
}
req->r_flags |= (flags & (R_OPTMASK | R_SOFT));
if (si) {
req->r_secinfo = *si;
}
FSDBG_TOP(273, R_XID32(req->r_xid), np, procnum, 0);
do {
req->r_error = 0;
req->r_flags &= ~R_RESTART;
if ((error = nfs_request_add_header(req))) {
break;
}
if (xidp) {
*xidp = req->r_xid;
}
if ((error = nfs_request_send(req, 1))) {
break;
}
nfs_request_wait(req);
if ((error = nfs_request_finish(req, nmrepp, status))) {
break;
}
} while (req->r_flags & R_RESTART);
FSDBG_BOT(273, R_XID32(req->r_xid), np, procnum, error);
nfs_request_rele(req);
return error;
}
#if CONFIG_NFS_GSS
int
nfs_request_gss(
mount_t mp,
struct nfsm_chain *nmrest,
thread_t thd,
kauth_cred_t cred,
int flags,
struct nfs_gss_clnt_ctx *cp,
struct nfsm_chain *nmrepp,
int *status)
{
struct nfsreq rq, *req = &rq;
int error, wait = 1;
if ((error = nfs_request_create(NULL, mp, nmrest, NFSPROC_NULL, thd, cred, &req))) {
return error;
}
req->r_flags |= (flags & R_OPTMASK);
if (cp == NULL) {
printf("nfs_request_gss request has no context\n");
nfs_request_rele(req);
return NFSERR_EAUTH;
}
nfs_gss_clnt_ctx_ref(req, cp);
if (cp->gss_clnt_proc == RPCSEC_GSS_DESTROY) {
wait = 0;
}
FSDBG_TOP(273, R_XID32(req->r_xid), NULL, NFSPROC_NULL, 0);
do {
req->r_error = 0;
req->r_flags &= ~R_RESTART;
if ((error = nfs_request_add_header(req))) {
break;
}
if ((error = nfs_request_send(req, wait))) {
break;
}
if (!wait) {
break;
}
nfs_request_wait(req);
if ((error = nfs_request_finish(req, nmrepp, status))) {
break;
}
} while (req->r_flags & R_RESTART);
FSDBG_BOT(273, R_XID32(req->r_xid), NULL, NFSPROC_NULL, error);
nfs_gss_clnt_ctx_unref(req);
nfs_request_rele(req);
return error;
}
#endif
int
nfs_request_async(
nfsnode_t np,
mount_t mp,
struct nfsm_chain *nmrest,
int procnum,
thread_t thd,
kauth_cred_t cred,
struct nfsreq_secinfo_args *si,
int flags,
struct nfsreq_cbinfo *cb,
struct nfsreq **reqp)
{
struct nfsreq *req;
struct nfsmount *nmp;
int error, sent;
error = nfs_request_create(np, mp, nmrest, procnum, thd, cred, reqp);
req = *reqp;
FSDBG(274, (req ? R_XID32(req->r_xid) : 0), np, procnum, error);
if (error) {
return error;
}
req->r_flags |= (flags & R_OPTMASK);
req->r_flags |= R_ASYNC;
if (si) {
req->r_secinfo = *si;
}
if (cb) {
req->r_callback = *cb;
}
error = nfs_request_add_header(req);
if (!error) {
req->r_flags |= R_WAITSENT;
if (req->r_callback.rcb_func) {
nfs_request_ref(req, 0);
}
error = nfs_request_send(req, 1);
lck_mtx_lock(&req->r_mtx);
if (!error && !(req->r_flags & R_SENT) && req->r_callback.rcb_func) {
int slpflag = (req->r_nmp && NMFLAG(req->r_nmp, INTR) && req->r_thread && !(req->r_flags & R_NOINTR)) ? PCATCH : 0;
struct timespec ts = { .tv_sec = 2, .tv_nsec = 0 };
while (!(req->r_flags & R_SENT)) {
nmp = req->r_nmp;
if ((req->r_flags & R_RESENDQ) && !nfs_mount_gone(nmp)) {
lck_mtx_lock(&nmp->nm_lock);
if ((nmp->nm_state & NFSSTA_RECOVER) && (req->r_rchain.tqe_next != NFSREQNOLIST)) {
TAILQ_REMOVE(&nmp->nm_resendq, req, r_rchain);
req->r_rchain.tqe_next = NFSREQNOLIST;
if (req->r_flags & R_RESENDQ) {
req->r_flags &= ~R_RESENDQ;
}
lck_mtx_unlock(&nmp->nm_lock);
req->r_flags |= R_SENDING;
lck_mtx_unlock(&req->r_mtx);
error = nfs_send(req, 1);
nfs_request_rele(req);
lck_mtx_lock(&req->r_mtx);
if (error) {
break;
}
continue;
}
lck_mtx_unlock(&nmp->nm_lock);
}
if ((error = nfs_sigintr(req->r_nmp, req, req->r_thread, 0))) {
break;
}
msleep(req, &req->r_mtx, slpflag | (PZERO - 1), "nfswaitsent", &ts);
slpflag = 0;
}
}
sent = req->r_flags & R_SENT;
lck_mtx_unlock(&req->r_mtx);
if (error && req->r_callback.rcb_func && !sent) {
nfs_request_rele(req);
}
}
FSDBG(274, R_XID32(req->r_xid), np, procnum, error);
if (error || req->r_callback.rcb_func) {
nfs_request_rele(req);
}
return error;
}
int
nfs_request_async_finish(
struct nfsreq *req,
struct nfsm_chain *nmrepp,
u_int64_t *xidp,
int *status)
{
int error = 0, asyncio = req->r_callback.rcb_func ? 1 : 0;
struct nfsmount *nmp;
lck_mtx_lock(&req->r_mtx);
if (!asyncio) {
req->r_flags |= R_ASYNCWAIT;
}
while (req->r_flags & R_RESENDQ) {
struct timespec ts = { .tv_sec = 2, .tv_nsec = 0 };
if ((nmp = req->r_nmp)) {
lck_mtx_lock(&nmp->nm_lock);
if ((nmp->nm_state & NFSSTA_RECOVER) && (req->r_rchain.tqe_next != NFSREQNOLIST)) {
TAILQ_REMOVE(&nmp->nm_resendq, req, r_rchain);
req->r_rchain.tqe_next = NFSREQNOLIST;
if (req->r_flags & R_RESENDQ) {
req->r_flags &= ~R_RESENDQ;
}
assert(req->r_refs > 0);
req->r_refs--;
lck_mtx_unlock(&nmp->nm_lock);
break;
}
lck_mtx_unlock(&nmp->nm_lock);
}
if ((error = nfs_sigintr(req->r_nmp, req, req->r_thread, 0))) {
break;
}
msleep(req, &req->r_mtx, PZERO - 1, "nfsresendqwait", &ts);
}
lck_mtx_unlock(&req->r_mtx);
if (!error) {
nfs_request_wait(req);
error = nfs_request_finish(req, nmrepp, status);
}
while (!error && (req->r_flags & R_RESTART)) {
if (asyncio) {
assert(req->r_achain.tqe_next == NFSREQNOLIST);
lck_mtx_lock(&req->r_mtx);
req->r_flags &= ~R_IOD;
if (req->r_resendtime) {
nfs_asyncio_resend(req);
lck_mtx_unlock(&req->r_mtx);
return EINPROGRESS;
}
lck_mtx_unlock(&req->r_mtx);
}
req->r_error = 0;
req->r_flags &= ~R_RESTART;
if ((error = nfs_request_add_header(req))) {
break;
}
if ((error = nfs_request_send(req, !asyncio))) {
break;
}
if (asyncio) {
return EINPROGRESS;
}
nfs_request_wait(req);
if ((error = nfs_request_finish(req, nmrepp, status))) {
break;
}
}
if (xidp) {
*xidp = req->r_xid;
}
FSDBG(275, R_XID32(req->r_xid), req->r_np, req->r_procnum, error);
nfs_request_rele(req);
return error;
}
void
nfs_request_async_cancel(struct nfsreq *req)
{
FSDBG(275, R_XID32(req->r_xid), req->r_np, req->r_procnum, 0xD1ED1E);
nfs_request_rele(req);
}
void
nfs_softterm(struct nfsreq *req)
{
struct nfsmount *nmp = req->r_nmp;
req->r_flags |= R_SOFTTERM;
req->r_error = ETIMEDOUT;
if (!(req->r_flags & R_CWND) || nfs_mount_gone(nmp)) {
return;
}
req->r_flags &= ~R_CWND;
lck_mtx_lock(&nmp->nm_lock);
FSDBG(532, R_XID32(req->r_xid), req, nmp->nm_sent, nmp->nm_cwnd);
nmp->nm_sent -= NFS_CWNDSCALE;
if ((nmp->nm_sent < nmp->nm_cwnd) && !TAILQ_EMPTY(&nmp->nm_cwndq)) {
struct nfsreq *req2 = TAILQ_FIRST(&nmp->nm_cwndq);
TAILQ_REMOVE(&nmp->nm_cwndq, req2, r_cchain);
req2->r_cchain.tqe_next = NFSREQNOLIST;
wakeup(req2);
}
lck_mtx_unlock(&nmp->nm_lock);
}
void
nfs_reqdequeue(struct nfsreq *req)
{
lck_mtx_lock(nfs_request_mutex);
while (req->r_lflags & RL_BUSY) {
req->r_lflags |= RL_WAITING;
msleep(&req->r_lflags, nfs_request_mutex, PSOCK, "reqdeq", NULL);
}
if (req->r_lflags & RL_QUEUED) {
TAILQ_REMOVE(&nfs_reqq, req, r_chain);
req->r_lflags &= ~RL_QUEUED;
}
lck_mtx_unlock(nfs_request_mutex);
}
void
nfs_reqbusy(struct nfsreq *req)
{
if (req->r_lflags & RL_BUSY) {
panic("req locked");
}
req->r_lflags |= RL_BUSY;
}
struct nfsreq *
nfs_reqnext(struct nfsreq *req)
{
struct nfsreq * nextreq;
if (req == NULL) {
return NULL;
}
nextreq = TAILQ_NEXT(req, r_chain);
if (nextreq != NULL) {
nfs_reqbusy(nextreq);
}
req->r_lflags &= ~RL_BUSY;
if (req->r_lflags & RL_WAITING) {
req->r_lflags &= ~RL_WAITING;
wakeup(&req->r_lflags);
}
return nextreq;
}
void
nfs_request_timer(__unused void *param0, __unused void *param1)
{
struct nfsreq *req;
struct nfsmount *nmp;
int timeo, maxtime, finish_asyncio, error;
struct timeval now;
TAILQ_HEAD(nfs_mount_pokeq, nfsmount) nfs_mount_poke_queue;
TAILQ_INIT(&nfs_mount_poke_queue);
restart:
lck_mtx_lock(nfs_request_mutex);
req = TAILQ_FIRST(&nfs_reqq);
if (req == NULL) {
nfs_request_timer_on = 0;
lck_mtx_unlock(nfs_request_mutex);
return;
}
nfs_reqbusy(req);
microuptime(&now);
for (; req != NULL; req = nfs_reqnext(req)) {
nmp = req->r_nmp;
if (nmp == NULL) {
NFS_SOCK_DBG("Found a request with out a mount!\n");
continue;
}
if (req->r_error || req->r_nmrep.nmc_mhead) {
continue;
}
if ((error = nfs_sigintr(nmp, req, req->r_thread, 0))) {
if (req->r_callback.rcb_func != NULL) {
lck_mtx_lock(&req->r_mtx);
req->r_error = error;
finish_asyncio = !(req->r_flags & R_WAITSENT);
wakeup(req);
lck_mtx_unlock(&req->r_mtx);
if (finish_asyncio) {
nfs_asyncio_finish(req);
}
}
continue;
}
lck_mtx_lock(&req->r_mtx);
if (nmp->nm_tprintf_initial_delay &&
((req->r_rexmit > 2) || (req->r_flags & R_RESENDERR)) &&
((req->r_lastmsg + nmp->nm_tprintf_delay) < now.tv_sec)) {
req->r_lastmsg = now.tv_sec;
nfs_down(req->r_nmp, req->r_thread, 0, NFSSTA_TIMEO,
"not responding", 1);
req->r_flags |= R_TPRINTFMSG;
lck_mtx_lock(&nmp->nm_lock);
if (!(nmp->nm_state & NFSSTA_MOUNTED)) {
lck_mtx_unlock(&nmp->nm_lock);
OSAddAtomic64(1, &nfsstats.rpctimeouts);
nfs_softterm(req);
finish_asyncio = ((req->r_callback.rcb_func != NULL) && !(req->r_flags & R_WAITSENT));
wakeup(req);
lck_mtx_unlock(&req->r_mtx);
if (finish_asyncio) {
nfs_asyncio_finish(req);
}
continue;
}
lck_mtx_unlock(&nmp->nm_lock);
}
if (!(NMFLAG(nmp, SOFT) || (req->r_flags & R_SOFT)) && !nfs_can_squish(nmp)) {
maxtime = NFS_MAXTIMEO;
} else if ((req->r_flags & (R_SETUP | R_RECOVER)) ||
((nmp->nm_reconnect_start <= 0) || ((now.tv_sec - nmp->nm_reconnect_start) < 8))) {
maxtime = (NFS_MAXTIMEO / (nmp->nm_timeouts + 1)) / 2;
} else {
maxtime = NFS_MINTIMEO / 4;
}
if (req->r_rtt >= 0) {
req->r_rtt++;
lck_mtx_lock(&nmp->nm_lock);
if (req->r_flags & R_RESENDERR) {
timeo = 4 * hz;
} else {
if (req->r_procnum == NFSPROC_NULL && req->r_gss_ctx != NULL) {
timeo = NFS_MINIDEMTIMEO; } else if (NMFLAG(nmp, DUMBTIMER)) {
timeo = nmp->nm_timeo;
} else {
timeo = NFS_RTO(nmp, proct[req->r_procnum]);
}
while (16 * timeo < hz) {
timeo *= 2;
}
if (nmp->nm_timeouts > 0) {
timeo *= nfs_backoff[nmp->nm_timeouts - 1];
}
}
if (timeo > maxtime) {
timeo = maxtime;
}
if (req->r_rtt <= timeo) {
NFS_SOCK_DBG("nfs timeout: req time %d and timeo is %d continue\n", req->r_rtt, timeo);
lck_mtx_unlock(&nmp->nm_lock);
lck_mtx_unlock(&req->r_mtx);
continue;
}
NFS_SOCK_DBG("nfs timeout: proc %d %d xid %llx rtt %d to %d # %d, t %ld/%d\n",
req->r_procnum, proct[req->r_procnum],
req->r_xid, req->r_rtt, timeo, nmp->nm_timeouts,
(now.tv_sec - req->r_start) * NFS_HZ, maxtime);
if (nmp->nm_timeouts < 8) {
nmp->nm_timeouts++;
}
if (nfs_mount_check_dead_timeout(nmp)) {
req->r_lflags &= ~RL_BUSY;
if (req->r_lflags & RL_WAITING) {
req->r_lflags &= ~RL_WAITING;
wakeup(&req->r_lflags);
}
lck_mtx_unlock(&req->r_mtx);
if (nmp->nm_sockflags & NMSOCK_POKE) {
nmp->nm_sockflags &= ~NMSOCK_POKE;
TAILQ_REMOVE(&nfs_mount_poke_queue, nmp, nm_pokeq);
}
lck_mtx_unlock(nfs_request_mutex);
nmp->nm_ref++;
nfs_mount_make_zombie(nmp);
lck_mtx_unlock(&nmp->nm_lock);
nfs_mount_rele(nmp);
goto restart;
}
if ((nmp->nm_sotype == SOCK_STREAM) &&
((now.tv_sec - req->r_start) >= 3) &&
!(nmp->nm_sockflags & (NMSOCK_POKE | NMSOCK_UNMOUNT)) &&
(nmp->nm_sockflags & NMSOCK_READY)) {
nmp->nm_sockflags |= NMSOCK_POKE;
nmp->nm_ref++;
TAILQ_INSERT_TAIL(&nfs_mount_poke_queue, nmp, nm_pokeq);
}
lck_mtx_unlock(&nmp->nm_lock);
}
if ((NMFLAG(nmp, SOFT) || (req->r_flags & (R_SETUP | R_RECOVER | R_SOFT))) &&
((req->r_rexmit >= req->r_retry) ||
((now.tv_sec - req->r_start) * NFS_HZ > maxtime))) {
OSAddAtomic64(1, &nfsstats.rpctimeouts);
lck_mtx_lock(&nmp->nm_lock);
if (!(nmp->nm_state & NFSSTA_TIMEO)) {
lck_mtx_unlock(&nmp->nm_lock);
nfs_down(req->r_nmp, req->r_thread, 0, NFSSTA_TIMEO,
"not responding", 1);
req->r_lastmsg = now.tv_sec;
req->r_flags |= R_TPRINTFMSG;
} else {
lck_mtx_unlock(&nmp->nm_lock);
}
if (req->r_flags & R_NOINTR) {
lck_mtx_unlock(&req->r_mtx);
continue;
}
NFS_SOCK_DBG("nfs timer TERMINATE: p %d x 0x%llx f 0x%x rtt %d t %ld\n",
req->r_procnum, req->r_xid, req->r_flags, req->r_rtt,
now.tv_sec - req->r_start);
nfs_softterm(req);
finish_asyncio = ((req->r_callback.rcb_func != NULL) && !(req->r_flags & R_WAITSENT));
wakeup(req);
lck_mtx_unlock(&req->r_mtx);
if (finish_asyncio) {
nfs_asyncio_finish(req);
}
continue;
}
if ((nmp->nm_sotype == SOCK_STREAM) && !(req->r_flags & R_MUSTRESEND)) {
if (++req->r_rexmit > NFS_MAXREXMIT) {
req->r_rexmit = NFS_MAXREXMIT;
}
req->r_rtt = 0;
lck_mtx_unlock(&req->r_mtx);
continue;
}
if ((req->r_flags & R_MUSTRESEND) && (req->r_rtt == -1)) {
lck_mtx_unlock(&req->r_mtx);
continue;
}
NFS_SOCK_DBG("nfs timer mark resend: p %d x 0x%llx f 0x%x rtt %d\n",
req->r_procnum, req->r_xid, req->r_flags, req->r_rtt);
req->r_flags |= R_MUSTRESEND;
req->r_rtt = -1;
wakeup(req);
if ((req->r_flags & (R_IOD | R_ASYNC | R_ASYNCWAIT | R_SENDING)) == R_ASYNC) {
nfs_asyncio_resend(req);
}
lck_mtx_unlock(&req->r_mtx);
}
lck_mtx_unlock(nfs_request_mutex);
while ((nmp = TAILQ_FIRST(&nfs_mount_poke_queue))) {
TAILQ_REMOVE(&nfs_mount_poke_queue, nmp, nm_pokeq);
nfs_sock_poke(nmp);
nfs_mount_rele(nmp);
}
nfs_interval_timer_start(nfs_request_timer_call, NFS_REQUESTDELAY);
}
int
nfs_noremotehang(thread_t thd)
{
proc_t p = thd ? get_bsdthreadtask_info(thd) : NULL;
return p && proc_noremotehang(p);
}
extern int sigprop[NSIG + 1];
int
nfs_sigintr(struct nfsmount *nmp, struct nfsreq *req, thread_t thd, int nmplocked)
{
proc_t p;
int error = 0;
if (!nmp) {
return ENXIO;
}
if (req && (req->r_flags & R_SOFTTERM)) {
return ETIMEDOUT;
}
if (req && (req->r_flags & R_NOINTR)) {
thd = NULL;
}
if (!nmplocked) {
lck_mtx_lock(&nmp->nm_lock);
}
if (nmp->nm_state & NFSSTA_FORCE) {
error = EIO;
} else if (vfs_isforce(nmp->nm_mountp)) {
NFS_BITMAP_SET(nmp->nm_flags, NFS_MFLAG_SOFT);
nmp->nm_state |= NFSSTA_FORCE;
}
if (!error && (nmp->nm_state & NFSSTA_DEAD)) {
error = ENXIO;
}
if (current_proc() != kernproc &&
!error && (nmp->nm_state & NFSSTA_TIMEO) && nfs_noremotehang(thd)) {
error = EIO;
}
if (!nmplocked) {
lck_mtx_unlock(&nmp->nm_lock);
}
if (error) {
return error;
}
if (thd == NULL || current_proc() == kernproc) {
return 0;
}
if (((p = current_proc()) != kernproc) && current_thread_aborted() &&
(!(p->p_acflag & AXSIG) || (p->exit_thread != current_thread()) ||
(p->p_sigacts == NULL) ||
(p->p_sigacts->ps_sig < 1) || (p->p_sigacts->ps_sig > NSIG) ||
!(sigprop[p->p_sigacts->ps_sig] & SA_CORE))) {
return EINTR;
}
if (NMFLAG(nmp, INTR) && ((p = get_bsdthreadtask_info(thd))) &&
proc_pendingsignals(p, NFSINT_SIGMASK)) {
return EINTR;
}
return 0;
}
int
nfs_sndlock(struct nfsreq *req)
{
struct nfsmount *nmp = req->r_nmp;
int *statep;
int error = 0, slpflag = 0;
struct timespec ts = { .tv_sec = 0, .tv_nsec = 0 };
if (nfs_mount_gone(nmp)) {
return ENXIO;
}
lck_mtx_lock(&nmp->nm_lock);
statep = &nmp->nm_state;
if (NMFLAG(nmp, INTR) && req->r_thread && !(req->r_flags & R_NOINTR)) {
slpflag = PCATCH;
}
while (*statep & NFSSTA_SNDLOCK) {
if ((error = nfs_sigintr(nmp, req, req->r_thread, 1))) {
break;
}
*statep |= NFSSTA_WANTSND;
if (nfs_noremotehang(req->r_thread)) {
ts.tv_sec = 1;
}
msleep(statep, &nmp->nm_lock, slpflag | (PZERO - 1), "nfsndlck", &ts);
if (slpflag == PCATCH) {
slpflag = 0;
ts.tv_sec = 2;
}
}
if (!error) {
*statep |= NFSSTA_SNDLOCK;
}
lck_mtx_unlock(&nmp->nm_lock);
return error;
}
void
nfs_sndunlock(struct nfsreq *req)
{
struct nfsmount *nmp = req->r_nmp;
int *statep, wake = 0;
if (!nmp) {
return;
}
lck_mtx_lock(&nmp->nm_lock);
statep = &nmp->nm_state;
if ((*statep & NFSSTA_SNDLOCK) == 0) {
panic("nfs sndunlock");
}
*statep &= ~(NFSSTA_SNDLOCK | NFSSTA_SENDING);
if (*statep & NFSSTA_WANTSND) {
*statep &= ~NFSSTA_WANTSND;
wake = 1;
}
lck_mtx_unlock(&nmp->nm_lock);
if (wake) {
wakeup(statep);
}
}
int
nfs_aux_request(
struct nfsmount *nmp,
thread_t thd,
struct sockaddr *saddr,
socket_t so,
int sotype,
mbuf_t mreq,
uint32_t xid,
int bindresv,
int timeo,
struct nfsm_chain *nmrep)
{
int error = 0, on = 1, try, sendat = 2, soproto, recv, optlen, restoreto = 0;
socket_t newso = NULL;
struct sockaddr_storage ss;
struct timeval orig_rcvto, orig_sndto, tv = { .tv_sec = 1, .tv_usec = 0 };
mbuf_t m, mrep = NULL;
struct msghdr msg;
uint32_t rxid = 0, reply = 0, reply_status, rejected_status;
uint32_t verf_type, verf_len, accepted_status;
size_t readlen, sentlen;
struct nfs_rpc_record_state nrrs;
if (!so) {
if (saddr->sa_family == AF_LOCAL) {
soproto = 0;
} else {
soproto = (sotype == SOCK_DGRAM) ? IPPROTO_UDP : IPPROTO_TCP;
}
if ((error = sock_socket(saddr->sa_family, sotype, soproto, NULL, NULL, &newso))) {
goto nfsmout;
}
if (bindresv && saddr->sa_family != AF_LOCAL) {
int level = (saddr->sa_family == AF_INET) ? IPPROTO_IP : IPPROTO_IPV6;
int optname = (saddr->sa_family == AF_INET) ? IP_PORTRANGE : IPV6_PORTRANGE;
int portrange = IP_PORTRANGE_LOW;
error = sock_setsockopt(newso, level, optname, &portrange, sizeof(portrange));
nfsmout_if(error);
ss.ss_len = saddr->sa_len;
ss.ss_family = saddr->sa_family;
if (ss.ss_family == AF_INET) {
((struct sockaddr_in*)&ss)->sin_addr.s_addr = INADDR_ANY;
((struct sockaddr_in*)&ss)->sin_port = htons(0);
} else if (ss.ss_family == AF_INET6) {
((struct sockaddr_in6*)&ss)->sin6_addr = in6addr_any;
((struct sockaddr_in6*)&ss)->sin6_port = htons(0);
} else {
error = EINVAL;
}
if (!error) {
error = sock_bind(newso, (struct sockaddr *)&ss);
}
nfsmout_if(error);
}
if (sotype == SOCK_STREAM) {
# define NFS_AUX_CONNECTION_TIMEOUT 4
int count = 0;
error = sock_connect(newso, saddr, MSG_DONTWAIT);
if (error == EINPROGRESS) {
error = 0;
}
nfsmout_if(error);
while ((error = sock_connectwait(newso, &tv)) == EINPROGRESS) {
if (++count >= NFS_AUX_CONNECTION_TIMEOUT) {
error = ETIMEDOUT;
break;
}
}
nfsmout_if(error);
}
if (((error = sock_setsockopt(newso, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)))) ||
((error = sock_setsockopt(newso, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)))) ||
((error = sock_setsockopt(newso, SOL_SOCKET, SO_NOADDRERR, &on, sizeof(on))))) {
goto nfsmout;
}
so = newso;
} else {
optlen = sizeof(orig_rcvto);
error = sock_getsockopt(so, SOL_SOCKET, SO_RCVTIMEO, &orig_rcvto, &optlen);
if (!error) {
optlen = sizeof(orig_sndto);
error = sock_getsockopt(so, SOL_SOCKET, SO_SNDTIMEO, &orig_sndto, &optlen);
}
if (!error) {
sock_setsockopt(so, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
sock_setsockopt(so, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
restoreto = 1;
}
}
if (sotype == SOCK_STREAM) {
sendat = 0;
nfs_rpc_record_state_init(&nrrs);
}
for (try = 0; try < timeo; try++) {
if ((error = nfs_sigintr(nmp, NULL, !try ? NULL : thd, 0))) {
break;
}
if (!try || (try == sendat)) {
if ((error = mbuf_copym(mreq, 0, MBUF_COPYALL, MBUF_WAITOK, &m))) {
goto nfsmout;
}
bzero(&msg, sizeof(msg));
if ((sotype == SOCK_DGRAM) && !sock_isconnected(so)) {
msg.msg_name = saddr;
msg.msg_namelen = saddr->sa_len;
}
if ((error = sock_sendmbuf(so, &msg, m, 0, &sentlen))) {
goto nfsmout;
}
sendat *= 2;
if (sendat > 30) {
sendat = 30;
}
}
if (sotype == SOCK_STREAM) {
error = nfs_rpc_record_read(so, &nrrs, 0, &recv, &mrep);
} else {
readlen = 1 << 18;
bzero(&msg, sizeof(msg));
error = sock_receivembuf(so, &msg, &mrep, 0, &readlen);
}
if (error == EWOULDBLOCK) {
continue;
}
nfsmout_if(error);
nfsm_chain_dissect_init(error, nmrep, mrep);
nfsm_chain_get_32(error, nmrep, rxid);
nfsm_chain_get_32(error, nmrep, reply);
nfsmout_if(error);
if ((rxid != xid) || (reply != RPC_REPLY)) {
error = EBADRPC;
}
nfsm_chain_get_32(error, nmrep, reply_status);
nfsmout_if(error);
if (reply_status == RPC_MSGDENIED) {
nfsm_chain_get_32(error, nmrep, rejected_status);
nfsmout_if(error);
error = (rejected_status == RPC_MISMATCH) ? ERPCMISMATCH : EACCES;
goto nfsmout;
}
nfsm_chain_get_32(error, nmrep, verf_type);
nfsm_chain_get_32(error, nmrep, verf_len);
nfsmout_if(error);
if (verf_len) {
nfsm_chain_adv(error, nmrep, nfsm_rndup(verf_len));
}
nfsm_chain_get_32(error, nmrep, accepted_status);
nfsmout_if(error);
switch (accepted_status) {
case RPC_SUCCESS:
error = 0;
break;
case RPC_PROGUNAVAIL:
error = EPROGUNAVAIL;
break;
case RPC_PROGMISMATCH:
error = EPROGMISMATCH;
break;
case RPC_PROCUNAVAIL:
error = EPROCUNAVAIL;
break;
case RPC_GARBAGE:
error = EBADRPC;
break;
case RPC_SYSTEM_ERR:
default:
error = EIO;
break;
}
break;
}
nfsmout:
if (restoreto) {
sock_setsockopt(so, SOL_SOCKET, SO_RCVTIMEO, &orig_rcvto, sizeof(tv));
sock_setsockopt(so, SOL_SOCKET, SO_SNDTIMEO, &orig_sndto, sizeof(tv));
}
if (newso) {
sock_shutdown(newso, SHUT_RDWR);
sock_close(newso);
}
mbuf_freem(mreq);
return error;
}
int
nfs_portmap_lookup(
struct nfsmount *nmp,
vfs_context_t ctx,
struct sockaddr *sa,
socket_t so,
uint32_t protocol,
uint32_t vers,
uint32_t stype,
int timeo)
{
thread_t thd = vfs_context_thread(ctx);
kauth_cred_t cred = vfs_context_ucred(ctx);
struct sockaddr_storage ss;
struct sockaddr *saddr = (struct sockaddr*)&ss;
static struct sockaddr_un rpcbind_cots = {
sizeof(struct sockaddr_un),
AF_LOCAL,
RPCB_TICOTSORD_PATH
};
static struct sockaddr_un rpcbind_clts = {
sizeof(struct sockaddr_un),
AF_LOCAL,
RPCB_TICLTS_PATH
};
struct nfsm_chain nmreq, nmrep;
mbuf_t mreq;
int error = 0, ip, pmprog, pmvers, pmproc;
uint32_t ualen = 0;
uint32_t port;
uint64_t xid = 0;
char uaddr[MAX_IPv6_STR_LEN + 16];
bcopy(sa, saddr, min(sizeof(ss), sa->sa_len));
if (saddr->sa_family == AF_INET) {
ip = 4;
pmprog = PMAPPROG;
pmvers = PMAPVERS;
pmproc = PMAPPROC_GETPORT;
} else if (saddr->sa_family == AF_INET6) {
ip = 6;
pmprog = RPCBPROG;
pmvers = RPCBVERS4;
pmproc = RPCBPROC_GETVERSADDR;
} else if (saddr->sa_family == AF_LOCAL) {
ip = 0;
pmprog = RPCBPROG;
pmvers = RPCBVERS4;
pmproc = RPCBPROC_GETVERSADDR;
NFS_SOCK_DBG("%s\n", ((struct sockaddr_un*)sa)->sun_path);
saddr = (struct sockaddr*)((stype == SOCK_STREAM) ? &rpcbind_cots : &rpcbind_clts);
} else {
return EINVAL;
}
nfsm_chain_null(&nmreq);
nfsm_chain_null(&nmrep);
tryagain:
if (ip == 4) {
((struct sockaddr_in*)saddr)->sin_port = htons(PMAPPORT);
} else if (ip == 6) {
((struct sockaddr_in6*)saddr)->sin6_port = htons(PMAPPORT);
}
nfsm_chain_build_alloc_init(error, &nmreq, 8 * NFSX_UNSIGNED);
nfsm_chain_add_32(error, &nmreq, protocol);
nfsm_chain_add_32(error, &nmreq, vers);
if (ip == 4) {
nfsm_chain_add_32(error, &nmreq, stype == SOCK_STREAM ? IPPROTO_TCP : IPPROTO_UDP);
nfsm_chain_add_32(error, &nmreq, 0);
} else {
if (stype == SOCK_STREAM) {
if (ip == 6) {
nfsm_chain_add_string(error, &nmreq, "tcp6", 4);
} else {
nfsm_chain_add_string(error, &nmreq, "ticotsord", 9);
}
} else {
if (ip == 6) {
nfsm_chain_add_string(error, &nmreq, "udp6", 4);
} else {
nfsm_chain_add_string(error, &nmreq, "ticlts", 6);
}
}
nfsm_chain_add_string(error, &nmreq, "", 0);
nfsm_chain_add_string(error, &nmreq, "", 0);
}
nfsm_chain_build_done(error, &nmreq);
nfsmout_if(error);
error = nfsm_rpchead2(nmp, stype, pmprog, pmvers, pmproc,
RPCAUTH_SYS, cred, NULL, nmreq.nmc_mhead, &xid, &mreq);
nfsmout_if(error);
nmreq.nmc_mhead = NULL;
NFS_SOCK_DUMP_MBUF("nfs_portmap_loockup request", mreq);
error = nfs_aux_request(nmp, thd, saddr, so,
stype, mreq, R_XID32(xid), 0, timeo, &nmrep);
NFS_SOCK_DUMP_MBUF("nfs_portmap_lookup reply", nmrep.nmc_mhead);
NFS_SOCK_DBG("rpcbind request returned %d for program %u vers %u: %s\n", error, protocol, vers,
(saddr->sa_family == AF_LOCAL) ? ((struct sockaddr_un *)saddr)->sun_path :
(saddr->sa_family == AF_INET6) ? "INET6 socket" : "INET socket");
if (ip == 4) {
nfsm_chain_get_32(error, &nmrep, port);
if (!error) {
((struct sockaddr_in*)sa)->sin_port = htons(port);
}
} else {
nfsm_chain_get_32(error, &nmrep, ualen);
if (!error) {
if (ualen > (sizeof(uaddr) - 1)) {
error = EIO;
}
if (ualen < 1) {
bcopy(sa, saddr, min(sizeof(ss), sa->sa_len));
if (ip == 6) {
((struct sockaddr_in6*)saddr)->sin6_port = htons(0);
} else {
((struct sockaddr_un*)saddr)->sun_path[0] = '\0';
}
NFS_SOCK_DBG("Program %u version %u unavailable", protocol, vers);
} else {
nfsm_chain_get_opaque(error, &nmrep, ualen, uaddr);
NFS_SOCK_DBG("Got uaddr %s\n", uaddr);
if (!error) {
uaddr[ualen] = '\0';
if (!nfs_uaddr2sockaddr(uaddr, saddr)) {
error = EIO;
}
}
}
}
if ((error == EPROGMISMATCH) || (error == EPROCUNAVAIL) || (error == EIO) || (error == EBADRPC)) {
if (pmvers == RPCBVERS4) {
pmvers = RPCBVERS3;
pmproc = RPCBPROC_GETADDR;
nfsm_chain_cleanup(&nmreq);
nfsm_chain_cleanup(&nmrep);
bcopy(sa, saddr, min(sizeof(ss), sa->sa_len));
xid = 0;
error = 0;
goto tryagain;
}
}
if (!error) {
bcopy(saddr, sa, min(saddr->sa_len, sa->sa_len));
}
}
nfsmout:
nfsm_chain_cleanup(&nmreq);
nfsm_chain_cleanup(&nmrep);
NFS_SOCK_DBG("Returned %d\n", error);
return error;
}
int
nfs_msg(thread_t thd,
const char *server,
const char *msg,
int error)
{
proc_t p = thd ? get_bsdthreadtask_info(thd) : NULL;
tpr_t tpr;
if (p) {
tpr = tprintf_open(p);
} else {
tpr = NULL;
}
if (error) {
tprintf(tpr, "nfs server %s: %s, error %d\n", server, msg, error);
} else {
tprintf(tpr, "nfs server %s: %s\n", server, msg);
}
tprintf_close(tpr);
return 0;
}
#define NFS_SQUISH_MOBILE_ONLY 0x0001
#define NFS_SQUISH_AUTOMOUNTED_ONLY 0x0002
#define NFS_SQUISH_SOFT 0x0004
#define NFS_SQUISH_QUICK 0x0008
#define NFS_SQUISH_SHUTDOWN 0x1000
uint32_t nfs_squishy_flags = NFS_SQUISH_MOBILE_ONLY | NFS_SQUISH_AUTOMOUNTED_ONLY | NFS_SQUISH_QUICK;
int32_t nfs_is_mobile;
#define NFS_SQUISHY_DEADTIMEOUT 8
#define NFS_SQUISHY_QUICKTIMEOUT 4
int
nfs_can_squish(struct nfsmount *nmp)
{
uint64_t flags = vfs_flags(nmp->nm_mountp);
int softsquish = ((nfs_squishy_flags & NFS_SQUISH_SOFT) & NMFLAG(nmp, SOFT));
if (!softsquish && (nfs_squishy_flags & NFS_SQUISH_MOBILE_ONLY) && nfs_is_mobile == 0) {
return 0;
}
if ((nfs_squishy_flags & NFS_SQUISH_AUTOMOUNTED_ONLY) && (flags & MNT_AUTOMOUNTED) == 0) {
return 0;
}
return 1;
}
int
nfs_is_squishy(struct nfsmount *nmp)
{
mount_t mp = nmp->nm_mountp;
int squishy = 0;
int timeo = (nfs_squishy_flags & NFS_SQUISH_QUICK) ? NFS_SQUISHY_QUICKTIMEOUT : NFS_SQUISHY_DEADTIMEOUT;
NFS_SOCK_DBG("%s: nm_curdeadtimeout = %d, nfs_is_mobile = %d\n",
vfs_statfs(mp)->f_mntfromname, nmp->nm_curdeadtimeout, nfs_is_mobile);
if (!nfs_can_squish(nmp)) {
goto out;
}
timeo = (nmp->nm_deadtimeout > timeo) ? max(nmp->nm_deadtimeout / 8, timeo) : timeo;
NFS_SOCK_DBG("nm_writers = %d nm_mappers = %d timeo = %d\n", nmp->nm_writers, nmp->nm_mappers, timeo);
if (nmp->nm_writers == 0 && nmp->nm_mappers == 0) {
uint64_t flags = mp ? vfs_flags(mp) : 0;
squishy = 1;
if (!(flags & MNT_RDONLY) && !(nmp->nm_state & NFSSTA_SQUISHY)) {
squishy = !nfs_mount_is_dirty(mp);
}
}
out:
if (squishy) {
nmp->nm_state |= NFSSTA_SQUISHY;
} else {
nmp->nm_state &= ~NFSSTA_SQUISHY;
}
nmp->nm_curdeadtimeout = squishy ? timeo : nmp->nm_deadtimeout;
NFS_SOCK_DBG("nm_curdeadtimeout = %d\n", nmp->nm_curdeadtimeout);
return squishy;
}
int
nfs_is_dead(int error, struct nfsmount *nmp)
{
fsid_t fsid;
lck_mtx_lock(&nmp->nm_lock);
if (nmp->nm_state & NFSSTA_DEAD) {
lck_mtx_unlock(&nmp->nm_lock);
return 1;
}
if ((error != ENETUNREACH && error != EHOSTUNREACH && error != EADDRNOTAVAIL) ||
!(nmp->nm_locations.nl_numlocs == 1 && nmp->nm_locations.nl_locations[0]->nl_servcount == 1)) {
lck_mtx_unlock(&nmp->nm_lock);
return 0;
}
if ((nfs_squishy_flags & NFS_SQUISH_QUICK) && nfs_is_squishy(nmp)) {
printf("nfs_is_dead: nfs server %s: unreachable. Squished dead\n", vfs_statfs(nmp->nm_mountp)->f_mntfromname);
fsid = vfs_statfs(nmp->nm_mountp)->f_fsid;
lck_mtx_unlock(&nmp->nm_lock);
nfs_mount_zombie(nmp, NFSSTA_DEAD);
vfs_event_signal(&fsid, VQ_DEAD, 0);
return 1;
}
lck_mtx_unlock(&nmp->nm_lock);
return 0;
}
int
nfs_use_cache(struct nfsmount *nmp)
{
int cache_ok = (nfs_is_mobile || NMFLAG(nmp, SOFT) ||
nfs_can_squish(nmp) || nmp->nm_deadtimeout);
int timeoutmask = NFSSTA_TIMEO | NFSSTA_LOCKTIMEO | NFSSTA_JUKEBOXTIMEO;
return (nmp->nm_state & timeoutmask) && cache_ok;
}
void
nfs_down(struct nfsmount *nmp, thread_t thd, int error, int flags, const char *msg, int holding_state)
{
int timeoutmask, wasunresponsive, unresponsive, softnobrowse;
uint32_t do_vfs_signal = 0;
struct timeval now;
if (nfs_mount_gone(nmp)) {
return;
}
lck_mtx_lock(&nmp->nm_lock);
timeoutmask = NFSSTA_TIMEO | NFSSTA_LOCKTIMEO | NFSSTA_JUKEBOXTIMEO;
if (NMFLAG(nmp, MUTEJUKEBOX)) {
timeoutmask &= ~NFSSTA_JUKEBOXTIMEO;
}
wasunresponsive = (nmp->nm_state & timeoutmask);
softnobrowse = (NMFLAG(nmp, SOFT) && (vfs_flags(nmp->nm_mountp) & MNT_DONTBROWSE));
if ((flags & NFSSTA_TIMEO) && !(nmp->nm_state & NFSSTA_TIMEO)) {
nmp->nm_state |= NFSSTA_TIMEO;
}
if ((flags & NFSSTA_LOCKTIMEO) && !(nmp->nm_state & NFSSTA_LOCKTIMEO)) {
nmp->nm_state |= NFSSTA_LOCKTIMEO;
}
if ((flags & NFSSTA_JUKEBOXTIMEO) && !(nmp->nm_state & NFSSTA_JUKEBOXTIMEO)) {
nmp->nm_state |= NFSSTA_JUKEBOXTIMEO;
}
unresponsive = (nmp->nm_state & timeoutmask);
nfs_is_squishy(nmp);
if (unresponsive && (nmp->nm_curdeadtimeout > 0)) {
microuptime(&now);
if (!wasunresponsive) {
nmp->nm_deadto_start = now.tv_sec;
nfs_mount_sock_thread_wake(nmp);
} else if ((now.tv_sec - nmp->nm_deadto_start) > nmp->nm_curdeadtimeout && !holding_state) {
if (!(nmp->nm_state & NFSSTA_DEAD)) {
printf("nfs server %s: %sdead\n", vfs_statfs(nmp->nm_mountp)->f_mntfromname,
(nmp->nm_curdeadtimeout != nmp->nm_deadtimeout) ? "squished " : "");
}
do_vfs_signal = VQ_DEAD;
}
}
lck_mtx_unlock(&nmp->nm_lock);
if (do_vfs_signal == VQ_DEAD && !(nmp->nm_state & NFSSTA_DEAD)) {
nfs_mount_zombie(nmp, NFSSTA_DEAD);
} else if (softnobrowse || wasunresponsive || !unresponsive) {
do_vfs_signal = 0;
} else {
do_vfs_signal = VQ_NOTRESP;
}
if (do_vfs_signal) {
vfs_event_signal(&vfs_statfs(nmp->nm_mountp)->f_fsid, do_vfs_signal, 0);
}
nfs_msg(thd, vfs_statfs(nmp->nm_mountp)->f_mntfromname, msg, error);
}
void
nfs_up(struct nfsmount *nmp, thread_t thd, int flags, const char *msg)
{
int timeoutmask, wasunresponsive, unresponsive, softnobrowse;
int do_vfs_signal;
if (nfs_mount_gone(nmp)) {
return;
}
if (msg) {
nfs_msg(thd, vfs_statfs(nmp->nm_mountp)->f_mntfromname, msg, 0);
}
lck_mtx_lock(&nmp->nm_lock);
timeoutmask = NFSSTA_TIMEO | NFSSTA_LOCKTIMEO | NFSSTA_JUKEBOXTIMEO;
if (NMFLAG(nmp, MUTEJUKEBOX)) {
timeoutmask &= ~NFSSTA_JUKEBOXTIMEO;
}
wasunresponsive = (nmp->nm_state & timeoutmask);
softnobrowse = (NMFLAG(nmp, SOFT) && (vfs_flags(nmp->nm_mountp) & MNT_DONTBROWSE));
if ((flags & NFSSTA_TIMEO) && (nmp->nm_state & NFSSTA_TIMEO)) {
nmp->nm_state &= ~NFSSTA_TIMEO;
}
if ((flags & NFSSTA_LOCKTIMEO) && (nmp->nm_state & NFSSTA_LOCKTIMEO)) {
nmp->nm_state &= ~NFSSTA_LOCKTIMEO;
}
if ((flags & NFSSTA_JUKEBOXTIMEO) && (nmp->nm_state & NFSSTA_JUKEBOXTIMEO)) {
nmp->nm_state &= ~NFSSTA_JUKEBOXTIMEO;
}
unresponsive = (nmp->nm_state & timeoutmask);
nmp->nm_deadto_start = 0;
nmp->nm_curdeadtimeout = nmp->nm_deadtimeout;
nmp->nm_state &= ~NFSSTA_SQUISHY;
lck_mtx_unlock(&nmp->nm_lock);
if (softnobrowse) {
do_vfs_signal = 0;
} else {
do_vfs_signal = (wasunresponsive && !unresponsive);
}
if (do_vfs_signal) {
vfs_event_signal(&vfs_statfs(nmp->nm_mountp)->f_fsid, VQ_NOTRESP, 1);
}
}
#endif
#if NFSSERVER
int
nfsrv_rephead(
struct nfsrv_descript *nd,
__unused struct nfsrv_sock *slp,
struct nfsm_chain *nmrepp,
size_t siz)
{
mbuf_t mrep;
u_int32_t *tl;
struct nfsm_chain nmrep;
int err, error;
err = nd->nd_repstat;
if (err && (nd->nd_vers == NFS_VER2)) {
siz = 0;
}
siz += RPC_REPLYSIZ;
if (siz >= nfs_mbuf_minclsize) {
error = mbuf_getpacket(MBUF_WAITOK, &mrep);
} else {
error = mbuf_gethdr(MBUF_WAITOK, MBUF_TYPE_DATA, &mrep);
}
if (error) {
return error;
}
if (siz < nfs_mbuf_minclsize) {
tl = mbuf_data(mrep);
tl += 80 / sizeof(*tl);
mbuf_setdata(mrep, tl, 6 * NFSX_UNSIGNED);
}
nfsm_chain_init(&nmrep, mrep);
nfsm_chain_add_32(error, &nmrep, nd->nd_retxid);
nfsm_chain_add_32(error, &nmrep, RPC_REPLY);
if (err == ERPCMISMATCH || (err & NFSERR_AUTHERR)) {
nfsm_chain_add_32(error, &nmrep, RPC_MSGDENIED);
if (err & NFSERR_AUTHERR) {
nfsm_chain_add_32(error, &nmrep, RPC_AUTHERR);
nfsm_chain_add_32(error, &nmrep, (err & ~NFSERR_AUTHERR));
} else {
nfsm_chain_add_32(error, &nmrep, RPC_MISMATCH);
nfsm_chain_add_32(error, &nmrep, RPC_VER2);
nfsm_chain_add_32(error, &nmrep, RPC_VER2);
}
} else {
nfsm_chain_add_32(error, &nmrep, RPC_MSGACCEPTED);
if (nd->nd_gss_context != NULL) {
error = nfs_gss_svc_verf_put(nd, &nmrep);
if (error) {
nfsm_chain_add_32(error, &nmrep, RPC_SYSTEM_ERR);
goto done;
}
} else {
nfsm_chain_add_32(error, &nmrep, RPCAUTH_NULL);
nfsm_chain_add_32(error, &nmrep, 0);
}
switch (err) {
case EPROGUNAVAIL:
nfsm_chain_add_32(error, &nmrep, RPC_PROGUNAVAIL);
break;
case EPROGMISMATCH:
nfsm_chain_add_32(error, &nmrep, RPC_PROGMISMATCH);
nfsm_chain_add_32(error, &nmrep, NFS_VER2);
nfsm_chain_add_32(error, &nmrep, NFS_VER3);
break;
case EPROCUNAVAIL:
nfsm_chain_add_32(error, &nmrep, RPC_PROCUNAVAIL);
break;
case EBADRPC:
nfsm_chain_add_32(error, &nmrep, RPC_GARBAGE);
break;
default:
nfsm_chain_add_32(error, &nmrep, RPC_SUCCESS);
if (nd->nd_gss_context != NULL) {
error = nfs_gss_svc_prepare_reply(nd, &nmrep);
}
if (err != NFSERR_RETVOID) {
nfsm_chain_add_32(error, &nmrep,
(err ? nfsrv_errmap(nd, err) : 0));
}
break;
}
}
done:
nfsm_chain_build_done(error, &nmrep);
if (error) {
mbuf_freem(mrep);
return error;
}
*nmrepp = nmrep;
if ((err != 0) && (err != NFSERR_RETVOID)) {
OSAddAtomic64(1, &nfsstats.srvrpc_errs);
}
return 0;
}
int
nfsrv_send(struct nfsrv_sock *slp, mbuf_t nam, mbuf_t top)
{
int error;
socket_t so = slp->ns_so;
struct sockaddr *sendnam;
struct msghdr msg;
bzero(&msg, sizeof(msg));
if (nam && !sock_isconnected(so) && (slp->ns_sotype != SOCK_STREAM)) {
if ((sendnam = mbuf_data(nam))) {
msg.msg_name = (caddr_t)sendnam;
msg.msg_namelen = sendnam->sa_len;
}
}
if (NFS_IS_DBG(NFS_FAC_SRV, 15)) {
nfs_dump_mbuf(__func__, __LINE__, "nfsrv_send\n", top);
}
error = sock_sendmbuf(so, &msg, top, 0, NULL);
if (!error) {
return 0;
}
log(LOG_INFO, "nfsd send error %d\n", error);
if ((error == EWOULDBLOCK) && (slp->ns_sotype == SOCK_STREAM)) {
error = EPIPE;
}
if (error != EINTR && error != ERESTART && error != EIO &&
error != EWOULDBLOCK && error != EPIPE) {
error = 0;
}
return error;
}
void
nfsrv_rcv(socket_t so, void *arg, int waitflag)
{
struct nfsrv_sock *slp = arg;
if (!nfsd_thread_count || !(slp->ns_flag & SLP_VALID)) {
return;
}
lck_rw_lock_exclusive(&slp->ns_rwlock);
nfsrv_rcv_locked(so, slp, waitflag);
}
void
nfsrv_rcv_locked(socket_t so, struct nfsrv_sock *slp, int waitflag)
{
mbuf_t m, mp, mhck, m2;
int ns_flag = 0, error;
struct msghdr msg;
size_t bytes_read;
if ((slp->ns_flag & SLP_VALID) == 0) {
if (waitflag == MBUF_DONTWAIT) {
lck_rw_done(&slp->ns_rwlock);
}
return;
}
#ifdef notdef
if (waitflag == MBUF_DONTWAIT) {
ns_flag = SLP_NEEDQ;
goto dorecs;
}
#endif
if (slp->ns_sotype == SOCK_STREAM) {
if (slp->ns_rec) {
ns_flag = SLP_NEEDQ;
goto dorecs;
}
bytes_read = 1000000000;
error = sock_receivembuf(so, NULL, &mp, MSG_DONTWAIT, &bytes_read);
if (error || mp == NULL) {
if (error == EWOULDBLOCK) {
ns_flag = (waitflag == MBUF_DONTWAIT) ? SLP_NEEDQ : 0;
} else {
ns_flag = SLP_DISCONN;
}
goto dorecs;
}
m = mp;
if (slp->ns_rawend) {
if ((error = mbuf_setnext(slp->ns_rawend, m))) {
panic("nfsrv_rcv: mbuf_setnext failed %d\n", error);
}
slp->ns_cc += bytes_read;
} else {
slp->ns_raw = m;
slp->ns_cc = bytes_read;
}
while ((m2 = mbuf_next(m))) {
m = m2;
}
slp->ns_rawend = m;
error = nfsrv_getstream(slp, waitflag);
if (error) {
if (error == EPERM) {
ns_flag = SLP_DISCONN;
} else {
ns_flag = SLP_NEEDQ;
}
}
} else {
struct sockaddr_storage nam;
if (slp->ns_reccnt >= nfsrv_sock_max_rec_queue_length) {
ns_flag = SLP_NEEDQ;
goto dorecs;
}
bzero(&msg, sizeof(msg));
msg.msg_name = (caddr_t)&nam;
msg.msg_namelen = sizeof(nam);
do {
bytes_read = 1000000000;
error = sock_receivembuf(so, &msg, &mp, MSG_DONTWAIT | MSG_NEEDSA, &bytes_read);
if (mp) {
if (msg.msg_name && (mbuf_get(MBUF_WAITOK, MBUF_TYPE_SONAME, &mhck) == 0)) {
mbuf_setlen(mhck, nam.ss_len);
bcopy(&nam, mbuf_data(mhck), nam.ss_len);
m = mhck;
if (mbuf_setnext(m, mp)) {
printf("nfsrv_rcv: mbuf_setnext failed\n");
mbuf_free(mhck);
m = mp;
}
} else {
m = mp;
}
if (slp->ns_recend) {
mbuf_setnextpkt(slp->ns_recend, m);
} else {
slp->ns_rec = m;
slp->ns_flag |= SLP_DOREC;
}
slp->ns_recend = m;
mbuf_setnextpkt(m, NULL);
slp->ns_reccnt++;
}
} while (mp);
}
dorecs:
if (ns_flag) {
slp->ns_flag |= ns_flag;
}
if (waitflag == MBUF_DONTWAIT) {
int wake = (slp->ns_flag & SLP_WORKTODO);
lck_rw_done(&slp->ns_rwlock);
if (wake && nfsd_thread_count) {
lck_mtx_lock(nfsd_mutex);
nfsrv_wakenfsd(slp);
lck_mtx_unlock(nfsd_mutex);
}
}
}
int
nfsrv_getstream(struct nfsrv_sock *slp, int waitflag)
{
mbuf_t m;
char *cp1, *cp2, *mdata;
int len, mlen, error;
mbuf_t om, m2, recm;
u_int32_t recmark;
if (slp->ns_flag & SLP_GETSTREAM) {
panic("nfs getstream");
}
slp->ns_flag |= SLP_GETSTREAM;
for (;;) {
if (slp->ns_reclen == 0) {
if (slp->ns_cc < NFSX_UNSIGNED) {
slp->ns_flag &= ~SLP_GETSTREAM;
return 0;
}
m = slp->ns_raw;
mdata = mbuf_data(m);
mlen = mbuf_len(m);
if (mlen >= NFSX_UNSIGNED) {
bcopy(mdata, (caddr_t)&recmark, NFSX_UNSIGNED);
mdata += NFSX_UNSIGNED;
mlen -= NFSX_UNSIGNED;
mbuf_setdata(m, mdata, mlen);
} else {
cp1 = (caddr_t)&recmark;
cp2 = mdata;
while (cp1 < ((caddr_t)&recmark) + NFSX_UNSIGNED) {
while (mlen == 0) {
m = mbuf_next(m);
cp2 = mbuf_data(m);
mlen = mbuf_len(m);
}
*cp1++ = *cp2++;
mlen--;
mbuf_setdata(m, cp2, mlen);
}
}
slp->ns_cc -= NFSX_UNSIGNED;
recmark = ntohl(recmark);
slp->ns_reclen = recmark & ~0x80000000;
if (recmark & 0x80000000) {
slp->ns_flag |= SLP_LASTFRAG;
} else {
slp->ns_flag &= ~SLP_LASTFRAG;
}
if (slp->ns_reclen <= 0 || slp->ns_reclen > NFS_MAXPACKET) {
slp->ns_flag &= ~SLP_GETSTREAM;
return EPERM;
}
}
recm = NULL;
if (slp->ns_cc == slp->ns_reclen) {
recm = slp->ns_raw;
slp->ns_raw = slp->ns_rawend = NULL;
slp->ns_cc = slp->ns_reclen = 0;
} else if (slp->ns_cc > slp->ns_reclen) {
len = 0;
m = slp->ns_raw;
mlen = mbuf_len(m);
mdata = mbuf_data(m);
om = NULL;
while (len < slp->ns_reclen) {
if ((len + mlen) > slp->ns_reclen) {
if (mbuf_copym(m, 0, slp->ns_reclen - len, waitflag, &m2)) {
slp->ns_flag &= ~SLP_GETSTREAM;
return EWOULDBLOCK;
}
if (om) {
if (mbuf_setnext(om, m2)) {
printf("nfsrv_getstream: mbuf_setnext failed\n");
mbuf_freem(m2);
slp->ns_flag &= ~SLP_GETSTREAM;
return EWOULDBLOCK;
}
recm = slp->ns_raw;
} else {
recm = m2;
}
mdata += slp->ns_reclen - len;
mlen -= slp->ns_reclen - len;
mbuf_setdata(m, mdata, mlen);
len = slp->ns_reclen;
} else if ((len + mlen) == slp->ns_reclen) {
om = m;
len += mlen;
m = mbuf_next(m);
recm = slp->ns_raw;
if (mbuf_setnext(om, NULL)) {
printf("nfsrv_getstream: mbuf_setnext failed 2\n");
slp->ns_flag &= ~SLP_GETSTREAM;
return EWOULDBLOCK;
}
mlen = mbuf_len(m);
mdata = mbuf_data(m);
} else {
om = m;
len += mlen;
m = mbuf_next(m);
mlen = mbuf_len(m);
mdata = mbuf_data(m);
}
}
slp->ns_raw = m;
slp->ns_cc -= len;
slp->ns_reclen = 0;
} else {
slp->ns_flag &= ~SLP_GETSTREAM;
return 0;
}
if (slp->ns_frag == NULL) {
slp->ns_frag = recm;
} else {
m = slp->ns_frag;
while ((m2 = mbuf_next(m))) {
m = m2;
}
if ((error = mbuf_setnext(m, recm))) {
panic("nfsrv_getstream: mbuf_setnext failed 3, %d\n", error);
}
}
if (slp->ns_flag & SLP_LASTFRAG) {
if (slp->ns_recend) {
mbuf_setnextpkt(slp->ns_recend, slp->ns_frag);
} else {
slp->ns_rec = slp->ns_frag;
slp->ns_flag |= SLP_DOREC;
}
slp->ns_recend = slp->ns_frag;
slp->ns_frag = NULL;
}
}
}
int
nfsrv_dorec(
struct nfsrv_sock *slp,
struct nfsd *nfsd,
struct nfsrv_descript **ndp)
{
mbuf_t m;
mbuf_t nam;
struct nfsrv_descript *nd;
int error = 0;
*ndp = NULL;
if (!(slp->ns_flag & (SLP_VALID | SLP_DOREC)) || (slp->ns_rec == NULL)) {
return ENOBUFS;
}
MALLOC_ZONE(nd, struct nfsrv_descript *,
sizeof(struct nfsrv_descript), M_NFSRVDESC, M_WAITOK);
if (!nd) {
return ENOMEM;
}
m = slp->ns_rec;
slp->ns_rec = mbuf_nextpkt(m);
if (slp->ns_rec) {
mbuf_setnextpkt(m, NULL);
} else {
slp->ns_flag &= ~SLP_DOREC;
slp->ns_recend = NULL;
}
slp->ns_reccnt--;
if (mbuf_type(m) == MBUF_TYPE_SONAME) {
nam = m;
m = mbuf_next(m);
if ((error = mbuf_setnext(nam, NULL))) {
panic("nfsrv_dorec: mbuf_setnext failed %d\n", error);
}
} else {
nam = NULL;
}
nd->nd_nam2 = nam;
nfsm_chain_dissect_init(error, &nd->nd_nmreq, m);
if (!error) {
error = nfsrv_getreq(nd);
}
if (error) {
if (nam) {
mbuf_freem(nam);
}
if (nd->nd_gss_context) {
nfs_gss_svc_ctx_deref(nd->nd_gss_context);
}
FREE_ZONE(nd, sizeof(*nd), M_NFSRVDESC);
return error;
}
nd->nd_mrep = NULL;
*ndp = nd;
nfsd->nfsd_nd = nd;
return 0;
}
int
nfsrv_getreq(struct nfsrv_descript *nd)
{
struct nfsm_chain *nmreq;
int len, i;
u_int32_t nfsvers, auth_type;
int error = 0;
uid_t user_id;
gid_t group_id;
int ngroups;
uint32_t val;
nd->nd_cr = NULL;
nd->nd_gss_context = NULL;
nd->nd_gss_seqnum = 0;
nd->nd_gss_mb = NULL;
user_id = group_id = -2;
val = auth_type = len = 0;
nmreq = &nd->nd_nmreq;
nfsm_chain_get_32(error, nmreq, nd->nd_retxid); nfsm_chain_get_32(error, nmreq, val); if (!error && (val != RPC_CALL)) {
error = EBADRPC;
}
nfsmout_if(error);
nd->nd_repstat = 0;
nfsm_chain_get_32(error, nmreq, val); nfsmout_if(error);
if (val != RPC_VER2) {
nd->nd_repstat = ERPCMISMATCH;
nd->nd_procnum = NFSPROC_NOOP;
return 0;
}
nfsm_chain_get_32(error, nmreq, val); nfsmout_if(error);
if (val != NFS_PROG) {
nd->nd_repstat = EPROGUNAVAIL;
nd->nd_procnum = NFSPROC_NOOP;
return 0;
}
nfsm_chain_get_32(error, nmreq, nfsvers); nfsmout_if(error);
if ((nfsvers < NFS_VER2) || (nfsvers > NFS_VER3)) {
nd->nd_repstat = EPROGMISMATCH;
nd->nd_procnum = NFSPROC_NOOP;
return 0;
}
nd->nd_vers = nfsvers;
nfsm_chain_get_32(error, nmreq, nd->nd_procnum); nfsmout_if(error);
if ((nd->nd_procnum >= NFS_NPROCS) ||
((nd->nd_vers == NFS_VER2) && (nd->nd_procnum > NFSV2PROC_STATFS))) {
nd->nd_repstat = EPROCUNAVAIL;
nd->nd_procnum = NFSPROC_NOOP;
return 0;
}
if (nfsvers != NFS_VER3) {
nd->nd_procnum = nfsv3_procid[nd->nd_procnum];
}
nfsm_chain_get_32(error, nmreq, auth_type); nfsm_chain_get_32(error, nmreq, len); if (!error && (len < 0 || len > RPCAUTH_MAXSIZ)) {
error = EBADRPC;
}
nfsmout_if(error);
if (auth_type == RPCAUTH_SYS) {
struct posix_cred temp_pcred;
if (nd->nd_procnum == NFSPROC_NULL) {
return 0;
}
nd->nd_sec = RPCAUTH_SYS;
nfsm_chain_adv(error, nmreq, NFSX_UNSIGNED); nfsm_chain_get_32(error, nmreq, len); if (len < 0 || len > NFS_MAXNAMLEN) {
error = EBADRPC;
}
nfsm_chain_adv(error, nmreq, nfsm_rndup(len)); nfsmout_if(error);
bzero(&temp_pcred, sizeof(temp_pcred));
nfsm_chain_get_32(error, nmreq, user_id);
nfsm_chain_get_32(error, nmreq, group_id);
temp_pcred.cr_groups[0] = group_id;
nfsm_chain_get_32(error, nmreq, len); if ((len < 0) || (len > RPCAUTH_UNIXGIDS)) {
error = EBADRPC;
}
nfsmout_if(error);
for (i = 1; i <= len; i++) {
if (i < NGROUPS) {
nfsm_chain_get_32(error, nmreq, temp_pcred.cr_groups[i]);
} else {
nfsm_chain_adv(error, nmreq, NFSX_UNSIGNED);
}
}
nfsmout_if(error);
ngroups = (len >= NGROUPS) ? NGROUPS : (len + 1);
if (ngroups > 1) {
nfsrv_group_sort(&temp_pcred.cr_groups[0], ngroups);
}
nfsm_chain_adv(error, nmreq, NFSX_UNSIGNED); nfsm_chain_get_32(error, nmreq, len); if (len < 0 || len > RPCAUTH_MAXSIZ) {
error = EBADRPC;
}
if (len > 0) {
nfsm_chain_adv(error, nmreq, nfsm_rndup(len));
}
temp_pcred.cr_uid = user_id;
temp_pcred.cr_ngroups = ngroups;
nd->nd_cr = posix_cred_create(&temp_pcred);
if (nd->nd_cr == NULL) {
nd->nd_repstat = ENOMEM;
nd->nd_procnum = NFSPROC_NOOP;
return 0;
}
} else if (auth_type == RPCSEC_GSS) {
error = nfs_gss_svc_cred_get(nd, nmreq);
if (error) {
if (error == EINVAL) {
goto nfsmout; }
nd->nd_repstat = error;
nd->nd_procnum = NFSPROC_NOOP;
return 0;
}
} else {
if (nd->nd_procnum == NFSPROC_NULL) { return 0;
}
nd->nd_repstat = (NFSERR_AUTHERR | AUTH_REJECTCRED);
nd->nd_procnum = NFSPROC_NOOP;
return 0;
}
return 0;
nfsmout:
if (IS_VALID_CRED(nd->nd_cr)) {
kauth_cred_unref(&nd->nd_cr);
}
nfsm_chain_cleanup(nmreq);
return error;
}
void
nfsrv_wakenfsd(struct nfsrv_sock *slp)
{
struct nfsd *nd;
if ((slp->ns_flag & SLP_VALID) == 0) {
return;
}
lck_rw_lock_exclusive(&slp->ns_rwlock);
if ((slp->ns_flag & SLP_WORKTODO) && !(slp->ns_flag & SLP_QUEUED)) {
TAILQ_INSERT_TAIL(&nfsrv_sockwait, slp, ns_svcq);
slp->ns_flag |= SLP_WAITQ;
}
lck_rw_done(&slp->ns_rwlock);
nd = TAILQ_FIRST(&nfsd_queue);
if (!nd) {
return;
}
TAILQ_REMOVE(&nfsd_queue, nd, nfsd_queue);
nd->nfsd_flag &= ~NFSD_WAITING;
wakeup(nd);
}
#endif