Merge branch 'char-misc-next' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc into fpga-dfl-for-5.4

Moritz Fischer committed 7 years ago

Commit af9ca4b2 parents cbb4a74 99097a21971 files · +22326 −14084Browse files

Showing the changes to include/linux (52 of 1971 files). Show all

Unified · Split

52 files

include/linux/blk-cgroup.h +1 −0
include/linux/ccp.h +2 −0
include/linux/ceph/buffer.h +2 −1
include/linux/clk.h +1 −0
include/linux/connector.h +0 −1
include/linux/cred.h +7 −1
include/linux/device.h +6 −0
include/linux/dim.h +0 −56
include/linux/dma-contiguous.h +1 −4
include/linux/dma-mapping.h +2 −2
include/linux/dma-noncoherent.h +9 −4
include/linux/elevator.h +0 −1
include/linux/filter.h +13 −0
include/linux/fs.h +6 −0
include/linux/gfp.h +4 −8
include/linux/gpio.h +0 −24
include/linux/gpio/consumer.h +32 −32
include/linux/hmm.h +0 −54
include/linux/if_pppox.h +3 −0
include/linux/if_rmnet.h +2 −2
include/linux/intel_th.h +79 −0
include/linux/iova.h +6 −0
include/linux/key.h +4 −4
include/linux/kvm_host.h +4 −2
include/linux/logic_pio.h +1 −0
include/linux/memcontrol.h +19 −0
include/linux/mempolicy.h +2 −0
include/linux/mlx5/device.h +2 −2
include/linux/mlx5/fs.h +1 −0
include/linux/mlx5/mlx5_ifc.h +6 −5
include/linux/mm_types.h +10 −1
include/linux/mmzone.h +3 −2
include/linux/mod_devicetable.h +1 −0
include/linux/netfilter/nf_conntrack_h323_asn1.h +1 −2
include/linux/netfilter/nf_conntrack_h323_types.h +5 −0
include/linux/of.h +1 −1
include/linux/page-flags-layout.h +11 −7
include/linux/page-flags.h +4 −0
include/linux/pci.h +2 −0
include/linux/phy.h +1 −0
include/linux/sched.h +9 −1
include/linux/sched/numa_balancing.h +2 −2
include/linux/signal.h +14 −1
include/linux/skbuff.h +8 −0
include/linux/skmsg.h +7 −1
include/linux/socket.h +3 −0
include/linux/sunrpc/sched.h +0 −1
include/linux/timekeeper_internal.h +5 −0
include/linux/trace_events.h +1 −0
include/linux/usb.h +1 −1
include/linux/usb/hcd.h +3 −0
include/linux/wait.h +13 −0

@@ -181,6 +181,7 @@ struct blkcg_policy { · 180 unmodified lines
181	181
182	182	extern struct blkcg blkcg_root;
183	183	extern struct cgroup_subsys_state * const blkcg_root_css;
	184	+extern bool blkcg_debug_stats;
184	185
185	186	struct blkcg_gq blkg_lookup_slowpath(struct blkcg blkcg,
186	187	struct request_queue *q, bool update_hint);

include/linux/ccp.h+2−0

@@ -170,6 +170,8 @@ struct ccp_aes_engine { · 169 unmodified lines
170	170	enum ccp_aes_mode mode;
171	171	enum ccp_aes_action action;
172	172
	173	+ u32 authsize;
	174	+
173	175	struct scatterlist *key;
174	176	u32 key_len; /* In bytes */
175	177

include/linux/ceph/buffer.h+2−1

@@ -30,7 +30,8 @@ static inline struct ceph_buffer ceph_buffer_get(struct ceph_buffer b) · 29 unmodified lines
30	30
31	31	static inline void ceph_buffer_put(struct ceph_buffer *b)
32	32	{
33		− kref_put(&b->kref, ceph_buffer_release);
	33	+ if (b)
	34	+ kref_put(&b->kref, ceph_buffer_release);
34	35	}
35	36
36	37	extern int ceph_decode_buffer(struct ceph_buffer b, void p, void *end);

include/linux/clk.h+1−0

@@ -359,6 +359,7 @@ int __must_check devm_clk_bulk_get(struct device *dev, int num_clks, · 358 unmodified lines
359	359	/**
360	360	* devm_clk_bulk_get_optional - managed get multiple optional consumer clocks
361	361	* @dev: device for clock "consumer"
	362	+ * @num_clks: the number of clk_bulk_data
362	363	* @clks: pointer to the clk_bulk_data table of consumer
363	364	*
364	365	* Behaves the same as devm_clk_bulk_get() except where there is no clock

include/linux/connector.h+0−1

@@ -50,7 +50,6 @@ struct cn_dev { · 49 unmodified lines
50	50
51	51	u32 seq, groups;
52	52	struct sock *nls;
53		− void (input) (struct sk_buff skb);
54	53
55	54	struct cn_queue_dev *cbdev;
56	55	};

include/linux/cred.h+7−1

@@ -145,7 +145,11 @@ struct cred { · 144 unmodified lines
145	145	struct user_struct user; / real user ID subscription */
146	146	struct user_namespace user_ns; / user_ns the caps and keyrings are relative to. */
147	147	struct group_info group_info; / supplementary groups for euid/fsgid */
148		− struct rcu_head rcu; /* RCU deletion hook */
	148	+ /* RCU deletion */
	149	+ union {
	150	+ int non_rcu; /* Can we skip RCU deletion? */
	151	+ struct rcu_head rcu; /* RCU deletion hook */
	152	+ };
149	153	} __randomize_layout;
150	154
151	155	extern void __put_cred(struct cred *);
@@ -246,6 +250,7 @@ static inline const struct cred get_cred(const struct cred cred) · 94 unmodified lines
246	250	if (!cred)
247	251	return cred;
248	252	validate_creds(cred);
	253	+ nonconst_cred->non_rcu = 0;
249	254	return get_new_cred(nonconst_cred);
250	255	}
251	256
@@ -257,6 +262,7 @@ static inline const struct cred get_cred_rcu(const struct cred cred) · 5 unmodified lines
257	262	if (!atomic_inc_not_zero(&nonconst_cred->usage))
258	263	return NULL;
259	264	validate_creds(cred);
	265	+ nonconst_cred->non_rcu = 0;
260	266	return cred;
261	267	}
262	268

include/linux/device.h+6−0

