lael-labs/linux

include/linux/acpi.h+8−0

@@ -678,6 +678,14 @@ static inline bool acpi_dev_present(const char hid, const char uid, s64 hrv) · 677 unmodified lines
678	return false;	678	return false;
679	}	679	}
680		680
		681	struct acpi_device;
		682
		683	static inline bool
		684	acpi_dev_hid_uid_match(struct acpi_device adev, const char hid2, const char *uid2)
		685	{
		686	return false;
		687	}
		688
681	static inline struct acpi_device *	689	static inline struct acpi_device *
682	acpi_dev_get_first_match_dev(const char hid, const char uid, s64 hrv)	690	acpi_dev_get_first_match_dev(const char hid, const char uid, s64 hrv)
683	{	691	{

include/linux/aer.h+4−0

 int pci_disable_pcie_error_reporting(struct pci_dev *dev);
 int pci_cleanup_aer_uncorrect_error_status(struct pci_dev *dev);
 int pci_cleanup_aer_error_status_regs(struct pci_dev *dev);
+void pci_save_aer_state(struct pci_dev *dev);
+void pci_restore_aer_state(struct pci_dev *dev);
 #else
 static inline int pci_enable_pcie_error_reporting(struct pci_dev *dev)
 {
 {
 	return -EINVAL;
 }
+static inline void pci_save_aer_state(struct pci_dev *dev) {}
+static inline void pci_restore_aer_state(struct pci_dev *dev) {}
 #endif
 void cper_print_aer(struct pci_dev *dev, int aer_severity,

include/linux/agpgart.h+0−2

@@ -30,8 +30,6 @@ · 29 unmodified lines
30	#include <linux/agp_backend.h>	30	#include <linux/agp_backend.h>
31	#include <uapi/linux/agpgart.h>	31	#include <uapi/linux/agpgart.h>
32		32
33	#define AGPGART_MINOR 175
34
35	struct agp_info {	33	struct agp_info {
36	struct agp_version version; /* version of the driver */	34	struct agp_version version; /* version of the driver */
37	u32 bridge_id; /* bridge vendor/device */	35	u32 bridge_id; /* bridge vendor/device */

include/linux/ahci_platform.h+2−0

@@ -19,6 +19,8 @@ struct ahci_host_priv; · 18 unmodified lines
19	struct platform_device;	19	struct platform_device;
20	struct scsi_host_template;	20	struct scsi_host_template;
21		21
		22	int ahci_platform_enable_phys(struct ahci_host_priv *hpriv);
		23	void ahci_platform_disable_phys(struct ahci_host_priv *hpriv);
22	int ahci_platform_enable_clks(struct ahci_host_priv *hpriv);	24	int ahci_platform_enable_clks(struct ahci_host_priv *hpriv);
23	void ahci_platform_disable_clks(struct ahci_host_priv *hpriv);	25	void ahci_platform_disable_clks(struct ahci_host_priv *hpriv);
24	int ahci_platform_enable_regulators(struct ahci_host_priv *hpriv);	26	int ahci_platform_enable_regulators(struct ahci_host_priv *hpriv);

include/linux/arch_topology.h+1−0

@@ -57,6 +57,7 @@ const struct cpumask *cpu_coregroup_mask(int cpu); · 56 unmodified lines
57	void update_siblings_masks(unsigned int cpu);	57	void update_siblings_masks(unsigned int cpu);
58	void remove_cpu_topology(unsigned int cpuid);	58	void remove_cpu_topology(unsigned int cpuid);
59	void reset_cpu_topology(void);	59	void reset_cpu_topology(void);
		60	int parse_acpi_topology(void);
60	#endif	61	#endif
61		62
62	#endif /* _LINUX_ARCH_TOPOLOGY_H_ */	63	#endif /* _LINUX_ARCH_TOPOLOGY_H_ */

include/linux/arm-smccc.h+75−0

@@ -45,6 +45,7 @@ · 44 unmodified lines
45	#define ARM_SMCCC_OWNER_SIP 2	45	#define ARM_SMCCC_OWNER_SIP 2
46	#define ARM_SMCCC_OWNER_OEM 3	46	#define ARM_SMCCC_OWNER_OEM 3
47	#define ARM_SMCCC_OWNER_STANDARD 4	47	#define ARM_SMCCC_OWNER_STANDARD 4
		48	#define ARM_SMCCC_OWNER_STANDARD_HYP 5
48	#define ARM_SMCCC_OWNER_TRUSTED_APP 48	49	#define ARM_SMCCC_OWNER_TRUSTED_APP 48
49	#define ARM_SMCCC_OWNER_TRUSTED_APP_END 49	50	#define ARM_SMCCC_OWNER_TRUSTED_APP_END 49
50	#define ARM_SMCCC_OWNER_TRUSTED_OS 50	51	#define ARM_SMCCC_OWNER_TRUSTED_OS 50
@@ -80,6 +81,22 @@ · 29 unmodified lines
80		81
81	#include <linux/linkage.h>	82	#include <linux/linkage.h>
82	#include <linux/types.h>	83	#include <linux/types.h>
		84
		85	enum arm_smccc_conduit {
		86	SMCCC_CONDUIT_NONE,
		87	SMCCC_CONDUIT_SMC,
		88	SMCCC_CONDUIT_HVC,
		89	};
		90
		91	/**
		92	* arm_smccc_1_1_get_conduit()
		93	*
		94	* Returns the conduit to be used for SMCCCv1.1 or later.
		95	*
		96	* When SMCCCv1.1 is not present, returns SMCCC_CONDUIT_NONE.
		97	*/
		98	enum arm_smccc_conduit arm_smccc_1_1_get_conduit(void);
		99
83	/**	100	/**
84	* struct arm_smccc_res - Result from SMC/HVC call	101	* struct arm_smccc_res - Result from SMC/HVC call
85	* @a0-a3 result values from registers 0 to 3	102	* @a0-a3 result values from registers 0 to 3
@@ -302,5 +319,63 @@ asmlinkage void __arm_smccc_hvc(unsigned long a0, unsigned long a1, · 216 unmodified lines
302	#define SMCCC_RET_NOT_SUPPORTED -1	319	#define SMCCC_RET_NOT_SUPPORTED -1
303	#define SMCCC_RET_NOT_REQUIRED -2	320	#define SMCCC_RET_NOT_REQUIRED -2
304		321
		322	/*
		323	* Like arm_smccc_1_1* but always returns SMCCC_RET_NOT_SUPPORTED.
		324	* Used when the SMCCC conduit is not defined. The empty asm statement
		325	* avoids compiler warnings about unused variables.
		326	*/
		327	#define __fail_smccc_1_1(...) \
		328	do { \
		329	__declare_args(__count_args(__VA_ARGS__), __VA_ARGS__); \
		330	asm ("" __constraints(__count_args(__VA_ARGS__))); \
		331	if (___res) \
		332	___res->a0 = SMCCC_RET_NOT_SUPPORTED; \
		333	} while (0)
		334
		335	/*
		336	* arm_smccc_1_1_invoke() - make an SMCCC v1.1 compliant call
		337	*
		338	* This is a variadic macro taking one to eight source arguments, and
		339	* an optional return structure.
		340	*
		341	* @a0-a7: arguments passed in registers 0 to 7
		342	* @res: result values from registers 0 to 3
		343	*
		344	* This macro will make either an HVC call or an SMC call depending on the
		345	* current SMCCC conduit. If no valid conduit is available then -1
		346	* (SMCCC_RET_NOT_SUPPORTED) is returned in @res.a0 (if supplied).
		347	*
		348	* The return value also provides the conduit that was used.
		349	*/
		350	#define arm_smccc_1_1_invoke(...) ({ \
		351	int method = arm_smccc_1_1_get_conduit(); \
		352	switch (method) { \
		353	case SMCCC_CONDUIT_HVC: \
		354	arm_smccc_1_1_hvc(__VA_ARGS__); \
		355	break; \
		356	case SMCCC_CONDUIT_SMC: \
		357	arm_smccc_1_1_smc(__VA_ARGS__); \
		358	break; \
		359	default: \
		360	__fail_smccc_1_1(__VA_ARGS__); \
		361	method = SMCCC_CONDUIT_NONE; \
		362	break; \
		363	} \
		364	method; \
		365	})
		366
		367	/* Paravirtualised time calls (defined by ARM DEN0057A) */
		368	#define ARM_SMCCC_HV_PV_TIME_FEATURES \
		369	ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, \
		370	ARM_SMCCC_SMC_64, \
		371	ARM_SMCCC_OWNER_STANDARD_HYP, \
		372	0x20)
		373
		374	#define ARM_SMCCC_HV_PV_TIME_ST \
		375	ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, \
		376	ARM_SMCCC_SMC_64, \
		377	ARM_SMCCC_OWNER_STANDARD_HYP, \
		378	0x21)
		379
305	#endif /__ASSEMBLY__/	380	#endif /__ASSEMBLY__/
306	#endif /__LINUX_ARM_SMCCC_H/	381	#endif /__LINUX_ARM_SMCCC_H/

include/linux/arm_sdei.h+0−6

 #include <uapi/linux/arm_sdei.h>
-enum sdei_conduit_types {
-	CONDUIT_INVALID = 0,
-	CONDUIT_SMC,
-	CONDUIT_HVC,
-};
 #include <acpi/ghes.h>
 #ifdef CONFIG_ARM_SDE_INTERFACE

include/linux/audit.h+3−2

 					     const struct path *path);
 extern void		    audit_log_key(struct audit_buffer *ab,
 					  char *key);
-extern void		    audit_log_link_denied(const char *operation);
+extern void		    audit_log_path_denied(int type,
+						  const char *operation);
 extern void		    audit_log_lost(const char *message);
 extern int audit_log_task_context(struct audit_buffer *ab);
 { }
 static inline void audit_log_key(struct audit_buffer *ab, char *key)
 { }
-static inline void audit_log_link_denied(const char *string)
+static inline void audit_log_path_denied(int type, const char *operation)
 { }
 static inline int audit_log_task_context(struct audit_buffer *ab)
 {

include/linux/bitmap.h+51−0

@@ -53,6 +53,7 @@ · 52 unmodified lines
53	* bitmap_find_next_zero_area_off(buf, len, pos, n, mask) as above	53	* bitmap_find_next_zero_area_off(buf, len, pos, n, mask) as above
54	* bitmap_shift_right(dst, src, n, nbits) dst = src >> n	54	* bitmap_shift_right(dst, src, n, nbits) dst = src >> n
55	* bitmap_shift_left(dst, src, n, nbits) dst = src << n	55	* bitmap_shift_left(dst, src, n, nbits) dst = src << n
		56	* bitmap_replace(dst, old, new, mask, nbits) dst = (old & ~(mask)) \| (new & *mask)
56	* bitmap_remap(dst, src, old, new, nbits) *dst = map(old, new)(src)	57	* bitmap_remap(dst, src, old, new, nbits) *dst = map(old, new)(src)
57	* bitmap_bitremap(oldbit, old, new, nbits) newbit = map(old, new)(oldbit)	58	* bitmap_bitremap(oldbit, old, new, nbits) newbit = map(old, new)(oldbit)
58	* bitmap_onto(dst, orig, relmap, nbits) *dst = orig relative to relmap	59	* bitmap_onto(dst, orig, relmap, nbits) *dst = orig relative to relmap
@@ -66,6 +67,8 @@ · 7 unmodified lines
66	* bitmap_allocate_region(bitmap, pos, order) Allocate specified bit region	67	* bitmap_allocate_region(bitmap, pos, order) Allocate specified bit region
67	* bitmap_from_arr32(dst, buf, nbits) Copy nbits from u32[] buf to dst	68	* bitmap_from_arr32(dst, buf, nbits) Copy nbits from u32[] buf to dst
68	* bitmap_to_arr32(buf, src, nbits) Copy nbits from buf to u32[] dst	69	* bitmap_to_arr32(buf, src, nbits) Copy nbits from buf to u32[] dst
		70	* bitmap_get_value8(map, start) Get 8bit value from map at start
		71	* bitmap_set_value8(map, value, start) Set 8bit value to map at start
69	*	72	*
70	* Note, bitmap_zero() and bitmap_fill() operate over the region of	73	* Note, bitmap_zero() and bitmap_fill() operate over the region of
71	* unsigned longs, that is, bits behind bitmap till the unsigned long	74	* unsigned longs, that is, bits behind bitmap till the unsigned long
@@ -138,6 +141,9 @@ extern void __bitmap_xor(unsigned long dst, const unsigned long bitmap1, · 66 unmodified lines
138	const unsigned long *bitmap2, unsigned int nbits);	141	const unsigned long *bitmap2, unsigned int nbits);
139	extern int __bitmap_andnot(unsigned long dst, const unsigned long bitmap1,	142	extern int __bitmap_andnot(unsigned long dst, const unsigned long bitmap1,
140	const unsigned long *bitmap2, unsigned int nbits);	143	const unsigned long *bitmap2, unsigned int nbits);
		144	extern void __bitmap_replace(unsigned long *dst,
		145	const unsigned long old, const unsigned long new,
		146	const unsigned long *mask, unsigned int nbits);
141	extern int __bitmap_intersects(const unsigned long *bitmap1,	147	extern int __bitmap_intersects(const unsigned long *bitmap1,
142	const unsigned long *bitmap2, unsigned int nbits);	148	const unsigned long *bitmap2, unsigned int nbits);
143	extern int __bitmap_subset(const unsigned long *bitmap1,	149	extern int __bitmap_subset(const unsigned long *bitmap1,
@@ -432,6 +438,18 @@ static inline void bitmap_shift_left(unsigned long dst, const unsigned long sr · 288 unmodified lines
432	__bitmap_shift_left(dst, src, shift, nbits);	438	__bitmap_shift_left(dst, src, shift, nbits);
433	}	439	}
434		440
		441	static inline void bitmap_replace(unsigned long *dst,
		442	const unsigned long *old,
		443	const unsigned long *new,
		444	const unsigned long *mask,
		445	unsigned int nbits)
		446	{
		447	if (small_const_nbits(nbits))
		448	dst = (old & ~(mask)) \| (new & *mask);
		449	else
		450	__bitmap_replace(dst, old, new, mask, nbits);
		451	}
		452
435	static inline int bitmap_parse(const char *buf, unsigned int buflen,	453	static inline int bitmap_parse(const char *buf, unsigned int buflen,
436	unsigned long *maskp, int nmaskbits)	454	unsigned long *maskp, int nmaskbits)
437	{	455	{
@@ -489,6 +507,39 @@ static inline void bitmap_from_u64(unsigned long *dst, u64 mask) · 51 unmodified lines
489	dst[1] = mask >> 32;	507	dst[1] = mask >> 32;
490	}	508	}
491		509
		510	/**
		511	* bitmap_get_value8 - get an 8-bit value within a memory region
		512	* @map: address to the bitmap memory region
		513	* @start: bit offset of the 8-bit value; must be a multiple of 8
		514	*
		515	* Returns the 8-bit value located at the @start bit offset within the @src
		516	* memory region.
		517	*/
		518	static inline unsigned long bitmap_get_value8(const unsigned long *map,
		519	unsigned long start)
		520	{
		521	const size_t index = BIT_WORD(start);
		522	const unsigned long offset = start % BITS_PER_LONG;
		523
		524	return (map[index] >> offset) & 0xFF;
		525	}
		526
		527	/**
		528	* bitmap_set_value8 - set an 8-bit value within a memory region
		529	* @map: address to the bitmap memory region
		530	* @value: the 8-bit value; values wider than 8 bits may clobber bitmap
		531	* @start: bit offset of the 8-bit value; must be a multiple of 8
		532	*/
		533	static inline void bitmap_set_value8(unsigned long *map, unsigned long value,
		534	unsigned long start)
		535	{
		536	const size_t index = BIT_WORD(start);
		537	const unsigned long offset = start % BITS_PER_LONG;
		538
		539	map[index] &= ~(0xFFUL << offset);
		540	map[index] \|= value << offset;
		541	}
		542
492	#endif /* __ASSEMBLY__ */	543	#endif /* __ASSEMBLY__ */
493		544
494	#endif /* __LINUX_BITMAP_H */	545	#endif /* __LINUX_BITMAP_H */

include/linux/bitops.h+12−0

@@ -47,6 +47,18 @@ extern unsigned long __sw_hweight64(__u64 w); · 46 unmodified lines
47	(bit) < (size); \	47	(bit) < (size); \
48	(bit) = find_next_zero_bit((addr), (size), (bit) + 1))	48	(bit) = find_next_zero_bit((addr), (size), (bit) + 1))
49		49
		50	/**
		51	* for_each_set_clump8 - iterate over bitmap for each 8-bit clump with set bits
		52	* @start: bit offset to start search and to store the current iteration offset
		53	* @clump: location to store copy of current 8-bit clump
		54	* @bits: bitmap address to base the search on
		55	* @size: bitmap size in number of bits
		56	*/
		57	#define for_each_set_clump8(start, clump, bits, size) \
		58	for ((start) = find_first_clump8(&(clump), (bits), (size)); \
		59	(start) < (size); \
		60	(start) = find_next_clump8(&(clump), (bits), (size), (start) + 8))
		61
50	static inline int get_bitmask_order(unsigned int count)	62	static inline int get_bitmask_order(unsigned int count)
51	{	63	{
52	int order;	64	int order;

include/linux/blk-cgroup.h+37−164

@@ -15,7 +15,9 @@ · 14 unmodified lines
15	*/	15	*/
16		16
17	#include <linux/cgroup.h>	17	#include <linux/cgroup.h>
		18	#include <linux/percpu.h>
18	#include <linux/percpu_counter.h>	19	#include <linux/percpu_counter.h>
		20	#include <linux/u64_stats_sync.h>
19	#include <linux/seq_file.h>	21	#include <linux/seq_file.h>
20	#include <linux/radix-tree.h>	22	#include <linux/radix-tree.h>
21	#include <linux/blkdev.h>	23	#include <linux/blkdev.h>
@@ -31,15 +33,12 @@ · 9 unmodified lines
31		33
32	#ifdef CONFIG_BLK_CGROUP	34	#ifdef CONFIG_BLK_CGROUP
33		35
34	enum blkg_rwstat_type {	36	enum blkg_iostat_type {
35	BLKG_RWSTAT_READ,	37	BLKG_IOSTAT_READ,
36	BLKG_RWSTAT_WRITE,	38	BLKG_IOSTAT_WRITE,
37	BLKG_RWSTAT_SYNC,	39	BLKG_IOSTAT_DISCARD,
38	BLKG_RWSTAT_ASYNC,
39	BLKG_RWSTAT_DISCARD,
40		40
41	BLKG_RWSTAT_NR,	41	BLKG_IOSTAT_NR,
42	BLKG_RWSTAT_TOTAL = BLKG_RWSTAT_NR,
43	};	42	};
44		43
45	struct blkcg_gq;	44	struct blkcg_gq;
@@ -61,17 +60,15 @@ struct blkcg { · 15 unmodified lines
61	#endif	60	#endif
62	};	61	};
63		62
64	/*	63	struct blkg_iostat {
65	* blkg_[rw]stat->aux_cnt is excluded for local stats but included for	64	u64 bytes[BLKG_IOSTAT_NR];
66	* recursive. Used to carry stats of dead children.	65	u64 ios[BLKG_IOSTAT_NR];
67	*/
68	struct blkg_rwstat {
69	struct percpu_counter cpu_cnt[BLKG_RWSTAT_NR];
70	atomic64_t aux_cnt[BLKG_RWSTAT_NR];
71	};	66	};
72		67
73	struct blkg_rwstat_sample {	68	struct blkg_iostat_set {
74	u64 cnt[BLKG_RWSTAT_NR];	69	struct u64_stats_sync sync;
		70	struct blkg_iostat cur;
		71	struct blkg_iostat last;
75	};	72	};
76		73
77	/*	74	/*
@@ -127,8 +124,8 @@ struct blkcg_gq { · 49 unmodified lines
127	/* is this blkg online? protected by both blkcg and q locks */	124	/* is this blkg online? protected by both blkcg and q locks */
128	bool online;	125	bool online;
129		126
130	struct blkg_rwstat stat_bytes;	127	struct blkg_iostat_set __percpu *iostat_cpu;
131	struct blkg_rwstat stat_ios;	128	struct blkg_iostat_set iostat;
132		129
133	struct blkg_policy_data *pd[BLKCG_MAX_POLS];	130	struct blkg_policy_data *pd[BLKCG_MAX_POLS];
134		131
@@ -191,7 +188,6 @@ struct blkcg_gq __blkg_lookup_create(struct blkcg blkcg, · 56 unmodified lines
191	struct blkcg_gq blkg_lookup_create(struct blkcg blkcg,	188	struct blkcg_gq blkg_lookup_create(struct blkcg blkcg,
192	struct request_queue *q);	189	struct request_queue *q);
193	int blkcg_init_queue(struct request_queue *q);	190	int blkcg_init_queue(struct request_queue *q);
194	void blkcg_drain_queue(struct request_queue *q);
195	void blkcg_exit_queue(struct request_queue *q);	191	void blkcg_exit_queue(struct request_queue *q);
196		192
197	/* Blkio controller policy registration */	193	/* Blkio controller policy registration */
@@ -202,13 +198,6 @@ int blkcg_activate_policy(struct request_queue *q, · 4 unmodified lines
202	void blkcg_deactivate_policy(struct request_queue *q,	198	void blkcg_deactivate_policy(struct request_queue *q,
203	const struct blkcg_policy *pol);	199	const struct blkcg_policy *pol);
204		200
205	static inline u64 blkg_rwstat_read_counter(struct blkg_rwstat *rwstat,
206	unsigned int idx)
207	{
208	return atomic64_read(&rwstat->aux_cnt[idx]) +
209	percpu_counter_sum_positive(&rwstat->cpu_cnt[idx]);
210	}
211
212	const char blkg_dev_name(struct blkcg_gq blkg);	201	const char blkg_dev_name(struct blkcg_gq blkg);
213	void blkcg_print_blkgs(struct seq_file sf, struct blkcg blkcg,	202	void blkcg_print_blkgs(struct seq_file sf, struct blkcg blkcg,
214	u64 (prfill)(struct seq_file ,	203	u64 (prfill)(struct seq_file ,
@@ -216,17 +205,6 @@ void blkcg_print_blkgs(struct seq_file sf, struct blkcg blkcg, · 1 unmodified line
216	const struct blkcg_policy *pol, int data,	205	const struct blkcg_policy *pol, int data,
217	bool show_total);	206	bool show_total);
218	u64 __blkg_prfill_u64(struct seq_file sf, struct blkg_policy_data pd, u64 v);	207	u64 __blkg_prfill_u64(struct seq_file sf, struct blkg_policy_data pd, u64 v);
219	u64 __blkg_prfill_rwstat(struct seq_file sf, struct blkg_policy_data pd,
220	const struct blkg_rwstat_sample *rwstat);
221	u64 blkg_prfill_rwstat(struct seq_file sf, struct blkg_policy_data pd,
222	int off);
223	int blkg_print_stat_bytes(struct seq_file sf, void v);
224	int blkg_print_stat_ios(struct seq_file sf, void v);
225	int blkg_print_stat_bytes_recursive(struct seq_file sf, void v);
226	int blkg_print_stat_ios_recursive(struct seq_file sf, void v);
227
228	void blkg_rwstat_recursive_sum(struct blkcg_gq blkg, struct blkcg_policy pol,
229	int off, struct blkg_rwstat_sample *sum);
230		208
231	struct blkg_conf_ctx {	209	struct blkg_conf_ctx {
232	struct gendisk *disk;	210	struct gendisk *disk;
@@ -578,128 +556,6 @@ static inline void blkg_put(struct blkcg_gq *blkg) · 345 unmodified lines
578	if (((d_blkg) = __blkg_lookup(css_to_blkcg(pos_css), \	556	if (((d_blkg) = __blkg_lookup(css_to_blkcg(pos_css), \
579	(p_blkg)->q, false)))	557	(p_blkg)->q, false)))
580		558
581	static inline int blkg_rwstat_init(struct blkg_rwstat *rwstat, gfp_t gfp)
582	{
583	int i, ret;
584
585	for (i = 0; i < BLKG_RWSTAT_NR; i++) {
586	ret = percpu_counter_init(&rwstat->cpu_cnt[i], 0, gfp);
587	if (ret) {
588	while (--i >= 0)
589	percpu_counter_destroy(&rwstat->cpu_cnt[i]);
590	return ret;
591	}
592	atomic64_set(&rwstat->aux_cnt[i], 0);
593	}
594	return 0;
595	}
596
597	static inline void blkg_rwstat_exit(struct blkg_rwstat *rwstat)
598	{
599	int i;
600
601	for (i = 0; i < BLKG_RWSTAT_NR; i++)
602	percpu_counter_destroy(&rwstat->cpu_cnt[i]);
603	}
604
605	/**
606	* blkg_rwstat_add - add a value to a blkg_rwstat
607	* @rwstat: target blkg_rwstat
608	* @op: REQ_OP and flags
609	* @val: value to add
610	*
611	* Add @val to @rwstat. The counters are chosen according to @rw. The
612	* caller is responsible for synchronizing calls to this function.
613	*/
614	static inline void blkg_rwstat_add(struct blkg_rwstat *rwstat,
615	unsigned int op, uint64_t val)
616	{
617	struct percpu_counter *cnt;
618
619	if (op_is_discard(op))
620	cnt = &rwstat->cpu_cnt[BLKG_RWSTAT_DISCARD];
621	else if (op_is_write(op))
622	cnt = &rwstat->cpu_cnt[BLKG_RWSTAT_WRITE];
623	else
624	cnt = &rwstat->cpu_cnt[BLKG_RWSTAT_READ];
625
626	percpu_counter_add_batch(cnt, val, BLKG_STAT_CPU_BATCH);
627
628	if (op_is_sync(op))
629	cnt = &rwstat->cpu_cnt[BLKG_RWSTAT_SYNC];
630	else
631	cnt = &rwstat->cpu_cnt[BLKG_RWSTAT_ASYNC];
632
633	percpu_counter_add_batch(cnt, val, BLKG_STAT_CPU_BATCH);
634	}
635
636	/**
637	* blkg_rwstat_read - read the current values of a blkg_rwstat
638	* @rwstat: blkg_rwstat to read
639	*
640	* Read the current snapshot of @rwstat and return it in the aux counts.
641	*/
642	static inline void blkg_rwstat_read(struct blkg_rwstat *rwstat,
643	struct blkg_rwstat_sample *result)
644	{
645	int i;
646
647	for (i = 0; i < BLKG_RWSTAT_NR; i++)
648	result->cnt[i] =
649	percpu_counter_sum_positive(&rwstat->cpu_cnt[i]);
650	}
651
652	/**
653	* blkg_rwstat_total - read the total count of a blkg_rwstat
654	* @rwstat: blkg_rwstat to read
655	*
656	* Return the total count of @rwstat regardless of the IO direction. This
657	* function can be called without synchronization and takes care of u64
658	* atomicity.
659	*/
660	static inline uint64_t blkg_rwstat_total(struct blkg_rwstat *rwstat)
661	{
662	struct blkg_rwstat_sample tmp = { };
663
664	blkg_rwstat_read(rwstat, &tmp);
665	return tmp.cnt[BLKG_RWSTAT_READ] + tmp.cnt[BLKG_RWSTAT_WRITE];
666	}
667
668	/**
669	* blkg_rwstat_reset - reset a blkg_rwstat
670	* @rwstat: blkg_rwstat to reset
671	*/
672	static inline void blkg_rwstat_reset(struct blkg_rwstat *rwstat)
673	{
674	int i;
675
676	for (i = 0; i < BLKG_RWSTAT_NR; i++) {
677	percpu_counter_set(&rwstat->cpu_cnt[i], 0);
678	atomic64_set(&rwstat->aux_cnt[i], 0);
679	}
680	}
681
682	/**
683	* blkg_rwstat_add_aux - add a blkg_rwstat into another's aux count
684	* @to: the destination blkg_rwstat
685	* @from: the source
686	*
687	* Add @from's count including the aux one to @to's aux count.
688	*/
689	static inline void blkg_rwstat_add_aux(struct blkg_rwstat *to,
690	struct blkg_rwstat *from)
691	{
692	u64 sum[BLKG_RWSTAT_NR];
693	int i;
694
695	for (i = 0; i < BLKG_RWSTAT_NR; i++)
696	sum[i] = percpu_counter_sum_positive(&from->cpu_cnt[i]);
697
698	for (i = 0; i < BLKG_RWSTAT_NR; i++)
699	atomic64_add(sum[i] + atomic64_read(&from->aux_cnt[i]),
700	&to->aux_cnt[i]);
701	}
702
703	#ifdef CONFIG_BLK_DEV_THROTTLING	559	#ifdef CONFIG_BLK_DEV_THROTTLING
704	extern bool blk_throtl_bio(struct request_queue q, struct blkcg_gq blkg,	560	extern bool blk_throtl_bio(struct request_queue q, struct blkcg_gq blkg,
705	struct bio *bio);	561	struct bio *bio);
@@ -745,15 +601,33 @@ static inline bool blkcg_bio_issue_check(struct request_queue *q, · 39 unmodified lines
745	throtl = blk_throtl_bio(q, blkg, bio);	601	throtl = blk_throtl_bio(q, blkg, bio);
746		602
747	if (!throtl) {	603	if (!throtl) {
		604	struct blkg_iostat_set *bis;
		605	int rwd, cpu;
		606
		607	if (op_is_discard(bio->bi_opf))
		608	rwd = BLKG_IOSTAT_DISCARD;
		609	else if (op_is_write(bio->bi_opf))
		610	rwd = BLKG_IOSTAT_WRITE;
		611	else
		612	rwd = BLKG_IOSTAT_READ;
		613
		614	cpu = get_cpu();
		615	bis = per_cpu_ptr(blkg->iostat_cpu, cpu);
		616	u64_stats_update_begin(&bis->sync);
		617
748	/*	618	/*
749	* If the bio is flagged with BIO_QUEUE_ENTERED it means this	619	* If the bio is flagged with BIO_QUEUE_ENTERED it means this
750	* is a split bio and we would have already accounted for the	620	* is a split bio and we would have already accounted for the
751	* size of the bio.	621	* size of the bio.
752	*/	622	*/
753	if (!bio_flagged(bio, BIO_QUEUE_ENTERED))	623	if (!bio_flagged(bio, BIO_QUEUE_ENTERED))
754	blkg_rwstat_add(&blkg->stat_bytes, bio->bi_opf,	624	bis->cur.bytes[rwd] += bio->bi_iter.bi_size;
755	bio->bi_iter.bi_size);	625	bis->cur.ios[rwd]++;
756	blkg_rwstat_add(&blkg->stat_ios, bio->bi_opf, 1);	626
		627	u64_stats_update_end(&bis->sync);
		628	if (cgroup_subsys_on_dfl(io_cgrp_subsys))
		629	cgroup_rstat_updated(blkg->blkcg->css.cgroup, cpu);
		630	put_cpu();
757	}	631	}
758		632
759	blkcg_bio_issue_init(bio);	633	blkcg_bio_issue_init(bio);
@@ -845,7 +719,6 @@ static inline struct blkcg_gq blkg_lookup(struct blkcg blkcg, void *key) { ret · 85 unmodified lines
845	static inline struct blkcg_gq blk_queue_root_blkg(struct request_queue q)	719	static inline struct blkcg_gq blk_queue_root_blkg(struct request_queue q)
846	{ return NULL; }	720	{ return NULL; }
847	static inline int blkcg_init_queue(struct request_queue *q) { return 0; }	721	static inline int blkcg_init_queue(struct request_queue *q) { return 0; }
848	static inline void blkcg_drain_queue(struct request_queue *q) { }
849	static inline void blkcg_exit_queue(struct request_queue *q) { }	722	static inline void blkcg_exit_queue(struct request_queue *q) { }
850	static inline int blkcg_policy_register(struct blkcg_policy *pol) { return 0; }	723	static inline int blkcg_policy_register(struct blkcg_policy *pol) { return 0; }
851	static inline void blkcg_policy_unregister(struct blkcg_policy *pol) { }	724	static inline void blkcg_policy_unregister(struct blkcg_policy *pol) { }

include/linux/blk-mq.h+246−54

@@ -10,103 +10,239 @@ struct blk_mq_tags; · 9 unmodified lines
10	struct blk_flush_queue;	10	struct blk_flush_queue;
11		11
12	/**	12	/**
13	* struct blk_mq_hw_ctx - State for a hardware queue facing the hardware block device	13	* struct blk_mq_hw_ctx - State for a hardware queue facing the hardware
		14	* block device
14	*/	15	*/
15	struct blk_mq_hw_ctx {	16	struct blk_mq_hw_ctx {
16	struct {	17	struct {
		18	/** @lock: Protects the dispatch list. */
17	spinlock_t lock;	19	spinlock_t lock;
		20	/**
		21	* @dispatch: Used for requests that are ready to be
		22	* dispatched to the hardware but for some reason (e.g. lack of
		23	* resources) could not be sent to the hardware. As soon as the
		24	* driver can send new requests, requests at this list will
		25	* be sent first for a fairer dispatch.
		26	*/
18	struct list_head dispatch;	27	struct list_head dispatch;
19	unsigned long state; /* BLK_MQ_S_* flags */	28	/**
		29	* @state: BLK_MQ_S_* flags. Defines the state of the hw
		30	* queue (active, scheduled to restart, stopped).
		31	*/
		32	unsigned long state;
20	} ____cacheline_aligned_in_smp;	33	} ____cacheline_aligned_in_smp;
21		34
		35	/**
		36	* @run_work: Used for scheduling a hardware queue run at a later time.
		37	*/
22	struct delayed_work run_work;	38	struct delayed_work run_work;
		39	/** @cpumask: Map of available CPUs where this hctx can run. */
23	cpumask_var_t cpumask;	40	cpumask_var_t cpumask;
		41	/**
		42	* @next_cpu: Used by blk_mq_hctx_next_cpu() for round-robin CPU
		43	* selection from @cpumask.
		44	*/
24	int next_cpu;	45	int next_cpu;
		46	/**
		47	* @next_cpu_batch: Counter of how many works left in the batch before
		48	* changing to the next CPU.
		49	*/
25	int next_cpu_batch;	50	int next_cpu_batch;
26		51
27	unsigned long flags; /* BLK_MQ_F_* flags */	52	/** @flags: BLK_MQ_F_* flags. Defines the behaviour of the queue. */
		53	unsigned long flags;
28		54
		55	/**
		56	* @sched_data: Pointer owned by the IO scheduler attached to a request
		57	* queue. It's up to the IO scheduler how to use this pointer.
		58	*/
29	void *sched_data;	59	void *sched_data;
		60	/**
		61	* @queue: Pointer to the request queue that owns this hardware context.
		62	*/
30	struct request_queue *queue;	63	struct request_queue *queue;
		64	/** @fq: Queue of requests that need to perform a flush operation. */
31	struct blk_flush_queue *fq;	65	struct blk_flush_queue *fq;
32		66
		67	/**
		68	* @driver_data: Pointer to data owned by the block driver that created
		69	* this hctx
		70	*/
33	void *driver_data;	71	void *driver_data;
34		72
		73	/**
		74	* @ctx_map: Bitmap for each software queue. If bit is on, there is a
		75	* pending request in that software queue.
		76	*/
35	struct sbitmap ctx_map;	77	struct sbitmap ctx_map;
36		78
		79	/**
		80	* @dispatch_from: Software queue to be used when no scheduler was
		81	* selected.
		82	*/
37	struct blk_mq_ctx *dispatch_from;	83	struct blk_mq_ctx *dispatch_from;
		84	/**
		85	* @dispatch_busy: Number used by blk_mq_update_dispatch_busy() to
		86	* decide if the hw_queue is busy using Exponential Weighted Moving
		87	* Average algorithm.
		88	*/
38	unsigned int dispatch_busy;	89	unsigned int dispatch_busy;
39		90
		91	/** @type: HCTX_TYPE_* flags. Type of hardware queue. */
40	unsigned short type;	92	unsigned short type;
		93	/** @nr_ctx: Number of software queues. */
41	unsigned short nr_ctx;	94	unsigned short nr_ctx;
		95	/** @ctxs: Array of software queues. */
42	struct blk_mq_ctx **ctxs;	96	struct blk_mq_ctx **ctxs;
43		97
		98	/** @dispatch_wait_lock: Lock for dispatch_wait queue. */
44	spinlock_t dispatch_wait_lock;	99	spinlock_t dispatch_wait_lock;
		100	/**
		101	* @dispatch_wait: Waitqueue to put requests when there is no tag
		102	* available at the moment, to wait for another try in the future.
		103	*/
45	wait_queue_entry_t dispatch_wait;	104	wait_queue_entry_t dispatch_wait;
		105
		106	/**
		107	* @wait_index: Index of next available dispatch_wait queue to insert
		108	* requests.
		109	*/
46	atomic_t wait_index;	110	atomic_t wait_index;
47		111
		112	/**
		113	* @tags: Tags owned by the block driver. A tag at this set is only
		114	* assigned when a request is dispatched from a hardware queue.
		115	*/
48	struct blk_mq_tags *tags;	116	struct blk_mq_tags *tags;
		117	/**
		118	* @sched_tags: Tags owned by I/O scheduler. If there is an I/O
		119	* scheduler associated with a request queue, a tag is assigned when
		120	* that request is allocated. Else, this member is not used.
		121	*/
49	struct blk_mq_tags *sched_tags;	122	struct blk_mq_tags *sched_tags;
50		123
		124	/** @queued: Number of queued requests. */
51	unsigned long queued;	125	unsigned long queued;
		126	/** @run: Number of dispatched requests. */
52	unsigned long run;	127	unsigned long run;
53	#define BLK_MQ_MAX_DISPATCH_ORDER 7	128	#define BLK_MQ_MAX_DISPATCH_ORDER 7
		129	/** @dispatched: Number of dispatch requests by queue. */
54	unsigned long dispatched[BLK_MQ_MAX_DISPATCH_ORDER];	130	unsigned long dispatched[BLK_MQ_MAX_DISPATCH_ORDER];
55		131
		132	/** @numa_node: NUMA node the storage adapter has been connected to. */
56	unsigned int numa_node;	133	unsigned int numa_node;
		134	/** @queue_num: Index of this hardware queue. */
57	unsigned int queue_num;	135	unsigned int queue_num;
58		136
		137	/**
		138	* @nr_active: Number of active requests. Only used when a tag set is
		139	* shared across request queues.
		140	*/
59	atomic_t nr_active;	141	atomic_t nr_active;
60		142
		143	/** @cpuhp_dead: List to store request if some CPU die. */
61	struct hlist_node cpuhp_dead;	144	struct hlist_node cpuhp_dead;
		145	/** @kobj: Kernel object for sysfs. */
62	struct kobject kobj;	146	struct kobject kobj;
63		147
		148	/** @poll_considered: Count times blk_poll() was called. */
64	unsigned long poll_considered;	149	unsigned long poll_considered;
		150	/** @poll_invoked: Count how many requests blk_poll() polled. */
65	unsigned long poll_invoked;	151	unsigned long poll_invoked;
		152	/** @poll_success: Count how many polled requests were completed. */
66	unsigned long poll_success;	153	unsigned long poll_success;
67		154
68	#ifdef CONFIG_BLK_DEBUG_FS	155	#ifdef CONFIG_BLK_DEBUG_FS
		156	/**
		157	* @debugfs_dir: debugfs directory for this hardware queue. Named
		158	* as cpu<cpu_number>.
		159	*/
69	struct dentry *debugfs_dir;	160	struct dentry *debugfs_dir;
		161	/** @sched_debugfs_dir: debugfs directory for the scheduler. */
70	struct dentry *sched_debugfs_dir;	162	struct dentry *sched_debugfs_dir;
71	#endif	163	#endif
72		164
		165	/** @hctx_list: List of all hardware queues. */
73	struct list_head hctx_list;	166	struct list_head hctx_list;
74		167
75	/* Must be the last member - see also blk_mq_hw_ctx_size(). */	168	/**
		169	* @srcu: Sleepable RCU. Use as lock when type of the hardware queue is
		170	* blocking (BLK_MQ_F_BLOCKING). Must be the last member - see also
		171	* blk_mq_hw_ctx_size().
		172	*/
76	struct srcu_struct srcu[0];	173	struct srcu_struct srcu[0];
77	};	174	};
78		175
		176	/**
		177	* struct blk_mq_queue_map - Map software queues to hardware queues
		178	* @mq_map: CPU ID to hardware queue index map. This is an array
		179	* with nr_cpu_ids elements. Each element has a value in the range
		180	* [@queue_offset, @queue_offset + @nr_queues).
		181	* @nr_queues: Number of hardware queues to map CPU IDs onto.
		182	* @queue_offset: First hardware queue to map onto. Used by the PCIe NVMe
		183	* driver to map each hardware queue type (enum hctx_type) onto a distinct
		184	* set of hardware queues.
		185	*/
79	struct blk_mq_queue_map {	186	struct blk_mq_queue_map {
80	unsigned int *mq_map;	187	unsigned int *mq_map;
81	unsigned int nr_queues;	188	unsigned int nr_queues;
82	unsigned int queue_offset;	189	unsigned int queue_offset;
83	};	190	};
84		191
		192	/**
		193	* enum hctx_type - Type of hardware queue
		194	* @HCTX_TYPE_DEFAULT: All I/O not otherwise accounted for.
		195	* @HCTX_TYPE_READ: Just for READ I/O.
		196	* @HCTX_TYPE_POLL: Polled I/O of any kind.
		197	* @HCTX_MAX_TYPES: Number of types of hctx.
		198	*/
85	enum hctx_type {	199	enum hctx_type {
86	HCTX_TYPE_DEFAULT, /* all I/O not otherwise accounted for */	200	HCTX_TYPE_DEFAULT,
87	HCTX_TYPE_READ, /* just for READ I/O */	201	HCTX_TYPE_READ,
88	HCTX_TYPE_POLL, /* polled I/O of any kind */	202	HCTX_TYPE_POLL,
89		203
90	HCTX_MAX_TYPES,	204	HCTX_MAX_TYPES,
91	};	205	};
92		206
		207	/**
		208	* struct blk_mq_tag_set - tag set that can be shared between request queues
		209	* @map: One or more ctx -> hctx mappings. One map exists for each
		210	* hardware queue type (enum hctx_type) that the driver wishes
		211	* to support. There are no restrictions on maps being of the
		212	* same size, and it's perfectly legal to share maps between
		213	* types.
		214	* @nr_maps: Number of elements in the @map array. A number in the range
		215	* [1, HCTX_MAX_TYPES].
		216	* @ops: Pointers to functions that implement block driver behavior.
		217	* @nr_hw_queues: Number of hardware queues supported by the block driver that
		218	* owns this data structure.
		219	* @queue_depth: Number of tags per hardware queue, reserved tags included.
		220	* @reserved_tags: Number of tags to set aside for BLK_MQ_REQ_RESERVED tag
		221	* allocations.
		222	* @cmd_size: Number of additional bytes to allocate per request. The block
		223	* driver owns these additional bytes.
		224	* @numa_node: NUMA node the storage adapter has been connected to.
		225	* @timeout: Request processing timeout in jiffies.
		226	* @flags: Zero or more BLK_MQ_F_* flags.
		227	* @driver_data: Pointer to data owned by the block driver that created this
		228	* tag set.
		229	* @tags: Tag sets. One tag set per hardware queue. Has @nr_hw_queues
		230	* elements.
		231	* @tag_list_lock: Serializes tag_list accesses.
		232	* @tag_list: List of the request queues that use this tag set. See also
		233	* request_queue.tag_set_list.
		234	*/
93	struct blk_mq_tag_set {	235	struct blk_mq_tag_set {
94	/*
95	* map[] holds ctx -> hctx mappings, one map exists for each type
96	* that the driver wishes to support. There are no restrictions
97	* on maps being of the same size, and it's perfectly legal to
98	* share maps between types.
99	*/
100	struct blk_mq_queue_map map[HCTX_MAX_TYPES];	236	struct blk_mq_queue_map map[HCTX_MAX_TYPES];
101	unsigned int nr_maps; /* nr entries in map[] */	237	unsigned int nr_maps;
102	const struct blk_mq_ops *ops;	238	const struct blk_mq_ops *ops;
103	unsigned int nr_hw_queues; /* nr hw queues across maps */	239	unsigned int nr_hw_queues;
104	unsigned int queue_depth; /* max hw supported */	240	unsigned int queue_depth;
105	unsigned int reserved_tags;	241	unsigned int reserved_tags;
106	unsigned int cmd_size; /* per-request extra data */	242	unsigned int cmd_size;
107	int numa_node;	243	int numa_node;
108	unsigned int timeout;	244	unsigned int timeout;
109	unsigned int flags; /* BLK_MQ_F_* */	245	unsigned int flags;
110	void *driver_data;	246	void *driver_data;
111		247
112	struct blk_mq_tags **tags;	248	struct blk_mq_tags **tags;
@@ -115,6 +251,12 @@ struct blk_mq_tag_set { · 2 unmodified lines
115	struct list_head tag_list;	251	struct list_head tag_list;
116	};	252	};
117		253
		254	/**
		255	* struct blk_mq_queue_data - Data about a request inserted in a queue
		256	*
		257	* @rq: Request pointer.
		258	* @last: If it is the last request in the queue.
		259	*/
118	struct blk_mq_queue_data {	260	struct blk_mq_queue_data {
119	struct request *rq;	261	struct request *rq;
120	bool last;	262	bool last;
@@ -142,81 +284,101 @@ typedef bool (busy_fn)(struct request_queue *); · 21 unmodified lines
142	typedef void (complete_fn)(struct request *);	284	typedef void (complete_fn)(struct request *);
143	typedef void (cleanup_rq_fn)(struct request *);	285	typedef void (cleanup_rq_fn)(struct request *);
144		286
145		287	/**
		288	* struct blk_mq_ops - Callback functions that implements block driver
		289	* behaviour.
		290	*/
146	struct blk_mq_ops {	291	struct blk_mq_ops {
147	/*	292	/**
148	* Queue request	293	* @queue_rq: Queue a new request from block IO.
149	*/	294	*/
150	queue_rq_fn *queue_rq;	295	queue_rq_fn *queue_rq;
151		296
152	/*	297	/**
153	* If a driver uses bd->last to judge when to submit requests to	298	* @commit_rqs: If a driver uses bd->last to judge when to submit
154	* hardware, it must define this function. In case of errors that	299	* requests to hardware, it must define this function. In case of errors
155	* make us stop issuing further requests, this hook serves the	300	* that make us stop issuing further requests, this hook serves the
156	* purpose of kicking the hardware (which the last request otherwise	301	* purpose of kicking the hardware (which the last request otherwise
157	* would have done).	302	* would have done).
158	*/	303	*/
159	commit_rqs_fn *commit_rqs;	304	commit_rqs_fn *commit_rqs;
160		305
161	/*	306	/**
162	* Reserve budget before queue request, once .queue_rq is	307	* @get_budget: Reserve budget before queue request, once .queue_rq is
163	* run, it is driver's responsibility to release the	308	* run, it is driver's responsibility to release the
164	* reserved budget. Also we have to handle failure case	309	* reserved budget. Also we have to handle failure case
165	* of .get_budget for avoiding I/O deadlock.	310	* of .get_budget for avoiding I/O deadlock.
166	*/	311	*/
167	get_budget_fn *get_budget;	312	get_budget_fn *get_budget;
		313	/**
		314	* @put_budget: Release the reserved budget.
		315	*/
168	put_budget_fn *put_budget;	316	put_budget_fn *put_budget;
169		317
170	/*	318	/**
171	* Called on request timeout	319	* @timeout: Called on request timeout.
172	*/	320	*/
173	timeout_fn *timeout;	321	timeout_fn *timeout;
174		322
175	/*	323	/**
176	* Called to poll for completion of a specific tag.	324	* @poll: Called to poll for completion of a specific tag.
177	*/	325	*/
178	poll_fn *poll;	326	poll_fn *poll;
179		327
		328	/**
		329	* @complete: Mark the request as complete.
		330	*/
180	complete_fn *complete;	331	complete_fn *complete;
181		332
182	/*	333	/**
183	* Called when the block layer side of a hardware queue has been	334	* @init_hctx: Called when the block layer side of a hardware queue has
184	* set up, allowing the driver to allocate/init matching structures.	335	* been set up, allowing the driver to allocate/init matching
185	* Ditto for exit/teardown.	336	* structures.
186	*/	337	*/
187	init_hctx_fn *init_hctx;	338	init_hctx_fn *init_hctx;
		339	/**
		340	* @exit_hctx: Ditto for exit/teardown.
		341	*/
188	exit_hctx_fn *exit_hctx;	342	exit_hctx_fn *exit_hctx;
189		343
190	/*	344	/**
191	* Called for every command allocated by the block layer to allow	345	* @init_request: Called for every command allocated by the block layer
192	* the driver to set up driver specific data.	346	* to allow the driver to set up driver specific data.
193	*	347	*
194	* Tag greater than or equal to queue_depth is for setting up	348	* Tag greater than or equal to queue_depth is for setting up
195	* flush request.	349	* flush request.
196	*
197	* Ditto for exit/teardown.
198	*/	350	*/
199	init_request_fn *init_request;	351	init_request_fn *init_request;
		352	/**
		353	* @exit_request: Ditto for exit/teardown.
		354	*/
200	exit_request_fn *exit_request;	355	exit_request_fn *exit_request;
201	/* Called from inside blk_get_request() */	356
		357	/**
		358	* @initialize_rq_fn: Called from inside blk_get_request().
		359	*/
202	void (initialize_rq_fn)(struct request rq);	360	void (initialize_rq_fn)(struct request rq);
203		361
204	/*	362	/**
205	* Called before freeing one request which isn't completed yet,	363	* @cleanup_rq: Called before freeing one request which isn't completed
206	* and usually for freeing the driver private data	364	* yet, and usually for freeing the driver private data.
207	*/	365	*/
208	cleanup_rq_fn *cleanup_rq;	366	cleanup_rq_fn *cleanup_rq;
209		367
210	/*	368	/**
211	* If set, returns whether or not this queue currently is busy	369	* @busy: If set, returns whether or not this queue currently is busy.
212	*/	370	*/
213	busy_fn *busy;	371	busy_fn *busy;
214		372
		373	/**
		374	* @map_queues: This allows drivers specify their own queue mapping by
		375	* overriding the setup-time function that builds the mq_map.
		376	*/
215	map_queues_fn *map_queues;	377	map_queues_fn *map_queues;
216		378
217	#ifdef CONFIG_BLK_DEBUG_FS	379	#ifdef CONFIG_BLK_DEBUG_FS
218	/*	380	/**
219	* Used by the debugfs implementation to show driver-specific	381	* @show_rq: Used by the debugfs implementation to show driver-specific
220	* information about a request.	382	* information about a request.
221	*/	383	*/
222	void (show_rq)(struct seq_file m, struct request *rq);	384	void (show_rq)(struct seq_file m, struct request *rq);
@@ -262,7 +424,6 @@ void blk_mq_free_tag_set(struct blk_mq_tag_set *set); · 39 unmodified lines
262	void blk_mq_flush_plug_list(struct blk_plug *plug, bool from_schedule);	424	void blk_mq_flush_plug_list(struct blk_plug *plug, bool from_schedule);
263		425
264	void blk_mq_free_request(struct request *rq);	426	void blk_mq_free_request(struct request *rq);
265	bool blk_mq_can_queue(struct blk_mq_hw_ctx *);
266		427
267	bool blk_mq_queue_inflight(struct request_queue *q);	428	bool blk_mq_queue_inflight(struct request_queue *q);
268		429
@@ -301,9 +462,25 @@ static inline u16 blk_mq_unique_tag_to_tag(u32 unique_tag) · 32 unmodified lines
301	return unique_tag & BLK_MQ_UNIQUE_TAG_MASK;	462	return unique_tag & BLK_MQ_UNIQUE_TAG_MASK;
302	}	463	}
303		464
		465	/**
		466	* blk_mq_rq_state() - read the current MQ_RQ_* state of a request
		467	* @rq: target request.
		468	*/
		469	static inline enum mq_rq_state blk_mq_rq_state(struct request *rq)
		470	{
		471	return READ_ONCE(rq->state);
		472	}
		473
		474	static inline int blk_mq_request_started(struct request *rq)
		475	{
		476	return blk_mq_rq_state(rq) != MQ_RQ_IDLE;
		477	}
		478
		479	static inline int blk_mq_request_completed(struct request *rq)
		480	{
		481	return blk_mq_rq_state(rq) == MQ_RQ_COMPLETE;
		482	}
304		483
305	int blk_mq_request_started(struct request *rq);
306	int blk_mq_request_completed(struct request *rq);
307	void blk_mq_start_request(struct request *rq);	484	void blk_mq_start_request(struct request *rq);
308	void blk_mq_end_request(struct request *rq, blk_status_t error);	485	void blk_mq_end_request(struct request *rq, blk_status_t error);
309	void __blk_mq_end_request(struct request *rq, blk_status_t error);	486	void __blk_mq_end_request(struct request *rq, blk_status_t error);
@@ -324,7 +501,7 @@ void blk_mq_start_stopped_hw_queues(struct request_queue *q, bool async); · 14 unmodified lines
324	void blk_mq_quiesce_queue(struct request_queue *q);	501	void blk_mq_quiesce_queue(struct request_queue *q);
325	void blk_mq_unquiesce_queue(struct request_queue *q);	502	void blk_mq_unquiesce_queue(struct request_queue *q);
326	void blk_mq_delay_run_hw_queue(struct blk_mq_hw_ctx *hctx, unsigned long msecs);	503	void blk_mq_delay_run_hw_queue(struct blk_mq_hw_ctx *hctx, unsigned long msecs);
327	bool blk_mq_run_hw_queue(struct blk_mq_hw_ctx *hctx, bool async);	504	void blk_mq_run_hw_queue(struct blk_mq_hw_ctx *hctx, bool async);
328	void blk_mq_run_hw_queues(struct request_queue *q, bool async);	505	void blk_mq_run_hw_queues(struct request_queue *q, bool async);
329	void blk_mq_tagset_busy_iter(struct blk_mq_tag_set *tagset,	506	void blk_mq_tagset_busy_iter(struct blk_mq_tag_set *tagset,
330	busy_tag_iter_fn fn, void priv);	507	busy_tag_iter_fn fn, void priv);
@@ -343,14 +520,29 @@ void blk_mq_quiesce_queue_nowait(struct request_queue *q); · 12 unmodified lines
343		520
344	unsigned int blk_mq_rq_cpu(struct request *rq);	521	unsigned int blk_mq_rq_cpu(struct request *rq);
345		522
346	/*	523	/**
		524	* blk_mq_rq_from_pdu - cast a PDU to a request
		525	* @pdu: the PDU (Protocol Data Unit) to be casted
		526	*
		527	* Return: request
		528	*
347	* Driver command data is immediately after the request. So subtract request	529	* Driver command data is immediately after the request. So subtract request
348	* size to get back to the original request, add request size to get the PDU.	530	* size to get back to the original request.
349	*/	531	*/
350	static inline struct request blk_mq_rq_from_pdu(void pdu)	532	static inline struct request blk_mq_rq_from_pdu(void pdu)
351	{	533	{
352	return pdu - sizeof(struct request);	534	return pdu - sizeof(struct request);
353	}	535	}
		536
		537	/**
		538	* blk_mq_rq_to_pdu - cast a request to a PDU
		539	* @rq: the request to be casted
		540	*
		541	* Return: pointer to the PDU
		542	*
		543	* Driver command data is immediately after the request. So add request to get
		544	* the PDU.
		545	*/
354	static inline void blk_mq_rq_to_pdu(struct request rq)	546	static inline void blk_mq_rq_to_pdu(struct request rq)
355	{	547	{
356	return rq + 1;	548	return rq + 1;

include/linux/blk_types.h+27−1

 	unsigned short		bi_write_hint;
 	blk_status_t		bi_status;
 	u8			bi_partno;
+	atomic_t		__bi_remaining;
 	struct bvec_iter	bi_iter;
-	atomic_t		__bi_remaining;
 	bio_end_io_t		*bi_end_io;
 	void			*bi_private;
 	REQ_OP_ZONE_RESET_ALL	= 8,
 	/* write the zero filled sector many times */
 	REQ_OP_WRITE_ZEROES	= 9,
+	/* Open a zone */
+	REQ_OP_ZONE_OPEN	= 10,
+	/* Close a zone */
+	REQ_OP_ZONE_CLOSE	= 11,
+	/* Transition a zone to full */
+	REQ_OP_ZONE_FINISH	= 12,
 	/* SCSI passthrough using struct scsi_request */
 	REQ_OP_SCSI_IN		= 32,
 	STAT_READ,
 	STAT_WRITE,
 	STAT_DISCARD,
+	STAT_FLUSH,
 	NR_STAT_GROUPS
 };
 	return (op & REQ_OP_MASK) == REQ_OP_DISCARD;
 }
+/*
+ * Check if a bio or request operation is a zone management operation, with
+ * the exception of REQ_OP_ZONE_RESET_ALL which is treated as a special case
+ * due to its different handling in the block layer and device response in
+ * case of command failure.
+ */
+static inline bool op_is_zone_mgmt(enum req_opf op)
+{
+	switch (op & REQ_OP_MASK) {
+	case REQ_OP_ZONE_RESET:
+	case REQ_OP_ZONE_OPEN:
+	case REQ_OP_ZONE_CLOSE:
+	case REQ_OP_ZONE_FINISH:
+		return true;
+	default:
+		return false;
+	}
+}
 static inline int op_stat_group(unsigned int op)
 {
 	if (op_is_discard(op))

include/linux/blkdev.h+27−30

@@ -349,34 +349,28 @@ struct queue_limits { · 348 unmodified lines
349	enum blk_zoned_model zoned;	349	enum blk_zoned_model zoned;
350	};	350	};
351		351
		352	typedef int (report_zones_cb)(struct blk_zone zone, unsigned int idx,
		353	void *data);
		354
352	#ifdef CONFIG_BLK_DEV_ZONED	355	#ifdef CONFIG_BLK_DEV_ZONED
353		356
354	/*	357	#define BLK_ALL_ZONES ((unsigned int)-1)
355	* Maximum number of zones to report with a single report zones command.	358	int blkdev_report_zones(struct block_device *bdev, sector_t sector,
356	*/	359	unsigned int nr_zones, report_zones_cb cb, void *data);
357	#define BLK_ZONED_REPORT_MAX_ZONES 8192U	360	unsigned int blkdev_nr_zones(struct gendisk *disk);
358		361	extern int blkdev_zone_mgmt(struct block_device *bdev, enum req_opf op,
359	extern unsigned int blkdev_nr_zones(struct block_device *bdev);	362	sector_t sectors, sector_t nr_sectors,
360	extern int blkdev_report_zones(struct block_device *bdev,	363	gfp_t gfp_mask);
361	sector_t sector, struct blk_zone *zones,
362	unsigned int *nr_zones);
363	extern int blkdev_reset_zones(struct block_device *bdev, sector_t sectors,
364	sector_t nr_sectors, gfp_t gfp_mask);
365	extern int blk_revalidate_disk_zones(struct gendisk *disk);	364	extern int blk_revalidate_disk_zones(struct gendisk *disk);
366		365
367	extern int blkdev_report_zones_ioctl(struct block_device *bdev, fmode_t mode,	366	extern int blkdev_report_zones_ioctl(struct block_device *bdev, fmode_t mode,
368	unsigned int cmd, unsigned long arg);	367	unsigned int cmd, unsigned long arg);
369	extern int blkdev_reset_zones_ioctl(struct block_device *bdev, fmode_t mode,	368	extern int blkdev_zone_mgmt_ioctl(struct block_device *bdev, fmode_t mode,
370	unsigned int cmd, unsigned long arg);	369	unsigned int cmd, unsigned long arg);
371		370
372	#else /* CONFIG_BLK_DEV_ZONED */	371	#else /* CONFIG_BLK_DEV_ZONED */
373		372
374	static inline unsigned int blkdev_nr_zones(struct block_device *bdev)	373	static inline unsigned int blkdev_nr_zones(struct gendisk *disk)
375	{
376	return 0;
377	}
378
379	static inline int blk_revalidate_disk_zones(struct gendisk *disk)
380	{	374	{
381	return 0;	375	return 0;
382	}	376	}
@@ -388,9 +382,9 @@ static inline int blkdev_report_zones_ioctl(struct block_device *bdev, · 5 unmodified lines
388	return -ENOTTY;	382	return -ENOTTY;
389	}	383	}
390		384
391	static inline int blkdev_reset_zones_ioctl(struct block_device *bdev,	385	static inline int blkdev_zone_mgmt_ioctl(struct block_device *bdev,
392	fmode_t mode, unsigned int cmd,	386	fmode_t mode, unsigned int cmd,
393	unsigned long arg)	387	unsigned long arg)
394	{	388	{
395	return -ENOTTY;	389	return -ENOTTY;
396	}	390	}
@@ -411,7 +405,6 @@ struct request_queue { · 14 unmodified lines
411		405
412	/* sw queues */	406	/* sw queues */
413	struct blk_mq_ctx __percpu *queue_ctx;	407	struct blk_mq_ctx __percpu *queue_ctx;
414	unsigned int nr_queues;
415		408
416	unsigned int queue_depth;	409	unsigned int queue_depth;
417		410
@@ -505,9 +498,9 @@ struct request_queue { · 87 unmodified lines
505	/*	498	/*
506	* Zoned block device information for request dispatch control.	499	* Zoned block device information for request dispatch control.
507	* nr_zones is the total number of zones of the device. This is always	500	* nr_zones is the total number of zones of the device. This is always
508	* 0 for regular block devices. seq_zones_bitmap is a bitmap of nr_zones	501	* 0 for regular block devices. conv_zones_bitmap is a bitmap of nr_zones
509	* bits which indicates if a zone is conventional (bit clear) or	502	* bits which indicates if a zone is conventional (bit set) or
510	* sequential (bit set). seq_zones_wlock is a bitmap of nr_zones	503	* sequential (bit clear). seq_zones_wlock is a bitmap of nr_zones
511	* bits which indicates if a zone is write locked, that is, if a write	504	* bits which indicates if a zone is write locked, that is, if a write
512	* request targeting the zone was dispatched. All three fields are	505	* request targeting the zone was dispatched. All three fields are
513	* initialized by the low level device driver (e.g. scsi/sd.c).	506	* initialized by the low level device driver (e.g. scsi/sd.c).
@@ -520,7 +513,7 @@ struct request_queue { · 6 unmodified lines
520	* blk_mq_unfreeze_queue().	513	* blk_mq_unfreeze_queue().
521	*/	514	*/
522	unsigned int nr_zones;	515	unsigned int nr_zones;
523	unsigned long *seq_zones_bitmap;	516	unsigned long *conv_zones_bitmap;
524	unsigned long *seq_zones_wlock;	517	unsigned long *seq_zones_wlock;
525	#endif /* CONFIG_BLK_DEV_ZONED */	518	#endif /* CONFIG_BLK_DEV_ZONED */
526		519
@@ -725,9 +718,11 @@ static inline unsigned int blk_queue_zone_no(struct request_queue *q, · 198 unmodified lines
725	static inline bool blk_queue_zone_is_seq(struct request_queue *q,	718	static inline bool blk_queue_zone_is_seq(struct request_queue *q,
726	sector_t sector)	719	sector_t sector)
727	{	720	{
728	if (!blk_queue_is_zoned(q) \|\| !q->seq_zones_bitmap)	721	if (!blk_queue_is_zoned(q))
729	return false;	722	return false;
730	return test_bit(blk_queue_zone_no(q, sector), q->seq_zones_bitmap);	723	if (!q->conv_zones_bitmap)
		724	return true;
		725	return !test_bit(blk_queue_zone_no(q, sector), q->conv_zones_bitmap);
731	}	726	}
732	#else /* CONFIG_BLK_DEV_ZONED */	727	#else /* CONFIG_BLK_DEV_ZONED */
733	static inline unsigned int blk_queue_nr_zones(struct request_queue *q)	728	static inline unsigned int blk_queue_nr_zones(struct request_queue *q)
@@ -870,6 +865,8 @@ extern int scsi_cmd_ioctl(struct request_queue , struct gendisk , fmode_t, · 136 unmodified lines
870	unsigned int, void __user *);	865	unsigned int, void __user *);
871	extern int sg_scsi_ioctl(struct request_queue , struct gendisk , fmode_t,	866	extern int sg_scsi_ioctl(struct request_queue , struct gendisk , fmode_t,
872	struct scsi_ioctl_command __user *);	867	struct scsi_ioctl_command __user *);
		868	extern int get_sg_io_hdr(struct sg_io_hdr hdr, const void __user argp);
		869	extern int put_sg_io_hdr(const struct sg_io_hdr hdr, void __user argp);
873		870
874	extern int blk_queue_enter(struct request_queue *q, blk_mq_req_flags_t flags);	871	extern int blk_queue_enter(struct request_queue *q, blk_mq_req_flags_t flags);
875	extern void blk_queue_exit(struct request_queue *q);	872	extern void blk_queue_exit(struct request_queue *q);
@@ -1709,7 +1706,7 @@ struct block_device_operations { · 833 unmodified lines
1709	/* this callback is with swap_lock and sometimes page table lock held */	1706	/* this callback is with swap_lock and sometimes page table lock held */
1710	void (swap_slot_free_notify) (struct block_device , unsigned long);	1707	void (swap_slot_free_notify) (struct block_device , unsigned long);
1711	int (report_zones)(struct gendisk , sector_t sector,	1708	int (report_zones)(struct gendisk , sector_t sector,
1712	struct blk_zone zones, unsigned int nr_zones);	1709	unsigned int nr_zones, report_zones_cb cb, void *data);
1713	struct module *owner;	1710	struct module *owner;
1714	const struct pr_ops *pr_ops;	1711	const struct pr_ops *pr_ops;
1715	};	1712	};

include/linux/bpf-cgroup.h+4−4

include/linux/bpf.h+244−55

 #include <linux/err.h>
 #include <linux/rbtree_latch.h>
 #include <linux/numa.h>
+#include <linux/mm_types.h>
 #include <linux/wait.h>
 #include <linux/u64_stats_sync.h>
+#include <linux/refcount.h>
+#include <linux/mutex.h>
 struct bpf_verifier_env;
+struct bpf_verifier_log;
 struct perf_event;
 struct bpf_prog;
+struct bpf_prog_aux;
 struct bpf_map;
 struct sock;
 struct seq_file;
 struct btf;
 struct btf_type;
+struct exception_table_entry;
 extern struct idr btf_idr;
 extern spinlock_t btf_idr_lock;
 			     const struct btf_type *key_type,
 			     const struct btf_type *value_type);
+	/* Prog poke tracking helpers. */
+	int (*map_poke_track)(struct bpf_map *map, struct bpf_prog_aux *aux);
+	void (*map_poke_untrack)(struct bpf_map *map, struct bpf_prog_aux *aux);
+	void (*map_poke_run)(struct bpf_map *map, u32 key, struct bpf_prog *old,
+			     struct bpf_prog *new);
 	/* Direct value access helpers. */
 	int (*map_direct_value_addr)(const struct bpf_map *map,
 				     u64 *imm, u32 off);
 	int (*map_direct_value_meta)(const struct bpf_map *map,
 				     u64 imm, u32 *off);
+	int (*map_mmap)(struct bpf_map *map, struct vm_area_struct *vma);
 };
 struct bpf_map_memory {
 	u32 btf_value_type_id;
 	struct btf *btf;
 	struct bpf_map_memory memory;
+	char name[BPF_OBJ_NAME_LEN];
 	bool unpriv_array;
-	bool frozen; /* write-once */
+	bool frozen; /* write-once; write-protected by freeze_mutex */
-	/* 48 bytes hole */
+	/* 22 bytes hole */
 	/* The 3rd and 4th cacheline with misc members to avoid false sharing
 	 * particularly with refcounting.
 	 */
-	atomic_t refcnt ____cacheline_aligned;
+	atomic64_t refcnt ____cacheline_aligned;
-	atomic_t usercnt;
+	atomic64_t usercnt;
 	struct work_struct work;
-	char name[BPF_OBJ_NAME_LEN];
+	struct mutex freeze_mutex;
+	u64 writecnt; /* writable mmap cnt; protected by freeze_mutex */
 };
 static inline bool map_value_has_spin_lock(const struct bpf_map *map)
 	ARG_PTR_TO_INT,		/* pointer to int */
 	ARG_PTR_TO_LONG,	/* pointer to long */
 	ARG_PTR_TO_SOCKET,	/* pointer to bpf_sock (fullsock) */
+	ARG_PTR_TO_BTF_ID,	/* pointer to in-kernel struct */
 };
 /* type of values returned from helper functions */
 	bool gpl_only;
 	bool pkt_access;
 	enum bpf_return_type ret_type;
-	enum bpf_arg_type arg1_type;
+	union {
-	enum bpf_arg_type arg2_type;
+		struct {
-	enum bpf_arg_type arg3_type;
+			enum bpf_arg_type arg1_type;
-	enum bpf_arg_type arg4_type;
+			enum bpf_arg_type arg2_type;
-	enum bpf_arg_type arg5_type;
+			enum bpf_arg_type arg3_type;
+			enum bpf_arg_type arg4_type;
+			enum bpf_arg_type arg5_type;
+		};
+		enum bpf_arg_type arg_type[5];
+	};
+	int *btf_id; /* BTF ids of arguments */
 };
 /* bpf_context is intentionally undefined structure. Pointer to bpf_context is
 	PTR_TO_TCP_SOCK_OR_NULL, /* reg points to struct tcp_sock or NULL */
 	PTR_TO_TP_BUFFER,	 /* reg points to a writable raw tp's buffer */
 	PTR_TO_XDP_SOCK,	 /* reg points to struct xdp_sock */
+	PTR_TO_BTF_ID,		 /* reg points to kernel struct */
 };
 /* The information passed from prog-specific *_is_valid_access
  */
 struct bpf_insn_access_aux {
 	enum bpf_reg_type reg_type;
-	int ctx_field_size;
+	union {
+		int ctx_field_size;
+		u32 btf_id;
+	};
+	struct bpf_verifier_log *log; /* for verbose logs */
 };
 static inline void
 #define MAX_BPF_CGROUP_STORAGE_TYPE __BPF_CGROUP_STORAGE_MAX
+/* The longest tracepoint has 12 args.
+ * See include/trace/bpf_probe.h
+ */
+#define MAX_BPF_FUNC_ARGS 12
 struct bpf_prog_stats {
 	u64 cnt;
 	u64 nsecs;
 	struct u64_stats_sync syncp;
+} __aligned(2 * sizeof(u64));
+struct btf_func_model {
+	u8 ret_size;
+	u8 nr_args;
+	u8 arg_size[MAX_BPF_FUNC_ARGS];
+};
+/* Restore arguments before returning from trampoline to let original function
+ * continue executing. This flag is used for fentry progs when there are no
+ * fexit progs.
+ */
+#define BPF_TRAMP_F_RESTORE_REGS	BIT(0)
+/* Call original function after fentry progs, but before fexit progs.
+ * Makes sense for fentry/fexit, normal calls and indirect calls.
+ */
+#define BPF_TRAMP_F_CALL_ORIG		BIT(1)
+/* Skip current frame and return to parent.  Makes sense for fentry/fexit
+ * programs only. Should not be used with normal calls and indirect calls.
+ */
+#define BPF_TRAMP_F_SKIP_FRAME		BIT(2)
+/* Different use cases for BPF trampoline:
+ * 1. replace nop at the function entry (kprobe equivalent)
+ *    flags = BPF_TRAMP_F_RESTORE_REGS
+ *    fentry = a set of programs to run before returning from trampoline
+ *
+ * 2. replace nop at the function entry (kprobe + kretprobe equivalent)
+ *    flags = BPF_TRAMP_F_CALL_ORIG | BPF_TRAMP_F_SKIP_FRAME
+ *    orig_call = fentry_ip + MCOUNT_INSN_SIZE
+ *    fentry = a set of program to run before calling original function
+ *    fexit = a set of program to run after original function
+ *
+ * 3. replace direct call instruction anywhere in the function body
+ *    or assign a function pointer for indirect call (like tcp_congestion_ops->cong_avoid)
+ *    With flags = 0
+ *      fentry = a set of programs to run before returning from trampoline
+ *    With flags = BPF_TRAMP_F_CALL_ORIG
+ *      orig_call = original callback addr or direct function addr
+ *      fentry = a set of program to run before calling original function
+ *      fexit = a set of program to run after original function
+ */
+int arch_prepare_bpf_trampoline(void *image, struct btf_func_model *m, u32 flags,
+				struct bpf_prog **fentry_progs, int fentry_cnt,
+				struct bpf_prog **fexit_progs, int fexit_cnt,
+				void *orig_call);
+/* these two functions are called from generated trampoline */
+u64 notrace __bpf_prog_enter(void);
+void notrace __bpf_prog_exit(struct bpf_prog *prog, u64 start);
+enum bpf_tramp_prog_type {
+	BPF_TRAMP_FENTRY,
+	BPF_TRAMP_FEXIT,
+	BPF_TRAMP_MAX
+};
+struct bpf_trampoline {
+	/* hlist for trampoline_table */
+	struct hlist_node hlist;
+	/* serializes access to fields of this trampoline */
+	struct mutex mutex;
+	refcount_t refcnt;
+	u64 key;
+	struct {
+		struct btf_func_model model;
+		void *addr;
+		bool ftrace_managed;
+	} func;
+	/* list of BPF programs using this trampoline */
+	struct hlist_head progs_hlist[BPF_TRAMP_MAX];
+	/* Number of attached programs. A counter per kind. */
+	int progs_cnt[BPF_TRAMP_MAX];
+	/* Executable image of trampoline */
+	void *image;
+	u64 selector;
+};
+#ifdef CONFIG_BPF_JIT
+struct bpf_trampoline *bpf_trampoline_lookup(u64 key);
+int bpf_trampoline_link_prog(struct bpf_prog *prog);
+int bpf_trampoline_unlink_prog(struct bpf_prog *prog);
+void bpf_trampoline_put(struct bpf_trampoline *tr);
+#else
+static inline struct bpf_trampoline *bpf_trampoline_lookup(u64 key)
+{
+	return NULL;
+}
+static inline int bpf_trampoline_link_prog(struct bpf_prog *prog)
+{
+	return -ENOTSUPP;
+}
+static inline int bpf_trampoline_unlink_prog(struct bpf_prog *prog)
+{
+	return -ENOTSUPP;
+}
+static inline void bpf_trampoline_put(struct bpf_trampoline *tr) {}
+#endif
+struct bpf_func_info_aux {
+	bool unreliable;
+};
+enum bpf_jit_poke_reason {
+	BPF_POKE_REASON_TAIL_CALL,
+};
+/* Descriptor of pokes pointing /into/ the JITed image. */
+struct bpf_jit_poke_descriptor {
+	void *ip;
+	union {
+		struct {
+			struct bpf_map *map;
+			u32 key;
+		} tail_call;
+	};
+	bool ip_stable;
+	u8 adj_off;
+	u16 reason;
 };
 struct bpf_prog_aux {
-	atomic_t refcnt;
+	atomic64_t refcnt;
 	u32 used_map_cnt;
 	u32 max_ctx_offset;
 	u32 max_pkt_offset;
 	u32 id;
 	u32 func_cnt; /* used by non-func prog as the number of func progs */
 	u32 func_idx; /* 0 for non-func prog, the index in func array for func prog */
+	u32 attach_btf_id; /* in-kernel BTF type id to attach to */
+	struct bpf_prog *linked_prog;
 	bool verifier_zext; /* Zero extensions has been inserted by verifier. */
 	bool offload_requested;
+	bool attach_btf_trace; /* true if attaching to BTF-enabled raw tp */
+	bool func_proto_unreliable;
+	enum bpf_tramp_prog_type trampoline_prog_type;
+	struct bpf_trampoline *trampoline;
+	struct hlist_node tramp_hlist;
+	/* BTF_KIND_FUNC_PROTO for valid attach_btf_id */
+	const struct btf_type *attach_func_proto;
+	/* function name for valid attach_btf_id */
+	const char *attach_func_name;
 	struct bpf_prog **func;
 	void *jit_data; /* JIT specific data. arch dependent */
+	struct bpf_jit_poke_descriptor *poke_tab;
+	u32 size_poke_tab;
 	struct latch_tree_node ksym_tnode;
 	struct list_head ksym_lnode;
 	const struct bpf_prog_ops *ops;
 	struct bpf_prog_offload *offload;
 	struct btf *btf;
 	struct bpf_func_info *func_info;
+	struct bpf_func_info_aux *func_info_aux;
 	/* bpf_line_info loaded from userspace.  linfo->insn_off
 	 * has the xlated insn offset.
 	 * Both the main and sub prog share the same linfo.
 	 * main prog always has linfo_idx == 0
 	 */
 	u32 linfo_idx;
+	u32 num_exentries;
+	struct exception_table_entry *extable;
 	struct bpf_prog_stats __percpu *stats;
 	union {
 		struct work_struct work;
 	};
 };
+struct bpf_array_aux {
+	/* 'Ownership' of prog array is claimed by the first program that
+	 * is going to use this map or by the first program which FD is
+	 * stored in the map to make sure that all callers and callees have
+	 * the same prog type and JITed flag.
+	 */
+	enum bpf_prog_type type;
+	bool jited;
+	/* Programs with direct jumps into programs part of this array. */
+	struct list_head poke_progs;
+	struct bpf_map *map;
+	struct mutex poke_mutex;
+	struct work_struct work;
+};
 struct bpf_array {
 	struct bpf_map map;
 	u32 elem_size;
 	u32 index_mask;
-	/* 'ownership' of prog_array is claimed by the first program that
+	struct bpf_array_aux *aux;
-	 * is going to use this map or by the first program which FD is stored
-	 * in the map to make sure that all callers and callees have the same
-	 * prog_type and JITed flag
-	 */
-	enum bpf_prog_type owner_prog_type;
-	bool owner_jited;
 	union {
 		char value[0] __aligned(8);
 		void *ptrs[0] __aligned(8);
 bool bpf_prog_array_compatible(struct bpf_array *array, const struct bpf_prog *fp);
 int bpf_prog_calc_tag(struct bpf_prog *fp);
+const char *kernel_type_name(u32 btf_type_id);
 const struct bpf_func_proto *bpf_get_trace_printk_proto(void);
 extern const struct file_operations bpf_map_fops;
 extern const struct file_operations bpf_prog_fops;
-#define BPF_PROG_TYPE(_id, _name) \
+#define BPF_PROG_TYPE(_id, _name, prog_ctx_type, kern_ctx_type) \
 	extern const struct bpf_prog_ops _name ## _prog_ops; \
 	extern const struct bpf_verifier_ops _name ## _verifier_ops;
 #define BPF_MAP_TYPE(_id, _ops) \
 struct bpf_prog *bpf_prog_get(u32 ufd);
 struct bpf_prog *bpf_prog_get_type_dev(u32 ufd, enum bpf_prog_type type,
 				       bool attach_drv);
-struct bpf_prog * __must_check bpf_prog_add(struct bpf_prog *prog, int i);
+void bpf_prog_add(struct bpf_prog *prog, int i);
 void bpf_prog_sub(struct bpf_prog *prog, int i);
-struct bpf_prog * __must_check bpf_prog_inc(struct bpf_prog *prog);
+void bpf_prog_inc(struct bpf_prog *prog);
 struct bpf_prog * __must_check bpf_prog_inc_not_zero(struct bpf_prog *prog);
 void bpf_prog_put(struct bpf_prog *prog);
 int __bpf_prog_charge(struct user_struct *user, u32 pages);
 void __bpf_prog_uncharge(struct user_struct *user, u32 pages);
+void __bpf_free_used_maps(struct bpf_prog_aux *aux,
+			  struct bpf_map **used_maps, u32 len);
 void bpf_prog_free_id(struct bpf_prog *prog, bool do_idr_lock);
 void bpf_map_free_id(struct bpf_map *map, bool do_idr_lock);
 struct bpf_map *bpf_map_get_with_uref(u32 ufd);
 struct bpf_map *__bpf_map_get(struct fd f);
-struct bpf_map * __must_check bpf_map_inc(struct bpf_map *map, bool uref);
+void bpf_map_inc(struct bpf_map *map);
-struct bpf_map * __must_check bpf_map_inc_not_zero(struct bpf_map *map,
+void bpf_map_inc_with_uref(struct bpf_map *map);
-						   bool uref);
+struct bpf_map * __must_check bpf_map_inc_not_zero(struct bpf_map *map);
 void bpf_map_put_with_uref(struct bpf_map *map);
 void bpf_map_put(struct bpf_map *map);
 int bpf_map_charge_memlock(struct bpf_map *map, u32 pages);
 void bpf_map_charge_move(struct bpf_map_memory *dst,
 			 struct bpf_map_memory *src);
 void *bpf_map_area_alloc(u64 size, int numa_node);
+void *bpf_map_area_mmapable_alloc(u64 size, int numa_node);
 void bpf_map_area_free(void *base);
 void bpf_map_init_from_attr(struct bpf_map *map, union bpf_attr *attr);
 int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog,
 				     const union bpf_attr *kattr,
 				     union bpf_attr __user *uattr);
+bool btf_ctx_access(int off, int size, enum bpf_access_type type,
+		    const struct bpf_prog *prog,
+		    struct bpf_insn_access_aux *info);
+int btf_struct_access(struct bpf_verifier_log *log,
+		      const struct btf_type *t, int off, int size,
+		      enum bpf_access_type atype,
+		      u32 *next_btf_id);
+int btf_resolve_helper_id(struct bpf_verifier_log *log,
+			  const struct bpf_func_proto *fn, int);
+int btf_distill_func_proto(struct bpf_verifier_log *log,
+			   struct btf *btf,
+			   const struct btf_type *func_proto,
+			   const char *func_name,
+			   struct btf_func_model *m);
+int btf_check_func_arg_match(struct bpf_verifier_env *env, int subprog);
 #else /* !CONFIG_BPF_SYSCALL */
 static inline struct bpf_prog *bpf_prog_get(u32 ufd)
 {
 	return ERR_PTR(-EOPNOTSUPP);
 }
-static inline struct bpf_prog * __must_check bpf_prog_add(struct bpf_prog *prog,
+static inline void bpf_prog_add(struct bpf_prog *prog, int i)
-							  int i)
 {
-	return ERR_PTR(-EOPNOTSUPP);
 }
 static inline void bpf_prog_sub(struct bpf_prog *prog, int i)
 {
 }
-static inline struct bpf_prog * __must_check bpf_prog_inc(struct bpf_prog *prog)
+static inline void bpf_prog_inc(struct bpf_prog *prog)
 {
-	return ERR_PTR(-EOPNOTSUPP);
 }
 static inline struct bpf_prog *__must_check
 {
 	return -ENOTSUPP;
 }
+static inline void bpf_map_put(struct bpf_map *map)
+{
+}
 #endif /* CONFIG_BPF_SYSCALL */
 static inline struct bpf_prog *bpf_prog_get_type(u32 ufd,
 }
 #endif
-#if defined(CONFIG_XDP_SOCKETS)
-struct xdp_sock;
-struct xdp_sock *__xsk_map_lookup_elem(struct bpf_map *map, u32 key);
-int __xsk_map_redirect(struct bpf_map *map, struct xdp_buff *xdp,
-		       struct xdp_sock *xs);
-void __xsk_map_flush(struct bpf_map *map);
-#else
-struct xdp_sock;
-static inline struct xdp_sock *__xsk_map_lookup_elem(struct bpf_map *map,
-						     u32 key)
-{
-	return NULL;
-}
-static inline int __xsk_map_redirect(struct bpf_map *map, struct xdp_buff *xdp,
-				     struct xdp_sock *xs)
-{
-	return -EOPNOTSUPP;
-}
-static inline void __xsk_map_flush(struct bpf_map *map)
-{
-}
-#endif
 #if defined(CONFIG_INET) && defined(CONFIG_BPF_SYSCALL)
 void bpf_sk_reuseport_detach(struct sock *sk);
 int bpf_fd_reuseport_array_lookup_elem(struct bpf_map *map, void *key,
 #endif
 #ifdef CONFIG_INET
+struct sk_reuseport_kern {
+	struct sk_buff *skb;
+	struct sock *sk;
+	struct sock *selected_sk;
+	void *data_end;
+	u32 hash;
+	u32 reuseport_id;
+	bool bind_inany;
+};
 bool bpf_tcp_sock_is_valid_access(int off, int size, enum bpf_access_type type,
 				  struct bpf_insn_access_aux *info);
 }
 #endif /* CONFIG_INET */
+enum bpf_text_poke_type {
+	BPF_MOD_CALL,
+	BPF_MOD_JUMP,
+};
+int bpf_arch_text_poke(void *ip, enum bpf_text_poke_type t,
+		       void *addr1, void *addr2);
 #endif /* _LINUX_BPF_H */

include/linux/bpf_types.h+52−25

 /* internal file - do not include directly */
 #ifdef CONFIG_NET
-BPF_PROG_TYPE(BPF_PROG_TYPE_SOCKET_FILTER, sk_filter)
+BPF_PROG_TYPE(BPF_PROG_TYPE_SOCKET_FILTER, sk_filter,
-BPF_PROG_TYPE(BPF_PROG_TYPE_SCHED_CLS, tc_cls_act)
+	      struct __sk_buff, struct sk_buff)
-BPF_PROG_TYPE(BPF_PROG_TYPE_SCHED_ACT, tc_cls_act)
+BPF_PROG_TYPE(BPF_PROG_TYPE_SCHED_CLS, tc_cls_act,
-BPF_PROG_TYPE(BPF_PROG_TYPE_XDP, xdp)
+	      struct __sk_buff, struct sk_buff)
+BPF_PROG_TYPE(BPF_PROG_TYPE_SCHED_ACT, tc_cls_act,
+	      struct __sk_buff, struct sk_buff)
+BPF_PROG_TYPE(BPF_PROG_TYPE_XDP, xdp,
+	      struct xdp_md, struct xdp_buff)
 #ifdef CONFIG_CGROUP_BPF
-BPF_PROG_TYPE(BPF_PROG_TYPE_CGROUP_SKB, cg_skb)
+BPF_PROG_TYPE(BPF_PROG_TYPE_CGROUP_SKB, cg_skb,
-BPF_PROG_TYPE(BPF_PROG_TYPE_CGROUP_SOCK, cg_sock)
+	      struct __sk_buff, struct sk_buff)
-BPF_PROG_TYPE(BPF_PROG_TYPE_CGROUP_SOCK_ADDR, cg_sock_addr)
+BPF_PROG_TYPE(BPF_PROG_TYPE_CGROUP_SOCK, cg_sock,
+	      struct bpf_sock, struct sock)
+BPF_PROG_TYPE(BPF_PROG_TYPE_CGROUP_SOCK_ADDR, cg_sock_addr,
+	      struct bpf_sock_addr, struct bpf_sock_addr_kern)
 #endif
-BPF_PROG_TYPE(BPF_PROG_TYPE_LWT_IN, lwt_in)
+BPF_PROG_TYPE(BPF_PROG_TYPE_LWT_IN, lwt_in,
-BPF_PROG_TYPE(BPF_PROG_TYPE_LWT_OUT, lwt_out)
+	      struct __sk_buff, struct sk_buff)
-BPF_PROG_TYPE(BPF_PROG_TYPE_LWT_XMIT, lwt_xmit)
+BPF_PROG_TYPE(BPF_PROG_TYPE_LWT_OUT, lwt_out,
-BPF_PROG_TYPE(BPF_PROG_TYPE_LWT_SEG6LOCAL, lwt_seg6local)
+	      struct __sk_buff, struct sk_buff)
-BPF_PROG_TYPE(BPF_PROG_TYPE_SOCK_OPS, sock_ops)
+BPF_PROG_TYPE(BPF_PROG_TYPE_LWT_XMIT, lwt_xmit,
-BPF_PROG_TYPE(BPF_PROG_TYPE_SK_SKB, sk_skb)
+	      struct __sk_buff, struct sk_buff)
-BPF_PROG_TYPE(BPF_PROG_TYPE_SK_MSG, sk_msg)
+BPF_PROG_TYPE(BPF_PROG_TYPE_LWT_SEG6LOCAL, lwt_seg6local,
-BPF_PROG_TYPE(BPF_PROG_TYPE_FLOW_DISSECTOR, flow_dissector)
+	      struct __sk_buff, struct sk_buff)
+BPF_PROG_TYPE(BPF_PROG_TYPE_SOCK_OPS, sock_ops,
+	      struct bpf_sock_ops, struct bpf_sock_ops_kern)
+BPF_PROG_TYPE(BPF_PROG_TYPE_SK_SKB, sk_skb,
+	      struct __sk_buff, struct sk_buff)
+BPF_PROG_TYPE(BPF_PROG_TYPE_SK_MSG, sk_msg,
+	      struct sk_msg_md, struct sk_msg)
+BPF_PROG_TYPE(BPF_PROG_TYPE_FLOW_DISSECTOR, flow_dissector,
+	      struct __sk_buff, struct bpf_flow_dissector)
 #endif
 #ifdef CONFIG_BPF_EVENTS
-BPF_PROG_TYPE(BPF_PROG_TYPE_KPROBE, kprobe)
+BPF_PROG_TYPE(BPF_PROG_TYPE_KPROBE, kprobe,
-BPF_PROG_TYPE(BPF_PROG_TYPE_TRACEPOINT, tracepoint)
+	      bpf_user_pt_regs_t, struct pt_regs)
-BPF_PROG_TYPE(BPF_PROG_TYPE_PERF_EVENT, perf_event)
+BPF_PROG_TYPE(BPF_PROG_TYPE_TRACEPOINT, tracepoint,
-BPF_PROG_TYPE(BPF_PROG_TYPE_RAW_TRACEPOINT, raw_tracepoint)
+	      __u64, u64)
-BPF_PROG_TYPE(BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE, raw_tracepoint_writable)
+BPF_PROG_TYPE(BPF_PROG_TYPE_PERF_EVENT, perf_event,
+	      struct bpf_perf_event_data, struct bpf_perf_event_data_kern)
+BPF_PROG_TYPE(BPF_PROG_TYPE_RAW_TRACEPOINT, raw_tracepoint,
+	      struct bpf_raw_tracepoint_args, u64)
+BPF_PROG_TYPE(BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE, raw_tracepoint_writable,
+	      struct bpf_raw_tracepoint_args, u64)
+BPF_PROG_TYPE(BPF_PROG_TYPE_TRACING, tracing,
+	      void *, void *)
 #endif
 #ifdef CONFIG_CGROUP_BPF
-BPF_PROG_TYPE(BPF_PROG_TYPE_CGROUP_DEVICE, cg_dev)
+BPF_PROG_TYPE(BPF_PROG_TYPE_CGROUP_DEVICE, cg_dev,
-BPF_PROG_TYPE(BPF_PROG_TYPE_CGROUP_SYSCTL, cg_sysctl)
+	      struct bpf_cgroup_dev_ctx, struct bpf_cgroup_dev_ctx)
-BPF_PROG_TYPE(BPF_PROG_TYPE_CGROUP_SOCKOPT, cg_sockopt)
+BPF_PROG_TYPE(BPF_PROG_TYPE_CGROUP_SYSCTL, cg_sysctl,
+	      struct bpf_sysctl, struct bpf_sysctl_kern)
+BPF_PROG_TYPE(BPF_PROG_TYPE_CGROUP_SOCKOPT, cg_sockopt,
+	      struct bpf_sockopt, struct bpf_sockopt_kern)
 #endif
 #ifdef CONFIG_BPF_LIRC_MODE2
-BPF_PROG_TYPE(BPF_PROG_TYPE_LIRC_MODE2, lirc_mode2)
+BPF_PROG_TYPE(BPF_PROG_TYPE_LIRC_MODE2, lirc_mode2,
+	      __u32, u32)
 #endif
 #ifdef CONFIG_INET
-BPF_PROG_TYPE(BPF_PROG_TYPE_SK_REUSEPORT, sk_reuseport)
+BPF_PROG_TYPE(BPF_PROG_TYPE_SK_REUSEPORT, sk_reuseport,
+	      struct sk_reuseport_md, struct sk_reuseport_kern)
 #endif
 BPF_MAP_TYPE(BPF_MAP_TYPE_ARRAY, array_map_ops)

include/linux/bpf_verifier.h+10−2

 		 */
 		struct bpf_map *map_ptr;
+		u32 btf_id; /* for PTR_TO_BTF_ID */
 		/* Max size from any of the above. */
 		unsigned long raw;
 	};
 struct bpf_insn_aux_data {
 	union {
 		enum bpf_reg_type ptr_type;	/* pointer type for load/store insns */
-		unsigned long map_state;	/* pointer/poison value for maps */
+		unsigned long map_ptr_state;	/* pointer/poison value for maps */
 		s32 call_imm;			/* saved imm field of call insn */
 		u32 alu_limit;			/* limit for add/sub register with pointer */
 		struct {
 			u32 map_off;		/* offset from value base address */
 		};
 	};
+	u64 map_key_state; /* constant (32 bit) key tracking for maps */
 	int ctx_field_size; /* the ctx field size for load insn, maybe 0 */
 	int sanitize_stack_off; /* stack slot to be cleared */
 	bool seen; /* this insn was processed by the verifier */
 #define BPF_LOG_STATS	4
 #define BPF_LOG_LEVEL	(BPF_LOG_LEVEL1 | BPF_LOG_LEVEL2)
 #define BPF_LOG_MASK	(BPF_LOG_LEVEL | BPF_LOG_STATS)
+#define BPF_LOG_KERNEL	(BPF_LOG_MASK + 1) /* kernel internal flag */
 static inline bool bpf_verifier_log_needed(const struct bpf_verifier_log *log)
 {
-	return log->level && log->ubuf && !bpf_verifier_log_full(log);
+	return (log->level && log->ubuf && !bpf_verifier_log_full(log)) ||
+		log->level == BPF_LOG_KERNEL;
 }
 #define BPF_MAX_SUBPROGS 256
 struct bpf_subprog_info {
+	/* 'start' has to be the first field otherwise find_subprog() won't work */
 	u32 start; /* insn idx of function entry point */
 	u32 linfo_idx; /* The idx to the main_prog->aux->linfo */
 	u16 stack_depth; /* max. stack depth used by this function */
 				      const char *fmt, va_list args);
 __printf(2, 3) void bpf_verifier_log_write(struct bpf_verifier_env *env,
 					   const char *fmt, ...);
+__printf(2, 3) void bpf_log(struct bpf_verifier_log *log,
+			    const char *fmt, ...);
 static inline struct bpf_func_state *cur_func(struct bpf_verifier_env *env)
 {

include/linux/brcmphy.h+8−2

 #define BCM5482_SHD_SSD		0x14	/* 10100: Secondary SerDes control */
 #define BCM5482_SHD_SSD_LEDM	0x0008	/* SSD LED Mode enable */
 #define BCM5482_SHD_SSD_EN	0x0001	/* SSD enable */
-#define BCM5482_SHD_MODE	0x1f	/* 11111: Mode Control Register */
-#define BCM5482_SHD_MODE_1000BX	0x0001	/* Enable 1000BASE-X registers */
+/* 10011: SerDes 100-FX Control Register */
+#define BCM54616S_SHD_100FX_CTRL	0x13
+#define	BCM54616S_100FX_MODE		BIT(0)	/* 100-FX SerDes Enable */
+/* 11111: Mode Control Register */
+#define BCM54XX_SHD_MODE		0x1f
+#define BCM54XX_SHD_INTF_SEL_MASK	GENMASK(2, 1)	/* INTERF_SEL[1:0] */
+#define BCM54XX_SHD_MODE_1000BX		BIT(0)	/* Enable 1000-X registers */
 /*
  * EXPANSION SHADOW ACCESS REGISTERS.  (PHY REG 0x15, 0x16, and 0x17)

include/linux/bsearch.h+1−1

@@ -5,6 +5,6 @@ · 4 unmodified lines
5	#include <linux/types.h>	5	#include <linux/types.h>
6		6
7	void bsearch(const void key, const void *base, size_t num, size_t size,	7	void bsearch(const void key, const void *base, size_t num, size_t size,
8	int (cmp)(const void key, const void *elt));	8	cmp_func_t cmp);
9		9
10	#endif /* _LINUX_BSEARCH_H */	10	#endif /* _LINUX_BSEARCH_H */

include/linux/btf.h+33−0

@@ -5,6 +5,7 @@ · 4 unmodified lines
5	#define _LINUX_BTF_H 1	5	#define _LINUX_BTF_H 1
6		6
7	#include <linux/types.h>	7	#include <linux/types.h>
		8	#include <uapi/linux/btf.h>
8		9
9	struct btf;	10	struct btf;
10	struct btf_member;	11	struct btf_member;
@@ -53,9 +54,41 @@ bool btf_member_is_reg_int(const struct btf btf, const struct btf_type s, · 42 unmodified lines
53	int btf_find_spin_lock(const struct btf btf, const struct btf_type t);	54	int btf_find_spin_lock(const struct btf btf, const struct btf_type t);
54	bool btf_type_is_void(const struct btf_type *t);	55	bool btf_type_is_void(const struct btf_type *t);
55		56
		57	static inline bool btf_type_is_ptr(const struct btf_type *t)
		58	{
		59	return BTF_INFO_KIND(t->info) == BTF_KIND_PTR;
		60	}
		61
		62	static inline bool btf_type_is_int(const struct btf_type *t)
		63	{
		64	return BTF_INFO_KIND(t->info) == BTF_KIND_INT;
		65	}
		66
		67	static inline bool btf_type_is_enum(const struct btf_type *t)
		68	{
		69	return BTF_INFO_KIND(t->info) == BTF_KIND_ENUM;
		70	}
		71
		72	static inline bool btf_type_is_typedef(const struct btf_type *t)
		73	{
		74	return BTF_INFO_KIND(t->info) == BTF_KIND_TYPEDEF;
		75	}
		76
		77	static inline bool btf_type_is_func(const struct btf_type *t)
		78	{
		79	return BTF_INFO_KIND(t->info) == BTF_KIND_FUNC;
		80	}
		81
		82	static inline bool btf_type_is_func_proto(const struct btf_type *t)
		83	{
		84	return BTF_INFO_KIND(t->info) == BTF_KIND_FUNC_PROTO;
		85	}
		86
56	#ifdef CONFIG_BPF_SYSCALL	87	#ifdef CONFIG_BPF_SYSCALL
57	const struct btf_type btf_type_by_id(const struct btf btf, u32 type_id);	88	const struct btf_type btf_type_by_id(const struct btf btf, u32 type_id);
58	const char btf_name_by_offset(const struct btf btf, u32 offset);	89	const char btf_name_by_offset(const struct btf btf, u32 offset);
		90	struct btf *btf_parse_vmlinux(void);
		91	struct btf bpf_prog_get_target_btf(const struct bpf_prog prog);
59	#else	92	#else
60	static inline const struct btf_type btf_type_by_id(const struct btf btf,	93	static inline const struct btf_type btf_type_by_id(const struct btf btf,
61	u32 type_id)	94	u32 type_id)

include/linux/build_bug.h+2−2

@@ -9,11 +9,11 @@ · 8 unmodified lines
9	#else /* __CHECKER__ */	9	#else /* __CHECKER__ */
10	/*	10	/*
11	* Force a compilation error if condition is true, but also produce a	11	* Force a compilation error if condition is true, but also produce a
12	* result (of value 0 and type size_t), so the expression can be used	12	* result (of value 0 and type int), so the expression can be used
13	* e.g. in a structure initializer (or where-ever else comma expressions	13	* e.g. in a structure initializer (or where-ever else comma expressions
14	* aren't permitted).	14	* aren't permitted).
15	*/	15	*/
16	#define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:(-!!(e)); }))	16	#define BUILD_BUG_ON_ZERO(e) ((int)(sizeof(struct { int:(-!!(e)); })))
17	#endif /* __CHECKER__ */	17	#endif /* __CHECKER__ */
18		18
19	/* Force a compilation error if a constant expression is not a power of 2 */	19	/* Force a compilation error if a constant expression is not a power of 2 */

include/linux/bvec.h+10−12

 static inline bool bvec_iter_advance(const struct bio_vec *bv,
 		struct bvec_iter *iter, unsigned bytes)
 {
+	unsigned int idx = iter->bi_idx;
 	if (WARN_ONCE(bytes > iter->bi_size,
 		     "Attempted to advance past end of bvec iter\n")) {
 		iter->bi_size = 0;
 		return false;
 	}
-	while (bytes) {
+	iter->bi_size -= bytes;
-		const struct bio_vec *cur = bv + iter->bi_idx;
+	bytes += iter->bi_bvec_done;
-		unsigned len = min3(bytes, iter->bi_size,
-				    cur->bv_len - iter->bi_bvec_done);
-		bytes -= len;
-		iter->bi_size -= len;
-		iter->bi_bvec_done += len;
-		if (iter->bi_bvec_done == cur->bv_len) {
+	while (bytes && bytes >= bv[idx].bv_len) {
-			iter->bi_bvec_done = 0;
+		bytes -= bv[idx].bv_len;
-			iter->bi_idx++;
+		idx++;
-		}
 	}
+	iter->bi_idx = idx;
+	iter->bi_bvec_done = bytes;
 	return true;
 }

include/linux/can/platform/mcp251x.h+0−22

@@ -1,22 +0,0 @@
1	/* SPDX-License-Identifier: GPL-2.0 */
2	#ifndef _CAN_PLATFORM_MCP251X_H
3	#define _CAN_PLATFORM_MCP251X_H
4
5	/*
6	*
7	* CAN bus driver for Microchip 251x CAN Controller with SPI Interface
8	*
9	*/
10
11	#include <linux/spi/spi.h>
12
13	/*
14	* struct mcp251x_platform_data - MCP251X SPI CAN controller platform data
15	* @oscillator_frequency: - oscillator frequency in Hz
16	*/
17
18	struct mcp251x_platform_data {
19	unsigned long oscillator_frequency;
20	};
21
22	#endif /* !_CAN_PLATFORM_MCP251X_H */

include/linux/can/rx-offload.h+3−4

 struct can_rx_offload {
 	struct net_device *dev;
-	unsigned int (*mailbox_read)(struct can_rx_offload *offload,
+	struct sk_buff *(*mailbox_read)(struct can_rx_offload *offload,
-				     struct can_frame *cf,
+					unsigned int mb, u32 *timestamp,
-				     u32 *timestamp, unsigned int mb);
+					bool drop);
 	struct sk_buff_head skb_queue;
 	u32 skb_queue_len_max;
 					 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/libceph.h+6−4

 extern int ceph_check_fsid(struct ceph_client *client, struct ceph_fsid *fsid);
 extern void *ceph_kvmalloc(size_t size, gfp_t flags);
-extern struct ceph_options *ceph_parse_options(char *options,
+struct fs_parameter;
-			      const char *dev_name, const char *dev_name_end,
+struct ceph_options *ceph_alloc_options(void);
-			      int (*parse_extra_token)(char *c, void *private),
+int ceph_parse_mon_ips(const char *buf, size_t len, struct ceph_options *opt,
-			      void *private);
+		       struct fs_context *fc);
+int ceph_parse_param(struct fs_parameter *param, struct ceph_options *opt,
+		     struct fs_context *fc);
 int ceph_print_client_options(struct seq_file *m, struct ceph_client *client,
 			      bool show_all);
 extern void ceph_destroy_options(struct ceph_options *opt);

include/linux/cgroup-defs.h+3−16

 	unsigned long flags;		/* "unsigned long" so bitops work */
-	/*
-	 * idr allocated in-hierarchy ID.
-	 *
-	 * ID 0 is not used, the ID of the root cgroup is always 1, and a
-	 * new cgroup will be assigned with a smallest available ID.
-	 *
-	 * Allocating/Removing ID must be protected by cgroup_mutex.
-	 */
-	int id;
 	/*
 	 * The depth this cgroup is at.  The root is at depth zero and each
 	 * step down the hierarchy increments the level.  This along with
 	struct list_head rstat_css_list;
 	/* cgroup basic resource statistics */
-	struct cgroup_base_stat pending_bstat;	/* pending from children */
+	struct cgroup_base_stat last_bstat;
 	struct cgroup_base_stat bstat;
 	struct prev_cputime prev_cputime;	/* for printing out cputime */
 	struct cgroup_freezer_state freezer;
 	/* ids of the ancestors at each level including self */
-	int ancestor_ids[];
+	u64 ancestor_ids[];
 };
 /*
 	struct cgroup cgrp;
 	/* for cgrp->ancestor_ids[0] */
-	int cgrp_ancestor_id_storage;
+	u64 cgrp_ancestor_id_storage;
 	/* Number of cgroups in the hierarchy, used only for /proc/cgroups */
 	atomic_t nr_cgrps;
 	/* Hierarchy-specific flags */
 	unsigned int flags;
-	/* IDs for cgroups in this hierarchy */
-	struct idr cgroup_idr;
 	/* The path to use for release notifications. */
 	char release_agent_path[PATH_MAX];

include/linux/cgroup.h+11−16

 struct task_struct *cgroup_taskset_next(struct cgroup_taskset *tset,
 					struct cgroup_subsys_state **dst_cssp);
-void cgroup_enable_task_cg_lists(void);
 void css_task_iter_start(struct cgroup_subsys_state *css, unsigned int flags,
 			 struct css_task_iter *it);
 struct task_struct *css_task_iter_next(struct css_task_iter *it);
  * Inline functions.
  */
+static inline u64 cgroup_id(struct cgroup *cgrp)
+{
+	return cgrp->kn->id;
+}
 /**
  * css_get - obtain a reference on the specified css
  * @css: target css
 {
 	if (cgrp->root != ancestor->root || cgrp->level < ancestor->level)
 		return false;
-	return cgrp->ancestor_ids[ancestor->level] == ancestor->id;
+	return cgrp->ancestor_ids[ancestor->level] == cgroup_id(ancestor);
 }
 /**
 /* returns ino associated with a cgroup */
 static inline ino_t cgroup_ino(struct cgroup *cgrp)
 {
-	return cgrp->kn->id.ino;
+	return kernfs_ino(cgrp->kn);
 }
 /* cft/css accessors for cftype->write() operation */
 	current->no_cgroup_migration = 0;
 }
-static inline union kernfs_node_id *cgroup_get_kernfs_id(struct cgroup *cgrp)
+void cgroup_path_from_kernfs_id(u64 id, char *buf, size_t buflen);
-{
-	return &cgrp->kn->id;
-}
-void cgroup_path_from_kernfs_id(const union kernfs_node_id *id,
-					char *buf, size_t buflen);
 #else /* !CONFIG_CGROUPS */
 struct cgroup_subsys_state;
 struct cgroup;
+static inline u64 cgroup_id(struct cgroup *cgrp) { return 1; }
 static inline void css_get(struct cgroup_subsys_state *css) {}
 static inline void css_put(struct cgroup_subsys_state *css) {}
 static inline int cgroup_attach_task_all(struct task_struct *from,
 static inline int cgroup_init(void) { return 0; }
 static inline void cgroup_init_kthreadd(void) {}
 static inline void cgroup_kthread_ready(void) {}
-static inline union kernfs_node_id *cgroup_get_kernfs_id(struct cgroup *cgrp)
-{
-	return NULL;
-}
 static inline struct cgroup *cgroup_parent(struct cgroup *cgrp)
 {
 	return true;
 }
-static inline void cgroup_path_from_kernfs_id(const union kernfs_node_id *id,
+static inline void cgroup_path_from_kernfs_id(u64 id, char *buf, size_t buflen)
-	char *buf, size_t buflen) {}
+{}
 #endif /* !CONFIG_CGROUPS */
 #ifdef CONFIG_CGROUPS

include/linux/clk-provider.h+1−0

@@ -818,6 +818,7 @@ unsigned int clk_hw_get_num_parents(const struct clk_hw *hw); · 817 unmodified lines
818	struct clk_hw clk_hw_get_parent(const struct clk_hw hw);	818	struct clk_hw clk_hw_get_parent(const struct clk_hw hw);
819	struct clk_hw clk_hw_get_parent_by_index(const struct clk_hw hw,	819	struct clk_hw clk_hw_get_parent_by_index(const struct clk_hw hw,
820	unsigned int index);	820	unsigned int index);
		821	int clk_hw_get_parent_index(struct clk_hw *hw);
821	int clk_hw_set_parent(struct clk_hw hw, struct clk_hw new_parent);	822	int clk_hw_set_parent(struct clk_hw hw, struct clk_hw new_parent);
822	unsigned int __clk_get_enable_count(struct clk *clk);	823	unsigned int __clk_get_enable_count(struct clk *clk);
823	unsigned long clk_hw_get_rate(const struct clk_hw *hw);	824	unsigned long clk_hw_get_rate(const struct clk_hw *hw);

include/linux/clk/tegra.h+24−0

@@ -108,6 +108,19 @@ static inline void tegra_cpu_clock_resume(void) · 107 unmodified lines
108		108
109	tegra_cpu_car_ops->resume();	109	tegra_cpu_car_ops->resume();
110	}	110	}
		111	#else
		112	static inline bool tegra_cpu_rail_off_ready(void)
		113	{
		114	return false;
		115	}
		116
		117	static inline void tegra_cpu_clock_suspend(void)
		118	{
		119	}
		120
		121	static inline void tegra_cpu_clock_resume(void)
		122	{
		123	}
111	#endif	124	#endif
112		125
113	extern void tegra210_xusb_pll_hw_control_enable(void);	126	extern void tegra210_xusb_pll_hw_control_enable(void);
@@ -119,4 +132,15 @@ extern void tegra210_put_utmipll_in_iddq(void); · 5 unmodified lines
119	extern void tegra210_put_utmipll_out_iddq(void);	132	extern void tegra210_put_utmipll_out_iddq(void);
120	extern int tegra210_clk_handle_mbist_war(unsigned int id);	133	extern int tegra210_clk_handle_mbist_war(unsigned int id);
121		134
		135	struct clk;
		136
		137	typedef long (tegra20_clk_emc_round_cb)(unsigned long rate,
		138	unsigned long min_rate,
		139	unsigned long max_rate,
		140	void *arg);
		141
		142	void tegra20_clk_set_emc_round_callback(tegra20_clk_emc_round_cb *round_cb,
		143	void *cb_arg);
		144	int tegra20_clk_prepare_emc_mc_same_freq(struct clk *emc_clk, bool same);
		145
122	#endif /* __LINUX_CLK_TEGRA_H_ */	146	#endif /* __LINUX_CLK_TEGRA_H_ */

include/linux/clk/ti.h+2−1

 	u8			fixed_div;
 	struct clk_omap_reg	enable_reg;
 	u8			enable_bit;
-	u8			flags;
+	unsigned long		flags;
 	struct clk_omap_reg	clksel_reg;
 	struct dpll_data	*dpll_data;
 	const char		*clkdm_name;
 void ti_clk_setup_features(struct ti_clk_features *features);
 const struct ti_clk_features *ti_clk_get_features(void);
+bool ti_clk_is_in_standby(struct clk *clk);
 int omap3_noncore_dpll_save_context(struct clk_hw *hw);
 void omap3_noncore_dpll_restore_context(struct clk_hw *hw);

include/linux/compat.h+6−15

 struct compat_sel_arg_struct;
 struct rusage;
-struct compat_itimerval {
+struct old_itimerval32;
-	struct old_timeval32	it_interval;
-	struct old_timeval32	it_value;
-};
-struct itimerval;
-int get_compat_itimerval(struct itimerval *, const struct compat_itimerval __user *);
-int put_compat_itimerval(struct compat_itimerval __user *, const struct itimerval *);
 struct compat_tms {
 	compat_clock_t		tms_utime;
 struct compat_mq_attr;
 struct compat_msgbuf;
-extern void compat_exit_robust_list(struct task_struct *curr);
 #define BITS_PER_COMPAT_LONG    (8*sizeof(compat_long_t))
 #define BITS_TO_COMPAT_LONGS(bits) DIV_ROUND_UP(bits, BITS_PER_COMPAT_LONG)
 /* kernel/itimer.c */
 asmlinkage long compat_sys_getitimer(int which,
-				     struct compat_itimerval __user *it);
+				     struct old_itimerval32 __user *it);
 asmlinkage long compat_sys_setitimer(int which,
-				     struct compat_itimerval __user *in,
+				     struct old_itimerval32 __user *in,
-				     struct compat_itimerval __user *out);
+				     struct old_itimerval32 __user *out);
 /* kernel/kexec.c */
 asmlinkage long compat_sys_kexec_load(compat_ulong_t entry,
  */
 static inline struct old_timeval32 ns_to_old_timeval32(s64 nsec)
 {
-	struct timeval tv;
+	struct __kernel_old_timeval tv;
 	struct old_timeval32 ctv;
-	tv = ns_to_timeval(nsec);
+	tv = ns_to_kernel_old_timeval(nsec);
 	ctv.tv_sec = tv.tv_sec;
 	ctv.tv_usec = tv.tv_usec;

include/linux/context_tracking.h+15−15

@@ -22,26 +22,26 @@ extern void context_tracking_user_exit(void); · 21 unmodified lines
22		22
23	static inline void user_enter(void)	23	static inline void user_enter(void)
24	{	24	{
25	if (context_tracking_is_enabled())	25	if (context_tracking_enabled())
26	context_tracking_enter(CONTEXT_USER);	26	context_tracking_enter(CONTEXT_USER);
27		27
28	}	28	}
29	static inline void user_exit(void)	29	static inline void user_exit(void)
30	{	30	{
31	if (context_tracking_is_enabled())	31	if (context_tracking_enabled())
32	context_tracking_exit(CONTEXT_USER);	32	context_tracking_exit(CONTEXT_USER);
33	}	33	}
34		34
35	/* Called with interrupts disabled. */	35	/* Called with interrupts disabled. */
36	static inline void user_enter_irqoff(void)	36	static inline void user_enter_irqoff(void)
37	{	37	{
38	if (context_tracking_is_enabled())	38	if (context_tracking_enabled())
39	__context_tracking_enter(CONTEXT_USER);	39	__context_tracking_enter(CONTEXT_USER);
40		40
41	}	41	}
42	static inline void user_exit_irqoff(void)	42	static inline void user_exit_irqoff(void)
43	{	43	{
44	if (context_tracking_is_enabled())	44	if (context_tracking_enabled())
45	__context_tracking_exit(CONTEXT_USER);	45	__context_tracking_exit(CONTEXT_USER);
46	}	46	}
47		47
@@ -49,7 +49,7 @@ static inline enum ctx_state exception_enter(void) · 1 unmodified line
49	{	49	{
50	enum ctx_state prev_ctx;	50	enum ctx_state prev_ctx;
51		51
52	if (!context_tracking_is_enabled())	52	if (!context_tracking_enabled())
53	return 0;	53	return 0;
54		54
55	prev_ctx = this_cpu_read(context_tracking.state);	55	prev_ctx = this_cpu_read(context_tracking.state);
@@ -61,7 +61,7 @@ static inline enum ctx_state exception_enter(void) · 5 unmodified lines
61		61
62	static inline void exception_exit(enum ctx_state prev_ctx)	62	static inline void exception_exit(enum ctx_state prev_ctx)
63	{	63	{
64	if (context_tracking_is_enabled()) {	64	if (context_tracking_enabled()) {
65	if (prev_ctx != CONTEXT_KERNEL)	65	if (prev_ctx != CONTEXT_KERNEL)
66	context_tracking_enter(prev_ctx);	66	context_tracking_enter(prev_ctx);
67	}	67	}
@@ -77,7 +77,7 @@ static inline void exception_exit(enum ctx_state prev_ctx) · 9 unmodified lines
77	*/	77	*/
78	static inline enum ctx_state ct_state(void)	78	static inline enum ctx_state ct_state(void)
79	{	79	{
80	return context_tracking_is_enabled() ?	80	return context_tracking_enabled() ?
81	this_cpu_read(context_tracking.state) : CONTEXT_DISABLED;	81	this_cpu_read(context_tracking.state) : CONTEXT_DISABLED;
82	}	82	}
83	#else	83	#else
@@ -90,7 +90,7 @@ static inline void exception_exit(enum ctx_state prev_ctx) { } · 6 unmodified lines
90	static inline enum ctx_state ct_state(void) { return CONTEXT_DISABLED; }	90	static inline enum ctx_state ct_state(void) { return CONTEXT_DISABLED; }
91	#endif /* !CONFIG_CONTEXT_TRACKING */	91	#endif /* !CONFIG_CONTEXT_TRACKING */
92		92
93	#define CT_WARN_ON(cond) WARN_ON(context_tracking_is_enabled() && (cond))	93	#define CT_WARN_ON(cond) WARN_ON(context_tracking_enabled() && (cond))
94		94
95	#ifdef CONFIG_CONTEXT_TRACKING_FORCE	95	#ifdef CONFIG_CONTEXT_TRACKING_FORCE
96	extern void context_tracking_init(void);	96	extern void context_tracking_init(void);
@@ -103,12 +103,12 @@ static inline void context_tracking_init(void) { } · 6 unmodified lines
103	/* must be called with irqs disabled */	103	/* must be called with irqs disabled */
104	static inline void guest_enter_irqoff(void)	104	static inline void guest_enter_irqoff(void)
105	{	105	{
106	if (vtime_accounting_cpu_enabled())	106	if (vtime_accounting_enabled_this_cpu())
107	vtime_guest_enter(current);	107	vtime_guest_enter(current);
108	else	108	else
109	current->flags \|= PF_VCPU;	109	current->flags \|= PF_VCPU;
110		110
111	if (context_tracking_is_enabled())	111	if (context_tracking_enabled())
112	__context_tracking_enter(CONTEXT_GUEST);	112	__context_tracking_enter(CONTEXT_GUEST);
113		113
114	/* KVM does not hold any references to rcu protected data when it	114	/* KVM does not hold any references to rcu protected data when it
@@ -118,16 +118,16 @@ static inline void guest_enter_irqoff(void) · 3 unmodified lines
118	* one time slice). Lets treat guest mode as quiescent state, just like	118	* one time slice). Lets treat guest mode as quiescent state, just like
119	* we do with user-mode execution.	119	* we do with user-mode execution.
120	*/	120	*/
121	if (!context_tracking_cpu_is_enabled())	121	if (!context_tracking_enabled_this_cpu())
122	rcu_virt_note_context_switch(smp_processor_id());	122	rcu_virt_note_context_switch(smp_processor_id());
123	}	123	}
124		124
125	static inline void guest_exit_irqoff(void)	125	static inline void guest_exit_irqoff(void)
126	{	126	{
127	if (context_tracking_is_enabled())	127	if (context_tracking_enabled())
128	__context_tracking_exit(CONTEXT_GUEST);	128	__context_tracking_exit(CONTEXT_GUEST);
129		129
130	if (vtime_accounting_cpu_enabled())	130	if (vtime_accounting_enabled_this_cpu())
131	vtime_guest_exit(current);	131	vtime_guest_exit(current);
132	else	132	else
133	current->flags &= ~PF_VCPU;	133	current->flags &= ~PF_VCPU;
@@ -141,7 +141,7 @@ static inline void guest_enter_irqoff(void) · 7 unmodified lines
141	* to assume that it's the stime pending cputime	141	* to assume that it's the stime pending cputime
142	* to flush.	142	* to flush.
143	*/	143	*/
144	vtime_account_system(current);	144	vtime_account_kernel(current);
145	current->flags \|= PF_VCPU;	145	current->flags \|= PF_VCPU;
146	rcu_virt_note_context_switch(smp_processor_id());	146	rcu_virt_note_context_switch(smp_processor_id());
147	}	147	}
@@ -149,7 +149,7 @@ static inline void guest_enter_irqoff(void) · 1 unmodified line
149	static inline void guest_exit_irqoff(void)	149	static inline void guest_exit_irqoff(void)
150	{	150	{
151	/* Flush the guest cputime we spent on the guest */	151	/* Flush the guest cputime we spent on the guest */
152	vtime_account_system(current);	152	vtime_account_kernel(current);
153	current->flags &= ~PF_VCPU;	153	current->flags &= ~PF_VCPU;
154	}	154	}
155	#endif /* CONFIG_VIRT_CPU_ACCOUNTING_GEN */	155	#endif /* CONFIG_VIRT_CPU_ACCOUNTING_GEN */

include/linux/context_tracking_state.h+13−8

 };
 #ifdef CONFIG_CONTEXT_TRACKING
-extern struct static_key_false context_tracking_enabled;
+extern struct static_key_false context_tracking_key;
 DECLARE_PER_CPU(struct context_tracking, context_tracking);
-static inline bool context_tracking_is_enabled(void)
+static inline bool context_tracking_enabled(void)
 {
-	return static_branch_unlikely(&context_tracking_enabled);
+	return static_branch_unlikely(&context_tracking_key);
 }
-static inline bool context_tracking_cpu_is_enabled(void)
+static inline bool context_tracking_enabled_cpu(int cpu)
 {
-	return __this_cpu_read(context_tracking.active);
+	return context_tracking_enabled() && per_cpu(context_tracking.active, cpu);
+}
+static inline bool context_tracking_enabled_this_cpu(void)
+{
+	return context_tracking_enabled() && __this_cpu_read(context_tracking.active);
 }
 static inline bool context_tracking_in_user(void)
 }
 #else
 static inline bool context_tracking_in_user(void) { return false; }
-static inline bool context_tracking_active(void) { return false; }
+static inline bool context_tracking_enabled(void) { return false; }
-static inline bool context_tracking_is_enabled(void) { return false; }
+static inline bool context_tracking_enabled_cpu(int cpu) { return false; }
-static inline bool context_tracking_cpu_is_enabled(void) { return false; }
+static inline bool context_tracking_enabled_this_cpu(void) { return false; }
 #endif /* CONFIG_CONTEXT_TRACKING */
 #endif

include/linux/coresight.h+6−0

 extern void coresight_disclaim_device_unlocked(void __iomem *base);
 extern char *coresight_alloc_device_name(struct coresight_dev_list *devs,
 					 struct device *dev);
+extern bool coresight_loses_context_with_cpu(struct device *dev);
 #else
 static inline struct coresight_device *
 coresight_register(struct coresight_desc *desc) { return NULL; }
 static inline void coresight_disclaim_device(void __iomem *base) {}
 static inline void coresight_disclaim_device_unlocked(void __iomem *base) {}
+static inline bool coresight_loses_context_with_cpu(struct device *dev)
+{
+	return false;
+}
 #endif
 extern int coresight_get_cpu(struct device *dev);

include/linux/counter.h+10−66

@@ -290,53 +290,22 @@ struct counter_device_state { · 289 unmodified lines
290	const struct attribute_group **groups;	290	const struct attribute_group **groups;
291	};	291	};
292		292
293	/**	293	enum counter_signal_value {
294	* struct counter_signal_read_value - Opaque Signal read value	294	COUNTER_SIGNAL_LOW = 0,
295	* @buf: string representation of Signal read value	295	COUNTER_SIGNAL_HIGH
296	* @len: length of string in @buf
297	*/
298	struct counter_signal_read_value {
299	char *buf;
300	size_t len;
301	};
302
303	/**
304	* struct counter_count_read_value - Opaque Count read value
305	* @buf: string representation of Count read value
306	* @len: length of string in @buf
307	*/
308	struct counter_count_read_value {
309	char *buf;
310	size_t len;
311	};
312
313	/**
314	* struct counter_count_write_value - Opaque Count write value
315	* @buf: string representation of Count write value
316	*/
317	struct counter_count_write_value {
318	const char *buf;
319	};	296	};
320		297
321	/**	298	/**
322	* struct counter_ops - Callbacks from driver	299	* struct counter_ops - Callbacks from driver
323	* @signal_read: optional read callback for Signal attribute. The read	300	* @signal_read: optional read callback for Signal attribute. The read
324	* value of the respective Signal should be passed back via	301	* value of the respective Signal should be passed back via
325	* the val parameter. val points to an opaque type which	302	* the val parameter.
326	* should be set only by calling the
327	* counter_signal_read_value_set function from within the
328	* signal_read callback.
329	* @count_read: optional read callback for Count attribute. The read	303	* @count_read: optional read callback for Count attribute. The read
330	* value of the respective Count should be passed back via	304	* value of the respective Count should be passed back via
331	* the val parameter. val points to an opaque type which	305	* the val parameter.
332	* should be set only by calling the
333	* counter_count_read_value_set function from within the
334	* count_read callback.
335	* @count_write: optional write callback for Count attribute. The write	306	* @count_write: optional write callback for Count attribute. The write
336	* value for the respective Count is passed in via the val	307	* value for the respective Count is passed in via the val
337	* parameter. val points to an opaque type which should be	308	* parameter.
338	* accessed only by calling the
339	* counter_count_write_value_get function.
340	* @function_get: function to get the current count function mode. Returns	309	* @function_get: function to get the current count function mode. Returns
341	* 0 on success and negative error code on error. The index	310	* 0 on success and negative error code on error. The index
342	* of the respective Count's returned function mode should	311	* of the respective Count's returned function mode should
@@ -346,7 +315,7 @@ struct counter_count_write_value { · 3 unmodified lines
346	* Count's functions_list array.	315	* Count's functions_list array.
347	* @action_get: function to get the current action mode. Returns 0 on	316	* @action_get: function to get the current action mode. Returns 0 on
348	* success and negative error code on error. The index of	317	* success and negative error code on error. The index of
349	* the respective Signal's returned action mode should be	318	* the respective Synapse's returned action mode should be
350	* passed back via the action parameter.	319	* passed back via the action parameter.
351	* @action_set: function to set the action mode. action is the index of	320	* @action_set: function to set the action mode. action is the index of
352	* the requested action mode from the respective Synapse's	321	* the requested action mode from the respective Synapse's
@@ -355,13 +324,11 @@ struct counter_count_write_value { · 2 unmodified lines
355	struct counter_ops {	324	struct counter_ops {
356	int (signal_read)(struct counter_device counter,	325	int (signal_read)(struct counter_device counter,
357	struct counter_signal *signal,	326	struct counter_signal *signal,
358	struct counter_signal_read_value *val);	327	enum counter_signal_value *val);
359	int (count_read)(struct counter_device counter,	328	int (count_read)(struct counter_device counter,
360	struct counter_count *count,	329	struct counter_count count, unsigned long val);
361	struct counter_count_read_value *val);
362	int (count_write)(struct counter_device counter,	330	int (count_write)(struct counter_device counter,
363	struct counter_count *count,	331	struct counter_count *count, unsigned long val);
364	struct counter_count_write_value *val);
365	int (function_get)(struct counter_device counter,	332	int (function_get)(struct counter_device counter,
366	struct counter_count count, size_t function);	333	struct counter_count count, size_t function);
367	int (function_set)(struct counter_device counter,	334	int (function_set)(struct counter_device counter,
@@ -477,29 +444,6 @@ struct counter_device { · 109 unmodified lines
477	void *priv;	444	void *priv;
478	};	445	};
479		446
480	enum counter_signal_level {
481	COUNTER_SIGNAL_LEVEL_LOW = 0,
482	COUNTER_SIGNAL_LEVEL_HIGH
483	};
484
485	enum counter_signal_value_type {
486	COUNTER_SIGNAL_LEVEL = 0
487	};
488
489	enum counter_count_value_type {
490	COUNTER_COUNT_POSITION = 0,
491	};
492
493	void counter_signal_read_value_set(struct counter_signal_read_value *const val,
494	const enum counter_signal_value_type type,
495	void *const data);
496	void counter_count_read_value_set(struct counter_count_read_value *const val,
497	const enum counter_count_value_type type,
498	void *const data);
499	int counter_count_write_value_get(void *const data,
500	const enum counter_count_value_type type,
501	const struct counter_count_write_value *const val);
502
503	int counter_register(struct counter_device *const counter);	447	int counter_register(struct counter_device *const counter);
504	void counter_unregister(struct counter_device *const counter);	448	void counter_unregister(struct counter_device *const counter);
505	int devm_counter_register(struct device *dev,	449	int devm_counter_register(struct device *dev,

include/linux/cpu.h+6−1

 int cpu_report_state(int cpu);
 int cpu_check_up_prepare(int cpu);
 void cpu_set_state_online(int cpu);
-void play_idle(unsigned long duration_us);
+void play_idle_precise(u64 duration_ns, u64 latency_ns);
+static inline void play_idle(unsigned long duration_us)
+{
+	play_idle_precise(duration_us * NSEC_PER_USEC, U64_MAX);
+}
 #ifdef CONFIG_HOTPLUG_CPU
 bool cpu_wait_death(unsigned int cpu, int seconds);

include/linux/cpu_cooling.h+8−10

  */
 void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev);
+/**
+ * of_cpufreq_cooling_register - create cpufreq cooling device based on DT.
+ * @policy: cpufreq policy.
+ */
+struct thermal_cooling_device *
+of_cpufreq_cooling_register(struct cpufreq_policy *policy);
 #else /* !CONFIG_CPU_THERMAL */
 static inline struct thermal_cooling_device *
 cpufreq_cooling_register(struct cpufreq_policy *policy)
 {
 	return;
 }
-#endif	/* CONFIG_CPU_THERMAL */
-#if defined(CONFIG_THERMAL_OF) && defined(CONFIG_CPU_THERMAL)
-/**
- * of_cpufreq_cooling_register - create cpufreq cooling device based on DT.
- * @policy: cpufreq policy.
- */
-struct thermal_cooling_device *
-of_cpufreq_cooling_register(struct cpufreq_policy *policy);
-#else
 static inline struct thermal_cooling_device *
 of_cpufreq_cooling_register(struct cpufreq_policy *policy)
 {
 	return NULL;
 }
-#endif /* defined(CONFIG_THERMAL_OF) && defined(CONFIG_CPU_THERMAL) */
+#endif /* CONFIG_CPU_THERMAL */
 #endif /* __CPU_COOLING_H__ */

include/linux/cpufreq.h+0−11

@@ -595,17 +595,6 @@ struct governor_attr { · 594 unmodified lines
595	size_t count);	595	size_t count);
596	};	596	};
597		597
598	static inline bool cpufreq_this_cpu_can_update(struct cpufreq_policy *policy)
599	{
600	/*
601	* Allow remote callbacks if:
602	* - dvfs_possible_from_any_cpu flag is set
603	* - the local and remote CPUs share cpufreq policy
604	*/
605	return policy->dvfs_possible_from_any_cpu \|\|
606	cpumask_test_cpu(smp_processor_id(), policy->cpus);
607	}
608
609	/*********************************************************************	598	/*********************************************************************
610	* FREQUENCY TABLE HELPERS *	599	* FREQUENCY TABLE HELPERS *
611	*********************************************************************/	600	*********************************************************************/

include/linux/cpuhotplug.h+2−0

 	CPUHP_AP_ARC_TIMER_STARTING,
 	CPUHP_AP_RISCV_TIMER_STARTING,
 	CPUHP_AP_CSKY_TIMER_STARTING,
+	CPUHP_AP_HYPERV_TIMER_STARTING,
 	CPUHP_AP_KVM_STARTING,
 	CPUHP_AP_KVM_ARM_VGIC_INIT_STARTING,
 	CPUHP_AP_KVM_ARM_VGIC_STARTING,
 	/* Must be the last timer callback */
 	CPUHP_AP_DUMMY_TIMER_STARTING,
 	CPUHP_AP_ARM_XEN_STARTING,
+	CPUHP_AP_ARM_KVMPV_STARTING,
 	CPUHP_AP_ARM_CORESIGHT_STARTING,
 	CPUHP_AP_ARM64_ISNDEP_STARTING,
 	CPUHP_AP_SMPCFD_DYING,

include/linux/cpuidle.h+20−9

  * CPUIDLE DEVICE INTERFACE *
  ****************************/
+#define CPUIDLE_STATE_DISABLED_BY_USER		BIT(0)
+#define CPUIDLE_STATE_DISABLED_BY_DRIVER	BIT(1)
 struct cpuidle_state_usage {
 	unsigned long long	disable;
 	unsigned long long	usage;
-	unsigned long long	time; /* in US */
+	u64			time_ns;
 	unsigned long long	above; /* Number of times it's been too deep */
 	unsigned long long	below; /* Number of times it's been too shallow */
 #ifdef CONFIG_SUSPEND
 	char		name[CPUIDLE_NAME_LEN];
 	char		desc[CPUIDLE_DESC_LEN];
+	u64		exit_latency_ns;
+	u64		target_residency_ns;
 	unsigned int	flags;
 	unsigned int	exit_latency; /* in US */
 	int		power_usage; /* in mW */
 	unsigned int	target_residency; /* in US */
-	bool		disabled; /* disabled on all CPUs */
 	int (*enter)	(struct cpuidle_device *dev,
 			struct cpuidle_driver *drv,
 #define CPUIDLE_FLAG_POLLING	BIT(0) /* polling state */
 #define CPUIDLE_FLAG_COUPLED	BIT(1) /* state applies to multiple cpus */
 #define CPUIDLE_FLAG_TIMER_STOP BIT(2) /* timer is stopped on this state */
+#define CPUIDLE_FLAG_UNUSABLE	BIT(3) /* avoid using this state */
 struct cpuidle_device_kobj;
 struct cpuidle_state_kobj;
 struct cpuidle_device {
 	unsigned int		registered:1;
 	unsigned int		enabled:1;
-	unsigned int		use_deepest_state:1;
 	unsigned int		poll_time_limit:1;
 	unsigned int		cpu;
 	ktime_t			next_hrtimer;
 	int			last_state_idx;
-	int			last_residency;
+	u64			last_residency_ns;
 	u64			poll_limit_ns;
+	u64			forced_idle_latency_limit_ns;
 	struct cpuidle_state_usage	states_usage[CPUIDLE_STATE_MAX];
 	struct cpuidle_state_kobj *kobjs[CPUIDLE_STATE_MAX];
 	struct cpuidle_driver_kobj *kobj_driver;
 extern struct cpuidle_driver *cpuidle_get_driver(void);
 extern struct cpuidle_driver *cpuidle_driver_ref(void);
 extern void cpuidle_driver_unref(void);
+extern void cpuidle_driver_state_disabled(struct cpuidle_driver *drv, int idx,
+					bool disable);
 extern void cpuidle_unregister_driver(struct cpuidle_driver *drv);
 extern int cpuidle_register_device(struct cpuidle_device *dev);
 extern void cpuidle_unregister_device(struct cpuidle_device *dev);
 static inline struct cpuidle_driver *cpuidle_get_driver(void) {return NULL; }
 static inline struct cpuidle_driver *cpuidle_driver_ref(void) {return NULL; }
 static inline void cpuidle_driver_unref(void) {}
+static inline void cpuidle_driver_state_disabled(struct cpuidle_driver *drv,
+					       int idx, bool disable) { }
 static inline void cpuidle_unregister_driver(struct cpuidle_driver *drv) { }
 static inline int cpuidle_register_device(struct cpuidle_device *dev)
 {return -ENODEV; }
 #ifdef CONFIG_CPU_IDLE
 extern int cpuidle_find_deepest_state(struct cpuidle_driver *drv,
-				      struct cpuidle_device *dev);
+				      struct cpuidle_device *dev,
+				      u64 latency_limit_ns);
 extern int cpuidle_enter_s2idle(struct cpuidle_driver *drv,
 				struct cpuidle_device *dev);
-extern void cpuidle_use_deepest_state(bool enable);
+extern void cpuidle_use_deepest_state(u64 latency_limit_ns);
 #else
 static inline int cpuidle_find_deepest_state(struct cpuidle_driver *drv,
-					     struct cpuidle_device *dev)
+					     struct cpuidle_device *dev,
+					     u64 latency_limit_ns)
 {return -ENODEV; }
 static inline int cpuidle_enter_s2idle(struct cpuidle_driver *drv,
 				       struct cpuidle_device *dev)
 {return -ENODEV; }
-static inline void cpuidle_use_deepest_state(bool enable)
+static inline void cpuidle_use_deepest_state(u64 latency_limit_ns)
 {
 }
 #endif
 #ifdef CONFIG_CPU_IDLE
 extern int cpuidle_register_governor(struct cpuidle_governor *gov);
-extern int cpuidle_governor_latency_req(unsigned int cpu);
+extern s64 cpuidle_governor_latency_req(unsigned int cpu);
 #else
 static inline int cpuidle_register_governor(struct cpuidle_governor *gov)
 {return 0;}

include/linux/crypto.h+2−859

@@ -41,8 +41,6 @@ · 40 unmodified lines
41	#define CRYPTO_ALG_TYPE_CIPHER 0x00000001	41	#define CRYPTO_ALG_TYPE_CIPHER 0x00000001
42	#define CRYPTO_ALG_TYPE_COMPRESS 0x00000002	42	#define CRYPTO_ALG_TYPE_COMPRESS 0x00000002
43	#define CRYPTO_ALG_TYPE_AEAD 0x00000003	43	#define CRYPTO_ALG_TYPE_AEAD 0x00000003
44	#define CRYPTO_ALG_TYPE_BLKCIPHER 0x00000004
45	#define CRYPTO_ALG_TYPE_ABLKCIPHER 0x00000005
46	#define CRYPTO_ALG_TYPE_SKCIPHER 0x00000005	44	#define CRYPTO_ALG_TYPE_SKCIPHER 0x00000005
47	#define CRYPTO_ALG_TYPE_KPP 0x00000008	45	#define CRYPTO_ALG_TYPE_KPP 0x00000008
48	#define CRYPTO_ALG_TYPE_ACOMPRESS 0x0000000a	46	#define CRYPTO_ALG_TYPE_ACOMPRESS 0x0000000a
@@ -55,7 +53,6 @@ · 6 unmodified lines
55		53
56	#define CRYPTO_ALG_TYPE_HASH_MASK 0x0000000e	54	#define CRYPTO_ALG_TYPE_HASH_MASK 0x0000000e
57	#define CRYPTO_ALG_TYPE_AHASH_MASK 0x0000000e	55	#define CRYPTO_ALG_TYPE_AHASH_MASK 0x0000000e
58	#define CRYPTO_ALG_TYPE_BLKCIPHER_MASK 0x0000000c
59	#define CRYPTO_ALG_TYPE_ACOMPRESS_MASK 0x0000000e	56	#define CRYPTO_ALG_TYPE_ACOMPRESS_MASK 0x0000000e
60		57
61	#define CRYPTO_ALG_LARVAL 0x00000010	58	#define CRYPTO_ALG_LARVAL 0x00000010
@@ -139,9 +136,7 @@ · 77 unmodified lines
139	#define CRYPTO_MINALIGN_ATTR __attribute__ ((__aligned__(CRYPTO_MINALIGN)))	136	#define CRYPTO_MINALIGN_ATTR __attribute__ ((__aligned__(CRYPTO_MINALIGN)))
140		137
141	struct scatterlist;	138	struct scatterlist;
142	struct crypto_ablkcipher;
143	struct crypto_async_request;	139	struct crypto_async_request;
144	struct crypto_blkcipher;
145	struct crypto_tfm;	140	struct crypto_tfm;
146	struct crypto_type;	141	struct crypto_type;
147		142
@@ -163,25 +158,6 @@ struct crypto_async_request { · 15 unmodified lines
163	u32 flags;	158	u32 flags;
164	};	159	};
165		160
166	struct ablkcipher_request {
167	struct crypto_async_request base;
168
169	unsigned int nbytes;
170
171	void *info;
172
173	struct scatterlist *src;
174	struct scatterlist *dst;
175
176	void *__ctx[] CRYPTO_MINALIGN_ATTR;
177	};
178
179	struct blkcipher_desc {
180	struct crypto_blkcipher *tfm;
181	void *info;
182	u32 flags;
183	};
184
185	/**	161	/**
186	* DOC: Block Cipher Algorithm Definitions	162	* DOC: Block Cipher Algorithm Definitions
187	*	163	*
@@ -189,83 +165,6 @@ struct blkcipher_desc { · 1 unmodified line
189	* managed via crypto_register_alg() and crypto_unregister_alg().	165	* managed via crypto_register_alg() and crypto_unregister_alg().
190	*/	166	*/
191		167
192	/**
193	* struct ablkcipher_alg - asynchronous block cipher definition
194	* @min_keysize: Minimum key size supported by the transformation. This is the
195	* smallest key length supported by this transformation algorithm.
196	* This must be set to one of the pre-defined values as this is
197	* not hardware specific. Possible values for this field can be
198	* found via git grep "_MIN_KEY_SIZE" include/crypto/
199	* @max_keysize: Maximum key size supported by the transformation. This is the
200	* largest key length supported by this transformation algorithm.
201	* This must be set to one of the pre-defined values as this is
202	* not hardware specific. Possible values for this field can be
203	* found via git grep "_MAX_KEY_SIZE" include/crypto/
204	* @setkey: Set key for the transformation. This function is used to either
205	* program a supplied key into the hardware or store the key in the
206	* transformation context for programming it later. Note that this
207	* function does modify the transformation context. This function can
208	* be called multiple times during the existence of the transformation
209	* object, so one must make sure the key is properly reprogrammed into
210	* the hardware. This function is also responsible for checking the key
211	* length for validity. In case a software fallback was put in place in
212	* the @cra_init call, this function might need to use the fallback if
213	* the algorithm doesn't support all of the key sizes.
214	* @encrypt: Encrypt a scatterlist of blocks. This function is used to encrypt
215	* the supplied scatterlist containing the blocks of data. The crypto
216	* API consumer is responsible for aligning the entries of the
217	* scatterlist properly and making sure the chunks are correctly
218	* sized. In case a software fallback was put in place in the
219	* @cra_init call, this function might need to use the fallback if
220	* the algorithm doesn't support all of the key sizes. In case the
221	* key was stored in transformation context, the key might need to be
222	* re-programmed into the hardware in this function. This function
223	* shall not modify the transformation context, as this function may
224	* be called in parallel with the same transformation object.
225	* @decrypt: Decrypt a single block. This is a reverse counterpart to @encrypt
226	* and the conditions are exactly the same.
227	* @ivsize: IV size applicable for transformation. The consumer must provide an
228	* IV of exactly that size to perform the encrypt or decrypt operation.
229	*
230	* All fields except @ivsize are mandatory and must be filled.
231	*/
232	struct ablkcipher_alg {
233	int (setkey)(struct crypto_ablkcipher tfm, const u8 *key,
234	unsigned int keylen);
235	int (encrypt)(struct ablkcipher_request req);
236	int (decrypt)(struct ablkcipher_request req);
237
238	unsigned int min_keysize;
239	unsigned int max_keysize;
240	unsigned int ivsize;
241	};
242
243	/**
244	* struct blkcipher_alg - synchronous block cipher definition
245	* @min_keysize: see struct ablkcipher_alg
246	* @max_keysize: see struct ablkcipher_alg
247	* @setkey: see struct ablkcipher_alg
248	* @encrypt: see struct ablkcipher_alg
249	* @decrypt: see struct ablkcipher_alg
250	* @ivsize: see struct ablkcipher_alg
251	*
252	* All fields except @ivsize are mandatory and must be filled.
253	*/
254	struct blkcipher_alg {
255	int (setkey)(struct crypto_tfm tfm, const u8 *key,
256	unsigned int keylen);
257	int (encrypt)(struct blkcipher_desc desc,
258	struct scatterlist dst, struct scatterlist src,
259	unsigned int nbytes);
260	int (decrypt)(struct blkcipher_desc desc,
261	struct scatterlist dst, struct scatterlist src,
262	unsigned int nbytes);
263
264	unsigned int min_keysize;
265	unsigned int max_keysize;
266	unsigned int ivsize;
267	};
268
269	/**	168	/**
270	* struct cipher_alg - single-block symmetric ciphers definition	169	* struct cipher_alg - single-block symmetric ciphers definition
271	* @cia_min_keysize: Minimum key size supported by the transformation. This is	170	* @cia_min_keysize: Minimum key size supported by the transformation. This is
@@ -450,8 +349,6 @@ struct crypto_istat_rng { · 178 unmodified lines
450	};	349	};
451	#endif /* CONFIG_CRYPTO_STATS */	350	#endif /* CONFIG_CRYPTO_STATS */
452		351
453	#define cra_ablkcipher cra_u.ablkcipher
454	#define cra_blkcipher cra_u.blkcipher
455	#define cra_cipher cra_u.cipher	352	#define cra_cipher cra_u.cipher
456	#define cra_compress cra_u.compress	353	#define cra_compress cra_u.compress
457		354
@@ -499,9 +396,8 @@ struct crypto_istat_rng { · 41 unmodified lines
499	* transformation algorithm.	396	* transformation algorithm.
500	* @cra_type: Type of the cryptographic transformation. This is a pointer to	397	* @cra_type: Type of the cryptographic transformation. This is a pointer to
501	* struct crypto_type, which implements callbacks common for all	398	* struct crypto_type, which implements callbacks common for all
502	* transformation types. There are multiple options:	399	* transformation types. There are multiple options, such as
503	* &crypto_blkcipher_type, &crypto_ablkcipher_type,	400	* &crypto_skcipher_type, &crypto_ahash_type, &crypto_rng_type.
504	* &crypto_ahash_type, &crypto_rng_type.
505	* This field might be empty. In that case, there are no common	401	* This field might be empty. In that case, there are no common
506	* callbacks. This is the case for: cipher, compress, shash.	402	* callbacks. This is the case for: cipher, compress, shash.
507	* @cra_u: Callbacks implementing the transformation. This is a union of	403	* @cra_u: Callbacks implementing the transformation. This is a union of
@@ -520,10 +416,6 @@ struct crypto_istat_rng { · 12 unmodified lines
520	* @cra_exit: Deinitialize the cryptographic transformation object. This is a	416	* @cra_exit: Deinitialize the cryptographic transformation object. This is a
521	* counterpart to @cra_init, used to remove various changes set in	417	* counterpart to @cra_init, used to remove various changes set in
522	* @cra_init.	418	* @cra_init.
523	* @cra_u.ablkcipher: Union member which contains an asynchronous block cipher
524	* definition. See @struct @ablkcipher_alg.
525	* @cra_u.blkcipher: Union member which contains a synchronous block cipher
526	* definition See @struct @blkcipher_alg.
527	* @cra_u.cipher: Union member which contains a single-block symmetric cipher	419	* @cra_u.cipher: Union member which contains a single-block symmetric cipher
528	* definition. See @struct @cipher_alg.	420	* definition. See @struct @cipher_alg.
529	* @cra_u.compress: Union member which contains a (de)compression algorithm.	421	* @cra_u.compress: Union member which contains a (de)compression algorithm.
@@ -565,8 +457,6 @@ struct crypto_alg { · 35 unmodified lines
565	const struct crypto_type *cra_type;	457	const struct crypto_type *cra_type;
566		458
567	union {	459	union {
568	struct ablkcipher_alg ablkcipher;
569	struct blkcipher_alg blkcipher;
570	struct cipher_alg cipher;	460	struct cipher_alg cipher;
571	struct compress_alg compress;	461	struct compress_alg compress;
572	} cra_u;	462	} cra_u;
@@ -594,8 +484,6 @@ struct crypto_alg { · 21 unmodified lines
594	#ifdef CONFIG_CRYPTO_STATS	484	#ifdef CONFIG_CRYPTO_STATS
595	void crypto_stats_init(struct crypto_alg *alg);	485	void crypto_stats_init(struct crypto_alg *alg);
596	void crypto_stats_get(struct crypto_alg *alg);	486	void crypto_stats_get(struct crypto_alg *alg);
597	void crypto_stats_ablkcipher_encrypt(unsigned int nbytes, int ret, struct crypto_alg *alg);
598	void crypto_stats_ablkcipher_decrypt(unsigned int nbytes, int ret, struct crypto_alg *alg);
599	void crypto_stats_aead_encrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret);	487	void crypto_stats_aead_encrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret);
600	void crypto_stats_aead_decrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret);	488	void crypto_stats_aead_decrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret);
601	void crypto_stats_ahash_update(unsigned int nbytes, int ret, struct crypto_alg *alg);	489	void crypto_stats_ahash_update(unsigned int nbytes, int ret, struct crypto_alg *alg);
@@ -618,10 +506,6 @@ static inline void crypto_stats_init(struct crypto_alg *alg) · 16 unmodified lines
618	{}	506	{}
619	static inline void crypto_stats_get(struct crypto_alg *alg)	507	static inline void crypto_stats_get(struct crypto_alg *alg)
620	{}	508	{}
621	static inline void crypto_stats_ablkcipher_encrypt(unsigned int nbytes, int ret, struct crypto_alg *alg)
622	{}
623	static inline void crypto_stats_ablkcipher_decrypt(unsigned int nbytes, int ret, struct crypto_alg *alg)
624	{}
625	static inline void crypto_stats_aead_encrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret)	509	static inline void crypto_stats_aead_encrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret)
626	{}	510	{}
627	static inline void crypto_stats_aead_decrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret)	511	static inline void crypto_stats_aead_decrypt(unsigned int cryptlen, struct crypto_alg *alg, int ret)
@@ -715,28 +599,6 @@ int crypto_has_alg(const char *name, u32 type, u32 mask); · 87 unmodified lines
715	* crypto_free_*(), as well as the various helpers below.	599	* crypto_free_*(), as well as the various helpers below.
716	*/	600	*/
717		601
718	struct ablkcipher_tfm {
719	int (setkey)(struct crypto_ablkcipher tfm, const u8 *key,
720	unsigned int keylen);
721	int (encrypt)(struct ablkcipher_request req);
722	int (decrypt)(struct ablkcipher_request req);
723
724	struct crypto_ablkcipher *base;
725
726	unsigned int ivsize;
727	unsigned int reqsize;
728	};
729
730	struct blkcipher_tfm {
731	void *iv;
732	int (setkey)(struct crypto_tfm tfm, const u8 *key,
733	unsigned int keylen);
734	int (encrypt)(struct blkcipher_desc desc, struct scatterlist *dst,
735	struct scatterlist *src, unsigned int nbytes);
736	int (decrypt)(struct blkcipher_desc desc, struct scatterlist *dst,
737	struct scatterlist *src, unsigned int nbytes);
738	};
739
740	struct cipher_tfm {	602	struct cipher_tfm {
741	int (cit_setkey)(struct crypto_tfm tfm,	603	int (cit_setkey)(struct crypto_tfm tfm,
742	const u8 *key, unsigned int keylen);	604	const u8 *key, unsigned int keylen);
@@ -753,8 +615,6 @@ struct compress_tfm { · 10 unmodified lines
753	u8 dst, unsigned int dlen);	615	u8 dst, unsigned int dlen);
754	};	616	};
755		617
756	#define crt_ablkcipher crt_u.ablkcipher
757	#define crt_blkcipher crt_u.blkcipher
758	#define crt_cipher crt_u.cipher	618	#define crt_cipher crt_u.cipher
759	#define crt_compress crt_u.compress	619	#define crt_compress crt_u.compress
760		620
@@ -763,8 +623,6 @@ struct crypto_tfm { · 2 unmodified lines
763	u32 crt_flags;	623	u32 crt_flags;
764		624
765	union {	625	union {
766	struct ablkcipher_tfm ablkcipher;
767	struct blkcipher_tfm blkcipher;
768	struct cipher_tfm cipher;	626	struct cipher_tfm cipher;
769	struct compress_tfm compress;	627	struct compress_tfm compress;
770	} crt_u;	628	} crt_u;
@@ -776,14 +634,6 @@ struct crypto_tfm { · 5 unmodified lines
776	void *__crt_ctx[] CRYPTO_MINALIGN_ATTR;	634	void *__crt_ctx[] CRYPTO_MINALIGN_ATTR;
777	};	635	};
778		636
779	struct crypto_ablkcipher {
780	struct crypto_tfm base;
781	};
782
783	struct crypto_blkcipher {
784	struct crypto_tfm base;
785	};
786
787	struct crypto_cipher {	637	struct crypto_cipher {
788	struct crypto_tfm base;	638	struct crypto_tfm base;
789	};	639	};
@@ -891,713 +741,6 @@ static inline unsigned int crypto_tfm_ctx_alignment(void) · 101 unmodified lines
891	return __alignof__(tfm->__crt_ctx);	741	return __alignof__(tfm->__crt_ctx);
892	}	742	}
893		743
894	/*
895	* API wrappers.
896	*/
897	static inline struct crypto_ablkcipher *__crypto_ablkcipher_cast(
898	struct crypto_tfm *tfm)
899	{
900	return (struct crypto_ablkcipher *)tfm;
901	}
902
903	static inline u32 crypto_skcipher_type(u32 type)
904	{
905	type &= ~CRYPTO_ALG_TYPE_MASK;
906	type \|= CRYPTO_ALG_TYPE_BLKCIPHER;
907	return type;
908	}
909
910	static inline u32 crypto_skcipher_mask(u32 mask)
911	{
912	mask &= ~CRYPTO_ALG_TYPE_MASK;
913	mask \|= CRYPTO_ALG_TYPE_BLKCIPHER_MASK;
914	return mask;
915	}
916
917	/**
918	* DOC: Asynchronous Block Cipher API
919	*
920	* Asynchronous block cipher API is used with the ciphers of type
921	* CRYPTO_ALG_TYPE_ABLKCIPHER (listed as type "ablkcipher" in /proc/crypto).
922	*
923	* Asynchronous cipher operations imply that the function invocation for a
924	* cipher request returns immediately before the completion of the operation.
925	* The cipher request is scheduled as a separate kernel thread and therefore
926	* load-balanced on the different CPUs via the process scheduler. To allow
927	* the kernel crypto API to inform the caller about the completion of a cipher
928	* request, the caller must provide a callback function. That function is
929	* invoked with the cipher handle when the request completes.
930	*
931	* To support the asynchronous operation, additional information than just the
932	* cipher handle must be supplied to the kernel crypto API. That additional
933	* information is given by filling in the ablkcipher_request data structure.
934	*
935	* For the asynchronous block cipher API, the state is maintained with the tfm
936	* cipher handle. A single tfm can be used across multiple calls and in
937	* parallel. For asynchronous block cipher calls, context data supplied and
938	* only used by the caller can be referenced the request data structure in
939	* addition to the IV used for the cipher request. The maintenance of such
940	* state information would be important for a crypto driver implementer to
941	* have, because when calling the callback function upon completion of the
942	* cipher operation, that callback function may need some information about
943	* which operation just finished if it invoked multiple in parallel. This
944	* state information is unused by the kernel crypto API.
945	*/
946
947	static inline struct crypto_tfm *crypto_ablkcipher_tfm(
948	struct crypto_ablkcipher *tfm)
949	{
950	return &tfm->base;
951	}
952
953	/**
954	* crypto_free_ablkcipher() - zeroize and free cipher handle
955	* @tfm: cipher handle to be freed
956	*/
957	static inline void crypto_free_ablkcipher(struct crypto_ablkcipher *tfm)
958	{
959	crypto_free_tfm(crypto_ablkcipher_tfm(tfm));
960	}
961
962	/**
963	* crypto_has_ablkcipher() - Search for the availability of an ablkcipher.
964	* @alg_name: is the cra_name / name or cra_driver_name / driver name of the
965	* ablkcipher
966	* @type: specifies the type of the cipher
967	* @mask: specifies the mask for the cipher
968	*
969	* Return: true when the ablkcipher is known to the kernel crypto API; false
970	* otherwise
971	*/
972	static inline int crypto_has_ablkcipher(const char *alg_name, u32 type,
973	u32 mask)
974	{
975	return crypto_has_alg(alg_name, crypto_skcipher_type(type),
976	crypto_skcipher_mask(mask));
977	}
978
979	static inline struct ablkcipher_tfm *crypto_ablkcipher_crt(
980	struct crypto_ablkcipher *tfm)
981	{
982	return &crypto_ablkcipher_tfm(tfm)->crt_ablkcipher;
983	}
984
985	/**
986	* crypto_ablkcipher_ivsize() - obtain IV size
987	* @tfm: cipher handle
988	*
989	* The size of the IV for the ablkcipher referenced by the cipher handle is
990	* returned. This IV size may be zero if the cipher does not need an IV.
991	*
992	* Return: IV size in bytes
993	*/
994	static inline unsigned int crypto_ablkcipher_ivsize(
995	struct crypto_ablkcipher *tfm)
996	{
997	return crypto_ablkcipher_crt(tfm)->ivsize;
998	}
999
1000	/**
1001	* crypto_ablkcipher_blocksize() - obtain block size of cipher
1002	* @tfm: cipher handle
1003	*
1004	* The block size for the ablkcipher referenced with the cipher handle is
1005	* returned. The caller may use that information to allocate appropriate
1006	* memory for the data returned by the encryption or decryption operation
1007	*
1008	* Return: block size of cipher
1009	*/
1010	static inline unsigned int crypto_ablkcipher_blocksize(
1011	struct crypto_ablkcipher *tfm)
1012	{
1013	return crypto_tfm_alg_blocksize(crypto_ablkcipher_tfm(tfm));
1014	}
1015
1016	static inline unsigned int crypto_ablkcipher_alignmask(
1017	struct crypto_ablkcipher *tfm)
1018	{
1019	return crypto_tfm_alg_alignmask(crypto_ablkcipher_tfm(tfm));
1020	}
1021
1022	static inline u32 crypto_ablkcipher_get_flags(struct crypto_ablkcipher *tfm)
1023	{
1024	return crypto_tfm_get_flags(crypto_ablkcipher_tfm(tfm));
1025	}
1026
1027	static inline void crypto_ablkcipher_set_flags(struct crypto_ablkcipher *tfm,
1028	u32 flags)
1029	{
1030	crypto_tfm_set_flags(crypto_ablkcipher_tfm(tfm), flags);
1031	}
1032
1033	static inline void crypto_ablkcipher_clear_flags(struct crypto_ablkcipher *tfm,
1034	u32 flags)
1035	{
1036	crypto_tfm_clear_flags(crypto_ablkcipher_tfm(tfm), flags);
1037	}
1038
1039	/**
1040	* crypto_ablkcipher_setkey() - set key for cipher
1041	* @tfm: cipher handle
1042	* @key: buffer holding the key
1043	* @keylen: length of the key in bytes
1044	*
1045	* The caller provided key is set for the ablkcipher referenced by the cipher
1046	* handle.
1047	*
1048	* Note, the key length determines the cipher type. Many block ciphers implement
1049	* different cipher modes depending on the key size, such as AES-128 vs AES-192
1050	* vs. AES-256. When providing a 16 byte key for an AES cipher handle, AES-128
1051	* is performed.
1052	*
1053	* Return: 0 if the setting of the key was successful; < 0 if an error occurred
1054	*/
1055	static inline int crypto_ablkcipher_setkey(struct crypto_ablkcipher *tfm,
1056	const u8 *key, unsigned int keylen)
1057	{
1058	struct ablkcipher_tfm *crt = crypto_ablkcipher_crt(tfm);
1059
1060	return crt->setkey(crt->base, key, keylen);
1061	}
1062
1063	/**
1064	* crypto_ablkcipher_reqtfm() - obtain cipher handle from request
1065	* @req: ablkcipher_request out of which the cipher handle is to be obtained
1066	*
1067	* Return the crypto_ablkcipher handle when furnishing an ablkcipher_request
1068	* data structure.
1069	*
1070	* Return: crypto_ablkcipher handle
1071	*/
1072	static inline struct crypto_ablkcipher *crypto_ablkcipher_reqtfm(
1073	struct ablkcipher_request *req)
1074	{
1075	return __crypto_ablkcipher_cast(req->base.tfm);
1076	}
1077
1078	/**
1079	* crypto_ablkcipher_encrypt() - encrypt plaintext
1080	* @req: reference to the ablkcipher_request handle that holds all information
1081	* needed to perform the cipher operation
1082	*
1083	* Encrypt plaintext data using the ablkcipher_request handle. That data
1084	* structure and how it is filled with data is discussed with the
1085	* ablkcipher_request_* functions.
1086	*
1087	* Return: 0 if the cipher operation was successful; < 0 if an error occurred
1088	*/
1089	static inline int crypto_ablkcipher_encrypt(struct ablkcipher_request *req)
1090	{
1091	struct ablkcipher_tfm *crt =
1092	crypto_ablkcipher_crt(crypto_ablkcipher_reqtfm(req));
1093	struct crypto_alg *alg = crt->base->base.__crt_alg;
1094	unsigned int nbytes = req->nbytes;
1095	int ret;
1096
1097	crypto_stats_get(alg);
1098	ret = crt->encrypt(req);
1099	crypto_stats_ablkcipher_encrypt(nbytes, ret, alg);
1100	return ret;
1101	}
1102
1103	/**
1104	* crypto_ablkcipher_decrypt() - decrypt ciphertext
1105	* @req: reference to the ablkcipher_request handle that holds all information
1106	* needed to perform the cipher operation
1107	*
1108	* Decrypt ciphertext data using the ablkcipher_request handle. That data
1109	* structure and how it is filled with data is discussed with the
1110	* ablkcipher_request_* functions.
1111	*
1112	* Return: 0 if the cipher operation was successful; < 0 if an error occurred
1113	*/
1114	static inline int crypto_ablkcipher_decrypt(struct ablkcipher_request *req)
1115	{
1116	struct ablkcipher_tfm *crt =
1117	crypto_ablkcipher_crt(crypto_ablkcipher_reqtfm(req));
1118	struct crypto_alg *alg = crt->base->base.__crt_alg;
1119	unsigned int nbytes = req->nbytes;
1120	int ret;
1121
1122	crypto_stats_get(alg);
1123	ret = crt->decrypt(req);
1124	crypto_stats_ablkcipher_decrypt(nbytes, ret, alg);
1125	return ret;
1126	}
1127
1128	/**
1129	* DOC: Asynchronous Cipher Request Handle
1130	*
1131	* The ablkcipher_request data structure contains all pointers to data
1132	* required for the asynchronous cipher operation. This includes the cipher
1133	* handle (which can be used by multiple ablkcipher_request instances), pointer
1134	* to plaintext and ciphertext, asynchronous callback function, etc. It acts
1135	* as a handle to the ablkcipher_request_* API calls in a similar way as
1136	* ablkcipher handle to the crypto_ablkcipher_* API calls.
1137	*/
1138
1139	/**
1140	* crypto_ablkcipher_reqsize() - obtain size of the request data structure
1141	* @tfm: cipher handle
1142	*
1143	* Return: number of bytes
1144	*/
1145	static inline unsigned int crypto_ablkcipher_reqsize(
1146	struct crypto_ablkcipher *tfm)
1147	{
1148	return crypto_ablkcipher_crt(tfm)->reqsize;
1149	}
1150
1151	/**
1152	* ablkcipher_request_set_tfm() - update cipher handle reference in request
1153	* @req: request handle to be modified
1154	* @tfm: cipher handle that shall be added to the request handle
1155	*
1156	* Allow the caller to replace the existing ablkcipher handle in the request
1157	* data structure with a different one.
1158	*/
1159	static inline void ablkcipher_request_set_tfm(
1160	struct ablkcipher_request req, struct crypto_ablkcipher tfm)
1161	{
1162	req->base.tfm = crypto_ablkcipher_tfm(crypto_ablkcipher_crt(tfm)->base);
1163	}
1164
1165	static inline struct ablkcipher_request *ablkcipher_request_cast(
1166	struct crypto_async_request *req)
1167	{
1168	return container_of(req, struct ablkcipher_request, base);
1169	}
1170
1171	/**
1172	* ablkcipher_request_alloc() - allocate request data structure
1173	* @tfm: cipher handle to be registered with the request
1174	* @gfp: memory allocation flag that is handed to kmalloc by the API call.
1175	*
1176	* Allocate the request data structure that must be used with the ablkcipher
1177	* encrypt and decrypt API calls. During the allocation, the provided ablkcipher
1178	* handle is registered in the request data structure.
1179	*
1180	* Return: allocated request handle in case of success, or NULL if out of memory
1181	*/
1182	static inline struct ablkcipher_request *ablkcipher_request_alloc(
1183	struct crypto_ablkcipher *tfm, gfp_t gfp)
1184	{
1185	struct ablkcipher_request *req;
1186
1187	req = kmalloc(sizeof(struct ablkcipher_request) +
1188	crypto_ablkcipher_reqsize(tfm), gfp);
1189
1190	if (likely(req))
1191	ablkcipher_request_set_tfm(req, tfm);
1192
1193	return req;
1194	}
1195
1196	/**
1197	* ablkcipher_request_free() - zeroize and free request data structure
1198	* @req: request data structure cipher handle to be freed
1199	*/
1200	static inline void ablkcipher_request_free(struct ablkcipher_request *req)
1201	{
1202	kzfree(req);
1203	}
1204
1205	/**
1206	* ablkcipher_request_set_callback() - set asynchronous callback function
1207	* @req: request handle
1208	* @flags: specify zero or an ORing of the flags
1209	* CRYPTO_TFM_REQ_MAY_BACKLOG the request queue may back log and
1210	* increase the wait queue beyond the initial maximum size;
1211	* CRYPTO_TFM_REQ_MAY_SLEEP the request processing may sleep
1212	* @compl: callback function pointer to be registered with the request handle
1213	* @data: The data pointer refers to memory that is not used by the kernel
1214	* crypto API, but provided to the callback function for it to use. Here,
1215	* the caller can provide a reference to memory the callback function can
1216	* operate on. As the callback function is invoked asynchronously to the
1217	* related functionality, it may need to access data structures of the
1218	* related functionality which can be referenced using this pointer. The
1219	* callback function can access the memory via the "data" field in the
1220	* crypto_async_request data structure provided to the callback function.
1221	*
1222	* This function allows setting the callback function that is triggered once the
1223	* cipher operation completes.
1224	*
1225	* The callback function is registered with the ablkcipher_request handle and
1226	* must comply with the following template::
1227	*
1228	* void callback_function(struct crypto_async_request *req, int error)
1229	*/
1230	static inline void ablkcipher_request_set_callback(
1231	struct ablkcipher_request *req,
1232	u32 flags, crypto_completion_t compl, void *data)
1233	{
1234	req->base.complete = compl;
1235	req->base.data = data;
1236	req->base.flags = flags;
1237	}
1238
1239	/**
1240	* ablkcipher_request_set_crypt() - set data buffers
1241	* @req: request handle
1242	* @src: source scatter / gather list
1243	* @dst: destination scatter / gather list
1244	* @nbytes: number of bytes to process from @src
1245	* @iv: IV for the cipher operation which must comply with the IV size defined
1246	* by crypto_ablkcipher_ivsize
1247	*
1248	* This function allows setting of the source data and destination data
1249	* scatter / gather lists.
1250	*
1251	* For encryption, the source is treated as the plaintext and the
1252	* destination is the ciphertext. For a decryption operation, the use is
1253	* reversed - the source is the ciphertext and the destination is the plaintext.
1254	*/
1255	static inline void ablkcipher_request_set_crypt(
1256	struct ablkcipher_request *req,
1257	struct scatterlist src, struct scatterlist dst,
1258	unsigned int nbytes, void *iv)
1259	{
1260	req->src = src;
1261	req->dst = dst;
1262	req->nbytes = nbytes;
1263	req->info = iv;
1264	}
1265
1266	/**
1267	* DOC: Synchronous Block Cipher API
1268	*
1269	* The synchronous block cipher API is used with the ciphers of type
1270	* CRYPTO_ALG_TYPE_BLKCIPHER (listed as type "blkcipher" in /proc/crypto)
1271	*
1272	* Synchronous calls, have a context in the tfm. But since a single tfm can be
1273	* used in multiple calls and in parallel, this info should not be changeable
1274	* (unless a lock is used). This applies, for example, to the symmetric key.
1275	* However, the IV is changeable, so there is an iv field in blkcipher_tfm
1276	* structure for synchronous blkcipher api. So, its the only state info that can
1277	* be kept for synchronous calls without using a big lock across a tfm.
1278	*
1279	* The block cipher API allows the use of a complete cipher, i.e. a cipher
1280	* consisting of a template (a block chaining mode) and a single block cipher
1281	* primitive (e.g. AES).
1282	*
1283	* The plaintext data buffer and the ciphertext data buffer are pointed to
1284	* by using scatter/gather lists. The cipher operation is performed
1285	* on all segments of the provided scatter/gather lists.
1286	*
1287	* The kernel crypto API supports a cipher operation "in-place" which means that
1288	* the caller may provide the same scatter/gather list for the plaintext and
1289	* cipher text. After the completion of the cipher operation, the plaintext
1290	* data is replaced with the ciphertext data in case of an encryption and vice
1291	* versa for a decryption. The caller must ensure that the scatter/gather lists
1292	* for the output data point to sufficiently large buffers, i.e. multiples of
1293	* the block size of the cipher.
1294	*/
1295
1296	static inline struct crypto_blkcipher *__crypto_blkcipher_cast(
1297	struct crypto_tfm *tfm)
1298	{
1299	return (struct crypto_blkcipher *)tfm;
1300	}
1301
1302	static inline struct crypto_blkcipher *crypto_blkcipher_cast(
1303	struct crypto_tfm *tfm)
1304	{
1305	BUG_ON(crypto_tfm_alg_type(tfm) != CRYPTO_ALG_TYPE_BLKCIPHER);
1306	return __crypto_blkcipher_cast(tfm);
1307	}
1308
1309	/**
1310	* crypto_alloc_blkcipher() - allocate synchronous block cipher handle
1311	* @alg_name: is the cra_name / name or cra_driver_name / driver name of the
1312	* blkcipher cipher
1313	* @type: specifies the type of the cipher
1314	* @mask: specifies the mask for the cipher
1315	*
1316	* Allocate a cipher handle for a block cipher. The returned struct
1317	* crypto_blkcipher is the cipher handle that is required for any subsequent
1318	* API invocation for that block cipher.
1319	*
1320	* Return: allocated cipher handle in case of success; IS_ERR() is true in case
1321	* of an error, PTR_ERR() returns the error code.
1322	*/
1323	static inline struct crypto_blkcipher *crypto_alloc_blkcipher(
1324	const char *alg_name, u32 type, u32 mask)
1325	{
1326	type &= ~CRYPTO_ALG_TYPE_MASK;
1327	type \|= CRYPTO_ALG_TYPE_BLKCIPHER;
1328	mask \|= CRYPTO_ALG_TYPE_MASK;
1329
1330	return __crypto_blkcipher_cast(crypto_alloc_base(alg_name, type, mask));
1331	}
1332
1333	static inline struct crypto_tfm *crypto_blkcipher_tfm(
1334	struct crypto_blkcipher *tfm)
1335	{
1336	return &tfm->base;
1337	}
1338
1339	/**
1340	* crypto_free_blkcipher() - zeroize and free the block cipher handle
1341	* @tfm: cipher handle to be freed
1342	*/
1343	static inline void crypto_free_blkcipher(struct crypto_blkcipher *tfm)
1344	{
1345	crypto_free_tfm(crypto_blkcipher_tfm(tfm));
1346	}
1347
1348	/**
1349	* crypto_has_blkcipher() - Search for the availability of a block cipher
1350	* @alg_name: is the cra_name / name or cra_driver_name / driver name of the
1351	* block cipher
1352	* @type: specifies the type of the cipher
1353	* @mask: specifies the mask for the cipher
1354	*
1355	* Return: true when the block cipher is known to the kernel crypto API; false
1356	* otherwise
1357	*/
1358	static inline int crypto_has_blkcipher(const char *alg_name, u32 type, u32 mask)
1359	{
1360	type &= ~CRYPTO_ALG_TYPE_MASK;
1361	type \|= CRYPTO_ALG_TYPE_BLKCIPHER;
1362	mask \|= CRYPTO_ALG_TYPE_MASK;
1363
1364	return crypto_has_alg(alg_name, type, mask);
1365	}
1366
1367	/**
1368	* crypto_blkcipher_name() - return the name / cra_name from the cipher handle
1369	* @tfm: cipher handle
1370	*
1371	* Return: The character string holding the name of the cipher
1372	*/
1373	static inline const char crypto_blkcipher_name(struct crypto_blkcipher tfm)
1374	{
1375	return crypto_tfm_alg_name(crypto_blkcipher_tfm(tfm));
1376	}
1377
1378	static inline struct blkcipher_tfm *crypto_blkcipher_crt(
1379	struct crypto_blkcipher *tfm)
1380	{
1381	return &crypto_blkcipher_tfm(tfm)->crt_blkcipher;
1382	}
1383
1384	static inline struct blkcipher_alg *crypto_blkcipher_alg(
1385	struct crypto_blkcipher *tfm)
1386	{
1387	return &crypto_blkcipher_tfm(tfm)->__crt_alg->cra_blkcipher;
1388	}
1389
1390	/**
1391	* crypto_blkcipher_ivsize() - obtain IV size
1392	* @tfm: cipher handle
1393	*
1394	* The size of the IV for the block cipher referenced by the cipher handle is
1395	* returned. This IV size may be zero if the cipher does not need an IV.
1396	*
1397	* Return: IV size in bytes
1398	*/
1399	static inline unsigned int crypto_blkcipher_ivsize(struct crypto_blkcipher *tfm)
1400	{
1401	return crypto_blkcipher_alg(tfm)->ivsize;
1402	}
1403
1404	/**
1405	* crypto_blkcipher_blocksize() - obtain block size of cipher
1406	* @tfm: cipher handle
1407	*
1408	* The block size for the block cipher referenced with the cipher handle is
1409	* returned. The caller may use that information to allocate appropriate
1410	* memory for the data returned by the encryption or decryption operation.
1411	*
1412	* Return: block size of cipher
1413	*/
1414	static inline unsigned int crypto_blkcipher_blocksize(
1415	struct crypto_blkcipher *tfm)
1416	{
1417	return crypto_tfm_alg_blocksize(crypto_blkcipher_tfm(tfm));
1418	}
1419
1420	static inline unsigned int crypto_blkcipher_alignmask(
1421	struct crypto_blkcipher *tfm)
1422	{
1423	return crypto_tfm_alg_alignmask(crypto_blkcipher_tfm(tfm));
1424	}
1425
1426	static inline u32 crypto_blkcipher_get_flags(struct crypto_blkcipher *tfm)
1427	{
1428	return crypto_tfm_get_flags(crypto_blkcipher_tfm(tfm));
1429	}
1430
1431	static inline void crypto_blkcipher_set_flags(struct crypto_blkcipher *tfm,
1432	u32 flags)
1433	{
1434	crypto_tfm_set_flags(crypto_blkcipher_tfm(tfm), flags);
1435	}
1436
1437	static inline void crypto_blkcipher_clear_flags(struct crypto_blkcipher *tfm,
1438	u32 flags)
1439	{
1440	crypto_tfm_clear_flags(crypto_blkcipher_tfm(tfm), flags);
1441	}
1442
1443	/**
1444	* crypto_blkcipher_setkey() - set key for cipher
1445	* @tfm: cipher handle
1446	* @key: buffer holding the key
1447	* @keylen: length of the key in bytes
1448	*
1449	* The caller provided key is set for the block cipher referenced by the cipher
1450	* handle.
1451	*
1452	* Note, the key length determines the cipher type. Many block ciphers implement
1453	* different cipher modes depending on the key size, such as AES-128 vs AES-192
1454	* vs. AES-256. When providing a 16 byte key for an AES cipher handle, AES-128
1455	* is performed.
1456	*
1457	* Return: 0 if the setting of the key was successful; < 0 if an error occurred
1458	*/
1459	static inline int crypto_blkcipher_setkey(struct crypto_blkcipher *tfm,
1460	const u8 *key, unsigned int keylen)
1461	{
1462	return crypto_blkcipher_crt(tfm)->setkey(crypto_blkcipher_tfm(tfm),
1463	key, keylen);
1464	}
1465
1466	/**
1467	* crypto_blkcipher_encrypt() - encrypt plaintext
1468	* @desc: reference to the block cipher handle with meta data
1469	* @dst: scatter/gather list that is filled by the cipher operation with the
1470	* ciphertext
1471	* @src: scatter/gather list that holds the plaintext
1472	* @nbytes: number of bytes of the plaintext to encrypt.
1473	*
1474	* Encrypt plaintext data using the IV set by the caller with a preceding
1475	* call of crypto_blkcipher_set_iv.
1476	*
1477	* The blkcipher_desc data structure must be filled by the caller and can
1478	* reside on the stack. The caller must fill desc as follows: desc.tfm is filled
1479	* with the block cipher handle; desc.flags is filled with either
1480	* CRYPTO_TFM_REQ_MAY_SLEEP or 0.
1481	*
1482	* Return: 0 if the cipher operation was successful; < 0 if an error occurred
1483	*/
1484	static inline int crypto_blkcipher_encrypt(struct blkcipher_desc *desc,
1485	struct scatterlist *dst,
1486	struct scatterlist *src,
1487	unsigned int nbytes)
1488	{
1489	desc->info = crypto_blkcipher_crt(desc->tfm)->iv;
1490	return crypto_blkcipher_crt(desc->tfm)->encrypt(desc, dst, src, nbytes);
1491	}
1492
1493	/**
1494	* crypto_blkcipher_encrypt_iv() - encrypt plaintext with dedicated IV
1495	* @desc: reference to the block cipher handle with meta data
1496	* @dst: scatter/gather list that is filled by the cipher operation with the
1497	* ciphertext
1498	* @src: scatter/gather list that holds the plaintext
1499	* @nbytes: number of bytes of the plaintext to encrypt.
1500	*
1501	* Encrypt plaintext data with the use of an IV that is solely used for this
1502	* cipher operation. Any previously set IV is not used.
1503	*
1504	* The blkcipher_desc data structure must be filled by the caller and can
1505	* reside on the stack. The caller must fill desc as follows: desc.tfm is filled
1506	* with the block cipher handle; desc.info is filled with the IV to be used for
1507	* the current operation; desc.flags is filled with either
1508	* CRYPTO_TFM_REQ_MAY_SLEEP or 0.
1509	*
1510	* Return: 0 if the cipher operation was successful; < 0 if an error occurred
1511	*/
1512	static inline int crypto_blkcipher_encrypt_iv(struct blkcipher_desc *desc,
1513	struct scatterlist *dst,
1514	struct scatterlist *src,
1515	unsigned int nbytes)
1516	{
1517	return crypto_blkcipher_crt(desc->tfm)->encrypt(desc, dst, src, nbytes);
1518	}
1519
1520	/**
1521	* crypto_blkcipher_decrypt() - decrypt ciphertext
1522	* @desc: reference to the block cipher handle with meta data
1523	* @dst: scatter/gather list that is filled by the cipher operation with the
1524	* plaintext
1525	* @src: scatter/gather list that holds the ciphertext
1526	* @nbytes: number of bytes of the ciphertext to decrypt.
1527	*
1528	* Decrypt ciphertext data using the IV set by the caller with a preceding
1529	* call of crypto_blkcipher_set_iv.
1530	*
1531	* The blkcipher_desc data structure must be filled by the caller as documented
1532	* for the crypto_blkcipher_encrypt call above.
1533	*
1534	* Return: 0 if the cipher operation was successful; < 0 if an error occurred
1535	*
1536	*/
1537	static inline int crypto_blkcipher_decrypt(struct blkcipher_desc *desc,
1538	struct scatterlist *dst,
1539	struct scatterlist *src,
1540	unsigned int nbytes)
1541	{
1542	desc->info = crypto_blkcipher_crt(desc->tfm)->iv;
1543	return crypto_blkcipher_crt(desc->tfm)->decrypt(desc, dst, src, nbytes);
1544	}
1545
1546	/**
1547	* crypto_blkcipher_decrypt_iv() - decrypt ciphertext with dedicated IV
1548	* @desc: reference to the block cipher handle with meta data
1549	* @dst: scatter/gather list that is filled by the cipher operation with the
1550	* plaintext
1551	* @src: scatter/gather list that holds the ciphertext
1552	* @nbytes: number of bytes of the ciphertext to decrypt.
1553	*
1554	* Decrypt ciphertext data with the use of an IV that is solely used for this
1555	* cipher operation. Any previously set IV is not used.
1556	*
1557	* The blkcipher_desc data structure must be filled by the caller as documented
1558	* for the crypto_blkcipher_encrypt_iv call above.
1559	*
1560	* Return: 0 if the cipher operation was successful; < 0 if an error occurred
1561	*/
1562	static inline int crypto_blkcipher_decrypt_iv(struct blkcipher_desc *desc,
1563	struct scatterlist *dst,
1564	struct scatterlist *src,
1565	unsigned int nbytes)
1566	{
1567	return crypto_blkcipher_crt(desc->tfm)->decrypt(desc, dst, src, nbytes);
1568	}
1569
1570	/**
1571	* crypto_blkcipher_set_iv() - set IV for cipher
1572	* @tfm: cipher handle
1573	* @src: buffer holding the IV
1574	* @len: length of the IV in bytes
1575	*
1576	* The caller provided IV is set for the block cipher referenced by the cipher
1577	* handle.
1578	*/
1579	static inline void crypto_blkcipher_set_iv(struct crypto_blkcipher *tfm,
1580	const u8 *src, unsigned int len)
1581	{
1582	memcpy(crypto_blkcipher_crt(tfm)->iv, src, len);
1583	}
1584
1585	/**
1586	* crypto_blkcipher_get_iv() - obtain IV from cipher
1587	* @tfm: cipher handle
1588	* @dst: buffer filled with the IV
1589	* @len: length of the buffer dst
1590	*
1591	* The caller can obtain the IV set for the block cipher referenced by the
1592	* cipher handle and store it into the user-provided buffer. If the buffer
1593	* has an insufficient space, the IV is truncated to fit the buffer.
1594	*/
1595	static inline void crypto_blkcipher_get_iv(struct crypto_blkcipher *tfm,
1596	u8 *dst, unsigned int len)
1597	{
1598	memcpy(dst, crypto_blkcipher_crt(tfm)->iv, len);
1599	}
1600
1601	/**	744	/**
1602	* DOC: Single Block Cipher API	745	* DOC: Single Block Cipher API
1603	*	746	*

include/linux/dcache.h+5−0

 	return d_is_miss(dentry);
 }
+static inline bool d_flags_negative(unsigned flags)
+{
+	return (flags & DCACHE_ENTRY_TYPE) == DCACHE_MISS_TYPE;
+}
 static inline bool d_is_positive(const struct dentry *dentry)
 {
 	return !d_is_negative(dentry);

include/linux/debugfs.h+63−73

 	.llseek  = no_llseek,						\
 }
+typedef struct vfsmount *(*debugfs_automount_t)(struct dentry *, void *);
 #if defined(CONFIG_DEBUG_FS)
 struct dentry *debugfs_lookup(const char *name, struct dentry *parent);
 struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent,
 				      const char *dest);
-typedef struct vfsmount *(*debugfs_automount_t)(struct dentry *, void *);
 struct dentry *debugfs_create_automount(const char *name,
 					struct dentry *parent,
 					debugfs_automount_t f,
 struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
                 struct dentry *new_dir, const char *new_name);
-struct dentry *debugfs_create_u8(const char *name, umode_t mode,
+void debugfs_create_u8(const char *name, umode_t mode, struct dentry *parent,
-				 struct dentry *parent, u8 *value);
+		       u8 *value);
-struct dentry *debugfs_create_u16(const char *name, umode_t mode,
+void debugfs_create_u16(const char *name, umode_t mode, struct dentry *parent,
-				  struct dentry *parent, u16 *value);
+			u16 *value);
 struct dentry *debugfs_create_u32(const char *name, umode_t mode,
 				  struct dentry *parent, u32 *value);
-struct dentry *debugfs_create_u64(const char *name, umode_t mode,
+void debugfs_create_u64(const char *name, umode_t mode, struct dentry *parent,
-				  struct dentry *parent, u64 *value);
+			u64 *value);
 struct dentry *debugfs_create_ulong(const char *name, umode_t mode,
 				    struct dentry *parent, unsigned long *value);
-struct dentry *debugfs_create_x8(const char *name, umode_t mode,
+void debugfs_create_x8(const char *name, umode_t mode, struct dentry *parent,
-				 struct dentry *parent, u8 *value);
+		       u8 *value);
-struct dentry *debugfs_create_x16(const char *name, umode_t mode,
+void debugfs_create_x16(const char *name, umode_t mode, struct dentry *parent,
-				  struct dentry *parent, u16 *value);
+			u16 *value);
-struct dentry *debugfs_create_x32(const char *name, umode_t mode,
+void debugfs_create_x32(const char *name, umode_t mode, struct dentry *parent,
-				  struct dentry *parent, u32 *value);
+			u32 *value);
-struct dentry *debugfs_create_x64(const char *name, umode_t mode,
+void debugfs_create_x64(const char *name, umode_t mode, struct dentry *parent,
-				  struct dentry *parent, u64 *value);
+			u64 *value);
-struct dentry *debugfs_create_size_t(const char *name, umode_t mode,
+void debugfs_create_size_t(const char *name, umode_t mode,
-				     struct dentry *parent, size_t *value);
+			   struct dentry *parent, size_t *value);
-struct dentry *debugfs_create_atomic_t(const char *name, umode_t mode,
+void debugfs_create_atomic_t(const char *name, umode_t mode,
-				     struct dentry *parent, atomic_t *value);
+			     struct dentry *parent, atomic_t *value);
 struct dentry *debugfs_create_bool(const char *name, umode_t mode,
 				  struct dentry *parent, bool *value);
 static inline struct dentry *debugfs_create_automount(const char *name,
 					struct dentry *parent,
-					struct vfsmount *(*f)(void *),
+					debugfs_automount_t f,
 					void *data)
 {
 	return ERR_PTR(-ENODEV);
 	return ERR_PTR(-ENODEV);
 }
-static inline struct dentry *debugfs_create_u8(const char *name, umode_t mode,
+static inline void debugfs_create_u8(const char *name, umode_t mode,
-					       struct dentry *parent,
+				     struct dentry *parent, u8 *value) { }
-					       u8 *value)
-{
-	return ERR_PTR(-ENODEV);
-}
-static inline struct dentry *debugfs_create_u16(const char *name, umode_t mode,
+static inline void debugfs_create_u16(const char *name, umode_t mode,
-						struct dentry *parent,
+				      struct dentry *parent, u16 *value) { }
-						u16 *value)
-{
-	return ERR_PTR(-ENODEV);
-}
 static inline struct dentry *debugfs_create_u32(const char *name, umode_t mode,
 						struct dentry *parent,
 	return ERR_PTR(-ENODEV);
 }
-static inline struct dentry *debugfs_create_u64(const char *name, umode_t mode,
+static inline void debugfs_create_u64(const char *name, umode_t mode,
-						struct dentry *parent,
+				      struct dentry *parent, u64 *value) { }
-						u64 *value)
-{
-	return ERR_PTR(-ENODEV);
-}
 static inline struct dentry *debugfs_create_ulong(const char *name,
 						umode_t mode,
 	return ERR_PTR(-ENODEV);
 }
-static inline struct dentry *debugfs_create_x8(const char *name, umode_t mode,
+static inline void debugfs_create_x8(const char *name, umode_t mode,
-					       struct dentry *parent,
+				     struct dentry *parent, u8 *value) { }
-					       u8 *value)
-{
-	return ERR_PTR(-ENODEV);
-}
-static inline struct dentry *debugfs_create_x16(const char *name, umode_t mode,
+static inline void debugfs_create_x16(const char *name, umode_t mode,
-						struct dentry *parent,
+				      struct dentry *parent, u16 *value) { }
-						u16 *value)
-{
-	return ERR_PTR(-ENODEV);
-}
-static inline struct dentry *debugfs_create_x32(const char *name, umode_t mode,
+static inline void debugfs_create_x32(const char *name, umode_t mode,
-						struct dentry *parent,
+				      struct dentry *parent, u32 *value) { }
-						u32 *value)
-{
-	return ERR_PTR(-ENODEV);
-}
-static inline struct dentry *debugfs_create_x64(const char *name, umode_t mode,
+static inline void debugfs_create_x64(const char *name, umode_t mode,
-						struct dentry *parent,
+				      struct dentry *parent, u64 *value) { }
-						u64 *value)
-{
-	return ERR_PTR(-ENODEV);
-}
-static inline struct dentry *debugfs_create_size_t(const char *name, umode_t mode,
+static inline void debugfs_create_size_t(const char *name, umode_t mode,
-				     struct dentry *parent,
+					 struct dentry *parent, size_t *value)
-				     size_t *value)
+{ }
-{
-	return ERR_PTR(-ENODEV);
-}
-static inline struct dentry *debugfs_create_atomic_t(const char *name, umode_t mode,
+static inline void debugfs_create_atomic_t(const char *name, umode_t mode,
-				     struct dentry *parent, atomic_t *value)
+					   struct dentry *parent,
-{
+					   atomic_t *value)
-	return ERR_PTR(-ENODEV);
+{ }
-}
 static inline struct dentry *debugfs_create_bool(const char *name, umode_t mode,
 						 struct dentry *parent,
 #endif
+/**
+ * debugfs_create_xul - create a debugfs file that is used to read and write an
+ * unsigned long value, formatted in hexadecimal
+ * @name: a pointer to a string containing the name of the file to create.
+ * @mode: the permission that the file should have
+ * @parent: a pointer to the parent dentry for this file.  This should be a
+ *          directory dentry if set.  If this parameter is %NULL, then the
+ *          file will be created in the root of the debugfs filesystem.
+ * @value: a pointer to the variable that the file should read to and write
+ *         from.
+ */
+static inline void debugfs_create_xul(const char *name, umode_t mode,
+				      struct dentry *parent,
+				      unsigned long *value)
+{
+	if (sizeof(*value) == sizeof(u32))
+		debugfs_create_x32(name, mode, parent, (u32 *)value);
+	else
+		debugfs_create_x64(name, mode, parent, (u64 *)value);
+}
 #endif

include/linux/devfreq.h+10−4

 #include <linux/device.h>
 #include <linux/notifier.h>
 #include <linux/pm_opp.h>
+#include <linux/pm_qos.h>
 #define DEVFREQ_NAME_LEN 16
  * @previous_freq:	previously configured frequency value.
  * @data:	Private data of the governor. The devfreq framework does not
  *		touch this.
- * @min_freq:	Limit minimum frequency requested by user (0: none)
+ * @user_min_freq_req:	PM QoS minimum frequency request from user (via sysfs)
- * @max_freq:	Limit maximum frequency requested by user (0: none)
+ * @user_max_freq_req:	PM QoS maximum frequency request from user (via sysfs)
  * @scaling_min_freq:	Limit minimum frequency requested by OPP interface
  * @scaling_max_freq:	Limit maximum frequency requested by OPP interface
  * @stop_polling:	 devfreq polling status of a device.
  * @time_in_state:	Statistics of devfreq states
  * @last_stat_updated:	The last time stat updated
  * @transition_notifier_list: list head of DEVFREQ_TRANSITION_NOTIFIER notifier
+ * @nb_min:		Notifier block for DEV_PM_QOS_MIN_FREQUENCY
+ * @nb_max:		Notifier block for DEV_PM_QOS_MAX_FREQUENCY
  *
  * This structure stores the devfreq information for a give device.
  *
 	void *data; /* private data for governors */
-	unsigned long min_freq;
+	struct dev_pm_qos_request user_min_freq_req;
-	unsigned long max_freq;
+	struct dev_pm_qos_request user_max_freq_req;
 	unsigned long scaling_min_freq;
 	unsigned long scaling_max_freq;
 	bool stop_polling;
 	unsigned long last_stat_updated;
 	struct srcu_notifier_head transition_notifier_list;
+	struct notifier_block nb_min;
+	struct notifier_block nb_max;
 };
 struct devfreq_freqs {

include/linux/device-mapper.h+19−8

 struct dm_dev;
 struct dm_target;
 struct dm_table;
+struct dm_report_zones_args;
 struct mapped_device;
 struct bio_vec;
 typedef int (*dm_prepare_ioctl_fn) (struct dm_target *ti, struct block_device **bdev);
-typedef int (*dm_report_zones_fn) (struct dm_target *ti, sector_t sector,
+typedef int (*dm_report_zones_fn) (struct dm_target *ti,
-				   struct blk_zone *zones,
+				   struct dm_report_zones_args *args,
-				   unsigned int *nr_zones);
+				   unsigned int nr_zones);
 /*
  * These iteration functions are typically used to check (and combine)
 int dm_suspended(struct dm_target *ti);
 int dm_noflush_suspending(struct dm_target *ti);
 void dm_accept_partial_bio(struct bio *bio, unsigned n_sectors);
-void dm_remap_zone_report(struct dm_target *ti, sector_t start,
-			  struct blk_zone *zones, unsigned int *nr_zones);
 union map_info *dm_get_rq_mapinfo(struct request *rq);
+#ifdef CONFIG_BLK_DEV_ZONED
+struct dm_report_zones_args {
+	struct dm_target *tgt;
+	sector_t next_sector;
+	void *orig_data;
+	report_zones_cb orig_cb;
+	unsigned int zone_idx;
+	/* must be filled by ->report_zones before calling dm_report_zones_cb */
+	sector_t start;
+};
+int dm_report_zones_cb(struct blk_zone *zone, unsigned int idx, void *data);
+#endif /* CONFIG_BLK_DEV_ZONED */
 /*
  * Device mapper functions to parse and create devices specified by the
  * parameter "dm-mod.create="
  */
 #define dm_round_up(n, sz) (dm_div_up((n), (sz)) * (sz))
-#define dm_array_too_big(fixed, obj, num) \
-	((num) > (UINT_MAX - (fixed)) / (obj))
 /*
  * Sector offset taken relative to the start of the target instead of
  * relative to the start of the device.

include/linux/device.h+38−5

  *		that generate uevents to add the environment variables.
  * @probe:	Called when a new device or driver add to this bus, and callback
  *		the specific driver's probe to initial the matched device.
+ * @sync_state:	Called to sync device state to software state after all the
+ *		state tracking consumers linked to this device (present at
+ *		the time of late_initcall) have successfully bound to a
+ *		driver. If the device has no consumers, this function will
+ *		be called at late_initcall_sync level. If the device has
+ *		consumers that are never bound to a driver, this function
+ *		will never get called until they do.
  * @remove:	Called when a device removed from this bus.
  * @shutdown:	Called at shut-down time to quiesce the device.
  *
 	int (*match)(struct device *dev, struct device_driver *drv);
 	int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
 	int (*probe)(struct device *dev);
+	void (*sync_state)(struct device *dev);
 	int (*remove)(struct device *dev);
 	void (*shutdown)(struct device *dev);
  * @probe:	Called to query the existence of a specific device,
  *		whether this driver can work with it, and bind the driver
  *		to a specific device.
+ * @sync_state:	Called to sync device state to software state after all the
+ *		state tracking consumers linked to this device (present at
+ *		the time of late_initcall) have successfully bound to a
+ *		driver. If the device has no consumers, this function will
+ *		be called at late_initcall_sync level. If the device has
+ *		consumers that are never bound to a driver, this function
+ *		will never get called until they do.
  * @remove:	Called when the device is removed from the system to
  *		unbind a device from this driver.
  * @shutdown:	Called at shut-down time to quiesce the device.
 	const struct acpi_device_id	*acpi_match_table;
 	int (*probe) (struct device *dev);
+	void (*sync_state)(struct device *dev);
 	int (*remove) (struct device *dev);
 	void (*shutdown) (struct device *dev);
 	int (*suspend) (struct device *dev, pm_message_t state);
 void __iomem *devm_ioremap_resource(struct device *dev,
 				    const struct resource *res);
+void __iomem *devm_ioremap_resource_wc(struct device *dev,
+				       const struct resource *res);
 void __iomem *devm_of_iomap(struct device *dev,
 			    struct device_node *node, int index,
  * AUTOREMOVE_SUPPLIER: Remove the link automatically on supplier driver unbind.
  * AUTOPROBE_CONSUMER: Probe consumer driver automatically after supplier binds.
  * MANAGED: The core tracks presence of supplier/consumer drivers (internal).
+ * SYNC_STATE_ONLY: Link only affects sync_state() behavior.
  */
 #define DL_FLAG_STATELESS		BIT(0)
 #define DL_FLAG_AUTOREMOVE_CONSUMER	BIT(1)
 #define DL_FLAG_AUTOREMOVE_SUPPLIER	BIT(4)
 #define DL_FLAG_AUTOPROBE_CONSUMER	BIT(5)
 #define DL_FLAG_MANAGED			BIT(6)
+#define DL_FLAG_SYNC_STATE_ONLY		BIT(7)
 /**
  * struct device_link - Device link representation.
  * struct dev_links_info - Device data related to device links.
  * @suppliers: List of links to supplier devices.
  * @consumers: List of links to consumer devices.
+ * @needs_suppliers: Hook to global list of devices waiting for suppliers.
+ * @defer_sync: Hook to global list of devices that have deferred sync_state.
+ * @need_for_probe: If needs_suppliers is on a list, this indicates if the
+ *		    suppliers are needed for probe or not.
  * @status: Driver status information.
  */
 struct dev_links_info {
 	struct list_head suppliers;
 	struct list_head consumers;
+	struct list_head needs_suppliers;
+	struct list_head defer_sync;
+	bool need_for_probe;
 	enum dl_dev_state status;
 };
  * @coherent_dma_mask: Like dma_mask, but for alloc_coherent mapping as not all
  * 		hardware supports 64-bit addresses for consistent allocations
  * 		such descriptors.
- * @bus_dma_mask: Mask of an upstream bridge or bus which imposes a smaller DMA
+ * @bus_dma_limit: Limit of an upstream bridge or bus which imposes a smaller
- *		limit than the device itself supports.
+ *		DMA limit than the device itself supports.
  * @dma_pfn_offset: offset of DMA memory range relatively of RAM
  * @dma_parms:	A low level driver may set these to teach IOMMU code about
  * 		segment limitations.
  * @offline:	Set after successful invocation of bus type's .offline().
  * @of_node_reused: Set if the device-tree node is shared with an ancestor
  *              device.
+ * @state_synced: The hardware state of this device has been synced to match
+ *		  the software state of this device by calling the driver/bus
+ *		  sync_state() callback.
  * @dma_coherent: this particular device is dma coherent, even if the
  *		architecture supports non-coherent devices.
  *
 					     not all hardware supports
 					     64 bit addresses for consistent
 					     allocations such descriptors. */
-	u64		bus_dma_mask;	/* upstream dma_mask constraint */
+	u64		bus_dma_limit;	/* upstream dma constraint */
 	unsigned long	dma_pfn_offset;
 	struct device_dma_parameters *dma_parms;
 	bool			offline_disabled:1;
 	bool			offline:1;
 	bool			of_node_reused:1;
+	bool			state_synced:1;
 #if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_DEVICE) || \
     defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) || \
     defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL)
 #ifdef CONFIG_DEVTMPFS
 extern int devtmpfs_create_node(struct device *dev);
 extern int devtmpfs_delete_node(struct device *dev);
-extern int devtmpfs_mount(const char *mntdir);
+extern int devtmpfs_mount(void);
 #else
 static inline int devtmpfs_create_node(struct device *dev) { return 0; }
 static inline int devtmpfs_delete_node(struct device *dev) { return 0; }
-static inline int devtmpfs_mount(const char *mountpoint) { return 0; }
+static inline int devtmpfs_mount(void) { return 0; }
 #endif
 /* drivers/base/power/shutdown.c */
 				    struct device *supplier, u32 flags);
 void device_link_del(struct device_link *link);
 void device_link_remove(void *consumer, struct device *supplier);
+void device_links_supplier_sync_state_pause(void);
+void device_links_supplier_sync_state_resume(void);
 #ifndef dev_fmt
 #define dev_fmt(fmt) fmt

include/linux/device_cgroup.h+4−15

 #define DEVCG_DEV_ALL   4  /* this represents all devices */
 #ifdef CONFIG_CGROUP_DEVICE
-extern int __devcgroup_check_permission(short type, u32 major, u32 minor,
+int devcgroup_check_permission(short type, u32 major, u32 minor,
-					short access);
+			       short access);
 #else
-static inline int __devcgroup_check_permission(short type, u32 major, u32 minor,
+static inline int devcgroup_check_permission(short type, u32 major, u32 minor,
-					       short access)
+					     short access)
 { return 0; }
 #endif
 #if defined(CONFIG_CGROUP_DEVICE) || defined(CONFIG_CGROUP_BPF)
-static inline int devcgroup_check_permission(short type, u32 major, u32 minor,
-					     short access)
-{
-	int rc = BPF_CGROUP_RUN_PROG_DEVICE_CGROUP(type, major, minor, access);
-	if (rc)
-		return -EPERM;
-	return __devcgroup_check_permission(type, major, minor, access);
-}
 static inline int devcgroup_inode_permission(struct inode *inode, int mask)
 {
 	short type, access = 0;

include/linux/dim.h+33−30

 #ifndef DIM_H
 #define DIM_H
+#include <linux/bits.h>
+#include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/types.h>
+#include <linux/workqueue.h>
-/**
+/*
  * Number of events between DIM iterations.
  * Causes a moderation of the algorithm run.
  */
 #define DIM_NEVENTS 64
-/**
+/*
  * Is a difference between values justifies taking an action.
  * We consider 10% difference as significant.
  */
 #define IS_SIGNIFICANT_DIFF(val, ref) \
 	(((100UL * abs((val) - (ref))) / (ref)) > 10)
-/**
+/*
  * Calculate the gap between two values.
  * Take wrap-around and variable size into consideration.
  */
 		& (BIT_ULL(bits) - 1))
 /**
- * Structure for CQ moderation values.
+ * struct dim_cq_moder - Structure for CQ moderation values.
  * Used for communications between DIM and its consumer.
  *
  * @usec: CQ timer suggestion (by DIM)
  * @pkts: CQ packet counter suggestion (by DIM)
- * @cq_period_mode: CQ priod count mode (from CQE/EQE)
+ * @comps: Completion counter
+ * @cq_period_mode: CQ period count mode (from CQE/EQE)
  */
 struct dim_cq_moder {
 	u16 usec;
 };
 /**
- * Structure for DIM sample data.
+ * struct dim_sample - Structure for DIM sample data.
  * Used for communications between DIM and its consumer.
  *
  * @time: Sample timestamp
  * @pkt_ctr: Number of packets
  * @byte_ctr: Number of bytes
  * @event_ctr: Number of events
+ * @comp_ctr: Current completion counter
  */
 struct dim_sample {
 	ktime_t time;
 };
 /**
- * Structure for DIM stats.
+ * struct dim_stats - Structure for DIM stats.
  * Used for holding current measured rates.
  *
  * @ppms: Packets per msec
  * @bpms: Bytes per msec
  * @epms: Events per msec
+ * @cpms: Completions per msec
+ * @cpe_ratio: Ratio of completions to events
  */
 struct dim_stats {
 	int ppms; /* packets per msec */
 };
 /**
- * Main structure for dynamic interrupt moderation (DIM).
+ * struct dim - Main structure for dynamic interrupt moderation (DIM).
  * Used for holding all information about a specific DIM instance.
  *
  * @state: Algorithm state (see below)
  * @prev_stats: Measured rates from previous iteration (for comparison)
  * @start_sample: Sampled data at start of current iteration
+ * @measuring_sample: A &dim_sample that is used to update the current events
  * @work: Work to perform on action required
  * @priv: A pointer to the struct that points to dim
  * @profile_ix: Current moderation profile
 };
 /**
- * enum dim_cq_period_mode
+ * enum dim_cq_period_mode - Modes for CQ period count
- *
- * These are the modes for CQ period count.
  *
  * @DIM_CQ_PERIOD_MODE_START_FROM_EQE: Start counting from EQE
  * @DIM_CQ_PERIOD_MODE_START_FROM_CQE: Start counting from CQE (implies timer reset)
  * @DIM_CQ_PERIOD_NUM_MODES: Number of modes
  */
-enum {
+enum dim_cq_period_mode {
 	DIM_CQ_PERIOD_MODE_START_FROM_EQE = 0x0,
 	DIM_CQ_PERIOD_MODE_START_FROM_CQE = 0x1,
 	DIM_CQ_PERIOD_NUM_MODES
 };
 /**
- * enum dim_state
+ * enum dim_state - DIM algorithm states
  *
- * These are the DIM algorithm states.
  * These will determine if the algorithm is in a valid state to start an iteration.
  *
  * @DIM_START_MEASURE: This is the first iteration (also after applying a new profile)
  * need to perform an action
  * @DIM_APPLY_NEW_PROFILE: DIM consumer is currently applying a profile - no need to measure
  */
-enum {
+enum dim_state {
 	DIM_START_MEASURE,
 	DIM_MEASURE_IN_PROGRESS,
 	DIM_APPLY_NEW_PROFILE,
 };
 /**
- * enum dim_tune_state
+ * enum dim_tune_state - DIM algorithm tune states
  *
- * These are the DIM algorithm tune states.
  * These will determine which action the algorithm should perform.
  *
  * @DIM_PARKING_ON_TOP: Algorithm found a local top point - exit on significant difference
  * @DIM_GOING_RIGHT: Algorithm is currently trying higher moderation levels
  * @DIM_GOING_LEFT: Algorithm is currently trying lower moderation levels
  */
-enum {
+enum dim_tune_state {
 	DIM_PARKING_ON_TOP,
 	DIM_PARKING_TIRED,
 	DIM_GOING_RIGHT,
 };
 /**
- * enum dim_stats_state
+ * enum dim_stats_state - DIM algorithm statistics states
  *
- * These are the DIM algorithm statistics states.
  * These will determine the verdict of current iteration.
  *
  * @DIM_STATS_WORSE: Current iteration shows worse performance than before
- * @DIM_STATS_WORSE: Current iteration shows same performance than before
+ * @DIM_STATS_SAME:  Current iteration shows same performance than before
- * @DIM_STATS_WORSE: Current iteration shows better performance than before
+ * @DIM_STATS_BETTER: Current iteration shows better performance than before
  */
-enum {
+enum dim_stats_state {
 	DIM_STATS_WORSE,
 	DIM_STATS_SAME,
 	DIM_STATS_BETTER,
 };
 /**
- * enum dim_step_result
+ * enum dim_step_result - DIM algorithm step results
  *
- * These are the DIM algorithm step results.
  * These describe the result of a step.
  *
  * @DIM_STEPPED: Performed a regular step
  * tired parking
  * @DIM_ON_EDGE: Stepped to the most left/right profile
  */
-enum {
+enum dim_step_result {
 	DIM_STEPPED,
 	DIM_TOO_TIRED,
 	DIM_ON_EDGE,
 bool dim_on_top(struct dim *dim);
 /**
- *	dim_turn - change profile alterning direction
+ *	dim_turn - change profile altering direction
  *	@dim: DIM context
  *
  * Go left if we were going right and vice-versa.
 		    struct dim_stats *curr_stats);
 /**
- *	dim_update_sample - set a sample's fields with give values
+ *	dim_update_sample - set a sample's fields with given values
  *	@event_ctr: number of events to set
  *	@packets: number of packets to set
  *	@bytes: number of bytes to set
  *	@end_sample: Current data measurement
  *
  * Called by the consumer.
- * This is the main logic of the algorithm, where data is processed in order to decide on next
+ * This is the main logic of the algorithm, where data is processed in order
- * required action.
+ * to decide on next required action.
  */
 void net_dim(struct dim *dim, struct dim_sample end_sample);

include/linux/dma-buf.h+57−6

 	  */
 	bool cache_sgt_mapping;
+	/**
+	 * @dynamic_mapping:
+	 *
+	 * If true the framework makes sure that the map/unmap_dma_buf
+	 * callbacks are always called with the dma_resv object locked.
+	 *
+	 * If false the framework makes sure that the map/unmap_dma_buf
+	 * callbacks are always called without the dma_resv object locked.
+	 * Mutual exclusive with @cache_sgt_mapping.
+	 */
+	bool dynamic_mapping;
 	/**
 	 * @attach:
 	 *
 	 * any other kind of sharing that the exporter might wish to make
 	 * available to buffer-users.
 	 *
+	 * This is always called with the dmabuf->resv object locked when
+	 * the dynamic_mapping flag is true.
+	 *
 	 * Returns:
 	 *
 	 * A &sg_table scatter list of or the backing storage of the DMA buffer,
  * struct dma_buf - shared buffer object
  * @size: size of the buffer
  * @file: file pointer used for sharing buffers across, and for refcounting.
- * @attachments: list of dma_buf_attachment that denotes all devices attached.
+ * @attachments: list of dma_buf_attachment that denotes all devices attached,
+ *               protected by dma_resv lock.
  * @ops: dma_buf_ops associated with this buffer object.
  * @lock: used internally to serialize list manipulation, attach/detach and
- *        vmap/unmap, and accesses to name
+ *        vmap/unmap
  * @vmapping_counter: used internally to refcnt the vmaps
  * @vmap_ptr: the current vmap ptr if vmapping_counter > 0
  * @exp_name: name of the exporter; useful for debugging.
- * @name: userspace-provided name; useful for accounting and debugging.
+ * @name: userspace-provided name; useful for accounting and debugging,
+ *        protected by @resv.
  * @owner: pointer to exporter module; used for refcounting when exporter is a
  *         kernel module.
  * @list_node: node for dma_buf accounting and debugging.
  * struct dma_buf_attachment - holds device-buffer attachment data
  * @dmabuf: buffer for this attachment.
  * @dev: device attached to the buffer.
- * @node: list of dma_buf_attachment.
+ * @node: list of dma_buf_attachment, protected by dma_resv lock of the dmabuf.
  * @sgt: cached mapping.
  * @dir: direction of cached mapping.
  * @priv: exporter specific attachment data.
+ * @dynamic_mapping: true if dma_buf_map/unmap_attachment() is called with the
+ * dma_resv lock held.
  *
  * This structure holds the attachment information between the dma_buf buffer
  * and its user device(s). The list contains one attachment struct per device
 	struct list_head node;
 	struct sg_table *sgt;
 	enum dma_data_direction dir;
+	bool dynamic_mapping;
 	void *priv;
 };
 	get_file(dmabuf->file);
 }
+/**
+ * dma_buf_is_dynamic - check if a DMA-buf uses dynamic mappings.
+ * @dmabuf: the DMA-buf to check
+ *
+ * Returns true if a DMA-buf exporter wants to be called with the dma_resv
+ * locked for the map/unmap callbacks, false if it doesn't wants to be called
+ * with the lock held.
+ */
+static inline bool dma_buf_is_dynamic(struct dma_buf *dmabuf)
+{
+	return dmabuf->ops->dynamic_mapping;
+}
+/**
+ * dma_buf_attachment_is_dynamic - check if a DMA-buf attachment uses dynamic
+ * mappinsg
+ * @attach: the DMA-buf attachment to check
+ *
+ * Returns true if a DMA-buf importer wants to call the map/unmap functions with
+ * the dma_resv lock held.
+ */
+static inline bool
+dma_buf_attachment_is_dynamic(struct dma_buf_attachment *attach)
+{
+	return attach->dynamic_mapping;
+}
 struct dma_buf_attachment *dma_buf_attach(struct dma_buf *dmabuf,
-							struct device *dev);
+					  struct device *dev);
+struct dma_buf_attachment *
+dma_buf_dynamic_attach(struct dma_buf *dmabuf, struct device *dev,
+		       bool dynamic_mapping);
 void dma_buf_detach(struct dma_buf *dmabuf,
-				struct dma_buf_attachment *dmabuf_attach);
+		    struct dma_buf_attachment *attach);
 struct dma_buf *dma_buf_export(const struct dma_buf_export_info *exp_info);
 					enum dma_data_direction);
 void dma_buf_unmap_attachment(struct dma_buf_attachment *, struct sg_table *,
 				enum dma_data_direction);
+void dma_buf_move_notify(struct dma_buf *dma_buf);
 int dma_buf_begin_cpu_access(struct dma_buf *dma_buf,
 			     enum dma_data_direction dir);
 int dma_buf_end_cpu_access(struct dma_buf *dma_buf,

include/linux/dma-direct.h+26−11

 #define _LINUX_DMA_DIRECT_H 1
 #include <linux/dma-mapping.h>
+#include <linux/memblock.h> /* for min_low_pfn */
 #include <linux/mem_encrypt.h>
+extern unsigned int zone_dma_bits;
 #ifdef CONFIG_ARCH_HAS_PHYS_TO_DMA
 #include <asm/dma-direct.h>
 #else
 	return paddr + ((phys_addr_t)dev->dma_pfn_offset << PAGE_SHIFT);
 }
-static inline bool dma_capable(struct device *dev, dma_addr_t addr, size_t size)
-{
-	if (!dev->dma_mask)
-		return false;
-	return addr + size - 1 <=
-		min_not_zero(*dev->dma_mask, dev->bus_dma_mask);
-}
 #endif /* !CONFIG_ARCH_HAS_PHYS_TO_DMA */
 #ifdef CONFIG_ARCH_HAS_FORCE_DMA_UNENCRYPTED
 	return __sme_clr(__dma_to_phys(dev, daddr));
 }
+static inline bool dma_capable(struct device *dev, dma_addr_t addr, size_t size,
+		bool is_ram)
+{
+	dma_addr_t end = addr + size - 1;
+	if (!dev->dma_mask)
+		return false;
+	if (is_ram && !IS_ENABLED(CONFIG_ARCH_DMA_ADDR_T_64BIT) &&
+	    min(addr, end) < phys_to_dma(dev, PFN_PHYS(min_low_pfn)))
+		return false;
+	return end <= min_not_zero(*dev->dma_mask, dev->bus_dma_limit);
+}
 u64 dma_direct_get_required_mask(struct device *dev);
 void *dma_direct_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle,
 		gfp_t gfp, unsigned long attrs);
 void dma_direct_free_pages(struct device *dev, size_t size, void *cpu_addr,
 		dma_addr_t dma_addr, unsigned long attrs);
 struct page *__dma_direct_alloc_pages(struct device *dev, size_t size,
-		dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs);
+		gfp_t gfp, unsigned long attrs);
-void __dma_direct_free_pages(struct device *dev, size_t size, struct page *page);
+int dma_direct_get_sgtable(struct device *dev, struct sg_table *sgt,
+		void *cpu_addr, dma_addr_t dma_addr, size_t size,
+		unsigned long attrs);
+bool dma_direct_can_mmap(struct device *dev);
+int dma_direct_mmap(struct device *dev, struct vm_area_struct *vma,
+		void *cpu_addr, dma_addr_t dma_addr, size_t size,
+		unsigned long attrs);
 int dma_direct_supported(struct device *dev, u64 mask);
 #endif /* _LINUX_DMA_DIRECT_H */

include/linux/dma-mapping.h+8−7

@@ -15,11 +15,8 @@ · 14 unmodified lines
15	/**	15	/**
16	* List of possible attributes associated with a DMA mapping. The semantics	16	* List of possible attributes associated with a DMA mapping. The semantics
17	* of each attribute should be defined in Documentation/DMA-attributes.txt.	17	* of each attribute should be defined in Documentation/DMA-attributes.txt.
18	*
19	* DMA_ATTR_WRITE_BARRIER: DMA to a memory region with this attribute
20	* forces all pending DMA writes to complete.
21	*/	18	*/
22	#define DMA_ATTR_WRITE_BARRIER (1UL << 0)	19
23	/*	20	/*
24	* DMA_ATTR_WEAK_ORDERING: Specifies that reads and writes to the mapping	21	* DMA_ATTR_WEAK_ORDERING: Specifies that reads and writes to the mapping
25	* may be weakly ordered, that is that reads and writes may pass each other.	22	* may be weakly ordered, that is that reads and writes may pass each other.
@@ -162,7 +159,7 @@ int dma_release_from_dev_coherent(struct device dev, int order, void vaddr); · 136 unmodified lines
162	int dma_mmap_from_dev_coherent(struct device dev, struct vm_area_struct vma,	159	int dma_mmap_from_dev_coherent(struct device dev, struct vm_area_struct vma,
163	void cpu_addr, size_t size, int ret);	160	void cpu_addr, size_t size, int ret);
164		161
165	void dma_alloc_from_global_coherent(ssize_t size, dma_addr_t dma_handle);	162	void dma_alloc_from_global_coherent(struct device dev, ssize_t size, dma_addr_t *dma_handle);
166	int dma_release_from_global_coherent(int order, void *vaddr);	163	int dma_release_from_global_coherent(int order, void *vaddr);
167	int dma_mmap_from_global_coherent(struct vm_area_struct vma, void cpu_addr,	164	int dma_mmap_from_global_coherent(struct vm_area_struct vma, void cpu_addr,
168	size_t size, int *ret);	165	size_t size, int *ret);
@@ -172,7 +169,7 @@ int dma_mmap_from_global_coherent(struct vm_area_struct vma, void cpu_addr, · 3 unmodified lines
172	#define dma_release_from_dev_coherent(dev, order, vaddr) (0)	169	#define dma_release_from_dev_coherent(dev, order, vaddr) (0)
173	#define dma_mmap_from_dev_coherent(dev, vma, vaddr, order, ret) (0)	170	#define dma_mmap_from_dev_coherent(dev, vma, vaddr, order, ret) (0)
174		171
175	static inline void *dma_alloc_from_global_coherent(ssize_t size,	172	static inline void dma_alloc_from_global_coherent(struct device dev, ssize_t size,
176	dma_addr_t *dma_handle)	173	dma_addr_t *dma_handle)
177	{	174	{
178	return NULL;	175	return NULL;
@@ -583,6 +580,10 @@ static inline unsigned long dma_get_merge_boundary(struct device *dev) · 404 unmodified lines
583	static inline dma_addr_t dma_map_single_attrs(struct device dev, void ptr,	580	static inline dma_addr_t dma_map_single_attrs(struct device dev, void ptr,
584	size_t size, enum dma_data_direction dir, unsigned long attrs)	581	size_t size, enum dma_data_direction dir, unsigned long attrs)
585	{	582	{
		583	/* DMA must never operate on areas that might be remapped. */
		584	if (dev_WARN_ONCE(dev, is_vmalloc_addr(ptr),
		585	"rejecting DMA map of vmalloc memory\n"))
		586	return DMA_MAPPING_ERROR;
586	debug_dma_map_single(dev, ptr, size);	587	debug_dma_map_single(dev, ptr, size);
587	return dma_map_page_attrs(dev, virt_to_page(ptr), offset_in_page(ptr),	588	return dma_map_page_attrs(dev, virt_to_page(ptr), offset_in_page(ptr),
588	size, dir, attrs);	589	size, dir, attrs);
@@ -693,7 +694,7 @@ static inline int dma_coerce_mask_and_coherent(struct device *dev, u64 mask) · 104 unmodified lines
693	*/	694	*/
694	static inline bool dma_addressing_limited(struct device *dev)	695	static inline bool dma_addressing_limited(struct device *dev)
695	{	696	{
696	return min_not_zero(dma_get_mask(dev), dev->bus_dma_mask) <	697	return min_not_zero(dma_get_mask(dev), dev->bus_dma_limit) <
697	dma_get_required_mask(dev);	698	dma_get_required_mask(dev);
698	}	699	}
699		700

include/linux/dma-noncoherent.h+10−12

 		gfp_t gfp, unsigned long attrs);
 void arch_dma_free(struct device *dev, size_t size, void *cpu_addr,
 		dma_addr_t dma_addr, unsigned long attrs);
-long arch_dma_coherent_to_pfn(struct device *dev, void *cpu_addr,
-		dma_addr_t dma_addr);
 #ifdef CONFIG_MMU
 /*
 #endif /* CONFIG_DMA_NONCOHERENT_CACHE_SYNC */
 #ifdef CONFIG_ARCH_HAS_SYNC_DMA_FOR_DEVICE
-void arch_sync_dma_for_device(struct device *dev, phys_addr_t paddr,
+void arch_sync_dma_for_device(phys_addr_t paddr, size_t size,
-		size_t size, enum dma_data_direction dir);
+		enum dma_data_direction dir);
 #else
-static inline void arch_sync_dma_for_device(struct device *dev,
+static inline void arch_sync_dma_for_device(phys_addr_t paddr, size_t size,
-		phys_addr_t paddr, size_t size, enum dma_data_direction dir)
+		enum dma_data_direction dir)
 {
 }
 #endif /* ARCH_HAS_SYNC_DMA_FOR_DEVICE */
 #ifdef CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU
-void arch_sync_dma_for_cpu(struct device *dev, phys_addr_t paddr,
+void arch_sync_dma_for_cpu(phys_addr_t paddr, size_t size,
-		size_t size, enum dma_data_direction dir);
+		enum dma_data_direction dir);
 #else
-static inline void arch_sync_dma_for_cpu(struct device *dev,
+static inline void arch_sync_dma_for_cpu(phys_addr_t paddr, size_t size,
-		phys_addr_t paddr, size_t size, enum dma_data_direction dir)
+		enum dma_data_direction dir)
 {
 }
 #endif /* ARCH_HAS_SYNC_DMA_FOR_CPU */
 #ifdef CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL
-void arch_sync_dma_for_cpu_all(struct device *dev);
+void arch_sync_dma_for_cpu_all(void);
 #else
-static inline void arch_sync_dma_for_cpu_all(struct device *dev)
+static inline void arch_sync_dma_for_cpu_all(void)
 {
 }
 #endif /* CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL */

include/linux/dma/sprd-dma.h+4−0

  * struct sprd_dma_linklist - DMA link-list address structure
  * @virt_addr: link-list virtual address to configure link-list node
  * @phy_addr: link-list physical address to link DMA transfer
+ * @wrap_addr: the wrap address for link-list mode, which means once the
+ * transfer address reaches the wrap address, the next transfer address
+ * will jump to the address specified by wrap_to register.
  *
  * The Spreadtrum DMA controller supports the link-list mode, that means slaves
  * can supply several groups configurations (each configuration represents one
 struct sprd_dma_linklist {
 	unsigned long virt_addr;
 	phys_addr_t phy_addr;
+	phys_addr_t wrap_addr;
 };
 #endif

include/linux/dmar.h+2−0

 #ifdef CONFIG_INTEL_IOMMU
 extern int iommu_detected, no_iommu;
 extern int intel_iommu_init(void);
+extern void intel_iommu_shutdown(void);
 extern int dmar_parse_one_rmrr(struct acpi_dmar_header *header, void *arg);
 extern int dmar_parse_one_atsr(struct acpi_dmar_header *header, void *arg);
 extern int dmar_check_one_atsr(struct acpi_dmar_header *hdr, void *arg);
 extern int dmar_iommu_notify_scope_dev(struct dmar_pci_notify_info *info);
 #else /* !CONFIG_INTEL_IOMMU: */
 static inline int intel_iommu_init(void) { return -ENODEV; }
+static inline void intel_iommu_shutdown(void) { }
 #define	dmar_parse_one_rmrr		dmar_res_noop
 #define	dmar_parse_one_atsr		dmar_res_noop

include/linux/dmi.h+4−0

 extern bool dmi_match(enum dmi_field f, const char *str);
 extern void dmi_memdev_name(u16 handle, const char **bank, const char **device);
 extern u64 dmi_memdev_size(u16 handle);
+extern u8 dmi_memdev_type(u16 handle);
+extern u16 dmi_memdev_handle(int slot);
 #else
 static inline void dmi_memdev_name(u16 handle, const char **bank,
 		const char **device) { }
 static inline u64 dmi_memdev_size(u16 handle) { return ~0ul; }
+static inline u8 dmi_memdev_type(u16 handle) { return 0x0; }
+static inline u16 dmi_memdev_handle(int slot) { return 0xffff; }
 static inline const struct dmi_system_id *
 	dmi_first_match(const struct dmi_system_id *list) { return NULL; }

include/linux/edac.h+68−78

@@ -362,78 +362,6 @@ struct edac_mc_layer { · 361 unmodified lines
362	*/	362	*/
363	#define EDAC_MAX_LAYERS 3	363	#define EDAC_MAX_LAYERS 3
364		364
365	/**
366	* EDAC_DIMM_OFF - Macro responsible to get a pointer offset inside a pointer
367	* array for the element given by [layer0,layer1,layer2]
368	* position
369	*
370	* @layers: a struct edac_mc_layer array, describing how many elements
371	* were allocated for each layer
372	* @nlayers: Number of layers at the @layers array
373	* @layer0: layer0 position
374	* @layer1: layer1 position. Unused if n_layers < 2
375	* @layer2: layer2 position. Unused if n_layers < 3
376	*
377	* For 1 layer, this macro returns "var[layer0] - var";
378	*
379	* For 2 layers, this macro is similar to allocate a bi-dimensional array
380	* and to return "var[layer0][layer1] - var";
381	*
382	* For 3 layers, this macro is similar to allocate a tri-dimensional array
383	* and to return "var[layer0][layer1][layer2] - var".
384	*
385	* A loop could be used here to make it more generic, but, as we only have
386	* 3 layers, this is a little faster.
387	*
388	* By design, layers can never be 0 or more than 3. If that ever happens,
389	* a NULL is returned, causing an OOPS during the memory allocation routine,
390	* with would point to the developer that he's doing something wrong.
391	*/
392	#define EDAC_DIMM_OFF(layers, nlayers, layer0, layer1, layer2) ({ \
393	int __i; \
394	if ((nlayers) == 1) \
395	__i = layer0; \
396	else if ((nlayers) == 2) \
397	__i = (layer1) + ((layers[1]).size * (layer0)); \
398	else if ((nlayers) == 3) \
399	__i = (layer2) + ((layers[2]).size * ((layer1) + \
400	((layers[1]).size * (layer0)))); \
401	else \
402	__i = -EINVAL; \
403	__i; \
404	})
405
406	/**
407	* EDAC_DIMM_PTR - Macro responsible to get a pointer inside a pointer array
408	* for the element given by [layer0,layer1,layer2] position
409	*
410	* @layers: a struct edac_mc_layer array, describing how many elements
411	* were allocated for each layer
412	* @var: name of the var where we want to get the pointer
413	* (like mci->dimms)
414	* @nlayers: Number of layers at the @layers array
415	* @layer0: layer0 position
416	* @layer1: layer1 position. Unused if n_layers < 2
417	* @layer2: layer2 position. Unused if n_layers < 3
418	*
419	* For 1 layer, this macro returns "var[layer0]";
420	*
421	* For 2 layers, this macro is similar to allocate a bi-dimensional array
422	* and to return "var[layer0][layer1]";
423	*
424	* For 3 layers, this macro is similar to allocate a tri-dimensional array
425	* and to return "var[layer0][layer1][layer2]";
426	*/
427	#define EDAC_DIMM_PTR(layers, var, nlayers, layer0, layer1, layer2) ({ \
428	typeof(*var) __p; \
429	int ___i = EDAC_DIMM_OFF(layers, nlayers, layer0, layer1, layer2); \
430	if (___i < 0) \
431	__p = NULL; \
432	else \
433	__p = (var)[___i]; \
434	__p; \
435	})
436
437	struct dimm_info {	365	struct dimm_info {
438	struct device dev;	366	struct device dev;
439		367
@@ -443,6 +371,7 @@ struct dimm_info { · 3 unmodified lines
443	unsigned int location[EDAC_MAX_LAYERS];	371	unsigned int location[EDAC_MAX_LAYERS];
444		372
445	struct mem_ctl_info mci; / the parent */	373	struct mem_ctl_info mci; / the parent */
		374	unsigned int idx; /* index within the parent dimm array */
446		375
447	u32 grain; /* granularity of reported error in bytes */	376	u32 grain; /* granularity of reported error in bytes */
448	enum dev_type dtype; /* memory device type */	377	enum dev_type dtype; /* memory device type */
@@ -528,15 +457,10 @@ struct errcount_attribute_data { · 79 unmodified lines
528	* (typically, a memory controller error)	457	* (typically, a memory controller error)
529	*/	458	*/
530	struct edac_raw_error_desc {	459	struct edac_raw_error_desc {
531	/*
532	* NOTE: everything before grain won't be cleaned by
533	* edac_raw_error_desc_clean()
534	*/
535	char location[LOCATION_SIZE];	460	char location[LOCATION_SIZE];
536	char label[(EDAC_MC_LABEL_LEN + 1 + sizeof(OTHER_LABEL)) * EDAC_MAX_LABELS];	461	char label[(EDAC_MC_LABEL_LEN + 1 + sizeof(OTHER_LABEL)) * EDAC_MAX_LABELS];
537	long grain;	462	long grain;
538		463
539	/* the vars below and grain will be cleaned on every new error report */
540	u16 error_count;	464	u16 error_count;
541	int top_layer;	465	int top_layer;
542	int mid_layer;	466	int mid_layer;
@@ -669,4 +593,70 @@ struct mem_ctl_info { · 126 unmodified lines
669	bool fake_inject_ue;	593	bool fake_inject_ue;
670	u16 fake_inject_count;	594	u16 fake_inject_count;
671	};	595	};
672	#endif	596
		597	#define mci_for_each_dimm(mci, dimm) \
		598	for ((dimm) = (mci)->dimms[0]; \
		599	(dimm); \
		600	(dimm) = (dimm)->idx + 1 < (mci)->tot_dimms \
		601	? (mci)->dimms[(dimm)->idx + 1] \
		602	: NULL)
		603
		604	/**
		605	* edac_get_dimm_by_index - Get DIMM info at @index from a memory
		606	* controller
		607	*
		608	* @mci: MC descriptor struct mem_ctl_info
		609	* @index: index in the memory controller's DIMM array
		610	*
		611	* Returns a struct dimm_info * or NULL on failure.
		612	*/
		613	static inline struct dimm_info *
		614	edac_get_dimm_by_index(struct mem_ctl_info *mci, int index)
		615	{
		616	if (index < 0 \|\| index >= mci->tot_dimms)
		617	return NULL;
		618
		619	if (WARN_ON_ONCE(mci->dimms[index]->idx != index))
		620	return NULL;
		621
		622	return mci->dimms[index];
		623	}
		624
		625	/**
		626	* edac_get_dimm - Get DIMM info from a memory controller given by
		627	* [layer0,layer1,layer2] position
		628	*
		629	* @mci: MC descriptor struct mem_ctl_info
		630	* @layer0: layer0 position
		631	* @layer1: layer1 position. Unused if n_layers < 2
		632	* @layer2: layer2 position. Unused if n_layers < 3
		633	*
		634	* For 1 layer, this function returns "dimms[layer0]";
		635	*
		636	* For 2 layers, this function is similar to allocating a two-dimensional
		637	* array and returning "dimms[layer0][layer1]";
		638	*
		639	* For 3 layers, this function is similar to allocating a tri-dimensional
		640	* array and returning "dimms[layer0][layer1][layer2]";
		641	*/
		642	static inline struct dimm_info edac_get_dimm(struct mem_ctl_info mci,
		643	int layer0, int layer1, int layer2)
		644	{
		645	int index;
		646
		647	if (layer0 < 0
		648	\|\| (mci->n_layers > 1 && layer1 < 0)
		649	\|\| (mci->n_layers > 2 && layer2 < 0))
		650	return NULL;
		651
		652	index = layer0;
		653
		654	if (mci->n_layers > 1)
		655	index = index * mci->layers[1].size + layer1;
		656
		657	if (mci->n_layers > 2)
		658	index = index * mci->layers[2].size + layer2;
		659
		660	return edac_get_dimm_by_index(mci, index);
		661	}
		662	#endif /* _LINUX_EDAC_H_ */

include/linux/efi.h+22−6

 #define EFI_MEMORY_MORE_RELIABLE \
 				((u64)0x0000000000010000ULL)	/* higher reliability */
 #define EFI_MEMORY_RO		((u64)0x0000000000020000ULL)	/* read-only */
+#define EFI_MEMORY_SP		((u64)0x0000000000040000ULL)	/* soft reserved */
 #define EFI_MEMORY_RUNTIME	((u64)0x8000000000000000ULL)	/* range requires runtime mapping */
 #define EFI_MEMORY_DESCRIPTOR_VERSION	1
 	__aligned_u64 image_size;
 	unsigned int image_code_type;
 	unsigned int image_data_type;
-	unsigned long unload;
+	u32 unload;
 } efi_loaded_image_32_t;
 typedef struct {
 	__aligned_u64 image_size;
 	unsigned int image_code_type;
 	unsigned int image_data_type;
-	unsigned long unload;
+	u64 unload;
 } efi_loaded_image_64_t;
 typedef struct {
 	u32 revision;
-	void *parent_handle;
+	efi_handle_t parent_handle;
 	efi_system_table_t *system_table;
-	void *device_handle;
+	efi_handle_t device_handle;
 	void *file_path;
 	void *reserved;
 	u32 load_options_size;
 	__aligned_u64 image_size;
 	unsigned int image_code_type;
 	unsigned int image_data_type;
-	unsigned long unload;
+	efi_status_t (*unload)(efi_handle_t image_handle);
 } efi_loaded_image_t;
 extern efi_status_t efi_query_variable_store(u32 attributes,
 					     unsigned long size,
 					     bool nonblocking);
-extern void efi_find_mirror(void);
 #else
 static inline efi_status_t efi_query_variable_store(u32 attributes,
 #define EFI_DBG			8	/* Print additional debug info at runtime */
 #define EFI_NX_PE_DATA		9	/* Can runtime data regions be mapped non-executable? */
 #define EFI_MEM_ATTR		10	/* Did firmware publish an EFI_MEMORY_ATTRIBUTES table? */
+#define EFI_MEM_NO_SOFT_RESERVE	11	/* Is the kernel configured to ignore soft reservations? */
 #ifdef CONFIG_EFI
 /*
 	return test_bit(feature, &efi.flags) != 0;
 }
 extern void efi_reboot(enum reboot_mode reboot_mode, const char *__unused);
+bool __pure __efi_soft_reserve_enabled(void);
+static inline bool __pure efi_soft_reserve_enabled(void)
+{
+	return IS_ENABLED(CONFIG_EFI_SOFT_RESERVE)
+		&& __efi_soft_reserve_enabled();
+}
 #else
 static inline bool efi_enabled(int feature)
 {
 {
 	return false;
 }
+static inline bool efi_soft_reserve_enabled(void)
+{
+	return false;
+}
 #endif
 extern int efi_status_to_err(efi_status_t status);
 efi_enable_reset_attack_mitigation(efi_system_table_t *sys_table_arg) { }
 #endif
+efi_status_t efi_random_get_seed(efi_system_table_t *sys_table_arg);
 void efi_retrieve_tpm2_eventlog(efi_system_table_t *sys_table);
 /*

include/linux/energy_model.h+1−2

 #include <linux/sched/topology.h>
 #include <linux/types.h>
-#ifdef CONFIG_ENERGY_MODEL
 /**
  * em_cap_state - Capacity state of a performance domain
  * @frequency:	The CPU frequency in KHz, for consistency with CPUFreq
 	unsigned long cpus[0];
 };
+#ifdef CONFIG_ENERGY_MODEL
 #define EM_CPU_MAX_POWER 0xFFFF
 struct em_data_callback {
 }
 #else
-struct em_perf_domain {};
 struct em_data_callback {};
 #define EM_DATA_CB(_active_power_cb) { }

include/linux/errname.h+16−0

@@ -0,0 +1,16 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef _LINUX_ERRNAME_H
	3	#define _LINUX_ERRNAME_H
	4
	5	#include <linux/stddef.h>
	6
	7	#ifdef CONFIG_SYMBOLIC_ERRNAME
	8	const char *errname(int err);
	9	#else
	10	static inline const char *errname(int err)
	11	{
	12	return NULL;
	13	}
	14	#endif
	15
	16	#endif /* _LINUX_ERRNAME_H */

include/linux/export.h+29−63

+/* SPDX-License-Identifier: GPL-2.0-only */
 #ifndef _LINUX_EXPORT_H
 #define _LINUX_EXPORT_H
  * absolute relocations that require runtime processing on relocatable
  * kernels.
  */
-#define __KSYMTAB_ENTRY_NS(sym, sec)					\
+#define __KSYMTAB_ENTRY(sym, sec)					\
 	__ADDRESSABLE(sym)						\
 	asm("	.section \"___ksymtab" sec "+" #sym "\", \"a\"	\n"	\
 	    "	.balign	4					\n"	\
 	    "	.long	__kstrtabns_" #sym "- .			\n"	\
 	    "	.previous					\n")
-#define __KSYMTAB_ENTRY(sym, sec)					\
-	__ADDRESSABLE(sym)						\
-	asm("	.section \"___ksymtab" sec "+" #sym "\", \"a\"	\n"	\
-	    "	.balign 4					\n"	\
-	    "__ksymtab_" #sym ":				\n"	\
-	    "	.long	" #sym "- .				\n"	\
-	    "	.long	__kstrtab_" #sym "- .			\n"	\
-	    "	.long	0					\n"	\
-	    "	.previous					\n")
 struct kernel_symbol {
 	int value_offset;
 	int name_offset;
 	int namespace_offset;
 };
 #else
-#define __KSYMTAB_ENTRY_NS(sym, sec)					\
-	static const struct kernel_symbol __ksymtab_##sym		\
-	__attribute__((section("___ksymtab" sec "+" #sym), used))	\
-	__aligned(sizeof(void *))					\
-	= { (unsigned long)&sym, __kstrtab_##sym, __kstrtabns_##sym }
 #define __KSYMTAB_ENTRY(sym, sec)					\
 	static const struct kernel_symbol __ksymtab_##sym		\
 	__attribute__((section("___ksymtab" sec "+" #sym), used))	\
 	__aligned(sizeof(void *))					\
-	= { (unsigned long)&sym, __kstrtab_##sym, NULL }
+	= { (unsigned long)&sym, __kstrtab_##sym, __kstrtabns_##sym }
 struct kernel_symbol {
 	unsigned long value;
 #ifdef __GENKSYMS__
-#define ___EXPORT_SYMBOL(sym,sec)	__GENKSYMS_EXPORT_SYMBOL(sym)
+#define ___EXPORT_SYMBOL(sym, sec, ns)	__GENKSYMS_EXPORT_SYMBOL(sym)
-#define ___EXPORT_SYMBOL_NS(sym,sec,ns)	__GENKSYMS_EXPORT_SYMBOL(sym)
 #else
-#define ___export_symbol_common(sym, sec)				\
+/* For every exported symbol, place a struct in the __ksymtab section */
+#define ___EXPORT_SYMBOL(sym, sec, ns)					\
 	extern typeof(sym) sym;						\
 	__CRC_SYMBOL(sym, sec);						\
 	static const char __kstrtab_##sym[]				\
 	__attribute__((section("__ksymtab_strings"), used, aligned(1)))	\
-	= #sym								\
+	= #sym;								\
-/* For every exported symbol, place a struct in the __ksymtab section */
-#define ___EXPORT_SYMBOL_NS(sym, sec, ns)				\
-	___export_symbol_common(sym, sec);				\
 	static const char __kstrtabns_##sym[]				\
 	__attribute__((section("__ksymtab_strings"), used, aligned(1)))	\
-	= #ns;								\
+	= ns;								\
-	__KSYMTAB_ENTRY_NS(sym, sec)
-#define ___EXPORT_SYMBOL(sym, sec)					\
-	___export_symbol_common(sym, sec);				\
 	__KSYMTAB_ENTRY(sym, sec)
 #endif
  * be reused in other execution contexts such as the UEFI stub or the
  * decompressor.
  */
-#define __EXPORT_SYMBOL_NS(sym, sec, ns)
+#define __EXPORT_SYMBOL(sym, sec, ns)
-#define __EXPORT_SYMBOL(sym, sec)
 #elif defined(CONFIG_TRIM_UNUSED_KSYMS)
 #define __ksym_marker(sym)	\
 	static int __ksym_marker_##sym[0] __section(".discard.ksym") __used
-#define __EXPORT_SYMBOL(sym, sec)				\
+#define __EXPORT_SYMBOL(sym, sec, ns)					\
-	__ksym_marker(sym);					\
-	__cond_export_sym(sym, sec, __is_defined(__KSYM_##sym))
-#define __cond_export_sym(sym, sec, conf)			\
-	___cond_export_sym(sym, sec, conf)
-#define ___cond_export_sym(sym, sec, enabled)			\
-	__cond_export_sym_##enabled(sym, sec)
-#define __cond_export_sym_1(sym, sec) ___EXPORT_SYMBOL(sym, sec)
-#define __cond_export_sym_0(sym, sec) /* nothing */
-#define __EXPORT_SYMBOL_NS(sym, sec, ns)				\
 	__ksym_marker(sym);						\
-	__cond_export_ns_sym(sym, sec, ns, __is_defined(__KSYM_##sym))
+	__cond_export_sym(sym, sec, ns, __is_defined(__KSYM_##sym))
-#define __cond_export_ns_sym(sym, sec, ns, conf)			\
+#define __cond_export_sym(sym, sec, ns, conf)				\
-	___cond_export_ns_sym(sym, sec, ns, conf)
+	___cond_export_sym(sym, sec, ns, conf)
-#define ___cond_export_ns_sym(sym, sec, ns, enabled)			\
+#define ___cond_export_sym(sym, sec, ns, enabled)			\
-	__cond_export_ns_sym_##enabled(sym, sec, ns)
+	__cond_export_sym_##enabled(sym, sec, ns)
-#define __cond_export_ns_sym_1(sym, sec, ns) ___EXPORT_SYMBOL_NS(sym, sec, ns)
+#define __cond_export_sym_1(sym, sec, ns) ___EXPORT_SYMBOL(sym, sec, ns)
-#define __cond_export_ns_sym_0(sym, sec, ns) /* nothing */
+#define __cond_export_sym_0(sym, sec, ns) /* nothing */
 #else
-#define __EXPORT_SYMBOL_NS(sym,sec,ns)	___EXPORT_SYMBOL_NS(sym,sec,ns)
+#define __EXPORT_SYMBOL(sym, sec, ns)	___EXPORT_SYMBOL(sym, sec, ns)
-#define __EXPORT_SYMBOL(sym,sec)	___EXPORT_SYMBOL(sym,sec)
 #endif /* CONFIG_MODULES */
 #ifdef DEFAULT_SYMBOL_NAMESPACE
-#undef __EXPORT_SYMBOL
+#include <linux/stringify.h>
-#define __EXPORT_SYMBOL(sym, sec)				\
+#define _EXPORT_SYMBOL(sym, sec)	__EXPORT_SYMBOL(sym, sec, __stringify(DEFAULT_SYMBOL_NAMESPACE))
-	__EXPORT_SYMBOL_NS(sym, sec, DEFAULT_SYMBOL_NAMESPACE)
+#else
+#define _EXPORT_SYMBOL(sym, sec)	__EXPORT_SYMBOL(sym, sec, "")
 #endif
-#define EXPORT_SYMBOL(sym)		__EXPORT_SYMBOL(sym, "")
+#define EXPORT_SYMBOL(sym)		_EXPORT_SYMBOL(sym, "")
-#define EXPORT_SYMBOL_GPL(sym)		__EXPORT_SYMBOL(sym, "_gpl")
+#define EXPORT_SYMBOL_GPL(sym)		_EXPORT_SYMBOL(sym, "_gpl")
-#define EXPORT_SYMBOL_GPL_FUTURE(sym)	__EXPORT_SYMBOL(sym, "_gpl_future")
+#define EXPORT_SYMBOL_GPL_FUTURE(sym)	_EXPORT_SYMBOL(sym, "_gpl_future")
-#define EXPORT_SYMBOL_NS(sym, ns)	__EXPORT_SYMBOL_NS(sym, "", ns)
+#define EXPORT_SYMBOL_NS(sym, ns)	__EXPORT_SYMBOL(sym, "", #ns)
-#define EXPORT_SYMBOL_NS_GPL(sym, ns)	__EXPORT_SYMBOL_NS(sym, "_gpl", ns)
+#define EXPORT_SYMBOL_NS_GPL(sym, ns)	__EXPORT_SYMBOL(sym, "_gpl", #ns)
 #ifdef CONFIG_UNUSED_SYMBOLS
-#define EXPORT_UNUSED_SYMBOL(sym)	__EXPORT_SYMBOL(sym, "_unused")
+#define EXPORT_UNUSED_SYMBOL(sym)	_EXPORT_SYMBOL(sym, "_unused")
-#define EXPORT_UNUSED_SYMBOL_GPL(sym)	__EXPORT_SYMBOL(sym, "_unused_gpl")
+#define EXPORT_UNUSED_SYMBOL_GPL(sym)	_EXPORT_SYMBOL(sym, "_unused_gpl")
 #else
 #define EXPORT_UNUSED_SYMBOL(sym)
 #define EXPORT_UNUSED_SYMBOL_GPL(sym)

include/linux/exportfs.h+5−0

 	 */
 	FILEID_LUSTRE = 0x97,
+	/*
+	 * 64 bit unique kernfs id
+	 */
+	FILEID_KERNFS = 0xfe,
 	/*
 	 * Filesystems must not use 0xff file ID.
 	 */

include/linux/extable.h+10−0

@@ -33,4 +33,14 @@ search_module_extables(unsigned long addr) · 32 unmodified lines
33	}	33	}
34	#endif /CONFIG_MODULES/	34	#endif /CONFIG_MODULES/
35		35
		36	#ifdef CONFIG_BPF_JIT
		37	const struct exception_table_entry *search_bpf_extables(unsigned long addr);
		38	#else
		39	static inline const struct exception_table_entry *
		40	search_bpf_extables(unsigned long addr)
		41	{
		42	return NULL;
		43	}
		44	#endif
		45
36	#endif /* _LINUX_EXTABLE_H */	46	#endif /* _LINUX_EXTABLE_H */

include/linux/falloc.h+26−0

@@ -20,7 +20,10 @@ struct space_resv { · 19 unmodified lines
20	};	20	};
21		21
22	#define FS_IOC_RESVSP _IOW('X', 40, struct space_resv)	22	#define FS_IOC_RESVSP _IOW('X', 40, struct space_resv)
		23	#define FS_IOC_UNRESVSP _IOW('X', 41, struct space_resv)
23	#define FS_IOC_RESVSP64 _IOW('X', 42, struct space_resv)	24	#define FS_IOC_RESVSP64 _IOW('X', 42, struct space_resv)
		25	#define FS_IOC_UNRESVSP64 _IOW('X', 43, struct space_resv)
		26	#define FS_IOC_ZERO_RANGE _IOW('X', 57, struct space_resv)
24		27
25	#define FALLOC_FL_SUPPORTED_MASK (FALLOC_FL_KEEP_SIZE \| \	28	#define FALLOC_FL_SUPPORTED_MASK (FALLOC_FL_KEEP_SIZE \| \
26	FALLOC_FL_PUNCH_HOLE \| \	29	FALLOC_FL_PUNCH_HOLE \| \
@@ -29,4 +32,27 @@ struct space_resv { · 2 unmodified lines
29	FALLOC_FL_INSERT_RANGE \| \	32	FALLOC_FL_INSERT_RANGE \| \
30	FALLOC_FL_UNSHARE_RANGE)	33	FALLOC_FL_UNSHARE_RANGE)
31		34
		35	/* on ia32 l_start is on a 32-bit boundary */
		36	#if defined(CONFIG_X86_64)
		37	struct space_resv_32 {
		38	__s16 l_type;
		39	__s16 l_whence;
		40	__s64 l_start __attribute__((packed));
		41	/* len == 0 means until end of file */
		42	__s64 l_len __attribute__((packed));
		43	__s32 l_sysid;
		44	__u32 l_pid;
		45	__s32 l_pad[4]; /* reserve area */
		46	};
		47
		48	#define FS_IOC_RESVSP_32 _IOW ('X', 40, struct space_resv_32)
		49	#define FS_IOC_UNRESVSP_32 _IOW ('X', 41, struct space_resv_32)
		50	#define FS_IOC_RESVSP64_32 _IOW ('X', 42, struct space_resv_32)
		51	#define FS_IOC_UNRESVSP64_32 _IOW ('X', 43, struct space_resv_32)
		52	#define FS_IOC_ZERO_RANGE_32 _IOW ('X', 57, struct space_resv_32)
		53
		54	int compat_ioctl_preallocate(struct file , int, struct space_resv_32 __user );
		55
		56	#endif
		57
32	#endif /* _FALLOC_H_ */	58	#endif /* _FALLOC_H_ */

include/linux/fb.h+1−1

@@ -607,7 +607,7 @@ extern ssize_t fb_sys_write(struct fb_info info, const char __user buf, · 606 unmodified lines
607	extern int register_framebuffer(struct fb_info *fb_info);	607	extern int register_framebuffer(struct fb_info *fb_info);
608	extern void unregister_framebuffer(struct fb_info *fb_info);	608	extern void unregister_framebuffer(struct fb_info *fb_info);
609	extern void unlink_framebuffer(struct fb_info *fb_info);	609	extern void unlink_framebuffer(struct fb_info *fb_info);
610	extern int remove_conflicting_pci_framebuffers(struct pci_dev *pdev, int res_id,	610	extern int remove_conflicting_pci_framebuffers(struct pci_dev *pdev,
611	const char *name);	611	const char *name);
612	extern int remove_conflicting_framebuffers(struct apertures_struct *a,	612	extern int remove_conflicting_framebuffers(struct apertures_struct *a,
613	const char *name, bool primary);	613	const char *name, bool primary);

include/linux/filter.h+36−11

 /* unused opcode to mark special call to bpf_tail_call() helper */
 #define BPF_TAIL_CALL	0xf0
+/* unused opcode to mark special load instruction. Same as BPF_ABS */
+#define BPF_PROBE_MEM	0x20
 /* unused opcode to mark call to interpreter with arguments */
 #define BPF_CALL_ARGS	0xe0
 #define BPF_FIELD_SIZEOF(type, field)				\
 	({							\
-		const int __size = bytes_to_bpf_size(FIELD_SIZEOF(type, field)); \
+		const int __size = bytes_to_bpf_size(sizeof_field(type, field)); \
 		BUILD_BUG_ON(__size < 0);			\
 		__size;						\
 	})
 #define BPF_CALL_x(x, name, ...)					       \
 	static __always_inline						       \
 	u64 ____##name(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_ARGS__));   \
+	typedef u64 (*btf_##name)(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_ARGS__)); \
 	u64 name(__BPF_REG(x, __BPF_DECL_REGS, __BPF_N, __VA_ARGS__));	       \
 	u64 name(__BPF_REG(x, __BPF_DECL_REGS, __BPF_N, __VA_ARGS__))	       \
 	{								       \
-		return ____##name(__BPF_MAP(x,__BPF_CAST,__BPF_N,__VA_ARGS__));\
+		return ((btf_##name)____##name)(__BPF_MAP(x,__BPF_CAST,__BPF_N,__VA_ARGS__));\
 	}								       \
 	static __always_inline						       \
 	u64 ____##name(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_ARGS__))
 #define bpf_target_off(TYPE, MEMBER, SIZE, PTR_SIZE)				\
 	({									\
-		BUILD_BUG_ON(FIELD_SIZEOF(TYPE, MEMBER) != (SIZE));		\
+		BUILD_BUG_ON(sizeof_field(TYPE, MEMBER) != (SIZE));		\
 		*(PTR_SIZE) = (SIZE);						\
 		offsetof(TYPE, MEMBER);						\
 	})
 	struct sock_filter	*filter;
 };
+/* Some arches need doubleword alignment for their instructions and/or data */
+#define BPF_IMAGE_ALIGNMENT 8
 struct bpf_binary_header {
 	u32 pages;
-	/* Some arches need word alignment for their instructions */
+	u8 image[] __aligned(BPF_IMAGE_ALIGNMENT);
-	u8 image[] __aligned(4);
 };
 struct bpf_prog {
 {
 	struct bpf_skb_data_end *cb = (struct bpf_skb_data_end *)skb->cb;
-	BUILD_BUG_ON(sizeof(*cb) > FIELD_SIZEOF(struct sk_buff, cb));
+	BUILD_BUG_ON(sizeof(*cb) > sizeof_field(struct sk_buff, cb));
 	cb->data_meta = skb->data - skb_metadata_len(skb);
 	cb->data_end  = skb->data + skb_headlen(skb);
 }
 	 * attached to sockets, we need to clear the bpf_skb_cb() area
 	 * to not leak previous contents to user space.
 	 */
-	BUILD_BUG_ON(FIELD_SIZEOF(struct __sk_buff, cb) != BPF_SKB_CB_LEN);
+	BUILD_BUG_ON(sizeof_field(struct __sk_buff, cb) != BPF_SKB_CB_LEN);
-	BUILD_BUG_ON(FIELD_SIZEOF(struct __sk_buff, cb) !=
+	BUILD_BUG_ON(sizeof_field(struct __sk_buff, cb) !=
-		     FIELD_SIZEOF(struct qdisc_skb_cb, data));
+		     sizeof_field(struct qdisc_skb_cb, data));
 	return qdisc_skb_cb(skb)->data;
 }
 static inline void bpf_prog_lock_ro(struct bpf_prog *fp)
 {
-	set_vm_flush_reset_perms(fp);
+#ifndef CONFIG_BPF_JIT_ALWAYS_ON
-	set_memory_ro((unsigned long)fp, fp->pages);
+	if (!fp->jited) {
+		set_vm_flush_reset_perms(fp);
+		set_memory_ro((unsigned long)fp, fp->pages);
+	}
+#endif
 }
 static inline void bpf_jit_binary_lock_ro(struct bpf_binary_header *hdr)
 void bpf_jit_free_exec(void *addr);
 void bpf_jit_free(struct bpf_prog *fp);
+int bpf_jit_add_poke_descriptor(struct bpf_prog *prog,
+				struct bpf_jit_poke_descriptor *poke);
 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);
 	return false;
 }
+static inline bool bpf_jit_blinding_enabled(struct bpf_prog *prog)
+{
+	return false;
+}
 static inline bool bpf_prog_ebpf_jited(const struct bpf_prog *fp)
 {
 	return false;
 }
+static inline int
+bpf_jit_add_poke_descriptor(struct bpf_prog *prog,
+			    struct bpf_jit_poke_descriptor *poke)
+{
+	return -ENOTSUPP;
+}
 static inline void bpf_jit_free(struct bpf_prog *fp)
 {
 	bpf_prog_unlock_free(fp);

include/linux/firmware/broadcom/tee_bnxt_fw.h+14−0

@@ -0,0 +1,14 @@
	1	/* SPDX-License-Identifier: BSD-2-Clause */
	2	/*
	3	* Copyright 2019 Broadcom.
	4	*/
	5
	6	#ifndef _BROADCOM_TEE_BNXT_FW_H
	7	#define _BROADCOM_TEE_BNXT_FW_H
	8
	9	#include <linux/types.h>
	10
	11	int tee_bnxt_fw_load(void);
	12	int tee_bnxt_copy_coredump(void *buf, u32 offset, u32 size);
	13
	14	#endif /* _BROADCOM_TEE_BNXT_FW_H */

include/linux/firmware/intel/stratix10-svc-client.h+8−0

  *
  * SVC_STATUS_RSU_OK:
  * Secure firmware accepts the request of remote status update (RSU).
+ *
+ * SVC_STATUS_RSU_ERROR:
+ * Error encountered during remote system update.
+ *
+ * SVC_STATUS_RSU_NO_SUPPORT:
+ * Secure firmware doesn't support RSU retry or notify feature.
  */
 #define SVC_STATUS_RECONFIG_REQUEST_OK		0
 #define SVC_STATUS_RECONFIG_BUFFER_SUBMITTED	1
 #define SVC_STATUS_RECONFIG_ERROR		5
 #define SVC_STATUS_RSU_OK			6
 #define SVC_STATUS_RSU_ERROR			7
+#define SVC_STATUS_RSU_NO_SUPPORT		8
 /**
  * Flag bit for COMMAND_RECONFIG
  *

include/linux/firmware/meson/meson_sm.h+9−6

@@ -16,11 +16,14 @@ enum { · 15 unmodified lines
16		16
17	struct meson_sm_firmware;	17	struct meson_sm_firmware;
18		18
19	int meson_sm_call(unsigned int cmd_index, u32 *ret, u32 arg0, u32 arg1,	19	int meson_sm_call(struct meson_sm_firmware *fw, unsigned int cmd_index,
20	u32 arg2, u32 arg3, u32 arg4);	20	u32 *ret, u32 arg0, u32 arg1, u32 arg2, u32 arg3, u32 arg4);
21	int meson_sm_call_write(void *buffer, unsigned int b_size, unsigned int cmd_index,	21	int meson_sm_call_write(struct meson_sm_firmware fw, void buffer,
22	u32 arg0, u32 arg1, u32 arg2, u32 arg3, u32 arg4);	22	unsigned int b_size, unsigned int cmd_index, u32 arg0,
23	int meson_sm_call_read(void *buffer, unsigned int bsize, unsigned int cmd_index,	23	u32 arg1, u32 arg2, u32 arg3, u32 arg4);
24	u32 arg0, u32 arg1, u32 arg2, u32 arg3, u32 arg4);	24	int meson_sm_call_read(struct meson_sm_firmware fw, void buffer,
		25	unsigned int bsize, unsigned int cmd_index, u32 arg0,
		26	u32 arg1, u32 arg2, u32 arg3, u32 arg4);
		27	struct meson_sm_firmware meson_sm_get(struct device_node firmware_node);
25		28
26	#endif /* _MESON_SM_FW_H_ */	29	#endif /* _MESON_SM_FW_H_ */

include/linux/firmware/xlnx-zynqmp.h+14−2

 /*
  * Xilinx Zynq MPSoC Firmware layer
  *
- *  Copyright (C) 2014-2018 Xilinx
+ *  Copyright (C) 2014-2019 Xilinx
  *
  *  Michal Simek <michal.simek@xilinx.com>
  *  Davorin Mista <davorin.mista@aggios.com>
 #define	ZYNQMP_PM_CAPABILITY_ACCESS	0x1U
 #define	ZYNQMP_PM_CAPABILITY_CONTEXT	0x2U
 #define	ZYNQMP_PM_CAPABILITY_WAKEUP	0x4U
+#define	ZYNQMP_PM_CAPABILITY_UNUSABLE	0x8U
 /*
  * Firmware FPGA Manager flags
 };
 enum pm_ioctl_id {
-	IOCTL_SET_PLL_FRAC_MODE = 8,
+	IOCTL_SET_SD_TAPDELAY = 7,
+	IOCTL_SET_PLL_FRAC_MODE,
 	IOCTL_GET_PLL_FRAC_MODE,
 	IOCTL_SET_PLL_FRAC_DATA,
 	IOCTL_GET_PLL_FRAC_DATA,
 	ZYNQMP_PM_REQUEST_ACK_NON_BLOCKING,
 };
+enum pm_node_id {
+	NODE_SD_0 = 39,
+	NODE_SD_1,
+};
+enum tap_delay_type {
+	PM_TAPDELAY_INPUT = 0,
+	PM_TAPDELAY_OUTPUT,
+};
 /**
  * struct zynqmp_pm_query_data - PM query data
  * @qid:	query ID

include/linux/fs.h+13−6

 extern long vfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
+#ifdef CONFIG_COMPAT
+extern long compat_ptr_ioctl(struct file *file, unsigned int cmd,
+					unsigned long arg);
+#else
+#define compat_ptr_ioctl NULL
+#endif
 /*
  * VFS file helper functions.
  */
 /* fs/ioctl.c */
-extern int ioctl_preallocate(struct file *filp, void __user *argp);
+extern int ioctl_preallocate(struct file *filp, int mode, void __user *argp);
 /* fs/dcache.c */
 extern void __init vfs_caches_init_early(void);
 extern void bd_abort_claiming(struct block_device *bdev,
 			      struct block_device *whole, void *holder);
 extern void blkdev_put(struct block_device *bdev, fmode_t mode);
-extern int __blkdev_reread_part(struct block_device *bdev);
-extern int blkdev_reread_part(struct block_device *bdev);
 #ifdef CONFIG_SYSFS
 extern int bd_link_disk_holder(struct block_device *bdev, struct gendisk *disk);
 extern bool is_bad_inode(struct inode *);
 #ifdef CONFIG_BLOCK
-extern void check_disk_size_change(struct gendisk *disk,
-		struct block_device *bdev, bool verbose);
 extern int revalidate_disk(struct gendisk *);
 extern int check_disk_change(struct block_device *);
 extern int __invalidate_device(struct block_device *, bool);
 };
 void dio_end_io(struct bio *bio);
-void dio_warn_stale_pagecache(struct file *filp);
 ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,
 			     struct block_device *bdev, struct iov_iter *iter,
 		wake_up_bit(&inode->i_state, __I_DIO_WAKEUP);
 }
+/*
+ * Warn about a page cache invalidation failure diring a direct I/O write.
+ */
+void dio_warn_stale_pagecache(struct file *filp);
 extern void inode_set_flags(struct inode *inode, unsigned int flags,
 			    unsigned int mask);

include/linux/fscrypt.h+3−32

@@ -20,7 +20,6 @@ · 19 unmodified lines
20		20
21	#define FS_CRYPTO_BLOCK_SIZE 16	21	#define FS_CRYPTO_BLOCK_SIZE 16
22		22
23	struct fscrypt_ctx;
24	struct fscrypt_info;	23	struct fscrypt_info;
25		24
26	struct fscrypt_str {	25	struct fscrypt_str {
@@ -62,18 +61,9 @@ struct fscrypt_operations { · 35 unmodified lines
62	bool (dummy_context)(struct inode );	61	bool (dummy_context)(struct inode );
63	bool (empty_dir)(struct inode );	62	bool (empty_dir)(struct inode );
64	unsigned int max_namelen;	63	unsigned int max_namelen;
65	};	64	bool (has_stable_inodes)(struct super_block sb);
66		65	void (get_ino_and_lblk_bits)(struct super_block sb,
67	/* Decryption work */	66	int ino_bits_ret, int lblk_bits_ret);
68	struct fscrypt_ctx {
69	union {
70	struct {
71	struct bio *bio;
72	struct work_struct work;
73	};
74	struct list_head free_list; /* Free list */
75	};
76	u8 flags; /* Flags */
77	};	67	};
78		68
79	static inline bool fscrypt_has_encryption_key(const struct inode *inode)	69	static inline bool fscrypt_has_encryption_key(const struct inode *inode)
@@ -102,8 +92,6 @@ static inline void fscrypt_handle_d_move(struct dentry *dentry) · 22 unmodified lines
102		92
103	/* crypto.c */	93	/* crypto.c */
104	extern void fscrypt_enqueue_decrypt_work(struct work_struct *);	94	extern void fscrypt_enqueue_decrypt_work(struct work_struct *);
105	extern struct fscrypt_ctx *fscrypt_get_ctx(gfp_t);
106	extern void fscrypt_release_ctx(struct fscrypt_ctx *);
107		95
108	extern struct page fscrypt_encrypt_pagecache_blocks(struct page page,	96	extern struct page fscrypt_encrypt_pagecache_blocks(struct page page,
109	unsigned int len,	97	unsigned int len,
@@ -244,8 +232,6 @@ static inline bool fscrypt_match_name(const struct fscrypt_name *fname, · 134 unmodified lines
244		232
245	/* bio.c */	233	/* bio.c */
246	extern void fscrypt_decrypt_bio(struct bio *);	234	extern void fscrypt_decrypt_bio(struct bio *);
247	extern void fscrypt_enqueue_decrypt_bio(struct fscrypt_ctx *ctx,
248	struct bio *bio);
249	extern int fscrypt_zeroout_range(const struct inode *, pgoff_t, sector_t,	235	extern int fscrypt_zeroout_range(const struct inode *, pgoff_t, sector_t,
250	unsigned int);	236	unsigned int);
251		237
@@ -295,16 +281,6 @@ static inline void fscrypt_enqueue_decrypt_work(struct work_struct *work) · 43 unmodified lines
295	{	281	{
296	}	282	}
297		283
298	static inline struct fscrypt_ctx *fscrypt_get_ctx(gfp_t gfp_flags)
299	{
300	return ERR_PTR(-EOPNOTSUPP);
301	}
302
303	static inline void fscrypt_release_ctx(struct fscrypt_ctx *ctx)
304	{
305	return;
306	}
307
308	static inline struct page fscrypt_encrypt_pagecache_blocks(struct page page,	284	static inline struct page fscrypt_encrypt_pagecache_blocks(struct page page,
309	unsigned int len,	285	unsigned int len,
310	unsigned int offs,	286	unsigned int offs,
@@ -484,11 +460,6 @@ static inline void fscrypt_decrypt_bio(struct bio *bio) · 173 unmodified lines
484	{	460	{
485	}	461	}
486		462
487	static inline void fscrypt_enqueue_decrypt_bio(struct fscrypt_ctx *ctx,
488	struct bio *bio)
489	{
490	}
491
492	static inline int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk,	463	static inline int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk,
493	sector_t pblk, unsigned int len)	464	sector_t pblk, unsigned int len)
494	{	465	{

include/linux/fsl/mc.h+2−0

@@ -403,6 +403,8 @@ int __must_check fsl_mc_allocate_irqs(struct fsl_mc_device *mc_dev); · 402 unmodified lines
403		403
404	void fsl_mc_free_irqs(struct fsl_mc_device *mc_dev);	404	void fsl_mc_free_irqs(struct fsl_mc_device *mc_dev);
405		405
		406	struct fsl_mc_device fsl_mc_get_endpoint(struct fsl_mc_device mc_dev);
		407
406	extern struct bus_type fsl_mc_bus_type;	408	extern struct bus_type fsl_mc_bus_type;
407		409
408	extern struct device_type fsl_mc_bus_dprc_type;	410	extern struct device_type fsl_mc_bus_dprc_type;

include/linux/ftrace.h+134−23

@@ -51,6 +51,7 @@ static inline void early_trace_init(void) { } · 50 unmodified lines
51		51
52	struct module;	52	struct module;
53	struct ftrace_hash;	53	struct ftrace_hash;
		54	struct ftrace_direct_func;
54		55
55	#if defined(CONFIG_FUNCTION_TRACER) && defined(CONFIG_MODULES) && \	56	#if defined(CONFIG_FUNCTION_TRACER) && defined(CONFIG_MODULES) && \
56	defined(CONFIG_DYNAMIC_FTRACE)	57	defined(CONFIG_DYNAMIC_FTRACE)
@@ -142,24 +143,30 @@ ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops); · 85 unmodified lines
142	* PID - Is affected by set_ftrace_pid (allows filtering on those pids)	143	* PID - Is affected by set_ftrace_pid (allows filtering on those pids)
143	* RCU - Set when the ops can only be called when RCU is watching.	144	* RCU - Set when the ops can only be called when RCU is watching.
144	* TRACE_ARRAY - The ops->private points to a trace_array descriptor.	145	* TRACE_ARRAY - The ops->private points to a trace_array descriptor.
		146	* PERMANENT - Set when the ops is permanent and should not be affected by
		147	* ftrace_enabled.
		148	* DIRECT - Used by the direct ftrace_ops helper for direct functions
		149	* (internal ftrace only, should not be used by others)
145	*/	150	*/
146	enum {	151	enum {
147	FTRACE_OPS_FL_ENABLED = 1 << 0,	152	FTRACE_OPS_FL_ENABLED = BIT(0),
148	FTRACE_OPS_FL_DYNAMIC = 1 << 1,	153	FTRACE_OPS_FL_DYNAMIC = BIT(1),
149	FTRACE_OPS_FL_SAVE_REGS = 1 << 2,	154	FTRACE_OPS_FL_SAVE_REGS = BIT(2),
150	FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED = 1 << 3,	155	FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED = BIT(3),
151	FTRACE_OPS_FL_RECURSION_SAFE = 1 << 4,	156	FTRACE_OPS_FL_RECURSION_SAFE = BIT(4),
152	FTRACE_OPS_FL_STUB = 1 << 5,	157	FTRACE_OPS_FL_STUB = BIT(5),
153	FTRACE_OPS_FL_INITIALIZED = 1 << 6,	158	FTRACE_OPS_FL_INITIALIZED = BIT(6),
154	FTRACE_OPS_FL_DELETED = 1 << 7,	159	FTRACE_OPS_FL_DELETED = BIT(7),
155	FTRACE_OPS_FL_ADDING = 1 << 8,	160	FTRACE_OPS_FL_ADDING = BIT(8),
156	FTRACE_OPS_FL_REMOVING = 1 << 9,	161	FTRACE_OPS_FL_REMOVING = BIT(9),
157	FTRACE_OPS_FL_MODIFYING = 1 << 10,	162	FTRACE_OPS_FL_MODIFYING = BIT(10),
158	FTRACE_OPS_FL_ALLOC_TRAMP = 1 << 11,	163	FTRACE_OPS_FL_ALLOC_TRAMP = BIT(11),
159	FTRACE_OPS_FL_IPMODIFY = 1 << 12,	164	FTRACE_OPS_FL_IPMODIFY = BIT(12),
160	FTRACE_OPS_FL_PID = 1 << 13,	165	FTRACE_OPS_FL_PID = BIT(13),
161	FTRACE_OPS_FL_RCU = 1 << 14,	166	FTRACE_OPS_FL_RCU = BIT(14),
162	FTRACE_OPS_FL_TRACE_ARRAY = 1 << 15,	167	FTRACE_OPS_FL_TRACE_ARRAY = BIT(15),
		168	FTRACE_OPS_FL_PERMANENT = BIT(16),
		169	FTRACE_OPS_FL_DIRECT = BIT(17),
163	};	170	};
164		171
165	#ifdef CONFIG_DYNAMIC_FTRACE	172	#ifdef CONFIG_DYNAMIC_FTRACE
@@ -239,6 +246,75 @@ static inline void ftrace_free_init_mem(void) { } · 73 unmodified lines
239	static inline void ftrace_free_mem(struct module mod, void start, void *end) { }	246	static inline void ftrace_free_mem(struct module mod, void start, void *end) { }
240	#endif /* CONFIG_FUNCTION_TRACER */	247	#endif /* CONFIG_FUNCTION_TRACER */
241		248
		249	struct ftrace_func_entry {
		250	struct hlist_node hlist;
		251	unsigned long ip;
		252	unsigned long direct; /* for direct lookup only */
		253	};
		254
		255	struct dyn_ftrace;
		256
		257	#ifdef CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS
		258	extern int ftrace_direct_func_count;
		259	int register_ftrace_direct(unsigned long ip, unsigned long addr);
		260	int unregister_ftrace_direct(unsigned long ip, unsigned long addr);
		261	int modify_ftrace_direct(unsigned long ip, unsigned long old_addr, unsigned long new_addr);
		262	struct ftrace_direct_func *ftrace_find_direct_func(unsigned long addr);
		263	int ftrace_modify_direct_caller(struct ftrace_func_entry *entry,
		264	struct dyn_ftrace *rec,
		265	unsigned long old_addr,
		266	unsigned long new_addr);
		267	unsigned long ftrace_find_rec_direct(unsigned long ip);
		268	#else
		269	# define ftrace_direct_func_count 0
		270	static inline int register_ftrace_direct(unsigned long ip, unsigned long addr)
		271	{
		272	return -ENOTSUPP;
		273	}
		274	static inline int unregister_ftrace_direct(unsigned long ip, unsigned long addr)
		275	{
		276	return -ENOTSUPP;
		277	}
		278	static inline int modify_ftrace_direct(unsigned long ip,
		279	unsigned long old_addr, unsigned long new_addr)
		280	{
		281	return -ENOTSUPP;
		282	}
		283	static inline struct ftrace_direct_func *ftrace_find_direct_func(unsigned long addr)
		284	{
		285	return NULL;
		286	}
		287	static inline int ftrace_modify_direct_caller(struct ftrace_func_entry *entry,
		288	struct dyn_ftrace *rec,
		289	unsigned long old_addr,
		290	unsigned long new_addr)
		291	{
		292	return -ENODEV;
		293	}
		294	static inline unsigned long ftrace_find_rec_direct(unsigned long ip)
		295	{
		296	return 0;
		297	}
		298	#endif /* CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS */
		299
		300	#ifndef CONFIG_HAVE_DYNAMIC_FTRACE_WITH_DIRECT_CALLS
		301	/*
		302	* This must be implemented by the architecture.
		303	* It is the way the ftrace direct_ops helper, when called
		304	* via ftrace (because there's other callbacks besides the
		305	* direct call), can inform the architecture's trampoline that this
		306	* routine has a direct caller, and what the caller is.
		307	*
		308	* For example, in x86, it returns the direct caller
		309	* callback function via the regs->orig_ax parameter.
		310	* Then in the ftrace trampoline, if this is set, it makes
		311	* the return from the trampoline jump to the direct caller
		312	* instead of going back to the function it just traced.
		313	*/
		314	static inline void arch_ftrace_set_direct_caller(struct pt_regs *regs,
		315	unsigned long addr) { }
		316	#endif /* CONFIG_HAVE_DYNAMIC_FTRACE_WITH_DIRECT_CALLS */
		317
242	#ifdef CONFIG_STACK_TRACER	318	#ifdef CONFIG_STACK_TRACER
243		319
244	extern int stack_tracer_enabled;	320	extern int stack_tracer_enabled;
@@ -291,8 +367,6 @@ static inline void stack_tracer_enable(void) { } · 46 unmodified lines
291	int ftrace_arch_code_modify_prepare(void);	367	int ftrace_arch_code_modify_prepare(void);
292	int ftrace_arch_code_modify_post_process(void);	368	int ftrace_arch_code_modify_post_process(void);
293		369
294	struct dyn_ftrace;
295
296	enum ftrace_bug_type {	370	enum ftrace_bug_type {
297	FTRACE_BUG_UNKNOWN,	371	FTRACE_BUG_UNKNOWN,
298	FTRACE_BUG_INIT,	372	FTRACE_BUG_INIT,
@@ -330,6 +404,7 @@ bool is_ftrace_trampoline(unsigned long addr); · 31 unmodified lines
330	* REGS_EN - the function is set up to save regs.	404	* REGS_EN - the function is set up to save regs.
331	* IPMODIFY - the record allows for the IP address to be changed.	405	* IPMODIFY - the record allows for the IP address to be changed.
332	* DISABLED - the record is not ready to be touched yet	406	* DISABLED - the record is not ready to be touched yet
		407	* DIRECT - there is a direct function to call
333	*	408	*
334	* When a new ftrace_ops is registered and wants a function to save	409	* When a new ftrace_ops is registered and wants a function to save
335	* pt_regs, the rec->flag REGS is set. When the function has been	410	* pt_regs, the rec->flag REGS is set. When the function has been
@@ -345,10 +420,12 @@ enum { · 9 unmodified lines
345	FTRACE_FL_TRAMP_EN = (1UL << 27),	420	FTRACE_FL_TRAMP_EN = (1UL << 27),
346	FTRACE_FL_IPMODIFY = (1UL << 26),	421	FTRACE_FL_IPMODIFY = (1UL << 26),
347	FTRACE_FL_DISABLED = (1UL << 25),	422	FTRACE_FL_DISABLED = (1UL << 25),
		423	FTRACE_FL_DIRECT = (1UL << 24),
		424	FTRACE_FL_DIRECT_EN = (1UL << 23),
348	};	425	};
349		426
350	#define FTRACE_REF_MAX_SHIFT 25	427	#define FTRACE_REF_MAX_SHIFT 23
351	#define FTRACE_FL_BITS 7	428	#define FTRACE_FL_BITS 9
352	#define FTRACE_FL_MASKED_BITS ((1UL << FTRACE_FL_BITS) - 1)	429	#define FTRACE_FL_MASKED_BITS ((1UL << FTRACE_FL_BITS) - 1)
353	#define FTRACE_FL_MASK (FTRACE_FL_MASKED_BITS << FTRACE_REF_MAX_SHIFT)	430	#define FTRACE_FL_MASK (FTRACE_FL_MASKED_BITS << FTRACE_REF_MAX_SHIFT)
354	#define FTRACE_REF_MAX ((1UL << FTRACE_REF_MAX_SHIFT) - 1)	431	#define FTRACE_REF_MAX ((1UL << FTRACE_REF_MAX_SHIFT) - 1)
@@ -499,7 +576,7 @@ static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; } · 144 unmodified lines
499	/**	576	/**
500	* ftrace_make_nop - convert code into nop	577	* ftrace_make_nop - convert code into nop
501	* @mod: module structure if called by module load initialization	578	* @mod: module structure if called by module load initialization
502	* @rec: the mcount call site record	579	* @rec: the call site record (e.g. mcount/fentry)
503	* @addr: the address that the call site should be calling	580	* @addr: the address that the call site should be calling
504	*	581	*
505	* This is a very sensitive operation and great care needs	582	* This is a very sensitive operation and great care needs
@@ -520,9 +597,38 @@ static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; } · 14 unmodified lines
520	extern int ftrace_make_nop(struct module *mod,	597	extern int ftrace_make_nop(struct module *mod,
521	struct dyn_ftrace *rec, unsigned long addr);	598	struct dyn_ftrace *rec, unsigned long addr);
522		599
		600
		601	/**
		602	* ftrace_init_nop - initialize a nop call site
		603	* @mod: module structure if called by module load initialization
		604	* @rec: the call site record (e.g. mcount/fentry)
		605	*
		606	* This is a very sensitive operation and great care needs
		607	* to be taken by the arch. The operation should carefully
		608	* read the location, check to see if what is read is indeed
		609	* what we expect it to be, and then on success of the compare,
		610	* it should write to the location.
		611	*
		612	* The code segment at @rec->ip should contain the contents created by
		613	* the compiler
		614	*
		615	* Return must be:
		616	* 0 on success
		617	* -EFAULT on error reading the location
		618	* -EINVAL on a failed compare of the contents
		619	* -EPERM on error writing to the location
		620	* Any other value will be considered a failure.
		621	*/
		622	#ifndef ftrace_init_nop
		623	static inline int ftrace_init_nop(struct module mod, struct dyn_ftrace rec)
		624	{
		625	return ftrace_make_nop(mod, rec, MCOUNT_ADDR);
		626	}
		627	#endif
		628
523	/**	629	/**
524	* ftrace_make_call - convert a nop call site into a call to addr	630	* ftrace_make_call - convert a nop call site into a call to addr
525	* @rec: the mcount call site record	631	* @rec: the call site record (e.g. mcount/fentry)
526	* @addr: the address that the call site should call	632	* @addr: the address that the call site should call
527	*	633	*
528	* This is a very sensitive operation and great care needs	634	* This is a very sensitive operation and great care needs
@@ -545,7 +651,7 @@ extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr); · 16 unmodified lines
545	#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS	651	#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
546	/**	652	/**
547	* ftrace_modify_call - convert from one addr to another (no nop)	653	* ftrace_modify_call - convert from one addr to another (no nop)
548	* @rec: the mcount call site record	654	* @rec: the call site record (e.g. mcount/fentry)
549	* @old_addr: the address expected to be currently called to	655	* @old_addr: the address expected to be currently called to
550	* @addr: the address to change to	656	* @addr: the address to change to
551	*	657	*
@@ -709,6 +815,11 @@ static inline unsigned long get_lock_parent_ip(void) · 157 unmodified lines
709		815
710	#ifdef CONFIG_FTRACE_MCOUNT_RECORD	816	#ifdef CONFIG_FTRACE_MCOUNT_RECORD
711	extern void ftrace_init(void);	817	extern void ftrace_init(void);
		818	#ifdef CC_USING_PATCHABLE_FUNCTION_ENTRY
		819	#define FTRACE_CALLSITE_SECTION "__patchable_function_entries"
		820	#else
		821	#define FTRACE_CALLSITE_SECTION "__mcount_loc"
		822	#endif
712	#else	823	#else
713	static inline void ftrace_init(void) { }	824	static inline void ftrace_init(void) { }
714	#endif	825	#endif

include/linux/futex.h+27−13

 #ifndef _LINUX_FUTEX_H
 #define _LINUX_FUTEX_H
+#include <linux/sched.h>
 #include <linux/ktime.h>
 #include <uapi/linux/futex.h>
 struct inode;
 #define FUTEX_KEY_INIT (union futex_key) { .both = { .ptr = NULL } }
 #ifdef CONFIG_FUTEX
-extern void exit_robust_list(struct task_struct *curr);
+enum {
+	FUTEX_STATE_OK,
+	FUTEX_STATE_EXITING,
+	FUTEX_STATE_DEAD,
+};
-long do_futex(u32 __user *uaddr, int op, u32 val, ktime_t *timeout,
+static inline void futex_init_task(struct task_struct *tsk)
-	      u32 __user *uaddr2, u32 val2, u32 val3);
-#else
-static inline void exit_robust_list(struct task_struct *curr)
 {
+	tsk->robust_list = NULL;
+#ifdef CONFIG_COMPAT
+	tsk->compat_robust_list = NULL;
+#endif
+	INIT_LIST_HEAD(&tsk->pi_state_list);
+	tsk->pi_state_cache = NULL;
+	tsk->futex_state = FUTEX_STATE_OK;
+	mutex_init(&tsk->futex_exit_mutex);
 }
+void futex_exit_recursive(struct task_struct *tsk);
+void futex_exit_release(struct task_struct *tsk);
+void futex_exec_release(struct task_struct *tsk);
+long do_futex(u32 __user *uaddr, int op, u32 val, ktime_t *timeout,
+	      u32 __user *uaddr2, u32 val2, u32 val3);
+#else
+static inline void futex_init_task(struct task_struct *tsk) { }
+static inline void futex_exit_recursive(struct task_struct *tsk) { }
+static inline void futex_exit_release(struct task_struct *tsk) { }
+static inline void futex_exec_release(struct task_struct *tsk) { }
 static inline long do_futex(u32 __user *uaddr, int op, u32 val,
 			    ktime_t *timeout, u32 __user *uaddr2,
 			    u32 val2, u32 val3)
 }
 #endif
-#ifdef CONFIG_FUTEX_PI
-extern void exit_pi_state_list(struct task_struct *curr);
-#else
-static inline void exit_pi_state_list(struct task_struct *curr)
-{
-}
-#endif
 #endif

include/linux/fwnode.h+49−3

@@ -17,6 +17,7 @@ struct device; · 16 unmodified lines
17	struct fwnode_handle {	17	struct fwnode_handle {
18	struct fwnode_handle *secondary;	18	struct fwnode_handle *secondary;
19	const struct fwnode_operations *ops;	19	const struct fwnode_operations *ops;
		20	struct device *dev;
20	};	21	};
21		22
22	/**	23	/**
@@ -49,13 +50,15 @@ struct fwnode_reference_args { · 26 unmodified lines
49	* struct fwnode_operations - Operations for fwnode interface	50	* struct fwnode_operations - Operations for fwnode interface
50	* @get: Get a reference to an fwnode.	51	* @get: Get a reference to an fwnode.
51	* @put: Put a reference to an fwnode.	52	* @put: Put a reference to an fwnode.
		53	* @device_is_available: Return true if the device is available.
52	* @device_get_match_data: Return the device driver match data.	54	* @device_get_match_data: Return the device driver match data.
53	* @property_present: Return true if a property is present.	55	* @property_present: Return true if a property is present.
54	* @property_read_integer_array: Read an array of integer properties. Return	56	* @property_read_int_array: Read an array of integer properties. Return zero on
55	* zero on success, a negative error code	57	* success, a negative error code otherwise.
56	* otherwise.
57	* @property_read_string_array: Read an array of string properties. Return zero	58	* @property_read_string_array: Read an array of string properties. Return zero
58	* on success, a negative error code otherwise.	59	* on success, a negative error code otherwise.
		60	* @get_name: Return the name of an fwnode.
		61	* @get_name_prefix: Get a prefix for a node (for printing purposes).
59	* @get_parent: Return the parent of an fwnode.	62	* @get_parent: Return the parent of an fwnode.
60	* @get_next_child_node: Return the next child node in an iteration.	63	* @get_next_child_node: Return the next child node in an iteration.
61	* @get_named_child_node: Return a child node with a given name.	64	* @get_named_child_node: Return a child node with a given name.
@@ -65,6 +68,44 @@ struct fwnode_reference_args { · 3 unmodified lines
65	* endpoint node.	68	* endpoint node.
66	* @graph_get_port_parent: Return the parent node of a port node.	69	* @graph_get_port_parent: Return the parent node of a port node.
67	* @graph_parse_endpoint: Parse endpoint for port and endpoint id.	70	* @graph_parse_endpoint: Parse endpoint for port and endpoint id.
		71	* @add_links: Called after the device corresponding to the fwnode is added
		72	* using device_add(). The function is expected to create device
		73	* links to all the suppliers of the device that are available at
		74	* the time this function is called. The function must NOT stop
		75	* at the first failed device link if other unlinked supplier
		76	* devices are present in the system. This is necessary for the
		77	* driver/bus sync_state() callbacks to work correctly.
		78	*
		79	* For example, say Device-C depends on suppliers Device-S1 and
		80	* Device-S2 and the dependency is listed in that order in the
		81	* firmware. Say, S1 gets populated from the firmware after
		82	* late_initcall_sync(). Say S2 is populated and probed way
		83	* before that in device_initcall(). When C is populated, if this
		84	* add_links() function doesn't continue past a "failed linking to
		85	* S1" and continue linking C to S2, then S2 will get a
		86	* sync_state() callback before C is probed. This is because from
		87	* the perspective of S2, C was never a consumer when its
		88	* sync_state() evaluation is done. To avoid this, the add_links()
		89	* function has to go through all available suppliers of the
		90	* device (that corresponds to this fwnode) and link to them
		91	* before returning.
		92	*
		93	* If some suppliers are not yet available (indicated by an error
		94	* return value), this function will be called again when other
		95	* devices are added to allow creating device links to any newly
		96	* available suppliers.
		97	*
		98	* Return 0 if device links have been successfully created to all
		99	* the known suppliers of this device or if the supplier
		100	* information is not known.
		101	*
		102	* Return -ENODEV if the suppliers needed for probing this device
		103	* have not been registered yet (because device links can only be
		104	* created to devices registered with the driver core).
		105	*
		106	* Return -EAGAIN if some of the suppliers of this device have not
		107	* been registered yet, but none of those suppliers are necessary
		108	* for probing the device.
68	*/	109	*/
69	struct fwnode_operations {	110	struct fwnode_operations {
70	struct fwnode_handle (get)(struct fwnode_handle *fwnode);	111	struct fwnode_handle (get)(struct fwnode_handle *fwnode);
@@ -82,6 +123,8 @@ struct fwnode_operations { · 11 unmodified lines
82	(property_read_string_array)(const struct fwnode_handle fwnode_handle,	123	(property_read_string_array)(const struct fwnode_handle fwnode_handle,
83	const char propname, const char *val,	124	const char propname, const char *val,
84	size_t nval);	125	size_t nval);
		126	const char (get_name)(const struct fwnode_handle *fwnode);
		127	const char (get_name_prefix)(const struct fwnode_handle *fwnode);
85	struct fwnode_handle (get_parent)(const struct fwnode_handle *fwnode);	128	struct fwnode_handle (get_parent)(const struct fwnode_handle *fwnode);
86	struct fwnode_handle *	129	struct fwnode_handle *
87	(get_next_child_node)(const struct fwnode_handle fwnode,	130	(get_next_child_node)(const struct fwnode_handle fwnode,
@@ -102,6 +145,8 @@ struct fwnode_operations { · 14 unmodified lines
102	(graph_get_port_parent)(struct fwnode_handle fwnode);	145	(graph_get_port_parent)(struct fwnode_handle fwnode);
103	int (graph_parse_endpoint)(const struct fwnode_handle fwnode,	146	int (graph_parse_endpoint)(const struct fwnode_handle fwnode,
104	struct fwnode_endpoint *endpoint);	147	struct fwnode_endpoint *endpoint);
		148	int (add_links)(const struct fwnode_handle fwnode,
		149	struct device *dev);
105	};	150	};
106		151
107	#define fwnode_has_op(fwnode, op) \	152	#define fwnode_has_op(fwnode, op) \
@@ -123,5 +168,6 @@ struct fwnode_operations { · 15 unmodified lines
123	if (fwnode_has_op(fwnode, op)) \	168	if (fwnode_has_op(fwnode, op)) \
124	(fwnode)->ops->op(fwnode, ## __VA_ARGS__); \	169	(fwnode)->ops->op(fwnode, ## __VA_ARGS__); \
125	} while (false)	170	} while (false)
		171	#define get_dev_from_fwnode(fwnode) get_device((fwnode)->dev)
126		172
127	#endif	173	#endif

include/linux/genalloc.h+1−1

@@ -206,7 +206,7 @@ extern struct gen_pool devm_gen_pool_create(struct device dev, · 205 unmodified lines
206	int min_alloc_order, int nid, const char *name);	206	int min_alloc_order, int nid, const char *name);
207	extern struct gen_pool gen_pool_get(struct device dev, const char *name);	207	extern struct gen_pool gen_pool_get(struct device dev, const char *name);
208		208
209	bool addr_in_gen_pool(struct gen_pool *pool, unsigned long start,	209	extern bool gen_pool_has_addr(struct gen_pool *pool, unsigned long start,
210	size_t size);	210	size_t size);
211		211
212	#ifdef CONFIG_OF	212	#ifdef CONFIG_OF

include/linux/genhd.h+3−2

 extern dev_t blk_lookup_devt(const char *name, int partno);
 extern char *disk_name (struct gendisk *hd, int partno, char *buf);
+int bdev_disk_changed(struct block_device *bdev, bool invalidate);
+int blk_add_partitions(struct gendisk *disk, struct block_device *bdev);
+int blk_drop_partitions(struct gendisk *disk, struct block_device *bdev);
 extern int disk_expand_part_tbl(struct gendisk *disk, int target);
-extern int rescan_partitions(struct gendisk *disk, struct block_device *bdev);
-extern int invalidate_partitions(struct gendisk *disk, struct block_device *bdev);
 extern struct hd_struct * __must_check add_partition(struct gendisk *disk,
 						     int partno, sector_t start,
 						     sector_t len, int flags,

include/linux/gfp.h+2−0

@@ -612,6 +612,8 @@ static inline bool pm_suspended_storage(void) · 611 unmodified lines
612	/* The below functions must be run on a range from a single zone. */	612	/* The below functions must be run on a range from a single zone. */
613	extern int alloc_contig_range(unsigned long start, unsigned long end,	613	extern int alloc_contig_range(unsigned long start, unsigned long end,
614	unsigned migratetype, gfp_t gfp_mask);	614	unsigned migratetype, gfp_t gfp_mask);
		615	extern struct page *alloc_contig_pages(unsigned long nr_pages, gfp_t gfp_mask,
		616	int nid, nodemask_t *nodemask);
615	#endif	617	#endif
616	void free_contig_range(unsigned long pfn, unsigned int nr_pages);	618	void free_contig_range(unsigned long pfn, unsigned int nr_pages);
617		619

include/linux/gpio/consumer.h+44−10

@@ -176,11 +176,15 @@ struct gpio_desc fwnode_get_named_gpiod(struct fwnode_handle fwnode, · 175 unmodified lines
176	const char *propname, int index,	176	const char *propname, int index,
177	enum gpiod_flags dflags,	177	enum gpiod_flags dflags,
178	const char *label);	178	const char *label);
179	struct gpio_desc devm_fwnode_get_index_gpiod_from_child(struct device dev,	179	struct gpio_desc fwnode_gpiod_get_index(struct fwnode_handle fwnode,
180	const char *con_id, int index,	180	const char *con_id, int index,
181	struct fwnode_handle *child,	181	enum gpiod_flags flags,
182	enum gpiod_flags flags,	182	const char *label);
183	const char *label);	183	struct gpio_desc devm_fwnode_gpiod_get_index(struct device dev,
		184	struct fwnode_handle *child,
		185	const char *con_id, int index,
		186	enum gpiod_flags flags,
		187	const char *label);
184		188
185	#else /* CONFIG_GPIOLIB */	189	#else /* CONFIG_GPIOLIB */
186		190
@@ -531,6 +535,38 @@ struct gpio_desc fwnode_get_named_gpiod(struct fwnode_handle fwnode, · 344 unmodified lines
531	return ERR_PTR(-ENOSYS);	535	return ERR_PTR(-ENOSYS);
532	}	536	}
533		537
		538	static inline
		539	struct gpio_desc fwnode_gpiod_get_index(struct fwnode_handle fwnode,
		540	const char *con_id, int index,
		541	enum gpiod_flags flags,
		542	const char *label)
		543	{
		544	return ERR_PTR(-ENOSYS);
		545	}
		546
		547	static inline
		548	struct gpio_desc devm_fwnode_gpiod_get_index(struct device dev,
		549	struct fwnode_handle *fwnode,
		550	const char *con_id, int index,
		551	enum gpiod_flags flags,
		552	const char *label)
		553	{
		554	return ERR_PTR(-ENOSYS);
		555	}
		556
		557	#endif /* CONFIG_GPIOLIB */
		558
		559	static inline
		560	struct gpio_desc devm_fwnode_gpiod_get(struct device dev,
		561	struct fwnode_handle *fwnode,
		562	const char *con_id,
		563	enum gpiod_flags flags,
		564	const char *label)
		565	{
		566	return devm_fwnode_gpiod_get_index(dev, fwnode, con_id, 0,
		567	flags, label);
		568	}
		569
534	static inline	570	static inline
535	struct gpio_desc devm_fwnode_get_index_gpiod_from_child(struct device dev,	571	struct gpio_desc devm_fwnode_get_index_gpiod_from_child(struct device dev,
536	const char *con_id, int index,	572	const char *con_id, int index,
@@ -538,11 +574,10 @@ struct gpio_desc devm_fwnode_get_index_gpiod_from_child(struct device dev, · 1 unmodified line
538	enum gpiod_flags flags,	574	enum gpiod_flags flags,
539	const char *label)	575	const char *label)
540	{	576	{
541	return ERR_PTR(-ENOSYS);	577	return devm_fwnode_gpiod_get_index(dev, child, con_id, index,
		578	flags, label);
542	}	579	}
543		580
544	#endif /* CONFIG_GPIOLIB */
545
546	static inline	581	static inline
547	struct gpio_desc devm_fwnode_get_gpiod_from_child(struct device dev,	582	struct gpio_desc devm_fwnode_get_gpiod_from_child(struct device dev,
548	const char *con_id,	583	const char *con_id,
@@ -550,8 +585,7 @@ struct gpio_desc devm_fwnode_get_gpiod_from_child(struct device dev, · 1 unmodified line
550	enum gpiod_flags flags,	585	enum gpiod_flags flags,
551	const char *label)	586	const char *label)
552	{	587	{
553	return devm_fwnode_get_index_gpiod_from_child(dev, con_id, 0, child,	588	return devm_fwnode_gpiod_get_index(dev, child, con_id, 0, flags, label);
554	flags, label);
555	}	589	}
556		590
557	#if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_OF_GPIO)	591	#if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_OF_GPIO)

include/linux/gpio/driver.h+8−0

 struct gpio_chip;
+#define GPIO_LINE_DIRECTION_IN	1
+#define GPIO_LINE_DIRECTION_OUT	0
 /**
  * struct gpio_irq_chip - GPIO interrupt controller
  */
  *	state (such as pullup/pulldown configuration).
  * @init_valid_mask: optional routine to initialize @valid_mask, to be used if
  *	not all GPIOs are valid.
+ * @add_pin_ranges: optional routine to initialize pin ranges, to be used when
+ *	requires special mapping of the pins that provides GPIO functionality.
+ *	It is called after adding GPIO chip and before adding IRQ chip.
  * @base: identifies the first GPIO number handled by this chip;
  *	or, if negative during registration, requests dynamic ID allocation.
  *	DEPRECATION: providing anything non-negative and nailing the base
 						   unsigned long *valid_mask,
 						   unsigned int ngpios);
+	int			(*add_pin_ranges)(struct gpio_chip *chip);
 	int			base;
 	u16			ngpio;
 	const char		*const *names;

include/linux/hmm.h+14−176

@@ -62,37 +62,12 @@ · 61 unmodified lines
62	#include <linux/kconfig.h>	62	#include <linux/kconfig.h>
63	#include <asm/pgtable.h>	63	#include <asm/pgtable.h>
64		64
65	#ifdef CONFIG_HMM_MIRROR
66
67	#include <linux/device.h>	65	#include <linux/device.h>
68	#include <linux/migrate.h>	66	#include <linux/migrate.h>
69	#include <linux/memremap.h>	67	#include <linux/memremap.h>
70	#include <linux/completion.h>	68	#include <linux/completion.h>
71	#include <linux/mmu_notifier.h>	69	#include <linux/mmu_notifier.h>
72		70
73
74	/*
75	* struct hmm - HMM per mm struct
76	*
77	* @mm: mm struct this HMM struct is bound to
78	* @lock: lock protecting ranges list
79	* @ranges: list of range being snapshotted
80	* @mirrors: list of mirrors for this mm
81	* @mmu_notifier: mmu notifier to track updates to CPU page table
82	* @mirrors_sem: read/write semaphore protecting the mirrors list
83	* @wq: wait queue for user waiting on a range invalidation
84	* @notifiers: count of active mmu notifiers
85	*/
86	struct hmm {
87	struct mmu_notifier mmu_notifier;
88	spinlock_t ranges_lock;
89	struct list_head ranges;
90	struct list_head mirrors;
91	struct rw_semaphore mirrors_sem;
92	wait_queue_head_t wq;
93	long notifiers;
94	};
95
96	/*	71	/*
97	* hmm_pfn_flag_e - HMM flag enums	72	* hmm_pfn_flag_e - HMM flag enums
98	*	73	*
@@ -145,6 +120,8 @@ enum hmm_pfn_value_e { · 46 unmodified lines
145	/*	120	/*
146	* struct hmm_range - track invalidation lock on virtual address range	121	* struct hmm_range - track invalidation lock on virtual address range
147	*	122	*
		123	* @notifier: a mmu_interval_notifier that includes the start/end
		124	* @notifier_seq: result of mmu_interval_read_begin()
148	* @hmm: the core HMM structure this range is active against	125	* @hmm: the core HMM structure this range is active against
149	* @vma: the vm area struct for the range	126	* @vma: the vm area struct for the range
150	* @list: all range lock are on a list	127	* @list: all range lock are on a list
@@ -159,8 +136,8 @@ enum hmm_pfn_value_e { · 8 unmodified lines
159	* @valid: pfns array did not change since it has been fill by an HMM function	136	* @valid: pfns array did not change since it has been fill by an HMM function
160	*/	137	*/
161	struct hmm_range {	138	struct hmm_range {
162	struct hmm *hmm;	139	struct mmu_interval_notifier *notifier;
163	struct list_head list;	140	unsigned long notifier_seq;
164	unsigned long start;	141	unsigned long start;
165	unsigned long end;	142	unsigned long end;
166	uint64_t *pfns;	143	uint64_t *pfns;
@@ -169,32 +146,8 @@ struct hmm_range { · 2 unmodified lines
169	uint64_t default_flags;	146	uint64_t default_flags;
170	uint64_t pfn_flags_mask;	147	uint64_t pfn_flags_mask;
171	uint8_t pfn_shift;	148	uint8_t pfn_shift;
172	bool valid;
173	};	149	};
174		150
175	/*
176	* hmm_range_wait_until_valid() - wait for range to be valid
177	* @range: range affected by invalidation to wait on
178	* @timeout: time out for wait in ms (ie abort wait after that period of time)
179	* Return: true if the range is valid, false otherwise.
180	*/
181	static inline bool hmm_range_wait_until_valid(struct hmm_range *range,
182	unsigned long timeout)
183	{
184	return wait_event_timeout(range->hmm->wq, range->valid,
185	msecs_to_jiffies(timeout)) != 0;
186	}
187
188	/*
189	* hmm_range_valid() - test if a range is valid or not
190	* @range: range
191	* Return: true if the range is valid, false otherwise.
192	*/
193	static inline bool hmm_range_valid(struct hmm_range *range)
194	{
195	return range->valid;
196	}
197
198	/*	151	/*
199	* hmm_device_entry_to_page() - return struct page pointed to by a device entry	152	* hmm_device_entry_to_page() - return struct page pointed to by a device entry
200	* @range: range use to decode device entry value	153	* @range: range use to decode device entry value
@@ -264,120 +217,6 @@ static inline uint64_t hmm_device_entry_from_pfn(const struct hmm_range *range, · 63 unmodified lines
264	range->flags[HMM_PFN_VALID];	217	range->flags[HMM_PFN_VALID];
265	}	218	}
266		219
267	/*
268	* Mirroring: how to synchronize device page table with CPU page table.
269	*
270	* A device driver that is participating in HMM mirroring must always
271	* synchronize with CPU page table updates. For this, device drivers can either
272	* directly use mmu_notifier APIs or they can use the hmm_mirror API. Device
273	* drivers can decide to register one mirror per device per process, or just
274	* one mirror per process for a group of devices. The pattern is:
275	*
276	* int device_bind_address_space(..., struct mm_struct *mm, ...)
277	* {
278	* struct device_address_space *das;
279	*
280	* // Device driver specific initialization, and allocation of das
281	* // which contains an hmm_mirror struct as one of its fields.
282	* ...
283	*
284	* ret = hmm_mirror_register(&das->mirror, mm, &device_mirror_ops);
285	* if (ret) {
286	* // Cleanup on error
287	* return ret;
288	* }
289	*
290	* // Other device driver specific initialization
291	* ...
292	* }
293	*
294	* Once an hmm_mirror is registered for an address space, the device driver
295	* will get callbacks through sync_cpu_device_pagetables() operation (see
296	* hmm_mirror_ops struct).
297	*
298	* Device driver must not free the struct containing the hmm_mirror struct
299	* before calling hmm_mirror_unregister(). The expected usage is to do that when
300	* the device driver is unbinding from an address space.
301	*
302	*
303	* void device_unbind_address_space(struct device_address_space *das)
304	* {
305	* // Device driver specific cleanup
306	* ...
307	*
308	* hmm_mirror_unregister(&das->mirror);
309	*
310	* // Other device driver specific cleanup, and now das can be freed
311	* ...
312	* }
313	*/
314
315	struct hmm_mirror;
316
317	/*
318	* struct hmm_mirror_ops - HMM mirror device operations callback
319	*
320	* @update: callback to update range on a device
321	*/
322	struct hmm_mirror_ops {
323	/* release() - release hmm_mirror
324	*
325	* @mirror: pointer to struct hmm_mirror
326	*
327	* This is called when the mm_struct is being released. The callback
328	* must ensure that all access to any pages obtained from this mirror
329	* is halted before the callback returns. All future access should
330	* fault.
331	*/
332	void (release)(struct hmm_mirror mirror);
333
334	/* sync_cpu_device_pagetables() - synchronize page tables
335	*
336	* @mirror: pointer to struct hmm_mirror
337	* @update: update information (see struct mmu_notifier_range)
338	* Return: -EAGAIN if mmu_notifier_range_blockable(update) is false
339	* and callback needs to block, 0 otherwise.
340	*
341	* This callback ultimately originates from mmu_notifiers when the CPU
342	* page table is updated. The device driver must update its page table
343	* in response to this callback. The update argument tells what action
344	* to perform.
345	*
346	* The device driver must not return from this callback until the device
347	* page tables are completely updated (TLBs flushed, etc); this is a
348	* synchronous call.
349	*/
350	int (*sync_cpu_device_pagetables)(
351	struct hmm_mirror *mirror,
352	const struct mmu_notifier_range *update);
353	};
354
355	/*
356	* struct hmm_mirror - mirror struct for a device driver
357	*
358	* @hmm: pointer to struct hmm (which is unique per mm_struct)
359	* @ops: device driver callback for HMM mirror operations
360	* @list: for list of mirrors of a given mm
361	*
362	* Each address space (mm_struct) being mirrored by a device must register one
363	* instance of an hmm_mirror struct with HMM. HMM will track the list of all
364	* mirrors for each mm_struct.
365	*/
366	struct hmm_mirror {
367	struct hmm *hmm;
368	const struct hmm_mirror_ops *ops;
369	struct list_head list;
370	};
371
372	int hmm_mirror_register(struct hmm_mirror mirror, struct mm_struct mm);
373	void hmm_mirror_unregister(struct hmm_mirror *mirror);
374
375	/*
376	* Please see Documentation/vm/hmm.rst for how to use the range API.
377	*/
378	int hmm_range_register(struct hmm_range range, struct hmm_mirror mirror);
379	void hmm_range_unregister(struct hmm_range *range);
380
381	/*	220	/*
382	* Retry fault if non-blocking, drop mmap_sem and return -EAGAIN in that case.	221	* Retry fault if non-blocking, drop mmap_sem and return -EAGAIN in that case.
383	*/	222	*/
@@ -386,16 +225,17 @@ void hmm_range_unregister(struct hmm_range *range); · 2 unmodified lines
386	/* Don't fault in missing PTEs, just snapshot the current state. */	225	/* Don't fault in missing PTEs, just snapshot the current state. */
387	#define HMM_FAULT_SNAPSHOT (1 << 1)	226	#define HMM_FAULT_SNAPSHOT (1 << 1)
388		227
		228	#ifdef CONFIG_HMM_MIRROR
		229	/*
		230	* Please see Documentation/vm/hmm.rst for how to use the range API.
		231	*/
389	long hmm_range_fault(struct hmm_range *range, unsigned int flags);	232	long hmm_range_fault(struct hmm_range *range, unsigned int flags);
390		233	#else
391	long hmm_range_dma_map(struct hmm_range *range,	234	static inline long hmm_range_fault(struct hmm_range *range, unsigned int flags)
392	struct device *device,	235	{
393	dma_addr_t *daddrs,	236	return -EOPNOTSUPP;
394	unsigned int flags);	237	}
395	long hmm_range_dma_unmap(struct hmm_range *range,	238	#endif
396	struct device *device,
397	dma_addr_t *daddrs,
398	bool dirty);
399		239
400	/*	240	/*
401	* HMM_RANGE_DEFAULT_TIMEOUT - default timeout (ms) when waiting for a range	241	* HMM_RANGE_DEFAULT_TIMEOUT - default timeout (ms) when waiting for a range
@@ -406,6 +246,4 @@ long hmm_range_dma_unmap(struct hmm_range *range, · 4 unmodified lines
406	*/	246	*/
407	#define HMM_RANGE_DEFAULT_TIMEOUT 1000	247	#define HMM_RANGE_DEFAULT_TIMEOUT 1000
408		248
409	#endif /* IS_ENABLED(CONFIG_HMM_MIRROR) */
410
411	#endif /* LINUX_HMM_H */	249	#endif /* LINUX_HMM_H */

include/linux/host1x.h+18−8

 };
 struct host1x_client;
+struct iommu_group;
 /**
  * struct host1x_client_ops - host1x client operations
  * @list: list node for the host1x client
  * @parent: pointer to struct device representing the host1x controller
  * @dev: pointer to struct device backing this host1x client
+ * @group: IOMMU group that this client is a member of
  * @ops: host1x client operations
  * @class: host1x class represented by this client
  * @channel: host1x channel associated with this client
 	struct list_head list;
 	struct device *parent;
 	struct device *dev;
+	struct iommu_group *group;
 	const struct host1x_client_ops *ops;
 struct host1x_bo_ops {
 	struct host1x_bo *(*get)(struct host1x_bo *bo);
 	void (*put)(struct host1x_bo *bo);
-	dma_addr_t (*pin)(struct host1x_bo *bo, struct sg_table **sgt);
+	struct sg_table *(*pin)(struct device *dev, struct host1x_bo *bo,
-	void (*unpin)(struct host1x_bo *bo, struct sg_table *sgt);
+				dma_addr_t *phys);
+	void (*unpin)(struct device *dev, struct sg_table *sgt);
 	void *(*mmap)(struct host1x_bo *bo);
 	void (*munmap)(struct host1x_bo *bo, void *addr);
 	void *(*kmap)(struct host1x_bo *bo, unsigned int pagenum);
 	bo->ops->put(bo);
 }
-static inline dma_addr_t host1x_bo_pin(struct host1x_bo *bo,
+static inline struct sg_table *host1x_bo_pin(struct device *dev,
-				       struct sg_table **sgt)
+					     struct host1x_bo *bo,
+					     dma_addr_t *phys)
 {
-	return bo->ops->pin(bo, sgt);
+	return bo->ops->pin(dev, bo, phys);
 }
-static inline void host1x_bo_unpin(struct host1x_bo *bo, struct sg_table *sgt)
+static inline void host1x_bo_unpin(struct device *dev, struct host1x_bo *bo,
+				   struct sg_table *sgt)
 {
-	bo->ops->unpin(bo, sgt);
+	bo->ops->unpin(dev, sgt);
 }
 static inline void *host1x_bo_mmap(struct host1x_bo *bo)
 struct host1x_channel;
 struct host1x_job;
-struct host1x_channel *host1x_channel_request(struct device *dev);
+struct host1x_channel *host1x_channel_request(struct host1x_client *client);
 struct host1x_channel *host1x_channel_get(struct host1x_channel *channel);
 void host1x_channel_put(struct host1x_channel *channel);
 int host1x_job_submit(struct host1x_job *job);
  * host1x job
  */
+#define HOST1X_RELOC_READ	(1 << 0)
+#define HOST1X_RELOC_WRITE	(1 << 1)
 struct host1x_reloc {
 	struct {
 		struct host1x_bo *bo;
 		unsigned long offset;
 	} target;
 	unsigned long shift;
+	unsigned long flags;
 };
 struct host1x_job {

include/linux/hrtimer.h+10−4

 extern bool hrtimer_active(const struct hrtimer *timer);
-/*
+/**
- * Helper function to check, whether the timer is on one of the queues
+ * hrtimer_is_queued = check, whether the timer is on one of the queues
+ * @timer:	Timer to check
+ *
+ * Returns: True if the timer is queued, false otherwise
+ *
+ * The function can be used lockless, but it gives only a current snapshot.
  */
-static inline int hrtimer_is_queued(struct hrtimer *timer)
+static inline bool hrtimer_is_queued(struct hrtimer *timer)
 {
-	return timer->state & HRTIMER_STATE_ENQUEUED;
+	/* The READ_ONCE pairs with the update functions of timer->state */
+	return !!(READ_ONCE(timer->state) & HRTIMER_STATE_ENQUEUED);
 }
 /*

include/linux/huge_mm.h+0−2

 static inline spinlock_t *pmd_trans_huge_lock(pmd_t *pmd,
 		struct vm_area_struct *vma)
 {
-	VM_BUG_ON_VMA(!rwsem_is_locked(&vma->vm_mm->mmap_sem), vma);
 	if (is_swap_pmd(*pmd) || pmd_trans_huge(*pmd) || pmd_devmap(*pmd))
 		return __pmd_trans_huge_lock(pmd, vma);
 	else
 static inline spinlock_t *pud_trans_huge_lock(pud_t *pud,
 		struct vm_area_struct *vma)
 {
-	VM_BUG_ON_VMA(!rwsem_is_locked(&vma->vm_mm->mmap_sem), vma);
 	if (pud_trans_huge(*pud) || pud_devmap(*pud))
 		return __pud_trans_huge_lock(pud, vma);
 	else

include/linux/hugetlb.h+116−24

@@ -105,8 +105,7 @@ void move_hugetlb_state(struct page oldpage, struct page newpage, int reason); · 104 unmodified lines
105	void free_huge_page(struct page *page);	105	void free_huge_page(struct page *page);
106	void hugetlb_fix_reserve_counts(struct inode *inode);	106	void hugetlb_fix_reserve_counts(struct inode *inode);
107	extern struct mutex *hugetlb_fault_mutex_table;	107	extern struct mutex *hugetlb_fault_mutex_table;
108	u32 hugetlb_fault_mutex_hash(struct hstate h, struct address_space mapping,	108	u32 hugetlb_fault_mutex_hash(struct address_space *mapping, pgoff_t idx);
109	pgoff_t idx, unsigned long address);
110		109
111	pte_t huge_pmd_share(struct mm_struct mm, unsigned long addr, pud_t *pud);	110	pte_t huge_pmd_share(struct mm_struct mm, unsigned long addr, pud_t *pud);
112		111
@@ -164,38 +163,130 @@ static inline void adjust_range_if_pmd_sharing_possible( · 51 unmodified lines
164	{	163	{
165	}	164	}
166		165
167	#define follow_hugetlb_page(m,v,p,vs,a,b,i,w,n) ({ BUG(); 0; })	166	static inline long follow_hugetlb_page(struct mm_struct *mm,
168	#define follow_huge_addr(mm, addr, write) ERR_PTR(-EINVAL)	167	struct vm_area_struct vma, struct page *pages,
169	#define copy_hugetlb_page_range(src, dst, vma) ({ BUG(); 0; })	168	struct vm_area_struct *vmas, unsigned long position,
		169	unsigned long *nr_pages, long i, unsigned int flags,
		170	int *nonblocking)
		171	{
		172	BUG();
		173	return 0;
		174	}
		175
		176	static inline struct page follow_huge_addr(struct mm_struct mm,
		177	unsigned long address, int write)
		178	{
		179	return ERR_PTR(-EINVAL);
		180	}
		181
		182	static inline int copy_hugetlb_page_range(struct mm_struct *dst,
		183	struct mm_struct src, struct vm_area_struct vma)
		184	{
		185	BUG();
		186	return 0;
		187	}
		188
170	static inline void hugetlb_report_meminfo(struct seq_file *m)	189	static inline void hugetlb_report_meminfo(struct seq_file *m)
171	{	190	{
172	}	191	}
173	#define hugetlb_report_node_meminfo(n, buf) 0	192
		193	static inline int hugetlb_report_node_meminfo(int nid, char *buf)
		194	{
		195	return 0;
		196	}
		197
174	static inline void hugetlb_show_meminfo(void)	198	static inline void hugetlb_show_meminfo(void)
175	{	199	{
176	}	200	}
177	#define follow_huge_pd(vma, addr, hpd, flags, pdshift) NULL	201
178	#define follow_huge_pmd(mm, addr, pmd, flags) NULL	202	static inline struct page follow_huge_pd(struct vm_area_struct vma,
179	#define follow_huge_pud(mm, addr, pud, flags) NULL	203	unsigned long address, hugepd_t hpd, int flags,
180	#define follow_huge_pgd(mm, addr, pgd, flags) NULL	204	int pdshift)
181	#define prepare_hugepage_range(file, addr, len) (-EINVAL)	205	{
182	#define pmd_huge(x) 0	206	return NULL;
183	#define pud_huge(x) 0	207	}
184	#define is_hugepage_only_range(mm, addr, len) 0	208
185	#define hugetlb_free_pgd_range(tlb, addr, end, floor, ceiling) ({BUG(); 0; })	209	static inline struct page follow_huge_pmd(struct mm_struct mm,
186	#define hugetlb_mcopy_atomic_pte(dst_mm, dst_pte, dst_vma, dst_addr, \	210	unsigned long address, pmd_t *pmd, int flags)
187	src_addr, pagep) ({ BUG(); 0; })	211	{
188	#define huge_pte_offset(mm, address, sz) 0	212	return NULL;
		213	}
		214
		215	static inline struct page follow_huge_pud(struct mm_struct mm,
		216	unsigned long address, pud_t *pud, int flags)
		217	{
		218	return NULL;
		219	}
		220
		221	static inline struct page follow_huge_pgd(struct mm_struct mm,
		222	unsigned long address, pgd_t *pgd, int flags)
		223	{
		224	return NULL;
		225	}
		226
		227	static inline int prepare_hugepage_range(struct file *file,
		228	unsigned long addr, unsigned long len)
		229	{
		230	return -EINVAL;
		231	}
		232
		233	static inline int pmd_huge(pmd_t pmd)
		234	{
		235	return 0;
		236	}
		237
		238	static inline int pud_huge(pud_t pud)
		239	{
		240	return 0;
		241	}
		242
		243	static inline int is_hugepage_only_range(struct mm_struct *mm,
		244	unsigned long addr, unsigned long len)
		245	{
		246	return 0;
		247	}
		248
		249	static inline void hugetlb_free_pgd_range(struct mmu_gather *tlb,
		250	unsigned long addr, unsigned long end,
		251	unsigned long floor, unsigned long ceiling)
		252	{
		253	BUG();
		254	}
		255
		256	static inline int hugetlb_mcopy_atomic_pte(struct mm_struct *dst_mm,
		257	pte_t *dst_pte,
		258	struct vm_area_struct *dst_vma,
		259	unsigned long dst_addr,
		260	unsigned long src_addr,
		261	struct page **pagep)
		262	{
		263	BUG();
		264	return 0;
		265	}
		266
		267	static inline pte_t huge_pte_offset(struct mm_struct mm, unsigned long addr,
		268	unsigned long sz)
		269	{
		270	return NULL;
		271	}
189		272
190	static inline bool isolate_huge_page(struct page page, struct list_head list)	273	static inline bool isolate_huge_page(struct page page, struct list_head list)
191	{	274	{
192	return false;	275	return false;
193	}	276	}
194	#define putback_active_hugepage(p) do {} while (0)
195	#define move_hugetlb_state(old, new, reason) do {} while (0)
196		277
197	static inline unsigned long hugetlb_change_protection(struct vm_area_struct *vma,	278	static inline void putback_active_hugepage(struct page *page)
198	unsigned long address, unsigned long end, pgprot_t newprot)	279	{
		280	}
		281
		282	static inline void move_hugetlb_state(struct page *oldpage,
		283	struct page *newpage, int reason)
		284	{
		285	}
		286
		287	static inline unsigned long hugetlb_change_protection(
		288	struct vm_area_struct *vma, unsigned long address,
		289	unsigned long end, pgprot_t newprot)
199	{	290	{
200	return 0;	291	return 0;
201	}	292	}
@@ -213,9 +304,10 @@ static inline void __unmap_hugepage_range(struct mmu_gather *tlb, · 11 unmodified lines
213	{	304	{
214	BUG();	305	BUG();
215	}	306	}
		307
216	static inline vm_fault_t hugetlb_fault(struct mm_struct *mm,	308	static inline vm_fault_t hugetlb_fault(struct mm_struct *mm,
217	struct vm_area_struct *vma, unsigned long address,	309	struct vm_area_struct *vma, unsigned long address,
218	unsigned int flags)	310	unsigned int flags)
219	{	311	{
220	BUG();	312	BUG();
221	return 0;	313	return 0;

include/linux/hyperv.h+26−5

@@ -182,19 +182,21 @@ static inline u32 hv_get_avail_to_write_percent( · 181 unmodified lines
182	* 2 . 4 (Windows 8)	182	* 2 . 4 (Windows 8)
183	* 3 . 0 (Windows 8 R2)	183	* 3 . 0 (Windows 8 R2)
184	* 4 . 0 (Windows 10)	184	* 4 . 0 (Windows 10)
		185	* 4 . 1 (Windows 10 RS3)
185	* 5 . 0 (Newer Windows 10)	186	* 5 . 0 (Newer Windows 10)
		187	* 5 . 1 (Windows 10 RS4)
		188	* 5 . 2 (Windows Server 2019, RS5)
186	*/	189	*/
187		190
188	#define VERSION_WS2008 ((0 << 16) \| (13))	191	#define VERSION_WS2008 ((0 << 16) \| (13))
189	#define VERSION_WIN7 ((1 << 16) \| (1))	192	#define VERSION_WIN7 ((1 << 16) \| (1))
190	#define VERSION_WIN8 ((2 << 16) \| (4))	193	#define VERSION_WIN8 ((2 << 16) \| (4))
191	#define VERSION_WIN8_1 ((3 << 16) \| (0))	194	#define VERSION_WIN8_1 ((3 << 16) \| (0))
192	#define VERSION_WIN10 ((4 << 16) \| (0))	195	#define VERSION_WIN10 ((4 << 16) \| (0))
		196	#define VERSION_WIN10_V4_1 ((4 << 16) \| (1))
193	#define VERSION_WIN10_V5 ((5 << 16) \| (0))	197	#define VERSION_WIN10_V5 ((5 << 16) \| (0))
194		198	#define VERSION_WIN10_V5_1 ((5 << 16) \| (1))
195	#define VERSION_INVAL -1	199	#define VERSION_WIN10_V5_2 ((5 << 16) \| (2))
196
197	#define VERSION_CURRENT VERSION_WIN10_V5
198		200
199	/* Make maximum size of pipe payload of 16K */	201	/* Make maximum size of pipe payload of 16K */
200	#define MAX_PIPE_DATA_PAYLOAD (sizeof(u8) * 16384)	202	#define MAX_PIPE_DATA_PAYLOAD (sizeof(u8) * 16384)
@@ -932,6 +934,21 @@ struct vmbus_channel { · 731 unmodified lines
932	* full outbound ring buffer.	934	* full outbound ring buffer.
933	*/	935	*/
934	u64 out_full_first;	936	u64 out_full_first;
		937
		938	/* enabling/disabling fuzz testing on the channel (default is false)*/
		939	bool fuzz_testing_state;
		940
		941	/*
		942	* Interrupt delay will delay the guest from emptying the ring buffer
		943	* for a specific amount of time. The delay is in microseconds and will
		944	* be between 1 to a maximum of 1000, its default is 0 (no delay).
		945	* The Message delay will delay guest reading on a per message basis
		946	* in microseconds between 1 to 1000 with the default being 0
		947	* (no delay).
		948	*/
		949	u32 fuzz_testing_interrupt_delay;
		950	u32 fuzz_testing_message_delay;
		951
935	};	952	};
936		953
937	static inline bool is_hvsock_channel(const struct vmbus_channel *c)	954	static inline bool is_hvsock_channel(const struct vmbus_channel *c)
@@ -1180,6 +1197,10 @@ struct hv_device { · 242 unmodified lines
1180		1197
1181	struct vmbus_channel *channel;	1198	struct vmbus_channel *channel;
1182	struct kset *channels_kset;	1199	struct kset *channels_kset;
		1200
		1201	/* place holder to keep track of the dir for hv device in debugfs */
		1202	struct dentry *debug_dir;
		1203
1183	};	1204	};
1184		1205
1185		1206

include/linux/i2c-pxa.h+0−18

@@ -1,18 +0,0 @@
1	/* SPDX-License-Identifier: GPL-2.0 */
2	#ifndef _LINUX_I2C_ALGO_PXA_H
3	#define _LINUX_I2C_ALGO_PXA_H
4
5	typedef enum i2c_slave_event_e {
6	I2C_SLAVE_EVENT_START_READ,
7	I2C_SLAVE_EVENT_START_WRITE,
8	I2C_SLAVE_EVENT_STOP
9	} i2c_slave_event_t;
10
11	struct i2c_slave_client {
12	void *data;
13	void (event)(void ptr, i2c_slave_event_t event);
14	int (read) (void ptr);
15	void (write)(void ptr, unsigned int val);
16	};
17
18	#endif /* _LINUX_I2C_ALGO_PXA_H */

include/linux/i2c.h+20−11

  *	generic enough to hide second-sourcing and compatible revisions.
  * @adapter: manages the bus segment hosting this I2C device
  * @dev: Driver model device node for the slave.
+ * @init_irq: IRQ that was set at initialization
  * @irq: indicates the IRQ generated by this device (if any)
  * @detected: member of an i2c_driver.clients list or i2c-core's
  *	userspace_devices list
  * a default probing method is used.
  */
 extern struct i2c_client *
+i2c_new_scanned_device(struct i2c_adapter *adap,
+		       struct i2c_board_info *info,
+		       unsigned short const *addr_list,
+		       int (*probe)(struct i2c_adapter *adap, unsigned short addr));
+extern struct i2c_client *
 i2c_new_probed_device(struct i2c_adapter *adap,
-		      struct i2c_board_info *info,
+		       struct i2c_board_info *info,
-		      unsigned short const *addr_list,
+		       unsigned short const *addr_list,
-		      int (*probe)(struct i2c_adapter *adap, unsigned short addr));
+		       int (*probe)(struct i2c_adapter *adap, unsigned short addr));
 /* Common custom probe functions */
 extern int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr);
-/* For devices that use several addresses, use i2c_new_dummy() to make
- * client handles for the extra addresses.
- */
-extern struct i2c_client *
-i2c_new_dummy(struct i2c_adapter *adap, u16 address);
 extern struct i2c_client *
 i2c_new_dummy_device(struct i2c_adapter *adapter, u16 address);
  * @scl_int_delay_ns: time IP core additionally needs to setup SCL in ns
  * @sda_fall_ns: time SDA signal takes to fall in ns; t(f) in the I2C specification
  * @sda_hold_ns: time IP core additionally needs to hold SDA in ns
+ * @digital_filter_width_ns: width in ns of spikes on i2c lines that the IP core
+ *	digital filter can filter out
+ * @analog_filter_cutoff_freq_hz: threshold frequency for the low pass IP core
+ *	analog filter
  */
 struct i2c_timings {
 	u32 bus_freq_hz;
 	u32 scl_int_delay_ns;
 	u32 sda_fall_ns;
 	u32 sda_hold_ns;
+	u32 digital_filter_width_ns;
+	u32 analog_filter_cutoff_freq_hz;
 };
 /**
 #define i2c_add_driver(driver) \
 	i2c_register_driver(THIS_MODULE, driver)
-extern struct i2c_client *i2c_use_client(struct i2c_client *client);
+static inline bool i2c_client_has_driver(struct i2c_client *client)
-extern void i2c_release_client(struct i2c_client *client);
+{
+	return !IS_ERR_OR_NULL(client) && client->dev.driver;
+}
 /* call the i2c_client->command() of all attached clients with
  * the given arguments */

include/linux/icmp.h+15−0

@@ -20,4 +20,19 @@ static inline struct icmphdr icmp_hdr(const struct sk_buff skb) · 19 unmodified lines
20	{	20	{
21	return (struct icmphdr *)skb_transport_header(skb);	21	return (struct icmphdr *)skb_transport_header(skb);
22	}	22	}
		23
		24	static inline bool icmp_is_err(int type)
		25	{
		26	switch (type) {
		27	case ICMP_DEST_UNREACH:
		28	case ICMP_SOURCE_QUENCH:
		29	case ICMP_REDIRECT:
		30	case ICMP_TIME_EXCEEDED:
		31	case ICMP_PARAMETERPROB:
		32	return true;
		33	}
		34
		35	return false;
		36	}
		37
23	#endif /* _LINUX_ICMP_H */	38	#endif /* _LINUX_ICMP_H */

include/linux/icmpv6.h+14−0

@@ -46,4 +46,18 @@ extern void icmpv6_flow_init(struct sock *sk, · 45 unmodified lines
46	const struct in6_addr *saddr,	46	const struct in6_addr *saddr,
47	const struct in6_addr *daddr,	47	const struct in6_addr *daddr,
48	int oif);	48	int oif);
		49
		50	static inline bool icmpv6_is_err(int type)
		51	{
		52	switch (type) {
		53	case ICMPV6_DEST_UNREACH:
		54	case ICMPV6_PKT_TOOBIG:
		55	case ICMPV6_TIME_EXCEED:
		56	case ICMPV6_PARAMPROB:
		57	return true;
		58	}
		59
		60	return false;
		61	}
		62
49	#endif	63	#endif

include/linux/iio/adc/ad_sigma_delta.h+2−0

@@ -119,6 +119,8 @@ int ad_sd_reset(struct ad_sigma_delta *sigma_delta, · 118 unmodified lines
119		119
120	int ad_sigma_delta_single_conversion(struct iio_dev *indio_dev,	120	int ad_sigma_delta_single_conversion(struct iio_dev *indio_dev,
121	const struct iio_chan_spec chan, int val);	121	const struct iio_chan_spec chan, int val);
		122	int ad_sd_calibrate(struct ad_sigma_delta *sigma_delta,
		123	unsigned int mode, unsigned int channel);
122	int ad_sd_calibrate_all(struct ad_sigma_delta *sigma_delta,	124	int ad_sd_calibrate_all(struct ad_sigma_delta *sigma_delta,
123	const struct ad_sd_calib_data *cd, unsigned int n);	125	const struct ad_sd_calib_data *cd, unsigned int n);
124	int ad_sd_init(struct ad_sigma_delta sigma_delta, struct iio_dev indio_dev,	126	int ad_sd_init(struct ad_sigma_delta sigma_delta, struct iio_dev indio_dev,

include/linux/iio/iio.h+2−0

  *			attributes
  * @chan_attr_group:	[INTERN] group for all attrs in base directory
  * @name:		[DRIVER] name of the device.
+ * @label:              [DRIVER] unique name to identify which device this is
  * @info:		[DRIVER] callbacks and constant info from driver
  * @clock_id:		[INTERN] timestamping clock posix identifier
  * @info_exist_lock:	[INTERN] lock to prevent use during removal
 	struct list_head		channel_attr_list;
 	struct attribute_group		chan_attr_group;
 	const char			*name;
+	const char			*label;
 	const struct iio_info		*info;
 	clockid_t			clock_id;
 	struct mutex			info_exist_lock;

include/linux/iio/imu/adis.h+4−2

 	int ret;
 	ret = adis_read_reg(adis, reg, &tmp, 2);
-	*val = tmp;
+	if (ret == 0)
+		*val = tmp;
 	return ret;
 }
 	int ret;
 	ret = adis_read_reg(adis, reg, &tmp, 4);
-	*val = tmp;
+	if (ret == 0)
+		*val = tmp;
 	return ret;
 }

include/linux/ima.h+2−1

@@ -29,7 +29,8 @@ extern void ima_kexec_cmdline(const void *buf, int size); · 28 unmodified lines
29	extern void ima_add_kexec_buffer(struct kimage *image);	29	extern void ima_add_kexec_buffer(struct kimage *image);
30	#endif	30	#endif
31		31
32	#if (defined(CONFIG_X86) && defined(CONFIG_EFI)) \|\| defined(CONFIG_S390)	32	#if (defined(CONFIG_X86) && defined(CONFIG_EFI)) \|\| defined(CONFIG_S390) \
		33	\|\| defined(CONFIG_PPC_SECURE_BOOT)
33	extern bool arch_ima_get_secureboot(void);	34	extern bool arch_ima_get_secureboot(void);
34	extern const char * const *arch_get_ima_policy(void);	35	extern const char * const *arch_get_ima_policy(void);
35	#else	36	#else

include/linux/initrd.h+2−0

@@ -28,3 +28,5 @@ extern unsigned int real_root_dev; · 27 unmodified lines
28		28
29	extern char __initramfs_start[];	29	extern char __initramfs_start[];
30	extern unsigned long __initramfs_size;	30	extern unsigned long __initramfs_size;
		31
		32	void console_on_rootfs(void);

include/linux/input.h+1−0

@@ -383,6 +383,7 @@ int input_setup_polling(struct input_dev *dev, · 382 unmodified lines
383	void input_set_poll_interval(struct input_dev *dev, unsigned int interval);	383	void input_set_poll_interval(struct input_dev *dev, unsigned int interval);
384	void input_set_min_poll_interval(struct input_dev *dev, unsigned int interval);	384	void input_set_min_poll_interval(struct input_dev *dev, unsigned int interval);
385	void input_set_max_poll_interval(struct input_dev *dev, unsigned int interval);	385	void input_set_max_poll_interval(struct input_dev *dev, unsigned int interval);
		386	int input_get_poll_interval(struct input_dev *dev);
386		387
387	int __must_check input_register_handler(struct input_handler *);	388	int __must_check input_register_handler(struct input_handler *);
388	void input_unregister_handler(struct input_handler *);	389	void input_unregister_handler(struct input_handler *);

include/linux/interrupt.h+14−2

 		     irq_handler_t thread_fn,
 		     unsigned long flags, const char *name, void *dev);
+/**
+ * request_irq - Add a handler for an interrupt line
+ * @irq:	The interrupt line to allocate
+ * @handler:	Function to be called when the IRQ occurs.
+ *		Primary handler for threaded interrupts
+ *		If NULL, the default primary handler is installed
+ * @flags:	Handling flags
+ * @name:	Name of the device generating this interrupt
+ * @dev:	A cookie passed to the handler function
+ *
+ * This call allocates an interrupt and establishes a handler; see
+ * the documentation for request_threaded_irq() for details.
+ */
 static inline int __must_check
 request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
 	    const char *name, void *dev)
 	IRQ_POLL_SOFTIRQ,
 	TASKLET_SOFTIRQ,
 	SCHED_SOFTIRQ,
-	HRTIMER_SOFTIRQ, /* Unused, but kept as tools rely on the
+	HRTIMER_SOFTIRQ,
-			    numbering. Sigh! */
 	RCU_SOFTIRQ,    /* Preferable RCU should always be the last softirq */
 	NR_SOFTIRQS

include/linux/io-pgtable.h+1−1

@@ -102,7 +102,7 @@ struct io_pgtable_cfg { · 101 unmodified lines
102	struct {	102	struct {
103	u64 ttbr[2];	103	u64 ttbr[2];
104	u64 tcr;	104	u64 tcr;
105	u64 mair[2];	105	u64 mair;
106	} arm_lpae_s1_cfg;	106	} arm_lpae_s1_cfg;
107		107
108	struct {	108	struct {

include/linux/io.h+2−0

@@ -64,6 +64,8 @@ static inline void devm_ioport_unmap(struct device dev, void __iomem addr) · 63 unmodified lines
64		64
65	void __iomem devm_ioremap(struct device dev, resource_size_t offset,	65	void __iomem devm_ioremap(struct device dev, resource_size_t offset,
66	resource_size_t size);	66	resource_size_t size);
		67	void __iomem devm_ioremap_uc(struct device dev, resource_size_t offset,
		68	resource_size_t size);
67	void __iomem devm_ioremap_nocache(struct device dev, resource_size_t offset,	69	void __iomem devm_ioremap_nocache(struct device dev, resource_size_t offset,
68	resource_size_t size);	70	resource_size_t size);
69	void __iomem devm_ioremap_wc(struct device dev, resource_size_t offset,	71	void __iomem devm_ioremap_wc(struct device dev, resource_size_t offset,

include/linux/ioasid.h+76−0

@@ -0,0 +1,76 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef __LINUX_IOASID_H
	3	#define __LINUX_IOASID_H
	4
	5	#include <linux/types.h>
	6	#include <linux/errno.h>
	7
	8	#define INVALID_IOASID ((ioasid_t)-1)
	9	typedef unsigned int ioasid_t;
	10	typedef ioasid_t (ioasid_alloc_fn_t)(ioasid_t min, ioasid_t max, void data);
	11	typedef void (ioasid_free_fn_t)(ioasid_t ioasid, void data);
	12
	13	struct ioasid_set {
	14	int dummy;
	15	};
	16
	17	/**
	18	* struct ioasid_allocator_ops - IOASID allocator helper functions and data
	19	*
	20	* @alloc: helper function to allocate IOASID
	21	* @free: helper function to free IOASID
	22	* @list: for tracking ops that share helper functions but not data
	23	* @pdata: data belong to the allocator, provided when calling alloc()
	24	*/
	25	struct ioasid_allocator_ops {
	26	ioasid_alloc_fn_t alloc;
	27	ioasid_free_fn_t free;
	28	struct list_head list;
	29	void *pdata;
	30	};
	31
	32	#define DECLARE_IOASID_SET(name) struct ioasid_set name = { 0 }
	33
	34	#if IS_ENABLED(CONFIG_IOASID)
	35	ioasid_t ioasid_alloc(struct ioasid_set *set, ioasid_t min, ioasid_t max,
	36	void *private);
	37	void ioasid_free(ioasid_t ioasid);
	38	void ioasid_find(struct ioasid_set set, ioasid_t ioasid,
	39	bool (getter)(void ));
	40	int ioasid_register_allocator(struct ioasid_allocator_ops *allocator);
	41	void ioasid_unregister_allocator(struct ioasid_allocator_ops *allocator);
	42	int ioasid_set_data(ioasid_t ioasid, void *data);
	43
	44	#else /* !CONFIG_IOASID */
	45	static inline ioasid_t ioasid_alloc(struct ioasid_set *set, ioasid_t min,
	46	ioasid_t max, void *private)
	47	{
	48	return INVALID_IOASID;
	49	}
	50
	51	static inline void ioasid_free(ioasid_t ioasid)
	52	{
	53	}
	54
	55	static inline void ioasid_find(struct ioasid_set set, ioasid_t ioasid,
	56	bool (getter)(void ))
	57	{
	58	return NULL;
	59	}
	60
	61	static inline int ioasid_register_allocator(struct ioasid_allocator_ops *allocator)
	62	{
	63	return -ENOTSUPP;
	64	}
	65
	66	static inline void ioasid_unregister_allocator(struct ioasid_allocator_ops *allocator)
	67	{
	68	}
	69
	70	static inline int ioasid_set_data(ioasid_t ioasid, void *data)
	71	{
	72	return -ENOTSUPP;
	73	}
	74
	75	#endif /* CONFIG_IOASID */
	76	#endif /* __LINUX_IOASID_H */

include/linux/iomap.h+95−34

 #include <linux/atomic.h>
 #include <linux/bitmap.h>
+#include <linux/blk_types.h>
 #include <linux/mm.h>
 #include <linux/types.h>
 #include <linux/mm_types.h>
 struct address_space;
 struct fiemap_extent_info;
 struct inode;
+struct iomap_writepage_ctx;
 struct iov_iter;
 struct kiocb;
 struct page;
 /*
  * Types of block ranges for iomap mappings:
  */
-#define IOMAP_HOLE	0x01	/* no blocks allocated, need allocation */
+#define IOMAP_HOLE	0	/* no blocks allocated, need allocation */
-#define IOMAP_DELALLOC	0x02	/* delayed allocation blocks */
+#define IOMAP_DELALLOC	1	/* delayed allocation blocks */
-#define IOMAP_MAPPED	0x03	/* blocks allocated at @addr */
+#define IOMAP_MAPPED	2	/* blocks allocated at @addr */
-#define IOMAP_UNWRITTEN	0x04	/* blocks allocated at @addr in unwritten state */
+#define IOMAP_UNWRITTEN	3	/* blocks allocated at @addr in unwritten state */
-#define IOMAP_INLINE	0x05	/* data inline in the inode */
+#define IOMAP_INLINE	4	/* data inline in the inode */
 /*
- * Flags for all iomap mappings:
+ * Flags reported by the file system from iomap_begin:
+ *
+ * IOMAP_F_NEW indicates that the blocks have been newly allocated and need
+ * zeroing for areas that no data is copied to.
  *
  * IOMAP_F_DIRTY indicates the inode has uncommitted metadata needed to access
  * written data and requires fdatasync to commit them to persistent storage.
+ * This needs to take into account metadata changes that *may* be made at IO
+ * completion, such as file size updates from direct IO.
+ *
+ * IOMAP_F_SHARED indicates that the blocks are shared, and will need to be
+ * unshared as part a write.
+ *
+ * IOMAP_F_MERGED indicates that the iomap contains the merge of multiple block
+ * mappings.
+ *
+ * IOMAP_F_BUFFER_HEAD indicates that the file system requires the use of
+ * buffer heads for this mapping.
  */
-#define IOMAP_F_NEW		0x01	/* blocks have been newly allocated */
+#define IOMAP_F_NEW		0x01
-#define IOMAP_F_DIRTY		0x02	/* uncommitted metadata */
+#define IOMAP_F_DIRTY		0x02
-#define IOMAP_F_BUFFER_HEAD	0x04	/* file system requires buffer heads */
+#define IOMAP_F_SHARED		0x04
-#define IOMAP_F_SIZE_CHANGED	0x08	/* file size has changed */
+#define IOMAP_F_MERGED		0x08
+#define IOMAP_F_BUFFER_HEAD	0x10
 /*
- * Flags that only need to be reported for IOMAP_REPORT requests:
+ * Flags set by the core iomap code during operations:
+ *
+ * IOMAP_F_SIZE_CHANGED indicates to the iomap_end method that the file size
+ * has changed as the result of this write operation.
  */
-#define IOMAP_F_MERGED		0x10	/* contains multiple blocks/extents */
+#define IOMAP_F_SIZE_CHANGED	0x100
-#define IOMAP_F_SHARED		0x20	/* block shared with another file */
 /*
  * Flags from 0x1000 up are for file system specific usage:
 	 * The actual length is returned in iomap->length.
 	 */
 	int (*iomap_begin)(struct inode *inode, loff_t pos, loff_t length,
-			unsigned flags, struct iomap *iomap);
+			unsigned flags, struct iomap *iomap,
+			struct iomap *srcmap);
 	/*
 	 * Commit and/or unreserve space previous allocated using iomap_begin.
  * Main iomap iterator function.
  */
 typedef loff_t (*iomap_actor_t)(struct inode *inode, loff_t pos, loff_t len,
-		void *data, struct iomap *iomap);
+		void *data, struct iomap *iomap, struct iomap *srcmap);
 loff_t iomap_apply(struct inode *inode, loff_t pos, loff_t length,
 		unsigned flags, const struct iomap_ops *ops, void *data,
 		iomap_actor_t actor);
-/*
- * Structure allocate for each page when block size < PAGE_SIZE to track
- * sub-page uptodate status and I/O completions.
- */
-struct iomap_page {
-	atomic_t		read_count;
-	atomic_t		write_count;
-	DECLARE_BITMAP(uptodate, PAGE_SIZE / 512);
-};
-static inline struct iomap_page *to_iomap_page(struct page *page)
-{
-	if (page_has_private(page))
-		return (struct iomap_page *)page_private(page);
-	return NULL;
-}
 ssize_t iomap_file_buffered_write(struct kiocb *iocb, struct iov_iter *from,
 		const struct iomap_ops *ops);
 int iomap_readpage(struct page *page, const struct iomap_ops *ops);
 #else
 #define iomap_migrate_page NULL
 #endif
-int iomap_file_dirty(struct inode *inode, loff_t pos, loff_t len,
+int iomap_file_unshare(struct inode *inode, loff_t pos, loff_t len,
 		const struct iomap_ops *ops);
 int iomap_zero_range(struct inode *inode, loff_t pos, loff_t len,
 		bool *did_zero, const struct iomap_ops *ops);
 sector_t iomap_bmap(struct address_space *mapping, sector_t bno,
 		const struct iomap_ops *ops);
+/*
+ * Structure for writeback I/O completions.
+ */
+struct iomap_ioend {
+	struct list_head	io_list;	/* next ioend in chain */
+	u16			io_type;
+	u16			io_flags;	/* IOMAP_F_* */
+	struct inode		*io_inode;	/* file being written to */
+	size_t			io_size;	/* size of the extent */
+	loff_t			io_offset;	/* offset in the file */
+	void			*io_private;	/* file system private data */
+	struct bio		*io_bio;	/* bio being built */
+	struct bio		io_inline_bio;	/* MUST BE LAST! */
+};
+struct iomap_writeback_ops {
+	/*
+	 * Required, maps the blocks so that writeback can be performed on
+	 * the range starting at offset.
+	 */
+	int (*map_blocks)(struct iomap_writepage_ctx *wpc, struct inode *inode,
+				loff_t offset);
+	/*
+	 * Optional, allows the file systems to perform actions just before
+	 * submitting the bio and/or override the bio end_io handler for complex
+	 * operations like copy on write extent manipulation or unwritten extent
+	 * conversions.
+	 */
+	int (*prepare_ioend)(struct iomap_ioend *ioend, int status);
+	/*
+	 * Optional, allows the file system to discard state on a page where
+	 * we failed to submit any I/O.
+	 */
+	void (*discard_page)(struct page *page);
+};
+struct iomap_writepage_ctx {
+	struct iomap		iomap;
+	struct iomap_ioend	*ioend;
+	const struct iomap_writeback_ops *ops;
+};
+void iomap_finish_ioends(struct iomap_ioend *ioend, int error);
+void iomap_ioend_try_merge(struct iomap_ioend *ioend,
+		struct list_head *more_ioends,
+		void (*merge_private)(struct iomap_ioend *ioend,
+				struct iomap_ioend *next));
+void iomap_sort_ioends(struct list_head *ioend_list);
+int iomap_writepage(struct page *page, struct writeback_control *wbc,
+		struct iomap_writepage_ctx *wpc,
+		const struct iomap_writeback_ops *ops);
+int iomap_writepages(struct address_space *mapping,
+		struct writeback_control *wbc, struct iomap_writepage_ctx *wpc,
+		const struct iomap_writeback_ops *ops);
 /*
  * Flags for direct I/O ->end_io:
  */
 };
 ssize_t iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,
-		const struct iomap_ops *ops, const struct iomap_dio_ops *dops);
+		const struct iomap_ops *ops, const struct iomap_dio_ops *dops,
+		bool wait_for_completion);
 int iomap_dio_iopoll(struct kiocb *kiocb, bool spin);
 #ifdef CONFIG_SWAP

include/linux/iommu.h+60−5

 #include <linux/errno.h>
 #include <linux/err.h>
 #include <linux/of.h>
+#include <linux/ioasid.h>
 #include <uapi/linux/iommu.h>
 #define IOMMU_READ	(1 << 0)
  */
 #define IOMMU_PRIV	(1 << 5)
 /*
- * Non-coherent masters on few Qualcomm SoCs can use this page protection flag
+ * Non-coherent masters can use this page protection flag to set cacheable
- * to set correct cacheability attributes to use an outer level of cache -
+ * memory attributes for only a transparent outer level of cache, also known as
- * last level cache, aka system cache.
+ * the last-level or system cache.
  */
-#define IOMMU_QCOM_SYS_CACHE	(1 << 6)
+#define IOMMU_SYS_CACHE_ONLY	(1 << 6)
 struct iommu_ops;
 struct iommu_group;
  * @sva_unbind: Unbind process address space from device
  * @sva_get_pasid: Get PASID associated to a SVA handle
  * @page_response: handle page request response
+ * @cache_invalidate: invalidate translation caches
  * @pgsize_bitmap: bitmap of all possible supported page sizes
+ * @sva_bind_gpasid: bind guest pasid and mm
+ * @sva_unbind_gpasid: unbind guest pasid and mm
  */
 struct iommu_ops {
 	bool (*capable)(enum iommu_cap);
 	int (*attach_dev)(struct iommu_domain *domain, struct device *dev);
 	void (*detach_dev)(struct iommu_domain *domain, struct device *dev);
 	int (*map)(struct iommu_domain *domain, unsigned long iova,
-		   phys_addr_t paddr, size_t size, int prot);
+		   phys_addr_t paddr, size_t size, int prot, gfp_t gfp);
 	size_t (*unmap)(struct iommu_domain *domain, unsigned long iova,
 		     size_t size, struct iommu_iotlb_gather *iotlb_gather);
 	void (*flush_iotlb_all)(struct iommu_domain *domain);
 	int (*page_response)(struct device *dev,
 			     struct iommu_fault_event *evt,
 			     struct iommu_page_response *msg);
+	int (*cache_invalidate)(struct iommu_domain *domain, struct device *dev,
+				struct iommu_cache_invalidate_info *inv_info);
+	int (*sva_bind_gpasid)(struct iommu_domain *domain,
+			struct device *dev, struct iommu_gpasid_bind_data *data);
+	int (*sva_unbind_gpasid)(struct device *dev, int pasid);
 	unsigned long pgsize_bitmap;
 };
 			       struct device *dev);
 extern void iommu_detach_device(struct iommu_domain *domain,
 				struct device *dev);
+extern int iommu_cache_invalidate(struct iommu_domain *domain,
+				  struct device *dev,
+				  struct iommu_cache_invalidate_info *inv_info);
+extern int iommu_sva_bind_gpasid(struct iommu_domain *domain,
+		struct device *dev, struct iommu_gpasid_bind_data *data);
+extern int iommu_sva_unbind_gpasid(struct iommu_domain *domain,
+				struct device *dev, ioasid_t pasid);
 extern struct iommu_domain *iommu_get_domain_for_dev(struct device *dev);
 extern struct iommu_domain *iommu_get_dma_domain(struct device *dev);
 extern int iommu_map(struct iommu_domain *domain, unsigned long iova,
 		     phys_addr_t paddr, size_t size, int prot);
+extern int iommu_map_atomic(struct iommu_domain *domain, unsigned long iova,
+			    phys_addr_t paddr, size_t size, int prot);
 extern size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova,
 			  size_t size);
 extern size_t iommu_unmap_fast(struct iommu_domain *domain,
 			       struct iommu_iotlb_gather *iotlb_gather);
 extern size_t iommu_map_sg(struct iommu_domain *domain, unsigned long iova,
 			   struct scatterlist *sg,unsigned int nents, int prot);
+extern size_t iommu_map_sg_atomic(struct iommu_domain *domain,
+				  unsigned long iova, struct scatterlist *sg,
+				  unsigned int nents, int prot);
 extern phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova);
 extern void iommu_set_fault_handler(struct iommu_domain *domain,
 			iommu_fault_handler_t handler, void *token);
 	return -ENODEV;
 }
+static inline int iommu_map_atomic(struct iommu_domain *domain,
+				   unsigned long iova, phys_addr_t paddr,
+				   size_t size, int prot)
+{
+	return -ENODEV;
+}
 static inline size_t iommu_unmap(struct iommu_domain *domain,
 				 unsigned long iova, size_t size)
 {
 	return 0;
 }
+static inline size_t iommu_map_sg_atomic(struct iommu_domain *domain,
+				  unsigned long iova, struct scatterlist *sg,
+				  unsigned int nents, int prot)
+{
+	return 0;
+}
 static inline void iommu_flush_tlb_all(struct iommu_domain *domain)
 {
 }
 	return IOMMU_PASID_INVALID;
 }
+static inline int
+iommu_cache_invalidate(struct iommu_domain *domain,
+		       struct device *dev,
+		       struct iommu_cache_invalidate_info *inv_info)
+{
+	return -ENODEV;
+}
+static inline int iommu_sva_bind_gpasid(struct iommu_domain *domain,
+				struct device *dev, struct iommu_gpasid_bind_data *data)
+{
+	return -ENODEV;
+}
+static inline int iommu_sva_unbind_gpasid(struct iommu_domain *domain,
+					   struct device *dev, int pasid)
+{
+	return -ENODEV;
+}
 #endif /* CONFIG_IOMMU_API */
 #ifdef CONFIG_IOMMU_DEBUGFS

include/linux/ioport.h+1−0

@@ -134,6 +134,7 @@ enum { · 133 unmodified lines
134	IORES_DESC_PERSISTENT_MEMORY_LEGACY = 5,	134	IORES_DESC_PERSISTENT_MEMORY_LEGACY = 5,
135	IORES_DESC_DEVICE_PRIVATE_MEMORY = 6,	135	IORES_DESC_DEVICE_PRIVATE_MEMORY = 6,
136	IORES_DESC_RESERVED = 7,	136	IORES_DESC_RESERVED = 7,
		137	IORES_DESC_SOFT_RESERVED = 8,
137	};	138	};
138		139
139	/*	140	/*

include/linux/ipmi_smi.h+8−4

  * is called, and the lower layer must get the interface from that
  * call.
  */
-int ipmi_register_smi(const struct ipmi_smi_handlers *handlers,
+int ipmi_add_smi(struct module            *owner,
-		      void                     *send_info,
+		 const struct ipmi_smi_handlers *handlers,
-		      struct device            *dev,
+		 void                     *send_info,
-		      unsigned char            slave_addr);
+		 struct device            *dev,
+		 unsigned char            slave_addr);
+#define ipmi_register_smi(handlers, send_info, dev, slave_addr) \
+	ipmi_add_smi(THIS_MODULE, handlers, send_info, dev, slave_addr)
 /*
  * Remove a low-level interface from the IPMI driver.  This will

include/linux/irq.h+6−0

 #ifdef	CONFIG_IRQ_DOMAIN_HIERARCHY
 extern void handle_fasteoi_ack_irq(struct irq_desc *desc);
 extern void handle_fasteoi_mask_irq(struct irq_desc *desc);
+extern int irq_chip_set_parent_state(struct irq_data *data,
+				     enum irqchip_irq_state which,
+				     bool val);
+extern int irq_chip_get_parent_state(struct irq_data *data,
+				     enum irqchip_irq_state which,
+				     bool *state);
 extern void irq_chip_enable_parent(struct irq_data *data);
 extern void irq_chip_disable_parent(struct irq_data *data);
 extern void irq_chip_ack_parent(struct irq_data *data);

include/linux/irq_work.h+7−3

 #define IRQ_WORK_CLAIMED	(IRQ_WORK_PENDING | IRQ_WORK_BUSY)
 struct irq_work {
-	unsigned long flags;
+	atomic_t flags;
 	struct llist_node llnode;
 	void (*func)(struct irq_work *);
 };
 static inline
 void init_irq_work(struct irq_work *work, void (*func)(struct irq_work *))
 {
-	work->flags = 0;
+	atomic_set(&work->flags, 0);
 	work->func = func;
 }
-#define DEFINE_IRQ_WORK(name, _f) struct irq_work name = { .func = (_f), }
+#define DEFINE_IRQ_WORK(name, _f) struct irq_work name = {	\
+		.flags = ATOMIC_INIT(0),			\
+		.func  = (_f)					\
+}
 bool irq_work_queue(struct irq_work *work);
 bool irq_work_queue_on(struct irq_work *work, int cpu);

include/linux/irqchip/arm-gic-v3.h+4−2

 #define GITS_TYPER_PLPIS		(1UL << 0)
 #define GITS_TYPER_VLPIS		(1UL << 1)
 #define GITS_TYPER_ITT_ENTRY_SIZE_SHIFT	4
-#define GITS_TYPER_ITT_ENTRY_SIZE(r)	((((r) >> GITS_TYPER_ITT_ENTRY_SIZE_SHIFT) & 0xf) + 1)
+#define GITS_TYPER_ITT_ENTRY_SIZE	GENMASK_ULL(7, 4)
 #define GITS_TYPER_IDBITS_SHIFT		8
 #define GITS_TYPER_DEVBITS_SHIFT	13
-#define GITS_TYPER_DEVBITS(r)		((((r) >> GITS_TYPER_DEVBITS_SHIFT) & 0x1f) + 1)
+#define GITS_TYPER_DEVBITS		GENMASK_ULL(17, 13)
 #define GITS_TYPER_PTA			(1UL << 19)
 #define GITS_TYPER_HCC_SHIFT		24
 #define GITS_TYPER_HCC(r)		(((r) >> GITS_TYPER_HCC_SHIFT) & 0xff)
 #define ICC_CTLR_EL1_EOImode_MASK	(1 << ICC_CTLR_EL1_EOImode_SHIFT)
 #define ICC_CTLR_EL1_CBPR_SHIFT		0
 #define ICC_CTLR_EL1_CBPR_MASK		(1 << ICC_CTLR_EL1_CBPR_SHIFT)
+#define ICC_CTLR_EL1_PMHE_SHIFT		6
+#define ICC_CTLR_EL1_PMHE_MASK		(1 << ICC_CTLR_EL1_PMHE_SHIFT)
 #define ICC_CTLR_EL1_PRI_BITS_SHIFT	8
 #define ICC_CTLR_EL1_PRI_BITS_MASK	(0x7 << ICC_CTLR_EL1_PRI_BITS_SHIFT)
 #define ICC_CTLR_EL1_ID_BITS_SHIFT	11

include/linux/irqchip/arm-gic-v4.h+4−0

 struct its_vpe {
 	struct page 		*vpt_page;
 	struct its_vm		*its_vm;
+	/* per-vPE VLPI tracking */
+	atomic_t		vlpi_count;
 	/* Doorbell interrupt */
 	int			irq;
 	irq_hw_number_t		vpe_db_lpi;
+	/* VPE resident */
+	bool			resident;
 	/* VPE proxy mapping */
 	int			vpe_proxy_event;
 	/*

include/linux/irqchip/ingenic.h+0−14

@@ -1,14 +0,0 @@
1	/* SPDX-License-Identifier: GPL-2.0-or-later */
2	/*
3	* Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
4	*/
5
6	#ifndef __LINUX_IRQCHIP_INGENIC_H__
7	#define __LINUX_IRQCHIP_INGENIC_H__
8
9	#include <linux/irq.h>
10
11	extern void ingenic_intc_irq_suspend(struct irq_data *data);
12	extern void ingenic_intc_irq_resume(struct irq_data *data);
13
14	#endif

include/linux/irqdomain.h+1−0

@@ -83,6 +83,7 @@ enum irq_domain_bus_token { · 82 unmodified lines
83	DOMAIN_BUS_IPI,	83	DOMAIN_BUS_IPI,
84	DOMAIN_BUS_FSL_MC_MSI,	84	DOMAIN_BUS_FSL_MC_MSI,
85	DOMAIN_BUS_TI_SCI_INTA_MSI,	85	DOMAIN_BUS_TI_SCI_INTA_MSI,
		86	DOMAIN_BUS_WAKEUP,
86	};	87	};
87		88
88	/**	89	/**

include/linux/jbd2.h+58−62

 	BH_Revoked,		/* Has been revoked from the log */
 	BH_RevokeValid,		/* Revoked flag is valid */
 	BH_JBDDirty,		/* Is dirty but journaled */
-	BH_State,		/* Pins most journal_head state */
 	BH_JournalHead,		/* Pins bh->b_private and jh->b_bh */
 	BH_Shadow,		/* IO on shadow buffer is running */
 	BH_Verified,		/* Metadata block has been verified ok */
 	return bh->b_private;
 }
-static inline void jbd_lock_bh_state(struct buffer_head *bh)
-{
-	bit_spin_lock(BH_State, &bh->b_state);
-}
-static inline int jbd_trylock_bh_state(struct buffer_head *bh)
-{
-	return bit_spin_trylock(BH_State, &bh->b_state);
-}
-static inline int jbd_is_locked_bh_state(struct buffer_head *bh)
-{
-	return bit_spin_is_locked(BH_State, &bh->b_state);
-}
-static inline void jbd_unlock_bh_state(struct buffer_head *bh)
-{
-	bit_spin_unlock(BH_State, &bh->b_state);
-}
 static inline void jbd_lock_bh_journal_head(struct buffer_head *bh)
 {
 	bit_spin_lock(BH_JournalHead, &bh->b_state);
  * @h_transaction: Which compound transaction is this update a part of?
  * @h_journal: Which journal handle belongs to - used iff h_reserved set.
  * @h_rsv_handle: Handle reserved for finishing the logical operation.
- * @h_buffer_credits: Number of remaining buffers we are allowed to dirty.
+ * @h_total_credits: Number of remaining buffers we are allowed to add to
+ *	journal. These are dirty buffers and revoke descriptor blocks.
+ * @h_revoke_credits: Number of remaining revoke records available for handle
  * @h_ref: Reference count on this handle.
  * @h_err: Field for caller's use to track errors through large fs operations.
  * @h_sync: Flag for sync-on-close.
  * @h_type: For handle statistics.
  * @h_line_no: For handle statistics.
  * @h_start_jiffies: Handle Start time.
- * @h_requested_credits: Holds @h_buffer_credits after handle is started.
+ * @h_requested_credits: Holds @h_total_credits after handle is started.
+ * @h_revoke_credits_requested: Holds @h_revoke_credits after handle is started.
  * @saved_alloc_context: Saved context while transaction is open.
  **/
 	};
 	handle_t		*h_rsv_handle;
-	int			h_buffer_credits;
+	int			h_total_credits;
+	int			h_revoke_credits;
+	int			h_revoke_credits_requested;
 	int			h_ref;
 	int			h_err;
  *      ->jbd_lock_bh_journal_head()	(This is "innermost")
  *
  *    j_state_lock
- *    ->jbd_lock_bh_state()
+ *    ->b_state_lock
  *
- *    jbd_lock_bh_state()
+ *    b_state_lock
  *    ->j_list_lock
  *
  *    j_state_lock
 	atomic_t		t_updates;
 	/*
-	 * Number of buffers reserved for use by all handles in this transaction
+	 * Number of blocks reserved for this transaction in the journal.
-	 * handle but not yet modified. [none]
+	 * This is including all credits reserved when starting transaction
+	 * handles as well as all journal descriptor blocks needed for this
+	 * transaction. [none]
 	 */
 	atomic_t		t_outstanding_credits;
+	/*
+	 * Number of revoke records for this transaction added by already
+	 * stopped handles. [none]
+	 */
+	atomic_t		t_outstanding_revokes;
+	/*
+	 * How many handles used this transaction? [none]
+	 */
+	atomic_t		t_handle_count;
 	/*
 	 * Forward and backward links for the circular list of all transactions
 	 * awaiting checkpoint. [j_list_lock]
 	 */
 	ktime_t			t_start_time;
-	/*
-	 * How many handles used this transaction? [none]
-	 */
-	atomic_t		t_handle_count;
 	/*
 	 * This transaction is being forced and some process is
 	 * waiting for it to finish.
 	 */
 	int			j_max_transaction_buffers;
+	/**
+	 * @j_revoke_records_per_block:
+	 *
+	 * Number of revoke records that fit in one descriptor block.
+	 */
+	int			j_revoke_records_per_block;
 	/**
 	 * @j_commit_interval:
 	 *
 #define jbd2_might_wait_for_commit(j) \
 	do { \
 		rwsem_acquire(&j->j_trans_commit_map, 0, 0, _THIS_IP_); \
-		rwsem_release(&j->j_trans_commit_map, 1, _THIS_IP_); \
+		rwsem_release(&j->j_trans_commit_map, _THIS_IP_); \
 	} while (0)
 /* journal feature predicate functions */
 /* Filing buffers */
 extern void jbd2_journal_unfile_buffer(journal_t *, struct journal_head *);
-extern void __jbd2_journal_refile_buffer(struct journal_head *);
+extern bool __jbd2_journal_refile_buffer(struct journal_head *);
 extern void jbd2_journal_refile_buffer(journal_t *, struct journal_head *);
 extern void __jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
 extern void __journal_free_buffer(struct journal_head *bh);
 extern handle_t *jbd2_journal_start(journal_t *, int nblocks);
 extern handle_t *jbd2__journal_start(journal_t *, int blocks, int rsv_blocks,
-				     gfp_t gfp_mask, unsigned int type,
+				     int revoke_records, gfp_t gfp_mask,
-				     unsigned int line_no);
+				     unsigned int type, unsigned int line_no);
 extern int	 jbd2_journal_restart(handle_t *, int nblocks);
-extern int	 jbd2__journal_restart(handle_t *, int nblocks, gfp_t gfp_mask);
+extern int	 jbd2__journal_restart(handle_t *, int nblocks,
+				       int revoke_records, gfp_t gfp_mask);
 extern int	 jbd2_journal_start_reserved(handle_t *handle,
 				unsigned int type, unsigned int line_no);
 extern void	 jbd2_journal_free_reserved(handle_t *handle);
-extern int	 jbd2_journal_extend (handle_t *, int nblocks);
+extern int	 jbd2_journal_extend(handle_t *handle, int nblocks,
+				     int revoke_records);
 extern int	 jbd2_journal_get_write_access(handle_t *, struct buffer_head *);
 extern int	 jbd2_journal_get_create_access (handle_t *, struct buffer_head *);
 extern int	 jbd2_journal_get_undo_access(handle_t *, struct buffer_head *);
 	return journal->j_chksum_driver != NULL;
 }
-/*
- * We reserve t_outstanding_credits >> JBD2_CONTROL_BLOCKS_SHIFT for
- * transaction control blocks.
- */
-#define JBD2_CONTROL_BLOCKS_SHIFT 5
-/*
- * Return the minimum number of blocks which must be free in the journal
- * before a new transaction may be started.  Must be called under j_state_lock.
- */
-static inline int jbd2_space_needed(journal_t *journal)
-{
-	int nblocks = journal->j_max_transaction_buffers;
-	return nblocks + (nblocks >> JBD2_CONTROL_BLOCKS_SHIFT);
-}
 /*
  * Return number of free blocks in the log. Must be called under j_state_lock.
  */
 static inline unsigned long jbd2_log_space_left(journal_t *journal)
 {
 	/* Allow for rounding errors */
-	unsigned long free = journal->j_free - 32;
+	long free = journal->j_free - 32;
 	if (journal->j_committing_transaction) {
-		unsigned long committing = atomic_read(&journal->
+		free -= atomic_read(&journal->
-			j_committing_transaction->t_outstanding_credits);
+                        j_committing_transaction->t_outstanding_credits);
-		/* Transaction + control blocks */
-		free -= committing + (committing >> JBD2_CONTROL_BLOCKS_SHIFT);
 	}
-	return free;
+	return max_t(long, free, 0);
 }
 /*
 	return tid;
 }
+static inline int jbd2_handle_buffer_credits(handle_t *handle)
+{
+	journal_t *journal;
+	if (!handle->h_reserved)
+		journal = handle->h_transaction->t_journal;
+	else
+		journal = handle->h_journal;
+	return handle->h_total_credits -
+		DIV_ROUND_UP(handle->h_revoke_credits_requested,
+			     journal->j_revoke_records_per_block);
+}
 #ifdef __KERNEL__
 #define buffer_trace_init(bh)	do {} while (0)

include/linux/journal-head.h+14−7

 #ifndef JOURNAL_HEAD_H_INCLUDED
 #define JOURNAL_HEAD_H_INCLUDED
+#include <linux/spinlock.h>
 typedef unsigned int		tid_t;		/* Unique transaction ID */
 typedef struct transaction_s	transaction_t;	/* Compound transaction type */
 	 */
 	struct buffer_head *b_bh;
+	/*
+	 * Protect the buffer head state
+	 */
+	spinlock_t b_state_lock;
 	/*
 	 * Reference count - see description in journal.c
 	 * [jbd_lock_bh_journal_head()]
 	int b_jcount;
 	/*
-	 * Journalling list for this buffer [jbd_lock_bh_state()]
+	 * Journalling list for this buffer [b_state_lock]
 	 * NOTE: We *cannot* combine this with b_modified into a bitfield
 	 * as gcc would then (which the C standard allows but which is
 	 * very unuseful) make 64-bit accesses to the bitfield and clobber
 	/*
 	 * This flag signals the buffer has been modified by
 	 * the currently running transaction
-	 * [jbd_lock_bh_state()]
+	 * [b_state_lock]
 	 */
 	unsigned b_modified;
 	/*
 	 * Copy of the buffer data frozen for writing to the log.
-	 * [jbd_lock_bh_state()]
+	 * [b_state_lock]
 	 */
 	char *b_frozen_data;
 	/*
 	 * Pointer to a saved copy of the buffer containing no uncommitted
 	 * deallocation references, so that allocations can avoid overwriting
-	 * uncommitted deletes. [jbd_lock_bh_state()]
+	 * uncommitted deletes. [b_state_lock]
 	 */
 	char *b_committed_data;
 	 * metadata: either the running transaction or the committing
 	 * transaction (if there is one).  Only applies to buffers on a
 	 * transaction's data or metadata journaling list.
-	 * [j_list_lock] [jbd_lock_bh_state()]
+	 * [j_list_lock] [b_state_lock]
 	 * Either of these locks is enough for reading, both are needed for
 	 * changes.
 	 */
 	 * Pointer to the running compound transaction which is currently
 	 * modifying the buffer's metadata, if there was already a transaction
 	 * committing it when the new transaction touched it.
-	 * [t_list_lock] [jbd_lock_bh_state()]
+	 * [t_list_lock] [b_state_lock]
 	 */
 	transaction_t *b_next_transaction;
 	/*
 	 * Doubly-linked list of buffers on a transaction's data, metadata or
-	 * forget queue. [t_list_lock] [jbd_lock_bh_state()]
+	 * forget queue. [t_list_lock] [b_state_lock]
 	 */
 	struct journal_head *b_tnext, *b_tprev;

include/linux/kasan.h+34−0

@@ -70,8 +70,18 @@ struct kasan_cache { · 69 unmodified lines
70	int free_meta_offset;	70	int free_meta_offset;
71	};	71	};
72		72
		73	/*
		74	* These functions provide a special case to support backing module
		75	* allocations with real shadow memory. With KASAN vmalloc, the special
		76	* case is unnecessary, as the work is handled in the generic case.
		77	*/
		78	#ifndef CONFIG_KASAN_VMALLOC
73	int kasan_module_alloc(void *addr, size_t size);	79	int kasan_module_alloc(void *addr, size_t size);
74	void kasan_free_shadow(const struct vm_struct *vm);	80	void kasan_free_shadow(const struct vm_struct *vm);
		81	#else
		82	static inline int kasan_module_alloc(void *addr, size_t size) { return 0; }
		83	static inline void kasan_free_shadow(const struct vm_struct *vm) {}
		84	#endif
75		85
76	int kasan_add_zero_shadow(void *start, unsigned long size);	86	int kasan_add_zero_shadow(void *start, unsigned long size);
77	void kasan_remove_zero_shadow(void *start, unsigned long size);	87	void kasan_remove_zero_shadow(void *start, unsigned long size);
@@ -194,4 +204,28 @@ static inline void kasan_reset_tag(const void addr) · 116 unmodified lines
194		204
195	#endif /* CONFIG_KASAN_SW_TAGS */	205	#endif /* CONFIG_KASAN_SW_TAGS */
196		206
		207	#ifdef CONFIG_KASAN_VMALLOC
		208	int kasan_populate_vmalloc(unsigned long addr, unsigned long size);
		209	void kasan_poison_vmalloc(const void *start, unsigned long size);
		210	void kasan_unpoison_vmalloc(const void *start, unsigned long size);
		211	void kasan_release_vmalloc(unsigned long start, unsigned long end,
		212	unsigned long free_region_start,
		213	unsigned long free_region_end);
		214	#else
		215	static inline int kasan_populate_vmalloc(unsigned long start,
		216	unsigned long size)
		217	{
		218	return 0;
		219	}
		220
		221	static inline void kasan_poison_vmalloc(const void *start, unsigned long size)
		222	{ }
		223	static inline void kasan_unpoison_vmalloc(const void *start, unsigned long size)
		224	{ }
		225	static inline void kasan_release_vmalloc(unsigned long start,
		226	unsigned long end,
		227	unsigned long free_region_start,
		228	unsigned long free_region_end) {}
		229	#endif
		230
197	#endif /* LINUX_KASAN_H */	231	#endif /* LINUX_KASAN_H */

include/linux/kcov.h+23−0

@@ -37,12 +37,35 @@ do { \ · 36 unmodified lines
37	(t)->kcov_mode &= ~KCOV_IN_CTXSW; \	37	(t)->kcov_mode &= ~KCOV_IN_CTXSW; \
38	} while (0)	38	} while (0)
39		39
		40	/* See Documentation/dev-tools/kcov.rst for usage details. */
		41	void kcov_remote_start(u64 handle);
		42	void kcov_remote_stop(void);
		43	u64 kcov_common_handle(void);
		44
		45	static inline void kcov_remote_start_common(u64 id)
		46	{
		47	kcov_remote_start(kcov_remote_handle(KCOV_SUBSYSTEM_COMMON, id));
		48	}
		49
		50	static inline void kcov_remote_start_usb(u64 id)
		51	{
		52	kcov_remote_start(kcov_remote_handle(KCOV_SUBSYSTEM_USB, id));
		53	}
		54
40	#else	55	#else
41		56
42	static inline void kcov_task_init(struct task_struct *t) {}	57	static inline void kcov_task_init(struct task_struct *t) {}
43	static inline void kcov_task_exit(struct task_struct *t) {}	58	static inline void kcov_task_exit(struct task_struct *t) {}
44	static inline void kcov_prepare_switch(struct task_struct *t) {}	59	static inline void kcov_prepare_switch(struct task_struct *t) {}
45	static inline void kcov_finish_switch(struct task_struct *t) {}	60	static inline void kcov_finish_switch(struct task_struct *t) {}
		61	static inline void kcov_remote_start(u64 handle) {}
		62	static inline void kcov_remote_stop(void) {}
		63	static inline u64 kcov_common_handle(void)
		64	{
		65	return 0;
		66	}
		67	static inline void kcov_remote_start_common(u64 id) {}
		68	static inline void kcov_remote_start_usb(u64 id) {}
46		69
47	#endif /* CONFIG_KCOV */	70	#endif /* CONFIG_KCOV */
48	#endif /* _LINUX_KCOV_H */	71	#endif /* _LINUX_KCOV_H */

include/linux/kernel.h+14−12

 void do_exit(long error_code) __noreturn;
 void complete_and_exit(struct completion *, long) __noreturn;
-#ifdef CONFIG_ARCH_HAS_REFCOUNT
-void refcount_error_report(struct pt_regs *regs, const char *err);
-#else
-static inline void refcount_error_report(struct pt_regs *regs, const char *err)
-{ }
-#endif
 /* Internal, do not use. */
 int __must_check _kstrtoul(const char *s, unsigned int base, unsigned long *res);
 int __must_check _kstrtol(const char *s, unsigned int base, long *res);
  * @res: Where to write the result of the conversion on success.
  *
  * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
- * Used as a replacement for the obsolete simple_strtoull. Return code must
+ * Used as a replacement for the simple_strtoull. Return code must be checked.
- * be checked.
 */
 static inline int __must_check kstrtoul(const char *s, unsigned int base, unsigned long *res)
 {
  * @res: Where to write the result of the conversion on success.
  *
  * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
- * Used as a replacement for the obsolete simple_strtoull. Return code must
+ * Used as a replacement for the simple_strtoull. Return code must be checked.
- * be checked.
  */
 static inline int __must_check kstrtol(const char *s, unsigned int base, long *res)
 {
 	return kstrtoint_from_user(s, count, base, res);
 }
-/* Obsolete, do not use.  Use kstrto<foo> instead */
+/*
+ * Use kstrto<foo> instead.
+ *
+ * NOTE: simple_strto<foo> does not check for the range overflow and,
+ *	 depending on the input, may give interesting results.
+ *
+ * Use these functions if and only if you cannot use kstrto<foo>, because
+ * the conversion ends on the first non-digit character, which may be far
+ * beyond the supported range. It might be useful to parse the strings like
+ * 10x50 or 12:21 without altering original string or temporary buffer in use.
+ * Keep in mind above caveat.
+ */
 extern unsigned long simple_strtoul(const char *,char **,unsigned int);
 extern long simple_strtol(const char *,char **,unsigned int);

include/linux/kernel_stat.h+18−0

@@ -78,6 +78,24 @@ static inline unsigned int kstat_cpu_irqs_sum(unsigned int cpu) · 77 unmodified lines
78	return kstat_cpu(cpu).irqs_sum;	78	return kstat_cpu(cpu).irqs_sum;
79	}	79	}
80		80
		81	#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
		82	extern u64 kcpustat_field(struct kernel_cpustat *kcpustat,
		83	enum cpu_usage_stat usage, int cpu);
		84	extern void kcpustat_cpu_fetch(struct kernel_cpustat *dst, int cpu);
		85	#else
		86	static inline u64 kcpustat_field(struct kernel_cpustat *kcpustat,
		87	enum cpu_usage_stat usage, int cpu)
		88	{
		89	return kcpustat->cpustat[usage];
		90	}
		91
		92	static inline void kcpustat_cpu_fetch(struct kernel_cpustat *dst, int cpu)
		93	{
		94	*dst = kcpustat_cpu(cpu);
		95	}
		96
		97	#endif
		98
81	extern void account_user_time(struct task_struct *, u64);	99	extern void account_user_time(struct task_struct *, u64);
82	extern void account_guest_time(struct task_struct *, u64);	100	extern void account_guest_time(struct task_struct *, u64);
83	extern void account_system_time(struct task_struct *, int, u64);	101	extern void account_system_time(struct task_struct *, int, u64);

include/linux/kernfs.h+38−19

 	struct kernfs_node	*notify_next;	/* for kernfs_notify() */
 };
-/* represent a kernfs node */
-union kernfs_node_id {
-	struct {
-		/*
-		 * blktrace will export this struct as a simplified 'struct
-		 * fid' (which is a big data struction), so userspace can use
-		 * it to find kernfs node. The layout must match the first two
-		 * fields of 'struct fid' exactly.
-		 */
-		u32		ino;
-		u32		generation;
-	};
-	u64			id;
-};
 /*
  * kernfs_node - the building block of kernfs hierarchy.  Each and every
  * kernfs node is represented by single kernfs_node.  Most fields are
 	void			*priv;
-	union kernfs_node_id	id;
+	/*
+	 * 64bit unique ID.  On 64bit ino setups, id is the ino.  On 32bit,
+	 * the low 32bits are ino and upper generation.
+	 */
+	u64			id;
 	unsigned short		flags;
 	umode_t			mode;
 	struct kernfs_iattrs	*iattr;
 	/* private fields, do not use outside kernfs proper */
 	struct idr		ino_idr;
-	u32			next_generation;
+	u32			last_id_lowbits;
+	u32			id_highbits;
 	struct kernfs_syscall_ops *syscall_ops;
 	/* list of kernfs_super_info of this root, protected by kernfs_mutex */
 	return kn->flags & KERNFS_TYPE_MASK;
 }
+static inline ino_t kernfs_id_ino(u64 id)
+{
+	/* id is ino if ino_t is 64bit; otherwise, low 32bits */
+	if (sizeof(ino_t) >= sizeof(u64))
+		return id;
+	else
+		return (u32)id;
+}
+static inline u32 kernfs_id_gen(u64 id)
+{
+	/* gen is fixed at 1 if ino_t is 64bit; otherwise, high 32bits */
+	if (sizeof(ino_t) >= sizeof(u64))
+		return 1;
+	else
+		return id >> 32;
+}
+static inline ino_t kernfs_ino(struct kernfs_node *kn)
+{
+	return kernfs_id_ino(kn->id);
+}
+static inline ino_t kernfs_gen(struct kernfs_node *kn)
+{
+	return kernfs_id_gen(kn->id);
+}
 /**
  * kernfs_enable_ns - enable namespace under a directory
  * @kn: directory of interest, should be empty
 void kernfs_init(void);
-struct kernfs_node *kernfs_get_node_by_id(struct kernfs_root *root,
+struct kernfs_node *kernfs_find_and_get_node_by_id(struct kernfs_root *root,
-	const union kernfs_node_id *id);
+						   u64 id);
 #else	/* CONFIG_KERNFS */
 static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn)

include/linux/kvm_host.h+31−12

 #define KVM_REQUEST_ARCH_BASE     8
 #define KVM_ARCH_REQ_FLAGS(nr, flags) ({ \
-	BUILD_BUG_ON((unsigned)(nr) >= (FIELD_SIZEOF(struct kvm_vcpu, requests) * 8) - KVM_REQUEST_ARCH_BASE); \
+	BUILD_BUG_ON((unsigned)(nr) >= (sizeof_field(struct kvm_vcpu, requests) * 8) - KVM_REQUEST_ARCH_BASE); \
 	(unsigned)(((nr) + KVM_REQUEST_ARCH_BASE) | (flags)); \
 })
 #define KVM_ARCH_REQ(nr)           KVM_ARCH_REQ_FLAGS(nr, 0)
 	struct preempt_notifier preempt_notifier;
 #endif
 	int cpu;
-	int vcpu_id;
+	int vcpu_id; /* id given by userspace at creation */
+	int vcpu_idx; /* index in kvm->vcpus array */
 	int srcu_idx;
 	int mode;
 	u64 requests;
 	struct mutex mutex;
 	struct kvm_run *run;
-	int guest_xcr0_loaded;
 	struct swait_queue_head wq;
 	struct pid __rcu *pid;
 	int sigset_active;
 static inline int kvm_vcpu_get_idx(struct kvm_vcpu *vcpu)
 {
-	struct kvm_vcpu *tmp;
+	return vcpu->vcpu_idx;
-	int idx;
-	kvm_for_each_vcpu(idx, tmp, vcpu->kvm)
-		if (tmp == vcpu)
-			return idx;
-	BUG();
 }
 #define kvm_for_each_memslot(memslot, slots)	\
 void kvm_get_kvm(struct kvm *kvm);
 void kvm_put_kvm(struct kvm *kvm);
+void kvm_put_kvm_no_destroy(struct kvm *kvm);
 static inline struct kvm_memslots *__kvm_memslots(struct kvm *kvm, int as_id)
 {
 				  unsigned long len);
 int kvm_gfn_to_hva_cache_init(struct kvm *kvm, struct gfn_to_hva_cache *ghc,
 			      gpa_t gpa, unsigned long len);
+#define __kvm_put_guest(kvm, gfn, offset, value, type)			\
+({									\
+	unsigned long __addr = gfn_to_hva(kvm, gfn);			\
+	type __user *__uaddr = (type __user *)(__addr + offset);	\
+	int __ret = -EFAULT;						\
+									\
+	if (!kvm_is_error_hva(__addr))					\
+		__ret = put_user(value, __uaddr);			\
+	if (!__ret)							\
+		mark_page_dirty(kvm, gfn);				\
+	__ret;								\
+})
+#define kvm_put_guest(kvm, gpa, value, type)				\
+({									\
+	gpa_t __gpa = gpa;						\
+	struct kvm *__kvm = kvm;					\
+	__kvm_put_guest(__kvm, __gpa >> PAGE_SHIFT,			\
+			offset_in_page(__gpa), (value), type);		\
+})
 int kvm_clear_guest_page(struct kvm *kvm, gfn_t gfn, int offset, int len);
 int kvm_clear_guest(struct kvm *kvm, gpa_t gpa, unsigned long len);
 struct kvm_memory_slot *gfn_to_memslot(struct kvm *kvm, gfn_t gfn);
 bool kvm_make_vcpus_request_mask(struct kvm *kvm, unsigned int req,
 				 unsigned long *vcpu_bitmap, cpumask_var_t tmp);
 bool kvm_make_all_cpus_request(struct kvm *kvm, unsigned int req);
+bool kvm_make_cpus_request_mask(struct kvm *kvm, unsigned int req,
+				unsigned long *vcpu_bitmap);
 long kvm_arch_dev_ioctl(struct file *filp,
 			unsigned int ioctl, unsigned long arg);
 extern unsigned int halt_poll_ns_shrink;
 struct kvm_device {
-	struct kvm_device_ops *ops;
+	const struct kvm_device_ops *ops;
 	struct kvm *kvm;
 	void *private;
 	struct list_head vm_node;
 void kvm_device_get(struct kvm_device *dev);
 void kvm_device_put(struct kvm_device *dev);
 struct kvm_device *kvm_device_from_filp(struct file *filp);
-int kvm_register_device_ops(struct kvm_device_ops *ops, u32 type);
+int kvm_register_device_ops(const struct kvm_device_ops *ops, u32 type);
 void kvm_unregister_device_ops(u32 type);
 extern struct kvm_device_ops kvm_mpic_ops;

include/linux/kvm_types.h+2−0

@@ -35,6 +35,8 @@ typedef unsigned long gva_t; · 34 unmodified lines
35	typedef u64 gpa_t;	35	typedef u64 gpa_t;
36	typedef u64 gfn_t;	36	typedef u64 gfn_t;
37		37
		38	#define GPA_INVALID (~(gpa_t)0)
		39
38	typedef unsigned long hva_t;	40	typedef unsigned long hva_t;
39	typedef u64 hpa_t;	41	typedef u64 hpa_t;
40	typedef u64 hfn_t;	42	typedef u64 hfn_t;

include/linux/led-class-flash.h+28−13

  *
  * Returns: 0 on success or negative error value on failure
  */
-extern int led_classdev_flash_register_ext(struct device *parent,
+int led_classdev_flash_register_ext(struct device *parent,
-					struct led_classdev_flash *fled_cdev,
+				    struct led_classdev_flash *fled_cdev,
-					struct led_init_data *init_data);
+				    struct led_init_data *init_data);
-#define led_classdev_flash_register(parent, fled_cdev)		\
+static inline int led_classdev_flash_register(struct device *parent,
-	led_classdev_flash_register_ext(parent, fled_cdev, NULL)
+					   struct led_classdev_flash *fled_cdev)
+{
+	return led_classdev_flash_register_ext(parent, fled_cdev, NULL);
+}
 /**
  * led_classdev_flash_unregister - unregisters an object of led_classdev class
  *
  * Unregister a previously registered via led_classdev_flash_register object
  */
-extern void led_classdev_flash_unregister(struct led_classdev_flash *fled_cdev);
+void led_classdev_flash_unregister(struct led_classdev_flash *fled_cdev);
+int devm_led_classdev_flash_register_ext(struct device *parent,
+				     struct led_classdev_flash *fled_cdev,
+				     struct led_init_data *init_data);
+static inline int devm_led_classdev_flash_register(struct device *parent,
+				     struct led_classdev_flash *fled_cdev)
+{
+	return devm_led_classdev_flash_register_ext(parent, fled_cdev, NULL);
+}
+void devm_led_classdev_flash_unregister(struct device *parent,
+					struct led_classdev_flash *fled_cdev);
 /**
  * led_set_flash_strobe - setup flash strobe
  *
  * Returns: 0 on success or negative error value on failure
  */
-extern int led_set_flash_brightness(struct led_classdev_flash *fled_cdev,
+int led_set_flash_brightness(struct led_classdev_flash *fled_cdev,
-					u32 brightness);
+			     u32 brightness);
 /**
  * led_update_flash_brightness - update flash LED brightness
  *
  * Returns: 0 on success or negative error value on failure
  */
-extern int led_update_flash_brightness(struct led_classdev_flash *fled_cdev);
+int led_update_flash_brightness(struct led_classdev_flash *fled_cdev);
 /**
  * led_set_flash_timeout - set flash LED timeout
  *
  * Returns: 0 on success or negative error value on failure
  */
-extern int led_set_flash_timeout(struct led_classdev_flash *fled_cdev,
+int led_set_flash_timeout(struct led_classdev_flash *fled_cdev, u32 timeout);
-					u32 timeout);
 /**
  * led_get_flash_fault - get the flash LED fault
  *
  * Returns: 0 on success or negative error value on failure
  */
-extern int led_get_flash_fault(struct led_classdev_flash *fled_cdev,
+int led_get_flash_fault(struct led_classdev_flash *fled_cdev, u32 *fault);
-					u32 *fault);
 #endif	/* __LINUX_FLASH_LEDS_H_INCLUDED */

include/linux/leds.h+44−56

  *
  * Returns: 0 on success or negative error value on failure
  */
-extern int led_classdev_register_ext(struct device *parent,
+int led_classdev_register_ext(struct device *parent,
 				     struct led_classdev *led_cdev,
 				     struct led_init_data *init_data);
 	return led_classdev_register_ext(parent, led_cdev, NULL);
 }
-extern int devm_led_classdev_register_ext(struct device *parent,
+int devm_led_classdev_register_ext(struct device *parent,
 					  struct led_classdev *led_cdev,
 					  struct led_init_data *init_data);
 {
 	return devm_led_classdev_register_ext(parent, led_cdev, NULL);
 }
-extern void led_classdev_unregister(struct led_classdev *led_cdev);
+void led_classdev_unregister(struct led_classdev *led_cdev);
-extern void devm_led_classdev_unregister(struct device *parent,
+void devm_led_classdev_unregister(struct device *parent,
-					 struct led_classdev *led_cdev);
+				  struct led_classdev *led_cdev);
-extern void led_classdev_suspend(struct led_classdev *led_cdev);
+void led_classdev_suspend(struct led_classdev *led_cdev);
-extern void led_classdev_resume(struct led_classdev *led_cdev);
+void led_classdev_resume(struct led_classdev *led_cdev);
 /**
  * led_blink_set - set blinking with software fallback
  * led_cdev->brightness_set() will not stop the blinking,
  * use led_classdev_brightness_set() instead.
  */
-extern void led_blink_set(struct led_classdev *led_cdev,
+void led_blink_set(struct led_classdev *led_cdev, unsigned long *delay_on,
-			  unsigned long *delay_on,
+		   unsigned long *delay_off);
-			  unsigned long *delay_off);
 /**
  * led_blink_set_oneshot - do a oneshot software blink
  * @led_cdev: the LED to start blinking
  * If invert is set, led blinks for delay_off first, then for
  * delay_on and leave the led on after the on-off cycle.
  */
-extern void led_blink_set_oneshot(struct led_classdev *led_cdev,
+void led_blink_set_oneshot(struct led_classdev *led_cdev,
-				  unsigned long *delay_on,
+			   unsigned long *delay_on, unsigned long *delay_off,
-				  unsigned long *delay_off,
+			   int invert);
-				  int invert);
 /**
  * led_set_brightness - set LED brightness
  * @led_cdev: the LED to set
  * software blink timer that implements blinking when the
  * hardware doesn't. This function is guaranteed not to sleep.
  */
-extern void led_set_brightness(struct led_classdev *led_cdev,
+void led_set_brightness(struct led_classdev *led_cdev,
-			       enum led_brightness brightness);
+			enum led_brightness brightness);
 /**
  * led_set_brightness_sync - set LED brightness synchronously
  *
  * Returns: 0 on success or negative error value on failure
  */
-extern int led_set_brightness_sync(struct led_classdev *led_cdev,
+int led_set_brightness_sync(struct led_classdev *led_cdev,
-				   enum led_brightness value);
+			    enum led_brightness value);
 /**
  * led_update_brightness - update LED brightness
  *
  * Returns: 0 on success or negative error value on failure
  */
-extern int led_update_brightness(struct led_classdev *led_cdev);
+int led_update_brightness(struct led_classdev *led_cdev);
 /**
  * led_get_default_pattern - return default pattern
  * Return:    Allocated array of integers with default pattern from device tree
  *            or NULL.  Caller is responsible for kfree().
  */
-extern u32 *led_get_default_pattern(struct led_classdev *led_cdev,
+u32 *led_get_default_pattern(struct led_classdev *led_cdev, unsigned int *size);
-				    unsigned int *size);
 /**
  * led_sysfs_disable - disable LED sysfs interface
  *
  * Disable the led_cdev's sysfs interface.
  */
-extern void led_sysfs_disable(struct led_classdev *led_cdev);
+void led_sysfs_disable(struct led_classdev *led_cdev);
 /**
  * led_sysfs_enable - enable LED sysfs interface
  *
  * Enable the led_cdev's sysfs interface.
  */
-extern void led_sysfs_enable(struct led_classdev *led_cdev);
+void led_sysfs_enable(struct led_classdev *led_cdev);
 /**
  * led_compose_name - compose LED class device name
  *
  * Returns: 0 on success or negative error value on failure
  */
-extern int led_compose_name(struct device *dev, struct led_init_data *init_data,
+int led_compose_name(struct device *dev, struct led_init_data *init_data,
-			    char *led_classdev_name);
+		     char *led_classdev_name);
 /**
  * led_sysfs_is_disabled - check if LED sysfs interface is disabled
 #define led_trigger_get_led(dev)	((struct led_classdev *)dev_get_drvdata((dev)))
 #define led_trigger_get_drvdata(dev)	(led_get_trigger_data(led_trigger_get_led(dev)))
-ssize_t led_trigger_store(struct device *dev, struct device_attribute *attr,
-			const char *buf, size_t count);
-ssize_t led_trigger_show(struct device *dev, struct device_attribute *attr,
-			char *buf);
 /* Registration functions for complex triggers */
-extern int led_trigger_register(struct led_trigger *trigger);
+int led_trigger_register(struct led_trigger *trigger);
-extern void led_trigger_unregister(struct led_trigger *trigger);
+void led_trigger_unregister(struct led_trigger *trigger);
-extern int devm_led_trigger_register(struct device *dev,
+int devm_led_trigger_register(struct device *dev,
 				     struct led_trigger *trigger);
-extern void led_trigger_register_simple(const char *name,
+void led_trigger_register_simple(const char *name,
 				struct led_trigger **trigger);
-extern void led_trigger_unregister_simple(struct led_trigger *trigger);
+void led_trigger_unregister_simple(struct led_trigger *trigger);
-extern void led_trigger_event(struct led_trigger *trigger,
+void led_trigger_event(struct led_trigger *trigger,  enum led_brightness event);
-				enum led_brightness event);
+void led_trigger_blink(struct led_trigger *trigger, unsigned long *delay_on,
-extern void led_trigger_blink(struct led_trigger *trigger,
+		       unsigned long *delay_off);
-			      unsigned long *delay_on,
+void led_trigger_blink_oneshot(struct led_trigger *trigger,
-			      unsigned long *delay_off);
+			       unsigned long *delay_on,
-extern void led_trigger_blink_oneshot(struct led_trigger *trigger,
+			       unsigned long *delay_off,
-				      unsigned long *delay_on,
+			       int invert);
-				      unsigned long *delay_off,
+void led_trigger_set_default(struct led_classdev *led_cdev);
-				      int invert);
+int led_trigger_set(struct led_classdev *led_cdev, struct led_trigger *trigger);
-extern void led_trigger_set_default(struct led_classdev *led_cdev);
+void led_trigger_remove(struct led_classdev *led_cdev);
-extern int led_trigger_set(struct led_classdev *led_cdev,
-			   struct led_trigger *trigger);
-extern void led_trigger_remove(struct led_classdev *led_cdev);
 static inline void led_set_trigger_data(struct led_classdev *led_cdev,
 					void *trigger_data)
  * This is meant to be used on triggers with statically
  * allocated name.
  */
-extern void led_trigger_rename_static(const char *name,
+void led_trigger_rename_static(const char *name, struct led_trigger *trig);
-				      struct led_trigger *trig);
 #define module_led_trigger(__led_trigger) \
 	module_driver(__led_trigger, led_trigger_register, \
 /* Trigger specific functions */
 #ifdef CONFIG_LEDS_TRIGGER_DISK
-extern void ledtrig_disk_activity(bool write);
+void ledtrig_disk_activity(bool write);
 #else
 static inline void ledtrig_disk_activity(bool write) {}
 #endif
 #ifdef CONFIG_LEDS_TRIGGER_MTD
-extern void ledtrig_mtd_activity(void);
+void ledtrig_mtd_activity(void);
 #else
 static inline void ledtrig_mtd_activity(void) {}
 #endif
 #if defined(CONFIG_LEDS_TRIGGER_CAMERA) || defined(CONFIG_LEDS_TRIGGER_CAMERA_MODULE)
-extern void ledtrig_flash_ctrl(bool on);
+void ledtrig_flash_ctrl(bool on);
-extern void ledtrig_torch_ctrl(bool on);
+void ledtrig_torch_ctrl(bool on);
 #else
 static inline void ledtrig_flash_ctrl(bool on) {}
 static inline void ledtrig_torch_ctrl(bool on) {}
 	CPU_LED_HALTED,		/* Machine shutdown */
 };
 #ifdef CONFIG_LEDS_TRIGGER_CPU
-extern void ledtrig_cpu(enum cpu_led_event evt);
+void ledtrig_cpu(enum cpu_led_event evt);
 #else
 static inline void ledtrig_cpu(enum cpu_led_event evt)
 {
 #endif
 #ifdef CONFIG_LEDS_BRIGHTNESS_HW_CHANGED
-extern void led_classdev_notify_brightness_hw_changed(
+void led_classdev_notify_brightness_hw_changed(
 	struct led_classdev *led_cdev, enum led_brightness brightness);
 #else
 static inline void led_classdev_notify_brightness_hw_changed(

include/linux/libata.h+8−6

 };
 enum ata_completion_errors {
+	AC_ERR_OK		= 0,	    /* no error */
 	AC_ERR_DEV		= (1 << 0), /* device reported error */
 	AC_ERR_HSM		= (1 << 1), /* host state machine violation */
 	AC_ERR_TIMEOUT		= (1 << 2), /* timeout */
 	/*
 	 * Command execution
 	 */
-	int  (*qc_defer)(struct ata_queued_cmd *qc);
+	int (*qc_defer)(struct ata_queued_cmd *qc);
-	int  (*check_atapi_dma)(struct ata_queued_cmd *qc);
+	int (*check_atapi_dma)(struct ata_queued_cmd *qc);
-	void (*qc_prep)(struct ata_queued_cmd *qc);
+	enum ata_completion_errors (*qc_prep)(struct ata_queued_cmd *qc);
 	unsigned int (*qc_issue)(struct ata_queued_cmd *qc);
 	bool (*qc_fill_rtf)(struct ata_queued_cmd *qc);
 extern const char *ata_mode_string(unsigned long xfer_mask);
 extern unsigned long ata_id_xfermask(const u16 *id);
 extern int ata_std_qc_defer(struct ata_queued_cmd *qc);
-extern void ata_noop_qc_prep(struct ata_queued_cmd *qc);
+extern enum ata_completion_errors ata_noop_qc_prep(struct ata_queued_cmd *qc);
 extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
 		 unsigned int n_elem);
 extern unsigned int ata_dev_classify(const struct ata_taskfile *tf);
 					struct ata_taskfile *tf, u16 *id);
 extern void ata_qc_complete(struct ata_queued_cmd *qc);
 extern int ata_qc_complete_multiple(struct ata_port *ap, u64 qc_active);
+extern u64 ata_qc_get_active(struct ata_port *ap);
 extern void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd);
 extern int ata_std_bios_param(struct scsi_device *sdev,
 			      struct block_device *bdev,
 	.sg_tablesize		= LIBATA_MAX_PRD,		\
 	.dma_boundary		= ATA_DMA_BOUNDARY
-extern void ata_bmdma_qc_prep(struct ata_queued_cmd *qc);
+extern enum ata_completion_errors ata_bmdma_qc_prep(struct ata_queued_cmd *qc);
 extern unsigned int ata_bmdma_qc_issue(struct ata_queued_cmd *qc);
-extern void ata_bmdma_dumb_qc_prep(struct ata_queued_cmd *qc);
+extern enum ata_completion_errors ata_bmdma_dumb_qc_prep(struct ata_queued_cmd *qc);
 extern unsigned int ata_bmdma_port_intr(struct ata_port *ap,
 				      struct ata_queued_cmd *qc);
 extern irqreturn_t ata_bmdma_interrupt(int irq, void *dev_instance);

include/linux/libfdt_env.h+4−1

 #ifndef LIBFDT_ENV_H
 #define LIBFDT_ENV_H
-#include <linux/kernel.h>	/* For INT_MAX */
+#include <linux/limits.h>	/* For INT_MAX */
 #include <linux/string.h>
 #include <asm/byteorder.h>
+#define INT32_MAX	S32_MAX
+#define UINT32_MAX	U32_MAX
 typedef __be16 fdt16_t;
 typedef __be32 fdt32_t;
 typedef __be64 fdt64_t;

include/linux/libnvdimm.h+0−7

@@ -65,13 +65,6 @@ enum { · 64 unmodified lines
65	DPA_RESOURCE_ADJUSTED = 1 << 0,	65	DPA_RESOURCE_ADJUSTED = 1 << 0,
66	};	66	};
67		67
68	extern struct attribute_group nvdimm_bus_attribute_group;
69	extern struct attribute_group nvdimm_attribute_group;
70	extern struct attribute_group nd_device_attribute_group;
71	extern struct attribute_group nd_numa_attribute_group;
72	extern struct attribute_group nd_region_attribute_group;
73	extern struct attribute_group nd_mapping_attribute_group;
74
75	struct nvdimm;	68	struct nvdimm;
76	struct nvdimm_bus_descriptor;	69	struct nvdimm_bus_descriptor;
77	typedef int (ndctl_fn)(struct nvdimm_bus_descriptor nd_desc,	70	typedef int (ndctl_fn)(struct nvdimm_bus_descriptor nd_desc,

include/linux/license.h+1−0

@@ -1,3 +1,4 @@
		1	/* SPDX-License-Identifier: GPL-2.0-only */
1	#ifndef __LICENSE_H	2	#ifndef __LICENSE_H
2	#define __LICENSE_H	3	#define __LICENSE_H
3		4

include/linux/linkage.h+241−8

@@ -75,32 +75,61 @@ · 74 unmodified lines
75		75
76	#ifdef __ASSEMBLY__	76	#ifdef __ASSEMBLY__
77		77
		78	/* SYM_T_FUNC -- type used by assembler to mark functions */
		79	#ifndef SYM_T_FUNC
		80	#define SYM_T_FUNC STT_FUNC
		81	#endif
		82
		83	/* SYM_T_OBJECT -- type used by assembler to mark data */
		84	#ifndef SYM_T_OBJECT
		85	#define SYM_T_OBJECT STT_OBJECT
		86	#endif
		87
		88	/* SYM_T_NONE -- type used by assembler to mark entries of unknown type */
		89	#ifndef SYM_T_NONE
		90	#define SYM_T_NONE STT_NOTYPE
		91	#endif
		92
		93	/* SYM_A_* -- align the symbol? */
		94	#define SYM_A_ALIGN ALIGN
		95	#define SYM_A_NONE /* nothing */
		96
		97	/* SYM_L_* -- linkage of symbols */
		98	#define SYM_L_GLOBAL(name) .globl name
		99	#define SYM_L_WEAK(name) .weak name
		100	#define SYM_L_LOCAL(name) /* nothing */
		101
78	#ifndef LINKER_SCRIPT	102	#ifndef LINKER_SCRIPT
79	#define ALIGN __ALIGN	103	#define ALIGN __ALIGN
80	#define ALIGN_STR __ALIGN_STR	104	#define ALIGN_STR __ALIGN_STR
81		105
		106	/* === DEPRECATED annotations === */
		107
		108	#ifndef CONFIG_X86
82	#ifndef GLOBAL	109	#ifndef GLOBAL
		110	/* deprecated, use SYM_DATA, SYM_ENTRY, or similar /
83	#define GLOBAL(name) \	111	#define GLOBAL(name) \
84	.globl name ASM_NL \	112	.globl name ASM_NL \
85	name:	113	name:
86	#endif	114	#endif
87		115
88	#ifndef ENTRY	116	#ifndef ENTRY
		117	/* deprecated, use SYM_FUNC_START */
89	#define ENTRY(name) \	118	#define ENTRY(name) \
90	.globl name ASM_NL \	119	SYM_FUNC_START(name)
91	ALIGN ASM_NL \
92	name:
93	#endif	120	#endif
		121	#endif /* CONFIG_X86 */
94	#endif /* LINKER_SCRIPT */	122	#endif /* LINKER_SCRIPT */
95		123
		124	#ifndef CONFIG_X86
96	#ifndef WEAK	125	#ifndef WEAK
		126	/* deprecated, use SYM_FUNC_START_WEAK* */
97	#define WEAK(name) \	127	#define WEAK(name) \
98	.weak name ASM_NL \	128	SYM_FUNC_START_WEAK(name)
99	ALIGN ASM_NL \
100	name:
101	#endif	129	#endif
102		130
103	#ifndef END	131	#ifndef END
		132	/* deprecated, use SYM_FUNC_END, SYM_DATA_END, or SYM_END */
104	#define END(name) \	133	#define END(name) \
105	.size name, .-name	134	.size name, .-name
106	#endif	135	#endif
@@ -110,11 +139,215 @@ · 3 unmodified lines
110	* static analysis tools such as stack depth analyzer.	139	* static analysis tools such as stack depth analyzer.
111	*/	140	*/
112	#ifndef ENDPROC	141	#ifndef ENDPROC
		142	/* deprecated, use SYM_FUNC_END */
113	#define ENDPROC(name) \	143	#define ENDPROC(name) \
114	.type name, @function ASM_NL \	144	SYM_FUNC_END(name)
115	END(name)	145	#endif
		146	#endif /* CONFIG_X86 */
		147
		148	/* === generic annotations === */
		149
		150	/* SYM_ENTRY -- use only if you have to for non-paired symbols */
		151	#ifndef SYM_ENTRY
		152	#define SYM_ENTRY(name, linkage, align...) \
		153	linkage(name) ASM_NL \
		154	align ASM_NL \
		155	name:
		156	#endif
		157
		158	/* SYM_START -- use only if you have to */
		159	#ifndef SYM_START
		160	#define SYM_START(name, linkage, align...) \
		161	SYM_ENTRY(name, linkage, align)
		162	#endif
		163
		164	/* SYM_END -- use only if you have to */
		165	#ifndef SYM_END
		166	#define SYM_END(name, sym_type) \
		167	.type name sym_type ASM_NL \
		168	.size name, .-name
		169	#endif
		170
		171	/* === code annotations === */
		172
		173	/*
		174	* FUNC -- C-like functions (proper stack frame etc.)
		175	* CODE -- non-C code (e.g. irq handlers with different, special stack etc.)
		176	*
		177	* Objtool validates stack for FUNC, but not for CODE.
		178	* Objtool generates debug info for both FUNC & CODE, but needs special
		179	* annotations for each CODE's start (to describe the actual stack frame).
		180	*
		181	* ALIAS -- does not generate debug info -- the aliased function will
		182	*/
		183
		184	/* SYM_INNER_LABEL_ALIGN -- only for labels in the middle of code */
		185	#ifndef SYM_INNER_LABEL_ALIGN
		186	#define SYM_INNER_LABEL_ALIGN(name, linkage) \
		187	.type name SYM_T_NONE ASM_NL \
		188	SYM_ENTRY(name, linkage, SYM_A_ALIGN)
		189	#endif
		190
		191	/* SYM_INNER_LABEL -- only for labels in the middle of code */
		192	#ifndef SYM_INNER_LABEL
		193	#define SYM_INNER_LABEL(name, linkage) \
		194	.type name SYM_T_NONE ASM_NL \
		195	SYM_ENTRY(name, linkage, SYM_A_NONE)
		196	#endif
		197
		198	/*
		199	* SYM_FUNC_START_LOCAL_ALIAS -- use where there are two local names for one
		200	* function
		201	*/
		202	#ifndef SYM_FUNC_START_LOCAL_ALIAS
		203	#define SYM_FUNC_START_LOCAL_ALIAS(name) \
		204	SYM_START(name, SYM_L_LOCAL, SYM_A_ALIGN)
		205	#endif
		206
		207	/*
		208	* SYM_FUNC_START_ALIAS -- use where there are two global names for one
		209	* function
		210	*/
		211	#ifndef SYM_FUNC_START_ALIAS
		212	#define SYM_FUNC_START_ALIAS(name) \
		213	SYM_START(name, SYM_L_GLOBAL, SYM_A_ALIGN)
		214	#endif
		215
		216	/* SYM_FUNC_START -- use for global functions */
		217	#ifndef SYM_FUNC_START
		218	/*
		219	* The same as SYM_FUNC_START_ALIAS, but we will need to distinguish these two
		220	* later.
		221	*/
		222	#define SYM_FUNC_START(name) \
		223	SYM_START(name, SYM_L_GLOBAL, SYM_A_ALIGN)
		224	#endif
		225
		226	/* SYM_FUNC_START_NOALIGN -- use for global functions, w/o alignment */
		227	#ifndef SYM_FUNC_START_NOALIGN
		228	#define SYM_FUNC_START_NOALIGN(name) \
		229	SYM_START(name, SYM_L_GLOBAL, SYM_A_NONE)
		230	#endif
		231
		232	/* SYM_FUNC_START_LOCAL -- use for local functions */
		233	#ifndef SYM_FUNC_START_LOCAL
		234	/* the same as SYM_FUNC_START_LOCAL_ALIAS, see comment near SYM_FUNC_START */
		235	#define SYM_FUNC_START_LOCAL(name) \
		236	SYM_START(name, SYM_L_LOCAL, SYM_A_ALIGN)
116	#endif	237	#endif
117		238
		239	/* SYM_FUNC_START_LOCAL_NOALIGN -- use for local functions, w/o alignment */
		240	#ifndef SYM_FUNC_START_LOCAL_NOALIGN
		241	#define SYM_FUNC_START_LOCAL_NOALIGN(name) \
		242	SYM_START(name, SYM_L_LOCAL, SYM_A_NONE)
118	#endif	243	#endif
119		244
		245	/* SYM_FUNC_START_WEAK -- use for weak functions */
		246	#ifndef SYM_FUNC_START_WEAK
		247	#define SYM_FUNC_START_WEAK(name) \
		248	SYM_START(name, SYM_L_WEAK, SYM_A_ALIGN)
120	#endif	249	#endif
		250
		251	/* SYM_FUNC_START_WEAK_NOALIGN -- use for weak functions, w/o alignment */
		252	#ifndef SYM_FUNC_START_WEAK_NOALIGN
		253	#define SYM_FUNC_START_WEAK_NOALIGN(name) \
		254	SYM_START(name, SYM_L_WEAK, SYM_A_NONE)
		255	#endif
		256
		257	/* SYM_FUNC_END_ALIAS -- the end of LOCAL_ALIASed or ALIASed function */
		258	#ifndef SYM_FUNC_END_ALIAS
		259	#define SYM_FUNC_END_ALIAS(name) \
		260	SYM_END(name, SYM_T_FUNC)
		261	#endif
		262
		263	/*
		264	* SYM_FUNC_END -- the end of SYM_FUNC_START_LOCAL, SYM_FUNC_START,
		265	* SYM_FUNC_START_WEAK, ...
		266	*/
		267	#ifndef SYM_FUNC_END
		268	/* the same as SYM_FUNC_END_ALIAS, see comment near SYM_FUNC_START */
		269	#define SYM_FUNC_END(name) \
		270	SYM_END(name, SYM_T_FUNC)
		271	#endif
		272
		273	/* SYM_CODE_START -- use for non-C (special) functions */
		274	#ifndef SYM_CODE_START
		275	#define SYM_CODE_START(name) \
		276	SYM_START(name, SYM_L_GLOBAL, SYM_A_ALIGN)
		277	#endif
		278
		279	/* SYM_CODE_START_NOALIGN -- use for non-C (special) functions, w/o alignment */
		280	#ifndef SYM_CODE_START_NOALIGN
		281	#define SYM_CODE_START_NOALIGN(name) \
		282	SYM_START(name, SYM_L_GLOBAL, SYM_A_NONE)
		283	#endif
		284
		285	/* SYM_CODE_START_LOCAL -- use for local non-C (special) functions */
		286	#ifndef SYM_CODE_START_LOCAL
		287	#define SYM_CODE_START_LOCAL(name) \
		288	SYM_START(name, SYM_L_LOCAL, SYM_A_ALIGN)
		289	#endif
		290
		291	/*
		292	* SYM_CODE_START_LOCAL_NOALIGN -- use for local non-C (special) functions,
		293	* w/o alignment
		294	*/
		295	#ifndef SYM_CODE_START_LOCAL_NOALIGN
		296	#define SYM_CODE_START_LOCAL_NOALIGN(name) \
		297	SYM_START(name, SYM_L_LOCAL, SYM_A_NONE)
		298	#endif
		299
		300	/* SYM_CODE_END -- the end of SYM_CODE_START_LOCAL, SYM_CODE_START, ... */
		301	#ifndef SYM_CODE_END
		302	#define SYM_CODE_END(name) \
		303	SYM_END(name, SYM_T_NONE)
		304	#endif
		305
		306	/* === data annotations === */
		307
		308	/* SYM_DATA_START -- global data symbol */
		309	#ifndef SYM_DATA_START
		310	#define SYM_DATA_START(name) \
		311	SYM_START(name, SYM_L_GLOBAL, SYM_A_NONE)
		312	#endif
		313
		314	/* SYM_DATA_START -- local data symbol */
		315	#ifndef SYM_DATA_START_LOCAL
		316	#define SYM_DATA_START_LOCAL(name) \
		317	SYM_START(name, SYM_L_LOCAL, SYM_A_NONE)
		318	#endif
		319
		320	/* SYM_DATA_END -- the end of SYM_DATA_START symbol */
		321	#ifndef SYM_DATA_END
		322	#define SYM_DATA_END(name) \
		323	SYM_END(name, SYM_T_OBJECT)
		324	#endif
		325
		326	/* SYM_DATA_END_LABEL -- the labeled end of SYM_DATA_START symbol */
		327	#ifndef SYM_DATA_END_LABEL
		328	#define SYM_DATA_END_LABEL(name, linkage, label) \
		329	linkage(label) ASM_NL \
		330	.type label SYM_T_OBJECT ASM_NL \
		331	label: \
		332	SYM_END(name, SYM_T_OBJECT)
		333	#endif
		334
		335	/* SYM_DATA -- start+end wrapper around simple global data */
		336	#ifndef SYM_DATA
		337	#define SYM_DATA(name, data...) \
		338	SYM_DATA_START(name) ASM_NL \
		339	data ASM_NL \
		340	SYM_DATA_END(name)
		341	#endif
		342
		343	/* SYM_DATA_LOCAL -- start+end wrapper around simple local data */
		344	#ifndef SYM_DATA_LOCAL
		345	#define SYM_DATA_LOCAL(name, data...) \
		346	SYM_DATA_START_LOCAL(name) ASM_NL \
		347	data ASM_NL \
		348	SYM_DATA_END(name)
		349	#endif
		350
		351	#endif /* __ASSEMBLY__ */
		352
		353	#endif /* _LINUX_LINKAGE_H */

include/linux/linkmode.h+6−0

@@ -82,4 +82,10 @@ static inline int linkmode_equal(const unsigned long *src1, · 81 unmodified lines
82	return bitmap_equal(src1, src2, __ETHTOOL_LINK_MODE_MASK_NBITS);	82	return bitmap_equal(src1, src2, __ETHTOOL_LINK_MODE_MASK_NBITS);
83	}	83	}
84		84
		85	static inline int linkmode_subset(const unsigned long *src1,
		86	const unsigned long *src2)
		87	{
		88	return bitmap_subset(src1, src2, __ETHTOOL_LINK_MODE_MASK_NBITS);
		89	}
		90
85	#endif /* __LINKMODE_H */	91	#endif /* __LINKMODE_H */

include/linux/livepatch.h+17−0

 	bool patched;
 };
+/**
+ * struct klp_state - state of the system modified by the livepatch
+ * @id:		system state identifier (non-zero)
+ * @version:	version of the change
+ * @data:	custom data
+ */
+struct klp_state {
+	unsigned long id;
+	unsigned int version;
+	void *data;
+};
 /**
  * struct klp_patch - patch structure for live patching
  * @mod:	reference to the live patch module
  * @objs:	object entries for kernel objects to be patched
+ * @states:	system states that can get modified
  * @replace:	replace all actively used patches
  * @list:	list node for global list of actively used patches
  * @kobj:	kobject for sysfs resources
 	/* external */
 	struct module *mod;
 	struct klp_object *objs;
+	struct klp_state *states;
 	bool replace;
 	/* internal */
 void klp_shadow_free(void *obj, unsigned long id, klp_shadow_dtor_t dtor);
 void klp_shadow_free_all(unsigned long id, klp_shadow_dtor_t dtor);
+struct klp_state *klp_get_state(struct klp_patch *patch, unsigned long id);
+struct klp_state *klp_get_prev_state(unsigned long id);
 #else /* !CONFIG_LIVEPATCH */
 static inline int klp_module_coming(struct module *mod) { return 0; }

include/linux/lockd/debug.h+0−4

 #ifndef LINUX_LOCKD_DEBUG_H
 #define LINUX_LOCKD_DEBUG_H
-#ifdef __KERNEL__
 #include <linux/sunrpc/debug.h>
 /*
 # define ifdebug(flag)		if (0)
 #endif
-#endif /* __KERNEL__ */
 /*
  * Debug flags
  */

include/linux/lockd/lockd.h+0−4

 #ifndef LINUX_LOCKD_LOCKD_H
 #define LINUX_LOCKD_LOCKD_H
-#ifdef __KERNEL__
 #include <linux/in.h>
 #include <linux/in6.h>
 #include <net/ipv6.h>
 extern const struct lock_manager_operations nlmsvc_lock_operations;
-#endif /* __KERNEL__ */
 #endif /* LINUX_LOCKD_LOCKD_H */

include/linux/lockdep.h+10−11

 			 int trylock, int read, int check,
 			 struct lockdep_map *nest_lock, unsigned long ip);
-extern void lock_release(struct lockdep_map *lock, int nested,
+extern void lock_release(struct lockdep_map *lock, unsigned long ip);
-			 unsigned long ip);
 /*
  * Same "read" as for lock_acquire(), except -1 means any.
 }
 # define lock_acquire(l, s, t, r, c, n, i)	do { } while (0)
-# define lock_release(l, n, i)			do { } while (0)
+# define lock_release(l, i)			do { } while (0)
 # define lock_downgrade(l, i)			do { } while (0)
 # define lock_set_class(l, n, k, s, i)		do { } while (0)
 # define lock_set_subclass(l, s, i)		do { } while (0)
 #define spin_acquire(l, s, t, i)		lock_acquire_exclusive(l, s, t, NULL, i)
 #define spin_acquire_nest(l, s, t, n, i)	lock_acquire_exclusive(l, s, t, n, i)
-#define spin_release(l, n, i)			lock_release(l, n, i)
+#define spin_release(l, i)			lock_release(l, i)
 #define rwlock_acquire(l, s, t, i)		lock_acquire_exclusive(l, s, t, NULL, i)
 #define rwlock_acquire_read(l, s, t, i)		lock_acquire_shared_recursive(l, s, t, NULL, i)
-#define rwlock_release(l, n, i)			lock_release(l, n, i)
+#define rwlock_release(l, i)			lock_release(l, i)
 #define seqcount_acquire(l, s, t, i)		lock_acquire_exclusive(l, s, t, NULL, i)
 #define seqcount_acquire_read(l, s, t, i)	lock_acquire_shared_recursive(l, s, t, NULL, i)
-#define seqcount_release(l, n, i)		lock_release(l, n, i)
+#define seqcount_release(l, i)			lock_release(l, i)
 #define mutex_acquire(l, s, t, i)		lock_acquire_exclusive(l, s, t, NULL, i)
 #define mutex_acquire_nest(l, s, t, n, i)	lock_acquire_exclusive(l, s, t, n, i)
-#define mutex_release(l, n, i)			lock_release(l, n, i)
+#define mutex_release(l, i)			lock_release(l, i)
 #define rwsem_acquire(l, s, t, i)		lock_acquire_exclusive(l, s, t, NULL, i)
 #define rwsem_acquire_nest(l, s, t, n, i)	lock_acquire_exclusive(l, s, t, n, i)
 #define rwsem_acquire_read(l, s, t, i)		lock_acquire_shared(l, s, t, NULL, i)
-#define rwsem_release(l, n, i)			lock_release(l, n, i)
+#define rwsem_release(l, i)			lock_release(l, i)
 #define lock_map_acquire(l)			lock_acquire_exclusive(l, 0, 0, NULL, _THIS_IP_)
 #define lock_map_acquire_read(l)		lock_acquire_shared_recursive(l, 0, 0, NULL, _THIS_IP_)
 #define lock_map_acquire_tryread(l)		lock_acquire_shared_recursive(l, 0, 1, NULL, _THIS_IP_)
-#define lock_map_release(l)			lock_release(l, 1, _THIS_IP_)
+#define lock_map_release(l)			lock_release(l, _THIS_IP_)
 #ifdef CONFIG_PROVE_LOCKING
 # define might_lock(lock) 						\
 do {									\
 	typecheck(struct lockdep_map *, &(lock)->dep_map);		\
 	lock_acquire(&(lock)->dep_map, 0, 0, 0, 1, NULL, _THIS_IP_);	\
-	lock_release(&(lock)->dep_map, 0, _THIS_IP_);			\
+	lock_release(&(lock)->dep_map, _THIS_IP_);			\
 } while (0)
 # define might_lock_read(lock) 						\
 do {									\
 	typecheck(struct lockdep_map *, &(lock)->dep_map);		\
 	lock_acquire(&(lock)->dep_map, 0, 0, 1, 1, NULL, _THIS_IP_);	\
-	lock_release(&(lock)->dep_map, 0, _THIS_IP_);			\
+	lock_release(&(lock)->dep_map, _THIS_IP_);			\
 } while (0)
 #define lockdep_assert_irqs_enabled()	do {				\

include/linux/logic_pio.h+2−2

  * area by redefining the macro below.
  */
 #define PIO_INDIRECT_SIZE 0x4000
-#define MMIO_UPPER_LIMIT (IO_SPACE_LIMIT - PIO_INDIRECT_SIZE)
 #else
-#define MMIO_UPPER_LIMIT IO_SPACE_LIMIT
+#define PIO_INDIRECT_SIZE 0
 #endif /* CONFIG_INDIRECT_PIO */
+#define MMIO_UPPER_LIMIT (IO_SPACE_LIMIT - PIO_INDIRECT_SIZE)
 struct logic_pio_hwaddr *find_io_range_by_fwnode(struct fwnode_handle *fwnode);
 unsigned long logic_pio_trans_hwaddr(struct fwnode_handle *fwnode,

include/linux/lsm_hooks.h+15−0

@@ -1818,6 +1818,14 @@ union security_list_options { · 1817 unmodified lines
1818	void (bpf_prog_free_security)(struct bpf_prog_aux aux);	1818	void (bpf_prog_free_security)(struct bpf_prog_aux aux);
1819	#endif /* CONFIG_BPF_SYSCALL */	1819	#endif /* CONFIG_BPF_SYSCALL */
1820	int (*locked_down)(enum lockdown_reason what);	1820	int (*locked_down)(enum lockdown_reason what);
		1821	#ifdef CONFIG_PERF_EVENTS
		1822	int (perf_event_open)(struct perf_event_attr attr, int type);
		1823	int (perf_event_alloc)(struct perf_event event);
		1824	void (perf_event_free)(struct perf_event event);
		1825	int (perf_event_read)(struct perf_event event);
		1826	int (perf_event_write)(struct perf_event event);
		1827
		1828	#endif
1821	};	1829	};
1822		1830
1823	struct security_hook_heads {	1831	struct security_hook_heads {
@@ -2060,6 +2068,13 @@ struct security_hook_heads { · 236 unmodified lines
2060	struct hlist_head bpf_prog_free_security;	2068	struct hlist_head bpf_prog_free_security;
2061	#endif /* CONFIG_BPF_SYSCALL */	2069	#endif /* CONFIG_BPF_SYSCALL */
2062	struct hlist_head locked_down;	2070	struct hlist_head locked_down;
		2071	#ifdef CONFIG_PERF_EVENTS
		2072	struct hlist_head perf_event_open;
		2073	struct hlist_head perf_event_alloc;
		2074	struct hlist_head perf_event_free;
		2075	struct hlist_head perf_event_read;
		2076	struct hlist_head perf_event_write;
		2077	#endif
2063	} __randomize_layout;	2078	} __randomize_layout;
2064		2079
2065	/*	2080	/*

include/linux/memblock.h+3−0

 					 MEMBLOCK_ALLOC_ACCESSIBLE);
 }
+void *memblock_alloc_exact_nid_raw(phys_addr_t size, phys_addr_t align,
+				 phys_addr_t min_addr, phys_addr_t max_addr,
+				 int nid);
 void *memblock_alloc_try_nid_raw(phys_addr_t size, phys_addr_t align,
 				 phys_addr_t min_addr, phys_addr_t max_addr,
 				 int nid);

include/linux/memcontrol.h+22−27

 struct mem_cgroup_reclaim_cookie {
 	pg_data_t *pgdat;
-	int priority;
 	unsigned int generation;
 };
 enum mem_cgroup_events_target {
 	MEM_CGROUP_TARGET_THRESH,
 	MEM_CGROUP_TARGET_SOFTLIMIT,
-	MEM_CGROUP_TARGET_NUMAINFO,
 	MEM_CGROUP_NTARGETS,
 };
 };
 /*
- * per-zone information in memory controller.
+ * per-node information in memory controller.
  */
 struct mem_cgroup_per_node {
 	struct lruvec		lruvec;
 	unsigned long		lru_zone_size[MAX_NR_ZONES][NR_LRU_LISTS];
-	struct mem_cgroup_reclaim_iter	iter[DEF_PRIORITY + 1];
+	struct mem_cgroup_reclaim_iter	iter;
 	struct memcg_shrinker_map __rcu	*shrinker_map;
 	unsigned long		usage_in_excess;/* Set to the value by which */
 						/* the soft limit is exceeded*/
 	bool			on_tree;
-	bool			congested;	/* memcg has many dirty pages */
-						/* backed by a congested BDI */
 	struct mem_cgroup	*memcg;		/* Back pointer, we cannot */
 						/* use container_of	   */
 };
 	struct list_head kmem_caches;
 #endif
-	int last_scanned_node;
-#if MAX_NUMNODES > 1
-	nodemask_t	scan_nodes;
-	atomic_t	numainfo_events;
-	atomic_t	numainfo_updating;
-#endif
 #ifdef CONFIG_CGROUP_WRITEBACK
 	struct list_head cgwb_list;
 	struct wb_domain cgwb_domain;
 }
 /**
- * mem_cgroup_lruvec - get the lru list vector for a node or a memcg zone
+ * mem_cgroup_lruvec - get the lru list vector for a memcg & node
- * @node: node of the wanted lruvec
  * @memcg: memcg of the wanted lruvec
  *
- * Returns the lru list vector holding pages for a given @node or a given
+ * Returns the lru list vector holding pages for a given @memcg &
- * @memcg and @zone. This can be the node lruvec, if the memory controller
+ * @node combination. This can be the node lruvec, if the memory
- * is disabled.
+ * controller is disabled.
  */
-static inline struct lruvec *mem_cgroup_lruvec(struct pglist_data *pgdat,
+static inline struct lruvec *mem_cgroup_lruvec(struct mem_cgroup *memcg,
-				struct mem_cgroup *memcg)
+					       struct pglist_data *pgdat)
 {
 	struct mem_cgroup_per_node *mz;
 	struct lruvec *lruvec;
 	if (mem_cgroup_disabled()) {
-		lruvec = node_lruvec(pgdat);
+		lruvec = &pgdat->__lruvec;
 		goto out;
 	}
+	if (!memcg)
+		memcg = root_mem_cgroup;
 	mz = mem_cgroup_nodeinfo(memcg, pgdat->node_id);
 	lruvec = &mz->lruvec;
 out:
 		return;
 	}
-	lruvec = mem_cgroup_lruvec(pgdat, page->mem_cgroup);
+	lruvec = mem_cgroup_lruvec(page->mem_cgroup, pgdat);
 	__mod_lruvec_state(lruvec, idx, val);
 }
 {
 }
-static inline struct lruvec *mem_cgroup_lruvec(struct pglist_data *pgdat,
+static inline struct lruvec *mem_cgroup_lruvec(struct mem_cgroup *memcg,
-				struct mem_cgroup *memcg)
+					       struct pglist_data *pgdat)
 {
-	return node_lruvec(pgdat);
+	return &pgdat->__lruvec;
 }
 static inline struct lruvec *mem_cgroup_page_lruvec(struct page *page,
 						    struct pglist_data *pgdat)
 {
-	return &pgdat->lruvec;
+	return &pgdat->__lruvec;
+}
+static inline struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *memcg)
+{
+	return NULL;
 }
 static inline bool mm_match_cgroup(struct mm_struct *mm,

include/linux/memory_hotplug.h+4−7

 typedef void (*online_page_callback_t)(struct page *page, unsigned int order);
+extern void generic_online_page(struct page *page, unsigned int order);
 extern int set_online_page_callback(online_page_callback_t callback);
 extern int restore_online_page_callback(online_page_callback_t callback);
-extern void __online_page_set_limits(struct page *page);
-extern void __online_page_increment_counters(struct page *page);
-extern void __online_page_free(struct page *page);
 extern int try_online_node(int nid);
 extern int arch_add_memory(int nid, u64 start, u64 size,
 void mem_hotplug_begin(void);
 void mem_hotplug_done(void);
-extern void set_zone_contiguous(struct zone *zone);
-extern void clear_zone_contiguous(struct zone *zone);
 #else /* ! CONFIG_MEMORY_HOTPLUG */
 #define pfn_to_online_page(pfn)			\
 ({						\
 static inline void __remove_memory(int nid, u64 start, u64 size) {}
 #endif /* CONFIG_MEMORY_HOTREMOVE */
+extern void set_zone_contiguous(struct zone *zone);
+extern void clear_zone_contiguous(struct zone *zone);
 extern void __ref free_area_init_core_hotplug(int nid);
 extern int __add_memory(int nid, u64 start, u64 size);
 extern int add_memory(int nid, u64 start, u64 size);

include/linux/memregion.h+23−0

@@ -0,0 +1,23 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef _MEMREGION_H_
	3	#define _MEMREGION_H_
	4	#include <linux/types.h>
	5	#include <linux/errno.h>
	6
	7	struct memregion_info {
	8	int target_node;
	9	};
	10
	11	#ifdef CONFIG_MEMREGION
	12	int memregion_alloc(gfp_t gfp);
	13	void memregion_free(int id);
	14	#else
	15	static inline int memregion_alloc(gfp_t gfp)
	16	{
	17	return -ENOMEM;
	18	}
	19	void memregion_free(int id)
	20	{
	21	}
	22	#endif
	23	#endif /* _MEMREGION_H_ */

include/linux/mfd/abx500/ab8500-gpadc.h+0−75

@@ -1,75 +0,0 @@
1	/* SPDX-License-Identifier: GPL-2.0-only */
2	/*
3	* Copyright (C) 2010 ST-Ericsson SA
4	*
5	* Author: Arun R Murthy <arun.murthy@stericsson.com>
6	* Author: Daniel Willerud <daniel.willerud@stericsson.com>
7	* Author: M'boumba Cedric Madianga <cedric.madianga@stericsson.com>
8	*/
9
10	#ifndef _AB8500_GPADC_H
11	#define _AB8500_GPADC_H
12
13	/* GPADC source: From datasheet(ADCSwSel[4:0] in GPADCCtrl2
14	* and ADCHwSel[4:0] in GPADCCtrl3 ) */
15	#define BAT_CTRL 0x01
16	#define BTEMP_BALL 0x02
17	#define MAIN_CHARGER_V 0x03
18	#define ACC_DETECT1 0x04
19	#define ACC_DETECT2 0x05
20	#define ADC_AUX1 0x06
21	#define ADC_AUX2 0x07
22	#define MAIN_BAT_V 0x08
23	#define VBUS_V 0x09
24	#define MAIN_CHARGER_C 0x0A
25	#define USB_CHARGER_C 0x0B
26	#define BK_BAT_V 0x0C
27	#define DIE_TEMP 0x0D
28	#define USB_ID 0x0E
29	#define XTAL_TEMP 0x12
30	#define VBAT_TRUE_MEAS 0x13
31	#define BAT_CTRL_AND_IBAT 0x1C
32	#define VBAT_MEAS_AND_IBAT 0x1D
33	#define VBAT_TRUE_MEAS_AND_IBAT 0x1E
34	#define BAT_TEMP_AND_IBAT 0x1F
35
36	/* Virtual channel used only for ibat convertion to ampere
37	* Battery current conversion (ibat) cannot be requested as a single conversion
38	* but it is always in combination with other input requests
39	*/
40	#define IBAT_VIRTUAL_CHANNEL 0xFF
41
42	#define SAMPLE_1 1
43	#define SAMPLE_4 4
44	#define SAMPLE_8 8
45	#define SAMPLE_16 16
46	#define RISING_EDGE 0
47	#define FALLING_EDGE 1
48
49	/* Arbitrary ADC conversion type constants */
50	#define ADC_SW 0
51	#define ADC_HW 1
52
53	struct ab8500_gpadc;
54
55	struct ab8500_gpadc ab8500_gpadc_get(char name);
56	int ab8500_gpadc_sw_hw_convert(struct ab8500_gpadc *gpadc, u8 channel,
57	u8 avg_sample, u8 trig_edge, u8 trig_timer, u8 conv_type);
58	static inline int ab8500_gpadc_convert(struct ab8500_gpadc *gpadc, u8 channel)
59	{
60	return ab8500_gpadc_sw_hw_convert(gpadc, channel,
61	SAMPLE_16, 0, 0, ADC_SW);
62	}
63
64	int ab8500_gpadc_read_raw(struct ab8500_gpadc *gpadc, u8 channel,
65	u8 avg_sample, u8 trig_edge, u8 trig_timer, u8 conv_type);
66	int ab8500_gpadc_double_read_raw(struct ab8500_gpadc *gpadc, u8 channel,
67	u8 avg_sample, u8 trig_edge, u8 trig_timer, u8 conv_type,
68	int *ibat);
69	int ab8500_gpadc_ad_to_voltage(struct ab8500_gpadc *gpadc,
70	u8 channel, int ad_value);
71	void ab8540_gpadc_get_otp(struct ab8500_gpadc *gpadc,
72	u16 vmain_l, u16 vmain_h, u16 btemp_l, u16 btemp_h,
73	u16 vbat_l, u16 vbat_h, u16 ibat_l, u16 ibat_h);
74
75	#endif /* _AB8500_GPADC_H */

include/linux/mfd/arizona/registers.h+0−7

@@ -1186,13 +1186,6 @@ · 1185 unmodified lines
1186	#define ARIZONA_DSP4_SCRATCH_1 0x1441	1186	#define ARIZONA_DSP4_SCRATCH_1 0x1441
1187	#define ARIZONA_DSP4_SCRATCH_2 0x1442	1187	#define ARIZONA_DSP4_SCRATCH_2 0x1442
1188	#define ARIZONA_DSP4_SCRATCH_3 0x1443	1188	#define ARIZONA_DSP4_SCRATCH_3 0x1443
1189	#define ARIZONA_FRF_COEFF_1 0x1700
1190	#define ARIZONA_FRF_COEFF_2 0x1701
1191	#define ARIZONA_FRF_COEFF_3 0x1702
1192	#define ARIZONA_FRF_COEFF_4 0x1703
1193	#define ARIZONA_V2_DAC_COMP_1 0x1704
1194	#define ARIZONA_V2_DAC_COMP_2 0x1705
1195
1196		1189
1197	/*	1190	/*
1198	* Field Definitions.	1191	* Field Definitions.

include/linux/mfd/core.h+29−20

 #include <linux/platform_device.h>
+#define MFD_RES_SIZE(arr) (sizeof(arr) / sizeof(struct resource))
+#define MFD_CELL_ALL(_name, _res, _pdata, _pdsize, _id, _compat, _match)\
+	{								\
+		.name = (_name),					\
+		.resources = (_res),					\
+		.num_resources = MFD_RES_SIZE((_res)),			\
+		.platform_data = (_pdata),				\
+		.pdata_size = (_pdsize),				\
+		.of_compatible = (_compat),				\
+		.acpi_match = (_match),					\
+		.id = (_id),						\
+	}
+#define OF_MFD_CELL(_name, _res, _pdata, _pdsize,_id, _compat)		\
+	MFD_CELL_ALL(_name, _res, _pdata, _pdsize, _id, _compat, NULL)	\
+#define ACPI_MFD_CELL(_name, _res, _pdata, _pdsize, _id, _match)	\
+	MFD_CELL_ALL(_name, _res, _pdata, _pdsize, _id, NULL, _match)	\
+#define MFD_CELL_BASIC(_name, _res, _pdata, _pdsize, _id)		\
+	MFD_CELL_ALL(_name, _res, _pdata, _pdsize, _id, NULL, NULL)	\
+#define MFD_CELL_RES(_name, _res)					\
+	MFD_CELL_ALL(_name, _res, NULL, 0, 0, NULL, NULL)		\
+#define MFD_CELL_NAME(_name)						\
+	MFD_CELL_ALL(_name, NULL, NULL, 0, 0, NULL, NULL)		\
 struct irq_domain;
 struct property_entry;
 	const char		*name;
 	int			id;
-	/* refcounting for multiple drivers to use a single cell */
-	atomic_t		*usage_count;
 	int			(*enable)(struct platform_device *dev);
 	int			(*disable)(struct platform_device *dev);
 extern int mfd_cell_enable(struct platform_device *pdev);
 extern int mfd_cell_disable(struct platform_device *pdev);
-/*
- * "Clone" multiple platform devices for a single cell. This is to be used
- * for devices that have multiple users of a cell.  For example, if an mfd
- * driver wants the cell "foo" to be used by a GPIO driver, an MTD driver,
- * and a platform driver, the following bit of code would be use after first
- * calling mfd_add_devices():
- *
- * const char *fclones[] = { "foo-gpio", "foo-mtd" };
- * err = mfd_clone_cells("foo", fclones, ARRAY_SIZE(fclones));
- *
- * Each driver (MTD, GPIO, and platform driver) would then register
- * platform_drivers for "foo-mtd", "foo-gpio", and "foo", respectively.
- * The cell's .enable/.disable hooks should be used to deal with hardware
- * resource contention.
- */
-extern int mfd_clone_cell(const char *cell, const char **clones,
-		size_t n_clones);
 /*
  * Given a platform device that's been created by mfd_add_devices(), fetch
  * the mfd_cell that created it.

include/linux/mfd/db8500-prcmu.h+2−2

@@ -489,7 +489,7 @@ struct prcmu_auto_pm_config { · 488 unmodified lines
489		489
490	#ifdef CONFIG_MFD_DB8500_PRCMU	490	#ifdef CONFIG_MFD_DB8500_PRCMU
491		491
492	void db8500_prcmu_early_init(u32 phy_base, u32 size);	492	void db8500_prcmu_early_init(void);
493	int prcmu_set_rc_a2p(enum romcode_write);	493	int prcmu_set_rc_a2p(enum romcode_write);
494	enum romcode_read prcmu_get_rc_p2a(void);	494	enum romcode_read prcmu_get_rc_p2a(void);
495	enum ap_pwrst prcmu_get_xp70_current_state(void);	495	enum ap_pwrst prcmu_get_xp70_current_state(void);
@@ -546,7 +546,7 @@ void db8500_prcmu_write_masked(unsigned int reg, u32 mask, u32 value); · 50 unmodified lines
546		546
547	#else /* !CONFIG_MFD_DB8500_PRCMU */	547	#else /* !CONFIG_MFD_DB8500_PRCMU */
548		548
549	static inline void db8500_prcmu_early_init(u32 phy_base, u32 size) {}	549	static inline void db8500_prcmu_early_init(void) {}
550		550
551	static inline int prcmu_set_rc_a2p(enum romcode_write code)	551	static inline int prcmu_set_rc_a2p(enum romcode_write code)
552	{	552	{

include/linux/mfd/dbx500-prcmu.h+4−3

 #define PRCMU_FW_PROJECT_U8500_MBL2	12 /* Customer specific */
 #define PRCMU_FW_PROJECT_U8520		13
 #define PRCMU_FW_PROJECT_U8420		14
+#define PRCMU_FW_PROJECT_U8420_SYSCLK	17
 #define PRCMU_FW_PROJECT_A9420		20
 /* [32..63] 9540 and derivatives */
 #define PRCMU_FW_PROJECT_U9540		32
 #if defined(CONFIG_UX500_SOC_DB8500)
-static inline void prcmu_early_init(u32 phy_base, u32 size)
+static inline void prcmu_early_init(void)
 {
-	return db8500_prcmu_early_init(phy_base, size);
+	return db8500_prcmu_early_init();
 }
 static inline int prcmu_set_power_state(u8 state, bool keep_ulp_clk,
 }
 #else
-static inline void prcmu_early_init(u32 phy_base, u32 size) {}
+static inline void prcmu_early_init(void) {}
 static inline int prcmu_set_power_state(u8 state, bool keep_ulp_clk,
 	bool keep_ap_pll)

include/linux/mfd/madera/core.h+11−0

 #ifndef MADERA_CORE_H
 #define MADERA_CORE_H
+#include <linux/clk.h>
 #include <linux/gpio/consumer.h>
 #include <linux/interrupt.h>
 #include <linux/mfd/madera/pdata.h>
 	CS42L92 = 9,
 };
+enum {
+	MADERA_MCLK1,
+	MADERA_MCLK2,
+	MADERA_MCLK3,
+	MADERA_NUM_MCLK
+};
 #define MADERA_MAX_CORE_SUPPLIES	2
 #define MADERA_MAX_GPIOS		40
  * @irq_dev:		the irqchip child driver device
  * @irq_data:		pointer to irqchip data for the child irqchip driver
  * @irq:		host irq number from SPI or I2C configuration
+ * @mclk:		Structure holding clock supplies
  * @out_clamp:		indicates output clamp state for each analogue output
  * @out_shorted:	indicates short circuit state for each analogue output
  * @hp_ena:		bitflags of enable state for the headphone outputs
 	struct regmap_irq_chip_data *irq_data;
 	int irq;
+	struct clk_bulk_data mclk[MADERA_NUM_MCLK];
 	unsigned int num_micbias;
 	unsigned int num_childbias[MADERA_MAX_MICBIAS];

include/linux/mfd/max77620.h+0−1

@@ -329,7 +329,6 @@ struct max77620_chip { · 328 unmodified lines
329	struct regmap *rmap;	329	struct regmap *rmap;
330		330
331	int chip_irq;	331	int chip_irq;
332	int irq_base;
333		332
334	/* chip id */	333	/* chip id */
335	enum max77620_chip_id chip_id;	334	enum max77620_chip_id chip_id;

include/linux/mfd/mt6397/rtc.h+71−0

@@ -0,0 +1,71 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	/*
	3	* Copyright (C) 2014-2019 MediaTek Inc.
	4	*
	5	* Author: Tianping.Fang <tianping.fang@mediatek.com>
	6	* Sean Wang <sean.wang@mediatek.com>
	7	*/
	8
	9	#ifndef _LINUX_MFD_MT6397_RTC_H_
	10	#define _LINUX_MFD_MT6397_RTC_H_
	11
	12	#include <linux/jiffies.h>
	13	#include <linux/mutex.h>
	14	#include <linux/regmap.h>
	15	#include <linux/rtc.h>
	16
	17	#define RTC_BBPU 0x0000
	18	#define RTC_BBPU_CBUSY BIT(6)
	19	#define RTC_BBPU_KEY (0x43 << 8)
	20
	21	#define RTC_WRTGR 0x003c
	22
	23	#define RTC_IRQ_STA 0x0002
	24	#define RTC_IRQ_STA_AL BIT(0)
	25	#define RTC_IRQ_STA_LP BIT(3)
	26
	27	#define RTC_IRQ_EN 0x0004
	28	#define RTC_IRQ_EN_AL BIT(0)
	29	#define RTC_IRQ_EN_ONESHOT BIT(2)
	30	#define RTC_IRQ_EN_LP BIT(3)
	31	#define RTC_IRQ_EN_ONESHOT_AL (RTC_IRQ_EN_ONESHOT \| RTC_IRQ_EN_AL)
	32
	33	#define RTC_AL_MASK 0x0008
	34	#define RTC_AL_MASK_DOW BIT(4)
	35
	36	#define RTC_TC_SEC 0x000a
	37	/* Min, Hour, Dom... register offset to RTC_TC_SEC */
	38	#define RTC_OFFSET_SEC 0
	39	#define RTC_OFFSET_MIN 1
	40	#define RTC_OFFSET_HOUR 2
	41	#define RTC_OFFSET_DOM 3
	42	#define RTC_OFFSET_DOW 4
	43	#define RTC_OFFSET_MTH 5
	44	#define RTC_OFFSET_YEAR 6
	45	#define RTC_OFFSET_COUNT 7
	46
	47	#define RTC_AL_SEC 0x0018
	48
	49	#define RTC_PDN2 0x002e
	50	#define RTC_PDN2_PWRON_ALARM BIT(4)
	51
	52	#define RTC_MIN_YEAR 1968
	53	#define RTC_BASE_YEAR 1900
	54	#define RTC_NUM_YEARS 128
	55	#define RTC_MIN_YEAR_OFFSET (RTC_MIN_YEAR - RTC_BASE_YEAR)
	56
	57	#define MTK_RTC_POLL_DELAY_US 10
	58	#define MTK_RTC_POLL_TIMEOUT (jiffies_to_usecs(HZ))
	59
	60	struct mt6397_rtc {
	61	struct device *dev;
	62	struct rtc_device *rtc_dev;
	63
	64	/* Protect register access from multiple tasks */
	65	struct mutex lock;
	66	struct regmap *regmap;
	67	int irq;
	68	u32 addr_base;
	69	};
	70
	71	#endif /* _LINUX_MFD_MT6397_RTC_H_ */

include/linux/mfd/rk808.h+1−1

@@ -610,7 +610,7 @@ enum { · 609 unmodified lines
610	RK808_ID = 0x0000,	610	RK808_ID = 0x0000,
611	RK809_ID = 0x8090,	611	RK809_ID = 0x8090,
612	RK817_ID = 0x8170,	612	RK817_ID = 0x8170,
613	RK818_ID = 0x8181,	613	RK818_ID = 0x8180,
614	};	614	};
615		615
616	struct rk808 {	616	struct rk808 {

include/linux/mfd/stm32-timers.h+4−8

 #define TIM_CCER_CC4E	BIT(12)	/* Capt/Comp 4  out Ena    */
 #define TIM_CCER_CC4P	BIT(13)	/* Capt/Comp 4  Polarity   */
 #define TIM_CCER_CCXE	(BIT(0) | BIT(4) | BIT(8) | BIT(12))
-#define TIM_BDTR_BKE	BIT(12) /* Break input enable	   */
+#define TIM_BDTR_BKE(x)	BIT(12 + (x) * 12) /* Break input enable */
-#define TIM_BDTR_BKP	BIT(13) /* Break input polarity	   */
+#define TIM_BDTR_BKP(x)	BIT(13 + (x) * 12) /* Break input polarity */
 #define TIM_BDTR_AOE	BIT(14)	/* Automatic Output Enable */
 #define TIM_BDTR_MOE	BIT(15)	/* Main Output Enable      */
-#define TIM_BDTR_BKF	(BIT(16) | BIT(17) | BIT(18) | BIT(19))
+#define TIM_BDTR_BKF(x)	(0xf << (16 + (x) * 4))
-#define TIM_BDTR_BK2F	(BIT(20) | BIT(21) | BIT(22) | BIT(23))
-#define TIM_BDTR_BK2E	BIT(24) /* Break 2 input enable	   */
-#define TIM_BDTR_BK2P	BIT(25) /* Break 2 input polarity  */
 #define TIM_DCR_DBA	GENMASK(4, 0)	/* DMA base addr */
 #define TIM_DCR_DBL	GENMASK(12, 8)	/* DMA burst len */
 #define TIM_CR2_MMS2_SHIFT	20
 #define TIM_SMCR_TS_SHIFT	4
 #define TIM_BDTR_BKF_MASK	0xF
-#define TIM_BDTR_BKF_SHIFT	16
+#define TIM_BDTR_BKF_SHIFT(x)	(16 + (x) * 4)
-#define TIM_BDTR_BK2F_SHIFT	20
 enum stm32_timers_dmas {
 	STM32_TIMERS_DMA_CH1,

include/linux/mfd/syscon/atmel-matrix.h+0−1

@@ -106,7 +106,6 @@ · 105 unmodified lines
106	#define AT91_MATRIX_DDR_IOSR BIT(18)	106	#define AT91_MATRIX_DDR_IOSR BIT(18)
107	#define AT91_MATRIX_NFD0_SELECT BIT(24)	107	#define AT91_MATRIX_NFD0_SELECT BIT(24)
108	#define AT91_MATRIX_DDR_MP_EN BIT(25)	108	#define AT91_MATRIX_DDR_MP_EN BIT(25)
109	#define AT91_MATRIX_EBI_NUM_CS 8
110		109
111	#define AT91_MATRIX_USBPUCR_PUON BIT(30)	110	#define AT91_MATRIX_USBPUCR_PUON BIT(30)
112		111

include/linux/mfd/twl.h+8−4

@@ -181,14 +181,18 @@ static inline int twl_i2c_read_u8(u8 mod_no, u8 *val, u8 reg) { · 180 unmodified lines
181	}	181	}
182		182
183	static inline int twl_i2c_write_u16(u8 mod_no, u16 val, u8 reg) {	183	static inline int twl_i2c_write_u16(u8 mod_no, u16 val, u8 reg) {
184	val = cpu_to_le16(val);	184	__le16 value;
185	return twl_i2c_write(mod_no, (u8*) &val, reg, 2);	185
		186	value = cpu_to_le16(val);
		187	return twl_i2c_write(mod_no, (u8 *) &value, reg, 2);
186	}	188	}
187		189
188	static inline int twl_i2c_read_u16(u8 mod_no, u16 *val, u8 reg) {	190	static inline int twl_i2c_read_u16(u8 mod_no, u16 *val, u8 reg) {
189	int ret;	191	int ret;
190	ret = twl_i2c_read(mod_no, (u8*) val, reg, 2);	192	__le16 value;
191	val = le16_to_cpu(val);	193
		194	ret = twl_i2c_read(mod_no, (u8 *) &value, reg, 2);
		195	*val = le16_to_cpu(value);
192	return ret;	196	return ret;
193	}	197	}
194		198

include/linux/miscdevice.h+2−0

 #define SGI_MMTIMER		153
 #define STORE_QUEUE_MINOR	155	/* unused */
 #define I2O_MINOR		166
+#define AGPGART_MINOR		175
 #define HWRNG_MINOR		183
 #define MICROCODE_MINOR		184
 #define IRNET_MINOR		187
 #define UHID_MINOR		239
 #define USERIO_MINOR		240
 #define VHOST_VSOCK_MINOR	241
+#define RFKILL_MINOR		242
 #define MISC_DYNAMIC_MINOR	255
 struct device;

include/linux/mlx5/driver.h+16−4

 	struct dentry	       *cmdif_debugfs;
 	/* end: qp staff */
-	struct xarray           mkey_table;
 	/* start: alloc staff */
 	/* protect buffer alocation according to numa node */
 	struct mutex            alloc_mutex;
 						      gfp_t flags, int npages);
 void mlx5_free_cmd_mailbox_chain(struct mlx5_core_dev *dev,
 				 struct mlx5_cmd_mailbox *head);
-void mlx5_init_mkey_table(struct mlx5_core_dev *dev);
-void mlx5_cleanup_mkey_table(struct mlx5_core_dev *dev);
 int mlx5_core_create_mkey_cb(struct mlx5_core_dev *dev,
 			     struct mlx5_core_mkey *mkey,
 			     struct mlx5_async_ctx *async_ctx, u32 *in,
 	return dev->coredev_type == MLX5_COREDEV_PF;
 }
+static inline bool mlx5_core_is_vf(const struct mlx5_core_dev *dev)
+{
+	return dev->coredev_type == MLX5_COREDEV_VF;
+}
 static inline bool mlx5_core_is_ecpf(struct mlx5_core_dev *dev)
 {
 	return dev->caps.embedded_cpu;
 	MLX5_TRIGGERED_CMD_COMP = (u64)1 << 32,
 };
+static inline bool mlx5_is_roce_enabled(struct mlx5_core_dev *dev)
+{
+	struct devlink *devlink = priv_to_devlink(dev);
+	union devlink_param_value val;
+	devlink_param_driverinit_value_get(devlink,
+					   DEVLINK_PARAM_GENERIC_ID_ENABLE_ROCE,
+					   &val);
+	return val.vbool;
+}
 #endif /* MLX5_DRIVER_H */

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

@@ -80,7 +80,8 @@ enum mlx5_flow_namespace_type { · 79 unmodified lines
80		80
81	enum {	81	enum {
82	FDB_BYPASS_PATH,	82	FDB_BYPASS_PATH,
83	FDB_FAST_PATH,	83	FDB_TC_OFFLOAD,
		84	FDB_FT_OFFLOAD,
84	FDB_SLOW_PATH,	85	FDB_SLOW_PATH,
85	};	86	};
86		87

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

 };
 enum {
+	MLX5_FLEX_PARSER_GENEVE_ENABLED		= 1 << 3,
 	MLX5_FLEX_PARSER_VXLAN_GPE_ENABLED	= 1 << 7,
 	MLX5_FLEX_PARSER_ICMP_V4_ENABLED	= 1 << 8,
 	MLX5_FLEX_PARSER_ICMP_V6_ENABLED	= 1 << 9,
 	u8         log_max_srq[0x5];
 	u8         reserved_at_b0[0x10];
-	u8         reserved_at_c0[0x8];
+	u8         max_sgl_for_optimized_performance[0x8];
 	u8         log_max_cq_sz[0x8];
 	u8         reserved_at_d0[0xb];
 	u8         log_max_cq[0x5];

include/linux/mm.h+32−28

@@ -564,21 +564,6 @@ int vma_is_stack_for_current(struct vm_area_struct *vma); · 563 unmodified lines
564	struct mmu_gather;	564	struct mmu_gather;
565	struct inode;	565	struct inode;
566		566
567	#if !defined(CONFIG_ARCH_HAS_PTE_DEVMAP) \|\| !defined(CONFIG_TRANSPARENT_HUGEPAGE)
568	static inline int pmd_devmap(pmd_t pmd)
569	{
570	return 0;
571	}
572	static inline int pud_devmap(pud_t pud)
573	{
574	return 0;
575	}
576	static inline int pgd_devmap(pgd_t pgd)
577	{
578	return 0;
579	}
580	#endif
581
582	/*	567	/*
583	* FIXME: take this include out, include page-flags.h in	568	* FIXME: take this include out, include page-flags.h in
584	* files which need it (119 of them)	569	* files which need it (119 of them)
@@ -1643,19 +1628,27 @@ static inline unsigned long get_mm_counter(struct mm_struct *mm, int member) · 1058 unmodified lines
1643	return (unsigned long)val;	1628	return (unsigned long)val;
1644	}	1629	}
1645		1630
		1631	void mm_trace_rss_stat(struct mm_struct *mm, int member, long count);
		1632
1646	static inline void add_mm_counter(struct mm_struct *mm, int member, long value)	1633	static inline void add_mm_counter(struct mm_struct *mm, int member, long value)
1647	{	1634	{
1648	atomic_long_add(value, &mm->rss_stat.count[member]);	1635	long count = atomic_long_add_return(value, &mm->rss_stat.count[member]);
		1636
		1637	mm_trace_rss_stat(mm, member, count);
1649	}	1638	}
1650		1639
1651	static inline void inc_mm_counter(struct mm_struct *mm, int member)	1640	static inline void inc_mm_counter(struct mm_struct *mm, int member)
1652	{	1641	{
1653	atomic_long_inc(&mm->rss_stat.count[member]);	1642	long count = atomic_long_inc_return(&mm->rss_stat.count[member]);
		1643
		1644	mm_trace_rss_stat(mm, member, count);
1654	}	1645	}
1655		1646
1656	static inline void dec_mm_counter(struct mm_struct *mm, int member)	1647	static inline void dec_mm_counter(struct mm_struct *mm, int member)
1657	{	1648	{
1658	atomic_long_dec(&mm->rss_stat.count[member]);	1649	long count = atomic_long_dec_return(&mm->rss_stat.count[member]);
		1650
		1651	mm_trace_rss_stat(mm, member, count);
1659	}	1652	}
1660		1653
1661	/* Optimized variant when page is already known not to be PageAnon */	1654	/* Optimized variant when page is already known not to be PageAnon */
@@ -1845,12 +1838,12 @@ static inline void mm_dec_nr_ptes(struct mm_struct *mm) {} · 183 unmodified lines
1845	int __pte_alloc(struct mm_struct mm, pmd_t pmd);	1838	int __pte_alloc(struct mm_struct mm, pmd_t pmd);
1846	int __pte_alloc_kernel(pmd_t *pmd);	1839	int __pte_alloc_kernel(pmd_t *pmd);
1847		1840
		1841	#if defined(CONFIG_MMU)
		1842
1848	/*	1843	/*
1849	* The following ifdef needed to get the 4level-fixup.h header to work.	1844	* The following ifdef needed to get the 5level-fixup.h header to work.
1850	* Remove it when 4level-fixup.h has been removed.	1845	* Remove it when 5level-fixup.h has been removed.
1851	*/	1846	*/
1852	#if defined(CONFIG_MMU) && !defined(__ARCH_HAS_4LEVEL_HACK)
1853
1854	#ifndef __ARCH_HAS_5LEVEL_HACK	1847	#ifndef __ARCH_HAS_5LEVEL_HACK
1855	static inline p4d_t p4d_alloc(struct mm_struct mm, pgd_t *pgd,	1848	static inline p4d_t p4d_alloc(struct mm_struct mm, pgd_t *pgd,
1856	unsigned long address)	1849	unsigned long address)
@@ -1872,7 +1865,7 @@ static inline pmd_t pmd_alloc(struct mm_struct mm, pud_t *pud, unsigned long a · 15 unmodified lines
1872	return (unlikely(pud_none(*pud)) && __pmd_alloc(mm, pud, address))?	1865	return (unlikely(pud_none(*pud)) && __pmd_alloc(mm, pud, address))?
1873	NULL: pmd_offset(pud, address);	1866	NULL: pmd_offset(pud, address);
1874	}	1867	}
1875	#endif /* CONFIG_MMU && !__ARCH_HAS_4LEVEL_HACK */	1868	#endif /* CONFIG_MMU */
1876		1869
1877	#if USE_SPLIT_PTE_PTLOCKS	1870	#if USE_SPLIT_PTE_PTLOCKS
1878	#if ALLOC_SPLIT_PTLOCKS	1871	#if ALLOC_SPLIT_PTLOCKS
@@ -2214,9 +2207,6 @@ void warn_alloc(gfp_t gfp_mask, nodemask_t nodemask, const char fmt, ...); · 335 unmodified lines
2214		2207
2215	extern void setup_per_cpu_pageset(void);	2208	extern void setup_per_cpu_pageset(void);
2216		2209
2217	extern void zone_pcp_update(struct zone *zone);
2218	extern void zone_pcp_reset(struct zone *zone);
2219
2220	/* page_alloc.c */	2210	/* page_alloc.c */
2221	extern int min_free_kbytes;	2211	extern int min_free_kbytes;
2222	extern int watermark_boost_factor;	2212	extern int watermark_boost_factor;
@@ -2631,7 +2621,9 @@ static inline int vm_fault_to_errno(vm_fault_t vm_fault, int foll_flags) · 408 unmodified lines
2631	typedef int (pte_fn_t)(pte_t pte, unsigned long addr, void *data);	2621	typedef int (pte_fn_t)(pte_t pte, unsigned long addr, void *data);
2632	extern int apply_to_page_range(struct mm_struct *mm, unsigned long address,	2622	extern int apply_to_page_range(struct mm_struct *mm, unsigned long address,
2633	unsigned long size, pte_fn_t fn, void *data);	2623	unsigned long size, pte_fn_t fn, void *data);
2634		2624	extern int apply_to_existing_page_range(struct mm_struct *mm,
		2625	unsigned long address, unsigned long size,
		2626	pte_fn_t fn, void *data);
2635		2627
2636	#ifdef CONFIG_PAGE_POISONING	2628	#ifdef CONFIG_PAGE_POISONING
2637	extern bool page_poisoning_enabled(void);	2629	extern bool page_poisoning_enabled(void);
@@ -2781,7 +2773,7 @@ extern int sysctl_memory_failure_early_kill; · 143 unmodified lines
2781	extern int sysctl_memory_failure_recovery;	2773	extern int sysctl_memory_failure_recovery;
2782	extern void shake_page(struct page *p, int access);	2774	extern void shake_page(struct page *p, int access);
2783	extern atomic_long_t num_poisoned_pages __read_mostly;	2775	extern atomic_long_t num_poisoned_pages __read_mostly;
2784	extern int soft_offline_page(struct page *page, int flags);	2776	extern int soft_offline_page(unsigned long pfn, int flags);
2785		2777
2786		2778
2787	/*	2779	/*
@@ -2873,5 +2865,17 @@ static inline int pages_identical(struct page page1, struct page page2) · 85 unmodified lines
2873	return !memcmp_pages(page1, page2);	2865	return !memcmp_pages(page1, page2);
2874	}	2866	}
2875		2867
		2868	#ifdef CONFIG_MAPPING_DIRTY_HELPERS
		2869	unsigned long clean_record_shared_mapping_range(struct address_space *mapping,
		2870	pgoff_t first_index, pgoff_t nr,
		2871	pgoff_t bitmap_pgoff,
		2872	unsigned long *bitmap,
		2873	pgoff_t *start,
		2874	pgoff_t *end);
		2875
		2876	unsigned long wp_shared_mapping_range(struct address_space *mapping,
		2877	pgoff_t first_index, pgoff_t nr);
		2878	#endif
		2879
2876	#endif /* __KERNEL__ */	2880	#endif /* __KERNEL__ */
2877	#endif /* _LINUX_MM_H */	2881	#endif /* _LINUX_MM_H */

include/linux/mmc/card.h+2−1

  * MMC Physical partitions
  */
 struct mmc_part {
-	unsigned int	size;	/* partition size (in bytes) */
+	u64		size;	/* partition size (in bytes) */
 	unsigned int	part_cfg;	/* partition type */
 	char	name[MAX_MMC_PART_NAME_LEN];
 	bool	force_ro;	/* to make boot parts RO by default */
 	struct sd_switch_caps	sw_caps;	/* switch (CMD6) caps */
 	unsigned int		sdio_funcs;	/* number of SDIO functions */
+	atomic_t		sdio_funcs_probed; /* number of probed SDIO funcs */
 	struct sdio_cccr	cccr;		/* common card info */
 	struct sdio_cis		cis;		/* common tuple info */
 	struct sdio_func	*sdio_func[SDIO_MAX_FUNCS]; /* SDIO functions (devices) */

include/linux/mmc/sdio_ids.h+2−0

@@ -71,6 +71,8 @@ · 70 unmodified lines
71		71
72	#define SDIO_VENDOR_ID_TI 0x0097	72	#define SDIO_VENDOR_ID_TI 0x0097
73	#define SDIO_DEVICE_ID_TI_WL1271 0x4076	73	#define SDIO_DEVICE_ID_TI_WL1271 0x4076
		74	#define SDIO_VENDOR_ID_TI_WL1251 0x104c
		75	#define SDIO_DEVICE_ID_TI_WL1251 0x9066
74		76
75	#define SDIO_VENDOR_ID_STE 0x0020	77	#define SDIO_VENDOR_ID_STE 0x0020
76	#define SDIO_DEVICE_ID_STE_CW1200 0x2280	78	#define SDIO_DEVICE_ID_STE_CW1200 0x2280

include/linux/mmu_notifier.h+118−29

@@ -6,9 +6,12 @@ · 5 unmodified lines
6	#include <linux/spinlock.h>	6	#include <linux/spinlock.h>
7	#include <linux/mm_types.h>	7	#include <linux/mm_types.h>
8	#include <linux/srcu.h>	8	#include <linux/srcu.h>
		9	#include <linux/interval_tree.h>
9		10
		11	struct mmu_notifier_mm;
10	struct mmu_notifier;	12	struct mmu_notifier;
11	struct mmu_notifier_ops;	13	struct mmu_notifier_range;
		14	struct mmu_interval_notifier;
12		15
13	/**	16	/**
14	* enum mmu_notifier_event - reason for the mmu notifier callback	17	* enum mmu_notifier_event - reason for the mmu notifier callback
@@ -31,6 +34,9 @@ struct mmu_notifier_ops; · 16 unmodified lines
31	* access flags). User should soft dirty the page in the end callback to make	34	* access flags). User should soft dirty the page in the end callback to make
32	* sure that anyone relying on soft dirtyness catch pages that might be written	35	* sure that anyone relying on soft dirtyness catch pages that might be written
33	* through non CPU mappings.	36	* through non CPU mappings.
		37	*
		38	* @MMU_NOTIFY_RELEASE: used during mmu_interval_notifier invalidate to signal
		39	* that the mm refcount is zero and the range is no longer accessible.
34	*/	40	*/
35	enum mmu_notifier_event {	41	enum mmu_notifier_event {
36	MMU_NOTIFY_UNMAP = 0,	42	MMU_NOTIFY_UNMAP = 0,
@@ -38,38 +44,11 @@ enum mmu_notifier_event { · 1 unmodified line
38	MMU_NOTIFY_PROTECTION_VMA,	44	MMU_NOTIFY_PROTECTION_VMA,
39	MMU_NOTIFY_PROTECTION_PAGE,	45	MMU_NOTIFY_PROTECTION_PAGE,
40	MMU_NOTIFY_SOFT_DIRTY,	46	MMU_NOTIFY_SOFT_DIRTY,
41	};	47	MMU_NOTIFY_RELEASE,
42
43	#ifdef CONFIG_MMU_NOTIFIER
44
45	#ifdef CONFIG_LOCKDEP
46	extern struct lockdep_map __mmu_notifier_invalidate_range_start_map;
47	#endif
48
49	/*
50	* The mmu notifier_mm structure is allocated and installed in
51	* mm->mmu_notifier_mm inside the mm_take_all_locks() protected
52	* critical section and it's released only when mm_count reaches zero
53	* in mmdrop().
54	*/
55	struct mmu_notifier_mm {
56	/* all mmu notifiers registerd in this mm are queued in this list */
57	struct hlist_head list;
58	/* to serialize the list modifications and hlist_unhashed */
59	spinlock_t lock;
60	};	48	};
61		49
62	#define MMU_NOTIFIER_RANGE_BLOCKABLE (1 << 0)	50	#define MMU_NOTIFIER_RANGE_BLOCKABLE (1 << 0)
63		51
64	struct mmu_notifier_range {
65	struct vm_area_struct *vma;
66	struct mm_struct *mm;
67	unsigned long start;
68	unsigned long end;
69	unsigned flags;
70	enum mmu_notifier_event event;
71	};
72
73	struct mmu_notifier_ops {	52	struct mmu_notifier_ops {
74	/*	53	/*
75	* Called either by mmu_notifier_unregister or when the mm is	54	* Called either by mmu_notifier_unregister or when the mm is
@@ -249,6 +228,41 @@ struct mmu_notifier { · 173 unmodified lines
249	unsigned int users;	228	unsigned int users;
250	};	229	};
251		230
		231	/**
		232	* struct mmu_interval_notifier_ops
		233	* @invalidate: Upon return the caller must stop using any SPTEs within this
		234	* range. This function can sleep. Return false only if sleeping
		235	* was required but mmu_notifier_range_blockable(range) is false.
		236	*/
		237	struct mmu_interval_notifier_ops {
		238	bool (invalidate)(struct mmu_interval_notifier mni,
		239	const struct mmu_notifier_range *range,
		240	unsigned long cur_seq);
		241	};
		242
		243	struct mmu_interval_notifier {
		244	struct interval_tree_node interval_tree;
		245	const struct mmu_interval_notifier_ops *ops;
		246	struct mm_struct *mm;
		247	struct hlist_node deferred_item;
		248	unsigned long invalidate_seq;
		249	};
		250
		251	#ifdef CONFIG_MMU_NOTIFIER
		252
		253	#ifdef CONFIG_LOCKDEP
		254	extern struct lockdep_map __mmu_notifier_invalidate_range_start_map;
		255	#endif
		256
		257	struct mmu_notifier_range {
		258	struct vm_area_struct *vma;
		259	struct mm_struct *mm;
		260	unsigned long start;
		261	unsigned long end;
		262	unsigned flags;
		263	enum mmu_notifier_event event;
		264	};
		265
252	static inline int mm_has_notifiers(struct mm_struct *mm)	266	static inline int mm_has_notifiers(struct mm_struct *mm)
253	{	267	{
254	return unlikely(mm->mmu_notifier_mm);	268	return unlikely(mm->mmu_notifier_mm);
@@ -275,6 +289,81 @@ extern int __mmu_notifier_register(struct mmu_notifier *mn, · 20 unmodified lines
275	struct mm_struct *mm);	289	struct mm_struct *mm);
276	extern void mmu_notifier_unregister(struct mmu_notifier *mn,	290	extern void mmu_notifier_unregister(struct mmu_notifier *mn,
277	struct mm_struct *mm);	291	struct mm_struct *mm);
		292
		293	unsigned long mmu_interval_read_begin(struct mmu_interval_notifier *mni);
		294	int mmu_interval_notifier_insert(struct mmu_interval_notifier *mni,
		295	struct mm_struct *mm, unsigned long start,
		296	unsigned long length,
		297	const struct mmu_interval_notifier_ops *ops);
		298	int mmu_interval_notifier_insert_locked(
		299	struct mmu_interval_notifier mni, struct mm_struct mm,
		300	unsigned long start, unsigned long length,
		301	const struct mmu_interval_notifier_ops *ops);
		302	void mmu_interval_notifier_remove(struct mmu_interval_notifier *mni);
		303
		304	/**
		305	* mmu_interval_set_seq - Save the invalidation sequence
		306	* @mni - The mni passed to invalidate
		307	* @cur_seq - The cur_seq passed to the invalidate() callback
		308	*
		309	* This must be called unconditionally from the invalidate callback of a
		310	* struct mmu_interval_notifier_ops under the same lock that is used to call
		311	* mmu_interval_read_retry(). It updates the sequence number for later use by
		312	* mmu_interval_read_retry(). The provided cur_seq will always be odd.
		313	*
		314	* If the caller does not call mmu_interval_read_begin() or
		315	* mmu_interval_read_retry() then this call is not required.
		316	*/
		317	static inline void mmu_interval_set_seq(struct mmu_interval_notifier *mni,
		318	unsigned long cur_seq)
		319	{
		320	WRITE_ONCE(mni->invalidate_seq, cur_seq);
		321	}
		322
		323	/**
		324	* mmu_interval_read_retry - End a read side critical section against a VA range
		325	* mni: The range
		326	* seq: The return of the paired mmu_interval_read_begin()
		327	*
		328	* This MUST be called under a user provided lock that is also held
		329	* unconditionally by op->invalidate() when it calls mmu_interval_set_seq().
		330	*
		331	* Each call should be paired with a single mmu_interval_read_begin() and
		332	* should be used to conclude the read side.
		333	*
		334	* Returns true if an invalidation collided with this critical section, and
		335	* the caller should retry.
		336	*/
		337	static inline bool mmu_interval_read_retry(struct mmu_interval_notifier *mni,
		338	unsigned long seq)
		339	{
		340	return mni->invalidate_seq != seq;
		341	}
		342
		343	/**
		344	* mmu_interval_check_retry - Test if a collision has occurred
		345	* mni: The range
		346	* seq: The return of the matching mmu_interval_read_begin()
		347	*
		348	* This can be used in the critical section between mmu_interval_read_begin()
		349	* and mmu_interval_read_retry(). A return of true indicates an invalidation
		350	* has collided with this critical region and a future
		351	* mmu_interval_read_retry() will return true.
		352	*
		353	* False is not reliable and only suggests a collision may not have
		354	* occured. It can be called many times and does not have to hold the user
		355	* provided lock.
		356	*
		357	* This call can be used as part of loops and other expensive operations to
		358	* expedite a retry.
		359	*/
		360	static inline bool mmu_interval_check_retry(struct mmu_interval_notifier *mni,
		361	unsigned long seq)
		362	{
		363	/* Pairs with the WRITE_ONCE in mmu_interval_set_seq() */
		364	return READ_ONCE(mni->invalidate_seq) != seq;
		365	}
		366
278	extern void __mmu_notifier_mm_destroy(struct mm_struct *mm);	367	extern void __mmu_notifier_mm_destroy(struct mm_struct *mm);
279	extern void __mmu_notifier_release(struct mm_struct *mm);	368	extern void __mmu_notifier_release(struct mm_struct *mm);
280	extern int __mmu_notifier_clear_flush_young(struct mm_struct *mm,	369	extern int __mmu_notifier_clear_flush_young(struct mm_struct *mm,

include/linux/mmzone.h+46−33

@@ -273,12 +273,12 @@ enum lru_list { · 272 unmodified lines
273		273
274	#define for_each_evictable_lru(lru) for (lru = 0; lru <= LRU_ACTIVE_FILE; lru++)	274	#define for_each_evictable_lru(lru) for (lru = 0; lru <= LRU_ACTIVE_FILE; lru++)
275		275
276	static inline int is_file_lru(enum lru_list lru)	276	static inline bool is_file_lru(enum lru_list lru)
277	{	277	{
278	return (lru == LRU_INACTIVE_FILE \|\| lru == LRU_ACTIVE_FILE);	278	return (lru == LRU_INACTIVE_FILE \|\| lru == LRU_ACTIVE_FILE);
279	}	279	}
280		280
281	static inline int is_active_lru(enum lru_list lru)	281	static inline bool is_active_lru(enum lru_list lru)
282	{	282	{
283	return (lru == LRU_ACTIVE_ANON \|\| lru == LRU_ACTIVE_FILE);	283	return (lru == LRU_ACTIVE_ANON \|\| lru == LRU_ACTIVE_FILE);
284	}	284	}
@@ -296,6 +296,12 @@ struct zone_reclaim_stat { · 11 unmodified lines
296	unsigned long recent_scanned[2];	296	unsigned long recent_scanned[2];
297	};	297	};
298		298
		299	enum lruvec_flags {
		300	LRUVEC_CONGESTED, /* lruvec has many dirty pages
		301	* backed by a congested BDI
		302	*/
		303	};
		304
299	struct lruvec {	305	struct lruvec {
300	struct list_head lists[NR_LRU_LISTS];	306	struct list_head lists[NR_LRU_LISTS];
301	struct zone_reclaim_stat reclaim_stat;	307	struct zone_reclaim_stat reclaim_stat;
@@ -303,12 +309,14 @@ struct lruvec { · 1 unmodified line
303	atomic_long_t inactive_age;	309	atomic_long_t inactive_age;
304	/* Refaults at the time of last reclaim cycle */	310	/* Refaults at the time of last reclaim cycle */
305	unsigned long refaults;	311	unsigned long refaults;
		312	/* Various lruvec state flags (enum lruvec_flags) */
		313	unsigned long flags;
306	#ifdef CONFIG_MEMCG	314	#ifdef CONFIG_MEMCG
307	struct pglist_data *pgdat;	315	struct pglist_data *pgdat;
308	#endif	316	#endif
309	};	317	};
310		318
311	/* Isolate unmapped file */	319	/* Isolate unmapped pages */
312	#define ISOLATE_UNMAPPED ((__force isolate_mode_t)0x2)	320	#define ISOLATE_UNMAPPED ((__force isolate_mode_t)0x2)
313	/* Isolate for asynchronous migration */	321	/* Isolate for asynchronous migration */
314	#define ISOLATE_ASYNC_MIGRATE ((__force isolate_mode_t)0x4)	322	#define ISOLATE_ASYNC_MIGRATE ((__force isolate_mode_t)0x4)
@@ -359,33 +367,40 @@ struct per_cpu_nodestat { · 44 unmodified lines
359	#endif /* !__GENERATING_BOUNDS.H */	367	#endif /* !__GENERATING_BOUNDS.H */
360		368
361	enum zone_type {	369	enum zone_type {
362	#ifdef CONFIG_ZONE_DMA
363	/*	370	/*
364	* ZONE_DMA is used when there are devices that are not able	371	* ZONE_DMA and ZONE_DMA32 are used when there are peripherals not able
365	* to do DMA to all of addressable memory (ZONE_NORMAL). Then we	372	* to DMA to all of the addressable memory (ZONE_NORMAL).
366	* carve out the portion of memory that is needed for these devices.	373	* On architectures where this area covers the whole 32 bit address
367	* The range is arch specific.	374	* space ZONE_DMA32 is used. ZONE_DMA is left for the ones with smaller
		375	* DMA addressing constraints. This distinction is important as a 32bit
		376	* DMA mask is assumed when ZONE_DMA32 is defined. Some 64-bit
		377	* platforms may need both zones as they support peripherals with
		378	* different DMA addressing limitations.
		379	*
		380	* Some examples:
		381	*
		382	* - i386 and x86_64 have a fixed 16M ZONE_DMA and ZONE_DMA32 for the
		383	* rest of the lower 4G.
368	*	384	*
369	* Some examples	385	* - arm only uses ZONE_DMA, the size, up to 4G, may vary depending on
		386	* the specific device.
370	*	387	*
371	* Architecture Limit	388	* - arm64 has a fixed 1G ZONE_DMA and ZONE_DMA32 for the rest of the
372	* ---------------------------	389	* lower 4G.
373	* parisc, ia64, sparc <4G
374	* s390, powerpc <2G
375	* arm Various
376	* alpha Unlimited or 0-16MB.
377	*	390	*
378	* i386, x86_64 and multiple other arches	391	* - powerpc only uses ZONE_DMA, the size, up to 2G, may vary
379	* <16M.	392	* depending on the specific device.
		393	*
		394	* - s390 uses ZONE_DMA fixed to the lower 2G.
		395	*
		396	* - ia64 and riscv only use ZONE_DMA32.
		397	*
		398	* - parisc uses neither.
380	*/	399	*/
		400	#ifdef CONFIG_ZONE_DMA
381	ZONE_DMA,	401	ZONE_DMA,
382	#endif	402	#endif
383	#ifdef CONFIG_ZONE_DMA32	403	#ifdef CONFIG_ZONE_DMA32
384	/*
385	* x86_64 needs two ZONE_DMAs because it supports devices that are
386	* only able to do DMA to the lower 16M but also 32 bit devices that
387	* can only do DMA areas below 4G.
388	*/
389	ZONE_DMA32,	404	ZONE_DMA32,
390	#endif	405	#endif
391	/*	406	/*
@@ -565,9 +580,6 @@ struct zone { · 173 unmodified lines
565	} ____cacheline_internodealigned_in_smp;	580	} ____cacheline_internodealigned_in_smp;
566		581
567	enum pgdat_flags {	582	enum pgdat_flags {
568	PGDAT_CONGESTED, /* pgdat has many dirty pages backed by
569	* a congested BDI
570	*/
571	PGDAT_DIRTY, /* reclaim scanning has recently found	583	PGDAT_DIRTY, /* reclaim scanning has recently found
572	* many dirty file pages at the tail	584	* many dirty file pages at the tail
573	* of the LRU.	585	* of the LRU.
@@ -770,7 +782,13 @@ typedef struct pglist_data { · 196 unmodified lines
770	#endif	782	#endif
771		783
772	/* Fields commonly accessed by the page reclaim scanner */	784	/* Fields commonly accessed by the page reclaim scanner */
773	struct lruvec lruvec;	785
		786	/*
		787	* NOTE: THIS IS UNUSED IF MEMCG IS ENABLED.
		788	*
		789	* Use mem_cgroup_lruvec() to look up lruvecs.
		790	*/
		791	struct lruvec __lruvec;
774		792
775	unsigned long flags;	793	unsigned long flags;
776		794
@@ -793,11 +811,6 @@ typedef struct pglist_data { · 16 unmodified lines
793	#define node_start_pfn(nid) (NODE_DATA(nid)->node_start_pfn)	811	#define node_start_pfn(nid) (NODE_DATA(nid)->node_start_pfn)
794	#define node_end_pfn(nid) pgdat_end_pfn(NODE_DATA(nid))	812	#define node_end_pfn(nid) pgdat_end_pfn(NODE_DATA(nid))
795		813
796	static inline struct lruvec node_lruvec(struct pglist_data pgdat)
797	{
798	return &pgdat->lruvec;
799	}
800
801	static inline unsigned long pgdat_end_pfn(pg_data_t *pgdat)	814	static inline unsigned long pgdat_end_pfn(pg_data_t *pgdat)
802	{	815	{
803	return pgdat->node_start_pfn + pgdat->node_spanned_pages;	816	return pgdat->node_start_pfn + pgdat->node_spanned_pages;
@@ -835,7 +848,7 @@ static inline struct pglist_data lruvec_pgdat(struct lruvec lruvec) · 31 unmodified lines
835	#ifdef CONFIG_MEMCG	848	#ifdef CONFIG_MEMCG
836	return lruvec->pgdat;	849	return lruvec->pgdat;
837	#else	850	#else
838	return container_of(lruvec, struct pglist_data, lruvec);	851	return container_of(lruvec, struct pglist_data, __lruvec);
839	#endif	852	#endif
840	}	853	}
841		854
@@ -1072,7 +1085,7 @@ static inline struct zoneref first_zones_zonelist(struct zonelist zonelist, · 230 unmodified lines
1072	/**	1085	/**
1073	* for_each_zone_zonelist_nodemask - helper macro to iterate over valid zones in a zonelist at or below a given zone index and within a nodemask	1086	* for_each_zone_zonelist_nodemask - helper macro to iterate over valid zones in a zonelist at or below a given zone index and within a nodemask
1074	* @zone - The current zone in the iterator	1087	* @zone - The current zone in the iterator
1075	* @z - The current pointer within zonelist->zones being iterated	1088	* @z - The current pointer within zonelist->_zonerefs being iterated
1076	* @zlist - The zonelist being iterated	1089	* @zlist - The zonelist being iterated
1077	* @highidx - The zone index of the highest zone to return	1090	* @highidx - The zone index of the highest zone to return
1078	* @nodemask - Nodemask allowed by the allocator	1091	* @nodemask - Nodemask allowed by the allocator

include/linux/mod_devicetable.h+2−2

@@ -587,9 +587,9 @@ struct platform_device_id { · 586 unmodified lines
587	#define MDIO_NAME_SIZE 32	587	#define MDIO_NAME_SIZE 32
588	#define MDIO_MODULE_PREFIX "mdio:"	588	#define MDIO_MODULE_PREFIX "mdio:"
589		589
590	#define MDIO_ID_FMT "%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d"	590	#define MDIO_ID_FMT "%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u%u"
591	#define MDIO_ID_ARGS(_id) \	591	#define MDIO_ID_ARGS(_id) \
592	(_id)>>31, ((_id)>>30) & 1, ((_id)>>29) & 1, ((_id)>>28) & 1, \	592	((_id)>>31) & 1, ((_id)>>30) & 1, ((_id)>>29) & 1, ((_id)>>28) & 1, \
593	((_id)>>27) & 1, ((_id)>>26) & 1, ((_id)>>25) & 1, ((_id)>>24) & 1, \	593	((_id)>>27) & 1, ((_id)>>26) & 1, ((_id)>>25) & 1, ((_id)>>24) & 1, \
594	((_id)>>23) & 1, ((_id)>>22) & 1, ((_id)>>21) & 1, ((_id)>>20) & 1, \	594	((_id)>>23) & 1, ((_id)>>22) & 1, ((_id)>>21) & 1, ((_id)>>20) & 1, \
595	((_id)>>19) & 1, ((_id)>>18) & 1, ((_id)>>17) & 1, ((_id)>>16) & 1, \	595	((_id)>>19) & 1, ((_id)>>18) & 1, ((_id)>>17) & 1, ((_id)>>16) & 1, \

include/linux/module.h+5−2

-#ifndef _LINUX_MODULE_H
+/* SPDX-License-Identifier: GPL-2.0-only */
-#define _LINUX_MODULE_H
 /*
  * Dynamic loading of modules into the kernel.
  *
  * Rewritten by Richard Henderson <rth@tamu.edu> Dec 1996
  * Rewritten again by Rusty Russell, 2002
  */
+#ifndef _LINUX_MODULE_H
+#define _LINUX_MODULE_H
 #include <linux/list.h>
 #include <linux/stat.h>
 #include <linux/compiler.h>

include/linux/moduleloader.h+1−1

@@ -91,7 +91,7 @@ void module_arch_cleanup(struct module *mod); · 90 unmodified lines
91	/* Any cleanup before freeing mod->module_init */	91	/* Any cleanup before freeing mod->module_init */
92	void module_arch_freeing_init(struct module *mod);	92	void module_arch_freeing_init(struct module *mod);
93		93
94	#ifdef CONFIG_KASAN	94	#if defined(CONFIG_KASAN) && !defined(CONFIG_KASAN_VMALLOC)
95	#include <linux/kasan.h>	95	#include <linux/kasan.h>
96	#define MODULE_ALIGN (PAGE_SIZE << KASAN_SHADOW_SCALE_SHIFT)	96	#define MODULE_ALIGN (PAGE_SIZE << KASAN_SHADOW_SCALE_SHIFT)
97	#else	97	#else

include/linux/moduleparam.h+2−2

@@ -100,11 +100,11 @@ struct kparam_array · 99 unmodified lines
100		100
101	/**	101	/**
102	* module_param - typesafe helper for a module/cmdline parameter	102	* module_param - typesafe helper for a module/cmdline parameter
103	* @value: the variable to alter, and exposed parameter name.	103	* @name: the variable to alter, and exposed parameter name.
104	* @type: the type of the parameter	104	* @type: the type of the parameter
105	* @perm: visibility in sysfs.	105	* @perm: visibility in sysfs.
106	*	106	*
107	* @value becomes the module parameter, or (prefixed by KBUILD_MODNAME and a	107	* @name becomes the module parameter, or (prefixed by KBUILD_MODNAME and a
108	* ".") the kernel commandline parameter. Note that - is changed to _, so	108	* ".") the kernel commandline parameter. Note that - is changed to _, so
109	* the user can use "foo-bar=1" even for variable "foo_bar".	109	* the user can use "foo-bar=1" even for variable "foo_bar".
110	*	110	*

include/linux/mroute_base.h+14−14

 };
 static inline int mr_call_vif_notifier(struct notifier_block *nb,
-				       struct net *net,
 				       unsigned short family,
 				       enum fib_event_type event_type,
 				       struct vif_device *vif,
-				       unsigned short vif_index, u32 tb_id)
+				       unsigned short vif_index, u32 tb_id,
+				       struct netlink_ext_ack *extack)
 {
 	struct vif_entry_notifier_info info = {
 		.info = {
 			.family = family,
-			.net = net,
+			.extack = extack,
 		},
 		.dev = vif->dev,
 		.vif_index = vif_index,
 		.tb_id = tb_id,
 	};
-	return call_fib_notifier(nb, net, event_type, &info.info);
+	return call_fib_notifier(nb, event_type, &info.info);
 }
 static inline int mr_call_vif_notifiers(struct net *net,
 	struct vif_entry_notifier_info info = {
 		.info = {
 			.family = family,
-			.net = net,
 		},
 		.dev = vif->dev,
 		.vif_index = vif_index,
 };
 static inline int mr_call_mfc_notifier(struct notifier_block *nb,
-				       struct net *net,
 				       unsigned short family,
 				       enum fib_event_type event_type,
-				       struct mr_mfc *mfc, u32 tb_id)
+				       struct mr_mfc *mfc, u32 tb_id,
+				       struct netlink_ext_ack *extack)
 {
 	struct mfc_entry_notifier_info info = {
 		.info = {
 			.family = family,
-			.net = net,
+			.extack = extack,
 		},
 		.mfc = mfc,
 		.tb_id = tb_id
 	};
-	return call_fib_notifier(nb, net, event_type, &info.info);
+	return call_fib_notifier(nb, event_type, &info.info);
 }
 static inline int mr_call_mfc_notifiers(struct net *net,
 	struct mfc_entry_notifier_info info = {
 		.info = {
 			.family = family,
-			.net = net,
 		},
 		.mfc = mfc,
 		.tb_id = tb_id
 int mr_dump(struct net *net, struct notifier_block *nb, unsigned short family,
 	    int (*rules_dump)(struct net *net,
-			      struct notifier_block *nb),
+			      struct notifier_block *nb,
+			      struct netlink_ext_ack *extack),
 	    struct mr_table *(*mr_iter)(struct net *net,
 					struct mr_table *mrt),
-	    rwlock_t *mrt_lock);
+	    rwlock_t *mrt_lock, struct netlink_ext_ack *extack);
 #else
 static inline void vif_device_init(struct vif_device *v,
 				   struct net_device *dev,
 static inline int mr_dump(struct net *net, struct notifier_block *nb,
 			  unsigned short family,
 			  int (*rules_dump)(struct net *net,
-					    struct notifier_block *nb),
+					    struct notifier_block *nb,
+					    struct netlink_ext_ack *extack),
 			  struct mr_table *(*mr_iter)(struct net *net,
 						      struct mr_table *mrt),
-			  rwlock_t *mrt_lock)
+			  rwlock_t *mrt_lock, struct netlink_ext_ack *extack)
 {
 	return -EINVAL;
 }

include/linux/mtd/spi-nor.h+36−28

 #define SNOR_MFR_INTEL		CFI_MFR_INTEL
 #define SNOR_MFR_ST		CFI_MFR_ST	/* ST Micro */
 #define SNOR_MFR_MICRON		CFI_MFR_MICRON	/* Micron */
+#define SNOR_MFR_ISSI		CFI_MFR_PMC
 #define SNOR_MFR_MACRONIX	CFI_MFR_MACRONIX
 #define SNOR_MFR_SPANSION	CFI_MFR_AMD
 #define SNOR_MFR_SST		CFI_MFR_SST
 #define SR_E_ERR		BIT(5)
 #define SR_P_ERR		BIT(6)
-#define SR_QUAD_EN_MX		BIT(6)	/* Macronix Quad I/O */
+#define SR1_QUAD_EN_BIT6	BIT(6)
 /* Enhanced Volatile Configuration Register bits */
 #define EVCR_QUAD_EN_MICRON	BIT(7)	/* Micron Quad I/O */
 #define FSR_P_ERR		BIT(4)	/* Program operation status */
 #define FSR_PT_ERR		BIT(1)	/* Protection error bit */
-/* Configuration Register bits. */
-#define CR_QUAD_EN_SPAN		BIT(1)	/* Spansion Quad I/O */
 /* Status Register 2 bits. */
+#define SR2_QUAD_EN_BIT1	BIT(1)
 #define SR2_QUAD_EN_BIT7	BIT(7)
 /* Supported SPI protocols */
 	SNOR_F_4B_OPCODES	= BIT(6),
 	SNOR_F_HAS_4BAIT	= BIT(7),
 	SNOR_F_HAS_LOCK		= BIT(8),
+	SNOR_F_HAS_16BIT_SR	= BIT(9),
+	SNOR_F_NO_READ_CR	= BIT(10),
 };
 /**
 /* Forward declaration that will be used in 'struct spi_nor_flash_parameter' */
 struct spi_nor;
+/**
+ * struct spi_nor_controller_ops - SPI NOR controller driver specific
+ *                                 operations.
+ * @prepare:		[OPTIONAL] do some preparations for the
+ *			read/write/erase/lock/unlock operations.
+ * @unprepare:		[OPTIONAL] do some post work after the
+ *			read/write/erase/lock/unlock operations.
+ * @read_reg:		read out the register.
+ * @write_reg:		write data to the register.
+ * @read:		read data from the SPI NOR.
+ * @write:		write data to the SPI NOR.
+ * @erase:		erase a sector of the SPI NOR at the offset @offs; if
+ *			not provided by the driver, spi-nor will send the erase
+ *			opcode via write_reg().
+ */
+struct spi_nor_controller_ops {
+	int (*prepare)(struct spi_nor *nor, enum spi_nor_ops ops);
+	void (*unprepare)(struct spi_nor *nor, enum spi_nor_ops ops);
+	int (*read_reg)(struct spi_nor *nor, u8 opcode, u8 *buf, size_t len);
+	int (*write_reg)(struct spi_nor *nor, u8 opcode, const u8 *buf,
+			 size_t len);
+	ssize_t (*read)(struct spi_nor *nor, loff_t from, size_t len, u8 *buf);
+	ssize_t (*write)(struct spi_nor *nor, loff_t to, size_t len,
+			 const u8 *buf);
+	int (*erase)(struct spi_nor *nor, loff_t offs);
+};
 /**
  * struct spi_nor_locking_ops - SPI NOR locking methods
  * @lock:	lock a region of the SPI NOR.
  * @read_proto:		the SPI protocol for read operations
  * @write_proto:	the SPI protocol for write operations
  * @reg_proto		the SPI protocol for read_reg/write_reg/erase operations
- * @prepare:		[OPTIONAL] do some preparations for the
+ * @controller_ops:	SPI NOR controller driver specific operations.
- *			read/write/erase/lock/unlock operations
- * @unprepare:		[OPTIONAL] do some post work after the
- *			read/write/erase/lock/unlock operations
- * @read_reg:		[DRIVER-SPECIFIC] read out the register
- * @write_reg:		[DRIVER-SPECIFIC] write data to the register
- * @read:		[DRIVER-SPECIFIC] read data from the SPI NOR
- * @write:		[DRIVER-SPECIFIC] write data to the SPI NOR
- * @erase:		[DRIVER-SPECIFIC] erase a sector of the SPI NOR
- *			at the offset @offs; if not provided by the driver,
- *			spi-nor will send the erase opcode via write_reg()
- * @clear_sr_bp:	[FLASH-SPECIFIC] clears the Block Protection Bits from
- *			the SPI NOR Status Register.
  * @params:		[FLASH-SPECIFIC] SPI-NOR flash parameters and settings.
  *                      The structure includes legacy flash parameters and
  *                      settings that can be overwritten by the spi_nor_fixups
 	bool			sst_write_second;
 	u32			flags;
-	int (*prepare)(struct spi_nor *nor, enum spi_nor_ops ops);
+	const struct spi_nor_controller_ops *controller_ops;
-	void (*unprepare)(struct spi_nor *nor, enum spi_nor_ops ops);
-	int (*read_reg)(struct spi_nor *nor, u8 opcode, u8 *buf, int len);
-	int (*write_reg)(struct spi_nor *nor, u8 opcode, u8 *buf, int len);
-	ssize_t (*read)(struct spi_nor *nor, loff_t from,
-			size_t len, u_char *read_buf);
-	ssize_t (*write)(struct spi_nor *nor, loff_t to,
-			size_t len, const u_char *write_buf);
-	int (*erase)(struct spi_nor *nor, loff_t offs);
-	int (*clear_sr_bp)(struct spi_nor *nor);
 	struct spi_nor_flash_parameter params;
 	void *priv;

include/linux/mtio.h+60−0

@@ -0,0 +1,60 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef _LINUX_MTIO_COMPAT_H
	3	#define _LINUX_MTIO_COMPAT_H
	4
	5	#include <linux/compat.h>
	6	#include <uapi/linux/mtio.h>
	7	#include <linux/uaccess.h>
	8
	9	/*
	10	* helper functions for implementing compat ioctls on the four tape
	11	* drivers: we define the 32-bit layout of each incompatible structure,
	12	* plus a wrapper function to copy it to user space in either format.
	13	*/
	14
	15	struct mtget32 {
	16	s32 mt_type;
	17	s32 mt_resid;
	18	s32 mt_dsreg;
	19	s32 mt_gstat;
	20	s32 mt_erreg;
	21	s32 mt_fileno;
	22	s32 mt_blkno;
	23	};
	24	#define MTIOCGET32 _IOR('m', 2, struct mtget32)
	25
	26	struct mtpos32 {
	27	s32 mt_blkno;
	28	};
	29	#define MTIOCPOS32 _IOR('m', 3, struct mtpos32)
	30
	31	static inline int put_user_mtget(void __user u, struct mtget k)
	32	{
	33	struct mtget32 k32 = {
	34	.mt_type = k->mt_type,
	35	.mt_resid = k->mt_resid,
	36	.mt_dsreg = k->mt_dsreg,
	37	.mt_gstat = k->mt_gstat,
	38	.mt_erreg = k->mt_erreg,
	39	.mt_fileno = k->mt_fileno,
	40	.mt_blkno = k->mt_blkno,
	41	};
	42	int ret;
	43
	44	if (in_compat_syscall())
	45	ret = copy_to_user(u, &k32, sizeof(k32));
	46	else
	47	ret = copy_to_user(u, k, sizeof(*k));
	48
	49	return ret ? -EFAULT : 0;
	50	}
	51
	52	static inline int put_user_mtpos(void __user u, struct mtpos k)
	53	{
	54	if (in_compat_syscall())
	55	return put_user(k->mt_blkno, (u32 __user *)u);
	56	else
	57	return put_user(k->mt_blkno, (long __user *)u);
	58	}
	59
	60	#endif

include/linux/namei.h+1−0

@@ -60,6 +60,7 @@ extern int kern_path_mountpoint(int, const char , struct path , unsigned int); · 59 unmodified lines
60	extern struct dentry try_lookup_one_len(const char , struct dentry *, int);	60	extern struct dentry try_lookup_one_len(const char , struct dentry *, int);
61	extern struct dentry lookup_one_len(const char , struct dentry *, int);	61	extern struct dentry lookup_one_len(const char , struct dentry *, int);
62	extern struct dentry lookup_one_len_unlocked(const char , struct dentry *, int);	62	extern struct dentry lookup_one_len_unlocked(const char , struct dentry *, int);
		63	extern struct dentry lookup_positive_unlocked(const char , struct dentry *, int);
63		64
64	extern int follow_down_one(struct path *);	65	extern int follow_down_one(struct path *);
65	extern int follow_down(struct path *);	66	extern int follow_down(struct path *);

include/linux/nd.h+1−1

@@ -147,7 +147,7 @@ static inline int nvdimm_read_bytes(struct nd_namespace_common *ndns, · 146 unmodified lines
147		147
148	/**	148	/**
149	* nvdimm_write_bytes() - synchronously write bytes to an nvdimm namespace	149	* nvdimm_write_bytes() - synchronously write bytes to an nvdimm namespace
150	* @ndns: device to read	150	* @ndns: device to write
151	* @offset: namespace-relative starting offset	151	* @offset: namespace-relative starting offset
152	* @buf: buffer to drain	152	* @buf: buffer to drain
153	* @size: transfer length	153	* @size: transfer length

include/linux/netdevice.h+42−8

 	TC_SETUP_ROOT_QDISC,
 	TC_SETUP_QDISC_GRED,
 	TC_SETUP_QDISC_TAPRIO,
+	TC_SETUP_FT,
 };
 /* These structures hold the attributes of bpf state that are being passed
 struct devlink;
 struct tlsdev_ops;
+struct netdev_name_node {
+	struct hlist_node hlist;
+	struct list_head list;
+	struct net_device *dev;
+	const char *name;
+};
+int netdev_name_node_alt_create(struct net_device *dev, const char *name);
+int netdev_name_node_alt_destroy(struct net_device *dev, const char *name);
 /*
  * This structure defines the management hooks for network devices.
 						   struct nlattr *port[]);
 	int			(*ndo_get_vf_port)(struct net_device *dev,
 						   int vf, struct sk_buff *skb);
+	int			(*ndo_get_vf_guid)(struct net_device *dev,
+						   int vf,
+						   struct ifla_vf_guid *node_guid,
+						   struct ifla_vf_guid *port_guid);
 	int			(*ndo_set_vf_guid)(struct net_device *dev,
 						   int vf, u64 guid,
 						   int guid_type);
  *		(i.e. as seen by users in the "Space.c" file).  It is the name
  *		of the interface.
  *
- *	@name_hlist: 	Device name hash chain, please keep it close to name[]
+ *	@name_node:	Name hashlist node
  *	@ifalias:	SNMP alias
  *	@mem_end:	Shared memory end
  *	@mem_start:	Shared memory start
  *			for hardware timestamping
  *	@sfp_bus:	attached &struct sfp_bus structure.
  *	@qdisc_tx_busylock_key: lockdep class annotating Qdisc->busylock
-				spinlock
+ *				spinlock
  *	@qdisc_running_key:	lockdep class annotating Qdisc->running seqcount
  *	@qdisc_xmit_lock_key:	lockdep class annotating
  *				netdev_queue->_xmit_lock spinlock
 struct net_device {
 	char			name[IFNAMSIZ];
-	struct hlist_node	name_hlist;
+	struct netdev_name_node	*name_node;
 	struct dev_ifalias	__rcu *ifalias;
 	/*
 	 *	I/O specific fields
 	unsigned char		if_port;
 	unsigned char		dma;
+	/* Note : dev->mtu is often read without holding a lock.
+	 * Writers usually hold RTNL.
+	 * It is recommended to use READ_ONCE() to annotate the reads,
+	 * and to use WRITE_ONCE() to annotate the writes.
+	 */
 	unsigned int		mtu;
 	unsigned int		min_mtu;
 	unsigned int		max_mtu;
 } __aligned(4 * sizeof(u64));
 struct pcpu_lstats {
-	u64 packets;
+	u64_stats_t packets;
-	u64 bytes;
+	u64_stats_t bytes;
 	struct u64_stats_sync syncp;
 } __aligned(2 * sizeof(u64));
+void dev_lstats_read(struct net_device *dev, u64 *packets, u64 *bytes);
+static inline void dev_lstats_add(struct net_device *dev, unsigned int len)
+{
+	struct pcpu_lstats *lstats = this_cpu_ptr(dev->lstats);
+	u64_stats_update_begin(&lstats->syncp);
+	u64_stats_add(&lstats->bytes, len);
+	u64_stats_inc(&lstats->packets);
+	u64_stats_update_end(&lstats->syncp);
+}
 #define __netdev_alloc_pcpu_stats(type, gfp)				\
 ({									\
 	typeof(type) __percpu *pcpu_stats = alloc_percpu_gfp(type, gfp);\
 int register_netdevice_notifier(struct notifier_block *nb);
 int unregister_netdevice_notifier(struct notifier_block *nb);
+int register_netdevice_notifier_net(struct net *net, struct notifier_block *nb);
+int unregister_netdevice_notifier_net(struct net *net,
+				      struct notifier_block *nb);
 struct netdev_notifier_info {
 	struct net_device	*dev;
 		list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list)
 #define for_each_netdev_continue(net, d)		\
 		list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list)
+#define for_each_netdev_continue_reverse(net, d)		\
+		list_for_each_entry_continue_reverse(d, &(net)->dev_base_head, \
+						     dev_list)
 #define for_each_netdev_continue_rcu(net, d)		\
 	list_for_each_entry_continue_rcu(d, &(net)->dev_base_head, dev_list)
 #define for_each_netdev_in_bond_rcu(bond, slave)	\
 				    unsigned char name_assign_type,
 				    void (*setup)(struct net_device *),
 				    unsigned int txqs, unsigned int rxqs);
-int dev_get_valid_name(struct net *net, struct net_device *dev,
-		       const char *name);
 #define alloc_netdev(sizeof_priv, name, name_assign_type, setup) \
 	alloc_netdev_mqs(sizeof_priv, name, name_assign_type, setup, 1, 1)

include/linux/netfilter.h+31−10

@@ -199,6 +199,8 @@ extern struct static_key nf_hooks_needed[NFPROTO_NUMPROTO][NF_MAX_HOOKS]; · 198 unmodified lines
199	int nf_hook_slow(struct sk_buff skb, struct nf_hook_state state,	199	int nf_hook_slow(struct sk_buff skb, struct nf_hook_state state,
200	const struct nf_hook_entries *e, unsigned int i);	200	const struct nf_hook_entries *e, unsigned int i);
201		201
		202	void nf_hook_slow_list(struct list_head head, struct nf_hook_state state,
		203	const struct nf_hook_entries *e);
202	/**	204	/**
203	* nf_hook - call a netfilter hook	205	* nf_hook - call a netfilter hook
204	*	206	*
@@ -311,17 +313,36 @@ NF_HOOK_LIST(uint8_t pf, unsigned int hook, struct net net, struct sock sk, · 106 unmodified lines
311	struct list_head head, struct net_device in, struct net_device *out,	313	struct list_head head, struct net_device in, struct net_device *out,
312	int (okfn)(struct net , struct sock , struct sk_buff ))	314	int (okfn)(struct net , struct sock , struct sk_buff ))
313	{	315	{
314	struct sk_buff skb, next;	316	struct nf_hook_entries *hook_head = NULL;
315	struct list_head sublist;	317
316		318	#ifdef CONFIG_JUMP_LABEL
317	INIT_LIST_HEAD(&sublist);	319	if (__builtin_constant_p(pf) &&
318	list_for_each_entry_safe(skb, next, head, list) {	320	__builtin_constant_p(hook) &&
319	list_del(&skb->list);	321	!static_key_false(&nf_hooks_needed[pf][hook]))
320	if (nf_hook(pf, hook, net, sk, skb, in, out, okfn) == 1)	322	return;
321	list_add_tail(&skb->list, &sublist);	323	#endif
		324
		325	rcu_read_lock();
		326	switch (pf) {
		327	case NFPROTO_IPV4:
		328	hook_head = rcu_dereference(net->nf.hooks_ipv4[hook]);
		329	break;
		330	case NFPROTO_IPV6:
		331	hook_head = rcu_dereference(net->nf.hooks_ipv6[hook]);
		332	break;
		333	default:
		334	WARN_ON_ONCE(1);
		335	break;
322	}	336	}
323	/* Put passed packets back on main list */	337
324	list_splice(&sublist, head);	338	if (hook_head) {
		339	struct nf_hook_state state;
		340
		341	nf_hook_state_init(&state, hook, pf, in, out, sk, net, okfn);
		342
		343	nf_hook_slow_list(head, &state, hook_head);
		344	}
		345	rcu_read_unlock();
325	}	346	}
326		347
327	/* Call setsockopt() */	348	/* Call setsockopt() */

include/linux/netfilter/ipset/ip_set.h+8−188

@@ -269,34 +269,15 @@ ip_set_ext_destroy(struct ip_set set, void data) · 268 unmodified lines
269	/* Check that the extension is enabled for the set and	269	/* Check that the extension is enabled for the set and
270	* call it's destroy function for its extension part in data.	270	* call it's destroy function for its extension part in data.
271	*/	271	*/
272	if (SET_WITH_COMMENT(set))	272	if (SET_WITH_COMMENT(set)) {
273	ip_set_extensions[IPSET_EXT_ID_COMMENT].destroy(	273	struct ip_set_comment *c = ext_comment(data, set);
274	set, ext_comment(data, set));
275	}
276		274
277	static inline int	275	ip_set_extensions[IPSET_EXT_ID_COMMENT].destroy(set, c);
278	ip_set_put_flags(struct sk_buff skb, struct ip_set set)	276	}
279	{
280	u32 cadt_flags = 0;
281
282	if (SET_WITH_TIMEOUT(set))
283	if (unlikely(nla_put_net32(skb, IPSET_ATTR_TIMEOUT,
284	htonl(set->timeout))))
285	return -EMSGSIZE;
286	if (SET_WITH_COUNTER(set))
287	cadt_flags \|= IPSET_FLAG_WITH_COUNTERS;
288	if (SET_WITH_COMMENT(set))
289	cadt_flags \|= IPSET_FLAG_WITH_COMMENT;
290	if (SET_WITH_SKBINFO(set))
291	cadt_flags \|= IPSET_FLAG_WITH_SKBINFO;
292	if (SET_WITH_FORCEADD(set))
293	cadt_flags \|= IPSET_FLAG_WITH_FORCEADD;
294
295	if (!cadt_flags)
296	return 0;
297	return nla_put_net32(skb, IPSET_ATTR_CADT_FLAGS, htonl(cadt_flags));
298	}	277	}
299		278
		279	int ip_set_put_flags(struct sk_buff skb, struct ip_set set);
		280
300	/* Netlink CB args */	281	/* Netlink CB args */
301	enum {	282	enum {
302	IPSET_CB_NET = 0, /* net namespace */	283	IPSET_CB_NET = 0, /* net namespace */
@@ -506,144 +487,8 @@ ip_set_timeout_set(unsigned long *timeout, u32 value) · 203 unmodified lines
506	*timeout = t;	487	*timeout = t;
507	}	488	}
508		489
509	static inline u32	490	void ip_set_init_comment(struct ip_set set, struct ip_set_comment comment,
510	ip_set_timeout_get(const unsigned long *timeout)	491	const struct ip_set_ext *ext);
511	{
512	u32 t;
513
514	if (*timeout == IPSET_ELEM_PERMANENT)
515	return 0;
516
517	t = jiffies_to_msecs(*timeout - jiffies)/MSEC_PER_SEC;
518	/* Zero value in userspace means no timeout */
519	return t == 0 ? 1 : t;
520	}
521
522	static inline char*
523	ip_set_comment_uget(struct nlattr *tb)
524	{
525	return nla_data(tb);
526	}
527
528	/* Called from uadd only, protected by the set spinlock.
529	* The kadt functions don't use the comment extensions in any way.
530	*/
531	static inline void
532	ip_set_init_comment(struct ip_set set, struct ip_set_comment comment,
533	const struct ip_set_ext *ext)
534	{
535	struct ip_set_comment_rcu *c = rcu_dereference_protected(comment->c, 1);
536	size_t len = ext->comment ? strlen(ext->comment) : 0;
537
538	if (unlikely(c)) {
539	set->ext_size -= sizeof(*c) + strlen(c->str) + 1;
540	kfree_rcu(c, rcu);
541	rcu_assign_pointer(comment->c, NULL);
542	}
543	if (!len)
544	return;
545	if (unlikely(len > IPSET_MAX_COMMENT_SIZE))
546	len = IPSET_MAX_COMMENT_SIZE;
547	c = kmalloc(sizeof(*c) + len + 1, GFP_ATOMIC);
548	if (unlikely(!c))
549	return;
550	strlcpy(c->str, ext->comment, len + 1);
551	set->ext_size += sizeof(*c) + strlen(c->str) + 1;
552	rcu_assign_pointer(comment->c, c);
553	}
554
555	/* Used only when dumping a set, protected by rcu_read_lock() */
556	static inline int
557	ip_set_put_comment(struct sk_buff skb, const struct ip_set_comment comment)
558	{
559	struct ip_set_comment_rcu *c = rcu_dereference(comment->c);
560
561	if (!c)
562	return 0;
563	return nla_put_string(skb, IPSET_ATTR_COMMENT, c->str);
564	}
565
566	/* Called from uadd/udel, flush or the garbage collectors protected
567	* by the set spinlock.
568	* Called when the set is destroyed and when there can't be any user
569	* of the set data anymore.
570	*/
571	static inline void
572	ip_set_comment_free(struct ip_set set, struct ip_set_comment comment)
573	{
574	struct ip_set_comment_rcu *c;
575
576	c = rcu_dereference_protected(comment->c, 1);
577	if (unlikely(!c))
578	return;
579	set->ext_size -= sizeof(*c) + strlen(c->str) + 1;
580	kfree_rcu(c, rcu);
581	rcu_assign_pointer(comment->c, NULL);
582	}
583
584	static inline void
585	ip_set_add_bytes(u64 bytes, struct ip_set_counter *counter)
586	{
587	atomic64_add((long long)bytes, &(counter)->bytes);
588	}
589
590	static inline void
591	ip_set_add_packets(u64 packets, struct ip_set_counter *counter)
592	{
593	atomic64_add((long long)packets, &(counter)->packets);
594	}
595
596	static inline u64
597	ip_set_get_bytes(const struct ip_set_counter *counter)
598	{
599	return (u64)atomic64_read(&(counter)->bytes);
600	}
601
602	static inline u64
603	ip_set_get_packets(const struct ip_set_counter *counter)
604	{
605	return (u64)atomic64_read(&(counter)->packets);
606	}
607
608	static inline bool
609	ip_set_match_counter(u64 counter, u64 match, u8 op)
610	{
611	switch (op) {
612	case IPSET_COUNTER_NONE:
613	return true;
614	case IPSET_COUNTER_EQ:
615	return counter == match;
616	case IPSET_COUNTER_NE:
617	return counter != match;
618	case IPSET_COUNTER_LT:
619	return counter < match;
620	case IPSET_COUNTER_GT:
621	return counter > match;
622	}
623	return false;
624	}
625
626	static inline void
627	ip_set_update_counter(struct ip_set_counter *counter,
628	const struct ip_set_ext *ext, u32 flags)
629	{
630	if (ext->packets != ULLONG_MAX &&
631	!(flags & IPSET_FLAG_SKIP_COUNTER_UPDATE)) {
632	ip_set_add_bytes(ext->bytes, counter);
633	ip_set_add_packets(ext->packets, counter);
634	}
635	}
636
637	static inline bool
638	ip_set_put_counter(struct sk_buff skb, const struct ip_set_counter counter)
639	{
640	return nla_put_net64(skb, IPSET_ATTR_BYTES,
641	cpu_to_be64(ip_set_get_bytes(counter)),
642	IPSET_ATTR_PAD) \|\|
643	nla_put_net64(skb, IPSET_ATTR_PACKETS,
644	cpu_to_be64(ip_set_get_packets(counter)),
645	IPSET_ATTR_PAD);
646	}
647		492
648	static inline void	493	static inline void
649	ip_set_init_counter(struct ip_set_counter *counter,	494	ip_set_init_counter(struct ip_set_counter *counter,
@@ -655,31 +500,6 @@ ip_set_init_counter(struct ip_set_counter *counter, · 5 unmodified lines
655	atomic64_set(&(counter)->packets, (long long)(ext->packets));	500	atomic64_set(&(counter)->packets, (long long)(ext->packets));
656	}	501	}
657		502
658	static inline void
659	ip_set_get_skbinfo(struct ip_set_skbinfo *skbinfo,
660	const struct ip_set_ext *ext,
661	struct ip_set_ext *mext, u32 flags)
662	{
663	mext->skbinfo = *skbinfo;
664	}
665
666	static inline bool
667	ip_set_put_skbinfo(struct sk_buff skb, const struct ip_set_skbinfo skbinfo)
668	{
669	/* Send nonzero parameters only */
670	return ((skbinfo->skbmark \|\| skbinfo->skbmarkmask) &&
671	nla_put_net64(skb, IPSET_ATTR_SKBMARK,
672	cpu_to_be64((u64)skbinfo->skbmark << 32 \|
673	skbinfo->skbmarkmask),
674	IPSET_ATTR_PAD)) \|\|
675	(skbinfo->skbprio &&
676	nla_put_net32(skb, IPSET_ATTR_SKBPRIO,
677	cpu_to_be32(skbinfo->skbprio))) \|\|
678	(skbinfo->skbqueue &&
679	nla_put_net16(skb, IPSET_ATTR_SKBQUEUE,
680	cpu_to_be16(skbinfo->skbqueue)));
681	}
682
683	static inline void	503	static inline void
684	ip_set_init_skbinfo(struct ip_set_skbinfo *skbinfo,	504	ip_set_init_skbinfo(struct ip_set_skbinfo *skbinfo,
685	const struct ip_set_ext *ext)	505	const struct ip_set_ext *ext)

include/linux/netfilter/ipset/ip_set_bitmap.h+0−14

@@ -12,18 +12,4 @@ enum { · 11 unmodified lines
12	IPSET_ADD_START_STORED_TIMEOUT,	12	IPSET_ADD_START_STORED_TIMEOUT,
13	};	13	};
14		14
15	/* Common functions */
16
17	static inline u32
18	range_to_mask(u32 from, u32 to, u8 *bits)
19	{
20	u32 mask = 0xFFFFFFFE;
21
22	*bits = 32;
23	while (--(*bits) > 0 && mask && (to & mask) != from)
24	mask <<= 1;
25
26	return mask;
27	}
28
29	#endif /* __IP_SET_BITMAP_H */	15	#endif /* __IP_SET_BITMAP_H */

include/linux/netfilter/ipset/ip_set_getport.h+0−3

@@ -20,9 +20,6 @@ static inline bool ip_set_get_ip6_port(const struct sk_buff *skb, bool src, · 19 unmodified lines
20	}	20	}
21	#endif	21	#endif
22		22
23	extern bool ip_set_get_ip_port(const struct sk_buff *skb, u8 pf, bool src,
24	__be16 *port);
25
26	static inline bool ip_set_proto_with_ports(u8 proto)	23	static inline bool ip_set_proto_with_ports(u8 proto)
27	{	24	{
28	switch (proto) {	25	switch (proto) {

include/linux/nfs4.h+26−0

@@ -16,6 +16,7 @@ · 15 unmodified lines
16	#include <linux/list.h>	16	#include <linux/list.h>
17	#include <linux/uidgid.h>	17	#include <linux/uidgid.h>
18	#include <uapi/linux/nfs4.h>	18	#include <uapi/linux/nfs4.h>
		19	#include <linux/sunrpc/msg_prot.h>
19		20
20	enum nfs4_acl_whotype {	21	enum nfs4_acl_whotype {
21	NFS4_ACL_WHO_NAMED = 0,	22	NFS4_ACL_WHO_NAMED = 0,
@@ -539,6 +540,8 @@ enum { · 517 unmodified lines
539		540
540	NFSPROC4_CLNT_LOOKUPP,	541	NFSPROC4_CLNT_LOOKUPP,
541	NFSPROC4_CLNT_LAYOUTERROR,	542	NFSPROC4_CLNT_LAYOUTERROR,
		543
		544	NFSPROC4_CLNT_COPY_NOTIFY,
542	};	545	};
543		546
544	/* nfs41 types */	547	/* nfs41 types */
@@ -674,4 +677,27 @@ struct nfs4_op_map { · 129 unmodified lines
674	} u;	677	} u;
675	};	678	};
676		679
		680	struct nfs42_netaddr {
		681	char netid[RPCBIND_MAXNETIDLEN];
		682	char addr[RPCBIND_MAXUADDRLEN + 1];
		683	u32 netid_len;
		684	u32 addr_len;
		685	};
		686
		687	enum netloc_type4 {
		688	NL4_NAME = 1,
		689	NL4_URL = 2,
		690	NL4_NETADDR = 3,
		691	};
		692
		693	struct nl4_server {
		694	enum netloc_type4 nl4_type;
		695	union {
		696	struct { /* NL4_NAME, NL4_URL */
		697	int nl4_str_sz;
		698	char nl4_str[NFS4_OPAQUE_LIMIT + 1];
		699	};
		700	struct nfs42_netaddr nl4_addr; /* NL4_NETADDR */
		701	} u;
		702	};
677	#endif	703	#endif

include/linux/nfs_fs.h+3−1

 struct nfs4_copy_state {
 	struct list_head	copies;
+	struct list_head	src_copies;
 	nfs4_stateid		stateid;
 	struct completion	completion;
 	uint64_t		count;
 	struct nfs_writeverf	verf;
 	int			error;
 	int			flags;
-	struct nfs4_state	*parent_state;
+	struct nfs4_state	*parent_src_state;
+	struct nfs4_state	*parent_dst_state;
 };
 /*

include/linux/nfs_fs_sb.h+5−1

 #define NFS_CS_INFINITE_SLOTS	3		/* - don't limit TCP slots */
 #define NFS_CS_NO_RETRANS_TIMEOUT	4	/* - Disable retransmit timeouts */
 #define NFS_CS_TSM_POSSIBLE	5		/* - Maybe state migration */
+#define NFS_CS_NOPING		6		/* - don't ping on connect */
+#define NFS_CS_DS		7		/* - Server is a DS */
+#define NFS_CS_REUSEPORT	8		/* - reuse src port on reconnect */
 	struct sockaddr_storage	cl_addr;	/* server identifier */
 	size_t			cl_addrlen;
 	char *			cl_hostname;	/* hostname of server */
 	struct nfs_fsid		fsid;
 	__u64			maxfilesize;	/* maximum file size */
-	struct timespec		time_delta;	/* smallest time granularity */
+	struct timespec64	time_delta;	/* smallest time granularity */
 	unsigned long		mount_time;	/* when this fs was mounted */
 	struct super_block	*super;		/* VFS super block */
 	dev_t			s_dev;		/* superblock dev numbers */
 #define NFS_CAP_COPY		(1U << 24)
 #define NFS_CAP_OFFLOAD_CANCEL	(1U << 25)
 #define NFS_CAP_LAYOUTERROR	(1U << 26)
+#define NFS_CAP_COPY_NOTIFY	(1U << 27)
 #endif

include/linux/nfs_xdr.h+24−7

 	struct nfs_fsid		fsid;
 	__u64			fileid;
 	__u64			mounted_on_fileid;
-	struct timespec		atime;
+	struct timespec64	atime;
-	struct timespec		mtime;
+	struct timespec64	mtime;
-	struct timespec		ctime;
+	struct timespec64	ctime;
 	__u64			change_attr;	/* NFSv4 change attribute */
 	__u64			pre_change_attr;/* pre-op NFSv4 change attribute */
 	__u64			pre_size;	/* pre_op_attr.size	  */
-	struct timespec		pre_mtime;	/* pre_op_attr.mtime	  */
+	struct timespec64	pre_mtime;	/* pre_op_attr.mtime	  */
-	struct timespec		pre_ctime;	/* pre_op_attr.ctime	  */
+	struct timespec64	pre_ctime;	/* pre_op_attr.ctime	  */
 	unsigned long		time_start;
 	unsigned long		gencount;
 	struct nfs4_string	*owner_name;
 	__u32			wtmult;	/* writes should be multiple of this */
 	__u32			dtpref;	/* pref. readdir transfer size */
 	__u64			maxfilesize;
-	struct timespec		time_delta; /* server time granularity */
+	struct timespec64	time_delta; /* server time granularity */
 	__u32			lease_time; /* in seconds */
 	__u32			nlayouttypes; /* number of layouttypes */
 	__u32			layouttype[NFS_MAX_LAYOUT_TYPES]; /* supported pnfs layout driver */
 	struct nfs_fh *		fh;
 	struct iattr *		sattr;
 	unsigned int		guard;
-	struct timespec		guardtime;
+	struct timespec64	guardtime;
 };
 struct nfs3_diropargs {
 	u64				count;
 	bool				sync;
+	struct nl4_server		*cp_src;
 };
 struct nfs42_write_res {
 	int				osr_status;
 };
+struct nfs42_copy_notify_args {
+	struct nfs4_sequence_args	cna_seq_args;
+	struct nfs_fh		*cna_src_fh;
+	nfs4_stateid		cna_src_stateid;
+	struct nl4_server	cna_dst;
+};
+struct nfs42_copy_notify_res {
+	struct nfs4_sequence_res	cnr_seq_res;
+	struct nfstime4		cnr_lease_time;
+	nfs4_stateid		cnr_stateid;
+	struct nl4_server	cnr_src;
+};
 struct nfs42_seek_args {
 	struct nfs4_sequence_args	seq_args;

include/linux/notifier.h+0−4

 extern int srcu_notifier_chain_register(struct srcu_notifier_head *nh,
 		struct notifier_block *nb);
-extern int blocking_notifier_chain_cond_register(
-		struct blocking_notifier_head *nh,
-		struct notifier_block *nb);
 extern int atomic_notifier_chain_unregister(struct atomic_notifier_head *nh,
 		struct notifier_block *nb);
 extern int blocking_notifier_chain_unregister(struct blocking_notifier_head *nh,

include/linux/nvme-fc-driver.h+4−0

  *
  * Host/Initiator Transport Entrypoints/Parameters:
  *
+ * @module:  The LLDD module using the interface
+ *
  * @localport_delete:  The LLDD initiates deletion of a localport via
  *       nvme_fc_deregister_localport(). However, the teardown is
  *       asynchronous. This routine is called upon the completion of the
  *       Value is Mandatory. Allowed to be zero.
  */
 struct nvme_fc_port_template {
+	struct module	*module;
 	/* initiator-based functions */
 	void	(*localport_delete)(struct nvme_fc_local_port *);
 	void	(*remoteport_delete)(struct nvme_fc_remote_port *);

include/linux/nvme-fc.h+137−45

  */
 /*
- * This file contains definitions relative to FC-NVME r1.14 (16-020vB).
+ * This file contains definitions relative to FC-NVME-2 r1.06
- * The fcnvme_lsdesc_cr_assoc_cmd struct reflects expected r1.16 content.
+ * (T11-2019-00210-v001).
  */
 #ifndef _NVME_FC_H
 #define _NVME_FC_H 1
+#include <uapi/scsi/fc/fc_fs.h>
-#define NVME_CMD_SCSI_ID		0xFD
+#define NVME_CMD_FORMAT_ID		0xFD
 #define NVME_CMD_FC_ID			FC_TYPE_NVME
 /* FC-NVME Cmd IU Flags */
-#define FCNVME_CMD_FLAGS_DIRMASK	0x03
+enum {
-#define FCNVME_CMD_FLAGS_WRITE		0x01
+	FCNVME_CMD_FLAGS_DIRMASK	= 0x03,
-#define FCNVME_CMD_FLAGS_READ		0x02
+	FCNVME_CMD_FLAGS_WRITE		= (1 << 0),
+	FCNVME_CMD_FLAGS_READ		= (1 << 1),
+	FCNVME_CMD_FLAGS_PICWP		= (1 << 2),
+};
+enum {
+	FCNVME_CMD_CAT_MASK		= 0x0F,
+	FCNVME_CMD_CAT_ADMINQ		= 0x01,
+	FCNVME_CMD_CAT_CSSMASK		= 0x07,
+	FCNVME_CMD_CAT_CSSFLAG		= 0x08,
+};
+static inline __u8 fccmnd_set_cat_admin(__u8 rsv_cat)
+{
+	return (rsv_cat & ~FCNVME_CMD_CAT_MASK) | FCNVME_CMD_CAT_ADMINQ;
+}
+static inline __u8 fccmnd_set_cat_css(__u8 rsv_cat, __u8 css)
+{
+	return (rsv_cat & ~FCNVME_CMD_CAT_MASK) | FCNVME_CMD_CAT_CSSFLAG |
+		(css & FCNVME_CMD_CAT_CSSMASK);
+}
 struct nvme_fc_cmd_iu {
-	__u8			scsi_id;
+	__u8			format_id;
 	__u8			fc_id;
 	__be16			iu_len;
-	__u8			rsvd4[3];
+	__u8			rsvd4[2];
+	__u8			rsv_cat;
 	__u8			flags;
 	__be64			connection_id;
 	__be32			csn;
 	__be32			data_len;
 	struct nvme_command	sqe;
-	__be32			rsvd88[2];
+	__u8			dps;
+	__u8			lbads;
+	__be16			ms;
+	__be32			rsvd92;
 };
 #define NVME_FC_SIZEOF_ZEROS_RSP	12
 enum {
 	FCNVME_SC_SUCCESS		= 0,
 	FCNVME_SC_INVALID_FIELD		= 1,
-	FCNVME_SC_INVALID_CONNID	= 2,
+	/* reserved			  2 */
+	FCNVME_SC_ILL_CONN_PARAMS	= 3,
 };
 struct nvme_fc_ersp_iu {
-	__u8			status_code;
+	__u8			ersp_result;
 	__u8			rsvd1;
 	__be16			iu_len;
 	__be32			rsn;
 };
-/* FC-NVME Link Services */
+#define FCNVME_NVME_SR_OPCODE	0x01
+struct nvme_fc_nvme_sr_iu {
+	__u8			fc_id;
+	__u8			opcode;
+	__u8			rsvd2;
+	__u8			retry_rctl;
+	__be32			rsvd4;
+};
+enum {
+	FCNVME_SRSTAT_ACC		= 0x0,
+	FCNVME_SRSTAT_INV_FCID		= 0x1,
+	/* reserved			  0x2 */
+	FCNVME_SRSTAT_LOGICAL_ERR	= 0x3,
+	FCNVME_SRSTAT_INV_QUALIF	= 0x4,
+	FCNVME_SRSTAT_UNABL2PERFORM	= 0x9,
+};
+struct nvme_fc_nvme_sr_rsp_iu {
+	__u8			fc_id;
+	__u8			opcode;
+	__u8			rsvd2;
+	__u8			status;
+	__be32			rsvd4;
+};
+/* FC-NVME Link Services - LS cmd values (w0 bits 31:24) */
 enum {
 	FCNVME_LS_RSVD			= 0,
 	FCNVME_LS_RJT			= 1,
 	FCNVME_LS_ACC			= 2,
-	FCNVME_LS_CREATE_ASSOCIATION	= 3,
+	FCNVME_LS_CREATE_ASSOCIATION	= 3,	/* Create Association */
-	FCNVME_LS_CREATE_CONNECTION	= 4,
+	FCNVME_LS_CREATE_CONNECTION	= 4,	/* Create I/O Connection */
-	FCNVME_LS_DISCONNECT		= 5,
+	FCNVME_LS_DISCONNECT_ASSOC	= 5,	/* Disconnect Association */
+	FCNVME_LS_DISCONNECT_CONN	= 6,	/* Disconnect Connection */
 };
 /* FC-NVME Link Service Descriptors */
 	FCNVME_RJT_RC_UNSUP		= 0x0b,
 	/* command not supported */
-	FCNVME_RJT_RC_INPROG		= 0x0e,
-	/* command already in progress */
 	FCNVME_RJT_RC_INV_ASSOC		= 0x40,
-	/* Invalid Association ID*/
+	/* Invalid Association ID */
 	FCNVME_RJT_RC_INV_CONN		= 0x41,
-	/* Invalid Connection ID*/
+	/* Invalid Connection ID */
+	FCNVME_RJT_RC_INV_PARAM		= 0x42,
+	/* Invalid Parameters */
+	FCNVME_RJT_RC_INSUF_RES		= 0x43,
+	/* Insufficient Resources */
 	FCNVME_RJT_RC_VENDOR		= 0xff,
 	/* vendor specific error */
 	FCNVME_RJT_EXP_OXID_RXID	= 0x17,
 	/* invalid OX_ID-RX_ID combination */
-	FCNVME_RJT_EXP_INSUF_RES	= 0x29,
-	/* insufficient resources */
 	FCNVME_RJT_EXP_UNAB_DATA	= 0x2a,
 	/* unable to supply requested data */
 	FCNVME_RJT_EXP_INV_LEN		= 0x2d,
 	/* Invalid payload length */
+	FCNVME_RJT_EXP_INV_ERSP_RAT	= 0x40,
+	/* Invalid NVMe_ERSP Ratio */
+	FCNVME_RJT_EXP_INV_CTLR_ID	= 0x41,
+	/* Invalid Controller ID */
+	FCNVME_RJT_EXP_INV_QUEUE_ID	= 0x42,
+	/* Invalid Queue ID */
+	FCNVME_RJT_EXP_INV_SQSIZE	= 0x43,
+	/* Invalid Submission Queue Size */
+	FCNVME_RJT_EXP_INV_HOSTID	= 0x44,
+	/* Invalid HOST ID */
+	FCNVME_RJT_EXP_INV_HOSTNQN	= 0x45,
+	/* Invalid HOSTNQN */
+	FCNVME_RJT_EXP_INV_SUBNQN	= 0x46,
+	/* Invalid SUBNQN */
 };
 /* FCNVME_LSDESC_RJT */
 	__be32  rsvd52;
 };
-/* Disconnect Scope Values */
-enum {
-	FCNVME_DISCONN_ASSOCIATION	= 0,
-	FCNVME_DISCONN_CONNECTION	= 1,
-};
 /* FCNVME_LSDESC_DISCONN_CMD */
 struct fcnvme_lsdesc_disconn_cmd {
 	__be32	desc_tag;		/* FCNVME_LSDESC_xxx */
 	__be32	desc_len;
-	u8	rsvd8[3];
+	__be32	rsvd8[4];
-	/* note: scope is really a 1 bit field */
-	u8	scope;			/* FCNVME_DISCONN_xxx */
-	__be32	rsvd12;
-	__be64	id;
 };
 /* FCNVME_LSDESC_CONN_ID */
 /* r_ctl values */
 enum {
-	FCNVME_RS_RCTL_DATA		= 1,
+	FCNVME_RS_RCTL_CMND		= 0x6,
-	FCNVME_RS_RCTL_XFER_RDY		= 5,
+	FCNVME_RS_RCTL_DATA		= 0x1,
-	FCNVME_RS_RCTL_RSP		= 8,
+	FCNVME_RS_RCTL_CONF		= 0x3,
+	FCNVME_RS_RCTL_SR		= 0x9,
+	FCNVME_RS_RCTL_XFER_RDY		= 0x5,
+	FCNVME_RS_RCTL_RSP		= 0x7,
+	FCNVME_RS_RCTL_ERSP		= 0x8,
+	FCNVME_RS_RCTL_SR_RSP		= 0xA,
 };
 	struct fcnvme_ls_rqst_w0		w0;
 	__be32					desc_list_len;
 	struct fcnvme_lsdesc_rqst		rqst;
-	/* Followed by cmd-specific ACC descriptors, see next definitions */
+	/*
+	 * Followed by cmd-specific ACCEPT descriptors, see xxx_acc
+	 * definitions below
+	 */
 };
 /* FCNVME_LS_CREATE_ASSOCIATION */
 	struct fcnvme_lsdesc_conn_id		connectid;
 };
-/* FCNVME_LS_DISCONNECT */
+/* FCNVME_LS_DISCONNECT_ASSOC */
-struct fcnvme_ls_disconnect_rqst {
+struct fcnvme_ls_disconnect_assoc_rqst {
 	struct fcnvme_ls_rqst_w0		w0;
 	__be32					desc_list_len;
 	struct fcnvme_lsdesc_assoc_id		associd;
 	struct fcnvme_lsdesc_disconn_cmd	discon_cmd;
 };
-struct fcnvme_ls_disconnect_acc {
+struct fcnvme_ls_disconnect_assoc_acc {
+	struct fcnvme_ls_acc_hdr		hdr;
+};
+/* FCNVME_LS_DISCONNECT_CONN */
+struct fcnvme_ls_disconnect_conn_rqst {
+	struct fcnvme_ls_rqst_w0		w0;
+	__be32					desc_list_len;
+	struct fcnvme_lsdesc_assoc_id		associd;
+	struct fcnvme_lsdesc_disconn_cmd	connectid;
+};
+struct fcnvme_ls_disconnect_conn_acc {
 	struct fcnvme_ls_acc_hdr		hdr;
 };
 /*
- * Yet to be defined in FC-NVME:
+ * Default R_A_TOV is pulled in from fc_fs.h but needs conversion
+ * from ms to seconds for our use.
  */
-#define NVME_FC_CONNECT_TIMEOUT_SEC	2		/* 2 seconds */
+#define FC_TWO_TIMES_R_A_TOV		(2 * (FC_DEF_R_A_TOV / 1000))
-#define NVME_FC_LS_TIMEOUT_SEC		2		/* 2 seconds */
+#define NVME_FC_LS_TIMEOUT_SEC		FC_TWO_TIMES_R_A_TOV
-#define NVME_FC_TGTOP_TIMEOUT_SEC	2		/* 2 seconds */
+#define NVME_FC_TGTOP_TIMEOUT_SEC	FC_TWO_TIMES_R_A_TOV
 /*
  * TRADDR string must be of form "nn-<16hexdigits>:pn-<16hexdigits>"
  * infront of the <16hexdigits>.  Without is considered the "min" string
  * and with is considered the "max" string. The hexdigits may be upper
  * or lower case.
+ * Note: FC-NVME-2 standard requires a "0x" prefix.
  */
 #define NVME_FC_TRADDR_NNLEN		3	/* "?n-" */
 #define NVME_FC_TRADDR_OXNNLEN		5	/* "?n-0x" */

include/linux/nvme.h+57−3

 	NVME_REG_AQA	= 0x0024,	/* Admin Queue Attributes */
 	NVME_REG_ASQ	= 0x0028,	/* Admin SQ Base Address */
 	NVME_REG_ACQ	= 0x0030,	/* Admin CQ Base Address */
-	NVME_REG_CMBLOC = 0x0038,	/* Controller Memory Buffer Location */
+	NVME_REG_CMBLOC	= 0x0038,	/* Controller Memory Buffer Location */
 	NVME_REG_CMBSZ	= 0x003c,	/* Controller Memory Buffer Size */
+	NVME_REG_BPINFO	= 0x0040,	/* Boot Partition Information */
+	NVME_REG_BPRSEL	= 0x0044,	/* Boot Partition Read Select */
+	NVME_REG_BPMBL	= 0x0048,	/* Boot Partition Memory Buffer
+					 * Location
+					 */
+	NVME_REG_PMRCAP	= 0x0e00,	/* Persistent Memory Capabilities */
+	NVME_REG_PMRCTL	= 0x0e04,	/* Persistent Memory Region Control */
+	NVME_REG_PMRSTS	= 0x0e08,	/* Persistent Memory Region Status */
+	NVME_REG_PMREBS	= 0x0e0c,	/* Persistent Memory Region Elasticity
+					 * Buffer Size
+					 */
+	NVME_REG_PMRSWTP = 0x0e10,	/* Persistent Memory Region Sustained
+					 * Write Throughput
+					 */
 	NVME_REG_DBS	= 0x1000,	/* SQ 0 Tail Doorbell */
 };
 	NVME_CTRL_OACS_DIRECTIVES		= 1 << 5,
 	NVME_CTRL_OACS_DBBUF_SUPP		= 1 << 8,
 	NVME_CTRL_LPA_CMD_EFFECTS_LOG		= 1 << 1,
+	NVME_CTRL_CTRATT_128_ID			= 1 << 0,
+	NVME_CTRL_CTRATT_NON_OP_PSP		= 1 << 1,
+	NVME_CTRL_CTRATT_NVM_SETS		= 1 << 2,
+	NVME_CTRL_CTRATT_READ_RECV_LVLS		= 1 << 3,
+	NVME_CTRL_CTRATT_ENDURANCE_GROUPS	= 1 << 4,
+	NVME_CTRL_CTRATT_PREDICTABLE_LAT	= 1 << 5,
+	NVME_CTRL_CTRATT_NAMESPACE_GRANULARITY	= 1 << 7,
+	NVME_CTRL_CTRATT_UUID_LIST		= 1 << 9,
 };
 struct nvme_lbaf {
 	NVME_ID_CNS_NS_PRESENT		= 0x11,
 	NVME_ID_CNS_CTRL_NS_LIST	= 0x12,
 	NVME_ID_CNS_CTRL_LIST		= 0x13,
+	NVME_ID_CNS_SCNDRY_CTRL_LIST	= 0x15,
+	NVME_ID_CNS_NS_GRANULARITY	= 0x16,
+	NVME_ID_CNS_UUID_LIST		= 0x17,
 };
 enum {
 	__u8			avail_spare;
 	__u8			spare_thresh;
 	__u8			percent_used;
-	__u8			rsvd6[26];
+	__u8			endu_grp_crit_warn_sumry;
+	__u8			rsvd7[25];
 	__u8			data_units_read[16];
 	__u8			data_units_written[16];
 	__u8			host_reads[16];
 	__le32			warning_temp_time;
 	__le32			critical_comp_time;
 	__le16			temp_sensor[8];
-	__u8			rsvd216[296];
+	__le32			thm_temp1_trans_count;
+	__le32			thm_temp2_trans_count;
+	__le32			thm_temp1_total_time;
+	__le32			thm_temp2_total_time;
+	__u8			rsvd232[280];
 };
 struct nvme_fw_slot_info_log {
 	NVME_CMD_EFFECTS_NIC		= 1 << 3,
 	NVME_CMD_EFFECTS_CCC		= 1 << 4,
 	NVME_CMD_EFFECTS_CSE_MASK	= 3 << 16,
+	NVME_CMD_EFFECTS_UUID_SEL	= 1 << 19,
 };
 struct nvme_effects_log {
 	nvme_cmd_compare	= 0x05,
 	nvme_cmd_write_zeroes	= 0x08,
 	nvme_cmd_dsm		= 0x09,
+	nvme_cmd_verify		= 0x0c,
 	nvme_cmd_resv_register	= 0x0d,
 	nvme_cmd_resv_report	= 0x0e,
 	nvme_cmd_resv_acquire	= 0x11,
 /* Features */
+enum {
+	NVME_TEMP_THRESH_MASK		= 0xffff,
+	NVME_TEMP_THRESH_SELECT_SHIFT	= 16,
+	NVME_TEMP_THRESH_TYPE_UNDER	= 0x100000,
+};
 struct nvme_feat_auto_pst {
 	__le64 entries[32];
 };
 	nvme_admin_ns_mgmt		= 0x0d,
 	nvme_admin_activate_fw		= 0x10,
 	nvme_admin_download_fw		= 0x11,
+	nvme_admin_dev_self_test	= 0x14,
 	nvme_admin_ns_attach		= 0x15,
 	nvme_admin_keep_alive		= 0x18,
 	nvme_admin_directive_send	= 0x19,
 	nvme_admin_directive_recv	= 0x1a,
+	nvme_admin_virtual_mgmt		= 0x1c,
+	nvme_admin_nvme_mi_send		= 0x1d,
+	nvme_admin_nvme_mi_recv		= 0x1e,
 	nvme_admin_dbbuf		= 0x7C,
 	nvme_admin_format_nvm		= 0x80,
 	nvme_admin_security_send	= 0x81,
 	NVME_FEAT_PLM_CONFIG	= 0x13,
 	NVME_FEAT_PLM_WINDOW	= 0x14,
 	NVME_FEAT_HOST_BEHAVIOR	= 0x16,
+	NVME_FEAT_SANITIZE	= 0x17,
 	NVME_FEAT_SW_PROGRESS	= 0x80,
 	NVME_FEAT_HOST_ID	= 0x81,
 	NVME_FEAT_RESV_MASK	= 0x82,
 	NVME_LOG_FW_SLOT	= 0x03,
 	NVME_LOG_CHANGED_NS	= 0x04,
 	NVME_LOG_CMD_EFFECTS	= 0x05,
+	NVME_LOG_DEVICE_SELF_TEST = 0x06,
+	NVME_LOG_TELEMETRY_HOST = 0x07,
+	NVME_LOG_TELEMETRY_CTRL = 0x08,
+	NVME_LOG_ENDURANCE_GROUP = 0x09,
 	NVME_LOG_ANA		= 0x0c,
 	NVME_LOG_DISC		= 0x70,
 	NVME_LOG_RESERVATION	= 0x80,
 	NVME_SC_SGL_INVALID_OFFSET	= 0x16,
 	NVME_SC_SGL_INVALID_SUBTYPE	= 0x17,
+	NVME_SC_SANITIZE_FAILED		= 0x1C,
+	NVME_SC_SANITIZE_IN_PROGRESS	= 0x1D,
 	NVME_SC_NS_WRITE_PROTECTED	= 0x20,
+	NVME_SC_CMD_INTERRUPTED		= 0x21,
 	NVME_SC_LBA_RANGE		= 0x80,
 	NVME_SC_CAP_EXCEEDED		= 0x81,
 	NVME_SC_NS_NOT_ATTACHED		= 0x11a,
 	NVME_SC_THIN_PROV_NOT_SUPP	= 0x11b,
 	NVME_SC_CTRL_LIST_INVALID	= 0x11c,
+	NVME_SC_BP_WRITE_PROHIBITED	= 0x11e,
+	NVME_SC_PMR_SAN_PROHIBITED	= 0x123,
 	/*
 	 * I/O Command Set Specific - NVM commands:
 	NVME_SC_ANA_INACCESSIBLE	= 0x302,
 	NVME_SC_ANA_TRANSITION		= 0x303,
 	NVME_SC_HOST_PATH_ERROR		= 0x370,
+	NVME_SC_HOST_ABORTED_CMD	= 0x371,
 	NVME_SC_CRD			= 0x1800,
 	NVME_SC_DNR			= 0x4000,

include/linux/nvmem-consumer.h+10−1

 int nvmem_register_notifier(struct notifier_block *nb);
 int nvmem_unregister_notifier(struct notifier_block *nb);
+struct nvmem_device *nvmem_device_find(void *data,
+			int (*match)(struct device *dev, const void *data));
 #else
 static inline struct nvmem_cell *nvmem_cell_get(struct device *dev,
 }
 static inline int nvmem_cell_write(struct nvmem_cell *cell,
-				    const char *buf, size_t len)
+				   void *buf, size_t len)
 {
 	return -EOPNOTSUPP;
 }
 	return -EOPNOTSUPP;
 }
+static inline struct nvmem_device *nvmem_device_find(void *data,
+			int (*match)(struct device *dev, const void *data))
+{
+	return NULL;
+}
 #endif /* CONFIG_NVMEM */
 #if IS_ENABLED(CONFIG_NVMEM) && IS_ENABLED(CONFIG_OF)

include/linux/of_address.h+1−20

 	const __be32 *end;
 	int np;
 	int pna;
+	bool dma;
 };
 struct of_pci_range {
 extern u64 of_translate_address(struct device_node *np, const __be32 *addr);
 extern int of_address_to_resource(struct device_node *dev, int index,
 				  struct resource *r);
-extern struct device_node *of_find_matching_node_by_address(
-					struct device_node *from,
-					const struct of_device_id *matches,
-					u64 base_address);
 extern void __iomem *of_iomap(struct device_node *device, int index);
 void __iomem *of_io_request_and_map(struct device_node *device,
 				    int index, const char *name);
 extern struct of_pci_range *of_pci_range_parser_one(
 					struct of_pci_range_parser *parser,
 					struct of_pci_range *range);
-extern int of_dma_get_range(struct device_node *np, u64 *dma_addr,
-				u64 *paddr, u64 *size);
 extern bool of_dma_is_coherent(struct device_node *np);
 #else /* CONFIG_OF_ADDRESS */
 static inline void __iomem *of_io_request_and_map(struct device_node *device,
 	return OF_BAD_ADDR;
 }
-static inline struct device_node *of_find_matching_node_by_address(
-					struct device_node *from,
-					const struct of_device_id *matches,
-					u64 base_address)
-{
-	return NULL;
-}
 static inline const __be32 *of_get_address(struct device_node *dev, int index,
 					u64 *size, unsigned int *flags)
 {
 	return NULL;
 }
-static inline int of_dma_get_range(struct device_node *np, u64 *dma_addr,
-				u64 *paddr, u64 *size)
-{
-	return -ENODEV;
-}
 static inline bool of_dma_is_coherent(struct device_node *np)
 {
 	return false;

include/linux/of_mdio.h+6−0

 #include <linux/of.h>
 #if IS_ENABLED(CONFIG_OF_MDIO)
+extern bool of_mdiobus_child_is_phy(struct device_node *child);
 extern int of_mdiobus_register(struct mii_bus *mdio, struct device_node *np);
 extern struct phy_device *of_phy_find_device(struct device_node *phy_np);
 extern struct phy_device *of_phy_connect(struct net_device *dev,
 }
 #else /* CONFIG_OF_MDIO */
+static bool of_mdiobus_child_is_phy(struct device_node *child)
+{
+	return false;
+}
 static inline int of_mdiobus_register(struct mii_bus *mdio, struct device_node *np)
 {
 	/*

include/linux/of_net.h+5−2

 #ifndef __LINUX_OF_NET_H
 #define __LINUX_OF_NET_H
+#include <linux/phy.h>
 #ifdef CONFIG_OF_NET
 #include <linux/of.h>
 struct net_device;
-extern int of_get_phy_mode(struct device_node *np);
+extern int of_get_phy_mode(struct device_node *np, phy_interface_t *interface);
 extern const void *of_get_mac_address(struct device_node *np);
 extern struct net_device *of_find_net_device_by_node(struct device_node *np);
 #else
-static inline int of_get_phy_mode(struct device_node *np)
+static inline int of_get_phy_mode(struct device_node *np,
+				  phy_interface_t *interface)
 {
 	return -ENODEV;
 }

include/linux/of_pci.h+2−3

 #ifndef __OF_PCI_H
 #define __OF_PCI_H
-#include <linux/pci.h>
+#include <linux/types.h>
-#include <linux/msi.h>
+#include <linux/errno.h>
 struct pci_dev;
-struct of_phandle_args;
 struct device_node;
 #if IS_ENABLED(CONFIG_OF) && IS_ENABLED(CONFIG_PCI)

include/linux/page-isolation.h+2−2

@@ -30,7 +30,7 @@ static inline bool is_migrate_isolate(int migratetype) · 29 unmodified lines
30	}	30	}
31	#endif	31	#endif
32		32
33	#define SKIP_HWPOISON 0x1	33	#define MEMORY_OFFLINE 0x1
34	#define REPORT_FAILURE 0x2	34	#define REPORT_FAILURE 0x2
35		35
36	bool has_unmovable_pages(struct zone zone, struct page page, int count,	36	bool has_unmovable_pages(struct zone zone, struct page page, int count,
@@ -58,7 +58,7 @@ undo_isolate_page_range(unsigned long start_pfn, unsigned long end_pfn, · 21 unmodified lines
58	* Test all pages in [start_pfn, end_pfn) are isolated or not.	58	* Test all pages in [start_pfn, end_pfn) are isolated or not.
59	*/	59	*/
60	int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn,	60	int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn,
61	bool skip_hwpoisoned_pages);	61	int isol_flags);
62		62
63	struct page alloc_migrate_target(struct page page, unsigned long private);	63	struct page alloc_migrate_target(struct page page, unsigned long private);
64		64

include/linux/pagewalk.h+9−0

  *			"do page table walk over the current vma", returning
  *			a negative value means "abort current page table walk
  *			right now" and returning 1 means "skip the current vma"
+ * @pre_vma:            if set, called before starting walk on a non-null vma.
+ * @post_vma:           if set, called after a walk on a non-null vma, provided
+ *                      that @pre_vma and the vma walk succeeded.
  */
 struct mm_walk_ops {
 	int (*pud_entry)(pud_t *pud, unsigned long addr,
 			     struct mm_walk *walk);
 	int (*test_walk)(unsigned long addr, unsigned long next,
 			struct mm_walk *walk);
+	int (*pre_vma)(unsigned long start, unsigned long end,
+		       struct mm_walk *walk);
+	void (*post_vma)(struct mm_walk *walk);
 };
 /**
 		void *private);
 int walk_page_vma(struct vm_area_struct *vma, const struct mm_walk_ops *ops,
 		void *private);
+int walk_page_mapping(struct address_space *mapping, pgoff_t first_index,
+		      pgoff_t nr, const struct mm_walk_ops *ops,
+		      void *private);
 #endif /* _LINUX_PAGEWALK_H */

include/linux/parport.h+1−0

@@ -460,6 +460,7 @@ extern size_t parport_ieee1284_epp_read_addr (struct parport *, · 459 unmodified lines
460	void *, size_t, int);	460	void *, size_t, int);
461		461
462	/* IEEE1284.3 functions */	462	/* IEEE1284.3 functions */
		463	#define daisy_dev_name "Device ID probe"
463	extern int parport_daisy_init (struct parport *port);	464	extern int parport_daisy_init (struct parport *port);
464	extern void parport_daisy_fini (struct parport *port);	465	extern void parport_daisy_fini (struct parport *port);
465	extern struct pardevice parport_open (int devnum, const char name);	466	extern struct pardevice parport_open (int devnum, const char name);

include/linux/pci-ats.h+21−56

@@ -4,74 +4,39 @@ · 3 unmodified lines
4		4
5	#include <linux/pci.h>	5	#include <linux/pci.h>
6		6
7	#ifdef CONFIG_PCI_PRI	7	#ifdef CONFIG_PCI_ATS
		8	/* Address Translation Service */
		9	int pci_enable_ats(struct pci_dev *dev, int ps);
		10	void pci_disable_ats(struct pci_dev *dev);
		11	int pci_ats_queue_depth(struct pci_dev *dev);
		12	int pci_ats_page_aligned(struct pci_dev *dev);
		13	#else /* CONFIG_PCI_ATS */
		14	static inline int pci_enable_ats(struct pci_dev *d, int ps)
		15	{ return -ENODEV; }
		16	static inline void pci_disable_ats(struct pci_dev *d) { }
		17	static inline int pci_ats_queue_depth(struct pci_dev *d)
		18	{ return -ENODEV; }
		19	static inline int pci_ats_page_aligned(struct pci_dev *dev)
		20	{ return 0; }
		21	#endif /* CONFIG_PCI_ATS */
8		22
		23	#ifdef CONFIG_PCI_PRI
9	int pci_enable_pri(struct pci_dev *pdev, u32 reqs);	24	int pci_enable_pri(struct pci_dev *pdev, u32 reqs);
10	void pci_disable_pri(struct pci_dev *pdev);	25	void pci_disable_pri(struct pci_dev *pdev);
11	void pci_restore_pri_state(struct pci_dev *pdev);
12	int pci_reset_pri(struct pci_dev *pdev);	26	int pci_reset_pri(struct pci_dev *pdev);
13		27	int pci_prg_resp_pasid_required(struct pci_dev *pdev);
14	#else /* CONFIG_PCI_PRI */
15
16	static inline int pci_enable_pri(struct pci_dev *pdev, u32 reqs)
17	{
18	return -ENODEV;
19	}
20
21	static inline void pci_disable_pri(struct pci_dev *pdev)
22	{
23	}
24
25	static inline void pci_restore_pri_state(struct pci_dev *pdev)
26	{
27	}
28
29	static inline int pci_reset_pri(struct pci_dev *pdev)
30	{
31	return -ENODEV;
32	}
33
34	#endif /* CONFIG_PCI_PRI */	28	#endif /* CONFIG_PCI_PRI */
35		29
36	#ifdef CONFIG_PCI_PASID	30	#ifdef CONFIG_PCI_PASID
37
38	int pci_enable_pasid(struct pci_dev *pdev, int features);	31	int pci_enable_pasid(struct pci_dev *pdev, int features);
39	void pci_disable_pasid(struct pci_dev *pdev);	32	void pci_disable_pasid(struct pci_dev *pdev);
40	void pci_restore_pasid_state(struct pci_dev *pdev);
41	int pci_pasid_features(struct pci_dev *pdev);	33	int pci_pasid_features(struct pci_dev *pdev);
42	int pci_max_pasids(struct pci_dev *pdev);	34	int pci_max_pasids(struct pci_dev *pdev);
43	int pci_prg_resp_pasid_required(struct pci_dev *pdev);	35	#else /* CONFIG_PCI_PASID */
44
45	#else /* CONFIG_PCI_PASID */
46
47	static inline int pci_enable_pasid(struct pci_dev *pdev, int features)
48	{
49	return -EINVAL;
50	}
51
52	static inline void pci_disable_pasid(struct pci_dev *pdev)
53	{
54	}
55
56	static inline void pci_restore_pasid_state(struct pci_dev *pdev)
57	{
58	}
59
60	static inline int pci_pasid_features(struct pci_dev *pdev)	36	static inline int pci_pasid_features(struct pci_dev *pdev)
61	{	37	{ return -EINVAL; }
62	return -EINVAL;
63	}
64
65	static inline int pci_max_pasids(struct pci_dev *pdev)	38	static inline int pci_max_pasids(struct pci_dev *pdev)
66	{	39	{ return -EINVAL; }
67	return -EINVAL;
68	}
69
70	static inline int pci_prg_resp_pasid_required(struct pci_dev *pdev)
71	{
72	return 0;
73	}
74	#endif /* CONFIG_PCI_PASID */	40	#endif /* CONFIG_PCI_PASID */
75		41
76		42	#endif /* LINUX_PCI_ATS_H */
77	#endif /* LINUX_PCI_ATS_H*/

include/linux/pci-epc.h+1−1

@@ -117,7 +117,7 @@ struct pci_epc_features { · 116 unmodified lines
117	unsigned int msix_capable : 1;	117	unsigned int msix_capable : 1;
118	u8 reserved_bar;	118	u8 reserved_bar;
119	u8 bar_fixed_64bit;	119	u8 bar_fixed_64bit;
120	u64 bar_fixed_size[BAR_5 + 1];	120	u64 bar_fixed_size[PCI_STD_NUM_BARS];
121	size_t align;	121	size_t align;
122	};	122	};
123		123

include/linux/pci.h+29−33

 enum {
 	/* #0-5: standard PCI resources */
 	PCI_STD_RESOURCES,
-	PCI_STD_RESOURCE_END = 5,
+	PCI_STD_RESOURCE_END = PCI_STD_RESOURCES + PCI_STD_NUM_BARS - 1,
 	/* #6: expansion ROM resource */
 	PCI_ROM_RESOURCE,
 struct pcie_link_state;
 struct pci_vpd;
 struct pci_sriov;
-struct pci_ats;
 struct pci_p2pdma;
 /* The pci_dev structure describes PCI devices */
 	};
 	u16		ats_cap;	/* ATS Capability offset */
 	u8		ats_stu;	/* ATS Smallest Translation Unit */
-	atomic_t	ats_ref_cnt;	/* Number of VFs with ATS enabled */
 #endif
 #ifdef CONFIG_PCI_PRI
+	u16		pri_cap;	/* PRI Capability offset */
 	u32		pri_reqs_alloc; /* Number of PRI requests allocated */
+	unsigned int	pasid_required:1; /* PRG Response PASID Required */
 #endif
 #ifdef CONFIG_PCI_PASID
+	u16		pasid_cap;	/* PASID Capability offset */
 	u16		pasid_features;
 #endif
 #ifdef CONFIG_PCI_P2PDMA
  *		The remove function always gets called from process
  *		context, so it can sleep.
  * @suspend:	Put device into low power state.
- * @suspend_late: Put device into low power state.
- * @resume_early: Wake device from low power state.
  * @resume:	Wake device from low power state.
  *		(Please see Documentation/power/pci.rst for descriptions
  *		of PCI Power Management and the related functions.)
 	int  (*probe)(struct pci_dev *dev, const struct pci_device_id *id);	/* New device inserted */
 	void (*remove)(struct pci_dev *dev);	/* Device removed (NULL if not a hot-plug capable driver) */
 	int  (*suspend)(struct pci_dev *dev, pm_message_t state);	/* Device suspended */
-	int  (*suspend_late)(struct pci_dev *dev, pm_message_t state);
-	int  (*resume_early)(struct pci_dev *dev);
 	int  (*resume)(struct pci_dev *dev);	/* Device woken up */
 	void (*shutdown)(struct pci_dev *dev);
 	int  (*sriov_configure)(struct pci_dev *dev, int num_vfs); /* On PF */
 int pci_add_cap_save_buffer(struct pci_dev *dev, char cap, unsigned int size);
 int pci_add_ext_cap_save_buffer(struct pci_dev *dev,
 				u16 cap, unsigned int size);
-int __pci_complete_power_transition(struct pci_dev *dev, pci_power_t state);
+int pci_platform_power_transition(struct pci_dev *dev, pci_power_t state);
 int pci_set_power_state(struct pci_dev *dev, pci_power_t state);
 pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state);
 bool pci_pme_capable(struct pci_dev *dev, pci_power_t state);
 void pci_free_irq_vectors(struct pci_dev *dev);
 int pci_irq_vector(struct pci_dev *dev, unsigned int nr);
 const struct cpumask *pci_irq_get_affinity(struct pci_dev *pdev, int vec);
-int pci_irq_get_node(struct pci_dev *pdev, int vec);
 #else
 static inline int pci_msi_vec_count(struct pci_dev *dev) { return -ENOSYS; }
 {
 	return cpu_possible_mask;
 }
-static inline int pci_irq_get_node(struct pci_dev *pdev, int vec)
-{
-	return first_online_node;
-}
 #endif
 /**
 #define pcie_ports_native	false
 #endif
-#define PCIE_LINK_STATE_L0S	1
+#define PCIE_LINK_STATE_L0S		BIT(0)
-#define PCIE_LINK_STATE_L1	2
+#define PCIE_LINK_STATE_L1		BIT(1)
-#define PCIE_LINK_STATE_CLKPM	4
+#define PCIE_LINK_STATE_CLKPM		BIT(2)
+#define PCIE_LINK_STATE_L1_1		BIT(3)
+#define PCIE_LINK_STATE_L1_2		BIT(4)
+#define PCIE_LINK_STATE_L1_1_PCIPM	BIT(5)
+#define PCIE_LINK_STATE_L1_2_PCIPM	BIT(6)
 #ifdef CONFIG_PCIEASPM
 int pci_disable_link_state(struct pci_dev *pdev, int state);
 static inline void pci_set_master(struct pci_dev *dev) { }
 static inline int pci_enable_device(struct pci_dev *dev) { return -EIO; }
 static inline void pci_disable_device(struct pci_dev *dev) { }
+static inline int pcim_enable_device(struct pci_dev *pdev) { return -EIO; }
 static inline int pci_assign_resource(struct pci_dev *dev, int i)
 { return -EBUSY; }
 static inline int __pci_register_driver(struct pci_driver *drv,
 					      NULL);
 }
-#ifdef CONFIG_PCI_ATS
-/* Address Translation Service */
-int pci_enable_ats(struct pci_dev *dev, int ps);
-void pci_disable_ats(struct pci_dev *dev);
-int pci_ats_queue_depth(struct pci_dev *dev);
-int pci_ats_page_aligned(struct pci_dev *dev);
-#else
-static inline int pci_enable_ats(struct pci_dev *d, int ps) { return -ENODEV; }
-static inline void pci_disable_ats(struct pci_dev *d) { }
-static inline int pci_ats_queue_depth(struct pci_dev *d) { return -ENODEV; }
-static inline int pci_ats_page_aligned(struct pci_dev *dev) { return 0; }
-#endif
 /* Include architecture-dependent settings and functions */
 #include <asm/pci.h>
 struct irq_domain *pci_host_bridge_of_msi_domain(struct pci_bus *bus);
 int pci_parse_request_of_pci_ranges(struct device *dev,
 				    struct list_head *resources,
+				    struct list_head *ib_resources,
 				    struct resource **bus_range);
 /* Arch may override this (weak) */
 #else	/* CONFIG_OF */
 static inline struct irq_domain *
 pci_host_bridge_of_msi_domain(struct pci_bus *bus) { return NULL; }
-static inline int pci_parse_request_of_pci_ranges(struct device *dev,
+static inline int
-						  struct list_head *resources,
+pci_parse_request_of_pci_ranges(struct device *dev,
-						  struct resource **bus_range)
+				struct list_head *resources,
+				struct list_head *ib_resources,
+				struct resource **bus_range)
 {
 	return -EINVAL;
 }
 void
 pci_msi_register_fwnode_provider(struct fwnode_handle *(*fn)(struct device *));
+bool pci_pr3_present(struct pci_dev *pdev);
 #else
 static inline struct irq_domain *
 pci_host_bridge_acpi_msi_domain(struct pci_bus *bus) { return NULL; }
+static inline bool pci_pr3_present(struct pci_dev *pdev) { return false; }
 #endif
 #ifdef CONFIG_EEH
 #define pci_info_ratelimited(pdev, fmt, arg...) \
 	dev_info_ratelimited(&(pdev)->dev, fmt, ##arg)
+#define pci_WARN(pdev, condition, fmt, arg...) \
+	WARN(condition, "%s %s: " fmt, \
+	     dev_driver_string(&(pdev)->dev), pci_name(pdev), ##arg)
+#define pci_WARN_ONCE(pdev, condition, fmt, arg...) \
+	WARN_ONCE(condition, "%s %s: " fmt, \
+		  dev_driver_string(&(pdev)->dev), pci_name(pdev), ##arg)
 #endif /* LINUX_PCI_H */

include/linux/pci_ids.h+1−0

@@ -3006,6 +3006,7 @@ · 3005 unmodified lines
3006	#define PCI_DEVICE_ID_INTEL_84460GX 0x84ea	3006	#define PCI_DEVICE_ID_INTEL_84460GX 0x84ea
3007	#define PCI_DEVICE_ID_INTEL_IXP4XX 0x8500	3007	#define PCI_DEVICE_ID_INTEL_IXP4XX 0x8500
3008	#define PCI_DEVICE_ID_INTEL_IXP2800 0x9004	3008	#define PCI_DEVICE_ID_INTEL_IXP2800 0x9004
		3009	#define PCI_DEVICE_ID_INTEL_VMD_9A0B 0x9a0b
3009	#define PCI_DEVICE_ID_INTEL_S21152BB 0xb152	3010	#define PCI_DEVICE_ID_INTEL_S21152BB 0xb152
3010		3011
3011	#define PCI_VENDOR_ID_SCALEMP 0x8686	3012	#define PCI_VENDOR_ID_SCALEMP 0x8686

include/linux/percpu-refcount.h+8−8

@@ -186,14 +186,14 @@ static inline void percpu_ref_get_many(struct percpu_ref *ref, unsigned long nr) · 185 unmodified lines
186	{	186	{
187	unsigned long __percpu *percpu_count;	187	unsigned long __percpu *percpu_count;
188		188
189	rcu_read_lock_sched();	189	rcu_read_lock();
190		190
191	if (__ref_is_percpu(ref, &percpu_count))	191	if (__ref_is_percpu(ref, &percpu_count))
192	this_cpu_add(*percpu_count, nr);	192	this_cpu_add(*percpu_count, nr);
193	else	193	else
194	atomic_long_add(nr, &ref->count);	194	atomic_long_add(nr, &ref->count);
195		195
196	rcu_read_unlock_sched();	196	rcu_read_unlock();
197	}	197	}
198		198
199	/**	199	/**
@@ -223,7 +223,7 @@ static inline bool percpu_ref_tryget(struct percpu_ref *ref) · 23 unmodified lines
223	unsigned long __percpu *percpu_count;	223	unsigned long __percpu *percpu_count;
224	bool ret;	224	bool ret;
225		225
226	rcu_read_lock_sched();	226	rcu_read_lock();
227		227
228	if (__ref_is_percpu(ref, &percpu_count)) {	228	if (__ref_is_percpu(ref, &percpu_count)) {
229	this_cpu_inc(*percpu_count);	229	this_cpu_inc(*percpu_count);
@@ -232,7 +232,7 @@ static inline bool percpu_ref_tryget(struct percpu_ref *ref) · 2 unmodified lines
232	ret = atomic_long_inc_not_zero(&ref->count);	232	ret = atomic_long_inc_not_zero(&ref->count);
233	}	233	}
234		234
235	rcu_read_unlock_sched();	235	rcu_read_unlock();
236		236
237	return ret;	237	return ret;
238	}	238	}
@@ -257,7 +257,7 @@ static inline bool percpu_ref_tryget_live(struct percpu_ref *ref) · 18 unmodified lines
257	unsigned long __percpu *percpu_count;	257	unsigned long __percpu *percpu_count;
258	bool ret = false;	258	bool ret = false;
259		259
260	rcu_read_lock_sched();	260	rcu_read_lock();
261		261
262	if (__ref_is_percpu(ref, &percpu_count)) {	262	if (__ref_is_percpu(ref, &percpu_count)) {
263	this_cpu_inc(*percpu_count);	263	this_cpu_inc(*percpu_count);
@@ -266,7 +266,7 @@ static inline bool percpu_ref_tryget_live(struct percpu_ref *ref) · 2 unmodified lines
266	ret = atomic_long_inc_not_zero(&ref->count);	266	ret = atomic_long_inc_not_zero(&ref->count);
267	}	267	}
268		268
269	rcu_read_unlock_sched();	269	rcu_read_unlock();
270		270
271	return ret;	271	return ret;
272	}	272	}
@@ -285,14 +285,14 @@ static inline void percpu_ref_put_many(struct percpu_ref *ref, unsigned long nr) · 12 unmodified lines
285	{	285	{
286	unsigned long __percpu *percpu_count;	286	unsigned long __percpu *percpu_count;
287		287
288	rcu_read_lock_sched();	288	rcu_read_lock();
289		289
290	if (__ref_is_percpu(ref, &percpu_count))	290	if (__ref_is_percpu(ref, &percpu_count))
291	this_cpu_sub(*percpu_count, nr);	291	this_cpu_sub(*percpu_count, nr);
292	else if (unlikely(atomic_long_sub_and_test(nr, &ref->count)))	292	else if (unlikely(atomic_long_sub_and_test(nr, &ref->count)))
293	ref->release(ref);	293	ref->release(ref);
294		294
295	rcu_read_unlock_sched();	295	rcu_read_unlock();
296	}	296	}
297		297
298	/**	298	/**

include/linux/percpu-rwsem.h+2−2

@@ -93,7 +93,7 @@ static inline void percpu_up_read(struct percpu_rw_semaphore *sem) · 92 unmodified lines
93	__percpu_up_read(sem); /* Unconditional memory barrier */	93	__percpu_up_read(sem); /* Unconditional memory barrier */
94	preempt_enable();	94	preempt_enable();
95		95
96	rwsem_release(&sem->rw_sem.dep_map, 1, _RET_IP_);	96	rwsem_release(&sem->rw_sem.dep_map, _RET_IP_);
97	}	97	}
98		98
99	extern void percpu_down_write(struct percpu_rw_semaphore *);	99	extern void percpu_down_write(struct percpu_rw_semaphore *);
@@ -118,7 +118,7 @@ extern void percpu_free_rwsem(struct percpu_rw_semaphore *); · 18 unmodified lines
118	static inline void percpu_rwsem_release(struct percpu_rw_semaphore *sem,	118	static inline void percpu_rwsem_release(struct percpu_rw_semaphore *sem,
119	bool read, unsigned long ip)	119	bool read, unsigned long ip)
120	{	120	{
121	lock_release(&sem->rw_sem.dep_map, 1, ip);	121	lock_release(&sem->rw_sem.dep_map, ip);
122	#ifdef CONFIG_RWSEM_SPIN_ON_OWNER	122	#ifdef CONFIG_RWSEM_SPIN_ON_OWNER
123	if (!read)	123	if (!read)
124	atomic_long_set(&sem->rw_sem.owner, RWSEM_OWNER_UNKNOWN);	124	atomic_long_set(&sem->rw_sem.owner, RWSEM_OWNER_UNKNOWN);

include/linux/perf_event.h+69−5

 #include <linux/perf_regs.h>
 #include <linux/cgroup.h>
 #include <linux/refcount.h>
+#include <linux/security.h>
 #include <asm/local.h>
 struct perf_callchain_entry {
 #define PERF_PMU_CAP_NO_EXCLUDE			0x80
 #define PERF_PMU_CAP_AUX_OUTPUT			0x100
+struct perf_output_handle;
 /**
  * struct pmu - generic performance monitoring unit
  */
 	 */
 	size_t				task_ctx_size;
+	/*
+	 * PMU specific parts of task perf event context (i.e. ctx->task_ctx_data)
+	 * can be synchronized using this function. See Intel LBR callstack support
+	 * implementation and Perf core context switch handling callbacks for usage
+	 * examples.
+	 */
+	void (*swap_task_ctx)		(struct perf_event_context *prev,
+					 struct perf_event_context *next);
+					/* optional */
 	/*
 	 * Set up pmu-private data structures for an AUX area
 	 */
 	void (*free_aux)		(void *aux); /* optional */
+	/*
+	 * Take a snapshot of the AUX buffer without touching the event
+	 * state, so that preempting ->start()/->stop() callbacks does
+	 * not interfere with their logic. Called in PMI context.
+	 *
+	 * Returns the size of AUX data copied to the output handle.
+	 *
+	 * Optional.
+	 */
+	long (*snapshot_aux)		(struct perf_event *event,
+					 struct perf_output_handle *handle,
+					 unsigned long size);
 	/*
 	 * Validate address range filters: make sure the HW supports the
 	 * requested configuration and number of filters; return 0 if the
 	struct perf_cgroup		*cgrp; /* cgroup event is attach to */
 #endif
+#ifdef CONFIG_SECURITY
+	void *security;
+#endif
 	struct list_head		sb_list;
 #endif /* CONFIG_PERF_EVENTS */
 };
 		u32	reserved;
 	}				cpu_entry;
 	struct perf_callchain_entry	*callchain;
+	u64				aux_size;
 	/*
 	 * regs_user may point to task_pt_regs or to regs_user_copy, depending
 int perf_event_max_stack_handler(struct ctl_table *table, int write,
 				 void __user *buffer, size_t *lenp, loff_t *ppos);
-static inline bool perf_paranoid_tracepoint_raw(void)
+/* Access to perf_event_open(2) syscall. */
+#define PERF_SECURITY_OPEN		0
+/* Finer grained perf_event_open(2) access control. */
+#define PERF_SECURITY_CPU		1
+#define PERF_SECURITY_KERNEL		2
+#define PERF_SECURITY_TRACEPOINT	3
+static inline int perf_is_paranoid(void)
 {
 	return sysctl_perf_event_paranoid > -1;
 }
-static inline bool perf_paranoid_cpu(void)
+static inline int perf_allow_kernel(struct perf_event_attr *attr)
+{
+	if (sysctl_perf_event_paranoid > 1 && !capable(CAP_SYS_ADMIN))
+		return -EACCES;
+	return security_perf_event_open(attr, PERF_SECURITY_KERNEL);
+}
+static inline int perf_allow_cpu(struct perf_event_attr *attr)
 {
-	return sysctl_perf_event_paranoid > 0;
+	if (sysctl_perf_event_paranoid > 0 && !capable(CAP_SYS_ADMIN))
+		return -EACCES;
+	return security_perf_event_open(attr, PERF_SECURITY_CPU);
 }
-static inline bool perf_paranoid_kernel(void)
+static inline int perf_allow_tracepoint(struct perf_event_attr *attr)
 {
-	return sysctl_perf_event_paranoid > 1;
+	if (sysctl_perf_event_paranoid > -1 && !capable(CAP_SYS_ADMIN))
+		return -EPERM;
+	return security_perf_event_open(attr, PERF_SECURITY_TRACEPOINT);
 }
 extern void perf_event_init(void);
 			     const void *buf, unsigned int len);
 extern unsigned int perf_output_skip(struct perf_output_handle *handle,
 				     unsigned int len);
+extern long perf_output_copy_aux(struct perf_output_handle *aux_handle,
+				 struct perf_output_handle *handle,
+				 unsigned long from, unsigned long to);
 extern int perf_swevent_get_recursion_context(void);
 extern void perf_swevent_put_recursion_context(int rctx);
 extern u64 perf_swevent_set_period(struct perf_event *event);
 extern void perf_event_disable_inatomic(struct perf_event *event);
 extern void perf_event_task_tick(void);
 extern int perf_event_account_interrupt(struct perf_event *event);
+extern int perf_event_period(struct perf_event *event, u64 value);
+extern u64 perf_event_pause(struct perf_event *event, bool reset);
 #else /* !CONFIG_PERF_EVENTS: */
 static inline void *
 perf_aux_output_begin(struct perf_output_handle *handle,
 static inline int __perf_event_disable(void *info)			{ return -1; }
 static inline void perf_event_task_tick(void)				{ }
 static inline int perf_event_release_kernel(struct perf_event *event)	{ return 0; }
+static inline int perf_event_period(struct perf_event *event, u64 value)
+{
+	return -EINVAL;
+}
+static inline u64 perf_event_pause(struct perf_event *event, bool reset)
+{
+	return 0;
+}
 #endif
 #if defined(CONFIG_PERF_EVENTS) && defined(CONFIG_CPU_SUP_INTEL)

include/linux/phy.h+26−2

 struct device;
 struct phylink;
+struct sfp_bus;
+struct sfp_upstream_ops;
 struct sk_buff;
 /*
  * dev_flags: Device-specific flags used by the PHY driver.
  * irq: IRQ number of the PHY's interrupt (-1 if none)
  * phy_timer: The timer for handling the state machine
+ * sfp_bus_attached: flag indicating whether the SFP bus has been attached
+ * sfp_bus: SFP bus attached to this PHY's fiber port
  * attached_dev: The attached enet driver's device instance ptr
  * adjust_link: Callback for the enet controller to respond to
  * changes in the link state.
 	struct mutex lock;
+	/* This may be modified under the rtnl lock */
+	bool sfp_bus_attached;
+	struct sfp_bus *sfp_bus;
 	struct phylink *phylink;
 	struct net_device *attached_dev;
 int phy_modify_paged(struct phy_device *phydev, int page, u32 regnum,
 		     u16 mask, u16 set);
-struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id,
+struct phy_device *phy_device_create(struct mii_bus *bus, int addr, u32 phy_id,
 				     bool is_c45,
 				     struct phy_c45_device_ids *c45_ids);
 #if IS_ENABLED(CONFIG_PHYLIB)
 int phy_resume(struct phy_device *phydev);
 int __phy_resume(struct phy_device *phydev);
 int phy_loopback(struct phy_device *phydev, bool enable);
+void phy_sfp_attach(void *upstream, struct sfp_bus *bus);
+void phy_sfp_detach(void *upstream, struct sfp_bus *bus);
+int phy_sfp_probe(struct phy_device *phydev,
+	          const struct sfp_upstream_ops *ops);
 struct phy_device *phy_attach(struct net_device *dev, const char *bus_id,
 			      phy_interface_t interface);
 struct phy_device *phy_find_first(struct mii_bus *bus);
 	return dev_name(&phydev->mdio.dev);
 }
+static inline void phy_lock_mdio_bus(struct phy_device *phydev)
+{
+	mutex_lock(&phydev->mdio.bus->mdio_lock);
+}
+static inline void phy_unlock_mdio_bus(struct phy_device *phydev)
+{
+	mutex_unlock(&phydev->mdio.bus->mdio_lock);
+}
 void phy_attached_print(struct phy_device *phydev, const char *fmt, ...)
 	__printf(2, 3);
 void phy_attached_info(struct phy_device *phydev);
 int genphy_write_mmd_unsupported(struct phy_device *phdev, int devnum,
 				 u16 regnum, u16 val);
+/* Clause 37 */
+int genphy_c37_config_aneg(struct phy_device *phydev);
+int genphy_c37_read_status(struct phy_device *phydev);
 /* Clause 45 PHY */
 int genphy_c45_restart_aneg(struct phy_device *phydev);
 int genphy_c45_check_and_restart_aneg(struct phy_device *phydev, bool restart);
 void phy_mac_interrupt(struct phy_device *phydev);
 void phy_start_machine(struct phy_device *phydev);
 void phy_stop_machine(struct phy_device *phydev);
-int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd);
 void phy_ethtool_ksettings_get(struct phy_device *phydev,
 			       struct ethtool_link_ksettings *cmd);
 int phy_ethtool_ksettings_set(struct phy_device *phydev,

include/linux/phy/phy.h+2−1

@@ -38,7 +38,8 @@ enum phy_mode { · 37 unmodified lines
38	PHY_MODE_PCIE,	38	PHY_MODE_PCIE,
39	PHY_MODE_ETHERNET,	39	PHY_MODE_ETHERNET,
40	PHY_MODE_MIPI_DPHY,	40	PHY_MODE_MIPI_DPHY,
41	PHY_MODE_SATA	41	PHY_MODE_SATA,
		42	PHY_MODE_LVDS,
42	};	43	};
43		44
44	/**	45	/**

include/linux/phy/tegra/xusb.h+3−1

@@ -18,5 +18,7 @@ int tegra_xusb_padctl_hsic_set_idle(struct tegra_xusb_padctl *padctl, · 17 unmodified lines
18	unsigned int port, bool idle);	18	unsigned int port, bool idle);
19	int tegra_xusb_padctl_usb3_set_lfps_detect(struct tegra_xusb_padctl *padctl,	19	int tegra_xusb_padctl_usb3_set_lfps_detect(struct tegra_xusb_padctl *padctl,
20	unsigned int port, bool enable);	20	unsigned int port, bool enable);
21		21	int tegra_xusb_padctl_set_vbus_override(struct tegra_xusb_padctl *padctl,
		22	bool val);
		23	int tegra_phy_xusb_utmi_port_reset(struct phy *phy);
22	#endif /* PHY_TEGRA_XUSB_H */	24	#endif /* PHY_TEGRA_XUSB_H */

include/linux/phy_led_triggers.h+1−1

@@ -14,7 +14,7 @@ struct phy_device; · 13 unmodified lines
14	#define PHY_LED_TRIGGER_SPEED_SUFFIX_SIZE 11	14	#define PHY_LED_TRIGGER_SPEED_SUFFIX_SIZE 11
15		15
16	#define PHY_LINK_LED_TRIGGER_NAME_SIZE (MII_BUS_ID_SIZE + \	16	#define PHY_LINK_LED_TRIGGER_NAME_SIZE (MII_BUS_ID_SIZE + \
17	FIELD_SIZEOF(struct mdio_device, addr)+\	17	sizeof_field(struct mdio_device, addr)+\
18	PHY_LED_TRIGGER_SPEED_SUFFIX_SIZE)	18	PHY_LED_TRIGGER_SPEED_SUFFIX_SIZE)
19		19
20	struct phy_led_trigger {	20	struct phy_led_trigger {

include/linux/phylink.h+13−12

 /**
  * struct phylink_mac_ops - MAC operations structure.
  * @validate: Validate and update the link configuration.
- * @mac_link_state: Read the current link state from the hardware.
+ * @mac_pcs_get_state: Read the current link state from the hardware.
  * @mac_config: configure the MAC for the selected mode and state.
  * @mac_an_restart: restart 802.3z BaseX autonegotiation.
  * @mac_link_down: take the link down.
 	void (*validate)(struct phylink_config *config,
 			 unsigned long *supported,
 			 struct phylink_link_state *state);
-	int (*mac_link_state)(struct phylink_config *config,
+	void (*mac_pcs_get_state)(struct phylink_config *config,
-			      struct phylink_link_state *state);
+				  struct phylink_link_state *state);
 	void (*mac_config)(struct phylink_config *config, unsigned int mode,
 			   const struct phylink_link_state *state);
 	void (*mac_an_restart)(struct phylink_config *config);
 	      struct phylink_link_state *state);
 /**
- * mac_link_state() - Read the current link state from the hardware
+ * mac_pcs_get_state() - Read the current inband link state from the hardware
  * @config: a pointer to a &struct phylink_config.
  * @state: a pointer to a &struct phylink_link_state.
  *
- * Read the current link state from the MAC, reporting the current
+ * Read the current inband link state from the MAC PCS, reporting the
- * speed in @state->speed, duplex mode in @state->duplex, pause mode
+ * current speed in @state->speed, duplex mode in @state->duplex, pause
- * in @state->pause using the %MLO_PAUSE_RX and %MLO_PAUSE_TX bits,
+ * mode in @state->pause using the %MLO_PAUSE_RX and %MLO_PAUSE_TX bits,
- * negotiation completion state in @state->an_complete, and link
+ * negotiation completion state in @state->an_complete, and link up state
- * up state in @state->link.
+ * in @state->link. If possible, @state->lp_advertising should also be
+ * populated.
  */
-int mac_link_state(struct phylink_config *config,
+void mac_pcs_get_state(struct phylink_config *config,
-		   struct phylink_link_state *state);
+		       struct phylink_link_state *state);
 /**
  * mac_config() - configure the MAC for the selected mode and state
  *   1000base-X or Cisco SGMII mode depending on the @state->interface
  *   mode). In both cases, link state management (whether the link
  *   is up or not) is performed by the MAC, and reported via the
- *   mac_link_state() callback. Changes in link state must be made
+ *   mac_pcs_get_state() callback. Changes in link state must be made
  *   by calling phylink_mac_change().
  *
  *   If in 802.3z mode, the link speed is fixed, dependent on the

include/linux/pid.h+6−1

 extern void put_pid(struct pid *pid);
 extern struct task_struct *pid_task(struct pid *pid, enum pid_type);
+static inline bool pid_has_task(struct pid *pid, enum pid_type type)
+{
+	return !hlist_empty(&pid->tasks[type]);
+}
 extern struct task_struct *get_pid_task(struct pid *pid, enum pid_type);
 extern struct pid *get_task_pid(struct task_struct *task, enum pid_type type);
 extern struct pid *find_get_pid(int nr);
 extern struct pid *find_ge_pid(int nr, struct pid_namespace *);
-extern struct pid *alloc_pid(struct pid_namespace *ns);
+extern struct pid *alloc_pid(struct pid_namespace *ns, pid_t *set_tid,
+			     size_t set_tid_size);
 extern void free_pid(struct pid *pid);
 extern void disable_pid_allocation(struct pid_namespace *ns);

include/linux/pid_namespace.h+2−0

@@ -12,6 +12,8 @@ · 11 unmodified lines
12	#include <linux/ns_common.h>	12	#include <linux/ns_common.h>
13	#include <linux/idr.h>	13	#include <linux/idr.h>
14		14
		15	/* MAX_PID_NS_LEVEL is needed for limiting size of 'struct pid' */
		16	#define MAX_PID_NS_LEVEL 32
15		17
16	struct fs_pin;	18	struct fs_pin;
17		19

include/linux/pipe_fs_i.h+60−6

@@ -30,14 +30,14 @@ struct pipe_buffer { · 29 unmodified lines
30	* struct pipe_inode_info - a linux kernel pipe	30	* struct pipe_inode_info - a linux kernel pipe
31	* @mutex: mutex protecting the whole thing	31	* @mutex: mutex protecting the whole thing
32	* @wait: reader/writer wait point in case of empty/full pipe	32	* @wait: reader/writer wait point in case of empty/full pipe
33	* @nrbufs: the number of non-empty pipe buffers in this pipe	33	* @head: The point of buffer production
34	* @buffers: total number of buffers (should be a power of 2)	34	* @tail: The point of buffer consumption
35	* @curbuf: the current pipe buffer entry	35	* @max_usage: The maximum number of slots that may be used in the ring
		36	* @ring_size: total number of buffers (should be a power of 2)
36	* @tmp_page: cached released page	37	* @tmp_page: cached released page
37	* @readers: number of current readers of this pipe	38	* @readers: number of current readers of this pipe
38	* @writers: number of current writers of this pipe	39	* @writers: number of current writers of this pipe
39	* @files: number of struct file referring this pipe (protected by ->i_lock)	40	* @files: number of struct file referring this pipe (protected by ->i_lock)
40	* @waiting_writers: number of writers blocked waiting for room
41	* @r_counter: reader counter	41	* @r_counter: reader counter
42	* @w_counter: writer counter	42	* @w_counter: writer counter
43	* @fasync_readers: reader side fasync	43	* @fasync_readers: reader side fasync
@@ -48,11 +48,13 @@ struct pipe_buffer { · 4 unmodified lines
48	struct pipe_inode_info {	48	struct pipe_inode_info {
49	struct mutex mutex;	49	struct mutex mutex;
50	wait_queue_head_t wait;	50	wait_queue_head_t wait;
51	unsigned int nrbufs, curbuf, buffers;	51	unsigned int head;
		52	unsigned int tail;
		53	unsigned int max_usage;
		54	unsigned int ring_size;
52	unsigned int readers;	55	unsigned int readers;
53	unsigned int writers;	56	unsigned int writers;
54	unsigned int files;	57	unsigned int files;
55	unsigned int waiting_writers;
56	unsigned int r_counter;	58	unsigned int r_counter;
57	unsigned int w_counter;	59	unsigned int w_counter;
58	struct page *tmp_page;	60	struct page *tmp_page;
@@ -104,6 +106,58 @@ struct pipe_buf_operations { · 45 unmodified lines
104	bool (get)(struct pipe_inode_info , struct pipe_buffer *);	106	bool (get)(struct pipe_inode_info , struct pipe_buffer *);
105	};	107	};
106		108
		109	/**
		110	* pipe_empty - Return true if the pipe is empty
		111	* @head: The pipe ring head pointer
		112	* @tail: The pipe ring tail pointer
		113	*/
		114	static inline bool pipe_empty(unsigned int head, unsigned int tail)
		115	{
		116	return head == tail;
		117	}
		118
		119	/**
		120	* pipe_occupancy - Return number of slots used in the pipe
		121	* @head: The pipe ring head pointer
		122	* @tail: The pipe ring tail pointer
		123	*/
		124	static inline unsigned int pipe_occupancy(unsigned int head, unsigned int tail)
		125	{
		126	return head - tail;
		127	}
		128
		129	/**
		130	* pipe_full - Return true if the pipe is full
		131	* @head: The pipe ring head pointer
		132	* @tail: The pipe ring tail pointer
		133	* @limit: The maximum amount of slots available.
		134	*/
		135	static inline bool pipe_full(unsigned int head, unsigned int tail,
		136	unsigned int limit)
		137	{
		138	return pipe_occupancy(head, tail) >= limit;
		139	}
		140
		141	/**
		142	* pipe_space_for_user - Return number of slots available to userspace
		143	* @head: The pipe ring head pointer
		144	* @tail: The pipe ring tail pointer
		145	* @pipe: The pipe info structure
		146	*/
		147	static inline unsigned int pipe_space_for_user(unsigned int head, unsigned int tail,
		148	struct pipe_inode_info *pipe)
		149	{
		150	unsigned int p_occupancy, p_space;
		151
		152	p_occupancy = pipe_occupancy(head, tail);
		153	if (p_occupancy >= pipe->max_usage)
		154	return 0;
		155	p_space = pipe->ring_size - p_occupancy;
		156	if (p_space > pipe->max_usage)
		157	p_space = pipe->max_usage;
		158	return p_space;
		159	}
		160
107	/**	161	/**
108	* pipe_buf_get - get a reference to a pipe_buffer	162	* pipe_buf_get - get a reference to a pipe_buffer
109	* @pipe: the pipe that the buffer belongs to	163	* @pipe: the pipe that the buffer belongs to

include/linux/platform_data/cros_ec_commands.h+220−65

@@ -556,6 +556,9 @@ enum host_event_code { · 555 unmodified lines
556	/* Keyboard recovery combo with hardware reinitialization */	556	/* Keyboard recovery combo with hardware reinitialization */
557	EC_HOST_EVENT_KEYBOARD_RECOVERY_HW_REINIT = 30,	557	EC_HOST_EVENT_KEYBOARD_RECOVERY_HW_REINIT = 30,
558		558
		559	/* WoV */
		560	EC_HOST_EVENT_WOV = 31,
		561
559	/*	562	/*
560	* The high bit of the event mask is not used as a host event code. If	563	* The high bit of the event mask is not used as a host event code. If
561	* it reads back as set, then the entire event mask should be	564	* it reads back as set, then the entire event mask should be
@@ -1277,8 +1280,6 @@ enum ec_feature_code { · 715 unmodified lines
1277	* MOTIONSENSE_CMD_TABLET_MODE_LID_ANGLE.	1280	* MOTIONSENSE_CMD_TABLET_MODE_LID_ANGLE.
1278	*/	1281	*/
1279	EC_FEATURE_REFINED_TABLET_MODE_HYSTERESIS = 37,	1282	EC_FEATURE_REFINED_TABLET_MODE_HYSTERESIS = 37,
1280	/* EC supports audio codec. */
1281	EC_FEATURE_AUDIO_CODEC = 38,
1282	/* The MCU is a System Companion Processor (SCP). */	1283	/* The MCU is a System Companion Processor (SCP). */
1283	EC_FEATURE_SCP = 39,	1284	EC_FEATURE_SCP = 39,
1284	/* The MCU is an Integrated Sensor Hub */	1285	/* The MCU is an Integrated Sensor Hub */
@@ -4468,92 +4469,246 @@ enum mkbp_cec_event { · 3183 unmodified lines
4468		4469
4469	/*****************************************************************************/	4470	/*****************************************************************************/
4470		4471
4471	/* Commands for I2S recording on audio codec. */	4472	/* Commands for audio codec. */
		4473	#define EC_CMD_EC_CODEC 0x00BC
4472		4474
4473	#define EC_CMD_CODEC_I2S 0x00BC	4475	enum ec_codec_subcmd {
4474	#define EC_WOV_I2S_SAMPLE_RATE 48000	4476	EC_CODEC_GET_CAPABILITIES = 0x0,
		4477	EC_CODEC_GET_SHM_ADDR = 0x1,
		4478	EC_CODEC_SET_SHM_ADDR = 0x2,
		4479	EC_CODEC_SUBCMD_COUNT,
		4480	};
4475		4481
4476	enum ec_codec_i2s_subcmd {	4482	enum ec_codec_cap {
4477	EC_CODEC_SET_SAMPLE_DEPTH = 0x0,	4483	EC_CODEC_CAP_WOV_AUDIO_SHM = 0,
4478	EC_CODEC_SET_GAIN = 0x1,	4484	EC_CODEC_CAP_WOV_LANG_SHM = 1,
4479	EC_CODEC_GET_GAIN = 0x2,	4485	EC_CODEC_CAP_LAST = 32,
4480	EC_CODEC_I2S_ENABLE = 0x3,
4481	EC_CODEC_I2S_SET_CONFIG = 0x4,
4482	EC_CODEC_I2S_SET_TDM_CONFIG = 0x5,
4483	EC_CODEC_I2S_SET_BCLK = 0x6,
4484	EC_CODEC_I2S_SUBCMD_COUNT = 0x7,
4485	};	4486	};
4486		4487
4487	enum ec_sample_depth_value {	4488	enum ec_codec_shm_id {
4488	EC_CODEC_SAMPLE_DEPTH_16 = 0,	4489	EC_CODEC_SHM_ID_WOV_AUDIO = 0x0,
4489	EC_CODEC_SAMPLE_DEPTH_24 = 1,	4490	EC_CODEC_SHM_ID_WOV_LANG = 0x1,
		4491	EC_CODEC_SHM_ID_LAST,
4490	};	4492	};
4491		4493
4492	enum ec_i2s_config {	4494	enum ec_codec_shm_type {
4493	EC_DAI_FMT_I2S = 0,	4495	EC_CODEC_SHM_TYPE_EC_RAM = 0x0,
4494	EC_DAI_FMT_RIGHT_J = 1,	4496	EC_CODEC_SHM_TYPE_SYSTEM_RAM = 0x1,
4495	EC_DAI_FMT_LEFT_J = 2,
4496	EC_DAI_FMT_PCM_A = 3,
4497	EC_DAI_FMT_PCM_B = 4,
4498	EC_DAI_FMT_PCM_TDM = 5,
4499	};	4497	};
4500		4498
4501	/*	4499	struct __ec_align1 ec_param_ec_codec_get_shm_addr {
4502	* For subcommand EC_CODEC_GET_GAIN.	4500	uint8_t shm_id;
4503	*/	4501	uint8_t reserved[3];
4504	struct __ec_align1 ec_codec_i2s_gain {	4502	};
		4503
		4504	struct __ec_align4 ec_param_ec_codec_set_shm_addr {
		4505	uint64_t phys_addr;
		4506	uint32_t len;
		4507	uint8_t shm_id;
		4508	uint8_t reserved[3];
		4509	};
		4510
		4511	struct __ec_align4 ec_param_ec_codec {
		4512	uint8_t cmd; /* enum ec_codec_subcmd */
		4513	uint8_t reserved[3];
		4514
		4515	union {
		4516	struct ec_param_ec_codec_get_shm_addr
		4517	get_shm_addr_param;
		4518	struct ec_param_ec_codec_set_shm_addr
		4519	set_shm_addr_param;
		4520	};
		4521	};
		4522
		4523	struct __ec_align4 ec_response_ec_codec_get_capabilities {
		4524	uint32_t capabilities;
		4525	};
		4526
		4527	struct __ec_align4 ec_response_ec_codec_get_shm_addr {
		4528	uint64_t phys_addr;
		4529	uint32_t len;
		4530	uint8_t type;
		4531	uint8_t reserved[3];
		4532	};
		4533
		4534	/*****************************************************************************/
		4535
		4536	/* Commands for DMIC on audio codec. */
		4537	#define EC_CMD_EC_CODEC_DMIC 0x00BD
		4538
		4539	enum ec_codec_dmic_subcmd {
		4540	EC_CODEC_DMIC_GET_MAX_GAIN = 0x0,
		4541	EC_CODEC_DMIC_SET_GAIN_IDX = 0x1,
		4542	EC_CODEC_DMIC_GET_GAIN_IDX = 0x2,
		4543	EC_CODEC_DMIC_SUBCMD_COUNT,
		4544	};
		4545
		4546	enum ec_codec_dmic_channel {
		4547	EC_CODEC_DMIC_CHANNEL_0 = 0x0,
		4548	EC_CODEC_DMIC_CHANNEL_1 = 0x1,
		4549	EC_CODEC_DMIC_CHANNEL_2 = 0x2,
		4550	EC_CODEC_DMIC_CHANNEL_3 = 0x3,
		4551	EC_CODEC_DMIC_CHANNEL_4 = 0x4,
		4552	EC_CODEC_DMIC_CHANNEL_5 = 0x5,
		4553	EC_CODEC_DMIC_CHANNEL_6 = 0x6,
		4554	EC_CODEC_DMIC_CHANNEL_7 = 0x7,
		4555	EC_CODEC_DMIC_CHANNEL_COUNT,
		4556	};
		4557
		4558	struct __ec_align1 ec_param_ec_codec_dmic_set_gain_idx {
		4559	uint8_t channel; /* enum ec_codec_dmic_channel */
		4560	uint8_t gain;
		4561	uint8_t reserved[2];
		4562	};
		4563
		4564	struct __ec_align1 ec_param_ec_codec_dmic_get_gain_idx {
		4565	uint8_t channel; /* enum ec_codec_dmic_channel */
		4566	uint8_t reserved[3];
		4567	};
		4568
		4569	struct __ec_align4 ec_param_ec_codec_dmic {
		4570	uint8_t cmd; /* enum ec_codec_dmic_subcmd */
		4571	uint8_t reserved[3];
		4572
		4573	union {
		4574	struct ec_param_ec_codec_dmic_set_gain_idx
		4575	set_gain_idx_param;
		4576	struct ec_param_ec_codec_dmic_get_gain_idx
		4577	get_gain_idx_param;
		4578	};
		4579	};
		4580
		4581	struct __ec_align1 ec_response_ec_codec_dmic_get_max_gain {
		4582	uint8_t max_gain;
		4583	};
		4584
		4585	struct __ec_align1 ec_response_ec_codec_dmic_get_gain_idx {
		4586	uint8_t gain;
		4587	};
		4588
		4589	/*****************************************************************************/
		4590
		4591	/* Commands for I2S RX on audio codec. */
		4592
		4593	#define EC_CMD_EC_CODEC_I2S_RX 0x00BE
		4594
		4595	enum ec_codec_i2s_rx_subcmd {
		4596	EC_CODEC_I2S_RX_ENABLE = 0x0,
		4597	EC_CODEC_I2S_RX_DISABLE = 0x1,
		4598	EC_CODEC_I2S_RX_SET_SAMPLE_DEPTH = 0x2,
		4599	EC_CODEC_I2S_RX_SET_DAIFMT = 0x3,
		4600	EC_CODEC_I2S_RX_SET_BCLK = 0x4,
		4601	EC_CODEC_I2S_RX_SUBCMD_COUNT,
		4602	};
		4603
		4604	enum ec_codec_i2s_rx_sample_depth {
		4605	EC_CODEC_I2S_RX_SAMPLE_DEPTH_16 = 0x0,
		4606	EC_CODEC_I2S_RX_SAMPLE_DEPTH_24 = 0x1,
		4607	EC_CODEC_I2S_RX_SAMPLE_DEPTH_COUNT,
		4608	};
		4609
		4610	enum ec_codec_i2s_rx_daifmt {
		4611	EC_CODEC_I2S_RX_DAIFMT_I2S = 0x0,
		4612	EC_CODEC_I2S_RX_DAIFMT_RIGHT_J = 0x1,
		4613	EC_CODEC_I2S_RX_DAIFMT_LEFT_J = 0x2,
		4614	EC_CODEC_I2S_RX_DAIFMT_COUNT,
		4615	};
		4616
		4617	struct __ec_align1 ec_param_ec_codec_i2s_rx_set_sample_depth {
		4618	uint8_t depth;
		4619	uint8_t reserved[3];
		4620	};
		4621
		4622	struct __ec_align1 ec_param_ec_codec_i2s_rx_set_gain {
4505	uint8_t left;	4623	uint8_t left;
4506	uint8_t right;	4624	uint8_t right;
		4625	uint8_t reserved[2];
4507	};	4626	};
4508		4627
4509	struct __ec_todo_unpacked ec_param_codec_i2s_tdm {	4628	struct __ec_align1 ec_param_ec_codec_i2s_rx_set_daifmt {
4510	int16_t ch0_delay; /* 0 to 496 */	4629	uint8_t daifmt;
4511	int16_t ch1_delay; /* -1 to 496 */	4630	uint8_t reserved[3];
4512	uint8_t adjacent_to_ch0;
4513	uint8_t adjacent_to_ch1;
4514	};	4631	};
4515		4632
4516	struct __ec_todo_packed ec_param_codec_i2s {	4633	struct __ec_align4 ec_param_ec_codec_i2s_rx_set_bclk {
4517	/* enum ec_codec_i2s_subcmd */	4634	uint32_t bclk;
4518	uint8_t cmd;	4635	};
		4636
		4637	struct __ec_align4 ec_param_ec_codec_i2s_rx {
		4638	uint8_t cmd; /* enum ec_codec_i2s_rx_subcmd */
		4639	uint8_t reserved[3];
		4640
4519	union {	4641	union {
4520	/*	4642	struct ec_param_ec_codec_i2s_rx_set_sample_depth
4521	* EC_CODEC_SET_SAMPLE_DEPTH	4643	set_sample_depth_param;
4522	* Value should be one of ec_sample_depth_value.	4644	struct ec_param_ec_codec_i2s_rx_set_daifmt
4523	*/	4645	set_daifmt_param;
4524	uint8_t depth;	4646	struct ec_param_ec_codec_i2s_rx_set_bclk
		4647	set_bclk_param;
		4648	};
		4649	};
4525		4650
4526	/*	4651	/*****************************************************************************/
4527	* EC_CODEC_SET_GAIN	4652	/* Commands for WoV on audio codec. */
4528	* Value should be 0~43 for both channels.	4653
4529	*/	4654	#define EC_CMD_EC_CODEC_WOV 0x00BF
4530	struct ec_codec_i2s_gain gain;	4655
		4656	enum ec_codec_wov_subcmd {
		4657	EC_CODEC_WOV_SET_LANG = 0x0,
		4658	EC_CODEC_WOV_SET_LANG_SHM = 0x1,
		4659	EC_CODEC_WOV_GET_LANG = 0x2,
		4660	EC_CODEC_WOV_ENABLE = 0x3,
		4661	EC_CODEC_WOV_DISABLE = 0x4,
		4662	EC_CODEC_WOV_READ_AUDIO = 0x5,
		4663	EC_CODEC_WOV_READ_AUDIO_SHM = 0x6,
		4664	EC_CODEC_WOV_SUBCMD_COUNT,
		4665	};
4531		4666
4532	/*	4667	/*
4533	* EC_CODEC_I2S_ENABLE	4668	* @hash is SHA256 of the whole language model.
4534	* 1 to enable, 0 to disable.	4669	* @total_len indicates the length of whole language model.
4535	*/	4670	* @offset is the cursor from the beginning of the model.
4536	uint8_t i2s_enable;	4671	* @buf is the packet buffer.
		4672	* @len denotes how many bytes in the buf.
		4673	*/
		4674	struct __ec_align4 ec_param_ec_codec_wov_set_lang {
		4675	uint8_t hash[32];
		4676	uint32_t total_len;
		4677	uint32_t offset;
		4678	uint8_t buf[128];
		4679	uint32_t len;
		4680	};
4537		4681
4538	/*	4682	struct __ec_align4 ec_param_ec_codec_wov_set_lang_shm {
4539	* EC_CODEC_I2S_SET_CONFIG	4683	uint8_t hash[32];
4540	* Value should be one of ec_i2s_config.	4684	uint32_t total_len;
4541	*/	4685	};
4542	uint8_t i2s_config;
4543		4686
4544	/*	4687	struct __ec_align4 ec_param_ec_codec_wov {
4545	* EC_CODEC_I2S_SET_TDM_CONFIG	4688	uint8_t cmd; /* enum ec_codec_wov_subcmd */
4546	* Value should be one of ec_i2s_config.	4689	uint8_t reserved[3];
4547	*/
4548	struct ec_param_codec_i2s_tdm tdm_param;
4549		4690
4550	/*	4691	union {
4551	* EC_CODEC_I2S_SET_BCLK	4692	struct ec_param_ec_codec_wov_set_lang
4552	*/	4693	set_lang_param;
4553	uint32_t bclk;	4694	struct ec_param_ec_codec_wov_set_lang_shm
		4695	set_lang_shm_param;
4554	};	4696	};
4555	};	4697	};
4556		4698
		4699	struct __ec_align4 ec_response_ec_codec_wov_get_lang {
		4700	uint8_t hash[32];
		4701	};
		4702
		4703	struct __ec_align4 ec_response_ec_codec_wov_read_audio {
		4704	uint8_t buf[128];
		4705	uint32_t len;
		4706	};
		4707
		4708	struct __ec_align4 ec_response_ec_codec_wov_read_audio_shm {
		4709	uint32_t offset;
		4710	uint32_t len;
		4711	};
4557		4712
4558	/*****************************************************************************/	4713	/*****************************************************************************/
4559	/* System commands */	4714	/* System commands */

include/linux/platform_data/cros_ec_proto.h+27−111

@@ -12,6 +12,7 @@ · 11 unmodified lines
12	#include <linux/mutex.h>	12	#include <linux/mutex.h>
13	#include <linux/notifier.h>	13	#include <linux/notifier.h>
14		14
		15	#include <linux/mfd/cros_ec.h>
15	#include <linux/platform_data/cros_ec_commands.h>	16	#include <linux/platform_data/cros_ec_commands.h>
16		17
17	#define CROS_EC_DEV_NAME "cros_ec"	18	#define CROS_EC_DEV_NAME "cros_ec"
@@ -115,12 +116,16 @@ struct cros_ec_command { · 97 unmodified lines
115	* code.	116	* code.
116	* @pkt_xfer: Send packet to EC and get response.	117	* @pkt_xfer: Send packet to EC and get response.
117	* @lock: One transaction at a time.	118	* @lock: One transaction at a time.
118	* @mkbp_event_supported: True if this EC supports the MKBP event protocol.	119	* @mkbp_event_supported: 0 if MKBP not supported. Otherwise its value is
		120	* the maximum supported version of the MKBP host event
		121	* command + 1.
119	* @host_sleep_v1: True if this EC supports the sleep v1 command.	122	* @host_sleep_v1: True if this EC supports the sleep v1 command.
120	* @event_notifier: Interrupt event notifier for transport devices.	123	* @event_notifier: Interrupt event notifier for transport devices.
121	* @event_data: Raw payload transferred with the MKBP event.	124	* @event_data: Raw payload transferred with the MKBP event.
122	* @event_size: Size in bytes of the event data.	125	* @event_size: Size in bytes of the event data.
123	* @host_event_wake_mask: Mask of host events that cause wake from suspend.	126	* @host_event_wake_mask: Mask of host events that cause wake from suspend.
		127	* @last_event_time: exact time from the hard irq when we got notified of
		128	* a new event.
124	* @ec: The platform_device used by the mfd driver to interface with the	129	* @ec: The platform_device used by the mfd driver to interface with the
125	* main EC.	130	* main EC.
126	* @pd: The platform_device used by the mfd driver to interface with the	131	* @pd: The platform_device used by the mfd driver to interface with the
@@ -153,7 +158,7 @@ struct cros_ec_device { · 26 unmodified lines
153	int (pkt_xfer)(struct cros_ec_device ec,	158	int (pkt_xfer)(struct cros_ec_device ec,
154	struct cros_ec_command *msg);	159	struct cros_ec_command *msg);
155	struct mutex lock;	160	struct mutex lock;
156	bool mkbp_event_supported;	161	u8 mkbp_event_supported;
157	bool host_sleep_v1;	162	bool host_sleep_v1;
158	struct blocking_notifier_head event_notifier;	163	struct blocking_notifier_head event_notifier;
159		164
@@ -161,20 +166,13 @@ struct cros_ec_device { · 1 unmodified line
161	int event_size;	166	int event_size;
162	u32 host_event_wake_mask;	167	u32 host_event_wake_mask;
163	u32 last_resume_result;	168	u32 last_resume_result;
		169	ktime_t last_event_time;
164		170
165	/* The platform devices used by the mfd driver */	171	/* The platform devices used by the mfd driver */
166	struct platform_device *ec;	172	struct platform_device *ec;
167	struct platform_device *pd;	173	struct platform_device *pd;
168	};	174	};
169		175
170	/**
171	* struct cros_ec_sensor_platform - ChromeOS EC sensor platform information.
172	* @sensor_num: Id of the sensor, as reported by the EC.
173	*/
174	struct cros_ec_sensor_platform {
175	u8 sensor_num;
176	};
177
178	/**	176	/**
179	* struct cros_ec_platform - ChromeOS EC platform information.	177	* struct cros_ec_platform - ChromeOS EC platform information.
180	* @ec_name: Name of EC device (e.g. 'cros-ec', 'cros-pd', ...)	178	* @ec_name: Name of EC device (e.g. 'cros-ec', 'cros-pd', ...)
@@ -187,133 +185,51 @@ struct cros_ec_platform { · 6 unmodified lines
187	u16 cmd_offset;	185	u16 cmd_offset;
188	};	186	};
189		187
190	/**
191	* cros_ec_suspend() - Handle a suspend operation for the ChromeOS EC device.
192	* @ec_dev: Device to suspend.
193	*
194	* This can be called by drivers to handle a suspend event.
195	*
196	* Return: 0 on success or negative error code.
197	*/
198	int cros_ec_suspend(struct cros_ec_device *ec_dev);	188	int cros_ec_suspend(struct cros_ec_device *ec_dev);
199		189
200	/**
201	* cros_ec_resume() - Handle a resume operation for the ChromeOS EC device.
202	* @ec_dev: Device to resume.
203	*
204	* This can be called by drivers to handle a resume event.
205	*
206	* Return: 0 on success or negative error code.
207	*/
208	int cros_ec_resume(struct cros_ec_device *ec_dev);	190	int cros_ec_resume(struct cros_ec_device *ec_dev);
209		191
210	/**
211	* cros_ec_prepare_tx() - Prepare an outgoing message in the output buffer.
212	* @ec_dev: Device to register.
213	* @msg: Message to write.
214	*
215	* This is intended to be used by all ChromeOS EC drivers, but at present
216	* only SPI uses it. Once LPC uses the same protocol it can start using it.
217	* I2C could use it now, with a refactor of the existing code.
218	*
219	* Return: 0 on success or negative error code.
220	*/
221	int cros_ec_prepare_tx(struct cros_ec_device *ec_dev,	192	int cros_ec_prepare_tx(struct cros_ec_device *ec_dev,
222	struct cros_ec_command *msg);	193	struct cros_ec_command *msg);
223		194
224	/**
225	* cros_ec_check_result() - Check ec_msg->result.
226	* @ec_dev: EC device.
227	* @msg: Message to check.
228	*
229	* This is used by ChromeOS EC drivers to check the ec_msg->result for
230	* errors and to warn about them.
231	*
232	* Return: 0 on success or negative error code.
233	*/
234	int cros_ec_check_result(struct cros_ec_device *ec_dev,	195	int cros_ec_check_result(struct cros_ec_device *ec_dev,
235	struct cros_ec_command *msg);	196	struct cros_ec_command *msg);
236		197
237	/**
238	* cros_ec_cmd_xfer() - Send a command to the ChromeOS EC.
239	* @ec_dev: EC device.
240	* @msg: Message to write.
241	*
242	* Call this to send a command to the ChromeOS EC. This should be used
243	* instead of calling the EC's cmd_xfer() callback directly.
244	*
245	* Return: 0 on success or negative error code.
246	*/
247	int cros_ec_cmd_xfer(struct cros_ec_device *ec_dev,	198	int cros_ec_cmd_xfer(struct cros_ec_device *ec_dev,
248	struct cros_ec_command *msg);	199	struct cros_ec_command *msg);
249		200
250	/**
251	* cros_ec_cmd_xfer_status() - Send a command to the ChromeOS EC.
252	* @ec_dev: EC device.
253	* @msg: Message to write.
254	*
255	* This function is identical to cros_ec_cmd_xfer, except it returns success
256	* status only if both the command was transmitted successfully and the EC
257	* replied with success status. It's not necessary to check msg->result when
258	* using this function.
259	*
260	* Return: The number of bytes transferred on success or negative error code.
261	*/
262	int cros_ec_cmd_xfer_status(struct cros_ec_device *ec_dev,	201	int cros_ec_cmd_xfer_status(struct cros_ec_device *ec_dev,
263	struct cros_ec_command *msg);	202	struct cros_ec_command *msg);
264		203
265	/**
266	* cros_ec_register() - Register a new ChromeOS EC, using the provided info.
267	* @ec_dev: Device to register.
268	*
269	* Before calling this, allocate a pointer to a new device and then fill
270	* in all the fields up to the --private-- marker.
271	*
272	* Return: 0 on success or negative error code.
273	*/
274	int cros_ec_register(struct cros_ec_device *ec_dev);	204	int cros_ec_register(struct cros_ec_device *ec_dev);
275		205
276	/**
277	* cros_ec_unregister() - Remove a ChromeOS EC.
278	* @ec_dev: Device to unregister.
279	*
280	* Call this to deregister a ChromeOS EC, then clean up any private data.
281	*
282	* Return: 0 on success or negative error code.
283	*/
284	int cros_ec_unregister(struct cros_ec_device *ec_dev);	206	int cros_ec_unregister(struct cros_ec_device *ec_dev);
285		207
286	/**
287	* cros_ec_query_all() - Query the protocol version supported by the
288	* ChromeOS EC.
289	* @ec_dev: Device to register.
290	*
291	* Return: 0 on success or negative error code.
292	*/
293	int cros_ec_query_all(struct cros_ec_device *ec_dev);	208	int cros_ec_query_all(struct cros_ec_device *ec_dev);
294		209
295	/**	210	int cros_ec_get_next_event(struct cros_ec_device *ec_dev,
296	* cros_ec_get_next_event() - Fetch next event from the ChromeOS EC.	211	bool *wake_event,
297	* @ec_dev: Device to fetch event from.	212	bool *has_more_events);
298	* @wake_event: Pointer to a bool set to true upon return if the event might be	213
299	* treated as a wake event. Ignored if null.	214	u32 cros_ec_get_host_event(struct cros_ec_device *ec_dev);
300	*	215
301	* Return: negative error code on errors; 0 for no data; or else number of	216	int cros_ec_check_features(struct cros_ec_dev *ec, int feature);
302	* bytes received (i.e., an event was retrieved successfully). Event types are	217
303	* written out to @ec_dev->event_data.event_type on success.	218	int cros_ec_get_sensor_count(struct cros_ec_dev *ec);
304	*/	219
305	int cros_ec_get_next_event(struct cros_ec_device ec_dev, bool wake_event);	220	bool cros_ec_handle_event(struct cros_ec_device *ec_dev);
306		221
307	/**	222	/**
308	* cros_ec_get_host_event() - Return a mask of event set by the ChromeOS EC.	223	* cros_ec_get_time_ns() - Return time in ns.
309	* @ec_dev: Device to fetch event from.
310	*	224	*
311	* When MKBP is supported, when the EC raises an interrupt, we collect the	225	* This is the function used to record the time for last_event_time in struct
312	* events raised and call the functions in the ec notifier. This function	226	* cros_ec_device during the hard irq.
313	* is a helper to know which events are raised.
314	*	227	*
315	* Return: 0 on error or non-zero bitmask of one or more EC_HOST_EVENT_*.	228	* Return: ktime_t format since boot.
316	*/	229	*/
317	u32 cros_ec_get_host_event(struct cros_ec_device *ec_dev);	230	static inline ktime_t cros_ec_get_time_ns(void)
		231	{
		232	return ktime_get_boottime_ns();
		233	}
318		234
319	#endif /* __LINUX_CROS_EC_PROTO_H */	235	#endif /* __LINUX_CROS_EC_PROTO_H */

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

@@ -0,0 +1,30 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	/*
	3	* Chrome OS EC MEMS Sensor Hub driver.
	4	*
	5	* Copyright 2019 Google LLC
	6	*/
	7
	8	#ifndef __LINUX_PLATFORM_DATA_CROS_EC_SENSORHUB_H
	9	#define __LINUX_PLATFORM_DATA_CROS_EC_SENSORHUB_H
	10
	11	#include <linux/platform_data/cros_ec_commands.h>
	12
	13	/**
	14	* struct cros_ec_sensor_platform - ChromeOS EC sensor platform information.
	15	* @sensor_num: Id of the sensor, as reported by the EC.
	16	*/
	17	struct cros_ec_sensor_platform {
	18	u8 sensor_num;
	19	};
	20
	21	/**
	22	* struct cros_ec_sensorhub - Sensor Hub device data.
	23	*
	24	* @ec: Embedded Controller where the hub is located.
	25	*/
	26	struct cros_ec_sensorhub {
	27	struct cros_ec_dev *ec;
	28	};
	29
	30	#endif /* __LINUX_PLATFORM_DATA_CROS_EC_SENSORHUB_H */

include/linux/platform_data/gpio_backlight.h+0−3

@@ -9,9 +9,6 @@ struct device; · 8 unmodified lines
9		9
10	struct gpio_backlight_platform_data {	10	struct gpio_backlight_platform_data {
11	struct device *fbdev;	11	struct device *fbdev;
12	int gpio;
13	int def_value;
14	const char *name;
15	};	12	};
16		13
17	#endif	14	#endif

include/linux/platform_data/hsmmc-omap.h+0−3

@@ -67,9 +67,6 @@ struct omap_hsmmc_platform_data { · 66 unmodified lines
67	/* string specifying a particular variant of hardware */	67	/* string specifying a particular variant of hardware */
68	char *version;	68	char *version;
69		69
70	/* if we have special card, init it using this callback */
71	void (init_card)(struct mmc_card card);
72
73	const char *name;	70	const char *name;
74	u32 ocr_mask;	71	u32 ocr_mask;
75	};	72	};

include/linux/platform_data/i2c-pxa.h+0−4

  */
 #define I2C_ISR_INIT	0x7FF  /* status register init */
-struct i2c_slave_client;
 struct i2c_pxa_platform_data {
-	unsigned int		slave_addr;
-	struct i2c_slave_client	*slave;
 	unsigned int		class;
 	unsigned int		use_pio :1;
 	unsigned int		fast_mode :1;

include/linux/platform_data/intel-spi.h+1−0

@@ -13,6 +13,7 @@ enum intel_spi_type { · 12 unmodified lines
13	INTEL_SPI_BYT = 1,	13	INTEL_SPI_BYT = 1,
14	INTEL_SPI_LPT,	14	INTEL_SPI_LPT,
15	INTEL_SPI_BXT,	15	INTEL_SPI_BXT,
		16	INTEL_SPI_CNL,
16	};	17	};
17		18
18	/**	19	/**

include/linux/platform_data/pixcir_i2c_ts.h+0−64

@@ -1,64 +0,0 @@
1	/* SPDX-License-Identifier: GPL-2.0 */
2	#ifndef _PIXCIR_I2C_TS_H
3	#define _PIXCIR_I2C_TS_H
4
5	/*
6	* Register map
7	*/
8	#define PIXCIR_REG_POWER_MODE 51
9	#define PIXCIR_REG_INT_MODE 52
10
11	/*
12	* Power modes:
13	* active: max scan speed
14	* idle: lower scan speed with automatic transition to active on touch
15	* halt: datasheet says sleep but this is more like halt as the chip
16	* clocks are cut and it can only be brought out of this mode
17	* using the RESET pin.
18	*/
19	enum pixcir_power_mode {
20	PIXCIR_POWER_ACTIVE,
21	PIXCIR_POWER_IDLE,
22	PIXCIR_POWER_HALT,
23	};
24
25	#define PIXCIR_POWER_MODE_MASK 0x03
26	#define PIXCIR_POWER_ALLOW_IDLE (1UL << 2)
27
28	/*
29	* Interrupt modes:
30	* periodical: interrupt is asserted periodicaly
31	* diff coordinates: interrupt is asserted when coordinates change
32	* level on touch: interrupt level asserted during touch
33	* pulse on touch: interrupt pulse asserted druing touch
34	*
35	*/
36	enum pixcir_int_mode {
37	PIXCIR_INT_PERIODICAL,
38	PIXCIR_INT_DIFF_COORD,
39	PIXCIR_INT_LEVEL_TOUCH,
40	PIXCIR_INT_PULSE_TOUCH,
41	};
42
43	#define PIXCIR_INT_MODE_MASK 0x03
44	#define PIXCIR_INT_ENABLE (1UL << 3)
45	#define PIXCIR_INT_POL_HIGH (1UL << 2)
46
47	/**
48	* struct pixcir_irc_chip_data - chip related data
49	* @max_fingers: Max number of fingers reported simultaneously by h/w
50	* @has_hw_ids: Hardware supports finger tracking IDs
51	*
52	*/
53	struct pixcir_i2c_chip_data {
54	u8 max_fingers;
55	bool has_hw_ids;
56	};
57
58	struct pixcir_ts_platform_data {
59	int x_max;
60	int y_max;
61	struct pixcir_i2c_chip_data chip;
62	};
63
64	#endif

include/linux/platform_data/spi-mt65xx.h+0−1

@@ -11,7 +11,6 @@ · 10 unmodified lines
11		11
12	/* Board specific platform_data */	12	/* Board specific platform_data */
13	struct mtk_chip_config {	13	struct mtk_chip_config {
14	u32 cs_pol;
15	u32 sample_sel;	14	u32 sample_sel;
16	};	15	};
17	#endif	16	#endif

include/linux/platform_data/st_sensors_pdata.h+2−0

  * @open_drain: set the interrupt line to be open drain if possible.
  * @spi_3wire: enable spi-3wire mode.
  * @pullups: enable/disable i2c controller pullup resistors.
+ * @wakeup_source: enable/disable device as wakeup generator.
  */
 struct st_sensors_platform_data {
 	u8 drdy_int_pin;
 	bool open_drain;
 	bool spi_3wire;
 	bool pullups;
+	bool wakeup_source;
 };
 #endif /* ST_SENSORS_PDATA_H */

include/linux/platform_data/ti-prm.h+21−0

@@ -0,0 +1,21 @@
	1	/* SPDX-License-Identifier: GPL-2.0-only */
	2	/*
	3	* TI PRM (Power & Reset Manager) platform data
	4	*
	5	* Copyright (C) 2019 Texas Instruments, Inc.
	6	*
	7	* Tero Kristo <t-kristo@ti.com>
	8	*/
	9
	10	#ifndef _LINUX_PLATFORM_DATA_TI_PRM_H
	11	#define _LINUX_PLATFORM_DATA_TI_PRM_H
	12
	13	struct clockdomain;
	14
	15	struct ti_prm_platform_data {
	16	void (clkdm_deny_idle)(struct clockdomain clkdm);
	17	void (clkdm_allow_idle)(struct clockdomain clkdm);
	18	struct clockdomain * (clkdm_lookup)(const char name);
	19	};
	20
	21	#endif /* _LINUX_PLATFORM_DATA_TI_PRM_H */

include/linux/platform_data/ti-sysc.h+2−0

@@ -49,6 +49,8 @@ struct sysc_regbits { · 48 unmodified lines
49	s8 emufree_shift;	49	s8 emufree_shift;
50	};	50	};
51		51
		52	#define SYSC_QUIRK_FORCE_MSTANDBY BIT(20)
		53	#define SYSC_MODULE_QUIRK_AESS BIT(19)
52	#define SYSC_MODULE_QUIRK_SGX BIT(18)	54	#define SYSC_MODULE_QUIRK_SGX BIT(18)
53	#define SYSC_MODULE_QUIRK_HDQ1W BIT(17)	55	#define SYSC_MODULE_QUIRK_HDQ1W BIT(17)
54	#define SYSC_MODULE_QUIRK_I2C BIT(16)	56	#define SYSC_MODULE_QUIRK_I2C BIT(16)

include/linux/platform_data/wilco-ec.h+15−0

  * @data_size: Size of the data buffer used for EC communication.
  * @debugfs_pdev: The child platform_device used by the debugfs sub-driver.
  * @rtc_pdev: The child platform_device used by the RTC sub-driver.
+ * @charger_pdev: Child platform_device used by the charger config sub-driver.
  * @telem_pdev: The child platform_device used by the telemetry sub-driver.
  */
 struct wilco_ec_device {
 	size_t data_size;
 	struct platform_device *debugfs_pdev;
 	struct platform_device *rtc_pdev;
+	struct platform_device *charger_pdev;
 	struct platform_device *telem_pdev;
 };
  */
 int wilco_ec_mailbox(struct wilco_ec_device *ec, struct wilco_ec_message *msg);
+/**
+ * wilco_keyboard_leds_init() - Set up the keyboard backlight LEDs.
+ * @ec: EC device to query.
+ *
+ * After this call, the keyboard backlight will be exposed through a an LED
+ * device at /sys/class/leds.
+ *
+ * This may sleep because it uses wilco_ec_mailbox().
+ *
+ * Return: 0 on success, negative error code on failure.
+ */
+int wilco_keyboard_leds_init(struct wilco_ec_device *ec);
 /*
  * A Property is typically a data item that is stored to NVRAM
  * by the EC. Each of these data items has an index associated

include/linux/platform_device.h+18−52

@@ -57,6 +57,12 @@ platform_find_device_by_driver(struct device *start, · 56 unmodified lines
57	extern void __iomem *	57	extern void __iomem *
58	devm_platform_ioremap_resource(struct platform_device *pdev,	58	devm_platform_ioremap_resource(struct platform_device *pdev,
59	unsigned int index);	59	unsigned int index);
		60	extern void __iomem *
		61	devm_platform_ioremap_resource_wc(struct platform_device *pdev,
		62	unsigned int index);
		63	extern void __iomem *
		64	devm_platform_ioremap_resource_byname(struct platform_device *pdev,
		65	const char *name);
60	extern int platform_get_irq(struct platform_device *, unsigned int);	66	extern int platform_get_irq(struct platform_device *, unsigned int);
61	extern int platform_get_irq_optional(struct platform_device *, unsigned int);	67	extern int platform_get_irq_optional(struct platform_device *, unsigned int);
62	extern int platform_irq_count(struct platform_device *);	68	extern int platform_irq_count(struct platform_device *);
@@ -294,58 +300,6 @@ void platform_unregister_drivers(struct platform_driver * const *drivers, · 231 unmodified lines
294	#define platform_register_drivers(drivers, count) \	300	#define platform_register_drivers(drivers, count) \
295	__platform_register_drivers(drivers, count, THIS_MODULE)	301	__platform_register_drivers(drivers, count, THIS_MODULE)
296		302
297	/* early platform driver interface */
298	struct early_platform_driver {
299	const char *class_str;
300	struct platform_driver *pdrv;
301	struct list_head list;
302	int requested_id;
303	char *buffer;
304	int bufsize;
305	};
306
307	#define EARLY_PLATFORM_ID_UNSET -2
308	#define EARLY_PLATFORM_ID_ERROR -3
309
310	extern int early_platform_driver_register(struct early_platform_driver *epdrv,
311	char *buf);
312	extern void early_platform_add_devices(struct platform_device **devs, int num);
313
314	static inline int is_early_platform_device(struct platform_device *pdev)
315	{
316	return !pdev->dev.driver;
317	}
318
319	extern void early_platform_driver_register_all(char *class_str);
320	extern int early_platform_driver_probe(char *class_str,
321	int nr_probe, int user_only);
322	extern void early_platform_cleanup(void);
323
324	#define early_platform_init(class_string, platdrv) \
325	early_platform_init_buffer(class_string, platdrv, NULL, 0)
326
327	#ifndef MODULE
328	#define early_platform_init_buffer(class_string, platdrv, buf, bufsiz) \
329	static __initdata struct early_platform_driver early_driver = { \
330	.class_str = class_string, \
331	.buffer = buf, \
332	.bufsize = bufsiz, \
333	.pdrv = platdrv, \
334	.requested_id = EARLY_PLATFORM_ID_UNSET, \
335	}; \
336	static int __init early_platform_driver_setup_func(char *buffer) \
337	{ \
338	return early_platform_driver_register(&early_driver, buffer); \
339	} \
340	early_param(class_string, early_platform_driver_setup_func)
341	#else /* MODULE */
342	#define early_platform_init_buffer(class_string, platdrv, buf, bufsiz) \
343	static inline char *early_platform_driver_setup_func(void) \
344	{ \
345	return bufsiz ? buf : NULL; \
346	}
347	#endif /* MODULE */
348
349	#ifdef CONFIG_SUSPEND	303	#ifdef CONFIG_SUSPEND
350	extern int platform_pm_suspend(struct device *dev);	304	extern int platform_pm_suspend(struct device *dev);
351	extern int platform_pm_resume(struct device *dev);	305	extern int platform_pm_resume(struct device *dev);
@@ -380,4 +334,16 @@ extern int platform_dma_configure(struct device *dev); · 28 unmodified lines
380	#define USE_PLATFORM_PM_SLEEP_OPS	334	#define USE_PLATFORM_PM_SLEEP_OPS
381	#endif	335	#endif
382		336
		337	#ifndef CONFIG_SUPERH
		338	/*
		339	* REVISIT: This stub is needed for all non-SuperH users of early platform
		340	* drivers. It should go away once we introduce the new platform_device-based
		341	* early driver framework.
		342	*/
		343	static inline int is_sh_early_platform_device(struct platform_device *pdev)
		344	{
		345	return 0;
		346	}
		347	#endif /* CONFIG_SUPERH */
		348
383	#endif /* _PLATFORM_DEVICE_H_ */	349	#endif /* _PLATFORM_DEVICE_H_ */

include/linux/pm.h+2−0

  * struct dev_pm_domain - power management domain representation.
  *
  * @ops: Power management operations associated with this domain.
+ * @start: Called when a user needs to start the device via the domain.
  * @detach: Called when removing a device from the domain.
  * @activate: Called before executing probe routines for bus types and drivers.
  * @sync: Called after successful driver probe.
  */
 struct dev_pm_domain {
 	struct dev_pm_ops	ops;
+	int (*start)(struct device *dev);
 	void (*detach)(struct device *dev, bool power_off);
 	int (*activate)(struct device *dev);
 	void (*sync)(struct device *dev);

include/linux/pm_domain.h+5−0

 struct device *dev_pm_domain_attach_by_name(struct device *dev,
 					    const char *name);
 void dev_pm_domain_detach(struct device *dev, bool power_off);
+int dev_pm_domain_start(struct device *dev);
 void dev_pm_domain_set(struct device *dev, struct dev_pm_domain *pd);
 #else
 static inline int dev_pm_domain_attach(struct device *dev, bool power_on)
 	return NULL;
 }
 static inline void dev_pm_domain_detach(struct device *dev, bool power_off) {}
+static inline int dev_pm_domain_start(struct device *dev)
+{
+	return 0;
+}
 static inline void dev_pm_domain_set(struct device *dev,
 				     struct dev_pm_domain *pd) {}
 #endif

include/linux/pm_opp.h+13−0

 enum dev_pm_opp_event {
 	OPP_EVENT_ADD, OPP_EVENT_REMOVE, OPP_EVENT_ENABLE, OPP_EVENT_DISABLE,
+	OPP_EVENT_ADJUST_VOLTAGE,
 };
 /**
 void dev_pm_opp_remove(struct device *dev, unsigned long freq);
 void dev_pm_opp_remove_all_dynamic(struct device *dev);
+int dev_pm_opp_adjust_voltage(struct device *dev, unsigned long freq,
+			      unsigned long u_volt, unsigned long u_volt_min,
+			      unsigned long u_volt_max);
 int dev_pm_opp_enable(struct device *dev, unsigned long freq);
 int dev_pm_opp_disable(struct device *dev, unsigned long freq);
 {
 }
+static inline int
+dev_pm_opp_adjust_voltage(struct device *dev, unsigned long freq,
+			  unsigned long u_volt, unsigned long u_volt_min,
+			  unsigned long u_volt_max)
+{
+	return 0;
+}
 static inline int dev_pm_opp_enable(struct device *dev, unsigned long freq)
 {
 	return 0;

include/linux/pm_qos.h+50−36

 #define PM_QOS_RESUME_LATENCY_NO_CONSTRAINT	PM_QOS_LATENCY_ANY
 #define PM_QOS_RESUME_LATENCY_NO_CONSTRAINT_NS	PM_QOS_LATENCY_ANY_NS
 #define PM_QOS_LATENCY_TOLERANCE_DEFAULT_VALUE	0
+#define PM_QOS_MIN_FREQUENCY_DEFAULT_VALUE	0
+#define PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE	FREQ_QOS_MAX_DEFAULT_VALUE
 #define PM_QOS_LATENCY_TOLERANCE_NO_CONSTRAINT	(-1)
 #define PM_QOS_FLAG_NO_POWER_OFF	(1 << 0)
 	s32 flags;	/* Do not change to 64 bit */
 };
-enum dev_pm_qos_req_type {
-	DEV_PM_QOS_RESUME_LATENCY = 1,
-	DEV_PM_QOS_LATENCY_TOLERANCE,
-	DEV_PM_QOS_FLAGS,
-};
-struct dev_pm_qos_request {
-	enum dev_pm_qos_req_type type;
-	union {
-		struct plist_node pnode;
-		struct pm_qos_flags_request flr;
-	} data;
-	struct device *dev;
-};
 enum pm_qos_type {
 	PM_QOS_UNITIALIZED,
 	PM_QOS_MAX,		/* return the largest value */
 	s32 effective_flags;	/* Do not change to 64 bit */
 };
+#define FREQ_QOS_MIN_DEFAULT_VALUE	0
+#define FREQ_QOS_MAX_DEFAULT_VALUE	S32_MAX
+enum freq_qos_req_type {
+	FREQ_QOS_MIN = 1,
+	FREQ_QOS_MAX,
+};
+struct freq_constraints {
+	struct pm_qos_constraints min_freq;
+	struct blocking_notifier_head min_freq_notifiers;
+	struct pm_qos_constraints max_freq;
+	struct blocking_notifier_head max_freq_notifiers;
+};
+struct freq_qos_request {
+	enum freq_qos_req_type type;
+	struct plist_node pnode;
+	struct freq_constraints *qos;
+};
+enum dev_pm_qos_req_type {
+	DEV_PM_QOS_RESUME_LATENCY = 1,
+	DEV_PM_QOS_LATENCY_TOLERANCE,
+	DEV_PM_QOS_MIN_FREQUENCY,
+	DEV_PM_QOS_MAX_FREQUENCY,
+	DEV_PM_QOS_FLAGS,
+};
+struct dev_pm_qos_request {
+	enum dev_pm_qos_req_type type;
+	union {
+		struct plist_node pnode;
+		struct pm_qos_flags_request flr;
+		struct freq_qos_request freq;
+	} data;
+	struct device *dev;
+};
 struct dev_pm_qos {
 	struct pm_qos_constraints resume_latency;
 	struct pm_qos_constraints latency_tolerance;
+	struct freq_constraints freq;
 	struct pm_qos_flags flags;
 	struct dev_pm_qos_request *resume_latency_req;
 	struct dev_pm_qos_request *latency_tolerance_req;
 	switch (type) {
 	case DEV_PM_QOS_RESUME_LATENCY:
 		return PM_QOS_RESUME_LATENCY_NO_CONSTRAINT;
+	case DEV_PM_QOS_MIN_FREQUENCY:
+		return PM_QOS_MIN_FREQUENCY_DEFAULT_VALUE;
+	case DEV_PM_QOS_MAX_FREQUENCY:
+		return PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE;
 	default:
 		WARN_ON(1);
 		return 0;
 }
 #endif
-#define FREQ_QOS_MIN_DEFAULT_VALUE	0
-#define FREQ_QOS_MAX_DEFAULT_VALUE	(-1)
-enum freq_qos_req_type {
-	FREQ_QOS_MIN = 1,
-	FREQ_QOS_MAX,
-};
-struct freq_constraints {
-	struct pm_qos_constraints min_freq;
-	struct blocking_notifier_head min_freq_notifiers;
-	struct pm_qos_constraints max_freq;
-	struct blocking_notifier_head max_freq_notifiers;
-};
-struct freq_qos_request {
-	enum freq_qos_req_type type;
-	struct plist_node pnode;
-	struct freq_constraints *qos;
-};
 static inline int freq_qos_request_active(struct freq_qos_request *req)
 {
 	return !IS_ERR_OR_NULL(req->qos);
 			 enum freq_qos_req_type type, s32 value);
 int freq_qos_update_request(struct freq_qos_request *req, s32 new_value);
 int freq_qos_remove_request(struct freq_qos_request *req);
+int freq_qos_apply(struct freq_qos_request *req,
+		   enum pm_qos_req_action action, s32 value);
 int freq_qos_add_notifier(struct freq_constraints *qos,
 			  enum freq_qos_req_type type,

include/linux/pm_wakeup.h+9−0

 	bool			autosleep_enabled:1;
 };
+#define for_each_wakeup_source(ws) \
+	for ((ws) = wakeup_sources_walk_start();	\
+	     (ws);					\
+	     (ws) = wakeup_sources_walk_next((ws)))
 #ifdef CONFIG_PM_SLEEP
 /*
 extern struct wakeup_source *wakeup_source_register(struct device *dev,
 						    const char *name);
 extern void wakeup_source_unregister(struct wakeup_source *ws);
+extern int wakeup_sources_read_lock(void);
+extern void wakeup_sources_read_unlock(int idx);
+extern struct wakeup_source *wakeup_sources_walk_start(void);
+extern struct wakeup_source *wakeup_sources_walk_next(struct wakeup_source *ws);
 extern int device_wakeup_enable(struct device *dev);
 extern int device_wakeup_disable(struct device *dev);
 extern void device_set_wakeup_capable(struct device *dev, bool capable);

include/linux/power/smartreflex.h+3−0

@@ -293,6 +293,9 @@ struct omap_sr_data { · 292 unmodified lines
293	struct voltagedomain *voltdm;	293	struct voltagedomain *voltdm;
294	};	294	};
295		295
		296
		297	extern struct omap_sr_data omap_sr_pdata[OMAP_SR_NR];
		298
296	#ifdef CONFIG_POWER_AVS_OMAP	299	#ifdef CONFIG_POWER_AVS_OMAP
297		300
298	/* Smartreflex module enable/disable interface */	301	/* Smartreflex module enable/disable interface */

include/linux/printk.h+1−2

 	printk(KERN_CRIT pr_fmt(fmt), ##__VA_ARGS__)
 #define pr_err(fmt, ...) \
 	printk(KERN_ERR pr_fmt(fmt), ##__VA_ARGS__)
-#define pr_warning(fmt, ...) \
+#define pr_warn(fmt, ...) \
 	printk(KERN_WARNING pr_fmt(fmt), ##__VA_ARGS__)
-#define pr_warn pr_warning
 #define pr_notice(fmt, ...) \
 	printk(KERN_NOTICE pr_fmt(fmt), ##__VA_ARGS__)
 #define pr_info(fmt, ...) \

include/linux/proc_fs.h+2−2

@@ -58,8 +58,8 @@ extern int remove_proc_subtree(const char , struct proc_dir_entry ); · 57 unmodified lines
58	struct proc_dir_entry proc_create_net_data(const char name, umode_t mode,	58	struct proc_dir_entry proc_create_net_data(const char name, umode_t mode,
59	struct proc_dir_entry parent, const struct seq_operations ops,	59	struct proc_dir_entry parent, const struct seq_operations ops,
60	unsigned int state_size, void *data);	60	unsigned int state_size, void *data);
61	#define proc_create_net(name, mode, parent, state_size, ops) \	61	#define proc_create_net(name, mode, parent, ops, state_size) \
62	proc_create_net_data(name, mode, parent, state_size, ops, NULL)	62	proc_create_net_data(name, mode, parent, ops, state_size, NULL)
63	struct proc_dir_entry proc_create_net_single(const char name, umode_t mode,	63	struct proc_dir_entry proc_create_net_single(const char name, umode_t mode,
64	struct proc_dir_entry *parent,	64	struct proc_dir_entry *parent,
65	int (show)(struct seq_file , void ), void data);	65	int (show)(struct seq_file , void ), void data);

include/linux/property.h+53−53

@@ -22,7 +22,6 @@ enum dev_prop_type { · 21 unmodified lines
22	DEV_PROP_U32,	22	DEV_PROP_U32,
23	DEV_PROP_U64,	23	DEV_PROP_U64,
24	DEV_PROP_STRING,	24	DEV_PROP_STRING,
25	DEV_PROP_MAX,
26	};	25	};
27		26
28	enum dev_dma_attr {	27	enum dev_dma_attr {
@@ -80,9 +79,14 @@ struct fwnode_handle fwnode_find_reference(const struct fwnode_handle fwnode, · 51 unmodified lines
80	const char *name,	79	const char *name,
81	unsigned int index);	80	unsigned int index);
82		81
		82	const char fwnode_get_name(const struct fwnode_handle fwnode);
		83	const char fwnode_get_name_prefix(const struct fwnode_handle fwnode);
83	struct fwnode_handle fwnode_get_parent(const struct fwnode_handle fwnode);	84	struct fwnode_handle fwnode_get_parent(const struct fwnode_handle fwnode);
84	struct fwnode_handle *fwnode_get_next_parent(	85	struct fwnode_handle *fwnode_get_next_parent(
85	struct fwnode_handle *fwnode);	86	struct fwnode_handle *fwnode);
		87	unsigned int fwnode_count_parents(const struct fwnode_handle *fwn);
		88	struct fwnode_handle fwnode_get_nth_parent(struct fwnode_handle fwn,
		89	unsigned int depth);
86	struct fwnode_handle *fwnode_get_next_child_node(	90	struct fwnode_handle *fwnode_get_next_child_node(
87	const struct fwnode_handle fwnode, struct fwnode_handle child);	91	const struct fwnode_handle fwnode, struct fwnode_handle child);
88	struct fwnode_handle *fwnode_get_next_available_child_node(	92	struct fwnode_handle *fwnode_get_next_available_child_node(
@@ -234,13 +238,7 @@ struct property_entry { · 145 unmodified lines
234	bool is_array;	238	bool is_array;
235	enum dev_prop_type type;	239	enum dev_prop_type type;
236	union {	240	union {
237	union {	241	const void *pointer;
238	const u8 *u8_data;
239	const u16 *u16_data;
240	const u32 *u32_data;
241	const u64 *u64_data;
242	const char * const *str;
243	} pointer;
244	union {	242	union {
245	u8 u8_data;	243	u8 u8_data;
246	u16 u16_data;	244	u16 u16_data;
@@ -252,62 +250,63 @@ struct property_entry { · 5 unmodified lines
252	};	250	};
253		251
254	/*	252	/*
255	* Note: the below four initializers for the anonymous union are carefully	253	* Note: the below initializers for the anonymous union are carefully
256	* crafted to avoid gcc-4.4.4's problems with initialization of anon unions	254	* crafted to avoid gcc-4.4.4's problems with initialization of anon unions
257	* and structs.	255	* and structs.
258	*/	256	*/
259		257
260	#define PROPERTY_ENTRY_INTEGER_ARRAY(_name_, _type_, _Type_, _val_) \	258	#define __PROPERTY_ENTRY_ELEMENT_SIZE(_elem_) \
		259	sizeof(((struct property_entry *)NULL)->value._elem_)
		260
		261	#define __PROPERTY_ENTRY_ARRAY_LEN(_name_, _elem_, _Type_, _val_, _len_)\
261	(struct property_entry) { \	262	(struct property_entry) { \
262	.name = _name_, \	263	.name = _name_, \
263	.length = ARRAY_SIZE(_val_) * sizeof(_type_), \	264	.length = (_len_) * __PROPERTY_ENTRY_ELEMENT_SIZE(_elem_), \
264	.is_array = true, \	265	.is_array = true, \
265	.type = DEV_PROP_##_Type_, \	266	.type = DEV_PROP_##_Type_, \
266	{ .pointer = { ._type_##_data = _val_ } }, \	267	{ .pointer = _val_ }, \
267	}	268	}
268		269
269	#define PROPERTY_ENTRY_U8_ARRAY(_name_, _val_) \	270	#define PROPERTY_ENTRY_U8_ARRAY_LEN(_name_, _val_, _len_) \
270	PROPERTY_ENTRY_INTEGER_ARRAY(_name_, u8, U8, _val_)	271	__PROPERTY_ENTRY_ARRAY_LEN(_name_, u8_data, U8, _val_, _len_)
271	#define PROPERTY_ENTRY_U16_ARRAY(_name_, _val_) \	272	#define PROPERTY_ENTRY_U16_ARRAY_LEN(_name_, _val_, _len_) \
272	PROPERTY_ENTRY_INTEGER_ARRAY(_name_, u16, U16, _val_)	273	__PROPERTY_ENTRY_ARRAY_LEN(_name_, u16_data, U16, _val_, _len_)
273	#define PROPERTY_ENTRY_U32_ARRAY(_name_, _val_) \	274	#define PROPERTY_ENTRY_U32_ARRAY_LEN(_name_, _val_, _len_) \
274	PROPERTY_ENTRY_INTEGER_ARRAY(_name_, u32, U32, _val_)	275	__PROPERTY_ENTRY_ARRAY_LEN(_name_, u32_data, U32, _val_, _len_)
275	#define PROPERTY_ENTRY_U64_ARRAY(_name_, _val_) \	276	#define PROPERTY_ENTRY_U64_ARRAY_LEN(_name_, _val_, _len_) \
276	PROPERTY_ENTRY_INTEGER_ARRAY(_name_, u64, U64, _val_)	277	__PROPERTY_ENTRY_ARRAY_LEN(_name_, u64_data, U64, _val_, _len_)
277		278	#define PROPERTY_ENTRY_STRING_ARRAY_LEN(_name_, _val_, _len_) \
278	#define PROPERTY_ENTRY_STRING_ARRAY(_name_, _val_) \	279	__PROPERTY_ENTRY_ARRAY_LEN(_name_, str, STRING, _val_, _len_)
279	(struct property_entry) { \	280
280	.name = _name_, \	281	#define PROPERTY_ENTRY_U8_ARRAY(_name_, _val_) \
281	.length = ARRAY_SIZE(_val_) * sizeof(const char *), \	282	PROPERTY_ENTRY_U8_ARRAY_LEN(_name_, _val_, ARRAY_SIZE(_val_))
282	.is_array = true, \	283	#define PROPERTY_ENTRY_U16_ARRAY(_name_, _val_) \
283	.type = DEV_PROP_STRING, \	284	PROPERTY_ENTRY_U16_ARRAY_LEN(_name_, _val_, ARRAY_SIZE(_val_))
284	{ .pointer = { .str = _val_ } }, \	285	#define PROPERTY_ENTRY_U32_ARRAY(_name_, _val_) \
285	}	286	PROPERTY_ENTRY_U32_ARRAY_LEN(_name_, _val_, ARRAY_SIZE(_val_))
286		287	#define PROPERTY_ENTRY_U64_ARRAY(_name_, _val_) \
287	#define PROPERTY_ENTRY_INTEGER(_name_, _type_, _Type_, _val_) \	288	PROPERTY_ENTRY_U64_ARRAY_LEN(_name_, _val_, ARRAY_SIZE(_val_))
288	(struct property_entry) { \	289	#define PROPERTY_ENTRY_STRING_ARRAY(_name_, _val_) \
289	.name = _name_, \	290	PROPERTY_ENTRY_STRING_ARRAY_LEN(_name_, _val_, ARRAY_SIZE(_val_))
290	.length = sizeof(_type_), \	291
291	.type = DEV_PROP_##_Type_, \	292	#define __PROPERTY_ENTRY_ELEMENT(_name_, _elem_, _Type_, _val_) \
292	{ .value = { ._type_##_data = _val_ } }, \	293	(struct property_entry) { \
		294	.name = _name_, \
		295	.length = __PROPERTY_ENTRY_ELEMENT_SIZE(_elem_), \
		296	.type = DEV_PROP_##_Type_, \
		297	{ .value = { ._elem_ = _val_ } }, \
293	}	298	}
294		299
295	#define PROPERTY_ENTRY_U8(_name_, _val_) \	300	#define PROPERTY_ENTRY_U8(_name_, _val_) \
296	PROPERTY_ENTRY_INTEGER(_name_, u8, U8, _val_)	301	__PROPERTY_ENTRY_ELEMENT(_name_, u8_data, U8, _val_)
297	#define PROPERTY_ENTRY_U16(_name_, _val_) \	302	#define PROPERTY_ENTRY_U16(_name_, _val_) \
298	PROPERTY_ENTRY_INTEGER(_name_, u16, U16, _val_)	303	__PROPERTY_ENTRY_ELEMENT(_name_, u16_data, U16, _val_)
299	#define PROPERTY_ENTRY_U32(_name_, _val_) \	304	#define PROPERTY_ENTRY_U32(_name_, _val_) \
300	PROPERTY_ENTRY_INTEGER(_name_, u32, U32, _val_)	305	__PROPERTY_ENTRY_ELEMENT(_name_, u32_data, U32, _val_)
301	#define PROPERTY_ENTRY_U64(_name_, _val_) \	306	#define PROPERTY_ENTRY_U64(_name_, _val_) \
302	PROPERTY_ENTRY_INTEGER(_name_, u64, U64, _val_)	307	__PROPERTY_ENTRY_ELEMENT(_name_, u64_data, U64, _val_)
303		308	#define PROPERTY_ENTRY_STRING(_name_, _val_) \
304	#define PROPERTY_ENTRY_STRING(_name_, _val_) \	309	__PROPERTY_ENTRY_ELEMENT(_name_, str, STRING, _val_)
305	(struct property_entry) { \
306	.name = _name_, \
307	.length = sizeof(const char *), \
308	.type = DEV_PROP_STRING, \
309	{ .value = { .str = _val_ } }, \
310	}
311		310
312	#define PROPERTY_ENTRY_BOOL(_name_) \	311	#define PROPERTY_ENTRY_BOOL(_name_) \
313	(struct property_entry) { \	312	(struct property_entry) { \
@@ -418,7 +417,8 @@ struct software_node { · 104 unmodified lines
418	};	417	};
419		418
420	bool is_software_node(const struct fwnode_handle *fwnode);	419	bool is_software_node(const struct fwnode_handle *fwnode);
421	const struct software_node to_software_node(struct fwnode_handle fwnode);	420	const struct software_node *
		421	to_software_node(const struct fwnode_handle *fwnode);
422	struct fwnode_handle software_node_fwnode(const struct software_node node);	422	struct fwnode_handle software_node_fwnode(const struct software_node node);
423		423
424	const struct software_node *	424	const struct software_node *

include/linux/psci.h+2−7

 #ifndef __LINUX_PSCI_H
 #define __LINUX_PSCI_H
+#include <linux/arm-smccc.h>
 #include <linux/init.h>
 #include <linux/types.h>
 int psci_cpu_suspend_enter(u32 state);
 bool psci_power_state_is_valid(u32 state);
-enum psci_conduit {
-	PSCI_CONDUIT_NONE,
-	PSCI_CONDUIT_SMC,
-	PSCI_CONDUIT_HVC,
-};
 enum smccc_version {
 	SMCCC_VERSION_1_0,
 	SMCCC_VERSION_1_1,
 	int (*affinity_info)(unsigned long target_affinity,
 			unsigned long lowest_affinity_level);
 	int (*migrate_info_type)(void);
-	enum psci_conduit conduit;
+	enum arm_smccc_conduit conduit;
 	enum smccc_version smccc_version;
 };

include/linux/pwm.h+1−4

  * @request: optional hook for requesting a PWM
  * @free: optional hook for freeing a PWM
  * @capture: capture and report PWM signal
- * @apply: atomically apply a new PWM config. The state argument
+ * @apply: atomically apply a new PWM config
- *	   should be adjusted with the real hardware config (if the
- *	   approximate the period or duty_cycle value, state should
- *	   reflect it)
  * @get_state: get the current PWM state. This function is only
  *	       called once per PWM device when the PWM chip is
  *	       registered.

include/linux/pxa2xx_ssp.h+1−1

@@ -206,7 +206,7 @@ enum pxa_ssp_type { · 205 unmodified lines
206	};	206	};
207		207
208	struct ssp_device {	208	struct ssp_device {
209	struct platform_device *pdev;	209	struct device *dev;
210	struct list_head node;	210	struct list_head node;
211		211
212	struct clk *clk;	212	struct clk *clk;

include/linux/qcom_scm.h+28−0

@@ -24,6 +24,26 @@ struct qcom_scm_vmperm { · 23 unmodified lines
24	int perm;	24	int perm;
25	};	25	};
26		26
		27	enum qcom_scm_ocmem_client {
		28	QCOM_SCM_OCMEM_UNUSED_ID = 0x0,
		29	QCOM_SCM_OCMEM_GRAPHICS_ID,
		30	QCOM_SCM_OCMEM_VIDEO_ID,
		31	QCOM_SCM_OCMEM_LP_AUDIO_ID,
		32	QCOM_SCM_OCMEM_SENSORS_ID,
		33	QCOM_SCM_OCMEM_OTHER_OS_ID,
		34	QCOM_SCM_OCMEM_DEBUG_ID,
		35	};
		36
		37	enum qcom_scm_sec_dev_id {
		38	QCOM_SCM_MDSS_DEV_ID = 1,
		39	QCOM_SCM_OCMEM_DEV_ID = 5,
		40	QCOM_SCM_PCIE0_DEV_ID = 11,
		41	QCOM_SCM_PCIE1_DEV_ID = 12,
		42	QCOM_SCM_GFX_DEV_ID = 18,
		43	QCOM_SCM_UFS_DEV_ID = 19,
		44	QCOM_SCM_ICE_DEV_ID = 20,
		45	};
		46
27	#define QCOM_SCM_VMID_HLOS 0x3	47	#define QCOM_SCM_VMID_HLOS 0x3
28	#define QCOM_SCM_VMID_MSS_MSA 0xF	48	#define QCOM_SCM_VMID_MSS_MSA 0xF
29	#define QCOM_SCM_VMID_WLAN 0x18	49	#define QCOM_SCM_VMID_WLAN 0x18
@@ -41,6 +61,11 @@ extern bool qcom_scm_is_available(void); · 11 unmodified lines
41	extern bool qcom_scm_hdcp_available(void);	61	extern bool qcom_scm_hdcp_available(void);
42	extern int qcom_scm_hdcp_req(struct qcom_scm_hdcp_req *req, u32 req_cnt,	62	extern int qcom_scm_hdcp_req(struct qcom_scm_hdcp_req *req, u32 req_cnt,
43	u32 *resp);	63	u32 *resp);
		64	extern bool qcom_scm_ocmem_lock_available(void);
		65	extern int qcom_scm_ocmem_lock(enum qcom_scm_ocmem_client id, u32 offset,
		66	u32 size, u32 mode);
		67	extern int qcom_scm_ocmem_unlock(enum qcom_scm_ocmem_client id, u32 offset,
		68	u32 size);
44	extern bool qcom_scm_pas_supported(u32 peripheral);	69	extern bool qcom_scm_pas_supported(u32 peripheral);
45	extern int qcom_scm_pas_init_image(u32 peripheral, const void *metadata,	70	extern int qcom_scm_pas_init_image(u32 peripheral, const void *metadata,
46	size_t size);	71	size_t size);
@@ -55,9 +80,11 @@ extern int qcom_scm_assign_mem(phys_addr_t mem_addr, size_t mem_sz, · 8 unmodified lines
55	extern void qcom_scm_cpu_power_down(u32 flags);	80	extern void qcom_scm_cpu_power_down(u32 flags);
56	extern u32 qcom_scm_get_version(void);	81	extern u32 qcom_scm_get_version(void);
57	extern int qcom_scm_set_remote_state(u32 state, u32 id);	82	extern int qcom_scm_set_remote_state(u32 state, u32 id);
		83	extern bool qcom_scm_restore_sec_cfg_available(void);
58	extern int qcom_scm_restore_sec_cfg(u32 device_id, u32 spare);	84	extern int qcom_scm_restore_sec_cfg(u32 device_id, u32 spare);
59	extern int qcom_scm_iommu_secure_ptbl_size(u32 spare, size_t *size);	85	extern int qcom_scm_iommu_secure_ptbl_size(u32 spare, size_t *size);
60	extern int qcom_scm_iommu_secure_ptbl_init(u64 addr, u32 size, u32 spare);	86	extern int qcom_scm_iommu_secure_ptbl_init(u64 addr, u32 size, u32 spare);
		87	extern int qcom_scm_qsmmu500_wait_safe_toggle(bool en);
61	extern int qcom_scm_io_readl(phys_addr_t addr, unsigned int *val);	88	extern int qcom_scm_io_readl(phys_addr_t addr, unsigned int *val);
62	extern int qcom_scm_io_writel(phys_addr_t addr, unsigned int val);	89	extern int qcom_scm_io_writel(phys_addr_t addr, unsigned int val);
63	#else	90	#else
@@ -97,6 +124,7 @@ qcom_scm_set_remote_state(u32 state,u32 id) { return -ENODEV; } · 33 unmodified lines
97	static inline int qcom_scm_restore_sec_cfg(u32 device_id, u32 spare) { return -ENODEV; }	124	static inline int qcom_scm_restore_sec_cfg(u32 device_id, u32 spare) { return -ENODEV; }
98	static inline int qcom_scm_iommu_secure_ptbl_size(u32 spare, size_t *size) { return -ENODEV; }	125	static inline int qcom_scm_iommu_secure_ptbl_size(u32 spare, size_t *size) { return -ENODEV; }
99	static inline int qcom_scm_iommu_secure_ptbl_init(u64 addr, u32 size, u32 spare) { return -ENODEV; }	126	static inline int qcom_scm_iommu_secure_ptbl_init(u64 addr, u32 size, u32 spare) { return -ENODEV; }
		127	static inline int qcom_scm_qsmmu500_wait_safe_toggle(bool en) { return -ENODEV; }
100	static inline int qcom_scm_io_readl(phys_addr_t addr, unsigned int *val) { return -ENODEV; }	128	static inline int qcom_scm_io_readl(phys_addr_t addr, unsigned int *val) { return -ENODEV; }
101	static inline int qcom_scm_io_writel(phys_addr_t addr, unsigned int val) { return -ENODEV; }	129	static inline int qcom_scm_io_writel(phys_addr_t addr, unsigned int val) { return -ENODEV; }
102	#endif	130	#endif

include/linux/quota.h+1−1

@@ -263,7 +263,7 @@ enum { · 262 unmodified lines
263	};	263	};
264		264
265	struct dqstats {	265	struct dqstats {
266	int stat[_DQST_DQSTAT_LAST];	266	unsigned long stat[_DQST_DQSTAT_LAST];
267	struct percpu_counter counter[_DQST_DQSTAT_LAST];	267	struct percpu_counter counter[_DQST_DQSTAT_LAST];
268	};	268	};
269		269

include/linux/quotaops.h+13−1

 	atomic_inc(&dquot->dq_count);
 	return dquot;
 }
+static inline bool dquot_is_busy(struct dquot *dquot)
+{
+	if (test_bit(DQ_MOD_B, &dquot->dq_flags))
+		return true;
+	if (atomic_read(&dquot->dq_count) > 1)
+		return true;
+	return false;
+}
 void dqput(struct dquot *dquot);
 int dquot_scan_active(struct super_block *sb,
 		      int (*fn)(struct dquot *dquot, unsigned long priv),
 int dquot_file_open(struct inode *inode, struct file *file);
-int dquot_enable(struct inode *inode, int type, int format_id,
+int dquot_load_quota_sb(struct super_block *sb, int type, int format_id,
+	unsigned int flags);
+int dquot_load_quota_inode(struct inode *inode, int type, int format_id,
 	unsigned int flags);
 int dquot_quota_on(struct super_block *sb, int type, int format_id,
 	const struct path *path);

include/linux/rbtree_augmented.h+2−4

 		__rb_change_child(node, successor, tmp, root);
 		if (child2) {
-			successor->__rb_parent_color = pc;
 			rb_set_parent_color(child2, parent, RB_BLACK);
 			rebalance = NULL;
 		} else {
-			unsigned long pc2 = successor->__rb_parent_color;
+			rebalance = rb_is_black(successor) ? parent : NULL;
-			successor->__rb_parent_color = pc;
-			rebalance = __rb_is_black(pc2) ? parent : NULL;
 		}
+		successor->__rb_parent_color = pc;
 		tmp = successor;
 	}

include/linux/rculist_bl.h+0−28

@@ -24,34 +24,6 @@ static inline struct hlist_bl_node hlist_bl_first_rcu(struct hlist_bl_head h) · 23 unmodified lines
24	((unsigned long)rcu_dereference_check(h->first, hlist_bl_is_locked(h)) & ~LIST_BL_LOCKMASK);	24	((unsigned long)rcu_dereference_check(h->first, hlist_bl_is_locked(h)) & ~LIST_BL_LOCKMASK);
25	}	25	}
26		26
27	/**
28	* hlist_bl_del_init_rcu - deletes entry from hash list with re-initialization
29	* @n: the element to delete from the hash list.
30	*
31	* Note: hlist_bl_unhashed() on the node returns true after this. It is
32	* useful for RCU based read lockfree traversal if the writer side
33	* must know if the list entry is still hashed or already unhashed.
34	*
35	* In particular, it means that we can not poison the forward pointers
36	* that may still be used for walking the hash list and we can only
37	* zero the pprev pointer so list_unhashed() will return true after
38	* this.
39	*
40	* The caller must take whatever precautions are necessary (such as
41	* holding appropriate locks) to avoid racing with another
42	* list-mutation primitive, such as hlist_bl_add_head_rcu() or
43	* hlist_bl_del_rcu(), running on this same list. However, it is
44	* perfectly legal to run concurrently with the _rcu list-traversal
45	* primitives, such as hlist_bl_for_each_entry_rcu().
46	*/
47	static inline void hlist_bl_del_init_rcu(struct hlist_bl_node *n)
48	{
49	if (!hlist_bl_unhashed(n)) {
50	__hlist_bl_del(n);
51	n->pprev = NULL;
52	}
53	}
54
55	/**	27	/**
56	* hlist_bl_del_rcu - deletes entry from hash list without re-initialization	28	* hlist_bl_del_rcu - deletes entry from hash list without re-initialization
57	* @n: the element to delete from the hash list.	29	* @n: the element to delete from the hash list.

include/linux/rculist_nulls.h+37−0

@@ -100,6 +100,43 @@ static inline void hlist_nulls_add_head_rcu(struct hlist_nulls_node *n, · 99 unmodified lines
100	first->pprev = &n->next;	100	first->pprev = &n->next;
101	}	101	}
102		102
		103	/**
		104	* hlist_nulls_add_tail_rcu
		105	* @n: the element to add to the hash list.
		106	* @h: the list to add to.
		107	*
		108	* Description:
		109	* Adds the specified element to the specified hlist_nulls,
		110	* while permitting racing traversals.
		111	*
		112	* The caller must take whatever precautions are necessary
		113	* (such as holding appropriate locks) to avoid racing
		114	* with another list-mutation primitive, such as hlist_nulls_add_head_rcu()
		115	* or hlist_nulls_del_rcu(), running on this same list.
		116	* However, it is perfectly legal to run concurrently with
		117	* the _rcu list-traversal primitives, such as
		118	* hlist_nulls_for_each_entry_rcu(), used to prevent memory-consistency
		119	* problems on Alpha CPUs. Regardless of the type of CPU, the
		120	* list-traversal primitive must be guarded by rcu_read_lock().
		121	*/
		122	static inline void hlist_nulls_add_tail_rcu(struct hlist_nulls_node *n,
		123	struct hlist_nulls_head *h)
		124	{
		125	struct hlist_nulls_node i, last = NULL;
		126
		127	/* Note: write side code, so rcu accessors are not needed. */
		128	for (i = h->first; !is_a_nulls(i); i = i->next)
		129	last = i;
		130
		131	if (last) {
		132	n->next = last->next;
		133	n->pprev = &last->next;
		134	rcu_assign_pointer(hlist_next_rcu(last), n);
		135	} else {
		136	hlist_nulls_add_head_rcu(n, h);
		137	}
		138	}
		139
103	/**	140	/**
104	* hlist_nulls_for_each_entry_rcu - iterate over rcu list of given type	141	* hlist_nulls_for_each_entry_rcu - iterate over rcu list of given type
105	* @tpos: the type * to use as a loop cursor.	142	* @tpos: the type * to use as a loop cursor.

include/linux/rcupdate.h+19−1

@@ -210,7 +210,7 @@ static inline void rcu_lock_acquire(struct lockdep_map *map) · 209 unmodified lines
210		210
211	static inline void rcu_lock_release(struct lockdep_map *map)	211	static inline void rcu_lock_release(struct lockdep_map *map)
212	{	212	{
213	lock_release(map, 1, _THIS_IP_);	213	lock_release(map, _THIS_IP_);
214	}	214	}
215		215
216	extern struct lockdep_map rcu_lock_map;	216	extern struct lockdep_map rcu_lock_map;
@@ -382,6 +382,24 @@ do { \ · 165 unmodified lines
382	smp_store_release(&p, RCU_INITIALIZER((typeof(p))_r_a_p__v)); \	382	smp_store_release(&p, RCU_INITIALIZER((typeof(p))_r_a_p__v)); \
383	} while (0)	383	} while (0)
384		384
		385	/**
		386	* rcu_replace_pointer() - replace an RCU pointer, returning its old value
		387	* @rcu_ptr: RCU pointer, whose old value is returned
		388	* @ptr: regular pointer
		389	* @c: the lockdep conditions under which the dereference will take place
		390	*
		391	* Perform a replacement, where @rcu_ptr is an RCU-annotated
		392	* pointer and @c is the lockdep argument that is passed to the
		393	* rcu_dereference_protected() call used to read that pointer. The old
		394	* value of @rcu_ptr is returned, and @rcu_ptr is set to @ptr.
		395	*/
		396	#define rcu_replace_pointer(rcu_ptr, ptr, c) \
		397	({ \
		398	typeof(ptr) __tmp = rcu_dereference_protected((rcu_ptr), (c)); \
		399	rcu_assign_pointer((rcu_ptr), (ptr)); \
		400	__tmp; \
		401	})
		402
385	/**	403	/**
386	* rcu_swap_protected() - swap an RCU and a regular pointer	404	* rcu_swap_protected() - swap an RCU and a regular pointer
387	* @rcu_ptr: RCU pointer	405	* @rcu_ptr: RCU pointer

include/linux/rcutiny.h+1−0

@@ -84,6 +84,7 @@ static inline void rcu_scheduler_starting(void) { } · 83 unmodified lines
84	#endif /* #else #ifndef CONFIG_SRCU */	84	#endif /* #else #ifndef CONFIG_SRCU */
85	static inline void rcu_end_inkernel_boot(void) { }	85	static inline void rcu_end_inkernel_boot(void) { }
86	static inline bool rcu_is_watching(void) { return true; }	86	static inline bool rcu_is_watching(void) { return true; }
		87	static inline void rcu_momentary_dyntick_idle(void) { }
87		88
88	/* Avoid RCU read-side critical sections leaking across. */	89	/* Avoid RCU read-side critical sections leaking across. */
89	static inline void rcu_all_qs(void) { barrier(); }	90	static inline void rcu_all_qs(void) { barrier(); }

include/linux/rcutree.h+1−0

@@ -37,6 +37,7 @@ void kfree_call_rcu(struct rcu_head *head, rcu_callback_t func); · 36 unmodified lines
37		37
38	void rcu_barrier(void);	38	void rcu_barrier(void);
39	bool rcu_eqs_special_set(int cpu);	39	bool rcu_eqs_special_set(int cpu);
		40	void rcu_momentary_dyntick_idle(void);
40	unsigned long get_state_synchronize_rcu(void);	41	unsigned long get_state_synchronize_rcu(void);
41	void cond_synchronize_rcu(unsigned long oldstate);	42	void cond_synchronize_rcu(unsigned long oldstate);
42		43

include/linux/refcount.h+229−40

@@ -1,9 +1,88 @@
1	/* SPDX-License-Identifier: GPL-2.0 */	1	/* SPDX-License-Identifier: GPL-2.0 */
		2	/*
		3	* Variant of atomic_t specialized for reference counts.
		4	*
		5	* The interface matches the atomic_t interface (to aid in porting) but only
		6	* provides the few functions one should use for reference counting.
		7	*
		8	* Saturation semantics
		9	* ====================
		10	*
		11	* refcount_t differs from atomic_t in that the counter saturates at
		12	* REFCOUNT_SATURATED and will not move once there. This avoids wrapping the
		13	* counter and causing 'spurious' use-after-free issues. In order to avoid the
		14	* cost associated with introducing cmpxchg() loops into all of the saturating
		15	* operations, we temporarily allow the counter to take on an unchecked value
		16	* and then explicitly set it to REFCOUNT_SATURATED on detecting that underflow
		17	* or overflow has occurred. Although this is racy when multiple threads
		18	* access the refcount concurrently, by placing REFCOUNT_SATURATED roughly
		19	* equidistant from 0 and INT_MAX we minimise the scope for error:
		20	*
		21	* INT_MAX REFCOUNT_SATURATED UINT_MAX
		22	* 0 (0x7fff_ffff) (0xc000_0000) (0xffff_ffff)
		23	* +--------------------------------+----------------+----------------+
		24	* <---------- bad value! ---------->
		25	*
		26	* (in a signed view of the world, the "bad value" range corresponds to
		27	* a negative counter value).
		28	*
		29	* As an example, consider a refcount_inc() operation that causes the counter
		30	* to overflow:
		31	*
		32	* int old = atomic_fetch_add_relaxed(r);
		33	* // old is INT_MAX, refcount now INT_MIN (0x8000_0000)
		34	* if (old < 0)
		35	* atomic_set(r, REFCOUNT_SATURATED);
		36	*
		37	* If another thread also performs a refcount_inc() operation between the two
		38	* atomic operations, then the count will continue to edge closer to 0. If it
		39	* reaches a value of 1 before /any/ of the threads reset it to the saturated
		40	* value, then a concurrent refcount_dec_and_test() may erroneously free the
		41	* underlying object. Given the precise timing details involved with the
		42	* round-robin scheduling of each thread manipulating the refcount and the need
		43	* to hit the race multiple times in succession, there doesn't appear to be a
		44	* practical avenue of attack even if using refcount_add() operations with
		45	* larger increments.
		46	*
		47	* Memory ordering
		48	* ===============
		49	*
		50	* Memory ordering rules are slightly relaxed wrt regular atomic_t functions
		51	* and provide only what is strictly required for refcounts.
		52	*
		53	* The increments are fully relaxed; these will not provide ordering. The
		54	* rationale is that whatever is used to obtain the object we're increasing the
		55	* reference count on will provide the ordering. For locked data structures,
		56	* its the lock acquire, for RCU/lockless data structures its the dependent
		57	* load.
		58	*
		59	* Do note that inc_not_zero() provides a control dependency which will order
		60	* future stores against the inc, this ensures we'll never modify the object
		61	* if we did not in fact acquire a reference.
		62	*
		63	* The decrements will provide release order, such that all the prior loads and
		64	* stores will be issued before, it also provides a control dependency, which
		65	* will order us against the subsequent free().
		66	*
		67	* The control dependency is against the load of the cmpxchg (ll/sc) that
		68	* succeeded. This means the stores aren't fully ordered, but this is fine
		69	* because the 1->0 transition indicates no concurrency.
		70	*
		71	* Note that the allocator is responsible for ordering things between free()
		72	* and alloc().
		73	*
		74	* The decrements dec_and_test() and sub_and_test() also provide acquire
		75	* ordering on success.
		76	*
		77	*/
		78
2	#ifndef _LINUX_REFCOUNT_H	79	#ifndef _LINUX_REFCOUNT_H
3	#define _LINUX_REFCOUNT_H	80	#define _LINUX_REFCOUNT_H
4		81
5	#include <linux/atomic.h>	82	#include <linux/atomic.h>
		83	#include <linux/bug.h>
6	#include <linux/compiler.h>	84	#include <linux/compiler.h>
		85	#include <linux/limits.h>
7	#include <linux/spinlock_types.h>	86	#include <linux/spinlock_types.h>
8		87
9	struct mutex;	88	struct mutex;
@@ -12,7 +91,7 @@ struct mutex; · 2 unmodified lines
12	* struct refcount_t - variant of atomic_t specialized for reference counts	91	* struct refcount_t - variant of atomic_t specialized for reference counts
13	* @refs: atomic_t counter field	92	* @refs: atomic_t counter field
14	*	93	*
15	* The counter saturates at UINT_MAX and will not move once	94	* The counter saturates at REFCOUNT_SATURATED and will not move once
16	* there. This avoids wrapping the counter and causing 'spurious'	95	* there. This avoids wrapping the counter and causing 'spurious'
17	* use-after-free bugs.	96	* use-after-free bugs.
18	*/	97	*/
@@ -21,13 +100,25 @@ typedef struct refcount_struct { · 2 unmodified lines
21	} refcount_t;	100	} refcount_t;
22		101
23	#define REFCOUNT_INIT(n) { .refs = ATOMIC_INIT(n), }	102	#define REFCOUNT_INIT(n) { .refs = ATOMIC_INIT(n), }
		103	#define REFCOUNT_MAX INT_MAX
		104	#define REFCOUNT_SATURATED (INT_MIN / 2)
		105
		106	enum refcount_saturation_type {
		107	REFCOUNT_ADD_NOT_ZERO_OVF,
		108	REFCOUNT_ADD_OVF,
		109	REFCOUNT_ADD_UAF,
		110	REFCOUNT_SUB_UAF,
		111	REFCOUNT_DEC_LEAK,
		112	};
		113
		114	void refcount_warn_saturate(refcount_t *r, enum refcount_saturation_type t);
24		115
25	/**	116	/**
26	* refcount_set - set a refcount's value	117	* refcount_set - set a refcount's value
27	* @r: the refcount	118	* @r: the refcount
28	* @n: value to which the refcount will be set	119	* @n: value to which the refcount will be set
29	*/	120	*/
30	static inline void refcount_set(refcount_t *r, unsigned int n)	121	static inline void refcount_set(refcount_t *r, int n)
31	{	122	{
32	atomic_set(&r->refs, n);	123	atomic_set(&r->refs, n);
33	}	124	}
@@ -43,70 +134,168 @@ static inline unsigned int refcount_read(const refcount_t *r) · 9 unmodified lines
43	return atomic_read(&r->refs);	134	return atomic_read(&r->refs);
44	}	135	}
45		136
46	extern __must_check bool refcount_add_not_zero_checked(unsigned int i, refcount_t *r);	137	/**
47	extern void refcount_add_checked(unsigned int i, refcount_t *r);	138	* refcount_add_not_zero - add a value to a refcount unless it is 0
48		139	* @i: the value to add to the refcount
49	extern __must_check bool refcount_inc_not_zero_checked(refcount_t *r);	140	* @r: the refcount
50	extern void refcount_inc_checked(refcount_t *r);	141	*
51		142	* Will saturate at REFCOUNT_SATURATED and WARN.
52	extern __must_check bool refcount_sub_and_test_checked(unsigned int i, refcount_t *r);	143	*
53		144	* Provides no memory ordering, it is assumed the caller has guaranteed the
54	extern __must_check bool refcount_dec_and_test_checked(refcount_t *r);	145	* object memory to be stable (RCU, etc.). It does provide a control dependency
55	extern void refcount_dec_checked(refcount_t *r);	146	* and thereby orders future stores. See the comment on top.
56		147	*
57	#ifdef CONFIG_REFCOUNT_FULL	148	* Use of this function is not recommended for the normal reference counting
58		149	* use case in which references are taken and released one at a time. In these
59	#define refcount_add_not_zero refcount_add_not_zero_checked	150	* cases, refcount_inc(), or one of its variants, should instead be used to
60	#define refcount_add refcount_add_checked	151	* increment a reference count.
61		152	*
62	#define refcount_inc_not_zero refcount_inc_not_zero_checked	153	* Return: false if the passed refcount is 0, true otherwise
63	#define refcount_inc refcount_inc_checked	154	*/
		155	static inline __must_check bool refcount_add_not_zero(int i, refcount_t *r)
		156	{
		157	int old = refcount_read(r);
64		158
65	#define refcount_sub_and_test refcount_sub_and_test_checked	159	do {
		160	if (!old)
		161	break;
		162	} while (!atomic_try_cmpxchg_relaxed(&r->refs, &old, old + i));
66		163
67	#define refcount_dec_and_test refcount_dec_and_test_checked	164	if (unlikely(old < 0 \|\| old + i < 0))
68	#define refcount_dec refcount_dec_checked	165	refcount_warn_saturate(r, REFCOUNT_ADD_NOT_ZERO_OVF);
69		166
70	#else	167	return old;
71	# ifdef CONFIG_ARCH_HAS_REFCOUNT
72	# include <asm/refcount.h>
73	# else
74	static inline __must_check bool refcount_add_not_zero(unsigned int i, refcount_t *r)
75	{
76	return atomic_add_unless(&r->refs, i, 0);
77	}	168	}
78		169
79	static inline void refcount_add(unsigned int i, refcount_t *r)	170	/**
		171	* refcount_add - add a value to a refcount
		172	* @i: the value to add to the refcount
		173	* @r: the refcount
		174	*
		175	* Similar to atomic_add(), but will saturate at REFCOUNT_SATURATED and WARN.
		176	*
		177	* Provides no memory ordering, it is assumed the caller has guaranteed the
		178	* object memory to be stable (RCU, etc.). It does provide a control dependency
		179	* and thereby orders future stores. See the comment on top.
		180	*
		181	* Use of this function is not recommended for the normal reference counting
		182	* use case in which references are taken and released one at a time. In these
		183	* cases, refcount_inc(), or one of its variants, should instead be used to
		184	* increment a reference count.
		185	*/
		186	static inline void refcount_add(int i, refcount_t *r)
80	{	187	{
81	atomic_add(i, &r->refs);	188	int old = atomic_fetch_add_relaxed(i, &r->refs);
		189
		190	if (unlikely(!old))
		191	refcount_warn_saturate(r, REFCOUNT_ADD_UAF);
		192	else if (unlikely(old < 0 \|\| old + i < 0))
		193	refcount_warn_saturate(r, REFCOUNT_ADD_OVF);
82	}	194	}
83		195
		196	/**
		197	* refcount_inc_not_zero - increment a refcount unless it is 0
		198	* @r: the refcount to increment
		199	*
		200	* Similar to atomic_inc_not_zero(), but will saturate at REFCOUNT_SATURATED
		201	* and WARN.
		202	*
		203	* Provides no memory ordering, it is assumed the caller has guaranteed the
		204	* object memory to be stable (RCU, etc.). It does provide a control dependency
		205	* and thereby orders future stores. See the comment on top.
		206	*
		207	* Return: true if the increment was successful, false otherwise
		208	*/
84	static inline __must_check bool refcount_inc_not_zero(refcount_t *r)	209	static inline __must_check bool refcount_inc_not_zero(refcount_t *r)
85	{	210	{
86	return atomic_add_unless(&r->refs, 1, 0);	211	return refcount_add_not_zero(1, r);
87	}	212	}
88		213
		214	/**
		215	* refcount_inc - increment a refcount
		216	* @r: the refcount to increment
		217	*
		218	* Similar to atomic_inc(), but will saturate at REFCOUNT_SATURATED and WARN.
		219	*
		220	* Provides no memory ordering, it is assumed the caller already has a
		221	* reference on the object.
		222	*
		223	* Will WARN if the refcount is 0, as this represents a possible use-after-free
		224	* condition.
		225	*/
89	static inline void refcount_inc(refcount_t *r)	226	static inline void refcount_inc(refcount_t *r)
90	{	227	{
91	atomic_inc(&r->refs);	228	refcount_add(1, r);
92	}	229	}
93		230
94	static inline __must_check bool refcount_sub_and_test(unsigned int i, refcount_t *r)	231	/**
		232	* refcount_sub_and_test - subtract from a refcount and test if it is 0
		233	* @i: amount to subtract from the refcount
		234	* @r: the refcount
		235	*
		236	* Similar to atomic_dec_and_test(), but it will WARN, return false and
		237	* ultimately leak on underflow and will fail to decrement when saturated
		238	* at REFCOUNT_SATURATED.
		239	*
		240	* Provides release memory ordering, such that prior loads and stores are done
		241	* before, and provides an acquire ordering on success such that free()
		242	* must come after.
		243	*
		244	* Use of this function is not recommended for the normal reference counting
		245	* use case in which references are taken and released one at a time. In these
		246	* cases, refcount_dec(), or one of its variants, should instead be used to
		247	* decrement a reference count.
		248	*
		249	* Return: true if the resulting refcount is 0, false otherwise
		250	*/
		251	static inline __must_check bool refcount_sub_and_test(int i, refcount_t *r)
95	{	252	{
96	return atomic_sub_and_test(i, &r->refs);	253	int old = atomic_fetch_sub_release(i, &r->refs);
		254
		255	if (old == i) {
		256	smp_acquire__after_ctrl_dep();
		257	return true;
		258	}
		259
		260	if (unlikely(old < 0 \|\| old - i < 0))
		261	refcount_warn_saturate(r, REFCOUNT_SUB_UAF);
		262
		263	return false;
97	}	264	}
98		265
		266	/**
		267	* refcount_dec_and_test - decrement a refcount and test if it is 0
		268	* @r: the refcount
		269	*
		270	* Similar to atomic_dec_and_test(), it will WARN on underflow and fail to
		271	* decrement when saturated at REFCOUNT_SATURATED.
		272	*
		273	* Provides release memory ordering, such that prior loads and stores are done
		274	* before, and provides an acquire ordering on success such that free()
		275	* must come after.
		276	*
		277	* Return: true if the resulting refcount is 0, false otherwise
		278	*/
99	static inline __must_check bool refcount_dec_and_test(refcount_t *r)	279	static inline __must_check bool refcount_dec_and_test(refcount_t *r)
100	{	280	{
101	return atomic_dec_and_test(&r->refs);	281	return refcount_sub_and_test(1, r);
102	}	282	}
103		283
		284	/**
		285	* refcount_dec - decrement a refcount
		286	* @r: the refcount
		287	*
		288	* Similar to atomic_dec(), it will WARN on underflow and fail to decrement
		289	* when saturated at REFCOUNT_SATURATED.
		290	*
		291	* Provides release memory ordering, such that prior loads and stores are done
		292	* before.
		293	*/
104	static inline void refcount_dec(refcount_t *r)	294	static inline void refcount_dec(refcount_t *r)
105	{	295	{
106	atomic_dec(&r->refs);	296	if (unlikely(atomic_fetch_sub_release(1, &r->refs) <= 1))
		297	refcount_warn_saturate(r, REFCOUNT_DEC_LEAK);
107	}	298	}
108	# endif /* !CONFIG_ARCH_HAS_REFCOUNT */
109	#endif /* CONFIG_REFCOUNT_FULL */
110		299
111	extern __must_check bool refcount_dec_if_one(refcount_t *r);	300	extern __must_check bool refcount_dec_if_one(refcount_t *r);
112	extern __must_check bool refcount_dec_not_one(refcount_t *r);	301	extern __must_check bool refcount_dec_not_one(refcount_t *r);

include/linux/regulator/ab8500.h+0−3

 	AB8505_LDO_AUX6,
 	AB8505_LDO_INTCORE,
 	AB8505_LDO_ADC,
-	AB8505_LDO_USB,
 	AB8505_LDO_AUDIO,
 	AB8505_LDO_ANAMIC1,
 	AB8505_LDO_ANAMIC2,
 	AB8505_LDO_AUX8,
 	AB8505_LDO_ANA,
-	AB8505_SYSCLKREQ_2,
-	AB8505_SYSCLKREQ_4,
 	AB8505_NUM_REGULATORS,
 };

include/linux/regulator/fixed.h+1−0

@@ -36,6 +36,7 @@ struct fixed_voltage_config { · 35 unmodified lines
36	const char *input_supply;	36	const char *input_supply;
37	int microvolts;	37	int microvolts;
38	unsigned startup_delay;	38	unsigned startup_delay;
		39	unsigned int off_on_delay;
39	unsigned enabled_at_boot:1;	40	unsigned enabled_at_boot:1;
40	struct regulator_init_data *init_data;	41	struct regulator_init_data *init_data;
41	};	42	};

include/linux/reset-controller.h+2−1

  * @of_node: corresponding device tree node as phandle target
  * @of_reset_n_cells: number of cells in reset line specifiers
  * @of_xlate: translation function to translate from specifier as found in the
- *            device tree to id as given to the reset control ops
+ *            device tree to id as given to the reset control ops, defaults
+ *            to :c:func:`of_reset_simple_xlate`.
  * @nr_resets: number of reset controls in this reset controller device
  */
 struct reset_controller_dev {

include/linux/reset.h+46−0

@@ -203,12 +203,34 @@ static inline struct reset_control *reset_control_get_shared( · 202 unmodified lines
203	return __reset_control_get(dev, id, 0, true, false, false);	203	return __reset_control_get(dev, id, 0, true, false, false);
204	}	204	}
205		205
		206	/**
		207	* reset_control_get_optional_exclusive - optional reset_control_get_exclusive()
		208	* @dev: device to be reset by the controller
		209	* @id: reset line name
		210	*
		211	* Optional variant of reset_control_get_exclusive(). If the requested reset
		212	* is not specified in the device tree, this function returns NULL instead of
		213	* an error.
		214	*
		215	* See reset_control_get_exclusive() for more information.
		216	*/
206	static inline struct reset_control *reset_control_get_optional_exclusive(	217	static inline struct reset_control *reset_control_get_optional_exclusive(
207	struct device dev, const char id)	218	struct device dev, const char id)
208	{	219	{
209	return __reset_control_get(dev, id, 0, false, true, true);	220	return __reset_control_get(dev, id, 0, false, true, true);
210	}	221	}
211		222
		223	/**
		224	* reset_control_get_optional_shared - optional reset_control_get_shared()
		225	* @dev: device to be reset by the controller
		226	* @id: reset line name
		227	*
		228	* Optional variant of reset_control_get_shared(). If the requested reset
		229	* is not specified in the device tree, this function returns NULL instead of
		230	* an error.
		231	*
		232	* See reset_control_get_shared() for more information.
		233	*/
212	static inline struct reset_control *reset_control_get_optional_shared(	234	static inline struct reset_control *reset_control_get_optional_shared(
213	struct device dev, const char id)	235	struct device dev, const char id)
214	{	236	{
@@ -354,12 +376,36 @@ static inline struct reset_control *devm_reset_control_get_shared( · 139 unmodified lines
354	return __devm_reset_control_get(dev, id, 0, true, false, false);	376	return __devm_reset_control_get(dev, id, 0, true, false, false);
355	}	377	}
356		378
		379	/**
		380	* devm_reset_control_get_optional_exclusive - resource managed
		381	* reset_control_get_optional_exclusive()
		382	* @dev: device to be reset by the controller
		383	* @id: reset line name
		384	*
		385	* Managed reset_control_get_optional_exclusive(). For reset controllers
		386	* returned from this function, reset_control_put() is called automatically on
		387	* driver detach.
		388	*
		389	* See reset_control_get_optional_exclusive() for more information.
		390	*/
357	static inline struct reset_control *devm_reset_control_get_optional_exclusive(	391	static inline struct reset_control *devm_reset_control_get_optional_exclusive(
358	struct device dev, const char id)	392	struct device dev, const char id)
359	{	393	{
360	return __devm_reset_control_get(dev, id, 0, false, true, true);	394	return __devm_reset_control_get(dev, id, 0, false, true, true);
361	}	395	}
362		396
		397	/**
		398	* devm_reset_control_get_optional_shared - resource managed
		399	* reset_control_get_optional_shared()
		400	* @dev: device to be reset by the controller
		401	* @id: reset line name
		402	*
		403	* Managed reset_control_get_optional_shared(). For reset controllers returned
		404	* from this function, reset_control_put() is called automatically on driver
		405	* detach.
		406	*
		407	* See reset_control_get_optional_shared() for more information.
		408	*/
363	static inline struct reset_control *devm_reset_control_get_optional_shared(	409	static inline struct reset_control *devm_reset_control_get_optional_shared(
364	struct device dev, const char id)	410	struct device dev, const char id)
365	{	411	{

include/linux/resource_ext.h+12−0

@@ -66,4 +66,16 @@ resource_list_destroy_entry(struct resource_entry *entry) · 65 unmodified lines
66	#define resource_list_for_each_entry_safe(entry, tmp, list) \	66	#define resource_list_for_each_entry_safe(entry, tmp, list) \
67	list_for_each_entry_safe((entry), (tmp), (list), node)	67	list_for_each_entry_safe((entry), (tmp), (list), node)
68		68
		69	static inline struct resource_entry *
		70	resource_list_first_type(struct list_head *list, unsigned long type)
		71	{
		72	struct resource_entry *entry;
		73
		74	resource_list_for_each_entry(entry, list) {
		75	if (resource_type(entry->res) == type)
		76	return entry;
		77	}
		78	return NULL;
		79	}
		80
69	#endif /* _LINUX_RESOURCE_EXT_H */	81	#endif /* _LINUX_RESOURCE_EXT_H */

include/linux/rtc.h+5−0

 };
 #define to_rtc_device(d) container_of(d, struct rtc_device, dev)
+#define rtc_lock(d) mutex_lock(&d->ops_lock)
+#define rtc_unlock(d) mutex_unlock(&d->ops_lock)
 /* useful timestamps */
+#define RTC_TIMESTAMP_BEGIN_0000	-62167219200ULL /* 0000-01-01 00:00:00 */
 #define RTC_TIMESTAMP_BEGIN_1900	-2208988800LL /* 1900-01-01 00:00:00 */
 #define RTC_TIMESTAMP_BEGIN_2000	946684800LL /* 2000-01-01 00:00:00 */
 #define RTC_TIMESTAMP_END_2063		2966371199LL /* 2063-12-31 23:59:59 */
 #define RTC_TIMESTAMP_END_2099		4102444799LL /* 2099-12-31 23:59:59 */
+#define RTC_TIMESTAMP_END_2199		7258118399LL /* 2199-12-31 23:59:59 */
 #define RTC_TIMESTAMP_END_9999		253402300799LL /* 9999-12-31 23:59:59 */
 extern struct rtc_device *devm_rtc_device_register(struct device *dev,

include/linux/rtc/ds1685.h+5−7

 struct ds1685_priv {
 	struct rtc_device *dev;
 	void __iomem *regs;
+	void __iomem *data;
 	u32 regstep;
-	resource_size_t baseaddr;
-	size_t size;
 	int irq_num;
 	bool bcd_mode;
 	bool no_irq;
-	bool uie_unsupported;
-	bool alloc_io_resources;
 	u8 (*read)(struct ds1685_priv *, int);
 	void (*write)(struct ds1685_priv *, int, u8);
 	void (*prepare_poweroff)(void);
 	const bool bcd_mode;
 	const bool no_irq;
 	const bool uie_unsupported;
-	const bool alloc_io_resources;
-	u8 (*plat_read)(struct ds1685_priv *, int);
-	void (*plat_write)(struct ds1685_priv *, int, u8);
 	void (*plat_prepare_poweroff)(void);
 	void (*plat_wake_alarm)(void);
 	void (*plat_post_ram_clear)(void);
+	enum {
+		ds1685_reg_direct,
+		ds1685_reg_indirect
+	} access_type;
 };

include/linux/rtsx_pci.h+1−0

@@ -1262,6 +1262,7 @@ struct rtsx_pcr { · 1261 unmodified lines
1262	#define PID_5250 0x5250	1262	#define PID_5250 0x5250
1263	#define PID_525A 0x525A	1263	#define PID_525A 0x525A
1264	#define PID_5260 0x5260	1264	#define PID_5260 0x5260
		1265	#define PID_5261 0x5261
1265		1266
1266	#define CHK_PCI_PID(pcr, pid) ((pcr)->pci->device == (pid))	1267	#define CHK_PCI_PID(pcr, pid) ((pcr)->pci->device == (pid))
1267	#define PCI_VID(pcr) ((pcr)->pci->vendor)	1268	#define PCI_VID(pcr) ((pcr)->pci->vendor)

include/linux/rwlock_api_smp.h+8−8

@@ -215,14 +215,14 @@ static inline void __raw_write_lock(rwlock_t *lock) · 214 unmodified lines
215		215
216	static inline void __raw_write_unlock(rwlock_t *lock)	216	static inline void __raw_write_unlock(rwlock_t *lock)
217	{	217	{
218	rwlock_release(&lock->dep_map, 1, _RET_IP_);	218	rwlock_release(&lock->dep_map, _RET_IP_);
219	do_raw_write_unlock(lock);	219	do_raw_write_unlock(lock);
220	preempt_enable();	220	preempt_enable();
221	}	221	}
222		222
223	static inline void __raw_read_unlock(rwlock_t *lock)	223	static inline void __raw_read_unlock(rwlock_t *lock)
224	{	224	{
225	rwlock_release(&lock->dep_map, 1, _RET_IP_);	225	rwlock_release(&lock->dep_map, _RET_IP_);
226	do_raw_read_unlock(lock);	226	do_raw_read_unlock(lock);
227	preempt_enable();	227	preempt_enable();
228	}	228	}
@@ -230,7 +230,7 @@ static inline void __raw_read_unlock(rwlock_t *lock) · 1 unmodified line
230	static inline void	230	static inline void
231	__raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)	231	__raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
232	{	232	{
233	rwlock_release(&lock->dep_map, 1, _RET_IP_);	233	rwlock_release(&lock->dep_map, _RET_IP_);
234	do_raw_read_unlock(lock);	234	do_raw_read_unlock(lock);
235	local_irq_restore(flags);	235	local_irq_restore(flags);
236	preempt_enable();	236	preempt_enable();
@@ -238,7 +238,7 @@ __raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags) · 1 unmodified line
238		238
239	static inline void __raw_read_unlock_irq(rwlock_t *lock)	239	static inline void __raw_read_unlock_irq(rwlock_t *lock)
240	{	240	{
241	rwlock_release(&lock->dep_map, 1, _RET_IP_);	241	rwlock_release(&lock->dep_map, _RET_IP_);
242	do_raw_read_unlock(lock);	242	do_raw_read_unlock(lock);
243	local_irq_enable();	243	local_irq_enable();
244	preempt_enable();	244	preempt_enable();
@@ -246,7 +246,7 @@ static inline void __raw_read_unlock_irq(rwlock_t *lock) · 1 unmodified line
246		246
247	static inline void __raw_read_unlock_bh(rwlock_t *lock)	247	static inline void __raw_read_unlock_bh(rwlock_t *lock)
248	{	248	{
249	rwlock_release(&lock->dep_map, 1, _RET_IP_);	249	rwlock_release(&lock->dep_map, _RET_IP_);
250	do_raw_read_unlock(lock);	250	do_raw_read_unlock(lock);
251	__local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);	251	__local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);
252	}	252	}
@@ -254,7 +254,7 @@ static inline void __raw_read_unlock_bh(rwlock_t *lock) · 1 unmodified line
254	static inline void __raw_write_unlock_irqrestore(rwlock_t *lock,	254	static inline void __raw_write_unlock_irqrestore(rwlock_t *lock,
255	unsigned long flags)	255	unsigned long flags)
256	{	256	{
257	rwlock_release(&lock->dep_map, 1, _RET_IP_);	257	rwlock_release(&lock->dep_map, _RET_IP_);
258	do_raw_write_unlock(lock);	258	do_raw_write_unlock(lock);
259	local_irq_restore(flags);	259	local_irq_restore(flags);
260	preempt_enable();	260	preempt_enable();
@@ -262,7 +262,7 @@ static inline void __raw_write_unlock_irqrestore(rwlock_t *lock, · 1 unmodified line
262		262
263	static inline void __raw_write_unlock_irq(rwlock_t *lock)	263	static inline void __raw_write_unlock_irq(rwlock_t *lock)
264	{	264	{
265	rwlock_release(&lock->dep_map, 1, _RET_IP_);	265	rwlock_release(&lock->dep_map, _RET_IP_);
266	do_raw_write_unlock(lock);	266	do_raw_write_unlock(lock);
267	local_irq_enable();	267	local_irq_enable();
268	preempt_enable();	268	preempt_enable();
@@ -270,7 +270,7 @@ static inline void __raw_write_unlock_irq(rwlock_t *lock) · 1 unmodified line
270		270
271	static inline void __raw_write_unlock_bh(rwlock_t *lock)	271	static inline void __raw_write_unlock_bh(rwlock_t *lock)
272	{	272	{
273	rwlock_release(&lock->dep_map, 1, _RET_IP_);	273	rwlock_release(&lock->dep_map, _RET_IP_);
274	do_raw_write_unlock(lock);	274	do_raw_write_unlock(lock);
275	__local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);	275	__local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);
276	}	276	}

include/linux/sbitmap.h+0−9

@@ -216,15 +216,6 @@ int sbitmap_get_shallow(struct sbitmap *sb, unsigned int alloc_hint, · 215 unmodified lines
216	*/	216	*/
217	bool sbitmap_any_bit_set(const struct sbitmap *sb);	217	bool sbitmap_any_bit_set(const struct sbitmap *sb);
218		218
219	/**
220	* sbitmap_any_bit_clear() - Check for an unset bit in a &struct
221	* sbitmap.
222	* @sb: Bitmap to check.
223	*
224	* Return: true if any bit in the bitmap is clear, false otherwise.
225	*/
226	bool sbitmap_any_bit_clear(const struct sbitmap *sb);
227
228	#define SB_NR_TO_INDEX(sb, bitnr) ((bitnr) >> (sb)->shift)	219	#define SB_NR_TO_INDEX(sb, bitnr) ((bitnr) >> (sb)->shift)
229	#define SB_NR_TO_BIT(sb, bitnr) ((bitnr) & ((1U << (sb)->shift) - 1U))	220	#define SB_NR_TO_BIT(sb, bitnr) ((bitnr) & ((1U << (sb)->shift) - 1U))
230		221

include/linux/sched.h+19−4

 enum vtime_state {
 	/* Task is sleeping or running in a CPU with VTIME inactive: */
 	VTIME_INACTIVE = 0,
-	/* Task runs in userspace in a CPU with VTIME active: */
+	/* Task is idle */
-	VTIME_USER,
+	VTIME_IDLE,
 	/* Task runs in kernelspace in a CPU with VTIME active: */
 	VTIME_SYS,
+	/* Task runs in userspace in a CPU with VTIME active: */
+	VTIME_USER,
+	/* Task runs as guests in a CPU with VTIME active: */
+	VTIME_GUEST,
 };
 struct vtime {
 	seqcount_t		seqcount;
 	unsigned long long	starttime;
 	enum vtime_state	state;
+	unsigned int		cpu;
 	u64			utime;
 	u64			stime;
 	u64			gtime;
 	u64				start_time;
 	/* Boot based time in nsecs: */
-	u64				real_start_time;
+	u64				start_boottime;
 	/* MM fault and swap info: this can arguably be seen as either mm-specific or thread-specific: */
 	unsigned long			min_flt;
 #endif
 	struct list_head		pi_state_list;
 	struct futex_pi_state		*pi_state_cache;
+	struct mutex			futex_exit_mutex;
+	unsigned int			futex_state;
 #endif
 #ifdef CONFIG_PERF_EVENTS
 	struct perf_event_context	*perf_event_ctxp[perf_nr_task_contexts];
 #endif /* CONFIG_TRACING */
 #ifdef CONFIG_KCOV
+	/* See kernel/kcov.c for more details. */
 	/* Coverage collection mode enabled for this task (0 if disabled): */
 	unsigned int			kcov_mode;
 	/* KCOV descriptor wired with this task or NULL: */
 	struct kcov			*kcov;
+	/* KCOV common handle for remote coverage collection: */
+	u64				kcov_handle;
+	/* KCOV sequence number: */
+	int				kcov_sequence;
 #endif
 #ifdef CONFIG_MEMCG
  */
 #define PF_IDLE			0x00000002	/* I am an IDLE thread */
 #define PF_EXITING		0x00000004	/* Getting shut down */
-#define PF_EXITPIDONE		0x00000008	/* PI exit done on shut down */
 #define PF_VCPU			0x00000010	/* I'm a virtual CPU */
 #define PF_WQ_WORKER		0x00000020	/* I'm a workqueue worker */
 #define PF_FORKNOEXEC		0x00000040	/* Forked but didn't exec */
 #define PF_NO_SETAFFINITY	0x04000000	/* Userland is not allowed to meddle with cpus_mask */
 #define PF_MCE_EARLY		0x08000000      /* Early kill for mce process policy */
 #define PF_MEMALLOC_NOCMA	0x10000000	/* All allocation request will have _GFP_MOVABLE cleared */
+#define PF_IO_WORKER		0x20000000	/* Task is an IO worker */
 #define PF_FREEZER_SKIP		0x40000000	/* Freezer should not count it as freezable */
 #define PF_SUSPEND_TASK		0x80000000      /* This thread called freeze_processes() and should not be frozen */

include/linux/sched/cpufreq.h+3−0

 #define SCHED_CPUFREQ_MIGRATION	(1U << 1)
 #ifdef CONFIG_CPU_FREQ
+struct cpufreq_policy;
 struct update_util_data {
        void (*func)(struct update_util_data *data, u64 time, unsigned int flags);
 };
                        void (*func)(struct update_util_data *data, u64 time,
 				    unsigned int flags));
 void cpufreq_remove_update_util_hook(int cpu);
+bool cpufreq_this_cpu_can_update(struct cpufreq_policy *policy);
 static inline unsigned long map_util_freq(unsigned long util,
 					unsigned long freq, unsigned long cap)

include/linux/sched/mm.h+4−2

  * succeeds.
  */
 extern struct mm_struct *mm_access(struct task_struct *task, unsigned int mode);
-/* Remove the current tasks stale references to the old mm_struct */
+/* Remove the current tasks stale references to the old mm_struct on exit() */
-extern void mm_release(struct task_struct *, struct mm_struct *);
+extern void exit_mm_release(struct task_struct *, struct mm_struct *);
+/* Remove the current tasks stale references to the old mm_struct on exec() */
+extern void exec_mm_release(struct task_struct *, struct mm_struct *);
 #ifdef CONFIG_MEMCG
 extern void mm_update_next_owner(struct mm_struct *mm);

include/linux/sched/task.h+3−0

 	unsigned long stack;
 	unsigned long stack_size;
 	unsigned long tls;
+	pid_t *set_tid;
+	/* Number of elements in *set_tid */
+	size_t set_tid_size;
 };
 /*

include/linux/seccomp.h+3−3

@@ -33,10 +33,10 @@ struct seccomp { · 32 unmodified lines
33		33
34	#ifdef CONFIG_HAVE_ARCH_SECCOMP_FILTER	34	#ifdef CONFIG_HAVE_ARCH_SECCOMP_FILTER
35	extern int __secure_computing(const struct seccomp_data *sd);	35	extern int __secure_computing(const struct seccomp_data *sd);
36	static inline int secure_computing(const struct seccomp_data *sd)	36	static inline int secure_computing(void)
37	{	37	{
38	if (unlikely(test_thread_flag(TIF_SECCOMP)))	38	if (unlikely(test_thread_flag(TIF_SECCOMP)))
39	return __secure_computing(sd);	39	return __secure_computing(NULL);
40	return 0;	40	return 0;
41	}	41	}
42	#else	42	#else
@@ -59,7 +59,7 @@ struct seccomp { }; · 16 unmodified lines
59	struct seccomp_filter { };	59	struct seccomp_filter { };
60		60
61	#ifdef CONFIG_HAVE_ARCH_SECCOMP_FILTER	61	#ifdef CONFIG_HAVE_ARCH_SECCOMP_FILTER
62	static inline int secure_computing(struct seccomp_data *sd) { return 0; }	62	static inline int secure_computing(void) { return 0; }
63	#else	63	#else
64	static inline void secure_computing_strict(int this_syscall) { return; }	64	static inline void secure_computing_strict(int this_syscall) { return; }
65	#endif	65	#endif

include/linux/security.h+40−1

@@ -117,12 +117,14 @@ enum lockdown_reason { · 116 unmodified lines
117	LOCKDOWN_MODULE_PARAMETERS,	117	LOCKDOWN_MODULE_PARAMETERS,
118	LOCKDOWN_MMIOTRACE,	118	LOCKDOWN_MMIOTRACE,
119	LOCKDOWN_DEBUGFS,	119	LOCKDOWN_DEBUGFS,
		120	LOCKDOWN_XMON_WR,
120	LOCKDOWN_INTEGRITY_MAX,	121	LOCKDOWN_INTEGRITY_MAX,
121	LOCKDOWN_KCORE,	122	LOCKDOWN_KCORE,
122	LOCKDOWN_KPROBES,	123	LOCKDOWN_KPROBES,
123	LOCKDOWN_BPF_READ,	124	LOCKDOWN_BPF_READ,
124	LOCKDOWN_PERF,	125	LOCKDOWN_PERF,
125	LOCKDOWN_TRACEFS,	126	LOCKDOWN_TRACEFS,
		127	LOCKDOWN_XMON_RW,
126	LOCKDOWN_CONFIDENTIALITY_MAX,	128	LOCKDOWN_CONFIDENTIALITY_MAX,
127	};	129	};
128		130
@@ -1895,5 +1897,42 @@ static inline void security_bpf_prog_free(struct bpf_prog_aux *aux) · 1766 unmodified lines
1895	#endif /* CONFIG_SECURITY */	1897	#endif /* CONFIG_SECURITY */
1896	#endif /* CONFIG_BPF_SYSCALL */	1898	#endif /* CONFIG_BPF_SYSCALL */
1897		1899
1898	#endif /* ! __LINUX_SECURITY_H */	1900	#ifdef CONFIG_PERF_EVENTS
		1901	struct perf_event_attr;
		1902	struct perf_event;
		1903
		1904	#ifdef CONFIG_SECURITY
		1905	extern int security_perf_event_open(struct perf_event_attr *attr, int type);
		1906	extern int security_perf_event_alloc(struct perf_event *event);
		1907	extern void security_perf_event_free(struct perf_event *event);
		1908	extern int security_perf_event_read(struct perf_event *event);
		1909	extern int security_perf_event_write(struct perf_event *event);
		1910	#else
		1911	static inline int security_perf_event_open(struct perf_event_attr *attr,
		1912	int type)
		1913	{
		1914	return 0;
		1915	}
		1916
		1917	static inline int security_perf_event_alloc(struct perf_event *event)
		1918	{
		1919	return 0;
		1920	}
		1921
		1922	static inline void security_perf_event_free(struct perf_event *event)
		1923	{
		1924	}
		1925
		1926	static inline int security_perf_event_read(struct perf_event *event)
		1927	{
		1928	return 0;
		1929	}
1899		1930
		1931	static inline int security_perf_event_write(struct perf_event *event)
		1932	{
		1933	return 0;
		1934	}
		1935	#endif /* CONFIG_SECURITY */
		1936	#endif /* CONFIG_PERF_EVENTS */
		1937
		1938	#endif /* ! __LINUX_SECURITY_H */

include/linux/sed-opal.h+1−0

@@ -42,6 +42,7 @@ static inline bool is_sed_ioctl(unsigned int cmd) · 41 unmodified lines
42	case IOC_OPAL_PSID_REVERT_TPR:	42	case IOC_OPAL_PSID_REVERT_TPR:
43	case IOC_OPAL_MBR_DONE:	43	case IOC_OPAL_MBR_DONE:
44	case IOC_OPAL_WRITE_SHADOW_MBR:	44	case IOC_OPAL_WRITE_SHADOW_MBR:
		45	case IOC_OPAL_GENERIC_TABLE_RW:
45	return true;	46	return true;
46	}	47	}
47	return false;	48	return false;

include/linux/seq_buf.h+3−0

 extern int seq_buf_putmem_hex(struct seq_buf *s, const void *mem,
 			      unsigned int len);
 extern int seq_buf_path(struct seq_buf *s, const struct path *path, const char *esc);
+extern int seq_buf_hex_dump(struct seq_buf *s, const char *prefix_str,
+			    int prefix_type, int rowsize, int groupsize,
+			    const void *buf, size_t len, bool ascii);
 #ifdef CONFIG_BINARY_PRINTF
 extern int

include/linux/seqlock.h+2−2

@@ -95,7 +95,7 @@ static inline void seqcount_lockdep_reader_access(const seqcount_t *s) · 94 unmodified lines
95		95
96	local_irq_save(flags);	96	local_irq_save(flags);
97	seqcount_acquire_read(&l->dep_map, 0, 0, _RET_IP_);	97	seqcount_acquire_read(&l->dep_map, 0, 0, _RET_IP_);
98	seqcount_release(&l->dep_map, 1, _RET_IP_);	98	seqcount_release(&l->dep_map, _RET_IP_);
99	local_irq_restore(flags);	99	local_irq_restore(flags);
100	}	100	}
101		101
@@ -415,7 +415,7 @@ static inline void write_seqcount_begin(seqcount_t *s) · 313 unmodified lines
415		415
416	static inline void write_seqcount_end(seqcount_t *s)	416	static inline void write_seqcount_end(seqcount_t *s)
417	{	417	{
418	seqcount_release(&s->dep_map, 1, _RET_IP_);	418	seqcount_release(&s->dep_map, _RET_IP_);
419	raw_write_seqcount_end(s);	419	raw_write_seqcount_end(s);
420	}	420	}
421		421

include/linux/sfp.h+22−9

 	SFP_TEC_CUR			= 0x6c,
 	SFP_STATUS			= 0x6e,
+	SFP_STATUS_TX_DISABLE		= BIT(7),
+	SFP_STATUS_TX_DISABLE_FORCE	= BIT(6),
+	SFP_STATUS_TX_FAULT		= BIT(2),
+	SFP_STATUS_RX_LOS		= BIT(1),
 	SFP_ALARM0			= 0x70,
 	SFP_ALARM0_TEMP_HIGH		= BIT(7),
 	SFP_ALARM0_TEMP_LOW		= BIT(6),
 			  u8 *data);
 void sfp_upstream_start(struct sfp_bus *bus);
 void sfp_upstream_stop(struct sfp_bus *bus);
-struct sfp_bus *sfp_register_upstream(struct fwnode_handle *fwnode,
+void sfp_bus_put(struct sfp_bus *bus);
-				      void *upstream,
+struct sfp_bus *sfp_bus_find_fwnode(struct fwnode_handle *fwnode);
-				      const struct sfp_upstream_ops *ops);
+int sfp_bus_add_upstream(struct sfp_bus *bus, void *upstream,
-void sfp_unregister_upstream(struct sfp_bus *bus);
+			 const struct sfp_upstream_ops *ops);
+void sfp_bus_del_upstream(struct sfp_bus *bus);
 #else
 static inline int sfp_parse_port(struct sfp_bus *bus,
 				 const struct sfp_eeprom_id *id,
 {
 }
-static inline struct sfp_bus *sfp_register_upstream(
+static inline void sfp_bus_put(struct sfp_bus *bus)
-	struct fwnode_handle *fwnode, void *upstream,
-	const struct sfp_upstream_ops *ops)
 {
-	return (struct sfp_bus *)-1;
 }
-static inline void sfp_unregister_upstream(struct sfp_bus *bus)
+static inline struct sfp_bus *sfp_bus_find_fwnode(struct fwnode_handle *fwnode)
+{
+	return NULL;
+}
+static inline int sfp_bus_add_upstream(struct sfp_bus *bus, void *upstream,
+				       const struct sfp_upstream_ops *ops)
+{
+	return 0;
+}
+static inline void sfp_bus_del_upstream(struct sfp_bus *bus)
 {
 }
 #endif

include/linux/skbuff.h+21−9

  */
 static inline struct sk_buff *skb_peek_tail(const struct sk_buff_head *list_)
 {
-	struct sk_buff *skb = list_->prev;
+	struct sk_buff *skb = READ_ONCE(list_->prev);
 	if (skb == (struct sk_buff *)list_)
 		skb = NULL;
 				struct sk_buff *prev, struct sk_buff *next,
 				struct sk_buff_head *list)
 {
-	/* see skb_queue_empty_lockless() for the opposite READ_ONCE() */
+	/* See skb_queue_empty_lockless() and skb_peek_tail()
+	 * for the opposite READ_ONCE()
+	 */
 	WRITE_ONCE(newsk->next, next);
 	WRITE_ONCE(newsk->prev, prev);
 	WRITE_ONCE(next->prev, newsk);
 	return unlikely(len > skb->len) ? NULL : __pskb_pull(skb, len);
 }
-static inline int pskb_may_pull(struct sk_buff *skb, unsigned int len)
+static inline bool pskb_may_pull(struct sk_buff *skb, unsigned int len)
 {
 	if (likely(len <= skb_headlen(skb)))
-		return 1;
+		return true;
 	if (unlikely(len > skb->len))
-		return 0;
+		return false;
 	return __pskb_pull_tail(skb, len - skb_headlen(skb)) != NULL;
 }
 int skb_vlan_pop(struct sk_buff *skb);
 int skb_vlan_push(struct sk_buff *skb, __be16 vlan_proto, u16 vlan_tci);
 int skb_mpls_push(struct sk_buff *skb, __be32 mpls_lse, __be16 mpls_proto,
-		  int mac_len);
+		  int mac_len, bool ethernet);
-int skb_mpls_pop(struct sk_buff *skb, __be16 next_proto, int mac_len);
+int skb_mpls_pop(struct sk_buff *skb, __be16 next_proto, int mac_len,
+		 bool ethernet);
 int skb_mpls_update_lse(struct sk_buff *skb, __be32 mpls_lse);
 int skb_mpls_dec_ttl(struct sk_buff *skb);
 struct sk_buff *pskb_extract(struct sk_buff *skb, int off, int to_copy,
 }
 static inline void skb_get_timestampns(const struct sk_buff *skb,
-				       struct timespec *stamp)
+				       struct __kernel_old_timespec *stamp)
 {
-	*stamp = ktime_to_timespec(skb->tstamp);
+	struct timespec64 ts = ktime_to_timespec64(skb->tstamp);
+	stamp->tv_sec = ts.tv_sec;
+	stamp->tv_nsec = ts.tv_nsec;
 }
 static inline void skb_get_new_timestampns(const struct sk_buff *skb,
 		skb->active_extensions = 0;
 	}
 }
+static inline bool skb_has_extensions(struct sk_buff *skb)
+{
+	return unlikely(skb->active_extensions);
+}
 #else
 static inline void skb_ext_put(struct sk_buff *skb) {}
 static inline void skb_ext_reset(struct sk_buff *skb) {}
 static inline void skb_ext_del(struct sk_buff *skb, int unused) {}
 static inline void __skb_ext_copy(struct sk_buff *d, const struct sk_buff *s) {}
 static inline void skb_ext_copy(struct sk_buff *dst, const struct sk_buff *s) {}
+static inline bool skb_has_extensions(struct sk_buff *skb) { return false; }
 #endif /* CONFIG_SKB_EXTENSIONS */
 static inline void nf_reset_ct(struct sk_buff *skb)

include/linux/skmsg.h+21−17

 #include <net/strparser.h>
 #define MAX_MSG_FRAGS			MAX_SKB_FRAGS
+#define NR_MSG_FRAG_IDS			(MAX_MSG_FRAGS + 1)
 enum __sk_action {
 	__SK_DROP = 0,
 	u32				end;
 	u32				size;
 	u32				copybreak;
-	bool				copy[MAX_MSG_FRAGS];
+	unsigned long			copy;
-	/* The extra element is used for chaining the front and sections when
+	/* The extra two elements:
-	 * the list becomes partitioned (e.g. end < start). The crypto APIs
+	 * 1) used for chaining the front and sections when the list becomes
-	 * require the chaining.
+	 *    partitioned (e.g. end < start). The crypto APIs require the
+	 *    chaining;
+	 * 2) to chain tailer SG entries after the message.
 	 */
-	struct scatterlist		data[MAX_MSG_FRAGS + 1];
+	struct scatterlist		data[MAX_MSG_FRAGS + 2];
 };
+static_assert(BITS_PER_LONG >= NR_MSG_FRAG_IDS);
 /* UAPI in filter.c depends on struct sk_msg_sg being first element. */
 struct sk_msg {
 static inline u32 sk_msg_iter_dist(u32 start, u32 end)
 {
-	return end >= start ? end - start : end + (MAX_MSG_FRAGS - start);
+	return end >= start ? end - start : end + (NR_MSG_FRAG_IDS - start);
 }
 #define sk_msg_iter_var_prev(var)			\
 	do {						\
 		if (var == 0)				\
-			var = MAX_MSG_FRAGS - 1;	\
+			var = NR_MSG_FRAG_IDS - 1;	\
 		else					\
 			var--;				\
 	} while (0)
 #define sk_msg_iter_var_next(var)			\
 	do {						\
 		var++;					\
-		if (var == MAX_MSG_FRAGS)		\
+		if (var == NR_MSG_FRAG_IDS)		\
 			var = 0;			\
 	} while (0)
 static inline void sk_msg_init(struct sk_msg *msg)
 {
-	BUILD_BUG_ON(ARRAY_SIZE(msg->sg.data) - 1 != MAX_MSG_FRAGS);
+	BUILD_BUG_ON(ARRAY_SIZE(msg->sg.data) - 1 != NR_MSG_FRAG_IDS);
 	memset(msg, 0, sizeof(*msg));
-	sg_init_marker(msg->sg.data, MAX_MSG_FRAGS);
+	sg_init_marker(msg->sg.data, NR_MSG_FRAG_IDS);
 }
 static inline void sk_msg_xfer(struct sk_msg *dst, struct sk_msg *src,
 static inline bool sk_msg_full(const struct sk_msg *msg)
 {
-	return (msg->sg.end == msg->sg.start) && msg->sg.size;
+	return sk_msg_iter_dist(msg->sg.start, msg->sg.end) == MAX_MSG_FRAGS;
 }
 static inline u32 sk_msg_elem_used(const struct sk_msg *msg)
 {
-	if (sk_msg_full(msg))
-		return MAX_MSG_FRAGS;
 	return sk_msg_iter_dist(msg->sg.start, msg->sg.end);
 }
 {
 	struct scatterlist *sge = sk_msg_elem(msg, msg->sg.start);
-	if (msg->sg.copy[msg->sg.start]) {
+	if (test_bit(msg->sg.start, &msg->sg.copy)) {
 		msg->data = NULL;
 		msg->data_end = NULL;
 	} else {
 	sg_set_page(sge, page, len, offset);
 	sg_unmark_end(sge);
-	msg->sg.copy[msg->sg.end] = true;
+	__set_bit(msg->sg.end, &msg->sg.copy);
 	msg->sg.size += len;
 	sk_msg_iter_next(msg, end);
 }
 static inline void sk_msg_sg_copy(struct sk_msg *msg, u32 i, bool copy_state)
 {
 	do {
-		msg->sg.copy[i] = copy_state;
+		if (copy_state)
+			__set_bit(i, &msg->sg.copy);
+		else
+			__clear_bit(i, &msg->sg.copy);
 		sk_msg_iter_var_next(i);
 		if (i == msg->sg.end)
 			break;

include/linux/slab.h+0−20

@@ -561,26 +561,6 @@ static __always_inline void *kmalloc(size_t size, gfp_t flags) · 560 unmodified lines
561	return __kmalloc(size, flags);	561	return __kmalloc(size, flags);
562	}	562	}
563		563
564	/*
565	* Determine size used for the nth kmalloc cache.
566	* return size or 0 if a kmalloc cache for that
567	* size does not exist
568	*/
569	static __always_inline unsigned int kmalloc_size(unsigned int n)
570	{
571	#ifndef CONFIG_SLOB
572	if (n > 2)
573	return 1U << n;
574
575	if (n == 1 && KMALLOC_MIN_SIZE <= 32)
576	return 96;
577
578	if (n == 2 && KMALLOC_MIN_SIZE <= 64)
579	return 192;
580	#endif
581	return 0;
582	}
583
584	static __always_inline void *kmalloc_node(size_t size, gfp_t flags, int node)	564	static __always_inline void *kmalloc_node(size_t size, gfp_t flags, int node)
585	{	565	{
586	#ifndef CONFIG_SLOB	566	#ifndef CONFIG_SLOB

include/linux/soc/mmp/cputype.h+87−0

@@ -0,0 +1,87 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef __ASM_MACH_CPUTYPE_H
	3	#define __ASM_MACH_CPUTYPE_H
	4
	5	#if defined(CONFIG_ARM) \|\| defined(CONFIG_ARM64)
	6	#include <asm/cputype.h>
	7	#endif
	8
	9	/*
	10	* CPU Stepping CPU_ID CHIP_ID
	11	*
	12	* PXA168 S0 0x56158400 0x0000C910
	13	* PXA168 A0 0x56158400 0x00A0A168
	14	* PXA910 Y1 0x56158400 0x00F2C920
	15	* PXA910 A0 0x56158400 0x00F2C910
	16	* PXA910 A1 0x56158400 0x00A0C910
	17	* PXA920 Y0 0x56158400 0x00F2C920
	18	* PXA920 A0 0x56158400 0x00A0C920
	19	* PXA920 A1 0x56158400 0x00A1C920
	20	* MMP2 Z0 0x560f5811 0x00F00410
	21	* MMP2 Z1 0x560f5811 0x00E00410
	22	* MMP2 A0 0x560f5811 0x00A0A610
	23	* MMP3 A0 0x562f5842 0x00A02128
	24	* MMP3 B0 0x562f5842 0x00B02128
	25	*/
	26
	27	extern unsigned int mmp_chip_id;
	28
	29	#ifdef CONFIG_CPU_PXA168
	30	static inline int cpu_is_pxa168(void)
	31	{
	32	return (((read_cpuid_id() >> 8) & 0xff) == 0x84) &&
	33	((mmp_chip_id & 0xfff) == 0x168);
	34	}
	35	#else
	36	#define cpu_is_pxa168() (0)
	37	#endif
	38
	39	/* cpu_is_pxa910() is shared on both pxa910 and pxa920 */
	40	#ifdef CONFIG_CPU_PXA910
	41	static inline int cpu_is_pxa910(void)
	42	{
	43	return (((read_cpuid_id() >> 8) & 0xff) == 0x84) &&
	44	(((mmp_chip_id & 0xfff) == 0x910) \|\|
	45	((mmp_chip_id & 0xfff) == 0x920));
	46	}
	47	#else
	48	#define cpu_is_pxa910() (0)
	49	#endif
	50
	51	#if defined(CONFIG_CPU_MMP2) \|\| defined(CONFIG_MACH_MMP2_DT)
	52	static inline int cpu_is_mmp2(void)
	53	{
	54	return (((read_cpuid_id() >> 8) & 0xff) == 0x58) &&
	55	(((mmp_chip_id & 0xfff) == 0x410) \|\|
	56	((mmp_chip_id & 0xfff) == 0x610));
	57	}
	58	#else
	59	#define cpu_is_mmp2() (0)
	60	#endif
	61
	62	#ifdef CONFIG_MACH_MMP3_DT
	63	static inline int cpu_is_mmp3(void)
	64	{
	65	return (((read_cpuid_id() >> 8) & 0xff) == 0x58) &&
	66	((mmp_chip_id & 0xffff) == 0x2128);
	67	}
	68
	69	static inline int cpu_is_mmp3_a0(void)
	70	{
	71	return (cpu_is_mmp3() &&
	72	((mmp_chip_id & 0x00ff0000) == 0x00a00000));
	73	}
	74
	75	static inline int cpu_is_mmp3_b0(void)
	76	{
	77	return (cpu_is_mmp3() &&
	78	((mmp_chip_id & 0x00ff0000) == 0x00b00000));
	79	}
	80
	81	#else
	82	#define cpu_is_mmp3() (0)
	83	#define cpu_is_mmp3_a0() (0)
	84	#define cpu_is_mmp3_b0() (0)
	85	#endif
	86
	87	#endif /* __ASM_MACH_CPUTYPE_H */

include/linux/soc/qcom/irq.h+34−0

@@ -0,0 +1,34 @@
	1	/* SPDX-License-Identifier: GPL-2.0-only */
	2
	3	#ifndef __QCOM_IRQ_H
	4	#define __QCOM_IRQ_H
	5
	6	#include <linux/irqdomain.h>
	7
	8	#define GPIO_NO_WAKE_IRQ ~0U
	9
	10	/**
	11	* QCOM specific IRQ domain flags that distinguishes the handling of wakeup
	12	* capable interrupts by different interrupt controllers.
	13	*
	14	* IRQ_DOMAIN_FLAG_QCOM_PDC_WAKEUP: Line must be masked at TLMM and the
	15	* interrupt configuration is done at PDC
	16	* IRQ_DOMAIN_FLAG_QCOM_MPM_WAKEUP: Interrupt configuration is handled at TLMM
	17	*/
	18	#define IRQ_DOMAIN_FLAG_QCOM_PDC_WAKEUP (IRQ_DOMAIN_FLAG_NONCORE << 0)
	19	#define IRQ_DOMAIN_FLAG_QCOM_MPM_WAKEUP (IRQ_DOMAIN_FLAG_NONCORE << 1)
	20
	21	/**
	22	* irq_domain_qcom_handle_wakeup: Return if the domain handles interrupt
	23	* configuration
	24	* @d: irq domain
	25	*
	26	* This QCOM specific irq domain call returns if the interrupt controller
	27	* requires the interrupt be masked at the child interrupt controller.
	28	*/
	29	static inline bool irq_domain_qcom_handle_wakeup(const struct irq_domain *d)
	30	{
	31	return (d->flags & IRQ_DOMAIN_FLAG_QCOM_PDC_WAKEUP);
	32	}
	33
	34	#endif

include/linux/soc/qcom/llcc-qcom.h+20−74

@@ -38,33 +38,27 @@ struct llcc_slice_desc { · 37 unmodified lines
38	};	38	};
39		39
40	/**	40	/**
41	* llcc_slice_config - Data associated with the llcc slice	41	* llcc_edac_reg_data - llcc edac registers data for each error type
42	* @usecase_id: usecase id for which the llcc slice is used	42	* @name: Name of the error
43	* @slice_id: llcc slice id assigned to each slice	43	* @synd_reg: Syndrome register address
44	* @max_cap: maximum capacity of the llcc slice	44	* @count_status_reg: Status register address to read the error count
45	* @priority: priority of the llcc slice	45	* @ways_status_reg: Status register address to read the error ways
46	* @fixed_size: whether the llcc slice can grow beyond its size	46	* @reg_cnt: Number of registers
47	* @bonus_ways: bonus ways associated with llcc slice	47	* @count_mask: Mask value to get the error count
48	* @res_ways: reserved ways associated with llcc slice	48	* @ways_mask: Mask value to get the error ways
49	* @cache_mode: mode of the llcc slice	49	* @count_shift: Shift value to get the error count
50	* @probe_target_ways: Probe only reserved and bonus ways on a cache miss	50	* @ways_shift: Shift value to get the error ways
51	* @dis_cap_alloc: Disable capacity based allocation
52	* @retain_on_pc: Retain through power collapse
53	* @activate_on_init: activate the slice on init
54	*/	51	*/
55	struct llcc_slice_config {	52	struct llcc_edac_reg_data {
56	u32 usecase_id;	53	char *name;
57	u32 slice_id;	54	u64 synd_reg;
58	u32 max_cap;	55	u64 count_status_reg;
59	u32 priority;	56	u64 ways_status_reg;
60	bool fixed_size;	57	u32 reg_cnt;
61	u32 bonus_ways;	58	u32 count_mask;
62	u32 res_ways;	59	u32 ways_mask;
63	u32 cache_mode;	60	u8 count_shift;
64	u32 probe_target_ways;	61	u8 ways_shift;
65	bool dis_cap_alloc;
66	bool retain_on_pc;
67	bool activate_on_init;
68	};	62	};
69		63
70	/**	64	/**
@@ -93,30 +87,6 @@ struct llcc_drv_data { · 22 unmodified lines
93	int ecc_irq;	87	int ecc_irq;
94	};	88	};
95		89
96	/**
97	* llcc_edac_reg_data - llcc edac registers data for each error type
98	* @name: Name of the error
99	* @synd_reg: Syndrome register address
100	* @count_status_reg: Status register address to read the error count
101	* @ways_status_reg: Status register address to read the error ways
102	* @reg_cnt: Number of registers
103	* @count_mask: Mask value to get the error count
104	* @ways_mask: Mask value to get the error ways
105	* @count_shift: Shift value to get the error count
106	* @ways_shift: Shift value to get the error ways
107	*/
108	struct llcc_edac_reg_data {
109	char *name;
110	u64 synd_reg;
111	u64 count_status_reg;
112	u64 ways_status_reg;
113	u32 reg_cnt;
114	u32 count_mask;
115	u32 ways_mask;
116	u8 count_shift;
117	u8 ways_shift;
118	};
119
120	#if IS_ENABLED(CONFIG_QCOM_LLCC)	90	#if IS_ENABLED(CONFIG_QCOM_LLCC)
121	/**	91	/**
122	* llcc_slice_getd - get llcc slice descriptor	92	* llcc_slice_getd - get llcc slice descriptor
@@ -154,20 +124,6 @@ int llcc_slice_activate(struct llcc_slice_desc *desc); · 31 unmodified lines
154	*/	124	*/
155	int llcc_slice_deactivate(struct llcc_slice_desc *desc);	125	int llcc_slice_deactivate(struct llcc_slice_desc *desc);
156		126
157	/**
158	* qcom_llcc_probe - program the sct table
159	* @pdev: platform device pointer
160	* @table: soc sct table
161	* @sz: Size of the config table
162	*/
163	int qcom_llcc_probe(struct platform_device *pdev,
164	const struct llcc_slice_config *table, u32 sz);
165
166	/**
167	* qcom_llcc_remove - remove the sct table
168	* @pdev: Platform device pointer
169	*/
170	int qcom_llcc_remove(struct platform_device *pdev);
171	#else	127	#else
172	static inline struct llcc_slice_desc *llcc_slice_getd(u32 uid)	128	static inline struct llcc_slice_desc *llcc_slice_getd(u32 uid)
173	{	129	{
@@ -197,16 +153,6 @@ static inline int llcc_slice_deactivate(struct llcc_slice_desc *desc) · 23 unmodified lines
197	{	153	{
198	return -EINVAL;	154	return -EINVAL;
199	}	155	}
200	static inline int qcom_llcc_probe(struct platform_device *pdev,
201	const struct llcc_slice_config *table, u32 sz)
202	{
203	return -ENODEV;
204	}
205
206	static inline int qcom_llcc_remove(struct platform_device *pdev)
207	{
208	return -ENODEV;
209	}
210	#endif	156	#endif
211		157
212	#endif	158	#endif

include/linux/socket.h+16−4

 extern int __sys_sendmmsg(int fd, struct mmsghdr __user *mmsg,
 			  unsigned int vlen, unsigned int flags,
 			  bool forbid_cmsg_compat);
-extern long __sys_sendmsg_sock(struct socket *sock,
+extern long __sys_sendmsg_sock(struct socket *sock, struct msghdr *msg,
-			       struct user_msghdr __user *msg,
 			       unsigned int flags);
-extern long __sys_recvmsg_sock(struct socket *sock,
+extern long __sys_recvmsg_sock(struct socket *sock, struct msghdr *msg,
-			       struct user_msghdr __user *msg,
+			       struct user_msghdr __user *umsg,
+			       struct sockaddr __user *uaddr,
 			       unsigned int flags);
+extern int sendmsg_copy_msghdr(struct msghdr *msg,
+			       struct user_msghdr __user *umsg, unsigned flags,
+			       struct iovec **iov);
+extern int recvmsg_copy_msghdr(struct msghdr *msg,
+			       struct user_msghdr __user *umsg, unsigned flags,
+			       struct sockaddr __user **uaddr,
+			       struct iovec **iov);
 /* helpers which do the actual work for syscalls */
 extern int __sys_recvfrom(int fd, void __user *ubuf, size_t size,
 extern int __sys_sendto(int fd, void __user *buff, size_t len,
 			unsigned int flags, struct sockaddr __user *addr,
 			int addr_len);
+extern int __sys_accept4_file(struct file *file, unsigned file_flags,
+			struct sockaddr __user *upeer_sockaddr,
+			 int __user *upeer_addrlen, int flags);
 extern int __sys_accept4(int fd, struct sockaddr __user *upeer_sockaddr,
 			 int __user *upeer_addrlen, int flags);
 extern int __sys_socket(int family, int type, int protocol);
 extern int __sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen);
+extern int __sys_connect_file(struct file *file, struct sockaddr_storage *addr,
+			      int addrlen, int file_flags);
 extern int __sys_connect(int fd, struct sockaddr __user *uservaddr,
 			 int addrlen);
 extern int __sys_listen(int fd, int backlog);

include/linux/sort.h+4−4

@@ -5,12 +5,12 @@ · 4 unmodified lines
5	#include <linux/types.h>	5	#include <linux/types.h>
6		6
7	void sort_r(void *base, size_t num, size_t size,	7	void sort_r(void *base, size_t num, size_t size,
8	int (cmp)(const void , const void , const void ),	8	cmp_r_func_t cmp_func,
9	void (swap)(void , void *, int),	9	swap_func_t swap_func,
10	const void *priv);	10	const void *priv);
11		11
12	void sort(void *base, size_t num, size_t size,	12	void sort(void *base, size_t num, size_t size,
13	int (cmp)(const void , const void *),	13	cmp_func_t cmp_func,
14	void (swap)(void , void *, int));	14	swap_func_t swap_func);
15		15
16	#endif	16	#endif

include/linux/soundwire/sdw.h+3−4

 #define SDW_VALID_PORT_RANGE(n)		((n) <= 14 && (n) >= 1)
-#define SDW_DAI_ID_RANGE_START		100
-#define SDW_DAI_ID_RANGE_END		200
 enum {
 	SDW_PORT_DIRN_SINK = 0,
 	SDW_PORT_DIRN_SOURCE,
  * SDW Slave Structures and APIs
  */
+#define SDW_IGNORED_UNIQUE_ID 0xFF
 /**
  * struct sdw_slave_id - Slave ID
  * @mfg_id: MIPI Manufacturer ID
 	__u16 mfg_id;
 	__u16 part_id;
 	__u8 class_id;
-	__u8 unique_id:4;
+	__u8 unique_id;
 	__u8 sdw_version:4;
 };

include/linux/spi/spi.h+116−16

 #include <linux/completion.h>
 #include <linux/scatterlist.h>
 #include <linux/gpio/consumer.h>
+#include <linux/ptp_clock_kernel.h>
 struct dma_chan;
 struct property_entry;
 #define SPI_STATISTICS_INCREMENT_FIELD(stats, field)	\
 	SPI_STATISTICS_ADD_TO_FIELD(stats, field, 1)
+/**
+ * struct spi_delay - SPI delay information
+ * @value: Value for the delay
+ * @unit: Unit for the delay
+ */
+struct spi_delay {
+#define SPI_DELAY_UNIT_USECS	0
+#define SPI_DELAY_UNIT_NSECS	1
+#define SPI_DELAY_UNIT_SCK	2
+	u16	value;
+	u8	unit;
+};
+extern int spi_delay_to_ns(struct spi_delay *_delay, struct spi_transfer *xfer);
+extern int spi_delay_exec(struct spi_delay *_delay, struct spi_transfer *xfer);
 /**
  * struct spi_device - Controller side proxy for an SPI slave device
  * @dev: Driver model representation of the device.
  *	the spi_master.
  * @cs_gpiod: gpio descriptor of the chipselect line (optional, NULL when
  *	not using a GPIO line)
- * @word_delay_usecs: microsecond delay to be inserted between consecutive
+ * @word_delay: delay to be inserted between consecutive
  *	words of a transfer
  *
  * @statistics: statistics for the spi_device
 	const char		*driver_override;
 	int			cs_gpio;	/* LEGACY: chip select gpio */
 	struct gpio_desc	*cs_gpiod;	/* chip select gpio desc */
-	uint8_t			word_delay_usecs; /* inter-word delay */
+	struct spi_delay	word_delay; /* inter-word delay */
 	/* the statistics */
 	struct spi_statistics	statistics;
  *	     controller has native support for memory like operations.
  * @unprepare_message: undo any work done by prepare_message().
  * @slave_abort: abort the ongoing transfer request on an SPI slave controller
+ * @cs_setup: delay to be introduced by the controller after CS is asserted
+ * @cs_hold: delay to be introduced by the controller before CS is deasserted
+ * @cs_inactive: delay to be introduced by the controller after CS is
+ *	deasserted. If @cs_change_delay is used from @spi_transfer, then the
+ *	two delays will be added up.
  * @cs_gpios: LEGACY: array of GPIO descs to use as chip select lines; one per
  *	CS number. Any individual value may be -ENOENT for CS lines that
  *	are not GPIOs (driven by the SPI controller itself). Use the cs_gpiods
  * @fw_translate_cs: If the boot firmware uses different numbering scheme
  *	what Linux expects, this optional hook can be used to translate
  *	between the two.
+ * @ptp_sts_supported: If the driver sets this to true, it must provide a
+ *	time snapshot in @spi_transfer->ptp_sts as close as possible to the
+ *	moment in time when @spi_transfer->ptp_sts_word_pre and
+ *	@spi_transfer->ptp_sts_word_post were transmitted.
+ *	If the driver does not set this, the SPI core takes the snapshot as
+ *	close to the driver hand-over as possible.
  *
  * Each SPI controller can communicate with one or more @spi_device
  * children.  These make a small bus, sharing MOSI, MISO and SCK signals
 	 * to configure specific CS timing through spi_set_cs_timing() after
 	 * spi_setup().
 	 */
-	void (*set_cs_timing)(struct spi_device *spi, u8 setup_clk_cycles,
+	int (*set_cs_timing)(struct spi_device *spi, struct spi_delay *setup,
-			      u8 hold_clk_cycles, u8 inactive_clk_cycles);
+			     struct spi_delay *hold, struct spi_delay *inactive);
 	/* bidirectional bulk transfers
 	 *
 	/* Optimized handlers for SPI memory-like operations. */
 	const struct spi_controller_mem_ops *mem_ops;
+	/* CS delays */
+	struct spi_delay	cs_setup;
+	struct spi_delay	cs_hold;
+	struct spi_delay	cs_inactive;
 	/* gpio chip select */
 	int			*cs_gpios;
 	struct gpio_desc	**cs_gpiods;
 	void			*dummy_tx;
 	int (*fw_translate_cs)(struct spi_controller *ctlr, unsigned cs);
+	/*
+	 * Driver sets this field to indicate it is able to snapshot SPI
+	 * transfers (needed e.g. for reading the time of POSIX clocks)
+	 */
+	bool			ptp_sts_supported;
+	/* Interrupt enable state during PTP system timestamping */
+	unsigned long		irq_flags;
 };
 static inline void *spi_controller_get_devdata(struct spi_controller *ctlr)
 extern void spi_finalize_current_message(struct spi_controller *ctlr);
 extern void spi_finalize_current_transfer(struct spi_controller *ctlr);
+/* Helper calls for driver to timestamp transfer */
+void spi_take_timestamp_pre(struct spi_controller *ctlr,
+			    struct spi_transfer *xfer,
+			    const void *tx, bool irqs_off);
+void spi_take_timestamp_post(struct spi_controller *ctlr,
+			     struct spi_transfer *xfer,
+			     const void *tx, bool irqs_off);
 /* the spi driver core manages memory for the spi_controller classdev */
 extern struct spi_controller *__spi_alloc_controller(struct device *host,
 						unsigned int size, bool slave);
  * @cs_change: affects chipselect after this transfer completes
  * @cs_change_delay: delay between cs deassert and assert when
  *      @cs_change is set and @spi_transfer is not the last in @spi_message
- * @cs_change_delay_unit: unit of cs_change_delay
+ * @delay: delay to be introduced after this transfer before
+ *	(optionally) changing the chipselect status, then starting
+ *	the next transfer or completing this @spi_message.
  * @delay_usecs: microseconds to delay after this transfer before
  *	(optionally) changing the chipselect status, then starting
  *	the next transfer or completing this @spi_message.
- * @word_delay_usecs: microseconds to inter word delay after each word size
+ * @word_delay: inter word delay to be introduced after each word size
- *	(set by bits_per_word) transmission.
- * @word_delay: clock cycles to inter word delay after each word size
  *	(set by bits_per_word) transmission.
  * @effective_speed_hz: the effective SCK-speed that was used to
  *      transfer this transfer. Set to 0 if the spi bus driver does
  * @transfer_list: transfers are sequenced through @spi_message.transfers
  * @tx_sg: Scatterlist for transmit, currently not for client use
  * @rx_sg: Scatterlist for receive, currently not for client use
+ * @ptp_sts_word_pre: The word (subject to bits_per_word semantics) offset
+ *	within @tx_buf for which the SPI device is requesting that the time
+ *	snapshot for this transfer begins. Upon completing the SPI transfer,
+ *	this value may have changed compared to what was requested, depending
+ *	on the available snapshotting resolution (DMA transfer,
+ *	@ptp_sts_supported is false, etc).
+ * @ptp_sts_word_post: See @ptp_sts_word_post. The two can be equal (meaning
+ *	that a single byte should be snapshotted).
+ *	If the core takes care of the timestamp (if @ptp_sts_supported is false
+ *	for this controller), it will set @ptp_sts_word_pre to 0, and
+ *	@ptp_sts_word_post to the length of the transfer. This is done
+ *	purposefully (instead of setting to spi_transfer->len - 1) to denote
+ *	that a transfer-level snapshot taken from within the driver may still
+ *	be of higher quality.
+ * @ptp_sts: Pointer to a memory location held by the SPI slave device where a
+ *	PTP system timestamp structure may lie. If drivers use PIO or their
+ *	hardware has some sort of assist for retrieving exact transfer timing,
+ *	they can (and should) assert @ptp_sts_supported and populate this
+ *	structure using the ptp_read_system_*ts helper functions.
+ *	The timestamp must represent the time at which the SPI slave device has
+ *	processed the word, i.e. the "pre" timestamp should be taken before
+ *	transmitting the "pre" word, and the "post" timestamp after receiving
+ *	transmit confirmation from the controller for the "post" word.
+ * @timestamped_pre: Set by the SPI controller driver to denote it has acted
+ *	upon the @ptp_sts request. Not set when the SPI core has taken care of
+ *	the task. SPI device drivers are free to print a warning if this comes
+ *	back unset and they need the better resolution.
+ * @timestamped_post: See above. The reason why both exist is that these
+ *	booleans are also used to keep state in the core SPI logic.
  *
  * SPI transfers always write the same number of bytes as they read.
  * Protocol drivers should always provide @rx_buf and/or @tx_buf.
 #define	SPI_NBITS_DUAL		0x02 /* 2bits transfer */
 #define	SPI_NBITS_QUAD		0x04 /* 4bits transfer */
 	u8		bits_per_word;
-	u8		word_delay_usecs;
 	u16		delay_usecs;
-	u16		cs_change_delay;
+	struct spi_delay	delay;
-	u8		cs_change_delay_unit;
+	struct spi_delay	cs_change_delay;
-#define SPI_DELAY_UNIT_USECS	0
+	struct spi_delay	word_delay;
-#define SPI_DELAY_UNIT_NSECS	1
-#define SPI_DELAY_UNIT_SCK	2
 	u32		speed_hz;
-	u16		word_delay;
 	u32		effective_speed_hz;
+	unsigned int	ptp_sts_word_pre;
+	unsigned int	ptp_sts_word_post;
+	struct ptp_system_timestamp *ptp_sts;
+	bool		timestamped_pre;
+	bool		timestamped_post;
 	struct list_head transfer_list;
 };
 	list_del(&t->transfer_list);
 }
+static inline int
+spi_transfer_delay_exec(struct spi_transfer *t)
+{
+	struct spi_delay d;
+	if (t->delay_usecs) {
+		d.value = t->delay_usecs;
+		d.unit = SPI_DELAY_UNIT_USECS;
+		return spi_delay_exec(&d, NULL);
+	}
+	return spi_delay_exec(&t->delay, t);
+}
 /**
  * spi_message_init_with_transfers - Initialize spi_message and append transfers
  * @m: spi_message to be initialized
 	kfree(m);
 }
-extern void spi_set_cs_timing(struct spi_device *spi, u8 setup, u8 hold, u8 inactive_dly);
+extern int spi_set_cs_timing(struct spi_device *spi,
+			     struct spi_delay *setup,
+			     struct spi_delay *hold,
+			     struct spi_delay *inactive);
 extern int spi_setup(struct spi_device *spi);
 extern int spi_async(struct spi_device *spi, struct spi_message *message);

include/linux/spinlock_api_smp.h+4−4

@@ -147,7 +147,7 @@ static inline void __raw_spin_lock(raw_spinlock_t *lock) · 146 unmodified lines
147		147
148	static inline void __raw_spin_unlock(raw_spinlock_t *lock)	148	static inline void __raw_spin_unlock(raw_spinlock_t *lock)
149	{	149	{
150	spin_release(&lock->dep_map, 1, _RET_IP_);	150	spin_release(&lock->dep_map, _RET_IP_);
151	do_raw_spin_unlock(lock);	151	do_raw_spin_unlock(lock);
152	preempt_enable();	152	preempt_enable();
153	}	153	}
@@ -155,7 +155,7 @@ static inline void __raw_spin_unlock(raw_spinlock_t *lock) · 1 unmodified line
155	static inline void __raw_spin_unlock_irqrestore(raw_spinlock_t *lock,	155	static inline void __raw_spin_unlock_irqrestore(raw_spinlock_t *lock,
156	unsigned long flags)	156	unsigned long flags)
157	{	157	{
158	spin_release(&lock->dep_map, 1, _RET_IP_);	158	spin_release(&lock->dep_map, _RET_IP_);
159	do_raw_spin_unlock(lock);	159	do_raw_spin_unlock(lock);
160	local_irq_restore(flags);	160	local_irq_restore(flags);
161	preempt_enable();	161	preempt_enable();
@@ -163,7 +163,7 @@ static inline void __raw_spin_unlock_irqrestore(raw_spinlock_t *lock, · 1 unmodified line
163		163
164	static inline void __raw_spin_unlock_irq(raw_spinlock_t *lock)	164	static inline void __raw_spin_unlock_irq(raw_spinlock_t *lock)
165	{	165	{
166	spin_release(&lock->dep_map, 1, _RET_IP_);	166	spin_release(&lock->dep_map, _RET_IP_);
167	do_raw_spin_unlock(lock);	167	do_raw_spin_unlock(lock);
168	local_irq_enable();	168	local_irq_enable();
169	preempt_enable();	169	preempt_enable();
@@ -171,7 +171,7 @@ static inline void __raw_spin_unlock_irq(raw_spinlock_t *lock) · 1 unmodified line
171		171
172	static inline void __raw_spin_unlock_bh(raw_spinlock_t *lock)	172	static inline void __raw_spin_unlock_bh(raw_spinlock_t *lock)
173	{	173	{
174	spin_release(&lock->dep_map, 1, _RET_IP_);	174	spin_release(&lock->dep_map, _RET_IP_);
175	do_raw_spin_unlock(lock);	175	do_raw_spin_unlock(lock);
176	__local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);	176	__local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);
177	}	177	}

include/linux/stat.h+2−1

 	 STATX_ATTR_IMMUTABLE |				\
 	 STATX_ATTR_APPEND |				\
 	 STATX_ATTR_NODUMP |				\
-	 STATX_ATTR_ENCRYPTED				\
+	 STATX_ATTR_ENCRYPTED |				\
+	 STATX_ATTR_VERITY				\
 	 )/* Attrs corresponding to FS_*_FL flags */
 	u64		ino;
 	dev_t		dev;

include/linux/stmmac.h+3−1

 #define __STMMAC_PLATFORM_DATA
 #include <linux/platform_device.h>
+#include <linux/phy.h>
 #define MTL_MAX_RX_QUEUES	8
 #define MTL_MAX_TX_QUEUES	8
 	int fixed_burst;
 	int mixed_burst;
 	bool aal;
+	bool eame;
 };
 #define AXI_BLEN	7
 	int bus_id;
 	int phy_addr;
 	int interface;
-	int phy_interface;
+	phy_interface_t phy_interface;
 	struct stmmac_mdio_bus_data *mdio_bus_data;
 	struct device_node *phy_node;
 	struct device_node *phylink_node;

include/linux/string.h+2−0

@@ -216,6 +216,8 @@ int bprintf(u32 bin_buf, size_t size, const char fmt, ...) __printf(3, 4); · 215 unmodified lines
216	extern ssize_t memory_read_from_buffer(void to, size_t count, loff_t ppos,	216	extern ssize_t memory_read_from_buffer(void to, size_t count, loff_t ppos,
217	const void *from, size_t available);	217	const void *from, size_t available);
218		218
		219	int ptr_to_hashval(const void ptr, unsigned long hashval_out);
		220
219	/**	221	/**
220	* strstarts - does @str start with @prefix?	222	* strstarts - does @str start with @prefix?
221	* @str: string to examine	223	* @str: string to examine

include/linux/sunrpc/auth.h+0−3

 #ifndef _LINUX_SUNRPC_AUTH_H
 #define _LINUX_SUNRPC_AUTH_H
-#ifdef __KERNEL__
 #include <linux/sunrpc/sched.h>
 #include <linux/sunrpc/msg_prot.h>
 #include <linux/sunrpc/xdr.h>
 	return NULL;
 }
-#endif /* __KERNEL__ */
 #endif /* _LINUX_SUNRPC_AUTH_H */

include/linux/sunrpc/auth_gss.h+0−2

 #ifndef _LINUX_SUNRPC_AUTH_GSS_H
 #define _LINUX_SUNRPC_AUTH_GSS_H
-#ifdef __KERNEL__
 #include <linux/refcount.h>
 #include <linux/sunrpc/auth.h>
 #include <linux/sunrpc/svc.h>
 	unsigned long		gc_upcall_timestamp;
 };
-#endif /* __KERNEL__ */
 #endif /* _LINUX_SUNRPC_AUTH_GSS_H */

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

 	const char *		p_name;		/* name of procedure */
 };
-#ifdef __KERNEL__
 struct rpc_create_args {
 	struct net		*net;
 	int			protocol;
 #define RPC_CLNT_CREATE_NO_IDLE_TIMEOUT	(1UL << 8)
 #define RPC_CLNT_CREATE_NO_RETRANS_TIMEOUT	(1UL << 9)
 #define RPC_CLNT_CREATE_SOFTERR		(1UL << 10)
+#define RPC_CLNT_CREATE_REUSEPORT	(1UL << 11)
 struct rpc_clnt *rpc_create(struct rpc_create_args *args);
 struct rpc_clnt	*rpc_bind_new_program(struct rpc_clnt *,
 		(task->tk_msg.rpc_proc->p_decode != NULL);
 }
-#endif /* __KERNEL__ */
 #endif /* _LINUX_SUNRPC_CLNT_H */

include/linux/sunrpc/gss_api.h+0−2

 #ifndef _LINUX_SUNRPC_GSS_API_H
 #define _LINUX_SUNRPC_GSS_API_H
-#ifdef __KERNEL__
 #include <linux/sunrpc/xdr.h>
 #include <linux/sunrpc/msg_prot.h>
 #include <linux/uio.h>
  * corresponding call to gss_mech_put. */
 void gss_mech_put(struct gss_api_mech *);
-#endif /* __KERNEL__ */
 #endif /* _LINUX_SUNRPC_GSS_API_H */

include/linux/sunrpc/gss_err.h+0−3

 #ifndef _LINUX_SUNRPC_GSS_ERR_H
 #define _LINUX_SUNRPC_GSS_ERR_H
-#ifdef __KERNEL__
 typedef unsigned int OM_uint32;
 /*
 /* XXXX This is a necessary evil until the spec is fixed */
 #define GSS_S_CRED_UNAVAIL GSS_S_FAILURE
-#endif /* __KERNEL__ */
 #endif /* __LINUX_SUNRPC_GSS_ERR_H */

include/linux/sunrpc/msg_prot.h+0−3

 #ifndef _LINUX_SUNRPC_MSGPROT_H_
 #define _LINUX_SUNRPC_MSGPROT_H_
-#ifdef __KERNEL__ /* user programs should get these from the rpc header files */
 #define RPC_VERSION 2
 /* size of an XDR encoding unit in bytes, i.e. 32bit */
 /* Assume INET6_ADDRSTRLEN will always be larger than INET_ADDRSTRLEN... */
 #define RPCBIND_MAXUADDRLEN	RPCBIND_MAXUADDR6LEN
-#endif /* __KERNEL__ */
 #endif /* _LINUX_SUNRPC_MSGPROT_H_ */

include/linux/sunrpc/rpc_pipe_fs.h+0−3

 #ifndef _LINUX_SUNRPC_RPC_PIPE_FS_H
 #define _LINUX_SUNRPC_RPC_PIPE_FS_H
-#ifdef __KERNEL__
 #include <linux/workqueue.h>
 struct rpc_pipe_dir_head {
 extern bool gssd_running(struct net *net);
 #endif
-#endif

include/linux/sunrpc/svcauth.h+0−4

 #ifndef _LINUX_SUNRPC_SVCAUTH_H_
 #define _LINUX_SUNRPC_SVCAUTH_H_
-#ifdef __KERNEL__
 #include <linux/string.h>
 #include <linux/sunrpc/msg_prot.h>
 #include <linux/sunrpc/cache.h>
 	return full_name_hash(NULL, buf, length) >> (32 - bits);
 }
-#endif /* __KERNEL__ */
 #endif /* _LINUX_SUNRPC_SVCAUTH_H_ */

include/linux/sunrpc/svcauth_gss.h+0−2

 #ifndef _LINUX_SUNRPC_SVCAUTH_GSS_H
 #define _LINUX_SUNRPC_SVCAUTH_GSS_H
-#ifdef __KERNEL__
 #include <linux/sched.h>
 #include <linux/sunrpc/types.h>
 #include <linux/sunrpc/xdr.h>
 int svcauth_gss_register_pseudoflavor(u32 pseudoflavor, char * name);
 u32 svcauth_gss_flavor(struct auth_domain *dom);
-#endif /* __KERNEL__ */
 #endif /* _LINUX_SUNRPC_SVCAUTH_GSS_H */

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

 #ifndef _SUNRPC_XDR_H_
 #define _SUNRPC_XDR_H_
-#ifdef __KERNEL__
 #include <linux/uio.h>
 #include <asm/byteorder.h>
 #include <asm/unaligned.h>
 		*array = be32_to_cpup(p);
 	return retval;
 }
-#endif /* __KERNEL__ */
 #endif /* _SUNRPC_XDR_H_ */

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

 #include <linux/sunrpc/xdr.h>
 #include <linux/sunrpc/msg_prot.h>
-#ifdef __KERNEL__
 #define RPC_MIN_SLOT_TABLE	(2U)
 #define RPC_DEF_SLOT_TABLE	(16U)
 #define RPC_MAX_SLOT_TABLE_LIMIT	(65536U)
 	unsigned int		min_reqs;	/* min number of slots */
 	unsigned int		num_reqs;	/* total slots */
 	unsigned long		state;		/* transport state */
-	unsigned char		resvport   : 1; /* use a reserved port */
+	unsigned char		resvport   : 1,	/* use a reserved port */
+				reuseport  : 1; /* reuse port on reconnect */
 	atomic_t		swapper;	/* we're swapping over this
 						   transport */
 	unsigned int		bind_index;	/* bind function index */
 }
 #endif
-#endif /* __KERNEL__*/
 #endif /* _LINUX_SUNRPC_XPRT_H */

include/linux/sunrpc/xprtsock.h+0−4

 #ifndef _LINUX_SUNRPC_XPRTSOCK_H
 #define _LINUX_SUNRPC_XPRTSOCK_H
-#ifdef __KERNEL__
 int		init_socket_xprt(void);
 void		cleanup_socket_xprt(void);
 #define XPRT_SOCK_WAKE_PENDING	(6)
 #define XPRT_SOCK_WAKE_DISCONNECT	(7)
-#endif /* __KERNEL__ */
 #endif /* _LINUX_SUNRPC_XPRTSOCK_H */

include/linux/swap.h+1−1

@@ -307,7 +307,7 @@ struct vma_swap_readahead { · 306 unmodified lines
307	};	307	};
308		308
309	/* linux/mm/workingset.c */	309	/* linux/mm/workingset.c */
310	void workingset_eviction(struct page page);	310	void workingset_eviction(struct page page, struct mem_cgroup *target_memcg);
311	void workingset_refault(struct page page, void shadow);	311	void workingset_refault(struct page page, void shadow);
312	void workingset_activation(struct page *page);	312	void workingset_activation(struct page *page);
313		313

include/linux/sxgbe_platform.h+3−1

 #ifndef __SXGBE_PLATFORM_H__
 #define __SXGBE_PLATFORM_H__
+#include <linux/phy.h>
 /* MDC Clock Selection define*/
 #define SXGBE_CSR_100_150M	0x0	/* MDC = clk_scr_i/62 */
 #define SXGBE_CSR_150_250M	0x1	/* MDC = clk_scr_i/102 */
 	char *phy_bus_name;
 	int bus_id;
 	int phy_addr;
-	int interface;
+	phy_interface_t interface;
 	struct sxgbe_mdio_bus_data *mdio_bus_data;
 	struct sxgbe_dma_cfg *dma_cfg;
 	int clk_csr;

include/linux/sys_soc.h+1−0

@@ -15,6 +15,7 @@ struct soc_device_attribute { · 14 unmodified lines
15	const char *serial_number;	15	const char *serial_number;
16	const char *soc_id;	16	const char *soc_id;
17	const void *data;	17	const void *data;
		18	const struct attribute_group *custom_attr_group;
18	};	19	};
19		20
20	/**	21	/**

include/linux/syscalls.h+8−11

 struct __sysctl_args;
 struct sysinfo;
 struct timespec;
-struct timeval;
+struct __kernel_old_timeval;
 struct __kernel_timex;
 struct timezone;
 struct tms;
 asmlinkage long sys_getcpu(unsigned __user *cpu, unsigned __user *node, struct getcpu_cache __user *cache);
 /* kernel/time.c */
-asmlinkage long sys_gettimeofday(struct timeval __user *tv,
+asmlinkage long sys_gettimeofday(struct __kernel_old_timeval __user *tv,
 				struct timezone __user *tz);
-asmlinkage long sys_settimeofday(struct timeval __user *tv,
+asmlinkage long sys_settimeofday(struct __kernel_old_timeval __user *tv,
 				struct timezone __user *tz);
 asmlinkage long sys_adjtimex(struct __kernel_timex __user *txc_p);
 asmlinkage long sys_adjtimex_time32(struct old_timex32 __user *txc_p);
 asmlinkage long sys_alarm(unsigned int seconds);
 asmlinkage long sys_getpgrp(void);
 asmlinkage long sys_pause(void);
-asmlinkage long sys_time(time_t __user *tloc);
+asmlinkage long sys_time(__kernel_old_time_t __user *tloc);
 asmlinkage long sys_time32(old_time32_t __user *tloc);
 #ifdef __ARCH_WANT_SYS_UTIME
 asmlinkage long sys_utime(char __user *filename,
 				struct utimbuf __user *times);
 asmlinkage long sys_utimes(char __user *filename,
-				struct timeval __user *utimes);
+				struct __kernel_old_timeval __user *utimes);
 asmlinkage long sys_futimesat(int dfd, const char __user *filename,
-			      struct timeval __user *utimes);
+			      struct __kernel_old_timeval __user *utimes);
 #endif
 asmlinkage long sys_futimesat_time32(unsigned int dfd,
 				     const char __user *filename,
 				struct linux_dirent __user *dirent,
 				unsigned int count);
 asmlinkage long sys_select(int n, fd_set __user *inp, fd_set __user *outp,
-			fd_set __user *exp, struct timeval __user *tvp);
+			fd_set __user *exp, struct __kernel_old_timeval __user *tvp);
 asmlinkage long sys_poll(struct pollfd __user *ufds, unsigned int nfds,
 				int timeout);
 asmlinkage long sys_epoll_wait(int epfd, struct epoll_event __user *events,
 asmlinkage long sys_fork(void);
 /* obsolete: kernel/time/time.c */
-asmlinkage long sys_stime(time_t __user *tptr);
+asmlinkage long sys_stime(__kernel_old_time_t __user *tptr);
 asmlinkage long sys_stime32(old_time32_t __user *tptr);
 /* obsolete: kernel/signal.c */
  * the ksys_xyzyyz() functions prototyped below.
  */
-int ksys_mount(const char __user *dev_name, const char __user *dir_name,
-	       const char __user *type, unsigned long flags, void __user *data);
 int ksys_umount(char __user *name, int flags);
-int ksys_dup(unsigned int fildes);
 int ksys_chroot(const char __user *filename);
 ssize_t ksys_write(unsigned int fd, const char __user *buf, size_t count);
 int ksys_chdir(const char __user *filename);

include/linux/sysctl.h+2−4

 	struct ctl_table_poll name = __CTL_TABLE_POLL_INITIALIZER(name)
 /* A sysctl table is an array of struct ctl_table: */
-struct ctl_table
+struct ctl_table {
-{
 	const char *procname;		/* Text ID for /proc/sys, or zero */
 	void *data;
 	int maxlen;
 /* struct ctl_table_header is used to maintain dynamic lists of
    struct ctl_table trees. */
-struct ctl_table_header
+struct ctl_table_header {
-{
 	union {
 		struct {
 			struct ctl_table *ctl_table;

include/linux/tcp.h+1−1

@@ -223,7 +223,7 @@ struct tcp_sock { · 222 unmodified lines
223	fastopen_connect:1, /* FASTOPEN_CONNECT sockopt */	223	fastopen_connect:1, /* FASTOPEN_CONNECT sockopt */
224	fastopen_no_cookie:1, /* Allow send/recv SYN+data without a cookie */	224	fastopen_no_cookie:1, /* Allow send/recv SYN+data without a cookie */
225	is_sack_reneg:1, /* in recovery from loss with SACK reneg? */	225	is_sack_reneg:1, /* in recovery from loss with SACK reneg? */
226	unused:2;	226	fastopen_client_fail:2; /* reason why fastopen failed */
227	u8 nonagle : 4,/* Disable Nagle algorithm? */	227	u8 nonagle : 4,/* Disable Nagle algorithm? */
228	thin_lto : 1,/* Use linear timeouts for thin streams */	228	thin_lto : 1,/* Use linear timeouts for thin streams */
229	recvmsg_inq : 1,/* Indicate # of bytes in queue upon recvmsg */	229	recvmsg_inq : 1,/* Indicate # of bytes in queue upon recvmsg */

include/linux/thermal.h+0−11

@@ -544,15 +544,4 @@ static inline void thermal_notify_framework(struct thermal_zone_device *tz, · 543 unmodified lines
544	{ }	544	{ }
545	#endif /* CONFIG_THERMAL */	545	#endif /* CONFIG_THERMAL */
546		546
547	#if defined(CONFIG_NET) && IS_ENABLED(CONFIG_THERMAL)
548	extern int thermal_generate_netlink_event(struct thermal_zone_device *tz,
549	enum events event);
550	#else
551	static inline int thermal_generate_netlink_event(struct thermal_zone_device *tz,
552	enum events event)
553	{
554	return 0;
555	}
556	#endif
557
558	#endif /* __THERMAL_H__ */	547	#endif /* __THERMAL_H__ */

include/linux/thread_info.h+2−0

 			__bad_copy_to();
 		return false;
 	}
+	if (WARN_ON_ONCE(bytes > INT_MAX))
+		return false;
 	check_object_size(addr, bytes, is_source);
 	return true;
 }

include/linux/tick.h+7−2

 	TICK_DEP_BIT_POSIX_TIMER	= 0,
 	TICK_DEP_BIT_PERF_EVENTS	= 1,
 	TICK_DEP_BIT_SCHED		= 2,
-	TICK_DEP_BIT_CLOCK_UNSTABLE	= 3
+	TICK_DEP_BIT_CLOCK_UNSTABLE	= 3,
+	TICK_DEP_BIT_RCU		= 4
 };
 #define TICK_DEP_MASK_NONE		0
 #define TICK_DEP_MASK_PERF_EVENTS	(1 << TICK_DEP_BIT_PERF_EVENTS)
 #define TICK_DEP_MASK_SCHED		(1 << TICK_DEP_BIT_SCHED)
 #define TICK_DEP_MASK_CLOCK_UNSTABLE	(1 << TICK_DEP_BIT_CLOCK_UNSTABLE)
+#define TICK_DEP_MASK_RCU		(1 << TICK_DEP_BIT_RCU)
 #ifdef CONFIG_NO_HZ_COMMON
 extern bool tick_nohz_enabled;
 static inline bool tick_nohz_full_enabled(void)
 {
-	if (!context_tracking_is_enabled())
+	if (!context_tracking_enabled())
 		return false;
 	return tick_nohz_full_running;
 static inline bool tick_nohz_full_cpu(int cpu) { return false; }
 static inline void tick_nohz_full_add_cpus_to(struct cpumask *mask) { }
+static inline void tick_nohz_dep_set_cpu(int cpu, enum tick_dep_bits bit) { }
+static inline void tick_nohz_dep_clear_cpu(int cpu, enum tick_dep_bits bit) { }
 static inline void tick_dep_set(enum tick_dep_bits bit) { }
 static inline void tick_dep_clear(enum tick_dep_bits bit) { }
 static inline void tick_dep_set_cpu(int cpu, enum tick_dep_bits bit) { }

include/linux/time.h+18−4

 extern u32 (*arch_gettimeoffset)(void);
 #endif
-struct itimerval;
+#ifdef CONFIG_POSIX_TIMERS
-extern int do_setitimer(int which, struct itimerval *value,
+extern void clear_itimer(void);
-			struct itimerval *ovalue);
+#else
-extern int do_getitimer(int which, struct itimerval *value);
+static inline void clear_itimer(void) {}
+#endif
 extern long do_utimes(int dfd, const char __user *filename, struct timespec64 *times, int flags);
  */
 #define time_after32(a, b)	((s32)((u32)(b) - (u32)(a)) < 0)
 #define time_before32(b, a)	time_after32(a, b)
+/**
+ * time_between32 - check if a 32-bit timestamp is within a given time range
+ * @t:	the time which may be within [l,h]
+ * @l:	the lower bound of the range
+ * @h:	the higher bound of the range
+ *
+ * time_before32(t, l, h) returns true if @l <= @t <= @h. All operands are
+ * treated as 32-bit integers.
+ *
+ * Equivalent to !(time_before32(@t, @l) || time_after32(@t, @h)).
+ */
+#define time_between32(t, l, h) ((u32)(h) - (u32)(l) >= (u32)(t) - (u32)(l))
 #endif

include/linux/time32.h+1−1

@@ -12,7 +12,7 @@ · 11 unmodified lines
12	#include <linux/time64.h>	12	#include <linux/time64.h>
13	#include <linux/timex.h>	13	#include <linux/timex.h>
14		14
15	#define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)	15	#define TIME_T_MAX (__kernel_old_time_t)((1UL << ((sizeof(__kernel_old_time_t) << 3) - 1)) - 1)
16		16
17	typedef s32 old_time32_t;	17	typedef s32 old_time32_t;
18		18

include/linux/tpm.h+233−18

@@ -21,6 +21,7 @@ · 20 unmodified lines
21	#include <linux/acpi.h>	21	#include <linux/acpi.h>
22	#include <linux/cdev.h>	22	#include <linux/cdev.h>
23	#include <linux/fs.h>	23	#include <linux/fs.h>
		24	#include <linux/highmem.h>
24	#include <crypto/hash_info.h>	25	#include <crypto/hash_info.h>
25		26
26	#define TPM_DIGEST_SIZE 20 /* Max TPM v1.2 PCR size */	27	#define TPM_DIGEST_SIZE 20 /* Max TPM v1.2 PCR size */
@@ -67,6 +68,8 @@ struct tpm_class_ops { · 40 unmodified lines
67	u8 (status) (struct tpm_chip chip);	68	u8 (status) (struct tpm_chip chip);
68	void (update_timeouts)(struct tpm_chip chip,	69	void (update_timeouts)(struct tpm_chip chip,
69	unsigned long *timeout_cap);	70	unsigned long *timeout_cap);
		71	void (update_durations)(struct tpm_chip chip,
		72	unsigned long *duration_cap);
70	int (go_idle)(struct tpm_chip chip);	73	int (go_idle)(struct tpm_chip chip);
71	int (cmd_ready)(struct tpm_chip chip);	74	int (cmd_ready)(struct tpm_chip chip);
72	int (request_locality)(struct tpm_chip chip, int loc);	75	int (request_locality)(struct tpm_chip chip, int loc);
@@ -161,6 +164,235 @@ struct tpm_chip { · 88 unmodified lines
161	int locality;	164	int locality;
162	};	165	};
163		166
		167	#define TPM_HEADER_SIZE 10
		168
		169	enum tpm2_const {
		170	TPM2_PLATFORM_PCR = 24,
		171	TPM2_PCR_SELECT_MIN = ((TPM2_PLATFORM_PCR + 7) / 8),
		172	};
		173
		174	enum tpm2_timeouts {
		175	TPM2_TIMEOUT_A = 750,
		176	TPM2_TIMEOUT_B = 2000,
		177	TPM2_TIMEOUT_C = 200,
		178	TPM2_TIMEOUT_D = 30,
		179	TPM2_DURATION_SHORT = 20,
		180	TPM2_DURATION_MEDIUM = 750,
		181	TPM2_DURATION_LONG = 2000,
		182	TPM2_DURATION_LONG_LONG = 300000,
		183	TPM2_DURATION_DEFAULT = 120000,
		184	};
		185
		186	enum tpm2_structures {
		187	TPM2_ST_NO_SESSIONS = 0x8001,
		188	TPM2_ST_SESSIONS = 0x8002,
		189	};
		190
		191	/* Indicates from what layer of the software stack the error comes from */
		192	#define TSS2_RC_LAYER_SHIFT 16
		193	#define TSS2_RESMGR_TPM_RC_LAYER (11 << TSS2_RC_LAYER_SHIFT)
		194
		195	enum tpm2_return_codes {
		196	TPM2_RC_SUCCESS = 0x0000,
		197	TPM2_RC_HASH = 0x0083, /* RC_FMT1 */
		198	TPM2_RC_HANDLE = 0x008B,
		199	TPM2_RC_INITIALIZE = 0x0100, /* RC_VER1 */
		200	TPM2_RC_FAILURE = 0x0101,
		201	TPM2_RC_DISABLED = 0x0120,
		202	TPM2_RC_COMMAND_CODE = 0x0143,
		203	TPM2_RC_TESTING = 0x090A, /* RC_WARN */
		204	TPM2_RC_REFERENCE_H0 = 0x0910,
		205	TPM2_RC_RETRY = 0x0922,
		206	};
		207
		208	enum tpm2_command_codes {
		209	TPM2_CC_FIRST = 0x011F,
		210	TPM2_CC_HIERARCHY_CONTROL = 0x0121,
		211	TPM2_CC_HIERARCHY_CHANGE_AUTH = 0x0129,
		212	TPM2_CC_CREATE_PRIMARY = 0x0131,
		213	TPM2_CC_SEQUENCE_COMPLETE = 0x013E,
		214	TPM2_CC_SELF_TEST = 0x0143,
		215	TPM2_CC_STARTUP = 0x0144,
		216	TPM2_CC_SHUTDOWN = 0x0145,
		217	TPM2_CC_NV_READ = 0x014E,
		218	TPM2_CC_CREATE = 0x0153,
		219	TPM2_CC_LOAD = 0x0157,
		220	TPM2_CC_SEQUENCE_UPDATE = 0x015C,
		221	TPM2_CC_UNSEAL = 0x015E,
		222	TPM2_CC_CONTEXT_LOAD = 0x0161,
		223	TPM2_CC_CONTEXT_SAVE = 0x0162,
		224	TPM2_CC_FLUSH_CONTEXT = 0x0165,
		225	TPM2_CC_VERIFY_SIGNATURE = 0x0177,
		226	TPM2_CC_GET_CAPABILITY = 0x017A,
		227	TPM2_CC_GET_RANDOM = 0x017B,
		228	TPM2_CC_PCR_READ = 0x017E,
		229	TPM2_CC_PCR_EXTEND = 0x0182,
		230	TPM2_CC_EVENT_SEQUENCE_COMPLETE = 0x0185,
		231	TPM2_CC_HASH_SEQUENCE_START = 0x0186,
		232	TPM2_CC_CREATE_LOADED = 0x0191,
		233	TPM2_CC_LAST = 0x0193, /* Spec 1.36 */
		234	};
		235
		236	enum tpm2_permanent_handles {
		237	TPM2_RS_PW = 0x40000009,
		238	};
		239
		240	enum tpm2_capabilities {
		241	TPM2_CAP_HANDLES = 1,
		242	TPM2_CAP_COMMANDS = 2,
		243	TPM2_CAP_PCRS = 5,
		244	TPM2_CAP_TPM_PROPERTIES = 6,
		245	};
		246
		247	enum tpm2_properties {
		248	TPM_PT_TOTAL_COMMANDS = 0x0129,
		249	};
		250
		251	enum tpm2_startup_types {
		252	TPM2_SU_CLEAR = 0x0000,
		253	TPM2_SU_STATE = 0x0001,
		254	};
		255
		256	enum tpm2_cc_attrs {
		257	TPM2_CC_ATTR_CHANDLES = 25,
		258	TPM2_CC_ATTR_RHANDLE = 28,
		259	};
		260
		261	#define TPM_VID_INTEL 0x8086
		262	#define TPM_VID_WINBOND 0x1050
		263	#define TPM_VID_STM 0x104A
		264
		265	enum tpm_chip_flags {
		266	TPM_CHIP_FLAG_TPM2 = BIT(1),
		267	TPM_CHIP_FLAG_IRQ = BIT(2),
		268	TPM_CHIP_FLAG_VIRTUAL = BIT(3),
		269	TPM_CHIP_FLAG_HAVE_TIMEOUTS = BIT(4),
		270	TPM_CHIP_FLAG_ALWAYS_POWERED = BIT(5),
		271	TPM_CHIP_FLAG_FIRMWARE_POWER_MANAGED = BIT(6),
		272	};
		273
		274	#define to_tpm_chip(d) container_of(d, struct tpm_chip, dev)
		275
		276	struct tpm_header {
		277	__be16 tag;
		278	__be32 length;
		279	union {
		280	__be32 ordinal;
		281	__be32 return_code;
		282	};
		283	} __packed;
		284
		285	/* A string buffer type for constructing TPM commands. This is based on the
		286	* ideas of string buffer code in security/keys/trusted.h but is heap based
		287	* in order to keep the stack usage minimal.
		288	*/
		289
		290	enum tpm_buf_flags {
		291	TPM_BUF_OVERFLOW = BIT(0),
		292	};
		293
		294	struct tpm_buf {
		295	unsigned int flags;
		296	u8 *data;
		297	};
		298
		299	enum tpm2_object_attributes {
		300	TPM2_OA_USER_WITH_AUTH = BIT(6),
		301	};
		302
		303	enum tpm2_session_attributes {
		304	TPM2_SA_CONTINUE_SESSION = BIT(0),
		305	};
		306
		307	struct tpm2_hash {
		308	unsigned int crypto_id;
		309	unsigned int tpm_id;
		310	};
		311
		312	static inline void tpm_buf_reset(struct tpm_buf *buf, u16 tag, u32 ordinal)
		313	{
		314	struct tpm_header head = (struct tpm_header )buf->data;
		315
		316	head->tag = cpu_to_be16(tag);
		317	head->length = cpu_to_be32(sizeof(*head));
		318	head->ordinal = cpu_to_be32(ordinal);
		319	}
		320
		321	static inline int tpm_buf_init(struct tpm_buf *buf, u16 tag, u32 ordinal)
		322	{
		323	buf->data = (u8 *)__get_free_page(GFP_KERNEL);
		324	if (!buf->data)
		325	return -ENOMEM;
		326
		327	buf->flags = 0;
		328	tpm_buf_reset(buf, tag, ordinal);
		329	return 0;
		330	}
		331
		332	static inline void tpm_buf_destroy(struct tpm_buf *buf)
		333	{
		334	free_page((unsigned long)buf->data);
		335	}
		336
		337	static inline u32 tpm_buf_length(struct tpm_buf *buf)
		338	{
		339	struct tpm_header head = (struct tpm_header )buf->data;
		340
		341	return be32_to_cpu(head->length);
		342	}
		343
		344	static inline u16 tpm_buf_tag(struct tpm_buf *buf)
		345	{
		346	struct tpm_header head = (struct tpm_header )buf->data;
		347
		348	return be16_to_cpu(head->tag);
		349	}
		350
		351	static inline void tpm_buf_append(struct tpm_buf *buf,
		352	const unsigned char *new_data,
		353	unsigned int new_len)
		354	{
		355	struct tpm_header head = (struct tpm_header )buf->data;
		356	u32 len = tpm_buf_length(buf);
		357
		358	/* Return silently if overflow has already happened. */
		359	if (buf->flags & TPM_BUF_OVERFLOW)
		360	return;
		361
		362	if ((len + new_len) > PAGE_SIZE) {
		363	WARN(1, "tpm_buf: overflow\n");
		364	buf->flags \|= TPM_BUF_OVERFLOW;
		365	return;
		366	}
		367
		368	memcpy(&buf->data[len], new_data, new_len);
		369	head->length = cpu_to_be32(len + new_len);
		370	}
		371
		372	static inline void tpm_buf_append_u8(struct tpm_buf *buf, const u8 value)
		373	{
		374	tpm_buf_append(buf, &value, 1);
		375	}
		376
		377	static inline void tpm_buf_append_u16(struct tpm_buf *buf, const u16 value)
		378	{
		379	__be16 value2 = cpu_to_be16(value);
		380
		381	tpm_buf_append(buf, (u8 *) &value2, 2);
		382	}
		383
		384	static inline void tpm_buf_append_u32(struct tpm_buf *buf, const u32 value)
		385	{
		386	__be32 value2 = cpu_to_be32(value);
		387
		388	tpm_buf_append(buf, (u8 *) &value2, 4);
		389	}
		390
		391	static inline u32 tpm2_rc_value(u32 rc)
		392	{
		393	return (rc & BIT(7)) ? rc & 0xff : rc;
		394	}
		395
164	#if defined(CONFIG_TCG_TPM) \|\| defined(CONFIG_TCG_TPM_MODULE)	396	#if defined(CONFIG_TCG_TPM) \|\| defined(CONFIG_TCG_TPM_MODULE)
165		397
166	extern int tpm_is_tpm2(struct tpm_chip *chip);	398	extern int tpm_is_tpm2(struct tpm_chip *chip);
@@ -170,13 +402,8 @@ extern int tpm_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, · 3 unmodified lines
170	struct tpm_digest *digests);	402	struct tpm_digest *digests);
171	extern int tpm_send(struct tpm_chip chip, void cmd, size_t buflen);	403	extern int tpm_send(struct tpm_chip chip, void cmd, size_t buflen);
172	extern int tpm_get_random(struct tpm_chip chip, u8 data, size_t max);	404	extern int tpm_get_random(struct tpm_chip chip, u8 data, size_t max);
173	extern int tpm_seal_trusted(struct tpm_chip *chip,
174	struct trusted_key_payload *payload,
175	struct trusted_key_options *options);
176	extern int tpm_unseal_trusted(struct tpm_chip *chip,
177	struct trusted_key_payload *payload,
178	struct trusted_key_options *options);
179	extern struct tpm_chip *tpm_default_chip(void);	405	extern struct tpm_chip *tpm_default_chip(void);
		406	void tpm2_flush_context(struct tpm_chip *chip, u32 handle);
180	#else	407	#else
181	static inline int tpm_is_tpm2(struct tpm_chip *chip)	408	static inline int tpm_is_tpm2(struct tpm_chip *chip)
182	{	409	{
@@ -204,18 +431,6 @@ static inline int tpm_get_random(struct tpm_chip chip, u8 data, size_t max) · 21 unmodified lines
204	return -ENODEV;	431	return -ENODEV;
205	}	432	}
206		433
207	static inline int tpm_seal_trusted(struct tpm_chip *chip,
208	struct trusted_key_payload *payload,
209	struct trusted_key_options *options)
210	{
211	return -ENODEV;
212	}
213	static inline int tpm_unseal_trusted(struct tpm_chip *chip,
214	struct trusted_key_payload *payload,
215	struct trusted_key_options *options)
216	{
217	return -ENODEV;
218	}
219	static inline struct tpm_chip *tpm_default_chip(void)	434	static inline struct tpm_chip *tpm_default_chip(void)
220	{	435	{
221	return NULL;	436	return NULL;

include/linux/trace.h+8−0

@@ -24,6 +24,14 @@ struct trace_export { · 23 unmodified lines
24	int register_ftrace_export(struct trace_export *export);	24	int register_ftrace_export(struct trace_export *export);
25	int unregister_ftrace_export(struct trace_export *export);	25	int unregister_ftrace_export(struct trace_export *export);
26		26
		27	struct trace_array;
		28
		29	void trace_printk_init_buffers(void);
		30	int trace_array_printk(struct trace_array *tr, unsigned long ip,
		31	const char *fmt, ...);
		32	void trace_array_put(struct trace_array *tr);
		33	struct trace_array trace_array_get_by_name(const char name);
		34	int trace_array_destroy(struct trace_array *tr);
27	#endif /* CONFIG_TRACING */	35	#endif /* CONFIG_TRACING */
28		36
29	#endif /* _LINUX_TRACE_H */	37	#endif /* _LINUX_TRACE_H */

include/linux/trace_events.h+7−1

@@ -45,6 +45,11 @@ const char trace_print_array_seq(struct trace_seq p, · 44 unmodified lines
45	const void *buf, int count,	45	const void *buf, int count,
46	size_t el_size);	46	size_t el_size);
47		47
		48	const char *
		49	trace_print_hex_dump_seq(struct trace_seq p, const char prefix_str,
		50	int prefix_type, int rowsize, int groupsize,
		51	const void *buf, size_t len, bool ascii);
		52
48	struct trace_iterator;	53	struct trace_iterator;
49	struct trace_event;	54	struct trace_event;
50		55
@@ -550,7 +555,8 @@ extern int trace_event_get_offsets(struct trace_event_call *call); · 499 unmodified lines
550		555
551	int ftrace_set_clr_event(struct trace_array tr, char buf, int set);	556	int ftrace_set_clr_event(struct trace_array tr, char buf, int set);
552	int trace_set_clr_event(const char system, const char event, int set);	557	int trace_set_clr_event(const char system, const char event, int set);
553		558	int trace_array_set_clr_event(struct trace_array tr, const char system,
		559	const char *event, bool enable);
554	/*	560	/*
555	* The double __builtin_constant_p is because gcc will give us an error	561	* The double __builtin_constant_p is because gcc will give us an error
556	* if we try to allocate the static variable to fmt if it is not a	562	* if we try to allocate the static variable to fmt if it is not a

include/linux/trace_seq.h+4−0

 extern void trace_seq_bitmask(struct trace_seq *s, const unsigned long *maskp,
 			     int nmaskbits);
+extern int trace_seq_hex_dump(struct trace_seq *s, const char *prefix_str,
+			      int prefix_type, int rowsize, int groupsize,
+			      const void *buf, size_t len, bool ascii);
 #else /* CONFIG_TRACING */
 static inline void trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
 {

include/linux/types.h+6−1

 #ifndef _TIME_T
 #define _TIME_T
-typedef __kernel_time_t		time_t;
+typedef __kernel_old_time_t	time_t;
 #endif
 #ifndef _CLOCK_T
 typedef void (*rcu_callback_t)(struct rcu_head *head);
 typedef void (*call_rcu_func_t)(struct rcu_head *head, rcu_callback_t func);
+typedef void (*swap_func_t)(void *a, void *b, int size);
+typedef int (*cmp_r_func_t)(const void *a, const void *b, const void *priv);
+typedef int (*cmp_func_t)(const void *a, const void *b);
 #endif /*  __ASSEMBLY__ */
 #endif /* _LINUX_TYPES_H */

include/linux/u64_stats_sync.h+47−4

@@ -40,8 +40,8 @@ · 39 unmodified lines
40	* spin_lock_bh(...) or other synchronization to get exclusive access	40	* spin_lock_bh(...) or other synchronization to get exclusive access
41	* ...	41	* ...
42	* u64_stats_update_begin(&stats->syncp);	42	* u64_stats_update_begin(&stats->syncp);
43	* stats->bytes64 += len; // non atomic operation	43	* u64_stats_add(&stats->bytes64, len); // non atomic operation
44	* stats->packets64++; // non atomic operation	44	* u64_stats_inc(&stats->packets64); // non atomic operation
45	* u64_stats_update_end(&stats->syncp);	45	* u64_stats_update_end(&stats->syncp);
46	*	46	*
47	* While a consumer (reader) should use following template to get consistent	47	* While a consumer (reader) should use following template to get consistent
@@ -52,8 +52,8 @@ · 4 unmodified lines
52	*	52	*
53	* do {	53	* do {
54	* start = u64_stats_fetch_begin(&stats->syncp);	54	* start = u64_stats_fetch_begin(&stats->syncp);
55	* tbytes = stats->bytes64; // non atomic operation	55	* tbytes = u64_stats_read(&stats->bytes64); // non atomic operation
56	* tpackets = stats->packets64; // non atomic operation	56	* tpackets = u64_stats_read(&stats->packets64); // non atomic operation
57	* } while (u64_stats_fetch_retry(&stats->syncp, start));	57	* } while (u64_stats_fetch_retry(&stats->syncp, start));
58	*	58	*
59	*	59	*
@@ -68,6 +68,49 @@ struct u64_stats_sync { · 8 unmodified lines
68	#endif	68	#endif
69	};	69	};
70		70
		71	#if BITS_PER_LONG == 64
		72	#include <asm/local64.h>
		73
		74	typedef struct {
		75	local64_t v;
		76	} u64_stats_t ;
		77
		78	static inline u64 u64_stats_read(const u64_stats_t *p)
		79	{
		80	return local64_read(&p->v);
		81	}
		82
		83	static inline void u64_stats_add(u64_stats_t *p, unsigned long val)
		84	{
		85	local64_add(val, &p->v);
		86	}
		87
		88	static inline void u64_stats_inc(u64_stats_t *p)
		89	{
		90	local64_inc(&p->v);
		91	}
		92
		93	#else
		94
		95	typedef struct {
		96	u64 v;
		97	} u64_stats_t;
		98
		99	static inline u64 u64_stats_read(const u64_stats_t *p)
		100	{
		101	return p->v;
		102	}
		103
		104	static inline void u64_stats_add(u64_stats_t *p, unsigned long val)
		105	{
		106	p->v += val;
		107	}
		108
		109	static inline void u64_stats_inc(u64_stats_t *p)
		110	{
		111	p->v++;
		112	}
		113	#endif
71		114
72	static inline void u64_stats_init(struct u64_stats_sync *syncp)	115	static inline void u64_stats_init(struct u64_stats_sync *syncp)
73	{	116	{

include/linux/uaccess.h+16−0

@@ -311,6 +311,7 @@ copy_struct_from_user(void dst, size_t ksize, const void __user src, · 310 unmodified lines
311	* happens, handle that and return -EFAULT.	311	* happens, handle that and return -EFAULT.
312	*/	312	*/
313	extern long probe_kernel_read(void dst, const void src, size_t size);	313	extern long probe_kernel_read(void dst, const void src, size_t size);
		314	extern long probe_kernel_read_strict(void dst, const void src, size_t size);
314	extern long __probe_kernel_read(void dst, const void src, size_t size);	315	extern long __probe_kernel_read(void dst, const void src, size_t size);
315		316
316	/*	317	/*
@@ -337,7 +338,22 @@ extern long __probe_user_read(void dst, const void __user src, size_t size); · 20 unmodified lines
337	extern long notrace probe_kernel_write(void dst, const void src, size_t size);	338	extern long notrace probe_kernel_write(void dst, const void src, size_t size);
338	extern long notrace __probe_kernel_write(void dst, const void src, size_t size);	339	extern long notrace __probe_kernel_write(void dst, const void src, size_t size);
339		340
		341	/*
		342	* probe_user_write(): safely attempt to write to a location in user space
		343	* @dst: address to write to
		344	* @src: pointer to the data that shall be written
		345	* @size: size of the data chunk
		346	*
		347	* Safely write to address @dst from the buffer at @src. If a kernel fault
		348	* happens, handle that and return -EFAULT.
		349	*/
		350	extern long notrace probe_user_write(void __user dst, const void src, size_t size);
		351	extern long notrace __probe_user_write(void __user dst, const void src, size_t size);
		352
340	extern long strncpy_from_unsafe(char dst, const void unsafe_addr, long count);	353	extern long strncpy_from_unsafe(char dst, const void unsafe_addr, long count);
		354	extern long strncpy_from_unsafe_strict(char dst, const void unsafe_addr,
		355	long count);
		356	extern long __strncpy_from_unsafe(char dst, const void unsafe_addr, long count);
341	extern long strncpy_from_unsafe_user(char dst, const void __user unsafe_addr,	357	extern long strncpy_from_unsafe_user(char dst, const void __user unsafe_addr,
342	long count);	358	long count);
343	extern long strnlen_unsafe_user(const void __user *unsafe_addr, long count);	359	extern long strnlen_unsafe_user(const void __user *unsafe_addr, long count);

include/linux/uio.h+2−2

@@ -45,8 +45,8 @@ struct iov_iter { · 44 unmodified lines
45	union {	45	union {
46	unsigned long nr_segs;	46	unsigned long nr_segs;
47	struct {	47	struct {
48	int idx;	48	unsigned int head;
49	int start_idx;	49	unsigned int start_head;
50	};	50	};
51	};	51	};
52	};	52	};

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

@@ -50,6 +50,9 @@ struct usb_role_switch usb_role_switch_get(struct device dev); · 49 unmodified lines
50	struct usb_role_switch fwnode_usb_role_switch_get(struct fwnode_handle node);	50	struct usb_role_switch fwnode_usb_role_switch_get(struct fwnode_handle node);
51	void usb_role_switch_put(struct usb_role_switch *sw);	51	void usb_role_switch_put(struct usb_role_switch *sw);
52		52
		53	struct usb_role_switch *
		54	usb_role_switch_find_by_fwnode(const struct fwnode_handle *fwnode);
		55
53	struct usb_role_switch *	56	struct usb_role_switch *
54	usb_role_switch_register(struct device *parent,	57	usb_role_switch_register(struct device *parent,
55	const struct usb_role_switch_desc *desc);	58	const struct usb_role_switch_desc *desc);

include/linux/usb/tcpm.h+0−41

@@ -46,45 +46,6 @@ enum tcpm_transmit_type { · 45 unmodified lines
46	TCPC_TX_BIST_MODE_2 = 7	46	TCPC_TX_BIST_MODE_2 = 7
47	};	47	};
48		48
49	/**
50	* struct tcpc_config - Port configuration
51	* @src_pdo: PDO parameters sent to port partner as response to
52	* PD_CTRL_GET_SOURCE_CAP message
53	* @nr_src_pdo: Number of entries in @src_pdo
54	* @snk_pdo: PDO parameters sent to partner as response to
55	* PD_CTRL_GET_SINK_CAP message
56	* @nr_snk_pdo: Number of entries in @snk_pdo
57	* @operating_snk_mw:
58	* Required operating sink power in mW
59	* @type: Port type (TYPEC_PORT_DFP, TYPEC_PORT_UFP, or
60	* TYPEC_PORT_DRP)
61	* @default_role:
62	* Default port role (TYPEC_SINK or TYPEC_SOURCE).
63	* Set to TYPEC_NO_PREFERRED_ROLE if no default role.
64	* @try_role_hw:True if try.{Src,Snk} is implemented in hardware
65	* @alt_modes: List of supported alternate modes
66	*/
67	struct tcpc_config {
68	const u32 *src_pdo;
69	unsigned int nr_src_pdo;
70
71	const u32 *snk_pdo;
72	unsigned int nr_snk_pdo;
73
74	const u32 *snk_vdo;
75	unsigned int nr_snk_vdo;
76
77	unsigned int operating_snk_mw;
78
79	enum typec_port_type type;
80	enum typec_port_data data;
81	enum typec_role default_role;
82	bool try_role_hw; /* try.{src,snk} implemented in hardware */
83	bool self_powered; /* port belongs to a self powered device */
84
85	const struct typec_altmode_desc *alt_modes;
86	};
87
88	/* Mux state attributes */	49	/* Mux state attributes */
89	#define TCPC_MUX_USB_ENABLED BIT(0) /* USB enabled */	50	#define TCPC_MUX_USB_ENABLED BIT(0) /* USB enabled */
90	#define TCPC_MUX_DP_ENABLED BIT(1) /* DP enabled */	51	#define TCPC_MUX_DP_ENABLED BIT(1) /* DP enabled */
@@ -92,7 +53,6 @@ struct tcpc_config { · 1 unmodified line
92		53
93	/**	54	/**
94	* struct tcpc_dev - Port configuration and callback functions	55	* struct tcpc_dev - Port configuration and callback functions
95	* @config: Pointer to port configuration
96	* @fwnode: Pointer to port fwnode	56	* @fwnode: Pointer to port fwnode
97	* @get_vbus: Called to read current VBUS state	57	* @get_vbus: Called to read current VBUS state
98	* @get_current_limit:	58	* @get_current_limit:
@@ -121,7 +81,6 @@ struct tcpc_config { · 22 unmodified lines
121	* @mux: Pointer to multiplexer data	81	* @mux: Pointer to multiplexer data
122	*/	82	*/
123	struct tcpc_dev {	83	struct tcpc_dev {
124	const struct tcpc_config *config;
125	struct fwnode_handle *fwnode;	84	struct fwnode_handle *fwnode;
126		85
127	int (init)(struct tcpc_dev dev);	86	int (init)(struct tcpc_dev dev);

include/linux/usb/typec.h+23−18

 	struct usb_pd_identity	*identity;
 };
+/**
+ * struct typec_operations - USB Type-C Port Operations
+ * @try_role: Set data role preference for DRP port
+ * @dr_set: Set Data Role
+ * @pr_set: Set Power Role
+ * @vconn_set: Source VCONN
+ * @port_type_set: Set port type
+ */
+struct typec_operations {
+	int (*try_role)(struct typec_port *port, int role);
+	int (*dr_set)(struct typec_port *port, enum typec_data_role role);
+	int (*pr_set)(struct typec_port *port, enum typec_role role);
+	int (*vconn_set)(struct typec_port *port, enum typec_role role);
+	int (*port_type_set)(struct typec_port *port,
+			     enum typec_port_type type);
+};
 /*
  * struct typec_capability - USB Type-C Port Capabilities
  * @type: Supported power role of the port
  * @sw: Cable plug orientation switch
  * @mux: Multiplexer switch for Alternate/Accessory Modes
  * @fwnode: Optional fwnode of the port
- * @try_role: Set data role preference for DRP port
+ * @driver_data: Private pointer for driver specific info
- * @dr_set: Set Data Role
+ * @ops: Port operations vector
- * @pr_set: Set Power Role
- * @vconn_set: Set VCONN Role
- * @port_type_set: Set port type
  *
  * Static capabilities of a single USB Type-C port.
  */
 	int			prefer_role;
 	enum typec_accessory	accessory[TYPEC_MAX_ACCESSORY];
-	struct typec_switch	*sw;
-	struct typec_mux	*mux;
 	struct fwnode_handle	*fwnode;
+	void			*driver_data;
-	int		(*try_role)(const struct typec_capability *,
+	const struct typec_operations	*ops;
-				    int role);
-	int		(*dr_set)(const struct typec_capability *,
-				  enum typec_data_role);
-	int		(*pr_set)(const struct typec_capability *,
-				  enum typec_role);
-	int		(*vconn_set)(const struct typec_capability *,
-				     enum typec_role);
-	int		(*port_type_set)(const struct typec_capability *,
-					 enum typec_port_type);
 };
 /* Specific to try_role(). Indicates the user want's to clear the preference. */
 enum typec_orientation typec_get_orientation(struct typec_port *port);
 int typec_set_mode(struct typec_port *port, int mode);
+void *typec_get_drvdata(struct typec_port *port);
 int typec_find_port_power_role(const char *name);
 int typec_find_power_role(const char *name);
 int typec_find_port_data_role(const char *name);

include/linux/virtio_vsock.h+3−15

 #include <net/sock.h>
 #include <net/af_vsock.h>
-#define VIRTIO_VSOCK_DEFAULT_MIN_BUF_SIZE	128
-#define VIRTIO_VSOCK_DEFAULT_BUF_SIZE		(1024 * 256)
-#define VIRTIO_VSOCK_DEFAULT_MAX_BUF_SIZE	(1024 * 256)
 #define VIRTIO_VSOCK_DEFAULT_RX_BUF_SIZE	(1024 * 4)
 #define VIRTIO_VSOCK_MAX_BUF_SIZE		0xFFFFFFFFUL
 #define VIRTIO_VSOCK_MAX_PKT_BUF_SIZE		(1024 * 64)
 struct virtio_vsock_sock {
 	struct vsock_sock *vsk;
-	/* Protected by lock_sock(sk_vsock(trans->vsk)) */
-	u32 buf_size;
-	u32 buf_size_min;
-	u32 buf_size_max;
 	spinlock_t tx_lock;
 	spinlock_t rx_lock;
 int virtio_transport_do_socket_init(struct vsock_sock *vsk,
 				 struct vsock_sock *psk);
-u64 virtio_transport_get_buffer_size(struct vsock_sock *vsk);
-u64 virtio_transport_get_min_buffer_size(struct vsock_sock *vsk);
-u64 virtio_transport_get_max_buffer_size(struct vsock_sock *vsk);
-void virtio_transport_set_buffer_size(struct vsock_sock *vsk, u64 val);
-void virtio_transport_set_min_buffer_size(struct vsock_sock *vsk, u64 val);
-void virtio_transport_set_max_buffer_size(struct vsock_sock *vs, u64 val);
 int
 virtio_transport_notify_poll_in(struct vsock_sock *vsk,
 				size_t target,
 	struct vsock_transport_send_notify_data *data);
 int virtio_transport_notify_send_post_enqueue(struct vsock_sock *vsk,
 	ssize_t written, struct vsock_transport_send_notify_data *data);
+void virtio_transport_notify_buffer_size(struct vsock_sock *vsk, u64 *val);
 u64 virtio_transport_stream_rcvhiwat(struct vsock_sock *vsk);
 bool virtio_transport_stream_is_active(struct vsock_sock *vsk);
 void virtio_transport_destruct(struct vsock_sock *vsk);
-void virtio_transport_recv_pkt(struct virtio_vsock_pkt *pkt);
+void virtio_transport_recv_pkt(struct virtio_transport *t,
+			       struct virtio_vsock_pkt *pkt);
 void virtio_transport_free_pkt(struct virtio_vsock_pkt *pkt);
 void virtio_transport_inc_tx_pkt(struct virtio_vsock_sock *vvs, struct virtio_vsock_pkt *pkt);
 u32 virtio_transport_get_credit(struct virtio_vsock_sock *vvs, u32 wanted);

include/linux/vm_sockets.h+0−15

@@ -1,15 +0,0 @@
1	/* SPDX-License-Identifier: GPL-2.0-only */
2	/*
3	* VMware vSockets Driver
4	*
5	* Copyright (C) 2007-2013 VMware, Inc. All rights reserved.
6	*/
7
8	#ifndef _VM_SOCKETS_H
9	#define _VM_SOCKETS_H
10
11	#include <uapi/linux/vm_sockets.h>
12
13	int vm_sockets_get_local_cid(void);
14
15	#endif /* _VM_SOCKETS_H */

include/linux/vmalloc.h+13−0

@@ -22,6 +22,18 @@ struct notifier_block; /* in notifier.h */ · 21 unmodified lines
22	#define VM_UNINITIALIZED 0x00000020 /* vm_struct is not fully initialized */	22	#define VM_UNINITIALIZED 0x00000020 /* vm_struct is not fully initialized */
23	#define VM_NO_GUARD 0x00000040 /* don't add guard page */	23	#define VM_NO_GUARD 0x00000040 /* don't add guard page */
24	#define VM_KASAN 0x00000080 /* has allocated kasan shadow memory */	24	#define VM_KASAN 0x00000080 /* has allocated kasan shadow memory */
		25
		26	/*
		27	* VM_KASAN is used slighly differently depending on CONFIG_KASAN_VMALLOC.
		28	*
		29	* If IS_ENABLED(CONFIG_KASAN_VMALLOC), VM_KASAN is set on a vm_struct after
		30	* shadow memory has been mapped. It's used to handle allocation errors so that
		31	* we don't try to poision shadow on free if it was never allocated.
		32	*
		33	* Otherwise, VM_KASAN is set for kasan_module_alloc() allocations and used to
		34	* determine which allocations need the module shadow freed.
		35	*/
		36
25	/*	37	/*
26	* Memory with VM_FLUSH_RESET_PERMS cannot be freed in an interrupt or with	38	* Memory with VM_FLUSH_RESET_PERMS cannot be freed in an interrupt or with
27	* vfree_atomic().	39	* vfree_atomic().
@@ -93,6 +105,7 @@ extern void *vzalloc(unsigned long size); · 65 unmodified lines
93	extern void *vmalloc_user(unsigned long size);	105	extern void *vmalloc_user(unsigned long size);
94	extern void *vmalloc_node(unsigned long size, int node);	106	extern void *vmalloc_node(unsigned long size, int node);
95	extern void *vzalloc_node(unsigned long size, int node);	107	extern void *vzalloc_node(unsigned long size, int node);
		108	extern void *vmalloc_user_node_flags(unsigned long size, int node, gfp_t flags);
96	extern void *vmalloc_exec(unsigned long size);	109	extern void *vmalloc_exec(unsigned long size);
97	extern void *vmalloc_32(unsigned long size);	110	extern void *vmalloc_32(unsigned long size);
98	extern void *vmalloc_32_user(unsigned long size);	111	extern void *vmalloc_32_user(unsigned long size);

include/linux/vmstat.h+50−0

@@ -31,6 +31,12 @@ struct reclaim_stat { · 30 unmodified lines
31	unsigned nr_unmap_fail;	31	unsigned nr_unmap_fail;
32	};	32	};
33		33
		34	enum writeback_stat_item {
		35	NR_DIRTY_THRESHOLD,
		36	NR_DIRTY_BG_THRESHOLD,
		37	NR_VM_WRITEBACK_STAT_ITEMS,
		38	};
		39
34	#ifdef CONFIG_VM_EVENT_COUNTERS	40	#ifdef CONFIG_VM_EVENT_COUNTERS
35	/*	41	/*
36	* Light weight per cpu counter implementation.	42	* Light weight per cpu counter implementation.
@@ -381,4 +387,48 @@ static inline void __mod_zone_freepage_state(struct zone *zone, int nr_pages, · 344 unmodified lines
381		387
382	extern const char * const vmstat_text[];	388	extern const char * const vmstat_text[];
383		389
		390	static inline const char *zone_stat_name(enum zone_stat_item item)
		391	{
		392	return vmstat_text[item];
		393	}
		394
		395	#ifdef CONFIG_NUMA
		396	static inline const char *numa_stat_name(enum numa_stat_item item)
		397	{
		398	return vmstat_text[NR_VM_ZONE_STAT_ITEMS +
		399	item];
		400	}
		401	#endif /* CONFIG_NUMA */
		402
		403	static inline const char *node_stat_name(enum node_stat_item item)
		404	{
		405	return vmstat_text[NR_VM_ZONE_STAT_ITEMS +
		406	NR_VM_NUMA_STAT_ITEMS +
		407	item];
		408	}
		409
		410	static inline const char *lru_list_name(enum lru_list lru)
		411	{
		412	return node_stat_name(NR_LRU_BASE + lru) + 3; // skip "nr_"
		413	}
		414
		415	static inline const char *writeback_stat_name(enum writeback_stat_item item)
		416	{
		417	return vmstat_text[NR_VM_ZONE_STAT_ITEMS +
		418	NR_VM_NUMA_STAT_ITEMS +
		419	NR_VM_NODE_STAT_ITEMS +
		420	item];
		421	}
		422
		423	#if defined(CONFIG_VM_EVENT_COUNTERS) \|\| defined(CONFIG_MEMCG)
		424	static inline const char *vm_event_name(enum vm_event_item item)
		425	{
		426	return vmstat_text[NR_VM_ZONE_STAT_ITEMS +
		427	NR_VM_NUMA_STAT_ITEMS +
		428	NR_VM_NODE_STAT_ITEMS +
		429	NR_VM_WRITEBACK_STAT_ITEMS +
		430	item];
		431	}
		432	#endif /* CONFIG_VM_EVENT_COUNTERS \|\| CONFIG_MEMCG */
		433
384	#endif /* _LINUX_VMSTAT_H */	434	#endif /* _LINUX_VMSTAT_H */

include/linux/vmw_vmci_api.h+2−0

 struct msghdr;
 typedef void (vmci_device_shutdown_fn) (void *device_registration,
 					void *user_data);
+typedef void (*vmci_vsock_cb) (bool is_host);
 int vmci_datagram_create_handle(u32 resource_id, u32 flags,
 				vmci_datagram_recv_cb recv_cb,
 int vmci_doorbell_notify(struct vmci_handle handle, u32 priv_flags);
 u32 vmci_get_context_id(void);
 bool vmci_is_context_owner(u32 context_id, kuid_t uid);
+int vmci_register_vsock_callback(vmci_vsock_cb callback);
 int vmci_event_subscribe(u32 event,
 			 vmci_event_cb callback, void *callback_data,

include/linux/vtime.h+30−29

@@ -11,11 +11,15 @@ · 10 unmodified lines
11	struct task_struct;	11	struct task_struct;
12		12
13	/*	13	/*
14	* vtime_accounting_cpu_enabled() definitions/declarations	14	* vtime_accounting_enabled_this_cpu() definitions/declarations
15	*/	15	*/
16	#if defined(CONFIG_VIRT_CPU_ACCOUNTING_NATIVE)	16	#if defined(CONFIG_VIRT_CPU_ACCOUNTING_NATIVE)
17	static inline bool vtime_accounting_cpu_enabled(void) { return true; }	17
		18	static inline bool vtime_accounting_enabled_this_cpu(void) { return true; }
		19	extern void vtime_task_switch(struct task_struct *prev);
		20
18	#elif defined(CONFIG_VIRT_CPU_ACCOUNTING_GEN)	21	#elif defined(CONFIG_VIRT_CPU_ACCOUNTING_GEN)
		22
19	/*	23	/*
20	* Checks if vtime is enabled on some CPU. Cputime readers want to be careful	24	* Checks if vtime is enabled on some CPU. Cputime readers want to be careful
21	* in that case and compute the tickless cputime.	25	* in that case and compute the tickless cputime.
@@ -24,46 +28,43 @@ static inline bool vtime_accounting_cpu_enabled(void) { return true; } · 2 unmodified lines
24	*/	28	*/
25	static inline bool vtime_accounting_enabled(void)	29	static inline bool vtime_accounting_enabled(void)
26	{	30	{
27	return context_tracking_is_enabled();	31	return context_tracking_enabled();
28	}	32	}
29		33
30	static inline bool vtime_accounting_cpu_enabled(void)	34	static inline bool vtime_accounting_enabled_cpu(int cpu)
31	{	35	{
32	if (vtime_accounting_enabled()) {	36	return context_tracking_enabled_cpu(cpu);
33	if (context_tracking_cpu_is_enabled())
34	return true;
35	}
36
37	return false;
38	}	37	}
39	#else /* !CONFIG_VIRT_CPU_ACCOUNTING */
40	static inline bool vtime_accounting_cpu_enabled(void) { return false; }
41	#endif
42		38
		39	static inline bool vtime_accounting_enabled_this_cpu(void)
		40	{
		41	return context_tracking_enabled_this_cpu();
		42	}
43		43
44	/*	44	extern void vtime_task_switch_generic(struct task_struct *prev);
45	* Common vtime APIs
46	*/
47	#ifdef CONFIG_VIRT_CPU_ACCOUNTING
48		45
49	#ifdef __ARCH_HAS_VTIME_TASK_SWITCH
50	extern void vtime_task_switch(struct task_struct *prev);
51	#else
52	extern void vtime_common_task_switch(struct task_struct *prev);
53	static inline void vtime_task_switch(struct task_struct *prev)	46	static inline void vtime_task_switch(struct task_struct *prev)
54	{	47	{
55	if (vtime_accounting_cpu_enabled())	48	if (vtime_accounting_enabled_this_cpu())
56	vtime_common_task_switch(prev);	49	vtime_task_switch_generic(prev);
57	}	50	}
58	#endif /* __ARCH_HAS_VTIME_TASK_SWITCH */
59
60	extern void vtime_account_system(struct task_struct *tsk);
61	extern void vtime_account_idle(struct task_struct *tsk);
62		51
63	#else /* !CONFIG_VIRT_CPU_ACCOUNTING */	52	#else /* !CONFIG_VIRT_CPU_ACCOUNTING */
64		53
		54	static inline bool vtime_accounting_enabled_cpu(int cpu) {return false; }
		55	static inline bool vtime_accounting_enabled_this_cpu(void) { return false; }
65	static inline void vtime_task_switch(struct task_struct *prev) { }	56	static inline void vtime_task_switch(struct task_struct *prev) { }
66	static inline void vtime_account_system(struct task_struct *tsk) { }	57
		58	#endif
		59
		60	/*
		61	* Common vtime APIs
		62	*/
		63	#ifdef CONFIG_VIRT_CPU_ACCOUNTING
		64	extern void vtime_account_kernel(struct task_struct *tsk);
		65	extern void vtime_account_idle(struct task_struct *tsk);
		66	#else /* !CONFIG_VIRT_CPU_ACCOUNTING */
		67	static inline void vtime_account_kernel(struct task_struct *tsk) { }
67	#endif /* !CONFIG_VIRT_CPU_ACCOUNTING */	68	#endif /* !CONFIG_VIRT_CPU_ACCOUNTING */
68		69
69	#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN	70	#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
@@ -86,7 +87,7 @@ extern void vtime_account_irq_enter(struct task_struct *tsk); · 16 unmodified lines
86	static inline void vtime_account_irq_exit(struct task_struct *tsk)	87	static inline void vtime_account_irq_exit(struct task_struct *tsk)
87	{	88	{
88	/* On hard\|softirq exit we always account to hard\|softirq cputime */	89	/* On hard\|softirq exit we always account to hard\|softirq cputime */
89	vtime_account_system(tsk);	90	vtime_account_kernel(tsk);
90	}	91	}
91	extern void vtime_flush(struct task_struct *tsk);	92	extern void vtime_flush(struct task_struct *tsk);
92	#else /* !CONFIG_VIRT_CPU_ACCOUNTING_NATIVE */	93	#else /* !CONFIG_VIRT_CPU_ACCOUNTING_NATIVE */

include/linux/w1.h+1−0

@@ -262,6 +262,7 @@ struct w1_family_ops { · 261 unmodified lines
262	* @family_entry: family linked list	262	* @family_entry: family linked list
263	* @fid: 8 bit family identifier	263	* @fid: 8 bit family identifier
264	* @fops: operations for this family	264	* @fops: operations for this family
		265	* @of_match_table: open firmware match table
265	* @refcnt: reference counter	266	* @refcnt: reference counter
266	*/	267	*/
267	struct w1_family {	268	struct w1_family {

include/linux/wait.h+7−4

 void __wake_up_locked_key(struct wait_queue_head *wq_head, unsigned int mode, void *key);
 void __wake_up_locked_key_bookmark(struct wait_queue_head *wq_head,
 		unsigned int mode, void *key, wait_queue_entry_t *bookmark);
-void __wake_up_sync_key(struct wait_queue_head *wq_head, unsigned int mode, int nr, void *key);
+void __wake_up_sync_key(struct wait_queue_head *wq_head, unsigned int mode, void *key);
+void __wake_up_locked_sync_key(struct wait_queue_head *wq_head, unsigned int mode, void *key);
 void __wake_up_locked(struct wait_queue_head *wq_head, unsigned int mode, int nr);
-void __wake_up_sync(struct wait_queue_head *wq_head, unsigned int mode, int nr);
+void __wake_up_sync(struct wait_queue_head *wq_head, unsigned int mode);
 #define wake_up(x)			__wake_up(x, TASK_NORMAL, 1, NULL)
 #define wake_up_nr(x, nr)		__wake_up(x, TASK_NORMAL, nr, NULL)
 #define wake_up_interruptible(x)	__wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
 #define wake_up_interruptible_nr(x, nr)	__wake_up(x, TASK_INTERRUPTIBLE, nr, NULL)
 #define wake_up_interruptible_all(x)	__wake_up(x, TASK_INTERRUPTIBLE, 0, NULL)
-#define wake_up_interruptible_sync(x)	__wake_up_sync((x), TASK_INTERRUPTIBLE, 1)
+#define wake_up_interruptible_sync(x)	__wake_up_sync((x), TASK_INTERRUPTIBLE)
 /*
  * Wakeup macros to be used to report events to the targets.
 #define wake_up_interruptible_poll(x, m)					\
 	__wake_up(x, TASK_INTERRUPTIBLE, 1, poll_to_key(m))
 #define wake_up_interruptible_sync_poll(x, m)					\
-	__wake_up_sync_key((x), TASK_INTERRUPTIBLE, 1, poll_to_key(m))
+	__wake_up_sync_key((x), TASK_INTERRUPTIBLE, poll_to_key(m))
+#define wake_up_interruptible_sync_poll_locked(x, m)				\
+	__wake_up_locked_sync_key((x), TASK_INTERRUPTIBLE, poll_to_key(m))
 #define ___wait_cond_timeout(condition)						\
 ({										\

include/linux/ww_mutex.h+1−1

@@ -182,7 +182,7 @@ static inline void ww_acquire_done(struct ww_acquire_ctx *ctx) · 181 unmodified lines
182	static inline void ww_acquire_fini(struct ww_acquire_ctx *ctx)	182	static inline void ww_acquire_fini(struct ww_acquire_ctx *ctx)
183	{	183	{
184	#ifdef CONFIG_DEBUG_MUTEXES	184	#ifdef CONFIG_DEBUG_MUTEXES
185	mutex_release(&ctx->dep_map, 0, _THIS_IP_);	185	mutex_release(&ctx->dep_map, _THIS_IP_);
186		186
187	DEBUG_LOCKS_WARN_ON(ctx->acquired);	187	DEBUG_LOCKS_WARN_ON(ctx->acquired);
188	if (!IS_ENABLED(CONFIG_PROVE_LOCKING))	188	if (!IS_ENABLED(CONFIG_PROVE_LOCKING))

Merge tag 'v5.5-rc4' into locking/kcsan, to resolve conflicts

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -157,8 +157,8 @@ void bpf_cgroup_storage_link(struct bpf_cgroup_storage *storage, · 156 unmodified lines
157	struct cgroup *cgroup,	157	struct cgroup *cgroup,
158	enum bpf_attach_type type);	158	enum bpf_attach_type type);
159	void bpf_cgroup_storage_unlink(struct bpf_cgroup_storage *storage);	159	void bpf_cgroup_storage_unlink(struct bpf_cgroup_storage *storage);
160	int bpf_cgroup_storage_assign(struct bpf_prog prog, struct bpf_map map);	160	int bpf_cgroup_storage_assign(struct bpf_prog_aux aux, struct bpf_map map);
161	void bpf_cgroup_storage_release(struct bpf_prog prog, struct bpf_map map);	161	void bpf_cgroup_storage_release(struct bpf_prog_aux aux, struct bpf_map map);
162		162
163	int bpf_percpu_cgroup_storage_copy(struct bpf_map map, void key, void *value);	163	int bpf_percpu_cgroup_storage_copy(struct bpf_map map, void key, void *value);
164	int bpf_percpu_cgroup_storage_update(struct bpf_map map, void key,	164	int bpf_percpu_cgroup_storage_update(struct bpf_map map, void key,
@@ -360,9 +360,9 @@ static inline int cgroup_bpf_prog_query(const union bpf_attr *attr, · 195 unmodified lines
360		360
361	static inline void bpf_cgroup_storage_set(	361	static inline void bpf_cgroup_storage_set(
362	struct bpf_cgroup_storage *storage[MAX_BPF_CGROUP_STORAGE_TYPE]) {}	362	struct bpf_cgroup_storage *storage[MAX_BPF_CGROUP_STORAGE_TYPE]) {}
363	static inline int bpf_cgroup_storage_assign(struct bpf_prog *prog,	363	static inline int bpf_cgroup_storage_assign(struct bpf_prog_aux *aux,
364	struct bpf_map *map) { return 0; }	364	struct bpf_map *map) { return 0; }
365	static inline void bpf_cgroup_storage_release(struct bpf_prog *prog,	365	static inline void bpf_cgroup_storage_release(struct bpf_prog_aux *aux,
366	struct bpf_map *map) {}	366	struct bpf_map *map) {}
367	static inline struct bpf_cgroup_storage *bpf_cgroup_storage_alloc(	367	static inline struct bpf_cgroup_storage *bpf_cgroup_storage_alloc(
368	struct bpf_prog *prog, enum bpf_cgroup_storage_type stype) { return NULL; }	368	struct bpf_prog *prog, enum bpf_cgroup_storage_type stype) { return NULL; }