Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux
Pull second set of s390 patches from Martin Schwidefsky:
"The main part of this merge are Heikos uaccess patches. Together with
commit 09884964335e ("mm: do not grow the stack vma just because of an
overrun on preceding vma") the user string access is hopefully fixed
for good.
In addition some bug fixes and two cleanup patches."
* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux:
s390/module: fix compile warning
qdio: remove unused parameters
s390/uaccess: fix kernel ds access for page table walk
s390/uaccess: fix strncpy_from_user string length check
input: disable i8042 PC Keyboard controller for s390
s390/dis: Fix invalid array size
s390/uaccess: remove pointless access_ok() checks
s390/uaccess: fix strncpy_from_user/strnlen_user zero maxlen case
s390/uaccess: shorten strncpy_from_user/strnlen_user
s390/dasd: fix unresponsive device after all channel paths were lost
s390/mm: ignore change bit for vmemmap
s390/page table dumper: add support for change-recording override bit
+172
-144
-6
arch/s390/include/asm/futex.h
-6
arch/s390/include/asm/futex.h
···
16
16
if (encoded_op & (FUTEX_OP_OPARG_SHIFT << 28))
17
17
oparg = 1 << oparg;
18
18
19
-
if (! access_ok (VERIFY_WRITE, uaddr, sizeof(u32)))
20
-
return -EFAULT;
21
-
22
19
pagefault_disable();
23
20
ret = uaccess.futex_atomic_op(op, uaddr, oparg, &oldval);
24
21
pagefault_enable();
···
37
40
static inline int futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *uaddr,
38
41
u32 oldval, u32 newval)
39
42
{
40
-
if (! access_ok (VERIFY_WRITE, uaddr, sizeof(u32)))
41
-
return -EFAULT;
42
-
43
43
return uaccess.futex_atomic_cmpxchg(uval, uaddr, oldval, newval);
44
44
}
45
45
+2
arch/s390/include/asm/pgtable.h
+2
arch/s390/include/asm/pgtable.h
···
340
340
#define _REGION3_ENTRY_EMPTY (_REGION_ENTRY_TYPE_R3 | _REGION_ENTRY_INV)
341
341
342
342
#define _REGION3_ENTRY_LARGE 0x400 /* RTTE-format control, large page */
343
+
#define _REGION3_ENTRY_RO 0x200 /* page protection bit */
344
+
#define _REGION3_ENTRY_CO 0x100 /* change-recording override */
343
345
344
346
/* Bits in the segment table entry */
345
347
#define _SEGMENT_ENTRY_ORIGIN ~0x7ffUL/* segment table origin */
+5
-18
arch/s390/include/asm/uaccess.h
+5
-18
arch/s390/include/asm/uaccess.h
···
252
252
copy_to_user(void __user *to, const void *from, unsigned long n)
253
253
{
254
254
might_fault();
255
-
if (access_ok(VERIFY_WRITE, to, n))
256
-
n = __copy_to_user(to, from, n);
257
-
return n;
255
+
return __copy_to_user(to, from, n);
258
256
}
259
257
260
258
/**
···
313
315
copy_from_user_overflow();
314
316
return n;
315
317
}
316
-
if (access_ok(VERIFY_READ, from, n))
317
-
n = __copy_from_user(to, from, n);
318
-
else
319
-
memset(to, 0, n);
320
-
return n;
318
+
return __copy_from_user(to, from, n);
321
319
}
322
320
323
321
static inline unsigned long __must_check
···
326
332
copy_in_user(void __user *to, const void __user *from, unsigned long n)
327
333
{
328
334
might_fault();
329
-
if (__access_ok(from,n) && __access_ok(to,n))
330
-
n = __copy_in_user(to, from, n);
331
-
return n;
335
+
return __copy_in_user(to, from, n);
332
336
}
333
337
334
338
/*
···
335
343
static inline long __must_check
336
344
strncpy_from_user(char *dst, const char __user *src, long count)
337
345
{
338
-
long res = -EFAULT;
339
346
might_fault();
340
-
if (access_ok(VERIFY_READ, src, 1))
341
-
res = uaccess.strncpy_from_user(count, src, dst);
342
-
return res;
347
+
return uaccess.strncpy_from_user(count, src, dst);
343
348
}
344
349
345
350
static inline unsigned long
···
376
387
clear_user(void __user *to, unsigned long n)
377
388
{
378
389
might_fault();
379
-
if (access_ok(VERIFY_WRITE, to, n))
380
-
n = uaccess.clear_user(n, to);
381
-
return n;
390
+
return uaccess.clear_user(n, to);
382
391
}
383
392
384
393
extern int copy_to_user_real(void __user *dest, void *src, size_t count);
-14
arch/s390/kernel/compat_signal.c
-14
arch/s390/kernel/compat_signal.c
···
53
53
{
54
54
int err;
55
55
56
-
if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
57
-
return -EFAULT;
58
-
59
56
/* If you change siginfo_t structure, please be sure
60
57
this code is fixed accordingly.
61
58
It should never copy any pad contained in the structure
···
106
109
{
107
110
int err;
108
111
u32 tmp;
109
-
110
-
if (!access_ok (VERIFY_READ, from, sizeof(compat_siginfo_t)))
111
-
return -EFAULT;
112
112
113
113
err = __get_user(to->si_signo, &from->si_signo);
114
114
err |= __get_user(to->si_errno, &from->si_errno);
···
238
244
sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
239
245
sigset_t set;
240
246
241
-
if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
242
-
goto badframe;
243
247
if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
244
248
goto badframe;
245
249
set_current_blocked(&set);
···
257
265
rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
258
266
sigset_t set;
259
267
260
-
if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
261
-
goto badframe;
262
268
if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
263
269
goto badframe;
264
270
set_current_blocked(&set);
···
315
325
sigset_t *set, struct pt_regs * regs)
316
326
{
317
327
sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));
318
-
if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32)))
319
-
goto give_sigsegv;
320
328
321
329
if (frame == (void __user *) -1UL)
322
330
goto give_sigsegv;
···
379
391
{
380
392
int err = 0;
381
393
rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
382
-
if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32)))
383
-
goto give_sigsegv;
384
394
385
395
if (frame == (void __user *) -1UL)
386
396
goto give_sigsegv;
+2
-2
arch/s390/kernel/dis.c
+2
-2
arch/s390/kernel/dis.c
···
1711
1711
if (!insn)
1712
1712
return -ENOENT;
1713
1713
if (insn->name[0] == '\0')
1714
-
snprintf(buf, sizeof(buf), "%s",
1714
+
snprintf(buf, 8, "%s",
1715
1715
long_insn_name[(int) insn->name[1]]);
1716
1716
else
1717
-
snprintf(buf, sizeof(buf), "%.5s", insn->name);
1717
+
snprintf(buf, 8, "%.5s", insn->name);
1718
1718
return 0;
1719
1719
}
1720
1720
EXPORT_SYMBOL_GPL(insn_to_mnemonic);
+1
-1
arch/s390/kernel/module.c
+1
-1
arch/s390/kernel/module.c
-8
arch/s390/kernel/signal.c
-8
arch/s390/kernel/signal.c
···
116
116
sigframe __user *frame = (sigframe __user *)regs->gprs[15];
117
117
sigset_t set;
118
118
119
-
if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
120
-
goto badframe;
121
119
if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE))
122
120
goto badframe;
123
121
set_current_blocked(&set);
···
133
135
rt_sigframe __user *frame = (rt_sigframe __user *)regs->gprs[15];
134
136
sigset_t set;
135
137
136
-
if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
137
-
goto badframe;
138
138
if (__copy_from_user(&set.sig, &frame->uc.uc_sigmask, sizeof(set)))
139
139
goto badframe;
140
140
set_current_blocked(&set);
···
191
195
sigframe __user *frame;
192
196
193
197
frame = get_sigframe(ka, regs, sizeof(sigframe));
194
-
if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe)))
195
-
goto give_sigsegv;
196
198
197
199
if (frame == (void __user *) -1UL)
198
200
goto give_sigsegv;
···
258
264
rt_sigframe __user *frame;
259
265
260
266
frame = get_sigframe(ka, regs, sizeof(rt_sigframe));
261
-
if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe)))
262
-
goto give_sigsegv;
263
267
264
268
if (frame == (void __user *) -1UL)
265
269
goto give_sigsegv;
+14
-12
arch/s390/lib/uaccess_mvcos.c
+14
-12
arch/s390/lib/uaccess_mvcos.c
···
162
162
163
163
static size_t strnlen_user_mvcos(size_t count, const char __user *src)
164
164
{
165
+
size_t done, len, offset, len_str;
165
166
char buf[256];
166
-
int rc;
167
-
size_t done, len, len_str;
168
167
169
168
done = 0;
170
169
do {
171
-
len = min(count - done, (size_t) 256);
172
-
rc = uaccess.copy_from_user(len, src + done, buf);
173
-
if (unlikely(rc == len))
170
+
offset = (size_t)src & ~PAGE_MASK;
171
+
len = min(256UL, PAGE_SIZE - offset);
172
+
len = min(count - done, len);
173
+
if (copy_from_user_mvcos(len, src, buf))
174
174
return 0;
175
-
len -= rc;
176
175
len_str = strnlen(buf, len);
177
176
done += len_str;
177
+
src += len_str;
178
178
} while ((len_str == len) && (done < count));
179
179
return done + 1;
180
180
}
···
182
182
static size_t strncpy_from_user_mvcos(size_t count, const char __user *src,
183
183
char *dst)
184
184
{
185
-
int rc;
186
-
size_t done, len, len_str;
185
+
size_t done, len, offset, len_str;
187
186
187
+
if (unlikely(!count))
188
+
return 0;
188
189
done = 0;
189
190
do {
190
-
len = min(count - done, (size_t) 4096);
191
-
rc = uaccess.copy_from_user(len, src + done, dst);
192
-
if (unlikely(rc == len))
191
+
offset = (size_t)src & ~PAGE_MASK;
192
+
len = min(count - done, PAGE_SIZE - offset);
193
+
if (copy_from_user_mvcos(len, src, dst))
193
194
return -EFAULT;
194
-
len -= rc;
195
195
len_str = strnlen(dst, len);
196
196
done += len_str;
197
+
src += len_str;
198
+
dst += len_str;
197
199
} while ((len_str == len) && (done < count));
198
200
return done;
199
201
}
+92
-37
arch/s390/lib/uaccess_pt.c
+92
-37
arch/s390/lib/uaccess_pt.c
···
14
14
#include <asm/futex.h>
15
15
#include "uaccess.h"
16
16
17
+
#ifndef CONFIG_64BIT
18
+
#define AHI "ahi"
19
+
#define SLR "slr"
20
+
#else
21
+
#define AHI "aghi"
22
+
#define SLR "slgr"
23
+
#endif
24
+
25
+
static size_t strnlen_kernel(size_t count, const char __user *src)
26
+
{
27
+
register unsigned long reg0 asm("0") = 0UL;
28
+
unsigned long tmp1, tmp2;
29
+
30
+
asm volatile(
31
+
" la %2,0(%1)\n"
32
+
" la %3,0(%0,%1)\n"
33
+
" "SLR" %0,%0\n"
34
+
"0: srst %3,%2\n"
35
+
" jo 0b\n"
36
+
" la %0,1(%3)\n" /* strnlen_kernel results includes \0 */
37
+
" "SLR" %0,%1\n"
38
+
"1:\n"
39
+
EX_TABLE(0b,1b)
40
+
: "+a" (count), "+a" (src), "=a" (tmp1), "=a" (tmp2)
41
+
: "d" (reg0) : "cc", "memory");
42
+
return count;
43
+
}
44
+
45
+
static size_t copy_in_kernel(size_t count, void __user *to,
46
+
const void __user *from)
47
+
{
48
+
unsigned long tmp1;
49
+
50
+
asm volatile(
51
+
" "AHI" %0,-1\n"
52
+
" jo 5f\n"
53
+
" bras %3,3f\n"
54
+
"0:"AHI" %0,257\n"
55
+
"1: mvc 0(1,%1),0(%2)\n"
56
+
" la %1,1(%1)\n"
57
+
" la %2,1(%2)\n"
58
+
" "AHI" %0,-1\n"
59
+
" jnz 1b\n"
60
+
" j 5f\n"
61
+
"2: mvc 0(256,%1),0(%2)\n"
62
+
" la %1,256(%1)\n"
63
+
" la %2,256(%2)\n"
64
+
"3:"AHI" %0,-256\n"
65
+
" jnm 2b\n"
66
+
"4: ex %0,1b-0b(%3)\n"
67
+
"5:"SLR" %0,%0\n"
68
+
"6:\n"
69
+
EX_TABLE(1b,6b) EX_TABLE(2b,0b) EX_TABLE(4b,0b)
70
+
: "+a" (count), "+a" (to), "+a" (from), "=a" (tmp1)
71
+
: : "cc", "memory");
72
+
return count;
73
+
}
17
74
18
75
/*
19
76
* Returns kernel address for user virtual address. If the returned address is
···
180
123
{
181
124
size_t rc;
182
125
183
-
if (segment_eq(get_fs(), KERNEL_DS)) {
184
-
memcpy(to, (void __kernel __force *) from, n);
185
-
return 0;
186
-
}
126
+
if (segment_eq(get_fs(), KERNEL_DS))
127
+
return copy_in_kernel(n, (void __user *) to, from);
187
128
rc = __user_copy_pt((unsigned long) from, to, n, 0);
188
129
if (unlikely(rc))
189
130
memset(to + n - rc, 0, rc);
···
190
135
191
136
size_t copy_to_user_pt(size_t n, void __user *to, const void *from)
192
137
{
193
-
if (segment_eq(get_fs(), KERNEL_DS)) {
194
-
memcpy((void __kernel __force *) to, from, n);
195
-
return 0;
196
-
}
138
+
if (segment_eq(get_fs(), KERNEL_DS))
139
+
return copy_in_kernel(n, to, (void __user *) from);
197
140
return __user_copy_pt((unsigned long) to, (void *) from, n, 1);
198
141
}
199
142
200
143
static size_t clear_user_pt(size_t n, void __user *to)
201
144
{
145
+
void *zpage = &empty_zero_page;
202
146
long done, size, ret;
203
147
204
-
if (segment_eq(get_fs(), KERNEL_DS)) {
205
-
memset((void __kernel __force *) to, 0, n);
206
-
return 0;
207
-
}
208
148
done = 0;
209
149
do {
210
150
if (n - done > PAGE_SIZE)
211
151
size = PAGE_SIZE;
212
152
else
213
153
size = n - done;
214
-
ret = __user_copy_pt((unsigned long) to + done,
215
-
&empty_zero_page, size, 1);
154
+
if (segment_eq(get_fs(), KERNEL_DS))
155
+
ret = copy_in_kernel(n, to, (void __user *) zpage);
156
+
else
157
+
ret = __user_copy_pt((unsigned long) to, zpage, size, 1);
216
158
done += size;
159
+
to += size;
217
160
if (ret)
218
161
return ret + n - done;
219
162
} while (done < n);
···
225
172
unsigned long offset, done, len, kaddr;
226
173
size_t len_str;
227
174
175
+
if (unlikely(!count))
176
+
return 0;
228
177
if (segment_eq(get_fs(), KERNEL_DS))
229
-
return strnlen((const char __kernel __force *) src, count) + 1;
178
+
return strnlen_kernel(count, src);
230
179
done = 0;
231
180
retry:
232
181
spin_lock(&mm->page_table_lock);
···
255
200
static size_t strncpy_from_user_pt(size_t count, const char __user *src,
256
201
char *dst)
257
202
{
258
-
size_t n = strnlen_user_pt(count, src);
203
+
size_t done, len, offset, len_str;
259
204
260
-
if (!n)
261
-
return -EFAULT;
262
-
if (n > count)
263
-
n = count;
264
-
if (segment_eq(get_fs(), KERNEL_DS)) {
265
-
memcpy(dst, (const char __kernel __force *) src, n);
266
-
if (dst[n-1] == '\0')
267
-
return n-1;
268
-
else
269
-
return n;
270
-
}
271
-
if (__user_copy_pt((unsigned long) src, dst, n, 0))
272
-
return -EFAULT;
273
-
if (dst[n-1] == '\0')
274
-
return n-1;
275
-
else
276
-
return n;
205
+
if (unlikely(!count))
206
+
return 0;
207
+
done = 0;
208
+
do {
209
+
offset = (size_t)src & ~PAGE_MASK;
210
+
len = min(count - done, PAGE_SIZE - offset);
211
+
if (segment_eq(get_fs(), KERNEL_DS)) {
212
+
if (copy_in_kernel(len, (void __user *) dst, src))
213
+
return -EFAULT;
214
+
} else {
215
+
if (__user_copy_pt((unsigned long) src, dst, len, 0))
216
+
return -EFAULT;
217
+
}
218
+
len_str = strnlen(dst, len);
219
+
done += len_str;
220
+
src += len_str;
221
+
dst += len_str;
222
+
} while ((len_str == len) && (done < count));
223
+
return done;
277
224
}
278
225
279
226
static size_t copy_in_user_pt(size_t n, void __user *to,
···
288
231
unsigned long kaddr_to, kaddr_from;
289
232
int write_user;
290
233
291
-
if (segment_eq(get_fs(), KERNEL_DS)) {
292
-
memcpy((void __force *) to, (void __force *) from, n);
293
-
return 0;
294
-
}
234
+
if (segment_eq(get_fs(), KERNEL_DS))
235
+
return copy_in_kernel(n, to, from);
295
236
done = 0;
296
237
retry:
297
238
spin_lock(&mm->page_table_lock);
+18
-30
arch/s390/lib/uaccess_std.c
+18
-30
arch/s390/lib/uaccess_std.c
···
188
188
register unsigned long reg0 asm("0") = 0UL;
189
189
unsigned long tmp1, tmp2;
190
190
191
+
if (unlikely(!size))
192
+
return 0;
191
193
asm volatile(
192
194
" la %2,0(%1)\n"
193
195
" la %3,0(%0,%1)\n"
···
206
204
return size;
207
205
}
208
206
209
-
size_t strncpy_from_user_std(size_t size, const char __user *src, char *dst)
207
+
size_t strncpy_from_user_std(size_t count, const char __user *src, char *dst)
210
208
{
211
-
register unsigned long reg0 asm("0") = 0UL;
212
-
unsigned long tmp1, tmp2;
209
+
size_t done, len, offset, len_str;
213
210
214
-
asm volatile(
215
-
" la %3,0(%1)\n"
216
-
" la %4,0(%0,%1)\n"
217
-
" sacf 256\n"
218
-
"0: srst %4,%3\n"
219
-
" jo 0b\n"
220
-
" sacf 0\n"
221
-
" la %0,0(%4)\n"
222
-
" jh 1f\n" /* found \0 in string ? */
223
-
" "AHI" %4,1\n" /* include \0 in copy */
224
-
"1:"SLR" %0,%1\n" /* %0 = return length (without \0) */
225
-
" "SLR" %4,%1\n" /* %4 = copy length (including \0) */
226
-
"2: mvcp 0(%4,%2),0(%1),%5\n"
227
-
" jz 9f\n"
228
-
"3:"AHI" %4,-256\n"
229
-
" la %1,256(%1)\n"
230
-
" la %2,256(%2)\n"
231
-
"4: mvcp 0(%4,%2),0(%1),%5\n"
232
-
" jnz 3b\n"
233
-
" j 9f\n"
234
-
"7: sacf 0\n"
235
-
"8:"LHI" %0,%6\n"
236
-
"9:\n"
237
-
EX_TABLE(0b,7b) EX_TABLE(2b,8b) EX_TABLE(4b,8b)
238
-
: "+a" (size), "+a" (src), "+d" (dst), "=a" (tmp1), "=a" (tmp2)
239
-
: "d" (reg0), "K" (-EFAULT) : "cc", "memory");
240
-
return size;
211
+
if (unlikely(!count))
212
+
return 0;
213
+
done = 0;
214
+
do {
215
+
offset = (size_t)src & ~PAGE_MASK;
216
+
len = min(count - done, PAGE_SIZE - offset);
217
+
if (copy_from_user_std(len, src, dst))
218
+
return -EFAULT;
219
+
len_str = strnlen(dst, len);
220
+
done += len_str;
221
+
src += len_str;
222
+
dst += len_str;
223
+
} while ((len_str == len) && (done < count));
224
+
return done;
241
225
}
242
226
243
227
#define __futex_atomic_op(insn, ret, oldval, newval, uaddr, oparg) \
+20
-5
arch/s390/mm/dump_pagetables.c
+20
-5
arch/s390/mm/dump_pagetables.c
···
49
49
{ "ASCE", "PGD", "PUD", "PMD", "PTE" };
50
50
51
51
seq_printf(m, "%s ", level_name[level]);
52
-
if (pr & _PAGE_INVALID)
52
+
if (pr & _PAGE_INVALID) {
53
53
seq_printf(m, "I\n");
54
-
else
55
-
seq_printf(m, "%s\n", pr & _PAGE_RO ? "RO" : "RW");
54
+
return;
55
+
}
56
+
seq_printf(m, "%s", pr & _PAGE_RO ? "RO " : "RW ");
57
+
seq_printf(m, "%s", pr & _PAGE_CO ? "CO " : " ");
58
+
seq_putc(m, '\n');
56
59
}
57
60
58
61
static void note_page(struct seq_file *m, struct pg_state *st,
···
128
125
}
129
126
}
130
127
128
+
#ifdef CONFIG_64BIT
129
+
#define _PMD_PROT_MASK (_SEGMENT_ENTRY_RO | _SEGMENT_ENTRY_CO)
130
+
#else
131
+
#define _PMD_PROT_MASK 0
132
+
#endif
133
+
131
134
static void walk_pmd_level(struct seq_file *m, struct pg_state *st,
132
135
pud_t *pud, unsigned long addr)
133
136
{
···
146
137
pmd = pmd_offset(pud, addr);
147
138
if (!pmd_none(*pmd)) {
148
139
if (pmd_large(*pmd)) {
149
-
prot = pmd_val(*pmd) & _SEGMENT_ENTRY_RO;
140
+
prot = pmd_val(*pmd) & _PMD_PROT_MASK;
150
141
note_page(m, st, prot, 3);
151
142
} else
152
143
walk_pte_level(m, st, pmd, addr);
···
155
146
addr += PMD_SIZE;
156
147
}
157
148
}
149
+
150
+
#ifdef CONFIG_64BIT
151
+
#define _PUD_PROT_MASK (_REGION3_ENTRY_RO | _REGION3_ENTRY_CO)
152
+
#else
153
+
#define _PUD_PROT_MASK 0
154
+
#endif
158
155
159
156
static void walk_pud_level(struct seq_file *m, struct pg_state *st,
160
157
pgd_t *pgd, unsigned long addr)
···
174
159
pud = pud_offset(pgd, addr);
175
160
if (!pud_none(*pud))
176
161
if (pud_large(*pud)) {
177
-
prot = pud_val(*pud) & _PAGE_RO;
162
+
prot = pud_val(*pud) & _PUD_PROT_MASK;
178
163
note_page(m, st, prot, 2);
179
164
} else
180
165
walk_pmd_level(m, st, pud, addr);
+2
-1
arch/s390/mm/vmem.c
+2
-1
arch/s390/mm/vmem.c
+1
-1
drivers/input/serio/Kconfig
+1
-1
drivers/input/serio/Kconfig
···
22
22
tristate "i8042 PC Keyboard controller" if EXPERT || !X86
23
23
default y
24
24
depends on !PARISC && (!ARM || ARCH_SHARK || FOOTBRIDGE_HOST) && \
25
-
(!SUPERH || SH_CAYMAN) && !M68K && !BLACKFIN
25
+
(!SUPERH || SH_CAYMAN) && !M68K && !BLACKFIN && !S390
26
26
help
27
27
i8042 is the chip over which the standard AT keyboard and PS/2
28
28
mouse are connected to the computer. If you use these devices,
+8
-2
drivers/s390/block/dasd_eckd.c
+8
-2
drivers/s390/block/dasd_eckd.c
···
1573
1573
{
1574
1574
struct dasd_device *device = container_of(work, struct dasd_device,
1575
1575
kick_validate);
1576
-
if (dasd_eckd_validate_server(device, DASD_CQR_FLAGS_FAILFAST)
1576
+
unsigned long flags = 0;
1577
+
1578
+
set_bit(DASD_CQR_FLAGS_FAILFAST, &flags);
1579
+
if (dasd_eckd_validate_server(device, flags)
1577
1580
== -EAGAIN) {
1578
1581
/* schedule worker again if failed */
1579
1582
schedule_work(&device->kick_validate);
···
4160
4157
int rc;
4161
4158
struct dasd_uid temp_uid;
4162
4159
unsigned long flags;
4160
+
unsigned long cqr_flags = 0;
4163
4161
4164
4162
private = (struct dasd_eckd_private *) device->private;
4165
4163
···
4182
4178
rc = dasd_alias_make_device_known_to_lcu(device);
4183
4179
if (rc)
4184
4180
return rc;
4185
-
dasd_eckd_validate_server(device, DASD_CQR_FLAGS_FAILFAST);
4181
+
4182
+
set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr_flags);
4183
+
dasd_eckd_validate_server(device, cqr_flags);
4186
4184
4187
4185
/* RE-Read Configuration Data */
4188
4186
dasd_eckd_read_conf(device);
+5
-4
drivers/s390/cio/qdio_debug.c
+5
-4
drivers/s390/cio/qdio_debug.c
···
232
232
.llseek = seq_lseek,
233
233
.release = single_release,
234
234
};
235
-
static void setup_debugfs_entry(struct qdio_q *q, struct ccw_device *cdev)
235
+
236
+
static void setup_debugfs_entry(struct qdio_q *q)
236
237
{
237
238
char name[QDIO_DEBUGFS_NAME_LEN];
238
239
···
264
263
irq_ptr->debugfs_perf = NULL;
265
264
266
265
for_each_input_queue(irq_ptr, q, i)
267
-
setup_debugfs_entry(q, cdev);
266
+
setup_debugfs_entry(q);
268
267
for_each_output_queue(irq_ptr, q, i)
269
-
setup_debugfs_entry(q, cdev);
268
+
setup_debugfs_entry(q);
270
269
}
271
270
272
-
void qdio_shutdown_debug_entries(struct qdio_irq *irq_ptr, struct ccw_device *cdev)
271
+
void qdio_shutdown_debug_entries(struct qdio_irq *irq_ptr)
273
272
{
274
273
struct qdio_q *q;
275
274
int i;
+1
-2
drivers/s390/cio/qdio_debug.h
+1
-2
drivers/s390/cio/qdio_debug.h
···
85
85
struct qdio_irq *irq_ptr);
86
86
void qdio_setup_debug_entries(struct qdio_irq *irq_ptr,
87
87
struct ccw_device *cdev);
88
-
void qdio_shutdown_debug_entries(struct qdio_irq *irq_ptr,
89
-
struct ccw_device *cdev);
88
+
void qdio_shutdown_debug_entries(struct qdio_irq *irq_ptr);
90
89
int qdio_debug_init(void);
91
90
void qdio_debug_exit(void);
92
91
+1
-1
drivers/s390/cio/qdio_main.c
+1
-1
drivers/s390/cio/qdio_main.c