lael-labs/linux

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/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+0−2

 struct blkcg_gq *blkg_lookup_create(struct blkcg *blkcg,
 				    struct request_queue *q);
 int blkcg_init_queue(struct request_queue *q);
-void blkcg_drain_queue(struct request_queue *q);
 void blkcg_exit_queue(struct request_queue *q);
 /* Blkio controller policy registration */
 static inline struct blkcg_gq *blk_queue_root_blkg(struct request_queue *q)
 { return NULL; }
 static inline int blkcg_init_queue(struct request_queue *q) { return 0; }
-static inline void blkcg_drain_queue(struct request_queue *q) { }
 static inline void blkcg_exit_queue(struct request_queue *q) { }
 static inline int blkcg_policy_register(struct blkcg_policy *pol) { return 0; }
 static inline void blkcg_policy_unregister(struct blkcg_policy *pol) { }

include/linux/blkdev.h+10−14

@@ -357,8 +357,7 @@ typedef int (report_zones_cb)(struct blk_zone zone, unsigned int idx, · 356 unmodified lines
357	#define BLK_ALL_ZONES ((unsigned int)-1)	357	#define BLK_ALL_ZONES ((unsigned int)-1)
358	int blkdev_report_zones(struct block_device *bdev, sector_t sector,	358	int blkdev_report_zones(struct block_device *bdev, sector_t sector,
359	unsigned int nr_zones, report_zones_cb cb, void *data);	359	unsigned int nr_zones, report_zones_cb cb, void *data);
360		360	unsigned int blkdev_nr_zones(struct gendisk *disk);
361	extern unsigned int blkdev_nr_zones(struct block_device *bdev);
362	extern int blkdev_zone_mgmt(struct block_device *bdev, enum req_opf op,	361	extern int blkdev_zone_mgmt(struct block_device *bdev, enum req_opf op,
363	sector_t sectors, sector_t nr_sectors,	362	sector_t sectors, sector_t nr_sectors,
364	gfp_t gfp_mask);	363	gfp_t gfp_mask);
@@ -371,12 +370,7 @@ extern int blkdev_zone_mgmt_ioctl(struct block_device *bdev, fmode_t mode, · 6 unmodified lines
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	}
@@ -504,9 +498,9 @@ struct request_queue { · 121 unmodified lines
504	/*	498	/*
505	* Zoned block device information for request dispatch control.	499	* Zoned block device information for request dispatch control.
506	* 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
507	* 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
508	* bits which indicates if a zone is conventional (bit clear) or	502	* bits which indicates if a zone is conventional (bit set) or
509	* 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
510	* 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
511	* request targeting the zone was dispatched. All three fields are	505	* request targeting the zone was dispatched. All three fields are
512	* 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).
@@ -519,7 +513,7 @@ struct request_queue { · 6 unmodified lines
519	* blk_mq_unfreeze_queue().	513	* blk_mq_unfreeze_queue().
520	*/	514	*/
521	unsigned int nr_zones;	515	unsigned int nr_zones;
522	unsigned long *seq_zones_bitmap;	516	unsigned long *conv_zones_bitmap;
523	unsigned long *seq_zones_wlock;	517	unsigned long *seq_zones_wlock;
524	#endif /* CONFIG_BLK_DEV_ZONED */	518	#endif /* CONFIG_BLK_DEV_ZONED */
525		519
@@ -724,9 +718,11 @@ static inline unsigned int blk_queue_zone_no(struct request_queue *q, · 198 unmodified lines
724	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,
725	sector_t sector)	719	sector_t sector)
726	{	720	{
727	if (!blk_queue_is_zoned(q) \|\| !q->seq_zones_bitmap)	721	if (!blk_queue_is_zoned(q))
728	return false;	722	return false;
729	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);
730	}	726	}
731	#else /* CONFIG_BLK_DEV_ZONED */	727	#else /* CONFIG_BLK_DEV_ZONED */
732	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)

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

include/linux/bpf.h+3−0

 	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];
 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);

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/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/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/cpuidle.h+1−1

 	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;

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/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.h+2−2

