lael-labs/linux

include/linux/amba/bus.h+1−0

@@ -65,6 +65,7 @@ struct amba_device { · 64 unmodified lines
65	struct device dev;	65	struct device dev;
66	struct resource res;	66	struct resource res;
67	struct clk *pclk;	67	struct clk *pclk;
		68	struct device_dma_parameters dma_parms;
68	unsigned int periphid;	69	unsigned int periphid;
69	unsigned int cid;	70	unsigned int cid;
70	struct amba_cs_uci_id uci;	71	struct amba_cs_uci_id uci;

include/linux/backing-dev-defs.h+1−1

 	WB_REASON_SYNC,
 	WB_REASON_PERIODIC,
 	WB_REASON_LAPTOP_TIMER,
-	WB_REASON_FREE_MORE_MEM,
 	WB_REASON_FS_FREE_SPACE,
 	/*
 	 * There is no bdi forker thread any more and works are done
 	wait_queue_head_t wb_waitq;
 	struct device *dev;
+	char dev_name[64];
 	struct device *owner;
 	struct timer_list laptop_mode_wb_timer;

include/linux/backing-dev.h+1−8

@@ -505,13 +505,6 @@ static inline int bdi_rw_congested(struct backing_dev_info *bdi) · 504 unmodified lines
505	(1 << WB_async_congested));	505	(1 << WB_async_congested));
506	}	506	}
507		507
508	extern const char *bdi_unknown_name;	508	const char bdi_dev_name(struct backing_dev_info bdi);
509
510	static inline const char bdi_dev_name(struct backing_dev_info bdi)
511	{
512	if (!bdi \|\| !bdi->dev)
513	return bdi_unknown_name;
514	return dev_name(bdi->dev);
515	}
516		509
517	#endif /* _LINUX_BACKING_DEV_H */	510	#endif /* _LINUX_BACKING_DEV_H */

include/linux/compiler.h+53−0

@@ -120,12 +120,65 @@ void ftrace_likely_update(struct ftrace_likely_data *f, int val, · 119 unmodified lines
120	/* Annotate a C jump table to allow objtool to follow the code flow */	120	/* Annotate a C jump table to allow objtool to follow the code flow */
121	#define __annotate_jump_table __section(.rodata..c_jump_table)	121	#define __annotate_jump_table __section(.rodata..c_jump_table)
122		122
		123	#ifdef CONFIG_DEBUG_ENTRY
		124	/* Begin/end of an instrumentation safe region */
		125	#define instrumentation_begin() ({ \
		126	asm volatile("%c0:\n\t" \
		127	".pushsection .discard.instr_begin\n\t" \
		128	".long %c0b - .\n\t" \
		129	".popsection\n\t" : : "i" (__COUNTER__)); \
		130	})
		131
		132	/*
		133	* Because instrumentation_{begin,end}() can nest, objtool validation considers
		134	* _begin() a +1 and _end() a -1 and computes a sum over the instructions.
		135	* When the value is greater than 0, we consider instrumentation allowed.
		136	*
		137	* There is a problem with code like:
		138	*
		139	* noinstr void foo()
		140	* {
		141	* instrumentation_begin();
		142	* ...
		143	* if (cond) {
		144	* instrumentation_begin();
		145	* ...
		146	* instrumentation_end();
		147	* }
		148	* bar();
		149	* instrumentation_end();
		150	* }
		151	*
		152	* If instrumentation_end() would be an empty label, like all the other
		153	* annotations, the inner _end(), which is at the end of a conditional block,
		154	* would land on the instruction after the block.
		155	*
		156	* If we then consider the sum of the !cond path, we'll see that the call to
		157	* bar() is with a 0-value, even though, we meant it to happen with a positive
		158	* value.
		159	*
		160	* To avoid this, have _end() be a NOP instruction, this ensures it will be
		161	* part of the condition block and does not escape.
		162	*/
		163	#define instrumentation_end() ({ \
		164	asm volatile("%c0: nop\n\t" \
		165	".pushsection .discard.instr_end\n\t" \
		166	".long %c0b - .\n\t" \
		167	".popsection\n\t" : : "i" (__COUNTER__)); \
		168	})
		169	#endif /* CONFIG_DEBUG_ENTRY */
		170
123	#else	171	#else
124	#define annotate_reachable()	172	#define annotate_reachable()
125	#define annotate_unreachable()	173	#define annotate_unreachable()
126	#define __annotate_jump_table	174	#define __annotate_jump_table
127	#endif	175	#endif
128		176
		177	#ifndef instrumentation_begin
		178	#define instrumentation_begin() do { } while(0)
		179	#define instrumentation_end() do { } while(0)
		180	#endif
		181
