linux-imx

// SPDX-License-Identifier: GPL-2.0

/* Copyright (C) 2013-2019  B.A.T.M.A.N. contributors:

 *

 * Martin Hundebøll <martin@hundeboll.net>

 */

​

#include "fragmentation.h"

#include "main.h"

​

#include <linux/atomic.h>

#include <linux/byteorder/generic.h>

#include <linux/errno.h>

#include <linux/etherdevice.h>

#include <linux/gfp.h>

#include <linux/if_ether.h>

#include <linux/jiffies.h>

#include <linux/kernel.h>

#include <linux/lockdep.h>

#include <linux/netdevice.h>

#include <linux/skbuff.h>

#include <linux/slab.h>

#include <linux/spinlock.h>

#include <linux/string.h>

#include <uapi/linux/batadv_packet.h>

​

#include "hard-interface.h"

#include "originator.h"

#include "routing.h"

#include "send.h"

#include "soft-interface.h"

​

/**

 * batadv_frag_clear_chain() - delete entries in the fragment buffer chain

 * @head: head of chain with entries.

 * @dropped: whether the chain is cleared because all fragments are dropped

 *

 * Free fragments in the passed hlist. Should be called with appropriate lock.

 */

static void batadv_frag_clear_chain(struct hlist_head *head, bool dropped)

{

    struct batadv_frag_list_entry *entry;

    struct hlist_node *node;

​

    hlist_for_each_entry_safe(entry, node, head, list) {

        hlist_del(&entry->list);

​

        if (dropped)

            kfree_skb(entry->skb);

        else

            consume_skb(entry->skb);

​

        kfree(entry);

    }

}

​

/**

 * batadv_frag_purge_orig() - free fragments associated to an orig

 * @orig_node: originator to free fragments from

 * @check_cb: optional function to tell if an entry should be purged

 */

void batadv_frag_purge_orig(struct batadv_orig_node *orig_node,

                bool (*check_cb)(struct batadv_frag_table_entry *))

{

    struct batadv_frag_table_entry *chain;

    u8 i;

​

    for (i = 0; i < BATADV_FRAG_BUFFER_COUNT; i++) {

        chain = &orig_node->fragments[i];

        spin_lock_bh(&chain->lock);

​

        if (!check_cb || check_cb(chain)) {

            batadv_frag_clear_chain(&chain->fragment_list, true);

            chain->size = 0;

        }

​

        spin_unlock_bh(&chain->lock);

    }

}

​

/**

 * batadv_frag_size_limit() - maximum possible size of packet to be fragmented

 *

 * Return: the maximum size of payload that can be fragmented.

 */

static int batadv_frag_size_limit(void)

{

    int limit = BATADV_FRAG_MAX_FRAG_SIZE;

​

    limit -= sizeof(struct batadv_frag_packet);

    limit *= BATADV_FRAG_MAX_FRAGMENTS;

​

    return limit;