net80211: split scan_task() (#3) (into scan_start() and scan_curchan_task() functions)

[avos]

Summary

(This part should fix the problem, described in https://lists.freebsd.org/pipermail/freebsd-wireless/2016-January/006420.html)

• Rename ss_scan_task into ss_scan_start (better describes it's current purpose)
• Utilize taskqueue_*_timeout() functions instead of current mechanism:
  • reschedule scan_curchan_task() via taskqueue_enqueue_timeout() for every 'maxdwell' msecs (will replace infinite loop + sleeping for 'maxdwell' period via cv_wait());
  • rerun the task immediately when an external event occurs (instead of waking it up via cv_signal())

Also, use mtx_sleep() to wait for null frame transmission (allows to drop conditional variable).

Test Plan

Tested with:

• Intel 3945BG, STA mode;
• RTL8188EU, STA mode.

head/sys/net80211/ieee80211_scan_sw.c

 static void
 vm_page_init_page(vm_page_t m, vm_paddr_t pa, int segind)
 {
 
         m->object = NULL;
         m->wire_count = 0;
         m->busy_lock = VPB_UNBUSIED;
         m->hold_count = 0;
-        m->flags = 0;
+        m->flags = m->aflags = 0;
         m->phys_addr = pa;
         m->queue = PQ_NONE;
         m->psind = 0;
         m->segind = segind;
         m->order = VM_NFREEORDER;
         m->pool = VM_FREEPOOL_DEFAULT;
         m->valid = m->dirty = 0;
         pmap_page_init(m);

 /*
  * Check a page that has been freshly dequeued from a freelist.
  */
 static void
 vm_page_alloc_check(vm_page_t m)
 {
 
         KASSERT(m->object == NULL, ("page %p has object", m));
-        KASSERT(m->queue == PQ_NONE,
-            ("page %p has unexpected queue %d", m, m->queue));
+        KASSERT(m->queue == PQ_NONE && (m->aflags & PGA_QUEUE_STATE_MASK) == 0,
+            ("page %p has unexpected queue %d, flags %#x",
+            m, m->queue, (m->aflags & PGA_QUEUE_STATE_MASK)));
         KASSERT(!vm_page_held(m), ("page %p is held", m));
         KASSERT(!vm_page_busied(m), ("page %p is busy", m));
         KASSERT(m->dirty == 0, ("page %p is dirty", m));
         KASSERT(pmap_page_get_memattr(m) == VM_MEMATTR_DEFAULT,
             ("page %p has unexpected memattr %d",
             m, pmap_page_get_memattr(m)));
         KASSERT(m->valid == 0, ("free page %p is valid", m));
 }
vm_page_pagequeue(vm_page_t m)
         return (&vm_pagequeue_domain(m)->vmd_pagequeues[m->queue]);
 }
 
 static struct mtx *
 vm_page_pagequeue_lockptr(vm_page_t m)
 {
         uint8_t queue;
 
-        if ((queue = m->queue) == PQ_NONE)
+        if ((queue = atomic_load_8(&m->queue)) == PQ_NONE)
                 return (NULL);
         return (&vm_pagequeue_domain(m)->vmd_pagequeues[queue].pq_mutex);
 }
 
 static inline void
 vm_pqbatch_process_page(struct vm_pagequeue *pq, vm_page_t m)
 {
         struct vm_domain *vmd;
         uint8_t aflags;
 
+        CRITICAL_ASSERT(curthread);
         vm_pagequeue_assert_locked(pq);
         KASSERT(pq == vm_page_pagequeue(m),
             ("page %p doesn't belong to %p", m, pq));
 
         aflags = m->aflags;
         if ((aflags & PGA_DEQUEUE) != 0) {
                 if (__predict_true((aflags & PGA_ENQUEUED) != 0)) {
                         TAILQ_REMOVE(&pq->pq_pl, m, plinks.q);

  */
 void
 vm_page_dequeue_deferred(vm_page_t m)
 {
         int queue;
 
         vm_page_assert_locked(m);
 
-        queue = m->queue;
+        queue = atomic_load_8(&m->queue);
         if (queue == PQ_NONE) {
                 KASSERT((m->aflags & PGA_QUEUE_STATE_MASK) == 0,
                     ("page %p has queue state", m));
                 return;
         }
         if ((m->aflags & PGA_DEQUEUE) == 0)
                 vm_page_aflag_set(m, PGA_DEQUEUE);
         vm_pqbatch_submit_page(m, queue);
 }
 
 /*
- *      vm_page_dequeue_locked:
- *
- *      Remove the page from its page queue, which must be locked.
- *      If the page lock is not held, there is no guarantee that the
- *      page will not be enqueued by another thread before this function
- *      returns.  In this case, it is up to the caller to ensure that
- *      no other threads hold a reference to the page.
- *
- *      The page queue lock must be held.  If the page is not already
- *      logically dequeued, the page lock must be held as well.
- */
-void
-vm_page_dequeue_locked(vm_page_t m)
-{
-        struct vm_pagequeue *pq;
-
-        pq = vm_page_pagequeue(m);
-
-        KASSERT(m->queue != PQ_NONE,
-            ("%s: page %p queue field is PQ_NONE", __func__, m));
-        vm_pagequeue_assert_locked(pq);
-        KASSERT((m->aflags & PGA_DEQUEUE) != 0 ||
-            mtx_owned(vm_page_lockptr(m)),
-            ("%s: queued unlocked page %p", __func__, m));
-
-        if ((m->aflags & PGA_ENQUEUED) != 0) {
-                TAILQ_REMOVE(&pq->pq_pl, m, plinks.q);
-                vm_pagequeue_cnt_dec(pq);
-        }
-        vm_page_dequeue_complete(m);
-}
-
-/*
  *      vm_page_dequeue:
  *
  *      Remove the page from whichever page queue it's in, if any.
- *      If the page lock is not held, there is no guarantee that the
- *      page will not be enqueued by another thread before this function
- *      returns.  In this case, it is up to the caller to ensure that
- *      no other threads hold a reference to the page.
+ *      The page must either be locked or unallocated.  This constraint
+ *      ensures that the queue state of the page will remain consistent
+ *      after this function returns.
  */
 void
 vm_page_dequeue(vm_page_t m)
 {
         struct mtx *lock, *lock1;
+        struct vm_pagequeue *pq;
+        uint8_t aflags;
 
-        lock = vm_page_pagequeue_lockptr(m);
+        KASSERT(mtx_owned(vm_page_lockptr(m)) || m->order == VM_NFREEORDER,
+            ("page %p is allocated and unlocked", m));
+
         for (;;) {
-                if (lock == NULL)
+                lock = vm_page_pagequeue_lockptr(m);
+                if (lock == NULL) {
+                        /*
+                         * A thread may be concurrently executing
+                         * vm_page_dequeue_complete().  Ensure that all queue
+                         * state is cleared before we return.
+                         */
+                        aflags = atomic_load_8(&m->aflags);
+                        if ((aflags & PGA_QUEUE_STATE_MASK) == 0)
                                 return;
+                        KASSERT((aflags & PGA_DEQUEUE) != 0,
+                            ("page %p has unexpected queue state flags %#x",
+                            m, aflags));
+
+                        /*
+                         * Busy wait until the thread updating queue state is
+                         * finished.  Such a thread must be executing in a
+                         * critical section.
+                         */
+                        cpu_spinwait();
+                        continue;
+                }
                 mtx_lock(lock);
                 if ((lock1 = vm_page_pagequeue_lockptr(m)) == lock)
                         break;
                 mtx_unlock(lock);
                 lock = lock1;
         }
         KASSERT(lock == vm_page_pagequeue_lockptr(m),
             ("%s: page %p migrated directly between queues", __func__, m));
-        vm_page_dequeue_locked(m);
+        KASSERT((m->aflags & PGA_DEQUEUE) != 0 ||
+            mtx_owned(vm_page_lockptr(m)),
+            ("%s: queued unlocked page %p", __func__, m));
+
+        if ((m->aflags & PGA_ENQUEUED) != 0) {
+                pq = vm_page_pagequeue(m);
+                TAILQ_REMOVE(&pq->pq_pl, m, plinks.q);
+                vm_pagequeue_cnt_dec(pq);
+        }
+        vm_page_dequeue_complete(m);
         mtx_unlock(lock);
 }
 
 /*
  * Schedule the given page for insertion into the specified page queue.
  * Physical insertion of the page may be deferred indefinitely.
  */
 static void

 {
 
         vm_page_assert_locked(m);
         KASSERT(m->queue != PQ_NONE,
             ("%s: page %p is not logically enqueued", __func__, m));
 
         if ((m->aflags & PGA_REQUEUE) == 0)
                 vm_page_aflag_set(m, PGA_REQUEUE);
-        vm_pqbatch_submit_page(m, m->queue);
+        vm_pqbatch_submit_page(m, atomic_load_8(&m->queue));
 }
 
 /*
  *      vm_page_activate:
  *
  *      Put the specified page on the active list (if appropriate).
  *      Ensure that act_count is at least ACT_INIT but do not otherwise
  *      mess with it.