~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/perf/util/util.c

Version: ~ [ linux-5.13-rc5 ] ~ [ linux-5.12.9 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.42 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.124 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.193 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.235 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.271 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.271 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 #include "util.h"
  3 #include "debug.h"
  4 #include "event.h"
  5 #include <api/fs/fs.h>
  6 #include <sys/stat.h>
  7 #include <sys/utsname.h>
  8 #include <dirent.h>
  9 #include <fcntl.h>
 10 #include <inttypes.h>
 11 #include <signal.h>
 12 #include <stdio.h>
 13 #include <stdlib.h>
 14 #include <string.h>
 15 #include <errno.h>
 16 #include <limits.h>
 17 #include <linux/capability.h>
 18 #include <linux/kernel.h>
 19 #include <linux/log2.h>
 20 #include <linux/time64.h>
 21 #include <unistd.h>
 22 #include "cap.h"
 23 #include "strlist.h"
 24 #include "string2.h"
 25 
 26 /*
 27  * XXX We need to find a better place for these things...
 28  */
 29 
 30 bool perf_singlethreaded = true;
 31 
 32 void perf_set_singlethreaded(void)
 33 {
 34         perf_singlethreaded = true;
 35 }
 36 
 37 void perf_set_multithreaded(void)
 38 {
 39         perf_singlethreaded = false;
 40 }
 41 
 42 int sysctl_perf_event_max_stack = PERF_MAX_STACK_DEPTH;
 43 int sysctl_perf_event_max_contexts_per_stack = PERF_MAX_CONTEXTS_PER_STACK;
 44 
 45 int sysctl__max_stack(void)
 46 {
 47         int value;
 48 
 49         if (sysctl__read_int("kernel/perf_event_max_stack", &value) == 0)
 50                 sysctl_perf_event_max_stack = value;
 51 
 52         if (sysctl__read_int("kernel/perf_event_max_contexts_per_stack", &value) == 0)
 53                 sysctl_perf_event_max_contexts_per_stack = value;
 54 
 55         return sysctl_perf_event_max_stack;
 56 }
 57 
 58 bool sysctl__nmi_watchdog_enabled(void)
 59 {
 60         static bool cached;
 61         static bool nmi_watchdog;
 62         int value;
 63 
 64         if (cached)
 65                 return nmi_watchdog;
 66 
 67         if (sysctl__read_int("kernel/nmi_watchdog", &value) < 0)
 68                 return false;
 69 
 70         nmi_watchdog = (value > 0) ? true : false;
 71         cached = true;
 72 
 73         return nmi_watchdog;
 74 }
 75 
 76 bool test_attr__enabled;
 77 
 78 bool perf_host  = true;
 79 bool perf_guest = false;
 80 
 81 void event_attr_init(struct perf_event_attr *attr)
 82 {
 83         if (!perf_host)
 84                 attr->exclude_host  = 1;
 85         if (!perf_guest)
 86                 attr->exclude_guest = 1;
 87         /* to capture ABI version */
 88         attr->size = sizeof(*attr);
 89 }
 90 
 91 int mkdir_p(char *path, mode_t mode)
 92 {
 93         struct stat st;
 94         int err;
 95         char *d = path;
 96 
 97         if (*d != '/')
 98                 return -1;
 99 
100         if (stat(path, &st) == 0)
101                 return 0;
102 
103         while (*++d == '/');
104 
105         while ((d = strchr(d, '/'))) {
106                 *d = '\0';
107                 err = stat(path, &st) && mkdir(path, mode);
108                 *d++ = '/';
109                 if (err)
110                         return -1;
111                 while (*d == '/')
112                         ++d;
113         }
114         return (stat(path, &st) && mkdir(path, mode)) ? -1 : 0;
115 }
116 
117 static bool match_pat(char *file, const char **pat)
118 {
119         int i = 0;
120 
121         if (!pat)
122                 return true;
123 
124         while (pat[i]) {
125                 if (strglobmatch(file, pat[i]))
126                         return true;
127 
128                 i++;
129         }
130 
131         return false;
132 }
133 
134 /*
135  * The depth specify how deep the removal will go.
136  * 0       - will remove only files under the 'path' directory
137  * 1 .. x  - will dive in x-level deep under the 'path' directory
138  *
139  * If specified the pat is array of string patterns ended with NULL,
140  * which are checked upon every file/directory found. Only matching
141  * ones are removed.
142  *
143  * The function returns:
144  *    0 on success
145  *   -1 on removal failure with errno set
146  *   -2 on pattern failure
147  */
148 static int rm_rf_depth_pat(const char *path, int depth, const char **pat)
149 {
150         DIR *dir;
151         int ret;
152         struct dirent *d;
153         char namebuf[PATH_MAX];
154         struct stat statbuf;
155 
156         /* Do not fail if there's no file. */
157         ret = lstat(path, &statbuf);
158         if (ret)
159                 return 0;
160 
161         /* Try to remove any file we get. */
162         if (!(statbuf.st_mode & S_IFDIR))
163                 return unlink(path);
164 
165         /* We have directory in path. */
166         dir = opendir(path);
167         if (dir == NULL)
168                 return -1;
169 
170         while ((d = readdir(dir)) != NULL && !ret) {
171 
172                 if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
173                         continue;
174 
175                 if (!match_pat(d->d_name, pat)) {
176                         ret =  -2;
177                         break;
178                 }
179 
180                 scnprintf(namebuf, sizeof(namebuf), "%s/%s",
181                           path, d->d_name);
182 
183                 /* We have to check symbolic link itself */
184                 ret = lstat(namebuf, &statbuf);
185                 if (ret < 0) {
186                         pr_debug("stat failed: %s\n", namebuf);
187                         break;
188                 }
189 
190                 if (S_ISDIR(statbuf.st_mode))
191                         ret = depth ? rm_rf_depth_pat(namebuf, depth - 1, pat) : 0;
192                 else
193                         ret = unlink(namebuf);
194         }
195         closedir(dir);
196 
197         if (ret < 0)
198                 return ret;
199 
200         return rmdir(path);
201 }
202 
203 static int rm_rf_kcore_dir(const char *path)
204 {
205         char kcore_dir_path[PATH_MAX];
206         const char *pat[] = {
207                 "kcore",
208                 "kallsyms",
209                 "modules",
210                 NULL,
211         };
212 
213         snprintf(kcore_dir_path, sizeof(kcore_dir_path), "%s/kcore_dir", path);
214 
215         return rm_rf_depth_pat(kcore_dir_path, 0, pat);
216 }
217 
218 int rm_rf_perf_data(const char *path)
219 {
220         const char *pat[] = {
221                 "data",
222                 "data.*",
223                 NULL,
224         };
225 
226         rm_rf_kcore_dir(path);
227 
228         return rm_rf_depth_pat(path, 0, pat);
229 }
230 
231 int rm_rf(const char *path)
232 {
233         return rm_rf_depth_pat(path, INT_MAX, NULL);
234 }
235 
236 /* A filter which removes dot files */
237 bool lsdir_no_dot_filter(const char *name __maybe_unused, struct dirent *d)
238 {
239         return d->d_name[0] != '.';
240 }
241 
242 /* lsdir reads a directory and store it in strlist */
243 struct strlist *lsdir(const char *name,
244                       bool (*filter)(const char *, struct dirent *))
245 {
246         struct strlist *list = NULL;
247         DIR *dir;
248         struct dirent *d;
249 
250         dir = opendir(name);
251         if (!dir)
252                 return NULL;
253 
254         list = strlist__new(NULL, NULL);
255         if (!list) {
256                 errno = ENOMEM;
257                 goto out;
258         }
259 
260         while ((d = readdir(dir)) != NULL) {
261                 if (!filter || filter(name, d))
262                         strlist__add(list, d->d_name);
263         }
264 
265 out:
266         closedir(dir);
267         return list;
268 }
269 
270 size_t hex_width(u64 v)
271 {
272         size_t n = 1;
273 
274         while ((v >>= 4))
275                 ++n;
276 
277         return n;
278 }
279 
280 int perf_event_paranoid(void)
281 {
282         int value;
283 
284         if (sysctl__read_int("kernel/perf_event_paranoid", &value))
285                 return INT_MAX;
286 
287         return value;
288 }
289 
290 bool perf_event_paranoid_check(int max_level)
291 {
292         return perf_cap__capable(CAP_SYS_ADMIN) ||
293                         perf_cap__capable(CAP_PERFMON) ||
294                         perf_event_paranoid() <= max_level;
295 }
296 
297 static int
298 fetch_ubuntu_kernel_version(unsigned int *puint)
299 {
300         ssize_t len;
301         size_t line_len = 0;
302         char *ptr, *line = NULL;
303         int version, patchlevel, sublevel, err;
304         FILE *vsig;
305 
306         if (!puint)
307                 return 0;
308 
309         vsig = fopen("/proc/version_signature", "r");
310         if (!vsig) {
311                 pr_debug("Open /proc/version_signature failed: %s\n",
312                          strerror(errno));
313                 return -1;
314         }
315 
316         len = getline(&line, &line_len, vsig);
317         fclose(vsig);
318         err = -1;
319         if (len <= 0) {
320                 pr_debug("Reading from /proc/version_signature failed: %s\n",
321                          strerror(errno));
322                 goto errout;
323         }
324 
325         ptr = strrchr(line, ' ');
326         if (!ptr) {
327                 pr_debug("Parsing /proc/version_signature failed: %s\n", line);
328                 goto errout;
329         }
330 
331         err = sscanf(ptr + 1, "%d.%d.%d",
332                      &version, &patchlevel, &sublevel);
333         if (err != 3) {
334                 pr_debug("Unable to get kernel version from /proc/version_signature '%s'\n",
335                          line);
336                 goto errout;
337         }
338 
339         *puint = (version << 16) + (patchlevel << 8) + sublevel;
340         err = 0;
341 errout:
342         free(line);
343         return err;
344 }
345 
346 int
347 fetch_kernel_version(unsigned int *puint, char *str,
348                      size_t str_size)
349 {
350         struct utsname utsname;
351         int version, patchlevel, sublevel, err;
352         bool int_ver_ready = false;
353 
354         if (access("/proc/version_signature", R_OK) == 0)
355                 if (!fetch_ubuntu_kernel_version(puint))
356                         int_ver_ready = true;
357 
358         if (uname(&utsname))
359                 return -1;
360 
361         if (str && str_size) {
362                 strncpy(str, utsname.release, str_size);
363                 str[str_size - 1] = '\0';
364         }
365 
366         if (!puint || int_ver_ready)
367                 return 0;
368 
369         err = sscanf(utsname.release, "%d.%d.%d",
370                      &version, &patchlevel, &sublevel);
371 
372         if (err != 3) {
373                 pr_debug("Unable to get kernel version from uname '%s'\n",
374                          utsname.release);
375                 return -1;
376         }
377 
378         *puint = (version << 16) + (patchlevel << 8) + sublevel;
379         return 0;
380 }
381 
382 const char *perf_tip(const char *dirpath)
383 {
384         struct strlist *tips;
385         struct str_node *node;
386         char *tip = NULL;
387         struct strlist_config conf = {
388                 .dirname = dirpath,
389                 .file_only = true,
390         };
391 
392         tips = strlist__new("tips.txt", &conf);
393         if (tips == NULL)
394                 return errno == ENOENT ? NULL :
395                         "Tip: check path of tips.txt or get more memory! ;-p";
396 
397         if (strlist__nr_entries(tips) == 0)
398                 goto out;
399 
400         node = strlist__entry(tips, random() % strlist__nr_entries(tips));
401         if (asprintf(&tip, "Tip: %s", node->s) < 0)
402                 tip = (char *)"Tip: get more memory! ;-)";
403 
404 out:
405         strlist__delete(tips);
406 
407         return tip;
408 }
409 
410 char *perf_exe(char *buf, int len)
411 {
412         int n = readlink("/proc/self/exe", buf, len);
413         if (n > 0) {
414                 buf[n] = 0;
415                 return buf;
416         }
417         return strcpy(buf, "perf");
418 }
419 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp