History

Merge branch 'linus' into irq/core

Pick up upstream changes to avoid conflicts for pending patches.

Thomas Gleixner committed 7 years ago

Commit d869f862 parents 030fc44 74e9671952 files · +9903 −4823Browse files

Showing the changes to include/linux (37 of 952 files). Show all

Unified · Split

37 files
  1. include/linux/backing-dev-defs.h +1 −0
  2. include/linux/bcma/bcma_soc.h +1 −0
  3. include/linux/blk_types.h +1 −1
  4. include/linux/bpf_verifier.h +1 −0
  5. include/linux/bpfilter.h +12 −3
  6. include/linux/compiler-clang.h +2 −3
  7. include/linux/compiler-gcc.h +0 −4
  8. include/linux/compiler-intel.h +1 −3
  9. include/linux/compiler.h +3 −1
  10. include/linux/cpu.h +0 −2
  11. include/linux/dcache.h +4 −3
  12. include/linux/fb.h +1 −0
  13. include/linux/fs.h +5 −4
  14. include/linux/hid-debug.h +4 −5
  15. include/linux/hid.h +1 −2
  16. include/linux/hyperv.h +3 −2
  17. include/linux/ide.h +2 −0
  18. include/linux/if_arp.h +1 −0
  19. include/linux/interrupt.h +1 −0
  20. include/linux/libnvdimm.h +1 −1
  21. include/linux/memory_hotplug.h +10 −8
  22. include/linux/mfd/cros_ec_commands.h +94 −0
  23. include/linux/mfd/ingenic-tcu.h +1 −1
  24. include/linux/mfd/madera/core.h +7 −0
  25. include/linux/mfd/ti_am335x_tscadc.h +4 −0
  26. include/linux/mfd/tmio.h +1 −1
  27. include/linux/of.h +0 −1
  28. include/linux/phy.h +4 −2
  29. include/linux/pm_runtime.h +1 −1
  30. include/linux/qed/qed_chain.h +31 −0
  31. include/linux/sched.h +10 −1
  32. include/linux/sched/coredump.h +1 −0
  33. include/linux/sched/wake_q.h +5 −1
  34. include/linux/skbuff.h +1 −0
  35. include/linux/umh.h +2 −0
  36. include/linux/virtio_config.h +9 −4
  37. include/linux/xarray.h +170 −57
