History

Merge tag 'v5.16-rc5' into rdma.git for-next

Required due to dependencies in following patches.

Jason Gunthorpe committed 4 years ago

Commit 4922f092 parents 2067909 2585cf91267 files · +14671 −9308Browse files

Showing the changes to include (65 of 1267 files). Show all

Unified · Split

65 files
  1. include/asm-generic/cacheflush.h +0 −6
  2. include/linux/acpi.h +9 −7
  3. include/linux/bpf.h +5 −15
  4. include/linux/btf.h +10 −4
  5. include/linux/cacheflush.h +18 −0
  6. include/linux/cacheinfo.h +0 −1
  7. include/linux/delay.h +13 −1
  8. include/linux/device/driver.h +1 −0
  9. include/linux/filter.h +1 −4
  10. include/linux/fs.h +0 −1
  11. include/linux/hid.h +5 −0
  12. include/linux/highmem.h +42 −5
  13. include/linux/hugetlb_cgroup.h +12 −0
  14. include/linux/intel-ish-client-if.h +2 −2
  15. include/linux/ipc_namespace.h +15 −0
  16. include/linux/kprobes.h +2 −0
  17. include/linux/kvm_host.h +1 −5
  18. include/linux/kvm_types.h +0 −7
  19. include/linux/mhi.h +13 −0
  20. include/linux/mlx5/eswitch.h +2 −2
  21. include/linux/mlx5/mlx5_ifc.h +4 −1
  22. include/linux/mm_types.h +12 −1
  23. include/linux/mod_devicetable.h +14 −0
  24. include/linux/netdevice.h +13 −6
  25. include/linux/page-flags.h +7 −7
  26. include/linux/pagemap.h +21 −5
  27. include/linux/percpu-refcount.h +1 −1
  28. include/linux/percpu.h +0 −1
  29. include/linux/phy.h +6 −5
  30. include/linux/pm_runtime.h +1 −1
  31. include/linux/printk.h +4 −0
  32. include/linux/ptp_classify.h +1 −0
  33. include/linux/regulator/driver.h +8 −6
  34. include/linux/sched/cputime.h +3 −2
  35. include/linux/sched/signal.h +1 −0
  36. include/linux/sched/task.h +1 −1
  37. include/linux/sdb.h +0 −160
  38. include/linux/siphash.h +4 −10
  39. include/linux/skbuff.h +1 −1
  40. include/linux/trace_events.h +1 −1
  41. include/linux/virtio.h +0 −2
  42. include/linux/virtio_net.h +6 −1
  43. include/linux/wait.h +26 −0
  44. include/net/bond_alb.h +1 −1
  45. include/net/busy_poll.h +13 −0
  46. include/net/dst_cache.h +11 −0
  47. include/net/fib_rules.h +3 −1
  48. include/net/ip6_fib.h +1 −0
  49. include/net/ip_fib.h +1 −1
  50. include/net/ipv6_stubs.h +1 −0
  51. include/net/netfilter/nf_conntrack.h +3 −3
  52. include/net/netns/ipv4.h +1 −1
  53. include/net/nfc/nci_core.h +1 −0
  54. include/net/nl802154.h +4 −3
  55. include/net/page_pool.h +11 −1
  56. include/net/sock.h +23 −7
  57. include/rdma/rdma_netlink.h +1 −1
  58. include/soc/mscc/ocelot_vcap.h +2 −0
  59. include/sound/soc-acpi.h +1 −1
  60. include/trace/events/rpcgss.h +1 −1
  61. include/uapi/asm-generic/poll.h +1 −1
  62. include/uapi/drm/virtgpu_drm.h +7 −0
  63. include/uapi/linux/if_ether.h +1 −1
  64. include/uapi/linux/resource.h +10 −3
  65. include/xen/xenbus.h +1 −0
