};
 
 /**
- * pevent_set_function_resolver - set an alternative function resolver
+ * tep_set_function_resolver - set an alternative function resolver
  * @pevent: handle for the pevent
  * @resolver: function to be used
  * @priv: resolver function private state.
  * keep using it instead of duplicating all the entries inside
  * pevent->funclist.
  */
-int pevent_set_function_resolver(struct tep_handle *pevent,
-                                tep_func_resolver_t *func, void *priv)
+int tep_set_function_resolver(struct tep_handle *pevent,
+                             tep_func_resolver_t *func, void *priv)
 {
        struct func_resolver *resolver = malloc(sizeof(*resolver));
 
 
        char *trace_clock;
 };
 
-static inline void pevent_set_flag(struct tep_handle *pevent, int flag)
+static inline void tep_set_flag(struct tep_handle *pevent, int flag)
 {
        pevent->flags |= flag;
 }
        TRACE_FLAG_SOFTIRQ              = 0x10,
 };
 
-int pevent_set_function_resolver(struct tep_handle *pevent,
-                                tep_func_resolver_t *func, void *priv);
+int tep_set_function_resolver(struct tep_handle *pevent,
+                             tep_func_resolver_t *func, void *priv);
 void pevent_reset_function_resolver(struct tep_handle *pevent);
 int tep_register_comm(struct tep_handle *pevent, const char *comm, int pid);
 int pevent_register_trace_clock(struct tep_handle *pevent, const char *trace_clock);
        pevent->cpus = cpus;
 }
 
-static inline int pevent_get_long_size(struct tep_handle *pevent)
+static inline int tep_get_long_size(struct tep_handle *pevent)
 {
        return pevent->long_size;
 }
 
-static inline void pevent_set_long_size(struct tep_handle *pevent, int long_size)
+static inline void tep_set_long_size(struct tep_handle *pevent, int long_size)
 {
        pevent->long_size = long_size;
 }
        return pevent->page_size;
 }
 
-static inline void pevent_set_page_size(struct tep_handle *pevent, int _page_size)
+static inline void tep_set_page_size(struct tep_handle *pevent, int _page_size)
 {
        pevent->page_size = _page_size;
 }
        return pevent->file_bigendian;
 }
 
-static inline void pevent_set_file_bigendian(struct tep_handle *pevent, int endian)
+static inline void tep_set_file_bigendian(struct tep_handle *pevent, int endian)
 {
        pevent->file_bigendian = endian;
 }
        return pevent->host_bigendian;
 }
 
-static inline void pevent_set_host_bigendian(struct tep_handle *pevent, int endian)
+static inline void tep_set_host_bigendian(struct tep_handle *pevent, int endian)
 {
        pevent->host_bigendian = endian;
 }
 
        }
 
        if (session->tevent.pevent &&
-           pevent_set_function_resolver(session->tevent.pevent,
-                                        machine__resolve_kernel_addr,
-                                        &session->machines.host) < 0) {
+           tep_set_function_resolver(session->tevent.pevent,
+                                     machine__resolve_kernel_addr,
+                                     &session->machines.host) < 0) {
                pr_err("%s: failed to set libtraceevent function resolver\n",
                       __func__);
                return -1;
 
                symbol_conf.use_callchain = false;
 
        if (session->tevent.pevent &&
-           pevent_set_function_resolver(session->tevent.pevent,
-                                        machine__resolve_kernel_addr,
-                                        &session->machines.host) < 0) {
+           tep_set_function_resolver(session->tevent.pevent,
+                                     machine__resolve_kernel_addr,
+                                     &session->machines.host) < 0) {
                pr_err("%s: failed to set libtraceevent function resolver\n", __func__);
                err = -1;
                goto out_delete;
 
 int machine__set_current_tid(struct machine *machine, int cpu, pid_t pid,
                             pid_t tid);
 /*
- * For use with libtraceevent's pevent_set_function_resolver()
+ * For use with libtraceevent's tep_set_function_resolver()
  */
 char *machine__resolve_kernel_addr(void *vmachine, unsigned long long *addrp, char **modp);
 
 
        }
 
        if (!tep_parse_header_page(pevent, header_page, size,
-                                  pevent_get_long_size(pevent))) {
+                                  tep_get_long_size(pevent))) {
                /*
                 * The commit field in the page is of type long,
                 * use that instead, since it represents the kernel.
                 */
-               pevent_set_long_size(pevent, pevent->header_page_size_size);
+               tep_set_long_size(pevent, pevent->header_page_size_size);
        }
        free(header_page);
 
 
        pevent = tevent->pevent;
 
-       pevent_set_flag(pevent, PEVENT_NSEC_OUTPUT);
-       pevent_set_file_bigendian(pevent, file_bigendian);
-       pevent_set_host_bigendian(pevent, host_bigendian);
+       tep_set_flag(pevent, PEVENT_NSEC_OUTPUT);
+       tep_set_file_bigendian(pevent, file_bigendian);
+       tep_set_host_bigendian(pevent, host_bigendian);
 
        if (do_read(buf, 1) < 0)
                goto out;
        if (!file_page_size)
                goto out;
 
-       pevent_set_long_size(pevent, file_long_size);
-       pevent_set_page_size(pevent, file_page_size);
+       tep_set_long_size(pevent, file_long_size);
+       tep_set_page_size(pevent, file_page_size);
 
        err = read_header_files(pevent);
        if (err)
 
                return -1;
 
        pevent = tevent.pevent;
-       pevent_set_flag(pevent, PEVENT_NSEC_OUTPUT);
-       pevent_set_file_bigendian(pevent, be);
-       pevent_set_host_bigendian(pevent, be);
+       tep_set_flag(pevent, PEVENT_NSEC_OUTPUT);
+       tep_set_file_bigendian(pevent, be);
+       tep_set_host_bigendian(pevent, be);
        tevent_initialized = true;
        return 0;
 }
        if (!tevent_initialized && trace_event__init2())
                return -1;
 
-       return pevent_set_function_resolver(tevent.pevent, func, machine);
+       return tep_set_function_resolver(tevent.pevent, func, machine);
 }
 
 void trace_event__cleanup(struct trace_event *t)