Cygwin: timerfd: rename overrun_count to expiration_count

The value returned by reading from a timerfd is not an overrun
count in the same sense as for posix timers, it's an expiry counter.
Reflect that in the name.

Signed-off-by: Corinna Vinschen <corinna@vinschen.de>

diff --git a/winsup/cygwin/fhandler_timerfd.cc b/winsup/cygwin/fhandler_timerfd.cc
index 33829edac558f18fab189a0ccccaf4699c9ad074..8a6c4b559469f6b26c3f1d37db0cf2b333dd9b5c 100644 (file)
--- a/winsup/cygwin/fhandler_timerfd.cc
+++ b/winsup/cygwin/fhandler_timerfd.cc
@@ -218,7 +218,7 @@ int
 fhandler_timerfd::ioctl (unsigned int cmd, void *p)
 {
   int ret = -1;
-  uint64_t ov_cnt;
+  uint64_t exp_cnt;
 
   switch (cmd)
     {
@@ -227,13 +227,13 @@ fhandler_timerfd::ioctl (unsigned int cmd, void *p)
        {
          timerfd_tracker *tfd = (timerfd_tracker *) timerid;
 
-         ov_cnt = *(uint64_t *) p;
-         if (!ov_cnt)
+         exp_cnt = *(uint64_t *) p;
+         if (!exp_cnt)
            {
              set_errno (EINVAL);
              break;
            }
-         tfd->ioctl_set_ticks (ov_cnt);
+         tfd->ioctl_set_ticks (exp_cnt);
          ret = 0;
        }
       __except (EFAULT) {}

diff --git a/winsup/cygwin/timerfd.cc b/winsup/cygwin/timerfd.cc
index 0a042415d44a01c9f5061763fa62ea07da636a3a..08fff312cd8e5bc335419c68ad1524dc18a99b78 100644 (file)
--- a/winsup/cygwin/timerfd.cc
+++ b/winsup/cygwin/timerfd.cc
@@ -70,7 +70,7 @@ timerfd_tracker::handle_timechange_window ()
          /* make sure to handle each WM_TIMECHANGE only once! */
          if (msg.time != tc_time ())
            {
-             set_overrun_count (-1LL);
+             set_expiration_count (-1LL);
              disarm_timer ();
              timer_expired ();
              set_tc_time (msg.time);
@@ -133,7 +133,7 @@ timerfd_tracker::thread_func ()
            continue;
          /* Make sure we haven't been abandoned and/or disarmed
             in the meantime */
-         if (overrun_count () == -1LL
+         if (expiration_count () == -1LL
              || IsEventSignalled (tfd_shared->disarm_evt ()))
            {
              leave_critical_section ();
@@ -142,29 +142,29 @@ timerfd_tracker::thread_func ()
          /* One-shot timer? */
          if (!get_interval ())
            {
-             /* Set overrun count, disarm timer */
-             increment_overrun_count (1);
+             /* Set expiration count, disarm timer */
+             increment_expiration_count (1);
              disarm_timer ();
            }
          else
            {
-             /* Compute overrun count. */
+             /* Compute expiration count. */
              LONG64 now = get_clock_now ();
              LONG64 ts = get_exp_ts ();
+             LONG64 exp_cnt;
 
              /* Make concessions for unexact realtime clock */
              if (ts > now)
                ts = now - 1;
-             LONG64 ov_cnt = (now - ts + get_interval () - 1)
-                             / get_interval ();
-             increment_overrun_count (ov_cnt);
-             ts += get_interval () * ov_cnt;
+             exp_cnt = (now - ts + get_interval () - 1) / get_interval ();
+             increment_expiration_count (exp_cnt);
+             ts += get_interval () * exp_cnt;
              /* Set exp_ts to current timestamp.  Make sure exp_ts ends up
-                bigger than "now" and fix overrun count as required */
+                bigger than "now" and fix expiration count as required */
              while (ts <= (now = get_clock_now ()))
                {
-                 increment_overrun_count ((now - ts + get_interval () - 1)
-                                          / get_interval ());
+                 increment_expiration_count ((now - ts + get_interval () - 1)
+                                             / get_interval ());
                  ts += get_interval ();
                }
              set_exp_ts (ts);
@@ -395,9 +395,9 @@ timerfd_tracker::close ()
 }
 
 void
-timerfd_tracker::ioctl_set_ticks (uint64_t ov_cnt)
+timerfd_tracker::ioctl_set_ticks (uint64_t exp_cnt)
 {
-  set_overrun_count (ov_cnt);
+  set_expiration_count (exp_cnt);
   timer_expired ();
 }
 
@@ -449,7 +449,7 @@ repeat:
        ret = -EIO;
       else
        {
-         ret = read_and_reset_overrun_count ();
+         ret = read_and_reset_expiration_count ();
          leave_critical_section ();
          switch (ret)
            {
@@ -461,7 +461,7 @@ repeat:
                goto repeat;
              ret = -EAGAIN;
              break;
-           default:    /* Return (positive) overrun count. */
+           default:    /* Return (positive) expiration count. */
              if (ret < 0)
                ret = INT64_MAX;
              break;
@@ -539,7 +539,7 @@ timerfd_shared::arm_timer (int flags, const struct itimerspec *new_value)
        {
          DueTime.QuadPart = get_clock_now () - ts;
          /* If the timestamp was earlier than now, compute number
-            of overruns and offset DueTime to expire immediately. */
+            of expirations and offset DueTime to expire immediately. */
          if (DueTime.QuadPart >= 0)
            DueTime.QuadPart = -1LL;
        }

diff --git a/winsup/cygwin/timerfd.h b/winsup/cygwin/timerfd.h
index e314579b0e1bfa15b1529ebab23620ab3edf1f74..1f9f7626880162e0e15f97608d96558445396352 100644 (file)
--- a/winsup/cygwin/timerfd.h
+++ b/winsup/cygwin/timerfd.h
@@ -29,7 +29,7 @@ class timerfd_shared
   LONG64 _exp_ts;              /* start timestamp or next expire timestamp
                                   in 100ns */
   LONG64 _interval;            /* timer interval in 100ns */
-  LONG64 _overrun_count;       /* expiry counter */
+  LONG64 _expiration_count;    /* expiry counter */
   int _flags;                  /* settime flags */
   DWORD _tc_time;              /* timestamp of the last WM_TIMECHANGE msg */
 
@@ -46,13 +46,13 @@ class timerfd_shared
   int flags () const { return _flags; }
 
   /* write access methods */
-  void increment_overrun_count (LONG64 add)
-    { InterlockedAdd64 (&_overrun_count, add); }
-  void set_overrun_count (LONG64 newval)
-    { InterlockedExchange64 (&_overrun_count, newval); }
-  LONG64 read_and_reset_overrun_count ()
+  void increment_expiration_count (LONG64 add)
+    { InterlockedAdd64 (&_expiration_count, add); }
+  void set_expiration_count (LONG64 newval)
+    { InterlockedExchange64 (&_expiration_count, newval); }
+  LONG64 read_and_reset_expiration_count ()
     {
-      LONG64 ret = InterlockedExchange64 (&_overrun_count, 0);
+      LONG64 ret = InterlockedExchange64 (&_expiration_count, 0);
       if (ret)
        ResetEvent (_expired_evt);
       return ret;
@@ -113,13 +113,13 @@ class timerfd_tracker             /* cygheap! */
   int disarm_timer () const { return tfd_shared->disarm_timer (); }
   void timer_expired () const { tfd_shared->timer_expired (); }
 
-  LONG64 overrun_count () const { return tfd_shared->_overrun_count; }
-  void increment_overrun_count (LONG64 add) const
-    { tfd_shared->increment_overrun_count (add); }
-  void set_overrun_count (LONG64 ov_cnt) const
-    { tfd_shared->set_overrun_count ((LONG64) ov_cnt); }
-  LONG64 read_and_reset_overrun_count () const
-    { return tfd_shared->read_and_reset_overrun_count (); }
+  LONG64 expiration_count () const { return tfd_shared->_expiration_count; }
+  void increment_expiration_count (LONG64 add) const
+    { tfd_shared->increment_expiration_count (add); }
+  void set_expiration_count (LONG64 exp_cnt) const
+    { tfd_shared->set_expiration_count ((LONG64) exp_cnt); }
+  LONG64 read_and_reset_expiration_count () const
+    { return tfd_shared->read_and_reset_expiration_count (); }
 
   struct timespec it_value () const
     { return tfd_shared->time_spec ().it_value; }