129	#ifndef ASM_UNREACHABLE	182	#ifndef ASM_UNREACHABLE
130	# define ASM_UNREACHABLE	183	# define ASM_UNREACHABLE
131	#endif	184	#endif

include/linux/compiler_types.h+4−0

 #define notrace			__attribute__((__no_instrument_function__))
 #endif
+/* Section for code which can't be instrumented at all */
+#define noinstr								\
+	noinline notrace __attribute((__section__(".noinstr.text")))
 /*
  * it doesn't make sense on ARM (currently the only user of __naked)
  * to trace naked functions because then mcount is called without

include/linux/debugfs.h+4−8

 		       u8 *value);
 void debugfs_create_u16(const char *name, umode_t mode, struct dentry *parent,
 			u16 *value);
-struct dentry *debugfs_create_u32(const char *name, umode_t mode,
+void debugfs_create_u32(const char *name, umode_t mode, struct dentry *parent,
-				  struct dentry *parent, u32 *value);
+			u32 *value);
 void debugfs_create_u64(const char *name, umode_t mode, struct dentry *parent,
 			u64 *value);
 struct dentry *debugfs_create_ulong(const char *name, umode_t mode,
 static inline void debugfs_create_u16(const char *name, umode_t mode,
 				      struct dentry *parent, u16 *value) { }
-static inline struct dentry *debugfs_create_u32(const char *name, umode_t mode,
+static inline void debugfs_create_u32(const char *name, umode_t mode,
-						struct dentry *parent,
+				      struct dentry *parent, u32 *value) { }
-						u32 *value)
-{
-	return ERR_PTR(-ENODEV);
-}
 static inline void debugfs_create_u64(const char *name, umode_t mode,
 				      struct dentry *parent, u64 *value) { }

include/linux/dma-buf.h+1−2

 /**
  * struct dma_buf_attach_ops - importer operations for an attachment
- * @move_notify: [optional] notification that the DMA-buf is moving
  *
  * Attachment operations implemented by the importer.
  */
 struct dma_buf_attach_ops {
 	/**
-	 * @move_notify
+	 * @move_notify: [optional] notification that the DMA-buf is moving
 	 *
 	 * If this callback is provided the framework can avoid pinning the
 	 * backing store while mappings exists.

include/linux/dmaengine.h+6−6

 /**
  * Interleaved Transfer Request
  * ----------------------------
- * A chunk is collection of contiguous bytes to be transfered.
+ * A chunk is collection of contiguous bytes to be transferred.
  * The gap(in bytes) between two chunks is called inter-chunk-gap(ICG).
- * ICGs may or maynot change between chunks.
+ * ICGs may or may not change between chunks.
  * A FRAME is the smallest series of contiguous {chunk,icg} pairs,
  *  that when repeated an integral number of times, specifies the transfer.
  * A transfer template is specification of a Frame, the number of times
  * @chan: driver channel device
  * @device: sysfs device
  * @dev_id: parent dma_device dev_id
- * @idr_ref: reference count to gate release of dma_device dev_id
  */
 struct dma_chan_dev {
 	struct dma_chan *chan;
 	struct device device;
 	int dev_id;
-	atomic_t *idr_ref;
 };
 /**
 	int dev_id;
 	struct device *dev;
 	struct module *owner;
+	struct ida chan_ida;
+	struct mutex chan_mutex;	/* to protect chan_ida */
 	u32 src_addr_widths;
 	u32 dst_addr_widths;
  * dmaengine_synchronize() needs to be called before it is safe to free
  * any memory that is accessed by previously submitted descriptors or before
  * freeing any resources accessed from within the completion callback of any
- * perviously submitted descriptors.
+ * previously submitted descriptors.
  *
  * This function can be called from atomic context as well as from within a
  * complete callback of a descriptor submitted on the same channel.
  *
  * Synchronizes to the DMA channel termination to the current context. When this
  * function returns it is guaranteed that all transfers for previously issued
- * descriptors have stopped and and it is safe to free the memory assoicated
+ * descriptors have stopped and it is safe to free the memory associated
  * with them. Furthermore it is guaranteed that all complete callback functions
  * for a previously submitted descriptor have finished running and it is safe to
  * free resources accessed from within the complete callbacks.

include/linux/fs.h+1−1

@@ -983,7 +983,7 @@ struct file_handle { · 982 unmodified lines
983	__u32 handle_bytes;	983	__u32 handle_bytes;
984	int handle_type;	984	int handle_type;
985	/* file identifier */	985	/* file identifier */
986	unsigned char f_handle[0];	986	unsigned char f_handle[];
987	};	987	};
988		988
989	static inline struct file get_file(struct file f)	989	static inline struct file get_file(struct file f)

