|
|
@@ -581,153 +581,73 @@ static int ioperm_get(struct task_struct *target,
|
|
|
}
|
|
|
|
|
|
#ifdef CONFIG_X86_PTRACE_BTS
|
|
|
-/*
|
|
|
- * The configuration for a particular BTS hardware implementation.
|
|
|
- */
|
|
|
-struct bts_configuration {
|
|
|
- /* the size of a BTS record in bytes; at most BTS_MAX_RECORD_SIZE */
|
|
|
- unsigned char sizeof_bts;
|
|
|
- /* the size of a field in the BTS record in bytes */
|
|
|
- unsigned char sizeof_field;
|
|
|
- /* a bitmask to enable/disable BTS in DEBUGCTL MSR */
|
|
|
- unsigned long debugctl_mask;
|
|
|
-};
|
|
|
-static struct bts_configuration bts_cfg;
|
|
|
-
|
|
|
-#define BTS_MAX_RECORD_SIZE (8 * 3)
|
|
|
-
|
|
|
-
|
|
|
-/*
|
|
|
- * Branch Trace Store (BTS) uses the following format. Different
|
|
|
- * architectures vary in the size of those fields.
|
|
|
- * - source linear address
|
|
|
- * - destination linear address
|
|
|
- * - flags
|
|
|
- *
|
|
|
- * Later architectures use 64bit pointers throughout, whereas earlier
|
|
|
- * architectures use 32bit pointers in 32bit mode.
|
|
|
- *
|
|
|
- * We compute the base address for the first 8 fields based on:
|
|
|
- * - the field size stored in the DS configuration
|
|
|
- * - the relative field position
|
|
|
- *
|
|
|
- * In order to store additional information in the BTS buffer, we use
|
|
|
- * a special source address to indicate that the record requires
|
|
|
- * special interpretation.
|
|
|
- *
|
|
|
- * Netburst indicated via a bit in the flags field whether the branch
|
|
|
- * was predicted; this is ignored.
|
|
|
- */
|
|
|
-
|
|
|
-enum bts_field {
|
|
|
- bts_from = 0,
|
|
|
- bts_to,
|
|
|
- bts_flags,
|
|
|
-
|
|
|
- bts_escape = (unsigned long)-1,
|
|
|
- bts_qual = bts_to,
|
|
|
- bts_jiffies = bts_flags
|
|
|
-};
|
|
|
-
|
|
|
-static inline unsigned long bts_get(const char *base, enum bts_field field)
|
|
|
-{
|
|
|
- base += (bts_cfg.sizeof_field * field);
|
|
|
- return *(unsigned long *)base;
|
|
|
-}
|
|
|
-
|
|
|
-static inline void bts_set(char *base, enum bts_field field, unsigned long val)
|
|
|
-{
|
|
|
- base += (bts_cfg.sizeof_field * field);;
|
|
|
- (*(unsigned long *)base) = val;
|
|
|
-}
|
|
|
-
|
|
|
-/*
|
|
|
- * Translate a BTS record from the raw format into the bts_struct format
|
|
|
- *
|
|
|
- * out (out): bts_struct interpretation
|
|
|
- * raw: raw BTS record
|
|
|
- */
|
|
|
-static void ptrace_bts_translate_record(struct bts_struct *out, const void *raw)
|
|
|
-{
|
|
|
- memset(out, 0, sizeof(*out));
|
|
|
- if (bts_get(raw, bts_from) == bts_escape) {
|
|
|
- out->qualifier = bts_get(raw, bts_qual);
|
|
|
- out->variant.jiffies = bts_get(raw, bts_jiffies);
|
|
|
- } else {
|
|
|
- out->qualifier = BTS_BRANCH;
|
|
|
- out->variant.lbr.from_ip = bts_get(raw, bts_from);
|
|
|
- out->variant.lbr.to_ip = bts_get(raw, bts_to);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
static int ptrace_bts_read_record(struct task_struct *child, size_t index,
|
|
|
struct bts_struct __user *out)
|
|
|
{
|
|
|
- struct bts_struct ret;
|
|
|
- const void *bts_record;
|
|
|
- size_t bts_index, bts_end;
|
|
|
+ const struct bts_trace *trace;
|
|
|
+ struct bts_struct bts;
|
|
|
+ const unsigned char *at;
|
|
|
int error;
|
|
|
|
|
|
- error = ds_get_bts_end(child->bts, &bts_end);
|
|
|
- if (error < 0)
|
|
|
- return error;
|
|
|
-
|
|
|
- if (bts_end <= index)
|
|
|
- return -EINVAL;
|
|
|
+ trace = ds_read_bts(child->bts);
|
|
|
+ if (!trace)
|
|
|
+ return -EPERM;
|
|
|
|
|
|
- error = ds_get_bts_index(child->bts, &bts_index);
|
|
|
- if (error < 0)
|
|
|
- return error;
|
|
|
+ at = trace->ds.top - ((index + 1) * trace->ds.size);
|
|
|
+ if ((void *)at < trace->ds.begin)
|
|
|
+ at += (trace->ds.n * trace->ds.size);
|
|
|
|
|
|
- /* translate the ptrace bts index into the ds bts index */
|
|
|
- bts_index += bts_end - (index + 1);
|
|
|
- if (bts_end <= bts_index)
|
|
|
- bts_index -= bts_end;
|
|
|
+ if (!trace->read)
|
|
|
+ return -EOPNOTSUPP;
|
|
|
|
|
|
- error = ds_access_bts(child->bts, bts_index, &bts_record);
|
|
|
+ error = trace->read(child->bts, at, &bts);
|
|
|
if (error < 0)
|
|
|
return error;
|
|
|
|
|
|
- ptrace_bts_translate_record(&ret, bts_record);
|
|
|
-
|
|
|
- if (copy_to_user(out, &ret, sizeof(ret)))
|
|
|
+ if (copy_to_user(out, &bts, sizeof(bts)))
|
|
|
return -EFAULT;
|
|
|
|
|
|
- return sizeof(ret);
|
|
|
+ return sizeof(bts);
|
|
|
}
|
|
|
|
|
|
static int ptrace_bts_drain(struct task_struct *child,
|
|
|
long size,
|
|
|
struct bts_struct __user *out)
|
|
|
{
|
|
|
- struct bts_struct ret;
|
|
|
- const unsigned char *raw;
|
|
|
- size_t end, i;
|
|
|
- int error;
|
|
|
+ const struct bts_trace *trace;
|
|
|
+ const unsigned char *at;
|
|
|
+ int error, drained = 0;
|
|
|
|
|
|
- error = ds_get_bts_index(child->bts, &end);
|
|
|
- if (error < 0)
|
|
|
- return error;
|
|
|
+ trace = ds_read_bts(child->bts);
|
|
|
+ if (!trace)
|
|
|
+ return -EPERM;
|
|
|
|
|
|
- if (size < (end * sizeof(struct bts_struct)))
|
|
|
+ if (!trace->read)
|
|
|
+ return -EOPNOTSUPP;
|
|
|
+
|
|
|
+ if (size < (trace->ds.top - trace->ds.begin))
|
|
|
return -EIO;
|
|
|
|
|
|
- error = ds_access_bts(child->bts, 0, (const void **)&raw);
|
|
|
- if (error < 0)
|
|
|
- return error;
|
|
|
+ for (at = trace->ds.begin; (void *)at < trace->ds.top;
|
|
|
+ out++, drained++, at += trace->ds.size) {
|
|
|
+ struct bts_struct bts;
|
|
|
+ int error;
|
|
|
|
|
|
- for (i = 0; i < end; i++, out++, raw += bts_cfg.sizeof_bts) {
|
|
|
- ptrace_bts_translate_record(&ret, raw);
|
|
|
+ error = trace->read(child->bts, at, &bts);
|
|
|
+ if (error < 0)
|
|
|
+ return error;
|
|
|
|
|
|
- if (copy_to_user(out, &ret, sizeof(ret)))
|
|
|
+ if (copy_to_user(out, &bts, sizeof(bts)))
|
|
|
return -EFAULT;
|
|
|
}
|
|
|
|
|
|
- error = ds_clear_bts(child->bts);
|
|
|
+ memset(trace->ds.begin, 0, trace->ds.n * trace->ds.size);
|
|
|
+
|
|
|
+ error = ds_reset_bts(child->bts);
|
|
|
if (error < 0)
|
|
|
return error;
|
|
|
|
|
|
- return end;
|
|
|
+ return drained;
|
|
|
}
|
|
|
|
|
|
static int ptrace_bts_config(struct task_struct *child,
|
|
|
@@ -735,136 +655,89 @@ static int ptrace_bts_config(struct task_struct *child,
|
|
|
const struct ptrace_bts_config __user *ucfg)
|
|
|
{
|
|
|
struct ptrace_bts_config cfg;
|
|
|
- int error = 0;
|
|
|
-
|
|
|
- error = -EOPNOTSUPP;
|
|
|
- if (!bts_cfg.sizeof_bts)
|
|
|
- goto errout;
|
|
|
+ unsigned int flags = 0;
|
|
|
|
|
|
- error = -EIO;
|
|
|
if (cfg_size < sizeof(cfg))
|
|
|
- goto errout;
|
|
|
+ return -EIO;
|
|
|
|
|
|
- error = -EFAULT;
|
|
|
if (copy_from_user(&cfg, ucfg, sizeof(cfg)))
|
|
|
- goto errout;
|
|
|
-
|
|
|
- error = -EINVAL;
|
|
|
- if ((cfg.flags & PTRACE_BTS_O_SIGNAL) &&
|
|
|
- !(cfg.flags & PTRACE_BTS_O_ALLOC))
|
|
|
- goto errout;
|
|
|
-
|
|
|
- if (cfg.flags & PTRACE_BTS_O_ALLOC) {
|
|
|
- bts_ovfl_callback_t ovfl = NULL;
|
|
|
- unsigned int sig = 0;
|
|
|
-
|
|
|
- error = -EINVAL;
|
|
|
- if (cfg.size < (10 * bts_cfg.sizeof_bts))
|
|
|
- goto errout;
|
|
|
+ return -EFAULT;
|
|
|
|
|
|
- if (cfg.flags & PTRACE_BTS_O_SIGNAL) {
|
|
|
- if (!cfg.signal)
|
|
|
- goto errout;
|
|
|
+ if (child->bts) {
|
|
|
+ ds_release_bts(child->bts);
|
|
|
+ child->bts = NULL;
|
|
|
+ }
|
|
|
|
|
|
- error = -EOPNOTSUPP;
|
|
|
- goto errout;
|
|
|
+ if (cfg.flags & PTRACE_BTS_O_SIGNAL) {
|
|
|
+ if (!cfg.signal)
|
|
|
+ return -EINVAL;
|
|
|
|
|
|
- sig = cfg.signal;
|
|
|
- }
|
|
|
+ return -EOPNOTSUPP;
|
|
|
|
|
|
- if (child->bts) {
|
|
|
- (void)ds_release_bts(child->bts);
|
|
|
- kfree(child->bts_buffer);
|
|
|
+ child->thread.bts_ovfl_signal = cfg.signal;
|
|
|
+ }
|
|
|
|
|
|
- child->bts = NULL;
|
|
|
- child->bts_buffer = NULL;
|
|
|
- }
|
|
|
+ if ((cfg.flags & PTRACE_BTS_O_ALLOC) &&
|
|
|
+ (cfg.size != child->bts_size)) {
|
|
|
+ kfree(child->bts_buffer);
|
|
|
|
|
|
- error = -ENOMEM;
|
|
|
+ child->bts_size = cfg.size;
|
|
|
child->bts_buffer = kzalloc(cfg.size, GFP_KERNEL);
|
|
|
- if (!child->bts_buffer)
|
|
|
- goto errout;
|
|
|
-
|
|
|
- child->bts = ds_request_bts(child, child->bts_buffer, cfg.size,
|
|
|
- ovfl, /* th = */ (size_t)-1);
|
|
|
- if (IS_ERR(child->bts)) {
|
|
|
- error = PTR_ERR(child->bts);
|
|
|
- kfree(child->bts_buffer);
|
|
|
- child->bts = NULL;
|
|
|
- child->bts_buffer = NULL;
|
|
|
- goto errout;
|
|
|
+ if (!child->bts_buffer) {
|
|
|
+ child->bts_size = 0;
|
|
|
+ return -ENOMEM;
|
|
|
}
|
|
|
-
|
|
|
- child->thread.bts_ovfl_signal = sig;
|
|
|
}
|
|
|
|
|
|
- error = -EINVAL;
|
|
|
- if (!child->thread.ds_ctx && cfg.flags)
|
|
|
- goto errout;
|
|
|
-
|
|
|
if (cfg.flags & PTRACE_BTS_O_TRACE)
|
|
|
- child->thread.debugctlmsr |= bts_cfg.debugctl_mask;
|
|
|
- else
|
|
|
- child->thread.debugctlmsr &= ~bts_cfg.debugctl_mask;
|
|
|
+ flags |= BTS_USER;
|
|
|
|
|
|
if (cfg.flags & PTRACE_BTS_O_SCHED)
|
|
|
- set_tsk_thread_flag(child, TIF_BTS_TRACE_TS);
|
|
|
- else
|
|
|
- clear_tsk_thread_flag(child, TIF_BTS_TRACE_TS);
|
|
|
+ flags |= BTS_TIMESTAMPS;
|
|
|
|
|
|
- error = sizeof(cfg);
|
|
|
+ child->bts = ds_request_bts(child, child->bts_buffer, child->bts_size,
|
|
|
+ /* ovfl = */ NULL, /* th = */ (size_t)-1,
|
|
|
+ flags);
|
|
|
+ if (IS_ERR(child->bts)) {
|
|
|
+ int error = PTR_ERR(child->bts);
|
|
|
|
|
|
-out:
|
|
|
- if (child->thread.debugctlmsr)
|
|
|
- set_tsk_thread_flag(child, TIF_DEBUGCTLMSR);
|
|
|
- else
|
|
|
- clear_tsk_thread_flag(child, TIF_DEBUGCTLMSR);
|
|
|
+ kfree(child->bts_buffer);
|
|
|
+ child->bts = NULL;
|
|
|
+ child->bts_buffer = NULL;
|
|
|
+ child->bts_size = 0;
|
|
|
|
|
|
- return error;
|
|
|
+ return error;
|
|
|
+ }
|
|
|
|
|
|
-errout:
|
|
|
- child->thread.debugctlmsr &= ~bts_cfg.debugctl_mask;
|
|
|
- clear_tsk_thread_flag(child, TIF_BTS_TRACE_TS);
|
|
|
- goto out;
|
|
|
+ return sizeof(cfg);
|
|
|
}
|
|
|
|
|
|
static int ptrace_bts_status(struct task_struct *child,
|
|
|
long cfg_size,
|
|
|
struct ptrace_bts_config __user *ucfg)
|
|
|
{
|
|
|
+ const struct bts_trace *trace;
|
|
|
struct ptrace_bts_config cfg;
|
|
|
- size_t end;
|
|
|
- const void *base, *max;
|
|
|
- int error;
|
|
|
|
|
|
if (cfg_size < sizeof(cfg))
|
|
|
return -EIO;
|
|
|
|
|
|
- error = ds_get_bts_end(child->bts, &end);
|
|
|
- if (error < 0)
|
|
|
- return error;
|
|
|
-
|
|
|
- error = ds_access_bts(child->bts, /* index = */ 0, &base);
|
|
|
- if (error < 0)
|
|
|
- return error;
|
|
|
-
|
|
|
- error = ds_access_bts(child->bts, /* index = */ end, &max);
|
|
|
- if (error < 0)
|
|
|
- return error;
|
|
|
+ trace = ds_read_bts(child->bts);
|
|
|
+ if (!trace)
|
|
|
+ return -EPERM;
|
|
|
|
|
|
memset(&cfg, 0, sizeof(cfg));
|
|
|
- cfg.size = (max - base);
|
|
|
+ cfg.size = trace->ds.end - trace->ds.begin;
|
|
|
cfg.signal = child->thread.bts_ovfl_signal;
|
|
|
cfg.bts_size = sizeof(struct bts_struct);
|
|
|
|
|
|
if (cfg.signal)
|
|
|
cfg.flags |= PTRACE_BTS_O_SIGNAL;
|
|
|
|
|
|
- if (test_tsk_thread_flag(child, TIF_DEBUGCTLMSR) &&
|
|
|
- child->thread.debugctlmsr & bts_cfg.debugctl_mask)
|
|
|
+ if (trace->ds.flags & BTS_USER)
|
|
|
cfg.flags |= PTRACE_BTS_O_TRACE;
|
|
|
|
|
|
- if (test_tsk_thread_flag(child, TIF_BTS_TRACE_TS))
|
|
|
+ if (trace->ds.flags & BTS_TIMESTAMPS)
|
|
|
cfg.flags |= PTRACE_BTS_O_SCHED;
|
|
|
|
|
|
if (copy_to_user(ucfg, &cfg, sizeof(cfg)))
|
|
|
@@ -873,105 +746,28 @@ static int ptrace_bts_status(struct task_struct *child,
|
|
|
return sizeof(cfg);
|
|
|
}
|
|
|
|
|
|
-static int ptrace_bts_write_record(struct task_struct *child,
|
|
|
- const struct bts_struct *in)
|
|
|
+static int ptrace_bts_clear(struct task_struct *child)
|
|
|
{
|
|
|
- unsigned char bts_record[BTS_MAX_RECORD_SIZE];
|
|
|
+ const struct bts_trace *trace;
|
|
|
|
|
|
- if (BTS_MAX_RECORD_SIZE < bts_cfg.sizeof_bts)
|
|
|
- return -EOVERFLOW;
|
|
|
+ trace = ds_read_bts(child->bts);
|
|
|
+ if (!trace)
|
|
|
+ return -EPERM;
|
|
|
|
|
|
- memset(bts_record, 0, bts_cfg.sizeof_bts);
|
|
|
- switch (in->qualifier) {
|
|
|
- case BTS_INVALID:
|
|
|
- break;
|
|
|
+ memset(trace->ds.begin, 0, trace->ds.n * trace->ds.size);
|
|
|
|
|
|
- case BTS_BRANCH:
|
|
|
- bts_set(bts_record, bts_from, in->variant.lbr.from_ip);
|
|
|
- bts_set(bts_record, bts_to, in->variant.lbr.to_ip);
|
|
|
- break;
|
|
|
-
|
|
|
- case BTS_TASK_ARRIVES:
|
|
|
- case BTS_TASK_DEPARTS:
|
|
|
- bts_set(bts_record, bts_from, bts_escape);
|
|
|
- bts_set(bts_record, bts_qual, in->qualifier);
|
|
|
- bts_set(bts_record, bts_jiffies, in->variant.jiffies);
|
|
|
- break;
|
|
|
-
|
|
|
- default:
|
|
|
- return -EINVAL;
|
|
|
- }
|
|
|
-
|
|
|
- return ds_write_bts(child->bts, bts_record, bts_cfg.sizeof_bts);
|
|
|
+ return ds_reset_bts(child->bts);
|
|
|
}
|
|
|
|
|
|
-void ptrace_bts_take_timestamp(struct task_struct *tsk,
|
|
|
- enum bts_qualifier qualifier)
|
|
|
+static int ptrace_bts_size(struct task_struct *child)
|
|
|
{
|
|
|
- struct bts_struct rec = {
|
|
|
- .qualifier = qualifier,
|
|
|
- .variant.jiffies = jiffies_64
|
|
|
- };
|
|
|
-
|
|
|
- ptrace_bts_write_record(tsk, &rec);
|
|
|
-}
|
|
|
-
|
|
|
-static const struct bts_configuration bts_cfg_netburst = {
|
|
|
- .sizeof_bts = sizeof(long) * 3,
|
|
|
- .sizeof_field = sizeof(long),
|
|
|
- .debugctl_mask = (1<<2)|(1<<3)|(1<<5)
|
|
|
-};
|
|
|
+ const struct bts_trace *trace;
|
|
|
|
|
|
-static const struct bts_configuration bts_cfg_pentium_m = {
|
|
|
- .sizeof_bts = sizeof(long) * 3,
|
|
|
- .sizeof_field = sizeof(long),
|
|
|
- .debugctl_mask = (1<<6)|(1<<7)
|
|
|
-};
|
|
|
+ trace = ds_read_bts(child->bts);
|
|
|
+ if (!trace)
|
|
|
+ return -EPERM;
|
|
|
|
|
|
-static const struct bts_configuration bts_cfg_core2 = {
|
|
|
- .sizeof_bts = 8 * 3,
|
|
|
- .sizeof_field = 8,
|
|
|
- .debugctl_mask = (1<<6)|(1<<7)|(1<<9)
|
|
|
-};
|
|
|
-
|
|
|
-static inline void bts_configure(const struct bts_configuration *cfg)
|
|
|
-{
|
|
|
- bts_cfg = *cfg;
|
|
|
-}
|
|
|
-
|
|
|
-void __cpuinit ptrace_bts_init_intel(struct cpuinfo_x86 *c)
|
|
|
-{
|
|
|
- switch (c->x86) {
|
|
|
- case 0x6:
|
|
|
- switch (c->x86_model) {
|
|
|
- case 0 ... 0xC:
|
|
|
- /* sorry, don't know about them */
|
|
|
- break;
|
|
|
- case 0xD:
|
|
|
- case 0xE: /* Pentium M */
|
|
|
- bts_configure(&bts_cfg_pentium_m);
|
|
|
- break;
|
|
|
- default: /* Core2, Atom, ... */
|
|
|
- bts_configure(&bts_cfg_core2);
|
|
|
- break;
|
|
|
- }
|
|
|
- break;
|
|
|
- case 0xF:
|
|
|
- switch (c->x86_model) {
|
|
|
- case 0x0:
|
|
|
- case 0x1:
|
|
|
- case 0x2: /* Netburst */
|
|
|
- bts_configure(&bts_cfg_netburst);
|
|
|
- break;
|
|
|
- default:
|
|
|
- /* sorry, don't know about them */
|
|
|
- break;
|
|
|
- }
|
|
|
- break;
|
|
|
- default:
|
|
|
- /* sorry, don't know about them */
|
|
|
- break;
|
|
|
- }
|
|
|
+ return (trace->ds.top - trace->ds.begin) / trace->ds.size;
|
|
|
}
|
|
|
#endif /* CONFIG_X86_PTRACE_BTS */
|
|
|
|
|
|
@@ -988,15 +784,12 @@ void ptrace_disable(struct task_struct *child)
|
|
|
#endif
|
|
|
#ifdef CONFIG_X86_PTRACE_BTS
|
|
|
if (child->bts) {
|
|
|
- (void)ds_release_bts(child->bts);
|
|
|
+ ds_release_bts(child->bts);
|
|
|
+ child->bts = NULL;
|
|
|
+
|
|
|
kfree(child->bts_buffer);
|
|
|
child->bts_buffer = NULL;
|
|
|
-
|
|
|
- child->thread.debugctlmsr &= ~bts_cfg.debugctl_mask;
|
|
|
- if (!child->thread.debugctlmsr)
|
|
|
- clear_tsk_thread_flag(child, TIF_DEBUGCTLMSR);
|
|
|
-
|
|
|
- clear_tsk_thread_flag(child, TIF_BTS_TRACE_TS);
|
|
|
+ child->bts_size = 0;
|
|
|
}
|
|
|
#endif /* CONFIG_X86_PTRACE_BTS */
|
|
|
}
|
|
|
@@ -1129,16 +922,9 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
|
|
|
(child, data, (struct ptrace_bts_config __user *)addr);
|
|
|
break;
|
|
|
|
|
|
- case PTRACE_BTS_SIZE: {
|
|
|
- size_t size;
|
|
|
-
|
|
|
- ret = ds_get_bts_index(child->bts, &size);
|
|
|
- if (ret == 0) {
|
|
|
- WARN_ON_ONCE(size != (int) size);
|
|
|
- ret = (int) size;
|
|
|
- }
|
|
|
+ case PTRACE_BTS_SIZE:
|
|
|
+ ret = ptrace_bts_size(child);
|
|
|
break;
|
|
|
- }
|
|
|
|
|
|
case PTRACE_BTS_GET:
|
|
|
ret = ptrace_bts_read_record
|
|
|
@@ -1146,7 +932,7 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
|
|
|
break;
|
|
|
|
|
|
case PTRACE_BTS_CLEAR:
|
|
|
- ret = ds_clear_bts(child->bts);
|
|
|
+ ret = ptrace_bts_clear(child);
|
|
|
break;
|
|
|
|
|
|
case PTRACE_BTS_DRAIN:
|
|
|
@@ -1409,6 +1195,14 @@ long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
|
|
|
|
|
|
case PTRACE_GET_THREAD_AREA:
|
|
|
case PTRACE_SET_THREAD_AREA:
|
|
|
+#ifdef CONFIG_X86_PTRACE_BTS
|
|
|
+ case PTRACE_BTS_CONFIG:
|
|
|
+ case PTRACE_BTS_STATUS:
|
|
|
+ case PTRACE_BTS_SIZE:
|
|
|
+ case PTRACE_BTS_GET:
|
|
|
+ case PTRACE_BTS_CLEAR:
|
|
|
+ case PTRACE_BTS_DRAIN:
|
|
|
+#endif /* CONFIG_X86_PTRACE_BTS */
|
|
|
return arch_ptrace(child, request, addr, data);
|
|
|
|
|
|
default:
|
Markus Metzger