/* * Toggle tray. * * Written by Benjamin Schwenk <*****@*****.**> and * Sybren Stuvel <*****@*****.**> * * Not supported by older kernels because it might use * CloseTray(). * */ static void toggle_tray(int fd) { #ifdef CDROM_DRIVE_STATUS /* First ask the CDROM for info, otherwise fall back to manual. */ switch (ioctl(fd, CDROM_DRIVE_STATUS)) { case CDS_TRAY_OPEN: close_tray(fd); return; case CDS_NO_DISC: case CDS_DISC_OK: if (!eject_cdrom(fd)) err(EXIT_FAILURE, _("CD-ROM eject command failed")); return; case CDS_NO_INFO: warnx(_("no CD-ROM information available")); return; case CDS_DRIVE_NOT_READY: warnx(_("CD-ROM drive is not ready")); return; default: abort(); } #else struct timeval time_start, time_stop; int time_elapsed; /* Try to open the CDROM tray and measure the time therefor * needed. In my experience the function needs less than 0.05 * seconds if the tray was already open, and at least 1.5 seconds * if it was closed. */ gettime_monotonic(&time_start); /* Send the CDROMEJECT command to the device. */ if (!eject_cdrom(fd)) err(EXIT_FAILURE, _("CD-ROM eject command failed")); /* Get the second timestamp, to measure the time needed to open * the tray. */ gettime_monotonic(&time_stop); time_elapsed = (time_stop.tv_sec * 1000000 + time_stop.tv_usec) - (time_start.tv_sec * 1000000 + time_start.tv_usec); /* If the tray "opened" too fast, we can be nearly sure, that it * was already open. In this case, close it now. Else the tray was * closed before. This would mean that we are done. */ if (time_elapsed < TRAY_WAS_ALREADY_OPEN_USECS) close_tray(fd); #endif }
/* * Wait for the top of a clock tick by reading /dev/rtc in a busy loop * until we see it. This function is used for rtc drivers without ioctl * interrupts. This is typical on an Alpha, where the Hardware Clock * interrupts are used by the kernel for the system clock, so aren't at * the user's disposal. */ static int busywait_for_rtc_clock_tick(const struct hwclock_control *ctl, const int rtc_fd) { struct tm start_time; /* The time when we were called (and started waiting) */ struct tm nowtime; int rc; struct timeval begin, now; if (ctl->verbose) { printf("ioctl(%d, RTC_UIE_ON, 0): %s\n", rtc_fd, strerror(errno)); printf(_("Waiting in loop for time from %s to change\n"), rtc_dev_name); } if (do_rtc_read_ioctl(rtc_fd, &start_time)) return 1; /* * Wait for change. Should be within a second, but in case * something weird happens, we have a time limit (1.5s) on this loop * to reduce the impact of this failure. */ gettime_monotonic(&begin); do { rc = do_rtc_read_ioctl(rtc_fd, &nowtime); if (rc || start_time.tm_sec != nowtime.tm_sec) break; gettime_monotonic(&now); if (time_diff(now, begin) > 1.5) { warnx(_("Timed out waiting for time change.")); return 1; } } while (1); if (rc) return 1; return 0; }
/* pim_time_monotonic_sec(): number of seconds since some unspecified starting point */ int64_t pim_time_monotonic_sec() { struct timeval now_tv; if (gettime_monotonic(&now_tv)) { zlog_err("%s: gettime_monotonic() failure: errno=%d: %s", __PRETTY_FUNCTION__, errno, safe_strerror(errno)); return -1; } return now_tv.tv_sec; }
static void write_output(struct script_control *ctl, char *obuf, ssize_t bytes) { DBG(IO, ul_debug(" writing output")); if (ctl->timing && ctl->timingfp) { struct timeval now, delta; DBG(IO, ul_debug(" writing timing info")); gettime_monotonic(&now); timersub(&now, &ctl->oldtime, &delta); fprintf(ctl->timingfp, "%ld.%06ld %zd\n", delta.tv_sec, delta.tv_usec, bytes); if (ctl->flush) fflush(ctl->timingfp); ctl->oldtime = now; } DBG(IO, ul_debug(" writing to script file")); if (fwrite_all(obuf, 1, bytes, ctl->typescriptfp)) { warn(_("cannot write script file")); fail(ctl); } if (ctl->flush) fflush(ctl->typescriptfp); DBG(IO, ul_debug(" writing to output")); if (write_all(STDOUT_FILENO, obuf, bytes)) { DBG(IO, ul_debug(" writing output *failed*")); warn(_("write failed")); fail(ctl); } DBG(IO, ul_debug(" writing output *done*")); }
int main(int argc, char **argv) { char *path; int c, fd, verbose = 0, secure = 0, secsize; uint64_t end, blksize, step, range[2], stats[2]; struct stat sb; struct timeval now, last; static const struct option longopts[] = { { "help", 0, 0, 'h' }, { "version", 0, 0, 'V' }, { "offset", 1, 0, 'o' }, { "length", 1, 0, 'l' }, { "step", 1, 0, 'p' }, { "secure", 0, 0, 's' }, { "verbose", 0, 0, 'v' }, { NULL, 0, 0, 0 } }; setlocale(LC_ALL, ""); bindtextdomain(PACKAGE, LOCALEDIR); textdomain(PACKAGE); atexit(close_stdout); range[0] = 0; range[1] = ULLONG_MAX; step = 0; while ((c = getopt_long(argc, argv, "hVsvo:l:p:", longopts, NULL)) != -1) { switch(c) { case 'h': usage(stdout); break; case 'V': printf(UTIL_LINUX_VERSION); return EXIT_SUCCESS; case 'l': range[1] = strtosize_or_err(optarg, _("failed to parse length")); break; case 'o': range[0] = strtosize_or_err(optarg, _("failed to parse offset")); break; case 'p': step = strtosize_or_err(optarg, _("failed to parse step")); break; case 's': secure = 1; break; case 'v': verbose = 1; break; default: usage(stderr); break; } } if (optind == argc) errx(EXIT_FAILURE, _("no device specified")); path = argv[optind++]; if (optind != argc) { warnx(_("unexpected number of arguments")); usage(stderr); } fd = open(path, O_WRONLY); if (fd < 0) err(EXIT_FAILURE, _("cannot open %s"), path); if (fstat(fd, &sb) == -1) err(EXIT_FAILURE, _("stat failed %s"), path); if (!S_ISBLK(sb.st_mode)) errx(EXIT_FAILURE, _("%s: not a block device"), path); if (ioctl(fd, BLKGETSIZE64, &blksize)) err(EXIT_FAILURE, _("%s: BLKGETSIZE64 ioctl failed"), path); if (ioctl(fd, BLKSSZGET, &secsize)) err(EXIT_FAILURE, _("%s: BLKSSZGET ioctl failed"), path); /* check offset alignment to the sector size */ if (range[0] % secsize) errx(EXIT_FAILURE, _("%s: offset %" PRIu64 " is not aligned " "to sector size %i"), path, range[0], secsize); /* is the range end behind the end of the device ?*/ if (range[0] > blksize) errx(EXIT_FAILURE, _("%s: offset is greater than device size"), path); end = range[0] + range[1]; if (end < range[0] || end > blksize) end = blksize; range[1] = (step > 0) ? step : end - range[0]; /* check length alignment to the sector size */ if (range[1] % secsize) errx(EXIT_FAILURE, _("%s: length %" PRIu64 " is not aligned " "to sector size %i"), path, range[1], secsize); stats[0] = range[0], stats[1] = 0; gettime_monotonic(&last); for (range[0] = range[0]; range[0] < end; range[0] += range[1]) { if (range[0] + range[1] > end) range[1] = end - range[0]; if (secure) { if (ioctl(fd, BLKSECDISCARD, &range)) err(EXIT_FAILURE, _("%s: BLKSECDISCARD ioctl failed"), path); } else { if (ioctl(fd, BLKDISCARD, &range)) err(EXIT_FAILURE, _("%s: BLKDISCARD ioctl failed"), path); } /* reporting progress */ if (verbose && step) { gettime_monotonic(&now); if (last.tv_sec < now.tv_sec) { print_stats(path, stats); stats[0] = range[0], stats[1] = 0; last = now; } } stats[1] += range[1]; } if (verbose) print_stats(path, stats); close(fd); return EXIT_SUCCESS; }