include/linux/iio/iio.h+1−1

@@ -600,7 +600,7 @@ void iio_device_unregister(struct iio_dev *indio_dev); · 599 unmodified lines
600	* 0 on success, negative error number on failure.	600	* 0 on success, negative error number on failure.
601	*/	601	*/
602	#define devm_iio_device_register(dev, indio_dev) \	602	#define devm_iio_device_register(dev, indio_dev) \
603	__devm_iio_device_register((dev), (indio_dev), THIS_MODULE);	603	__devm_iio_device_register((dev), (indio_dev), THIS_MODULE)
604	int __devm_iio_device_register(struct device dev, struct iio_dev indio_dev,	604	int __devm_iio_device_register(struct device dev, struct iio_dev indio_dev,
605	struct module *this_mod);	605	struct module *this_mod);
606	void devm_iio_device_unregister(struct device dev, struct iio_dev indio_dev);	606	void devm_iio_device_unregister(struct device dev, struct iio_dev indio_dev);

include/linux/kvm_host.h+1−1

@@ -1048,7 +1048,7 @@ search_memslots(struct kvm_memslots *slots, gfn_t gfn) · 1047 unmodified lines
1048	start = slot + 1;	1048	start = slot + 1;
1049	}	1049	}
1050		1050
1051	if (gfn >= memslots[start].base_gfn &&	1051	if (start < slots->used_slots && gfn >= memslots[start].base_gfn &&
1052	gfn < memslots[start].base_gfn + memslots[start].npages) {	1052	gfn < memslots[start].base_gfn + memslots[start].npages) {
1053	atomic_set(&slots->lru_slot, start);	1053	atomic_set(&slots->lru_slot, start);
1054	return &memslots[start];	1054	return &memslots[start];

include/linux/lsm_hook_defs.h+1−1

@@ -55,7 +55,7 @@ LSM_HOOK(void, LSM_RET_VOID, bprm_committing_creds, struct linux_binprm *bprm) · 54 unmodified lines
55	LSM_HOOK(void, LSM_RET_VOID, bprm_committed_creds, struct linux_binprm *bprm)	55	LSM_HOOK(void, LSM_RET_VOID, bprm_committed_creds, struct linux_binprm *bprm)
56	LSM_HOOK(int, 0, fs_context_dup, struct fs_context *fc,	56	LSM_HOOK(int, 0, fs_context_dup, struct fs_context *fc,
57	struct fs_context *src_sc)	57	struct fs_context *src_sc)
58	LSM_HOOK(int, 0, fs_context_parse_param, struct fs_context *fc,	58	LSM_HOOK(int, -ENOPARAM, fs_context_parse_param, struct fs_context *fc,
59	struct fs_parameter *param)	59	struct fs_parameter *param)
60	LSM_HOOK(int, 0, sb_alloc_security, struct super_block *sb)	60	LSM_HOOK(int, 0, sb_alloc_security, struct super_block *sb)
61	LSM_HOOK(void, LSM_RET_VOID, sb_free_security, struct super_block *sb)	61	LSM_HOOK(void, LSM_RET_VOID, sb_free_security, struct super_block *sb)

include/linux/mhi.h+10−6

  * @MHI_CHAIN: Linked transfer
  */
 enum mhi_flags {
-	MHI_EOB,
+	MHI_EOB = BIT(0),
-	MHI_EOT,
+	MHI_EOT = BIT(1),
-	MHI_CHAIN,
+	MHI_CHAIN = BIT(2),
 };
 /**
  * @syserr_worker: System error worker
  * @state_event: State change event
  * @status_cb: CB function to notify power states of the device (required)
- * @link_status: CB function to query link status of the device (required)
  * @wake_get: CB function to assert device wake (optional)
  * @wake_put: CB function to de-assert device wake (optional)
  * @wake_toggle: CB function to assert and de-assert device wake (optional)
  * @runtime_get: CB function to controller runtime resume (required)
- * @runtimet_put: CB function to decrement pm usage (required)
+ * @runtime_put: CB function to decrement pm usage (required)
  * @map_single: CB function to create TRE buffer
  * @unmap_single: CB function to destroy TRE buffer
+ * @read_reg: Read a MHI register via the physical link (required)
+ * @write_reg: Write a MHI register via the physical link (required)
  * @buffer_len: Bounce buffer length
  * @bounce_buf: Use of bounce buffer
  * @fbc_download: MHI host needs to do complete image transfer (optional)
 	void (*status_cb)(struct mhi_controller *mhi_cntrl,
 			  enum mhi_callback cb);
-	int (*link_status)(struct mhi_controller *mhi_cntrl);
 	void (*wake_get)(struct mhi_controller *mhi_cntrl, bool override);
 	void (*wake_put)(struct mhi_controller *mhi_cntrl, bool override);
 	void (*wake_toggle)(struct mhi_controller *mhi_cntrl);
 			  struct mhi_buf_info *buf);
 	void (*unmap_single)(struct mhi_controller *mhi_cntrl,
 			     struct mhi_buf_info *buf);
+	int (*read_reg)(struct mhi_controller *mhi_cntrl, void __iomem *addr,
+			u32 *out);
+	void (*write_reg)(struct mhi_controller *mhi_cntrl, void __iomem *addr,
+			  u32 val);
 	size_t buffer_len;
 	bool bounce_buf;

include/linux/nfs_xdr.h+2−0

 	struct nfstime4			date;
 };
+#define MAX_BIND_CONN_TO_SESSION_RETRIES 3
 struct nfs41_bind_conn_to_session_args {
 	struct nfs_client		*client;
 	struct nfs4_sessionid		sessionid;
 	u32				dir;
 	bool				use_conn_in_rdma_mode;
+	int				retries;
 };
 struct nfs41_bind_conn_to_session_res {

include/linux/platform_data/cros_ec_sensorhub.h+1−0

@@ -185,6 +185,7 @@ int cros_ec_sensorhub_register_push_data(struct cros_ec_sensorhub *sensorhub, · 184 unmodified lines
185	void cros_ec_sensorhub_unregister_push_data(struct cros_ec_sensorhub *sensorhub,	185	void cros_ec_sensorhub_unregister_push_data(struct cros_ec_sensorhub *sensorhub,
186	u8 sensor_num);	186	u8 sensor_num);
187		187
		188	int cros_ec_sensorhub_ring_allocate(struct cros_ec_sensorhub *sensorhub);
188	int cros_ec_sensorhub_ring_add(struct cros_ec_sensorhub *sensorhub);	189	int cros_ec_sensorhub_ring_add(struct cros_ec_sensorhub *sensorhub);
189	void cros_ec_sensorhub_ring_remove(void *arg);	190	void cros_ec_sensorhub_ring_remove(void *arg);
190	int cros_ec_sensorhub_ring_fifo_enable(struct cros_ec_sensorhub *sensorhub,	191	int cros_ec_sensorhub_ring_fifo_enable(struct cros_ec_sensorhub *sensorhub,

include/linux/platform_device.h+1−0

@@ -25,6 +25,7 @@ struct platform_device { · 24 unmodified lines
25	bool id_auto;	25	bool id_auto;
26	struct device dev;	26	struct device dev;
27	u64 platform_dma_mask;	27	u64 platform_dma_mask;
		28	struct device_dma_parameters dma_parms;
28	u32 num_resources;	29	u32 num_resources;
29	struct resource *resource;	30	struct resource *resource;
30		31

include/linux/pnp.h+9−20

 #define global_to_pnp_card(n) list_entry(n, struct pnp_card, global_list)
 #define protocol_to_pnp_card(n) list_entry(n, struct pnp_card, protocol_list)
 #define to_pnp_card(n) container_of(n, struct pnp_card, dev)
-#define pnp_for_each_card(card) \
+#define pnp_for_each_card(card)	\
-	for((card) = global_to_pnp_card(pnp_cards.next); \
+	list_for_each_entry(card, &pnp_cards, global_list)
-	(card) != global_to_pnp_card(&pnp_cards); \
-	(card) = global_to_pnp_card((card)->global_list.next))
 struct pnp_card_link {
 	struct pnp_card *card;
 #define card_to_pnp_dev(n) list_entry(n, struct pnp_dev, card_list)
 #define protocol_to_pnp_dev(n) list_entry(n, struct pnp_dev, protocol_list)
 #define	to_pnp_dev(n) container_of(n, struct pnp_dev, dev)
-#define pnp_for_each_dev(dev) \
+#define pnp_for_each_dev(dev) list_for_each_entry(dev, &pnp_global, global_list)
-	for((dev) = global_to_pnp_dev(pnp_global.next); \
+#define card_for_each_dev(card, dev)	\
-	(dev) != global_to_pnp_dev(&pnp_global); \
+	list_for_each_entry(dev, &(card)->devices, card_list)
-	(dev) = global_to_pnp_dev((dev)->global_list.next))
-#define card_for_each_dev(card,dev) \
-	for((dev) = card_to_pnp_dev((card)->devices.next); \
-	(dev) != card_to_pnp_dev(&(card)->devices); \
-	(dev) = card_to_pnp_dev((dev)->card_list.next))
 #define pnp_dev_name(dev) (dev)->name
 static inline void *pnp_get_drvdata(struct pnp_dev *pdev)
 };
 #define to_pnp_protocol(n) list_entry(n, struct pnp_protocol, protocol_list)
-#define protocol_for_each_card(protocol,card) \
+#define protocol_for_each_card(protocol, card)	\
-	for((card) = protocol_to_pnp_card((protocol)->cards.next); \
+	list_for_each_entry(card, &(protocol)->cards, protocol_list)
-	(card) != protocol_to_pnp_card(&(protocol)->cards); \
+#define protocol_for_each_dev(protocol, dev)	\
-	(card) = protocol_to_pnp_card((card)->protocol_list.next))
+	list_for_each_entry(dev, &(protocol)->devices, protocol_list)
-#define protocol_for_each_dev(protocol,dev) \
-	for((dev) = protocol_to_pnp_dev((protocol)->devices.next); \
-	(dev) != protocol_to_pnp_dev(&(protocol)->devices); \
-	(dev) = protocol_to_pnp_dev((dev)->protocol_list.next))
 extern struct bus_type pnp_bus_type;

include/linux/stmmac.h+2−0

 	struct stmmac_rxq_cfg rx_queues_cfg[MTL_MAX_RX_QUEUES];
 	struct stmmac_txq_cfg tx_queues_cfg[MTL_MAX_TX_QUEUES];
 	void (*fix_mac_speed)(void *priv, unsigned int speed);
+	int (*serdes_powerup)(struct net_device *ndev, void *priv);
+	void (*serdes_powerdown)(struct net_device *ndev, void *priv);
 	int (*init)(struct platform_device *pdev, void *priv);
 	void (*exit)(struct platform_device *pdev, void *priv);
 	struct mac_device_info *(*setup)(void *priv);

include/linux/sunrpc/clnt.h+12−1

 #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
 	struct dentry		*cl_debugfs;	/* debugfs directory */
 #endif
-	struct rpc_xprt_iter	cl_xpi;
+	/* cl_work is only needed after cl_xpi is no longer used,
+	 * and that are of similar size
+	 */
+	union {
+		struct rpc_xprt_iter	cl_xpi;
+		struct work_struct	cl_work;
+	};
 	const struct cred	*cl_cred;
 };
 		(task->tk_msg.rpc_proc->p_decode != NULL);
 }
