[mirror_ubuntu-artful-kernel.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 <jiri@mellanox.com>
 *
 * 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;
	struct list_head dpipe_table_list;
	struct devlink_dpipe_headers *dpipe_headers;
	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_dpipe_field - dpipe field object
 * @name: field name
 * @id: index inside the headers field array
 * @bitwidth: bitwidth
 * @mapping_type: mapping type
 */
struct devlink_dpipe_field {
	const char *name;
	unsigned int id;
	unsigned int bitwidth;
	enum devlink_dpipe_field_mapping_type mapping_type;
};

/**
 * struct devlink_dpipe_header - dpipe header object
 * @name: header name
 * @id: index, global/local detrmined by global bit
 * @fields: fields
 * @fields_count: number of fields
 * @global: indicates if header is shared like most protocol header
 *	    or driver specific
 */
struct devlink_dpipe_header {
	const char *name;
	unsigned int id;
	struct devlink_dpipe_field *fields;
	unsigned int fields_count;
	bool global;
};

/**
 * struct devlink_dpipe_match - represents match operation
 * @type: type of match
 * @header_index: header index (packets can have several headers of same
 *		  type like in case of tunnels)
 * @header: header
 * @fieled_id: field index
 */
struct devlink_dpipe_match {
	enum devlink_dpipe_match_type type;
	unsigned int header_index;
	struct devlink_dpipe_header *header;
	unsigned int field_id;
};

/**
 * struct devlink_dpipe_action - represents action operation
 * @type: type of action
 * @header_index: header index (packets can have several headers of same
 *		  type like in case of tunnels)
 * @header: header
 * @fieled_id: field index
 */
struct devlink_dpipe_action {
	enum devlink_dpipe_action_type type;
	unsigned int header_index;
	struct devlink_dpipe_header *header;
	unsigned int field_id;
};

/**
 * struct devlink_dpipe_value - represents value of match/action
 * @action: action
 * @match: match
 * @mapping_value: in case the field has some mapping this value
 *                 specified the mapping value
 * @mapping_valid: specify if mapping value is valid
 * @value_size: value size
 * @value: value
 * @mask: bit mask
 */
struct devlink_dpipe_value {
	union {
		struct devlink_dpipe_action *action;
		struct devlink_dpipe_match *match;
	};
	unsigned int mapping_value;
	bool mapping_valid;
	unsigned int value_size;
	void *value;
	void *mask;
};

/**
 * struct devlink_dpipe_entry - table entry object
 * @index: index of the entry in the table
 * @match_values: match values
 * @matche_values_count: count of matches tuples
 * @action_values: actions values
 * @action_values_count: count of actions values
 * @counter: value of counter
 * @counter_valid: Specify if value is valid from hardware
 */
struct devlink_dpipe_entry {
	u64 index;
	struct devlink_dpipe_value *match_values;
	unsigned int match_values_count;
	struct devlink_dpipe_value *action_values;
	unsigned int action_values_count;
	u64 counter;
	bool counter_valid;
};

/**
 * struct devlink_dpipe_dump_ctx - context provided to driver in order
 *				   to dump
 * @info: info
 * @cmd: devlink command
 * @skb: skb
 * @nest: top attribute
 * @hdr: hdr
 */
struct devlink_dpipe_dump_ctx {
	struct genl_info *info;
	enum devlink_command cmd;
	struct sk_buff *skb;
	struct nlattr *nest;
	void *hdr;
};

struct devlink_dpipe_table_ops;

/**
 * struct devlink_dpipe_table - table object
 * @priv: private
 * @name: table name
 * @size: maximum number of entries
 * @counters_enabled: indicates if counters are active
 * @counter_control_extern: indicates if counter control is in dpipe or
 *			    external tool
 * @table_ops: table operations
 * @rcu: rcu
 */
struct devlink_dpipe_table {
	void *priv;
	struct list_head list;
	const char *name;
	u64 size;
	bool counters_enabled;
	bool counter_control_extern;
	struct devlink_dpipe_table_ops *table_ops;
	struct rcu_head rcu;
};

/**
 * struct devlink_dpipe_table_ops - dpipe_table ops
 * @actions_dump - dumps all tables actions
 * @matches_dump - dumps all tables matches
 * @entries_dump - dumps all active entries in the table
 * @counters_set_update - when changing the counter status hardware sync
 *			  maybe needed to allocate/free counter related
 *			  resources
 */
struct devlink_dpipe_table_ops {
	int (*actions_dump)(void *priv, struct sk_buff *skb);
	int (*matches_dump)(void *priv, struct sk_buff *skb);
	int (*entries_dump)(void *priv, bool counters_enabled,
			    struct devlink_dpipe_dump_ctx *dump_ctx);
	int (*counters_set_update)(void *priv, bool enable);
};

/**
 * struct devlink_dpipe_headers - dpipe headers
 * @headers - header array can be shared (global bit) or driver specific
 * @headers_count - count of headers
 */
struct devlink_dpipe_headers {
	struct devlink_dpipe_header **headers;
	unsigned int headers_count;
};

struct devlink_ops {
	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);

	int (*eswitch_mode_get)(struct devlink *devlink, u16 *p_mode);
	int (*eswitch_mode_set)(struct devlink *devlink, u16 mode);
	int (*eswitch_inline_mode_get)(struct devlink *devlink, u8 *p_inline_mode);
	int (*eswitch_inline_mode_set)(struct devlink *devlink, u8 inline_mode);
	int (*eswitch_encap_mode_get)(struct devlink *devlink, u8 *p_encap_mode);
	int (*eswitch_encap_mode_set)(struct devlink *devlink, u8 encap_mode);
};

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);
int devlink_dpipe_table_register(struct devlink *devlink,
				 const char *table_name,
				 struct devlink_dpipe_table_ops *table_ops,
				 void *priv, u64 size,
				 bool counter_control_extern);
