Annotation of /trunk/kernel-alx/patches-5.4/0182-5.4.83-all-fixes.patch
Parent Directory | Revision Log
Revision 3635 -
(hide annotations)
(download)
Mon Oct 24 12:34:12 2022 UTC (18 months, 3 weeks ago) by niro
File size: 63010 byte(s)
Mon Oct 24 12:34:12 2022 UTC (18 months, 3 weeks ago) by niro
File size: 63010 byte(s)
-sync kernel patches
1 | niro | 3635 | diff --git a/Makefile b/Makefile |
2 | index e520dee34490a..eee1aa092ede8 100644 | ||
3 | --- a/Makefile | ||
4 | +++ b/Makefile | ||
5 | @@ -1,7 +1,7 @@ | ||
6 | # SPDX-License-Identifier: GPL-2.0 | ||
7 | VERSION = 5 | ||
8 | PATCHLEVEL = 4 | ||
9 | -SUBLEVEL = 82 | ||
10 | +SUBLEVEL = 83 | ||
11 | EXTRAVERSION = | ||
12 | NAME = Kleptomaniac Octopus | ||
13 | |||
14 | diff --git a/arch/powerpc/platforms/powernv/setup.c b/arch/powerpc/platforms/powernv/setup.c | ||
15 | index 3a9f79d18f6b0..1b7b0d0c3ebdd 100644 | ||
16 | --- a/arch/powerpc/platforms/powernv/setup.c | ||
17 | +++ b/arch/powerpc/platforms/powernv/setup.c | ||
18 | @@ -186,11 +186,16 @@ static void __init pnv_init(void) | ||
19 | add_preferred_console("hvc", 0, NULL); | ||
20 | |||
21 | if (!radix_enabled()) { | ||
22 | + size_t size = sizeof(struct slb_entry) * mmu_slb_size; | ||
23 | int i; | ||
24 | |||
25 | /* Allocate per cpu area to save old slb contents during MCE */ | ||
26 | - for_each_possible_cpu(i) | ||
27 | - paca_ptrs[i]->mce_faulty_slbs = memblock_alloc_node(mmu_slb_size, __alignof__(*paca_ptrs[i]->mce_faulty_slbs), cpu_to_node(i)); | ||
28 | + for_each_possible_cpu(i) { | ||
29 | + paca_ptrs[i]->mce_faulty_slbs = | ||
30 | + memblock_alloc_node(size, | ||
31 | + __alignof__(struct slb_entry), | ||
32 | + cpu_to_node(i)); | ||
33 | + } | ||
34 | } | ||
35 | } | ||
36 | |||
37 | diff --git a/arch/powerpc/platforms/pseries/msi.c b/arch/powerpc/platforms/pseries/msi.c | ||
38 | index 133f6adcb39cb..b3ac2455faadc 100644 | ||
39 | --- a/arch/powerpc/platforms/pseries/msi.c | ||
40 | +++ b/arch/powerpc/platforms/pseries/msi.c | ||
41 | @@ -458,7 +458,8 @@ again: | ||
42 | return hwirq; | ||
43 | } | ||
44 | |||
45 | - virq = irq_create_mapping(NULL, hwirq); | ||
46 | + virq = irq_create_mapping_affinity(NULL, hwirq, | ||
47 | + entry->affinity); | ||
48 | |||
49 | if (!virq) { | ||
50 | pr_debug("rtas_msi: Failed mapping hwirq %d\n", hwirq); | ||
51 | diff --git a/arch/x86/include/asm/insn.h b/arch/x86/include/asm/insn.h | ||
52 | index 154f27be8bfcb..a51ffeea6d879 100644 | ||
53 | --- a/arch/x86/include/asm/insn.h | ||
54 | +++ b/arch/x86/include/asm/insn.h | ||
55 | @@ -195,6 +195,21 @@ static inline int insn_offset_immediate(struct insn *insn) | ||
56 | return insn_offset_displacement(insn) + insn->displacement.nbytes; | ||
57 | } | ||
58 | |||
59 | +/** | ||
60 | + * for_each_insn_prefix() -- Iterate prefixes in the instruction | ||
61 | + * @insn: Pointer to struct insn. | ||
62 | + * @idx: Index storage. | ||
63 | + * @prefix: Prefix byte. | ||
64 | + * | ||
65 | + * Iterate prefix bytes of given @insn. Each prefix byte is stored in @prefix | ||
66 | + * and the index is stored in @idx (note that this @idx is just for a cursor, | ||
67 | + * do not change it.) | ||
68 | + * Since prefixes.nbytes can be bigger than 4 if some prefixes | ||
69 | + * are repeated, it cannot be used for looping over the prefixes. | ||
70 | + */ | ||
71 | +#define for_each_insn_prefix(insn, idx, prefix) \ | ||
72 | + for (idx = 0; idx < ARRAY_SIZE(insn->prefixes.bytes) && (prefix = insn->prefixes.bytes[idx]) != 0; idx++) | ||
73 | + | ||
74 | #define POP_SS_OPCODE 0x1f | ||
75 | #define MOV_SREG_OPCODE 0x8e | ||
76 | |||
77 | diff --git a/arch/x86/kernel/uprobes.c b/arch/x86/kernel/uprobes.c | ||
78 | index 8cd745ef8c7b7..fae5b00cbccfb 100644 | ||
79 | --- a/arch/x86/kernel/uprobes.c | ||
80 | +++ b/arch/x86/kernel/uprobes.c | ||
81 | @@ -255,12 +255,13 @@ static volatile u32 good_2byte_insns[256 / 32] = { | ||
82 | |||
83 | static bool is_prefix_bad(struct insn *insn) | ||
84 | { | ||
85 | + insn_byte_t p; | ||
86 | int i; | ||
87 | |||
88 | - for (i = 0; i < insn->prefixes.nbytes; i++) { | ||
89 | + for_each_insn_prefix(insn, i, p) { | ||
90 | insn_attr_t attr; | ||
91 | |||
92 | - attr = inat_get_opcode_attribute(insn->prefixes.bytes[i]); | ||
93 | + attr = inat_get_opcode_attribute(p); | ||
94 | switch (attr) { | ||
95 | case INAT_MAKE_PREFIX(INAT_PFX_ES): | ||
96 | case INAT_MAKE_PREFIX(INAT_PFX_CS): | ||
97 | @@ -715,6 +716,7 @@ static const struct uprobe_xol_ops push_xol_ops = { | ||
98 | static int branch_setup_xol_ops(struct arch_uprobe *auprobe, struct insn *insn) | ||
99 | { | ||
100 | u8 opc1 = OPCODE1(insn); | ||
101 | + insn_byte_t p; | ||
102 | int i; | ||
103 | |||
104 | switch (opc1) { | ||
105 | @@ -746,8 +748,8 @@ static int branch_setup_xol_ops(struct arch_uprobe *auprobe, struct insn *insn) | ||
106 | * Intel and AMD behavior differ in 64-bit mode: Intel ignores 66 prefix. | ||
107 | * No one uses these insns, reject any branch insns with such prefix. | ||
108 | */ | ||
109 | - for (i = 0; i < insn->prefixes.nbytes; i++) { | ||
110 | - if (insn->prefixes.bytes[i] == 0x66) | ||
111 | + for_each_insn_prefix(insn, i, p) { | ||
112 | + if (p == 0x66) | ||
113 | return -ENOTSUPP; | ||
114 | } | ||
115 | |||
116 | diff --git a/arch/x86/lib/insn-eval.c b/arch/x86/lib/insn-eval.c | ||
117 | index 306c3a0902bad..cbe7e2503394f 100644 | ||
118 | --- a/arch/x86/lib/insn-eval.c | ||
119 | +++ b/arch/x86/lib/insn-eval.c | ||
120 | @@ -70,14 +70,15 @@ static int get_seg_reg_override_idx(struct insn *insn) | ||
121 | { | ||
122 | int idx = INAT_SEG_REG_DEFAULT; | ||
123 | int num_overrides = 0, i; | ||
124 | + insn_byte_t p; | ||
125 | |||
126 | insn_get_prefixes(insn); | ||
127 | |||
128 | /* Look for any segment override prefixes. */ | ||
129 | - for (i = 0; i < insn->prefixes.nbytes; i++) { | ||
130 | + for_each_insn_prefix(insn, i, p) { | ||
131 | insn_attr_t attr; | ||
132 | |||
133 | - attr = inat_get_opcode_attribute(insn->prefixes.bytes[i]); | ||
134 | + attr = inat_get_opcode_attribute(p); | ||
135 | switch (attr) { | ||
136 | case INAT_MAKE_PREFIX(INAT_PFX_CS): | ||
137 | idx = INAT_SEG_REG_CS; | ||
138 | diff --git a/drivers/gpu/drm/i915/gt/intel_mocs.c b/drivers/gpu/drm/i915/gt/intel_mocs.c | ||
139 | index cea184a7dde9d..e97a2aa31485c 100644 | ||
140 | --- a/drivers/gpu/drm/i915/gt/intel_mocs.c | ||
141 | +++ b/drivers/gpu/drm/i915/gt/intel_mocs.c | ||
142 | @@ -130,7 +130,19 @@ static const struct drm_i915_mocs_entry skylake_mocs_table[] = { | ||
143 | GEN9_MOCS_ENTRIES, | ||
144 | MOCS_ENTRY(I915_MOCS_CACHED, | ||
145 | LE_3_WB | LE_TC_2_LLC_ELLC | LE_LRUM(3), | ||
146 | - L3_3_WB) | ||
147 | + L3_3_WB), | ||
148 | + | ||
149 | + /* | ||
150 | + * mocs:63 | ||
151 | + * - used by the L3 for all of its evictions. | ||
152 | + * Thus it is expected to allow LLC cacheability to enable coherent | ||
153 | + * flows to be maintained. | ||
154 | + * - used to force L3 uncachable cycles. | ||
155 | + * Thus it is expected to make the surface L3 uncacheable. | ||
156 | + */ | ||
157 | + MOCS_ENTRY(63, | ||
158 | + LE_3_WB | LE_TC_1_LLC | LE_LRUM(3), | ||
159 | + L3_1_UC) | ||
160 | }; | ||
161 | |||
162 | /* NOTE: the LE_TGT_CACHE is not used on Broxton */ | ||
163 | diff --git a/drivers/i2c/busses/i2c-imx.c b/drivers/i2c/busses/i2c-imx.c | ||
164 | index 9543c9816eed9..9d3f42fd63522 100644 | ||
165 | --- a/drivers/i2c/busses/i2c-imx.c | ||
166 | +++ b/drivers/i2c/busses/i2c-imx.c | ||
167 | @@ -414,6 +414,19 @@ static void i2c_imx_dma_free(struct imx_i2c_struct *i2c_imx) | ||
168 | dma->chan_using = NULL; | ||
169 | } | ||
170 | |||
171 | +static void i2c_imx_clear_irq(struct imx_i2c_struct *i2c_imx, unsigned int bits) | ||
172 | +{ | ||
173 | + unsigned int temp; | ||
174 | + | ||
175 | + /* | ||
176 | + * i2sr_clr_opcode is the value to clear all interrupts. Here we want to | ||
177 | + * clear only <bits>, so we write ~i2sr_clr_opcode with just <bits> | ||
178 | + * toggled. This is required because i.MX needs W0C and Vybrid uses W1C. | ||
179 | + */ | ||
180 | + temp = ~i2c_imx->hwdata->i2sr_clr_opcode ^ bits; | ||
181 | + imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2SR); | ||
182 | +} | ||
183 | + | ||
184 | static int i2c_imx_bus_busy(struct imx_i2c_struct *i2c_imx, int for_busy) | ||
185 | { | ||
186 | unsigned long orig_jiffies = jiffies; | ||
187 | @@ -426,8 +439,7 @@ static int i2c_imx_bus_busy(struct imx_i2c_struct *i2c_imx, int for_busy) | ||
188 | |||
189 | /* check for arbitration lost */ | ||
190 | if (temp & I2SR_IAL) { | ||
191 | - temp &= ~I2SR_IAL; | ||
192 | - imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2SR); | ||
193 | + i2c_imx_clear_irq(i2c_imx, I2SR_IAL); | ||
194 | return -EAGAIN; | ||
195 | } | ||
196 | |||
197 | @@ -458,6 +470,16 @@ static int i2c_imx_trx_complete(struct imx_i2c_struct *i2c_imx) | ||
198 | dev_dbg(&i2c_imx->adapter.dev, "<%s> Timeout\n", __func__); | ||
199 | return -ETIMEDOUT; | ||
200 | } | ||
201 | + | ||
202 | + /* check for arbitration lost */ | ||
203 | + if (i2c_imx->i2csr & I2SR_IAL) { | ||
204 | + dev_dbg(&i2c_imx->adapter.dev, "<%s> Arbitration lost\n", __func__); | ||
205 | + i2c_imx_clear_irq(i2c_imx, I2SR_IAL); | ||
206 | + | ||
207 | + i2c_imx->i2csr = 0; | ||
208 | + return -EAGAIN; | ||
209 | + } | ||
210 | + | ||
211 | dev_dbg(&i2c_imx->adapter.dev, "<%s> TRX complete\n", __func__); | ||
212 | i2c_imx->i2csr = 0; | ||
213 | return 0; | ||
214 | @@ -567,6 +589,8 @@ static void i2c_imx_stop(struct imx_i2c_struct *i2c_imx) | ||
215 | /* Stop I2C transaction */ | ||
216 | dev_dbg(&i2c_imx->adapter.dev, "<%s>\n", __func__); | ||
217 | temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR); | ||
218 | + if (!(temp & I2CR_MSTA)) | ||
219 | + i2c_imx->stopped = 1; | ||
220 | temp &= ~(I2CR_MSTA | I2CR_MTX); | ||
221 | if (i2c_imx->dma) | ||
222 | temp &= ~I2CR_DMAEN; | ||
223 | @@ -597,9 +621,7 @@ static irqreturn_t i2c_imx_isr(int irq, void *dev_id) | ||
224 | if (temp & I2SR_IIF) { | ||
225 | /* save status register */ | ||
226 | i2c_imx->i2csr = temp; | ||
227 | - temp &= ~I2SR_IIF; | ||
228 | - temp |= (i2c_imx->hwdata->i2sr_clr_opcode & I2SR_IIF); | ||
229 | - imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2SR); | ||
230 | + i2c_imx_clear_irq(i2c_imx, I2SR_IIF); | ||
231 | wake_up(&i2c_imx->queue); | ||
232 | return IRQ_HANDLED; | ||
233 | } | ||
234 | @@ -732,9 +754,12 @@ static int i2c_imx_dma_read(struct imx_i2c_struct *i2c_imx, | ||
235 | */ | ||
236 | dev_dbg(dev, "<%s> clear MSTA\n", __func__); | ||
237 | temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR); | ||
238 | + if (!(temp & I2CR_MSTA)) | ||
239 | + i2c_imx->stopped = 1; | ||
240 | temp &= ~(I2CR_MSTA | I2CR_MTX); | ||
241 | imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR); | ||
242 | - i2c_imx_bus_busy(i2c_imx, 0); | ||
243 | + if (!i2c_imx->stopped) | ||
244 | + i2c_imx_bus_busy(i2c_imx, 0); | ||
245 | } else { | ||
246 | /* | ||
247 | * For i2c master receiver repeat restart operation like: | ||
248 | @@ -857,9 +882,12 @@ static int i2c_imx_read(struct imx_i2c_struct *i2c_imx, struct i2c_msg *msgs, bo | ||
249 | dev_dbg(&i2c_imx->adapter.dev, | ||
250 | "<%s> clear MSTA\n", __func__); | ||
251 | temp = imx_i2c_read_reg(i2c_imx, IMX_I2C_I2CR); | ||
252 | + if (!(temp & I2CR_MSTA)) | ||
253 | + i2c_imx->stopped = 1; | ||
254 | temp &= ~(I2CR_MSTA | I2CR_MTX); | ||
255 | imx_i2c_write_reg(temp, i2c_imx, IMX_I2C_I2CR); | ||
256 | - i2c_imx_bus_busy(i2c_imx, 0); | ||
257 | + if (!i2c_imx->stopped) | ||
258 | + i2c_imx_bus_busy(i2c_imx, 0); | ||
259 | } else { | ||
260 | /* | ||
261 | * For i2c master receiver repeat restart operation like: | ||
262 | diff --git a/drivers/i2c/busses/i2c-qup.c b/drivers/i2c/busses/i2c-qup.c | ||
263 | index e09cd0775ae91..3417f7dffa943 100644 | ||
264 | --- a/drivers/i2c/busses/i2c-qup.c | ||
265 | +++ b/drivers/i2c/busses/i2c-qup.c | ||
266 | @@ -806,7 +806,8 @@ static int qup_i2c_bam_schedule_desc(struct qup_i2c_dev *qup) | ||
267 | if (ret || qup->bus_err || qup->qup_err) { | ||
268 | reinit_completion(&qup->xfer); | ||
269 | |||
270 | - if (qup_i2c_change_state(qup, QUP_RUN_STATE)) { | ||
271 | + ret = qup_i2c_change_state(qup, QUP_RUN_STATE); | ||
272 | + if (ret) { | ||
273 | dev_err(qup->dev, "change to run state timed out"); | ||
274 | goto desc_err; | ||
275 | } | ||
276 | diff --git a/drivers/input/serio/i8042.c b/drivers/input/serio/i8042.c | ||
277 | index 5a89c1cfdaa97..6ff6b5710dd4e 100644 | ||
278 | --- a/drivers/input/serio/i8042.c | ||
279 | +++ b/drivers/input/serio/i8042.c | ||
280 | @@ -1468,7 +1468,8 @@ static int __init i8042_setup_aux(void) | ||
281 | if (error) | ||
282 | goto err_free_ports; | ||
283 | |||
284 | - if (aux_enable()) | ||
285 | + error = aux_enable(); | ||
286 | + if (error) | ||
287 | goto err_free_irq; | ||
288 | |||
289 | i8042_aux_irq_registered = true; | ||
290 | diff --git a/drivers/iommu/amd_iommu_types.h b/drivers/iommu/amd_iommu_types.h | ||
291 | index 3ec090adcdae7..76e9d3e2f9f20 100644 | ||
292 | --- a/drivers/iommu/amd_iommu_types.h | ||
293 | +++ b/drivers/iommu/amd_iommu_types.h | ||
294 | @@ -254,7 +254,7 @@ | ||
295 | #define DTE_IRQ_REMAP_INTCTL_MASK (0x3ULL << 60) | ||
296 | #define DTE_IRQ_TABLE_LEN_MASK (0xfULL << 1) | ||
297 | #define DTE_IRQ_REMAP_INTCTL (2ULL << 60) | ||
298 | -#define DTE_IRQ_TABLE_LEN (8ULL << 1) | ||
299 | +#define DTE_IRQ_TABLE_LEN (9ULL << 1) | ||
300 | #define DTE_IRQ_REMAP_ENABLE 1ULL | ||
301 | |||
302 | #define PAGE_MODE_NONE 0x00 | ||
303 | diff --git a/drivers/md/dm-writecache.c b/drivers/md/dm-writecache.c | ||
304 | index 4e414b06192eb..08ae59a6e8734 100644 | ||
305 | --- a/drivers/md/dm-writecache.c | ||
306 | +++ b/drivers/md/dm-writecache.c | ||
307 | @@ -316,7 +316,7 @@ err1: | ||
308 | #else | ||
309 | static int persistent_memory_claim(struct dm_writecache *wc) | ||
310 | { | ||
311 | - BUG(); | ||
312 | + return -EOPNOTSUPP; | ||
313 | } | ||
314 | #endif | ||
315 | |||
316 | @@ -1889,7 +1889,7 @@ static int writecache_ctr(struct dm_target *ti, unsigned argc, char **argv) | ||
317 | struct wc_memory_superblock s; | ||
318 | |||
319 | static struct dm_arg _args[] = { | ||
320 | - {0, 10, "Invalid number of feature args"}, | ||
321 | + {0, 16, "Invalid number of feature args"}, | ||
322 | }; | ||
323 | |||
324 | as.argc = argc; | ||
325 | diff --git a/drivers/md/dm.c b/drivers/md/dm.c | ||
326 | index 667db23f10ee1..bf3c2a1159e68 100644 | ||
327 | --- a/drivers/md/dm.c | ||
328 | +++ b/drivers/md/dm.c | ||
329 | @@ -455,8 +455,10 @@ static int dm_blk_report_zones(struct gendisk *disk, sector_t sector, | ||
330 | return -EAGAIN; | ||
331 | |||
332 | map = dm_get_live_table(md, &srcu_idx); | ||
333 | - if (!map) | ||
334 | - return -EIO; | ||
335 | + if (!map) { | ||
336 | + ret = -EIO; | ||
337 | + goto out; | ||
338 | + } | ||
339 | |||
340 | tgt = dm_table_find_target(map, sector); | ||
341 | if (!tgt) { | ||
342 | @@ -493,7 +495,6 @@ out: | ||
343 | |||
344 | static int dm_prepare_ioctl(struct mapped_device *md, int *srcu_idx, | ||
345 | struct block_device **bdev) | ||
346 | - __acquires(md->io_barrier) | ||
347 | { | ||
348 | struct dm_target *tgt; | ||
349 | struct dm_table *map; | ||
350 | @@ -527,7 +528,6 @@ retry: | ||
351 | } | ||
352 | |||
353 | static void dm_unprepare_ioctl(struct mapped_device *md, int srcu_idx) | ||
354 | - __releases(md->io_barrier) | ||
355 | { | ||
356 | dm_put_live_table(md, srcu_idx); | ||
357 | } | ||
358 | diff --git a/drivers/net/geneve.c b/drivers/net/geneve.c | ||
359 | index 496ae07aca5e5..c7ec3d24eabc8 100644 | ||
360 | --- a/drivers/net/geneve.c | ||
361 | +++ b/drivers/net/geneve.c | ||
362 | @@ -254,21 +254,11 @@ static void geneve_rx(struct geneve_dev *geneve, struct geneve_sock *gs, | ||
363 | skb_dst_set(skb, &tun_dst->dst); | ||
364 | |||
365 | /* Ignore packet loops (and multicast echo) */ | ||
366 | - if (ether_addr_equal(eth_hdr(skb)->h_source, geneve->dev->dev_addr)) | ||
367 | - goto rx_error; | ||
368 | - | ||
369 | - switch (skb_protocol(skb, true)) { | ||
370 | - case htons(ETH_P_IP): | ||
371 | - if (pskb_may_pull(skb, sizeof(struct iphdr))) | ||
372 | - goto rx_error; | ||
373 | - break; | ||
374 | - case htons(ETH_P_IPV6): | ||
375 | - if (pskb_may_pull(skb, sizeof(struct ipv6hdr))) | ||
376 | - goto rx_error; | ||
377 | - break; | ||
378 | - default: | ||
379 | - goto rx_error; | ||
380 | + if (ether_addr_equal(eth_hdr(skb)->h_source, geneve->dev->dev_addr)) { | ||
381 | + geneve->dev->stats.rx_errors++; | ||
382 | + goto drop; | ||
383 | } | ||
384 | + | ||
385 | oiph = skb_network_header(skb); | ||
386 | skb_reset_network_header(skb); | ||
387 | |||
388 | @@ -309,8 +299,6 @@ static void geneve_rx(struct geneve_dev *geneve, struct geneve_sock *gs, | ||
389 | u64_stats_update_end(&stats->syncp); | ||
390 | } | ||
391 | return; | ||
392 | -rx_error: | ||
393 | - geneve->dev->stats.rx_errors++; | ||
394 | drop: | ||
395 | /* Consume bad packet */ | ||
396 | kfree_skb(skb); | ||
397 | diff --git a/drivers/net/wireless/realtek/rtw88/debug.c b/drivers/net/wireless/realtek/rtw88/debug.c | ||
398 | index 6ad985e98e425..5a906101498d9 100644 | ||
399 | --- a/drivers/net/wireless/realtek/rtw88/debug.c | ||
400 | +++ b/drivers/net/wireless/realtek/rtw88/debug.c | ||
401 | @@ -146,6 +146,8 @@ static int rtw_debugfs_copy_from_user(char tmp[], int size, | ||
402 | { | ||
403 | int tmp_len; | ||
404 | |||
405 | + memset(tmp, 0, size); | ||
406 | + | ||
407 | if (count < num) | ||
408 | return -EFAULT; | ||
409 | |||
410 | diff --git a/drivers/pinctrl/intel/pinctrl-baytrail.c b/drivers/pinctrl/intel/pinctrl-baytrail.c | ||
411 | index cae7caf5ab282..5a1174a8e2bac 100644 | ||
412 | --- a/drivers/pinctrl/intel/pinctrl-baytrail.c | ||
413 | +++ b/drivers/pinctrl/intel/pinctrl-baytrail.c | ||
414 | @@ -811,6 +811,21 @@ static void byt_gpio_disable_free(struct pinctrl_dev *pctl_dev, | ||
415 | pm_runtime_put(&vg->pdev->dev); | ||
416 | } | ||
417 | |||
418 | +static void byt_gpio_direct_irq_check(struct byt_gpio *vg, | ||
419 | + unsigned int offset) | ||
420 | +{ | ||
421 | + void __iomem *conf_reg = byt_gpio_reg(vg, offset, BYT_CONF0_REG); | ||
422 | + | ||
423 | + /* | ||
424 | + * Before making any direction modifications, do a check if gpio is set | ||
425 | + * for direct IRQ. On Bay Trail, setting GPIO to output does not make | ||
426 | + * sense, so let's at least inform the caller before they shoot | ||
427 | + * themselves in the foot. | ||
428 | + */ | ||
429 | + if (readl(conf_reg) & BYT_DIRECT_IRQ_EN) | ||
430 | + dev_info_once(&vg->pdev->dev, "Potential Error: Setting GPIO with direct_irq_en to output"); | ||
431 | +} | ||
432 | + | ||
433 | static int byt_gpio_set_direction(struct pinctrl_dev *pctl_dev, | ||
434 | struct pinctrl_gpio_range *range, | ||
435 | unsigned int offset, | ||
436 | @@ -818,7 +833,6 @@ static int byt_gpio_set_direction(struct pinctrl_dev *pctl_dev, | ||
437 | { | ||
438 | struct byt_gpio *vg = pinctrl_dev_get_drvdata(pctl_dev); | ||
439 | void __iomem *val_reg = byt_gpio_reg(vg, offset, BYT_VAL_REG); | ||
440 | - void __iomem *conf_reg = byt_gpio_reg(vg, offset, BYT_CONF0_REG); | ||
441 | unsigned long flags; | ||
442 | u32 value; | ||
443 | |||
444 | @@ -829,14 +843,8 @@ static int byt_gpio_set_direction(struct pinctrl_dev *pctl_dev, | ||
445 | if (input) | ||
446 | value |= BYT_OUTPUT_EN; | ||
447 | else | ||
448 | - /* | ||
449 | - * Before making any direction modifications, do a check if gpio | ||
450 | - * is set for direct IRQ. On baytrail, setting GPIO to output | ||
451 | - * does not make sense, so let's at least warn the caller before | ||
452 | - * they shoot themselves in the foot. | ||
453 | - */ | ||
454 | - WARN(readl(conf_reg) & BYT_DIRECT_IRQ_EN, | ||
455 | - "Potential Error: Setting GPIO with direct_irq_en to output"); | ||
456 | + byt_gpio_direct_irq_check(vg, offset); | ||
457 | + | ||
458 | writel(value, val_reg); | ||
459 | |||
460 | raw_spin_unlock_irqrestore(&byt_lock, flags); | ||
461 | @@ -1176,19 +1184,50 @@ static int byt_gpio_get_direction(struct gpio_chip *chip, unsigned int offset) | ||
462 | |||
463 | static int byt_gpio_direction_input(struct gpio_chip *chip, unsigned int offset) | ||
464 | { | ||
465 | - return pinctrl_gpio_direction_input(chip->base + offset); | ||
466 | + struct byt_gpio *vg = gpiochip_get_data(chip); | ||
467 | + void __iomem *val_reg = byt_gpio_reg(vg, offset, BYT_VAL_REG); | ||
468 | + unsigned long flags; | ||
469 | + u32 reg; | ||
470 | + | ||
471 | + raw_spin_lock_irqsave(&byt_lock, flags); | ||
472 | + | ||
473 | + reg = readl(val_reg); | ||
474 | + reg &= ~BYT_DIR_MASK; | ||
475 | + reg |= BYT_OUTPUT_EN; | ||
476 | + writel(reg, val_reg); | ||
477 | + | ||
478 | + raw_spin_unlock_irqrestore(&byt_lock, flags); | ||
479 | + return 0; | ||
480 | } | ||
481 | |||
482 | +/* | ||
483 | + * Note despite the temptation this MUST NOT be converted into a call to | ||
484 | + * pinctrl_gpio_direction_output() + byt_gpio_set() that does not work this | ||
485 | + * MUST be done as a single BYT_VAL_REG register write. | ||
486 | + * See the commit message of the commit adding this comment for details. | ||
487 | + */ | ||
488 | static int byt_gpio_direction_output(struct gpio_chip *chip, | ||
489 | unsigned int offset, int value) | ||
490 | { | ||
491 | - int ret = pinctrl_gpio_direction_output(chip->base + offset); | ||
492 | + struct byt_gpio *vg = gpiochip_get_data(chip); | ||
493 | + void __iomem *val_reg = byt_gpio_reg(vg, offset, BYT_VAL_REG); | ||
494 | + unsigned long flags; | ||
495 | + u32 reg; | ||
496 | |||
497 | - if (ret) | ||
498 | - return ret; | ||
499 | + raw_spin_lock_irqsave(&byt_lock, flags); | ||
500 | |||
501 | - byt_gpio_set(chip, offset, value); | ||
502 | + byt_gpio_direct_irq_check(vg, offset); | ||
503 | |||
504 | + reg = readl(val_reg); | ||
505 | + reg &= ~BYT_DIR_MASK; | ||
506 | + if (value) | ||
507 | + reg |= BYT_LEVEL; | ||
508 | + else | ||
509 | + reg &= ~BYT_LEVEL; | ||
510 | + | ||
511 | + writel(reg, val_reg); | ||
512 | + | ||
513 | + raw_spin_unlock_irqrestore(&byt_lock, flags); | ||
514 | return 0; | ||
515 | } | ||
516 | |||
517 | diff --git a/drivers/scsi/mpt3sas/mpt3sas_ctl.c b/drivers/scsi/mpt3sas/mpt3sas_ctl.c | ||
518 | index bae7cf70ee177..1c5c172315de4 100644 | ||
519 | --- a/drivers/scsi/mpt3sas/mpt3sas_ctl.c | ||
520 | +++ b/drivers/scsi/mpt3sas/mpt3sas_ctl.c | ||
521 | @@ -650,7 +650,7 @@ _ctl_do_mpt_command(struct MPT3SAS_ADAPTER *ioc, struct mpt3_ioctl_command karg, | ||
522 | Mpi26NVMeEncapsulatedRequest_t *nvme_encap_request = NULL; | ||
523 | struct _pcie_device *pcie_device = NULL; | ||
524 | u16 smid; | ||
525 | - u8 timeout; | ||
526 | + unsigned long timeout; | ||
527 | u8 issue_reset; | ||
528 | u32 sz, sz_arg; | ||
529 | void *psge; | ||
530 | diff --git a/drivers/spi/spi-bcm2835.c b/drivers/spi/spi-bcm2835.c | ||
531 | index 5bc97b22491cd..56ee84e85bee2 100644 | ||
532 | --- a/drivers/spi/spi-bcm2835.c | ||
533 | +++ b/drivers/spi/spi-bcm2835.c | ||
534 | @@ -1310,21 +1310,22 @@ static int bcm2835_spi_probe(struct platform_device *pdev) | ||
535 | dev_name(&pdev->dev), ctlr); | ||
536 | if (err) { | ||
537 | dev_err(&pdev->dev, "could not request IRQ: %d\n", err); | ||
538 | - goto out_clk_disable; | ||
539 | + goto out_dma_release; | ||
540 | } | ||
541 | |||
542 | err = spi_register_controller(ctlr); | ||
543 | if (err) { | ||
544 | dev_err(&pdev->dev, "could not register SPI controller: %d\n", | ||
545 | err); | ||
546 | - goto out_clk_disable; | ||
547 | + goto out_dma_release; | ||
548 | } | ||
549 | |||
550 | bcm2835_debugfs_create(bs, dev_name(&pdev->dev)); | ||
551 | |||
552 | return 0; | ||
553 | |||
554 | -out_clk_disable: | ||
555 | +out_dma_release: | ||
556 | + bcm2835_dma_release(ctlr, bs); | ||
557 | clk_disable_unprepare(bs->clk); | ||
558 | return err; | ||
559 | } | ||
560 | diff --git a/drivers/staging/speakup/spk_ttyio.c b/drivers/staging/speakup/spk_ttyio.c | ||
561 | index 9917dbce24703..472804c3f44dc 100644 | ||
562 | --- a/drivers/staging/speakup/spk_ttyio.c | ||
563 | +++ b/drivers/staging/speakup/spk_ttyio.c | ||
564 | @@ -47,27 +47,20 @@ static int spk_ttyio_ldisc_open(struct tty_struct *tty) | ||
565 | { | ||
566 | struct spk_ldisc_data *ldisc_data; | ||
567 | |||
568 | + if (tty != speakup_tty) | ||
569 | + /* Somebody tried to use this line discipline outside speakup */ | ||
570 | + return -ENODEV; | ||
571 | + | ||
572 | if (!tty->ops->write) | ||
573 | return -EOPNOTSUPP; | ||
574 | |||
575 | - mutex_lock(&speakup_tty_mutex); | ||
576 | - if (speakup_tty) { | ||
577 | - mutex_unlock(&speakup_tty_mutex); | ||
578 | - return -EBUSY; | ||
579 | - } | ||
580 | - speakup_tty = tty; | ||
581 | - | ||
582 | ldisc_data = kmalloc(sizeof(struct spk_ldisc_data), GFP_KERNEL); | ||
583 | - if (!ldisc_data) { | ||
584 | - speakup_tty = NULL; | ||
585 | - mutex_unlock(&speakup_tty_mutex); | ||
586 | + if (!ldisc_data) | ||
587 | return -ENOMEM; | ||
588 | - } | ||
589 | |||
590 | init_completion(&ldisc_data->completion); | ||
591 | ldisc_data->buf_free = true; | ||
592 | - speakup_tty->disc_data = ldisc_data; | ||
593 | - mutex_unlock(&speakup_tty_mutex); | ||
594 | + tty->disc_data = ldisc_data; | ||
595 | |||
596 | return 0; | ||
597 | } | ||
598 | @@ -189,9 +182,25 @@ static int spk_ttyio_initialise_ldisc(struct spk_synth *synth) | ||
599 | |||
600 | tty_unlock(tty); | ||
601 | |||
602 | + mutex_lock(&speakup_tty_mutex); | ||
603 | + speakup_tty = tty; | ||
604 | ret = tty_set_ldisc(tty, N_SPEAKUP); | ||
605 | if (ret) | ||
606 | - pr_err("speakup: Failed to set N_SPEAKUP on tty\n"); | ||
607 | + speakup_tty = NULL; | ||
608 | + mutex_unlock(&speakup_tty_mutex); | ||
609 | + | ||
610 | + if (!ret) | ||
611 | + /* Success */ | ||
612 | + return 0; | ||
613 | + | ||
614 | + pr_err("speakup: Failed to set N_SPEAKUP on tty\n"); | ||
615 | + | ||
616 | + tty_lock(tty); | ||
617 | + if (tty->ops->close) | ||
618 | + tty->ops->close(tty, NULL); | ||
619 | + tty_unlock(tty); | ||
620 | + | ||
621 | + tty_kclose(tty); | ||
622 | |||
623 | return ret; | ||
624 | } | ||
625 | diff --git a/drivers/thunderbolt/icm.c b/drivers/thunderbolt/icm.c | ||
626 | index 245588f691e79..2f932b61b69ad 100644 | ||
627 | --- a/drivers/thunderbolt/icm.c | ||
628 | +++ b/drivers/thunderbolt/icm.c | ||
629 | @@ -1919,7 +1919,9 @@ static int complete_rpm(struct device *dev, void *data) | ||
630 | |||
631 | static void remove_unplugged_switch(struct tb_switch *sw) | ||
632 | { | ||
633 | - pm_runtime_get_sync(sw->dev.parent); | ||
634 | + struct device *parent = get_device(sw->dev.parent); | ||
635 | + | ||
636 | + pm_runtime_get_sync(parent); | ||
637 | |||
638 | /* | ||
639 | * Signal this and switches below for rpm_complete because | ||
640 | @@ -1930,8 +1932,10 @@ static void remove_unplugged_switch(struct tb_switch *sw) | ||
641 | bus_for_each_dev(&tb_bus_type, &sw->dev, NULL, complete_rpm); | ||
642 | tb_switch_remove(sw); | ||
643 | |||
644 | - pm_runtime_mark_last_busy(sw->dev.parent); | ||
645 | - pm_runtime_put_autosuspend(sw->dev.parent); | ||
646 | + pm_runtime_mark_last_busy(parent); | ||
647 | + pm_runtime_put_autosuspend(parent); | ||
648 | + | ||
649 | + put_device(parent); | ||
650 | } | ||
651 | |||
652 | static void icm_free_unplugged_children(struct tb_switch *sw) | ||
653 | diff --git a/drivers/tty/tty_io.c b/drivers/tty/tty_io.c | ||
654 | index 36c1c59cc72a2..642765bf10230 100644 | ||
655 | --- a/drivers/tty/tty_io.c | ||
656 | +++ b/drivers/tty/tty_io.c | ||
657 | @@ -2894,10 +2894,14 @@ void __do_SAK(struct tty_struct *tty) | ||
658 | struct task_struct *g, *p; | ||
659 | struct pid *session; | ||
660 | int i; | ||
661 | + unsigned long flags; | ||
662 | |||
663 | if (!tty) | ||
664 | return; | ||
665 | - session = tty->session; | ||
666 | + | ||
667 | + spin_lock_irqsave(&tty->ctrl_lock, flags); | ||
668 | + session = get_pid(tty->session); | ||
669 | + spin_unlock_irqrestore(&tty->ctrl_lock, flags); | ||
670 | |||
671 | tty_ldisc_flush(tty); | ||
672 | |||
673 | @@ -2929,6 +2933,7 @@ void __do_SAK(struct tty_struct *tty) | ||
674 | task_unlock(p); | ||
675 | } while_each_thread(g, p); | ||
676 | read_unlock(&tasklist_lock); | ||
677 | + put_pid(session); | ||
678 | #endif | ||
679 | } | ||
680 | |||
681 | diff --git a/drivers/tty/tty_jobctrl.c b/drivers/tty/tty_jobctrl.c | ||
682 | index f8ed50a168481..813be2c052629 100644 | ||
683 | --- a/drivers/tty/tty_jobctrl.c | ||
684 | +++ b/drivers/tty/tty_jobctrl.c | ||
685 | @@ -103,8 +103,8 @@ static void __proc_set_tty(struct tty_struct *tty) | ||
686 | put_pid(tty->session); | ||
687 | put_pid(tty->pgrp); | ||
688 | tty->pgrp = get_pid(task_pgrp(current)); | ||
689 | - spin_unlock_irqrestore(&tty->ctrl_lock, flags); | ||
690 | tty->session = get_pid(task_session(current)); | ||
691 | + spin_unlock_irqrestore(&tty->ctrl_lock, flags); | ||
692 | if (current->signal->tty) { | ||
693 | tty_debug(tty, "current tty %s not NULL!!\n", | ||
694 | current->signal->tty->name); | ||
695 | @@ -293,20 +293,23 @@ void disassociate_ctty(int on_exit) | ||
696 | spin_lock_irq(¤t->sighand->siglock); | ||
697 | put_pid(current->signal->tty_old_pgrp); | ||
698 | current->signal->tty_old_pgrp = NULL; | ||
699 | - | ||
700 | tty = tty_kref_get(current->signal->tty); | ||
701 | + spin_unlock_irq(¤t->sighand->siglock); | ||
702 | + | ||
703 | if (tty) { | ||
704 | unsigned long flags; | ||
705 | + | ||
706 | + tty_lock(tty); | ||
707 | spin_lock_irqsave(&tty->ctrl_lock, flags); | ||
708 | put_pid(tty->session); | ||
709 | put_pid(tty->pgrp); | ||
710 | tty->session = NULL; | ||
711 | tty->pgrp = NULL; | ||
712 | spin_unlock_irqrestore(&tty->ctrl_lock, flags); | ||
713 | + tty_unlock(tty); | ||
714 | tty_kref_put(tty); | ||
715 | } | ||
716 | |||
717 | - spin_unlock_irq(¤t->sighand->siglock); | ||
718 | /* Now clear signal->tty under the lock */ | ||
719 | read_lock(&tasklist_lock); | ||
720 | session_clear_tty(task_session(current)); | ||
721 | @@ -477,14 +480,19 @@ static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t | ||
722 | return -ENOTTY; | ||
723 | if (retval) | ||
724 | return retval; | ||
725 | - if (!current->signal->tty || | ||
726 | - (current->signal->tty != real_tty) || | ||
727 | - (real_tty->session != task_session(current))) | ||
728 | - return -ENOTTY; | ||
729 | + | ||
730 | if (get_user(pgrp_nr, p)) | ||
731 | return -EFAULT; | ||
732 | if (pgrp_nr < 0) | ||
733 | return -EINVAL; | ||
734 | + | ||
735 | + spin_lock_irq(&real_tty->ctrl_lock); | ||
736 | + if (!current->signal->tty || | ||
737 | + (current->signal->tty != real_tty) || | ||
738 | + (real_tty->session != task_session(current))) { | ||
739 | + retval = -ENOTTY; | ||
740 | + goto out_unlock_ctrl; | ||
741 | + } | ||
742 | rcu_read_lock(); | ||
743 | pgrp = find_vpid(pgrp_nr); | ||
744 | retval = -ESRCH; | ||
745 | @@ -494,12 +502,12 @@ static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t | ||
746 | if (session_of_pgrp(pgrp) != task_session(current)) | ||
747 | goto out_unlock; | ||
748 | retval = 0; | ||
749 | - spin_lock_irq(&tty->ctrl_lock); | ||
750 | put_pid(real_tty->pgrp); | ||
751 | real_tty->pgrp = get_pid(pgrp); | ||
752 | - spin_unlock_irq(&tty->ctrl_lock); | ||
753 | out_unlock: | ||
754 | rcu_read_unlock(); | ||
755 | +out_unlock_ctrl: | ||
756 | + spin_unlock_irq(&real_tty->ctrl_lock); | ||
757 | return retval; | ||
758 | } | ||
759 | |||
760 | @@ -511,20 +519,30 @@ out_unlock: | ||
761 | * | ||
762 | * Obtain the session id of the tty. If there is no session | ||
763 | * return an error. | ||
764 | - * | ||
765 | - * Locking: none. Reference to current->signal->tty is safe. | ||
766 | */ | ||
767 | static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p) | ||
768 | { | ||
769 | + unsigned long flags; | ||
770 | + pid_t sid; | ||
771 | + | ||
772 | /* | ||
773 | * (tty == real_tty) is a cheap way of | ||
774 | * testing if the tty is NOT a master pty. | ||
775 | */ | ||
776 | if (tty == real_tty && current->signal->tty != real_tty) | ||
777 | return -ENOTTY; | ||
778 | + | ||
779 | + spin_lock_irqsave(&real_tty->ctrl_lock, flags); | ||
780 | if (!real_tty->session) | ||
781 | - return -ENOTTY; | ||
782 | - return put_user(pid_vnr(real_tty->session), p); | ||
783 | + goto err; | ||
784 | + sid = pid_vnr(real_tty->session); | ||
785 | + spin_unlock_irqrestore(&real_tty->ctrl_lock, flags); | ||
786 | + | ||
787 | + return put_user(sid, p); | ||
788 | + | ||
789 | +err: | ||
790 | + spin_unlock_irqrestore(&real_tty->ctrl_lock, flags); | ||
791 | + return -ENOTTY; | ||
792 | } | ||
793 | |||
794 | /* | ||
795 | diff --git a/drivers/usb/gadget/function/f_fs.c b/drivers/usb/gadget/function/f_fs.c | ||
796 | index f8bcfc506f4a3..d2cfb8ff9ca8a 100644 | ||
797 | --- a/drivers/usb/gadget/function/f_fs.c | ||
798 | +++ b/drivers/usb/gadget/function/f_fs.c | ||
799 | @@ -1328,7 +1328,7 @@ static long ffs_epfile_ioctl(struct file *file, unsigned code, | ||
800 | case FUNCTIONFS_ENDPOINT_DESC: | ||
801 | { | ||
802 | int desc_idx; | ||
803 | - struct usb_endpoint_descriptor *desc; | ||
804 | + struct usb_endpoint_descriptor desc1, *desc; | ||
805 | |||
806 | switch (epfile->ffs->gadget->speed) { | ||
807 | case USB_SPEED_SUPER: | ||
808 | @@ -1340,10 +1340,12 @@ static long ffs_epfile_ioctl(struct file *file, unsigned code, | ||
809 | default: | ||
810 | desc_idx = 0; | ||
811 | } | ||
812 | + | ||
813 | desc = epfile->ep->descs[desc_idx]; | ||
814 | + memcpy(&desc1, desc, desc->bLength); | ||
815 | |||
816 | spin_unlock_irq(&epfile->ffs->eps_lock); | ||
817 | - ret = copy_to_user((void __user *)value, desc, desc->bLength); | ||
818 | + ret = copy_to_user((void __user *)value, &desc1, desc1.bLength); | ||
819 | if (ret) | ||
820 | ret = -EFAULT; | ||
821 | return ret; | ||
822 | diff --git a/drivers/usb/serial/ch341.c b/drivers/usb/serial/ch341.c | ||
823 | index 390bc4b250453..fdaefbe924908 100644 | ||
824 | --- a/drivers/usb/serial/ch341.c | ||
825 | +++ b/drivers/usb/serial/ch341.c | ||
826 | @@ -80,10 +80,11 @@ | ||
827 | #define CH341_LCR_CS5 0x00 | ||
828 | |||
829 | static const struct usb_device_id id_table[] = { | ||
830 | - { USB_DEVICE(0x4348, 0x5523) }, | ||
831 | + { USB_DEVICE(0x1a86, 0x5512) }, | ||
832 | + { USB_DEVICE(0x1a86, 0x5523) }, | ||
833 | { USB_DEVICE(0x1a86, 0x7522) }, | ||
834 | { USB_DEVICE(0x1a86, 0x7523) }, | ||
835 | - { USB_DEVICE(0x1a86, 0x5523) }, | ||
836 | + { USB_DEVICE(0x4348, 0x5523) }, | ||
837 | { }, | ||
838 | }; | ||
839 | MODULE_DEVICE_TABLE(usb, id_table); | ||
840 | diff --git a/drivers/usb/serial/kl5kusb105.c b/drivers/usb/serial/kl5kusb105.c | ||
841 | index 5ee48b0650c45..5f6b82ebccc5a 100644 | ||
842 | --- a/drivers/usb/serial/kl5kusb105.c | ||
843 | +++ b/drivers/usb/serial/kl5kusb105.c | ||
844 | @@ -276,12 +276,12 @@ static int klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port) | ||
845 | priv->cfg.unknown2 = cfg->unknown2; | ||
846 | spin_unlock_irqrestore(&priv->lock, flags); | ||
847 | |||
848 | + kfree(cfg); | ||
849 | + | ||
850 | /* READ_ON and urb submission */ | ||
851 | rc = usb_serial_generic_open(tty, port); | ||
852 | - if (rc) { | ||
853 | - retval = rc; | ||
854 | - goto err_free_cfg; | ||
855 | - } | ||
856 | + if (rc) | ||
857 | + return rc; | ||
858 | |||
859 | rc = usb_control_msg(port->serial->dev, | ||
860 | usb_sndctrlpipe(port->serial->dev, 0), | ||
861 | @@ -324,8 +324,6 @@ err_disable_read: | ||
862 | KLSI_TIMEOUT); | ||
863 | err_generic_close: | ||
864 | usb_serial_generic_close(port); | ||
865 | -err_free_cfg: | ||
866 | - kfree(cfg); | ||
867 | |||
868 | return retval; | ||
869 | } | ||
870 | diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c | ||
871 | index 741c72bd499a9..c2ef238653002 100644 | ||
872 | --- a/drivers/usb/serial/option.c | ||
873 | +++ b/drivers/usb/serial/option.c | ||
874 | @@ -419,6 +419,7 @@ static void option_instat_callback(struct urb *urb); | ||
875 | #define CINTERION_PRODUCT_PH8 0x0053 | ||
876 | #define CINTERION_PRODUCT_AHXX 0x0055 | ||
877 | #define CINTERION_PRODUCT_PLXX 0x0060 | ||
878 | +#define CINTERION_PRODUCT_EXS82 0x006c | ||
879 | #define CINTERION_PRODUCT_PH8_2RMNET 0x0082 | ||
880 | #define CINTERION_PRODUCT_PH8_AUDIO 0x0083 | ||
881 | #define CINTERION_PRODUCT_AHXX_2RMNET 0x0084 | ||
882 | @@ -1105,9 +1106,8 @@ static const struct usb_device_id option_ids[] = { | ||
883 | { USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EG95, 0xff, 0xff, 0xff), | ||
884 | .driver_info = NUMEP2 }, | ||
885 | { USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EG95, 0xff, 0, 0) }, | ||
886 | - { USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_BG96, 0xff, 0xff, 0xff), | ||
887 | - .driver_info = NUMEP2 }, | ||
888 | - { USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_BG96, 0xff, 0, 0) }, | ||
889 | + { USB_DEVICE(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_BG96), | ||
890 | + .driver_info = RSVD(4) }, | ||
891 | { USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EP06, 0xff, 0xff, 0xff), | ||
892 | .driver_info = RSVD(1) | RSVD(2) | RSVD(3) | RSVD(4) | NUMEP2 }, | ||
893 | { USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EP06, 0xff, 0, 0) }, | ||
894 | @@ -1902,6 +1902,7 @@ static const struct usb_device_id option_ids[] = { | ||
895 | { USB_DEVICE_INTERFACE_CLASS(CINTERION_VENDOR_ID, CINTERION_PRODUCT_AHXX_AUDIO, 0xff) }, | ||
896 | { USB_DEVICE_INTERFACE_CLASS(CINTERION_VENDOR_ID, CINTERION_PRODUCT_CLS8, 0xff), | ||
897 | .driver_info = RSVD(0) | RSVD(4) }, | ||
898 | + { USB_DEVICE_INTERFACE_CLASS(CINTERION_VENDOR_ID, CINTERION_PRODUCT_EXS82, 0xff) }, | ||
899 | { USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_HC28_MDM) }, | ||
900 | { USB_DEVICE(CINTERION_VENDOR_ID, CINTERION_PRODUCT_HC28_MDMNET) }, | ||
901 | { USB_DEVICE(SIEMENS_VENDOR_ID, CINTERION_PRODUCT_HC25_MDM) }, | ||
902 | @@ -2046,12 +2047,13 @@ static const struct usb_device_id option_ids[] = { | ||
903 | .driver_info = RSVD(0) | RSVD(1) | RSVD(6) }, | ||
904 | { USB_DEVICE(0x0489, 0xe0b5), /* Foxconn T77W968 ESIM */ | ||
905 | .driver_info = RSVD(0) | RSVD(1) | RSVD(6) }, | ||
906 | - { USB_DEVICE(0x1508, 0x1001), /* Fibocom NL668 */ | ||
907 | + { USB_DEVICE(0x1508, 0x1001), /* Fibocom NL668 (IOT version) */ | ||
908 | .driver_info = RSVD(4) | RSVD(5) | RSVD(6) }, | ||
909 | { USB_DEVICE(0x2cb7, 0x0104), /* Fibocom NL678 series */ | ||
910 | .driver_info = RSVD(4) | RSVD(5) }, | ||
911 | { USB_DEVICE_INTERFACE_CLASS(0x2cb7, 0x0105, 0xff), /* Fibocom NL678 series */ | ||
912 | .driver_info = RSVD(6) }, | ||
913 | + { USB_DEVICE_INTERFACE_CLASS(0x2cb7, 0x01a0, 0xff) }, /* Fibocom NL668-AM/NL652-EU (laptop MBIM) */ | ||
914 | { USB_DEVICE_INTERFACE_CLASS(0x305a, 0x1404, 0xff) }, /* GosunCn GM500 RNDIS */ | ||
915 | { USB_DEVICE_INTERFACE_CLASS(0x305a, 0x1405, 0xff) }, /* GosunCn GM500 MBIM */ | ||
916 | { USB_DEVICE_INTERFACE_CLASS(0x305a, 0x1406, 0xff) }, /* GosunCn GM500 ECM/NCM */ | ||
917 | diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c | ||
918 | index f5df2a4195c24..ab9eeb5ff8e57 100644 | ||
919 | --- a/fs/cifs/connect.c | ||
920 | +++ b/fs/cifs/connect.c | ||
921 | @@ -975,6 +975,8 @@ static void clean_demultiplex_info(struct TCP_Server_Info *server) | ||
922 | list_del_init(&server->tcp_ses_list); | ||
923 | spin_unlock(&cifs_tcp_ses_lock); | ||
924 | |||
925 | + cancel_delayed_work_sync(&server->echo); | ||
926 | + | ||
927 | spin_lock(&GlobalMid_Lock); | ||
928 | server->tcpStatus = CifsExiting; | ||
929 | spin_unlock(&GlobalMid_Lock); | ||
930 | diff --git a/fs/cifs/transport.c b/fs/cifs/transport.c | ||
931 | index eafc49de4d7f7..6d6de183915b5 100644 | ||
932 | --- a/fs/cifs/transport.c | ||
933 | +++ b/fs/cifs/transport.c | ||
934 | @@ -340,8 +340,8 @@ __smb_send_rqst(struct TCP_Server_Info *server, int num_rqst, | ||
935 | return -EAGAIN; | ||
936 | |||
937 | if (signal_pending(current)) { | ||
938 | - cifs_dbg(FYI, "signal is pending before sending any data\n"); | ||
939 | - return -EINTR; | ||
940 | + cifs_dbg(FYI, "signal pending before send request\n"); | ||
941 | + return -ERESTARTSYS; | ||
942 | } | ||
943 | |||
944 | /* cork the socket */ | ||
945 | diff --git a/fs/coredump.c b/fs/coredump.c | ||
946 | index 5c0375e7440f6..f34767eedf38e 100644 | ||
947 | --- a/fs/coredump.c | ||
948 | +++ b/fs/coredump.c | ||
949 | @@ -224,7 +224,8 @@ static int format_corename(struct core_name *cn, struct coredump_params *cprm, | ||
950 | */ | ||
951 | if (ispipe) { | ||
952 | if (isspace(*pat_ptr)) { | ||
953 | - was_space = true; | ||
954 | + if (cn->used != 0) | ||
955 | + was_space = true; | ||
956 | pat_ptr++; | ||
957 | continue; | ||
958 | } else if (was_space) { | ||
959 | diff --git a/fs/gfs2/rgrp.c b/fs/gfs2/rgrp.c | ||
960 | index 5d9d93ca0db70..c056ed5c6df30 100644 | ||
961 | --- a/fs/gfs2/rgrp.c | ||
962 | +++ b/fs/gfs2/rgrp.c | ||
963 | @@ -1008,6 +1008,10 @@ static int gfs2_ri_update(struct gfs2_inode *ip) | ||
964 | if (error < 0) | ||
965 | return error; | ||
966 | |||
967 | + if (RB_EMPTY_ROOT(&sdp->sd_rindex_tree)) { | ||
968 | + fs_err(sdp, "no resource groups found in the file system.\n"); | ||
969 | + return -ENOENT; | ||
970 | + } | ||
971 | set_rgrp_preferences(sdp); | ||
972 | |||
973 | sdp->sd_rindex_uptodate = 1; | ||
974 | diff --git a/include/linux/irqdomain.h b/include/linux/irqdomain.h | ||
975 | index e85f714a623ef..824d7a19dd66e 100644 | ||
976 | --- a/include/linux/irqdomain.h | ||
977 | +++ b/include/linux/irqdomain.h | ||
978 | @@ -382,11 +382,19 @@ extern void irq_domain_associate_many(struct irq_domain *domain, | ||
979 | extern void irq_domain_disassociate(struct irq_domain *domain, | ||
980 | unsigned int irq); | ||
981 | |||
982 | -extern unsigned int irq_create_mapping(struct irq_domain *host, | ||
983 | - irq_hw_number_t hwirq); | ||
984 | +extern unsigned int irq_create_mapping_affinity(struct irq_domain *host, | ||
985 | + irq_hw_number_t hwirq, | ||
986 | + const struct irq_affinity_desc *affinity); | ||
987 | extern unsigned int irq_create_fwspec_mapping(struct irq_fwspec *fwspec); | ||
988 | extern void irq_dispose_mapping(unsigned int virq); | ||
989 | |||
990 | +static inline unsigned int irq_create_mapping(struct irq_domain *host, | ||
991 | + irq_hw_number_t hwirq) | ||
992 | +{ | ||
993 | + return irq_create_mapping_affinity(host, hwirq, NULL); | ||
994 | +} | ||
995 | + | ||
996 | + | ||
997 | /** | ||
998 | * irq_linear_revmap() - Find a linux irq from a hw irq number. | ||
999 | * @domain: domain owning this hardware interrupt | ||
1000 | diff --git a/include/linux/tty.h b/include/linux/tty.h | ||
1001 | index a99e9b8e4e316..eb33d948788cc 100644 | ||
1002 | --- a/include/linux/tty.h | ||
1003 | +++ b/include/linux/tty.h | ||
1004 | @@ -306,6 +306,10 @@ struct tty_struct { | ||
1005 | struct termiox *termiox; /* May be NULL for unsupported */ | ||
1006 | char name[64]; | ||
1007 | struct pid *pgrp; /* Protected by ctrl lock */ | ||
1008 | + /* | ||
1009 | + * Writes protected by both ctrl lock and legacy mutex, readers must use | ||
1010 | + * at least one of them. | ||
1011 | + */ | ||
1012 | struct pid *session; | ||
1013 | unsigned long flags; | ||
1014 | int count; | ||
1015 | diff --git a/include/net/netfilter/nf_tables_offload.h b/include/net/netfilter/nf_tables_offload.h | ||
1016 | index 03cf5856d76f2..d0bb9e3bcec1c 100644 | ||
1017 | --- a/include/net/netfilter/nf_tables_offload.h | ||
1018 | +++ b/include/net/netfilter/nf_tables_offload.h | ||
1019 | @@ -37,6 +37,7 @@ void nft_offload_update_dependency(struct nft_offload_ctx *ctx, | ||
1020 | |||
1021 | struct nft_flow_key { | ||
1022 | struct flow_dissector_key_basic basic; | ||
1023 | + struct flow_dissector_key_control control; | ||
1024 | union { | ||
1025 | struct flow_dissector_key_ipv4_addrs ipv4; | ||
1026 | struct flow_dissector_key_ipv6_addrs ipv6; | ||
1027 | @@ -61,6 +62,9 @@ struct nft_flow_rule { | ||
1028 | |||
1029 | #define NFT_OFFLOAD_F_ACTION (1 << 0) | ||
1030 | |||
1031 | +void nft_flow_rule_set_addr_type(struct nft_flow_rule *flow, | ||
1032 | + enum flow_dissector_key_id addr_type); | ||
1033 | + | ||
1034 | struct nft_rule; | ||
1035 | struct nft_flow_rule *nft_flow_rule_create(struct net *net, const struct nft_rule *rule); | ||
1036 | void nft_flow_rule_destroy(struct nft_flow_rule *flow); | ||
1037 | diff --git a/kernel/irq/irqdomain.c b/kernel/irq/irqdomain.c | ||
1038 | index c776b8e86fbcc..5a60de39457c7 100644 | ||
1039 | --- a/kernel/irq/irqdomain.c | ||
1040 | +++ b/kernel/irq/irqdomain.c | ||
1041 | @@ -638,17 +638,19 @@ unsigned int irq_create_direct_mapping(struct irq_domain *domain) | ||
1042 | EXPORT_SYMBOL_GPL(irq_create_direct_mapping); | ||
1043 | |||
1044 | /** | ||
1045 | - * irq_create_mapping() - Map a hardware interrupt into linux irq space | ||
1046 | + * irq_create_mapping_affinity() - Map a hardware interrupt into linux irq space | ||
1047 | * @domain: domain owning this hardware interrupt or NULL for default domain | ||
1048 | * @hwirq: hardware irq number in that domain space | ||
1049 | + * @affinity: irq affinity | ||
1050 | * | ||
1051 | * Only one mapping per hardware interrupt is permitted. Returns a linux | ||
1052 | * irq number. | ||
1053 | * If the sense/trigger is to be specified, set_irq_type() should be called | ||
1054 | * on the number returned from that call. | ||
1055 | */ | ||
1056 | -unsigned int irq_create_mapping(struct irq_domain *domain, | ||
1057 | - irq_hw_number_t hwirq) | ||
1058 | +unsigned int irq_create_mapping_affinity(struct irq_domain *domain, | ||
1059 | + irq_hw_number_t hwirq, | ||
1060 | + const struct irq_affinity_desc *affinity) | ||
1061 | { | ||
1062 | struct device_node *of_node; | ||
1063 | int virq; | ||
1064 | @@ -674,7 +676,8 @@ unsigned int irq_create_mapping(struct irq_domain *domain, | ||
1065 | } | ||
1066 | |||
1067 | /* Allocate a virtual interrupt number */ | ||
1068 | - virq = irq_domain_alloc_descs(-1, 1, hwirq, of_node_to_nid(of_node), NULL); | ||
1069 | + virq = irq_domain_alloc_descs(-1, 1, hwirq, of_node_to_nid(of_node), | ||
1070 | + affinity); | ||
1071 | if (virq <= 0) { | ||
1072 | pr_debug("-> virq allocation failed\n"); | ||
1073 | return 0; | ||
1074 | @@ -690,7 +693,7 @@ unsigned int irq_create_mapping(struct irq_domain *domain, | ||
1075 | |||
1076 | return virq; | ||
1077 | } | ||
1078 | -EXPORT_SYMBOL_GPL(irq_create_mapping); | ||
1079 | +EXPORT_SYMBOL_GPL(irq_create_mapping_affinity); | ||
1080 | |||
1081 | /** | ||
1082 | * irq_create_strict_mappings() - Map a range of hw irqs to fixed linux irqs | ||
1083 | diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c | ||
1084 | index fbba31baef53c..cbb76ffaf499f 100644 | ||
1085 | --- a/kernel/trace/ftrace.c | ||
1086 | +++ b/kernel/trace/ftrace.c | ||
1087 | @@ -1626,6 +1626,8 @@ static bool test_rec_ops_needs_regs(struct dyn_ftrace *rec) | ||
1088 | static struct ftrace_ops * | ||
1089 | ftrace_find_tramp_ops_any(struct dyn_ftrace *rec); | ||
1090 | static struct ftrace_ops * | ||
1091 | +ftrace_find_tramp_ops_any_other(struct dyn_ftrace *rec, struct ftrace_ops *op_exclude); | ||
1092 | +static struct ftrace_ops * | ||
1093 | ftrace_find_tramp_ops_next(struct dyn_ftrace *rec, struct ftrace_ops *ops); | ||
1094 | |||
1095 | static bool __ftrace_hash_rec_update(struct ftrace_ops *ops, | ||
1096 | @@ -1763,7 +1765,7 @@ static bool __ftrace_hash_rec_update(struct ftrace_ops *ops, | ||
1097 | * to it. | ||
1098 | */ | ||
1099 | if (ftrace_rec_count(rec) == 1 && | ||
1100 | - ftrace_find_tramp_ops_any(rec)) | ||
1101 | + ftrace_find_tramp_ops_any_other(rec, ops)) | ||
1102 | rec->flags |= FTRACE_FL_TRAMP; | ||
1103 | else | ||
1104 | rec->flags &= ~FTRACE_FL_TRAMP; | ||
1105 | @@ -2191,6 +2193,24 @@ ftrace_find_tramp_ops_any(struct dyn_ftrace *rec) | ||
1106 | return NULL; | ||
1107 | } | ||
1108 | |||
1109 | +static struct ftrace_ops * | ||
1110 | +ftrace_find_tramp_ops_any_other(struct dyn_ftrace *rec, struct ftrace_ops *op_exclude) | ||
1111 | +{ | ||
1112 | + struct ftrace_ops *op; | ||
1113 | + unsigned long ip = rec->ip; | ||
1114 | + | ||
1115 | + do_for_each_ftrace_op(op, ftrace_ops_list) { | ||
1116 | + | ||
1117 | + if (op == op_exclude || !op->trampoline) | ||
1118 | + continue; | ||
1119 | + | ||
1120 | + if (hash_contains_ip(ip, op->func_hash)) | ||
1121 | + return op; | ||
1122 | + } while_for_each_ftrace_op(op); | ||
1123 | + | ||
1124 | + return NULL; | ||
1125 | +} | ||
1126 | + | ||
1127 | static struct ftrace_ops * | ||
1128 | ftrace_find_tramp_ops_next(struct dyn_ftrace *rec, | ||
1129 | struct ftrace_ops *op) | ||
1130 | diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c | ||
1131 | index f7cac11a90055..67af28f03cf41 100644 | ||
1132 | --- a/kernel/trace/trace.c | ||
1133 | +++ b/kernel/trace/trace.c | ||
1134 | @@ -160,7 +160,8 @@ static union trace_eval_map_item *trace_eval_maps; | ||
1135 | #endif /* CONFIG_TRACE_EVAL_MAP_FILE */ | ||
1136 | |||
1137 | static int tracing_set_tracer(struct trace_array *tr, const char *buf); | ||
1138 | -static void ftrace_trace_userstack(struct ring_buffer *buffer, | ||
1139 | +static void ftrace_trace_userstack(struct trace_array *tr, | ||
1140 | + struct ring_buffer *buffer, | ||
1141 | unsigned long flags, int pc); | ||
1142 | |||
1143 | #define MAX_TRACER_SIZE 100 | ||
1144 | @@ -2621,7 +2622,7 @@ void trace_buffer_unlock_commit_regs(struct trace_array *tr, | ||
1145 | * two. They are not that meaningful. | ||
1146 | */ | ||
1147 | ftrace_trace_stack(tr, buffer, flags, regs ? 0 : STACK_SKIP, pc, regs); | ||
1148 | - ftrace_trace_userstack(buffer, flags, pc); | ||
1149 | + ftrace_trace_userstack(tr, buffer, flags, pc); | ||
1150 | } | ||
1151 | |||
1152 | /* | ||
1153 | @@ -2936,13 +2937,14 @@ EXPORT_SYMBOL_GPL(trace_dump_stack); | ||
1154 | static DEFINE_PER_CPU(int, user_stack_count); | ||
1155 | |||
1156 | static void | ||
1157 | -ftrace_trace_userstack(struct ring_buffer *buffer, unsigned long flags, int pc) | ||
1158 | +ftrace_trace_userstack(struct trace_array *tr, | ||
1159 | + struct ring_buffer *buffer, unsigned long flags, int pc) | ||
1160 | { | ||
1161 | struct trace_event_call *call = &event_user_stack; | ||
1162 | struct ring_buffer_event *event; | ||
1163 | struct userstack_entry *entry; | ||
1164 | |||
1165 | - if (!(global_trace.trace_flags & TRACE_ITER_USERSTACKTRACE)) | ||
1166 | + if (!(tr->trace_flags & TRACE_ITER_USERSTACKTRACE)) | ||
1167 | return; | ||
1168 | |||
1169 | /* | ||
1170 | @@ -2981,7 +2983,8 @@ ftrace_trace_userstack(struct ring_buffer *buffer, unsigned long flags, int pc) | ||
1171 | preempt_enable(); | ||
1172 | } | ||
1173 | #else /* CONFIG_USER_STACKTRACE_SUPPORT */ | ||
1174 | -static void ftrace_trace_userstack(struct ring_buffer *buffer, | ||
1175 | +static void ftrace_trace_userstack(struct trace_array *tr, | ||
1176 | + struct ring_buffer *buffer, | ||
1177 | unsigned long flags, int pc) | ||
1178 | { | ||
1179 | } | ||
1180 | diff --git a/lib/syscall.c b/lib/syscall.c | ||
1181 | index fb328e7ccb089..71ffcf5aff122 100644 | ||
1182 | --- a/lib/syscall.c | ||
1183 | +++ b/lib/syscall.c | ||
1184 | @@ -7,6 +7,7 @@ | ||
1185 | |||
1186 | static int collect_syscall(struct task_struct *target, struct syscall_info *info) | ||
1187 | { | ||
1188 | + unsigned long args[6] = { }; | ||
1189 | struct pt_regs *regs; | ||
1190 | |||
1191 | if (!try_get_task_stack(target)) { | ||
1192 | @@ -27,8 +28,14 @@ static int collect_syscall(struct task_struct *target, struct syscall_info *info | ||
1193 | |||
1194 | info->data.nr = syscall_get_nr(target, regs); | ||
1195 | if (info->data.nr != -1L) | ||
1196 | - syscall_get_arguments(target, regs, | ||
1197 | - (unsigned long *)&info->data.args[0]); | ||
1198 | + syscall_get_arguments(target, regs, args); | ||
1199 | + | ||
1200 | + info->data.args[0] = args[0]; | ||
1201 | + info->data.args[1] = args[1]; | ||
1202 | + info->data.args[2] = args[2]; | ||
1203 | + info->data.args[3] = args[3]; | ||
1204 | + info->data.args[4] = args[4]; | ||
1205 | + info->data.args[5] = args[5]; | ||
1206 | |||
1207 | put_task_stack(target); | ||
1208 | return 0; | ||
1209 | diff --git a/mm/list_lru.c b/mm/list_lru.c | ||
1210 | index 0f1f6b06b7f36..d12c1943f6f39 100644 | ||
1211 | --- a/mm/list_lru.c | ||
1212 | +++ b/mm/list_lru.c | ||
1213 | @@ -544,7 +544,6 @@ static void memcg_drain_list_lru_node(struct list_lru *lru, int nid, | ||
1214 | struct list_lru_node *nlru = &lru->node[nid]; | ||
1215 | int dst_idx = dst_memcg->kmemcg_id; | ||
1216 | struct list_lru_one *src, *dst; | ||
1217 | - bool set; | ||
1218 | |||
1219 | /* | ||
1220 | * Since list_lru_{add,del} may be called under an IRQ-safe lock, | ||
1221 | @@ -556,11 +555,12 @@ static void memcg_drain_list_lru_node(struct list_lru *lru, int nid, | ||
1222 | dst = list_lru_from_memcg_idx(nlru, dst_idx); | ||
1223 | |||
1224 | list_splice_init(&src->list, &dst->list); | ||
1225 | - set = (!dst->nr_items && src->nr_items); | ||
1226 | - dst->nr_items += src->nr_items; | ||
1227 | - if (set) | ||
1228 | + | ||
1229 | + if (src->nr_items) { | ||
1230 | + dst->nr_items += src->nr_items; | ||
1231 | memcg_set_shrinker_bit(dst_memcg, nid, lru_shrinker_id(lru)); | ||
1232 | - src->nr_items = 0; | ||
1233 | + src->nr_items = 0; | ||
1234 | + } | ||
1235 | |||
1236 | spin_unlock_irq(&nlru->lock); | ||
1237 | } | ||
1238 | diff --git a/mm/swapfile.c b/mm/swapfile.c | ||
1239 | index ff83ffe7a9108..7947633d3cede 100644 | ||
1240 | --- a/mm/swapfile.c | ||
1241 | +++ b/mm/swapfile.c | ||
1242 | @@ -2824,6 +2824,7 @@ late_initcall(max_swapfiles_check); | ||
1243 | static struct swap_info_struct *alloc_swap_info(void) | ||
1244 | { | ||
1245 | struct swap_info_struct *p; | ||
1246 | + struct swap_info_struct *defer = NULL; | ||
1247 | unsigned int type; | ||
1248 | int i; | ||
1249 | |||
1250 | @@ -2852,7 +2853,7 @@ static struct swap_info_struct *alloc_swap_info(void) | ||
1251 | smp_wmb(); | ||
1252 | WRITE_ONCE(nr_swapfiles, nr_swapfiles + 1); | ||
1253 | } else { | ||
1254 | - kvfree(p); | ||
1255 | + defer = p; | ||
1256 | p = swap_info[type]; | ||
1257 | /* | ||
1258 | * Do not memset this entry: a racing procfs swap_next() | ||
1259 | @@ -2865,6 +2866,7 @@ static struct swap_info_struct *alloc_swap_info(void) | ||
1260 | plist_node_init(&p->avail_lists[i], 0); | ||
1261 | p->flags = SWP_USED; | ||
1262 | spin_unlock(&swap_lock); | ||
1263 | + kvfree(defer); | ||
1264 | spin_lock_init(&p->lock); | ||
1265 | spin_lock_init(&p->cont_lock); | ||
1266 | |||
1267 | diff --git a/net/can/af_can.c b/net/can/af_can.c | ||
1268 | index fd6ef6d26846f..306d3584a4417 100644 | ||
1269 | --- a/net/can/af_can.c | ||
1270 | +++ b/net/can/af_can.c | ||
1271 | @@ -539,10 +539,13 @@ void can_rx_unregister(struct net *net, struct net_device *dev, canid_t can_id, | ||
1272 | |||
1273 | /* Check for bugs in CAN protocol implementations using af_can.c: | ||
1274 | * 'rcv' will be NULL if no matching list item was found for removal. | ||
1275 | + * As this case may potentially happen when closing a socket while | ||
1276 | + * the notifier for removing the CAN netdev is running we just print | ||
1277 | + * a warning here. | ||
1278 | */ | ||
1279 | if (!rcv) { | ||
1280 | - WARN(1, "BUG: receive list entry not found for dev %s, id %03X, mask %03X\n", | ||
1281 | - DNAME(dev), can_id, mask); | ||
1282 | + pr_warn("can: receive list entry not found for dev %s, id %03X, mask %03X\n", | ||
1283 | + DNAME(dev), can_id, mask); | ||
1284 | goto out; | ||
1285 | } | ||
1286 | |||
1287 | diff --git a/net/netfilter/ipset/ip_set_core.c b/net/netfilter/ipset/ip_set_core.c | ||
1288 | index 3cc4daa856d6b..16ae770f049dd 100644 | ||
1289 | --- a/net/netfilter/ipset/ip_set_core.c | ||
1290 | +++ b/net/netfilter/ipset/ip_set_core.c | ||
1291 | @@ -285,8 +285,7 @@ flag_nested(const struct nlattr *nla) | ||
1292 | |||
1293 | static const struct nla_policy ipaddr_policy[IPSET_ATTR_IPADDR_MAX + 1] = { | ||
1294 | [IPSET_ATTR_IPADDR_IPV4] = { .type = NLA_U32 }, | ||
1295 | - [IPSET_ATTR_IPADDR_IPV6] = { .type = NLA_BINARY, | ||
1296 | - .len = sizeof(struct in6_addr) }, | ||
1297 | + [IPSET_ATTR_IPADDR_IPV6] = NLA_POLICY_EXACT_LEN(sizeof(struct in6_addr)), | ||
1298 | }; | ||
1299 | |||
1300 | int | ||
1301 | diff --git a/net/netfilter/nf_tables_api.c b/net/netfilter/nf_tables_api.c | ||
1302 | index 51391d5d22656..459b7c0547115 100644 | ||
1303 | --- a/net/netfilter/nf_tables_api.c | ||
1304 | +++ b/net/netfilter/nf_tables_api.c | ||
1305 | @@ -560,7 +560,8 @@ static int nft_request_module(struct net *net, const char *fmt, ...) | ||
1306 | static void lockdep_nfnl_nft_mutex_not_held(void) | ||
1307 | { | ||
1308 | #ifdef CONFIG_PROVE_LOCKING | ||
1309 | - WARN_ON_ONCE(lockdep_nfnl_is_held(NFNL_SUBSYS_NFTABLES)); | ||
1310 | + if (debug_locks) | ||
1311 | + WARN_ON_ONCE(lockdep_nfnl_is_held(NFNL_SUBSYS_NFTABLES)); | ||
1312 | #endif | ||
1313 | } | ||
1314 | |||
1315 | diff --git a/net/netfilter/nf_tables_offload.c b/net/netfilter/nf_tables_offload.c | ||
1316 | index c480549a7f946..3aa4306ca39f6 100644 | ||
1317 | --- a/net/netfilter/nf_tables_offload.c | ||
1318 | +++ b/net/netfilter/nf_tables_offload.c | ||
1319 | @@ -28,6 +28,23 @@ static struct nft_flow_rule *nft_flow_rule_alloc(int num_actions) | ||
1320 | return flow; | ||
1321 | } | ||
1322 | |||
1323 | +void nft_flow_rule_set_addr_type(struct nft_flow_rule *flow, | ||
1324 | + enum flow_dissector_key_id addr_type) | ||
1325 | +{ | ||
1326 | + struct nft_flow_match *match = &flow->match; | ||
1327 | + struct nft_flow_key *mask = &match->mask; | ||
1328 | + struct nft_flow_key *key = &match->key; | ||
1329 | + | ||
1330 | + if (match->dissector.used_keys & BIT(FLOW_DISSECTOR_KEY_CONTROL)) | ||
1331 | + return; | ||
1332 | + | ||
1333 | + key->control.addr_type = addr_type; | ||
1334 | + mask->control.addr_type = 0xffff; | ||
1335 | + match->dissector.used_keys |= BIT(FLOW_DISSECTOR_KEY_CONTROL); | ||
1336 | + match->dissector.offset[FLOW_DISSECTOR_KEY_CONTROL] = | ||
1337 | + offsetof(struct nft_flow_key, control); | ||
1338 | +} | ||
1339 | + | ||
1340 | struct nft_flow_rule *nft_flow_rule_create(struct net *net, | ||
1341 | const struct nft_rule *rule) | ||
1342 | { | ||
1343 | diff --git a/net/netfilter/nft_payload.c b/net/netfilter/nft_payload.c | ||
1344 | index 62dc728bf93c9..921f8f45b17f4 100644 | ||
1345 | --- a/net/netfilter/nft_payload.c | ||
1346 | +++ b/net/netfilter/nft_payload.c | ||
1347 | @@ -197,6 +197,7 @@ static int nft_payload_offload_ip(struct nft_offload_ctx *ctx, | ||
1348 | |||
1349 | NFT_OFFLOAD_MATCH(FLOW_DISSECTOR_KEY_IPV4_ADDRS, ipv4, src, | ||
1350 | sizeof(struct in_addr), reg); | ||
1351 | + nft_flow_rule_set_addr_type(flow, FLOW_DISSECTOR_KEY_IPV4_ADDRS); | ||
1352 | break; | ||
1353 | case offsetof(struct iphdr, daddr): | ||
1354 | if (priv->len != sizeof(struct in_addr)) | ||
1355 | @@ -204,6 +205,7 @@ static int nft_payload_offload_ip(struct nft_offload_ctx *ctx, | ||
1356 | |||
1357 | NFT_OFFLOAD_MATCH(FLOW_DISSECTOR_KEY_IPV4_ADDRS, ipv4, dst, | ||
1358 | sizeof(struct in_addr), reg); | ||
1359 | + nft_flow_rule_set_addr_type(flow, FLOW_DISSECTOR_KEY_IPV4_ADDRS); | ||
1360 | break; | ||
1361 | case offsetof(struct iphdr, protocol): | ||
1362 | if (priv->len != sizeof(__u8)) | ||
1363 | @@ -233,6 +235,7 @@ static int nft_payload_offload_ip6(struct nft_offload_ctx *ctx, | ||
1364 | |||
1365 | NFT_OFFLOAD_MATCH(FLOW_DISSECTOR_KEY_IPV6_ADDRS, ipv6, src, | ||
1366 | sizeof(struct in6_addr), reg); | ||
1367 | + nft_flow_rule_set_addr_type(flow, FLOW_DISSECTOR_KEY_IPV6_ADDRS); | ||
1368 | break; | ||
1369 | case offsetof(struct ipv6hdr, daddr): | ||
1370 | if (priv->len != sizeof(struct in6_addr)) | ||
1371 | @@ -240,6 +243,7 @@ static int nft_payload_offload_ip6(struct nft_offload_ctx *ctx, | ||
1372 | |||
1373 | NFT_OFFLOAD_MATCH(FLOW_DISSECTOR_KEY_IPV6_ADDRS, ipv6, dst, | ||
1374 | sizeof(struct in6_addr), reg); | ||
1375 | + nft_flow_rule_set_addr_type(flow, FLOW_DISSECTOR_KEY_IPV6_ADDRS); | ||
1376 | break; | ||
1377 | case offsetof(struct ipv6hdr, nexthdr): | ||
1378 | if (priv->len != sizeof(__u8)) | ||
1379 | diff --git a/net/tipc/core.c b/net/tipc/core.c | ||
1380 | index 2374adb505589..e3d79f8b69d81 100644 | ||
1381 | --- a/net/tipc/core.c | ||
1382 | +++ b/net/tipc/core.c | ||
1383 | @@ -59,6 +59,7 @@ static int __net_init tipc_init_net(struct net *net) | ||
1384 | tn->trial_addr = 0; | ||
1385 | tn->addr_trial_end = 0; | ||
1386 | tn->capabilities = TIPC_NODE_CAPABILITIES; | ||
1387 | + INIT_WORK(&tn->final_work.work, tipc_net_finalize_work); | ||
1388 | memset(tn->node_id, 0, sizeof(tn->node_id)); | ||
1389 | memset(tn->node_id_string, 0, sizeof(tn->node_id_string)); | ||
1390 | tn->mon_threshold = TIPC_DEF_MON_THRESHOLD; | ||
1391 | @@ -96,13 +97,13 @@ out_sk_rht: | ||
1392 | |||
1393 | static void __net_exit tipc_exit_net(struct net *net) | ||
1394 | { | ||
1395 | + struct tipc_net *tn = tipc_net(net); | ||
1396 | + | ||
1397 | tipc_detach_loopback(net); | ||
1398 | + /* Make sure the tipc_net_finalize_work() finished */ | ||
1399 | + cancel_work_sync(&tn->final_work.work); | ||
1400 | tipc_net_stop(net); | ||
1401 | |||
1402 | - /* Make sure the tipc_net_finalize_work stopped | ||
1403 | - * before releasing the resources. | ||
1404 | - */ | ||
1405 | - flush_scheduled_work(); | ||
1406 | tipc_bcast_stop(net); | ||
1407 | tipc_nametbl_stop(net); | ||
1408 | tipc_sk_rht_destroy(net); | ||
1409 | diff --git a/net/tipc/core.h b/net/tipc/core.h | ||
1410 | index 3042f654e0af0..e119c4a88d63e 100644 | ||
1411 | --- a/net/tipc/core.h | ||
1412 | +++ b/net/tipc/core.h | ||
1413 | @@ -86,6 +86,12 @@ extern unsigned int tipc_net_id __read_mostly; | ||
1414 | extern int sysctl_tipc_rmem[3] __read_mostly; | ||
1415 | extern int sysctl_tipc_named_timeout __read_mostly; | ||
1416 | |||
1417 | +struct tipc_net_work { | ||
1418 | + struct work_struct work; | ||
1419 | + struct net *net; | ||
1420 | + u32 addr; | ||
1421 | +}; | ||
1422 | + | ||
1423 | struct tipc_net { | ||
1424 | u8 node_id[NODE_ID_LEN]; | ||
1425 | u32 node_addr; | ||
1426 | @@ -134,6 +140,9 @@ struct tipc_net { | ||
1427 | |||
1428 | /* Tracing of node internal messages */ | ||
1429 | struct packet_type loopback_pt; | ||
1430 | + | ||
1431 | + /* Work item for net finalize */ | ||
1432 | + struct tipc_net_work final_work; | ||
1433 | }; | ||
1434 | |||
1435 | static inline struct tipc_net *tipc_net(struct net *net) | ||
1436 | diff --git a/net/tipc/net.c b/net/tipc/net.c | ||
1437 | index 2de3cec9929d8..2498ce8b83c1a 100644 | ||
1438 | --- a/net/tipc/net.c | ||
1439 | +++ b/net/tipc/net.c | ||
1440 | @@ -105,12 +105,6 @@ | ||
1441 | * - A local spin_lock protecting the queue of subscriber events. | ||
1442 | */ | ||
1443 | |||
1444 | -struct tipc_net_work { | ||
1445 | - struct work_struct work; | ||
1446 | - struct net *net; | ||
1447 | - u32 addr; | ||
1448 | -}; | ||
1449 | - | ||
1450 | static void tipc_net_finalize(struct net *net, u32 addr); | ||
1451 | |||
1452 | int tipc_net_init(struct net *net, u8 *node_id, u32 addr) | ||
1453 | @@ -142,25 +136,21 @@ static void tipc_net_finalize(struct net *net, u32 addr) | ||
1454 | TIPC_CLUSTER_SCOPE, 0, addr); | ||
1455 | } | ||
1456 | |||
1457 | -static void tipc_net_finalize_work(struct work_struct *work) | ||
1458 | +void tipc_net_finalize_work(struct work_struct *work) | ||
1459 | { | ||
1460 | struct tipc_net_work *fwork; | ||
1461 | |||
1462 | fwork = container_of(work, struct tipc_net_work, work); | ||
1463 | tipc_net_finalize(fwork->net, fwork->addr); | ||
1464 | - kfree(fwork); | ||
1465 | } | ||
1466 | |||
1467 | void tipc_sched_net_finalize(struct net *net, u32 addr) | ||
1468 | { | ||
1469 | - struct tipc_net_work *fwork = kzalloc(sizeof(*fwork), GFP_ATOMIC); | ||
1470 | + struct tipc_net *tn = tipc_net(net); | ||
1471 | |||
1472 | - if (!fwork) | ||
1473 | - return; | ||
1474 | - INIT_WORK(&fwork->work, tipc_net_finalize_work); | ||
1475 | - fwork->net = net; | ||
1476 | - fwork->addr = addr; | ||
1477 | - schedule_work(&fwork->work); | ||
1478 | + tn->final_work.net = net; | ||
1479 | + tn->final_work.addr = addr; | ||
1480 | + schedule_work(&tn->final_work.work); | ||
1481 | } | ||
1482 | |||
1483 | void tipc_net_stop(struct net *net) | ||
1484 | diff --git a/net/tipc/net.h b/net/tipc/net.h | ||
1485 | index b7f2e364eb99e..a6a4dba136738 100644 | ||
1486 | --- a/net/tipc/net.h | ||
1487 | +++ b/net/tipc/net.h | ||
1488 | @@ -42,6 +42,7 @@ | ||
1489 | extern const struct nla_policy tipc_nl_net_policy[]; | ||
1490 | |||
1491 | int tipc_net_init(struct net *net, u8 *node_id, u32 addr); | ||
1492 | +void tipc_net_finalize_work(struct work_struct *work); | ||
1493 | void tipc_sched_net_finalize(struct net *net, u32 addr); | ||
1494 | void tipc_net_stop(struct net *net); | ||
1495 | int tipc_nl_net_dump(struct sk_buff *skb, struct netlink_callback *cb); | ||
1496 | diff --git a/sound/pci/hda/hda_generic.c b/sound/pci/hda/hda_generic.c | ||
1497 | index e1750bdbe51f6..3caea6d58c9aa 100644 | ||
1498 | --- a/sound/pci/hda/hda_generic.c | ||
1499 | +++ b/sound/pci/hda/hda_generic.c | ||
1500 | @@ -1364,16 +1364,20 @@ static int try_assign_dacs(struct hda_codec *codec, int num_outs, | ||
1501 | struct nid_path *path; | ||
1502 | hda_nid_t pin = pins[i]; | ||
1503 | |||
1504 | - path = snd_hda_get_path_from_idx(codec, path_idx[i]); | ||
1505 | - if (path) { | ||
1506 | - badness += assign_out_path_ctls(codec, path); | ||
1507 | - continue; | ||
1508 | + if (!spec->obey_preferred_dacs) { | ||
1509 | + path = snd_hda_get_path_from_idx(codec, path_idx[i]); | ||
1510 | + if (path) { | ||
1511 | + badness += assign_out_path_ctls(codec, path); | ||
1512 | + continue; | ||
1513 | + } | ||
1514 | } | ||
1515 | |||
1516 | dacs[i] = get_preferred_dac(codec, pin); | ||
1517 | if (dacs[i]) { | ||
1518 | if (is_dac_already_used(codec, dacs[i])) | ||
1519 | badness += bad->shared_primary; | ||
1520 | + } else if (spec->obey_preferred_dacs) { | ||
1521 | + badness += BAD_NO_PRIMARY_DAC; | ||
1522 | } | ||
1523 | |||
1524 | if (!dacs[i]) | ||
1525 | diff --git a/sound/pci/hda/hda_generic.h b/sound/pci/hda/hda_generic.h | ||
1526 | index fb9f1a90238bf..e728df6145adb 100644 | ||
1527 | --- a/sound/pci/hda/hda_generic.h | ||
1528 | +++ b/sound/pci/hda/hda_generic.h | ||
1529 | @@ -236,6 +236,7 @@ struct hda_gen_spec { | ||
1530 | unsigned int power_down_unused:1; /* power down unused widgets */ | ||
1531 | unsigned int dac_min_mute:1; /* minimal = mute for DACs */ | ||
1532 | unsigned int suppress_vmaster:1; /* don't create vmaster kctls */ | ||
1533 | + unsigned int obey_preferred_dacs:1; /* obey preferred_dacs assignment */ | ||
1534 | |||
1535 | /* other internal flags */ | ||
1536 | unsigned int no_analog:1; /* digital I/O only */ | ||
1537 | diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c | ||
1538 | index bd802cbc1165a..c804c15debc69 100644 | ||
1539 | --- a/sound/pci/hda/patch_realtek.c | ||
1540 | +++ b/sound/pci/hda/patch_realtek.c | ||
1541 | @@ -436,6 +436,7 @@ static void alc_fill_eapd_coef(struct hda_codec *codec) | ||
1542 | alc_update_coef_idx(codec, 0x7, 1<<5, 0); | ||
1543 | break; | ||
1544 | case 0x10ec0892: | ||
1545 | + case 0x10ec0897: | ||
1546 | alc_update_coef_idx(codec, 0x7, 1<<5, 0); | ||
1547 | break; | ||
1548 | case 0x10ec0899: | ||
1549 | @@ -5990,6 +5991,21 @@ static void alc274_fixup_bind_dacs(struct hda_codec *codec, | ||
1550 | codec->power_save_node = 0; | ||
1551 | } | ||
1552 | |||
1553 | +/* avoid DAC 0x06 for bass speaker 0x17; it has no volume control */ | ||
1554 | +static void alc289_fixup_asus_ga401(struct hda_codec *codec, | ||
1555 | + const struct hda_fixup *fix, int action) | ||
1556 | +{ | ||
1557 | + static const hda_nid_t preferred_pairs[] = { | ||
1558 | + 0x14, 0x02, 0x17, 0x02, 0x21, 0x03, 0 | ||
1559 | + }; | ||
1560 | + struct alc_spec *spec = codec->spec; | ||
1561 | + | ||
1562 | + if (action == HDA_FIXUP_ACT_PRE_PROBE) { | ||
1563 | + spec->gen.preferred_dacs = preferred_pairs; | ||
1564 | + spec->gen.obey_preferred_dacs = 1; | ||
1565 | + } | ||
1566 | +} | ||
1567 | + | ||
1568 | /* The DAC of NID 0x3 will introduce click/pop noise on headphones, so invalidate it */ | ||
1569 | static void alc285_fixup_invalidate_dacs(struct hda_codec *codec, | ||
1570 | const struct hda_fixup *fix, int action) | ||
1571 | @@ -7543,11 +7559,10 @@ static const struct hda_fixup alc269_fixups[] = { | ||
1572 | .chain_id = ALC269_FIXUP_HEADSET_MIC | ||
1573 | }, | ||
1574 | [ALC289_FIXUP_ASUS_GA401] = { | ||
1575 | - .type = HDA_FIXUP_PINS, | ||
1576 | - .v.pins = (const struct hda_pintbl[]) { | ||
1577 | - { 0x19, 0x03a11020 }, /* headset mic with jack detect */ | ||
1578 | - { } | ||
1579 | - }, | ||
1580 | + .type = HDA_FIXUP_FUNC, | ||
1581 | + .v.func = alc289_fixup_asus_ga401, | ||
1582 | + .chained = true, | ||
1583 | + .chain_id = ALC289_FIXUP_ASUS_GA502, | ||
1584 | }, | ||
1585 | [ALC289_FIXUP_ASUS_GA502] = { | ||
1586 | .type = HDA_FIXUP_PINS, | ||
1587 | @@ -7671,7 +7686,7 @@ static const struct hda_fixup alc269_fixups[] = { | ||
1588 | { } | ||
1589 | }, | ||
1590 | .chained = true, | ||
1591 | - .chain_id = ALC289_FIXUP_ASUS_GA401 | ||
1592 | + .chain_id = ALC289_FIXUP_ASUS_GA502 | ||
1593 | }, | ||
1594 | [ALC274_FIXUP_HP_MIC] = { | ||
1595 | .type = HDA_FIXUP_VERBS, | ||
1596 | @@ -7847,6 +7862,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { | ||
1597 | SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3), | ||
1598 | SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC), | ||
1599 | SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360), | ||
1600 | + SND_PCI_QUIRK(0x103c, 0x827f, "HP x360", ALC269_FIXUP_HP_MUTE_LED_MIC3), | ||
1601 | SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE), | ||
1602 | SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE), | ||
1603 | SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3), | ||
1604 | @@ -8573,6 +8589,9 @@ static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = { | ||
1605 | SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, | ||
1606 | ALC292_STANDARD_PINS, | ||
1607 | {0x13, 0x90a60140}), | ||
1608 | + SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_HPE, | ||
1609 | + {0x17, 0x90170110}, | ||
1610 | + {0x21, 0x04211020}), | ||
1611 | SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC, | ||
1612 | {0x14, 0x90170110}, | ||
1613 | {0x1b, 0x90a70130}, | ||
1614 | @@ -10156,6 +10175,7 @@ static const struct hda_device_id snd_hda_id_realtek[] = { | ||
1615 | HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882), | ||
1616 | HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882), | ||
1617 | HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662), | ||
1618 | + HDA_CODEC_ENTRY(0x10ec0897, "ALC897", patch_alc662), | ||
1619 | HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882), | ||
1620 | HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882), | ||
1621 | HDA_CODEC_ENTRY(0x10ec0b00, "ALCS1200A", patch_alc882), | ||
1622 | diff --git a/sound/soc/codecs/wm_adsp.c b/sound/soc/codecs/wm_adsp.c | ||
1623 | index 9b8bb7bbe945d..4c56b782500db 100644 | ||
1624 | --- a/sound/soc/codecs/wm_adsp.c | ||
1625 | +++ b/sound/soc/codecs/wm_adsp.c | ||
1626 | @@ -1912,6 +1912,7 @@ static int wm_adsp_load(struct wm_adsp *dsp) | ||
1627 | mem = wm_adsp_find_region(dsp, type); | ||
1628 | if (!mem) { | ||
1629 | adsp_err(dsp, "No region of type: %x\n", type); | ||
1630 | + ret = -EINVAL; | ||
1631 | goto out_fw; | ||
1632 | } | ||
1633 | |||
1634 | diff --git a/tools/arch/x86/include/asm/insn.h b/tools/arch/x86/include/asm/insn.h | ||
1635 | index 37a4c390750bc..d7f0ae8f3c442 100644 | ||
1636 | --- a/tools/arch/x86/include/asm/insn.h | ||
1637 | +++ b/tools/arch/x86/include/asm/insn.h | ||
1638 | @@ -195,6 +195,21 @@ static inline int insn_offset_immediate(struct insn *insn) | ||
1639 | return insn_offset_displacement(insn) + insn->displacement.nbytes; | ||
1640 | } | ||
1641 | |||
1642 | +/** | ||
1643 | + * for_each_insn_prefix() -- Iterate prefixes in the instruction | ||
1644 | + * @insn: Pointer to struct insn. | ||
1645 | + * @idx: Index storage. | ||
1646 | + * @prefix: Prefix byte. | ||
1647 | + * | ||
1648 | + * Iterate prefix bytes of given @insn. Each prefix byte is stored in @prefix | ||
1649 | + * and the index is stored in @idx (note that this @idx is just for a cursor, | ||
1650 | + * do not change it.) | ||
1651 | + * Since prefixes.nbytes can be bigger than 4 if some prefixes | ||
1652 | + * are repeated, it cannot be used for looping over the prefixes. | ||
1653 | + */ | ||
1654 | +#define for_each_insn_prefix(insn, idx, prefix) \ | ||
1655 | + for (idx = 0; idx < ARRAY_SIZE(insn->prefixes.bytes) && (prefix = insn->prefixes.bytes[idx]) != 0; idx++) | ||
1656 | + | ||
1657 | #define POP_SS_OPCODE 0x1f | ||
1658 | #define MOV_SREG_OPCODE 0x8e | ||
1659 | |||
1660 | diff --git a/tools/testing/selftests/bpf/prog_tests/map_init.c b/tools/testing/selftests/bpf/prog_tests/map_init.c | ||
1661 | deleted file mode 100644 | ||
1662 | index 14a31109dd0e0..0000000000000 | ||
1663 | --- a/tools/testing/selftests/bpf/prog_tests/map_init.c | ||
1664 | +++ /dev/null | ||
1665 | @@ -1,214 +0,0 @@ | ||
1666 | -// SPDX-License-Identifier: GPL-2.0-only | ||
1667 | -/* Copyright (c) 2020 Tessares SA <http://www.tessares.net> */ | ||
1668 | - | ||
1669 | -#include <test_progs.h> | ||
1670 | -#include "test_map_init.skel.h" | ||
1671 | - | ||
1672 | -#define TEST_VALUE 0x1234 | ||
1673 | -#define FILL_VALUE 0xdeadbeef | ||
1674 | - | ||
1675 | -static int nr_cpus; | ||
1676 | -static int duration; | ||
1677 | - | ||
1678 | -typedef unsigned long long map_key_t; | ||
1679 | -typedef unsigned long long map_value_t; | ||
1680 | -typedef struct { | ||
1681 | - map_value_t v; /* padding */ | ||
1682 | -} __bpf_percpu_val_align pcpu_map_value_t; | ||
1683 | - | ||
1684 | - | ||
1685 | -static int map_populate(int map_fd, int num) | ||
1686 | -{ | ||
1687 | - pcpu_map_value_t value[nr_cpus]; | ||
1688 | - int i, err; | ||
1689 | - map_key_t key; | ||
1690 | - | ||
1691 | - for (i = 0; i < nr_cpus; i++) | ||
1692 | - bpf_percpu(value, i) = FILL_VALUE; | ||
1693 | - | ||
1694 | - for (key = 1; key <= num; key++) { | ||
1695 | - err = bpf_map_update_elem(map_fd, &key, value, BPF_NOEXIST); | ||
1696 | - if (!ASSERT_OK(err, "bpf_map_update_elem")) | ||
1697 | - return -1; | ||
1698 | - } | ||
1699 | - | ||
1700 | - return 0; | ||
1701 | -} | ||
1702 | - | ||
1703 | -static struct test_map_init *setup(enum bpf_map_type map_type, int map_sz, | ||
1704 | - int *map_fd, int populate) | ||
1705 | -{ | ||
1706 | - struct test_map_init *skel; | ||
1707 | - int err; | ||
1708 | - | ||
1709 | - skel = test_map_init__open(); | ||
1710 | - if (!ASSERT_OK_PTR(skel, "skel_open")) | ||
1711 | - return NULL; | ||
1712 | - | ||
1713 | - err = bpf_map__set_type(skel->maps.hashmap1, map_type); | ||
1714 | - if (!ASSERT_OK(err, "bpf_map__set_type")) | ||
1715 | - goto error; | ||
1716 | - | ||
1717 | - err = bpf_map__set_max_entries(skel->maps.hashmap1, map_sz); | ||
1718 | - if (!ASSERT_OK(err, "bpf_map__set_max_entries")) | ||
1719 | - goto error; | ||
1720 | - | ||
1721 | - err = test_map_init__load(skel); | ||
1722 | - if (!ASSERT_OK(err, "skel_load")) | ||
1723 | - goto error; | ||
1724 | - | ||
1725 | - *map_fd = bpf_map__fd(skel->maps.hashmap1); | ||
1726 | - if (CHECK(*map_fd < 0, "bpf_map__fd", "failed\n")) | ||
1727 | - goto error; | ||
1728 | - | ||
1729 | - err = map_populate(*map_fd, populate); | ||
1730 | - if (!ASSERT_OK(err, "map_populate")) | ||
1731 | - goto error_map; | ||
1732 | - | ||
1733 | - return skel; | ||
1734 | - | ||
1735 | -error_map: | ||
1736 | - close(*map_fd); | ||
1737 | -error: | ||
1738 | - test_map_init__destroy(skel); | ||
1739 | - return NULL; | ||
1740 | -} | ||
1741 | - | ||
1742 | -/* executes bpf program that updates map with key, value */ | ||
1743 | -static int prog_run_insert_elem(struct test_map_init *skel, map_key_t key, | ||
1744 | - map_value_t value) | ||
1745 | -{ | ||
1746 | - struct test_map_init__bss *bss; | ||
1747 | - | ||
1748 | - bss = skel->bss; | ||
1749 | - | ||
1750 | - bss->inKey = key; | ||
1751 | - bss->inValue = value; | ||
1752 | - bss->inPid = getpid(); | ||
1753 | - | ||
1754 | - if (!ASSERT_OK(test_map_init__attach(skel), "skel_attach")) | ||
1755 | - return -1; | ||
1756 | - | ||
1757 | - /* Let tracepoint trigger */ | ||
1758 | - syscall(__NR_getpgid); | ||
1759 | - | ||
1760 | - test_map_init__detach(skel); | ||
1761 | - | ||
1762 | - return 0; | ||
1763 | -} | ||
1764 | - | ||
1765 | -static int check_values_one_cpu(pcpu_map_value_t *value, map_value_t expected) | ||
1766 | -{ | ||
1767 | - int i, nzCnt = 0; | ||
1768 | - map_value_t val; | ||
1769 | - | ||
1770 | - for (i = 0; i < nr_cpus; i++) { | ||
1771 | - val = bpf_percpu(value, i); | ||
1772 | - if (val) { | ||
1773 | - if (CHECK(val != expected, "map value", | ||
1774 | - "unexpected for cpu %d: 0x%llx\n", i, val)) | ||
1775 | - return -1; | ||
1776 | - nzCnt++; | ||
1777 | - } | ||
1778 | - } | ||
1779 | - | ||
1780 | - if (CHECK(nzCnt != 1, "map value", "set for %d CPUs instead of 1!\n", | ||
1781 | - nzCnt)) | ||
1782 | - return -1; | ||
1783 | - | ||
1784 | - return 0; | ||
1785 | -} | ||
1786 | - | ||
1787 | -/* Add key=1 elem with values set for all CPUs | ||
1788 | - * Delete elem key=1 | ||
1789 | - * Run bpf prog that inserts new key=1 elem with value=0x1234 | ||
1790 | - * (bpf prog can only set value for current CPU) | ||
1791 | - * Lookup Key=1 and check value is as expected for all CPUs: | ||
1792 | - * value set by bpf prog for one CPU, 0 for all others | ||
1793 | - */ | ||
1794 | -static void test_pcpu_map_init(void) | ||
1795 | -{ | ||
1796 | - pcpu_map_value_t value[nr_cpus]; | ||
1797 | - struct test_map_init *skel; | ||
1798 | - int map_fd, err; | ||
1799 | - map_key_t key; | ||
1800 | - | ||
1801 | - /* max 1 elem in map so insertion is forced to reuse freed entry */ | ||
1802 | - skel = setup(BPF_MAP_TYPE_PERCPU_HASH, 1, &map_fd, 1); | ||
1803 | - if (!ASSERT_OK_PTR(skel, "prog_setup")) | ||
1804 | - return; | ||
1805 | - | ||
1806 | - /* delete element so the entry can be re-used*/ | ||
1807 | - key = 1; | ||
1808 | - err = bpf_map_delete_elem(map_fd, &key); | ||
1809 | - if (!ASSERT_OK(err, "bpf_map_delete_elem")) | ||
1810 | - goto cleanup; | ||
1811 | - | ||
1812 | - /* run bpf prog that inserts new elem, re-using the slot just freed */ | ||
1813 | - err = prog_run_insert_elem(skel, key, TEST_VALUE); | ||
1814 | - if (!ASSERT_OK(err, "prog_run_insert_elem")) | ||
1815 | - goto cleanup; | ||
1816 | - | ||
1817 | - /* check that key=1 was re-created by bpf prog */ | ||
1818 | - err = bpf_map_lookup_elem(map_fd, &key, value); | ||
1819 | - if (!ASSERT_OK(err, "bpf_map_lookup_elem")) | ||
1820 | - goto cleanup; | ||
1821 | - | ||
1822 | - /* and has expected values */ | ||
1823 | - check_values_one_cpu(value, TEST_VALUE); | ||
1824 | - | ||
1825 | -cleanup: | ||
1826 | - test_map_init__destroy(skel); | ||
1827 | -} | ||
1828 | - | ||
1829 | -/* Add key=1 and key=2 elems with values set for all CPUs | ||
1830 | - * Run bpf prog that inserts new key=3 elem | ||
1831 | - * (only for current cpu; other cpus should have initial value = 0) | ||
1832 | - * Lookup Key=1 and check value is as expected for all CPUs | ||
1833 | - */ | ||
1834 | -static void test_pcpu_lru_map_init(void) | ||
1835 | -{ | ||
1836 | - pcpu_map_value_t value[nr_cpus]; | ||
1837 | - struct test_map_init *skel; | ||
1838 | - int map_fd, err; | ||
1839 | - map_key_t key; | ||
1840 | - | ||
1841 | - /* Set up LRU map with 2 elements, values filled for all CPUs. | ||
1842 | - * With these 2 elements, the LRU map is full | ||
1843 | - */ | ||
1844 | - skel = setup(BPF_MAP_TYPE_LRU_PERCPU_HASH, 2, &map_fd, 2); | ||
1845 | - if (!ASSERT_OK_PTR(skel, "prog_setup")) | ||
1846 | - return; | ||
1847 | - | ||
1848 | - /* run bpf prog that inserts new key=3 element, re-using LRU slot */ | ||
1849 | - key = 3; | ||
1850 | - err = prog_run_insert_elem(skel, key, TEST_VALUE); | ||
1851 | - if (!ASSERT_OK(err, "prog_run_insert_elem")) | ||
1852 | - goto cleanup; | ||
1853 | - | ||
1854 | - /* check that key=3 replaced one of earlier elements */ | ||
1855 | - err = bpf_map_lookup_elem(map_fd, &key, value); | ||
1856 | - if (!ASSERT_OK(err, "bpf_map_lookup_elem")) | ||
1857 | - goto cleanup; | ||
1858 | - | ||
1859 | - /* and has expected values */ | ||
1860 | - check_values_one_cpu(value, TEST_VALUE); | ||
1861 | - | ||
1862 | -cleanup: | ||
1863 | - test_map_init__destroy(skel); | ||
1864 | -} | ||
1865 | - | ||
1866 | -void test_map_init(void) | ||
1867 | -{ | ||
1868 | - nr_cpus = bpf_num_possible_cpus(); | ||
1869 | - if (nr_cpus <= 1) { | ||
1870 | - printf("%s:SKIP: >1 cpu needed for this test\n", __func__); | ||
1871 | - test__skip(); | ||
1872 | - return; | ||
1873 | - } | ||
1874 | - | ||
1875 | - if (test__start_subtest("pcpu_map_init")) | ||
1876 | - test_pcpu_map_init(); | ||
1877 | - if (test__start_subtest("pcpu_lru_map_init")) | ||
1878 | - test_pcpu_lru_map_init(); | ||
1879 | -} | ||
1880 | diff --git a/tools/testing/selftests/bpf/progs/test_map_init.c b/tools/testing/selftests/bpf/progs/test_map_init.c | ||
1881 | deleted file mode 100644 | ||
1882 | index c89d28ead6737..0000000000000 | ||
1883 | --- a/tools/testing/selftests/bpf/progs/test_map_init.c | ||
1884 | +++ /dev/null | ||
1885 | @@ -1,33 +0,0 @@ | ||
1886 | -// SPDX-License-Identifier: GPL-2.0 | ||
1887 | -/* Copyright (c) 2020 Tessares SA <http://www.tessares.net> */ | ||
1888 | - | ||
1889 | -#include "vmlinux.h" | ||
1890 | -#include <bpf/bpf_helpers.h> | ||
1891 | - | ||
1892 | -__u64 inKey = 0; | ||
1893 | -__u64 inValue = 0; | ||
1894 | -__u32 inPid = 0; | ||
1895 | - | ||
1896 | -struct { | ||
1897 | - __uint(type, BPF_MAP_TYPE_PERCPU_HASH); | ||
1898 | - __uint(max_entries, 2); | ||
1899 | - __type(key, __u64); | ||
1900 | - __type(value, __u64); | ||
1901 | -} hashmap1 SEC(".maps"); | ||
1902 | - | ||
1903 | - | ||
1904 | -SEC("tp/syscalls/sys_enter_getpgid") | ||
1905 | -int sysenter_getpgid(const void *ctx) | ||
1906 | -{ | ||
1907 | - /* Just do it for once, when called from our own test prog. This | ||
1908 | - * ensures the map value is only updated for a single CPU. | ||
1909 | - */ | ||
1910 | - int cur_pid = bpf_get_current_pid_tgid() >> 32; | ||
1911 | - | ||
1912 | - if (cur_pid == inPid) | ||
1913 | - bpf_map_update_elem(&hashmap1, &inKey, &inValue, BPF_NOEXIST); | ||
1914 | - | ||
1915 | - return 0; | ||
1916 | -} | ||
1917 | - | ||
1918 | -char _license[] SEC("license") = "GPL"; |