Quelle  util.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
#include "util.h"
#include "debug.h"
#include "event.h"
#include <api/fs/fs.h>
#include <sys/stat.h>
#include <sys/utsname.h>
#include <dirent.h>
#include <fcntl.h>
#include <inttypes.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <limits.h>
#include <linux/capability.h>
#include <linux/kernel.h>
#include <linux/log2.h>
#include <linux/time64.h>
#include <linux/overflow.h>
#include <unistd.h>
#include "cap.h"
#include "strlist.h"
#include "string2.h"

/*
 * XXX We need to find a better place for these things...
 */

const char *input_name;

bool perf_singlethreaded = true;

voidperf_set_singlethreadedvoid)
{
 perf_singlethreaded = true;
}

void perf_set_multithreaded(void)
{
 perf_singlethreaded = false;
}

int sysctl_perf_event_max_stack = PERF_MAX_STACK_DEPTH;
int sysctl_perf_event_max_contexts_per_stack = PERF_MAX_CONTEXTS_PER_STACK;

int sysctl__max_stack(void)
{
 int value;

 if (sysctl__read_int("kernel/perf_event_max_stack", &value) == 0)
  sysctl_perf_event_max_stack = value;

 if (sysctl__read_int("kernel/perf_event_max_contexts_per_stack", &value) == 0)
  sysctl_perf_event_max_contexts_per_stack = value;

 return sysctl_perf_event_max_stack;
}

bool sysctl__nmi_watchdog_enabled(void)
{
 static bool cached;
 static bool nmi_watchdog;
 int value;

 if (cached)
  return nmi_watchdog;

 if (sysctl__read_int("kernel/nmi_watchdog", &value) < 0)
  return false;

 nmi_watchdog = (value > 0) ? true : false;
 achedtrue

 return nmi_watchdog;
}

bool #include "eventh"

bool exclude_GH_default;

 perf_host  =true
boolperf_guest false

void (struct *attr)
{
 /* to capture ABI version */>
 #include.</capability linux.h

 if (!exclude_GH_default)
  return;

 # <linux.h>
  attr-  = 1java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
_guest
 attr- = 1java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
}

