Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 's390-5.8-2' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux
Pull s390 fixes from Vasily Gorbik:
- a few ptrace fixes mostly for strace and seccomp_bpf kernel tests
findings
- cleanup unused pm callbacks in virtio ccw
- replace kmalloc + memset with kzalloc in crypto
- use $(LD) for vDSO linkage to make clang happy
- fix vDSO clock_getres() to preserve the same behaviour as
posix_get_hrtimer_res()
- fix workqueue cpumask warning when NUMA=n and nr_node_ids=2
- reduce SLSB writes during input processing, improve warnings and
cleanup qdio_data usage in qdio
- a few fixes to use scnprintf() instead of snprintf()
* tag 's390-5.8-2' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux:
s390: fix syscall_get_error for compat processes
s390/qdio: warn about unexpected SLSB states
s390/qdio: clean up usage of qdio_data
s390/numa: let NODES_SHIFT depend on NEED_MULTIPLE_NODES
s390/vdso: fix vDSO clock_getres()
s390/vdso: Use $(LD) instead of $(CC) to link vDSO
s390/protvirt: use scnprintf() instead of snprintf()
s390: use scnprintf() in sys_##_prefix##_##_name##_show
s390/crypto: use scnprintf() instead of snprintf()
s390/zcrypt: use kzalloc
s390/virtio: remove unused pm callbacks
s390/qdio: reduce SLSB writes during Input Queue processing
selftests/seccomp: s390 shares the syscall and return value register
s390/ptrace: fix setting syscall number
s390/ptrace: pass invalid syscall numbers to tracing
s390/ptrace: return -ENOSYS when invalid syscall is supplied
s390/seccomp: pass syscall arguments via seccomp_data
s390/qdio: fine-tune SLSB update
+154
-134
+1
arch/s390/Kconfig
+1
arch/s390/Kconfig
+7
-7
arch/s390/crypto/prng.c
+7
-7
arch/s390/crypto/prng.c
···
693
693
struct device_attribute *attr,
694
694
char *buf)
695
695
{
696
-
return snprintf(buf, PAGE_SIZE, "%u\n", prng_chunk_size);
696
+
return scnprintf(buf, PAGE_SIZE, "%u\n", prng_chunk_size);
697
697
}
698
698
static DEVICE_ATTR(chunksize, 0444, prng_chunksize_show, NULL);
699
699
···
712
712
counter = prng_data->prngws.byte_counter;
713
713
mutex_unlock(&prng_data->mutex);
714
714
715
-
return snprintf(buf, PAGE_SIZE, "%llu\n", counter);
715
+
return scnprintf(buf, PAGE_SIZE, "%llu\n", counter);
716
716
}
717
717
static DEVICE_ATTR(byte_counter, 0444, prng_counter_show, NULL);
718
718
···
721
721
struct device_attribute *attr,
722
722
char *buf)
723
723
{
724
-
return snprintf(buf, PAGE_SIZE, "%d\n", prng_errorflag);
724
+
return scnprintf(buf, PAGE_SIZE, "%d\n", prng_errorflag);
725
725
}
726
726
static DEVICE_ATTR(errorflag, 0444, prng_errorflag_show, NULL);
727
727
···
731
731
char *buf)
732
732
{
733
733
if (prng_mode == PRNG_MODE_TDES)
734
-
return snprintf(buf, PAGE_SIZE, "TDES\n");
734
+
return scnprintf(buf, PAGE_SIZE, "TDES\n");
735
735
else
736
-
return snprintf(buf, PAGE_SIZE, "SHA512\n");
736
+
return scnprintf(buf, PAGE_SIZE, "SHA512\n");
737
737
}
738
738
static DEVICE_ATTR(mode, 0444, prng_mode_show, NULL);
739
739
···
756
756
struct device_attribute *attr,
757
757
char *buf)
758
758
{
759
-
return snprintf(buf, PAGE_SIZE, "%u\n", prng_reseed_limit);
759
+
return scnprintf(buf, PAGE_SIZE, "%u\n", prng_reseed_limit);
760
760
}
761
761
static ssize_t prng_reseed_limit_store(struct device *dev,
762
762
struct device_attribute *attr,
···
787
787
struct device_attribute *attr,
788
788
char *buf)
789
789
{
790
-
return snprintf(buf, PAGE_SIZE, "256\n");
790
+
return scnprintf(buf, PAGE_SIZE, "256\n");
791
791
}
792
792
static DEVICE_ATTR(strength, 0444, prng_strength_show, NULL);
793
793
+11
-1
arch/s390/include/asm/syscall.h
+11
-1
arch/s390/include/asm/syscall.h
···
33
33
static inline long syscall_get_error(struct task_struct *task,
34
34
struct pt_regs *regs)
35
35
{
36
-
return IS_ERR_VALUE(regs->gprs[2]) ? regs->gprs[2] : 0;
36
+
unsigned long error = regs->gprs[2];
37
+
#ifdef CONFIG_COMPAT
38
+
if (test_tsk_thread_flag(task, TIF_31BIT)) {
39
+
/*
40
+
* Sign-extend the value so (int)-EFOO becomes (long)-EFOO
41
+
* and will match correctly in comparisons.
42
+
*/
43
+
error = (long)(int)error;
44
+
}
45
+
#endif
46
+
return IS_ERR_VALUE(error) ? error : 0;
37
47
}
38
48
39
49
static inline long syscall_get_return_value(struct task_struct *task,
+1
arch/s390/include/asm/vdso.h
+1
arch/s390/include/asm/vdso.h
+1
-1
arch/s390/kernel/asm-offsets.c
+1
-1
arch/s390/kernel/asm-offsets.c
···
76
76
OFFSET(__VDSO_TK_SHIFT, vdso_data, tk_shift);
77
77
OFFSET(__VDSO_TS_DIR, vdso_data, ts_dir);
78
78
OFFSET(__VDSO_TS_END, vdso_data, ts_end);
79
+
OFFSET(__VDSO_CLOCK_REALTIME_RES, vdso_data, hrtimer_res);
79
80
OFFSET(__VDSO_ECTG_BASE, vdso_per_cpu_data, ectg_timer_base);
80
81
OFFSET(__VDSO_ECTG_USER, vdso_per_cpu_data, ectg_user_time);
81
82
OFFSET(__VDSO_GETCPU_VAL, vdso_per_cpu_data, getcpu_val);
···
87
86
DEFINE(__CLOCK_REALTIME_COARSE, CLOCK_REALTIME_COARSE);
88
87
DEFINE(__CLOCK_MONOTONIC_COARSE, CLOCK_MONOTONIC_COARSE);
89
88
DEFINE(__CLOCK_THREAD_CPUTIME_ID, CLOCK_THREAD_CPUTIME_ID);
90
-
DEFINE(__CLOCK_REALTIME_RES, MONOTONIC_RES_NSEC);
91
89
DEFINE(__CLOCK_COARSE_RES, LOW_RES_NSEC);
92
90
BLANK();
93
91
/* idle data offsets */
+1
-1
arch/s390/kernel/entry.S
+1
-1
arch/s390/kernel/entry.S
···
401
401
jnz .Lsysc_nr_ok
402
402
# svc 0: system call number in %r1
403
403
llgfr %r1,%r1 # clear high word in r1
404
+
sth %r1,__PT_INT_CODE+2(%r11)
404
405
cghi %r1,NR_syscalls
405
406
jnl .Lsysc_nr_ok
406
-
sth %r1,__PT_INT_CODE+2(%r11)
407
407
slag %r8,%r1,3
408
408
.Lsysc_nr_ok:
409
409
xc __SF_BACKCHAIN(8,%r15),__SF_BACKCHAIN(%r15)
+1
-1
arch/s390/kernel/ipl.c
+1
-1
arch/s390/kernel/ipl.c
+69
-14
arch/s390/kernel/ptrace.c
+69
-14
arch/s390/kernel/ptrace.c
···
323
323
child->thread.per_user.end = data;
324
324
}
325
325
326
+
static void fixup_int_code(struct task_struct *child, addr_t data)
327
+
{
328
+
struct pt_regs *regs = task_pt_regs(child);
329
+
int ilc = regs->int_code >> 16;
330
+
u16 insn;
331
+
332
+
if (ilc > 6)
333
+
return;
334
+
335
+
if (ptrace_access_vm(child, regs->psw.addr - (regs->int_code >> 16),
336
+
&insn, sizeof(insn), FOLL_FORCE) != sizeof(insn))
337
+
return;
338
+
339
+
/* double check that tracee stopped on svc instruction */
340
+
if ((insn >> 8) != 0xa)
341
+
return;
342
+
343
+
regs->int_code = 0x20000 | (data & 0xffff);
344
+
}
326
345
/*
327
346
* Write a word to the user area of a process at location addr. This
328
347
* operation does have an additional problem compared to peek_user.
···
353
334
struct user *dummy = NULL;
354
335
addr_t offset;
355
336
337
+
356
338
if (addr < (addr_t) &dummy->regs.acrs) {
339
+
struct pt_regs *regs = task_pt_regs(child);
357
340
/*
358
341
* psw and gprs are stored on the stack
359
342
*/
···
373
352
/* Invalid addressing mode bits */
374
353
return -EINVAL;
375
354
}
376
-
*(addr_t *)((addr_t) &task_pt_regs(child)->psw + addr) = data;
355
+
356
+
if (test_pt_regs_flag(regs, PIF_SYSCALL) &&
357
+
addr == offsetof(struct user, regs.gprs[2]))
358
+
fixup_int_code(child, data);
359
+
*(addr_t *)((addr_t) ®s->psw + addr) = data;
377
360
378
361
} else if (addr < (addr_t) (&dummy->regs.orig_gpr2)) {
379
362
/*
···
743
718
regs->psw.mask = (regs->psw.mask & ~PSW_MASK_BA) |
744
719
(__u64)(tmp & PSW32_ADDR_AMODE);
745
720
} else {
721
+
722
+
if (test_pt_regs_flag(regs, PIF_SYSCALL) &&
723
+
addr == offsetof(struct compat_user, regs.gprs[2]))
724
+
fixup_int_code(child, data);
746
725
/* gpr 0-15 */
747
726
*(__u32*)((addr_t) ®s->psw + addr*2 + 4) = tmp;
748
727
}
···
866
837
asmlinkage long do_syscall_trace_enter(struct pt_regs *regs)
867
838
{
868
839
unsigned long mask = -1UL;
840
+
long ret = -1;
841
+
842
+
if (is_compat_task())
843
+
mask = 0xffffffff;
869
844
870
845
/*
871
846
* The sysc_tracesys code in entry.S stored the system
872
847
* call number to gprs[2].
873
848
*/
874
849
if (test_thread_flag(TIF_SYSCALL_TRACE) &&
875
-
(tracehook_report_syscall_entry(regs) ||
876
-
regs->gprs[2] >= NR_syscalls)) {
850
+
tracehook_report_syscall_entry(regs)) {
877
851
/*
878
-
* Tracing decided this syscall should not happen or the
879
-
* debugger stored an invalid system call number. Skip
852
+
* Tracing decided this syscall should not happen. Skip
880
853
* the system call and the system call restart handling.
881
854
*/
882
-
clear_pt_regs_flag(regs, PIF_SYSCALL);
883
-
return -1;
855
+
goto skip;
884
856
}
885
857
858
+
#ifdef CONFIG_SECCOMP
886
859
/* Do the secure computing check after ptrace. */
887
-
if (secure_computing()) {
888
-
/* seccomp failures shouldn't expose any additional code. */
889
-
return -1;
860
+
if (unlikely(test_thread_flag(TIF_SECCOMP))) {
861
+
struct seccomp_data sd;
862
+
863
+
if (is_compat_task()) {
864
+
sd.instruction_pointer = regs->psw.addr & 0x7fffffff;
865
+
sd.arch = AUDIT_ARCH_S390;
866
+
} else {
867
+
sd.instruction_pointer = regs->psw.addr;
868
+
sd.arch = AUDIT_ARCH_S390X;
869
+
}
870
+
871
+
sd.nr = regs->int_code & 0xffff;
872
+
sd.args[0] = regs->orig_gpr2 & mask;
873
+
sd.args[1] = regs->gprs[3] & mask;
874
+
sd.args[2] = regs->gprs[4] & mask;
875
+
sd.args[3] = regs->gprs[5] & mask;
876
+
sd.args[4] = regs->gprs[6] & mask;
877
+
sd.args[5] = regs->gprs[7] & mask;
878
+
879
+
if (__secure_computing(&sd) == -1)
880
+
goto skip;
890
881
}
882
+
#endif /* CONFIG_SECCOMP */
891
883
892
884
if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
893
-
trace_sys_enter(regs, regs->gprs[2]);
885
+
trace_sys_enter(regs, regs->int_code & 0xffff);
894
886
895
-
if (is_compat_task())
896
-
mask = 0xffffffff;
897
887
898
-
audit_syscall_entry(regs->gprs[2], regs->orig_gpr2 & mask,
888
+
audit_syscall_entry(regs->int_code & 0xffff, regs->orig_gpr2 & mask,
899
889
regs->gprs[3] &mask, regs->gprs[4] &mask,
900
890
regs->gprs[5] &mask);
901
891
892
+
if ((signed long)regs->gprs[2] >= NR_syscalls) {
893
+
regs->gprs[2] = -ENOSYS;
894
+
ret = -ENOSYS;
895
+
}
902
896
return regs->gprs[2];
897
+
skip:
898
+
clear_pt_regs_flag(regs, PIF_SYSCALL);
899
+
return ret;
903
900
}
904
901
905
902
asmlinkage void do_syscall_trace_exit(struct pt_regs *regs)
+1
arch/s390/kernel/time.c
+1
arch/s390/kernel/time.c
+4
-4
arch/s390/kernel/uv.c
+4
-4
arch/s390/kernel/uv.c
···
331
331
static ssize_t uv_query_facilities(struct kobject *kobj,
332
332
struct kobj_attribute *attr, char *page)
333
333
{
334
-
return snprintf(page, PAGE_SIZE, "%lx\n%lx\n%lx\n%lx\n",
334
+
return scnprintf(page, PAGE_SIZE, "%lx\n%lx\n%lx\n%lx\n",
335
335
uv_info.inst_calls_list[0],
336
336
uv_info.inst_calls_list[1],
337
337
uv_info.inst_calls_list[2],
···
344
344
static ssize_t uv_query_max_guest_cpus(struct kobject *kobj,
345
345
struct kobj_attribute *attr, char *page)
346
346
{
347
-
return snprintf(page, PAGE_SIZE, "%d\n",
347
+
return scnprintf(page, PAGE_SIZE, "%d\n",
348
348
uv_info.max_guest_cpus);
349
349
}
350
350
···
354
354
static ssize_t uv_query_max_guest_vms(struct kobject *kobj,
355
355
struct kobj_attribute *attr, char *page)
356
356
{
357
-
return snprintf(page, PAGE_SIZE, "%d\n",
357
+
return scnprintf(page, PAGE_SIZE, "%d\n",
358
358
uv_info.max_num_sec_conf);
359
359
}
360
360
···
364
364
static ssize_t uv_query_max_guest_addr(struct kobject *kobj,
365
365
struct kobj_attribute *attr, char *page)
366
366
{
367
-
return snprintf(page, PAGE_SIZE, "%lx\n",
367
+
return scnprintf(page, PAGE_SIZE, "%lx\n",
368
368
uv_info.max_sec_stor_addr);
369
369
}
370
370
+4
-6
arch/s390/kernel/vdso64/Makefile
+4
-6
arch/s390/kernel/vdso64/Makefile
···
18
18
19
19
KBUILD_CFLAGS_64 := $(filter-out -m64,$(KBUILD_CFLAGS))
20
20
KBUILD_CFLAGS_64 += -m64 -fPIC -shared -fno-common -fno-builtin
21
-
KBUILD_CFLAGS_64 += -nostdlib -Wl,-soname=linux-vdso64.so.1 \
22
-
-Wl,--hash-style=both
21
+
ldflags-y := -fPIC -shared -nostdlib -soname=linux-vdso64.so.1 \
22
+
--hash-style=both --build-id -T
23
23
24
24
$(targets:%=$(obj)/%.dbg): KBUILD_CFLAGS = $(KBUILD_CFLAGS_64)
25
25
$(targets:%=$(obj)/%.dbg): KBUILD_AFLAGS = $(KBUILD_AFLAGS_64)
···
37
37
$(obj)/vdso64_wrapper.o : $(obj)/vdso64.so
38
38
39
39
# link rule for the .so file, .lds has to be first
40
-
$(obj)/vdso64.so.dbg: $(src)/vdso64.lds $(obj-vdso64) FORCE
41
-
$(call if_changed,vdso64ld)
40
+
$(obj)/vdso64.so.dbg: $(obj)/vdso64.lds $(obj-vdso64) FORCE
41
+
$(call if_changed,ld)
42
42
43
43
# strip rule for the .so file
44
44
$(obj)/%.so: OBJCOPYFLAGS := -S
···
50
50
$(call if_changed_dep,vdso64as)
51
51
52
52
# actual build commands
53
-
quiet_cmd_vdso64ld = VDSO64L $@
54
-
cmd_vdso64ld = $(CC) $(c_flags) -Wl,-T $(filter %.lds %.o,$^) -o $@
55
53
quiet_cmd_vdso64as = VDSO64A $@
56
54
cmd_vdso64as = $(CC) $(a_flags) -c -o $@ $<
57
55
+5
-5
arch/s390/kernel/vdso64/clock_getres.S
+5
-5
arch/s390/kernel/vdso64/clock_getres.S
···
17
17
.type __kernel_clock_getres,@function
18
18
__kernel_clock_getres:
19
19
CFI_STARTPROC
20
-
larl %r1,4f
20
+
larl %r1,3f
21
+
lg %r0,0(%r1)
21
22
cghi %r2,__CLOCK_REALTIME_COARSE
22
23
je 0f
23
24
cghi %r2,__CLOCK_MONOTONIC_COARSE
24
25
je 0f
25
-
larl %r1,3f
26
+
larl %r1,_vdso_data
27
+
llgf %r0,__VDSO_CLOCK_REALTIME_RES(%r1)
26
28
cghi %r2,__CLOCK_REALTIME
27
29
je 0f
28
30
cghi %r2,__CLOCK_MONOTONIC
···
38
36
jz 2f
39
37
0: ltgr %r3,%r3
40
38
jz 1f /* res == NULL */
41
-
lg %r0,0(%r1)
42
39
xc 0(8,%r3),0(%r3) /* set tp->tv_sec to zero */
43
40
stg %r0,8(%r3) /* store tp->tv_usec */
44
41
1: lghi %r2,0
···
46
45
svc 0
47
46
br %r14
48
47
CFI_ENDPROC
49
-
3: .quad __CLOCK_REALTIME_RES
50
-
4: .quad __CLOCK_COARSE_RES
48
+
3: .quad __CLOCK_COARSE_RES
51
49
.size __kernel_clock_getres,.-__kernel_clock_getres
+3
-4
drivers/s390/cio/qdio.h
+3
-4
drivers/s390/cio/qdio.h
···
182
182
};
183
183
184
184
struct qdio_input_q {
185
-
/* first ACK'ed buffer */
186
-
int ack_start;
187
-
/* how many SBALs are acknowledged */
188
-
int ack_count;
185
+
/* Batch of SBALs that we processed while polling the queue: */
186
+
unsigned int batch_start;
187
+
unsigned int batch_count;
189
188
/* last time of noticing incoming data */
190
189
u64 timestamp;
191
190
};
+2
-2
drivers/s390/cio/qdio_debug.c
+2
-2
drivers/s390/cio/qdio_debug.c
···
110
110
seq_printf(m, "nr_used: %d ftc: %d\n",
111
111
atomic_read(&q->nr_buf_used), q->first_to_check);
112
112
if (q->is_input_q) {
113
-
seq_printf(m, "ack start: %d ack count: %d\n",
114
-
q->u.in.ack_start, q->u.in.ack_count);
113
+
seq_printf(m, "batch start: %u batch count: %u\n",
114
+
q->u.in.batch_start, q->u.in.batch_count);
115
115
seq_printf(m, "DSCI: %x IRQs disabled: %u\n",
116
116
*(u8 *)q->irq_ptr->dsci,
117
117
test_bit(QDIO_IRQ_DISABLED,
+41
-60
drivers/s390/cio/qdio_main.c
+41
-60
drivers/s390/cio/qdio_main.c
···
254
254
if (is_qebsm(q))
255
255
return qdio_do_sqbs(q, state, bufnr, count);
256
256
257
+
/* Ensure that all preceding changes to the SBALs are visible: */
258
+
mb();
259
+
257
260
for (i = 0; i < count; i++) {
258
-
xchg(&q->slsb.val[bufnr], state);
261
+
WRITE_ONCE(q->slsb.val[bufnr], state);
259
262
bufnr = next_buf(bufnr);
260
263
}
264
+
265
+
/* Make our SLSB changes visible: */
266
+
mb();
267
+
261
268
return count;
262
269
}
263
270
···
400
393
401
394
static inline void qdio_stop_polling(struct qdio_q *q)
402
395
{
403
-
if (!q->u.in.ack_count)
396
+
if (!q->u.in.batch_count)
404
397
return;
405
398
406
399
qperf_inc(q, stop_polling);
407
400
408
401
/* show the card that we are not polling anymore */
409
-
set_buf_states(q, q->u.in.ack_start, SLSB_P_INPUT_NOT_INIT,
410
-
q->u.in.ack_count);
411
-
q->u.in.ack_count = 0;
402
+
set_buf_states(q, q->u.in.batch_start, SLSB_P_INPUT_NOT_INIT,
403
+
q->u.in.batch_count);
404
+
q->u.in.batch_count = 0;
412
405
}
413
406
414
407
static inline void account_sbals(struct qdio_q *q, unsigned int count)
···
448
441
static inline void inbound_handle_work(struct qdio_q *q, unsigned int start,
449
442
int count, bool auto_ack)
450
443
{
451
-
int new;
444
+
/* ACK the newest SBAL: */
445
+
if (!auto_ack)
446
+
set_buf_state(q, add_buf(start, count - 1), SLSB_P_INPUT_ACK);
452
447
453
-
if (auto_ack) {
454
-
if (!q->u.in.ack_count) {
455
-
q->u.in.ack_count = count;
456
-
q->u.in.ack_start = start;
457
-
return;
458
-
}
459
-
460
-
/* delete the previous ACK's */
461
-
set_buf_states(q, q->u.in.ack_start, SLSB_P_INPUT_NOT_INIT,
462
-
q->u.in.ack_count);
463
-
q->u.in.ack_count = count;
464
-
q->u.in.ack_start = start;
465
-
return;
466
-
}
467
-
468
-
/*
469
-
* ACK the newest buffer. The ACK will be removed in qdio_stop_polling
470
-
* or by the next inbound run.
471
-
*/
472
-
new = add_buf(start, count - 1);
473
-
set_buf_state(q, new, SLSB_P_INPUT_ACK);
474
-
475
-
/* delete the previous ACKs */
476
-
if (q->u.in.ack_count)
477
-
set_buf_states(q, q->u.in.ack_start, SLSB_P_INPUT_NOT_INIT,
478
-
q->u.in.ack_count);
479
-
480
-
q->u.in.ack_count = 1;
481
-
q->u.in.ack_start = new;
482
-
count--;
483
-
if (!count)
484
-
return;
485
-
/* need to change ALL buffers to get more interrupts */
486
-
set_buf_states(q, start, SLSB_P_INPUT_NOT_INIT, count);
448
+
if (!q->u.in.batch_count)
449
+
q->u.in.batch_start = start;
450
+
q->u.in.batch_count += count;
487
451
}
488
452
489
453
static int get_inbound_buffer_frontier(struct qdio_q *q, unsigned int start)
···
503
525
account_sbals_error(q, count);
504
526
return count;
505
527
case SLSB_CU_INPUT_EMPTY:
506
-
case SLSB_P_INPUT_NOT_INIT:
507
-
case SLSB_P_INPUT_ACK:
508
528
if (q->irq_ptr->perf_stat_enabled)
509
529
q->q_stats.nr_sbal_nop++;
510
530
DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "in nop:%1d %#02x",
511
531
q->nr, start);
512
532
return 0;
533
+
case SLSB_P_INPUT_NOT_INIT:
534
+
case SLSB_P_INPUT_ACK:
535
+
/* We should never see this state, throw a WARN: */
513
536
default:
514
-
WARN_ON_ONCE(1);
537
+
dev_WARN_ONCE(&q->irq_ptr->cdev->dev, 1,
538
+
"found state %#x at index %u on queue %u\n",
539
+
state, start, q->nr);
515
540
return 0;
516
541
}
517
542
}
···
719
738
DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "out primed:%1d",
720
739
q->nr);
721
740
return 0;
722
-
case SLSB_P_OUTPUT_NOT_INIT:
723
741
case SLSB_P_OUTPUT_HALTED:
724
742
return 0;
743
+
case SLSB_P_OUTPUT_NOT_INIT:
744
+
/* We should never see this state, throw a WARN: */
725
745
default:
726
-
WARN_ON_ONCE(1);
746
+
dev_WARN_ONCE(&q->irq_ptr->cdev->dev, 1,
747
+
"found state %#x at index %u on queue %u\n",
748
+
state, start, q->nr);
727
749
return 0;
728
750
}
729
751
}
···
922
938
}
923
939
}
924
940
925
-
static void qdio_handle_activate_check(struct ccw_device *cdev,
926
-
unsigned long intparm, int cstat, int dstat)
941
+
static void qdio_handle_activate_check(struct qdio_irq *irq_ptr,
942
+
unsigned long intparm, int cstat,
943
+
int dstat)
927
944
{
928
-
struct qdio_irq *irq_ptr = cdev->private->qdio_data;
929
945
struct qdio_q *q;
930
946
931
947
DBF_ERROR("%4x ACT CHECK", irq_ptr->schid.sch_no);
···
952
968
lgr_info_log();
953
969
}
954
970
955
-
static void qdio_establish_handle_irq(struct ccw_device *cdev, int cstat,
971
+
static void qdio_establish_handle_irq(struct qdio_irq *irq_ptr, int cstat,
956
972
int dstat)
957
973
{
958
-
struct qdio_irq *irq_ptr = cdev->private->qdio_data;
959
-
960
974
DBF_DEV_EVENT(DBF_INFO, irq_ptr, "qest irq");
961
975
962
976
if (cstat)
···
1001
1019
1002
1020
switch (irq_ptr->state) {
1003
1021
case QDIO_IRQ_STATE_INACTIVE:
1004
-
qdio_establish_handle_irq(cdev, cstat, dstat);
1022
+
qdio_establish_handle_irq(irq_ptr, cstat, dstat);
1005
1023
break;
1006
1024
case QDIO_IRQ_STATE_CLEANUP:
1007
1025
qdio_set_state(irq_ptr, QDIO_IRQ_STATE_INACTIVE);
···
1013
1031
return;
1014
1032
}
1015
1033
if (cstat || dstat)
1016
-
qdio_handle_activate_check(cdev, intparm, cstat,
1034
+
qdio_handle_activate_check(irq_ptr, intparm, cstat,
1017
1035
dstat);
1018
1036
break;
1019
1037
case QDIO_IRQ_STATE_STOPPED:
···
1428
1446
1429
1447
qperf_inc(q, inbound_call);
1430
1448
1431
-
/* If any ACKed SBALs are returned to HW, adjust ACK tracking: */
1432
-
overlap = min(count - sub_buf(q->u.in.ack_start, bufnr),
1433
-
q->u.in.ack_count);
1449
+
/* If any processed SBALs are returned to HW, adjust our tracking: */
1450
+
overlap = min_t(int, count - sub_buf(q->u.in.batch_start, bufnr),
1451
+
q->u.in.batch_count);
1434
1452
if (overlap > 0) {
1435
-
q->u.in.ack_start = add_buf(q->u.in.ack_start, overlap);
1436
-
q->u.in.ack_count -= overlap;
1453
+
q->u.in.batch_start = add_buf(q->u.in.batch_start, overlap);
1454
+
q->u.in.batch_count -= overlap;
1437
1455
}
1438
1456
1439
1457
count = set_buf_states(q, bufnr, SLSB_CU_INPUT_EMPTY, count);
···
1517
1535
int do_QDIO(struct ccw_device *cdev, unsigned int callflags,
1518
1536
int q_nr, unsigned int bufnr, unsigned int count)
1519
1537
{
1520
-
struct qdio_irq *irq_ptr;
1538
+
struct qdio_irq *irq_ptr = cdev->private->qdio_data;
1521
1539
1522
1540
if (bufnr >= QDIO_MAX_BUFFERS_PER_Q || count > QDIO_MAX_BUFFERS_PER_Q)
1523
1541
return -EINVAL;
1524
1542
1525
-
irq_ptr = cdev->private->qdio_data;
1526
1543
if (!irq_ptr)
1527
1544
return -ENODEV;
1528
1545
+1
-2
drivers/s390/crypto/zcrypt_ep11misc.c
+1
-2
drivers/s390/crypto/zcrypt_ep11misc.c
···
195
195
size_t len = sizeof(struct ep11_cprb) + payload_len;
196
196
struct ep11_cprb *cprb;
197
197
198
-
cprb = kmalloc(len, GFP_KERNEL);
198
+
cprb = kzalloc(len, GFP_KERNEL);
199
199
if (!cprb)
200
200
return NULL;
201
201
202
-
memset(cprb, 0, len);
203
202
cprb->cprb_len = sizeof(struct ep11_cprb);
204
203
cprb->cprb_ver_id = 0x04;
205
204
memcpy(cprb->func_id, "T4", 2);
-26
drivers/s390/virtio/virtio_ccw.c
-26
drivers/s390/virtio/virtio_ccw.c
···
1372
1372
{},
1373
1373
};
1374
1374
1375
-
#ifdef CONFIG_PM_SLEEP
1376
-
static int virtio_ccw_freeze(struct ccw_device *cdev)
1377
-
{
1378
-
struct virtio_ccw_device *vcdev = dev_get_drvdata(&cdev->dev);
1379
-
1380
-
return virtio_device_freeze(&vcdev->vdev);
1381
-
}
1382
-
1383
-
static int virtio_ccw_restore(struct ccw_device *cdev)
1384
-
{
1385
-
struct virtio_ccw_device *vcdev = dev_get_drvdata(&cdev->dev);
1386
-
int ret;
1387
-
1388
-
ret = virtio_ccw_set_transport_rev(vcdev);
1389
-
if (ret)
1390
-
return ret;
1391
-
1392
-
return virtio_device_restore(&vcdev->vdev);
1393
-
}
1394
-
#endif
1395
-
1396
1375
static struct ccw_driver virtio_ccw_driver = {
1397
1376
.driver = {
1398
1377
.owner = THIS_MODULE,
···
1384
1405
.set_online = virtio_ccw_online,
1385
1406
.notify = virtio_ccw_cio_notify,
1386
1407
.int_class = IRQIO_VIR,
1387
-
#ifdef CONFIG_PM_SLEEP
1388
-
.freeze = virtio_ccw_freeze,
1389
-
.thaw = virtio_ccw_restore,
1390
-
.restore = virtio_ccw_restore,
1391
-
#endif
1392
1408
};
1393
1409
1394
1410
static int __init pure_hex(char **cp, unsigned int *val, int min_digit,
+1
tools/testing/selftests/seccomp/seccomp_bpf.c
+1
tools/testing/selftests/seccomp/seccomp_bpf.c