include/asm-generic/cacheflush.h+0−6
@@ -50,13 +50,7 @@ static inline void flush_dcache_page(struct page *page) · 49 unmodified lines
5050 {
5151 }
5252
53−static inline void flush_dcache_folio(struct folio *folio) { }
5453 #define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE 0
55−#define ARCH_IMPLEMENTS_FLUSH_DCACHE_FOLIO
56−#endif
57−
58−#ifndef ARCH_IMPLEMENTS_FLUSH_DCACHE_FOLIO
59−void flush_dcache_folio(struct folio *folio);
6054 #endif
6155
6256 #ifndef flush_dcache_mmap_lock
include/linux/acpi.h+9−7
@@ -974,6 +974,15 @@ static inline int acpi_get_local_address(acpi_handle handle, u32 *addr) · 973 unmodified lines
974974 return -ENODEV;
975975 }
976976
977+static inline int acpi_register_wakeup_handler(int wake_irq,
978+ bool (*wakeup)(void *context), void *context)
979+{
980+ return -ENXIO;
981+}
982+
983+static inline void acpi_unregister_wakeup_handler(
984+ bool (*wakeup)(void *context), void *context) { }
985+
977986 #endif /* !CONFIG_ACPI */
978987
979988 #ifdef CONFIG_ACPI_HOTPLUG_IOAPIC
@@ -1173,7 +1182,6 @@ int acpi_node_prop_get(const struct fwnode_handle *fwnode, const char *propname, · 193 unmodified lines
11731182
11741183 struct fwnode_handle *acpi_get_next_subnode(const struct fwnode_handle *fwnode,
11751184 struct fwnode_handle *child);
1176−struct fwnode_handle *acpi_node_get_parent(const struct fwnode_handle *fwnode);
11771185
11781186 struct acpi_probe_entry;
11791187 typedef bool (*acpi_probe_entry_validate_subtbl)(struct acpi_subtable_header *,
@@ -1278,12 +1286,6 @@ acpi_get_next_subnode(const struct fwnode_handle *fwnode, · 98 unmodified lines
12781286 return NULL;
12791287 }
12801288
1281−static inline struct fwnode_handle *
1282−acpi_node_get_parent(const struct fwnode_handle *fwnode)
1283−{
1284− return NULL;
1285−}
1286−
12871289 static inline struct fwnode_handle *
12881290 acpi_graph_get_next_endpoint(const struct fwnode_handle *fwnode,
12891291 struct fwnode_handle *prev)
include/linux/bpf.h+5−15
@@ -193,7 +193,7 @@ struct bpf_map { · 192 unmodified lines
193193 atomic64_t usercnt;
194194 struct work_struct work;
195195 struct mutex freeze_mutex;
196− u64 writecnt; /* writable mmap cnt; protected by freeze_mutex */
196+ atomic64_t writecnt;
197197 };
198198
199199 static inline bool map_value_has_spin_lock(const struct bpf_map *map)
@@ -732,6 +732,7 @@ int bpf_trampoline_unlink_prog(struct bpf_prog *prog, struct bpf_trampoline *tr) · 532 unmodified lines
732732 struct bpf_trampoline *bpf_trampoline_get(u64 key,
733733 struct bpf_attach_target_info *tgt_info);
734734 void bpf_trampoline_put(struct bpf_trampoline *tr);
735+int arch_prepare_bpf_dispatcher(void *image, s64 *funcs, int num_funcs);
735736 #define BPF_DISPATCHER_INIT(_name) { \
736737 .mutex = __MUTEX_INITIALIZER(_name.mutex), \
737738 .func = &_name##_func, \
@@ -1352,28 +1353,16 @@ extern struct mutex bpf_stats_enabled_mutex; · 614 unmodified lines
13521353 * kprobes, tracepoints) to prevent deadlocks on map operations as any of
13531354 * these events can happen inside a region which holds a map bucket lock
13541355 * and can deadlock on it.
1355− *
1356− * Use the preemption safe inc/dec variants on RT because migrate disable
1357− * is preemptible on RT and preemption in the middle of the RMW operation
1358− * might lead to inconsistent state. Use the raw variants for non RT
1359− * kernels as migrate_disable() maps to preempt_disable() so the slightly
1360− * more expensive save operation can be avoided.
13611356 */
13621357 static inline void bpf_disable_instrumentation(void)
13631358 {
13641359 migrate_disable();
1365− if (IS_ENABLED(CONFIG_PREEMPT_RT))
1366− this_cpu_inc(bpf_prog_active);
1367− else
1368− __this_cpu_inc(bpf_prog_active);
1360+ this_cpu_inc(bpf_prog_active);
13691361 }
13701362
13711363 static inline void bpf_enable_instrumentation(void)
13721364 {
1373− if (IS_ENABLED(CONFIG_PREEMPT_RT))
1374− this_cpu_dec(bpf_prog_active);
1375− else
1376− __this_cpu_dec(bpf_prog_active);
1365+ this_cpu_dec(bpf_prog_active);
13771366 migrate_enable();
13781367 }
13791368
@@ -1419,6 +1408,7 @@ void bpf_map_put(struct bpf_map *map); · 39 unmodified lines
14191408 void *bpf_map_area_alloc(u64 size, int numa_node);
14201409 void *bpf_map_area_mmapable_alloc(u64 size, int numa_node);
14211410 void bpf_map_area_free(void *base);
1411+bool bpf_map_write_active(const struct bpf_map *map);
14221412 void bpf_map_init_from_attr(struct bpf_map *map, union bpf_attr *attr);
14231413 int generic_map_lookup_batch(struct bpf_map *map,
14241414 const union bpf_attr *attr,
include/linux/btf.h+10−4
@@ -245,7 +245,10 @@ struct kfunc_btf_id_set { · 244 unmodified lines
245245 struct module *owner;
246246 };
247247
248−struct kfunc_btf_id_list;
248+struct kfunc_btf_id_list {
249+ struct list_head list;
250+ struct mutex mutex;
251+};
249252
250253 #ifdef CONFIG_DEBUG_INFO_BTF_MODULES
251254 void register_kfunc_btf_id_set(struct kfunc_btf_id_list *l,
@@ -254,6 +257,9 @@ void unregister_kfunc_btf_id_set(struct kfunc_btf_id_list *l, · 2 unmodified lines
254257 struct kfunc_btf_id_set *s);
255258 bool bpf_check_mod_kfunc_call(struct kfunc_btf_id_list *klist, u32 kfunc_id,
256259 struct module *owner);
260+
261+extern struct kfunc_btf_id_list bpf_tcp_ca_kfunc_list;
262+extern struct kfunc_btf_id_list prog_test_kfunc_list;
257263 #else
258264 static inline void register_kfunc_btf_id_set(struct kfunc_btf_id_list *l,
259265 struct kfunc_btf_id_set *s)
@@ -268,13 +274,13 @@ static inline bool bpf_check_mod_kfunc_call(struct kfunc_btf_id_list *klist, · 8 unmodified lines
268274 {
269275 return false;
270276 }
277+
278+static struct kfunc_btf_id_list bpf_tcp_ca_kfunc_list __maybe_unused;
279+static struct kfunc_btf_id_list prog_test_kfunc_list __maybe_unused;
271280 #endif
272281
273282 #define DEFINE_KFUNC_BTF_ID_SET(set, name) \
274283 struct kfunc_btf_id_set name = { LIST_HEAD_INIT(name.list), (set), \
275284 THIS_MODULE }
276285
277−extern struct kfunc_btf_id_list bpf_tcp_ca_kfunc_list;
278−extern struct kfunc_btf_id_list prog_test_kfunc_list;
279−
280286 #endif
include/linux/cacheflush.h+18−0
@@ -0,0 +1,18 @@
1+/* SPDX-License-Identifier: GPL-2.0 */
2+#ifndef _LINUX_CACHEFLUSH_H
3+#define _LINUX_CACHEFLUSH_H
4+
5+#include <asm/cacheflush.h>
6+
7+#if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
8+#ifndef ARCH_IMPLEMENTS_FLUSH_DCACHE_FOLIO
9+void flush_dcache_folio(struct folio *folio);
10+#endif
11+#else
12+static inline void flush_dcache_folio(struct folio *folio)
13+{
14+}
15+#define ARCH_IMPLEMENTS_FLUSH_DCACHE_FOLIO 0
16+#endif /* ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE */
17+
18+#endif /* _LINUX_CACHEFLUSH_H */
include/linux/cacheinfo.h+0−1
@@ -3,7 +3,6 @@ · 2 unmodified lines
33 #define _LINUX_CACHEINFO_H
44
55 #include <linux/bitops.h>
6−#include <linux/cpu.h>
76 #include <linux/cpumask.h>
87 #include <linux/smp.h>
98
include/linux/delay.h+13−1
@@ -20,6 +20,7 @@ · 19 unmodified lines
2020 */
2121
2222 #include <linux/math.h>
23+#include <linux/sched.h>
2324
2425 extern unsigned long loops_per_jiffy;
2526
@@ -58,7 +59,18 @@ void calibrate_delay(void); · 32 unmodified lines
5859 void __attribute__((weak)) calibration_delay_done(void);
5960 void msleep(unsigned int msecs);
6061 unsigned long msleep_interruptible(unsigned int msecs);
61−void usleep_range(unsigned long min, unsigned long max);
62+void usleep_range_state(unsigned long min, unsigned long max,
63+ unsigned int state);
64+
65+static inline void usleep_range(unsigned long min, unsigned long max)
66+{
67+ usleep_range_state(min, max, TASK_UNINTERRUPTIBLE);
68+}
69+
70+static inline void usleep_idle_range(unsigned long min, unsigned long max)
71+{
72+ usleep_range_state(min, max, TASK_IDLE);
73+}
6274
6375 static inline void ssleep(unsigned int seconds)
6476 {
include/linux/device/driver.h+1−0
@@ -18,6 +18,7 @@ · 17 unmodified lines
1818 #include <linux/klist.h>
1919 #include <linux/pm.h>
2020 #include <linux/device/bus.h>
21+#include <linux/module.h>
2122
2223 /**
2324 * enum probe_type - device driver probe type to try
include/linux/filter.h+1−4
@@ -6,6 +6,7 @@ · 5 unmodified lines
66 #define __LINUX_FILTER_H__
77
88 #include <linux/atomic.h>
9+#include <linux/bpf.h>
910 #include <linux/refcount.h>
1011 #include <linux/compat.h>
1112 #include <linux/skbuff.h>
@@ -26,7 +27,6 @@ · 14 unmodified lines
2627
2728 #include <asm/byteorder.h>
2829 #include <uapi/linux/filter.h>
29−#include <uapi/linux/bpf.h>
3030
3131 struct sk_buff;
3232 struct sock;
@@ -640,9 +640,6 @@ static __always_inline u32 bpf_prog_run(const struct bpf_prog *prog, const void · 607 unmodified lines
640640 * This uses migrate_disable/enable() explicitly to document that the
641641 * invocation of a BPF program does not require reentrancy protection
642642 * against a BPF program which is invoked from a preempting task.
643− *
644− * For non RT enabled kernels migrate_disable/enable() maps to
645− * preempt_disable/enable(), i.e. it disables also preemption.
646643 */
647644 static inline u32 bpf_prog_run_pin_on_cpu(const struct bpf_prog *prog,
648645 const void *ctx)
include/linux/fs.h+0−1
@@ -2518,7 +2518,6 @@ struct file_system_type { · 2517 unmodified lines
25182518 #define FS_USERNS_MOUNT 8 /* Can be mounted by userns root */
25192519 #define FS_DISALLOW_NOTIFY_PERM 16 /* Disable fanotify permission events */
25202520 #define FS_ALLOW_IDMAP 32 /* FS has been updated to handle vfs idmappings. */
2521−#define FS_THP_SUPPORT 8192 /* Remove once all fs converted */
25222521 #define FS_RENAME_DOES_D_MOVE 32768 /* FS will handle d_move() during rename() internally. */
25232522 int (*init_fs_context)(struct fs_context *);
25242523 const struct fs_parameter_spec *parameters;
include/linux/hid.h+5−0
@@ -840,6 +840,11 @@ static inline bool hid_is_using_ll_driver(struct hid_device *hdev, · 839 unmodified lines
840840 return hdev->ll_driver == driver;
841841 }
842842
843+static inline bool hid_is_usb(struct hid_device *hdev)
844+{
845+ return hid_is_using_ll_driver(hdev, &usb_hid_driver);
846+}
847+
843848 #define PM_HINT_FULLON 1<<5
844849 #define PM_HINT_NORMAL 1<<1
845850
include/linux/highmem.h+42−5
@@ -5,12 +5,11 @@ · 4 unmodified lines
55 #include <linux/fs.h>
66 #include <linux/kernel.h>
77 #include <linux/bug.h>
8+#include <linux/cacheflush.h>
89 #include <linux/mm.h>
910 #include <linux/uaccess.h>
1011 #include <linux/hardirq.h>
1112
12−#include <asm/cacheflush.h>
13−
1413 #include "highmem-internal.h"
1514
1615 /**
@@ -231,10 +230,10 @@ static inline void tag_clear_highpage(struct page *page) · 214 unmodified lines
231230 * If we pass in a base or tail page, we can zero up to PAGE_SIZE.
232231 * If we pass in a head page, we can zero up to the size of the compound page.
233232 */
234−#if defined(CONFIG_HIGHMEM) && defined(CONFIG_TRANSPARENT_HUGEPAGE)
233+#ifdef CONFIG_HIGHMEM
235234 void zero_user_segments(struct page *page, unsigned start1, unsigned end1,
236235 unsigned start2, unsigned end2);
237−#else /* !HIGHMEM || !TRANSPARENT_HUGEPAGE */
236+#else
238237 static inline void zero_user_segments(struct page *page,
239238 unsigned start1, unsigned end1,
240239 unsigned start2, unsigned end2)
@@ -254,7 +253,7 @@ static inline void zero_user_segments(struct page *page, · 13 unmodified lines
254253 for (i = 0; i < compound_nr(page); i++)
255254 flush_dcache_page(page + i);
256255 }
257−#endif /* !HIGHMEM || !TRANSPARENT_HUGEPAGE */
256+#endif
258257
259258 static inline void zero_user_segment(struct page *page,
260259 unsigned start, unsigned end)
@@ -364,4 +363,42 @@ static inline void memzero_page(struct page *page, size_t offset, size_t len) · 103 unmodified lines
364363 kunmap_local(addr);
365364 }
366365
366+/**
367+ * folio_zero_segments() - Zero two byte ranges in a folio.
368+ * @folio: The folio to write to.
369+ * @start1: The first byte to zero.
370+ * @xend1: One more than the last byte in the first range.
371+ * @start2: The first byte to zero in the second range.
372+ * @xend2: One more than the last byte in the second range.
373+ */
374+static inline void folio_zero_segments(struct folio *folio,
375+ size_t start1, size_t xend1, size_t start2, size_t xend2)
376+{
377+ zero_user_segments(&folio->page, start1, xend1, start2, xend2);
378+}
379+
380+/**
381+ * folio_zero_segment() - Zero a byte range in a folio.
382+ * @folio: The folio to write to.
383+ * @start: The first byte to zero.
384+ * @xend: One more than the last byte to zero.
385+ */
386+static inline void folio_zero_segment(struct folio *folio,
387+ size_t start, size_t xend)
388+{
389+ zero_user_segments(&folio->page, start, xend, 0, 0);
390+}
391+
392+/**
393+ * folio_zero_range() - Zero a byte range in a folio.
394+ * @folio: The folio to write to.
395+ * @start: The first byte to zero.
396+ * @length: The number of bytes to zero.
397+ */
398+static inline void folio_zero_range(struct folio *folio,
399+ size_t start, size_t length)
400+{
401+ zero_user_segments(&folio->page, start, start + length, 0, 0);
402+}
403+
367404 #endif /* _LINUX_HIGHMEM_H */
include/linux/hugetlb_cgroup.h+12−0
@@ -128,6 +128,13 @@ static inline void resv_map_dup_hugetlb_cgroup_uncharge_info( · 127 unmodified lines
128128 css_get(resv_map->css);
129129 }
130130
131+static inline void resv_map_put_hugetlb_cgroup_uncharge_info(
132+ struct resv_map *resv_map)
133+{
134+ if (resv_map->css)
135+ css_put(resv_map->css);
136+}
137+
131138 extern int hugetlb_cgroup_charge_cgroup(int idx, unsigned long nr_pages,
132139 struct hugetlb_cgroup **ptr);
133140 extern int hugetlb_cgroup_charge_cgroup_rsvd(int idx, unsigned long nr_pages,
@@ -211,6 +218,11 @@ static inline void resv_map_dup_hugetlb_cgroup_uncharge_info( · 77 unmodified lines
211218 {
212219 }
213220
221+static inline void resv_map_put_hugetlb_cgroup_uncharge_info(
222+ struct resv_map *resv_map)
223+{
224+}
225+
214226 static inline int hugetlb_cgroup_charge_cgroup(int idx, unsigned long nr_pages,
215227 struct hugetlb_cgroup **ptr)
216228 {
include/linux/intel-ish-client-if.h+2−2
@@ -9,7 +9,7 @@ · 8 unmodified lines
99 #define _INTEL_ISH_CLIENT_IF_H_
1010
1111 #include <linux/device.h>
12−#include <linux/uuid.h>
12+#include <linux/mod_devicetable.h>
1313
1414 struct ishtp_cl_device;
1515 struct ishtp_device;
@@ -40,7 +40,7 @@ enum cl_state { · 24 unmodified lines
4040 struct ishtp_cl_driver {
4141 struct device_driver driver;
4242 const char *name;
43− const guid_t *guid;
43+ const struct ishtp_device_id *id;
4444 int (*probe)(struct ishtp_cl_device *dev);
4545 void (*remove)(struct ishtp_cl_device *dev);
4646 int (*reset)(struct ishtp_cl_device *dev);
include/linux/ipc_namespace.h+15−0
@@ -131,6 +131,16 @@ static inline struct ipc_namespace *get_ipc_ns(struct ipc_namespace *ns) · 130 unmodified lines
131131 return ns;
132132 }
133133
134+static inline struct ipc_namespace *get_ipc_ns_not_zero(struct ipc_namespace *ns)
135+{
136+ if (ns) {
137+ if (refcount_inc_not_zero(&ns->ns.count))
138+ return ns;
139+ }
140+
141+ return NULL;
142+}
143+
134144 extern void put_ipc_ns(struct ipc_namespace *ns);
135145 #else
136146 static inline struct ipc_namespace *copy_ipcs(unsigned long flags,
@@ -147,6 +157,11 @@ static inline struct ipc_namespace *get_ipc_ns(struct ipc_namespace *ns) · 10 unmodified lines
147157 return ns;
148158 }
149159
160+static inline struct ipc_namespace *get_ipc_ns_not_zero(struct ipc_namespace *ns)
161+{
162+ return ns;
163+}
164+
150165 static inline void put_ipc_ns(struct ipc_namespace *ns)
151166 {
152167 }
include/linux/kprobes.h+2−0
@@ -153,6 +153,8 @@ struct kretprobe { · 152 unmodified lines
153153 struct kretprobe_holder *rph;
154154 };
155155
156+#define KRETPROBE_MAX_DATA_SIZE 4096
157+
156158 struct kretprobe_instance {
157159 union {
158160 struct freelist_node freelist;
include/linux/kvm_host.h+1−5
@@ -874,7 +874,7 @@ void kvm_release_pfn_dirty(kvm_pfn_t pfn); · 873 unmodified lines
874874 void kvm_set_pfn_dirty(kvm_pfn_t pfn);
875875 void kvm_set_pfn_accessed(kvm_pfn_t pfn);
876876
877−void kvm_release_pfn(kvm_pfn_t pfn, bool dirty, struct gfn_to_pfn_cache *cache);
877+void kvm_release_pfn(kvm_pfn_t pfn, bool dirty);
878878 int kvm_read_guest_page(struct kvm *kvm, gfn_t gfn, void *data, int offset,
879879 int len);
880880 int kvm_read_guest(struct kvm *kvm, gpa_t gpa, void *data, unsigned long len);
@@ -950,12 +950,8 @@ struct kvm_memory_slot *kvm_vcpu_gfn_to_memslot(struct kvm_vcpu *vcpu, gfn_t gfn · 69 unmodified lines
950950 kvm_pfn_t kvm_vcpu_gfn_to_pfn_atomic(struct kvm_vcpu *vcpu, gfn_t gfn);
951951 kvm_pfn_t kvm_vcpu_gfn_to_pfn(struct kvm_vcpu *vcpu, gfn_t gfn);
952952 int kvm_vcpu_map(struct kvm_vcpu *vcpu, gpa_t gpa, struct kvm_host_map *map);
953−int kvm_map_gfn(struct kvm_vcpu *vcpu, gfn_t gfn, struct kvm_host_map *map,
954− struct gfn_to_pfn_cache *cache, bool atomic);
955953 struct page *kvm_vcpu_gfn_to_page(struct kvm_vcpu *vcpu, gfn_t gfn);
956954 void kvm_vcpu_unmap(struct kvm_vcpu *vcpu, struct kvm_host_map *map, bool dirty);
957−int kvm_unmap_gfn(struct kvm_vcpu *vcpu, struct kvm_host_map *map,
958− struct gfn_to_pfn_cache *cache, bool dirty, bool atomic);
959955 unsigned long kvm_vcpu_gfn_to_hva(struct kvm_vcpu *vcpu, gfn_t gfn);
960956 unsigned long kvm_vcpu_gfn_to_hva_prot(struct kvm_vcpu *vcpu, gfn_t gfn, bool *writable);
961957 int kvm_vcpu_read_guest_page(struct kvm_vcpu *vcpu, gfn_t gfn, void *data, int offset,
include/linux/kvm_types.h+0−7
@@ -53,13 +53,6 @@ struct gfn_to_hva_cache { · 52 unmodified lines
5353 struct kvm_memory_slot *memslot;
5454 };
5555
56−struct gfn_to_pfn_cache {
57− u64 generation;
58− gfn_t gfn;
59− kvm_pfn_t pfn;
60− bool dirty;
61−};
62−
6356 #ifdef KVM_ARCH_NR_OBJS_PER_MEMORY_CACHE
6457 /*
6558 * Memory caches are used to preallocate memory ahead of various MMU flows,
include/linux/mhi.h+13−0
@@ -663,6 +663,19 @@ int mhi_pm_suspend(struct mhi_controller *mhi_cntrl); · 662 unmodified lines
663663 */
664664 int mhi_pm_resume(struct mhi_controller *mhi_cntrl);
665665
666+/**
667+ * mhi_pm_resume_force - Force resume MHI from suspended state
668+ * @mhi_cntrl: MHI controller
669+ *
670+ * Resume the device irrespective of its MHI state. As per the MHI spec, devices
671+ * has to be in M3 state during resume. But some devices seem to be in a
672+ * different MHI state other than M3 but they continue working fine if allowed.
673+ * This API is intented to be used for such devices.
674+ *
675+ * Return: 0 if the resume succeeds, a negative error code otherwise
676+ */
677+int mhi_pm_resume_force(struct mhi_controller *mhi_cntrl);
678+
666679 /**
667680 * mhi_download_rddm_image - Download ramdump image from device for
668681 * debugging purpose.
include/linux/mlx5/eswitch.h+2−2
@@ -145,13 +145,13 @@ u32 mlx5_eswitch_get_vport_metadata_for_set(struct mlx5_eswitch *esw, · 144 unmodified lines
145145 GENMASK(31 - ESW_TUN_ID_BITS - ESW_RESERVED_BITS, \
146146 ESW_TUN_OPTS_OFFSET + 1)
147147
148−u8 mlx5_eswitch_mode(struct mlx5_core_dev *dev);
148+u8 mlx5_eswitch_mode(const struct mlx5_core_dev *dev);
149149 u16 mlx5_eswitch_get_total_vports(const struct mlx5_core_dev *dev);
150150 struct mlx5_core_dev *mlx5_eswitch_get_core_dev(struct mlx5_eswitch *esw);
151151
152152 #else /* CONFIG_MLX5_ESWITCH */
153153
154−static inline u8 mlx5_eswitch_mode(struct mlx5_core_dev *dev)
154+static inline u8 mlx5_eswitch_mode(const struct mlx5_core_dev *dev)
155155 {
156156 return MLX5_ESWITCH_NONE;
157157 }
include/linux/mlx5/mlx5_ifc.h+4−1
@@ -9698,7 +9698,10 @@ struct mlx5_ifc_mcam_access_reg_bits { · 9697 unmodified lines
96989698 u8 regs_84_to_68[0x11];
96999699 u8 tracer_registers[0x4];
97009700
9701− u8 regs_63_to_32[0x20];
9701+ u8 regs_63_to_46[0x12];
9702+ u8 mrtc[0x1];
9703+ u8 regs_44_to_32[0xd];
9704+
97029705 u8 regs_31_to_0[0x20];
97039706 };
97049707
include/linux/mm_types.h+12−1
@@ -105,7 +105,18 @@ struct page { · 104 unmodified lines
105105 struct page_pool *pp;
106106 unsigned long _pp_mapping_pad;
107107 unsigned long dma_addr;
108− atomic_long_t pp_frag_count;
108+ union {
109+ /**
110+ * dma_addr_upper: might require a 64-bit
111+ * value on 32-bit architectures.
112+ */
113+ unsigned long dma_addr_upper;
114+ /**
115+ * For frag page support, not supported in
116+ * 32-bit architectures with 64-bit DMA.
117+ */
118+ atomic_long_t pp_frag_count;
119+ };
109120 };
110121 struct { /* slab, slob and slub */
111122 union {
include/linux/mod_devicetable.h+14−0
@@ -895,4 +895,18 @@ struct dfl_device_id { · 894 unmodified lines
895895 kernel_ulong_t driver_data;
896896 };
897897
898+/* ISHTP (Integrated Sensor Hub Transport Protocol) */
899+
900+#define ISHTP_MODULE_PREFIX "ishtp:"
901+
902+/**
903+ * struct ishtp_device_id - ISHTP device identifier
904+ * @guid: GUID of the device.
905+ * @driver_data: pointer to driver specific data
906+ */
907+struct ishtp_device_id {
908+ guid_t guid;
909+ kernel_ulong_t driver_data;
910+};
911+
898912 #endif /* LINUX_MOD_DEVICETABLE_H */
include/linux/netdevice.h+13−6
@@ -4404,7 +4404,8 @@ static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits) · 4403 unmodified lines
44044404 static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)
44054405 {
44064406 spin_lock(&txq->_xmit_lock);
4407− txq->xmit_lock_owner = cpu;
4407+ /* Pairs with READ_ONCE() in __dev_queue_xmit() */
4408+ WRITE_ONCE(txq->xmit_lock_owner, cpu);
44084409 }
44094410
44104411 static inline bool __netif_tx_acquire(struct netdev_queue *txq)
@@ -4421,26 +4422,32 @@ static inline void __netif_tx_release(struct netdev_queue *txq) · 10 unmodified lines
44214422 static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
44224423 {
44234424 spin_lock_bh(&txq->_xmit_lock);
4424− txq->xmit_lock_owner = smp_processor_id();
4425+ /* Pairs with READ_ONCE() in __dev_queue_xmit() */
4426+ WRITE_ONCE(txq->xmit_lock_owner, smp_processor_id());
44254427 }
44264428
44274429 static inline bool __netif_tx_trylock(struct netdev_queue *txq)
44284430 {
44294431 bool ok = spin_trylock(&txq->_xmit_lock);
4430− if (likely(ok))
4431− txq->xmit_lock_owner = smp_processor_id();
4432+
4433+ if (likely(ok)) {
4434+ /* Pairs with READ_ONCE() in __dev_queue_xmit() */
4435+ WRITE_ONCE(txq->xmit_lock_owner, smp_processor_id());
4436+ }
44324437 return ok;
44334438 }
44344439
44354440 static inline void __netif_tx_unlock(struct netdev_queue *txq)
44364441 {
4437− txq->xmit_lock_owner = -1;
4442+ /* Pairs with READ_ONCE() in __dev_queue_xmit() */
4443+ WRITE_ONCE(txq->xmit_lock_owner, -1);
44384444 spin_unlock(&txq->_xmit_lock);
44394445 }
44404446
44414447 static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
44424448 {
4443− txq->xmit_lock_owner = -1;
4449+ /* Pairs with READ_ONCE() in __dev_queue_xmit() */
4450+ WRITE_ONCE(txq->xmit_lock_owner, -1);
44444451 spin_unlock_bh(&txq->_xmit_lock);
44454452 }
44464453
include/linux/page-flags.h+7−7
@@ -686,13 +686,13 @@ static inline bool test_set_page_writeback(struct page *page) · 685 unmodified lines
686686
687687 __PAGEFLAG(Head, head, PF_ANY) CLEARPAGEFLAG(Head, head, PF_ANY)
688688
689−/* Whether there are one or multiple pages in a folio */
690−static inline bool folio_test_single(struct folio *folio)
691−{
692− return !folio_test_head(folio);
693−}
694−
695−static inline bool folio_test_multi(struct folio *folio)
689+/**
690+ * folio_test_large() - Does this folio contain more than one page?
691+ * @folio: The folio to test.
692+ *
693+ * Return: True if the folio is larger than one page.
694+ */
695+static inline bool folio_test_large(struct folio *folio)
696696 {
697697 return folio_test_head(folio);
698698 }
include/linux/pagemap.h+21−5
@@ -84,7 +84,7 @@ enum mapping_flags { · 83 unmodified lines
8484 AS_EXITING = 4, /* final truncate in progress */
8585 /* writeback related tags are not used */
8686 AS_NO_WRITEBACK_TAGS = 5,
87− AS_THP_SUPPORT = 6, /* THPs supported */
87+ AS_LARGE_FOLIO_SUPPORT = 6,
8888 };
8989
9090 /**
@@ -176,9 +176,25 @@ static inline void mapping_set_gfp_mask(struct address_space *m, gfp_t mask) · 85 unmodified lines
176176 m->gfp_mask = mask;
177177 }
178178
179−static inline bool mapping_thp_support(struct address_space *mapping)
179+/**
180+ * mapping_set_large_folios() - Indicate the file supports large folios.
181+ * @mapping: The file.
182+ *
183+ * The filesystem should call this function in its inode constructor to
184+ * indicate that the VFS can use large folios to cache the contents of
185+ * the file.
186+ *
187+ * Context: This should not be called while the inode is active as it
188+ * is non-atomic.
189+ */
190+static inline void mapping_set_large_folios(struct address_space *mapping)
191+{
192+ __set_bit(AS_LARGE_FOLIO_SUPPORT, &mapping->flags);
193+}
194+
195+static inline bool mapping_large_folio_support(struct address_space *mapping)
180196 {
181− return test_bit(AS_THP_SUPPORT, &mapping->flags);
197+ return test_bit(AS_LARGE_FOLIO_SUPPORT, &mapping->flags);
182198 }
183199
184200 static inline int filemap_nr_thps(struct address_space *mapping)
@@ -193,7 +209,7 @@ static inline int filemap_nr_thps(struct address_space *mapping) · 8 unmodified lines
193209 static inline void filemap_nr_thps_inc(struct address_space *mapping)
194210 {
195211 #ifdef CONFIG_READ_ONLY_THP_FOR_FS
196− if (!mapping_thp_support(mapping))
212+ if (!mapping_large_folio_support(mapping))
197213 atomic_inc(&mapping->nr_thps);
198214 #else
199215 WARN_ON_ONCE(1);
@@ -203,7 +219,7 @@ static inline void filemap_nr_thps_inc(struct address_space *mapping) · 3 unmodified lines
203219 static inline void filemap_nr_thps_dec(struct address_space *mapping)
204220 {
205221 #ifdef CONFIG_READ_ONLY_THP_FOR_FS
206− if (!mapping_thp_support(mapping))
222+ if (!mapping_large_folio_support(mapping))
207223 atomic_dec(&mapping->nr_thps);
208224 #else
209225 WARN_ON_ONCE(1);
include/linux/percpu-refcount.h+1−1
@@ -51,9 +51,9 @@ · 50 unmodified lines
5151 #define _LINUX_PERCPU_REFCOUNT_H
5252
5353 #include <linux/atomic.h>
54−#include <linux/kernel.h>
5554 #include <linux/percpu.h>
5655 #include <linux/rcupdate.h>
56+#include <linux/types.h>
5757 #include <linux/gfp.h>
5858
5959 struct percpu_ref;
include/linux/percpu.h+0−1
@@ -6,7 +6,6 @@ · 5 unmodified lines
66 #include <linux/preempt.h>
77 #include <linux/smp.h>
88 #include <linux/cpumask.h>
9−#include <linux/printk.h>
109 #include <linux/pfn.h>
1110 #include <linux/init.h>
1211
include/linux/phy.h+6−5
@@ -538,11 +538,12 @@ struct macsec_ops; · 537 unmodified lines
538538 * @mac_managed_pm: Set true if MAC driver takes of suspending/resuming PHY
539539 * @state: State of the PHY for management purposes
540540 * @dev_flags: Device-specific flags used by the PHY driver.
541− * Bits [15:0] are free to use by the PHY driver to communicate
542− * driver specific behavior.
543− * Bits [23:16] are currently reserved for future use.
544− * Bits [31:24] are reserved for defining generic
545− * PHY driver behavior.
541+ *
542+ * - Bits [15:0] are free to use by the PHY driver to communicate
543+ * driver specific behavior.
544+ * - Bits [23:16] are currently reserved for future use.
545+ * - Bits [31:24] are reserved for defining generic
546+ * PHY driver behavior.
546547 * @irq: IRQ number of the PHY's interrupt (-1 if none)
547548 * @phy_timer: The timer for handling the state machine
548549 * @phylink: Pointer to phylink instance for this PHY
include/linux/pm_runtime.h+1−1
@@ -129,7 +129,7 @@ static inline bool pm_runtime_suspended(struct device *dev) · 128 unmodified lines
129129 * pm_runtime_active - Check whether or not a device is runtime-active.
130130 * @dev: Target device.
131131 *
132− * Return %true if runtime PM is enabled for @dev and its runtime PM status is
132+ * Return %true if runtime PM is disabled for @dev or its runtime PM status is
133133 * %RPM_ACTIVE, or %false otherwise.
134134 *
135135 * Note that the return value of this function can only be trusted if it is
include/linux/printk.h+4−0
@@ -198,6 +198,7 @@ void dump_stack_print_info(const char *log_lvl); · 197 unmodified lines
198198 void show_regs_print_info(const char *log_lvl);
199199 extern asmlinkage void dump_stack_lvl(const char *log_lvl) __cold;
200200 extern asmlinkage void dump_stack(void) __cold;
201+void printk_trigger_flush(void);
201202 #else
202203 static inline __printf(1, 0)
203204 int vprintk(const char *s, va_list args)
@@ -274,6 +275,9 @@ static inline void dump_stack_lvl(const char *log_lvl) · 70 unmodified lines
274275 static inline void dump_stack(void)
275276 {
276277 }
278+static inline void printk_trigger_flush(void)
279+{
280+}
277281 #endif
278282
279283 #ifdef CONFIG_SMP
include/linux/ptp_classify.h+1−0
@@ -37,6 +37,7 @@ · 36 unmodified lines
3737 #define PTP_MSGTYPE_PDELAY_RESP 0x3
3838
3939 #define PTP_EV_PORT 319
40+#define PTP_GEN_PORT 320
4041 #define PTP_GEN_BIT 0x08 /* indicates general message, if set in message type */
4142
4243 #define OFF_PTP_SOURCE_UUID 22 /* PTPv1 only */
include/linux/regulator/driver.h+8−6
@@ -499,7 +499,8 @@ struct regulator_irq_data { · 498 unmodified lines
499499 * best to shut-down regulator(s) or reboot the SOC if error
500500 * handling is repeatedly failing. If fatal_cnt is given the IRQ
501501 * handling is aborted if it fails for fatal_cnt times and die()
502− * callback (if populated) or BUG() is called to try to prevent
502+ * callback (if populated) is called. If die() is not populated
503+ * poweroff for the system is attempted in order to prevent any
503504 * further damage.
504505 * @reread_ms: The time which is waited before attempting to re-read status
505506 * at the worker if IC reading fails. Immediate re-read is done
@@ -516,11 +517,12 @@ struct regulator_irq_data { · 10 unmodified lines
516517 * @data: Driver private data pointer which will be passed as such to
517518 * the renable, map_event and die callbacks in regulator_irq_data.
518519 * @die: Protection callback. If IC status reading or recovery actions
519− * fail fatal_cnt times this callback or BUG() is called. This
520− * callback should implement a final protection attempt like
521− * disabling the regulator. If protection succeeded this may
522− * return 0. If anything else is returned the core assumes final
523− * protection failed and calls BUG() as a last resort.
520+ * fail fatal_cnt times this callback is called or system is
521+ * powered off. This callback should implement a final protection
522+ * attempt like disabling the regulator. If protection succeeded
523+ * die() may return 0. If anything else is returned the core
524+ * assumes final protection failed and attempts to perform a
525+ * poweroff as a last resort.
524526 * @map_event: Driver callback to map IRQ status into regulator devices with
525527 * events / errors. NOTE: callback MUST initialize both the
526528 * errors and notifs for all rdevs which it signals having
include/linux/sched/cputime.h+3−2
@@ -18,15 +18,16 @@ · 17 unmodified lines
1818 #endif /* CONFIG_VIRT_CPU_ACCOUNTING_NATIVE */
1919
2020 #ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
21−extern void task_cputime(struct task_struct *t,
21+extern bool task_cputime(struct task_struct *t,
2222 u64 *utime, u64 *stime);
2323 extern u64 task_gtime(struct task_struct *t);
2424 #else
25−static inline void task_cputime(struct task_struct *t,
25+static inline bool task_cputime(struct task_struct *t,
2626 u64 *utime, u64 *stime)
2727 {
2828 *utime = t->utime;
2929 *stime = t->stime;
30+ return false;
3031 }
3132
3233 static inline u64 task_gtime(struct task_struct *t)
include/linux/sched/signal.h+1−0
@@ -352,6 +352,7 @@ extern __must_check bool do_notify_parent(struct task_struct *, int); · 351 unmodified lines
352352 extern void __wake_up_parent(struct task_struct *p, struct task_struct *parent);
353353 extern void force_sig(int);
354354 extern void force_fatal_sig(int);
355+extern void force_exit_sig(int);
355356 extern int send_sig(int, struct task_struct *, int);
356357 extern int zap_other_threads(struct task_struct *p);
357358 extern struct sigqueue *sigqueue_alloc(void);
include/linux/sched/task.h+1−1
@@ -158,7 +158,7 @@ static inline struct vm_struct *task_stack_vm_area(const struct task_struct *t) · 157 unmodified lines
158158 * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring
159159 * subscriptions and synchronises with wait4(). Also used in procfs. Also
160160 * pins the final release of task.io_context. Also protects ->cpuset and
161− * ->cgroup.subsys[]. And ->vfork_done.
161+ * ->cgroup.subsys[]. And ->vfork_done. And ->sysvshm.shm_clist.
162162 *
163163 * Nests both inside and outside of read_lock(&tasklist_lock).
164164 * It must not be nested with write_lock_irq(&tasklist_lock),
include/linux/sdb.h+0−160
@@ -1,160 +0,0 @@
1−/* SPDX-License-Identifier: GPL-2.0 */
2−/*
3− * This is the official version 1.1 of sdb.h
4− */
5−#ifndef __SDB_H__
6−#define __SDB_H__
7−#ifdef __KERNEL__
8−#include <linux/types.h>
9−#else
10−#include <stdint.h>
11−#endif
12−
13−/*
14− * All structures are 64 bytes long and are expected
15− * to live in an array, one for each interconnect.
16− * Most fields of the structures are shared among the
17− * various types, and most-specific fields are at the
18− * beginning (for alignment reasons, and to keep the
19− * magic number at the head of the interconnect record
20− */
21−
22−/* Product, 40 bytes at offset 24, 8-byte aligned
23− *
24− * device_id is vendor-assigned; version is device-specific,
25− * date is hex (e.g 0x20120501), name is UTF-8, blank-filled
26− * and not terminated with a 0 byte.
27− */
28−struct sdb_product {
29− uint64_t vendor_id; /* 0x18..0x1f */
30− uint32_t device_id; /* 0x20..0x23 */
31− uint32_t version; /* 0x24..0x27 */
32− uint32_t date; /* 0x28..0x2b */
33− uint8_t name[19]; /* 0x2c..0x3e */
34− uint8_t record_type; /* 0x3f */
35−};
36−
37−/*
38− * Component, 56 bytes at offset 8, 8-byte aligned
39− *
40− * The address range is first to last, inclusive
41− * (for example 0x100000 - 0x10ffff)
42− */
43−struct sdb_component {
44− uint64_t addr_first; /* 0x08..0x0f */
45− uint64_t addr_last; /* 0x10..0x17 */
46− struct sdb_product product; /* 0x18..0x3f */
47−};
48−
49−/* Type of the SDB record */
50−enum sdb_record_type {
51− sdb_type_interconnect = 0x00,
52− sdb_type_device = 0x01,
53− sdb_type_bridge = 0x02,
54− sdb_type_integration = 0x80,
55− sdb_type_repo_url = 0x81,
56− sdb_type_synthesis = 0x82,
57− sdb_type_empty = 0xFF,
58−};
59−
60−/* Type 0: interconnect (first of the array)
61− *
62− * sdb_records is the length of the table including this first
63− * record, version is 1. The bus type is enumerated later.
64− */
65−#define SDB_MAGIC 0x5344422d /* "SDB-" */
66−struct sdb_interconnect {
67− uint32_t sdb_magic; /* 0x00-0x03 */
68− uint16_t sdb_records; /* 0x04-0x05 */
69− uint8_t sdb_version; /* 0x06 */
70− uint8_t sdb_bus_type; /* 0x07 */
71− struct sdb_component sdb_component; /* 0x08-0x3f */
72−};
73−
74−/* Type 1: device
75− *
76− * class is 0 for "custom device", other values are
77− * to be standardized; ABI version is for the driver,
78− * bus-specific bits are defined by each bus (see below)
79− */
80−struct sdb_device {
81− uint16_t abi_class; /* 0x00-0x01 */
82− uint8_t abi_ver_major; /* 0x02 */
83− uint8_t abi_ver_minor; /* 0x03 */
84− uint32_t bus_specific; /* 0x04-0x07 */
85− struct sdb_component sdb_component; /* 0x08-0x3f */
86−};
87−
88−/* Type 2: bridge
89− *
90− * child is the address of the nested SDB table
91− */
92−struct sdb_bridge {
93− uint64_t sdb_child; /* 0x00-0x07 */
94− struct sdb_component sdb_component; /* 0x08-0x3f */
95−};
96−
97−/* Type 0x80: integration
98− *
99− * all types with bit 7 set are meta-information, so
100− * software can ignore the types it doesn't know. Here we
101− * just provide product information for an aggregate device
102− */
103−struct sdb_integration {
104− uint8_t reserved[24]; /* 0x00-0x17 */
105− struct sdb_product product; /* 0x08-0x3f */
106−};
107−
108−/* Type 0x81: Top module repository url
109− *
110− * again, an informative field that software can ignore
111− */
112−struct sdb_repo_url {
113− uint8_t repo_url[63]; /* 0x00-0x3e */
114− uint8_t record_type; /* 0x3f */
115−};
116−
117−/* Type 0x82: Synthesis tool information
118− *
119− * this informative record
120− */
121−struct sdb_synthesis {
122− uint8_t syn_name[16]; /* 0x00-0x0f */
123− uint8_t commit_id[16]; /* 0x10-0x1f */
124− uint8_t tool_name[8]; /* 0x20-0x27 */
125− uint32_t tool_version; /* 0x28-0x2b */
126− uint32_t date; /* 0x2c-0x2f */
127− uint8_t user_name[15]; /* 0x30-0x3e */
128− uint8_t record_type; /* 0x3f */
129−};
130−
131−/* Type 0xff: empty
132− *
133− * this allows keeping empty slots during development,
134− * so they can be filled later with minimal efforts and
135− * no misleading description is ever shipped -- hopefully.
136− * It can also be used to pad a table to a desired length.
137− */
138−struct sdb_empty {
139− uint8_t reserved[63]; /* 0x00-0x3e */
140− uint8_t record_type; /* 0x3f */
141−};
142−
143−/* The type of bus, for bus-specific flags */
144−enum sdb_bus_type {
145− sdb_wishbone = 0x00,
146− sdb_data = 0x01,
147−};
148−
149−#define SDB_WB_WIDTH_MASK 0x0f
150−#define SDB_WB_ACCESS8 0x01
151−#define SDB_WB_ACCESS16 0x02
152−#define SDB_WB_ACCESS32 0x04
153−#define SDB_WB_ACCESS64 0x08
154−#define SDB_WB_LITTLE_ENDIAN 0x80
155−
156−#define SDB_DATA_READ 0x04
157−#define SDB_DATA_WRITE 0x02
158−#define SDB_DATA_EXEC 0x01
159−
160−#endif /* __SDB_H__ */
include/linux/siphash.h+4−10
@@ -27,9 +27,7 @@ static inline bool siphash_key_is_zero(const siphash_key_t *key) · 26 unmodified lines
2727 }
2828
2929 u64 __siphash_aligned(const void *data, size_t len, const siphash_key_t *key);
30−#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
3130 u64 __siphash_unaligned(const void *data, size_t len, const siphash_key_t *key);
32−#endif
3331
3432 u64 siphash_1u64(const u64 a, const siphash_key_t *key);
3533 u64 siphash_2u64(const u64 a, const u64 b, const siphash_key_t *key);
@@ -82,10 +80,9 @@ static inline u64 ___siphash_aligned(const __le64 *data, size_t len, · 46 unmodified lines
8280 static inline u64 siphash(const void *data, size_t len,
8381 const siphash_key_t *key)
8482 {
85−#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
86− if (!IS_ALIGNED((unsigned long)data, SIPHASH_ALIGNMENT))
83+ if (IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) ||
84+ !IS_ALIGNED((unsigned long)data, SIPHASH_ALIGNMENT))
8785 return __siphash_unaligned(data, len, key);
88−#endif
8986 return ___siphash_aligned(data, len, key);
9087 }
9188
@@ -96,10 +93,8 @@ typedef struct { · 4 unmodified lines
9693
9794 u32 __hsiphash_aligned(const void *data, size_t len,
9895 const hsiphash_key_t *key);
99−#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
10096 u32 __hsiphash_unaligned(const void *data, size_t len,
10197 const hsiphash_key_t *key);
102−#endif
10398
10499 u32 hsiphash_1u32(const u32 a, const hsiphash_key_t *key);
105100 u32 hsiphash_2u32(const u32 a, const u32 b, const hsiphash_key_t *key);
@@ -135,10 +130,9 @@ static inline u32 ___hsiphash_aligned(const __le32 *data, size_t len, · 29 unmodified lines
135130 static inline u32 hsiphash(const void *data, size_t len,
136131 const hsiphash_key_t *key)
137132 {
138−#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
139− if (!IS_ALIGNED((unsigned long)data, HSIPHASH_ALIGNMENT))
133+ if (IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) ||
134+ !IS_ALIGNED((unsigned long)data, HSIPHASH_ALIGNMENT))
140135 return __hsiphash_unaligned(data, len, key);
141−#endif
142136 return ___hsiphash_aligned(data, len, key);
143137 }
144138
include/linux/skbuff.h+1−1
@@ -4226,7 +4226,7 @@ static inline void skb_remcsum_process(struct sk_buff *skb, void *ptr, · 4225 unmodified lines
42264226 return;
42274227 }
42284228
4229− if (unlikely(skb->ip_summed != CHECKSUM_COMPLETE)) {
4229+ if (unlikely(skb->ip_summed != CHECKSUM_COMPLETE)) {
42304230 __skb_checksum_complete(skb);
42314231 skb_postpull_rcsum(skb, skb->data, ptr - (void *)skb->data);
42324232 }
include/linux/trace_events.h+1−1
@@ -673,7 +673,7 @@ struct trace_event_file { · 672 unmodified lines
673673
674674 #define PERF_MAX_TRACE_SIZE 8192
675675
676−#define MAX_FILTER_STR_VAL 256 /* Should handle KSYM_SYMBOL_LEN */
676+#define MAX_FILTER_STR_VAL 256U /* Should handle KSYM_SYMBOL_LEN */
677677
678678 enum event_trigger_type {
679679 ETT_NONE = (0),
include/linux/virtio.h+0−2
@@ -152,7 +152,6 @@ size_t virtio_max_dma_size(struct virtio_device *vdev); · 151 unmodified lines
152152 * @feature_table_size: number of entries in the feature table array.
153153 * @feature_table_legacy: same as feature_table but when working in legacy mode.
154154 * @feature_table_size_legacy: number of entries in feature table legacy array.
155− * @suppress_used_validation: set to not have core validate used length
156155 * @probe: the function to call when a device is found. Returns 0 or -errno.
157156 * @scan: optional function to call after successful probe; intended
158157 * for virtio-scsi to invoke a scan.
@@ -169,7 +168,6 @@ struct virtio_driver { · 10 unmodified lines
169168 unsigned int feature_table_size;
170169 const unsigned int *feature_table_legacy;
171170 unsigned int feature_table_size_legacy;
172− bool suppress_used_validation;
173171 int (*validate)(struct virtio_device *dev);
174172 int (*probe)(struct virtio_device *dev);
175173 void (*scan)(struct virtio_device *dev);
include/linux/virtio_net.h+6−1
@@ -120,10 +120,15 @@ retry: · 119 unmodified lines
120120
121121 if (hdr->gso_type != VIRTIO_NET_HDR_GSO_NONE) {
122122 u16 gso_size = __virtio16_to_cpu(little_endian, hdr->gso_size);
123+ unsigned int nh_off = p_off;
123124 struct skb_shared_info *shinfo = skb_shinfo(skb);
124125
126+ /* UFO may not include transport header in gso_size. */
127+ if (gso_type & SKB_GSO_UDP)
128+ nh_off -= thlen;
129+
125130 /* Too small packets are not really GSO ones. */
126− if (skb->len - p_off > gso_size) {
131+ if (skb->len - nh_off > gso_size) {
127132 shinfo->gso_size = gso_size;
128133 shinfo->gso_type = gso_type;
129134
include/linux/wait.h+26−0
@@ -217,6 +217,7 @@ void __wake_up_sync_key(struct wait_queue_head *wq_head, unsigned int mode, void · 216 unmodified lines
217217 void __wake_up_locked_sync_key(struct wait_queue_head *wq_head, unsigned int mode, void *key);
218218 void __wake_up_locked(struct wait_queue_head *wq_head, unsigned int mode, int nr);
219219 void __wake_up_sync(struct wait_queue_head *wq_head, unsigned int mode);
220+void __wake_up_pollfree(struct wait_queue_head *wq_head);
220221
221222 #define wake_up(x) __wake_up(x, TASK_NORMAL, 1, NULL)
222223 #define wake_up_nr(x, nr) __wake_up(x, TASK_NORMAL, nr, NULL)
@@ -245,6 +246,31 @@ void __wake_up_sync(struct wait_queue_head *wq_head, unsigned int mode); · 22 unmodified lines
245246 #define wake_up_interruptible_sync_poll_locked(x, m) \
246247 __wake_up_locked_sync_key((x), TASK_INTERRUPTIBLE, poll_to_key(m))
247248
249+/**
250+ * wake_up_pollfree - signal that a polled waitqueue is going away
251+ * @wq_head: the wait queue head
252+ *
253+ * In the very rare cases where a ->poll() implementation uses a waitqueue whose
254+ * lifetime is tied to a task rather than to the 'struct file' being polled,
255+ * this function must be called before the waitqueue is freed so that
256+ * non-blocking polls (e.g. epoll) are notified that the queue is going away.
257+ *
258+ * The caller must also RCU-delay the freeing of the wait_queue_head, e.g. via
259+ * an explicit synchronize_rcu() or call_rcu(), or via SLAB_TYPESAFE_BY_RCU.
260+ */
261+static inline void wake_up_pollfree(struct wait_queue_head *wq_head)
262+{
263+ /*
264+ * For performance reasons, we don't always take the queue lock here.
265+ * Therefore, we might race with someone removing the last entry from
266+ * the queue, and proceed while they still hold the queue lock.
267+ * However, rcu_read_lock() is required to be held in such cases, so we
268+ * can safely proceed with an RCU-delayed free.
269+ */
270+ if (waitqueue_active(wq_head))
271+ __wake_up_pollfree(wq_head);
272+}
273+
248274 #define ___wait_cond_timeout(condition) \
249275 ({ \
250276 bool __cond = (condition); \
include/net/bond_alb.h+1−1
@@ -126,7 +126,7 @@ struct tlb_slave_info { · 125 unmodified lines
126126 struct alb_bond_info {
127127 struct tlb_client_info *tx_hashtbl; /* Dynamically allocated */
128128 u32 unbalanced_load;
129− int tx_rebalance_counter;
129+ atomic_t tx_rebalance_counter;
130130 int lp_counter;
131131 /* -------- rlb parameters -------- */
132132 int rlb_enabled;
include/net/busy_poll.h+13−0
@@ -132,6 +132,19 @@ static inline void sk_mark_napi_id(struct sock *sk, const struct sk_buff *skb) · 131 unmodified lines
132132 #ifdef CONFIG_NET_RX_BUSY_POLL
133133 if (unlikely(READ_ONCE(sk->sk_napi_id) != skb->napi_id))
134134 WRITE_ONCE(sk->sk_napi_id, skb->napi_id);
135+#endif
136+ sk_rx_queue_update(sk, skb);
137+}
138+
139+/* Variant of sk_mark_napi_id() for passive flow setup,
140+ * as sk->sk_napi_id and sk->sk_rx_queue_mapping content
141+ * needs to be set.
142+ */
143+static inline void sk_mark_napi_id_set(struct sock *sk,
144+ const struct sk_buff *skb)
145+{
146+#ifdef CONFIG_NET_RX_BUSY_POLL
147+ WRITE_ONCE(sk->sk_napi_id, skb->napi_id);
135148 #endif
136149 sk_rx_queue_set(sk, skb);
137150 }
include/net/dst_cache.h+11−0
@@ -79,6 +79,17 @@ static inline void dst_cache_reset(struct dst_cache *dst_cache) · 78 unmodified lines
7979 dst_cache->reset_ts = jiffies;
8080 }
8181
82+/**
83+ * dst_cache_reset_now - invalidate the cache contents immediately
84+ * @dst_cache: the cache
85+ *
86+ * The caller must be sure there are no concurrent users, as this frees
87+ * all dst_cache users immediately, rather than waiting for the next
88+ * per-cpu usage like dst_cache_reset does. Most callers should use the
89+ * higher speed lazily-freed dst_cache_reset function instead.
90+ */
91+void dst_cache_reset_now(struct dst_cache *dst_cache);
92+
8293 /**
8394 * dst_cache_init - initialize the cache, allocating the required storage
8495 * @dst_cache: the cache
include/net/fib_rules.h+3−1
@@ -69,7 +69,7 @@ struct fib_rules_ops { · 68 unmodified lines
6969 int (*action)(struct fib_rule *,
7070 struct flowi *, int,
7171 struct fib_lookup_arg *);
72− bool (*suppress)(struct fib_rule *,
72+ bool (*suppress)(struct fib_rule *, int,
7373 struct fib_lookup_arg *);
7474 int (*match)(struct fib_rule *,
7575 struct flowi *, int);
@@ -218,7 +218,9 @@ INDIRECT_CALLABLE_DECLARE(int fib4_rule_action(struct fib_rule *rule, · 142 unmodified lines
218218 struct fib_lookup_arg *arg));
219219
220220 INDIRECT_CALLABLE_DECLARE(bool fib6_rule_suppress(struct fib_rule *rule,
221+ int flags,
221222 struct fib_lookup_arg *arg));
222223 INDIRECT_CALLABLE_DECLARE(bool fib4_rule_suppress(struct fib_rule *rule,
224+ int flags,
223225 struct fib_lookup_arg *arg));
224226 #endif
include/net/ip6_fib.h+1−0
@@ -485,6 +485,7 @@ int fib6_nh_init(struct net *net, struct fib6_nh *fib6_nh, · 484 unmodified lines
485485 struct fib6_config *cfg, gfp_t gfp_flags,
486486 struct netlink_ext_ack *extack);
487487 void fib6_nh_release(struct fib6_nh *fib6_nh);
488+void fib6_nh_release_dsts(struct fib6_nh *fib6_nh);
488489
489490 int call_fib6_entry_notifiers(struct net *net,
490491 enum fib_event_type event_type,
include/net/ip_fib.h+1−1
@@ -438,7 +438,7 @@ int fib_validate_source(struct sk_buff *skb, __be32 src, __be32 dst, · 437 unmodified lines
438438 #ifdef CONFIG_IP_ROUTE_CLASSID
439439 static inline int fib_num_tclassid_users(struct net *net)
440440 {
441− return net->ipv4.fib_num_tclassid_users;
441+ return atomic_read(&net->ipv4.fib_num_tclassid_users);
442442 }
443443 #else
444444 static inline int fib_num_tclassid_users(struct net *net)
include/net/ipv6_stubs.h+1−0
@@ -47,6 +47,7 @@ struct ipv6_stub { · 46 unmodified lines
4747 struct fib6_config *cfg, gfp_t gfp_flags,
4848 struct netlink_ext_ack *extack);
4949 void (*fib6_nh_release)(struct fib6_nh *fib6_nh);
50+ void (*fib6_nh_release_dsts)(struct fib6_nh *fib6_nh);
5051 void (*fib6_update_sernum)(struct net *net, struct fib6_info *rt);
5152 int (*ip6_del_rt)(struct net *net, struct fib6_info *rt, bool skip_notify);
5253 void (*fib6_rt_update)(struct net *net, struct fib6_info *rt,
include/net/netfilter/nf_conntrack.h+3−3
@@ -276,14 +276,14 @@ static inline bool nf_is_loopback_packet(const struct sk_buff *skb) · 275 unmodified lines
276276 /* jiffies until ct expires, 0 if already expired */
277277 static inline unsigned long nf_ct_expires(const struct nf_conn *ct)
278278 {
279− s32 timeout = ct->timeout - nfct_time_stamp;
279+ s32 timeout = READ_ONCE(ct->timeout) - nfct_time_stamp;
280280
281281 return timeout > 0 ? timeout : 0;
282282 }
283283
284284 static inline bool nf_ct_is_expired(const struct nf_conn *ct)
285285 {
286− return (__s32)(ct->timeout - nfct_time_stamp) <= 0;
286+ return (__s32)(READ_ONCE(ct->timeout) - nfct_time_stamp) <= 0;
287287 }
288288
289289 /* use after obtaining a reference count */
@@ -302,7 +302,7 @@ static inline bool nf_ct_should_gc(const struct nf_conn *ct) · 12 unmodified lines
302302 static inline void nf_ct_offload_timeout(struct nf_conn *ct)
303303 {
304304 if (nf_ct_expires(ct) < NF_CT_DAY / 2)
305− ct->timeout = nfct_time_stamp + NF_CT_DAY;
305+ WRITE_ONCE(ct->timeout, nfct_time_stamp + NF_CT_DAY);
306306 }
307307
308308 struct kernel_param;
include/net/netns/ipv4.h+1−1
@@ -65,7 +65,7 @@ struct netns_ipv4 { · 64 unmodified lines
6565 bool fib_has_custom_local_routes;
6666 bool fib_offload_disabled;
6767 #ifdef CONFIG_IP_ROUTE_CLASSID
68− int fib_num_tclassid_users;
68+ atomic_t fib_num_tclassid_users;
6969 #endif
7070 struct hlist_head *fib_table_hash;
7171 struct sock *fibnl;
include/net/nfc/nci_core.h+1−0
@@ -30,6 +30,7 @@ enum nci_flag { · 29 unmodified lines
3030 NCI_UP,
3131 NCI_DATA_EXCHANGE,
3232 NCI_DATA_EXCHANGE_TO,
33+ NCI_UNREG,
3334 };
3435
3536 /* NCI device states */
include/net/nl802154.h+4−3
@@ -19,6 +19,8 @@ · 18 unmodified lines
1919 *
2020 */
2121
22+#include <linux/types.h>
23+
2224 #define NL802154_GENL_NAME "nl802154"
2325
2426 enum nl802154_commands {
@@ -150,10 +152,9 @@ enum nl802154_attrs { · 125 unmodified lines
150152 };
151153
152154 enum nl802154_iftype {
153− /* for backwards compatibility TODO */
154− NL802154_IFTYPE_UNSPEC = -1,
155+ NL802154_IFTYPE_UNSPEC = (~(__u32)0),
155156
156− NL802154_IFTYPE_NODE,
157+ NL802154_IFTYPE_NODE = 0,
157158 NL802154_IFTYPE_MONITOR,
158159 NL802154_IFTYPE_COORD,
159160
include/net/page_pool.h+11−1
@@ -216,14 +216,24 @@ static inline void page_pool_recycle_direct(struct page_pool *pool, · 215 unmodified lines
216216 page_pool_put_full_page(pool, page, true);
217217 }
218218
219+#define PAGE_POOL_DMA_USE_PP_FRAG_COUNT \
220+ (sizeof(dma_addr_t) > sizeof(unsigned long))
221+
219222 static inline dma_addr_t page_pool_get_dma_addr(struct page *page)
220223 {
221− return page->dma_addr;
224+ dma_addr_t ret = page->dma_addr;
225+
226+ if (PAGE_POOL_DMA_USE_PP_FRAG_COUNT)
227+ ret |= (dma_addr_t)page->dma_addr_upper << 16 << 16;
228+
229+ return ret;
222230 }
223231
224232 static inline void page_pool_set_dma_addr(struct page *page, dma_addr_t addr)
225233 {
226234 page->dma_addr = addr;
235+ if (PAGE_POOL_DMA_USE_PP_FRAG_COUNT)
236+ page->dma_addr_upper = upper_32_bits(addr);
227237 }
228238
229239 static inline void page_pool_set_frag_count(struct page *page, long nr)
include/net/sock.h+23−7
@@ -1913,18 +1913,31 @@ static inline int sk_tx_queue_get(const struct sock *sk) · 1912 unmodified lines
19131913 return -1;
19141914 }
19151915
1916−static inline void sk_rx_queue_set(struct sock *sk, const struct sk_buff *skb)
1916+static inline void __sk_rx_queue_set(struct sock *sk,
1917+ const struct sk_buff *skb,
1918+ bool force_set)
19171919 {
19181920 #ifdef CONFIG_SOCK_RX_QUEUE_MAPPING
19191921 if (skb_rx_queue_recorded(skb)) {
19201922 u16 rx_queue = skb_get_rx_queue(skb);
19211923
1922− if (unlikely(READ_ONCE(sk->sk_rx_queue_mapping) != rx_queue))
1924+ if (force_set ||
1925+ unlikely(READ_ONCE(sk->sk_rx_queue_mapping) != rx_queue))
19231926 WRITE_ONCE(sk->sk_rx_queue_mapping, rx_queue);
19241927 }
19251928 #endif
19261929 }
19271930
1931+static inline void sk_rx_queue_set(struct sock *sk, const struct sk_buff *skb)
1932+{
1933+ __sk_rx_queue_set(sk, skb, true);
1934+}
1935+
1936+static inline void sk_rx_queue_update(struct sock *sk, const struct sk_buff *skb)
1937+{
1938+ __sk_rx_queue_set(sk, skb, false);
1939+}
1940+
19281941 static inline void sk_rx_queue_clear(struct sock *sk)
19291942 {
19301943 #ifdef CONFIG_SOCK_RX_QUEUE_MAPPING
@@ -2430,19 +2443,22 @@ static inline void sk_stream_moderate_sndbuf(struct sock *sk) · 499 unmodified lines
24302443 * @sk: socket
24312444 *
24322445 * Use the per task page_frag instead of the per socket one for
2433− * optimization when we know that we're in the normal context and owns
2446+ * optimization when we know that we're in process context and own
24342447 * everything that's associated with %current.
24352448 *
2436− * gfpflags_allow_blocking() isn't enough here as direct reclaim may nest
2437− * inside other socket operations and end up recursing into sk_page_frag()
2438− * while it's already in use.
2449+ * Both direct reclaim and page faults can nest inside other
2450+ * socket operations and end up recursing into sk_page_frag()
2451+ * while it's already in use: explicitly avoid task page_frag
2452+ * usage if the caller is potentially doing any of them.
2453+ * This assumes that page fault handlers use the GFP_NOFS flags.
24392454 *
24402455 * Return: a per task page_frag if context allows that,
24412456 * otherwise a per socket one.
24422457 */
24432458 static inline struct page_frag *sk_page_frag(struct sock *sk)
24442459 {
2445− if (gfpflags_normal_context(sk->sk_allocation))
2460+ if ((sk->sk_allocation & (__GFP_DIRECT_RECLAIM | __GFP_MEMALLOC | __GFP_FS)) ==
2461+ (__GFP_DIRECT_RECLAIM | __GFP_FS))
24462462 return &current->task_frag;
24472463
24482464 return &sk->sk_frag;
include/rdma/rdma_netlink.h+1−1
@@ -30,7 +30,7 @@ enum rdma_nl_flags { · 29 unmodified lines
3030 * constant as well and the compiler checks they are the same.
3131 */
3232 #define MODULE_ALIAS_RDMA_NETLINK(_index, _val) \
33− static inline void __chk_##_index(void) \
33+ static inline void __maybe_unused __chk_##_index(void) \
3434 { \
3535 BUILD_BUG_ON(_index != _val); \
3636 } \
include/soc/mscc/ocelot_vcap.h+2−0
@@ -703,6 +703,8 @@ int ocelot_vcap_filter_add(struct ocelot *ocelot, · 702 unmodified lines
703703 struct netlink_ext_ack *extack);
704704 int ocelot_vcap_filter_del(struct ocelot *ocelot,
705705 struct ocelot_vcap_filter *rule);
706+int ocelot_vcap_filter_replace(struct ocelot *ocelot,
707+ struct ocelot_vcap_filter *filter);
706708 struct ocelot_vcap_filter *
707709 ocelot_vcap_block_find_filter_by_id(struct ocelot_vcap_block *block,
708710 unsigned long cookie, bool tc_offload);
include/sound/soc-acpi.h+1−1
@@ -147,7 +147,7 @@ struct snd_soc_acpi_link_adr { · 146 unmodified lines
147147 */
148148 /* Descriptor for SST ASoC machine driver */
149149 struct snd_soc_acpi_mach {
150− const u8 id[ACPI_ID_LEN];
150+ u8 id[ACPI_ID_LEN];
151151 const struct snd_soc_acpi_codecs *comp_ids;
152152 const u32 link_mask;
153153 const struct snd_soc_acpi_link_adr *links;
include/trace/events/rpcgss.h+1−1
@@ -8,7 +8,7 @@ · 7 unmodified lines
88 #undef TRACE_SYSTEM
99 #define TRACE_SYSTEM rpcgss
1010
11−#if !defined(_TRACE_RPCRDMA_H) || defined(TRACE_HEADER_MULTI_READ)
11+#if !defined(_TRACE_RPCGSS_H) || defined(TRACE_HEADER_MULTI_READ)
1212 #define _TRACE_RPCGSS_H
1313
1414 #include <linux/tracepoint.h>
include/uapi/asm-generic/poll.h+1−1
@@ -29,7 +29,7 @@ · 28 unmodified lines
2929 #define POLLRDHUP 0x2000
3030 #endif
3131
32−#define POLLFREE (__force __poll_t)0x4000 /* currently only for epoll */
32+#define POLLFREE (__force __poll_t)0x4000
3333
3434 #define POLL_BUSY_LOOP (__force __poll_t)0x8000
3535
include/uapi/drm/virtgpu_drm.h+7−0
@@ -196,6 +196,13 @@ struct drm_virtgpu_context_init { · 195 unmodified lines
196196 __u64 ctx_set_params;
197197 };
198198
199+/*
200+ * Event code that's given when VIRTGPU_CONTEXT_PARAM_POLL_RINGS_MASK is in
201+ * effect. The event size is sizeof(drm_event), since there is no additional
202+ * payload.
203+ */
204+#define VIRTGPU_EVENT_FENCE_SIGNALED 0x90000000
205+
199206 #define DRM_IOCTL_VIRTGPU_MAP \
200207 DRM_IOWR(DRM_COMMAND_BASE + DRM_VIRTGPU_MAP, struct drm_virtgpu_map)
201208
include/uapi/linux/if_ether.h+1−1
@@ -117,7 +117,7 @@ · 116 unmodified lines
117117 #define ETH_P_IFE 0xED3E /* ForCES inter-FE LFB type */
118118 #define ETH_P_AF_IUCV 0xFBFB /* IBM af_iucv [ NOT AN OFFICIALLY REGISTERED ID ] */
119119
120−#define ETH_P_802_3_MIN 0x0600 /* If the value in the ethernet type is less than this value
120+#define ETH_P_802_3_MIN 0x0600 /* If the value in the ethernet type is more than this value
121121 * then the frame is Ethernet II. Else it is 802.3 */
122122
123123 /*
include/uapi/linux/resource.h+10−3
@@ -66,10 +66,17 @@ struct rlimit64 { · 65 unmodified lines
6666 #define _STK_LIM (8*1024*1024)
6767
6868 /*
69− * GPG2 wants 64kB of mlocked memory, to make sure pass phrases
70− * and other sensitive information are never written to disk.
69+ * Limit the amount of locked memory by some sane default:
70+ * root can always increase this limit if needed.
71+ *
72+ * The main use-cases are (1) preventing sensitive memory
73+ * from being swapped; (2) real-time operations; (3) via
74+ * IOURING_REGISTER_BUFFERS.
75+ *
76+ * The first two don't need much. The latter will take as
77+ * much as it can get. 8MB is a reasonably sane default.
7178 */
72−#define MLOCK_LIMIT ((PAGE_SIZE > 64*1024) ? PAGE_SIZE : 64*1024)
79+#define MLOCK_LIMIT (8*1024*1024)
7380
7481 /*
7582 * Due to binary compatibility, the actual resource numbers
include/xen/xenbus.h+1−0
@@ -112,6 +112,7 @@ struct xenbus_driver { · 111 unmodified lines
112112 const char *name; /* defaults to ids[0].devicetype */
113113 const struct xenbus_device_id *ids;
114114 bool allow_rebind; /* avoid setting xenstore closed during remove */
115+ bool not_essential; /* is not mandatory for boot progress */
115116 int (*probe)(struct xenbus_device *dev,
116117 const struct xenbus_device_id *id);
117118 void (*otherend_changed)(struct xenbus_device *dev,

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t