[linux.git] / include / net / devlink.h

/*
 * include/net/devlink.h - Network physical device Netlink interface
 * Copyright (c) 2016 Mellanox Technologies. All rights reserved.
 * Copyright (c) 2016 Jiri Pirko <[email protected]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */
#ifndef _NET_DEVLINK_H_
#define _NET_DEVLINK_H_

#include <linux/device.h>
#include <linux/slab.h>
#include <linux/gfp.h>
#include <linux/list.h>
#include <linux/netdevice.h>
#include <net/net_namespace.h>
#include <uapi/linux/devlink.h>

struct devlink_ops;

struct devlink {
	struct list_head list;
	struct list_head port_list;
	struct list_head sb_list;
	const struct devlink_ops *ops;
	struct device *dev;
	possible_net_t _net;
	char priv[0] __aligned(NETDEV_ALIGN);
};

struct devlink_port {
	struct list_head list;
	struct devlink *devlink;
	unsigned index;
	bool registered;
	enum devlink_port_type type;
	enum devlink_port_type desired_type;
	void *type_dev;
	bool split;
	u32 split_group;
};

struct devlink_sb_pool_info {
	enum devlink_sb_pool_type pool_type;
	u32 size;
	enum devlink_sb_threshold_type threshold_type;
};

struct devlink_ops {
	size_t priv_size;
	int (*port_type_set)(struct devlink_port *devlink_port,
			     enum devlink_port_type port_type);
	int (*port_split)(struct devlink *devlink, unsigned int port_index,
			  unsigned int count);
	int (*port_unsplit)(struct devlink *devlink, unsigned int port_index);
	int (*sb_pool_get)(struct devlink *devlink, unsigned int sb_index,
			   u16 pool_index,
			   struct devlink_sb_pool_info *pool_info);
	int (*sb_pool_set)(struct devlink *devlink, unsigned int sb_index,
			   u16 pool_index, u32 size,
			   enum devlink_sb_threshold_type threshold_type);
	int (*sb_port_pool_get)(struct devlink_port *devlink_port,
				unsigned int sb_index, u16 pool_index,
				u32 *p_threshold);
	int (*sb_port_pool_set)(struct devlink_port *devlink_port,
				unsigned int sb_index, u16 pool_index,
				u32 threshold);
	int (*sb_tc_pool_bind_get)(struct devlink_port *devlink_port,
				   unsigned int sb_index,
				   u16 tc_index,
				   enum devlink_sb_pool_type pool_type,
				   u16 *p_pool_index, u32 *p_threshold);
	int (*sb_tc_pool_bind_set)(struct devlink_port *devlink_port,
				   unsigned int sb_index,
				   u16 tc_index,
				   enum devlink_sb_pool_type pool_type,
				   u16 pool_index, u32 threshold);
	int (*sb_occ_snapshot)(struct devlink *devlink,
			       unsigned int sb_index);
	int (*sb_occ_max_clear)(struct devlink *devlink,
				unsigned int sb_index);
	int (*sb_occ_port_pool_get)(struct devlink_port *devlink_port,
				    unsigned int sb_index, u16 pool_index,
				    u32 *p_cur, u32 *p_max);
	int (*sb_occ_tc_port_bind_get)(struct devlink_port *devlink_port,
				       unsigned int sb_index,
				       u16 tc_index,
				       enum devlink_sb_pool_type pool_type,
				       u32 *p_cur, u32 *p_max);
};

static inline void *devlink_priv(struct devlink *devlink)
{
	BUG_ON(!devlink);
	return &devlink->priv;
}

static inline struct devlink *priv_to_devlink(void *priv)
{
	BUG_ON(!priv);
	return container_of(priv, struct devlink, priv);
}

struct ib_device;

#if IS_ENABLED(CONFIG_NET_DEVLINK)

struct devlink *devlink_alloc(const struct devlink_ops *ops, size_t priv_size);
int devlink_register(struct devlink *devlink, struct device *dev);
void devlink_unregister(struct devlink *devlink);
void devlink_free(struct devlink *devlink);
int devlink_port_register(struct devlink *devlink,
			  struct devlink_port *devlink_port,
			  unsigned int port_index);
void devlink_port_unregister(struct devlink_port *devlink_port);
void devlink_port_type_eth_set(struct devlink_port *devlink_port,
			       struct net_device *netdev);
void devlink_port_type_ib_set(struct devlink_port *devlink_port,
			      struct ib_device *ibdev);
void devlink_port_type_clear(struct devlink_port *devlink_port);
void devlink_port_split_set(struct devlink_port *devlink_port,
			    u32 split_group);
int devlink_sb_register(struct devlink *devlink, unsigned int sb_index,
			u32 size, u16 ingress_pools_count,
			u16 egress_pools_count, u16 ingress_tc_count,
			u16 egress_tc_count);