void devlink_dpipe_table_unregister(struct devlink *devlink,
				    const char *table_name);
int devlink_dpipe_headers_register(struct devlink *devlink,
				   struct devlink_dpipe_headers *dpipe_headers);
void devlink_dpipe_headers_unregister(struct devlink *devlink);
bool devlink_dpipe_table_counter_enabled(struct devlink *devlink,
					 const char *table_name);
int devlink_dpipe_entry_ctx_prepare(struct devlink_dpipe_dump_ctx *dump_ctx);
int devlink_dpipe_entry_ctx_append(struct devlink_dpipe_dump_ctx *dump_ctx,
				   struct devlink_dpipe_entry *entry);
int devlink_dpipe_entry_ctx_close(struct devlink_dpipe_dump_ctx *dump_ctx);
int devlink_dpipe_action_put(struct sk_buff *skb,
			     struct devlink_dpipe_action *action);
int devlink_dpipe_match_put(struct sk_buff *skb,
			    struct devlink_dpipe_match *match);

#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 ingress_tc_count,
				      u16 egress_tc_count)
{
	return 0;
}

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

static inline int
devlink_dpipe_table_register(struct devlink *devlink,
			     const char *table_name,
			     struct devlink_dpipe_table_ops *table_ops,
			     void *priv, u64 size,
			     bool counter_control_extern)
{
	return 0;
}

static inline void devlink_dpipe_table_unregister(struct devlink *devlink,
						  const char *table_name)
{
}

static inline int devlink_dpipe_headers_register(struct devlink *devlink,
						 struct devlink_dpipe_headers *
						 dpipe_headers)
{
	return 0;
}

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

static inline bool devlink_dpipe_table_counter_enabled(struct devlink *devlink,
						       const char *table_name)
{
	return false;
}

static inline int
devlink_dpipe_entry_ctx_prepare(struct devlink_dpipe_dump_ctx *dump_ctx)
{
	return 0;
}

static inline int
devlink_dpipe_entry_ctx_append(struct devlink_dpipe_dump_ctx *dump_ctx,
			       struct devlink_dpipe_entry *entry)
{
	return 0;
}

static inline int
devlink_dpipe_entry_ctx_close(struct devlink_dpipe_dump_ctx *dump_ctx)
{
	return 0;
}

static inline int
devlink_dpipe_action_put(struct sk_buff *skb,
			 struct devlink_dpipe_action *action)
{
	return 0;
}

