lael-labs/linux

include/linux/bpf.h+1−0

@@ -160,6 +160,7 @@ static inline void copy_map_value(struct bpf_map map, void dst, void *src) · 159 unmodified lines
160	}	160	}
161	void copy_map_value_locked(struct bpf_map map, void dst, void *src,	161	void copy_map_value_locked(struct bpf_map map, void dst, void *src,
162	bool lock_src);	162	bool lock_src);
		163	int bpf_obj_name_cpy(char dst, const char src, unsigned int size);
163		164
164	struct bpf_offload_dev;	165	struct bpf_offload_dev;
165	struct bpf_offloaded_map;	166	struct bpf_offloaded_map;

include/linux/ceph/messenger.h+4−3

 #endif /* CONFIG_BLOCK */
 		struct ceph_bvec_iter	bvec_pos;
 		struct {
-			struct page	**pages;	/* NOT OWNER. */
+			struct page	**pages;
 			size_t		length;		/* total # bytes */
 			unsigned int	alignment;	/* first page */
+			bool		own_pages;
 		};
 		struct ceph_pagelist	*pagelist;
 	};
 extern bool ceph_con_keepalive_expired(struct ceph_connection *con,
 				       unsigned long interval);
-extern void ceph_msg_data_add_pages(struct ceph_msg *msg, struct page **pages,
+void ceph_msg_data_add_pages(struct ceph_msg *msg, struct page **pages,
-				size_t length, size_t alignment);
+			     size_t length, size_t alignment, bool own_pages);
 extern void ceph_msg_data_add_pagelist(struct ceph_msg *msg,
 				struct ceph_pagelist *pagelist);
 #ifdef CONFIG_BLOCK

include/linux/ceph/osdmap.h+4−0

 #define CEPH_POOL_FLAG_HASHPSPOOL	(1ULL << 0) /* hash pg seed and pool id
 						       together */
 #define CEPH_POOL_FLAG_FULL		(1ULL << 1) /* pool is full */
+#define CEPH_POOL_FLAG_FULL_QUOTA	(1ULL << 10) /* pool ran out of quota,
+							will set FULL too */
+#define CEPH_POOL_FLAG_NEARFULL		(1ULL << 11) /* pool is nearfull */
 struct ceph_pg_pool_info {
 	struct rb_node node;
 extern const char *ceph_pg_pool_name_by_id(struct ceph_osdmap *map, u64 id);
 extern int ceph_pg_poolid_by_name(struct ceph_osdmap *map, const char *name);
+u64 ceph_pg_pool_flags(struct ceph_osdmap *map, u64 id);
 #endif

include/linux/ceph/rados.h+4−2

 /*
  * osd map flag bits
  */
-#define CEPH_OSDMAP_NEARFULL (1<<0)  /* sync writes (near ENOSPC) */
+#define CEPH_OSDMAP_NEARFULL (1<<0)  /* sync writes (near ENOSPC),
-#define CEPH_OSDMAP_FULL     (1<<1)  /* no data writes (ENOSPC) */
+					not set since ~luminous */
+#define CEPH_OSDMAP_FULL     (1<<1)  /* no data writes (ENOSPC),
+					not set since ~luminous */
 #define CEPH_OSDMAP_PAUSERD  (1<<2)  /* pause all reads */
 #define CEPH_OSDMAP_PAUSEWR  (1<<3)  /* pause all writes */
 #define CEPH_OSDMAP_PAUSEREC (1<<4)  /* pause recovery */

include/linux/cgroup.h+1−0

@@ -62,6 +62,7 @@ struct css_task_iter { · 61 unmodified lines
62	struct list_head *mg_tasks_head;	62	struct list_head *mg_tasks_head;
63	struct list_head *dying_tasks_head;	63	struct list_head *dying_tasks_head;
64		64
		65	struct list_head *cur_tasks_head;
65	struct css_set *cur_cset;	66	struct css_set *cur_cset;
66	struct css_set *cur_dcset;	67	struct css_set *cur_dcset;
67	struct task_struct *cur_task;	68	struct task_struct *cur_task;

include/linux/clk-provider.h+5−5

include/linux/dmar.h+9−5

 extern struct rw_semaphore dmar_global_lock;
 extern struct list_head dmar_drhd_units;
-#define for_each_drhd_unit(drhd) \
+#define for_each_drhd_unit(drhd)					\
-	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list)
+	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list,		\
+				dmar_rcu_check())
 #define for_each_active_drhd_unit(drhd)					\