@@ -1666,11 +1666,11 @@ extern bool kill_device(struct device *dev); · 1665 unmodified lines
1666	#ifdef CONFIG_DEVTMPFS	1666	#ifdef CONFIG_DEVTMPFS
1667	extern int devtmpfs_create_node(struct device *dev);	1667	extern int devtmpfs_create_node(struct device *dev);
1668	extern int devtmpfs_delete_node(struct device *dev);	1668	extern int devtmpfs_delete_node(struct device *dev);
1669	extern int devtmpfs_mount(const char *mntdir);	1669	extern int devtmpfs_mount(void);
1670	#else	1670	#else
1671	static inline int devtmpfs_create_node(struct device *dev) { return 0; }	1671	static inline int devtmpfs_create_node(struct device *dev) { return 0; }
1672	static inline int devtmpfs_delete_node(struct device *dev) { return 0; }	1672	static inline int devtmpfs_delete_node(struct device *dev) { return 0; }
1673	static inline int devtmpfs_mount(const char *mountpoint) { return 0; }	1673	static inline int devtmpfs_mount(void) { return 0; }
1674	#endif	1674	#endif
1675		1675
1676	/* drivers/base/power/shutdown.c */	1676	/* drivers/base/power/shutdown.c */

include/linux/efi.h+5−5

@@ -824,7 +824,7 @@ typedef struct { · 823 unmodified lines
824	__aligned_u64 image_size;	824	__aligned_u64 image_size;
825	unsigned int image_code_type;	825	unsigned int image_code_type;
826	unsigned int image_data_type;	826	unsigned int image_data_type;
827	unsigned long unload;	827	u32 unload;
828	} efi_loaded_image_32_t;	828	} efi_loaded_image_32_t;
829		829
830	typedef struct {	830	typedef struct {
@@ -840,14 +840,14 @@ typedef struct { · 9 unmodified lines
840	__aligned_u64 image_size;	840	__aligned_u64 image_size;
841	unsigned int image_code_type;	841	unsigned int image_code_type;
842	unsigned int image_data_type;	842	unsigned int image_data_type;
843	unsigned long unload;	843	u64 unload;
844	} efi_loaded_image_64_t;	844	} efi_loaded_image_64_t;
845		845
846	typedef struct {	846	typedef struct {
847	u32 revision;	847	u32 revision;
848	void *parent_handle;	848	efi_handle_t parent_handle;
849	efi_system_table_t *system_table;	849	efi_system_table_t *system_table;
850	void *device_handle;	850	efi_handle_t device_handle;
851	void *file_path;	851	void *file_path;
852	void *reserved;	852	void *reserved;
853	u32 load_options_size;	853	u32 load_options_size;
@@ -856,7 +856,7 @@ typedef struct { · 2 unmodified lines
856	__aligned_u64 image_size;	856	__aligned_u64 image_size;
857	unsigned int image_code_type;	857	unsigned int image_code_type;
858	unsigned int image_data_type;	858	unsigned int image_data_type;
859	unsigned long unload;	859	efi_status_t (*unload)(efi_handle_t image_handle);
860	} efi_loaded_image_t;	860	} efi_loaded_image_t;
861		861
862		862

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/export.h+28−63

  * 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/filter.h+12−8

 #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_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 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)

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+2−1

 /*
  * 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

include/linux/ftrace.h+5−0

 				struct dyn_ftrace *rec,
 				unsigned long old_addr,
 				unsigned long new_addr);
+unsigned long ftrace_find_rec_direct(unsigned long ip);
 #else
 # define ftrace_direct_func_count 0
 static inline int register_ftrace_direct(unsigned long ip, unsigned long addr)
 {
 	return -ENODEV;
 }
+static inline unsigned long ftrace_find_rec_direct(unsigned long ip)
+{
+	return 0;
+}
 #endif /* CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS */
 #ifndef CONFIG_HAVE_DYNAMIC_FTRACE_WITH_DIRECT_CALLS

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/i2c.h+6−6

  *	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
 /* 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);
 #define i2c_add_driver(driver) \
 	i2c_register_driver(THIS_MODULE, driver)
+static inline bool i2c_client_has_driver(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 */
 extern void i2c_clients_command(struct i2c_adapter *adap,

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/jbd2.h+1−1

@@ -457,7 +457,7 @@ struct jbd2_revoke_table_s; · 456 unmodified lines
457	* @h_journal: Which journal handle belongs to - used iff h_reserved set.	457	* @h_journal: Which journal handle belongs to - used iff h_reserved set.
458	* @h_rsv_handle: Handle reserved for finishing the logical operation.	458	* @h_rsv_handle: Handle reserved for finishing the logical operation.
459	* @h_total_credits: Number of remaining buffers we are allowed to add to	459	* @h_total_credits: Number of remaining buffers we are allowed to add to
460	journal. These are dirty buffers and revoke descriptor blocks.	460	* journal. These are dirty buffers and revoke descriptor blocks.
461	* @h_revoke_credits: Number of remaining revoke records available for handle	461	* @h_revoke_credits: Number of remaining revoke records available for handle
462	* @h_ref: Reference count on this handle.	462	* @h_ref: Reference count on this handle.
463	* @h_err: Field for caller's use to track errors through large fs operations.	463	* @h_err: Field for caller's use to track errors through large fs operations.

include/linux/kasan.h+9−6

 #endif /* CONFIG_KASAN_SW_TAGS */
 #ifdef CONFIG_KASAN_VMALLOC
-int kasan_populate_vmalloc(unsigned long requested_size,
+int kasan_populate_vmalloc(unsigned long addr, unsigned long size);
-			   struct vm_struct *area);
+void kasan_poison_vmalloc(const void *start, unsigned long size);
-void kasan_poison_vmalloc(void *start, unsigned long size);
+void kasan_unpoison_vmalloc(const void *start, unsigned long size);
 void kasan_release_vmalloc(unsigned long start, unsigned long end,
 			   unsigned long free_region_start,
 			   unsigned long free_region_end);
 #else
-static inline int kasan_populate_vmalloc(unsigned long requested_size,
+static inline int kasan_populate_vmalloc(unsigned long start,
-					 struct vm_struct *area)
+					unsigned long size)
 {
 	return 0;
 }
-static inline void kasan_poison_vmalloc(void *start, unsigned long size) {}
+static inline void kasan_poison_vmalloc(const void *start, unsigned long size)
+{ }
+static inline void kasan_unpoison_vmalloc(const void *start, unsigned long size)
+{ }
 static inline void kasan_release_vmalloc(unsigned long start,
 					 unsigned long end,
 					 unsigned long free_region_start,

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−5

  * @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/kvm_host.h+1−1

@@ -149,7 +149,7 @@ static inline bool is_error_page(struct page *page) · 148 unmodified lines
149	#define KVM_REQUEST_ARCH_BASE 8	149	#define KVM_REQUEST_ARCH_BASE 8
150		150
151	#define KVM_ARCH_REQ_FLAGS(nr, flags) ({ \	151	#define KVM_ARCH_REQ_FLAGS(nr, flags) ({ \
152	BUILD_BUG_ON((unsigned)(nr) >= (FIELD_SIZEOF(struct kvm_vcpu, requests) * 8) - KVM_REQUEST_ARCH_BASE); \	152	BUILD_BUG_ON((unsigned)(nr) >= (sizeof_field(struct kvm_vcpu, requests) * 8) - KVM_REQUEST_ARCH_BASE); \
153	(unsigned)(((nr) + KVM_REQUEST_ARCH_BASE) \| (flags)); \	153	(unsigned)(((nr) + KVM_REQUEST_ARCH_BASE) \| (flags)); \
154	})	154	})
155	#define KVM_ARCH_REQ(nr) KVM_ARCH_REQ_FLAGS(nr, 0)	155	#define KVM_ARCH_REQ(nr) KVM_ARCH_REQ_FLAGS(nr, 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/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/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/miscdevice.h+1−0