@@ -918,6 +918,8 @@ struct dev_links_info { · 917 unmodified lines
918	918	* This identifies the device type and carries type-specific
919	919	* information.
920	920	* @mutex: Mutex to synchronize calls to its driver.
	921	+ * @lockdep_mutex: An optional debug lock that a subsystem can use as a
	922	+ * peer lock to gain localized lockdep coverage of the device_lock.
921	923	* @bus: Type of bus device is on.
922	924	* @driver: Which driver has allocated this
923	925	* @platform_data: Platform data specific to the device.
@@ -1001,6 +1003,9 @@ struct device { · 77 unmodified lines
1001	1003	core doesn't touch it */
1002	1004	void driver_data; / Driver data, set and get with
1003	1005	dev_set_drvdata/dev_get_drvdata */
	1006	+#ifdef CONFIG_PROVE_LOCKING
	1007	+ struct mutex lockdep_mutex;
	1008	+#endif
1004	1009	struct mutex mutex; /* mutex to synchronize calls to
1005	1010	* its driver.
1006	1011	*/
@@ -1386,6 +1391,7 @@ extern int (platform_notify_remove)(struct device dev); · 379 unmodified lines
1386	1391	*/
1387	1392	extern struct device get_device(struct device dev);
1388	1393	extern void put_device(struct device *dev);
	1394	+extern bool kill_device(struct device *dev);
1389	1395
1390	1396	#ifdef CONFIG_DEVTMPFS
1391	1397	extern int devtmpfs_create_node(struct device *dev);

include/linux/dim.h+0−56

@@ -272,62 +272,6 @@ dim_update_sample_with_comps(u16 event_ctr, u64 packets, u64 bytes, u64 comps, · 271 unmodified lines
272	272
273	273	/* Net DIM */
274	274
275		−/*
276		− * Net DIM profiles:
277		− * There are different set of profiles for each CQ period mode.
278		− * There are different set of profiles for RX/TX CQs.
279		− * Each profile size must be of NET_DIM_PARAMS_NUM_PROFILES
280		− */
281		−#define NET_DIM_PARAMS_NUM_PROFILES 5
282		−#define NET_DIM_DEFAULT_RX_CQ_MODERATION_PKTS_FROM_EQE 256
283		−#define NET_DIM_DEFAULT_TX_CQ_MODERATION_PKTS_FROM_EQE 128
284		−#define NET_DIM_DEF_PROFILE_CQE 1
285		−#define NET_DIM_DEF_PROFILE_EQE 1
286		−
287		−#define NET_DIM_RX_EQE_PROFILES { \
288		− {1, NET_DIM_DEFAULT_RX_CQ_MODERATION_PKTS_FROM_EQE}, \
289		− {8, NET_DIM_DEFAULT_RX_CQ_MODERATION_PKTS_FROM_EQE}, \
290		− {64, NET_DIM_DEFAULT_RX_CQ_MODERATION_PKTS_FROM_EQE}, \
291		− {128, NET_DIM_DEFAULT_RX_CQ_MODERATION_PKTS_FROM_EQE}, \
292		− {256, NET_DIM_DEFAULT_RX_CQ_MODERATION_PKTS_FROM_EQE}, \
293		−}
294		−
295		−#define NET_DIM_RX_CQE_PROFILES { \
296		− {2, 256}, \
297		− {8, 128}, \
298		− {16, 64}, \
299		− {32, 64}, \
300		− {64, 64} \
301		−}
302		−
303		−#define NET_DIM_TX_EQE_PROFILES { \
304		− {1, NET_DIM_DEFAULT_TX_CQ_MODERATION_PKTS_FROM_EQE}, \
305		− {8, NET_DIM_DEFAULT_TX_CQ_MODERATION_PKTS_FROM_EQE}, \
306		− {32, NET_DIM_DEFAULT_TX_CQ_MODERATION_PKTS_FROM_EQE}, \
307		− {64, NET_DIM_DEFAULT_TX_CQ_MODERATION_PKTS_FROM_EQE}, \
308		− {128, NET_DIM_DEFAULT_TX_CQ_MODERATION_PKTS_FROM_EQE} \
309		−}
310		−
311		−#define NET_DIM_TX_CQE_PROFILES { \
312		− {5, 128}, \
313		− {8, 64}, \
314		− {16, 32}, \
315		− {32, 32}, \
316		− {64, 32} \
317		−}
318		−
319		−static const struct dim_cq_moder
320		−rx_profile[DIM_CQ_PERIOD_NUM_MODES][NET_DIM_PARAMS_NUM_PROFILES] = {
321		− NET_DIM_RX_EQE_PROFILES,
322		− NET_DIM_RX_CQE_PROFILES,
323		−};
324		−
325		−static const struct dim_cq_moder
326		−tx_profile[DIM_CQ_PERIOD_NUM_MODES][NET_DIM_PARAMS_NUM_PROFILES] = {
327		− NET_DIM_TX_EQE_PROFILES,
328		− NET_DIM_TX_CQE_PROFILES,
329		−};
330		−
331	275	/**
332	276	* net_dim_get_rx_moderation - provide a CQ moderation object for the given RX profile
333	277	* @cq_period_mode: CQ period mode

include/linux/dma-contiguous.h+1−4

@@ -160,10 +160,7 @@ bool dma_release_from_contiguous(struct device dev, struct page pages, · 159 unmodified lines
160	160	static inline struct page dma_alloc_contiguous(struct device dev, size_t size,
161	161	gfp_t gfp)
162	162	{
163		− int node = dev ? dev_to_node(dev) : NUMA_NO_NODE;
164		− size_t align = get_order(PAGE_ALIGN(size));
165		−
166		− return alloc_pages_node(node, gfp, align);
	163	+ return NULL;
167	164	}
168	165
169	166	static inline void dma_free_contiguous(struct device dev, struct page page,

include/linux/dma-mapping.h+2−2

@@ -689,8 +689,8 @@ static inline int dma_coerce_mask_and_coherent(struct device *dev, u64 mask) · 688 unmodified lines
689	689	*/
690	690	static inline bool dma_addressing_limited(struct device *dev)
691	691	{
692		− return min_not_zero(*dev->dma_mask, dev->bus_dma_mask) <
693		− dma_get_required_mask(dev);
	692	+ return min_not_zero(dma_get_mask(dev), dev->bus_dma_mask) <
	693	+ dma_get_required_mask(dev);
694	694	}
695	695
696	696	#ifdef CONFIG_ARCH_HAS_SETUP_DMA_OPS

include/linux/dma-noncoherent.h+9−4

@@ -42,13 +42,18 @@ void arch_dma_free(struct device dev, size_t size, void cpu_addr, · 41 unmodified lines
42	42	dma_addr_t dma_addr, unsigned long attrs);
43	43	long arch_dma_coherent_to_pfn(struct device dev, void cpu_addr,
44	44	dma_addr_t dma_addr);
45		−
46		−#ifdef CONFIG_ARCH_HAS_DMA_MMAP_PGPROT
47	45	pgprot_t arch_dma_mmap_pgprot(struct device *dev, pgprot_t prot,
48	46	unsigned long attrs);
	47	+
	48	+#ifdef CONFIG_MMU
	49	+pgprot_t dma_pgprot(struct device *dev, pgprot_t prot, unsigned long attrs);
49	50	#else
50		−# define arch_dma_mmap_pgprot(dev, prot, attrs) pgprot_noncached(prot)
51		−#endif
	51	+static inline pgprot_t dma_pgprot(struct device *dev, pgprot_t prot,
	52	+ unsigned long attrs)
	53	+{
	54	+ return prot; /* no protection bits supported without page tables */
	55	+}
	56	+#endif /* CONFIG_MMU */
52	57
53	58	#ifdef CONFIG_DMA_NONCOHERENT_CACHE_SYNC
54	59	void arch_dma_cache_sync(struct device dev, void vaddr, size_t size,

include/linux/elevator.h+0−1

@@ -45,7 +45,6 @@ struct elevator_mq_ops { · 44 unmodified lines
45	45	struct request (dispatch_request)(struct blk_mq_hw_ctx *);
46	46	bool (has_work)(struct blk_mq_hw_ctx );
47	47	void (completed_request)(struct request , u64);
48		− void (started_request)(struct request );
49	48	void (requeue_request)(struct request );
50	49	struct request (former_request)(struct request_queue , struct request );
51	50	struct request (next_request)(struct request_queue , struct request );

include/linux/filter.h+13−0

@@ -24,6 +24,7 @@ · 23 unmodified lines
24	24
25	25	#include <net/sch_generic.h>
26	26
	27	+#include <asm/byteorder.h>
27	28	#include <uapi/linux/filter.h>
28	29	#include <uapi/linux/bpf.h>
29	30
@@ -747,6 +748,18 @@ bpf_ctx_narrow_access_ok(u32 off, u32 size, u32 size_default) · 717 unmodified lines
747	748	return size <= size_default && (size & (size - 1)) == 0;
748	749	}
749	750
	751	+static inline u8
	752	+bpf_ctx_narrow_load_shift(u32 off, u32 size, u32 size_default)
	753	+{
	754	+ u8 load_off = off & (size_default - 1);
	755	+
	756	+#ifdef __LITTLE_ENDIAN
	757	+ return load_off * 8;
	758	+#else
	759	+ return (size_default - (load_off + size)) * 8;
	760	+#endif
	761	+}
	762	+
750	763	#define bpf_ctx_wide_access_ok(off, size, type, field) \
751	764	(size == sizeof(__u64) && \
752	765	off >= offsetof(type, field) && \

include/linux/fs.h+6−0

@@ -2598,6 +2598,12 @@ extern struct block_device blkdev_get_by_path(const char path, fmode_t mode, · 2597 unmodified lines
2598	2598	void *holder);
2599	2599	extern struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode,
2600	2600	void *holder);
	2601	+extern struct block_device bd_start_claiming(struct block_device bdev,
	2602	+ void *holder);
	2603	+extern void bd_finish_claiming(struct block_device *bdev,
	2604	+ struct block_device whole, void holder);
	2605	+extern void bd_abort_claiming(struct block_device *bdev,
	2606	+ struct block_device whole, void holder);
2601	2607	extern void blkdev_put(struct block_device *bdev, fmode_t mode);
2602	2608	extern int __blkdev_reread_part(struct block_device *bdev);
2603	2609	extern int blkdev_reread_part(struct block_device *bdev);

include/linux/gfp.h+4−8

@@ -510,22 +510,18 @@ alloc_pages(gfp_t gfp_mask, unsigned int order) · 509 unmodified lines
510	510	}
511	511	extern struct page *alloc_pages_vma(gfp_t gfp_mask, int order,
512	512	struct vm_area_struct *vma, unsigned long addr,
513		− int node, bool hugepage);
514		−#define alloc_hugepage_vma(gfp_mask, vma, addr, order) \
515		− alloc_pages_vma(gfp_mask, order, vma, addr, numa_node_id(), true)
	513	+ int node);