-	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list)		\
+	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list,		\
+				dmar_rcu_check())			\
 		if (drhd->ignored) {} else
 #define for_each_active_iommu(i, drhd)					\
-	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list)		\
+	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list,		\
+				dmar_rcu_check())			\
 		if (i=drhd->iommu, drhd->ignored) {} else
 #define for_each_iommu(i, drhd)						\
-	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list)		\
+	list_for_each_entry_rcu(drhd, &dmar_drhd_units, list,		\
+				dmar_rcu_check())			\
 		if (i=drhd->iommu, 0) {} else
 static inline bool dmar_rcu_check(void)

include/linux/dsa/8021q.h+0−7

 int dsa_8021q_rx_source_port(u16 vid);
-struct sk_buff *dsa_8021q_remove_header(struct sk_buff *skb);
 #else
 int dsa_port_setup_8021q_tagging(struct dsa_switch *ds, int index,
 	return 0;
 }
-struct sk_buff *dsa_8021q_remove_header(struct sk_buff *skb)
-{
-	return NULL;
-}
 #endif /* IS_ENABLED(CONFIG_NET_DSA_TAG_8021Q) */
 #endif /* _NET_DSA_8021Q_H */

include/linux/file.h+1−0

@@ -85,6 +85,7 @@ extern int f_dupfd(unsigned int from, struct file *file, unsigned flags); · 84 unmodified lines
85	extern int replace_fd(unsigned fd, struct file *file, unsigned flags);	85	extern int replace_fd(unsigned fd, struct file *file, unsigned flags);
86	extern void set_close_on_exec(unsigned int fd, int flag);	86	extern void set_close_on_exec(unsigned int fd, int flag);
87	extern bool get_close_on_exec(unsigned int fd);	87	extern bool get_close_on_exec(unsigned int fd);
		88	extern int __get_unused_fd_flags(unsigned flags, unsigned long nofile);
88	extern int get_unused_fd_flags(unsigned flags);	89	extern int get_unused_fd_flags(unsigned flags);
89	extern void put_unused_fd(unsigned int fd);	90	extern void put_unused_fd(unsigned int fd);
90		91

include/linux/fs.h+1−0

@@ -698,6 +698,7 @@ struct inode { · 697 unmodified lines
698	struct rcu_head i_rcu;	698	struct rcu_head i_rcu;
699	};	699	};
700	atomic64_t i_version;	700	atomic64_t i_version;
		701	atomic64_t i_sequence; /* see futex */
701	atomic_t i_count;	702	atomic_t i_count;
702	atomic_t i_dio_count;	703	atomic_t i_dio_count;
703	atomic_t i_writecount;	704	atomic_t i_writecount;

include/linux/futex.h+10−7

 union futex_key {
 	struct {
+		u64 i_seq;
 		unsigned long pgoff;
-		struct inode *inode;
+		unsigned int offset;
-		int offset;
 	} shared;
 	struct {
+		union {
+			struct mm_struct *mm;
+			u64 __tmp;
+		};
 		unsigned long address;
-		struct mm_struct *mm;
+		unsigned int offset;
-		int offset;
 	} private;
 	struct {
+		u64 ptr;
 		unsigned long word;
-		void *ptr;
+		unsigned int offset;
-		int offset;
 	} both;
 };
-#define FUTEX_KEY_INIT (union futex_key) { .both = { .ptr = NULL } }
+#define FUTEX_KEY_INIT (union futex_key) { .both = { .ptr = 0ULL } }
 #ifdef CONFIG_FUTEX
 enum {

include/linux/genhd.h+1−12

 		!(disk->flags & GENHD_FL_NO_PART_SCAN);
 }
