include/net/mctp.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Management Component Transport Protocol (MCTP)
   4  *
   5  * Copyright (c) 2021 Code Construct
   6  * Copyright (c) 2021 Google
   7  */
   8
   9 #ifndef __NET_MCTP_H
  10 #define __NET_MCTP_H
  11
  12 #include <linux/bits.h>
  13 #include <linux/mctp.h>
  14 #include <linux/netdevice.h>
  15 #include <net/net_namespace.h>
  16 #include <net/sock.h>
  17
  18 /* MCTP packet definitions */
  19 struct mctp_hdr {
  20         u8      ver;
  21         u8      dest;
  22         u8      src;
  23         u8      flags_seq_tag;
  24 };
  25
  26 #define MCTP_VER_MIN    1
  27 #define MCTP_VER_MAX    1
  28
  29 /* Definitions for flags_seq_tag field */
  30 #define MCTP_HDR_FLAG_SOM       BIT(7)
  31 #define MCTP_HDR_FLAG_EOM       BIT(6)
  32 #define MCTP_HDR_FLAG_TO        BIT(3)
  33 #define MCTP_HDR_FLAGS          GENMASK(5, 3)
  34 #define MCTP_HDR_SEQ_SHIFT      4
  35 #define MCTP_HDR_SEQ_MASK       GENMASK(1, 0)
  36 #define MCTP_HDR_TAG_SHIFT      0
  37 #define MCTP_HDR_TAG_MASK       GENMASK(2, 0)
  38
  39 #define MCTP_INITIAL_DEFAULT_NET        1
  40
  41 static inline bool mctp_address_unicast(mctp_eid_t eid)
  42 {
  43         return eid >= 8 && eid < 255;
  44 }
  45
  46 static inline bool mctp_address_broadcast(mctp_eid_t eid)
  47 {
  48         return eid == 255;
  49 }
  50
  51 static inline bool mctp_address_null(mctp_eid_t eid)
  52 {
  53         return eid == 0;
  54 }
  55
  56 static inline bool mctp_address_matches(mctp_eid_t match, mctp_eid_t eid)
  57 {
  58         return match == eid || match == MCTP_ADDR_ANY;
  59 }
  60
  61 static inline struct mctp_hdr *mctp_hdr(struct sk_buff *skb)
  62 {
  63         return (struct mctp_hdr *)skb_network_header(skb);
  64 }
  65
  66 /* socket implementation */
  67 struct mctp_sock {
  68         struct sock     sk;
  69
  70         /* bind() params */
  71         unsigned int    bind_net;
  72         mctp_eid_t      bind_addr;
  73         __u8            bind_type;
  74
  75         /* sendmsg()/recvmsg() uses struct sockaddr_mctp_ext */
  76         bool            addr_ext;
  77
  78         /* list of mctp_sk_key, for incoming tag lookup. updates protected
  79          * by sk->net->keys_lock
  80          */
  81         struct hlist_head keys;
  82
  83         /* mechanism for expiring allocated keys; will release an allocated
  84          * tag, and any netdev state for a request/response pairing
  85          */
  86         struct timer_list key_expiry;
  87 };
  88
  89 /* Key for matching incoming packets to sockets or reassembly contexts.
  90  * Packets are matched on (peer EID, local EID, tag).
  91  *
  92  * Lifetime / locking requirements:
  93  *
  94  *  - individual key data (ie, the struct itself) is protected by key->lock;
  95  *    changes must be made with that lock held.
  96  *
  97  *  - the lookup fields: peer_addr, local_addr and tag are set before the
  98  *    key is added to lookup lists, and never updated.
  99  *
 100  *  - A ref to the key must be held (throuh key->refs) if a pointer to the
 101  *    key is to be accessed after key->lock is released.
 102  *
 103  *  - a mctp_sk_key contains a reference to a struct sock; this is valid
 104  *    for the life of the key. On sock destruction (through unhash), the key is
 105  *    removed from lists (see below), and marked invalid.
 106  *
 107  * - these mctp_sk_keys appear on two lists:
 108  *     1) the struct mctp_sock->keys list
 109  *     2) the struct netns_mctp->keys list
 110  *
 111  *   presences on these lists requires a (single) refcount to be held; both
 112  *   lists are updated as a single operation.
 113  *
 114  *   Updates and lookups in either list are performed under the
 115  *   netns_mctp->keys lock. Lookup functions will need to lock the key and
 116  *   take a reference before unlocking the keys_lock. Consequently, the list's
 117  *   keys_lock *cannot* be acquired with the individual key->lock held.
 118  *
 119  * - a key may have a sk_buff attached as part of an in-progress message
 120  *   reassembly (->reasm_head). The reasm data is protected by the individual
 121  *   key->lock.
 122  *
 123  * - there are two destruction paths for a mctp_sk_key:
 124  *
 125  *    - through socket unhash (see mctp_sk_unhash). This performs the list
 126  *      removal under keys_lock.
 127  *
 128  *    - where a key is established to receive a reply message: after receiving
 129  *      the (complete) reply, or during reassembly errors. Here, we clean up
 130  *      the reassembly context (marking reasm_dead, to prevent another from
 131  *      starting), and remove the socket from the netns & socket lists.
 132  *
 133  *    - through an expiry timeout, on a per-socket timer
 134  */
 135 struct mctp_sk_key {
 136         unsigned int    net;
 137         mctp_eid_t      peer_addr;
 138         mctp_eid_t      local_addr; /* MCTP_ADDR_ANY for local owned tags */
 139         __u8            tag; /* incoming tag match; invert TO for local */
 140
 141         /* we hold a ref to sk when set */
 142         struct sock     *sk;
 143
 144         /* routing lookup list */
 145         struct hlist_node hlist;
 146
 147         /* per-socket list */
 148         struct hlist_node sklist;
 149
 150         /* lock protects against concurrent updates to the reassembly and
 151          * expiry data below.
 152          */
 153         spinlock_t      lock;
 154
 155         /* Keys are referenced during the output path, which may sleep */
 156         refcount_t      refs;
 157
 158         /* incoming fragment reassembly context */
 159         struct sk_buff  *reasm_head;
 160         struct sk_buff  **reasm_tailp;
 161         bool            reasm_dead;
 162         u8              last_seq;
 163
 164         /* key validity */
 165         bool            valid;
 166
 167         /* expiry timeout; valid (above) cleared on expiry */
 168         unsigned long   expiry;
 169
 170         /* free to use for device flow state tracking. Initialised to
 171          * zero on initial key creation
 172          */
 173         unsigned long   dev_flow_state;
 174         struct mctp_dev *dev;
 175
 176         /* a tag allocated with SIOCMCTPALLOCTAG ioctl will not expire
 177          * automatically on timeout or response, instead SIOCMCTPDROPTAG
 178          * is used.
 179          */
 180         bool            manual_alloc;
 181 };
 182
 183 struct mctp_skb_cb {
 184         unsigned int    magic;
 185         unsigned int    net;
 186         int             ifindex; /* extended/direct addressing if set */
 187         mctp_eid_t      src;
 188         unsigned char   halen;
 189         unsigned char   haddr[MAX_ADDR_LEN];
 190 };
 191
 192 /* skb control-block accessors with a little extra debugging for initial
 193  * development.
 194  *
 195  * TODO: remove checks & mctp_skb_cb->magic; replace callers of __mctp_cb
 196  * with mctp_cb().
 197  *
 198  * __mctp_cb() is only for the initial ingress code; we should see ->magic set
 199  * at all times after this.
 200  */
 201 static inline struct mctp_skb_cb *__mctp_cb(struct sk_buff *skb)
 202 {
 203         struct mctp_skb_cb *cb = (void *)skb->cb;
 204
 205         cb->magic = 0x4d435450;
 206         return cb;
 207 }
 208
 209 static inline struct mctp_skb_cb *mctp_cb(struct sk_buff *skb)
 210 {
 211         struct mctp_skb_cb *cb = (void *)skb->cb;
 212
 213         BUILD_BUG_ON(sizeof(struct mctp_skb_cb) > sizeof(skb->cb));
 214         WARN_ON(cb->magic != 0x4d435450);
 215         return (void *)(skb->cb);
 216 }
 217
 218 /* If CONFIG_MCTP_FLOWS, we may add one of these as a SKB extension,
 219  * indicating the flow to the device driver.
 220  */
 221 struct mctp_flow {
 222         struct mctp_sk_key *key;
 223 };
 224
 225 /* Route definition.
 226  *
 227  * These are held in the pernet->mctp.routes list, with RCU protection for
 228  * removed routes. We hold a reference to the netdev; routes need to be
 229  * dropped on NETDEV_UNREGISTER events.
 230  *
 231  * Updates to the route table are performed under rtnl; all reads under RCU,
 232  * so routes cannot be referenced over a RCU grace period. Specifically: A
 233  * caller cannot block between mctp_route_lookup and mctp_route_release()
 234  */
 235 struct mctp_route {
 236         mctp_eid_t              min, max;
 237
 238         unsigned char           type;
 239         unsigned int            mtu;
 240         struct mctp_dev         *dev;
 241         int                     (*output)(struct mctp_route *route,
 242                                           struct sk_buff *skb);
 243
 244         struct list_head        list;
 245         refcount_t              refs;
 246         struct rcu_head         rcu;
 247 };
 248
 249 /* route interfaces */
 250 struct mctp_route *mctp_route_lookup(struct net *net, unsigned int dnet,
 251                                      mctp_eid_t daddr);
 252
 253 /* always takes ownership of skb */
 254 int mctp_local_output(struct sock *sk, struct mctp_route *rt,
 255                       struct sk_buff *skb, mctp_eid_t daddr, u8 req_tag);
 256
 257 void mctp_key_unref(struct mctp_sk_key *key);
 258 struct mctp_sk_key *mctp_alloc_local_tag(struct mctp_sock *msk,
 259                                          unsigned int netid,
 260                                          mctp_eid_t local, mctp_eid_t peer,
 261                                          bool manual, u8 *tagp);
 262
 263 /* routing <--> device interface */
 264 unsigned int mctp_default_net(struct net *net);
 265 int mctp_default_net_set(struct net *net, unsigned int index);
 266 int mctp_route_add_local(struct mctp_dev *mdev, mctp_eid_t addr);
 267 int mctp_route_remove_local(struct mctp_dev *mdev, mctp_eid_t addr);
 268 void mctp_route_remove_dev(struct mctp_dev *mdev);
 269
 270 /* neighbour definitions */
 271 enum mctp_neigh_source {
 272         MCTP_NEIGH_STATIC,
 273         MCTP_NEIGH_DISCOVER,
 274 };
 275
 276 struct mctp_neigh {
 277         struct mctp_dev         *dev;
 278         mctp_eid_t              eid;
 279         enum mctp_neigh_source  source;
 280
 281         unsigned char           ha[MAX_ADDR_LEN];
 282
 283         struct list_head        list;
 284         struct rcu_head         rcu;
 285 };
 286
 287 int mctp_neigh_init(void);
 288 void mctp_neigh_exit(void);
 289
 290 // ret_hwaddr may be NULL, otherwise must have space for MAX_ADDR_LEN
 291 int mctp_neigh_lookup(struct mctp_dev *dev, mctp_eid_t eid,
 292                       void *ret_hwaddr);
 293 void mctp_neigh_remove_dev(struct mctp_dev *mdev);
 294
 295 int mctp_routes_init(void);
 296 void mctp_routes_exit(void);
 297
 298 int mctp_device_init(void);
 299 void mctp_device_exit(void);
 300
 301 /* MCTP IDs and Codes from DMTF specification
 302  * "DSP0239 Management Component Transport Protocol (MCTP) IDs and Codes"
 303  * https://www.dmtf.org/sites/default/files/standards/documents/DSP0239_1.11.1.pdf
 304  */
 305 enum mctp_phys_binding {
 306         MCTP_PHYS_BINDING_UNSPEC        = 0x00,
 307         MCTP_PHYS_BINDING_SMBUS         = 0x01,
 308         MCTP_PHYS_BINDING_PCIE_VDM      = 0x02,
 309         MCTP_PHYS_BINDING_USB           = 0x03,
 310         MCTP_PHYS_BINDING_KCS           = 0x04,
 311         MCTP_PHYS_BINDING_SERIAL        = 0x05,
 312         MCTP_PHYS_BINDING_I3C           = 0x06,
 313         MCTP_PHYS_BINDING_MMBI          = 0x07,
 314         MCTP_PHYS_BINDING_PCC           = 0x08,
 315         MCTP_PHYS_BINDING_UCIE          = 0x09,
 316         MCTP_PHYS_BINDING_VENDOR        = 0xFF,
 317 };
 318
 319 #endif /* __NET_MCTP_H */