static inline int
devlink_dpipe_match_put(struct sk_buff *skb,
			struct devlink_dpipe_match *match)
{
	return 0;
}

#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 <jiri@mellanox.com>
	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;
1555d204 AS	28	struct list_head dpipe_table_list;
1555d204 AS	29	struct devlink_dpipe_headers *dpipe_headers;
bfcd3a46 JP	30	const struct devlink_ops *ops;
	31	struct device *dev;
	32	possible_net_t _net;
	33	char priv[0] __aligned(NETDEV_ALIGN);
	34	};
	35
	36	struct devlink_port {
	37	struct list_head list;
	38	struct devlink *devlink;
	39	unsigned index;
	40	bool registered;
	41	enum devlink_port_type type;
	42	enum devlink_port_type desired_type;
	43	void *type_dev;
	44	bool split;
	45	u32 split_group;
	46	};
	47
bf797471 JP	48	struct devlink_sb_pool_info {
	49	enum devlink_sb_pool_type pool_type;
	50	u32 size;
	51	enum devlink_sb_threshold_type threshold_type;
	52	};
	53
1555d204 AS	54	/**
	55	* struct devlink_dpipe_field - dpipe field object
	56	* @name: field name
	57	* @id: index inside the headers field array
	58	* @bitwidth: bitwidth
	59	* @mapping_type: mapping type
	60	*/
	61	struct devlink_dpipe_field {
	62	const char *name;
	63	unsigned int id;
	64	unsigned int bitwidth;
	65	enum devlink_dpipe_field_mapping_type mapping_type;
	66	};
	67
	68	/**
	69	* struct devlink_dpipe_header - dpipe header object
	70	* @name: header name
	71	* @id: index, global/local detrmined by global bit
	72	* @fields: fields
	73	* @fields_count: number of fields
	74	* @global: indicates if header is shared like most protocol header
	75	* or driver specific
	76	*/
	77	struct devlink_dpipe_header {
	78	const char *name;
	79	unsigned int id;
	80	struct devlink_dpipe_field *fields;
	81	unsigned int fields_count;
	82	bool global;
	83	};
	84
	85	/**
	86	* struct devlink_dpipe_match - represents match operation
	87	* @type: type of match
	88	* @header_index: header index (packets can have several headers of same
	89	* type like in case of tunnels)
	90	* @header: header
	91	* @fieled_id: field index
	92	*/
	93	struct devlink_dpipe_match {
	94	enum devlink_dpipe_match_type type;
	95	unsigned int header_index;
	96	struct devlink_dpipe_header *header;
	97	unsigned int field_id;
	98	};
	99
	100	/**
	101	* struct devlink_dpipe_action - represents action operation
	102	* @type: type of action
	103	* @header_index: header index (packets can have several headers of same
	104	* type like in case of tunnels)
	105	* @header: header
	106	* @fieled_id: field index
	107	*/
	108	struct devlink_dpipe_action {
	109	enum devlink_dpipe_action_type type;
	110	unsigned int header_index;
	111	struct devlink_dpipe_header *header;
	112	unsigned int field_id;
	113	};
	114
	115	/**
	116	* struct devlink_dpipe_value - represents value of match/action
	117	* @action: action
118	* @match: match
119	* @mapping_value: in case the field has some mapping this value
120	* specified the mapping value
121	* @mapping_valid: specify if mapping value is valid
122	* @value_size: value size
123	* @value: value
124	* @mask: bit mask
125	*/
126	struct devlink_dpipe_value {
127	union {
128	struct devlink_dpipe_action *action;
129	struct devlink_dpipe_match *match;
130	};
131	unsigned int mapping_value;
132	bool mapping_valid;
133	unsigned int value_size;
134	void *value;
135	void *mask;
136	};
137
138	/**
139	* struct devlink_dpipe_entry - table entry object
140	* @index: index of the entry in the table
141	* @match_values: match values
142	* @matche_values_count: count of matches tuples
143	* @action_values: actions values
144	* @action_values_count: count of actions values
145	* @counter: value of counter
146	* @counter_valid: Specify if value is valid from hardware
147	*/
148	struct devlink_dpipe_entry {
149	u64 index;
150	struct devlink_dpipe_value *match_values;
151	unsigned int match_values_count;
152	struct devlink_dpipe_value *action_values;
153	unsigned int action_values_count;
154	u64 counter;
155	bool counter_valid;
156	};
157
158	/**
159	* struct devlink_dpipe_dump_ctx - context provided to driver in order
160	* to dump
161	* @info: info
162	* @cmd: devlink command
163	* @skb: skb
164	* @nest: top attribute
165	* @hdr: hdr
166	*/
167	struct devlink_dpipe_dump_ctx {
168	struct genl_info *info;
169	enum devlink_command cmd;
170	struct sk_buff *skb;
171	struct nlattr *nest;
172	void *hdr;
173	};
174
175	struct devlink_dpipe_table_ops;
176
177	/**
178	* struct devlink_dpipe_table - table object
179	* @priv: private
180	* @name: table name
181	* @size: maximum number of entries
182	* @counters_enabled: indicates if counters are active
183	* @counter_control_extern: indicates if counter control is in dpipe or
184	* external tool
185	* @table_ops: table operations
186	* @rcu: rcu
187	*/
188	struct devlink_dpipe_table {
189	void *priv;
190	struct list_head list;
191	const char *name;
192	u64 size;
193	bool counters_enabled;
194	bool counter_control_extern;
195	struct devlink_dpipe_table_ops *table_ops;
196	struct rcu_head rcu;
197	};
198
199	/**
200	* struct devlink_dpipe_table_ops - dpipe_table ops
201	* @actions_dump - dumps all tables actions
202	* @matches_dump - dumps all tables matches
203	* @entries_dump - dumps all active entries in the table
204	* @counters_set_update - when changing the counter status hardware sync
205	* maybe needed to allocate/free counter related
206	* resources
207	*/
208	struct devlink_dpipe_table_ops {
209	int (actions_dump)(void priv, struct sk_buff *skb);
210	int (matches_dump)(void priv, struct sk_buff *skb);
211	int (entries_dump)(void priv, bool counters_enabled,
212	struct devlink_dpipe_dump_ctx *dump_ctx);
213	int (counters_set_update)(void priv, bool enable);
214	};
215
216	/**
217	* struct devlink_dpipe_headers - dpipe headers
218	* @headers - header array can be shared (global bit) or driver specific
219	* @headers_count - count of headers
220	*/
221	struct devlink_dpipe_headers {
222	struct devlink_dpipe_header **headers;
223	unsigned int headers_count;
224	};
225
bfcd3a46	226	struct devlink_ops {
bfcd3a46 JP	227	int (port_type_set)(struct devlink_port devlink_port,
	228	enum devlink_port_type port_type);
	229	int (port_split)(struct devlink devlink, unsigned int port_index,
	230	unsigned int count);
	231	int (port_unsplit)(struct devlink devlink, unsigned int port_index);
bf797471 JP	232	int (sb_pool_get)(struct devlink devlink, unsigned int sb_index,
	233	u16 pool_index,
	234	struct devlink_sb_pool_info *pool_info);
	235	int (sb_pool_set)(struct devlink devlink, unsigned int sb_index,
	236	u16 pool_index, u32 size,
	237	enum devlink_sb_threshold_type threshold_type);
	238	int (sb_port_pool_get)(struct devlink_port devlink_port,
	239	unsigned int sb_index, u16 pool_index,
	240	u32 *p_threshold);
	241	int (sb_port_pool_set)(struct devlink_port devlink_port,
	242	unsigned int sb_index, u16 pool_index,
	243	u32 threshold);
	244	int (sb_tc_pool_bind_get)(struct devlink_port devlink_port,
	245	unsigned int sb_index,
	246	u16 tc_index,
	247	enum devlink_sb_pool_type pool_type,
	248	u16 p_pool_index, u32 p_threshold);
	249	int (sb_tc_pool_bind_set)(struct devlink_port devlink_port,
	250	unsigned int sb_index,
	251	u16 tc_index,
	252	enum devlink_sb_pool_type pool_type,
	253	u16 pool_index, u32 threshold);
df38dafd JP	254	int (sb_occ_snapshot)(struct devlink devlink,
	255	unsigned int sb_index);
	256	int (sb_occ_max_clear)(struct devlink devlink,
	257	unsigned int sb_index);
	258	int (sb_occ_port_pool_get)(struct devlink_port devlink_port,
	259	unsigned int sb_index, u16 pool_index,
	260	u32 p_cur, u32 p_max);
	261	int (sb_occ_tc_port_bind_get)(struct devlink_port devlink_port,
	262	unsigned int sb_index,
	263	u16 tc_index,
	264	enum devlink_sb_pool_type pool_type,
	265	u32 p_cur, u32 p_max);
08f4b591 OG	266
	267	int (eswitch_mode_get)(struct devlink devlink, u16 *p_mode);
	268	int (eswitch_mode_set)(struct devlink devlink, u16 mode);
59bfde01 RD	269	int (eswitch_inline_mode_get)(struct devlink devlink, u8 *p_inline_mode);
59bfde01 RD	270	int (eswitch_inline_mode_set)(struct devlink devlink, u8 inline_mode);
f43e9b06 RD	271	int (eswitch_encap_mode_get)(struct devlink devlink, u8 *p_encap_mode);
f43e9b06 RD	272	int (eswitch_encap_mode_set)(struct devlink devlink, u8 encap_mode);
bfcd3a46 JP	273	};
	274
	275	static inline void devlink_priv(struct devlink devlink)
	276	{
	277	BUG_ON(!devlink);
	278	return &devlink->priv;
	279	}
	280
	281	static inline struct devlink priv_to_devlink(void priv)
	282	{
	283	BUG_ON(!priv);
	284	return container_of(priv, struct devlink, priv);
	285	}
	286
	287	struct ib_device;
	288
	289	#if IS_ENABLED(CONFIG_NET_DEVLINK)
	290
	291	struct devlink devlink_alloc(const struct devlink_ops ops, size_t priv_size);
	292	int devlink_register(struct devlink devlink, struct device dev);
	293	void devlink_unregister(struct devlink *devlink);
	294	void devlink_free(struct devlink *devlink);
	295	int devlink_port_register(struct devlink *devlink,
	296	struct devlink_port *devlink_port,
	297	unsigned int port_index);
	298	void devlink_port_unregister(struct devlink_port *devlink_port);
	299	void devlink_port_type_eth_set(struct devlink_port *devlink_port,
	300	struct net_device *netdev);
	301	void devlink_port_type_ib_set(struct devlink_port *devlink_port,
	302	struct ib_device *ibdev);
	303	void devlink_port_type_clear(struct devlink_port *devlink_port);
	304	void devlink_port_split_set(struct devlink_port *devlink_port,
	305	u32 split_group);
