src/shared/bus-unit-procs.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include "bus-unit-procs.h"
   4 #include "glyph-util.h"
   5 #include "hashmap.h"
   6 #include "list.h"
   7 #include "macro.h"
   8 #include "path-util.h"
   9 #include "process-util.h"
  10 #include "sort-util.h"
  11 #include "string-util.h"
  12 #include "terminal-util.h"
  13
  14 struct CGroupInfo {
  15         char *cgroup_path;
  16         bool is_const; /* If false, cgroup_path should be free()'d */
  17
  18         Hashmap *pids; /* PID → process name */
  19         bool done;
  20
  21         struct CGroupInfo *parent;
  22         LIST_FIELDS(struct CGroupInfo, siblings);
  23         LIST_HEAD(struct CGroupInfo, children);
  24         size_t n_children;
  25 };
  26
  27 static int add_cgroup(Hashmap *cgroups, const char *path, bool is_const, struct CGroupInfo **ret) {
  28         struct CGroupInfo *parent = NULL, *cg;
  29         int r;
  30
  31         assert(cgroups);
  32         assert(ret);
  33
  34         path = empty_to_root(path);
  35
  36         cg = hashmap_get(cgroups, path);
  37         if (cg) {
  38                 *ret = cg;
  39                 return 0;
  40         }
  41
  42         if (!empty_or_root(path)) {
  43                 const char *e, *pp;
  44
  45                 e = strrchr(path, '/');
  46                 if (!e)
  47                         return -EINVAL;
  48
  49                 pp = strndupa_safe(path, e - path);
  50
  51                 r = add_cgroup(cgroups, pp, false, &parent);
  52                 if (r < 0)
  53                         return r;
  54         }
  55
  56         cg = new0(struct CGroupInfo, 1);
  57         if (!cg)
  58                 return -ENOMEM;
  59
  60         if (is_const)
  61                 cg->cgroup_path = (char*) path;
  62         else {
  63                 cg->cgroup_path = strdup(path);
  64                 if (!cg->cgroup_path) {
  65                         free(cg);
  66                         return -ENOMEM;
  67                 }
  68         }
  69
  70         cg->is_const = is_const;
  71         cg->parent = parent;
  72
  73         r = hashmap_put(cgroups, cg->cgroup_path, cg);
  74         if (r < 0) {
  75                 if (!is_const)
  76                         free(cg->cgroup_path);
  77                 free(cg);
  78                 return r;
  79         }
  80
  81         if (parent) {
  82                 LIST_PREPEND(siblings, parent->children, cg);
  83                 parent->n_children++;
  84         }
  85
  86         *ret = cg;
  87         return 1;
  88 }
  89
  90 static int add_process(
  91                 Hashmap *cgroups,
  92                 const char *path,
  93                 pid_t pid,
  94                 const char *name) {
  95
  96         struct CGroupInfo *cg;
  97         int r;
  98
  99         assert(cgroups);
 100         assert(name);
 101         assert(pid > 0);
 102
 103         r = add_cgroup(cgroups, path, true, &cg);
 104         if (r < 0)
 105                 return r;
 106
 107         return hashmap_ensure_put(&cg->pids, &trivial_hash_ops, PID_TO_PTR(pid), (void*) name);
 108 }
 109
 110 static void remove_cgroup(Hashmap *cgroups, struct CGroupInfo *cg) {
 111         assert(cgroups);
 112         assert(cg);
 113
 114         while (cg->children)
 115                 remove_cgroup(cgroups, cg->children);
 116
 117         hashmap_remove(cgroups, cg->cgroup_path);
 118
 119         if (!cg->is_const)
 120                 free(cg->cgroup_path);
 121
 122         hashmap_free(cg->pids);
 123
 124         if (cg->parent)
 125                 LIST_REMOVE(siblings, cg->parent->children, cg);
 126
 127         free(cg);
 128 }
 129
 130 static int cgroup_info_compare_func(struct CGroupInfo * const *a, struct CGroupInfo * const *b) {
 131         return strcmp((*a)->cgroup_path, (*b)->cgroup_path);
 132 }
 133
 134 static int dump_processes(
 135                 Hashmap *cgroups,
 136                 const char *cgroup_path,
 137                 const char *prefix,
 138                 unsigned n_columns,
 139                 OutputFlags flags) {
 140
 141         struct CGroupInfo *cg;
 142         int r;
 143
 144         assert(prefix);
 145
 146         cgroup_path = empty_to_root(cgroup_path);
 147
 148         cg = hashmap_get(cgroups, cgroup_path);
 149         if (!cg)
 150                 return 0;
 151
 152         if (!hashmap_isempty(cg->pids)) {
 153                 const char *name;
 154                 size_t n = 0, i;
 155                 pid_t *pids;
 156                 void *pidp;
 157                 int width;
 158
 159                 /* Order processes by their PID */
 160                 pids = newa(pid_t, hashmap_size(cg->pids));
 161
 162                 HASHMAP_FOREACH_KEY(name, pidp, cg->pids)
 163                         pids[n++] = PTR_TO_PID(pidp);
 164
 165                 assert(n == hashmap_size(cg->pids));
 166                 typesafe_qsort(pids, n, pid_compare_func);
 167
 168                 width = DECIMAL_STR_WIDTH(pids[n-1]);
 169
 170                 for (i = 0; i < n; i++) {
 171                         _cleanup_free_ char *e = NULL;
 172                         const char *special;
 173                         bool more;
 174
 175                         name = hashmap_get(cg->pids, PID_TO_PTR(pids[i]));
 176                         assert(name);
 177
 178                         if (n_columns != 0) {
 179                                 unsigned k;
 180
 181                                 k = MAX(LESS_BY(n_columns, 2U + width + 1U), 20U);
 182
 183                                 e = ellipsize(name, k, 100);
 184                                 if (e)
 185                                         name = e;
 186                         }
 187
 188                         more = i+1 < n || cg->children;
 189                         special = special_glyph(more ? SPECIAL_GLYPH_TREE_BRANCH : SPECIAL_GLYPH_TREE_RIGHT);
 190
 191                         fprintf(stdout, "%s%s%s%*"PID_PRI" %s%s\n",
 192                                 prefix,
 193                                 special,
 194                                 ansi_grey(),
 195                                 width, pids[i],
 196                                 name,
 197                                 ansi_normal());
 198                 }
 199         }
 200
 201         if (cg->children) {
 202                 struct CGroupInfo **children;
 203                 size_t n = 0, i;
 204
 205                 /* Order subcgroups by their name */
 206                 children = newa(struct CGroupInfo*, cg->n_children);
 207                 LIST_FOREACH(siblings, child, cg->children)
 208                         children[n++] = child;
 209                 assert(n == cg->n_children);
 210                 typesafe_qsort(children, n, cgroup_info_compare_func);
 211
 212                 if (n_columns != 0)
 213                         n_columns = MAX(LESS_BY(n_columns, 2U), 20U);
 214
 215                 for (i = 0; i < n; i++) {
 216                         _cleanup_free_ char *pp = NULL;
 217                         const char *name, *special;
 218                         bool more;
 219
 220                         name = strrchr(children[i]->cgroup_path, '/');
 221                         if (!name)
 222                                 return -EINVAL;
 223                         name++;
 224
 225                         more = i+1 < n;
 226                         special = special_glyph(more ? SPECIAL_GLYPH_TREE_BRANCH : SPECIAL_GLYPH_TREE_RIGHT);
 227
 228                         fputs(prefix, stdout);
 229                         fputs(special, stdout);
 230                         fputs(name, stdout);
 231                         fputc('\n', stdout);
 232
 233                         special = special_glyph(more ? SPECIAL_GLYPH_TREE_VERTICAL : SPECIAL_GLYPH_TREE_SPACE);
 234
 235                         pp = strjoin(prefix, special);
 236                         if (!pp)
 237                                 return -ENOMEM;
 238
 239                         r = dump_processes(cgroups, children[i]->cgroup_path, pp, n_columns, flags);
 240                         if (r < 0)
 241                                 return r;
 242                 }
 243         }
 244
 245         cg->done = true;
 246         return 0;
 247 }
 248
 249 static int dump_extra_processes(
 250                 Hashmap *cgroups,
 251                 const char *prefix,
 252                 unsigned n_columns,
 253                 OutputFlags flags) {
 254
 255         _cleanup_free_ pid_t *pids = NULL;
 256         _cleanup_hashmap_free_ Hashmap *names = NULL;
 257         struct CGroupInfo *cg;
 258         size_t n = 0, k;
 259         int width, r;
 260
 261         /* Prints the extra processes, i.e. those that are in cgroups we haven't displayed yet. We show them as
 262          * combined, sorted, linear list. */
 263
 264         HASHMAP_FOREACH(cg, cgroups) {
 265                 const char *name;
 266                 void *pidp;
 267
 268                 if (cg->done)
 269                         continue;
 270
 271                 if (hashmap_isempty(cg->pids))
 272                         continue;
 273
 274                 r = hashmap_ensure_allocated(&names, &trivial_hash_ops);
 275                 if (r < 0)
 276                         return r;
 277
 278                 if (!GREEDY_REALLOC(pids, n + hashmap_size(cg->pids)))
 279                         return -ENOMEM;
 280
 281                 HASHMAP_FOREACH_KEY(name, pidp, cg->pids) {
 282                         pids[n++] = PTR_TO_PID(pidp);
 283
 284                         r = hashmap_put(names, pidp, (void*) name);
 285                         if (r < 0)
 286                                 return r;
 287                 }
 288         }
 289
 290         if (n == 0)
 291                 return 0;
 292
 293         typesafe_qsort(pids, n, pid_compare_func);
 294         width = DECIMAL_STR_WIDTH(pids[n-1]);
 295
 296         for (k = 0; k < n; k++) {
 297                 _cleanup_free_ char *e = NULL;
 298                 const char *name;
 299
 300                 name = hashmap_get(names, PID_TO_PTR(pids[k]));
 301                 assert(name);
 302
 303                 if (n_columns != 0) {
 304                         unsigned z;
 305
 306                         z = MAX(LESS_BY(n_columns, 2U + width + 1U), 20U);
 307
 308                         e = ellipsize(name, z, 100);
 309                         if (e)
 310                                 name = e;
 311                 }
 312
 313                 fprintf(stdout, "%s%s %*" PID_PRI " %s\n",
 314                         prefix,
 315                         special_glyph(SPECIAL_GLYPH_TRIANGULAR_BULLET),
 316                         width, pids[k],
 317                         name);
 318         }
 319
 320         return 0;
 321 }
 322
 323 int unit_show_processes(
 324                 sd_bus *bus,
 325                 const char *unit,
 326                 const char *cgroup_path,
 327                 const char *prefix,
 328                 unsigned n_columns,
 329                 OutputFlags flags,
 330                 sd_bus_error *error) {
 331
 332         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 333         Hashmap *cgroups = NULL;
 334         struct CGroupInfo *cg;
 335         int r;
 336
 337         assert(bus);
 338         assert(unit);
 339
 340         if (flags & OUTPUT_FULL_WIDTH)
 341                 n_columns = 0;
 342         else if (n_columns <= 0)
 343                 n_columns = columns();
 344
 345         prefix = strempty(prefix);
 346
 347         r = sd_bus_call_method(
 348                         bus,
 349                         "org.freedesktop.systemd1",
 350                         "/org/freedesktop/systemd1",
 351                         "org.freedesktop.systemd1.Manager",
 352                         "GetUnitProcesses",
 353                         error,
 354                         &reply,
 355                         "s",
 356                         unit);
 357         if (r < 0)
 358                 return r;
 359
 360         cgroups = hashmap_new(&path_hash_ops);
 361         if (!cgroups)
 362                 return -ENOMEM;
 363
 364         r = sd_bus_message_enter_container(reply, 'a', "(sus)");
 365         if (r < 0)
 366                 goto finish;
 367
 368         for (;;) {
 369                 const char *path = NULL, *name = NULL;
 370                 uint32_t pid;
 371
 372                 r = sd_bus_message_read(reply, "(sus)", &path, &pid, &name);
 373                 if (r < 0)
 374                         goto finish;
 375                 if (r == 0)
 376                         break;
 377
 378                 r = add_process(cgroups, path, pid, name);
 379                 if (r == -ENOMEM)
 380                         goto finish;
 381                 if (r < 0)
 382                         log_warning_errno(r, "Invalid process description in GetUnitProcesses reply: cgroup=\"%s\" pid="PID_FMT" command=\"%s\", ignoring: %m",
 383                                           path, pid, name);
 384         }
 385
 386         r = sd_bus_message_exit_container(reply);
 387         if (r < 0)
 388                 goto finish;
 389
 390         r = dump_processes(cgroups, cgroup_path, prefix, n_columns, flags);
 391         if (r < 0)
 392                 goto finish;
 393
 394         r = dump_extra_processes(cgroups, prefix, n_columns, flags);
 395
 396 finish:
 397         while ((cg = hashmap_first(cgroups)))
 398                remove_cgroup(cgroups, cg);
 399
 400         hashmap_free(cgroups);
 401
 402         return r;
 403 }