@@ -33,6 +33,7 @@ · 32 unmodified lines
33	#define SGI_MMTIMER 153	33	#define SGI_MMTIMER 153
34	#define STORE_QUEUE_MINOR 155 /* unused */	34	#define STORE_QUEUE_MINOR 155 /* unused */
35	#define I2O_MINOR 166	35	#define I2O_MINOR 166
		36	#define AGPGART_MINOR 175
36	#define HWRNG_MINOR 183	37	#define HWRNG_MINOR 183
37	#define MICROCODE_MINOR 184	38	#define MICROCODE_MINOR 184
38	#define IRNET_MINOR 187	39	#define IRNET_MINOR 187

include/linux/mm.h+8−5

 int __pte_alloc(struct mm_struct *mm, pmd_t *pmd);
 int __pte_alloc_kernel(pmd_t *pmd);
+#if defined(CONFIG_MMU)
 /*
- * The following ifdef needed to get the 4level-fixup.h header to work.
+ * The following ifdef needed to get the 5level-fixup.h header to work.
- * Remove it when 4level-fixup.h has been removed.
+ * Remove it when 5level-fixup.h has been removed.
  */
-#if defined(CONFIG_MMU) && !defined(__ARCH_HAS_4LEVEL_HACK)
 #ifndef __ARCH_HAS_5LEVEL_HACK
 static inline p4d_t *p4d_alloc(struct mm_struct *mm, pgd_t *pgd,
 		unsigned long address)
 	return (unlikely(pud_none(*pud)) && __pmd_alloc(mm, pud, address))?
 		NULL: pmd_offset(pud, address);
 }
