xref: /illumos-gate/usr/src/cmd/power/powerd.c (revision b172429eb7fa68712e018d8965b6d0c7f6779f9e)
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 (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  * Copyright 2016 Nexenta Systems, Inc. All rights reserved.
25  */
26 
27 #include <stdio.h>			/* Standard */
28 #include <stdlib.h>
29 #include <fcntl.h>
30 #include <sys/types.h>
31 #include <time.h>
32 #include <string.h>
33 #include <errno.h>
34 #include <pwd.h>
35 #include <dirent.h>
36 #include <thread.h>
37 #include <limits.h>
38 #include <sys/todio.h>			/* Time-Of-Day chip */
39 #include <sys/stat.h>
40 #include <sys/wait.h>
41 #include <sys/ipc.h>			/* IPC functions */
42 #include <signal.h>			/* signal handling */
43 #include <syslog.h>
44 #include <unistd.h>
45 #include <libdevinfo.h>
46 #include <poll.h>
47 #include <sys/pm.h>			/* power management driver */
48 #include <sys/uadmin.h>
49 #include <sys/openpromio.h>		/* for prom access */
50 #include <sys/sysmacros.h>		/* for MIN & MAX macros */
51 #include <sys/modctl.h>
52 #include <sys/stropts.h>		/* for INFTIM */
53 #include <sys/pbio.h>
54 #include <sys/cpr.h>
55 #include <sys/srn.h>
56 #include <stdarg.h>
57 
58 #include "powerd.h"
59 
60 /* External Functions */
61 extern struct tm *localtime_r(const time_t *, struct tm *);
62 extern void sysstat_init(void);
63 extern int check_tty(hrtime_t *, int);
64 extern int check_disks(hrtime_t *, int);
65 extern int check_load_ave(hrtime_t *, float);
66 extern int check_nfs(hrtime_t *, int);
67 extern int last_disk_activity(hrtime_t *, int);
68 extern int last_tty_activity(hrtime_t *, int);
69 extern int last_load_ave_activity(hrtime_t *);
70 extern int last_nfs_activity(hrtime_t *, int);
71 
72 #define	PM		"/dev/pm"
73 #define	TOD		"/dev/tod"
74 #define	PROM		"/dev/openprom"
75 #define	PB		"/dev/power_button"
76 #define	SRN		"/dev/srn"
77 #define	LOGFILE		"./powerd.log"
78 
79 #define	PBM_THREAD	0
80 #define	ATTACH_THREAD	1
81 #define	NUM_THREADS	2
82 
83 #define	CHECK_INTERVAL	5
84 #define	IDLECHK_INTERVAL	15
85 #define	MINS_TO_SECS	60
86 #define	HOURS_TO_SECS	(60 * 60)
87 #define	DAYS_TO_SECS	(24 * 60 * 60)
88 #define	HOURS_TO_MINS	60
89 #define	DAYS_TO_MINS	(24 * 60)
90 
91 #define	LIFETIME_SECS			(7 * 365 * DAYS_TO_SECS)
92 #define	DEFAULT_POWER_CYCLE_LIMIT	10000
93 #define	DEFAULT_SYSTEM_BOARD_DATE	804582000	/* July 1, 1995 */
94 
95 #define	LLEN 80
96 
97 typedef	enum {root, options} prom_node_t;
98 
99 /* State Variables */
100 static struct cprconfig	asinfo;
101 static time_t		shutdown_time;	/* Time for next shutdown check */
102 static time_t		checkidle_time;	/* Time for next idleness check */
103 static time_t		last_resume;
104 pwr_info_t		*info;		/* private as config data buffer */
105 static int		pb_fd;		/* power button driver */
106 static int		broadcast;	/* Enables syslog messages */
107 static int		start_calc;
108 static int		autoshutdown_en;
109 static int		do_idlecheck;
110 static int		got_sighup;
111 static int		estar_v2_prop;
112 static int		estar_v3_prop;
113 static int		log_power_cycles_error = 0;
114 static int		log_system_board_date_error = 0;
115 static int		log_no_autoshutdown_warning = 0;
116 static mutex_t		poweroff_mutex;
117 
118 static char *autoshutdown_cmd[] = {
119 	"/usr/bin/sys-suspend",
120 	"-n", "-d", ":0", NULL
121 };
122 
123 static char *power_button_cmd[] = {
124 	"/usr/bin/sys-suspend",
125 	"-h", "-d", ":0", NULL
126 };
127 
128 #ifdef __x86
129 static char *autoS3_cmd[] = {
130 	"/usr/bin/sys-suspend",
131 	"-n", "-d", ":0", NULL
132 };
133 #endif
134 
135 static char pidpath[] = PIDPATH;
136 static char scratch[PATH_MAX];
137 static char *prog;
138 
139 /* Local Functions */
140 static void alarm_handler(int);
141 static void thaw_handler(int);
142 static void kill_handler(int);
143 static void work_handler(int);
144 static void check_shutdown(time_t *, hrtime_t *);
145 static void check_idleness(time_t *, hrtime_t *);
146 static int last_system_activity(hrtime_t *);
147 static int run_idlecheck(void);
148 static void set_alarm(time_t);
149 static int poweroff(const char *, char **);
150 static int is_ok2shutdown(time_t *);
151 static int get_prom(int, prom_node_t, char *, char *, size_t);
152 static void *power_button_monitor(void *);
153 static int open_pidfile(char *);
154 static int write_pidfile(int, pid_t);
155 static int read_cpr_config(void);
156 static void *system_activity_monitor(void *);
157 #ifdef __x86
158 static void *autos3_monitor(void *);
159 #endif
160 static void do_attach(void);
161 static void *attach_devices(void *);
162 static int powerd_debug;
163 
164 /* PRINTFLIKE1 */
165 static void
logerror(const char * fmt,...)166 logerror(const char *fmt, ...)
167 {
168 	va_list args;
169 
170 	va_start(args, fmt);
171 	if (broadcast)
172 		vsyslog(LOG_ERR, fmt, args);
173 	va_end(args);
174 }
175 
176 
177 static void
estrcpy(char * dst,char * src,size_t dlen)178 estrcpy(char *dst, char *src, size_t dlen)
179 {
180 	size_t slen;
181 
182 	slen = strlcpy(dst, src, dlen);
183 	if (slen >= dlen) {
184 		logerror("%s: string too long \"%s ...\"\n"
185 		    "(len %d, max %d)\n", prog, dst, slen, dlen - 1);
186 		exit(EXIT_FAILURE);
187 	}
188 }
189 
190 
191 int
main(int argc,char * argv[])192 main(int argc, char *argv[])
193 {
194 	pid_t		pid;
195 	int		pm_fd;
196 	struct sigaction act;
197 	sigset_t	sigmask;
198 	int		c;
199 	char		errmsg[PATH_MAX + 64];
200 	int		pid_fd;
201 
202 	prog = argv[0];
203 	if (geteuid() != 0) {
204 		(void) fprintf(stderr, "%s: Must be root\n", prog);
205 		exit(EXIT_FAILURE);
206 	}
207 
208 	if ((pid_fd = open_pidfile(prog)) ==  -1)
209 		exit(EXIT_FAILURE);
210 
211 	/*
212 	 * Process options
213 	 */
214 	broadcast = 1;
215 	while ((c = getopt(argc, argv, "nd")) != EOF) {
216 		switch (c) {
217 		case 'd':
218 			powerd_debug = 1;
219 			break;
220 		case 'n':
221 			broadcast = 0;
222 			break;
223 		case '?':
224 			(void) fprintf(stderr, "Usage: %s [-n]\n", prog);
225 			exit(EXIT_FAILURE);
226 		}
227 	}
228 
229 	pm_fd = open(PM, O_RDWR);
230 	if (pm_fd == -1) {
231 		(void) snprintf(errmsg, sizeof (errmsg), "%s: %s", prog, PM);
232 		perror(errmsg);
233 		exit(EXIT_FAILURE);
234 	}
235 	(void) close(pm_fd);
236 
237 	/*
238 	 * Initialize mutex lock used to insure only one command to
239 	 * run at a time.
240 	 */
241 	if (mutex_init(&poweroff_mutex, USYNC_THREAD, NULL) != 0) {
242 		(void) fprintf(stderr,
243 		    "%s: Unable to initialize mutex lock\n", prog);
244 		exit(EXIT_FAILURE);
245 	}
246 
247 	if ((info = (pwr_info_t *)malloc(sizeof (pwr_info_t))) == NULL) {
248 		(void) snprintf(errmsg, sizeof (errmsg), "%s: malloc", prog);
249 		perror(errmsg);
250 		exit(EXIT_FAILURE);
251 	}
252 
253 	/*
254 	 * Daemon is set to go...
255 	 */
256 	if ((pid = fork()) < 0)
257 		exit(EXIT_FAILURE);
258 	else if (pid != 0)
259 		exit(EXIT_SUCCESS);
260 
261 	pid = getpid();
262 	openlog(prog, 0, LOG_DAEMON);
263 	if (write_pidfile(pid_fd, pid) == -1)	/* logs errors on failure */
264 		exit(EXIT_FAILURE);
265 	(void) close(pid_fd);
266 
267 	/*
268 	 * Close all the parent's file descriptors (Bug 1225843).
269 	 */
270 	closefrom(0);
271 	(void) setsid();
272 	(void) chdir("/");
273 	(void) umask(0);
274 #ifdef DEBUG
275 	/*
276 	 * Connect stdout to the console.
277 	 */
278 	if (dup2(open("/dev/console", O_WRONLY|O_NOCTTY), 1) == -1) {
279 		logerror("Unable to connect to the console.");
280 	}
281 #endif
282 	info->pd_flags = PD_AC;
283 	info->pd_idle_time = -1;
284 	info->pd_start_time = 0;
285 	info->pd_finish_time = 0;
286 
287 	/*
288 	 * Allow SIGQUIT, SIGINT and SIGTERM signals to terminate us
289 	 * any time
290 	 */
291 	act.sa_handler = kill_handler;
292 	(void) sigemptyset(&act.sa_mask);
293 	act.sa_flags = 0;
294 	(void) sigaction(SIGQUIT, &act, NULL);
295 	(void) sigaction(SIGINT, &act, NULL);
296 	(void) sigaction(SIGTERM, &act, NULL);
297 
298 	(void) sigfillset(&sigmask);
299 	(void) sigdelset(&sigmask, SIGQUIT);
300 	(void) sigdelset(&sigmask, SIGINT);
301 	(void) sigdelset(&sigmask, SIGTERM);
302 	(void) thr_sigsetmask(SIG_SETMASK, &sigmask, NULL);
303 
304 	/*
305 	 * If "power_button" device node can be opened, create a new
306 	 * thread to monitor the power button.
307 	 */
308 	if ((pb_fd = open(PB, O_RDONLY)) != -1) {
309 		if (powerd_debug)
310 			logerror("powerd starting power button monitor.");
311 		if (thr_create(NULL, 0, power_button_monitor, NULL,
312 		    THR_DAEMON, NULL) != 0) {
313 			logerror("Unable to monitor system's power button.");
314 		}
315 	}
316 
317 	do_attach();
318 
319 	/*
320 	 * Create a new thread to monitor system activity and suspend
321 	 * system if idle.
322 	 */
323 	if (powerd_debug)
324 		logerror("powerd starting system activity monitor.");
325 	if (thr_create(NULL, 0, system_activity_monitor, NULL,
326 	    THR_DAEMON, NULL) != 0) {
327 		logerror("Unable to create thread to monitor system activity.");
328 	}
329 
330 #ifdef __x86
331 	/*
332 	 * Create a new thread to handle autos3 trigger
333 	 */
334 	if (powerd_debug)
335 		logerror("powerd starting autos3 monitor.");
336 	if (thr_create(NULL, 0, autos3_monitor, NULL, THR_DAEMON,
337 	    NULL) != 0) {
338 		logerror("Unable to create thread to monitor autos3 activity.");
339 	}
340 #endif
341 
342 	/*
343 	 * Block until we receive an explicit terminate signal
344 	 */
345 	(void) sigsuspend(&sigmask);
346 
347 	return (1);
348 }
349 
350 static void *
system_activity_monitor(void * arg __unused)351 system_activity_monitor(void *arg __unused)
352 {
353 	struct sigaction act;
354 	sigset_t sigmask;
355 
356 	/*
357 	 * Setup for gathering system's statistic.
358 	 */
359 	sysstat_init();
360 
361 	/*
362 	 * In addition to the SIGQUIT, SIGINT and SIGTERM signals already
363 	 * being handled, this thread also needs to handle SIGHUP, SIGALRM
364 	 * and SIGTHAW signals.
365 	 */
366 	(void) sigemptyset(&act.sa_mask);
367 	act.sa_flags = 0;
368 	act.sa_handler = alarm_handler;
369 	(void) sigaction(SIGALRM, &act, NULL);
370 	act.sa_handler = work_handler;
371 	(void) sigaction(SIGHUP, &act, NULL);
372 	act.sa_handler = thaw_handler;
373 	(void) sigaction(SIGTHAW, &act, NULL);
374 
375 	/*
376 	 * Invoke work_handler with a dummy SIGHUP signal to read
377 	 * cpr config file, get autoshutdown properties and schedule
378 	 * an alarm if needed.
379 	 */
380 	work_handler(SIGHUP);
381 
382 	/*
383 	 * Wait for signal to read file
384 	 */
385 	(void) thr_sigsetmask(0, 0, &sigmask);
386 	(void) sigdelset(&sigmask, SIGHUP);
387 	(void) sigdelset(&sigmask, SIGALRM);
388 	(void) sigdelset(&sigmask, SIGTHAW);
389 	(void) thr_sigsetmask(SIG_SETMASK, &sigmask, NULL);
390 	do {
391 		(void) sigsuspend(&sigmask);
392 	} while (errno == EINTR);
393 	return (NULL);
394 }
395 
396 #ifdef __x86
397 static void *
autos3_monitor(void * arg __unused)398 autos3_monitor(void *arg __unused)
399 {
400 	struct pollfd poll_fd;
401 	srn_event_info_t srn_event;		/* contains suspend type */
402 	int fd, ret;
403 
404 	fd = open(SRN, O_RDWR|O_EXCL|O_NDELAY);
405 	if (fd == -1) {
406 		logerror("Unable to open %s: %s", SRN, strerror(errno));
407 		thr_exit((void *)(intptr_t)errno);
408 	}
409 
410 	/*
411 	 * Tell device we want the special sauce
412 	 */
413 	ret = ioctl(fd, SRN_IOC_AUTOSX, NULL);
414 	if (ret == -1) {
415 		logerror("Ioctl SRN_IOC_AUTOSX failed: %s", strerror(errno));
416 		(void) close(fd);
417 		thr_exit((void *)(intptr_t)errno);
418 	}
419 	poll_fd.fd = fd;
420 	/*CONSTCOND*/
421 	while (1) {
422 		poll_fd.revents = 0;
423 		poll_fd.events = POLLIN;
424 		if (poll(&poll_fd, 1, -1) < 0) {
425 			switch (errno) {
426 			case EINTR:
427 			case EAGAIN:
428 				continue;
429 			default:
430 				logerror("Poll error: %s", strerror(errno));
431 				(void) close(fd);
432 				thr_exit((void *)(intptr_t)errno);
433 			}
434 		}
435 
436 		ret = ioctl(fd, SRN_IOC_NEXTEVENT, &srn_event);
437 		if (ret == -1) {
438 			logerror("ioctl error: %s", strerror(errno));
439 			(void) close(fd);
440 			thr_exit((void *)(intptr_t)errno);
441 		}
442 		switch (srn_event.ae_type) {
443 		case 3:			/* S3 */
444 			if (powerd_debug)
445 				logerror("ioctl returns type: %d",
446 				    srn_event.ae_type);
447 			break;
448 		default:
449 			logerror("Unsupported target state %d",
450 			    srn_event.ae_type);
451 			continue;
452 		}
453 		(void) poweroff("AutoS3", autoS3_cmd);
454 		continue;
455 	}
456 	return (NULL);
457 }
458 #endif
459 
460 static int
read_cpr_config(void)461 read_cpr_config(void)
462 {
463 	int	asfd;
464 
465 	if ((asfd = open(CPR_CONFIG, O_RDONLY)) < 0) {
466 		logerror("Unable to open CPR config file '%s'", CPR_CONFIG);
467 		return (-1);
468 	}
469 
470 	if (read(asfd, (void *)&asinfo, sizeof (asinfo)) != sizeof (asinfo)) {
471 		logerror("Unable to read CPR config file '%s'", CPR_CONFIG);
472 		(void) close(asfd);
473 		return (-1);
474 	}
475 
476 	(void) close(asfd);
477 
478 	return (0);
479 }
480 
481 /*ARGSUSED*/
482 static void
thaw_handler(int sig)483 thaw_handler(int sig)
484 {
485 	start_calc  = 0;
486 	last_resume = time(NULL);
487 }
488 
489 /*ARGSUSED*/
490 static void
kill_handler(int sig)491 kill_handler(int sig)
492 {
493 	int ret_code = EXIT_SUCCESS;
494 
495 	/*
496 	 * Free resources
497 	 */
498 
499 	free(info);
500 	if (pb_fd != -1) {
501 		(void) close(pb_fd);
502 	}
503 	(void) mutex_destroy(&poweroff_mutex);
504 	(void) unlink(pidpath);
505 	closelog();
506 	exit(ret_code);
507 }
508 
509 /*ARGSUSED*/
510 static void
alarm_handler(int sig)511 alarm_handler(int sig)
512 {
513 	time_t		now;
514 	hrtime_t	hr_now;
515 
516 	now = time(NULL);
517 	hr_now = gethrtime();
518 	if (checkidle_time <= now && checkidle_time != 0)
519 		check_idleness(&now, &hr_now);
520 	if (shutdown_time <= now && shutdown_time != 0)
521 		check_shutdown(&now, &hr_now);
522 
523 	set_alarm(now);
524 }
525 
526 /*ARGSUSED*/
527 static void
work_handler(int sig)528 work_handler(int sig)
529 {
530 	time_t		now;
531 	hrtime_t	hr_now;
532 	struct stat	stat_buf;
533 
534 	do_idlecheck = 0;
535 	info->pd_flags = PD_AC;
536 
537 	/*
538 	 * Parse the config file for autoshutdown and idleness entries.
539 	 */
540 	if (read_cpr_config() < 0)
541 		return;
542 
543 	/*
544 	 * Since Oct. 1, 1995, any new system shipped had root
545 	 * property "energystar-v2" defined in its prom.  Systems
546 	 * shipped after July 1, 1999, will have "energystar-v3"
547 	 * property.
548 	 */
549 	estar_v2_prop = asinfo.is_cpr_default;
550 
551 	info->pd_flags |= asinfo.is_autowakeup_capable;
552 
553 	if (strlen(asinfo.idlecheck_path) > 0) {
554 		if (stat(asinfo.idlecheck_path, &stat_buf) != 0) {
555 			logerror("unable to access idlecheck program \"%s\".",
556 			    asinfo.idlecheck_path);
557 		} else if (!(stat_buf.st_mode & S_IXUSR)) {
558 			logerror("idlecheck program \"%s\" is not executable.",
559 			    asinfo.idlecheck_path);
560 		} else {
561 			do_idlecheck = 1;
562 		}
563 	}
564 
565 	if (strlen(asinfo.as_behavior) == 0 ||
566 	    strcmp(asinfo.as_behavior, "noshutdown") == 0 ||
567 	    strcmp(asinfo.as_behavior, "unconfigured") == 0) {
568 		info->pd_autoshutdown = 0;
569 	} else if (strcmp(asinfo.as_behavior, "default") == 0) {
570 		info->pd_autoshutdown = estar_v2_prop;
571 	} else if (strcmp(asinfo.as_behavior, "shutdown") == 0 ||
572 	    strcmp(asinfo.as_behavior, "autowakeup") == 0) {
573 		info->pd_autoshutdown = asinfo.is_cpr_capable;
574 	} else {
575 		logerror("autoshutdown behavior \"%s\" unrecognized.",
576 		    asinfo.as_behavior);
577 		info->pd_autoshutdown = 0;
578 	}
579 
580 	if (info->pd_autoshutdown) {
581 		info->pd_idle_time = asinfo.as_idle;
582 		info->pd_start_time =
583 		    (asinfo.as_sh * 60 + asinfo.as_sm) % DAYS_TO_MINS;
584 		info->pd_finish_time =
585 		    (asinfo.as_fh * 60 + asinfo.as_fm) % DAYS_TO_MINS;
586 		info->pd_autoresume =
587 		    (strcmp(asinfo.as_behavior, "autowakeup") == 0) ? 1 : 0;
588 	}
589 	autoshutdown_en = (asinfo.as_idle >= 0 && info->pd_autoshutdown)
590 	    ? 1 : 0;
591 
592 #ifdef DEBUG
593 	(void) fprintf(stderr, "autoshutdown_en = %d, as_idle = %d, "
594 	    "pd_autoresume = %d\n",
595 	    autoshutdown_en, asinfo.as_idle, info->pd_autoresume);
596 
597 	(void) fprintf(stderr, " pd_start_time=%d, pd_finish_time=%d\n",
598 	    info->pd_start_time, info->pd_finish_time);
599 #endif
600 
601 	got_sighup = 1;
602 	now = last_resume = time(NULL);
603 	hr_now = gethrtime();
604 	check_idleness(&now, &hr_now);
605 	check_shutdown(&now, &hr_now);
606 	set_alarm(now);
607 }
608 
609 static void
check_shutdown(time_t * now,hrtime_t * hr_now)610 check_shutdown(time_t *now, hrtime_t *hr_now)
611 {
612 	int		tod_fd = -1;
613 	int		kbd, mouse, system, least_idle, idlecheck_time;
614 	int		next_time;
615 	int		s, f;
616 	struct tm	tmp_time;
617 	time_t		start_of_day, time_since_last_resume;
618 	time_t		wakeup_time;
619 	extern long	conskbd_idle_time(void);
620 	extern long	consms_idle_time(void);
621 	static int	warned_kbd, warned_ms; /* print error msg one time */
622 
623 	if (!autoshutdown_en) {
624 		shutdown_time = 0;
625 		return;
626 	}
627 
628 	(void) localtime_r(now, &tmp_time);
629 	tmp_time.tm_sec = 0;
630 	tmp_time.tm_min = 0;
631 	tmp_time.tm_hour = 0;
632 	start_of_day = mktime(&tmp_time);
633 	s = start_of_day + info->pd_start_time * 60;
634 	f = start_of_day + info->pd_finish_time * 60;
635 	if ((s < f && *now >= s && *now < f) ||
636 	    (s >= f && (*now < f || *now >= s))) {
637 		if ((mouse = (int)consms_idle_time()) < 0) {
638 			if (! warned_ms) {
639 				warned_ms = 1;
640 				logerror("powerd: failed to get "
641 				    "idle time for console mouse");
642 			}
643 			return;
644 		}
645 		if ((kbd = (int)conskbd_idle_time()) < 0) {
646 			if (! warned_kbd) {
647 				warned_kbd = 1;
648 				logerror("powerd: failed to get "
649 				    "idle time for console keyboard");
650 			}
651 			return;
652 		}
653 
654 		system = last_system_activity(hr_now);
655 		/* who is the last to go idle */
656 		least_idle = MIN(system, MIN(kbd, mouse));
657 
658 		/*
659 		 * Calculate time_since_last_resume and the next_time
660 		 * to auto suspend.
661 		 */
662 		start_calc = 1;
663 		time_since_last_resume = time(NULL) - last_resume;
664 		next_time = info->pd_idle_time * 60 -
665 		    MIN(least_idle, time_since_last_resume);
666 
667 #ifdef DEBUG
668 		fprintf(stderr, " check_shutdown: next_time=%d\n", next_time);
669 #endif
670 
671 		/*
672 		 * If we have get the SIGTHAW signal at this point - our
673 		 * calculation of time_since_last_resume is wrong  so
674 		 * - we need to recalculate.
675 		 */
676 		while (start_calc == 0) {
677 			/* need to redo calculation */
678 			start_calc = 1;
679 			time_since_last_resume = time(NULL) - last_resume;
680 			next_time = info->pd_idle_time * 60 -
681 			    MIN(least_idle, time_since_last_resume);
682 		}
683 
684 		/*
685 		 * Only when everything else is idle, run the user's idlecheck
686 		 * script.
687 		 */
688 		if (next_time <= 0 && do_idlecheck) {
689 			got_sighup = 0;
690 			idlecheck_time = run_idlecheck();
691 			next_time = info->pd_idle_time * 60 -
692 			    MIN(idlecheck_time, MIN(least_idle,
693 			    time_since_last_resume));
694 			/*
695 			 * If we have caught SIGTHAW or SIGHUP, need to
696 			 * recalculate.
697 			 */
698 			while (start_calc == 0 || got_sighup == 1) {
699 				start_calc = 1;
700 				got_sighup = 0;
701 				idlecheck_time = run_idlecheck();
702 				time_since_last_resume = time(NULL) -
703 				    last_resume;
704 				next_time = info->pd_idle_time * 60 -
705 				    MIN(idlecheck_time, MIN(least_idle,
706 				    time_since_last_resume));
707 			}
708 		}
709 
710 		if (next_time <= 0) {
711 			if (is_ok2shutdown(now)) {
712 				/*
713 				 * Setup the autowakeup alarm.  Clear it
714 				 * right after poweroff, just in case if
715 				 * shutdown doesn't go through.
716 				 */
717 				if (info->pd_autoresume)
718 					tod_fd = open(TOD, O_RDWR);
719 				if (info->pd_autoresume && tod_fd != -1) {
720 					wakeup_time = (*now < f) ? f :
721 					    (f + DAYS_TO_SECS);
722 					/*
723 					 * A software fix for hardware
724 					 * bug 1217415.
725 					 */
726 					if ((wakeup_time - *now) < 180) {
727 						logerror(
728 		"Since autowakeup time is less than 3 minutes away, "
729 		"autoshutdown will not occur.");
730 						shutdown_time = *now + 180;
731 						(void) close(tod_fd);
732 						return;
733 					}
734 					if (ioctl(tod_fd, TOD_SET_ALARM,
735 					    &wakeup_time) == -1) {
736 						logerror("Unable to program TOD"
737 						    " alarm for autowakeup.");
738 						(void) close(tod_fd);
739 						return;
740 					}
741 				}
742 
743 				(void) poweroff("Autoshutdown",
744 				    autoshutdown_cmd);
745 
746 				if (info->pd_autoresume && tod_fd != -1) {
747 					if (ioctl(tod_fd, TOD_CLEAR_ALARM,
748 					    NULL) == -1)
749 						logerror("Unable to clear "
750 						    "alarm in TOD device.");
751 					(void) close(tod_fd);
752 				}
753 
754 				(void) time(now);
755 				/* wait at least 5 mins */
756 				shutdown_time = *now +
757 				    ((info->pd_idle_time * 60) > 300 ?
758 				    (info->pd_idle_time * 60) : 300);
759 			} else {
760 				/* wait 5 mins */
761 				shutdown_time = *now + 300;
762 			}
763 		} else
764 			shutdown_time = *now + next_time;
765 	} else if (s < f && *now >= f) {
766 		shutdown_time = s + DAYS_TO_SECS;
767 	} else
768 		shutdown_time = s;
769 }
770 
771 static int
is_ok2shutdown(time_t * now)772 is_ok2shutdown(time_t *now)
773 {
774 	int	prom_fd = -1;
775 	char	power_cycles_st[LLEN];
776 	char	power_cycle_limit_st[LLEN];
777 	char	system_board_date_st[LLEN];
778 	int	power_cycles, power_cycle_limit, free_cycles, scaled_cycles;
779 	time_t	life_began, life_passed;
780 	int	no_power_cycles = 0;
781 	int	no_system_board_date = 0;
782 	int	ret = 1;
783 
784 	/* CONSTCOND */
785 	while (1) {
786 		if ((prom_fd = open(PROM, O_RDWR)) == -1 &&
787 		    (errno == EAGAIN))
788 			continue;
789 		break;
790 	}
791 
792 	/*
793 	 * when #power-cycles property does not exist
794 	 * power cycles are unlimited.
795 	 */
796 	if (get_prom(prom_fd, options, "#power-cycles",
797 	    power_cycles_st, sizeof (power_cycles_st)) == 0)
798 		goto ckdone;
799 
800 	if (get_prom(prom_fd, root, "power-cycle-limit",
801 	    power_cycle_limit_st, sizeof (power_cycle_limit_st)) == 0) {
802 		power_cycle_limit = DEFAULT_POWER_CYCLE_LIMIT;
803 	} else {
804 		power_cycle_limit = atoi(power_cycle_limit_st);
805 	}
806 
807 	/*
808 	 * Allow 10% of power_cycle_limit as free cycles.
809 	 */
810 	free_cycles = power_cycle_limit / 10;
811 
812 	power_cycles = atoi(power_cycles_st);
813 	if (power_cycles < 0)
814 		no_power_cycles++;
815 	else if (power_cycles <= free_cycles)
816 		goto ckdone;
817 
818 	if (no_power_cycles && log_power_cycles_error == 0) {
819 		logerror("Invalid PROM property \"#power-cycles\" was found.");
820 		log_power_cycles_error++;
821 	}
822 
823 	if (get_prom(prom_fd, options, "system-board-date",
824 	    system_board_date_st, sizeof (system_board_date_st)) == 0) {
825 		no_system_board_date++;
826 	} else {
827 		life_began = strtol(system_board_date_st, (char **)NULL, 16);
828 		if (life_began > *now) {
829 			no_system_board_date++;
830 		}
831 	}
832 	if (no_system_board_date) {
833 		if (log_system_board_date_error == 0) {
834 			logerror("No or invalid PROM property "
835 			    "\"system-board-date\" was found.");
836 			log_system_board_date_error++;
837 		}
838 		life_began = DEFAULT_SYSTEM_BOARD_DATE;
839 	}
840 
841 	life_passed = *now - life_began;
842 
843 	/*
844 	 * Since we don't keep the date that last free_cycle is ended, we
845 	 * need to spread (power_cycle_limit - free_cycles) over the entire
846 	 * 7-year life span instead of (lifetime - date free_cycles ended).
847 	 */
848 	scaled_cycles = (int)(((float)life_passed / (float)LIFETIME_SECS) *
849 	    (power_cycle_limit - free_cycles));
850 
851 	if (no_power_cycles)
852 		goto ckdone;
853 
854 #ifdef DEBUG
855 	(void) fprintf(stderr, "Actual power_cycles = %d\t"
856 	    "Scaled power_cycles = %d\n", power_cycles, scaled_cycles);
857 #endif
858 	if (power_cycles > scaled_cycles) {
859 		if (log_no_autoshutdown_warning == 0) {
860 			logerror("Automatic shutdown has been temporarily "
861 			    "suspended in order to preserve the reliability "
862 			    "of this system.");
863 			log_no_autoshutdown_warning++;
864 		}
865 		ret = 0;
866 		goto ckdone;
867 	}
868 
869 ckdone:
870 	if (prom_fd != -1)
871 		(void) close(prom_fd);
872 	return (ret);
873 }
874 
875 static void
check_idleness(time_t * now,hrtime_t * hr_now)876 check_idleness(time_t *now, hrtime_t *hr_now)
877 {
878 
879 	/*
880 	 * Check idleness only when autoshutdown is enabled.
881 	 */
882 	if (!autoshutdown_en) {
883 		checkidle_time = 0;
884 		return;
885 	}
886 
887 	info->pd_ttychars_idle = check_tty(hr_now, asinfo.ttychars_thold);
888 	info->pd_loadaverage_idle =
889 	    check_load_ave(hr_now, asinfo.loadaverage_thold);
890 	info->pd_diskreads_idle = check_disks(hr_now, asinfo.diskreads_thold);
891 	info->pd_nfsreqs_idle = check_nfs(hr_now, asinfo.nfsreqs_thold);
892 
893 #ifdef DEBUG
894 	(void) fprintf(stderr, "Idle ttychars for %d secs.\n",
895 	    info->pd_ttychars_idle);
896 	(void) fprintf(stderr, "Idle loadaverage for %d secs.\n",
897 	    info->pd_loadaverage_idle);
898 	(void) fprintf(stderr, "Idle diskreads for %d secs.\n",
899 	    info->pd_diskreads_idle);
900 	(void) fprintf(stderr, "Idle nfsreqs for %d secs.\n",
901 	    info->pd_nfsreqs_idle);
902 #endif
903 
904 	checkidle_time = *now + IDLECHK_INTERVAL;
905 }
906 
907 static int
last_system_activity(hrtime_t * hr_now)908 last_system_activity(hrtime_t *hr_now)
909 {
910 	int	act_idle, latest;
911 
912 	latest = info->pd_idle_time * 60;
913 	act_idle = last_tty_activity(hr_now, asinfo.ttychars_thold);
914 	latest = MIN(latest, act_idle);
915 	act_idle = last_load_ave_activity(hr_now);
916 	latest = MIN(latest, act_idle);
917 	act_idle = last_disk_activity(hr_now, asinfo.diskreads_thold);
918 	latest = MIN(latest, act_idle);
919 	act_idle = last_nfs_activity(hr_now, asinfo.nfsreqs_thold);
920 	latest = MIN(latest, act_idle);
921 
922 	return (latest);
923 }
924 
925 static int
run_idlecheck()926 run_idlecheck()
927 {
928 	char		pm_variable[LLEN];
929 	char		*cp;
930 	int		status;
931 	pid_t		child;
932 
933 	/*
934 	 * Reap any child process which has been left over.
935 	 */
936 	while (waitpid((pid_t)-1, &status, WNOHANG) > 0)
937 		;
938 
939 	/*
940 	 * Execute the user's idlecheck script and set variable PM_IDLETIME.
941 	 * Returned exit value is the idle time in minutes.
942 	 */
943 	if ((child = fork1()) == 0) {
944 		(void) sprintf(pm_variable, "PM_IDLETIME=%d",
945 		    info->pd_idle_time);
946 		(void) putenv(pm_variable);
947 		cp = strrchr(asinfo.idlecheck_path, '/');
948 		if (cp == NULL)
949 			cp = asinfo.idlecheck_path;
950 		else
951 			cp++;
952 		(void) execl(asinfo.idlecheck_path, cp, NULL);
953 		exit(-1);
954 	} else if (child == -1) {
955 		return (info->pd_idle_time * 60);
956 	}
957 
958 	/*
959 	 * Wait until the idlecheck program completes.
960 	 */
961 	if (waitpid(child, &status, 0) != child) {
962 		/*
963 		 * We get here if the calling process gets a signal.
964 		 */
965 		return (info->pd_idle_time * 60);
966 	}
967 
968 	if (WEXITSTATUS(status) < 0) {
969 		return (info->pd_idle_time * 60);
970 	} else {
971 		return (WEXITSTATUS(status) * 60);
972 	}
973 }
974 
975 static void
set_alarm(time_t now)976 set_alarm(time_t now)
977 {
978 	time_t	itime, stime, next_time, max_time;
979 	int	next_alarm;
980 
981 	max_time = MAX(checkidle_time, shutdown_time);
982 	if (max_time == 0) {
983 		(void) alarm(0);
984 		return;
985 	}
986 	itime = (checkidle_time == 0) ? max_time : checkidle_time;
987 	stime = (shutdown_time == 0) ? max_time : shutdown_time;
988 	next_time = MIN(itime, stime);
989 	next_alarm = (next_time <= now) ? 1 : (next_time - now);
990 	(void) alarm(next_alarm);
991 
992 #ifdef DEBUG
993 	(void) fprintf(stderr, "Currently @ %s", ctime(&now));
994 	(void) fprintf(stderr, "Checkidle in %d secs\n", checkidle_time - now);
995 	(void) fprintf(stderr, "Shutdown  in %d secs\n", shutdown_time - now);
996 	(void) fprintf(stderr, "Next alarm goes off in %d secs\n", next_alarm);
997 	(void) fprintf(stderr, "************************************\n");
998 #endif
999 }
1000 
1001 static int
poweroff(const char * msg,char ** cmd_argv)1002 poweroff(const char *msg, char **cmd_argv)
1003 {
1004 	struct stat	statbuf;
1005 	pid_t		pid, child;
1006 	struct passwd	*pwd;
1007 	char		*home, *user;
1008 	char		ehome[] = "HOME=";
1009 	char		euser[] = "LOGNAME=";
1010 	int		status;
1011 	char		**ca;
1012 
1013 	if (mutex_trylock(&poweroff_mutex) != 0)
1014 		return (0);
1015 
1016 	if (stat("/dev/console", &statbuf) == -1 ||
1017 	    (pwd = getpwuid(statbuf.st_uid)) == NULL) {
1018 		(void) mutex_unlock(&poweroff_mutex);
1019 		return (1);
1020 	}
1021 
1022 	if (msg)
1023 		syslog(LOG_NOTICE, msg);
1024 
1025 	if (*cmd_argv == NULL) {
1026 		logerror("No command to run.");
1027 		(void) mutex_unlock(&poweroff_mutex);
1028 		return (1);
1029 	}
1030 
1031 	home = malloc(strlen(pwd->pw_dir) + sizeof (ehome));
1032 	user = malloc(strlen(pwd->pw_name) + sizeof (euser));
1033 	if (home == NULL || user == NULL) {
1034 		free(home);
1035 		free(user);
1036 		logerror("No memory.");
1037 		(void) mutex_unlock(&poweroff_mutex);
1038 		return (1);
1039 	}
1040 	(void) strcpy(home, ehome);
1041 	(void) strcat(home, pwd->pw_dir);
1042 	(void) strcpy(user, euser);
1043 	(void) strcat(user, pwd->pw_name);
1044 
1045 	/*
1046 	 * Need to simulate the user enviroment, minimaly set HOME, and USER.
1047 	 */
1048 	if ((child = fork1()) == 0) {
1049 		(void) putenv(home);
1050 		(void) putenv(user);
1051 		(void) setgid(pwd->pw_gid);
1052 		(void) setuid(pwd->pw_uid);
1053 
1054 		/*
1055 		 * check for shutdown flag and set environment
1056 		 */
1057 		for (ca = cmd_argv; *ca; ca++) {
1058 			if (strcmp("-h", *ca) == 0) {
1059 				(void) putenv("SYSSUSPENDDODEFAULT=");
1060 				break;
1061 			}
1062 		}
1063 
1064 		(void) execv(cmd_argv[0], cmd_argv);
1065 		exit(EXIT_FAILURE);
1066 	} else {
1067 		free(home);
1068 		free(user);
1069 		if (child == -1) {
1070 			(void) mutex_unlock(&poweroff_mutex);
1071 			return (1);
1072 		}
1073 	}
1074 	pid = 0;
1075 	while (pid != child)
1076 		pid = wait(&status);
1077 	if (WEXITSTATUS(status)) {
1078 		(void) syslog(LOG_ERR, "Failed to exec \"%s\".", cmd_argv[0]);
1079 		(void) mutex_unlock(&poweroff_mutex);
1080 		return (1);
1081 	}
1082 
1083 	(void) mutex_unlock(&poweroff_mutex);
1084 	return (0);
1085 }
1086 
1087 #define	PBUFSIZE	256
1088 
1089 /*
1090  * Gets the value of a prom property at either root or options node.  It
1091  * returns 1 if it is successful, otherwise it returns 0 .
1092  */
1093 static int
get_prom(int prom_fd,prom_node_t node_name,char * property_name,char * property_value,size_t len)1094 get_prom(int prom_fd, prom_node_t node_name,
1095     char *property_name, char *property_value, size_t len)
1096 {
1097 	union {
1098 		char buf[PBUFSIZE + sizeof (uint_t)];
1099 		struct openpromio opp;
1100 	} oppbuf;
1101 	register struct openpromio *opp = &(oppbuf.opp);
1102 	int	got_it = 0;
1103 
1104 	if (prom_fd == -1) {
1105 		return (0);
1106 	}
1107 
1108 	switch (node_name) {
1109 	case root:
1110 		(void) memset(oppbuf.buf, 0, PBUFSIZE);
1111 		opp->oprom_size = PBUFSIZE;
1112 		if (ioctl(prom_fd, OPROMNEXT, opp) < 0) {
1113 			return (0);
1114 		}
1115 
1116 		/*
1117 		 * Passing null string will give us the first property.
1118 		 */
1119 		(void) memset(oppbuf.buf, 0, PBUFSIZE);
1120 		do {
1121 			opp->oprom_size = PBUFSIZE;
1122 			if (ioctl(prom_fd, OPROMNXTPROP, opp) < 0) {
1123 				return (0);
1124 			}
1125 			if (strcmp(opp->oprom_array, property_name) == 0) {
1126 				got_it++;
1127 				break;
1128 			}
1129 		} while (opp->oprom_size > 0);
1130 
1131 		if (!got_it) {
1132 			return (0);
1133 		}
1134 		if (got_it && property_value == NULL) {
1135 			return (1);
1136 		}
1137 		opp->oprom_size = PBUFSIZE;
1138 		if (ioctl(prom_fd, OPROMGETPROP, opp) < 0) {
1139 			return (0);
1140 		}
1141 		if (opp->oprom_size == 0) {
1142 			*property_value = '\0';
1143 		} else {
1144 			estrcpy(property_value, opp->oprom_array, len);
1145 		}
1146 		break;
1147 	case options:
1148 		estrcpy(opp->oprom_array, property_name, PBUFSIZE);
1149 		opp->oprom_size = PBUFSIZE;
1150 		if (ioctl(prom_fd, OPROMGETOPT, opp) < 0) {
1151 			return (0);
1152 		}
1153 		if (opp->oprom_size == 0) {
1154 			return (0);
1155 		}
1156 		if (property_value != NULL) {
1157 			estrcpy(property_value, opp->oprom_array, len);
1158 		}
1159 		break;
1160 	default:
1161 		logerror("Only root node and options node are supported.\n");
1162 		return (0);
1163 	}
1164 
1165 	return (1);
1166 }
1167 
1168 #define	isspace(ch)	((ch) == ' ' || (ch) == '\t')
1169 #define	iseol(ch)	((ch) == '\n' || (ch) == '\r' || (ch) == '\f')
1170 
1171 /*ARGSUSED*/
1172 static void *
power_button_monitor(void * arg)1173 power_button_monitor(void *arg)
1174 {
1175 	struct pollfd pfd;
1176 	int events, ret;
1177 
1178 	if (ioctl(pb_fd, PB_BEGIN_MONITOR, NULL) == -1) {
1179 		logerror("Failed to monitor the power button.");
1180 		thr_exit((void *) 0);
1181 	}
1182 
1183 	pfd.fd = pb_fd;
1184 	pfd.events = POLLIN;
1185 
1186 	/*CONSTCOND*/
1187 	while (1) {
1188 		if (poll(&pfd, 1, INFTIM) == -1) {
1189 			logerror("Failed to poll for power button events.");
1190 			thr_exit((void *) 0);
1191 		}
1192 
1193 		if (!(pfd.revents & POLLIN))
1194 			continue;
1195 
1196 		/*
1197 		 * Monitor the power button, but only take action if
1198 		 * gnome-power-manager is not running.
1199 		 *
1200 		 * ret greater than 0 means could not find process.
1201 		 */
1202 		ret = system("/usr/bin/pgrep -fx gnome-power-manager");
1203 
1204 		if (ioctl(pfd.fd, PB_GET_EVENTS, &events) == -1) {
1205 			logerror("Failed to get power button events.");
1206 			thr_exit((void *) 0);
1207 		}
1208 
1209 		if ((ret > 0) && (events & PB_BUTTON_PRESS) &&
1210 		    (poweroff(NULL, power_button_cmd) != 0)) {
1211 			logerror("Power button is pressed, powering "
1212 			    "down the system!");
1213 
1214 			/*
1215 			 * Send SIGPWR signal to the init process to
1216 			 * shut down the system.
1217 			 */
1218 			if (kill(1, SIGPWR) == -1)
1219 				(void) uadmin(A_SHUTDOWN, AD_POWEROFF, 0);
1220 		}
1221 
1222 		/*
1223 		 * Clear any power button event that has happened
1224 		 * meanwhile we were busy processing the last one.
1225 		 */
1226 		if (ioctl(pfd.fd, PB_GET_EVENTS, &events) == -1) {
1227 			logerror("Failed to get power button events.");
1228 			thr_exit((void *) 0);
1229 		}
1230 	}
1231 	return (NULL);
1232 }
1233 
1234 static void
do_attach(void)1235 do_attach(void)
1236 {
1237 	if (read_cpr_config() < 0)
1238 		return;
1239 
1240 	/*
1241 	 * If autopm behavior is explicitly enabled for energystar-v2, or
1242 	 * set to default for energystar-v3, create a new thread to attach
1243 	 * all devices.
1244 	 */
1245 	estar_v3_prop = asinfo.is_autopm_default;
1246 	if ((strcmp(asinfo.apm_behavior, "enable") == 0) ||
1247 	    (estar_v3_prop && strcmp(asinfo.apm_behavior, "default") == 0)) {
1248 		if (powerd_debug)
1249 			logerror("powerd starting device attach thread.");
1250 		if (thr_create(NULL, 0, attach_devices, NULL,
1251 		    THR_DAEMON, NULL) != 0) {
1252 			logerror("Unable to create thread to attach devices.");
1253 		}
1254 	}
1255 }
1256 
1257 /*ARGSUSED*/
1258 static void *
attach_devices(void * arg)1259 attach_devices(void *arg)
1260 {
1261 	di_node_t root_node;
1262 
1263 	(void) sleep(60);	/* let booting finish first */
1264 
1265 	if ((root_node = di_init("/", DINFOFORCE)) == DI_NODE_NIL) {
1266 		logerror("Failed to attach devices.");
1267 		return (NULL);
1268 	}
1269 	di_fini(root_node);
1270 
1271 	/*
1272 	 * Unload all the modules.
1273 	 */
1274 	(void) modctl(MODUNLOAD, 0);
1275 
1276 	return (NULL);
1277 }
1278 
1279 
1280 /*
1281  * Create a file which will contain our pid.  Pmconfig will check this file
1282  * to see if we are running and can use the pid to signal us.  Returns the
1283  * file descriptor if successful, -1 otherwise.
1284  *
1285  * Note: Deal with attempt to launch multiple instances and also with existence
1286  * of an obsolete pid file caused by an earlier abort.
1287  */
1288 static int
open_pidfile(char * me)1289 open_pidfile(char *me)
1290 {
1291 	int fd;
1292 	const char *e1 = "%s: Cannot open pid file for read: ";
1293 	const char *e2 = "%s: Cannot unlink obsolete pid file: ";
1294 	const char *e3 = "%s: Either another daemon is running or the"
1295 	    " process is defunct (pid %d). \n";
1296 	const char *e4 = "%s: Cannot create pid file: ";
1297 
1298 again:
1299 	if ((fd = open(pidpath, O_CREAT | O_EXCL | O_WRONLY, 0444)) == -1) {
1300 		if (errno  == EEXIST) {
1301 			FILE *fp;
1302 			pid_t pid;
1303 
1304 			if ((fp = fopen(pidpath, "r")) == NULL) {
1305 				(void) fprintf(stderr, e1, me);
1306 				perror(NULL);
1307 				return (-1);
1308 			}
1309 
1310 			/* Read the pid */
1311 			pid = (pid_t)-1;
1312 			(void) fscanf(fp, "%ld", &pid);
1313 			(void) fclose(fp);
1314 			if (pid == -1) {
1315 				if (unlink(pidpath) == -1) {
1316 					(void) fprintf(stderr, e2, me);
1317 					perror(NULL);
1318 					return (-1);
1319 				} else /* try without corrupted file */
1320 					goto again;
1321 			}
1322 
1323 			/* Is pid for a running process */
1324 			if (kill(pid, 0) == -1) {
1325 				if (errno == ESRCH) {
1326 					if (unlink(pidpath) == -1) {
1327 						(void) fprintf(stderr, e2, me);
1328 						perror(NULL);
1329 						return (-1);
1330 					} else	/* try without obsolete file */
1331 						goto again;
1332 				}
1333 			} else {    /* powerd deamon still running or defunct */
1334 				(void) fprintf(stderr, e3, me, pid);
1335 				return (-1);
1336 			}
1337 
1338 		} else {	/* create failure not due to existing file */
1339 			(void) fprintf(stderr, e4, me);
1340 			perror(NULL);
1341 			return (-1);
1342 		}
1343 	}
1344 
1345 	(void) fchown(fd, (uid_t)-1, (gid_t)0);
1346 	return (fd);
1347 }
1348 
1349 /*
1350  * Write a pid to the pid file.  Report errors to syslog.
1351  *
1352  */
1353 static int
write_pidfile(int fd,pid_t pid)1354 write_pidfile(int fd, pid_t pid)
1355 {
1356 	int	len;
1357 	int	rc = 0;			/* assume success */
1358 
1359 	len = sprintf(scratch, "%ld\n", pid);
1360 	if (write(fd, scratch, len) != len) {
1361 		logerror("Cannot write pid file: %s", strerror(errno));
1362 		rc = -1;
1363 	}
1364 
1365 	return (rc);
1366 }
1367