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
50{50{
51}51}
52 52
53static inline void flush_dcache_folio(struct folio *folio) { }
54#define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE 053#define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE 0
55#define ARCH_IMPLEMENTS_FLUSH_DCACHE_FOLIO
56#endif
57
58#ifndef ARCH_IMPLEMENTS_FLUSH_DCACHE_FOLIO
59void flush_dcache_folio(struct folio *folio);
60#endif54#endif
61 55
62#ifndef flush_dcache_mmap_lock56#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
974 return -ENODEV;974 return -ENODEV;
975}975}
976 976
977static inline int acpi_register_wakeup_handler(int wake_irq,
978 bool (*wakeup)(void *context), void *context)
979{
980 return -ENXIO;
981}
982
983static inline void acpi_unregister_wakeup_handler(
984 bool (*wakeup)(void *context), void *context) { }
985
977#endif /* !CONFIG_ACPI */986#endif /* !CONFIG_ACPI */
978 987
979#ifdef CONFIG_ACPI_HOTPLUG_IOAPIC988#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
1173 1182
1174struct fwnode_handle *acpi_get_next_subnode(const struct fwnode_handle *fwnode,1183struct fwnode_handle *acpi_get_next_subnode(const struct fwnode_handle *fwnode,
1175 struct fwnode_handle *child);1184 struct fwnode_handle *child);
1176struct fwnode_handle *acpi_node_get_parent(const struct fwnode_handle *fwnode);
1177 1185
1178struct acpi_probe_entry;1186struct acpi_probe_entry;
1179typedef bool (*acpi_probe_entry_validate_subtbl)(struct acpi_subtable_header *,1187typedef 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
1278 return NULL;1286 return NULL;
1279}1287}
1280 1288
1281static inline struct fwnode_handle *
1282acpi_node_get_parent(const struct fwnode_handle *fwnode)
1283{
1284 return NULL;
1285}
1286
1287static inline struct fwnode_handle *1289static inline struct fwnode_handle *
1288acpi_graph_get_next_endpoint(const struct fwnode_handle *fwnode,1290acpi_graph_get_next_endpoint(const struct fwnode_handle *fwnode,
1289 struct fwnode_handle *prev)1291 struct fwnode_handle *prev)
include/linux/bpf.h+5−15
@@ -193,7 +193,7 @@ struct bpf_map { · 192 unmodified lines
193 atomic64_t usercnt;193 atomic64_t usercnt;
194 struct work_struct work;194 struct work_struct work;
195 struct mutex freeze_mutex;195 struct mutex freeze_mutex;
196 u64 writecnt; /* writable mmap cnt; protected by freeze_mutex */196 atomic64_t writecnt;
197};197};
198 198
199static inline bool map_value_has_spin_lock(const struct bpf_map *map)199static 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
732struct bpf_trampoline *bpf_trampoline_get(u64 key,732struct bpf_trampoline *bpf_trampoline_get(u64 key,
733 struct bpf_attach_target_info *tgt_info);733 struct bpf_attach_target_info *tgt_info);
734void bpf_trampoline_put(struct bpf_trampoline *tr);734void bpf_trampoline_put(struct bpf_trampoline *tr);
735int arch_prepare_bpf_dispatcher(void *image, s64 *funcs, int num_funcs);
735#define BPF_DISPATCHER_INIT(_name) { \736#define BPF_DISPATCHER_INIT(_name) { \
736 .mutex = __MUTEX_INITIALIZER(_name.mutex), \737 .mutex = __MUTEX_INITIALIZER(_name.mutex), \
737 .func = &_name##_func, \738 .func = &_name##_func, \
@@ -1352,28 +1353,16 @@ extern struct mutex bpf_stats_enabled_mutex; · 614 unmodified lines
1352 * kprobes, tracepoints) to prevent deadlocks on map operations as any of1353 * kprobes, tracepoints) to prevent deadlocks on map operations as any of
1353 * these events can happen inside a region which holds a map bucket lock1354 * these events can happen inside a region which holds a map bucket lock
1354 * and can deadlock on it.1355 * 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.
1361 */1356 */
1362static inline void bpf_disable_instrumentation(void)1357static inline void bpf_disable_instrumentation(void)
1363{1358{
1364 migrate_disable();1359 migrate_disable();
1365 if (IS_ENABLED(CONFIG_PREEMPT_RT))1360 this_cpu_inc(bpf_prog_active);
1366 this_cpu_inc(bpf_prog_active);
1367 else
1368 __this_cpu_inc(bpf_prog_active);
1369}1361}
1370 1362
1371static inline void bpf_enable_instrumentation(void)1363static inline void bpf_enable_instrumentation(void)
1372{1364{
1373 if (IS_ENABLED(CONFIG_PREEMPT_RT))1365 this_cpu_dec(bpf_prog_active);
1374 this_cpu_dec(bpf_prog_active);
1375 else
1376 __this_cpu_dec(bpf_prog_active);
1377 migrate_enable();1366 migrate_enable();
1378}1367}
1379 1368
@@ -1419,6 +1408,7 @@ void bpf_map_put(struct bpf_map *map); · 39 unmodified lines
1419void *bpf_map_area_alloc(u64 size, int numa_node);1408void *bpf_map_area_alloc(u64 size, int numa_node);
1420void *bpf_map_area_mmapable_alloc(u64 size, int numa_node);1409void *bpf_map_area_mmapable_alloc(u64 size, int numa_node);
1421void bpf_map_area_free(void *base);1410void bpf_map_area_free(void *base);
1411bool bpf_map_write_active(const struct bpf_map *map);
1422void bpf_map_init_from_attr(struct bpf_map *map, union bpf_attr *attr);1412void bpf_map_init_from_attr(struct bpf_map *map, union bpf_attr *attr);
1423int generic_map_lookup_batch(struct bpf_map *map,1413int generic_map_lookup_batch(struct bpf_map *map,
1424 const union bpf_attr *attr,1414 const union bpf_attr *attr,
include/linux/btf.h+10−4
@@ -245,7 +245,10 @@ struct kfunc_btf_id_set { · 244 unmodified lines
245 struct module *owner;245 struct module *owner;
246};246};
247 247
248struct kfunc_btf_id_list;248struct kfunc_btf_id_list {
249 struct list_head list;
250 struct mutex mutex;
251};
249 252
250#ifdef CONFIG_DEBUG_INFO_BTF_MODULES253#ifdef CONFIG_DEBUG_INFO_BTF_MODULES
251void register_kfunc_btf_id_set(struct kfunc_btf_id_list *l,254void 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
254 struct kfunc_btf_id_set *s);257 struct kfunc_btf_id_set *s);
255bool bpf_check_mod_kfunc_call(struct kfunc_btf_id_list *klist, u32 kfunc_id,258bool bpf_check_mod_kfunc_call(struct kfunc_btf_id_list *klist, u32 kfunc_id,
256 struct module *owner);259 struct module *owner);
260
261extern struct kfunc_btf_id_list bpf_tcp_ca_kfunc_list;
262extern struct kfunc_btf_id_list prog_test_kfunc_list;
257#else263#else
258static inline void register_kfunc_btf_id_set(struct kfunc_btf_id_list *l,264static inline void register_kfunc_btf_id_set(struct kfunc_btf_id_list *l,
259 struct kfunc_btf_id_set *s)265 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
268{274{
269 return false;275 return false;
270}276}
277
278static struct kfunc_btf_id_list bpf_tcp_ca_kfunc_list __maybe_unused;
279static struct kfunc_btf_id_list prog_test_kfunc_list __maybe_unused;
271#endif280#endif
272 281
273#define DEFINE_KFUNC_BTF_ID_SET(set, name) \282#define DEFINE_KFUNC_BTF_ID_SET(set, name) \
274 struct kfunc_btf_id_set name = { LIST_HEAD_INIT(name.list), (set), \283 struct kfunc_btf_id_set name = { LIST_HEAD_INIT(name.list), (set), \
275 THIS_MODULE }284 THIS_MODULE }
276 285
277extern struct kfunc_btf_id_list bpf_tcp_ca_kfunc_list;
278extern struct kfunc_btf_id_list prog_test_kfunc_list;
279
280#endif286#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
9void flush_dcache_folio(struct folio *folio);
10#endif
11#else
12static 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
3#define _LINUX_CACHEINFO_H3#define _LINUX_CACHEINFO_H
4 4
5#include <linux/bitops.h>5#include <linux/bitops.h>
6#include <linux/cpu.h>
7#include <linux/cpumask.h>6#include <linux/cpumask.h>
8#include <linux/smp.h>7#include <linux/smp.h>
9 8
include/linux/delay.h+13−1
@@ -20,6 +20,7 @@ · 19 unmodified lines
20 */20 */
21 21
22#include <linux/math.h>22#include <linux/math.h>
23#include <linux/sched.h>
23 24
24extern unsigned long loops_per_jiffy;25extern unsigned long loops_per_jiffy;
25 26
@@ -58,7 +59,18 @@ void calibrate_delay(void); · 32 unmodified lines
58void __attribute__((weak)) calibration_delay_done(void);59void __attribute__((weak)) calibration_delay_done(void);
59void msleep(unsigned int msecs);60void msleep(unsigned int msecs);
60unsigned long msleep_interruptible(unsigned int msecs);61unsigned long msleep_interruptible(unsigned int msecs);
61void usleep_range(unsigned long min, unsigned long max);62void usleep_range_state(unsigned long min, unsigned long max,
63 unsigned int state);
64
65static inline void usleep_range(unsigned long min, unsigned long max)
66{
67 usleep_range_state(min, max, TASK_UNINTERRUPTIBLE);
68}
69
70static inline void usleep_idle_range(unsigned long min, unsigned long max)
71{
72 usleep_range_state(min, max, TASK_IDLE);
73}
62 74
63static inline void ssleep(unsigned int seconds)75static inline void ssleep(unsigned int seconds)
64{76{
include/linux/device/driver.h+1−0
@@ -18,6 +18,7 @@ · 17 unmodified lines
18#include <linux/klist.h>18#include <linux/klist.h>
19#include <linux/pm.h>19#include <linux/pm.h>
20#include <linux/device/bus.h>20#include <linux/device/bus.h>
21#include <linux/module.h>
21 22
22/**23/**
23 * enum probe_type - device driver probe type to try24 * enum probe_type - device driver probe type to try
include/linux/filter.h+1−4
@@ -6,6 +6,7 @@ · 5 unmodified lines
6#define __LINUX_FILTER_H__6#define __LINUX_FILTER_H__
7 7
8#include <linux/atomic.h>8#include <linux/atomic.h>
9#include <linux/bpf.h>
9#include <linux/refcount.h>10#include <linux/refcount.h>
10#include <linux/compat.h>11#include <linux/compat.h>
11#include <linux/skbuff.h>12#include <linux/skbuff.h>
@@ -26,7 +27,6 @@ · 14 unmodified lines
26 27
27#include <asm/byteorder.h>28#include <asm/byteorder.h>
28#include <uapi/linux/filter.h>29#include <uapi/linux/filter.h>
29#include <uapi/linux/bpf.h>
30 30
31struct sk_buff;31struct sk_buff;
32struct sock;32struct sock;
@@ -640,9 +640,6 @@ static __always_inline u32 bpf_prog_run(const struct bpf_prog *prog, const void · 607 unmodified lines
640 * This uses migrate_disable/enable() explicitly to document that the640 * This uses migrate_disable/enable() explicitly to document that the
641 * invocation of a BPF program does not require reentrancy protection641 * invocation of a BPF program does not require reentrancy protection
642 * against a BPF program which is invoked from a preempting task.642 * 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.
646 */643 */
647static inline u32 bpf_prog_run_pin_on_cpu(const struct bpf_prog *prog,644static inline u32 bpf_prog_run_pin_on_cpu(const struct bpf_prog *prog,
648 const void *ctx)645 const void *ctx)
include/linux/fs.h+0−1
@@ -2518,7 +2518,6 @@ struct file_system_type { · 2517 unmodified lines
2518#define FS_USERNS_MOUNT 8 /* Can be mounted by userns root */2518#define FS_USERNS_MOUNT 8 /* Can be mounted by userns root */
2519#define FS_DISALLOW_NOTIFY_PERM 16 /* Disable fanotify permission events */2519#define FS_DISALLOW_NOTIFY_PERM 16 /* Disable fanotify permission events */
2520#define FS_ALLOW_IDMAP 32 /* FS has been updated to handle vfs idmappings. */2520#define FS_ALLOW_IDMAP 32 /* FS has been updated to handle vfs idmappings. */
2521#define FS_THP_SUPPORT 8192 /* Remove once all fs converted */
2522#define FS_RENAME_DOES_D_MOVE 32768 /* FS will handle d_move() during rename() internally. */2521#define FS_RENAME_DOES_D_MOVE 32768 /* FS will handle d_move() during rename() internally. */
2523 int (*init_fs_context)(struct fs_context *);2522 int (*init_fs_context)(struct fs_context *);
2524 const struct fs_parameter_spec *parameters;2523 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
840 return hdev->ll_driver == driver;840 return hdev->ll_driver == driver;
841}841}
842 842
843static inline bool hid_is_usb(struct hid_device *hdev)
844{
845 return hid_is_using_ll_driver(hdev, &usb_hid_driver);
846}
847
843#define PM_HINT_FULLON 1<<5848#define PM_HINT_FULLON 1<<5
844#define PM_HINT_NORMAL 1<<1849#define PM_HINT_NORMAL 1<<1
845 850
include/linux/highmem.h+42−5
@@ -5,12 +5,11 @@ · 4 unmodified lines
5#include <linux/fs.h>5#include <linux/fs.h>
6#include <linux/kernel.h>6#include <linux/kernel.h>
7#include <linux/bug.h>7#include <linux/bug.h>
8#include <linux/cacheflush.h>
8#include <linux/mm.h>9#include <linux/mm.h>
9#include <linux/uaccess.h>10#include <linux/uaccess.h>
10#include <linux/hardirq.h>11#include <linux/hardirq.h>
11 12
12#include <asm/cacheflush.h>
13
14#include "highmem-internal.h"13#include "highmem-internal.h"
15 14
16/**15/**
@@ -231,10 +230,10 @@ static inline void tag_clear_highpage(struct page *page) · 214 unmodified lines
231 * If we pass in a base or tail page, we can zero up to PAGE_SIZE.230 * If we pass in a base or tail page, we can zero up to PAGE_SIZE.
232 * If we pass in a head page, we can zero up to the size of the compound page.231 * If we pass in a head page, we can zero up to the size of the compound page.
233 */232 */
234#if defined(CONFIG_HIGHMEM) && defined(CONFIG_TRANSPARENT_HUGEPAGE)233#ifdef CONFIG_HIGHMEM
235void zero_user_segments(struct page *page, unsigned start1, unsigned end1,234void zero_user_segments(struct page *page, unsigned start1, unsigned end1,
236 unsigned start2, unsigned end2);235 unsigned start2, unsigned end2);
237#else /* !HIGHMEM || !TRANSPARENT_HUGEPAGE */236#else
238static inline void zero_user_segments(struct page *page,237static inline void zero_user_segments(struct page *page,
239 unsigned start1, unsigned end1,238 unsigned start1, unsigned end1,
240 unsigned start2, unsigned end2)239 unsigned start2, unsigned end2)
@@ -254,7 +253,7 @@ static inline void zero_user_segments(struct page *page, · 13 unmodified lines
254 for (i = 0; i < compound_nr(page); i++)253 for (i = 0; i < compound_nr(page); i++)
255 flush_dcache_page(page + i);254 flush_dcache_page(page + i);
256}255}
257#endif /* !HIGHMEM || !TRANSPARENT_HUGEPAGE */256#endif
258 257
259static inline void zero_user_segment(struct page *page,258static inline void zero_user_segment(struct page *page,
260 unsigned start, unsigned end)259 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
364 kunmap_local(addr);363 kunmap_local(addr);
365}364}
366 365
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 */
374static 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 */
386static 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 */
398static 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
367#endif /* _LINUX_HIGHMEM_H */404#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
128 css_get(resv_map->css);128 css_get(resv_map->css);
129}129}
130 130
131static 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
131extern int hugetlb_cgroup_charge_cgroup(int idx, unsigned long nr_pages,138extern int hugetlb_cgroup_charge_cgroup(int idx, unsigned long nr_pages,
132 struct hugetlb_cgroup **ptr);139 struct hugetlb_cgroup **ptr);
133extern int hugetlb_cgroup_charge_cgroup_rsvd(int idx, unsigned long nr_pages,140extern 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
211{218{
212}219}
213 220
221static inline void resv_map_put_hugetlb_cgroup_uncharge_info(
222 struct resv_map *resv_map)
223{
224}
225
214static inline int hugetlb_cgroup_charge_cgroup(int idx, unsigned long nr_pages,226static inline int hugetlb_cgroup_charge_cgroup(int idx, unsigned long nr_pages,
215 struct hugetlb_cgroup **ptr)227 struct hugetlb_cgroup **ptr)
216{228{
include/linux/intel-ish-client-if.h+2−2
@@ -9,7 +9,7 @@ · 8 unmodified lines
9#define _INTEL_ISH_CLIENT_IF_H_9#define _INTEL_ISH_CLIENT_IF_H_
10 10
11#include <linux/device.h>11#include <linux/device.h>
12#include <linux/uuid.h>12#include <linux/mod_devicetable.h>
13 13
14struct ishtp_cl_device;14struct ishtp_cl_device;
15struct ishtp_device;15struct ishtp_device;
@@ -40,7 +40,7 @@ enum cl_state { · 24 unmodified lines
40struct ishtp_cl_driver {40struct ishtp_cl_driver {
41 struct device_driver driver;41 struct device_driver driver;
42 const char *name;42 const char *name;
43 const guid_t *guid;43 const struct ishtp_device_id *id;
44 int (*probe)(struct ishtp_cl_device *dev);44 int (*probe)(struct ishtp_cl_device *dev);
45 void (*remove)(struct ishtp_cl_device *dev);45 void (*remove)(struct ishtp_cl_device *dev);
46 int (*reset)(struct ishtp_cl_device *dev);46 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
131 return ns;131 return ns;
132}132}
133 133
134static 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
134extern void put_ipc_ns(struct ipc_namespace *ns);144extern void put_ipc_ns(struct ipc_namespace *ns);
135#else145#else
136static inline struct ipc_namespace *copy_ipcs(unsigned long flags,146static 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
147 return ns;157 return ns;
148}158}
149 159
160static inline struct ipc_namespace *get_ipc_ns_not_zero(struct ipc_namespace *ns)
161{
162 return ns;
163}
164
150static inline void put_ipc_ns(struct ipc_namespace *ns)165static inline void put_ipc_ns(struct ipc_namespace *ns)
151{166{
152}167}
include/linux/kprobes.h+2−0
@@ -153,6 +153,8 @@ struct kretprobe { · 152 unmodified lines
153 struct kretprobe_holder *rph;153 struct kretprobe_holder *rph;
154};154};
155 155
156#define KRETPROBE_MAX_DATA_SIZE 4096
157
156struct kretprobe_instance {158struct kretprobe_instance {
157 union {159 union {
158 struct freelist_node freelist;160 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
874void kvm_set_pfn_dirty(kvm_pfn_t pfn);874void kvm_set_pfn_dirty(kvm_pfn_t pfn);
875void kvm_set_pfn_accessed(kvm_pfn_t pfn);875void kvm_set_pfn_accessed(kvm_pfn_t pfn);
876 876
877void kvm_release_pfn(kvm_pfn_t pfn, bool dirty, struct gfn_to_pfn_cache *cache);877void kvm_release_pfn(kvm_pfn_t pfn, bool dirty);
878int kvm_read_guest_page(struct kvm *kvm, gfn_t gfn, void *data, int offset,878int kvm_read_guest_page(struct kvm *kvm, gfn_t gfn, void *data, int offset,
879 int len);879 int len);
880int kvm_read_guest(struct kvm *kvm, gpa_t gpa, void *data, unsigned long len);880int 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
950kvm_pfn_t kvm_vcpu_gfn_to_pfn_atomic(struct kvm_vcpu *vcpu, gfn_t gfn);950kvm_pfn_t kvm_vcpu_gfn_to_pfn_atomic(struct kvm_vcpu *vcpu, gfn_t gfn);
951kvm_pfn_t kvm_vcpu_gfn_to_pfn(struct kvm_vcpu *vcpu, gfn_t gfn);951kvm_pfn_t kvm_vcpu_gfn_to_pfn(struct kvm_vcpu *vcpu, gfn_t gfn);
952int kvm_vcpu_map(struct kvm_vcpu *vcpu, gpa_t gpa, struct kvm_host_map *map);952int kvm_vcpu_map(struct kvm_vcpu *vcpu, gpa_t gpa, struct kvm_host_map *map);
953int kvm_map_gfn(struct kvm_vcpu *vcpu, gfn_t gfn, struct kvm_host_map *map,
954 struct gfn_to_pfn_cache *cache, bool atomic);
955struct page *kvm_vcpu_gfn_to_page(struct kvm_vcpu *vcpu, gfn_t gfn);953struct page *kvm_vcpu_gfn_to_page(struct kvm_vcpu *vcpu, gfn_t gfn);
956void kvm_vcpu_unmap(struct kvm_vcpu *vcpu, struct kvm_host_map *map, bool dirty);954void kvm_vcpu_unmap(struct kvm_vcpu *vcpu, struct kvm_host_map *map, bool dirty);
957int kvm_unmap_gfn(struct kvm_vcpu *vcpu, struct kvm_host_map *map,
958 struct gfn_to_pfn_cache *cache, bool dirty, bool atomic);
959unsigned long kvm_vcpu_gfn_to_hva(struct kvm_vcpu *vcpu, gfn_t gfn);955unsigned long kvm_vcpu_gfn_to_hva(struct kvm_vcpu *vcpu, gfn_t gfn);
960unsigned long kvm_vcpu_gfn_to_hva_prot(struct kvm_vcpu *vcpu, gfn_t gfn, bool *writable);956unsigned long kvm_vcpu_gfn_to_hva_prot(struct kvm_vcpu *vcpu, gfn_t gfn, bool *writable);
961int kvm_vcpu_read_guest_page(struct kvm_vcpu *vcpu, gfn_t gfn, void *data, int offset,957int 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
53 struct kvm_memory_slot *memslot;53 struct kvm_memory_slot *memslot;
54};54};
55 55
56struct gfn_to_pfn_cache {
57 u64 generation;
58 gfn_t gfn;
59 kvm_pfn_t pfn;
60 bool dirty;
61};
62
63#ifdef KVM_ARCH_NR_OBJS_PER_MEMORY_CACHE56#ifdef KVM_ARCH_NR_OBJS_PER_MEMORY_CACHE
64/*57/*
65 * Memory caches are used to preallocate memory ahead of various MMU flows,58 * 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
663 */663 */
664int mhi_pm_resume(struct mhi_controller *mhi_cntrl);664int mhi_pm_resume(struct mhi_controller *mhi_cntrl);
665 665
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 */
677int mhi_pm_resume_force(struct mhi_controller *mhi_cntrl);
678
666/**679/**
667 * mhi_download_rddm_image - Download ramdump image from device for680 * mhi_download_rddm_image - Download ramdump image from device for
668 * debugging purpose.681 * 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
145 GENMASK(31 - ESW_TUN_ID_BITS - ESW_RESERVED_BITS, \145 GENMASK(31 - ESW_TUN_ID_BITS - ESW_RESERVED_BITS, \
146 ESW_TUN_OPTS_OFFSET + 1)146 ESW_TUN_OPTS_OFFSET + 1)
147 147
148u8 mlx5_eswitch_mode(struct mlx5_core_dev *dev);148u8 mlx5_eswitch_mode(const struct mlx5_core_dev *dev);
149u16 mlx5_eswitch_get_total_vports(const struct mlx5_core_dev *dev);149u16 mlx5_eswitch_get_total_vports(const struct mlx5_core_dev *dev);
150struct mlx5_core_dev *mlx5_eswitch_get_core_dev(struct mlx5_eswitch *esw);150struct mlx5_core_dev *mlx5_eswitch_get_core_dev(struct mlx5_eswitch *esw);
151 151
152#else /* CONFIG_MLX5_ESWITCH */152#else /* CONFIG_MLX5_ESWITCH */
153 153
154static inline u8 mlx5_eswitch_mode(struct mlx5_core_dev *dev)154static inline u8 mlx5_eswitch_mode(const struct mlx5_core_dev *dev)
155{155{
156 return MLX5_ESWITCH_NONE;156 return MLX5_ESWITCH_NONE;
157}157}
include/linux/mlx5/mlx5_ifc.h+4−1
@@ -9698,7 +9698,10 @@ struct mlx5_ifc_mcam_access_reg_bits { · 9697 unmodified lines
9698 u8 regs_84_to_68[0x11];9698 u8 regs_84_to_68[0x11];
9699 u8 tracer_registers[0x4];9699 u8 tracer_registers[0x4];
9700 9700
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
9702 u8 regs_31_to_0[0x20];9705 u8 regs_31_to_0[0x20];
9703};9706};
9704 9707
include/linux/mm_types.h+12−1
@@ -105,7 +105,18 @@ struct page { · 104 unmodified lines
105 struct page_pool *pp;105 struct page_pool *pp;
106 unsigned long _pp_mapping_pad;106 unsigned long _pp_mapping_pad;
107 unsigned long dma_addr;107 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 };
109 };120 };
110 struct { /* slab, slob and slub */121 struct { /* slab, slob and slub */
111 union {122 union {
include/linux/mod_devicetable.h+14−0
@@ -895,4 +895,18 @@ struct dfl_device_id { · 894 unmodified lines
895 kernel_ulong_t driver_data;895 kernel_ulong_t driver_data;
896};896};
897 897
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 */
907struct ishtp_device_id {
908 guid_t guid;
909 kernel_ulong_t driver_data;
910};
911
898#endif /* LINUX_MOD_DEVICETABLE_H */912#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
4404static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)4404static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)
4405{4405{
4406 spin_lock(&txq->_xmit_lock);4406 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);
4408}4409}
4409 4410
4410static inline bool __netif_tx_acquire(struct netdev_queue *txq)4411static 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
4421static inline void __netif_tx_lock_bh(struct netdev_queue *txq)4422static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
4422{4423{
4423 spin_lock_bh(&txq->_xmit_lock);4424 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());
4425}4427}
4426 4428
4427static inline bool __netif_tx_trylock(struct netdev_queue *txq)4429static inline bool __netif_tx_trylock(struct netdev_queue *txq)
4428{4430{
4429 bool ok = spin_trylock(&txq->_xmit_lock);4431 bool ok = spin_trylock(&txq->_xmit_lock);
4430 if (likely(ok))4432
4431 txq->xmit_lock_owner = smp_processor_id();4433 if (likely(ok)) {
4434 /* Pairs with READ_ONCE() in __dev_queue_xmit() */
4435 WRITE_ONCE(txq->xmit_lock_owner, smp_processor_id());
4436 }
4432 return ok;4437 return ok;
4433}4438}
4434 4439
4435static inline void __netif_tx_unlock(struct netdev_queue *txq)4440static inline void __netif_tx_unlock(struct netdev_queue *txq)
4436{4441{
4437 txq->xmit_lock_owner = -1;4442 /* Pairs with READ_ONCE() in __dev_queue_xmit() */
4443 WRITE_ONCE(txq->xmit_lock_owner, -1);
4438 spin_unlock(&txq->_xmit_lock);4444 spin_unlock(&txq->_xmit_lock);
4439}4445}
4440 4446
4441static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)4447static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
4442{4448{
4443 txq->xmit_lock_owner = -1;4449 /* Pairs with READ_ONCE() in __dev_queue_xmit() */
4450 WRITE_ONCE(txq->xmit_lock_owner, -1);
4444 spin_unlock_bh(&txq->_xmit_lock);4451 spin_unlock_bh(&txq->_xmit_lock);
4445}4452}
4446 4453
include/linux/page-flags.h+7−7
@@ -686,13 +686,13 @@ static inline bool test_set_page_writeback(struct page *page) · 685 unmodified lines
686 686
687__PAGEFLAG(Head, head, PF_ANY) CLEARPAGEFLAG(Head, head, PF_ANY)687__PAGEFLAG(Head, head, PF_ANY) CLEARPAGEFLAG(Head, head, PF_ANY)
688 688
689/* Whether there are one or multiple pages in a folio */689/**
690static inline bool folio_test_single(struct folio *folio)690 * folio_test_large() - Does this folio contain more than one page?
691{691 * @folio: The folio to test.
692 return !folio_test_head(folio);692 *
693}693 * Return: True if the folio is larger than one page.
694 694 */
695static inline bool folio_test_multi(struct folio *folio)695static inline bool folio_test_large(struct folio *folio)
696{696{
697 return folio_test_head(folio);697 return folio_test_head(folio);
698}698}
include/linux/pagemap.h+21−5
@@ -84,7 +84,7 @@ enum mapping_flags { · 83 unmodified lines
84 AS_EXITING = 4, /* final truncate in progress */84 AS_EXITING = 4, /* final truncate in progress */
85 /* writeback related tags are not used */85 /* writeback related tags are not used */
86 AS_NO_WRITEBACK_TAGS = 5,86 AS_NO_WRITEBACK_TAGS = 5,
87 AS_THP_SUPPORT = 6, /* THPs supported */87 AS_LARGE_FOLIO_SUPPORT = 6,
88};88};
89 89
90/**90/**
@@ -176,9 +176,25 @@ static inline void mapping_set_gfp_mask(struct address_space *m, gfp_t mask) · 85 unmodified lines
176 m->gfp_mask = mask;176 m->gfp_mask = mask;
177}177}
178 178
179static 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 */
190static inline void mapping_set_large_folios(struct address_space *mapping)
191{
192 __set_bit(AS_LARGE_FOLIO_SUPPORT, &mapping->flags);
193}
194
195static inline bool mapping_large_folio_support(struct address_space *mapping)
180{196{
181 return test_bit(AS_THP_SUPPORT, &mapping->flags);197 return test_bit(AS_LARGE_FOLIO_SUPPORT, &mapping->flags);
182}198}
183 199
184static inline int filemap_nr_thps(struct address_space *mapping)200static 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
193static inline void filemap_nr_thps_inc(struct address_space *mapping)209static inline void filemap_nr_thps_inc(struct address_space *mapping)
194{210{
195#ifdef CONFIG_READ_ONLY_THP_FOR_FS211#ifdef CONFIG_READ_ONLY_THP_FOR_FS
196 if (!mapping_thp_support(mapping))212 if (!mapping_large_folio_support(mapping))
197 atomic_inc(&mapping->nr_thps);213 atomic_inc(&mapping->nr_thps);
198#else214#else
199 WARN_ON_ONCE(1);215 WARN_ON_ONCE(1);
@@ -203,7 +219,7 @@ static inline void filemap_nr_thps_inc(struct address_space *mapping) · 3 unmodified lines
203static inline void filemap_nr_thps_dec(struct address_space *mapping)219static inline void filemap_nr_thps_dec(struct address_space *mapping)
204{220{
205#ifdef CONFIG_READ_ONLY_THP_FOR_FS221#ifdef CONFIG_READ_ONLY_THP_FOR_FS
206 if (!mapping_thp_support(mapping))222 if (!mapping_large_folio_support(mapping))
207 atomic_dec(&mapping->nr_thps);223 atomic_dec(&mapping->nr_thps);
208#else224#else
209 WARN_ON_ONCE(1);225 WARN_ON_ONCE(1);
include/linux/percpu-refcount.h+1−1
@@ -51,9 +51,9 @@ · 50 unmodified lines
51#define _LINUX_PERCPU_REFCOUNT_H51#define _LINUX_PERCPU_REFCOUNT_H
52 52
53#include <linux/atomic.h>53#include <linux/atomic.h>
54#include <linux/kernel.h>
55#include <linux/percpu.h>54#include <linux/percpu.h>
56#include <linux/rcupdate.h>55#include <linux/rcupdate.h>
56#include <linux/types.h>
57#include <linux/gfp.h>57#include <linux/gfp.h>
58 58
59struct percpu_ref;59struct percpu_ref;
include/linux/percpu.h+0−1
@@ -6,7 +6,6 @@ · 5 unmodified lines
6#include <linux/preempt.h>6#include <linux/preempt.h>
7#include <linux/smp.h>7#include <linux/smp.h>
8#include <linux/cpumask.h>8#include <linux/cpumask.h>
9#include <linux/printk.h>
10#include <linux/pfn.h>9#include <linux/pfn.h>
11#include <linux/init.h>10#include <linux/init.h>
12 11
include/linux/phy.h+6−5
@@ -538,11 +538,12 @@ struct macsec_ops; · 537 unmodified lines
538 * @mac_managed_pm: Set true if MAC driver takes of suspending/resuming PHY538 * @mac_managed_pm: Set true if MAC driver takes of suspending/resuming PHY
539 * @state: State of the PHY for management purposes539 * @state: State of the PHY for management purposes
540 * @dev_flags: Device-specific flags used by the PHY driver.540 * @dev_flags: Device-specific flags used by the PHY driver.
541 * Bits [15:0] are free to use by the PHY driver to communicate541 *
542 * driver specific behavior.542 * - Bits [15:0] are free to use by the PHY driver to communicate
543 * Bits [23:16] are currently reserved for future use.543 * driver specific behavior.
544 * Bits [31:24] are reserved for defining generic544 * - Bits [23:16] are currently reserved for future use.
545 * PHY driver behavior.545 * - Bits [31:24] are reserved for defining generic
546 * PHY driver behavior.
546 * @irq: IRQ number of the PHY's interrupt (-1 if none)547 * @irq: IRQ number of the PHY's interrupt (-1 if none)
547 * @phy_timer: The timer for handling the state machine548 * @phy_timer: The timer for handling the state machine
548 * @phylink: Pointer to phylink instance for this PHY549 * @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
129 * pm_runtime_active - Check whether or not a device is runtime-active.129 * pm_runtime_active - Check whether or not a device is runtime-active.
130 * @dev: Target device.130 * @dev: Target device.
131 *131 *
132 * Return %true if runtime PM is enabled for @dev and its runtime PM status is132 * Return %true if runtime PM is disabled for @dev or its runtime PM status is
133 * %RPM_ACTIVE, or %false otherwise.133 * %RPM_ACTIVE, or %false otherwise.
134 *134 *
135 * Note that the return value of this function can only be trusted if it is135 * 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
198void show_regs_print_info(const char *log_lvl);198void show_regs_print_info(const char *log_lvl);
199extern asmlinkage void dump_stack_lvl(const char *log_lvl) __cold;199extern asmlinkage void dump_stack_lvl(const char *log_lvl) __cold;
200extern asmlinkage void dump_stack(void) __cold;200extern asmlinkage void dump_stack(void) __cold;
201void printk_trigger_flush(void);
201#else202#else
202static inline __printf(1, 0)203static inline __printf(1, 0)
203int vprintk(const char *s, va_list args)204int vprintk(const char *s, va_list args)
@@ -274,6 +275,9 @@ static inline void dump_stack_lvl(const char *log_lvl) · 70 unmodified lines
274static inline void dump_stack(void)275static inline void dump_stack(void)
275{276{
276}277}
278static inline void printk_trigger_flush(void)
279{
280}
277#endif281#endif
278 282
279#ifdef CONFIG_SMP283#ifdef CONFIG_SMP
include/linux/ptp_classify.h+1−0
@@ -37,6 +37,7 @@ · 36 unmodified lines
37#define PTP_MSGTYPE_PDELAY_RESP 0x337#define PTP_MSGTYPE_PDELAY_RESP 0x3
38 38
39#define PTP_EV_PORT 31939#define PTP_EV_PORT 319
40#define PTP_GEN_PORT 320
40#define PTP_GEN_BIT 0x08 /* indicates general message, if set in message type */41#define PTP_GEN_BIT 0x08 /* indicates general message, if set in message type */
41 42
42#define OFF_PTP_SOURCE_UUID 22 /* PTPv1 only */43#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
499 * best to shut-down regulator(s) or reboot the SOC if error499 * best to shut-down regulator(s) or reboot the SOC if error
500 * handling is repeatedly failing. If fatal_cnt is given the IRQ500 * handling is repeatedly failing. If fatal_cnt is given the IRQ
501 * handling is aborted if it fails for fatal_cnt times and die()501 * handling is aborted if it fails for fatal_cnt times and die()
502 * callback (if populated) or BUG() is called to try to prevent502 * callback (if populated) is called. If die() is not populated
503 * poweroff for the system is attempted in order to prevent any
503 * further damage.504 * further damage.
504 * @reread_ms: The time which is waited before attempting to re-read status505 * @reread_ms: The time which is waited before attempting to re-read status
505 * at the worker if IC reading fails. Immediate re-read is done506 * at the worker if IC reading fails. Immediate re-read is done
@@ -516,11 +517,12 @@ struct regulator_irq_data { · 10 unmodified lines
516 * @data: Driver private data pointer which will be passed as such to517 * @data: Driver private data pointer which will be passed as such to
517 * the renable, map_event and die callbacks in regulator_irq_data.518 * the renable, map_event and die callbacks in regulator_irq_data.
518 * @die: Protection callback. If IC status reading or recovery actions519 * @die: Protection callback. If IC status reading or recovery actions
519 * fail fatal_cnt times this callback or BUG() is called. This520 * fail fatal_cnt times this callback is called or system is
520 * callback should implement a final protection attempt like521 * powered off. This callback should implement a final protection
521 * disabling the regulator. If protection succeeded this may522 * attempt like disabling the regulator. If protection succeeded
522 * return 0. If anything else is returned the core assumes final523 * die() may return 0. If anything else is returned the core
523 * protection failed and calls BUG() as a last resort.524 * assumes final protection failed and attempts to perform a
525 * poweroff as a last resort.
524 * @map_event: Driver callback to map IRQ status into regulator devices with526 * @map_event: Driver callback to map IRQ status into regulator devices with
525 * events / errors. NOTE: callback MUST initialize both the527 * events / errors. NOTE: callback MUST initialize both the
526 * errors and notifs for all rdevs which it signals having528 * errors and notifs for all rdevs which it signals having
include/linux/sched/cputime.h+3−2
@@ -18,15 +18,16 @@ · 17 unmodified lines
18#endif /* CONFIG_VIRT_CPU_ACCOUNTING_NATIVE */18#endif /* CONFIG_VIRT_CPU_ACCOUNTING_NATIVE */
19 19
20#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN20#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
21extern void task_cputime(struct task_struct *t,21extern bool task_cputime(struct task_struct *t,
22 u64 *utime, u64 *stime);22 u64 *utime, u64 *stime);
23extern u64 task_gtime(struct task_struct *t);23extern u64 task_gtime(struct task_struct *t);
24#else24#else
25static inline void task_cputime(struct task_struct *t,25static inline bool task_cputime(struct task_struct *t,
26 u64 *utime, u64 *stime)26 u64 *utime, u64 *stime)
27{27{
28 *utime = t->utime;28 *utime = t->utime;
29 *stime = t->stime;29 *stime = t->stime;
30 return false;
30}31}
31 32
32static inline u64 task_gtime(struct task_struct *t)33static 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
352extern void __wake_up_parent(struct task_struct *p, struct task_struct *parent);352extern void __wake_up_parent(struct task_struct *p, struct task_struct *parent);
353extern void force_sig(int);353extern void force_sig(int);
354extern void force_fatal_sig(int);354extern void force_fatal_sig(int);
355extern void force_exit_sig(int);
355extern int send_sig(int, struct task_struct *, int);356extern int send_sig(int, struct task_struct *, int);
356extern int zap_other_threads(struct task_struct *p);357extern int zap_other_threads(struct task_struct *p);
357extern struct sigqueue *sigqueue_alloc(void);358extern 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
158 * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring158 * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring
159 * subscriptions and synchronises with wait4(). Also used in procfs. Also159 * subscriptions and synchronises with wait4(). Also used in procfs. Also
160 * pins the final release of task.io_context. Also protects ->cpuset and160 * 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.
162 *162 *
163 * Nests both inside and outside of read_lock(&tasklist_lock).163 * Nests both inside and outside of read_lock(&tasklist_lock).
164 * It must not be nested with write_lock_irq(&tasklist_lock),164 * 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 */
28struct 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 */
43struct 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 */
50enum 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-" */
66struct 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 */
80struct 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 */
92struct 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 */
103struct 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 */
112struct 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 */
121struct 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 */
138struct 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 */
144enum 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
27}27}
28 28
29u64 __siphash_aligned(const void *data, size_t len, const siphash_key_t *key);29u64 __siphash_aligned(const void *data, size_t len, const siphash_key_t *key);
30#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
31u64 __siphash_unaligned(const void *data, size_t len, const siphash_key_t *key);30u64 __siphash_unaligned(const void *data, size_t len, const siphash_key_t *key);
32#endif
33 31
34u64 siphash_1u64(const u64 a, const siphash_key_t *key);32u64 siphash_1u64(const u64 a, const siphash_key_t *key);
35u64 siphash_2u64(const u64 a, const u64 b, const siphash_key_t *key);33u64 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
82static inline u64 siphash(const void *data, size_t len,80static inline u64 siphash(const void *data, size_t len,
83 const siphash_key_t *key)81 const siphash_key_t *key)
84{82{
85#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS83 if (IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) ||
86 if (!IS_ALIGNED((unsigned long)data, SIPHASH_ALIGNMENT))84 !IS_ALIGNED((unsigned long)data, SIPHASH_ALIGNMENT))
87 return __siphash_unaligned(data, len, key);85 return __siphash_unaligned(data, len, key);
88#endif
89 return ___siphash_aligned(data, len, key);86 return ___siphash_aligned(data, len, key);
90}87}
91 88
@@ -96,10 +93,8 @@ typedef struct { · 4 unmodified lines
96 93
97u32 __hsiphash_aligned(const void *data, size_t len,94u32 __hsiphash_aligned(const void *data, size_t len,
98 const hsiphash_key_t *key);95 const hsiphash_key_t *key);
99#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
100u32 __hsiphash_unaligned(const void *data, size_t len,96u32 __hsiphash_unaligned(const void *data, size_t len,
101 const hsiphash_key_t *key);97 const hsiphash_key_t *key);
102#endif
103 98
104u32 hsiphash_1u32(const u32 a, const hsiphash_key_t *key);99u32 hsiphash_1u32(const u32 a, const hsiphash_key_t *key);
105u32 hsiphash_2u32(const u32 a, const u32 b, const hsiphash_key_t *key);100u32 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
135static inline u32 hsiphash(const void *data, size_t len,130static inline u32 hsiphash(const void *data, size_t len,
136 const hsiphash_key_t *key)131 const hsiphash_key_t *key)
137{132{
138#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS133 if (IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) ||
139 if (!IS_ALIGNED((unsigned long)data, HSIPHASH_ALIGNMENT))134 !IS_ALIGNED((unsigned long)data, HSIPHASH_ALIGNMENT))
140 return __hsiphash_unaligned(data, len, key);135 return __hsiphash_unaligned(data, len, key);
141#endif
142 return ___hsiphash_aligned(data, len, key);136 return ___hsiphash_aligned(data, len, key);
143}137}
144 138
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
4226 return;4226 return;
4227 }4227 }
4228 4228
4229 if (unlikely(skb->ip_summed != CHECKSUM_COMPLETE)) {4229 if (unlikely(skb->ip_summed != CHECKSUM_COMPLETE)) {
4230 __skb_checksum_complete(skb);4230 __skb_checksum_complete(skb);
4231 skb_postpull_rcsum(skb, skb->data, ptr - (void *)skb->data);4231 skb_postpull_rcsum(skb, skb->data, ptr - (void *)skb->data);
4232 }4232 }
include/linux/trace_events.h+1−1
@@ -673,7 +673,7 @@ struct trace_event_file { · 672 unmodified lines
673 673
674#define PERF_MAX_TRACE_SIZE 8192674#define PERF_MAX_TRACE_SIZE 8192
675 675
676#define MAX_FILTER_STR_VAL 256 /* Should handle KSYM_SYMBOL_LEN */676#define MAX_FILTER_STR_VAL 256U /* Should handle KSYM_SYMBOL_LEN */
677 677
678enum event_trigger_type {678enum event_trigger_type {
679 ETT_NONE = (0),679 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
152 * @feature_table_size: number of entries in the feature table array.152 * @feature_table_size: number of entries in the feature table array.
153 * @feature_table_legacy: same as feature_table but when working in legacy mode.153 * @feature_table_legacy: same as feature_table but when working in legacy mode.
154 * @feature_table_size_legacy: number of entries in feature table legacy array.154 * @feature_table_size_legacy: number of entries in feature table legacy array.
155 * @suppress_used_validation: set to not have core validate used length
156 * @probe: the function to call when a device is found. Returns 0 or -errno.155 * @probe: the function to call when a device is found. Returns 0 or -errno.
157 * @scan: optional function to call after successful probe; intended156 * @scan: optional function to call after successful probe; intended
158 * for virtio-scsi to invoke a scan.157 * for virtio-scsi to invoke a scan.
@@ -169,7 +168,6 @@ struct virtio_driver { · 10 unmodified lines
169 unsigned int feature_table_size;168 unsigned int feature_table_size;
170 const unsigned int *feature_table_legacy;169 const unsigned int *feature_table_legacy;
171 unsigned int feature_table_size_legacy;170 unsigned int feature_table_size_legacy;
172 bool suppress_used_validation;
173 int (*validate)(struct virtio_device *dev);171 int (*validate)(struct virtio_device *dev);
174 int (*probe)(struct virtio_device *dev);172 int (*probe)(struct virtio_device *dev);
175 void (*scan)(struct virtio_device *dev);173 void (*scan)(struct virtio_device *dev);
include/linux/virtio_net.h+6−1
@@ -120,10 +120,15 @@ retry: · 119 unmodified lines
120 120
121 if (hdr->gso_type != VIRTIO_NET_HDR_GSO_NONE) {121 if (hdr->gso_type != VIRTIO_NET_HDR_GSO_NONE) {
122 u16 gso_size = __virtio16_to_cpu(little_endian, hdr->gso_size);122 u16 gso_size = __virtio16_to_cpu(little_endian, hdr->gso_size);
123 unsigned int nh_off = p_off;
123 struct skb_shared_info *shinfo = skb_shinfo(skb);124 struct skb_shared_info *shinfo = skb_shinfo(skb);
124 125
126 /* UFO may not include transport header in gso_size. */
127 if (gso_type & SKB_GSO_UDP)
128 nh_off -= thlen;
129
125 /* Too small packets are not really GSO ones. */130 /* Too small packets are not really GSO ones. */
126 if (skb->len - p_off > gso_size) {131 if (skb->len - nh_off > gso_size) {
127 shinfo->gso_size = gso_size;132 shinfo->gso_size = gso_size;
128 shinfo->gso_type = gso_type;133 shinfo->gso_type = gso_type;
129 134
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
217void __wake_up_locked_sync_key(struct wait_queue_head *wq_head, unsigned int mode, void *key);217void __wake_up_locked_sync_key(struct wait_queue_head *wq_head, unsigned int mode, void *key);
218void __wake_up_locked(struct wait_queue_head *wq_head, unsigned int mode, int nr);218void __wake_up_locked(struct wait_queue_head *wq_head, unsigned int mode, int nr);
219void __wake_up_sync(struct wait_queue_head *wq_head, unsigned int mode);219void __wake_up_sync(struct wait_queue_head *wq_head, unsigned int mode);
220void __wake_up_pollfree(struct wait_queue_head *wq_head);
220 221
221#define wake_up(x) __wake_up(x, TASK_NORMAL, 1, NULL)222#define wake_up(x) __wake_up(x, TASK_NORMAL, 1, NULL)
222#define wake_up_nr(x, nr) __wake_up(x, TASK_NORMAL, nr, NULL)223#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
245#define wake_up_interruptible_sync_poll_locked(x, m) \246#define wake_up_interruptible_sync_poll_locked(x, m) \
246 __wake_up_locked_sync_key((x), TASK_INTERRUPTIBLE, poll_to_key(m))247 __wake_up_locked_sync_key((x), TASK_INTERRUPTIBLE, poll_to_key(m))
247 248
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 */
261static 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
248#define ___wait_cond_timeout(condition) \274#define ___wait_cond_timeout(condition) \
249({ \275({ \
250 bool __cond = (condition); \276 bool __cond = (condition); \
include/net/bond_alb.h+1−1
@@ -126,7 +126,7 @@ struct tlb_slave_info { · 125 unmodified lines
126struct alb_bond_info {126struct alb_bond_info {
127 struct tlb_client_info *tx_hashtbl; /* Dynamically allocated */127 struct tlb_client_info *tx_hashtbl; /* Dynamically allocated */
128 u32 unbalanced_load;128 u32 unbalanced_load;
129 int tx_rebalance_counter;129 atomic_t tx_rebalance_counter;
130 int lp_counter;130 int lp_counter;
131 /* -------- rlb parameters -------- */131 /* -------- rlb parameters -------- */
132 int rlb_enabled;132 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
132#ifdef CONFIG_NET_RX_BUSY_POLL132#ifdef CONFIG_NET_RX_BUSY_POLL
133 if (unlikely(READ_ONCE(sk->sk_napi_id) != skb->napi_id))133 if (unlikely(READ_ONCE(sk->sk_napi_id) != skb->napi_id))
134 WRITE_ONCE(sk->sk_napi_id, skb->napi_id);134 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 */
143static 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);
135#endif148#endif
136 sk_rx_queue_set(sk, skb);149 sk_rx_queue_set(sk, skb);
137}150}
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
79 dst_cache->reset_ts = jiffies;79 dst_cache->reset_ts = jiffies;
80}80}
81 81
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 */
91void dst_cache_reset_now(struct dst_cache *dst_cache);
92
82/**93/**
83 * dst_cache_init - initialize the cache, allocating the required storage94 * dst_cache_init - initialize the cache, allocating the required storage
84 * @dst_cache: the cache95 * @dst_cache: the cache
include/net/fib_rules.h+3−1
@@ -69,7 +69,7 @@ struct fib_rules_ops { · 68 unmodified lines
69 int (*action)(struct fib_rule *,69 int (*action)(struct fib_rule *,
70 struct flowi *, int,70 struct flowi *, int,
71 struct fib_lookup_arg *);71 struct fib_lookup_arg *);
72 bool (*suppress)(struct fib_rule *,72 bool (*suppress)(struct fib_rule *, int,
73 struct fib_lookup_arg *);73 struct fib_lookup_arg *);
74 int (*match)(struct fib_rule *,74 int (*match)(struct fib_rule *,
75 struct flowi *, int);75 struct flowi *, int);
@@ -218,7 +218,9 @@ INDIRECT_CALLABLE_DECLARE(int fib4_rule_action(struct fib_rule *rule, · 142 unmodified lines
218 struct fib_lookup_arg *arg));218 struct fib_lookup_arg *arg));
219 219
220INDIRECT_CALLABLE_DECLARE(bool fib6_rule_suppress(struct fib_rule *rule,220INDIRECT_CALLABLE_DECLARE(bool fib6_rule_suppress(struct fib_rule *rule,
221 int flags,
221 struct fib_lookup_arg *arg));222 struct fib_lookup_arg *arg));
222INDIRECT_CALLABLE_DECLARE(bool fib4_rule_suppress(struct fib_rule *rule,223INDIRECT_CALLABLE_DECLARE(bool fib4_rule_suppress(struct fib_rule *rule,
224 int flags,
223 struct fib_lookup_arg *arg));225 struct fib_lookup_arg *arg));
224#endif226#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
485 struct fib6_config *cfg, gfp_t gfp_flags,485 struct fib6_config *cfg, gfp_t gfp_flags,
486 struct netlink_ext_ack *extack);486 struct netlink_ext_ack *extack);
487void fib6_nh_release(struct fib6_nh *fib6_nh);487void fib6_nh_release(struct fib6_nh *fib6_nh);
488void fib6_nh_release_dsts(struct fib6_nh *fib6_nh);
488 489
489int call_fib6_entry_notifiers(struct net *net,490int call_fib6_entry_notifiers(struct net *net,
490 enum fib_event_type event_type,491 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
438#ifdef CONFIG_IP_ROUTE_CLASSID438#ifdef CONFIG_IP_ROUTE_CLASSID
439static inline int fib_num_tclassid_users(struct net *net)439static inline int fib_num_tclassid_users(struct net *net)
440{440{
441 return net->ipv4.fib_num_tclassid_users;441 return atomic_read(&net->ipv4.fib_num_tclassid_users);
442}442}
443#else443#else
444static inline int fib_num_tclassid_users(struct net *net)444static 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
47 struct fib6_config *cfg, gfp_t gfp_flags,47 struct fib6_config *cfg, gfp_t gfp_flags,
48 struct netlink_ext_ack *extack);48 struct netlink_ext_ack *extack);
49 void (*fib6_nh_release)(struct fib6_nh *fib6_nh);49 void (*fib6_nh_release)(struct fib6_nh *fib6_nh);
50 void (*fib6_nh_release_dsts)(struct fib6_nh *fib6_nh);
50 void (*fib6_update_sernum)(struct net *net, struct fib6_info *rt);51 void (*fib6_update_sernum)(struct net *net, struct fib6_info *rt);
51 int (*ip6_del_rt)(struct net *net, struct fib6_info *rt, bool skip_notify);52 int (*ip6_del_rt)(struct net *net, struct fib6_info *rt, bool skip_notify);
52 void (*fib6_rt_update)(struct net *net, struct fib6_info *rt,53 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
276/* jiffies until ct expires, 0 if already expired */276/* jiffies until ct expires, 0 if already expired */
277static inline unsigned long nf_ct_expires(const struct nf_conn *ct)277static inline unsigned long nf_ct_expires(const struct nf_conn *ct)
278{278{
279 s32 timeout = ct->timeout - nfct_time_stamp;279 s32 timeout = READ_ONCE(ct->timeout) - nfct_time_stamp;
280 280
281 return timeout > 0 ? timeout : 0;281 return timeout > 0 ? timeout : 0;
282}282}
283 283
284static inline bool nf_ct_is_expired(const struct nf_conn *ct)284static inline bool nf_ct_is_expired(const struct nf_conn *ct)
285{285{
286 return (__s32)(ct->timeout - nfct_time_stamp) <= 0;286 return (__s32)(READ_ONCE(ct->timeout) - nfct_time_stamp) <= 0;
287}287}
288 288
289/* use after obtaining a reference count */289/* 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
302static inline void nf_ct_offload_timeout(struct nf_conn *ct)302static inline void nf_ct_offload_timeout(struct nf_conn *ct)
303{303{
304 if (nf_ct_expires(ct) < NF_CT_DAY / 2)304 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);
306}306}
307 307
308struct kernel_param;308struct kernel_param;
include/net/netns/ipv4.h+1−1
@@ -65,7 +65,7 @@ struct netns_ipv4 { · 64 unmodified lines
65 bool fib_has_custom_local_routes;65 bool fib_has_custom_local_routes;
66 bool fib_offload_disabled;66 bool fib_offload_disabled;
67#ifdef CONFIG_IP_ROUTE_CLASSID67#ifdef CONFIG_IP_ROUTE_CLASSID
68 int fib_num_tclassid_users;68 atomic_t fib_num_tclassid_users;
69#endif69#endif
70 struct hlist_head *fib_table_hash;70 struct hlist_head *fib_table_hash;
71 struct sock *fibnl;71 struct sock *fibnl;
include/net/nfc/nci_core.h+1−0
@@ -30,6 +30,7 @@ enum nci_flag { · 29 unmodified lines
30 NCI_UP,30 NCI_UP,
31 NCI_DATA_EXCHANGE,31 NCI_DATA_EXCHANGE,
32 NCI_DATA_EXCHANGE_TO,32 NCI_DATA_EXCHANGE_TO,
33 NCI_UNREG,
33};34};
34 35
35/* NCI device states */36/* NCI device states */
include/net/nl802154.h+4−3
@@ -19,6 +19,8 @@ · 18 unmodified lines
19 *19 *
20 */20 */
21 21
22#include <linux/types.h>
23
22#define NL802154_GENL_NAME "nl802154"24#define NL802154_GENL_NAME "nl802154"
23 25
24enum nl802154_commands {26enum nl802154_commands {
@@ -150,10 +152,9 @@ enum nl802154_attrs { · 125 unmodified lines
150};152};
151 153
152enum nl802154_iftype {154enum nl802154_iftype {
153 /* for backwards compatibility TODO */155 NL802154_IFTYPE_UNSPEC = (~(__u32)0),
154 NL802154_IFTYPE_UNSPEC = -1,
155 156
156 NL802154_IFTYPE_NODE,157 NL802154_IFTYPE_NODE = 0,
157 NL802154_IFTYPE_MONITOR,158 NL802154_IFTYPE_MONITOR,
158 NL802154_IFTYPE_COORD,159 NL802154_IFTYPE_COORD,
159 160
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
216 page_pool_put_full_page(pool, page, true);216 page_pool_put_full_page(pool, page, true);
217}217}
218 218
219#define PAGE_POOL_DMA_USE_PP_FRAG_COUNT \
220 (sizeof(dma_addr_t) > sizeof(unsigned long))
221
219static inline dma_addr_t page_pool_get_dma_addr(struct page *page)222static inline dma_addr_t page_pool_get_dma_addr(struct page *page)
220{223{
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;
222}230}
223 231
224static inline void page_pool_set_dma_addr(struct page *page, dma_addr_t addr)232static inline void page_pool_set_dma_addr(struct page *page, dma_addr_t addr)
225{233{
226 page->dma_addr = addr;234 page->dma_addr = addr;
235 if (PAGE_POOL_DMA_USE_PP_FRAG_COUNT)
236 page->dma_addr_upper = upper_32_bits(addr);
227}237}
228 238
229static inline void page_pool_set_frag_count(struct page *page, long nr)239static 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
1913 return -1;1913 return -1;
1914}1914}
1915 1915
1916static inline void sk_rx_queue_set(struct sock *sk, const struct sk_buff *skb)1916static inline void __sk_rx_queue_set(struct sock *sk,
1917 const struct sk_buff *skb,
1918 bool force_set)
1917{1919{
1918#ifdef CONFIG_SOCK_RX_QUEUE_MAPPING1920#ifdef CONFIG_SOCK_RX_QUEUE_MAPPING
1919 if (skb_rx_queue_recorded(skb)) {1921 if (skb_rx_queue_recorded(skb)) {
1920 u16 rx_queue = skb_get_rx_queue(skb);1922 u16 rx_queue = skb_get_rx_queue(skb);
1921 1923
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))
1923 WRITE_ONCE(sk->sk_rx_queue_mapping, rx_queue);1926 WRITE_ONCE(sk->sk_rx_queue_mapping, rx_queue);
1924 }1927 }
1925#endif1928#endif
1926}1929}
1927 1930
1931static 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
1936static 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
1928static inline void sk_rx_queue_clear(struct sock *sk)1941static inline void sk_rx_queue_clear(struct sock *sk)
1929{1942{
1930#ifdef CONFIG_SOCK_RX_QUEUE_MAPPING1943#ifdef CONFIG_SOCK_RX_QUEUE_MAPPING
@@ -2430,19 +2443,22 @@ static inline void sk_stream_moderate_sndbuf(struct sock *sk) · 499 unmodified lines
2430 * @sk: socket2443 * @sk: socket
2431 *2444 *
2432 * Use the per task page_frag instead of the per socket one for2445 * 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 owns2446 * optimization when we know that we're in process context and own
2434 * everything that's associated with %current.2447 * everything that's associated with %current.
2435 *2448 *
2436 * gfpflags_allow_blocking() isn't enough here as direct reclaim may nest2449 * Both direct reclaim and page faults can nest inside other
2437 * inside other socket operations and end up recursing into sk_page_frag()2450 * socket operations and end up recursing into sk_page_frag()
2438 * while it's already in use.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.
2439 *2454 *
2440 * Return: a per task page_frag if context allows that,2455 * Return: a per task page_frag if context allows that,
2441 * otherwise a per socket one.2456 * otherwise a per socket one.
2442 */2457 */
2443static inline struct page_frag *sk_page_frag(struct sock *sk)2458static inline struct page_frag *sk_page_frag(struct sock *sk)
2444{2459{
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))
2446 return &current->task_frag;2462 return &current->task_frag;
2447 2463
2448 return &sk->sk_frag;2464 return &sk->sk_frag;
include/rdma/rdma_netlink.h+1−1
@@ -30,7 +30,7 @@ enum rdma_nl_flags { · 29 unmodified lines
30 * constant as well and the compiler checks they are the same.30 * constant as well and the compiler checks they are the same.
31 */31 */
32#define MODULE_ALIAS_RDMA_NETLINK(_index, _val) \32#define MODULE_ALIAS_RDMA_NETLINK(_index, _val) \
33 static inline void __chk_##_index(void) \33 static inline void __maybe_unused __chk_##_index(void) \
34 { \34 { \
35 BUILD_BUG_ON(_index != _val); \35 BUILD_BUG_ON(_index != _val); \
36 } \36 } \
include/soc/mscc/ocelot_vcap.h+2−0
@@ -703,6 +703,8 @@ int ocelot_vcap_filter_add(struct ocelot *ocelot, · 702 unmodified lines
703 struct netlink_ext_ack *extack);703 struct netlink_ext_ack *extack);
704int ocelot_vcap_filter_del(struct ocelot *ocelot,704int ocelot_vcap_filter_del(struct ocelot *ocelot,
705 struct ocelot_vcap_filter *rule);705 struct ocelot_vcap_filter *rule);
706int ocelot_vcap_filter_replace(struct ocelot *ocelot,
707 struct ocelot_vcap_filter *filter);
706struct ocelot_vcap_filter *708struct ocelot_vcap_filter *
707ocelot_vcap_block_find_filter_by_id(struct ocelot_vcap_block *block,709ocelot_vcap_block_find_filter_by_id(struct ocelot_vcap_block *block,
708 unsigned long cookie, bool tc_offload);710 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
147 */147 */
148/* Descriptor for SST ASoC machine driver */148/* Descriptor for SST ASoC machine driver */
149struct snd_soc_acpi_mach {149struct snd_soc_acpi_mach {
150 const u8 id[ACPI_ID_LEN];150 u8 id[ACPI_ID_LEN];
151 const struct snd_soc_acpi_codecs *comp_ids;151 const struct snd_soc_acpi_codecs *comp_ids;
152 const u32 link_mask;152 const u32 link_mask;
153 const struct snd_soc_acpi_link_adr *links;153 const struct snd_soc_acpi_link_adr *links;
include/trace/events/rpcgss.h+1−1
@@ -8,7 +8,7 @@ · 7 unmodified lines
8#undef TRACE_SYSTEM8#undef TRACE_SYSTEM
9#define TRACE_SYSTEM rpcgss9#define TRACE_SYSTEM rpcgss
10 10
11#if !defined(_TRACE_RPCRDMA_H) || defined(TRACE_HEADER_MULTI_READ)11#if !defined(_TRACE_RPCGSS_H) || defined(TRACE_HEADER_MULTI_READ)
12#define _TRACE_RPCGSS_H12#define _TRACE_RPCGSS_H
13 13
14#include <linux/tracepoint.h>14#include <linux/tracepoint.h>
include/uapi/asm-generic/poll.h+1−1
@@ -29,7 +29,7 @@ · 28 unmodified lines
29#define POLLRDHUP 0x200029#define POLLRDHUP 0x2000
30#endif30#endif
31 31
32#define POLLFREE (__force __poll_t)0x4000 /* currently only for epoll */32#define POLLFREE (__force __poll_t)0x4000
33 33
34#define POLL_BUSY_LOOP (__force __poll_t)0x800034#define POLL_BUSY_LOOP (__force __poll_t)0x8000
35 35
include/uapi/drm/virtgpu_drm.h+7−0
@@ -196,6 +196,13 @@ struct drm_virtgpu_context_init { · 195 unmodified lines
196 __u64 ctx_set_params;196 __u64 ctx_set_params;
197};197};
198 198
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
199#define DRM_IOCTL_VIRTGPU_MAP \206#define DRM_IOCTL_VIRTGPU_MAP \
200 DRM_IOWR(DRM_COMMAND_BASE + DRM_VIRTGPU_MAP, struct drm_virtgpu_map)207 DRM_IOWR(DRM_COMMAND_BASE + DRM_VIRTGPU_MAP, struct drm_virtgpu_map)
201 208
include/uapi/linux/if_ether.h+1−1
@@ -117,7 +117,7 @@ · 116 unmodified lines
117#define ETH_P_IFE 0xED3E /* ForCES inter-FE LFB type */117#define ETH_P_IFE 0xED3E /* ForCES inter-FE LFB type */
118#define ETH_P_AF_IUCV 0xFBFB /* IBM af_iucv [ NOT AN OFFICIALLY REGISTERED ID ] */118#define ETH_P_AF_IUCV 0xFBFB /* IBM af_iucv [ NOT AN OFFICIALLY REGISTERED ID ] */
119 119
120#define ETH_P_802_3_MIN 0x0600 /* If the value in the ethernet type is less than this value120#define ETH_P_802_3_MIN 0x0600 /* If the value in the ethernet type is more than this value
121 * then the frame is Ethernet II. Else it is 802.3 */121 * then the frame is Ethernet II. Else it is 802.3 */
122 122
123/*123/*
include/uapi/linux/resource.h+10−3
@@ -66,10 +66,17 @@ struct rlimit64 { · 65 unmodified lines
66#define _STK_LIM (8*1024*1024)66#define _STK_LIM (8*1024*1024)
67 67
68/*68/*
69 * GPG2 wants 64kB of mlocked memory, to make sure pass phrases69 * Limit the amount of locked memory by some sane default:
70 * and other sensitive information are never written to disk.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.
71 */78 */
72#define MLOCK_LIMIT ((PAGE_SIZE > 64*1024) ? PAGE_SIZE : 64*1024)79#define MLOCK_LIMIT (8*1024*1024)
73 80
74/*81/*
75 * Due to binary compatibility, the actual resource numbers82 * Due to binary compatibility, the actual resource numbers
include/xen/xenbus.h+1−0
@@ -112,6 +112,7 @@ struct xenbus_driver { · 111 unmodified lines
112 const char *name; /* defaults to ids[0].devicetype */112 const char *name; /* defaults to ids[0].devicetype */
113 const struct xenbus_device_id *ids;113 const struct xenbus_device_id *ids;
114 bool allow_rebind; /* avoid setting xenstore closed during remove */114 bool allow_rebind; /* avoid setting xenstore closed during remove */
115 bool not_essential; /* is not mandatory for boot progress */
115 int (*probe)(struct xenbus_device *dev,116 int (*probe)(struct xenbus_device *dev,
116 const struct xenbus_device_id *id);117 const struct xenbus_device_id *id);
117 void (*otherend_changed)(struct xenbus_device *dev,118 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