0c86e62082
for the Getattr and Recall callbacks. This patch fixes it. Since the NFSv4.1 specific error codes would only happen for abnormal circumstances, this patch has little effect, in practice. MFC after: 1 week
5222 lines
140 KiB
C
5222 lines
140 KiB
C
/*-
|
|
* Copyright (c) 2009 Rick Macklem, University of Guelph
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
/*
|
|
* These functions implement the client side state handling for NFSv4.
|
|
* NFSv4 state handling:
|
|
* - A lockowner is used to determine lock contention, so it
|
|
* corresponds directly to a Posix pid. (1 to 1 mapping)
|
|
* - The correct granularity of an OpenOwner is not nearly so
|
|
* obvious. An OpenOwner does the following:
|
|
* - provides a serial sequencing of Open/Close/Lock-with-new-lockowner
|
|
* - is used to check for Open/Share contention (not applicable to
|
|
* this client, since all Opens are Deny_None)
|
|
* As such, I considered both extreme.
|
|
* 1 OpenOwner per ClientID - Simple to manage, but fully serializes
|
|
* all Open, Close and Lock (with a new lockowner) Ops.
|
|
* 1 OpenOwner for each Open - This one results in an OpenConfirm for
|
|
* every Open, for most servers.
|
|
* So, I chose to use the same mapping as I did for LockOwnwers.
|
|
* The main concern here is that you can end up with multiple Opens
|
|
* for the same File Handle, but on different OpenOwners (opens
|
|
* inherited from parents, grandparents...) and you do not know
|
|
* which of these the vnodeop close applies to. This is handled by
|
|
* delaying the Close Op(s) until all of the Opens have been closed.
|
|
* (It is not yet obvious if this is the correct granularity.)
|
|
* - How the code handles serialization:
|
|
* - For the ClientId, it uses an exclusive lock while getting its
|
|
* SetClientId and during recovery. Otherwise, it uses a shared
|
|
* lock via a reference count.
|
|
* - For the rest of the data structures, it uses an SMP mutex
|
|
* (once the nfs client is SMP safe) and doesn't sleep while
|
|
* manipulating the linked lists.
|
|
* - The serialization of Open/Close/Lock/LockU falls out in the
|
|
* "wash", since OpenOwners and LockOwners are both mapped from
|
|
* Posix pid. In other words, there is only one Posix pid using
|
|
* any given owner, so that owner is serialized. (If you change
|
|
* the granularity of the OpenOwner, then code must be added to
|
|
* serialize Ops on the OpenOwner.)
|
|
* - When to get rid of OpenOwners and LockOwners.
|
|
* - The function nfscl_cleanup_common() is executed after a process exits.
|
|
* It goes through the client list looking for all Open and Lock Owners.
|
|
* When one is found, it is marked "defunct" or in the case of
|
|
* an OpenOwner without any Opens, freed.
|
|
* The renew thread scans for defunct Owners and gets rid of them,
|
|
* if it can. The LockOwners will also be deleted when the
|
|
* associated Open is closed.
|
|
* - If the LockU or Close Op(s) fail during close in a way
|
|
* that could be recovered upon retry, they are relinked to the
|
|
* ClientId's defunct open list and retried by the renew thread
|
|
* until they succeed or an unmount/recovery occurs.
|
|
* (Since we are done with them, they do not need to be recovered.)
|
|
*/
|
|
|
|
#ifndef APPLEKEXT
|
|
#include <fs/nfs/nfsport.h>
|
|
|
|
/*
|
|
* Global variables
|
|
*/
|
|
extern struct nfsstats newnfsstats;
|
|
extern struct nfsreqhead nfsd_reqq;
|
|
extern u_int32_t newnfs_false, newnfs_true;
|
|
extern int nfscl_debuglevel;
|
|
NFSREQSPINLOCK;
|
|
NFSCLSTATEMUTEX;
|
|
int nfscl_inited = 0;
|
|
struct nfsclhead nfsclhead; /* Head of clientid list */
|
|
int nfscl_deleghighwater = NFSCLDELEGHIGHWATER;
|
|
int nfscl_layouthighwater = NFSCLLAYOUTHIGHWATER;
|
|
#endif /* !APPLEKEXT */
|
|
|
|
static int nfscl_delegcnt = 0;
|
|
static int nfscl_layoutcnt = 0;
|
|
static int nfscl_getopen(struct nfsclownerhead *, u_int8_t *, int, u_int8_t *,
|
|
u_int8_t *, u_int32_t, struct nfscllockowner **, struct nfsclopen **);
|
|
static void nfscl_clrelease(struct nfsclclient *);
|
|
static void nfscl_cleanclient(struct nfsclclient *);
|
|
static void nfscl_expireclient(struct nfsclclient *, struct nfsmount *,
|
|
struct ucred *, NFSPROC_T *);
|
|
static int nfscl_expireopen(struct nfsclclient *, struct nfsclopen *,
|
|
struct nfsmount *, struct ucred *, NFSPROC_T *);
|
|
static void nfscl_recover(struct nfsclclient *, struct ucred *, NFSPROC_T *);
|
|
static void nfscl_insertlock(struct nfscllockowner *, struct nfscllock *,
|
|
struct nfscllock *, int);
|
|
static int nfscl_updatelock(struct nfscllockowner *, struct nfscllock **,
|
|
struct nfscllock **, int);
|
|
static void nfscl_delegreturnall(struct nfsclclient *, NFSPROC_T *);
|
|
static u_int32_t nfscl_nextcbident(void);
|
|
static mount_t nfscl_getmnt(int, uint8_t *, u_int32_t, struct nfsclclient **);
|
|
static struct nfsclclient *nfscl_getclnt(u_int32_t);
|
|
static struct nfsclclient *nfscl_getclntsess(uint8_t *);
|
|
static struct nfscldeleg *nfscl_finddeleg(struct nfsclclient *, u_int8_t *,
|
|
int);
|
|
static void nfscl_retoncloselayout(struct nfsclclient *, uint8_t *, int);
|
|
static void nfscl_reldevinfo_locked(struct nfscldevinfo *);
|
|
static struct nfscllayout *nfscl_findlayout(struct nfsclclient *, u_int8_t *,
|
|
int);
|
|
static struct nfscldevinfo *nfscl_finddevinfo(struct nfsclclient *, uint8_t *);
|
|
static int nfscl_checkconflict(struct nfscllockownerhead *, struct nfscllock *,
|
|
u_int8_t *, struct nfscllock **);
|
|
static void nfscl_freealllocks(struct nfscllockownerhead *, int);
|
|
static int nfscl_localconflict(struct nfsclclient *, u_int8_t *, int,
|
|
struct nfscllock *, u_int8_t *, struct nfscldeleg *, struct nfscllock **);
|
|
static void nfscl_newopen(struct nfsclclient *, struct nfscldeleg *,
|
|
struct nfsclowner **, struct nfsclowner **, struct nfsclopen **,
|
|
struct nfsclopen **, u_int8_t *, u_int8_t *, int, int *);
|
|
static int nfscl_moveopen(vnode_t , struct nfsclclient *,
|
|
struct nfsmount *, struct nfsclopen *, struct nfsclowner *,
|
|
struct nfscldeleg *, struct ucred *, NFSPROC_T *);
|
|
static void nfscl_totalrecall(struct nfsclclient *);
|
|
static int nfscl_relock(vnode_t , struct nfsclclient *, struct nfsmount *,
|
|
struct nfscllockowner *, struct nfscllock *, struct ucred *, NFSPROC_T *);
|
|
static int nfscl_tryopen(struct nfsmount *, vnode_t , u_int8_t *, int,
|
|
u_int8_t *, int, u_int32_t, struct nfsclopen *, u_int8_t *, int,
|
|
struct nfscldeleg **, int, u_int32_t, struct ucred *, NFSPROC_T *);
|
|
static int nfscl_trylock(struct nfsmount *, vnode_t , u_int8_t *,
|
|
int, struct nfscllockowner *, int, int, u_int64_t, u_int64_t, short,
|
|
struct ucred *, NFSPROC_T *);
|
|
static int nfsrpc_reopen(struct nfsmount *, u_int8_t *, int, u_int32_t,
|
|
struct nfsclopen *, struct nfscldeleg **, struct ucred *, NFSPROC_T *);
|
|
static void nfscl_freedeleg(struct nfscldeleghead *, struct nfscldeleg *);
|
|
static int nfscl_errmap(struct nfsrv_descript *, u_int32_t);
|
|
static void nfscl_cleanup_common(struct nfsclclient *, u_int8_t *);
|
|
static int nfscl_recalldeleg(struct nfsclclient *, struct nfsmount *,
|
|
struct nfscldeleg *, vnode_t, struct ucred *, NFSPROC_T *, int);
|
|
static void nfscl_freeopenowner(struct nfsclowner *, int);
|
|
static void nfscl_cleandeleg(struct nfscldeleg *);
|
|
static int nfscl_trydelegreturn(struct nfscldeleg *, struct ucred *,
|
|
struct nfsmount *, NFSPROC_T *);
|
|
static void nfscl_emptylockowner(struct nfscllockowner *,
|
|
struct nfscllockownerfhhead *);
|
|
static void nfscl_mergeflayouts(struct nfsclflayouthead *,
|
|
struct nfsclflayouthead *);
|
|
static int nfscl_layoutrecall(int, struct nfscllayout *, uint32_t, uint64_t,
|
|
uint64_t, uint32_t, struct nfsclrecalllayout *);
|
|
static int nfscl_seq(uint32_t, uint32_t);
|
|
static void nfscl_layoutreturn(struct nfsmount *, struct nfscllayout *,
|
|
struct ucred *, NFSPROC_T *);
|
|
static void nfscl_dolayoutcommit(struct nfsmount *, struct nfscllayout *,
|
|
struct ucred *, NFSPROC_T *);
|
|
|
|
static short nfscberr_null[] = {
|
|
0,
|
|
0,
|
|
};
|
|
|
|
static short nfscberr_getattr[] = {
|
|
NFSERR_RESOURCE,
|
|
NFSERR_BADHANDLE,
|
|
NFSERR_BADXDR,
|
|
NFSERR_RESOURCE,
|
|
NFSERR_SERVERFAULT,
|
|
0,
|
|
};
|
|
|
|
static short nfscberr_recall[] = {
|
|
NFSERR_RESOURCE,
|
|
NFSERR_BADHANDLE,
|
|
NFSERR_BADSTATEID,
|
|
NFSERR_BADXDR,
|
|
NFSERR_RESOURCE,
|
|
NFSERR_SERVERFAULT,
|
|
0,
|
|
};
|
|
|
|
static short *nfscl_cberrmap[] = {
|
|
nfscberr_null,
|
|
nfscberr_null,
|
|
nfscberr_null,
|
|
nfscberr_getattr,
|
|
nfscberr_recall
|
|
};
|
|
|
|
#define NETFAMILY(clp) \
|
|
(((clp)->nfsc_flags & NFSCLFLAGS_AFINET6) ? AF_INET6 : AF_INET)
|
|
|
|
/*
|
|
* Called for an open operation.
|
|
* If the nfhp argument is NULL, just get an openowner.
|
|
*/
|
|
APPLESTATIC int
|
|
nfscl_open(vnode_t vp, u_int8_t *nfhp, int fhlen, u_int32_t amode, int usedeleg,
|
|
struct ucred *cred, NFSPROC_T *p, struct nfsclowner **owpp,
|
|
struct nfsclopen **opp, int *newonep, int *retp, int lockit)
|
|
{
|
|
struct nfsclclient *clp;
|
|
struct nfsclowner *owp, *nowp;
|
|
struct nfsclopen *op = NULL, *nop = NULL;
|
|
struct nfscldeleg *dp;
|
|
struct nfsclownerhead *ohp;
|
|
u_int8_t own[NFSV4CL_LOCKNAMELEN];
|
|
int ret;
|
|
|
|
if (newonep != NULL)
|
|
*newonep = 0;
|
|
if (opp != NULL)
|
|
*opp = NULL;
|
|
if (owpp != NULL)
|
|
*owpp = NULL;
|
|
|
|
/*
|
|
* Might need one or both of these, so MALLOC them now, to
|
|
* avoid a tsleep() in MALLOC later.
|
|
*/
|
|
MALLOC(nowp, struct nfsclowner *, sizeof (struct nfsclowner),
|
|
M_NFSCLOWNER, M_WAITOK);
|
|
if (nfhp != NULL)
|
|
MALLOC(nop, struct nfsclopen *, sizeof (struct nfsclopen) +
|
|
fhlen - 1, M_NFSCLOPEN, M_WAITOK);
|
|
ret = nfscl_getcl(vnode_mount(vp), cred, p, 1, &clp);
|
|
if (ret != 0) {
|
|
FREE((caddr_t)nowp, M_NFSCLOWNER);
|
|
if (nop != NULL)
|
|
FREE((caddr_t)nop, M_NFSCLOPEN);
|
|
return (ret);
|
|
}
|
|
|
|
/*
|
|
* Get the Open iff it already exists.
|
|
* If none found, add the new one or return error, depending upon
|
|
* "create".
|
|
*/
|
|
nfscl_filllockowner(p->td_proc, own, F_POSIX);
|
|
NFSLOCKCLSTATE();
|
|
dp = NULL;
|
|
/* First check the delegation list */
|
|
if (nfhp != NULL && usedeleg) {
|
|
LIST_FOREACH(dp, NFSCLDELEGHASH(clp, nfhp, fhlen), nfsdl_hash) {
|
|
if (dp->nfsdl_fhlen == fhlen &&
|
|
!NFSBCMP(nfhp, dp->nfsdl_fh, fhlen)) {
|
|
if (!(amode & NFSV4OPEN_ACCESSWRITE) ||
|
|
(dp->nfsdl_flags & NFSCLDL_WRITE))
|
|
break;
|
|
dp = NULL;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dp != NULL)
|
|
ohp = &dp->nfsdl_owner;
|
|
else
|
|
ohp = &clp->nfsc_owner;
|
|
/* Now, search for an openowner */
|
|
LIST_FOREACH(owp, ohp, nfsow_list) {
|
|
if (!NFSBCMP(owp->nfsow_owner, own, NFSV4CL_LOCKNAMELEN))
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Create a new open, as required.
|
|
*/
|
|
nfscl_newopen(clp, dp, &owp, &nowp, &op, &nop, own, nfhp, fhlen,
|
|
newonep);
|
|
|
|
/*
|
|
* Serialize modifications to the open owner for multiple threads
|
|
* within the same process using a read/write sleep lock.
|
|
*/
|
|
if (lockit)
|
|
nfscl_lockexcl(&owp->nfsow_rwlock, NFSCLSTATEMUTEXPTR);
|
|
NFSUNLOCKCLSTATE();
|
|
if (nowp != NULL)
|
|
FREE((caddr_t)nowp, M_NFSCLOWNER);
|
|
if (nop != NULL)
|
|
FREE((caddr_t)nop, M_NFSCLOPEN);
|
|
if (owpp != NULL)
|
|
*owpp = owp;
|
|
if (opp != NULL)
|
|
*opp = op;
|
|
if (retp != NULL) {
|
|
if (nfhp != NULL && dp != NULL && nop == NULL)
|
|
/* new local open on delegation */
|
|
*retp = NFSCLOPEN_SETCRED;
|
|
else
|
|
*retp = NFSCLOPEN_OK;
|
|
}
|
|
|
|
/*
|
|
* Now, check the mode on the open and return the appropriate
|
|
* value.
|
|
*/
|
|
if (op != NULL && (amode & ~(op->nfso_mode))) {
|
|
op->nfso_mode |= amode;
|
|
if (retp != NULL && dp == NULL)
|
|
*retp = NFSCLOPEN_DOOPEN;
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Create a new open, as required.
|
|
*/
|
|
static void
|
|
nfscl_newopen(struct nfsclclient *clp, struct nfscldeleg *dp,
|
|
struct nfsclowner **owpp, struct nfsclowner **nowpp, struct nfsclopen **opp,
|
|
struct nfsclopen **nopp, u_int8_t *own, u_int8_t *fhp, int fhlen,
|
|
int *newonep)
|
|
{
|
|
struct nfsclowner *owp = *owpp, *nowp;
|
|
struct nfsclopen *op, *nop;
|
|
|
|
if (nowpp != NULL)
|
|
nowp = *nowpp;
|
|
else
|
|
nowp = NULL;
|
|
if (nopp != NULL)
|
|
nop = *nopp;
|
|
else
|
|
nop = NULL;
|
|
if (owp == NULL && nowp != NULL) {
|
|
NFSBCOPY(own, nowp->nfsow_owner, NFSV4CL_LOCKNAMELEN);
|
|
LIST_INIT(&nowp->nfsow_open);
|
|
nowp->nfsow_clp = clp;
|
|
nowp->nfsow_seqid = 0;
|
|
nowp->nfsow_defunct = 0;
|
|
nfscl_lockinit(&nowp->nfsow_rwlock);
|
|
if (dp != NULL) {
|
|
newnfsstats.cllocalopenowners++;
|
|
LIST_INSERT_HEAD(&dp->nfsdl_owner, nowp, nfsow_list);
|
|
} else {
|
|
newnfsstats.clopenowners++;
|
|
LIST_INSERT_HEAD(&clp->nfsc_owner, nowp, nfsow_list);
|
|
}
|
|
owp = *owpp = nowp;
|
|
*nowpp = NULL;
|
|
if (newonep != NULL)
|
|
*newonep = 1;
|
|
}
|
|
|
|
/* If an fhp has been specified, create an Open as well. */
|
|
if (fhp != NULL) {
|
|
/* and look for the correct open, based upon FH */
|
|
LIST_FOREACH(op, &owp->nfsow_open, nfso_list) {
|
|
if (op->nfso_fhlen == fhlen &&
|
|
!NFSBCMP(op->nfso_fh, fhp, fhlen))
|
|
break;
|
|
}
|
|
if (op == NULL && nop != NULL) {
|
|
nop->nfso_own = owp;
|
|
nop->nfso_mode = 0;
|
|
nop->nfso_opencnt = 0;
|
|
nop->nfso_posixlock = 1;
|
|
nop->nfso_fhlen = fhlen;
|
|
NFSBCOPY(fhp, nop->nfso_fh, fhlen);
|
|
LIST_INIT(&nop->nfso_lock);
|
|
nop->nfso_stateid.seqid = 0;
|
|
nop->nfso_stateid.other[0] = 0;
|
|
nop->nfso_stateid.other[1] = 0;
|
|
nop->nfso_stateid.other[2] = 0;
|
|
if (dp != NULL) {
|
|
TAILQ_REMOVE(&clp->nfsc_deleg, dp, nfsdl_list);
|
|
TAILQ_INSERT_HEAD(&clp->nfsc_deleg, dp,
|
|
nfsdl_list);
|
|
dp->nfsdl_timestamp = NFSD_MONOSEC + 120;
|
|
newnfsstats.cllocalopens++;
|
|
} else {
|
|
newnfsstats.clopens++;
|
|
}
|
|
LIST_INSERT_HEAD(&owp->nfsow_open, nop, nfso_list);
|
|
*opp = nop;
|
|
*nopp = NULL;
|
|
if (newonep != NULL)
|
|
*newonep = 1;
|
|
} else {
|
|
*opp = op;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Called to find/add a delegation to a client.
|
|
*/
|
|
APPLESTATIC int
|
|
nfscl_deleg(mount_t mp, struct nfsclclient *clp, u_int8_t *nfhp,
|
|
int fhlen, struct ucred *cred, NFSPROC_T *p, struct nfscldeleg **dpp)
|
|
{
|
|
struct nfscldeleg *dp = *dpp, *tdp;
|
|
|
|
/*
|
|
* First, if we have received a Read delegation for a file on a
|
|
* read/write file system, just return it, because they aren't
|
|
* useful, imho.
|
|
*/
|
|
if (mp != NULL && dp != NULL && !NFSMNT_RDONLY(mp) &&
|
|
(dp->nfsdl_flags & NFSCLDL_READ)) {
|
|
(void) nfscl_trydelegreturn(dp, cred, VFSTONFS(mp), p);
|
|
FREE((caddr_t)dp, M_NFSCLDELEG);
|
|
*dpp = NULL;
|
|
return (0);
|
|
}
|
|
|
|
/* Look for the correct deleg, based upon FH */
|
|
NFSLOCKCLSTATE();
|
|
tdp = nfscl_finddeleg(clp, nfhp, fhlen);
|
|
if (tdp == NULL) {
|
|
if (dp == NULL) {
|
|
NFSUNLOCKCLSTATE();
|
|
return (NFSERR_BADSTATEID);
|
|
}
|
|
*dpp = NULL;
|
|
TAILQ_INSERT_HEAD(&clp->nfsc_deleg, dp, nfsdl_list);
|
|
LIST_INSERT_HEAD(NFSCLDELEGHASH(clp, nfhp, fhlen), dp,
|
|
nfsdl_hash);
|
|
dp->nfsdl_timestamp = NFSD_MONOSEC + 120;
|
|
newnfsstats.cldelegates++;
|
|
nfscl_delegcnt++;
|
|
} else {
|
|
/*
|
|
* Delegation already exists, what do we do if a new one??
|
|
*/
|
|
if (dp != NULL) {
|
|
printf("Deleg already exists!\n");
|
|
FREE((caddr_t)dp, M_NFSCLDELEG);
|
|
*dpp = NULL;
|
|
} else {
|
|
*dpp = tdp;
|
|
}
|
|
}
|
|
NFSUNLOCKCLSTATE();
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Find a delegation for this file handle. Return NULL upon failure.
|
|
*/
|
|
static struct nfscldeleg *
|
|
nfscl_finddeleg(struct nfsclclient *clp, u_int8_t *fhp, int fhlen)
|
|
{
|
|
struct nfscldeleg *dp;
|
|
|
|
LIST_FOREACH(dp, NFSCLDELEGHASH(clp, fhp, fhlen), nfsdl_hash) {
|
|
if (dp->nfsdl_fhlen == fhlen &&
|
|
!NFSBCMP(dp->nfsdl_fh, fhp, fhlen))
|
|
break;
|
|
}
|
|
return (dp);
|
|
}
|
|
|
|
/*
|
|
* Get a stateid for an I/O operation. First, look for an open and iff
|
|
* found, return either a lockowner stateid or the open stateid.
|
|
* If no Open is found, just return error and the special stateid of all zeros.
|
|
*/
|
|
APPLESTATIC int
|
|
nfscl_getstateid(vnode_t vp, u_int8_t *nfhp, int fhlen, u_int32_t mode,
|
|
int fords, struct ucred *cred, NFSPROC_T *p, nfsv4stateid_t *stateidp,
|
|
void **lckpp)
|
|
{
|
|
struct nfsclclient *clp;
|
|
struct nfsclowner *owp;
|
|
struct nfsclopen *op = NULL;
|
|
struct nfscllockowner *lp;
|
|
struct nfscldeleg *dp;
|
|
struct nfsnode *np;
|
|
u_int8_t own[NFSV4CL_LOCKNAMELEN];
|
|
int error, done;
|
|
|
|
*lckpp = NULL;
|
|
/*
|
|
* Initially, just set the special stateid of all zeros.
|
|
* (Don't do this for a DS, since the special stateid can't be used.)
|
|
*/
|
|
if (fords == 0) {
|
|
stateidp->seqid = 0;
|
|
stateidp->other[0] = 0;
|
|
stateidp->other[1] = 0;
|
|
stateidp->other[2] = 0;
|
|
}
|
|
if (vnode_vtype(vp) != VREG)
|
|
return (EISDIR);
|
|
np = VTONFS(vp);
|
|
NFSLOCKCLSTATE();
|
|
clp = nfscl_findcl(VFSTONFS(vnode_mount(vp)));
|
|
if (clp == NULL) {
|
|
NFSUNLOCKCLSTATE();
|
|
return (EACCES);
|
|
}
|
|
|
|
/*
|
|
* Wait for recovery to complete.
|
|
*/
|
|
while ((clp->nfsc_flags & NFSCLFLAGS_RECVRINPROG))
|
|
(void) nfsmsleep(&clp->nfsc_flags, NFSCLSTATEMUTEXPTR,
|
|
PZERO, "nfsrecvr", NULL);
|
|
|
|
/*
|
|
* First, look for a delegation.
|
|
*/
|
|
LIST_FOREACH(dp, NFSCLDELEGHASH(clp, nfhp, fhlen), nfsdl_hash) {
|
|
if (dp->nfsdl_fhlen == fhlen &&
|
|
!NFSBCMP(nfhp, dp->nfsdl_fh, fhlen)) {
|
|
if (!(mode & NFSV4OPEN_ACCESSWRITE) ||
|
|
(dp->nfsdl_flags & NFSCLDL_WRITE)) {
|
|
stateidp->seqid = dp->nfsdl_stateid.seqid;
|
|
stateidp->other[0] = dp->nfsdl_stateid.other[0];
|
|
stateidp->other[1] = dp->nfsdl_stateid.other[1];
|
|
stateidp->other[2] = dp->nfsdl_stateid.other[2];
|
|
if (!(np->n_flag & NDELEGRECALL)) {
|
|
TAILQ_REMOVE(&clp->nfsc_deleg, dp,
|
|
nfsdl_list);
|
|
TAILQ_INSERT_HEAD(&clp->nfsc_deleg, dp,
|
|
nfsdl_list);
|
|
dp->nfsdl_timestamp = NFSD_MONOSEC +
|
|
120;
|
|
dp->nfsdl_rwlock.nfslock_usecnt++;
|
|
*lckpp = (void *)&dp->nfsdl_rwlock;
|
|
}
|
|
NFSUNLOCKCLSTATE();
|
|
return (0);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (p != NULL) {
|
|
/*
|
|
* If p != NULL, we want to search the parentage tree
|
|
* for a matching OpenOwner and use that.
|
|
*/
|
|
nfscl_filllockowner(p->td_proc, own, F_POSIX);
|
|
lp = NULL;
|
|
error = nfscl_getopen(&clp->nfsc_owner, nfhp, fhlen, own, own,
|
|
mode, &lp, &op);
|
|
if (error == 0 && lp != NULL && fords == 0) {
|
|
/* Don't return a lock stateid for a DS. */
|
|
stateidp->seqid =
|
|
lp->nfsl_stateid.seqid;
|
|
stateidp->other[0] =
|
|
lp->nfsl_stateid.other[0];
|
|
stateidp->other[1] =
|
|
lp->nfsl_stateid.other[1];
|
|
stateidp->other[2] =
|
|
lp->nfsl_stateid.other[2];
|
|
NFSUNLOCKCLSTATE();
|
|
return (0);
|
|
}
|
|
}
|
|
if (op == NULL) {
|
|
/* If not found, just look for any OpenOwner that will work. */
|
|
done = 0;
|
|
owp = LIST_FIRST(&clp->nfsc_owner);
|
|
while (!done && owp != NULL) {
|
|
LIST_FOREACH(op, &owp->nfsow_open, nfso_list) {
|
|
if (op->nfso_fhlen == fhlen &&
|
|
!NFSBCMP(op->nfso_fh, nfhp, fhlen) &&
|
|
(mode & op->nfso_mode) == mode) {
|
|
done = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (!done)
|
|
owp = LIST_NEXT(owp, nfsow_list);
|
|
}
|
|
if (!done) {
|
|
NFSUNLOCKCLSTATE();
|
|
return (ENOENT);
|
|
}
|
|
/*
|
|
* For read aheads or write behinds, use the open cred.
|
|
* A read ahead or write behind is indicated by p == NULL.
|
|
*/
|
|
if (p == NULL)
|
|
newnfs_copycred(&op->nfso_cred, cred);
|
|
}
|
|
|
|
/*
|
|
* No lock stateid, so return the open stateid.
|
|
*/
|
|
stateidp->seqid = op->nfso_stateid.seqid;
|
|
stateidp->other[0] = op->nfso_stateid.other[0];
|
|
stateidp->other[1] = op->nfso_stateid.other[1];
|
|
stateidp->other[2] = op->nfso_stateid.other[2];
|
|
NFSUNLOCKCLSTATE();
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Search for a matching file, mode and, optionally, lockowner.
|
|
*/
|
|
static int
|
|
nfscl_getopen(struct nfsclownerhead *ohp, u_int8_t *nfhp, int fhlen,
|
|
u_int8_t *openown, u_int8_t *lockown, u_int32_t mode,
|
|
struct nfscllockowner **lpp, struct nfsclopen **opp)
|
|
{
|
|
struct nfsclowner *owp;
|
|
struct nfsclopen *op, *rop, *rop2;
|
|
struct nfscllockowner *lp;
|
|
int keep_looping;
|
|
|
|
if (lpp != NULL)
|
|
*lpp = NULL;
|
|
/*
|
|
* rop will be set to the open to be returned. There are three
|
|
* variants of this, all for an open of the correct file:
|
|
* 1 - A match of lockown.
|
|
* 2 - A match of the openown, when no lockown match exists.
|
|
* 3 - A match for any open, if no openown or lockown match exists.
|
|
* Looking for #2 over #3 probably isn't necessary, but since
|
|
* RFC3530 is vague w.r.t. the relationship between openowners and
|
|
* lockowners, I think this is the safer way to go.
|
|
*/
|
|
rop = NULL;
|
|
rop2 = NULL;
|
|
keep_looping = 1;
|
|
/* Search the client list */
|
|
owp = LIST_FIRST(ohp);
|
|
while (owp != NULL && keep_looping != 0) {
|
|
/* and look for the correct open */
|
|
op = LIST_FIRST(&owp->nfsow_open);
|
|
while (op != NULL && keep_looping != 0) {
|
|
if (op->nfso_fhlen == fhlen &&
|
|
!NFSBCMP(op->nfso_fh, nfhp, fhlen)
|
|
&& (op->nfso_mode & mode) == mode) {
|
|
if (lpp != NULL) {
|
|
/* Now look for a matching lockowner. */
|
|
LIST_FOREACH(lp, &op->nfso_lock,
|
|
nfsl_list) {
|
|
if (!NFSBCMP(lp->nfsl_owner,
|
|
lockown,
|
|
NFSV4CL_LOCKNAMELEN)) {
|
|
*lpp = lp;
|
|
rop = op;
|
|
keep_looping = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (rop == NULL && !NFSBCMP(owp->nfsow_owner,
|
|
openown, NFSV4CL_LOCKNAMELEN)) {
|
|
rop = op;
|
|
if (lpp == NULL)
|
|
keep_looping = 0;
|
|
}
|
|
if (rop2 == NULL)
|
|
rop2 = op;
|
|
}
|
|
op = LIST_NEXT(op, nfso_list);
|
|
}
|
|
owp = LIST_NEXT(owp, nfsow_list);
|
|
}
|
|
if (rop == NULL)
|
|
rop = rop2;
|
|
if (rop == NULL)
|
|
return (EBADF);
|
|
*opp = rop;
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Release use of an open owner. Called when open operations are done
|
|
* with the open owner.
|
|
*/
|
|
APPLESTATIC void
|
|
nfscl_ownerrelease(struct nfsclowner *owp, __unused int error,
|
|
__unused int candelete, int unlocked)
|
|
{
|
|
|
|
if (owp == NULL)
|
|
return;
|
|
NFSLOCKCLSTATE();
|
|
if (!unlocked)
|
|
nfscl_lockunlock(&owp->nfsow_rwlock);
|
|
nfscl_clrelease(owp->nfsow_clp);
|
|
NFSUNLOCKCLSTATE();
|
|
}
|
|
|
|
/*
|
|
* Release use of an open structure under an open owner.
|
|
*/
|
|
APPLESTATIC void
|
|
nfscl_openrelease(struct nfsclopen *op, int error, int candelete)
|
|
{
|
|
struct nfsclclient *clp;
|
|
struct nfsclowner *owp;
|
|
|
|
if (op == NULL)
|
|
return;
|
|
NFSLOCKCLSTATE();
|
|
owp = op->nfso_own;
|
|
nfscl_lockunlock(&owp->nfsow_rwlock);
|
|
clp = owp->nfsow_clp;
|
|
if (error && candelete && op->nfso_opencnt == 0)
|
|
nfscl_freeopen(op, 0);
|
|
nfscl_clrelease(clp);
|
|
NFSUNLOCKCLSTATE();
|
|
}
|
|
|
|
/*
|
|
* Called to get a clientid structure. It will optionally lock the
|
|
* client data structures to do the SetClientId/SetClientId_confirm,
|
|
* but will release that lock and return the clientid with a refernce
|
|
* count on it.
|
|
* If the "cred" argument is NULL, a new clientid should not be created.
|
|
* If the "p" argument is NULL, a SetClientID/SetClientIDConfirm cannot
|
|
* be done.
|
|
* The start_renewthread argument tells nfscl_getcl() to start a renew
|
|
* thread if this creates a new clp.
|
|
* It always clpp with a reference count on it, unless returning an error.
|
|
*/
|
|
APPLESTATIC int
|
|
nfscl_getcl(struct mount *mp, struct ucred *cred, NFSPROC_T *p,
|
|
int start_renewthread, struct nfsclclient **clpp)
|
|
{
|
|
struct nfsclclient *clp;
|
|
struct nfsclclient *newclp = NULL;
|
|
struct nfsmount *nmp;
|
|
char uuid[HOSTUUIDLEN];
|
|
int igotlock = 0, error, trystalecnt, clidinusedelay, i;
|
|
u_int16_t idlen = 0;
|
|
|
|
nmp = VFSTONFS(mp);
|
|
if (cred != NULL) {
|
|
getcredhostuuid(cred, uuid, sizeof uuid);
|
|
idlen = strlen(uuid);
|
|
if (idlen > 0)
|
|
idlen += sizeof (u_int64_t);
|
|
else
|
|
idlen += sizeof (u_int64_t) + 16; /* 16 random bytes */
|
|
MALLOC(newclp, struct nfsclclient *,
|
|
sizeof (struct nfsclclient) + idlen - 1, M_NFSCLCLIENT,
|
|
M_WAITOK | M_ZERO);
|
|
}
|
|
NFSLOCKCLSTATE();
|
|
/*
|
|
* If a forced dismount is already in progress, don't
|
|
* allocate a new clientid and get out now. For the case where
|
|
* clp != NULL, this is a harmless optimization.
|
|
*/
|
|
if ((mp->mnt_kern_flag & MNTK_UNMOUNTF) != 0) {
|
|
NFSUNLOCKCLSTATE();
|
|
if (newclp != NULL)
|
|
free(newclp, M_NFSCLCLIENT);
|
|
return (EBADF);
|
|
}
|
|
clp = nmp->nm_clp;
|
|
if (clp == NULL) {
|
|
if (newclp == NULL) {
|
|
NFSUNLOCKCLSTATE();
|
|
return (EACCES);
|
|
}
|
|
clp = newclp;
|
|
clp->nfsc_idlen = idlen;
|
|
LIST_INIT(&clp->nfsc_owner);
|
|
TAILQ_INIT(&clp->nfsc_deleg);
|
|
TAILQ_INIT(&clp->nfsc_layout);
|
|
LIST_INIT(&clp->nfsc_devinfo);
|
|
for (i = 0; i < NFSCLDELEGHASHSIZE; i++)
|
|
LIST_INIT(&clp->nfsc_deleghash[i]);
|
|
for (i = 0; i < NFSCLLAYOUTHASHSIZE; i++)
|
|
LIST_INIT(&clp->nfsc_layouthash[i]);
|
|
clp->nfsc_flags = NFSCLFLAGS_INITED;
|
|
clp->nfsc_clientidrev = 1;
|
|
clp->nfsc_cbident = nfscl_nextcbident();
|
|
nfscl_fillclid(nmp->nm_clval, uuid, clp->nfsc_id,
|
|
clp->nfsc_idlen);
|
|
LIST_INSERT_HEAD(&nfsclhead, clp, nfsc_list);
|
|
nmp->nm_clp = clp;
|
|
clp->nfsc_nmp = nmp;
|
|
NFSUNLOCKCLSTATE();
|
|
if (start_renewthread != 0)
|
|
nfscl_start_renewthread(clp);
|
|
} else {
|
|
NFSUNLOCKCLSTATE();
|
|
if (newclp != NULL)
|
|
free(newclp, M_NFSCLCLIENT);
|
|
}
|
|
NFSLOCKCLSTATE();
|
|
while ((clp->nfsc_flags & NFSCLFLAGS_HASCLIENTID) == 0 && !igotlock &&
|
|
(mp->mnt_kern_flag & MNTK_UNMOUNTF) == 0)
|
|
igotlock = nfsv4_lock(&clp->nfsc_lock, 1, NULL,
|
|
NFSCLSTATEMUTEXPTR, mp);
|
|
if (!igotlock)
|
|
nfsv4_getref(&clp->nfsc_lock, NULL, NFSCLSTATEMUTEXPTR, mp);
|
|
if (igotlock == 0 && (mp->mnt_kern_flag & MNTK_UNMOUNTF) != 0) {
|
|
/*
|
|
* Both nfsv4_lock() and nfsv4_getref() know to check
|
|
* for MNTK_UNMOUNTF and return without sleeping to
|
|
* wait for the exclusive lock to be released, since it
|
|
* might be held by nfscl_umount() and we need to get out
|
|
* now for that case and not wait until nfscl_umount()
|
|
* releases it.
|
|
*/
|
|
NFSUNLOCKCLSTATE();
|
|
return (EBADF);
|
|
}
|
|
NFSUNLOCKCLSTATE();
|
|
|
|
/*
|
|
* If it needs a clientid, do the setclientid now.
|
|
*/
|
|
if ((clp->nfsc_flags & NFSCLFLAGS_HASCLIENTID) == 0) {
|
|
if (!igotlock)
|
|
panic("nfscl_clget");
|
|
if (p == NULL || cred == NULL) {
|
|
NFSLOCKCLSTATE();
|
|
nfsv4_unlock(&clp->nfsc_lock, 0);
|
|
NFSUNLOCKCLSTATE();
|
|
return (EACCES);
|
|
}
|
|
/*
|
|
* If RFC3530 Sec. 14.2.33 is taken literally,
|
|
* NFSERR_CLIDINUSE will be returned persistently for the
|
|
* case where a new mount of the same file system is using
|
|
* a different principal. In practice, NFSERR_CLIDINUSE is
|
|
* only returned when there is outstanding unexpired state
|
|
* on the clientid. As such, try for twice the lease
|
|
* interval, if we know what that is. Otherwise, make a
|
|
* wild ass guess.
|
|
* The case of returning NFSERR_STALECLIENTID is far less
|
|
* likely, but might occur if there is a significant delay
|
|
* between doing the SetClientID and SetClientIDConfirm Ops,
|
|
* such that the server throws away the clientid before
|
|
* receiving the SetClientIDConfirm.
|
|
*/
|
|
if (clp->nfsc_renew > 0)
|
|
clidinusedelay = NFSCL_LEASE(clp->nfsc_renew) * 2;
|
|
else
|
|
clidinusedelay = 120;
|
|
trystalecnt = 3;
|
|
do {
|
|
error = nfsrpc_setclient(nmp, clp, 0, cred, p);
|
|
if (error == NFSERR_STALECLIENTID ||
|
|
error == NFSERR_STALEDONTRECOVER ||
|
|
error == NFSERR_BADSESSION ||
|
|
error == NFSERR_CLIDINUSE) {
|
|
(void) nfs_catnap(PZERO, error, "nfs_setcl");
|
|
}
|
|
} while (((error == NFSERR_STALECLIENTID ||
|
|
error == NFSERR_BADSESSION ||
|
|
error == NFSERR_STALEDONTRECOVER) && --trystalecnt > 0) ||
|
|
(error == NFSERR_CLIDINUSE && --clidinusedelay > 0));
|
|
if (error) {
|
|
NFSLOCKCLSTATE();
|
|
nfsv4_unlock(&clp->nfsc_lock, 0);
|
|
NFSUNLOCKCLSTATE();
|
|
return (error);
|
|
}
|
|
clp->nfsc_flags |= NFSCLFLAGS_HASCLIENTID;
|
|
}
|
|
if (igotlock) {
|
|
NFSLOCKCLSTATE();
|
|
nfsv4_unlock(&clp->nfsc_lock, 1);
|
|
NFSUNLOCKCLSTATE();
|
|
}
|
|
|
|
*clpp = clp;
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Get a reference to a clientid and return it, if valid.
|
|
*/
|
|
APPLESTATIC struct nfsclclient *
|
|
nfscl_findcl(struct nfsmount *nmp)
|
|
{
|
|
struct nfsclclient *clp;
|
|
|
|
clp = nmp->nm_clp;
|
|
if (clp == NULL || !(clp->nfsc_flags & NFSCLFLAGS_HASCLIENTID))
|
|
return (NULL);
|
|
return (clp);
|
|
}
|
|
|
|
/*
|
|
* Release the clientid structure. It may be locked or reference counted.
|
|
*/
|
|
static void
|
|
nfscl_clrelease(struct nfsclclient *clp)
|
|
{
|
|
|
|
if (clp->nfsc_lock.nfslock_lock & NFSV4LOCK_LOCK)
|
|
nfsv4_unlock(&clp->nfsc_lock, 0);
|
|
else
|
|
nfsv4_relref(&clp->nfsc_lock);
|
|
}
|
|
|
|
/*
|
|
* External call for nfscl_clrelease.
|
|
*/
|
|
APPLESTATIC void
|
|
nfscl_clientrelease(struct nfsclclient *clp)
|
|
{
|
|
|
|
NFSLOCKCLSTATE();
|
|
if (clp->nfsc_lock.nfslock_lock & NFSV4LOCK_LOCK)
|
|
nfsv4_unlock(&clp->nfsc_lock, 0);
|
|
else
|
|
nfsv4_relref(&clp->nfsc_lock);
|
|
NFSUNLOCKCLSTATE();
|
|
}
|
|
|
|
/*
|
|
* Called when wanting to lock a byte region.
|
|
*/
|
|
APPLESTATIC int
|
|
nfscl_getbytelock(vnode_t vp, u_int64_t off, u_int64_t len,
|
|
short type, struct ucred *cred, NFSPROC_T *p, struct nfsclclient *rclp,
|
|
int recovery, void *id, int flags, u_int8_t *rownp, u_int8_t *ropenownp,
|
|
struct nfscllockowner **lpp, int *newonep, int *donelocallyp)
|
|
{
|
|
struct nfscllockowner *lp;
|
|
struct nfsclopen *op;
|
|
struct nfsclclient *clp;
|
|
struct nfscllockowner *nlp;
|
|
struct nfscllock *nlop, *otherlop;
|
|
struct nfscldeleg *dp = NULL, *ldp = NULL;
|
|
struct nfscllockownerhead *lhp = NULL;
|
|
struct nfsnode *np;
|
|
u_int8_t own[NFSV4CL_LOCKNAMELEN], *ownp, openown[NFSV4CL_LOCKNAMELEN];
|
|
u_int8_t *openownp;
|
|
int error = 0, ret, donelocally = 0;
|
|
u_int32_t mode;
|
|
|
|
/* For Lock Ops, the open mode doesn't matter, so use 0 to match any. */
|
|
mode = 0;
|
|
np = VTONFS(vp);
|
|
*lpp = NULL;
|
|
lp = NULL;
|
|
*newonep = 0;
|
|
*donelocallyp = 0;
|
|
|
|
/*
|
|
* Might need these, so MALLOC them now, to
|
|
* avoid a tsleep() in MALLOC later.
|
|
*/
|
|
MALLOC(nlp, struct nfscllockowner *,
|
|
sizeof (struct nfscllockowner), M_NFSCLLOCKOWNER, M_WAITOK);
|
|
MALLOC(otherlop, struct nfscllock *,
|
|
sizeof (struct nfscllock), M_NFSCLLOCK, M_WAITOK);
|
|
MALLOC(nlop, struct nfscllock *,
|
|
sizeof (struct nfscllock), M_NFSCLLOCK, M_WAITOK);
|
|
nlop->nfslo_type = type;
|
|
nlop->nfslo_first = off;
|
|
if (len == NFS64BITSSET) {
|
|
nlop->nfslo_end = NFS64BITSSET;
|
|
} else {
|
|
nlop->nfslo_end = off + len;
|
|
if (nlop->nfslo_end <= nlop->nfslo_first)
|
|
error = NFSERR_INVAL;
|
|
}
|
|
|
|
if (!error) {
|
|
if (recovery)
|
|
clp = rclp;
|
|
else
|
|
error = nfscl_getcl(vnode_mount(vp), cred, p, 1, &clp);
|
|
}
|
|
if (error) {
|
|
FREE((caddr_t)nlp, M_NFSCLLOCKOWNER);
|
|
FREE((caddr_t)otherlop, M_NFSCLLOCK);
|
|
FREE((caddr_t)nlop, M_NFSCLLOCK);
|
|
return (error);
|
|
}
|
|
|
|
op = NULL;
|
|
if (recovery) {
|
|
ownp = rownp;
|
|
openownp = ropenownp;
|
|
} else {
|
|
nfscl_filllockowner(id, own, flags);
|
|
ownp = own;
|
|
nfscl_filllockowner(p->td_proc, openown, F_POSIX);
|
|
openownp = openown;
|
|
}
|
|
if (!recovery) {
|
|
NFSLOCKCLSTATE();
|
|
/*
|
|
* First, search for a delegation. If one exists for this file,
|
|
* the lock can be done locally against it, so long as there
|
|
* isn't a local lock conflict.
|
|
*/
|
|
ldp = dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh,
|
|
np->n_fhp->nfh_len);
|
|
/* Just sanity check for correct type of delegation */
|
|
if (dp != NULL && ((dp->nfsdl_flags &
|
|
(NFSCLDL_RECALL | NFSCLDL_DELEGRET)) != 0 ||
|
|
(type == F_WRLCK &&
|
|
(dp->nfsdl_flags & NFSCLDL_WRITE) == 0)))
|
|
dp = NULL;
|
|
}
|
|
if (dp != NULL) {
|
|
/* Now, find an open and maybe a lockowner. */
|
|
ret = nfscl_getopen(&dp->nfsdl_owner, np->n_fhp->nfh_fh,
|
|
np->n_fhp->nfh_len, openownp, ownp, mode, NULL, &op);
|
|
if (ret)
|
|
ret = nfscl_getopen(&clp->nfsc_owner,
|
|
np->n_fhp->nfh_fh, np->n_fhp->nfh_len, openownp,
|
|
ownp, mode, NULL, &op);
|
|
if (!ret) {
|
|
lhp = &dp->nfsdl_lock;
|
|
TAILQ_REMOVE(&clp->nfsc_deleg, dp, nfsdl_list);
|
|
TAILQ_INSERT_HEAD(&clp->nfsc_deleg, dp, nfsdl_list);
|
|
dp->nfsdl_timestamp = NFSD_MONOSEC + 120;
|
|
donelocally = 1;
|
|
} else {
|
|
dp = NULL;
|
|
}
|
|
}
|
|
if (!donelocally) {
|
|
/*
|
|
* Get the related Open and maybe lockowner.
|
|
*/
|
|
error = nfscl_getopen(&clp->nfsc_owner,
|
|
np->n_fhp->nfh_fh, np->n_fhp->nfh_len, openownp,
|
|
ownp, mode, &lp, &op);
|
|
if (!error)
|
|
lhp = &op->nfso_lock;
|
|
}
|
|
if (!error && !recovery)
|
|
error = nfscl_localconflict(clp, np->n_fhp->nfh_fh,
|
|
np->n_fhp->nfh_len, nlop, ownp, ldp, NULL);
|
|
if (error) {
|
|
if (!recovery) {
|
|
nfscl_clrelease(clp);
|
|
NFSUNLOCKCLSTATE();
|
|
}
|
|
FREE((caddr_t)nlp, M_NFSCLLOCKOWNER);
|
|
FREE((caddr_t)otherlop, M_NFSCLLOCK);
|
|
FREE((caddr_t)nlop, M_NFSCLLOCK);
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* Ok, see if a lockowner exists and create one, as required.
|
|
*/
|
|
if (lp == NULL)
|
|
LIST_FOREACH(lp, lhp, nfsl_list) {
|
|
if (!NFSBCMP(lp->nfsl_owner, ownp, NFSV4CL_LOCKNAMELEN))
|
|
break;
|
|
}
|
|
if (lp == NULL) {
|
|
NFSBCOPY(ownp, nlp->nfsl_owner, NFSV4CL_LOCKNAMELEN);
|
|
if (recovery)
|
|
NFSBCOPY(ropenownp, nlp->nfsl_openowner,
|
|
NFSV4CL_LOCKNAMELEN);
|
|
else
|
|
NFSBCOPY(op->nfso_own->nfsow_owner, nlp->nfsl_openowner,
|
|
NFSV4CL_LOCKNAMELEN);
|
|
nlp->nfsl_seqid = 0;
|
|
nlp->nfsl_lockflags = flags;
|
|
nlp->nfsl_inprog = NULL;
|
|
nfscl_lockinit(&nlp->nfsl_rwlock);
|
|
LIST_INIT(&nlp->nfsl_lock);
|
|
if (donelocally) {
|
|
nlp->nfsl_open = NULL;
|
|
newnfsstats.cllocallockowners++;
|
|
} else {
|
|
nlp->nfsl_open = op;
|
|
newnfsstats.cllockowners++;
|
|
}
|
|
LIST_INSERT_HEAD(lhp, nlp, nfsl_list);
|
|
lp = nlp;
|
|
nlp = NULL;
|
|
*newonep = 1;
|
|
}
|
|
|
|
/*
|
|
* Now, update the byte ranges for locks.
|
|
*/
|
|
ret = nfscl_updatelock(lp, &nlop, &otherlop, donelocally);
|
|
if (!ret)
|
|
donelocally = 1;
|
|
if (donelocally) {
|
|
*donelocallyp = 1;
|
|
if (!recovery)
|
|
nfscl_clrelease(clp);
|
|
} else {
|
|
/*
|
|
* Serial modifications on the lock owner for multiple threads
|
|
* for the same process using a read/write lock.
|
|
*/
|
|
if (!recovery)
|
|
nfscl_lockexcl(&lp->nfsl_rwlock, NFSCLSTATEMUTEXPTR);
|
|
}
|
|
if (!recovery)
|
|
NFSUNLOCKCLSTATE();
|
|
|
|
if (nlp)
|
|
FREE((caddr_t)nlp, M_NFSCLLOCKOWNER);
|
|
if (nlop)
|
|
FREE((caddr_t)nlop, M_NFSCLLOCK);
|
|
if (otherlop)
|
|
FREE((caddr_t)otherlop, M_NFSCLLOCK);
|
|
|
|
*lpp = lp;
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Called to unlock a byte range, for LockU.
|
|
*/
|
|
APPLESTATIC int
|
|
nfscl_relbytelock(vnode_t vp, u_int64_t off, u_int64_t len,
|
|
__unused struct ucred *cred, NFSPROC_T *p, int callcnt,
|
|
struct nfsclclient *clp, void *id, int flags,
|
|
struct nfscllockowner **lpp, int *dorpcp)
|
|
{
|
|
struct nfscllockowner *lp;
|
|
struct nfsclowner *owp;
|
|
struct nfsclopen *op;
|
|
struct nfscllock *nlop, *other_lop = NULL;
|
|
struct nfscldeleg *dp;
|
|
struct nfsnode *np;
|
|
u_int8_t own[NFSV4CL_LOCKNAMELEN];
|
|
int ret = 0, fnd;
|
|
|
|
np = VTONFS(vp);
|
|
*lpp = NULL;
|
|
*dorpcp = 0;
|
|
|
|
/*
|
|
* Might need these, so MALLOC them now, to
|
|
* avoid a tsleep() in MALLOC later.
|
|
*/
|
|
MALLOC(nlop, struct nfscllock *,
|
|
sizeof (struct nfscllock), M_NFSCLLOCK, M_WAITOK);
|
|
nlop->nfslo_type = F_UNLCK;
|
|
nlop->nfslo_first = off;
|
|
if (len == NFS64BITSSET) {
|
|
nlop->nfslo_end = NFS64BITSSET;
|
|
} else {
|
|
nlop->nfslo_end = off + len;
|
|
if (nlop->nfslo_end <= nlop->nfslo_first) {
|
|
FREE((caddr_t)nlop, M_NFSCLLOCK);
|
|
return (NFSERR_INVAL);
|
|
}
|
|
}
|
|
if (callcnt == 0) {
|
|
MALLOC(other_lop, struct nfscllock *,
|
|
sizeof (struct nfscllock), M_NFSCLLOCK, M_WAITOK);
|
|
*other_lop = *nlop;
|
|
}
|
|
nfscl_filllockowner(id, own, flags);
|
|
dp = NULL;
|
|
NFSLOCKCLSTATE();
|
|
if (callcnt == 0)
|
|
dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh,
|
|
np->n_fhp->nfh_len);
|
|
|
|
/*
|
|
* First, unlock any local regions on a delegation.
|
|
*/
|
|
if (dp != NULL) {
|
|
/* Look for this lockowner. */
|
|
LIST_FOREACH(lp, &dp->nfsdl_lock, nfsl_list) {
|
|
if (!NFSBCMP(lp->nfsl_owner, own,
|
|
NFSV4CL_LOCKNAMELEN))
|
|
break;
|
|
}
|
|
if (lp != NULL)
|
|
/* Use other_lop, so nlop is still available */
|
|
(void)nfscl_updatelock(lp, &other_lop, NULL, 1);
|
|
}
|
|
|
|
/*
|
|
* Now, find a matching open/lockowner that hasn't already been done,
|
|
* as marked by nfsl_inprog.
|
|
*/
|
|
lp = NULL;
|
|
fnd = 0;
|
|
LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
|
|
LIST_FOREACH(op, &owp->nfsow_open, nfso_list) {
|
|
if (op->nfso_fhlen == np->n_fhp->nfh_len &&
|
|
!NFSBCMP(op->nfso_fh, np->n_fhp->nfh_fh, op->nfso_fhlen)) {
|
|
LIST_FOREACH(lp, &op->nfso_lock, nfsl_list) {
|
|
if (lp->nfsl_inprog == NULL &&
|
|
!NFSBCMP(lp->nfsl_owner, own,
|
|
NFSV4CL_LOCKNAMELEN)) {
|
|
fnd = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (fnd)
|
|
break;
|
|
}
|
|
}
|
|
if (fnd)
|
|
break;
|
|
}
|
|
|
|
if (lp != NULL) {
|
|
ret = nfscl_updatelock(lp, &nlop, NULL, 0);
|
|
if (ret)
|
|
*dorpcp = 1;
|
|
/*
|
|
* Serial modifications on the lock owner for multiple
|
|
* threads for the same process using a read/write lock.
|
|
*/
|
|
lp->nfsl_inprog = p;
|
|
nfscl_lockexcl(&lp->nfsl_rwlock, NFSCLSTATEMUTEXPTR);
|
|
*lpp = lp;
|
|
}
|
|
NFSUNLOCKCLSTATE();
|
|
if (nlop)
|
|
FREE((caddr_t)nlop, M_NFSCLLOCK);
|
|
if (other_lop)
|
|
FREE((caddr_t)other_lop, M_NFSCLLOCK);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Release all lockowners marked in progess for this process and file.
|
|
*/
|
|
APPLESTATIC void
|
|
nfscl_releasealllocks(struct nfsclclient *clp, vnode_t vp, NFSPROC_T *p,
|
|
void *id, int flags)
|
|
{
|
|
struct nfsclowner *owp;
|
|
struct nfsclopen *op;
|
|
struct nfscllockowner *lp;
|
|
struct nfsnode *np;
|
|
u_int8_t own[NFSV4CL_LOCKNAMELEN];
|
|
|
|
np = VTONFS(vp);
|
|
nfscl_filllockowner(id, own, flags);
|
|
NFSLOCKCLSTATE();
|
|
LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
|
|
LIST_FOREACH(op, &owp->nfsow_open, nfso_list) {
|
|
if (op->nfso_fhlen == np->n_fhp->nfh_len &&
|
|
!NFSBCMP(op->nfso_fh, np->n_fhp->nfh_fh, op->nfso_fhlen)) {
|
|
LIST_FOREACH(lp, &op->nfso_lock, nfsl_list) {
|
|
if (lp->nfsl_inprog == p &&
|
|
!NFSBCMP(lp->nfsl_owner, own,
|
|
NFSV4CL_LOCKNAMELEN)) {
|
|
lp->nfsl_inprog = NULL;
|
|
nfscl_lockunlock(&lp->nfsl_rwlock);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
nfscl_clrelease(clp);
|
|
NFSUNLOCKCLSTATE();
|
|
}
|
|
|
|
/*
|
|
* Called to find out if any bytes within the byte range specified are
|
|
* write locked by the calling process. Used to determine if flushing
|
|
* is required before a LockU.
|
|
* If in doubt, return 1, so the flush will occur.
|
|
*/
|
|
APPLESTATIC int
|
|
nfscl_checkwritelocked(vnode_t vp, struct flock *fl,
|
|
struct ucred *cred, NFSPROC_T *p, void *id, int flags)
|
|
{
|
|
struct nfsclowner *owp;
|
|
struct nfscllockowner *lp;
|
|
struct nfsclopen *op;
|
|
struct nfsclclient *clp;
|
|
struct nfscllock *lop;
|
|
struct nfscldeleg *dp;
|
|
struct nfsnode *np;
|
|
u_int64_t off, end;
|
|
u_int8_t own[NFSV4CL_LOCKNAMELEN];
|
|
int error = 0;
|
|
|
|
np = VTONFS(vp);
|
|
switch (fl->l_whence) {
|
|
case SEEK_SET:
|
|
case SEEK_CUR:
|
|
/*
|
|
* Caller is responsible for adding any necessary offset
|
|
* when SEEK_CUR is used.
|
|
*/
|
|
off = fl->l_start;
|
|
break;
|
|
case SEEK_END:
|
|
off = np->n_size + fl->l_start;
|
|
break;
|
|
default:
|
|
return (1);
|
|
};
|
|
if (fl->l_len != 0) {
|
|
end = off + fl->l_len;
|
|
if (end < off)
|
|
return (1);
|
|
} else {
|
|
end = NFS64BITSSET;
|
|
}
|
|
|
|
error = nfscl_getcl(vnode_mount(vp), cred, p, 1, &clp);
|
|
if (error)
|
|
return (1);
|
|
nfscl_filllockowner(id, own, flags);
|
|
NFSLOCKCLSTATE();
|
|
|
|
/*
|
|
* First check the delegation locks.
|
|
*/
|
|
dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
|
|
if (dp != NULL) {
|
|
LIST_FOREACH(lp, &dp->nfsdl_lock, nfsl_list) {
|
|
if (!NFSBCMP(lp->nfsl_owner, own,
|
|
NFSV4CL_LOCKNAMELEN))
|
|
break;
|
|
}
|
|
if (lp != NULL) {
|
|
LIST_FOREACH(lop, &lp->nfsl_lock, nfslo_list) {
|
|
if (lop->nfslo_first >= end)
|
|
break;
|
|
if (lop->nfslo_end <= off)
|
|
continue;
|
|
if (lop->nfslo_type == F_WRLCK) {
|
|
nfscl_clrelease(clp);
|
|
NFSUNLOCKCLSTATE();
|
|
return (1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Now, check state against the server.
|
|
*/
|
|
LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
|
|
LIST_FOREACH(op, &owp->nfsow_open, nfso_list) {
|
|
if (op->nfso_fhlen == np->n_fhp->nfh_len &&
|
|
!NFSBCMP(op->nfso_fh, np->n_fhp->nfh_fh, op->nfso_fhlen)) {
|
|
LIST_FOREACH(lp, &op->nfso_lock, nfsl_list) {
|
|
if (!NFSBCMP(lp->nfsl_owner, own,
|
|
NFSV4CL_LOCKNAMELEN))
|
|
break;
|
|
}
|
|
if (lp != NULL) {
|
|
LIST_FOREACH(lop, &lp->nfsl_lock, nfslo_list) {
|
|
if (lop->nfslo_first >= end)
|
|
break;
|
|
if (lop->nfslo_end <= off)
|
|
continue;
|
|
if (lop->nfslo_type == F_WRLCK) {
|
|
nfscl_clrelease(clp);
|
|
NFSUNLOCKCLSTATE();
|
|
return (1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
nfscl_clrelease(clp);
|
|
NFSUNLOCKCLSTATE();
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Release a byte range lock owner structure.
|
|
*/
|
|
APPLESTATIC void
|
|
nfscl_lockrelease(struct nfscllockowner *lp, int error, int candelete)
|
|
{
|
|
struct nfsclclient *clp;
|
|
|
|
if (lp == NULL)
|
|
return;
|
|
NFSLOCKCLSTATE();
|
|
clp = lp->nfsl_open->nfso_own->nfsow_clp;
|
|
if (error != 0 && candelete &&
|
|
(lp->nfsl_rwlock.nfslock_lock & NFSV4LOCK_WANTED) == 0)
|
|
nfscl_freelockowner(lp, 0);
|
|
else
|
|
nfscl_lockunlock(&lp->nfsl_rwlock);
|
|
nfscl_clrelease(clp);
|
|
NFSUNLOCKCLSTATE();
|
|
}
|
|
|
|
/*
|
|
* Free up an open structure and any associated byte range lock structures.
|
|
*/
|
|
APPLESTATIC void
|
|
nfscl_freeopen(struct nfsclopen *op, int local)
|
|
{
|
|
|
|
LIST_REMOVE(op, nfso_list);
|
|
nfscl_freealllocks(&op->nfso_lock, local);
|
|
FREE((caddr_t)op, M_NFSCLOPEN);
|
|
if (local)
|
|
newnfsstats.cllocalopens--;
|
|
else
|
|
newnfsstats.clopens--;
|
|
}
|
|
|
|
/*
|
|
* Free up all lock owners and associated locks.
|
|
*/
|
|
static void
|
|
nfscl_freealllocks(struct nfscllockownerhead *lhp, int local)
|
|
{
|
|
struct nfscllockowner *lp, *nlp;
|
|
|
|
LIST_FOREACH_SAFE(lp, lhp, nfsl_list, nlp) {
|
|
if ((lp->nfsl_rwlock.nfslock_lock & NFSV4LOCK_WANTED))
|
|
panic("nfscllckw");
|
|
nfscl_freelockowner(lp, local);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Called for an Open when NFSERR_EXPIRED is received from the server.
|
|
* If there are no byte range locks nor a Share Deny lost, try to do a
|
|
* fresh Open. Otherwise, free the open.
|
|
*/
|
|
static int
|
|
nfscl_expireopen(struct nfsclclient *clp, struct nfsclopen *op,
|
|
struct nfsmount *nmp, struct ucred *cred, NFSPROC_T *p)
|
|
{
|
|
struct nfscllockowner *lp;
|
|
struct nfscldeleg *dp;
|
|
int mustdelete = 0, error;
|
|
|
|
/*
|
|
* Look for any byte range lock(s).
|
|
*/
|
|
LIST_FOREACH(lp, &op->nfso_lock, nfsl_list) {
|
|
if (!LIST_EMPTY(&lp->nfsl_lock)) {
|
|
mustdelete = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If no byte range lock(s) nor a Share deny, try to re-open.
|
|
*/
|
|
if (!mustdelete && (op->nfso_mode & NFSLCK_DENYBITS) == 0) {
|
|
newnfs_copycred(&op->nfso_cred, cred);
|
|
dp = NULL;
|
|
error = nfsrpc_reopen(nmp, op->nfso_fh,
|
|
op->nfso_fhlen, op->nfso_mode, op, &dp, cred, p);
|
|
if (error) {
|
|
mustdelete = 1;
|
|
if (dp != NULL) {
|
|
FREE((caddr_t)dp, M_NFSCLDELEG);
|
|
dp = NULL;
|
|
}
|
|
}
|
|
if (dp != NULL)
|
|
nfscl_deleg(nmp->nm_mountp, clp, op->nfso_fh,
|
|
op->nfso_fhlen, cred, p, &dp);
|
|
}
|
|
|
|
/*
|
|
* If a byte range lock or Share deny or couldn't re-open, free it.
|
|
*/
|
|
if (mustdelete)
|
|
nfscl_freeopen(op, 0);
|
|
return (mustdelete);
|
|
}
|
|
|
|
/*
|
|
* Free up an open owner structure.
|
|
*/
|
|
static void
|
|
nfscl_freeopenowner(struct nfsclowner *owp, int local)
|
|
{
|
|
|
|
LIST_REMOVE(owp, nfsow_list);
|
|
FREE((caddr_t)owp, M_NFSCLOWNER);
|
|
if (local)
|
|
newnfsstats.cllocalopenowners--;
|
|
else
|
|
newnfsstats.clopenowners--;
|
|
}
|
|
|
|
/*
|
|
* Free up a byte range lock owner structure.
|
|
*/
|
|
APPLESTATIC void
|
|
nfscl_freelockowner(struct nfscllockowner *lp, int local)
|
|
{
|
|
struct nfscllock *lop, *nlop;
|
|
|
|
LIST_REMOVE(lp, nfsl_list);
|
|
LIST_FOREACH_SAFE(lop, &lp->nfsl_lock, nfslo_list, nlop) {
|
|
nfscl_freelock(lop, local);
|
|
}
|
|
FREE((caddr_t)lp, M_NFSCLLOCKOWNER);
|
|
if (local)
|
|
newnfsstats.cllocallockowners--;
|
|
else
|
|
newnfsstats.cllockowners--;
|
|
}
|
|
|
|
/*
|
|
* Free up a byte range lock structure.
|
|
*/
|
|
APPLESTATIC void
|
|
nfscl_freelock(struct nfscllock *lop, int local)
|
|
{
|
|
|
|
LIST_REMOVE(lop, nfslo_list);
|
|
FREE((caddr_t)lop, M_NFSCLLOCK);
|
|
if (local)
|
|
newnfsstats.cllocallocks--;
|
|
else
|
|
newnfsstats.cllocks--;
|
|
}
|
|
|
|
/*
|
|
* Clean out the state related to a delegation.
|
|
*/
|
|
static void
|
|
nfscl_cleandeleg(struct nfscldeleg *dp)
|
|
{
|
|
struct nfsclowner *owp, *nowp;
|
|
struct nfsclopen *op;
|
|
|
|
LIST_FOREACH_SAFE(owp, &dp->nfsdl_owner, nfsow_list, nowp) {
|
|
op = LIST_FIRST(&owp->nfsow_open);
|
|
if (op != NULL) {
|
|
if (LIST_NEXT(op, nfso_list) != NULL)
|
|
panic("nfscleandel");
|
|
nfscl_freeopen(op, 1);
|
|
}
|
|
nfscl_freeopenowner(owp, 1);
|
|
}
|
|
nfscl_freealllocks(&dp->nfsdl_lock, 1);
|
|
}
|
|
|
|
/*
|
|
* Free a delegation.
|
|
*/
|
|
static void
|
|
nfscl_freedeleg(struct nfscldeleghead *hdp, struct nfscldeleg *dp)
|
|
{
|
|
|
|
TAILQ_REMOVE(hdp, dp, nfsdl_list);
|
|
LIST_REMOVE(dp, nfsdl_hash);
|
|
FREE((caddr_t)dp, M_NFSCLDELEG);
|
|
newnfsstats.cldelegates--;
|
|
nfscl_delegcnt--;
|
|
}
|
|
|
|
/*
|
|
* Free up all state related to this client structure.
|
|
*/
|
|
static void
|
|
nfscl_cleanclient(struct nfsclclient *clp)
|
|
{
|
|
struct nfsclowner *owp, *nowp;
|
|
struct nfsclopen *op, *nop;
|
|
|
|
/* Now, all the OpenOwners, etc. */
|
|
LIST_FOREACH_SAFE(owp, &clp->nfsc_owner, nfsow_list, nowp) {
|
|
LIST_FOREACH_SAFE(op, &owp->nfsow_open, nfso_list, nop) {
|
|
nfscl_freeopen(op, 0);
|
|
}
|
|
nfscl_freeopenowner(owp, 0);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Called when an NFSERR_EXPIRED is received from the server.
|
|
*/
|
|
static void
|
|
nfscl_expireclient(struct nfsclclient *clp, struct nfsmount *nmp,
|
|
struct ucred *cred, NFSPROC_T *p)
|
|
{
|
|
struct nfsclowner *owp, *nowp, *towp;
|
|
struct nfsclopen *op, *nop, *top;
|
|
struct nfscldeleg *dp, *ndp;
|
|
int ret, printed = 0;
|
|
|
|
/*
|
|
* First, merge locally issued Opens into the list for the server.
|
|
*/
|
|
dp = TAILQ_FIRST(&clp->nfsc_deleg);
|
|
while (dp != NULL) {
|
|
ndp = TAILQ_NEXT(dp, nfsdl_list);
|
|
owp = LIST_FIRST(&dp->nfsdl_owner);
|
|
while (owp != NULL) {
|
|
nowp = LIST_NEXT(owp, nfsow_list);
|
|
op = LIST_FIRST(&owp->nfsow_open);
|
|
if (op != NULL) {
|
|
if (LIST_NEXT(op, nfso_list) != NULL)
|
|
panic("nfsclexp");
|
|
LIST_FOREACH(towp, &clp->nfsc_owner, nfsow_list) {
|
|
if (!NFSBCMP(towp->nfsow_owner, owp->nfsow_owner,
|
|
NFSV4CL_LOCKNAMELEN))
|
|
break;
|
|
}
|
|
if (towp != NULL) {
|
|
/* Merge opens in */
|
|
LIST_FOREACH(top, &towp->nfsow_open, nfso_list) {
|
|
if (top->nfso_fhlen == op->nfso_fhlen &&
|
|
!NFSBCMP(top->nfso_fh, op->nfso_fh,
|
|
op->nfso_fhlen)) {
|
|
top->nfso_mode |= op->nfso_mode;
|
|
top->nfso_opencnt += op->nfso_opencnt;
|
|
break;
|
|
}
|
|
}
|
|
if (top == NULL) {
|
|
/* Just add the open to the owner list */
|
|
LIST_REMOVE(op, nfso_list);
|
|
op->nfso_own = towp;
|
|
LIST_INSERT_HEAD(&towp->nfsow_open, op, nfso_list);
|
|
newnfsstats.cllocalopens--;
|
|
newnfsstats.clopens++;
|
|
}
|
|
} else {
|
|
/* Just add the openowner to the client list */
|
|
LIST_REMOVE(owp, nfsow_list);
|
|
owp->nfsow_clp = clp;
|
|
LIST_INSERT_HEAD(&clp->nfsc_owner, owp, nfsow_list);
|
|
newnfsstats.cllocalopenowners--;
|
|
newnfsstats.clopenowners++;
|
|
newnfsstats.cllocalopens--;
|
|
newnfsstats.clopens++;
|
|
}
|
|
}
|
|
owp = nowp;
|
|
}
|
|
if (!printed && !LIST_EMPTY(&dp->nfsdl_lock)) {
|
|
printed = 1;
|
|
printf("nfsv4 expired locks lost\n");
|
|
}
|
|
nfscl_cleandeleg(dp);
|
|
nfscl_freedeleg(&clp->nfsc_deleg, dp);
|
|
dp = ndp;
|
|
}
|
|
if (!TAILQ_EMPTY(&clp->nfsc_deleg))
|
|
panic("nfsclexp");
|
|
|
|
/*
|
|
* Now, try and reopen against the server.
|
|
*/
|
|
LIST_FOREACH_SAFE(owp, &clp->nfsc_owner, nfsow_list, nowp) {
|
|
owp->nfsow_seqid = 0;
|
|
LIST_FOREACH_SAFE(op, &owp->nfsow_open, nfso_list, nop) {
|
|
ret = nfscl_expireopen(clp, op, nmp, cred, p);
|
|
if (ret && !printed) {
|
|
printed = 1;
|
|
printf("nfsv4 expired locks lost\n");
|
|
}
|
|
}
|
|
if (LIST_EMPTY(&owp->nfsow_open))
|
|
nfscl_freeopenowner(owp, 0);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This function must be called after the process represented by "own" has
|
|
* exited. Must be called with CLSTATE lock held.
|
|
*/
|
|
static void
|
|
nfscl_cleanup_common(struct nfsclclient *clp, u_int8_t *own)
|
|
{
|
|
struct nfsclowner *owp, *nowp;
|
|
struct nfscllockowner *lp, *nlp;
|
|
struct nfscldeleg *dp;
|
|
|
|
/* First, get rid of local locks on delegations. */
|
|
TAILQ_FOREACH(dp, &clp->nfsc_deleg, nfsdl_list) {
|
|
LIST_FOREACH_SAFE(lp, &dp->nfsdl_lock, nfsl_list, nlp) {
|
|
if (!NFSBCMP(lp->nfsl_owner, own, NFSV4CL_LOCKNAMELEN)) {
|
|
if ((lp->nfsl_rwlock.nfslock_lock & NFSV4LOCK_WANTED))
|
|
panic("nfscllckw");
|
|
nfscl_freelockowner(lp, 1);
|
|
}
|
|
}
|
|
}
|
|
owp = LIST_FIRST(&clp->nfsc_owner);
|
|
while (owp != NULL) {
|
|
nowp = LIST_NEXT(owp, nfsow_list);
|
|
if (!NFSBCMP(owp->nfsow_owner, own,
|
|
NFSV4CL_LOCKNAMELEN)) {
|
|
/*
|
|
* If there are children that haven't closed the
|
|
* file descriptors yet, the opens will still be
|
|
* here. For that case, let the renew thread clear
|
|
* out the OpenOwner later.
|
|
*/
|
|
if (LIST_EMPTY(&owp->nfsow_open))
|
|
nfscl_freeopenowner(owp, 0);
|
|
else
|
|
owp->nfsow_defunct = 1;
|
|
}
|
|
owp = nowp;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Find open/lock owners for processes that have exited.
|
|
*/
|
|
static void
|
|
nfscl_cleanupkext(struct nfsclclient *clp, struct nfscllockownerfhhead *lhp)
|
|
{
|
|
struct nfsclowner *owp, *nowp;
|
|
struct nfsclopen *op;
|
|
struct nfscllockowner *lp, *nlp;
|
|
|
|
NFSPROCLISTLOCK();
|
|
NFSLOCKCLSTATE();
|
|
LIST_FOREACH_SAFE(owp, &clp->nfsc_owner, nfsow_list, nowp) {
|
|
LIST_FOREACH(op, &owp->nfsow_open, nfso_list) {
|
|
LIST_FOREACH_SAFE(lp, &op->nfso_lock, nfsl_list, nlp) {
|
|
if (LIST_EMPTY(&lp->nfsl_lock))
|
|
nfscl_emptylockowner(lp, lhp);
|
|
}
|
|
}
|
|
if (nfscl_procdoesntexist(owp->nfsow_owner))
|
|
nfscl_cleanup_common(clp, owp->nfsow_owner);
|
|
}
|
|
NFSUNLOCKCLSTATE();
|
|
NFSPROCLISTUNLOCK();
|
|
}
|
|
|
|
/*
|
|
* Take the empty lock owner and move it to the local lhp list if the
|
|
* associated process no longer exists.
|
|
*/
|
|
static void
|
|
nfscl_emptylockowner(struct nfscllockowner *lp,
|
|
struct nfscllockownerfhhead *lhp)
|
|
{
|
|
struct nfscllockownerfh *lfhp, *mylfhp;
|
|
struct nfscllockowner *nlp;
|
|
int fnd_it;
|
|
|
|
/* If not a Posix lock owner, just return. */
|
|
if ((lp->nfsl_lockflags & F_POSIX) == 0)
|
|
return;
|
|
|
|
fnd_it = 0;
|
|
mylfhp = NULL;
|
|
/*
|
|
* First, search to see if this lock owner is already in the list.
|
|
* If it is, then the associated process no longer exists.
|
|
*/
|
|
SLIST_FOREACH(lfhp, lhp, nfslfh_list) {
|
|
if (lfhp->nfslfh_len == lp->nfsl_open->nfso_fhlen &&
|
|
!NFSBCMP(lfhp->nfslfh_fh, lp->nfsl_open->nfso_fh,
|
|
lfhp->nfslfh_len))
|
|
mylfhp = lfhp;
|
|
LIST_FOREACH(nlp, &lfhp->nfslfh_lock, nfsl_list)
|
|
if (!NFSBCMP(nlp->nfsl_owner, lp->nfsl_owner,
|
|
NFSV4CL_LOCKNAMELEN))
|
|
fnd_it = 1;
|
|
}
|
|
/* If not found, check if process still exists. */
|
|
if (fnd_it == 0 && nfscl_procdoesntexist(lp->nfsl_owner) == 0)
|
|
return;
|
|
|
|
/* Move the lock owner over to the local list. */
|
|
if (mylfhp == NULL) {
|
|
mylfhp = malloc(sizeof(struct nfscllockownerfh), M_TEMP,
|
|
M_NOWAIT);
|
|
if (mylfhp == NULL)
|
|
return;
|
|
mylfhp->nfslfh_len = lp->nfsl_open->nfso_fhlen;
|
|
NFSBCOPY(lp->nfsl_open->nfso_fh, mylfhp->nfslfh_fh,
|
|
mylfhp->nfslfh_len);
|
|
LIST_INIT(&mylfhp->nfslfh_lock);
|
|
SLIST_INSERT_HEAD(lhp, mylfhp, nfslfh_list);
|
|
}
|
|
LIST_REMOVE(lp, nfsl_list);
|
|
LIST_INSERT_HEAD(&mylfhp->nfslfh_lock, lp, nfsl_list);
|
|
}
|
|
|
|
static int fake_global; /* Used to force visibility of MNTK_UNMOUNTF */
|
|
/*
|
|
* Called from nfs umount to free up the clientid.
|
|
*/
|
|
APPLESTATIC void
|
|
nfscl_umount(struct nfsmount *nmp, NFSPROC_T *p)
|
|
{
|
|
struct nfsclclient *clp;
|
|
struct ucred *cred;
|
|
int igotlock;
|
|
|
|
/*
|
|
* For the case that matters, this is the thread that set
|
|
* MNTK_UNMOUNTF, so it will see it set. The code that follows is
|
|
* done to ensure that any thread executing nfscl_getcl() after
|
|
* this time, will see MNTK_UNMOUNTF set. nfscl_getcl() uses the
|
|
* mutex for NFSLOCKCLSTATE(), so it is "m" for the following
|
|
* explanation, courtesy of Alan Cox.
|
|
* What follows is a snippet from Alan Cox's email at:
|
|
* http://docs.FreeBSD.org/cgi/
|
|
* mid.cgi?BANLkTikR3d65zPHo9==08ZfJ2vmqZucEvw
|
|
*
|
|
* 1. Set MNTK_UNMOUNTF
|
|
* 2. Acquire a standard FreeBSD mutex "m".
|
|
* 3. Update some data structures.
|
|
* 4. Release mutex "m".
|
|
*
|
|
* Then, other threads that acquire "m" after step 4 has occurred will
|
|
* see MNTK_UNMOUNTF as set. But, other threads that beat thread X to
|
|
* step 2 may or may not see MNTK_UNMOUNTF as set.
|
|
*/
|
|
NFSLOCKCLSTATE();
|
|
if ((nmp->nm_mountp->mnt_kern_flag & MNTK_UNMOUNTF) != 0) {
|
|
fake_global++;
|
|
NFSUNLOCKCLSTATE();
|
|
NFSLOCKCLSTATE();
|
|
}
|
|
|
|
clp = nmp->nm_clp;
|
|
if (clp != NULL) {
|
|
if ((clp->nfsc_flags & NFSCLFLAGS_INITED) == 0)
|
|
panic("nfscl umount");
|
|
|
|
/*
|
|
* First, handshake with the nfscl renew thread, to terminate
|
|
* it.
|
|
*/
|
|
clp->nfsc_flags |= NFSCLFLAGS_UMOUNT;
|
|
while (clp->nfsc_flags & NFSCLFLAGS_HASTHREAD)
|
|
(void)mtx_sleep(clp, NFSCLSTATEMUTEXPTR, PWAIT,
|
|
"nfsclumnt", hz);
|
|
|
|
/*
|
|
* Now, get the exclusive lock on the client state, so
|
|
* that no uses of the state are still in progress.
|
|
*/
|
|
do {
|
|
igotlock = nfsv4_lock(&clp->nfsc_lock, 1, NULL,
|
|
NFSCLSTATEMUTEXPTR, NULL);
|
|
} while (!igotlock);
|
|
NFSUNLOCKCLSTATE();
|
|
|
|
/*
|
|
* Free up all the state. It will expire on the server, but
|
|
* maybe we should do a SetClientId/SetClientIdConfirm so
|
|
* the server throws it away?
|
|
*/
|
|
LIST_REMOVE(clp, nfsc_list);
|
|
nfscl_delegreturnall(clp, p);
|
|
cred = newnfs_getcred();
|
|
if (NFSHASNFSV4N(nmp)) {
|
|
(void)nfsrpc_destroysession(nmp, clp, cred, p);
|
|
(void)nfsrpc_destroyclient(nmp, clp, cred, p);
|
|
} else
|
|
(void)nfsrpc_setclient(nmp, clp, 0, cred, p);
|
|
nfscl_cleanclient(clp);
|
|
nmp->nm_clp = NULL;
|
|
NFSFREECRED(cred);
|
|
free(clp, M_NFSCLCLIENT);
|
|
} else
|
|
NFSUNLOCKCLSTATE();
|
|
}
|
|
|
|
/*
|
|
* This function is called when a server replies with NFSERR_STALECLIENTID
|
|
* NFSERR_STALESTATEID or NFSERR_BADSESSION. It traverses the clientid lists,
|
|
* doing Opens and Locks with reclaim. If these fail, it deletes the
|
|
* corresponding state.
|
|
*/
|
|
static void
|
|
nfscl_recover(struct nfsclclient *clp, struct ucred *cred, NFSPROC_T *p)
|
|
{
|
|
struct nfsclowner *owp, *nowp;
|
|
struct nfsclopen *op, *nop;
|
|
struct nfscllockowner *lp, *nlp;
|
|
struct nfscllock *lop, *nlop;
|
|
struct nfscldeleg *dp, *ndp, *tdp;
|
|
struct nfsmount *nmp;
|
|
struct ucred *tcred;
|
|
struct nfsclopenhead extra_open;
|
|
struct nfscldeleghead extra_deleg;
|
|
struct nfsreq *rep;
|
|
u_int64_t len;
|
|
u_int32_t delegtype = NFSV4OPEN_DELEGATEWRITE, mode;
|
|
int i, igotlock = 0, error, trycnt, firstlock;
|
|
struct nfscllayout *lyp, *nlyp;
|
|
|
|
/*
|
|
* First, lock the client structure, so everyone else will
|
|
* block when trying to use state.
|
|
*/
|
|
NFSLOCKCLSTATE();
|
|
clp->nfsc_flags |= NFSCLFLAGS_RECVRINPROG;
|
|
do {
|
|
igotlock = nfsv4_lock(&clp->nfsc_lock, 1, NULL,
|
|
NFSCLSTATEMUTEXPTR, NULL);
|
|
} while (!igotlock);
|
|
NFSUNLOCKCLSTATE();
|
|
|
|
nmp = clp->nfsc_nmp;
|
|
if (nmp == NULL)
|
|
panic("nfscl recover");
|
|
|
|
/*
|
|
* For now, just get rid of all layouts. There may be a need
|
|
* to do LayoutCommit Ops with reclaim == true later.
|
|
*/
|
|
TAILQ_FOREACH_SAFE(lyp, &clp->nfsc_layout, nfsly_list, nlyp)
|
|
nfscl_freelayout(lyp);
|
|
TAILQ_INIT(&clp->nfsc_layout);
|
|
for (i = 0; i < NFSCLLAYOUTHASHSIZE; i++)
|
|
LIST_INIT(&clp->nfsc_layouthash[i]);
|
|
|
|
trycnt = 5;
|
|
do {
|
|
error = nfsrpc_setclient(nmp, clp, 1, cred, p);
|
|
} while ((error == NFSERR_STALECLIENTID ||
|
|
error == NFSERR_BADSESSION ||
|
|
error == NFSERR_STALEDONTRECOVER) && --trycnt > 0);
|
|
if (error) {
|
|
nfscl_cleanclient(clp);
|
|
NFSLOCKCLSTATE();
|
|
clp->nfsc_flags &= ~(NFSCLFLAGS_HASCLIENTID |
|
|
NFSCLFLAGS_RECOVER | NFSCLFLAGS_RECVRINPROG);
|
|
wakeup(&clp->nfsc_flags);
|
|
nfsv4_unlock(&clp->nfsc_lock, 0);
|
|
NFSUNLOCKCLSTATE();
|
|
return;
|
|
}
|
|
clp->nfsc_flags |= NFSCLFLAGS_HASCLIENTID;
|
|
clp->nfsc_flags &= ~NFSCLFLAGS_RECOVER;
|
|
|
|
/*
|
|
* Mark requests already queued on the server, so that they don't
|
|
* initiate another recovery cycle. Any requests already in the
|
|
* queue that handle state information will have the old stale
|
|
* clientid/stateid and will get a NFSERR_STALESTATEID,
|
|
* NFSERR_STALECLIENTID or NFSERR_BADSESSION reply from the server.
|
|
* This will be translated to NFSERR_STALEDONTRECOVER when
|
|
* R_DONTRECOVER is set.
|
|
*/
|
|
NFSLOCKREQ();
|
|
TAILQ_FOREACH(rep, &nfsd_reqq, r_chain) {
|
|
if (rep->r_nmp == nmp)
|
|
rep->r_flags |= R_DONTRECOVER;
|
|
}
|
|
NFSUNLOCKREQ();
|
|
|
|
/*
|
|
* Now, mark all delegations "need reclaim".
|
|
*/
|
|
TAILQ_FOREACH(dp, &clp->nfsc_deleg, nfsdl_list)
|
|
dp->nfsdl_flags |= NFSCLDL_NEEDRECLAIM;
|
|
|
|
TAILQ_INIT(&extra_deleg);
|
|
LIST_INIT(&extra_open);
|
|
/*
|
|
* Now traverse the state lists, doing Open and Lock Reclaims.
|
|
*/
|
|
tcred = newnfs_getcred();
|
|
owp = LIST_FIRST(&clp->nfsc_owner);
|
|
while (owp != NULL) {
|
|
nowp = LIST_NEXT(owp, nfsow_list);
|
|
owp->nfsow_seqid = 0;
|
|
op = LIST_FIRST(&owp->nfsow_open);
|
|
while (op != NULL) {
|
|
nop = LIST_NEXT(op, nfso_list);
|
|
if (error != NFSERR_NOGRACE) {
|
|
/* Search for a delegation to reclaim with the open */
|
|
TAILQ_FOREACH(dp, &clp->nfsc_deleg, nfsdl_list) {
|
|
if (!(dp->nfsdl_flags & NFSCLDL_NEEDRECLAIM))
|
|
continue;
|
|
if ((dp->nfsdl_flags & NFSCLDL_WRITE)) {
|
|
mode = NFSV4OPEN_ACCESSWRITE;
|
|
delegtype = NFSV4OPEN_DELEGATEWRITE;
|
|
} else {
|
|
mode = NFSV4OPEN_ACCESSREAD;
|
|
delegtype = NFSV4OPEN_DELEGATEREAD;
|
|
}
|
|
if ((op->nfso_mode & mode) == mode &&
|
|
op->nfso_fhlen == dp->nfsdl_fhlen &&
|
|
!NFSBCMP(op->nfso_fh, dp->nfsdl_fh, op->nfso_fhlen))
|
|
break;
|
|
}
|
|
ndp = dp;
|
|
if (dp == NULL)
|
|
delegtype = NFSV4OPEN_DELEGATENONE;
|
|
newnfs_copycred(&op->nfso_cred, tcred);
|
|
error = nfscl_tryopen(nmp, NULL, op->nfso_fh,
|
|
op->nfso_fhlen, op->nfso_fh, op->nfso_fhlen,
|
|
op->nfso_mode, op, NULL, 0, &ndp, 1, delegtype,
|
|
tcred, p);
|
|
if (!error) {
|
|
/* Handle any replied delegation */
|
|
if (ndp != NULL && ((ndp->nfsdl_flags & NFSCLDL_WRITE)
|
|
|| NFSMNT_RDONLY(nmp->nm_mountp))) {
|
|
if ((ndp->nfsdl_flags & NFSCLDL_WRITE))
|
|
mode = NFSV4OPEN_ACCESSWRITE;
|
|
else
|
|
mode = NFSV4OPEN_ACCESSREAD;
|
|
TAILQ_FOREACH(dp, &clp->nfsc_deleg, nfsdl_list) {
|
|
if (!(dp->nfsdl_flags & NFSCLDL_NEEDRECLAIM))
|
|
continue;
|
|
if ((op->nfso_mode & mode) == mode &&
|
|
op->nfso_fhlen == dp->nfsdl_fhlen &&
|
|
!NFSBCMP(op->nfso_fh, dp->nfsdl_fh,
|
|
op->nfso_fhlen)) {
|
|
dp->nfsdl_stateid = ndp->nfsdl_stateid;
|
|
dp->nfsdl_sizelimit = ndp->nfsdl_sizelimit;
|
|
dp->nfsdl_ace = ndp->nfsdl_ace;
|
|
dp->nfsdl_change = ndp->nfsdl_change;
|
|
dp->nfsdl_flags &= ~NFSCLDL_NEEDRECLAIM;
|
|
if ((ndp->nfsdl_flags & NFSCLDL_RECALL))
|
|
dp->nfsdl_flags |= NFSCLDL_RECALL;
|
|
FREE((caddr_t)ndp, M_NFSCLDELEG);
|
|
ndp = NULL;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (ndp != NULL)
|
|
TAILQ_INSERT_HEAD(&extra_deleg, ndp, nfsdl_list);
|
|
|
|
/* and reclaim all byte range locks */
|
|
lp = LIST_FIRST(&op->nfso_lock);
|
|
while (lp != NULL) {
|
|
nlp = LIST_NEXT(lp, nfsl_list);
|
|
lp->nfsl_seqid = 0;
|
|
firstlock = 1;
|
|
lop = LIST_FIRST(&lp->nfsl_lock);
|
|
while (lop != NULL) {
|
|
nlop = LIST_NEXT(lop, nfslo_list);
|
|
if (lop->nfslo_end == NFS64BITSSET)
|
|
len = NFS64BITSSET;
|
|
else
|
|
len = lop->nfslo_end - lop->nfslo_first;
|
|
if (error != NFSERR_NOGRACE)
|
|
error = nfscl_trylock(nmp, NULL,
|
|
op->nfso_fh, op->nfso_fhlen, lp,
|
|
firstlock, 1, lop->nfslo_first, len,
|
|
lop->nfslo_type, tcred, p);
|
|
if (error != 0)
|
|
nfscl_freelock(lop, 0);
|
|
else
|
|
firstlock = 0;
|
|
lop = nlop;
|
|
}
|
|
/* If no locks, but a lockowner, just delete it. */
|
|
if (LIST_EMPTY(&lp->nfsl_lock))
|
|
nfscl_freelockowner(lp, 0);
|
|
lp = nlp;
|
|
}
|
|
} else {
|
|
nfscl_freeopen(op, 0);
|
|
}
|
|
}
|
|
op = nop;
|
|
}
|
|
owp = nowp;
|
|
}
|
|
|
|
/*
|
|
* Now, try and get any delegations not yet reclaimed by cobbling
|
|
* to-gether an appropriate open.
|
|
*/
|
|
nowp = NULL;
|
|
dp = TAILQ_FIRST(&clp->nfsc_deleg);
|
|
while (dp != NULL) {
|
|
ndp = TAILQ_NEXT(dp, nfsdl_list);
|
|
if ((dp->nfsdl_flags & NFSCLDL_NEEDRECLAIM)) {
|
|
if (nowp == NULL) {
|
|
MALLOC(nowp, struct nfsclowner *,
|
|
sizeof (struct nfsclowner), M_NFSCLOWNER, M_WAITOK);
|
|
/*
|
|
* Name must be as long an largest possible
|
|
* NFSV4CL_LOCKNAMELEN. 12 for now.
|
|
*/
|
|
NFSBCOPY("RECLAIMDELEG", nowp->nfsow_owner,
|
|
NFSV4CL_LOCKNAMELEN);
|
|
LIST_INIT(&nowp->nfsow_open);
|
|
nowp->nfsow_clp = clp;
|
|
nowp->nfsow_seqid = 0;
|
|
nowp->nfsow_defunct = 0;
|
|
nfscl_lockinit(&nowp->nfsow_rwlock);
|
|
}
|
|
nop = NULL;
|
|
if (error != NFSERR_NOGRACE) {
|
|
MALLOC(nop, struct nfsclopen *, sizeof (struct nfsclopen) +
|
|
dp->nfsdl_fhlen - 1, M_NFSCLOPEN, M_WAITOK);
|
|
nop->nfso_own = nowp;
|
|
if ((dp->nfsdl_flags & NFSCLDL_WRITE)) {
|
|
nop->nfso_mode = NFSV4OPEN_ACCESSWRITE;
|
|
delegtype = NFSV4OPEN_DELEGATEWRITE;
|
|
} else {
|
|
nop->nfso_mode = NFSV4OPEN_ACCESSREAD;
|
|
delegtype = NFSV4OPEN_DELEGATEREAD;
|
|
}
|
|
nop->nfso_opencnt = 0;
|
|
nop->nfso_posixlock = 1;
|
|
nop->nfso_fhlen = dp->nfsdl_fhlen;
|
|
NFSBCOPY(dp->nfsdl_fh, nop->nfso_fh, dp->nfsdl_fhlen);
|
|
LIST_INIT(&nop->nfso_lock);
|
|
nop->nfso_stateid.seqid = 0;
|
|
nop->nfso_stateid.other[0] = 0;
|
|
nop->nfso_stateid.other[1] = 0;
|
|
nop->nfso_stateid.other[2] = 0;
|
|
newnfs_copycred(&dp->nfsdl_cred, tcred);
|
|
newnfs_copyincred(tcred, &nop->nfso_cred);
|
|
tdp = NULL;
|
|
error = nfscl_tryopen(nmp, NULL, nop->nfso_fh,
|
|
nop->nfso_fhlen, nop->nfso_fh, nop->nfso_fhlen,
|
|
nop->nfso_mode, nop, NULL, 0, &tdp, 1,
|
|
delegtype, tcred, p);
|
|
if (tdp != NULL) {
|
|
if ((tdp->nfsdl_flags & NFSCLDL_WRITE))
|
|
mode = NFSV4OPEN_ACCESSWRITE;
|
|
else
|
|
mode = NFSV4OPEN_ACCESSREAD;
|
|
if ((nop->nfso_mode & mode) == mode &&
|
|
nop->nfso_fhlen == tdp->nfsdl_fhlen &&
|
|
!NFSBCMP(nop->nfso_fh, tdp->nfsdl_fh,
|
|
nop->nfso_fhlen)) {
|
|
dp->nfsdl_stateid = tdp->nfsdl_stateid;
|
|
dp->nfsdl_sizelimit = tdp->nfsdl_sizelimit;
|
|
dp->nfsdl_ace = tdp->nfsdl_ace;
|
|
dp->nfsdl_change = tdp->nfsdl_change;
|
|
dp->nfsdl_flags &= ~NFSCLDL_NEEDRECLAIM;
|
|
if ((tdp->nfsdl_flags & NFSCLDL_RECALL))
|
|
dp->nfsdl_flags |= NFSCLDL_RECALL;
|
|
FREE((caddr_t)tdp, M_NFSCLDELEG);
|
|
} else {
|
|
TAILQ_INSERT_HEAD(&extra_deleg, tdp, nfsdl_list);
|
|
}
|
|
}
|
|
}
|
|
if (error) {
|
|
if (nop != NULL)
|
|
FREE((caddr_t)nop, M_NFSCLOPEN);
|
|
/*
|
|
* Couldn't reclaim it, so throw the state
|
|
* away. Ouch!!
|
|
*/
|
|
nfscl_cleandeleg(dp);
|
|
nfscl_freedeleg(&clp->nfsc_deleg, dp);
|
|
} else {
|
|
LIST_INSERT_HEAD(&extra_open, nop, nfso_list);
|
|
}
|
|
}
|
|
dp = ndp;
|
|
}
|
|
|
|
/*
|
|
* Now, get rid of extra Opens and Delegations.
|
|
*/
|
|
LIST_FOREACH_SAFE(op, &extra_open, nfso_list, nop) {
|
|
do {
|
|
newnfs_copycred(&op->nfso_cred, tcred);
|
|
error = nfscl_tryclose(op, tcred, nmp, p);
|
|
if (error == NFSERR_GRACE)
|
|
(void) nfs_catnap(PZERO, error, "nfsexcls");
|
|
} while (error == NFSERR_GRACE);
|
|
LIST_REMOVE(op, nfso_list);
|
|
FREE((caddr_t)op, M_NFSCLOPEN);
|
|
}
|
|
if (nowp != NULL)
|
|
FREE((caddr_t)nowp, M_NFSCLOWNER);
|
|
|
|
TAILQ_FOREACH_SAFE(dp, &extra_deleg, nfsdl_list, ndp) {
|
|
do {
|
|
newnfs_copycred(&dp->nfsdl_cred, tcred);
|
|
error = nfscl_trydelegreturn(dp, tcred, nmp, p);
|
|
if (error == NFSERR_GRACE)
|
|
(void) nfs_catnap(PZERO, error, "nfsexdlg");
|
|
} while (error == NFSERR_GRACE);
|
|
TAILQ_REMOVE(&extra_deleg, dp, nfsdl_list);
|
|
FREE((caddr_t)dp, M_NFSCLDELEG);
|
|
}
|
|
|
|
/* For NFSv4.1 or later, do a RECLAIM_COMPLETE. */
|
|
if (NFSHASNFSV4N(nmp))
|
|
(void)nfsrpc_reclaimcomplete(nmp, cred, p);
|
|
|
|
NFSLOCKCLSTATE();
|
|
clp->nfsc_flags &= ~NFSCLFLAGS_RECVRINPROG;
|
|
wakeup(&clp->nfsc_flags);
|
|
nfsv4_unlock(&clp->nfsc_lock, 0);
|
|
NFSUNLOCKCLSTATE();
|
|
NFSFREECRED(tcred);
|
|
}
|
|
|
|
/*
|
|
* This function is called when a server replies with NFSERR_EXPIRED.
|
|
* It deletes all state for the client and does a fresh SetClientId/confirm.
|
|
* XXX Someday it should post a signal to the process(es) that hold the
|
|
* state, so they know that lock state has been lost.
|
|
*/
|
|
APPLESTATIC int
|
|
nfscl_hasexpired(struct nfsclclient *clp, u_int32_t clidrev, NFSPROC_T *p)
|
|
{
|
|
struct nfsmount *nmp;
|
|
struct ucred *cred;
|
|
int igotlock = 0, error, trycnt;
|
|
|
|
/*
|
|
* If the clientid has gone away or a new SetClientid has already
|
|
* been done, just return ok.
|
|
*/
|
|
if (clp == NULL || clidrev != clp->nfsc_clientidrev)
|
|
return (0);
|
|
|
|
/*
|
|
* First, lock the client structure, so everyone else will
|
|
* block when trying to use state. Also, use NFSCLFLAGS_EXPIREIT so
|
|
* that only one thread does the work.
|
|
*/
|
|
NFSLOCKCLSTATE();
|
|
clp->nfsc_flags |= NFSCLFLAGS_EXPIREIT;
|
|
do {
|
|
igotlock = nfsv4_lock(&clp->nfsc_lock, 1, NULL,
|
|
NFSCLSTATEMUTEXPTR, NULL);
|
|
} while (!igotlock && (clp->nfsc_flags & NFSCLFLAGS_EXPIREIT));
|
|
if ((clp->nfsc_flags & NFSCLFLAGS_EXPIREIT) == 0) {
|
|
if (igotlock)
|
|
nfsv4_unlock(&clp->nfsc_lock, 0);
|
|
NFSUNLOCKCLSTATE();
|
|
return (0);
|
|
}
|
|
clp->nfsc_flags |= NFSCLFLAGS_RECVRINPROG;
|
|
NFSUNLOCKCLSTATE();
|
|
|
|
nmp = clp->nfsc_nmp;
|
|
if (nmp == NULL)
|
|
panic("nfscl expired");
|
|
cred = newnfs_getcred();
|
|
trycnt = 5;
|
|
do {
|
|
error = nfsrpc_setclient(nmp, clp, 0, cred, p);
|
|
} while ((error == NFSERR_STALECLIENTID ||
|
|
error == NFSERR_BADSESSION ||
|
|
error == NFSERR_STALEDONTRECOVER) && --trycnt > 0);
|
|
if (error) {
|
|
/*
|
|
* Clear out any state.
|
|
*/
|
|
nfscl_cleanclient(clp);
|
|
NFSLOCKCLSTATE();
|
|
clp->nfsc_flags &= ~(NFSCLFLAGS_HASCLIENTID |
|
|
NFSCLFLAGS_RECOVER);
|
|
} else {
|
|
/*
|
|
* Expire the state for the client.
|
|
*/
|
|
nfscl_expireclient(clp, nmp, cred, p);
|
|
NFSLOCKCLSTATE();
|
|
clp->nfsc_flags |= NFSCLFLAGS_HASCLIENTID;
|
|
clp->nfsc_flags &= ~NFSCLFLAGS_RECOVER;
|
|
}
|
|
clp->nfsc_flags &= ~(NFSCLFLAGS_EXPIREIT | NFSCLFLAGS_RECVRINPROG);
|
|
wakeup(&clp->nfsc_flags);
|
|
nfsv4_unlock(&clp->nfsc_lock, 0);
|
|
NFSUNLOCKCLSTATE();
|
|
NFSFREECRED(cred);
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* This function inserts a lock in the list after insert_lop.
|
|
*/
|
|
static void
|
|
nfscl_insertlock(struct nfscllockowner *lp, struct nfscllock *new_lop,
|
|
struct nfscllock *insert_lop, int local)
|
|
{
|
|
|
|
if ((struct nfscllockowner *)insert_lop == lp)
|
|
LIST_INSERT_HEAD(&lp->nfsl_lock, new_lop, nfslo_list);
|
|
else
|
|
LIST_INSERT_AFTER(insert_lop, new_lop, nfslo_list);
|
|
if (local)
|
|
newnfsstats.cllocallocks++;
|
|
else
|
|
newnfsstats.cllocks++;
|
|
}
|
|
|
|
/*
|
|
* This function updates the locking for a lock owner and given file. It
|
|
* maintains a list of lock ranges ordered on increasing file offset that
|
|
* are NFSCLLOCK_READ or NFSCLLOCK_WRITE and non-overlapping (aka POSIX style).
|
|
* It always adds new_lop to the list and sometimes uses the one pointed
|
|
* at by other_lopp.
|
|
* Returns 1 if the locks were modified, 0 otherwise.
|
|
*/
|
|
static int
|
|
nfscl_updatelock(struct nfscllockowner *lp, struct nfscllock **new_lopp,
|
|
struct nfscllock **other_lopp, int local)
|
|
{
|
|
struct nfscllock *new_lop = *new_lopp;
|
|
struct nfscllock *lop, *tlop, *ilop;
|
|
struct nfscllock *other_lop;
|
|
int unlock = 0, modified = 0;
|
|
u_int64_t tmp;
|
|
|
|
/*
|
|
* Work down the list until the lock is merged.
|
|
*/
|
|
if (new_lop->nfslo_type == F_UNLCK)
|
|
unlock = 1;
|
|
ilop = (struct nfscllock *)lp;
|
|
lop = LIST_FIRST(&lp->nfsl_lock);
|
|
while (lop != NULL) {
|
|
/*
|
|
* Only check locks for this file that aren't before the start of
|
|
* new lock's range.
|
|
*/
|
|
if (lop->nfslo_end >= new_lop->nfslo_first) {
|
|
if (new_lop->nfslo_end < lop->nfslo_first) {
|
|
/*
|
|
* If the new lock ends before the start of the
|
|
* current lock's range, no merge, just insert
|
|
* the new lock.
|
|
*/
|
|
break;
|
|
}
|
|
if (new_lop->nfslo_type == lop->nfslo_type ||
|
|
(new_lop->nfslo_first <= lop->nfslo_first &&
|
|
new_lop->nfslo_end >= lop->nfslo_end)) {
|
|
/*
|
|
* This lock can be absorbed by the new lock/unlock.
|
|
* This happens when it covers the entire range
|
|
* of the old lock or is contiguous
|
|
* with the old lock and is of the same type or an
|
|
* unlock.
|
|
*/
|
|
if (new_lop->nfslo_type != lop->nfslo_type ||
|
|
new_lop->nfslo_first != lop->nfslo_first ||
|
|
new_lop->nfslo_end != lop->nfslo_end)
|
|
modified = 1;
|
|
if (lop->nfslo_first < new_lop->nfslo_first)
|
|
new_lop->nfslo_first = lop->nfslo_first;
|
|
if (lop->nfslo_end > new_lop->nfslo_end)
|
|
new_lop->nfslo_end = lop->nfslo_end;
|
|
tlop = lop;
|
|
lop = LIST_NEXT(lop, nfslo_list);
|
|
nfscl_freelock(tlop, local);
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* All these cases are for contiguous locks that are not the
|
|
* same type, so they can't be merged.
|
|
*/
|
|
if (new_lop->nfslo_first <= lop->nfslo_first) {
|
|
/*
|
|
* This case is where the new lock overlaps with the
|
|
* first part of the old lock. Move the start of the
|
|
* old lock to just past the end of the new lock. The
|
|
* new lock will be inserted in front of the old, since
|
|
* ilop hasn't been updated. (We are done now.)
|
|
*/
|
|
if (lop->nfslo_first != new_lop->nfslo_end) {
|
|
lop->nfslo_first = new_lop->nfslo_end;
|
|
modified = 1;
|
|
}
|
|
break;
|
|
}
|
|
if (new_lop->nfslo_end >= lop->nfslo_end) {
|
|
/*
|
|
* This case is where the new lock overlaps with the
|
|
* end of the old lock's range. Move the old lock's
|
|
* end to just before the new lock's first and insert
|
|
* the new lock after the old lock.
|
|
* Might not be done yet, since the new lock could
|
|
* overlap further locks with higher ranges.
|
|
*/
|
|
if (lop->nfslo_end != new_lop->nfslo_first) {
|
|
lop->nfslo_end = new_lop->nfslo_first;
|
|
modified = 1;
|
|
}
|
|
ilop = lop;
|
|
lop = LIST_NEXT(lop, nfslo_list);
|
|
continue;
|
|
}
|
|
/*
|
|
* The final case is where the new lock's range is in the
|
|
* middle of the current lock's and splits the current lock
|
|
* up. Use *other_lopp to handle the second part of the
|
|
* split old lock range. (We are done now.)
|
|
* For unlock, we use new_lop as other_lop and tmp, since
|
|
* other_lop and new_lop are the same for this case.
|
|
* We noted the unlock case above, so we don't need
|
|
* new_lop->nfslo_type any longer.
|
|
*/
|
|
tmp = new_lop->nfslo_first;
|
|
if (unlock) {
|
|
other_lop = new_lop;
|
|
*new_lopp = NULL;
|
|
} else {
|
|
other_lop = *other_lopp;
|
|
*other_lopp = NULL;
|
|
}
|
|
other_lop->nfslo_first = new_lop->nfslo_end;
|
|
other_lop->nfslo_end = lop->nfslo_end;
|
|
other_lop->nfslo_type = lop->nfslo_type;
|
|
lop->nfslo_end = tmp;
|
|
nfscl_insertlock(lp, other_lop, lop, local);
|
|
ilop = lop;
|
|
modified = 1;
|
|
break;
|
|
}
|
|
ilop = lop;
|
|
lop = LIST_NEXT(lop, nfslo_list);
|
|
if (lop == NULL)
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Insert the new lock in the list at the appropriate place.
|
|
*/
|
|
if (!unlock) {
|
|
nfscl_insertlock(lp, new_lop, ilop, local);
|
|
*new_lopp = NULL;
|
|
modified = 1;
|
|
}
|
|
return (modified);
|
|
}
|
|
|
|
/*
|
|
* This function must be run as a kernel thread.
|
|
* It does Renew Ops and recovery, when required.
|
|
*/
|
|
APPLESTATIC void
|
|
nfscl_renewthread(struct nfsclclient *clp, NFSPROC_T *p)
|
|
{
|
|
struct nfsclowner *owp, *nowp;
|
|
struct nfsclopen *op;
|
|
struct nfscllockowner *lp, *nlp;
|
|
struct nfscldeleghead dh;
|
|
struct nfscldeleg *dp, *ndp;
|
|
struct ucred *cred;
|
|
u_int32_t clidrev;
|
|
int error, cbpathdown, islept, igotlock, ret, clearok;
|
|
uint32_t recover_done_time = 0;
|
|
time_t mytime;
|
|
static time_t prevsec = 0;
|
|
struct nfscllockownerfh *lfhp, *nlfhp;
|
|
struct nfscllockownerfhhead lfh;
|
|
struct nfscllayout *lyp, *nlyp;
|
|
struct nfscldevinfo *dip, *ndip;
|
|
struct nfscllayouthead rlh;
|
|
struct nfsclrecalllayout *recallp;
|
|
struct nfsclds *dsp;
|
|
|
|
cred = newnfs_getcred();
|
|
NFSLOCKCLSTATE();
|
|
clp->nfsc_flags |= NFSCLFLAGS_HASTHREAD;
|
|
NFSUNLOCKCLSTATE();
|
|
for(;;) {
|
|
newnfs_setroot(cred);
|
|
cbpathdown = 0;
|
|
if (clp->nfsc_flags & NFSCLFLAGS_RECOVER) {
|
|
/*
|
|
* Only allow one recover within 1/2 of the lease
|
|
* duration (nfsc_renew).
|
|
*/
|
|
if (recover_done_time < NFSD_MONOSEC) {
|
|
recover_done_time = NFSD_MONOSEC +
|
|
clp->nfsc_renew;
|
|
nfscl_recover(clp, cred, p);
|
|
} else {
|
|
NFSLOCKCLSTATE();
|
|
clp->nfsc_flags &= ~NFSCLFLAGS_RECOVER;
|
|
NFSUNLOCKCLSTATE();
|
|
}
|
|
}
|
|
if (clp->nfsc_expire <= NFSD_MONOSEC &&
|
|
(clp->nfsc_flags & NFSCLFLAGS_HASCLIENTID)) {
|
|
clp->nfsc_expire = NFSD_MONOSEC + clp->nfsc_renew;
|
|
clidrev = clp->nfsc_clientidrev;
|
|
error = nfsrpc_renew(clp,
|
|
TAILQ_FIRST(&clp->nfsc_nmp->nm_sess), cred, p);
|
|
if (error == NFSERR_CBPATHDOWN)
|
|
cbpathdown = 1;
|
|
else if (error == NFSERR_STALECLIENTID ||
|
|
error == NFSERR_BADSESSION) {
|
|
NFSLOCKCLSTATE();
|
|
clp->nfsc_flags |= NFSCLFLAGS_RECOVER;
|
|
NFSUNLOCKCLSTATE();
|
|
} else if (error == NFSERR_EXPIRED)
|
|
(void) nfscl_hasexpired(clp, clidrev, p);
|
|
}
|
|
|
|
/* Do renews for any DS sessions. */
|
|
checkdsrenew:
|
|
NFSLOCKMNT(clp->nfsc_nmp);
|
|
/* Skip first entry, since the MDS is handled above. */
|
|
dsp = TAILQ_FIRST(&clp->nfsc_nmp->nm_sess);
|
|
if (dsp != NULL)
|
|
dsp = TAILQ_NEXT(dsp, nfsclds_list);
|
|
while (dsp != NULL) {
|
|
if (dsp->nfsclds_expire <= NFSD_MONOSEC) {
|
|
dsp->nfsclds_expire = NFSD_MONOSEC +
|
|
clp->nfsc_renew;
|
|
NFSUNLOCKMNT(clp->nfsc_nmp);
|
|
(void)nfsrpc_renew(clp, dsp, cred, p);
|
|
goto checkdsrenew;
|
|
}
|
|
dsp = TAILQ_NEXT(dsp, nfsclds_list);
|
|
}
|
|
NFSUNLOCKMNT(clp->nfsc_nmp);
|
|
|
|
TAILQ_INIT(&dh);
|
|
NFSLOCKCLSTATE();
|
|
if (cbpathdown)
|
|
/* It's a Total Recall! */
|
|
nfscl_totalrecall(clp);
|
|
|
|
/*
|
|
* Now, handle defunct owners.
|
|
*/
|
|
LIST_FOREACH_SAFE(owp, &clp->nfsc_owner, nfsow_list, nowp) {
|
|
if (LIST_EMPTY(&owp->nfsow_open)) {
|
|
if (owp->nfsow_defunct != 0)
|
|
nfscl_freeopenowner(owp, 0);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Do the recall on any delegations. To avoid trouble, always
|
|
* come back up here after having slept.
|
|
*/
|
|
igotlock = 0;
|
|
tryagain:
|
|
dp = TAILQ_FIRST(&clp->nfsc_deleg);
|
|
while (dp != NULL) {
|
|
ndp = TAILQ_NEXT(dp, nfsdl_list);
|
|
if ((dp->nfsdl_flags & NFSCLDL_RECALL)) {
|
|
/*
|
|
* Wait for outstanding I/O ops to be done.
|
|
*/
|
|
if (dp->nfsdl_rwlock.nfslock_usecnt > 0) {
|
|
if (igotlock) {
|
|
nfsv4_unlock(&clp->nfsc_lock, 0);
|
|
igotlock = 0;
|
|
}
|
|
dp->nfsdl_rwlock.nfslock_lock |=
|
|
NFSV4LOCK_WANTED;
|
|
(void) nfsmsleep(&dp->nfsdl_rwlock,
|
|
NFSCLSTATEMUTEXPTR, PZERO, "nfscld",
|
|
NULL);
|
|
goto tryagain;
|
|
}
|
|
while (!igotlock) {
|
|
igotlock = nfsv4_lock(&clp->nfsc_lock, 1,
|
|
&islept, NFSCLSTATEMUTEXPTR, NULL);
|
|
if (islept)
|
|
goto tryagain;
|
|
}
|
|
NFSUNLOCKCLSTATE();
|
|
newnfs_copycred(&dp->nfsdl_cred, cred);
|
|
ret = nfscl_recalldeleg(clp, clp->nfsc_nmp, dp,
|
|
NULL, cred, p, 1);
|
|
if (!ret) {
|
|
nfscl_cleandeleg(dp);
|
|
TAILQ_REMOVE(&clp->nfsc_deleg, dp,
|
|
nfsdl_list);
|
|
LIST_REMOVE(dp, nfsdl_hash);
|
|
TAILQ_INSERT_HEAD(&dh, dp, nfsdl_list);
|
|
nfscl_delegcnt--;
|
|
newnfsstats.cldelegates--;
|
|
}
|
|
NFSLOCKCLSTATE();
|
|
}
|
|
dp = ndp;
|
|
}
|
|
|
|
/*
|
|
* Clear out old delegations, if we are above the high water
|
|
* mark. Only clear out ones with no state related to them.
|
|
* The tailq list is in LRU order.
|
|
*/
|
|
dp = TAILQ_LAST(&clp->nfsc_deleg, nfscldeleghead);
|
|
while (nfscl_delegcnt > nfscl_deleghighwater && dp != NULL) {
|
|
ndp = TAILQ_PREV(dp, nfscldeleghead, nfsdl_list);
|
|
if (dp->nfsdl_rwlock.nfslock_usecnt == 0 &&
|
|
dp->nfsdl_rwlock.nfslock_lock == 0 &&
|
|
dp->nfsdl_timestamp < NFSD_MONOSEC &&
|
|
(dp->nfsdl_flags & (NFSCLDL_RECALL | NFSCLDL_ZAPPED |
|
|
NFSCLDL_NEEDRECLAIM | NFSCLDL_DELEGRET)) == 0) {
|
|
clearok = 1;
|
|
LIST_FOREACH(owp, &dp->nfsdl_owner, nfsow_list) {
|
|
op = LIST_FIRST(&owp->nfsow_open);
|
|
if (op != NULL) {
|
|
clearok = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (clearok) {
|
|
LIST_FOREACH(lp, &dp->nfsdl_lock, nfsl_list) {
|
|
if (!LIST_EMPTY(&lp->nfsl_lock)) {
|
|
clearok = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (clearok) {
|
|
TAILQ_REMOVE(&clp->nfsc_deleg, dp, nfsdl_list);
|
|
LIST_REMOVE(dp, nfsdl_hash);
|
|
TAILQ_INSERT_HEAD(&dh, dp, nfsdl_list);
|
|
nfscl_delegcnt--;
|
|
newnfsstats.cldelegates--;
|
|
}
|
|
}
|
|
dp = ndp;
|
|
}
|
|
if (igotlock)
|
|
nfsv4_unlock(&clp->nfsc_lock, 0);
|
|
|
|
/*
|
|
* Do the recall on any layouts. To avoid trouble, always
|
|
* come back up here after having slept.
|
|
*/
|
|
TAILQ_INIT(&rlh);
|
|
tryagain2:
|
|
TAILQ_FOREACH_SAFE(lyp, &clp->nfsc_layout, nfsly_list, nlyp) {
|
|
if ((lyp->nfsly_flags & NFSLY_RECALL) != 0) {
|
|
/*
|
|
* Wait for outstanding I/O ops to be done.
|
|
*/
|
|
if (lyp->nfsly_lock.nfslock_usecnt > 0 ||
|
|
(lyp->nfsly_lock.nfslock_lock &
|
|
NFSV4LOCK_LOCK) != 0) {
|
|
lyp->nfsly_lock.nfslock_lock |=
|
|
NFSV4LOCK_WANTED;
|
|
(void)nfsmsleep(&lyp->nfsly_lock,
|
|
NFSCLSTATEMUTEXPTR, PZERO, "nfslyp",
|
|
NULL);
|
|
goto tryagain2;
|
|
}
|
|
/* Move the layout to the recall list. */
|
|
TAILQ_REMOVE(&clp->nfsc_layout, lyp,
|
|
nfsly_list);
|
|
LIST_REMOVE(lyp, nfsly_hash);
|
|
TAILQ_INSERT_HEAD(&rlh, lyp, nfsly_list);
|
|
|
|
/* Handle any layout commits. */
|
|
if (!NFSHASNOLAYOUTCOMMIT(clp->nfsc_nmp) &&
|
|
(lyp->nfsly_flags & NFSLY_WRITTEN) != 0) {
|
|
lyp->nfsly_flags &= ~NFSLY_WRITTEN;
|
|
NFSUNLOCKCLSTATE();
|
|
NFSCL_DEBUG(3, "do layoutcommit\n");
|
|
nfscl_dolayoutcommit(clp->nfsc_nmp, lyp,
|
|
cred, p);
|
|
NFSLOCKCLSTATE();
|
|
goto tryagain2;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Now, look for stale layouts. */
|
|
lyp = TAILQ_LAST(&clp->nfsc_layout, nfscllayouthead);
|
|
while (lyp != NULL) {
|
|
nlyp = TAILQ_PREV(lyp, nfscllayouthead, nfsly_list);
|
|
if (lyp->nfsly_timestamp < NFSD_MONOSEC &&
|
|
(lyp->nfsly_flags & NFSLY_RECALL) == 0 &&
|
|
lyp->nfsly_lock.nfslock_usecnt == 0 &&
|
|
lyp->nfsly_lock.nfslock_lock == 0) {
|
|
NFSCL_DEBUG(4, "ret stale lay=%d\n",
|
|
nfscl_layoutcnt);
|
|
recallp = malloc(sizeof(*recallp),
|
|
M_NFSLAYRECALL, M_NOWAIT);
|
|
if (recallp == NULL)
|
|
break;
|
|
(void)nfscl_layoutrecall(NFSLAYOUTRETURN_FILE,
|
|
lyp, NFSLAYOUTIOMODE_ANY, 0, UINT64_MAX,
|
|
lyp->nfsly_stateid.seqid, recallp);
|
|
}
|
|
lyp = nlyp;
|
|
}
|
|
|
|
/*
|
|
* Free up any unreferenced device info structures.
|
|
*/
|
|
LIST_FOREACH_SAFE(dip, &clp->nfsc_devinfo, nfsdi_list, ndip) {
|
|
if (dip->nfsdi_layoutrefs == 0 &&
|
|
dip->nfsdi_refcnt == 0) {
|
|
NFSCL_DEBUG(4, "freeing devinfo\n");
|
|
LIST_REMOVE(dip, nfsdi_list);
|
|
nfscl_freedevinfo(dip);
|
|
}
|
|
}
|
|
NFSUNLOCKCLSTATE();
|
|
|
|
/* Do layout return(s), as required. */
|
|
TAILQ_FOREACH_SAFE(lyp, &rlh, nfsly_list, nlyp) {
|
|
TAILQ_REMOVE(&rlh, lyp, nfsly_list);
|
|
NFSCL_DEBUG(4, "ret layout\n");
|
|
nfscl_layoutreturn(clp->nfsc_nmp, lyp, cred, p);
|
|
nfscl_freelayout(lyp);
|
|
}
|
|
|
|
/*
|
|
* Delegreturn any delegations cleaned out or recalled.
|
|
*/
|
|
TAILQ_FOREACH_SAFE(dp, &dh, nfsdl_list, ndp) {
|
|
newnfs_copycred(&dp->nfsdl_cred, cred);
|
|
(void) nfscl_trydelegreturn(dp, cred, clp->nfsc_nmp, p);
|
|
TAILQ_REMOVE(&dh, dp, nfsdl_list);
|
|
FREE((caddr_t)dp, M_NFSCLDELEG);
|
|
}
|
|
|
|
SLIST_INIT(&lfh);
|
|
/*
|
|
* Call nfscl_cleanupkext() once per second to check for
|
|
* open/lock owners where the process has exited.
|
|
*/
|
|
mytime = NFSD_MONOSEC;
|
|
if (prevsec != mytime) {
|
|
prevsec = mytime;
|
|
nfscl_cleanupkext(clp, &lfh);
|
|
}
|
|
|
|
/*
|
|
* Do a ReleaseLockOwner for all lock owners where the
|
|
* associated process no longer exists, as found by
|
|
* nfscl_cleanupkext().
|
|
*/
|
|
newnfs_setroot(cred);
|
|
SLIST_FOREACH_SAFE(lfhp, &lfh, nfslfh_list, nlfhp) {
|
|
LIST_FOREACH_SAFE(lp, &lfhp->nfslfh_lock, nfsl_list,
|
|
nlp) {
|
|
(void)nfsrpc_rellockown(clp->nfsc_nmp, lp,
|
|
lfhp->nfslfh_fh, lfhp->nfslfh_len, cred,
|
|
p);
|
|
nfscl_freelockowner(lp, 0);
|
|
}
|
|
free(lfhp, M_TEMP);
|
|
}
|
|
SLIST_INIT(&lfh);
|
|
|
|
NFSLOCKCLSTATE();
|
|
if ((clp->nfsc_flags & NFSCLFLAGS_RECOVER) == 0)
|
|
(void)mtx_sleep(clp, NFSCLSTATEMUTEXPTR, PWAIT, "nfscl",
|
|
hz);
|
|
if (clp->nfsc_flags & NFSCLFLAGS_UMOUNT) {
|
|
clp->nfsc_flags &= ~NFSCLFLAGS_HASTHREAD;
|
|
NFSUNLOCKCLSTATE();
|
|
NFSFREECRED(cred);
|
|
wakeup((caddr_t)clp);
|
|
return;
|
|
}
|
|
NFSUNLOCKCLSTATE();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Initiate state recovery. Called when NFSERR_STALECLIENTID,
|
|
* NFSERR_STALESTATEID or NFSERR_BADSESSION is received.
|
|
*/
|
|
APPLESTATIC void
|
|
nfscl_initiate_recovery(struct nfsclclient *clp)
|
|
{
|
|
|
|
if (clp == NULL)
|
|
return;
|
|
NFSLOCKCLSTATE();
|
|
clp->nfsc_flags |= NFSCLFLAGS_RECOVER;
|
|
NFSUNLOCKCLSTATE();
|
|
wakeup((caddr_t)clp);
|
|
}
|
|
|
|
/*
|
|
* Dump out the state stuff for debugging.
|
|
*/
|
|
APPLESTATIC void
|
|
nfscl_dumpstate(struct nfsmount *nmp, int openowner, int opens,
|
|
int lockowner, int locks)
|
|
{
|
|
struct nfsclclient *clp;
|
|
struct nfsclowner *owp;
|
|
struct nfsclopen *op;
|
|
struct nfscllockowner *lp;
|
|
struct nfscllock *lop;
|
|
struct nfscldeleg *dp;
|
|
|
|
clp = nmp->nm_clp;
|
|
if (clp == NULL) {
|
|
printf("nfscl dumpstate NULL clp\n");
|
|
return;
|
|
}
|
|
NFSLOCKCLSTATE();
|
|
TAILQ_FOREACH(dp, &clp->nfsc_deleg, nfsdl_list) {
|
|
LIST_FOREACH(owp, &dp->nfsdl_owner, nfsow_list) {
|
|
if (openowner && !LIST_EMPTY(&owp->nfsow_open))
|
|
printf("owner=0x%x 0x%x 0x%x 0x%x seqid=%d\n",
|
|
owp->nfsow_owner[0], owp->nfsow_owner[1],
|
|
owp->nfsow_owner[2], owp->nfsow_owner[3],
|
|
owp->nfsow_seqid);
|
|
LIST_FOREACH(op, &owp->nfsow_open, nfso_list) {
|
|
if (opens)
|
|
printf("open st=0x%x 0x%x 0x%x cnt=%d fh12=0x%x\n",
|
|
op->nfso_stateid.other[0], op->nfso_stateid.other[1],
|
|
op->nfso_stateid.other[2], op->nfso_opencnt,
|
|
op->nfso_fh[12]);
|
|
LIST_FOREACH(lp, &op->nfso_lock, nfsl_list) {
|
|
if (lockowner)
|
|
printf("lckown=0x%x 0x%x 0x%x 0x%x seqid=%d st=0x%x 0x%x 0x%x\n",
|
|
lp->nfsl_owner[0], lp->nfsl_owner[1],
|
|
lp->nfsl_owner[2], lp->nfsl_owner[3],
|
|
lp->nfsl_seqid,
|
|
lp->nfsl_stateid.other[0], lp->nfsl_stateid.other[1],
|
|
lp->nfsl_stateid.other[2]);
|
|
LIST_FOREACH(lop, &lp->nfsl_lock, nfslo_list) {
|
|
if (locks)
|
|
#ifdef __FreeBSD__
|
|
printf("lck typ=%d fst=%ju end=%ju\n",
|
|
lop->nfslo_type, (intmax_t)lop->nfslo_first,
|
|
(intmax_t)lop->nfslo_end);
|
|
#else
|
|
printf("lck typ=%d fst=%qd end=%qd\n",
|
|
lop->nfslo_type, lop->nfslo_first,
|
|
lop->nfslo_end);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
|
|
if (openowner && !LIST_EMPTY(&owp->nfsow_open))
|
|
printf("owner=0x%x 0x%x 0x%x 0x%x seqid=%d\n",
|
|
owp->nfsow_owner[0], owp->nfsow_owner[1],
|
|
owp->nfsow_owner[2], owp->nfsow_owner[3],
|
|
owp->nfsow_seqid);
|
|
LIST_FOREACH(op, &owp->nfsow_open, nfso_list) {
|
|
if (opens)
|
|
printf("open st=0x%x 0x%x 0x%x cnt=%d fh12=0x%x\n",
|
|
op->nfso_stateid.other[0], op->nfso_stateid.other[1],
|
|
op->nfso_stateid.other[2], op->nfso_opencnt,
|
|
op->nfso_fh[12]);
|
|
LIST_FOREACH(lp, &op->nfso_lock, nfsl_list) {
|
|
if (lockowner)
|
|
printf("lckown=0x%x 0x%x 0x%x 0x%x seqid=%d st=0x%x 0x%x 0x%x\n",
|
|
lp->nfsl_owner[0], lp->nfsl_owner[1],
|
|
lp->nfsl_owner[2], lp->nfsl_owner[3],
|
|
lp->nfsl_seqid,
|
|
lp->nfsl_stateid.other[0], lp->nfsl_stateid.other[1],
|
|
lp->nfsl_stateid.other[2]);
|
|
LIST_FOREACH(lop, &lp->nfsl_lock, nfslo_list) {
|
|
if (locks)
|
|
#ifdef __FreeBSD__
|
|
printf("lck typ=%d fst=%ju end=%ju\n",
|
|
lop->nfslo_type, (intmax_t)lop->nfslo_first,
|
|
(intmax_t)lop->nfslo_end);
|
|
#else
|
|
printf("lck typ=%d fst=%qd end=%qd\n",
|
|
lop->nfslo_type, lop->nfslo_first,
|
|
lop->nfslo_end);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
NFSUNLOCKCLSTATE();
|
|
}
|
|
|
|
/*
|
|
* Check for duplicate open owners and opens.
|
|
* (Only used as a diagnostic aid.)
|
|
*/
|
|
APPLESTATIC void
|
|
nfscl_dupopen(vnode_t vp, int dupopens)
|
|
{
|
|
struct nfsclclient *clp;
|
|
struct nfsclowner *owp, *owp2;
|
|
struct nfsclopen *op, *op2;
|
|
struct nfsfh *nfhp;
|
|
|
|
clp = VFSTONFS(vnode_mount(vp))->nm_clp;
|
|
if (clp == NULL) {
|
|
printf("nfscl dupopen NULL clp\n");
|
|
return;
|
|
}
|
|
nfhp = VTONFS(vp)->n_fhp;
|
|
NFSLOCKCLSTATE();
|
|
|
|
/*
|
|
* First, search for duplicate owners.
|
|
* These should never happen!
|
|
*/
|
|
LIST_FOREACH(owp2, &clp->nfsc_owner, nfsow_list) {
|
|
LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
|
|
if (owp != owp2 &&
|
|
!NFSBCMP(owp->nfsow_owner, owp2->nfsow_owner,
|
|
NFSV4CL_LOCKNAMELEN)) {
|
|
NFSUNLOCKCLSTATE();
|
|
printf("DUP OWNER\n");
|
|
nfscl_dumpstate(VFSTONFS(vnode_mount(vp)), 1, 1, 0, 0);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Now, search for duplicate stateids.
|
|
* These shouldn't happen, either.
|
|
*/
|
|
LIST_FOREACH(owp2, &clp->nfsc_owner, nfsow_list) {
|
|
LIST_FOREACH(op2, &owp2->nfsow_open, nfso_list) {
|
|
LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
|
|
LIST_FOREACH(op, &owp->nfsow_open, nfso_list) {
|
|
if (op != op2 &&
|
|
(op->nfso_stateid.other[0] != 0 ||
|
|
op->nfso_stateid.other[1] != 0 ||
|
|
op->nfso_stateid.other[2] != 0) &&
|
|
op->nfso_stateid.other[0] == op2->nfso_stateid.other[0] &&
|
|
op->nfso_stateid.other[1] == op2->nfso_stateid.other[1] &&
|
|
op->nfso_stateid.other[2] == op2->nfso_stateid.other[2]) {
|
|
NFSUNLOCKCLSTATE();
|
|
printf("DUP STATEID\n");
|
|
nfscl_dumpstate(VFSTONFS(vnode_mount(vp)), 1, 1, 0,
|
|
0);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Now search for duplicate opens.
|
|
* Duplicate opens for the same owner
|
|
* should never occur. Other duplicates are
|
|
* possible and are checked for if "dupopens"
|
|
* is true.
|
|
*/
|
|
LIST_FOREACH(owp2, &clp->nfsc_owner, nfsow_list) {
|
|
LIST_FOREACH(op2, &owp2->nfsow_open, nfso_list) {
|
|
if (nfhp->nfh_len == op2->nfso_fhlen &&
|
|
!NFSBCMP(nfhp->nfh_fh, op2->nfso_fh, nfhp->nfh_len)) {
|
|
LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
|
|
LIST_FOREACH(op, &owp->nfsow_open, nfso_list) {
|
|
if (op != op2 && nfhp->nfh_len == op->nfso_fhlen &&
|
|
!NFSBCMP(nfhp->nfh_fh, op->nfso_fh, nfhp->nfh_len) &&
|
|
(!NFSBCMP(op->nfso_own->nfsow_owner,
|
|
op2->nfso_own->nfsow_owner, NFSV4CL_LOCKNAMELEN) ||
|
|
dupopens)) {
|
|
if (!NFSBCMP(op->nfso_own->nfsow_owner,
|
|
op2->nfso_own->nfsow_owner, NFSV4CL_LOCKNAMELEN)) {
|
|
NFSUNLOCKCLSTATE();
|
|
printf("BADDUP OPEN\n");
|
|
} else {
|
|
NFSUNLOCKCLSTATE();
|
|
printf("DUP OPEN\n");
|
|
}
|
|
nfscl_dumpstate(VFSTONFS(vnode_mount(vp)), 1, 1,
|
|
0, 0);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
NFSUNLOCKCLSTATE();
|
|
}
|
|
|
|
/*
|
|
* During close, find an open that needs to be dereferenced and
|
|
* dereference it. If there are no more opens for this file,
|
|
* log a message to that effect.
|
|
* Opens aren't actually Close'd until VOP_INACTIVE() is performed
|
|
* on the file's vnode.
|
|
* This is the safe way, since it is difficult to identify
|
|
* which open the close is for and I/O can be performed after the
|
|
* close(2) system call when a file is mmap'd.
|
|
* If it returns 0 for success, there will be a referenced
|
|
* clp returned via clpp.
|
|
*/
|
|
APPLESTATIC int
|
|
nfscl_getclose(vnode_t vp, struct nfsclclient **clpp)
|
|
{
|
|
struct nfsclclient *clp;
|
|
struct nfsclowner *owp;
|
|
struct nfsclopen *op;
|
|
struct nfscldeleg *dp;
|
|
struct nfsfh *nfhp;
|
|
int error, notdecr;
|
|
|
|
error = nfscl_getcl(vnode_mount(vp), NULL, NULL, 1, &clp);
|
|
if (error)
|
|
return (error);
|
|
*clpp = clp;
|
|
|
|
nfhp = VTONFS(vp)->n_fhp;
|
|
notdecr = 1;
|
|
NFSLOCKCLSTATE();
|
|
/*
|
|
* First, look for one under a delegation that was locally issued
|
|
* and just decrement the opencnt for it. Since all my Opens against
|
|
* the server are DENY_NONE, I don't see a problem with hanging
|
|
* onto them. (It is much easier to use one of the extant Opens
|
|
* that I already have on the server when a Delegation is recalled
|
|
* than to do fresh Opens.) Someday, I might need to rethink this, but.
|
|
*/
|
|
dp = nfscl_finddeleg(clp, nfhp->nfh_fh, nfhp->nfh_len);
|
|
if (dp != NULL) {
|
|
LIST_FOREACH(owp, &dp->nfsdl_owner, nfsow_list) {
|
|
op = LIST_FIRST(&owp->nfsow_open);
|
|
if (op != NULL) {
|
|
/*
|
|
* Since a delegation is for a file, there
|
|
* should never be more than one open for
|
|
* each openowner.
|
|
*/
|
|
if (LIST_NEXT(op, nfso_list) != NULL)
|
|
panic("nfscdeleg opens");
|
|
if (notdecr && op->nfso_opencnt > 0) {
|
|
notdecr = 0;
|
|
op->nfso_opencnt--;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Now process the opens against the server. */
|
|
LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
|
|
LIST_FOREACH(op, &owp->nfsow_open, nfso_list) {
|
|
if (op->nfso_fhlen == nfhp->nfh_len &&
|
|
!NFSBCMP(op->nfso_fh, nfhp->nfh_fh,
|
|
nfhp->nfh_len)) {
|
|
/* Found an open, decrement cnt if possible */
|
|
if (notdecr && op->nfso_opencnt > 0) {
|
|
notdecr = 0;
|
|
op->nfso_opencnt--;
|
|
}
|
|
/*
|
|
* There are more opens, so just return.
|
|
*/
|
|
if (op->nfso_opencnt > 0) {
|
|
NFSUNLOCKCLSTATE();
|
|
return (0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
NFSUNLOCKCLSTATE();
|
|
if (notdecr)
|
|
printf("nfscl: never fnd open\n");
|
|
return (0);
|
|
}
|
|
|
|
APPLESTATIC int
|
|
nfscl_doclose(vnode_t vp, struct nfsclclient **clpp, NFSPROC_T *p)
|
|
{
|
|
struct nfsclclient *clp;
|
|
struct nfsclowner *owp, *nowp;
|
|
struct nfsclopen *op;
|
|
struct nfscldeleg *dp;
|
|
struct nfsfh *nfhp;
|
|
int error;
|
|
|
|
error = nfscl_getcl(vnode_mount(vp), NULL, NULL, 1, &clp);
|
|
if (error)
|
|
return (error);
|
|
*clpp = clp;
|
|
|
|
nfhp = VTONFS(vp)->n_fhp;
|
|
NFSLOCKCLSTATE();
|
|
/*
|
|
* First get rid of the local Open structures, which should be no
|
|
* longer in use.
|
|
*/
|
|
dp = nfscl_finddeleg(clp, nfhp->nfh_fh, nfhp->nfh_len);
|
|
if (dp != NULL) {
|
|
LIST_FOREACH_SAFE(owp, &dp->nfsdl_owner, nfsow_list, nowp) {
|
|
op = LIST_FIRST(&owp->nfsow_open);
|
|
if (op != NULL) {
|
|
KASSERT((op->nfso_opencnt == 0),
|
|
("nfscl: bad open cnt on deleg"));
|
|
nfscl_freeopen(op, 1);
|
|
}
|
|
nfscl_freeopenowner(owp, 1);
|
|
}
|
|
}
|
|
|
|
/* Return any layouts marked return on close. */
|
|
nfscl_retoncloselayout(clp, nfhp->nfh_fh, nfhp->nfh_len);
|
|
|
|
/* Now process the opens against the server. */
|
|
lookformore:
|
|
LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
|
|
op = LIST_FIRST(&owp->nfsow_open);
|
|
while (op != NULL) {
|
|
if (op->nfso_fhlen == nfhp->nfh_len &&
|
|
!NFSBCMP(op->nfso_fh, nfhp->nfh_fh,
|
|
nfhp->nfh_len)) {
|
|
/* Found an open, close it. */
|
|
KASSERT((op->nfso_opencnt == 0),
|
|
("nfscl: bad open cnt on server"));
|
|
NFSUNLOCKCLSTATE();
|
|
nfsrpc_doclose(VFSTONFS(vnode_mount(vp)), op,
|
|
p);
|
|
NFSLOCKCLSTATE();
|
|
goto lookformore;
|
|
}
|
|
op = LIST_NEXT(op, nfso_list);
|
|
}
|
|
}
|
|
NFSUNLOCKCLSTATE();
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Return all delegations on this client.
|
|
* (Must be called with client sleep lock.)
|
|
*/
|
|
static void
|
|
nfscl_delegreturnall(struct nfsclclient *clp, NFSPROC_T *p)
|
|
{
|
|
struct nfscldeleg *dp, *ndp;
|
|
struct ucred *cred;
|
|
|
|
cred = newnfs_getcred();
|
|
TAILQ_FOREACH_SAFE(dp, &clp->nfsc_deleg, nfsdl_list, ndp) {
|
|
nfscl_cleandeleg(dp);
|
|
(void) nfscl_trydelegreturn(dp, cred, clp->nfsc_nmp, p);
|
|
nfscl_freedeleg(&clp->nfsc_deleg, dp);
|
|
}
|
|
NFSFREECRED(cred);
|
|
}
|
|
|
|
/*
|
|
* Do a callback RPC.
|
|
*/
|
|
APPLESTATIC void
|
|
nfscl_docb(struct nfsrv_descript *nd, NFSPROC_T *p)
|
|
{
|
|
int clist, gotseq_ok, i, j, k, op, rcalls;
|
|
u_int32_t *tl;
|
|
struct nfsclclient *clp;
|
|
struct nfscldeleg *dp = NULL;
|
|
int numops, taglen = -1, error = 0, trunc;
|
|
u_int32_t minorvers = 0, retops = 0, *retopsp = NULL, *repp, cbident;
|
|
u_char tag[NFSV4_SMALLSTR + 1], *tagstr;
|
|
vnode_t vp = NULL;
|
|
struct nfsnode *np;
|
|
struct vattr va;
|
|
struct nfsfh *nfhp;
|
|
mount_t mp;
|
|
nfsattrbit_t attrbits, rattrbits;
|
|
nfsv4stateid_t stateid;
|
|
uint32_t seqid, slotid = 0, highslot, cachethis;
|
|
uint8_t sessionid[NFSX_V4SESSIONID];
|
|
struct mbuf *rep;
|
|
struct nfscllayout *lyp;
|
|
uint64_t filesid[2], len, off;
|
|
int changed, gotone, laytype, recalltype;
|
|
uint32_t iomode;
|
|
struct nfsclrecalllayout *recallp = NULL;
|
|
|
|
gotseq_ok = 0;
|
|
nfsrvd_rephead(nd);
|
|
NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
|
|
taglen = fxdr_unsigned(int, *tl);
|
|
if (taglen < 0) {
|
|
error = EBADRPC;
|
|
goto nfsmout;
|
|
}
|
|
if (taglen <= NFSV4_SMALLSTR)
|
|
tagstr = tag;
|
|
else
|
|
tagstr = malloc(taglen + 1, M_TEMP, M_WAITOK);
|
|
error = nfsrv_mtostr(nd, tagstr, taglen);
|
|
if (error) {
|
|
if (taglen > NFSV4_SMALLSTR)
|
|
free(tagstr, M_TEMP);
|
|
taglen = -1;
|
|
goto nfsmout;
|
|
}
|
|
(void) nfsm_strtom(nd, tag, taglen);
|
|
if (taglen > NFSV4_SMALLSTR) {
|
|
free(tagstr, M_TEMP);
|
|
}
|
|
NFSM_BUILD(retopsp, u_int32_t *, NFSX_UNSIGNED);
|
|
NFSM_DISSECT(tl, u_int32_t *, 3 * NFSX_UNSIGNED);
|
|
minorvers = fxdr_unsigned(u_int32_t, *tl++);
|
|
if (minorvers != NFSV4_MINORVERSION && minorvers != NFSV41_MINORVERSION)
|
|
nd->nd_repstat = NFSERR_MINORVERMISMATCH;
|
|
cbident = fxdr_unsigned(u_int32_t, *tl++);
|
|
if (nd->nd_repstat)
|
|
numops = 0;
|
|
else
|
|
numops = fxdr_unsigned(int, *tl);
|
|
/*
|
|
* Loop around doing the sub ops.
|
|
*/
|
|
for (i = 0; i < numops; i++) {
|
|
NFSM_DISSECT(tl, u_int32_t *, NFSX_UNSIGNED);
|
|
NFSM_BUILD(repp, u_int32_t *, 2 * NFSX_UNSIGNED);
|
|
*repp++ = *tl;
|
|
op = fxdr_unsigned(int, *tl);
|
|
if (op < NFSV4OP_CBGETATTR ||
|
|
(op > NFSV4OP_CBRECALL && minorvers == NFSV4_MINORVERSION) ||
|
|
(op > NFSV4OP_CBNOTIFYDEVID &&
|
|
minorvers == NFSV41_MINORVERSION)) {
|
|
nd->nd_repstat = NFSERR_OPILLEGAL;
|
|
*repp = nfscl_errmap(nd, minorvers);
|
|
retops++;
|
|
break;
|
|
}
|
|
nd->nd_procnum = op;
|
|
if (op < NFSV4OP_CBNOPS)
|
|
newnfsstats.cbrpccnt[nd->nd_procnum]++;
|
|
switch (op) {
|
|
case NFSV4OP_CBGETATTR:
|
|
NFSCL_DEBUG(4, "cbgetattr\n");
|
|
mp = NULL;
|
|
vp = NULL;
|
|
error = nfsm_getfh(nd, &nfhp);
|
|
if (!error)
|
|
error = nfsrv_getattrbits(nd, &attrbits,
|
|
NULL, NULL);
|
|
if (error == 0 && i == 0 &&
|
|
minorvers != NFSV4_MINORVERSION)
|
|
error = NFSERR_OPNOTINSESS;
|
|
if (!error) {
|
|
mp = nfscl_getmnt(minorvers, sessionid, cbident,
|
|
&clp);
|
|
if (mp == NULL)
|
|
error = NFSERR_SERVERFAULT;
|
|
}
|
|
if (!error) {
|
|
error = nfscl_ngetreopen(mp, nfhp->nfh_fh,
|
|
nfhp->nfh_len, p, &np);
|
|
if (!error)
|
|
vp = NFSTOV(np);
|
|
}
|
|
if (!error) {
|
|
NFSZERO_ATTRBIT(&rattrbits);
|
|
NFSLOCKCLSTATE();
|
|
dp = nfscl_finddeleg(clp, nfhp->nfh_fh,
|
|
nfhp->nfh_len);
|
|
if (dp != NULL) {
|
|
if (NFSISSET_ATTRBIT(&attrbits,
|
|
NFSATTRBIT_SIZE)) {
|
|
if (vp != NULL)
|
|
va.va_size = np->n_size;
|
|
else
|
|
va.va_size =
|
|
dp->nfsdl_size;
|
|
NFSSETBIT_ATTRBIT(&rattrbits,
|
|
NFSATTRBIT_SIZE);
|
|
}
|
|
if (NFSISSET_ATTRBIT(&attrbits,
|
|
NFSATTRBIT_CHANGE)) {
|
|
va.va_filerev =
|
|
dp->nfsdl_change;
|
|
if (vp == NULL ||
|
|
(np->n_flag & NDELEGMOD))
|
|
va.va_filerev++;
|
|
NFSSETBIT_ATTRBIT(&rattrbits,
|
|
NFSATTRBIT_CHANGE);
|
|
}
|
|
} else
|
|
error = NFSERR_SERVERFAULT;
|
|
NFSUNLOCKCLSTATE();
|
|
}
|
|
if (vp != NULL)
|
|
vrele(vp);
|
|
if (mp != NULL)
|
|
vfs_unbusy(mp);
|
|
if (nfhp != NULL)
|
|
FREE((caddr_t)nfhp, M_NFSFH);
|
|
if (!error)
|
|
(void) nfsv4_fillattr(nd, NULL, NULL, NULL, &va,
|
|
NULL, 0, &rattrbits, NULL, NULL, 0, 0, 0, 0,
|
|
(uint64_t)0);
|
|
break;
|
|
case NFSV4OP_CBRECALL:
|
|
NFSCL_DEBUG(4, "cbrecall\n");
|
|
NFSM_DISSECT(tl, u_int32_t *, NFSX_STATEID +
|
|
NFSX_UNSIGNED);
|
|
stateid.seqid = *tl++;
|
|
NFSBCOPY((caddr_t)tl, (caddr_t)stateid.other,
|
|
NFSX_STATEIDOTHER);
|
|
tl += (NFSX_STATEIDOTHER / NFSX_UNSIGNED);
|
|
trunc = fxdr_unsigned(int, *tl);
|
|
error = nfsm_getfh(nd, &nfhp);
|
|
if (error == 0 && i == 0 &&
|
|
minorvers != NFSV4_MINORVERSION)
|
|
error = NFSERR_OPNOTINSESS;
|
|
if (!error) {
|
|
NFSLOCKCLSTATE();
|
|
if (minorvers == NFSV4_MINORVERSION)
|
|
clp = nfscl_getclnt(cbident);
|
|
else
|
|
clp = nfscl_getclntsess(sessionid);
|
|
if (clp != NULL) {
|
|
dp = nfscl_finddeleg(clp, nfhp->nfh_fh,
|
|
nfhp->nfh_len);
|
|
if (dp != NULL && (dp->nfsdl_flags &
|
|
NFSCLDL_DELEGRET) == 0) {
|
|
dp->nfsdl_flags |=
|
|
NFSCLDL_RECALL;
|
|
wakeup((caddr_t)clp);
|
|
}
|
|
} else {
|
|
error = NFSERR_SERVERFAULT;
|
|
}
|
|
NFSUNLOCKCLSTATE();
|
|
}
|
|
if (nfhp != NULL)
|
|
FREE((caddr_t)nfhp, M_NFSFH);
|
|
break;
|
|
case NFSV4OP_CBLAYOUTRECALL:
|
|
NFSCL_DEBUG(4, "cblayrec\n");
|
|
nfhp = NULL;
|
|
NFSM_DISSECT(tl, uint32_t *, 4 * NFSX_UNSIGNED);
|
|
laytype = fxdr_unsigned(int, *tl++);
|
|
iomode = fxdr_unsigned(uint32_t, *tl++);
|
|
if (newnfs_true == *tl++)
|
|
changed = 1;
|
|
else
|
|
changed = 0;
|
|
recalltype = fxdr_unsigned(int, *tl);
|
|
recallp = malloc(sizeof(*recallp), M_NFSLAYRECALL,
|
|
M_WAITOK);
|
|
if (laytype != NFSLAYOUT_NFSV4_1_FILES)
|
|
error = NFSERR_NOMATCHLAYOUT;
|
|
else if (recalltype == NFSLAYOUTRETURN_FILE) {
|
|
error = nfsm_getfh(nd, &nfhp);
|
|
NFSCL_DEBUG(4, "retfile getfh=%d\n", error);
|
|
if (error != 0)
|
|
goto nfsmout;
|
|
NFSM_DISSECT(tl, u_int32_t *, 2 * NFSX_HYPER +
|
|
NFSX_STATEID);
|
|
off = fxdr_hyper(tl); tl += 2;
|
|
len = fxdr_hyper(tl); tl += 2;
|
|
stateid.seqid = fxdr_unsigned(uint32_t, *tl++);
|
|
NFSBCOPY(tl, stateid.other, NFSX_STATEIDOTHER);
|
|
if (minorvers == NFSV4_MINORVERSION)
|
|
error = NFSERR_NOTSUPP;
|
|
else if (i == 0)
|
|
error = NFSERR_OPNOTINSESS;
|
|
if (error == 0) {
|
|
NFSLOCKCLSTATE();
|
|
clp = nfscl_getclntsess(sessionid);
|
|
NFSCL_DEBUG(4, "cbly clp=%p\n", clp);
|
|
if (clp != NULL) {
|
|
lyp = nfscl_findlayout(clp,
|
|
nfhp->nfh_fh,
|
|
nfhp->nfh_len);
|
|
NFSCL_DEBUG(4, "cblyp=%p\n",
|
|
lyp);
|
|
if (lyp != NULL &&
|
|
(lyp->nfsly_flags &
|
|
NFSLY_FILES) != 0 &&
|
|
!NFSBCMP(stateid.other,
|
|
lyp->nfsly_stateid.other,
|
|
NFSX_STATEIDOTHER)) {
|
|
error =
|
|
nfscl_layoutrecall(
|
|
recalltype,
|
|
lyp, iomode, off,
|
|
len, stateid.seqid,
|
|
recallp);
|
|
recallp = NULL;
|
|
wakeup(clp);
|
|
NFSCL_DEBUG(4,
|
|
"aft layrcal=%d\n",
|
|
error);
|
|
} else
|
|
error =
|
|
NFSERR_NOMATCHLAYOUT;
|
|
} else
|
|
error = NFSERR_NOMATCHLAYOUT;
|
|
NFSUNLOCKCLSTATE();
|
|
}
|
|
free(nfhp, M_NFSFH);
|
|
} else if (recalltype == NFSLAYOUTRETURN_FSID) {
|
|
NFSM_DISSECT(tl, uint32_t *, 2 * NFSX_HYPER);
|
|
filesid[0] = fxdr_hyper(tl); tl += 2;
|
|
filesid[1] = fxdr_hyper(tl); tl += 2;
|
|
gotone = 0;
|
|
NFSLOCKCLSTATE();
|
|
clp = nfscl_getclntsess(sessionid);
|
|
if (clp != NULL) {
|
|
TAILQ_FOREACH(lyp, &clp->nfsc_layout,
|
|
nfsly_list) {
|
|
if (lyp->nfsly_filesid[0] ==
|
|
filesid[0] &&
|
|
lyp->nfsly_filesid[1] ==
|
|
filesid[1]) {
|
|
error =
|
|
nfscl_layoutrecall(
|
|
recalltype,
|
|
lyp, iomode, 0,
|
|
UINT64_MAX,
|
|
lyp->nfsly_stateid.seqid,
|
|
recallp);
|
|
recallp = NULL;
|
|
gotone = 1;
|
|
}
|
|
}
|
|
if (gotone != 0)
|
|
wakeup(clp);
|
|
else
|
|
error = NFSERR_NOMATCHLAYOUT;
|
|
} else
|
|
error = NFSERR_NOMATCHLAYOUT;
|
|
NFSUNLOCKCLSTATE();
|
|
} else if (recalltype == NFSLAYOUTRETURN_ALL) {
|
|
gotone = 0;
|
|
NFSLOCKCLSTATE();
|
|
clp = nfscl_getclntsess(sessionid);
|
|
if (clp != NULL) {
|
|
TAILQ_FOREACH(lyp, &clp->nfsc_layout,
|
|
nfsly_list) {
|
|
error = nfscl_layoutrecall(
|
|
recalltype, lyp, iomode, 0,
|
|
UINT64_MAX,
|
|
lyp->nfsly_stateid.seqid,
|
|
recallp);
|
|
recallp = NULL;
|
|
gotone = 1;
|
|
}
|
|
if (gotone != 0)
|
|
wakeup(clp);
|
|
else
|
|
error = NFSERR_NOMATCHLAYOUT;
|
|
} else
|
|
error = NFSERR_NOMATCHLAYOUT;
|
|
NFSUNLOCKCLSTATE();
|
|
} else
|
|
error = NFSERR_NOMATCHLAYOUT;
|
|
if (recallp != NULL) {
|
|
free(recallp, M_NFSLAYRECALL);
|
|
recallp = NULL;
|
|
}
|
|
break;
|
|
case NFSV4OP_CBSEQUENCE:
|
|
NFSM_DISSECT(tl, uint32_t *, NFSX_V4SESSIONID +
|
|
5 * NFSX_UNSIGNED);
|
|
bcopy(tl, sessionid, NFSX_V4SESSIONID);
|
|
tl += NFSX_V4SESSIONID / NFSX_UNSIGNED;
|
|
seqid = fxdr_unsigned(uint32_t, *tl++);
|
|
slotid = fxdr_unsigned(uint32_t, *tl++);
|
|
highslot = fxdr_unsigned(uint32_t, *tl++);
|
|
cachethis = *tl++;
|
|
/* Throw away the referring call stuff. */
|
|
clist = fxdr_unsigned(int, *tl);
|
|
for (j = 0; j < clist; j++) {
|
|
NFSM_DISSECT(tl, uint32_t *, NFSX_V4SESSIONID +
|
|
NFSX_UNSIGNED);
|
|
tl += NFSX_V4SESSIONID / NFSX_UNSIGNED;
|
|
rcalls = fxdr_unsigned(int, *tl);
|
|
for (k = 0; k < rcalls; k++) {
|
|
NFSM_DISSECT(tl, uint32_t *,
|
|
2 * NFSX_UNSIGNED);
|
|
}
|
|
}
|
|
NFSLOCKCLSTATE();
|
|
if (i == 0) {
|
|
clp = nfscl_getclntsess(sessionid);
|
|
if (clp == NULL)
|
|
error = NFSERR_SERVERFAULT;
|
|
} else
|
|
error = NFSERR_SEQUENCEPOS;
|
|
if (error == 0)
|
|
error = nfsv4_seqsession(seqid, slotid,
|
|
highslot,
|
|
NFSMNT_MDSSESSION(clp->nfsc_nmp)->
|
|
nfsess_cbslots, &rep,
|
|
NFSMNT_MDSSESSION(clp->nfsc_nmp)->
|
|
nfsess_backslots);
|
|
NFSUNLOCKCLSTATE();
|
|
if (error == 0) {
|
|
gotseq_ok = 1;
|
|
if (rep != NULL) {
|
|
NFSCL_DEBUG(4, "Got cbretry\n");
|
|
m_freem(nd->nd_mreq);
|
|
nd->nd_mreq = rep;
|
|
rep = NULL;
|
|
goto out;
|
|
}
|
|
NFSM_BUILD(tl, uint32_t *,
|
|
NFSX_V4SESSIONID + 4 * NFSX_UNSIGNED);
|
|
bcopy(sessionid, tl, NFSX_V4SESSIONID);
|
|
tl += NFSX_V4SESSIONID / NFSX_UNSIGNED;
|
|
*tl++ = txdr_unsigned(seqid);
|
|
*tl++ = txdr_unsigned(slotid);
|
|
*tl++ = txdr_unsigned(NFSV4_CBSLOTS - 1);
|
|
*tl = txdr_unsigned(NFSV4_CBSLOTS - 1);
|
|
}
|
|
break;
|
|
default:
|
|
if (i == 0 && minorvers == NFSV41_MINORVERSION)
|
|
error = NFSERR_OPNOTINSESS;
|
|
else {
|
|
NFSCL_DEBUG(1, "unsupp callback %d\n", op);
|
|
error = NFSERR_NOTSUPP;
|
|
}
|
|
break;
|
|
};
|
|
if (error) {
|
|
if (error == EBADRPC || error == NFSERR_BADXDR) {
|
|
nd->nd_repstat = NFSERR_BADXDR;
|
|
} else {
|
|
nd->nd_repstat = error;
|
|
}
|
|
error = 0;
|
|
}
|
|
retops++;
|
|
if (nd->nd_repstat) {
|
|
*repp = nfscl_errmap(nd, minorvers);
|
|
break;
|
|
} else
|
|
*repp = 0; /* NFS4_OK */
|
|
}
|
|
nfsmout:
|
|
if (recallp != NULL)
|
|
free(recallp, M_NFSLAYRECALL);
|
|
if (error) {
|
|
if (error == EBADRPC || error == NFSERR_BADXDR)
|
|
nd->nd_repstat = NFSERR_BADXDR;
|
|
else
|
|
printf("nfsv4 comperr1=%d\n", error);
|
|
}
|
|
if (taglen == -1) {
|
|
NFSM_BUILD(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
|
|
*tl++ = 0;
|
|
*tl = 0;
|
|
} else {
|
|
*retopsp = txdr_unsigned(retops);
|
|
}
|
|
*nd->nd_errp = nfscl_errmap(nd, minorvers);
|
|
out:
|
|
if (gotseq_ok != 0) {
|
|
rep = m_copym(nd->nd_mreq, 0, M_COPYALL, M_WAITOK);
|
|
NFSLOCKCLSTATE();
|
|
clp = nfscl_getclntsess(sessionid);
|
|
if (clp != NULL) {
|
|
nfsv4_seqsess_cacherep(slotid,
|
|
NFSMNT_MDSSESSION(clp->nfsc_nmp)->nfsess_cbslots,
|
|
rep);
|
|
NFSUNLOCKCLSTATE();
|
|
} else {
|
|
NFSUNLOCKCLSTATE();
|
|
m_freem(rep);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Generate the next cbident value. Basically just increment a static value
|
|
* and then check that it isn't already in the list, if it has wrapped around.
|
|
*/
|
|
static u_int32_t
|
|
nfscl_nextcbident(void)
|
|
{
|
|
struct nfsclclient *clp;
|
|
int matched;
|
|
static u_int32_t nextcbident = 0;
|
|
static int haswrapped = 0;
|
|
|
|
nextcbident++;
|
|
if (nextcbident == 0)
|
|
haswrapped = 1;
|
|
if (haswrapped) {
|
|
/*
|
|
* Search the clientid list for one already using this cbident.
|
|
*/
|
|
do {
|
|
matched = 0;
|
|
NFSLOCKCLSTATE();
|
|
LIST_FOREACH(clp, &nfsclhead, nfsc_list) {
|
|
if (clp->nfsc_cbident == nextcbident) {
|
|
matched = 1;
|
|
break;
|
|
}
|
|
}
|
|
NFSUNLOCKCLSTATE();
|
|
if (matched == 1)
|
|
nextcbident++;
|
|
} while (matched);
|
|
}
|
|
return (nextcbident);
|
|
}
|
|
|
|
/*
|
|
* Get the mount point related to a given cbident or session and busy it.
|
|
*/
|
|
static mount_t
|
|
nfscl_getmnt(int minorvers, uint8_t *sessionid, u_int32_t cbident,
|
|
struct nfsclclient **clpp)
|
|
{
|
|
struct nfsclclient *clp;
|
|
mount_t mp;
|
|
int error;
|
|
|
|
*clpp = NULL;
|
|
NFSLOCKCLSTATE();
|
|
LIST_FOREACH(clp, &nfsclhead, nfsc_list) {
|
|
if (minorvers == NFSV4_MINORVERSION) {
|
|
if (clp->nfsc_cbident == cbident)
|
|
break;
|
|
} else if (!NFSBCMP(NFSMNT_MDSSESSION(clp->nfsc_nmp)->
|
|
nfsess_sessionid, sessionid, NFSX_V4SESSIONID))
|
|
break;
|
|
}
|
|
if (clp == NULL) {
|
|
NFSUNLOCKCLSTATE();
|
|
return (NULL);
|
|
}
|
|
mp = clp->nfsc_nmp->nm_mountp;
|
|
vfs_ref(mp);
|
|
NFSUNLOCKCLSTATE();
|
|
error = vfs_busy(mp, 0);
|
|
vfs_rel(mp);
|
|
if (error != 0)
|
|
return (NULL);
|
|
*clpp = clp;
|
|
return (mp);
|
|
}
|
|
|
|
/*
|
|
* Get the clientid pointer related to a given cbident.
|
|
*/
|
|
static struct nfsclclient *
|
|
nfscl_getclnt(u_int32_t cbident)
|
|
{
|
|
struct nfsclclient *clp;
|
|
|
|
LIST_FOREACH(clp, &nfsclhead, nfsc_list)
|
|
if (clp->nfsc_cbident == cbident)
|
|
break;
|
|
return (clp);
|
|
}
|
|
|
|
/*
|
|
* Get the clientid pointer related to a given sessionid.
|
|
*/
|
|
static struct nfsclclient *
|
|
nfscl_getclntsess(uint8_t *sessionid)
|
|
{
|
|
struct nfsclclient *clp;
|
|
|
|
LIST_FOREACH(clp, &nfsclhead, nfsc_list)
|
|
if (!NFSBCMP(NFSMNT_MDSSESSION(clp->nfsc_nmp)->nfsess_sessionid,
|
|
sessionid, NFSX_V4SESSIONID))
|
|
break;
|
|
return (clp);
|
|
}
|
|
|
|
/*
|
|
* Search for a lock conflict locally on the client. A conflict occurs if
|
|
* - not same owner and overlapping byte range and at least one of them is
|
|
* a write lock or this is an unlock.
|
|
*/
|
|
static int
|
|
nfscl_localconflict(struct nfsclclient *clp, u_int8_t *fhp, int fhlen,
|
|
struct nfscllock *nlop, u_int8_t *own, struct nfscldeleg *dp,
|
|
struct nfscllock **lopp)
|
|
{
|
|
struct nfsclowner *owp;
|
|
struct nfsclopen *op;
|
|
int ret;
|
|
|
|
if (dp != NULL) {
|
|
ret = nfscl_checkconflict(&dp->nfsdl_lock, nlop, own, lopp);
|
|
if (ret)
|
|
return (ret);
|
|
}
|
|
LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
|
|
LIST_FOREACH(op, &owp->nfsow_open, nfso_list) {
|
|
if (op->nfso_fhlen == fhlen &&
|
|
!NFSBCMP(op->nfso_fh, fhp, fhlen)) {
|
|
ret = nfscl_checkconflict(&op->nfso_lock, nlop,
|
|
own, lopp);
|
|
if (ret)
|
|
return (ret);
|
|
}
|
|
}
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
nfscl_checkconflict(struct nfscllockownerhead *lhp, struct nfscllock *nlop,
|
|
u_int8_t *own, struct nfscllock **lopp)
|
|
{
|
|
struct nfscllockowner *lp;
|
|
struct nfscllock *lop;
|
|
|
|
LIST_FOREACH(lp, lhp, nfsl_list) {
|
|
if (NFSBCMP(lp->nfsl_owner, own, NFSV4CL_LOCKNAMELEN)) {
|
|
LIST_FOREACH(lop, &lp->nfsl_lock, nfslo_list) {
|
|
if (lop->nfslo_first >= nlop->nfslo_end)
|
|
break;
|
|
if (lop->nfslo_end <= nlop->nfslo_first)
|
|
continue;
|
|
if (lop->nfslo_type == F_WRLCK ||
|
|
nlop->nfslo_type == F_WRLCK ||
|
|
nlop->nfslo_type == F_UNLCK) {
|
|
if (lopp != NULL)
|
|
*lopp = lop;
|
|
return (NFSERR_DENIED);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Check for a local conflicting lock.
|
|
*/
|
|
APPLESTATIC int
|
|
nfscl_lockt(vnode_t vp, struct nfsclclient *clp, u_int64_t off,
|
|
u_int64_t len, struct flock *fl, NFSPROC_T *p, void *id, int flags)
|
|
{
|
|
struct nfscllock *lop, nlck;
|
|
struct nfscldeleg *dp;
|
|
struct nfsnode *np;
|
|
u_int8_t own[NFSV4CL_LOCKNAMELEN];
|
|
int error;
|
|
|
|
nlck.nfslo_type = fl->l_type;
|
|
nlck.nfslo_first = off;
|
|
if (len == NFS64BITSSET) {
|
|
nlck.nfslo_end = NFS64BITSSET;
|
|
} else {
|
|
nlck.nfslo_end = off + len;
|
|
if (nlck.nfslo_end <= nlck.nfslo_first)
|
|
return (NFSERR_INVAL);
|
|
}
|
|
np = VTONFS(vp);
|
|
nfscl_filllockowner(id, own, flags);
|
|
NFSLOCKCLSTATE();
|
|
dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
|
|
error = nfscl_localconflict(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len,
|
|
&nlck, own, dp, &lop);
|
|
if (error != 0) {
|
|
fl->l_whence = SEEK_SET;
|
|
fl->l_start = lop->nfslo_first;
|
|
if (lop->nfslo_end == NFS64BITSSET)
|
|
fl->l_len = 0;
|
|
else
|
|
fl->l_len = lop->nfslo_end - lop->nfslo_first;
|
|
fl->l_pid = (pid_t)0;
|
|
fl->l_type = lop->nfslo_type;
|
|
error = -1; /* no RPC required */
|
|
} else if (dp != NULL && ((dp->nfsdl_flags & NFSCLDL_WRITE) ||
|
|
fl->l_type == F_RDLCK)) {
|
|
/*
|
|
* The delegation ensures that there isn't a conflicting
|
|
* lock on the server, so return -1 to indicate an RPC
|
|
* isn't required.
|
|
*/
|
|
fl->l_type = F_UNLCK;
|
|
error = -1;
|
|
}
|
|
NFSUNLOCKCLSTATE();
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* Handle Recall of a delegation.
|
|
* The clp must be exclusive locked when this is called.
|
|
*/
|
|
static int
|
|
nfscl_recalldeleg(struct nfsclclient *clp, struct nfsmount *nmp,
|
|
struct nfscldeleg *dp, vnode_t vp, struct ucred *cred, NFSPROC_T *p,
|
|
int called_from_renewthread)
|
|
{
|
|
struct nfsclowner *owp, *lowp, *nowp;
|
|
struct nfsclopen *op, *lop;
|
|
struct nfscllockowner *lp;
|
|
struct nfscllock *lckp;
|
|
struct nfsnode *np;
|
|
int error = 0, ret, gotvp = 0;
|
|
|
|
if (vp == NULL) {
|
|
/*
|
|
* First, get a vnode for the file. This is needed to do RPCs.
|
|
*/
|
|
ret = nfscl_ngetreopen(nmp->nm_mountp, dp->nfsdl_fh,
|
|
dp->nfsdl_fhlen, p, &np);
|
|
if (ret) {
|
|
/*
|
|
* File isn't open, so nothing to move over to the
|
|
* server.
|
|
*/
|
|
return (0);
|
|
}
|
|
vp = NFSTOV(np);
|
|
gotvp = 1;
|
|
} else {
|
|
np = VTONFS(vp);
|
|
}
|
|
dp->nfsdl_flags &= ~NFSCLDL_MODTIMESET;
|
|
|
|
/*
|
|
* Ok, if it's a write delegation, flush data to the server, so
|
|
* that close/open consistency is retained.
|
|
*/
|
|
ret = 0;
|
|
NFSLOCKNODE(np);
|
|
if ((dp->nfsdl_flags & NFSCLDL_WRITE) && (np->n_flag & NMODIFIED)) {
|
|
np->n_flag |= NDELEGRECALL;
|
|
NFSUNLOCKNODE(np);
|
|
ret = ncl_flush(vp, MNT_WAIT, cred, p, 1,
|
|
called_from_renewthread);
|
|
NFSLOCKNODE(np);
|
|
np->n_flag &= ~NDELEGRECALL;
|
|
}
|
|
NFSINVALATTRCACHE(np);
|
|
NFSUNLOCKNODE(np);
|
|
if (ret == EIO && called_from_renewthread != 0) {
|
|
/*
|
|
* If the flush failed with EIO for the renew thread,
|
|
* return now, so that the dirty buffer will be flushed
|
|
* later.
|
|
*/
|
|
if (gotvp != 0)
|
|
vrele(vp);
|
|
return (ret);
|
|
}
|
|
|
|
/*
|
|
* Now, for each openowner with opens issued locally, move them
|
|
* over to state against the server.
|
|
*/
|
|
LIST_FOREACH(lowp, &dp->nfsdl_owner, nfsow_list) {
|
|
lop = LIST_FIRST(&lowp->nfsow_open);
|
|
if (lop != NULL) {
|
|
if (LIST_NEXT(lop, nfso_list) != NULL)
|
|
panic("nfsdlg mult opens");
|
|
/*
|
|
* Look for the same openowner against the server.
|
|
*/
|
|
LIST_FOREACH(owp, &clp->nfsc_owner, nfsow_list) {
|
|
if (!NFSBCMP(lowp->nfsow_owner,
|
|
owp->nfsow_owner, NFSV4CL_LOCKNAMELEN)) {
|
|
newnfs_copycred(&dp->nfsdl_cred, cred);
|
|
ret = nfscl_moveopen(vp, clp, nmp, lop,
|
|
owp, dp, cred, p);
|
|
if (ret == NFSERR_STALECLIENTID ||
|
|
ret == NFSERR_STALEDONTRECOVER ||
|
|
ret == NFSERR_BADSESSION) {
|
|
if (gotvp)
|
|
vrele(vp);
|
|
return (ret);
|
|
}
|
|
if (ret) {
|
|
nfscl_freeopen(lop, 1);
|
|
if (!error)
|
|
error = ret;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If no openowner found, create one and get an open
|
|
* for it.
|
|
*/
|
|
if (owp == NULL) {
|
|
MALLOC(nowp, struct nfsclowner *,
|
|
sizeof (struct nfsclowner), M_NFSCLOWNER,
|
|
M_WAITOK);
|
|
nfscl_newopen(clp, NULL, &owp, &nowp, &op,
|
|
NULL, lowp->nfsow_owner, dp->nfsdl_fh,
|
|
dp->nfsdl_fhlen, NULL);
|
|
newnfs_copycred(&dp->nfsdl_cred, cred);
|
|
ret = nfscl_moveopen(vp, clp, nmp, lop,
|
|
owp, dp, cred, p);
|
|
if (ret) {
|
|
nfscl_freeopenowner(owp, 0);
|
|
if (ret == NFSERR_STALECLIENTID ||
|
|
ret == NFSERR_STALEDONTRECOVER ||
|
|
ret == NFSERR_BADSESSION) {
|
|
if (gotvp)
|
|
vrele(vp);
|
|
return (ret);
|
|
}
|
|
if (ret) {
|
|
nfscl_freeopen(lop, 1);
|
|
if (!error)
|
|
error = ret;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Now, get byte range locks for any locks done locally.
|
|
*/
|
|
LIST_FOREACH(lp, &dp->nfsdl_lock, nfsl_list) {
|
|
LIST_FOREACH(lckp, &lp->nfsl_lock, nfslo_list) {
|
|
newnfs_copycred(&dp->nfsdl_cred, cred);
|
|
ret = nfscl_relock(vp, clp, nmp, lp, lckp, cred, p);
|
|
if (ret == NFSERR_STALESTATEID ||
|
|
ret == NFSERR_STALEDONTRECOVER ||
|
|
ret == NFSERR_STALECLIENTID ||
|
|
ret == NFSERR_BADSESSION) {
|
|
if (gotvp)
|
|
vrele(vp);
|
|
return (ret);
|
|
}
|
|
if (ret && !error)
|
|
error = ret;
|
|
}
|
|
}
|
|
if (gotvp)
|
|
vrele(vp);
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* Move a locally issued open over to an owner on the state list.
|
|
* SIDE EFFECT: If it needs to sleep (do an rpc), it unlocks clstate and
|
|
* returns with it unlocked.
|
|
*/
|
|
static int
|
|
nfscl_moveopen(vnode_t vp, struct nfsclclient *clp, struct nfsmount *nmp,
|
|
struct nfsclopen *lop, struct nfsclowner *owp, struct nfscldeleg *dp,
|
|
struct ucred *cred, NFSPROC_T *p)
|
|
{
|
|
struct nfsclopen *op, *nop;
|
|
struct nfscldeleg *ndp;
|
|
struct nfsnode *np;
|
|
int error = 0, newone;
|
|
|
|
/*
|
|
* First, look for an appropriate open, If found, just increment the
|
|
* opencnt in it.
|
|
*/
|
|
LIST_FOREACH(op, &owp->nfsow_open, nfso_list) {
|
|
if ((op->nfso_mode & lop->nfso_mode) == lop->nfso_mode &&
|
|
op->nfso_fhlen == lop->nfso_fhlen &&
|
|
!NFSBCMP(op->nfso_fh, lop->nfso_fh, op->nfso_fhlen)) {
|
|
op->nfso_opencnt += lop->nfso_opencnt;
|
|
nfscl_freeopen(lop, 1);
|
|
return (0);
|
|
}
|
|
}
|
|
|
|
/* No appropriate open, so we have to do one against the server. */
|
|
np = VTONFS(vp);
|
|
MALLOC(nop, struct nfsclopen *, sizeof (struct nfsclopen) +
|
|
lop->nfso_fhlen - 1, M_NFSCLOPEN, M_WAITOK);
|
|
newone = 0;
|
|
nfscl_newopen(clp, NULL, &owp, NULL, &op, &nop, owp->nfsow_owner,
|
|
lop->nfso_fh, lop->nfso_fhlen, &newone);
|
|
ndp = dp;
|
|
error = nfscl_tryopen(nmp, vp, np->n_v4->n4_data, np->n_v4->n4_fhlen,
|
|
lop->nfso_fh, lop->nfso_fhlen, lop->nfso_mode, op,
|
|
NFS4NODENAME(np->n_v4), np->n_v4->n4_namelen, &ndp, 0, 0, cred, p);
|
|
if (error) {
|
|
if (newone)
|
|
nfscl_freeopen(op, 0);
|
|
} else {
|
|
if (newone)
|
|
newnfs_copyincred(cred, &op->nfso_cred);
|
|
op->nfso_mode |= lop->nfso_mode;
|
|
op->nfso_opencnt += lop->nfso_opencnt;
|
|
nfscl_freeopen(lop, 1);
|
|
}
|
|
if (nop != NULL)
|
|
FREE((caddr_t)nop, M_NFSCLOPEN);
|
|
if (ndp != NULL) {
|
|
/*
|
|
* What should I do with the returned delegation, since the
|
|
* delegation is being recalled? For now, just printf and
|
|
* through it away.
|
|
*/
|
|
printf("Moveopen returned deleg\n");
|
|
FREE((caddr_t)ndp, M_NFSCLDELEG);
|
|
}
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* Recall all delegations on this client.
|
|
*/
|
|
static void
|
|
nfscl_totalrecall(struct nfsclclient *clp)
|
|
{
|
|
struct nfscldeleg *dp;
|
|
|
|
TAILQ_FOREACH(dp, &clp->nfsc_deleg, nfsdl_list) {
|
|
if ((dp->nfsdl_flags & NFSCLDL_DELEGRET) == 0)
|
|
dp->nfsdl_flags |= NFSCLDL_RECALL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Relock byte ranges. Called for delegation recall and state expiry.
|
|
*/
|
|
static int
|
|
nfscl_relock(vnode_t vp, struct nfsclclient *clp, struct nfsmount *nmp,
|
|
struct nfscllockowner *lp, struct nfscllock *lop, struct ucred *cred,
|
|
NFSPROC_T *p)
|
|
{
|
|
struct nfscllockowner *nlp;
|
|
struct nfsfh *nfhp;
|
|
u_int64_t off, len;
|
|
u_int32_t clidrev = 0;
|
|
int error, newone, donelocally;
|
|
|
|
off = lop->nfslo_first;
|
|
len = lop->nfslo_end - lop->nfslo_first;
|
|
error = nfscl_getbytelock(vp, off, len, lop->nfslo_type, cred, p,
|
|
clp, 1, NULL, lp->nfsl_lockflags, lp->nfsl_owner,
|
|
lp->nfsl_openowner, &nlp, &newone, &donelocally);
|
|
if (error || donelocally)
|
|
return (error);
|
|
if (nmp->nm_clp != NULL)
|
|
clidrev = nmp->nm_clp->nfsc_clientidrev;
|
|
else
|
|
clidrev = 0;
|
|
nfhp = VTONFS(vp)->n_fhp;
|
|
error = nfscl_trylock(nmp, vp, nfhp->nfh_fh,
|
|
nfhp->nfh_len, nlp, newone, 0, off,
|
|
len, lop->nfslo_type, cred, p);
|
|
if (error)
|
|
nfscl_freelockowner(nlp, 0);
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* Called to re-open a file. Basically get a vnode for the file handle
|
|
* and then call nfsrpc_openrpc() to do the rest.
|
|
*/
|
|
static int
|
|
nfsrpc_reopen(struct nfsmount *nmp, u_int8_t *fhp, int fhlen,
|
|
u_int32_t mode, struct nfsclopen *op, struct nfscldeleg **dpp,
|
|
struct ucred *cred, NFSPROC_T *p)
|
|
{
|
|
struct nfsnode *np;
|
|
vnode_t vp;
|
|
int error;
|
|
|
|
error = nfscl_ngetreopen(nmp->nm_mountp, fhp, fhlen, p, &np);
|
|
if (error)
|
|
return (error);
|
|
vp = NFSTOV(np);
|
|
if (np->n_v4 != NULL) {
|
|
error = nfscl_tryopen(nmp, vp, np->n_v4->n4_data,
|
|
np->n_v4->n4_fhlen, fhp, fhlen, mode, op,
|
|
NFS4NODENAME(np->n_v4), np->n_v4->n4_namelen, dpp, 0, 0,
|
|
cred, p);
|
|
} else {
|
|
error = EINVAL;
|
|
}
|
|
vrele(vp);
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* Try an open against the server. Just call nfsrpc_openrpc(), retrying while
|
|
* NFSERR_DELAY. Also, try system credentials, if the passed in credentials
|
|
* fail.
|
|
*/
|
|
static int
|
|
nfscl_tryopen(struct nfsmount *nmp, vnode_t vp, u_int8_t *fhp, int fhlen,
|
|
u_int8_t *newfhp, int newfhlen, u_int32_t mode, struct nfsclopen *op,
|
|
u_int8_t *name, int namelen, struct nfscldeleg **ndpp,
|
|
int reclaim, u_int32_t delegtype, struct ucred *cred, NFSPROC_T *p)
|
|
{
|
|
int error;
|
|
|
|
do {
|
|
error = nfsrpc_openrpc(nmp, vp, fhp, fhlen, newfhp, newfhlen,
|
|
mode, op, name, namelen, ndpp, reclaim, delegtype, cred, p,
|
|
0, 0);
|
|
if (error == NFSERR_DELAY)
|
|
(void) nfs_catnap(PZERO, error, "nfstryop");
|
|
} while (error == NFSERR_DELAY);
|
|
if (error == EAUTH || error == EACCES) {
|
|
/* Try again using system credentials */
|
|
newnfs_setroot(cred);
|
|
do {
|
|
error = nfsrpc_openrpc(nmp, vp, fhp, fhlen, newfhp,
|
|
newfhlen, mode, op, name, namelen, ndpp, reclaim,
|
|
delegtype, cred, p, 1, 0);
|
|
if (error == NFSERR_DELAY)
|
|
(void) nfs_catnap(PZERO, error, "nfstryop");
|
|
} while (error == NFSERR_DELAY);
|
|
}
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* Try a byte range lock. Just loop on nfsrpc_lock() while it returns
|
|
* NFSERR_DELAY. Also, retry with system credentials, if the provided
|
|
* cred don't work.
|
|
*/
|
|
static int
|
|
nfscl_trylock(struct nfsmount *nmp, vnode_t vp, u_int8_t *fhp,
|
|
int fhlen, struct nfscllockowner *nlp, int newone, int reclaim,
|
|
u_int64_t off, u_int64_t len, short type, struct ucred *cred, NFSPROC_T *p)
|
|
{
|
|
struct nfsrv_descript nfsd, *nd = &nfsd;
|
|
int error;
|
|
|
|
do {
|
|
error = nfsrpc_lock(nd, nmp, vp, fhp, fhlen, nlp, newone,
|
|
reclaim, off, len, type, cred, p, 0);
|
|
if (!error && nd->nd_repstat == NFSERR_DELAY)
|
|
(void) nfs_catnap(PZERO, (int)nd->nd_repstat,
|
|
"nfstrylck");
|
|
} while (!error && nd->nd_repstat == NFSERR_DELAY);
|
|
if (!error)
|
|
error = nd->nd_repstat;
|
|
if (error == EAUTH || error == EACCES) {
|
|
/* Try again using root credentials */
|
|
newnfs_setroot(cred);
|
|
do {
|
|
error = nfsrpc_lock(nd, nmp, vp, fhp, fhlen, nlp,
|
|
newone, reclaim, off, len, type, cred, p, 1);
|
|
if (!error && nd->nd_repstat == NFSERR_DELAY)
|
|
(void) nfs_catnap(PZERO, (int)nd->nd_repstat,
|
|
"nfstrylck");
|
|
} while (!error && nd->nd_repstat == NFSERR_DELAY);
|
|
if (!error)
|
|
error = nd->nd_repstat;
|
|
}
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* Try a delegreturn against the server. Just call nfsrpc_delegreturn(),
|
|
* retrying while NFSERR_DELAY. Also, try system credentials, if the passed in
|
|
* credentials fail.
|
|
*/
|
|
static int
|
|
nfscl_trydelegreturn(struct nfscldeleg *dp, struct ucred *cred,
|
|
struct nfsmount *nmp, NFSPROC_T *p)
|
|
{
|
|
int error;
|
|
|
|
do {
|
|
error = nfsrpc_delegreturn(dp, cred, nmp, p, 0);
|
|
if (error == NFSERR_DELAY)
|
|
(void) nfs_catnap(PZERO, error, "nfstrydp");
|
|
} while (error == NFSERR_DELAY);
|
|
if (error == EAUTH || error == EACCES) {
|
|
/* Try again using system credentials */
|
|
newnfs_setroot(cred);
|
|
do {
|
|
error = nfsrpc_delegreturn(dp, cred, nmp, p, 1);
|
|
if (error == NFSERR_DELAY)
|
|
(void) nfs_catnap(PZERO, error, "nfstrydp");
|
|
} while (error == NFSERR_DELAY);
|
|
}
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* Try a close against the server. Just call nfsrpc_closerpc(),
|
|
* retrying while NFSERR_DELAY. Also, try system credentials, if the passed in
|
|
* credentials fail.
|
|
*/
|
|
APPLESTATIC int
|
|
nfscl_tryclose(struct nfsclopen *op, struct ucred *cred,
|
|
struct nfsmount *nmp, NFSPROC_T *p)
|
|
{
|
|
struct nfsrv_descript nfsd, *nd = &nfsd;
|
|
int error;
|
|
|
|
do {
|
|
error = nfsrpc_closerpc(nd, nmp, op, cred, p, 0);
|
|
if (error == NFSERR_DELAY)
|
|
(void) nfs_catnap(PZERO, error, "nfstrycl");
|
|
} while (error == NFSERR_DELAY);
|
|
if (error == EAUTH || error == EACCES) {
|
|
/* Try again using system credentials */
|
|
newnfs_setroot(cred);
|
|
do {
|
|
error = nfsrpc_closerpc(nd, nmp, op, cred, p, 1);
|
|
if (error == NFSERR_DELAY)
|
|
(void) nfs_catnap(PZERO, error, "nfstrycl");
|
|
} while (error == NFSERR_DELAY);
|
|
}
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* Decide if a delegation on a file permits close without flushing writes
|
|
* to the server. This might be a big performance win in some environments.
|
|
* (Not useful until the client does caching on local stable storage.)
|
|
*/
|
|
APPLESTATIC int
|
|
nfscl_mustflush(vnode_t vp)
|
|
{
|
|
struct nfsclclient *clp;
|
|
struct nfscldeleg *dp;
|
|
struct nfsnode *np;
|
|
struct nfsmount *nmp;
|
|
|
|
np = VTONFS(vp);
|
|
nmp = VFSTONFS(vnode_mount(vp));
|
|
if (!NFSHASNFSV4(nmp))
|
|
return (1);
|
|
NFSLOCKCLSTATE();
|
|
clp = nfscl_findcl(nmp);
|
|
if (clp == NULL) {
|
|
NFSUNLOCKCLSTATE();
|
|
return (1);
|
|
}
|
|
dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
|
|
if (dp != NULL && (dp->nfsdl_flags &
|
|
(NFSCLDL_WRITE | NFSCLDL_RECALL | NFSCLDL_DELEGRET)) ==
|
|
NFSCLDL_WRITE &&
|
|
(dp->nfsdl_sizelimit >= np->n_size ||
|
|
!NFSHASSTRICT3530(nmp))) {
|
|
NFSUNLOCKCLSTATE();
|
|
return (0);
|
|
}
|
|
NFSUNLOCKCLSTATE();
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
* See if a (write) delegation exists for this file.
|
|
*/
|
|
APPLESTATIC int
|
|
nfscl_nodeleg(vnode_t vp, int writedeleg)
|
|
{
|
|
struct nfsclclient *clp;
|
|
struct nfscldeleg *dp;
|
|
struct nfsnode *np;
|
|
struct nfsmount *nmp;
|
|
|
|
np = VTONFS(vp);
|
|
nmp = VFSTONFS(vnode_mount(vp));
|
|
if (!NFSHASNFSV4(nmp))
|
|
return (1);
|
|
NFSLOCKCLSTATE();
|
|
clp = nfscl_findcl(nmp);
|
|
if (clp == NULL) {
|
|
NFSUNLOCKCLSTATE();
|
|
return (1);
|
|
}
|
|
dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
|
|
if (dp != NULL &&
|
|
(dp->nfsdl_flags & (NFSCLDL_RECALL | NFSCLDL_DELEGRET)) == 0 &&
|
|
(writedeleg == 0 || (dp->nfsdl_flags & NFSCLDL_WRITE) ==
|
|
NFSCLDL_WRITE)) {
|
|
NFSUNLOCKCLSTATE();
|
|
return (0);
|
|
}
|
|
NFSUNLOCKCLSTATE();
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
* Look for an associated delegation that should be DelegReturned.
|
|
*/
|
|
APPLESTATIC int
|
|
nfscl_removedeleg(vnode_t vp, NFSPROC_T *p, nfsv4stateid_t *stp)
|
|
{
|
|
struct nfsclclient *clp;
|
|
struct nfscldeleg *dp;
|
|
struct nfsclowner *owp;
|
|
struct nfscllockowner *lp;
|
|
struct nfsmount *nmp;
|
|
struct ucred *cred;
|
|
struct nfsnode *np;
|
|
int igotlock = 0, triedrecall = 0, needsrecall, retcnt = 0, islept;
|
|
|
|
nmp = VFSTONFS(vnode_mount(vp));
|
|
np = VTONFS(vp);
|
|
NFSLOCKCLSTATE();
|
|
/*
|
|
* Loop around waiting for:
|
|
* - outstanding I/O operations on delegations to complete
|
|
* - for a delegation on vp that has state, lock the client and
|
|
* do a recall
|
|
* - return delegation with no state
|
|
*/
|
|
while (1) {
|
|
clp = nfscl_findcl(nmp);
|
|
if (clp == NULL) {
|
|
NFSUNLOCKCLSTATE();
|
|
return (retcnt);
|
|
}
|
|
dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh,
|
|
np->n_fhp->nfh_len);
|
|
if (dp != NULL) {
|
|
/*
|
|
* Wait for outstanding I/O ops to be done.
|
|
*/
|
|
if (dp->nfsdl_rwlock.nfslock_usecnt > 0) {
|
|
if (igotlock) {
|
|
nfsv4_unlock(&clp->nfsc_lock, 0);
|
|
igotlock = 0;
|
|
}
|
|
dp->nfsdl_rwlock.nfslock_lock |= NFSV4LOCK_WANTED;
|
|
(void) nfsmsleep(&dp->nfsdl_rwlock,
|
|
NFSCLSTATEMUTEXPTR, PZERO, "nfscld", NULL);
|
|
continue;
|
|
}
|
|
needsrecall = 0;
|
|
LIST_FOREACH(owp, &dp->nfsdl_owner, nfsow_list) {
|
|
if (!LIST_EMPTY(&owp->nfsow_open)) {
|
|
needsrecall = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (!needsrecall) {
|
|
LIST_FOREACH(lp, &dp->nfsdl_lock, nfsl_list) {
|
|
if (!LIST_EMPTY(&lp->nfsl_lock)) {
|
|
needsrecall = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (needsrecall && !triedrecall) {
|
|
dp->nfsdl_flags |= NFSCLDL_DELEGRET;
|
|
islept = 0;
|
|
while (!igotlock) {
|
|
igotlock = nfsv4_lock(&clp->nfsc_lock, 1,
|
|
&islept, NFSCLSTATEMUTEXPTR, NULL);
|
|
if (islept)
|
|
break;
|
|
}
|
|
if (islept)
|
|
continue;
|
|
NFSUNLOCKCLSTATE();
|
|
cred = newnfs_getcred();
|
|
newnfs_copycred(&dp->nfsdl_cred, cred);
|
|
(void) nfscl_recalldeleg(clp, nmp, dp, vp, cred, p, 0);
|
|
NFSFREECRED(cred);
|
|
triedrecall = 1;
|
|
NFSLOCKCLSTATE();
|
|
nfsv4_unlock(&clp->nfsc_lock, 0);
|
|
igotlock = 0;
|
|
continue;
|
|
}
|
|
*stp = dp->nfsdl_stateid;
|
|
retcnt = 1;
|
|
nfscl_cleandeleg(dp);
|
|
nfscl_freedeleg(&clp->nfsc_deleg, dp);
|
|
}
|
|
if (igotlock)
|
|
nfsv4_unlock(&clp->nfsc_lock, 0);
|
|
NFSUNLOCKCLSTATE();
|
|
return (retcnt);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Look for associated delegation(s) that should be DelegReturned.
|
|
*/
|
|
APPLESTATIC int
|
|
nfscl_renamedeleg(vnode_t fvp, nfsv4stateid_t *fstp, int *gotfdp, vnode_t tvp,
|
|
nfsv4stateid_t *tstp, int *gottdp, NFSPROC_T *p)
|
|
{
|
|
struct nfsclclient *clp;
|
|
struct nfscldeleg *dp;
|
|
struct nfsclowner *owp;
|
|
struct nfscllockowner *lp;
|
|
struct nfsmount *nmp;
|
|
struct ucred *cred;
|
|
struct nfsnode *np;
|
|
int igotlock = 0, triedrecall = 0, needsrecall, retcnt = 0, islept;
|
|
|
|
nmp = VFSTONFS(vnode_mount(fvp));
|
|
*gotfdp = 0;
|
|
*gottdp = 0;
|
|
NFSLOCKCLSTATE();
|
|
/*
|
|
* Loop around waiting for:
|
|
* - outstanding I/O operations on delegations to complete
|
|
* - for a delegation on fvp that has state, lock the client and
|
|
* do a recall
|
|
* - return delegation(s) with no state.
|
|
*/
|
|
while (1) {
|
|
clp = nfscl_findcl(nmp);
|
|
if (clp == NULL) {
|
|
NFSUNLOCKCLSTATE();
|
|
return (retcnt);
|
|
}
|
|
np = VTONFS(fvp);
|
|
dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh,
|
|
np->n_fhp->nfh_len);
|
|
if (dp != NULL && *gotfdp == 0) {
|
|
/*
|
|
* Wait for outstanding I/O ops to be done.
|
|
*/
|
|
if (dp->nfsdl_rwlock.nfslock_usecnt > 0) {
|
|
if (igotlock) {
|
|
nfsv4_unlock(&clp->nfsc_lock, 0);
|
|
igotlock = 0;
|
|
}
|
|
dp->nfsdl_rwlock.nfslock_lock |= NFSV4LOCK_WANTED;
|
|
(void) nfsmsleep(&dp->nfsdl_rwlock,
|
|
NFSCLSTATEMUTEXPTR, PZERO, "nfscld", NULL);
|
|
continue;
|
|
}
|
|
needsrecall = 0;
|
|
LIST_FOREACH(owp, &dp->nfsdl_owner, nfsow_list) {
|
|
if (!LIST_EMPTY(&owp->nfsow_open)) {
|
|
needsrecall = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (!needsrecall) {
|
|
LIST_FOREACH(lp, &dp->nfsdl_lock, nfsl_list) {
|
|
if (!LIST_EMPTY(&lp->nfsl_lock)) {
|
|
needsrecall = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (needsrecall && !triedrecall) {
|
|
dp->nfsdl_flags |= NFSCLDL_DELEGRET;
|
|
islept = 0;
|
|
while (!igotlock) {
|
|
igotlock = nfsv4_lock(&clp->nfsc_lock, 1,
|
|
&islept, NFSCLSTATEMUTEXPTR, NULL);
|
|
if (islept)
|
|
break;
|
|
}
|
|
if (islept)
|
|
continue;
|
|
NFSUNLOCKCLSTATE();
|
|
cred = newnfs_getcred();
|
|
newnfs_copycred(&dp->nfsdl_cred, cred);
|
|
(void) nfscl_recalldeleg(clp, nmp, dp, fvp, cred, p, 0);
|
|
NFSFREECRED(cred);
|
|
triedrecall = 1;
|
|
NFSLOCKCLSTATE();
|
|
nfsv4_unlock(&clp->nfsc_lock, 0);
|
|
igotlock = 0;
|
|
continue;
|
|
}
|
|
*fstp = dp->nfsdl_stateid;
|
|
retcnt++;
|
|
*gotfdp = 1;
|
|
nfscl_cleandeleg(dp);
|
|
nfscl_freedeleg(&clp->nfsc_deleg, dp);
|
|
}
|
|
if (igotlock) {
|
|
nfsv4_unlock(&clp->nfsc_lock, 0);
|
|
igotlock = 0;
|
|
}
|
|
if (tvp != NULL) {
|
|
np = VTONFS(tvp);
|
|
dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh,
|
|
np->n_fhp->nfh_len);
|
|
if (dp != NULL && *gottdp == 0) {
|
|
/*
|
|
* Wait for outstanding I/O ops to be done.
|
|
*/
|
|
if (dp->nfsdl_rwlock.nfslock_usecnt > 0) {
|
|
dp->nfsdl_rwlock.nfslock_lock |= NFSV4LOCK_WANTED;
|
|
(void) nfsmsleep(&dp->nfsdl_rwlock,
|
|
NFSCLSTATEMUTEXPTR, PZERO, "nfscld", NULL);
|
|
continue;
|
|
}
|
|
LIST_FOREACH(owp, &dp->nfsdl_owner, nfsow_list) {
|
|
if (!LIST_EMPTY(&owp->nfsow_open)) {
|
|
NFSUNLOCKCLSTATE();
|
|
return (retcnt);
|
|
}
|
|
}
|
|
LIST_FOREACH(lp, &dp->nfsdl_lock, nfsl_list) {
|
|
if (!LIST_EMPTY(&lp->nfsl_lock)) {
|
|
NFSUNLOCKCLSTATE();
|
|
return (retcnt);
|
|
}
|
|
}
|
|
*tstp = dp->nfsdl_stateid;
|
|
retcnt++;
|
|
*gottdp = 1;
|
|
nfscl_cleandeleg(dp);
|
|
nfscl_freedeleg(&clp->nfsc_deleg, dp);
|
|
}
|
|
}
|
|
NFSUNLOCKCLSTATE();
|
|
return (retcnt);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Get a reference on the clientid associated with the mount point.
|
|
* Return 1 if success, 0 otherwise.
|
|
*/
|
|
APPLESTATIC int
|
|
nfscl_getref(struct nfsmount *nmp)
|
|
{
|
|
struct nfsclclient *clp;
|
|
|
|
NFSLOCKCLSTATE();
|
|
clp = nfscl_findcl(nmp);
|
|
if (clp == NULL) {
|
|
NFSUNLOCKCLSTATE();
|
|
return (0);
|
|
}
|
|
nfsv4_getref(&clp->nfsc_lock, NULL, NFSCLSTATEMUTEXPTR, NULL);
|
|
NFSUNLOCKCLSTATE();
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
* Release a reference on a clientid acquired with the above call.
|
|
*/
|
|
APPLESTATIC void
|
|
nfscl_relref(struct nfsmount *nmp)
|
|
{
|
|
struct nfsclclient *clp;
|
|
|
|
NFSLOCKCLSTATE();
|
|
clp = nfscl_findcl(nmp);
|
|
if (clp == NULL) {
|
|
NFSUNLOCKCLSTATE();
|
|
return;
|
|
}
|
|
nfsv4_relref(&clp->nfsc_lock);
|
|
NFSUNLOCKCLSTATE();
|
|
}
|
|
|
|
/*
|
|
* Save the size attribute in the delegation, since the nfsnode
|
|
* is going away.
|
|
*/
|
|
APPLESTATIC void
|
|
nfscl_reclaimnode(vnode_t vp)
|
|
{
|
|
struct nfsclclient *clp;
|
|
struct nfscldeleg *dp;
|
|
struct nfsnode *np = VTONFS(vp);
|
|
struct nfsmount *nmp;
|
|
|
|
nmp = VFSTONFS(vnode_mount(vp));
|
|
if (!NFSHASNFSV4(nmp))
|
|
return;
|
|
NFSLOCKCLSTATE();
|
|
clp = nfscl_findcl(nmp);
|
|
if (clp == NULL) {
|
|
NFSUNLOCKCLSTATE();
|
|
return;
|
|
}
|
|
dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
|
|
if (dp != NULL && (dp->nfsdl_flags & NFSCLDL_WRITE))
|
|
dp->nfsdl_size = np->n_size;
|
|
NFSUNLOCKCLSTATE();
|
|
}
|
|
|
|
/*
|
|
* Get the saved size attribute in the delegation, since it is a
|
|
* newly allocated nfsnode.
|
|
*/
|
|
APPLESTATIC void
|
|
nfscl_newnode(vnode_t vp)
|
|
{
|
|
struct nfsclclient *clp;
|
|
struct nfscldeleg *dp;
|
|
struct nfsnode *np = VTONFS(vp);
|
|
struct nfsmount *nmp;
|
|
|
|
nmp = VFSTONFS(vnode_mount(vp));
|
|
if (!NFSHASNFSV4(nmp))
|
|
return;
|
|
NFSLOCKCLSTATE();
|
|
clp = nfscl_findcl(nmp);
|
|
if (clp == NULL) {
|
|
NFSUNLOCKCLSTATE();
|
|
return;
|
|
}
|
|
dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
|
|
if (dp != NULL && (dp->nfsdl_flags & NFSCLDL_WRITE))
|
|
np->n_size = dp->nfsdl_size;
|
|
NFSUNLOCKCLSTATE();
|
|
}
|
|
|
|
/*
|
|
* If there is a valid write delegation for this file, set the modtime
|
|
* to the local clock time.
|
|
*/
|
|
APPLESTATIC void
|
|
nfscl_delegmodtime(vnode_t vp)
|
|
{
|
|
struct nfsclclient *clp;
|
|
struct nfscldeleg *dp;
|
|
struct nfsnode *np = VTONFS(vp);
|
|
struct nfsmount *nmp;
|
|
|
|
nmp = VFSTONFS(vnode_mount(vp));
|
|
if (!NFSHASNFSV4(nmp))
|
|
return;
|
|
NFSLOCKCLSTATE();
|
|
clp = nfscl_findcl(nmp);
|
|
if (clp == NULL) {
|
|
NFSUNLOCKCLSTATE();
|
|
return;
|
|
}
|
|
dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
|
|
if (dp != NULL && (dp->nfsdl_flags & NFSCLDL_WRITE)) {
|
|
nanotime(&dp->nfsdl_modtime);
|
|
dp->nfsdl_flags |= NFSCLDL_MODTIMESET;
|
|
}
|
|
NFSUNLOCKCLSTATE();
|
|
}
|
|
|
|
/*
|
|
* If there is a valid write delegation for this file with a modtime set,
|
|
* put that modtime in mtime.
|
|
*/
|
|
APPLESTATIC void
|
|
nfscl_deleggetmodtime(vnode_t vp, struct timespec *mtime)
|
|
{
|
|
struct nfsclclient *clp;
|
|
struct nfscldeleg *dp;
|
|
struct nfsnode *np = VTONFS(vp);
|
|
struct nfsmount *nmp;
|
|
|
|
nmp = VFSTONFS(vnode_mount(vp));
|
|
if (!NFSHASNFSV4(nmp))
|
|
return;
|
|
NFSLOCKCLSTATE();
|
|
clp = nfscl_findcl(nmp);
|
|
if (clp == NULL) {
|
|
NFSUNLOCKCLSTATE();
|
|
return;
|
|
}
|
|
dp = nfscl_finddeleg(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
|
|
if (dp != NULL &&
|
|
(dp->nfsdl_flags & (NFSCLDL_WRITE | NFSCLDL_MODTIMESET)) ==
|
|
(NFSCLDL_WRITE | NFSCLDL_MODTIMESET))
|
|
*mtime = dp->nfsdl_modtime;
|
|
NFSUNLOCKCLSTATE();
|
|
}
|
|
|
|
static int
|
|
nfscl_errmap(struct nfsrv_descript *nd, u_int32_t minorvers)
|
|
{
|
|
short *defaulterrp, *errp;
|
|
|
|
if (!nd->nd_repstat)
|
|
return (0);
|
|
if (nd->nd_procnum == NFSPROC_NOOP)
|
|
return (txdr_unsigned(nd->nd_repstat & 0xffff));
|
|
if (nd->nd_repstat == EBADRPC)
|
|
return (txdr_unsigned(NFSERR_BADXDR));
|
|
if (nd->nd_repstat == NFSERR_MINORVERMISMATCH ||
|
|
nd->nd_repstat == NFSERR_OPILLEGAL)
|
|
return (txdr_unsigned(nd->nd_repstat));
|
|
if (nd->nd_repstat >= NFSERR_BADIOMODE && nd->nd_repstat < 20000 &&
|
|
minorvers > NFSV4_MINORVERSION) {
|
|
/* NFSv4.n error. */
|
|
return (txdr_unsigned(nd->nd_repstat));
|
|
}
|
|
if (nd->nd_procnum < NFSV4OP_CBNOPS)
|
|
errp = defaulterrp = nfscl_cberrmap[nd->nd_procnum];
|
|
else
|
|
return (txdr_unsigned(nd->nd_repstat));
|
|
while (*++errp)
|
|
if (*errp == (short)nd->nd_repstat)
|
|
return (txdr_unsigned(nd->nd_repstat));
|
|
return (txdr_unsigned(*defaulterrp));
|
|
}
|
|
|
|
/*
|
|
* Called to find/add a layout to a client.
|
|
* This function returns the layout with a refcnt (shared lock) upon
|
|
* success (returns 0) or with no lock/refcnt on the layout when an
|
|
* error is returned.
|
|
* If a layout is passed in via lypp, it is locked (exclusively locked).
|
|
*/
|
|
APPLESTATIC int
|
|
nfscl_layout(struct nfsmount *nmp, vnode_t vp, u_int8_t *fhp, int fhlen,
|
|
nfsv4stateid_t *stateidp, int retonclose,
|
|
struct nfsclflayouthead *fhlp, struct nfscllayout **lypp,
|
|
struct ucred *cred, NFSPROC_T *p)
|
|
{
|
|
struct nfsclclient *clp;
|
|
struct nfscllayout *lyp, *tlyp;
|
|
struct nfsclflayout *flp;
|
|
struct nfsnode *np = VTONFS(vp);
|
|
mount_t mp;
|
|
int layout_passed_in;
|
|
|
|
mp = nmp->nm_mountp;
|
|
layout_passed_in = 1;
|
|
tlyp = NULL;
|
|
lyp = *lypp;
|
|
if (lyp == NULL) {
|
|
layout_passed_in = 0;
|
|
tlyp = malloc(sizeof(*tlyp) + fhlen - 1, M_NFSLAYOUT,
|
|
M_WAITOK | M_ZERO);
|
|
}
|
|
|
|
NFSLOCKCLSTATE();
|
|
clp = nmp->nm_clp;
|
|
if (clp == NULL) {
|
|
if (layout_passed_in != 0)
|
|
nfsv4_unlock(&lyp->nfsly_lock, 0);
|
|
NFSUNLOCKCLSTATE();
|
|
if (tlyp != NULL)
|
|
free(tlyp, M_NFSLAYOUT);
|
|
return (EPERM);
|
|
}
|
|
if (lyp == NULL) {
|
|
/*
|
|
* Although no lyp was passed in, another thread might have
|
|
* allocated one. If one is found, just increment it's ref
|
|
* count and return it.
|
|
*/
|
|
lyp = nfscl_findlayout(clp, fhp, fhlen);
|
|
if (lyp == NULL) {
|
|
lyp = tlyp;
|
|
tlyp = NULL;
|
|
lyp->nfsly_stateid.seqid = stateidp->seqid;
|
|
lyp->nfsly_stateid.other[0] = stateidp->other[0];
|
|
lyp->nfsly_stateid.other[1] = stateidp->other[1];
|
|
lyp->nfsly_stateid.other[2] = stateidp->other[2];
|
|
lyp->nfsly_lastbyte = 0;
|
|
LIST_INIT(&lyp->nfsly_flayread);
|
|
LIST_INIT(&lyp->nfsly_flayrw);
|
|
LIST_INIT(&lyp->nfsly_recall);
|
|
lyp->nfsly_filesid[0] = np->n_vattr.na_filesid[0];
|
|
lyp->nfsly_filesid[1] = np->n_vattr.na_filesid[1];
|
|
lyp->nfsly_clp = clp;
|
|
lyp->nfsly_flags = (retonclose != 0) ?
|
|
(NFSLY_FILES | NFSLY_RETONCLOSE) : NFSLY_FILES;
|
|
lyp->nfsly_fhlen = fhlen;
|
|
NFSBCOPY(fhp, lyp->nfsly_fh, fhlen);
|
|
TAILQ_INSERT_HEAD(&clp->nfsc_layout, lyp, nfsly_list);
|
|
LIST_INSERT_HEAD(NFSCLLAYOUTHASH(clp, fhp, fhlen), lyp,
|
|
nfsly_hash);
|
|
lyp->nfsly_timestamp = NFSD_MONOSEC + 120;
|
|
nfscl_layoutcnt++;
|
|
} else {
|
|
if (retonclose != 0)
|
|
lyp->nfsly_flags |= NFSLY_RETONCLOSE;
|
|
TAILQ_REMOVE(&clp->nfsc_layout, lyp, nfsly_list);
|
|
TAILQ_INSERT_HEAD(&clp->nfsc_layout, lyp, nfsly_list);
|
|
lyp->nfsly_timestamp = NFSD_MONOSEC + 120;
|
|
}
|
|
nfsv4_getref(&lyp->nfsly_lock, NULL, NFSCLSTATEMUTEXPTR, mp);
|
|
if ((mp->mnt_kern_flag & MNTK_UNMOUNTF) != 0) {
|
|
NFSUNLOCKCLSTATE();
|
|
if (tlyp != NULL)
|
|
free(tlyp, M_NFSLAYOUT);
|
|
return (EPERM);
|
|
}
|
|
*lypp = lyp;
|
|
} else
|
|
lyp->nfsly_stateid.seqid = stateidp->seqid;
|
|
|
|
/* Merge the new list of File Layouts into the list. */
|
|
flp = LIST_FIRST(fhlp);
|
|
if (flp != NULL) {
|
|
if (flp->nfsfl_iomode == NFSLAYOUTIOMODE_READ)
|
|
nfscl_mergeflayouts(&lyp->nfsly_flayread, fhlp);
|
|
else
|
|
nfscl_mergeflayouts(&lyp->nfsly_flayrw, fhlp);
|
|
}
|
|
if (layout_passed_in != 0)
|
|
nfsv4_unlock(&lyp->nfsly_lock, 1);
|
|
NFSUNLOCKCLSTATE();
|
|
if (tlyp != NULL)
|
|
free(tlyp, M_NFSLAYOUT);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Search for a layout by MDS file handle.
|
|
* If one is found, it is returned with a refcnt (shared lock) iff
|
|
* retflpp returned non-NULL and locked (exclusive locked) iff retflpp is
|
|
* returned NULL.
|
|
*/
|
|
struct nfscllayout *
|
|
nfscl_getlayout(struct nfsclclient *clp, uint8_t *fhp, int fhlen,
|
|
uint64_t off, struct nfsclflayout **retflpp, int *recalledp)
|
|
{
|
|
struct nfscllayout *lyp;
|
|
mount_t mp;
|
|
int error, igotlock;
|
|
|
|
mp = clp->nfsc_nmp->nm_mountp;
|
|
*recalledp = 0;
|
|
*retflpp = NULL;
|
|
NFSLOCKCLSTATE();
|
|
lyp = nfscl_findlayout(clp, fhp, fhlen);
|
|
if (lyp != NULL) {
|
|
if ((lyp->nfsly_flags & NFSLY_RECALL) == 0) {
|
|
TAILQ_REMOVE(&clp->nfsc_layout, lyp, nfsly_list);
|
|
TAILQ_INSERT_HEAD(&clp->nfsc_layout, lyp, nfsly_list);
|
|
lyp->nfsly_timestamp = NFSD_MONOSEC + 120;
|
|
error = nfscl_findlayoutforio(lyp, off,
|
|
NFSV4OPEN_ACCESSREAD, retflpp);
|
|
if (error == 0)
|
|
nfsv4_getref(&lyp->nfsly_lock, NULL,
|
|
NFSCLSTATEMUTEXPTR, mp);
|
|
else {
|
|
do {
|
|
igotlock = nfsv4_lock(&lyp->nfsly_lock,
|
|
1, NULL, NFSCLSTATEMUTEXPTR, mp);
|
|
} while (igotlock == 0 &&
|
|
(mp->mnt_kern_flag & MNTK_UNMOUNTF) == 0);
|
|
*retflpp = NULL;
|
|
}
|
|
if ((mp->mnt_kern_flag & MNTK_UNMOUNTF) != 0) {
|
|
lyp = NULL;
|
|
*recalledp = 1;
|
|
}
|
|
} else {
|
|
lyp = NULL;
|
|
*recalledp = 1;
|
|
}
|
|
}
|
|
NFSUNLOCKCLSTATE();
|
|
return (lyp);
|
|
}
|
|
|
|
/*
|
|
* Search for a layout by MDS file handle. If one is found that is marked
|
|
* "return on close", delete it, since it should now be forgotten.
|
|
*/
|
|
static void
|
|
nfscl_retoncloselayout(struct nfsclclient *clp, uint8_t *fhp, int fhlen)
|
|
{
|
|
struct nfscllayout *lyp;
|
|
|
|
tryagain:
|
|
lyp = nfscl_findlayout(clp, fhp, fhlen);
|
|
if (lyp != NULL && (lyp->nfsly_flags & NFSLY_RETONCLOSE) != 0) {
|
|
/*
|
|
* Wait for outstanding I/O ops to be done.
|
|
*/
|
|
if (lyp->nfsly_lock.nfslock_usecnt != 0 ||
|
|
lyp->nfsly_lock.nfslock_lock != 0) {
|
|
lyp->nfsly_lock.nfslock_lock |= NFSV4LOCK_WANTED;
|
|
(void)mtx_sleep(&lyp->nfsly_lock,
|
|
NFSCLSTATEMUTEXPTR, PZERO, "nfslyc", 0);
|
|
goto tryagain;
|
|
}
|
|
nfscl_freelayout(lyp);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Dereference a layout.
|
|
*/
|
|
void
|
|
nfscl_rellayout(struct nfscllayout *lyp, int exclocked)
|
|
{
|
|
|
|
NFSLOCKCLSTATE();
|
|
if (exclocked != 0)
|
|
nfsv4_unlock(&lyp->nfsly_lock, 0);
|
|
else
|
|
nfsv4_relref(&lyp->nfsly_lock);
|
|
NFSUNLOCKCLSTATE();
|
|
}
|
|
|
|
/*
|
|
* Search for a devinfo by deviceid. If one is found, return it after
|
|
* acquiring a reference count on it.
|
|
*/
|
|
struct nfscldevinfo *
|
|
nfscl_getdevinfo(struct nfsclclient *clp, uint8_t *deviceid,
|
|
struct nfscldevinfo *dip)
|
|
{
|
|
|
|
NFSLOCKCLSTATE();
|
|
if (dip == NULL)
|
|
dip = nfscl_finddevinfo(clp, deviceid);
|
|
if (dip != NULL)
|
|
dip->nfsdi_refcnt++;
|
|
NFSUNLOCKCLSTATE();
|
|
return (dip);
|
|
}
|
|
|
|
/*
|
|
* Dereference a devinfo structure.
|
|
*/
|
|
static void
|
|
nfscl_reldevinfo_locked(struct nfscldevinfo *dip)
|
|
{
|
|
|
|
dip->nfsdi_refcnt--;
|
|
if (dip->nfsdi_refcnt == 0)
|
|
wakeup(&dip->nfsdi_refcnt);
|
|
}
|
|
|
|
/*
|
|
* Dereference a devinfo structure.
|
|
*/
|
|
void
|
|
nfscl_reldevinfo(struct nfscldevinfo *dip)
|
|
{
|
|
|
|
NFSLOCKCLSTATE();
|
|
nfscl_reldevinfo_locked(dip);
|
|
NFSUNLOCKCLSTATE();
|
|
}
|
|
|
|
/*
|
|
* Find a layout for this file handle. Return NULL upon failure.
|
|
*/
|
|
static struct nfscllayout *
|
|
nfscl_findlayout(struct nfsclclient *clp, u_int8_t *fhp, int fhlen)
|
|
{
|
|
struct nfscllayout *lyp;
|
|
|
|
LIST_FOREACH(lyp, NFSCLLAYOUTHASH(clp, fhp, fhlen), nfsly_hash)
|
|
if (lyp->nfsly_fhlen == fhlen &&
|
|
!NFSBCMP(lyp->nfsly_fh, fhp, fhlen))
|
|
break;
|
|
return (lyp);
|
|
}
|
|
|
|
/*
|
|
* Find a devinfo for this deviceid. Return NULL upon failure.
|
|
*/
|
|
static struct nfscldevinfo *
|
|
nfscl_finddevinfo(struct nfsclclient *clp, uint8_t *deviceid)
|
|
{
|
|
struct nfscldevinfo *dip;
|
|
|
|
LIST_FOREACH(dip, &clp->nfsc_devinfo, nfsdi_list)
|
|
if (NFSBCMP(dip->nfsdi_deviceid, deviceid, NFSX_V4DEVICEID)
|
|
== 0)
|
|
break;
|
|
return (dip);
|
|
}
|
|
|
|
/*
|
|
* Merge the new file layout list into the main one, maintaining it in
|
|
* increasing offset order.
|
|
*/
|
|
static void
|
|
nfscl_mergeflayouts(struct nfsclflayouthead *fhlp,
|
|
struct nfsclflayouthead *newfhlp)
|
|
{
|
|
struct nfsclflayout *flp, *nflp, *prevflp, *tflp;
|
|
|
|
flp = LIST_FIRST(fhlp);
|
|
prevflp = NULL;
|
|
LIST_FOREACH_SAFE(nflp, newfhlp, nfsfl_list, tflp) {
|
|
while (flp != NULL && flp->nfsfl_off < nflp->nfsfl_off) {
|
|
prevflp = flp;
|
|
flp = LIST_NEXT(flp, nfsfl_list);
|
|
}
|
|
if (prevflp == NULL)
|
|
LIST_INSERT_HEAD(fhlp, nflp, nfsfl_list);
|
|
else
|
|
LIST_INSERT_AFTER(prevflp, nflp, nfsfl_list);
|
|
prevflp = nflp;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Add this nfscldevinfo to the client, if it doesn't already exist.
|
|
* This function consumes the structure pointed at by dip, if not NULL.
|
|
*/
|
|
APPLESTATIC int
|
|
nfscl_adddevinfo(struct nfsmount *nmp, struct nfscldevinfo *dip,
|
|
struct nfsclflayout *flp)
|
|
{
|
|
struct nfsclclient *clp;
|
|
struct nfscldevinfo *tdip;
|
|
|
|
NFSLOCKCLSTATE();
|
|
clp = nmp->nm_clp;
|
|
if (clp == NULL) {
|
|
NFSUNLOCKCLSTATE();
|
|
if (dip != NULL)
|
|
free(dip, M_NFSDEVINFO);
|
|
return (ENODEV);
|
|
}
|
|
tdip = nfscl_finddevinfo(clp, flp->nfsfl_dev);
|
|
if (tdip != NULL) {
|
|
tdip->nfsdi_layoutrefs++;
|
|
flp->nfsfl_devp = tdip;
|
|
nfscl_reldevinfo_locked(tdip);
|
|
NFSUNLOCKCLSTATE();
|
|
if (dip != NULL)
|
|
free(dip, M_NFSDEVINFO);
|
|
return (0);
|
|
}
|
|
if (dip != NULL) {
|
|
LIST_INSERT_HEAD(&clp->nfsc_devinfo, dip, nfsdi_list);
|
|
dip->nfsdi_layoutrefs = 1;
|
|
flp->nfsfl_devp = dip;
|
|
}
|
|
NFSUNLOCKCLSTATE();
|
|
if (dip == NULL)
|
|
return (ENODEV);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Free up a layout structure and associated file layout structure(s).
|
|
*/
|
|
APPLESTATIC void
|
|
nfscl_freelayout(struct nfscllayout *layp)
|
|
{
|
|
struct nfsclflayout *flp, *nflp;
|
|
struct nfsclrecalllayout *rp, *nrp;
|
|
|
|
LIST_FOREACH_SAFE(flp, &layp->nfsly_flayread, nfsfl_list, nflp) {
|
|
LIST_REMOVE(flp, nfsfl_list);
|
|
nfscl_freeflayout(flp);
|
|
}
|
|
LIST_FOREACH_SAFE(flp, &layp->nfsly_flayrw, nfsfl_list, nflp) {
|
|
LIST_REMOVE(flp, nfsfl_list);
|
|
nfscl_freeflayout(flp);
|
|
}
|
|
LIST_FOREACH_SAFE(rp, &layp->nfsly_recall, nfsrecly_list, nrp) {
|
|
LIST_REMOVE(rp, nfsrecly_list);
|
|
free(rp, M_NFSLAYRECALL);
|
|
}
|
|
nfscl_layoutcnt--;
|
|
free(layp, M_NFSLAYOUT);
|
|
}
|
|
|
|
/*
|
|
* Free up a file layout structure.
|
|
*/
|
|
APPLESTATIC void
|
|
nfscl_freeflayout(struct nfsclflayout *flp)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < flp->nfsfl_fhcnt; i++)
|
|
free(flp->nfsfl_fh[i], M_NFSFH);
|
|
if (flp->nfsfl_devp != NULL)
|
|
flp->nfsfl_devp->nfsdi_layoutrefs--;
|
|
free(flp, M_NFSFLAYOUT);
|
|
}
|
|
|
|
/*
|
|
* Free up a file layout devinfo structure.
|
|
*/
|
|
APPLESTATIC void
|
|
nfscl_freedevinfo(struct nfscldevinfo *dip)
|
|
{
|
|
|
|
free(dip, M_NFSDEVINFO);
|
|
}
|
|
|
|
/*
|
|
* Mark any layouts that match as recalled.
|
|
*/
|
|
static int
|
|
nfscl_layoutrecall(int recalltype, struct nfscllayout *lyp, uint32_t iomode,
|
|
uint64_t off, uint64_t len, uint32_t stateseqid,
|
|
struct nfsclrecalllayout *recallp)
|
|
{
|
|
struct nfsclrecalllayout *rp, *orp;
|
|
|
|
recallp->nfsrecly_recalltype = recalltype;
|
|
recallp->nfsrecly_iomode = iomode;
|
|
recallp->nfsrecly_stateseqid = stateseqid;
|
|
recallp->nfsrecly_off = off;
|
|
recallp->nfsrecly_len = len;
|
|
/*
|
|
* Order the list as file returns first, followed by fsid and any
|
|
* returns, both in increasing stateseqid order.
|
|
* Note that the seqids wrap around, so 1 is after 0xffffffff.
|
|
* (I'm not sure this is correct because I find RFC5661 confusing
|
|
* on this, but hopefully it will work ok.)
|
|
*/
|
|
orp = NULL;
|
|
LIST_FOREACH(rp, &lyp->nfsly_recall, nfsrecly_list) {
|
|
orp = rp;
|
|
if ((recalltype == NFSLAYOUTRETURN_FILE &&
|
|
(rp->nfsrecly_recalltype != NFSLAYOUTRETURN_FILE ||
|
|
nfscl_seq(stateseqid, rp->nfsrecly_stateseqid) != 0)) ||
|
|
(recalltype != NFSLAYOUTRETURN_FILE &&
|
|
rp->nfsrecly_recalltype != NFSLAYOUTRETURN_FILE &&
|
|
nfscl_seq(stateseqid, rp->nfsrecly_stateseqid) != 0)) {
|
|
LIST_INSERT_BEFORE(rp, recallp, nfsrecly_list);
|
|
break;
|
|
}
|
|
}
|
|
if (rp == NULL) {
|
|
if (orp == NULL)
|
|
LIST_INSERT_HEAD(&lyp->nfsly_recall, recallp,
|
|
nfsrecly_list);
|
|
else
|
|
LIST_INSERT_AFTER(orp, recallp, nfsrecly_list);
|
|
}
|
|
lyp->nfsly_flags |= NFSLY_RECALL;
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Compare the two seqids for ordering. The trick is that the seqids can
|
|
* wrap around from 0xffffffff->0, so check for the cases where one
|
|
* has wrapped around.
|
|
* Return 1 if seqid1 comes before seqid2, 0 otherwise.
|
|
*/
|
|
static int
|
|
nfscl_seq(uint32_t seqid1, uint32_t seqid2)
|
|
{
|
|
|
|
if (seqid2 > seqid1 && (seqid2 - seqid1) >= 0x7fffffff)
|
|
/* seqid2 has wrapped around. */
|
|
return (0);
|
|
if (seqid1 > seqid2 && (seqid1 - seqid2) >= 0x7fffffff)
|
|
/* seqid1 has wrapped around. */
|
|
return (1);
|
|
if (seqid1 <= seqid2)
|
|
return (1);
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Do a layout return for each of the recalls.
|
|
*/
|
|
static void
|
|
nfscl_layoutreturn(struct nfsmount *nmp, struct nfscllayout *lyp,
|
|
struct ucred *cred, NFSPROC_T *p)
|
|
{
|
|
struct nfsclrecalllayout *rp;
|
|
nfsv4stateid_t stateid;
|
|
|
|
NFSBCOPY(lyp->nfsly_stateid.other, stateid.other, NFSX_STATEIDOTHER);
|
|
LIST_FOREACH(rp, &lyp->nfsly_recall, nfsrecly_list) {
|
|
stateid.seqid = rp->nfsrecly_stateseqid;
|
|
(void)nfsrpc_layoutreturn(nmp, lyp->nfsly_fh,
|
|
lyp->nfsly_fhlen, 0, NFSLAYOUT_NFSV4_1_FILES,
|
|
rp->nfsrecly_iomode, rp->nfsrecly_recalltype,
|
|
rp->nfsrecly_off, rp->nfsrecly_len,
|
|
&stateid, 0, NULL, cred, p, NULL);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Do the layout commit for a file layout.
|
|
*/
|
|
static void
|
|
nfscl_dolayoutcommit(struct nfsmount *nmp, struct nfscllayout *lyp,
|
|
struct ucred *cred, NFSPROC_T *p)
|
|
{
|
|
struct nfsclflayout *flp;
|
|
uint64_t len;
|
|
int error;
|
|
|
|
LIST_FOREACH(flp, &lyp->nfsly_flayrw, nfsfl_list) {
|
|
if (flp->nfsfl_off <= lyp->nfsly_lastbyte) {
|
|
len = flp->nfsfl_end - flp->nfsfl_off;
|
|
error = nfsrpc_layoutcommit(nmp, lyp->nfsly_fh,
|
|
lyp->nfsly_fhlen, 0, flp->nfsfl_off, len,
|
|
lyp->nfsly_lastbyte, &lyp->nfsly_stateid,
|
|
NFSLAYOUT_NFSV4_1_FILES, 0, NULL, cred, p, NULL);
|
|
NFSCL_DEBUG(4, "layoutcommit err=%d\n", error);
|
|
if (error == NFSERR_NOTSUPP) {
|
|
/* If not supported, don't bother doing it. */
|
|
NFSLOCKMNT(nmp);
|
|
nmp->nm_state |= NFSSTA_NOLAYOUTCOMMIT;
|
|
NFSUNLOCKMNT(nmp);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Commit all layouts for a file (vnode).
|
|
*/
|
|
int
|
|
nfscl_layoutcommit(vnode_t vp, NFSPROC_T *p)
|
|
{
|
|
struct nfsclclient *clp;
|
|
struct nfscllayout *lyp;
|
|
struct nfsnode *np = VTONFS(vp);
|
|
mount_t mp;
|
|
struct nfsmount *nmp;
|
|
|
|
mp = vnode_mount(vp);
|
|
nmp = VFSTONFS(mp);
|
|
if (NFSHASNOLAYOUTCOMMIT(nmp))
|
|
return (0);
|
|
NFSLOCKCLSTATE();
|
|
clp = nmp->nm_clp;
|
|
if (clp == NULL) {
|
|
NFSUNLOCKCLSTATE();
|
|
return (EPERM);
|
|
}
|
|
lyp = nfscl_findlayout(clp, np->n_fhp->nfh_fh, np->n_fhp->nfh_len);
|
|
if (lyp == NULL) {
|
|
NFSUNLOCKCLSTATE();
|
|
return (EPERM);
|
|
}
|
|
nfsv4_getref(&lyp->nfsly_lock, NULL, NFSCLSTATEMUTEXPTR, mp);
|
|
if ((mp->mnt_kern_flag & MNTK_UNMOUNTF) != 0) {
|
|
NFSUNLOCKCLSTATE();
|
|
return (EPERM);
|
|
}
|
|
tryagain:
|
|
if ((lyp->nfsly_flags & NFSLY_WRITTEN) != 0) {
|
|
lyp->nfsly_flags &= ~NFSLY_WRITTEN;
|
|
NFSUNLOCKCLSTATE();
|
|
NFSCL_DEBUG(4, "do layoutcommit2\n");
|
|
nfscl_dolayoutcommit(clp->nfsc_nmp, lyp, NFSPROCCRED(p), p);
|
|
NFSLOCKCLSTATE();
|
|
goto tryagain;
|
|
}
|
|
nfsv4_relref(&lyp->nfsly_lock);
|
|
NFSUNLOCKCLSTATE();
|
|
return (0);
|
|
}
|
|
|