linux-imx

#include <linux/module.h>

#include <linux/sock_diag.h>

#include <linux/net.h>

#include <linux/netdevice.h>

#include <linux/packet_diag.h>

#include <linux/percpu.h>

#include <net/net_namespace.h>

#include <net/sock.h>

​

#include "internal.h"

​

static int pdiag_put_info(const struct packet_sock *po, struct sk_buff *nlskb)

{

    struct packet_diag_info pinfo;

​

    pinfo.pdi_index = po->ifindex;

    pinfo.pdi_version = po->tp_version;

    pinfo.pdi_reserve = po->tp_reserve;

    pinfo.pdi_copy_thresh = po->copy_thresh;

    pinfo.pdi_tstamp = po->tp_tstamp;

​

    pinfo.pdi_flags = 0;

    if (po->running)

        pinfo.pdi_flags |= PDI_RUNNING;

    if (po->auxdata)

        pinfo.pdi_flags |= PDI_AUXDATA;

    if (po->origdev)

        pinfo.pdi_flags |= PDI_ORIGDEV;

    if (po->has_vnet_hdr)

        pinfo.pdi_flags |= PDI_VNETHDR;

    if (po->tp_loss)

        pinfo.pdi_flags |= PDI_LOSS;

​

    return nla_put(nlskb, PACKET_DIAG_INFO, sizeof(pinfo), &pinfo);

}

​

static int pdiag_put_mclist(const struct packet_sock *po, struct sk_buff *nlskb)

{

    struct nlattr *mca;

    struct packet_mclist *ml;

​

    mca = nla_nest_start(nlskb, PACKET_DIAG_MCLIST);

    if (!mca)

        return -EMSGSIZE;

​

    rtnl_lock();

    for (ml = po->mclist; ml; ml = ml->next) {

        struct packet_diag_mclist *dml;

​

        dml = nla_reserve_nohdr(nlskb, sizeof(*dml));

        if (!dml) {

            rtnl_unlock();

            nla_nest_cancel(nlskb, mca);

            return -EMSGSIZE;

        }

​

        dml->pdmc_index = ml->ifindex;

        dml->pdmc_type = ml->type;

        dml->pdmc_alen = ml->alen;

        dml->pdmc_count = ml->count;

        BUILD_BUG_ON(sizeof(dml->pdmc_addr) != sizeof(ml->addr));

        memcpy(dml->pdmc_addr, ml->addr, sizeof(ml->addr));

    }

​

    rtnl_unlock();

    nla_nest_end(nlskb, mca);

​

    return 0;

}

​

static int pdiag_put_ring(struct packet_ring_buffer *ring, int ver, int nl_type,

        struct sk_buff *nlskb)

{

    struct packet_diag_ring pdr;

​

    if (!ring->pg_vec)

        return 0;

​

    pdr.pdr_block_size = ring->pg_vec_pages << PAGE_SHIFT;

    pdr.pdr_block_nr = ring->pg_vec_len;

    pdr.pdr_frame_size = ring->frame_size;

    pdr.pdr_frame_nr = ring->frame_max + 1;

​

    if (ver > TPACKET_V2) {

        pdr.pdr_retire_tmo = ring->prb_bdqc.retire_blk_tov;

        pdr.pdr_sizeof_priv = ring->prb_bdqc.blk_sizeof_priv;

        pdr.pdr_features = ring->prb_bdqc.feature_req_word;

    } else {

        pdr.pdr_retire_tmo = 0;

        pdr.pdr_sizeof_priv = 0;

        pdr.pdr_features = 0;

    }