signal.c 13.7 KB
Newer Older
1
/*
2
 * arch/xtensa/kernel/signal.c
3
 *
4
 * Default platform functions.
5
 *
6
7
8
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
9
 *
10
11
12
 * Copyright (C) 2005, 2006 Tensilica Inc.
 * Copyright (C) 1991, 1992  Linus Torvalds
 * 1997-11-28  Modified for POSIX.1b signals by Richard Henderson
13
 *
14
15
 * Chris Zankel <chris@zankel.net>
 * Joe Taylor <joe@tensilica.com>
16
17
18
19
20
21
 */

#include <linux/signal.h>
#include <linux/errno.h>
#include <linux/ptrace.h>
#include <linux/personality.h>
22
23
#include <linux/freezer.h>

24
25
26
#include <asm/ucontext.h>
#include <asm/uaccess.h>
#include <asm/cacheflush.h>
27
28
#include <asm/coprocessor.h>
#include <asm/unistd.h>
29
30
31
32
33
34
35
36
37

#define DEBUG_SIG  0

#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))

asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset);

extern struct task_struct *coproc_owners[];

38
39
40
41
struct rt_sigframe
{
	struct siginfo info;
	struct ucontext uc;
42
43
44
45
46
47
48
	struct {
		xtregs_opt_t opt;
		xtregs_user_t user;
#if XTENSA_HAVE_COPROCESSORS
		xtregs_coprocessor_t cp;
#endif
	} xtregs;
49
50
51
52
53
54
55
	unsigned char retcode[6];
	unsigned int window[4];
};

/* 
 * Flush register windows stored in pt_regs to stack.
 * Returns 1 for errors.
56
57
 */

58
59
int
flush_window_regs_user(struct pt_regs *regs)
60
{
61
62
63
64
65
66
	const unsigned long ws = regs->windowstart;
	const unsigned long wb = regs->windowbase;
	unsigned long sp = 0;
	unsigned long wm;
	int err = 1;
	int base;
67

68
	/* Return if no other frames. */
69

70
71
	if (regs->wmask == 1)
		return 0;
72

73
	/* Rotate windowmask and skip empty frames. */
74

75
76
77
78
	wm = (ws >> wb) | (ws << (XCHAL_NUM_AREGS / 4 - wb));
	base = (XCHAL_NUM_AREGS / 4) - (regs->wmask >> 4);
		
	/* For call8 or call12 frames, we need the previous stack pointer. */
79

80
81
82
	if ((regs->wmask & 2) == 0)
		if (__get_user(sp, (int*)(regs->areg[base * 4 + 1] - 12)))
			goto errout;
83

84
	/* Spill frames to stack. */
85

86
	while (base < XCHAL_NUM_AREGS / 4) {
87

88
89
		int m = (wm >> base);
		int inc = 0;
90

91
		/* Save registers a4..a7 (call8) or a4...a11 (call12) */
92

93
94
		if (m & 2) {			/* call4 */
			inc = 1;
95

96
97
98
99
100
		} else if (m & 4) {		/* call8 */
			if (copy_to_user((void*)(sp - 32),
					   &regs->areg[(base + 1) * 4], 16))
				goto errout;
			inc = 2;
101

102
103
104
105
106
107
		} else if (m & 8) {	/* call12 */
			if (copy_to_user((void*)(sp - 48),
					   &regs->areg[(base + 1) * 4], 32))
				goto errout;
			inc = 3;
		}
108

109
		/* Save current frame a0..a3 under next SP */
110

111
112
113
114
115
116
117
118
119
120
		sp = regs->areg[((base + inc) * 4 + 1) % XCHAL_NUM_AREGS];
		if (copy_to_user((void*)(sp - 16), &regs->areg[base * 4], 16))
			goto errout;

		/* Get current stack pointer for next loop iteration. */

		sp = regs->areg[base * 4 + 1];
		base += inc;
	}

121
122
123
	regs->wmask = 1;
	regs->windowstart = 1 << wb;

124
	return 0;
125

126
127
128
errout:
	return err;
}
129
130

