lael-labs/linux

include/linux/bitmap.h+2−1

 }
 /**
- * bitmap_or_equal - Check whether the or of two bitnaps is equal to a third
+ * bitmap_or_equal - Check whether the or of two bitmaps is equal to a third
  * @src1:	Pointer to bitmap 1
  * @src2:	Pointer to bitmap 2 will be or'ed with bitmap 1
  * @src3:	Pointer to bitmap 3. Compare to the result of *@src1 | *@src2
+ * @nbits:	number of bits in each of these bitmaps
  *
  * Returns: True if (*@src1 | *@src2) == *@src3, false otherwise
  */

include/linux/bpf.h+2−2

@@ -656,11 +656,11 @@ void bpf_map_put_with_uref(struct bpf_map *map); · 655 unmodified lines
656	void bpf_map_put(struct bpf_map *map);	656	void bpf_map_put(struct bpf_map *map);
657	int bpf_map_charge_memlock(struct bpf_map *map, u32 pages);	657	int bpf_map_charge_memlock(struct bpf_map *map, u32 pages);
658	void bpf_map_uncharge_memlock(struct bpf_map *map, u32 pages);	658	void bpf_map_uncharge_memlock(struct bpf_map *map, u32 pages);
659	int bpf_map_charge_init(struct bpf_map_memory *mem, size_t size);	659	int bpf_map_charge_init(struct bpf_map_memory *mem, u64 size);
660	void bpf_map_charge_finish(struct bpf_map_memory *mem);	660	void bpf_map_charge_finish(struct bpf_map_memory *mem);
661	void bpf_map_charge_move(struct bpf_map_memory *dst,	661	void bpf_map_charge_move(struct bpf_map_memory *dst,
662	struct bpf_map_memory *src);	662	struct bpf_map_memory *src);
663	void *bpf_map_area_alloc(size_t size, int numa_node);	663	void *bpf_map_area_alloc(u64 size, int numa_node);
664	void bpf_map_area_free(void *base);	664	void bpf_map_area_free(void *base);
665	void bpf_map_init_from_attr(struct bpf_map map, union bpf_attr attr);	665	void bpf_map_init_from_attr(struct bpf_map map, union bpf_attr attr);
666		666

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

@@ -65,5 +65,6 @@ extern void can_rx_unregister(struct net net, struct net_device dev, · 64 unmodified lines
65	void *data);	65	void *data);
66		66
67	extern int can_send(struct sk_buff *skb, int loop);	67	extern int can_send(struct sk_buff *skb, int loop);
		68	void can_sock_destruct(struct sock *sk);
68		69
69	#endif /* !_CAN_CORE_H */	70	#endif /* !_CAN_CORE_H */

include/linux/compiler_attributes.h+17−0

@@ -40,6 +40,7 @@ · 39 unmodified lines
40	# define __GCC4_has_attribute___noclone__ 1	40	# define __GCC4_has_attribute___noclone__ 1
41	# define __GCC4_has_attribute___nonstring__ 0	41	# define __GCC4_has_attribute___nonstring__ 0
42	# define __GCC4_has_attribute___no_sanitize_address__ (__GNUC_MINOR__ >= 8)	42	# define __GCC4_has_attribute___no_sanitize_address__ (__GNUC_MINOR__ >= 8)
		43	# define __GCC4_has_attribute___fallthrough__ 0
43	#endif	44	#endif
44		45
45	/*	46	/*
@@ -185,6 +186,22 @@ · 139 unmodified lines
185	# define __noclone	186	# define __noclone
186	#endif	187	#endif
187		188
		189	/*
		190	* Add the pseudo keyword 'fallthrough' so case statement blocks
		191	* must end with any of these keywords:
		192	* break;
		193	* fallthrough;
		194	* goto <label>;
		195	* return [expression];
		196	*
		197	* gcc: https://gcc.gnu.org/onlinedocs/gcc/Statement-Attributes.html#Statement-Attributes
		198	*/
		199	#if __has_attribute(__fallthrough__)
		200	# define fallthrough __attribute__((__fallthrough__))
		201	#else
		202	# define fallthrough do {} while (0) /* fallthrough */
		203	#endif
		204
188	/*	205	/*
189	* Note the missing underscores.	206	* Note the missing underscores.
190	*	207	*

include/linux/cpu.h+7−23

@@ -59,6 +59,11 @@ extern ssize_t cpu_show_l1tf(struct device *dev, · 58 unmodified lines
59	struct device_attribute attr, char buf);	59	struct device_attribute attr, char buf);
60	extern ssize_t cpu_show_mds(struct device *dev,	60	extern ssize_t cpu_show_mds(struct device *dev,
61	struct device_attribute attr, char buf);	61	struct device_attribute attr, char buf);
		62	extern ssize_t cpu_show_tsx_async_abort(struct device *dev,
		63	struct device_attribute *attr,
		64	char *buf);
		65	extern ssize_t cpu_show_itlb_multihit(struct device *dev,
		66	struct device_attribute attr, char buf);
62		67
63	extern __printf(4, 5)	68	extern __printf(4, 5)
64	struct device cpu_device_create(struct device parent, void *drvdata,	69	struct device cpu_device_create(struct device parent, void *drvdata,
@@ -213,28 +218,7 @@ static inline int cpuhp_smt_enable(void) { return 0; } · 148 unmodified lines
213	static inline int cpuhp_smt_disable(enum cpuhp_smt_control ctrlval) { return 0; }	218	static inline int cpuhp_smt_disable(enum cpuhp_smt_control ctrlval) { return 0; }
214	#endif	219	#endif
215		220
216	/*	221	extern bool cpu_mitigations_off(void);
217	* These are used for a global "mitigations=" cmdline option for toggling	222	extern bool cpu_mitigations_auto_nosmt(void);
218	* optional CPU mitigations.
219	*/
220	enum cpu_mitigations {
221	CPU_MITIGATIONS_OFF,
222	CPU_MITIGATIONS_AUTO,
223	CPU_MITIGATIONS_AUTO_NOSMT,
224	};
225
226	extern enum cpu_mitigations cpu_mitigations;
227
228	/* mitigations=off */
229	static inline bool cpu_mitigations_off(void)
230	{
231	return cpu_mitigations == CPU_MITIGATIONS_OFF;
232	}
233
234	/* mitigations=auto,nosmt */
235	static inline bool cpu_mitigations_auto_nosmt(void)
236	{
237	return cpu_mitigations == CPU_MITIGATIONS_AUTO_NOSMT;
238	}
239		223
240	#endif /* _LINUX_CPU_H_ */	224	#endif /* _LINUX_CPU_H_ */

include/linux/cpufreq.h+5−2

 #include <linux/completion.h>
 #include <linux/kobject.h>
 #include <linux/notifier.h>
+#include <linux/pm_qos.h>
 #include <linux/spinlock.h>
 #include <linux/sysfs.h>
 	struct work_struct	update; /* if update_policy() needs to be
 					 * called, but you're in IRQ context */
