Annotation of /trunk/kernel-alx-legacy/patches-4.9/0346-4.9.247-all-fixes.patch
Parent Directory | Revision Log
Revision 3648 -
(hide annotations)
(download)
Mon Oct 24 14:07:28 2022 UTC (23 months ago) by niro
File size: 56626 byte(s)
Mon Oct 24 14:07:28 2022 UTC (23 months ago) by niro
File size: 56626 byte(s)
-linux-4.9.247
1 | niro | 3648 | diff --git a/Makefile b/Makefile |
2 | index b9e2a97da5da7..82f71f9460cb6 100644 | ||
3 | --- a/Makefile | ||
4 | +++ b/Makefile | ||
5 | @@ -1,6 +1,6 @@ | ||
6 | VERSION = 4 | ||
7 | PATCHLEVEL = 9 | ||
8 | -SUBLEVEL = 246 | ||
9 | +SUBLEVEL = 247 | ||
10 | EXTRAVERSION = | ||
11 | NAME = Roaring Lionus | ||
12 | |||
13 | diff --git a/arch/arm64/include/asm/pgtable.h b/arch/arm64/include/asm/pgtable.h | ||
14 | index 199f434f99a49..60e92da7bf37b 100644 | ||
15 | --- a/arch/arm64/include/asm/pgtable.h | ||
16 | +++ b/arch/arm64/include/asm/pgtable.h | ||
17 | @@ -85,8 +85,6 @@ extern unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)]; | ||
18 | #define pte_valid(pte) (!!(pte_val(pte) & PTE_VALID)) | ||
19 | #define pte_valid_not_user(pte) \ | ||
20 | ((pte_val(pte) & (PTE_VALID | PTE_USER)) == PTE_VALID) | ||
21 | -#define pte_valid_young(pte) \ | ||
22 | - ((pte_val(pte) & (PTE_VALID | PTE_AF)) == (PTE_VALID | PTE_AF)) | ||
23 | #define pte_valid_user(pte) \ | ||
24 | ((pte_val(pte) & (PTE_VALID | PTE_USER)) == (PTE_VALID | PTE_USER)) | ||
25 | |||
26 | @@ -94,9 +92,12 @@ extern unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)]; | ||
27 | * Could the pte be present in the TLB? We must check mm_tlb_flush_pending | ||
28 | * so that we don't erroneously return false for pages that have been | ||
29 | * remapped as PROT_NONE but are yet to be flushed from the TLB. | ||
30 | + * Note that we can't make any assumptions based on the state of the access | ||
31 | + * flag, since ptep_clear_flush_young() elides a DSB when invalidating the | ||
32 | + * TLB. | ||
33 | */ | ||
34 | #define pte_accessible(mm, pte) \ | ||
35 | - (mm_tlb_flush_pending(mm) ? pte_present(pte) : pte_valid_young(pte)) | ||
36 | + (mm_tlb_flush_pending(mm) ? pte_present(pte) : pte_valid(pte)) | ||
37 | |||
38 | /* | ||
39 | * p??_access_permitted() is true for valid user mappings (subject to the | ||
40 | diff --git a/arch/x86/events/intel/cstate.c b/arch/x86/events/intel/cstate.c | ||
41 | index 72d09340c24d2..88ba013d08d49 100644 | ||
42 | --- a/arch/x86/events/intel/cstate.c | ||
43 | +++ b/arch/x86/events/intel/cstate.c | ||
44 | @@ -98,14 +98,14 @@ | ||
45 | MODULE_LICENSE("GPL"); | ||
46 | |||
47 | #define DEFINE_CSTATE_FORMAT_ATTR(_var, _name, _format) \ | ||
48 | -static ssize_t __cstate_##_var##_show(struct kobject *kobj, \ | ||
49 | - struct kobj_attribute *attr, \ | ||
50 | +static ssize_t __cstate_##_var##_show(struct device *dev, \ | ||
51 | + struct device_attribute *attr, \ | ||
52 | char *page) \ | ||
53 | { \ | ||
54 | BUILD_BUG_ON(sizeof(_format) >= PAGE_SIZE); \ | ||
55 | return sprintf(page, _format "\n"); \ | ||
56 | } \ | ||
57 | -static struct kobj_attribute format_attr_##_var = \ | ||
58 | +static struct device_attribute format_attr_##_var = \ | ||
59 | __ATTR(_name, 0444, __cstate_##_var##_show, NULL) | ||
60 | |||
61 | static ssize_t cstate_get_attr_cpumask(struct device *dev, | ||
62 | diff --git a/arch/x86/events/intel/rapl.c b/arch/x86/events/intel/rapl.c | ||
63 | index 4c1b7ea185415..38dae3d1391b5 100644 | ||
64 | --- a/arch/x86/events/intel/rapl.c | ||
65 | +++ b/arch/x86/events/intel/rapl.c | ||
66 | @@ -115,18 +115,6 @@ static const char *const rapl_domain_names[NR_RAPL_DOMAINS] __initconst = { | ||
67 | * any other bit is reserved | ||
68 | */ | ||
69 | #define RAPL_EVENT_MASK 0xFFULL | ||
70 | - | ||
71 | -#define DEFINE_RAPL_FORMAT_ATTR(_var, _name, _format) \ | ||
72 | -static ssize_t __rapl_##_var##_show(struct kobject *kobj, \ | ||
73 | - struct kobj_attribute *attr, \ | ||
74 | - char *page) \ | ||
75 | -{ \ | ||
76 | - BUILD_BUG_ON(sizeof(_format) >= PAGE_SIZE); \ | ||
77 | - return sprintf(page, _format "\n"); \ | ||
78 | -} \ | ||
79 | -static struct kobj_attribute format_attr_##_var = \ | ||
80 | - __ATTR(_name, 0444, __rapl_##_var##_show, NULL) | ||
81 | - | ||
82 | #define RAPL_CNTR_WIDTH 32 | ||
83 | |||
84 | #define RAPL_EVENT_ATTR_STR(_name, v, str) \ | ||
85 | @@ -548,7 +536,7 @@ static struct attribute_group rapl_pmu_events_group = { | ||
86 | .attrs = NULL, /* patched at runtime */ | ||
87 | }; | ||
88 | |||
89 | -DEFINE_RAPL_FORMAT_ATTR(event, event, "config:0-7"); | ||
90 | +PMU_FORMAT_ATTR(event, "config:0-7"); | ||
91 | static struct attribute *rapl_formats_attr[] = { | ||
92 | &format_attr_event.attr, | ||
93 | NULL, | ||
94 | diff --git a/arch/x86/events/intel/uncore.c b/arch/x86/events/intel/uncore.c | ||
95 | index 4f365267b12fe..9f572bf6c6216 100644 | ||
96 | --- a/arch/x86/events/intel/uncore.c | ||
97 | +++ b/arch/x86/events/intel/uncore.c | ||
98 | @@ -90,8 +90,8 @@ end: | ||
99 | return map; | ||
100 | } | ||
101 | |||
102 | -ssize_t uncore_event_show(struct kobject *kobj, | ||
103 | - struct kobj_attribute *attr, char *buf) | ||
104 | +ssize_t uncore_event_show(struct device *dev, | ||
105 | + struct device_attribute *attr, char *buf) | ||
106 | { | ||
107 | struct uncore_event_desc *event = | ||
108 | container_of(attr, struct uncore_event_desc, attr); | ||
109 | diff --git a/arch/x86/events/intel/uncore.h b/arch/x86/events/intel/uncore.h | ||
110 | index ad986c1e29bcc..f699783114ee3 100644 | ||
111 | --- a/arch/x86/events/intel/uncore.h | ||
112 | +++ b/arch/x86/events/intel/uncore.h | ||
113 | @@ -124,7 +124,7 @@ struct intel_uncore_box { | ||
114 | #define UNCORE_BOX_FLAG_CTL_OFFS8 1 /* event config registers are 8-byte apart */ | ||
115 | |||
116 | struct uncore_event_desc { | ||
117 | - struct kobj_attribute attr; | ||
118 | + struct device_attribute attr; | ||
119 | const char *config; | ||
120 | }; | ||
121 | |||
122 | @@ -136,8 +136,8 @@ struct pci2phy_map { | ||
123 | |||
124 | struct pci2phy_map *__find_pci2phy_map(int segment); | ||
125 | |||
126 | -ssize_t uncore_event_show(struct kobject *kobj, | ||
127 | - struct kobj_attribute *attr, char *buf); | ||
128 | +ssize_t uncore_event_show(struct device *dev, | ||
129 | + struct device_attribute *attr, char *buf); | ||
130 | |||
131 | #define INTEL_UNCORE_EVENT_DESC(_name, _config) \ | ||
132 | { \ | ||
133 | @@ -146,14 +146,14 @@ ssize_t uncore_event_show(struct kobject *kobj, | ||
134 | } | ||
135 | |||
136 | #define DEFINE_UNCORE_FORMAT_ATTR(_var, _name, _format) \ | ||
137 | -static ssize_t __uncore_##_var##_show(struct kobject *kobj, \ | ||
138 | - struct kobj_attribute *attr, \ | ||
139 | +static ssize_t __uncore_##_var##_show(struct device *dev, \ | ||
140 | + struct device_attribute *attr, \ | ||
141 | char *page) \ | ||
142 | { \ | ||
143 | BUILD_BUG_ON(sizeof(_format) >= PAGE_SIZE); \ | ||
144 | return sprintf(page, _format "\n"); \ | ||
145 | } \ | ||
146 | -static struct kobj_attribute format_attr_##_var = \ | ||
147 | +static struct device_attribute format_attr_##_var = \ | ||
148 | __ATTR(_name, 0444, __uncore_##_var##_show, NULL) | ||
149 | |||
150 | static inline unsigned uncore_pci_box_ctl(struct intel_uncore_box *box) | ||
151 | diff --git a/arch/x86/kernel/cpu/bugs.c b/arch/x86/kernel/cpu/bugs.c | ||
152 | index f8a7aba4b0959..a884bb7e7b01d 100644 | ||
153 | --- a/arch/x86/kernel/cpu/bugs.c | ||
154 | +++ b/arch/x86/kernel/cpu/bugs.c | ||
155 | @@ -732,11 +732,13 @@ spectre_v2_user_select_mitigation(enum spectre_v2_mitigation_cmd v2_cmd) | ||
156 | if (boot_cpu_has(X86_FEATURE_IBPB)) { | ||
157 | setup_force_cpu_cap(X86_FEATURE_USE_IBPB); | ||
158 | |||
159 | + spectre_v2_user_ibpb = mode; | ||
160 | switch (cmd) { | ||
161 | case SPECTRE_V2_USER_CMD_FORCE: | ||
162 | case SPECTRE_V2_USER_CMD_PRCTL_IBPB: | ||
163 | case SPECTRE_V2_USER_CMD_SECCOMP_IBPB: | ||
164 | static_branch_enable(&switch_mm_always_ibpb); | ||
165 | + spectre_v2_user_ibpb = SPECTRE_V2_USER_STRICT; | ||
166 | break; | ||
167 | case SPECTRE_V2_USER_CMD_PRCTL: | ||
168 | case SPECTRE_V2_USER_CMD_AUTO: | ||
169 | @@ -750,8 +752,6 @@ spectre_v2_user_select_mitigation(enum spectre_v2_mitigation_cmd v2_cmd) | ||
170 | pr_info("mitigation: Enabling %s Indirect Branch Prediction Barrier\n", | ||
171 | static_key_enabled(&switch_mm_always_ibpb) ? | ||
172 | "always-on" : "conditional"); | ||
173 | - | ||
174 | - spectre_v2_user_ibpb = mode; | ||
175 | } | ||
176 | |||
177 | /* | ||
178 | diff --git a/arch/x86/xen/spinlock.c b/arch/x86/xen/spinlock.c | ||
179 | index 8d2c6f071dccf..44bf8a22c97b8 100644 | ||
180 | --- a/arch/x86/xen/spinlock.c | ||
181 | +++ b/arch/x86/xen/spinlock.c | ||
182 | @@ -98,10 +98,20 @@ void xen_init_lock_cpu(int cpu) | ||
183 | |||
184 | void xen_uninit_lock_cpu(int cpu) | ||
185 | { | ||
186 | + int irq; | ||
187 | + | ||
188 | if (!xen_pvspin) | ||
189 | return; | ||
190 | |||
191 | - unbind_from_irqhandler(per_cpu(lock_kicker_irq, cpu), NULL); | ||
192 | + /* | ||
193 | + * When booting the kernel with 'mitigations=auto,nosmt', the secondary | ||
194 | + * CPUs are not activated, and lock_kicker_irq is not initialized. | ||
195 | + */ | ||
196 | + irq = per_cpu(lock_kicker_irq, cpu); | ||
197 | + if (irq == -1) | ||
198 | + return; | ||
199 | + | ||
200 | + unbind_from_irqhandler(irq, NULL); | ||
201 | per_cpu(lock_kicker_irq, cpu) = -1; | ||
202 | kfree(per_cpu(irq_name, cpu)); | ||
203 | per_cpu(irq_name, cpu) = NULL; | ||
204 | diff --git a/drivers/dma/pl330.c b/drivers/dma/pl330.c | ||
205 | index 16c08846ea0e1..f5a9bb1231882 100644 | ||
206 | --- a/drivers/dma/pl330.c | ||
207 | +++ b/drivers/dma/pl330.c | ||
208 | @@ -2682,7 +2682,7 @@ pl330_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dst, | ||
209 | * If burst size is smaller than bus width then make sure we only | ||
210 | * transfer one at a time to avoid a burst stradling an MFIFO entry. | ||
211 | */ | ||
212 | - if (desc->rqcfg.brst_size * 8 < pl330->pcfg.data_bus_width) | ||
213 | + if (burst * 8 < pl330->pcfg.data_bus_width) | ||
214 | desc->rqcfg.brst_len = 1; | ||
215 | |||
216 | desc->bytes_requested = len; | ||
217 | diff --git a/drivers/dma/xilinx/xilinx_dma.c b/drivers/dma/xilinx/xilinx_dma.c | ||
218 | index cd271f7826051..ef99ef0bb1ca2 100644 | ||
219 | --- a/drivers/dma/xilinx/xilinx_dma.c | ||
220 | +++ b/drivers/dma/xilinx/xilinx_dma.c | ||
221 | @@ -420,8 +420,8 @@ struct xilinx_dma_device { | ||
222 | #define to_dma_tx_descriptor(tx) \ | ||
223 | container_of(tx, struct xilinx_dma_tx_descriptor, async_tx) | ||
224 | #define xilinx_dma_poll_timeout(chan, reg, val, cond, delay_us, timeout_us) \ | ||
225 | - readl_poll_timeout(chan->xdev->regs + chan->ctrl_offset + reg, val, \ | ||
226 | - cond, delay_us, timeout_us) | ||
227 | + readl_poll_timeout_atomic(chan->xdev->regs + chan->ctrl_offset + reg, \ | ||
228 | + val, cond, delay_us, timeout_us) | ||
229 | |||
230 | /* IO accessors */ | ||
231 | static inline u32 dma_read(struct xilinx_dma_chan *chan, u32 reg) | ||
232 | diff --git a/drivers/hid/hid-cypress.c b/drivers/hid/hid-cypress.c | ||
233 | index 1689568b597d4..12c5d7c96527a 100644 | ||
234 | --- a/drivers/hid/hid-cypress.c | ||
235 | +++ b/drivers/hid/hid-cypress.c | ||
236 | @@ -26,19 +26,17 @@ | ||
237 | #define CP_2WHEEL_MOUSE_HACK 0x02 | ||
238 | #define CP_2WHEEL_MOUSE_HACK_ON 0x04 | ||
239 | |||
240 | +#define VA_INVAL_LOGICAL_BOUNDARY 0x08 | ||
241 | + | ||
242 | /* | ||
243 | * Some USB barcode readers from cypress have usage min and usage max in | ||
244 | * the wrong order | ||
245 | */ | ||
246 | -static __u8 *cp_report_fixup(struct hid_device *hdev, __u8 *rdesc, | ||
247 | +static __u8 *cp_rdesc_fixup(struct hid_device *hdev, __u8 *rdesc, | ||
248 | unsigned int *rsize) | ||
249 | { | ||
250 | - unsigned long quirks = (unsigned long)hid_get_drvdata(hdev); | ||
251 | unsigned int i; | ||
252 | |||
253 | - if (!(quirks & CP_RDESC_SWAPPED_MIN_MAX)) | ||
254 | - return rdesc; | ||
255 | - | ||
256 | if (*rsize < 4) | ||
257 | return rdesc; | ||
258 | |||
259 | @@ -51,6 +49,40 @@ static __u8 *cp_report_fixup(struct hid_device *hdev, __u8 *rdesc, | ||
260 | return rdesc; | ||
261 | } | ||
262 | |||
263 | +static __u8 *va_logical_boundary_fixup(struct hid_device *hdev, __u8 *rdesc, | ||
264 | + unsigned int *rsize) | ||
265 | +{ | ||
266 | + /* | ||
267 | + * Varmilo VA104M (with VID Cypress and device ID 07B1) incorrectly | ||
268 | + * reports Logical Minimum of its Consumer Control device as 572 | ||
269 | + * (0x02 0x3c). Fix this by setting its Logical Minimum to zero. | ||
270 | + */ | ||
271 | + if (*rsize == 25 && | ||
272 | + rdesc[0] == 0x05 && rdesc[1] == 0x0c && | ||
273 | + rdesc[2] == 0x09 && rdesc[3] == 0x01 && | ||
274 | + rdesc[6] == 0x19 && rdesc[7] == 0x00 && | ||
275 | + rdesc[11] == 0x16 && rdesc[12] == 0x3c && rdesc[13] == 0x02) { | ||
276 | + hid_info(hdev, | ||
277 | + "fixing up varmilo VA104M consumer control report descriptor\n"); | ||
278 | + rdesc[12] = 0x00; | ||
279 | + rdesc[13] = 0x00; | ||
280 | + } | ||
281 | + return rdesc; | ||
282 | +} | ||
283 | + | ||
284 | +static __u8 *cp_report_fixup(struct hid_device *hdev, __u8 *rdesc, | ||
285 | + unsigned int *rsize) | ||
286 | +{ | ||
287 | + unsigned long quirks = (unsigned long)hid_get_drvdata(hdev); | ||
288 | + | ||
289 | + if (quirks & CP_RDESC_SWAPPED_MIN_MAX) | ||
290 | + rdesc = cp_rdesc_fixup(hdev, rdesc, rsize); | ||
291 | + if (quirks & VA_INVAL_LOGICAL_BOUNDARY) | ||
292 | + rdesc = va_logical_boundary_fixup(hdev, rdesc, rsize); | ||
293 | + | ||
294 | + return rdesc; | ||
295 | +} | ||
296 | + | ||
297 | static int cp_input_mapped(struct hid_device *hdev, struct hid_input *hi, | ||
298 | struct hid_field *field, struct hid_usage *usage, | ||
299 | unsigned long **bit, int *max) | ||
300 | @@ -131,6 +163,8 @@ static const struct hid_device_id cp_devices[] = { | ||
301 | .driver_data = CP_RDESC_SWAPPED_MIN_MAX }, | ||
302 | { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE), | ||
303 | .driver_data = CP_2WHEEL_MOUSE_HACK }, | ||
304 | + { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_VARMILO_VA104M_07B1), | ||
305 | + .driver_data = VA_INVAL_LOGICAL_BOUNDARY }, | ||
306 | { } | ||
307 | }; | ||
308 | MODULE_DEVICE_TABLE(hid, cp_devices); | ||
309 | diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h | ||
310 | index 4630b58634d87..c4a53fc648e95 100644 | ||
311 | --- a/drivers/hid/hid-ids.h | ||
312 | +++ b/drivers/hid/hid-ids.h | ||
313 | @@ -307,6 +307,8 @@ | ||
314 | #define USB_DEVICE_ID_CYPRESS_BARCODE_4 0xed81 | ||
315 | #define USB_DEVICE_ID_CYPRESS_TRUETOUCH 0xc001 | ||
316 | |||
317 | +#define USB_DEVICE_ID_CYPRESS_VARMILO_VA104M_07B1 0X07b1 | ||
318 | + | ||
319 | #define USB_VENDOR_ID_DATA_MODUL 0x7374 | ||
320 | #define USB_VENDOR_ID_DATA_MODUL_EASYMAXTOUCH 0x1201 | ||
321 | |||
322 | diff --git a/drivers/hid/hid-sensor-hub.c b/drivers/hid/hid-sensor-hub.c | ||
323 | index 4ef73374a8f98..7001f07ca3996 100644 | ||
324 | --- a/drivers/hid/hid-sensor-hub.c | ||
325 | +++ b/drivers/hid/hid-sensor-hub.c | ||
326 | @@ -489,7 +489,8 @@ static int sensor_hub_raw_event(struct hid_device *hdev, | ||
327 | return 1; | ||
328 | |||
329 | ptr = raw_data; | ||
330 | - ptr++; /* Skip report id */ | ||
331 | + if (report->id) | ||
332 | + ptr++; /* Skip report id */ | ||
333 | |||
334 | spin_lock_irqsave(&pdata->lock, flags); | ||
335 | |||
336 | diff --git a/drivers/infiniband/hw/mthca/mthca_cq.c b/drivers/infiniband/hw/mthca/mthca_cq.c | ||
337 | index a6531ffe29a6f..a5694dec3f2ee 100644 | ||
338 | --- a/drivers/infiniband/hw/mthca/mthca_cq.c | ||
339 | +++ b/drivers/infiniband/hw/mthca/mthca_cq.c | ||
340 | @@ -808,8 +808,10 @@ int mthca_init_cq(struct mthca_dev *dev, int nent, | ||
341 | } | ||
342 | |||
343 | mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL); | ||
344 | - if (IS_ERR(mailbox)) | ||
345 | + if (IS_ERR(mailbox)) { | ||
346 | + err = PTR_ERR(mailbox); | ||
347 | goto err_out_arm; | ||
348 | + } | ||
349 | |||
350 | cq_context = mailbox->buf; | ||
351 | |||
352 | @@ -851,9 +853,9 @@ int mthca_init_cq(struct mthca_dev *dev, int nent, | ||
353 | } | ||
354 | |||
355 | spin_lock_irq(&dev->cq_table.lock); | ||
356 | - if (mthca_array_set(&dev->cq_table.cq, | ||
357 | - cq->cqn & (dev->limits.num_cqs - 1), | ||
358 | - cq)) { | ||
359 | + err = mthca_array_set(&dev->cq_table.cq, | ||
360 | + cq->cqn & (dev->limits.num_cqs - 1), cq); | ||
361 | + if (err) { | ||
362 | spin_unlock_irq(&dev->cq_table.lock); | ||
363 | goto err_out_free_mr; | ||
364 | } | ||
365 | diff --git a/drivers/input/serio/i8042.c b/drivers/input/serio/i8042.c | ||
366 | index c84c685056b99..6b648339733fa 100644 | ||
367 | --- a/drivers/input/serio/i8042.c | ||
368 | +++ b/drivers/input/serio/i8042.c | ||
369 | @@ -125,6 +125,7 @@ module_param_named(unmask_kbd_data, i8042_unmask_kbd_data, bool, 0600); | ||
370 | MODULE_PARM_DESC(unmask_kbd_data, "Unconditional enable (may reveal sensitive data) of normally sanitize-filtered kbd data traffic debug log [pre-condition: i8042.debug=1 enabled]"); | ||
371 | #endif | ||
372 | |||
373 | +static bool i8042_present; | ||
374 | static bool i8042_bypass_aux_irq_test; | ||
375 | static char i8042_kbd_firmware_id[128]; | ||
376 | static char i8042_aux_firmware_id[128]; | ||
377 | @@ -343,6 +344,9 @@ int i8042_command(unsigned char *param, int command) | ||
378 | unsigned long flags; | ||
379 | int retval; | ||
380 | |||
381 | + if (!i8042_present) | ||
382 | + return -1; | ||
383 | + | ||
384 | spin_lock_irqsave(&i8042_lock, flags); | ||
385 | retval = __i8042_command(param, command); | ||
386 | spin_unlock_irqrestore(&i8042_lock, flags); | ||
387 | @@ -1597,12 +1601,15 @@ static int __init i8042_init(void) | ||
388 | |||
389 | err = i8042_platform_init(); | ||
390 | if (err) | ||
391 | - return err; | ||
392 | + return (err == -ENODEV) ? 0 : err; | ||
393 | |||
394 | err = i8042_controller_check(); | ||
395 | if (err) | ||
396 | goto err_platform_exit; | ||
397 | |||
398 | + /* Set this before creating the dev to allow i8042_command to work right away */ | ||
399 | + i8042_present = true; | ||
400 | + | ||
401 | pdev = platform_create_bundle(&i8042_driver, i8042_probe, NULL, 0, NULL, 0); | ||
402 | if (IS_ERR(pdev)) { | ||
403 | err = PTR_ERR(pdev); | ||
404 | @@ -1621,6 +1628,9 @@ static int __init i8042_init(void) | ||
405 | |||
406 | static void __exit i8042_exit(void) | ||
407 | { | ||
408 | + if (!i8042_present) | ||
409 | + return; | ||
410 | + | ||
411 | platform_device_unregister(i8042_platform_device); | ||
412 | platform_driver_unregister(&i8042_driver); | ||
413 | i8042_platform_exit(); | ||
414 | diff --git a/drivers/net/can/usb/gs_usb.c b/drivers/net/can/usb/gs_usb.c | ||
415 | index a65203e6ea5f4..d21c68882e867 100644 | ||
416 | --- a/drivers/net/can/usb/gs_usb.c | ||
417 | +++ b/drivers/net/can/usb/gs_usb.c | ||
418 | @@ -71,21 +71,27 @@ enum gs_can_identify_mode { | ||
419 | }; | ||
420 | |||
421 | /* data types passed between host and device */ | ||
422 | + | ||
423 | +/* The firmware on the original USB2CAN by Geschwister Schneider | ||
424 | + * Technologie Entwicklungs- und Vertriebs UG exchanges all data | ||
425 | + * between the host and the device in host byte order. This is done | ||
426 | + * with the struct gs_host_config::byte_order member, which is sent | ||
427 | + * first to indicate the desired byte order. | ||
428 | + * | ||
429 | + * The widely used open source firmware candleLight doesn't support | ||
430 | + * this feature and exchanges the data in little endian byte order. | ||
431 | + */ | ||
432 | struct gs_host_config { | ||
433 | - u32 byte_order; | ||
434 | + __le32 byte_order; | ||
435 | } __packed; | ||
436 | -/* All data exchanged between host and device is exchanged in host byte order, | ||
437 | - * thanks to the struct gs_host_config byte_order member, which is sent first | ||
438 | - * to indicate the desired byte order. | ||
439 | - */ | ||
440 | |||
441 | struct gs_device_config { | ||
442 | u8 reserved1; | ||
443 | u8 reserved2; | ||
444 | u8 reserved3; | ||
445 | u8 icount; | ||
446 | - u32 sw_version; | ||
447 | - u32 hw_version; | ||
448 | + __le32 sw_version; | ||
449 | + __le32 hw_version; | ||
450 | } __packed; | ||
451 | |||
452 | #define GS_CAN_MODE_NORMAL 0 | ||
453 | @@ -95,26 +101,26 @@ struct gs_device_config { | ||
454 | #define GS_CAN_MODE_ONE_SHOT BIT(3) | ||
455 | |||
456 | struct gs_device_mode { | ||
457 | - u32 mode; | ||
458 | - u32 flags; | ||
459 | + __le32 mode; | ||
460 | + __le32 flags; | ||
461 | } __packed; | ||
462 | |||
463 | struct gs_device_state { | ||
464 | - u32 state; | ||
465 | - u32 rxerr; | ||
466 | - u32 txerr; | ||
467 | + __le32 state; | ||
468 | + __le32 rxerr; | ||
469 | + __le32 txerr; | ||
470 | } __packed; | ||
471 | |||
472 | struct gs_device_bittiming { | ||
473 | - u32 prop_seg; | ||
474 | - u32 phase_seg1; | ||
475 | - u32 phase_seg2; | ||
476 | - u32 sjw; | ||
477 | - u32 brp; | ||
478 | + __le32 prop_seg; | ||
479 | + __le32 phase_seg1; | ||
480 | + __le32 phase_seg2; | ||
481 | + __le32 sjw; | ||
482 | + __le32 brp; | ||
483 | } __packed; | ||
484 | |||
485 | struct gs_identify_mode { | ||
486 | - u32 mode; | ||
487 | + __le32 mode; | ||
488 | } __packed; | ||
489 | |||
490 | #define GS_CAN_FEATURE_LISTEN_ONLY BIT(0) | ||
491 | @@ -125,23 +131,23 @@ struct gs_identify_mode { | ||
492 | #define GS_CAN_FEATURE_IDENTIFY BIT(5) | ||
493 | |||
494 | struct gs_device_bt_const { | ||
495 | - u32 feature; | ||
496 | - u32 fclk_can; | ||
497 | - u32 tseg1_min; | ||
498 | - u32 tseg1_max; | ||
499 | - u32 tseg2_min; | ||
500 | - u32 tseg2_max; | ||
501 | - u32 sjw_max; | ||
502 | - u32 brp_min; | ||
503 | - u32 brp_max; | ||
504 | - u32 brp_inc; | ||
505 | + __le32 feature; | ||
506 | + __le32 fclk_can; | ||
507 | + __le32 tseg1_min; | ||
508 | + __le32 tseg1_max; | ||
509 | + __le32 tseg2_min; | ||
510 | + __le32 tseg2_max; | ||
511 | + __le32 sjw_max; | ||
512 | + __le32 brp_min; | ||
513 | + __le32 brp_max; | ||
514 | + __le32 brp_inc; | ||
515 | } __packed; | ||
516 | |||
517 | #define GS_CAN_FLAG_OVERFLOW 1 | ||
518 | |||
519 | struct gs_host_frame { | ||
520 | u32 echo_id; | ||
521 | - u32 can_id; | ||
522 | + __le32 can_id; | ||
523 | |||
524 | u8 can_dlc; | ||
525 | u8 channel; | ||
526 | @@ -337,13 +343,13 @@ static void gs_usb_receive_bulk_callback(struct urb *urb) | ||
527 | if (!skb) | ||
528 | return; | ||
529 | |||
530 | - cf->can_id = hf->can_id; | ||
531 | + cf->can_id = le32_to_cpu(hf->can_id); | ||
532 | |||
533 | cf->can_dlc = get_can_dlc(hf->can_dlc); | ||
534 | memcpy(cf->data, hf->data, 8); | ||
535 | |||
536 | /* ERROR frames tell us information about the controller */ | ||
537 | - if (hf->can_id & CAN_ERR_FLAG) | ||
538 | + if (le32_to_cpu(hf->can_id) & CAN_ERR_FLAG) | ||
539 | gs_update_state(dev, cf); | ||
540 | |||
541 | netdev->stats.rx_packets++; | ||
542 | @@ -426,11 +432,11 @@ static int gs_usb_set_bittiming(struct net_device *netdev) | ||
543 | if (!dbt) | ||
544 | return -ENOMEM; | ||
545 | |||
546 | - dbt->prop_seg = bt->prop_seg; | ||
547 | - dbt->phase_seg1 = bt->phase_seg1; | ||
548 | - dbt->phase_seg2 = bt->phase_seg2; | ||
549 | - dbt->sjw = bt->sjw; | ||
550 | - dbt->brp = bt->brp; | ||
551 | + dbt->prop_seg = cpu_to_le32(bt->prop_seg); | ||
552 | + dbt->phase_seg1 = cpu_to_le32(bt->phase_seg1); | ||
553 | + dbt->phase_seg2 = cpu_to_le32(bt->phase_seg2); | ||
554 | + dbt->sjw = cpu_to_le32(bt->sjw); | ||
555 | + dbt->brp = cpu_to_le32(bt->brp); | ||
556 | |||
557 | /* request bit timings */ | ||
558 | rc = usb_control_msg(interface_to_usbdev(intf), | ||
559 | @@ -511,7 +517,7 @@ static netdev_tx_t gs_can_start_xmit(struct sk_buff *skb, | ||
560 | |||
561 | cf = (struct can_frame *)skb->data; | ||
562 | |||
563 | - hf->can_id = cf->can_id; | ||
564 | + hf->can_id = cpu_to_le32(cf->can_id); | ||
565 | hf->can_dlc = cf->can_dlc; | ||
566 | memcpy(hf->data, cf->data, cf->can_dlc); | ||
567 | |||
568 | @@ -582,6 +588,7 @@ static int gs_can_open(struct net_device *netdev) | ||
569 | int rc, i; | ||
570 | struct gs_device_mode *dm; | ||
571 | u32 ctrlmode; | ||
572 | + u32 flags = 0; | ||
573 | |||
574 | rc = open_candev(netdev); | ||
575 | if (rc) | ||
576 | @@ -649,24 +656,24 @@ static int gs_can_open(struct net_device *netdev) | ||
577 | |||
578 | /* flags */ | ||
579 | ctrlmode = dev->can.ctrlmode; | ||
580 | - dm->flags = 0; | ||
581 | |||
582 | if (ctrlmode & CAN_CTRLMODE_LOOPBACK) | ||
583 | - dm->flags |= GS_CAN_MODE_LOOP_BACK; | ||
584 | + flags |= GS_CAN_MODE_LOOP_BACK; | ||
585 | else if (ctrlmode & CAN_CTRLMODE_LISTENONLY) | ||
586 | - dm->flags |= GS_CAN_MODE_LISTEN_ONLY; | ||
587 | + flags |= GS_CAN_MODE_LISTEN_ONLY; | ||
588 | |||
589 | /* Controller is not allowed to retry TX | ||
590 | * this mode is unavailable on atmels uc3c hardware | ||
591 | */ | ||
592 | if (ctrlmode & CAN_CTRLMODE_ONE_SHOT) | ||
593 | - dm->flags |= GS_CAN_MODE_ONE_SHOT; | ||
594 | + flags |= GS_CAN_MODE_ONE_SHOT; | ||
595 | |||
596 | if (ctrlmode & CAN_CTRLMODE_3_SAMPLES) | ||
597 | - dm->flags |= GS_CAN_MODE_TRIPLE_SAMPLE; | ||
598 | + flags |= GS_CAN_MODE_TRIPLE_SAMPLE; | ||
599 | |||
600 | /* finally start device */ | ||
601 | - dm->mode = GS_CAN_MODE_START; | ||
602 | + dm->mode = cpu_to_le32(GS_CAN_MODE_START); | ||
603 | + dm->flags = cpu_to_le32(flags); | ||
604 | rc = usb_control_msg(interface_to_usbdev(dev->iface), | ||
605 | usb_sndctrlpipe(interface_to_usbdev(dev->iface), 0), | ||
606 | GS_USB_BREQ_MODE, | ||
607 | @@ -746,9 +753,9 @@ static int gs_usb_set_identify(struct net_device *netdev, bool do_identify) | ||
608 | return -ENOMEM; | ||
609 | |||
610 | if (do_identify) | ||
611 | - imode->mode = GS_CAN_IDENTIFY_ON; | ||
612 | + imode->mode = cpu_to_le32(GS_CAN_IDENTIFY_ON); | ||
613 | else | ||
614 | - imode->mode = GS_CAN_IDENTIFY_OFF; | ||
615 | + imode->mode = cpu_to_le32(GS_CAN_IDENTIFY_OFF); | ||
616 | |||
617 | rc = usb_control_msg(interface_to_usbdev(dev->iface), | ||
618 | usb_sndctrlpipe(interface_to_usbdev(dev->iface), | ||
619 | @@ -799,6 +806,7 @@ static struct gs_can *gs_make_candev(unsigned int channel, | ||
620 | struct net_device *netdev; | ||
621 | int rc; | ||
622 | struct gs_device_bt_const *bt_const; | ||
623 | + u32 feature; | ||
624 | |||
625 | bt_const = kmalloc(sizeof(*bt_const), GFP_KERNEL); | ||
626 | if (!bt_const) | ||
627 | @@ -839,14 +847,14 @@ static struct gs_can *gs_make_candev(unsigned int channel, | ||
628 | |||
629 | /* dev settup */ | ||
630 | strcpy(dev->bt_const.name, "gs_usb"); | ||
631 | - dev->bt_const.tseg1_min = bt_const->tseg1_min; | ||
632 | - dev->bt_const.tseg1_max = bt_const->tseg1_max; | ||
633 | - dev->bt_const.tseg2_min = bt_const->tseg2_min; | ||
634 | - dev->bt_const.tseg2_max = bt_const->tseg2_max; | ||
635 | - dev->bt_const.sjw_max = bt_const->sjw_max; | ||
636 | - dev->bt_const.brp_min = bt_const->brp_min; | ||
637 | - dev->bt_const.brp_max = bt_const->brp_max; | ||
638 | - dev->bt_const.brp_inc = bt_const->brp_inc; | ||
639 | + dev->bt_const.tseg1_min = le32_to_cpu(bt_const->tseg1_min); | ||
640 | + dev->bt_const.tseg1_max = le32_to_cpu(bt_const->tseg1_max); | ||
641 | + dev->bt_const.tseg2_min = le32_to_cpu(bt_const->tseg2_min); | ||
642 | + dev->bt_const.tseg2_max = le32_to_cpu(bt_const->tseg2_max); | ||
643 | + dev->bt_const.sjw_max = le32_to_cpu(bt_const->sjw_max); | ||
644 | + dev->bt_const.brp_min = le32_to_cpu(bt_const->brp_min); | ||
645 | + dev->bt_const.brp_max = le32_to_cpu(bt_const->brp_max); | ||
646 | + dev->bt_const.brp_inc = le32_to_cpu(bt_const->brp_inc); | ||
647 | |||
648 | dev->udev = interface_to_usbdev(intf); | ||
649 | dev->iface = intf; | ||
650 | @@ -863,28 +871,29 @@ static struct gs_can *gs_make_candev(unsigned int channel, | ||
651 | |||
652 | /* can settup */ | ||
653 | dev->can.state = CAN_STATE_STOPPED; | ||
654 | - dev->can.clock.freq = bt_const->fclk_can; | ||
655 | + dev->can.clock.freq = le32_to_cpu(bt_const->fclk_can); | ||
656 | dev->can.bittiming_const = &dev->bt_const; | ||
657 | dev->can.do_set_bittiming = gs_usb_set_bittiming; | ||
658 | |||
659 | dev->can.ctrlmode_supported = 0; | ||
660 | |||
661 | - if (bt_const->feature & GS_CAN_FEATURE_LISTEN_ONLY) | ||
662 | + feature = le32_to_cpu(bt_const->feature); | ||
663 | + if (feature & GS_CAN_FEATURE_LISTEN_ONLY) | ||
664 | dev->can.ctrlmode_supported |= CAN_CTRLMODE_LISTENONLY; | ||
665 | |||
666 | - if (bt_const->feature & GS_CAN_FEATURE_LOOP_BACK) | ||
667 | + if (feature & GS_CAN_FEATURE_LOOP_BACK) | ||
668 | dev->can.ctrlmode_supported |= CAN_CTRLMODE_LOOPBACK; | ||
669 | |||
670 | - if (bt_const->feature & GS_CAN_FEATURE_TRIPLE_SAMPLE) | ||
671 | + if (feature & GS_CAN_FEATURE_TRIPLE_SAMPLE) | ||
672 | dev->can.ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES; | ||
673 | |||
674 | - if (bt_const->feature & GS_CAN_FEATURE_ONE_SHOT) | ||
675 | + if (feature & GS_CAN_FEATURE_ONE_SHOT) | ||
676 | dev->can.ctrlmode_supported |= CAN_CTRLMODE_ONE_SHOT; | ||
677 | |||
678 | SET_NETDEV_DEV(netdev, &intf->dev); | ||
679 | |||
680 | - if (dconf->sw_version > 1) | ||
681 | - if (bt_const->feature & GS_CAN_FEATURE_IDENTIFY) | ||
682 | + if (le32_to_cpu(dconf->sw_version) > 1) | ||
683 | + if (feature & GS_CAN_FEATURE_IDENTIFY) | ||
684 | netdev->ethtool_ops = &gs_usb_ethtool_ops; | ||
685 | |||
686 | kfree(bt_const); | ||
687 | @@ -919,7 +928,7 @@ static int gs_usb_probe(struct usb_interface *intf, | ||
688 | if (!hconf) | ||
689 | return -ENOMEM; | ||
690 | |||
691 | - hconf->byte_order = 0x0000beef; | ||
692 | + hconf->byte_order = cpu_to_le32(0x0000beef); | ||
693 | |||
694 | /* send host config */ | ||
695 | rc = usb_control_msg(interface_to_usbdev(intf), | ||
696 | diff --git a/drivers/net/ethernet/amazon/ena/ena_netdev.c b/drivers/net/ethernet/amazon/ena/ena_netdev.c | ||
697 | index da21886609e30..de3d6f8b54316 100644 | ||
698 | --- a/drivers/net/ethernet/amazon/ena/ena_netdev.c | ||
699 | +++ b/drivers/net/ethernet/amazon/ena/ena_netdev.c | ||
700 | @@ -2345,16 +2345,9 @@ static int ena_device_init(struct ena_com_dev *ena_dev, struct pci_dev *pdev, | ||
701 | goto err_mmio_read_less; | ||
702 | } | ||
703 | |||
704 | - rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(dma_width)); | ||
705 | + rc = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(dma_width)); | ||
706 | if (rc) { | ||
707 | - dev_err(dev, "pci_set_dma_mask failed 0x%x\n", rc); | ||
708 | - goto err_mmio_read_less; | ||
709 | - } | ||
710 | - | ||
711 | - rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(dma_width)); | ||
712 | - if (rc) { | ||
713 | - dev_err(dev, "err_pci_set_consistent_dma_mask failed 0x%x\n", | ||
714 | - rc); | ||
715 | + dev_err(dev, "dma_set_mask_and_coherent failed %d\n", rc); | ||
716 | goto err_mmio_read_less; | ||
717 | } | ||
718 | |||
719 | @@ -2894,6 +2887,12 @@ static int ena_probe(struct pci_dev *pdev, const struct pci_device_id *ent) | ||
720 | return rc; | ||
721 | } | ||
722 | |||
723 | + rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(ENA_MAX_PHYS_ADDR_SIZE_BITS)); | ||
724 | + if (rc) { | ||
725 | + dev_err(&pdev->dev, "dma_set_mask_and_coherent failed %d\n", rc); | ||
726 | + goto err_disable_device; | ||
727 | + } | ||
728 | + | ||
729 | pci_set_master(pdev); | ||
730 | |||
731 | ena_dev = vzalloc(sizeof(*ena_dev)); | ||
732 | diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.c b/drivers/net/ethernet/broadcom/bnxt/bnxt.c | ||
733 | index dc34cfa2a58fc..f9610f860e6d1 100644 | ||
734 | --- a/drivers/net/ethernet/broadcom/bnxt/bnxt.c | ||
735 | +++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.c | ||
736 | @@ -6319,7 +6319,8 @@ static int bnxt_init_board(struct pci_dev *pdev, struct net_device *dev) | ||
737 | if (dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64)) != 0 && | ||
738 | dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)) != 0) { | ||
739 | dev_err(&pdev->dev, "System does not support DMA, aborting\n"); | ||
740 | - goto init_err_disable; | ||
741 | + rc = -EIO; | ||
742 | + goto init_err_release; | ||
743 | } | ||
744 | |||
745 | pci_set_master(pdev); | ||
746 | diff --git a/drivers/net/ethernet/ibm/ibmvnic.c b/drivers/net/ethernet/ibm/ibmvnic.c | ||
747 | index d25b76440c114..88c837504c7d6 100644 | ||
748 | --- a/drivers/net/ethernet/ibm/ibmvnic.c | ||
749 | +++ b/drivers/net/ethernet/ibm/ibmvnic.c | ||
750 | @@ -3525,6 +3525,9 @@ static int ibmvnic_reset_crq(struct ibmvnic_adapter *adapter) | ||
751 | } while (rc == H_BUSY || H_IS_LONG_BUSY(rc)); | ||
752 | |||
753 | /* Clean out the queue */ | ||
754 | + if (!crq->msgs) | ||
755 | + return -EINVAL; | ||
756 | + | ||
757 | memset(crq->msgs, 0, PAGE_SIZE); | ||
758 | crq->cur = 0; | ||
759 | |||
760 | diff --git a/drivers/nfc/s3fwrn5/i2c.c b/drivers/nfc/s3fwrn5/i2c.c | ||
761 | index 3ed0adf6479b0..5b0c065bd279f 100644 | ||
762 | --- a/drivers/nfc/s3fwrn5/i2c.c | ||
763 | +++ b/drivers/nfc/s3fwrn5/i2c.c | ||
764 | @@ -37,8 +37,8 @@ struct s3fwrn5_i2c_phy { | ||
765 | struct i2c_client *i2c_dev; | ||
766 | struct nci_dev *ndev; | ||
767 | |||
768 | - unsigned int gpio_en; | ||
769 | - unsigned int gpio_fw_wake; | ||
770 | + int gpio_en; | ||
771 | + int gpio_fw_wake; | ||
772 | |||
773 | struct mutex mutex; | ||
774 | |||
775 | diff --git a/drivers/pci/bus.c b/drivers/pci/bus.c | ||
776 | index c288e5a525754..32001787cff3f 100644 | ||
777 | --- a/drivers/pci/bus.c | ||
778 | +++ b/drivers/pci/bus.c | ||
779 | @@ -324,12 +324,8 @@ void pci_bus_add_device(struct pci_dev *dev) | ||
780 | |||
781 | dev->match_driver = true; | ||
782 | retval = device_attach(&dev->dev); | ||
783 | - if (retval < 0 && retval != -EPROBE_DEFER) { | ||
784 | + if (retval < 0 && retval != -EPROBE_DEFER) | ||
785 | dev_warn(&dev->dev, "device attach failed (%d)\n", retval); | ||
786 | - pci_proc_detach_device(dev); | ||
787 | - pci_remove_sysfs_dev_files(dev); | ||
788 | - return; | ||
789 | - } | ||
790 | |||
791 | dev->is_added = 1; | ||
792 | } | ||
793 | diff --git a/drivers/phy/tegra/xusb.c b/drivers/phy/tegra/xusb.c | ||
794 | index bd0e659002161..0156134dd022d 100644 | ||
795 | --- a/drivers/phy/tegra/xusb.c | ||
796 | +++ b/drivers/phy/tegra/xusb.c | ||
797 | @@ -916,6 +916,7 @@ remove_pads: | ||
798 | reset: | ||
799 | reset_control_assert(padctl->rst); | ||
800 | remove: | ||
801 | + platform_set_drvdata(pdev, NULL); | ||
802 | soc->ops->remove(padctl); | ||
803 | return err; | ||
804 | } | ||
805 | diff --git a/drivers/platform/x86/toshiba_acpi.c b/drivers/platform/x86/toshiba_acpi.c | ||
806 | index 79a2289370729..f25278bb3e1a8 100644 | ||
807 | --- a/drivers/platform/x86/toshiba_acpi.c | ||
808 | +++ b/drivers/platform/x86/toshiba_acpi.c | ||
809 | @@ -1497,7 +1497,7 @@ static ssize_t video_proc_write(struct file *file, const char __user *buf, | ||
810 | struct toshiba_acpi_dev *dev = PDE_DATA(file_inode(file)); | ||
811 | char *buffer; | ||
812 | char *cmd; | ||
813 | - int lcd_out, crt_out, tv_out; | ||
814 | + int lcd_out = -1, crt_out = -1, tv_out = -1; | ||
815 | int remain = count; | ||
816 | int value; | ||
817 | int ret; | ||
818 | @@ -1534,7 +1534,6 @@ static ssize_t video_proc_write(struct file *file, const char __user *buf, | ||
819 | |||
820 | kfree(cmd); | ||
821 | |||
822 | - lcd_out = crt_out = tv_out = -1; | ||
823 | ret = get_video_status(dev, &video_out); | ||
824 | if (!ret) { | ||
825 | unsigned int new_video_out = video_out; | ||
826 | diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c | ||
827 | index 0a0dd0aac047c..23323add5b0b1 100644 | ||
828 | --- a/drivers/regulator/core.c | ||
829 | +++ b/drivers/regulator/core.c | ||
830 | @@ -1550,6 +1550,15 @@ static int regulator_resolve_supply(struct regulator_dev *rdev) | ||
831 | } | ||
832 | } | ||
833 | |||
834 | + if (r == rdev) { | ||
835 | + dev_err(dev, "Supply for %s (%s) resolved to itself\n", | ||
836 | + rdev->desc->name, rdev->supply_name); | ||
837 | + if (!have_full_constraints()) | ||
838 | + return -EINVAL; | ||
839 | + r = dummy_regulator_rdev; | ||
840 | + get_device(&r->dev); | ||
841 | + } | ||
842 | + | ||
843 | /* Recursively resolve the supply of the supply */ | ||
844 | ret = regulator_resolve_supply(r); | ||
845 | if (ret < 0) { | ||
846 | diff --git a/drivers/scsi/libiscsi.c b/drivers/scsi/libiscsi.c | ||
847 | index c4336b01db23c..a84b473d4a08b 100644 | ||
848 | --- a/drivers/scsi/libiscsi.c | ||
849 | +++ b/drivers/scsi/libiscsi.c | ||
850 | @@ -570,8 +570,8 @@ static void iscsi_complete_task(struct iscsi_task *task, int state) | ||
851 | if (conn->task == task) | ||
852 | conn->task = NULL; | ||
853 | |||
854 | - if (conn->ping_task == task) | ||
855 | - conn->ping_task = NULL; | ||
856 | + if (READ_ONCE(conn->ping_task) == task) | ||
857 | + WRITE_ONCE(conn->ping_task, NULL); | ||
858 | |||
859 | /* release get from queueing */ | ||
860 | __iscsi_put_task(task); | ||
861 | @@ -780,6 +780,9 @@ __iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, | ||
862 | task->conn->session->age); | ||
863 | } | ||
864 | |||
865 | + if (unlikely(READ_ONCE(conn->ping_task) == INVALID_SCSI_TASK)) | ||
866 | + WRITE_ONCE(conn->ping_task, task); | ||
867 | + | ||
868 | if (!ihost->workq) { | ||
869 | if (iscsi_prep_mgmt_task(conn, task)) | ||
870 | goto free_task; | ||
871 | @@ -987,8 +990,11 @@ static int iscsi_send_nopout(struct iscsi_conn *conn, struct iscsi_nopin *rhdr) | ||
872 | struct iscsi_nopout hdr; | ||
873 | struct iscsi_task *task; | ||
874 | |||
875 | - if (!rhdr && conn->ping_task) | ||
876 | - return -EINVAL; | ||
877 | + if (!rhdr) { | ||
878 | + if (READ_ONCE(conn->ping_task)) | ||
879 | + return -EINVAL; | ||
880 | + WRITE_ONCE(conn->ping_task, INVALID_SCSI_TASK); | ||
881 | + } | ||
882 | |||
883 | memset(&hdr, 0, sizeof(struct iscsi_nopout)); | ||
884 | hdr.opcode = ISCSI_OP_NOOP_OUT | ISCSI_OP_IMMEDIATE; | ||
885 | @@ -1003,11 +1009,12 @@ static int iscsi_send_nopout(struct iscsi_conn *conn, struct iscsi_nopin *rhdr) | ||
886 | |||
887 | task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)&hdr, NULL, 0); | ||
888 | if (!task) { | ||
889 | + if (!rhdr) | ||
890 | + WRITE_ONCE(conn->ping_task, NULL); | ||
891 | iscsi_conn_printk(KERN_ERR, conn, "Could not send nopout\n"); | ||
892 | return -EIO; | ||
893 | } else if (!rhdr) { | ||
894 | /* only track our nops */ | ||
895 | - conn->ping_task = task; | ||
896 | conn->last_ping = jiffies; | ||
897 | } | ||
898 | |||
899 | @@ -1020,7 +1027,7 @@ static int iscsi_nop_out_rsp(struct iscsi_task *task, | ||
900 | struct iscsi_conn *conn = task->conn; | ||
901 | int rc = 0; | ||
902 | |||
903 | - if (conn->ping_task != task) { | ||
904 | + if (READ_ONCE(conn->ping_task) != task) { | ||
905 | /* | ||
906 | * If this is not in response to one of our | ||
907 | * nops then it must be from userspace. | ||
908 | @@ -1960,7 +1967,7 @@ static void iscsi_start_tx(struct iscsi_conn *conn) | ||
909 | */ | ||
910 | static int iscsi_has_ping_timed_out(struct iscsi_conn *conn) | ||
911 | { | ||
912 | - if (conn->ping_task && | ||
913 | + if (READ_ONCE(conn->ping_task) && | ||
914 | time_before_eq(conn->last_recv + (conn->recv_timeout * HZ) + | ||
915 | (conn->ping_timeout * HZ), jiffies)) | ||
916 | return 1; | ||
917 | @@ -2095,7 +2102,7 @@ static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc) | ||
918 | * Checking the transport already or nop from a cmd timeout still | ||
919 | * running | ||
920 | */ | ||
921 | - if (conn->ping_task) { | ||
922 | + if (READ_ONCE(conn->ping_task)) { | ||
923 | task->have_checked_conn = true; | ||
924 | rc = BLK_EH_RESET_TIMER; | ||
925 | goto done; | ||
926 | diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c | ||
927 | index ad5f2e2b4cbaf..ad80e4223c2d3 100644 | ||
928 | --- a/drivers/scsi/ufs/ufshcd.c | ||
929 | +++ b/drivers/scsi/ufs/ufshcd.c | ||
930 | @@ -6521,11 +6521,7 @@ int ufshcd_shutdown(struct ufs_hba *hba) | ||
931 | if (ufshcd_is_ufs_dev_poweroff(hba) && ufshcd_is_link_off(hba)) | ||
932 | goto out; | ||
933 | |||
934 | - if (pm_runtime_suspended(hba->dev)) { | ||
935 | - ret = ufshcd_runtime_resume(hba); | ||
936 | - if (ret) | ||
937 | - goto out; | ||
938 | - } | ||
939 | + pm_runtime_get_sync(hba->dev); | ||
940 | |||
941 | ret = ufshcd_suspend(hba, UFS_SHUTDOWN_PM); | ||
942 | out: | ||
943 | diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c | ||
944 | index 7c0f4b96816a8..eba21f06a9b95 100644 | ||
945 | --- a/drivers/target/iscsi/iscsi_target.c | ||
946 | +++ b/drivers/target/iscsi/iscsi_target.c | ||
947 | @@ -493,8 +493,7 @@ void iscsit_aborted_task(struct iscsi_conn *conn, struct iscsi_cmd *cmd) | ||
948 | bool scsi_cmd = (cmd->iscsi_opcode == ISCSI_OP_SCSI_CMD); | ||
949 | |||
950 | spin_lock_bh(&conn->cmd_lock); | ||
951 | - if (!list_empty(&cmd->i_conn_node) && | ||
952 | - !(cmd->se_cmd.transport_state & CMD_T_FABRIC_STOP)) | ||
953 | + if (!list_empty(&cmd->i_conn_node)) | ||
954 | list_del_init(&cmd->i_conn_node); | ||
955 | spin_unlock_bh(&conn->cmd_lock); | ||
956 | |||
957 | @@ -4093,12 +4092,22 @@ static void iscsit_release_commands_from_conn(struct iscsi_conn *conn) | ||
958 | spin_lock_bh(&conn->cmd_lock); | ||
959 | list_splice_init(&conn->conn_cmd_list, &tmp_list); | ||
960 | |||
961 | - list_for_each_entry(cmd, &tmp_list, i_conn_node) { | ||
962 | + list_for_each_entry_safe(cmd, cmd_tmp, &tmp_list, i_conn_node) { | ||
963 | struct se_cmd *se_cmd = &cmd->se_cmd; | ||
964 | |||
965 | if (se_cmd->se_tfo != NULL) { | ||
966 | spin_lock_irq(&se_cmd->t_state_lock); | ||
967 | - se_cmd->transport_state |= CMD_T_FABRIC_STOP; | ||
968 | + if (se_cmd->transport_state & CMD_T_ABORTED) { | ||
969 | + /* | ||
970 | + * LIO's abort path owns the cleanup for this, | ||
971 | + * so put it back on the list and let | ||
972 | + * aborted_task handle it. | ||
973 | + */ | ||
974 | + list_move_tail(&cmd->i_conn_node, | ||
975 | + &conn->conn_cmd_list); | ||
976 | + } else { | ||
977 | + se_cmd->transport_state |= CMD_T_FABRIC_STOP; | ||
978 | + } | ||
979 | spin_unlock_irq(&se_cmd->t_state_lock); | ||
980 | } | ||
981 | } | ||
982 | diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c | ||
983 | index edf66b2f916b8..34081f03b1f56 100644 | ||
984 | --- a/drivers/usb/core/config.c | ||
985 | +++ b/drivers/usb/core/config.c | ||
986 | @@ -251,6 +251,7 @@ static int usb_parse_endpoint(struct device *ddev, int cfgno, | ||
987 | struct usb_host_interface *ifp, int num_ep, | ||
988 | unsigned char *buffer, int size) | ||
989 | { | ||
990 | + struct usb_device *udev = to_usb_device(ddev); | ||
991 | unsigned char *buffer0 = buffer; | ||
992 | struct usb_endpoint_descriptor *d; | ||
993 | struct usb_host_endpoint *endpoint; | ||
994 | @@ -292,6 +293,16 @@ static int usb_parse_endpoint(struct device *ddev, int cfgno, | ||
995 | goto skip_to_next_endpoint_or_interface_descriptor; | ||
996 | } | ||
997 | |||
998 | + /* Ignore blacklisted endpoints */ | ||
999 | + if (udev->quirks & USB_QUIRK_ENDPOINT_BLACKLIST) { | ||
1000 | + if (usb_endpoint_is_blacklisted(udev, ifp, d)) { | ||
1001 | + dev_warn(ddev, "config %d interface %d altsetting %d has a blacklisted endpoint with address 0x%X, skipping\n", | ||
1002 | + cfgno, inum, asnum, | ||
1003 | + d->bEndpointAddress); | ||
1004 | + goto skip_to_next_endpoint_or_interface_descriptor; | ||
1005 | + } | ||
1006 | + } | ||
1007 | + | ||
1008 | endpoint = &ifp->endpoint[ifp->desc.bNumEndpoints]; | ||
1009 | ++ifp->desc.bNumEndpoints; | ||
1010 | |||
1011 | diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c | ||
1012 | index 059e71d71b666..781db58004f7f 100644 | ||
1013 | --- a/drivers/usb/core/devio.c | ||
1014 | +++ b/drivers/usb/core/devio.c | ||
1015 | @@ -477,11 +477,11 @@ static void snoop_urb(struct usb_device *udev, | ||
1016 | |||
1017 | if (userurb) { /* Async */ | ||
1018 | if (when == SUBMIT) | ||
1019 | - dev_info(&udev->dev, "userurb %pK, ep%d %s-%s, " | ||
1020 | + dev_info(&udev->dev, "userurb %px, ep%d %s-%s, " | ||
1021 | "length %u\n", | ||
1022 | userurb, ep, t, d, length); | ||
1023 | else | ||
1024 | - dev_info(&udev->dev, "userurb %pK, ep%d %s-%s, " | ||
1025 | + dev_info(&udev->dev, "userurb %px, ep%d %s-%s, " | ||
1026 | "actual_length %u status %d\n", | ||
1027 | userurb, ep, t, d, length, | ||
1028 | timeout_or_status); | ||
1029 | @@ -1945,7 +1945,7 @@ static int proc_reapurb(struct usb_dev_state *ps, void __user *arg) | ||
1030 | if (as) { | ||
1031 | int retval; | ||
1032 | |||
1033 | - snoop(&ps->dev->dev, "reap %pK\n", as->userurb); | ||
1034 | + snoop(&ps->dev->dev, "reap %px\n", as->userurb); | ||
1035 | retval = processcompl(as, (void __user * __user *)arg); | ||
1036 | free_async(as); | ||
1037 | return retval; | ||
1038 | @@ -1962,7 +1962,7 @@ static int proc_reapurbnonblock(struct usb_dev_state *ps, void __user *arg) | ||
1039 | |||
1040 | as = async_getcompleted(ps); | ||
1041 | if (as) { | ||
1042 | - snoop(&ps->dev->dev, "reap %pK\n", as->userurb); | ||
1043 | + snoop(&ps->dev->dev, "reap %px\n", as->userurb); | ||
1044 | retval = processcompl(as, (void __user * __user *)arg); | ||
1045 | free_async(as); | ||
1046 | } else { | ||
1047 | @@ -2094,7 +2094,7 @@ static int proc_reapurb_compat(struct usb_dev_state *ps, void __user *arg) | ||
1048 | if (as) { | ||
1049 | int retval; | ||
1050 | |||
1051 | - snoop(&ps->dev->dev, "reap %pK\n", as->userurb); | ||
1052 | + snoop(&ps->dev->dev, "reap %px\n", as->userurb); | ||
1053 | retval = processcompl_compat(as, (void __user * __user *)arg); | ||
1054 | free_async(as); | ||
1055 | return retval; | ||
1056 | @@ -2111,7 +2111,7 @@ static int proc_reapurbnonblock_compat(struct usb_dev_state *ps, void __user *ar | ||
1057 | |||
1058 | as = async_getcompleted(ps); | ||
1059 | if (as) { | ||
1060 | - snoop(&ps->dev->dev, "reap %pK\n", as->userurb); | ||
1061 | + snoop(&ps->dev->dev, "reap %px\n", as->userurb); | ||
1062 | retval = processcompl_compat(as, (void __user * __user *)arg); | ||
1063 | free_async(as); | ||
1064 | } else { | ||
1065 | @@ -2540,7 +2540,7 @@ static long usbdev_do_ioctl(struct file *file, unsigned int cmd, | ||
1066 | #endif | ||
1067 | |||
1068 | case USBDEVFS_DISCARDURB: | ||
1069 | - snoop(&dev->dev, "%s: DISCARDURB %pK\n", __func__, p); | ||
1070 | + snoop(&dev->dev, "%s: DISCARDURB %px\n", __func__, p); | ||
1071 | ret = proc_unlinkurb(ps, p); | ||
1072 | break; | ||
1073 | |||
1074 | diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c | ||
1075 | index ca74b67c4450d..34d8cece6dd3b 100644 | ||
1076 | --- a/drivers/usb/core/quirks.c | ||
1077 | +++ b/drivers/usb/core/quirks.c | ||
1078 | @@ -195,6 +195,10 @@ static const struct usb_device_id usb_quirk_list[] = { | ||
1079 | /* Guillemot Webcam Hercules Dualpix Exchange*/ | ||
1080 | { USB_DEVICE(0x06f8, 0x3005), .driver_info = USB_QUIRK_RESET_RESUME }, | ||
1081 | |||
1082 | + /* Guillemot Hercules DJ Console audio card (BZ 208357) */ | ||
1083 | + { USB_DEVICE(0x06f8, 0xb000), .driver_info = | ||
1084 | + USB_QUIRK_ENDPOINT_BLACKLIST }, | ||
1085 | + | ||
1086 | /* Midiman M-Audio Keystation 88es */ | ||
1087 | { USB_DEVICE(0x0763, 0x0192), .driver_info = USB_QUIRK_RESET_RESUME }, | ||
1088 | |||
1089 | @@ -344,6 +348,40 @@ static const struct usb_device_id usb_amd_resume_quirk_list[] = { | ||
1090 | { } /* terminating entry must be last */ | ||
1091 | }; | ||
1092 | |||
1093 | +/* | ||
1094 | + * Entries for blacklisted endpoints that should be ignored when parsing | ||
1095 | + * configuration descriptors. | ||
1096 | + * | ||
1097 | + * Matched for devices with USB_QUIRK_ENDPOINT_BLACKLIST. | ||
1098 | + */ | ||
1099 | +static const struct usb_device_id usb_endpoint_blacklist[] = { | ||
1100 | + { USB_DEVICE_INTERFACE_NUMBER(0x06f8, 0xb000, 5), .driver_info = 0x01 }, | ||
1101 | + { USB_DEVICE_INTERFACE_NUMBER(0x06f8, 0xb000, 5), .driver_info = 0x81 }, | ||
1102 | + { } | ||
1103 | +}; | ||
1104 | + | ||
1105 | +bool usb_endpoint_is_blacklisted(struct usb_device *udev, | ||
1106 | + struct usb_host_interface *intf, | ||
1107 | + struct usb_endpoint_descriptor *epd) | ||
1108 | +{ | ||
1109 | + const struct usb_device_id *id; | ||
1110 | + unsigned int address; | ||
1111 | + | ||
1112 | + for (id = usb_endpoint_blacklist; id->match_flags; ++id) { | ||
1113 | + if (!usb_match_device(udev, id)) | ||
1114 | + continue; | ||
1115 | + | ||
1116 | + if (!usb_match_one_id_intf(udev, intf, id)) | ||
1117 | + continue; | ||
1118 | + | ||
1119 | + address = id->driver_info; | ||
1120 | + if (address == epd->bEndpointAddress) | ||
1121 | + return true; | ||
1122 | + } | ||
1123 | + | ||
1124 | + return false; | ||
1125 | +} | ||
1126 | + | ||
1127 | static bool usb_match_any_interface(struct usb_device *udev, | ||
1128 | const struct usb_device_id *id) | ||
1129 | { | ||
1130 | diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h | ||
1131 | index 6b2f115442838..462a00c749b87 100644 | ||
1132 | --- a/drivers/usb/core/usb.h | ||
1133 | +++ b/drivers/usb/core/usb.h | ||
1134 | @@ -31,6 +31,9 @@ extern void usb_deauthorize_interface(struct usb_interface *); | ||
1135 | extern void usb_authorize_interface(struct usb_interface *); | ||
1136 | extern void usb_detect_quirks(struct usb_device *udev); | ||
1137 | extern void usb_detect_interface_quirks(struct usb_device *udev); | ||
1138 | +extern bool usb_endpoint_is_blacklisted(struct usb_device *udev, | ||
1139 | + struct usb_host_interface *intf, | ||
1140 | + struct usb_endpoint_descriptor *epd); | ||
1141 | extern int usb_remove_device(struct usb_device *udev); | ||
1142 | |||
1143 | extern int usb_get_device_descriptor(struct usb_device *dev, | ||
1144 | diff --git a/drivers/usb/gadget/function/f_midi.c b/drivers/usb/gadget/function/f_midi.c | ||
1145 | index 70ac1963b5987..cab5fbd5b9557 100644 | ||
1146 | --- a/drivers/usb/gadget/function/f_midi.c | ||
1147 | +++ b/drivers/usb/gadget/function/f_midi.c | ||
1148 | @@ -1256,7 +1256,7 @@ static struct usb_function *f_midi_alloc(struct usb_function_instance *fi) | ||
1149 | midi->id = kstrdup(opts->id, GFP_KERNEL); | ||
1150 | if (opts->id && !midi->id) { | ||
1151 | status = -ENOMEM; | ||
1152 | - goto setup_fail; | ||
1153 | + goto midi_free; | ||
1154 | } | ||
1155 | midi->in_ports = opts->in_ports; | ||
1156 | midi->out_ports = opts->out_ports; | ||
1157 | @@ -1267,7 +1267,7 @@ static struct usb_function *f_midi_alloc(struct usb_function_instance *fi) | ||
1158 | |||
1159 | status = kfifo_alloc(&midi->in_req_fifo, midi->qlen, GFP_KERNEL); | ||
1160 | if (status) | ||
1161 | - goto setup_fail; | ||
1162 | + goto midi_free; | ||
1163 | |||
1164 | spin_lock_init(&midi->transmit_lock); | ||
1165 | |||
1166 | @@ -1283,9 +1283,13 @@ static struct usb_function *f_midi_alloc(struct usb_function_instance *fi) | ||
1167 | |||
1168 | return &midi->func; | ||
1169 | |||
1170 | +midi_free: | ||
1171 | + if (midi) | ||
1172 | + kfree(midi->id); | ||
1173 | + kfree(midi); | ||
1174 | setup_fail: | ||
1175 | mutex_unlock(&opts->lock); | ||
1176 | - kfree(midi); | ||
1177 | + | ||
1178 | return ERR_PTR(status); | ||
1179 | } | ||
1180 | |||
1181 | diff --git a/drivers/usb/gadget/legacy/inode.c b/drivers/usb/gadget/legacy/inode.c | ||
1182 | index cb02e9ecd8e7d..de0f3c2c9f6f3 100644 | ||
1183 | --- a/drivers/usb/gadget/legacy/inode.c | ||
1184 | +++ b/drivers/usb/gadget/legacy/inode.c | ||
1185 | @@ -2045,6 +2045,9 @@ gadgetfs_fill_super (struct super_block *sb, void *opts, int silent) | ||
1186 | return 0; | ||
1187 | |||
1188 | Enomem: | ||
1189 | + kfree(CHIP); | ||
1190 | + CHIP = NULL; | ||
1191 | + | ||
1192 | return -ENOMEM; | ||
1193 | } | ||
1194 | |||
1195 | diff --git a/drivers/video/fbdev/hyperv_fb.c b/drivers/video/fbdev/hyperv_fb.c | ||
1196 | index 2fd49b2358f8b..f3938c5278832 100644 | ||
1197 | --- a/drivers/video/fbdev/hyperv_fb.c | ||
1198 | +++ b/drivers/video/fbdev/hyperv_fb.c | ||
1199 | @@ -712,7 +712,12 @@ static int hvfb_getmem(struct hv_device *hdev, struct fb_info *info) | ||
1200 | goto err1; | ||
1201 | } | ||
1202 | |||
1203 | - fb_virt = ioremap(par->mem->start, screen_fb_size); | ||
1204 | + /* | ||
1205 | + * Map the VRAM cacheable for performance. This is also required for | ||
1206 | + * VM Connect to display properly for ARM64 Linux VM, as the host also | ||
1207 | + * maps the VRAM cacheable. | ||
1208 | + */ | ||
1209 | + fb_virt = ioremap_cache(par->mem->start, screen_fb_size); | ||
1210 | if (!fb_virt) | ||
1211 | goto err2; | ||
1212 | |||
1213 | diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c | ||
1214 | index dfc0b3adf57af..6f8f37e37abb2 100644 | ||
1215 | --- a/fs/btrfs/inode.c | ||
1216 | +++ b/fs/btrfs/inode.c | ||
1217 | @@ -5440,11 +5440,13 @@ no_delete: | ||
1218 | } | ||
1219 | |||
1220 | /* | ||
1221 | - * this returns the key found in the dir entry in the location pointer. | ||
1222 | + * Return the key found in the dir entry in the location pointer, fill @type | ||
1223 | + * with BTRFS_FT_*, and return 0. | ||
1224 | + * | ||
1225 | * If no dir entries were found, location->objectid is 0. | ||
1226 | */ | ||
1227 | static int btrfs_inode_by_name(struct inode *dir, struct dentry *dentry, | ||
1228 | - struct btrfs_key *location) | ||
1229 | + struct btrfs_key *location, u8 *type) | ||
1230 | { | ||
1231 | const char *name = dentry->d_name.name; | ||
1232 | int namelen = dentry->d_name.len; | ||
1233 | @@ -5466,6 +5468,8 @@ static int btrfs_inode_by_name(struct inode *dir, struct dentry *dentry, | ||
1234 | goto out_err; | ||
1235 | |||
1236 | btrfs_dir_item_key_to_cpu(path->nodes[0], di, location); | ||
1237 | + if (!ret) | ||
1238 | + *type = btrfs_dir_type(path->nodes[0], di); | ||
1239 | out: | ||
1240 | btrfs_free_path(path); | ||
1241 | return ret; | ||
1242 | @@ -5755,19 +5759,25 @@ static struct inode *new_simple_dir(struct super_block *s, | ||
1243 | return inode; | ||
1244 | } | ||
1245 | |||
1246 | +static inline u8 btrfs_inode_type(struct inode *inode) | ||
1247 | +{ | ||
1248 | + return btrfs_type_by_mode[(inode->i_mode & S_IFMT) >> S_SHIFT]; | ||
1249 | +} | ||
1250 | + | ||
1251 | struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry) | ||
1252 | { | ||
1253 | struct inode *inode; | ||
1254 | struct btrfs_root *root = BTRFS_I(dir)->root; | ||
1255 | struct btrfs_root *sub_root = root; | ||
1256 | struct btrfs_key location; | ||
1257 | + u8 di_type = 0; | ||
1258 | int index; | ||
1259 | int ret = 0; | ||
1260 | |||
1261 | if (dentry->d_name.len > BTRFS_NAME_LEN) | ||
1262 | return ERR_PTR(-ENAMETOOLONG); | ||
1263 | |||
1264 | - ret = btrfs_inode_by_name(dir, dentry, &location); | ||
1265 | + ret = btrfs_inode_by_name(dir, dentry, &location, &di_type); | ||
1266 | if (ret < 0) | ||
1267 | return ERR_PTR(ret); | ||
1268 | |||
1269 | @@ -5776,6 +5786,18 @@ struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry) | ||
1270 | |||
1271 | if (location.type == BTRFS_INODE_ITEM_KEY) { | ||
1272 | inode = btrfs_iget(dir->i_sb, &location, root, NULL); | ||
1273 | + if (IS_ERR(inode)) | ||
1274 | + return inode; | ||
1275 | + | ||
1276 | + /* Do extra check against inode mode with di_type */ | ||
1277 | + if (btrfs_inode_type(inode) != di_type) { | ||
1278 | + btrfs_crit(root->fs_info, | ||
1279 | +"inode mode mismatch with dir: inode mode=0%o btrfs type=%u dir type=%u", | ||
1280 | + inode->i_mode, btrfs_inode_type(inode), | ||
1281 | + di_type); | ||
1282 | + iput(inode); | ||
1283 | + return ERR_PTR(-EUCLEAN); | ||
1284 | + } | ||
1285 | return inode; | ||
1286 | } | ||
1287 | |||
1288 | @@ -6391,11 +6413,6 @@ fail: | ||
1289 | return ERR_PTR(ret); | ||
1290 | } | ||
1291 | |||
1292 | -static inline u8 btrfs_inode_type(struct inode *inode) | ||
1293 | -{ | ||
1294 | - return btrfs_type_by_mode[(inode->i_mode & S_IFMT) >> S_SHIFT]; | ||
1295 | -} | ||
1296 | - | ||
1297 | /* | ||
1298 | * utility function to add 'inode' into 'parent_inode' with | ||
1299 | * a give name and a given sequence number. | ||
1300 | @@ -6981,6 +6998,14 @@ again: | ||
1301 | extent_start = found_key.offset; | ||
1302 | if (found_type == BTRFS_FILE_EXTENT_REG || | ||
1303 | found_type == BTRFS_FILE_EXTENT_PREALLOC) { | ||
1304 | + /* Only regular file could have regular/prealloc extent */ | ||
1305 | + if (!S_ISREG(inode->i_mode)) { | ||
1306 | + ret = -EUCLEAN; | ||
1307 | + btrfs_crit(root->fs_info, | ||
1308 | + "regular/prealloc extent found for non-regular inode %llu", | ||
1309 | + btrfs_ino(inode)); | ||
1310 | + goto out; | ||
1311 | + } | ||
1312 | extent_end = extent_start + | ||
1313 | btrfs_file_extent_num_bytes(leaf, item); | ||
1314 | } else if (found_type == BTRFS_FILE_EXTENT_INLINE) { | ||
1315 | diff --git a/fs/btrfs/qgroup.c b/fs/btrfs/qgroup.c | ||
1316 | index 0355e6d9e21cb..154008e245a2f 100644 | ||
1317 | --- a/fs/btrfs/qgroup.c | ||
1318 | +++ b/fs/btrfs/qgroup.c | ||
1319 | @@ -461,13 +461,13 @@ next2: | ||
1320 | break; | ||
1321 | } | ||
1322 | out: | ||
1323 | + btrfs_free_path(path); | ||
1324 | fs_info->qgroup_flags |= flags; | ||
1325 | if (!(fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_ON)) | ||
1326 | clear_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags); | ||
1327 | else if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_RESCAN && | ||
1328 | ret >= 0) | ||
1329 | ret = qgroup_rescan_init(fs_info, rescan_progress, 0); | ||
1330 | - btrfs_free_path(path); | ||
1331 | |||
1332 | if (ret < 0) { | ||
1333 | ulist_free(fs_info->qgroup_ulist); | ||
1334 | diff --git a/fs/btrfs/tests/inode-tests.c b/fs/btrfs/tests/inode-tests.c | ||
1335 | index 0bf46808ce8f2..ee89de7f4d61b 100644 | ||
1336 | --- a/fs/btrfs/tests/inode-tests.c | ||
1337 | +++ b/fs/btrfs/tests/inode-tests.c | ||
1338 | @@ -245,6 +245,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize) | ||
1339 | return ret; | ||
1340 | } | ||
1341 | |||
1342 | + inode->i_mode = S_IFREG; | ||
1343 | BTRFS_I(inode)->location.type = BTRFS_INODE_ITEM_KEY; | ||
1344 | BTRFS_I(inode)->location.objectid = BTRFS_FIRST_FREE_OBJECTID; | ||
1345 | BTRFS_I(inode)->location.offset = 0; | ||
1346 | diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c | ||
1347 | index c31b02692f706..7391634520ab2 100644 | ||
1348 | --- a/fs/btrfs/volumes.c | ||
1349 | +++ b/fs/btrfs/volumes.c | ||
1350 | @@ -6414,6 +6414,13 @@ static int btrfs_check_chunk_valid(struct btrfs_root *root, | ||
1351 | return -EIO; | ||
1352 | } | ||
1353 | |||
1354 | + if (!is_power_of_2(type & BTRFS_BLOCK_GROUP_PROFILE_MASK) && | ||
1355 | + (type & BTRFS_BLOCK_GROUP_PROFILE_MASK) != 0) { | ||
1356 | + btrfs_err(root->fs_info, | ||
1357 | + "invalid chunk profile flag: 0x%llx, expect 0 or 1 bit set", | ||
1358 | + type & BTRFS_BLOCK_GROUP_PROFILE_MASK); | ||
1359 | + return -EUCLEAN; | ||
1360 | + } | ||
1361 | if ((type & BTRFS_BLOCK_GROUP_TYPE_MASK) == 0) { | ||
1362 | btrfs_err(root->fs_info, "missing chunk type flag: 0x%llx", type); | ||
1363 | return -EIO; | ||
1364 | diff --git a/fs/efivarfs/inode.c b/fs/efivarfs/inode.c | ||
1365 | index 71fccccf317e8..5decb3e06563f 100644 | ||
1366 | --- a/fs/efivarfs/inode.c | ||
1367 | +++ b/fs/efivarfs/inode.c | ||
1368 | @@ -10,6 +10,7 @@ | ||
1369 | #include <linux/efi.h> | ||
1370 | #include <linux/fs.h> | ||
1371 | #include <linux/ctype.h> | ||
1372 | +#include <linux/kmemleak.h> | ||
1373 | #include <linux/slab.h> | ||
1374 | #include <linux/uuid.h> | ||
1375 | |||
1376 | @@ -104,6 +105,7 @@ static int efivarfs_create(struct inode *dir, struct dentry *dentry, | ||
1377 | var->var.VariableName[i] = '\0'; | ||
1378 | |||
1379 | inode->i_private = var; | ||
1380 | + kmemleak_ignore(var); | ||
1381 | |||
1382 | err = efivar_entry_add(var, &efivarfs_list); | ||
1383 | if (err) | ||
1384 | diff --git a/fs/efivarfs/super.c b/fs/efivarfs/super.c | ||
1385 | index bbf056191aaa4..b1e6acec53041 100644 | ||
1386 | --- a/fs/efivarfs/super.c | ||
1387 | +++ b/fs/efivarfs/super.c | ||
1388 | @@ -23,7 +23,6 @@ LIST_HEAD(efivarfs_list); | ||
1389 | static void efivarfs_evict_inode(struct inode *inode) | ||
1390 | { | ||
1391 | clear_inode(inode); | ||
1392 | - kfree(inode->i_private); | ||
1393 | } | ||
1394 | |||
1395 | static const struct super_operations efivarfs_ops = { | ||
1396 | diff --git a/fs/proc/self.c b/fs/proc/self.c | ||
1397 | index c8bbc1c84a39a..f6e2e3fb8a226 100644 | ||
1398 | --- a/fs/proc/self.c | ||
1399 | +++ b/fs/proc/self.c | ||
1400 | @@ -26,6 +26,13 @@ static const char *proc_self_get_link(struct dentry *dentry, | ||
1401 | pid_t tgid = task_tgid_nr_ns(current, ns); | ||
1402 | char *name; | ||
1403 | |||
1404 | + /* | ||
1405 | + * Not currently supported. Once we can inherit all of struct pid, | ||
1406 | + * we can allow this. | ||
1407 | + */ | ||
1408 | + if (current->flags & PF_KTHREAD) | ||
1409 | + return ERR_PTR(-EOPNOTSUPP); | ||
1410 | + | ||
1411 | if (!tgid) | ||
1412 | return ERR_PTR(-ENOENT); | ||
1413 | /* 11 for max length of signed int in decimal + NULL term */ | ||
1414 | diff --git a/include/linux/usb/quirks.h b/include/linux/usb/quirks.h | ||
1415 | index ea4f81c2a6d5e..602dff213bae1 100644 | ||
1416 | --- a/include/linux/usb/quirks.h | ||
1417 | +++ b/include/linux/usb/quirks.h | ||
1418 | @@ -59,4 +59,7 @@ | ||
1419 | /* Device needs a pause after every control message. */ | ||
1420 | #define USB_QUIRK_DELAY_CTRL_MSG BIT(13) | ||
1421 | |||
1422 | +/* device has blacklisted endpoints */ | ||
1423 | +#define USB_QUIRK_ENDPOINT_BLACKLIST BIT(15) | ||
1424 | + | ||
1425 | #endif /* __LINUX_USB_QUIRKS_H */ | ||
1426 | diff --git a/include/scsi/libiscsi.h b/include/scsi/libiscsi.h | ||
1427 | index c7b1dc713cdd7..9c7f4aad6db66 100644 | ||
1428 | --- a/include/scsi/libiscsi.h | ||
1429 | +++ b/include/scsi/libiscsi.h | ||
1430 | @@ -144,6 +144,9 @@ struct iscsi_task { | ||
1431 | void *dd_data; /* driver/transport data */ | ||
1432 | }; | ||
1433 | |||
1434 | +/* invalid scsi_task pointer */ | ||
1435 | +#define INVALID_SCSI_TASK (struct iscsi_task *)-1l | ||
1436 | + | ||
1437 | static inline int iscsi_task_has_unsol_data(struct iscsi_task *task) | ||
1438 | { | ||
1439 | return task->unsol_r2t.data_length > task->unsol_r2t.sent; | ||
1440 | diff --git a/mm/huge_memory.c b/mm/huge_memory.c | ||
1441 | index cf4c0a61b3708..0385c57a2b7af 100644 | ||
1442 | --- a/mm/huge_memory.c | ||
1443 | +++ b/mm/huge_memory.c | ||
1444 | @@ -661,7 +661,6 @@ int do_huge_pmd_anonymous_page(struct fault_env *fe) | ||
1445 | transparent_hugepage_use_zero_page()) { | ||
1446 | pgtable_t pgtable; | ||
1447 | struct page *zero_page; | ||
1448 | - bool set; | ||
1449 | int ret; | ||
1450 | pgtable = pte_alloc_one(vma->vm_mm, haddr); | ||
1451 | if (unlikely(!pgtable)) | ||
1452 | @@ -674,22 +673,21 @@ int do_huge_pmd_anonymous_page(struct fault_env *fe) | ||
1453 | } | ||
1454 | fe->ptl = pmd_lock(vma->vm_mm, fe->pmd); | ||
1455 | ret = 0; | ||
1456 | - set = false; | ||
1457 | if (pmd_none(*fe->pmd)) { | ||
1458 | if (userfaultfd_missing(vma)) { | ||
1459 | spin_unlock(fe->ptl); | ||
1460 | + pte_free(vma->vm_mm, pgtable); | ||
1461 | ret = handle_userfault(fe, VM_UFFD_MISSING); | ||
1462 | VM_BUG_ON(ret & VM_FAULT_FALLBACK); | ||
1463 | } else { | ||
1464 | set_huge_zero_page(pgtable, vma->vm_mm, vma, | ||
1465 | haddr, fe->pmd, zero_page); | ||
1466 | spin_unlock(fe->ptl); | ||
1467 | - set = true; | ||
1468 | } | ||
1469 | - } else | ||
1470 | + } else { | ||
1471 | spin_unlock(fe->ptl); | ||
1472 | - if (!set) | ||
1473 | pte_free(vma->vm_mm, pgtable); | ||
1474 | + } | ||
1475 | return ret; | ||
1476 | } | ||
1477 | gfp = alloc_hugepage_direct_gfpmask(vma); | ||
1478 | diff --git a/net/batman-adv/log.c b/net/batman-adv/log.c | ||
1479 | index 56dc532f7a2c2..b422a8b34b9f5 100644 | ||
1480 | --- a/net/batman-adv/log.c | ||
1481 | +++ b/net/batman-adv/log.c | ||
1482 | @@ -196,6 +196,7 @@ static const struct file_operations batadv_log_fops = { | ||
1483 | .read = batadv_log_read, | ||
1484 | .poll = batadv_log_poll, | ||
1485 | .llseek = no_llseek, | ||
1486 | + .owner = THIS_MODULE, | ||
1487 | }; | ||
1488 | |||
1489 | int batadv_debug_log_setup(struct batadv_priv *bat_priv) | ||
1490 | diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c | ||
1491 | index 4f8dd558af48f..ba0c3a381933e 100644 | ||
1492 | --- a/sound/pci/hda/patch_hdmi.c | ||
1493 | +++ b/sound/pci/hda/patch_hdmi.c | ||
1494 | @@ -307,13 +307,13 @@ static int hdmi_eld_ctl_info(struct snd_kcontrol *kcontrol, | ||
1495 | if (!per_pin) { | ||
1496 | /* no pin is bound to the pcm */ | ||
1497 | uinfo->count = 0; | ||
1498 | - mutex_unlock(&spec->pcm_lock); | ||
1499 | - return 0; | ||
1500 | + goto unlock; | ||
1501 | } | ||
1502 | eld = &per_pin->sink_eld; | ||
1503 | uinfo->count = eld->eld_valid ? eld->eld_size : 0; | ||
1504 | - mutex_unlock(&spec->pcm_lock); | ||
1505 | |||
1506 | + unlock: | ||
1507 | + mutex_unlock(&spec->pcm_lock); | ||
1508 | return 0; | ||
1509 | } | ||
1510 | |||
1511 | @@ -325,6 +325,7 @@ static int hdmi_eld_ctl_get(struct snd_kcontrol *kcontrol, | ||
1512 | struct hdmi_spec_per_pin *per_pin; | ||
1513 | struct hdmi_eld *eld; | ||
1514 | int pcm_idx; | ||
1515 | + int err = 0; | ||
1516 | |||
1517 | pcm_idx = kcontrol->private_value; | ||
1518 | mutex_lock(&spec->pcm_lock); | ||
1519 | @@ -333,16 +334,15 @@ static int hdmi_eld_ctl_get(struct snd_kcontrol *kcontrol, | ||
1520 | /* no pin is bound to the pcm */ | ||
1521 | memset(ucontrol->value.bytes.data, 0, | ||
1522 | ARRAY_SIZE(ucontrol->value.bytes.data)); | ||
1523 | - mutex_unlock(&spec->pcm_lock); | ||
1524 | - return 0; | ||
1525 | + goto unlock; | ||
1526 | } | ||
1527 | - eld = &per_pin->sink_eld; | ||
1528 | |||
1529 | + eld = &per_pin->sink_eld; | ||
1530 | if (eld->eld_size > ARRAY_SIZE(ucontrol->value.bytes.data) || | ||
1531 | eld->eld_size > ELD_MAX_SIZE) { | ||
1532 | - mutex_unlock(&spec->pcm_lock); | ||
1533 | snd_BUG(); | ||
1534 | - return -EINVAL; | ||
1535 | + err = -EINVAL; | ||
1536 | + goto unlock; | ||
1537 | } | ||
1538 | |||
1539 | memset(ucontrol->value.bytes.data, 0, | ||
1540 | @@ -350,9 +350,10 @@ static int hdmi_eld_ctl_get(struct snd_kcontrol *kcontrol, | ||
1541 | if (eld->eld_valid) | ||
1542 | memcpy(ucontrol->value.bytes.data, eld->eld_buffer, | ||
1543 | eld->eld_size); | ||
1544 | - mutex_unlock(&spec->pcm_lock); | ||
1545 | |||
1546 | - return 0; | ||
1547 | + unlock: | ||
1548 | + mutex_unlock(&spec->pcm_lock); | ||
1549 | + return err; | ||
1550 | } | ||
1551 | |||
1552 | static struct snd_kcontrol_new eld_bytes_ctl = { | ||
1553 | @@ -1114,8 +1115,8 @@ static int hdmi_pcm_open(struct hda_pcm_stream *hinfo, | ||
1554 | pin_idx = hinfo_to_pin_index(codec, hinfo); | ||
1555 | if (!spec->dyn_pcm_assign) { | ||
1556 | if (snd_BUG_ON(pin_idx < 0)) { | ||
1557 | - mutex_unlock(&spec->pcm_lock); | ||
1558 | - return -EINVAL; | ||
1559 | + err = -EINVAL; | ||
1560 | + goto unlock; | ||
1561 | } | ||
1562 | } else { | ||
1563 | /* no pin is assigned to the PCM | ||
1564 | @@ -1123,16 +1124,13 @@ static int hdmi_pcm_open(struct hda_pcm_stream *hinfo, | ||
1565 | */ | ||
1566 | if (pin_idx < 0) { | ||
1567 | err = hdmi_pcm_open_no_pin(hinfo, codec, substream); | ||
1568 | - mutex_unlock(&spec->pcm_lock); | ||
1569 | - return err; | ||
1570 | + goto unlock; | ||
1571 | } | ||
1572 | } | ||
1573 | |||
1574 | err = hdmi_choose_cvt(codec, pin_idx, &cvt_idx); | ||
1575 | - if (err < 0) { | ||
1576 | - mutex_unlock(&spec->pcm_lock); | ||
1577 | - return err; | ||
1578 | - } | ||
1579 | + if (err < 0) | ||
1580 | + goto unlock; | ||
1581 | |||
1582 | per_cvt = get_cvt(spec, cvt_idx); | ||
1583 | /* Claim converter */ | ||
1584 | @@ -1168,12 +1166,11 @@ static int hdmi_pcm_open(struct hda_pcm_stream *hinfo, | ||
1585 | per_cvt->assigned = 0; | ||
1586 | hinfo->nid = 0; | ||
1587 | snd_hda_spdif_ctls_unassign(codec, pcm_idx); | ||
1588 | - mutex_unlock(&spec->pcm_lock); | ||
1589 | - return -ENODEV; | ||
1590 | + err = -ENODEV; | ||
1591 | + goto unlock; | ||
1592 | } | ||
1593 | } | ||
1594 | |||
1595 | - mutex_unlock(&spec->pcm_lock); | ||
1596 | /* Store the updated parameters */ | ||
1597 | runtime->hw.channels_min = hinfo->channels_min; | ||
1598 | runtime->hw.channels_max = hinfo->channels_max; | ||
1599 | @@ -1182,7 +1179,9 @@ static int hdmi_pcm_open(struct hda_pcm_stream *hinfo, | ||
1600 | |||
1601 | snd_pcm_hw_constraint_step(substream->runtime, 0, | ||
1602 | SNDRV_PCM_HW_PARAM_CHANNELS, 2); | ||
1603 | - return 0; | ||
1604 | + unlock: | ||
1605 | + mutex_unlock(&spec->pcm_lock); | ||
1606 | + return err; | ||
1607 | } | ||
1608 | |||
1609 | /* | ||
1610 | @@ -1726,7 +1725,7 @@ static int generic_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo, | ||
1611 | struct snd_pcm_runtime *runtime = substream->runtime; | ||
1612 | bool non_pcm; | ||
1613 | int pinctl; | ||
1614 | - int err; | ||
1615 | + int err = 0; | ||
1616 | |||
1617 | mutex_lock(&spec->pcm_lock); | ||
1618 | pin_idx = hinfo_to_pin_index(codec, hinfo); | ||
1619 | @@ -1738,13 +1737,12 @@ static int generic_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo, | ||
1620 | pin_cvt_fixup(codec, NULL, cvt_nid); | ||
1621 | snd_hda_codec_setup_stream(codec, cvt_nid, | ||
1622 | stream_tag, 0, format); | ||
1623 | - mutex_unlock(&spec->pcm_lock); | ||
1624 | - return 0; | ||
1625 | + goto unlock; | ||
1626 | } | ||
1627 | |||
1628 | if (snd_BUG_ON(pin_idx < 0)) { | ||
1629 | - mutex_unlock(&spec->pcm_lock); | ||
1630 | - return -EINVAL; | ||
1631 | + err = -EINVAL; | ||
1632 | + goto unlock; | ||
1633 | } | ||
1634 | per_pin = get_pin(spec, pin_idx); | ||
1635 | pin_nid = per_pin->pin_nid; | ||
1636 | @@ -1781,6 +1779,7 @@ static int generic_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo, | ||
1637 | |||
1638 | err = spec->ops.setup_stream(codec, cvt_nid, pin_nid, | ||
1639 | stream_tag, format); | ||
1640 | + unlock: | ||
1641 | mutex_unlock(&spec->pcm_lock); | ||
1642 | return err; | ||
1643 | } | ||
1644 | @@ -1802,32 +1801,34 @@ static int hdmi_pcm_close(struct hda_pcm_stream *hinfo, | ||
1645 | struct hdmi_spec_per_cvt *per_cvt; | ||
1646 | struct hdmi_spec_per_pin *per_pin; | ||
1647 | int pinctl; | ||
1648 | + int err = 0; | ||
1649 | |||
1650 | + mutex_lock(&spec->pcm_lock); | ||
1651 | if (hinfo->nid) { | ||
1652 | pcm_idx = hinfo_to_pcm_index(codec, hinfo); | ||
1653 | - if (snd_BUG_ON(pcm_idx < 0)) | ||
1654 | - return -EINVAL; | ||
1655 | + if (snd_BUG_ON(pcm_idx < 0)) { | ||
1656 | + err = -EINVAL; | ||
1657 | + goto unlock; | ||
1658 | + } | ||
1659 | cvt_idx = cvt_nid_to_cvt_index(codec, hinfo->nid); | ||
1660 | - if (snd_BUG_ON(cvt_idx < 0)) | ||
1661 | - return -EINVAL; | ||
1662 | + if (snd_BUG_ON(cvt_idx < 0)) { | ||
1663 | + err = -EINVAL; | ||
1664 | + goto unlock; | ||
1665 | + } | ||
1666 | per_cvt = get_cvt(spec, cvt_idx); | ||
1667 | - | ||
1668 | snd_BUG_ON(!per_cvt->assigned); | ||
1669 | per_cvt->assigned = 0; | ||
1670 | hinfo->nid = 0; | ||
1671 | |||
1672 | - mutex_lock(&spec->pcm_lock); | ||
1673 | snd_hda_spdif_ctls_unassign(codec, pcm_idx); | ||
1674 | clear_bit(pcm_idx, &spec->pcm_in_use); | ||
1675 | pin_idx = hinfo_to_pin_index(codec, hinfo); | ||
1676 | - if (spec->dyn_pcm_assign && pin_idx < 0) { | ||
1677 | - mutex_unlock(&spec->pcm_lock); | ||
1678 | - return 0; | ||
1679 | - } | ||
1680 | + if (spec->dyn_pcm_assign && pin_idx < 0) | ||
1681 | + goto unlock; | ||
1682 | |||
1683 | if (snd_BUG_ON(pin_idx < 0)) { | ||
1684 | - mutex_unlock(&spec->pcm_lock); | ||
1685 | - return -EINVAL; | ||
1686 | + err = -EINVAL; | ||
1687 | + goto unlock; | ||
1688 | } | ||
1689 | per_pin = get_pin(spec, pin_idx); | ||
1690 | |||
1691 | @@ -1846,10 +1847,12 @@ static int hdmi_pcm_close(struct hda_pcm_stream *hinfo, | ||
1692 | per_pin->setup = false; | ||
1693 | per_pin->channels = 0; | ||
1694 | mutex_unlock(&per_pin->lock); | ||
1695 | - mutex_unlock(&spec->pcm_lock); | ||
1696 | } | ||
1697 | |||
1698 | - return 0; | ||
1699 | +unlock: | ||
1700 | + mutex_unlock(&spec->pcm_lock); | ||
1701 | + | ||
1702 | + return err; | ||
1703 | } | ||
1704 | |||
1705 | static const struct hda_pcm_ops generic_ops = { | ||
1706 | diff --git a/tools/perf/util/dwarf-aux.c b/tools/perf/util/dwarf-aux.c | ||
1707 | index fb4e1d2839c5f..cbbacc3467494 100644 | ||
1708 | --- a/tools/perf/util/dwarf-aux.c | ||
1709 | +++ b/tools/perf/util/dwarf-aux.c | ||
1710 | @@ -329,6 +329,7 @@ bool die_is_func_def(Dwarf_Die *dw_die) | ||
1711 | int die_entrypc(Dwarf_Die *dw_die, Dwarf_Addr *addr) | ||
1712 | { | ||
1713 | Dwarf_Addr base, end; | ||
1714 | + Dwarf_Attribute attr; | ||
1715 | |||
1716 | if (!addr) | ||
1717 | return -EINVAL; | ||
1718 | @@ -336,6 +337,13 @@ int die_entrypc(Dwarf_Die *dw_die, Dwarf_Addr *addr) | ||
1719 | if (dwarf_entrypc(dw_die, addr) == 0) | ||
1720 | return 0; | ||
1721 | |||
1722 | + /* | ||
1723 | + * Since the dwarf_ranges() will return 0 if there is no | ||
1724 | + * DW_AT_ranges attribute, we should check it first. | ||
1725 | + */ | ||
1726 | + if (!dwarf_attr(dw_die, DW_AT_ranges, &attr)) | ||
1727 | + return -ENOENT; | ||
1728 | + | ||
1729 | return dwarf_ranges(dw_die, 0, &base, addr, &end) < 0 ? -ENOENT : 0; | ||
1730 | } | ||
1731 | |||
1732 | diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c | ||
1733 | index 2d5744d986f0b..659c41004322d 100644 | ||
1734 | --- a/tools/perf/util/event.c | ||
1735 | +++ b/tools/perf/util/event.c | ||
1736 | @@ -682,11 +682,13 @@ int perf_event__synthesize_kernel_mmap(struct perf_tool *tool, | ||
1737 | int err; | ||
1738 | union perf_event *event; | ||
1739 | |||
1740 | - if (symbol_conf.kptr_restrict) | ||
1741 | - return -1; | ||
1742 | if (map == NULL) | ||
1743 | return -1; | ||
1744 | |||
1745 | + kmap = map__kmap(map); | ||
1746 | + if (!kmap->ref_reloc_sym) | ||
1747 | + return -1; | ||
1748 | + | ||
1749 | /* | ||
1750 | * We should get this from /sys/kernel/sections/.text, but till that is | ||
1751 | * available use this, and after it is use this as a fallback for older | ||
1752 | @@ -710,7 +712,6 @@ int perf_event__synthesize_kernel_mmap(struct perf_tool *tool, | ||
1753 | event->header.misc = PERF_RECORD_MISC_GUEST_KERNEL; | ||
1754 | } | ||
1755 | |||
1756 | - kmap = map__kmap(map); | ||
1757 | size = snprintf(event->mmap.filename, sizeof(event->mmap.filename), | ||
1758 | "%s%s", mmap_name, kmap->ref_reloc_sym->name) + 1; | ||
1759 | size = PERF_ALIGN(size, sizeof(u64)); |