/*
131
132
133
134
135
 * Note: We don't copy double exception 'regs', we have to finish double exc. 
 * first before we return to signal handler! This dbl.exc.handler might cause 
 * another double exception, but I think we are fine as the situation is the 
 * same as if we had returned to the signal handerl and got an interrupt 
 * immediately...
136
137
 */

138
static int
139
setup_sigcontext(struct rt_sigframe __user *frame, struct pt_regs *regs)
140
{
141
142
	struct sigcontext __user *sc = &frame->uc.uc_mcontext;
	struct thread_info *ti = current_thread_info();
143
	int err = 0;
144

145
146
147
148
149
150
151
152
#define COPY(x)	err |= __put_user(regs->x, &sc->sc_##x)
	COPY(pc);
	COPY(ps);
	COPY(lbeg);
	COPY(lend);
	COPY(lcount);
	COPY(sar);
#undef COPY
153

154
155
	err |= flush_window_regs_user(regs);
	err |= __copy_to_user (sc->sc_a, regs->areg, 16 * 4);
156
	err |= __put_user(0, &sc->sc_xtregs);
157

158
159
	if (err)
		return err;
160

161
162
163
164
165
#if XTENSA_HAVE_COPROCESSORS
	coprocessor_flush_all(ti);
	coprocessor_release_all(ti);
	err |= __copy_to_user(&frame->xtregs.cp, &ti->xtregs_cp,
			      sizeof (frame->xtregs.cp));
166
#endif
167
168
169
170
171
172
	err |= __copy_to_user(&frame->xtregs.opt, &regs->xtregs_opt,
			      sizeof (xtregs_opt_t));
	err |= __copy_to_user(&frame->xtregs.user, &ti->xtregs_user,
			      sizeof (xtregs_user_t));

	err |= __put_user(err ? NULL : &frame->xtregs, &sc->sc_xtregs);
173

174
175
	return err;
}
176
177

static int
178
restore_sigcontext(struct pt_regs *regs, struct rt_sigframe __user *frame)
179
{
180
181
	struct sigcontext __user *sc = &frame->uc.uc_mcontext;
	struct thread_info *ti = current_thread_info();
182
183
184
185
186
187
188
189
190
191
192
	unsigned int err = 0;
	unsigned long ps;

#define COPY(x)	err |= __get_user(regs->x, &sc->sc_##x)
	COPY(pc);
	COPY(lbeg);
	COPY(lend);
	COPY(lcount);
	COPY(sar);
#undef COPY

193
194
195
196
197
198
	/* All registers were flushed to stack. Start with a prestine frame. */

	regs->wmask = 1;
	regs->windowbase = 0;
	regs->windowstart = 1;

199
200
	regs->syscall = -1;		/* disable syscall checks */

201
202
203
204
205
	/* For PS, restore only PS.CALLINC.
	 * Assume that all other bits are either the same as for the signal
	 * handler, or the user mode value doesn't matter (e.g. PS.OWB).
	 */
	err |= __get_user(ps, &sc->sc_ps);
206
	regs->ps = (regs->ps & ~PS_CALLINC_MASK) | (ps & PS_CALLINC_MASK);
207
208
209
210

	/* Additional corruption checks */

	if ((regs->lcount > 0)
211
	    && ((regs->lbeg > TASK_SIZE) || (regs->lend > TASK_SIZE)) )
212
213
		err = 1;

214
	err |= __copy_from_user(regs->areg, sc->sc_a, 16 * 4);
215

216
217
218
	if (err)
		return err;

219
220
221
222
223
224
 	/* The signal handler may have used coprocessors in which
	 * case they are still enabled.  We disable them to force a
	 * reloading of the original task's CP state by the lazy
	 * context-switching mechanisms of CP exception handling.
	 * Also, we essentially discard any coprocessor state that the
	 * signal handler created. */
225

226
227
228
229
#if XTENSA_HAVE_COPROCESSORS
	coprocessor_release_all(ti);
	err |= __copy_from_user(&ti->xtregs_cp, &frame->xtregs.cp,
				sizeof (frame->xtregs.cp));
230
#endif
231
232
233
234
	err |= __copy_from_user(&ti->xtregs_user, &frame->xtregs.user,
				sizeof (xtregs_user_t));
	err |= __copy_from_user(&regs->xtregs_opt, &frame->xtregs.opt,
				sizeof (xtregs_opt_t));
235
236
237
238
239

	return err;
}


