← Back to branch summary

~ubuntu-branches/ubuntu/quantal/linux-linaro-mx51/quantal

« back to all changes in this revision

Viewing changes to arch/tile/kernel/signal.c

  • Committer: Package Import Robot
  • Author(s): John Rigby, John Rigby
  • Date: 2011-09-26 10:44:23 UTC
  • Revision ID: package-import@ubuntu.com-20110926104423-3o58a3c1bj7x00rs
Tags: 3.0.0-1007.9
https://launchpad.net/bugs/826021
[ John Rigby ]

Enable crypto modules and remove crypto-modules from
exclude-module files
LP: #826021

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/tile/kernel/signal.c
39
39
 
40
40
#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
41
41
 
42
 
 
43
42
SYSCALL_DEFINE3(sigaltstack, const stack_t __user *, uss,
44
43
                stack_t __user *, uoss, struct pt_regs *, regs)
45
44
{
78
77
        return err;
79
78
}
80
79
 
 
80
void signal_fault(const char *type, struct pt_regs *regs,
 
81
                  void __user *frame, int sig)
 
82
{
 
83
        trace_unhandled_signal(type, regs, (unsigned long)frame, SIGSEGV);
 
84
        force_sigsegv(sig, current);
 
85
}
 
86
 
81
87
/* The assembly shim for this function arranges to ignore the return value. */
82
88
SYSCALL_DEFINE1(rt_sigreturn, struct pt_regs *, regs)
83
89
{
105
111
        return 0;
106
112
 
107
113
badframe:
108
 
        force_sig(SIGSEGV, current);
 
114
        signal_fault("bad sigreturn frame", regs, frame, 0);
109
115
        return 0;
110
116
}
111
117
 
231
237
        return 0;
232
238
 
233
239
give_sigsegv:
234
 
        force_sigsegv(sig, current);
 
240
        signal_fault("bad setup frame", regs, frame, sig);
235
241
        return -EFAULT;
236
242
}
237
243
 
245
251
{
246
252
        int ret;
247
253
 
248
 
 
249
254
        /* Are we from a system call? */
250
255
        if (regs->faultnum == INT_SWINT_1) {
251
256
                /* If so, check system call restarting.. */
363
368
        /* Avoid double syscall restart if there are nested signals. */
364
369
        regs->faultnum = INT_SWINT_1_SIGRETURN;
365
370
}
 
371
 
 
372
int show_unhandled_signals = 1;
 
373
 
 
374
static int __init crashinfo(char *str)
 
375
{
 
376
        unsigned long val;
 
377
        const char *word;
 
378
 
 
379
        if (*str == '\0')
 
380
                val = 2;
 
381
        else if (*str != '=' || strict_strtoul(++str, 0, &val) != 0)
 
382
                return 0;
 
383
        show_unhandled_signals = val;
 
384
        switch (show_unhandled_signals) {
 
385
        case 0:
 
386
                word = "No";
 
387
                break;
 
388
        case 1:
 
389
                word = "One-line";
 
390
                break;
 
391
        default:
 
392
                word = "Detailed";
 
393
                break;
 
394
        }
 
395
        pr_info("%s crash reports will be generated on the console\n", word);
 
396
        return 1;
 
397
}
 
398
__setup("crashinfo", crashinfo);
 
399
 
 
400
static void dump_mem(void __user *address)
 
401
{
 
402
        void __user *addr;
 
403
        enum { region_size = 256, bytes_per_line = 16 };
 
404
        int i, j, k;
 
405
        int found_readable_mem = 0;
 
406
 
 
407
        pr_err("\n");
 
408
        if (!access_ok(VERIFY_READ, address, 1)) {
 
409
                pr_err("Not dumping at address 0x%lx (kernel address)\n",
 
410
                       (unsigned long)address);
 
411
                return;
 
412
        }
 
413
 
 
414
        addr = (void __user *)
 
415
                (((unsigned long)address & -bytes_per_line) - region_size/2);
 
416
        if (addr > address)
 
417
                addr = NULL;
 
418
        for (i = 0; i < region_size;
 
419
             addr += bytes_per_line, i += bytes_per_line) {
 
420
                unsigned char buf[bytes_per_line];
 
421
                char line[100];
 
422
                if (copy_from_user(buf, addr, bytes_per_line))
 
423
                        continue;
 
424
                if (!found_readable_mem) {
 
425
                        pr_err("Dumping memory around address 0x%lx:\n",
 
426
                               (unsigned long)address);
 
427
                        found_readable_mem = 1;
 
428
                }
 
429
                j = sprintf(line, REGFMT":", (unsigned long)addr);
 
430
                for (k = 0; k < bytes_per_line; ++k)
 
431
                        j += sprintf(&line[j], " %02x", buf[k]);
 
432
                pr_err("%s\n", line);
 
433
        }
 
434
        if (!found_readable_mem)
 
435
                pr_err("No readable memory around address 0x%lx\n",
 
436
                       (unsigned long)address);
 
437
}
 
438
 
 
439
void trace_unhandled_signal(const char *type, struct pt_regs *regs,
 
440
                            unsigned long address, int sig)
 
441
{
 
442
        struct task_struct *tsk = current;
 
443
 
 
444
        if (show_unhandled_signals == 0)
 
445
                return;
 
446
 
 
447
        /* If the signal is handled, don't show it here. */
 
448
        if (!is_global_init(tsk)) {
 
449
                void __user *handler =
 
450
                        tsk->sighand->action[sig-1].sa.sa_handler;
 
451
                if (handler != SIG_IGN && handler != SIG_DFL)
 
452
                        return;
 
453
        }
 
454
 
 
455
        /* Rate-limit the one-line output, not the detailed output. */
 
456
        if (show_unhandled_signals <= 1 && !printk_ratelimit())
 
457
                return;
 
458
 
 
459
        printk("%s%s[%d]: %s at %lx pc "REGFMT" signal %d",
 
460
               task_pid_nr(tsk) > 1 ? KERN_INFO : KERN_EMERG,
 
461
               tsk->comm, task_pid_nr(tsk), type, address, regs->pc, sig);
 
462
 
 
463
        print_vma_addr(KERN_CONT " in ", regs->pc);
 
464
 
 
465
        printk(KERN_CONT "\n");
 
466
 
 
467
        if (show_unhandled_signals > 1) {
 
468
                switch (sig) {
 
469
                case SIGILL:
 
470
                case SIGFPE:
 
471
                case SIGSEGV:
 
472
                case SIGBUS:
 
473
                        pr_err("User crash: signal %d,"
 
474
                               " trap %ld, address 0x%lx\n",
 
475
                               sig, regs->faultnum, address);
 
476
                        show_regs(regs);
 
477
                        dump_mem((void __user *)address);
 
478
                        break;
 
479
                default:
 
480
                        pr_err("User crash: signal %d, trap %ld\n",
 
481
                               sig, regs->faultnum);
 
482
                        break;
 
483
                }
 
484
        }
 
485
}