void devlink_sb_unregister(struct devlink *devlink, unsigned int sb_index);

#else

static inline struct devlink *devlink_alloc(const struct devlink_ops *ops,
					    size_t priv_size)
{
	return kzalloc(sizeof(struct devlink) + priv_size, GFP_KERNEL);
}

static inline int devlink_register(struct devlink *devlink, struct device *dev)
{
	return 0;
}

static inline void devlink_unregister(struct devlink *devlink)
{
}

static inline void devlink_free(struct devlink *devlink)
{
	kfree(devlink);
}

static inline int devlink_port_register(struct devlink *devlink,
					struct devlink_port *devlink_port,
					unsigned int port_index)
{
	return 0;
}

static inline void devlink_port_unregister(struct devlink_port *devlink_port)
{
}

static inline void devlink_port_type_eth_set(struct devlink_port *devlink_port,
					     struct net_device *netdev)
{
}

static inline void devlink_port_type_ib_set(struct devlink_port *devlink_port,
					    struct ib_device *ibdev)
{
}

static inline void devlink_port_type_clear(struct devlink_port *devlink_port)
{
}

static inline void devlink_port_split_set(struct devlink_port *devlink_port,
					  u32 split_group)
{
}

static inline int devlink_sb_register(struct devlink *devlink,
				      unsigned int sb_index, u32 size,
				      u16 ingress_pools_count,
				      u16 egress_pools_count, u16 tc_count)
{
	return 0;
}

static inline void devlink_sb_unregister(struct devlink *devlink,
					 unsigned int sb_index)
{
}

#endif

#endif /* _NET_DEVLINK_H_ */
Commit	Line	Data
bfcd3a46 JP	1	/*
	2	* include/net/devlink.h - Network physical device Netlink interface
	3	* Copyright (c) 2016 Mellanox Technologies. All rights reserved.
	4	* Copyright (c) 2016 Jiri Pirko <[email protected]>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*/
	11	#ifndef _NET_DEVLINK_H_
	12	#define _NET_DEVLINK_H_
	13
	14	#include <linux/device.h>
	15	#include <linux/slab.h>
	16	#include <linux/gfp.h>
	17	#include <linux/list.h>
	18	#include <linux/netdevice.h>
	19	#include <net/net_namespace.h>
	20	#include <uapi/linux/devlink.h>
	21
	22	struct devlink_ops;
	23
	24	struct devlink {
	25	struct list_head list;
	26	struct list_head port_list;
bf797471	27	struct list_head sb_list;
bfcd3a46 JP	28	const struct devlink_ops *ops;
	29	struct device *dev;
	30	possible_net_t _net;
	31	char priv[0] __aligned(NETDEV_ALIGN);
	32	};
	33
	34	struct devlink_port {
	35	struct list_head list;
	36	struct devlink *devlink;
	37	unsigned index;
	38	bool registered;
	39	enum devlink_port_type type;
	40	enum devlink_port_type desired_type;
	41	void *type_dev;
	42	bool split;
	43	u32 split_group;
	44	};
	45
bf797471 JP	46	struct devlink_sb_pool_info {
	47	enum devlink_sb_pool_type pool_type;
	48	u32 size;
	49	enum devlink_sb_threshold_type threshold_type;
	50	};
	51