240
241
242
/*
 * Do a signal return; undo the signal stack.
 */
243

244
245
asmlinkage long xtensa_rt_sigreturn(long a0, long a1, long a2, long a3,
				    long a4, long a5, struct pt_regs *regs)
246
{
247
	struct rt_sigframe __user *frame;
248
249
	sigset_t set;
	int ret;
250

251
	if (regs->depc > 64)
252
253
254
		panic("rt_sigreturn in double exception!\n");

	frame = (struct rt_sigframe __user *) regs->areg[1];
255

256
	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
257
258
259
260
261
262
263
264
265
266
267
		goto badframe;

	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
		goto badframe;

	sigdelsetmask(&set, ~_BLOCKABLE);
	spin_lock_irq(&current->sighand->siglock);
	current->blocked = set;
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);

268
	if (restore_sigcontext(regs, frame))
269
		goto badframe;
270

271
272
	ret = regs->areg[2];

273
	if (do_sigaltstack(&frame->uc.uc_stack, NULL, regs->areg[1]) == -EFAULT)
274
275
276
277
278
279
280
281
282
		goto badframe;

	return ret;

badframe:
	force_sig(SIGSEGV, current);
	return 0;
}

283

284
285

/*
286
 * Set up a signal frame.
287
288
289
 */

static int
290
gen_return_code(unsigned char *codemem)
291
292
293
{
	int err = 0;

294
295
296
297
298
	/*
	 * The 12-bit immediate is really split up within the 24-bit MOVI
	 * instruction.  As long as the above system call numbers fit within
	 * 8-bits, the following code works fine. See the Xtensa ISA for
	 * details.
299
300
	 */

301
302
#if __NR_rt_sigreturn > 255
# error Generating the MOVI instruction below breaks!
303
304
305
#endif

#ifdef __XTENSA_EB__   /* Big Endian version */
306
307
308
309
310
311
312
313
	/* Generate instruction:  MOVI a2, __NR_rt_sigreturn */
	err |= __put_user(0x22, &codemem[0]);
	err |= __put_user(0x0a, &codemem[1]);
	err |= __put_user(__NR_rt_sigreturn, &codemem[2]);
	/* Generate instruction:  SYSCALL */
	err |= __put_user(0x00, &codemem[3]);
	err |= __put_user(0x05, &codemem[4]);
	err |= __put_user(0x00, &codemem[5]);
314
315

#elif defined __XTENSA_EL__   /* Little Endian version */
316
317
318
319
320
321
322
323
	/* Generate instruction:  MOVI a2, __NR_rt_sigreturn */
	err |= __put_user(0x22, &codemem[0]);
	err |= __put_user(0xa0, &codemem[1]);
	err |= __put_user(__NR_rt_sigreturn, &codemem[2]);
	/* Generate instruction:  SYSCALL */
	err |= __put_user(0x00, &codemem[3]);
	err |= __put_user(0x50, &codemem[4]);
	err |= __put_user(0x00, &codemem[5]);
324
#else
325
# error Must use compiler for Xtensa processors.
326
327
328
329
#endif

	/* Flush generated code out of the data cache */

330
331
332
333
	if (err == 0) {
		__invalidate_icache_range((unsigned long)codemem, 6UL);
		__flush_invalidate_dcache_range((unsigned long)codemem, 6UL);
	}
334
335
336
337
338

	return err;
}