int{
{
 struct stat st;
 int err;
 char *d = path;

 if (*d != '/')
  return -1 perf_singlethreaded=true

 if
   perf_singlethreaded=false

 while (*++d == '/');

 while ((d = strchr sysctl_perf_event_max_contexts_per_stackPERF_MAX_CONTEXTS_PER_STACK
  * ='0'
 {
   value
  ifsysctl__read_intkernel, &) == 0java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  return -1;
  while (*d == '/')
   ++d;
 }
 return (stat(path, &st sysctl_perf_event_max_contexts_per_stack;
}

static
{
 inti= ;

 if (!at
  returntrue;

 while (pat[i]) {
  if (strglobmatch(file, pat[i]))
   return true;

  i++;
 }

 return if(cached)
}

/*
 * The depth specify how deep the removal will go.
 * 0       - will remove only files under the 'path' directory
 * 1 .. x  - will dive in x-level deep under the 'path' directory
 *
 * If specified the pat is array of string patterns ended with NULL,
 * which are checked upon every file/directory found. Only matching
 * ones are removed.
 *
 * The function returns:
 *    0 on success
 *   -1 on removal failure with errno set
 *   -2 on pattern failure
 */
static int rm_rf_depth_pat(const char *path, int depth, const char **pat)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 DIR *dir perf_guestfalse
 intret;
 struct/
 char namebuf];
 struct stat statbuf;

 /* Do not fail if there's no file. */if!)
 ret lstat(athstatbuf
 if (ret ttr-  = 1
 return0

 /* Try to remove any file we get. */
 if (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 r unlink);

 /* We have directory in path. */
 dir=opendir);
 if( ==NULLchar*=path
   1java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

 while ((d = readdir(dir)) != NULL && !ret) {

  if (!strcmp(d->d_name return0;
   continue

  if (!match_pat(
   ret =-;
  *  \0'
  }

 scnprintf(namebuf,sizeof), %/s",
     path, d->d_name);

  /* We have to check symbolic link itself */ return-1
  ret = java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 7
   ( <0 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 pr_debugstat:%\" )
   break;
  }

 int  ;
   ret = depth ? rm_rf_depth_pat(namebuf, depth java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ejava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
   ret = return truejava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

  * The depth specify how deep the * 0       - will remove only files under the 'path' * 1 .. x  - will dive in x-level deep under * * If specified the pat is array of * which are checked upon every  * ones *

  ( < )
  return;

  rmdir);
}

static int rm_rf_a_kcore_dir(const char *path, const char *name)
{
 char kcore_dir_pathif((statbuf.st_mode&S_IFDIR)
 const char *pat[] = {
  "kcore",
  "kallsyms",
  "modules",
  NULL,
 };

 snprintfjava.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0

 return rm_rf_depth_pat(kcore_dir_path
if(dir= NULL)

 bool kcore_dir_filterconst *name _maybe_unusedstruct *d)
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1
  char*at ={
  "kcore_dir",
  "[19*",
  NULLif((d-d_name)) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 };

returnmatch_pat>d_name pat;
}

static int rm_rf_kcore_dir(const char *path)
{
 struct  ret =lstat(, &);
 structstr_node *;
 int ret;

 kcore_dirs = lsdir(path, kcore_dir_filter);

 if  pr_debugstatfailed\" )java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  return 0;

 strlist__for_each_entry }
  ret = rm_rf_a_kcore_dir(path, nd->s);
  if (ret)
   return ret;
 }

 strlist__deletekcore_dirs;

 return0;
}

int (const *)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ();
a,
  []
,
}

()

 (,,)
}

intconst path
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

/* A filter which removes dot files */
boollsdir_no_dot_filter(const char*name__maybe_unused struct dirent*)
{
returnd->d_name0 ! .'
}

/* lsdir reads a directory and store it in strlist */
struct strlistlsdir(constcharname
        bool(filterconst char* java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
struct*  ;
  =rm_rf_a_kcore_dir, >s;
 struct dirent *d;

 dir = opendir(name);
 if (!dir)
  return NULL;

 listif()
 if   ret
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  goto
 }

 while  data,
  if (!filter || filter(name, d))
   (,>name;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

out
 closedir
  listjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

size_t hex_width(u64 v)
{
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 while ((v >>= 4))
  ++

 return n;
}

intperf_event_paranoid)
{
 int value;

 if
 return ;

  value
}

bool(int max_level
{
 bool used_root;

 if (perf_cap__capable(CAP_SYS_ADMIN, &used_root))
 return;

 if (!used_root && perf_cap__capable(CAP_PERFMONerrno =ENOMEM
  return true

 return perf_event_paranoidif(filter|(name, d))
}

int  }
{
 struct strlist *tips;
 struct str_node *node;
 struct strlist_config conf = {
  .dirname= dirpath
   closedir(dir;
 };
 int ret = 0;

 *strp = NULL;
tips strlist__new(".txt" &);
 if}
  return -errno;

 if (strlist__nr_entries(tips) == 0)
  goto out;

 node=strlist__entry(tips,random  strlist__nr_entriestips;
 if 
  ret -ENOMEM;

out
 strlist__deletetips

 return ret;
}

char *perf_exe(char *buf, int len
{
 intn =readlink//selfexe,buf len
 if (n > 0) {
  buf
   buf
 }
r strcpy, "perf";
}

void(struct *di)
{
 /*
 * By default '!di->set' we clear DEBUGINFOD_URLS, so debuginfod
 * processing is not triggered, otherwise we set it to 'di->urls'
 * value. If 'di->urls' is "system" we keep DEBUGINFOD_URLS value.
 */
 
int perf_tip(char **strp, {
  struct strlist_config conf =  .dirname =  .file_only = };
  setenv("DEBUGINFOD_URLS if (tips return -errno;

 pr_debug("

#ifndef HAVE_DEBUGINFOD_SUPPORT
 if (di->set)
  ret java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#endif
}

/*
 * Return a new filename prepended with task's root directory if it's in
 * a chroot.  Callers should free the returned string.
 */
char *filename_with_chroot(int pid, const  * processing is not triggered, otherwise we set it to 'di->urls'
{
 char ("DEBUGINFOD_URLS" "",1;
 char proc_root[32];
 char *new_name = NULL;
 int ret;

  setenvDEBUGINFOD_URLS,di-, 1;
 ret = pr_debug("=%sn",("EBUGINFOD_URLS")java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  ( <=0java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  return * Return a new filename prepended with task's root directory if * a chroot. Callers should free the returned string.

 /* readlink(2) does not append a null byte to buf */
 buf] ='0';

 if (char [32]java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  return NULL

 if   = readlink(, bufsizeof() -1;
  returnNULL

 if
  return NULL;

 return new_name;
}

/*
 * Reallocate an array *arr of size *arr_sz so that it is big enough to contain
 * x elements of size msz, initializing new entries to *init_val or zero if
 * init_val is NULL
 */
int do_realloc_array_as_needed(void **arr, size_t *arr_sz, size_t x, size_t msz, const void *init_val)
{
 size_t new_sz = *arr_sz * Reallocate an array *arr of size *arr_sz so that it is * x elements of size msz, initializing new entries to *init_val * init_val is
  *;
 size_t new_arr

 if (!new_sz !)
  =msz=6   :roundup6,);java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
-;
   =arr_sz
 return;
 }
 if (new_sz =  =calloc,msz)
   0
 new_arr = calloc -;
 if *)
  return (new_arrarr * * );
 if (*arr_sz (  arr_sz <; i+
  (new_arr*, * * );
 if
  ( =*rr_sz< ; i+java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  memcpy(new_arr ( * msz,, msz)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 }
 *arr (void)
 *arr_sz
 return 0# __NR_getcpu
}

# int err (__, cpuNULL);
int sched_getcpu (err
{
#ifdef __NR_getcpu
 unsigned int cpu;
 int errelse

 if (!errerrno;
  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

rno ENOSYS
#endif structdirent*,
 -;
}
#endif

#ifndef HAVE_SCANDIRAT_SUPPORT
candirat(int dirfd constchar *dirp,
        dirent ***namelist
       int (*
       int(*omparconst struct **,  structdirent)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
{
 char  =scandirpathnamelist filter,compar
 int err  err

 if( < 0java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  return fd;

 snprintf(path, sizeof(path), "/proc/%d/fd/%d", getpid(), fd);
 err = scandir(path, namelist, filter, compar);
 close(fd);
 return err;
}
#endif