Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc
Pull sparc fixes from David Miller:
1) Finally make perf stack backtraces stable on sparc, several problems
(mostly due to the context in which the user copies from the stack
are done) contributed to this.
From Rob Gardner.
2) Export ADI capability if the cpu supports it.
3) Hook up userfaultfd system call.
4) When faults happen during user copies we really have to clean up and
restore the FPU state fully. Also from Rob Gardner
* git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc:
tty/serial: Skip 'NULL' char after console break when sysrq enabled
sparc64: fix FP corruption in user copy functions
sparc64: Perf should save/restore fault info
sparc64: Ensure perf can access user stacks
sparc64: Don't set %pil in rtrap_nmi too early
sparc64: Add ADI capability to cpu capabilities
tty: serial: constify sunhv_ops structs
sparc: Hook up userfaultfd system call
+271
-148
+1
arch/sparc/include/asm/elf_64.h
+1
arch/sparc/include/asm/elf_64.h
+2
-1
arch/sparc/include/uapi/asm/unistd.h
+2
-1
arch/sparc/include/uapi/asm/unistd.h
···
417
417
#define __NR_bpf 349
418
418
#define __NR_execveat 350
419
419
#define __NR_membarrier 351
420
+
#define __NR_userfaultfd 352
420
421
421
-
#define NR_syscalls 352
422
+
#define NR_syscalls 353
422
423
423
424
/* Bitmask values returned from kern_features system call. */
424
425
#define KERN_FEATURE_MIXED_MODE_STACK 0x00000001
+13
arch/sparc/kernel/head_64.S
+13
arch/sparc/kernel/head_64.S
···
946
946
mov 1, %o0
947
947
ENDPROC(__retl_one)
948
948
949
+
ENTRY(__retl_one_fp)
950
+
VISExitHalf
951
+
retl
952
+
mov 1, %o0
953
+
ENDPROC(__retl_one_fp)
954
+
949
955
ENTRY(__ret_one_asi)
950
956
wr %g0, ASI_AIUS, %asi
951
957
ret
···
963
957
retl
964
958
mov 1, %o0
965
959
ENDPROC(__retl_one_asi)
960
+
961
+
ENTRY(__retl_one_asi_fp)
962
+
wr %g0, ASI_AIUS, %asi
963
+
VISExitHalf
964
+
retl
965
+
mov 1, %o0
966
+
ENDPROC(__retl_one_asi_fp)
966
967
967
968
ENTRY(__retl_o1)
968
969
retl
+11
arch/sparc/kernel/perf_event.c
+11
arch/sparc/kernel/perf_event.c
···
1828
1828
void
1829
1829
perf_callchain_user(struct perf_callchain_entry *entry, struct pt_regs *regs)
1830
1830
{
1831
+
u64 saved_fault_address = current_thread_info()->fault_address;
1832
+
u8 saved_fault_code = get_thread_fault_code();
1833
+
mm_segment_t old_fs;
1834
+
1831
1835
perf_callchain_store(entry, regs->tpc);
1832
1836
1833
1837
if (!current->mm)
1834
1838
return;
1839
+
1840
+
old_fs = get_fs();
1841
+
set_fs(USER_DS);
1835
1842
1836
1843
flushw_user();
1837
1844
···
1850
1843
perf_callchain_user_64(entry, regs);
1851
1844
1852
1845
pagefault_enable();
1846
+
1847
+
set_fs(old_fs);
1848
+
set_thread_fault_code(saved_fault_code);
1849
+
current_thread_info()->fault_address = saved_fault_address;
1853
1850
}
+7
-1
arch/sparc/kernel/rtrap_64.S
+7
-1
arch/sparc/kernel/rtrap_64.S
···
73
73
andn %l1, %l4, %l1
74
74
srl %l4, 20, %l4
75
75
ba,pt %xcc, rtrap_no_irq_enable
76
-
wrpr %l4, %pil
76
+
nop
77
+
/* Do not actually set the %pil here. We will do that
78
+
* below after we clear PSTATE_IE in the %pstate register.
79
+
* If we re-enable interrupts here, we can recurse down
80
+
* the hardirq stack potentially endlessly, causing a
81
+
* stack overflow.
82
+
*/
77
83
78
84
.align 64
79
85
.globl rtrap_irq, rtrap, irqsz_patchme, rtrap_xcall
+5
-4
arch/sparc/kernel/setup_64.c
+5
-4
arch/sparc/kernel/setup_64.c
···
380
380
*/
381
381
"mul32", "div32", "fsmuld", "v8plus", "popc", "vis", "vis2",
382
382
"ASIBlkInit", "fmaf", "vis3", "hpc", "random", "trans", "fjfmau",
383
-
"ima", "cspare", "pause", "cbcond",
383
+
"ima", "cspare", "pause", "cbcond", NULL /*reserved for crypto */,
384
+
"adp",
384
385
};
385
386
386
387
static const char *crypto_hwcaps[] = {
···
397
396
seq_puts(m, "cpucaps\t\t: ");
398
397
for (i = 0; i < ARRAY_SIZE(hwcaps); i++) {
399
398
unsigned long bit = 1UL << i;
400
-
if (caps & bit) {
399
+
if (hwcaps[i] && (caps & bit)) {
401
400
seq_printf(m, "%s%s",
402
401
printed ? "," : "", hwcaps[i]);
403
402
printed++;
···
451
450
452
451
for (i = 0; i < ARRAY_SIZE(hwcaps); i++) {
453
452
unsigned long bit = 1UL << i;
454
-
if (caps & bit)
453
+
if (hwcaps[i] && (caps & bit))
455
454
report_one_hwcap(&printed, hwcaps[i]);
456
455
}
457
456
if (caps & HWCAP_SPARC_CRYPTO)
···
486
485
for (i = 0; i < ARRAY_SIZE(hwcaps); i++) {
487
486
unsigned long bit = 1UL << i;
488
487
489
-
if (!strcmp(prop, hwcaps[i])) {
488
+
if (hwcaps[i] && !strcmp(prop, hwcaps[i])) {
490
489
caps |= bit;
491
490
break;
492
491
}
+1
-1
arch/sparc/kernel/systbls_32.S
+1
-1
arch/sparc/kernel/systbls_32.S
···
87
87
/*335*/ .long sys_syncfs, sys_sendmmsg, sys_setns, sys_process_vm_readv, sys_process_vm_writev
88
88
/*340*/ .long sys_ni_syscall, sys_kcmp, sys_finit_module, sys_sched_setattr, sys_sched_getattr
89
89
/*345*/ .long sys_renameat2, sys_seccomp, sys_getrandom, sys_memfd_create, sys_bpf
90
-
/*350*/ .long sys_execveat, sys_membarrier
90
+
/*350*/ .long sys_execveat, sys_membarrier, sys_userfaultfd
+2
-2
arch/sparc/kernel/systbls_64.S
+2
-2
arch/sparc/kernel/systbls_64.S
···
88
88
.word sys_syncfs, compat_sys_sendmmsg, sys_setns, compat_sys_process_vm_readv, compat_sys_process_vm_writev
89
89
/*340*/ .word sys_kern_features, sys_kcmp, sys_finit_module, sys_sched_setattr, sys_sched_getattr
90
90
.word sys32_renameat2, sys_seccomp, sys_getrandom, sys_memfd_create, sys_bpf
91
-
/*350*/ .word sys32_execveat, sys_membarrier
91
+
/*350*/ .word sys32_execveat, sys_membarrier, sys_userfaultfd
92
92
93
93
#endif /* CONFIG_COMPAT */
94
94
···
168
168
.word sys_syncfs, sys_sendmmsg, sys_setns, sys_process_vm_readv, sys_process_vm_writev
169
169
/*340*/ .word sys_kern_features, sys_kcmp, sys_finit_module, sys_sched_setattr, sys_sched_getattr
170
170
.word sys_renameat2, sys_seccomp, sys_getrandom, sys_memfd_create, sys_bpf
171
-
/*350*/ .word sys64_execveat, sys_membarrier
171
+
/*350*/ .word sys64_execveat, sys_membarrier, sys_userfaultfd
+8
arch/sparc/lib/NG2copy_from_user.S
+8
arch/sparc/lib/NG2copy_from_user.S
+8
arch/sparc/lib/NG2copy_to_user.S
+8
arch/sparc/lib/NG2copy_to_user.S
+62
-56
arch/sparc/lib/NG2memcpy.S
+62
-56
arch/sparc/lib/NG2memcpy.S
···
34
34
#ifndef EX_LD
35
35
#define EX_LD(x) x
36
36
#endif
37
+
#ifndef EX_LD_FP
38
+
#define EX_LD_FP(x) x
39
+
#endif
37
40
38
41
#ifndef EX_ST
39
42
#define EX_ST(x) x
43
+
#endif
44
+
#ifndef EX_ST_FP
45
+
#define EX_ST_FP(x) x
40
46
#endif
41
47
42
48
#ifndef EX_RETVAL
···
140
134
fsrc2 %x6, %f12; \
141
135
fsrc2 %x7, %f14;
142
136
#define FREG_LOAD_1(base, x0) \
143
-
EX_LD(LOAD(ldd, base + 0x00, %x0))
137
+
EX_LD_FP(LOAD(ldd, base + 0x00, %x0))
144
138
#define FREG_LOAD_2(base, x0, x1) \
145
-
EX_LD(LOAD(ldd, base + 0x00, %x0)); \
146
-
EX_LD(LOAD(ldd, base + 0x08, %x1));
139
+
EX_LD_FP(LOAD(ldd, base + 0x00, %x0)); \
140
+
EX_LD_FP(LOAD(ldd, base + 0x08, %x1));
147
141
#define FREG_LOAD_3(base, x0, x1, x2) \
148
-
EX_LD(LOAD(ldd, base + 0x00, %x0)); \
149
-
EX_LD(LOAD(ldd, base + 0x08, %x1)); \
150
-
EX_LD(LOAD(ldd, base + 0x10, %x2));
142
+
EX_LD_FP(LOAD(ldd, base + 0x00, %x0)); \
143
+
EX_LD_FP(LOAD(ldd, base + 0x08, %x1)); \
144
+
EX_LD_FP(LOAD(ldd, base + 0x10, %x2));
151
145
#define FREG_LOAD_4(base, x0, x1, x2, x3) \
152
-
EX_LD(LOAD(ldd, base + 0x00, %x0)); \
153
-
EX_LD(LOAD(ldd, base + 0x08, %x1)); \
154
-
EX_LD(LOAD(ldd, base + 0x10, %x2)); \
155
-
EX_LD(LOAD(ldd, base + 0x18, %x3));
146
+
EX_LD_FP(LOAD(ldd, base + 0x00, %x0)); \
147
+
EX_LD_FP(LOAD(ldd, base + 0x08, %x1)); \
148
+
EX_LD_FP(LOAD(ldd, base + 0x10, %x2)); \
149
+
EX_LD_FP(LOAD(ldd, base + 0x18, %x3));
156
150
#define FREG_LOAD_5(base, x0, x1, x2, x3, x4) \
157
-
EX_LD(LOAD(ldd, base + 0x00, %x0)); \
158
-
EX_LD(LOAD(ldd, base + 0x08, %x1)); \
159
-
EX_LD(LOAD(ldd, base + 0x10, %x2)); \
160
-
EX_LD(LOAD(ldd, base + 0x18, %x3)); \
161
-
EX_LD(LOAD(ldd, base + 0x20, %x4));
151
+
EX_LD_FP(LOAD(ldd, base + 0x00, %x0)); \
152
+
EX_LD_FP(LOAD(ldd, base + 0x08, %x1)); \
153
+
EX_LD_FP(LOAD(ldd, base + 0x10, %x2)); \
154
+
EX_LD_FP(LOAD(ldd, base + 0x18, %x3)); \
155
+
EX_LD_FP(LOAD(ldd, base + 0x20, %x4));
162
156
#define FREG_LOAD_6(base, x0, x1, x2, x3, x4, x5) \
163
-
EX_LD(LOAD(ldd, base + 0x00, %x0)); \
164
-
EX_LD(LOAD(ldd, base + 0x08, %x1)); \
165
-
EX_LD(LOAD(ldd, base + 0x10, %x2)); \
166
-
EX_LD(LOAD(ldd, base + 0x18, %x3)); \
167
-
EX_LD(LOAD(ldd, base + 0x20, %x4)); \
168
-
EX_LD(LOAD(ldd, base + 0x28, %x5));
157
+
EX_LD_FP(LOAD(ldd, base + 0x00, %x0)); \
158
+
EX_LD_FP(LOAD(ldd, base + 0x08, %x1)); \
159
+
EX_LD_FP(LOAD(ldd, base + 0x10, %x2)); \
160
+
EX_LD_FP(LOAD(ldd, base + 0x18, %x3)); \
161
+
EX_LD_FP(LOAD(ldd, base + 0x20, %x4)); \
162
+
EX_LD_FP(LOAD(ldd, base + 0x28, %x5));
169
163
#define FREG_LOAD_7(base, x0, x1, x2, x3, x4, x5, x6) \
170
-
EX_LD(LOAD(ldd, base + 0x00, %x0)); \
171
-
EX_LD(LOAD(ldd, base + 0x08, %x1)); \
172
-
EX_LD(LOAD(ldd, base + 0x10, %x2)); \
173
-
EX_LD(LOAD(ldd, base + 0x18, %x3)); \
174
-
EX_LD(LOAD(ldd, base + 0x20, %x4)); \
175
-
EX_LD(LOAD(ldd, base + 0x28, %x5)); \
176
-
EX_LD(LOAD(ldd, base + 0x30, %x6));
164
+
EX_LD_FP(LOAD(ldd, base + 0x00, %x0)); \
165
+
EX_LD_FP(LOAD(ldd, base + 0x08, %x1)); \
166
+
EX_LD_FP(LOAD(ldd, base + 0x10, %x2)); \
167
+
EX_LD_FP(LOAD(ldd, base + 0x18, %x3)); \
168
+
EX_LD_FP(LOAD(ldd, base + 0x20, %x4)); \
169
+
EX_LD_FP(LOAD(ldd, base + 0x28, %x5)); \
170
+
EX_LD_FP(LOAD(ldd, base + 0x30, %x6));
177
171
178
172
.register %g2,#scratch
179
173
.register %g3,#scratch
···
281
275
nop
282
276
/* fall through for 0 < low bits < 8 */
283
277
110: sub %o4, 64, %g2
284
-
EX_LD(LOAD_BLK(%g2, %f0))
285
-
1: EX_ST(STORE_INIT(%g0, %o4 + %g3))
286
-
EX_LD(LOAD_BLK(%o4, %f16))
278
+
EX_LD_FP(LOAD_BLK(%g2, %f0))
279
+
1: EX_ST_FP(STORE_INIT(%g0, %o4 + %g3))
280
+
EX_LD_FP(LOAD_BLK(%o4, %f16))
287
281
FREG_FROB(f0, f2, f4, f6, f8, f10, f12, f14, f16)
288
-
EX_ST(STORE_BLK(%f0, %o4 + %g3))
282
+
EX_ST_FP(STORE_BLK(%f0, %o4 + %g3))
289
283
FREG_MOVE_8(f16, f18, f20, f22, f24, f26, f28, f30)
290
284
subcc %g1, 64, %g1
291
285
add %o4, 64, %o4
···
296
290
297
291
120: sub %o4, 56, %g2
298
292
FREG_LOAD_7(%g2, f0, f2, f4, f6, f8, f10, f12)
299
-
1: EX_ST(STORE_INIT(%g0, %o4 + %g3))
300
-
EX_LD(LOAD_BLK(%o4, %f16))
293
+
1: EX_ST_FP(STORE_INIT(%g0, %o4 + %g3))
294
+
EX_LD_FP(LOAD_BLK(%o4, %f16))
301
295
FREG_FROB(f0, f2, f4, f6, f8, f10, f12, f16, f18)
302
-
EX_ST(STORE_BLK(%f0, %o4 + %g3))
296
+
EX_ST_FP(STORE_BLK(%f0, %o4 + %g3))
303
297
FREG_MOVE_7(f18, f20, f22, f24, f26, f28, f30)
304
298
subcc %g1, 64, %g1
305
299
add %o4, 64, %o4
···
310
304
311
305
130: sub %o4, 48, %g2
312
306
FREG_LOAD_6(%g2, f0, f2, f4, f6, f8, f10)
313
-
1: EX_ST(STORE_INIT(%g0, %o4 + %g3))
314
-
EX_LD(LOAD_BLK(%o4, %f16))
307
+
1: EX_ST_FP(STORE_INIT(%g0, %o4 + %g3))
308
+
EX_LD_FP(LOAD_BLK(%o4, %f16))
315
309
FREG_FROB(f0, f2, f4, f6, f8, f10, f16, f18, f20)
316
-
EX_ST(STORE_BLK(%f0, %o4 + %g3))
310
+
EX_ST_FP(STORE_BLK(%f0, %o4 + %g3))
317
311
FREG_MOVE_6(f20, f22, f24, f26, f28, f30)
318
312
subcc %g1, 64, %g1
319
313
add %o4, 64, %o4
···
324
318
325
319
140: sub %o4, 40, %g2
326
320
FREG_LOAD_5(%g2, f0, f2, f4, f6, f8)
327
-
1: EX_ST(STORE_INIT(%g0, %o4 + %g3))
328
-
EX_LD(LOAD_BLK(%o4, %f16))
321
+
1: EX_ST_FP(STORE_INIT(%g0, %o4 + %g3))
322
+
EX_LD_FP(LOAD_BLK(%o4, %f16))
329
323
FREG_FROB(f0, f2, f4, f6, f8, f16, f18, f20, f22)
330
-
EX_ST(STORE_BLK(%f0, %o4 + %g3))
324
+
EX_ST_FP(STORE_BLK(%f0, %o4 + %g3))
331
325
FREG_MOVE_5(f22, f24, f26, f28, f30)
332
326
subcc %g1, 64, %g1
333
327
add %o4, 64, %o4
···
338
332
339
333
150: sub %o4, 32, %g2
340
334
FREG_LOAD_4(%g2, f0, f2, f4, f6)
341
-
1: EX_ST(STORE_INIT(%g0, %o4 + %g3))
342
-
EX_LD(LOAD_BLK(%o4, %f16))
335
+
1: EX_ST_FP(STORE_INIT(%g0, %o4 + %g3))
336
+
EX_LD_FP(LOAD_BLK(%o4, %f16))
343
337
FREG_FROB(f0, f2, f4, f6, f16, f18, f20, f22, f24)
344
-
EX_ST(STORE_BLK(%f0, %o4 + %g3))
338
+
EX_ST_FP(STORE_BLK(%f0, %o4 + %g3))
345
339
FREG_MOVE_4(f24, f26, f28, f30)
346
340
subcc %g1, 64, %g1
347
341
add %o4, 64, %o4
···
352
346
353
347
160: sub %o4, 24, %g2
354
348
FREG_LOAD_3(%g2, f0, f2, f4)
355
-
1: EX_ST(STORE_INIT(%g0, %o4 + %g3))
356
-
EX_LD(LOAD_BLK(%o4, %f16))
349
+
1: EX_ST_FP(STORE_INIT(%g0, %o4 + %g3))
350
+
EX_LD_FP(LOAD_BLK(%o4, %f16))
357
351
FREG_FROB(f0, f2, f4, f16, f18, f20, f22, f24, f26)
358
-
EX_ST(STORE_BLK(%f0, %o4 + %g3))
352
+
EX_ST_FP(STORE_BLK(%f0, %o4 + %g3))
359
353
FREG_MOVE_3(f26, f28, f30)
360
354
subcc %g1, 64, %g1
361
355
add %o4, 64, %o4
···
366
360
367
361
170: sub %o4, 16, %g2
368
362
FREG_LOAD_2(%g2, f0, f2)
369
-
1: EX_ST(STORE_INIT(%g0, %o4 + %g3))
370
-
EX_LD(LOAD_BLK(%o4, %f16))
363
+
1: EX_ST_FP(STORE_INIT(%g0, %o4 + %g3))
364
+
EX_LD_FP(LOAD_BLK(%o4, %f16))
371
365
FREG_FROB(f0, f2, f16, f18, f20, f22, f24, f26, f28)
372
-
EX_ST(STORE_BLK(%f0, %o4 + %g3))
366
+
EX_ST_FP(STORE_BLK(%f0, %o4 + %g3))
373
367
FREG_MOVE_2(f28, f30)
374
368
subcc %g1, 64, %g1
375
369
add %o4, 64, %o4
···
380
374
381
375
180: sub %o4, 8, %g2
382
376
FREG_LOAD_1(%g2, f0)
383
-
1: EX_ST(STORE_INIT(%g0, %o4 + %g3))
384
-
EX_LD(LOAD_BLK(%o4, %f16))
377
+
1: EX_ST_FP(STORE_INIT(%g0, %o4 + %g3))
378
+
EX_LD_FP(LOAD_BLK(%o4, %f16))
385
379
FREG_FROB(f0, f16, f18, f20, f22, f24, f26, f28, f30)
386
-
EX_ST(STORE_BLK(%f0, %o4 + %g3))
380
+
EX_ST_FP(STORE_BLK(%f0, %o4 + %g3))
387
381
FREG_MOVE_1(f30)
388
382
subcc %g1, 64, %g1
389
383
add %o4, 64, %o4
···
393
387
nop
394
388
395
389
190:
396
-
1: EX_ST(STORE_INIT(%g0, %o4 + %g3))
390
+
1: EX_ST_FP(STORE_INIT(%g0, %o4 + %g3))
397
391
subcc %g1, 64, %g1
398
-
EX_LD(LOAD_BLK(%o4, %f0))
399
-
EX_ST(STORE_BLK(%f0, %o4 + %g3))
392
+
EX_LD_FP(LOAD_BLK(%o4, %f0))
393
+
EX_ST_FP(STORE_BLK(%f0, %o4 + %g3))
400
394
add %o4, 64, %o4
401
395
bne,pt %xcc, 1b
402
396
LOAD(prefetch, %o4 + 64, #one_read)
+8
arch/sparc/lib/NG4copy_from_user.S
+8
arch/sparc/lib/NG4copy_from_user.S
+8
arch/sparc/lib/NG4copy_to_user.S
+8
arch/sparc/lib/NG4copy_to_user.S
+23
-17
arch/sparc/lib/NG4memcpy.S
+23
-17
arch/sparc/lib/NG4memcpy.S
···
48
48
#ifndef EX_LD
49
49
#define EX_LD(x) x
50
50
#endif
51
+
#ifndef EX_LD_FP
52
+
#define EX_LD_FP(x) x
53
+
#endif
51
54
52
55
#ifndef EX_ST
53
56
#define EX_ST(x) x
57
+
#endif
58
+
#ifndef EX_ST_FP
59
+
#define EX_ST_FP(x) x
54
60
#endif
55
61
56
62
#ifndef EX_RETVAL
···
216
210
sub %o2, %o4, %o2
217
211
alignaddr %o1, %g0, %g1
218
212
add %o1, %o4, %o1
219
-
EX_LD(LOAD(ldd, %g1 + 0x00, %f0))
220
-
1: EX_LD(LOAD(ldd, %g1 + 0x08, %f2))
213
+
EX_LD_FP(LOAD(ldd, %g1 + 0x00, %f0))
214
+
1: EX_LD_FP(LOAD(ldd, %g1 + 0x08, %f2))
221
215
subcc %o4, 0x40, %o4
222
-
EX_LD(LOAD(ldd, %g1 + 0x10, %f4))
223
-
EX_LD(LOAD(ldd, %g1 + 0x18, %f6))
224
-
EX_LD(LOAD(ldd, %g1 + 0x20, %f8))
225
-
EX_LD(LOAD(ldd, %g1 + 0x28, %f10))
226
-
EX_LD(LOAD(ldd, %g1 + 0x30, %f12))
227
-
EX_LD(LOAD(ldd, %g1 + 0x38, %f14))
216
+
EX_LD_FP(LOAD(ldd, %g1 + 0x10, %f4))
217
+
EX_LD_FP(LOAD(ldd, %g1 + 0x18, %f6))
218
+
EX_LD_FP(LOAD(ldd, %g1 + 0x20, %f8))
219
+
EX_LD_FP(LOAD(ldd, %g1 + 0x28, %f10))
220
+
EX_LD_FP(LOAD(ldd, %g1 + 0x30, %f12))
221
+
EX_LD_FP(LOAD(ldd, %g1 + 0x38, %f14))
228
222
faligndata %f0, %f2, %f16
229
-
EX_LD(LOAD(ldd, %g1 + 0x40, %f0))
223
+
EX_LD_FP(LOAD(ldd, %g1 + 0x40, %f0))
230
224
faligndata %f2, %f4, %f18
231
225
add %g1, 0x40, %g1
232
226
faligndata %f4, %f6, %f20
···
235
229
faligndata %f10, %f12, %f26
236
230
faligndata %f12, %f14, %f28
237
231
faligndata %f14, %f0, %f30
238
-
EX_ST(STORE(std, %f16, %o0 + 0x00))
239
-
EX_ST(STORE(std, %f18, %o0 + 0x08))
240
-
EX_ST(STORE(std, %f20, %o0 + 0x10))
241
-
EX_ST(STORE(std, %f22, %o0 + 0x18))
242
-
EX_ST(STORE(std, %f24, %o0 + 0x20))
243
-
EX_ST(STORE(std, %f26, %o0 + 0x28))
244
-
EX_ST(STORE(std, %f28, %o0 + 0x30))
245
-
EX_ST(STORE(std, %f30, %o0 + 0x38))
232
+
EX_ST_FP(STORE(std, %f16, %o0 + 0x00))
233
+
EX_ST_FP(STORE(std, %f18, %o0 + 0x08))
234
+
EX_ST_FP(STORE(std, %f20, %o0 + 0x10))
235
+
EX_ST_FP(STORE(std, %f22, %o0 + 0x18))
236
+
EX_ST_FP(STORE(std, %f24, %o0 + 0x20))
237
+
EX_ST_FP(STORE(std, %f26, %o0 + 0x28))
238
+
EX_ST_FP(STORE(std, %f28, %o0 + 0x30))
239
+
EX_ST_FP(STORE(std, %f30, %o0 + 0x38))
246
240
add %o0, 0x40, %o0
247
241
bne,pt %icc, 1b
248
242
LOAD(prefetch, %g1 + 0x200, #n_reads_strong)
+8
arch/sparc/lib/U1copy_from_user.S
+8
arch/sparc/lib/U1copy_from_user.S
···
11
11
.text; \
12
12
.align 4;
13
13
14
+
#define EX_LD_FP(x) \
15
+
98: x; \
16
+
.section __ex_table,"a";\
17
+
.align 4; \
18
+
.word 98b, __retl_one_fp;\
19
+
.text; \
20
+
.align 4;
21
+
14
22
#define FUNC_NAME ___copy_from_user
15
23
#define LOAD(type,addr,dest) type##a [addr] %asi, dest
16
24
#define LOAD_BLK(addr,dest) ldda [addr] ASI_BLK_AIUS, dest
+8
arch/sparc/lib/U1copy_to_user.S
+8
arch/sparc/lib/U1copy_to_user.S
···
11
11
.text; \
12
12
.align 4;
13
13
14
+
#define EX_ST_FP(x) \
15
+
98: x; \
16
+
.section __ex_table,"a";\
17
+
.align 4; \
18
+
.word 98b, __retl_one_fp;\
19
+
.text; \
20
+
.align 4;
21
+
14
22
#define FUNC_NAME ___copy_to_user
15
23
#define STORE(type,src,addr) type##a src, [addr] ASI_AIUS
16
24
#define STORE_BLK(src,addr) stda src, [addr] ASI_BLK_AIUS
+27
-21
arch/sparc/lib/U1memcpy.S
+27
-21
arch/sparc/lib/U1memcpy.S
···
25
25
#ifndef EX_LD
26
26
#define EX_LD(x) x
27
27
#endif
28
+
#ifndef EX_LD_FP
29
+
#define EX_LD_FP(x) x
30
+
#endif
28
31
29
32
#ifndef EX_ST
30
33
#define EX_ST(x) x
34
+
#endif
35
+
#ifndef EX_ST_FP
36
+
#define EX_ST_FP(x) x
31
37
#endif
32
38
33
39
#ifndef EX_RETVAL
···
79
73
faligndata %f8, %f9, %f62;
80
74
81
75
#define MAIN_LOOP_CHUNK(src, dest, fdest, fsrc, len, jmptgt) \
82
-
EX_LD(LOAD_BLK(%src, %fdest)); \
83
-
EX_ST(STORE_BLK(%fsrc, %dest)); \
76
+
EX_LD_FP(LOAD_BLK(%src, %fdest)); \
77
+
EX_ST_FP(STORE_BLK(%fsrc, %dest)); \
84
78
add %src, 0x40, %src; \
85
79
subcc %len, 0x40, %len; \
86
80
be,pn %xcc, jmptgt; \
···
95
89
96
90
#define DO_SYNC membar #Sync;
97
91
#define STORE_SYNC(dest, fsrc) \
98
-
EX_ST(STORE_BLK(%fsrc, %dest)); \
92
+
EX_ST_FP(STORE_BLK(%fsrc, %dest)); \
99
93
add %dest, 0x40, %dest; \
100
94
DO_SYNC
101
95
102
96
#define STORE_JUMP(dest, fsrc, target) \
103
-
EX_ST(STORE_BLK(%fsrc, %dest)); \
97
+
EX_ST_FP(STORE_BLK(%fsrc, %dest)); \
104
98
add %dest, 0x40, %dest; \
105
99
ba,pt %xcc, target; \
106
100
nop;
···
109
103
subcc %left, 8, %left;\
110
104
bl,pn %xcc, 95f; \
111
105
faligndata %f0, %f1, %f48; \
112
-
EX_ST(STORE(std, %f48, %dest)); \
106
+
EX_ST_FP(STORE(std, %f48, %dest)); \
113
107
add %dest, 8, %dest;
114
108
115
109
#define UNEVEN_VISCHUNK_LAST(dest, f0, f1, left) \
···
166
160
and %g2, 0x38, %g2
167
161
168
162
1: subcc %g1, 0x1, %g1
169
-
EX_LD(LOAD(ldub, %o1 + 0x00, %o3))
170
-
EX_ST(STORE(stb, %o3, %o1 + %GLOBAL_SPARE))
163
+
EX_LD_FP(LOAD(ldub, %o1 + 0x00, %o3))
164
+
EX_ST_FP(STORE(stb, %o3, %o1 + %GLOBAL_SPARE))
171
165
bgu,pt %XCC, 1b
172
166
add %o1, 0x1, %o1
173
167
···
178
172
be,pt %icc, 3f
179
173
alignaddr %o1, %g0, %o1
180
174
181
-
EX_LD(LOAD(ldd, %o1, %f4))
182
-
1: EX_LD(LOAD(ldd, %o1 + 0x8, %f6))
175
+
EX_LD_FP(LOAD(ldd, %o1, %f4))
176
+
1: EX_LD_FP(LOAD(ldd, %o1 + 0x8, %f6))
183
177
add %o1, 0x8, %o1
184
178
subcc %g2, 0x8, %g2
185
179
faligndata %f4, %f6, %f0
186
-
EX_ST(STORE(std, %f0, %o0))
180
+
EX_ST_FP(STORE(std, %f0, %o0))
187
181
be,pn %icc, 3f
188
182
add %o0, 0x8, %o0
189
183
190
-
EX_LD(LOAD(ldd, %o1 + 0x8, %f4))
184
+
EX_LD_FP(LOAD(ldd, %o1 + 0x8, %f4))
191
185
add %o1, 0x8, %o1
192
186
subcc %g2, 0x8, %g2
193
187
faligndata %f6, %f4, %f0
194
-
EX_ST(STORE(std, %f0, %o0))
188
+
EX_ST_FP(STORE(std, %f0, %o0))
195
189
bne,pt %icc, 1b
196
190
add %o0, 0x8, %o0
197
191
···
214
208
add %g1, %GLOBAL_SPARE, %g1
215
209
subcc %o2, %g3, %o2
216
210
217
-
EX_LD(LOAD_BLK(%o1, %f0))
211
+
EX_LD_FP(LOAD_BLK(%o1, %f0))
218
212
add %o1, 0x40, %o1
219
213
add %g1, %g3, %g1
220
-
EX_LD(LOAD_BLK(%o1, %f16))
214
+
EX_LD_FP(LOAD_BLK(%o1, %f16))
221
215
add %o1, 0x40, %o1
222
216
sub %GLOBAL_SPARE, 0x80, %GLOBAL_SPARE
223
-
EX_LD(LOAD_BLK(%o1, %f32))
217
+
EX_LD_FP(LOAD_BLK(%o1, %f32))
224
218
add %o1, 0x40, %o1
225
219
226
220
/* There are 8 instances of the unrolled loop,
···
432
426
62: FINISH_VISCHUNK(o0, f44, f46, g3)
433
427
63: UNEVEN_VISCHUNK_LAST(o0, f46, f0, g3)
434
428
435
-
93: EX_LD(LOAD(ldd, %o1, %f2))
429
+
93: EX_LD_FP(LOAD(ldd, %o1, %f2))
436
430
add %o1, 8, %o1
437
431
subcc %g3, 8, %g3
438
432
faligndata %f0, %f2, %f8
439
-
EX_ST(STORE(std, %f8, %o0))
433
+
EX_ST_FP(STORE(std, %f8, %o0))
440
434
bl,pn %xcc, 95f
441
435
add %o0, 8, %o0
442
-
EX_LD(LOAD(ldd, %o1, %f0))
436
+
EX_LD_FP(LOAD(ldd, %o1, %f0))
443
437
add %o1, 8, %o1
444
438
subcc %g3, 8, %g3
445
439
faligndata %f2, %f0, %f8
446
-
EX_ST(STORE(std, %f8, %o0))
440
+
EX_ST_FP(STORE(std, %f8, %o0))
447
441
bge,pt %xcc, 93b
448
442
add %o0, 8, %o0
449
443
450
444
95: brz,pt %o2, 2f
451
445
mov %g1, %o1
452
446
453
-
1: EX_LD(LOAD(ldub, %o1, %o3))
447
+
1: EX_LD_FP(LOAD(ldub, %o1, %o3))
454
448
add %o1, 1, %o1
455
449
subcc %o2, 1, %o2
456
-
EX_ST(STORE(stb, %o3, %o0))
450
+
EX_ST_FP(STORE(stb, %o3, %o0))
457
451
bne,pt %xcc, 1b
458
452
add %o0, 1, %o0
459
453
+8
arch/sparc/lib/U3copy_from_user.S
+8
arch/sparc/lib/U3copy_from_user.S
···
11
11
.text; \
12
12
.align 4;
13
13
14
+
#define EX_LD_FP(x) \
15
+
98: x; \
16
+
.section __ex_table,"a";\
17
+
.align 4; \
18
+
.word 98b, __retl_one_fp;\
19
+
.text; \
20
+
.align 4;
21
+
14
22
#define FUNC_NAME U3copy_from_user
15
23
#define LOAD(type,addr,dest) type##a [addr] %asi, dest
16
24
#define EX_RETVAL(x) 0
+8
arch/sparc/lib/U3copy_to_user.S
+8
arch/sparc/lib/U3copy_to_user.S
···
11
11
.text; \
12
12
.align 4;
13
13
14
+
#define EX_ST_FP(x) \
15
+
98: x; \
16
+
.section __ex_table,"a";\
17
+
.align 4; \
18
+
.word 98b, __retl_one_fp;\
19
+
.text; \
20
+
.align 4;
21
+
14
22
#define FUNC_NAME U3copy_to_user
15
23
#define STORE(type,src,addr) type##a src, [addr] ASI_AIUS
16
24
#define STORE_BLK(src,addr) stda src, [addr] ASI_BLK_AIUS
+46
-40
arch/sparc/lib/U3memcpy.S
+46
-40
arch/sparc/lib/U3memcpy.S
···
24
24
#ifndef EX_LD
25
25
#define EX_LD(x) x
26
26
#endif
27
+
#ifndef EX_LD_FP
28
+
#define EX_LD_FP(x) x
29
+
#endif
27
30
28
31
#ifndef EX_ST
29
32
#define EX_ST(x) x
33
+
#endif
34
+
#ifndef EX_ST_FP
35
+
#define EX_ST_FP(x) x
30
36
#endif
31
37
32
38
#ifndef EX_RETVAL
···
126
120
and %g2, 0x38, %g2
127
121
128
122
1: subcc %g1, 0x1, %g1
129
-
EX_LD(LOAD(ldub, %o1 + 0x00, %o3))
130
-
EX_ST(STORE(stb, %o3, %o1 + GLOBAL_SPARE))
123
+
EX_LD_FP(LOAD(ldub, %o1 + 0x00, %o3))
124
+
EX_ST_FP(STORE(stb, %o3, %o1 + GLOBAL_SPARE))
131
125
bgu,pt %XCC, 1b
132
126
add %o1, 0x1, %o1
133
127
···
138
132
be,pt %icc, 3f
139
133
alignaddr %o1, %g0, %o1
140
134
141
-
EX_LD(LOAD(ldd, %o1, %f4))
142
-
1: EX_LD(LOAD(ldd, %o1 + 0x8, %f6))
135
+
EX_LD_FP(LOAD(ldd, %o1, %f4))
136
+
1: EX_LD_FP(LOAD(ldd, %o1 + 0x8, %f6))
143
137
add %o1, 0x8, %o1
144
138
subcc %g2, 0x8, %g2
145
139
faligndata %f4, %f6, %f0
146
-
EX_ST(STORE(std, %f0, %o0))
140
+
EX_ST_FP(STORE(std, %f0, %o0))
147
141
be,pn %icc, 3f
148
142
add %o0, 0x8, %o0
149
143
150
-
EX_LD(LOAD(ldd, %o1 + 0x8, %f4))
144
+
EX_LD_FP(LOAD(ldd, %o1 + 0x8, %f4))
151
145
add %o1, 0x8, %o1
152
146
subcc %g2, 0x8, %g2
153
147
faligndata %f6, %f4, %f2
154
-
EX_ST(STORE(std, %f2, %o0))
148
+
EX_ST_FP(STORE(std, %f2, %o0))
155
149
bne,pt %icc, 1b
156
150
add %o0, 0x8, %o0
157
151
···
161
155
LOAD(prefetch, %o1 + 0x080, #one_read)
162
156
LOAD(prefetch, %o1 + 0x0c0, #one_read)
163
157
LOAD(prefetch, %o1 + 0x100, #one_read)
164
-
EX_LD(LOAD(ldd, %o1 + 0x000, %f0))
158
+
EX_LD_FP(LOAD(ldd, %o1 + 0x000, %f0))
165
159
LOAD(prefetch, %o1 + 0x140, #one_read)
166
-
EX_LD(LOAD(ldd, %o1 + 0x008, %f2))
160
+
EX_LD_FP(LOAD(ldd, %o1 + 0x008, %f2))
167
161
LOAD(prefetch, %o1 + 0x180, #one_read)
168
-
EX_LD(LOAD(ldd, %o1 + 0x010, %f4))
162
+
EX_LD_FP(LOAD(ldd, %o1 + 0x010, %f4))
169
163
LOAD(prefetch, %o1 + 0x1c0, #one_read)
170
164
faligndata %f0, %f2, %f16
171
-
EX_LD(LOAD(ldd, %o1 + 0x018, %f6))
165
+
EX_LD_FP(LOAD(ldd, %o1 + 0x018, %f6))
172
166
faligndata %f2, %f4, %f18
173
-
EX_LD(LOAD(ldd, %o1 + 0x020, %f8))
167
+
EX_LD_FP(LOAD(ldd, %o1 + 0x020, %f8))
174
168
faligndata %f4, %f6, %f20
175
-
EX_LD(LOAD(ldd, %o1 + 0x028, %f10))
169
+
EX_LD_FP(LOAD(ldd, %o1 + 0x028, %f10))
176
170
faligndata %f6, %f8, %f22
177
171
178
-
EX_LD(LOAD(ldd, %o1 + 0x030, %f12))
172
+
EX_LD_FP(LOAD(ldd, %o1 + 0x030, %f12))
179
173
faligndata %f8, %f10, %f24
180
-
EX_LD(LOAD(ldd, %o1 + 0x038, %f14))
174
+
EX_LD_FP(LOAD(ldd, %o1 + 0x038, %f14))
181
175
faligndata %f10, %f12, %f26
182
-
EX_LD(LOAD(ldd, %o1 + 0x040, %f0))
176
+
EX_LD_FP(LOAD(ldd, %o1 + 0x040, %f0))
183
177
184
178
subcc GLOBAL_SPARE, 0x80, GLOBAL_SPARE
185
179
add %o1, 0x40, %o1
···
190
184
191
185
.align 64
192
186
1:
193
-
EX_LD(LOAD(ldd, %o1 + 0x008, %f2))
187
+
EX_LD_FP(LOAD(ldd, %o1 + 0x008, %f2))
194
188
faligndata %f12, %f14, %f28
195
-
EX_LD(LOAD(ldd, %o1 + 0x010, %f4))
189
+
EX_LD_FP(LOAD(ldd, %o1 + 0x010, %f4))
196
190
faligndata %f14, %f0, %f30
197
-
EX_ST(STORE_BLK(%f16, %o0))
198
-
EX_LD(LOAD(ldd, %o1 + 0x018, %f6))
191
+
EX_ST_FP(STORE_BLK(%f16, %o0))
192
+
EX_LD_FP(LOAD(ldd, %o1 + 0x018, %f6))
199
193
faligndata %f0, %f2, %f16
200
194
add %o0, 0x40, %o0
201
195
202
-
EX_LD(LOAD(ldd, %o1 + 0x020, %f8))
196
+
EX_LD_FP(LOAD(ldd, %o1 + 0x020, %f8))
203
197
faligndata %f2, %f4, %f18
204
-
EX_LD(LOAD(ldd, %o1 + 0x028, %f10))
198
+
EX_LD_FP(LOAD(ldd, %o1 + 0x028, %f10))
205
199
faligndata %f4, %f6, %f20
206
-
EX_LD(LOAD(ldd, %o1 + 0x030, %f12))
200
+
EX_LD_FP(LOAD(ldd, %o1 + 0x030, %f12))
207
201
subcc %o3, 0x01, %o3
208
202
faligndata %f6, %f8, %f22
209
-
EX_LD(LOAD(ldd, %o1 + 0x038, %f14))
203
+
EX_LD_FP(LOAD(ldd, %o1 + 0x038, %f14))
210
204
211
205
faligndata %f8, %f10, %f24
212
-
EX_LD(LOAD(ldd, %o1 + 0x040, %f0))
206
+
EX_LD_FP(LOAD(ldd, %o1 + 0x040, %f0))
213
207
LOAD(prefetch, %o1 + 0x1c0, #one_read)
214
208
faligndata %f10, %f12, %f26
215
209
bg,pt %XCC, 1b
···
217
211
218
212
/* Finally we copy the last full 64-byte block. */
219
213
2:
220
-
EX_LD(LOAD(ldd, %o1 + 0x008, %f2))
214
+
EX_LD_FP(LOAD(ldd, %o1 + 0x008, %f2))
221
215
faligndata %f12, %f14, %f28
222
-
EX_LD(LOAD(ldd, %o1 + 0x010, %f4))
216
+
EX_LD_FP(LOAD(ldd, %o1 + 0x010, %f4))
223
217
faligndata %f14, %f0, %f30
224
-
EX_ST(STORE_BLK(%f16, %o0))
225
-
EX_LD(LOAD(ldd, %o1 + 0x018, %f6))
218
+
EX_ST_FP(STORE_BLK(%f16, %o0))
219
+
EX_LD_FP(LOAD(ldd, %o1 + 0x018, %f6))
226
220
faligndata %f0, %f2, %f16
227
-
EX_LD(LOAD(ldd, %o1 + 0x020, %f8))
221
+
EX_LD_FP(LOAD(ldd, %o1 + 0x020, %f8))
228
222
faligndata %f2, %f4, %f18
229
-
EX_LD(LOAD(ldd, %o1 + 0x028, %f10))
223
+
EX_LD_FP(LOAD(ldd, %o1 + 0x028, %f10))
230
224
faligndata %f4, %f6, %f20
231
-
EX_LD(LOAD(ldd, %o1 + 0x030, %f12))
225
+
EX_LD_FP(LOAD(ldd, %o1 + 0x030, %f12))
232
226
faligndata %f6, %f8, %f22
233
-
EX_LD(LOAD(ldd, %o1 + 0x038, %f14))
227
+
EX_LD_FP(LOAD(ldd, %o1 + 0x038, %f14))
234
228
faligndata %f8, %f10, %f24
235
229
cmp %g1, 0
236
230
be,pt %XCC, 1f
237
231
add %o0, 0x40, %o0
238
-
EX_LD(LOAD(ldd, %o1 + 0x040, %f0))
232
+
EX_LD_FP(LOAD(ldd, %o1 + 0x040, %f0))
239
233
1: faligndata %f10, %f12, %f26
240
234
faligndata %f12, %f14, %f28
241
235
faligndata %f14, %f0, %f30
242
-
EX_ST(STORE_BLK(%f16, %o0))
236
+
EX_ST_FP(STORE_BLK(%f16, %o0))
243
237
add %o0, 0x40, %o0
244
238
add %o1, 0x40, %o1
245
239
membar #Sync
···
259
253
260
254
sub %o2, %g2, %o2
261
255
be,a,pt %XCC, 1f
262
-
EX_LD(LOAD(ldd, %o1 + 0x00, %f0))
256
+
EX_LD_FP(LOAD(ldd, %o1 + 0x00, %f0))
263
257
264
-
1: EX_LD(LOAD(ldd, %o1 + 0x08, %f2))
258
+
1: EX_LD_FP(LOAD(ldd, %o1 + 0x08, %f2))
265
259
add %o1, 0x8, %o1
266
260
subcc %g2, 0x8, %g2
267
261
faligndata %f0, %f2, %f8
268
-
EX_ST(STORE(std, %f8, %o0))
262
+
EX_ST_FP(STORE(std, %f8, %o0))
269
263
be,pn %XCC, 2f
270
264
add %o0, 0x8, %o0
271
-
EX_LD(LOAD(ldd, %o1 + 0x08, %f0))
265
+
EX_LD_FP(LOAD(ldd, %o1 + 0x08, %f0))
272
266
add %o1, 0x8, %o1
273
267
subcc %g2, 0x8, %g2
274
268
faligndata %f2, %f0, %f8
275
-
EX_ST(STORE(std, %f8, %o0))
269
+
EX_ST_FP(STORE(std, %f8, %o0))
276
270
bne,pn %XCC, 1b
277
271
add %o0, 0x8, %o0
278
272
+7
-5
drivers/tty/serial/sunhv.c
+7
-5
drivers/tty/serial/sunhv.c
···
148
148
uart_handle_dcd_change(port, 1);
149
149
}
150
150
151
-
for (i = 0; i < bytes_read; i++)
152
-
uart_handle_sysrq_char(port, con_read_page[i]);
151
+
if (port->sysrq != 0 && *con_read_page) {
152
+
for (i = 0; i < bytes_read; i++)
153
+
uart_handle_sysrq_char(port, con_read_page[i]);
154
+
}
153
155
154
156
if (port->state == NULL)
155
157
continue;
···
170
168
int (*receive_chars)(struct uart_port *port);
171
169
};
172
170
173
-
static struct sunhv_ops bychar_ops = {
171
+
static const struct sunhv_ops bychar_ops = {
174
172
.transmit_chars = transmit_chars_putchar,
175
173
.receive_chars = receive_chars_getchar,
176
174
};
177
175
178
-
static struct sunhv_ops bywrite_ops = {
176
+
static const struct sunhv_ops bywrite_ops = {
179
177
.transmit_chars = transmit_chars_write,
180
178
.receive_chars = receive_chars_read,
181
179
};
182
180
183
-
static struct sunhv_ops *sunhv_ops = &bychar_ops;
181
+
static const struct sunhv_ops *sunhv_ops = &bychar_ops;
184
182
185
183
static struct tty_port *receive_chars(struct uart_port *port)
186
184
{