Changeset c8c43cae in mainline for uspace/lib/c

Timestamp:

2011-12-09T23:30:36Z (14 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

77b1c1a

Parents:

db8a034 (diff), a52de0e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge TCP rewrite.

Location:

uspace/lib/c

Files:

• generic/fibril_synch.c (modified) (1 diff)
• include/bitops.h (modified) (1 diff)
• include/errno.h (modified) (1 diff)
• include/fibril_synch.h (modified) (2 diffs)

uspace/lib/c/generic/fibril_synch.c

@@ -447 +447 @@
 }
 
+/** Timer fibril.
+ *
+ * @param arg   Timer
+ */
+static int fibril_timer_func(void *arg)
+{
+        fibril_timer_t *timer = (fibril_timer_t *) arg;
+        int rc;
+
+        fibril_mutex_lock(&timer->lock);
+
+        while (true) {
+                while (timer->state != fts_active &&
+                    timer->state != fts_cleanup) {
+
+                        if (timer->state == fts_cleanup)
+                                break;
+
+                        fibril_condvar_wait(&timer->cv, &timer->lock);
+                }
+
+                if (timer->state == fts_cleanup)
+                        break;
+
+                rc = fibril_condvar_wait_timeout(&timer->cv, &timer->lock,
+                    timer->delay);
+                if (rc == ETIMEOUT) {
+                        timer->state = fts_fired;
+                        fibril_mutex_unlock(&timer->lock);
+                        timer->fun(timer->arg);
+                        fibril_mutex_lock(&timer->lock);
+                }
+        }
+
+        fibril_mutex_unlock(&timer->lock);
+        return 0;
+}
+
+/** Create new timer.
+ *
+ * @return              New timer on success, @c NULL if out of memory.
+ */
+fibril_timer_t *fibril_timer_create(void)
+{
+        fid_t fid;
+        fibril_timer_t *timer;
+
+        timer = calloc(1, sizeof(fibril_timer_t));
+        if (timer == NULL)
+                return NULL;
+
+        fid = fibril_create(fibril_timer_func, (void *) timer);
+        if (fid == 0) {
+                free(timer);
+                return NULL;
+        }
+
+        fibril_mutex_initialize(&timer->lock);
+        fibril_condvar_initialize(&timer->cv);
+
+        timer->fibril = fid;
+        timer->state = fts_not_set;
+
+        fibril_add_ready(fid);
+
+        return timer;
+}
+
+/** Destroy timer.
+ *
+ * @param timer         Timer, must not be active or accessed by other threads.
+ */
+void fibril_timer_destroy(fibril_timer_t *timer)
+{
+        fibril_mutex_lock(&timer->lock);
+        assert(timer->state != fts_active);
+        timer->state = fts_cleanup;
+        fibril_condvar_broadcast(&timer->cv);
+        fibril_mutex_unlock(&timer->lock);
+}
+
+/** Set timer.
+ *
+ * Set timer to execute a callback function after the specified
+ * interval.
+ *
+ * @param timer         Timer
+ * @param delay         Delay in microseconds
+ * @param fun           Callback function
+ * @param arg           Argument for @a fun
+ */
+void fibril_timer_set(fibril_timer_t *timer, suseconds_t delay,
+    fibril_timer_fun_t fun, void *arg)
+{
+        fibril_mutex_lock(&timer->lock);
+        timer->state = fts_active;
+        timer->delay = delay;
+        timer->fun = fun;
+        timer->arg = arg;
+        fibril_condvar_broadcast(&timer->cv);
+        fibril_mutex_unlock(&timer->lock);
+}
+
+/** Clear timer.
+ *
+ * Clears (cancels) timer and returns last state of the timer.
+ * This can be one of:
+ *    - fts_not_set     If the timer has not been set or has been cleared
+ *    - fts_active      Timer was set but did not fire
+ *    - fts_fired       Timer fired
+ *
+ * @param timer         Timer
+ * @return              Last timer state
+ */
+fibril_timer_state_t fibril_timer_clear(fibril_timer_t *timer)
+{
+        fibril_timer_state_t old_state;
+
+        fibril_mutex_lock(&timer->lock);
+        old_state = timer->state;
+        timer->state = fts_not_set;
+
+        timer->delay = 0;
+        timer->fun = NULL;
+        timer->arg = NULL;
+        fibril_condvar_broadcast(&timer->cv);
+        fibril_mutex_unlock(&timer->lock);
+
+        return old_state;
+}
+
 /** @}
  */

uspace/lib/c/include/bitops.h

@@ -40 +40 @@
 /** Mask with bit @a n set. */
 #define BIT_V(type, n) \
-    ((type)1 << ((n) - 1))
+    ((type)1 << (n))
 
 /** Mask with rightmost @a n bits set. */
 #define BIT_RRANGE(type, n) \
-    (BIT_V(type, (n) + 1) - 1)
+    (BIT_V(type, (n)) - 1)
 
 /** Mask with bits @a hi .. @a lo set. @a hi >= @a lo. */

uspace/lib/c/include/errno.h

@@ -96 +96 @@
 #define ENOTCONN  (-10057)
 
+#define ECONNREFUSED  (-10058)
+
+#define ECONNABORTED  (-10059)
+
 /** The requested operation was not performed. Try again later. */
 #define EAGAIN  (-11002)

uspace/lib/c/include/fibril_synch.h

@@ -107 +107 @@
         fibril_condvar_t name = FIBRIL_CONDVAR_INITIALIZER(name)
 
+typedef void (*fibril_timer_fun_t)(void *);
+
+typedef enum {
+        /** Timer has not been set or has been cleared */
+        fts_not_set,
+        /** Timer was set but did not fire yet */
+        fts_active,
+        /** Timer has fired and has not been cleared since */
+        fts_fired,
+        /** Timer is being destroyed */
+        fts_cleanup
+} fibril_timer_state_t;
+
+/** Fibril timer.
+ *
+ * When a timer is set it executes a callback function (in a separate
+ * fibril) after a specified time interval. The timer can be cleared
+ * (canceled) before that. From the return value of fibril_timer_clear()
+ * one can tell whether the timer fired or not.
+ */
+typedef struct {
+        fibril_mutex_t lock;
+        fibril_condvar_t cv;
+        fid_t fibril;
+        fibril_timer_state_t state;
+
+        suseconds_t delay;
+        fibril_timer_fun_t fun;
+        void *arg;
+} fibril_timer_t;
+
 extern void fibril_mutex_initialize(fibril_mutex_t *);
 extern void fibril_mutex_lock(fibril_mutex_t *);
@@ -129 +160 @@
 extern void fibril_condvar_broadcast(fibril_condvar_t *);
 
+extern fibril_timer_t *fibril_timer_create(void);
+extern void fibril_timer_destroy(fibril_timer_t *);
+extern void fibril_timer_set(fibril_timer_t *, suseconds_t, fibril_timer_fun_t,
+    void *);
+extern fibril_timer_state_t fibril_timer_clear(fibril_timer_t *);
+
 #endif