bf797471 JP	306	int devlink_sb_register(struct devlink *devlink, unsigned int sb_index,
	307	u32 size, u16 ingress_pools_count,
	308	u16 egress_pools_count, u16 ingress_tc_count,
	309	u16 egress_tc_count);
	310	void devlink_sb_unregister(struct devlink *devlink, unsigned int sb_index);
1555d204 AS	311	int devlink_dpipe_table_register(struct devlink *devlink,
	312	const char *table_name,
	313	struct devlink_dpipe_table_ops *table_ops,
	314	void *priv, u64 size,
	315	bool counter_control_extern);
	316	void devlink_dpipe_table_unregister(struct devlink *devlink,
	317	const char *table_name);
	318	int devlink_dpipe_headers_register(struct devlink *devlink,
	319	struct devlink_dpipe_headers *dpipe_headers);
	320	void devlink_dpipe_headers_unregister(struct devlink *devlink);
	321	bool devlink_dpipe_table_counter_enabled(struct devlink *devlink,
	322	const char *table_name);
	323	int devlink_dpipe_entry_ctx_prepare(struct devlink_dpipe_dump_ctx *dump_ctx);
	324	int devlink_dpipe_entry_ctx_append(struct devlink_dpipe_dump_ctx *dump_ctx,
	325	struct devlink_dpipe_entry *entry);
	326	int devlink_dpipe_entry_ctx_close(struct devlink_dpipe_dump_ctx *dump_ctx);
	327	int devlink_dpipe_action_put(struct sk_buff *skb,
	328	struct devlink_dpipe_action *action);
	329	int devlink_dpipe_match_put(struct sk_buff *skb,
	330	struct devlink_dpipe_match *match);
