work.c

Go to the documentation of this file.

/*
 * mac80211 work implementation
 *
 * Copyright 2003-2008, Jouni Malinen <j@w1.fi>
 * Copyright 2004, Instant802 Networks, Inc.
 * Copyright 2005, Devicescape Software, Inc.
 * Copyright 2006-2007  Jiri Benc <jbenc@suse.cz>
 * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
 * Copyright 2009, Johannes Berg <johannes@sipsolutions.net>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/delay.h>
#include <linux/if_ether.h>
#include <linux/skbuff.h>
#include <linux/if_arp.h>
#include <linux/etherdevice.h>
#include <linux/crc32.h>
#include <linux/slab.h>
#include <net/mac80211.h>
#include <asm/unaligned.h>

#include "ieee80211_i.h"
#include "rate.h"
#include "driver-ops.h"

enum work_action {
        WORK_ACT_NONE,
        WORK_ACT_TIMEOUT,
};


/* utils */
static inline void ASSERT_WORK_MTX(struct ieee80211_local *local)
{
        lockdep_assert_held(&local->mtx);
}

/*
 * We can have multiple work items (and connection probing)
 * scheduling this timer, but we need to take care to only
 * reschedule it when it should fire _earlier_ than it was
 * asked for before, or if it's not pending right now. This
 * function ensures that. Note that it then is required to
 * run this function for all timeouts after the first one
 * has happened -- the work that runs from this timer will
 * do that.
 */
static void run_again(struct ieee80211_local *local,
                      unsigned long timeout)
{
        ASSERT_WORK_MTX(local);

        if (!timer_pending(&local->work_timer) ||
            time_before(timeout, local->work_timer.expires))
                mod_timer(&local->work_timer, timeout);
}

void free_work(struct ieee80211_work *wk)
{
        kfree_rcu(wk, rcu_head);
}

static enum work_action __must_check
ieee80211_remain_on_channel_timeout(struct ieee80211_work *wk)
{
        /*
         * First time we run, do nothing -- the generic code will
         * have switched to the right channel etc.
         */
        if (!wk->started) {
                wk->timeout = jiffies + msecs_to_jiffies(wk->remain.duration);

                cfg80211_ready_on_channel(wk->sdata->dev, (unsigned long) wk,
                                          wk->chan, wk->chan_type,
                                          wk->remain.duration, GFP_KERNEL);

                return WORK_ACT_NONE;
        }

        return WORK_ACT_TIMEOUT;
}

static enum work_action __must_check
ieee80211_offchannel_tx(struct ieee80211_work *wk)
{
        if (!wk->started) {
                wk->timeout = jiffies + msecs_to_jiffies(wk->offchan_tx.wait);

                /*
                 * After this, offchan_tx.frame remains but now is no
                 * longer a valid pointer -- we still need it as the
                 * cookie for canceling this work/status matching.
                 */
                ieee80211_tx_skb(wk->sdata, wk->offchan_tx.frame);

                return WORK_ACT_NONE;
        }

        return WORK_ACT_TIMEOUT;
}

static void ieee80211_work_timer(unsigned long data)
{
        struct ieee80211_local *local = (void *) data;

        if (local->quiescing)
                return;

        ieee80211_queue_work(&local->hw, &local->work_work);
}

static void ieee80211_work_work(struct work_struct *work)
{
        struct ieee80211_local *local =
                container_of(work, struct ieee80211_local, work_work);
        struct ieee80211_work *wk, *tmp;
        LIST_HEAD(free_work);
        enum work_action rma;
        bool remain_off_channel = false;

        /*
         * ieee80211_queue_work() should have picked up most cases,
         * here we'll pick the rest.
         */
        if (WARN(local->suspended, "work scheduled while going to suspend\n"))
                return;

        mutex_lock(&local->mtx);

        if (local->scanning) {
                mutex_unlock(&local->mtx);
                return;
        }

        ieee80211_recalc_idle(local);

        list_for_each_entry_safe(wk, tmp, &local->work_list, list) {
                bool started = wk->started;

                /* mark work as started if it's on the current off-channel */
                if (!started && local->tmp_channel &&
                    wk->chan == local->tmp_channel &&
                    wk->chan_type == local->tmp_channel_type) {
                        started = true;
                        wk->timeout = jiffies;
                }

                if (!started && !local->tmp_channel) {
                        ieee80211_offchannel_stop_vifs(local, true);

                        local->tmp_channel = wk->chan;
                        local->tmp_channel_type = wk->chan_type;

                        ieee80211_hw_config(local, 0);

                        started = true;
                        wk->timeout = jiffies;
                }

                /* don't try to work with items that aren't started */
                if (!started)
                        continue;

                if (time_is_after_jiffies(wk->timeout)) {
                        /*
                         * This work item isn't supposed to be worked on
                         * right now, but take care to adjust the timer
                         * properly.
                         */
                        run_again(local, wk->timeout);
                        continue;
                }

                switch (wk->type) {
                default:
                        WARN_ON(1);
                        /* nothing */
                        rma = WORK_ACT_NONE;
                        break;
                case IEEE80211_WORK_ABORT:
                        rma = WORK_ACT_TIMEOUT;
                        break;
                case IEEE80211_WORK_REMAIN_ON_CHANNEL:
                        rma = ieee80211_remain_on_channel_timeout(wk);
                        break;
                case IEEE80211_WORK_OFFCHANNEL_TX:
                        rma = ieee80211_offchannel_tx(wk);
                        break;
                }

                wk->started = started;

                switch (rma) {
                case WORK_ACT_NONE:
                        /* might have changed the timeout */
                        run_again(local, wk->timeout);
                        break;
                case WORK_ACT_TIMEOUT:
                        list_del_rcu(&wk->list);
                        synchronize_rcu();
                        list_add(&wk->list, &free_work);
                        break;
                default:
                        WARN(1, "unexpected: %d", rma);
                }
        }

        list_for_each_entry(wk, &local->work_list, list) {
                if (!wk->started)
                        continue;
                if (wk->chan != local->tmp_channel ||
                    wk->chan_type != local->tmp_channel_type)
                        continue;
                remain_off_channel = true;
        }

        if (!remain_off_channel && local->tmp_channel) {
                local->tmp_channel = NULL;
                ieee80211_hw_config(local, 0);

                ieee80211_offchannel_return(local, true);

                /* give connection some time to breathe */
                run_again(local, jiffies + HZ/2);
        }

        ieee80211_recalc_idle(local);
        ieee80211_run_deferred_scan(local);

        mutex_unlock(&local->mtx);

        list_for_each_entry_safe(wk, tmp, &free_work, list) {
                wk->done(wk, NULL);
                list_del(&wk->list);
                kfree(wk);
        }
}

