lael-labs/linux

include/linux/avf/virtchnl.h+5−0

 	u16 vsi_id;
 	u16 key_len;
 	u8 key[1];         /* RSS hash key, packed bytes */
+	u8 pad[1];
 };
 VIRTCHNL_CHECK_STRUCT_LEN(6, virtchnl_rss_key);
 	u16 vsi_id;
 	u16 lut_entries;
 	u8 lut[1];        /* RSS lookup table */
+	u8 pad[1];
 };
 VIRTCHNL_CHECK_STRUCT_LEN(6, virtchnl_rss_lut);
 	enum	virtchnl_action action;
 	u32	action_meta;
 	u8	field_flags;
+	u8	pad[3];
 };
 VIRTCHNL_CHECK_STRUCT_LEN(272, virtchnl_filter);
 			/* link_speed provided in Mbps */
 			u32 link_speed;
 			u8 link_status;
+			u8 pad[3];
 		} link_event_adv;
 	} event_data;
 	u16 ceq_idx;
 	u16 aeq_idx;
 	u8 itr_idx;
+	u8 pad[3];
 };
 VIRTCHNL_CHECK_STRUCT_LEN(12, virtchnl_iwarp_qv_info);

include/linux/bpf-cgroup.h+5−19

 	enum bpf_attach_type type;
 };
-extern const struct bpf_link_ops bpf_cgroup_link_lops;
 struct bpf_prog_list {
 	struct list_head node;
 	struct bpf_prog *prog;
 int __cgroup_bpf_detach(struct cgroup *cgrp, struct bpf_prog *prog,
 			struct bpf_cgroup_link *link,
 			enum bpf_attach_type type);
-int __cgroup_bpf_replace(struct cgroup *cgrp, struct bpf_cgroup_link *link,
-			 struct bpf_prog *new_prog);
 int __cgroup_bpf_query(struct cgroup *cgrp, const union bpf_attr *attr,
 		       union bpf_attr __user *uattr);
 		      u32 flags);
 int cgroup_bpf_detach(struct cgroup *cgrp, struct bpf_prog *prog,
 		      enum bpf_attach_type type);
-int cgroup_bpf_replace(struct bpf_link *link, struct bpf_prog *old_prog,
-		       struct bpf_prog *new_prog);
 int cgroup_bpf_query(struct cgroup *cgrp, const union bpf_attr *attr,
 		     union bpf_attr __user *uattr);
 int __cgroup_bpf_run_filter_sysctl(struct ctl_table_header *head,
 				   struct ctl_table *table, int write,
-				   void __user *buf, size_t *pcount,
+				   void **buf, size_t *pcount, loff_t *ppos,
-				   loff_t *ppos, void **new_buf,
 				   enum bpf_attach_type type);
 int __cgroup_bpf_run_filter_setsockopt(struct sock *sock, int *level,
 })
-#define BPF_CGROUP_RUN_PROG_SYSCTL(head, table, write, buf, count, pos, nbuf)  \
+#define BPF_CGROUP_RUN_PROG_SYSCTL(head, table, write, buf, count, pos)  \
 ({									       \
 	int __ret = 0;							       \
 	if (cgroup_bpf_enabled)						       \
 		__ret = __cgroup_bpf_run_filter_sysctl(head, table, write,     \
-						       buf, count, pos, nbuf,  \
+						       buf, count, pos,        \
 						       BPF_CGROUP_SYSCTL);     \
 	__ret;								       \
 })
 #else
 struct bpf_prog;
-struct bpf_link;
 struct cgroup_bpf {};
 static inline int cgroup_bpf_inherit(struct cgroup *cgrp) { return 0; }
 static inline void cgroup_bpf_offline(struct cgroup *cgrp) {}
 	return -EINVAL;
 }
-static inline int cgroup_bpf_replace(struct bpf_link *link,
-				     struct bpf_prog *old_prog,
-				     struct bpf_prog *new_prog)
-{
-	return -EINVAL;
-}
 static inline int cgroup_bpf_prog_query(const union bpf_attr *attr,
 					union bpf_attr __user *uattr)
 {
 }
 #define cgroup_bpf_enabled (0)
+#define BPF_CGROUP_RUN_SA_PROG_LOCK(sk, uaddr, type, t_ctx) ({ 0; })
 #define BPF_CGROUP_PRE_CONNECT_ENABLED(sk) (0)
 #define BPF_CGROUP_RUN_PROG_INET_INGRESS(sk,skb) ({ 0; })
 #define BPF_CGROUP_RUN_PROG_INET_EGRESS(sk,skb) ({ 0; })
 #define BPF_CGROUP_RUN_PROG_UDP6_RECVMSG_LOCK(sk, uaddr) ({ 0; })
 #define BPF_CGROUP_RUN_PROG_SOCK_OPS(sock_ops) ({ 0; })
 #define BPF_CGROUP_RUN_PROG_DEVICE_CGROUP(type,major,minor,access) ({ 0; })
-#define BPF_CGROUP_RUN_PROG_SYSCTL(head,table,write,buf,count,pos,nbuf) ({ 0; })
+#define BPF_CGROUP_RUN_PROG_SYSCTL(head,table,write,buf,count,pos) ({ 0; })
 #define BPF_CGROUP_GETSOCKOPT_MAX_OPTLEN(optlen) ({ 0; })
 #define BPF_CGROUP_RUN_PROG_GETSOCKOPT(sock, level, optname, optval, \
 				       optlen, max_optlen, retval) ({ retval; })

include/linux/bpf-netns.h+64−0

@@ -0,0 +1,64 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef _BPF_NETNS_H
	3	#define _BPF_NETNS_H
	4
	5	#include <linux/mutex.h>
	6	#include <uapi/linux/bpf.h>
	7
	8	enum netns_bpf_attach_type {
	9	NETNS_BPF_INVALID = -1,
	10	NETNS_BPF_FLOW_DISSECTOR = 0,
	11	MAX_NETNS_BPF_ATTACH_TYPE
	12	};
	13
	14	static inline enum netns_bpf_attach_type
	15	to_netns_bpf_attach_type(enum bpf_attach_type attach_type)
	16	{
	17	switch (attach_type) {
	18	case BPF_FLOW_DISSECTOR:
	19	return NETNS_BPF_FLOW_DISSECTOR;
	20	default:
	21	return NETNS_BPF_INVALID;
	22	}
	23	}
	24
	25	/* Protects updates to netns_bpf */
	26	extern struct mutex netns_bpf_mutex;
	27
	28	union bpf_attr;
	29	struct bpf_prog;
	30
	31	#ifdef CONFIG_NET
	32	int netns_bpf_prog_query(const union bpf_attr *attr,
	33	union bpf_attr __user *uattr);
	34	int netns_bpf_prog_attach(const union bpf_attr *attr,
	35	struct bpf_prog *prog);
	36	int netns_bpf_prog_detach(const union bpf_attr *attr);
	37	int netns_bpf_link_create(const union bpf_attr *attr,
	38	struct bpf_prog *prog);
	39	#else
	40	static inline int netns_bpf_prog_query(const union bpf_attr *attr,
	41	union bpf_attr __user *uattr)
	42	{
	43	return -EOPNOTSUPP;
	44	}
	45
	46	static inline int netns_bpf_prog_attach(const union bpf_attr *attr,
	47	struct bpf_prog *prog)
	48	{
	49	return -EOPNOTSUPP;
	50	}
	51
	52	static inline int netns_bpf_prog_detach(const union bpf_attr *attr)
	53	{
	54	return -EOPNOTSUPP;
	55	}
	56
	57	static inline int netns_bpf_link_create(const union bpf_attr *attr,
	58	struct bpf_prog *prog)
	59	{
	60	return -EOPNOTSUPP;
	61	}
	62	#endif
	63
	64	#endif /* _BPF_NETNS_H */

include/linux/bpf.h+116−6

@@ -19,6 +19,7 @@ · 18 unmodified lines
19	#include <linux/mutex.h>	19	#include <linux/mutex.h>
20	#include <linux/module.h>	20	#include <linux/module.h>
21	#include <linux/kallsyms.h>	21	#include <linux/kallsyms.h>
		22	#include <linux/capability.h>
22		23
23	struct bpf_verifier_env;	24	struct bpf_verifier_env;
24	struct bpf_verifier_log;	25	struct bpf_verifier_log;
@@ -31,6 +32,7 @@ struct seq_file; · 6 unmodified lines
31	struct btf;	32	struct btf;
32	struct btf_type;	33	struct btf_type;
33	struct exception_table_entry;	34	struct exception_table_entry;
		35	struct seq_operations;
34		36
35	extern struct idr btf_idr;	37	extern struct idr btf_idr;
36	extern spinlock_t btf_idr_lock;	38	extern spinlock_t btf_idr_lock;
@@ -88,6 +90,8 @@ struct bpf_map_ops { · 51 unmodified lines
88	int (map_direct_value_meta)(const struct bpf_map map,	90	int (map_direct_value_meta)(const struct bpf_map map,
89	u64 imm, u32 *off);	91	u64 imm, u32 *off);
90	int (map_mmap)(struct bpf_map map, struct vm_area_struct *vma);	92	int (map_mmap)(struct bpf_map map, struct vm_area_struct *vma);
		93	__poll_t (map_poll)(struct bpf_map map, struct file *filp,
		94	struct poll_table_struct *pts);
91	};	95	};
92		96
93	struct bpf_map_memory {	97	struct bpf_map_memory {
@@ -118,7 +122,7 @@ struct bpf_map { · 24 unmodified lines
118	struct bpf_map_memory memory;	122	struct bpf_map_memory memory;
119	char name[BPF_OBJ_NAME_LEN];	123	char name[BPF_OBJ_NAME_LEN];
120	u32 btf_vmlinux_value_type_id;	124	u32 btf_vmlinux_value_type_id;
121	bool unpriv_array;	125	bool bypass_spec_v1;
122	bool frozen; /* write-once; write-protected by freeze_mutex */	126	bool frozen; /* write-once; write-protected by freeze_mutex */
123	/* 22 bytes hole */	127	/* 22 bytes hole */
124		128
@@ -242,6 +246,9 @@ enum bpf_arg_type { · 117 unmodified lines
242	ARG_PTR_TO_LONG, /* pointer to long */	246	ARG_PTR_TO_LONG, /* pointer to long */
243	ARG_PTR_TO_SOCKET, /* pointer to bpf_sock (fullsock) */	247	ARG_PTR_TO_SOCKET, /* pointer to bpf_sock (fullsock) */
244	ARG_PTR_TO_BTF_ID, /* pointer to in-kernel struct */	248	ARG_PTR_TO_BTF_ID, /* pointer to in-kernel struct */
		249	ARG_PTR_TO_ALLOC_MEM, /* pointer to dynamically allocated memory */
		250	ARG_PTR_TO_ALLOC_MEM_OR_NULL, /* pointer to dynamically allocated memory or NULL */
		251	ARG_CONST_ALLOC_SIZE_OR_ZERO, /* number of allocated bytes requested */
245	};	252	};
246		253
247	/* type of values returned from helper functions */	254	/* type of values returned from helper functions */
@@ -253,6 +260,7 @@ enum bpf_return_type { · 5 unmodified lines
253	RET_PTR_TO_SOCKET_OR_NULL, /* returns a pointer to a socket or NULL */	260	RET_PTR_TO_SOCKET_OR_NULL, /* returns a pointer to a socket or NULL */
254	RET_PTR_TO_TCP_SOCK_OR_NULL, /* returns a pointer to a tcp_sock or NULL */	261	RET_PTR_TO_TCP_SOCK_OR_NULL, /* returns a pointer to a tcp_sock or NULL */
255	RET_PTR_TO_SOCK_COMMON_OR_NULL, /* returns a pointer to a sock_common or NULL */	262	RET_PTR_TO_SOCK_COMMON_OR_NULL, /* returns a pointer to a sock_common or NULL */
		263	RET_PTR_TO_ALLOC_MEM_OR_NULL, /* returns a pointer to dynamically allocated memory or NULL */
256	};	264	};
257		265
258	/* eBPF function prototype used by verifier to allow BPF_CALLs from eBPF programs	266	/* eBPF function prototype used by verifier to allow BPF_CALLs from eBPF programs
@@ -319,6 +327,9 @@ enum bpf_reg_type { · 60 unmodified lines
319	PTR_TO_TP_BUFFER, /* reg points to a writable raw tp's buffer */	327	PTR_TO_TP_BUFFER, /* reg points to a writable raw tp's buffer */
320	PTR_TO_XDP_SOCK, /* reg points to struct xdp_sock */	328	PTR_TO_XDP_SOCK, /* reg points to struct xdp_sock */
321	PTR_TO_BTF_ID, /* reg points to kernel struct */	329	PTR_TO_BTF_ID, /* reg points to kernel struct */
		330	PTR_TO_BTF_ID_OR_NULL, /* reg points to kernel struct or NULL */
		331	PTR_TO_MEM, /* reg points to valid memory region */
		332	PTR_TO_MEM_OR_NULL, /* reg points to valid memory region or NULL */
322	};	333	};
323		334
324	/* The information passed from prog-specific *_is_valid_access	335	/* The information passed from prog-specific *_is_valid_access
@@ -641,6 +652,12 @@ struct bpf_jit_poke_descriptor { · 316 unmodified lines
641	u16 reason;	652	u16 reason;
642	};	653	};
643		654
		655	/* reg_type info for ctx arguments */
		656	struct bpf_ctx_arg_aux {
		657	u32 offset;
		658	enum bpf_reg_type reg_type;
		659	};
		660
