Attachment #23462 for bug #40360

View | Details | Raw Unified | Return to bug 40360
Collapse All | Expand All





struct nfs_args nfsdefargs = {
	NFS_ARGSVERSION,
	NULL,
	sizeof (struct sockaddr_in),
	SOCK_DGRAM,
	0,
	NULL,
	0,
	NFSMNT_RESVPORT,
	NFS_WSIZE,

	NFS_DEFRAHEAD,
	0,			/* was: NQ_DEFLEASE */
	NFS_MAXDEADTHRESH,	/* was: NQ_DEADTHRESH */
	NULL,
	/* args version 4 */
	NFS_MINATTRTIMO,
	NFS_MAXATTRTIMO,





	if (nmp->nm_flag & NFSMNT_INT) {
		bp = getblk(vp, bn, size, PCATCH, 0);
		while (bp == NULL) {
			if (nfs_sigintr(nmp, NULL, td))
				return(NULL);
			bp = getblk(vp, bn, size, 0, 2 * hz);
		}
	} else {

		error = tsleep((caddr_t)&np->n_flag, PRIBIO + 2, "nfsvinval",
			slptimeo);
		if (error && intrflg &&
		    nfs_sigintr(nmp, NULL, td))
			return (EINTR);
	}


	error = vinvalbuf(vp, flags, cred, td, slpflag, 0);
	while (error) {
		if (intrflg &&
		    nfs_sigintr(nmp, NULL, td)) {
			np->n_flag &= ~NFLUSHINPROG;
			if (np->n_flag & NFLUSHWANT) {
				np->n_flag &= ~NFLUSHWANT;

		 */
		NFS_DPF(ASYNCIO, ("nfs_asyncio: waking iod %d for mount %p\n",
		    iod, nmp));
		nfs_iodwant[iod] = NULL;
		nfs_iodmount[iod] = nmp;
		nmp->nm_bufqiods++;
		wakeup((caddr_t)&nfs_iodwant[iod]);

Lines 258-266 Link Here

(-)sys/nfsclient/nfs_nfsiod.c (-2 / +2 lines)
258	wakeup(&nmp->nm_bufq);	258	wakeup(&nmp->nm_bufq);
259	}	259	}
260	if (bp->b_iocmd == BIO_READ)	260	if (bp->b_iocmd == BIO_READ)
261	(void) nfs_doio(bp, bp->b_rcred, (struct thread *)0);	261	(void) nfs_doio(bp, bp->b_rcred, NULL);
262	else	262	else
263	(void) nfs_doio(bp, bp->b_wcred, (struct thread *)0);	263	(void) nfs_doio(bp, bp->b_wcred, NULL);
264	/*	264	/*
265	* If there are more than one iod on this mount, then defect	265	* If there are more than one iod on this mount, then defect
266	* so that the iods can be shared out fairly between the mounts	266	* so that the iods can be shared out fairly between the mounts

Lines 285-293 Link Here

(-)sys/nfsclient/nfs_node.c (-3 / +3 lines)
285	vprint("nfs_inactive: pushing active", ap->a_vp);	285	vprint("nfs_inactive: pushing active", ap->a_vp);
286	if (ap->a_vp->v_type != VDIR) {	286	if (ap->a_vp->v_type != VDIR) {
287	sp = np->n_sillyrename;	287	sp = np->n_sillyrename;
288	np->n_sillyrename = (struct sillyrename *)0;	288	np->n_sillyrename = NULL;
289	} else	289	} else
290	sp = (struct sillyrename *)0;	290	sp = NULL;
291	if (sp) {	291	if (sp) {
292	/*	292	/*
293	* We need a reference to keep the vnode from being	293	* We need a reference to keep the vnode from being
Lines 354-359 Link Here
354		354
355	cache_purge(vp);	355	cache_purge(vp);
356	uma_zfree(nfsnode_zone, vp->v_data);	356	uma_zfree(nfsnode_zone, vp->v_data);
357	vp->v_data = (void *)0;	357	vp->v_data = NULL;
358	return (0);	358	return (0);
359	}	359	}




	struct sockaddr_in *sin;
	struct thread *td = &thread0; /* only used for socreate and sobind */

	nmp->nm_so = NULL;
	saddr = nmp->nm_nam;
	error = socreate(saddr->sa_family, &nmp->nm_so, nmp->nm_sotype,
		nmp->nm_soproto, nmp->nm_cred, td);


	if (nmp->nm_so) {
		so = nmp->nm_so;
		nmp->nm_so = NULL;
		soshutdown(so, 2);
		soclose(so);
	}

	soflags = rep->r_nmp->nm_soflags;

	if ((soflags & PR_CONNREQUIRED) || (so->so_state & SS_ISCONNECTED))
		sendnam = NULL;
	else
		sendnam = nam;
	if (so->so_type == SOCK_SEQPACKET)

	/*
	 * Set up arguments for soreceive()
	 */
	*mp = NULL;
	*aname = NULL;
	sotype = rep->r_nmp->nm_sotype;

	/*

			do {
			   rcvflg = MSG_WAITALL;
			   error = so->so_proto->pr_usrreqs->pru_soreceive
				   (so, NULL, &auio, NULL, NULL, &rcvflg);
				    (struct mbuf **)0, (struct mbuf **)0,
				    &rcvflg);
			   if (error == EWOULDBLOCK && rep) {
				if (rep->r_flags & R_SOFTTERM)
					return (EINTR);

			do {
			    rcvflg = MSG_WAITALL;
			    error =  so->so_proto->pr_usrreqs->pru_soreceive
				    (so, NULL,
				     &auio, mp, NULL, &rcvflg);
			} while (error == EWOULDBLOCK || error == EINTR ||
				 error == ERESTART);
			if (!error && auio.uio_resid > 0) {

			do {
			    rcvflg = 0;
			    error =  so->so_proto->pr_usrreqs->pru_soreceive
				    (so, NULL,
				&auio, mp, &control, &rcvflg);
			    if (control)
				m_freem(control);

errout:
		if (error && error != EINTR && error != ERESTART) {
			m_freem(*mp);
			*mp = NULL;
			if (error != EPIPE)
				log(LOG_INFO,
				    "receive error %d from nfs server %s\n",

		if ((so = rep->r_nmp->nm_so) == NULL)
			return (EACCES);
		if (so->so_state & SS_ISCONNECTED)
			getnam = NULL;
		else
			getnam = aname;
		auio.uio_resid = len = 1000000;

			rcvflg = 0;
			error =  so->so_proto->pr_usrreqs->pru_soreceive
				(so, getnam, &auio, mp,
				NULL, &rcvflg);
			if (error == EWOULDBLOCK &&
			    (rep->r_flags & R_SOFTTERM))
				return (EINTR);

	}
	if (error) {
		m_freem(*mp);
		*mp = NULL;
	}
	/*
	 * Search for any mbufs that are not a multiple of 4 bytes long

		   (m = m_copym(rep->r_mreq, 0, M_COPYALL, M_DONTWAIT))){
			if ((nmp->nm_flag & NFSMNT_NOCONN) == 0)
			    error = (*so->so_proto->pr_usrreqs->pru_send)
				    (so, 0, m, NULL,
				     NULL, td);
			else
			    error = (*so->so_proto->pr_usrreqs->pru_send)
				    (so, 0, m, nmp->nm_nam, NULL,
				     td);
			if (error) {
				if (NFSIGNORE_SOERROR(nmp->nm_soflags, error))

		}
	}
	splx(s);
	nfs_timer_handle = timeout(nfs_timer, NULL, nfs_ticks);
}

/*

		if (rep->r_nmp->nm_flag & NFSMNT_INT)
			slpflag = PCATCH;
	} else
		td = NULL;
	while (*statep & NFSSTA_SNDLOCK) {
		if (nfs_sigintr(rep->r_nmp, rep, td))
			return (EINTR);




	*tl = 0;
	mb->m_next = mrest;
	mreq->m_pkthdr.len = authsiz + 10 * NFSX_UNSIGNED + mrest_len;
	mreq->m_pkthdr.rcvif = NULL;
	*mbp = mb;
	return (mreq);
}

		nfs_ticks = 1;
	/* Ensure async daemons disabled */
	for (i = 0; i < NFS_MAXASYNCDAEMON; i++) {
		nfs_iodwant[i] = NULL;
		nfs_iodmount[i] = NULL;
	}
	nfs_nhinit();			/* Init the nfsnode table */


			dp->ndm_eocookie = 0;
			LIST_INSERT_HEAD(&np->n_cookies, dp, ndm_list);
		} else
			return (NULL);
	}
	while (pos >= NFSNUMCOOKIES) {
		pos -= NFSNUMCOOKIES;
		if (LIST_NEXT(dp, ndm_list)) {
			if (!add && dp->ndm_eocookie < NFSNUMCOOKIES &&
				pos >= dp->ndm_eocookie)
				return (NULL);
			dp = LIST_NEXT(dp, ndm_list);
		} else if (add) {
			MALLOC(dp2, struct nfsdmap *, sizeof (struct nfsdmap),

			LIST_INSERT_AFTER(dp, dp2, ndm_list);
			dp = dp2;
		} else
			return (NULL);
	}
	if (pos >= dp->ndm_eocookie) {
		if (add)
			dp->ndm_eocookie = pos + 1;
		else
			return (NULL);
	}
	return (&dp->ndm_cookies[pos]);
}

	}
	if (*f) {
		ttvp = *v;
		t1 = nfs_loadattrcache(&ttvp, md, dpos, NULL, 0);
		if (t1)
			return t1;
		*v = ttvp;

		return EBADRPC;
	*f = fxdr_unsigned(int, *tl);
	if (*f != 0) {
		t1 = nfs_loadattrcache(&ttvp, md, dpos, NULL, 1);
		if (t1 != 0) {
			*f = 0;
			return t1;




	u_quad_t tquad;

#ifndef nolint
	sfp = NULL;
#endif
	error = nfs_nget(mp, (nfsfh_t *)nmp->nm_fh, nmp->nm_fhsize, &np);
	if (error)

		error = rtrequest(RTM_ADD, (struct sockaddr *)&sin,
		    (struct sockaddr *)&nd->mygateway,
		    (struct sockaddr *)&mask,
		    RTF_UP | RTF_GATEWAY, NULL);
		if (error)
			panic("nfs_mountroot: RTM_ADD: %d", error);
	}

	if (nmp->nm_so && adjsock) {
		nfs_safedisconnect(nmp);
		if (nmp->nm_sotype == SOCK_DGRAM)
			while (nfs_connect(nmp, NULL)) {
				printf("nfs_args: retrying connect\n");
				(void) tsleep((caddr_t)&lbolt,
					      PSOCK, "nfscon", 0);

	 * the first request, in case the server is not responding.
	 */
	if (nmp->nm_sotype == SOCK_DGRAM &&
		(error = nfs_connect(nmp, NULL)))
		goto bad;

	/*




	if (v3) {
		nfsm_wcc_data(vp, wccflag);
	} else
		nfsm_loadattr(vp, NULL);
	m_freem(mrep);
nfsmout:
	return (error);

			nfsm_postop_attr(newvp, attrflag);
			nfsm_postop_attr(dvp, attrflag);
		} else
			nfsm_loadattr(newvp, NULL);
		*vpp = newvp;
		m_freem(mrep);
		cnp->cn_flags |= SAVENAME;

		nfsm_postop_attr(newvp, attrflag);
		nfsm_postop_attr(dvp, attrflag);
	} else
		nfsm_loadattr(newvp, NULL);
	if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
		cnp->cn_flags |= SAVENAME;
	if ((cnp->cn_flags & MAKEENTRY) &&

			tl = nfsm_dissect(u_int32_t *, 2 * NFSX_UNSIGNED);
			eof = fxdr_unsigned(int, *(tl + 1));
		} else
			nfsm_loadattr(vp, NULL);
		nfsm_strsiz(retlen, nmp->nm_rsize);
		nfsm_mtouio(uiop, retlen);
		m_freem(mrep);

				}
			}
		} else
		    nfsm_loadattr(vp, NULL);
		if (wccflag)
		    VTONFS(vp)->n_mtime = VTONFS(vp)->n_vattr.va_mtime.tv_sec;
		m_freem(mrep);

{
	struct nfsv2_sattr *sp;
	u_int32_t *tl;
	struct vnode *newvp = NULL;
	struct nfsnode *np = NULL;
	struct vattr vattr;
	caddr_t bpos, dpos;
	int error = 0, wccflag = NFSV3_WCCRATTR, gotvp = 0;

		if (!gotvp) {
			if (newvp) {
				vput(newvp);
				newvp = NULL;
			}
			error = nfs_lookitup(dvp, cnp->cn_nameptr,
			    cnp->cn_namelen, cnp->cn_cred, cnp->cn_thread, &np);

	struct componentname *cnp = ap->a_cnp;
	struct nfsv2_sattr *sp;
	u_int32_t *tl;
	struct nfsnode *np = NULL;
	struct vnode *newvp = NULL;
	caddr_t bpos, dpos;
	int error = 0, wccflag = NFSV3_WCCRATTR, gotvp = 0, fmode = 0;
	struct mbuf *mreq, *mrep, *md, *mb;

		if (!gotvp) {
			if (newvp) {
				vput(newvp);
				newvp = NULL;
			}
			error = nfs_lookitup(dvp, cnp->cn_nameptr,
			    cnp->cn_namelen, cnp->cn_cred, cnp->cn_thread, &np);

{

	return (nfs_removerpc(sp->s_dvp, sp->s_name, sp->s_namlen, sp->s_cred,
		NULL));
}

/*

	caddr_t bpos, dpos;
	int slen, error = 0, wccflag = NFSV3_WCCRATTR, gotvp;
	struct mbuf *mreq, *mrep, *md, *mb;
	struct vnode *newvp = NULL;
	int v3 = NFS_ISV3(dvp);

	nfsstats.rpccnt[NFSPROC_SYMLINK]++;

	struct componentname *cnp = ap->a_cnp;
	struct nfsv2_sattr *sp;
	int len;
	struct nfsnode *np = NULL;
	struct vnode *newvp = NULL;
	caddr_t bpos, dpos;
	int error = 0, wccflag = NFSV3_WCCRATTR;
	int gotvp = 0;

	if (error == EEXIST || (!error && !gotvp)) {
		if (newvp) {
			vrele(newvp);
			newvp = NULL;
		}
		error = nfs_lookitup(dvp, cnp->cn_nameptr, len, cnp->cn_cred,
			cnp->cn_thread, &np);

	int attrflag, fhsize;

#ifndef nolint
	dp = NULL;
#endif
#ifndef DIAGNOSTIC
	if (uiop->uio_iovcnt != 1 || (uiop->uio_offset & (DIRBLKSIZ - 1)) ||

				dpos = dpossav1;
				mdsav2 = md;
				md = mdsav1;
				nfsm_loadattr(newvp, NULL);
				dpos = dpossav2;
				md = mdsav2;
				dp->d_type =


	/* Try lookitups until we get one that isn't there */
	while (nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred,
		cnp->cn_thread, NULL) == 0) {
		sp->s_name[4]++;
		if (sp->s_name[4] > 'z') {
			error = EINVAL;

nfs_lookitup(struct vnode *dvp, const char *name, int len, struct ucred *cred,
    struct thread *td, struct nfsnode **npp)
{
	struct vnode *newvp = NULL;
	struct nfsnode *np, *dnp = VTONFS(dvp);
	caddr_t bpos, dpos;
	int error = 0, fhlen, attrflag;

				return (ENOENT);
			}
		} else
			nfsm_loadattr(newvp, NULL);
	}
	m_freem(mrep);
nfsmout:

		panic("nfs physio");

	if (bp->b_flags & B_ASYNC)
		td = NULL;
	else
		td = curthread;	/* XXX */


				panic("nfs_fsync: inconsistent lock");
			if (error == ENOLCK)
				goto loop;
			if (nfs_sigintr(nmp, NULL, td)) {
				error = EINTR;
				goto done;
			}

			error = tsleep((caddr_t)&vp->v_numoutput,
				slpflag | (PRIBIO + 1), "nfsfsync", slptimeo);
			if (error) {
			    if (nfs_sigintr(nmp, NULL, td)) {
				error = EINTR;
				goto done;
			    }




	error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly, TRUE);
	if (error) {
		nfsm_reply(NFSX_UNSIGNED);
		nfsm_srvpostop_attr(1, NULL);
		error = 0;
		goto nfsmout;
	}


	nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
#ifndef nolint
	mp = NULL;
#endif
	mp3 = NULL;
	fhp = &nfh.fh_generic;

	uiop->uio_resid = len;
	uiop->uio_rw = UIO_READ;
	uiop->uio_segflg = UIO_SYSSPACE;
	uiop->uio_td = NULL;
	error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly, TRUE);
	if (error) {
		nfsm_reply(2 * NFSX_UNSIGNED);
		if (v3)
			nfsm_srvpostop_attr(1, NULL);
		error = 0;
		goto nfsmout;
	}

		vp = NULL;
		nfsm_reply(2 * NFSX_UNSIGNED);
		if (v3)
			nfsm_srvpostop_attr(1, NULL);
		error = 0;
		goto nfsmout;
	}

	    uiop->uio_resid = len;
	    uiop->uio_rw = UIO_WRITE;
	    uiop->uio_segflg = UIO_SYSSPACE;
	    uiop->uio_td = NULL;
	    uiop->uio_offset = off;
	    error = VOP_WRITE(vp, uiop, ioflags, cred);
	    nfsrvstats.srvvop_writes++;

		    ioflags = (IO_METASYNC | IO_SYNC | IO_NODELOCKED);
		uiop->uio_rw = UIO_WRITE;
		uiop->uio_segflg = UIO_SYSSPACE;
		uiop->uio_td = NULL;
		uiop->uio_offset = nfsd->nd_off;
		uiop->uio_resid = nfsd->nd_eoff - nfsd->nd_off;
		if (uiop->uio_resid > 0) {

	int v3 = (nfsd->nd_flag & ND_NFSV3), how, exclusive_flag = 0;
	caddr_t cp;
	struct mbuf *mb, *mreq;
	struct vnode *dirp = NULL;
	nfsfh_t nfh;
	fhandle_t *fhp;
	u_quad_t tempsize;

	u_int32_t major, minor;
	enum vtype vtyp;
	struct mbuf *mb, *mreq;
	struct vnode *vp, *dirp = NULL;
	nfsfh_t nfh;
	fhandle_t *fhp;
	struct mount *mp = NULL;

	int v3 = (nfsd->nd_flag & ND_NFSV3);
	struct mbuf *mb, *mreq;
	struct nameidata fromnd, tond;
	struct vnode *fvp, *tvp, *tdvp, *fdirp = NULL;
	struct vnode *tdirp = NULL;
	struct vattr fdirfor, fdiraft, tdirfor, tdiraft;
	nfsfh_t fnfh, tnfh;
	fhandle_t *ffhp, *tfhp;


	nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
#ifndef nolint
	fvp = NULL;
#endif
	ffhp = &fnfh.fh_generic;
	tfhp = &tnfh.fh_generic;

	int error = 0, rdonly, len, dirfor_ret = 1, diraft_ret = 1;
	int getret = 1, v3 = (nfsd->nd_flag & ND_NFSV3);
	struct mbuf *mb, *mreq;
	struct vnode *vp = NULL, *xp, *dirp = NULL;
	struct vattr dirfor, diraft, at;
	nfsfh_t nfh, dnfh;
	fhandle_t *fhp, *dfhp;

	struct nameidata nd;
	struct vattr *vap = &va;
	struct nfsv2_sattr *sp;
	char *bpos, *pathcp = NULL;
	struct uio io;
	struct iovec iv;
	int error = 0, len, len2, dirfor_ret = 1, diraft_ret = 1;
	int v3 = (nfsd->nd_flag & ND_NFSV3);
	struct mbuf *mb, *mreq;
	struct vnode *dirp = NULL;
	nfsfh_t nfh;
	fhandle_t *fhp;
	struct mount *mp = NULL;

	io.uio_iovcnt = 1;
	io.uio_segflg = UIO_SYSSPACE;
	io.uio_rw = UIO_READ;
	io.uio_td = NULL;
	nfsm_mtouio(&io, len2);
	if (!v3) {
		sp = nfsm_dissect(struct nfsv2_sattr *, NFSX_V2SATTR);

	int error = 0, len, dirfor_ret = 1, diraft_ret = 1;
	int v3 = (nfsd->nd_flag & ND_NFSV3);
	struct mbuf *mb, *mreq;
	struct vnode *vp, *dirp = NULL;
	struct vattr dirfor, diraft;
	nfsfh_t nfh;
	fhandle_t *fhp;

	io.uio_resid = fullsiz;
	io.uio_segflg = UIO_SYSSPACE;
	io.uio_rw = UIO_READ;
	io.uio_td = NULL;
	eofflag = 0;
	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
	if (cookies) {

	io.uio_resid = fullsiz;
	io.uio_segflg = UIO_SYSSPACE;
	io.uio_rw = UIO_READ;
	io.uio_td = NULL;
	eofflag = 0;
	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
	if (cookies) {




		auio.uio_resid = 1000000000;
		flags = MSG_DONTWAIT;
		error = so->so_proto->pr_usrreqs->pru_soreceive
			(so, &nam, &auio, &mp, NULL, &flags);
		if (error || mp == NULL) {
			if (error == EWOULDBLOCK)
				slp->ns_flag |= SLP_NEEDQ;
			else

			flags = MSG_DONTWAIT;
			error = so->so_proto->pr_usrreqs->pru_soreceive
				(so, &nam, &auio, &mp,
						NULL, &flags);
			if (mp) {
				struct nfsrv_rec *rec;
				rec = malloc(sizeof(struct nfsrv_rec),

	     */
	    if (slp->ns_cc == slp->ns_reclen) {
		recm = slp->ns_raw;
		slp->ns_raw = slp->ns_rawend = NULL;
		slp->ns_cc = slp->ns_reclen = 0;
	    } else if (slp->ns_cc > slp->ns_reclen) {
		len = 0;
		m = slp->ns_raw;
		om = NULL;
		while (len < slp->ns_reclen) {
			if ((len + m->m_len) > slp->ns_reclen) {
				m2 = m_copym(m, 0, slp->ns_reclen - len,

				len += m->m_len;
				m = m->m_next;
				recm = slp->ns_raw;
				om->m_next = NULL;
			} else {
				om = m;
				len += m->m_len;

		    m_freem(slp->ns_frag);
		} else {
		    nfs_realign(&slp->ns_frag, 10 * NFSX_UNSIGNED);
		    rec->nr_address = NULL;
		    rec->nr_packet = slp->ns_frag;
		    STAILQ_INSERT_TAIL(&slp->ns_rec, rec, nr_link);
		}
		slp->ns_frag = NULL;
	    }
	}
}


	soflags = so->so_proto->pr_flags;
	if ((soflags & PR_CONNREQUIRED) || (so->so_state & SS_ISCONNECTED))
		sendnam = NULL;
	else
		sendnam = nam;
	if (so->so_type == SOCK_SEQPACKET)

			nfsrv_wakenfsd(slp);
	}
	splx(s);
	nfsrv_timer_handle = timeout(nfsrv_timer, NULL, nfsrv_ticks);
}




	int error, rdonly, linklen;
	struct componentname *cnp = &ndp->ni_cnd;

	*retdirp = NULL;
	cnp->cn_pnbuf = uma_zalloc(namei_zone, M_WAITOK);

	/*

		auio.uio_offset = 0;
		auio.uio_rw = UIO_READ;
		auio.uio_segflg = UIO_SYSSPACE;
		auio.uio_td = NULL;
		auio.uio_resid = MAXPATHLEN;
		error = VOP_READLINK(ndp->ni_vp, &auio, cnp->cn_cred);
		if (error) {

	m = mp;
	for (;;) {
		count += m->m_len;
		if (m->m_next == NULL)
			break;
		m = m->m_next;
	}

	struct sockaddr_int *saddr;
#endif

	*vpp = NULL;

	if (nfs_ispublicfh(fhp)) {
		if (!pubflag || !nfs_pub.np_valid)




		 * Get the client address for connected sockets.
		 */
		if (nfsdarg.name == NULL || nfsdarg.namelen == 0)
			nam = NULL;
		else {
			error = getsockaddr(&nam, nfsdarg.name,
					    nfsdarg.namelen);


	so = (struct socket *)fp->f_data;
#if 0
	tslp = NULL;
	/*
	 * Add it to the list, as required.
	 */

	cacherep = RC_DOIT;
	writes_todo = 0;
#endif
	if (nfsd == NULL) {
		nsd->nsd_nfsd = nfsd = (struct nfsd *)
			malloc(sizeof (struct nfsd), M_NFSD, M_WAITOK | M_ZERO);
		s = splnet();

	 */
	for (;;) {
		if ((nfsd->nfsd_flag & NFSD_REQINPROG) == 0) {
			while (nfsd->nfsd_slp == NULL &&
			    (nfsd_head_flag & NFSD_CHECKSLP) == 0) {
				nfsd->nfsd_flag |= NFSD_WAITING;
				nfsd_waiting++;

				if (error)
					goto done;
			}
			if (nfsd->nfsd_slp == NULL &&
			    (nfsd_head_flag & NFSD_CHECKSLP) != 0) {
				TAILQ_FOREACH(slp, &nfssvc_sockhead, ns_chain) {
				    if ((slp->ns_flag & (SLP_VALID | SLP_DOREC))

				if (slp == 0)
					nfsd_head_flag &= ~NFSD_CHECKSLP;
			}
			if ((slp = nfsd->nfsd_slp) == NULL)
				continue;
			if (slp->ns_flag & SLP_VALID) {
				if (slp->ns_flag & SLP_DISCONN)

				free((caddr_t)nd, M_NFSRVDESC);
				nd = NULL;
			}
			nfsd->nfsd_slp = NULL;
			nfsd->nfsd_flag &= ~NFSD_REQINPROG;
			nfsrv_slpderef(slp);
			continue;

			}
			nfsrvstats.srvrpccnt[nd->nd_procnum]++;
			nfsrv_updatecache(nd, TRUE, mreq);
			nd->nd_mrep = NULL;
		    case RC_REPLY:
			m = mreq;
			siz = 0;

			}
			m = mreq;
			m->m_pkthdr.len = siz;
			m->m_pkthdr.rcvif = NULL;
			/*
			 * For stream protocols, prepend a Sun RPC
			 * Record Mark.

	TAILQ_REMOVE(&nfsd_head, nfsd, nfsd_chain);
	splx(s);
	free((caddr_t)nfsd, M_NFSD);
	nsd->nsd_nfsd = NULL;
	if (--nfs_numnfsd == 0)
		nfsrv_init(TRUE);	/* Reinitialize everything */
	return (error);

	slp->ns_flag &= ~SLP_ALLFLAGS;
	fp = slp->ns_fp;
	if (fp) {
		slp->ns_fp = NULL;
		so = slp->ns_so;
		so->so_rcv.sb_flags &= ~SB_UPCALL;
		so->so_upcall = NULL;
		so->so_upcallarg = NULL;
		soshutdown(so, 2);
		closef(fp, NULL);
		if (slp->ns_nam)
			FREE(slp->ns_nam, M_SONAME);
		m_freem(slp->ns_raw);

Return to bug 40360

Lines 125-135 Link Here

(-)sbin/mount_nfs/mount_nfs.c (-3 / +3 lines)
125		125
126	struct nfs_args nfsdefargs = {	126	struct nfs_args nfsdefargs = {
127	NFS_ARGSVERSION,	127	NFS_ARGSVERSION,
128	(struct sockaddr *)0,	128	NULL,
129	sizeof (struct sockaddr_in),	129	sizeof (struct sockaddr_in),
130	SOCK_DGRAM,	130	SOCK_DGRAM,
131	0,	131	0,
132	(u_char *)0,	132	NULL,
133	0,	133	0,
134	NFSMNT_RESVPORT,	134	NFSMNT_RESVPORT,
135	NFS_WSIZE,	135	NFS_WSIZE,
Lines 141-147 Link Here
141	NFS_DEFRAHEAD,	141	NFS_DEFRAHEAD,
142	0, /* was: NQ_DEFLEASE */	142	0, /* was: NQ_DEFLEASE */
143	NFS_MAXDEADTHRESH, /* was: NQ_DEADTHRESH */	143	NFS_MAXDEADTHRESH, /* was: NQ_DEADTHRESH */
144	(char *)0,	144	NULL,
145	/* args version 4 */	145	/* args version 4 */
146	NFS_MINATTRTIMO,	146	NFS_MINATTRTIMO,
147	NFS_MAXATTRTIMO,	147	NFS_MAXATTRTIMO,

Lines 1025-1033 Link Here

(-)sys/nfsclient/nfs_bio.c (-6 / +6 lines)
1025		1025
1026	if (nmp->nm_flag & NFSMNT_INT) {	1026	if (nmp->nm_flag & NFSMNT_INT) {
1027	bp = getblk(vp, bn, size, PCATCH, 0);	1027	bp = getblk(vp, bn, size, PCATCH, 0);
1028	while (bp == (struct buf *)0) {	1028	while (bp == NULL) {
1029	if (nfs_sigintr(nmp, (struct nfsreq *)0, td))	1029	if (nfs_sigintr(nmp, NULL, td))
1030	return ((struct buf *)0);	1030	return(NULL);
1031	bp = getblk(vp, bn, size, 0, 2 * hz);	1031	bp = getblk(vp, bn, size, 0, 2 * hz);
1032	}	1032	}
1033	} else {	1033	} else {
Lines 1076-1082 Link Here
1076	error = tsleep((caddr_t)&np->n_flag, PRIBIO + 2, "nfsvinval",	1076	error = tsleep((caddr_t)&np->n_flag, PRIBIO + 2, "nfsvinval",
1077	slptimeo);	1077	slptimeo);
1078	if (error && intrflg &&	1078	if (error && intrflg &&
1079	nfs_sigintr(nmp, (struct nfsreq *)0, td))	1079	nfs_sigintr(nmp, NULL, td))
1080	return (EINTR);	1080	return (EINTR);
1081	}	1081	}
1082		1082
Lines 1087-1093 Link Here
1087	error = vinvalbuf(vp, flags, cred, td, slpflag, 0);	1087	error = vinvalbuf(vp, flags, cred, td, slpflag, 0);
1088	while (error) {	1088	while (error) {
1089	if (intrflg &&	1089	if (intrflg &&
1090	nfs_sigintr(nmp, (struct nfsreq *)0, td)) {	1090	nfs_sigintr(nmp, NULL, td)) {
1091	np->n_flag &= ~NFLUSHINPROG;	1091	np->n_flag &= ~NFLUSHINPROG;
1092	if (np->n_flag & NFLUSHWANT) {	1092	if (np->n_flag & NFLUSHWANT) {
1093	np->n_flag &= ~NFLUSHWANT;	1093	np->n_flag &= ~NFLUSHWANT;
Lines 1165-1171 Link Here
1165	*/	1165	*/
1166	NFS_DPF(ASYNCIO, ("nfs_asyncio: waking iod %d for mount %p\n",	1166	NFS_DPF(ASYNCIO, ("nfs_asyncio: waking iod %d for mount %p\n",
1167	iod, nmp));	1167	iod, nmp));
1168	nfs_iodwant[iod] = (struct proc *)0;	1168	nfs_iodwant[iod] = NULL;
1169	nfs_iodmount[iod] = nmp;	1169	nfs_iodmount[iod] = nmp;
1170	nmp->nm_bufqiods++;	1170	nmp->nm_bufqiods++;
1171	wakeup((caddr_t)&nfs_iodwant[iod]);	1171	wakeup((caddr_t)&nfs_iodwant[iod]);

Lines 160-166 Link Here

(-)sys/nfsclient/nfs_socket.c (-20 / +18 lines)
160	struct sockaddr_in *sin;	160	struct sockaddr_in *sin;
161	struct thread td = &thread0; / only used for socreate and sobind */	161	struct thread td = &thread0; / only used for socreate and sobind */
162		162
163	nmp->nm_so = (struct socket *)0;	163	nmp->nm_so = NULL;
164	saddr = nmp->nm_nam;	164	saddr = nmp->nm_nam;
165	error = socreate(saddr->sa_family, &nmp->nm_so, nmp->nm_sotype,	165	error = socreate(saddr->sa_family, &nmp->nm_so, nmp->nm_sotype,
166	nmp->nm_soproto, nmp->nm_cred, td);	166	nmp->nm_soproto, nmp->nm_cred, td);
Lines 367-373 Link Here
367		367
368	if (nmp->nm_so) {	368	if (nmp->nm_so) {
369	so = nmp->nm_so;	369	so = nmp->nm_so;
370	nmp->nm_so = (struct socket *)0;	370	nmp->nm_so = NULL;
371	soshutdown(so, 2);	371	soshutdown(so, 2);
372	soclose(so);	372	soclose(so);
373	}	373	}
Lines 414-420 Link Here
414	soflags = rep->r_nmp->nm_soflags;	414	soflags = rep->r_nmp->nm_soflags;
415		415
416	if ((soflags & PR_CONNREQUIRED) \|\| (so->so_state & SS_ISCONNECTED))	416	if ((soflags & PR_CONNREQUIRED) \|\| (so->so_state & SS_ISCONNECTED))
417	sendnam = (struct sockaddr *)0;	417	sendnam = NULL;
418	else	418	else
419	sendnam = nam;	419	sendnam = nam;
420	if (so->so_type == SOCK_SEQPACKET)	420	if (so->so_type == SOCK_SEQPACKET)
Lines 475-482 Link Here
475	/*	475	/*
476	* Set up arguments for soreceive()	476	* Set up arguments for soreceive()
477	*/	477	*/
478	mp = (struct mbuf )0;	478	*mp = NULL;
479	aname = (struct sockaddr )0;	479	*aname = NULL;
480	sotype = rep->r_nmp->nm_sotype;	480	sotype = rep->r_nmp->nm_sotype;
481		481
482	/*	482	/*
Lines 541-549 Link Here
541	do {	541	do {
542	rcvflg = MSG_WAITALL;	542	rcvflg = MSG_WAITALL;
543	error = so->so_proto->pr_usrreqs->pru_soreceive	543	error = so->so_proto->pr_usrreqs->pru_soreceive
544	(so, (struct sockaddr **)0, &auio,	544	(so, NULL, &auio, NULL, NULL, &rcvflg);
545	(struct mbuf )0, (struct mbuf )0,
546	&rcvflg);
547	if (error == EWOULDBLOCK && rep) {	545	if (error == EWOULDBLOCK && rep) {
548	if (rep->r_flags & R_SOFTTERM)	546	if (rep->r_flags & R_SOFTTERM)
549	return (EINTR);	547	return (EINTR);
Lines 583-590 Link Here
583	do {	581	do {
584	rcvflg = MSG_WAITALL;	582	rcvflg = MSG_WAITALL;
585	error = so->so_proto->pr_usrreqs->pru_soreceive	583	error = so->so_proto->pr_usrreqs->pru_soreceive
586	(so, (struct sockaddr **)0,	584	(so, NULL,
587	&auio, mp, (struct mbuf **)0, &rcvflg);	585	&auio, mp, NULL, &rcvflg);
588	} while (error == EWOULDBLOCK \|\| error == EINTR \|\|	586	} while (error == EWOULDBLOCK \|\| error == EINTR \|\|
589	error == ERESTART);	587	error == ERESTART);
590	if (!error && auio.uio_resid > 0) {	588	if (!error && auio.uio_resid > 0) {
Lines 609-615 Link Here
609	do {	607	do {
610	rcvflg = 0;	608	rcvflg = 0;
611	error = so->so_proto->pr_usrreqs->pru_soreceive	609	error = so->so_proto->pr_usrreqs->pru_soreceive
612	(so, (struct sockaddr **)0,	610	(so, NULL,
613	&auio, mp, &control, &rcvflg);	611	&auio, mp, &control, &rcvflg);
614	if (control)	612	if (control)
615	m_freem(control);	613	m_freem(control);
Lines 628-634 Link Here
628	errout:	626	errout:
629	if (error && error != EINTR && error != ERESTART) {	627	if (error && error != EINTR && error != ERESTART) {
630	m_freem(*mp);	628	m_freem(*mp);
631	mp = (struct mbuf )0;	629	*mp = NULL;
632	if (error != EPIPE)	630	if (error != EPIPE)
633	log(LOG_INFO,	631	log(LOG_INFO,
634	"receive error %d from nfs server %s\n",	632	"receive error %d from nfs server %s\n",
Lines 646-652 Link Here
646	if ((so = rep->r_nmp->nm_so) == NULL)	644	if ((so = rep->r_nmp->nm_so) == NULL)
647	return (EACCES);	645	return (EACCES);
648	if (so->so_state & SS_ISCONNECTED)	646	if (so->so_state & SS_ISCONNECTED)
649	getnam = (struct sockaddr **)0;	647	getnam = NULL;
650	else	648	else
651	getnam = aname;	649	getnam = aname;
652	auio.uio_resid = len = 1000000;	650	auio.uio_resid = len = 1000000;
Lines 655-661 Link Here
655	rcvflg = 0;	653	rcvflg = 0;
656	error = so->so_proto->pr_usrreqs->pru_soreceive	654	error = so->so_proto->pr_usrreqs->pru_soreceive
657	(so, getnam, &auio, mp,	655	(so, getnam, &auio, mp,
658	(struct mbuf **)0, &rcvflg);	656	NULL, &rcvflg);
659	if (error == EWOULDBLOCK &&	657	if (error == EWOULDBLOCK &&
660	(rep->r_flags & R_SOFTTERM))	658	(rep->r_flags & R_SOFTTERM))
661	return (EINTR);	659	return (EINTR);
Lines 664-670 Link Here
664	}	662	}
665	if (error) {	663	if (error) {
666	m_freem(*mp);	664	m_freem(*mp);
667	mp = (struct mbuf )0;	665	*mp = NULL;
668	}	666	}
669	/*	667	/*
670	* Search for any mbufs that are not a multiple of 4 bytes long	668	* Search for any mbufs that are not a multiple of 4 bytes long
Lines 1130-1140 Link Here
1130	(m = m_copym(rep->r_mreq, 0, M_COPYALL, M_DONTWAIT))){	1128	(m = m_copym(rep->r_mreq, 0, M_COPYALL, M_DONTWAIT))){
1131	if ((nmp->nm_flag & NFSMNT_NOCONN) == 0)	1129	if ((nmp->nm_flag & NFSMNT_NOCONN) == 0)
1132	error = (*so->so_proto->pr_usrreqs->pru_send)	1130	error = (*so->so_proto->pr_usrreqs->pru_send)
1133	(so, 0, m, (struct sockaddr *)0,	1131	(so, 0, m, NULL,
1134	(struct mbuf *)0, td);	1132	NULL, td);
1135	else	1133	else
1136	error = (*so->so_proto->pr_usrreqs->pru_send)	1134	error = (*so->so_proto->pr_usrreqs->pru_send)
1137	(so, 0, m, nmp->nm_nam, (struct mbuf *)0,	1135	(so, 0, m, nmp->nm_nam, NULL,
1138	td);	1136	td);
1139	if (error) {	1137	if (error) {
1140	if (NFSIGNORE_SOERROR(nmp->nm_soflags, error))	1138	if (NFSIGNORE_SOERROR(nmp->nm_soflags, error))
Lines 1162-1168 Link Here
1162	}	1160	}
1163	}	1161	}
1164	splx(s);	1162	splx(s);
1165	nfs_timer_handle = timeout(nfs_timer, (void *)0, nfs_ticks);	1163	nfs_timer_handle = timeout(nfs_timer, NULL, nfs_ticks);
1166	}	1164	}
1167		1165
1168	/*	1166	/*
Lines 1265-1271 Link Here
1265	if (rep->r_nmp->nm_flag & NFSMNT_INT)	1263	if (rep->r_nmp->nm_flag & NFSMNT_INT)
1266	slpflag = PCATCH;	1264	slpflag = PCATCH;
1267	} else	1265	} else
1268	td = (struct thread *)0;	1266	td = NULL;
1269	while (*statep & NFSSTA_SNDLOCK) {	1267	while (*statep & NFSSTA_SNDLOCK) {
1270	if (nfs_sigintr(rep->r_nmp, rep, td))	1268	if (nfs_sigintr(rep->r_nmp, rep, td))
1271	return (EINTR);	1269	return (EINTR);

Lines 233-239 Link Here

(-)sys/nfsclient/nfs_subs.c (-9 / +9 lines)
233	*tl = 0;	233	*tl = 0;
234	mb->m_next = mrest;	234	mb->m_next = mrest;
235	mreq->m_pkthdr.len = authsiz + 10 * NFSX_UNSIGNED + mrest_len;	235	mreq->m_pkthdr.len = authsiz + 10 * NFSX_UNSIGNED + mrest_len;
236	mreq->m_pkthdr.rcvif = (struct ifnet *)0;	236	mreq->m_pkthdr.rcvif = NULL;
237	*mbp = mb;	237	*mbp = mb;
238	return (mreq);	238	return (mreq);
239	}	239	}
Lines 406-413 Link Here
406	nfs_ticks = 1;	406	nfs_ticks = 1;
407	/* Ensure async daemons disabled */	407	/* Ensure async daemons disabled */
408	for (i = 0; i < NFS_MAXASYNCDAEMON; i++) {	408	for (i = 0; i < NFS_MAXASYNCDAEMON; i++) {
409	nfs_iodwant[i] = (struct proc *)0;	409	nfs_iodwant[i] = NULL;
410	nfs_iodmount[i] = (struct nfsmount *)0;	410	nfs_iodmount[i] = NULL;
411	}	411	}
412	nfs_nhinit(); /* Init the nfsnode table */	412	nfs_nhinit(); /* Init the nfsnode table */
413		413
Lines 719-732 Link Here
719	dp->ndm_eocookie = 0;	719	dp->ndm_eocookie = 0;
720	LIST_INSERT_HEAD(&np->n_cookies, dp, ndm_list);	720	LIST_INSERT_HEAD(&np->n_cookies, dp, ndm_list);
721	} else	721	} else
722	return ((nfsuint64 *)0);	722	return (NULL);
723	}	723	}
724	while (pos >= NFSNUMCOOKIES) {	724	while (pos >= NFSNUMCOOKIES) {
725	pos -= NFSNUMCOOKIES;	725	pos -= NFSNUMCOOKIES;
726	if (LIST_NEXT(dp, ndm_list)) {	726	if (LIST_NEXT(dp, ndm_list)) {
727	if (!add && dp->ndm_eocookie < NFSNUMCOOKIES &&	727	if (!add && dp->ndm_eocookie < NFSNUMCOOKIES &&
728	pos >= dp->ndm_eocookie)	728	pos >= dp->ndm_eocookie)
729	return ((nfsuint64 *)0);	729	return (NULL);
730	dp = LIST_NEXT(dp, ndm_list);	730	dp = LIST_NEXT(dp, ndm_list);
731	} else if (add) {	731	} else if (add) {
732	MALLOC(dp2, struct nfsdmap *, sizeof (struct nfsdmap),	732	MALLOC(dp2, struct nfsdmap *, sizeof (struct nfsdmap),
Lines 735-747 Link Here
735	LIST_INSERT_AFTER(dp, dp2, ndm_list);	735	LIST_INSERT_AFTER(dp, dp2, ndm_list);
736	dp = dp2;	736	dp = dp2;
737	} else	737	} else
738	return ((nfsuint64 *)0);	738	return (NULL);
739	}	739	}
740	if (pos >= dp->ndm_eocookie) {	740	if (pos >= dp->ndm_eocookie) {
741	if (add)	741	if (add)
742	dp->ndm_eocookie = pos + 1;	742	dp->ndm_eocookie = pos + 1;
743	else	743	else
744	return ((nfsuint64 *)0);	744	return (NULL);
745	}	745	}
746	return (&dp->ndm_cookies[pos]);	746	return (&dp->ndm_cookies[pos]);
747	}	747	}
Lines 848-854 Link Here
848	}	848	}
849	if (*f) {	849	if (*f) {
850	ttvp = *v;	850	ttvp = *v;
851	t1 = nfs_loadattrcache(&ttvp, md, dpos, (struct vattr *)0, 0);	851	t1 = nfs_loadattrcache(&ttvp, md, dpos, NULL, 0);
852	if (t1)	852	if (t1)
853	return t1;	853	return t1;
854	*v = ttvp;	854	*v = ttvp;
Lines 905-911 Link Here
905	return EBADRPC;	905	return EBADRPC;
906	f = fxdr_unsigned(int, tl);	906	f = fxdr_unsigned(int, tl);
907	if (*f != 0) {	907	if (*f != 0) {
908	t1 = nfs_loadattrcache(&ttvp, md, dpos, (struct vattr *)0, 1);	908	t1 = nfs_loadattrcache(&ttvp, md, dpos, NULL, 1);
909	if (t1 != 0) {	909	if (t1 != 0) {
910	*f = 0;	910	*f = 0;
911	return t1;	911	return t1;

Lines 246-252 Link Here

(-)sys/nfsclient/nfs_vfsops.c (-4 / +4 lines)
246	u_quad_t tquad;	246	u_quad_t tquad;
247		247
248	#ifndef nolint	248	#ifndef nolint
249	sfp = (struct nfs_statfs *)0;	249	sfp = NULL;
250	#endif	250	#endif
251	error = nfs_nget(mp, (nfsfh_t *)nmp->nm_fh, nmp->nm_fhsize, &np);	251	error = nfs_nget(mp, (nfsfh_t *)nmp->nm_fh, nmp->nm_fhsize, &np);
252	if (error)	252	if (error)
Lines 452-458 Link Here
452	error = rtrequest(RTM_ADD, (struct sockaddr *)&sin,	452	error = rtrequest(RTM_ADD, (struct sockaddr *)&sin,
453	(struct sockaddr *)&nd->mygateway,	453	(struct sockaddr *)&nd->mygateway,
454	(struct sockaddr *)&mask,	454	(struct sockaddr *)&mask,
455	RTF_UP \| RTF_GATEWAY, (struct rtentry **)0);	455	RTF_UP \| RTF_GATEWAY, NULL);
456	if (error)	456	if (error)
457	panic("nfs_mountroot: RTM_ADD: %d", error);	457	panic("nfs_mountroot: RTM_ADD: %d", error);
458	}	458	}
Lines 697-703 Link Here
697	if (nmp->nm_so && adjsock) {	697	if (nmp->nm_so && adjsock) {
698	nfs_safedisconnect(nmp);	698	nfs_safedisconnect(nmp);
699	if (nmp->nm_sotype == SOCK_DGRAM)	699	if (nmp->nm_sotype == SOCK_DGRAM)
700	while (nfs_connect(nmp, (struct nfsreq *)0)) {	700	while (nfs_connect(nmp, NULL)) {
701	printf("nfs_args: retrying connect\n");	701	printf("nfs_args: retrying connect\n");
702	(void) tsleep((caddr_t)&lbolt,	702	(void) tsleep((caddr_t)&lbolt,
703	PSOCK, "nfscon", 0);	703	PSOCK, "nfscon", 0);
Lines 850-856 Link Here
850	* the first request, in case the server is not responding.	850	* the first request, in case the server is not responding.
851	*/	851	*/
852	if (nmp->nm_sotype == SOCK_DGRAM &&	852	if (nmp->nm_sotype == SOCK_DGRAM &&
853	(error = nfs_connect(nmp, (struct nfsreq *)0)))	853	(error = nfs_connect(nmp, NULL)))
854	goto bad;	854	goto bad;
855		855
856	/*	856	/*

Lines 727-733 Link Here

(-)sys/nfsclient/nfs_vnops.c (-24 / +24 lines)
727	if (v3) {	727	if (v3) {
728	nfsm_wcc_data(vp, wccflag);	728	nfsm_wcc_data(vp, wccflag);
729	} else	729	} else
730	nfsm_loadattr(vp, (struct vattr *)0);	730	nfsm_loadattr(vp, NULL);
731	m_freem(mrep);	731	m_freem(mrep);
732	nfsmout:	732	nfsmout:
733	return (error);	733	return (error);
Lines 865-871 Link Here
865	nfsm_postop_attr(newvp, attrflag);	865	nfsm_postop_attr(newvp, attrflag);
866	nfsm_postop_attr(dvp, attrflag);	866	nfsm_postop_attr(dvp, attrflag);
867	} else	867	} else
868	nfsm_loadattr(newvp, (struct vattr *)0);	868	nfsm_loadattr(newvp, NULL);
869	*vpp = newvp;	869	*vpp = newvp;
870	m_freem(mrep);	870	m_freem(mrep);
871	cnp->cn_flags \|= SAVENAME;	871	cnp->cn_flags \|= SAVENAME;
Lines 912-918 Link Here
912	nfsm_postop_attr(newvp, attrflag);	912	nfsm_postop_attr(newvp, attrflag);
913	nfsm_postop_attr(dvp, attrflag);	913	nfsm_postop_attr(dvp, attrflag);
914	} else	914	} else
915	nfsm_loadattr(newvp, (struct vattr *)0);	915	nfsm_loadattr(newvp, NULL);
916	if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))	916	if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
917	cnp->cn_flags \|= SAVENAME;	917	cnp->cn_flags \|= SAVENAME;
918	if ((cnp->cn_flags & MAKEENTRY) &&	918	if ((cnp->cn_flags & MAKEENTRY) &&
Lines 1053-1059 Link Here
1053	tl = nfsm_dissect(u_int32_t , 2 NFSX_UNSIGNED);	1053	tl = nfsm_dissect(u_int32_t , 2 NFSX_UNSIGNED);
1054	eof = fxdr_unsigned(int, *(tl + 1));	1054	eof = fxdr_unsigned(int, *(tl + 1));
1055	} else	1055	} else
1056	nfsm_loadattr(vp, (struct vattr *)0);	1056	nfsm_loadattr(vp, NULL);
1057	nfsm_strsiz(retlen, nmp->nm_rsize);	1057	nfsm_strsiz(retlen, nmp->nm_rsize);
1058	nfsm_mtouio(uiop, retlen);	1058	nfsm_mtouio(uiop, retlen);
1059	m_freem(mrep);	1059	m_freem(mrep);
Lines 1164-1170 Link Here
1164	}	1164	}
1165	}	1165	}
1166	} else	1166	} else
1167	nfsm_loadattr(vp, (struct vattr *)0);	1167	nfsm_loadattr(vp, NULL);
1168	if (wccflag)	1168	if (wccflag)
1169	VTONFS(vp)->n_mtime = VTONFS(vp)->n_vattr.va_mtime.tv_sec;	1169	VTONFS(vp)->n_mtime = VTONFS(vp)->n_vattr.va_mtime.tv_sec;
1170	m_freem(mrep);	1170	m_freem(mrep);
Lines 1192-1199 Link Here
1192	{	1192	{
1193	struct nfsv2_sattr *sp;	1193	struct nfsv2_sattr *sp;
1194	u_int32_t *tl;	1194	u_int32_t *tl;
1195	struct vnode newvp = (struct vnode )0;	1195	struct vnode *newvp = NULL;
1196	struct nfsnode np = (struct nfsnode )0;	1196	struct nfsnode *np = NULL;
1197	struct vattr vattr;	1197	struct vattr vattr;
1198	caddr_t bpos, dpos;	1198	caddr_t bpos, dpos;
1199	int error = 0, wccflag = NFSV3_WCCRATTR, gotvp = 0;	1199	int error = 0, wccflag = NFSV3_WCCRATTR, gotvp = 0;
Lines 1242-1248 Link Here
1242	if (!gotvp) {	1242	if (!gotvp) {
1243	if (newvp) {	1243	if (newvp) {
1244	vput(newvp);	1244	vput(newvp);
1245	newvp = (struct vnode *)0;	1245	newvp = NULL;
1246	}	1246	}
1247	error = nfs_lookitup(dvp, cnp->cn_nameptr,	1247	error = nfs_lookitup(dvp, cnp->cn_nameptr,
1248	cnp->cn_namelen, cnp->cn_cred, cnp->cn_thread, &np);	1248	cnp->cn_namelen, cnp->cn_cred, cnp->cn_thread, &np);
Lines 1292-1299 Link Here
1292	struct componentname *cnp = ap->a_cnp;	1292	struct componentname *cnp = ap->a_cnp;
1293	struct nfsv2_sattr *sp;	1293	struct nfsv2_sattr *sp;
1294	u_int32_t *tl;	1294	u_int32_t *tl;
1295	struct nfsnode np = (struct nfsnode )0;	1295	struct nfsnode *np = NULL;
1296	struct vnode newvp = (struct vnode )0;	1296	struct vnode *newvp = NULL;
1297	caddr_t bpos, dpos;	1297	caddr_t bpos, dpos;
1298	int error = 0, wccflag = NFSV3_WCCRATTR, gotvp = 0, fmode = 0;	1298	int error = 0, wccflag = NFSV3_WCCRATTR, gotvp = 0, fmode = 0;
1299	struct mbuf mreq, mrep, md, mb;	1299	struct mbuf mreq, mrep, md, mb;
Lines 1350-1356 Link Here
1350	if (!gotvp) {	1350	if (!gotvp) {
1351	if (newvp) {	1351	if (newvp) {
1352	vput(newvp);	1352	vput(newvp);
1353	newvp = (struct vnode *)0;	1353	newvp = NULL;
1354	}	1354	}
1355	error = nfs_lookitup(dvp, cnp->cn_nameptr,	1355	error = nfs_lookitup(dvp, cnp->cn_nameptr,
1356	cnp->cn_namelen, cnp->cn_cred, cnp->cn_thread, &np);	1356	cnp->cn_namelen, cnp->cn_cred, cnp->cn_thread, &np);
Lines 1466-1472 Link Here
1466	{	1466	{
1467		1467
1468	return (nfs_removerpc(sp->s_dvp, sp->s_name, sp->s_namlen, sp->s_cred,	1468	return (nfs_removerpc(sp->s_dvp, sp->s_name, sp->s_namlen, sp->s_cred,
1469	(struct thread *)0));	1469	NULL));
1470	}	1470	}
1471		1471
1472	/*	1472	/*
Lines 1694-1700 Link Here
1694	caddr_t bpos, dpos;	1694	caddr_t bpos, dpos;
1695	int slen, error = 0, wccflag = NFSV3_WCCRATTR, gotvp;	1695	int slen, error = 0, wccflag = NFSV3_WCCRATTR, gotvp;
1696	struct mbuf mreq, mrep, md, mb;	1696	struct mbuf mreq, mrep, md, mb;
1697	struct vnode newvp = (struct vnode )0;	1697	struct vnode *newvp = NULL;
1698	int v3 = NFS_ISV3(dvp);	1698	int v3 = NFS_ISV3(dvp);
1699		1699
1700	nfsstats.rpccnt[NFSPROC_SYMLINK]++;	1700	nfsstats.rpccnt[NFSPROC_SYMLINK]++;
Lines 1784-1791 Link Here
1784	struct componentname *cnp = ap->a_cnp;	1784	struct componentname *cnp = ap->a_cnp;
1785	struct nfsv2_sattr *sp;	1785	struct nfsv2_sattr *sp;
1786	int len;	1786	int len;
1787	struct nfsnode np = (struct nfsnode )0;	1787	struct nfsnode *np = NULL;
1788	struct vnode newvp = (struct vnode )0;	1788	struct vnode *newvp = NULL;
1789	caddr_t bpos, dpos;	1789	caddr_t bpos, dpos;
1790	int error = 0, wccflag = NFSV3_WCCRATTR;	1790	int error = 0, wccflag = NFSV3_WCCRATTR;
1791	int gotvp = 0;	1791	int gotvp = 0;
Lines 1832-1838 Link Here
1832	if (error == EEXIST \|\| (!error && !gotvp)) {	1832	if (error == EEXIST \|\| (!error && !gotvp)) {
1833	if (newvp) {	1833	if (newvp) {
1834	vrele(newvp);	1834	vrele(newvp);
1835	newvp = (struct vnode *)0;	1835	newvp = NULL;
1836	}	1836	}
1837	error = nfs_lookitup(dvp, cnp->cn_nameptr, len, cnp->cn_cred,	1837	error = nfs_lookitup(dvp, cnp->cn_nameptr, len, cnp->cn_cred,
1838	cnp->cn_thread, &np);	1838	cnp->cn_thread, &np);
Lines 2138-2144 Link Here
2138	int attrflag, fhsize;	2138	int attrflag, fhsize;
2139		2139
2140	#ifndef nolint	2140	#ifndef nolint
2141	dp = (struct dirent *)0;	2141	dp = NULL;
2142	#endif	2142	#endif
2143	#ifndef DIAGNOSTIC	2143	#ifndef DIAGNOSTIC
2144	if (uiop->uio_iovcnt != 1 \|\| (uiop->uio_offset & (DIRBLKSIZ - 1)) \|\|	2144	if (uiop->uio_iovcnt != 1 \|\| (uiop->uio_offset & (DIRBLKSIZ - 1)) \|\|
Lines 2274-2280 Link Here
2274	dpos = dpossav1;	2274	dpos = dpossav1;
2275	mdsav2 = md;	2275	mdsav2 = md;
2276	md = mdsav1;	2276	md = mdsav1;
2277	nfsm_loadattr(newvp, (struct vattr *)0);	2277	nfsm_loadattr(newvp, NULL);
2278	dpos = dpossav2;	2278	dpos = dpossav2;
2279	md = mdsav2;	2279	md = mdsav2;
2280	dp->d_type =	2280	dp->d_type =
Lines 2377-2383 Link Here
2377		2377
2378	/* Try lookitups until we get one that isn't there */	2378	/* Try lookitups until we get one that isn't there */
2379	while (nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred,	2379	while (nfs_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred,
2380	cnp->cn_thread, (struct nfsnode **)0) == 0) {	2380	cnp->cn_thread, NULL) == 0) {
2381	sp->s_name[4]++;	2381	sp->s_name[4]++;
2382	if (sp->s_name[4] > 'z') {	2382	if (sp->s_name[4] > 'z') {
2383	error = EINVAL;	2383	error = EINVAL;
Lines 2410-2416 Link Here
2410	nfs_lookitup(struct vnode dvp, const char name, int len, struct ucred *cred,	2410	nfs_lookitup(struct vnode dvp, const char name, int len, struct ucred *cred,
2411	struct thread td, struct nfsnode *npp)	2411	struct thread td, struct nfsnode *npp)
2412	{	2412	{
2413	struct vnode newvp = (struct vnode )0;	2413	struct vnode *newvp = NULL;
2414	struct nfsnode np, dnp = VTONFS(dvp);	2414	struct nfsnode np, dnp = VTONFS(dvp);
2415	caddr_t bpos, dpos;	2415	caddr_t bpos, dpos;
2416	int error = 0, fhlen, attrflag;	2416	int error = 0, fhlen, attrflag;
Lines 2460-2466 Link Here
2460	return (ENOENT);	2460	return (ENOENT);
2461	}	2461	}
2462	} else	2462	} else
2463	nfsm_loadattr(newvp, (struct vattr *)0);	2463	nfsm_loadattr(newvp, NULL);
2464	}	2464	}
2465	m_freem(mrep);	2465	m_freem(mrep);
2466	nfsmout:	2466	nfsmout:
Lines 2539-2545 Link Here
2539	panic("nfs physio");	2539	panic("nfs physio");
2540		2540
2541	if (bp->b_flags & B_ASYNC)	2541	if (bp->b_flags & B_ASYNC)
2542	td = (struct thread *)0;	2542	td = NULL;
2543	else	2543	else
2544	td = curthread; /* XXX */	2544	td = curthread; /* XXX */
2545		2545
Lines 2776-2782 Link Here
2776	panic("nfs_fsync: inconsistent lock");	2776	panic("nfs_fsync: inconsistent lock");
2777	if (error == ENOLCK)	2777	if (error == ENOLCK)
2778	goto loop;	2778	goto loop;
2779	if (nfs_sigintr(nmp, (struct nfsreq *)0, td)) {	2779	if (nfs_sigintr(nmp, NULL, td)) {
2780	error = EINTR;	2780	error = EINTR;
2781	goto done;	2781	goto done;
2782	}	2782	}
Lines 2812-2818 Link Here
2812	error = tsleep((caddr_t)&vp->v_numoutput,	2812	error = tsleep((caddr_t)&vp->v_numoutput,
2813	slpflag \| (PRIBIO + 1), "nfsfsync", slptimeo);	2813	slpflag \| (PRIBIO + 1), "nfsfsync", slptimeo);
2814	if (error) {	2814	if (error) {
2815	if (nfs_sigintr(nmp, (struct nfsreq *)0, td)) {	2815	if (nfs_sigintr(nmp, NULL, td)) {
2816	error = EINTR;	2816	error = EINTR;
2817	goto done;	2817	goto done;
2818	}	2818	}

Lines 192-198 Link Here

(-)sys/nfsserver/nfs_serv.c (-19 / +19 lines)
192	error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly, TRUE);	192	error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly, TRUE);
193	if (error) {	193	if (error) {
194	nfsm_reply(NFSX_UNSIGNED);	194	nfsm_reply(NFSX_UNSIGNED);
195	nfsm_srvpostop_attr(1, (struct vattr *)0);	195	nfsm_srvpostop_attr(1, NULL);
196	error = 0;	196	error = 0;
197	goto nfsmout;	197	goto nfsmout;
198	}	198	}
Lines 648-654 Link Here
648		648
649	nfsdbprintf(("%s %d\n", __FILE__, __LINE__));	649	nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
650	#ifndef nolint	650	#ifndef nolint
651	mp = (struct mbuf *)0;	651	mp = NULL;
652	#endif	652	#endif
653	mp3 = NULL;	653	mp3 = NULL;
654	fhp = &nfh.fh_generic;	654	fhp = &nfh.fh_generic;
Lines 681-692 Link Here
681	uiop->uio_resid = len;	681	uiop->uio_resid = len;
682	uiop->uio_rw = UIO_READ;	682	uiop->uio_rw = UIO_READ;
683	uiop->uio_segflg = UIO_SYSSPACE;	683	uiop->uio_segflg = UIO_SYSSPACE;
684	uiop->uio_td = (struct thread *)0;	684	uiop->uio_td = NULL;
685	error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly, TRUE);	685	error = nfsrv_fhtovp(fhp, 1, &vp, cred, slp, nam, &rdonly, TRUE);
686	if (error) {	686	if (error) {
687	nfsm_reply(2 * NFSX_UNSIGNED);	687	nfsm_reply(2 * NFSX_UNSIGNED);
688	if (v3)	688	if (v3)
689	nfsm_srvpostop_attr(1, (struct vattr *)0);	689	nfsm_srvpostop_attr(1, NULL);
690	error = 0;	690	error = 0;
691	goto nfsmout;	691	goto nfsmout;
692	}	692	}
Lines 780-786 Link Here
780	vp = NULL;	780	vp = NULL;
781	nfsm_reply(2 * NFSX_UNSIGNED);	781	nfsm_reply(2 * NFSX_UNSIGNED);
782	if (v3)	782	if (v3)
783	nfsm_srvpostop_attr(1, (struct vattr *)0);	783	nfsm_srvpostop_attr(1, NULL);
784	error = 0;	784	error = 0;
785	goto nfsmout;	785	goto nfsmout;
786	}	786	}
Lines 1136-1142 Link Here
1136	uiop->uio_resid = len;	1136	uiop->uio_resid = len;
1137	uiop->uio_rw = UIO_WRITE;	1137	uiop->uio_rw = UIO_WRITE;
1138	uiop->uio_segflg = UIO_SYSSPACE;	1138	uiop->uio_segflg = UIO_SYSSPACE;
1139	uiop->uio_td = (struct thread *)0;	1139	uiop->uio_td = NULL;
1140	uiop->uio_offset = off;	1140	uiop->uio_offset = off;
1141	error = VOP_WRITE(vp, uiop, ioflags, cred);	1141	error = VOP_WRITE(vp, uiop, ioflags, cred);
1142	nfsrvstats.srvvop_writes++;	1142	nfsrvstats.srvvop_writes++;
Lines 1391-1397 Link Here
1391	ioflags = (IO_METASYNC \| IO_SYNC \| IO_NODELOCKED);	1391	ioflags = (IO_METASYNC \| IO_SYNC \| IO_NODELOCKED);
1392	uiop->uio_rw = UIO_WRITE;	1392	uiop->uio_rw = UIO_WRITE;
1393	uiop->uio_segflg = UIO_SYSSPACE;	1393	uiop->uio_segflg = UIO_SYSSPACE;
1394	uiop->uio_td = (struct thread *)0;	1394	uiop->uio_td = NULL;
1395	uiop->uio_offset = nfsd->nd_off;	1395	uiop->uio_offset = nfsd->nd_off;
1396	uiop->uio_resid = nfsd->nd_eoff - nfsd->nd_off;	1396	uiop->uio_resid = nfsd->nd_eoff - nfsd->nd_off;
1397	if (uiop->uio_resid > 0) {	1397	if (uiop->uio_resid > 0) {
Lines 1588-1594 Link Here
1588	int v3 = (nfsd->nd_flag & ND_NFSV3), how, exclusive_flag = 0;	1588	int v3 = (nfsd->nd_flag & ND_NFSV3), how, exclusive_flag = 0;
1589	caddr_t cp;	1589	caddr_t cp;
1590	struct mbuf mb, mreq;	1590	struct mbuf mb, mreq;
1591	struct vnode dirp = (struct vnode )0;	1591	struct vnode *dirp = NULL;
1592	nfsfh_t nfh;	1592	nfsfh_t nfh;
1593	fhandle_t *fhp;	1593	fhandle_t *fhp;
1594	u_quad_t tempsize;	1594	u_quad_t tempsize;
Lines 1869-1875 Link Here
1869	u_int32_t major, minor;	1869	u_int32_t major, minor;
1870	enum vtype vtyp;	1870	enum vtype vtyp;
1871	struct mbuf mb, mreq;	1871	struct mbuf mb, mreq;
1872	struct vnode vp, dirp = (struct vnode *)0;	1872	struct vnode vp, dirp = NULL;
1873	nfsfh_t nfh;	1873	nfsfh_t nfh;
1874	fhandle_t *fhp;	1874	fhandle_t *fhp;
1875	struct mount *mp = NULL;	1875	struct mount *mp = NULL;
Lines 2155-2162 Link Here
2155	int v3 = (nfsd->nd_flag & ND_NFSV3);	2155	int v3 = (nfsd->nd_flag & ND_NFSV3);
2156	struct mbuf mb, mreq;	2156	struct mbuf mb, mreq;
2157	struct nameidata fromnd, tond;	2157	struct nameidata fromnd, tond;
2158	struct vnode fvp, tvp, tdvp, fdirp = (struct vnode *)0;	2158	struct vnode fvp, tvp, tdvp, fdirp = NULL;
2159	struct vnode tdirp = (struct vnode )0;	2159	struct vnode *tdirp = NULL;
2160	struct vattr fdirfor, fdiraft, tdirfor, tdiraft;	2160	struct vattr fdirfor, fdiraft, tdirfor, tdiraft;
2161	nfsfh_t fnfh, tnfh;	2161	nfsfh_t fnfh, tnfh;
2162	fhandle_t ffhp, tfhp;	2162	fhandle_t ffhp, tfhp;
Lines 2166-2172 Link Here
2166		2166
2167	nfsdbprintf(("%s %d\n", __FILE__, __LINE__));	2167	nfsdbprintf(("%s %d\n", __FILE__, __LINE__));
2168	#ifndef nolint	2168	#ifndef nolint
2169	fvp = (struct vnode *)0;	2169	fvp = NULL;
2170	#endif	2170	#endif
2171	ffhp = &fnfh.fh_generic;	2171	ffhp = &fnfh.fh_generic;
2172	tfhp = &tnfh.fh_generic;	2172	tfhp = &tnfh.fh_generic;
Lines 2381-2387 Link Here
2381	int error = 0, rdonly, len, dirfor_ret = 1, diraft_ret = 1;	2381	int error = 0, rdonly, len, dirfor_ret = 1, diraft_ret = 1;
2382	int getret = 1, v3 = (nfsd->nd_flag & ND_NFSV3);	2382	int getret = 1, v3 = (nfsd->nd_flag & ND_NFSV3);
2383	struct mbuf mb, mreq;	2383	struct mbuf mb, mreq;
2384	struct vnode vp = NULL, xp, dirp = (struct vnode )0;	2384	struct vnode vp = NULL, xp, *dirp = NULL;
2385	struct vattr dirfor, diraft, at;	2385	struct vattr dirfor, diraft, at;
2386	nfsfh_t nfh, dnfh;	2386	nfsfh_t nfh, dnfh;
2387	fhandle_t fhp, dfhp;	2387	fhandle_t fhp, dfhp;
Lines 2501-2513 Link Here
2501	struct nameidata nd;	2501	struct nameidata nd;
2502	struct vattr *vap = &va;	2502	struct vattr *vap = &va;
2503	struct nfsv2_sattr *sp;	2503	struct nfsv2_sattr *sp;
2504	char bpos, pathcp = (char *)0;	2504	char bpos, pathcp = NULL;
2505	struct uio io;	2505	struct uio io;
2506	struct iovec iv;	2506	struct iovec iv;
2507	int error = 0, len, len2, dirfor_ret = 1, diraft_ret = 1;	2507	int error = 0, len, len2, dirfor_ret = 1, diraft_ret = 1;
2508	int v3 = (nfsd->nd_flag & ND_NFSV3);	2508	int v3 = (nfsd->nd_flag & ND_NFSV3);
2509	struct mbuf mb, mreq;	2509	struct mbuf mb, mreq;
2510	struct vnode dirp = (struct vnode )0;	2510	struct vnode *dirp = NULL;
2511	nfsfh_t nfh;	2511	nfsfh_t nfh;
2512	fhandle_t *fhp;	2512	fhandle_t *fhp;
2513	struct mount *mp = NULL;	2513	struct mount *mp = NULL;
Lines 2560-2566 Link Here
2560	io.uio_iovcnt = 1;	2560	io.uio_iovcnt = 1;
2561	io.uio_segflg = UIO_SYSSPACE;	2561	io.uio_segflg = UIO_SYSSPACE;
2562	io.uio_rw = UIO_READ;	2562	io.uio_rw = UIO_READ;
2563	io.uio_td = (struct thread *)0;	2563	io.uio_td = NULL;
2564	nfsm_mtouio(&io, len2);	2564	nfsm_mtouio(&io, len2);
2565	if (!v3) {	2565	if (!v3) {
2566	sp = nfsm_dissect(struct nfsv2_sattr *, NFSX_V2SATTR);	2566	sp = nfsm_dissect(struct nfsv2_sattr *, NFSX_V2SATTR);
Lines 2831-2837 Link Here
2831	int error = 0, len, dirfor_ret = 1, diraft_ret = 1;	2831	int error = 0, len, dirfor_ret = 1, diraft_ret = 1;
2832	int v3 = (nfsd->nd_flag & ND_NFSV3);	2832	int v3 = (nfsd->nd_flag & ND_NFSV3);
2833	struct mbuf mb, mreq;	2833	struct mbuf mb, mreq;
2834	struct vnode vp, dirp = (struct vnode *)0;	2834	struct vnode vp, dirp = NULL;
2835	struct vattr dirfor, diraft;	2835	struct vattr dirfor, diraft;
2836	nfsfh_t nfh;	2836	nfsfh_t nfh;
2837	fhandle_t *fhp;	2837	fhandle_t *fhp;
Lines 3070-3076 Link Here
3070	io.uio_resid = fullsiz;	3070	io.uio_resid = fullsiz;
3071	io.uio_segflg = UIO_SYSSPACE;	3071	io.uio_segflg = UIO_SYSSPACE;
3072	io.uio_rw = UIO_READ;	3072	io.uio_rw = UIO_READ;
3073	io.uio_td = (struct thread *)0;	3073	io.uio_td = NULL;
3074	eofflag = 0;	3074	eofflag = 0;
3075	vn_lock(vp, LK_EXCLUSIVE \| LK_RETRY, td);	3075	vn_lock(vp, LK_EXCLUSIVE \| LK_RETRY, td);
3076	if (cookies) {	3076	if (cookies) {
Lines 3348-3354 Link Here
3348	io.uio_resid = fullsiz;	3348	io.uio_resid = fullsiz;
3349	io.uio_segflg = UIO_SYSSPACE;	3349	io.uio_segflg = UIO_SYSSPACE;
3350	io.uio_rw = UIO_READ;	3350	io.uio_rw = UIO_READ;
3351	io.uio_td = (struct thread *)0;	3351	io.uio_td = NULL;
3352	eofflag = 0;	3352	eofflag = 0;
3353	vn_lock(vp, LK_EXCLUSIVE \| LK_RETRY, td);	3353	vn_lock(vp, LK_EXCLUSIVE \| LK_RETRY, td);
3354	if (cookies) {	3354	if (cookies) {

Lines 437-444 Link Here

(-)sys/nfsserver/nfs_srvsock.c (-10 / +10 lines)
437	auio.uio_resid = 1000000000;	437	auio.uio_resid = 1000000000;
438	flags = MSG_DONTWAIT;	438	flags = MSG_DONTWAIT;
439	error = so->so_proto->pr_usrreqs->pru_soreceive	439	error = so->so_proto->pr_usrreqs->pru_soreceive
440	(so, &nam, &auio, &mp, (struct mbuf **)0, &flags);	440	(so, &nam, &auio, &mp, NULL, &flags);
441	if (error \|\| mp == (struct mbuf *)0) {	441	if (error \|\| mp == NULL) {
442	if (error == EWOULDBLOCK)	442	if (error == EWOULDBLOCK)
443	slp->ns_flag \|= SLP_NEEDQ;	443	slp->ns_flag \|= SLP_NEEDQ;
444	else	444	else
Lines 473-479 Link Here
473	flags = MSG_DONTWAIT;	473	flags = MSG_DONTWAIT;
474	error = so->so_proto->pr_usrreqs->pru_soreceive	474	error = so->so_proto->pr_usrreqs->pru_soreceive
475	(so, &nam, &auio, &mp,	475	(so, &nam, &auio, &mp,
476	(struct mbuf **)0, &flags);	476	NULL, &flags);
477	if (mp) {	477	if (mp) {
478	struct nfsrv_rec *rec;	478	struct nfsrv_rec *rec;
479	rec = malloc(sizeof(struct nfsrv_rec),	479	rec = malloc(sizeof(struct nfsrv_rec),
Lines 568-579 Link Here
568	*/	568	*/
569	if (slp->ns_cc == slp->ns_reclen) {	569	if (slp->ns_cc == slp->ns_reclen) {
570	recm = slp->ns_raw;	570	recm = slp->ns_raw;
571	slp->ns_raw = slp->ns_rawend = (struct mbuf *)0;	571	slp->ns_raw = slp->ns_rawend = NULL;
572	slp->ns_cc = slp->ns_reclen = 0;	572	slp->ns_cc = slp->ns_reclen = 0;
573	} else if (slp->ns_cc > slp->ns_reclen) {	573	} else if (slp->ns_cc > slp->ns_reclen) {
574	len = 0;	574	len = 0;
575	m = slp->ns_raw;	575	m = slp->ns_raw;
576	om = (struct mbuf *)0;	576	om = NULL;
577	while (len < slp->ns_reclen) {	577	while (len < slp->ns_reclen) {
578	if ((len + m->m_len) > slp->ns_reclen) {	578	if ((len + m->m_len) > slp->ns_reclen) {
579	m2 = m_copym(m, 0, slp->ns_reclen - len,	579	m2 = m_copym(m, 0, slp->ns_reclen - len,
Lines 596-602 Link Here
596	len += m->m_len;	596	len += m->m_len;
597	m = m->m_next;	597	m = m->m_next;
598	recm = slp->ns_raw;	598	recm = slp->ns_raw;
599	om->m_next = (struct mbuf *)0;	599	om->m_next = NULL;
600	} else {	600	} else {
601	om = m;	601	om = m;
602	len += m->m_len;	602	len += m->m_len;
Lines 625-635 Link Here
625	m_freem(slp->ns_frag);	625	m_freem(slp->ns_frag);
626	} else {	626	} else {
627	nfs_realign(&slp->ns_frag, 10 * NFSX_UNSIGNED);	627	nfs_realign(&slp->ns_frag, 10 * NFSX_UNSIGNED);
628	rec->nr_address = (struct sockaddr *)0;	628	rec->nr_address = NULL;
629	rec->nr_packet = slp->ns_frag;	629	rec->nr_packet = slp->ns_frag;
630	STAILQ_INSERT_TAIL(&slp->ns_rec, rec, nr_link);	630	STAILQ_INSERT_TAIL(&slp->ns_rec, rec, nr_link);
631	}	631	}
632	slp->ns_frag = (struct mbuf *)0;	632	slp->ns_frag = NULL;
633	}	633	}
634	}	634	}
635	}	635	}
Lines 715-721 Link Here
715		715
716	soflags = so->so_proto->pr_flags;	716	soflags = so->so_proto->pr_flags;
717	if ((soflags & PR_CONNREQUIRED) \|\| (so->so_state & SS_ISCONNECTED))	717	if ((soflags & PR_CONNREQUIRED) \|\| (so->so_state & SS_ISCONNECTED))
718	sendnam = (struct sockaddr *)0;	718	sendnam = NULL;
719	else	719	else
720	sendnam = nam;	720	sendnam = nam;
721	if (so->so_type == SOCK_SEQPACKET)	721	if (so->so_type == SOCK_SEQPACKET)
Lines 763-767 Link Here
763	nfsrv_wakenfsd(slp);	763	nfsrv_wakenfsd(slp);
764	}	764	}
765	splx(s);	765	splx(s);
766	nfsrv_timer_handle = timeout(nfsrv_timer, (void *)0, nfsrv_ticks);	766	nfsrv_timer_handle = timeout(nfsrv_timer, NULL, nfsrv_ticks);
767	}	767	}

Lines 604-610 Link Here

(-)sys/nfsserver/nfs_srvsubs.c (-4 / +4 lines)
604	int error, rdonly, linklen;	604	int error, rdonly, linklen;
605	struct componentname *cnp = &ndp->ni_cnd;	605	struct componentname *cnp = &ndp->ni_cnd;
606		606
607	retdirp = (struct vnode )0;	607	*retdirp = NULL;
608	cnp->cn_pnbuf = uma_zalloc(namei_zone, M_WAITOK);	608	cnp->cn_pnbuf = uma_zalloc(namei_zone, M_WAITOK);
609		609
610	/*	610	/*
Lines 789-795 Link Here
789	auio.uio_offset = 0;	789	auio.uio_offset = 0;
790	auio.uio_rw = UIO_READ;	790	auio.uio_rw = UIO_READ;
791	auio.uio_segflg = UIO_SYSSPACE;	791	auio.uio_segflg = UIO_SYSSPACE;
792	auio.uio_td = (struct thread *)0;	792	auio.uio_td = NULL;
793	auio.uio_resid = MAXPATHLEN;	793	auio.uio_resid = MAXPATHLEN;
794	error = VOP_READLINK(ndp->ni_vp, &auio, cnp->cn_cred);	794	error = VOP_READLINK(ndp->ni_vp, &auio, cnp->cn_cred);
795	if (error) {	795	if (error) {
Lines 881-887 Link Here
881	m = mp;	881	m = mp;
882	for (;;) {	882	for (;;) {
883	count += m->m_len;	883	count += m->m_len;
884	if (m->m_next == (struct mbuf *)0)	884	if (m->m_next == NULL)
885	break;	885	break;
886	m = m->m_next;	886	m = m->m_next;
887	}	887	}
Lines 1031-1037 Link Here
1031	struct sockaddr_int *saddr;	1031	struct sockaddr_int *saddr;
1032	#endif	1032	#endif
1033		1033
1034	vpp = (struct vnode )0;	1034	*vpp = NULL;
1035		1035
1036	if (nfs_ispublicfh(fhp)) {	1036	if (nfs_ispublicfh(fhp)) {
1037	if (!pubflag \|\| !nfs_pub.np_valid)	1037	if (!pubflag \|\| !nfs_pub.np_valid)

Lines 150-156 Link Here

(-)sys/nfsserver/nfs_syscalls.c (-12 / +12 lines)
150	* Get the client address for connected sockets.	150	* Get the client address for connected sockets.
151	*/	151	*/
152	if (nfsdarg.name == NULL \|\| nfsdarg.namelen == 0)	152	if (nfsdarg.name == NULL \|\| nfsdarg.namelen == 0)
153	nam = (struct sockaddr *)0;	153	nam = NULL;
154	else {	154	else {
155	error = getsockaddr(&nam, nfsdarg.name,	155	error = getsockaddr(&nam, nfsdarg.name,
156	nfsdarg.namelen);	156	nfsdarg.namelen);
Lines 189-195 Link Here
189		189
190	so = (struct socket *)fp->f_data;	190	so = (struct socket *)fp->f_data;
191	#if 0	191	#if 0
192	tslp = (struct nfssvc_sock *)0;	192	tslp = NULL;
193	/*	193	/*
194	* Add it to the list, as required.	194	* Add it to the list, as required.
195	*/	195	*/
Lines 288-294 Link Here
288	cacherep = RC_DOIT;	288	cacherep = RC_DOIT;
289	writes_todo = 0;	289	writes_todo = 0;
290	#endif	290	#endif
291	if (nfsd == (struct nfsd *)0) {	291	if (nfsd == NULL) {
292	nsd->nsd_nfsd = nfsd = (struct nfsd *)	292	nsd->nsd_nfsd = nfsd = (struct nfsd *)
293	malloc(sizeof (struct nfsd), M_NFSD, M_WAITOK \| M_ZERO);	293	malloc(sizeof (struct nfsd), M_NFSD, M_WAITOK \| M_ZERO);
294	s = splnet();	294	s = splnet();
Lines 303-309 Link Here
303	*/	303	*/
304	for (;;) {	304	for (;;) {
305	if ((nfsd->nfsd_flag & NFSD_REQINPROG) == 0) {	305	if ((nfsd->nfsd_flag & NFSD_REQINPROG) == 0) {
306	while (nfsd->nfsd_slp == (struct nfssvc_sock *)0 &&	306	while (nfsd->nfsd_slp == NULL &&
307	(nfsd_head_flag & NFSD_CHECKSLP) == 0) {	307	(nfsd_head_flag & NFSD_CHECKSLP) == 0) {
308	nfsd->nfsd_flag \|= NFSD_WAITING;	308	nfsd->nfsd_flag \|= NFSD_WAITING;
309	nfsd_waiting++;	309	nfsd_waiting++;
Lines 313-319 Link Here
313	if (error)	313	if (error)
314	goto done;	314	goto done;
315	}	315	}
316	if (nfsd->nfsd_slp == (struct nfssvc_sock *)0 &&	316	if (nfsd->nfsd_slp == NULL &&
317	(nfsd_head_flag & NFSD_CHECKSLP) != 0) {	317	(nfsd_head_flag & NFSD_CHECKSLP) != 0) {
318	TAILQ_FOREACH(slp, &nfssvc_sockhead, ns_chain) {	318	TAILQ_FOREACH(slp, &nfssvc_sockhead, ns_chain) {
319	if ((slp->ns_flag & (SLP_VALID \| SLP_DOREC))	319	if ((slp->ns_flag & (SLP_VALID \| SLP_DOREC))
Lines 327-333 Link Here
327	if (slp == 0)	327	if (slp == 0)
328	nfsd_head_flag &= ~NFSD_CHECKSLP;	328	nfsd_head_flag &= ~NFSD_CHECKSLP;
329	}	329	}
330	if ((slp = nfsd->nfsd_slp) == (struct nfssvc_sock *)0)	330	if ((slp = nfsd->nfsd_slp) == NULL)
331	continue;	331	continue;
332	if (slp->ns_flag & SLP_VALID) {	332	if (slp->ns_flag & SLP_VALID) {
333	if (slp->ns_flag & SLP_DISCONN)	333	if (slp->ns_flag & SLP_DISCONN)
Lines 359-365 Link Here
359	free((caddr_t)nd, M_NFSRVDESC);	359	free((caddr_t)nd, M_NFSRVDESC);
360	nd = NULL;	360	nd = NULL;
361	}	361	}
362	nfsd->nfsd_slp = (struct nfssvc_sock *)0;	362	nfsd->nfsd_slp = NULL;
363	nfsd->nfsd_flag &= ~NFSD_REQINPROG;	363	nfsd->nfsd_flag &= ~NFSD_REQINPROG;
364	nfsrv_slpderef(slp);	364	nfsrv_slpderef(slp);
365	continue;	365	continue;
Lines 427-433 Link Here
427	}	427	}
428	nfsrvstats.srvrpccnt[nd->nd_procnum]++;	428	nfsrvstats.srvrpccnt[nd->nd_procnum]++;
429	nfsrv_updatecache(nd, TRUE, mreq);	429	nfsrv_updatecache(nd, TRUE, mreq);
430	nd->nd_mrep = (struct mbuf *)0;	430	nd->nd_mrep = NULL;
431	case RC_REPLY:	431	case RC_REPLY:
432	m = mreq;	432	m = mreq;
433	siz = 0;	433	siz = 0;
Lines 441-447 Link Here
441	}	441	}
442	m = mreq;	442	m = mreq;
443	m->m_pkthdr.len = siz;	443	m->m_pkthdr.len = siz;
444	m->m_pkthdr.rcvif = (struct ifnet *)0;	444	m->m_pkthdr.rcvif = NULL;
445	/*	445	/*
446	* For stream protocols, prepend a Sun RPC	446	* For stream protocols, prepend a Sun RPC
447	* Record Mark.	447	* Record Mark.
Lines 509-515 Link Here
509	TAILQ_REMOVE(&nfsd_head, nfsd, nfsd_chain);	509	TAILQ_REMOVE(&nfsd_head, nfsd, nfsd_chain);
510	splx(s);	510	splx(s);
511	free((caddr_t)nfsd, M_NFSD);	511	free((caddr_t)nfsd, M_NFSD);
512	nsd->nsd_nfsd = (struct nfsd *)0;	512	nsd->nsd_nfsd = NULL;
513	if (--nfs_numnfsd == 0)	513	if (--nfs_numnfsd == 0)
514	nfsrv_init(TRUE); /* Reinitialize everything */	514	nfsrv_init(TRUE); /* Reinitialize everything */
515	return (error);	515	return (error);
Lines 534-546 Link Here
534	slp->ns_flag &= ~SLP_ALLFLAGS;	534	slp->ns_flag &= ~SLP_ALLFLAGS;
535	fp = slp->ns_fp;	535	fp = slp->ns_fp;
536	if (fp) {	536	if (fp) {
537	slp->ns_fp = (struct file *)0;	537	slp->ns_fp = NULL;
538	so = slp->ns_so;	538	so = slp->ns_so;
539	so->so_rcv.sb_flags &= ~SB_UPCALL;	539	so->so_rcv.sb_flags &= ~SB_UPCALL;
540	so->so_upcall = NULL;	540	so->so_upcall = NULL;
541	so->so_upcallarg = NULL;	541	so->so_upcallarg = NULL;
542	soshutdown(so, 2);	542	soshutdown(so, 2);
543	closef(fp, (struct thread *)0);	543	closef(fp, NULL);
544	if (slp->ns_nam)	544	if (slp->ns_nam)
545	FREE(slp->ns_nam, M_SONAME);	545	FREE(slp->ns_nam, M_SONAME);
546	m_freem(slp->ns_raw);	546	m_freem(slp->ns_raw);