-	struct dev_pm_qos_request *min_freq_req;
+	struct freq_constraints	constraints;
-	struct dev_pm_qos_request *max_freq_req;
+	struct freq_qos_request	*min_freq_req;
+	struct freq_qos_request	*max_freq_req;
 	struct cpufreq_frequency_table	*freq_table;
 	enum cpufreq_table_sorting freq_table_sorted;

include/linux/dynamic_debug.h+6−0

 	do { if (0) printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__); } while (0)
 #define dynamic_dev_dbg(dev, fmt, ...)					\
 	do { if (0) dev_printk(KERN_DEBUG, dev, fmt, ##__VA_ARGS__); } while (0)
+#define dynamic_hex_dump(prefix_str, prefix_type, rowsize,		\
+			 groupsize, buf, len, ascii)			\
+	do { if (0)							\
+		print_hex_dump(KERN_DEBUG, prefix_str, prefix_type,	\
+				rowsize, groupsize, buf, len, ascii);	\
+	} while (0)
 #endif
 #endif

include/linux/efi.h+16−2

 efi_status_t efi_get_memory_map(efi_system_table_t *sys_table_arg,
 				struct efi_boot_memmap *map);
+efi_status_t efi_low_alloc_above(efi_system_table_t *sys_table_arg,
+				 unsigned long size, unsigned long align,
+				 unsigned long *addr, unsigned long min);
+static inline
 efi_status_t efi_low_alloc(efi_system_table_t *sys_table_arg,
 			   unsigned long size, unsigned long align,
-			   unsigned long *addr);
+			   unsigned long *addr)
+{
+	/*
+	 * Don't allocate at 0x0. It will confuse code that
+	 * checks pointers against NULL. Skip the first 8
+	 * bytes so we start at a nice even number.
+	 */
+	return efi_low_alloc_above(sys_table_arg, size, align, addr, 0x8);
+}
 efi_status_t efi_high_alloc(efi_system_table_t *sys_table_arg,
 			    unsigned long size, unsigned long align,
 				 unsigned long image_size,
 				 unsigned long alloc_size,
 				 unsigned long preferred_addr,
-				 unsigned long alignment);
+				 unsigned long alignment,
+				 unsigned long min_addr);
 efi_status_t handle_cmdline_files(efi_system_table_t *sys_table_arg,
 				  efi_loaded_image_t *image,

include/linux/export.h+8−12

 #define THIS_MODULE ((struct module *)0)
 #endif
-#define NS_SEPARATOR "."
 #ifdef CONFIG_MODVERSIONS
 /* Mark the CRC weak since genksyms apparently decides not to
  * generate a checksums for some symbols */
  * absolute relocations that require runtime processing on relocatable
  * kernels.
  */
-#define __KSYMTAB_ENTRY_NS(sym, sec, ns)				\
+#define __KSYMTAB_ENTRY_NS(sym, sec)					\
 	__ADDRESSABLE(sym)						\
 	asm("	.section \"___ksymtab" sec "+" #sym "\", \"a\"	\n"	\
 	    "	.balign	4					\n"	\
-	    "__ksymtab_" #sym NS_SEPARATOR #ns ":		\n"	\
+	    "__ksymtab_" #sym ":				\n"	\
 	    "	.long	" #sym "- .				\n"	\
 	    "	.long	__kstrtab_" #sym "- .			\n"	\
-	    "	.long	__kstrtab_ns_" #sym "- .		\n"	\
+	    "	.long	__kstrtabns_" #sym "- .			\n"	\
 	    "	.previous					\n")
 #define __KSYMTAB_ENTRY(sym, sec)					\
 	int namespace_offset;
 };
 #else
