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 */ 25 26 #include "statcommon.h" 27 28 #include <stdarg.h> 29 #include <signal.h> 30 #include <errno.h> 31 #include <string.h> 32 #include <stdlib.h> 33 34 extern char *cmdname; 35 extern int caught_cont; 36 37 /*PRINTFLIKE2*/ 38 void 39 fail(int do_perror, char *message, ...) 40 { 41 va_list args; 42 int save_errno = errno; 43 44 va_start(args, message); 45 (void) fprintf(stderr, "%s: ", cmdname); 46 (void) vfprintf(stderr, message, args); 47 va_end(args); 48 if (do_perror) 49 (void) fprintf(stderr, ": %s", strerror(save_errno)); 50 (void) fprintf(stderr, "\n"); 51 exit(2); 52 } 53 54 /* 55 * Sleep until *wakeup + interval, keeping cadence where desired 56 * 57 * *wakeup - The time we last wanted to wake up. Updated. 58 * interval - We want to sleep until *wakeup + interval 59 * forever - Running for infinite periods, so cadence not important 60 * *caught_cont - Global set by signal handler if we got a SIGCONT 61 */ 62 void 63 sleep_until(hrtime_t *wakeup, hrtime_t interval, int forever, 64 int *caught_cont) 65 { 66 hrtime_t now, pause, pause_left; 67 struct timespec pause_tv; 68 int status; 69 70 now = gethrtime(); 71 pause = *wakeup + interval - now; 72 73 if (pause <= 0 || pause < (interval / 4)) 74 if (forever || *caught_cont) { 75 /* Reset our cadence (see comment below) */ 76 *wakeup = now + interval; 77 pause = interval; 78 } else { 79 /* 80 * If we got here, then the time between the 81 * output we just did, and the scheduled time 82 * for the next output is < 1/4 of our requested 83 * interval AND the number of intervals has been 84 * requested AND we have never caught a SIGCONT 85 * (so we have never been suspended). In this 86 * case, we'll try to stay to the desired 87 * cadence, and we will pause for 1/2 the normal 88 * interval this time. 89 */ 90 pause = interval / 2; 91 *wakeup += interval; 92 } 93 else 94 *wakeup += interval; 95 if (pause < 1000) 96 /* Near enough */ 97 return; 98 99 /* Now do the actual sleep */ 100 pause_left = pause; 101 do { 102 pause_tv.tv_sec = pause_left / NANOSEC; 103 pause_tv.tv_nsec = pause_left % NANOSEC; 104 status = nanosleep(&pause_tv, (struct timespec *)NULL); 105 if (status < 0) 106 if (errno == EINTR) { 107 now = gethrtime(); 108 pause_left = *wakeup - now; 109 if (pause_left < 1000) 110 /* Near enough */ 111 return; 112 } else { 113 fail(1, "nanosleep failed"); 114 } 115 } while (status != 0); 116 } 117 118 /* 119 * Signal handler - so we can be aware of SIGCONT 120 */ 121 void 122 cont_handler(int sig_number) 123 { 124 /* Re-set the signal handler */ 125 (void) signal(sig_number, cont_handler); 126 caught_cont = 1; 127 } 128