kernel.h: update comment about simple_strto<foo>() functions

[sfrench/cifs-2.6.git] / include / linux / perf_event.h

diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
index 68ccc5b1913b485ba940dc6fa283a6ec7c0a381d..6d4c22aee38483a34362e3d56c3c22108645fe1f 100644 (file)
--- a/include/linux/perf_event.h
+++ b/include/linux/perf_event.h
@@ -56,6 +56,7 @@ struct perf_guest_info_callbacks {
 #include <linux/perf_regs.h>
 #include <linux/cgroup.h>
 #include <linux/refcount.h>
+#include <linux/security.h>
 #include <asm/local.h>
 
 struct perf_callchain_entry {
@@ -248,6 +249,8 @@ struct perf_event;
 #define PERF_PMU_CAP_NO_EXCLUDE                        0x80
 #define PERF_PMU_CAP_AUX_OUTPUT                        0x100
 
+struct perf_output_handle;
+
 /**
  * struct pmu - generic performance monitoring unit
  */
@@ -409,6 +412,15 @@ struct pmu {
         */
        size_t                          task_ctx_size;
 
+       /*
+        * PMU specific parts of task perf event context (i.e. ctx->task_ctx_data)
+        * can be synchronized using this function. See Intel LBR callstack support
+        * implementation and Perf core context switch handling callbacks for usage
+        * examples.
+        */
+       void (*swap_task_ctx)           (struct perf_event_context *prev,
+                                        struct perf_event_context *next);
+                                       /* optional */
 
        /*
         * Set up pmu-private data structures for an AUX area
@@ -422,6 +434,19 @@ struct pmu {
         */
        void (*free_aux)                (void *aux); /* optional */
 
+       /*
+        * Take a snapshot of the AUX buffer without touching the event
+        * state, so that preempting ->start()/->stop() callbacks does
+        * not interfere with their logic. Called in PMI context.
+        *
+        * Returns the size of AUX data copied to the output handle.
+        *
+        * Optional.
+        */
+       long (*snapshot_aux)            (struct perf_event *event,
+                                        struct perf_output_handle *handle,
+                                        unsigned long size);
+
        /*
         * Validate address range filters: make sure the HW supports the
         * requested configuration and number of filters; return 0 if the
@@ -721,6 +746,9 @@ struct perf_event {
        struct perf_cgroup              *cgrp; /* cgroup event is attach to */
 #endif
 
+#ifdef CONFIG_SECURITY
+       void *security;
+#endif
        struct list_head                sb_list;
 #endif /* CONFIG_PERF_EVENTS */
 };
@@ -960,6 +988,7 @@ struct perf_sample_data {
                u32     reserved;
        }                               cpu_entry;
        struct perf_callchain_entry     *callchain;
+       u64                             aux_size;
 
        /*
         * regs_user may point to task_pt_regs or to regs_user_copy, depending
@@ -1241,19 +1270,41 @@ extern int perf_cpu_time_max_percent_handler(struct ctl_table *table, int write,
 int perf_event_max_stack_handler(struct ctl_table *table, int write,
                                 void __user *buffer, size_t *lenp, loff_t *ppos);
 
-static inline bool perf_paranoid_tracepoint_raw(void)
+/* Access to perf_event_open(2) syscall. */
+#define PERF_SECURITY_OPEN             0
+
+/* Finer grained perf_event_open(2) access control. */
+#define PERF_SECURITY_CPU              1
+#define PERF_SECURITY_KERNEL           2
+#define PERF_SECURITY_TRACEPOINT       3
+
+static inline int perf_is_paranoid(void)
 {
        return sysctl_perf_event_paranoid > -1;
 }
 
-static inline bool perf_paranoid_cpu(void)
+static inline int perf_allow_kernel(struct perf_event_attr *attr)
+{
+       if (sysctl_perf_event_paranoid > 1 && !capable(CAP_SYS_ADMIN))
+               return -EACCES;
+
+       return security_perf_event_open(attr, PERF_SECURITY_KERNEL);
+}
+
+static inline int perf_allow_cpu(struct perf_event_attr *attr)
 {
-       return sysctl_perf_event_paranoid > 0;
+       if (sysctl_perf_event_paranoid > 0 && !capable(CAP_SYS_ADMIN))
+               return -EACCES;
+
+       return security_perf_event_open(attr, PERF_SECURITY_CPU);
 }
 
-static inline bool perf_paranoid_kernel(void)
+static inline int perf_allow_tracepoint(struct perf_event_attr *attr)
 {
-       return sysctl_perf_event_paranoid > 1;
+       if (sysctl_perf_event_paranoid > -1 && !capable(CAP_SYS_ADMIN))
+               return -EPERM;
+
+       return security_perf_event_open(attr, PERF_SECURITY_TRACEPOINT);
 }
 
 extern void perf_event_init(void);
@@ -1327,6 +1378,9 @@ extern unsigned int perf_output_copy(struct perf_output_handle *handle,
                             const void *buf, unsigned int len);
 extern unsigned int perf_output_skip(struct perf_output_handle *handle,
                                     unsigned int len);
+extern long perf_output_copy_aux(struct perf_output_handle *aux_handle,
+                                struct perf_output_handle *handle,
+                                unsigned long from, unsigned long to);
 extern int perf_swevent_get_recursion_context(void);
 extern void perf_swevent_put_recursion_context(int rctx);
 extern u64 perf_swevent_set_period(struct perf_event *event);
@@ -1336,6 +1390,8 @@ extern void perf_event_disable_local(struct perf_event *event);
 extern void perf_event_disable_inatomic(struct perf_event *event);
 extern void perf_event_task_tick(void);
 extern int perf_event_account_interrupt(struct perf_event *event);
+extern int perf_event_period(struct perf_event *event, u64 value);
+extern u64 perf_event_pause(struct perf_event *event, bool reset);
 #else /* !CONFIG_PERF_EVENTS: */
 static inline void *
 perf_aux_output_begin(struct perf_output_handle *handle,
@@ -1415,6 +1471,14 @@ static inline void perf_event_disable(struct perf_event *event)          { }
 static inline int __perf_event_disable(void *info)                     { return -1; }
 static inline void perf_event_task_tick(void)                          { }
 static inline int perf_event_release_kernel(struct perf_event *event)  { return 0; }
+static inline int perf_event_period(struct perf_event *event, u64 value)
+{
+       return -EINVAL;
+}
+static inline u64 perf_event_pause(struct perf_event *event, bool reset)
+{
+       return 0;
+}
 #endif
 
 #if defined(CONFIG_PERF_EVENTS) && defined(CONFIG_CPU_SUP_INTEL)