← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-linaro-u8500/trusty

« back to all changes in this revision

Viewing changes to arch/sh/kernel/ptrace_32.c

  • Committer: Bazaar Package Importer
  • Author(s): John Rigby, Upstream Fixes, Andy Green, John Rigby
  • Date: 2011-04-14 12:16:06 UTC
  • Revision ID: james.westby@ubuntu.com-20110414121606-b77podkyqgr2oix7
Tags: 2.6.38-1002.3
https://launchpad.net/bugs/745737
https://launchpad.net/bugs/747639
https://launchpad.net/bugs/752900
https://launchpad.net/bugs/745737
https://launchpad.net/bugs/732842
https://launchpad.net/bugs/732912
[ Upstream Fixes ]

* MUSB: shutdown: Make sure block is awake before doing shutdown
  - LP: #745737
* Fixed gpio polarity of gpio USB-phy reset.
  - LP: #747639

[ Andy Green ]

* LINARO: SAUCE: disable CONFIG_OMAP_RESET_CLOCKS
  - LP: #752900

[ John Rigby ]

* Rebase to new upstreams:
  Linux v2.6.38.1
  linaro-linux-2.6.38-upstream-29Mar2011
  Ubuntu-2.6.38-7.35
* SAUCE: OMAP4: clock: wait for module to become accessible on
  a clk enable
  - LP: #745737
* Rebase to new upstreams:
  Linux v2.6.38.2
  linaro-linux-2.6.38-upstream-5Apr2011
  Ubuntu-2.6.38-8.41
  - LP: #732842
* Update configs for device tree, dvfs and lttng
* LINARO: add building of dtb's
* LINARO: SAUCE: Disable lowest operating freqs on omap34xx
  - LP: #732912

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/sh/kernel/ptrace_32.c
26
26
#include <linux/elf.h>
27
27
#include <linux/regset.h>
28
28
#include <linux/hw_breakpoint.h>
 
29
#include <linux/module.h>
 
30
#include <linux/kallsyms.h>
 
31
#include <linux/marker.h>
 
32
#include <trace/syscall.h>
29
33
#include <asm/uaccess.h>
30
34
#include <asm/pgtable.h>
31
35
#include <asm/system.h>
33
37
#include <asm/mmu_context.h>
34
38
#include <asm/syscalls.h>
35
39
#include <asm/fpu.h>
 
40
#include <asm/unistd.h>
36
41
 
37
42
#define CREATE_TRACE_POINTS
38
43
#include <trace/events/syscalls.h>
39
44
 
 
45
DEFINE_TRACE(syscall_entry);
 
46
DEFINE_TRACE(syscall_exit);
 
47
 
 
48
extern unsigned long sys_call_table[];
 
49
void ltt_dump_sys_call_table(void *call_data)
 
50
{
 
51
        int i;
 
52
        char namebuf[KSYM_NAME_LEN];
 
53
 
 
54
        for (i = 0; i < NR_syscalls; i++) {
 
55
                sprint_symbol(namebuf, sys_call_table[i]);
 
56
                __trace_mark(0, syscall_state, sys_call_table, call_data,
 
57
                        "id %d address %p symbol %s",
 
58
                        i, (void *)sys_call_table[i], namebuf);
 
59
        }
 
60
}
 
61
EXPORT_SYMBOL_GPL(ltt_dump_sys_call_table);
 
62
 
 
63
void ltt_dump_idt_table(void *call_data)
 
64
{
 
65
}
 
66
EXPORT_SYMBOL_GPL(ltt_dump_idt_table);
 
67
 
40
68
/*
41
69
 * This routine will get a word off of the process kernel stack.
42
70
 */
101
129
 
102
130
                attr = bp->attr;
103
131
                attr.bp_addr = addr;
 
132
                /* reenable breakpoint */
 
133
                attr.disabled = false;
104
134
                err = modify_user_hw_breakpoint(bp, &attr);
105
135
                if (unlikely(err))
106
136
                        return err;
392
422
                                        tmp = 0;
393
423
                        } else {
394
424
                                unsigned long index;
 
425
                                ret = init_fpu(child);
 
426
                                if (ret)
 
427
                                        break;
395
428
                                index = addr - offsetof(struct user, fpu);
396
429
                                tmp = ((unsigned long *)child->thread.xstate)
397
430
                                        [index >> 2];
423
456
                else if (addr >= offsetof(struct user, fpu) &&
424
457
                         addr < offsetof(struct user, u_fpvalid)) {
425
458
                        unsigned long index;
 
459
                        ret = init_fpu(child);
 
460
                        if (ret)
 
461
                                break;
426
462
                        index = addr - offsetof(struct user, fpu);
427
463
                        set_stopped_child_used_math(child);
428
464
                        ((unsigned long *)child->thread.xstate)
491
527
{
492
528
        long ret = 0;
493
529
 
 
530
        trace_syscall_entry(regs, regs->regs[3]);
 
531
 
494
532
        secure_computing(regs->regs[0]);
495
533
 
496
534
        if (test_thread_flag(TIF_SYSCALL_TRACE) &&
517
555
{
518
556
        int step;
519
557
 
 
558
        trace_syscall_exit(regs->regs[0]);
 
559
 
520
560
        if (unlikely(current->audit_context))
521
561
                audit_syscall_exit(AUDITSC_RESULT(regs->regs[0]),
522
562
                                   regs->regs[0]);