include/linux/backing-dev-defs.h+1−0
@@ -190,6 +190,7 @@ struct backing_dev_info { · 189 unmodified lines
190 struct radix_tree_root cgwb_tree; /* radix tree of active cgroup wbs */190 struct radix_tree_root cgwb_tree; /* radix tree of active cgroup wbs */
191 struct rb_root cgwb_congested_tree; /* their congested states */191 struct rb_root cgwb_congested_tree; /* their congested states */
192 struct mutex cgwb_release_mutex; /* protect shutdown of wb structs */192 struct mutex cgwb_release_mutex; /* protect shutdown of wb structs */
193 struct rw_semaphore wb_switch_rwsem; /* no cgwb switch while syncing */
193#else194#else
194 struct bdi_writeback_congested *wb_congested;195 struct bdi_writeback_congested *wb_congested;
195#endif196#endif
include/linux/bcma/bcma_soc.h+1−0
@@ -6,6 +6,7 @@ · 5 unmodified lines
6 6
7struct bcma_soc {7struct bcma_soc {
8 struct bcma_bus bus;8 struct bcma_bus bus;
9 struct device *dev;
9};10};
10 11
11int __init bcma_host_soc_register(struct bcma_soc *soc);12int __init bcma_host_soc_register(struct bcma_soc *soc);
include/linux/blk_types.h+1−1
@@ -287,7 +287,7 @@ enum req_opf { · 286 unmodified lines
287 REQ_OP_DISCARD = 3,287 REQ_OP_DISCARD = 3,
288 /* securely erase sectors */288 /* securely erase sectors */
289 REQ_OP_SECURE_ERASE = 5,289 REQ_OP_SECURE_ERASE = 5,
290 /* seset a zone write pointer */290 /* reset a zone write pointer */
291 REQ_OP_ZONE_RESET = 6,291 REQ_OP_ZONE_RESET = 6,
292 /* write the same sector many times */292 /* write the same sector many times */
293 REQ_OP_WRITE_SAME = 7,293 REQ_OP_WRITE_SAME = 7,
include/linux/bpf_verifier.h+1−0
@@ -172,6 +172,7 @@ struct bpf_verifier_state_list { · 171 unmodified lines
172#define BPF_ALU_SANITIZE_SRC 1U172#define BPF_ALU_SANITIZE_SRC 1U
173#define BPF_ALU_SANITIZE_DST 2U173#define BPF_ALU_SANITIZE_DST 2U
174#define BPF_ALU_NEG_VALUE (1U << 2)174#define BPF_ALU_NEG_VALUE (1U << 2)
175#define BPF_ALU_NON_POINTER (1U << 3)
175#define BPF_ALU_SANITIZE (BPF_ALU_SANITIZE_SRC | \176#define BPF_ALU_SANITIZE (BPF_ALU_SANITIZE_SRC | \
176 BPF_ALU_SANITIZE_DST)177 BPF_ALU_SANITIZE_DST)
177 178
include/linux/bpfilter.h+12−3
@@ -3,13 +3,22 @@ · 2 unmodified lines
3#define _LINUX_BPFILTER_H3#define _LINUX_BPFILTER_H
4 4
5#include <uapi/linux/bpfilter.h>5#include <uapi/linux/bpfilter.h>
6#include <linux/umh.h>
6 7
7struct sock;8struct sock;
8int bpfilter_ip_set_sockopt(struct sock *sk, int optname, char __user *optval,9int bpfilter_ip_set_sockopt(struct sock *sk, int optname, char __user *optval,
9 unsigned int optlen);10 unsigned int optlen);
10int bpfilter_ip_get_sockopt(struct sock *sk, int optname, char __user *optval,11int bpfilter_ip_get_sockopt(struct sock *sk, int optname, char __user *optval,
11 int __user *optlen);12 int __user *optlen);
12extern int (*bpfilter_process_sockopt)(struct sock *sk, int optname,13struct bpfilter_umh_ops {
13 char __user *optval,14 struct umh_info info;
14 unsigned int optlen, bool is_set);15 /* since ip_getsockopt() can run in parallel, serialize access to umh */
16 struct mutex lock;
17 int (*sockopt)(struct sock *sk, int optname,
18 char __user *optval,
19 unsigned int optlen, bool is_set);
20 int (*start)(void);
21 bool stop;
22};
23extern struct bpfilter_umh_ops bpfilter_ops;
15#endif24#endif
include/linux/compiler-clang.h+2−3
@@ -3,9 +3,8 @@ · 2 unmodified lines
3#error "Please don't include <linux/compiler-clang.h> directly, include <linux/compiler.h> instead."3#error "Please don't include <linux/compiler-clang.h> directly, include <linux/compiler.h> instead."
4#endif4#endif
5 5
6/* Some compiler specific definitions are overwritten here6/* Compiler specific definitions for Clang compiler */
7 * for Clang compiler7
8 */
9#define uninitialized_var(x) x = *(&(x))8#define uninitialized_var(x) x = *(&(x))
10 9
11/* same as gcc, this was present in clang-2.6 so we can assume it works10/* same as gcc, this was present in clang-2.6 so we can assume it works
include/linux/compiler-gcc.h+0−4
@@ -58,10 +58,6 @@ · 57 unmodified lines
58 (typeof(ptr)) (__ptr + (off)); \58 (typeof(ptr)) (__ptr + (off)); \
59})59})
60 60
61/* Make the optimizer believe the variable can be manipulated arbitrarily. */
62#define OPTIMIZER_HIDE_VAR(var) \
63 __asm__ ("" : "=r" (var) : "0" (var))
64
65/*61/*
66 * A trick to suppress uninitialized variable warning without generating any62 * A trick to suppress uninitialized variable warning without generating any
67 * code63 * code
include/linux/compiler-intel.h+1−3
@@ -5,9 +5,7 @@ · 4 unmodified lines
5 5
6#ifdef __ECC6#ifdef __ECC
7 7
8/* Some compiler specific definitions are overwritten here8/* Compiler specific definitions for Intel ECC compiler */
9 * for Intel ECC compiler
10 */
11 9
12#include <asm/intrinsics.h>10#include <asm/intrinsics.h>
13 11
include/linux/compiler.h+3−1
@@ -161,7 +161,9 @@ void ftrace_likely_update(struct ftrace_likely_data *f, int val, · 160 unmodified lines
161#endif161#endif
162 162
163#ifndef OPTIMIZER_HIDE_VAR163#ifndef OPTIMIZER_HIDE_VAR
164#define OPTIMIZER_HIDE_VAR(var) barrier()164/* Make the optimizer believe the variable can be manipulated arbitrarily. */
165#define OPTIMIZER_HIDE_VAR(var) \
166 __asm__ ("" : "=r" (var) : "0" (var))
165#endif167#endif
166 168
167/* Not-quite-unique ID. */169/* Not-quite-unique ID. */
include/linux/cpu.h+0−2
@@ -180,12 +180,10 @@ enum cpuhp_smt_control { · 179 unmodified lines
180#if defined(CONFIG_SMP) && defined(CONFIG_HOTPLUG_SMT)180#if defined(CONFIG_SMP) && defined(CONFIG_HOTPLUG_SMT)
181extern enum cpuhp_smt_control cpu_smt_control;181extern enum cpuhp_smt_control cpu_smt_control;
182extern void cpu_smt_disable(bool force);182extern void cpu_smt_disable(bool force);
183extern void cpu_smt_check_topology_early(void);
184extern void cpu_smt_check_topology(void);183extern void cpu_smt_check_topology(void);
185#else184#else
186# define cpu_smt_control (CPU_SMT_ENABLED)185# define cpu_smt_control (CPU_SMT_ENABLED)
187static inline void cpu_smt_disable(bool force) { }186static inline void cpu_smt_disable(bool force) { }
188static inline void cpu_smt_check_topology_early(void) { }
189static inline void cpu_smt_check_topology(void) { }187static inline void cpu_smt_check_topology(void) { }
190#endif188#endif
191 189
include/linux/dcache.h+4−3
@@ -62,9 +62,10 @@ extern const struct qstr slash_name; · 61 unmodified lines
62struct dentry_stat_t {62struct dentry_stat_t {
63 long nr_dentry;63 long nr_dentry;
64 long nr_unused;64 long nr_unused;
65 long age_limit; /* age in seconds */65 long age_limit; /* age in seconds */
66 long want_pages; /* pages requested by system */66 long want_pages; /* pages requested by system */
67 long dummy[2];67 long nr_negative; /* # of unused negative dentries */
68 long dummy; /* Reserved for future use */
68};69};
69extern struct dentry_stat_t dentry_stat;70extern struct dentry_stat_t dentry_stat;
70 71
include/linux/fb.h+1−0
@@ -653,6 +653,7 @@ extern int fb_new_modelist(struct fb_info *info); · 652 unmodified lines
653 653
654extern struct fb_info *registered_fb[FB_MAX];654extern struct fb_info *registered_fb[FB_MAX];
655extern int num_registered_fb;655extern int num_registered_fb;
656extern bool fb_center_logo;
656extern struct class *fb_class;657extern struct class *fb_class;
657 658
658#define for_each_registered_fb(i) \659#define for_each_registered_fb(i) \
include/linux/fs.h+5−4
@@ -1479,11 +1479,12 @@ struct super_block { · 1478 unmodified lines
1479 struct user_namespace *s_user_ns;1479 struct user_namespace *s_user_ns;
1480 1480
1481 /*1481 /*
1482 * Keep the lru lists last in the structure so they always sit on their1482 * The list_lru structure is essentially just a pointer to a table
1483 * own individual cachelines.1483 * of per-node lru lists, each of which has its own spinlock.
1484 * There is no need to put them into separate cachelines.
1484 */1485 */
1485 struct list_lru s_dentry_lru ____cacheline_aligned_in_smp;1486 struct list_lru s_dentry_lru;
1486 struct list_lru s_inode_lru ____cacheline_aligned_in_smp;1487 struct list_lru s_inode_lru;
1487 struct rcu_head rcu;1488 struct rcu_head rcu;
1488 struct work_struct destroy_work;1489 struct work_struct destroy_work;
1489 1490
include/linux/hid-debug.h+4−5
@@ -24,7 +24,10 @@ · 23 unmodified lines
24 24
25#ifdef CONFIG_DEBUG_FS25#ifdef CONFIG_DEBUG_FS
26 26
27#include <linux/kfifo.h>
28
27#define HID_DEBUG_BUFSIZE 51229#define HID_DEBUG_BUFSIZE 512
30#define HID_DEBUG_FIFOSIZE 512
28 31
29void hid_dump_input(struct hid_device *, struct hid_usage *, __s32);32void hid_dump_input(struct hid_device *, struct hid_usage *, __s32);
30void hid_dump_report(struct hid_device *, int , u8 *, int);33void hid_dump_report(struct hid_device *, int , u8 *, int);
@@ -37,11 +40,8 @@ void hid_debug_init(void); · 6 unmodified lines
37void hid_debug_exit(void);40void hid_debug_exit(void);
38void hid_debug_event(struct hid_device *, char *);41void hid_debug_event(struct hid_device *, char *);
39 42
40
41struct hid_debug_list {43struct hid_debug_list {
42 char *hid_debug_buf;44 DECLARE_KFIFO_PTR(hid_debug_fifo, char);
43 int head;
44 int tail;
45 struct fasync_struct *fasync;45 struct fasync_struct *fasync;
46 struct hid_device *hdev;46 struct hid_device *hdev;
47 struct list_head node;47 struct list_head node;
@@ -64,4 +64,3 @@ struct hid_debug_list { · 16 unmodified lines
64#endif64#endif
65 65
66#endif66#endif
67
include/linux/hid.h+1−2
@@ -430,7 +430,7 @@ struct hid_local { · 429 unmodified lines
430 */430 */
431 431
432struct hid_collection {432struct hid_collection {
433 struct hid_collection *parent;433 int parent_idx; /* device->collection */
434 unsigned type;434 unsigned type;
435 unsigned usage;435 unsigned usage;
436 unsigned level;436 unsigned level;
@@ -658,7 +658,6 @@ struct hid_parser { · 221 unmodified lines
658 unsigned int *collection_stack;658 unsigned int *collection_stack;
659 unsigned int collection_stack_ptr;659 unsigned int collection_stack_ptr;
660 unsigned int collection_stack_size;660 unsigned int collection_stack_size;
661 struct hid_collection *active_collection;
662 struct hid_device *device;661 struct hid_device *device;
663 unsigned int scan_flags;662 unsigned int scan_flags;
664};663};
include/linux/hyperv.h+3−2
@@ -1159,8 +1159,9 @@ struct hv_ring_buffer_debug_info { · 1158 unmodified lines
1159 u32 bytes_avail_towrite;1159 u32 bytes_avail_towrite;
1160};1160};
1161 1161
1162void hv_ringbuffer_get_debuginfo(const struct hv_ring_buffer_info *ring_info,1162
1163 struct hv_ring_buffer_debug_info *debug_info);1163int hv_ringbuffer_get_debuginfo(const struct hv_ring_buffer_info *ring_info,
1164 struct hv_ring_buffer_debug_info *debug_info);
1164 1165
1165/* Vmbus interface */1166/* Vmbus interface */
1166#define vmbus_driver_register(driver) \1167#define vmbus_driver_register(driver) \
include/linux/ide.h+2−0
@@ -615,6 +615,7 @@ struct ide_drive_s { · 614 unmodified lines
615 615
616 /* current sense rq and buffer */616 /* current sense rq and buffer */
617 bool sense_rq_armed;617 bool sense_rq_armed;
618 bool sense_rq_active;
618 struct request *sense_rq;619 struct request *sense_rq;
619 struct request_sense sense_data;620 struct request_sense sense_data;
620 621
@@ -1219,6 +1220,7 @@ extern void ide_stall_queue(ide_drive_t *drive, unsigned long timeout); · 598 unmodified lines
1219extern void ide_timer_expiry(struct timer_list *t);1220extern void ide_timer_expiry(struct timer_list *t);
1220extern irqreturn_t ide_intr(int irq, void *dev_id);1221extern irqreturn_t ide_intr(int irq, void *dev_id);
1221extern blk_status_t ide_queue_rq(struct blk_mq_hw_ctx *, const struct blk_mq_queue_data *);1222extern blk_status_t ide_queue_rq(struct blk_mq_hw_ctx *, const struct blk_mq_queue_data *);
1223extern blk_status_t ide_issue_rq(ide_drive_t *, struct request *, bool);
1222extern void ide_requeue_and_plug(ide_drive_t *drive, struct request *rq);1224extern void ide_requeue_and_plug(ide_drive_t *drive, struct request *rq);
1223 1225
1224void ide_init_disk(struct gendisk *, ide_drive_t *);1226void ide_init_disk(struct gendisk *, ide_drive_t *);
include/linux/if_arp.h+1−0
@@ -54,6 +54,7 @@ static inline bool dev_is_mac_header_xmit(const struct net_device *dev) · 53 unmodified lines
54 case ARPHRD_IPGRE:54 case ARPHRD_IPGRE:
55 case ARPHRD_VOID:55 case ARPHRD_VOID:
56 case ARPHRD_NONE:56 case ARPHRD_NONE:
57 case ARPHRD_RAWIP:
57 return false;58 return false;
58 default:59 default:
59 return true;60 return true;
include/linux/interrupt.h+1−0
@@ -260,6 +260,7 @@ struct irq_affinity { · 259 unmodified lines
260/**260/**
261 * struct irq_affinity_desc - Interrupt affinity descriptor261 * struct irq_affinity_desc - Interrupt affinity descriptor
262 * @mask: cpumask to hold the affinity assignment262 * @mask: cpumask to hold the affinity assignment
263 * @is_managed: 1 if the interrupt is managed internally
263 */264 */
264struct irq_affinity_desc {265struct irq_affinity_desc {
265 struct cpumask mask;266 struct cpumask mask;
include/linux/libnvdimm.h+1−1
@@ -160,6 +160,7 @@ static inline struct nd_blk_region_desc *to_blk_region_desc( · 159 unmodified lines
160}160}
161 161
162enum nvdimm_security_state {162enum nvdimm_security_state {
163 NVDIMM_SECURITY_ERROR = -1,
163 NVDIMM_SECURITY_DISABLED,164 NVDIMM_SECURITY_DISABLED,
164 NVDIMM_SECURITY_UNLOCKED,165 NVDIMM_SECURITY_UNLOCKED,
165 NVDIMM_SECURITY_LOCKED,166 NVDIMM_SECURITY_LOCKED,
@@ -234,7 +235,6 @@ static inline struct nvdimm *nvdimm_create(struct nvdimm_bus *nvdimm_bus, · 68 unmodified lines
234 cmd_mask, num_flush, flush_wpq, NULL, NULL);235 cmd_mask, num_flush, flush_wpq, NULL, NULL);
235}236}
236 237
237int nvdimm_security_setup_events(struct nvdimm *nvdimm);
238const struct nd_cmd_desc *nd_cmd_dimm_desc(int cmd);238const struct nd_cmd_desc *nd_cmd_dimm_desc(int cmd);
239const struct nd_cmd_desc *nd_cmd_bus_desc(int cmd);239const struct nd_cmd_desc *nd_cmd_bus_desc(int cmd);
240u32 nd_cmd_in_size(struct nvdimm *nvdimm, int cmd,240u32 nd_cmd_in_size(struct nvdimm *nvdimm, int cmd,
include/linux/memory_hotplug.h+10−8
@@ -21,14 +21,16 @@ struct vmem_altmap; · 20 unmodified lines
21 * walkers which rely on the fully initialized page->flags and others21 * walkers which rely on the fully initialized page->flags and others
22 * should use this rather than pfn_valid && pfn_to_page22 * should use this rather than pfn_valid && pfn_to_page
23 */23 */
24#define pfn_to_online_page(pfn) \24#define pfn_to_online_page(pfn) \
25({ \25({ \
26 struct page *___page = NULL; \26 struct page *___page = NULL; \
27 unsigned long ___nr = pfn_to_section_nr(pfn); \27 unsigned long ___pfn = pfn; \
28 \28 unsigned long ___nr = pfn_to_section_nr(___pfn); \
29 if (___nr < NR_MEM_SECTIONS && online_section_nr(___nr))\29 \
30 ___page = pfn_to_page(pfn); \30 if (___nr < NR_MEM_SECTIONS && online_section_nr(___nr) && \
31 ___page; \31 pfn_valid_within(___pfn)) \
32 ___page = pfn_to_page(___pfn); \
33 ___page; \
32})34})
33 35
34/*36/*
include/linux/mfd/cros_ec_commands.h+94−0
@@ -2790,6 +2790,100 @@ struct ec_response_battery_vendor_param { · 2789 unmodified lines
2790 uint32_t value;2790 uint32_t value;
2791} __packed;2791} __packed;
2792 2792
2793/*****************************************************************************/
2794/* Commands for I2S recording on audio codec. */
2795
2796#define EC_CMD_CODEC_I2S 0x00BC
2797
2798enum ec_codec_i2s_subcmd {
2799 EC_CODEC_SET_SAMPLE_DEPTH = 0x0,
2800 EC_CODEC_SET_GAIN = 0x1,
2801 EC_CODEC_GET_GAIN = 0x2,
2802 EC_CODEC_I2S_ENABLE = 0x3,
2803 EC_CODEC_I2S_SET_CONFIG = 0x4,
2804 EC_CODEC_I2S_SET_TDM_CONFIG = 0x5,
2805 EC_CODEC_I2S_SET_BCLK = 0x6,
2806};
2807
2808enum ec_sample_depth_value {
2809 EC_CODEC_SAMPLE_DEPTH_16 = 0,
2810 EC_CODEC_SAMPLE_DEPTH_24 = 1,
2811};
2812
2813enum ec_i2s_config {
2814 EC_DAI_FMT_I2S = 0,
2815 EC_DAI_FMT_RIGHT_J = 1,
2816 EC_DAI_FMT_LEFT_J = 2,
2817 EC_DAI_FMT_PCM_A = 3,
2818 EC_DAI_FMT_PCM_B = 4,
2819 EC_DAI_FMT_PCM_TDM = 5,
2820};
2821
2822struct ec_param_codec_i2s {
2823 /*
2824 * enum ec_codec_i2s_subcmd
2825 */
2826 uint8_t cmd;
2827 union {
2828 /*
2829 * EC_CODEC_SET_SAMPLE_DEPTH
2830 * Value should be one of ec_sample_depth_value.
2831 */
2832 uint8_t depth;
2833
2834 /*
2835 * EC_CODEC_SET_GAIN
2836 * Value should be 0~43 for both channels.
2837 */
2838 struct ec_param_codec_i2s_set_gain {
2839 uint8_t left;
2840 uint8_t right;
2841 } __packed gain;
2842
2843 /*
2844 * EC_CODEC_I2S_ENABLE
2845 * 1 to enable, 0 to disable.
2846 */
2847 uint8_t i2s_enable;
2848
2849 /*
2850 * EC_CODEC_I2S_SET_COFNIG
2851 * Value should be one of ec_i2s_config.
2852 */
2853 uint8_t i2s_config;
2854
2855 /*
2856 * EC_CODEC_I2S_SET_TDM_CONFIG
2857 * Value should be one of ec_i2s_config.
2858 */
2859 struct ec_param_codec_i2s_tdm {
2860 /*
2861 * 0 to 496
2862 */
2863 int16_t ch0_delay;
2864 /*
2865 * -1 to 496
2866 */
2867 int16_t ch1_delay;
2868 uint8_t adjacent_to_ch0;
2869 uint8_t adjacent_to_ch1;
2870 } __packed tdm_param;
2871
2872 /*
2873 * EC_CODEC_I2S_SET_BCLK
2874 */
2875 uint32_t bclk;
2876 };
2877} __packed;
2878
2879/*
2880 * For subcommand EC_CODEC_GET_GAIN.
2881 */
2882struct ec_response_codec_gain {
2883 uint8_t left;
2884 uint8_t right;
2885} __packed;
2886
2793/*****************************************************************************/2887/*****************************************************************************/
2794/* System commands */2888/* System commands */
2795 2889
include/linux/mfd/ingenic-tcu.h+1−1
@@ -41,7 +41,7 @@ · 40 unmodified lines
41#define TCU_TCSR_PRESCALE_LSB 341#define TCU_TCSR_PRESCALE_LSB 3
42#define TCU_TCSR_PRESCALE_MASK 0x3842#define TCU_TCSR_PRESCALE_MASK 0x38
43 43
44#define TCU_TCSR_PWM_SD BIT(9) /* 0: Shutdown abruptly 1: gracefully */44#define TCU_TCSR_PWM_SD BIT(9) /* 0: Shutdown gracefully 1: abruptly */
45#define TCU_TCSR_PWM_INITL_HIGH BIT(8) /* Sets the initial output level */45#define TCU_TCSR_PWM_INITL_HIGH BIT(8) /* Sets the initial output level */
46#define TCU_TCSR_PWM_EN BIT(7) /* PWM pin output enable */46#define TCU_TCSR_PWM_EN BIT(7) /* PWM pin output enable */
47 47
include/linux/mfd/madera/core.h+7−0
@@ -15,6 +15,7 @@ · 14 unmodified lines
15#include <linux/gpio/consumer.h>15#include <linux/gpio/consumer.h>
16#include <linux/interrupt.h>16#include <linux/interrupt.h>
17#include <linux/mfd/madera/pdata.h>17#include <linux/mfd/madera/pdata.h>
18#include <linux/mutex.h>
18#include <linux/notifier.h>19#include <linux/notifier.h>
19#include <linux/regmap.h>20#include <linux/regmap.h>
20#include <linux/regulator/consumer.h>21#include <linux/regulator/consumer.h>
@@ -37,6 +38,8 @@ enum madera_type { · 16 unmodified lines
37 38
38#define MADERA_MAX_MICBIAS 439#define MADERA_MAX_MICBIAS 4
39 40
41#define MADERA_MAX_HP_OUTPUT 3
42
40/* Notifier events */43/* Notifier events */
41#define MADERA_NOTIFY_VOICE_TRIGGER 0x144#define MADERA_NOTIFY_VOICE_TRIGGER 0x1
42#define MADERA_NOTIFY_HPDET 0x245#define MADERA_NOTIFY_HPDET 0x2
@@ -183,6 +186,10 @@ struct madera { · 140 unmodified lines
183 unsigned int num_childbias[MADERA_MAX_MICBIAS];186 unsigned int num_childbias[MADERA_MAX_MICBIAS];
184 187
185 struct snd_soc_dapm_context *dapm;188 struct snd_soc_dapm_context *dapm;
189 struct mutex dapm_ptr_lock;
190 unsigned int hp_ena;
191 bool out_clamp[MADERA_MAX_HP_OUTPUT];
192 bool out_shorted[MADERA_MAX_HP_OUTPUT];
186 193
187 struct blocking_notifier_head notifier;194 struct blocking_notifier_head notifier;
188};195};
include/linux/mfd/ti_am335x_tscadc.h+4−0
@@ -78,6 +78,8 @@ · 77 unmodified lines
78#define STEPCONFIG_YNN BIT(8)78#define STEPCONFIG_YNN BIT(8)
79#define STEPCONFIG_XNP BIT(9)79#define STEPCONFIG_XNP BIT(9)
80#define STEPCONFIG_YPN BIT(10)80#define STEPCONFIG_YPN BIT(10)
81#define STEPCONFIG_RFP(val) ((val) << 12)
82#define STEPCONFIG_RFP_VREFP (0x3 << 12)
81#define STEPCONFIG_INM_MASK (0xF << 15)83#define STEPCONFIG_INM_MASK (0xF << 15)
82#define STEPCONFIG_INM(val) ((val) << 15)84#define STEPCONFIG_INM(val) ((val) << 15)
83#define STEPCONFIG_INM_ADCREFM STEPCONFIG_INM(8)85#define STEPCONFIG_INM_ADCREFM STEPCONFIG_INM(8)
@@ -86,6 +88,8 @@ · 2 unmodified lines
86#define STEPCONFIG_INP_AN4 STEPCONFIG_INP(4)88#define STEPCONFIG_INP_AN4 STEPCONFIG_INP(4)
87#define STEPCONFIG_INP_ADCREFM STEPCONFIG_INP(8)89#define STEPCONFIG_INP_ADCREFM STEPCONFIG_INP(8)
88#define STEPCONFIG_FIFO1 BIT(26)90#define STEPCONFIG_FIFO1 BIT(26)
91#define STEPCONFIG_RFM(val) ((val) << 23)
92#define STEPCONFIG_RFM_VREFN (0x3 << 23)
89 93
90/* Delay register */94/* Delay register */
91#define STEPDELAY_OPEN_MASK (0x3FFFF << 0)95#define STEPDELAY_OPEN_MASK (0x3FFFF << 0)
include/linux/mfd/tmio.h+1−1
@@ -79,7 +79,7 @@ · 78 unmodified lines
79/* Some controllers have a CBSY bit */79/* Some controllers have a CBSY bit */
80#define TMIO_MMC_HAVE_CBSY BIT(11)80#define TMIO_MMC_HAVE_CBSY BIT(11)
81 81
82/* Some controllers that support HS400 use use 4 taps while others use 8. */82/* Some controllers that support HS400 use 4 taps while others use 8. */
83#define TMIO_MMC_HAVE_4TAP_HS400 BIT(13)83#define TMIO_MMC_HAVE_4TAP_HS400 BIT(13)
84 84
85int tmio_core_mmc_enable(void __iomem *cnf, int shift, unsigned long base);85int tmio_core_mmc_enable(void __iomem *cnf, int shift, unsigned long base);
include/linux/of.h+0−1
@@ -50,7 +50,6 @@ struct of_irq_controller; · 49 unmodified lines
50 50
51struct device_node {51struct device_node {
52 const char *name;52 const char *name;
53 const char *type;
54 phandle phandle;53 phandle phandle;
55 const char *full_name;54 const char *full_name;
56 struct fwnode_handle fwnode;55 struct fwnode_handle fwnode;
include/linux/phy.h+4−2
@@ -48,6 +48,7 @@ extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_features) __ro_after_init; · 47 unmodified lines
48extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_fibre_features) __ro_after_init;48extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_fibre_features) __ro_after_init;
49extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_all_ports_features) __ro_after_init;49extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_all_ports_features) __ro_after_init;
50extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_features) __ro_after_init;50extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_features) __ro_after_init;
51extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_fec_features) __ro_after_init;
51extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_full_features) __ro_after_init;52extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_full_features) __ro_after_init;
52 53
53#define PHY_BASIC_FEATURES ((unsigned long *)&phy_basic_features)54#define PHY_BASIC_FEATURES ((unsigned long *)&phy_basic_features)
@@ -56,6 +57,7 @@ extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_full_features) __ro_after_ini · 2 unmodified lines
56#define PHY_GBIT_FIBRE_FEATURES ((unsigned long *)&phy_gbit_fibre_features)57#define PHY_GBIT_FIBRE_FEATURES ((unsigned long *)&phy_gbit_fibre_features)
57#define PHY_GBIT_ALL_PORTS_FEATURES ((unsigned long *)&phy_gbit_all_ports_features)58#define PHY_GBIT_ALL_PORTS_FEATURES ((unsigned long *)&phy_gbit_all_ports_features)
58#define PHY_10GBIT_FEATURES ((unsigned long *)&phy_10gbit_features)59#define PHY_10GBIT_FEATURES ((unsigned long *)&phy_10gbit_features)
60#define PHY_10GBIT_FEC_FEATURES ((unsigned long *)&phy_10gbit_fec_features)
59#define PHY_10GBIT_FULL_FEATURES ((unsigned long *)&phy_10gbit_full_features)61#define PHY_10GBIT_FULL_FEATURES ((unsigned long *)&phy_10gbit_full_features)
60 62
61extern const int phy_10_100_features_array[4];63extern const int phy_10_100_features_array[4];
@@ -467,8 +469,8 @@ struct phy_device { · 405 unmodified lines
467 * only works for PHYs with IDs which match this field469 * only works for PHYs with IDs which match this field
468 * name: The friendly name of this PHY type470 * name: The friendly name of this PHY type
469 * phy_id_mask: Defines the important bits of the phy_id471 * phy_id_mask: Defines the important bits of the phy_id
470 * features: A list of features (speed, duplex, etc) supported472 * features: A mandatory list of features (speed, duplex, etc)
471 * by this PHY473 * supported by this PHY
472 * flags: A bitfield defining certain other features this PHY474 * flags: A bitfield defining certain other features this PHY
473 * supports (like interrupts)475 * supports (like interrupts)
474 *476 *
include/linux/pm_runtime.h+1−1
@@ -105,7 +105,7 @@ static inline bool pm_runtime_callbacks_present(struct device *dev) · 104 unmodified lines
105 105
106static inline void pm_runtime_mark_last_busy(struct device *dev)106static inline void pm_runtime_mark_last_busy(struct device *dev)
107{107{
108 WRITE_ONCE(dev->power.last_busy, ktime_to_ns(ktime_get()));108 WRITE_ONCE(dev->power.last_busy, ktime_get_mono_fast_ns());
109}109}
110 110
111static inline bool pm_runtime_is_irq_safe(struct device *dev)111static inline bool pm_runtime_is_irq_safe(struct device *dev)
include/linux/qed/qed_chain.h+31−0
@@ -663,6 +663,37 @@ out: · 662 unmodified lines
663static inline void qed_chain_set_prod(struct qed_chain *p_chain,663static inline void qed_chain_set_prod(struct qed_chain *p_chain,
664 u32 prod_idx, void *p_prod_elem)664 u32 prod_idx, void *p_prod_elem)
665{665{
666 if (p_chain->mode == QED_CHAIN_MODE_PBL) {
667 u32 cur_prod, page_mask, page_cnt, page_diff;
668
669 cur_prod = is_chain_u16(p_chain) ? p_chain->u.chain16.prod_idx :
670 p_chain->u.chain32.prod_idx;
671
672 /* Assume that number of elements in a page is power of 2 */
673 page_mask = ~p_chain->elem_per_page_mask;
674
675 /* Use "cur_prod - 1" and "prod_idx - 1" since producer index
676 * reaches the first element of next page before the page index
677 * is incremented. See qed_chain_produce().
678 * Index wrap around is not a problem because the difference
679 * between current and given producer indices is always
680 * positive and lower than the chain's capacity.
681 */
682 page_diff = (((cur_prod - 1) & page_mask) -
683 ((prod_idx - 1) & page_mask)) /
684 p_chain->elem_per_page;
685
686 page_cnt = qed_chain_get_page_cnt(p_chain);
687 if (is_chain_u16(p_chain))
688 p_chain->pbl.c.u16.prod_page_idx =
689 (p_chain->pbl.c.u16.prod_page_idx -
690 page_diff + page_cnt) % page_cnt;
691 else
692 p_chain->pbl.c.u32.prod_page_idx =
693 (p_chain->pbl.c.u32.prod_page_idx -
694 page_diff + page_cnt) % page_cnt;
695 }
696
666 if (is_chain_u16(p_chain))697 if (is_chain_u16(p_chain))
667 p_chain->u.chain16.prod_idx = (u16) prod_idx;698 p_chain->u.chain16.prod_idx = (u16) prod_idx;
668 else699 else
include/linux/sched.h+10−1
@@ -995,7 +995,7 @@ struct task_struct { · 994 unmodified lines
995 /* cg_list protected by css_set_lock and tsk->alloc_lock: */995 /* cg_list protected by css_set_lock and tsk->alloc_lock: */
996 struct list_head cg_list;996 struct list_head cg_list;
997#endif997#endif
998#ifdef CONFIG_X86_RESCTRL998#ifdef CONFIG_X86_CPU_RESCTRL
999 u32 closid;999 u32 closid;
1000 u32 rmid;1000 u32 rmid;
1001#endif1001#endif
@@ -1406,6 +1406,7 @@ extern struct pid *cad_pid; · 404 unmodified lines
1406#define PF_RANDOMIZE 0x00400000 /* Randomize virtual address space */1406#define PF_RANDOMIZE 0x00400000 /* Randomize virtual address space */
1407#define PF_SWAPWRITE 0x00800000 /* Allowed to write to swap */1407#define PF_SWAPWRITE 0x00800000 /* Allowed to write to swap */
1408#define PF_MEMSTALL 0x01000000 /* Stalled due to lack of memory */1408#define PF_MEMSTALL 0x01000000 /* Stalled due to lack of memory */
1409#define PF_UMH 0x02000000 /* I'm an Usermodehelper process */
1409#define PF_NO_SETAFFINITY 0x04000000 /* Userland is not allowed to meddle with cpus_allowed */1410#define PF_NO_SETAFFINITY 0x04000000 /* Userland is not allowed to meddle with cpus_allowed */
1410#define PF_MCE_EARLY 0x08000000 /* Early kill for mce process policy */1411#define PF_MCE_EARLY 0x08000000 /* Early kill for mce process policy */
1411#define PF_MUTEX_TESTER 0x20000000 /* Thread belongs to the rt mutex tester */1412#define PF_MUTEX_TESTER 0x20000000 /* Thread belongs to the rt mutex tester */
@@ -1904,6 +1905,14 @@ static inline void rseq_execve(struct task_struct *t) · 492 unmodified lines
1904 1905
1905#endif1906#endif
1906 1907
1908void __exit_umh(struct task_struct *tsk);
1909
1910static inline void exit_umh(struct task_struct *tsk)
1911{
1912 if (unlikely(tsk->flags & PF_UMH))
1913 __exit_umh(tsk);
1914}
1915
1907#ifdef CONFIG_DEBUG_RSEQ1916#ifdef CONFIG_DEBUG_RSEQ
1908 1917
1909void rseq_syscall(struct pt_regs *regs);1918void rseq_syscall(struct pt_regs *regs);
include/linux/sched/coredump.h+1−0
@@ -71,6 +71,7 @@ static inline int get_dumpable(struct mm_struct *mm) · 70 unmodified lines
71#define MMF_HUGE_ZERO_PAGE 23 /* mm has ever used the global huge zero page */71#define MMF_HUGE_ZERO_PAGE 23 /* mm has ever used the global huge zero page */
72#define MMF_DISABLE_THP 24 /* disable THP for all VMAs */72#define MMF_DISABLE_THP 24 /* disable THP for all VMAs */
73#define MMF_OOM_VICTIM 25 /* mm is the oom victim */73#define MMF_OOM_VICTIM 25 /* mm is the oom victim */
74#define MMF_OOM_REAP_QUEUED 26 /* mm was queued for oom_reaper */
74#define MMF_DISABLE_THP_MASK (1 << MMF_DISABLE_THP)75#define MMF_DISABLE_THP_MASK (1 << MMF_DISABLE_THP)
75 76
76#define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\77#define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\
include/linux/sched/wake_q.h+5−1
@@ -24,9 +24,13 @@ · 23 unmodified lines
24 * called near the end of a function. Otherwise, the list can be24 * called near the end of a function. Otherwise, the list can be
25 * re-initialized for later re-use by wake_q_init().25 * re-initialized for later re-use by wake_q_init().
26 *26 *
27 * Note that this can cause spurious wakeups. schedule() callers27 * NOTE that this can cause spurious wakeups. schedule() callers
28 * must ensure the call is done inside a loop, confirming that the28 * must ensure the call is done inside a loop, confirming that the
29 * wakeup condition has in fact occurred.29 * wakeup condition has in fact occurred.
30 *
31 * NOTE that there is no guarantee the wakeup will happen any later than the
32 * wake_q_add() location. Therefore task must be ready to be woken at the
33 * location of the wake_q_add().
30 */34 */
31 35
32#include <linux/sched.h>36#include <linux/sched.h>
include/linux/skbuff.h+1−0
@@ -3218,6 +3218,7 @@ int pskb_trim_rcsum_slow(struct sk_buff *skb, unsigned int len); · 3217 unmodified lines
3218 *3218 *
3219 * This is exactly the same as pskb_trim except that it ensures the3219 * This is exactly the same as pskb_trim except that it ensures the
3220 * checksum of received packets are still valid after the operation.3220 * checksum of received packets are still valid after the operation.
3221 * It can change skb pointers.
3221 */3222 */
3222 3223
3223static inline int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len)3224static inline int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len)
include/linux/umh.h+2−0
@@ -47,6 +47,8 @@ struct umh_info { · 46 unmodified lines
47 const char *cmdline;47 const char *cmdline;
48 struct file *pipe_to_umh;48 struct file *pipe_to_umh;
49 struct file *pipe_from_umh;49 struct file *pipe_from_umh;
50 struct list_head list;
51 void (*cleanup)(struct umh_info *info);
50 pid_t pid;52 pid_t pid;
51};53};
52int fork_usermode_blob(void *data, size_t len, struct umh_info *info);54int fork_usermode_blob(void *data, size_t len, struct umh_info *info);
include/linux/virtio_config.h+9−4
@@ -12,6 +12,11 @@ struct irq_affinity; · 11 unmodified lines
12 12
13/**13/**
14 * virtio_config_ops - operations for configuring a virtio device14 * virtio_config_ops - operations for configuring a virtio device
15 * Note: Do not assume that a transport implements all of the operations
16 * getting/setting a value as a simple read/write! Generally speaking,
17 * any of @get/@set, @get_status/@set_status, or @get_features/
18 * @finalize_features are NOT safe to be called from an atomic
19 * context.
15 * @get: read the value of a configuration field20 * @get: read the value of a configuration field
16 * vdev: the virtio_device21 * vdev: the virtio_device
17 * offset: the offset of the configuration field22 * offset: the offset of the configuration field
@@ -22,7 +27,7 @@ struct irq_affinity; · 4 unmodified lines
22 * offset: the offset of the configuration field27 * offset: the offset of the configuration field
23 * buf: the buffer to read the field value from.28 * buf: the buffer to read the field value from.
24 * len: the length of the buffer29 * len: the length of the buffer
25 * @generation: config generation counter30 * @generation: config generation counter (optional)
26 * vdev: the virtio_device31 * vdev: the virtio_device
27 * Returns the config generation counter32 * Returns the config generation counter
28 * @get_status: read the status byte33 * @get_status: read the status byte
@@ -48,17 +53,17 @@ struct irq_affinity; · 19 unmodified lines
48 * @del_vqs: free virtqueues found by find_vqs().53 * @del_vqs: free virtqueues found by find_vqs().
49 * @get_features: get the array of feature bits for this device.54 * @get_features: get the array of feature bits for this device.
50 * vdev: the virtio_device55 * vdev: the virtio_device
51 * Returns the first 32 feature bits (all we currently need).56 * Returns the first 64 feature bits (all we currently need).
52 * @finalize_features: confirm what device features we'll be using.57 * @finalize_features: confirm what device features we'll be using.
53 * vdev: the virtio_device58 * vdev: the virtio_device
54 * This gives the final feature bits for the device: it can change59 * This gives the final feature bits for the device: it can change
55 * the dev->feature bits if it wants.60 * the dev->feature bits if it wants.
56 * Returns 0 on success or error status61 * Returns 0 on success or error status
57 * @bus_name: return the bus name associated with the device62 * @bus_name: return the bus name associated with the device (optional)
58 * vdev: the virtio_device63 * vdev: the virtio_device
59 * This returns a pointer to the bus name a la pci_name from which64 * This returns a pointer to the bus name a la pci_name from which
60 * the caller can then copy.65 * the caller can then copy.
61 * @set_vq_affinity: set the affinity for a virtqueue.66 * @set_vq_affinity: set the affinity for a virtqueue (optional).
62 * @get_vq_affinity: get the affinity for a virtqueue (optional).67 * @get_vq_affinity: get the affinity for a virtqueue (optional).
63 */68 */
64typedef void vq_callback_t(struct virtqueue *);69typedef void vq_callback_t(struct virtqueue *);
include/linux/xarray.h+170−57
@@ -176,7 +176,8 @@ static inline bool xa_is_internal(const void *entry) · 175 unmodified lines
176 */176 */
177static inline bool xa_is_err(const void *entry)177static inline bool xa_is_err(const void *entry)
178{178{
179 return unlikely(xa_is_internal(entry));179 return unlikely(xa_is_internal(entry) &&
180 entry >= xa_mk_internal(-MAX_ERRNO));
180}181}
181 182
182/**183/**
@@ -286,7 +287,6 @@ struct xarray { · 103 unmodified lines
286 */287 */
287#define DEFINE_XARRAY_ALLOC(name) DEFINE_XARRAY_FLAGS(name, XA_FLAGS_ALLOC)288#define DEFINE_XARRAY_ALLOC(name) DEFINE_XARRAY_FLAGS(name, XA_FLAGS_ALLOC)
288 289
289void xa_init_flags(struct xarray *, gfp_t flags);
290void *xa_load(struct xarray *, unsigned long index);290void *xa_load(struct xarray *, unsigned long index);
291void *xa_store(struct xarray *, unsigned long index, void *entry, gfp_t);291void *xa_store(struct xarray *, unsigned long index, void *entry, gfp_t);
292void *xa_erase(struct xarray *, unsigned long index);292void *xa_erase(struct xarray *, unsigned long index);
@@ -303,6 +303,24 @@ unsigned int xa_extract(struct xarray *, void **dst, unsigned long start, · 10 unmodified lines
303 unsigned long max, unsigned int n, xa_mark_t);303 unsigned long max, unsigned int n, xa_mark_t);
304void xa_destroy(struct xarray *);304void xa_destroy(struct xarray *);
305 305
306/**
307 * xa_init_flags() - Initialise an empty XArray with flags.
308 * @xa: XArray.
309 * @flags: XA_FLAG values.
310 *
311 * If you need to initialise an XArray with special flags (eg you need
312 * to take the lock from interrupt context), use this function instead
313 * of xa_init().
314 *
315 * Context: Any context.
316 */
317static inline void xa_init_flags(struct xarray *xa, gfp_t flags)
318{
319 spin_lock_init(&xa->xa_lock);
320 xa->xa_flags = flags;
321 xa->xa_head = NULL;
322}
323
306/**324/**
307 * xa_init() - Initialise an empty XArray.325 * xa_init() - Initialise an empty XArray.
308 * @xa: XArray.326 * @xa: XArray.
@@ -342,20 +360,45 @@ static inline bool xa_marked(const struct xarray *xa, xa_mark_t mark) · 33 unmodified lines
342}360}
343 361
344/**362/**
345 * xa_for_each() - Iterate over a portion of an XArray.363 * xa_for_each_start() - Iterate over a portion of an XArray.
346 * @xa: XArray.364 * @xa: XArray.
365 * @index: Index of @entry.
347 * @entry: Entry retrieved from array.366 * @entry: Entry retrieved from array.
367 * @start: First index to retrieve from array.
368 *
369 * During the iteration, @entry will have the value of the entry stored
370 * in @xa at @index. You may modify @index during the iteration if you
371 * want to skip or reprocess indices. It is safe to modify the array
372 * during the iteration. At the end of the iteration, @entry will be set
373 * to NULL and @index will have a value less than or equal to max.
374 *
375 * xa_for_each_start() is O(n.log(n)) while xas_for_each() is O(n). You have
376 * to handle your own locking with xas_for_each(), and if you have to unlock
377 * after each iteration, it will also end up being O(n.log(n)).
378 * xa_for_each_start() will spin if it hits a retry entry; if you intend to
379 * see retry entries, you should use the xas_for_each() iterator instead.
380 * The xas_for_each() iterator will expand into more inline code than
381 * xa_for_each_start().
382 *
383 * Context: Any context. Takes and releases the RCU lock.
384 */
385#define xa_for_each_start(xa, index, entry, start) \
386 for (index = start, \
387 entry = xa_find(xa, &index, ULONG_MAX, XA_PRESENT); \
388 entry; \
389 entry = xa_find_after(xa, &index, ULONG_MAX, XA_PRESENT))
390
391/**
392 * xa_for_each() - Iterate over present entries in an XArray.
393 * @xa: XArray.
348 * @index: Index of @entry.394 * @index: Index of @entry.
349 * @max: Maximum index to retrieve from array.395 * @entry: Entry retrieved from array.
350 * @filter: Selection criterion.
351 *396 *
352 * Initialise @index to the lowest index you want to retrieve from the397 * During the iteration, @entry will have the value of the entry stored
353 * array. During the iteration, @entry will have the value of the entry398 * in @xa at @index. You may modify @index during the iteration if you want
354 * stored in @xa at @index. The iteration will skip all entries in the399 * to skip or reprocess indices. It is safe to modify the array during the
355 * array which do not match @filter. You may modify @index during the400 * iteration. At the end of the iteration, @entry will be set to NULL and
356 * iteration if you want to skip or reprocess indices. It is safe to modify401 * @index will have a value less than or equal to max.
357 * the array during the iteration. At the end of the iteration, @entry will
358 * be set to NULL and @index will have a value less than or equal to max.
359 *402 *
360 * xa_for_each() is O(n.log(n)) while xas_for_each() is O(n). You have403 * xa_for_each() is O(n.log(n)) while xas_for_each() is O(n). You have
361 * to handle your own locking with xas_for_each(), and if you have to unlock404 * to handle your own locking with xas_for_each(), and if you have to unlock
@@ -366,9 +409,36 @@ static inline bool xa_marked(const struct xarray *xa, xa_mark_t mark) · 4 unmodified lines
366 *409 *
367 * Context: Any context. Takes and releases the RCU lock.410 * Context: Any context. Takes and releases the RCU lock.
368 */411 */
369#define xa_for_each(xa, entry, index, max, filter) \412#define xa_for_each(xa, index, entry) \
370 for (entry = xa_find(xa, &index, max, filter); entry; \413 xa_for_each_start(xa, index, entry, 0)
371 entry = xa_find_after(xa, &index, max, filter))414
415/**
416 * xa_for_each_marked() - Iterate over marked entries in an XArray.
417 * @xa: XArray.
418 * @index: Index of @entry.
419 * @entry: Entry retrieved from array.
420 * @filter: Selection criterion.
421 *
422 * During the iteration, @entry will have the value of the entry stored
423 * in @xa at @index. The iteration will skip all entries in the array
424 * which do not match @filter. You may modify @index during the iteration
425 * if you want to skip or reprocess indices. It is safe to modify the array
426 * during the iteration. At the end of the iteration, @entry will be set to
427 * NULL and @index will have a value less than or equal to max.
428 *
429 * xa_for_each_marked() is O(n.log(n)) while xas_for_each_marked() is O(n).
430 * You have to handle your own locking with xas_for_each(), and if you have
431 * to unlock after each iteration, it will also end up being O(n.log(n)).
432 * xa_for_each_marked() will spin if it hits a retry entry; if you intend to
433 * see retry entries, you should use the xas_for_each_marked() iterator
434 * instead. The xas_for_each_marked() iterator will expand into more inline
435 * code than xa_for_each_marked().
436 *
437 * Context: Any context. Takes and releases the RCU lock.
438 */
439#define xa_for_each_marked(xa, index, entry, filter) \
440 for (index = 0, entry = xa_find(xa, &index, ULONG_MAX, filter); \
441 entry; entry = xa_find_after(xa, &index, ULONG_MAX, filter))
372 442
373#define xa_trylock(xa) spin_trylock(&(xa)->xa_lock)443#define xa_trylock(xa) spin_trylock(&(xa)->xa_lock)
374#define xa_lock(xa) spin_lock(&(xa)->xa_lock)444#define xa_lock(xa) spin_lock(&(xa)->xa_lock)
@@ -393,39 +463,12 @@ void *__xa_erase(struct xarray *, unsigned long index); · 18 unmodified lines
393void *__xa_store(struct xarray *, unsigned long index, void *entry, gfp_t);463void *__xa_store(struct xarray *, unsigned long index, void *entry, gfp_t);
394void *__xa_cmpxchg(struct xarray *, unsigned long index, void *old,464void *__xa_cmpxchg(struct xarray *, unsigned long index, void *old,
395 void *entry, gfp_t);465 void *entry, gfp_t);
466int __xa_insert(struct xarray *, unsigned long index, void *entry, gfp_t);
396int __xa_alloc(struct xarray *, u32 *id, u32 max, void *entry, gfp_t);467int __xa_alloc(struct xarray *, u32 *id, u32 max, void *entry, gfp_t);
397int __xa_reserve(struct xarray *, unsigned long index, gfp_t);468int __xa_reserve(struct xarray *, unsigned long index, gfp_t);
398void __xa_set_mark(struct xarray *, unsigned long index, xa_mark_t);469void __xa_set_mark(struct xarray *, unsigned long index, xa_mark_t);
399void __xa_clear_mark(struct xarray *, unsigned long index, xa_mark_t);470void __xa_clear_mark(struct xarray *, unsigned long index, xa_mark_t);
400 471
401/**
402 * __xa_insert() - Store this entry in the XArray unless another entry is
403 * already present.
404 * @xa: XArray.
405 * @index: Index into array.
406 * @entry: New entry.
407 * @gfp: Memory allocation flags.
408 *
409 * If you would rather see the existing entry in the array, use __xa_cmpxchg().
410 * This function is for users who don't care what the entry is, only that
411 * one is present.
412 *
413 * Context: Any context. Expects xa_lock to be held on entry. May
414 * release and reacquire xa_lock if the @gfp flags permit.
415 * Return: 0 if the store succeeded. -EEXIST if another entry was present.
416 * -ENOMEM if memory could not be allocated.
417 */
418static inline int __xa_insert(struct xarray *xa, unsigned long index,
419 void *entry, gfp_t gfp)
420{
421 void *curr = __xa_cmpxchg(xa, index, NULL, entry, gfp);
422 if (!curr)
423 return 0;
424 if (xa_is_err(curr))
425 return xa_err(curr);
426 return -EEXIST;
427}
428
429/**472/**
430 * xa_store_bh() - Store this entry in the XArray.473 * xa_store_bh() - Store this entry in the XArray.
431 * @xa: XArray.474 * @xa: XArray.
@@ -453,7 +496,7 @@ static inline void *xa_store_bh(struct xarray *xa, unsigned long index, · 21 unmodified lines
453}496}
454 497
455/**498/**
456 * xa_store_irq() - Erase this entry from the XArray.499 * xa_store_irq() - Store this entry in the XArray.
457 * @xa: XArray.500 * @xa: XArray.
458 * @index: Index into array.501 * @index: Index into array.
459 * @entry: New entry.502 * @entry: New entry.
@@ -615,24 +658,83 @@ static inline void *xa_cmpxchg_irq(struct xarray *xa, unsigned long index, · 155 unmodified lines
615 * @entry: New entry.658 * @entry: New entry.
616 * @gfp: Memory allocation flags.659 * @gfp: Memory allocation flags.
617 *660 *
618 * If you would rather see the existing entry in the array, use xa_cmpxchg().661 * Inserting a NULL entry will store a reserved entry (like xa_reserve())
619 * This function is for users who don't care what the entry is, only that662 * if no entry is present. Inserting will fail if a reserved entry is
620 * one is present.663 * present, even though loading from this index will return NULL.
621 *664 *
622 * Context: Process context. Takes and releases the xa_lock.665 * Context: Any context. Takes and releases the xa_lock. May sleep if
623 * May sleep if the @gfp flags permit.666 * the @gfp flags permit.
624 * Return: 0 if the store succeeded. -EEXIST if another entry was present.667 * Return: 0 if the store succeeded. -EEXIST if another entry was present.
625 * -ENOMEM if memory could not be allocated.668 * -ENOMEM if memory could not be allocated.
626 */669 */
627static inline int xa_insert(struct xarray *xa, unsigned long index,670static inline int xa_insert(struct xarray *xa, unsigned long index,
628 void *entry, gfp_t gfp)671 void *entry, gfp_t gfp)
629{672{
630 void *curr = xa_cmpxchg(xa, index, NULL, entry, gfp);673 int err;
631 if (!curr)674
632 return 0;675 xa_lock(xa);
633 if (xa_is_err(curr))676 err = __xa_insert(xa, index, entry, gfp);
634 return xa_err(curr);677 xa_unlock(xa);
635 return -EEXIST;678
679 return err;
680}
681
682/**
683 * xa_insert_bh() - Store this entry in the XArray unless another entry is
684 * already present.
685 * @xa: XArray.
686 * @index: Index into array.
687 * @entry: New entry.
688 * @gfp: Memory allocation flags.
689 *
690 * Inserting a NULL entry will store a reserved entry (like xa_reserve())
691 * if no entry is present. Inserting will fail if a reserved entry is
692 * present, even though loading from this index will return NULL.
693 *
694 * Context: Any context. Takes and releases the xa_lock while
695 * disabling softirqs. May sleep if the @gfp flags permit.
696 * Return: 0 if the store succeeded. -EEXIST if another entry was present.
697 * -ENOMEM if memory could not be allocated.
698 */
699static inline int xa_insert_bh(struct xarray *xa, unsigned long index,
700 void *entry, gfp_t gfp)
701{
702 int err;
703
704 xa_lock_bh(xa);
705 err = __xa_insert(xa, index, entry, gfp);
706 xa_unlock_bh(xa);
707
708 return err;
709}
710
711/**
712 * xa_insert_irq() - Store this entry in the XArray unless another entry is
713 * already present.
714 * @xa: XArray.
715 * @index: Index into array.
716 * @entry: New entry.
717 * @gfp: Memory allocation flags.
718 *
719 * Inserting a NULL entry will store a reserved entry (like xa_reserve())
720 * if no entry is present. Inserting will fail if a reserved entry is
721 * present, even though loading from this index will return NULL.
722 *
723 * Context: Process context. Takes and releases the xa_lock while
724 * disabling interrupts. May sleep if the @gfp flags permit.
725 * Return: 0 if the store succeeded. -EEXIST if another entry was present.
726 * -ENOMEM if memory could not be allocated.
727 */
728static inline int xa_insert_irq(struct xarray *xa, unsigned long index,
729 void *entry, gfp_t gfp)
730{
731 int err;
732
733 xa_lock_irq(xa);
734 err = __xa_insert(xa, index, entry, gfp);
735 xa_unlock_irq(xa);
736
737 return err;
636}738}
637 739
638/**740/**
@@ -970,8 +1072,8 @@ static inline bool xa_is_sibling(const void *entry) · 331 unmodified lines
970 (entry < xa_mk_sibling(XA_CHUNK_SIZE - 1));1072 (entry < xa_mk_sibling(XA_CHUNK_SIZE - 1));
971}1073}
972 1074
973#define XA_ZERO_ENTRY xa_mk_internal(256)1075#define XA_RETRY_ENTRY xa_mk_internal(256)
974#define XA_RETRY_ENTRY xa_mk_internal(257)1076#define XA_ZERO_ENTRY xa_mk_internal(257)
975 1077
976/**1078/**
977 * xa_is_zero() - Is the entry a zero entry?1079 * xa_is_zero() - Is the entry a zero entry?
@@ -995,6 +1097,17 @@ static inline bool xa_is_retry(const void *entry) · 17 unmodified lines
995 return unlikely(entry == XA_RETRY_ENTRY);1097 return unlikely(entry == XA_RETRY_ENTRY);
996}1098}
997 1099
1100/**
1101 * xa_is_advanced() - Is the entry only permitted for the advanced API?
1102 * @entry: Entry to be stored in the XArray.
1103 *
1104 * Return: %true if the entry cannot be stored by the normal API.
1105 */
1106static inline bool xa_is_advanced(const void *entry)
1107{
1108 return xa_is_internal(entry) && (entry <= XA_RETRY_ENTRY);
1109}
1110
998/**1111/**
999 * typedef xa_update_node_t - A callback function from the XArray.1112 * typedef xa_update_node_t - A callback function from the XArray.
1000 * @node: The node which is being processed1113 * @node: The node which is being processed

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