int sick_transaction(sick_t *s, uint8_t *request, uint8_t responsetype, uint8_t *response, int timeoutms) { pthread_mutex_lock(&s->writelock); int res = 0; int trials = 0; int requestlen; retry: requestlen = packet_length(request); if (s->log_packets_file) { for (int i = 0; i < requestlen; i++) { if (i%16 == 0) fprintf(s->log_packets_file, "TX %04x : ", i); fprintf(s->log_packets_file, "%02x ", request[i]); if ((i%16) == 15 || i+1 == requestlen) fprintf(s->log_packets_file, "\n"); } } // send the request res = write_fully(s->serialfd, request, requestlen); if (res < 0) { printf("write failed\n"); goto exit; } // wait for response s->writereqid = responsetype; s->writedata = response; s->writevalid = 0; struct timespec ts; timespec_now(&ts); timespec_addms(&ts, timeoutms); pthread_cond_timedwait(&s->writecond, &s->writelock, &ts); if (!s->writevalid) { trials++; if (trials > SICK_OP_MAX_RETRIES) { res = -2; goto exit; } goto retry; } exit: s->writedata = NULL; s->writereqid = 0; pthread_mutex_unlock(&s->writelock); return res; }
gf_timer_t * gf_timer_call_after (glusterfs_ctx_t *ctx, struct timespec delta, gf_timer_cbk_t callbk, void *data) { gf_timer_registry_t *reg = NULL; gf_timer_t *event = NULL; gf_timer_t *trav = NULL; uint64_t at = 0; if (ctx == NULL) { gf_msg_callingfn ("timer", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG, "invalid argument"); return NULL; } reg = gf_timer_registry_init (ctx); if (!reg) { gf_msg_callingfn ("timer", GF_LOG_ERROR, 0, LG_MSG_TIMER_REGISTER_ERROR, "!reg"); return NULL; } event = GF_CALLOC (1, sizeof (*event), gf_common_mt_gf_timer_t); if (!event) { return NULL; } timespec_now (&event->at); timespec_adjust_delta (&event->at, delta); at = TS (event->at); event->callbk = callbk; event->data = data; event->xl = THIS; LOCK (®->lock); { trav = reg->active.prev; while (trav != ®->active) { if (TS (trav->at) < at) break; trav = trav->prev; } event->prev = trav; event->next = event->prev->next; event->prev->next = event; event->next->prev = event; } UNLOCK (®->lock); return event; }
// 插入一个事件到定时器链表中 gf_timer_t * gf_timer_call_after (glusterfs_ctx_t *ctx, struct timespec delta, gf_timer_cbk_t callbk, void *data) { gf_timer_registry_t *reg = NULL; gf_timer_t *event = NULL; gf_timer_t *trav = NULL; uint64_t at = 0; if (ctx == NULL) { gf_log_callingfn ("timer", GF_LOG_ERROR, "invalid argument"); return NULL; } reg = gf_timer_registry_init (ctx); if (!reg) { gf_log_callingfn ("timer", GF_LOG_ERROR, "!reg"); return NULL; } event = GF_CALLOC (1, sizeof (*event), gf_common_mt_gf_timer_t); if (!event) { return NULL; } timespec_now (&event->at); timespec_adjust_delta (&event->at, delta); at = TS (event->at); event->callbk = callbk; event->data = data; event->xl = THIS; pthread_mutex_lock (®->lock); { //列表最后一个 trav = reg->active.prev; //找最后一个时间比我早的(链表是按时间排序的) while (trav != ®->active) { if (TS (trav->at) < at) break; trav = trav->prev; } event->prev = trav; event->next = event->prev->next; event->prev->next = event; event->next->prev = event; } pthread_mutex_unlock (®->lock); return event; }
int orc_transaction_once(orc_t *orc, uint8_t *request, uint8_t *response) { while (orc->fd <= 0) { usleep(1000); } // grab an id int id = alloc_transaction_id(orc); // fix up the packet. request[0] = PACKET_MARKER; request[PACKET_ID] = id; packet_fill_checksum(request); // fill out the transaction record transaction_t *t = &orc->transactions[id]; pthread_mutex_lock(&t->mutex); t->response = response; // send the packet pthread_mutex_lock(&orc->writeLock); write_fully(orc->fd, request, request[PACKET_DATALEN] + 4); pthread_mutex_unlock(&orc->writeLock); // compute our timeout time struct timespec ts; timespec_now(&ts); timespec_addms(&ts, 100); // wait! int res = pthread_cond_timedwait(&t->cond, &t->mutex, &ts); t->response = garbage; // cleanup pthread_mutex_unlock(&t->mutex); free_transaction_id(orc, id); if (res == ETIMEDOUT) { LOG_VERBOSE("Timeout packet, id = %02X", id); return -1; } return 0; }
static void test_invoice_post ( Fixture *fixture, gconstpointer pData ) { GncInvoice *invoice = gncInvoiceCreate(fixture->book); Timespec ts1 = timespec_now(), ts2 = ts1; g_assert(invoice); g_assert(!gncInvoiceGetIsCreditNote(invoice)); g_assert(gncInvoiceGetActive(invoice)); g_assert(gncInvoiceGetPostedAcc(invoice) == NULL); gncInvoiceSetCurrency(invoice, fixture->commodity); gncInvoiceSetOwner(invoice, &fixture->owner); g_test_message( "Will now post the invoice" ); g_assert(!gncInvoiceIsPosted(invoice)); gncInvoicePostToAccount(invoice, fixture->account, &ts1, &ts2, "memo", TRUE); g_assert(gncInvoiceIsPosted(invoice)); gncInvoiceUnpost(invoice, TRUE); g_assert(!gncInvoiceIsPosted(invoice)); }
void test_qofsession_aqb_kvp( void ) { /* load the accounts from the users datafile */ /* but first, check to make sure we've got a session going. */ QofBackendError io_err; char *file1 = get_filepath("file-book.gnucash"); char *file2 = get_filepath("file-book-hbcislot.gnucash"); if (1) { // A file with no content at all, but a valid XML file QofSession *new_session = qof_session_new (); char *newfile = g_strdup_printf("file://%s", file1); qof_session_begin (new_session, newfile, TRUE, FALSE, FALSE); io_err = qof_session_get_error (new_session); //printf("io_err1 = %d\n", io_err); g_assert(io_err != ERR_BACKEND_NO_HANDLER); // Do not have no handler g_assert(io_err != ERR_BACKEND_NO_SUCH_DB); // DB must exist g_assert(io_err != ERR_BACKEND_LOCKED); g_assert(io_err == 0); qof_session_load (new_session, NULL); io_err = qof_session_get_error (new_session); //printf("io_err2 = %d\n", io_err); g_assert(io_err == 0); g_free(newfile); g_free(file1); gnc_hook_run(HOOK_BOOK_CLOSED, new_session); //qof_session_destroy(new_session); // tries to delete the LCK file but it wasn't created in the first place } if (1) { // A file with no content except for the book_template_list kvp // slot QofSession *new_session = qof_session_new (); char *newfile = g_strdup_printf("file://%s", file2); qof_session_begin (new_session, newfile, TRUE, FALSE, FALSE); io_err = qof_session_get_error (new_session); //printf("io_err1 = %d\n", io_err); g_assert(io_err != ERR_BACKEND_NO_HANDLER); // Do not have no handler g_assert(io_err != ERR_BACKEND_NO_SUCH_DB); // DB must exist g_assert(io_err != ERR_BACKEND_LOCKED); g_assert(io_err == 0); qof_session_load (new_session, NULL); io_err = qof_session_get_error (new_session); //printf("io_err2 = %d\n", io_err); g_assert(io_err == 0); { GList *templ_list; GncABTransTempl *templ; QofBook *book = qof_session_get_book(new_session); const char* ORIGINAL_NAME = "Some Name"; const char* CHANGED_NAME = "Some Changed Name"; templ_list = gnc_ab_trans_templ_list_new_from_book (book); g_assert_cmpint(g_list_length(templ_list), ==, 1); templ = templ_list->data; //Raise the edit level so that we can check that it's marked dirty. qof_instance_increase_editlevel(QOF_INSTANCE(book)); g_assert_cmpstr(gnc_ab_trans_templ_get_name(templ), ==, ORIGINAL_NAME); // ok, name from file is here // Now we change the name into something else and verify it can be saved gnc_ab_trans_templ_set_name(templ, CHANGED_NAME); { g_assert(!qof_instance_get_dirty(QOF_INSTANCE(book))); // not yet dirty // Here we save the changed kvp gnc_ab_set_book_template_list(book, templ_list); g_assert(qof_instance_get_dirty(QOF_INSTANCE(book))); // yup, now dirty gnc_ab_trans_templ_list_free(templ_list); } { templ_list = gnc_ab_trans_templ_list_new_from_book (book); g_assert_cmpint(g_list_length(templ_list), ==, 1); templ = templ_list->data; g_assert_cmpstr(gnc_ab_trans_templ_get_name(templ), ==, CHANGED_NAME); // ok, the change has been saved! gnc_ab_trans_templ_list_free(templ_list); } } { // Check the kvp slots of a aqbanking-enabled account QofBook *book = qof_session_get_book(new_session); Account* account = gnc_book_get_root_account(book); GDate retrieved_date, original_date; gchar buff[MAX_DATE_LENGTH]; g_assert(account); // The interesting test case here: Can we read the correct date // from the xml file? if (1) { Timespec retrieved_ts = gnc_ab_get_account_trans_retrieval(account); g_test_message("retrieved_ts=%s\n", gnc_print_date(retrieved_ts)); //printf("Time=%s\n", gnc_print_date(retrieved_ts)); retrieved_date = timespec_to_gdate(retrieved_ts); g_date_set_dmy(&original_date, 29, 8, 2014); g_assert_cmpint(g_date_compare(&retrieved_date, &original_date), ==, 0); } // A lower-level test here: Can we write and read again the // trans_retrieval date? This wouldn't need this particular // Account, just a general Account object. if (0) { Timespec original_ts = timespec_now(), retrieved_ts; // Check whether the "ab-trans-retrieval" property of Account // is written and read again correctly. gnc_ab_set_account_trans_retrieval(account, original_ts); retrieved_ts = gnc_ab_get_account_trans_retrieval(account); // printf("original_ts=%s = %d retrieved_ts=%s = %d\n", // gnc_print_date(original_ts), original_ts.tv_sec, // gnc_print_date(retrieved_ts), retrieved_ts.tv_sec); original_date = timespec_to_gdate(original_ts); retrieved_date = timespec_to_gdate(retrieved_ts); qof_print_gdate (buff, sizeof (buff), &original_date); //printf("original_date=%s\n", buff); qof_print_gdate (buff, sizeof (buff), &retrieved_date); //printf("retrieved_date=%s\n", buff); // Is the retrieved date identical to the one written g_assert_cmpint(g_date_compare(&retrieved_date, &original_date), ==, 0); }
gf_timer_t * gf_timer_call_after (glusterfs_ctx_t *ctx, struct timespec delta, gf_timer_cbk_t callbk, void *data) { gf_timer_registry_t *reg = NULL; gf_timer_t *event = NULL; gf_timer_t *trav = NULL; uint64_t at = 0; if (ctx == NULL) { gf_msg_callingfn ("timer", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG, "invalid argument"); return NULL; } /* ctx and its fields are not accessed inside mutex!? * TODO: Even with this there is a possiblity of race * when cleanup_started is set after checking for it */ if (ctx->cleanup_started) { gf_msg_callingfn ("timer", GF_LOG_INFO, 0, LG_MSG_CTX_CLEANUP_STARTED, "ctx cleanup " "started"); return NULL; } reg = gf_timer_registry_init (ctx); if (!reg) { gf_msg_callingfn ("timer", GF_LOG_ERROR, 0, LG_MSG_TIMER_REGISTER_ERROR, "!reg"); return NULL; } event = GF_CALLOC (1, sizeof (*event), gf_common_mt_gf_timer_t); if (!event) { return NULL; } timespec_now (&event->at); timespec_adjust_delta (&event->at, delta); at = TS (event->at); event->callbk = callbk; event->data = data; event->xl = THIS; pthread_mutex_lock (®->lock); { trav = reg->active.prev; while (trav != ®->active) { if (TS (trav->at) < at) break; trav = trav->prev; } event->prev = trav; event->next = event->prev->next; event->prev->next = event; event->next->prev = event; } pthread_mutex_unlock (®->lock); return event; }
void * gf_timer_proc (void *ctx) { gf_timer_registry_t *reg = NULL; const struct timespec sleepts = {.tv_sec = 1, .tv_nsec = 0, }; gf_timer_t *event = NULL; xlator_t *old_THIS = NULL; if (ctx == NULL) { gf_msg_callingfn ("timer", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG, "invalid argument"); return NULL; } reg = gf_timer_registry_init (ctx); if (!reg) { gf_msg ("timer", GF_LOG_ERROR, 0, LG_MSG_INIT_TIMER_FAILED, "!reg"); return NULL; } while (!reg->fin) { uint64_t now; struct timespec now_ts; timespec_now (&now_ts); now = TS (now_ts); while (1) { uint64_t at; char need_cbk = 0; pthread_mutex_lock (®->lock); { event = reg->active.next; at = TS (event->at); if (event != ®->active && now >= at) { need_cbk = 1; event->next->prev = event->prev; event->prev->next = event->next; event->fired = _gf_true; } } pthread_mutex_unlock (®->lock); if (need_cbk) { old_THIS = NULL; if (event->xl) { old_THIS = THIS; THIS = event->xl; } event->callbk (event->data); GF_FREE (event); if (old_THIS) { THIS = old_THIS; } } else { break; } } nanosleep (&sleepts, NULL); } pthread_mutex_lock (®->lock); { /* Do not call gf_timer_call_cancel(), * it will lead to deadlock */ while (reg->active.next != ®->active) { event = reg->active.next; /* cannot call list_del as the event doesnt have * list_head*/ __delete_entry (event); } } pthread_mutex_unlock (®->lock); pthread_mutex_destroy (®->lock); GF_FREE (((glusterfs_ctx_t *)ctx)->timer); return NULL; } gf_timer_registry_t * gf_timer_registry_init (glusterfs_ctx_t *ctx) { if (ctx == NULL) { gf_msg_callingfn ("timer", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG, "invalid argument"); return NULL; } if (!ctx->timer) { gf_timer_registry_t *reg = NULL; reg = GF_CALLOC (1, sizeof (*reg), gf_common_mt_gf_timer_registry_t); if (!reg) goto out; pthread_mutex_init (®->lock, NULL); reg->active.next = ®->active; reg->active.prev = ®->active; ctx->timer = reg; gf_thread_create (®->th, NULL, gf_timer_proc, ctx); } out: return ctx->timer; } void gf_timer_registry_destroy (glusterfs_ctx_t *ctx) { pthread_t thr_id; gf_timer_registry_t *reg = NULL; if (ctx == NULL) return; reg = ctx->timer; thr_id = reg->th; reg->fin = 1; pthread_join (thr_id, NULL); }
static void * gf_timer_proc (void *data) { gf_timer_registry_t *reg = data; const struct timespec sleepts = {.tv_sec = 1, .tv_nsec = 0, }; gf_timer_t *event = NULL; xlator_t *old_THIS = NULL; while (!reg->fin) { uint64_t now; struct timespec now_ts; timespec_now (&now_ts); now = TS (now_ts); while (1) { uint64_t at; char need_cbk = 0; LOCK (®->lock); { event = reg->active.next; at = TS (event->at); if (event != ®->active && now >= at) { need_cbk = 1; event->next->prev = event->prev; event->prev->next = event->next; event->fired = _gf_true; } } UNLOCK (®->lock); if (need_cbk) { old_THIS = NULL; if (event->xl) { old_THIS = THIS; THIS = event->xl; } event->callbk (event->data); GF_FREE (event); if (old_THIS) { THIS = old_THIS; } } else { break; } } nanosleep (&sleepts, NULL); } LOCK (®->lock); { /* Do not call gf_timer_call_cancel(), * it will lead to deadlock */ while (reg->active.next != ®->active) { event = reg->active.next; /* cannot call list_del as the event doesnt have * list_head*/ __delete_entry (event); } } UNLOCK (®->lock); LOCK_DESTROY (®->lock); return NULL; } static gf_timer_registry_t * gf_timer_registry_init (glusterfs_ctx_t *ctx) { gf_timer_registry_t *reg = NULL; if (ctx == NULL) { gf_msg_callingfn ("timer", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG, "invalid argument"); return NULL; } if (ctx->cleanup_started) { gf_msg_callingfn ("timer", GF_LOG_INFO, 0, LG_MSG_CTX_CLEANUP_STARTED, "ctx cleanup started"); return NULL; } LOCK (&ctx->lock); { reg = ctx->timer; } UNLOCK (&ctx->lock); if (!reg) { reg = GF_CALLOC (1, sizeof (*reg), gf_common_mt_gf_timer_registry_t); if (!reg) return NULL; LOCK_INIT (®->lock); reg->active.next = ®->active; reg->active.prev = ®->active; LOCK (&ctx->lock); { ctx->timer = reg; } UNLOCK (&ctx->lock); gf_thread_create (®->th, NULL, gf_timer_proc, reg); } return reg; }
//计时器线程 void * gf_timer_proc (void *ctx) { gf_timer_registry_t *reg = NULL; const struct timespec sleepts = {.tv_sec = 1, .tv_nsec = 0, }; if (ctx == NULL) { gf_log_callingfn ("timer", GF_LOG_ERROR, "invalid argument"); return NULL; } reg = gf_timer_registry_init (ctx); if (!reg) { gf_log ("timer", GF_LOG_ERROR, "!reg"); return NULL; } while (!reg->fin) { uint64_t now; struct timespec now_ts; gf_timer_t *event = NULL; timespec_now (&now_ts); //现在的时间 now = TS (now_ts); while (1) { uint64_t at; char need_cbk = 0; pthread_mutex_lock (®->lock); { event = reg->active.next; at = TS (event->at); if (event != ®->active && now >= at) { need_cbk = 1; gf_timer_call_stale (reg, event); } } pthread_mutex_unlock (®->lock); if (event->xl) THIS = event->xl; if (need_cbk) event->callbk (event->data); else //跳出while(1) break; } // 睡1秒 nanosleep (&sleepts, NULL); } pthread_mutex_lock (®->lock); { while (reg->active.next != ®->active) { gf_timer_call_cancel (ctx, reg->active.next); } while (reg->stale.next != ®->stale) { gf_timer_call_cancel (ctx, reg->stale.next); } } pthread_mutex_unlock (®->lock); pthread_mutex_destroy (®->lock); GF_FREE (((glusterfs_ctx_t *)ctx)->timer); return NULL; } // 计时器注册初始化 gf_timer_registry_t * gf_timer_registry_init (glusterfs_ctx_t *ctx) { if (ctx == NULL) { gf_log_callingfn ("timer", GF_LOG_ERROR, "invalid argument"); return NULL; } // 还没初始化过的 if (!ctx->timer) { gf_timer_registry_t *reg = NULL; reg = GF_CALLOC (1, sizeof (*reg), gf_common_mt_gf_timer_registry_t); if (!reg) goto out; pthread_mutex_init (®->lock, NULL); reg->active.next = ®->active; reg->active.prev = ®->active; reg->stale.next = ®->stale; reg->stale.prev = ®->stale; ctx->timer = reg; gf_thread_create (®->th, NULL, gf_timer_proc, ctx); } out: return ctx->timer; }