void noit_metric_director_message_deref(void *m) { noit_metric_message_t *message = (noit_metric_message_t *)m; if (mtev_atomic_dec32(&message->refcnt) == 0) { noit_metric_director_free_message(message); } }
static void filterset_free(void *vp) { filterset_t *fs = vp; filterrule_t *r; if(mtev_atomic_dec32(&fs->ref_cnt) != 0) return; mtevL(noit_debug, "Freeing filterset [%d]: %s\n", fs->ref_cnt, fs->name); while(fs->rules) { r = fs->rules->next; filterrule_free(fs->rules); fs->rules = r; } if(fs->name) free(fs->name); free(fs); }
/* * Helpers to create and destroy our context. */ static void ssl_ctx_cache_node_free(ssl_ctx_cache_node *node) { mtev_atomic32_t endval; if(!node) return; endval = mtev_atomic_dec32(&node->refcnt); if(endval == 0) { mtevL(eventer_deb, "ssl_ctx_cache_node_free(%p -> %d) freeing\n", node, endval); SSL_CTX_free(node->internal_ssl_ctx); free(node->key); free(node); } else { mtevL(eventer_deb, "ssl_ctx_cache_node_free(%p -> %d)\n", node, endval); } }
void eventer_free(eventer_t e) { if(mtev_atomic_dec32(&e->refcnt) == 0) { mtev_atomic_dec64(&ealloccnt); free(e); } }
void * noit_jlog_thread_main(void *e_vptr) { int mask, bytes_read, sleeptime, max_sleeptime; eventer_t e = e_vptr; acceptor_closure_t *ac = e->closure; noit_jlog_closure_t *jcl = ac->service_ctx; char inbuff[sizeof(jlog_id)]; mtev_memory_init_thread(); eventer_set_fd_blocking(e->fd); max_sleeptime = DEFAULT_MSECONDS_BETWEEN_BATCHES; if(ac->cmd == NOIT_JLOG_DATA_TEMP_FEED) max_sleeptime = DEFAULT_TRANSIENT_MSECONDS_BETWEEN_BATCHES; sleeptime = max_sleeptime; while(1) { jlog_id client_chkpt; sleeptime = MIN(sleeptime, max_sleeptime); jlog_get_checkpoint(jcl->jlog, ac->remote_cn, &jcl->chkpt); jcl->count = jlog_ctx_read_interval(jcl->jlog, &jcl->start, &jcl->finish); if(jcl->count < 0) { char idxfile[PATH_MAX]; mtevL(noit_error, "jlog_ctx_read_interval: %s\n", jlog_ctx_err_string(jcl->jlog)); switch (jlog_ctx_err(jcl->jlog)) { case JLOG_ERR_FILE_CORRUPT: case JLOG_ERR_IDX_CORRUPT: jlog_repair_datafile(jcl->jlog, jcl->start.log); jlog_repair_datafile(jcl->jlog, jcl->start.log + 1); mtevL(noit_error, "jlog reconstructed, deleting corresponding index.\n"); STRSETDATAFILE(jcl->jlog, idxfile, jcl->start.log); strlcat(idxfile, INDEX_EXT, sizeof(idxfile)); unlink(idxfile); STRSETDATAFILE(jcl->jlog, idxfile, jcl->start.log + 1); strlcat(idxfile, INDEX_EXT, sizeof(idxfile)); unlink(idxfile); goto alldone; break; default: goto alldone; } } if(jcl->count > MAX_ROWS_AT_ONCE) { /* Artificially set down the range to make the batches a bit easier * to handle on the stratcond/postgres end. * However, we must have more data, so drop the sleeptime to 0 */ jcl->count = MAX_ROWS_AT_ONCE; jcl->finish.marker = jcl->start.marker + jcl->count; } if(jcl->count > 0) { sleeptime = 0; if(noit_jlog_push(e, jcl)) { goto alldone; } /* Read our jlog_id accounting for possibly short reads */ bytes_read = 0; while(bytes_read < sizeof(jlog_id)) { int len; if((len = e->opset->read(e->fd, inbuff + bytes_read, sizeof(jlog_id) - bytes_read, &mask, e)) <= 0) goto alldone; bytes_read += len; } memcpy(&client_chkpt, inbuff, sizeof(jlog_id)); /* Fix the endian */ client_chkpt.log = ntohl(client_chkpt.log); client_chkpt.marker = ntohl(client_chkpt.marker); if(memcmp(&jcl->chkpt, &client_chkpt, sizeof(jlog_id))) { mtevL(noit_error, "client %s submitted invalid checkpoint %u:%u expected %u:%u\n", ac->remote_cn, client_chkpt.log, client_chkpt.marker, jcl->chkpt.log, jcl->chkpt.marker); goto alldone; } mtev_gettimeofday(&jcl->feed_stats->last_checkpoint, NULL); jlog_ctx_read_checkpoint(jcl->jlog, &jcl->chkpt); } else { /* we have nothing to write -- maybe we have no checks configured... * If this is the case "forever", the remote might disconnect and * we would never know. Do the painful work of detecting a * disconnected client. */ struct pollfd pfd; pfd.fd = e->fd; pfd.events = POLLIN | POLLHUP | POLLRDNORM; pfd.revents = 0; if(poll(&pfd, 1, 0) != 0) { /* normally, we'd recv PEEK|DONTWAIT. However, the client should * not be writing to us. So, we know we can't have any legitimate * data on this socket (true even though this is SSL). So, if we're * here then "shit went wrong" */ mtevL(noit_error, "jlog client %s disconnected while idle\n", ac->remote_cn); goto alldone; } } if(sleeptime) { usleep(sleeptime * 1000); /* us -> ms */ } sleeptime += 1000; /* 1 s */ } alldone: e->opset->close(e->fd, &mask, e); mtev_atomic_dec32(&jcl->feed_stats->connections); noit_jlog_closure_free(jcl); acceptor_closure_free(ac); mtev_memory_maintenance(); return NULL; }