lael-labs/linux

include/linux/adxl.h+5−0

 #ifndef _LINUX_ADXL_H
 #define _LINUX_ADXL_H
+#ifdef CONFIG_ACPI_ADXL
 const char * const *adxl_get_component_names(void);
 int adxl_decode(u64 addr, u64 component_values[]);
+#else
+static inline const char * const *adxl_get_component_names(void)  { return NULL; }
+static inline int adxl_decode(u64 addr, u64 component_values[])   { return  -EOPNOTSUPP; }
+#endif
 #endif /* _LINUX_ADXL_H */

include/linux/avf/virtchnl.h+9−3

 /* Error Codes */
 enum virtchnl_status_code {
 	VIRTCHNL_STATUS_SUCCESS				= 0,
-	VIRTCHNL_ERR_PARAM				= -5,
+	VIRTCHNL_STATUS_ERR_PARAM			= -5,
+	VIRTCHNL_STATUS_ERR_NO_MEMORY			= -18,
 	VIRTCHNL_STATUS_ERR_OPCODE_MISMATCH		= -38,
 	VIRTCHNL_STATUS_ERR_CQP_COMPL_ERROR		= -39,
 	VIRTCHNL_STATUS_ERR_INVALID_VF_ID		= -40,
-	VIRTCHNL_STATUS_NOT_SUPPORTED			= -64,
+	VIRTCHNL_STATUS_ERR_ADMIN_QUEUE_ERROR		= -53,
+	VIRTCHNL_STATUS_ERR_NOT_SUPPORTED		= -64,
 };
+/* Backward compatibility */
+#define VIRTCHNL_ERR_PARAM VIRTCHNL_STATUS_ERR_PARAM
+#define VIRTCHNL_STATUS_NOT_SUPPORTED VIRTCHNL_STATUS_ERR_NOT_SUPPORTED
 #define VIRTCHNL_LINK_SPEED_100MB_SHIFT		0x1
 #define VIRTCHNL_LINK_SPEED_1000MB_SHIFT	0x2
 #define VIRTCHNL_LINK_SPEED_10GB_SHIFT		0x3
 	case VIRTCHNL_OP_EVENT:
 	case VIRTCHNL_OP_UNKNOWN:
 	default:
-		return VIRTCHNL_ERR_PARAM;
+		return VIRTCHNL_STATUS_ERR_PARAM;
 	}
 	/* few more checks */
 	if (err_msg_format || valid_len != msglen)

include/linux/bio.h+9−17

 	disk_devt((bio)->bi_disk)
 #if defined(CONFIG_MEMCG) && defined(CONFIG_BLK_CGROUP)
-int bio_associate_blkg_from_page(struct bio *bio, struct page *page);
+int bio_associate_blkcg_from_page(struct bio *bio, struct page *page);
 #else
-static inline int bio_associate_blkg_from_page(struct bio *bio,
+static inline int bio_associate_blkcg_from_page(struct bio *bio,
-					       struct page *page) { return 0; }
+						struct page *page) {  return 0; }
 #endif
 #ifdef CONFIG_BLK_CGROUP
+int bio_associate_blkcg(struct bio *bio, struct cgroup_subsys_state *blkcg_css);
 int bio_associate_blkg(struct bio *bio, struct blkcg_gq *blkg);
-int bio_associate_blkg_from_css(struct bio *bio,
-				struct cgroup_subsys_state *css);
-int bio_associate_create_blkg(struct request_queue *q, struct bio *bio);
-int bio_reassociate_blkg(struct request_queue *q, struct bio *bio);
 void bio_disassociate_task(struct bio *bio);
-void bio_clone_blkg_association(struct bio *dst, struct bio *src);
+void bio_clone_blkcg_association(struct bio *dst, struct bio *src);
 #else	/* CONFIG_BLK_CGROUP */
-static inline int bio_associate_blkg_from_css(struct bio *bio,
+static inline int bio_associate_blkcg(struct bio *bio,
-					      struct cgroup_subsys_state *css)
+			struct cgroup_subsys_state *blkcg_css) { return 0; }
-{ return 0; }
-static inline int bio_associate_create_blkg(struct request_queue *q,
-					    struct bio *bio) { return 0; }
-static inline int bio_reassociate_blkg(struct request_queue *q, struct bio *bio)
-{ return 0; }
 static inline void bio_disassociate_task(struct bio *bio) { }
-static inline void bio_clone_blkg_association(struct bio *dst,
+static inline void bio_clone_blkcg_association(struct bio *dst,
-					      struct bio *src) { }
+			struct bio *src) { }
 #endif	/* CONFIG_BLK_CGROUP */
 #ifdef CONFIG_HIGHMEM

include/linux/blk-cgroup.h+45−100

@@ -126,7 +126,7 @@ struct blkcg_gq { · 125 unmodified lines
126	struct request_list rl;	126	struct request_list rl;
127		127
128	/* reference count */	128	/* reference count */
129	struct percpu_ref refcnt;	129	atomic_t refcnt;
130		130
131	/* is this blkg online? protected by both blkcg and q locks */	131	/* is this blkg online? protected by both blkcg and q locks */
132	bool online;	132	bool online;
@@ -184,8 +184,6 @@ extern struct cgroup_subsys_state * const blkcg_root_css; · 51 unmodified lines
184		184
185	struct blkcg_gq blkg_lookup_slowpath(struct blkcg blkcg,	185	struct blkcg_gq blkg_lookup_slowpath(struct blkcg blkcg,
186	struct request_queue *q, bool update_hint);	186	struct request_queue *q, bool update_hint);
187	struct blkcg_gq __blkg_lookup_create(struct blkcg blkcg,
188	struct request_queue *q);
189	struct blkcg_gq blkg_lookup_create(struct blkcg blkcg,	187	struct blkcg_gq blkg_lookup_create(struct blkcg blkcg,
190	struct request_queue *q);	188	struct request_queue *q);
191	int blkcg_init_queue(struct request_queue *q);	189	int blkcg_init_queue(struct request_queue *q);
@@ -232,59 +230,22 @@ int blkg_conf_prep(struct blkcg blkcg, const struct blkcg_policy pol, · 40 unmodified lines
232	char input, struct blkg_conf_ctx ctx);	230	char input, struct blkg_conf_ctx ctx);
233	void blkg_conf_finish(struct blkg_conf_ctx *ctx);	231	void blkg_conf_finish(struct blkg_conf_ctx *ctx);
234		232
235	/**
236	* blkcg_css - find the current css
237	*
238	* Find the css associated with either the kthread or the current task.
239	* This may return a dying css, so it is up to the caller to use tryget logic
240	* to confirm it is alive and well.
241	*/
242	static inline struct cgroup_subsys_state *blkcg_css(void)
243	{
244	struct cgroup_subsys_state *css;
245
246	css = kthread_blkcg();
247	if (css)
248	return css;
249	return task_css(current, io_cgrp_id);
250	}
251		233
252	static inline struct blkcg css_to_blkcg(struct cgroup_subsys_state css)	234	static inline struct blkcg css_to_blkcg(struct cgroup_subsys_state css)
253	{	235	{
254	return css ? container_of(css, struct blkcg, css) : NULL;	236	return css ? container_of(css, struct blkcg, css) : NULL;
255	}	237	}
256		238
257	/**
258	* __bio_blkcg - internal version of bio_blkcg for bfq and cfq
259	*
260	* DO NOT USE.
261	* There is a flaw using this version of the function. In particular, this was
262	* used in a broken paradigm where association was called on the given css. It
263	* is possible though that the returned css from task_css() is in the process
264	* of dying due to migration of the current task. So it is improper to assume
265	* *_get() is going to succeed. Both BFQ and CFQ rely on this logic and will
266	* take additional work to handle more gracefully.
267	*/
268	static inline struct blkcg __bio_blkcg(struct bio bio)
269	{
270	if (bio && bio->bi_blkg)
271	return bio->bi_blkg->blkcg;
272	return css_to_blkcg(blkcg_css());
273	}
274
275	/**
276	* bio_blkcg - grab the blkcg associated with a bio
277	* @bio: target bio
278	*
279	* This returns the blkcg associated with a bio, NULL if not associated.
280	* Callers are expected to either handle NULL or know association has been
281	* done prior to calling this.
282	*/
283	static inline struct blkcg bio_blkcg(struct bio bio)	239	static inline struct blkcg bio_blkcg(struct bio bio)
284	{	240	{
285	if (bio && bio->bi_blkg)	241	struct cgroup_subsys_state *css;
286	return bio->bi_blkg->blkcg;	242
287	return NULL;	243	if (bio && bio->bi_css)
		244	return css_to_blkcg(bio->bi_css);
		245	css = kthread_blkcg();
		246	if (css)
		247	return css_to_blkcg(css);
		248	return css_to_blkcg(task_css(current, io_cgrp_id));
288	}	249	}
289		250
290	static inline bool blk_cgroup_congested(void)	251	static inline bool blk_cgroup_congested(void)
@@ -490,35 +451,26 @@ static inline int blkg_path(struct blkcg_gq blkg, char buf, int buflen) · 199 unmodified lines
490	*/	451	*/
491	static inline void blkg_get(struct blkcg_gq *blkg)	452	static inline void blkg_get(struct blkcg_gq *blkg)
492	{	453	{
493	percpu_ref_get(&blkg->refcnt);	454	WARN_ON_ONCE(atomic_read(&blkg->refcnt) <= 0);
		455	atomic_inc(&blkg->refcnt);
494	}	456	}
495		457
496	/**	458	/**
497	* blkg_tryget - try and get a blkg reference	459	* blkg_try_get - try and get a blkg reference
498	* @blkg: blkg to get	460	* @blkg: blkg to get
499	*	461	*
500	* This is for use when doing an RCU lookup of the blkg. We may be in the midst	462	* This is for use when doing an RCU lookup of the blkg. We may be in the midst
501	* of freeing this blkg, so we can only use it if the refcnt is not zero.	463	* of freeing this blkg, so we can only use it if the refcnt is not zero.
502	*/	464	*/
503	static inline bool blkg_tryget(struct blkcg_gq *blkg)	465	static inline struct blkcg_gq blkg_try_get(struct blkcg_gq blkg)
504	{	466	{
505	return percpu_ref_tryget(&blkg->refcnt);	467	if (atomic_inc_not_zero(&blkg->refcnt))
		468	return blkg;
		469	return NULL;
506	}	470	}
507		471
508	/**
509	* blkg_tryget_closest - try and get a blkg ref on the closet blkg
510	* @blkg: blkg to get
511	*
512	* This walks up the blkg tree to find the closest non-dying blkg and returns
513	* the blkg that it did association with as it may not be the passed in blkg.
514	*/
515	static inline struct blkcg_gq blkg_tryget_closest(struct blkcg_gq blkg)
516	{
517	while (!percpu_ref_tryget(&blkg->refcnt))
518	blkg = blkg->parent;
519		472
520	return blkg;	473	void __blkg_release_rcu(struct rcu_head *rcu);
521	}
522		474
523	/**	475	/**
524	* blkg_put - put a blkg reference	476	* blkg_put - put a blkg reference
@@ -526,7 +478,9 @@ static inline struct blkcg_gq blkg_tryget_closest(struct blkcg_gq blkg) · 1 unmodified line
526	*/	478	*/
527	static inline void blkg_put(struct blkcg_gq *blkg)	479	static inline void blkg_put(struct blkcg_gq *blkg)
528	{	480	{
529	percpu_ref_put(&blkg->refcnt);	481	WARN_ON_ONCE(atomic_read(&blkg->refcnt) <= 0);
		482	if (atomic_dec_and_test(&blkg->refcnt))
		483	call_rcu(&blkg->rcu_head, __blkg_release_rcu);
530	}	484	}
531		485
532	/**	486	/**
@@ -579,36 +533,25 @@ static inline struct request_list blk_get_rl(struct request_queue q, · 46 unmodified lines
579		533
580	rcu_read_lock();	534	rcu_read_lock();
581		535
582	if (bio && bio->bi_blkg) {	536	blkcg = bio_blkcg(bio);
583	blkcg = bio->bi_blkg->blkcg;
584	if (blkcg == &blkcg_root)
585	goto rl_use_root;
586
587	blkg_get(bio->bi_blkg);
588	rcu_read_unlock();
589	return &bio->bi_blkg->rl;
590	}
591		537
592	blkcg = css_to_blkcg(blkcg_css());	538	/* bypass blkg lookup and use @q->root_rl directly for root */
593	if (blkcg == &blkcg_root)	539	if (blkcg == &blkcg_root)
594	goto rl_use_root;	540	goto root_rl;
595		541
		542	/*
		543	* Try to use blkg->rl. blkg lookup may fail under memory pressure
		544	* or if either the blkcg or queue is going away. Fall back to
		545	* root_rl in such cases.
		546	*/
596	blkg = blkg_lookup(blkcg, q);	547	blkg = blkg_lookup(blkcg, q);
597	if (unlikely(!blkg))	548	if (unlikely(!blkg))
598	blkg = __blkg_lookup_create(blkcg, q);	549	goto root_rl;
599
600	if (blkg->blkcg == &blkcg_root \|\| !blkg_tryget(blkg))
601	goto rl_use_root;
602		550
		551	blkg_get(blkg);
