cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

ife.c (4434B)

      1/*
      2 * net/ife/ife.c - Inter-FE protocol based on ForCES WG InterFE LFB
      3 * Copyright (c) 2015 Jamal Hadi Salim <jhs@mojatatu.com>
      4 * Copyright (c) 2017 Yotam Gigi <yotamg@mellanox.com>
      5 *
      6 * Refer to: draft-ietf-forces-interfelfb-03 and netdev01 paper:
      7 * "Distributing Linux Traffic Control Classifier-Action Subsystem"
      8 * Authors: Jamal Hadi Salim and Damascene M. Joachimpillai
      9 *
     10 * This program is free software; you can redistribute it and/or modify
     11 * it under the terms of the GNU General Public License as published by
     12 * the Free Software Foundation.
     13 */
     14
     15#include <linux/types.h>
     16#include <linux/kernel.h>
     17#include <linux/string.h>
     18#include <linux/errno.h>
     19#include <linux/skbuff.h>
     20#include <linux/rtnetlink.h>
     21#include <linux/module.h>
     22#include <linux/init.h>
     23#include <net/net_namespace.h>
     24#include <net/netlink.h>
     25#include <net/pkt_sched.h>
     26#include <linux/etherdevice.h>
     27#include <net/ife.h>
     28
     29struct ifeheadr {
     30	__be16 metalen;
     31	u8 tlv_data[];
     32};
     33
     34void *ife_encode(struct sk_buff *skb, u16 metalen)
     35{
     36	/* OUTERHDR:TOTMETALEN:{TLVHDR:Metadatum:TLVHDR..}:ORIGDATA
     37	 * where ORIGDATA = original ethernet header ...
     38	 */
     39	int hdrm = metalen + IFE_METAHDRLEN;
     40	int total_push = hdrm + skb->dev->hard_header_len;
     41	struct ifeheadr *ifehdr;
     42	struct ethhdr *iethh;	/* inner ether header */
     43	int skboff = 0;
     44	int err;
     45
     46	err = skb_cow_head(skb, total_push);
     47	if (unlikely(err))
     48		return NULL;
     49
     50	iethh = (struct ethhdr *) skb->data;
     51
     52	__skb_push(skb, total_push);
     53	memcpy(skb->data, iethh, skb->dev->hard_header_len);
     54	skb_reset_mac_header(skb);
     55	skboff += skb->dev->hard_header_len;
     56
     57	/* total metadata length */
     58	ifehdr = (struct ifeheadr *) (skb->data + skboff);
     59	metalen += IFE_METAHDRLEN;
     60	ifehdr->metalen = htons(metalen);
     61
     62	return ifehdr->tlv_data;
     63}
     64EXPORT_SYMBOL_GPL(ife_encode);
     65
     66void *ife_decode(struct sk_buff *skb, u16 *metalen)
     67{
     68	struct ifeheadr *ifehdr;
     69	int total_pull;
     70	u16 ifehdrln;
     71
     72	if (!pskb_may_pull(skb, skb->dev->hard_header_len + IFE_METAHDRLEN))
     73		return NULL;
     74
     75	ifehdr = (struct ifeheadr *) (skb->data + skb->dev->hard_header_len);
     76	ifehdrln = ntohs(ifehdr->metalen);
     77	total_pull = skb->dev->hard_header_len + ifehdrln;
     78
     79	if (unlikely(ifehdrln < 2))
     80		return NULL;
     81
     82	if (unlikely(!pskb_may_pull(skb, total_pull)))
     83		return NULL;
     84
     85	skb_set_mac_header(skb, total_pull);
     86	__skb_pull(skb, total_pull);
     87	*metalen = ifehdrln - IFE_METAHDRLEN;
     88
     89	return &ifehdr->tlv_data;
     90}
     91EXPORT_SYMBOL_GPL(ife_decode);
     92
     93struct meta_tlvhdr {
     94	__be16 type;
     95	__be16 len;
     96};
     97
     98static bool __ife_tlv_meta_valid(const unsigned char *skbdata,
     99				 const unsigned char *ifehdr_end)
    100{
    101	const struct meta_tlvhdr *tlv;
    102	u16 tlvlen;
    103
    104	if (unlikely(skbdata + sizeof(*tlv) > ifehdr_end))
    105		return false;
    106
    107	tlv = (const struct meta_tlvhdr *)skbdata;
    108	tlvlen = ntohs(tlv->len);
    109
    110	/* tlv length field is inc header, check on minimum */
    111	if (tlvlen < NLA_HDRLEN)
    112		return false;
    113
    114	/* overflow by NLA_ALIGN check */
    115	if (NLA_ALIGN(tlvlen) < tlvlen)
    116		return false;
    117
    118	if (unlikely(skbdata + NLA_ALIGN(tlvlen) > ifehdr_end))
    119		return false;
    120
    121	return true;
    122}
    123
    124/* Caller takes care of presenting data in network order
    125 */
    126void *ife_tlv_meta_decode(void *skbdata, const void *ifehdr_end, u16 *attrtype,
    127			  u16 *dlen, u16 *totlen)
    128{
    129	struct meta_tlvhdr *tlv;
    130
    131	if (!__ife_tlv_meta_valid(skbdata, ifehdr_end))
    132		return NULL;
    133
    134	tlv = (struct meta_tlvhdr *)skbdata;
    135	*dlen = ntohs(tlv->len) - NLA_HDRLEN;
    136	*attrtype = ntohs(tlv->type);
    137
    138	if (totlen)
    139		*totlen = nla_total_size(*dlen);
    140
    141	return skbdata + sizeof(struct meta_tlvhdr);
    142}
    143EXPORT_SYMBOL_GPL(ife_tlv_meta_decode);
    144
    145void *ife_tlv_meta_next(void *skbdata)
    146{
    147	struct meta_tlvhdr *tlv = (struct meta_tlvhdr *) skbdata;
    148	u16 tlvlen = ntohs(tlv->len);
    149
    150	tlvlen = NLA_ALIGN(tlvlen);
    151
    152	return skbdata + tlvlen;
    153}
    154EXPORT_SYMBOL_GPL(ife_tlv_meta_next);
    155
    156/* Caller takes care of presenting data in network order
    157 */
    158int ife_tlv_meta_encode(void *skbdata, u16 attrtype, u16 dlen, const void *dval)
    159{
    160	__be32 *tlv = (__be32 *) (skbdata);
    161	u16 totlen = nla_total_size(dlen);	/*alignment + hdr */
    162	char *dptr = (char *) tlv + NLA_HDRLEN;
    163	u32 htlv = attrtype << 16 | (dlen + NLA_HDRLEN);
    164
    165	*tlv = htonl(htlv);
    166	memset(dptr, 0, totlen - NLA_HDRLEN);
    167	memcpy(dptr, dval, dlen);
    168
    169	return totlen;
    170}
    171EXPORT_SYMBOL_GPL(ife_tlv_meta_encode);
    172
    173MODULE_AUTHOR("Jamal Hadi Salim <jhs@mojatatu.com>");
    174MODULE_AUTHOR("Yotam Gigi <yotam.gi@gmail.com>");
    175MODULE_DESCRIPTION("Inter-FE LFB action");
    176MODULE_LICENSE("GPL");