516	514	#else
517	515	#define alloc_pages(gfp_mask, order) \
518	516	alloc_pages_node(numa_node_id(), gfp_mask, order)
519		−#define alloc_pages_vma(gfp_mask, order, vma, addr, node, false)\
520		− alloc_pages(gfp_mask, order)
521		−#define alloc_hugepage_vma(gfp_mask, vma, addr, order) \
	517	+#define alloc_pages_vma(gfp_mask, order, vma, addr, node)\
522	518	alloc_pages(gfp_mask, order)
523	519	#endif
524	520	#define alloc_page(gfp_mask) alloc_pages(gfp_mask, 0)
525	521	#define alloc_page_vma(gfp_mask, vma, addr) \
526		− alloc_pages_vma(gfp_mask, 0, vma, addr, numa_node_id(), false)
	522	+ alloc_pages_vma(gfp_mask, 0, vma, addr, numa_node_id())
527	523	#define alloc_page_vma_node(gfp_mask, vma, addr, node) \
528		− alloc_pages_vma(gfp_mask, 0, vma, addr, node, false)
	524	+ alloc_pages_vma(gfp_mask, 0, vma, addr, node)
529	525
530	526	extern unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order);
531	527	extern unsigned long get_zeroed_page(gfp_t gfp_mask);

include/linux/gpio.h+0−24

@@ -241,30 +241,6 @@ static inline int irq_to_gpio(unsigned irq) · 240 unmodified lines
241	241	return -EINVAL;
242	242	}
243	243
244		−static inline int
245		−gpiochip_add_pin_range(struct gpio_chip chip, const char pinctl_name,
246		− unsigned int gpio_offset, unsigned int pin_offset,
247		− unsigned int npins)
248		−{
249		− WARN_ON(1);
250		− return -EINVAL;
251		−}
252		−
253		−static inline int
254		−gpiochip_add_pingroup_range(struct gpio_chip *chip,
255		− struct pinctrl_dev *pctldev,
256		− unsigned int gpio_offset, const char *pin_group)
257		−{
258		− WARN_ON(1);
259		− return -EINVAL;
260		−}
261		−
262		−static inline void
263		−gpiochip_remove_pin_ranges(struct gpio_chip *chip)
264		−{
265		− WARN_ON(1);
266		−}
267		−
268	244	static inline int devm_gpio_request(struct device *dev, unsigned gpio,
269	245	const char *label)
270	246	{

include/linux/gpio/consumer.h+32−32

@@ -247,7 +247,7 @@ static inline void gpiod_put(struct gpio_desc *desc) · 246 unmodified lines
247	247	might_sleep();
248	248
249	249	/* GPIO can never have been requested */
250		− WARN_ON(1);
	250	+ WARN_ON(desc);
251	251	}
252	252
253	253	static inline void devm_gpiod_unhinge(struct device *dev,
@@ -256,7 +256,7 @@ static inline void devm_gpiod_unhinge(struct device *dev, · 2 unmodified lines
256	256	might_sleep();
257	257
258	258	/* GPIO can never have been requested */
259		− WARN_ON(1);
	259	+ WARN_ON(desc);
260	260	}
261	261
262	262	static inline void gpiod_put_array(struct gpio_descs *descs)
@@ -264,7 +264,7 @@ static inline void gpiod_put_array(struct gpio_descs *descs) · 1 unmodified line
264	264	might_sleep();
265	265
266	266	/* GPIO can never have been requested */
267		− WARN_ON(1);
	267	+ WARN_ON(descs);
268	268	}
269	269
270	270	static inline struct gpio_desc *__must_check
@@ -317,7 +317,7 @@ static inline void devm_gpiod_put(struct device dev, struct gpio_desc desc) · 46 unmodified lines
317	317	might_sleep();
318	318
319	319	/* GPIO can never have been requested */
320		− WARN_ON(1);
	320	+ WARN_ON(desc);