bfcd3a46 JP	331
	332	#else
	333
	334	static inline struct devlink devlink_alloc(const struct devlink_ops ops,
	335	size_t priv_size)
	336	{
	337	return kzalloc(sizeof(struct devlink) + priv_size, GFP_KERNEL);
	338	}
	339
	340	static inline int devlink_register(struct devlink devlink, struct device dev)
	341	{
	342	return 0;
	343	}
	344
	345	static inline void devlink_unregister(struct devlink *devlink)
	346	{
	347	}
	348
	349	static inline void devlink_free(struct devlink *devlink)
	350	{
	351	kfree(devlink);
	352	}
	353
	354	static inline int devlink_port_register(struct devlink *devlink,
	355	struct devlink_port *devlink_port,
	356	unsigned int port_index)
	357	{
	358	return 0;
	359	}
	360
	361	static inline void devlink_port_unregister(struct devlink_port *devlink_port)
	362	{
	363	}
	364
	365	static inline void devlink_port_type_eth_set(struct devlink_port *devlink_port,
	366	struct net_device *netdev)
	367	{
	368	}
	369
	370	static inline void devlink_port_type_ib_set(struct devlink_port *devlink_port,
	371	struct ib_device *ibdev)
	372	{
	373	}
	374
	375	static inline void devlink_port_type_clear(struct devlink_port *devlink_port)
	376	{
	377	}
	378
	379	static inline void devlink_port_split_set(struct devlink_port *devlink_port,
	380	u32 split_group)
	381	{
	382	}
	383