+static inline void rpc_task_close_connection(struct rpc_task *task)
+{
+	if (task->tk_xprt)
+		xprt_force_disconnect(task->tk_xprt);
+}
 #endif /* _LINUX_SUNRPC_CLNT_H */

include/linux/sunrpc/svc_rdma.h+1−0

@@ -170,6 +170,7 @@ extern bool svc_rdma_post_recvs(struct svcxprt_rdma *rdma); · 169 unmodified lines
170	extern void svc_rdma_recv_ctxt_put(struct svcxprt_rdma *rdma,	170	extern void svc_rdma_recv_ctxt_put(struct svcxprt_rdma *rdma,
171	struct svc_rdma_recv_ctxt *ctxt);	171	struct svc_rdma_recv_ctxt *ctxt);
172	extern void svc_rdma_flush_recv_queues(struct svcxprt_rdma *rdma);	172	extern void svc_rdma_flush_recv_queues(struct svcxprt_rdma *rdma);
		173	extern void svc_rdma_release_rqst(struct svc_rqst *rqstp);
173	extern int svc_rdma_recvfrom(struct svc_rqst *);	174	extern int svc_rdma_recvfrom(struct svc_rqst *);
174		175
175	/* svc_rdma_rw.c */	176	/* svc_rdma_rw.c */