603	rcu_read_unlock();	552	rcu_read_unlock();
604	return &blkg->rl;	553	return &blkg->rl;
605		554	root_rl:
606	/*
607	* Each blkg has its own request_list, however, the root blkcg
608	* uses the request_queue's root_rl. This is to avoid most
609	* overhead for the root blkcg.
610	*/
611	rl_use_root:
612	rcu_read_unlock();	555	rcu_read_unlock();
613	return &q->root_rl;	556	return &q->root_rl;
614	}	557	}
@@ -854,26 +797,32 @@ static inline bool blk_throtl_bio(struct request_queue q, struct blkcg_gq blkg · 239 unmodified lines
854	struct bio *bio) { return false; }	797	struct bio *bio) { return false; }
855	#endif	798	#endif
856		799
857
858	static inline void blkcg_bio_issue_init(struct bio *bio)
859	{
860	bio_issue_init(&bio->bi_issue, bio_sectors(bio));
861	}
862
863	static inline bool blkcg_bio_issue_check(struct request_queue *q,	800	static inline bool blkcg_bio_issue_check(struct request_queue *q,
864	struct bio *bio)	801	struct bio *bio)
865	{	802	{
		803	struct blkcg *blkcg;
866	struct blkcg_gq *blkg;	804	struct blkcg_gq *blkg;
867	bool throtl = false;	805	bool throtl = false;
868		806
869	rcu_read_lock();	807	rcu_read_lock();
		808	blkcg = bio_blkcg(bio);
		809
		810	/* associate blkcg if bio hasn't attached one */
		811	bio_associate_blkcg(bio, &blkcg->css);
870		812
871	bio_associate_create_blkg(q, bio);	813	blkg = blkg_lookup(blkcg, q);
872	blkg = bio->bi_blkg;	814	if (unlikely(!blkg)) {
		815	spin_lock_irq(q->queue_lock);
		816	blkg = blkg_lookup_create(blkcg, q);
		817	if (IS_ERR(blkg))
		818	blkg = NULL;
		819	spin_unlock_irq(q->queue_lock);
		820	}
873		821
874	throtl = blk_throtl_bio(q, blkg, bio);	822	throtl = blk_throtl_bio(q, blkg, bio);
875		823
876	if (!throtl) {	824	if (!throtl) {
		825	blkg = blkg ?: q->root_blkg;
877	/*	826	/*
878	* If the bio is flagged with BIO_QUEUE_ENTERED it means this	827	* If the bio is flagged with BIO_QUEUE_ENTERED it means this
879	* is a split bio and we would have already accounted for the	828	* is a split bio and we would have already accounted for the
@@ -885,8 +834,6 @@ static inline bool blkcg_bio_issue_check(struct request_queue *q, · 5 unmodified lines
885	blkg_rwstat_add(&blkg->stat_ios, bio->bi_opf, 1);	834	blkg_rwstat_add(&blkg->stat_ios, bio->bi_opf, 1);
886	}	835	}
887		836
888	blkcg_bio_issue_init(bio);
889
890	rcu_read_unlock();	837	rcu_read_unlock();
891	return !throtl;	838	return !throtl;
892	}	839	}
@@ -983,7 +930,6 @@ static inline int blkcg_activate_policy(struct request_queue *q, · 90 unmodified lines
983	static inline void blkcg_deactivate_policy(struct request_queue *q,	930	static inline void blkcg_deactivate_policy(struct request_queue *q,
984	const struct blkcg_policy *pol) { }	931	const struct blkcg_policy *pol) { }
985		932
986	static inline struct blkcg __bio_blkcg(struct bio bio) { return NULL; }
987	static inline struct blkcg bio_blkcg(struct bio bio) { return NULL; }	933	static inline struct blkcg bio_blkcg(struct bio bio) { return NULL; }
988		934
989	static inline struct blkg_policy_data blkg_to_pd(struct blkcg_gq blkg,	935	static inline struct blkg_policy_data blkg_to_pd(struct blkcg_gq blkg,
@@ -999,7 +945,6 @@ static inline void blk_put_rl(struct request_list *rl) { } · 9 unmodified lines
999	static inline void blk_rq_set_rl(struct request rq, struct request_list rl) { }	945	static inline void blk_rq_set_rl(struct request rq, struct request_list rl) { }
1000	static inline struct request_list blk_rq_rl(struct request rq) { return &rq->q->root_rl; }	946	static inline struct request_list blk_rq_rl(struct request rq) { return &rq->q->root_rl; }
1001		947
1002	static inline void blkcg_bio_issue_init(struct bio *bio) { }
1003	static inline bool blkcg_bio_issue_check(struct request_queue *q,	948	static inline bool blkcg_bio_issue_check(struct request_queue *q,
1004	struct bio *bio) { return true; }	949	struct bio *bio) { return true; }
1005		950

include/linux/blk_types.h+1−0

@@ -178,6 +178,7 @@ struct bio { · 177 unmodified lines
178	* release. Read comment on top of bio_associate_current().	178	* release. Read comment on top of bio_associate_current().
179	*/	179	*/
180	struct io_context *bi_ioc;	180	struct io_context *bi_ioc;
		181	struct cgroup_subsys_state *bi_css;
181	struct blkcg_gq *bi_blkg;	182	struct blkcg_gq *bi_blkg;
182	struct bio_issue bi_issue;	183	struct bio_issue bi_issue;
183	#endif	184	#endif

include/linux/bpf_verifier.h+3−0

 		 *   PTR_TO_MAP_VALUE_OR_NULL
 		 */
 		struct bpf_map *map_ptr;
+		/* Max size from any of the above. */
+		unsigned long raw;
 	};
 	/* Fixed part of pointer offset, pointer types only */
 	s32 off;

include/linux/can/dev.h+1−0

@@ -169,6 +169,7 @@ void can_change_state(struct net_device dev, struct can_frame cf, · 168 unmodified lines
169		169
170	void can_put_echo_skb(struct sk_buff skb, struct net_device dev,	170	void can_put_echo_skb(struct sk_buff skb, struct net_device dev,
171	unsigned int idx);	171	unsigned int idx);
		172	struct sk_buff __can_get_echo_skb(struct net_device dev, unsigned int idx, u8 *len_ptr);
172	unsigned int can_get_echo_skb(struct net_device *dev, unsigned int idx);	173	unsigned int can_get_echo_skb(struct net_device *dev, unsigned int idx);
173	void can_free_echo_skb(struct net_device *dev, unsigned int idx);	174	void can_free_echo_skb(struct net_device *dev, unsigned int idx);
174		175

include/linux/can/rx-offload.h+6−1

 int can_rx_offload_add_fifo(struct net_device *dev, struct can_rx_offload *offload, unsigned int weight);
 int can_rx_offload_irq_offload_timestamp(struct can_rx_offload *offload, u64 reg);
 int can_rx_offload_irq_offload_fifo(struct can_rx_offload *offload);
-int can_rx_offload_irq_queue_err_skb(struct can_rx_offload *offload, struct sk_buff *skb);
+int can_rx_offload_queue_sorted(struct can_rx_offload *offload,
+				struct sk_buff *skb, u32 timestamp);
+unsigned int can_rx_offload_get_echo_skb(struct can_rx_offload *offload,
+					 unsigned int idx, u32 timestamp);
+int can_rx_offload_queue_tail(struct can_rx_offload *offload,
+			      struct sk_buff *skb);
 void can_rx_offload_reset(struct can_rx_offload *offload);
 void can_rx_offload_del(struct can_rx_offload *offload);
 void can_rx_offload_enable(struct can_rx_offload *offload);

include/linux/ceph/ceph_features.h+1−7

 	 CEPH_FEATURE_NEW_OSDOPREPLY_ENCODING |	\
 	 CEPH_FEATURE_CEPHX_V2)
-#define CEPH_FEATURES_REQUIRED_DEFAULT   \
+#define CEPH_FEATURES_REQUIRED_DEFAULT	0
-	(CEPH_FEATURE_NOSRCADDR |	 \
-	 CEPH_FEATURE_SUBSCRIBE2 |	 \
-	 CEPH_FEATURE_RECONNECT_SEQ |	 \
-	 CEPH_FEATURE_PGID64 |		 \
-	 CEPH_FEATURE_PGPOOL3 |		 \
-	 CEPH_FEATURE_OSDENC)
 #endif

include/linux/cgroup.h+0−2

@@ -93,8 +93,6 @@ extern struct css_set init_css_set; · 92 unmodified lines
93		93
94	bool css_has_online_children(struct cgroup_subsys_state *css);	94	bool css_has_online_children(struct cgroup_subsys_state *css);
95	struct cgroup_subsys_state css_from_id(int id, struct cgroup_subsys ss);	95	struct cgroup_subsys_state css_from_id(int id, struct cgroup_subsys ss);
96	struct cgroup_subsys_state cgroup_e_css(struct cgroup cgroup,
97	struct cgroup_subsys *ss);
98	struct cgroup_subsys_state cgroup_get_e_css(struct cgroup cgroup,	96	struct cgroup_subsys_state cgroup_get_e_css(struct cgroup cgroup,
99	struct cgroup_subsys *ss);	97	struct cgroup_subsys *ss);
100	struct cgroup_subsys_state css_tryget_online_from_dir(struct dentry dentry,	98	struct cgroup_subsys_state css_tryget_online_from_dir(struct dentry dentry,

include/linux/compat.h+2−2

@@ -1032,9 +1032,9 @@ int kcompat_sys_fstatfs64(unsigned int fd, compat_size_t sz, · 1031 unmodified lines
1032	#else /* !CONFIG_COMPAT */	1032	#else /* !CONFIG_COMPAT */
1033		1033
1034	#define is_compat_task() (0)	1034	#define is_compat_task() (0)
1035	#ifndef in_compat_syscall	1035	/* Ensure no one redefines in_compat_syscall() under !CONFIG_COMPAT */
		1036	#define in_compat_syscall in_compat_syscall
1036	static inline bool in_compat_syscall(void) { return false; }	1037	static inline bool in_compat_syscall(void) { return false; }
1037	#endif
1038		1038
1039	#endif /* CONFIG_COMPAT */	1039	#endif /* CONFIG_COMPAT */
1040		1040

include/linux/compiler-clang.h+0−5

 #define __SANITIZE_ADDRESS__
 #endif
-#define __no_sanitize_address __attribute__((no_sanitize("address")))
 /*
  * Not all versions of clang implement the the type-generic versions
  * of the builtin overflow checkers. Fortunately, clang implements
  * compilers, like ICC.
  */
 #define barrier() __asm__ __volatile__("" : : : "memory")
-#define __must_be_array(a) BUILD_BUG_ON_ZERO(__same_type((a), &(a)[0]))
-#define __assume_aligned(a, ...)	\
-	__attribute__((__assume_aligned__(a, ## __VA_ARGS__)))

include/linux/compiler-gcc.h+4−77

@@ -68,31 +68,20 @@ · 67 unmodified lines
68	*/	68	*/
69	#define uninitialized_var(x) x = x	69	#define uninitialized_var(x) x = x
70		70
71	#ifdef __CHECKER__
72	#define __must_be_array(a) 0
73	#else
74	/* &a[0] degrades to a pointer: a different type from an array */
75	#define __must_be_array(a) BUILD_BUG_ON_ZERO(__same_type((a), &(a)[0]))
76	#endif
77
78	#ifdef RETPOLINE	71	#ifdef RETPOLINE
79	#define __noretpoline __attribute__((indirect_branch("keep")))	72	#define __noretpoline __attribute__((__indirect_branch__("keep")))
80	#endif	73	#endif
81		74
82	#define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__)	75	#define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__)
83		76
84	#define __optimize(level) __attribute__((__optimize__(level)))
85
86	#define __compiletime_object_size(obj) __builtin_object_size(obj, 0)	77	#define __compiletime_object_size(obj) __builtin_object_size(obj, 0)
87		78
88	#ifndef __CHECKER__	79	#define __compiletime_warning(message) __attribute__((__warning__(message)))
89	#define __compiletime_warning(message) __attribute__((warning(message)))	80	#define __compiletime_error(message) __attribute__((__error__(message)))
90	#define __compiletime_error(message) __attribute__((error(message)))
91		81
92	#ifdef LATENT_ENTROPY_PLUGIN	82	#if defined(LATENT_ENTROPY_PLUGIN) && !defined(__CHECKER__)
93	#define __latent_entropy __attribute__((latent_entropy))	83	#define __latent_entropy __attribute__((latent_entropy))
94	#endif	84	#endif
95	#endif /* __CHECKER__ */
96		85
97	/*	86	/*
98	* calling noreturn functions, __builtin_unreachable() and __builtin_trap()	87	* calling noreturn functions, __builtin_unreachable() and __builtin_trap()
@@ -107,10 +96,6 @@ · 8 unmodified lines
107	* Mark a position in code as unreachable. This can be used to	96	* Mark a position in code as unreachable. This can be used to
108	* suppress control flow warnings after asm blocks that transfer	97	* suppress control flow warnings after asm blocks that transfer
109	* control elsewhere.	98	* control elsewhere.
110	*
111	* Early snapshots of gcc 4.5 don't support this and we can't detect
112	* this in the preprocessor, but we can live with this because they're
113	* unreleased. Really, we need to have autoconf for the kernel.
114	*/	99	*/
115	#define unreachable() \	100	#define unreachable() \
116	do { \	101	do { \
@@ -119,9 +104,6 @@ · 2 unmodified lines
119	__builtin_unreachable(); \	104	__builtin_unreachable(); \
120	} while (0)	105	} while (0)
121		106
122	/* Mark a function definition as prohibited from being cloned. */
123	#define __noclone __attribute__((__noclone__, __optimize__("no-tracer")))
124
125	#if defined(RANDSTRUCT_PLUGIN) && !defined(__CHECKER__)	107	#if defined(RANDSTRUCT_PLUGIN) && !defined(__CHECKER__)
126	#define __randomize_layout __attribute__((randomize_layout))	108	#define __randomize_layout __attribute__((randomize_layout))
127	#define __no_randomize_layout __attribute__((no_randomize_layout))	109	#define __no_randomize_layout __attribute__((no_randomize_layout))
@@ -130,32 +112,6 @@ · 2 unmodified lines
130	#define randomized_struct_fields_end } __randomize_layout;	112	#define randomized_struct_fields_end } __randomize_layout;
131	#endif	113	#endif
132		114
133	/*
134	* When used with Link Time Optimization, gcc can optimize away C functions or
135	* variables which are referenced only from assembly code. __visible tells the
136	* optimizer that something else uses this function or variable, thus preventing
137	* this.
138	*/
139	#define __visible __attribute__((externally_visible))
140
141	/* gcc version specific checks */
142
143	#if GCC_VERSION >= 40900 && !defined(__CHECKER__)
144	/*
145	* __assume_aligned(n, k): Tell the optimizer that the returned
146	* pointer can be assumed to be k modulo n. The second argument is
147	* optional (default 0), so we use a variadic macro to make the
148	* shorthand.
149	*
150	* Beware: Do not apply this to functions which may return
151	* ERR_PTRs. Also, it is probably unwise to apply it to functions
152	* returning extra information in the low bits (but in that case the
153	* compiler should see some alignment anyway, when the return value is
154	* massaged by 'flags = ptr & 3; ptr &= ~3;').
155	*/
156	#define __assume_aligned(a, ...) __attribute__((__assume_aligned__(a, ## __VA_ARGS__)))
157	#endif
158
159	/*	115	/*
160	* GCC 'asm goto' miscompiles certain code sequences:	116	* GCC 'asm goto' miscompiles certain code sequences:
161	*	117	*
@@ -187,39 +143,10 @@ · 25 unmodified lines
187	#define KASAN_ABI_VERSION 3	143	#define KASAN_ABI_VERSION 3
188	#endif	144	#endif
189		145
190	#if GCC_VERSION >= 40902
191	/*
192	* Tell the compiler that address safety instrumentation (KASAN)
193	* should not be applied to that function.
194	* Conflicts with inlining: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67368
195	*/
196	#define __no_sanitize_address __attribute__((no_sanitize_address))
197	#ifdef CONFIG_KASAN
198	#define __no_sanitize_address_or_inline \
199	__no_sanitize_address __maybe_unused notrace
200	#else
201	#define __no_sanitize_address_or_inline inline
202	#endif
203	#endif
204
205	#if GCC_VERSION >= 50100	146	#if GCC_VERSION >= 50100
206	/*
207	* Mark structures as requiring designated initializers.
208	* https://gcc.gnu.org/onlinedocs/gcc/Designated-Inits.html
209	*/
210	#define __designated_init __attribute__((designated_init))
211	#define COMPILER_HAS_GENERIC_BUILTIN_OVERFLOW 1	147	#define COMPILER_HAS_GENERIC_BUILTIN_OVERFLOW 1
212	#endif	148	#endif
213		149
214	#if !defined(__noclone)
215	#define __noclone /* not needed */
216	#endif
217
218	#if !defined(__no_sanitize_address)
219	#define __no_sanitize_address
220	#define __no_sanitize_address_or_inline inline
221	#endif
222
223	/*	150	/*
224	* Turn individual warnings and errors on and off locally, depending	151	* Turn individual warnings and errors on and off locally, depending
225	* on version.	152	* on version.

include/linux/compiler-intel.h+0−9

@@ -29,17 +29,8 @@ · 28 unmodified lines
29	*/	29	*/
30	#define OPTIMIZER_HIDE_VAR(var) barrier()	30	#define OPTIMIZER_HIDE_VAR(var) barrier()
31		31
32	/* Intel ECC compiler doesn't support __builtin_types_compatible_p() */
33	#define __must_be_array(a) 0
34
35	#endif	32	#endif
36		33
37	/* icc has this, but it's called _bswap16 */	34	/* icc has this, but it's called _bswap16 */
38	#define __HAVE_BUILTIN_BSWAP16__	35	#define __HAVE_BUILTIN_BSWAP16__
39	#define __builtin_bswap16 _bswap16	36	#define __builtin_bswap16 _bswap16
40
41	/* The following are for compatibility with GCC, from compiler-gcc.h,
42	* and may be redefined here because they should not be shared with other
43	* compilers, like clang.
44	*/
45	#define __visible __attribute__((externally_visible))

include/linux/compiler.h+14−12

 #define __branch_check__(x, expect, is_constant) ({			\
 			long ______r;					\
 			static struct ftrace_likely_data		\
-				__attribute__((__aligned__(4)))		\
+				__aligned(4)				\
-				__attribute__((section("_ftrace_annotated_branch"))) \
+				__section("_ftrace_annotated_branch")	\
 				______f = {				\
 				.data.func = __func__,			\
 				.data.file = __FILE__,			\
 	({								\
 		int ______r;						\
 		static struct ftrace_branch_data			\
-			__attribute__((__aligned__(4)))			\
+			__aligned(4)					\
-			__attribute__((section("_ftrace_branch")))	\
+			__section("_ftrace_branch")			\
 			______f = {					\
 				.func = __func__,			\
 				.file = __FILE__,			\
 # define ASM_UNREACHABLE
 #endif
 #ifndef unreachable
-# define unreachable() do { annotate_reachable(); do { } while (1); } while (0)
+# define unreachable() do {		\
+	annotate_unreachable();		\
+	__builtin_unreachable();	\
+} while (0)
 #endif
 /*
 	extern typeof(sym) sym;					\
 	static const unsigned long __kentry_##sym		\
 	__used							\
-	__attribute__((section("___kentry" "+" #sym ), used))	\
+	__section("___kentry" "+" #sym )			\
 	= (unsigned long)&sym;
 #endif
  * 	https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67368
  * '__maybe_unused' allows us to avoid defined-but-not-used warnings.
  */
-# define __no_kasan_or_inline __no_sanitize_address __maybe_unused
+# define __no_kasan_or_inline __no_sanitize_address notrace __maybe_unused
 #else
 # define __no_kasan_or_inline __always_inline
 #endif
  * visible to the compiler.
  */
 #define __ADDRESSABLE(sym) \
-	static void * __attribute__((section(".discard.addressable"), used)) \
+	static void * __section(".discard.addressable") __used \
 		__PASTE(__addressable_##sym, __LINE__) = (void *)&sym;
 /**
 #endif /* __KERNEL__ */
 #endif /* __ASSEMBLY__ */
-#ifndef __optimize
-# define __optimize(level)
-#endif
 /* Compile time object size, -1 for unknown */
 #ifndef __compiletime_object_size
 # define __compiletime_object_size(obj) -1
 	compiletime_assert(__native_word(t),				\
 		"Need native word sized stores/loads for atomicity.")
+/* &a[0] degrades to a pointer: a different type from an array */
+#define __must_be_array(a)	BUILD_BUG_ON_ZERO(__same_type((a), &(a)[0]))
 #endif /* __LINUX_COMPILER_H */

include/linux/compiler_attributes.h+262−0

@@ -0,0 +1,262 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef __LINUX_COMPILER_ATTRIBUTES_H
	3	#define __LINUX_COMPILER_ATTRIBUTES_H
	4
	5	/*
	6	* The attributes in this file are unconditionally defined and they directly
	7	* map to compiler attribute(s), unless one of the compilers does not support
	8	* the attribute. In that case, __has_attribute is used to check for support
	9	* and the reason is stated in its comment ("Optional: ...").
	10	*
	11	* Any other "attributes" (i.e. those that depend on a configuration option,
	12	* on a compiler, on an architecture, on plugins, on other attributes...)
	13	* should be defined elsewhere (e.g. compiler_types.h or compiler-*.h).
	14	* The intention is to keep this file as simple as possible, as well as
	15	* compiler- and version-agnostic (e.g. avoiding GCC_VERSION checks).
	16	*
	17	* This file is meant to be sorted (by actual attribute name,
	18	* not by #define identifier). Use the __attribute__((__name__)) syntax
	19	* (i.e. with underscores) to avoid future collisions with other macros.
	20	* Provide links to the documentation of each supported compiler, if it exists.
	21	*/
	22
	23	/*
	24	* __has_attribute is supported on gcc >= 5, clang >= 2.9 and icc >= 17.
	25	* In the meantime, to support 4.6 <= gcc < 5, we implement __has_attribute
	26	* by hand.
	27	*
	28	* sparse does not support __has_attribute (yet) and defines __GNUC_MINOR__
	29	* depending on the compiler used to build it; however, these attributes have
	30	* no semantic effects for sparse, so it does not matter. Also note that,
	31	* in order to avoid sparse's warnings, even the unsupported ones must be
	32	* defined to 0.
	33	*/
	34	#ifndef __has_attribute
	35	# define __has_attribute(x) __GCC4_has_attribute_##x
	36	# define __GCC4_has_attribute___assume_aligned__ (__GNUC_MINOR__ >= 9)
	37	# define __GCC4_has_attribute___designated_init__ 0
	38	# define __GCC4_has_attribute___externally_visible__ 1
	39	# define __GCC4_has_attribute___noclone__ 1
	40	# define __GCC4_has_attribute___optimize__ 1
	41	# define __GCC4_has_attribute___nonstring__ 0
	42	# define __GCC4_has_attribute___no_sanitize_address__ (__GNUC_MINOR__ >= 8)
	43	#endif
	44
	45	/*
	46	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-alias-function-attribute
	47	*/
	48	#define __alias(symbol) __attribute__((__alias__(#symbol)))
	49
	50	/*
	51	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-aligned-function-attribute
	52	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Type-Attributes.html#index-aligned-type-attribute
	53	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Variable-Attributes.html#index-aligned-variable-attribute
	54	*/
	55	#define __aligned(x) __attribute__((__aligned__(x)))
	56	#define __aligned_largest __attribute__((__aligned__))
	57
	58	/*
	59	* Note: users of __always_inline currently do not write "inline" themselves,
	60	* which seems to be required by gcc to apply the attribute according
	61	* to its docs (and also "warning: always_inline function might not be
	62	* inlinable [-Wattributes]" is emitted).
	63	*
	64	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-always_005finline-function-attribute
	65	* clang: mentioned
	66	*/
	67	#define __always_inline inline __attribute__((__always_inline__))
	68
	69	/*
	70	* The second argument is optional (default 0), so we use a variadic macro
	71	* to make the shorthand.
	72	*
	73	* Beware: Do not apply this to functions which may return
	74	* ERR_PTRs. Also, it is probably unwise to apply it to functions
	75	* returning extra information in the low bits (but in that case the
	76	* compiler should see some alignment anyway, when the return value is
	77	* massaged by 'flags = ptr & 3; ptr &= ~3;').
	78	*
	79	* Optional: only supported since gcc >= 4.9
	80	* Optional: not supported by icc
	81	*
	82	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-assume_005faligned-function-attribute
	83	* clang: https://clang.llvm.org/docs/AttributeReference.html#assume-aligned
	84	*/
	85	#if __has_attribute(__assume_aligned__)
	86	# define __assume_aligned(a, ...) __attribute__((__assume_aligned__(a, ## __VA_ARGS__)))
	87	#else
	88	# define __assume_aligned(a, ...)
	89	#endif
	90
	91	/*
	92	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-cold-function-attribute
	93	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Label-Attributes.html#index-cold-label-attribute
	94	*/
	95	#define __cold __attribute__((__cold__))
	96
	97	/*
	98	* Note the long name.
	99	*
	100	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-const-function-attribute
	101	*/
	102	#define __attribute_const__ __attribute__((__const__))
	103
	104	/*
	105	* Don't. Just don't. See commit 771c035372a0 ("deprecate the '__deprecated'
	106	* attribute warnings entirely and for good") for more information.
	107	*
	108	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-deprecated-function-attribute
	109	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Type-Attributes.html#index-deprecated-type-attribute
	110	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Variable-Attributes.html#index-deprecated-variable-attribute
	111	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Enumerator-Attributes.html#index-deprecated-enumerator-attribute
	112	* clang: https://clang.llvm.org/docs/AttributeReference.html#deprecated
	113	*/
	114	#define __deprecated
	115
	116	/*
	117	* Optional: only supported since gcc >= 5.1
	118	* Optional: not supported by clang
	119	* Optional: not supported by icc
	120	*
	121	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Type-Attributes.html#index-designated_005finit-type-attribute
	122	*/
	123	#if __has_attribute(__designated_init__)
	124	# define __designated_init __attribute__((__designated_init__))
	125	#else
	126	# define __designated_init
	127	#endif
	128
	129	/*
	130	* Optional: not supported by clang
	131	*
	132	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-externally_005fvisible-function-attribute
	133	*/
	134	#if __has_attribute(__externally_visible__)
	135	# define __visible __attribute__((__externally_visible__))
	136	#else
	137	# define __visible
	138	#endif
	139
	140	/*
	141	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-format-function-attribute
	142	* clang: https://clang.llvm.org/docs/AttributeReference.html#format
	143	*/
	144	#define __printf(a, b) __attribute__((__format__(printf, a, b)))
	145	#define __scanf(a, b) __attribute__((__format__(scanf, a, b)))
	146
	147	/*
	148	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-gnu_005finline-function-attribute
	149	* clang: https://clang.llvm.org/docs/AttributeReference.html#gnu-inline
	150	*/
	151	#define __gnu_inline __attribute__((__gnu_inline__))
	152
	153	/*
	154	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-malloc-function-attribute
	155	*/
	156	#define __malloc __attribute__((__malloc__))
	157
	158	/*
	159	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Type-Attributes.html#index-mode-type-attribute
	160	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Variable-Attributes.html#index-mode-variable-attribute
	161	*/
	162	#define __mode(x) __attribute__((__mode__(x)))
	163
	164	/*
	165	* Optional: not supported by clang
	166	* Note: icc does not recognize gcc's no-tracer
	167	*
	168	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-noclone-function-attribute
	169	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-optimize-function-attribute
	170	*/
	171	#if __has_attribute(__noclone__)
	172	# if __has_attribute(__optimize__)
	173	# define __noclone __attribute__((__noclone__, __optimize__("no-tracer")))
	174	# else
	175	# define __noclone __attribute__((__noclone__))
	176	# endif
	177	#else
	178	# define __noclone
	179	#endif
	180
	181	/*
	182	* Note the missing underscores.
	183	*
	184	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-noinline-function-attribute
	185	* clang: mentioned
	186	*/
	187	#define noinline __attribute__((__noinline__))
	188
	189	/*
	190	* Optional: only supported since gcc >= 8
	191	* Optional: not supported by clang
	192	* Optional: not supported by icc
	193	*
	194	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Variable-Attributes.html#index-nonstring-variable-attribute
	195	*/
	196	#if __has_attribute(__nonstring__)
	197	# define __nonstring __attribute__((__nonstring__))
	198	#else
	199	# define __nonstring
	200	#endif
	201
	202	/*
	203	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-noreturn-function-attribute
	204	* clang: https://clang.llvm.org/docs/AttributeReference.html#noreturn
	205	* clang: https://clang.llvm.org/docs/AttributeReference.html#id1
	206	*/
	207	#define __noreturn __attribute__((__noreturn__))
	208
	209	/*
	210	* Optional: only supported since gcc >= 4.8
	211	* Optional: not supported by icc
	212	*
	213	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-no_005fsanitize_005faddress-function-attribute
	214	* clang: https://clang.llvm.org/docs/AttributeReference.html#no-sanitize-address-no-address-safety-analysis
	215	*/
	216	#if __has_attribute(__no_sanitize_address__)
	217	# define __no_sanitize_address __attribute__((__no_sanitize_address__))
	218	#else
	219	# define __no_sanitize_address
	220	#endif
	221
	222	/*
	223	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Type-Attributes.html#index-packed-type-attribute
	224	* clang: https://gcc.gnu.org/onlinedocs/gcc/Common-Variable-Attributes.html#index-packed-variable-attribute
	225	*/
	226	#define __packed __attribute__((__packed__))
	227
	228	/*
	229	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-pure-function-attribute
	230	*/
	231	#define __pure __attribute__((__pure__))
	232
	233	/*
	234	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-section-function-attribute
	235	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Variable-Attributes.html#index-section-variable-attribute
	236	* clang: https://clang.llvm.org/docs/AttributeReference.html#section-declspec-allocate
	237	*/
	238	#define __section(S) __attribute__((__section__(#S)))
	239
	240	/*
	241	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-unused-function-attribute
	242	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Type-Attributes.html#index-unused-type-attribute
	243	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Variable-Attributes.html#index-unused-variable-attribute
	244	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Label-Attributes.html#index-unused-label-attribute
	245	* clang: https://clang.llvm.org/docs/AttributeReference.html#maybe-unused-unused
	246	*/
	247	#define __always_unused __attribute__((__unused__))
	248	#define __maybe_unused __attribute__((__unused__))
	249
	250	/*
	251	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-used-function-attribute
	252	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Variable-Attributes.html#index-used-variable-attribute
	253	*/
	254	#define __used __attribute__((__used__))
	255
	256	/*
	257	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-weak-function-attribute
	258	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Variable-Attributes.html#index-weak-variable-attribute
	259	*/
	260	#define __weak __attribute__((__weak__))
	261
	262	#endif /* __LINUX_COMPILER_ATTRIBUTES_H */

include/linux/compiler_types.h+17−83

+/* SPDX-License-Identifier: GPL-2.0 */
 #ifndef __LINUX_COMPILER_TYPES_H
 #define __LINUX_COMPILER_TYPES_H
 #ifdef __KERNEL__
+/* Attributes */
+#include <linux/compiler_attributes.h>
 /* Compiler specific macros. */
 #ifdef __clang__
 #include <linux/compiler-clang.h>
 #include <asm/compiler.h>
 #endif
-/*
- * Generic compiler-independent macros required for kernel
- * build go below this comment. Actual compiler/compiler version
- * specific implementations come from the above header files
- */
 struct ftrace_branch_data {
 	const char *func;
 	const char *file;
 	unsigned long			constant;
 };
-/* Don't. Just don't. */
-#define __deprecated
-#define __deprecated_for_modules
 #endif /* __KERNEL__ */
 #endif /* __ASSEMBLY__ */
  * compilers. We don't consider that to be an error, so set them to nothing.
  * For example, some of them are for compiler specific plugins.
  */
-#ifndef __designated_init
-# define __designated_init
-#endif
 #ifndef __latent_entropy
 # define __latent_entropy
 #endif
 # define randomized_struct_fields_end
 #endif
-#ifndef __visible
+#ifndef asm_volatile_goto
-#define __visible
+#define asm_volatile_goto(x...) asm goto(x)
-#endif
-/*
- * Assume alignment of return value.
- */
-#ifndef __assume_aligned
-#define __assume_aligned(a, ...)
 #endif
 /* Are two types/vars the same type (ignoring qualifiers)? */
 	(sizeof(t) == sizeof(char) || sizeof(t) == sizeof(short) || \
 	 sizeof(t) == sizeof(int) || sizeof(t) == sizeof(long))
-#ifndef __attribute_const__
-#define __attribute_const__	__attribute__((__const__))
-#endif
-#ifndef __noclone
-#define __noclone
-#endif
 /* Helpers for emitting diagnostics in pragmas. */
 #ifndef __diag
 #define __diag(string)
 #define __diag_error(compiler, version, option, comment) \
 	__diag_ ## compiler(version, error, option)
-/*
- * From the GCC manual:
- *
- * Many functions have no effects except the return value and their
- * return value depends only on the parameters and/or global
- * variables.  Such a function can be subject to common subexpression
- * elimination and loop optimization just as an arithmetic operator
- * would be.
- * [...]
- */
-#define __pure			__attribute__((pure))
-#define __aligned(x)		__attribute__((aligned(x)))
-#define __printf(a, b)		__attribute__((format(printf, a, b)))
-#define __scanf(a, b)		__attribute__((format(scanf, a, b)))
-#define __maybe_unused		__attribute__((unused))
-#define __always_unused		__attribute__((unused))
-#define __mode(x)		__attribute__((mode(x)))
-#define __malloc		__attribute__((__malloc__))
-#define __used			__attribute__((__used__))
-#define __noreturn		__attribute__((noreturn))
-#define __packed		__attribute__((packed))
-#define __weak			__attribute__((weak))
-#define __alias(symbol)		__attribute__((alias(#symbol)))
-#define __cold			__attribute__((cold))
-#define __section(S)		__attribute__((__section__(#S)))
 #ifdef CONFIG_ENABLE_MUST_CHECK
-#define __must_check		__attribute__((warn_unused_result))
+#define __must_check		__attribute__((__warn_unused_result__))
 #else
 #define __must_check
 #endif
-#if defined(CC_USING_HOTPATCH) && !defined(__CHECKER__)
+#if defined(CC_USING_HOTPATCH)
 #define notrace			__attribute__((hotpatch(0, 0)))
 #else
-#define notrace			__attribute__((no_instrument_function))
+#define notrace			__attribute__((__no_instrument_function__))
 #endif
 /*
  * stack and frame pointer being set up and there is no chance to
  * restore the lr register to the value before mcount was called.
  */
-#define __naked			__attribute__((naked)) notrace
+#define __naked			__attribute__((__naked__)) notrace
 #define __compiler_offsetof(a, b)	__builtin_offsetof(a, b)
-/*
- * Feature detection for gnu_inline (gnu89 extern inline semantics). Either
- * __GNUC_STDC_INLINE__ is defined (not using gnu89 extern inline semantics,
- * and we opt in to the gnu89 semantics), or __GNUC_STDC_INLINE__ is not
- * defined so the gnu89 semantics are the default.
- */
-#ifdef __GNUC_STDC_INLINE__
-# define __gnu_inline	__attribute__((gnu_inline))
-#else
-# define __gnu_inline
-#endif
 /*
  * Force always-inline if the user requests it so via the .config.
  * GCC does not warn about unused static inline functions for
  * semantics rather than c99. This prevents multiple symbol definition errors
  * of extern inline functions at link time.
  * A lot of inline functions can cause havoc with function tracing.
+ * Do not use __always_inline here, since currently it expands to inline again
+ * (which would break users of __always_inline).
  */
 #if !defined(CONFIG_ARCH_SUPPORTS_OPTIMIZED_INLINING) || \
 	!defined(CONFIG_OPTIMIZE_INLINING)
-#define inline \
+#define inline inline __attribute__((__always_inline__)) __gnu_inline \
-	inline __attribute__((always_inline, unused)) notrace __gnu_inline
+	__maybe_unused notrace
 #else
-#define inline inline	__attribute__((unused)) notrace __gnu_inline
+#define inline inline                                    __gnu_inline \
+	__maybe_unused notrace
 #endif
 #define __inline__ inline
-#define __inline inline
+#define __inline   inline
-#define noinline	__attribute__((noinline))
-#ifndef __always_inline
-#define __always_inline inline __attribute__((always_inline))
-#endif
 /*
  * Rather then using noinline to prevent stack consumption, use

include/linux/cpuhotplug.h+1−0

@@ -126,6 +126,7 @@ enum cpuhp_state { · 125 unmodified lines
126	CPUHP_AP_MIPS_GIC_TIMER_STARTING,	126	CPUHP_AP_MIPS_GIC_TIMER_STARTING,
127	CPUHP_AP_ARC_TIMER_STARTING,	127	CPUHP_AP_ARC_TIMER_STARTING,
128	CPUHP_AP_RISCV_TIMER_STARTING,	128	CPUHP_AP_RISCV_TIMER_STARTING,
		129	CPUHP_AP_CSKY_TIMER_STARTING,
129	CPUHP_AP_KVM_STARTING,	130	CPUHP_AP_KVM_STARTING,
130	CPUHP_AP_KVM_ARM_VGIC_INIT_STARTING,	131	CPUHP_AP_KVM_ARM_VGIC_INIT_STARTING,
131	CPUHP_AP_KVM_ARM_VGIC_STARTING,	132	CPUHP_AP_KVM_ARM_VGIC_STARTING,

include/linux/dax.h+8−6

 #include <linux/radix-tree.h>
 #include <asm/pgtable.h>
+typedef unsigned long dax_entry_t;
 struct iomap_ops;
 struct dax_device;
 struct dax_operations {
 		struct block_device *bdev, struct writeback_control *wbc);
 struct page *dax_layout_busy_page(struct address_space *mapping);
-bool dax_lock_mapping_entry(struct page *page);
+dax_entry_t dax_lock_page(struct page *page);
-void dax_unlock_mapping_entry(struct page *page);
+void dax_unlock_page(struct page *page, dax_entry_t cookie);
 #else
 static inline bool bdev_dax_supported(struct block_device *bdev,
 		int blocksize)
 	return -EOPNOTSUPP;
 }
-static inline bool dax_lock_mapping_entry(struct page *page)
+static inline dax_entry_t dax_lock_page(struct page *page)
 {
 	if (IS_DAX(page->mapping->host))
-		return true;
+		return ~0UL;
-	return false;
+	return 0;
 }
-static inline void dax_unlock_mapping_entry(struct page *page)
+static inline void dax_unlock_page(struct page *page, dax_entry_t cookie)
 {
 }
 #endif

include/linux/dma-direct.h+1−1

@@ -5,7 +5,7 @@ · 4 unmodified lines
5	#include <linux/dma-mapping.h>	5	#include <linux/dma-mapping.h>
6	#include <linux/mem_encrypt.h>	6	#include <linux/mem_encrypt.h>
7		7
8	#define DIRECT_MAPPING_ERROR 0	8	#define DIRECT_MAPPING_ERROR (~(dma_addr_t)0)
9		9
10	#ifdef CONFIG_ARCH_HAS_PHYS_TO_DMA	10	#ifdef CONFIG_ARCH_HAS_PHYS_TO_DMA
11	#include <asm/dma-direct.h>	11	#include <asm/dma-direct.h>

include/linux/efi.h+7−0

 extern void efi_reboot(enum reboot_mode reboot_mode, const char *__unused);
 extern bool efi_is_table_address(unsigned long phys_addr);
+extern int efi_apply_persistent_mem_reservations(void);
 #else
 static inline bool efi_enabled(int feature)
 {
 {
 	return false;
 }
+static inline int efi_apply_persistent_mem_reservations(void)
+{
+	return 0;
+}
 #endif
 extern int efi_status_to_err(efi_status_t status);

include/linux/filter.h+11−0

 	offsetof(TYPE, MEMBER) ... offsetofend(TYPE, MEMBER) - 1
 #define bpf_ctx_range_till(TYPE, MEMBER1, MEMBER2)				\
 	offsetof(TYPE, MEMBER1) ... offsetofend(TYPE, MEMBER2) - 1
+#if BITS_PER_LONG == 64
+# define bpf_ctx_range_ptr(TYPE, MEMBER)					\
+	offsetof(TYPE, MEMBER) ... offsetofend(TYPE, MEMBER) - 1
+#else
+# define bpf_ctx_range_ptr(TYPE, MEMBER)					\
+	offsetof(TYPE, MEMBER) ... offsetof(TYPE, MEMBER) + 8 - 1
+#endif /* BITS_PER_LONG == 64 */
 #define bpf_target_off(TYPE, MEMBER, SIZE, PTR_SIZE)				\
 	({									\
 void bpf_jit_free(struct bpf_prog *fp);
+int bpf_jit_get_func_addr(const struct bpf_prog *prog,
+			  const struct bpf_insn *insn, bool extra_pass,
+			  u64 *func_addr, bool *func_addr_fixed);
 struct bpf_prog *bpf_jit_blind_constants(struct bpf_prog *fp);
 void bpf_jit_prog_release_other(struct bpf_prog *fp, struct bpf_prog *fp_other);

include/linux/fs.h+38−17

 #define NOMMU_VMFLAGS \
 	(NOMMU_MAP_READ | NOMMU_MAP_WRITE | NOMMU_MAP_EXEC)
+/*
+ * These flags control the behavior of the remap_file_range function pointer.
+ * If it is called with len == 0 that means "remap to end of source file".
+ * See Documentation/filesystems/vfs.txt for more details about this call.
+ *
+ * REMAP_FILE_DEDUP: only remap if contents identical (i.e. deduplicate)
+ * REMAP_FILE_CAN_SHORTEN: caller can handle a shortened request
+ */
+#define REMAP_FILE_DEDUP		(1 << 0)
+#define REMAP_FILE_CAN_SHORTEN		(1 << 1)
+/*
+ * These flags signal that the caller is ok with altering various aspects of
+ * the behavior of the remap operation.  The changes must be made by the
+ * implementation; the vfs remap helper functions can take advantage of them.
+ * Flags in this category exist to preserve the quirky behavior of the hoisted
+ * btrfs clone/dedupe ioctls.
+ */
+#define REMAP_FILE_ADVISORY		(REMAP_FILE_CAN_SHORTEN)
 struct iov_iter;
 #endif
 	ssize_t (*copy_file_range)(struct file *, loff_t, struct file *,
 			loff_t, size_t, unsigned int);
-	int (*clone_file_range)(struct file *, loff_t, struct file *, loff_t,
+	loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in,
-			u64);
+				   struct file *file_out, loff_t pos_out,
-	int (*dedupe_file_range)(struct file *, loff_t, struct file *, loff_t,
+				   loff_t len, unsigned int remap_flags);
-			u64);
 	int (*fadvise)(struct file *, loff_t, loff_t, int);
 } __randomize_layout;
 		unsigned long, loff_t *, rwf_t);
 extern ssize_t vfs_copy_file_range(struct file *, loff_t , struct file *,
 				   loff_t, size_t, unsigned int);
-extern int vfs_clone_file_prep_inodes(struct inode *inode_in, loff_t pos_in,
+extern int generic_remap_file_range_prep(struct file *file_in, loff_t pos_in,
-				      struct inode *inode_out, loff_t pos_out,
+					 struct file *file_out, loff_t pos_out,
-				      u64 *len, bool is_dedupe);
+					 loff_t *count,
-extern int do_clone_file_range(struct file *file_in, loff_t pos_in,
+					 unsigned int remap_flags);
-			       struct file *file_out, loff_t pos_out, u64 len);
+extern loff_t do_clone_file_range(struct file *file_in, loff_t pos_in,
-extern int vfs_clone_file_range(struct file *file_in, loff_t pos_in,
+				  struct file *file_out, loff_t pos_out,
-				struct file *file_out, loff_t pos_out, u64 len);
+				  loff_t len, unsigned int remap_flags);
-extern int vfs_dedupe_file_range_compare(struct inode *src, loff_t srcoff,
+extern loff_t vfs_clone_file_range(struct file *file_in, loff_t pos_in,
-					 struct inode *dest, loff_t destoff,
+				   struct file *file_out, loff_t pos_out,
-					 loff_t len, bool *is_same);
+				   loff_t len, unsigned int remap_flags);
 extern int vfs_dedupe_file_range(struct file *file,
 				 struct file_dedupe_range *same);
-extern int vfs_dedupe_file_range_one(struct file *src_file, loff_t src_pos,
+extern loff_t vfs_dedupe_file_range_one(struct file *src_file, loff_t src_pos,
-				     struct file *dst_file, loff_t dst_pos,
+					struct file *dst_file, loff_t dst_pos,
-				     u64 len);
+					loff_t len, unsigned int remap_flags);
 struct super_operations {
 extern int generic_file_mmap(struct file *, struct vm_area_struct *);
 extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
 extern ssize_t generic_write_checks(struct kiocb *, struct iov_iter *);
+extern int generic_remap_checks(struct file *file_in, loff_t pos_in,
+				struct file *file_out, loff_t pos_out,
+				loff_t *count, unsigned int remap_flags);
 extern ssize_t generic_file_read_iter(struct kiocb *, struct iov_iter *);
 extern ssize_t __generic_file_write_iter(struct kiocb *, struct iov_iter *);
 extern ssize_t generic_file_write_iter(struct kiocb *, struct iov_iter *);

include/linux/fscache-cache.h+1−2

@@ -196,8 +196,7 @@ static inline void fscache_enqueue_retrieval(struct fscache_retrieval *op) · 195 unmodified lines
196	static inline void fscache_retrieval_complete(struct fscache_retrieval *op,	196	static inline void fscache_retrieval_complete(struct fscache_retrieval *op,
197	int n_pages)	197	int n_pages)
198	{	198	{
199	atomic_sub(n_pages, &op->n_pages);	199	if (atomic_sub_return_relaxed(n_pages, &op->n_pages) <= 0)
200	if (atomic_read(&op->n_pages) <= 0)
201	fscache_op_complete(&op->op, false);	200	fscache_op_complete(&op->op, false);
202	}	201	}
203		202

include/linux/ftrace.h+2−2

@@ -777,8 +777,8 @@ struct ftrace_ret_stack { · 776 unmodified lines
777	extern void return_to_handler(void);	777	extern void return_to_handler(void);
778		778
779	extern int	779	extern int
780	ftrace_push_return_trace(unsigned long ret, unsigned long func, int *depth,	780	function_graph_enter(unsigned long ret, unsigned long func,
781	unsigned long frame_pointer, unsigned long *retp);	781	unsigned long frame_pointer, unsigned long *retp);
782		782
783	unsigned long ftrace_graph_ret_addr(struct task_struct task, int idx,	783	unsigned long ftrace_graph_ret_addr(struct task_struct task, int idx,
784	unsigned long ret, unsigned long *retp);	784	unsigned long ret, unsigned long *retp);

include/linux/gfp.h+2−2

include/linux/hid-sensor-hub.h+3−1

 * @attr_usage_id:	Attribute usage id as per spec
 * @report_id:	Report id to look for
 * @flag:      Synchronous or asynchronous read
+* @is_signed:   If true then fields < 32 bits will be sign-extended
 *
 * Issues a synchronous or asynchronous read request for an input attribute.
 * Returns data upto 32 bits.
 int sensor_hub_input_attr_get_raw_value(struct hid_sensor_hub_device *hsdev,
  					u32 usage_id,
  					u32 attr_usage_id, u32 report_id,
- 					enum sensor_hub_read_flags flag
+					enum sensor_hub_read_flags flag,
+					bool is_signed
 );
 /**

include/linux/hid.h+16−1

 #define HID_GD_VBRZ		0x00010045
 #define HID_GD_VNO		0x00010046
 #define HID_GD_FEATURE		0x00010047
+#define HID_GD_RESOLUTION_MULTIPLIER	0x00010048
 #define HID_GD_SYSTEM_CONTROL	0x00010080
 #define HID_GD_UP		0x00010090
 #define HID_GD_DOWN		0x00010091
 #define HID_DC_BATTERYSTRENGTH	0x00060020
 #define HID_CP_CONSUMER_CONTROL	0x000c0001
+#define HID_CP_AC_PAN		0x000c0238
 #define HID_DG_DIGITIZER	0x000d0001
 #define HID_DG_PEN		0x000d0002
 #define HID_DG_LIGHTPEN		0x000d0003
 #define HID_DG_TOUCHSCREEN	0x000d0004
 #define HID_DG_TOUCHPAD		0x000d0005
+#define HID_DG_WHITEBOARD	0x000d0006
 #define HID_DG_STYLUS		0x000d0020
 #define HID_DG_PUCK		0x000d0021
 #define HID_DG_FINGER		0x000d0022
  */
 struct hid_collection {
+	struct hid_collection *parent;
 	unsigned type;
 	unsigned usage;
 	unsigned level;
 	unsigned  hid;			/* hid usage code */
 	unsigned  collection_index;	/* index into collection array */
 	unsigned  usage_index;		/* index into usage array */
+	__s8	  resolution_multiplier;/* Effective Resolution Multiplier
+					   (HUT v1.12, 4.3.1), default: 1 */
 	/* hidinput data */
+	__s8	  wheel_factor;		/* 120/resolution_multiplier */
 	__u16     code;			/* input driver code */
 	__u8      type;			/* input driver type */
 	__s8	  hat_min;		/* hat switch fun */
 	__s8	  hat_max;		/* ditto */
 	__s8	  hat_dir;		/* ditto */
+	__s16	  wheel_accumulated;	/* hi-res wheel */
 };
 struct hid_input;
 	unsigned int         *collection_stack;
 	unsigned int          collection_stack_ptr;
 	unsigned int          collection_stack_size;
+	struct hid_collection *active_collection;
 	struct hid_device    *device;
 	unsigned int          scan_flags;
 };
 /* Applications from HID Usage Tables 4/8/99 Version 1.1 */
 /* We ignore a few input applications that are not widely used */
-#define IS_INPUT_APPLICATION(a) (((a >= 0x00010000) && (a <= 0x00010008)) || (a == 0x00010080) || (a == 0x000c0001) || ((a >= 0x000d0002) && (a <= 0x000d0006)))
+#define IS_INPUT_APPLICATION(a) \
+		(((a >= HID_UP_GENDESK) && (a <= HID_GD_MULTIAXIS)) \
+		|| ((a >= HID_DG_PEN) && (a <= HID_DG_WHITEBOARD)) \
+		|| (a == HID_GD_SYSTEM_CONTROL) || (a == HID_CP_CONSUMER_CONTROL) \
+		|| (a == HID_GD_WIRELESS_RADIO_CTLS))
 /* HID core API */
 				       unsigned int type, unsigned int id,
 				       unsigned int field_index,
 				       unsigned int report_counts);
+void hid_setup_resolution_multiplier(struct hid_device *hid);
 int hid_open_report(struct hid_device *device);
 int hid_check_keys_pressed(struct hid_device *hid);
 int hid_connect(struct hid_device *hid, unsigned int connect_mask);

include/linux/hyperv.h+7−0

@@ -905,6 +905,13 @@ struct vmbus_channel { · 904 unmodified lines
905		905
906	bool probe_done;	906	bool probe_done;
907		907
		908	/*
		909	* We must offload the handling of the primary/sub channels
		910	* from the single-threaded vmbus_connection.work_queue to
		911	* two different workqueue, otherwise we can block
		912	* vmbus_connection.work_queue and hang: see vmbus_process_offer().
		913	*/
		914	struct work_struct add_channel_work;
908	};	915	};
909		916
910	static inline bool is_hvsock_channel(const struct vmbus_channel *c)	917	static inline bool is_hvsock_channel(const struct vmbus_channel *c)

include/linux/i8253.h+1−0

@@ -21,6 +21,7 @@ · 20 unmodified lines
21	#define PIT_LATCH ((PIT_TICK_RATE + HZ/2) / HZ)	21	#define PIT_LATCH ((PIT_TICK_RATE + HZ/2) / HZ)
22		22
23	extern raw_spinlock_t i8253_lock;	23	extern raw_spinlock_t i8253_lock;
		24	extern bool i8253_clear_counter_on_shutdown;
24	extern struct clock_event_device i8253_clockevent;	25	extern struct clock_event_device i8253_clockevent;
25	extern void clockevent_i8253_init(bool oneshot);	26	extern void clockevent_i8253_init(bool oneshot);
26		27

include/linux/inetdevice.h+3−1

 	unsigned long		mr_v1_seen;
 	unsigned long		mr_v2_seen;
 	unsigned long		mr_maxdelay;
-	unsigned char		mr_qrv;
+	unsigned long		mr_qi;		/* Query Interval */
+	unsigned long		mr_qri;		/* Query Response Interval */
+	unsigned char		mr_qrv;		/* Query Robustness Variable */
 	unsigned char		mr_gq_running;
 	unsigned char		mr_ifc_count;
 	struct timer_list	mr_gq_timer;	/* general query timer */

include/linux/key-type.h+11−0

 #ifdef CONFIG_KEYS
+struct kernel_pkey_query;
+struct kernel_pkey_params;
 /*
  * key under-construction record
  * - passed to the request_key actor if supplied
 	 */
 	struct key_restriction *(*lookup_restriction)(const char *params);
+	/* Asymmetric key accessor functions. */
+	int (*asym_query)(const struct kernel_pkey_params *params,
+			  struct kernel_pkey_query *info);
+	int (*asym_eds_op)(struct kernel_pkey_params *params,
+			   const void *in, void *out);
+	int (*asym_verify_signature)(struct kernel_pkey_params *params,
+				     const void *in, const void *in2);
 	/* internal fields */
 	struct list_head	link;		/* link in types list */
 	struct lock_class_key	lock_class;	/* key->sem lock class */

include/linux/keyctl.h+46−0

@@ -0,0 +1,46 @@
	1	/* keyctl kernel bits
	2	*
	3	* Copyright (C) 2016 Red Hat, Inc. All Rights Reserved.
	4	* Written by David Howells (dhowells@redhat.com)
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public Licence
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the Licence, or (at your option) any later version.
	10	*/
	11
	12	#ifndef __LINUX_KEYCTL_H
	13	#define __LINUX_KEYCTL_H
	14
	15	#include <uapi/linux/keyctl.h>
	16
	17	struct kernel_pkey_query {
	18	__u32 supported_ops; /* Which ops are supported */
	19	__u32 key_size; /* Size of the key in bits */
	20	__u16 max_data_size; /* Maximum size of raw data to sign in bytes */
	21	__u16 max_sig_size; /* Maximum size of signature in bytes */
	22	__u16 max_enc_size; /* Maximum size of encrypted blob in bytes */
	23	__u16 max_dec_size; /* Maximum size of decrypted blob in bytes */
	24	};
	25
	26	enum kernel_pkey_operation {
	27	kernel_pkey_encrypt,
	28	kernel_pkey_decrypt,
	29	kernel_pkey_sign,
	30	kernel_pkey_verify,
	31	};
	32
	33	struct kernel_pkey_params {
	34	struct key *key;
	35	const char encoding; / Encoding (eg. "oaep" or "raw" for none) */
	36	const char hash_algo; / Digest algorithm used (eg. "sha1") or NULL if N/A */
	37	char info; / Modified info string to be released later */
	38	__u32 in_len; /* Input data size */
	39	union {
	40	__u32 out_len; /* Output buffer size (enc/dec/sign) */
	41	__u32 in2_len; /* 2nd input data size (verify) */
	42	};
	43	enum kernel_pkey_operation op : 8;
	44	};
	45
	46	#endif /* __LINUX_KEYCTL_H */

include/linux/mlx5/mlx5_ifc.h+8−4

 	u8         wq_signature[0x1];
 	u8         cont_srq[0x1];
-	u8         dbr_umem_valid[0x1];
+	u8         reserved_at_22[0x1];
 	u8         rlky[0x1];
 	u8         basic_cyclic_rcv_wqe[0x1];
 	u8         log_rq_stride[0x3];
 	u8         xrcd[0x18];
 	u8         page_offset[0x6];
-	u8         reserved_at_46[0x2];
+	u8         reserved_at_46[0x1];
+	u8         dbr_umem_valid[0x1];
 	u8         cqn[0x18];
 	u8         reserved_at_60[0x20];
 	struct mlx5_ifc_xrc_srqc_bits xrc_srq_context_entry;
-	u8         reserved_at_280[0x40];
+	u8         reserved_at_280[0x60];
 	u8         xrc_srq_umem_valid[0x1];
-	u8         reserved_at_2c1[0x5bf];
+	u8         reserved_at_2e1[0x1f];
+	u8         reserved_at_300[0x580];
 	u8         pas[0][0x40];
 };

include/linux/mm.h+8−0

 static inline void mm_inc_nr_puds(struct mm_struct *mm)
 {
+	if (mm_pud_folded(mm))
+		return;
 	atomic_long_add(PTRS_PER_PUD * sizeof(pud_t), &mm->pgtables_bytes);
 }
 static inline void mm_dec_nr_puds(struct mm_struct *mm)
 {
+	if (mm_pud_folded(mm))
+		return;
 	atomic_long_sub(PTRS_PER_PUD * sizeof(pud_t), &mm->pgtables_bytes);
 }
 #endif
 static inline void mm_inc_nr_pmds(struct mm_struct *mm)
 {
+	if (mm_pmd_folded(mm))
+		return;
 	atomic_long_add(PTRS_PER_PMD * sizeof(pmd_t), &mm->pgtables_bytes);
 }
 static inline void mm_dec_nr_pmds(struct mm_struct *mm)
 {
+	if (mm_pmd_folded(mm))
+		return;
 	atomic_long_sub(PTRS_PER_PMD * sizeof(pmd_t), &mm->pgtables_bytes);
 }
 #endif

include/linux/mtd/nand.h+3−4

  */
 static inline unsigned int nanddev_neraseblocks(const struct nand_device *nand)
 {
-	return (u64)nand->memorg.luns_per_target *
+	return nand->memorg.ntargets * nand->memorg.luns_per_target *
-	       nand->memorg.eraseblocks_per_lun *
+	       nand->memorg.eraseblocks_per_lun;
-	       nand->memorg.pages_per_eraseblock;
 }
 /**
 }
 /**
- * nanddev_pos_next_eraseblock() - Move a position to the next page
+ * nanddev_pos_next_page() - Move a position to the next page
  * @nand: NAND device
  * @pos: the position to update
  *

include/linux/net_dim.h+2−0

 		}
 		/* fall through */
 	case NET_DIM_START_MEASURE:
+		net_dim_sample(end_sample.event_ctr, end_sample.pkt_ctr, end_sample.byte_ctr,
+			       &dim->start_sample);
 		dim->state = NET_DIM_MEASURE_IN_PROGRESS;
 		break;
 	case NET_DIM_APPLY_NEW_PROFILE:

include/linux/netdevice.h+20−0

@@ -3190,6 +3190,26 @@ static inline void netdev_tx_sent_queue(struct netdev_queue *dev_queue, · 3189 unmodified lines
3190	#endif	3190	#endif
3191	}	3191	}
3192		3192
		3193	/* Variant of netdev_tx_sent_queue() for drivers that are aware
		3194	* that they should not test BQL status themselves.
		3195	* We do want to change __QUEUE_STATE_STACK_XOFF only for the last
		3196	* skb of a batch.
		3197	* Returns true if the doorbell must be used to kick the NIC.
		3198	*/
		3199	static inline bool __netdev_tx_sent_queue(struct netdev_queue *dev_queue,
		3200	unsigned int bytes,
		3201	bool xmit_more)
		3202	{
		3203	if (xmit_more) {
		3204	#ifdef CONFIG_BQL
		3205	dql_queued(&dev_queue->dql, bytes);
		3206	#endif
		3207	return netif_tx_queue_stopped(dev_queue);
		3208	}
		3209	netdev_tx_sent_queue(dev_queue, bytes);
		3210	return true;
		3211	}
		3212
3193	/**	3213	/**
3194	* netdev_sent_queue - report the number of bytes queued to hardware	3214	* netdev_sent_queue - report the number of bytes queued to hardware
3195	* @dev: network device	3215	* @dev: network device

include/linux/netfilter/ipset/ip_set.h+1−1

@@ -314,7 +314,7 @@ enum { · 313 unmodified lines
314	extern ip_set_id_t ip_set_get_byname(struct net *net,	314	extern ip_set_id_t ip_set_get_byname(struct net *net,
315	const char name, struct ip_set *set);	315	const char name, struct ip_set *set);
316	extern void ip_set_put_byindex(struct net *net, ip_set_id_t index);	316	extern void ip_set_put_byindex(struct net *net, ip_set_id_t index);
317	extern const char ip_set_name_byindex(struct net net, ip_set_id_t index);	317	extern void ip_set_name_byindex(struct net net, ip_set_id_t index, char name);
318	extern ip_set_id_t ip_set_nfnl_get_byindex(struct net *net, ip_set_id_t index);	318	extern ip_set_id_t ip_set_nfnl_get_byindex(struct net *net, ip_set_id_t index);
319	extern void ip_set_nfnl_put(struct net *net, ip_set_id_t index);	319	extern void ip_set_nfnl_put(struct net *net, ip_set_id_t index);
320		320

include/linux/netfilter/ipset/ip_set_comment.h+2−2

@@ -43,11 +43,11 @@ ip_set_init_comment(struct ip_set set, struct ip_set_comment comment, · 42 unmodified lines
43	rcu_assign_pointer(comment->c, c);	43	rcu_assign_pointer(comment->c, c);
44	}	44	}
45		45
46	/* Used only when dumping a set, protected by rcu_read_lock_bh() */	46	/* Used only when dumping a set, protected by rcu_read_lock() */
47	static inline int	47	static inline int
48	ip_set_put_comment(struct sk_buff skb, const struct ip_set_comment comment)	48	ip_set_put_comment(struct sk_buff skb, const struct ip_set_comment comment)
49	{	49	{
50	struct ip_set_comment_rcu *c = rcu_dereference_bh(comment->c);	50	struct ip_set_comment_rcu *c = rcu_dereference(comment->c);
51		51
52	if (!c)	52	if (!c)
53	return 0;	53	return 0;

include/linux/netfilter/nf_conntrack_proto_gre.h+13−0

@@ -21,6 +21,19 @@ struct nf_ct_gre_keymap { · 20 unmodified lines
21	struct nf_conntrack_tuple tuple;	21	struct nf_conntrack_tuple tuple;
22	};	22	};
23		23
		24	enum grep_conntrack {
		25	GRE_CT_UNREPLIED,
		26	GRE_CT_REPLIED,
		27	GRE_CT_MAX
		28	};
		29
		30	struct netns_proto_gre {
		31	struct nf_proto_net nf;
		32	rwlock_t keymap_lock;
		33	struct list_head keymap_list;
		34	unsigned int gre_timeouts[GRE_CT_MAX];
		35	};
		36
24	/* add new tuple->key_reply pair to keymap */	37	/* add new tuple->key_reply pair to keymap */
25	int nf_ct_gre_keymap_add(struct nf_conn *ct, enum ip_conntrack_dir dir,	38	int nf_ct_gre_keymap_add(struct nf_conn *ct, enum ip_conntrack_dir dir,
26	struct nf_conntrack_tuple *t);	39	struct nf_conntrack_tuple *t);

include/linux/nmi.h+2−0

@@ -119,6 +119,8 @@ static inline int hardlockup_detector_perf_init(void) { return 0; } · 118 unmodified lines
119	void watchdog_nmi_stop(void);	119	void watchdog_nmi_stop(void);
120	void watchdog_nmi_start(void);	120	void watchdog_nmi_start(void);
121	int watchdog_nmi_probe(void);	121	int watchdog_nmi_probe(void);
		122	int watchdog_nmi_enable(unsigned int cpu);
		123	void watchdog_nmi_disable(unsigned int cpu);
122		124
123	/**	125	/**
124	* touch_nmi_watchdog - restart NMI watchdog timeout.	126	* touch_nmi_watchdog - restart NMI watchdog timeout.

include/linux/notifier.h+1−2

@@ -122,8 +122,7 @@ extern void srcu_init_notifier_head(struct srcu_notifier_head *nh); · 121 unmodified lines
122		122
123	#ifdef CONFIG_TREE_SRCU	123	#ifdef CONFIG_TREE_SRCU
124	#define _SRCU_NOTIFIER_HEAD(name, mod) \	124	#define _SRCU_NOTIFIER_HEAD(name, mod) \
125	static DEFINE_PER_CPU(struct srcu_data, \	125	static DEFINE_PER_CPU(struct srcu_data, name##_head_srcu_data); \
126	name##_head_srcu_data); \
127	mod struct srcu_notifier_head name = \	126	mod struct srcu_notifier_head name = \
128	SRCU_NOTIFIER_INIT(name, name##_head_srcu_data)	127	SRCU_NOTIFIER_INIT(name, name##_head_srcu_data)
129		128

include/linux/platform_data/gpio-davinci.h+2−0

@@ -17,6 +17,8 @@ · 16 unmodified lines
17	#define __DAVINCI_GPIO_PLATFORM_H	17	#define __DAVINCI_GPIO_PLATFORM_H
18		18
19	struct davinci_gpio_platform_data {	19	struct davinci_gpio_platform_data {
		20	bool no_auto_base;
		21	u32 base;
20	u32 ngpio;	22	u32 ngpio;
21	u32 gpio_unbanked;	23	u32 gpio_unbanked;
22	};	24	};

include/linux/psi.h+2−1

 #ifndef _LINUX_PSI_H
 #define _LINUX_PSI_H
+#include <linux/jump_label.h>
 #include <linux/psi_types.h>
 #include <linux/sched.h>
 #ifdef CONFIG_PSI
-extern bool psi_disabled;
+extern struct static_key_false psi_disabled;
 void psi_init(void);

include/linux/pstore.h+4−1

  *
  * @buf_lock:	spinlock to serialize access to @buf
  * @buf:	preallocated crash dump buffer
- * @bufsize:	size of @buf available for crash dump writes
+ * @bufsize:	size of @buf available for crash dump bytes (must match
+ *		smallest number of bytes available for writing to a
+ *		backend entry, since compressed bytes don't take kindly
+ *		to being truncated)
  *
  * @read_mutex:	serializes @open, @read, @close, and @erase callbacks
  * @flags:	bitfield of frontends the backend can accept writes for

include/linux/ptrace.h+0−17

 #define PTRACE_MODE_NOAUDIT	0x04
 #define PTRACE_MODE_FSCREDS	0x08
 #define PTRACE_MODE_REALCREDS	0x10
-#define PTRACE_MODE_SCHED	0x20
-#define PTRACE_MODE_IBPB	0x40
 /* shorthands for READ/ATTACH and FSCREDS/REALCREDS combinations */
 #define PTRACE_MODE_READ_FSCREDS (PTRACE_MODE_READ | PTRACE_MODE_FSCREDS)
 #define PTRACE_MODE_READ_REALCREDS (PTRACE_MODE_READ | PTRACE_MODE_REALCREDS)
 #define PTRACE_MODE_ATTACH_FSCREDS (PTRACE_MODE_ATTACH | PTRACE_MODE_FSCREDS)
 #define PTRACE_MODE_ATTACH_REALCREDS (PTRACE_MODE_ATTACH | PTRACE_MODE_REALCREDS)
-#define PTRACE_MODE_SPEC_IBPB (PTRACE_MODE_ATTACH_REALCREDS | PTRACE_MODE_IBPB)
 /**
  * ptrace_may_access - check whether the caller is permitted to access
  */
 extern bool ptrace_may_access(struct task_struct *task, unsigned int mode);
-/**
- * ptrace_may_access - check whether the caller is permitted to access
- * a target task.
- * @task: target task
- * @mode: selects type of access and caller credentials
- *
- * Returns true on success, false on denial.
- *
- * Similar to ptrace_may_access(). Only to be called from context switch
- * code. Does not call into audit and the regular LSM hooks due to locking
- * constraints.
- */
-extern bool ptrace_may_access_sched(struct task_struct *task, unsigned int mode);
 static inline int ptrace_reparented(struct task_struct *child)
 {
 	return !same_thread_group(child->real_parent, child->parent);

include/linux/sched.h+15−0

 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 	/* Index of current stored address in ret_stack: */
 	int				curr_ret_stack;
+	int				curr_ret_depth;
 	/* Stack of return addresses for return function tracing: */
 	struct ftrace_ret_stack		*ret_stack;
 	void				*security;
 #endif
+#ifdef CONFIG_GCC_PLUGIN_STACKLEAK
+	unsigned long			lowest_stack;
+	unsigned long			prev_lowest_stack;
+#endif
 	/*
 	 * New fields for task_struct should be added above here, so that
 	 * they are included in the randomized portion of task_struct.
 #define PFA_SPREAD_SLAB			2	/* Spread some slab caches over cpuset */
 #define PFA_SPEC_SSB_DISABLE		3	/* Speculative Store Bypass disabled */
 #define PFA_SPEC_SSB_FORCE_DISABLE	4	/* Speculative Store Bypass force disabled*/
+#define PFA_SPEC_IB_DISABLE		5	/* Indirect branch speculation restricted */
+#define PFA_SPEC_IB_FORCE_DISABLE	6	/* Indirect branch speculation permanently restricted */
 #define TASK_PFA_TEST(name, func)					\
 	static inline bool task_##func(struct task_struct *p)		\
 TASK_PFA_TEST(SPEC_SSB_FORCE_DISABLE, spec_ssb_force_disable)
 TASK_PFA_SET(SPEC_SSB_FORCE_DISABLE, spec_ssb_force_disable)
+TASK_PFA_TEST(SPEC_IB_DISABLE, spec_ib_disable)
+TASK_PFA_SET(SPEC_IB_DISABLE, spec_ib_disable)
+TASK_PFA_CLEAR(SPEC_IB_DISABLE, spec_ib_disable)
+TASK_PFA_TEST(SPEC_IB_FORCE_DISABLE, spec_ib_force_disable)
+TASK_PFA_SET(SPEC_IB_FORCE_DISABLE, spec_ib_force_disable)
 static inline void
 current_restore_flags(unsigned long orig_flags, unsigned long flags)
 {

include/linux/sched/smt.h+20−0

@@ -0,0 +1,20 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef _LINUX_SCHED_SMT_H
	3	#define _LINUX_SCHED_SMT_H
	4
	5	#include <linux/static_key.h>
	6
	7	#ifdef CONFIG_SCHED_SMT
	8	extern struct static_key_false sched_smt_present;
	9
	10	static __always_inline bool sched_smt_active(void)
	11	{
	12	return static_branch_likely(&sched_smt_present);
	13	}
	14	#else
	15	static inline bool sched_smt_active(void) { return false; }
	16	#endif
	17
	18	void arch_smt_update(void);
	19
	20	#endif

include/linux/sfp.h+1−1

@@ -224,7 +224,7 @@ struct sfp_eeprom_ext { · 223 unmodified lines
224	*	224	*
225	* See the SFF-8472 specification and related documents for the definition	225	* See the SFF-8472 specification and related documents for the definition
226	* of these structure members. This can be obtained from	226	* of these structure members. This can be obtained from
227	* ftp://ftp.seagate.com/sff	227	* https://www.snia.org/technology-communities/sff/specifications
228	*/	228	*/
229	struct sfp_eeprom_id {	229	struct sfp_eeprom_id {
230	struct sfp_eeprom_base base;	230	struct sfp_eeprom_base base;

include/linux/skbuff.h+17−1

@@ -1326,6 +1326,22 @@ static inline void skb_zcopy_set(struct sk_buff skb, struct ubuf_info uarg) · 1325 unmodified lines
1326	}	1326	}
1327	}	1327	}
1328		1328
		1329	static inline void skb_zcopy_set_nouarg(struct sk_buff skb, void val)
		1330	{
		1331	skb_shinfo(skb)->destructor_arg = (void *)((uintptr_t) val \| 0x1UL);
		1332	skb_shinfo(skb)->tx_flags \|= SKBTX_ZEROCOPY_FRAG;
		1333	}
		1334
		1335	static inline bool skb_zcopy_is_nouarg(struct sk_buff *skb)
		1336	{
		1337	return (uintptr_t) skb_shinfo(skb)->destructor_arg & 0x1UL;
		1338	}
		1339
		1340	static inline void skb_zcopy_get_nouarg(struct sk_buff skb)
		1341	{
		1342	return (void *)((uintptr_t) skb_shinfo(skb)->destructor_arg & ~0x1UL);
		1343	}
		1344
1329	/* Release a reference on a zerocopy structure */	1345	/* Release a reference on a zerocopy structure */
1330	static inline void skb_zcopy_clear(struct sk_buff *skb, bool zerocopy)	1346	static inline void skb_zcopy_clear(struct sk_buff *skb, bool zerocopy)
1331	{	1347	{
@@ -1335,7 +1351,7 @@ static inline void skb_zcopy_clear(struct sk_buff *skb, bool zerocopy) · 3 unmodified lines
1335	if (uarg->callback == sock_zerocopy_callback) {	1351	if (uarg->callback == sock_zerocopy_callback) {
1336	uarg->zerocopy = uarg->zerocopy && zerocopy;	1352	uarg->zerocopy = uarg->zerocopy && zerocopy;
1337	sock_zerocopy_put(uarg);	1353	sock_zerocopy_put(uarg);
1338	} else {	1354	} else if (!skb_zcopy_is_nouarg(skb)) {
1339	uarg->callback(uarg, zerocopy);	1355	uarg->callback(uarg, zerocopy);
1340	}	1356	}
1341		1357

include/linux/stackleak.h+35−0

@@ -0,0 +1,35 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef _LINUX_STACKLEAK_H
	3	#define _LINUX_STACKLEAK_H
	4
	5	#include <linux/sched.h>
	6	#include <linux/sched/task_stack.h>
	7
	8	/*
	9	* Check that the poison value points to the unused hole in the
	10	* virtual memory map for your platform.
	11	*/
	12	#define STACKLEAK_POISON -0xBEEF
	13	#define STACKLEAK_SEARCH_DEPTH 128
	14
	15	#ifdef CONFIG_GCC_PLUGIN_STACKLEAK
	16	#include <asm/stacktrace.h>
	17
	18	static inline void stackleak_task_init(struct task_struct *t)
	19	{
	20	t->lowest_stack = (unsigned long)end_of_stack(t) + sizeof(unsigned long);
	21	# ifdef CONFIG_STACKLEAK_METRICS
	22	t->prev_lowest_stack = t->lowest_stack;
	23	# endif
	24	}
	25
	26	#ifdef CONFIG_STACKLEAK_RUNTIME_DISABLE
	27	int stack_erasing_sysctl(struct ctl_table *table, int write,
	28	void __user buffer, size_t lenp, loff_t *ppos);
	29	#endif
	30
	31	#else /* !CONFIG_GCC_PLUGIN_STACKLEAK */
	32	static inline void stackleak_task_init(struct task_struct *t) { }
	33	#endif
	34
	35	#endif

include/linux/sunrpc/gss_krb5.h+2−5

 	u8			Ksess[GSS_KRB5_MAX_KEYLEN]; /* session key */
 	u8			cksum[GSS_KRB5_MAX_KEYLEN];
 	s32			endtime;
-	u32			seq_send;
+	atomic_t		seq_send;
-	u64			seq_send64;
+	atomic64_t		seq_send64;
 	struct xdr_netobj	mech_used;
 	u8			initiator_sign[GSS_KRB5_MAX_KEYLEN];
 	u8			acceptor_sign[GSS_KRB5_MAX_KEYLEN];
 	u8			acceptor_integ[GSS_KRB5_MAX_KEYLEN];
 };
-extern u32 gss_seq_send_fetch_and_inc(struct krb5_ctx *ctx);
-extern u64 gss_seq_send64_fetch_and_inc(struct krb5_ctx *ctx);
 /* The length of the Kerberos GSS token header */
 #define GSS_KRB5_TOK_HDR_LEN	(16)

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

@@ -72,7 +72,6 @@ xdr_buf_init(struct xdr_buf buf, void start, size_t len) · 71 unmodified lines
72	buf->head[0].iov_base = start;	72	buf->head[0].iov_base = start;
73	buf->head[0].iov_len = len;	73	buf->head[0].iov_len = len;
74	buf->tail[0].iov_len = 0;	74	buf->tail[0].iov_len = 0;
75	buf->bvec = NULL;
76	buf->pages = NULL;	75	buf->pages = NULL;
77	buf->page_len = 0;	76	buf->page_len = 0;
78	buf->flags = 0;	77	buf->flags = 0;

include/linux/tcp.h+1−0

@@ -196,6 +196,7 @@ struct tcp_sock { · 195 unmodified lines
196	u32 rcv_tstamp; /* timestamp of last received ACK (for keepalives) */	196	u32 rcv_tstamp; /* timestamp of last received ACK (for keepalives) */
197	u32 lsndtime; /* timestamp of last sent data packet (for restart window) */	197	u32 lsndtime; /* timestamp of last sent data packet (for restart window) */
198	u32 last_oow_ack_time; /* timestamp of last out-of-window ACK */	198	u32 last_oow_ack_time; /* timestamp of last out-of-window ACK */
		199	u32 compressed_ack_rcv_nxt;
199		200
200	u32 tsoffset; /* timestamp offset */	201	u32 tsoffset; /* timestamp offset */
201		202

include/linux/tracehook.h+2−2

@@ -83,8 +83,8 @@ static inline int ptrace_report_syscall(struct pt_regs *regs) · 82 unmodified lines
83	* tracehook_report_syscall_entry - task is about to attempt a system call	83	* tracehook_report_syscall_entry - task is about to attempt a system call
84	* @regs: user register state of current task	84	* @regs: user register state of current task
85	*	85	*
86	* This will be called if %TIF_SYSCALL_TRACE has been set, when the	86	* This will be called if %TIF_SYSCALL_TRACE or %TIF_SYSCALL_EMU have been set,
87	* current task has just entered the kernel for a system call.	87	* when the current task has just entered the kernel for a system call.
88	* Full user register state is available here. Changing the values	88	* Full user register state is available here. Changing the values
89	* in @regs can affect the system call number and arguments to be tried.	89	* in @regs can affect the system call number and arguments to be tried.
90	* It is safe to block here, preventing the system call from beginning.	90	* It is safe to block here, preventing the system call from beginning.

include/linux/tracepoint.h+3−3

@@ -166,7 +166,7 @@ static inline struct tracepoint tracepoint_ptr_deref(tracepoint_ptr_t p) · 165 unmodified lines
166	struct tracepoint_func *it_func_ptr; \	166	struct tracepoint_func *it_func_ptr; \
167	void *it_func; \	167	void *it_func; \
168	void *__data; \	168	void *__data; \
169	int __maybe_unused idx = 0; \	169	int __maybe_unused __idx = 0; \
170	\	170	\
171	if (!(cond)) \	171	if (!(cond)) \
172	return; \	172	return; \
@@ -182,7 +182,7 @@ static inline struct tracepoint tracepoint_ptr_deref(tracepoint_ptr_t p) · 9 unmodified lines
182	* doesn't work from the idle path. \	182	* doesn't work from the idle path. \
183	*/ \	183	*/ \
184	if (rcuidle) { \	184	if (rcuidle) { \
185	idx = srcu_read_lock_notrace(&tracepoint_srcu); \	185	__idx = srcu_read_lock_notrace(&tracepoint_srcu);\
186	rcu_irq_enter_irqson(); \	186	rcu_irq_enter_irqson(); \
187	} \	187	} \
188	\	188	\
@@ -198,7 +198,7 @@ static inline struct tracepoint tracepoint_ptr_deref(tracepoint_ptr_t p) · 9 unmodified lines
198	\	198	\
199	if (rcuidle) { \	199	if (rcuidle) { \
200	rcu_irq_exit_irqson(); \	200	rcu_irq_exit_irqson(); \
201	srcu_read_unlock_notrace(&tracepoint_srcu, idx);\	201	srcu_read_unlock_notrace(&tracepoint_srcu, __idx);\
202	} \	202	} \
203	\	203	\
204	preempt_enable_notrace(); \	204	preempt_enable_notrace(); \

include/linux/tty.h+1−0

@@ -556,6 +556,7 @@ extern struct tty_struct tty_init_dev(struct tty_driver driver, int idx); · 555 unmodified lines
556	extern void tty_release_struct(struct tty_struct *tty, int idx);	556	extern void tty_release_struct(struct tty_struct *tty, int idx);
557	extern int tty_release(struct inode inode, struct file filp);	557	extern int tty_release(struct inode inode, struct file filp);
558	extern void tty_init_termios(struct tty_struct *tty);	558	extern void tty_init_termios(struct tty_struct *tty);
		559	extern void tty_save_termios(struct tty_struct *tty);
559	extern int tty_standard_install(struct tty_driver *driver,	560	extern int tty_standard_install(struct tty_driver *driver,
560	struct tty_struct *tty);	561	struct tty_struct *tty);
561		562

include/linux/uio.h+45−20

 	size_t iov_len;
 };
-enum {
+enum iter_type {
 	ITER_IOVEC = 0,
 	ITER_KVEC = 2,
 	ITER_BVEC = 4,
 	ITER_PIPE = 8,
+	ITER_DISCARD = 16,
 };
 struct iov_iter {
-	int type;
+	unsigned int type;
 	size_t iov_offset;
 	size_t count;
 	union {
 	};
 };
+static inline enum iter_type iov_iter_type(const struct iov_iter *i)
+{
+	return i->type & ~(READ | WRITE);
+}
+static inline bool iter_is_iovec(const struct iov_iter *i)
+{
+	return iov_iter_type(i) == ITER_IOVEC;
+}
+static inline bool iov_iter_is_kvec(const struct iov_iter *i)
+{
+	return iov_iter_type(i) == ITER_KVEC;
+}
+static inline bool iov_iter_is_bvec(const struct iov_iter *i)
+{
+	return iov_iter_type(i) == ITER_BVEC;
+}
+static inline bool iov_iter_is_pipe(const struct iov_iter *i)
+{
+	return iov_iter_type(i) == ITER_PIPE;
+}
+static inline bool iov_iter_is_discard(const struct iov_iter *i)
+{
+	return iov_iter_type(i) == ITER_DISCARD;
+}
+static inline unsigned char iov_iter_rw(const struct iov_iter *i)
+{
+	return i->type & (READ | WRITE);
+}
 /*
  * Total number of bytes covered by an iovec.
  *
 }
 #define iov_for_each(iov, iter, start)				\
-	if (!((start).type & (ITER_BVEC | ITER_PIPE)))		\
+	if (iov_iter_type(start) == ITER_IOVEC ||		\
+	    iov_iter_type(start) == ITER_KVEC)			\
 	for (iter = (start);					\
 	     (iter).count &&					\
 	     ((iov = iov_iter_iovec(&(iter))), 1);		\
 size_t iov_iter_zero(size_t bytes, struct iov_iter *);
 unsigned long iov_iter_alignment(const struct iov_iter *i);
 unsigned long iov_iter_gap_alignment(const struct iov_iter *i);
-void iov_iter_init(struct iov_iter *i, int direction, const struct iovec *iov,
+void iov_iter_init(struct iov_iter *i, unsigned int direction, const struct iovec *iov,
 			unsigned long nr_segs, size_t count);
-void iov_iter_kvec(struct iov_iter *i, int direction, const struct kvec *kvec,
+void iov_iter_kvec(struct iov_iter *i, unsigned int direction, const struct kvec *kvec,
 			unsigned long nr_segs, size_t count);
-void iov_iter_bvec(struct iov_iter *i, int direction, const struct bio_vec *bvec,
+void iov_iter_bvec(struct iov_iter *i, unsigned int direction, const struct bio_vec *bvec,
 			unsigned long nr_segs, size_t count);
-void iov_iter_pipe(struct iov_iter *i, int direction, struct pipe_inode_info *pipe,
+void iov_iter_pipe(struct iov_iter *i, unsigned int direction, struct pipe_inode_info *pipe,
 			size_t count);
+void iov_iter_discard(struct iov_iter *i, unsigned int direction, size_t count);
 ssize_t iov_iter_get_pages(struct iov_iter *i, struct page **pages,
 			size_t maxsize, unsigned maxpages, size_t *start);
 ssize_t iov_iter_get_pages_alloc(struct iov_iter *i, struct page ***pages,
 	return i->count;
 }
-static inline bool iter_is_iovec(const struct iov_iter *i)
-{
-	return !(i->type & (ITER_BVEC | ITER_KVEC | ITER_PIPE));
-}
-/*
- * Get one of READ or WRITE out of iter->type without any other flags OR'd in
- * with it.
- *
- * The ?: is just for type safety.
- */
-#define iov_iter_rw(i) ((0 ? (struct iov_iter *)0 : (i))->type & (READ | WRITE))
 /*
  * Cap the iov_iter by given limit; note that the second argument is
  * *not* the new size - it's upper limit for such.  Passing it a value

include/linux/usb.h+2−2

@@ -407,11 +407,11 @@ struct usb_host_bos { · 406 unmodified lines
407	};	407	};
408		408
409	int __usb_get_extra_descriptor(char *buffer, unsigned size,	409	int __usb_get_extra_descriptor(char *buffer, unsigned size,
410	unsigned char type, void **ptr);	410	unsigned char type, void **ptr, size_t min);
411	#define usb_get_extra_descriptor(ifpoint, type, ptr) \	411	#define usb_get_extra_descriptor(ifpoint, type, ptr) \
412	__usb_get_extra_descriptor((ifpoint)->extra, \	412	__usb_get_extra_descriptor((ifpoint)->extra, \
413	(ifpoint)->extralen, \	413	(ifpoint)->extralen, \
414	type, (void **)ptr)	414	type, (void )ptr, sizeof((ptr)))
415		415
416	/* ----------------------------------------------------------------------- */	416	/* ----------------------------------------------------------------------- */
417		417

include/linux/usb/quirks.h+3−0

@@ -66,4 +66,7 @@ · 65 unmodified lines
66	/* Device needs a pause after every control message. */	66	/* Device needs a pause after every control message. */
67	#define USB_QUIRK_DELAY_CTRL_MSG BIT(13)	67	#define USB_QUIRK_DELAY_CTRL_MSG BIT(13)
68		68
		69	/* Hub needs extra delay after resetting its port. */
		70	#define USB_QUIRK_HUB_SLOW_RESET BIT(14)
		71
69	#endif /* __LINUX_USB_QUIRKS_H */	72	#endif /* __LINUX_USB_QUIRKS_H */

include/linux/writeback.h+2−3

  *
  * @bio is a part of the writeback in progress controlled by @wbc.  Perform
  * writeback specific initialization.  This is used to apply the cgroup
- * writeback context.  Must be called after the bio has been associated with
+ * writeback context.
- * a device.
  */
 static inline void wbc_init_bio(struct writeback_control *wbc, struct bio *bio)
 {
 	 * regular writeback instead of writing things out itself.
 	 */
 	if (wbc->wb)
-		bio_associate_blkg_from_css(bio, wbc->wb->blkcg_css);
+		bio_associate_blkcg(bio, wbc->wb->blkcg_css);
 }
 #else	/* CONFIG_CGROUP_WRITEBACK */

include/linux/xarray.h+203−64

@@ -289,9 +289,7 @@ struct xarray { · 288 unmodified lines
289	void xa_init_flags(struct xarray *, gfp_t flags);	289	void xa_init_flags(struct xarray *, gfp_t flags);
290	void xa_load(struct xarray , unsigned long index);	290	void xa_load(struct xarray , unsigned long index);
291	void xa_store(struct xarray , unsigned long index, void *entry, gfp_t);	291	void xa_store(struct xarray , unsigned long index, void *entry, gfp_t);
292	void xa_cmpxchg(struct xarray , unsigned long index,	292	void xa_erase(struct xarray , unsigned long index);
293	void old, void entry, gfp_t);
294	int xa_reserve(struct xarray *, unsigned long index, gfp_t);
295	void xa_store_range(struct xarray , unsigned long first, unsigned long last,	293	void xa_store_range(struct xarray , unsigned long first, unsigned long last,
296	void *entry, gfp_t);	294	void *entry, gfp_t);
297	bool xa_get_mark(struct xarray *, unsigned long index, xa_mark_t);	295	bool xa_get_mark(struct xarray *, unsigned long index, xa_mark_t);
@@ -343,65 +341,6 @@ static inline bool xa_marked(const struct xarray *xa, xa_mark_t mark) · 45 unmodified lines
343	return xa->xa_flags & XA_FLAGS_MARK(mark);	341	return xa->xa_flags & XA_FLAGS_MARK(mark);
344	}	342	}
345		343
346	/**
347	* xa_erase() - Erase this entry from the XArray.
348	* @xa: XArray.
349	* @index: Index of entry.
350	*
351	* This function is the equivalent of calling xa_store() with %NULL as
352	* the third argument. The XArray does not need to allocate memory, so
353	* the user does not need to provide GFP flags.
354	*
355	* Context: Process context. Takes and releases the xa_lock.
356	* Return: The entry which used to be at this index.
357	*/
358	static inline void xa_erase(struct xarray xa, unsigned long index)
359	{
360	return xa_store(xa, index, NULL, 0);
361	}
362
363	/**
364	* xa_insert() - Store this entry in the XArray unless another entry is
365	* already present.
366	* @xa: XArray.
367	* @index: Index into array.
368	* @entry: New entry.
369	* @gfp: Memory allocation flags.
370	*
371	* If you would rather see the existing entry in the array, use xa_cmpxchg().
372	* This function is for users who don't care what the entry is, only that
373	* one is present.
374	*
375	* Context: Process context. Takes and releases the xa_lock.
376	* May sleep if the @gfp flags permit.
377	* Return: 0 if the store succeeded. -EEXIST if another entry was present.
378	* -ENOMEM if memory could not be allocated.
379	*/
380	static inline int xa_insert(struct xarray *xa, unsigned long index,
381	void *entry, gfp_t gfp)
382	{
383	void *curr = xa_cmpxchg(xa, index, NULL, entry, gfp);
384	if (!curr)
385	return 0;
386	if (xa_is_err(curr))
387	return xa_err(curr);
388	return -EEXIST;
389	}
390
391	/**
392	* xa_release() - Release a reserved entry.
393	* @xa: XArray.
394	* @index: Index of entry.
395	*
396	* After calling xa_reserve(), you can call this function to release the
397	* reservation. If the entry at @index has been stored to, this function
398	* will do nothing.
399	*/
400	static inline void xa_release(struct xarray *xa, unsigned long index)
401	{
402	xa_cmpxchg(xa, index, NULL, NULL, 0);
403	}
404
405	/**	344	/**
406	* xa_for_each() - Iterate over a portion of an XArray.	345	* xa_for_each() - Iterate over a portion of an XArray.
407	* @xa: XArray.	346	* @xa: XArray.
@@ -455,6 +394,7 @@ void __xa_store(struct xarray , unsigned long index, void *entry, gfp_t); · 47 unmodified lines
455	void __xa_cmpxchg(struct xarray , unsigned long index, void *old,	394	void __xa_cmpxchg(struct xarray , unsigned long index, void *old,
456	void *entry, gfp_t);	395	void *entry, gfp_t);
457	int __xa_alloc(struct xarray , u32 id, u32 max, void *entry, gfp_t);	396	int __xa_alloc(struct xarray , u32 id, u32 max, void *entry, gfp_t);
		397	int __xa_reserve(struct xarray *, unsigned long index, gfp_t);
458	void __xa_set_mark(struct xarray *, unsigned long index, xa_mark_t);	398	void __xa_set_mark(struct xarray *, unsigned long index, xa_mark_t);
459	void __xa_clear_mark(struct xarray *, unsigned long index, xa_mark_t);	399	void __xa_clear_mark(struct xarray *, unsigned long index, xa_mark_t);
460		400
@@ -486,6 +426,58 @@ static inline int __xa_insert(struct xarray *xa, unsigned long index, · 25 unmodified lines
486	return -EEXIST;	426	return -EEXIST;
487	}	427	}
488		428
		429	/**
		430	* xa_store_bh() - Store this entry in the XArray.
		431	* @xa: XArray.
		432	* @index: Index into array.
		433	* @entry: New entry.
		434	* @gfp: Memory allocation flags.
		435	*
		436	* This function is like calling xa_store() except it disables softirqs
		437	* while holding the array lock.
		438	*
		439	* Context: Any context. Takes and releases the xa_lock while
		440	* disabling softirqs.
		441	* Return: The entry which used to be at this index.
		442	*/
		443	static inline void xa_store_bh(struct xarray xa, unsigned long index,
		444	void *entry, gfp_t gfp)
		445	{
		446	void *curr;
		447
		448	xa_lock_bh(xa);
		449	curr = __xa_store(xa, index, entry, gfp);
		450	xa_unlock_bh(xa);
		451
		452	return curr;
		453	}
		454
		455	/**
		456	* xa_store_irq() - Erase this entry from the XArray.
		457	* @xa: XArray.
		458	* @index: Index into array.
		459	* @entry: New entry.
		460	* @gfp: Memory allocation flags.
		461	*
		462	* This function is like calling xa_store() except it disables interrupts
		463	* while holding the array lock.
		464	*
		465	* Context: Process context. Takes and releases the xa_lock while
		466	* disabling interrupts.
		467	* Return: The entry which used to be at this index.
		468	*/
		469	static inline void xa_store_irq(struct xarray xa, unsigned long index,
		470	void *entry, gfp_t gfp)
		471	{
		472	void *curr;
		473
		474	xa_lock_irq(xa);
		475	curr = __xa_store(xa, index, entry, gfp);
		476	xa_unlock_irq(xa);
		477
		478	return curr;
		479	}
		480
489	/**	481	/**
490	* xa_erase_bh() - Erase this entry from the XArray.	482	* xa_erase_bh() - Erase this entry from the XArray.
491	* @xa: XArray.	483	* @xa: XArray.
@@ -495,7 +487,7 @@ static inline int __xa_insert(struct xarray *xa, unsigned long index, · 3 unmodified lines
495	* the third argument. The XArray does not need to allocate memory, so	487	* the third argument. The XArray does not need to allocate memory, so
496	* the user does not need to provide GFP flags.	488	* the user does not need to provide GFP flags.
497	*	489	*
498	* Context: Process context. Takes and releases the xa_lock while	490	* Context: Any context. Takes and releases the xa_lock while
499	* disabling softirqs.	491	* disabling softirqs.
500	* Return: The entry which used to be at this index.	492	* Return: The entry which used to be at this index.
501	*/	493	*/
@@ -534,6 +526,61 @@ static inline void xa_erase_irq(struct xarray xa, unsigned long index) · 32 unmodified lines
534	return entry;	526	return entry;
535	}	527	}
536		528
		529	/**
		530	* xa_cmpxchg() - Conditionally replace an entry in the XArray.
		531	* @xa: XArray.
		532	* @index: Index into array.
		533	* @old: Old value to test against.
		534	* @entry: New value to place in array.
		535	* @gfp: Memory allocation flags.
		536	*
		537	* If the entry at @index is the same as @old, replace it with @entry.
		538	* If the return value is equal to @old, then the exchange was successful.
		539	*
		540	* Context: Any context. Takes and releases the xa_lock. May sleep
		541	* if the @gfp flags permit.
		542	* Return: The old value at this index or xa_err() if an error happened.
		543	*/
		544	static inline void xa_cmpxchg(struct xarray xa, unsigned long index,
		545	void old, void entry, gfp_t gfp)
		546	{
		547	void *curr;
		548
		549	xa_lock(xa);
		550	curr = __xa_cmpxchg(xa, index, old, entry, gfp);
		551	xa_unlock(xa);
		552
		553	return curr;
		554	}
		555
		556	/**
		557	* xa_insert() - Store this entry in the XArray unless another entry is
		558	* already present.
		559	* @xa: XArray.
		560	* @index: Index into array.
		561	* @entry: New entry.
		562	* @gfp: Memory allocation flags.
		563	*
		564	* If you would rather see the existing entry in the array, use xa_cmpxchg().
		565	* This function is for users who don't care what the entry is, only that
		566	* one is present.
		567	*
		568	* Context: Process context. Takes and releases the xa_lock.
		569	* May sleep if the @gfp flags permit.
		570	* Return: 0 if the store succeeded. -EEXIST if another entry was present.
		571	* -ENOMEM if memory could not be allocated.
		572	*/
		573	static inline int xa_insert(struct xarray *xa, unsigned long index,
		574	void *entry, gfp_t gfp)
		575	{
		576	void *curr = xa_cmpxchg(xa, index, NULL, entry, gfp);
		577	if (!curr)
		578	return 0;
		579	if (xa_is_err(curr))
		580	return xa_err(curr);
		581	return -EEXIST;
		582	}
		583
537	/**	584	/**
538	* xa_alloc() - Find somewhere to store this entry in the XArray.	585	* xa_alloc() - Find somewhere to store this entry in the XArray.
539	* @xa: XArray.	586	* @xa: XArray.
@@ -575,7 +622,7 @@ static inline int xa_alloc(struct xarray xa, u32 id, u32 max, void *entry, · 35 unmodified lines
575	* Updates the @id pointer with the index, then stores the entry at that	622	* Updates the @id pointer with the index, then stores the entry at that
576	* index. A concurrent lookup will not see an uninitialised @id.	623	* index. A concurrent lookup will not see an uninitialised @id.
577	*	624	*
578	* Context: Process context. Takes and releases the xa_lock while	625	* Context: Any context. Takes and releases the xa_lock while
579	* disabling softirqs. May sleep if the @gfp flags permit.	626	* disabling softirqs. May sleep if the @gfp flags permit.
580	* Return: 0 on success, -ENOMEM if memory allocation fails or -ENOSPC if	627	* Return: 0 on success, -ENOMEM if memory allocation fails or -ENOSPC if
581	* there is no more space in the XArray.	628	* there is no more space in the XArray.
@@ -621,6 +668,98 @@ static inline int xa_alloc_irq(struct xarray xa, u32 id, u32 max, void *entry, · 39 unmodified lines
621	return err;	668	return err;
622	}	669	}
623		670
		671	/**
		672	* xa_reserve() - Reserve this index in the XArray.
		673	* @xa: XArray.
		674	* @index: Index into array.
		675	* @gfp: Memory allocation flags.
		676	*
		677	* Ensures there is somewhere to store an entry at @index in the array.
		678	* If there is already something stored at @index, this function does
		679	* nothing. If there was nothing there, the entry is marked as reserved.
		680	* Loading from a reserved entry returns a %NULL pointer.
		681	*
		682	* If you do not use the entry that you have reserved, call xa_release()
		683	* or xa_erase() to free any unnecessary memory.
		684	*
		685	* Context: Any context. Takes and releases the xa_lock.
		686	* May sleep if the @gfp flags permit.
		687	* Return: 0 if the reservation succeeded or -ENOMEM if it failed.
		688	*/
		689	static inline
		690	int xa_reserve(struct xarray *xa, unsigned long index, gfp_t gfp)
		691	{
		692	int ret;
		693
		694	xa_lock(xa);
		695	ret = __xa_reserve(xa, index, gfp);
		696	xa_unlock(xa);
		697
		698	return ret;
		699	}
		700
		701	/**
		702	* xa_reserve_bh() - Reserve this index in the XArray.
		703	* @xa: XArray.
		704	* @index: Index into array.
		705	* @gfp: Memory allocation flags.
		706	*
		707	* A softirq-disabling version of xa_reserve().
		708	*
		709	* Context: Any context. Takes and releases the xa_lock while
		710	* disabling softirqs.
		711	* Return: 0 if the reservation succeeded or -ENOMEM if it failed.
		712	*/
		713	static inline
		714	int xa_reserve_bh(struct xarray *xa, unsigned long index, gfp_t gfp)
		715	{
		716	int ret;
		717
		718	xa_lock_bh(xa);
		719	ret = __xa_reserve(xa, index, gfp);
		720	xa_unlock_bh(xa);
		721
		722	return ret;
		723	}
		724
		725	/**
		726	* xa_reserve_irq() - Reserve this index in the XArray.
		727	* @xa: XArray.
		728	* @index: Index into array.
		729	* @gfp: Memory allocation flags.
		730	*
		731	* An interrupt-disabling version of xa_reserve().
		732	*
		733	* Context: Process context. Takes and releases the xa_lock while
		734	* disabling interrupts.
		735	* Return: 0 if the reservation succeeded or -ENOMEM if it failed.
		736	*/
		737	static inline
		738	int xa_reserve_irq(struct xarray *xa, unsigned long index, gfp_t gfp)
		739	{
		740	int ret;
		741
		742	xa_lock_irq(xa);
		743	ret = __xa_reserve(xa, index, gfp);
		744	xa_unlock_irq(xa);
		745
		746	return ret;
		747	}
		748
		749	/**
		750	* xa_release() - Release a reserved entry.
		751	* @xa: XArray.
		752	* @index: Index of entry.
		753	*
		754	* After calling xa_reserve(), you can call this function to release the
		755	* reservation. If the entry at @index has been stored to, this function
		756	* will do nothing.
		757	*/
		758	static inline void xa_release(struct xarray *xa, unsigned long index)
		759	{
		760	xa_cmpxchg(xa, index, NULL, NULL, 0);
		761	}
		762
624	/* Everything below here is the Advanced API. Proceed with caution. */	763	/* Everything below here is the Advanced API. Proceed with caution. */
625		764
626	/*	765	/*

@@ -511,14 +511,14 @@ alloc_pages(gfp_t gfp_mask, unsigned int order) · 510 unmodified lines
511	extern struct page *alloc_pages_vma(gfp_t gfp_mask, int order,	511	extern struct page *alloc_pages_vma(gfp_t gfp_mask, int order,
512	struct vm_area_struct *vma, unsigned long addr,	512	struct vm_area_struct *vma, unsigned long addr,
513	int node, bool hugepage);	513	int node, bool hugepage);
514	#define alloc_hugepage_vma(gfp_mask, vma, addr, order) \	514	#define alloc_hugepage_vma(gfp_mask, vma, addr, order) \
515	alloc_pages_vma(gfp_mask, order, vma, addr, numa_node_id(), true)	515	alloc_pages_vma(gfp_mask, order, vma, addr, numa_node_id(), true)
516	#else	516	#else
517	#define alloc_pages(gfp_mask, order) \	517	#define alloc_pages(gfp_mask, order) \
518	alloc_pages_node(numa_node_id(), gfp_mask, order)	518	alloc_pages_node(numa_node_id(), gfp_mask, order)
519	#define alloc_pages_vma(gfp_mask, order, vma, addr, node, false)\	519	#define alloc_pages_vma(gfp_mask, order, vma, addr, node, false)\
520	alloc_pages(gfp_mask, order)	520	alloc_pages(gfp_mask, order)
521	#define alloc_hugepage_vma(gfp_mask, vma, addr, order) \	521	#define alloc_hugepage_vma(gfp_mask, vma, addr, order) \
522	alloc_pages(gfp_mask, order)	522	alloc_pages(gfp_mask, order)
523	#endif	523	#endif
524	#define alloc_page(gfp_mask) alloc_pages(gfp_mask, 0)	524	#define alloc_page(gfp_mask) alloc_pages(gfp_mask, 0)