-#endif /* CONFIG_MMU && !__ARCH_HAS_4LEVEL_HACK */
+#endif /* CONFIG_MMU */
 #if USE_SPLIT_PTE_PTLOCKS
 #if ALLOC_SPLIT_PTLOCKS
 typedef int (*pte_fn_t)(pte_t *pte, unsigned long addr, void *data);
 extern int apply_to_page_range(struct mm_struct *mm, unsigned long address,
 			       unsigned long size, pte_fn_t fn, void *data);
+extern int apply_to_existing_page_range(struct mm_struct *mm,
+				   unsigned long address, unsigned long size,
+				   pte_fn_t fn, void *data);
 #ifdef CONFIG_PAGE_POISONING
 extern bool page_poisoning_enabled(void);

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/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/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/netdevice.h+6−1

  *			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
 	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;

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/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/phy.h+1−1

@@ -1000,7 +1000,7 @@ int phy_modify_paged_changed(struct phy_device *phydev, int page, u32 regnum, · 999 unmodified lines
1000	int phy_modify_paged(struct phy_device *phydev, int page, u32 regnum,	1000	int phy_modify_paged(struct phy_device *phydev, int page, u32 regnum,
1001	u16 mask, u16 set);	1001	u16 mask, u16 set);
1002		1002
1003	struct phy_device phy_device_create(struct mii_bus bus, int addr, int phy_id,	1003	struct phy_device phy_device_create(struct mii_bus bus, int addr, u32 phy_id,
1004	bool is_c45,	1004	bool is_c45,
1005	struct phy_c45_device_ids *c45_ids);	1005	struct phy_c45_device_ids *c45_ids);
1006	#if IS_ENABLED(CONFIG_PHYLIB)	1006	#if IS_ENABLED(CONFIG_PHYLIB)

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/pipe_fs_i.h+0−2

  *	@readers: number of current readers of this pipe
  *	@writers: number of current writers of this pipe
  *	@files: number of struct file referring this pipe (protected by ->i_lock)
- *	@waiting_writers: number of writers blocked waiting for room
  *	@r_counter: reader counter
  *	@w_counter: writer counter
  *	@fasync_readers: reader side fasync
 	unsigned int readers;
 	unsigned int writers;
 	unsigned int files;
-	unsigned int waiting_writers;
 	unsigned int r_counter;
 	unsigned int w_counter;
 	struct page *tmp_page;

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/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/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/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/qcom_scm.h+26−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,6 +80,7 @@ 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);

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_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/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/sched.h+8−0

 #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

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/skbuff.h+3−2

 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,

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/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+13−7

 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,
 			 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,
+extern int __sys_connect_file(struct file *file, struct sockaddr_storage *addr,
-			struct sockaddr __user *uservaddr, int addrlen,
+			      int addrlen, int file_flags);
-			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/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/syscalls.h+0−3

  * 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/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/time.h+13−0

@@ -97,4 +97,17 @@ static inline bool itimerspec64_valid(const struct itimerspec64 *its) · 96 unmodified lines
97	*/	97	*/
98	#define time_after32(a, b) ((s32)((u32)(b) - (u32)(a)) < 0)	98	#define time_after32(a, b) ((s32)((u32)(b) - (u32)(a)) < 0)
99	#define time_before32(b, a) time_after32(a, b)	99	#define time_before32(b, a) time_after32(a, b)
		100
		101	/**
		102	* time_between32 - check if a 32-bit timestamp is within a given time range
		103	* @t: the time which may be within [l,h]
		104	* @l: the lower bound of the range
		105	* @h: the higher bound of the range
		106	*
		107	* time_before32(t, l, h) returns true if @l <= @t <= @h. All operands are
		108	* treated as 32-bit integers.
		109	*
		110	* Equivalent to !(time_before32(@t, @l) \|\| time_after32(@t, @h)).
		111	*/
		112	#define time_between32(t, l, h) ((u32)(h) - (u32)(l) >= (u32)(t) - (u32)(l))
100	#endif	113	#endif

include/linux/tpm.h+1−0

@@ -403,6 +403,7 @@ extern int tpm_pcr_extend(struct tpm_chip *chip, u32 pcr_idx, · 402 unmodified lines
403	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);
404	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);
405	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);
406	#else	407	#else
407	static inline int tpm_is_tpm2(struct tpm_chip *chip)	408	static inline int tpm_is_tpm2(struct tpm_chip *chip)
408	{	409	{

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 */

@@ -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; }