include/linux/tcp.h+0−51

@@ -78,47 +78,6 @@ struct tcp_sack_block { · 77 unmodified lines
78	#define TCP_SACK_SEEN (1 << 0) /1 = peer is SACK capable, /	78	#define TCP_SACK_SEEN (1 << 0) /1 = peer is SACK capable, /
79	#define TCP_DSACK_SEEN (1 << 2) /1 = DSACK was received from peer/	79	#define TCP_DSACK_SEEN (1 << 2) /1 = DSACK was received from peer/
80		80
81	#if IS_ENABLED(CONFIG_MPTCP)
82	struct mptcp_options_received {
83	u64 sndr_key;
84	u64 rcvr_key;
85	u64 data_ack;
86	u64 data_seq;
87	u32 subflow_seq;
88	u16 data_len;
89	u16 mp_capable : 1,
90	mp_join : 1,
91	dss : 1,
92	add_addr : 1,
93	rm_addr : 1,
94	family : 4,
95	echo : 1,
96	backup : 1;
97	u32 token;
98	u32 nonce;
99	u64 thmac;
100	u8 hmac[20];
101	u8 join_id;
102	u8 use_map:1,
103	dsn64:1,
104	data_fin:1,
105	use_ack:1,
106	ack64:1,
107	mpc_map:1,
108	__unused:2;
109	u8 addr_id;
110	u8 rm_id;
111	union {
112	struct in_addr addr;
113	#if IS_ENABLED(CONFIG_MPTCP_IPV6)
114	struct in6_addr addr6;
115	#endif
116	};
117	u64 ahmac;
118	u16 port;
119	};
120	#endif
121
122	struct tcp_options_received {	81	struct tcp_options_received {
123	/* PAWS/RTTM data */	82	/* PAWS/RTTM data */
124	int ts_recent_stamp;/* Time we stored ts_recent (for aging) */	83	int ts_recent_stamp;/* Time we stored ts_recent (for aging) */
@@ -136,9 +95,6 @@ struct tcp_options_received { · 11 unmodified lines
136	u8 num_sacks; /* Number of SACK blocks */	95	u8 num_sacks; /* Number of SACK blocks */
137	u16 user_mss; /* mss requested by user in ioctl */	96	u16 user_mss; /* mss requested by user in ioctl */
138	u16 mss_clamp; /* Maximal mss, negotiated at connection setup */	97	u16 mss_clamp; /* Maximal mss, negotiated at connection setup */
139	#if IS_ENABLED(CONFIG_MPTCP)
140	struct mptcp_options_received mptcp;
141	#endif
142	};	98	};
143		99
144	static inline void tcp_clear_options(struct tcp_options_received *rx_opt)	100	static inline void tcp_clear_options(struct tcp_options_received *rx_opt)
@@ -148,13 +104,6 @@ static inline void tcp_clear_options(struct tcp_options_received *rx_opt) · 3 unmodified lines
148	#if IS_ENABLED(CONFIG_SMC)	104	#if IS_ENABLED(CONFIG_SMC)
149	rx_opt->smc_ok = 0;	105	rx_opt->smc_ok = 0;
150	#endif	106	#endif
151	#if IS_ENABLED(CONFIG_MPTCP)
152	rx_opt->mptcp.mp_capable = 0;
153	rx_opt->mptcp.mp_join = 0;
154	rx_opt->mptcp.add_addr = 0;
155	rx_opt->mptcp.rm_addr = 0;
156	rx_opt->mptcp.dss = 0;
157	#endif
158	}	107	}
159		108
160	/* This is the max number of SACKS that we'll generate and process. It's safe	109	/* This is the max number of SACKS that we'll generate and process. It's safe

include/linux/tracepoint.h+1−21

@@ -156,8 +156,7 @@ static inline struct tracepoint tracepoint_ptr_deref(tracepoint_ptr_t p) · 155 unmodified lines
156	* Note, the proto and args passed in includes "__data" as the first parameter.	156	* Note, the proto and args passed in includes "__data" as the first parameter.
157	* The reason for this is to handle the "void" prototype. If a tracepoint	157	* The reason for this is to handle the "void" prototype. If a tracepoint
158	* has a "void" prototype, then it is invalid to declare a function	158	* has a "void" prototype, then it is invalid to declare a function
159	* as "(void *, void)". The DECLARE_TRACE_NOARGS() will pass in just	159	* as "(void *, void)".
160	* "void data", where as the DECLARE_TRACE() will pass in "void data, proto".
161	*/	160	*/
162	#define __DO_TRACE(tp, proto, args, cond, rcuidle) \	161	#define __DO_TRACE(tp, proto, args, cond, rcuidle) \
163	do { \	162	do { \
@@ -373,25 +372,6 @@ static inline struct tracepoint tracepoint_ptr_deref(tracepoint_ptr_t p) · 209 unmodified lines
373	# define __tracepoint_string	372	# define __tracepoint_string
374	#endif	373	#endif
375		374
376	/*
377	* The need for the DECLARE_TRACE_NOARGS() is to handle the prototype
378	* (void). "void" is a special value in a function prototype and can
379	* not be combined with other arguments. Since the DECLARE_TRACE()
380	* macro adds a data element at the beginning of the prototype,
381	* we need a way to differentiate "(void *data, proto)" from
382	* "(void *data, void)". The second prototype is invalid.
383	*
384	* DECLARE_TRACE_NOARGS() passes "void" as the tracepoint prototype
385	* and "void *__data" as the callback prototype.
386	*
387	* DECLARE_TRACE() passes "proto" as the tracepoint protoype and
388	* "void *__data, proto" as the callback prototype.
389	*/
390	#define DECLARE_TRACE_NOARGS(name) \
391	__DECLARE_TRACE(name, void, , \
392	cpu_online(raw_smp_processor_id()), \
393	void *__data, __data)
394
395	#define DECLARE_TRACE(name, proto, args) \	375	#define DECLARE_TRACE(name, proto, args) \
396	__DECLARE_TRACE(name, PARAMS(proto), PARAMS(args), \	376	__DECLARE_TRACE(name, PARAMS(proto), PARAMS(args), \
397	cpu_online(raw_smp_processor_id()), \	377	cpu_online(raw_smp_processor_id()), \

include/linux/tty.h+1−1

@@ -66,7 +66,7 @@ struct tty_buffer { · 65 unmodified lines
66	int read;	66	int read;
67	int flags;	67	int flags;
68	/* Data points here */	68	/* Data points here */
69	unsigned long data[0];	69	unsigned long data[];
70	};	70	};
71		71
72	/* Values for .flags field of tty_buffer */	72	/* Values for .flags field of tty_buffer */

include/linux/vdpa.h+1−1

@@ -164,7 +164,7 @@ struct vdpa_config_ops { · 163 unmodified lines
164	u64 (get_vq_state)(struct vdpa_device vdev, u16 idx);	164	u64 (get_vq_state)(struct vdpa_device vdev, u16 idx);
165		165
166	/* Device ops */	166	/* Device ops */
167	u16 (get_vq_align)(struct vdpa_device vdev);	167	u32 (get_vq_align)(struct vdpa_device vdev);
168	u64 (get_features)(struct vdpa_device vdev);	168	u64 (get_features)(struct vdpa_device vdev);
169	int (set_features)(struct vdpa_device vdev, u64 features);	169	int (set_features)(struct vdpa_device vdev, u64 features);
170	void (set_config_cb)(struct vdpa_device vdev,	170	void (set_config_cb)(struct vdpa_device vdev,

include/linux/vermagic.h+5−3

 /* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _LINUX_VERMAGIC_H
+#define _LINUX_VERMAGIC_H
 #include <generated/utsrelease.h>
+#include <asm/vermagic.h>
 /* Simply sanity version stamp for modules. */
 #ifdef CONFIG_SMP
 #else
 #define MODULE_VERMAGIC_MODVERSIONS ""
 #endif
-#ifndef MODULE_ARCH_VERMAGIC
-#define MODULE_ARCH_VERMAGIC ""
-#endif
 #ifdef RANDSTRUCT_PLUGIN
 #include <generated/randomize_layout_hash.h>
 #define MODULE_RANDSTRUCT_PLUGIN "RANDSTRUCT_PLUGIN_" RANDSTRUCT_HASHED_SEED
 	MODULE_ARCH_VERMAGIC						\
 	MODULE_RANDSTRUCT_PLUGIN
+#endif /* _LINUX_VERMAGIC_H */

include/linux/virtio.h+0−1

@@ -9,7 +9,6 @@ · 8 unmodified lines
9	#include <linux/device.h>	9	#include <linux/device.h>
10	#include <linux/mod_devicetable.h>	10	#include <linux/mod_devicetable.h>
11	#include <linux/gfp.h>	11	#include <linux/gfp.h>
12	#include <linux/vringh.h>
13		12
14	/**	13	/**
15	* virtqueue - a queue to register buffers for sending or receiving.	14	* virtqueue - a queue to register buffers for sending or receiving.

include/linux/virtio_net.h+24−2

 #define _LINUX_VIRTIO_NET_H
 #include <linux/if_vlan.h>
+#include <uapi/linux/tcp.h>
+#include <uapi/linux/udp.h>
 #include <uapi/linux/virtio_net.h>
 static inline int virtio_net_hdr_set_proto(struct sk_buff *skb,
 					bool little_endian)
 {
 	unsigned int gso_type = 0;
+	unsigned int thlen = 0;
+	unsigned int ip_proto;
 	if (hdr->gso_type != VIRTIO_NET_HDR_GSO_NONE) {
 		switch (hdr->gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
 		case VIRTIO_NET_HDR_GSO_TCPV4:
 			gso_type = SKB_GSO_TCPV4;
+			ip_proto = IPPROTO_TCP;
+			thlen = sizeof(struct tcphdr);
 			break;
 		case VIRTIO_NET_HDR_GSO_TCPV6:
 			gso_type = SKB_GSO_TCPV6;
+			ip_proto = IPPROTO_TCP;
+			thlen = sizeof(struct tcphdr);
 			break;
 		case VIRTIO_NET_HDR_GSO_UDP:
 			gso_type = SKB_GSO_UDP;
+			ip_proto = IPPROTO_UDP;
+			thlen = sizeof(struct udphdr);
 			break;
 		default:
 			return -EINVAL;
 		if (!skb_partial_csum_set(skb, start, off))
 			return -EINVAL;
+		if (skb_transport_offset(skb) + thlen > skb_headlen(skb))
+			return -EINVAL;
 	} else {
 		/* gso packets without NEEDS_CSUM do not set transport_offset.
 		 * probe and drop if does not match one of the above types.
 		 */
 		if (gso_type && skb->network_header) {
+			struct flow_keys_basic keys;
 			if (!skb->protocol)
 				virtio_net_hdr_set_proto(skb, hdr);
 retry:
-			skb_probe_transport_header(skb);
+			if (!skb_flow_dissect_flow_keys_basic(NULL, skb, &keys,
-			if (!skb_transport_header_was_set(skb)) {
+							      NULL, 0, 0, 0,
+							      0)) {
 				/* UFO does not specify ipv4 or 6: try both */
 				if (gso_type & SKB_GSO_UDP &&
 				    skb->protocol == htons(ETH_P_IP)) {
 				}
 				return -EINVAL;
 			}
+			if (keys.control.thoff + thlen > skb_headlen(skb) ||
+			    keys.basic.ip_proto != ip_proto)
+				return -EINVAL;
+			skb_set_transport_header(skb, keys.control.thoff);
 		}
 	}

include/linux/virtio_vsock.h+1−0

@@ -48,6 +48,7 @@ struct virtio_vsock_pkt { · 47 unmodified lines
48	u32 len;	48	u32 len;
49	u32 off;	49	u32 off;
50	bool reply;	50	bool reply;
		51	bool tap_delivered;
51	};	52	};
52		53
53	struct virtio_vsock_pkt_info {	54	struct virtio_vsock_pkt_info {

include/linux/vmalloc.h+1−1

@@ -137,7 +137,7 @@ extern void vunmap(const void *addr); · 136 unmodified lines
137		137
138	extern int remap_vmalloc_range_partial(struct vm_area_struct *vma,	138	extern int remap_vmalloc_range_partial(struct vm_area_struct *vma,
139	unsigned long uaddr, void *kaddr,	139	unsigned long uaddr, void *kaddr,
140	unsigned long size);	140	unsigned long pgoff, unsigned long size);
141		141
142	extern int remap_vmalloc_range(struct vm_area_struct vma, void addr,	142	extern int remap_vmalloc_range(struct vm_area_struct vma, void addr,
143	unsigned long pgoff);	143	unsigned long pgoff);

include/linux/vringh.h+6−0

 #include <linux/virtio_byteorder.h>
 #include <linux/uio.h>
 #include <linux/slab.h>
+#if IS_REACHABLE(CONFIG_VHOST_IOTLB)
 #include <linux/dma-direction.h>
 #include <linux/vhost_iotlb.h>
+#endif
 #include <asm/barrier.h>
 /* virtio_ring with information needed for host access. */
 	return __cpu_to_virtio64(vringh_is_little_endian(vrh), val);
 }
+#if IS_REACHABLE(CONFIG_VHOST_IOTLB)
 void vringh_set_iotlb(struct vringh *vrh, struct vhost_iotlb *iotlb);
 int vringh_init_iotlb(struct vringh *vrh, u64 features,
 int vringh_need_notify_iotlb(struct vringh *vrh);
+#endif /* CONFIG_VHOST_IOTLB */
 #endif /* _LINUX_VRINGH_H */