644	struct bpf_prog_aux {	661	struct bpf_prog_aux {
645	atomic64_t refcnt;	662	atomic64_t refcnt;
646	u32 used_map_cnt;	663	u32 used_map_cnt;
@@ -652,6 +669,8 @@ struct bpf_prog_aux { · 5 unmodified lines
652	u32 func_cnt; /* used by non-func prog as the number of func progs */	669	u32 func_cnt; /* used by non-func prog as the number of func progs */
653	u32 func_idx; /* 0 for non-func prog, the index in func array for func prog */	670	u32 func_idx; /* 0 for non-func prog, the index in func array for func prog */
654	u32 attach_btf_id; /* in-kernel BTF type id to attach to */	671	u32 attach_btf_id; /* in-kernel BTF type id to attach to */
		672	u32 ctx_arg_info_size;
		673	const struct bpf_ctx_arg_aux *ctx_arg_info;
655	struct bpf_prog *linked_prog;	674	struct bpf_prog *linked_prog;
656	bool verifier_zext; /* Zero extensions has been inserted by verifier. */	675	bool verifier_zext; /* Zero extensions has been inserted by verifier. */
657	bool offload_requested;	676	bool offload_requested;
@@ -987,6 +1006,7 @@ _out: \ · 329 unmodified lines
987		1006
988	#ifdef CONFIG_BPF_SYSCALL	1007	#ifdef CONFIG_BPF_SYSCALL
989	DECLARE_PER_CPU(int, bpf_prog_active);	1008	DECLARE_PER_CPU(int, bpf_prog_active);
		1009	extern struct mutex bpf_stats_enabled_mutex;
990		1010
991	/*	1011	/*
992	* Block execution of BPF programs attached to instrumentation (perf,	1012	* Block execution of BPF programs attached to instrumentation (perf,
@@ -1020,15 +1040,18 @@ static inline void bpf_enable_instrumentation(void) · 27 unmodified lines
1020		1040
1021	extern const struct file_operations bpf_map_fops;	1041	extern const struct file_operations bpf_map_fops;
1022	extern const struct file_operations bpf_prog_fops;	1042	extern const struct file_operations bpf_prog_fops;
		1043	extern const struct file_operations bpf_iter_fops;
1023		1044
1024	#define BPF_PROG_TYPE(_id, _name, prog_ctx_type, kern_ctx_type) \	1045	#define BPF_PROG_TYPE(_id, _name, prog_ctx_type, kern_ctx_type) \
1025	extern const struct bpf_prog_ops _name ## _prog_ops; \	1046	extern const struct bpf_prog_ops _name ## _prog_ops; \
1026	extern const struct bpf_verifier_ops _name ## _verifier_ops;	1047	extern const struct bpf_verifier_ops _name ## _verifier_ops;
1027	#define BPF_MAP_TYPE(_id, _ops) \	1048	#define BPF_MAP_TYPE(_id, _ops) \
1028	extern const struct bpf_map_ops _ops;	1049	extern const struct bpf_map_ops _ops;
		1050	#define BPF_LINK_TYPE(_id, _name)
1029	#include <linux/bpf_types.h>	1051	#include <linux/bpf_types.h>
1030	#undef BPF_PROG_TYPE	1052	#undef BPF_PROG_TYPE
1031	#undef BPF_MAP_TYPE	1053	#undef BPF_MAP_TYPE
		1054	#undef BPF_LINK_TYPE
1032		1055
1033	extern const struct bpf_prog_ops bpf_offload_prog_ops;	1056	extern const struct bpf_prog_ops bpf_offload_prog_ops;
1034	extern const struct bpf_verifier_ops tc_cls_act_analyzer_ops;	1057	extern const struct bpf_verifier_ops tc_cls_act_analyzer_ops;
@@ -1077,29 +1100,59 @@ int generic_map_update_batch(struct bpf_map *map, · 42 unmodified lines
1077	int generic_map_delete_batch(struct bpf_map *map,	1100	int generic_map_delete_batch(struct bpf_map *map,
1078	const union bpf_attr *attr,	1101	const union bpf_attr *attr,
1079	union bpf_attr __user *uattr);	1102	union bpf_attr __user *uattr);
		1103	struct bpf_map bpf_map_get_curr_or_next(u32 id);
1080		1104
1081	extern int sysctl_unprivileged_bpf_disabled;	1105	extern int sysctl_unprivileged_bpf_disabled;
1082		1106
		1107	static inline bool bpf_allow_ptr_leaks(void)
		1108	{
		1109	return perfmon_capable();
		1110	}
		1111
		1112	static inline bool bpf_bypass_spec_v1(void)
		1113	{
		1114	return perfmon_capable();
		1115	}
		1116
		1117	static inline bool bpf_bypass_spec_v4(void)
		1118	{
		1119	return perfmon_capable();
		1120	}
		1121
1083	int bpf_map_new_fd(struct bpf_map *map, int flags);	1122	int bpf_map_new_fd(struct bpf_map *map, int flags);
1084	int bpf_prog_new_fd(struct bpf_prog *prog);	1123	int bpf_prog_new_fd(struct bpf_prog *prog);
1085		1124
1086	struct bpf_link {	1125	struct bpf_link {
1087	atomic64_t refcnt;	1126	atomic64_t refcnt;
		1127	u32 id;
		1128	enum bpf_link_type type;
1088	const struct bpf_link_ops *ops;	1129	const struct bpf_link_ops *ops;
1089	struct bpf_prog *prog;	1130	struct bpf_prog *prog;
1090	struct work_struct work;	1131	struct work_struct work;
1091	};	1132	};
1092		1133
		1134	struct bpf_link_primer {
		1135	struct bpf_link *link;
		1136	struct file *file;
		1137	int fd;
		1138	u32 id;
		1139	};
		1140
1093	struct bpf_link_ops {	1141	struct bpf_link_ops {
1094	void (release)(struct bpf_link link);	1142	void (release)(struct bpf_link link);
1095	void (dealloc)(struct bpf_link link);	1143	void (dealloc)(struct bpf_link link);
1096		1144	int (update_prog)(struct bpf_link link, struct bpf_prog *new_prog,
		1145	struct bpf_prog *old_prog);
		1146	void (show_fdinfo)(const struct bpf_link link, struct seq_file *seq);
		1147	int (fill_link_info)(const struct bpf_link link,
		1148	struct bpf_link_info *info);
1097	};	1149	};
1098		1150
1099	void bpf_link_init(struct bpf_link link, const struct bpf_link_ops ops,	1151	void bpf_link_init(struct bpf_link *link, enum bpf_link_type type,
1100	struct bpf_prog *prog);	1152	const struct bpf_link_ops ops, struct bpf_prog prog);
1101	void bpf_link_cleanup(struct bpf_link link, struct file link_file,	1153	int bpf_link_prime(struct bpf_link link, struct bpf_link_primer primer);
1102	int link_fd);	1154	int bpf_link_settle(struct bpf_link_primer *primer);
		1155	void bpf_link_cleanup(struct bpf_link_primer *primer);
1103	void bpf_link_inc(struct bpf_link *link);	1156	void bpf_link_inc(struct bpf_link *link);
1104	void bpf_link_put(struct bpf_link *link);	1157	void bpf_link_put(struct bpf_link *link);
1105	int bpf_link_new_fd(struct bpf_link *link);	1158	int bpf_link_new_fd(struct bpf_link *link);
@@ -1109,6 +1162,40 @@ struct bpf_link *bpf_link_get_from_fd(u32 ufd); · 3 unmodified lines
1109	int bpf_obj_pin_user(u32 ufd, const char __user *pathname);	1162	int bpf_obj_pin_user(u32 ufd, const char __user *pathname);
1110	int bpf_obj_get_user(const char __user *pathname, int flags);	1163	int bpf_obj_get_user(const char __user *pathname, int flags);
1111		1164
		1165	#define BPF_ITER_FUNC_PREFIX "bpf_iter_"
		1166	#define DEFINE_BPF_ITER_FUNC(target, args...) \
		1167	extern int bpf_iter_ ## target(args); \
		1168	int __init bpf_iter_ ## target(args) { return 0; }
		1169
		1170	typedef int (bpf_iter_init_seq_priv_t)(void private_data);
		1171	typedef void (bpf_iter_fini_seq_priv_t)(void private_data);
		1172
		1173	#define BPF_ITER_CTX_ARG_MAX 2
		1174	struct bpf_iter_reg {
		1175	const char *target;
		1176	const struct seq_operations *seq_ops;
		1177	bpf_iter_init_seq_priv_t init_seq_private;
		1178	bpf_iter_fini_seq_priv_t fini_seq_private;
		1179	u32 seq_priv_size;
		1180	u32 ctx_arg_info_size;
		1181	struct bpf_ctx_arg_aux ctx_arg_info[BPF_ITER_CTX_ARG_MAX];
		1182	};
		1183
		1184	struct bpf_iter_meta {
		1185	__bpf_md_ptr(struct seq_file *, seq);
		1186	u64 session_id;
		1187	u64 seq_num;
		1188	};
		1189
		1190	int bpf_iter_reg_target(const struct bpf_iter_reg *reg_info);
		1191	void bpf_iter_unreg_target(const struct bpf_iter_reg *reg_info);
		1192	bool bpf_iter_prog_supported(struct bpf_prog *prog);
		1193	int bpf_iter_link_attach(const union bpf_attr attr, struct bpf_prog prog);
		1194	int bpf_iter_new_fd(struct bpf_link *link);
		1195	bool bpf_link_is_iter(struct bpf_link *link);
		1196	struct bpf_prog bpf_iter_get_info(struct bpf_iter_meta meta, bool in_stop);
		1197	int bpf_iter_run_prog(struct bpf_prog prog, void ctx);
		1198
1112	int bpf_percpu_hash_copy(struct bpf_map map, void key, void *value);	1199	int bpf_percpu_hash_copy(struct bpf_map map, void key, void *value);
1113	int bpf_percpu_array_copy(struct bpf_map map, void key, void *value);	1200	int bpf_percpu_array_copy(struct bpf_map map, void key, void *value);
1114	int bpf_percpu_hash_update(struct bpf_map map, void key, void *value,	1201	int bpf_percpu_hash_update(struct bpf_map map, void key, void *value,
@@ -1163,6 +1250,7 @@ int dev_map_enqueue(struct bpf_dtab_netdev dst, struct xdp_buff xdp, · 48 unmodified lines
1163	struct net_device *dev_rx);	1250	struct net_device *dev_rx);
1164	int dev_map_generic_redirect(struct bpf_dtab_netdev dst, struct sk_buff skb,	1251	int dev_map_generic_redirect(struct bpf_dtab_netdev dst, struct sk_buff skb,
1165	struct bpf_prog *xdp_prog);	1252	struct bpf_prog *xdp_prog);
		1253	bool dev_map_can_have_prog(struct bpf_map *map);
1166		1254
1167	struct bpf_cpu_map_entry __cpu_map_lookup_elem(struct bpf_map map, u32 key);	1255	struct bpf_cpu_map_entry __cpu_map_lookup_elem(struct bpf_map map, u32 key);
1168	void __cpu_map_flush(void);	1256	void __cpu_map_flush(void);
@@ -1215,6 +1303,7 @@ int btf_check_type_match(struct bpf_verifier_env env, struct bpf_prog prog, · 46 unmodified lines
1215		1303
1216	struct bpf_prog *bpf_prog_by_id(u32 id);	1304	struct bpf_prog *bpf_prog_by_id(u32 id);
1217		1305
		1306	const struct bpf_func_proto *bpf_base_func_proto(enum bpf_func_id func_id);
1218	#else /* !CONFIG_BPF_SYSCALL */	1307	#else /* !CONFIG_BPF_SYSCALL */
1219	static inline struct bpf_prog *bpf_prog_get(u32 ufd)	1308	static inline struct bpf_prog *bpf_prog_get(u32 ufd)
1220	{	1309	{
@@ -1275,6 +1364,10 @@ static inline struct net_device __dev_map_hash_lookup_elem(struct bpf_map map · 54 unmodified lines
1275	{	1364	{
1276	return NULL;	1365	return NULL;
1277	}	1366	}
		1367	static inline bool dev_map_can_have_prog(struct bpf_map *map)
		1368	{
		1369	return false;
		1370	}
1278		1371
1279	static inline void __dev_flush(void)	1372	static inline void __dev_flush(void)
1280	{	1373	{
@@ -1365,6 +1458,12 @@ static inline struct bpf_prog *bpf_prog_by_id(u32 id) · 84 unmodified lines
1365	{	1458	{
1366	return ERR_PTR(-ENOTSUPP);	1459	return ERR_PTR(-ENOTSUPP);
1367	}	1460	}
		1461
		1462	static inline const struct bpf_func_proto *
		1463	bpf_base_func_proto(enum bpf_func_id func_id)
		1464	{
		1465	return NULL;
		1466	}
1368	#endif /* CONFIG_BPF_SYSCALL */	1467	#endif /* CONFIG_BPF_SYSCALL */
1369		1468
1370	static inline struct bpf_prog *bpf_prog_get_type(u32 ufd,	1469	static inline struct bpf_prog *bpf_prog_get_type(u32 ufd,
@@ -1502,6 +1601,7 @@ extern const struct bpf_func_proto bpf_get_smp_processor_id_proto; · 131 unmodified lines
1502	extern const struct bpf_func_proto bpf_get_numa_node_id_proto;	1601	extern const struct bpf_func_proto bpf_get_numa_node_id_proto;
1503	extern const struct bpf_func_proto bpf_tail_call_proto;	1602	extern const struct bpf_func_proto bpf_tail_call_proto;
1504	extern const struct bpf_func_proto bpf_ktime_get_ns_proto;	1603	extern const struct bpf_func_proto bpf_ktime_get_ns_proto;
		1604	extern const struct bpf_func_proto bpf_ktime_get_boot_ns_proto;
1505	extern const struct bpf_func_proto bpf_get_current_pid_tgid_proto;	1605	extern const struct bpf_func_proto bpf_get_current_pid_tgid_proto;
1506	extern const struct bpf_func_proto bpf_get_current_uid_gid_proto;	1606	extern const struct bpf_func_proto bpf_get_current_uid_gid_proto;
1507	extern const struct bpf_func_proto bpf_get_current_comm_proto;	1607	extern const struct bpf_func_proto bpf_get_current_comm_proto;
@@ -1523,13 +1623,23 @@ extern const struct bpf_func_proto bpf_strtoul_proto; · 15 unmodified lines
1523	extern const struct bpf_func_proto bpf_tcp_sock_proto;	1623	extern const struct bpf_func_proto bpf_tcp_sock_proto;
1524	extern const struct bpf_func_proto bpf_jiffies64_proto;	1624	extern const struct bpf_func_proto bpf_jiffies64_proto;
1525	extern const struct bpf_func_proto bpf_get_ns_current_pid_tgid_proto;	1625	extern const struct bpf_func_proto bpf_get_ns_current_pid_tgid_proto;
		1626	extern const struct bpf_func_proto bpf_event_output_data_proto;
		1627	extern const struct bpf_func_proto bpf_ringbuf_output_proto;
		1628	extern const struct bpf_func_proto bpf_ringbuf_reserve_proto;
		1629	extern const struct bpf_func_proto bpf_ringbuf_submit_proto;
		1630	extern const struct bpf_func_proto bpf_ringbuf_discard_proto;
		1631	extern const struct bpf_func_proto bpf_ringbuf_query_proto;
1526		1632
1527	const struct bpf_func_proto *bpf_tracing_func_proto(	1633	const struct bpf_func_proto *bpf_tracing_func_proto(
1528	enum bpf_func_id func_id, const struct bpf_prog *prog);	1634	enum bpf_func_id func_id, const struct bpf_prog *prog);
1529		1635
		1636	const struct bpf_func_proto *tracing_prog_func_proto(
		1637	enum bpf_func_id func_id, const struct bpf_prog *prog);
		1638
1530	/* Shared helpers among cBPF and eBPF. */	1639	/* Shared helpers among cBPF and eBPF. */
1531	void bpf_user_rnd_init_once(void);	1640	void bpf_user_rnd_init_once(void);
1532	u64 bpf_user_rnd_u32(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5);	1641	u64 bpf_user_rnd_u32(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5);
		1642	u64 bpf_get_raw_cpu_id(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5);
1533		1643
1534	#if defined(CONFIG_NET)	1644	#if defined(CONFIG_NET)
1535	bool bpf_sock_common_is_valid_access(int off, int size,	1645	bool bpf_sock_common_is_valid_access(int off, int size,

include/linux/bpf_types.h+11−0

@@ -118,3 +118,14 @@ BPF_MAP_TYPE(BPF_MAP_TYPE_STACK, stack_map_ops) · 117 unmodified lines
118	#if defined(CONFIG_BPF_JIT)	118	#if defined(CONFIG_BPF_JIT)
119	BPF_MAP_TYPE(BPF_MAP_TYPE_STRUCT_OPS, bpf_struct_ops_map_ops)	119	BPF_MAP_TYPE(BPF_MAP_TYPE_STRUCT_OPS, bpf_struct_ops_map_ops)
120	#endif	120	#endif
		121	BPF_MAP_TYPE(BPF_MAP_TYPE_RINGBUF, ringbuf_map_ops)
		122
		123	BPF_LINK_TYPE(BPF_LINK_TYPE_RAW_TRACEPOINT, raw_tracepoint)
		124	BPF_LINK_TYPE(BPF_LINK_TYPE_TRACING, tracing)
		125	#ifdef CONFIG_CGROUP_BPF
		126	BPF_LINK_TYPE(BPF_LINK_TYPE_CGROUP, cgroup)
		127	#endif
		128	BPF_LINK_TYPE(BPF_LINK_TYPE_ITER, iter)
		129	#ifdef CONFIG_NET
		130	BPF_LINK_TYPE(BPF_LINK_TYPE_NETNS, netns)
		131	#endif

include/linux/bpf_verifier.h+7−0

 		u32 btf_id; /* for PTR_TO_BTF_ID */
+		u32 mem_size; /* for PTR_TO_MEM | PTR_TO_MEM_OR_NULL */
 		/* Max size from any of the above. */
 		unsigned long raw;
 	};
 	 * offset, so they can share range knowledge.
 	 * For PTR_TO_MAP_VALUE_OR_NULL this is used to share which map value we
 	 * came from, when one is tested for != NULL.
+	 * For PTR_TO_MEM_OR_NULL this is used to identify memory allocation
+	 * for the purpose of tracking that it's freed.
 	 * For PTR_TO_SOCKET this is used to share which pointers retain the
 	 * same reference to the socket, to determine proper reference freeing.
 	 */
 	u32 used_map_cnt;		/* number of used maps */
 	u32 id_gen;			/* used to generate unique reg IDs */
 	bool allow_ptr_leaks;
+	bool bpf_capable;
+	bool bypass_spec_v1;
+	bool bypass_spec_v4;
 	bool seen_direct_write;
 	struct bpf_insn_aux_data *insn_aux_data; /* array of per-insn state */
 	const struct bpf_line_info *prev_linfo;

include/linux/brcmphy.h+58−0

@@ -15,7 +15,9 @@ · 14 unmodified lines
15	#define PHY_ID_BCMAC131 0x0143bc70	15	#define PHY_ID_BCMAC131 0x0143bc70
16	#define PHY_ID_BCM5481 0x0143bca0	16	#define PHY_ID_BCM5481 0x0143bca0
17	#define PHY_ID_BCM5395 0x0143bcf0	17	#define PHY_ID_BCM5395 0x0143bcf0
		18	#define PHY_ID_BCM53125 0x03625f20
18	#define PHY_ID_BCM54810 0x03625d00	19	#define PHY_ID_BCM54810 0x03625d00
		20	#define PHY_ID_BCM54811 0x03625cc0
19	#define PHY_ID_BCM5482 0x0143bcb0	21	#define PHY_ID_BCM5482 0x0143bcb0
20	#define PHY_ID_BCM5411 0x00206070	22	#define PHY_ID_BCM5411 0x00206070
21	#define PHY_ID_BCM5421 0x002060e0	23	#define PHY_ID_BCM5421 0x002060e0
@@ -24,6 +26,7 @@ · 2 unmodified lines
24	#define PHY_ID_BCM5461 0x002060c0	26	#define PHY_ID_BCM5461 0x002060c0
25	#define PHY_ID_BCM54612E 0x03625e60	27	#define PHY_ID_BCM54612E 0x03625e60
26	#define PHY_ID_BCM54616S 0x03625d10	28	#define PHY_ID_BCM54616S 0x03625d10
		29	#define PHY_ID_BCM54140 0xae025009
27	#define PHY_ID_BCM57780 0x03625d90	30	#define PHY_ID_BCM57780 0x03625d90
28	#define PHY_ID_BCM89610 0x03625cd0	31	#define PHY_ID_BCM89610 0x03625cd0
29		32
@@ -114,6 +117,14 @@ · 84 unmodified lines
114	#define MII_BCM54XX_SHD_VAL(x) ((x & 0x1f) << 10)	117	#define MII_BCM54XX_SHD_VAL(x) ((x & 0x1f) << 10)
115	#define MII_BCM54XX_SHD_DATA(x) ((x & 0x3ff) << 0)	118	#define MII_BCM54XX_SHD_DATA(x) ((x & 0x3ff) << 0)
116		119
		120	#define MII_BCM54XX_RDB_ADDR 0x1e
		121	#define MII_BCM54XX_RDB_DATA 0x1f
		122
		123	/* legacy access control via rdb/expansion register */
		124	#define BCM54XX_RDB_REG0087 0x0087
		125	#define BCM54XX_EXP_REG7E (MII_BCM54XX_EXP_SEL_ER + 0x7E)
		126	#define BCM54XX_ACCESS_MODE_LEGACY_EN BIT(15)
		127
117	/*	128	/*
118	* AUXILIARY CONTROL SHADOW ACCESS REGISTERS. (PHY REG 0x18)	129	* AUXILIARY CONTROL SHADOW ACCESS REGISTERS. (PHY REG 0x18)
119	*/	130	*/
@@ -290,4 +301,51 @@ · 170 unmodified lines
290	#define MII_BRCM_CORE_EXPB0 0xB0	301	#define MII_BRCM_CORE_EXPB0 0xB0
291	#define MII_BRCM_CORE_EXPB1 0xB1	302	#define MII_BRCM_CORE_EXPB1 0xB1
292		303
		304	/* Enhanced Cable Diagnostics */
		305	#define BCM54XX_RDB_ECD_CTRL 0x2a0
		306	#define BCM54XX_EXP_ECD_CTRL (MII_BCM54XX_EXP_SEL_ER + 0xc0)
		307
		308	#define BCM54XX_ECD_CTRL_CABLE_TYPE_CAT3 1 /* CAT3 or worse */
		309	#define BCM54XX_ECD_CTRL_CABLE_TYPE_CAT5 0 /* CAT5 or better */
		310	#define BCM54XX_ECD_CTRL_CABLE_TYPE_MASK BIT(0) /* cable type */
		311	#define BCM54XX_ECD_CTRL_INVALID BIT(3) /* invalid result */
		312	#define BCM54XX_ECD_CTRL_UNIT_CM 0 /* centimeters */
		313	#define BCM54XX_ECD_CTRL_UNIT_M 1 /* meters */
		314	#define BCM54XX_ECD_CTRL_UNIT_MASK BIT(10) /* cable length unit */
		315	#define BCM54XX_ECD_CTRL_IN_PROGRESS BIT(11) /* test in progress */
		316	#define BCM54XX_ECD_CTRL_BREAK_LINK BIT(12) /* unconnect link
		317	* during test
		318	*/
		319	#define BCM54XX_ECD_CTRL_CROSS_SHORT_DIS BIT(13) /* disable inter-pair
		320	* short check
		321	*/
		322	#define BCM54XX_ECD_CTRL_RUN BIT(15) /* run immediate */
		323
		324	#define BCM54XX_RDB_ECD_FAULT_TYPE 0x2a1
		325	#define BCM54XX_EXP_ECD_FAULT_TYPE (MII_BCM54XX_EXP_SEL_ER + 0xc1)
		326	#define BCM54XX_ECD_FAULT_TYPE_INVALID 0x0
		327	#define BCM54XX_ECD_FAULT_TYPE_OK 0x1
		328	#define BCM54XX_ECD_FAULT_TYPE_OPEN 0x2
		329	#define BCM54XX_ECD_FAULT_TYPE_SAME_SHORT 0x3 /* short same pair */
		330	#define BCM54XX_ECD_FAULT_TYPE_CROSS_SHORT 0x4 /* short different pairs */
		331	#define BCM54XX_ECD_FAULT_TYPE_BUSY 0x9
		332	#define BCM54XX_ECD_FAULT_TYPE_PAIR_D_MASK GENMASK(3, 0)
		333	#define BCM54XX_ECD_FAULT_TYPE_PAIR_C_MASK GENMASK(7, 4)
		334	#define BCM54XX_ECD_FAULT_TYPE_PAIR_B_MASK GENMASK(11, 8)
		335	#define BCM54XX_ECD_FAULT_TYPE_PAIR_A_MASK GENMASK(15, 12)
		336	#define BCM54XX_ECD_PAIR_A_LENGTH_RESULTS 0x2a2
		337	#define BCM54XX_ECD_PAIR_B_LENGTH_RESULTS 0x2a3
		338	#define BCM54XX_ECD_PAIR_C_LENGTH_RESULTS 0x2a4
		339	#define BCM54XX_ECD_PAIR_D_LENGTH_RESULTS 0x2a5
		340
		341	#define BCM54XX_RDB_ECD_PAIR_A_LENGTH_RESULTS 0x2a2
		342	#define BCM54XX_EXP_ECD_PAIR_A_LENGTH_RESULTS (MII_BCM54XX_EXP_SEL_ER + 0xc2)
		343	#define BCM54XX_RDB_ECD_PAIR_B_LENGTH_RESULTS 0x2a3
		344	#define BCM54XX_EXP_ECD_PAIR_B_LENGTH_RESULTS (MII_BCM54XX_EXP_SEL_ER + 0xc3)
		345	#define BCM54XX_RDB_ECD_PAIR_C_LENGTH_RESULTS 0x2a4
		346	#define BCM54XX_EXP_ECD_PAIR_C_LENGTH_RESULTS (MII_BCM54XX_EXP_SEL_ER + 0xc4)
		347	#define BCM54XX_RDB_ECD_PAIR_D_LENGTH_RESULTS 0x2a5
		348	#define BCM54XX_EXP_ECD_PAIR_D_LENGTH_RESULTS (MII_BCM54XX_EXP_SEL_ER + 0xc5)
		349	#define BCM54XX_ECD_LENGTH_RESULTS_INVALID 0xffff
		350
293	#endif /* _LINUX_BRCMPHY_H */	351	#endif /* _LINUX_BRCMPHY_H */

include/linux/capability.h+5−0

 	return capable(CAP_PERFMON) || capable(CAP_SYS_ADMIN);
 }
+static inline bool bpf_capable(void)
+{
+	return capable(CAP_BPF) || capable(CAP_SYS_ADMIN);
+}
 /* audit system wants to get cap info from files as well */
 extern int get_vfs_caps_from_disk(const struct dentry *dentry, struct cpu_vfs_cap_data *cpu_caps);

include/linux/compaction.h+1−1

@@ -86,7 +86,7 @@ static inline unsigned long compact_gap(unsigned int order) · 85 unmodified lines
86	#ifdef CONFIG_COMPACTION	86	#ifdef CONFIG_COMPACTION
87	extern int sysctl_compact_memory;	87	extern int sysctl_compact_memory;
88	extern int sysctl_compaction_handler(struct ctl_table *table, int write,	88	extern int sysctl_compaction_handler(struct ctl_table *table, int write,
89	void __user buffer, size_t length, loff_t *ppos);	89	void buffer, size_t length, loff_t *ppos);
90	extern int sysctl_extfrag_threshold;	90	extern int sysctl_extfrag_threshold;
91	extern int sysctl_compact_unevictable_allowed;	91	extern int sysctl_compact_unevictable_allowed;
92		92

include/linux/coredump.h+4−0

@@ -22,4 +22,8 @@ extern void do_coredump(const kernel_siginfo_t *siginfo); · 21 unmodified lines
22	static inline void do_coredump(const kernel_siginfo_t *siginfo) {}	22	static inline void do_coredump(const kernel_siginfo_t *siginfo) {}
23	#endif	23	#endif
24		24
		25	extern int core_uses_pid;
		26	extern char core_pattern[];
		27	extern unsigned int core_pipe_limit;
		28
25	#endif /* _LINUX_COREDUMP_H */	29	#endif /* _LINUX_COREDUMP_H */

include/linux/delay.h+11−0

@@ -65,4 +65,15 @@ static inline void ssleep(unsigned int seconds) · 64 unmodified lines
65	msleep(seconds * 1000);	65	msleep(seconds * 1000);
66	}	66	}
67		67
		68	/* see Documentation/timers/timers-howto.rst for the thresholds */
		69	static inline void fsleep(unsigned long usecs)
		70	{
		71	if (usecs <= 10)
		72	udelay(usecs);
		73	else if (usecs <= 20000)
		74	usleep_range(usecs, 2 * usecs);
		75	else
		76	msleep(DIV_ROUND_UP(usecs, 1000));
		77	}
		78
68	#endif /* defined(_LINUX_DELAY_H) */	79	#endif /* defined(_LINUX_DELAY_H) */

include/linux/dsa/8021q.h+57−0

@@ -12,11 +12,31 @@ struct sk_buff; · 11 unmodified lines
12	struct net_device;	12	struct net_device;
13	struct packet_type;	13	struct packet_type;
14		14
		15	struct dsa_8021q_crosschip_link {
		16	struct list_head list;
		17	int port;
		18	struct dsa_switch *other_ds;
		19	int other_port;
		20	refcount_t refcount;
		21	};
		22
		23	#define DSA_8021Q_N_SUBVLAN 8
		24
15	#if IS_ENABLED(CONFIG_NET_DSA_TAG_8021Q)	25	#if IS_ENABLED(CONFIG_NET_DSA_TAG_8021Q)
16		26
17	int dsa_port_setup_8021q_tagging(struct dsa_switch *ds, int index,	27	int dsa_port_setup_8021q_tagging(struct dsa_switch *ds, int index,
18	bool enabled);	28	bool enabled);
19		29
		30	int dsa_8021q_crosschip_bridge_join(struct dsa_switch *ds, int port,
		31	struct dsa_switch *other_ds,
		32	int other_port,
		33	struct list_head *crosschip_links);
		34
		35	int dsa_8021q_crosschip_bridge_leave(struct dsa_switch *ds, int port,
		36	struct dsa_switch *other_ds,
		37	int other_port,
		38	struct list_head *crosschip_links);
		39
20	struct sk_buff dsa_8021q_xmit(struct sk_buff skb, struct net_device *netdev,	40	struct sk_buff dsa_8021q_xmit(struct sk_buff skb, struct net_device *netdev,
21	u16 tpid, u16 tci);	41	u16 tpid, u16 tci);
22		42
@@ -24,10 +44,16 @@ u16 dsa_8021q_tx_vid(struct dsa_switch *ds, int port); · 1 unmodified line
24		44
25	u16 dsa_8021q_rx_vid(struct dsa_switch *ds, int port);	45	u16 dsa_8021q_rx_vid(struct dsa_switch *ds, int port);
26		46
		47	u16 dsa_8021q_rx_vid_subvlan(struct dsa_switch *ds, int port, u16 subvlan);
		48
27	int dsa_8021q_rx_switch_id(u16 vid);	49	int dsa_8021q_rx_switch_id(u16 vid);
28		50
29	int dsa_8021q_rx_source_port(u16 vid);	51	int dsa_8021q_rx_source_port(u16 vid);
30		52
		53	u16 dsa_8021q_rx_subvlan(u16 vid);
		54
		55	bool vid_is_dsa_8021q(u16 vid);
		56
31	#else	57	#else
32		58
33	int dsa_port_setup_8021q_tagging(struct dsa_switch *ds, int index,	59	int dsa_port_setup_8021q_tagging(struct dsa_switch *ds, int index,
@@ -36,6 +62,22 @@ int dsa_port_setup_8021q_tagging(struct dsa_switch *ds, int index, · 2 unmodified lines
36	return 0;	62	return 0;
37	}	63	}
38		64
		65	int dsa_8021q_crosschip_bridge_join(struct dsa_switch *ds, int port,
		66	struct dsa_switch *other_ds,
		67	int other_port,
		68	struct list_head *crosschip_links)
		69	{
		70	return 0;
		71	}
		72
		73	int dsa_8021q_crosschip_bridge_leave(struct dsa_switch *ds, int port,
		74	struct dsa_switch *other_ds,
		75	int other_port,
		76	struct list_head *crosschip_links)
		77	{
		78	return 0;
		79	}
		80
39	struct sk_buff dsa_8021q_xmit(struct sk_buff skb, struct net_device *netdev,	81	struct sk_buff dsa_8021q_xmit(struct sk_buff skb, struct net_device *netdev,
40	u16 tpid, u16 tci)	82	u16 tpid, u16 tci)
41	{	83	{
@@ -52,6 +94,11 @@ u16 dsa_8021q_rx_vid(struct dsa_switch *ds, int port) · 10 unmodified lines
52	return 0;	94	return 0;
53	}	95	}
54		96
		97	u16 dsa_8021q_rx_vid_subvlan(struct dsa_switch *ds, int port, u16 subvlan)
		98	{
		99	return 0;
		100	}
		101
55	int dsa_8021q_rx_switch_id(u16 vid)	102	int dsa_8021q_rx_switch_id(u16 vid)
56	{	103	{
57	return 0;	104	return 0;
@@ -62,6 +109,16 @@ int dsa_8021q_rx_source_port(u16 vid) · 4 unmodified lines
62	return 0;	109	return 0;
63	}	110	}
64		111
		112	u16 dsa_8021q_rx_subvlan(u16 vid)
		113	{
		114	return 0;
		115	}
		116
		117	bool vid_is_dsa_8021q(u16 vid)
		118	{
		119	return false;
		120	}
		121
65	#endif /* IS_ENABLED(CONFIG_NET_DSA_TAG_8021Q) */	122	#endif /* IS_ENABLED(CONFIG_NET_DSA_TAG_8021Q) */
66		123
67	#endif /* _NET_DSA_8021Q_H */	124	#endif /* _NET_DSA_8021Q_H */

include/linux/dsa/sja1105.h+3−0

 #include <linux/skbuff.h>
 #include <linux/etherdevice.h>
+#include <linux/dsa/8021q.h>
 #include <net/dsa.h>
 #define ETH_P_SJA1105				ETH_P_DSA_8021Q
 	((struct sja1105_skb_cb *)DSA_SKB_CB_PRIV(skb))
 struct sja1105_port {
+	u16 subvlan_map[DSA_8021Q_N_SUBVLAN];
 	struct kthread_worker *xmit_worker;
 	struct kthread_work xmit_work;
 	struct sk_buff_head xmit_queue;
 	struct sja1105_tagger_data *data;
 	struct dsa_port *dp;
 	bool hwts_tx_en;
+	u16 xmit_tpid;
 };
 #endif /* _NET_DSA_SJA1105_H */

include/linux/etherdevice.h+12−0

 #include <linux/if_ether.h>
 #include <linux/netdevice.h>
 #include <linux/random.h>
+#include <linux/crc32.h>
 #include <asm/unaligned.h>
 #include <asm/bitsperlong.h>
 	eth_random_addr(dev->dev_addr);
 }
+/**
+ * eth_hw_addr_crc - Calculate CRC from netdev_hw_addr
+ * @ha: pointer to hardware address
+ *
+ * Calculate CRC from a hardware address as basis for filter hashes.
+ */
+static inline u32 eth_hw_addr_crc(struct netdev_hw_addr *ha)
+{
+	return ether_crc(ETH_ALEN, ha->addr);
+}
 /**
  * ether_addr_copy - Copy an Ethernet address
  * @dst: Pointer to a six-byte array Ethernet address destination

include/linux/ethtool_netlink.h+54−0

@@ -14,4 +14,58 @@ enum ethtool_multicast_groups { · 13 unmodified lines
14	ETHNL_MCGRP_MONITOR,	14	ETHNL_MCGRP_MONITOR,
15	};	15	};
16		16
		17	struct phy_device;
		18
		19	#if IS_ENABLED(CONFIG_ETHTOOL_NETLINK)
		20	int ethnl_cable_test_alloc(struct phy_device *phydev, u8 cmd);
		21	void ethnl_cable_test_free(struct phy_device *phydev);
		22	void ethnl_cable_test_finished(struct phy_device *phydev);
		23	int ethnl_cable_test_result(struct phy_device *phydev, u8 pair, u8 result);
		24	int ethnl_cable_test_fault_length(struct phy_device *phydev, u8 pair, u32 cm);
		25	int ethnl_cable_test_amplitude(struct phy_device *phydev, u8 pair, s16 mV);
		26	int ethnl_cable_test_pulse(struct phy_device *phydev, u16 mV);
		27	int ethnl_cable_test_step(struct phy_device *phydev, u32 first, u32 last,
		28	u32 step);
		29	#else
		30	static inline int ethnl_cable_test_alloc(struct phy_device *phydev, u8 cmd)
		31	{
		32	return -EOPNOTSUPP;
		33	}
		34
		35	static inline void ethnl_cable_test_free(struct phy_device *phydev)
		36	{
		37	}
		38
		39	static inline void ethnl_cable_test_finished(struct phy_device *phydev)
		40	{
		41	}
		42	static inline int ethnl_cable_test_result(struct phy_device *phydev, u8 pair,
		43	u8 result)
		44	{
		45	return -EOPNOTSUPP;
		46	}
		47
		48	static inline int ethnl_cable_test_fault_length(struct phy_device *phydev,
		49	u8 pair, u32 cm)
		50	{
		51	return -EOPNOTSUPP;
		52	}
		53
		54	static inline int ethnl_cable_test_amplitude(struct phy_device *phydev,
		55	u8 pair, s16 mV)
		56	{
		57	return -EOPNOTSUPP;
		58	}
		59
		60	static inline int ethnl_cable_test_pulse(struct phy_device *phydev, u16 mV)
		61	{
		62	return -EOPNOTSUPP;
		63	}
		64
		65	static inline int ethnl_cable_test_step(struct phy_device *phydev, u32 first,
		66	u32 last, u32 step)
		67	{
		68	return -EOPNOTSUPP;
		69	}
		70	#endif /* IS_ENABLED(ETHTOOL_NETLINK) */
17	#endif /* _LINUX_ETHTOOL_NETLINK_H_ */	71	#endif /* _LINUX_ETHTOOL_NETLINK_H_ */

include/linux/file.h+2−0

@@ -94,4 +94,6 @@ extern void fd_install(unsigned int fd, struct file *file); · 93 unmodified lines
94	extern void flush_delayed_fput(void);	94	extern void flush_delayed_fput(void);
95	extern void __fput_sync(struct file *);	95	extern void __fput_sync(struct file *);
96		96
		97	extern unsigned int sysctl_nr_open_min, sysctl_nr_open_max;
		98
97	#endif /* __LINUX_FILE_H */	99	#endif /* __LINUX_FILE_H */

include/linux/filter.h+2−6

 	unsigned int		(*bpf_func)(const void *ctx,
 					    const struct bpf_insn *insn);
 	/* Instructions for interpreter */
-	union {
+	struct sock_filter	insns[0];
-		struct sock_filter	insns[0];
+	struct bpf_insn		insnsi[];
-		struct bpf_insn		insnsi[0];
-	};
 };
 struct sk_filter {
 int bpf_prog_create_from_user(struct bpf_prog **pfp, struct sock_fprog *fprog,
 			      bpf_aux_classic_check_t trans, bool save_orig);
 void bpf_prog_destroy(struct bpf_prog *fp);
-const struct bpf_func_proto *
-bpf_base_func_proto(enum bpf_func_id func_id);
 int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk);
 int sk_attach_bpf(u32 ufd, struct sock *sk);

include/linux/fs.h+3−3

@@ -3555,11 +3555,11 @@ ssize_t simple_attr_write(struct file file, const char __user buf, · 3554 unmodified lines
3555		3555
3556	struct ctl_table;	3556	struct ctl_table;
3557	int proc_nr_files(struct ctl_table *table, int write,	3557	int proc_nr_files(struct ctl_table *table, int write,
3558	void __user buffer, size_t lenp, loff_t *ppos);	3558	void buffer, size_t lenp, loff_t *ppos);
3559	int proc_nr_dentry(struct ctl_table *table, int write,	3559	int proc_nr_dentry(struct ctl_table *table, int write,
3560	void __user buffer, size_t lenp, loff_t *ppos);	3560	void buffer, size_t lenp, loff_t *ppos);
3561	int proc_nr_inodes(struct ctl_table *table, int write,	3561	int proc_nr_inodes(struct ctl_table *table, int write,
3562	void __user buffer, size_t lenp, loff_t *ppos);	3562	void buffer, size_t lenp, loff_t *ppos);
3563	int __init get_filesystem_list(char *buf);	3563	int __init get_filesystem_list(char *buf);
3564		3564
3565	#define __FMODE_EXEC ((__force int) FMODE_EXEC)	3565	#define __FMODE_EXEC ((__force int) FMODE_EXEC)

include/linux/fsl/ptp_qoriq.h+1−1

@@ -135,7 +135,7 @@ struct ptp_qoriq_registers { · 134 unmodified lines
135	#define DEFAULT_CKSEL 1	135	#define DEFAULT_CKSEL 1
136	#define DEFAULT_TMR_PRSC 2	136	#define DEFAULT_TMR_PRSC 2
137	#define DEFAULT_FIPER1_PERIOD 1000000000	137	#define DEFAULT_FIPER1_PERIOD 1000000000
138	#define DEFAULT_FIPER2_PERIOD 100000	138	#define DEFAULT_FIPER2_PERIOD 1000000000
139		139
140	struct ptp_qoriq {	140	struct ptp_qoriq {
141	void __iomem *base;	141	void __iomem *base;

include/linux/ftrace.h+1−2

@@ -1028,8 +1028,7 @@ extern void disable_trace_on_warning(void); · 1027 unmodified lines
1028	extern int __disable_trace_on_warning;	1028	extern int __disable_trace_on_warning;
1029		1029
1030	int tracepoint_printk_sysctl(struct ctl_table *table, int write,	1030	int tracepoint_printk_sysctl(struct ctl_table *table, int write,
1031	void __user buffer, size_t lenp,	1031	void buffer, size_t lenp, loff_t *ppos);
1032	loff_t *ppos);
1033		1032
1034	#else /* CONFIG_TRACING */	1033	#else /* CONFIG_TRACING */
1035	static inline void disable_trace_on_warning(void) { }	1034	static inline void disable_trace_on_warning(void) { }

include/linux/hugetlb.h+7−8

@@ -105,14 +105,13 @@ struct hugepage_subpool hugepage_new_subpool(struct hstate h, long max_hpages, · 104 unmodified lines
105	void hugepage_put_subpool(struct hugepage_subpool *spool);	105	void hugepage_put_subpool(struct hugepage_subpool *spool);
106		106
107	void reset_vma_resv_huge_pages(struct vm_area_struct *vma);	107	void reset_vma_resv_huge_pages(struct vm_area_struct *vma);
108	int hugetlb_sysctl_handler(struct ctl_table , int, void __user , size_t , loff_t );	108	int hugetlb_sysctl_handler(struct ctl_table , int, void , size_t , loff_t );
109	int hugetlb_overcommit_handler(struct ctl_table , int, void __user , size_t , loff_t );	109	int hugetlb_overcommit_handler(struct ctl_table , int, void , size_t *,
110	int hugetlb_treat_movable_handler(struct ctl_table , int, void __user , size_t , loff_t );	110	loff_t *);
111		111	int hugetlb_treat_movable_handler(struct ctl_table , int, void , size_t *,
112	#ifdef CONFIG_NUMA	112	loff_t *);
113	int hugetlb_mempolicy_sysctl_handler(struct ctl_table *, int,	113	int hugetlb_mempolicy_sysctl_handler(struct ctl_table , int, void , size_t *,
114	void __user , size_t , loff_t *);	114	loff_t *);
115	#endif
116		115
117	int copy_hugetlb_page_range(struct mm_struct , struct mm_struct , struct vm_area_struct *);	116	int copy_hugetlb_page_range(struct mm_struct , struct mm_struct , struct vm_area_struct *);
118	long follow_hugetlb_page(struct mm_struct , struct vm_area_struct ,	117	long follow_hugetlb_page(struct mm_struct , struct vm_area_struct ,

include/linux/ieee80211.h+359−8

@@ -9,7 +9,7 @@ · 8 unmodified lines
9	* Copyright (c) 2006, Michael Wu <flamingice@sourmilk.net>	9	* Copyright (c) 2006, Michael Wu <flamingice@sourmilk.net>
10	* Copyright (c) 2013 - 2014 Intel Mobile Communications GmbH	10	* Copyright (c) 2013 - 2014 Intel Mobile Communications GmbH
11	* Copyright (c) 2016 - 2017 Intel Deutschland GmbH	11	* Copyright (c) 2016 - 2017 Intel Deutschland GmbH
12	* Copyright (c) 2018 - 2019 Intel Corporation	12	* Copyright (c) 2018 - 2020 Intel Corporation
13	*/	13	*/
14		14
15	#ifndef LINUX_IEEE80211_H	15	#ifndef LINUX_IEEE80211_H
@@ -105,6 +105,51 @@ · 89 unmodified lines
105		105
106	/* extension, added by 802.11ad */	106	/* extension, added by 802.11ad */
107	#define IEEE80211_STYPE_DMG_BEACON 0x0000	107	#define IEEE80211_STYPE_DMG_BEACON 0x0000
		108	#define IEEE80211_STYPE_S1G_BEACON 0x0010
		109
		110	/* bits unique to S1G beacon */
		111	#define IEEE80211_S1G_BCN_NEXT_TBTT 0x100
		112
		113	/* see 802.11ah-2016 9.9 NDP CMAC frames */
		114	#define IEEE80211_S1G_1MHZ_NDP_BITS 25
		115	#define IEEE80211_S1G_1MHZ_NDP_BYTES 4
		116	#define IEEE80211_S1G_2MHZ_NDP_BITS 37
		117	#define IEEE80211_S1G_2MHZ_NDP_BYTES 5
		118
		119	#define IEEE80211_NDP_FTYPE_CTS 0
		120	#define IEEE80211_NDP_FTYPE_CF_END 0
		121	#define IEEE80211_NDP_FTYPE_PS_POLL 1
		122	#define IEEE80211_NDP_FTYPE_ACK 2
		123	#define IEEE80211_NDP_FTYPE_PS_POLL_ACK 3
		124	#define IEEE80211_NDP_FTYPE_BA 4
		125	#define IEEE80211_NDP_FTYPE_BF_REPORT_POLL 5
		126	#define IEEE80211_NDP_FTYPE_PAGING 6
		127	#define IEEE80211_NDP_FTYPE_PREQ 7
		128
		129	#define SM64(f, v) ((((u64)v) << f##_S) & f)
		130
		131	/* NDP CMAC frame fields */
		132	#define IEEE80211_NDP_FTYPE 0x0000000000000007
		133	#define IEEE80211_NDP_FTYPE_S 0x0000000000000000
		134
		135	/* 1M Probe Request 11ah 9.9.3.1.1 */
		136	#define IEEE80211_NDP_1M_PREQ_ANO 0x0000000000000008
		137	#define IEEE80211_NDP_1M_PREQ_ANO_S 3
		138	#define IEEE80211_NDP_1M_PREQ_CSSID 0x00000000000FFFF0
		139	#define IEEE80211_NDP_1M_PREQ_CSSID_S 4
		140	#define IEEE80211_NDP_1M_PREQ_RTYPE 0x0000000000100000
		141	#define IEEE80211_NDP_1M_PREQ_RTYPE_S 20
		142	#define IEEE80211_NDP_1M_PREQ_RSV 0x0000000001E00000
		143	#define IEEE80211_NDP_1M_PREQ_RSV 0x0000000001E00000
		144	/* 2M Probe Request 11ah 9.9.3.1.2 */
		145	#define IEEE80211_NDP_2M_PREQ_ANO 0x0000000000000008
		146	#define IEEE80211_NDP_2M_PREQ_ANO_S 3
		147	#define IEEE80211_NDP_2M_PREQ_CSSID 0x0000000FFFFFFFF0
		148	#define IEEE80211_NDP_2M_PREQ_CSSID_S 4
		149	#define IEEE80211_NDP_2M_PREQ_RTYPE 0x0000001000000000
		150	#define IEEE80211_NDP_2M_PREQ_RTYPE_S 36
		151
		152	#define IEEE80211_ANO_NETTYPE_WILD 15
108		153
109	/* control extension - for IEEE80211_FTYPE_CTL \| IEEE80211_STYPE_CTL_EXT */	154	/* control extension - for IEEE80211_FTYPE_CTL \| IEEE80211_STYPE_CTL_EXT */
110	#define IEEE80211_CTL_EXT_POLL 0x2000	155	#define IEEE80211_CTL_EXT_POLL 0x2000
@@ -121,6 +166,21 @@ · 10 unmodified lines
121	#define IEEE80211_MAX_SN IEEE80211_SN_MASK	166	#define IEEE80211_MAX_SN IEEE80211_SN_MASK
122	#define IEEE80211_SN_MODULO (IEEE80211_MAX_SN + 1)	167	#define IEEE80211_SN_MODULO (IEEE80211_MAX_SN + 1)
123		168
		169
		170	/* PV1 Layout 11ah 9.8.3.1 */
		171	#define IEEE80211_PV1_FCTL_VERS 0x0003
		172	#define IEEE80211_PV1_FCTL_FTYPE 0x001c
		173	#define IEEE80211_PV1_FCTL_STYPE 0x00e0
		174	#define IEEE80211_PV1_FCTL_TODS 0x0100
		175	#define IEEE80211_PV1_FCTL_MOREFRAGS 0x0200
		176	#define IEEE80211_PV1_FCTL_PM 0x0400
		177	#define IEEE80211_PV1_FCTL_MOREDATA 0x0800
		178	#define IEEE80211_PV1_FCTL_PROTECTED 0x1000
		179	#define IEEE80211_PV1_FCTL_END_SP 0x2000
		180	#define IEEE80211_PV1_FCTL_RELAYED 0x4000
		181	#define IEEE80211_PV1_FCTL_ACK_POLICY 0x8000
		182	#define IEEE80211_PV1_FCTL_CTL_EXT 0x0f00
		183
124	static inline bool ieee80211_sn_less(u16 sn1, u16 sn2)	184	static inline bool ieee80211_sn_less(u16 sn1, u16 sn2)
125	{	185	{
126	return ((sn1 - sn2) & IEEE80211_SN_MASK) > (IEEE80211_SN_MODULO >> 1);	186	return ((sn1 - sn2) & IEEE80211_SN_MASK) > (IEEE80211_SN_MODULO >> 1);
@@ -148,6 +208,7 @@ static inline u16 ieee80211_sn_sub(u16 sn1, u16 sn2) · 21 unmodified lines
148	#define IEEE80211_MAX_FRAG_THRESHOLD 2352	208	#define IEEE80211_MAX_FRAG_THRESHOLD 2352
149	#define IEEE80211_MAX_RTS_THRESHOLD 2353	209	#define IEEE80211_MAX_RTS_THRESHOLD 2353
150	#define IEEE80211_MAX_AID 2007	210	#define IEEE80211_MAX_AID 2007
		211	#define IEEE80211_MAX_AID_S1G 8191
151	#define IEEE80211_MAX_TIM_LEN 251	212	#define IEEE80211_MAX_TIM_LEN 251
152	#define IEEE80211_MAX_MESH_PEERINGS 63	213	#define IEEE80211_MAX_MESH_PEERINGS 63
153	/* Maximum size for the MA-UNITDATA primitive, 802.11 standard section	214	/* Maximum size for the MA-UNITDATA primitive, 802.11 standard section
@@ -371,6 +432,17 @@ static inline bool ieee80211_is_data(__le16 fc) · 217 unmodified lines
371	cpu_to_le16(IEEE80211_FTYPE_DATA);	432	cpu_to_le16(IEEE80211_FTYPE_DATA);
372	}	433	}
373		434
		435	/**
		436	* ieee80211_is_ext - check if type is IEEE80211_FTYPE_EXT
		437	* @fc: frame control bytes in little-endian byteorder
		438	*/
		439	static inline bool ieee80211_is_ext(__le16 fc)
		440	{
		441	return (fc & cpu_to_le16(IEEE80211_FCTL_FTYPE)) ==
		442	cpu_to_le16(IEEE80211_FTYPE_EXT);
		443	}
		444
		445
374	/**	446	/**
375	* ieee80211_is_data_qos - check if type is IEEE80211_FTYPE_DATA and IEEE80211_STYPE_QOS_DATA is set	447	* ieee80211_is_data_qos - check if type is IEEE80211_FTYPE_DATA and IEEE80211_STYPE_QOS_DATA is set
376	* @fc: frame control bytes in little-endian byteorder	448	* @fc: frame control bytes in little-endian byteorder
@@ -469,6 +541,18 @@ static inline bool ieee80211_is_beacon(__le16 fc) · 92 unmodified lines
469	cpu_to_le16(IEEE80211_FTYPE_MGMT \| IEEE80211_STYPE_BEACON);	541	cpu_to_le16(IEEE80211_FTYPE_MGMT \| IEEE80211_STYPE_BEACON);
470	}	542	}
471		543
		544	/**
		545	* ieee80211_is_s1g_beacon - check if IEEE80211_FTYPE_EXT &&
		546	* IEEE80211_STYPE_S1G_BEACON
		547	* @fc: frame control bytes in little-endian byteorder
		548	*/
		549	static inline bool ieee80211_is_s1g_beacon(__le16 fc)
		550	{
		551	return (fc & cpu_to_le16(IEEE80211_FCTL_FTYPE \|
		552	IEEE80211_FCTL_STYPE)) ==
		553	cpu_to_le16(IEEE80211_FTYPE_EXT \| IEEE80211_STYPE_S1G_BEACON);
		554	}
		555
472	/**	556	/**
473	* ieee80211_is_atim - check if IEEE80211_FTYPE_MGMT && IEEE80211_STYPE_ATIM	557	* ieee80211_is_atim - check if IEEE80211_FTYPE_MGMT && IEEE80211_STYPE_ATIM
474	* @fc: frame control bytes in little-endian byteorder	558	* @fc: frame control bytes in little-endian byteorder
@@ -716,7 +800,7 @@ struct ieee80211_msrment_ie { · 241 unmodified lines
716	u8 token;	800	u8 token;
717	u8 mode;	801	u8 mode;
718	u8 type;	802	u8 type;
719	u8 request[0];	803	u8 request[];
720	} __packed;	804	} __packed;
721		805
722	/**	806	/**
@@ -859,6 +943,7 @@ enum ieee80211_ht_chanwidth_values { · 136 unmodified lines
859	* @IEEE80211_OPMODE_NOTIF_CHANWIDTH_40MHZ: 40 MHz channel width	943	* @IEEE80211_OPMODE_NOTIF_CHANWIDTH_40MHZ: 40 MHz channel width
860	* @IEEE80211_OPMODE_NOTIF_CHANWIDTH_80MHZ: 80 MHz channel width	944	* @IEEE80211_OPMODE_NOTIF_CHANWIDTH_80MHZ: 80 MHz channel width
861	* @IEEE80211_OPMODE_NOTIF_CHANWIDTH_160MHZ: 160 MHz or 80+80 MHz channel width	945	* @IEEE80211_OPMODE_NOTIF_CHANWIDTH_160MHZ: 160 MHz or 80+80 MHz channel width
		946	* @IEEE80211_OPMODE_NOTIF_BW_160_80P80: 160 / 80+80 MHz indicator flag
862	* @IEEE80211_OPMODE_NOTIF_RX_NSS_MASK: number of spatial streams mask	947	* @IEEE80211_OPMODE_NOTIF_RX_NSS_MASK: number of spatial streams mask
863	* (the NSS value is the value of this field + 1)	948	* (the NSS value is the value of this field + 1)
864	* @IEEE80211_OPMODE_NOTIF_RX_NSS_SHIFT: number of spatial streams shift	949	* @IEEE80211_OPMODE_NOTIF_RX_NSS_SHIFT: number of spatial streams shift
@@ -866,11 +951,12 @@ enum ieee80211_ht_chanwidth_values { · 1 unmodified line
866	* using a beamforming steering matrix	951	* using a beamforming steering matrix
867	*/	952	*/
868	enum ieee80211_vht_opmode_bits {	953	enum ieee80211_vht_opmode_bits {
869	IEEE80211_OPMODE_NOTIF_CHANWIDTH_MASK = 3,	954	IEEE80211_OPMODE_NOTIF_CHANWIDTH_MASK = 0x03,
870	IEEE80211_OPMODE_NOTIF_CHANWIDTH_20MHZ = 0,	955	IEEE80211_OPMODE_NOTIF_CHANWIDTH_20MHZ = 0,
871	IEEE80211_OPMODE_NOTIF_CHANWIDTH_40MHZ = 1,	956	IEEE80211_OPMODE_NOTIF_CHANWIDTH_40MHZ = 1,
872	IEEE80211_OPMODE_NOTIF_CHANWIDTH_80MHZ = 2,	957	IEEE80211_OPMODE_NOTIF_CHANWIDTH_80MHZ = 2,
873	IEEE80211_OPMODE_NOTIF_CHANWIDTH_160MHZ = 3,	958	IEEE80211_OPMODE_NOTIF_CHANWIDTH_160MHZ = 3,
		959	IEEE80211_OPMODE_NOTIF_BW_160_80P80 = 0x04,
874	IEEE80211_OPMODE_NOTIF_RX_NSS_MASK = 0x70,	960	IEEE80211_OPMODE_NOTIF_RX_NSS_MASK = 0x70,
875	IEEE80211_OPMODE_NOTIF_RX_NSS_SHIFT = 4,	961	IEEE80211_OPMODE_NOTIF_RX_NSS_SHIFT = 4,
876	IEEE80211_OPMODE_NOTIF_RX_NSS_TYPE_BF = 0x80,	962	IEEE80211_OPMODE_NOTIF_RX_NSS_TYPE_BF = 0x80,
@@ -898,6 +984,59 @@ struct ieee80211_addba_ext_ie { · 21 unmodified lines
898	u8 data;	984	u8 data;
899	} __packed;	985	} __packed;
900		986
		987	/**
		988	* struct ieee80211_s1g_bcn_compat_ie
		989	*
		990	* S1G Beacon Compatibility element
		991	*/
		992	struct ieee80211_s1g_bcn_compat_ie {
		993	__le16 compat_info;
		994	__le16 beacon_int;
		995	__le32 tsf_completion;
		996	} __packed;
		997
		998	/**
		999	* struct ieee80211_s1g_oper_ie
		1000	*
		1001	* S1G Operation element
		1002	*/
		1003	struct ieee80211_s1g_oper_ie {
		1004	u8 ch_width;
		1005	u8 oper_class;
		1006	u8 primary_ch;
		1007	u8 oper_ch;
		1008	__le16 basic_mcs_nss;
		1009	} __packed;
		1010
		1011	/**
		1012	* struct ieee80211_aid_response_ie
		1013	*
		1014	* AID Response element
		1015	*/
		1016	struct ieee80211_aid_response_ie {
		1017	__le16 aid;
		1018	u8 switch_count;
		1019	__le16 response_int;
		1020	} __packed;
		1021
		1022	struct ieee80211_s1g_cap {
		1023	u8 capab_info[10];
		1024	u8 supp_mcs_nss[5];
		1025	} __packed;
		1026
		1027	struct ieee80211_ext {
		1028	__le16 frame_control;
		1029	__le16 duration;
		1030	union {
		1031	struct {
		1032	u8 sa[ETH_ALEN];
		1033	__le32 timestamp;
		1034	u8 change_seq;
		1035	u8 variable[0];
		1036	} __packed s1g_beacon;
		1037	} u;
		1038	} __packed __aligned(2);
		1039
901	struct ieee80211_mgmt {	1040	struct ieee80211_mgmt {
902	__le16 frame_control;	1041	__le16 frame_control;
903	__le16 duration;	1042	__le16 duration;
@@ -1065,6 +1204,7 @@ struct ieee80211_mgmt { · 161 unmodified lines
1065	/* Supported rates membership selectors */	1204	/* Supported rates membership selectors */
1066	#define BSS_MEMBERSHIP_SELECTOR_HT_PHY 127	1205	#define BSS_MEMBERSHIP_SELECTOR_HT_PHY 127
1067	#define BSS_MEMBERSHIP_SELECTOR_VHT_PHY 126	1206	#define BSS_MEMBERSHIP_SELECTOR_VHT_PHY 126
		1207	#define BSS_MEMBERSHIP_SELECTOR_HE_PHY 122
1068		1208
1069	/* mgmt header + 1 byte category code */	1209	/* mgmt header + 1 byte category code */
1070	#define IEEE80211_MIN_ACTION_SIZE offsetof(struct ieee80211_mgmt, u.action.u)	1210	#define IEEE80211_MIN_ACTION_SIZE offsetof(struct ieee80211_mgmt, u.action.u)
@@ -1641,7 +1781,7 @@ struct ieee80211_he_operation { · 570 unmodified lines
1641	__le32 he_oper_params;	1781	__le32 he_oper_params;
1642	__le16 he_mcs_nss_set;	1782	__le16 he_mcs_nss_set;
1643	/* Optional 0,1,3,4,5,7 or 8 bytes: depends on @he_oper_params */	1783	/* Optional 0,1,3,4,5,7 or 8 bytes: depends on @he_oper_params */
1644	u8 optional[0];	1784	u8 optional[];
1645	} __packed;	1785	} __packed;
1646		1786
1647	/**	1787	/**
@@ -1653,7 +1793,7 @@ struct ieee80211_he_operation { · 5 unmodified lines
1653	struct ieee80211_he_spr {	1793	struct ieee80211_he_spr {
1654	u8 he_sr_control;	1794	u8 he_sr_control;
1655	/* Optional 0 to 19 bytes: depends on @he_sr_control */	1795	/* Optional 0 to 19 bytes: depends on @he_sr_control */
1656	u8 optional[0];	1796	u8 optional[];
1657	} __packed;	1797	} __packed;
1658		1798
1659	/**	1799	/**
@@ -1731,6 +1871,9 @@ struct ieee80211_mu_edca_param_set { · 71 unmodified lines
1731	* @ext_nss_bw_capable: indicates whether or not the local transmitter	1871	* @ext_nss_bw_capable: indicates whether or not the local transmitter
1732	* (rate scaling algorithm) can deal with the new logic	1872	* (rate scaling algorithm) can deal with the new logic
1733	* (dot11VHTExtendedNSSBWCapable)	1873	* (dot11VHTExtendedNSSBWCapable)
		1874	* @max_vht_nss: current maximum NSS as advertised by the STA in
		1875	* operating mode notification, can be 0 in which case the
		1876	* capability data will be used to derive this (from MCS support)
1734	*	1877	*
1735	* Due to the VHT Extended NSS Bandwidth Support, the maximum NSS can	1878	* Due to the VHT Extended NSS Bandwidth Support, the maximum NSS can
1736	* vary for a given BW/MCS. This function parses the data.	1879	* vary for a given BW/MCS. This function parses the data.
@@ -1739,7 +1882,8 @@ struct ieee80211_mu_edca_param_set { · 2 unmodified lines
1739	*/	1882	*/
1740	int ieee80211_get_vht_max_nss(struct ieee80211_vht_cap *cap,	1883	int ieee80211_get_vht_max_nss(struct ieee80211_vht_cap *cap,
1741	enum ieee80211_vht_chanwidth bw,	1884	enum ieee80211_vht_chanwidth bw,
1742	int mcs, bool ext_nss_bw_capable);	1885	int mcs, bool ext_nss_bw_capable,
		1886	unsigned int max_vht_nss);
1743		1887
1744	/* 802.11ax HE MAC capabilities */	1888	/* 802.11ax HE MAC capabilities */
1745	#define IEEE80211_HE_MAC_CAP0_HTC_HE 0x01	1889	#define IEEE80211_HE_MAC_CAP0_HTC_HE 0x01
@@ -1814,6 +1958,8 @@ int ieee80211_get_vht_max_nss(struct ieee80211_vht_cap *cap, · 68 unmodified lines
1814	#define IEEE80211_HE_MAC_CAP3_FLEX_TWT_SCHED 0x40	1958	#define IEEE80211_HE_MAC_CAP3_FLEX_TWT_SCHED 0x40
1815	#define IEEE80211_HE_MAC_CAP3_RX_CTRL_FRAME_TO_MULTIBSS 0x80	1959	#define IEEE80211_HE_MAC_CAP3_RX_CTRL_FRAME_TO_MULTIBSS 0x80
1816		1960
		1961	#define IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_SHIFT 3
		1962
1817	#define IEEE80211_HE_MAC_CAP4_BSRP_BQRP_A_MPDU_AGG 0x01	1963	#define IEEE80211_HE_MAC_CAP4_BSRP_BQRP_A_MPDU_AGG 0x01
1818	#define IEEE80211_HE_MAC_CAP4_QTP 0x02	1964	#define IEEE80211_HE_MAC_CAP4_QTP 0x02
1819	#define IEEE80211_HE_MAC_CAP4_BQR 0x04	1965	#define IEEE80211_HE_MAC_CAP4_BQR 0x04
@@ -1835,6 +1981,9 @@ int ieee80211_get_vht_max_nss(struct ieee80211_vht_cap *cap, · 15 unmodified lines
1835	#define IEEE80211_HE_MAC_CAP5_PUNCTURED_SOUNDING 0x40	1981	#define IEEE80211_HE_MAC_CAP5_PUNCTURED_SOUNDING 0x40
1836	#define IEEE80211_HE_MAC_CAP5_HT_VHT_TRIG_FRAME_RX 0x80	1982	#define IEEE80211_HE_MAC_CAP5_HT_VHT_TRIG_FRAME_RX 0x80
1837		1983
		1984	#define IEEE80211_HE_VHT_MAX_AMPDU_FACTOR 20
		1985	#define IEEE80211_HE_HT_MAX_AMPDU_FACTOR 16
		1986
1838	/* 802.11ax HE PHY capabilities */	1987	/* 802.11ax HE PHY capabilities */
1839	#define IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_IN_2G 0x02	1988	#define IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_IN_2G 0x02
1840	#define IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G 0x04	1989	#define IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G 0x04
@@ -2060,6 +2209,28 @@ ieee80211_he_ppe_size(u8 ppe_thres_hdr, const u8 *phy_cap_info) · 219 unmodified lines
2060	#define IEEE80211_HE_OPERATION_PARTIAL_BSS_COLOR 0x40000000	2209	#define IEEE80211_HE_OPERATION_PARTIAL_BSS_COLOR 0x40000000
2061	#define IEEE80211_HE_OPERATION_BSS_COLOR_DISABLED 0x80000000	2210	#define IEEE80211_HE_OPERATION_BSS_COLOR_DISABLED 0x80000000
2062		2211
		2212	/**
		2213	* ieee80211_he_6ghz_oper - HE 6 GHz operation Information field
		2214	* @primary: primary channel
		2215	* @control: control flags
		2216	* @ccfs0: channel center frequency segment 0
		2217	* @ccfs1: channel center frequency segment 1
		2218	* @minrate: minimum rate (in 1 Mbps units)
		2219	*/
		2220	struct ieee80211_he_6ghz_oper {
		2221	u8 primary;
		2222	#define IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH 0x3
		2223	#define IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_20MHZ 0
		2224	#define IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_40MHZ 1
		2225	#define IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_80MHZ 2
		2226	#define IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_160MHZ 3
		2227	#define IEEE80211_HE_6GHZ_OPER_CTRL_DUP_BEACON 0x4
		2228	u8 control;
		2229	u8 ccfs0;
		2230	u8 ccfs1;
		2231	u8 minrate;
		2232	} __packed;
		2233
2063	/*	2234	/*
2064	* ieee80211_he_oper_size - calculate 802.11ax HE Operations IE size	2235	* ieee80211_he_oper_size - calculate 802.11ax HE Operations IE size
2065	* @he_oper_ie: byte data of the He Operations IE, stating from the byte	2236	* @he_oper_ie: byte data of the He Operations IE, stating from the byte
@@ -2086,7 +2257,7 @@ ieee80211_he_oper_size(const u8 *he_oper_ie) · 20 unmodified lines
2086	if (he_oper_params & IEEE80211_HE_OPERATION_CO_HOSTED_BSS)	2257	if (he_oper_params & IEEE80211_HE_OPERATION_CO_HOSTED_BSS)
2087	oper_len++;	2258	oper_len++;
2088	if (he_oper_params & IEEE80211_HE_OPERATION_6GHZ_OP_INFO)	2259	if (he_oper_params & IEEE80211_HE_OPERATION_6GHZ_OP_INFO)
2089	oper_len += 4;	2260	oper_len += sizeof(struct ieee80211_he_6ghz_oper);
2090		2261
2091	/* Add the first byte (extension ID) to the total length */	2262	/* Add the first byte (extension ID) to the total length */
2092	oper_len++;	2263	oper_len++;
@@ -2094,6 +2265,34 @@ ieee80211_he_oper_size(const u8 *he_oper_ie) · 1 unmodified line
2094	return oper_len;	2265	return oper_len;
2095	}	2266	}
2096		2267
		2268	/**
		2269	* ieee80211_he_6ghz_oper - obtain 6 GHz operation field
		2270	* @he_oper: HE operation element (must be pre-validated for size)
		2271	* but may be %NULL
		2272	*
		2273	* Return: a pointer to the 6 GHz operation field, or %NULL
		2274	*/
		2275	static inline const struct ieee80211_he_6ghz_oper *
		2276	ieee80211_he_6ghz_oper(const struct ieee80211_he_operation *he_oper)
		2277	{
		2278	const u8 ret = (void )&he_oper->optional;
		2279	u32 he_oper_params;
		2280
		2281	if (!he_oper)
		2282	return NULL;
		2283
		2284	he_oper_params = le32_to_cpu(he_oper->he_oper_params);
		2285
		2286	if (!(he_oper_params & IEEE80211_HE_OPERATION_6GHZ_OP_INFO))
		2287	return NULL;
		2288	if (he_oper_params & IEEE80211_HE_OPERATION_VHT_OPER_INFO)
		2289	ret += 3;
		2290	if (he_oper_params & IEEE80211_HE_OPERATION_CO_HOSTED_BSS)
		2291	ret++;
		2292
		2293	return (void *)ret;
		2294	}
		2295
2097	/* HE Spatial Reuse defines */	2296	/* HE Spatial Reuse defines */
2098	#define IEEE80211_HE_SPR_NON_SRG_OFFSET_PRESENT 0x4	2297	#define IEEE80211_HE_SPR_NON_SRG_OFFSET_PRESENT 0x4
2099	#define IEEE80211_HE_SPR_SRG_INFORMATION_PRESENT 0x8	2298	#define IEEE80211_HE_SPR_SRG_INFORMATION_PRESENT 0x8
@@ -2130,6 +2329,86 @@ ieee80211_he_spr_size(const u8 *he_spr_ie) · 30 unmodified lines
2130	return spr_len;	2329	return spr_len;
2131	}	2330	}
2132		2331
		2332	/* S1G Capabilities Information field */
		2333	#define S1G_CAPAB_B0_S1G_LONG BIT(0)
		2334	#define S1G_CAPAB_B0_SGI_1MHZ BIT(1)
		2335	#define S1G_CAPAB_B0_SGI_2MHZ BIT(2)
		2336	#define S1G_CAPAB_B0_SGI_4MHZ BIT(3)
		2337	#define S1G_CAPAB_B0_SGI_8MHZ BIT(4)
		2338	#define S1G_CAPAB_B0_SGI_16MHZ BIT(5)
		2339	#define S1G_CAPAB_B0_SUPP_CH_WIDTH_MASK (BIT(6) \| BIT(7))
		2340	#define S1G_CAPAB_B0_SUPP_CH_WIDTH_SHIFT 6
		2341
		2342	#define S1G_CAPAB_B1_RX_LDPC BIT(0)
		2343	#define S1G_CAPAB_B1_TX_STBC BIT(1)
		2344	#define S1G_CAPAB_B1_RX_STBC BIT(2)
		2345	#define S1G_CAPAB_B1_SU_BFER BIT(3)
		2346	#define S1G_CAPAB_B1_SU_BFEE BIT(4)
		2347	#define S1G_CAPAB_B1_BFEE_STS_MASK (BIT(5) \| BIT(6) \| BIT(7))
		2348	#define S1G_CAPAB_B1_BFEE_STS_SHIFT 5
		2349
		2350	#define S1G_CAPAB_B2_SOUNDING_DIMENSIONS_MASK (BIT(0) \| BIT(1) \| BIT(2))
		2351	#define S1G_CAPAB_B2_SOUNDING_DIMENSIONS_SHIFT 0
		2352	#define S1G_CAPAB_B2_MU_BFER BIT(3)
		2353	#define S1G_CAPAB_B2_MU_BFEE BIT(4)
		2354	#define S1G_CAPAB_B2_PLUS_HTC_VHT BIT(5)
		2355	#define S1G_CAPAB_B2_TRAVELING_PILOT_MASK (BIT(6) \| BIT(7))
		2356	#define S1G_CAPAB_B2_TRAVELING_PILOT_SHIFT 6
		2357
		2358	#define S1G_CAPAB_B3_RD_RESPONDER BIT(0)
		2359	#define S1G_CAPAB_B3_HT_DELAYED_BA BIT(1)
		2360	#define S1G_CAPAB_B3_MAX_MPDU_LEN BIT(2)
		2361	#define S1G_CAPAB_B3_MAX_AMPDU_LEN_EXP_MASK (BIT(3) \| BIT(4))
		2362	#define S1G_CAPAB_B3_MAX_AMPDU_LEN_EXP_SHIFT 3
		2363	#define S1G_CAPAB_B3_MIN_MPDU_START_MASK (BIT(5) \| BIT(6) \| BIT(7))
		2364	#define S1G_CAPAB_B3_MIN_MPDU_START_SHIFT 5
		2365
		2366	#define S1G_CAPAB_B4_UPLINK_SYNC BIT(0)
		2367	#define S1G_CAPAB_B4_DYNAMIC_AID BIT(1)
		2368	#define S1G_CAPAB_B4_BAT BIT(2)
		2369	#define S1G_CAPAB_B4_TIME_ADE BIT(3)
		2370	#define S1G_CAPAB_B4_NON_TIM BIT(4)
		2371	#define S1G_CAPAB_B4_GROUP_AID BIT(5)
		2372	#define S1G_CAPAB_B4_STA_TYPE_MASK (BIT(6) \| BIT(7))
		2373	#define S1G_CAPAB_B4_STA_TYPE_SHIFT 6
		2374
		2375	#define S1G_CAPAB_B5_CENT_AUTH_CONTROL BIT(0)
		2376	#define S1G_CAPAB_B5_DIST_AUTH_CONTROL BIT(1)
		2377	#define S1G_CAPAB_B5_AMSDU BIT(2)
		2378	#define S1G_CAPAB_B5_AMPDU BIT(3)
		2379	#define S1G_CAPAB_B5_ASYMMETRIC_BA BIT(4)
		2380	#define S1G_CAPAB_B5_FLOW_CONTROL BIT(5)
		2381	#define S1G_CAPAB_B5_SECTORIZED_BEAM_MASK (BIT(6) \| BIT(7))
		2382	#define S1G_CAPAB_B5_SECTORIZED_BEAM_SHIFT 6
		2383
		2384	#define S1G_CAPAB_B6_OBSS_MITIGATION BIT(0)
		2385	#define S1G_CAPAB_B6_FRAGMENT_BA BIT(1)
		2386	#define S1G_CAPAB_B6_NDP_PS_POLL BIT(2)
		2387	#define S1G_CAPAB_B6_RAW_OPERATION BIT(3)
		2388	#define S1G_CAPAB_B6_PAGE_SLICING BIT(4)
		2389	#define S1G_CAPAB_B6_TXOP_SHARING_IMP_ACK BIT(5)
		2390	#define S1G_CAPAB_B6_VHT_LINK_ADAPT_MASK (BIT(6) \| BIT(7))
		2391	#define S1G_CAPAB_B6_VHT_LINK_ADAPT_SHIFT 6
		2392
		2393	#define S1G_CAPAB_B7_TACK_AS_PS_POLL BIT(0)
		2394	#define S1G_CAPAB_B7_DUP_1MHZ BIT(1)
		2395	#define S1G_CAPAB_B7_MCS_NEGOTIATION BIT(2)
		2396	#define S1G_CAPAB_B7_1MHZ_CTL_RESPONSE_PREAMBLE BIT(3)
		2397	#define S1G_CAPAB_B7_NDP_BFING_REPORT_POLL BIT(4)
		2398	#define S1G_CAPAB_B7_UNSOLICITED_DYN_AID BIT(5)
		2399	#define S1G_CAPAB_B7_SECTOR_TRAINING_OPERATION BIT(6)
		2400	#define S1G_CAPAB_B7_TEMP_PS_MODE_SWITCH BIT(7)
		2401
		2402	#define S1G_CAPAB_B8_TWT_GROUPING BIT(0)
		2403	#define S1G_CAPAB_B8_BDT BIT(1)
		2404	#define S1G_CAPAB_B8_COLOR_MASK (BIT(2) \| BIT(3) \| BIT(4))
		2405	#define S1G_CAPAB_B8_COLOR_SHIFT 2
		2406	#define S1G_CAPAB_B8_TWT_REQUEST BIT(5)
		2407	#define S1G_CAPAB_B8_TWT_RESPOND BIT(6)
		2408	#define S1G_CAPAB_B8_PV1_FRAME BIT(7)
		2409
		2410	#define S1G_CAPAB_B9_LINK_ADAPT_PER_CONTROL_RESPONSE BIT(0)
		2411
2133	/* Authentication algorithms */	2412	/* Authentication algorithms */
2134	#define WLAN_AUTH_OPEN 0	2413	#define WLAN_AUTH_OPEN 0
2135	#define WLAN_AUTH_SHARED_KEY 1	2414	#define WLAN_AUTH_SHARED_KEY 1
@@ -2525,8 +2804,14 @@ enum ieee80211_eid { · 389 unmodified lines
2525	WLAN_EID_QUIET_CHANNEL = 198,	2804	WLAN_EID_QUIET_CHANNEL = 198,
2526	WLAN_EID_OPMODE_NOTIF = 199,	2805	WLAN_EID_OPMODE_NOTIF = 199,
2527		2806
		2807	WLAN_EID_REDUCED_NEIGHBOR_REPORT = 201,
		2808
		2809	WLAN_EID_S1G_BCN_COMPAT = 213,
		2810	WLAN_EID_S1G_SHORT_BCN_INTERVAL = 214,
		2811	WLAN_EID_S1G_CAPABILITIES = 217,
2528	WLAN_EID_VENDOR_SPECIFIC = 221,	2812	WLAN_EID_VENDOR_SPECIFIC = 221,
2529	WLAN_EID_QOS_PARAMETER = 222,	2813	WLAN_EID_QOS_PARAMETER = 222,
		2814	WLAN_EID_S1G_OPERATION = 232,
2530	WLAN_EID_CAG_NUMBER = 237,	2815	WLAN_EID_CAG_NUMBER = 237,
2531	WLAN_EID_AP_CSN = 239,	2816	WLAN_EID_AP_CSN = 239,
2532	WLAN_EID_FILS_INDICATION = 240,	2817	WLAN_EID_FILS_INDICATION = 240,
@@ -2554,9 +2839,19 @@ enum ieee80211_eid_ext { · 21 unmodified lines
2554	WLAN_EID_EXT_UORA = 37,	2839	WLAN_EID_EXT_UORA = 37,
2555	WLAN_EID_EXT_HE_MU_EDCA = 38,	2840	WLAN_EID_EXT_HE_MU_EDCA = 38,
2556	WLAN_EID_EXT_HE_SPR = 39,	2841	WLAN_EID_EXT_HE_SPR = 39,
		2842	WLAN_EID_EXT_NDP_FEEDBACK_REPORT_PARAMSET = 41,
		2843	WLAN_EID_EXT_BSS_COLOR_CHG_ANN = 42,
		2844	WLAN_EID_EXT_QUIET_TIME_PERIOD_SETUP = 43,
		2845	WLAN_EID_EXT_ESS_REPORT = 45,
		2846	WLAN_EID_EXT_OPS = 46,
		2847	WLAN_EID_EXT_HE_BSS_LOAD = 47,
2557	WLAN_EID_EXT_MAX_CHANNEL_SWITCH_TIME = 52,	2848	WLAN_EID_EXT_MAX_CHANNEL_SWITCH_TIME = 52,
2558	WLAN_EID_EXT_MULTIPLE_BSSID_CONFIGURATION = 55,	2849	WLAN_EID_EXT_MULTIPLE_BSSID_CONFIGURATION = 55,
2559	WLAN_EID_EXT_NON_INHERITANCE = 56,	2850	WLAN_EID_EXT_NON_INHERITANCE = 56,
		2851	WLAN_EID_EXT_KNOWN_BSSID = 57,
		2852	WLAN_EID_EXT_SHORT_SSID_LIST = 58,
		2853	WLAN_EID_EXT_HE_6GHZ_CAPA = 59,
		2854	WLAN_EID_EXT_UL_MU_POWER_CAPA = 60,
2560	};	2855	};
2561		2856
2562	/* Action category code */	2857	/* Action category code */
@@ -2787,7 +3082,7 @@ enum ieee80211_tdls_actioncode { · 224 unmodified lines
2787	#define WLAN_EXT_CAPA10_OBSS_NARROW_BW_RU_TOLERANCE_SUPPORT BIT(7)	3082	#define WLAN_EXT_CAPA10_OBSS_NARROW_BW_RU_TOLERANCE_SUPPORT BIT(7)
2788		3083
2789	/* Defines support for enhanced multi-bssid advertisement*/	3084	/* Defines support for enhanced multi-bssid advertisement*/
2790	#define WLAN_EXT_CAPA11_EMA_SUPPORT BIT(1)	3085	#define WLAN_EXT_CAPA11_EMA_SUPPORT BIT(3)
2791		3086
2792	/* TDLS specific payload type in the LLC/SNAP header */	3087	/* TDLS specific payload type in the LLC/SNAP header */
2793	#define WLAN_TDLS_SNAP_RFTYPE 0x2	3088	#define WLAN_TDLS_SNAP_RFTYPE 0x2
@@ -3099,6 +3394,24 @@ struct ieee80211_tspec_ie { · 305 unmodified lines
3099	__le16 medium_time;	3394	__le16 medium_time;
3100	} __packed;	3395	} __packed;
3101		3396
		3397	struct ieee80211_he_6ghz_capa {
		3398	/* uses IEEE80211_HE_6GHZ_CAP_* below */
		3399	__le16 capa;
		3400	} __packed;
		3401
		3402	/* HE 6 GHz band capabilities */
		3403	/* uses enum ieee80211_min_mpdu_spacing values */
		3404	#define IEEE80211_HE_6GHZ_CAP_MIN_MPDU_START 0x0007
		3405	/* uses enum ieee80211_vht_max_ampdu_length_exp values */
		3406	#define IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP 0x0038
		3407	/* uses IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_* values */
		3408	#define IEEE80211_HE_6GHZ_CAP_MAX_MPDU_LEN 0x00c0
		3409	/* WLAN_HT_CAP_SM_PS_* values */
		3410	#define IEEE80211_HE_6GHZ_CAP_SM_PS 0x0600
		3411	#define IEEE80211_HE_6GHZ_CAP_RD_RESPONDER 0x0800
		3412	#define IEEE80211_HE_6GHZ_CAP_RX_ANTPAT_CONS 0x1000
		3413	#define IEEE80211_HE_6GHZ_CAP_TX_ANTPAT_CONS 0x2000
		3414
3102	/**	3415	/**
3103	* ieee80211_get_qos_ctl - get pointer to qos control bytes	3416	* ieee80211_get_qos_ctl - get pointer to qos control bytes
3104	* @hdr: the frame	3417	* @hdr: the frame
@@ -3323,6 +3636,18 @@ static inline int ieee80211_get_tdls_action(struct sk_buff *skb, u32 hdr_size) · 218 unmodified lines
3323	#define TU_TO_JIFFIES(x) (usecs_to_jiffies((x) * 1024))	3636	#define TU_TO_JIFFIES(x) (usecs_to_jiffies((x) * 1024))
3324	#define TU_TO_EXP_TIME(x) (jiffies + TU_TO_JIFFIES(x))	3637	#define TU_TO_EXP_TIME(x) (jiffies + TU_TO_JIFFIES(x))
3325		3638
		3639	/* convert frequencies */
		3640	#define MHZ_TO_KHZ(freq) ((freq) * 1000)
		3641	#define KHZ_TO_MHZ(freq) ((freq) / 1000)
		3642	#define PR_KHZ(f) KHZ_TO_MHZ(f), f % 1000
		3643	#define KHZ_F "%d.%03d"
		3644
		3645	/* convert powers */
		3646	#define DBI_TO_MBI(gain) ((gain) * 100)
		3647	#define MBI_TO_DBI(gain) ((gain) / 100)
		3648	#define DBM_TO_MBM(gain) ((gain) * 100)
		3649	#define MBM_TO_DBM(gain) ((gain) / 100)
		3650
3326	/**	3651	/**
3327	* ieee80211_action_contains_tpc - checks if the frame contains TPC element	3652	* ieee80211_action_contains_tpc - checks if the frame contains TPC element
3328	* @skb: the skb containing the frame, length will be checked	3653	* @skb: the skb containing the frame, length will be checked
@@ -3430,4 +3755,30 @@ static inline bool for_each_element_completed(const struct element *element, · 101 unmodified lines
3430	#define WLAN_RSNX_CAPA_PROTECTED_TWT BIT(4)	3755	#define WLAN_RSNX_CAPA_PROTECTED_TWT BIT(4)
3431	#define WLAN_RSNX_CAPA_SAE_H2E BIT(5)	3756	#define WLAN_RSNX_CAPA_SAE_H2E BIT(5)
3432		3757
		3758	/*
		3759	* reduced neighbor report, based on Draft P802.11ax_D5.0,
		3760	* section 9.4.2.170
		3761	*/
		3762	#define IEEE80211_AP_INFO_TBTT_HDR_TYPE 0x03
		3763	#define IEEE80211_AP_INFO_TBTT_HDR_FILTERED 0x04
		3764	#define IEEE80211_AP_INFO_TBTT_HDR_COLOC 0x08
		3765	#define IEEE80211_AP_INFO_TBTT_HDR_COUNT 0xF0
		3766	#define IEEE80211_TBTT_INFO_OFFSET_BSSID_BSS_PARAM 8
		3767	#define IEEE80211_TBTT_INFO_OFFSET_BSSID_SSSID_BSS_PARAM 12
		3768
		3769	#define IEEE80211_RNR_TBTT_PARAMS_OCT_RECOMMENDED 0x01
		3770	#define IEEE80211_RNR_TBTT_PARAMS_SAME_SSID 0x02
		3771	#define IEEE80211_RNR_TBTT_PARAMS_MULTI_BSSID 0x04
		3772	#define IEEE80211_RNR_TBTT_PARAMS_TRANSMITTED_BSSID 0x08
		3773	#define IEEE80211_RNR_TBTT_PARAMS_COLOC_ESS 0x10
		3774	#define IEEE80211_RNR_TBTT_PARAMS_PROBE_ACTIVE 0x20
		3775	#define IEEE80211_RNR_TBTT_PARAMS_COLOC_AP 0x40
		3776
		3777	struct ieee80211_neighbor_ap_info {
		3778	u8 tbtt_info_hdr;
		3779	u8 tbtt_info_len;
		3780	u8 op_class;
		3781	u8 channel;
		3782	} __packed;
		3783
3433	#endif /* LINUX_IEEE80211_H */	3784	#endif /* LINUX_IEEE80211_H */

include/linux/if_bridge.h+2−0

@@ -47,6 +47,8 @@ struct br_ip_list { · 46 unmodified lines
47	#define BR_BCAST_FLOOD BIT(14)	47	#define BR_BCAST_FLOOD BIT(14)
48	#define BR_NEIGH_SUPPRESS BIT(15)	48	#define BR_NEIGH_SUPPRESS BIT(15)
49	#define BR_ISOLATED BIT(16)	49	#define BR_ISOLATED BIT(16)
		50	#define BR_MRP_AWARE BIT(17)
		51	#define BR_MRP_LOST_CONT BIT(18)
50		52
51	#define BR_DEFAULT_AGEING_TIME (300 * HZ)	53	#define BR_DEFAULT_AGEING_TIME (300 * HZ)
52		54

include/linux/if_team.h+2−5

 	u16 queue_id;
 	struct list_head qom_list; /* node in queue override mapping list */
 	struct rcu_head	rcu;
-	long mode_priv[0];
+	long mode_priv[];
 };
 static inline struct team_port *team_port_get_rcu(const struct net_device *dev)
 static inline void team_netpoll_send_skb(struct team_port *port,
 					 struct sk_buff *skb)
 {
-	struct netpoll *np = port->np;
+	netpoll_send_skb(port->np, skb);
-	if (np)
-		netpoll_send_skb(np, skb);
 }
 #else
 static inline void team_netpoll_send_skb(struct team_port *port,

include/linux/igmp.h+1−1

@@ -123,7 +123,7 @@ extern int ip_mc_msfilter(struct sock sk, struct ip_msfilter msf,int ifindex); · 122 unmodified lines
123	extern int ip_mc_msfget(struct sock sk, struct ip_msfilter msf,	123	extern int ip_mc_msfget(struct sock sk, struct ip_msfilter msf,
124	struct ip_msfilter __user optval, int __user optlen);	124	struct ip_msfilter __user optval, int __user optlen);
125	extern int ip_mc_gsfget(struct sock sk, struct group_filter gsf,	125	extern int ip_mc_gsfget(struct sock sk, struct group_filter gsf,
126	struct group_filter __user optval, int __user optlen);	126	struct sockaddr_storage __user *p);
127	extern int ip_mc_sf_allow(struct sock *sk, __be32 local, __be32 rmt,	127	extern int ip_mc_sf_allow(struct sock *sk, __be32 local, __be32 rmt,
128	int dif, int sdif);	128	int dif, int sdif);
129	extern void ip_mc_init_dev(struct in_device *);	129	extern void ip_mc_init_dev(struct in_device *);

include/linux/inet_diag.h+5−1

 		+ nla_total_size(1)  /* INET_DIAG_SKV6ONLY */
 #endif
 		+ nla_total_size(4)  /* INET_DIAG_MARK */
-		+ nla_total_size(4); /* INET_DIAG_CLASS_ID */
+		+ nla_total_size(4)  /* INET_DIAG_CLASS_ID */
+#ifdef CONFIG_SOCK_CGROUP_DATA
+		+ nla_total_size_64bit(sizeof(u64))  /* INET_DIAG_CGROUP_ID */
+#endif
+		;
 }
 int inet_diag_msg_attrs_fill(struct sock *sk, struct sk_buff *skb,
 			     struct inet_diag_msg *r, int ext,

include/linux/iopoll.h+43−19

@@ -57,6 +57,48 @@ · 56 unmodified lines
57	(cond) ? 0 : -ETIMEDOUT; \	57	(cond) ? 0 : -ETIMEDOUT; \
58	})	58	})
59		59
		60	/**
		61	* read_poll_timeout_atomic - Periodically poll an address until a condition is
		62	* met or a timeout occurs
		63	* @op: accessor function (takes @addr as its only argument)
		64	* @addr: Address to poll
		65	* @val: Variable to read the value into
		66	* @cond: Break condition (usually involving @val)
		67	* @delay_us: Time to udelay between reads in us (0 tight-loops). Should
		68	* be less than ~10us since udelay is used (see
		69	* Documentation/timers/timers-howto.rst).
		70	* @timeout_us: Timeout in us, 0 means never timeout
		71	* @delay_before_read: if it is true, delay @delay_us before read.
		72	*
		73	* Returns 0 on success and -ETIMEDOUT upon a timeout. In either
		74	* case, the last read value at @args is stored in @val.
		75	*
		76	* When available, you'll probably want to use one of the specialized
		77	* macros defined below rather than this macro directly.
		78	*/
		79	#define read_poll_timeout_atomic(op, val, cond, delay_us, timeout_us, \
		80	delay_before_read, args...) \
		81	({ \
		82	u64 __timeout_us = (timeout_us); \
		83	unsigned long __delay_us = (delay_us); \
		84	ktime_t __timeout = ktime_add_us(ktime_get(), __timeout_us); \
		85	if (delay_before_read && __delay_us) \
		86	udelay(__delay_us); \
		87	for (;;) { \
		88	(val) = op(args); \
		89	if (cond) \
		90	break; \
		91	if (__timeout_us && \
		92	ktime_compare(ktime_get(), __timeout) > 0) { \
		93	(val) = op(args); \
		94	break; \
		95	} \
		96	if (__delay_us) \
		97	udelay(__delay_us); \
		98	} \
		99	(cond) ? 0 : -ETIMEDOUT; \
		100	})
		101
60	/**	102	/**
61	* readx_poll_timeout - Periodically poll an address until a condition is met or a timeout occurs	103	* readx_poll_timeout - Periodically poll an address until a condition is met or a timeout occurs
62	* @op: accessor function (takes @addr as its only argument)	104	* @op: accessor function (takes @addr as its only argument)
@@ -96,25 +138,7 @@ · 33 unmodified lines
96	* macros defined below rather than this macro directly.	138	* macros defined below rather than this macro directly.
97	*/	139	*/
98	#define readx_poll_timeout_atomic(op, addr, val, cond, delay_us, timeout_us) \	140	#define readx_poll_timeout_atomic(op, addr, val, cond, delay_us, timeout_us) \
99	({ \	141	read_poll_timeout_atomic(op, val, cond, delay_us, timeout_us, false, addr)
100	u64 __timeout_us = (timeout_us); \
101	unsigned long __delay_us = (delay_us); \
102	ktime_t __timeout = ktime_add_us(ktime_get(), __timeout_us); \
103	for (;;) { \
104	(val) = op(addr); \
105	if (cond) \
106	break; \
107	if (__timeout_us && \
108	ktime_compare(ktime_get(), __timeout) > 0) { \
109	(val) = op(addr); \
110	break; \
111	} \
112	if (__delay_us) \
113	udelay(__delay_us); \
114	} \
115	(cond) ? 0 : -ETIMEDOUT; \
116	})
117
118		142
119	#define readb_poll_timeout(addr, val, cond, delay_us, timeout_us) \	143	#define readb_poll_timeout(addr, val, cond, delay_us, timeout_us) \
120	readx_poll_timeout(readb, addr, val, cond, delay_us, timeout_us)	144	readx_poll_timeout(readb, addr, val, cond, delay_us, timeout_us)

include/linux/kprobes.h+1−1

@@ -312,7 +312,7 @@ DEFINE_INSN_CACHE_OPS(optinsn); · 311 unmodified lines
312	#ifdef CONFIG_SYSCTL	312	#ifdef CONFIG_SYSCTL
313	extern int sysctl_kprobes_optimization;	313	extern int sysctl_kprobes_optimization;
314	extern int proc_kprobes_optimization_handler(struct ctl_table *table,	314	extern int proc_kprobes_optimization_handler(struct ctl_table *table,
315	int write, void __user *buffer,	315	int write, void *buffer,
316	size_t length, loff_t ppos);	316	size_t length, loff_t ppos);
317	#endif	317	#endif
318	extern void wait_for_kprobe_optimizer(void);	318	extern void wait_for_kprobe_optimizer(void);

include/linux/latencytop.h+2−2

@@ -38,8 +38,8 @@ account_scheduler_latency(struct task_struct *task, int usecs, int inter) · 37 unmodified lines
38		38
39	void clear_tsk_latency_tracing(struct task_struct *p);	39	void clear_tsk_latency_tracing(struct task_struct *p);
40		40
41	extern int sysctl_latencytop(struct ctl_table *table, int write,	41	int sysctl_latencytop(struct ctl_table table, int write, void buffer,
42	void __user buffer, size_t lenp, loff_t *ppos);	42	size_t lenp, loff_t ppos);
43		43
44	#else	44	#else
45		45

include/linux/mdio.h+31−0

@@ -9,6 +9,13 @@ · 8 unmodified lines
9	#include <uapi/linux/mdio.h>	9	#include <uapi/linux/mdio.h>
10	#include <linux/mod_devicetable.h>	10	#include <linux/mod_devicetable.h>
11		11
		12	/* Or MII_ADDR_C45 into regnum for read/write on mii_bus to enable the 21 bit
		13	* IEEE 802.3ae clause 45 addressing mode used by 10GIGE phy chips.
		14	*/
		15	#define MII_ADDR_C45 (1<<30)
		16	#define MII_DEVADDR_C45_SHIFT 16
		17	#define MII_REGADDR_C45_MASK GENMASK(15, 0)
		18
12	struct gpio_desc;	19	struct gpio_desc;
13	struct mii_bus;	20	struct mii_bus;
14		21
@@ -326,6 +333,30 @@ int mdiobus_write_nested(struct mii_bus *bus, int addr, u32 regnum, u16 val); · 311 unmodified lines
326	int mdiobus_modify(struct mii_bus *bus, int addr, u32 regnum, u16 mask,	333	int mdiobus_modify(struct mii_bus *bus, int addr, u32 regnum, u16 mask,
327	u16 set);	334	u16 set);
328		335
		336	static inline u32 mdiobus_c45_addr(int devad, u16 regnum)
		337	{
		338	return MII_ADDR_C45 \| devad << MII_DEVADDR_C45_SHIFT \| regnum;
		339	}
		340
		341	static inline int __mdiobus_c45_read(struct mii_bus *bus, int prtad, int devad,
		342	u16 regnum)
		343	{
		344	return __mdiobus_read(bus, prtad, mdiobus_c45_addr(devad, regnum));
		345	}
		346
		347	static inline int __mdiobus_c45_write(struct mii_bus *bus, int prtad, int devad,
		348	u16 regnum, u16 val)
		349	{
		350	return __mdiobus_write(bus, prtad, mdiobus_c45_addr(devad, regnum),
		351	val);
		352	}
		353
		354	static inline int mdiobus_c45_read(struct mii_bus *bus, int prtad, int devad,
		355	u16 regnum)
		356	{
		357	return mdiobus_read(bus, prtad, mdiobus_c45_addr(devad, regnum));
		358	}
		359
329	int mdiobus_register_device(struct mdio_device *mdiodev);	360	int mdiobus_register_device(struct mdio_device *mdiodev);
330	int mdiobus_unregister_device(struct mdio_device *mdiodev);	361	int mdiobus_unregister_device(struct mdio_device *mdiodev);
331	bool mdiobus_is_registered_device(struct mii_bus *bus, int addr);	362	bool mdiobus_is_registered_device(struct mii_bus *bus, int addr);

include/linux/mlx4/qp.h+1−1

@@ -362,7 +362,7 @@ struct mlx4_wqe_datagram_seg { · 361 unmodified lines
362		362
363	struct mlx4_wqe_lso_seg {	363	struct mlx4_wqe_lso_seg {
364	__be32 mss_hdr_size;	364	__be32 mss_hdr_size;
365	__be32 header[0];	365	__be32 header[];
366	};	366	};
367		367
368	enum mlx4_wqe_bind_seg_flags2 {	368	enum mlx4_wqe_bind_seg_flags2 {

include/linux/mlx5/accel.h+13−1

 struct mlx5_accel_esp_xfrm_attrs {
 	enum mlx5_accel_esp_action action;
 	u32   esn;
-	u32   spi;
+	__be32 spi;
 	u32   seq;
 	u32   tfc_pad;
 	u32   flags;
 	union {
 		struct aes_gcm_keymat aes_gcm;
 	} keymat;
+	union {
+		__be32 a4;
+		__be32 a6[4];
+	} saddr;
+	union {
+		__be32 a4;
+		__be32 a6[4];
+	} daddr;
+	u8 is_ipv6;
 };
 struct mlx5_accel_esp_xfrm {

include/linux/mlx5/cmd.h+0−51

@@ -1,51 +0,0 @@
1	/*
2	* Copyright (c) 2013-2015, Mellanox Technologies. All rights reserved.
3	*
4	* This software is available to you under a choice of one of two
5	* licenses. You may choose to be licensed under the terms of the GNU
6	* General Public License (GPL) Version 2, available from the file
7	* COPYING in the main directory of this source tree, or the
8	* OpenIB.org BSD license below:
9	*
10	* Redistribution and use in source and binary forms, with or
11	* without modification, are permitted provided that the following
12	* conditions are met:
13	*
14	* - Redistributions of source code must retain the above
15	* copyright notice, this list of conditions and the following
16	* disclaimer.
17	*
18	* - Redistributions in binary form must reproduce the above
19	* copyright notice, this list of conditions and the following
20	* disclaimer in the documentation and/or other materials
21	* provided with the distribution.
22	*
23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27	* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28	* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30	* SOFTWARE.
31	*/
32
33	#ifndef MLX5_CMD_H
34	#define MLX5_CMD_H
35
36	#include <linux/types.h>
37
38	struct manage_pages_layout {
39	u64 ptr;
40	u32 reserved;
41	u16 num_entries;
42	u16 func_id;
43	};
44
45
46	struct mlx5_cmd_alloc_uar_imm_out {
47	u32 rsvd[3];
48	u32 uarn;
49	};
50
51	#endif /* MLX5_CMD_H */

include/linux/mlx5/cq.h+1−1

@@ -188,7 +188,7 @@ int mlx5_core_create_cq(struct mlx5_core_dev dev, struct mlx5_core_cq cq, · 187 unmodified lines
188	u32 in, int inlen, u32 out, int outlen);	188	u32 in, int inlen, u32 out, int outlen);
189	int mlx5_core_destroy_cq(struct mlx5_core_dev dev, struct mlx5_core_cq cq);	189	int mlx5_core_destroy_cq(struct mlx5_core_dev dev, struct mlx5_core_cq cq);
190	int mlx5_core_query_cq(struct mlx5_core_dev dev, struct mlx5_core_cq cq,	190	int mlx5_core_query_cq(struct mlx5_core_dev dev, struct mlx5_core_cq cq,
191	u32 *out, int outlen);	191	u32 *out);
192	int mlx5_core_modify_cq(struct mlx5_core_dev dev, struct mlx5_core_cq cq,	192	int mlx5_core_modify_cq(struct mlx5_core_dev dev, struct mlx5_core_cq cq,
193	u32 *in, int inlen);	193	u32 *in, int inlen);
194	int mlx5_core_modify_cq_moderation(struct mlx5_core_dev *dev,	194	int mlx5_core_modify_cq_moderation(struct mlx5_core_dev *dev,

include/linux/mlx5/device.h+41−3

 enum {
 	MLX5_GENERAL_SUBTYPE_DELAY_DROP_TIMEOUT = 0x1,
 	MLX5_GENERAL_SUBTYPE_PCI_POWER_CHANGE_EVENT = 0x5,
+	MLX5_GENERAL_SUBTYPE_PCI_SYNC_FOR_FW_UPDATE_EVENT = 0x8,
 };
 enum {
 enum {
 	MLX5_OPC_MOD_TLS_TIS_STATIC_PARAMS = 0x1,
+	MLX5_OPC_MOD_TLS_TIR_STATIC_PARAMS = 0x2,
 };
 enum {
 	MLX5_OPC_MOD_TLS_TIS_PROGRESS_PARAMS = 0x1,
+	MLX5_OPC_MOD_TLS_TIR_PROGRESS_PARAMS = 0x2,
 };
 enum {
 	__be64 sensor_warning_lsb;
 } __packed;
+#define SYNC_RST_STATE_MASK    0xf
+enum sync_rst_state_type {
+	MLX5_SYNC_RST_STATE_RESET_REQUEST	= 0x0,
+	MLX5_SYNC_RST_STATE_RESET_NOW		= 0x1,
+	MLX5_SYNC_RST_STATE_RESET_ABORT		= 0x2,
+};
+struct mlx5_eqe_sync_fw_update {
+	u8 reserved_at_0[3];
+	u8 sync_rst_state;
+};
 union ev_data {
 	__be32				raw[7];
 	struct mlx5_eqe_cmd		cmd;
 	struct mlx5_eqe_dct             dct;
 	struct mlx5_eqe_temp_warning	temp_warning;
 	struct mlx5_eqe_xrq_err		xrq_err;
+	struct mlx5_eqe_sync_fw_update	sync_fw_update;
 } __packed;
 struct mlx5_eqe {
 };
 struct mlx5_cqe64 {
-	u8		outer_l3_tunneled;
+	u8		tls_outer_l3_tunneled;
 	u8		rsvd0;
 	__be16		wqe_id;
 	u8		lro_tcppsh_abort_dupack;
 	u8		l4_l3_hdr_type;
 	__be16		vlan_info;
 	__be32		srqn; /* [31:24]: lro_num_seg, [23:0]: srqn */
-	__be32		imm_inval_pkey;
+	union {
+		__be32 immediate;
+		__be32 inval_rkey;
+		__be32 pkey;
+		__be32 ft_metadata;
+	};
 	u8		rsvd40[4];
 	__be32		byte_cnt;
 	__be32		timestamp_h;
 static inline bool cqe_is_tunneled(struct mlx5_cqe64 *cqe)
 {
-	return cqe->outer_l3_tunneled & 0x1;
+	return cqe->tls_outer_l3_tunneled & 0x1;
+}
+static inline u8 get_cqe_tls_offload(struct mlx5_cqe64 *cqe)
+{
+	return (cqe->tls_outer_l3_tunneled >> 3) & 0x3;
 }
 static inline bool cqe_has_vlan(struct mlx5_cqe64 *cqe)
 	CQE_L4_OK	= 1 << 2,
 };
+enum {
+	CQE_TLS_OFFLOAD_NOT_DECRYPTED		= 0x0,
+	CQE_TLS_OFFLOAD_DECRYPTED		= 0x1,
+	CQE_TLS_OFFLOAD_RESYNC			= 0x2,
+	CQE_TLS_OFFLOAD_ERROR			= 0x3,
+};
 struct mlx5_sig_err_cqe {
 	u8		rsvd0[16];
 	__be32		expected_trans_sig;
 	MLX5_CAP_TLS,
 	MLX5_CAP_VDPA_EMULATION = 0x13,
 	MLX5_CAP_DEV_EVENT = 0x14,
+	MLX5_CAP_IPSEC,
 	/* NUM OF CAP Types */
 	MLX5_CAP_NUM
 };
 	MLX5_GET64(device_virtio_emulation_cap, \
 		(mdev)->caps.hca_cur[MLX5_CAP_VDPA_EMULATION], cap)
+#define MLX5_CAP_IPSEC(mdev, cap)\
+	MLX5_GET(ipsec_cap, (mdev)->caps.hca_cur[MLX5_CAP_IPSEC], cap)
 enum {
 	MLX5_CMD_STAT_OK			= 0x0,
 	MLX5_CMD_STAT_INT_ERR			= 0x1,

include/linux/mlx5/driver.h+20−15

 	MLX5_REG_NODE_DESC	 = 0x6001,
 	MLX5_REG_HOST_ENDIANNESS = 0x7004,
 	MLX5_REG_MCIA		 = 0x9014,
+	MLX5_REG_MFRL		 = 0x9028,
 	MLX5_REG_MLCR		 = 0x902b,
 	MLX5_REG_MTRC_CAP	 = 0x9040,
 	MLX5_REG_MTRC_CONF	 = 0x9041,
 	void		       *object;
 	enum dbg_rsc_type	type;
 	struct dentry	       *root;
-	struct mlx5_field_desc	fields[0];
+	struct mlx5_field_desc	fields[];
 };
 enum mlx5_dev_event {
 	struct mlx5_cmd_debug dbg;
 	struct cmd_msg_cache cache[MLX5_NUM_COMMAND_CACHES];
 	int checksum_disabled;
-	struct mlx5_cmd_stats stats[MLX5_CMD_OP_MAX];
+	struct mlx5_cmd_stats *stats;
 };
 struct mlx5_port_caps {
 	struct mlx5_core_health health;
 	/* start: qp staff */
-	struct mlx5_qp_table	qp_table;
 	struct dentry	       *qp_debugfs;
 	struct dentry	       *eq_debugfs;
 	struct dentry	       *cq_debugfs;
 	unsigned long		intf_state;
 	struct mlx5_priv	priv;
 	struct mlx5_profile	*profile;
-	atomic_t		num_qps;
 	u32			issi;
 	struct mlx5e_resources  mlx5e_res;
 	struct mlx5_dm          *dm;
 	return ioread32be(&dev->iseg->cmdif_rev_fw_sub) & 0xffff;
 }
-static inline u16 cmdif_rev(struct mlx5_core_dev *dev)
-{
-	return ioread32be(&dev->iseg->cmdif_rev_fw_sub) >> 16;
-}
 static inline u32 mlx5_base_mkey(const u32 key)
 {
 	return key & 0xffffff00u;
 int mlx5_cmd_exec(struct mlx5_core_dev *dev, void *in, int in_size, void *out,
 		  int out_size);
+#define mlx5_cmd_exec_inout(dev, ifc_cmd, in, out)                             \
+	({                                                                     \
+		mlx5_cmd_exec(dev, in, MLX5_ST_SZ_BYTES(ifc_cmd##_in), out,    \
+			      MLX5_ST_SZ_BYTES(ifc_cmd##_out));                \
+	})
+#define mlx5_cmd_exec_in(dev, ifc_cmd, in)                                     \
+	({                                                                     \
+		u32 _out[MLX5_ST_SZ_DW(ifc_cmd##_out)] = {};                   \
+		mlx5_cmd_exec_inout(dev, ifc_cmd, in, _out);                   \
+	})
 int mlx5_cmd_exec_polling(struct mlx5_core_dev *dev, void *in, int in_size,
 			  void *out, int out_size);
 void mlx5_cmd_mbox_status(void *out, u8 *status, u32 *syndrome);
 			   u8 roce_version, u8 roce_l3_type, const u8 *gid,
 			   const u8 *mac, bool vlan, u16 vlan_id, u8 port_num);
-static inline int fw_initializing(struct mlx5_core_dev *dev)
-{
-	return ioread32be(&dev->iseg->initializing) >> 31;
-}
 static inline u32 mlx5_mkey_to_idx(u32 mkey)
 {
 	return mkey >> 8;
 bool mlx5_lag_is_multipath(struct mlx5_core_dev *dev);
 bool mlx5_lag_is_active(struct mlx5_core_dev *dev);
 struct net_device *mlx5_lag_get_roce_netdev(struct mlx5_core_dev *dev);
+u8 mlx5_lag_get_slave_port(struct mlx5_core_dev *dev,
+			   struct net_device *slave);
 int mlx5_lag_query_cong_counters(struct mlx5_core_dev *dev,
 				 u64 *values,
 				 int num_counters,
 struct mlx5_uars_page *mlx5_get_uars_page(struct mlx5_core_dev *mdev);
 void mlx5_put_uars_page(struct mlx5_core_dev *mdev, struct mlx5_uars_page *up);
 int mlx5_dm_sw_icm_alloc(struct mlx5_core_dev *dev, enum mlx5_sw_icm_type type,
-			 u64 length, u16 uid, phys_addr_t *addr, u32 *obj_id);
+			 u64 length, u32 log_alignment, u16 uid,
+			 phys_addr_t *addr, u32 *obj_id);
 int mlx5_dm_sw_icm_dealloc(struct mlx5_core_dev *dev, enum mlx5_sw_icm_type type,
 			   u64 length, u16 uid, phys_addr_t addr, u32 obj_id);

include/linux/mlx5/fs.h+1−0

@@ -42,6 +42,7 @@ enum { · 41 unmodified lines
42	MLX5_FLOW_CONTEXT_ACTION_FWD_NEXT_PRIO = 1 << 16,	42	MLX5_FLOW_CONTEXT_ACTION_FWD_NEXT_PRIO = 1 << 16,
43	MLX5_FLOW_CONTEXT_ACTION_ENCRYPT = 1 << 17,	43	MLX5_FLOW_CONTEXT_ACTION_ENCRYPT = 1 << 17,
44	MLX5_FLOW_CONTEXT_ACTION_DECRYPT = 1 << 18,	44	MLX5_FLOW_CONTEXT_ACTION_DECRYPT = 1 << 18,
		45	MLX5_FLOW_CONTEXT_ACTION_FWD_NEXT_NS = 1 << 19,
45	};	46	};
46		47
47	enum {	48	enum {

include/linux/mlx5/mlx5_ifc.h+166−58

 	MLX5_SET_HCA_CAP_OP_MOD_GENERAL_DEVICE        = 0x0,
 	MLX5_SET_HCA_CAP_OP_MOD_ODP                   = 0x2,
 	MLX5_SET_HCA_CAP_OP_MOD_ATOMIC                = 0x3,
+	MLX5_SET_HCA_CAP_OP_MOD_ROCE                  = 0x4,
 };
 enum {
 	u8         metadata_reg_a[0x20];
-	u8         metadata_reg_b[0x20];
+	u8         reserved_at_1a0[0x60];
-	u8         reserved_at_1c0[0x40];
 };
 struct mlx5_ifc_fte_match_set_misc3_bits {
 	u8         tunnel_stateless_vxlan_gpe[0x1];
 	u8         tunnel_stateless_ipv4_over_vxlan[0x1];
 	u8         tunnel_stateless_ip_over_ip[0x1];
-	u8         reserved_at_2a[0x6];
+	u8         insert_trailer[0x1];
+	u8         reserved_at_2b[0x5];
 	u8         max_vxlan_udp_ports[0x8];
 	u8         reserved_at_38[0x6];
 	u8         max_geneve_opt_len[0x1];
 struct mlx5_ifc_roce_cap_bits {
 	u8         roce_apm[0x1];
-	u8         reserved_at_1[0x1f];
+	u8         reserved_at_1[0x3];
+	u8         sw_r_roce_src_udp_port[0x1];
+	u8         reserved_at_5[0x1b];
 	u8         reserved_at_20[0x60];
 	u8         reserved_at_20[0x7e0];
 };
+struct mlx5_ifc_ipsec_cap_bits {
+	u8         ipsec_full_offload[0x1];
+	u8         ipsec_crypto_offload[0x1];
+	u8         ipsec_esn[0x1];
+	u8         ipsec_crypto_esp_aes_gcm_256_encrypt[0x1];
+	u8         ipsec_crypto_esp_aes_gcm_128_encrypt[0x1];
+	u8         ipsec_crypto_esp_aes_gcm_256_decrypt[0x1];
+	u8         ipsec_crypto_esp_aes_gcm_128_decrypt[0x1];
+	u8         reserved_at_7[0x4];
+	u8         log_max_ipsec_offload[0x5];
+	u8         reserved_at_10[0x10];
+	u8         min_log_ipsec_full_replay_window[0x8];
+	u8         max_log_ipsec_full_replay_window[0x8];
+	u8         reserved_at_30[0x7d0];
+};
 enum {
 	MLX5_WQ_TYPE_LINKED_LIST  = 0x0,
 	MLX5_WQ_TYPE_CYCLIC       = 0x1,
 	u8         reserved_at_99[0x2];
 	u8         log_max_qp[0x5];
-	u8         reserved_at_a0[0xb];
+	u8         reserved_at_a0[0x3];
+	u8	   ece_support[0x1];
+	u8	   reserved_at_a4[0x7];
 	u8         log_max_srq[0x5];
 	u8         reserved_at_b0[0x10];
 	u8         reserved_at_130[0xa];
 	u8         log_max_ra_res_dc[0x6];
-	u8         reserved_at_140[0x9];
+	u8         reserved_at_140[0x6];
+	u8         release_all_pages[0x1];
+	u8         reserved_at_147[0x2];
 	u8         roce_accl[0x1];
 	u8         log_max_ra_req_qp[0x6];
 	u8         reserved_at_150[0xa];
 	u8         wol_p[0x1];
 	u8         stat_rate_support[0x10];
-	u8         reserved_at_1f0[0xc];
+	u8         reserved_at_1f0[0x1];
+	u8         pci_sync_for_fw_update_event[0x1];
+	u8         reserved_at_1f2[0xa];
 	u8         cqe_version[0x4];
 	u8         compact_address_vector[0x1];
 	u8         reserved_at_460[0x3];
 	u8         log_max_uctx[0x5];
-	u8         reserved_at_468[0x3];
+	u8         reserved_at_468[0x2];
+	u8         ipsec_offload[0x1];
 	u8         log_max_umem[0x5];
 	u8         max_num_eqs[0x10];
 	u8         reserved_at_480[0x1];
 	u8         tls_tx[0x1];
-	u8         reserved_at_482[0x1];
+	u8         tls_rx[0x1];
 	u8         log_max_l2_table[0x5];
 	u8         reserved_at_488[0x8];
 	u8         log_uar_page_sz[0x10];
 	u8         reserved_at_140[0x4c0];
-	struct mlx5_ifc_cmd_pas_bits pas[0];
+	struct mlx5_ifc_cmd_pas_bits pas[];
 };
 struct mlx5_ifc_rq_num_bits {
 	u8         reserved_at_20[0x10];
 	u8         num_of_records[0x10];
-	struct mlx5_ifc_resource_dump_menu_record_bits record[0];
+	struct mlx5_ifc_resource_dump_menu_record_bits record[];
 };
 struct mlx5_ifc_resource_dump_resource_segment_bits {
 	u8         index2[0x20];
-	u8         payload[0][0x20];
+	u8         payload[][0x20];
 };
 struct mlx5_ifc_resource_dump_terminate_segment_bits {
 	u8         reserved_at_1200[0x600];
-	union mlx5_ifc_dest_format_struct_flow_counter_list_auto_bits destination[0];
+	union mlx5_ifc_dest_format_struct_flow_counter_list_auto_bits destination[];
 };
 enum {
 	u8         reserved_at_0[0x20];
 	u8         disp_type[0x4];
-	u8         reserved_at_24[0x1c];
+	u8         tls_en[0x1];
+	u8         reserved_at_25[0x1b];
 	u8         reserved_at_40[0x40];
 	u8         reserved_at_e0[0x6a0];
-	struct mlx5_ifc_rq_num_bits rq_num[0];
+	struct mlx5_ifc_rq_num_bits rq_num[];
 };
 enum {
 	u8         reserved_at_7e0[0x20];
-	u8         current_uc_mac_address[0][0x40];
+	u8         current_uc_mac_address[][0x40];
 };
 enum {
 	MLX5_SET_FTE_MODIFY_ENABLE_MASK_ACTION    = 0x0,
 	MLX5_SET_FTE_MODIFY_ENABLE_MASK_FLOW_TAG  = 0x1,
 	MLX5_SET_FTE_MODIFY_ENABLE_MASK_DESTINATION_LIST    = 0x2,
-	MLX5_SET_FTE_MODIFY_ENABLE_MASK_FLOW_COUNTERS    = 0x3
+	MLX5_SET_FTE_MODIFY_ENABLE_MASK_FLOW_COUNTERS    = 0x3,
+	MLX5_SET_FTE_MODIFY_ENABLE_MASK_IPSEC_OBJ_ID    = 0x4
 };
 struct mlx5_ifc_set_fte_out_bits {
 	u8         syndrome[0x20];
-	u8         reserved_at_40[0x40];
+	u8         reserved_at_40[0x20];
+	u8         ece[0x20];
 };
 struct mlx5_ifc_rts2rts_qp_in_bits {
 	u8         opt_param_mask[0x20];
-	u8         reserved_at_a0[0x20];
+	u8         ece[0x20];
 	struct mlx5_ifc_qpc_bits qpc;
 	u8         syndrome[0x20];
-	u8         reserved_at_40[0x40];
+	u8         reserved_at_40[0x20];
+	u8         ece[0x20];
 };
 struct mlx5_ifc_rtr2rts_qp_in_bits {
 	u8         opt_param_mask[0x20];
-	u8         reserved_at_a0[0x20];
+	u8         ece[0x20];
 	struct mlx5_ifc_qpc_bits qpc;
 	u8         reserved_at_280[0x600];
-	u8         pas[0][0x40];
+	u8         pas[][0x40];
 };
 struct mlx5_ifc_query_xrc_srq_in_bits {
 	u8         reserved_at_280[0x600];
-	u8         pas[0][0x40];
+	u8         pas[][0x40];
 };
 struct mlx5_ifc_query_srq_in_bits {
 	u8         syndrome[0x20];
-	u8         reserved_at_40[0x40];
+	u8         reserved_at_40[0x20];
+	u8         ece[0x20];
 	u8         opt_param_mask[0x20];
 	u8         reserved_at_800[0x80];
-	u8         pas[0][0x40];
+	u8         pas[][0x40];
 };
 struct mlx5_ifc_query_qp_in_bits {
 	u8         reserved_at_40[0x40];
-	struct mlx5_ifc_pkey_bits pkey[0];
+	struct mlx5_ifc_pkey_bits pkey[];
 };
 struct mlx5_ifc_query_hca_vport_pkey_in_bits {
 	u8         gids_num[0x10];
 	u8         reserved_at_70[0x10];
-	struct mlx5_ifc_array128_auto_bits gid[0];
+	struct mlx5_ifc_array128_auto_bits gid[];
 };
 struct mlx5_ifc_query_hca_vport_gid_in_bits {
 	u8         reserved_at_40[0x40];
-	struct mlx5_ifc_traffic_counter_bits flow_statistics[0];
+	struct mlx5_ifc_traffic_counter_bits flow_statistics[];
 };
 struct mlx5_ifc_query_flow_counter_in_bits {
 	u8         reserved_at_300[0x580];
-	u8         pas[0][0x40];
+	u8         pas[][0x40];
 };
 struct mlx5_ifc_query_eq_in_bits {
 	u8         reserved_at_20[0x10];
 	u8         reformat_data[2][0x8];
-	u8         more_reformat_data[0][0x8];
+	u8         more_reformat_data[][0x8];
 };
 struct mlx5_ifc_query_packet_reformat_context_out_bits {
 	u8         reserved_at_40[0xa0];
-	struct mlx5_ifc_packet_reformat_context_in_bits packet_reformat_context[0];
+	struct mlx5_ifc_packet_reformat_context_in_bits packet_reformat_context[];
 };
 struct mlx5_ifc_query_packet_reformat_context_in_bits {
 	u8         reserved_at_38[0x8];
 };
-union mlx5_ifc_set_action_in_add_action_in_auto_bits {
+union mlx5_ifc_set_add_copy_action_in_auto_bits {
-	struct mlx5_ifc_set_action_in_bits set_action_in;
+	struct mlx5_ifc_set_action_in_bits  set_action_in;
-	struct mlx5_ifc_add_action_in_bits add_action_in;
+	struct mlx5_ifc_add_action_in_bits  add_action_in;
 	struct mlx5_ifc_copy_action_in_bits copy_action_in;
 	u8         reserved_at_0[0x40];
 };
 	u8         reserved_at_68[0x10];
 	u8         num_of_actions[0x8];
-	union mlx5_ifc_set_action_in_add_action_in_auto_bits actions[0];
+	union mlx5_ifc_set_add_copy_action_in_auto_bits actions[0];
 };
 struct mlx5_ifc_dealloc_modify_header_context_out_bits {
 	u8         reserved_at_280[0x600];
-	u8         pas[0][0x40];
+	u8         pas[][0x40];
 };
 struct mlx5_ifc_query_cq_in_bits {
 	u8         reserved_at_300[0x580];
-	u8         pas[0][0x40];
+	u8         pas[][0x40];
 };
 struct mlx5_ifc_modify_cong_status_out_bits {
 	u8         reserved_at_60[0x20];
-	u8         pas[0][0x40];
+	u8         pas[][0x40];
 };
 enum {
 	u8         input_num_entries[0x20];
-	u8         pas[0][0x40];
+	u8         pas[][0x40];
 };
 struct mlx5_ifc_mad_ifc_out_bits {
 	u8         syndrome[0x20];
-	u8         reserved_at_40[0x40];
+	u8         reserved_at_40[0x20];
+	u8         ece[0x20];
 };
 struct mlx5_ifc_init2rtr_qp_in_bits {
 	u8         opt_param_mask[0x20];
-	u8         reserved_at_a0[0x20];
+	u8         ece[0x20];
 	struct mlx5_ifc_qpc_bits qpc;
 	u8         reserved_at_300[0x580];
-	u8         pas[0][0x40];
+	u8         pas[][0x40];
 };
 struct mlx5_ifc_create_tis_out_bits {
 	u8         reserved_at_280[0x600];
-	u8         pas[0][0x40];
+	u8         pas[][0x40];
 };
 struct mlx5_ifc_create_sq_out_bits {
 	u8         reserved_at_40[0x8];
 	u8         qpn[0x18];
-	u8         reserved_at_60[0x20];
+	u8         ece[0x20];
 };
 struct mlx5_ifc_create_qp_in_bits {
 	u8         opt_param_mask[0x20];
-	u8         reserved_at_a0[0x20];
+	u8         ece[0x20];
 	struct mlx5_ifc_qpc_bits qpc;
 	u8         wq_umem_valid[0x1];
 	u8         reserved_at_861[0x1f];
-	u8         pas[0][0x40];
+	u8         pas[][0x40];
 };
 struct mlx5_ifc_create_psv_out_bits {
 	u8         reserved_at_320[0x560];
-	u8         klm_pas_mtt[0][0x20];
+	u8         klm_pas_mtt[][0x20];
 };
 enum {
 	u8         reserved_at_3c0[0x4c0];
-	u8         pas[0][0x40];
+	u8         pas[][0x40];
 };
 struct mlx5_ifc_create_dct_out_bits {
 	u8         cq_umem_valid[0x1];
 	u8         reserved_at_2e1[0x59f];
-	u8         pas[0][0x40];
+	u8         pas[][0x40];
 };
 struct mlx5_ifc_config_int_moderation_out_bits {
 	u8         reserved_at_40[0x40];
-	u8         register_data[0][0x20];
+	u8         register_data[][0x20];
 };
 enum {
 	u8         argument[0x20];
-	u8         register_data[0][0x20];
+	u8         register_data[][0x20];
 };
 struct mlx5_ifc_sltp_reg_bits {
 	u8         reserved_at_20[0x10];
 	u8         op_mod[0x10];
-	u8         command[0][0x20];
+	u8         command[][0x20];
 };
 struct mlx5_ifc_cmd_if_box_bits {
 	u8         reserved_at_a0[0x10];
 	u8         data_size[0x10];
-	union mlx5_ifc_mcqi_reg_data_bits data[0];
+	union mlx5_ifc_mcqi_reg_data_bits data[];
 };
 struct mlx5_ifc_mcc_reg_bits {
 	u8         data[0][0x20];
 };
+enum {
+	MLX5_MFRL_REG_RESET_TYPE_FULL_CHIP = BIT(0),
+	MLX5_MFRL_REG_RESET_TYPE_NET_PORT_ALIVE = BIT(1),
+};
+enum {
+	MLX5_MFRL_REG_RESET_LEVEL0 = BIT(0),
+	MLX5_MFRL_REG_RESET_LEVEL3 = BIT(3),
+	MLX5_MFRL_REG_RESET_LEVEL6 = BIT(6),
+};
+struct mlx5_ifc_mfrl_reg_bits {
+	u8         reserved_at_0[0x20];
+	u8         reserved_at_20[0x2];
+	u8         pci_sync_for_fw_update_start[0x1];
+	u8         pci_sync_for_fw_update_resp[0x2];
+	u8         rst_type_sel[0x3];
+	u8         reserved_at_28[0x8];
+	u8         reset_type[0x8];
+	u8         reset_level[0x8];
+};
 struct mlx5_ifc_mirc_reg_bits {
 	u8         reserved_at_0[0x18];
 	u8         status_code[0x8];
 	struct mlx5_ifc_mcc_reg_bits mcc_reg;
 	struct mlx5_ifc_mcda_reg_bits mcda_reg;
 	struct mlx5_ifc_mirc_reg_bits mirc_reg;
+	struct mlx5_ifc_mfrl_reg_bits mfrl_reg;
 	u8         reserved_at_0[0x60e0];
 };
 	u8         num_of_mtt[0x40];
-	struct mlx5_ifc_mtt_bits  mtt[0];
+	struct mlx5_ifc_mtt_bits  mtt[];
 };
 struct mlx5_ifc_uctx_bits {
 	u8         reserved_at_4[0x4];
 	u8         read_size[0x18];
 	u8         start_offset[0x20];
-	u8         string_db_data[0];
+	u8         string_db_data[];
 };
 struct mlx5_ifc_mtrc_ctrl_bits {
 	struct mlx5_ifc_host_params_context_bits host_params_context;
 	u8         reserved_at_280[0x180];
-	u8         host_sf_enable[0][0x40];
+	u8         host_sf_enable[][0x40];
 };
 struct mlx5_ifc_sf_partition_bits {
 	u8         reserved_at_60[0x20];
-	struct mlx5_ifc_sf_partition_bits sf_partition[0];
+	struct mlx5_ifc_sf_partition_bits sf_partition[];
 };
 struct mlx5_ifc_query_sf_partitions_in_bits {
 enum {
 	MLX5_HCA_CAP_GENERAL_OBJECT_TYPES_ENCRYPTION_KEY = BIT(0xc),
+	MLX5_HCA_CAP_GENERAL_OBJECT_TYPES_IPSEC = BIT(0x13),
 };
 enum {
 	MLX5_GENERAL_OBJECT_TYPES_ENCRYPTION_KEY = 0xc,
+	MLX5_GENERAL_OBJECT_TYPES_IPSEC = 0x13,
+};
+enum {
+	MLX5_IPSEC_OBJECT_ICV_LEN_16B,
+	MLX5_IPSEC_OBJECT_ICV_LEN_12B,
+	MLX5_IPSEC_OBJECT_ICV_LEN_8B,
+};
+struct mlx5_ifc_ipsec_obj_bits {
+	u8         modify_field_select[0x40];
+	u8         full_offload[0x1];
+	u8         reserved_at_41[0x1];
+	u8         esn_en[0x1];
+	u8         esn_overlap[0x1];
+	u8         reserved_at_44[0x2];
+	u8         icv_length[0x2];
+	u8         reserved_at_48[0x4];
+	u8         aso_return_reg[0x4];
+	u8         reserved_at_50[0x10];
+	u8         esn_msb[0x20];
+	u8         reserved_at_80[0x8];
+	u8         dekn[0x18];
+	u8         salt[0x20];
+	u8         implicit_iv[0x40];
+	u8         reserved_at_100[0x700];
+};
+struct mlx5_ifc_create_ipsec_obj_in_bits {
+	struct mlx5_ifc_general_obj_in_cmd_hdr_bits general_obj_in_cmd_hdr;
+	struct mlx5_ifc_ipsec_obj_bits ipsec_object;
+};
+enum {
+	MLX5_MODIFY_IPSEC_BITMASK_ESN_OVERLAP = BIT(0),
+	MLX5_MODIFY_IPSEC_BITMASK_ESN_MSB = BIT(1),
+};
+struct mlx5_ifc_query_ipsec_obj_out_bits {
+	struct mlx5_ifc_general_obj_out_cmd_hdr_bits general_obj_out_cmd_hdr;
+	struct mlx5_ifc_ipsec_obj_bits ipsec_object;
+};
+struct mlx5_ifc_modify_ipsec_obj_in_bits {
+	struct mlx5_ifc_general_obj_in_cmd_hdr_bits general_obj_in_cmd_hdr;
+	struct mlx5_ifc_ipsec_obj_bits ipsec_object;
 };
 struct mlx5_ifc_encryption_key_obj_bits {

include/linux/mlx5/qp.h+7−50

@@ -229,6 +229,11 @@ enum { · 228 unmodified lines
229		229
230	enum {	230	enum {
231	MLX5_ETH_WQE_SVLAN = 1 << 0,	231	MLX5_ETH_WQE_SVLAN = 1 << 0,
		232	MLX5_ETH_WQE_TRAILER_HDR_OUTER_IP_ASSOC = 1 << 26,
		233	MLX5_ETH_WQE_TRAILER_HDR_OUTER_L4_ASSOC = 1 << 27,
		234	MLX5_ETH_WQE_TRAILER_HDR_INNER_IP_ASSOC = 3 << 26,
		235	MLX5_ETH_WQE_TRAILER_HDR_INNER_L4_ASSOC = 1 << 28,
		236	MLX5_ETH_WQE_INSERT_TRAILER = 1 << 30,
232	MLX5_ETH_WQE_INSERT_VLAN = 1 << 15,	237	MLX5_ETH_WQE_INSERT_VLAN = 1 << 15,
233	};	238	};
234		239
@@ -257,6 +262,7 @@ struct mlx5_wqe_eth_seg { · 22 unmodified lines
257	__be16 type;	262	__be16 type;
258	__be16 vlan_tci;	263	__be16 vlan_tci;
259	} insert;	264	} insert;
		265	__be32 trailer;
260	};	266	};
261	};	267	};
262		268
@@ -402,7 +408,7 @@ struct mlx5_wqe_signature_seg { · 139 unmodified lines
402		408
403	struct mlx5_wqe_inline_seg {	409	struct mlx5_wqe_inline_seg {
404	__be32 byte_count;	410	__be32 byte_count;
405	__be32 data[0];	411	__be32 data[];
406	};	412	};
407		413
408	enum mlx5_sig_type {	414	enum mlx5_sig_type {
@@ -553,57 +559,8 @@ struct mlx5_qp_context { · 144 unmodified lines
553	u8 rsvd1[24];	559	u8 rsvd1[24];
554	};	560	};
555		561
556	static inline struct mlx5_core_qp __mlx5_qp_lookup(struct mlx5_core_dev dev, u32 qpn)
557	{
558	return radix_tree_lookup(&dev->priv.qp_table.tree, qpn);
559	}
560
561	int mlx5_core_create_dct(struct mlx5_core_dev *dev,
562	struct mlx5_core_dct *qp,
563	u32 *in, int inlen,
564	u32 *out, int outlen);
565	int mlx5_core_create_qp(struct mlx5_core_dev *dev,
566	struct mlx5_core_qp *qp,
567	u32 *in,
568	int inlen);
569	int mlx5_core_qp_modify(struct mlx5_core_dev *dev, u16 opcode,
570	u32 opt_param_mask, void *qpc,
571	struct mlx5_core_qp *qp);
572	int mlx5_core_destroy_qp(struct mlx5_core_dev *dev,
573	struct mlx5_core_qp *qp);
574	int mlx5_core_destroy_dct(struct mlx5_core_dev *dev,
575	struct mlx5_core_dct *dct);
576	int mlx5_core_qp_query(struct mlx5_core_dev dev, struct mlx5_core_qp qp,
577	u32 *out, int outlen);
578	int mlx5_core_dct_query(struct mlx5_core_dev dev, struct mlx5_core_dct dct,
579	u32 *out, int outlen);
580
581	int mlx5_core_set_delay_drop(struct mlx5_core_dev *dev,
582	u32 timeout_usec);
583
584	int mlx5_core_xrcd_alloc(struct mlx5_core_dev dev, u32 xrcdn);
585	int mlx5_core_xrcd_dealloc(struct mlx5_core_dev *dev, u32 xrcdn);
586	void mlx5_init_qp_table(struct mlx5_core_dev *dev);
587	void mlx5_cleanup_qp_table(struct mlx5_core_dev *dev);
588	int mlx5_debug_qp_add(struct mlx5_core_dev dev, struct mlx5_core_qp qp);	562	int mlx5_debug_qp_add(struct mlx5_core_dev dev, struct mlx5_core_qp qp);
589	void mlx5_debug_qp_remove(struct mlx5_core_dev dev, struct mlx5_core_qp qp);	563	void mlx5_debug_qp_remove(struct mlx5_core_dev dev, struct mlx5_core_qp qp);
590	int mlx5_core_create_rq_tracked(struct mlx5_core_dev dev, u32 in, int inlen,
591	struct mlx5_core_qp *rq);
592	void mlx5_core_destroy_rq_tracked(struct mlx5_core_dev *dev,
593	struct mlx5_core_qp *rq);
594	int mlx5_core_create_sq_tracked(struct mlx5_core_dev dev, u32 in, int inlen,
595	struct mlx5_core_qp *sq);
596	void mlx5_core_destroy_sq_tracked(struct mlx5_core_dev *dev,
597	struct mlx5_core_qp *sq);
598	int mlx5_core_alloc_q_counter(struct mlx5_core_dev dev, u16 counter_id);
599	int mlx5_core_dealloc_q_counter(struct mlx5_core_dev *dev, u16 counter_id);
600	int mlx5_core_query_q_counter(struct mlx5_core_dev *dev, u16 counter_id,
601	int reset, void *out, int out_size);
602
603	struct mlx5_core_rsc_common mlx5_core_res_hold(struct mlx5_core_dev dev,
604	int res_num,
605	enum mlx5_res_type res_type);
606	void mlx5_core_res_put(struct mlx5_core_rsc_common *res);
607		564
608	static inline const char *mlx5_qp_type_str(int type)	565	static inline const char *mlx5_qp_type_str(int type)
609	{	566	{

include/linux/mlx5/transobj.h+6−13

 void mlx5_core_dealloc_transport_domain(struct mlx5_core_dev *dev, u32 tdn);
 int mlx5_core_create_rq(struct mlx5_core_dev *dev, u32 *in, int inlen,
 			u32 *rqn);
-int mlx5_core_modify_rq(struct mlx5_core_dev *dev, u32 rqn, u32 *in, int inlen);
+int mlx5_core_modify_rq(struct mlx5_core_dev *dev, u32 rqn, u32 *in);
 void mlx5_core_destroy_rq(struct mlx5_core_dev *dev, u32 rqn);
 int mlx5_core_query_rq(struct mlx5_core_dev *dev, u32 rqn, u32 *out);
 int mlx5_core_create_sq(struct mlx5_core_dev *dev, u32 *in, int inlen,
 			u32 *sqn);
-int mlx5_core_modify_sq(struct mlx5_core_dev *dev, u32 sqn, u32 *in, int inlen);
+int mlx5_core_modify_sq(struct mlx5_core_dev *dev, u32 sqn, u32 *in);
 void mlx5_core_destroy_sq(struct mlx5_core_dev *dev, u32 sqn);
 int mlx5_core_query_sq(struct mlx5_core_dev *dev, u32 sqn, u32 *out);
 int mlx5_core_query_sq_state(struct mlx5_core_dev *dev, u32 sqn, u8 *state);
-int mlx5_core_create_tir(struct mlx5_core_dev *dev, u32 *in, int inlen,
+int mlx5_core_create_tir(struct mlx5_core_dev *dev, u32 *in, u32 *tirn);
-			 u32 *tirn);
+int mlx5_core_modify_tir(struct mlx5_core_dev *dev, u32 tirn, u32 *in);
-int mlx5_core_create_tir_out(struct mlx5_core_dev *dev,
-			     u32 *in, int inlen,
-			     u32 *out, int outlen);
-int mlx5_core_modify_tir(struct mlx5_core_dev *dev, u32 tirn, u32 *in,
-			 int inlen);
 void mlx5_core_destroy_tir(struct mlx5_core_dev *dev, u32 tirn);
-int mlx5_core_create_tis(struct mlx5_core_dev *dev, u32 *in, int inlen,
+int mlx5_core_create_tis(struct mlx5_core_dev *dev, u32 *in, u32 *tisn);
-			 u32 *tisn);
+int mlx5_core_modify_tis(struct mlx5_core_dev *dev, u32 tisn, u32 *in);
-int mlx5_core_modify_tis(struct mlx5_core_dev *dev, u32 tisn, u32 *in,
-			 int inlen);
 void mlx5_core_destroy_tis(struct mlx5_core_dev *dev, u32 tisn);
 int mlx5_core_create_rqt(struct mlx5_core_dev *dev, u32 *in, int inlen,
 			 u32 *rqtn);

include/linux/mlx5/vport.h+1−2

 				u8 other_vport, u64 *rx_discard_vport_down,
 				u64 *tx_discard_vport_down);
 int mlx5_core_query_vport_counter(struct mlx5_core_dev *dev, u8 other_vport,
-				  int vf, u8 port_num, void *out,
+				  int vf, u8 port_num, void *out);
-				  size_t out_sz);
 int mlx5_core_modify_hca_vport_context(struct mlx5_core_dev *dev,
 				       u8 other_vport, u8 port_num,
 				       int vf,

include/linux/mm.h+8−6

 extern int sysctl_overcommit_ratio;
 extern unsigned long sysctl_overcommit_kbytes;
-extern int overcommit_ratio_handler(struct ctl_table *, int, void __user *,
+int overcommit_ratio_handler(struct ctl_table *, int, void *, size_t *,
-				    size_t *, loff_t *);
+		loff_t *);
-extern int overcommit_kbytes_handler(struct ctl_table *, int, void __user *,
+int overcommit_kbytes_handler(struct ctl_table *, int, void *, size_t *,
-				    size_t *, loff_t *);
+		loff_t *);
 #define nth_page(page,n) pfn_to_page(page_to_pfn((page)) + (n))
 #ifdef CONFIG_SYSCTL
 extern int sysctl_drop_caches;
-int drop_caches_sysctl_handler(struct ctl_table *, int,
+int drop_caches_sysctl_handler(struct ctl_table *, int, void *, size_t *,
-					void __user *, size_t *, loff_t *);
+		loff_t *);
 #endif
 void drop_slab(void);
 				      pgoff_t first_index, pgoff_t nr);
 #endif
+extern int sysctl_nr_trim_pages;
 #endif /* __KERNEL__ */
 #endif /* _LINUX_MM_H */

include/linux/mmzone.h+13−14

@@ -911,24 +911,23 @@ static inline int is_highmem(struct zone *zone) · 910 unmodified lines
911		911
912	/* These two functions are used to setup the per zone pages min values */	912	/* These two functions are used to setup the per zone pages min values */
913	struct ctl_table;	913	struct ctl_table;
914	int min_free_kbytes_sysctl_handler(struct ctl_table *, int,	914
915	void __user , size_t , loff_t *);	915	int min_free_kbytes_sysctl_handler(struct ctl_table , int, void , size_t *,
916	int watermark_boost_factor_sysctl_handler(struct ctl_table *, int,	916	loff_t *);
917	void __user , size_t , loff_t *);	917	int watermark_scale_factor_sysctl_handler(struct ctl_table , int, void ,
918	int watermark_scale_factor_sysctl_handler(struct ctl_table *, int,	918	size_t , loff_t );
919	void __user , size_t , loff_t *);
920	extern int sysctl_lowmem_reserve_ratio[MAX_NR_ZONES];	919	extern int sysctl_lowmem_reserve_ratio[MAX_NR_ZONES];
921	int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *, int,	920	int lowmem_reserve_ratio_sysctl_handler(struct ctl_table , int, void ,
922	void __user , size_t , loff_t *);	921	size_t , loff_t );
923	int percpu_pagelist_fraction_sysctl_handler(struct ctl_table *, int,	922	int percpu_pagelist_fraction_sysctl_handler(struct ctl_table *, int,
924	void __user , size_t , loff_t *);	923	void , size_t , loff_t *);
925	int sysctl_min_unmapped_ratio_sysctl_handler(struct ctl_table *, int,	924	int sysctl_min_unmapped_ratio_sysctl_handler(struct ctl_table *, int,
926	void __user , size_t , loff_t *);	925	void , size_t , loff_t *);
927	int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *, int,	926	int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *, int,
928	void __user , size_t , loff_t *);	927	void , size_t , loff_t *);
929		928	int numa_zonelist_order_handler(struct ctl_table *, int,
930	extern int numa_zonelist_order_handler(struct ctl_table *, int,	929	void , size_t , loff_t *);
931	void __user , size_t , loff_t *);	930	extern int percpu_pagelist_fraction;
932	extern char numa_zonelist_order[];	931	extern char numa_zonelist_order[];
933	#define NUMA_ZONELIST_ORDER_LEN 16	932	#define NUMA_ZONELIST_ORDER_LEN 16
934		933

include/linux/net.h+0−4

 		   int flags);
 int kernel_getsockname(struct socket *sock, struct sockaddr *addr);
 int kernel_getpeername(struct socket *sock, struct sockaddr *addr);
-int kernel_getsockopt(struct socket *sock, int level, int optname, char *optval,
-		      int *optlen);
-int kernel_setsockopt(struct socket *sock, int level, int optname, char *optval,
-		      unsigned int optlen);
 int kernel_sendpage(struct socket *sock, struct page *page, int offset,
 		    size_t size, int flags);
 int kernel_sendpage_locked(struct sock *sk, struct page *page, int offset,

include/linux/netdev_features.h+1−1

@@ -89,7 +89,7 @@ enum { · 88 unmodified lines
89	* Add your fresh new feature above and remember to update	89	* Add your fresh new feature above and remember to update
90	* netdev_features_strings[] in net/core/ethtool.c and maybe	90	* netdev_features_strings[] in net/core/ethtool.c and maybe
91	* some feature mask #defines below. Please also describe it	91	* some feature mask #defines below. Please also describe it
92	* in Documentation/networking/netdev-features.txt.	92	* in Documentation/networking/netdev-features.rst.
93	*/	93	*/
94		94
95	/**/NETDEV_FEATURE_COUNT	95	/**/NETDEV_FEATURE_COUNT

include/linux/netdevice.h+82−8

 struct device;
 struct phy_device;
 struct dsa_port;
+struct ip_tunnel_parm;
 struct macsec_context;
 struct macsec_ops;
 	__LINK_STATE_NOCARRIER,
 	__LINK_STATE_LINKWATCH_PENDING,
 	__LINK_STATE_DORMANT,
+	__LINK_STATE_TESTING,
 };
 	unsigned long		state;
 	int			weight;
+	int			defer_hard_irqs_count;
 	unsigned long		gro_bitmask;
 	int			(*poll)(struct napi_struct *, int);
 #ifdef CONFIG_NETPOLL
  * int (*ndo_del_slave)(struct net_device *dev, struct net_device *slave_dev);
  *	Called to release previously enslaved netdev.
  *
+ * struct net_device *(*ndo_get_xmit_slave)(struct net_device *dev,
+ *					    struct sk_buff *skb,
+ *					    bool all_slaves);
+ *	Get the xmit slave of master device. If all_slaves is true, function
+ *	assume all the slaves can transmit.
+ *
  *      Feature/offload setting functions.
  * netdev_features_t (*ndo_fix_features)(struct net_device *dev,
  *		netdev_features_t features);
  *	Get devlink port instance associated with a given netdev.
  *	Called with a reference on the netdevice and devlink locks only,
  *	rtnl_lock is not held.
+ * int (*ndo_tunnel_ctl)(struct net_device *dev, struct ip_tunnel_parm *p,
+ *			 int cmd);
+ *	Add, change, delete or get information on an IPv4 tunnel.
  */
 struct net_device_ops {
 	int			(*ndo_init)(struct net_device *dev);
 						 struct netlink_ext_ack *extack);
 	int			(*ndo_del_slave)(struct net_device *dev,
 						 struct net_device *slave_dev);
+	struct net_device*	(*ndo_get_xmit_slave)(struct net_device *dev,
+						      struct sk_buff *skb,
+						      bool all_slaves);
 	netdev_features_t	(*ndo_fix_features)(struct net_device *dev,
 						    netdev_features_t features);
 	int			(*ndo_set_features)(struct net_device *dev,
 	int			(*ndo_xsk_wakeup)(struct net_device *dev,
 						  u32 queue_id, u32 flags);
 	struct devlink_port *	(*ndo_get_devlink_port)(struct net_device *dev);
+	int			(*ndo_tunnel_ctl)(struct net_device *dev,
+						  struct ip_tunnel_parm *p, int cmd);
 };
 /**
  *	@phydev:	Physical device may attach itself
  *			for hardware timestamping
  *	@sfp_bus:	attached &struct sfp_bus structure.
- *	@qdisc_tx_busylock_key: lockdep class annotating Qdisc->busylock
+ *
- *				spinlock
- *	@qdisc_running_key:	lockdep class annotating Qdisc->running seqcount
- *	@qdisc_xmit_lock_key:	lockdep class annotating
- *				netdev_queue->_xmit_lock spinlock
  *	@addr_list_lock_key:	lockdep class annotating
  *				net_device->addr_list_lock spinlock
+ *	@qdisc_tx_busylock: lockdep class annotating Qdisc->busylock spinlock
+ *	@qdisc_running_key: lockdep class annotating Qdisc->running seqcount
  *
  *	@proto_down:	protocol port state information can be sent to the
  *			switch driver and used to set the phys state of the
 	struct bpf_prog __rcu	*xdp_prog;
 	unsigned long		gro_flush_timeout;
+	int			napi_defer_hard_irqs;
 	rx_handler_func_t __rcu	*rx_handler;
 	void __rcu		*rx_handler_data;
 #endif
 	struct phy_device	*phydev;
 	struct sfp_bus		*sfp_bus;
-	struct lock_class_key	qdisc_tx_busylock_key;
-	struct lock_class_key	qdisc_running_key;
-	struct lock_class_key	qdisc_xmit_lock_key;
 	struct lock_class_key	addr_list_lock_key;
+	struct lock_class_key	*qdisc_tx_busylock;
+	struct lock_class_key	*qdisc_running_key;
 	bool			proto_down;
 	unsigned		wol_enabled:1;
 		f(dev, &dev->_tx[i], arg);
 }
+#define netdev_lockdep_set_classes(dev)				\
+{								\
+	static struct lock_class_key qdisc_tx_busylock_key;	\
+	static struct lock_class_key qdisc_running_key;		\
+	static struct lock_class_key qdisc_xmit_lock_key;	\
+	unsigned int i;						\
+								\
+	(dev)->qdisc_tx_busylock = &qdisc_tx_busylock_key;	\
+	(dev)->qdisc_running_key = &qdisc_running_key;		\
+	for (i = 0; i < (dev)->num_tx_queues; i++)		\
+		lockdep_set_class(&(dev)->_tx[i]._xmit_lock,	\
+				  &qdisc_xmit_lock_key);	\
+}
 u16 netdev_pick_tx(struct net_device *dev, struct sk_buff *skb,
 		     struct net_device *sb_dev);
 struct netdev_queue *netdev_core_pick_tx(struct net_device *dev,
 void synchronize_net(void);
 int init_dummy_netdev(struct net_device *dev);
+struct net_device *netdev_get_xmit_slave(struct net_device *dev,
+					 struct sk_buff *skb,
+					 bool all_slaves);
 struct net_device *dev_get_by_index(struct net *net, int ifindex);
 struct net_device *__dev_get_by_index(struct net *net, int ifindex);
 struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex);
 }
+/**
+ *	netif_testing_on - mark device as under test.
+ *	@dev: network device
+ *
+ * Mark device as under test (as per RFC2863).
+ *
+ * The testing state indicates that some test(s) must be performed on
+ * the interface. After completion, of the test, the interface state
+ * will change to up, dormant, or down, as appropriate.
+ */
+static inline void netif_testing_on(struct net_device *dev)
+{
+	if (!test_and_set_bit(__LINK_STATE_TESTING, &dev->state))
+		linkwatch_fire_event(dev);
+}
+/**
+ *	netif_testing_off - set device as not under test.
+ *	@dev: network device
+ *
+ * Device is not in testing state.
+ */
+static inline void netif_testing_off(struct net_device *dev)
+{
+	if (test_and_clear_bit(__LINK_STATE_TESTING, &dev->state))
+		linkwatch_fire_event(dev);
+}
+/**
+ *	netif_testing - test if device is under test
+ *	@dev: network device
+ *
+ * Check if device is under test
+ */
+static inline bool netif_testing(const struct net_device *dev)
+{
+	return test_bit(__LINK_STATE_TESTING, &dev->state);
+}
 /**
  *	netif_oper_up - test if device is operational
  *	@dev: network device
 int register_netdev(struct net_device *dev);
 void unregister_netdev(struct net_device *dev);
+int devm_register_netdev(struct device *dev, struct net_device *ndev);
 /* General hardware address lists handling functions */
 int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
 		   struct netdev_hw_addr_list *from_list, int addr_len);

include/linux/netpoll.h+1−9

@@ -63,15 +63,7 @@ int netpoll_setup(struct netpoll *np); · 62 unmodified lines
63	void __netpoll_cleanup(struct netpoll *np);	63	void __netpoll_cleanup(struct netpoll *np);
64	void __netpoll_free(struct netpoll *np);	64	void __netpoll_free(struct netpoll *np);
65	void netpoll_cleanup(struct netpoll *np);	65	void netpoll_cleanup(struct netpoll *np);
66	void netpoll_send_skb_on_dev(struct netpoll np, struct sk_buff skb,	66	netdev_tx_t netpoll_send_skb(struct netpoll np, struct sk_buff skb);
67	struct net_device *dev);
68	static inline void netpoll_send_skb(struct netpoll np, struct sk_buff skb)
69	{
70	unsigned long flags;
71	local_irq_save(flags);
72	netpoll_send_skb_on_dev(np, skb, np->dev);
73	local_irq_restore(flags);
74	}
75		67
76	#ifdef CONFIG_NETPOLL	68	#ifdef CONFIG_NETPOLL
77	static inline void netpoll_poll_lock(struct napi_struct napi)	69	static inline void netpoll_poll_lock(struct napi_struct napi)

include/linux/nmi.h+5−10

 #endif
 struct ctl_table;
-extern int proc_watchdog(struct ctl_table *, int ,
+int proc_watchdog(struct ctl_table *, int, void *, size_t *, loff_t *);
-			 void __user *, size_t *, loff_t *);
+int proc_nmi_watchdog(struct ctl_table *, int , void *, size_t *, loff_t *);
-extern int proc_nmi_watchdog(struct ctl_table *, int ,
+int proc_soft_watchdog(struct ctl_table *, int , void *, size_t *, loff_t *);
-			     void __user *, size_t *, loff_t *);
+int proc_watchdog_thresh(struct ctl_table *, int , void *, size_t *, loff_t *);
-extern int proc_soft_watchdog(struct ctl_table *, int ,
+int proc_watchdog_cpumask(struct ctl_table *, int, void *, size_t *, loff_t *);
-			      void __user *, size_t *, loff_t *);
-extern int proc_watchdog_thresh(struct ctl_table *, int ,
-				void __user *, size_t *, loff_t *);
-extern int proc_watchdog_cpumask(struct ctl_table *, int,
-				 void __user *, size_t *, loff_t *);
 #ifdef CONFIG_HAVE_ACPI_APEI_NMI
 #include <asm/nmi.h>

include/linux/of_mdio.h+10−1

@@ -30,7 +30,9 @@ extern struct mii_bus of_mdio_find_bus(struct device_node mdio_np); · 29 unmodified lines
30	extern int of_phy_register_fixed_link(struct device_node *np);	30	extern int of_phy_register_fixed_link(struct device_node *np);
31	extern void of_phy_deregister_fixed_link(struct device_node *np);	31	extern void of_phy_deregister_fixed_link(struct device_node *np);
32	extern bool of_phy_is_fixed_link(struct device_node *np);	32	extern bool of_phy_is_fixed_link(struct device_node *np);
33		33	extern int of_mdiobus_phy_device_register(struct mii_bus *mdio,
		34	struct phy_device *phy,
		35	struct device_node *child, u32 addr);
34		36
35	static inline int of_mdio_parse_addr(struct device *dev,	37	static inline int of_mdio_parse_addr(struct device *dev,
36	const struct device_node *np)	38	const struct device_node *np)
@@ -118,6 +120,13 @@ static inline bool of_phy_is_fixed_link(struct device_node *np) · 81 unmodified lines
118	{	120	{
119	return false;	121	return false;
120	}	122	}
		123
		124	static inline int of_mdiobus_phy_device_register(struct mii_bus *mdio,
		125	struct phy_device *phy,
		126	struct device_node *child, u32 addr)
		127	{
		128	return -ENOSYS;
		129	}
121	#endif	130	#endif
122		131
123		132

include/linux/perf_event.h+5−8

@@ -1280,15 +1280,12 @@ extern int sysctl_perf_cpu_time_max_percent; · 1279 unmodified lines
1280		1280
1281	extern void perf_sample_event_took(u64 sample_len_ns);	1281	extern void perf_sample_event_took(u64 sample_len_ns);
1282		1282
1283	extern int perf_proc_update_handler(struct ctl_table *table, int write,	1283	int perf_proc_update_handler(struct ctl_table *table, int write,
1284	void __user buffer, size_t lenp,	1284	void buffer, size_t lenp, loff_t *ppos);
1285	loff_t *ppos);	1285	int perf_cpu_time_max_percent_handler(struct ctl_table *table, int write,
1286	extern int perf_cpu_time_max_percent_handler(struct ctl_table *table, int write,	1286	void buffer, size_t lenp, loff_t *ppos);
1287	void __user buffer, size_t lenp,
1288	loff_t *ppos);
1289
1290	int perf_event_max_stack_handler(struct ctl_table *table, int write,	1287	int perf_event_max_stack_handler(struct ctl_table *table, int write,
1291	void __user buffer, size_t lenp, loff_t *ppos);	1288	void buffer, size_t lenp, loff_t *ppos);
1292		1289
1293	/* Access to perf_event_open(2) syscall. */	1290	/* Access to perf_event_open(2) syscall. */
1294	#define PERF_SECURITY_OPEN 0	1291	#define PERF_SECURITY_OPEN 0

include/linux/phy.h+182−11

@@ -15,6 +15,7 @@ · 14 unmodified lines
15	#include <linux/spinlock.h>	15	#include <linux/spinlock.h>
16	#include <linux/ethtool.h>	16	#include <linux/ethtool.h>
17	#include <linux/linkmode.h>	17	#include <linux/linkmode.h>
		18	#include <linux/netlink.h>
18	#include <linux/mdio.h>	19	#include <linux/mdio.h>
19	#include <linux/mii.h>	20	#include <linux/mii.h>
20	#include <linux/mii_timestamper.h>	21	#include <linux/mii_timestamper.h>
@@ -25,6 +26,7 @@ · 4 unmodified lines
25	#include <linux/u64_stats_sync.h>	26	#include <linux/u64_stats_sync.h>
26	#include <linux/irqreturn.h>	27	#include <linux/irqreturn.h>
27	#include <linux/iopoll.h>	28	#include <linux/iopoll.h>
		29	#include <linux/refcount.h>
28		30
29	#include <linux/atomic.h>	31	#include <linux/atomic.h>
30		32
@@ -77,6 +79,7 @@ extern const int phy_10gbit_features_array[1]; · 46 unmodified lines
77		79
78	#define PHY_IS_INTERNAL 0x00000001	80	#define PHY_IS_INTERNAL 0x00000001
79	#define PHY_RST_AFTER_CLK_EN 0x00000002	81	#define PHY_RST_AFTER_CLK_EN 0x00000002
		82	#define PHY_POLL_CABLE_TEST 0x00000004
80	#define MDIO_DEVICE_IS_PHY 0x80000000	83	#define MDIO_DEVICE_IS_PHY 0x80000000
81		84
82	/* Interface Mode definitions */	85	/* Interface Mode definitions */
@@ -206,12 +209,6 @@ static inline const char *phy_modes(phy_interface_t interface) · 123 unmodified lines
206		209
207	#define MII_BUS_ID_SIZE 61	210	#define MII_BUS_ID_SIZE 61
208		211
209	/* Or MII_ADDR_C45 into regnum for read/write on mii_bus to enable the 21 bit
210	IEEE 802.3ae clause 45 addressing mode used by 10GIGE phy chips. */
211	#define MII_ADDR_C45 (1<<30)
212	#define MII_DEVADDR_C45_SHIFT 16
213	#define MII_REGADDR_C45_MASK GENMASK(15, 0)
214
215	struct device;	212	struct device;
216	struct phylink;	213	struct phylink;
217	struct sfp_bus;	214	struct sfp_bus;
@@ -227,6 +224,28 @@ struct mdio_bus_stats { · 9 unmodified lines
227	struct u64_stats_sync syncp;	224	struct u64_stats_sync syncp;
228	};	225	};
229		226
		227	/* Represents a shared structure between different phydev's in the same
		228	* package, for example a quad PHY. See phy_package_join() and
		229	* phy_package_leave().
		230	*/
		231	struct phy_package_shared {
		232	int addr;
		233	refcount_t refcnt;
		234	unsigned long flags;
		235	size_t priv_size;
		236
		237	/* private data pointer */
		238	/* note that this pointer is shared between different phydevs and
		239	* the user has to take care of appropriate locking. It is allocated
		240	* and freed automatically by phy_package_join() and
		241	* phy_package_leave().
		242	*/
		243	void *priv;
		244	};
		245
		246	/* used as bit number in atomic bitops */
		247	#define PHY_SHARED_F_INIT_DONE 0
		248
230	/*	249	/*
231	* The Bus class for PHYs. Devices which provide access to	250	* The Bus class for PHYs. Devices which provide access to
232	* PHYs should register using this structure	251	* PHYs should register using this structure
@@ -241,6 +260,9 @@ struct mii_bus { · 8 unmodified lines
241	int (reset)(struct mii_bus bus);	260	int (reset)(struct mii_bus bus);
242	struct mdio_bus_stats stats[PHY_MAX_ADDR];	261	struct mdio_bus_stats stats[PHY_MAX_ADDR];
243		262
		263	unsigned int is_managed:1; /* is device-managed */
		264	unsigned int is_managed_registered:1;
		265
244	/*	266	/*
245	* A lock to ensure that only one thing can read/write	267	* A lock to ensure that only one thing can read/write
246	* the MDIO bus at a time	268	* the MDIO bus at a time
@@ -275,6 +297,12 @@ struct mii_bus { · 28 unmodified lines
275	int reset_delay_us;	297	int reset_delay_us;
276	/* RESET GPIO descriptor pointer */	298	/* RESET GPIO descriptor pointer */
277	struct gpio_desc *reset_gpiod;	299	struct gpio_desc *reset_gpiod;
		300
		301	/* protect access to the shared element */
		302	struct mutex shared_lock;
		303
		304	/* shared state across different PHYs */
		305	struct phy_package_shared *shared[PHY_MAX_ADDR];
278	};	306	};
279	#define to_mii_bus(d) container_of(d, struct mii_bus, dev)	307	#define to_mii_bus(d) container_of(d, struct mii_bus, dev)
280		308
@@ -286,6 +314,20 @@ static inline struct mii_bus *mdiobus_alloc(void) · 5 unmodified lines
286		314
287	int __mdiobus_register(struct mii_bus bus, struct module owner);	315	int __mdiobus_register(struct mii_bus bus, struct module owner);
288	#define mdiobus_register(bus) __mdiobus_register(bus, THIS_MODULE)	316	#define mdiobus_register(bus) __mdiobus_register(bus, THIS_MODULE)
		317	static inline int devm_mdiobus_register(struct mii_bus *bus)
		318	{
		319	int ret;
		320
		321	if (!bus->is_managed)
		322	return -EPERM;
		323
		324	ret = mdiobus_register(bus);
		325	if (!ret)
		326	bus->is_managed_registered = 1;
		327
		328	return ret;
		329	}
		330
289	void mdiobus_unregister(struct mii_bus *bus);	331	void mdiobus_unregister(struct mii_bus *bus);
290	void mdiobus_free(struct mii_bus *bus);	332	void mdiobus_free(struct mii_bus *bus);
291	struct mii_bus devm_mdiobus_alloc_size(struct device dev, int sizeof_priv);	333	struct mii_bus devm_mdiobus_alloc_size(struct device dev, int sizeof_priv);
@@ -326,6 +368,12 @@ struct phy_device mdiobus_scan(struct mii_bus bus, int addr); · 34 unmodified lines
326	* - irq or timer will set NOLINK if link goes down	368	* - irq or timer will set NOLINK if link goes down
327	* - phy_stop moves to HALTED	369	* - phy_stop moves to HALTED
328	*	370	*
		371	* CABLETEST: PHY is performing a cable test. Packet reception/sending
		372	* is not expected to work, carrier will be indicated as down. PHY will be
		373	* poll once per second, or on interrupt for it current state.
		374	* Once complete, move to UP to restart the PHY.
		375	* - phy_stop aborts the running test and moves to HALTED
		376	*
329	* HALTED: PHY is up, but no polling or interrupts are done. Or	377	* HALTED: PHY is up, but no polling or interrupts are done. Or
330	* PHY is in an error state.	378	* PHY is in an error state.
331	* - phy_start moves to UP	379	* - phy_start moves to UP
@@ -337,6 +385,7 @@ enum phy_state { · 5 unmodified lines
337	PHY_UP,	385	PHY_UP,
338	PHY_RUNNING,	386	PHY_RUNNING,
339	PHY_NOLINK,	387	PHY_NOLINK,
		388	PHY_CABLETEST,
340	};	389	};
341		390
342	/**	391	/**
@@ -431,6 +480,9 @@ struct phy_device { · 88 unmodified lines
431	int duplex;	480	int duplex;
432	int pause;	481	int pause;
433	int asym_pause;	482	int asym_pause;
		483	u8 master_slave_get;
		484	u8 master_slave_set;
		485	u8 master_slave_state;
434		486
435	/* Union of PHY and Attached devices' supported link modes */	487	/* Union of PHY and Attached devices' supported link modes */
436	/* See ethtool.h for more info */	488	/* See ethtool.h for more info */
@@ -461,6 +513,15 @@ struct phy_device { · 24 unmodified lines
461	/* For use by PHYs to maintain extra state */	513	/* For use by PHYs to maintain extra state */
462	void *priv;	514	void *priv;
463		515
		516	/* shared data pointer */
		517	/* For use by PHYs inside the same package that need a shared state. */
		518	struct phy_package_shared *shared;
		519
		520	/* Reporting cable test results */
		521	struct sk_buff *skb;
		522	void *ehdr;
		523	struct nlattr *nest;
		524
464	/* Interrupt and Polling infrastructure */	525	/* Interrupt and Polling infrastructure */
465	struct delayed_work state_queue;	526	struct delayed_work state_queue;
466		527
@@ -476,7 +537,7 @@ struct phy_device { · 9 unmodified lines
476	u8 mdix;	537	u8 mdix;
477	u8 mdix_ctrl;	538	u8 mdix_ctrl;
478		539
479	void (phy_link_change)(struct phy_device , bool up, bool do_carrier);	540	void (phy_link_change)(struct phy_device phydev, bool up);
480	void (adjust_link)(struct net_device dev);	541	void (adjust_link)(struct net_device dev);
481		542
482	#if IS_ENABLED(CONFIG_MACSEC)	543	#if IS_ENABLED(CONFIG_MACSEC)
@@ -487,6 +548,18 @@ struct phy_device { · 4 unmodified lines
487	#define to_phy_device(d) container_of(to_mdio_device(d), \	548	#define to_phy_device(d) container_of(to_mdio_device(d), \
488	struct phy_device, mdio)	549	struct phy_device, mdio)
489		550
		551	/* A structure containing possible configuration parameters
		552	* for a TDR cable test. The driver does not need to implement
		553	* all the parameters, but should report what is actually used.
		554	*/
		555	struct phy_tdr_config {
		556	u32 first;
		557	u32 last;
		558	u32 step;
		559	s8 pair;
		560	};
		561	#define PHY_PAIR_ALL -1
		562
490	/* struct phy_driver: Driver structure for a particular PHY type	563	/* struct phy_driver: Driver structure for a particular PHY type
491	*	564	*
492	* driver_data: static driver data	565	* driver_data: static driver data
@@ -636,6 +709,18 @@ struct phy_driver { · 143 unmodified lines
636	int (module_eeprom)(struct phy_device dev,	709	int (module_eeprom)(struct phy_device dev,
637	struct ethtool_eeprom ee, u8 data);	710	struct ethtool_eeprom ee, u8 data);
638		711
		712	/* Start a cable test */
		713	int (cable_test_start)(struct phy_device dev);
		714
		715	/* Start a raw TDR cable test */
		716	int (cable_test_tdr_start)(struct phy_device dev,
		717	const struct phy_tdr_config *config);
		718
		719	/* Once per second, or on interrupt, request the status of the
		720	* test.
		721	*/
		722	int (cable_test_get_status)(struct phy_device dev, bool *finished);
		723
639	/* Get statistics from the phy using ethtool */	724	/* Get statistics from the phy using ethtool */
640	int (get_sset_count)(struct phy_device dev);	725	int (get_sset_count)(struct phy_device dev);
641	void (get_strings)(struct phy_device dev, u8 *data);	726	void (get_strings)(struct phy_device dev, u8 *data);
@@ -649,6 +734,8 @@ struct phy_driver { · 7 unmodified lines
649	struct ethtool_tunable *tuna,	734	struct ethtool_tunable *tuna,
650	const void *data);	735	const void *data);
651	int (set_loopback)(struct phy_device dev, bool enable);	736	int (set_loopback)(struct phy_device dev, bool enable);
		737	int (get_sqi)(struct phy_device dev);
		738	int (get_sqi_max)(struct phy_device dev);
652	};	739	};
653	#define to_phy_driver(d) container_of(to_mdio_common_driver(d), \	740	#define to_phy_driver(d) container_of(to_mdio_common_driver(d), \
654	struct phy_driver, mdiodrv)	741	struct phy_driver, mdiodrv)
@@ -993,6 +1080,10 @@ static inline bool phy_interrupt_is_valid(struct phy_device *phydev) · 338 unmodified lines
993	*/	1080	*/
994	static inline bool phy_polling_mode(struct phy_device *phydev)	1081	static inline bool phy_polling_mode(struct phy_device *phydev)
995	{	1082	{
		1083	if (phydev->state == PHY_CABLETEST)
		1084	if (phydev->drv->flags & PHY_POLL_CABLE_TEST)
		1085	return true;
		1086
996	return phydev->irq == PHY_POLL;	1087	return phydev->irq == PHY_POLL;
997	}	1088	}
998		1089
@@ -1174,6 +1265,34 @@ int phy_speed_up(struct phy_device *phydev); · 175 unmodified lines
1174	int phy_restart_aneg(struct phy_device *phydev);	1265	int phy_restart_aneg(struct phy_device *phydev);
1175	int phy_reset_after_clk_enable(struct phy_device *phydev);	1266	int phy_reset_after_clk_enable(struct phy_device *phydev);
1176		1267
		1268	#if IS_ENABLED(CONFIG_PHYLIB)
		1269	int phy_start_cable_test(struct phy_device *phydev,
		1270	struct netlink_ext_ack *extack);
		1271	int phy_start_cable_test_tdr(struct phy_device *phydev,
		1272	struct netlink_ext_ack *extack,
		1273	const struct phy_tdr_config *config);
		1274	#else
		1275	static inline
		1276	int phy_start_cable_test(struct phy_device *phydev,
		1277	struct netlink_ext_ack *extack)
		1278	{
		1279	NL_SET_ERR_MSG(extack, "Kernel not compiled with PHYLIB support");
		1280	return -EOPNOTSUPP;
		1281	}
		1282	static inline
		1283	int phy_start_cable_test_tdr(struct phy_device *phydev,
		1284	struct netlink_ext_ack *extack,
		1285	const struct phy_tdr_config *config)
		1286	{
		1287	NL_SET_ERR_MSG(extack, "Kernel not compiled with PHYLIB support");
		1288	return -EOPNOTSUPP;
		1289	}
		1290	#endif
		1291
		1292	int phy_cable_test_result(struct phy_device *phydev, u8 pair, u16 result);
		1293	int phy_cable_test_fault_length(struct phy_device *phydev, u8 pair,
		1294	u16 cm);
		1295
1177	static inline void phy_device_reset(struct phy_device *phydev, int value)	1296	static inline void phy_device_reset(struct phy_device *phydev, int value)
1178	{	1297	{
1179	mdio_device_reset(&phydev->mdio, value);	1298	mdio_device_reset(&phydev->mdio, value);
@@ -1234,10 +1353,6 @@ static inline int genphy_config_aneg(struct phy_device *phydev) · 54 unmodified lines
1234	return __genphy_config_aneg(phydev, false);	1353	return __genphy_config_aneg(phydev, false);
1235	}	1354	}
1236		1355
1237	static inline int genphy_no_soft_reset(struct phy_device *phydev)
1238	{
1239	return 0;
1240	}
1241	static inline int genphy_no_ack_interrupt(struct phy_device *phydev)	1356	static inline int genphy_no_ack_interrupt(struct phy_device *phydev)
1242	{	1357	{
1243	return 0;	1358	return 0;
@@ -1341,6 +1456,10 @@ int phy_ethtool_get_link_ksettings(struct net_device *ndev, · 97 unmodified lines
1341	int phy_ethtool_set_link_ksettings(struct net_device *ndev,	1456	int phy_ethtool_set_link_ksettings(struct net_device *ndev,
1342	const struct ethtool_link_ksettings *cmd);	1457	const struct ethtool_link_ksettings *cmd);
1343	int phy_ethtool_nway_reset(struct net_device *ndev);	1458	int phy_ethtool_nway_reset(struct net_device *ndev);
		1459	int phy_package_join(struct phy_device *phydev, int addr, size_t priv_size);
		1460	void phy_package_leave(struct phy_device *phydev);
		1461	int devm_phy_package_join(struct device dev, struct phy_device phydev,
		1462	int addr, size_t priv_size);
1344		1463
1345	#if IS_ENABLED(CONFIG_PHYLIB)	1464	#if IS_ENABLED(CONFIG_PHYLIB)
1346	int __init mdio_bus_init(void);	1465	int __init mdio_bus_init(void);
@@ -1393,6 +1512,58 @@ static inline int phy_ethtool_get_stats(struct phy_device *phydev, · 46 unmodified lines
1393	return 0;	1512	return 0;
1394	}	1513	}
1395		1514
		1515	static inline int phy_package_read(struct phy_device *phydev, u32 regnum)
		1516	{
		1517	struct phy_package_shared *shared = phydev->shared;
		1518
		1519	if (!shared)
		1520	return -EIO;
		1521
		1522	return mdiobus_read(phydev->mdio.bus, shared->addr, regnum);
		1523	}
		1524
		1525	static inline int __phy_package_read(struct phy_device *phydev, u32 regnum)
		1526	{
		1527	struct phy_package_shared *shared = phydev->shared;
		1528
		1529	if (!shared)
		1530	return -EIO;
		1531
		1532	return __mdiobus_read(phydev->mdio.bus, shared->addr, regnum);
		1533	}
		1534
		1535	static inline int phy_package_write(struct phy_device *phydev,
		1536	u32 regnum, u16 val)
		1537	{
		1538	struct phy_package_shared *shared = phydev->shared;
		1539
		1540	if (!shared)
		1541	return -EIO;
		1542
		1543	return mdiobus_write(phydev->mdio.bus, shared->addr, regnum, val);
		1544	}
		1545
		1546	static inline int __phy_package_write(struct phy_device *phydev,
		1547	u32 regnum, u16 val)
		1548	{
		1549	struct phy_package_shared *shared = phydev->shared;
		1550
		1551	if (!shared)
		1552	return -EIO;
		1553
		1554	return __mdiobus_write(phydev->mdio.bus, shared->addr, regnum, val);
		1555	}
		1556
		1557	static inline bool phy_package_init_once(struct phy_device *phydev)
		1558	{
		1559	struct phy_package_shared *shared = phydev->shared;
		1560
		1561	if (!shared)
		1562	return false;
		1563
		1564	return !test_and_set_bit(PHY_SHARED_F_INIT_DONE, &shared->flags);
		1565	}
		1566
1396	extern struct bus_type mdio_bus_type;	1567	extern struct bus_type mdio_bus_type;
1397		1568
1398	struct mdio_board_info {	1569	struct mdio_board_info {

include/linux/phylink.h+3−3

 	struct device *dev;
 	enum phylink_op_type type;
 	bool pcs_poll;
+	bool poll_fixed_state;
+	void (*get_fixed_state)(struct phylink_config *config,
+				struct phylink_link_state *state);
 };
 /**
 int phylink_connect_phy(struct phylink *, struct phy_device *);
 int phylink_of_phy_connect(struct phylink *, struct device_node *, u32 flags);
 void phylink_disconnect_phy(struct phylink *);
-int phylink_fixed_state_cb(struct phylink *,
-			   void (*cb)(struct net_device *dev,
-				      struct phylink_link_state *));
 void phylink_mac_change(struct phylink *, bool up);

include/linux/pid.h+3−0

@@ -108,6 +108,9 @@ extern void transfer_pid(struct task_struct old, struct task_struct new, · 107 unmodified lines
108	struct pid_namespace;	108	struct pid_namespace;
109	extern struct pid_namespace init_pid_ns;	109	extern struct pid_namespace init_pid_ns;
110		110
		111	extern int pid_max;
		112	extern int pid_max_min, pid_max_max;
		113
111	/*	114	/*
112	* look up a PID in the hash table. Must be called with the tasklist_lock	115	* look up a PID in the hash table. Must be called with the tasklist_lock
113	* or rcu_read_lock() held.	116	* or rcu_read_lock() held.

include/linux/printk.h+1−1

@@ -189,7 +189,7 @@ extern int printk_delay_msec; · 188 unmodified lines
189	extern int dmesg_restrict;	189	extern int dmesg_restrict;
190		190
191	extern int	191	extern int
192	devkmsg_sysctl_set_loglvl(struct ctl_table table, int write, void __user buf,	192	devkmsg_sysctl_set_loglvl(struct ctl_table table, int write, void buf,
193	size_t lenp, loff_t ppos);	193	size_t lenp, loff_t ppos);
194		194
195	extern void wake_up_klogd(void);	195	extern void wake_up_klogd(void);

include/linux/proc_fs.h+3−0

@@ -105,6 +105,9 @@ struct proc_dir_entry proc_create_net_single_write(const char name, umode_t mo · 104 unmodified lines
105	void *data);	105	void *data);
106	extern struct pid tgid_pidfd_to_pid(const struct file file);	106	extern struct pid tgid_pidfd_to_pid(const struct file file);
107		107
		108	extern int bpf_iter_init_seq_net(void *priv_data);
		109	extern void bpf_iter_fini_seq_net(void *priv_data);
		110
108	#ifdef CONFIG_PROC_PID_ARCH_STATUS	111	#ifdef CONFIG_PROC_PID_ARCH_STATUS
109	/*	112	/*
110	* The architecture which selects CONFIG_PROC_PID_ARCH_STATUS must	113	* The architecture which selects CONFIG_PROC_PID_ARCH_STATUS must

include/linux/ptp_clock_kernel.h+5−1

 };
 /**
- * struct ptp_clock_info - decribes a PTP hardware clock
+ * struct ptp_clock_info - describes a PTP hardware clock
  *
  * @owner:     The clock driver should set to THIS_MODULE.
  * @name:      A short "friendly name" to identify the clock and to
  *            parameter delta: Desired frequency offset from nominal frequency
  *            in parts per billion
  *
+ * @adjphase:  Adjusts the phase offset of the hardware clock.
+ *             parameter delta: Desired change in nanoseconds.
+ *
  * @adjtime:  Shifts the time of the hardware clock.
  *            parameter delta: Desired change in nanoseconds.
  *
 	struct ptp_pin_desc *pin_config;
 	int (*adjfine)(struct ptp_clock_info *ptp, long scaled_ppm);
 	int (*adjfreq)(struct ptp_clock_info *ptp, s32 delta);
+	int (*adjphase)(struct ptp_clock_info *ptp, s32 phase);
 	int (*adjtime)(struct ptp_clock_info *ptp, s64 delta);
 	int (*gettime64)(struct ptp_clock_info *ptp, struct timespec64 *ts);
 	int (*gettimex64)(struct ptp_clock_info *ptp, struct timespec64 *ts,

include/linux/qed/qed_if.h+23−3

 	struct qed_dev *cdev;
 };
+enum qed_hw_err_type {
+	QED_HW_ERR_FAN_FAIL,
+	QED_HW_ERR_MFW_RESP_FAIL,
+	QED_HW_ERR_HW_ATTN,
+	QED_HW_ERR_DMAE_FAIL,
+	QED_HW_ERR_RAMROD_FAIL,
+	QED_HW_ERR_FW_ASSERT,
+	QED_HW_ERR_LAST,
+};
 enum qed_dev_type {
 	QED_DEV_TYPE_BB,
 	QED_DEV_TYPE_AH,
 struct qed_common_cb_ops {
 	void (*arfs_filter_op)(void *dev, void *fltr, u8 fw_rc);
-	void	(*link_update)(void			*dev,
+	void (*link_update)(void *dev, struct qed_link_output *link);
-			       struct qed_link_output	*link);
 	void (*schedule_recovery_handler)(void *dev);
-	void	(*dcbx_aen)(void *dev, struct qed_dcbx_get *get, u32 mib_type);
+	void (*schedule_hw_err_handler)(void *dev,
+					enum qed_hw_err_type err_type);
+	void (*dcbx_aen)(void *dev, struct qed_dcbx_get *get, u32 mib_type);
 	void (*get_generic_tlv_data)(void *dev, struct qed_generic_tlvs *data);
 	void (*get_protocol_tlv_data)(void *dev, void *data);
 };
  */
 	int (*set_led)(struct qed_dev *cdev,
 		       enum qed_led_mode mode);
+/**
+ * @brief attn_clr_enable - Prevent attentions from being reasserted
+ *
+ * @param cdev
+ * @param clr_enable
+ */
+	void (*attn_clr_enable)(struct qed_dev *cdev, bool clr_enable);
 /**
  * @brief db_recovery_add - add doorbell information to the doorbell
  * recovery mechanism.

include/linux/qed/qed_rdma_if.h+22−0

 	QED_ROCE_QP_STATE_SQE
 };
+enum qed_rdma_qp_type {
+	QED_RDMA_QP_TYPE_RC,
+	QED_RDMA_QP_TYPE_XRC_INI,
+	QED_RDMA_QP_TYPE_XRC_TGT,
+	QED_RDMA_QP_TYPE_INVAL = 0xffff,
+};
 enum qed_rdma_tid_type {
 	QED_RDMA_TID_REGISTERED_MR,
 	QED_RDMA_TID_FMR,
 	u16 num_pages;
 	u16 pd_id;
 	u16 page_size;
+	/* XRC related only */
+	bool reserved_key_en;
+	bool is_xrc;
+	u32 cq_cid;
+	u16 xrcd_id;
 };
 struct qed_rdma_destroy_cq_in_params {
 	u16 rq_num_pages;
 	u64 rq_pbl_ptr;
 	u16 srq_id;
+	u16 xrcd_id;
 	u8 stats_queue;
+	enum qed_rdma_qp_type qp_type;
+	u8 flags;
+#define QED_ROCE_EDPM_MODE_MASK      0x1
+#define QED_ROCE_EDPM_MODE_SHIFT     0
 };
 struct qed_rdma_create_qp_out_params {
 struct qed_rdma_destroy_srq_in_params {
 	u16 srq_id;
+	bool is_xrc;
 };
 struct qed_rdma_modify_srq_in_params {
 	u32 wqe_limit;
 	u16 srq_id;
+	bool is_xrc;
 };
 struct qed_rdma_stats_out_params {
 	int (*rdma_set_rdma_int)(struct qed_dev *cdev, u16 cnt);
 	int (*rdma_alloc_pd)(void *rdma_cxt, u16 *pd);
 	void (*rdma_dealloc_pd)(void *rdma_cxt, u16 pd);
+	int (*rdma_alloc_xrcd)(void *rdma_cxt, u16 *xrcd);
+	void (*rdma_dealloc_xrcd)(void *rdma_cxt, u16 xrcd);
 	int (*rdma_create_cq)(void *rdma_cxt,
 			      struct qed_rdma_create_cq_in_params *params,
 			      u16 *icid);

include/linux/sched/sysctl.h+15−29

@@ -12,9 +12,8 @@ extern unsigned int sysctl_hung_task_panic; · 11 unmodified lines
12	extern unsigned long sysctl_hung_task_timeout_secs;	12	extern unsigned long sysctl_hung_task_timeout_secs;
13	extern unsigned long sysctl_hung_task_check_interval_secs;	13	extern unsigned long sysctl_hung_task_check_interval_secs;
14	extern int sysctl_hung_task_warnings;	14	extern int sysctl_hung_task_warnings;
15	extern int proc_dohung_task_timeout_secs(struct ctl_table *table, int write,	15	int proc_dohung_task_timeout_secs(struct ctl_table *table, int write,
16	void __user *buffer,	16	void buffer, size_t lenp, loff_t *ppos);
17	size_t lenp, loff_t ppos);
18	#else	17	#else
19	/* Avoid need for ifdefs elsewhere in the code */	18	/* Avoid need for ifdefs elsewhere in the code */
20	enum { sysctl_hung_task_timeout_secs = 0 };	19	enum { sysctl_hung_task_timeout_secs = 0 };
@@ -43,8 +42,7 @@ extern __read_mostly unsigned int sysctl_sched_migration_cost; · 22 unmodified lines
43	extern __read_mostly unsigned int sysctl_sched_nr_migrate;	42	extern __read_mostly unsigned int sysctl_sched_nr_migrate;
44		43
45	int sched_proc_update_handler(struct ctl_table *table, int write,	44	int sched_proc_update_handler(struct ctl_table *table, int write,
46	void __user buffer, size_t length,	45	void buffer, size_t length, loff_t *ppos);
47	loff_t *ppos);
48	#endif	46	#endif
49		47
50	/*	48	/*
@@ -72,33 +70,21 @@ extern unsigned int sysctl_sched_autogroup_enabled; · 21 unmodified lines
72	extern int sysctl_sched_rr_timeslice;	70	extern int sysctl_sched_rr_timeslice;
73	extern int sched_rr_timeslice;	71	extern int sched_rr_timeslice;
74		72
75	extern int sched_rr_handler(struct ctl_table *table, int write,	73	int sched_rr_handler(struct ctl_table table, int write, void buffer,
76	void __user buffer, size_t lenp,	74	size_t lenp, loff_t ppos);
77	loff_t *ppos);	75	int sched_rt_handler(struct ctl_table table, int write, void buffer,
78		76	size_t lenp, loff_t ppos);
79	extern int sched_rt_handler(struct ctl_table *table, int write,	77	int sysctl_sched_uclamp_handler(struct ctl_table *table, int write,
80	void __user buffer, size_t lenp,	78	void buffer, size_t lenp, loff_t *ppos);
81	loff_t *ppos);	79	int sysctl_numa_balancing(struct ctl_table table, int write, void buffer,
82		80	size_t lenp, loff_t ppos);
83	#ifdef CONFIG_UCLAMP_TASK	81	int sysctl_schedstats(struct ctl_table table, int write, void buffer,
84	extern int sysctl_sched_uclamp_handler(struct ctl_table *table, int write,	82	size_t lenp, loff_t ppos);
85	void __user buffer, size_t lenp,
86	loff_t *ppos);
87	#endif
88
89	extern int sysctl_numa_balancing(struct ctl_table *table, int write,
90	void __user buffer, size_t lenp,
91	loff_t *ppos);
92
93	extern int sysctl_schedstats(struct ctl_table *table, int write,
94	void __user buffer, size_t lenp,
95	loff_t *ppos);
96		83
97	#if defined(CONFIG_ENERGY_MODEL) && defined(CONFIG_CPU_FREQ_GOV_SCHEDUTIL)	84	#if defined(CONFIG_ENERGY_MODEL) && defined(CONFIG_CPU_FREQ_GOV_SCHEDUTIL)
98	extern unsigned int sysctl_sched_energy_aware;	85	extern unsigned int sysctl_sched_energy_aware;
99	extern int sched_energy_aware_handler(struct ctl_table *table, int write,	86	int sched_energy_aware_handler(struct ctl_table *table, int write,
100	void __user buffer, size_t lenp,	87	void buffer, size_t lenp, loff_t *ppos);
101	loff_t *ppos);
102	#endif	88	#endif
103		89
104	#endif /* _LINUX_SCHED_SYSCTL_H */	90	#endif /* _LINUX_SCHED_SYSCTL_H */

include/linux/security.h+1−1

@@ -211,7 +211,7 @@ struct request_sock; · 210 unmodified lines
211		211
212	#ifdef CONFIG_MMU	212	#ifdef CONFIG_MMU
213	extern int mmap_min_addr_handler(struct ctl_table *table, int write,	213	extern int mmap_min_addr_handler(struct ctl_table *table, int write,
214	void __user buffer, size_t lenp, loff_t *ppos);	214	void buffer, size_t lenp, loff_t *ppos);
215	#endif	215	#endif
216		216
217	/* security_inode_init_security callback function to write xattrs */	217	/* security_inode_init_security callback function to write xattrs */

include/linux/skbuff.h+9−27

 			     const struct flow_dissector_key *key,
 			     unsigned int key_count);
-#ifdef CONFIG_NET
-int skb_flow_dissector_prog_query(const union bpf_attr *attr,
-				  union bpf_attr __user *uattr);
-int skb_flow_dissector_bpf_prog_attach(const union bpf_attr *attr,
-				       struct bpf_prog *prog);
-int skb_flow_dissector_bpf_prog_detach(const union bpf_attr *attr);
-#else
-static inline int skb_flow_dissector_prog_query(const union bpf_attr *attr,
-						union bpf_attr __user *uattr)
-{
-	return -EOPNOTSUPP;
-}
-static inline int skb_flow_dissector_bpf_prog_attach(const union bpf_attr *attr,
-						     struct bpf_prog *prog)
-{
-	return -EOPNOTSUPP;
-}
-static inline int skb_flow_dissector_bpf_prog_detach(const union bpf_attr *attr)
-{
-	return -EOPNOTSUPP;
-}
-#endif
 struct bpf_flow_dissector;
 bool bpf_flow_dissect(struct bpf_prog *prog, struct bpf_flow_dissector *ctx,
 		      __be16 proto, int nhoff, int hlen, unsigned int flags);
 	}
 }
+static inline void __skb_reset_checksum_unnecessary(struct sk_buff *skb)
+{
+	if (skb->ip_summed == CHECKSUM_UNNECESSARY) {
+		skb->ip_summed = CHECKSUM_NONE;
+		skb->csum_level = 0;
+	}
+}
 /* Check if we need to perform checksum complete validation.
  *
  * Returns true if checksum complete is needed, false otherwise
 	char data[] __aligned(8);
 };
-struct skb_ext *__skb_ext_alloc(void);
+struct skb_ext *__skb_ext_alloc(gfp_t flags);
 void *__skb_ext_set(struct sk_buff *skb, enum skb_ext_id id,
 		    struct skb_ext *ext);
 void *skb_ext_add(struct sk_buff *skb, enum skb_ext_id id);

include/linux/skmsg.h+8−0

@@ -437,4 +437,12 @@ static inline void psock_progs_drop(struct sk_psock_progs *progs) · 436 unmodified lines
437	psock_set_prog(&progs->skb_verdict, NULL);	437	psock_set_prog(&progs->skb_verdict, NULL);
438	}	438	}
439		439
		440	int sk_psock_tls_strp_read(struct sk_psock psock, struct sk_buff skb);
		441
		442	static inline bool sk_psock_strp_enabled(struct sk_psock *psock)
		443	{
		444	if (!psock)
		445	return false;
		446	return psock->parser.enabled;
		447	}
440	#endif /* _LINUX_SKMSG_H */	448	#endif /* _LINUX_SKMSG_H */

include/linux/socket.h+15−2

@@ -50,7 +50,17 @@ struct msghdr { · 49 unmodified lines
50	void msg_name; / ptr to socket address structure */	50	void msg_name; / ptr to socket address structure */
51	int msg_namelen; /* size of socket address structure */	51	int msg_namelen; /* size of socket address structure */
52	struct iov_iter msg_iter; /* data */	52	struct iov_iter msg_iter; /* data */
53	void msg_control; / ancillary data */	53
		54	/*
		55	* Ancillary data. msg_control_user is the user buffer used for the
		56	* recv* side when msg_control_is_user is set, msg_control is the kernel
		57	* buffer used for all other cases.
		58	*/
		59	union {
		60	void *msg_control;
		61	void __user *msg_control_user;
		62	};
		63	bool msg_control_is_user : 1;
54	__kernel_size_t msg_controllen; /* ancillary data buffer length */	64	__kernel_size_t msg_controllen; /* ancillary data buffer length */
55	unsigned int msg_flags; /* flags on received message */	65	unsigned int msg_flags; /* flags on received message */
56	struct kiocb msg_iocb; / ptr to iocb for async requests */	66	struct kiocb msg_iocb; / ptr to iocb for async requests */
@@ -94,7 +104,10 @@ struct cmsghdr { · 37 unmodified lines
94		104
95	#define CMSG_ALIGN(len) ( ((len)+sizeof(long)-1) & ~(sizeof(long)-1) )	105	#define CMSG_ALIGN(len) ( ((len)+sizeof(long)-1) & ~(sizeof(long)-1) )
96		106
97	#define CMSG_DATA(cmsg) ((void )((char )(cmsg) + sizeof(struct cmsghdr)))	107	#define CMSG_DATA(cmsg) \
		108	((void *)(cmsg) + sizeof(struct cmsghdr))
		109	#define CMSG_USER_DATA(cmsg) \
		110	((void __user *)(cmsg) + sizeof(struct cmsghdr))
98	#define CMSG_SPACE(len) (sizeof(struct cmsghdr) + CMSG_ALIGN(len))	111	#define CMSG_SPACE(len) (sizeof(struct cmsghdr) + CMSG_ALIGN(len))
99	#define CMSG_LEN(len) (sizeof(struct cmsghdr) + (len))	112	#define CMSG_LEN(len) (sizeof(struct cmsghdr) + (len))
100		113

include/linux/sysctl.h+30−31

@@ -44,35 +44,26 @@ struct ctl_dir; · 43 unmodified lines
44		44
45	extern const int sysctl_vals[];	45	extern const int sysctl_vals[];
46		46
47	typedef int proc_handler (struct ctl_table *ctl, int write,	47	typedef int proc_handler(struct ctl_table ctl, int write, void buffer,
48	void __user buffer, size_t lenp, loff_t *ppos);	48	size_t lenp, loff_t ppos);
49		49
50	extern int proc_dostring(struct ctl_table *, int,	50	int proc_dostring(struct ctl_table , int, void , size_t , loff_t );
51	void __user , size_t , loff_t *);	51	int proc_dointvec(struct ctl_table , int, void , size_t , loff_t );
52	extern int proc_dointvec(struct ctl_table *, int,	52	int proc_douintvec(struct ctl_table , int, void , size_t , loff_t );
53	void __user , size_t , loff_t *);	53	int proc_dointvec_minmax(struct ctl_table , int, void , size_t , loff_t );
54	extern int proc_douintvec(struct ctl_table *, int,	54	int proc_douintvec_minmax(struct ctl_table table, int write, void buffer,
55	void __user , size_t , loff_t *);	55	size_t lenp, loff_t ppos);
56	extern int proc_dointvec_minmax(struct ctl_table *, int,	56	int proc_dointvec_jiffies(struct ctl_table , int, void , size_t , loff_t );
57	void __user , size_t , loff_t *);	57	int proc_dointvec_userhz_jiffies(struct ctl_table , int, void , size_t *,
58	extern int proc_douintvec_minmax(struct ctl_table *table, int write,	58	loff_t *);
59	void __user buffer, size_t lenp,	59	int proc_dointvec_ms_jiffies(struct ctl_table , int, void , size_t *,
60	loff_t *ppos);	60	loff_t *);
61	extern int proc_dointvec_jiffies(struct ctl_table *, int,	61	int proc_doulongvec_minmax(struct ctl_table , int, void , size_t , loff_t );
62	void __user , size_t , loff_t *);	62	int proc_doulongvec_ms_jiffies_minmax(struct ctl_table table, int, void ,
63	extern int proc_dointvec_userhz_jiffies(struct ctl_table *, int,	63	size_t , loff_t );
64	void __user , size_t , loff_t *);	64	int proc_do_large_bitmap(struct ctl_table , int, void , size_t , loff_t );
65	extern int proc_dointvec_ms_jiffies(struct ctl_table *, int,	65	int proc_do_static_key(struct ctl_table table, int write, void buffer,
66	void __user , size_t , loff_t *);	66	size_t lenp, loff_t ppos);
67	extern int proc_doulongvec_minmax(struct ctl_table *, int,
68	void __user , size_t , loff_t *);
69	extern int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int,
70	void __user , size_t , loff_t *);
71	extern int proc_do_large_bitmap(struct ctl_table *, int,
72	void __user , size_t , loff_t *);
73	extern int proc_do_static_key(struct ctl_table *table, int write,
74	void __user buffer, size_t lenp,
75	loff_t *ppos);
76		67
77	/*	68	/*
78	* Register a set of sysctl names by calling register_sysctl_table	69	* Register a set of sysctl names by calling register_sysctl_table
@@ -207,7 +198,15 @@ void unregister_sysctl_table(struct ctl_table_header * table); · 128 unmodified lines
207		198
208	extern int sysctl_init(void);	199	extern int sysctl_init(void);
209		200
		201	extern int pwrsw_enabled;
		202	extern int unaligned_enabled;
		203	extern int unaligned_dump_stack;
		204	extern int no_unaligned_warning;
		205
210	extern struct ctl_table sysctl_mount_point[];	206	extern struct ctl_table sysctl_mount_point[];
		207	extern struct ctl_table random_table[];
		208	extern struct ctl_table firmware_config_table[];
		209	extern struct ctl_table epoll_table[];
211		210
212	#else /* CONFIG_SYSCTL */	211	#else /* CONFIG_SYSCTL */
213	static inline struct ctl_table_header register_sysctl_table(struct ctl_table table)	212	static inline struct ctl_table_header register_sysctl_table(struct ctl_table table)
@@ -238,7 +237,7 @@ static inline void setup_sysctl_set(struct ctl_table_set *p, · 24 unmodified lines
238		237
239	#endif /* CONFIG_SYSCTL */	238	#endif /* CONFIG_SYSCTL */
240		239
241	int sysctl_max_threads(struct ctl_table *table, int write,	240	int sysctl_max_threads(struct ctl_table table, int write, void buffer,
242	void __user buffer, size_t lenp, loff_t *ppos);	241	size_t lenp, loff_t ppos);
243		242
244	#endif /* _LINUX_SYSCTL_H */	243	#endif /* _LINUX_SYSCTL_H */

include/linux/tcp.h+13−0

 	u64				snt_synack; /* first SYNACK sent time */
 	bool				tfo_listener;
 	bool				is_mptcp;
+#if IS_ENABLED(CONFIG_MPTCP)
+	bool				drop_req;
+#endif
 	u32				txhash;
 	u32				rcv_isn;
 	u32				snt_isn;
 	} rack;
 	u16	advmss;		/* Advertised MSS			*/
 	u8	compressed_ack;
+	u8	dup_ack_counter;
 	u32	chrono_start;	/* Start time in jiffies of a TCP chrono */
 	u32	chrono_stat[3];	/* Time in jiffies for chrono_stat stats */
 	u8	chrono_type:2,	/* current chronograph type */
 int tcp_skb_shift(struct sk_buff *to, struct sk_buff *from, int pcount,
 		  int shiftlen);
+void tcp_sock_set_cork(struct sock *sk, bool on);
+int tcp_sock_set_keepcnt(struct sock *sk, int val);
+int tcp_sock_set_keepidle(struct sock *sk, int val);
+int tcp_sock_set_keepintvl(struct sock *sk, int val);
+void tcp_sock_set_nodelay(struct sock *sk);
+void tcp_sock_set_quickack(struct sock *sk, int val);
+int tcp_sock_set_syncnt(struct sock *sk, int val);
+void tcp_sock_set_user_timeout(struct sock *sk, u32 val);
 #endif	/* _LINUX_TCP_H */

include/linux/timer.h+1−2

@@ -201,8 +201,7 @@ struct ctl_table; · 200 unmodified lines
201		201
202	extern unsigned int sysctl_timer_migration;	202	extern unsigned int sysctl_timer_migration;
203	int timer_migration_handler(struct ctl_table *table, int write,	203	int timer_migration_handler(struct ctl_table *table, int write,
204	void __user buffer, size_t lenp,	204	void buffer, size_t lenp, loff_t *ppos);
205	loff_t *ppos);
206	#endif	205	#endif
207		206
208	unsigned long __round_jiffies(unsigned long j, int cpu);	207	unsigned long __round_jiffies(unsigned long j, int cpu);

include/linux/vermagic.h+4−0

@@ -2,6 +2,10 @@ · 1 unmodified line
2	#ifndef _LINUX_VERMAGIC_H	2	#ifndef _LINUX_VERMAGIC_H
3	#define _LINUX_VERMAGIC_H	3	#define _LINUX_VERMAGIC_H
4		4
		5	#ifndef INCLUDE_VERMAGIC
		6	#error "This header can be included from kernel/module.c or *.mod.c only"
		7	#endif
		8
5	#include <generated/utsrelease.h>	9	#include <generated/utsrelease.h>
6	#include <asm/vermagic.h>	10	#include <asm/vermagic.h>
7		11

include/linux/vmstat.h+4−4

@@ -16,8 +16,8 @@ extern int sysctl_stat_interval; · 15 unmodified lines
16	#define DISABLE_NUMA_STAT 0	16	#define DISABLE_NUMA_STAT 0
17	extern int sysctl_vm_numa_stat;	17	extern int sysctl_vm_numa_stat;
18	DECLARE_STATIC_KEY_TRUE(vm_numa_stat_key);	18	DECLARE_STATIC_KEY_TRUE(vm_numa_stat_key);
19	extern int sysctl_vm_numa_stat_handler(struct ctl_table *table,	19	int sysctl_vm_numa_stat_handler(struct ctl_table *table, int write,
20	int write, void __user buffer, size_t length, loff_t *ppos);	20	void buffer, size_t length, loff_t *ppos);
21	#endif	21	#endif
22		22
23	struct reclaim_stat {	23	struct reclaim_stat {
@@ -274,8 +274,8 @@ void cpu_vm_stats_fold(int cpu); · 250 unmodified lines
274	void refresh_zone_stat_thresholds(void);	274	void refresh_zone_stat_thresholds(void);
275		275
276	struct ctl_table;	276	struct ctl_table;
277	int vmstat_refresh(struct ctl_table *, int write,	277	int vmstat_refresh(struct ctl_table , int write, void buffer, size_t *lenp,
278	void __user buffer, size_t lenp, loff_t *ppos);	278	loff_t *ppos);
279		279
280	void drain_zonestat(struct zone zone, struct per_cpu_pageset );	280	void drain_zonestat(struct zone zone, struct per_cpu_pageset );
281		281

include/linux/writeback.h+11−17

@@ -362,24 +362,18 @@ extern int vm_highmem_is_dirtyable; · 361 unmodified lines
362	extern int block_dump;	362	extern int block_dump;
363	extern int laptop_mode;	363	extern int laptop_mode;
364		364
365	extern int dirty_background_ratio_handler(struct ctl_table *table, int write,	365	int dirty_background_ratio_handler(struct ctl_table *table, int write,
366	void __user buffer, size_t lenp,	366	void buffer, size_t lenp, loff_t *ppos);
367	loff_t *ppos);	367	int dirty_background_bytes_handler(struct ctl_table *table, int write,
368	extern int dirty_background_bytes_handler(struct ctl_table *table, int write,	368	void buffer, size_t lenp, loff_t *ppos);
369	void __user buffer, size_t lenp,	369	int dirty_ratio_handler(struct ctl_table *table, int write,
370	loff_t *ppos);	370	void buffer, size_t lenp, loff_t *ppos);
371	extern int dirty_ratio_handler(struct ctl_table *table, int write,	371	int dirty_bytes_handler(struct ctl_table *table, int write,
372	void __user buffer, size_t lenp,	372	void buffer, size_t lenp, loff_t *ppos);
373	loff_t *ppos);
374	extern int dirty_bytes_handler(struct ctl_table *table, int write,
375	void __user buffer, size_t lenp,
376	loff_t *ppos);
377	int dirtytime_interval_handler(struct ctl_table *table, int write,	373	int dirtytime_interval_handler(struct ctl_table *table, int write,
378	void __user buffer, size_t lenp, loff_t *ppos);	374	void buffer, size_t lenp, loff_t *ppos);
379		375	int dirty_writeback_centisecs_handler(struct ctl_table *table, int write,
380	struct ctl_table;	376	void buffer, size_t lenp, loff_t *ppos);
381	int dirty_writeback_centisecs_handler(struct ctl_table *, int,
382	void __user , size_t , loff_t *);
383		377
384	void global_dirty_limits(unsigned long pbackground, unsigned long pdirty);	378	void global_dirty_limits(unsigned long pbackground, unsigned long pdirty);
385	unsigned long wb_calc_thresh(struct bdi_writeback *wb, unsigned long thresh);	379	unsigned long wb_calc_thresh(struct bdi_writeback *wb, unsigned long thresh);