opcontrol/opcontrol.cpp - platform/external/oprofile - Git at Google

 /*
  * Copyright 2008, The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 /*
  * Binary implementation of the original opcontrol script due to missing tools
  * like awk, test, etc.
  */

 #include <unistd.h>
 #include <getopt.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <dirent.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>

 #include "op_config.h"

 #define verbose(fmt...) if (verbose_print) printf(fmt)

 struct event_info {
     int id;
     int counters;
     int um;
     const char *name;
     const char *explanation;
 };

 #define CTR(n)  (1<<(n))

 #if defined(__i386__) || defined(__x86_64__)
 struct event_info event_info_arch_perfmon[] = {
     #include "../events/i386/arch_perfmon/events.h"
 };

 #define MAX_EVENTS 2
 int min_count[MAX_EVENTS] = {60000, 100000};

 const char *default_event = "CPU_CLK_UNHALTED";
 #endif

 #if defined(__arm__)
 #if !defined(WITH_ARM_V7_A)
 struct event_info event_info_armv6[] = {
     #include "../events/arm/armv6/events.h"
 };

 #define MAX_EVENTS 3
 int min_count[MAX_EVENTS] = {150000, 200000, 250000};

 #else
 struct event_info event_info_armv7[] = {
     #include "../events/arm/armv7/events.h"
 };

 #define MAX_EVENTS 5
 int min_count[MAX_EVENTS] = {150000, 20000, 25000, 30000, 35000};
 #endif

 const char *default_event = "CPU_CYCLES";
 #endif

 #if defined(__mips__)
 struct event_info event_info_24K[] = {
     #include "../events/mips/24K/events.h"
 };
 struct event_info event_info_34K[] = {
     #include "../events/mips/34K/events.h"
 };
 struct event_info event_info_74K[] = {
     #include "../events/mips/74K/events.h"
 };
 struct event_info event_info_1004K[] = {
     #include "../events/mips/1004K/events.h"
 };

 #define MAX_EVENTS 4
 int min_count[MAX_EVENTS] = {150000, 20000, 25000, 30000};

 const char *default_event = "CYCLES";
 #endif /* defined(__mips__) */

 #define ARRAYSZ(x) (sizeof(x)/sizeof((x)[0]))

 struct cpuevents {
     const char *cpu;
     struct event_info *event_info;
     unsigned int nevents;
 } cpuevents[] = {
 #if defined(__i386__) || defined(__x86_64__)
     {"i386/arch_perfmon", event_info_arch_perfmon, ARRAYSZ(event_info_arch_perfmon)},
 #endif /* defined(__i386__) || defined(__x86_64__) */
 #if defined(__arm__)
 #if !defined(WITH_ARM_V7_A)
     {"arm/armv6", event_info_armv6, ARRAYSZ(event_info_armv6)},
 #else
     {"arm/armv7", event_info_armv7, ARRAYSZ(event_info_armv7)},
 #endif
 #endif /* defined(__arm__) */
 #if defined(__mips__)
     {"mips/24K", event_info_24K, ARRAYSZ(event_info_24K)},
     {"mips/34K", event_info_34K, ARRAYSZ(event_info_34K)},
     {"mips/74K", event_info_74K, ARRAYSZ(event_info_74K)},
     {"mips/1004K", event_info_1004K, ARRAYSZ(event_info_1004K)},
 #endif /* defined(__mips__) */
 };

 struct cpuevents *cpuevent;
 #define event_info cpuevent->event_info
 #define NEVENTS cpuevent->nevents

 int verbose_print;
 int list_events;
 int show_usage;
 int setup;
 int quick;
 int timer;
 int num_events;
 int start;
 int stop;
 int reset;

 int selected_events[MAX_EVENTS];
 int selected_counts[MAX_EVENTS];
 int max_events;

 char callgraph[8];
 char kernel_range[512];
 char vmlinux[512];

 struct option long_options[] = {
     {"help", 0, &show_usage, 1},
     {"list-events", 0, &list_events, 1},
     {"reset", 0, &reset, 1},
     {"setup", 0, &setup, 1},
     {"quick", 0, &quick, 1},
     {"timer", 0, &timer, 1},
     {"callgraph", 1, 0, 'c'},
     {"event", 1, 0, 'e'},
     {"vmlinux", 1, 0, 'v'},
     {"kernel-range", 1, 0, 'r'},
     {"start", 0, &start, 1},
     {"stop", 0, &stop, 1},
     {"dump", 0, 0, 'd'},
     {"shutdown", 0, 0, 'h'},
     {"status", 0, 0, 't'},
     {"verbose", 0, 0, 'V'},
     {"verbose-log", 1, 0, 'l'},
     {0, 0, 0, 0},
 };


 void usage()
 {
     printf("\nopcontrol: usage:\n"
            "   --list-events    list event types\n"
            "   --help           this message\n"
            "   --verbose        show extra status\n"
            "   --verbose-log=lvl set daemon logging verbosity during setup\n"
            "                    levels are: all,sfile,arcs,samples,module,misc\n"
            "   --setup          setup directories\n"
 #if defined(__i386__) || defined(__x86_64__)
            "   --quick          setup and select CPU_CLK_UNHALTED:60000\n"
 #elif defined(__arm__)
            "   --quick          setup and select CPU_CYCLES:150000\n"
 #elif defined(__mips__)
            "   --quick          setup and select CYCLES:150000\n"
 #endif
            "   --timer          timer-based profiling\n"
            "   --status         show configuration\n"
            "   --start          start data collection\n"
            "   --stop           stop data collection\n"
            "   --reset          clears out data from current session\n"
            "   --shutdown       kill the oprofile daemon\n"
            "   --callgraph=depth callgraph depth\n"
            "   --event=eventspec\n"
            "      Choose an event. May be specified multiple times.\n"
            "      eventspec is in the form of name[:count], where :\n"
            "        name:  event name, see \"opcontrol --list-events\"\n"
            "        count: reset counter value\n"
            "   --vmlinux=file   vmlinux kernel image\n"
            "   --kernel-range=start,end\n"
            "                    kernel range vma address in hexadecimal\n"
           );
 }

 int setup_device(void)
 {
     if (mkdir(OP_DRIVER_BASE, 0755)) {
         if (errno != EEXIST) {
             fprintf(stderr, "Cannot create directory "OP_DRIVER_BASE": %s\n",
                     strerror(errno));
             return -1;
         }
     }

     if (access(OP_DRIVER_BASE"/stats", F_OK)) {
         if (system("mount -t oprofilefs nodev "OP_DRIVER_BASE)) {
             return -1;
         }
     }

     /* Selecting the event information by cpu_type has only been tested on MIPS */
 #if defined(__mips__)
     /* Use cpu_type to select the events */
     int fd = open(OP_DRIVER_BASE "/cpu_type", O_RDONLY);
     if (fd < 0) {
 	fprintf(stderr, OP_DRIVER_BASE "/cpu_type: %s\n",
 		strerror(errno));
 	return -1;
     }

     char buf[512];
     int n = read(fd, buf, sizeof(buf)-1);
     close(fd);
     if (n < 0) {
 	fprintf(stderr, OP_DRIVER_BASE "/cpu_type: %s\n",
 		strerror(errno));
 	return -1;
     }
     buf[n] = '\0';
     for (unsigned int i = 0; i < ARRAYSZ(cpuevents); i++) {
 	if (strcmp(buf, cpuevents[i].cpu) == 0) {
 	    cpuevent = &cpuevents[i];
 	}
     }
     if (cpuevent == NULL) {
 	fprintf(stderr, "Unrecognised CPU type %s\n", buf);
 	return -1;
     }
     for (max_events = 0; max_events < MAX_EVENTS; max_events++) {
 	snprintf(buf, sizeof(buf), OP_DRIVER_BASE"/%d", max_events);
 	if (access(buf, F_OK) < 0)
 	    break;
     }
 #else
     max_events = MAX_EVENTS;
     cpuevent = &cpuevents[0];
 #endif
     return 0;
 }

 void setup_session_dir()
 {
     if (access(OP_DATA_DIR, F_OK) == 0)
         system("rm -r "OP_DATA_DIR);

     if (mkdir(OP_DATA_DIR, 0755)) {
         fprintf(stderr, "Cannot create directory \"%s\": %s\n",
                 OP_DATA_DIR, strerror(errno));
     }
     if (mkdir(OP_DATA_DIR"/samples", 0755)) {
         fprintf(stderr, "Cannot create directory \"%s\": %s\n",
                 OP_DATA_DIR"/samples", strerror(errno));
     }
 }

 int read_num(const char* file)
 {
     char buffer[256];
     int fd = open(file, O_RDONLY);
     if (fd<0) return -1;
     int rd = read(fd, buffer, sizeof(buffer)-1);
     buffer[rd] = 0;
     close(fd);
     return atoi(buffer);
 }

 int do_setup()
 {
     char dir[1024];

     /*
      * Kill the old daemon so that setup can be done more than once to achieve
      * the same effect as reset.
      */
     int num = read_num(OP_DATA_DIR"/lock");
     if (num >= 0) {
         printf("Terminating the old daemon...\n");
         kill(num, SIGTERM);
         sleep(5);
     }

     setup_session_dir();

     return 0;
 }

 void stringify_counters(char *ctr_string, int ctr_mask)
 {
     int i, n, len;
     char *p = ctr_string;

     *p = '\0';
     for (i=0; i<32; ++i) {
         if (ctr_mask & (1<<i)) {
 	    p += sprintf(p, "%d,", i);
 	}
     }
     if (p != ctr_string) {
         *(p-1) = '\0';  /* erase the final comma */
     }
 }

 void do_list_events()
 {
     unsigned int i;
     char ctrs[32*3+1];

     printf("%-12s | %-30s: %s\n", "counter", "name", "meaning");
     printf("----------------------------------------"
            "--------------------------------------\n");
     for (i = 0; i < NEVENTS; i++) {
         stringify_counters(ctrs, event_info[i].counters);
         printf("%-12s | %-30s: %s\n", ctrs, event_info[i].name, event_info[i].explanation);
     }
 }

 int find_event_idx_from_name(const char *name)
 {
     unsigned int i;

     for (i = 0; i < NEVENTS; i++) {
         if (!strcmp(name, event_info[i].name)) {
             return i;
         }
     }
     return -1;
 }

 const char * find_event_name_from_id(int id, int mask)
 {
     unsigned int i;

     for (i = 0; i < NEVENTS; i++) {
 	if (event_info[i].id == id && (event_info[i].counters == 0 || (event_info[i].counters & mask))) {
             return event_info[i].name;
         }
     }
     return "Undefined Event";
 }

 int process_event(const char *event_spec)
 {
     char event_name[512];
     char count_name[512];
     unsigned int i;
     int event_idx;
     int count_val;

     strncpy(event_name, event_spec, 512);
     count_name[0] = 0;

     /* First, check if the name is followed by ":" */
     for (i = 0; i < strlen(event_name); i++) {
         if (event_name[i] == 0) {
             break;
         }
         if (event_name[i] == ':') {
             strncpy(count_name, event_name+i+1, 512);
             event_name[i] = 0;
             break;
         }
     }
     event_idx = find_event_idx_from_name(event_name);
     if (event_idx == -1) {
         fprintf(stderr, "Unknown event name: %s\n", event_name);
         return -1;
     }

     /*
      * check that the named event is valid for this event counter
      * 'num_events' represents the cpu internal counter number
      */
     verbose("idx: %d, name: %s, mask: %02x, ctr#: %d\n",
             event_idx, event_info[event_idx].name,
             event_info[event_idx].counters, num_events);
     if (event_info[event_idx].counters != 0 &&
 	(event_info[event_idx].counters & CTR(num_events)) == 0) {
 	fprintf(stderr, "Bad event name: %s for counter %d, see --list\n",
 		event_name, num_events);
 	return -1;
     }

     /* Use default count */
     if (count_name[0] == 0) {
         count_val = min_count[0];
     } else {
         count_val = atoi(count_name);
     }

     selected_events[num_events] = event_idx;
     selected_counts[num_events++] = count_val;
     verbose("event_id is %d\n", event_info[event_idx].id);
     verbose("count_val is %d\n", count_val);
     return 0;
 }

 int echo_dev(const char* str, int val, const char* file, int counter)
 {
     char fullname[512];
     char content[128];
     int fd;

     if (counter >= 0) {
         snprintf(fullname, 512, OP_DRIVER_BASE"/%d/%s", counter, file);
     }
     else {
         snprintf(fullname, 512, OP_DRIVER_BASE"/%s", file);
     }
     fd = open(fullname, O_WRONLY);
     if (fd<0) {
         fprintf(stderr, "Cannot open %s: %s\n", fullname, strerror(errno));
         return fd;
     }
     if (str == 0) {
         sprintf(content, "%d", val);
     }
     else {
         strncpy(content, str, 128);
     }
     verbose("Configure %s (%s)\n", fullname, content);
     write(fd, content, strlen(content));
     close(fd);
     return 0;
 }

 void do_status()
 {
     int num;
     char fullname[512];
     int i;

     printf("Driver directory: %s\n", OP_DRIVER_BASE);
     printf("Session directory: %s\n", OP_DATA_DIR);
     for (i = 0; i < max_events; i++) {
         sprintf(fullname, OP_DRIVER_BASE"/%d/enabled", i);
         num = read_num(fullname);
         if (num > 0) {
             printf("Counter %d:\n", i);

             /* event name */
             sprintf(fullname, OP_DRIVER_BASE"/%d/event", i);
             num = read_num(fullname);
             printf("    name: %s\n", find_event_name_from_id(num, CTR(i)));

             /* profile interval */
             sprintf(fullname, OP_DRIVER_BASE"/%d/count", i);
             num = read_num(fullname);
             printf("    count: %d\n", num);
         }
         else {
             printf("Counter %d disabled\n", i);
         }
     }

     num = read_num(OP_DATA_DIR"/lock");
     if (num >= 0) {
         /* Still needs to check if this lock is left-over */
         sprintf(fullname, "/proc/%d", num);
         if (access(fullname, R_OK) != 0) {
             printf("OProfile daemon exited prematurely - redo setup"
                    " before you continue\n");
             return;
         }
         else {

             printf("oprofiled pid: %d\n", num);
             num = read_num(OP_DRIVER_BASE"/enable");

             printf("profiler is%s running\n", num == 0 ? " not" : "");

             DIR* dir = opendir(OP_DRIVER_BASE"/stats");
             if (dir) {
                 for (struct dirent* dirent; !!(dirent = readdir(dir));) {
                     if (strlen(dirent->d_name) >= 4 && memcmp(dirent->d_name, "cpu", 3) == 0) {
                         char cpupath[256];
                         strcpy(cpupath, OP_DRIVER_BASE"/stats/");
                         strcat(cpupath, dirent->d_name);

                         strcpy(fullname, cpupath);
                         strcat(fullname, "/sample_received");
                         num = read_num(fullname);
                         printf("  %s %9u samples received\n", dirent->d_name, num);

                         strcpy(fullname, cpupath);
                         strcat(fullname, "/sample_lost_overflow");
                         num = read_num(fullname);
                         printf("  %s %9u samples lost overflow\n", dirent->d_name, num);

                         strcpy(fullname, cpupath);
                         strcat(fullname, "/sample_invalid_eip");
                         num = read_num(fullname);
                         printf("  %s %9u samples invalid eip\n", dirent->d_name, num);

                         strcpy(fullname, cpupath);
                         strcat(fullname, "/backtrace_aborted");
                         num = read_num(fullname);
                         printf("  %s %9u backtrace aborted\n", dirent->d_name, num);
                     }
                 }
                 closedir(dir);
             }

             num = read_num(OP_DRIVER_BASE"/backtrace_depth");
             printf("backtrace_depth: %u\n", num);
         }
     }
     else {
         printf("oprofiled is not running\n");
     }
 }

 void do_reset()
 {
     /*
      * Sending SIGHUP will result in the following crash in oprofiled when
      * profiling subsequent runs:
      * Stack Trace:
      * RELADDR   FUNCTION                         FILE:LINE
      *   00008cd8  add_node+12                    oprofilelibdb/db_insert.c:32
      *   00008d69  odb_update_node_with_offset+60 oprofilelibdb/db_insert.c:102
      *
      * However without sending SIGHUP oprofile cannot be restarted successfully.
      * As a temporary workaround, change do_reset into a no-op for now and kill
      * the old daemon in do_setup to start all over again as a heavy-weight
      * reset.
      */
 #if 0
     int pid = read_num(OP_DATA_DIR"/lock");
     if (pid >= 0)
         kill(pid, SIGHUP);  /* HUP makes oprofiled close its sample files */

     if (access(OP_DATA_DIR"/samples/current", R_OK) == 0)
       system("rm -r "OP_DATA_DIR"/samples/current");
 #endif
 }

 int main(int argc, char * const argv[])
 {
     int option_index;
     bool show_status = false;
     char* verbose_log = NULL;

     /* Initialize default strings */
     strcpy(vmlinux, "--no-vmlinux");
     strcpy(kernel_range, "");

     setup_device();

     while (1) {
         int c = getopt_long(argc, argv, "c:e:v:r:dhVtl:", long_options, &option_index);
         if (c == -1) {
             break;
         }
         switch (c) {
             case 0:
                 break;
             /* --callgraph */
             case 'c':
                 strncpy(callgraph, optarg, sizeof(callgraph));
                 break;
             /* --event */
             case 'e':
                 if (num_events == MAX_EVENTS) {
                     fprintf(stderr, "More than %d events specified\n",
                             MAX_EVENTS);
                     exit(1);
                 }
                 if (process_event(optarg)) {
                     exit(1);
                 }
                 break;
             /* --vmlinux */
             case 'v':
                 sprintf(vmlinux, "-k %s", optarg);
                 break;
             /* --kernel-range */
             case 'r':
                 sprintf(kernel_range, "-r %s", optarg);
                 break;
             case 'd':
             /* --dump */ {
                 int pid = read_num(OP_DATA_DIR"/lock");
                 echo_dev("1", 0, "dump", -1);
                 break;
             }
             /* --shutdown */
             case 'h': {
                 int pid = read_num(OP_DATA_DIR"/lock");
                 if (pid >= 0) {
                     kill(pid, SIGHUP); /* Politely ask the daemon to close files */
                     sleep(1);
                     kill(pid, SIGTERM);/* Politely ask the daemon to die */
                     sleep(1);
                     kill(pid, SIGKILL);
                 }
                 setup_session_dir();
                 break;
             }
             /* --verbose */
             case 'V':
                 verbose_print++;
                 break;
             /* --verbose-log */
             case 'l':
                 verbose_log = strdup(optarg);
                 break;
             /* --status */
             case 't':
                 show_status = true;
                 break;
             default:
                 usage();
                 exit(1);
         }
     }
     verbose("list_events = %d\n", list_events);
     verbose("setup = %d\n", setup);

     if (list_events) {
         do_list_events();
     }

     if (quick) {
         process_event(default_event);
         setup = 1;
     }

     if (timer) {
         setup = 1;
     }

     if (reset) {
         do_reset();
     }

     if (show_usage) {
         usage();
     }

     if (setup) {
         if (do_setup()) {
             fprintf(stderr, "do_setup failed");
             exit(1);
         }
     }

     if (strlen(callgraph)) {
         echo_dev(callgraph, 0, "backtrace_depth", -1);
     }

     if (num_events != 0 || timer != 0) {
         char command[1024];
         int i;

         strcpy(command, argv[0]);
         char* slash = strrchr(command, '/');
         strcpy(slash ? slash + 1 : command, "oprofiled --session-dir="OP_DATA_DIR);

 #if defined(__arm__) && !defined(WITH_ARM_V7_A)
         /* Since counter #3 can only handle CPU_CYCLES, check and shuffle the
          * order a bit so that the maximal number of events can be profiled
          * simultaneously
          */
         if (num_events == 3) {
             for (i = 0; i < num_events; i++) {
                 int event_idx = selected_events[i];

                 if (event_info[event_idx].id == 0xff) {
                     break;
                 }
             }

             /* No CPU_CYCLES is found */
             if (i == 3) {
                 fprintf(stderr, "You can only specify three events if one of "
                                 "them is CPU_CYCLES\n");
                 exit(1);
             }
             /* Swap CPU_CYCLES to counter #2 (starting from #0)*/
             else if (i != 2) {
                 int temp;

                 temp = selected_events[2];
                 selected_events[2] = selected_events[i];
                 selected_events[i] = temp;

                 temp = selected_counts[2];
                 selected_counts[2] = selected_counts[i];
                 selected_counts[i] = temp;
             }
         }
 #endif

         /* Configure the counters and enable them */
         for (i = 0; i < num_events; i++) {
             int event_idx = selected_events[i];
             int setup_result = 0;

             if (i == 0) {
                 snprintf(command + strlen(command), sizeof(command) - strlen(command),
                         " --events=");
             } else {
                 snprintf(command + strlen(command), sizeof(command) - strlen(command), ",");
             }
             /* Compose name:id:count:unit_mask:kernel:user, something like
              * --events=CYCLES_DATA_STALL:2:0:200000:0:1:1,....
              */
             snprintf(command + strlen(command), sizeof(command) - strlen(command),
                      "%s:%d:%d:%d:%d:1:1",
                      event_info[event_idx].name,
                      event_info[event_idx].id,
                      i,
                      selected_counts[i],
                      event_info[event_idx].um);

             setup_result |= echo_dev("1", 0, "user", i);
             setup_result |= echo_dev("1", 0, "kernel", i);
             setup_result |= echo_dev(NULL, event_info[event_idx].um, "unit_mask", i);
             setup_result |= echo_dev("1", 0, "enabled", i);
             setup_result |= echo_dev(NULL, selected_counts[i], "count", i);
             setup_result |= echo_dev(NULL, event_info[event_idx].id,
                                      "event", i);
             if (setup_result) {
                 fprintf(stderr, "Counter configuration failed for %s\n",
                         event_info[event_idx].name);
                 fprintf(stderr, "Did you do \"opcontrol --setup\" first?\n");
                 exit(1);
             }
         }

         if (timer == 0) {
             /* If not in timer mode, disable unused counters */
             for (i = num_events; i < max_events; i++) {
                 echo_dev("0", 0, "enabled", i);
             }
         } else {
             /* Timer mode uses empty event list */
             snprintf(command + strlen(command), sizeof(command) - strlen(command),
                     " --events=");
         }

         snprintf(command + strlen(command), sizeof(command) - strlen(command),
                 " %s", vmlinux);
         if (kernel_range[0]) {
             snprintf(command + strlen(command), sizeof(command) - strlen(command),
                     " %s", kernel_range);
         }

         if (verbose_log) {
             snprintf(command + strlen(command), sizeof(command) - strlen(command),
                     " --verbose=%s", verbose_log);
         }

         printf("Starting oprofiled...\n");
         verbose("command: %s\n", command);

         int rc = system(command);
         if (rc) {
             fprintf(stderr, "Failed, oprofile returned exit code: %d\n", rc);
         } else {
             sleep(2);
             printf("Ready\n");
         }
     }

     if (start) {
         echo_dev("1", 0, "enable", -1);
         int num = read_num(OP_DATA_DIR"/lock");

         if (num >= 0) {
             kill(num, SIGUSR1);
         }
     }

     if (stop) {
         echo_dev("1", 0, "dump", -1);
         echo_dev("0", 0, "enable", -1);
     }

     if (show_status) {
         do_status();
     }
 }
	/*
	* Copyright 2008, The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/*
	* Binary implementation of the original opcontrol script due to missing tools
	* like awk, test, etc.
	*/

	#include <unistd.h>
	#include <getopt.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <signal.h>
	#include <dirent.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <sys/wait.h>

	#include "op_config.h"

	#define verbose(fmt...) if (verbose_print) printf(fmt)

	struct event_info {
	int id;
	int counters;
	int um;
	const char *name;
	const char *explanation;
	};

	#define CTR(n) (1<<(n))

	#if defined(__i386__) \|\| defined(__x86_64__)
	struct event_info event_info_arch_perfmon[] = {
	#include "../events/i386/arch_perfmon/events.h"
	};

	#define MAX_EVENTS 2
	int min_count[MAX_EVENTS] = {60000, 100000};

	const char *default_event = "CPU_CLK_UNHALTED";
	#endif

	#if defined(__arm__)
	#if !defined(WITH_ARM_V7_A)
	struct event_info event_info_armv6[] = {
	#include "../events/arm/armv6/events.h"
	};

	#define MAX_EVENTS 3
	int min_count[MAX_EVENTS] = {150000, 200000, 250000};

	#else
	struct event_info event_info_armv7[] = {
	#include "../events/arm/armv7/events.h"
	};

	#define MAX_EVENTS 5
	int min_count[MAX_EVENTS] = {150000, 20000, 25000, 30000, 35000};
	#endif

	const char *default_event = "CPU_CYCLES";
	#endif

	#if defined(__mips__)
	struct event_info event_info_24K[] = {
	#include "../events/mips/24K/events.h"
	};
	struct event_info event_info_34K[] = {
	#include "../events/mips/34K/events.h"
	};
	struct event_info event_info_74K[] = {
	#include "../events/mips/74K/events.h"
	};
	struct event_info event_info_1004K[] = {
	#include "../events/mips/1004K/events.h"
	};

	#define MAX_EVENTS 4
	int min_count[MAX_EVENTS] = {150000, 20000, 25000, 30000};

	const char *default_event = "CYCLES";
	#endif /* defined(__mips__) */

	#define ARRAYSZ(x) (sizeof(x)/sizeof((x)[0]))

	struct cpuevents {
	const char *cpu;
	struct event_info *event_info;
	unsigned int nevents;
	} cpuevents[] = {
	#if defined(__i386__) \|\| defined(__x86_64__)
	{"i386/arch_perfmon", event_info_arch_perfmon, ARRAYSZ(event_info_arch_perfmon)},
	#endif /* defined(__i386__) \|\| defined(__x86_64__) */
	#if defined(__arm__)
	#if !defined(WITH_ARM_V7_A)
	{"arm/armv6", event_info_armv6, ARRAYSZ(event_info_armv6)},
	#else
	{"arm/armv7", event_info_armv7, ARRAYSZ(event_info_armv7)},
	#endif
	#endif /* defined(__arm__) */
	#if defined(__mips__)
	{"mips/24K", event_info_24K, ARRAYSZ(event_info_24K)},
	{"mips/34K", event_info_34K, ARRAYSZ(event_info_34K)},
	{"mips/74K", event_info_74K, ARRAYSZ(event_info_74K)},
	{"mips/1004K", event_info_1004K, ARRAYSZ(event_info_1004K)},
	#endif /* defined(__mips__) */
	};

	struct cpuevents *cpuevent;
	#define event_info cpuevent->event_info
	#define NEVENTS cpuevent->nevents

	int verbose_print;
	int list_events;
	int show_usage;
	int setup;
	int quick;
	int timer;
	int num_events;
	int start;
	int stop;
	int reset;

	int selected_events[MAX_EVENTS];
	int selected_counts[MAX_EVENTS];
	int max_events;

	char callgraph[8];
	char kernel_range[512];
	char vmlinux[512];

	struct option long_options[] = {
	{"help", 0, &show_usage, 1},
	{"list-events", 0, &list_events, 1},
	{"reset", 0, &reset, 1},
	{"setup", 0, &setup, 1},
	{"quick", 0, &quick, 1},
	{"timer", 0, &timer, 1},
	{"callgraph", 1, 0, 'c'},
	{"event", 1, 0, 'e'},
	{"vmlinux", 1, 0, 'v'},
	{"kernel-range", 1, 0, 'r'},
	{"start", 0, &start, 1},
	{"stop", 0, &stop, 1},
	{"dump", 0, 0, 'd'},
	{"shutdown", 0, 0, 'h'},
	{"status", 0, 0, 't'},
	{"verbose", 0, 0, 'V'},
	{"verbose-log", 1, 0, 'l'},
	{0, 0, 0, 0},
	};


	void usage()
	{
	printf("\nopcontrol: usage:\n"
	" --list-events list event types\n"
	" --help this message\n"
	" --verbose show extra status\n"
	" --verbose-log=lvl set daemon logging verbosity during setup\n"
	" levels are: all,sfile,arcs,samples,module,misc\n"
	" --setup setup directories\n"
	#if defined(__i386__) \|\| defined(__x86_64__)
	" --quick setup and select CPU_CLK_UNHALTED:60000\n"
	#elif defined(__arm__)
	" --quick setup and select CPU_CYCLES:150000\n"
	#elif defined(__mips__)
	" --quick setup and select CYCLES:150000\n"
	#endif
	" --timer timer-based profiling\n"
	" --status show configuration\n"
	" --start start data collection\n"
	" --stop stop data collection\n"
	" --reset clears out data from current session\n"
	" --shutdown kill the oprofile daemon\n"
	" --callgraph=depth callgraph depth\n"
	" --event=eventspec\n"
	" Choose an event. May be specified multiple times.\n"
	" eventspec is in the form of name[:count], where :\n"
	" name: event name, see \"opcontrol --list-events\"\n"
	" count: reset counter value\n"
	" --vmlinux=file vmlinux kernel image\n"
	" --kernel-range=start,end\n"
	" kernel range vma address in hexadecimal\n"
	);
	}

	int setup_device(void)
	{
	if (mkdir(OP_DRIVER_BASE, 0755)) {
	if (errno != EEXIST) {
	fprintf(stderr, "Cannot create directory "OP_DRIVER_BASE": %s\n",
	strerror(errno));
	return -1;
	}
	}

	if (access(OP_DRIVER_BASE"/stats", F_OK)) {
	if (system("mount -t oprofilefs nodev "OP_DRIVER_BASE)) {
	return -1;
	}
	}

	/* Selecting the event information by cpu_type has only been tested on MIPS */
	#if defined(__mips__)
	/* Use cpu_type to select the events */
	int fd = open(OP_DRIVER_BASE "/cpu_type", O_RDONLY);
	if (fd < 0) {
	fprintf(stderr, OP_DRIVER_BASE "/cpu_type: %s\n",
	strerror(errno));
	return -1;
	}

	char buf[512];
	int n = read(fd, buf, sizeof(buf)-1);
	close(fd);
	if (n < 0) {
	fprintf(stderr, OP_DRIVER_BASE "/cpu_type: %s\n",
	strerror(errno));
	return -1;
	}
	buf[n] = '\0';
	for (unsigned int i = 0; i < ARRAYSZ(cpuevents); i++) {
	if (strcmp(buf, cpuevents[i].cpu) == 0) {
	cpuevent = &cpuevents[i];
	}
	}
	if (cpuevent == NULL) {
	fprintf(stderr, "Unrecognised CPU type %s\n", buf);
	return -1;
	}
	for (max_events = 0; max_events < MAX_EVENTS; max_events++) {
	snprintf(buf, sizeof(buf), OP_DRIVER_BASE"/%d", max_events);
	if (access(buf, F_OK) < 0)
	break;
	}
	#else
	max_events = MAX_EVENTS;
	cpuevent = &cpuevents[0];
	#endif
	return 0;
	}

	void setup_session_dir()
	{
	if (access(OP_DATA_DIR, F_OK) == 0)
	system("rm -r "OP_DATA_DIR);

	if (mkdir(OP_DATA_DIR, 0755)) {
	fprintf(stderr, "Cannot create directory \"%s\": %s\n",
	OP_DATA_DIR, strerror(errno));
	}
	if (mkdir(OP_DATA_DIR"/samples", 0755)) {
	fprintf(stderr, "Cannot create directory \"%s\": %s\n",
	OP_DATA_DIR"/samples", strerror(errno));
	}
	}

	int read_num(const char* file)
	{
	char buffer[256];
	int fd = open(file, O_RDONLY);
	if (fd<0) return -1;
	int rd = read(fd, buffer, sizeof(buffer)-1);
	buffer[rd] = 0;
	close(fd);
	return atoi(buffer);
	}

	int do_setup()
	{
	char dir[1024];

	/*
	* Kill the old daemon so that setup can be done more than once to achieve
	* the same effect as reset.
	*/
	int num = read_num(OP_DATA_DIR"/lock");
	if (num >= 0) {
	printf("Terminating the old daemon...\n");
	kill(num, SIGTERM);
	sleep(5);
	}

	setup_session_dir();

	return 0;
	}

	void stringify_counters(char *ctr_string, int ctr_mask)
	{
	int i, n, len;
	char *p = ctr_string;

	*p = '\0';
	for (i=0; i<32; ++i) {
	if (ctr_mask & (1<<i)) {
	p += sprintf(p, "%d,", i);
	}
	}
	if (p != ctr_string) {
	(p-1) = '\0'; / erase the final comma */
	}
	}

	void do_list_events()
	{
	unsigned int i;
	char ctrs[32*3+1];

	printf("%-12s \| %-30s: %s\n", "counter", "name", "meaning");
	printf("----------------------------------------"
	"--------------------------------------\n");
	for (i = 0; i < NEVENTS; i++) {
	stringify_counters(ctrs, event_info[i].counters);
	printf("%-12s \| %-30s: %s\n", ctrs, event_info[i].name, event_info[i].explanation);
	}
	}

	int find_event_idx_from_name(const char *name)
	{
	unsigned int i;

	for (i = 0; i < NEVENTS; i++) {
	if (!strcmp(name, event_info[i].name)) {
	return i;
	}
	}
	return -1;
	}

	const char * find_event_name_from_id(int id, int mask)
	{
	unsigned int i;

	for (i = 0; i < NEVENTS; i++) {
	if (event_info[i].id == id && (event_info[i].counters == 0 \|\| (event_info[i].counters & mask))) {
	return event_info[i].name;
	}
	}
	return "Undefined Event";
	}

	int process_event(const char *event_spec)
	{
	char event_name[512];
	char count_name[512];
	unsigned int i;
	int event_idx;
	int count_val;

	strncpy(event_name, event_spec, 512);
	count_name[0] = 0;

	/* First, check if the name is followed by ":" */
	for (i = 0; i < strlen(event_name); i++) {
	if (event_name[i] == 0) {
	break;
	}
	if (event_name[i] == ':') {
	strncpy(count_name, event_name+i+1, 512);
	event_name[i] = 0;
	break;
	}
	}
	event_idx = find_event_idx_from_name(event_name);
	if (event_idx == -1) {
	fprintf(stderr, "Unknown event name: %s\n", event_name);
	return -1;
	}

	/*
	* check that the named event is valid for this event counter
	* 'num_events' represents the cpu internal counter number
	*/
	verbose("idx: %d, name: %s, mask: %02x, ctr#: %d\n",
	event_idx, event_info[event_idx].name,
	event_info[event_idx].counters, num_events);
	if (event_info[event_idx].counters != 0 &&
	(event_info[event_idx].counters & CTR(num_events)) == 0) {
	fprintf(stderr, "Bad event name: %s for counter %d, see --list\n",
	event_name, num_events);
	return -1;
	}

	/* Use default count */
	if (count_name[0] == 0) {
	count_val = min_count[0];
	} else {
	count_val = atoi(count_name);
	}

	selected_events[num_events] = event_idx;
	selected_counts[num_events++] = count_val;
	verbose("event_id is %d\n", event_info[event_idx].id);
	verbose("count_val is %d\n", count_val);
	return 0;
	}

	int echo_dev(const char* str, int val, const char* file, int counter)
	{
	char fullname[512];
	char content[128];
	int fd;

	if (counter >= 0) {
	snprintf(fullname, 512, OP_DRIVER_BASE"/%d/%s", counter, file);
	}
	else {
	snprintf(fullname, 512, OP_DRIVER_BASE"/%s", file);
	}
	fd = open(fullname, O_WRONLY);
	if (fd<0) {
	fprintf(stderr, "Cannot open %s: %s\n", fullname, strerror(errno));
	return fd;
	}
	if (str == 0) {
	sprintf(content, "%d", val);
	}
	else {
	strncpy(content, str, 128);
	}
	verbose("Configure %s (%s)\n", fullname, content);
	write(fd, content, strlen(content));
	close(fd);
	return 0;
	}

	void do_status()
	{
	int num;
	char fullname[512];
	int i;

	printf("Driver directory: %s\n", OP_DRIVER_BASE);
	printf("Session directory: %s\n", OP_DATA_DIR);
	for (i = 0; i < max_events; i++) {
	sprintf(fullname, OP_DRIVER_BASE"/%d/enabled", i);
	num = read_num(fullname);
	if (num > 0) {
	printf("Counter %d:\n", i);

	/* event name */
	sprintf(fullname, OP_DRIVER_BASE"/%d/event", i);
	num = read_num(fullname);
	printf(" name: %s\n", find_event_name_from_id(num, CTR(i)));

	/* profile interval */
	sprintf(fullname, OP_DRIVER_BASE"/%d/count", i);
	num = read_num(fullname);
	printf(" count: %d\n", num);
	}
	else {
	printf("Counter %d disabled\n", i);
	}
	}

	num = read_num(OP_DATA_DIR"/lock");
	if (num >= 0) {
	/* Still needs to check if this lock is left-over */
	sprintf(fullname, "/proc/%d", num);
	if (access(fullname, R_OK) != 0) {
	printf("OProfile daemon exited prematurely - redo setup"
	" before you continue\n");
	return;
	}
	else {

	printf("oprofiled pid: %d\n", num);
	num = read_num(OP_DRIVER_BASE"/enable");

	printf("profiler is%s running\n", num == 0 ? " not" : "");

	DIR* dir = opendir(OP_DRIVER_BASE"/stats");
	if (dir) {
	for (struct dirent* dirent; !!(dirent = readdir(dir));) {
	if (strlen(dirent->d_name) >= 4 && memcmp(dirent->d_name, "cpu", 3) == 0) {
	char cpupath[256];
	strcpy(cpupath, OP_DRIVER_BASE"/stats/");
	strcat(cpupath, dirent->d_name);

	strcpy(fullname, cpupath);
	strcat(fullname, "/sample_received");
	num = read_num(fullname);
	printf(" %s %9u samples received\n", dirent->d_name, num);

	strcpy(fullname, cpupath);
	strcat(fullname, "/sample_lost_overflow");
	num = read_num(fullname);
	printf(" %s %9u samples lost overflow\n", dirent->d_name, num);

	strcpy(fullname, cpupath);
	strcat(fullname, "/sample_invalid_eip");
	num = read_num(fullname);
	printf(" %s %9u samples invalid eip\n", dirent->d_name, num);

	strcpy(fullname, cpupath);
	strcat(fullname, "/backtrace_aborted");
	num = read_num(fullname);
	printf(" %s %9u backtrace aborted\n", dirent->d_name, num);
	}
	}
	closedir(dir);
	}

	num = read_num(OP_DRIVER_BASE"/backtrace_depth");
	printf("backtrace_depth: %u\n", num);
	}
	}
	else {
	printf("oprofiled is not running\n");
	}
	}

	void do_reset()
	{
	/*
	* Sending SIGHUP will result in the following crash in oprofiled when
	* profiling subsequent runs:
	* Stack Trace:
	* RELADDR FUNCTION FILE:LINE
	* 00008cd8 add_node+12 oprofilelibdb/db_insert.c:32
	* 00008d69 odb_update_node_with_offset+60 oprofilelibdb/db_insert.c:102
	*
	* However without sending SIGHUP oprofile cannot be restarted successfully.
	* As a temporary workaround, change do_reset into a no-op for now and kill
	* the old daemon in do_setup to start all over again as a heavy-weight
	* reset.
	*/
	#if 0
	int pid = read_num(OP_DATA_DIR"/lock");
	if (pid >= 0)
	kill(pid, SIGHUP); /* HUP makes oprofiled close its sample files */

	if (access(OP_DATA_DIR"/samples/current", R_OK) == 0)
	system("rm -r "OP_DATA_DIR"/samples/current");
	#endif
	}

	int main(int argc, char * const argv[])
	{
	int option_index;
	bool show_status = false;
	char* verbose_log = NULL;

	/* Initialize default strings */
	strcpy(vmlinux, "--no-vmlinux");
	strcpy(kernel_range, "");

	setup_device();

	while (1) {
	int c = getopt_long(argc, argv, "c:e:v:r:dhVtl:", long_options, &option_index);
	if (c == -1) {
	break;
	}
	switch (c) {
	case 0:
	break;
	/* --callgraph */
	case 'c':
	strncpy(callgraph, optarg, sizeof(callgraph));
	break;
	/* --event */
	case 'e':
	if (num_events == MAX_EVENTS) {
	fprintf(stderr, "More than %d events specified\n",
	MAX_EVENTS);
	exit(1);
	}
	if (process_event(optarg)) {
	exit(1);
	}
	break;
	/* --vmlinux */
	case 'v':
	sprintf(vmlinux, "-k %s", optarg);
	break;
	/* --kernel-range */
	case 'r':
	sprintf(kernel_range, "-r %s", optarg);
	break;
	case 'd':
	/* --dump */ {
	int pid = read_num(OP_DATA_DIR"/lock");
	echo_dev("1", 0, "dump", -1);
	break;
	}
	/* --shutdown */
	case 'h': {
	int pid = read_num(OP_DATA_DIR"/lock");
	if (pid >= 0) {
	kill(pid, SIGHUP); /* Politely ask the daemon to close files */
	sleep(1);
	kill(pid, SIGTERM);/* Politely ask the daemon to die */
	sleep(1);
	kill(pid, SIGKILL);
	}
	setup_session_dir();
	break;
	}
	/* --verbose */
	case 'V':
	verbose_print++;
	break;
	/* --verbose-log */
	case 'l':
	verbose_log = strdup(optarg);
	break;
	/* --status */
	case 't':
	show_status = true;
	break;
	default:
	usage();
	exit(1);
	}
	}
	verbose("list_events = %d\n", list_events);
	verbose("setup = %d\n", setup);

	if (list_events) {
	do_list_events();
	}

	if (quick) {
	process_event(default_event);
	setup = 1;
	}

	if (timer) {
	setup = 1;
	}

	if (reset) {
	do_reset();
	}

	if (show_usage) {
	usage();
	}

	if (setup) {
	if (do_setup()) {
	fprintf(stderr, "do_setup failed");
	exit(1);
	}
	}

	if (strlen(callgraph)) {
	echo_dev(callgraph, 0, "backtrace_depth", -1);
	}

	if (num_events != 0 \|\| timer != 0) {
	char command[1024];
	int i;

	strcpy(command, argv[0]);
	char* slash = strrchr(command, '/');
	strcpy(slash ? slash + 1 : command, "oprofiled --session-dir="OP_DATA_DIR);

	#if defined(__arm__) && !defined(WITH_ARM_V7_A)
	/* Since counter #3 can only handle CPU_CYCLES, check and shuffle the
	* order a bit so that the maximal number of events can be profiled
	* simultaneously
	*/
	if (num_events == 3) {
	for (i = 0; i < num_events; i++) {
	int event_idx = selected_events[i];

	if (event_info[event_idx].id == 0xff) {
	break;
	}
	}

	/* No CPU_CYCLES is found */
	if (i == 3) {
	fprintf(stderr, "You can only specify three events if one of "
	"them is CPU_CYCLES\n");
	exit(1);
	}
	/* Swap CPU_CYCLES to counter #2 (starting from #0)*/
	else if (i != 2) {
	int temp;

	temp = selected_events[2];
	selected_events[2] = selected_events[i];
	selected_events[i] = temp;

	temp = selected_counts[2];
	selected_counts[2] = selected_counts[i];
	selected_counts[i] = temp;
	}
	}
	#endif

	/* Configure the counters and enable them */
	for (i = 0; i < num_events; i++) {
	int event_idx = selected_events[i];
	int setup_result = 0;

	if (i == 0) {
	snprintf(command + strlen(command), sizeof(command) - strlen(command),
	" --events=");
	} else {
	snprintf(command + strlen(command), sizeof(command) - strlen(command), ",");
	}
	/* Compose name:id:count:unit_mask:kernel:user, something like
	* --events=CYCLES_DATA_STALL:2:0:200000:0:1:1,....
	*/
	snprintf(command + strlen(command), sizeof(command) - strlen(command),
	"%s:%d:%d:%d:%d:1:1",
	event_info[event_idx].name,
	event_info[event_idx].id,
	i,
	selected_counts[i],
	event_info[event_idx].um);

	setup_result \|= echo_dev("1", 0, "user", i);
	setup_result \|= echo_dev("1", 0, "kernel", i);
	setup_result \|= echo_dev(NULL, event_info[event_idx].um, "unit_mask", i);
	setup_result \|= echo_dev("1", 0, "enabled", i);
	setup_result \|= echo_dev(NULL, selected_counts[i], "count", i);
	setup_result \|= echo_dev(NULL, event_info[event_idx].id,
	"event", i);
	if (setup_result) {
	fprintf(stderr, "Counter configuration failed for %s\n",
	event_info[event_idx].name);
	fprintf(stderr, "Did you do \"opcontrol --setup\" first?\n");
	exit(1);
	}
	}

	if (timer == 0) {
	/* If not in timer mode, disable unused counters */
	for (i = num_events; i < max_events; i++) {
	echo_dev("0", 0, "enabled", i);
	}
	} else {
	/* Timer mode uses empty event list */
	snprintf(command + strlen(command), sizeof(command) - strlen(command),
	" --events=");
	}

	snprintf(command + strlen(command), sizeof(command) - strlen(command),
	" %s", vmlinux);
	if (kernel_range[0]) {
	snprintf(command + strlen(command), sizeof(command) - strlen(command),
	" %s", kernel_range);
	}

	if (verbose_log) {
	snprintf(command + strlen(command), sizeof(command) - strlen(command),
	" --verbose=%s", verbose_log);
	}

	printf("Starting oprofiled...\n");
	verbose("command: %s\n", command);

	int rc = system(command);
	if (rc) {
	fprintf(stderr, "Failed, oprofile returned exit code: %d\n", rc);
	} else {
	sleep(2);
	printf("Ready\n");
	}
	}

	if (start) {
	echo_dev("1", 0, "enable", -1);
	int num = read_num(OP_DATA_DIR"/lock");

	if (num >= 0) {
	kill(num, SIGUSR1);
	}
	}

	if (stop) {
	echo_dev("1", 0, "dump", -1);
	echo_dev("0", 0, "enable", -1);
	}

	if (show_status) {
	do_status();
	}
	}