Pick up upstream changes to avoid conflicts for pending patches.
Showing the changes to include/linux (37 of 952 files). Show all
Unified · Split
| @@ -190,6 +190,7 @@ struct backing_dev_info { · 189 unmodified lines | ||
| 190 | 190 | struct radix_tree_root cgwb_tree; /* radix tree of active cgroup wbs */ |
| 191 | 191 | struct rb_root cgwb_congested_tree; /* their congested states */ |
| 192 | 192 | struct mutex cgwb_release_mutex; /* protect shutdown of wb structs */ |
| 193 | + struct rw_semaphore wb_switch_rwsem; /* no cgwb switch while syncing */ | |
| 193 | 194 | #else |
| 194 | 195 | struct bdi_writeback_congested *wb_congested; |
| 195 | 196 | #endif |
| @@ -6,6 +6,7 @@ · 5 unmodified lines | ||
| 6 | 6 | |
| 7 | 7 | struct bcma_soc { |
| 8 | 8 | struct bcma_bus bus; |
| 9 | + struct device *dev; | |
| 9 | 10 | }; |
| 10 | 11 | |
| 11 | 12 | int __init bcma_host_soc_register(struct bcma_soc *soc); |
| @@ -287,7 +287,7 @@ enum req_opf { · 286 unmodified lines | ||
| 287 | 287 | REQ_OP_DISCARD = 3, |
| 288 | 288 | /* securely erase sectors */ |
| 289 | 289 | REQ_OP_SECURE_ERASE = 5, |
| 290 | − /* seset a zone write pointer */ | |
| 290 | + /* reset a zone write pointer */ | |
| 291 | 291 | REQ_OP_ZONE_RESET = 6, |
| 292 | 292 | /* write the same sector many times */ |
| 293 | 293 | REQ_OP_WRITE_SAME = 7, |
| @@ -172,6 +172,7 @@ struct bpf_verifier_state_list { · 171 unmodified lines | ||
| 172 | 172 | #define BPF_ALU_SANITIZE_SRC 1U |
| 173 | 173 | #define BPF_ALU_SANITIZE_DST 2U |
| 174 | 174 | #define BPF_ALU_NEG_VALUE (1U << 2) |
| 175 | +#define BPF_ALU_NON_POINTER (1U << 3) | |
| 175 | 176 | #define BPF_ALU_SANITIZE (BPF_ALU_SANITIZE_SRC | \ |
| 176 | 177 | BPF_ALU_SANITIZE_DST) |
| 177 | 178 | |
| @@ -3,13 +3,22 @@ · 2 unmodified lines | ||
| 3 | 3 | #define _LINUX_BPFILTER_H |
| 4 | 4 | |
| 5 | 5 | #include <uapi/linux/bpfilter.h> |
| 6 | +#include <linux/umh.h> | |
| 6 | 7 | |
| 7 | 8 | struct sock; |
| 8 | 9 | int bpfilter_ip_set_sockopt(struct sock *sk, int optname, char __user *optval, |
| 9 | 10 | unsigned int optlen); |
| 10 | 11 | int bpfilter_ip_get_sockopt(struct sock *sk, int optname, char __user *optval, |
| 11 | 12 | int __user *optlen); |
| 12 | −extern int (*bpfilter_process_sockopt)(struct sock *sk, int optname, | |
| 13 | − char __user *optval, | |
| 14 | − unsigned int optlen, bool is_set); | |
| 13 | +struct bpfilter_umh_ops { | |
| 14 | + struct umh_info info; | |
| 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 | +}; | |
| 23 | +extern struct bpfilter_umh_ops bpfilter_ops; | |
| 15 | 24 | #endif |
| @@ -3,9 +3,8 @@ · 2 unmodified lines | ||
| 3 | 3 | #error "Please don't include <linux/compiler-clang.h> directly, include <linux/compiler.h> instead." |
| 4 | 4 | #endif |
| 5 | 5 | |
| 6 | −/* Some compiler specific definitions are overwritten here | |
| 7 | − * for Clang compiler | |
| 8 | − */ | |
| 6 | +/* Compiler specific definitions for Clang compiler */ | |
| 7 | + | |
| 9 | 8 | #define uninitialized_var(x) x = *(&(x)) |
| 10 | 9 | |
| 11 | 10 | /* same as gcc, this was present in clang-2.6 so we can assume it works |
| @@ -58,10 +58,6 @@ · 57 unmodified lines | ||
| 58 | 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 | 62 | * A trick to suppress uninitialized variable warning without generating any |
| 67 | 63 | * code |
| @@ -5,9 +5,7 @@ · 4 unmodified lines | ||
| 5 | 5 | |
| 6 | 6 | #ifdef __ECC |
| 7 | 7 | |
| 8 | −/* Some compiler specific definitions are overwritten here | |
| 9 | − * for Intel ECC compiler | |
| 10 | − */ | |
| 8 | +/* Compiler specific definitions for Intel ECC compiler */ | |
| 11 | 9 | |
| 12 | 10 | #include <asm/intrinsics.h> |
| 13 | 11 | |
| @@ -161,7 +161,9 @@ void ftrace_likely_update(struct ftrace_likely_data *f, int val, · 160 unmodified lines | ||
| 161 | 161 | #endif |
| 162 | 162 | |
| 163 | 163 | #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 | 167 | #endif |
| 166 | 168 | |
| 167 | 169 | /* Not-quite-unique ID. */ |
| @@ -180,12 +180,10 @@ enum cpuhp_smt_control { · 179 unmodified lines | ||
| 180 | 180 | #if defined(CONFIG_SMP) && defined(CONFIG_HOTPLUG_SMT) |
| 181 | 181 | extern enum cpuhp_smt_control cpu_smt_control; |
| 182 | 182 | extern void cpu_smt_disable(bool force); |
| 183 | −extern void cpu_smt_check_topology_early(void); | |
| 184 | 183 | extern void cpu_smt_check_topology(void); |
| 185 | 184 | #else |
| 186 | 185 | # define cpu_smt_control (CPU_SMT_ENABLED) |
| 187 | 186 | static inline void cpu_smt_disable(bool force) { } |
| 188 | −static inline void cpu_smt_check_topology_early(void) { } | |
| 189 | 187 | static inline void cpu_smt_check_topology(void) { } |
| 190 | 188 | #endif |
| 191 | 189 | |
| @@ -62,9 +62,10 @@ extern const struct qstr slash_name; · 61 unmodified lines | ||
| 62 | 62 | struct dentry_stat_t { |
| 63 | 63 | long nr_dentry; |
| 64 | 64 | long nr_unused; |
| 65 | − long age_limit; /* age in seconds */ | |
| 66 | − long want_pages; /* pages requested by system */ | |
| 67 | − long dummy[2]; | |
| 65 | + long age_limit; /* age in seconds */ | |
| 66 | + long want_pages; /* pages requested by system */ | |
| 67 | + long nr_negative; /* # of unused negative dentries */ | |
| 68 | + long dummy; /* Reserved for future use */ | |
| 68 | 69 | }; |
| 69 | 70 | extern struct dentry_stat_t dentry_stat; |
| 70 | 71 | |
| @@ -653,6 +653,7 @@ extern int fb_new_modelist(struct fb_info *info); · 652 unmodified lines | ||
| 653 | 653 | |
| 654 | 654 | extern struct fb_info *registered_fb[FB_MAX]; |
| 655 | 655 | extern int num_registered_fb; |
| 656 | +extern bool fb_center_logo; | |
| 656 | 657 | extern struct class *fb_class; |
| 657 | 658 | |
| 658 | 659 | #define for_each_registered_fb(i) \ |
| @@ -1479,11 +1479,12 @@ struct super_block { · 1478 unmodified lines | ||
| 1479 | 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 their | |
| 1483 | − * own individual cachelines. | |
| 1482 | + * The list_lru structure is essentially just a pointer to a table | |
| 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_inode_lru ____cacheline_aligned_in_smp; | |
| 1486 | + struct list_lru s_dentry_lru; | |
| 1487 | + struct list_lru s_inode_lru; | |
| 1487 | 1488 | struct rcu_head rcu; |
| 1488 | 1489 | struct work_struct destroy_work; |
| 1489 | 1490 | |
| @@ -24,7 +24,10 @@ · 23 unmodified lines | ||
| 24 | 24 | |
| 25 | 25 | #ifdef CONFIG_DEBUG_FS |
| 26 | 26 | |
| 27 | +#include <linux/kfifo.h> | |
| 28 | + | |
| 27 | 29 | #define HID_DEBUG_BUFSIZE 512 |
| 30 | +#define HID_DEBUG_FIFOSIZE 512 | |
| 28 | 31 | |
| 29 | 32 | void hid_dump_input(struct hid_device *, struct hid_usage *, __s32); |
| 30 | 33 | void hid_dump_report(struct hid_device *, int , u8 *, int); |
| @@ -37,11 +40,8 @@ void hid_debug_init(void); · 6 unmodified lines | ||
| 37 | 40 | void hid_debug_exit(void); |
| 38 | 41 | void hid_debug_event(struct hid_device *, char *); |
| 39 | 42 | |
| 40 | − | |
| 41 | 43 | struct hid_debug_list { |
| 42 | − char *hid_debug_buf; | |
| 43 | − int head; | |
| 44 | − int tail; | |
| 44 | + DECLARE_KFIFO_PTR(hid_debug_fifo, char); | |
| 45 | 45 | struct fasync_struct *fasync; |
| 46 | 46 | struct hid_device *hdev; |
| 47 | 47 | struct list_head node; |
| @@ -64,4 +64,3 @@ struct hid_debug_list { · 16 unmodified lines | ||
| 64 | 64 | #endif |
| 65 | 65 | |
| 66 | 66 | #endif |
| 67 | − | |
| @@ -430,7 +430,7 @@ struct hid_local { · 429 unmodified lines | ||
| 430 | 430 | */ |
| 431 | 431 | |
| 432 | 432 | struct hid_collection { |
| 433 | − struct hid_collection *parent; | |
| 433 | + int parent_idx; /* device->collection */ | |
| 434 | 434 | unsigned type; |
| 435 | 435 | unsigned usage; |
| 436 | 436 | unsigned level; |
| @@ -658,7 +658,6 @@ struct hid_parser { · 221 unmodified lines | ||
| 658 | 658 | unsigned int *collection_stack; |
| 659 | 659 | unsigned int collection_stack_ptr; |
| 660 | 660 | unsigned int collection_stack_size; |
| 661 | − struct hid_collection *active_collection; | |
| 662 | 661 | struct hid_device *device; |
| 663 | 662 | unsigned int scan_flags; |
| 664 | 663 | }; |
| @@ -1159,8 +1159,9 @@ struct hv_ring_buffer_debug_info { · 1158 unmodified lines | ||
| 1159 | 1159 | u32 bytes_avail_towrite; |
| 1160 | 1160 | }; |
| 1161 | 1161 | |
| 1162 | −void hv_ringbuffer_get_debuginfo(const struct hv_ring_buffer_info *ring_info, | |
| 1163 | − struct hv_ring_buffer_debug_info *debug_info); | |
| 1162 | + | |
| 1163 | +int hv_ringbuffer_get_debuginfo(const struct hv_ring_buffer_info *ring_info, | |
| 1164 | + struct hv_ring_buffer_debug_info *debug_info); | |
| 1164 | 1165 | |
| 1165 | 1166 | /* Vmbus interface */ |
| 1166 | 1167 | #define vmbus_driver_register(driver) \ |
| @@ -615,6 +615,7 @@ struct ide_drive_s { · 614 unmodified lines | ||
| 615 | 615 | |
| 616 | 616 | /* current sense rq and buffer */ |
| 617 | 617 | bool sense_rq_armed; |
| 618 | + bool sense_rq_active; | |
| 618 | 619 | struct request *sense_rq; |
| 619 | 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 | ||
| 1219 | 1220 | extern void ide_timer_expiry(struct timer_list *t); |
| 1220 | 1221 | extern irqreturn_t ide_intr(int irq, void *dev_id); |
| 1221 | 1222 | extern blk_status_t ide_queue_rq(struct blk_mq_hw_ctx *, const struct blk_mq_queue_data *); |
| 1223 | +extern blk_status_t ide_issue_rq(ide_drive_t *, struct request *, bool); | |
| 1222 | 1224 | extern void ide_requeue_and_plug(ide_drive_t *drive, struct request *rq); |
| 1223 | 1225 | |
| 1224 | 1226 | void ide_init_disk(struct gendisk *, ide_drive_t *); |
| @@ -54,6 +54,7 @@ static inline bool dev_is_mac_header_xmit(const struct net_device *dev) · 53 unmodified lines | ||
| 54 | 54 | case ARPHRD_IPGRE: |
| 55 | 55 | case ARPHRD_VOID: |
| 56 | 56 | case ARPHRD_NONE: |
| 57 | + case ARPHRD_RAWIP: | |
| 57 | 58 | return false; |
| 58 | 59 | default: |
| 59 | 60 | return true; |
| @@ -260,6 +260,7 @@ struct irq_affinity { · 259 unmodified lines | ||
| 260 | 260 | /** |
| 261 | 261 | * struct irq_affinity_desc - Interrupt affinity descriptor |
| 262 | 262 | * @mask: cpumask to hold the affinity assignment |
| 263 | + * @is_managed: 1 if the interrupt is managed internally | |
| 263 | 264 | */ |
| 264 | 265 | struct irq_affinity_desc { |
| 265 | 266 | struct cpumask mask; |
| @@ -160,6 +160,7 @@ static inline struct nd_blk_region_desc *to_blk_region_desc( · 159 unmodified lines | ||
| 160 | 160 | } |
| 161 | 161 | |
| 162 | 162 | enum nvdimm_security_state { |
| 163 | + NVDIMM_SECURITY_ERROR = -1, | |
| 163 | 164 | NVDIMM_SECURITY_DISABLED, |
| 164 | 165 | NVDIMM_SECURITY_UNLOCKED, |
| 165 | 166 | NVDIMM_SECURITY_LOCKED, |
| @@ -234,7 +235,6 @@ static inline struct nvdimm *nvdimm_create(struct nvdimm_bus *nvdimm_bus, · 68 unmodified lines | ||
| 234 | 235 | cmd_mask, num_flush, flush_wpq, NULL, NULL); |
| 235 | 236 | } |
| 236 | 237 | |
| 237 | −int nvdimm_security_setup_events(struct nvdimm *nvdimm); | |
| 238 | 238 | const struct nd_cmd_desc *nd_cmd_dimm_desc(int cmd); |
| 239 | 239 | const struct nd_cmd_desc *nd_cmd_bus_desc(int cmd); |
| 240 | 240 | u32 nd_cmd_in_size(struct nvdimm *nvdimm, int cmd, |
| @@ -21,14 +21,16 @@ struct vmem_altmap; · 20 unmodified lines | ||
| 21 | 21 | * walkers which rely on the fully initialized page->flags and others |
| 22 | 22 | * should use this rather than pfn_valid && pfn_to_page |
| 23 | 23 | */ |
| 24 | −#define pfn_to_online_page(pfn) \ | |
| 25 | −({ \ | |
| 26 | − struct page *___page = NULL; \ | |
| 27 | − unsigned long ___nr = pfn_to_section_nr(pfn); \ | |
| 28 | − \ | |
| 29 | − if (___nr < NR_MEM_SECTIONS && online_section_nr(___nr))\ | |
| 30 | − ___page = pfn_to_page(pfn); \ | |
| 31 | − ___page; \ | |
| 24 | +#define pfn_to_online_page(pfn) \ | |
| 25 | +({ \ | |
| 26 | + struct page *___page = NULL; \ | |
| 27 | + unsigned long ___pfn = pfn; \ | |
| 28 | + unsigned long ___nr = pfn_to_section_nr(___pfn); \ | |
| 29 | + \ | |
| 30 | + if (___nr < NR_MEM_SECTIONS && online_section_nr(___nr) && \ | |
| 31 | + pfn_valid_within(___pfn)) \ | |
| 32 | + ___page = pfn_to_page(___pfn); \ | |
| 33 | + ___page; \ | |
| 32 | 34 | }) |
| 33 | 35 | |
| 34 | 36 | /* |
| @@ -2790,6 +2790,100 @@ struct ec_response_battery_vendor_param { · 2789 unmodified lines | ||
| 2790 | 2790 | uint32_t value; |
| 2791 | 2791 | } __packed; |
| 2792 | 2792 | |
| 2793 | +/*****************************************************************************/ | |
| 2794 | +/* Commands for I2S recording on audio codec. */ | |
| 2795 | + | |
| 2796 | +#define EC_CMD_CODEC_I2S 0x00BC | |
| 2797 | + | |
| 2798 | +enum 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 | + | |
| 2808 | +enum ec_sample_depth_value { | |
| 2809 | + EC_CODEC_SAMPLE_DEPTH_16 = 0, | |
| 2810 | + EC_CODEC_SAMPLE_DEPTH_24 = 1, | |
| 2811 | +}; | |
| 2812 | + | |
| 2813 | +enum 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 | + | |
| 2822 | +struct 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 | + */ | |
| 2882 | +struct ec_response_codec_gain { | |
| 2883 | + uint8_t left; | |
| 2884 | + uint8_t right; | |
| 2885 | +} __packed; | |
| 2886 | + | |
| 2793 | 2887 | /*****************************************************************************/ |
| 2794 | 2888 | /* System commands */ |
| 2795 | 2889 | |
| @@ -41,7 +41,7 @@ · 40 unmodified lines | ||
| 41 | 41 | #define TCU_TCSR_PRESCALE_LSB 3 |
| 42 | 42 | #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 | 45 | #define TCU_TCSR_PWM_INITL_HIGH BIT(8) /* Sets the initial output level */ |
| 46 | 46 | #define TCU_TCSR_PWM_EN BIT(7) /* PWM pin output enable */ |
| 47 | 47 | |
| @@ -15,6 +15,7 @@ · 14 unmodified lines | ||
| 15 | 15 | #include <linux/gpio/consumer.h> |
| 16 | 16 | #include <linux/interrupt.h> |
| 17 | 17 | #include <linux/mfd/madera/pdata.h> |
| 18 | +#include <linux/mutex.h> | |
| 18 | 19 | #include <linux/notifier.h> |
| 19 | 20 | #include <linux/regmap.h> |
| 20 | 21 | #include <linux/regulator/consumer.h> |
| @@ -37,6 +38,8 @@ enum madera_type { · 16 unmodified lines | ||
| 37 | 38 | |
| 38 | 39 | #define MADERA_MAX_MICBIAS 4 |
| 39 | 40 | |
| 41 | +#define MADERA_MAX_HP_OUTPUT 3 | |
| 42 | + | |
| 40 | 43 | /* Notifier events */ |
| 41 | 44 | #define MADERA_NOTIFY_VOICE_TRIGGER 0x1 |
| 42 | 45 | #define MADERA_NOTIFY_HPDET 0x2 |
| @@ -183,6 +186,10 @@ struct madera { · 140 unmodified lines | ||
| 183 | 186 | unsigned int num_childbias[MADERA_MAX_MICBIAS]; |
| 184 | 187 | |
| 185 | 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 | 194 | struct blocking_notifier_head notifier; |
| 188 | 195 | }; |
| @@ -78,6 +78,8 @@ · 77 unmodified lines | ||
| 78 | 78 | #define STEPCONFIG_YNN BIT(8) |
| 79 | 79 | #define STEPCONFIG_XNP BIT(9) |
| 80 | 80 | #define STEPCONFIG_YPN BIT(10) |
| 81 | +#define STEPCONFIG_RFP(val) ((val) << 12) | |
| 82 | +#define STEPCONFIG_RFP_VREFP (0x3 << 12) | |
| 81 | 83 | #define STEPCONFIG_INM_MASK (0xF << 15) |
| 82 | 84 | #define STEPCONFIG_INM(val) ((val) << 15) |
| 83 | 85 | #define STEPCONFIG_INM_ADCREFM STEPCONFIG_INM(8) |
| @@ -86,6 +88,8 @@ · 2 unmodified lines | ||
| 86 | 88 | #define STEPCONFIG_INP_AN4 STEPCONFIG_INP(4) |
| 87 | 89 | #define STEPCONFIG_INP_ADCREFM STEPCONFIG_INP(8) |
| 88 | 90 | #define STEPCONFIG_FIFO1 BIT(26) |
| 91 | +#define STEPCONFIG_RFM(val) ((val) << 23) | |
| 92 | +#define STEPCONFIG_RFM_VREFN (0x3 << 23) | |
| 89 | 93 | |
| 90 | 94 | /* Delay register */ |
| 91 | 95 | #define STEPDELAY_OPEN_MASK (0x3FFFF << 0) |
| @@ -79,7 +79,7 @@ · 78 unmodified lines | ||
| 79 | 79 | /* Some controllers have a CBSY bit */ |
| 80 | 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 | 83 | #define TMIO_MMC_HAVE_4TAP_HS400 BIT(13) |
| 84 | 84 | |
| 85 | 85 | int tmio_core_mmc_enable(void __iomem *cnf, int shift, unsigned long base); |
| @@ -50,7 +50,6 @@ struct of_irq_controller; · 49 unmodified lines | ||
| 50 | 50 | |
| 51 | 51 | struct device_node { |
| 52 | 52 | const char *name; |
| 53 | − const char *type; | |
| 54 | 53 | phandle phandle; |
| 55 | 54 | const char *full_name; |
| 56 | 55 | struct fwnode_handle fwnode; |
| @@ -48,6 +48,7 @@ extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_features) __ro_after_init; · 47 unmodified lines | ||
| 48 | 48 | extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_fibre_features) __ro_after_init; |
| 49 | 49 | extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_all_ports_features) __ro_after_init; |
| 50 | 50 | extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_features) __ro_after_init; |
| 51 | +extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_fec_features) __ro_after_init; | |
| 51 | 52 | extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_full_features) __ro_after_init; |
| 52 | 53 | |
| 53 | 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 | 57 | #define PHY_GBIT_FIBRE_FEATURES ((unsigned long *)&phy_gbit_fibre_features) |
| 57 | 58 | #define PHY_GBIT_ALL_PORTS_FEATURES ((unsigned long *)&phy_gbit_all_ports_features) |
| 58 | 59 | #define PHY_10GBIT_FEATURES ((unsigned long *)&phy_10gbit_features) |
| 60 | +#define PHY_10GBIT_FEC_FEATURES ((unsigned long *)&phy_10gbit_fec_features) | |
| 59 | 61 | #define PHY_10GBIT_FULL_FEATURES ((unsigned long *)&phy_10gbit_full_features) |
| 60 | 62 | |
| 61 | 63 | extern const int phy_10_100_features_array[4]; |
| @@ -467,8 +469,8 @@ struct phy_device { · 405 unmodified lines | ||
| 467 | 469 | * only works for PHYs with IDs which match this field |
| 468 | 470 | * name: The friendly name of this PHY type |
| 469 | 471 | * phy_id_mask: Defines the important bits of the phy_id |
| 470 | − * features: A list of features (speed, duplex, etc) supported | |
| 471 | − * by this PHY | |
| 472 | + * features: A mandatory list of features (speed, duplex, etc) | |
| 473 | + * supported by this PHY | |
| 472 | 474 | * flags: A bitfield defining certain other features this PHY |
| 473 | 475 | * supports (like interrupts) |
| 474 | 476 | * |
| @@ -105,7 +105,7 @@ static inline bool pm_runtime_callbacks_present(struct device *dev) · 104 unmodified lines | ||
| 105 | 105 | |
| 106 | 106 | static 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 | |
| 111 | 111 | static inline bool pm_runtime_is_irq_safe(struct device *dev) |
| @@ -663,6 +663,37 @@ out: · 662 unmodified lines | ||
| 663 | 663 | static inline void qed_chain_set_prod(struct qed_chain *p_chain, |
| 664 | 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 | 697 | if (is_chain_u16(p_chain)) |
| 667 | 698 | p_chain->u.chain16.prod_idx = (u16) prod_idx; |
| 668 | 699 | else |
| @@ -995,7 +995,7 @@ struct task_struct { · 994 unmodified lines | ||
| 995 | 995 | /* cg_list protected by css_set_lock and tsk->alloc_lock: */ |
| 996 | 996 | struct list_head cg_list; |
| 997 | 997 | #endif |
| 998 | −#ifdef CONFIG_X86_RESCTRL | |
| 998 | +#ifdef CONFIG_X86_CPU_RESCTRL | |
| 999 | 999 | u32 closid; |
| 1000 | 1000 | u32 rmid; |
| 1001 | 1001 | #endif |
| @@ -1406,6 +1406,7 @@ extern struct pid *cad_pid; · 404 unmodified lines | ||
| 1406 | 1406 | #define PF_RANDOMIZE 0x00400000 /* Randomize virtual address space */ |
| 1407 | 1407 | #define PF_SWAPWRITE 0x00800000 /* Allowed to write to swap */ |
| 1408 | 1408 | #define PF_MEMSTALL 0x01000000 /* Stalled due to lack of memory */ |
| 1409 | +#define PF_UMH 0x02000000 /* I'm an Usermodehelper process */ | |
| 1409 | 1410 | #define PF_NO_SETAFFINITY 0x04000000 /* Userland is not allowed to meddle with cpus_allowed */ |
| 1410 | 1411 | #define PF_MCE_EARLY 0x08000000 /* Early kill for mce process policy */ |
| 1411 | 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 | 1906 | #endif |
| 1906 | 1907 | |
| 1908 | +void __exit_umh(struct task_struct *tsk); | |
| 1909 | + | |
| 1910 | +static inline void exit_umh(struct task_struct *tsk) | |
| 1911 | +{ | |
| 1912 | + if (unlikely(tsk->flags & PF_UMH)) | |
| 1913 | + __exit_umh(tsk); | |
| 1914 | +} | |
| 1915 | + | |
| 1907 | 1916 | #ifdef CONFIG_DEBUG_RSEQ |
| 1908 | 1917 | |
| 1909 | 1918 | void rseq_syscall(struct pt_regs *regs); |
| @@ -71,6 +71,7 @@ static inline int get_dumpable(struct mm_struct *mm) · 70 unmodified lines | ||
| 71 | 71 | #define MMF_HUGE_ZERO_PAGE 23 /* mm has ever used the global huge zero page */ |
| 72 | 72 | #define MMF_DISABLE_THP 24 /* disable THP for all VMAs */ |
| 73 | 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 | 75 | #define MMF_DISABLE_THP_MASK (1 << MMF_DISABLE_THP) |
| 75 | 76 | |
| 76 | 77 | #define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ |
| @@ -24,9 +24,13 @@ · 23 unmodified lines | ||
| 24 | 24 | * called near the end of a function. Otherwise, the list can be |
| 25 | 25 | * re-initialized for later re-use by wake_q_init(). |
| 26 | 26 | * |
| 27 | − * Note that this can cause spurious wakeups. schedule() callers | |
| 27 | + * NOTE that this can cause spurious wakeups. schedule() callers | |
| 28 | 28 | * must ensure the call is done inside a loop, confirming that the |
| 29 | 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 | 36 | #include <linux/sched.h> |
| @@ -3218,6 +3218,7 @@ int pskb_trim_rcsum_slow(struct sk_buff *skb, unsigned int len); · 3217 unmodified lines | ||
| 3218 | 3218 | * |
| 3219 | 3219 | * This is exactly the same as pskb_trim except that it ensures the |
| 3220 | 3220 | * checksum of received packets are still valid after the operation. |
| 3221 | + * It can change skb pointers. | |
| 3221 | 3222 | */ |
| 3222 | 3223 | |
| 3223 | 3224 | static inline int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len) |
| @@ -47,6 +47,8 @@ struct umh_info { · 46 unmodified lines | ||
| 47 | 47 | const char *cmdline; |
| 48 | 48 | struct file *pipe_to_umh; |
| 49 | 49 | struct file *pipe_from_umh; |
| 50 | + struct list_head list; | |
| 51 | + void (*cleanup)(struct umh_info *info); | |
| 50 | 52 | pid_t pid; |
| 51 | 53 | }; |
| 52 | 54 | int fork_usermode_blob(void *data, size_t len, struct umh_info *info); |
| @@ -12,6 +12,11 @@ struct irq_affinity; · 11 unmodified lines | ||
| 12 | 12 | |
| 13 | 13 | /** |
| 14 | 14 | * 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 | 20 | * @get: read the value of a configuration field |
| 16 | 21 | * vdev: the virtio_device |
| 17 | 22 | * offset: the offset of the configuration field |
| @@ -22,7 +27,7 @@ struct irq_affinity; · 4 unmodified lines | ||
| 22 | 27 | * offset: the offset of the configuration field |
| 23 | 28 | * buf: the buffer to read the field value from. |
| 24 | 29 | * len: the length of the buffer |
| 25 | − * @generation: config generation counter | |
| 30 | + * @generation: config generation counter (optional) | |
| 26 | 31 | * vdev: the virtio_device |
| 27 | 32 | * Returns the config generation counter |
| 28 | 33 | * @get_status: read the status byte |
| @@ -48,17 +53,17 @@ struct irq_affinity; · 19 unmodified lines | ||
| 48 | 53 | * @del_vqs: free virtqueues found by find_vqs(). |
| 49 | 54 | * @get_features: get the array of feature bits for this device. |
| 50 | 55 | * 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 | 57 | * @finalize_features: confirm what device features we'll be using. |
| 53 | 58 | * vdev: the virtio_device |
| 54 | 59 | * This gives the final feature bits for the device: it can change |
| 55 | 60 | * the dev->feature bits if it wants. |
| 56 | 61 | * Returns 0 on success or error status |
| 57 | − * @bus_name: return the bus name associated with the device | |
| 62 | + * @bus_name: return the bus name associated with the device (optional) | |
| 58 | 63 | * vdev: the virtio_device |
| 59 | 64 | * This returns a pointer to the bus name a la pci_name from which |
| 60 | 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 | 67 | * @get_vq_affinity: get the affinity for a virtqueue (optional). |
| 63 | 68 | */ |
| 64 | 69 | typedef void vq_callback_t(struct virtqueue *); |
| @@ -176,7 +176,8 @@ static inline bool xa_is_internal(const void *entry) · 175 unmodified lines | ||
| 176 | 176 | */ |
| 177 | 177 | static 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 | 288 | #define DEFINE_XARRAY_ALLOC(name) DEFINE_XARRAY_FLAGS(name, XA_FLAGS_ALLOC) |
| 288 | 289 | |
| 289 | −void xa_init_flags(struct xarray *, gfp_t flags); | |
| 290 | 290 | void *xa_load(struct xarray *, unsigned long index); |
| 291 | 291 | void *xa_store(struct xarray *, unsigned long index, void *entry, gfp_t); |
| 292 | 292 | void *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 | 303 | unsigned long max, unsigned int n, xa_mark_t); |
| 304 | 304 | void 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 | + */ | |
| 317 | +static 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 | 325 | * xa_init() - Initialise an empty XArray. |
| 308 | 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 | 364 | * @xa: XArray. |
| 365 | + * @index: Index of @entry. | |
| 347 | 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 | 394 | * @index: Index of @entry. |
| 349 | − * @max: Maximum index to retrieve from array. | |
| 350 | − * @filter: Selection criterion. | |
| 395 | + * @entry: Entry retrieved from array. | |
| 351 | 396 | * |
| 352 | − * Initialise @index to the lowest index you want to retrieve from the | |
| 353 | − * array. During the iteration, @entry will have the value of the entry | |
| 354 | − * stored in @xa at @index. The iteration will skip all entries in the | |
| 355 | − * array which do not match @filter. You may modify @index during the | |
| 356 | − * iteration if you want to skip or reprocess indices. It is safe to modify | |
| 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. | |
| 397 | + * During the iteration, @entry will have the value of the entry stored | |
| 398 | + * in @xa at @index. You may modify @index during the iteration if you want | |
| 399 | + * to skip or reprocess indices. It is safe to modify the array during the | |
| 400 | + * iteration. At the end of the iteration, @entry will be set to NULL and | |
| 401 | + * @index will have a value less than or equal to max. | |
| 359 | 402 | * |
| 360 | 403 | * xa_for_each() is O(n.log(n)) while xas_for_each() is O(n). You have |
| 361 | 404 | * 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 | 410 | * Context: Any context. Takes and releases the RCU lock. |
| 368 | 411 | */ |
| 369 | −#define xa_for_each(xa, entry, index, max, filter) \ | |
| 370 | − for (entry = xa_find(xa, &index, max, filter); entry; \ | |
| 371 | − entry = xa_find_after(xa, &index, max, filter)) | |
| 412 | +#define xa_for_each(xa, index, entry) \ | |
| 413 | + xa_for_each_start(xa, index, entry, 0) | |
| 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 | 443 | #define xa_trylock(xa) spin_trylock(&(xa)->xa_lock) |
| 374 | 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 | ||
| 393 | 463 | void *__xa_store(struct xarray *, unsigned long index, void *entry, gfp_t); |
| 394 | 464 | void *__xa_cmpxchg(struct xarray *, unsigned long index, void *old, |
| 395 | 465 | void *entry, gfp_t); |
| 466 | +int __xa_insert(struct xarray *, unsigned long index, void *entry, gfp_t); | |
| 396 | 467 | int __xa_alloc(struct xarray *, u32 *id, u32 max, void *entry, gfp_t); |
| 397 | 468 | int __xa_reserve(struct xarray *, unsigned long index, gfp_t); |
| 398 | 469 | void __xa_set_mark(struct xarray *, unsigned long index, xa_mark_t); |
| 399 | 470 | void __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 | − */ | |
| 418 | −static 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 | 473 | * xa_store_bh() - Store this entry in the XArray. |
| 431 | 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 | 500 | * @xa: XArray. |
| 458 | 501 | * @index: Index into array. |
| 459 | 502 | * @entry: New entry. |
| @@ -615,24 +658,83 @@ static inline void *xa_cmpxchg_irq(struct xarray *xa, unsigned long index, · 155 unmodified lines | ||
| 615 | 658 | * @entry: New entry. |
| 616 | 659 | * @gfp: Memory allocation flags. |
| 617 | 660 | * |
| 618 | − * If you would rather see the existing entry in the array, use xa_cmpxchg(). | |
| 619 | − * This function is for users who don't care what the entry is, only that | |
| 620 | − * one is present. | |
| 661 | + * Inserting a NULL entry will store a reserved entry (like xa_reserve()) | |
| 662 | + * if no entry is present. Inserting will fail if a reserved entry is | |
| 663 | + * present, even though loading from this index will return NULL. | |
| 621 | 664 | * |
| 622 | − * Context: Process context. Takes and releases the xa_lock. | |
| 623 | − * May sleep if the @gfp flags permit. | |
| 665 | + * Context: Any context. Takes and releases the xa_lock. May sleep if | |
| 666 | + * the @gfp flags permit. | |
| 624 | 667 | * Return: 0 if the store succeeded. -EEXIST if another entry was present. |
| 625 | 668 | * -ENOMEM if memory could not be allocated. |
| 626 | 669 | */ |
| 627 | 670 | static inline int xa_insert(struct xarray *xa, unsigned long index, |
| 628 | 671 | void *entry, gfp_t gfp) |
| 629 | 672 | { |
| 630 | − void *curr = xa_cmpxchg(xa, index, NULL, entry, gfp); | |
| 631 | − if (!curr) | |
| 632 | − return 0; | |
| 633 | − if (xa_is_err(curr)) | |
| 634 | − return xa_err(curr); | |
| 635 | − return -EEXIST; | |
| 673 | + int err; | |
| 674 | + | |
| 675 | + xa_lock(xa); | |
| 676 | + err = __xa_insert(xa, index, entry, gfp); | |
| 677 | + xa_unlock(xa); | |
| 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 | + */ | |
| 699 | +static 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 | + */ | |
| 728 | +static 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 | 1072 | (entry < xa_mk_sibling(XA_CHUNK_SIZE - 1)); |
| 971 | 1073 | } |
| 972 | 1074 | |
| 973 | −#define XA_ZERO_ENTRY xa_mk_internal(256) | |
| 974 | −#define XA_RETRY_ENTRY xa_mk_internal(257) | |
| 1075 | +#define XA_RETRY_ENTRY xa_mk_internal(256) | |
| 1076 | +#define XA_ZERO_ENTRY xa_mk_internal(257) | |
| 975 | 1077 | |
| 976 | 1078 | /** |
| 977 | 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 | 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 | + */ | |
| 1106 | +static inline bool xa_is_advanced(const void *entry) | |
| 1107 | +{ | |
| 1108 | + return xa_is_internal(entry) && (entry <= XA_RETRY_ENTRY); | |
| 1109 | +} | |
| 1110 | + | |
| 998 | 1111 | /** |
| 999 | 1112 | * typedef xa_update_node_t - A callback function from the XArray. |
| 1000 | 1113 | * @node: The node which is being processed |