-static inline bool disk_has_partitions(struct gendisk *disk)
-{
-	bool ret = false;
-	rcu_read_lock();
-	if (rcu_dereference(disk->part_tbl)->len > 1)
-		ret = true;
-	rcu_read_unlock();
-	return ret;
-}
 static inline dev_t disk_devt(struct gendisk *disk)
 {
 	return MKDEV(disk->major, disk->first_minor);
 extern struct hd_struct *disk_map_sector_rcu(struct gendisk *disk,
 					     sector_t sector);
+bool disk_has_partitions(struct gendisk *disk);
 /*
  * Macros to operate on percpu disk statistics:

include/linux/i2c.h+2−2

@@ -506,7 +506,7 @@ i2c_register_board_info(int busnum, struct i2c_board_info const *info, · 505 unmodified lines
506	* @smbus_xfer_atomic: same as @smbus_xfer. Yet, only using atomic context	506	* @smbus_xfer_atomic: same as @smbus_xfer. Yet, only using atomic context
507	* so e.g. PMICs can be accessed very late before shutdown. Optional.	507	* so e.g. PMICs can be accessed very late before shutdown. Optional.
508	* @functionality: Return the flags that this algorithm/adapter pair supports	508	* @functionality: Return the flags that this algorithm/adapter pair supports
509	* from the I2C_FUNC_* flags.	509	* from the ``I2C_FUNC_*`` flags.
510	* @reg_slave: Register given client to I2C slave mode of this adapter	510	* @reg_slave: Register given client to I2C slave mode of this adapter
511	* @unreg_slave: Unregister given client from I2C slave mode of this adapter	511	* @unreg_slave: Unregister given client from I2C slave mode of this adapter
512	*	512	*
@@ -515,7 +515,7 @@ i2c_register_board_info(int busnum, struct i2c_board_info const *info, · 2 unmodified lines
515	* be addressed using the same bus algorithms - i.e. bit-banging or the PCF8584	515	* be addressed using the same bus algorithms - i.e. bit-banging or the PCF8584
516	* to name two of the most common.	516	* to name two of the most common.
517	*	517	*
518	* The return codes from the @master_xfer{_atomic} fields should indicate the	518	* The return codes from the ``master_xfer{_atomic}`` fields should indicate the
519	* type of error code that occurred during the transfer, as documented in the	519	* type of error code that occurred during the transfer, as documented in the
520	* Kernel Documentation file Documentation/i2c/fault-codes.rst.	520	* Kernel Documentation file Documentation/i2c/fault-codes.rst.
521	*/	521	*/

include/linux/ieee80211.h+2−2

@@ -2102,14 +2102,14 @@ ieee80211_he_spr_size(const u8 *he_spr_ie) · 2101 unmodified lines
2102	{	2102	{
2103	struct ieee80211_he_spr he_spr = (void )he_spr_ie;	2103	struct ieee80211_he_spr he_spr = (void )he_spr_ie;
2104	u8 spr_len = sizeof(struct ieee80211_he_spr);	2104	u8 spr_len = sizeof(struct ieee80211_he_spr);
2105	u32 he_spr_params;	2105	u8 he_spr_params;
2106		2106
2107	/* Make sure the input is not NULL */	2107	/* Make sure the input is not NULL */
2108	if (!he_spr_ie)	2108	if (!he_spr_ie)
2109	return 0;	2109	return 0;
2110		2110
2111	/* Calc required length */	2111	/* Calc required length */
2112	he_spr_params = le32_to_cpu(he_spr->he_sr_control);	2112	he_spr_params = he_spr->he_sr_control;
2113	if (he_spr_params & IEEE80211_HE_SPR_NON_SRG_OFFSET_PRESENT)	2113	if (he_spr_params & IEEE80211_HE_SPR_NON_SRG_OFFSET_PRESENT)
2114	spr_len++;	2114	spr_len++;
2115	if (he_spr_params & IEEE80211_HE_SPR_SRG_INFORMATION_PRESENT)	2115	if (he_spr_params & IEEE80211_HE_SPR_SRG_INFORMATION_PRESENT)

include/linux/inet_diag.h+12−6

 #ifndef _INET_DIAG_H_
 #define _INET_DIAG_H_ 1
+#include <net/netlink.h>
 #include <uapi/linux/inet_diag.h>
-struct net;
-struct sock;
 struct inet_hashinfo;
-struct nlattr;
-struct nlmsghdr;
-struct sk_buff;
-struct netlink_callback;
 struct inet_diag_handler {
 	void		(*dump)(struct sk_buff *skb,
 void inet_diag_msg_common_fill(struct inet_diag_msg *r, struct sock *sk);
+static inline size_t inet_diag_msg_attrs_size(void)
+{
+	return	  nla_total_size(1)  /* INET_DIAG_SHUTDOWN */
+		+ nla_total_size(1)  /* INET_DIAG_TOS */
+#if IS_ENABLED(CONFIG_IPV6)
+		+ nla_total_size(1)  /* INET_DIAG_TCLASS */
+		+ nla_total_size(1)  /* INET_DIAG_SKV6ONLY */
+#endif
+		+ nla_total_size(4)  /* INET_DIAG_MARK */
+		+ nla_total_size(4); /* INET_DIAG_CLASS_ID */
+}
 int inet_diag_msg_attrs_fill(struct sock *sk, struct sk_buff *skb,
 			     struct inet_diag_msg *r, int ext,
 			     struct user_namespace *user_ns, bool net_admin);

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

@@ -123,6 +123,8 @@ · 122 unmodified lines
123		123
124	#define dmar_readq(a) readq(a)	124	#define dmar_readq(a) readq(a)
125	#define dmar_writeq(a,v) writeq(v,a)	125	#define dmar_writeq(a,v) writeq(v,a)
		126	#define dmar_readl(a) readl(a)
		127	#define dmar_writel(a, v) writel(v, a)
126		128
127	#define DMAR_VER_MAJOR(v) (((v) & 0xf0) >> 4)	129	#define DMAR_VER_MAJOR(v) (((v) & 0xf0) >> 4)
128	#define DMAR_VER_MINOR(v) ((v) & 0x0f)	130	#define DMAR_VER_MINOR(v) ((v) & 0x0f)

include/linux/memcontrol.h+12−0

 void __mod_lruvec_state(struct lruvec *lruvec, enum node_stat_item idx,
 			int val);
 void __mod_lruvec_slab_state(void *p, enum node_stat_item idx, int val);
+void mod_memcg_obj_state(void *p, int idx, int val);
 static inline void mod_lruvec_state(struct lruvec *lruvec,
 				    enum node_stat_item idx, int val)
 	__mod_node_page_state(page_pgdat(page), idx, val);
 }
+static inline void mod_memcg_obj_state(void *p, int idx, int val)
+{
+}
 static inline
 unsigned long mem_cgroup_soft_limit_reclaim(pg_data_t *pgdat, int order,
 					    gfp_t gfp_mask,
 	return memcg ? memcg->kmemcg_id : -1;
 }
+struct mem_cgroup *mem_cgroup_from_obj(void *p);
 #else
 static inline int memcg_kmem_charge(struct page *page, gfp_t gfp, int order)
 {
 }
+static inline struct mem_cgroup *mem_cgroup_from_obj(void *p)
+{
+       return NULL;
+}
 #endif /* CONFIG_MEMCG_KMEM */
 #endif /* _LINUX_MEMCONTROL_H */

include/linux/mmc/host.h+1−0

@@ -333,6 +333,7 @@ struct mmc_host { · 332 unmodified lines
333	MMC_CAP_UHS_SDR50 \| MMC_CAP_UHS_SDR104 \| \	333	MMC_CAP_UHS_SDR50 \| MMC_CAP_UHS_SDR104 \| \
334	MMC_CAP_UHS_DDR50)	334	MMC_CAP_UHS_DDR50)
335	#define MMC_CAP_SYNC_RUNTIME_PM (1 << 21) /* Synced runtime PM suspends. */	335	#define MMC_CAP_SYNC_RUNTIME_PM (1 << 21) /* Synced runtime PM suspends. */
		336	#define MMC_CAP_NEED_RSP_BUSY (1 << 22) /* Commands with R1B can't use R1. */
336	#define MMC_CAP_DRIVER_TYPE_A (1 << 23) /* Host supports Driver Type A */	337	#define MMC_CAP_DRIVER_TYPE_A (1 << 23) /* Host supports Driver Type A */
337	#define MMC_CAP_DRIVER_TYPE_C (1 << 24) /* Host supports Driver Type C */	338	#define MMC_CAP_DRIVER_TYPE_C (1 << 24) /* Host supports Driver Type C */
338	#define MMC_CAP_DRIVER_TYPE_D (1 << 25) /* Host supports Driver Type D */	339	#define MMC_CAP_DRIVER_TYPE_D (1 << 25) /* Host supports Driver Type D */

include/linux/netlink.h+13−0

@@ -115,6 +115,19 @@ static inline void nl_set_extack_cookie_u64(struct netlink_ext_ack *extack, · 114 unmodified lines
115	{	115	{
116	u64 __cookie = cookie;	116	u64 __cookie = cookie;
117		117
		118	if (!extack)
		119	return;
		120	memcpy(extack->cookie, &__cookie, sizeof(__cookie));
		121	extack->cookie_len = sizeof(__cookie);
		122	}
		123
		124	static inline void nl_set_extack_cookie_u32(struct netlink_ext_ack *extack,
		125	u32 cookie)
		126	{
		127	u32 __cookie = cookie;
		128
		129	if (!extack)
		130	return;
118	memcpy(extack->cookie, &__cookie, sizeof(__cookie));	131	memcpy(extack->cookie, &__cookie, sizeof(__cookie));
119	extack->cookie_len = sizeof(__cookie);	132	extack->cookie_len = sizeof(__cookie);
120	}	133	}

include/linux/of_clk.h+4−4

@@ -11,17 +11,17 @@ struct of_device_id; · 10 unmodified lines
11		11
12	#if defined(CONFIG_COMMON_CLK) && defined(CONFIG_OF)	12	#if defined(CONFIG_COMMON_CLK) && defined(CONFIG_OF)
13		13
14	unsigned int of_clk_get_parent_count(struct device_node *np);	14	unsigned int of_clk_get_parent_count(const struct device_node *np);
15	const char of_clk_get_parent_name(struct device_node np, int index);	15	const char of_clk_get_parent_name(const struct device_node np, int index);
16	void of_clk_init(const struct of_device_id *matches);	16	void of_clk_init(const struct of_device_id *matches);
17		17
18	#else /* !CONFIG_COMMON_CLK \|\| !CONFIG_OF */	18	#else /* !CONFIG_COMMON_CLK \|\| !CONFIG_OF */
19		19
20	static inline unsigned int of_clk_get_parent_count(struct device_node *np)	20	static inline unsigned int of_clk_get_parent_count(const struct device_node *np)
21	{	21	{
22	return 0;	22	return 0;
23	}	23	}
24	static inline const char of_clk_get_parent_name(struct device_node np,	24	static inline const char of_clk_get_parent_name(const struct device_node np,
25	int index)	25	int index)
26	{	26	{
27	return NULL;	27	return NULL;

include/linux/page-flags.h+1−1

@@ -311,7 +311,7 @@ static inline int TestClearPage##uname(struct page *page) { return 0; } · 310 unmodified lines
311		311
312	__PAGEFLAG(Locked, locked, PF_NO_TAIL)	312	__PAGEFLAG(Locked, locked, PF_NO_TAIL)
313	PAGEFLAG(Waiters, waiters, PF_ONLY_HEAD) __CLEARPAGEFLAG(Waiters, waiters, PF_ONLY_HEAD)	313	PAGEFLAG(Waiters, waiters, PF_ONLY_HEAD) __CLEARPAGEFLAG(Waiters, waiters, PF_ONLY_HEAD)
314	PAGEFLAG(Error, error, PF_NO_COMPOUND) TESTCLEARFLAG(Error, error, PF_NO_COMPOUND)	314	PAGEFLAG(Error, error, PF_NO_TAIL) TESTCLEARFLAG(Error, error, PF_NO_TAIL)
315	PAGEFLAG(Referenced, referenced, PF_HEAD)	315	PAGEFLAG(Referenced, referenced, PF_HEAD)
316	TESTCLEARFLAG(Referenced, referenced, PF_HEAD)	316	TESTCLEARFLAG(Referenced, referenced, PF_HEAD)
317	__SETPAGEFLAG(Referenced, referenced, PF_HEAD)	317	__SETPAGEFLAG(Referenced, referenced, PF_HEAD)

include/linux/phy.h+3−0

  * is_gigabit_capable: Set to true if PHY supports 1000Mbps
  * has_fixups: Set to true if this phy has fixups/quirks.
  * suspended: Set to true if this phy has been suspended successfully.
+ * suspended_by_mdio_bus: Set to true if this phy was suspended by MDIO bus.
  * sysfs_links: Internal boolean tracking sysfs symbolic links setup/removal.
  * loopback_enabled: Set true if this phy has been loopbacked successfully.
  * state: state of the PHY for management purposes
 	unsigned is_gigabit_capable:1;
 	unsigned has_fixups:1;
 	unsigned suspended:1;
+	unsigned suspended_by_mdio_bus:1;
 	unsigned sysfs_links:1;
 	unsigned loopback_enabled:1;
 	/*
 	 * Checks if the PHY generated an interrupt.
 	 * For multi-PHY devices with shared PHY interrupt pin
+	 * Set interrupt bits have to be cleared.
 	 */
 	int (*did_interrupt)(struct phy_device *phydev);

include/linux/platform_device.h+1−1

@@ -24,7 +24,7 @@ struct platform_device { · 23 unmodified lines
24	int id;	24	int id;
25	bool id_auto;	25	bool id_auto;
26	struct device dev;	26	struct device dev;
27	u64 dma_mask;	27	u64 platform_dma_mask;
28	u32 num_resources;	28	u32 num_resources;
29	struct resource *resource;	29	struct resource *resource;
30		30

include/linux/rhashtable.h+1−1

 /**
  * rhashtable_lookup_get_insert_key - lookup and insert object into hash table
  * @ht:		hash table
+ * @key:	key
  * @obj:	pointer to hash head inside object
  * @params:	hash table parameters
- * @data:	pointer to element data already in hashes
  *
  * Just like rhashtable_lookup_insert_key(), but this function returns the
  * object if it exists, NULL if it does not and the insertion was successful,

include/linux/skbuff.h+32−4

@@ -645,8 +645,8 @@ typedef unsigned char *sk_buff_data_t; · 644 unmodified lines
645	* @offload_l3_fwd_mark: Packet was L3-forwarded in hardware	645	* @offload_l3_fwd_mark: Packet was L3-forwarded in hardware
646	* @tc_skip_classify: do not classify packet. set by IFB device	646	* @tc_skip_classify: do not classify packet. set by IFB device
647	* @tc_at_ingress: used within tc_classify to distinguish in/egress	647	* @tc_at_ingress: used within tc_classify to distinguish in/egress
648	* @tc_redirected: packet was redirected by a tc action	648	* @redirected: packet was redirected by packet classifier
649	* @tc_from_ingress: if tc_redirected, tc_at_ingress at time of redirect	649	* @from_ingress: packet was redirected from the ingress path
650	* @peeked: this packet has been seen already, so stats have been	650	* @peeked: this packet has been seen already, so stats have been
651	* done for it, don't do them again	651	* done for it, don't do them again
652	* @nf_trace: netfilter packet trace flag	652	* @nf_trace: netfilter packet trace flag
@@ -848,8 +848,10 @@ struct sk_buff { · 195 unmodified lines
848	#ifdef CONFIG_NET_CLS_ACT	848	#ifdef CONFIG_NET_CLS_ACT
849	__u8 tc_skip_classify:1;	849	__u8 tc_skip_classify:1;
850	__u8 tc_at_ingress:1;	850	__u8 tc_at_ingress:1;
851	__u8 tc_redirected:1;	851	#endif
852	__u8 tc_from_ingress:1;	852	#ifdef CONFIG_NET_REDIRECT
		853	__u8 redirected:1;
		854	__u8 from_ingress:1;
853	#endif	855	#endif
854	#ifdef CONFIG_TLS_DEVICE	856	#ifdef CONFIG_TLS_DEVICE
855	__u8 decrypted:1;	857	__u8 decrypted:1;
@@ -4579,5 +4581,31 @@ static inline __wsum lco_csum(struct sk_buff *skb) · 3723 unmodified lines
4579	return csum_partial(l4_hdr, csum_start - l4_hdr, partial);	4581	return csum_partial(l4_hdr, csum_start - l4_hdr, partial);
4580	}	4582	}
4581		4583
		4584	static inline bool skb_is_redirected(const struct sk_buff *skb)
		4585	{
		4586	#ifdef CONFIG_NET_REDIRECT
		4587	return skb->redirected;
		4588	#else
		4589	return false;
		4590	#endif
		4591	}
		4592
		4593	static inline void skb_set_redirected(struct sk_buff *skb, bool from_ingress)
		4594	{
		4595	#ifdef CONFIG_NET_REDIRECT
		4596	skb->redirected = 1;
		4597	skb->from_ingress = from_ingress;
		4598	if (skb->from_ingress)
		4599	skb->tstamp = 0;
		4600	#endif
		4601	}
		4602
		4603	static inline void skb_reset_redirect(struct sk_buff *skb)
		4604	{
		4605	#ifdef CONFIG_NET_REDIRECT
		4606	skb->redirected = 0;
		4607	#endif
		4608	}
		4609
4582	#endif /* __KERNEL__ */	4610	#endif /* __KERNEL__ */
4583	#endif /* _LINUX_SKBUFF_H */	4611	#endif /* _LINUX_SKBUFF_H */

include/linux/socket.h+2−1

 			int addr_len);
 extern int __sys_accept4_file(struct file *file, unsigned file_flags,
 			struct sockaddr __user *upeer_sockaddr,
-			 int __user *upeer_addrlen, int flags);
+			 int __user *upeer_addrlen, int flags,
+			 unsigned long nofile);
 extern int __sys_accept4(int fd, struct sockaddr __user *upeer_sockaddr,
 			 int __user *upeer_addrlen, int flags);
 extern int __sys_socket(int family, int type, int protocol);

include/linux/vmalloc.h+3−2

@@ -141,8 +141,9 @@ extern int remap_vmalloc_range_partial(struct vm_area_struct *vma, · 140 unmodified lines
141		141
142	extern int remap_vmalloc_range(struct vm_area_struct vma, void addr,	142	extern int remap_vmalloc_range(struct vm_area_struct vma, void addr,
143	unsigned long pgoff);	143	unsigned long pgoff);
144	void vmalloc_sync_all(void);	144	void vmalloc_sync_mappings(void);
145		145	void vmalloc_sync_unmappings(void);
		146
146	/*	147	/*
147	* Lowlevel-APIs (not for driver use!)	148	* Lowlevel-APIs (not for driver use!)
148	*/	149	*/

include/linux/workqueue.h+16−0

@@ -487,6 +487,19 @@ extern void wq_worker_comm(char buf, size_t size, struct task_struct task); · 486 unmodified lines
487	*	487	*
488	* We queue the work to the CPU on which it was submitted, but if the CPU dies	488	* We queue the work to the CPU on which it was submitted, but if the CPU dies
489	* it can be processed by another CPU.	489	* it can be processed by another CPU.
		490	*
		491	* Memory-ordering properties: If it returns %true, guarantees that all stores
		492	* preceding the call to queue_work() in the program order will be visible from
		493	* the CPU which will execute @work by the time such work executes, e.g.,
		494	*
		495	* { x is initially 0 }
		496	*
		497	* CPU0 CPU1
		498	*
		499	* WRITE_ONCE(x, 1); [ @work is being executed ]
		500	* r0 = queue_work(wq, work); r1 = READ_ONCE(x);
		501	*
		502	* Forbids: r0 == true && r1 == 0
490	*/	503	*/
491	static inline bool queue_work(struct workqueue_struct *wq,	504	static inline bool queue_work(struct workqueue_struct *wq,
492	struct work_struct *work)	505	struct work_struct *work)
@@ -546,6 +559,9 @@ static inline bool schedule_work_on(int cpu, struct work_struct *work) · 53 unmodified lines
546	* This puts a job in the kernel-global workqueue if it was not already	559	* This puts a job in the kernel-global workqueue if it was not already
547	* queued and leaves it in the same position on the kernel-global	560	* queued and leaves it in the same position on the kernel-global
548	* workqueue otherwise.	561	* workqueue otherwise.
		562	*
		563	* Shares the same memory-ordering properties of queue_work(), cf. the
		564	* DocBook header of queue_work().
549	*/	565	*/
550	static inline bool schedule_work(struct work_struct *work)	566	static inline bool schedule_work(struct work_struct *work)
551	{	567	{

@@ -522,9 +522,9 @@ struct clk clk_register_gate(struct device dev, const char *name, · 521 unmodified lines
522	* @clk_gate_flags: gate-specific flags for this clock	522	* @clk_gate_flags: gate-specific flags for this clock
523	* @lock: shared register lock for this clock	523	* @lock: shared register lock for this clock
524	*/	524	*/
525	#define clk_hw_register_gate_parent_hw(dev, name, parent_name, flags, reg, \	525	#define clk_hw_register_gate_parent_hw(dev, name, parent_hw, flags, reg, \
526	bit_idx, clk_gate_flags, lock) \	526	bit_idx, clk_gate_flags, lock) \
527	__clk_hw_register_gate((dev), NULL, (name), (parent_name), NULL, \	527	__clk_hw_register_gate((dev), NULL, (name), NULL, (parent_hw), \
528	NULL, (flags), (reg), (bit_idx), \	528	NULL, (flags), (reg), (bit_idx), \
529	(clk_gate_flags), (lock))	529	(clk_gate_flags), (lock))
530	/**	530	/**
@@ -539,10 +539,10 @@ struct clk clk_register_gate(struct device dev, const char *name, · 8 unmodified lines
539	* @clk_gate_flags: gate-specific flags for this clock	539	* @clk_gate_flags: gate-specific flags for this clock
540	* @lock: shared register lock for this clock	540	* @lock: shared register lock for this clock
541	*/	541	*/
542	#define clk_hw_register_gate_parent_data(dev, name, parent_name, flags, reg, \	542	#define clk_hw_register_gate_parent_data(dev, name, parent_data, flags, reg, \
543	bit_idx, clk_gate_flags, lock) \	543	bit_idx, clk_gate_flags, lock) \
544	__clk_hw_register_gate((dev), NULL, (name), (parent_name), NULL, \	544	__clk_hw_register_gate((dev), NULL, (name), NULL, NULL, (parent_data), \
545	NULL, (flags), (reg), (bit_idx), \	545	(flags), (reg), (bit_idx), \
546	(clk_gate_flags), (lock))	546	(clk_gate_flags), (lock))
547	void clk_unregister_gate(struct clk *clk);	547	void clk_unregister_gate(struct clk *clk);
548	void clk_hw_unregister_gate(struct clk_hw *hw);	548	void clk_hw_unregister_gate(struct clk_hw *hw);