Annotation of /trunk/kernel-alx/patches-4.14/0149-4.14.50-all-fixes.patch
Parent Directory | Revision Log
Revision 3238 -
(hide annotations)
(download)
Fri Nov 9 12:14:58 2018 UTC (5 years, 10 months ago) by niro
File size: 84844 byte(s)
Fri Nov 9 12:14:58 2018 UTC (5 years, 10 months ago) by niro
File size: 84844 byte(s)
-added up to patches-4.14.79
1 | niro | 3238 | diff --git a/Makefile b/Makefile |
2 | index 480ae7ef755c..84374c5ba60e 100644 | ||
3 | --- a/Makefile | ||
4 | +++ b/Makefile | ||
5 | @@ -1,7 +1,7 @@ | ||
6 | # SPDX-License-Identifier: GPL-2.0 | ||
7 | VERSION = 4 | ||
8 | PATCHLEVEL = 14 | ||
9 | -SUBLEVEL = 49 | ||
10 | +SUBLEVEL = 50 | ||
11 | EXTRAVERSION = | ||
12 | NAME = Petit Gorille | ||
13 | |||
14 | diff --git a/arch/x86/include/asm/kvm_emulate.h b/arch/x86/include/asm/kvm_emulate.h | ||
15 | index ee23a43386a2..8493303d8b2e 100644 | ||
16 | --- a/arch/x86/include/asm/kvm_emulate.h | ||
17 | +++ b/arch/x86/include/asm/kvm_emulate.h | ||
18 | @@ -107,11 +107,12 @@ struct x86_emulate_ops { | ||
19 | * @addr: [IN ] Linear address from which to read. | ||
20 | * @val: [OUT] Value read from memory, zero-extended to 'u_long'. | ||
21 | * @bytes: [IN ] Number of bytes to read from memory. | ||
22 | + * @system:[IN ] Whether the access is forced to be at CPL0. | ||
23 | */ | ||
24 | int (*read_std)(struct x86_emulate_ctxt *ctxt, | ||
25 | unsigned long addr, void *val, | ||
26 | unsigned int bytes, | ||
27 | - struct x86_exception *fault); | ||
28 | + struct x86_exception *fault, bool system); | ||
29 | |||
30 | /* | ||
31 | * read_phys: Read bytes of standard (non-emulated/special) memory. | ||
32 | @@ -129,10 +130,11 @@ struct x86_emulate_ops { | ||
33 | * @addr: [IN ] Linear address to which to write. | ||
34 | * @val: [OUT] Value write to memory, zero-extended to 'u_long'. | ||
35 | * @bytes: [IN ] Number of bytes to write to memory. | ||
36 | + * @system:[IN ] Whether the access is forced to be at CPL0. | ||
37 | */ | ||
38 | int (*write_std)(struct x86_emulate_ctxt *ctxt, | ||
39 | unsigned long addr, void *val, unsigned int bytes, | ||
40 | - struct x86_exception *fault); | ||
41 | + struct x86_exception *fault, bool system); | ||
42 | /* | ||
43 | * fetch: Read bytes of standard (non-emulated/special) memory. | ||
44 | * Used for instruction fetch. | ||
45 | diff --git a/arch/x86/kvm/emulate.c b/arch/x86/kvm/emulate.c | ||
46 | index fab073b19528..5f758568fc44 100644 | ||
47 | --- a/arch/x86/kvm/emulate.c | ||
48 | +++ b/arch/x86/kvm/emulate.c | ||
49 | @@ -811,6 +811,19 @@ static inline int jmp_rel(struct x86_emulate_ctxt *ctxt, int rel) | ||
50 | return assign_eip_near(ctxt, ctxt->_eip + rel); | ||
51 | } | ||
52 | |||
53 | +static int linear_read_system(struct x86_emulate_ctxt *ctxt, ulong linear, | ||
54 | + void *data, unsigned size) | ||
55 | +{ | ||
56 | + return ctxt->ops->read_std(ctxt, linear, data, size, &ctxt->exception, true); | ||
57 | +} | ||
58 | + | ||
59 | +static int linear_write_system(struct x86_emulate_ctxt *ctxt, | ||
60 | + ulong linear, void *data, | ||
61 | + unsigned int size) | ||
62 | +{ | ||
63 | + return ctxt->ops->write_std(ctxt, linear, data, size, &ctxt->exception, true); | ||
64 | +} | ||
65 | + | ||
66 | static int segmented_read_std(struct x86_emulate_ctxt *ctxt, | ||
67 | struct segmented_address addr, | ||
68 | void *data, | ||
69 | @@ -822,7 +835,7 @@ static int segmented_read_std(struct x86_emulate_ctxt *ctxt, | ||
70 | rc = linearize(ctxt, addr, size, false, &linear); | ||
71 | if (rc != X86EMUL_CONTINUE) | ||
72 | return rc; | ||
73 | - return ctxt->ops->read_std(ctxt, linear, data, size, &ctxt->exception); | ||
74 | + return ctxt->ops->read_std(ctxt, linear, data, size, &ctxt->exception, false); | ||
75 | } | ||
76 | |||
77 | static int segmented_write_std(struct x86_emulate_ctxt *ctxt, | ||
78 | @@ -836,7 +849,7 @@ static int segmented_write_std(struct x86_emulate_ctxt *ctxt, | ||
79 | rc = linearize(ctxt, addr, size, true, &linear); | ||
80 | if (rc != X86EMUL_CONTINUE) | ||
81 | return rc; | ||
82 | - return ctxt->ops->write_std(ctxt, linear, data, size, &ctxt->exception); | ||
83 | + return ctxt->ops->write_std(ctxt, linear, data, size, &ctxt->exception, false); | ||
84 | } | ||
85 | |||
86 | /* | ||
87 | @@ -1509,8 +1522,7 @@ static int read_interrupt_descriptor(struct x86_emulate_ctxt *ctxt, | ||
88 | return emulate_gp(ctxt, index << 3 | 0x2); | ||
89 | |||
90 | addr = dt.address + index * 8; | ||
91 | - return ctxt->ops->read_std(ctxt, addr, desc, sizeof *desc, | ||
92 | - &ctxt->exception); | ||
93 | + return linear_read_system(ctxt, addr, desc, sizeof *desc); | ||
94 | } | ||
95 | |||
96 | static void get_descriptor_table_ptr(struct x86_emulate_ctxt *ctxt, | ||
97 | @@ -1573,8 +1585,7 @@ static int read_segment_descriptor(struct x86_emulate_ctxt *ctxt, | ||
98 | if (rc != X86EMUL_CONTINUE) | ||
99 | return rc; | ||
100 | |||
101 | - return ctxt->ops->read_std(ctxt, *desc_addr_p, desc, sizeof(*desc), | ||
102 | - &ctxt->exception); | ||
103 | + return linear_read_system(ctxt, *desc_addr_p, desc, sizeof(*desc)); | ||
104 | } | ||
105 | |||
106 | /* allowed just for 8 bytes segments */ | ||
107 | @@ -1588,8 +1599,7 @@ static int write_segment_descriptor(struct x86_emulate_ctxt *ctxt, | ||
108 | if (rc != X86EMUL_CONTINUE) | ||
109 | return rc; | ||
110 | |||
111 | - return ctxt->ops->write_std(ctxt, addr, desc, sizeof *desc, | ||
112 | - &ctxt->exception); | ||
113 | + return linear_write_system(ctxt, addr, desc, sizeof *desc); | ||
114 | } | ||
115 | |||
116 | static int __load_segment_descriptor(struct x86_emulate_ctxt *ctxt, | ||
117 | @@ -1750,8 +1760,7 @@ static int __load_segment_descriptor(struct x86_emulate_ctxt *ctxt, | ||
118 | return ret; | ||
119 | } | ||
120 | } else if (ctxt->mode == X86EMUL_MODE_PROT64) { | ||
121 | - ret = ctxt->ops->read_std(ctxt, desc_addr+8, &base3, | ||
122 | - sizeof(base3), &ctxt->exception); | ||
123 | + ret = linear_read_system(ctxt, desc_addr+8, &base3, sizeof(base3)); | ||
124 | if (ret != X86EMUL_CONTINUE) | ||
125 | return ret; | ||
126 | if (emul_is_noncanonical_address(get_desc_base(&seg_desc) | | ||
127 | @@ -2064,11 +2073,11 @@ static int __emulate_int_real(struct x86_emulate_ctxt *ctxt, int irq) | ||
128 | eip_addr = dt.address + (irq << 2); | ||
129 | cs_addr = dt.address + (irq << 2) + 2; | ||
130 | |||
131 | - rc = ops->read_std(ctxt, cs_addr, &cs, 2, &ctxt->exception); | ||
132 | + rc = linear_read_system(ctxt, cs_addr, &cs, 2); | ||
133 | if (rc != X86EMUL_CONTINUE) | ||
134 | return rc; | ||
135 | |||
136 | - rc = ops->read_std(ctxt, eip_addr, &eip, 2, &ctxt->exception); | ||
137 | + rc = linear_read_system(ctxt, eip_addr, &eip, 2); | ||
138 | if (rc != X86EMUL_CONTINUE) | ||
139 | return rc; | ||
140 | |||
141 | @@ -2912,12 +2921,12 @@ static bool emulator_io_port_access_allowed(struct x86_emulate_ctxt *ctxt, | ||
142 | #ifdef CONFIG_X86_64 | ||
143 | base |= ((u64)base3) << 32; | ||
144 | #endif | ||
145 | - r = ops->read_std(ctxt, base + 102, &io_bitmap_ptr, 2, NULL); | ||
146 | + r = ops->read_std(ctxt, base + 102, &io_bitmap_ptr, 2, NULL, true); | ||
147 | if (r != X86EMUL_CONTINUE) | ||
148 | return false; | ||
149 | if (io_bitmap_ptr + port/8 > desc_limit_scaled(&tr_seg)) | ||
150 | return false; | ||
151 | - r = ops->read_std(ctxt, base + io_bitmap_ptr + port/8, &perm, 2, NULL); | ||
152 | + r = ops->read_std(ctxt, base + io_bitmap_ptr + port/8, &perm, 2, NULL, true); | ||
153 | if (r != X86EMUL_CONTINUE) | ||
154 | return false; | ||
155 | if ((perm >> bit_idx) & mask) | ||
156 | @@ -3046,35 +3055,30 @@ static int task_switch_16(struct x86_emulate_ctxt *ctxt, | ||
157 | u16 tss_selector, u16 old_tss_sel, | ||
158 | ulong old_tss_base, struct desc_struct *new_desc) | ||
159 | { | ||
160 | - const struct x86_emulate_ops *ops = ctxt->ops; | ||
161 | struct tss_segment_16 tss_seg; | ||
162 | int ret; | ||
163 | u32 new_tss_base = get_desc_base(new_desc); | ||
164 | |||
165 | - ret = ops->read_std(ctxt, old_tss_base, &tss_seg, sizeof tss_seg, | ||
166 | - &ctxt->exception); | ||
167 | + ret = linear_read_system(ctxt, old_tss_base, &tss_seg, sizeof tss_seg); | ||
168 | if (ret != X86EMUL_CONTINUE) | ||
169 | return ret; | ||
170 | |||
171 | save_state_to_tss16(ctxt, &tss_seg); | ||
172 | |||
173 | - ret = ops->write_std(ctxt, old_tss_base, &tss_seg, sizeof tss_seg, | ||
174 | - &ctxt->exception); | ||
175 | + ret = linear_write_system(ctxt, old_tss_base, &tss_seg, sizeof tss_seg); | ||
176 | if (ret != X86EMUL_CONTINUE) | ||
177 | return ret; | ||
178 | |||
179 | - ret = ops->read_std(ctxt, new_tss_base, &tss_seg, sizeof tss_seg, | ||
180 | - &ctxt->exception); | ||
181 | + ret = linear_read_system(ctxt, new_tss_base, &tss_seg, sizeof tss_seg); | ||
182 | if (ret != X86EMUL_CONTINUE) | ||
183 | return ret; | ||
184 | |||
185 | if (old_tss_sel != 0xffff) { | ||
186 | tss_seg.prev_task_link = old_tss_sel; | ||
187 | |||
188 | - ret = ops->write_std(ctxt, new_tss_base, | ||
189 | - &tss_seg.prev_task_link, | ||
190 | - sizeof tss_seg.prev_task_link, | ||
191 | - &ctxt->exception); | ||
192 | + ret = linear_write_system(ctxt, new_tss_base, | ||
193 | + &tss_seg.prev_task_link, | ||
194 | + sizeof tss_seg.prev_task_link); | ||
195 | if (ret != X86EMUL_CONTINUE) | ||
196 | return ret; | ||
197 | } | ||
198 | @@ -3190,38 +3194,34 @@ static int task_switch_32(struct x86_emulate_ctxt *ctxt, | ||
199 | u16 tss_selector, u16 old_tss_sel, | ||
200 | ulong old_tss_base, struct desc_struct *new_desc) | ||
201 | { | ||
202 | - const struct x86_emulate_ops *ops = ctxt->ops; | ||
203 | struct tss_segment_32 tss_seg; | ||
204 | int ret; | ||
205 | u32 new_tss_base = get_desc_base(new_desc); | ||
206 | u32 eip_offset = offsetof(struct tss_segment_32, eip); | ||
207 | u32 ldt_sel_offset = offsetof(struct tss_segment_32, ldt_selector); | ||
208 | |||
209 | - ret = ops->read_std(ctxt, old_tss_base, &tss_seg, sizeof tss_seg, | ||
210 | - &ctxt->exception); | ||
211 | + ret = linear_read_system(ctxt, old_tss_base, &tss_seg, sizeof tss_seg); | ||
212 | if (ret != X86EMUL_CONTINUE) | ||
213 | return ret; | ||
214 | |||
215 | save_state_to_tss32(ctxt, &tss_seg); | ||
216 | |||
217 | /* Only GP registers and segment selectors are saved */ | ||
218 | - ret = ops->write_std(ctxt, old_tss_base + eip_offset, &tss_seg.eip, | ||
219 | - ldt_sel_offset - eip_offset, &ctxt->exception); | ||
220 | + ret = linear_write_system(ctxt, old_tss_base + eip_offset, &tss_seg.eip, | ||
221 | + ldt_sel_offset - eip_offset); | ||
222 | if (ret != X86EMUL_CONTINUE) | ||
223 | return ret; | ||
224 | |||
225 | - ret = ops->read_std(ctxt, new_tss_base, &tss_seg, sizeof tss_seg, | ||
226 | - &ctxt->exception); | ||
227 | + ret = linear_read_system(ctxt, new_tss_base, &tss_seg, sizeof tss_seg); | ||
228 | if (ret != X86EMUL_CONTINUE) | ||
229 | return ret; | ||
230 | |||
231 | if (old_tss_sel != 0xffff) { | ||
232 | tss_seg.prev_task_link = old_tss_sel; | ||
233 | |||
234 | - ret = ops->write_std(ctxt, new_tss_base, | ||
235 | - &tss_seg.prev_task_link, | ||
236 | - sizeof tss_seg.prev_task_link, | ||
237 | - &ctxt->exception); | ||
238 | + ret = linear_write_system(ctxt, new_tss_base, | ||
239 | + &tss_seg.prev_task_link, | ||
240 | + sizeof tss_seg.prev_task_link); | ||
241 | if (ret != X86EMUL_CONTINUE) | ||
242 | return ret; | ||
243 | } | ||
244 | @@ -4152,7 +4152,9 @@ static int check_cr_write(struct x86_emulate_ctxt *ctxt) | ||
245 | maxphyaddr = eax & 0xff; | ||
246 | else | ||
247 | maxphyaddr = 36; | ||
248 | - rsvd = rsvd_bits(maxphyaddr, 62); | ||
249 | + rsvd = rsvd_bits(maxphyaddr, 63); | ||
250 | + if (ctxt->ops->get_cr(ctxt, 4) & X86_CR4_PCIDE) | ||
251 | + rsvd &= ~CR3_PCID_INVD; | ||
252 | } | ||
253 | |||
254 | if (new_val & rsvd) | ||
255 | diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c | ||
256 | index 4c88572d2b81..b1556166a06d 100644 | ||
257 | --- a/arch/x86/kvm/vmx.c | ||
258 | +++ b/arch/x86/kvm/vmx.c | ||
259 | @@ -7317,8 +7317,7 @@ static int nested_vmx_get_vmptr(struct kvm_vcpu *vcpu, gpa_t *vmpointer) | ||
260 | vmcs_read32(VMX_INSTRUCTION_INFO), false, &gva)) | ||
261 | return 1; | ||
262 | |||
263 | - if (kvm_read_guest_virt(&vcpu->arch.emulate_ctxt, gva, vmpointer, | ||
264 | - sizeof(*vmpointer), &e)) { | ||
265 | + if (kvm_read_guest_virt(vcpu, gva, vmpointer, sizeof(*vmpointer), &e)) { | ||
266 | kvm_inject_page_fault(vcpu, &e); | ||
267 | return 1; | ||
268 | } | ||
269 | @@ -7399,6 +7398,12 @@ static int handle_vmon(struct kvm_vcpu *vcpu) | ||
270 | return 1; | ||
271 | } | ||
272 | |||
273 | + /* CPL=0 must be checked manually. */ | ||
274 | + if (vmx_get_cpl(vcpu)) { | ||
275 | + kvm_queue_exception(vcpu, UD_VECTOR); | ||
276 | + return 1; | ||
277 | + } | ||
278 | + | ||
279 | if (vmx->nested.vmxon) { | ||
280 | nested_vmx_failValid(vcpu, VMXERR_VMXON_IN_VMX_ROOT_OPERATION); | ||
281 | return kvm_skip_emulated_instruction(vcpu); | ||
282 | @@ -7458,6 +7463,11 @@ static int handle_vmon(struct kvm_vcpu *vcpu) | ||
283 | */ | ||
284 | static int nested_vmx_check_permission(struct kvm_vcpu *vcpu) | ||
285 | { | ||
286 | + if (vmx_get_cpl(vcpu)) { | ||
287 | + kvm_queue_exception(vcpu, UD_VECTOR); | ||
288 | + return 0; | ||
289 | + } | ||
290 | + | ||
291 | if (!to_vmx(vcpu)->nested.vmxon) { | ||
292 | kvm_queue_exception(vcpu, UD_VECTOR); | ||
293 | return 0; | ||
294 | @@ -7790,9 +7800,9 @@ static int handle_vmread(struct kvm_vcpu *vcpu) | ||
295 | if (get_vmx_mem_address(vcpu, exit_qualification, | ||
296 | vmx_instruction_info, true, &gva)) | ||
297 | return 1; | ||
298 | - /* _system ok, as hardware has verified cpl=0 */ | ||
299 | - kvm_write_guest_virt_system(&vcpu->arch.emulate_ctxt, gva, | ||
300 | - &field_value, (is_long_mode(vcpu) ? 8 : 4), NULL); | ||
301 | + /* _system ok, nested_vmx_check_permission has verified cpl=0 */ | ||
302 | + kvm_write_guest_virt_system(vcpu, gva, &field_value, | ||
303 | + (is_long_mode(vcpu) ? 8 : 4), NULL); | ||
304 | } | ||
305 | |||
306 | nested_vmx_succeed(vcpu); | ||
307 | @@ -7828,8 +7838,8 @@ static int handle_vmwrite(struct kvm_vcpu *vcpu) | ||
308 | if (get_vmx_mem_address(vcpu, exit_qualification, | ||
309 | vmx_instruction_info, false, &gva)) | ||
310 | return 1; | ||
311 | - if (kvm_read_guest_virt(&vcpu->arch.emulate_ctxt, gva, | ||
312 | - &field_value, (is_64_bit_mode(vcpu) ? 8 : 4), &e)) { | ||
313 | + if (kvm_read_guest_virt(vcpu, gva, &field_value, | ||
314 | + (is_64_bit_mode(vcpu) ? 8 : 4), &e)) { | ||
315 | kvm_inject_page_fault(vcpu, &e); | ||
316 | return 1; | ||
317 | } | ||
318 | @@ -7933,10 +7943,10 @@ static int handle_vmptrst(struct kvm_vcpu *vcpu) | ||
319 | if (get_vmx_mem_address(vcpu, exit_qualification, | ||
320 | vmx_instruction_info, true, &vmcs_gva)) | ||
321 | return 1; | ||
322 | - /* ok to use *_system, as hardware has verified cpl=0 */ | ||
323 | - if (kvm_write_guest_virt_system(&vcpu->arch.emulate_ctxt, vmcs_gva, | ||
324 | - (void *)&to_vmx(vcpu)->nested.current_vmptr, | ||
325 | - sizeof(u64), &e)) { | ||
326 | + /* *_system ok, nested_vmx_check_permission has verified cpl=0 */ | ||
327 | + if (kvm_write_guest_virt_system(vcpu, vmcs_gva, | ||
328 | + (void *)&to_vmx(vcpu)->nested.current_vmptr, | ||
329 | + sizeof(u64), &e)) { | ||
330 | kvm_inject_page_fault(vcpu, &e); | ||
331 | return 1; | ||
332 | } | ||
333 | @@ -7983,8 +7993,7 @@ static int handle_invept(struct kvm_vcpu *vcpu) | ||
334 | if (get_vmx_mem_address(vcpu, vmcs_readl(EXIT_QUALIFICATION), | ||
335 | vmx_instruction_info, false, &gva)) | ||
336 | return 1; | ||
337 | - if (kvm_read_guest_virt(&vcpu->arch.emulate_ctxt, gva, &operand, | ||
338 | - sizeof(operand), &e)) { | ||
339 | + if (kvm_read_guest_virt(vcpu, gva, &operand, sizeof(operand), &e)) { | ||
340 | kvm_inject_page_fault(vcpu, &e); | ||
341 | return 1; | ||
342 | } | ||
343 | @@ -8048,8 +8057,7 @@ static int handle_invvpid(struct kvm_vcpu *vcpu) | ||
344 | if (get_vmx_mem_address(vcpu, vmcs_readl(EXIT_QUALIFICATION), | ||
345 | vmx_instruction_info, false, &gva)) | ||
346 | return 1; | ||
347 | - if (kvm_read_guest_virt(&vcpu->arch.emulate_ctxt, gva, &operand, | ||
348 | - sizeof(operand), &e)) { | ||
349 | + if (kvm_read_guest_virt(vcpu, gva, &operand, sizeof(operand), &e)) { | ||
350 | kvm_inject_page_fault(vcpu, &e); | ||
351 | return 1; | ||
352 | } | ||
353 | diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c | ||
354 | index adac01d0181a..b62328cd4cb0 100644 | ||
355 | --- a/arch/x86/kvm/x86.c | ||
356 | +++ b/arch/x86/kvm/x86.c | ||
357 | @@ -836,7 +836,7 @@ int kvm_set_cr3(struct kvm_vcpu *vcpu, unsigned long cr3) | ||
358 | } | ||
359 | |||
360 | if (is_long_mode(vcpu) && | ||
361 | - (cr3 & rsvd_bits(cpuid_maxphyaddr(vcpu), 62))) | ||
362 | + (cr3 & rsvd_bits(cpuid_maxphyaddr(vcpu), 63))) | ||
363 | return 1; | ||
364 | else if (is_pae(vcpu) && is_paging(vcpu) && | ||
365 | !load_pdptrs(vcpu, vcpu->arch.walk_mmu, cr3)) | ||
366 | @@ -4492,11 +4492,10 @@ static int kvm_fetch_guest_virt(struct x86_emulate_ctxt *ctxt, | ||
367 | return X86EMUL_CONTINUE; | ||
368 | } | ||
369 | |||
370 | -int kvm_read_guest_virt(struct x86_emulate_ctxt *ctxt, | ||
371 | +int kvm_read_guest_virt(struct kvm_vcpu *vcpu, | ||
372 | gva_t addr, void *val, unsigned int bytes, | ||
373 | struct x86_exception *exception) | ||
374 | { | ||
375 | - struct kvm_vcpu *vcpu = emul_to_vcpu(ctxt); | ||
376 | u32 access = (kvm_x86_ops->get_cpl(vcpu) == 3) ? PFERR_USER_MASK : 0; | ||
377 | |||
378 | return kvm_read_guest_virt_helper(addr, val, bytes, vcpu, access, | ||
379 | @@ -4504,12 +4503,17 @@ int kvm_read_guest_virt(struct x86_emulate_ctxt *ctxt, | ||
380 | } | ||
381 | EXPORT_SYMBOL_GPL(kvm_read_guest_virt); | ||
382 | |||
383 | -static int kvm_read_guest_virt_system(struct x86_emulate_ctxt *ctxt, | ||
384 | - gva_t addr, void *val, unsigned int bytes, | ||
385 | - struct x86_exception *exception) | ||
386 | +static int emulator_read_std(struct x86_emulate_ctxt *ctxt, | ||
387 | + gva_t addr, void *val, unsigned int bytes, | ||
388 | + struct x86_exception *exception, bool system) | ||
389 | { | ||
390 | struct kvm_vcpu *vcpu = emul_to_vcpu(ctxt); | ||
391 | - return kvm_read_guest_virt_helper(addr, val, bytes, vcpu, 0, exception); | ||
392 | + u32 access = 0; | ||
393 | + | ||
394 | + if (!system && kvm_x86_ops->get_cpl(vcpu) == 3) | ||
395 | + access |= PFERR_USER_MASK; | ||
396 | + | ||
397 | + return kvm_read_guest_virt_helper(addr, val, bytes, vcpu, access, exception); | ||
398 | } | ||
399 | |||
400 | static int kvm_read_guest_phys_system(struct x86_emulate_ctxt *ctxt, | ||
401 | @@ -4521,18 +4525,16 @@ static int kvm_read_guest_phys_system(struct x86_emulate_ctxt *ctxt, | ||
402 | return r < 0 ? X86EMUL_IO_NEEDED : X86EMUL_CONTINUE; | ||
403 | } | ||
404 | |||
405 | -int kvm_write_guest_virt_system(struct x86_emulate_ctxt *ctxt, | ||
406 | - gva_t addr, void *val, | ||
407 | - unsigned int bytes, | ||
408 | - struct x86_exception *exception) | ||
409 | +static int kvm_write_guest_virt_helper(gva_t addr, void *val, unsigned int bytes, | ||
410 | + struct kvm_vcpu *vcpu, u32 access, | ||
411 | + struct x86_exception *exception) | ||
412 | { | ||
413 | - struct kvm_vcpu *vcpu = emul_to_vcpu(ctxt); | ||
414 | void *data = val; | ||
415 | int r = X86EMUL_CONTINUE; | ||
416 | |||
417 | while (bytes) { | ||
418 | gpa_t gpa = vcpu->arch.walk_mmu->gva_to_gpa(vcpu, addr, | ||
419 | - PFERR_WRITE_MASK, | ||
420 | + access, | ||
421 | exception); | ||
422 | unsigned offset = addr & (PAGE_SIZE-1); | ||
423 | unsigned towrite = min(bytes, (unsigned)PAGE_SIZE - offset); | ||
424 | @@ -4553,6 +4555,27 @@ int kvm_write_guest_virt_system(struct x86_emulate_ctxt *ctxt, | ||
425 | out: | ||
426 | return r; | ||
427 | } | ||
428 | + | ||
429 | +static int emulator_write_std(struct x86_emulate_ctxt *ctxt, gva_t addr, void *val, | ||
430 | + unsigned int bytes, struct x86_exception *exception, | ||
431 | + bool system) | ||
432 | +{ | ||
433 | + struct kvm_vcpu *vcpu = emul_to_vcpu(ctxt); | ||
434 | + u32 access = PFERR_WRITE_MASK; | ||
435 | + | ||
436 | + if (!system && kvm_x86_ops->get_cpl(vcpu) == 3) | ||
437 | + access |= PFERR_USER_MASK; | ||
438 | + | ||
439 | + return kvm_write_guest_virt_helper(addr, val, bytes, vcpu, | ||
440 | + access, exception); | ||
441 | +} | ||
442 | + | ||
443 | +int kvm_write_guest_virt_system(struct kvm_vcpu *vcpu, gva_t addr, void *val, | ||
444 | + unsigned int bytes, struct x86_exception *exception) | ||
445 | +{ | ||
446 | + return kvm_write_guest_virt_helper(addr, val, bytes, vcpu, | ||
447 | + PFERR_WRITE_MASK, exception); | ||
448 | +} | ||
449 | EXPORT_SYMBOL_GPL(kvm_write_guest_virt_system); | ||
450 | |||
451 | static int vcpu_is_mmio_gpa(struct kvm_vcpu *vcpu, unsigned long gva, | ||
452 | @@ -5287,8 +5310,8 @@ static void emulator_set_hflags(struct x86_emulate_ctxt *ctxt, unsigned emul_fla | ||
453 | static const struct x86_emulate_ops emulate_ops = { | ||
454 | .read_gpr = emulator_read_gpr, | ||
455 | .write_gpr = emulator_write_gpr, | ||
456 | - .read_std = kvm_read_guest_virt_system, | ||
457 | - .write_std = kvm_write_guest_virt_system, | ||
458 | + .read_std = emulator_read_std, | ||
459 | + .write_std = emulator_write_std, | ||
460 | .read_phys = kvm_read_guest_phys_system, | ||
461 | .fetch = kvm_fetch_guest_virt, | ||
462 | .read_emulated = emulator_read_emulated, | ||
463 | diff --git a/arch/x86/kvm/x86.h b/arch/x86/kvm/x86.h | ||
464 | index 6d112d8f799c..d4b59cf0dc51 100644 | ||
465 | --- a/arch/x86/kvm/x86.h | ||
466 | +++ b/arch/x86/kvm/x86.h | ||
467 | @@ -213,11 +213,11 @@ int kvm_inject_realmode_interrupt(struct kvm_vcpu *vcpu, int irq, int inc_eip); | ||
468 | void kvm_write_tsc(struct kvm_vcpu *vcpu, struct msr_data *msr); | ||
469 | u64 get_kvmclock_ns(struct kvm *kvm); | ||
470 | |||
471 | -int kvm_read_guest_virt(struct x86_emulate_ctxt *ctxt, | ||
472 | +int kvm_read_guest_virt(struct kvm_vcpu *vcpu, | ||
473 | gva_t addr, void *val, unsigned int bytes, | ||
474 | struct x86_exception *exception); | ||
475 | |||
476 | -int kvm_write_guest_virt_system(struct x86_emulate_ctxt *ctxt, | ||
477 | +int kvm_write_guest_virt_system(struct kvm_vcpu *vcpu, | ||
478 | gva_t addr, void *val, unsigned int bytes, | ||
479 | struct x86_exception *exception); | ||
480 | |||
481 | diff --git a/block/blk-zoned.c b/block/blk-zoned.c | ||
482 | index ff57fb51b338..77fce6f09f78 100644 | ||
483 | --- a/block/blk-zoned.c | ||
484 | +++ b/block/blk-zoned.c | ||
485 | @@ -286,7 +286,11 @@ int blkdev_report_zones_ioctl(struct block_device *bdev, fmode_t mode, | ||
486 | if (!rep.nr_zones) | ||
487 | return -EINVAL; | ||
488 | |||
489 | - zones = kcalloc(rep.nr_zones, sizeof(struct blk_zone), GFP_KERNEL); | ||
490 | + if (rep.nr_zones > INT_MAX / sizeof(struct blk_zone)) | ||
491 | + return -ERANGE; | ||
492 | + | ||
493 | + zones = kvmalloc(rep.nr_zones * sizeof(struct blk_zone), | ||
494 | + GFP_KERNEL | __GFP_ZERO); | ||
495 | if (!zones) | ||
496 | return -ENOMEM; | ||
497 | |||
498 | @@ -308,7 +312,7 @@ int blkdev_report_zones_ioctl(struct block_device *bdev, fmode_t mode, | ||
499 | } | ||
500 | |||
501 | out: | ||
502 | - kfree(zones); | ||
503 | + kvfree(zones); | ||
504 | |||
505 | return ret; | ||
506 | } | ||
507 | diff --git a/drivers/crypto/caam/caamalg.c b/drivers/crypto/caam/caamalg.c | ||
508 | index 54f3b375a453..a8a2a271b63d 100644 | ||
509 | --- a/drivers/crypto/caam/caamalg.c | ||
510 | +++ b/drivers/crypto/caam/caamalg.c | ||
511 | @@ -735,15 +735,18 @@ struct aead_edesc { | ||
512 | * @src_nents: number of segments in input s/w scatterlist | ||
513 | * @dst_nents: number of segments in output s/w scatterlist | ||
514 | * @iv_dma: dma address of iv for checking continuity and link table | ||
515 | + * @iv_dir: DMA mapping direction for IV | ||
516 | * @sec4_sg_bytes: length of dma mapped sec4_sg space | ||
517 | * @sec4_sg_dma: bus physical mapped address of h/w link table | ||
518 | * @sec4_sg: pointer to h/w link table | ||
519 | * @hw_desc: the h/w job descriptor followed by any referenced link tables | ||
520 | + * and IV | ||
521 | */ | ||
522 | struct ablkcipher_edesc { | ||
523 | int src_nents; | ||
524 | int dst_nents; | ||
525 | dma_addr_t iv_dma; | ||
526 | + enum dma_data_direction iv_dir; | ||
527 | int sec4_sg_bytes; | ||
528 | dma_addr_t sec4_sg_dma; | ||
529 | struct sec4_sg_entry *sec4_sg; | ||
530 | @@ -753,7 +756,8 @@ struct ablkcipher_edesc { | ||
531 | static void caam_unmap(struct device *dev, struct scatterlist *src, | ||
532 | struct scatterlist *dst, int src_nents, | ||
533 | int dst_nents, | ||
534 | - dma_addr_t iv_dma, int ivsize, dma_addr_t sec4_sg_dma, | ||
535 | + dma_addr_t iv_dma, int ivsize, | ||
536 | + enum dma_data_direction iv_dir, dma_addr_t sec4_sg_dma, | ||
537 | int sec4_sg_bytes) | ||
538 | { | ||
539 | if (dst != src) { | ||
540 | @@ -765,7 +769,7 @@ static void caam_unmap(struct device *dev, struct scatterlist *src, | ||
541 | } | ||
542 | |||
543 | if (iv_dma) | ||
544 | - dma_unmap_single(dev, iv_dma, ivsize, DMA_TO_DEVICE); | ||
545 | + dma_unmap_single(dev, iv_dma, ivsize, iv_dir); | ||
546 | if (sec4_sg_bytes) | ||
547 | dma_unmap_single(dev, sec4_sg_dma, sec4_sg_bytes, | ||
548 | DMA_TO_DEVICE); | ||
549 | @@ -776,7 +780,7 @@ static void aead_unmap(struct device *dev, | ||
550 | struct aead_request *req) | ||
551 | { | ||
552 | caam_unmap(dev, req->src, req->dst, | ||
553 | - edesc->src_nents, edesc->dst_nents, 0, 0, | ||
554 | + edesc->src_nents, edesc->dst_nents, 0, 0, DMA_NONE, | ||
555 | edesc->sec4_sg_dma, edesc->sec4_sg_bytes); | ||
556 | } | ||
557 | |||
558 | @@ -789,7 +793,7 @@ static void ablkcipher_unmap(struct device *dev, | ||
559 | |||
560 | caam_unmap(dev, req->src, req->dst, | ||
561 | edesc->src_nents, edesc->dst_nents, | ||
562 | - edesc->iv_dma, ivsize, | ||
563 | + edesc->iv_dma, ivsize, edesc->iv_dir, | ||
564 | edesc->sec4_sg_dma, edesc->sec4_sg_bytes); | ||
565 | } | ||
566 | |||
567 | @@ -878,6 +882,18 @@ static void ablkcipher_encrypt_done(struct device *jrdev, u32 *desc, u32 err, | ||
568 | scatterwalk_map_and_copy(req->info, req->dst, req->nbytes - ivsize, | ||
569 | ivsize, 0); | ||
570 | |||
571 | + /* In case initial IV was generated, copy it in GIVCIPHER request */ | ||
572 | + if (edesc->iv_dir == DMA_FROM_DEVICE) { | ||
573 | + u8 *iv; | ||
574 | + struct skcipher_givcrypt_request *greq; | ||
575 | + | ||
576 | + greq = container_of(req, struct skcipher_givcrypt_request, | ||
577 | + creq); | ||
578 | + iv = (u8 *)edesc->hw_desc + desc_bytes(edesc->hw_desc) + | ||
579 | + edesc->sec4_sg_bytes; | ||
580 | + memcpy(greq->giv, iv, ivsize); | ||
581 | + } | ||
582 | + | ||
583 | kfree(edesc); | ||
584 | |||
585 | ablkcipher_request_complete(req, err); | ||
586 | @@ -888,10 +904,10 @@ static void ablkcipher_decrypt_done(struct device *jrdev, u32 *desc, u32 err, | ||
587 | { | ||
588 | struct ablkcipher_request *req = context; | ||
589 | struct ablkcipher_edesc *edesc; | ||
590 | +#ifdef DEBUG | ||
591 | struct crypto_ablkcipher *ablkcipher = crypto_ablkcipher_reqtfm(req); | ||
592 | int ivsize = crypto_ablkcipher_ivsize(ablkcipher); | ||
593 | |||
594 | -#ifdef DEBUG | ||
595 | dev_err(jrdev, "%s %d: err 0x%x\n", __func__, __LINE__, err); | ||
596 | #endif | ||
597 | |||
598 | @@ -909,14 +925,6 @@ static void ablkcipher_decrypt_done(struct device *jrdev, u32 *desc, u32 err, | ||
599 | edesc->dst_nents > 1 ? 100 : req->nbytes, 1); | ||
600 | |||
601 | ablkcipher_unmap(jrdev, edesc, req); | ||
602 | - | ||
603 | - /* | ||
604 | - * The crypto API expects us to set the IV (req->info) to the last | ||
605 | - * ciphertext block. | ||
606 | - */ | ||
607 | - scatterwalk_map_and_copy(req->info, req->src, req->nbytes - ivsize, | ||
608 | - ivsize, 0); | ||
609 | - | ||
610 | kfree(edesc); | ||
611 | |||
612 | ablkcipher_request_complete(req, err); | ||
613 | @@ -1057,15 +1065,14 @@ static void init_authenc_job(struct aead_request *req, | ||
614 | */ | ||
615 | static void init_ablkcipher_job(u32 *sh_desc, dma_addr_t ptr, | ||
616 | struct ablkcipher_edesc *edesc, | ||
617 | - struct ablkcipher_request *req, | ||
618 | - bool iv_contig) | ||
619 | + struct ablkcipher_request *req) | ||
620 | { | ||
621 | struct crypto_ablkcipher *ablkcipher = crypto_ablkcipher_reqtfm(req); | ||
622 | int ivsize = crypto_ablkcipher_ivsize(ablkcipher); | ||
623 | u32 *desc = edesc->hw_desc; | ||
624 | - u32 out_options = 0, in_options; | ||
625 | - dma_addr_t dst_dma, src_dma; | ||
626 | - int len, sec4_sg_index = 0; | ||
627 | + u32 out_options = 0; | ||
628 | + dma_addr_t dst_dma; | ||
629 | + int len; | ||
630 | |||
631 | #ifdef DEBUG | ||
632 | print_hex_dump(KERN_ERR, "presciv@"__stringify(__LINE__)": ", | ||
633 | @@ -1081,30 +1088,18 @@ static void init_ablkcipher_job(u32 *sh_desc, dma_addr_t ptr, | ||
634 | len = desc_len(sh_desc); | ||
635 | init_job_desc_shared(desc, ptr, len, HDR_SHARE_DEFER | HDR_REVERSE); | ||
636 | |||
637 | - if (iv_contig) { | ||
638 | - src_dma = edesc->iv_dma; | ||
639 | - in_options = 0; | ||
640 | - } else { | ||
641 | - src_dma = edesc->sec4_sg_dma; | ||
642 | - sec4_sg_index += edesc->src_nents + 1; | ||
643 | - in_options = LDST_SGF; | ||
644 | - } | ||
645 | - append_seq_in_ptr(desc, src_dma, req->nbytes + ivsize, in_options); | ||
646 | + append_seq_in_ptr(desc, edesc->sec4_sg_dma, req->nbytes + ivsize, | ||
647 | + LDST_SGF); | ||
648 | |||
649 | if (likely(req->src == req->dst)) { | ||
650 | - if (edesc->src_nents == 1 && iv_contig) { | ||
651 | - dst_dma = sg_dma_address(req->src); | ||
652 | - } else { | ||
653 | - dst_dma = edesc->sec4_sg_dma + | ||
654 | - sizeof(struct sec4_sg_entry); | ||
655 | - out_options = LDST_SGF; | ||
656 | - } | ||
657 | + dst_dma = edesc->sec4_sg_dma + sizeof(struct sec4_sg_entry); | ||
658 | + out_options = LDST_SGF; | ||
659 | } else { | ||
660 | if (edesc->dst_nents == 1) { | ||
661 | dst_dma = sg_dma_address(req->dst); | ||
662 | } else { | ||
663 | - dst_dma = edesc->sec4_sg_dma + | ||
664 | - sec4_sg_index * sizeof(struct sec4_sg_entry); | ||
665 | + dst_dma = edesc->sec4_sg_dma + (edesc->src_nents + 1) * | ||
666 | + sizeof(struct sec4_sg_entry); | ||
667 | out_options = LDST_SGF; | ||
668 | } | ||
669 | } | ||
670 | @@ -1116,13 +1111,12 @@ static void init_ablkcipher_job(u32 *sh_desc, dma_addr_t ptr, | ||
671 | */ | ||
672 | static void init_ablkcipher_giv_job(u32 *sh_desc, dma_addr_t ptr, | ||
673 | struct ablkcipher_edesc *edesc, | ||
674 | - struct ablkcipher_request *req, | ||
675 | - bool iv_contig) | ||
676 | + struct ablkcipher_request *req) | ||
677 | { | ||
678 | struct crypto_ablkcipher *ablkcipher = crypto_ablkcipher_reqtfm(req); | ||
679 | int ivsize = crypto_ablkcipher_ivsize(ablkcipher); | ||
680 | u32 *desc = edesc->hw_desc; | ||
681 | - u32 out_options, in_options; | ||
682 | + u32 in_options; | ||
683 | dma_addr_t dst_dma, src_dma; | ||
684 | int len, sec4_sg_index = 0; | ||
685 | |||
686 | @@ -1148,15 +1142,9 @@ static void init_ablkcipher_giv_job(u32 *sh_desc, dma_addr_t ptr, | ||
687 | } | ||
688 | append_seq_in_ptr(desc, src_dma, req->nbytes, in_options); | ||
689 | |||
690 | - if (iv_contig) { | ||
691 | - dst_dma = edesc->iv_dma; | ||
692 | - out_options = 0; | ||
693 | - } else { | ||
694 | - dst_dma = edesc->sec4_sg_dma + | ||
695 | - sec4_sg_index * sizeof(struct sec4_sg_entry); | ||
696 | - out_options = LDST_SGF; | ||
697 | - } | ||
698 | - append_seq_out_ptr(desc, dst_dma, req->nbytes + ivsize, out_options); | ||
699 | + dst_dma = edesc->sec4_sg_dma + sec4_sg_index * | ||
700 | + sizeof(struct sec4_sg_entry); | ||
701 | + append_seq_out_ptr(desc, dst_dma, req->nbytes + ivsize, LDST_SGF); | ||
702 | } | ||
703 | |||
704 | /* | ||
705 | @@ -1245,7 +1233,7 @@ static struct aead_edesc *aead_edesc_alloc(struct aead_request *req, | ||
706 | GFP_DMA | flags); | ||
707 | if (!edesc) { | ||
708 | caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, 0, | ||
709 | - 0, 0, 0); | ||
710 | + 0, DMA_NONE, 0, 0); | ||
711 | return ERR_PTR(-ENOMEM); | ||
712 | } | ||
713 | |||
714 | @@ -1449,8 +1437,7 @@ static int aead_decrypt(struct aead_request *req) | ||
715 | * allocate and map the ablkcipher extended descriptor for ablkcipher | ||
716 | */ | ||
717 | static struct ablkcipher_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request | ||
718 | - *req, int desc_bytes, | ||
719 | - bool *iv_contig_out) | ||
720 | + *req, int desc_bytes) | ||
721 | { | ||
722 | struct crypto_ablkcipher *ablkcipher = crypto_ablkcipher_reqtfm(req); | ||
723 | struct caam_ctx *ctx = crypto_ablkcipher_ctx(ablkcipher); | ||
724 | @@ -1459,8 +1446,8 @@ static struct ablkcipher_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request | ||
725 | GFP_KERNEL : GFP_ATOMIC; | ||
726 | int src_nents, mapped_src_nents, dst_nents = 0, mapped_dst_nents = 0; | ||
727 | struct ablkcipher_edesc *edesc; | ||
728 | - dma_addr_t iv_dma = 0; | ||
729 | - bool in_contig; | ||
730 | + dma_addr_t iv_dma; | ||
731 | + u8 *iv; | ||
732 | int ivsize = crypto_ablkcipher_ivsize(ablkcipher); | ||
733 | int dst_sg_idx, sec4_sg_ents, sec4_sg_bytes; | ||
734 | |||
735 | @@ -1504,33 +1491,20 @@ static struct ablkcipher_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request | ||
736 | } | ||
737 | } | ||
738 | |||
739 | - iv_dma = dma_map_single(jrdev, req->info, ivsize, DMA_TO_DEVICE); | ||
740 | - if (dma_mapping_error(jrdev, iv_dma)) { | ||
741 | - dev_err(jrdev, "unable to map IV\n"); | ||
742 | - caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, 0, | ||
743 | - 0, 0, 0); | ||
744 | - return ERR_PTR(-ENOMEM); | ||
745 | - } | ||
746 | - | ||
747 | - if (mapped_src_nents == 1 && | ||
748 | - iv_dma + ivsize == sg_dma_address(req->src)) { | ||
749 | - in_contig = true; | ||
750 | - sec4_sg_ents = 0; | ||
751 | - } else { | ||
752 | - in_contig = false; | ||
753 | - sec4_sg_ents = 1 + mapped_src_nents; | ||
754 | - } | ||
755 | + sec4_sg_ents = 1 + mapped_src_nents; | ||
756 | dst_sg_idx = sec4_sg_ents; | ||
757 | sec4_sg_ents += mapped_dst_nents > 1 ? mapped_dst_nents : 0; | ||
758 | sec4_sg_bytes = sec4_sg_ents * sizeof(struct sec4_sg_entry); | ||
759 | |||
760 | - /* allocate space for base edesc and hw desc commands, link tables */ | ||
761 | - edesc = kzalloc(sizeof(*edesc) + desc_bytes + sec4_sg_bytes, | ||
762 | + /* | ||
763 | + * allocate space for base edesc and hw desc commands, link tables, IV | ||
764 | + */ | ||
765 | + edesc = kzalloc(sizeof(*edesc) + desc_bytes + sec4_sg_bytes + ivsize, | ||
766 | GFP_DMA | flags); | ||
767 | if (!edesc) { | ||
768 | dev_err(jrdev, "could not allocate extended descriptor\n"); | ||
769 | - caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, | ||
770 | - iv_dma, ivsize, 0, 0); | ||
771 | + caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, 0, | ||
772 | + 0, DMA_NONE, 0, 0); | ||
773 | return ERR_PTR(-ENOMEM); | ||
774 | } | ||
775 | |||
776 | @@ -1539,13 +1513,24 @@ static struct ablkcipher_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request | ||
777 | edesc->sec4_sg_bytes = sec4_sg_bytes; | ||
778 | edesc->sec4_sg = (void *)edesc + sizeof(struct ablkcipher_edesc) + | ||
779 | desc_bytes; | ||
780 | + edesc->iv_dir = DMA_TO_DEVICE; | ||
781 | |||
782 | - if (!in_contig) { | ||
783 | - dma_to_sec4_sg_one(edesc->sec4_sg, iv_dma, ivsize, 0); | ||
784 | - sg_to_sec4_sg_last(req->src, mapped_src_nents, | ||
785 | - edesc->sec4_sg + 1, 0); | ||
786 | + /* Make sure IV is located in a DMAable area */ | ||
787 | + iv = (u8 *)edesc->hw_desc + desc_bytes + sec4_sg_bytes; | ||
788 | + memcpy(iv, req->info, ivsize); | ||
789 | + | ||
790 | + iv_dma = dma_map_single(jrdev, iv, ivsize, DMA_TO_DEVICE); | ||
791 | + if (dma_mapping_error(jrdev, iv_dma)) { | ||
792 | + dev_err(jrdev, "unable to map IV\n"); | ||
793 | + caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, 0, | ||
794 | + 0, DMA_NONE, 0, 0); | ||
795 | + kfree(edesc); | ||
796 | + return ERR_PTR(-ENOMEM); | ||
797 | } | ||
798 | |||
799 | + dma_to_sec4_sg_one(edesc->sec4_sg, iv_dma, ivsize, 0); | ||
800 | + sg_to_sec4_sg_last(req->src, mapped_src_nents, edesc->sec4_sg + 1, 0); | ||
801 | + | ||
802 | if (mapped_dst_nents > 1) { | ||
803 | sg_to_sec4_sg_last(req->dst, mapped_dst_nents, | ||
804 | edesc->sec4_sg + dst_sg_idx, 0); | ||
805 | @@ -1556,7 +1541,7 @@ static struct ablkcipher_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request | ||
806 | if (dma_mapping_error(jrdev, edesc->sec4_sg_dma)) { | ||
807 | dev_err(jrdev, "unable to map S/G table\n"); | ||
808 | caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, | ||
809 | - iv_dma, ivsize, 0, 0); | ||
810 | + iv_dma, ivsize, DMA_TO_DEVICE, 0, 0); | ||
811 | kfree(edesc); | ||
812 | return ERR_PTR(-ENOMEM); | ||
813 | } | ||
814 | @@ -1569,7 +1554,6 @@ static struct ablkcipher_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request | ||
815 | sec4_sg_bytes, 1); | ||
816 | #endif | ||
817 | |||
818 | - *iv_contig_out = in_contig; | ||
819 | return edesc; | ||
820 | } | ||
821 | |||
822 | @@ -1579,19 +1563,16 @@ static int ablkcipher_encrypt(struct ablkcipher_request *req) | ||
823 | struct crypto_ablkcipher *ablkcipher = crypto_ablkcipher_reqtfm(req); | ||
824 | struct caam_ctx *ctx = crypto_ablkcipher_ctx(ablkcipher); | ||
825 | struct device *jrdev = ctx->jrdev; | ||
826 | - bool iv_contig; | ||
827 | u32 *desc; | ||
828 | int ret = 0; | ||
829 | |||
830 | /* allocate extended descriptor */ | ||
831 | - edesc = ablkcipher_edesc_alloc(req, DESC_JOB_IO_LEN * | ||
832 | - CAAM_CMD_SZ, &iv_contig); | ||
833 | + edesc = ablkcipher_edesc_alloc(req, DESC_JOB_IO_LEN * CAAM_CMD_SZ); | ||
834 | if (IS_ERR(edesc)) | ||
835 | return PTR_ERR(edesc); | ||
836 | |||
837 | /* Create and submit job descriptor*/ | ||
838 | - init_ablkcipher_job(ctx->sh_desc_enc, | ||
839 | - ctx->sh_desc_enc_dma, edesc, req, iv_contig); | ||
840 | + init_ablkcipher_job(ctx->sh_desc_enc, ctx->sh_desc_enc_dma, edesc, req); | ||
841 | #ifdef DEBUG | ||
842 | print_hex_dump(KERN_ERR, "ablkcipher jobdesc@"__stringify(__LINE__)": ", | ||
843 | DUMP_PREFIX_ADDRESS, 16, 4, edesc->hw_desc, | ||
844 | @@ -1615,20 +1596,25 @@ static int ablkcipher_decrypt(struct ablkcipher_request *req) | ||
845 | struct ablkcipher_edesc *edesc; | ||
846 | struct crypto_ablkcipher *ablkcipher = crypto_ablkcipher_reqtfm(req); | ||
847 | struct caam_ctx *ctx = crypto_ablkcipher_ctx(ablkcipher); | ||
848 | + int ivsize = crypto_ablkcipher_ivsize(ablkcipher); | ||
849 | struct device *jrdev = ctx->jrdev; | ||
850 | - bool iv_contig; | ||
851 | u32 *desc; | ||
852 | int ret = 0; | ||
853 | |||
854 | /* allocate extended descriptor */ | ||
855 | - edesc = ablkcipher_edesc_alloc(req, DESC_JOB_IO_LEN * | ||
856 | - CAAM_CMD_SZ, &iv_contig); | ||
857 | + edesc = ablkcipher_edesc_alloc(req, DESC_JOB_IO_LEN * CAAM_CMD_SZ); | ||
858 | if (IS_ERR(edesc)) | ||
859 | return PTR_ERR(edesc); | ||
860 | |||
861 | + /* | ||
862 | + * The crypto API expects us to set the IV (req->info) to the last | ||
863 | + * ciphertext block. | ||
864 | + */ | ||
865 | + scatterwalk_map_and_copy(req->info, req->src, req->nbytes - ivsize, | ||
866 | + ivsize, 0); | ||
867 | + | ||
868 | /* Create and submit job descriptor*/ | ||
869 | - init_ablkcipher_job(ctx->sh_desc_dec, | ||
870 | - ctx->sh_desc_dec_dma, edesc, req, iv_contig); | ||
871 | + init_ablkcipher_job(ctx->sh_desc_dec, ctx->sh_desc_dec_dma, edesc, req); | ||
872 | desc = edesc->hw_desc; | ||
873 | #ifdef DEBUG | ||
874 | print_hex_dump(KERN_ERR, "ablkcipher jobdesc@"__stringify(__LINE__)": ", | ||
875 | @@ -1653,8 +1639,7 @@ static int ablkcipher_decrypt(struct ablkcipher_request *req) | ||
876 | */ | ||
877 | static struct ablkcipher_edesc *ablkcipher_giv_edesc_alloc( | ||
878 | struct skcipher_givcrypt_request *greq, | ||
879 | - int desc_bytes, | ||
880 | - bool *iv_contig_out) | ||
881 | + int desc_bytes) | ||
882 | { | ||
883 | struct ablkcipher_request *req = &greq->creq; | ||
884 | struct crypto_ablkcipher *ablkcipher = crypto_ablkcipher_reqtfm(req); | ||
885 | @@ -1664,8 +1649,8 @@ static struct ablkcipher_edesc *ablkcipher_giv_edesc_alloc( | ||
886 | GFP_KERNEL : GFP_ATOMIC; | ||
887 | int src_nents, mapped_src_nents, dst_nents, mapped_dst_nents; | ||
888 | struct ablkcipher_edesc *edesc; | ||
889 | - dma_addr_t iv_dma = 0; | ||
890 | - bool out_contig; | ||
891 | + dma_addr_t iv_dma; | ||
892 | + u8 *iv; | ||
893 | int ivsize = crypto_ablkcipher_ivsize(ablkcipher); | ||
894 | int dst_sg_idx, sec4_sg_ents, sec4_sg_bytes; | ||
895 | |||
896 | @@ -1710,36 +1695,20 @@ static struct ablkcipher_edesc *ablkcipher_giv_edesc_alloc( | ||
897 | } | ||
898 | } | ||
899 | |||
900 | - /* | ||
901 | - * Check if iv can be contiguous with source and destination. | ||
902 | - * If so, include it. If not, create scatterlist. | ||
903 | - */ | ||
904 | - iv_dma = dma_map_single(jrdev, greq->giv, ivsize, DMA_TO_DEVICE); | ||
905 | - if (dma_mapping_error(jrdev, iv_dma)) { | ||
906 | - dev_err(jrdev, "unable to map IV\n"); | ||
907 | - caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, 0, | ||
908 | - 0, 0, 0); | ||
909 | - return ERR_PTR(-ENOMEM); | ||
910 | - } | ||
911 | - | ||
912 | sec4_sg_ents = mapped_src_nents > 1 ? mapped_src_nents : 0; | ||
913 | dst_sg_idx = sec4_sg_ents; | ||
914 | - if (mapped_dst_nents == 1 && | ||
915 | - iv_dma + ivsize == sg_dma_address(req->dst)) { | ||
916 | - out_contig = true; | ||
917 | - } else { | ||
918 | - out_contig = false; | ||
919 | - sec4_sg_ents += 1 + mapped_dst_nents; | ||
920 | - } | ||
921 | + sec4_sg_ents += 1 + mapped_dst_nents; | ||
922 | |||
923 | - /* allocate space for base edesc and hw desc commands, link tables */ | ||
924 | + /* | ||
925 | + * allocate space for base edesc and hw desc commands, link tables, IV | ||
926 | + */ | ||
927 | sec4_sg_bytes = sec4_sg_ents * sizeof(struct sec4_sg_entry); | ||
928 | - edesc = kzalloc(sizeof(*edesc) + desc_bytes + sec4_sg_bytes, | ||
929 | + edesc = kzalloc(sizeof(*edesc) + desc_bytes + sec4_sg_bytes + ivsize, | ||
930 | GFP_DMA | flags); | ||
931 | if (!edesc) { | ||
932 | dev_err(jrdev, "could not allocate extended descriptor\n"); | ||
933 | - caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, | ||
934 | - iv_dma, ivsize, 0, 0); | ||
935 | + caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, 0, | ||
936 | + 0, DMA_NONE, 0, 0); | ||
937 | return ERR_PTR(-ENOMEM); | ||
938 | } | ||
939 | |||
940 | @@ -1748,24 +1717,33 @@ static struct ablkcipher_edesc *ablkcipher_giv_edesc_alloc( | ||
941 | edesc->sec4_sg_bytes = sec4_sg_bytes; | ||
942 | edesc->sec4_sg = (void *)edesc + sizeof(struct ablkcipher_edesc) + | ||
943 | desc_bytes; | ||
944 | + edesc->iv_dir = DMA_FROM_DEVICE; | ||
945 | + | ||
946 | + /* Make sure IV is located in a DMAable area */ | ||
947 | + iv = (u8 *)edesc->hw_desc + desc_bytes + sec4_sg_bytes; | ||
948 | + iv_dma = dma_map_single(jrdev, iv, ivsize, DMA_FROM_DEVICE); | ||
949 | + if (dma_mapping_error(jrdev, iv_dma)) { | ||
950 | + dev_err(jrdev, "unable to map IV\n"); | ||
951 | + caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, 0, | ||
952 | + 0, DMA_NONE, 0, 0); | ||
953 | + kfree(edesc); | ||
954 | + return ERR_PTR(-ENOMEM); | ||
955 | + } | ||
956 | |||
957 | if (mapped_src_nents > 1) | ||
958 | sg_to_sec4_sg_last(req->src, mapped_src_nents, edesc->sec4_sg, | ||
959 | 0); | ||
960 | |||
961 | - if (!out_contig) { | ||
962 | - dma_to_sec4_sg_one(edesc->sec4_sg + dst_sg_idx, | ||
963 | - iv_dma, ivsize, 0); | ||
964 | - sg_to_sec4_sg_last(req->dst, mapped_dst_nents, | ||
965 | - edesc->sec4_sg + dst_sg_idx + 1, 0); | ||
966 | - } | ||
967 | + dma_to_sec4_sg_one(edesc->sec4_sg + dst_sg_idx, iv_dma, ivsize, 0); | ||
968 | + sg_to_sec4_sg_last(req->dst, mapped_dst_nents, edesc->sec4_sg + | ||
969 | + dst_sg_idx + 1, 0); | ||
970 | |||
971 | edesc->sec4_sg_dma = dma_map_single(jrdev, edesc->sec4_sg, | ||
972 | sec4_sg_bytes, DMA_TO_DEVICE); | ||
973 | if (dma_mapping_error(jrdev, edesc->sec4_sg_dma)) { | ||
974 | dev_err(jrdev, "unable to map S/G table\n"); | ||
975 | caam_unmap(jrdev, req->src, req->dst, src_nents, dst_nents, | ||
976 | - iv_dma, ivsize, 0, 0); | ||
977 | + iv_dma, ivsize, DMA_FROM_DEVICE, 0, 0); | ||
978 | kfree(edesc); | ||
979 | return ERR_PTR(-ENOMEM); | ||
980 | } | ||
981 | @@ -1778,7 +1756,6 @@ static struct ablkcipher_edesc *ablkcipher_giv_edesc_alloc( | ||
982 | sec4_sg_bytes, 1); | ||
983 | #endif | ||
984 | |||
985 | - *iv_contig_out = out_contig; | ||
986 | return edesc; | ||
987 | } | ||
988 | |||
989 | @@ -1789,19 +1766,17 @@ static int ablkcipher_givencrypt(struct skcipher_givcrypt_request *creq) | ||
990 | struct crypto_ablkcipher *ablkcipher = crypto_ablkcipher_reqtfm(req); | ||
991 | struct caam_ctx *ctx = crypto_ablkcipher_ctx(ablkcipher); | ||
992 | struct device *jrdev = ctx->jrdev; | ||
993 | - bool iv_contig = false; | ||
994 | u32 *desc; | ||
995 | int ret = 0; | ||
996 | |||
997 | /* allocate extended descriptor */ | ||
998 | - edesc = ablkcipher_giv_edesc_alloc(creq, DESC_JOB_IO_LEN * | ||
999 | - CAAM_CMD_SZ, &iv_contig); | ||
1000 | + edesc = ablkcipher_giv_edesc_alloc(creq, DESC_JOB_IO_LEN * CAAM_CMD_SZ); | ||
1001 | if (IS_ERR(edesc)) | ||
1002 | return PTR_ERR(edesc); | ||
1003 | |||
1004 | /* Create and submit job descriptor*/ | ||
1005 | init_ablkcipher_giv_job(ctx->sh_desc_givenc, ctx->sh_desc_givenc_dma, | ||
1006 | - edesc, req, iv_contig); | ||
1007 | + edesc, req); | ||
1008 | #ifdef DEBUG | ||
1009 | print_hex_dump(KERN_ERR, | ||
1010 | "ablkcipher jobdesc@" __stringify(__LINE__) ": ", | ||
1011 | diff --git a/drivers/crypto/caam/caamalg_qi.c b/drivers/crypto/caam/caamalg_qi.c | ||
1012 | index b648e31673f9..e7966e37a5aa 100644 | ||
1013 | --- a/drivers/crypto/caam/caamalg_qi.c | ||
1014 | +++ b/drivers/crypto/caam/caamalg_qi.c | ||
1015 | @@ -401,7 +401,7 @@ static int xts_ablkcipher_setkey(struct crypto_ablkcipher *ablkcipher, | ||
1016 | * @assoclen: associated data length, in CAAM endianness | ||
1017 | * @assoclen_dma: bus physical mapped address of req->assoclen | ||
1018 | * @drv_req: driver-specific request structure | ||
1019 | - * @sgt: the h/w link table | ||
1020 | + * @sgt: the h/w link table, followed by IV | ||
1021 | */ | ||
1022 | struct aead_edesc { | ||
1023 | int src_nents; | ||
1024 | @@ -412,9 +412,6 @@ struct aead_edesc { | ||
1025 | unsigned int assoclen; | ||
1026 | dma_addr_t assoclen_dma; | ||
1027 | struct caam_drv_req drv_req; | ||
1028 | -#define CAAM_QI_MAX_AEAD_SG \ | ||
1029 | - ((CAAM_QI_MEMCACHE_SIZE - offsetof(struct aead_edesc, sgt)) / \ | ||
1030 | - sizeof(struct qm_sg_entry)) | ||
1031 | struct qm_sg_entry sgt[0]; | ||
1032 | }; | ||
1033 | |||
1034 | @@ -426,7 +423,7 @@ struct aead_edesc { | ||
1035 | * @qm_sg_bytes: length of dma mapped h/w link table | ||
1036 | * @qm_sg_dma: bus physical mapped address of h/w link table | ||
1037 | * @drv_req: driver-specific request structure | ||
1038 | - * @sgt: the h/w link table | ||
1039 | + * @sgt: the h/w link table, followed by IV | ||
1040 | */ | ||
1041 | struct ablkcipher_edesc { | ||
1042 | int src_nents; | ||
1043 | @@ -435,9 +432,6 @@ struct ablkcipher_edesc { | ||
1044 | int qm_sg_bytes; | ||
1045 | dma_addr_t qm_sg_dma; | ||
1046 | struct caam_drv_req drv_req; | ||
1047 | -#define CAAM_QI_MAX_ABLKCIPHER_SG \ | ||
1048 | - ((CAAM_QI_MEMCACHE_SIZE - offsetof(struct ablkcipher_edesc, sgt)) / \ | ||
1049 | - sizeof(struct qm_sg_entry)) | ||
1050 | struct qm_sg_entry sgt[0]; | ||
1051 | }; | ||
1052 | |||
1053 | @@ -649,17 +643,8 @@ static struct aead_edesc *aead_edesc_alloc(struct aead_request *req, | ||
1054 | } | ||
1055 | } | ||
1056 | |||
1057 | - if ((alg->caam.rfc3686 && encrypt) || !alg->caam.geniv) { | ||
1058 | + if ((alg->caam.rfc3686 && encrypt) || !alg->caam.geniv) | ||
1059 | ivsize = crypto_aead_ivsize(aead); | ||
1060 | - iv_dma = dma_map_single(qidev, req->iv, ivsize, DMA_TO_DEVICE); | ||
1061 | - if (dma_mapping_error(qidev, iv_dma)) { | ||
1062 | - dev_err(qidev, "unable to map IV\n"); | ||
1063 | - caam_unmap(qidev, req->src, req->dst, src_nents, | ||
1064 | - dst_nents, 0, 0, op_type, 0, 0); | ||
1065 | - qi_cache_free(edesc); | ||
1066 | - return ERR_PTR(-ENOMEM); | ||
1067 | - } | ||
1068 | - } | ||
1069 | |||
1070 | /* | ||
1071 | * Create S/G table: req->assoclen, [IV,] req->src [, req->dst]. | ||
1072 | @@ -667,16 +652,33 @@ static struct aead_edesc *aead_edesc_alloc(struct aead_request *req, | ||
1073 | */ | ||
1074 | qm_sg_ents = 1 + !!ivsize + mapped_src_nents + | ||
1075 | (mapped_dst_nents > 1 ? mapped_dst_nents : 0); | ||
1076 | - if (unlikely(qm_sg_ents > CAAM_QI_MAX_AEAD_SG)) { | ||
1077 | - dev_err(qidev, "Insufficient S/G entries: %d > %zu\n", | ||
1078 | - qm_sg_ents, CAAM_QI_MAX_AEAD_SG); | ||
1079 | - caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, | ||
1080 | - iv_dma, ivsize, op_type, 0, 0); | ||
1081 | + sg_table = &edesc->sgt[0]; | ||
1082 | + qm_sg_bytes = qm_sg_ents * sizeof(*sg_table); | ||
1083 | + if (unlikely(offsetof(struct aead_edesc, sgt) + qm_sg_bytes + ivsize > | ||
1084 | + CAAM_QI_MEMCACHE_SIZE)) { | ||
1085 | + dev_err(qidev, "No space for %d S/G entries and/or %dB IV\n", | ||
1086 | + qm_sg_ents, ivsize); | ||
1087 | + caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, 0, | ||
1088 | + 0, 0, 0, 0); | ||
1089 | qi_cache_free(edesc); | ||
1090 | return ERR_PTR(-ENOMEM); | ||
1091 | } | ||
1092 | - sg_table = &edesc->sgt[0]; | ||
1093 | - qm_sg_bytes = qm_sg_ents * sizeof(*sg_table); | ||
1094 | + | ||
1095 | + if (ivsize) { | ||
1096 | + u8 *iv = (u8 *)(sg_table + qm_sg_ents); | ||
1097 | + | ||
1098 | + /* Make sure IV is located in a DMAable area */ | ||
1099 | + memcpy(iv, req->iv, ivsize); | ||
1100 | + | ||
1101 | + iv_dma = dma_map_single(qidev, iv, ivsize, DMA_TO_DEVICE); | ||
1102 | + if (dma_mapping_error(qidev, iv_dma)) { | ||
1103 | + dev_err(qidev, "unable to map IV\n"); | ||
1104 | + caam_unmap(qidev, req->src, req->dst, src_nents, | ||
1105 | + dst_nents, 0, 0, 0, 0, 0); | ||
1106 | + qi_cache_free(edesc); | ||
1107 | + return ERR_PTR(-ENOMEM); | ||
1108 | + } | ||
1109 | + } | ||
1110 | |||
1111 | edesc->src_nents = src_nents; | ||
1112 | edesc->dst_nents = dst_nents; | ||
1113 | @@ -813,15 +815,27 @@ static void ablkcipher_done(struct caam_drv_req *drv_req, u32 status) | ||
1114 | #endif | ||
1115 | |||
1116 | ablkcipher_unmap(qidev, edesc, req); | ||
1117 | - qi_cache_free(edesc); | ||
1118 | + | ||
1119 | + /* In case initial IV was generated, copy it in GIVCIPHER request */ | ||
1120 | + if (edesc->drv_req.drv_ctx->op_type == GIVENCRYPT) { | ||
1121 | + u8 *iv; | ||
1122 | + struct skcipher_givcrypt_request *greq; | ||
1123 | + | ||
1124 | + greq = container_of(req, struct skcipher_givcrypt_request, | ||
1125 | + creq); | ||
1126 | + iv = (u8 *)edesc->sgt + edesc->qm_sg_bytes; | ||
1127 | + memcpy(greq->giv, iv, ivsize); | ||
1128 | + } | ||
1129 | |||
1130 | /* | ||
1131 | * The crypto API expects us to set the IV (req->info) to the last | ||
1132 | * ciphertext block. This is used e.g. by the CTS mode. | ||
1133 | */ | ||
1134 | - scatterwalk_map_and_copy(req->info, req->dst, req->nbytes - ivsize, | ||
1135 | - ivsize, 0); | ||
1136 | + if (edesc->drv_req.drv_ctx->op_type != DECRYPT) | ||
1137 | + scatterwalk_map_and_copy(req->info, req->dst, req->nbytes - | ||
1138 | + ivsize, ivsize, 0); | ||
1139 | |||
1140 | + qi_cache_free(edesc); | ||
1141 | ablkcipher_request_complete(req, status); | ||
1142 | } | ||
1143 | |||
1144 | @@ -836,9 +850,9 @@ static struct ablkcipher_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request | ||
1145 | int src_nents, mapped_src_nents, dst_nents = 0, mapped_dst_nents = 0; | ||
1146 | struct ablkcipher_edesc *edesc; | ||
1147 | dma_addr_t iv_dma; | ||
1148 | - bool in_contig; | ||
1149 | + u8 *iv; | ||
1150 | int ivsize = crypto_ablkcipher_ivsize(ablkcipher); | ||
1151 | - int dst_sg_idx, qm_sg_ents; | ||
1152 | + int dst_sg_idx, qm_sg_ents, qm_sg_bytes; | ||
1153 | struct qm_sg_entry *sg_table, *fd_sgt; | ||
1154 | struct caam_drv_ctx *drv_ctx; | ||
1155 | enum optype op_type = encrypt ? ENCRYPT : DECRYPT; | ||
1156 | @@ -885,55 +899,53 @@ static struct ablkcipher_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request | ||
1157 | } | ||
1158 | } | ||
1159 | |||
1160 | - iv_dma = dma_map_single(qidev, req->info, ivsize, DMA_TO_DEVICE); | ||
1161 | - if (dma_mapping_error(qidev, iv_dma)) { | ||
1162 | - dev_err(qidev, "unable to map IV\n"); | ||
1163 | - caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, 0, | ||
1164 | - 0, 0, 0, 0); | ||
1165 | - return ERR_PTR(-ENOMEM); | ||
1166 | - } | ||
1167 | - | ||
1168 | - if (mapped_src_nents == 1 && | ||
1169 | - iv_dma + ivsize == sg_dma_address(req->src)) { | ||
1170 | - in_contig = true; | ||
1171 | - qm_sg_ents = 0; | ||
1172 | - } else { | ||
1173 | - in_contig = false; | ||
1174 | - qm_sg_ents = 1 + mapped_src_nents; | ||
1175 | - } | ||
1176 | + qm_sg_ents = 1 + mapped_src_nents; | ||
1177 | dst_sg_idx = qm_sg_ents; | ||
1178 | |||
1179 | qm_sg_ents += mapped_dst_nents > 1 ? mapped_dst_nents : 0; | ||
1180 | - if (unlikely(qm_sg_ents > CAAM_QI_MAX_ABLKCIPHER_SG)) { | ||
1181 | - dev_err(qidev, "Insufficient S/G entries: %d > %zu\n", | ||
1182 | - qm_sg_ents, CAAM_QI_MAX_ABLKCIPHER_SG); | ||
1183 | - caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, | ||
1184 | - iv_dma, ivsize, op_type, 0, 0); | ||
1185 | + qm_sg_bytes = qm_sg_ents * sizeof(struct qm_sg_entry); | ||
1186 | + if (unlikely(offsetof(struct ablkcipher_edesc, sgt) + qm_sg_bytes + | ||
1187 | + ivsize > CAAM_QI_MEMCACHE_SIZE)) { | ||
1188 | + dev_err(qidev, "No space for %d S/G entries and/or %dB IV\n", | ||
1189 | + qm_sg_ents, ivsize); | ||
1190 | + caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, 0, | ||
1191 | + 0, 0, 0, 0); | ||
1192 | return ERR_PTR(-ENOMEM); | ||
1193 | } | ||
1194 | |||
1195 | - /* allocate space for base edesc and link tables */ | ||
1196 | + /* allocate space for base edesc, link tables and IV */ | ||
1197 | edesc = qi_cache_alloc(GFP_DMA | flags); | ||
1198 | if (unlikely(!edesc)) { | ||
1199 | dev_err(qidev, "could not allocate extended descriptor\n"); | ||
1200 | - caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, | ||
1201 | - iv_dma, ivsize, op_type, 0, 0); | ||
1202 | + caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, 0, | ||
1203 | + 0, 0, 0, 0); | ||
1204 | + return ERR_PTR(-ENOMEM); | ||
1205 | + } | ||
1206 | + | ||
1207 | + /* Make sure IV is located in a DMAable area */ | ||
1208 | + sg_table = &edesc->sgt[0]; | ||
1209 | + iv = (u8 *)(sg_table + qm_sg_ents); | ||
1210 | + memcpy(iv, req->info, ivsize); | ||
1211 | + | ||
1212 | + iv_dma = dma_map_single(qidev, iv, ivsize, DMA_TO_DEVICE); | ||
1213 | + if (dma_mapping_error(qidev, iv_dma)) { | ||
1214 | + dev_err(qidev, "unable to map IV\n"); | ||
1215 | + caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, 0, | ||
1216 | + 0, 0, 0, 0); | ||
1217 | + qi_cache_free(edesc); | ||
1218 | return ERR_PTR(-ENOMEM); | ||
1219 | } | ||
1220 | |||
1221 | edesc->src_nents = src_nents; | ||
1222 | edesc->dst_nents = dst_nents; | ||
1223 | edesc->iv_dma = iv_dma; | ||
1224 | - sg_table = &edesc->sgt[0]; | ||
1225 | - edesc->qm_sg_bytes = qm_sg_ents * sizeof(*sg_table); | ||
1226 | + edesc->qm_sg_bytes = qm_sg_bytes; | ||
1227 | edesc->drv_req.app_ctx = req; | ||
1228 | edesc->drv_req.cbk = ablkcipher_done; | ||
1229 | edesc->drv_req.drv_ctx = drv_ctx; | ||
1230 | |||
1231 | - if (!in_contig) { | ||
1232 | - dma_to_qm_sg_one(sg_table, iv_dma, ivsize, 0); | ||
1233 | - sg_to_qm_sg_last(req->src, mapped_src_nents, sg_table + 1, 0); | ||
1234 | - } | ||
1235 | + dma_to_qm_sg_one(sg_table, iv_dma, ivsize, 0); | ||
1236 | + sg_to_qm_sg_last(req->src, mapped_src_nents, sg_table + 1, 0); | ||
1237 | |||
1238 | if (mapped_dst_nents > 1) | ||
1239 | sg_to_qm_sg_last(req->dst, mapped_dst_nents, sg_table + | ||
1240 | @@ -951,20 +963,12 @@ static struct ablkcipher_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request | ||
1241 | |||
1242 | fd_sgt = &edesc->drv_req.fd_sgt[0]; | ||
1243 | |||
1244 | - if (!in_contig) | ||
1245 | - dma_to_qm_sg_one_last_ext(&fd_sgt[1], edesc->qm_sg_dma, | ||
1246 | - ivsize + req->nbytes, 0); | ||
1247 | - else | ||
1248 | - dma_to_qm_sg_one_last(&fd_sgt[1], iv_dma, ivsize + req->nbytes, | ||
1249 | - 0); | ||
1250 | + dma_to_qm_sg_one_last_ext(&fd_sgt[1], edesc->qm_sg_dma, | ||
1251 | + ivsize + req->nbytes, 0); | ||
1252 | |||
1253 | if (req->src == req->dst) { | ||
1254 | - if (!in_contig) | ||
1255 | - dma_to_qm_sg_one_ext(&fd_sgt[0], edesc->qm_sg_dma + | ||
1256 | - sizeof(*sg_table), req->nbytes, 0); | ||
1257 | - else | ||
1258 | - dma_to_qm_sg_one(&fd_sgt[0], sg_dma_address(req->src), | ||
1259 | - req->nbytes, 0); | ||
1260 | + dma_to_qm_sg_one_ext(&fd_sgt[0], edesc->qm_sg_dma + | ||
1261 | + sizeof(*sg_table), req->nbytes, 0); | ||
1262 | } else if (mapped_dst_nents > 1) { | ||
1263 | dma_to_qm_sg_one_ext(&fd_sgt[0], edesc->qm_sg_dma + dst_sg_idx * | ||
1264 | sizeof(*sg_table), req->nbytes, 0); | ||
1265 | @@ -988,10 +992,10 @@ static struct ablkcipher_edesc *ablkcipher_giv_edesc_alloc( | ||
1266 | int src_nents, mapped_src_nents, dst_nents, mapped_dst_nents; | ||
1267 | struct ablkcipher_edesc *edesc; | ||
1268 | dma_addr_t iv_dma; | ||
1269 | - bool out_contig; | ||
1270 | + u8 *iv; | ||
1271 | int ivsize = crypto_ablkcipher_ivsize(ablkcipher); | ||
1272 | struct qm_sg_entry *sg_table, *fd_sgt; | ||
1273 | - int dst_sg_idx, qm_sg_ents; | ||
1274 | + int dst_sg_idx, qm_sg_ents, qm_sg_bytes; | ||
1275 | struct caam_drv_ctx *drv_ctx; | ||
1276 | |||
1277 | drv_ctx = get_drv_ctx(ctx, GIVENCRYPT); | ||
1278 | @@ -1039,46 +1043,45 @@ static struct ablkcipher_edesc *ablkcipher_giv_edesc_alloc( | ||
1279 | mapped_dst_nents = src_nents; | ||
1280 | } | ||
1281 | |||
1282 | - iv_dma = dma_map_single(qidev, creq->giv, ivsize, DMA_FROM_DEVICE); | ||
1283 | - if (dma_mapping_error(qidev, iv_dma)) { | ||
1284 | - dev_err(qidev, "unable to map IV\n"); | ||
1285 | - caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, 0, | ||
1286 | - 0, 0, 0, 0); | ||
1287 | - return ERR_PTR(-ENOMEM); | ||
1288 | - } | ||
1289 | - | ||
1290 | qm_sg_ents = mapped_src_nents > 1 ? mapped_src_nents : 0; | ||
1291 | dst_sg_idx = qm_sg_ents; | ||
1292 | - if (mapped_dst_nents == 1 && | ||
1293 | - iv_dma + ivsize == sg_dma_address(req->dst)) { | ||
1294 | - out_contig = true; | ||
1295 | - } else { | ||
1296 | - out_contig = false; | ||
1297 | - qm_sg_ents += 1 + mapped_dst_nents; | ||
1298 | - } | ||
1299 | |||
1300 | - if (unlikely(qm_sg_ents > CAAM_QI_MAX_ABLKCIPHER_SG)) { | ||
1301 | - dev_err(qidev, "Insufficient S/G entries: %d > %zu\n", | ||
1302 | - qm_sg_ents, CAAM_QI_MAX_ABLKCIPHER_SG); | ||
1303 | - caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, | ||
1304 | - iv_dma, ivsize, GIVENCRYPT, 0, 0); | ||
1305 | + qm_sg_ents += 1 + mapped_dst_nents; | ||
1306 | + qm_sg_bytes = qm_sg_ents * sizeof(struct qm_sg_entry); | ||
1307 | + if (unlikely(offsetof(struct ablkcipher_edesc, sgt) + qm_sg_bytes + | ||
1308 | + ivsize > CAAM_QI_MEMCACHE_SIZE)) { | ||
1309 | + dev_err(qidev, "No space for %d S/G entries and/or %dB IV\n", | ||
1310 | + qm_sg_ents, ivsize); | ||
1311 | + caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, 0, | ||
1312 | + 0, 0, 0, 0); | ||
1313 | return ERR_PTR(-ENOMEM); | ||
1314 | } | ||
1315 | |||
1316 | - /* allocate space for base edesc and link tables */ | ||
1317 | + /* allocate space for base edesc, link tables and IV */ | ||
1318 | edesc = qi_cache_alloc(GFP_DMA | flags); | ||
1319 | if (!edesc) { | ||
1320 | dev_err(qidev, "could not allocate extended descriptor\n"); | ||
1321 | - caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, | ||
1322 | - iv_dma, ivsize, GIVENCRYPT, 0, 0); | ||
1323 | + caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, 0, | ||
1324 | + 0, 0, 0, 0); | ||
1325 | + return ERR_PTR(-ENOMEM); | ||
1326 | + } | ||
1327 | + | ||
1328 | + /* Make sure IV is located in a DMAable area */ | ||
1329 | + sg_table = &edesc->sgt[0]; | ||
1330 | + iv = (u8 *)(sg_table + qm_sg_ents); | ||
1331 | + iv_dma = dma_map_single(qidev, iv, ivsize, DMA_FROM_DEVICE); | ||
1332 | + if (dma_mapping_error(qidev, iv_dma)) { | ||
1333 | + dev_err(qidev, "unable to map IV\n"); | ||
1334 | + caam_unmap(qidev, req->src, req->dst, src_nents, dst_nents, 0, | ||
1335 | + 0, 0, 0, 0); | ||
1336 | + qi_cache_free(edesc); | ||
1337 | return ERR_PTR(-ENOMEM); | ||
1338 | } | ||
1339 | |||
1340 | edesc->src_nents = src_nents; | ||
1341 | edesc->dst_nents = dst_nents; | ||
1342 | edesc->iv_dma = iv_dma; | ||
1343 | - sg_table = &edesc->sgt[0]; | ||
1344 | - edesc->qm_sg_bytes = qm_sg_ents * sizeof(*sg_table); | ||
1345 | + edesc->qm_sg_bytes = qm_sg_bytes; | ||
1346 | edesc->drv_req.app_ctx = req; | ||
1347 | edesc->drv_req.cbk = ablkcipher_done; | ||
1348 | edesc->drv_req.drv_ctx = drv_ctx; | ||
1349 | @@ -1086,11 +1089,9 @@ static struct ablkcipher_edesc *ablkcipher_giv_edesc_alloc( | ||
1350 | if (mapped_src_nents > 1) | ||
1351 | sg_to_qm_sg_last(req->src, mapped_src_nents, sg_table, 0); | ||
1352 | |||
1353 | - if (!out_contig) { | ||
1354 | - dma_to_qm_sg_one(sg_table + dst_sg_idx, iv_dma, ivsize, 0); | ||
1355 | - sg_to_qm_sg_last(req->dst, mapped_dst_nents, sg_table + | ||
1356 | - dst_sg_idx + 1, 0); | ||
1357 | - } | ||
1358 | + dma_to_qm_sg_one(sg_table + dst_sg_idx, iv_dma, ivsize, 0); | ||
1359 | + sg_to_qm_sg_last(req->dst, mapped_dst_nents, sg_table + dst_sg_idx + 1, | ||
1360 | + 0); | ||
1361 | |||
1362 | edesc->qm_sg_dma = dma_map_single(qidev, sg_table, edesc->qm_sg_bytes, | ||
1363 | DMA_TO_DEVICE); | ||
1364 | @@ -1111,13 +1112,8 @@ static struct ablkcipher_edesc *ablkcipher_giv_edesc_alloc( | ||
1365 | dma_to_qm_sg_one(&fd_sgt[1], sg_dma_address(req->src), | ||
1366 | req->nbytes, 0); | ||
1367 | |||
1368 | - if (!out_contig) | ||
1369 | - dma_to_qm_sg_one_ext(&fd_sgt[0], edesc->qm_sg_dma + dst_sg_idx * | ||
1370 | - sizeof(*sg_table), ivsize + req->nbytes, | ||
1371 | - 0); | ||
1372 | - else | ||
1373 | - dma_to_qm_sg_one(&fd_sgt[0], sg_dma_address(req->dst), | ||
1374 | - ivsize + req->nbytes, 0); | ||
1375 | + dma_to_qm_sg_one_ext(&fd_sgt[0], edesc->qm_sg_dma + dst_sg_idx * | ||
1376 | + sizeof(*sg_table), ivsize + req->nbytes, 0); | ||
1377 | |||
1378 | return edesc; | ||
1379 | } | ||
1380 | @@ -1127,6 +1123,7 @@ static inline int ablkcipher_crypt(struct ablkcipher_request *req, bool encrypt) | ||
1381 | struct ablkcipher_edesc *edesc; | ||
1382 | struct crypto_ablkcipher *ablkcipher = crypto_ablkcipher_reqtfm(req); | ||
1383 | struct caam_ctx *ctx = crypto_ablkcipher_ctx(ablkcipher); | ||
1384 | + int ivsize = crypto_ablkcipher_ivsize(ablkcipher); | ||
1385 | int ret; | ||
1386 | |||
1387 | if (unlikely(caam_congested)) | ||
1388 | @@ -1137,6 +1134,14 @@ static inline int ablkcipher_crypt(struct ablkcipher_request *req, bool encrypt) | ||
1389 | if (IS_ERR(edesc)) | ||
1390 | return PTR_ERR(edesc); | ||
1391 | |||
1392 | + /* | ||
1393 | + * The crypto API expects us to set the IV (req->info) to the last | ||
1394 | + * ciphertext block. | ||
1395 | + */ | ||
1396 | + if (!encrypt) | ||
1397 | + scatterwalk_map_and_copy(req->info, req->src, req->nbytes - | ||
1398 | + ivsize, ivsize, 0); | ||
1399 | + | ||
1400 | ret = caam_qi_enqueue(ctx->qidev, &edesc->drv_req); | ||
1401 | if (!ret) { | ||
1402 | ret = -EINPROGRESS; | ||
1403 | diff --git a/drivers/crypto/caam/caampkc.c b/drivers/crypto/caam/caampkc.c | ||
1404 | index 7a897209f181..7ff4a25440ac 100644 | ||
1405 | --- a/drivers/crypto/caam/caampkc.c | ||
1406 | +++ b/drivers/crypto/caam/caampkc.c | ||
1407 | @@ -66,7 +66,7 @@ static void rsa_priv_f2_unmap(struct device *dev, struct rsa_edesc *edesc, | ||
1408 | struct caam_rsa_key *key = &ctx->key; | ||
1409 | struct rsa_priv_f2_pdb *pdb = &edesc->pdb.priv_f2; | ||
1410 | size_t p_sz = key->p_sz; | ||
1411 | - size_t q_sz = key->p_sz; | ||
1412 | + size_t q_sz = key->q_sz; | ||
1413 | |||
1414 | dma_unmap_single(dev, pdb->d_dma, key->d_sz, DMA_TO_DEVICE); | ||
1415 | dma_unmap_single(dev, pdb->p_dma, p_sz, DMA_TO_DEVICE); | ||
1416 | @@ -83,7 +83,7 @@ static void rsa_priv_f3_unmap(struct device *dev, struct rsa_edesc *edesc, | ||
1417 | struct caam_rsa_key *key = &ctx->key; | ||
1418 | struct rsa_priv_f3_pdb *pdb = &edesc->pdb.priv_f3; | ||
1419 | size_t p_sz = key->p_sz; | ||
1420 | - size_t q_sz = key->p_sz; | ||
1421 | + size_t q_sz = key->q_sz; | ||
1422 | |||
1423 | dma_unmap_single(dev, pdb->p_dma, p_sz, DMA_TO_DEVICE); | ||
1424 | dma_unmap_single(dev, pdb->q_dma, q_sz, DMA_TO_DEVICE); | ||
1425 | @@ -166,18 +166,71 @@ static void rsa_priv_f3_done(struct device *dev, u32 *desc, u32 err, | ||
1426 | akcipher_request_complete(req, err); | ||
1427 | } | ||
1428 | |||
1429 | +static int caam_rsa_count_leading_zeros(struct scatterlist *sgl, | ||
1430 | + unsigned int nbytes, | ||
1431 | + unsigned int flags) | ||
1432 | +{ | ||
1433 | + struct sg_mapping_iter miter; | ||
1434 | + int lzeros, ents; | ||
1435 | + unsigned int len; | ||
1436 | + unsigned int tbytes = nbytes; | ||
1437 | + const u8 *buff; | ||
1438 | + | ||
1439 | + ents = sg_nents_for_len(sgl, nbytes); | ||
1440 | + if (ents < 0) | ||
1441 | + return ents; | ||
1442 | + | ||
1443 | + sg_miter_start(&miter, sgl, ents, SG_MITER_FROM_SG | flags); | ||
1444 | + | ||
1445 | + lzeros = 0; | ||
1446 | + len = 0; | ||
1447 | + while (nbytes > 0) { | ||
1448 | + while (len && !*buff) { | ||
1449 | + lzeros++; | ||
1450 | + len--; | ||
1451 | + buff++; | ||
1452 | + } | ||
1453 | + | ||
1454 | + if (len && *buff) | ||
1455 | + break; | ||
1456 | + | ||
1457 | + sg_miter_next(&miter); | ||
1458 | + buff = miter.addr; | ||
1459 | + len = miter.length; | ||
1460 | + | ||
1461 | + nbytes -= lzeros; | ||
1462 | + lzeros = 0; | ||
1463 | + } | ||
1464 | + | ||
1465 | + miter.consumed = lzeros; | ||
1466 | + sg_miter_stop(&miter); | ||
1467 | + nbytes -= lzeros; | ||
1468 | + | ||
1469 | + return tbytes - nbytes; | ||
1470 | +} | ||
1471 | + | ||
1472 | static struct rsa_edesc *rsa_edesc_alloc(struct akcipher_request *req, | ||
1473 | size_t desclen) | ||
1474 | { | ||
1475 | struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req); | ||
1476 | struct caam_rsa_ctx *ctx = akcipher_tfm_ctx(tfm); | ||
1477 | struct device *dev = ctx->dev; | ||
1478 | + struct caam_rsa_req_ctx *req_ctx = akcipher_request_ctx(req); | ||
1479 | struct rsa_edesc *edesc; | ||
1480 | gfp_t flags = (req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP) ? | ||
1481 | GFP_KERNEL : GFP_ATOMIC; | ||
1482 | + int sg_flags = (flags == GFP_ATOMIC) ? SG_MITER_ATOMIC : 0; | ||
1483 | int sgc; | ||
1484 | int sec4_sg_index, sec4_sg_len = 0, sec4_sg_bytes; | ||
1485 | int src_nents, dst_nents; | ||
1486 | + int lzeros; | ||
1487 | + | ||
1488 | + lzeros = caam_rsa_count_leading_zeros(req->src, req->src_len, sg_flags); | ||
1489 | + if (lzeros < 0) | ||
1490 | + return ERR_PTR(lzeros); | ||
1491 | + | ||
1492 | + req->src_len -= lzeros; | ||
1493 | + req->src = scatterwalk_ffwd(req_ctx->src, req->src, lzeros); | ||
1494 | |||
1495 | src_nents = sg_nents_for_len(req->src, req->src_len); | ||
1496 | dst_nents = sg_nents_for_len(req->dst, req->dst_len); | ||
1497 | @@ -344,7 +397,7 @@ static int set_rsa_priv_f2_pdb(struct akcipher_request *req, | ||
1498 | struct rsa_priv_f2_pdb *pdb = &edesc->pdb.priv_f2; | ||
1499 | int sec4_sg_index = 0; | ||
1500 | size_t p_sz = key->p_sz; | ||
1501 | - size_t q_sz = key->p_sz; | ||
1502 | + size_t q_sz = key->q_sz; | ||
1503 | |||
1504 | pdb->d_dma = dma_map_single(dev, key->d, key->d_sz, DMA_TO_DEVICE); | ||
1505 | if (dma_mapping_error(dev, pdb->d_dma)) { | ||
1506 | @@ -419,7 +472,7 @@ static int set_rsa_priv_f3_pdb(struct akcipher_request *req, | ||
1507 | struct rsa_priv_f3_pdb *pdb = &edesc->pdb.priv_f3; | ||
1508 | int sec4_sg_index = 0; | ||
1509 | size_t p_sz = key->p_sz; | ||
1510 | - size_t q_sz = key->p_sz; | ||
1511 | + size_t q_sz = key->q_sz; | ||
1512 | |||
1513 | pdb->p_dma = dma_map_single(dev, key->p, p_sz, DMA_TO_DEVICE); | ||
1514 | if (dma_mapping_error(dev, pdb->p_dma)) { | ||
1515 | @@ -953,6 +1006,7 @@ static struct akcipher_alg caam_rsa = { | ||
1516 | .max_size = caam_rsa_max_size, | ||
1517 | .init = caam_rsa_init_tfm, | ||
1518 | .exit = caam_rsa_exit_tfm, | ||
1519 | + .reqsize = sizeof(struct caam_rsa_req_ctx), | ||
1520 | .base = { | ||
1521 | .cra_name = "rsa", | ||
1522 | .cra_driver_name = "rsa-caam", | ||
1523 | diff --git a/drivers/crypto/caam/caampkc.h b/drivers/crypto/caam/caampkc.h | ||
1524 | index fd145c46eae1..82645bcf8b27 100644 | ||
1525 | --- a/drivers/crypto/caam/caampkc.h | ||
1526 | +++ b/drivers/crypto/caam/caampkc.h | ||
1527 | @@ -95,6 +95,14 @@ struct caam_rsa_ctx { | ||
1528 | struct device *dev; | ||
1529 | }; | ||
1530 | |||
1531 | +/** | ||
1532 | + * caam_rsa_req_ctx - per request context. | ||
1533 | + * @src: input scatterlist (stripped of leading zeros) | ||
1534 | + */ | ||
1535 | +struct caam_rsa_req_ctx { | ||
1536 | + struct scatterlist src[2]; | ||
1537 | +}; | ||
1538 | + | ||
1539 | /** | ||
1540 | * rsa_edesc - s/w-extended rsa descriptor | ||
1541 | * @src_nents : number of segments in input scatterlist | ||
1542 | diff --git a/drivers/crypto/cavium/zip/common.h b/drivers/crypto/cavium/zip/common.h | ||
1543 | index dc451e0a43c5..58fb3ed6e644 100644 | ||
1544 | --- a/drivers/crypto/cavium/zip/common.h | ||
1545 | +++ b/drivers/crypto/cavium/zip/common.h | ||
1546 | @@ -46,8 +46,10 @@ | ||
1547 | #ifndef __COMMON_H__ | ||
1548 | #define __COMMON_H__ | ||
1549 | |||
1550 | +#include <linux/delay.h> | ||
1551 | #include <linux/init.h> | ||
1552 | #include <linux/interrupt.h> | ||
1553 | +#include <linux/io.h> | ||
1554 | #include <linux/kernel.h> | ||
1555 | #include <linux/module.h> | ||
1556 | #include <linux/pci.h> | ||
1557 | @@ -149,6 +151,25 @@ struct zip_operation { | ||
1558 | u32 sizeofzops; | ||
1559 | }; | ||
1560 | |||
1561 | +static inline int zip_poll_result(union zip_zres_s *result) | ||
1562 | +{ | ||
1563 | + int retries = 1000; | ||
1564 | + | ||
1565 | + while (!result->s.compcode) { | ||
1566 | + if (!--retries) { | ||
1567 | + pr_err("ZIP ERR: request timed out"); | ||
1568 | + return -ETIMEDOUT; | ||
1569 | + } | ||
1570 | + udelay(10); | ||
1571 | + /* | ||
1572 | + * Force re-reading of compcode which is updated | ||
1573 | + * by the ZIP coprocessor. | ||
1574 | + */ | ||
1575 | + rmb(); | ||
1576 | + } | ||
1577 | + return 0; | ||
1578 | +} | ||
1579 | + | ||
1580 | /* error messages */ | ||
1581 | #define zip_err(fmt, args...) pr_err("ZIP ERR:%s():%d: " \ | ||
1582 | fmt "\n", __func__, __LINE__, ## args) | ||
1583 | diff --git a/drivers/crypto/cavium/zip/zip_crypto.c b/drivers/crypto/cavium/zip/zip_crypto.c | ||
1584 | index 8df4d26cf9d4..b92b6e7e100f 100644 | ||
1585 | --- a/drivers/crypto/cavium/zip/zip_crypto.c | ||
1586 | +++ b/drivers/crypto/cavium/zip/zip_crypto.c | ||
1587 | @@ -124,7 +124,7 @@ int zip_compress(const u8 *src, unsigned int slen, | ||
1588 | struct zip_kernel_ctx *zip_ctx) | ||
1589 | { | ||
1590 | struct zip_operation *zip_ops = NULL; | ||
1591 | - struct zip_state zip_state; | ||
1592 | + struct zip_state *zip_state; | ||
1593 | struct zip_device *zip = NULL; | ||
1594 | int ret; | ||
1595 | |||
1596 | @@ -135,20 +135,23 @@ int zip_compress(const u8 *src, unsigned int slen, | ||
1597 | if (!zip) | ||
1598 | return -ENODEV; | ||
1599 | |||
1600 | - memset(&zip_state, 0, sizeof(struct zip_state)); | ||
1601 | + zip_state = kzalloc(sizeof(*zip_state), GFP_ATOMIC); | ||
1602 | + if (!zip_state) | ||
1603 | + return -ENOMEM; | ||
1604 | + | ||
1605 | zip_ops = &zip_ctx->zip_comp; | ||
1606 | |||
1607 | zip_ops->input_len = slen; | ||
1608 | zip_ops->output_len = *dlen; | ||
1609 | memcpy(zip_ops->input, src, slen); | ||
1610 | |||
1611 | - ret = zip_deflate(zip_ops, &zip_state, zip); | ||
1612 | + ret = zip_deflate(zip_ops, zip_state, zip); | ||
1613 | |||
1614 | if (!ret) { | ||
1615 | *dlen = zip_ops->output_len; | ||
1616 | memcpy(dst, zip_ops->output, *dlen); | ||
1617 | } | ||
1618 | - | ||
1619 | + kfree(zip_state); | ||
1620 | return ret; | ||
1621 | } | ||
1622 | |||
1623 | @@ -157,7 +160,7 @@ int zip_decompress(const u8 *src, unsigned int slen, | ||
1624 | struct zip_kernel_ctx *zip_ctx) | ||
1625 | { | ||
1626 | struct zip_operation *zip_ops = NULL; | ||
1627 | - struct zip_state zip_state; | ||
1628 | + struct zip_state *zip_state; | ||
1629 | struct zip_device *zip = NULL; | ||
1630 | int ret; | ||
1631 | |||
1632 | @@ -168,7 +171,10 @@ int zip_decompress(const u8 *src, unsigned int slen, | ||
1633 | if (!zip) | ||
1634 | return -ENODEV; | ||
1635 | |||
1636 | - memset(&zip_state, 0, sizeof(struct zip_state)); | ||
1637 | + zip_state = kzalloc(sizeof(*zip_state), GFP_ATOMIC); | ||
1638 | + if (!zip_state) | ||
1639 | + return -ENOMEM; | ||
1640 | + | ||
1641 | zip_ops = &zip_ctx->zip_decomp; | ||
1642 | memcpy(zip_ops->input, src, slen); | ||
1643 | |||
1644 | @@ -179,13 +185,13 @@ int zip_decompress(const u8 *src, unsigned int slen, | ||
1645 | zip_ops->input_len = slen; | ||
1646 | zip_ops->output_len = *dlen; | ||
1647 | |||
1648 | - ret = zip_inflate(zip_ops, &zip_state, zip); | ||
1649 | + ret = zip_inflate(zip_ops, zip_state, zip); | ||
1650 | |||
1651 | if (!ret) { | ||
1652 | *dlen = zip_ops->output_len; | ||
1653 | memcpy(dst, zip_ops->output, *dlen); | ||
1654 | } | ||
1655 | - | ||
1656 | + kfree(zip_state); | ||
1657 | return ret; | ||
1658 | } | ||
1659 | |||
1660 | diff --git a/drivers/crypto/cavium/zip/zip_deflate.c b/drivers/crypto/cavium/zip/zip_deflate.c | ||
1661 | index 9a944b8c1e29..d7133f857d67 100644 | ||
1662 | --- a/drivers/crypto/cavium/zip/zip_deflate.c | ||
1663 | +++ b/drivers/crypto/cavium/zip/zip_deflate.c | ||
1664 | @@ -129,8 +129,8 @@ int zip_deflate(struct zip_operation *zip_ops, struct zip_state *s, | ||
1665 | /* Stats update for compression requests submitted */ | ||
1666 | atomic64_inc(&zip_dev->stats.comp_req_submit); | ||
1667 | |||
1668 | - while (!result_ptr->s.compcode) | ||
1669 | - continue; | ||
1670 | + /* Wait for completion or error */ | ||
1671 | + zip_poll_result(result_ptr); | ||
1672 | |||
1673 | /* Stats update for compression requests completed */ | ||
1674 | atomic64_inc(&zip_dev->stats.comp_req_complete); | ||
1675 | diff --git a/drivers/crypto/cavium/zip/zip_inflate.c b/drivers/crypto/cavium/zip/zip_inflate.c | ||
1676 | index 50cbdd83dbf2..7e0d73e2f89e 100644 | ||
1677 | --- a/drivers/crypto/cavium/zip/zip_inflate.c | ||
1678 | +++ b/drivers/crypto/cavium/zip/zip_inflate.c | ||
1679 | @@ -143,8 +143,8 @@ int zip_inflate(struct zip_operation *zip_ops, struct zip_state *s, | ||
1680 | /* Decompression requests submitted stats update */ | ||
1681 | atomic64_inc(&zip_dev->stats.decomp_req_submit); | ||
1682 | |||
1683 | - while (!result_ptr->s.compcode) | ||
1684 | - continue; | ||
1685 | + /* Wait for completion or error */ | ||
1686 | + zip_poll_result(result_ptr); | ||
1687 | |||
1688 | /* Decompression requests completed stats update */ | ||
1689 | atomic64_inc(&zip_dev->stats.decomp_req_complete); | ||
1690 | diff --git a/drivers/crypto/omap-sham.c b/drivers/crypto/omap-sham.c | ||
1691 | index c40ac30ec002..c1f8da958c78 100644 | ||
1692 | --- a/drivers/crypto/omap-sham.c | ||
1693 | +++ b/drivers/crypto/omap-sham.c | ||
1694 | @@ -1082,7 +1082,7 @@ static void omap_sham_finish_req(struct ahash_request *req, int err) | ||
1695 | |||
1696 | if (test_bit(FLAGS_SGS_COPIED, &dd->flags)) | ||
1697 | free_pages((unsigned long)sg_virt(ctx->sg), | ||
1698 | - get_order(ctx->sg->length)); | ||
1699 | + get_order(ctx->sg->length + ctx->bufcnt)); | ||
1700 | |||
1701 | if (test_bit(FLAGS_SGS_ALLOCED, &dd->flags)) | ||
1702 | kfree(ctx->sg); | ||
1703 | diff --git a/drivers/crypto/vmx/aes.c b/drivers/crypto/vmx/aes.c | ||
1704 | index 96072b9b55c4..d7316f7a3a69 100644 | ||
1705 | --- a/drivers/crypto/vmx/aes.c | ||
1706 | +++ b/drivers/crypto/vmx/aes.c | ||
1707 | @@ -48,8 +48,6 @@ static int p8_aes_init(struct crypto_tfm *tfm) | ||
1708 | alg, PTR_ERR(fallback)); | ||
1709 | return PTR_ERR(fallback); | ||
1710 | } | ||
1711 | - printk(KERN_INFO "Using '%s' as fallback implementation.\n", | ||
1712 | - crypto_tfm_alg_driver_name((struct crypto_tfm *) fallback)); | ||
1713 | |||
1714 | crypto_cipher_set_flags(fallback, | ||
1715 | crypto_cipher_get_flags((struct | ||
1716 | diff --git a/drivers/crypto/vmx/aes_cbc.c b/drivers/crypto/vmx/aes_cbc.c | ||
1717 | index 7394d35d5936..5285ece4f33a 100644 | ||
1718 | --- a/drivers/crypto/vmx/aes_cbc.c | ||
1719 | +++ b/drivers/crypto/vmx/aes_cbc.c | ||
1720 | @@ -52,9 +52,6 @@ static int p8_aes_cbc_init(struct crypto_tfm *tfm) | ||
1721 | alg, PTR_ERR(fallback)); | ||
1722 | return PTR_ERR(fallback); | ||
1723 | } | ||
1724 | - printk(KERN_INFO "Using '%s' as fallback implementation.\n", | ||
1725 | - crypto_skcipher_driver_name(fallback)); | ||
1726 | - | ||
1727 | |||
1728 | crypto_skcipher_set_flags( | ||
1729 | fallback, | ||
1730 | diff --git a/drivers/crypto/vmx/aes_ctr.c b/drivers/crypto/vmx/aes_ctr.c | ||
1731 | index 17d84217dd76..02ba5f2aa0e6 100644 | ||
1732 | --- a/drivers/crypto/vmx/aes_ctr.c | ||
1733 | +++ b/drivers/crypto/vmx/aes_ctr.c | ||
1734 | @@ -48,8 +48,6 @@ static int p8_aes_ctr_init(struct crypto_tfm *tfm) | ||
1735 | alg, PTR_ERR(fallback)); | ||
1736 | return PTR_ERR(fallback); | ||
1737 | } | ||
1738 | - printk(KERN_INFO "Using '%s' as fallback implementation.\n", | ||
1739 | - crypto_tfm_alg_driver_name((struct crypto_tfm *) fallback)); | ||
1740 | |||
1741 | crypto_blkcipher_set_flags( | ||
1742 | fallback, | ||
1743 | diff --git a/drivers/crypto/vmx/aes_xts.c b/drivers/crypto/vmx/aes_xts.c | ||
1744 | index 8cd6e62e4c90..8bd9aff0f55f 100644 | ||
1745 | --- a/drivers/crypto/vmx/aes_xts.c | ||
1746 | +++ b/drivers/crypto/vmx/aes_xts.c | ||
1747 | @@ -53,8 +53,6 @@ static int p8_aes_xts_init(struct crypto_tfm *tfm) | ||
1748 | alg, PTR_ERR(fallback)); | ||
1749 | return PTR_ERR(fallback); | ||
1750 | } | ||
1751 | - printk(KERN_INFO "Using '%s' as fallback implementation.\n", | ||
1752 | - crypto_skcipher_driver_name(fallback)); | ||
1753 | |||
1754 | crypto_skcipher_set_flags( | ||
1755 | fallback, | ||
1756 | diff --git a/drivers/crypto/vmx/ghash.c b/drivers/crypto/vmx/ghash.c | ||
1757 | index 27a94a119009..1c4b5b889fba 100644 | ||
1758 | --- a/drivers/crypto/vmx/ghash.c | ||
1759 | +++ b/drivers/crypto/vmx/ghash.c | ||
1760 | @@ -64,8 +64,6 @@ static int p8_ghash_init_tfm(struct crypto_tfm *tfm) | ||
1761 | alg, PTR_ERR(fallback)); | ||
1762 | return PTR_ERR(fallback); | ||
1763 | } | ||
1764 | - printk(KERN_INFO "Using '%s' as fallback implementation.\n", | ||
1765 | - crypto_tfm_alg_driver_name(crypto_shash_tfm(fallback))); | ||
1766 | |||
1767 | crypto_shash_set_flags(fallback, | ||
1768 | crypto_shash_get_flags((struct crypto_shash | ||
1769 | diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c | ||
1770 | index 68ea6e712bf9..7e0bfd7347f6 100644 | ||
1771 | --- a/drivers/gpio/gpiolib.c | ||
1772 | +++ b/drivers/gpio/gpiolib.c | ||
1773 | @@ -3313,6 +3313,8 @@ struct gpio_desc *__must_check gpiod_get_index(struct device *dev, | ||
1774 | struct gpio_desc *desc = NULL; | ||
1775 | int status; | ||
1776 | enum gpio_lookup_flags lookupflags = 0; | ||
1777 | + /* Maybe we have a device name, maybe not */ | ||
1778 | + const char *devname = dev ? dev_name(dev) : "?"; | ||
1779 | |||
1780 | dev_dbg(dev, "GPIO lookup for consumer %s\n", con_id); | ||
1781 | |||
1782 | @@ -3341,8 +3343,11 @@ struct gpio_desc *__must_check gpiod_get_index(struct device *dev, | ||
1783 | return desc; | ||
1784 | } | ||
1785 | |||
1786 | - /* If a connection label was passed use that, else use the device name as label */ | ||
1787 | - status = gpiod_request(desc, con_id ? con_id : dev_name(dev)); | ||
1788 | + /* | ||
1789 | + * If a connection label was passed use that, else attempt to use | ||
1790 | + * the device name as label | ||
1791 | + */ | ||
1792 | + status = gpiod_request(desc, con_id ? con_id : devname); | ||
1793 | if (status < 0) | ||
1794 | return ERR_PTR(status); | ||
1795 | |||
1796 | diff --git a/drivers/input/joystick/xpad.c b/drivers/input/joystick/xpad.c | ||
1797 | index d88d3e0f59fb..466cef930bf1 100644 | ||
1798 | --- a/drivers/input/joystick/xpad.c | ||
1799 | +++ b/drivers/input/joystick/xpad.c | ||
1800 | @@ -126,6 +126,7 @@ static const struct xpad_device { | ||
1801 | u8 mapping; | ||
1802 | u8 xtype; | ||
1803 | } xpad_device[] = { | ||
1804 | + { 0x0079, 0x18d4, "GPD Win 2 Controller", 0, XTYPE_XBOX360 }, | ||
1805 | { 0x044f, 0x0f00, "Thrustmaster Wheel", 0, XTYPE_XBOX }, | ||
1806 | { 0x044f, 0x0f03, "Thrustmaster Wheel", 0, XTYPE_XBOX }, | ||
1807 | { 0x044f, 0x0f07, "Thrustmaster, Inc. Controller", 0, XTYPE_XBOX }, | ||
1808 | @@ -411,6 +412,7 @@ static const signed short xpad_abs_triggers[] = { | ||
1809 | |||
1810 | static const struct usb_device_id xpad_table[] = { | ||
1811 | { USB_INTERFACE_INFO('X', 'B', 0) }, /* X-Box USB-IF not approved class */ | ||
1812 | + XPAD_XBOX360_VENDOR(0x0079), /* GPD Win 2 Controller */ | ||
1813 | XPAD_XBOX360_VENDOR(0x044f), /* Thrustmaster X-Box 360 controllers */ | ||
1814 | XPAD_XBOX360_VENDOR(0x045e), /* Microsoft X-Box 360 controllers */ | ||
1815 | XPAD_XBOXONE_VENDOR(0x045e), /* Microsoft X-Box One controllers */ | ||
1816 | diff --git a/drivers/input/mouse/elan_i2c_core.c b/drivers/input/mouse/elan_i2c_core.c | ||
1817 | index d6135900da64..c4926645c779 100644 | ||
1818 | --- a/drivers/input/mouse/elan_i2c_core.c | ||
1819 | +++ b/drivers/input/mouse/elan_i2c_core.c | ||
1820 | @@ -1260,6 +1260,7 @@ static const struct acpi_device_id elan_acpi_id[] = { | ||
1821 | { "ELAN060B", 0 }, | ||
1822 | { "ELAN060C", 0 }, | ||
1823 | { "ELAN0611", 0 }, | ||
1824 | + { "ELAN0612", 0 }, | ||
1825 | { "ELAN1000", 0 }, | ||
1826 | { } | ||
1827 | }; | ||
1828 | diff --git a/drivers/input/touchscreen/goodix.c b/drivers/input/touchscreen/goodix.c | ||
1829 | index 5dafafad6351..2bfa89ec552c 100644 | ||
1830 | --- a/drivers/input/touchscreen/goodix.c | ||
1831 | +++ b/drivers/input/touchscreen/goodix.c | ||
1832 | @@ -888,6 +888,7 @@ MODULE_DEVICE_TABLE(i2c, goodix_ts_id); | ||
1833 | #ifdef CONFIG_ACPI | ||
1834 | static const struct acpi_device_id goodix_acpi_match[] = { | ||
1835 | { "GDIX1001", 0 }, | ||
1836 | + { "GDIX1002", 0 }, | ||
1837 | { } | ||
1838 | }; | ||
1839 | MODULE_DEVICE_TABLE(acpi, goodix_acpi_match); | ||
1840 | diff --git a/drivers/misc/vmw_balloon.c b/drivers/misc/vmw_balloon.c | ||
1841 | index 9047c0a529b2..efd733472a35 100644 | ||
1842 | --- a/drivers/misc/vmw_balloon.c | ||
1843 | +++ b/drivers/misc/vmw_balloon.c | ||
1844 | @@ -576,15 +576,9 @@ static void vmballoon_pop(struct vmballoon *b) | ||
1845 | } | ||
1846 | } | ||
1847 | |||
1848 | - if (b->batch_page) { | ||
1849 | - vunmap(b->batch_page); | ||
1850 | - b->batch_page = NULL; | ||
1851 | - } | ||
1852 | - | ||
1853 | - if (b->page) { | ||
1854 | - __free_page(b->page); | ||
1855 | - b->page = NULL; | ||
1856 | - } | ||
1857 | + /* Clearing the batch_page unconditionally has no adverse effect */ | ||
1858 | + free_page((unsigned long)b->batch_page); | ||
1859 | + b->batch_page = NULL; | ||
1860 | } | ||
1861 | |||
1862 | /* | ||
1863 | @@ -991,16 +985,13 @@ static const struct vmballoon_ops vmballoon_batched_ops = { | ||
1864 | |||
1865 | static bool vmballoon_init_batching(struct vmballoon *b) | ||
1866 | { | ||
1867 | - b->page = alloc_page(VMW_PAGE_ALLOC_NOSLEEP); | ||
1868 | - if (!b->page) | ||
1869 | - return false; | ||
1870 | + struct page *page; | ||
1871 | |||
1872 | - b->batch_page = vmap(&b->page, 1, VM_MAP, PAGE_KERNEL); | ||
1873 | - if (!b->batch_page) { | ||
1874 | - __free_page(b->page); | ||
1875 | + page = alloc_page(GFP_KERNEL | __GFP_ZERO); | ||
1876 | + if (!page) | ||
1877 | return false; | ||
1878 | - } | ||
1879 | |||
1880 | + b->batch_page = page_address(page); | ||
1881 | return true; | ||
1882 | } | ||
1883 | |||
1884 | diff --git a/drivers/nfc/pn533/usb.c b/drivers/nfc/pn533/usb.c | ||
1885 | index e153e8b64bb8..d5553c47014f 100644 | ||
1886 | --- a/drivers/nfc/pn533/usb.c | ||
1887 | +++ b/drivers/nfc/pn533/usb.c | ||
1888 | @@ -62,6 +62,9 @@ struct pn533_usb_phy { | ||
1889 | struct urb *out_urb; | ||
1890 | struct urb *in_urb; | ||
1891 | |||
1892 | + struct urb *ack_urb; | ||
1893 | + u8 *ack_buffer; | ||
1894 | + | ||
1895 | struct pn533 *priv; | ||
1896 | }; | ||
1897 | |||
1898 | @@ -150,13 +153,16 @@ static int pn533_usb_send_ack(struct pn533 *dev, gfp_t flags) | ||
1899 | struct pn533_usb_phy *phy = dev->phy; | ||
1900 | static const u8 ack[6] = {0x00, 0x00, 0xff, 0x00, 0xff, 0x00}; | ||
1901 | /* spec 7.1.1.3: Preamble, SoPC (2), ACK Code (2), Postamble */ | ||
1902 | - int rc; | ||
1903 | |||
1904 | - phy->out_urb->transfer_buffer = (u8 *)ack; | ||
1905 | - phy->out_urb->transfer_buffer_length = sizeof(ack); | ||
1906 | - rc = usb_submit_urb(phy->out_urb, flags); | ||
1907 | + if (!phy->ack_buffer) { | ||
1908 | + phy->ack_buffer = kmemdup(ack, sizeof(ack), flags); | ||
1909 | + if (!phy->ack_buffer) | ||
1910 | + return -ENOMEM; | ||
1911 | + } | ||
1912 | |||
1913 | - return rc; | ||
1914 | + phy->ack_urb->transfer_buffer = phy->ack_buffer; | ||
1915 | + phy->ack_urb->transfer_buffer_length = sizeof(ack); | ||
1916 | + return usb_submit_urb(phy->ack_urb, flags); | ||
1917 | } | ||
1918 | |||
1919 | static int pn533_usb_send_frame(struct pn533 *dev, | ||
1920 | @@ -375,26 +381,31 @@ static int pn533_acr122_poweron_rdr(struct pn533_usb_phy *phy) | ||
1921 | /* Power on th reader (CCID cmd) */ | ||
1922 | u8 cmd[10] = {PN533_ACR122_PC_TO_RDR_ICCPOWERON, | ||
1923 | 0, 0, 0, 0, 0, 0, 3, 0, 0}; | ||
1924 | + char *buffer; | ||
1925 | + int transferred; | ||
1926 | int rc; | ||
1927 | void *cntx; | ||
1928 | struct pn533_acr122_poweron_rdr_arg arg; | ||
1929 | |||
1930 | dev_dbg(&phy->udev->dev, "%s\n", __func__); | ||
1931 | |||
1932 | + buffer = kmemdup(cmd, sizeof(cmd), GFP_KERNEL); | ||
1933 | + if (!buffer) | ||
1934 | + return -ENOMEM; | ||
1935 | + | ||
1936 | init_completion(&arg.done); | ||
1937 | cntx = phy->in_urb->context; /* backup context */ | ||
1938 | |||
1939 | phy->in_urb->complete = pn533_acr122_poweron_rdr_resp; | ||
1940 | phy->in_urb->context = &arg; | ||
1941 | |||
1942 | - phy->out_urb->transfer_buffer = cmd; | ||
1943 | - phy->out_urb->transfer_buffer_length = sizeof(cmd); | ||
1944 | - | ||
1945 | print_hex_dump_debug("ACR122 TX: ", DUMP_PREFIX_NONE, 16, 1, | ||
1946 | cmd, sizeof(cmd), false); | ||
1947 | |||
1948 | - rc = usb_submit_urb(phy->out_urb, GFP_KERNEL); | ||
1949 | - if (rc) { | ||
1950 | + rc = usb_bulk_msg(phy->udev, phy->out_urb->pipe, buffer, sizeof(cmd), | ||
1951 | + &transferred, 0); | ||
1952 | + kfree(buffer); | ||
1953 | + if (rc || (transferred != sizeof(cmd))) { | ||
1954 | nfc_err(&phy->udev->dev, | ||
1955 | "Reader power on cmd error %d\n", rc); | ||
1956 | return rc; | ||
1957 | @@ -490,8 +501,9 @@ static int pn533_usb_probe(struct usb_interface *interface, | ||
1958 | |||
1959 | phy->in_urb = usb_alloc_urb(0, GFP_KERNEL); | ||
1960 | phy->out_urb = usb_alloc_urb(0, GFP_KERNEL); | ||
1961 | + phy->ack_urb = usb_alloc_urb(0, GFP_KERNEL); | ||
1962 | |||
1963 | - if (!phy->in_urb || !phy->out_urb) | ||
1964 | + if (!phy->in_urb || !phy->out_urb || !phy->ack_urb) | ||
1965 | goto error; | ||
1966 | |||
1967 | usb_fill_bulk_urb(phy->in_urb, phy->udev, | ||
1968 | @@ -501,7 +513,9 @@ static int pn533_usb_probe(struct usb_interface *interface, | ||
1969 | usb_fill_bulk_urb(phy->out_urb, phy->udev, | ||
1970 | usb_sndbulkpipe(phy->udev, out_endpoint), | ||
1971 | NULL, 0, pn533_send_complete, phy); | ||
1972 | - | ||
1973 | + usb_fill_bulk_urb(phy->ack_urb, phy->udev, | ||
1974 | + usb_sndbulkpipe(phy->udev, out_endpoint), | ||
1975 | + NULL, 0, pn533_send_complete, phy); | ||
1976 | |||
1977 | switch (id->driver_info) { | ||
1978 | case PN533_DEVICE_STD: | ||
1979 | @@ -554,6 +568,7 @@ static int pn533_usb_probe(struct usb_interface *interface, | ||
1980 | error: | ||
1981 | usb_free_urb(phy->in_urb); | ||
1982 | usb_free_urb(phy->out_urb); | ||
1983 | + usb_free_urb(phy->ack_urb); | ||
1984 | usb_put_dev(phy->udev); | ||
1985 | kfree(in_buf); | ||
1986 | |||
1987 | @@ -573,10 +588,13 @@ static void pn533_usb_disconnect(struct usb_interface *interface) | ||
1988 | |||
1989 | usb_kill_urb(phy->in_urb); | ||
1990 | usb_kill_urb(phy->out_urb); | ||
1991 | + usb_kill_urb(phy->ack_urb); | ||
1992 | |||
1993 | kfree(phy->in_urb->transfer_buffer); | ||
1994 | usb_free_urb(phy->in_urb); | ||
1995 | usb_free_urb(phy->out_urb); | ||
1996 | + usb_free_urb(phy->ack_urb); | ||
1997 | + kfree(phy->ack_buffer); | ||
1998 | |||
1999 | nfc_info(&interface->dev, "NXP PN533 NFC device disconnected\n"); | ||
2000 | } | ||
2001 | diff --git a/drivers/phy/qualcomm/phy-qcom-qusb2.c b/drivers/phy/qualcomm/phy-qcom-qusb2.c | ||
2002 | index 6c575244c0fb..af9b7005a2ba 100644 | ||
2003 | --- a/drivers/phy/qualcomm/phy-qcom-qusb2.c | ||
2004 | +++ b/drivers/phy/qualcomm/phy-qcom-qusb2.c | ||
2005 | @@ -178,6 +178,10 @@ static void qusb2_phy_set_tune2_param(struct qusb2_phy *qphy) | ||
2006 | struct device *dev = &qphy->phy->dev; | ||
2007 | u8 *val; | ||
2008 | |||
2009 | + /* efuse register is optional */ | ||
2010 | + if (!qphy->cell) | ||
2011 | + return; | ||
2012 | + | ||
2013 | /* | ||
2014 | * Read efuse register having TUNE2 parameter's high nibble. | ||
2015 | * If efuse register shows value as 0x0, or if we fail to find | ||
2016 | diff --git a/drivers/staging/android/ion/ion.c b/drivers/staging/android/ion/ion.c | ||
2017 | index 83dc3292e9ab..24cb666c9224 100644 | ||
2018 | --- a/drivers/staging/android/ion/ion.c | ||
2019 | +++ b/drivers/staging/android/ion/ion.c | ||
2020 | @@ -131,8 +131,11 @@ static struct ion_buffer *ion_buffer_create(struct ion_heap *heap, | ||
2021 | |||
2022 | void ion_buffer_destroy(struct ion_buffer *buffer) | ||
2023 | { | ||
2024 | - if (WARN_ON(buffer->kmap_cnt > 0)) | ||
2025 | + if (buffer->kmap_cnt > 0) { | ||
2026 | + pr_warn_once("%s: buffer still mapped in the kernel\n", | ||
2027 | + __func__); | ||
2028 | buffer->heap->ops->unmap_kernel(buffer->heap, buffer); | ||
2029 | + } | ||
2030 | buffer->heap->ops->free(buffer); | ||
2031 | kfree(buffer); | ||
2032 | } | ||
2033 | diff --git a/drivers/tty/serial/8250/8250_omap.c b/drivers/tty/serial/8250/8250_omap.c | ||
2034 | index 833771bca0a5..da04ba1ecf68 100644 | ||
2035 | --- a/drivers/tty/serial/8250/8250_omap.c | ||
2036 | +++ b/drivers/tty/serial/8250/8250_omap.c | ||
2037 | @@ -1100,13 +1100,14 @@ static int omap8250_no_handle_irq(struct uart_port *port) | ||
2038 | return 0; | ||
2039 | } | ||
2040 | |||
2041 | +static const u8 omap4_habit = UART_ERRATA_CLOCK_DISABLE; | ||
2042 | static const u8 am3352_habit = OMAP_DMA_TX_KICK | UART_ERRATA_CLOCK_DISABLE; | ||
2043 | static const u8 dra742_habit = UART_ERRATA_CLOCK_DISABLE; | ||
2044 | |||
2045 | static const struct of_device_id omap8250_dt_ids[] = { | ||
2046 | { .compatible = "ti,omap2-uart" }, | ||
2047 | { .compatible = "ti,omap3-uart" }, | ||
2048 | - { .compatible = "ti,omap4-uart" }, | ||
2049 | + { .compatible = "ti,omap4-uart", .data = &omap4_habit, }, | ||
2050 | { .compatible = "ti,am3352-uart", .data = &am3352_habit, }, | ||
2051 | { .compatible = "ti,am4372-uart", .data = &am3352_habit, }, | ||
2052 | { .compatible = "ti,dra742-uart", .data = &dra742_habit, }, | ||
2053 | @@ -1343,6 +1344,19 @@ static int omap8250_soft_reset(struct device *dev) | ||
2054 | int sysc; | ||
2055 | int syss; | ||
2056 | |||
2057 | + /* | ||
2058 | + * At least on omap4, unused uarts may not idle after reset without | ||
2059 | + * a basic scr dma configuration even with no dma in use. The | ||
2060 | + * module clkctrl status bits will be 1 instead of 3 blocking idle | ||
2061 | + * for the whole clockdomain. The softreset below will clear scr, | ||
2062 | + * and we restore it on resume so this is safe to do on all SoCs | ||
2063 | + * needing omap8250_soft_reset() quirk. Do it in two writes as | ||
2064 | + * recommended in the comment for omap8250_update_scr(). | ||
2065 | + */ | ||
2066 | + serial_out(up, UART_OMAP_SCR, OMAP_UART_SCR_DMAMODE_1); | ||
2067 | + serial_out(up, UART_OMAP_SCR, | ||
2068 | + OMAP_UART_SCR_DMAMODE_1 | OMAP_UART_SCR_DMAMODE_CTL); | ||
2069 | + | ||
2070 | sysc = serial_in(up, UART_OMAP_SYSC); | ||
2071 | |||
2072 | /* softreset the UART */ | ||
2073 | diff --git a/drivers/tty/serial/amba-pl011.c b/drivers/tty/serial/amba-pl011.c | ||
2074 | index 111e6a950779..c9f701aca677 100644 | ||
2075 | --- a/drivers/tty/serial/amba-pl011.c | ||
2076 | +++ b/drivers/tty/serial/amba-pl011.c | ||
2077 | @@ -1747,10 +1747,26 @@ static int pl011_allocate_irq(struct uart_amba_port *uap) | ||
2078 | */ | ||
2079 | static void pl011_enable_interrupts(struct uart_amba_port *uap) | ||
2080 | { | ||
2081 | + unsigned int i; | ||
2082 | + | ||
2083 | spin_lock_irq(&uap->port.lock); | ||
2084 | |||
2085 | /* Clear out any spuriously appearing RX interrupts */ | ||
2086 | pl011_write(UART011_RTIS | UART011_RXIS, uap, REG_ICR); | ||
2087 | + | ||
2088 | + /* | ||
2089 | + * RXIS is asserted only when the RX FIFO transitions from below | ||
2090 | + * to above the trigger threshold. If the RX FIFO is already | ||
2091 | + * full to the threshold this can't happen and RXIS will now be | ||
2092 | + * stuck off. Drain the RX FIFO explicitly to fix this: | ||
2093 | + */ | ||
2094 | + for (i = 0; i < uap->fifosize * 2; ++i) { | ||
2095 | + if (pl011_read(uap, REG_FR) & UART01x_FR_RXFE) | ||
2096 | + break; | ||
2097 | + | ||
2098 | + pl011_read(uap, REG_DR); | ||
2099 | + } | ||
2100 | + | ||
2101 | uap->im = UART011_RTIM; | ||
2102 | if (!pl011_dma_rx_running(uap)) | ||
2103 | uap->im |= UART011_RXIM; | ||
2104 | diff --git a/drivers/tty/serial/atmel_serial.c b/drivers/tty/serial/atmel_serial.c | ||
2105 | index a0b24bc09783..2286e9d73115 100644 | ||
2106 | --- a/drivers/tty/serial/atmel_serial.c | ||
2107 | +++ b/drivers/tty/serial/atmel_serial.c | ||
2108 | @@ -1786,7 +1786,6 @@ static int atmel_startup(struct uart_port *port) | ||
2109 | { | ||
2110 | struct platform_device *pdev = to_platform_device(port->dev); | ||
2111 | struct atmel_uart_port *atmel_port = to_atmel_uart_port(port); | ||
2112 | - struct tty_struct *tty = port->state->port.tty; | ||
2113 | int retval; | ||
2114 | |||
2115 | /* | ||
2116 | @@ -1801,8 +1800,8 @@ static int atmel_startup(struct uart_port *port) | ||
2117 | * Allocate the IRQ | ||
2118 | */ | ||
2119 | retval = request_irq(port->irq, atmel_interrupt, | ||
2120 | - IRQF_SHARED | IRQF_COND_SUSPEND, | ||
2121 | - tty ? tty->name : "atmel_serial", port); | ||
2122 | + IRQF_SHARED | IRQF_COND_SUSPEND, | ||
2123 | + dev_name(&pdev->dev), port); | ||
2124 | if (retval) { | ||
2125 | dev_err(port->dev, "atmel_startup - Can't get irq\n"); | ||
2126 | return retval; | ||
2127 | diff --git a/drivers/tty/serial/samsung.c b/drivers/tty/serial/samsung.c | ||
2128 | index bedd4bdec4ab..57baa84ccf86 100644 | ||
2129 | --- a/drivers/tty/serial/samsung.c | ||
2130 | +++ b/drivers/tty/serial/samsung.c | ||
2131 | @@ -865,15 +865,12 @@ static int s3c24xx_serial_request_dma(struct s3c24xx_uart_port *p) | ||
2132 | dma->rx_conf.direction = DMA_DEV_TO_MEM; | ||
2133 | dma->rx_conf.src_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE; | ||
2134 | dma->rx_conf.src_addr = p->port.mapbase + S3C2410_URXH; | ||
2135 | - dma->rx_conf.src_maxburst = 16; | ||
2136 | + dma->rx_conf.src_maxburst = 1; | ||
2137 | |||
2138 | dma->tx_conf.direction = DMA_MEM_TO_DEV; | ||
2139 | dma->tx_conf.dst_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE; | ||
2140 | dma->tx_conf.dst_addr = p->port.mapbase + S3C2410_UTXH; | ||
2141 | - if (dma_get_cache_alignment() >= 16) | ||
2142 | - dma->tx_conf.dst_maxburst = 16; | ||
2143 | - else | ||
2144 | - dma->tx_conf.dst_maxburst = 1; | ||
2145 | + dma->tx_conf.dst_maxburst = 1; | ||
2146 | |||
2147 | dma->rx_chan = dma_request_chan(p->port.dev, "rx"); | ||
2148 | |||
2149 | diff --git a/drivers/tty/serial/sh-sci.c b/drivers/tty/serial/sh-sci.c | ||
2150 | index 8a58ee32ff61..c6daa315ee4e 100644 | ||
2151 | --- a/drivers/tty/serial/sh-sci.c | ||
2152 | +++ b/drivers/tty/serial/sh-sci.c | ||
2153 | @@ -2669,8 +2669,8 @@ static int sci_init_clocks(struct sci_port *sci_port, struct device *dev) | ||
2154 | dev_dbg(dev, "failed to get %s (%ld)\n", clk_names[i], | ||
2155 | PTR_ERR(clk)); | ||
2156 | else | ||
2157 | - dev_dbg(dev, "clk %s is %pC rate %pCr\n", clk_names[i], | ||
2158 | - clk, clk); | ||
2159 | + dev_dbg(dev, "clk %s is %pC rate %lu\n", clk_names[i], | ||
2160 | + clk, clk_get_rate(clk)); | ||
2161 | sci_port->clks[i] = IS_ERR(clk) ? NULL : clk; | ||
2162 | } | ||
2163 | return 0; | ||
2164 | diff --git a/drivers/usb/gadget/function/f_printer.c b/drivers/usb/gadget/function/f_printer.c | ||
2165 | index ea0da35a44e2..e6d4fa5eeff1 100644 | ||
2166 | --- a/drivers/usb/gadget/function/f_printer.c | ||
2167 | +++ b/drivers/usb/gadget/function/f_printer.c | ||
2168 | @@ -635,19 +635,19 @@ printer_write(struct file *fd, const char __user *buf, size_t len, loff_t *ptr) | ||
2169 | return -EAGAIN; | ||
2170 | } | ||
2171 | |||
2172 | + list_add(&req->list, &dev->tx_reqs_active); | ||
2173 | + | ||
2174 | /* here, we unlock, and only unlock, to avoid deadlock. */ | ||
2175 | spin_unlock(&dev->lock); | ||
2176 | value = usb_ep_queue(dev->in_ep, req, GFP_ATOMIC); | ||
2177 | spin_lock(&dev->lock); | ||
2178 | if (value) { | ||
2179 | + list_del(&req->list); | ||
2180 | list_add(&req->list, &dev->tx_reqs); | ||
2181 | spin_unlock_irqrestore(&dev->lock, flags); | ||
2182 | mutex_unlock(&dev->lock_printer_io); | ||
2183 | return -EAGAIN; | ||
2184 | } | ||
2185 | - | ||
2186 | - list_add(&req->list, &dev->tx_reqs_active); | ||
2187 | - | ||
2188 | } | ||
2189 | |||
2190 | spin_unlock_irqrestore(&dev->lock, flags); | ||
2191 | diff --git a/drivers/usb/gadget/udc/renesas_usb3.c b/drivers/usb/gadget/udc/renesas_usb3.c | ||
2192 | index 6b3e8adb64e6..4cfa72cb0a91 100644 | ||
2193 | --- a/drivers/usb/gadget/udc/renesas_usb3.c | ||
2194 | +++ b/drivers/usb/gadget/udc/renesas_usb3.c | ||
2195 | @@ -623,6 +623,13 @@ static void usb3_disconnect(struct renesas_usb3 *usb3) | ||
2196 | usb3_usb2_pullup(usb3, 0); | ||
2197 | usb3_clear_bit(usb3, USB30_CON_B3_CONNECT, USB3_USB30_CON); | ||
2198 | usb3_reset_epc(usb3); | ||
2199 | + usb3_disable_irq_1(usb3, USB_INT_1_B2_RSUM | USB_INT_1_B3_PLLWKUP | | ||
2200 | + USB_INT_1_B3_LUPSUCS | USB_INT_1_B3_DISABLE | | ||
2201 | + USB_INT_1_SPEED | USB_INT_1_B3_WRMRST | | ||
2202 | + USB_INT_1_B3_HOTRST | USB_INT_1_B2_SPND | | ||
2203 | + USB_INT_1_B2_L1SPND | USB_INT_1_B2_USBRST); | ||
2204 | + usb3_clear_bit(usb3, USB_COM_CON_SPD_MODE, USB3_USB_COM_CON); | ||
2205 | + usb3_init_epc_registers(usb3); | ||
2206 | |||
2207 | if (usb3->driver) | ||
2208 | usb3->driver->disconnect(&usb3->gadget); | ||
2209 | diff --git a/drivers/usb/storage/uas.c b/drivers/usb/storage/uas.c | ||
2210 | index 25a281f876b5..33a6d624c843 100644 | ||
2211 | --- a/drivers/usb/storage/uas.c | ||
2212 | +++ b/drivers/usb/storage/uas.c | ||
2213 | @@ -836,6 +836,12 @@ static int uas_slave_configure(struct scsi_device *sdev) | ||
2214 | if (devinfo->flags & US_FL_BROKEN_FUA) | ||
2215 | sdev->broken_fua = 1; | ||
2216 | |||
2217 | + /* UAS also needs to support FL_ALWAYS_SYNC */ | ||
2218 | + if (devinfo->flags & US_FL_ALWAYS_SYNC) { | ||
2219 | + sdev->skip_ms_page_3f = 1; | ||
2220 | + sdev->skip_ms_page_8 = 1; | ||
2221 | + sdev->wce_default_on = 1; | ||
2222 | + } | ||
2223 | scsi_change_queue_depth(sdev, devinfo->qdepth - 2); | ||
2224 | return 0; | ||
2225 | } | ||
2226 | diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h | ||
2227 | index 52b3e6da0745..d100290628bd 100644 | ||
2228 | --- a/drivers/usb/storage/unusual_devs.h | ||
2229 | +++ b/drivers/usb/storage/unusual_devs.h | ||
2230 | @@ -2340,6 +2340,15 @@ UNUSUAL_DEV( 0x4146, 0xba01, 0x0100, 0x0100, | ||
2231 | "Micro Mini 1GB", | ||
2232 | USB_SC_DEVICE, USB_PR_DEVICE, NULL, US_FL_NOT_LOCKABLE ), | ||
2233 | |||
2234 | +/* "G-DRIVE" external HDD hangs on write without these. | ||
2235 | + * Patch submitted by Alexander Kappner <agk@godking.net> | ||
2236 | + */ | ||
2237 | +UNUSUAL_DEV(0x4971, 0x8024, 0x0000, 0x9999, | ||
2238 | + "SimpleTech", | ||
2239 | + "External HDD", | ||
2240 | + USB_SC_DEVICE, USB_PR_DEVICE, NULL, | ||
2241 | + US_FL_ALWAYS_SYNC), | ||
2242 | + | ||
2243 | /* | ||
2244 | * Nick Bowler <nbowler@elliptictech.com> | ||
2245 | * SCSI stack spams (otherwise harmless) error messages. | ||
2246 | diff --git a/drivers/usb/storage/unusual_uas.h b/drivers/usb/storage/unusual_uas.h | ||
2247 | index 719ec68ae309..f15aa47c54a9 100644 | ||
2248 | --- a/drivers/usb/storage/unusual_uas.h | ||
2249 | +++ b/drivers/usb/storage/unusual_uas.h | ||
2250 | @@ -183,3 +183,12 @@ UNUSUAL_DEV(0x4971, 0x8017, 0x0000, 0x9999, | ||
2251 | "External HDD", | ||
2252 | USB_SC_DEVICE, USB_PR_DEVICE, NULL, | ||
2253 | US_FL_NO_REPORT_OPCODES), | ||
2254 | + | ||
2255 | +/* "G-DRIVE" external HDD hangs on write without these. | ||
2256 | + * Patch submitted by Alexander Kappner <agk@godking.net> | ||
2257 | + */ | ||
2258 | +UNUSUAL_DEV(0x4971, 0x8024, 0x0000, 0x9999, | ||
2259 | + "SimpleTech", | ||
2260 | + "External HDD", | ||
2261 | + USB_SC_DEVICE, USB_PR_DEVICE, NULL, | ||
2262 | + US_FL_ALWAYS_SYNC), | ||
2263 | diff --git a/drivers/usb/usbip/vhci_sysfs.c b/drivers/usb/usbip/vhci_sysfs.c | ||
2264 | index 84df63e3130d..4a22a9f06d96 100644 | ||
2265 | --- a/drivers/usb/usbip/vhci_sysfs.c | ||
2266 | +++ b/drivers/usb/usbip/vhci_sysfs.c | ||
2267 | @@ -24,6 +24,9 @@ | ||
2268 | #include <linux/platform_device.h> | ||
2269 | #include <linux/slab.h> | ||
2270 | |||
2271 | +/* Hardening for Spectre-v1 */ | ||
2272 | +#include <linux/nospec.h> | ||
2273 | + | ||
2274 | #include "usbip_common.h" | ||
2275 | #include "vhci.h" | ||
2276 | |||
2277 | @@ -219,16 +222,20 @@ static int vhci_port_disconnect(struct vhci_hcd *vhci_hcd, __u32 rhport) | ||
2278 | return 0; | ||
2279 | } | ||
2280 | |||
2281 | -static int valid_port(__u32 pdev_nr, __u32 rhport) | ||
2282 | +static int valid_port(__u32 *pdev_nr, __u32 *rhport) | ||
2283 | { | ||
2284 | - if (pdev_nr >= vhci_num_controllers) { | ||
2285 | - pr_err("pdev %u\n", pdev_nr); | ||
2286 | + if (*pdev_nr >= vhci_num_controllers) { | ||
2287 | + pr_err("pdev %u\n", *pdev_nr); | ||
2288 | return 0; | ||
2289 | } | ||
2290 | - if (rhport >= VHCI_HC_PORTS) { | ||
2291 | - pr_err("rhport %u\n", rhport); | ||
2292 | + *pdev_nr = array_index_nospec(*pdev_nr, vhci_num_controllers); | ||
2293 | + | ||
2294 | + if (*rhport >= VHCI_HC_PORTS) { | ||
2295 | + pr_err("rhport %u\n", *rhport); | ||
2296 | return 0; | ||
2297 | } | ||
2298 | + *rhport = array_index_nospec(*rhport, VHCI_HC_PORTS); | ||
2299 | + | ||
2300 | return 1; | ||
2301 | } | ||
2302 | |||
2303 | @@ -246,7 +253,7 @@ static ssize_t store_detach(struct device *dev, struct device_attribute *attr, | ||
2304 | pdev_nr = port_to_pdev_nr(port); | ||
2305 | rhport = port_to_rhport(port); | ||
2306 | |||
2307 | - if (!valid_port(pdev_nr, rhport)) | ||
2308 | + if (!valid_port(&pdev_nr, &rhport)) | ||
2309 | return -EINVAL; | ||
2310 | |||
2311 | hcd = platform_get_drvdata(vhcis[pdev_nr].pdev); | ||
2312 | @@ -272,7 +279,8 @@ static ssize_t store_detach(struct device *dev, struct device_attribute *attr, | ||
2313 | } | ||
2314 | static DEVICE_ATTR(detach, S_IWUSR, NULL, store_detach); | ||
2315 | |||
2316 | -static int valid_args(__u32 pdev_nr, __u32 rhport, enum usb_device_speed speed) | ||
2317 | +static int valid_args(__u32 *pdev_nr, __u32 *rhport, | ||
2318 | + enum usb_device_speed speed) | ||
2319 | { | ||
2320 | if (!valid_port(pdev_nr, rhport)) { | ||
2321 | return 0; | ||
2322 | @@ -336,7 +344,7 @@ static ssize_t store_attach(struct device *dev, struct device_attribute *attr, | ||
2323 | sockfd, devid, speed); | ||
2324 | |||
2325 | /* check received parameters */ | ||
2326 | - if (!valid_args(pdev_nr, rhport, speed)) | ||
2327 | + if (!valid_args(&pdev_nr, &rhport, speed)) | ||
2328 | return -EINVAL; | ||
2329 | |||
2330 | hcd = platform_get_drvdata(vhcis[pdev_nr].pdev); | ||
2331 | diff --git a/net/key/af_key.c b/net/key/af_key.c | ||
2332 | index 2ad693232f74..3b209cbfe1df 100644 | ||
2333 | --- a/net/key/af_key.c | ||
2334 | +++ b/net/key/af_key.c | ||
2335 | @@ -437,6 +437,24 @@ static int verify_address_len(const void *p) | ||
2336 | return 0; | ||
2337 | } | ||
2338 | |||
2339 | +static inline int sadb_key_len(const struct sadb_key *key) | ||
2340 | +{ | ||
2341 | + int key_bytes = DIV_ROUND_UP(key->sadb_key_bits, 8); | ||
2342 | + | ||
2343 | + return DIV_ROUND_UP(sizeof(struct sadb_key) + key_bytes, | ||
2344 | + sizeof(uint64_t)); | ||
2345 | +} | ||
2346 | + | ||
2347 | +static int verify_key_len(const void *p) | ||
2348 | +{ | ||
2349 | + const struct sadb_key *key = p; | ||
2350 | + | ||
2351 | + if (sadb_key_len(key) > key->sadb_key_len) | ||
2352 | + return -EINVAL; | ||
2353 | + | ||
2354 | + return 0; | ||
2355 | +} | ||
2356 | + | ||
2357 | static inline int pfkey_sec_ctx_len(const struct sadb_x_sec_ctx *sec_ctx) | ||
2358 | { | ||
2359 | return DIV_ROUND_UP(sizeof(struct sadb_x_sec_ctx) + | ||
2360 | @@ -533,16 +551,25 @@ static int parse_exthdrs(struct sk_buff *skb, const struct sadb_msg *hdr, void * | ||
2361 | return -EINVAL; | ||
2362 | if (ext_hdrs[ext_type-1] != NULL) | ||
2363 | return -EINVAL; | ||
2364 | - if (ext_type == SADB_EXT_ADDRESS_SRC || | ||
2365 | - ext_type == SADB_EXT_ADDRESS_DST || | ||
2366 | - ext_type == SADB_EXT_ADDRESS_PROXY || | ||
2367 | - ext_type == SADB_X_EXT_NAT_T_OA) { | ||
2368 | + switch (ext_type) { | ||
2369 | + case SADB_EXT_ADDRESS_SRC: | ||
2370 | + case SADB_EXT_ADDRESS_DST: | ||
2371 | + case SADB_EXT_ADDRESS_PROXY: | ||
2372 | + case SADB_X_EXT_NAT_T_OA: | ||
2373 | if (verify_address_len(p)) | ||
2374 | return -EINVAL; | ||
2375 | - } | ||
2376 | - if (ext_type == SADB_X_EXT_SEC_CTX) { | ||
2377 | + break; | ||
2378 | + case SADB_X_EXT_SEC_CTX: | ||
2379 | if (verify_sec_ctx_len(p)) | ||
2380 | return -EINVAL; | ||
2381 | + break; | ||
2382 | + case SADB_EXT_KEY_AUTH: | ||
2383 | + case SADB_EXT_KEY_ENCRYPT: | ||
2384 | + if (verify_key_len(p)) | ||
2385 | + return -EINVAL; | ||
2386 | + break; | ||
2387 | + default: | ||
2388 | + break; | ||
2389 | } | ||
2390 | ext_hdrs[ext_type-1] = (void *) p; | ||
2391 | } | ||
2392 | @@ -1104,14 +1131,12 @@ static struct xfrm_state * pfkey_msg2xfrm_state(struct net *net, | ||
2393 | key = ext_hdrs[SADB_EXT_KEY_AUTH - 1]; | ||
2394 | if (key != NULL && | ||
2395 | sa->sadb_sa_auth != SADB_X_AALG_NULL && | ||
2396 | - ((key->sadb_key_bits+7) / 8 == 0 || | ||
2397 | - (key->sadb_key_bits+7) / 8 > key->sadb_key_len * sizeof(uint64_t))) | ||
2398 | + key->sadb_key_bits == 0) | ||
2399 | return ERR_PTR(-EINVAL); | ||
2400 | key = ext_hdrs[SADB_EXT_KEY_ENCRYPT-1]; | ||
2401 | if (key != NULL && | ||
2402 | sa->sadb_sa_encrypt != SADB_EALG_NULL && | ||
2403 | - ((key->sadb_key_bits+7) / 8 == 0 || | ||
2404 | - (key->sadb_key_bits+7) / 8 > key->sadb_key_len * sizeof(uint64_t))) | ||
2405 | + key->sadb_key_bits == 0) | ||
2406 | return ERR_PTR(-EINVAL); | ||
2407 | |||
2408 | x = xfrm_state_alloc(net); | ||
2409 | diff --git a/net/netfilter/nft_ct.c b/net/netfilter/nft_ct.c | ||
2410 | index bd0975d7dd6f..5e0d367a0988 100644 | ||
2411 | --- a/net/netfilter/nft_ct.c | ||
2412 | +++ b/net/netfilter/nft_ct.c | ||
2413 | @@ -875,22 +875,26 @@ static int nft_ct_helper_obj_dump(struct sk_buff *skb, | ||
2414 | struct nft_object *obj, bool reset) | ||
2415 | { | ||
2416 | const struct nft_ct_helper_obj *priv = nft_obj_data(obj); | ||
2417 | - const struct nf_conntrack_helper *helper = priv->helper4; | ||
2418 | + const struct nf_conntrack_helper *helper; | ||
2419 | u16 family; | ||
2420 | |||
2421 | + if (priv->helper4 && priv->helper6) { | ||
2422 | + family = NFPROTO_INET; | ||
2423 | + helper = priv->helper4; | ||
2424 | + } else if (priv->helper6) { | ||
2425 | + family = NFPROTO_IPV6; | ||
2426 | + helper = priv->helper6; | ||
2427 | + } else { | ||
2428 | + family = NFPROTO_IPV4; | ||
2429 | + helper = priv->helper4; | ||
2430 | + } | ||
2431 | + | ||
2432 | if (nla_put_string(skb, NFTA_CT_HELPER_NAME, helper->name)) | ||
2433 | return -1; | ||
2434 | |||
2435 | if (nla_put_u8(skb, NFTA_CT_HELPER_L4PROTO, priv->l4proto)) | ||
2436 | return -1; | ||
2437 | |||
2438 | - if (priv->helper4 && priv->helper6) | ||
2439 | - family = NFPROTO_INET; | ||
2440 | - else if (priv->helper6) | ||
2441 | - family = NFPROTO_IPV6; | ||
2442 | - else | ||
2443 | - family = NFPROTO_IPV4; | ||
2444 | - | ||
2445 | if (nla_put_be16(skb, NFTA_CT_HELPER_L3PROTO, htons(family))) | ||
2446 | return -1; | ||
2447 |