339
static void setup_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
340
341
			sigset_t *set, struct pt_regs *regs)
{
342
	struct rt_sigframe *frame;
343
344
	int err = 0;
	int signal;
345
	unsigned long sp, ra;
346

347
	sp = regs->areg[1];
348

349
350
	if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! on_sig_stack(sp)) {
		sp = current->sas_ss_sp + current->sas_ss_size;
351
352
	}

353
	frame = (void *)((sp - sizeof(*frame)) & -16ul);
354
355
356
357

	if (regs->depc > 64)
		panic ("Double exception sys_sigreturn\n");

358
	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) {
359
		goto give_sigsegv;
360
	}
361
362
363
364
365
366
367

	signal = current_thread_info()->exec_domain
		&& current_thread_info()->exec_domain->signal_invmap
		&& sig < 32
		? current_thread_info()->exec_domain->signal_invmap[sig]
		: sig;

368
369
370
371
372
	if (ka->sa.sa_flags & SA_SIGINFO) {
		err |= copy_siginfo_to_user(&frame->info, info);
	}

	/* Create the user context.  */
373
374
375
376
377
378
379
380

	err |= __put_user(0, &frame->uc.uc_flags);
	err |= __put_user(0, &frame->uc.uc_link);
	err |= __put_user((void *)current->sas_ss_sp,
			  &frame->uc.uc_stack.ss_sp);
	err |= __put_user(sas_ss_flags(regs->areg[1]),
			  &frame->uc.uc_stack.ss_flags);
	err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
381
	err |= setup_sigcontext(frame, regs);
382
383
	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));

384
385
386
	if (ka->sa.sa_flags & SA_RESTORER) {
		ra = (unsigned long)ka->sa.sa_restorer;
	} else {
387

388
		/* Create sys_rt_sigreturn syscall in stack frame */
389

390
391
392
393
394
395
		err |= gen_return_code(frame->retcode);

		if (err) {
			goto give_sigsegv;
		}
		ra = (unsigned long) frame->retcode;
396
	}
397

398
399
	/* 
	 * Create signal handler execution context.
400
401
	 * Return context not modified until this point.
	 */
402
403
404
405
406
407
408
409
410
411
412
413

	/* Set up registers for signal handler */
	start_thread(regs, (unsigned long) ka->sa.sa_handler, 
		     (unsigned long) frame);

	/* Set up a stack frame for a call4
	 * Note: PS.CALLINC is set to one by start_thread
	 */
	regs->areg[4] = (((unsigned long) ra) & 0x3fffffff) | 0x40000000;
	regs->areg[6] = (unsigned long) signal;
	regs->areg[7] = (unsigned long) &frame->info;
	regs->areg[8] = (unsigned long) &frame->uc;
414
415
416
417
418
419
420
421
422
423
424
425
426
427

	/* Set access mode to USER_DS.  Nomenclature is outdated, but
	 * functionality is used in uaccess.h
	 */
	set_fs(USER_DS);

#if DEBUG_SIG
	printk("SIG rt deliver (%s:%d): signal=%d sp=%p pc=%08x\n",
		current->comm, current->pid, signal, frame, regs->pc);
#endif

	return;

give_sigsegv:
428
	force_sigsegv(sig, current);
429
430
}

431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
/*
 * Atomically swap in the new signal mask, and wait for a signal.
 */

asmlinkage long xtensa_rt_sigsuspend(sigset_t __user *unewset, 
    				     size_t sigsetsize,
    				     long a2, long a3, long a4, long a5, 
				     struct pt_regs *regs)
{
	sigset_t saveset, newset;

	/* XXX: Don't preclude handling different sized sigset_t's.  */
	if (sigsetsize != sizeof(sigset_t))
		return -EINVAL;