bf797471 JP	384	static inline int devlink_sb_register(struct devlink *devlink,
	385	unsigned int sb_index, u32 size,
	386	u16 ingress_pools_count,
de33efd0 JP	387	u16 egress_pools_count,
	388	u16 ingress_tc_count,
	389	u16 egress_tc_count)
bf797471 JP	390	{
	391	return 0;
	392	}
	393
	394	static inline void devlink_sb_unregister(struct devlink *devlink,
	395	unsigned int sb_index)
	396	{
	397	}
	398
1555d204 AS	399	static inline int
	400	devlink_dpipe_table_register(struct devlink *devlink,
	401	const char *table_name,
	402	struct devlink_dpipe_table_ops *table_ops,
	403	void *priv, u64 size,
	404	bool counter_control_extern)
	405	{
	406	return 0;
	407	}
	408
	409	static inline void devlink_dpipe_table_unregister(struct devlink *devlink,
	410	const char *table_name)
	411	{
	412	}
	413
	414	static inline int devlink_dpipe_headers_register(struct devlink *devlink,
	415	struct devlink_dpipe_headers *
	416	dpipe_headers)
	417	{
	418	return 0;
	419	}
	420
	421	static inline void devlink_dpipe_headers_unregister(struct devlink *devlink)
	422	{
	423	}
	424
	425	static inline bool devlink_dpipe_table_counter_enabled(struct devlink *devlink,
	426	const char *table_name)
	427	{
	428	return false;
	429	}
	430
	431	static inline int
	432	devlink_dpipe_entry_ctx_prepare(struct devlink_dpipe_dump_ctx *dump_ctx)
	433	{
	434	return 0;
	435	}
	436
	437	static inline int
	438	devlink_dpipe_entry_ctx_append(struct devlink_dpipe_dump_ctx *dump_ctx,
	439	struct devlink_dpipe_entry *entry)
	440	{
	441	return 0;
	442	}
	443
	444	static inline int
	445	devlink_dpipe_entry_ctx_close(struct devlink_dpipe_dump_ctx *dump_ctx)
	446	{
	447	return 0;
	448	}
	449
	450	static inline int
	451	devlink_dpipe_action_put(struct sk_buff *skb,
	452	struct devlink_dpipe_action *action)
	453	{
	454	return 0;
	455	}
	456
	457	static inline int
	458	devlink_dpipe_match_put(struct sk_buff *skb,
	459	struct devlink_dpipe_match *match)
	460	{
	461	return 0;
	462	}
463
bfcd3a46 JP	464	#endif
	465
	466	#endif /* _NET_DEVLINK_H_ */