void ieee80211_add_work(struct ieee80211_work *wk)
{
        struct ieee80211_local *local;

        if (WARN_ON(!wk->chan))
                return;

        if (WARN_ON(!wk->sdata))
                return;

        if (WARN_ON(!wk->done))
                return;

        if (WARN_ON(!ieee80211_sdata_running(wk->sdata)))
                return;

        wk->started = false;

        local = wk->sdata->local;
        mutex_lock(&local->mtx);
        list_add_tail(&wk->list, &local->work_list);
        mutex_unlock(&local->mtx);

        ieee80211_queue_work(&local->hw, &local->work_work);
}

void ieee80211_work_init(struct ieee80211_local *local)
{
        INIT_LIST_HEAD(&local->work_list);
        setup_timer(&local->work_timer, ieee80211_work_timer,
                    (unsigned long)local);
        INIT_WORK(&local->work_work, ieee80211_work_work);
}

void ieee80211_work_purge(struct ieee80211_sub_if_data *sdata)
{
        struct ieee80211_local *local = sdata->local;
        struct ieee80211_work *wk;
        bool cleanup = false;

        mutex_lock(&local->mtx);
        list_for_each_entry(wk, &local->work_list, list) {
                if (wk->sdata != sdata)
                        continue;
                cleanup = true;
                wk->type = IEEE80211_WORK_ABORT;
                wk->started = true;
                wk->timeout = jiffies;
        }
        mutex_unlock(&local->mtx);

        /* run cleanups etc. */
        if (cleanup)
                ieee80211_work_work(&local->work_work);

        mutex_lock(&local->mtx);
        list_for_each_entry(wk, &local->work_list, list) {
                if (wk->sdata != sdata)
                        continue;
                WARN_ON(1);
                break;
        }
        mutex_unlock(&local->mtx);
}

static enum work_done_result ieee80211_remain_done(struct ieee80211_work *wk,
                                                   struct sk_buff *skb)
{
        /*
         * We are done serving the remain-on-channel command.
         */
        cfg80211_remain_on_channel_expired(wk->sdata->dev, (unsigned long) wk,
                                           wk->chan, wk->chan_type,
                                           GFP_KERNEL);

        return WORK_DONE_DESTROY;
}

int ieee80211_wk_remain_on_channel(struct ieee80211_sub_if_data *sdata,
                                   struct ieee80211_channel *chan,
                                   enum nl80211_channel_type channel_type,
                                   unsigned int duration, u64 *cookie)
{
        struct ieee80211_work *wk;

        wk = kzalloc(sizeof(*wk), GFP_KERNEL);
        if (!wk)
                return -ENOMEM;

        wk->type = IEEE80211_WORK_REMAIN_ON_CHANNEL;
        wk->chan = chan;
        wk->chan_type = channel_type;
        wk->sdata = sdata;
        wk->done = ieee80211_remain_done;

        wk->remain.duration = duration;

        *cookie = (unsigned long) wk;

        ieee80211_add_work(wk);

        return 0;
}

int ieee80211_wk_cancel_remain_on_channel(struct ieee80211_sub_if_data *sdata,
                                          u64 cookie)
{
        struct ieee80211_local *local = sdata->local;
        struct ieee80211_work *wk, *tmp;
        bool found = false;

        mutex_lock(&local->mtx);
        list_for_each_entry_safe(wk, tmp, &local->work_list, list) {
                if ((unsigned long) wk == cookie) {
                        wk->timeout = jiffies;
                        found = true;
                        break;
                }
        }
        mutex_unlock(&local->mtx);

        if (!found)
                return -ENOENT;

        ieee80211_queue_work(&local->hw, &local->work_work);

        return 0;
}