tools/perf/util/namespaces.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *
   4  * Copyright (C) 2017 Hari Bathini, IBM Corporation
   5  */
   6
   7 #include "namespaces.h"
   8 #include "event.h"
   9 #include "get_current_dir_name.h"
  10 #include <sys/types.h>
  11 #include <sys/stat.h>
  12 #include <fcntl.h>
  13 #include <limits.h>
  14 #include <sched.h>
  15 #include <stdlib.h>
  16 #include <stdio.h>
  17 #include <string.h>
  18 #include <unistd.h>
  19 #include <asm/bug.h>
  20 #include <linux/kernel.h>
  21 #include <linux/zalloc.h>
  22
  23 static const char *perf_ns__names[] = {
  24         [NET_NS_INDEX]          = "net",
  25         [UTS_NS_INDEX]          = "uts",
  26         [IPC_NS_INDEX]          = "ipc",
  27         [PID_NS_INDEX]          = "pid",
  28         [USER_NS_INDEX]         = "user",
  29         [MNT_NS_INDEX]          = "mnt",
  30         [CGROUP_NS_INDEX]       = "cgroup",
  31 };
  32
  33 const char *perf_ns__name(unsigned int id)
  34 {
  35         if (id >= ARRAY_SIZE(perf_ns__names))
  36                 return "UNKNOWN";
  37         return perf_ns__names[id];
  38 }
  39
  40 struct namespaces *namespaces__new(struct perf_record_namespaces *event)
  41 {
  42         struct namespaces *namespaces;
  43         u64 link_info_size = ((event ? event->nr_namespaces : NR_NAMESPACES) *
  44                               sizeof(struct perf_ns_link_info));
  45
  46         namespaces = zalloc(sizeof(struct namespaces) + link_info_size);
  47         if (!namespaces)
  48                 return NULL;
  49
  50         namespaces->end_time = -1;
  51
  52         if (event)
  53                 memcpy(namespaces->link_info, event->link_info, link_info_size);
  54
  55         return namespaces;
  56 }
  57
  58 void namespaces__free(struct namespaces *namespaces)
  59 {
  60         free(namespaces);
  61 }
  62
  63 static int nsinfo__get_nspid(struct nsinfo *nsi, const char *path)
  64 {
  65         FILE *f = NULL;
  66         char *statln = NULL;
  67         size_t linesz = 0;
  68         char *nspid;
  69
  70         f = fopen(path, "r");
  71         if (f == NULL)
  72                 return -1;
  73
  74         while (getline(&statln, &linesz, f) != -1) {
  75                 /* Use tgid if CONFIG_PID_NS is not defined. */
  76                 if (strstr(statln, "Tgid:") != NULL) {
  77                         nsi->tgid = (pid_t)strtol(strrchr(statln, '\t'),
  78                                                      NULL, 10);
  79                         nsi->nstgid = nsinfo__tgid(nsi);
  80                 }
  81
  82                 if (strstr(statln, "NStgid:") != NULL) {
  83                         nspid = strrchr(statln, '\t');
  84                         nsi->nstgid = (pid_t)strtol(nspid, NULL, 10);
  85                         /*
  86                          * If innermost tgid is not the first, process is in a different
  87                          * PID namespace.
  88                          */
  89                         nsi->in_pidns = (statln + sizeof("NStgid:") - 1) != nspid;
  90                         break;
  91                 }
  92         }
  93
  94         fclose(f);
  95         free(statln);
  96         return 0;
  97 }
  98
  99 int nsinfo__init(struct nsinfo *nsi)
 100 {
 101         char oldns[PATH_MAX];
 102         char spath[PATH_MAX];
 103         char *newns = NULL;
 104         struct stat old_stat;
 105         struct stat new_stat;
 106         int rv = -1;
 107
 108         if (snprintf(oldns, PATH_MAX, "/proc/self/ns/mnt") >= PATH_MAX)
 109                 return rv;
 110
 111         if (asprintf(&newns, "/proc/%d/ns/mnt", nsinfo__pid(nsi)) == -1)
 112                 return rv;
 113
 114         if (stat(oldns, &old_stat) < 0)
 115                 goto out;
 116
 117         if (stat(newns, &new_stat) < 0)
 118                 goto out;
 119
 120         /* Check if the mount namespaces differ, if so then indicate that we
 121          * want to switch as part of looking up dso/map data.
 122          */
 123         if (old_stat.st_ino != new_stat.st_ino) {
 124                 nsi->need_setns = true;
 125                 nsi->mntns_path = newns;
 126                 newns = NULL;
 127         }
 128
 129         /* If we're dealing with a process that is in a different PID namespace,
 130          * attempt to work out the innermost tgid for the process.
 131          */
 132         if (snprintf(spath, PATH_MAX, "/proc/%d/status", nsinfo__pid(nsi)) >= PATH_MAX)
 133                 goto out;
 134
 135         rv = nsinfo__get_nspid(nsi, spath);
 136
 137 out:
 138         free(newns);
 139         return rv;
 140 }
 141
 142 struct nsinfo *nsinfo__new(pid_t pid)
 143 {
 144         struct nsinfo *nsi;
 145
 146         if (pid == 0)
 147                 return NULL;
 148
 149         nsi = calloc(1, sizeof(*nsi));
 150         if (nsi != NULL) {
 151                 nsi->pid = pid;
 152                 nsi->tgid = pid;
 153                 nsi->nstgid = pid;
 154                 nsi->need_setns = false;
 155                 nsi->in_pidns = false;
 156                 /* Init may fail if the process exits while we're trying to look
 157                  * at its proc information.  In that case, save the pid but
 158                  * don't try to enter the namespace.
 159                  */
 160                 if (nsinfo__init(nsi) == -1)
 161                         nsi->need_setns = false;
 162
 163                 refcount_set(&nsi->refcnt, 1);
 164         }
 165
 166         return nsi;
 167 }
 168
 169 struct nsinfo *nsinfo__copy(const struct nsinfo *nsi)
 170 {
 171         struct nsinfo *nnsi;
 172
 173         if (nsi == NULL)
 174                 return NULL;
 175
 176         nnsi = calloc(1, sizeof(*nnsi));
 177         if (nnsi != NULL) {
 178                 nnsi->pid = nsinfo__pid(nsi);
 179                 nnsi->tgid = nsinfo__tgid(nsi);
 180                 nnsi->nstgid = nsinfo__nstgid(nsi);
 181                 nnsi->need_setns = nsinfo__need_setns(nsi);
 182                 nnsi->in_pidns = nsinfo__in_pidns(nsi);
 183                 if (nsi->mntns_path) {
 184                         nnsi->mntns_path = strdup(nsi->mntns_path);
 185                         if (!nnsi->mntns_path) {
 186                                 free(nnsi);
 187                                 return NULL;
 188                         }
 189                 }
 190                 refcount_set(&nnsi->refcnt, 1);
 191         }
 192
 193         return nnsi;
 194 }
 195
 196 static void nsinfo__delete(struct nsinfo *nsi)
 197 {
 198         zfree(&nsi->mntns_path);
 199         free(nsi);
 200 }
 201
 202 struct nsinfo *nsinfo__get(struct nsinfo *nsi)
 203 {
 204         if (nsi)
 205                 refcount_inc(&nsi->refcnt);
 206         return nsi;
 207 }
 208
 209 void nsinfo__put(struct nsinfo *nsi)
 210 {
 211         if (nsi && refcount_dec_and_test(&nsi->refcnt))
 212                 nsinfo__delete(nsi);
 213 }
 214
 215 bool nsinfo__need_setns(const struct nsinfo *nsi)
 216 {
 217         return nsi->need_setns;
 218 }
 219
 220 void nsinfo__clear_need_setns(struct nsinfo *nsi)
 221 {
 222         nsi->need_setns = false;
 223 }
 224
 225 pid_t nsinfo__tgid(const struct nsinfo  *nsi)
 226 {
 227         return nsi->tgid;
 228 }
 229
 230 pid_t nsinfo__nstgid(const struct nsinfo  *nsi)
 231 {
 232         return nsi->nstgid;
 233 }
 234
 235 pid_t nsinfo__pid(const struct nsinfo  *nsi)
 236 {
 237         return nsi->pid;
 238 }
 239
 240 pid_t nsinfo__in_pidns(const struct nsinfo  *nsi)
 241 {
 242         return nsi->in_pidns;
 243 }
 244
 245 void nsinfo__mountns_enter(struct nsinfo *nsi,
 246                                   struct nscookie *nc)
 247 {
 248         char curpath[PATH_MAX];
 249         int oldns = -1;
 250         int newns = -1;
 251         char *oldcwd = NULL;
 252
 253         if (nc == NULL)
 254                 return;
 255
 256         nc->oldns = -1;
 257         nc->newns = -1;
 258
 259         if (!nsi || !nsi->need_setns)
 260                 return;
 261
 262         if (snprintf(curpath, PATH_MAX, "/proc/self/ns/mnt") >= PATH_MAX)
 263                 return;
 264
 265         oldcwd = get_current_dir_name();
 266         if (!oldcwd)
 267                 return;
 268
 269         oldns = open(curpath, O_RDONLY);
 270         if (oldns < 0)
 271                 goto errout;
 272
 273         newns = open(nsi->mntns_path, O_RDONLY);
 274         if (newns < 0)
 275                 goto errout;
 276
 277         if (setns(newns, CLONE_NEWNS) < 0)
 278                 goto errout;
 279
 280         nc->oldcwd = oldcwd;
 281         nc->oldns = oldns;
 282         nc->newns = newns;
 283         return;
 284
 285 errout:
 286         free(oldcwd);
 287         if (oldns > -1)
 288                 close(oldns);
 289         if (newns > -1)
 290                 close(newns);
 291 }
 292
 293 void nsinfo__mountns_exit(struct nscookie *nc)
 294 {
 295         if (nc == NULL || nc->oldns == -1 || nc->newns == -1 || !nc->oldcwd)
 296                 return;
 297
 298         setns(nc->oldns, CLONE_NEWNS);
 299
 300         if (nc->oldcwd) {
 301                 WARN_ON_ONCE(chdir(nc->oldcwd));
 302                 zfree(&nc->oldcwd);
 303         }
 304
 305         if (nc->oldns > -1) {
 306                 close(nc->oldns);
 307                 nc->oldns = -1;
 308         }
 309
 310         if (nc->newns > -1) {
 311                 close(nc->newns);
 312                 nc->newns = -1;
 313         }
 314 }
 315
 316 char *nsinfo__realpath(const char *path, struct nsinfo *nsi)
 317 {
 318         char *rpath;
 319         struct nscookie nsc;
 320
 321         nsinfo__mountns_enter(nsi, &nsc);
 322         rpath = realpath(path, NULL);
 323         nsinfo__mountns_exit(&nsc);
 324
 325         return rpath;
 326 }
 327
 328 int nsinfo__stat(const char *filename, struct stat *st, struct nsinfo *nsi)
 329 {
 330         int ret;
 331         struct nscookie nsc;
 332
 333         nsinfo__mountns_enter(nsi, &nsc);
 334         ret = stat(filename, st);
 335         nsinfo__mountns_exit(&nsc);
 336
 337         return ret;
 338 }
 339
 340 bool nsinfo__is_in_root_namespace(void)
 341 {
 342         struct nsinfo nsi;
 343
 344         memset(&nsi, 0x0, sizeof(nsi));
 345         nsinfo__get_nspid(&nsi, "/proc/self/status");
 346         return !nsi.in_pidns;
 347 }