bfcd3a46 JP	52	struct devlink_ops {
	53	size_t priv_size;
	54	int (port_type_set)(struct devlink_port devlink_port,
	55	enum devlink_port_type port_type);
	56	int (port_split)(struct devlink devlink, unsigned int port_index,
	57	unsigned int count);
	58	int (port_unsplit)(struct devlink devlink, unsigned int port_index);
bf797471 JP	59	int (sb_pool_get)(struct devlink devlink, unsigned int sb_index,
	60	u16 pool_index,
	61	struct devlink_sb_pool_info *pool_info);
	62	int (sb_pool_set)(struct devlink devlink, unsigned int sb_index,
	63	u16 pool_index, u32 size,
	64	enum devlink_sb_threshold_type threshold_type);
	65	int (sb_port_pool_get)(struct devlink_port devlink_port,
	66	unsigned int sb_index, u16 pool_index,
	67	u32 *p_threshold);
	68	int (sb_port_pool_set)(struct devlink_port devlink_port,
	69	unsigned int sb_index, u16 pool_index,
	70	u32 threshold);
	71	int (sb_tc_pool_bind_get)(struct devlink_port devlink_port,
	72	unsigned int sb_index,
	73	u16 tc_index,
	74	enum devlink_sb_pool_type pool_type,
	75	u16 p_pool_index, u32 p_threshold);
	76	int (sb_tc_pool_bind_set)(struct devlink_port devlink_port,
	77	unsigned int sb_index,
	78	u16 tc_index,
	79	enum devlink_sb_pool_type pool_type,
	80	u16 pool_index, u32 threshold);
df38dafd JP	81	int (sb_occ_snapshot)(struct devlink devlink,
	82	unsigned int sb_index);
	83	int (sb_occ_max_clear)(struct devlink devlink,
	84	unsigned int sb_index);
	85	int (sb_occ_port_pool_get)(struct devlink_port devlink_port,
	86	unsigned int sb_index, u16 pool_index,
	87	u32 p_cur, u32 p_max);
	88	int (sb_occ_tc_port_bind_get)(struct devlink_port devlink_port,
	89	unsigned int sb_index,
	90	u16 tc_index,
	91	enum devlink_sb_pool_type pool_type,
	92	u32 p_cur, u32 p_max);
bfcd3a46 JP	93	};
	94
	95	static inline void devlink_priv(struct devlink devlink)
	96	{
	97	BUG_ON(!devlink);
	98	return &devlink->priv;
	99	}
	100
	101	static inline struct devlink priv_to_devlink(void priv)
	102	{
	103	BUG_ON(!priv);
	104	return container_of(priv, struct devlink, priv);
	105	}
	106
	107	struct ib_device;
	108
	109	#if IS_ENABLED(CONFIG_NET_DEVLINK)
	110
	111	struct devlink devlink_alloc(const struct devlink_ops ops, size_t priv_size);
	112	int devlink_register(struct devlink devlink, struct device dev);
	113	void devlink_unregister(struct devlink *devlink);
	114	void devlink_free(struct devlink *devlink);
	115	int devlink_port_register(struct devlink *devlink,
	116	struct devlink_port *devlink_port,
	117	unsigned int port_index);
	118	void devlink_port_unregister(struct devlink_port *devlink_port);
	119	void devlink_port_type_eth_set(struct devlink_port *devlink_port,
	120	struct net_device *netdev);
	121	void devlink_port_type_ib_set(struct devlink_port *devlink_port,
	122	struct ib_device *ibdev);
	123	void devlink_port_type_clear(struct devlink_port *devlink_port);
	124	void devlink_port_split_set(struct devlink_port *devlink_port,
	125	u32 split_group);
bf797471 JP	126	int devlink_sb_register(struct devlink *devlink, unsigned int sb_index,
	127	u32 size, u16 ingress_pools_count,
	128	u16 egress_pools_count, u16 ingress_tc_count,
	129	u16 egress_tc_count);
	130	void devlink_sb_unregister(struct devlink *devlink, unsigned int sb_index);
bfcd3a46 JP	131
	132	#else
	133
	134	static inline struct devlink devlink_alloc(const struct devlink_ops ops,
	135	size_t priv_size)
	136	{
	137	return kzalloc(sizeof(struct devlink) + priv_size, GFP_KERNEL);
	138	}
	139
	140	static inline int devlink_register(struct devlink devlink, struct device dev)
	141	{
	142	return 0;
	143	}
	144
	145	static inline void devlink_unregister(struct devlink *devlink)
	146	{
	147	}
	148
	149	static inline void devlink_free(struct devlink *devlink)
	150	{
	151	kfree(devlink);
	152	}
	153
	154	static inline int devlink_port_register(struct devlink *devlink,
	155	struct devlink_port *devlink_port,
	156	unsigned int port_index)
	157	{
	158	return 0;
	159	}
	160
	161	static inline void devlink_port_unregister(struct devlink_port *devlink_port)
	162	{
	163	}
	164
	165	static inline void devlink_port_type_eth_set(struct devlink_port *devlink_port,
	166	struct net_device *netdev)
	167	{
	168	}
	169
	170	static inline void devlink_port_type_ib_set(struct devlink_port *devlink_port,
	171	struct ib_device *ibdev)
	172	{
	173	}
	174
	175	static inline void devlink_port_type_clear(struct devlink_port *devlink_port)
	176	{
	177	}
	178
	179	static inline void devlink_port_split_set(struct devlink_port *devlink_port,
	180	u32 split_group)
	181	{
	182	}
	183
bf797471 JP	184	static inline int devlink_sb_register(struct devlink *devlink,
	185	unsigned int sb_index, u32 size,
	186	u16 ingress_pools_count,
	187	u16 egress_pools_count, u16 tc_count)
	188	{
	189	return 0;
	190	}
	191
	192	static inline void devlink_sb_unregister(struct devlink *devlink,
	193	unsigned int sb_index)
	194	{
	195	}
	196
bfcd3a46 JP	197	#endif
	198
	199	#endif /* _NET_DEVLINK_H_ */