struct mbuf;
struct ieee80211_ageq {
- ieee80211_ageq_lock_t aq_lock;
int aq_len; /* # items on queue */
int aq_maxlen; /* max queue length */
int aq_drops; /* frames dropped */
#define _NET80211_IEEE80211_DRAGONFLY_H_
#ifdef _KERNEL
+
#include <sys/param.h>
#include <sys/types.h>
-#include <sys/lock.h>
-#include <sys/mutex2.h>
+#include <sys/serialize.h>
#include <sys/sysctl.h>
+#include <sys/condvar.h>
#include <sys/taskqueue.h>
-#define IF_LOCK(_lock) /* */
-#define IF_UNLOCK(_lock) /* */
-
-/*
- * Common state locking definitions.
- */
-typedef struct {
- char name[16]; /* e.g. "ath0_com_lock" */
- struct lock lock;
-} ieee80211_com_lock_t;
-/*
-#define IEEE80211_LOCK_INIT(_ic, _name) do { \
- ieee80211_com_lock_t *cl = &(_ic)->ic_comlock; \
- ksnprintf(cl->name, sizeof(cl->name), "%s_com_lock", _name); \
- lockinit(&cl->lock, cl->name, 0, LK_CANRECURSE); \
-} while (0)
-#define IEEE80211_LOCK_OBJ(_ic) (&(_ic)->ic_comlock.lock)
-#define IEEE80211_LOCK_DESTROY(_ic) lockuninit(IEEE80211_LOCK_OBJ(_ic))
-#define IEEE80211_LOCK(_ic) \
- lockmgr(IEEE80211_LOCK_OBJ(_ic), LK_EXCLUSIVE)
-#define IEEE80211_UNLOCK(_ic) lockmgr(IEEE80211_LOCK_OBJ(_ic), LK_RELEASE)
-#define IEEE80211_LOCK_ASSERT(_ic) \
- KKASSERT(lockstatus(IEEE80211_LOCK_OBJ(_ic), curthread) != 0)
-*/
-#define IEEE80211_LOCK_INIT(_ic, _name)
-#define IEEE80211_LOCK_OBJ(_ic) (NULL)
-#define IEEE80211_LOCK_DESTROY(_ic)
-#define IEEE80211_LOCK(_ic) lwkt_gettoken(&wlan_token)
-#define IEEE80211_UNLOCK(_ic) lwkt_reltoken(&wlan_token)
-#define IEEE80211_LOCK_ASSERT(_ic) ASSERT_LWKT_TOKEN_HELD(&wlan_token)
-
-/*
- * Node locking definitions.
- */
-typedef struct {
- char name[16]; /* e.g. "ath0_node_lock" */
- struct lock lock;
-} ieee80211_node_lock_t;
-#define IEEE80211_NODE_LOCK_INIT(_nt, _name) do { \
- ieee80211_node_lock_t *nl = &(_nt)->nt_nodelock; \
- ksnprintf(nl->name, sizeof(nl->name), "%s_node_lock", _name); \
- lockinit(&nl->lock, nl->name, 0, LK_CANRECURSE); \
-} while (0)
-#define IEEE80211_NODE_LOCK_OBJ(_nt) (&(_nt)->nt_nodelock.lock)
-#define IEEE80211_NODE_LOCK_DESTROY(_nt) \
- lockuninit(IEEE80211_NODE_LOCK_OBJ(_nt))
-#define IEEE80211_NODE_LOCK(_nt) \
- lockmgr(IEEE80211_NODE_LOCK_OBJ(_nt), LK_EXCLUSIVE)
-#define IEEE80211_NODE_IS_LOCKED(_nt) \
- (lockstatus(IEEE80211_NODE_LOCK_OBJ(_nt), curthread) == LK_EXCLUSIVE)
-#define IEEE80211_NODE_UNLOCK(_nt) \
- lockmgr(IEEE80211_NODE_LOCK_OBJ(_nt), LK_RELEASE)
-#define IEEE80211_NODE_LOCK_ASSERT(_nt) \
- KKASSERT(lockstatus(IEEE80211_NODE_LOCK_OBJ(_nt), curthread) != 0)
-
-/*
- * Node table iteration locking definitions; this protects the
- * scan generation # used to iterate over the station table
- * while grabbing+releasing the node lock.
- */
-typedef struct {
- char name[16]; /* e.g. "ath0_scan_lock" */
- struct lock lock;
-} ieee80211_scan_lock_t;
-#define IEEE80211_NODE_ITERATE_LOCK_INIT(_nt, _name) do { \
- ieee80211_scan_lock_t *sl = &(_nt)->nt_scanlock; \
- ksnprintf(sl->name, sizeof(sl->name), "%s_scan_lock", _name); \
- lockinit(&sl->lock, sl->name, 0, 0); \
-} while (0)
-#define IEEE80211_NODE_ITERATE_LOCK_OBJ(_nt) (&(_nt)->nt_scanlock.lock)
-#define IEEE80211_NODE_ITERATE_LOCK_DESTROY(_nt) \
- lockuninit(IEEE80211_NODE_ITERATE_LOCK_OBJ(_nt))
-#define IEEE80211_NODE_ITERATE_LOCK(_nt) \
- lockmgr(IEEE80211_NODE_ITERATE_LOCK_OBJ(_nt), LK_EXCLUSIVE)
-#define IEEE80211_NODE_ITERATE_UNLOCK(_nt) \
- lockmgr(IEEE80211_NODE_ITERATE_LOCK_OBJ(_nt), LK_RELEASE)
-
-/*
- * Power-save queue definitions.
- */
-typedef struct lock ieee80211_psq_lock_t;
-#define IEEE80211_PSQ_INIT(_psq, _name) \
- lockinit(&(_psq)->psq_lock, __DECONST(char *, _name), 0, 0)
-#define IEEE80211_PSQ_DESTROY(_psq) lockuninit(&(_psq)->psq_lock)
-#define IEEE80211_PSQ_LOCK(_psq) lockmgr(&(_psq)->psq_lock, LK_EXCLUSIVE)
-#define IEEE80211_PSQ_UNLOCK(_psq) lockmgr(&(_psq)->psq_lock, LK_RELEASE)
+#include <sys/mutex2.h>
+#include <sys/serialize2.h>
#ifndef IF_PREPEND_LIST
+
#define _IF_PREPEND_LIST(ifq, mhead, mtail, mcount) do { \
(mtail)->m_nextpkt = (ifq)->ifq_head; \
if ((ifq)->ifq_tail == NULL) \
(ifq)->ifq_head = (mhead); \
(ifq)->ifq_len += (mcount); \
} while (0)
+
#define IF_PREPEND_LIST(ifq, mhead, mtail, mcount) do { \
- IF_LOCK(ifq); \
+ wlan_assert_serialized(); \
_IF_PREPEND_LIST(ifq, mhead, mtail, mcount); \
- IF_UNLOCK(ifq); \
} while (0)
+
#endif /* IF_PREPEND_LIST */
-
+
/*
- * Age queue definitions.
+ * Global serializer (operates like a non-reentrant lockmgr lock)
*/
-typedef struct lock ieee80211_ageq_lock_t;
-#define IEEE80211_AGEQ_INIT(_aq, _name) \
- lockinit(&(_aq)->aq_lock, __DECONST(char *, _name), 0, 0)
-#define IEEE80211_AGEQ_DESTROY(_aq) lockuninit(&(_aq)->aq_lock)
-#define IEEE80211_AGEQ_LOCK(_aq) lockmgr(&(_aq)->aq_lock, LK_EXCLUSIVE)
-#define IEEE80211_AGEQ_UNLOCK(_aq) lockmgr(&(_aq)->aq_lock, LK_RELEASE)
+extern struct lwkt_serialize wlan_global_serializer;
+
+void wlan_serialize_enter(void);
+void wlan_serialize_exit(void);
+int wlan_serialize_sleep(void *ident, int flags, const char *wmesg, int timo);
+
+static __inline void
+wlan_assert_serialized(void)
+{
+ ASSERT_SERIALIZED(&wlan_global_serializer);
+}
/*
- * 802.1x MAC ACL database locking definitions.
+ * wlan condition variables. Assume the global serializer is held.
*/
-typedef struct lock acl_lock_t;
-#define ACL_LOCK_INIT(_as, _name) \
- lockinit(&(_as)->as_lock, __DECONST(char *, _name), 0, 0)
-#define ACL_LOCK_DESTROY(_as) lockuninit(&(_as)->as_lock)
-#define ACL_LOCK(_as) lockmgr(&(_as)->as_lock, LK_EXCLUSIVE)
-#define ACL_UNLOCK(_as) lockmgr(&(_as)->as_lock, LK_RELEASE)
-#define ACL_LOCK_ASSERT(_as) \
- KKASSERT(lockstatus(&(_as)->as_lock, curthread) != 0)
+void wlan_cv_init(struct cv *cv, const char *desc);
+int wlan_cv_timedwait(struct cv *cv, int ticks);
+void wlan_cv_wait(struct cv *cv);
+void wlan_cv_signal(struct cv *cv, int broadcast);
/*
* Node reference counting definitions.
#define IEEE80211_MESHFLAGS_PORTAL 0x02 /* mesh portal role */
#define IEEE80211_MESHFLAGS_FWD 0x04 /* forward packets */
uint8_t ms_flags;
- struct lock ms_rt_lock;
struct callout ms_cleantimer;
TAILQ_HEAD(, ieee80211_mesh_route) ms_routes;
struct ieee80211_mesh_proto_metric *ms_pmetric;
*/
struct ieee80211_node_table {
struct ieee80211com *nt_ic; /* back reference */
- ieee80211_node_lock_t nt_nodelock; /* on node table */
TAILQ_HEAD(, ieee80211_node) nt_node; /* information of all nodes */
LIST_HEAD(, ieee80211_node) nt_hash[IEEE80211_NODE_HASHSIZE];
struct ieee80211_node **nt_keyixmap; /* key ix -> node map */
int nt_keyixmax; /* keyixmap size */
const char *nt_name; /* table name for debug msgs */
- ieee80211_scan_lock_t nt_scanlock; /* on nt_scangen */
u_int nt_scangen; /* gen# for iterators */
int nt_inact_init; /* initial node inact setting */
};
* frames are required to handle them when they come back.
*/
struct ieee80211_psq {
- ieee80211_psq_lock_t psq_lock;
int psq_len;
int psq_maxlen;
int psq_drops;
struct ieee80211com {
struct ifnet *ic_ifp; /* associated device */
- ieee80211_com_lock_t ic_comlock; /* state update lock */
TAILQ_HEAD(, ieee80211vap) ic_vaps; /* list of vap instances */
int ic_headroom; /* driver tx headroom needs */
enum ieee80211_phytype ic_phytype; /* XXX wrong for multi-mode */
KASSERT(ifp->if_type == IFT_IEEE80211, ("if_type %d", ifp->if_type));
- IEEE80211_LOCK_INIT(ic, ifp->if_xname);
TAILQ_INIT(&ic->ic_vaps);
/* Create a taskqueue for all state changes */
ifmedia_removeall(&ic->ic_media);
taskqueue_free(ic->ic_tq);
- IEEE80211_LOCK_DESTROY(ic);
}
/*
}
/* NB: if_mtu set by ether_ifattach to ETHERMTU */
- IEEE80211_LOCK(ic);
TAILQ_INSERT_TAIL(&ic->ic_vaps, vap, iv_next);
ieee80211_syncflag_locked(ic, IEEE80211_F_WME);
#ifdef IEEE80211_SUPPORT_SUPERG
ieee80211_syncflag_ht_locked(ic, IEEE80211_FHT_USEHT40);
ieee80211_syncifflag_locked(ic, IFF_PROMISC);
ieee80211_syncifflag_locked(ic, IFF_ALLMULTI);
- IEEE80211_UNLOCK(ic);
return 1;
}
taskqueue_drain(taskqueue_swi, &ifp->if_linktask);
#endif
- IEEE80211_LOCK(ic);
KASSERT(vap->iv_state == IEEE80211_S_INIT , ("vap still running"));
TAILQ_REMOVE(&ic->ic_vaps, vap, iv_next);
ieee80211_syncflag_locked(ic, IEEE80211_F_WME);
ieee80211_syncflag_ext_locked(ic, IEEE80211_FEXT_BPF);
ieee80211_syncifflag_locked(ic, IFF_PROMISC);
ieee80211_syncifflag_locked(ic, IFF_ALLMULTI);
- IEEE80211_UNLOCK(ic);
ifmedia_removeall(&vap->iv_media);
struct ieee80211vap *vap;
int bit, oflags;
- IEEE80211_LOCK_ASSERT(ic);
-
bit = 0;
TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next)
if (vap->iv_ifp->if_flags & flag) {
struct ieee80211vap *vap;
int bit;
- IEEE80211_LOCK_ASSERT(ic);
-
bit = 0;
TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next)
if (vap->iv_flags & flag) {
{
struct ieee80211com *ic = vap->iv_ic;
- IEEE80211_LOCK(ic);
if (flag < 0) {
flag = -flag;
vap->iv_flags &= ~flag;
} else
vap->iv_flags |= flag;
ieee80211_syncflag_locked(ic, flag);
- IEEE80211_UNLOCK(ic);
}
/*
struct ieee80211vap *vap;
int bit;
- IEEE80211_LOCK_ASSERT(ic);
-
bit = 0;
TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next)
if (vap->iv_flags_ht & flag) {
{
struct ieee80211com *ic = vap->iv_ic;
- IEEE80211_LOCK(ic);
if (flag < 0) {
flag = -flag;
vap->iv_flags_ht &= ~flag;
} else
vap->iv_flags_ht |= flag;
ieee80211_syncflag_ht_locked(ic, flag);
- IEEE80211_UNLOCK(ic);
}
/*
struct ieee80211vap *vap;
int bit;
- IEEE80211_LOCK_ASSERT(ic);
-
bit = 0;
TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next)
if (vap->iv_flags_ext & flag) {
{
struct ieee80211com *ic = vap->iv_ic;
- IEEE80211_LOCK(ic);
if (flag < 0) {
flag = -flag;
vap->iv_flags_ext &= ~flag;
} else
vap->iv_flags_ext |= flag;
ieee80211_syncflag_ext_locked(ic, flag);
- IEEE80211_UNLOCK(ic);
}
static __inline int
struct ieee80211_node *ni;
enum ieee80211_state ostate;
- IEEE80211_LOCK_ASSERT(vap->iv_ic);
-
ostate = vap->iv_state;
IEEE80211_DPRINTF(vap, IEEE80211_MSG_STATE, "%s: %s -> %s (%d)\n",
__func__, ieee80211_state_name[ostate],
{
memset(aq, 0, sizeof(aq));
aq->aq_maxlen = maxlen;
- IEEE80211_AGEQ_INIT(aq, name); /* OS-dependent setup */
}
/*
ieee80211_ageq_cleanup(struct ieee80211_ageq *aq)
{
KASSERT(aq->aq_len == 0, ("%d frames on ageq", aq->aq_len));
- IEEE80211_AGEQ_DESTROY(aq); /* OS-dependent cleanup */
}
/*
int
ieee80211_ageq_append(struct ieee80211_ageq *aq, struct mbuf *m, int age)
{
- IEEE80211_AGEQ_LOCK(aq);
if (__predict_true(aq->aq_len < aq->aq_maxlen)) {
if (aq->aq_tail == NULL) {
aq->aq_head = m;
m->m_nextpkt = NULL;
aq->aq_tail = m;
aq->aq_len++;
- IEEE80211_AGEQ_UNLOCK(aq);
return 0;
} else {
/*
* No space, drop and cleanup references.
*/
aq->aq_drops++;
- IEEE80211_AGEQ_UNLOCK(aq);
/* XXX tail drop? */
ageq_mfree(m);
return ENOSPC;
phead = &head;
if (aq->aq_len != 0) {
- IEEE80211_AGEQ_LOCK(aq);
while ((m = aq->aq_head) != NULL && M_AGE_GET(m) < quanta) {
if ((aq->aq_head = m->m_nextpkt) == NULL)
aq->aq_tail = NULL;
}
if (m != NULL)
M_AGE_SUB(m, quanta);
- IEEE80211_AGEQ_UNLOCK(aq);
}
*phead = NULL;
return head;
struct mbuf *m, **prev, *ohead;
struct mbuf *head, **phead;
- IEEE80211_AGEQ_LOCK(aq);
ohead = aq->aq_head;
prev = &aq->aq_head;
phead = &head;
}
if (head == ohead && aq->aq_head != NULL) /* correct age */
M_AGE_SET(aq->aq_head, M_AGE_GET(head));
- IEEE80211_AGEQ_UNLOCK(aq);
*phead = NULL;
return head;
db_printf(" %s(%p)", vap->iv_ifp->if_xname, vap);
db_printf("\n");
db_printf("\tifp %p(%s)", ic->ic_ifp, ic->ic_ifp->if_xname);
- db_printf(" comlock %p", &ic->ic_comlock);
db_printf("\n");
db_printf("\theadroom %d", ic->ic_headroom);
db_printf(" phytype %d", ic->ic_phytype);
int i;
db_printf("%s%s@%p:\n", tag, nt->nt_name, nt);
- db_printf("%s nodelock %p", tag, &nt->nt_nodelock);
db_printf(" inact_init %d", nt->nt_inact_init);
- db_printf(" scanlock %p", &nt->nt_scanlock);
db_printf(" scangen %u\n", nt->nt_scangen);
db_printf("%s keyixmax %d keyixmap %p\n",
tag, nt->nt_keyixmax, nt->nt_keyixmap);
{
const struct mbuf *m;
- db_printf("%s lock %p len %d maxlen %d drops %d head %p tail %p\n",
- tag, &q->aq_lock, q->aq_len, q->aq_maxlen, q->aq_drops,
+ db_printf("%s len %d maxlen %d drops %d head %p tail %p\n",
+ tag, q->aq_len, q->aq_maxlen, q->aq_drops,
q->aq_head, q->aq_tail);
for (m = q->aq_head; m != NULL; m = m->m_nextpkt)
db_printf("%s %p (len %d, %b)\n", tag, m, m->m_len,
struct ieee80211_dfs_state *dfs = &ic->ic_dfs;
int i;
- IEEE80211_LOCK(ic);
-
if (vap->iv_state != IEEE80211_S_CAC) /* NB: just in case */
return;
/*
IEEE80211_NOTIFY_CAC_EXPIRE);
ieee80211_cac_completeswitch(vap);
}
-
- IEEE80211_UNLOCK(ic);
}
/*
struct ieee80211com *ic = vap->iv_ic;
struct ieee80211_dfs_state *dfs = &ic->ic_dfs;
- IEEE80211_LOCK_ASSERT(ic);
-
callout_reset(&dfs->cac_timer, CAC_TIMEOUT, cac_timeout, vap);
if_printf(vap->iv_ifp, "start %d second CAC timer on channel %u (%u MHz)\n",
ticks_to_secs(CAC_TIMEOUT),
struct ieee80211com *ic = vap->iv_ic;
struct ieee80211_dfs_state *dfs = &ic->ic_dfs;
- IEEE80211_LOCK_ASSERT(ic);
-
/* NB: racey but not important */
if (callout_pending(&dfs->cac_timer)) {
if_printf(vap->iv_ifp, "stop CAC timer on channel %u (%u MHz)\n",
struct ieee80211_channel *c;
int i, oldest, now;
- IEEE80211_LOCK(ic);
-
now = oldest = ticks;
for (i = 0; i < ic->ic_nchans; i++) {
c = &ic->ic_channels[i];
callout_reset(&dfs->nol_timer, oldest + NOL_TIMEOUT - now,
dfs_timeout, ic);
}
-
- IEEE80211_UNLOCK(ic);
}
static void
struct ieee80211_dfs_state *dfs = &ic->ic_dfs;
int i, now;
- IEEE80211_LOCK_ASSERT(ic);
-
/*
* Mark all entries with this frequency. Notify user
* space and arrange for notification when the radar
IF_CLONE_INITIALIZER("wlan", wlan_clone_create, wlan_clone_destroy,
0, IF_MAXUNIT);
+struct lwkt_serialize wlan_global_serializer = LWKT_SERIALIZE_INITIALIZER;
/*
* Allocate/free com structure in conjunction with ifnet;
ic->ic_vap_delete(vap);
}
+/*
+ * These serializer functions are used by wlan and all drivers.
+ */
+void
+wlan_serialize_enter(void)
+{
+ lwkt_serialize_enter(&wlan_global_serializer);
+}
+
+void
+wlan_serialize_exit(void)
+{
+ lwkt_serialize_exit(&wlan_global_serializer);
+}
+
+int
+wlan_serialize_sleep(void *ident, int flags, const char *wmesg, int timo)
+{
+ return(zsleep(ident, &wlan_global_serializer, flags, wmesg, timo));
+}
+
+/*
+ * condition-var functions which interlock the ic lock (which is now
+ * just wlan_global_serializer)
+ */
+void
+wlan_cv_init(struct cv *cv, const char *desc)
+{
+ cv->cv_desc = desc;
+ cv->cv_waiters = 0;
+}
+
+int
+wlan_cv_timedwait(struct cv *cv, int ticks)
+{
+ int error;
+
+ ++cv->cv_waiters;
+ error = wlan_serialize_sleep(cv, 0, cv->cv_desc, ticks);
+ return (error);
+}
+
+void
+wlan_cv_wait(struct cv *cv)
+{
+ ++cv->cv_waiters;
+ wlan_serialize_sleep(cv, 0, cv->cv_desc, 0);
+}
+
+void
+wlan_cv_signal(struct cv *cv, int broadcast)
+{
+ if (cv->cv_waiters) {
+ if (broadcast) {
+ cv->cv_waiters = 0;
+ wakeup(cv);
+ } else {
+ --cv->cv_waiters;
+ wakeup_one(cv);
+ }
+ }
+}
+
+/*
+ * Misc
+ */
void
ieee80211_vap_destroy(struct ieee80211vap *vap)
{
error = sysctl_handle_int(oidp, &t, 0, req);
if (error || !req->newptr)
return error;
- IEEE80211_LOCK(ic);
ieee80211_dfs_notify_radar(ic, ic->ic_curchan);
- IEEE80211_UNLOCK(ic);
return 0;
}
struct ieee80211_node *ni;
struct mbuf *m;
+ wlan_assert_serialized();
for (;;) {
IF_DEQUEUE(ifq, m);
if (m == NULL)
struct ieee80211_node *ni;
struct mbuf *m, **mprev;
- IF_LOCK(ifq);
+ wlan_assert_serialized();
mprev = &ifq->ifq_head;
while ((m = *mprev) != NULL) {
ni = (struct ieee80211_node *)m->m_pkthdr.rcvif;
for (; m != NULL && m->m_nextpkt != NULL; m = m->m_nextpkt)
;
ifq->ifq_tail = m;
- IF_UNLOCK(ifq);
}
/*
if (ifp->if_type != IFT_IEEE80211 || ic == NULL)
return;
- IEEE80211_LOCK(ic);
TAILQ_FOREACH_MUTABLE(vap, &ic->ic_vaps, iv_next, next) {
/*
* If the MAC address has changed on the parent and it was
if (vap->iv_ic == ic &&
(vap->iv_flags_ext & IEEE80211_FEXT_UNIQMAC) == 0) {
IEEE80211_ADDR_COPY(vap->iv_myaddr, IF_LLADDR(ifp));
- IEEE80211_UNLOCK(ic);
+ wlan_serialize_exit();
if_setlladdr(vap->iv_ifp, IF_LLADDR(ifp),
- IEEE80211_ADDR_LEN);
- IEEE80211_LOCK(ic);
+ IEEE80211_ADDR_LEN);
+ wlan_serialize_enter();
}
}
- IEEE80211_UNLOCK(ic);
}
/*
struct ieee80211com *ic = vap->iv_ic;
enum ieee80211_state ostate;
- IEEE80211_LOCK_ASSERT(ic);
-
ostate = vap->iv_state;
IEEE80211_DPRINTF(vap, IEEE80211_MSG_STATE, "%s: %s -> %s (%d)\n",
__func__, ieee80211_state_name[ostate],
struct ieee80211vap *vap;
int first = 1;
- IEEE80211_LOCK_ASSERT(ic);
-
TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) {
if (vap->iv_opmode != IEEE80211_M_HOSTAP)
continue;
{
struct ieee80211com *ic = ni->ni_ic;
- IEEE80211_LOCK_ASSERT(ic);
-
if (ni->ni_flags & IEEE80211_NODE_HT) {
ic->ic_ht_sta_assoc++;
if (ni->ni_chw == 40)
{
struct ieee80211com *ic = ni->ni_ic;
- IEEE80211_LOCK_ASSERT(ic);
-
if (ni->ni_flags & IEEE80211_NODE_HT) {
ic->ic_ht_sta_assoc--;
if (ni->ni_chw == 40)
ieee80211_htprot_update(struct ieee80211com *ic, int protmode)
{
#define OPMODE(x) SM(x, IEEE80211_HTINFO_OPMODE)
- IEEE80211_LOCK(ic);
-
/* track non-HT station presence */
KASSERT(protmode & IEEE80211_HTINFO_NONHT_PRESENT,
("protmode 0x%x", protmode));
ic->ic_curhtprotmode = protmode;
htinfo_notify(ic);
}
- IEEE80211_UNLOCK(ic);
#undef OPMODE
}
void
ieee80211_ht_timeout(struct ieee80211com *ic)
{
- IEEE80211_LOCK_ASSERT(ic);
-
if ((ic->ic_flags_ht & IEEE80211_FHT_NONHT_PR) &&
time_after(ticks, ic->ic_lastnonht + IEEE80211_NONHT_PRESENT_AGE)) {
#if 0
m_freem(m);
return NULL;
}
- IEEE80211_NODE_LOCK(ni->ni_table);
mfrag = ni->ni_rxfrag[0];
ni->ni_rxfrag[0] = NULL;
- IEEE80211_NODE_UNLOCK(ni->ni_table);
/*
* Validate new fragment is in order and
/* NB: the broadcast address means do 'em all */
if (!IEEE80211_ADDR_EQ(mac, ic->ic_ifp->if_broadcastaddr)) {
- IEEE80211_NODE_LOCK(nt);
ni = ieee80211_find_node_locked(nt, mac);
if (ni != NULL) {
domlme(mlmeop, ni);
ieee80211_free_node(ni);
} else
error = ENOENT;
- IEEE80211_NODE_UNLOCK(nt);
} else {
ieee80211_iterate_nodes(nt, domlme, mlmeop);
}
error = EINVAL;
break;
}
- IEEE80211_NODE_LOCK(nt);
ni = ieee80211_find_vap_node_locked(nt, vap, mac);
if (ni != NULL) {
mlmedebug(vap, mac, op, reason);
ieee80211_free_node(ni);
} else
error = ENOENT;
- IEEE80211_NODE_UNLOCK(nt);
break;
case IEEE80211_MLME_AUTH:
if (vap->iv_opmode != IEEE80211_M_HOSTAP) {
error = EINVAL;
break;
}
- IEEE80211_NODE_LOCK(nt);
ni = ieee80211_find_vap_node_locked(nt, vap, mac);
if (ni != NULL) {
mlmedebug(vap, mac, op, reason);
ieee80211_free_node(ni);
} else
error = ENOENT;
- IEEE80211_NODE_UNLOCK(nt);
break;
default:
error = EINVAL;
{
int error;
- IEEE80211_LOCK_ASSERT(vap->iv_ic);
-
switch (fc0 & IEEE80211_FC0_SUBTYPE_MASK) {
case IEEE80211_FC0_SUBTYPE_BEACON:
if (vap->iv_opmode != IEEE80211_M_HOSTAP &&
if ((fc0 & IEEE80211_FC0_TYPE_MASK) != IEEE80211_FC0_TYPE_MGT)
return EINVAL;
/* NB: could check iv_opmode and reject but hardly worth the effort */
- IEEE80211_LOCK(ic);
error = ieee80211_ioctl_setappie_locked(vap, ireq, fc0);
- IEEE80211_UNLOCK(ic);
return error;
}
csr.csa_chan.ic_freq, csr.csa_chan.ic_flags);
if (c == NULL)
return ENOENT;
- IEEE80211_LOCK(ic);
if ((ic->ic_flags & IEEE80211_F_CSAPENDING) == 0)
ieee80211_csa_startswitch(ic, c, csr.csa_mode, csr.csa_count);
else if (csr.csa_count == 0)
ieee80211_csa_cancelswitch(ic);
else
error = EBUSY;
- IEEE80211_UNLOCK(ic);
return error;
}
*
* Otherwise just invoke the scan machinery directly.
*/
- IEEE80211_LOCK(ic);
if (vap->iv_state == IEEE80211_S_INIT) {
/* NB: clobbers previous settings */
vap->iv_scanreq_flags = sr.sr_flags;
sr.sr_ssid[i].len);
}
vap->iv_flags_ext |= IEEE80211_FEXT_SCANREQ;
- IEEE80211_UNLOCK(ic);
ieee80211_new_state(vap, IEEE80211_S_SCAN, 0);
} else {
vap->iv_flags_ext &= ~IEEE80211_FEXT_SCANREQ;
- IEEE80211_UNLOCK(ic);
/* XXX neeed error return codes */
if (sr.sr_flags & IEEE80211_IOC_SCAN_CHECK) {
(void) ieee80211_check_scan(vap, sr.sr_flags,
struct ieee80211vap *vap;
void *ioctl;
- IEEE80211_LOCK(ic);
if_delallmulti(parent);
ioctl = parent->if_ioctl; /* XXX WAR if_allmulti */
parent->if_ioctl = NULL;
}
parent->if_ioctl = ioctl;
ieee80211_runtask(ic, &ic->ic_mcast_task);
- IEEE80211_UNLOCK(ic);
}
int
switch (cmd) {
case SIOCSIFFLAGS:
- IEEE80211_LOCK(ic);
ieee80211_syncifflag_locked(ic, IFF_PROMISC);
ieee80211_syncifflag_locked(ic, IFF_ALLMULTI);
if (ifp->if_flags & IFF_UP) {
*/
ieee80211_stop_locked(vap);
}
- IEEE80211_UNLOCK(ic);
/* Wait for parent ioctl handler if it was queued */
ieee80211_waitfor_parent(ic);
break;
static struct ieee80211_mesh_proto_path mesh_proto_paths[4];
static struct ieee80211_mesh_proto_metric mesh_proto_metrics[4];
-#define MESH_RT_LOCK(ms) lockmgr(&(ms)->ms_rt_lock, LK_EXCLUSIVE)
-#define MESH_RT_LOCK_ASSERT(ms) \
- KKASSERT(lockstatus(&(ms)->ms_rt_lock, curthread) != 0)
-#define MESH_RT_UNLOCK(ms) lockmgr(&(ms)->ms_rt_lock, LK_RELEASE)
-
MALLOC_DEFINE(M_80211_MESH_RT, "80211mesh", "802.11s routing table");
/*
{
struct ieee80211_mesh_route *rt;
- MESH_RT_LOCK_ASSERT(ms);
-
TAILQ_FOREACH(rt, &ms->ms_routes, rt_next) {
if (IEEE80211_ADDR_EQ(dest, rt->rt_dest))
return rt;
KASSERT(!IEEE80211_ADDR_EQ(broadcastaddr, dest),
("%s: adding broadcast to the routing table", __func__));
- MESH_RT_LOCK_ASSERT(ms);
-
rt = kmalloc(ALIGN(sizeof(struct ieee80211_mesh_route)) +
ms->ms_ppath->mpp_privlen, M_80211_MESH_RT, M_INTWAIT | M_ZERO);
if (rt != NULL) {
struct ieee80211_mesh_state *ms = vap->iv_mesh;
struct ieee80211_mesh_route *rt;
- MESH_RT_LOCK(ms);
rt = mesh_rt_find_locked(ms, dest);
- MESH_RT_UNLOCK(ms);
return rt;
}
KASSERT(!IEEE80211_ADDR_EQ(vap->iv_myaddr, dest),
("%s: adding self to the routing table", __func__));
- MESH_RT_LOCK(ms);
rt = mesh_rt_add_locked(ms, dest);
- MESH_RT_UNLOCK(ms);
return rt;
}
struct ieee80211_mesh_state *ms = vap->iv_mesh;
struct ieee80211_mesh_route *rt;
- MESH_RT_LOCK(ms);
rt = mesh_rt_find_locked(ms, dest);
if (rt == NULL) {
rt = mesh_rt_add_locked(ms, dest);
(void *)(uintptr_t) ieee80211_mac_hash(ic, dest));
/* XXX stat? */
}
- MESH_RT_UNLOCK(ms);
}
static __inline void
struct ieee80211_mesh_state *ms = vap->iv_mesh;
struct ieee80211_mesh_route *rt, *next;
- MESH_RT_LOCK(ms);
TAILQ_FOREACH_MUTABLE(rt, &ms->ms_routes, rt_next, next) {
if (IEEE80211_ADDR_EQ(rt->rt_dest, dest)) {
mesh_rt_del(ms, rt);
- MESH_RT_UNLOCK(ms);
return;
}
}
- MESH_RT_UNLOCK(ms);
}
void
if (ms == NULL)
return;
- MESH_RT_LOCK(ms);
TAILQ_FOREACH_MUTABLE(rt, &ms->ms_routes, rt_next, next)
mesh_rt_del(ms, rt);
- MESH_RT_UNLOCK(ms);
}
void
struct ieee80211_mesh_state *ms = vap->iv_mesh;
struct ieee80211_mesh_route *rt, *next;
- MESH_RT_LOCK(ms);
TAILQ_FOREACH_MUTABLE(rt, &ms->ms_routes, rt_next, next) {
if (IEEE80211_ADDR_EQ(rt->rt_nexthop, peer))
mesh_rt_del(ms, rt);
}
- MESH_RT_UNLOCK(ms);
}
/*
if (ms == NULL)
return;
- MESH_RT_LOCK(ms);
TAILQ_FOREACH_MUTABLE(rt, &ms->ms_routes, rt_next, next) {
if ((rt->rt_flags & IEEE80211_MESHRT_FLAGS_VALID) == 0 &&
ticks - rt->rt_crtime >= ms->ms_ppath->mpp_inact)
mesh_rt_del(ms, rt);
}
- MESH_RT_UNLOCK(ms);
}
#define N(a) (sizeof(a) / sizeof(a[0]))
ieee80211_iterate_nodes(&vap->iv_ic->ic_sta, mesh_vdetach_peers,
NULL);
ieee80211_mesh_rt_flush(vap);
- lockuninit(&ms->ms_rt_lock);
ms->ms_ppath->mpp_vdetach(vap);
kfree(vap->iv_mesh, M_80211_VAP);
vap->iv_mesh = NULL;
ms->ms_flags = (IEEE80211_MESHFLAGS_AP | IEEE80211_MESHFLAGS_FWD);
ms->ms_ttl = IEEE80211_MESH_DEFAULT_TTL;
TAILQ_INIT(&ms->ms_routes);
- lockinit(&ms->ms_rt_lock, "MBSS", 0, 0);
callout_init_mp(&ms->ms_cleantimer);
mesh_select_proto_metric(vap, "AIRTIME");
KASSERT(ms->ms_pmetric, ("ms_pmetric == NULL"));
struct ieee80211_node *ni;
enum ieee80211_state ostate;
- IEEE80211_LOCK_ASSERT(ic);
-
ostate = vap->iv_state;
IEEE80211_DPRINTF(vap, IEEE80211_MSG_STATE, "%s: %s -> %s (%d)\n",
__func__, ieee80211_state_name[ostate],
switch (ireq->i_val) {
case IEEE80211_MESH_RTCMD_LIST:
len = 0;
- MESH_RT_LOCK(ms);
TAILQ_FOREACH(rt, &ms->ms_routes, rt_next) {
len += sizeof(*imr);
}
- MESH_RT_UNLOCK(ms);
if (len > ireq->i_len || ireq->i_len < sizeof(*imr)) {
ireq->i_len = len;
return ENOMEM;
if (p == NULL)
return ENOMEM;
off = 0;
- MESH_RT_LOCK(ms);
TAILQ_FOREACH(rt, &ms->ms_routes, rt_next) {
if (off >= len)
break;
imr->imr_lastmseq = rt->rt_lastmseq;
off += sizeof(*imr);
}
- MESH_RT_UNLOCK(ms);
error = copyout(p, (uint8_t *)ireq->i_data,
ireq->i_len);
kfree(p, M_TEMP);
struct ieee80211com *ic = vap->iv_ic;
enum ieee80211_state ostate;
- IEEE80211_LOCK_ASSERT(ic);
-
ostate = vap->iv_state;
IEEE80211_DPRINTF(vap, IEEE80211_MSG_STATE, "%s: %s -> %s (%d)\n",
__func__, ieee80211_state_name[ostate],
ic->ic_curchan = c;
ic->ic_curmode = ieee80211_chan2mode(ic->ic_curchan);
ic->ic_rt = ieee80211_get_ratetable(ic->ic_curchan);
- IEEE80211_UNLOCK(ic);
ic->ic_set_channel(ic);
ieee80211_radiotap_chan_change(ic);
- IEEE80211_LOCK(ic);
}
}
{
struct ieee80211vap *vap = ni->ni_vap;
- IEEE80211_NODE_LOCK_ASSERT(&vap->iv_ic->ic_sta);
-
/*
* Age frames on the power save queue.
*/
if (vap->iv_opmode == IEEE80211_M_MBSS)
ieee80211_mesh_node_init(vap, ni);
#endif
- IEEE80211_NODE_LOCK(nt);
TAILQ_INSERT_TAIL(&nt->nt_node, ni, ni_list);
LIST_INSERT_HEAD(&nt->nt_hash[hash], ni, ni_hash);
ni->ni_table = nt;
ni->ni_vap = vap;
ni->ni_ic = ic;
- IEEE80211_NODE_UNLOCK(nt);
IEEE80211_NOTE(vap, IEEE80211_MSG_INACT, ni,
"%s: inact_reload %u", __func__, ni->ni_inact_reload);
struct ieee80211_node *ni;
int hash;
- IEEE80211_NODE_LOCK_ASSERT(nt);
-
hash = IEEE80211_NODE_HASH(nt->nt_ic, macaddr);
LIST_FOREACH(ni, &nt->nt_hash[hash], ni_hash) {
if (IEEE80211_ADDR_EQ(ni->ni_macaddr, macaddr)) {
{
struct ieee80211_node *ni;
- IEEE80211_NODE_LOCK(nt);
ni = ieee80211_find_node_locked(nt, macaddr);
- IEEE80211_NODE_UNLOCK(nt);
return ni;
}
struct ieee80211_node *ni;
int hash;
- IEEE80211_NODE_LOCK_ASSERT(nt);
-
hash = IEEE80211_NODE_HASH(nt->nt_ic, macaddr);
LIST_FOREACH(ni, &nt->nt_hash[hash], ni_hash) {
if (ni->ni_vap == vap &&
{
struct ieee80211_node *ni;
- IEEE80211_NODE_LOCK(nt);
ni = ieee80211_find_vap_node_locked(nt, vap, macaddr);
- IEEE80211_NODE_UNLOCK(nt);
return ni;
}
struct ieee80211_node *ni;
nt = &ic->ic_sta;
- IEEE80211_NODE_LOCK(nt);
ni = _find_rxnode(nt, wh);
- IEEE80211_NODE_UNLOCK(nt);
return ni;
}
struct ieee80211_node *ni;
nt = &ic->ic_sta;
- IEEE80211_NODE_LOCK(nt);
if (nt->nt_keyixmap != NULL && keyix < nt->nt_keyixmax)
ni = nt->nt_keyixmap[keyix];
else
else
ieee80211_ref_node(ni);
}
- IEEE80211_NODE_UNLOCK(nt);
-
return ni;
}
#undef IS_BCAST_PROBEREQ
* to the bss node.
*/
/* XXX can't hold lock across dup_bss 'cuz of recursive locking */
- IEEE80211_NODE_LOCK(nt);
if (vap->iv_opmode == IEEE80211_M_STA ||
vap->iv_opmode == IEEE80211_M_WDS ||
IEEE80211_IS_MULTICAST(macaddr))
ni = ieee80211_ref_node(vap->iv_bss);
else
ni = ieee80211_find_node_locked(nt, macaddr);
- IEEE80211_NODE_UNLOCK(nt);
if (ni == NULL) {
if (vap->iv_opmode == IEEE80211_M_IBSS ||
ni->ni_macaddr, ":", ieee80211_node_refcnt(ni)-1);
#endif
if (nt != NULL) {
- IEEE80211_NODE_LOCK(nt);
if (ieee80211_node_dectestref(ni)) {
/*
* Last reference, reclaim state.
_ieee80211_free_node(ni);
}
}
- IEEE80211_NODE_UNLOCK(nt);
} else {
if (ieee80211_node_dectestref(ni))
_ieee80211_free_node(ni);
struct ieee80211_node_table *nt = &ic->ic_sta;
struct ieee80211_node *nikey;
ieee80211_keyix keyix;
- int isowned, status;
+ int status;
/*
* NB: We must beware of LOR here; deleting the key
* way to separate out this path so we must do this
* conditionally.
*/
- isowned = IEEE80211_NODE_IS_LOCKED(nt);
- if (!isowned)
- IEEE80211_NODE_LOCK(nt);
nikey = NULL;
status = 1; /* NB: success */
if (ni->ni_ucastkey.wk_keyix != IEEE80211_KEYIX_NONE) {
nt->nt_keyixmap[keyix] = NULL;
}
}
- if (!isowned)
- IEEE80211_NODE_UNLOCK(nt);
if (nikey != NULL) {
KASSERT(nikey == ni,
{
ieee80211_keyix keyix;
- IEEE80211_NODE_LOCK_ASSERT(nt);
-
IEEE80211_DPRINTF(ni->ni_vap, IEEE80211_MSG_NODE,
"%s: remove %p<%6D> from %s table, refcnt %d\n",
__func__, ni, ni->ni_macaddr, ":",
struct ieee80211_node_table *nt,
const char *name, int inact, int keyixmax)
{
- struct ifnet *ifp = ic->ic_ifp;
-
nt->nt_ic = ic;
- IEEE80211_NODE_LOCK_INIT(nt, ifp->if_xname);
- IEEE80211_NODE_ITERATE_LOCK_INIT(nt, ifp->if_xname);
TAILQ_INIT(&nt->nt_node);
nt->nt_name = name;
nt->nt_scangen = 1;
{
struct ieee80211_node *ni, *next;
- IEEE80211_NODE_LOCK(nt);
TAILQ_FOREACH_MUTABLE(ni, &nt->nt_node, ni_list, next) {
if (match != NULL && ni->ni_vap != match)
continue;
if (ni->ni_wdsvap == match)
ni->ni_wdsvap = NULL;
}
- IEEE80211_NODE_UNLOCK(nt);
}
static void
kfree(nt->nt_keyixmap, M_80211_NODE);
nt->nt_keyixmap = NULL;
}
- IEEE80211_NODE_ITERATE_LOCK_DESTROY(nt);
- IEEE80211_NODE_LOCK_DESTROY(nt);
}
/*
struct ieee80211_node *ni;
int gen = 0;
- IEEE80211_NODE_ITERATE_LOCK(nt);
gen = ++nt->nt_scangen;
restart:
- IEEE80211_NODE_LOCK(nt);
TAILQ_FOREACH(ni, &nt->nt_node, ni_list) {
if (ni->ni_scangen == gen) /* previously handled */
continue;
* ref for us as needed.
*/
ieee80211_ref_node(ni);
- IEEE80211_NODE_UNLOCK(nt);
ieee80211_send_nulldata(ni);
/* XXX stat? */
goto restart;
* in a LOR between the node lock and the driver lock.
*/
ieee80211_ref_node(ni);
- IEEE80211_NODE_UNLOCK(nt);
if (ni->ni_associd != 0) {
IEEE80211_SEND_MGMT(ni,
IEEE80211_FC0_SUBTYPE_DEAUTH,
goto restart;
}
}
- IEEE80211_NODE_UNLOCK(nt);
-
- IEEE80211_NODE_ITERATE_UNLOCK(nt);
}
/*
struct ieee80211vap *vap;
struct ieee80211_node *ni;
- IEEE80211_NODE_LOCK(nt);
TAILQ_FOREACH(ni, &nt->nt_node, ni_list) {
/*
* Ignore entries for which have yet to receive an
*/
ic->ic_node_drain(ni);
}
- IEEE80211_NODE_UNLOCK(nt);
}
/*
ieee80211_timeout_stations(ic);
ieee80211_ageq_age(&ic->ic_stageq, IEEE80211_INACT_WAIT);
- IEEE80211_LOCK(ic);
ieee80211_erp_timeout(ic);
ieee80211_ht_timeout(ic);
- IEEE80211_UNLOCK(ic);
}
callout_reset(&ic->ic_inact, IEEE80211_INACT_WAIT*hz,
ieee80211_node_timeout, ic);
struct ieee80211_node *ni;
u_int gen;
- IEEE80211_NODE_ITERATE_LOCK(nt);
gen = ++nt->nt_scangen;
restart:
- IEEE80211_NODE_LOCK(nt);
TAILQ_FOREACH(ni, &nt->nt_node, ni_list) {
if (ni->ni_scangen != gen) {
ni->ni_scangen = gen;
(void) ieee80211_ref_node(ni);
- IEEE80211_NODE_UNLOCK(nt);
(*f)(arg, ni);
ieee80211_free_node(ni);
goto restart;
}
}
- IEEE80211_NODE_UNLOCK(nt);
-
- IEEE80211_NODE_ITERATE_UNLOCK(nt);
}
void
{
struct ieee80211vap *vap;
- IEEE80211_LOCK_ASSERT(ic);
-
TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next)
if (vap->iv_opmode == IEEE80211_M_HOSTAP)
ieee80211_beacon_notify(vap, IEEE80211_BEACON_ERP);
void
ieee80211_notify_erp(struct ieee80211com *ic)
{
- IEEE80211_LOCK(ic);
ieee80211_notify_erp_locked(ic);
- IEEE80211_UNLOCK(ic);
}
/*
{
struct ieee80211com *ic = ni->ni_ic;
- IEEE80211_LOCK_ASSERT(ic);
-
/*
* Station isn't capable of short slot time. Bump
* the count of long slot time stations and disable
}
ni->ni_associd = aid | 0xc000;
ni->ni_jointime = time_second;
- IEEE80211_LOCK(ic);
IEEE80211_AID_SET(vap, ni->ni_associd);
vap->iv_sta_assoc++;
ic->ic_sta_assoc++;
if (IEEE80211_IS_CHAN_ANYG(ic->ic_bsschan) &&
IEEE80211_IS_CHAN_FULL(ic->ic_bsschan))
ieee80211_node_join_11g(ni);
- IEEE80211_UNLOCK(ic);
newassoc = 1;
} else
{
struct ieee80211com *ic = ni->ni_ic;
- IEEE80211_LOCK_ASSERT(ic);
-
KASSERT(IEEE80211_IS_CHAN_ANYG(ic->ic_bsschan),
("not in 11g, bss %u:0x%x", ic->ic_bsschan->ic_freq,
ic->ic_bsschan->ic_flags));
static void
ieee80211_erp_timeout(struct ieee80211com *ic)
{
-
- IEEE80211_LOCK_ASSERT(ic);
-
if ((ic->ic_flags_ext & IEEE80211_FEXT_NONERP_PR) &&
time_after(ticks, ic->ic_lastnonerp + IEEE80211_NONERP_PRESENT_AGE)) {
#if 0
if (vap->iv_auth->ia_node_leave != NULL)
vap->iv_auth->ia_node_leave(ni);
- IEEE80211_LOCK(ic);
IEEE80211_AID_CLR(vap, ni->ni_associd);
ni->ni_associd = 0;
vap->iv_sta_assoc--;
if (IEEE80211_IS_CHAN_ANYG(ic->ic_bsschan) &&
IEEE80211_IS_CHAN_FULL(ic->ic_bsschan))
ieee80211_node_leave_11g(ni);
- IEEE80211_UNLOCK(ic);
/*
* Cleanup station state. In particular clear various
* state that might otherwise be reused if the node
* for inactivity.
*/
if (nt != NULL) {
- IEEE80211_NODE_LOCK(nt);
node_reclaim(nt, ni);
- IEEE80211_NODE_UNLOCK(nt);
} else
ieee80211_free_node(ni);
}
* for CSA).
*/
if (vap->iv_state != IEEE80211_S_RUN) {
- IEEE80211_LOCK(ic);
/* re-check under the com lock to avoid races */
if (vap->iv_state != IEEE80211_S_RUN) {
IEEE80211_DPRINTF(vap, IEEE80211_MSG_OUTPUT,
__func__, ieee80211_state_name[vap->iv_state]);
vap->iv_stats.is_tx_badstate++;
ifp->if_flags |= IFF_OACTIVE;
- IEEE80211_UNLOCK(ic);
return;
}
- IEEE80211_UNLOCK(ic);
}
for (;;) {
m = ifq_dequeue(&ifp->if_snd, NULL);
int len_changed = 0;
uint16_t capinfo;
- IEEE80211_LOCK(ic);
/*
* Handle 11h channel change when we've reached the count.
* We must recalculate the beacon frame contents to account
mtod(m, uint8_t*) + sizeof(struct ieee80211_frame), bo, ni);
/* XXX do WME aggressive mode processing? */
- IEEE80211_UNLOCK(ic);
return 1; /* just assume length changed */
}
frm = add_appie(frm, aie);
clrbit(bo->bo_flags, IEEE80211_BEACON_APPIE);
}
- IEEE80211_UNLOCK(ic);
return len_changed;
}
{
memset(psq, 0, sizeof(psq));
psq->psq_maxlen = IEEE80211_PS_MAX_QUEUE;
- IEEE80211_PSQ_INIT(psq, name); /* OS-dependent setup */
}
void
#else
KASSERT(psq->psq_len == 0, ("%d frames on ps q", psq->psq_len));
#endif
- IEEE80211_PSQ_DESTROY(psq); /* OS-dependent cleanup */
}
/*
struct ieee80211_psq_head *qhead;
struct mbuf *m;
- IEEE80211_PSQ_LOCK(psq);
qhead = &psq->psq_head[0];
again:
if ((m = qhead->head) != NULL) {
}
if (qlen != NULL)
*qlen = psq->psq_len;
- IEEE80211_PSQ_UNLOCK(psq);
return m;
}
struct mbuf *m;
int qlen;
- IEEE80211_PSQ_LOCK(psq);
qlen = psq->psq_len;
qhead = &psq->psq_head[0];
again:
goto again;
}
psq->psq_len = 0;
- IEEE80211_PSQ_UNLOCK(psq);
return qlen;
}
struct ieee80211_psq_head *qhead;
struct mbuf *m;
- IEEE80211_PSQ_LOCK(psq);
qhead = &psq->psq_head[0];
again:
while ((m = qhead->head) != NULL &&
}
if (m != NULL)
M_AGE_SUB(m, IEEE80211_INACT_WAIT);
- IEEE80211_PSQ_UNLOCK(psq);
IEEE80211_NOTE(vap, IEEE80211_MSG_POWER, ni,
"discard %u frames for age", discard);
KASSERT(aid < vap->iv_max_aid,
("bogus aid %u, max %u", aid, vap->iv_max_aid));
- IEEE80211_LOCK(ic);
changed = (set != (isset(vap->iv_tim_bitmap, aid) != 0));
if (changed) {
if (set) {
/* NB: we know vap is in RUN state so no need to check */
vap->iv_update_beacon(vap, IEEE80211_BEACON_TIM);
}
- IEEE80211_UNLOCK(ic);
return changed;
}
struct ieee80211_psq_head *qhead;
int qlen, age;
- IEEE80211_PSQ_LOCK(psq);
if (psq->psq_len >= psq->psq_maxlen) {
psq->psq_drops++;
- IEEE80211_PSQ_UNLOCK(psq);
IEEE80211_NOTE(vap, IEEE80211_MSG_ANY, ni,
"pwr save q overflow, drops %d (size %d)",
psq->psq_drops, psq->psq_len);
qhead->tail = m;
qhead->len++;
qlen = ++(psq->psq_len);
- IEEE80211_PSQ_UNLOCK(psq);
IEEE80211_NOTE(vap, IEEE80211_MSG_POWER, ni,
"save frame with age %d, %u now queued", age, qlen);
IEEE80211_NOTE(vap, IEEE80211_MSG_POWER, ni,
"flush ps queue, %u packets queued", psq->psq_len);
- IEEE80211_PSQ_LOCK(psq);
qhead = &psq->psq_head[0]; /* 802.11 frames */
if (qhead->head != NULL) {
/* XXX could dispatch through vap and check M_ENCAP */
} else
ifp = NULL;
psq->psq_len = 0;
- IEEE80211_PSQ_UNLOCK(psq);
/* NB: do this outside the psq lock */
/* XXX packets might get reordered if parent is OACTIVE */
enum ieee80211_phymode mode;
int i;
- IEEE80211_LOCK_ASSERT(ic);
-
if ((ic->ic_caps & IEEE80211_C_WME) == 0 || ic->ic_nrunning > 1)
return;
struct ieee80211com *ic = vap->iv_ic;
ic = vap->iv_ic;
- IEEE80211_LOCK(ic);
ieee80211_wme_initparams_locked(vap);
- IEEE80211_UNLOCK(ic);
}
/*
struct ieee80211com *ic = vap->iv_ic;
if (ic->ic_caps & IEEE80211_C_WME) {
- IEEE80211_LOCK(ic);
ieee80211_wme_updateparams_locked(vap);
- IEEE80211_UNLOCK(ic);
}
}
struct ieee80211com *ic = vap->iv_ic;
struct ifnet *parent = ic->ic_ifp;
- IEEE80211_LOCK_ASSERT(ic);
-
IEEE80211_DPRINTF(vap,
IEEE80211_MSG_STATE | IEEE80211_MSG_DEBUG,
"start running, %d vaps running\n", ic->ic_nrunning);
IEEE80211_DPRINTF(vap, IEEE80211_MSG_STATE | IEEE80211_MSG_DEBUG,
"%s\n", __func__);
- IEEE80211_LOCK(vap->iv_ic);
ieee80211_start_locked(vap);
- IEEE80211_UNLOCK(vap->iv_ic);
}
/*
{
struct ieee80211vap *vap;
- IEEE80211_LOCK(ic);
TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) {
struct ifnet *ifp = vap->iv_ifp;
if (IFNET_IS_UP_RUNNING(ifp)) /* NB: avoid recursion */
ieee80211_start_locked(vap);
}
- IEEE80211_UNLOCK(ic);
}
/*
struct ifnet *ifp = vap->iv_ifp;
struct ifnet *parent = ic->ic_ifp;
- IEEE80211_LOCK_ASSERT(ic);
-
IEEE80211_DPRINTF(vap, IEEE80211_MSG_STATE | IEEE80211_MSG_DEBUG,
"stop running, %d vaps running\n", ic->ic_nrunning);
struct ieee80211com *ic = vap->iv_ic;
ic = vap->iv_ic;
- IEEE80211_LOCK(ic);
ieee80211_stop_locked(vap);
- IEEE80211_UNLOCK(ic);
}
/*
{
struct ieee80211vap *vap;
- IEEE80211_LOCK(ic);
TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) {
struct ifnet *ifp = vap->iv_ifp;
if (IFNET_IS_UP_RUNNING(ifp)) /* NB: avoid recursion */
ieee80211_stop_locked(vap);
}
- IEEE80211_UNLOCK(ic);
ieee80211_waitfor_parent(ic);
}
{
struct ieee80211vap *vap;
- IEEE80211_LOCK(ic);
TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) {
struct ifnet *ifp = vap->iv_ifp;
if (IFNET_IS_UP_RUNNING(ifp)) { /* NB: avoid recursion */
ieee80211_stop_locked(vap);
}
}
- IEEE80211_UNLOCK(ic);
ieee80211_waitfor_parent(ic);
}
{
struct ieee80211vap *vap;
- IEEE80211_LOCK(ic);
TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) {
struct ifnet *ifp = vap->iv_ifp;
if (!IFNET_IS_UP_RUNNING(ifp) &&
ieee80211_start_locked(vap);
}
}
- IEEE80211_UNLOCK(ic);
}
void
ieee80211_beacon_miss(struct ieee80211com *ic)
{
- IEEE80211_LOCK(ic);
if ((ic->ic_flags & IEEE80211_F_SCAN) == 0) {
/* Process in a taskq, the handler may reenter the driver */
ieee80211_runtask(ic, &ic->ic_bmiss_task);
}
- IEEE80211_UNLOCK(ic);
}
static void
{
struct ieee80211vap *vap;
- IEEE80211_LOCK_ASSERT(ic);
-
ic->ic_csa_newchan = c;
ic->ic_csa_mode = mode;
ic->ic_csa_count = count;
void
ieee80211_csa_completeswitch(struct ieee80211com *ic)
{
- IEEE80211_LOCK_ASSERT(ic);
-
KASSERT(ic->ic_flags & IEEE80211_F_CSAPENDING, ("csa not pending"));
ieee80211_setcurchan(ic, ic->ic_csa_newchan);
void
ieee80211_csa_cancelswitch(struct ieee80211com *ic)
{
- IEEE80211_LOCK_ASSERT(ic);
-
csa_completeswitch(ic);
}
struct ieee80211com *ic = vap0->iv_ic;
struct ieee80211vap *vap;
- IEEE80211_LOCK(ic);
/*
* Complete CAC state change for lead vap first; then
* clock all the other vap's waiting.
TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next)
if (vap->iv_state == IEEE80211_S_CAC)
ieee80211_new_state_locked(vap, IEEE80211_S_RUN, 0);
- IEEE80211_UNLOCK(ic);
}
/*
struct ieee80211com *ic = vap0->iv_ic;
struct ieee80211vap *vap;
- IEEE80211_LOCK_ASSERT(ic);
-
/*
* A vap list entry can not disappear since we are running on the
* taskqueue and a vap destroy will queue and drain another state
struct ieee80211com *ic = vap0->iv_ic;
struct ieee80211vap *vap;
- IEEE80211_LOCK_ASSERT(ic);
-
/*
* A vap list entry can not disappear since we are running on the
* taskqueue and a vap destroy will queue and drain another state
enum ieee80211_state nstate, ostate;
int arg, rc;
- IEEE80211_LOCK(ic);
nstate = vap->iv_nstate;
arg = vap->iv_nstate_arg;
ieee80211_flush_ifq((struct ifqueue *)&ic->ic_ifp->if_snd, vap);
}
done:
- IEEE80211_UNLOCK(ic);
+ ;
}
/*
enum ieee80211_state ostate;
int nrunning, nscanning;
- IEEE80211_LOCK_ASSERT(ic);
-
if (vap->iv_flags_ext & IEEE80211_FEXT_STATEWAIT) {
if (vap->iv_nstate == IEEE80211_S_INIT) {
/*
int rc;
ic = vap->iv_ic;
- IEEE80211_LOCK(ic);
rc = ieee80211_new_state_locked(vap, nstate, arg);
- IEEE80211_UNLOCK(ic);
return rc;
}
{
struct ieee80211vap *vap;
- IEEE80211_LOCK_ASSERT(ic);
TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next)
if (vap->iv_state != IEEE80211_S_INIT)
return 0;
if (c->ic_maxpower == 0)
c->ic_maxpower = 2*c->ic_maxregpower;
}
- IEEE80211_LOCK(ic);
/* XXX bandaid; a running vap will likely crash */
if (!allvapsdown(ic)) {
- IEEE80211_UNLOCK(ic);
IEEE80211_DPRINTF(vap, IEEE80211_MSG_IOCTL,
"%s: reject: vaps are running\n", __func__);
return EBUSY;
error = ic->ic_setregdomain(ic, ®->rd,
reg->chaninfo.ic_nchans, reg->chaninfo.ic_chans);
if (error != 0) {
- IEEE80211_UNLOCK(ic);
IEEE80211_DPRINTF(vap, IEEE80211_MSG_IOCTL,
"%s: driver rejected request, error %u\n", __func__, error);
return error;
/* NB: may be NULL if not present in new channel list */
vap->iv_des_chan = (c != NULL) ? c : IEEE80211_CHAN_ANYC;
}
- IEEE80211_UNLOCK(ic);
return 0;
}
ic->ic_scan = NULL;
return;
}
- cv_init(&ss->ss_scan_cv, "scan");
+ wlan_cv_init(&ss->ss_scan_cv, "scan");
callout_init(&ss->ss_scan_timer);
TASK_INIT(&ss->ss_scan_task, 0, scan_task, ss);
ic->ic_scan = &ss->base;
struct ieee80211_scan_state *ss = ic->ic_scan;
if (ss != NULL) {
- IEEE80211_LOCK(ic);
SCAN_PRIVATE(ss)->ss_iflags |= ISCAN_ABORT;
scan_signal(ss);
- IEEE80211_UNLOCK(ic);
ieee80211_draintask(ic, &SCAN_PRIVATE(ss)->ss_scan_task);
callout_stop(&SCAN_PRIVATE(ss)->ss_scan_timer);
KASSERT((ic->ic_flags & IEEE80211_F_SCAN) == 0,
struct ieee80211com *ic = vap->iv_ic;
struct ieee80211_scan_state *ss;
- IEEE80211_LOCK(ic);
ss = ic->ic_scan;
if (ss != NULL && ss->ss_vap == vap) {
if (ic->ic_flags & IEEE80211_F_SCAN) {
}
ss->ss_vap = NULL;
}
- IEEE80211_UNLOCK(ic);
}
/*
struct ieee80211com *ic = vap->iv_ic;
struct ieee80211_scan_state *ss = ic->ic_scan;
- IEEE80211_LOCK_ASSERT(ic);
-
#ifdef IEEE80211_DEBUG
if (ss->ss_vap != vap || ss->ss_ops != scan) {
IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN,
struct ieee80211com *ic = vap->iv_ic;
struct ieee80211_scan_state *ss = ic->ic_scan;
- IEEE80211_LOCK_ASSERT(ic);
-
if (ic->ic_flags & IEEE80211_F_CSAPENDING) {
IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN,
"%s: scan inhibited by pending channel change\n", __func__);
return 0;
}
- IEEE80211_LOCK(ic);
result = start_scan_locked(scan, vap, flags, duration,
mindwell, maxdwell, nssid, ssids);
- IEEE80211_UNLOCK(ic);
return result;
}
* XXX want more than the ap we're currently associated with
*/
- IEEE80211_LOCK(ic);
IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN,
"%s: %s scan, %s%s%s%s%s\n"
, __func__
SCAN_PRIVATE(ss)->ss_iflags &= ~ISCAN_DISCARD;
if (result) {
ieee80211_notify_scan_done(vap);
- IEEE80211_UNLOCK(ic);
return 1;
}
}
}
result = start_scan_locked(scan, vap, flags, duration,
mindwell, maxdwell, nssid, ssids);
- IEEE80211_UNLOCK(ic);
return result;
}
return 0;
}
- IEEE80211_LOCK(ic);
if ((ic->ic_flags & IEEE80211_F_SCAN) == 0) {
u_int duration;
/*
"%s: %s scan already in progress\n", __func__,
ss->ss_flags & IEEE80211_SCAN_ACTIVE ? "active" : "passive");
}
- IEEE80211_UNLOCK(ic);
/* NB: racey, does it matter? */
return (ic->ic_flags & IEEE80211_F_SCAN);
struct ieee80211com *ic = vap->iv_ic;
struct ieee80211_scan_state *ss = ic->ic_scan;
- IEEE80211_LOCK(ic);
if ((ic->ic_flags & IEEE80211_F_SCAN) &&
ss->ss_vap == vap &&
(SCAN_PRIVATE(ss)->ss_iflags & ISCAN_CANCEL) == 0) {
/* wake up the scan task */
scan_signal(ss);
}
- IEEE80211_UNLOCK(ic);
}
/*
struct ieee80211com *ic = vap->iv_ic;
struct ieee80211_scan_state *ss = ic->ic_scan;
- IEEE80211_LOCK(ic);
if ((ic->ic_flags & IEEE80211_F_SCAN) &&
(SCAN_PRIVATE(ss)->ss_iflags & ISCAN_CANCEL) == 0) {
IEEE80211_DPRINTF(vap, IEEE80211_MSG_SCAN,
/* wake up the scan task */
scan_signal(ss);
}
- IEEE80211_UNLOCK(ic);
}
/*
struct ieee80211_scan_state *ss = ic->ic_scan;
/* wake up the scan task */
- IEEE80211_LOCK(ic);
scan_signal(ss);
- IEEE80211_UNLOCK(ic);
}
/*
struct ieee80211com *ic = vap->iv_ic;
struct ieee80211_scan_state *ss;
- IEEE80211_LOCK(ic);
ss = ic->ic_scan;
ss->ss_next = ss->ss_last; /* all channels are complete */
scan_signal(ss);
- IEEE80211_UNLOCK(ic);
}
/*
{
struct ieee80211vap *vap = ss->ss_vap;
- IEEE80211_LOCK(vap->iv_ic);
if (ss->ss_flags & IEEE80211_SCAN_ACTIVE)
ieee80211_probe_curchan(vap, 0);
callout_reset(&SCAN_PRIVATE(ss)->ss_scan_timer,
maxdwell, scan_signal, ss);
- IEEE80211_UNLOCK(vap->iv_ic);
}
static void
{
struct ieee80211_scan_state *ss = (struct ieee80211_scan_state *) arg;
- IEEE80211_LOCK(ss->ss_ic);
- cv_signal(&SCAN_PRIVATE(ss)->ss_scan_cv);
- IEEE80211_UNLOCK(ss->ss_ic);
+ wlan_cv_signal(&SCAN_PRIVATE(ss)->ss_scan_cv, 0);
}
/*
struct ieee80211com *ic = ss->ss_ic;
ic = ss->ss_ic;
- IEEE80211_LOCK(ic);
scan_signal(ss);
- IEEE80211_UNLOCK(ic);
}
static void
unsigned long maxdwell, scanend;
int scandone = 0;
- IEEE80211_LOCK(ic);
if (vap == NULL || (ic->ic_flags & IEEE80211_F_SCAN) == 0 ||
(SCAN_PRIVATE(ss)->ss_iflags & ISCAN_ABORT)) {
/* Cancelled before we started */
ieee80211_sta_pwrsave(vap, 1);
/*
* Use an 1ms delay so the null data frame has a chance
- * to go out.
+ * to go out. Minimum one tick.
* XXX Should use M_TXCB mechanism to eliminate this.
*/
- cv_timedwait(&SCAN_PRIVATE(ss)->ss_scan_cv,
- IEEE80211_LOCK_OBJ(ic), hz / 1000);
+ wlan_cv_timedwait(&SCAN_PRIVATE(ss)->ss_scan_cv,
+ hz / 1000 + 1);
if (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_ABORT)
goto done;
}
}
scanend = ticks + SCAN_PRIVATE(ss)->ss_duration;
- IEEE80211_UNLOCK(ic);
ic->ic_scan_start(ic); /* notify driver */
- IEEE80211_LOCK(ic);
for (;;) {
scandone = (ss->ss_next >= ss->ss_last) ||
*/
ic->ic_curchan = chan;
ic->ic_rt = ieee80211_get_ratetable(chan);
- IEEE80211_UNLOCK(ic);
/*
* Perform the channel change and scan unlocked so the driver
* may sleep. Once set_channel returns the hardware has
* and allows it to be signalled for abort.
*/
ic->ic_scan_curchan(ss, maxdwell);
- IEEE80211_LOCK(ic);
SCAN_PRIVATE(ss)->ss_chanmindwell = ticks + ss->ss_mindwell;
/* clear mindwell lock and initial channel change flush */
continue;
/* Wait to be signalled to scan the next channel */
- cv_wait(&SCAN_PRIVATE(ss)->ss_scan_cv, IEEE80211_LOCK_OBJ(ic));
+ wlan_cv_wait(&SCAN_PRIVATE(ss)->ss_scan_cv);
}
if (SCAN_PRIVATE(ss)->ss_iflags & ISCAN_ABORT)
goto done;
- IEEE80211_UNLOCK(ic);
ic->ic_scan_end(ic); /* notify driver */
- IEEE80211_LOCK(ic);
/*
* Record scan complete time. Note that we also do
if (ic->ic_bsschan != IEEE80211_CHAN_ANYC &&
ic->ic_curchan != ic->ic_bsschan) {
ieee80211_setupcurchan(ic, ic->ic_bsschan);
- IEEE80211_UNLOCK(ic);
ic->ic_set_channel(ic);
ieee80211_radiotap_chan_change(ic);
- IEEE80211_LOCK(ic);
}
/* clear internal flags and any indication of a pick */
SCAN_PRIVATE(ss)->ss_iflags &= ~ISCAN_REP;
ss->ss_ops->scan_restart(ss, vap); /* XXX? */
ieee80211_runtask(ic, &SCAN_PRIVATE(ss)->ss_scan_task);
- IEEE80211_UNLOCK(ic);
return;
}
}
SCAN_PRIVATE(ss)->ss_iflags &= ~(ISCAN_CANCEL|ISCAN_ABORT);
ss->ss_flags &= ~(IEEE80211_SCAN_ONCE | IEEE80211_SCAN_PICK1ST);
- IEEE80211_UNLOCK(ic);
#undef ISCAN_REP
}
{
struct ieee80211_scan_state *ss = ic->ic_scan;
- IEEE80211_LOCK_ASSERT(ic);
-
if (ss == NULL || ss->ss_ops == NULL || ss->ss_vap == NULL) {
/* XXX printf? */
return NULL;
{
struct ifnet *ifp = ic->ic_ifp;
- IEEE80211_LOCK(ic);
/* set interface into promiscuous mode */
ifp->if_flags |= IFF_PROMISC;
ieee80211_runtask(ic, &ic->ic_promisc_task);
- IEEE80211_UNLOCK(ic);
}
static void
ap_reset_promisc(struct ieee80211com *ic)
{
- IEEE80211_LOCK(ic);
ieee80211_syncifflag_locked(ic, IFF_PROMISC);
- IEEE80211_UNLOCK(ic);
}
static int
struct ieee80211_node *ni;
enum ieee80211_state ostate;
- IEEE80211_LOCK_ASSERT(ic);
-
ostate = vap->iv_state;
IEEE80211_DPRINTF(vap, IEEE80211_MSG_STATE, "%s: %s -> %s (%d)\n",
__func__, ieee80211_state_name[ostate],
wh, "CSA", "invalid mode %u", csa->csa_mode);
return;
}
- IEEE80211_LOCK(ic);
if ((ic->ic_flags & IEEE80211_F_CSAPENDING) == 0) {
/*
* Convert the channel number to a channel reference. We
}
}
done:
- IEEE80211_UNLOCK(ic);
+ ;
}
/*
* stuck in CSA state. If the AP really is
* moving we'll get a beacon miss and scan.
*/
- IEEE80211_LOCK(ic);
ieee80211_csa_cancelswitch(ic);
- IEEE80211_UNLOCK(ic);
}
/*
* If scanning, pass the info to the scan module.
KASSERT(sq->head != NULL, ("stageq empty"));
- IEEE80211_LOCK(ic);
head = sq->head;
while ((m = sq->head) != NULL && M_AGE_GET(m) < quanta) {
/* clear tap ref to frame */
sq->tail = NULL;
else
M_AGE_SUB(m, quanta);
- IEEE80211_UNLOCK(ic);
ff_flush(head, m);
}
* Do 802.1x EAPOL frames proceed in the clear? Then they couldn't
* be aggregated with other types of frames when encryption is on?
*/
- IEEE80211_LOCK(ic);
tap = &ni->ni_tx_ampdu[pri];
mstaged = tap->txa_private; /* NB: we reuse AMPDU state */
ieee80211_txampdu_count_packet(tap);
if (vap->iv_opmode != IEEE80211_M_STA &&
ETHER_IS_MULTICAST(mtod(m, struct ether_header *)->ether_dhost)) {
/* XXX flush staged frame? */
- IEEE80211_UNLOCK(ic);
return m;
}
/*
*/
if (mstaged == NULL &&
ieee80211_txampdu_getpps(tap) < ieee80211_ffppsmin) {
- IEEE80211_UNLOCK(ic);
return m;
}
sq = &sg->ff_stageq[pri];
tap->txa_private = NULL;
if (mstaged != NULL)
stageq_remove(sq, mstaged);
- IEEE80211_UNLOCK(ic);
if (mstaged != NULL) {
IEEE80211_NOTE(vap, IEEE80211_MSG_SUPERG, ni,
if (mstaged != NULL) {
tap->txa_private = NULL;
stageq_remove(sq, mstaged);
- IEEE80211_UNLOCK(ic);
IEEE80211_NOTE(vap, IEEE80211_MSG_SUPERG, ni,
"%s: aggregate fast-frame", __func__);
stageq_add(sq, m);
sg->ff_stageqdepth++;
- IEEE80211_UNLOCK(ic);
IEEE80211_NOTE(vap, IEEE80211_MSG_SUPERG, ni,
"%s: stage frame, %u queued", __func__, sq->depth);
struct mbuf *m, *head;
int ac;
- IEEE80211_LOCK(ic);
head = NULL;
for (ac = 0; ac < WME_NUM_AC; ac++) {
tap = &ni->ni_tx_ampdu[ac];
head = m;
}
}
- IEEE80211_UNLOCK(ic);
for (m = head; m != NULL; m = m->m_nextpkt) {
m_freem(m);
enum ieee80211_state ostate;
int status;
- IEEE80211_LOCK_ASSERT(ic);
-
ostate = vap->iv_state;
IEEE80211_DPRINTF(vap, IEEE80211_MSG_STATE, "%s: %s -> %s (%d)\n",
__func__, ieee80211_state_name[ostate],
ieee80211_create_wds(struct ieee80211vap *vap, struct ieee80211_channel *chan)
{
struct ieee80211com *ic = vap->iv_ic;
- struct ieee80211_node_table *nt = &ic->ic_sta;
+/* struct ieee80211_node_table *nt = &ic->ic_sta;*/
struct ieee80211_node *ni, *obss;
IEEE80211_DPRINTF(vap, IEEE80211_MSG_WDS,
* be dispatched upward (e.g. to a bridge) as though
* they arrived on the WDS vap.
*/
- IEEE80211_NODE_LOCK(nt);
obss = NULL;
ni = ieee80211_find_node_locked(&ic->ic_sta, vap->iv_des_bssid);
if (ni == NULL) {
vap->iv_bss = ni;
ni->ni_wdsvap = vap;
}
- IEEE80211_NODE_UNLOCK(nt);
if (obss != NULL) {
/* NB: deferred to avoid recursive lock */
ieee80211_free_node(obss);
enum ieee80211_state ostate;
int error;
- IEEE80211_LOCK_ASSERT(ic);
-
ostate = vap->iv_state;
IEEE80211_DPRINTF(vap, IEEE80211_MSG_STATE, "%s: %s -> %s\n", __func__,
ieee80211_state_name[ostate], ieee80211_state_name[nstate]);
uint8_t acl_macaddr[IEEE80211_ADDR_LEN];
};
struct aclstate {
- acl_lock_t as_lock;
int as_policy;
int as_nacls;
TAILQ_HEAD(, acl) as_list; /* list of all ACL's */
M_80211_ACL, M_INTWAIT | M_ZERO);
if (as == NULL)
return 0;
- ACL_LOCK_INIT(as, "acl");
TAILQ_INIT(&as->as_list);
as->as_policy = ACL_POLICY_OPEN;
as->as_vap = vap;
acl_free_all(vap);
vap->iv_as = NULL;
- ACL_LOCK_DESTROY(as);
kfree(as, M_80211_ACL);
}
static void
_acl_free(struct aclstate *as, struct acl *acl)
{
- ACL_LOCK_ASSERT(as);
TAILQ_REMOVE(&as->as_list, acl, acl_list);
LIST_REMOVE(acl, acl_hash);
return ENOMEM;
}
- ACL_LOCK(as);
hash = ACL_HASH(mac);
LIST_FOREACH(acl, &as->as_hash[hash], acl_hash) {
if (IEEE80211_ADDR_EQ(acl->acl_macaddr, mac)) {
- ACL_UNLOCK(as);
kfree(new, M_80211_ACL);
IEEE80211_DPRINTF(vap, IEEE80211_MSG_ACL,
"ACL: add %6D failed, already present\n",
TAILQ_INSERT_TAIL(&as->as_list, new, acl_list);
LIST_INSERT_HEAD(&as->as_hash[hash], new, acl_hash);
as->as_nacls++;
- ACL_UNLOCK(as);
IEEE80211_DPRINTF(vap, IEEE80211_MSG_ACL,
"ACL: add %6D\n", mac, ":");
struct aclstate *as = vap->iv_as;
struct acl *acl;
- ACL_LOCK(as);
acl = _find_acl(as, mac);
if (acl != NULL)
_acl_free(as, acl);
- ACL_UNLOCK(as);
IEEE80211_DPRINTF(vap, IEEE80211_MSG_ACL,
"ACL: remove %6D%s\n", mac, ":",
IEEE80211_DPRINTF(vap, IEEE80211_MSG_ACL, "ACL: %s\n", "free all");
- ACL_LOCK(as);
while ((acl = TAILQ_FIRST(&as->as_list)) != NULL)
_acl_free(as, acl);
- ACL_UNLOCK(as);
return 0;
}
if (ap == NULL)
return ENOMEM;
i = 0;
- ACL_LOCK(as);
TAILQ_FOREACH(acl, &as->as_list, acl_list) {
IEEE80211_ADDR_COPY(ap[i].ml_macaddr, acl->acl_macaddr);
i++;
}
- ACL_UNLOCK(as);
if (ireq->i_len >= space) {
error = copyout(ap, ireq->i_data, space);
ireq->i_len = space;
lentferj's projects / dragonfly.git / commitdiff