-#define __KSYMTAB_ENTRY_NS(sym, sec, ns)				\
+#define __KSYMTAB_ENTRY_NS(sym, sec)					\
-	static const struct kernel_symbol __ksymtab_##sym##__##ns	\
+	static const struct kernel_symbol __ksymtab_##sym		\
-	asm("__ksymtab_" #sym NS_SEPARATOR #ns)				\
 	__attribute__((section("___ksymtab" sec "+" #sym), used))	\
 	__aligned(sizeof(void *))					\
-	= { (unsigned long)&sym, __kstrtab_##sym, __kstrtab_ns_##sym }
+	= { (unsigned long)&sym, __kstrtab_##sym, __kstrtabns_##sym }
 #define __KSYMTAB_ENTRY(sym, sec)					\
 	static const struct kernel_symbol __ksymtab_##sym		\
-	asm("__ksymtab_" #sym)						\
 	__attribute__((section("___ksymtab" sec "+" #sym), used))	\
 	__aligned(sizeof(void *))					\
 	= { (unsigned long)&sym, __kstrtab_##sym, NULL }
 /* 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 __kstrtab_ns_##sym[]				\
+	static const char __kstrtabns_##sym[]				\
 	__attribute__((section("__ksymtab_strings"), used, aligned(1)))	\
 	= #ns;								\
-	__KSYMTAB_ENTRY_NS(sym, sec, ns)
+	__KSYMTAB_ENTRY_NS(sym, sec)
 #define ___EXPORT_SYMBOL(sym, sec)					\
 	___export_symbol_common(sym, sec);				\

include/linux/filter.h+0−1

@@ -1099,7 +1099,6 @@ static inline void bpf_get_prog_name(const struct bpf_prog prog, char sym) · 1098 unmodified lines
1099		1099
1100	#endif /* CONFIG_BPF_JIT */	1100	#endif /* CONFIG_BPF_JIT */
1101		1101
1102	void bpf_prog_kallsyms_del_subprogs(struct bpf_prog *fp);
1103	void bpf_prog_kallsyms_del_all(struct bpf_prog *fp);	1102	void bpf_prog_kallsyms_del_all(struct bpf_prog *fp);
1104		1103
1105	#define BPF_ANC BIT(15)	1104	#define BPF_ANC BIT(15)

include/linux/gfp.h+23−0

@@ -325,6 +325,29 @@ static inline bool gfpflags_allow_blocking(const gfp_t gfp_flags) · 324 unmodified lines
325	return !!(gfp_flags & __GFP_DIRECT_RECLAIM);	325	return !!(gfp_flags & __GFP_DIRECT_RECLAIM);
326	}	326	}
327		327
		328	/**
		329	* gfpflags_normal_context - is gfp_flags a normal sleepable context?
		330	* @gfp_flags: gfp_flags to test
		331	*
		332	* Test whether @gfp_flags indicates that the allocation is from the
		333	* %current context and allowed to sleep.
		334	*
		335	* An allocation being allowed to block doesn't mean it owns the %current
		336	* context. When direct reclaim path tries to allocate memory, the
		337	* allocation context is nested inside whatever %current was doing at the
		338	* time of the original allocation. The nested allocation may be allowed
		339	* to block but modifying anything %current owns can corrupt the outer
		340	* context's expectations.
		341	*
		342	* %true result from this function indicates that the allocation context
		343	* can sleep and use anything that's associated with %current.
		344	*/
		345	static inline bool gfpflags_normal_context(const gfp_t gfp_flags)
		346	{
		347	return (gfp_flags & (__GFP_DIRECT_RECLAIM \| __GFP_MEMALLOC)) ==
		348	__GFP_DIRECT_RECLAIM;
		349	}
		350
328	#ifdef CONFIG_HIGHMEM	351	#ifdef CONFIG_HIGHMEM
329	#define OPT_ZONE_HIGHMEM ZONE_HIGHMEM	352	#define OPT_ZONE_HIGHMEM ZONE_HIGHMEM
330	#else	353	#else

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

@@ -201,6 +201,14 @@ struct gpio_irq_chip { · 200 unmodified lines
201	*/	201	*/
202	bool threaded;	202	bool threaded;
203		203
		204	/**
		205	* @init_hw: optional routine to initialize hardware before
		206	* an IRQ chip will be added. This is quite useful when
		207	* a particular driver wants to clear IRQ related registers
		208	* in order to avoid undesired events.
		209	*/
		210	int (init_hw)(struct gpio_chip chip);
		211
204	/**	212	/**
205	* @init_valid_mask: optional routine to initialize @valid_mask, to be	213	* @init_valid_mask: optional routine to initialize @valid_mask, to be
206	* used if not all GPIO lines are valid interrupts. Sometimes some	214	* used if not all GPIO lines are valid interrupts. Sometimes some

include/linux/hwmon.h+1−1

@@ -235,7 +235,7 @@ enum hwmon_power_attributes { · 234 unmodified lines
235	#define HWMON_P_LABEL BIT(hwmon_power_label)	235	#define HWMON_P_LABEL BIT(hwmon_power_label)
236	#define HWMON_P_ALARM BIT(hwmon_power_alarm)	236	#define HWMON_P_ALARM BIT(hwmon_power_alarm)
237	#define HWMON_P_CAP_ALARM BIT(hwmon_power_cap_alarm)	237	#define HWMON_P_CAP_ALARM BIT(hwmon_power_cap_alarm)
238	#define HWMON_P_MIN_ALARM BIT(hwmon_power_max_alarm)	238	#define HWMON_P_MIN_ALARM BIT(hwmon_power_min_alarm)
239	#define HWMON_P_MAX_ALARM BIT(hwmon_power_max_alarm)	239	#define HWMON_P_MAX_ALARM BIT(hwmon_power_max_alarm)
240	#define HWMON_P_LCRIT_ALARM BIT(hwmon_power_lcrit_alarm)	240	#define HWMON_P_LCRIT_ALARM BIT(hwmon_power_lcrit_alarm)
241	#define HWMON_P_CRIT_ALARM BIT(hwmon_power_crit_alarm)	241	#define HWMON_P_CRIT_ALARM BIT(hwmon_power_crit_alarm)

include/linux/idr.h+1−1

@@ -185,7 +185,7 @@ static inline void idr_preload_end(void) · 184 unmodified lines
185	* is convenient for a "not found" value.	185	* is convenient for a "not found" value.
186	*/	186	*/
187	#define idr_for_each_entry(idr, entry, id) \	187	#define idr_for_each_entry(idr, entry, id) \
188	for (id = 0; ((entry) = idr_get_next(idr, &(id))) != NULL; ++id)	188	for (id = 0; ((entry) = idr_get_next(idr, &(id))) != NULL; id += 1U)
189		189
190	/**	190	/**
191	* idr_for_each_entry_ul() - Iterate over an IDR's elements of a given type.	191	* idr_for_each_entry_ul() - Iterate over an IDR's elements of a given type.

include/linux/if_macvlan.h+0−1

@@ -29,7 +29,6 @@ struct macvlan_dev { · 28 unmodified lines
29	netdev_features_t set_features;	29	netdev_features_t set_features;
30	enum macvlan_mode mode;	30	enum macvlan_mode mode;
31	u16 flags;	31	u16 flags;
32	int nest_level;
33	unsigned int macaddr_count;	32	unsigned int macaddr_count;
34	#ifdef CONFIG_NET_POLL_CONTROLLER	33	#ifdef CONFIG_NET_POLL_CONTROLLER
35	struct netpoll *netpoll;	34	struct netpoll *netpoll;

include/linux/if_team.h+1−0

@@ -223,6 +223,7 @@ struct team { · 222 unmodified lines
223	atomic_t count_pending;	223	atomic_t count_pending;
224	struct delayed_work dw;	224	struct delayed_work dw;
225	} mcast_rejoin;	225	} mcast_rejoin;
		226	struct lock_class_key team_lock_key;
226	long mode_priv[TEAM_MODE_PRIV_LONGS];	227	long mode_priv[TEAM_MODE_PRIV_LONGS];
227	};	228	};
228		229

include/linux/if_vlan.h+0−11

 #ifdef CONFIG_NET_POLL_CONTROLLER
 	struct netpoll				*netpoll;
 #endif
-	unsigned int				nest_level;
 };
 static inline struct vlan_dev_priv *vlan_dev_priv(const struct net_device *dev)
 extern bool vlan_uses_dev(const struct net_device *dev);
-static inline int vlan_get_encap_level(struct net_device *dev)
-{
-	BUG_ON(!is_vlan_dev(dev));
-	return vlan_dev_priv(dev)->nest_level;
-}
 #else
 static inline struct net_device *
 __vlan_find_dev_deep_rcu(struct net_device *real_dev,
 {
 	return false;
 }
-static inline int vlan_get_encap_level(struct net_device *dev)
-{
-	BUG();
-	return 0;
-}
 #endif
 /**

include/linux/intel-iommu.h+4−2

 #define QI_DEV_IOTLB_SID(sid)	((u64)((sid) & 0xffff) << 32)
 #define QI_DEV_IOTLB_QDEP(qdep)	(((qdep) & 0x1f) << 16)
 #define QI_DEV_IOTLB_ADDR(addr)	((u64)(addr) & VTD_PAGE_MASK)
-#define QI_DEV_IOTLB_PFSID(pfsid) (((u64)(pfsid & 0xf) << 12) | ((u64)(pfsid & 0xfff) << 52))
+#define QI_DEV_IOTLB_PFSID(pfsid) (((u64)(pfsid & 0xf) << 12) | \
+				   ((u64)((pfsid >> 4) & 0xfff) << 52))
 #define QI_DEV_IOTLB_SIZE	1
 #define QI_DEV_IOTLB_MAX_INVS	32
 #define QI_DEV_EIOTLB_PASID(p)	(((u64)p) << 32)
 #define QI_DEV_EIOTLB_SID(sid)	((u64)((sid) & 0xffff) << 16)
 #define QI_DEV_EIOTLB_QDEP(qd)	((u64)((qd) & 0x1f) << 4)
-#define QI_DEV_EIOTLB_PFSID(pfsid) (((u64)(pfsid & 0xf) << 12) | ((u64)(pfsid & 0xfff) << 52))
+#define QI_DEV_EIOTLB_PFSID(pfsid) (((u64)(pfsid & 0xf) << 12) | \
+				    ((u64)((pfsid >> 4) & 0xfff) << 52))
 #define QI_DEV_EIOTLB_MAX_INVS	32
 /* Page group response descriptor QW0 */

include/linux/kvm_host.h+7−0

 void kvm_vcpu_kick(struct kvm_vcpu *vcpu);
 bool kvm_is_reserved_pfn(kvm_pfn_t pfn);
+bool kvm_is_zone_device_pfn(kvm_pfn_t pfn);
 struct kvm_irq_ack_notifier {
 	struct hlist_node link;
 }
 #endif /* CONFIG_HAVE_KVM_VCPU_RUN_PID_CHANGE */
+typedef int (*kvm_vm_thread_fn_t)(struct kvm *kvm, uintptr_t data);
+int kvm_vm_create_worker_thread(struct kvm *kvm, kvm_vm_thread_fn_t thread_fn,
+				uintptr_t data, const char *name,
+				struct task_struct **thread_ptr);
 #endif

include/linux/leds.h+2−3

 /**
  * led_set_brightness_sync - set LED brightness synchronously
  * @led_cdev: the LED to set
- * @brightness: the brightness to set it to
+ * @value: the brightness to set it to
  *
  * Set an LED's brightness immediately. This function will block
  * the caller for the time required for accessing device registers,
 /**
  * led_compose_name - compose LED class device name
  * @dev: LED controller device object
- * @child: child fwnode_handle describing a LED or a group of synchronized LEDs;
+ * @init_data: the LED class device initialization data
- *	   it must be provided only for fwnode based LEDs
  * @led_classdev_name: composed LED class device name
  *
  * Create LED class device name basing on the provided init_data argument.

include/linux/memcontrol.h+29−0

 	return !cgroup_subsys_enabled(memory_cgrp_subsys);
 }
+static inline unsigned long mem_cgroup_protection(struct mem_cgroup *memcg,
+						  bool in_low_reclaim)
+{
+	if (mem_cgroup_disabled())
+		return 0;
+	if (in_low_reclaim)
+		return READ_ONCE(memcg->memory.emin);
+	return max(READ_ONCE(memcg->memory.emin),
+		   READ_ONCE(memcg->memory.elow));
+}
 enum mem_cgroup_protection mem_cgroup_protected(struct mem_cgroup *root,
 						struct mem_cgroup *memcg);
 unsigned long mem_cgroup_get_max(struct mem_cgroup *memcg);
+unsigned long mem_cgroup_size(struct mem_cgroup *memcg);
 void mem_cgroup_print_oom_context(struct mem_cgroup *memcg,
 				struct task_struct *p);
 {
 }
+static inline unsigned long mem_cgroup_protection(struct mem_cgroup *memcg,
+						  bool in_low_reclaim)
+{
+	return 0;
+}
 static inline enum mem_cgroup_protection mem_cgroup_protected(
 	struct mem_cgroup *root, struct mem_cgroup *memcg)
 {
 	return 0;
 }
+static inline unsigned long mem_cgroup_size(struct mem_cgroup *memcg)
+{
+	return 0;
+}
 static inline void
 mem_cgroup_print_oom_context(struct mem_cgroup *memcg, struct task_struct *p)
 {
 static inline void mem_cgroup_track_foreign_dirty(struct page *page,
 						  struct bdi_writeback *wb)
 {
+	if (mem_cgroup_disabled())
+		return;
 	if (unlikely(&page->mem_cgroup->css != wb->memcg_css))
 		mem_cgroup_track_foreign_dirty_slowpath(page, wb);
 }

include/linux/memory.h+1−0

@@ -119,6 +119,7 @@ extern struct memory_block find_memory_block(struct mem_section ); · 118 unmodified lines
119	typedef int (walk_memory_blocks_func_t)(struct memory_block , void *);	119	typedef int (walk_memory_blocks_func_t)(struct memory_block , void *);
120	extern int walk_memory_blocks(unsigned long start, unsigned long size,	120	extern int walk_memory_blocks(unsigned long start, unsigned long size,
121	void *arg, walk_memory_blocks_func_t func);	121	void *arg, walk_memory_blocks_func_t func);
		122	extern int for_each_memory_block(void *arg, walk_memory_blocks_func_t func);
122	#define CONFIG_MEM_BLOCK_SIZE (PAGES_PER_SECTION<<PAGE_SHIFT)	123	#define CONFIG_MEM_BLOCK_SIZE (PAGES_PER_SECTION<<PAGE_SHIFT)
123	#endif /* CONFIG_MEMORY_HOTPLUG_SPARSE */	124	#endif /* CONFIG_MEMORY_HOTPLUG_SPARSE */
124		125

include/linux/micrel_phy.h+1−1

@@ -31,7 +31,7 @@ · 30 unmodified lines
31	#define PHY_ID_KSZ886X 0x00221430	31	#define PHY_ID_KSZ886X 0x00221430
32	#define PHY_ID_KSZ8863 0x00221435	32	#define PHY_ID_KSZ8863 0x00221435
33		33
34	#define PHY_ID_KSZ8795 0x00221550	34	#define PHY_ID_KSZ87XX 0x00221550
35		35
36	#define PHY_ID_KSZ9477 0x00221631	36	#define PHY_ID_KSZ9477 0x00221631
37		37

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

@@ -1545,9 +1545,8 @@ struct mlx5_ifc_extended_dest_format_bits { · 1544 unmodified lines
1545	};	1545	};
1546		1546
1547	union mlx5_ifc_dest_format_struct_flow_counter_list_auto_bits {	1547	union mlx5_ifc_dest_format_struct_flow_counter_list_auto_bits {
1548	struct mlx5_ifc_dest_format_struct_bits dest_format_struct;	1548	struct mlx5_ifc_extended_dest_format_bits extended_dest_format;
1549	struct mlx5_ifc_flow_counter_list_bits flow_counter_list;	1549	struct mlx5_ifc_flow_counter_list_bits flow_counter_list;
1550	u8 reserved_at_0[0x40];
1551	};	1550	};
1552		1551
1553	struct mlx5_ifc_fte_match_param_bits {	1552	struct mlx5_ifc_fte_match_param_bits {

include/linux/mm.h+0−5

 extern void kvfree(const void *addr);
-static inline atomic_t *compound_mapcount_ptr(struct page *page)
-{
-	return &page[1].compound_mapcount;
-}
 static inline int compound_mapcount(struct page *page)
 {
 	VM_BUG_ON_PAGE(!PageCompound(page), page);

include/linux/mm_types.h+5−0

 #endif
 } _struct_page_alignment;
+static inline atomic_t *compound_mapcount_ptr(struct page *page)
+{
+	return &page[1].compound_mapcount;
+}
 /*
  * Used for sizing the vmemmap region on some architectures
  */

include/linux/netdevice.h+27−34

 struct devlink;
 struct tlsdev_ops;
 /*
  * This structure defines the management hooks for network devices.
  * The following hooks can be defined; unless noted otherwise, they are
 	void			(*ndo_dfwd_del_station)(struct net_device *pdev,
 							void *priv);
-	int			(*ndo_get_lock_subclass)(struct net_device *dev);
 	int			(*ndo_set_tx_maxrate)(struct net_device *dev,
 						      int queue_index,
 						      u32 maxrate);
  * 	@perm_addr:		Permanent hw address
  * 	@addr_assign_type:	Hw address assignment type
  * 	@addr_len:		Hardware address length
+ *	@upper_level:		Maximum depth level of upper devices.
+ *	@lower_level:		Maximum depth level of lower devices.
  *	@neigh_priv_len:	Used in neigh_alloc()
  * 	@dev_id:		Used to differentiate devices that share
  * 				the same link layer address
  *	@phydev:	Physical device may attach itself
  *			for hardware timestamping
  *	@sfp_bus:	attached &struct sfp_bus structure.
- *
+ *	@qdisc_tx_busylock_key: lockdep class annotating Qdisc->busylock
- *	@qdisc_tx_busylock: lockdep class annotating Qdisc->busylock spinlock
+				spinlock
- *	@qdisc_running_key: lockdep class annotating Qdisc->running seqcount
+ *	@qdisc_running_key:	lockdep class annotating Qdisc->running seqcount
+ *	@qdisc_xmit_lock_key:	lockdep class annotating
+ *				netdev_queue->_xmit_lock spinlock
+ *	@addr_list_lock_key:	lockdep class annotating
+ *				net_device->addr_list_lock spinlock
  *
  *	@proto_down:	protocol port state information can be sent to the
  *			switch driver and used to set the phys state of the
 	unsigned char		perm_addr[MAX_ADDR_LEN];
 	unsigned char		addr_assign_type;
 	unsigned char		addr_len;
+	unsigned char		upper_level;
+	unsigned char		lower_level;
 	unsigned short		neigh_priv_len;
 	unsigned short          dev_id;
 	unsigned short          dev_port;
 #endif
 	struct phy_device	*phydev;
 	struct sfp_bus		*sfp_bus;
-	struct lock_class_key	*qdisc_tx_busylock;
+	struct lock_class_key	qdisc_tx_busylock_key;
-	struct lock_class_key	*qdisc_running_key;
+	struct lock_class_key	qdisc_running_key;
+	struct lock_class_key	qdisc_xmit_lock_key;
+	struct lock_class_key	addr_list_lock_key;
 	bool			proto_down;
 	unsigned		wol_enabled:1;
 };
 		f(dev, &dev->_tx[i], arg);
 }
-#define netdev_lockdep_set_classes(dev)				\
-{								\
-	static struct lock_class_key qdisc_tx_busylock_key;	\
-	static struct lock_class_key qdisc_running_key;		\
-	static struct lock_class_key qdisc_xmit_lock_key;	\
-	static struct lock_class_key dev_addr_list_lock_key;	\
-	unsigned int i;						\
-								\
-	(dev)->qdisc_tx_busylock = &qdisc_tx_busylock_key;	\
-	(dev)->qdisc_running_key = &qdisc_running_key;		\
-	lockdep_set_class(&(dev)->addr_list_lock,		\
-			  &dev_addr_list_lock_key); 		\
-	for (i = 0; i < (dev)->num_tx_queues; i++)		\
-		lockdep_set_class(&(dev)->_tx[i]._xmit_lock,	\
-				  &qdisc_xmit_lock_key);	\
-}
 u16 netdev_pick_tx(struct net_device *dev, struct sk_buff *skb,
 		     struct net_device *sb_dev);
 struct netdev_queue *netdev_core_pick_tx(struct net_device *dev,
 }
 void netif_tx_stop_all_queues(struct net_device *dev);
+void netdev_update_lockdep_key(struct net_device *dev);
 static inline bool netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
 {
 	spin_lock(&dev->addr_list_lock);
 }
-static inline void netif_addr_lock_nested(struct net_device *dev)
-{
-	int subclass = SINGLE_DEPTH_NESTING;
-	if (dev->netdev_ops->ndo_get_lock_subclass)
-		subclass = dev->netdev_ops->ndo_get_lock_subclass(dev);
-	spin_lock_nested(&dev->addr_list_lock, subclass);
-}
 static inline void netif_addr_lock_bh(struct net_device *dev)
 {
 	spin_lock_bh(&dev->addr_list_lock);
 				 struct netlink_ext_ack *extack);
 void netdev_upper_dev_unlink(struct net_device *dev,
 			     struct net_device *upper_dev);
+int netdev_adjacent_change_prepare(struct net_device *old_dev,
+				   struct net_device *new_dev,
+				   struct net_device *dev,
+				   struct netlink_ext_ack *extack);
+void netdev_adjacent_change_commit(struct net_device *old_dev,
+				   struct net_device *new_dev,
+				   struct net_device *dev);
+void netdev_adjacent_change_abort(struct net_device *old_dev,
+				  struct net_device *new_dev,
+				  struct net_device *dev);
 void netdev_adjacent_rename_links(struct net_device *dev, char *oldname);
 void *netdev_lower_dev_get_private(struct net_device *dev,
 				   struct net_device *lower_dev);
 extern u8 netdev_rss_key[NETDEV_RSS_KEY_LEN] __read_mostly;
 void netdev_rss_key_fill(void *buffer, size_t len);
-int dev_get_nest_level(struct net_device *dev);
 int skb_checksum_help(struct sk_buff *skb);
 int skb_crc32c_csum_help(struct sk_buff *skb);
 int skb_csum_hwoffload_help(struct sk_buff *skb,

include/linux/page-flags.h+18−2

@@ -622,12 +622,28 @@ static inline int PageTransCompound(struct page *page) · 621 unmodified lines
622	*	622	*
623	* Unlike PageTransCompound, this is safe to be called only while	623	* Unlike PageTransCompound, this is safe to be called only while
624	* split_huge_pmd() cannot run from under us, like if protected by the	624	* split_huge_pmd() cannot run from under us, like if protected by the
625	* MMU notifier, otherwise it may result in page->_mapcount < 0 false	625	* MMU notifier, otherwise it may result in page->_mapcount check false
626	* positives.	626	* positives.
		627	*
		628	* We have to treat page cache THP differently since every subpage of it
		629	* would get _mapcount inc'ed once it is PMD mapped. But, it may be PTE
		630	* mapped in the current process so comparing subpage's _mapcount to
		631	* compound_mapcount to filter out PTE mapped case.
627	*/	632	*/
628	static inline int PageTransCompoundMap(struct page *page)	633	static inline int PageTransCompoundMap(struct page *page)
629	{	634	{
630	return PageTransCompound(page) && atomic_read(&page->_mapcount) < 0;	635	struct page *head;
		636
		637	if (!PageTransCompound(page))
		638	return 0;
		639
		640	if (PageAnon(page))
		641	return atomic_read(&page->_mapcount) < 0;
		642
		643	head = compound_head(page);
		644	/* File THP is PMD mapped and not PTE mapped */
		645	return atomic_read(&page->_mapcount) ==
		646	atomic_read(compound_mapcount_ptr(head));
631	}	647	}
632		648
633	/*	649	/*

include/linux/page_ext.h+9−1

 enum page_ext_flags {
 	PAGE_EXT_OWNER,
-	PAGE_EXT_OWNER_ACTIVE,
+	PAGE_EXT_OWNER_ALLOCATED,
 #if defined(CONFIG_IDLE_PAGE_TRACKING) && !defined(CONFIG_64BIT)
 	PAGE_EXT_YOUNG,
 	PAGE_EXT_IDLE,
 	unsigned long flags;
 };
+extern unsigned long page_ext_size;
 extern void pgdat_page_ext_init(struct pglist_data *pgdat);
 #ifdef CONFIG_SPARSEMEM
 struct page_ext *lookup_page_ext(const struct page *page);
+static inline struct page_ext *page_ext_next(struct page_ext *curr)
+{
+	void *next = curr;
+	next += page_ext_size;
+	return next;
+}
 #else /* !CONFIG_PAGE_EXTENSION */
 struct page_ext;

include/linux/perf_event.h+1−1

@@ -292,7 +292,7 @@ struct pmu { · 291 unmodified lines
292	* -EBUSY -- @event is for this PMU but PMU temporarily unavailable	292	* -EBUSY -- @event is for this PMU but PMU temporarily unavailable
293	* -EINVAL -- @event is for this PMU but @event is not valid	293	* -EINVAL -- @event is for this PMU but @event is not valid
294	* -EOPNOTSUPP -- @event is for this PMU, @event is valid, but not supported	294	* -EOPNOTSUPP -- @event is for this PMU, @event is valid, but not supported
295	* -EACCESS -- @event is for this PMU, @event is valid, but no privilidges	295	* -EACCES -- @event is for this PMU, @event is valid, but no privileges
296	*	296	*
297	* 0 -- @event is for this PMU and valid	297	* 0 -- @event is for this PMU and valid
298	*	298	*

include/linux/platform_data/dma-imx-sdma.h+3−0

 	/* End of v2 array */
 	s32 zcanfd_2_mcu_addr;
 	s32 zqspi_2_mcu_addr;
+	s32 mcu_2_ecspi_addr;
 	/* End of v3 array */
+	s32 mcu_2_zqspi_addr;
+	/* End of v4 array */
 };
 /**

include/linux/platform_device.h+2−0

@@ -64,6 +64,8 @@ extern struct resource platform_get_resource_byname(struct platform_device , · 63 unmodified lines
64	unsigned int,	64	unsigned int,
65	const char *);	65	const char *);
66	extern int platform_get_irq_byname(struct platform_device , const char );	66	extern int platform_get_irq_byname(struct platform_device , const char );
		67	extern int platform_get_irq_byname_optional(struct platform_device *dev,
		68	const char *name);
67	extern int platform_add_devices(struct platform_device **, int);	69	extern int platform_add_devices(struct platform_device **, int);
68		70
69	struct platform_device_info {	71	struct platform_device_info {

include/linux/pm_qos.h+44−12

 #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	(-1)
 #define PM_QOS_LATENCY_TOLERANCE_NO_CONSTRAINT	(-1)
 #define PM_QOS_FLAG_NO_POWER_OFF	(1 << 0)
 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 {
 	struct pm_qos_constraints resume_latency;
 	struct pm_qos_constraints latency_tolerance;
-	struct pm_qos_constraints min_frequency;
-	struct pm_qos_constraints max_frequency;
 	struct pm_qos_flags flags;
 	struct dev_pm_qos_request *resume_latency_req;
 	struct dev_pm_qos_request *latency_tolerance_req;
 	struct dev_pm_qos_request *flags_req;
-	struct dev_pm_qos_request *min_frequency_req;
-	struct dev_pm_qos_request *max_frequency_req;
 };
 /* Action requested to pm_qos_update_target */
 	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);
+}
+void freq_constraints_init(struct freq_constraints *qos);
+s32 freq_qos_read_value(struct freq_constraints *qos,
+			enum freq_qos_req_type type);
+int freq_qos_add_request(struct freq_constraints *qos,
+			 struct freq_qos_request *req,
+			 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_add_notifier(struct freq_constraints *qos,
+			  enum freq_qos_req_type type,
+			  struct notifier_block *notifier);
+int freq_qos_remove_notifier(struct freq_constraints *qos,
+			     enum freq_qos_req_type type,
+			     struct notifier_block *notifier);
 #endif

include/linux/radix-tree.h+0−18

@@ -315,24 +315,6 @@ radix_tree_iter_lookup(const struct radix_tree_root *root, · 314 unmodified lines
315	return radix_tree_next_chunk(root, iter, RADIX_TREE_ITER_CONTIG);	315	return radix_tree_next_chunk(root, iter, RADIX_TREE_ITER_CONTIG);
316	}	316	}
317		317
318	/**
319	* radix_tree_iter_find - find a present entry
320	* @root: radix tree root
321	* @iter: iterator state
322	* @index: start location
323	*
324	* This function returns the slot containing the entry with the lowest index
325	* which is at least @index. If @index is larger than any present entry, this
326	* function returns NULL. The @iter is updated to describe the entry found.
327	*/
328	static inline void __rcu **
329	radix_tree_iter_find(const struct radix_tree_root *root,
330	struct radix_tree_iter *iter, unsigned long index)
331	{
332	radix_tree_iter_init(iter, index);
333	return radix_tree_next_chunk(root, iter, 0);
334	}
335
336	/**	318	/**
337	* radix_tree_iter_retry - retry this chunk of the iteration	319	* radix_tree_iter_retry - retry this chunk of the iteration
338	* @iter: iterator state	320	* @iter: iterator state

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

@@ -7,7 +7,7 @@ · 6 unmodified lines
7	struct reset_controller_dev;	7	struct reset_controller_dev;
8		8
9	/**	9	/**
10	* struct reset_control_ops	10	* struct reset_control_ops - reset controller driver callbacks
11	*	11	*
12	* @reset: for self-deasserting resets, does all necessary	12	* @reset: for self-deasserting resets, does all necessary
13	* things to reset the device	13	* things to reset the device
@@ -33,7 +33,7 @@ struct of_phandle_args; · 19 unmodified lines
33	* @provider: name of the reset controller device controlling this reset line	33	* @provider: name of the reset controller device controlling this reset line
34	* @index: ID of the reset controller in the reset controller device	34	* @index: ID of the reset controller in the reset controller device
35	* @dev_id: name of the device associated with this reset line	35	* @dev_id: name of the device associated with this reset line
36	* @con_id name of the reset line (can be NULL)	36	* @con_id: name of the reset line (can be NULL)
37	*/	37	*/
38	struct reset_control_lookup {	38	struct reset_control_lookup {
39	struct list_head list;	39	struct list_head list;

include/linux/reset.h+1−1

@@ -143,7 +143,7 @@ static inline int device_reset_optional(struct device *dev) · 142 unmodified lines
143	* If this function is called more than once for the same reset_control it will	143	* If this function is called more than once for the same reset_control it will
144	* return -EBUSY.	144	* return -EBUSY.
145	*	145	*
146	* See reset_control_get_shared for details on shared references to	146	* See reset_control_get_shared() for details on shared references to
147	* reset-controls.	147	* reset-controls.
148	*	148	*
149	* Use of id names is optional.	149	* Use of id names is optional.

include/linux/sched.h+1−0

@@ -223,6 +223,7 @@ extern long schedule_timeout_uninterruptible(long timeout); · 222 unmodified lines
223	extern long schedule_timeout_idle(long timeout);	223	extern long schedule_timeout_idle(long timeout);
224	asmlinkage void schedule(void);	224	asmlinkage void schedule(void);
225	extern void schedule_preempt_disabled(void);	225	extern void schedule_preempt_disabled(void);
		226	asmlinkage void preempt_schedule_irq(void);
226		227
227	extern int __must_check io_schedule_prepare(void);	228	extern int __must_check io_schedule_prepare(void);
228	extern void io_schedule_finish(int token);	229	extern void io_schedule_finish(int token);

include/linux/security.h+1−0

@@ -105,6 +105,7 @@ enum lockdown_reason { · 104 unmodified lines
105	LOCKDOWN_NONE,	105	LOCKDOWN_NONE,
106	LOCKDOWN_MODULE_SIGNATURE,	106	LOCKDOWN_MODULE_SIGNATURE,
107	LOCKDOWN_DEV_MEM,	107	LOCKDOWN_DEV_MEM,
		108	LOCKDOWN_EFI_TEST,
108	LOCKDOWN_KEXEC,	109	LOCKDOWN_KEXEC,
109	LOCKDOWN_HIBERNATION,	110	LOCKDOWN_HIBERNATION,
110	LOCKDOWN_PCI_ACCESS,	111	LOCKDOWN_PCI_ACCESS,

include/linux/skbuff.h+29−12

 	return skb->hash;
 }
-__u32 skb_get_hash_perturb(const struct sk_buff *skb, u32 perturb);
+__u32 skb_get_hash_perturb(const struct sk_buff *skb,
+			   const siphash_key_t *perturb);
 static inline __u32 skb_get_hash_raw(const struct sk_buff *skb)
 {
 	return list->next == (const struct sk_buff *) list;
 }
+/**
+ *	skb_queue_empty_lockless - check if a queue is empty
+ *	@list: queue head
+ *
+ *	Returns true if the queue is empty, false otherwise.
+ *	This variant can be used in lockless contexts.
+ */
+static inline bool skb_queue_empty_lockless(const struct sk_buff_head *list)
+{
+	return READ_ONCE(list->next) == (const struct sk_buff *) list;
+}
 /**
  *	skb_queue_is_last - check if skb is the last entry in the queue
  *	@list: queue head
 				struct sk_buff *prev, struct sk_buff *next,
 				struct sk_buff_head *list)
 {
-	newsk->next = next;
+	/* see skb_queue_empty_lockless() for the opposite READ_ONCE() */
-	newsk->prev = prev;
+	WRITE_ONCE(newsk->next, next);
-	next->prev  = prev->next = newsk;
+	WRITE_ONCE(newsk->prev, prev);
+	WRITE_ONCE(next->prev, newsk);
+	WRITE_ONCE(prev->next, newsk);
 	list->qlen++;
 }
 	struct sk_buff *first = list->next;
 	struct sk_buff *last = list->prev;
-	first->prev = prev;
+	WRITE_ONCE(first->prev, prev);
-	prev->next = first;
+	WRITE_ONCE(prev->next, first);
-	last->next = next;
+	WRITE_ONCE(last->next, next);
-	next->prev = last;
+	WRITE_ONCE(next->prev, last);
 }
 /**
 	next	   = skb->next;
 	prev	   = skb->prev;
 	skb->next  = skb->prev = NULL;
-	next->prev = prev;
+	WRITE_ONCE(next->prev, prev);
-	prev->next = next;
+	WRITE_ONCE(prev->next, next);
 }
 /**
 int __skb_vlan_pop(struct sk_buff *skb, u16 *vlan_tci);
 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 skb_mpls_push(struct sk_buff *skb, __be32 mpls_lse, __be16 mpls_proto,
-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);
 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/skmsg.h+6−3

 	}
 }
+static inline u32 sk_msg_iter_dist(u32 start, u32 end)
+{
+	return end >= start ? end - start : end + (MAX_MSG_FRAGS - start);
+}
 #define sk_msg_iter_var_prev(var)			\
 	do {						\
 		if (var == 0)				\
 	if (sk_msg_full(msg))
 		return MAX_MSG_FRAGS;
-	return msg->sg.end >= msg->sg.start ?
+	return sk_msg_iter_dist(msg->sg.start, msg->sg.end);
-		msg->sg.end - msg->sg.start :
-		msg->sg.end + (MAX_MSG_FRAGS - msg->sg.start);
 }
 static inline struct scatterlist *sk_msg_elem(struct sk_msg *msg, int which)

include/linux/slab.h+4−0

  * kmalloc is the normal method of allocating memory
  * for objects smaller than page size in the kernel.
  *
+ * The allocated object address is aligned to at least ARCH_KMALLOC_MINALIGN
+ * bytes. For @size of power of two bytes, the alignment is also guaranteed
+ * to be at least to the size.
+ *
  * The @flags argument may be one of the GFP flags defined at
  * include/linux/gfp.h and described at
  * :ref:`Documentation/core-api/mm-api.rst <mm-api-gfp-flags>`

include/linux/socket.h+1−1

@@ -263,7 +263,7 @@ struct ucred { · 262 unmodified lines
263	#define PF_MAX AF_MAX	263	#define PF_MAX AF_MAX
264		264
265	/* Maximum queue length specifiable by listen. */	265	/* Maximum queue length specifiable by listen. */
266	#define SOMAXCONN 128	266	#define SOMAXCONN 4096
267		267
268	/* Flags we can use with send/ and recv.	268	/* Flags we can use with send/ and recv.
269	Added those for 1003.1g not all are supported yet	269	Added those for 1003.1g not all are supported yet

include/linux/string.h+20−1

@@ -227,7 +227,26 @@ static inline bool strstarts(const char str, const char prefix) · 226 unmodified lines
227	}	227	}
228		228
229	size_t memweight(const void *ptr, size_t bytes);	229	size_t memweight(const void *ptr, size_t bytes);
230	void memzero_explicit(void *s, size_t count);	230
		231	/**
		232	* memzero_explicit - Fill a region of memory (e.g. sensitive
		233	* keying data) with 0s.
		234	* @s: Pointer to the start of the area.
		235	* @count: The size of the area.
		236	*
		237	* Note: usually using memset() is just fine (!), but in cases
		238	* where clearing out _local_ data at the end of a scope is
		239	* necessary, memzero_explicit() should be used instead in
		240	* order to prevent the compiler from optimising away zeroing.
		241	*
		242	* memzero_explicit() doesn't need an arch-specific version as
		243	* it just invokes the one of memset() implicitly.
		244	*/
		245	static inline void memzero_explicit(void *s, size_t count)
		246	{
		247	memset(s, 0, count);
		248	barrier_data(s);
		249	}
231		250
232	/**	251	/**
233	* kbasename - return the last part of a pathname.	252	* kbasename - return the last part of a pathname.

include/linux/sunrpc/bc_xprt.h+5−0

 	return 0;
 }
+static inline void xprt_destroy_backchannel(struct rpc_xprt *xprt,
+					    unsigned int max_reqs)
+{
+}
 static inline bool svc_is_backchannel(const struct svc_rqst *rqstp)
 {
 	return false;

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

@@ -61,6 +61,7 @@ struct sock_xprt { · 60 unmodified lines
61	struct mutex recv_mutex;	61	struct mutex recv_mutex;
62	struct sockaddr_storage srcaddr;	62	struct sockaddr_storage srcaddr;
63	unsigned short srcport;	63	unsigned short srcport;
		64	int xprt_err;
64		65
65	/*	66	/*
66	* UDP socket buffer size parameters	67	* UDP socket buffer size parameters

include/linux/sysfs.h+2−2

@@ -196,9 +196,9 @@ struct bin_attribute { · 195 unmodified lines
196	.size = _size, \	196	.size = _size, \
197	}	197	}
198		198
199	#define __BIN_ATTR_WO(_name) { \	199	#define __BIN_ATTR_WO(_name, _size) { \
200	.attr = { .name = __stringify(_name), .mode = 0200 }, \	200	.attr = { .name = __stringify(_name), .mode = 0200 }, \
201	.store = _name##_store, \	201	.write = _name##_write, \
202	.size = _size, \	202	.size = _size, \
203	}	203	}
204		204

include/linux/tcp.h+3−3

@@ -393,7 +393,7 @@ struct tcp_sock { · 392 unmodified lines
393	/* fastopen_rsk points to request_sock that resulted in this big	393	/* fastopen_rsk points to request_sock that resulted in this big
394	* socket. Used to retransmit SYNACKs etc.	394	* socket. Used to retransmit SYNACKs etc.
395	*/	395	*/
396	struct request_sock *fastopen_rsk;	396	struct request_sock __rcu *fastopen_rsk;
397	u32 *saved_syn;	397	u32 *saved_syn;
398	};	398	};
399		399
@@ -447,8 +447,8 @@ static inline struct tcp_timewait_sock tcp_twsk(const struct sock sk) · 47 unmodified lines
447		447
448	static inline bool tcp_passive_fastopen(const struct sock *sk)	448	static inline bool tcp_passive_fastopen(const struct sock *sk)
449	{	449	{
450	return (sk->sk_state == TCP_SYN_RECV &&	450	return sk->sk_state == TCP_SYN_RECV &&
451	tcp_sk(sk)->fastopen_rsk != NULL);	451	rcu_access_pointer(tcp_sk(sk)->fastopen_rsk) != NULL;
452	}	452	}
453		453
454	static inline void fastopen_queue_tune(struct sock *sk, int backlog)	454	static inline void fastopen_queue_tune(struct sock *sk, int backlog)

include/linux/tpm_eventlog.h+12−4

  * total. Once we've done this we know the offset of the data length field,
  * and can calculate the total size of the event.
  *
- * Return: size of the event on success, <0 on failure
+ * Return: size of the event on success, 0 on failure
  */
 static inline int __calc_tpm2_event_size(struct tcg_pcr_event2_head *event,
 	u16 halg;
 	int i;
 	int j;
+	u32 count, event_type;
 	marker = event;
 	marker_start = marker;
 	}
 	event = (struct tcg_pcr_event2_head *)mapping;
+	/*
+	 * The loop below will unmap these fields if the log is larger than
+	 * one page, so save them here for reference:
+	 */
+	count = READ_ONCE(event->count);
+	event_type = READ_ONCE(event->event_type);
 	efispecid = (struct tcg_efi_specid_event_head *)event_header->event;
 	/* Check if event is malformed. */
-	if (event->count > efispecid->num_algs) {
+	if (count > efispecid->num_algs) {
 		size = 0;
 		goto out;
 	}
-	for (i = 0; i < event->count; i++) {
+	for (i = 0; i < count; i++) {
 		halg_size = sizeof(event->digests[i].alg_id);
 		/* Map the digest's algorithm identifier */
 		+ event_field->event_size;
 	size = marker - marker_start;
-	if ((event->event_type == 0) && (event_field->event_size == 0))
+	if (event_type == 0 && event_field->event_size == 0)
 		size = 0;
 out:
 	if (do_mapping)
 		TPM_MEMUNMAP(mapping, mapping_size);

include/linux/uaccess.h+4−2

 #ifndef user_access_begin
 #define user_access_begin(ptr,len) access_ok(ptr, len)
 #define user_access_end() do { } while (0)
-#define unsafe_get_user(x, ptr, err) do { if (unlikely(__get_user(x, ptr))) goto err; } while (0)
+#define unsafe_op_wrap(op, err) do { if (unlikely(op)) goto err; } while (0)
-#define unsafe_put_user(x, ptr, err) do { if (unlikely(__put_user(x, ptr))) goto err; } while (0)
+#define unsafe_get_user(x,p,e) unsafe_op_wrap(__get_user(x,p),e)
+#define unsafe_put_user(x,p,e) unsafe_op_wrap(__put_user(x,p),e)
+#define unsafe_copy_to_user(d,s,l,e) unsafe_op_wrap(__copy_to_user(d,s,l),e)
 static inline unsigned long user_access_save(void) { return 0UL; }
 static inline void user_access_restore(unsigned long flags) { }
 #endif

include/linux/virtio_vsock.h+0−1

@@ -48,7 +48,6 @@ struct virtio_vsock_sock { · 47 unmodified lines
48		48
49	struct virtio_vsock_pkt {	49	struct virtio_vsock_pkt {
50	struct virtio_vsock_hdr hdr;	50	struct virtio_vsock_hdr hdr;
51	struct work_struct work;
52	struct list_head list;	51	struct list_head list;
53	/* socket refcnt not held, only use for cancellation */	52	/* socket refcnt not held, only use for cancellation */
54	struct vsock_sock *vsk;	53	struct vsock_sock *vsk;

include/linux/xarray.h+2−2

@@ -230,8 +230,8 @@ static inline int xa_err(void *entry) · 229 unmodified lines
230	* This structure is used either directly or via the XA_LIMIT() macro	230	* This structure is used either directly or via the XA_LIMIT() macro
231	* to communicate the range of IDs that are valid for allocation.	231	* to communicate the range of IDs that are valid for allocation.
232	* Two common ranges are predefined for you:	232	* Two common ranges are predefined for you:
233	* * xa_limit_32b - [0 - UINT_MAX]	233	* * xa_limit_32b - [0 - UINT_MAX]
234	* * xa_limit_31b - [0 - INT_MAX]	234	* * xa_limit_31b - [0 - INT_MAX]
235	*/	235	*/
236	struct xa_limit {	236	struct xa_limit {
237	u32 max;	237	u32 max;

Merge tag 'asoc-v5.5-2' of https://git.kernel.org/pub/scm/linux/kernel/git/broonie/sound into for-linus

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code