自学教程：C++ uma_zalloc函数代码示例

static struct namecache *cache_alloc(int len, int ts){	if (len > CACHE_PATH_CUTOFF) {		if (ts)			return (uma_zalloc(cache_zone_large_ts, M_WAITOK));		else			return (uma_zalloc(cache_zone_large, M_WAITOK));	}	if (ts)		return (uma_zalloc(cache_zone_small_ts, M_WAITOK));	else		return (uma_zalloc(cache_zone_small, M_WAITOK));}

/*- * Configure a provided mbuf to refer to the provided external storage * buffer and setup a reference count for said buffer.  If the setting * up of the reference count fails, the M_EXT bit will not be set.  If * successfull, the M_EXT bit is set in the mbuf's flags. * * Arguments: *    mb     The existing mbuf to which to attach the provided buffer. *    buf    The address of the provided external storage buffer. *    size   The size of the provided buffer. *    freef  A pointer to a routine that is responsible for freeing the *           provided external storage buffer. *    args   A pointer to an argument structure (of any type) to be passed *           to the provided freef routine (may be NULL). *    flags  Any other flags to be passed to the provided mbuf. *    type   The type that the external storage buffer should be *           labeled with. * * Returns: *    Nothing. */intm_extadd(struct mbuf *mb, caddr_t buf, u_int size,    void (*freef)(struct mbuf *, void *, void *), void *arg1, void *arg2,    int flags, int type, int wait){	KASSERT(type != EXT_CLUSTER, ("%s: EXT_CLUSTER not allowed", __func__));	if (type != EXT_EXTREF)		mb->m_ext.ext_cnt = uma_zalloc(zone_ext_refcnt, wait);	if (mb->m_ext.ext_cnt == NULL)		return (ENOMEM);	*(mb->m_ext.ext_cnt) = 1;	mb->m_flags |= (M_EXT | flags);	mb->m_ext.ext_buf = buf;	mb->m_data = mb->m_ext.ext_buf;	mb->m_ext.ext_size = size;	mb->m_ext.ext_free = freef;	mb->m_ext.ext_arg1 = arg1;	mb->m_ext.ext_arg2 = arg2;	mb->m_ext.ext_type = type;	mb->m_ext.ext_flags = 0;	return (0);}

