#define MEMZALLOC(PTR, CAST, SIZE) \
((PTR) = (CAST)kmalloc((SIZE), M_NG_SSCFU_INS, M_WAITOK | M_NULLOK | M_ZERO))
#define MEMFREE(PTR) \
- FREE(PTR, M_NG_SSCFU_INS)
+ kfree(PTR, M_NG_SSCFU_INS)
#define SIG_ALLOC(PTR) \
((PTR) = kmalloc(sizeof(struct sscfu_sig), \
M_NG_SSCFU_SIG, M_WAITOK | M_NULLOK | M_ZERO))
#define SIG_FREE(PTR) \
- FREE(PTR, M_NG_SSCFU_SIG)
+ kfree(PTR, M_NG_SSCFU_SIG)
#endif
return (error);
/* Initialize private struct */
- MALLOC(sc, ng_h4_info_p, sizeof(*sc), M_NETGRAPH_H4, M_WAITOK | M_NULLOK | M_ZERO);
+ sc = kmalloc(sizeof(*sc), M_NETGRAPH_H4, M_WAITOK | M_NULLOK | M_ZERO);
if (sc == NULL)
return (ENOMEM);
mtx_destroy(&sc->outq.ifq_mtx);
bzero(sc, sizeof(*sc));
- FREE(sc, M_NETGRAPH_H4);
+ kfree(sc, M_NETGRAPH_H4);
lwkt_reltoken(&tty_token);
return (error);
NG_NODE_UNREF(sc->node);
mtx_destroy(&sc->outq.ifq_mtx);
bzero(sc, sizeof(*sc));
- FREE(sc, M_NETGRAPH_H4);
+ kfree(sc, M_NETGRAPH_H4);
lwkt_reltoken(&tty_token);
return (error);
NG_NODE_UNREF(node);
mtx_destroy(&sc->outq.ifq_mtx);
bzero(sc, sizeof(*sc));
- FREE(sc, M_NETGRAPH_H4);
+ kfree(sc, M_NETGRAPH_H4);
return (0);
} /* ng_h4_shutdown */
{
ng_hci_unit_p unit = NULL;
- MALLOC(unit, ng_hci_unit_p, sizeof(*unit), M_NETGRAPH_HCI,
- M_WAITOK | M_NULLOK | M_ZERO);
+ unit = kmalloc(sizeof(*unit), M_NETGRAPH_HCI,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (unit == NULL)
return (ENOMEM);
NG_BT_MBUFQ_DESTROY(&unit->cmdq);
bzero(unit, sizeof(*unit));
- FREE(unit, M_NETGRAPH_HCI);
+ kfree(unit, M_NETGRAPH_HCI);
return (0);
} /* ng_hci_shutdown */
{
ng_hci_neighbor_p n = NULL;
- MALLOC(n, ng_hci_neighbor_p, sizeof(*n), M_NETGRAPH_HCI,
- M_WAITOK | M_NULLOK | M_ZERO);
+ n = kmalloc(sizeof(*n), M_NETGRAPH_HCI, M_WAITOK | M_NULLOK | M_ZERO);
if (n != NULL) {
getmicrotime(&n->updated);
LIST_INSERT_HEAD(&unit->neighbors, n, next);
{
LIST_REMOVE(n, next);
bzero(n, sizeof(*n));
- FREE(n, M_NETGRAPH_HCI);
+ kfree(n, M_NETGRAPH_HCI);
} /* ng_hci_free_neighbor */
/*
int num_pkts;
static int fake_con_handle = 0x0f00;
- MALLOC(con, ng_hci_unit_con_p, sizeof(*con), M_NETGRAPH_HCI,
- M_WAITOK | M_NULLOK | M_ZERO);
+ con = kmalloc(sizeof(*con), M_NETGRAPH_HCI,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (con != NULL) {
con->unit = unit;
con->state = NG_HCI_CON_CLOSED;
NG_BT_ITEMQ_DESTROY(&con->conq);
bzero(con, sizeof(*con));
- FREE(con, M_NETGRAPH_HCI);
+ kfree(con, M_NETGRAPH_HCI);
} /* ng_hci_free_con */
/*
ng_l2cap_p l2cap = NULL;
/* Create new L2CAP node */
- MALLOC(l2cap, ng_l2cap_p, sizeof(*l2cap),
- M_NETGRAPH_L2CAP, M_WAITOK | M_NULLOK | M_ZERO);
+ l2cap = kmalloc(sizeof(*l2cap), M_NETGRAPH_L2CAP,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (l2cap == NULL)
return (ENOMEM);
ng_l2cap_cleanup(l2cap);
bzero(l2cap, sizeof(*l2cap));
- FREE(l2cap, M_NETGRAPH_L2CAP);
+ kfree(l2cap, M_NETGRAPH_L2CAP);
return (0);
} /* ng_l2cap_shutdown */
ng_l2cap_con_p con = NULL;
/* Create new connection descriptor */
- MALLOC(con, ng_l2cap_con_p, sizeof(*con), M_NETGRAPH_L2CAP,
- M_WAITOK | M_NULLOK | M_ZERO);
+ con = kmalloc(sizeof(*con), M_NETGRAPH_L2CAP,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (con == NULL)
return (NULL);
LIST_REMOVE(con, next);
bzero(con, sizeof(*con));
- FREE(con, M_NETGRAPH_L2CAP);
+ kfree(con, M_NETGRAPH_L2CAP);
} /* ng_l2cap_free_con */
/*
{
ng_l2cap_chan_p ch = NULL;
- MALLOC(ch, ng_l2cap_chan_p, sizeof(*ch), M_NETGRAPH_L2CAP,
- M_WAITOK | M_NULLOK | M_ZERO);
+ ch = kmalloc(sizeof(*ch), M_NETGRAPH_L2CAP,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (ch == NULL)
return (NULL);
ng_l2cap_con_ref(con);
} else {
bzero(ch, sizeof(*ch));
- FREE(ch, M_NETGRAPH_L2CAP);
+ kfree(ch, M_NETGRAPH_L2CAP);
ch = NULL;
}
ng_l2cap_con_unref(ch->con);
bzero(ch, sizeof(*ch));
- FREE(ch, M_NETGRAPH_L2CAP);
+ kfree(ch, M_NETGRAPH_L2CAP);
} /* ng_l2cap_free_chan */
/*
("%s: %s - invalid channel pointer!\n",
__func__, NG_NODE_NAME(con->l2cap->node)));
- MALLOC(cmd, ng_l2cap_cmd_p, sizeof(*cmd), M_NETGRAPH_L2CAP,
- M_WAITOK | M_NULLOK | M_ZERO);
+ cmd = kmalloc(sizeof(*cmd), M_NETGRAPH_L2CAP,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (cmd == NULL)
return (NULL);
KASSERT(!callout_pending(&(cmd)->timo), ("Pending callout!")); \
NG_FREE_M((cmd)->aux); \
bzero((cmd), sizeof(*(cmd))); \
- FREE((cmd), M_NETGRAPH_L2CAP); \
+ kfree((cmd), M_NETGRAPH_L2CAP); \
} while (0)
ng_l2cap_cmd_p ng_l2cap_new_cmd (ng_l2cap_con_p, ng_l2cap_chan_p,
ng_btsocket_hci_raw_sec_filter = NULL;
- MALLOC(ng_btsocket_hci_raw_sec_filter,
- struct ng_btsocket_hci_raw_sec_filter *,
- sizeof(struct ng_btsocket_hci_raw_sec_filter),
- M_NETGRAPH_BTSOCKET_HCI_RAW, M_WAITOK | M_NULLOK | M_ZERO);
+ ng_btsocket_hci_raw_sec_filter = kmalloc(sizeof(struct ng_btsocket_hci_raw_sec_filter),
+ M_NETGRAPH_BTSOCKET_HCI_RAW,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (ng_btsocket_hci_raw_sec_filter == NULL) {
printf("%s: Could not allocate security filter!\n", __func__);
return;
if (error != 0)
return (error);
- MALLOC(pcb, ng_btsocket_hci_raw_pcb_p, sizeof(*pcb),
- M_NETGRAPH_BTSOCKET_HCI_RAW, M_WAITOK | M_NULLOK | M_ZERO);
+ pcb = kmalloc(sizeof(*pcb), M_NETGRAPH_BTSOCKET_HCI_RAW,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (pcb == NULL)
return (ENOMEM);
mtx_destroy(&pcb->pcb_mtx);
bzero(pcb, sizeof(*pcb));
- FREE(pcb, M_NETGRAPH_BTSOCKET_HCI_RAW);
+ kfree(pcb, M_NETGRAPH_BTSOCKET_HCI_RAW);
so->so_pcb = NULL;
} /* ng_btsocket_hci_raw_detach */
rt = (ng_btsocket_l2cap_rtentry_t *) NG_HOOK_PRIVATE(hook);
if (rt == NULL) {
- MALLOC(rt, ng_btsocket_l2cap_rtentry_p, sizeof(*rt),
- M_NETGRAPH_BTSOCKET_L2CAP, M_WAITOK | M_NULLOK | M_ZERO);
+ rt = kmalloc(sizeof(*rt), M_NETGRAPH_BTSOCKET_L2CAP,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (rt == NULL) {
mtx_unlock(&ng_btsocket_l2cap_rt_mtx);
break;
NG_HOOK_UNREF(rt->hook); /* Remove extra reference */
bzero(rt, sizeof(*rt));
- FREE(rt, M_NETGRAPH_BTSOCKET_L2CAP);
+ kfree(rt, M_NETGRAPH_BTSOCKET_L2CAP);
}
rt = rt_next;
}
/* Allocate the PCB */
- MALLOC(pcb, ng_btsocket_l2cap_pcb_p, sizeof(*pcb),
- M_NETGRAPH_BTSOCKET_L2CAP, M_WAITOK | M_NULLOK | M_ZERO);
+ pcb = kmalloc(sizeof(*pcb), M_NETGRAPH_BTSOCKET_L2CAP,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (pcb == NULL)
return (ENOMEM);
mtx_destroy(&pcb->pcb_mtx);
bzero(pcb, sizeof(*pcb));
- FREE(pcb, M_NETGRAPH_BTSOCKET_L2CAP);
+ kfree(pcb, M_NETGRAPH_BTSOCKET_L2CAP);
soisdisconnected(so);
so->so_pcb = NULL;
rt = (ng_btsocket_l2cap_rtentry_t *)
NG_HOOK_PRIVATE(hook);
if (rt == NULL) {
- MALLOC(rt, ng_btsocket_l2cap_rtentry_p,
- sizeof(*rt),
- M_NETGRAPH_BTSOCKET_L2CAP_RAW,
- M_WAITOK | M_NULLOK | M_ZERO);
+ rt = kmalloc(sizeof(*rt),
+ M_NETGRAPH_BTSOCKET_L2CAP_RAW,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (rt == NULL)
break;
NG_HOOK_UNREF(rt->hook); /* Remove extra reference */
bzero(rt, sizeof(*rt));
- FREE(rt, M_NETGRAPH_BTSOCKET_L2CAP_RAW);
+ kfree(rt, M_NETGRAPH_BTSOCKET_L2CAP_RAW);
}
rt = rt_next;
return (error);
/* Allocate the PCB */
- MALLOC(pcb, ng_btsocket_l2cap_raw_pcb_p, sizeof(*pcb),
- M_NETGRAPH_BTSOCKET_L2CAP_RAW, M_WAITOK | M_NULLOK | M_ZERO);
+ pcb = kmalloc(sizeof(*pcb), M_NETGRAPH_BTSOCKET_L2CAP_RAW,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (pcb == NULL)
return (ENOMEM);
mtx_destroy(&pcb->pcb_mtx);
bzero(pcb, sizeof(*pcb));
- FREE(pcb, M_NETGRAPH_BTSOCKET_L2CAP_RAW);
+ kfree(pcb, M_NETGRAPH_BTSOCKET_L2CAP_RAW);
so->so_pcb = NULL;
} /* ng_btsocket_l2cap_raw_detach */
}
/* Allocate the PCB */
- MALLOC(pcb, ng_btsocket_rfcomm_pcb_p, sizeof(*pcb),
- M_NETGRAPH_BTSOCKET_RFCOMM, M_WAITOK | M_NULLOK | M_ZERO);
+ pcb = kmalloc(sizeof(*pcb), M_NETGRAPH_BTSOCKET_RFCOMM,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (pcb == NULL)
return (ENOMEM);
mtx_destroy(&pcb->pcb_mtx);
bzero(pcb, sizeof(*pcb));
- FREE(pcb, M_NETGRAPH_BTSOCKET_RFCOMM);
+ kfree(pcb, M_NETGRAPH_BTSOCKET_RFCOMM);
soisdisconnected(so);
sofree(so); /* for so_pcb = NULL */
mtx_destroy(&s->session_mtx);
bzero(s, sizeof(*s));
- FREE(s, M_NETGRAPH_BTSOCKET_RFCOMM);
+ kfree(s, M_NETGRAPH_BTSOCKET_RFCOMM);
} else
mtx_unlock(&s->session_mtx);
mtx_assert(&ng_btsocket_rfcomm_sessions_mtx, MA_OWNED);
/* Allocate the RFCOMM session */
- MALLOC(s, ng_btsocket_rfcomm_session_p, sizeof(*s),
- M_NETGRAPH_BTSOCKET_RFCOMM, M_WAITOK | M_NULLOK | M_ZERO);
+ s = kmalloc(sizeof(*s), M_NETGRAPH_BTSOCKET_RFCOMM,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (s == NULL)
return (ENOMEM);
mtx_destroy(&s->session_mtx);
bzero(s, sizeof(*s));
- FREE(s, M_NETGRAPH_BTSOCKET_RFCOMM);
+ kfree(s, M_NETGRAPH_BTSOCKET_RFCOMM);
return (error);
} /* ng_btsocket_rfcomm_session_create */
uma_zone_set_max(priv->zone, CACHESIZE);
/* Allocate hash. */
- MALLOC(priv->hash, struct flow_hash_entry *,
- NBUCKETS * sizeof(struct flow_hash_entry),
- M_NETFLOW_HASH, M_WAITOK | M_ZERO);
+ priv->hash = kmalloc(NBUCKETS * sizeof(struct flow_hash_entry),
+ M_NETFLOW_HASH, M_WAITOK | M_ZERO);
if (priv->hash == NULL) {
uma_zdestroy(priv->zone);
/* Free hash memory. */
if (priv->hash)
- FREE(priv->hash, M_NETFLOW_HASH);
+ kfree(priv->hash, M_NETFLOW_HASH);
mtx_destroy(&priv->export_mtx);
}
int error = 0;
/* Initialize private data */
- MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_WAITOK | M_NULLOK);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH, M_WAITOK | M_NULLOK);
if (priv == NULL)
return (ENOMEM);
bzero(priv, sizeof(*priv));
NG_NODE_SET_PRIVATE(node, NULL);
NG_NODE_UNREF(priv->node);
- FREE(priv, M_NETGRAPH);
+ kfree(priv, M_NETGRAPH);
return (0);
}
#define NG_FREE_MSG(msg) \
do { \
if ((msg)) { \
- FREE((msg), M_NETGRAPH_MSG); \
+ kfree((msg), M_NETGRAPH_MSG); \
(msg) = NULL; \
} \
} while (0)
priv_p priv;
/* Allocate private structure */
- MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_WAITOK | M_NULLOK | M_ZERO);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (priv == NULL) {
return (ENOMEM);
}
const priv_p priv = NG_NODE_PRIVATE(node);
/* Take down netgraph node */
- FREE(priv, M_NETGRAPH);
+ kfree(priv, M_NETGRAPH);
NG_NODE_SET_PRIVATE(node, NULL);
NG_NODE_UNREF(node);
return (0);
{
sc_p sc;
- MALLOC(sc, sc_p, sizeof(*sc), M_NETGRAPH_ASYNC, M_WAITOK | M_NULLOK | M_ZERO);
+ sc = kmalloc(sizeof(*sc), M_NETGRAPH_ASYNC,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (sc == NULL)
return (ENOMEM);
sc->amode = MODE_HUNT;
sc->cfg.accm = ~0;
sc->cfg.amru = NG_ASYNC_DEFAULT_MRU;
sc->cfg.smru = NG_ASYNC_DEFAULT_MRU;
- MALLOC(sc->abuf, u_char *,
- ASYNC_BUF_SIZE(sc->cfg.smru), M_NETGRAPH_ASYNC, M_WAITOK | M_NULLOK);
+ sc->abuf = kmalloc(ASYNC_BUF_SIZE(sc->cfg.smru), M_NETGRAPH_ASYNC,
+ M_WAITOK | M_NULLOK);
if (sc->abuf == NULL)
goto fail;
- MALLOC(sc->sbuf, u_char *,
- SYNC_BUF_SIZE(sc->cfg.amru), M_NETGRAPH_ASYNC, M_WAITOK | M_NULLOK);
+ sc->sbuf = kmalloc(SYNC_BUF_SIZE(sc->cfg.amru), M_NETGRAPH_ASYNC,
+ M_WAITOK | M_NULLOK);
if (sc->sbuf == NULL) {
- FREE(sc->abuf, M_NETGRAPH_ASYNC);
+ kfree(sc->abuf, M_NETGRAPH_ASYNC);
fail:
- FREE(sc, M_NETGRAPH_ASYNC);
+ kfree(sc, M_NETGRAPH_ASYNC);
return (ENOMEM);
}
NG_NODE_SET_PRIVATE(node, sc);
ERROUT(EINVAL);
cfg->enabled = !!cfg->enabled; /* normalize */
if (cfg->smru > sc->cfg.smru) { /* reallocate buffer */
- MALLOC(buf, u_char *, ASYNC_BUF_SIZE(cfg->smru),
- M_NETGRAPH_ASYNC, M_WAITOK | M_NULLOK);
+ buf = kmalloc(ASYNC_BUF_SIZE(cfg->smru),
+ M_NETGRAPH_ASYNC,
+ M_WAITOK | M_NULLOK);
if (!buf)
ERROUT(ENOMEM);
- FREE(sc->abuf, M_NETGRAPH_ASYNC);
+ kfree(sc->abuf, M_NETGRAPH_ASYNC);
sc->abuf = buf;
}
if (cfg->amru > sc->cfg.amru) { /* reallocate buffer */
- MALLOC(buf, u_char *, SYNC_BUF_SIZE(cfg->amru),
- M_NETGRAPH_ASYNC, M_WAITOK | M_NULLOK);
+ buf = kmalloc(SYNC_BUF_SIZE(cfg->amru),
+ M_NETGRAPH_ASYNC,
+ M_WAITOK | M_NULLOK);
if (!buf)
ERROUT(ENOMEM);
- FREE(sc->sbuf, M_NETGRAPH_ASYNC);
+ kfree(sc->sbuf, M_NETGRAPH_ASYNC);
sc->sbuf = buf;
sc->amode = MODE_HUNT;
sc->slen = 0;
{
const sc_p sc = NG_NODE_PRIVATE(node);
- FREE(sc->abuf, M_NETGRAPH_ASYNC);
- FREE(sc->sbuf, M_NETGRAPH_ASYNC);
+ kfree(sc->abuf, M_NETGRAPH_ASYNC);
+ kfree(sc->sbuf, M_NETGRAPH_ASYNC);
bzero(sc, sizeof(*sc));
- FREE(sc, M_NETGRAPH_ASYNC);
+ kfree(sc, M_NETGRAPH_ASYNC);
NG_NODE_SET_PRIVATE(node, NULL);
NG_NODE_UNREF(node);
return (0);
{
struct ng_atmllc_priv *priv;
- MALLOC(priv, struct ng_atmllc_priv *, sizeof(*priv), M_NETGRAPH,
- M_WAITOK | M_NULLOK | M_ZERO);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (priv == NULL) {
return (ENOMEM);
}
priv = NG_NODE_PRIVATE(node);
- FREE(priv, M_NETGRAPH);
+ kfree(priv, M_NETGRAPH);
NG_NODE_UNREF(node);
/* Should not be visible outside this file */
#define _NG_ALLOC_HOOK(hook) \
- MALLOC(hook, hook_p, sizeof(*hook), M_NETGRAPH_HOOK, M_WAITOK | M_NULLOK | M_ZERO)
+ hook = kmalloc(sizeof(*hook), M_NETGRAPH_HOOK, \
+ M_WAITOK | M_NULLOK | M_ZERO)
#define _NG_ALLOC_NODE(node) \
- MALLOC(node, node_p, sizeof(*node), M_NETGRAPH_NODE, M_WAITOK | M_NULLOK | M_ZERO)
+ node = kmalloc(sizeof(*node), M_NETGRAPH_NODE, \
+ M_WAITOK | M_NULLOK | M_ZERO)
#define NG_QUEUE_LOCK_INIT(n) \
mtx_init(&(n)->q_mtx, "ng_node", NULL, MTX_DEF)
#define NG_ALLOC_HOOK(hook) _NG_ALLOC_HOOK(hook)
#define NG_ALLOC_NODE(node) _NG_ALLOC_NODE(node)
-#define NG_FREE_HOOK(hook) do { FREE((hook), M_NETGRAPH_HOOK); } while (0)
-#define NG_FREE_NODE(node) do { FREE((node), M_NETGRAPH_NODE); } while (0)
+#define NG_FREE_HOOK(hook) do { kfree((hook), M_NETGRAPH_HOOK); } while (0)
+#define NG_FREE_NODE(node) do { kfree((node), M_NETGRAPH_NODE); } while (0)
#endif /* NETGRAPH_DEBUG */ /*----------------------------------------------*/
int error;
/* Create hook private structure */
- MALLOC(hip, hinfo_p, sizeof(*hip), M_NETGRAPH_BPF, M_WAITOK | M_NULLOK | M_ZERO);
+ hip = kmalloc(sizeof(*hip), M_NETGRAPH_BPF,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (hip == NULL)
return (ENOMEM);
hip->hook = hook;
/* Attach the default BPF program */
if ((error = ng_bpf_setprog(hook, &ng_bpf_default_prog)) != 0) {
- FREE(hip, M_NETGRAPH_BPF);
+ kfree(hip, M_NETGRAPH_BPF);
NG_HOOK_SET_PRIVATE(hook, NULL);
return (error);
}
/* Need to put packet in contiguous memory for bpf */
if (m->m_next != NULL && totlen > MHLEN) {
if (usejit) {
- MALLOC(data, u_char *, totlen, M_NETGRAPH_BPF, M_NOWAIT);
+ data = kmalloc(totlen, M_NETGRAPH_BPF, M_NOWAIT);
if (data == NULL) {
NG_FREE_ITEM(item);
return (ENOMEM);
else
len = bpf_filter(hip->prog->bpf_prog, (u_char *)m, totlen, 0);
if (needfree)
- FREE(data, M_NETGRAPH_BPF);
+ kfree(data, M_NETGRAPH_BPF);
ready:
/* See if we got a match and find destination hook */
if (len > 0) {
/* Remove our reference from other hooks data. */
NG_NODE_FOREACH_HOOK(node, ng_bpf_remrefs, hook, tmp);
- FREE(hip->prog, M_NETGRAPH_BPF);
+ kfree(hip->prog, M_NETGRAPH_BPF);
#ifdef BPF_JITTER
if (hip->jit_prog != NULL)
bpf_destroy_jit_filter(hip->jit_prog);
#endif
- FREE(hip, M_NETGRAPH_BPF);
+ kfree(hip, M_NETGRAPH_BPF);
if ((NG_NODE_NUMHOOKS(node) == 0) &&
(NG_NODE_IS_VALID(node))) {
ng_rmnode_self(node);
/* Make a copy of the program */
size = NG_BPF_HOOKPROG_SIZE(hp0->bpf_prog_len);
- MALLOC(hp, struct ng_bpf_hookprog *, size, M_NETGRAPH_BPF, M_NOWAIT);
+ hp = kmalloc(size, M_NETGRAPH_BPF, M_NOWAIT);
if (hp == NULL)
return (ENOMEM);
bcopy(hp0, hp, size);
/* Free previous program, if any, and assign new one */
if (hip->prog != NULL)
- FREE(hip->prog, M_NETGRAPH_BPF);
+ kfree(hip->prog, M_NETGRAPH_BPF);
hip->prog = hp;
#ifdef BPF_JITTER
if (hip->jit_prog != NULL)
priv_p priv;
/* Allocate and initialize private info */
- MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH_BRIDGE, M_WAITOK | M_NULLOK | M_ZERO);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH_BRIDGE,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (priv == NULL)
return (ENOMEM);
ng_callout_init(&priv->timer);
/* Allocate and initialize hash table, etc. */
- MALLOC(priv->tab, struct ng_bridge_bucket *,
- MIN_BUCKETS * sizeof(*priv->tab), M_NETGRAPH_BRIDGE, M_WAITOK | M_NULLOK | M_ZERO);
+ priv->tab = kmalloc(MIN_BUCKETS * sizeof(*priv->tab),
+ M_NETGRAPH_BRIDGE, M_WAITOK | M_NULLOK | M_ZERO);
if (priv->tab == NULL) {
- FREE(priv, M_NETGRAPH_BRIDGE);
+ kfree(priv, M_NETGRAPH_BRIDGE);
return (ENOMEM);
}
priv->numBuckets = MIN_BUCKETS;
return (EINVAL);
if (priv->links[linkNum] != NULL)
return (EISCONN);
- MALLOC(priv->links[linkNum], struct ng_bridge_link *,
- sizeof(*priv->links[linkNum]), M_NETGRAPH_BRIDGE, M_WAITOK | M_NULLOK | M_ZERO);
+ priv->links[linkNum] = kmalloc(sizeof(*priv->links[linkNum]),
+ M_NETGRAPH_BRIDGE,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (priv->links[linkNum] == NULL)
return (ENOMEM);
priv->links[linkNum]->hook = hook;
ng_uncallout(&priv->timer, node);
NG_NODE_SET_PRIVATE(node, NULL);
NG_NODE_UNREF(node);
- FREE(priv->tab, M_NETGRAPH_BRIDGE);
- FREE(priv, M_NETGRAPH_BRIDGE);
+ kfree(priv->tab, M_NETGRAPH_BRIDGE);
+ kfree(priv, M_NETGRAPH_BRIDGE);
return (0);
}
/* Free associated link information */
KASSERT(priv->links[linkNum] != NULL, ("%s: no link", __func__));
- FREE(priv->links[linkNum], M_NETGRAPH_BRIDGE);
+ kfree(priv->links[linkNum], M_NETGRAPH_BRIDGE);
priv->links[linkNum] = NULL;
priv->numLinks--;
#endif
/* Allocate and initialize new hashtable entry */
- MALLOC(hent, struct ng_bridge_hent *,
- sizeof(*hent), M_NETGRAPH_BRIDGE, M_WAITOK | M_NULLOK);
+ hent = kmalloc(sizeof(*hent), M_NETGRAPH_BRIDGE, M_WAITOK | M_NULLOK);
if (hent == NULL)
return (0);
bcopy(addr, hent->host.addr, ETHER_ADDR_LEN);
newMask = newNumBuckets - 1;
/* Allocate and initialize new table */
- MALLOC(newTab, struct ng_bridge_bucket *,
- newNumBuckets * sizeof(*newTab), M_NETGRAPH_BRIDGE, M_NOWAIT | M_ZERO);
+ newTab = kmalloc(newNumBuckets * sizeof(*newTab), M_NETGRAPH_BRIDGE,
+ M_NOWAIT | M_ZERO);
if (newTab == NULL)
return;
ng_bridge_nodename(priv->node),
priv->numBuckets, newNumBuckets);
}
- FREE(priv->tab, M_NETGRAPH_BRIDGE);
+ kfree(priv->tab, M_NETGRAPH_BRIDGE);
priv->numBuckets = newNumBuckets;
priv->hashMask = newMask;
priv->tab = newTab;
if (linkNum == -1 || hent->host.linkNum == linkNum) {
*hptr = SLIST_NEXT(hent, next);
- FREE(hent, M_NETGRAPH_BRIDGE);
+ kfree(hent, M_NETGRAPH_BRIDGE);
priv->numHosts--;
} else
hptr = &SLIST_NEXT(hent, next);
/* Remove hosts we haven't heard from in a while */
if (++hent->host.staleness >= priv->conf.maxStaleness) {
*hptr = SLIST_NEXT(hent, next);
- FREE(hent, M_NETGRAPH_BRIDGE);
+ kfree(hent, M_NETGRAPH_BRIDGE);
priv->numHosts--;
} else {
if (hent->host.age < 0xffff)
{
sc_p sc;
- MALLOC(sc, sc_p, sizeof(*sc), M_NETGRAPH, M_WAITOK | M_NULLOK | M_ZERO);
+ sc = kmalloc(sizeof(*sc), M_NETGRAPH, M_WAITOK | M_NULLOK | M_ZERO);
if (sc == NULL)
return (ENOMEM);
NG_NODE_SET_PRIVATE(node, NULL);
NG_NODE_UNREF(sc->node);
- FREE(sc, M_NETGRAPH);
+ kfree(sc, M_NETGRAPH);
return (0);
}
DBG;
- MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_WAITOK | M_ZERO);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH, M_WAITOK | M_ZERO);
if (priv == NULL)
return (ENOMEM);
mtx_destroy(&priv->ngd_mtx);
mtx_destroy(&priv->readq.ifq_mtx);
free_unr(ngd_unit, priv->unit);
- FREE(priv, M_NETGRAPH);
+ kfree(priv, M_NETGRAPH);
return(EINVAL);
}
/* XXX: race here? */
free_unr(ngd_unit, priv->unit);
- FREE(priv, M_NETGRAPH);
+ kfree(priv, M_NETGRAPH);
ng_rmnode_self(NG_HOOK_NODE(hook));
u_char eaddr[6] = {0,0,0,0,0,0};
/* Allocate node and interface private structures */
- MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_WAITOK | M_NULLOK | M_ZERO);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (priv == NULL)
return (ENOMEM);
ether_ifdetach(ifp);
if_free(ifp);
free_unr(ng_eiface_unit, priv->unit);
- FREE(priv, M_NETGRAPH);
+ kfree(priv, M_NETGRAPH);
NG_NODE_SET_PRIVATE(node, NULL);
NG_NODE_UNREF(node);
return (0);
int i;
/* Initialize private descriptor */
- MALLOC(privdata, etf_p, sizeof(*privdata), M_NETGRAPH_ETF,
- M_WAITOK | M_NULLOK | M_ZERO);
+ privdata = kmalloc(sizeof(*privdata), M_NETGRAPH_ETF,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (privdata == NULL)
return (ENOMEM);
for (i = 0; i < HASHSIZE; i++) {
* Any other hook name is valid and can
* later be associated with a filter rule.
*/
- MALLOC(hpriv, struct ETF_hookinfo *, sizeof(*hpriv),
- M_NETGRAPH_ETF, M_WAITOK | M_NULLOK | M_ZERO);
+ hpriv = kmalloc(sizeof(*hpriv), M_NETGRAPH_ETF,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (hpriv == NULL) {
return (ENOMEM);
}
* Ok, make the filter and put it in the
* hashtable ready for matching.
*/
- MALLOC(fil, struct filter *, sizeof(*fil),
- M_NETGRAPH_ETF, M_WAITOK | M_NULLOK | M_ZERO);
+ fil = kmalloc(sizeof(*fil), M_NETGRAPH_ETF,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (fil == NULL) {
error = ENOMEM;
break;
NG_NODE_SET_PRIVATE(node, NULL);
NG_NODE_UNREF(privdata->node);
- FREE(privdata, M_NETGRAPH_ETF);
+ kfree(privdata, M_NETGRAPH_ETF);
return (0);
}
fil2 = LIST_NEXT(fil1, next);
if (fil1->match_hook == hook) {
LIST_REMOVE(fil1, next);
- FREE(fil1, M_NETGRAPH_ETF);
+ kfree(fil1, M_NETGRAPH_ETF);
}
fil1 = fil2;
}
etfp->nomatch_hook.hook = NULL;
} else {
if (NG_HOOK_PRIVATE(hook)) /* Paranoia */
- FREE(NG_HOOK_PRIVATE(hook), M_NETGRAPH_ETF);
+ kfree(NG_HOOK_PRIVATE(hook), M_NETGRAPH_ETF);
}
NG_HOOK_SET_PRIVATE(hook, NULL);
}
/* Allocate private data */
- MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_WAITOK | M_NULLOK | M_ZERO);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (priv == NULL) {
log(LOG_ERR, "%s: can't %s for %s\n",
__func__, "allocate memory", ifp->if_xname);
* Assume the ifp has already been freed.
*/
NG_NODE_SET_PRIVATE(node, NULL);
- FREE(priv, M_NETGRAPH);
+ kfree(priv, M_NETGRAPH);
NG_NODE_UNREF(node); /* free node itself */
return (0);
}
int i, *newarray, newlen;
newlen = (2 * ng_fec_units_len) + 4;
- MALLOC(newarray, int *, newlen * sizeof(*ng_fec_units),
- M_NETGRAPH, M_WAITOK | M_NULLOK);
+ newarray = kmalloc(newlen * sizeof(*ng_fec_units),
+ M_NETGRAPH, M_WAITOK | M_NULLOK);
if (newarray == NULL) {
mtx_unlock(&ng_fec_mtx);
return (ENOMEM);
for (i = ng_fec_units_len; i < newlen; i++)
newarray[i] = ~0;
if (ng_fec_units != NULL)
- FREE(ng_fec_units, M_NETGRAPH);
+ kfree(ng_fec_units, M_NETGRAPH);
ng_fec_units = newarray;
ng_fec_units_len = newlen;
}
*/
ng_units_in_use--;
if (ng_units_in_use == 0) { /* XXX make SMP safe */
- FREE(ng_fec_units, M_NETGRAPH);
+ kfree(ng_fec_units, M_NETGRAPH);
ng_fec_units_len = 0;
ng_fec_units = NULL;
}
}
/* Allocate new list entry. */
- MALLOC(new, struct ng_fec_portlist *,
- sizeof(struct ng_fec_portlist), M_NETGRAPH, M_WAITOK | M_NULLOK);
+ new = kmalloc(sizeof(struct ng_fec_portlist), M_NETGRAPH,
+ M_WAITOK | M_NULLOK);
if (new == NULL)
return(ENOMEM);
/* Delete port */
TAILQ_REMOVE(&b->ng_fec_ports, p, fec_list);
- FREE(p, M_NETGRAPH);
+ kfree(p, M_NETGRAPH);
b->fec_ifcnt--;
if (b->fec_ifcnt == 0)
int error = 0;
/* Allocate node and interface private structures */
- MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_WAITOK | M_NULLOK | M_ZERO);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (priv == NULL)
return (ENOMEM);
ifp = priv->ifp = if_alloc(IFT_ETHER);
if (ifp == NULL) {
- FREE(priv, M_NETGRAPH);
+ kfree(priv, M_NETGRAPH);
return (ENOSPC);
}
b = &priv->fec_bundle;
/* Get an interface unit number */
if ((error = ng_fec_get_unit(&priv->unit)) != 0) {
if_free(ifp);
- FREE(priv, M_NETGRAPH);
+ kfree(priv, M_NETGRAPH);
return (error);
}
if_free_type(priv->ifp, IFT_ETHER);
ifmedia_removeall(&priv->ifmedia);
ng_fec_free_unit(priv->unit);
- FREE(priv, M_NETGRAPH);
+ kfree(priv, M_NETGRAPH);
NG_NODE_SET_PRIVATE(node, NULL);
NG_NODE_UNREF(node);
return (0);
{
sc_p sc;
- MALLOC(sc, sc_p, sizeof(*sc), M_NETGRAPH, M_WAITOK | M_NULLOK | M_ZERO);
+ sc = kmalloc(sizeof(*sc), M_NETGRAPH, M_WAITOK | M_NULLOK | M_ZERO);
if (!sc)
return (ENOMEM);
sc->addrlen = 2; /* default */
const sc_p sc = NG_NODE_PRIVATE(node);
NG_NODE_SET_PRIVATE(node, NULL);
- FREE(sc, M_NETGRAPH);
+ kfree(sc, M_NETGRAPH);
NG_NODE_UNREF(node);
return (0);
}
}
/* Allocate private data */
- MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_WAITOK | M_NULLOK | M_ZERO);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (priv == NULL) {
log(LOG_ERR, "%s: can't %s for %s\n",
__func__, "allocate memory", ifp->if_xname);
* Assume the ifp has already been freed.
*/
NG_NODE_SET_PRIVATE(node, NULL);
- FREE(priv, M_NETGRAPH);
+ kfree(priv, M_NETGRAPH);
NG_NODE_UNREF(node); /* free node itself */
return (0);
}
priv_p priv;
/* Allocate and initialize private info */
- MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH_GIF_DEMUX,
- M_WAITOK | M_NULLOK | M_ZERO);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH_GIF_DEMUX,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (priv == NULL)
return (ENOMEM);
priv->node = node;
{
const priv_p priv = NG_NODE_PRIVATE(node);
- FREE(priv, M_NETGRAPH_GIF_DEMUX);
+ kfree(priv, M_NETGRAPH_GIF_DEMUX);
NG_NODE_SET_PRIVATE(node, NULL);
NG_NODE_UNREF(node);
return (0);
hinfo_p hip;
/* Create hook private structure. */
- MALLOC(hip, hinfo_p, sizeof(*hip), M_NETGRAPH, M_WAITOK | M_NULLOK | M_ZERO);
+ hip = kmalloc(sizeof(*hip), M_NETGRAPH, M_WAITOK | M_NULLOK | M_ZERO);
if (hip == NULL)
return (ENOMEM);
NG_HOOK_SET_PRIVATE(hook, hip);
ngh_disconnect(hook_p hook)
{
- FREE(NG_HOOK_PRIVATE(hook), M_NETGRAPH);
+ kfree(NG_HOOK_PRIVATE(hook), M_NETGRAPH);
NG_HOOK_SET_PRIVATE(hook, NULL);
if (NG_NODE_NUMHOOKS(NG_HOOK_NODE(hook)) == 0)
ng_rmnode_self(NG_HOOK_NODE(hook));
priv_p priv;
/* Allocate node and interface private structures */
- MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH_IFACE, M_WAITOK | M_NULLOK | M_ZERO);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH_IFACE,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (priv == NULL)
return (ENOMEM);
ifp = if_alloc(IFT_PROPVIRTUAL);
if (ifp == NULL) {
- FREE(priv, M_NETGRAPH_IFACE);
+ kfree(priv, M_NETGRAPH_IFACE);
return (ENOMEM);
}
if_free(priv->ifp);
priv->ifp = NULL;
free_unr(ng_iface_unit, priv->unit);
- FREE(priv, M_NETGRAPH_IFACE);
+ kfree(priv, M_NETGRAPH_IFACE);
NG_NODE_SET_PRIVATE(node, NULL);
NG_NODE_UNREF(node);
return (0);
return (EINVAL);
/* Allocate memory for this hook's private data */
- MALLOC(hpriv, hpriv_p, sizeof(*hpriv), M_NETGRAPH, M_WAITOK | M_NULLOK | M_ZERO);
+ hpriv = kmalloc(sizeof(*hpriv), M_NETGRAPH,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (hpriv== NULL)
return (ENOMEM);
{
const hpriv_p hpriv = NG_HOOK_PRIVATE(hook);
- FREE(hpriv, M_NETGRAPH);
+ kfree(hpriv, M_NETGRAPH);
NG_HOOK_SET_PRIVATE(hook, NULL);
return (0);
return (EINVAL);
pathlen = strlen(path);
if (pathlen > SOCK_MAXADDRLEN) {
- FREE(path, M_NETGRAPH_KSOCKET);
+ kfree(path, M_NETGRAPH_KSOCKET);
return (E2BIG);
}
if (*buflen < pathoff + pathlen) {
- FREE(path, M_NETGRAPH_KSOCKET);
+ kfree(path, M_NETGRAPH_KSOCKET);
return (ERANGE);
}
*off += toklen;
bcopy(path, sun->sun_path, pathlen);
sun->sun_len = pathoff + pathlen;
- FREE(path, M_NETGRAPH_KSOCKET);
+ kfree(path, M_NETGRAPH_KSOCKET);
break;
}
if ((pathtoken = ng_encode_string(pathbuf, pathlen)) == NULL)
return (ENOMEM);
slen += snprintf(cbuf, cbuflen, "local/%s", pathtoken);
- FREE(pathtoken, M_NETGRAPH_KSOCKET);
+ kfree(pathtoken, M_NETGRAPH);
if (slen >= cbuflen)
return (ERANGE);
*off += sun->sun_len;
priv_p priv;
/* Allocate private structure */
- MALLOC(priv, priv_p, sizeof(*priv),
- M_NETGRAPH_KSOCKET, M_WAITOK | M_NULLOK | M_ZERO);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (priv == NULL)
return (ENOMEM);
bail:
/* Cleanup */
if (sa != NULL)
- FREE(sa, M_SONAME);
+ kfree(sa, M_SONAME);
break;
}
/* Take down netgraph node */
bzero(priv, sizeof(*priv));
- FREE(priv, M_NETGRAPH_KSOCKET);
+ kfree(priv, M_NETGRAPH);
NG_NODE_SET_PRIVATE(node, NULL);
NG_NODE_UNREF(node); /* let the node escape */
return (0);
/* See if we got anything */
if (m == NULL) {
if (sa != NULL)
- FREE(sa, M_SONAME);
+ kfree(sa, M_SONAME);
break;
}
NG_KSOCKET_TAG_SOCKADDR, sizeof(ng_ID_t) +
sa->sa_len, MB_DONTWAIT);
if (stag == NULL) {
- FREE(sa, M_SONAME);
+ kfree(sa, M_SONAME);
goto sendit;
}
bcopy(sa, &stag->sa, sa->sa_len);
- FREE(sa, M_SONAME);
+ kfree(sa, M_SONAME);
stag->id = NG_NODE_ID(node);
m_tag_prepend(m, &stag->tag);
}
/* Clone a ksocket node to wrap the new socket */
error = ng_make_node_common(&ng_ksocket_typestruct, &node);
if (error) {
- FREE(resp, M_NETGRAPH);
+ kfree(resp, M_NETGRAPH);
soclose(so);
goto out;
}
if (ng_ksocket_constructor(node) != 0) {
NG_NODE_UNREF(node);
- FREE(resp, M_NETGRAPH);
+ kfree(resp, M_NETGRAPH);
soclose(so);
goto out;
}
out:
if (sa != NULL)
- FREE(sa, M_SONAME);
+ kfree(sa, M_SONAME);
}
/*
int i;
/* Allocate private structure */
- MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH_L2TP, M_WAITOK | M_NULLOK | M_ZERO);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH_L2TP,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (priv == NULL)
return (ENOMEM);
NG_NODE_SET_PRIVATE(node, priv);
return (EINVAL);
/* Create hook private structure */
- MALLOC(hpriv, hookpriv_p,
- sizeof(*hpriv), M_NETGRAPH_L2TP, M_WAITOK | M_NULLOK | M_ZERO);
+ hpriv = kmalloc(sizeof(*hpriv), M_NETGRAPH_L2TP,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (hpriv == NULL)
return (ENOMEM);
hpriv->conf.session_id = htons(session_id);
mtx_destroy(&seq->mtx);
- FREE(priv, M_NETGRAPH_L2TP);
+ kfree(priv, M_NETGRAPH_L2TP);
/* Unref node */
NG_NODE_UNREF(node);
else {
const hookpriv_p hpriv = NG_HOOK_PRIVATE(hook);
LIST_REMOVE(hpriv, sessions);
- FREE(hpriv, M_NETGRAPH_L2TP);
+ kfree(hpriv, M_NETGRAPH_L2TP);
NG_HOOK_SET_PRIVATE(hook, NULL);
}
{
sc_p sc;
- MALLOC(sc, sc_p, sizeof(*sc), M_NETGRAPH, M_WAITOK | M_NULLOK | M_ZERO);
+ sc = kmalloc(sizeof(*sc), M_NETGRAPH, M_WAITOK | M_NULLOK | M_ZERO);
if (sc == NULL)
return (ENOMEM);
NG_NODE_SET_PRIVATE(node, NULL);
NG_NODE_UNREF(sc->node);
- FREE(sc, M_NETGRAPH);
+ kfree(sc, M_NETGRAPH);
return (0);
}
*/
#define NG_MKMESSAGE(msg, cookie, cmdid, len, how) \
do { \
- MALLOC((msg), struct ng_mesg *, sizeof(struct ng_mesg) \
- + (len), M_NETGRAPH_MSG, (how) | M_ZERO); \
+ (msg) = kmalloc(sizeof(struct ng_mesg) + (len), \
+ M_NETGRAPH_MSG, (how) | M_ZERO); \
if ((msg) == NULL) \
break; \
(msg)->header.version = NG_VERSION; \
*/
#define NG_MKRESPONSE(rsp, msg, len, how) \
do { \
- MALLOC((rsp), struct ng_mesg *, sizeof(struct ng_mesg) \
- + (len), M_NETGRAPH_MSG, (how) | M_ZERO); \
+ (rsp) = kmalloc(sizeof(struct ng_mesg) + (len), \
+ M_NETGRAPH_MSG, (how) | M_ZERO); \
if ((rsp) == NULL) \
break; \
(rsp)->header.version = NG_VERSION; \
*/
#define NG_COPYMESSAGE(copy, msg, how) \
do { \
- MALLOC((copy), struct ng_mesg *, sizeof(struct ng_mesg) + \
- (msg)->header.arglen, M_NETGRAPH_MSG, (how) | M_ZERO); \
+ (copy) = kmalloc(sizeof(struct ng_mesg) + (msg)->header.arglen,\
+ M_NETGRAPH_MSG, (how) | M_ZERO); \
if ((copy) == NULL) \
break; \
(copy)->header.version = NG_VERSION; \
priv_p priv;
/* Allocate private structure */
- MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH_MPPC, M_WAITOK | M_NULLOK | M_ZERO);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH_MPPC,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (priv == NULL)
return (ENOMEM);
#ifdef NETGRAPH7_MPPC_COMPRESSION
/* Initialize state buffers for compression */
if (d->history != NULL) {
- FREE(d->history, M_NETGRAPH_MPPC);
+ kfree(d->history, M_NETGRAPH_MPPC);
d->history = NULL;
}
if ((cfg->bits & MPPC_BIT) != 0) {
- MALLOC(d->history, u_char *,
- isComp ? MPPC_SizeOfCompressionHistory() :
- MPPC_SizeOfDecompressionHistory(),
- M_NETGRAPH_MPPC, M_WAITOK | M_NULLOK);
+ d->history = kmalloc(isComp ? MPPC_SizeOfCompressionHistory() : MPPC_SizeOfDecompressionHistory(),
+ M_NETGRAPH_MPPC,
+ M_WAITOK | M_NULLOK);
if (d->history == NULL)
ERROUT(ENOMEM);
if (isComp)
/* Take down netgraph node */
#ifdef NETGRAPH7_MPPC_COMPRESSION
if (priv->xmit.history != NULL)
- FREE(priv->xmit.history, M_NETGRAPH_MPPC);
+ kfree(priv->xmit.history, M_NETGRAPH_MPPC);
if (priv->recv.history != NULL)
- FREE(priv->recv.history, M_NETGRAPH_MPPC);
+ kfree(priv->recv.history, M_NETGRAPH_MPPC);
#endif
bzero(priv, sizeof(*priv));
- FREE(priv, M_NETGRAPH_MPPC);
+ kfree(priv, M_NETGRAPH_MPPC);
NG_NODE_SET_PRIVATE(node, NULL);
NG_NODE_UNREF(node); /* let the node escape */
return (0);
priv_p priv;
/* Initialize private descriptor. */
- MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH,
- M_WAITOK | M_NULLOK | M_ZERO);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (priv == NULL)
return (ENOMEM);
/* Init aliasing engine. */
priv->lib = LibAliasInit(NULL);
if (priv->lib == NULL) {
- FREE(priv, M_NETGRAPH);
+ kfree(priv, M_NETGRAPH);
return (ENOMEM);
}
if (entry->lnk == NULL) {
error = ENOMEM;
- FREE(entry, M_NETGRAPH);
+ kfree(entry, M_NETGRAPH);
break;
}
if (entry->lnk == NULL) {
error = ENOMEM;
- FREE(entry, M_NETGRAPH);
+ kfree(entry, M_NETGRAPH);
break;
}
if (entry->lnk == NULL) {
error = ENOMEM;
- FREE(entry, M_NETGRAPH);
+ kfree(entry, M_NETGRAPH);
break;
}
/* Delete entry from our internal list. */
priv->rdrcount--;
STAILQ_REMOVE(&priv->redirhead, entry, ng_nat_rdr_lst, entries);
- FREE(entry, M_NETGRAPH);
+ kfree(entry, M_NETGRAPH);
}
break;
case NGM_NAT_ADD_SERVER:
while (!STAILQ_EMPTY(&priv->redirhead)) {
struct ng_nat_rdr_lst *entry = STAILQ_FIRST(&priv->redirhead);
STAILQ_REMOVE_HEAD(&priv->redirhead, entries);
- FREE(entry, M_NETGRAPH);
+ kfree(entry, M_NETGRAPH);
};
/* Final free. */
LibAliasUninit(priv->lib);
- FREE(priv, M_NETGRAPH);
+ kfree(priv, M_NETGRAPH);
return (0);
}
priv_p priv;
/* Allocate and initialize private info */
- MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_WAITOK | M_NULLOK | M_ZERO);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (priv == NULL)
return (ENOMEM);
priv->conf.xmitAlg = NG_ONE2MANY_XMIT_ROUNDROBIN;
KASSERT(priv->numActiveMany == 0,
("%s: numActiveMany=%d", __func__, priv->numActiveMany));
- FREE(priv, M_NETGRAPH);
+ kfree(priv, M_NETGRAPH);
NG_NODE_SET_PRIVATE(node, NULL);
NG_NODE_UNREF(node);
return (0);
return (EINVAL);
*off += len;
bcopy(sval, buf, slen + 1);
- FREE(sval, M_NETGRAPH_PARSE);
+ kfree(sval, M_NETGRAPH_PARSE);
*buflen = slen + 1;
return (0);
}
if (s == NULL)
return (ENOMEM);
if ((error = ng_parse_append(&cbuf, &cbuflen, "%s", s)) != 0) {
- FREE(s, M_NETGRAPH_PARSE);
+ kfree(s, M_NETGRAPH_PARSE);
return (error);
}
*off += strlen(raw) + 1;
- FREE(s, M_NETGRAPH_PARSE);
+ kfree(s, M_NETGRAPH_PARSE);
return (0);
}
if ((sval = ng_get_string_token(s, off, &len, &slen)) == NULL)
return (EINVAL);
if (slen + 1 > fi->bufSize) {
- FREE(sval, M_NETGRAPH_PARSE);
+ kfree(sval, M_NETGRAPH_PARSE);
return (E2BIG);
}
*off += len;
bcopy(sval, buf, slen);
- FREE(sval, M_NETGRAPH_PARSE);
+ kfree(sval, M_NETGRAPH_PARSE);
bzero(buf + slen, fi->bufSize - slen);
*buflen = fi->bufSize;
return (0);
if ((sval = ng_get_string_token(s, off, &len, &slen)) == NULL)
return (EINVAL);
if (slen > USHRT_MAX) {
- FREE(sval, M_NETGRAPH_PARSE);
+ kfree(sval, M_NETGRAPH_PARSE);
return (EINVAL);
}
*off += len;
*((u_int16_t *)buf) = (u_int16_t)slen;
bcopy(sval, buf + 2, slen);
- FREE(sval, M_NETGRAPH_PARSE);
+ kfree(sval, M_NETGRAPH_PARSE);
*buflen = 2 + slen;
return (0);
}
if (s == NULL)
return (ENOMEM);
if ((error = ng_parse_append(&cbuf, &cbuflen, "%s", s)) != 0) {
- FREE(s, M_NETGRAPH_PARSE);
+ kfree(s, M_NETGRAPH_PARSE);
return (error);
}
- FREE(s, M_NETGRAPH_PARSE);
+ kfree(s, M_NETGRAPH_PARSE);
*off += slen + 2;
return (0);
}
arraylen = (*getLength)(type, start, buf);
if (arraylen > *buflen) {
- FREE(str, M_NETGRAPH_PARSE);
+ kfree(str, M_NETGRAPH_PARSE);
return (ERANGE);
}
if (slen > arraylen) {
- FREE(str, M_NETGRAPH_PARSE);
+ kfree(str, M_NETGRAPH_PARSE);
return (E2BIG);
}
bcopy(str, buf, slen);
bzero(buf + slen, arraylen - slen);
- FREE(str, M_NETGRAPH_PARSE);
+ kfree(str, M_NETGRAPH_PARSE);
*off += toklen;
*buflen = arraylen;
return (0);
int align, len, blen, error = 0;
/* Initialize */
- MALLOC(foff, int *, num * sizeof(*foff), M_NETGRAPH_PARSE, M_WAITOK | M_NULLOK | M_ZERO);
+ foff = kmalloc(num * sizeof(*foff), M_NETGRAPH_PARSE,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (foff == NULL) {
error = ENOMEM;
goto done;
*buflen = blen;
done:
if (foff != NULL)
- FREE(foff, M_NETGRAPH_PARSE);
+ kfree(foff, M_NETGRAPH_PARSE);
return (error);
}
u_char *workBuf;
/* Get workspace for checking default values */
- MALLOC(workBuf, u_char *, workSize, M_NETGRAPH_PARSE, M_WAITOK | M_NULLOK);
+ workBuf = kmalloc(workSize, M_NETGRAPH_PARSE, M_WAITOK | M_NULLOK);
if (workBuf == NULL)
return (ENOMEM);
/* Print value */
if ((error = INVOKE(etype, unparse)
(etype, data, off, cbuf, cbuflen)) != 0) {
- FREE(workBuf, M_NETGRAPH_PARSE);
+ kfree(workBuf, M_NETGRAPH_PARSE);
return (error);
}
cbuflen -= strlen(cbuf);
fail:
/* Clean up after failure */
- FREE(workBuf, M_NETGRAPH_PARSE);
+ kfree(workBuf, M_NETGRAPH_PARSE);
return (error);
}
case '"':
if ((t = ng_get_string_token(s, startp, lenp, NULL)) == NULL)
return T_ERROR;
- FREE(t, M_NETGRAPH_PARSE);
+ kfree(t, M_NETGRAPH_PARSE);
return T_STRING;
default:
for (i = *startp + 1; s[i] != '\0' && !isspace(s[i])
start = *startp;
if (s[*startp] != '"')
return (NULL);
- MALLOC(cbuf, char *, strlen(s + start), M_NETGRAPH_PARSE, M_WAITOK | M_NULLOK);
+ cbuf = kmalloc(strlen(s + start), M_NETGRAPH_PARSE,
+ M_WAITOK | M_NULLOK);
if (cbuf == NULL)
return (NULL);
strcpy(cbuf, s + start + 1);
strcpy(p, v);
}
}
- FREE(cbuf, M_NETGRAPH_PARSE);
+ kfree(cbuf, M_NETGRAPH_PARSE);
return (NULL); /* no closing quote */
}
int off = 0;
int i;
- MALLOC(cbuf, char *, strlen(raw) * 4 + 3, M_NETGRAPH_PARSE, M_WAITOK | M_NULLOK);
+ cbuf = kmalloc(strlen(raw) * 4 + 3, M_NETGRAPH_PARSE,
+ M_WAITOK | M_NULLOK);
if (cbuf == NULL)
return (NULL);
cbuf[off++] = '"';
int i;
/* Allocate private structure */
- MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH_PPP, M_WAITOK | M_NULLOK | M_ZERO);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH_PPP,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (priv == NULL)
return (ENOMEM);
mtx_destroy(&priv->rmtx);
mtx_destroy(&priv->xmtx);
bzero(priv, sizeof(*priv));
- FREE(priv, M_NETGRAPH_PPP);
+ kfree(priv, M_NETGRAPH_PPP);
NG_NODE_SET_PRIVATE(node, NULL);
NG_NODE_UNREF(node); /* let the node escape */
return (0);
int i;
/* Allocate private structure */
- MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_WAITOK | M_NULLOK | M_ZERO);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (priv == NULL)
return (ENOMEM);
LIST_REMOVE(&priv->uppersess, sessions);
mtx_destroy(&priv->uppersess.mtx);
- FREE(priv, M_NETGRAPH);
+ kfree(priv, M_NETGRAPH);
/* Decrement ref count */
NG_NODE_UNREF(node);
priv_p priv;
/* Allocate private structure */
- MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_WAITOK | M_NULLOK | M_ZERO);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (priv == NULL)
return (ENOMEM);
/* Take down netgraph node */
bzero(priv, sizeof(*priv));
- FREE(priv, M_NETGRAPH);
+ kfree(priv, M_NETGRAPH);
NG_NODE_SET_PRIVATE(node, NULL);
NG_NODE_UNREF(node); /* let the node escape */
return (0);
int i;
/* Initialize private descriptor */
- MALLOC(privdata, xxx_p, sizeof(*privdata), M_NETGRAPH,
- M_WAITOK | M_NULLOK | M_ZERO);
+ privdata = kmalloc(sizeof(*privdata), M_NETGRAPH,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (privdata == NULL)
return (ENOMEM);
for (i = 0; i < XXX_NUM_DLCIS; i++) {
#ifndef PERSISTANT_NODE
NG_NODE_SET_PRIVATE(node, NULL);
NG_NODE_UNREF(node);
- FREE(privdata, M_NETGRAPH);
+ kfree(privdata, M_NETGRAPH);
#else
if (node->nd_flags & NGF_REALLY_DIE) {
/*
*/
NG_NODE_SET_PRIVATE(node, NULL);
NG_NODE_UNREF(privdata->node);
- FREE(privdata, M_NETGRAPH);
+ kfree(privdata, M_NETGRAPH);
return (0);
}
NG_NODE_REVIVE(node); /* tell ng_rmnode() we will persist */
priv_p priv;
/* Allocate node */
- MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_ZERO | M_WAITOK | M_NULLOK);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH,
+ M_ZERO | M_WAITOK | M_NULLOK);
if (priv == NULL)
return (ENOMEM);
NG_NODE_SET_PRIVATE(node, NULL);
NG_NODE_UNREF(node);
- FREE(priv, M_NETGRAPH);
+ kfree(priv, M_NETGRAPH);
return (0);
}
int newlen;
newlen = (2 * ng_sppp_units_len) + sizeof (*ng_sppp_units);
- MALLOC (newarray, unsigned char *,
- newlen * sizeof (*ng_sppp_units), M_NETGRAPH_SPPP, M_WAITOK | M_NULLOK);
+ newarray = kmalloc(newlen * sizeof(*ng_sppp_units),
+ M_NETGRAPH_SPPP, M_WAITOK | M_NULLOK);
if (newarray == NULL)
return (ENOMEM);
bcopy (ng_sppp_units, newarray,
bzero (newarray + ng_sppp_units_len,
newlen - ng_sppp_units_len);
if (ng_sppp_units != NULL)
- FREE (ng_sppp_units, M_NETGRAPH_SPPP);
+ kfree(ng_sppp_units, M_NETGRAPH_SPPP);
ng_sppp_units = newarray;
ng_sppp_units_len = newlen;
}
ng_units_in_use--;
if (ng_units_in_use == 0) {
- FREE (ng_sppp_units, M_NETGRAPH_SPPP);
+ kfree(ng_sppp_units, M_NETGRAPH_SPPP);
ng_sppp_units_len = 0;
ng_sppp_units = NULL;
}
int error = 0;
/* Allocate node and interface private structures */
- MALLOC (priv, priv_p, sizeof(*priv), M_NETGRAPH_SPPP, M_WAITOK | M_NULLOK | M_ZERO);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH_SPPP,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (priv == NULL)
return (ENOMEM);
ifp = if_alloc(IFT_PPP);
if (ifp == NULL) {
- FREE (priv, M_NETGRAPH_SPPP);
+ kfree(priv, M_NETGRAPH_SPPP);
return (ENOSPC);
}
pp = IFP2SP(ifp);
/* Get an interface unit number */
if ((error = ng_sppp_get_unit(&priv->unit)) != 0) {
- FREE (pp, M_NETGRAPH_SPPP);
- FREE (priv, M_NETGRAPH_SPPP);
+ kfree(pp, M_NETGRAPH_SPPP);
+ kfree(priv, M_NETGRAPH_SPPP);
return (error);
}
if_detach (priv->ifp);
if_free(priv->ifp);
ng_sppp_free_unit (priv->unit);
- FREE (priv, M_NETGRAPH_SPPP);
+ kfree(priv, M_NETGRAPH_SPPP);
NG_NODE_SET_PRIVATE (node, NULL);
NG_NODE_UNREF (node);
return (0);
int error;
/* Create hook private structure. */
- MALLOC(hip, hinfo_p, sizeof(*hip), M_NETGRAPH_TAG, M_WAITOK | M_ZERO);
+ hip = kmalloc(sizeof(*hip), M_NETGRAPH_TAG, M_WAITOK | M_ZERO);
/* M_WAITOK can't return NULL. */
NG_HOOK_SET_PRIVATE(hook, hip);
/* Attach the default IN data. */
if ((error = ng_tag_setdata_in(hook, &ng_tag_default_in)) != 0) {
- FREE(hip, M_NETGRAPH_TAG);
+ kfree(hip, M_NETGRAPH_TAG);
return (error);
}
/* Attach the default OUT data. */
if ((error = ng_tag_setdata_out(hook, &ng_tag_default_out)) != 0) {
- FREE(hip, M_NETGRAPH_TAG);
+ kfree(hip, M_NETGRAPH_TAG);
return (error);
}
priv->hi_nonmatch = NULL;
}
- FREE(hip->in, M_NETGRAPH_TAG);
- FREE(hip->out, M_NETGRAPH_TAG);
- FREE(hip, M_NETGRAPH_TAG);
+ kfree(hip->in, M_NETGRAPH_TAG);
+ kfree(hip->out, M_NETGRAPH_TAG);
+ kfree(hip, M_NETGRAPH_TAG);
NG_HOOK_SET_PRIVATE(hook, NULL); /* for good measure */
if ((NG_NODE_NUMHOOKS(NG_HOOK_NODE(hook)) == 0) &&
(NG_NODE_IS_VALID(NG_HOOK_NODE(hook)))) {
/* Make a copy of the tag values and data. */
size = NG_TAG_HOOKIN_SIZE(hp0->tag_len);
- MALLOC(hp, struct ng_tag_hookin *, size, M_NETGRAPH_TAG, M_WAITOK);
+ hp = kmalloc(size, M_NETGRAPH_TAG, M_WAITOK);
/* M_WAITOK can't return NULL. */
bcopy(hp0, hp, size);
/* Free previous tag, if any, and assign new one. */
if (hip->in != NULL)
- FREE(hip->in, M_NETGRAPH_TAG);
+ kfree(hip->in, M_NETGRAPH_TAG);
hip->in = hp;
/*
/* Make a copy of the tag values and data. */
size = NG_TAG_HOOKOUT_SIZE(hp0->tag_len);
- MALLOC(hp, struct ng_tag_hookout *, size, M_NETGRAPH_TAG, M_WAITOK);
+ hp = kmalloc(size, M_NETGRAPH_TAG, M_WAITOK);
/* M_WAITOK can't return NULL. */
bcopy(hp0, hp, size);
/* Free previous tag, if any, and assign new one. */
if (hip->out != NULL)
- FREE(hip->out, M_NETGRAPH_TAG);
+ kfree(hip->out, M_NETGRAPH_TAG);
hip->out = hp;
/* Fill internal values from API structures. */
{
hpriv_p priv;
- MALLOC(priv, hpriv_p, sizeof(*priv), M_NETGRAPH, M_WAITOK | M_NULLOK | M_ZERO);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (priv == NULL)
return (ENOMEM);
priv->outHook = NULL;
}
- FREE(NG_HOOK_PRIVATE(hook), M_NETGRAPH);
+ kfree(NG_HOOK_PRIVATE(hook), M_NETGRAPH);
if (NG_NODE_NUMHOOKS(NG_HOOK_NODE(hook)) == 0)
ng_rmnode_self(NG_HOOK_NODE(hook));
{
sc_p privdata;
- MALLOC(privdata, sc_p, sizeof(*privdata), M_NETGRAPH, M_WAITOK | M_NULLOK | M_ZERO);
+ privdata = kmalloc(sizeof(*privdata), M_NETGRAPH,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (privdata == NULL)
return (ENOMEM);
const sc_p privdata = NG_NODE_PRIVATE(node);
NG_NODE_SET_PRIVATE(node, NULL);
- FREE(privdata, M_NETGRAPH);
+ kfree(privdata, M_NETGRAPH);
NG_NODE_UNREF(node);
return (0);
}
return (error);
/* Initialize private struct */
- MALLOC(sc, sc_p, sizeof(*sc), M_NETGRAPH, M_WAITOK | M_ZERO);
+ sc = kmalloc(sizeof(*sc), M_NETGRAPH, M_WAITOK | M_ZERO);
if (sc == NULL)
return (ENOMEM);
error = ng_make_node_common(&typestruct, &sc->node);
if (error) {
NGTUNLOCK(sc);
- FREE(sc, M_NETGRAPH);
+ kfree(sc, M_NETGRAPH);
lwkt_reltoken(&tty_token);
return (error);
}
mtx_destroy(&(sc)->outq.ifq_mtx);
m_freem(sc->m);
NG_NODE_UNREF(sc->node);
- FREE(sc, M_NETGRAPH);
+ kfree(sc, M_NETGRAPH);
return (0);
}
priv_p priv;
/* Allocate private structure */
- MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_WAITOK | M_NULLOK | M_ZERO);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (priv == NULL)
return (ENOMEM);
const priv_p priv = NG_NODE_PRIVATE(node);
bzero(priv, sizeof(*priv));
- FREE(priv, M_NETGRAPH);
+ kfree(priv, M_NETGRAPH);
NG_NODE_SET_PRIVATE(node, NULL);
NG_NODE_UNREF(node);
return (0);
priv_p priv;
int i;
- MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_WAITOK | M_NULLOK | M_ZERO);
+ priv = kmalloc(sizeof(*priv), M_NETGRAPH,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (priv == NULL)
return (ENOMEM);
for (i = 0; i < HASHSIZE; i++)
break;
}
/* Create filter. */
- MALLOC(f, struct filter *, sizeof(*f),
- M_NETGRAPH, M_WAITOK | M_NULLOK | M_ZERO);
+ f = kmalloc(sizeof(*f), M_NETGRAPH,
+ M_WAITOK | M_NULLOK | M_ZERO);
if (f == NULL) {
error = ENOMEM;
break;
NG_HOOK_SET_PRIVATE(hook, NULL);
LIST_REMOVE(f, next);
priv->nent--;
- FREE(f, M_NETGRAPH);
+ kfree(f, M_NETGRAPH);
break;
case NGM_VLAN_GET_TABLE:
NG_MKRESPONSE(resp, msg, sizeof(*t) +
NG_NODE_SET_PRIVATE(node, NULL);
NG_NODE_UNREF(node);
- FREE(priv, M_NETGRAPH);
+ kfree(priv, M_NETGRAPH);
return (0);
}
if ((f = NG_HOOK_PRIVATE(hook)) != NULL) {
LIST_REMOVE(f, next);
priv->nent--;
- FREE(f, M_NETGRAPH);
+ kfree(f, M_NETGRAPH);
}
}
NG_HOOK_SET_PRIVATE(hook, NULL);
projects / dragonfly.git / commitdiff