tools/perf/util/target.c

   1 /*
   2  * Helper functions for handling target threads/cpus
   3  *
   4  * Copyright (C) 2012, LG Electronics, Namhyung Kim <namhyung.kim@lge.com>
   5  *
   6  * Released under the GPL v2.
   7  */
   8
   9 #include "target.h"
  10 #include "util.h"
  11 #include "debug.h"
  12
  13 #include <pwd.h>
  14 #include <string.h>
  15
  16
  17 enum target_errno target__validate(struct target *target)
  18 {
  19         enum target_errno ret = TARGET_ERRNO__SUCCESS;
  20
  21         if (target->pid)
  22                 target->tid = target->pid;
  23
  24         /* CPU and PID are mutually exclusive */
  25         if (target->tid && target->cpu_list) {
  26                 target->cpu_list = NULL;
  27                 if (ret == TARGET_ERRNO__SUCCESS)
  28                         ret = TARGET_ERRNO__PID_OVERRIDE_CPU;
  29         }
  30
  31         /* UID and PID are mutually exclusive */
  32         if (target->tid && target->uid_str) {
  33                 target->uid_str = NULL;
  34                 if (ret == TARGET_ERRNO__SUCCESS)
  35                         ret = TARGET_ERRNO__PID_OVERRIDE_UID;
  36         }
  37
  38         /* UID and CPU are mutually exclusive */
  39         if (target->uid_str && target->cpu_list) {
  40                 target->cpu_list = NULL;
  41                 if (ret == TARGET_ERRNO__SUCCESS)
  42                         ret = TARGET_ERRNO__UID_OVERRIDE_CPU;
  43         }
  44
  45         /* PID and SYSTEM are mutually exclusive */
  46         if (target->tid && target->system_wide) {
  47                 target->system_wide = false;
  48                 if (ret == TARGET_ERRNO__SUCCESS)
  49                         ret = TARGET_ERRNO__PID_OVERRIDE_SYSTEM;
  50         }
  51
  52         /* UID and SYSTEM are mutually exclusive */
  53         if (target->uid_str && target->system_wide) {
  54                 target->system_wide = false;
  55                 if (ret == TARGET_ERRNO__SUCCESS)
  56                         ret = TARGET_ERRNO__UID_OVERRIDE_SYSTEM;
  57         }
  58
  59         /* THREAD and SYSTEM/CPU are mutually exclusive */
  60         if (target->per_thread && (target->system_wide || target->cpu_list)) {
  61                 target->per_thread = false;
  62                 if (ret == TARGET_ERRNO__SUCCESS)
  63                         ret = TARGET_ERRNO__SYSTEM_OVERRIDE_THREAD;
  64         }
  65
  66         return ret;
  67 }
  68
  69 enum target_errno target__parse_uid(struct target *target)
  70 {
  71         struct passwd pwd, *result;
  72         char buf[1024];
  73         const char *str = target->uid_str;
  74
  75         target->uid = UINT_MAX;
  76         if (str == NULL)
  77                 return TARGET_ERRNO__SUCCESS;
  78
  79         /* Try user name first */
  80         getpwnam_r(str, &pwd, buf, sizeof(buf), &result);
  81
  82         if (result == NULL) {
  83                 /*
  84                  * The user name not found. Maybe it's a UID number.
  85                  */
  86                 char *endptr;
  87                 int uid = strtol(str, &endptr, 10);
  88
  89                 if (*endptr != '\0')
  90                         return TARGET_ERRNO__INVALID_UID;
  91
  92                 getpwuid_r(uid, &pwd, buf, sizeof(buf), &result);
  93
  94                 if (result == NULL)
  95                         return TARGET_ERRNO__USER_NOT_FOUND;
  96         }
  97
  98         target->uid = result->pw_uid;
  99         return TARGET_ERRNO__SUCCESS;
 100 }
 101
 102 /*
 103  * This must have a same ordering as the enum target_errno.
 104  */
 105 static const char *target__error_str[] = {
 106         "PID/TID switch overriding CPU",
 107         "PID/TID switch overriding UID",
 108         "UID switch overriding CPU",
 109         "PID/TID switch overriding SYSTEM",
 110         "UID switch overriding SYSTEM",
 111         "SYSTEM/CPU switch overriding PER-THREAD",
 112         "Invalid User: %s",
 113         "Problems obtaining information for user %s",
 114 };
 115
 116 int target__strerror(struct target *target, int errnum,
 117                           char *buf, size_t buflen)
 118 {
 119         int idx;
 120         const char *msg;
 121
 122         BUG_ON(buflen == 0);
 123
 124         if (errnum >= 0) {
 125                 const char *err = str_error_r(errnum, buf, buflen);
 126
 127                 if (err != buf)
 128                         scnprintf(buf, buflen, "%s", err);
 129
 130                 return 0;
 131         }
 132
 133         if (errnum <  __TARGET_ERRNO__START || errnum >= __TARGET_ERRNO__END)
 134                 return -1;
 135
 136         idx = errnum - __TARGET_ERRNO__START;
 137         msg = target__error_str[idx];
 138
 139         switch (errnum) {
 140         case TARGET_ERRNO__PID_OVERRIDE_CPU ...
 141              TARGET_ERRNO__SYSTEM_OVERRIDE_THREAD:
 142                 snprintf(buf, buflen, "%s", msg);
 143                 break;
 144
 145         case TARGET_ERRNO__INVALID_UID:
 146         case TARGET_ERRNO__USER_NOT_FOUND:
 147                 snprintf(buf, buflen, msg, target->uid_str);
 148                 break;
 149
 150         default:
 151                 /* cannot reach here */
 152                 break;
 153         }
 154
 155         return 0;
 156 }