	if (copy_from_user(&newset, unewset, sizeof(newset)))
		return -EFAULT;

	sigdelsetmask(&newset, ~_BLOCKABLE);
	spin_lock_irq(&current->sighand->siglock);
	saveset = current->blocked;
	current->blocked = newset;
	recalc_sigpending();
	spin_unlock_irq(&current->sighand->siglock);

	regs->areg[2] = -EINTR;
	while (1) {
		current->state = TASK_INTERRUPTIBLE;
		schedule();
		if (do_signal(regs, &saveset))
			return -EINTR;
	}
}

asmlinkage long xtensa_sigaltstack(const stack_t __user *uss, 
				   stack_t __user *uoss,
    				   long a2, long a3, long a4, long a5,
				   struct pt_regs *regs)
{
	return do_sigaltstack(uss, uoss, regs->areg[1]);
}

473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489


/*
 * Note that 'init' is a special process: it doesn't get signals it doesn't
 * want to handle. Thus you cannot kill init even with a SIGKILL even by
 * mistake.
 *
 * Note that we go through the signals twice: once to check the signals that
 * the kernel can handle, and then we build all the user-level signal handling
 * stack-frames in one go after that.
 */
int do_signal(struct pt_regs *regs, sigset_t *oldset)
{
	siginfo_t info;
	int signr;
	struct k_sigaction ka;

490
491
492
493
494
495
	if (!user_mode(regs))
		return 0;

	if (try_to_freeze())
		goto no_signal;

496
497
498
	if (!oldset)
		oldset = &current->blocked;

499
500
	task_pt_regs(current)->icountlevel = 0;

501
502
	signr = get_signal_to_deliver(&info, &ka, regs, NULL);

503
504
505
506
507
	if (signr > 0) {

		/* Are we from a system call? */

		if ((signed)regs->syscall >= 0) {
508

509
510
511
512
513
			/* If so, check system call restarting.. */

			switch (regs->areg[2]) {
				case -ERESTARTNOHAND:
				case -ERESTART_RESTARTBLOCK:
514
515
					regs->areg[2] = -EINTR;
					break;
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532

				case -ERESTARTSYS:
					if (!(ka.sa.sa_flags & SA_RESTART)) {
						regs->areg[2] = -EINTR;
						break;
					}
					/* fallthrough */
				case -ERESTARTNOINTR:
					regs->areg[2] = regs->syscall;
					regs->pc -= 3;
					break;

				default:
					/* nothing to do */
					if (regs->areg[2] != 0)
					break;
			}
533
534
		}

535
536
537
		/* Whee!  Actually deliver the signal.  */
		/* Set up the stack frame */
		setup_frame(signr, &ka, &info, oldset, regs);
538

539
540
541
542
543
544
545
546
		spin_lock_irq(&current->sighand->siglock);
		sigorsets(&current->blocked, &current->blocked, &ka.sa.sa_mask);
		if (!(ka.sa.sa_flags & SA_NODEFER))
			sigaddset(&current->blocked, signr);
		recalc_sigpending();
		spin_unlock_irq(&current->sighand->siglock);
		if (current->ptrace & PT_SINGLESTEP)
			task_pt_regs(current)->icountlevel = 1;
547

548
549
		return 1;
	}
550

551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
no_signal:
	/* Did we come from a system call? */
	if ((signed) regs->syscall >= 0) {
		/* Restart the system call - no handlers present */
		switch (regs->areg[2]) {
		case -ERESTARTNOHAND:
		case -ERESTARTSYS:
		case -ERESTARTNOINTR:
			regs->areg[2] = regs->syscall;
			regs->pc -= 3;
			break;
		case -ERESTART_RESTARTBLOCK:
			regs->areg[2] = __NR_restart_syscall;
			regs->pc -= 3;
			break;
		}
	}
	if (current->ptrace & PT_SINGLESTEP)
		task_pt_regs(current)->icountlevel = 1;
	return 0;
571
}
572