xref: /openbmc/qemu/os-posix.c (revision 1d3daf95) 
1 /*
2  * os-posix.c
3  *
4  * Copyright (c) 2003-2008 Fabrice Bellard
5  * Copyright (c) 2010 Red Hat, Inc.
6  *
7  * Permission is hereby granted, free of charge, to any person obtaining a copy
8  * of this software and associated documentation files (the "Software"), to deal
9  * in the Software without restriction, including without limitation the rights
10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11  * copies of the Software, and to permit persons to whom the Software is
12  * furnished to do so, subject to the following conditions:
13  *
14  * The above copyright notice and this permission notice shall be included in
15  * all copies or substantial portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23  * THE SOFTWARE.
24  */
25 
26 #include "qemu/osdep.h"
27 #include <sys/wait.h>
28 #include <pwd.h>
29 #include <grp.h>
30 #include <libgen.h>
31 
32 /* Needed early for CONFIG_BSD etc. */
33 #include "net/slirp.h"
34 #include "qemu/qemu-options.h"
35 #include "qemu/error-report.h"
36 #include "qemu/log.h"
37 #include "sysemu/runstate.h"
38 #include "qemu/cutils.h"
39 #include "qemu/config-file.h"
40 #include "qemu/option.h"
41 
42 #ifdef CONFIG_LINUX
43 #include <sys/prctl.h>
44 #include "qemu/async-teardown.h"
45 #endif
46 
47 /*
48  * Must set all three of these at once.
49  * Legal combinations are              unset   by name   by uid
50  */
51 static struct passwd *user_pwd;    /*   NULL   non-NULL   NULL   */
52 static uid_t user_uid = (uid_t)-1; /*   -1      -1        >=0    */
53 static gid_t user_gid = (gid_t)-1; /*   -1      -1        >=0    */
54 
55 static const char *chroot_dir;
56 static int daemonize;
57 static int daemon_pipe;
58 
59 void os_setup_early_signal_handling(void)
60 {
61     struct sigaction act;
62     sigfillset(&act.sa_mask);
63     act.sa_flags = 0;
64     act.sa_handler = SIG_IGN;
65     sigaction(SIGPIPE, &act, NULL);
66 }
67 
68 static void termsig_handler(int signal, siginfo_t *info, void *c)
69 {
70     qemu_system_killed(info->si_signo, info->si_pid);
71 }
72 
73 void os_setup_signal_handling(void)
74 {
75     struct sigaction act;
76 
77     memset(&act, 0, sizeof(act));
78     act.sa_sigaction = termsig_handler;
79     act.sa_flags = SA_SIGINFO;
80     sigaction(SIGINT,  &act, NULL);
81     sigaction(SIGHUP,  &act, NULL);
82     sigaction(SIGTERM, &act, NULL);
83 }
84 
85 void os_set_proc_name(const char *s)
86 {
87 #if defined(PR_SET_NAME)
88     char name[16];
89     if (!s)
90         return;
91     pstrcpy(name, sizeof(name), s);
92     /* Could rewrite argv[0] too, but that's a bit more complicated.
93        This simple way is enough for `top'. */
94     if (prctl(PR_SET_NAME, name)) {
95         error_report("unable to change process name: %s", strerror(errno));
96         exit(1);
97     }
98 #else
99     error_report("Change of process name not supported by your OS");
100     exit(1);
101 #endif
102 }
103 
104 
105 static bool os_parse_runas_uid_gid(const char *optarg)
106 {
107     unsigned long lv;
108     const char *ep;
109     uid_t got_uid;
110     gid_t got_gid;
111     int rc;
112 
113     rc = qemu_strtoul(optarg, &ep, 0, &lv);
114     got_uid = lv; /* overflow here is ID in C99 */
115     if (rc || *ep != ':' || got_uid != lv || got_uid == (uid_t)-1) {
116         return false;
117     }
118 
119     rc = qemu_strtoul(ep + 1, 0, 0, &lv);
120     got_gid = lv; /* overflow here is ID in C99 */
121     if (rc || got_gid != lv || got_gid == (gid_t)-1) {
122         return false;
123     }
124 
125     user_pwd = NULL;
126     user_uid = got_uid;
127     user_gid = got_gid;
128     return true;
129 }
130 
131 /*
132  * Parse OS specific command line options.
133  * return 0 if option handled, -1 otherwise
134  */
135 int os_parse_cmd_args(int index, const char *optarg)
136 {
137     switch (index) {
138     case QEMU_OPTION_runas:
139         user_pwd = getpwnam(optarg);
140         if (user_pwd) {
141             user_uid = -1;
142             user_gid = -1;
143         } else if (!os_parse_runas_uid_gid(optarg)) {
144             error_report("User \"%s\" doesn't exist"
145                          " (and is not <uid>:<gid>)",
146                          optarg);
147             exit(1);
148         }
149         break;
150     case QEMU_OPTION_chroot:
151         chroot_dir = optarg;
152         break;
153     case QEMU_OPTION_daemonize:
154         daemonize = 1;
155         break;
156 #if defined(CONFIG_LINUX)
157     /* deprecated */
158     case QEMU_OPTION_asyncteardown:
159         init_async_teardown();
160         break;
161     case QEMU_OPTION_run_with: {
162         QemuOpts *opts = qemu_opts_parse_noisily(qemu_find_opts("run-with"),
163                                                  optarg, false);
164         if (!opts) {
165             exit(1);
166         }
167         if (qemu_opt_get_bool(opts, "async-teardown", false)) {
168             init_async_teardown();
169         }
170         break;
171     }
172 #endif
173     default:
174         return -1;
175     }
176 
177     return 0;
178 }
179 
180 static void change_process_uid(void)
181 {
182     assert((user_uid == (uid_t)-1) || user_pwd == NULL);
183     assert((user_uid == (uid_t)-1) ==
184            (user_gid == (gid_t)-1));
185 
186     if (user_pwd || user_uid != (uid_t)-1) {
187         gid_t intended_gid = user_pwd ? user_pwd->pw_gid : user_gid;
188         uid_t intended_uid = user_pwd ? user_pwd->pw_uid : user_uid;
189         if (setgid(intended_gid) < 0) {
190             error_report("Failed to setgid(%d)", intended_gid);
191             exit(1);
192         }
193         if (user_pwd) {
194             if (initgroups(user_pwd->pw_name, user_pwd->pw_gid) < 0) {
195                 error_report("Failed to initgroups(\"%s\", %d)",
196                         user_pwd->pw_name, user_pwd->pw_gid);
197                 exit(1);
198             }
199         } else {
200             if (setgroups(1, &user_gid) < 0) {
201                 error_report("Failed to setgroups(1, [%d])",
202                         user_gid);
203                 exit(1);
204             }
205         }
206         if (setuid(intended_uid) < 0) {
207             error_report("Failed to setuid(%d)", intended_uid);
208             exit(1);
209         }
210         if (setuid(0) != -1) {
211             error_report("Dropping privileges failed");
212             exit(1);
213         }
214     }
215 }
216 
217 static void change_root(void)
218 {
219     if (chroot_dir) {
220         if (chroot(chroot_dir) < 0) {
221             error_report("chroot failed");
222             exit(1);
223         }
224         if (chdir("/")) {
225             error_report("not able to chdir to /: %s", strerror(errno));
226             exit(1);
227         }
228     }
229 
230 }
231 
232 void os_daemonize(void)
233 {
234     if (daemonize) {
235         pid_t pid;
236         int fds[2];
237 
238         if (!g_unix_open_pipe(fds, FD_CLOEXEC, NULL)) {
239             exit(1);
240         }
241 
242         pid = fork();
243         if (pid > 0) {
244             uint8_t status;
245             ssize_t len;
246 
247             close(fds[1]);
248 
249             do {
250                 len = read(fds[0], &status, 1);
251             } while (len < 0 && errno == EINTR);
252 
253             /* only exit successfully if our child actually wrote
254              * a one-byte zero to our pipe, upon successful init */
255             exit(len == 1 && status == 0 ? 0 : 1);
256 
257         } else if (pid < 0) {
258             exit(1);
259         }
260 
261         close(fds[0]);
262         daemon_pipe = fds[1];
263 
264         setsid();
265 
266         pid = fork();
267         if (pid > 0) {
268             exit(0);
269         } else if (pid < 0) {
270             exit(1);
271         }
272         umask(027);
273 
274         signal(SIGTSTP, SIG_IGN);
275         signal(SIGTTOU, SIG_IGN);
276         signal(SIGTTIN, SIG_IGN);
277     }
278 }
279 
280 void os_setup_post(void)
281 {
282     int fd = 0;
283 
284     if (daemonize) {
285         if (chdir("/")) {
286             error_report("not able to chdir to /: %s", strerror(errno));
287             exit(1);
288         }
289         fd = RETRY_ON_EINTR(qemu_open_old("/dev/null", O_RDWR));
290         if (fd == -1) {
291             exit(1);
292         }
293     }
294 
295     change_root();
296     change_process_uid();
297 
298     if (daemonize) {
299         uint8_t status = 0;
300         ssize_t len;
301 
302         dup2(fd, 0);
303         dup2(fd, 1);
304         /* In case -D is given do not redirect stderr to /dev/null */
305         if (!qemu_log_enabled()) {
306             dup2(fd, 2);
307         }
308 
309         close(fd);
310 
311         do {
312             len = write(daemon_pipe, &status, 1);
313         } while (len < 0 && errno == EINTR);
314         if (len != 1) {
315             exit(1);
316         }
317     }
318 }
319 
320 void os_set_line_buffering(void)
321 {
322     setvbuf(stdout, NULL, _IOLBF, 0);
323 }
324 
325 bool is_daemonized(void)
326 {
327     return daemonize;
328 }
329 
330 int os_set_daemonize(bool d)
331 {
332     daemonize = d;
333     return 0;
334 }
335 
336 int os_mlock(void)
337 {
338 #ifdef HAVE_MLOCKALL
339     int ret = 0;
340 
341     ret = mlockall(MCL_CURRENT | MCL_FUTURE);
342     if (ret < 0) {
343         error_report("mlockall: %s", strerror(errno));
344     }
345 
346     return ret;
347 #else
348     return -ENOSYS;
349 #endif
350 }
351