chiark / gitweb /
sysusers: fix uninitialized warning
[elogind.git] / src / cgls / cgls.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2010 Lennart Poettering
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <limits.h>
23 #include <stdio.h>
24 #include <unistd.h>
25 #include <errno.h>
26 #include <getopt.h>
27 #include <string.h>
28
29 #include "cgroup-show.h"
30 #include "cgroup-util.h"
31 #include "log.h"
32 #include "path-util.h"
33 #include "util.h"
34 #include "pager.h"
35 #include "build.h"
36 #include "output-mode.h"
37 #include "fileio.h"
38 #include "sd-bus.h"
39 #include "bus-util.h"
40 #include "bus-error.h"
41 #include "unit-name.h"
42
43 static bool arg_no_pager = false;
44 static bool arg_kernel_threads = false;
45 static bool arg_all = false;
46 static int arg_full = -1;
47 static char* arg_machine = NULL;
48
49 static int help(void) {
50
51         printf("%s [OPTIONS...] [CGROUP...]\n\n"
52                "Recursively show control group contents.\n\n"
53                "  -h --help           Show this help\n"
54                "     --version        Show package version\n"
55                "     --no-pager       Do not pipe output into a pager\n"
56                "  -a --all            Show all groups, including empty\n"
57                "  -l --full           Do not ellipsize output\n"
58                "  -k                  Include kernel threads in output\n"
59                "  -M --machine        Show container\n",
60                program_invocation_short_name);
61
62         return 0;
63 }
64
65 static int parse_argv(int argc, char *argv[]) {
66
67         enum {
68                 ARG_NO_PAGER = 0x100,
69                 ARG_VERSION,
70         };
71
72         static const struct option options[] = {
73                 { "help",      no_argument,       NULL, 'h'          },
74                 { "version",   no_argument,       NULL, ARG_VERSION  },
75                 { "no-pager",  no_argument,       NULL, ARG_NO_PAGER },
76                 { "all",       no_argument,       NULL, 'a'          },
77                 { "full",      no_argument,       NULL, 'l'          },
78                 { "machine",   required_argument, NULL, 'M'          },
79                 {}
80         };
81
82         int c;
83
84         assert(argc >= 1);
85         assert(argv);
86
87         while ((c = getopt_long(argc, argv, "hkalM:", options, NULL)) >= 0) {
88
89                 switch (c) {
90
91                 case 'h':
92                         return help();
93
94                 case ARG_VERSION:
95                         puts(PACKAGE_STRING);
96                         puts(SYSTEMD_FEATURES);
97                         return 0;
98
99                 case ARG_NO_PAGER:
100                         arg_no_pager = true;
101                         break;
102
103                 case 'a':
104                         arg_all = true;
105                         break;
106
107                 case 'l':
108                         arg_full = true;
109                         break;
110
111                 case 'k':
112                         arg_kernel_threads = true;
113                         break;
114
115                 case 'M':
116                         arg_machine = optarg;
117                         break;
118
119                 case '?':
120                         return -EINVAL;
121
122                 default:
123                         assert_not_reached("Unhandled option");
124                 }
125         }
126
127         return 1;
128 }
129
130 int main(int argc, char *argv[]) {
131         int r = 0, retval = EXIT_FAILURE;
132         int output_flags;
133         _cleanup_free_ char *root = NULL;
134         _cleanup_bus_unref_ sd_bus *bus = NULL;
135
136         log_parse_environment();
137         log_open();
138
139         r = parse_argv(argc, argv);
140         if (r < 0)
141                 goto finish;
142         else if (r == 0) {
143                 retval = EXIT_SUCCESS;
144                 goto finish;
145         }
146
147         if (!arg_no_pager) {
148                 r = pager_open(false);
149                 if (r > 0) {
150                         if (arg_full == -1)
151                                 arg_full = true;
152                 }
153         }
154
155         output_flags =
156                 arg_all * OUTPUT_SHOW_ALL |
157                 (arg_full > 0) * OUTPUT_FULL_WIDTH;
158
159         r = bus_open_transport(BUS_TRANSPORT_LOCAL, NULL, false, &bus);
160         if (r < 0) {
161                 log_error("Failed to create bus connection: %s", strerror(-r));
162                 goto finish;
163         }
164
165         if (optind < argc) {
166                 int i;
167
168                 for (i = optind; i < argc; i++) {
169                         int q;
170
171                         fprintf(stdout, "%s:\n", argv[i]);
172                         fflush(stdout);
173
174                         if (arg_machine)
175                                 root = strjoin("machine/", arg_machine, "/", argv[i], NULL);
176                         else
177                                 root = strdup(argv[i]);
178                         if (!root)
179                                 return log_oom();
180
181                         q = show_cgroup_by_path(root, NULL, 0,
182                                                 arg_kernel_threads, output_flags);
183                         if (q < 0)
184                                 r = q;
185                 }
186
187         } else {
188                 _cleanup_free_ char *p;
189
190                 p = get_current_dir_name();
191                 if (!p) {
192                         log_error("Cannot determine current working directory: %m");
193                         goto finish;
194                 }
195
196                 if (path_startswith(p, "/sys/fs/cgroup") && !arg_machine) {
197                         printf("Working Directory %s:\n", p);
198                         r = show_cgroup_by_path(p, NULL, 0,
199                                                 arg_kernel_threads, output_flags);
200                 } else {
201                         if (arg_machine) {
202                                 char *m;
203                                 const char *cgroup;
204                                 _cleanup_free_ char *scope = NULL;
205                                 _cleanup_free_ char *path = NULL;
206                                 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
207                                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
208
209                                 m = strappenda("/run/systemd/machines/", arg_machine);
210                                 r = parse_env_file(m, NEWLINE, "SCOPE", &scope, NULL);
211                                 if (r < 0) {
212                                         log_error("Failed to get machine path: %s", strerror(-r));
213                                         goto finish;
214                                 }
215
216                                 path = unit_dbus_path_from_name(scope);
217                                 if (!path) {
218                                         log_oom();
219                                         goto finish;
220                                 }
221
222                                 r = sd_bus_get_property(
223                                                 bus,
224                                                 "org.freedesktop.systemd1",
225                                                 path,
226                                                 "org.freedesktop.systemd1.Scope",
227                                                 "ControlGroup",
228                                                 &error,
229                                                 &reply,
230                                                 "s");
231
232                                 if (r < 0) {
233                                         log_error("Failed to query ControlGroup: %s", bus_error_message(&error, -r));
234                                         goto finish;
235                                 }
236
237                                 r = sd_bus_message_read(reply, "s", &cgroup);
238                                 if (r < 0) {
239                                         bus_log_parse_error(r);
240                                         goto finish;
241                                 }
242
243                                 root = strdup(cgroup);
244                                 if (!root) {
245                                         log_oom();
246                                         goto finish;
247                                 }
248
249                         } else
250                                 r = cg_get_root_path(&root);
251                         if (r < 0) {
252                                 log_error("Failed to get %s path: %s",
253                                           arg_machine ? "machine" : "root", strerror(-r));
254                                 goto finish;
255                         }
256
257                         r = show_cgroup(SYSTEMD_CGROUP_CONTROLLER, root, NULL, 0,
258                                         arg_kernel_threads, output_flags);
259                 }
260         }
261
262         if (r < 0) {
263                 log_error("Failed to list cgroup tree %s: %s", root, strerror(-r));
264                 retval = EXIT_FAILURE;
265         } else
266                 retval = EXIT_SUCCESS;
267
268 finish:
269         pager_close();
270
271         return retval;
272 }