321	321	}
322	322
323	323	static inline void devm_gpiod_put_array(struct device *dev,
@@ -326,32 +326,32 @@ static inline void devm_gpiod_put_array(struct device *dev, · 2 unmodified lines
326	326	might_sleep();
327	327
328	328	/* GPIO can never have been requested */
329		− WARN_ON(1);
	329	+ WARN_ON(descs);
330	330	}
331	331
332	332
333	333	static inline int gpiod_get_direction(const struct gpio_desc *desc)
334	334	{
335	335	/* GPIO can never have been requested */
336		− WARN_ON(1);
	336	+ WARN_ON(desc);
337	337	return -ENOSYS;
338	338	}
339	339	static inline int gpiod_direction_input(struct gpio_desc *desc)
340	340	{
341	341	/* GPIO can never have been requested */
342		− WARN_ON(1);
	342	+ WARN_ON(desc);
343	343	return -ENOSYS;
344	344	}
345	345	static inline int gpiod_direction_output(struct gpio_desc *desc, int value)
346	346	{
347	347	/* GPIO can never have been requested */
348		− WARN_ON(1);
	348	+ WARN_ON(desc);
349	349	return -ENOSYS;
350	350	}
351	351	static inline int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
352	352	{
353	353	/* GPIO can never have been requested */
354		− WARN_ON(1);
	354	+ WARN_ON(desc);
355	355	return -ENOSYS;
356	356	}
357	357
@@ -359,7 +359,7 @@ static inline int gpiod_direction_output_raw(struct gpio_desc *desc, int value) · 1 unmodified line
359	359	static inline int gpiod_get_value(const struct gpio_desc *desc)
360	360	{
361	361	/* GPIO can never have been requested */
362		− WARN_ON(1);
	362	+ WARN_ON(desc);
363	363	return 0;
364	364	}
365	365	static inline int gpiod_get_array_value(unsigned int array_size,
@@ -368,13 +368,13 @@ static inline int gpiod_get_array_value(unsigned int array_size, · 2 unmodified lines
368	368	unsigned long *value_bitmap)
369	369	{
370	370	/* GPIO can never have been requested */
371		− WARN_ON(1);
	371	+ WARN_ON(desc_array);
372	372	return 0;
373	373	}
374	374	static inline void gpiod_set_value(struct gpio_desc *desc, int value)
375	375	{
376	376	/* GPIO can never have been requested */
377		− WARN_ON(1);
	377	+ WARN_ON(desc);
378	378	}
379	379	static inline int gpiod_set_array_value(unsigned int array_size,
380	380	struct gpio_desc **desc_array,
@@ -382,13 +382,13 @@ static inline int gpiod_set_array_value(unsigned int array_size, · 1 unmodified line
382	382	unsigned long *value_bitmap)
383	383	{
384	384	/* GPIO can never have been requested */
385		− WARN_ON(1);
	385	+ WARN_ON(desc_array);
386	386	return 0;
387	387	}
388	388	static inline int gpiod_get_raw_value(const struct gpio_desc *desc)
389	389	{
390	390	/* GPIO can never have been requested */
391		− WARN_ON(1);
	391	+ WARN_ON(desc);
392	392	return 0;
393	393	}
394	394	static inline int gpiod_get_raw_array_value(unsigned int array_size,
@@ -397,13 +397,13 @@ static inline int gpiod_get_raw_array_value(unsigned int array_size, · 2 unmodified lines
397	397	unsigned long *value_bitmap)
398	398	{
399	399	/* GPIO can never have been requested */
400		− WARN_ON(1);
	400	+ WARN_ON(desc_array);
401	401	return 0;
402	402	}
403	403	static inline void gpiod_set_raw_value(struct gpio_desc *desc, int value)
404	404	{
405	405	/* GPIO can never have been requested */
406		− WARN_ON(1);
	406	+ WARN_ON(desc);
407	407	}
408	408	static inline int gpiod_set_raw_array_value(unsigned int array_size,
409	409	struct gpio_desc **desc_array,
@@ -411,14 +411,14 @@ static inline int gpiod_set_raw_array_value(unsigned int array_size, · 1 unmodified line
411	411	unsigned long *value_bitmap)
412	412	{
413	413	/* GPIO can never have been requested */
414		− WARN_ON(1);
	414	+ WARN_ON(desc_array);
415	415	return 0;
416	416	}
417	417
418	418	static inline int gpiod_get_value_cansleep(const struct gpio_desc *desc)
419	419	{
420	420	/* GPIO can never have been requested */
421		− WARN_ON(1);
	421	+ WARN_ON(desc);
422	422	return 0;
423	423	}
424	424	static inline int gpiod_get_array_value_cansleep(unsigned int array_size,
@@ -427,13 +427,13 @@ static inline int gpiod_get_array_value_cansleep(unsigned int array_size, · 2 unmodified lines
427	427	unsigned long *value_bitmap)
428	428	{
429	429	/* GPIO can never have been requested */
430		− WARN_ON(1);
	430	+ WARN_ON(desc_array);
431	431	return 0;
432	432	}
433	433	static inline void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
434	434	{
435	435	/* GPIO can never have been requested */
436		− WARN_ON(1);
	436	+ WARN_ON(desc);
437	437	}
438	438	static inline int gpiod_set_array_value_cansleep(unsigned int array_size,
439	439	struct gpio_desc **desc_array,
@@ -441,13 +441,13 @@ static inline int gpiod_set_array_value_cansleep(unsigned int array_size, · 1 unmodified line
441	441	unsigned long *value_bitmap)
442	442	{
443	443	/* GPIO can never have been requested */
444		− WARN_ON(1);
	444	+ WARN_ON(desc_array);
445	445	return 0;
446	446	}
447	447	static inline int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
448	448	{
449	449	/* GPIO can never have been requested */
450		− WARN_ON(1);
	450	+ WARN_ON(desc);
451	451	return 0;
452	452	}
453	453	static inline int gpiod_get_raw_array_value_cansleep(unsigned int array_size,
@@ -456,14 +456,14 @@ static inline int gpiod_get_raw_array_value_cansleep(unsigned int array_size, · 2 unmodified lines
456	456	unsigned long *value_bitmap)
457	457	{
458	458	/* GPIO can never have been requested */
459		− WARN_ON(1);
	459	+ WARN_ON(desc_array);
460	460	return 0;
461	461	}
462	462	static inline void gpiod_set_raw_value_cansleep(struct gpio_desc *desc,
463	463	int value)
464	464	{
465	465	/* GPIO can never have been requested */
466		− WARN_ON(1);
	466	+ WARN_ON(desc);
467	467	}
468	468	static inline int gpiod_set_raw_array_value_cansleep(unsigned int array_size,
469	469	struct gpio_desc **desc_array,
@@ -471,41 +471,41 @@ static inline int gpiod_set_raw_array_value_cansleep(unsigned int array_size, · 1 unmodified line
471	471	unsigned long *value_bitmap)
472	472	{
473	473	/* GPIO can never have been requested */
474		− WARN_ON(1);
	474	+ WARN_ON(desc_array);
475	475	return 0;
476	476	}
477	477
478	478	static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
479	479	{
480	480	/* GPIO can never have been requested */
481		− WARN_ON(1);
	481	+ WARN_ON(desc);
482	482	return -ENOSYS;
483	483	}
484	484
485	485	static inline int gpiod_set_transitory(struct gpio_desc *desc, bool transitory)
486	486	{
487	487	/* GPIO can never have been requested */
488		− WARN_ON(1);
	488	+ WARN_ON(desc);
489	489	return -ENOSYS;
490	490	}
491	491
492	492	static inline int gpiod_is_active_low(const struct gpio_desc *desc)
493	493	{
494	494	/* GPIO can never have been requested */
495		− WARN_ON(1);
	495	+ WARN_ON(desc);
496	496	return 0;
497	497	}
498	498	static inline int gpiod_cansleep(const struct gpio_desc *desc)
499	499	{
500	500	/* GPIO can never have been requested */
501		− WARN_ON(1);
	501	+ WARN_ON(desc);
502	502	return 0;
503	503	}
504	504
505	505	static inline int gpiod_to_irq(const struct gpio_desc *desc)
506	506	{
507	507	/* GPIO can never have been requested */
508		− WARN_ON(1);
	508	+ WARN_ON(desc);
509	509	return -EINVAL;
510	510	}
511	511
@@ -513,7 +513,7 @@ static inline int gpiod_set_consumer_name(struct gpio_desc *desc, · 1 unmodified line
513	513	const char *name)
514	514	{
515	515	/* GPIO can never have been requested */
516		− WARN_ON(1);
	516	+ WARN_ON(desc);
517	517	return -EINVAL;
518	518	}
519	519
@@ -525,7 +525,7 @@ static inline struct gpio_desc *gpio_to_desc(unsigned gpio) · 5 unmodified lines
525	525	static inline int desc_to_gpio(const struct gpio_desc *desc)
526	526	{
527	527	/* GPIO can never have been requested */
528		− WARN_ON(1);
	528	+ WARN_ON(desc);
529	529	return -EINVAL;
530	530	}
531	531

include/linux/hmm.h+0−54

@@ -484,60 +484,6 @@ long hmm_range_dma_unmap(struct hmm_range *range, · 483 unmodified lines
484	484	*/
485	485	#define HMM_RANGE_DEFAULT_TIMEOUT 1000
486	486
487		−/* This is a temporary helper to avoid merge conflict between trees. */
488		−static inline bool hmm_vma_range_done(struct hmm_range *range)
489		−{
490		− bool ret = hmm_range_valid(range);
491		−
492		− hmm_range_unregister(range);
493		− return ret;
494		−}
495		−
496		−/* This is a temporary helper to avoid merge conflict between trees. */
497		−static inline int hmm_vma_fault(struct hmm_mirror *mirror,
498		− struct hmm_range *range, bool block)
499		−{
500		− long ret;
501		−
502		− /*
503		− * With the old API the driver must set each individual entries with
504		− * the requested flags (valid, write, ...). So here we set the mask to
505		− * keep intact the entries provided by the driver and zero out the
506		− * default_flags.
507		− */
508		− range->default_flags = 0;
509		− range->pfn_flags_mask = -1UL;
510		−
511		− ret = hmm_range_register(range, mirror,
512		− range->start, range->end,
513		− PAGE_SHIFT);
514		− if (ret)
515		− return (int)ret;
516		−
517		− if (!hmm_range_wait_until_valid(range, HMM_RANGE_DEFAULT_TIMEOUT)) {
518		− /*
519		− * The mmap_sem was taken by driver we release it here and
520		− * returns -EAGAIN which correspond to mmap_sem have been
521		− * drop in the old API.
522		− */
523		− up_read(&range->vma->vm_mm->mmap_sem);
524		− return -EAGAIN;
525		− }
526		−
527		− ret = hmm_range_fault(range, block);
528		− if (ret <= 0) {
529		− if (ret == -EBUSY \|\| !ret) {
530		− /* Same as above, drop mmap_sem to match old API. */
531		− up_read(&range->vma->vm_mm->mmap_sem);
532		− ret = -EBUSY;
533		− } else if (ret == -EAGAIN)
534		− ret = -EBUSY;
535		− hmm_range_unregister(range);
536		− return ret;
537		− }
538		− return 0;
539		−}
540		−
541	487	/* Below are for HMM internal use only! Not to be used by device driver! */
542	488	static inline void hmm_mm_init(struct mm_struct *mm)
543	489	{

include/linux/if_pppox.h+3−0

@@ -80,6 +80,9 @@ extern int register_pppox_proto(int proto_num, const struct pppox_proto *pp); · 79 unmodified lines
80	80	extern void unregister_pppox_proto(int proto_num);
81	81	extern void pppox_unbind_sock(struct sock sk);/ delete ppp-channel binding */
82	82	extern int pppox_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg);
	83	+extern int pppox_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg);
	84	+
	85	+#define PPPOEIOCSFWD32 _IOW(0xB1 ,0, compat_size_t)
83	86
84	87	/* PPPoX socket states */
85	88	enum {

include/linux/if_rmnet.h+2−2

@@ -41,11 +41,11 @@ struct rmnet_map_ul_csum_header { · 40 unmodified lines
41	41	__be16 csum_start_offset;
42	42	#if defined(__LITTLE_ENDIAN_BITFIELD)
43	43	u16 csum_insert_offset:14;
44		− u16 udp_ip4_ind:1;
	44	+ u16 udp_ind:1;
45	45	u16 csum_enabled:1;
46	46	#elif defined (__BIG_ENDIAN_BITFIELD)
47	47	u16 csum_enabled:1;
48		− u16 udp_ip4_ind:1;
	48	+ u16 udp_ind:1;
49	49	u16 csum_insert_offset:14;
50	50	#else
51	51	#error "Please fix <asm/byteorder.h>"

include/linux/intel_th.h+79−0

@@ -0,0 +1,79 @@
	1	+/* SPDX-License-Identifier: GPL-2.0 */
	2	+/*
	3	+ * Intel(R) Trace Hub data structures for implementing buffer sinks.
	4	+ *
	5	+ * Copyright (C) 2019 Intel Corporation.
	6	+ */
	7	+
	8	+#ifndef _INTEL_TH_H_
	9	+#define _INTEL_TH_H_
	10	+
	11	+#include <linux/scatterlist.h>
	12	+
	13	+/* MSC operating modes (MSC_MODE) */
	14	+enum {
	15	+ MSC_MODE_SINGLE = 0,
	16	+ MSC_MODE_MULTI,
	17	+ MSC_MODE_EXI,
	18	+ MSC_MODE_DEBUG,
	19	+};
	20	+
	21	+struct msu_buffer {
	22	+ const char *name;
	23	+ /*
	24	+ * ->assign() called when buffer 'mode' is set to this driver
	25	+ * (aka mode_store())
	26	+ * @device: struct device * of the msc
	27	+ * @mode: allows the driver to set HW mode (see the enum above)
	28	+ * Returns: a pointer to a private structure associated with this
	29	+ * msc or NULL in case of error. This private structure
	30	+ * will then be passed into all other callbacks.
	31	+ */
	32	+ void (assign)(struct device dev, int mode);
	33	+ /* ->unassign(): some other mode is selected, clean up */
	34	+ void (unassign)(void priv);
	35	+ /*
	36	+ * ->alloc_window(): allocate memory for the window of a given
	37	+ * size
	38	+ * @sgt: pointer to sg_table, can be overridden by the buffer
	39	+ * driver, or kept intact
	40	+ * Returns: number of sg table entries <= number of pages;
	41	+ * 0 is treated as an allocation failure.
	42	+ */
	43	+ int (alloc_window)(void priv, struct sg_table **sgt,
	44	+ size_t size);
	45	+ void (free_window)(void priv, struct sg_table *sgt);
	46	+ /* ->activate(): trace has started */
	47	+ void (activate)(void priv);
	48	+ /* ->deactivate(): trace is about to stop */
	49	+ void (deactivate)(void priv);
	50	+ /*
	51	+ * ->ready(): window @sgt is filled up to the last block OR
	52	+ * tracing is stopped by the user; this window contains
	53	+ * @bytes data. The window in question transitions into
	54	+ * the "LOCKED" state, indicating that it can't be used
	55	+ * by hardware. To clear this state and make the window
	56	+ * available to the hardware again, call
	57	+ * intel_th_msc_window_unlock().
	58	+ */
	59	+ int (ready)(void priv, struct sg_table *sgt, size_t bytes);
	60	+};
	61	+
	62	+int intel_th_msu_buffer_register(const struct msu_buffer *mbuf,
	63	+ struct module *owner);
	64	+void intel_th_msu_buffer_unregister(const struct msu_buffer *mbuf);
	65	+void intel_th_msc_window_unlock(struct device dev, struct sg_table sgt);
	66	+
	67	+#define module_intel_th_msu_buffer(__buffer) \
	68	+static int __init __buffer##_init(void) \
	69	+{ \
	70	+ return intel_th_msu_buffer_register(&(__buffer), THIS_MODULE); \
	71	+} \
	72	+module_init(__buffer##_init); \
	73	+static void __exit __buffer##_exit(void) \
	74	+{ \
	75	+ intel_th_msu_buffer_unregister(&(__buffer)); \
	76	+} \
	77	+module_exit(__buffer##_exit);
	78	+
	79	+#endif /* _INTEL_TH_H_ */

include/linux/iova.h+6−0

@@ -155,6 +155,7 @@ struct iova reserve_iova(struct iova_domain iovad, unsigned long pfn_lo, · 154 unmodified lines
155	155	void copy_reserved_iova(struct iova_domain from, struct iova_domain to);
156	156	void init_iova_domain(struct iova_domain *iovad, unsigned long granule,
157	157	unsigned long start_pfn);
	158	+bool has_iova_flush_queue(struct iova_domain *iovad);
158	159	int init_iova_flush_queue(struct iova_domain *iovad,
159	160	iova_flush_cb flush_cb, iova_entry_dtor entry_dtor);
160	161	struct iova find_iova(struct iova_domain iovad, unsigned long pfn);
@@ -235,6 +236,11 @@ static inline void init_iova_domain(struct iova_domain *iovad, · 74 unmodified lines
235	236	{
236	237	}
237	238
	239	+static inline bool has_iova_flush_queue(struct iova_domain *iovad)
	240	+{
	241	+ return false;
	242	+}
	243	+
238	244	static inline int init_iova_flush_queue(struct iova_domain *iovad,
239	245	iova_flush_cb flush_cb,
240	246	iova_entry_dtor entry_dtor)

include/linux/key.h+4−4

@@ -94,11 +94,11 @@ struct keyring_index_key { · 93 unmodified lines
94	94	union {
95	95	struct {
96	96	#ifdef __LITTLE_ENDIAN /* Put desc_len at the LSB of x */
97		− u8 desc_len;
98		− char desc[sizeof(long) - 1]; /* First few chars of description */
	97	+ u16 desc_len;
	98	+ char desc[sizeof(long) - 2]; /* First few chars of description */
99	99	#else
100		− char desc[sizeof(long) - 1]; /* First few chars of description */
101		− u8 desc_len;
	100	+ char desc[sizeof(long) - 2]; /* First few chars of description */
	101	+ u16 desc_len;
102	102	#endif
103	103	};
104	104	unsigned long x;

include/linux/kvm_host.h+4−2

@@ -861,8 +861,9 @@ int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu); · 860 unmodified lines
861	861	void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu);
862	862	void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu);
863	863
864		−bool kvm_arch_has_vcpu_debugfs(void);
865		−int kvm_arch_create_vcpu_debugfs(struct kvm_vcpu *vcpu);
	864	+#ifdef __KVM_HAVE_ARCH_VCPU_DEBUGFS
	865	+void kvm_arch_create_vcpu_debugfs(struct kvm_vcpu *vcpu);
	866	+#endif
866	867
867	868	int kvm_arch_hardware_enable(void);
868	869	void kvm_arch_hardware_disable(void);
@@ -872,6 +873,7 @@ int kvm_arch_check_processor_compat(void); · 3 unmodified lines
872	873	int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu);
873	874	bool kvm_arch_vcpu_in_kernel(struct kvm_vcpu *vcpu);
874	875	int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu);
	876	+bool kvm_arch_dy_runnable(struct kvm_vcpu *vcpu);
875	877
876	878	#ifndef __KVM_HAVE_ARCH_VM_ALLOC
877	879	/*

include/linux/logic_pio.h+1−0

@@ -117,6 +117,7 @@ struct logic_pio_hwaddr find_io_range_by_fwnode(struct fwnode_handle fwnode); · 116 unmodified lines
117	117	unsigned long logic_pio_trans_hwaddr(struct fwnode_handle *fwnode,
118	118	resource_size_t hw_addr, resource_size_t size);
119	119	int logic_pio_register_range(struct logic_pio_hwaddr *newrange);
	120	+void logic_pio_unregister_range(struct logic_pio_hwaddr *range);
120	121	resource_size_t logic_pio_to_hwaddr(unsigned long pio);
121	122	unsigned long logic_pio_trans_cpuaddr(resource_size_t hw_addr);
122	123

include/linux/memcontrol.h+19−0

@@ -668,6 +668,7 @@ static inline unsigned long lruvec_page_state_local(struct lruvec *lruvec, · 667 unmodified lines
668	668
669	669	void __mod_lruvec_state(struct lruvec *lruvec, enum node_stat_item idx,
670	670	int val);
	671	+void __mod_lruvec_slab_state(void *p, enum node_stat_item idx, int val);
671	672
672	673	static inline void mod_lruvec_state(struct lruvec *lruvec,
673	674	enum node_stat_item idx, int val)
@@ -1072,6 +1073,14 @@ static inline void mod_lruvec_page_state(struct page *page, · 398 unmodified lines
1072	1073	mod_node_page_state(page_pgdat(page), idx, val);
1073	1074	}
1074	1075
	1076	+static inline void __mod_lruvec_slab_state(void *p, enum node_stat_item idx,
	1077	+ int val)
	1078	+{
	1079	+ struct page *page = virt_to_head_page(p);
	1080	+
	1081	+ __mod_node_page_state(page_pgdat(page), idx, val);
	1082	+}
	1083	+
1075	1084	static inline
1076	1085	unsigned long mem_cgroup_soft_limit_reclaim(pg_data_t *pgdat, int order,
1077	1086	gfp_t gfp_mask,
@@ -1159,6 +1168,16 @@ static inline void __dec_lruvec_page_state(struct page *page, · 81 unmodified lines
1159	1168	__mod_lruvec_page_state(page, idx, -1);
1160	1169	}
1161	1170
	1171	+static inline void __inc_lruvec_slab_state(void *p, enum node_stat_item idx)
	1172	+{
	1173	+ __mod_lruvec_slab_state(p, idx, 1);
	1174	+}
	1175	+
	1176	+static inline void __dec_lruvec_slab_state(void *p, enum node_stat_item idx)
	1177	+{
	1178	+ __mod_lruvec_slab_state(p, idx, -1);
	1179	+}
	1180	+
1162	1181	/* idx can be of type enum memcg_stat_item or node_stat_item */
1163	1182	static inline void inc_memcg_state(struct mem_cgroup *memcg,
1164	1183	int idx)

include/linux/mempolicy.h+2−0

@@ -139,6 +139,8 @@ struct mempolicy mpol_shared_policy_lookup(struct shared_policy sp, · 138 unmodified lines
139	139	struct mempolicy get_task_policy(struct task_struct p);
140	140	struct mempolicy __get_vma_policy(struct vm_area_struct vma,
141	141	unsigned long addr);
	142	+struct mempolicy get_vma_policy(struct vm_area_struct vma,
	143	+ unsigned long addr);
142	144	bool vma_policy_mof(struct vm_area_struct *vma);
143	145
144	146	extern void numa_default_policy(void);

include/linux/mlx5/device.h+2−2

@@ -446,11 +446,11 @@ enum { · 445 unmodified lines
446	446	};
447	447
448	448	enum {
449		− MLX5_OPC_MOD_TLS_TIS_STATIC_PARAMS = 0x20,
	449	+ MLX5_OPC_MOD_TLS_TIS_STATIC_PARAMS = 0x1,
450	450	};
451	451
452	452	enum {
453		− MLX5_OPC_MOD_TLS_TIS_PROGRESS_PARAMS = 0x20,
	453	+ MLX5_OPC_MOD_TLS_TIS_PROGRESS_PARAMS = 0x1,
454	454	};
455	455
456	456	enum {

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

@@ -220,6 +220,7 @@ int mlx5_modify_rule_destination(struct mlx5_flow_handle *handler, · 219 unmodified lines
220	220
221	221	struct mlx5_fc mlx5_fc_create(struct mlx5_core_dev dev, bool aging);
222	222	void mlx5_fc_destroy(struct mlx5_core_dev dev, struct mlx5_fc counter);
	223	+u64 mlx5_fc_query_lastuse(struct mlx5_fc *counter);
223	224	void mlx5_fc_query_cached(struct mlx5_fc *counter,
224	225	u64 bytes, u64 packets, u64 *lastuse);
225	226	int mlx5_fc_query(struct mlx5_core_dev dev, struct mlx5_fc counter,

include/linux/mlx5/mlx5_ifc.h+6−5

@@ -5975,10 +5975,12 @@ struct mlx5_ifc_modify_cq_in_bits { · 5974 unmodified lines
5975	5975
5976	5976	struct mlx5_ifc_cqc_bits cq_context;
5977	5977
5978		− u8 reserved_at_280[0x40];
	5978	+ u8 reserved_at_280[0x60];
5979	5979
5980	5980	u8 cq_umem_valid[0x1];
5981		− u8 reserved_at_2c1[0x5bf];
	5981	+ u8 reserved_at_2e1[0x1f];
	5982	+
	5983	+ u8 reserved_at_300[0x580];
5982	5984
5983	5985	u8 pas[0][0x40];
5984	5986	};
@@ -10052,9 +10054,8 @@ struct mlx5_ifc_tls_static_params_bits { · 4067 unmodified lines
10052	10054	};
10053	10055
10054	10056	struct mlx5_ifc_tls_progress_params_bits {
10055		− u8 valid[0x1];
10056		− u8 reserved_at_1[0x7];
10057		− u8 pd[0x18];
	10057	+ u8 reserved_at_0[0x8];
	10058	+ u8 tisn[0x18];
10058	10059
10059	10060	u8 next_record_tcp_sn[0x20];
10060	10061

include/linux/mm_types.h+10−1

@@ -159,7 +159,16 @@ struct page { · 158 unmodified lines
159	159	/** @pgmap: Points to the hosting device page map. */
160	160	struct dev_pagemap *pgmap;
161	161	void *zone_device_data;
162		− unsigned long _zd_pad_1; /* uses mapping */
	162	+ /*
	163	+ * ZONE_DEVICE private pages are counted as being
	164	+ * mapped so the next 3 words hold the mapping, index,
	165	+ * and private fields from the source anonymous or
	166	+ * page cache page while the page is migrated to device
	167	+ * private memory.
	168	+ * ZONE_DEVICE MEMORY_DEVICE_FS_DAX pages also
	169	+ * use the mapping, index, and private fields when
	170	+ * pmem backed DAX files are mapped.
	171	+ */
163	172	};
164	173
165	174	/** @rcu_head: You can use this to free a page by RCU. */

include/linux/mmzone.h+3−2

@@ -215,8 +215,9 @@ enum node_stat_item { · 214 unmodified lines
215	215	NR_INACTIVE_FILE, /* " " " " " */
216	216	NR_ACTIVE_FILE, /* " " " " " */
217	217	NR_UNEVICTABLE, /* " " " " " */
218		− NR_SLAB_RECLAIMABLE,
219		− NR_SLAB_UNRECLAIMABLE,
	218	+ NR_SLAB_RECLAIMABLE, /* Please do not reorder this item */
	219	+ NR_SLAB_UNRECLAIMABLE, /* and this one without looking at
	220	+ * memcg_flush_percpu_vmstats() first. */
220	221	NR_ISOLATED_ANON, /* Temporary isolated pages from anon lru */
221	222	NR_ISOLATED_FILE, /* Temporary isolated pages from file lru */
222	223	WORKINGSET_NODES,

include/linux/mod_devicetable.h+1−0

@@ -814,6 +814,7 @@ struct tee_client_device_id { · 813 unmodified lines
814	814	/**
815	815	* struct wmi_device_id - WMI device identifier
816	816	* @guid_string: 36 char string of the form fa50ff2b-f2e8-45de-83fa-65417f2f49ba
	817	+ * @context: pointer to driver specific data
817	818	*/
818	819	struct wmi_device_id {
819	820	const char guid_string[UUID_STRING_LEN+1];

include/linux/netfilter/nf_conntrack_h323_asn1.h+1−2

@@ -1,7 +1,6 @@
1	1	/* SPDX-License-Identifier: GPL-2.0-only */
2	2	/****************************************************************************
3		− * ip_conntrack_h323_asn1.h - BER and PER decoding library for H.323
4		− * conntrack/NAT module.
	3	+ * BER and PER decoding library for H.323 conntrack/NAT module.
5	4	*
6	5	* Copyright (c) 2006 by Jing Min Zhao <zhaojingmin@users.sourceforge.net>
7	6	*

include/linux/netfilter/nf_conntrack_h323_types.h+5−0

@@ -4,6 +4,9 @@ · 3 unmodified lines
4	4	* Copyright (c) 2006 Jing Min Zhao <zhaojingmin@users.sourceforge.net>
5	5	*/
6	6
	7	+#ifndef _NF_CONNTRACK_H323_TYPES_H
	8	+#define _NF_CONNTRACK_H323_TYPES_H
	9	+
7	10	typedef struct TransportAddress_ipAddress { /* SEQUENCE */
8	11	int options; /* No use */
9	12	unsigned int ip;
@@ -931,3 +934,5 @@ typedef struct RasMessage { /* CHOICE */ · 921 unmodified lines
931	934	InfoRequestResponse infoRequestResponse;
932	935	};
933	936	} RasMessage;
	937	+
	938	+#endif /* _NF_CONNTRACK_H323_TYPES_H */

include/linux/of.h+1−1

@@ -1164,7 +1164,7 @@ static inline int of_property_read_string_index(const struct device_node *np, · 1163 unmodified lines
1164	1164	}
1165	1165
1166	1166	/**
1167		− * of_property_read_bool - Findfrom a property
	1167	+ * of_property_read_bool - Find a property
1168	1168	* @np: device node from which the property value is to be read.
1169	1169	* @propname: name of the property to be searched.
1170	1170	*

include/linux/page-flags-layout.h+11−7

@@ -32,6 +32,7 @@ · 31 unmodified lines
32	32
33	33	#endif /* CONFIG_SPARSEMEM */
34	34
	35	+#ifndef BUILD_VDSO32_64
35	36	/*
36	37	* page->flags layout:
37	38	*
@@ -76,20 +77,22 @@ · 38 unmodified lines
76	77	#define LAST_CPUPID_SHIFT 0
77	78	#endif
78	79
79		−#if SECTIONS_WIDTH+ZONES_WIDTH+NODES_SHIFT+LAST_CPUPID_SHIFT <= BITS_PER_LONG - NR_PAGEFLAGS
	80	+#ifdef CONFIG_KASAN_SW_TAGS
	81	+#define KASAN_TAG_WIDTH 8
	82	+#else
	83	+#define KASAN_TAG_WIDTH 0
	84	+#endif
	85	+
	86	+#if SECTIONS_WIDTH+ZONES_WIDTH+NODES_SHIFT+LAST_CPUPID_SHIFT+KASAN_TAG_WIDTH \
	87	+ <= BITS_PER_LONG - NR_PAGEFLAGS
80	88	#define LAST_CPUPID_WIDTH LAST_CPUPID_SHIFT
81	89	#else
82	90	#define LAST_CPUPID_WIDTH 0
83	91	#endif
84	92
85		−#ifdef CONFIG_KASAN_SW_TAGS
86		−#define KASAN_TAG_WIDTH 8
87	93	#if SECTIONS_WIDTH+NODES_WIDTH+ZONES_WIDTH+LAST_CPUPID_WIDTH+KASAN_TAG_WIDTH \
88	94	> BITS_PER_LONG - NR_PAGEFLAGS
89		−#error "KASAN: not enough bits in page flags for tag"
90		−#endif
91		−#else
92		−#define KASAN_TAG_WIDTH 0
	95	+#error "Not enough bits in page flags"
93	96	#endif
94	97
95	98	/*
@@ -104,4 +107,5 @@ · 8 unmodified lines
104	107	#define LAST_CPUPID_NOT_IN_PAGE_FLAGS
105	108	#endif
106	109
	110	+#endif
107	111	#endif /* _LINUX_PAGE_FLAGS_LAYOUT */

include/linux/page-flags.h+4−0

@@ -152,6 +152,8 @@ enum pageflags { · 151 unmodified lines
152	152	PG_savepinned = PG_dirty,
153	153	/* Has a grant mapping of another (foreign) domain's page. */
154	154	PG_foreign = PG_owner_priv_1,
	155	+ /* Remapped by swiotlb-xen. */
	156	+ PG_xen_remapped = PG_owner_priv_1,
155	157
156	158	/* SLOB */
157	159	PG_slob_free = PG_private,
@@ -329,6 +331,8 @@ PAGEFLAG(Pinned, pinned, PF_NO_COMPOUND) · 171 unmodified lines
329	331	TESTSCFLAG(Pinned, pinned, PF_NO_COMPOUND)
330	332	PAGEFLAG(SavePinned, savepinned, PF_NO_COMPOUND);
331	333	PAGEFLAG(Foreign, foreign, PF_NO_COMPOUND);
	334	+PAGEFLAG(XenRemapped, xen_remapped, PF_NO_COMPOUND)
	335	+ TESTCLEARFLAG(XenRemapped, xen_remapped, PF_NO_COMPOUND)
332	336
333	337	PAGEFLAG(Reserved, reserved, PF_NO_COMPOUND)
334	338	__CLEARPAGEFLAG(Reserved, reserved, PF_NO_COMPOUND)

include/linux/pci.h+2−0

@@ -1567,8 +1567,10 @@ extern bool pcie_ports_native; · 1566 unmodified lines
1567	1567
1568	1568	#ifdef CONFIG_PCIEASPM
1569	1569	bool pcie_aspm_support_enabled(void);
	1570	+bool pcie_aspm_enabled(struct pci_dev *pdev);
1570	1571	#else
1571	1572	static inline bool pcie_aspm_support_enabled(void) { return false; }
	1573	+static inline bool pcie_aspm_enabled(struct pci_dev *pdev) { return false; }
1572	1574	#endif
1573	1575
1574	1576	#ifdef CONFIG_PCIEAER

include/linux/phy.h+1−0

@@ -1107,6 +1107,7 @@ int genphy_c45_an_disable_aneg(struct phy_device *phydev); · 1106 unmodified lines
1107	1107	int genphy_c45_read_mdix(struct phy_device *phydev);
1108	1108	int genphy_c45_pma_read_abilities(struct phy_device *phydev);
1109	1109	int genphy_c45_read_status(struct phy_device *phydev);
	1110	+int genphy_c45_config_aneg(struct phy_device *phydev);
1110	1111
1111	1112	/* The gen10g_* functions are the old Clause 45 stub */
1112	1113	int gen10g_config_aneg(struct phy_device *phydev);

include/linux/sched.h+9−1

@@ -1092,7 +1092,15 @@ struct task_struct { · 1091 unmodified lines
1092	1092	u64 last_sum_exec_runtime;
1093	1093	struct callback_head numa_work;
1094	1094
1095		− struct numa_group *numa_group;
	1095	+ /*
	1096	+ * This pointer is only modified for current in syscall and
	1097	+ * pagefault context (and for tasks being destroyed), so it can be read
	1098	+ * from any of the following contexts:
	1099	+ * - RCU read-side critical section
	1100	+ * - current->numa_group from everywhere
	1101	+ * - task's runqueue locked, task not running
	1102	+ */
	1103	+ struct numa_group __rcu *numa_group;
1096	1104
1097	1105	/*
1098	1106	* numa_faults is an array split into four regions:

include/linux/sched/numa_balancing.h+2−2

@@ -19,7 +19,7 @@ · 18 unmodified lines
19	19	extern void task_numa_fault(int last_node, int node, int pages, int flags);
20	20	extern pid_t task_numa_group_id(struct task_struct *p);
21	21	extern void set_numabalancing_state(bool enabled);
22		−extern void task_numa_free(struct task_struct *p);
	22	+extern void task_numa_free(struct task_struct *p, bool final);
23	23	extern bool should_numa_migrate_memory(struct task_struct p, struct page page,
24	24	int src_nid, int dst_cpu);
25	25	#else
@@ -34,7 +34,7 @@ static inline pid_t task_numa_group_id(struct task_struct *p) · 8 unmodified lines
34	34	static inline void set_numabalancing_state(bool enabled)
35	35	{
36	36	}
37		−static inline void task_numa_free(struct task_struct *p)
	37	+static inline void task_numa_free(struct task_struct *p, bool final)
38	38	{
39	39	}
40	40	static inline bool should_numa_migrate_memory(struct task_struct *p,

include/linux/signal.h+14−1

@@ -282,6 +282,9 @@ extern void signal_setup_done(int failed, struct ksignal *ksig, int stepping); · 281 unmodified lines
282	282	extern void exit_signals(struct task_struct *tsk);
283	283	extern void kernel_sigaction(int, __sighandler_t);
284	284
	285	+#define SIG_KTHREAD ((__force __sighandler_t)2)
	286	+#define SIG_KTHREAD_KERNEL ((__force __sighandler_t)3)
	287	+
285	288	static inline void allow_signal(int sig)
286	289	{
287	290	/*
@@ -289,7 +292,17 @@ static inline void allow_signal(int sig) · 1 unmodified line
289	292	* know it'll be handled, so that they don't get converted to
290	293	* SIGKILL or just silently dropped.
291	294	*/
292		− kernel_sigaction(sig, (__force __sighandler_t)2);
	295	+ kernel_sigaction(sig, SIG_KTHREAD);
	296	+}
	297	+
	298	+static inline void allow_kernel_signal(int sig)
	299	+{
	300	+ /*
	301	+ * Kernel threads handle their own signals. Let the signal code
	302	+ * know signals sent by the kernel will be handled, so that they
	303	+ * don't get silently dropped.
	304	+ */
	305	+ kernel_sigaction(sig, SIG_KTHREAD_KERNEL);
293	306	}
294	307
295	308	static inline void disallow_signal(int sig)

include/linux/skbuff.h+8−0

@@ -1374,6 +1374,14 @@ static inline void skb_copy_hash(struct sk_buff to, const struct sk_buff from) · 1373 unmodified lines
1374	1374	to->l4_hash = from->l4_hash;
1375	1375	};
1376	1376
	1377	+static inline void skb_copy_decrypted(struct sk_buff *to,
	1378	+ const struct sk_buff *from)
	1379	+{
	1380	+#ifdef CONFIG_TLS_DEVICE
	1381	+ to->decrypted = from->decrypted;
	1382	+#endif
	1383	+}
	1384	+
1377	1385	#ifdef NET_SKBUFF_DATA_USES_OFFSET
1378	1386	static inline unsigned char skb_end_pointer(const struct sk_buff skb)
1379	1387	{

include/linux/skmsg.h+7−1

@@ -354,7 +354,13 @@ static inline void sk_psock_restore_proto(struct sock *sk, · 353 unmodified lines
354	354	sk->sk_write_space = psock->saved_write_space;
355	355
356	356	if (psock->sk_proto) {
357		− sk->sk_prot = psock->sk_proto;
	357	+ struct inet_connection_sock *icsk = inet_csk(sk);
	358	+ bool has_ulp = !!icsk->icsk_ulp_data;
	359	+
	360	+ if (has_ulp)
	361	+ tcp_update_ulp(sk, psock->sk_proto);
	362	+ else
	363	+ sk->sk_prot = psock->sk_proto;
358	364	psock->sk_proto = NULL;
359	365	}
360	366	}

include/linux/socket.h+3−0

@@ -292,6 +292,9 @@ struct ucred { · 291 unmodified lines
292	292	#define MSG_BATCH 0x40000 /* sendmmsg(): more messages coming */
293	293	#define MSG_EOF MSG_FIN
294	294	#define MSG_NO_SHARED_FRAGS 0x80000 /* sendpage() internal : page frags are not shared */
	295	+#define MSG_SENDPAGE_DECRYPTED 0x100000 /* sendpage() internal : page may carry
	296	+ * plain text and require encryption
	297	+ */
295	298
296	299	#define MSG_ZEROCOPY 0x4000000 /* Use user data in kernel path */
297	300	#define MSG_FASTOPEN 0x20000000 /* Send data in TCP SYN */

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

@@ -98,7 +98,6 @@ typedef void (rpc_action)(struct rpc_task ); · 97 unmodified lines
98	98
99	99	struct rpc_call_ops {
100	100	void (rpc_call_prepare)(struct rpc_task , void *);
101		− void (rpc_call_prepare_transmit)(struct rpc_task , void *);
102	101	void (rpc_call_done)(struct rpc_task , void *);
103	102	void (rpc_count_stats)(struct rpc_task , void *);
104	103	void (rpc_release)(void );

include/linux/timekeeper_internal.h+5−0

@@ -57,6 +57,7 @@ struct tk_read_base { · 56 unmodified lines
57	57	* @cs_was_changed_seq: The sequence number of clocksource change events
58	58	* @next_leap_ktime: CLOCK_MONOTONIC time value of a pending leap-second
59	59	* @raw_sec: CLOCK_MONOTONIC_RAW time in seconds
	60	+ * @monotonic_to_boot: CLOCK_MONOTONIC to CLOCK_BOOTTIME offset
60	61	* @cycle_interval: Number of clock cycles in one NTP interval
61	62	* @xtime_interval: Number of clock shifted nano seconds in one NTP
62	63	* interval.
@@ -84,6 +85,9 @@ struct tk_read_base { · 21 unmodified lines
84	85	*
85	86	* wall_to_monotonic is no longer the boot time, getboottime must be
86	87	* used instead.
	88	+ *
	89	+ * @monotonic_to_boottime is a timespec64 representation of @offs_boot to
	90	+ * accelerate the VDSO update for CLOCK_BOOTTIME.
87	91	*/
88	92	struct timekeeper {
89	93	struct tk_read_base tkr_mono;
@@ -99,6 +103,7 @@ struct timekeeper { · 9 unmodified lines
99	103	u8 cs_was_changed_seq;
100	104	ktime_t next_leap_ktime;
101	105	u64 raw_sec;
	106	+ struct timespec64 monotonic_to_boot;
102	107
103	108	/* The following members are for timekeeping internal use */
104	109	u64 cycle_interval;

include/linux/trace_events.h+1−0

@@ -548,6 +548,7 @@ extern int trace_event_get_offsets(struct trace_event_call *call); · 547 unmodified lines
548	548
549	549	#define is_signed_type(type) (((type)(-1)) < (type)1)
550	550
	551	+int ftrace_set_clr_event(struct trace_array tr, char buf, int set);
551	552	int trace_set_clr_event(const char system, const char event, int set);
552	553
553	554	/*

include/linux/usb.h+1−1

@@ -1457,7 +1457,7 @@ typedef void (usb_complete_t)(struct urb ); · 1456 unmodified lines
1457	1457	* field rather than determining a dma address themselves.
1458	1458	*
1459	1459	* Note that transfer_buffer must still be set if the controller
1460		− * does not support DMA (as indicated by bus.uses_dma) and when talking
	1460	+ * does not support DMA (as indicated by hcd_uses_dma()) and when talking
1461	1461	* to root hub. If you have to trasfer between highmem zone and the device
1462	1462	* on such controller, create a bounce buffer or bail out with an error.
1463	1463	* If transfer_buffer cannot be set (is in highmem) and the controller is DMA

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

@@ -422,6 +422,9 @@ static inline bool hcd_periodic_completion_in_progress(struct usb_hcd *hcd, · 421 unmodified lines
422	422	return hcd->high_prio_bh.completing_ep == ep;
423	423	}
424	424
	425	+#define hcd_uses_dma(hcd) \
	426	+ (IS_ENABLED(CONFIG_HAS_DMA) && (hcd)->self.uses_dma)
	427	+
425	428	extern int usb_hcd_link_urb_to_ep(struct usb_hcd hcd, struct urb urb);
426	429	extern int usb_hcd_check_unlink_urb(struct usb_hcd hcd, struct urb urb,
427	430	int status);

include/linux/wait.h+13−0

@@ -126,6 +126,19 @@ static inline int waitqueue_active(struct wait_queue_head *wq_head) · 125 unmodified lines
126	126	return !list_empty(&wq_head->head);
127	127	}
128	128
	129	+/**
	130	+ * wq_has_single_sleeper - check if there is only one sleeper
	131	+ * @wq_head: wait queue head
	132	+ *
	133	+ * Returns true of wq_head has only one sleeper on the list.
	134	+ *
	135	+ * Please refer to the comment for waitqueue_active.
	136	+ */
	137	+static inline bool wq_has_single_sleeper(struct wait_queue_head *wq_head)
	138	+{
	139	+ return list_is_singular(&wq_head->head);
	140	+}
	141	+
129	142	/**
130	143	* wq_has_sleeper - check if there are any waiting processes
131	144	* @wq_head: wait queue head

Merge branch 'char-misc-next' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc into fpga-dfl-for-5.4

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code