1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /*
28 * Copyright (c) 2013, Joyent, Inc. All rights reserved.
29 */
30
31 /*
32 * utmpx.c - utmpx utility routines
33 *
34 * Since svc.startd(1M) places utmpx records for its launched instances, it must
35 * also mark them as dead once completed.
36 */
37
38 #include <sys/stat.h>
39 #include <sys/types.h>
40 #include <sys/wait.h>
41 #include <sys/stat.h>
42 #include <errno.h>
43 #include <pthread.h>
44 #include <sac.h>
45 #include <string.h>
46 #include <strings.h>
47 #include <time.h>
48 #include <unistd.h>
49 #include <utmpx.h>
50 #include <fcntl.h>
51
52 #include "startd.h"
53
54 static const char rlevels[] = { 'S', '0', '1', '2', '3', '4', '5', '6', 0 };
55 static int n_prev[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
56
57 static pthread_mutex_t utmpx_lock;
58 static int utmpx_truncated = 0;
59
60 #define USEC_PER_MSEC 1000
61
62 int
utmpx_mark_init(pid_t pid,char * prefix)63 utmpx_mark_init(pid_t pid, char *prefix)
64 {
65 struct utmpx ut, *oldu;
66 int tmplen;
67 int ret;
68
69 while (st->st_initial && !utmpx_truncated)
70 (void) usleep(200 * USEC_PER_MSEC);
71
72 /*
73 * Clean out any preexisting records for this PID, as they must be
74 * inaccurate.
75 */
76 utmpx_mark_dead(pid, 0, B_TRUE);
77
78 /*
79 * Construct a new record with the appropriate prefix.
80 */
81 (void) memset(&ut, 0, sizeof (ut));
82 (void) strncpy(ut.ut_user, ".startd", sizeof (ut.ut_user));
83 ut.ut_pid = pid;
84
85 ut.ut_id[0] = ut.ut_id[1] = ut.ut_id[2] = ut.ut_id[3] = (char)SC_WILDC;
86
87 for (ret = 0; ret < strlen(prefix); ret++)
88 ut.ut_id[ret] = prefix[ret];
89
90 ut.ut_type = INIT_PROCESS;
91 (void) time(&ut.ut_tv.tv_sec);
92
93 for (;;) {
94 MUTEX_LOCK(&utmpx_lock);
95 setutxent();
96
97 if ((oldu = getutxid(&ut)) != NULL) {
98 /*
99 * Copy in the old "line" and "host" fields.
100 */
101 bcopy(oldu->ut_line, ut.ut_line, sizeof (ut.ut_line));
102 bcopy(oldu->ut_host, ut.ut_host, sizeof (ut.ut_host));
103 ut.ut_syslen = (tmplen = strlen(ut.ut_host)) ?
104 min(tmplen + 1, sizeof (ut.ut_host)) : 0;
105 }
106
107 if (makeutx(&ut) != NULL)
108 break;
109
110 if (errno != EROFS)
111 log_framework(LOG_WARNING,
112 "makeutx failed, retrying: %s\n", strerror(errno));
113
114 MUTEX_UNLOCK(&utmpx_lock);
115
116 (void) sleep(1);
117 }
118
119 updwtmpx(WTMPX_FILE, &ut);
120
121 endutxent();
122 MUTEX_UNLOCK(&utmpx_lock);
123
124 return (ret);
125 }
126
127 void
utmpx_mark_dead(pid_t pid,int status,boolean_t blocking)128 utmpx_mark_dead(pid_t pid, int status, boolean_t blocking)
129 {
130 struct utmpx *up;
131 int logged = 0;
132
133 for (;;) {
134 int found = 0;
135
136 MUTEX_LOCK(&utmpx_lock);
137 setutxent();
138
139 while (up = getutxent()) {
140 if (up->ut_pid == pid) {
141 found = 1;
142
143 if (up->ut_type == DEAD_PROCESS) {
144 /*
145 * Cleaned up elsewhere.
146 */
147 endutxent();
148 MUTEX_UNLOCK(&utmpx_lock);
149 return;
150 }
151
152 up->ut_type = DEAD_PROCESS;
153 up->ut_exit.e_termination = WTERMSIG(status);
154 up->ut_exit.e_exit = WEXITSTATUS(status);
155 (void) time(&up->ut_tv.tv_sec);
156
157 if (pututxline(up) != NULL) {
158 /*
159 * Now attempt to add to the end of the
160 * wtmp and wtmpx files. Do not create
161 * if they don't already exist.
162 */
163 updwtmpx(WTMPX_FILE, up);
164 endutxent();
165 MUTEX_UNLOCK(&utmpx_lock);
166
167 return;
168 }
169 }
170 }
171
172 endutxent();
173 MUTEX_UNLOCK(&utmpx_lock);
174
175 if (!found || !blocking)
176 return;
177
178 if (!logged) {
179 log_framework(LOG_INFO, "retrying utmpx_dead on PID "
180 "%ld\n", pid);
181 logged++;
182 }
183
184 (void) sleep(1);
185 }
186 }
187
188 static void
utmpx_check()189 utmpx_check()
190 {
191 struct stat sb;
192
193 if (stat(_UTMPX_FILE, &sb) == 0 &&
194 sb.st_mode != (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))
195 (void) chmod(_UTMPX_FILE, S_IRUSR | S_IWUSR | S_IRGRP |
196 S_IROTH);
197
198 if (stat(_WTMPX_FILE, &sb) == 0 &&
199 sb.st_mode != (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))
200 (void) chmod(_WTMPX_FILE, S_IRUSR | S_IWUSR | S_IRGRP |
201 S_IROTH);
202 }
203
204 /*
205 * Retrieve the runlevel utmpx entry if there is one; used to recover
206 * state when svc.startd is restarted.
207 */
208 char
utmpx_get_runlevel(void)209 utmpx_get_runlevel(void)
210 {
211 struct utmpx *up;
212 char rl = '\0';
213
214 MUTEX_LOCK(&utmpx_lock);
215 setutxent();
216
217 while (up = getutxent()) {
218 if (up->ut_type == RUN_LVL &&
219 sscanf(up->ut_line, RUNLVL_MSG, &rl) == 1)
220 break;
221 }
222 endutxent();
223 MUTEX_UNLOCK(&utmpx_lock);
224
225 return (rl);
226 }
227
228 void
utmpx_set_runlevel(char runlevel,char oldrl,boolean_t do_bump)229 utmpx_set_runlevel(char runlevel, char oldrl, boolean_t do_bump)
230 {
231 struct utmpx u;
232 struct utmpx *oup;
233 size_t tmplen;
234 int i;
235
236 if (runlevel == 's')
237 runlevel = 'S';
238 if (oldrl == 's')
239 oldrl = 'S';
240
241 bzero(&u, sizeof (struct utmpx));
242
243 u.ut_id[0] = u.ut_id[1] = u.ut_id[2] = u.ut_id[3] = '\0';
244 u.ut_pid = 0;
245 u.ut_type = RUN_LVL;
246
247 (void) time(&u.ut_tv.tv_sec);
248
249 MUTEX_LOCK(&utmpx_lock);
250 setutxent();
251
252 if ((oup = getutxid(&u)) != NULL) {
253 bcopy(oup->ut_host, u.ut_host, sizeof (u.ut_host));
254 bcopy(oup->ut_line, u.ut_line, sizeof (u.ut_line));
255 bcopy(oup->ut_user, u.ut_user, sizeof (u.ut_user));
256
257 tmplen = strlen(u.ut_host);
258 if (tmplen)
259 u.ut_syslen = min(tmplen + 1, sizeof (u.ut_host));
260 else
261 u.ut_syslen = 0;
262 }
263
264 if (oldrl != '\0')
265 u.ut_exit.e_exit = oldrl;
266 else if (oup != NULL)
267 u.ut_exit.e_exit = oup->ut_exit.e_termination;
268 else
269 u.ut_exit.e_exit = '0';
270
271 u.ut_exit.e_termination = runlevel;
272
273 for (i = 0; rlevels[i] != '\0'; ++i) {
274 if (rlevels[i] == runlevel)
275 break;
276 }
277
278 u.ut_pid = n_prev[i];
279
280 if (do_bump) {
281 for (i = 0; rlevels[i] != '\0'; ++i) {
282 if (rlevels[i] == u.ut_exit.e_exit)
283 break;
284 }
285
286 ++n_prev[i];
287 }
288
289 (void) sprintf(u.ut_line, RUNLVL_MSG, runlevel);
290
291 if (pututxline(&u) == NULL) {
292 endutxent();
293 MUTEX_UNLOCK(&utmpx_lock);
294
295 return;
296 }
297
298 updwtmpx(WTMPX_FILE, &u);
299
300 endutxent();
301 MUTEX_UNLOCK(&utmpx_lock);
302
303 utmpx_check();
304 }
305
306 static void
utmpx_write_entry(short type,const char * msg,time_t tstamp)307 utmpx_write_entry(short type, const char *msg, time_t tstamp)
308 {
309 struct utmpx u;
310 struct utmpx *oup;
311 size_t tmplen;
312
313 bzero(&u, sizeof (struct utmpx));
314
315 u.ut_id[0] = u.ut_id[1] = u.ut_id[2] = u.ut_id[3] = '\0';
316 u.ut_pid = 0;
317
318 u.ut_exit.e_termination = WTERMSIG(0);
319 u.ut_exit.e_exit = WEXITSTATUS(0);
320 u.ut_type = type;
321 u.ut_tv.tv_sec = tstamp;
322
323 MUTEX_LOCK(&utmpx_lock);
324 setutxent();
325
326 if ((oup = getutxid(&u)) != NULL) {
327 bcopy(oup->ut_user, u.ut_user, sizeof (u.ut_user));
328 bcopy(oup->ut_line, u.ut_line, sizeof (u.ut_line));
329 bcopy(oup->ut_host, u.ut_host, sizeof (u.ut_host));
330
331 tmplen = strlen(u.ut_host);
332 if (tmplen)
333 u.ut_syslen = min(tmplen + 1, sizeof (u.ut_host));
334 else
335 u.ut_syslen = 0;
336 }
337
338 (void) sprintf(u.ut_line, "%.12s", msg);
339
340 if (pututxline(&u) == NULL) {
341 endutxent();
342 MUTEX_UNLOCK(&utmpx_lock);
343
344 return;
345 }
346
347 updwtmpx(WTMPX_FILE, &u);
348
349 endutxent();
350 MUTEX_UNLOCK(&utmpx_lock);
351
352 utmpx_check();
353 }
354
355 void
utmpx_write_boottime(void)356 utmpx_write_boottime(void)
357 {
358 time_t tstamp;
359 struct stat stbuf;
360
361 /*
362 * The DOWN_TIME record tracks when the OS became unavailable
363 * during the previous boot. We stat(2) WTMPX and check its
364 * attributes to determine when (and how) the OS became
365 * unavailable. If the file is empty, skip writing a DOWN_TIME
366 * record. Otherwise, check the access and modify times and
367 * use whichever is latest as the time that the OS became
368 * unavailable. If st_atime is latest, the instance crashed or
369 * the machine lost power. If st_mtime is latest, the shutdown
370 * was controlled.
371 */
372 if (stat(WTMPX_FILE, &stbuf) == 0 && stbuf.st_size != 0) {
373 tstamp = (stbuf.st_atime >= stbuf.st_mtime) ?
374 stbuf.st_atime : stbuf.st_mtime;
375 utmpx_write_entry(DOWN_TIME, DOWN_MSG, tstamp);
376 }
377
378 /*
379 * The boot time (or start time, for a non-global zone) is retrieved in
380 * log_init().
381 */
382 tstamp = st->st_start_time.tv_sec;
383
384 utmpx_write_entry(BOOT_TIME, BOOT_MSG, tstamp);
385 }
386
387 /*
388 * void utmpx_clear_old(void)
389 * At boot and only at boot, truncate the utmpx file.
390 *
391 */
392 void
utmpx_clear_old(void)393 utmpx_clear_old(void)
394 {
395 int fd;
396 mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
397
398 if (!st->st_initial || utmpx_truncated)
399 return;
400
401 MUTEX_LOCK(&utmpx_lock);
402
403 if ((fd = open(_UTMPX_FILE,
404 O_WRONLY | O_CREAT | O_TRUNC, mode)) != -1) {
405 (void) fchmod(fd, mode); /* force mode regardless of umask() */
406 (void) fchown(fd, 0, 2); /* force owner to root/bin */
407 (void) close(fd);
408 } else {
409 log_framework(LOG_NOTICE, "Unable to create %s: %s\n",
410 _UTMPX_FILE, strerror(errno));
411 }
412
413 utmpx_truncated = 1;
414
415 MUTEX_UNLOCK(&utmpx_lock);
416 }
417
418 void
utmpx_init()419 utmpx_init()
420 {
421 (void) pthread_mutex_init(&utmpx_lock, &mutex_attrs);
422 }
423
424 void
utmpx_prefork()425 utmpx_prefork()
426 {
427 /*
428 * The libc utmpx routines are entirely MT-unsafe; we must assure
429 * that no other thread is in these routines when we fork lest we
430 * leave the child with inconsistent library state.
431 */
432 MUTEX_LOCK(&utmpx_lock);
433 }
434
435 void
utmpx_postfork()436 utmpx_postfork()
437 {
438 MUTEX_UNLOCK(&utmpx_lock);
439 }
440