conn.c

   1 #include <stdint.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include <errno.h>
   6 #include <limits.h>
   7 #include <unistd.h>
   8 #include "dat.h"
   9
  10 #define SAFETY_MARGIN (1000000000) /* 1 second */
  11
  12 static int cur_conn_ct = 0, cur_worker_ct = 0, cur_producer_ct = 0;
  13 static uint tot_conn_ct = 0;
  14 int verbose = 0;
  15
  16 static void
  17 on_watch(ms a, tube t, size_t i)
  18 {
  19     tube_iref(t);
  20     t->watching_ct++;
  21 }
  22
  23 static void
  24 on_ignore(ms a, tube t, size_t i)
  25 {
  26     t->watching_ct--;
  27     tube_dref(t);
  28 }
  29
  30 Conn *
  31 make_conn(int fd, char start_state, tube use, tube watch)
  32 {
  33     job j;
  34     Conn *c;
  35
  36     c = new(Conn);
  37     if (!c) return twarn("OOM"), NULL;
  38
  39     ms_init(&c->watch, (ms_event_fn) on_watch, (ms_event_fn) on_ignore);
  40     if (!ms_append(&c->watch, watch)) {
  41         free(c);
  42         return twarn("OOM"), NULL;
  43     }
  44
  45     TUBE_ASSIGN(c->use, use);
  46     use->using_ct++;
  47
  48     c->sock.fd = fd;
  49     c->state = start_state;
  50     c->pending_timeout = -1;
  51     c->tickpos = -1;
  52     j = &c->reserved_jobs;
  53     j->prev = j->next = j;
  54
  55     /* stats */
  56     cur_conn_ct++;
  57     tot_conn_ct++;
  58
  59     return c;
  60 }
  61
  62 void
  63 connsetproducer(Conn *c)
  64 {
  65     if (c->type & CONN_TYPE_PRODUCER) return;
  66     c->type |= CONN_TYPE_PRODUCER;
  67     cur_producer_ct++; /* stats */
  68 }
  69
  70 void
  71 connsetworker(Conn *c)
  72 {
  73     if (c->type & CONN_TYPE_WORKER) return;
  74     c->type |= CONN_TYPE_WORKER;
  75     cur_worker_ct++; /* stats */
  76 }
  77
  78 int
  79 count_cur_conns()
  80 {
  81     return cur_conn_ct;
  82 }
  83
  84 uint
  85 count_tot_conns()
  86 {
  87     return tot_conn_ct;
  88 }
  89
  90 int
  91 count_cur_producers()
  92 {
  93     return cur_producer_ct;
  94 }
  95
  96 int
  97 count_cur_workers()
  98 {
  99     return cur_worker_ct;
 100 }
 101
 102 static int
 103 has_reserved_job(Conn *c)
 104 {
 105     return job_list_any_p(&c->reserved_jobs);
 106 }
 107
 108
 109 static int64
 110 conntickat(Conn *c)
 111 {
 112     int margin = 0, should_timeout = 0;
 113     int64 t = INT64_MAX;
 114
 115     if (conn_waiting(c)) {
 116         margin = SAFETY_MARGIN;
 117     }
 118
 119     if (has_reserved_job(c)) {
 120         t = connsoonestjob(c)->r.deadline_at - nanoseconds() - margin;
 121         should_timeout = 1;
 122     }
 123     if (c->pending_timeout >= 0) {
 124         t = min(t, ((int64)c->pending_timeout) * 1000000000);
 125         should_timeout = 1;
 126     }
 127
 128     if (should_timeout) {
 129         return nanoseconds() + t;
 130     }
 131     return 0;
 132 }
 133
 134
 135 void
 136 connwant(Conn *c, int rw)
 137 {
 138     c->rw = rw;
 139     connsched(c);
 140 }
 141
 142
 143 void
 144 connsched(Conn *c)
 145 {
 146     c->tickat = conntickat(c);
 147     srvschedconn(c->srv, c);
 148 }
 149
 150
 151 /* return the reserved job with the earliest deadline,
 152  * or NULL if there's no reserved job */
 153 job
 154 connsoonestjob(Conn *c)
 155 {
 156     job j = NULL;
 157     job soonest = c->soonest_job;
 158
 159     if (soonest == NULL) {
 160         for (j = c->reserved_jobs.next; j != &c->reserved_jobs; j = j->next) {
 161             if (j->r.deadline_at <= (soonest ? : j)->r.deadline_at) soonest = j;
 162         }
 163     }
 164     c->soonest_job = soonest;
 165     return soonest;
 166 }
 167
 168
 169 /* return true if c has a reserved job with less than one second until its
 170  * deadline */
 171 int
 172 conndeadlinesoon(Conn *c)
 173 {
 174     int64 t = nanoseconds();
 175     job j = connsoonestjob(c);
 176
 177     return j && t >= j->r.deadline_at - SAFETY_MARGIN;
 178 }
 179
 180 int
 181 conn_ready(Conn *c)
 182 {
 183     size_t i;
 184
 185     for (i = 0; i < c->watch.used; i++) {
 186         if (((tube) c->watch.items[i])->ready.len) return 1;
 187     }
 188     return 0;
 189 }
 190
 191
 192 int
 193 connless(Conn *a, Conn *b)
 194 {
 195     return a->tickat < b->tickat;
 196 }
 197
 198
 199 void
 200 connrec(Conn *c, int i)
 201 {
 202     c->tickpos = i;
 203 }
 204
 205
 206 void
 207 connclose(Conn *c)
 208 {
 209     sockwant(&c->sock, 0);
 210     close(c->sock.fd);
 211     if (verbose) {
 212         printf("close %d\n", c->sock.fd);
 213     }
 214
 215     job_free(c->in_job);
 216
 217     /* was this a peek or stats command? */
 218     if (c->out_job && !c->out_job->r.id) job_free(c->out_job);
 219
 220     c->in_job = c->out_job = NULL;
 221     c->in_job_read = 0;
 222
 223     if (c->type & CONN_TYPE_PRODUCER) cur_producer_ct--; /* stats */
 224     if (c->type & CONN_TYPE_WORKER) cur_worker_ct--; /* stats */
 225
 226     cur_conn_ct--; /* stats */
 227
 228     remove_waiting_conn(c);
 229     if (has_reserved_job(c)) enqueue_reserved_jobs(c);
 230
 231     ms_clear(&c->watch);
 232     c->use->using_ct--;
 233     TUBE_ASSIGN(c->use, NULL);
 234
 235     if (c->tickpos > -1) {
 236         heapremove(&c->srv->conns, c->tickpos);
 237     }
 238
 239     protrmdirty(c);
 240     free(c);
 241 }