/* * Allocate icl_pdu with empty BHS to fill up by the caller. */struct icl_pdu *icl_soft_conn_new_pdu(struct icl_conn *ic, int flags){	struct icl_pdu *ip;#ifdef DIAGNOSTIC	refcount_acquire(&ic->ic_outstanding_pdus);#endif	ip = uma_zalloc(icl_pdu_zone, flags | M_ZERO);	if (ip == NULL) {		ICL_WARN("failed to allocate %zd bytes", sizeof(*ip));#ifdef DIAGNOSTIC		refcount_release(&ic->ic_outstanding_pdus);#endif		return (NULL);	}	ip->ip_conn = ic;	CTASSERT(sizeof(struct iscsi_bhs) <= MHLEN);	ip->ip_bhs_mbuf = m_gethdr(flags, MT_DATA);	if (ip->ip_bhs_mbuf == NULL) {		ICL_WARN("failed to allocate BHS mbuf");		icl_soft_conn_pdu_free(ic, ip);		return (NULL);	}	ip->ip_bhs = mtod(ip->ip_bhs_mbuf, struct iscsi_bhs *);	memset(ip->ip_bhs, 0, sizeof(struct iscsi_bhs));	ip->ip_bhs_mbuf->m_len = sizeof(struct iscsi_bhs);	return (ip);}

static struct dtsec_rm_frame_info *dtsec_rm_fi_alloc(struct dtsec_softc *sc){	struct dtsec_rm_frame_info *fi;	fi = uma_zalloc(sc->sc_fi_zone, M_NOWAIT);	return (fi);}

static uint8_t *dtsec_rm_pool_rx_get_buffer(t_Handle h_BufferPool, t_Handle *context){	struct dtsec_softc *sc;	uint8_t *buffer;	sc = h_BufferPool;	buffer = uma_zalloc(sc->sc_rx_zone, M_NOWAIT);	return (buffer);}

intudp_newudpcb(struct inpcb *inp){	struct udpcb *up;	up = uma_zalloc(V_udpcb_zone, M_NOWAIT | M_ZERO);	if (up == NULL)		return (ENOBUFS);	inp->inp_ppcb = up;	return (0);}

counter_u64_tcounter_u64_alloc(int flags){	counter_u64_t r;	r = uma_zalloc(pcpu_zone_64, flags);	if (r != NULL)		counter_u64_zero(r);	return (r);}

struct pefs_dircache *pefs_dircache_get(void){	struct pefs_dircache *pd;	pd = uma_zalloc(dircache_zone, M_WAITOK | M_ZERO);	sx_init(&pd->pd_lock, "pefs_dircache_sx");	LIST_INIT(&pd->pd_heads[0]);	LIST_INIT(&pd->pd_heads[1]);	return (pd);}

/* * Allocate a radix node. */static __inline struct vm_radix_node *vm_radix_node_get(vm_pindex_t owner, uint16_t count, uint16_t clevel){	struct vm_radix_node *rnode;	rnode = uma_zalloc(vm_radix_node_zone, M_NOWAIT | M_ZERO);	if (rnode == NULL)		return (NULL);	rnode->rn_owner = owner;	rnode->rn_count = count;	rnode->rn_clev = clevel;	return (rnode);}

struct pefs_dircache_entry *pefs_dircache_insert(struct pefs_dircache *pd, struct pefs_tkey *ptk,    char const *name, size_t name_len,    char const *encname, size_t encname_len){	struct pefs_dircache_listhead *head;	struct pefs_dircache_entry *pde;	MPASS(ptk->ptk_key != NULL);	sx_assert(&pd->pd_lock, SA_XLOCKED);	if (name_len == 0 || name_len >= sizeof(pde->pde_name) ||	    encname_len == 0 || encname_len >= sizeof(pde->pde_encname))		panic("pefs: invalid file name length: %zd/%zd",		    name_len, encname_len);	pde = uma_zalloc(dircache_entry_zone, M_WAITOK | M_ZERO);	pde->pde_dircache = pd;	pde->pde_tkey = *ptk;	pefs_key_ref(pde->pde_tkey.ptk_key);	pde->pde_namelen = name_len;	memcpy(pde->pde_name, name, name_len);	pde->pde_name[name_len] = '/0';	pde->pde_namehash = dircache_hashname(pd, pde->pde_name,	    pde->pde_namelen);	pde->pde_encnamelen = encname_len;	memcpy(pde->pde_encname, encname, encname_len);	pde->pde_encname[encname_len] = '/0';	pde->pde_encnamehash = dircache_hashname(pd, pde->pde_encname,	    pde->pde_encnamelen);	/* Insert into list and set pge_gen */	dircache_update(pde, 0);	mtx_lock(&dircache_mtx);	head = &dircache_tbl[pde->pde_namehash & pefs_dircache_hashmask];	LIST_INSERT_HEAD(head, pde, pde_hash_entry);	head = &dircache_enctbl[pde->pde_encnamehash & pefs_dircache_hashmask];	LIST_INSERT_HEAD(head, pde, pde_enchash_entry);	dircache_entries++;	mtx_unlock(&dircache_mtx);	PEFSDEBUG("pefs_dircache_insert: hash=%x enchash=%x: %s -> %s/n",	    pde->pde_namehash, pde->pde_encnamehash,	    pde->pde_name, pde->pde_encname);	return (pde);}

static struct icl_pdu *icl_pdu_new(struct icl_conn *ic, int flags){	struct icl_pdu *ip;	refcount_acquire(&ic->ic_outstanding_pdus);	ip = uma_zalloc(icl_pdu_zone, flags | M_ZERO);	if (ip == NULL) {		ICL_WARN("failed to allocate %zd bytes", sizeof(*ip));		refcount_release(&ic->ic_outstanding_pdus);		return (NULL);	}	ip->ip_conn = ic;	return (ip);}

/** * Install state of type 'type' for a dynamic session. * The hash table contains two type of rules: * - regular rules (O_KEEP_STATE) * - rules for sessions with limited number of sess per user *   (O_LIMIT). When they are created, the parent is *   increased by 1, and decreased on delete. In this case, *   the third parameter is the parent rule and not the chain. * - "parent" rules for the above (O_LIMIT_PARENT). */static ipfw_dyn_rule *add_dyn_rule(struct ipfw_flow_id *id, int i, uint8_t dyn_type,    struct ip_fw *rule, uint16_t kidx){	ipfw_dyn_rule *r;	IPFW_BUCK_ASSERT(i);	r = uma_zalloc(V_ipfw_dyn_rule_zone, M_NOWAIT | M_ZERO);	if (r == NULL) {		if (last_log != time_uptime) {			last_log = time_uptime;			log(LOG_DEBUG,			    "ipfw: Cannot allocate dynamic state, "			    "consider increasing net.inet.ip.fw.dyn_max/n");		}		return NULL;	}	ipfw_dyn_count++;	/*	 * refcount on parent is already incremented, so	 * it is safe to use parent unlocked.	 */	if (dyn_type == O_LIMIT) {		ipfw_dyn_rule *parent = (ipfw_dyn_rule *)rule;		if ( parent->dyn_type != O_LIMIT_PARENT)			panic("invalid parent");		r->parent = parent;		rule = parent->rule;	}	r->id = *id;	r->expire = time_uptime + V_dyn_syn_lifetime;	r->rule = rule;	r->dyn_type = dyn_type;	IPFW_ZERO_DYN_COUNTER(r);	r->count = 0;	r->kidx = kidx;	r->bucket = i;	r->next = V_ipfw_dyn_v[i].head;	V_ipfw_dyn_v[i].head = r;	DEB(print_dyn_rule(id, dyn_type, "add dyn entry", "total");)	return r;

/* * Allocate struct sackhole. */static struct sackhole *tcp_sackhole_alloc(struct tcpcb *tp, tcp_seq start, tcp_seq end){    struct sackhole *hole;    if (tp->snd_numholes >= V_tcp_sack_maxholes ||        V_tcp_sack_globalholes >= V_tcp_sack_globalmaxholes) {        TCPSTAT_INC(tcps_sack_sboverflow);        return NULL;    }    hole = (struct sackhole *)uma_zalloc(V_sack_hole_zone, M_NOWAIT);    if (hole == NULL)        return NULL;    hole->start = start;    hole->end = end;    hole->rxmit = start;    tp->snd_numholes++;    atomic_add_int(&V_tcp_sack_globalholes, 1);    return hole;}

/* * Look up a vnode/nfsnode by file handle. * Callers must check for mount points!! * In all cases, a pointer to a * nfsnode structure is returned. */intnfs_nget(struct mount *mntp, nfsfh_t *fhp, int fhsize, struct nfsnode **npp, int flags){	struct thread *td = curthread;	/* XXX */	struct nfsnode *np;	struct vnode *vp;	struct vnode *nvp;	int error;	u_int hash;	struct nfsmount *nmp;	struct nfs_vncmp ncmp;	nmp = VFSTONFS(mntp);	*npp = NULL;	hash = fnv_32_buf(fhp->fh_bytes, fhsize, FNV1_32_INIT);	ncmp.fhsize = fhsize;	ncmp.fh = fhp;	error = vfs_hash_get(mntp, hash, flags,	    td, &nvp, nfs_vncmpf, &ncmp);	if (error)		return (error);	if (nvp != NULL) {		*npp = VTONFS(nvp);		return (0);	}	/*	 * Allocate before getnewvnode since doing so afterward	 * might cause a bogus v_data pointer to get dereferenced	 * elsewhere if zalloc should block.	 */	np = uma_zalloc(nfsnode_zone, M_WAITOK | M_ZERO);	error = getnewvnode("nfs", mntp, &nfs_vnodeops, &nvp);	if (error) {		uma_zfree(nfsnode_zone, np);		return (error);	}	vp = nvp;	vp->v_bufobj.bo_ops = &buf_ops_nfs;	vp->v_data = np;	np->n_vnode = vp;	/* 	 * Initialize the mutex even if the vnode is going to be a loser.	 * This simplifies the logic in reclaim, which can then unconditionally	 * destroy the mutex (in the case of the loser, or if hash_insert happened	 * to return an error no special casing is needed).	 */	mtx_init(&np->n_mtx, "NFSnode lock", NULL, MTX_DEF);	/*	 * NFS supports recursive and shared locking.	 */	lockmgr(vp->v_vnlock, LK_EXCLUSIVE | LK_NOWITNESS, NULL);	VN_LOCK_AREC(vp);	VN_LOCK_ASHARE(vp);	if (fhsize > NFS_SMALLFH) {		np->n_fhp = malloc(fhsize, M_NFSBIGFH, M_WAITOK);	} else		np->n_fhp = &np->n_fh;	bcopy((caddr_t)fhp, (caddr_t)np->n_fhp, fhsize);	np->n_fhsize = fhsize;	error = insmntque(vp, mntp);	if (error != 0) {		*npp = NULL;		if (np->n_fhsize > NFS_SMALLFH) {			free((caddr_t)np->n_fhp, M_NFSBIGFH);		}		mtx_destroy(&np->n_mtx);		uma_zfree(nfsnode_zone, np);		return (error);	}	error = vfs_hash_insert(vp, hash, flags, 	    td, &nvp, nfs_vncmpf, &ncmp);	if (error)		return (error);	if (nvp != NULL) {		*npp = VTONFS(nvp);		/* vfs_hash_insert() vput()'s the losing vnode */		return (0);	}	*npp = np;	return (0);}

/* * Add information about a transmitted segment to a list. * This is called via the helper hook in tcp_output.c */static intertt_add_tx_segment_info_hook(int hhook_type, int hhook_id, void *udata,    void *ctx_data, void *hdata, struct osd *hosd){	struct ertt *e_t;	struct tcpcb *tp;	struct tcphdr *th;	struct tcpopt *to;	struct tcp_hhook_data *thdp;	struct txseginfo *txsi;	uint32_t len;	int tso;	KASSERT(ctx_data != NULL, ("%s: ctx_data is NULL!", __func__));	KASSERT(hdata != NULL, ("%s: hdata is NULL!", __func__));	e_t = (struct ertt *)hdata;	thdp = ctx_data;	tp = thdp->tp;	th = thdp->th;	to = thdp->to;	len = thdp->len;	tso = thdp->tso;	INP_WLOCK_ASSERT(tp->t_inpcb);	if (len > 0) {		txsi = uma_zalloc(txseginfo_zone, M_NOWAIT);		if (txsi != NULL) {			/* Construct txsi setting the necessary flags. */			txsi->flags = 0; /* Needs to be initialised. */			txsi->seq = ntohl(th->th_seq);			txsi->len = len;			if (tso)				txsi->flags |= TXSI_TSO;			else if (e_t->flags & ERTT_TSO_DISABLED) {				tp->t_flags |= TF_TSO;				e_t->flags &= ~ERTT_TSO_DISABLED;			}			if (e_t->flags & ERTT_MEASUREMENT_IN_PROGRESS) {				e_t->bytes_tx_in_rtt += len;			} else {				txsi->flags |= TXSI_RTT_MEASURE_START;				e_t->flags |= ERTT_MEASUREMENT_IN_PROGRESS;				e_t->bytes_tx_in_rtt = len;			}			if (((tp->t_flags & TF_NOOPT) == 0) &&			    (to->to_flags & TOF_TS)) {				txsi->tx_ts = ntohl(to->to_tsval) -				    tp->ts_offset;				txsi->rx_ts = ntohl(to->to_tsecr);			} else {				txsi->tx_ts = tcp_ts_getticks();				txsi->rx_ts = 0; /* No received time stamp. */			}			TAILQ_INSERT_TAIL(&e_t->txsegi_q, txsi, txsegi_lnk);		}	}	return (0);}

/** * Install state of type 'type' for a dynamic session. * The hash table contains two type of rules: * - regular rules (O_KEEP_STATE) * - rules for sessions with limited number of sess per user *   (O_LIMIT). When they are created, the parent is *   increased by 1, and decreased on delete. In this case, *   the third parameter is the parent rule and not the chain. * - "parent" rules for the above (O_LIMIT_PARENT). */static ipfw_dyn_rule *add_dyn_rule(struct ipfw_flow_id *id, u_int8_t dyn_type, struct ip_fw *rule){	ipfw_dyn_rule *r;	int i;	IPFW_DYN_LOCK_ASSERT();	if (V_ipfw_dyn_v == NULL ||	    (V_dyn_count == 0 && V_dyn_buckets != V_curr_dyn_buckets)) {		realloc_dynamic_table();		if (V_ipfw_dyn_v == NULL)			return NULL; /* failed ! */	}	i = hash_packet(id);	r = uma_zalloc(ipfw_dyn_rule_zone, M_NOWAIT | M_ZERO);	if (r == NULL) {		printf ("ipfw: sorry cannot allocate state/n");		return NULL;	}	/* increase refcount on parent, and set pointer */	if (dyn_type == O_LIMIT) {		ipfw_dyn_rule *parent = (ipfw_dyn_rule *)rule;		if ( parent->dyn_type != O_LIMIT_PARENT)			panic("invalid parent");		parent->count++;		r->parent = parent;		rule = parent->rule;	}	r->id = *id;	r->expire = time_uptime + V_dyn_syn_lifetime;	r->rule = rule;	r->dyn_type = dyn_type;	r->pcnt = r->bcnt = 0;	r->count = 0;	r->bucket = i;	r->next = V_ipfw_dyn_v[i];	V_ipfw_dyn_v[i] = r;	V_dyn_count++;	DEB({		struct in_addr da;#ifdef INET6		char src[INET6_ADDRSTRLEN];		char dst[INET6_ADDRSTRLEN];#else		char src[INET_ADDRSTRLEN];		char dst[INET_ADDRSTRLEN];#endif#ifdef INET6		if (IS_IP6_FLOW_ID(&(r->id))) {			ip6_sprintf(src, &r->id.src_ip6);			ip6_sprintf(dst, &r->id.dst_ip6);		} else#endif		{			da.s_addr = htonl(r->id.src_ip);			inet_ntoa_r(da, src);			da.s_addr = htonl(r->id.dst_ip);			inet_ntoa_r(da, dst);		}		printf("ipfw: add dyn entry ty %d %s %d -> %s %d, total %d/n",		    dyn_type, src, r->id.src_port, dst, r->id.dst_port,		    V_dyn_count);	})	return r;

struct label *mac_labelzone_alloc(int flags){    return (uma_zalloc(zone_label, flags));}

/* * Move a TCP connection into TIME_WAIT state. *    tcbinfo is locked. *    inp is locked, and is unlocked before returning. */voidtcp_twstart(struct tcpcb *tp){    struct tcptw *tw;    struct inpcb *inp = tp->t_inpcb;    int acknow;    struct socket *so;#ifdef INET6//ScenSim-Port//    int isipv6 = inp->inp_inc.inc_flags & INC_ISIPV6;#endif//ScenSim-Port//    INP_INFO_WLOCK_ASSERT(&V_tcbinfo);  /* tcp_tw_2msl_reset(). *///ScenSim-Port//    INP_WLOCK_ASSERT(inp);//ScenSim-Port//    if (V_nolocaltimewait) {//ScenSim-Port//        int error = 0;//ScenSim-Port//#ifdef INET6//ScenSim-Port//        if (isipv6)//ScenSim-Port//            error = in6_localaddr(&inp->in6p_faddr);//ScenSim-Port//#endif//ScenSim-Port//#if defined(INET6) && defined(INET)//ScenSim-Port//        else//ScenSim-Port//#endif//ScenSim-Port//#ifdef INET//ScenSim-Port//            error = in_localip(inp->inp_faddr);//ScenSim-Port//#endif//ScenSim-Port//        if (error) {//ScenSim-Port//            tp = tcp_close(tp);//ScenSim-Port//            if (tp != NULL)//ScenSim-Port//                INP_WUNLOCK(inp);//ScenSim-Port//            return;//ScenSim-Port//        }//ScenSim-Port//    }//ScenSim-Port//    tw = uma_zalloc(V_tcptw_zone, M_NOWAIT);    tw = (struct tcptw *)uma_zalloc(V_tcptw_zone, M_NOWAIT);    //ScenSim-Port//    if (tw == NULL) {        tw = tcp_tw_2msl_scan(1);        if (tw == NULL) {            tp = tcp_close(tp);//ScenSim-Port//            if (tp != NULL)//ScenSim-Port//                INP_WUNLOCK(inp);            return;        }    }    tw->tw_inpcb = inp;    /*     * Recover last window size sent.     *///ScenSim-Port//    KASSERT(SEQ_GEQ(tp->rcv_adv, tp->rcv_nxt),//ScenSim-Port//        ("tcp_twstart negative window: tp %p rcv_nxt %u rcv_adv %u", tp,//ScenSim-Port//        tp->rcv_nxt, tp->rcv_adv));    tw->last_win = (tp->rcv_adv - tp->rcv_nxt) >> tp->rcv_scale;    /*     * Set t_recent if timestamps are used on the connection.     */    if ((tp->t_flags & (TF_REQ_TSTMP|TF_RCVD_TSTMP|TF_NOOPT)) ==        (TF_REQ_TSTMP|TF_RCVD_TSTMP)) {        tw->t_recent = tp->ts_recent;        tw->ts_offset = tp->ts_offset;    } else {        tw->t_recent = 0;        tw->ts_offset = 0;    }    tw->snd_nxt = tp->snd_nxt;    tw->rcv_nxt = tp->rcv_nxt;    tw->iss     = tp->iss;    tw->irs     = tp->irs;    tw->t_starttime = tp->t_starttime;    tw->tw_time = 0;/* XXX * If this code will * be used for fin-wait-2 state also, then we may need * a ts_recent from the last segment. */    acknow = tp->t_flags & TF_ACKNOW;    /*     * First, discard tcpcb state, which includes stopping its timers and     * freeing it.  tcp_discardcb() used to also release the inpcb, but     * that work is now done in the caller.     *     * Note: soisdisconnected() call used to be made in tcp_discardcb(),     * and might not be needed here any longer.     */    tcp_discardcb(tp);    so = inp->inp_socket;    soisdisconnected(so);//ScenSim-Port//    tw->tw_cred = crhold(so->so_cred);//ScenSim-Port//    SOCK_LOCK(so);    tw->tw_so_options = so->so_options;//.........这里部分代码省略.........

/* * Try to open the given VCC. */static inthatm_open_vcc(struct hatm_softc *sc, struct atmio_openvcc *arg){	u_int cid;	struct hevcc *vcc;	int error = 0;	DBG(sc, VCC, ("Open VCC: %u.%u flags=%#x", arg->param.vpi,	    arg->param.vci, arg->param.flags));	if ((arg->param.vpi & ~HE_VPI_MASK) ||	    (arg->param.vci & ~HE_VCI_MASK) ||	    (arg->param.vci == 0))		return (EINVAL);	cid = HE_CID(arg->param.vpi, arg->param.vci);	if ((arg->param.flags & ATMIO_FLAG_NOTX) &&	    (arg->param.flags & ATMIO_FLAG_NORX))		return (EINVAL);	vcc = uma_zalloc(sc->vcc_zone, M_NOWAIT | M_ZERO);	if (vcc == NULL)		return (ENOMEM);	mtx_lock(&sc->mtx);	if (!(sc->ifp->if_drv_flags & IFF_DRV_RUNNING)) {		error = EIO;		goto done;	}	if (sc->vccs[cid] != NULL) {		error = EBUSY;		goto done;	}	vcc->param = arg->param;	vcc->rxhand = arg->rxhand;	switch (vcc->param.aal) {	  case ATMIO_AAL_0:	  case ATMIO_AAL_5:	  case ATMIO_AAL_RAW:		break;	  default:		error = EINVAL;		goto done;	}	switch (vcc->param.traffic) {	  case ATMIO_TRAFFIC_UBR:	  case ATMIO_TRAFFIC_CBR:	  case ATMIO_TRAFFIC_ABR:		break;	  default:		error = EINVAL;		goto done;	}	vcc->ntpds = 0;	vcc->chain = vcc->last = NULL;	vcc->ibytes = vcc->ipackets = 0;	vcc->obytes = vcc->opackets = 0;	if (!(vcc->param.flags & ATMIO_FLAG_NOTX) &&	     (error = hatm_tx_vcc_can_open(sc, cid, vcc)) != 0)		goto done;	/* ok - go ahead */	sc->vccs[cid] = vcc;	hatm_load_vc(sc, cid, 0);	/* don't free below */	vcc = NULL;	sc->open_vccs++;  done:	mtx_unlock(&sc->mtx);	if (vcc != NULL)		uma_zfree(sc->vcc_zone, vcc);	return (error);}

//.........这里部分代码省略.........	 * Don't allow a nonprivileged user to use the last ten	 * processes; don't let root exceed the limit.	 */	nprocs_new = atomic_fetchadd_int(&nprocs, 1) + 1;	if ((nprocs_new >= maxproc - 10 && priv_check_cred(td->td_ucred,	    PRIV_MAXPROC, 0) != 0) || nprocs_new >= maxproc) {		error = EAGAIN;		sx_xlock(&allproc_lock);		if (ppsratecheck(&lastfail, &curfail, 1)) {			printf("maxproc limit exceeded by uid %u (pid %d); "			    "see tuning(7) and login.conf(5)/n",			    td->td_ucred->cr_ruid, p1->p_pid);		}		sx_xunlock(&allproc_lock);		goto fail2;	}	/*	 * If required, create a process descriptor in the parent first; we	 * will abandon it if something goes wrong. We don't finit() until	 * later.	 */	if (flags & RFPROCDESC) {		error = procdesc_falloc(td, &fp_procdesc, fr->fr_pd_fd,		    fr->fr_pd_flags, fr->fr_pd_fcaps);		if (error != 0)			goto fail2;	}	mem_charged = 0;	if (pages == 0)		pages = kstack_pages;	/* Allocate new proc. */	newproc = uma_zalloc(proc_zone, M_WAITOK);	td2 = FIRST_THREAD_IN_PROC(newproc);	if (td2 == NULL) {		td2 = thread_alloc(pages);		if (td2 == NULL) {			error = ENOMEM;			goto fail2;		}		proc_linkup(newproc, td2);	} else {		if (td2->td_kstack == 0 || td2->td_kstack_pages != pages) {			if (td2->td_kstack != 0)				vm_thread_dispose(td2);			if (!thread_alloc_stack(td2, pages)) {				error = ENOMEM;				goto fail2;			}		}	}	if ((flags & RFMEM) == 0) {		vm2 = vmspace_fork(p1->p_vmspace, &mem_charged);		if (vm2 == NULL) {			error = ENOMEM;			goto fail2;		}		if (!swap_reserve(mem_charged)) {			/*			 * The swap reservation failed. The accounting			 * from the entries of the copied vm2 will be			 * subtracted in vmspace_free(), so force the			 * reservation there.			 */

/* *	malloc: * *	Allocate a block of memory. * *	If M_NOWAIT is set, this routine will not block and return NULL if *	the allocation fails. */void *malloc(unsigned long size, struct malloc_type *mtp, int flags){	int indx;	struct malloc_type_internal *mtip;	caddr_t va;	uma_zone_t zone;#if defined(DIAGNOSTIC) || defined(DEBUG_REDZONE)	unsigned long osize = size;#endif#ifdef INVARIANTS	KASSERT(mtp->ks_magic == M_MAGIC, ("malloc: bad malloc type magic"));	/*	 * Check that exactly one of M_WAITOK or M_NOWAIT is specified.	 */	indx = flags & (M_WAITOK | M_NOWAIT);	if (indx != M_NOWAIT && indx != M_WAITOK) {		static	struct timeval lasterr;		static	int curerr, once;		if (once == 0 && ppsratecheck(&lasterr, &curerr, 1)) {			printf("Bad malloc flags: %x/n", indx);			kdb_backtrace();			flags |= M_WAITOK;			once++;		}	}#endif#ifdef MALLOC_MAKE_FAILURES	if ((flags & M_NOWAIT) && (malloc_failure_rate != 0)) {		atomic_add_int(&malloc_nowait_count, 1);		if ((malloc_nowait_count % malloc_failure_rate) == 0) {			atomic_add_int(&malloc_failure_count, 1);			t_malloc_fail = time_uptime;			return (NULL);		}	}#endif	if (flags & M_WAITOK)		KASSERT(curthread->td_intr_nesting_level == 0,		   ("malloc(M_WAITOK) in interrupt context"));#ifdef DEBUG_MEMGUARD	if (memguard_cmp_mtp(mtp, size)) {		va = memguard_alloc(size, flags);		if (va != NULL)			return (va);		/* This is unfortunate but should not be fatal. */	}#endif#ifdef DEBUG_REDZONE	size = redzone_size_ntor(size);#endif	if (size <= kmem_zmax) {		mtip = mtp->ks_handle;		if (size & KMEM_ZMASK)			size = (size & ~KMEM_ZMASK) + KMEM_ZBASE;		indx = kmemsize[size >> KMEM_ZSHIFT];		KASSERT(mtip->mti_zone < numzones,		    ("mti_zone %u out of range %d",		    mtip->mti_zone, numzones));		zone = kmemzones[indx].kz_zone[mtip->mti_zone];#ifdef MALLOC_PROFILE		krequests[size >> KMEM_ZSHIFT]++;#endif		va = uma_zalloc(zone, flags);		if (va != NULL)			size = zone->uz_size;		malloc_type_zone_allocated(mtp, va == NULL ? 0 : size, indx);	} else {

intudf_vget(struct mount *mp, ino_t ino, int flags, struct vnode **vpp){	struct buf *bp;	struct vnode *devvp;	struct udf_mnt *udfmp;	struct thread *td;	struct vnode *vp;	struct udf_node *unode;	struct file_entry *fe;	int error, sector, size;	error = vfs_hash_get(mp, ino, flags, curthread, vpp, NULL, NULL);	if (error || *vpp != NULL)		return (error);	/*	 * We must promote to an exclusive lock for vnode creation.  This	 * can happen if lookup is passed LOCKSHARED. 	 */	if ((flags & LK_TYPE_MASK) == LK_SHARED) {		flags &= ~LK_TYPE_MASK;		flags |= LK_EXCLUSIVE;	}	/*	 * We do not lock vnode creation as it is believed to be too	 * expensive for such rare case as simultaneous creation of vnode	 * for same ino by different processes. We just allow them to race	 * and check later to decide who wins. Let the race begin!	 */	td = curthread;	udfmp = VFSTOUDFFS(mp);	unode = uma_zalloc(udf_zone_node, M_WAITOK | M_ZERO);	if ((error = udf_allocv(mp, &vp, td))) {		printf("Error from udf_allocv/n");		uma_zfree(udf_zone_node, unode);		return (error);	}	unode->i_vnode = vp;	unode->hash_id = ino;	unode->udfmp = udfmp;	vp->v_data = unode;	lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL);	error = insmntque(vp, mp);	if (error != 0) {		uma_zfree(udf_zone_node, unode);		return (error);	}	error = vfs_hash_insert(vp, ino, flags, td, vpp, NULL, NULL);	if (error || *vpp != NULL)		return (error);	/*	 * Copy in the file entry.  Per the spec, the size can only be 1 block.	 */	sector = ino + udfmp->part_start;	devvp = udfmp->im_devvp;	if ((error = RDSECTOR(devvp, sector, udfmp->bsize, &bp)) != 0) {		printf("Cannot read sector %d/n", sector);		vgone(vp);		vput(vp);		brelse(bp);		*vpp = NULL;		return (error);	}	fe = (struct file_entry *)bp->b_data;	if (udf_checktag(&fe->tag, TAGID_FENTRY)) {		printf("Invalid file entry!/n");		vgone(vp);		vput(vp);		brelse(bp);		*vpp = NULL;		return (ENOMEM);	}	size = UDF_FENTRY_SIZE + le32toh(fe->l_ea) + le32toh(fe->l_ad);	unode->fentry = malloc(size, M_UDFFENTRY, M_NOWAIT | M_ZERO);	if (unode->fentry == NULL) {		printf("Cannot allocate file entry block/n");		vgone(vp);		vput(vp);		brelse(bp);		*vpp = NULL;		return (ENOMEM);	}	bcopy(bp->b_data, unode->fentry, size);		brelse(bp);	bp = NULL;	switch (unode->fentry->icbtag.file_type) {	default:		vp->v_type = VBAD;//.........这里部分代码省略.........

/* * ONLY USED FOR THE ROOT DIRECTORY. nfscl_nget() does the rest. If this * function is going to be used to get Regular Files, code must be added * to fill in the "struct nfsv4node". * Look up a vnode/nfsnode by file handle. * Callers must check for mount points!! * In all cases, a pointer to a * nfsnode structure is returned. */intncl_nget(struct mount *mntp, u_int8_t *fhp, int fhsize, struct nfsnode **npp,    int lkflags){	struct thread *td = curthread;	/* XXX */	struct nfsnode *np;	struct vnode *vp;	struct vnode *nvp;	int error;	u_int hash;	struct nfsmount *nmp;	struct nfsfh *nfhp;	nmp = VFSTONFS(mntp);	*npp = NULL;	hash = fnv_32_buf(fhp, fhsize, FNV1_32_INIT);	MALLOC(nfhp, struct nfsfh *, sizeof (struct nfsfh) + fhsize,	    M_NFSFH, M_WAITOK);	bcopy(fhp, &nfhp->nfh_fh[0], fhsize);	nfhp->nfh_len = fhsize;	error = vfs_hash_get(mntp, hash, lkflags,	    td, &nvp, newnfs_vncmpf, nfhp);	FREE(nfhp, M_NFSFH);	if (error)		return (error);	if (nvp != NULL) {		*npp = VTONFS(nvp);		return (0);	}	np = uma_zalloc(newnfsnode_zone, M_WAITOK | M_ZERO);	error = getnewvnode("newnfs", mntp, &newnfs_vnodeops, &nvp);	if (error) {		uma_zfree(newnfsnode_zone, np);		return (error);	}	vp = nvp;	KASSERT(vp->v_bufobj.bo_bsize != 0, ("ncl_nget: bo_bsize == 0"));	vp->v_bufobj.bo_ops = &buf_ops_newnfs;	vp->v_data = np;	np->n_vnode = vp;	/* 	 * Initialize the mutex even if the vnode is going to be a loser.	 * This simplifies the logic in reclaim, which can then unconditionally	 * destroy the mutex (in the case of the loser, or if hash_insert	 * happened to return an error no special casing is needed).	 */	mtx_init(&np->n_mtx, "NEWNFSnode lock", NULL, MTX_DEF | MTX_DUPOK);	/*	 * NFS supports recursive and shared locking.	 */	lockmgr(vp->v_vnlock, LK_EXCLUSIVE | LK_NOWITNESS, NULL);	VN_LOCK_AREC(vp);	VN_LOCK_ASHARE(vp);	/* 	 * Are we getting the root? If so, make sure the vnode flags	 * are correct 	 */	if ((fhsize == nmp->nm_fhsize) &&	    !bcmp(fhp, nmp->nm_fh, fhsize)) {		if (vp->v_type == VNON)			vp->v_type = VDIR;		vp->v_vflag |= VV_ROOT;	}		MALLOC(np->n_fhp, struct nfsfh *, sizeof (struct nfsfh) + fhsize,	    M_NFSFH, M_WAITOK);	bcopy(fhp, np->n_fhp->nfh_fh, fhsize);	np->n_fhp->nfh_len = fhsize;	error = insmntque(vp, mntp);	if (error != 0) {		*npp = NULL;		FREE((caddr_t)np->n_fhp, M_NFSFH);		mtx_destroy(&np->n_mtx);		uma_zfree(newnfsnode_zone, np);		return (error);	}	error = vfs_hash_insert(vp, hash, lkflags, 	    td, &nvp, newnfs_vncmpf, np->n_fhp);	if (error)		return (error);	if (nvp != NULL) {		*npp = VTONFS(nvp);		/* vfs_hash_insert() vput()'s the losing vnode */		return (0);	}	*npp = np;	return (0);//.........这里部分代码省略.........