static void watch_file(const char *filename, struct stat *old) { do { roll_file(filename, old); xusleep(250000); } while(1); }
void unlinkdUnlink(const char *path) { char buf[MAXPATHLEN]; int l; int x; static int queuelen = 0; if (unlinkd_wfd < 0) { debug_trap("unlinkdUnlink: unlinkd_wfd < 0"); safeunlink(path, 0); return; } /* * If the queue length is greater than our limit, then * we pause for up to 10ms, hoping that unlinkd * has some feedback for us. Maybe it just needs a slice * of the CPU's time. */ if (queuelen >= UNLINKD_QUEUE_LIMIT) xusleep(10000); /* * If there is at least one outstanding unlink request, then * try to read a response. If there's nothing to read we'll * get an EWOULDBLOCK or whatever. If we get a response, then * decrement the queue size by the number of newlines read. */ if (queuelen > 0) { int x; int i; char rbuf[512]; #ifdef _SQUID_MSWIN_ x = recv(unlinkd_rfd, rbuf, 511, 0); #else x = read(unlinkd_rfd, rbuf, 511); #endif if (x > 0) { rbuf[x] = '\0'; for (i = 0; i < x; i++) if ('\n' == rbuf[i]) queuelen--; assert(queuelen >= 0); } } l = strlen(path); assert(l < MAXPATHLEN); xstrncpy(buf, path, MAXPATHLEN); buf[l++] = '\n'; #ifdef _SQUID_MSWIN_ x = send(unlinkd_wfd, buf, l, 0); #else x = write(unlinkd_wfd, buf, l); #endif if (x < 0) { debug(2, 1) ("unlinkdUnlink: write FD %d failed: %s\n", unlinkd_wfd, xstrerror()); safeunlink(path, 0); return; } else if (x != l) { debug(2, 1) ("unlinkdUnlink: FD %d only wrote %d of %d bytes\n", unlinkd_wfd, x, l); safeunlink(path, 0); return; } statCounter.unlink.requests++; statCounter.syscalls.disk.unlinks++; queuelen++; }
void startup(int argc, char *argv[]) { Dampkt dam_p; char tmp; char *ep = &tmp; ulong start = 0; long sluimer; int period = 0; int tmpperiod, tmp_alpha, tmp_beta, tmp_ftable_alpha, tmp_eij, tmp_maxhops; strncpy(dam_myID, (char *)NIC_OUI, DAM_ID_LEN); hdlr_install(); print("DAM node [%s] installed vector code.\n", dam_myID); devmac_ctl(NIC_NCR_WRITE, NIC_CMD_POWERUP, 0); print("DAM node [%s] powered up NIC.\n", dam_myID); dam_period = DAM_PROTOCOL_PERIOD; if (argc == 6) { tmpperiod = strtol(argv[0], &ep, 0); if (*ep != '\0') { printf("Invalid DAM period supplied as argument.\n"); } else { dam_period = tmpperiod; printf("Set dam_period to [%d] usecs\n", dam_period); } tmp_alpha = strtol(argv[1], &ep, 0); if (*ep != '\0') { printf("Invalid EAR alpha supplied as argument.\n"); } tmp_beta = strtol(argv[2], &ep, 0); if (*ep != '\0') { printf("Invalid EAR beta supplied as argument.\n"); } tmp_ftable_alpha = strtol(argv[3], &ep, 0); if (*ep != '\0') { printf("Invalid EAR ftable_alpha supplied as argument.\n"); } tmp_eij = strtol(argv[4], &ep, 0); if (*ep != '\0') { printf("Invalid EAR eij supplied as argument.\n"); } tmp_maxhops = strtol(argv[5], &ep, 0); if (*ep != '\0') { printf("Invalid EAR maxhops supplied as argument.\n"); } Ear = ear_init(dam_myID, 0, tmp_alpha, tmp_beta, tmp_ftable_alpha, tmp_eij, tmp_maxhops, (uchar)devloc_getxloc(), (uchar)devloc_getyloc(), (uchar)devloc_getzloc()); fprintf(stderr, "DAM node [%s] completed EAR init with runtime args:\n" "\talpha=%d\n\tbeta=%d\n\tftable_alpha=%d\n\teij=%d\n\tmaxhops=%d\n\n\n\n", dam_myID, tmp_alpha, tmp_beta, tmp_ftable_alpha, tmp_eij, tmp_maxhops); } else { Ear = ear_init(dam_myID, 0, 1, 50, 1, 1 /* eij */, 8 /* maxhops */, (uchar)devloc_getxloc(), (uchar)devloc_getyloc(), (uchar)devloc_getzloc()); print("DAM node [%s] completed EAR init using defaults.\n\n\n", dam_myID); } /* */ /* Implemented to mirror description in paper */ /* All variables beginning w/ dam_ correspond */ /* to variables in the paper's algorithm descr. */ /* */ while (1) { start = devrtc_getusecs(); dam_p.timestamp = start; /* */ /* Write the log for the previous period. We want all actions to */ /* be in the timed loop, and though this log writing may seem to */ /* be not inherent to application, you can think of it as some */ /* post-peak detection actions that the algorithm must perform. */ /* */ if ((period > 0) && dam_participating) { if (strlen(dam_sink) > 0) { int id; char tmp; char *ep = &tmp; id = strtol(dam_leaderID, &ep, 0); ear_response(Ear, dam_sink, NULL, 0, id); } //print("\n\ndam_sink = [%s]\n\n\n", dam_sink); write_log(period - 1); } /* */ /* The values in this case are in Lux (see test.m) */ /* Noise floor is 0.1 Lux. DAM_THRESHOLD_ELECTION is */ /* thus set to 10 Lux. */ /* */ dam_myPr = devsignal_read(LIGHT_SENSOR); /* */ /* Algorithm description in PARC paper does not reset */ /* maxPrHeard. For each DAM period, until a packet is */ /* received, or our local reading is > threshold, the */ /* maxPrHeard should be 0. */ /* */ dam_maxPrHeard = 0; if (dam_myPr > DAM_THRESHOLD_ELECTION) { LOGMARK(12); dam_participating = TRUE; dam_maxPrHeard = dam_myPr; strncpy(dam_leaderID, dam_myID, DAM_ID_LEN); dam_p.maxPr = dam_p.transPr = dam_myPr; strncpy((char *)dam_p.transID, dam_myID, DAM_ID_LEN); strncpy((char *)dam_p.maxID, dam_myID, DAM_ID_LEN); dam_broadcast(&dam_p); LOGMARK(13); } else { dam_participating = FALSE; } sluimer = dam_period - (devrtc_getusecs() - start); sluimer = max(sluimer, 0); LOGMARK(2); xusleep(sluimer); LOGMARK(3); period++; } return; }
int main(int argc, char **argv) { struct rtcwake_control ctl = { .mode_str = "suspend", /* default mode */ .adjfile = _PATH_ADJTIME, .clock_mode = CM_AUTO }; char *devname = DEFAULT_RTC_DEVICE; unsigned seconds = 0; int suspend = SYSFS_MODE; int rc = EXIT_SUCCESS; int t; int fd; time_t alarm = 0; enum { OPT_DATE = CHAR_MAX + 1, OPT_LIST }; static const struct option long_options[] = { {"adjfile", required_argument, 0, 'A'}, {"auto", no_argument, 0, 'a'}, {"dry-run", no_argument, 0, 'n'}, {"local", no_argument, 0, 'l'}, {"utc", no_argument, 0, 'u'}, {"verbose", no_argument, 0, 'v'}, {"version", no_argument, 0, 'V'}, {"help", no_argument, 0, 'h'}, {"mode", required_argument, 0, 'm'}, {"device", required_argument, 0, 'd'}, {"seconds", required_argument, 0, 's'}, {"time", required_argument, 0, 't'}, {"date", required_argument, 0, OPT_DATE}, {"list-modes", no_argument, 0, OPT_LIST}, {0, 0, 0, 0 } }; static const ul_excl_t excl[] = { { 'a', 'l', 'u' }, { 's', 't', OPT_DATE }, }; int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT; setlocale(LC_ALL, ""); bindtextdomain(PACKAGE, LOCALEDIR); textdomain(PACKAGE); atexit(close_stdout); while ((t = getopt_long(argc, argv, "A:ahd:lm:ns:t:uVv", long_options, NULL)) != EOF) { err_exclusive_options(t, long_options, excl, excl_st); switch (t) { case 'A': /* for better compatibility with hwclock */ ctl.adjfile = optarg; break; case 'a': ctl.clock_mode = CM_AUTO; break; case 'd': devname = optarg; break; case 'l': ctl.clock_mode = CM_LOCAL; break; case OPT_LIST: list_modes(&ctl); return EXIT_SUCCESS; case 'm': if ((suspend = get_rtc_mode(&ctl, optarg)) < 0) errx(EXIT_FAILURE, _("unrecognized suspend state '%s'"), optarg); ctl.mode_str = optarg; break; case 'n': ctl.dryrun = 1; break; case 's': /* alarm time, seconds-to-sleep (relative) */ seconds = strtou32_or_err(optarg, _("invalid seconds argument")); break; case 't': /* alarm time, time_t (absolute, seconds since epoch) */ alarm = strtou32_or_err(optarg, _("invalid time argument")); break; case OPT_DATE: { /* alarm time, see timestamp format from manual */ usec_t p; if (parse_timestamp(optarg, &p) < 0) errx(EXIT_FAILURE, _("invalid time value \"%s\""), optarg); alarm = (time_t) (p / 1000000); break; } case 'u': ctl.clock_mode = CM_UTC; break; case 'v': ctl.verbose = 1; break; case 'V': printf(UTIL_LINUX_VERSION); exit(EXIT_SUCCESS); case 'h': usage(stdout); default: usage(stderr); } } if (ctl.clock_mode == CM_AUTO) { if (read_clock_mode(&ctl) < 0) { printf(_("%s: assuming RTC uses UTC ...\n"), program_invocation_short_name); ctl.clock_mode = CM_UTC; } } if (ctl.verbose) printf("%s", ctl.clock_mode == CM_UTC ? _("Using UTC time.\n") : _("Using local time.\n")); if (!alarm && !seconds && suspend != DISABLE_MODE && suspend != SHOW_MODE) errx(EXIT_FAILURE, _("must provide wake time (see --seconds, --time and --date options)")); /* device must exist and (if we'll sleep) be wakeup-enabled */ fd = open_dev_rtc(devname); if (suspend != ON_MODE && suspend != NO_MODE && !is_wakeup_enabled(devname)) errx(EXIT_FAILURE, _("%s not enabled for wakeup events"), devname); /* relative or absolute alarm time, normalized to time_t */ if (get_basetimes(&ctl, fd) < 0) exit(EXIT_FAILURE); if (ctl.verbose) printf(_("alarm %ld, sys_time %ld, rtc_time %ld, seconds %u\n"), alarm, ctl.sys_time, ctl.rtc_time, seconds); if (suspend != DISABLE_MODE && suspend != SHOW_MODE) { /* perform alarm setup when the show or disable modes are not set */ if (alarm) { if (alarm < ctl.sys_time) errx(EXIT_FAILURE, _("time doesn't go backward to %s"), ctime(&alarm)); alarm += ctl.sys_time - ctl.rtc_time; } else alarm = ctl.rtc_time + seconds + 1; if (setup_alarm(&ctl, fd, &alarm) < 0) exit(EXIT_FAILURE); if (suspend == NO_MODE || suspend == ON_MODE) printf(_("%s: wakeup using %s at %s"), program_invocation_short_name, devname, ctime(&alarm)); else printf(_("%s: wakeup from \"%s\" using %s at %s"), program_invocation_short_name, ctl.mode_str, devname, ctime(&alarm)); fflush(stdout); xusleep(10 * 1000); } switch (suspend) { case NO_MODE: if (ctl.verbose) printf(_("suspend mode: no; leaving\n")); ctl.dryrun = 1; /* to skip disabling alarm at the end */ break; case OFF_MODE: { char *arg[5]; int i = 0; if (ctl.verbose) printf(_("suspend mode: off; executing %s\n"), _PATH_SHUTDOWN); arg[i++] = _PATH_SHUTDOWN; arg[i++] = "-h"; arg[i++] = "-P"; arg[i++] = "now"; arg[i] = NULL; if (!ctl.dryrun) { execv(arg[0], arg); warn(_("failed to execute %s"), _PATH_SHUTDOWN); rc = EXIT_FAILURE; } break; } case ON_MODE: { unsigned long data; if (ctl.verbose) printf(_("suspend mode: on; reading rtc\n")); if (!ctl.dryrun) { do { t = read(fd, &data, sizeof data); if (t < 0) { warn(_("rtc read failed")); break; } if (ctl.verbose) printf("... %s: %03lx\n", devname, data); } while (!(data & RTC_AF)); } break; } case DISABLE_MODE: /* just break, alarm gets disabled in the end */ if (ctl.verbose) printf(_("suspend mode: disable; disabling alarm\n")); break; case SHOW_MODE: if (ctl.verbose) printf(_("suspend mode: show; printing alarm info\n")); if (print_alarm(&ctl, fd)) rc = EXIT_FAILURE; ctl.dryrun = 1; /* don't really disable alarm in the end, just show */ break; default: if (ctl.verbose) printf(_("suspend mode: %s; suspending system\n"), ctl.mode_str); sync(); suspend_system(&ctl); } if (!ctl.dryrun) { struct rtc_wkalrm wake; if (ioctl(fd, RTC_WKALM_RD, &wake) < 0) { warn(_("read rtc alarm failed")); rc = EXIT_FAILURE; } else { wake.enabled = 0; if (ioctl(fd, RTC_WKALM_SET, &wake) < 0) { warn(_("disable rtc alarm interrupt failed")); rc = EXIT_FAILURE; } } } close(fd); return rc; }