Author: grothoff
Date: 2006-06-25 00:28:25 -0700 (Sun, 25 Jun 2006)
New Revision: 3052
Modified:
GNUnet/src/include/gnunet_util_cron.h
GNUnet/src/util/cron/cron.c
GNUnet/src/util/threads/pthread.c
Log:
new util now compiles
Modified: GNUnet/src/include/gnunet_util_cron.h
===================================================================
--- GNUnet/src/include/gnunet_util_cron.h 2006-06-25 03:29:57 UTC (rev
3051)
+++ GNUnet/src/include/gnunet_util_cron.h 2006-06-25 07:28:25 UTC (rev
3052)
@@ -113,7 +113,7 @@
void * data);
/**
- * Remove all matching cron-jobs from the list. This method should
+ * Remove first matching cron-job from the list. This method should
* only be called while cron is suspended or stopped, or from a cron
* job that deletes another cron job. If cron is not suspended or
* stopped, it may be running the method that is to be deleted, which
@@ -123,7 +123,7 @@
* @param method which method is listed?
* @param repeat which repeat factor was chosen?
* @param data what was the data given to the method
- * @return the number of jobs removed
+ * @return the number of jobs removed (0 or 1)
*/
int cron_del_job(struct CronManager * mgr,
CronJob method,
Modified: GNUnet/src/util/cron/cron.c
===================================================================
--- GNUnet/src/util/cron/cron.c 2006-06-25 03:29:57 UTC (rev 3051)
+++ GNUnet/src/util/cron/cron.c 2006-06-25 07:28:25 UTC (rev 3052)
@@ -132,6 +132,8 @@
void * runningData_;
+ struct GE_Context * ectx;
+
/**
* The cron thread.
*/
@@ -165,34 +167,40 @@
*/
int cron_shutdown;
+ /**
+ * Are we in block?
+ */
+ int inBlock;
+
+ struct SEMAPHORE * sig;
+
} CronManager;
-/**
- * Initialize the cron service.
- */
-void initCron() {
+struct CronManager * cron_create(struct GE_Context * ectx) {
+ struct CronManager * cron;
unsigned int i;
-#ifndef MINGW
- static struct sigaction sig;
- static struct sigaction old;
-#endif
- deltaListSize_ = INIT_CRON_JOBS;
- deltaList_
- = MALLOC(sizeof(UTIL_cron_DeltaListEntry) * deltaListSize_);
- for (i=0;i<deltaListSize_;i++)
- deltaList_[i].next = i-1;
- firstFree_ = deltaListSize_-1;
- MUTEX_CREATE_RECURSIVE(&deltaListLock_);
- MUTEX_CREATE(&inBlockLock_);
- runningJob_ = NULL;
- firstUsed_ = -1;
- /* SA_NODEFER == SA_NOMASK but is available on linux */
-
- cron_signal_up = SEMAPHORE_NEW(0);
+ cron = MALLOC(sizeof(CronManager));
+ memset(cron, 0, sizeof(CronManager));
+ cron->deltaListSize_ = INIT_CRON_JOBS;
+ cron->deltaList_
+ = MALLOC(sizeof(UTIL_cron_DeltaListEntry) * cron->deltaListSize_);
+ for (i=0;i<cron->deltaListSize_;i++)
+ cron->deltaList_[i].next = i-1;
+ cron->firstFree_ = cron->deltaListSize_-1;
+ cron->deltaListLock_ = MUTEX_CREATE(YES);
+ cron->inBlockLock_ = MUTEX_CREATE(NO);
+ cron->runningJob_ = NULL;
+ cron->firstUsed_ = -1;
+ cron->cron_signal_up = SEMAPHORE_CREATE(0);
+ cron->ectx = ectx;
+ cron->cron_shutdown = NO;
+ cron->sig = NULL;
+ return cron;
}
+
static void noJob(void * unused) {
#if DEBUG_CRON
GE_LOG(NULL,
@@ -201,23 +209,24 @@
#endif
}
-/**
- * Stop the cron service.
- */
-void stopCron() {
+void cron_stop(struct CronManager * cron) {
void * unused;
#if DEBUG_CRON
- GE_LOG(NULL,
+ GE_LOG(cron->ectx,
GE_STATUS | GE_DEVELOPER | GE_BULK,
"Stopping cron\n");
#endif
- cron_shutdown = YES;
- addCronJob(&noJob, 0, 0, NULL);
- SEMAPHORE_DOWN(cron_signal);
- SEMAPHORE_FREE(cron_signal);
- cron_signal = NULL;
- PTHREAD_JOIN(&cron_handle, &unused);
+ cron->cron_shutdown = YES;
+ cron_add_job(cron,
+ &noJob,
+ 0,
+ 0,
+ NULL);
+ SEMAPHORE_DOWN(cron->cron_signal, YES);
+ SEMAPHORE_DESTROY(cron->cron_signal);
+ cron->cron_signal = NULL;
+ PTHREAD_JOIN(cron->cron_handle, &unused);
#if DEBUG_CRON
GE_LOG(NULL,
GE_STATUS | GE_DEVELOPER | GE_BULK,
@@ -225,81 +234,69 @@
#endif
}
-static int inBlock = 0;
-
/**
* CronJob to suspend the cron thread
* until it is resumed.
*/
-static void block(void * sem) {
- Semaphore * sig = sem;
+static void block(void * cls) {
+ struct CronManager * cron = cls;
int ok = SYSERR;
- if (sig != NULL)
- SEMAPHORE_UP(sig);
+ if (cron->sig != NULL)
+ SEMAPHORE_UP(cron->sig);
while (ok == SYSERR) {
- SEMAPHORE_DOWN(cron_signal_up);
- MUTEX_LOCK(&inBlockLock_);
- inBlock--;
- if (inBlock == 0)
+ SEMAPHORE_DOWN(cron->cron_signal_up, YES);
+ MUTEX_LOCK(cron->inBlockLock_);
+ cron->inBlock--;
+ if (cron->inBlock == 0)
ok = OK;
- MUTEX_UNLOCK(&inBlockLock_);
+ MUTEX_UNLOCK(cron->inBlockLock_);
}
}
-/**
- * Stop running cron-jobs for a short time. This method may only be
- * called by a thread that is not holding any locks (otherwise
- * there is the danger of a deadlock).
- */
-void suspendCron() {
- Semaphore * blockSignal;
-
- GE_ASSERT(NULL, cron_shutdown == NO);
- GE_ASSERT(NULL, NO == PTHREAD_SELF_TEST(&cron_handle));
- MUTEX_LOCK(&inBlockLock_);
- inBlock++;
- if (inBlock == 1) {
- blockSignal = SEMAPHORE_NEW(0);
- addCronJob(&block,
- 0,
- 0,
- blockSignal);
- SEMAPHORE_DOWN(blockSignal);
- SEMAPHORE_FREE(blockSignal);
+void cron_suspend(struct CronManager * cron,
+ int checkSelf) {
+ if ( (YES == checkSelf) &&
+ (NO != PTHREAD_TEST_SELF(cron->cron_handle)) )
+ return;
+ GE_ASSERT(NULL, cron->cron_shutdown == NO);
+ GE_ASSERT(NULL, NO == PTHREAD_TEST_SELF(cron->cron_handle));
+ MUTEX_LOCK(cron->inBlockLock_);
+ cron->inBlock++;
+ if (cron->inBlock == 1) {
+ cron->sig = SEMAPHORE_CREATE(0);
+ cron_add_job(cron,
+ &block,
+ 0,
+ 0,
+ cron);
+ SEMAPHORE_DOWN(cron->sig, YES);
+ SEMAPHORE_DESTROY(cron->sig);
+ cron->sig = NULL;
}
- MUTEX_UNLOCK(&inBlockLock_);
+ MUTEX_UNLOCK(cron->inBlockLock_);
}
-int isCronRunning() {
- if ( (NO == cron_shutdown) || (inBlock > 0) )
+int isCronRunning(struct CronManager * cron) {
+ if ( (NO == cron->cron_shutdown) || (cron->inBlock > 0) )
return YES;
else
return NO;
}
-/**
- * Resume running cron-jobs.
- */
-void resumeCron() {
- GE_ASSERT(NULL, inBlock > 0);
- SEMAPHORE_UP(cron_signal_up);
+void resumeCron(struct CronManager * cron,
+ int checkSelf) {
+ if ( (YES == checkSelf) &&
+ (NO != PTHREAD_TEST_SELF(cron->cron_handle)) )
+ return;
+ GE_ASSERT(NULL, cron->inBlock > 0);
+ SEMAPHORE_UP(cron->cron_signal_up);
}
-void suspendIfNotCron() {
- if (NO == PTHREAD_SELF_TEST(&cron_handle))
- suspendCron();
-}
-
-void resumeIfNotCron() {
- if (NO == PTHREAD_SELF_TEST(&cron_handle))
- resumeCron();
-}
-
-static void abortSleep() {
- if (cron_signal == NULL)
+static void abortSleep(struct CronManager * cron) {
+ if (cron->cron_signal == NULL)
return; /* cron_handle not valid */
- PTHREAD_KILL(&cron_handle, SIGALRM);
+ PTHREAD_STOP_SLEEP(cron->cron_handle);
}
@@ -307,17 +304,17 @@
/**
* Print the cron-tab.
*/
-void printCronTab() {
+void printCronTab(struct CronManager * cron) {
int jobId;
UTIL_cron_DeltaListEntry * tab;
cron_t now;
- cronTime(&now);
- MUTEX_LOCK(&deltaListLock_);
+ now = get_time();
+ MUTEX_LOCK(cron->deltaListLock_);
- jobId = firstUsed_;
+ jobId = cron->firstUsed_;
while (jobId != -1) {
- tab = &deltaList_[jobId];
+ tab = &cron->deltaList_[jobId];
GE_LOG(NULL,
GE_STATUS | GE_DEVELOPER | GE_BULK,
"%3u: delta %8lld CU --- method %p --- repeat %8u CU\n",
@@ -327,26 +324,14 @@
tab->deltaRepeat);
jobId = tab->next;
}
- MUTEX_UNLOCK(&deltaListLock_);
+ MUTEX_UNLOCK(cron->deltaListLock_);
}
#endif
-
-/**
- * If the specified cron-job exists in th delta-list, move it to the
- * head of the list. If it is running, do nothing. If it is does not
- * exist and is not running, add it to the list to run it next.
- *
- * @param method which method should we run
- * @param deltaRepeat if this is a periodic, the time between
- * the runs, otherwise 0.
- * @param data extra argument to calls to method, freed if
- * non-null and cron is shutdown before the job is
- * run and/or delCronJob is called
- */
-void advanceCronJob(CronJob method,
- unsigned int deltaRepeat,
- void * data) {
+void cron_advance_job(struct CronManager * cron,
+ CronJob method,
+ unsigned int deltaRepeat,
+ void * data) {
UTIL_cron_DeltaListEntry * job;
UTIL_cron_DeltaListEntry * last;
int jobId;
@@ -358,80 +343,74 @@
method,
data);
#endif
- MUTEX_LOCK(&deltaListLock_);
- jobId = firstUsed_;
+ MUTEX_LOCK(cron->deltaListLock_);
+ jobId = cron->firstUsed_;
if (jobId == -1) {
/* not in queue; add if not running */
- if ( (method != runningJob_) ||
- (data != runningData_) ||
- (deltaRepeat != runningRepeat_) ) {
- GE_LOG(NULL,
+ if ( (method != cron->runningJob_) ||
+ (data != cron->runningData_) ||
+ (deltaRepeat != cron->runningRepeat_) ) {
+ GE_LOG(cron->ectx,
GE_ERROR | GE_USER | GE_DEVELOPER | GE_BULK,
_("`%s' called with cron job not in queue, adding. This may not
be what you want.\n"),
__FUNCTION__);
- addCronJob(method,
- 0,
- deltaRepeat,
- data);
+ cron_add_job(cron,
+ method,
+ 0,
+ deltaRepeat,
+ data);
}
- MUTEX_UNLOCK(&deltaListLock_);
+ MUTEX_UNLOCK(cron->deltaListLock_);
return;
}
last = NULL;
- job = &deltaList_[jobId];
+ job = &cron->deltaList_[jobId];
while ( (job->method != method) ||
(job->data != data) ||
(job->deltaRepeat != deltaRepeat) ) {
last = job;
if (job->next == -1) {
/* not in queue; add if not running */
- if ( (method != runningJob_) ||
- (data != runningData_) ||
- (deltaRepeat != runningRepeat_) ) {
- addCronJob(method,
- 0,
- deltaRepeat,
- data);
+ if ( (method != cron->runningJob_) ||
+ (data != cron->runningData_) ||
+ (deltaRepeat != cron->runningRepeat_) ) {
+ cron_add_job(cron,
+ method,
+ 0,
+ deltaRepeat,
+ data);
}
- MUTEX_UNLOCK(&deltaListLock_);
+ MUTEX_UNLOCK(cron->deltaListLock_);
return;
}
jobId = job->next;
- job = &deltaList_[jobId];
+ job = &cron->deltaList_[jobId];
}
/* ok, found it; remove, re-add with time 0 */
- delCronJob(method,
- deltaRepeat,
- data);
- addCronJob(method,
- 0,
- deltaRepeat,
- data);
- MUTEX_UNLOCK(&deltaListLock_);
+ cron_del_job(cron,
+ method,
+ deltaRepeat,
+ data);
+ cron_add_job(cron,
+ method,
+ 0,
+ deltaRepeat,
+ data);
+ MUTEX_UNLOCK(cron->deltaListLock_);
}
-/**
- * Add a cron-job to the delta list.
- *
- * @param method which method should we run
- * @param delta how many milliseconds until we run the method
- * @param deltaRepeat if this is a periodic, the time between
- * the runs, otherwise 0.
- * @param data extra argument to calls to method, freed if
- * non-null and cron is shutdown before the job is
- * run and/or delCronJob is called
- */
-void addCronJob(CronJob method,
- unsigned int delta,
- unsigned int deltaRepeat,
- void * data) {
+void cron_add_job(struct CronManager * cron,
+ CronJob method,
+ unsigned int delta,
+ unsigned int deltaRepeat,
+ void * data) {
UTIL_cron_DeltaListEntry * entry;
UTIL_cron_DeltaListEntry * pos;
int last;
int current;
#if DEBUG_CRON
- GE_LOG(NULL,
+ GE_LOG(cron->ectx,
GE_STATUS | GE_DEVELOPER | GE_BULK,
"Adding job %p-%p to fire in %d CU\n",
method,
@@ -439,50 +418,50 @@
delta);
#endif
- MUTEX_LOCK(&deltaListLock_);
- if (firstFree_ == -1) { /* need to grow */
+ MUTEX_LOCK(cron->deltaListLock_);
+ if (cron->firstFree_ == -1) { /* need to grow */
unsigned int i;
- GROW(deltaList_,
- deltaListSize_,
- deltaListSize_ * 2);
- for (i=deltaListSize_/2;i<deltaListSize_;i++)
- deltaList_[i].next = i-1;
- deltaList_[deltaListSize_/2].next = -1;
- firstFree_ = deltaListSize_-1;
+ GROW(cron->deltaList_,
+ cron->deltaListSize_,
+ cron->deltaListSize_ * 2);
+ for (i=cron->deltaListSize_/2;i<cron->deltaListSize_;i++)
+ cron->deltaList_[i].next = i-1;
+ cron->deltaList_[cron->deltaListSize_/2].next = -1;
+ cron->firstFree_ = cron->deltaListSize_-1;
}
- entry = &deltaList_[firstFree_];
+ entry = &cron->deltaList_[cron->firstFree_];
entry->method = method;
entry->data = data;
entry->deltaRepeat = deltaRepeat;
- entry->delta = cronTime(NULL) + delta;
- if (firstUsed_ == -1) {
- firstUsed_
- = firstFree_;
- firstFree_
+ entry->delta = get_time() + delta;
+ if (cron->firstUsed_ == -1) {
+ cron->firstUsed_
+ = cron->firstFree_;
+ cron->firstFree_
= entry->next;
entry->next = -1; /* end of list */
- MUTEX_UNLOCK(&deltaListLock_);
+ MUTEX_UNLOCK(cron->deltaListLock_);
/* interrupt sleeping cron-thread! */
- abortSleep();
+ abortSleep(cron);
return;
}
/* no, there are jobs waiting */
last = -1;
- current = firstUsed_;
- pos = &deltaList_[current];
+ current = cron->firstUsed_;
+ pos = &cron->deltaList_[current];
while (entry->delta > pos->delta) {
if (pos->next != -1) {
last = current;
current = pos->next;
- pos = &deltaList_[current];
+ pos = &cron->deltaList_[current];
} else { /* append */
- pos->next = firstFree_;
- firstFree_
+ pos->next = cron->firstFree_;
+ cron->firstFree_
= entry->next;
entry->next = -1;
- MUTEX_UNLOCK(&deltaListLock_);
+ MUTEX_UNLOCK(cron->deltaListLock_);
#if HAVE_PRINT_CRON_TAB
printCronTab();
#endif
@@ -491,18 +470,18 @@
}
/* insert before pos */
if (last == -1) {
- firstUsed_ = firstFree_;
- abortSleep();
+ cron->firstUsed_ = cron->firstFree_;
+ abortSleep(cron);
} else {
- deltaList_[last].next = firstFree_;
+ cron->deltaList_[last].next = cron->firstFree_;
#if HAVE_PRINT_CRON_TAB
printCronTab();
#endif
}
- firstFree_
+ cron->firstFree_
= entry->next;
entry->next = current;
- MUTEX_UNLOCK(&deltaListLock_);
+ MUTEX_UNLOCK(cron->deltaListLock_);
}
/**
@@ -513,55 +492,59 @@
* where the job is running (the job to run may add other
* jobs!)
*/
-static void runJob() {
+static void runJob(struct CronManager * cron) {
UTIL_cron_DeltaListEntry * job;
int jobId;
CronJob method;
void * data;
unsigned int repeat;
- jobId = firstUsed_;
+ jobId = cron->firstUsed_;
if (jobId == -1)
return; /* no job to be done */
- job = &deltaList_[jobId];
+ job = &cron->deltaList_[jobId];
method = job->method;
- runningJob_ = method;
+ cron->runningJob_ = method;
data = job->data;
- runningData_ = data;
+ cron->runningData_ = data;
repeat = job->deltaRepeat;
- runningRepeat_ = repeat;
+ cron->runningRepeat_ = repeat;
/* remove from queue */
- firstUsed_
+ cron->firstUsed_
= job->next;
job->next
- = firstFree_;
- firstFree_ = jobId;
- MUTEX_UNLOCK(&deltaListLock_);
+ = cron->firstFree_;
+ cron->firstFree_ = jobId;
+ MUTEX_UNLOCK(cron->deltaListLock_);
/* re-insert */
if (repeat > 0) {
#if DEBUG_CRON
- GE_LOG(NULL,
+ GE_LOG(cron->ectx,
GE_STATUS | GE_DEVELOPER | GE_BULK,
"adding periodic job %p-%p to run again in %u\n",
method,
data,
repeat);
#endif
- addCronJob(method, repeat, repeat, data);
+ cron_add_job(cron,
+ method,
+ repeat,
+ repeat,
+ data);
}
/* run */
#if DEBUG_CRON
- GE_LOG(NULL,
+ GE_LOG(cron->ectx,
GE_STATUS | GE_DEVELOPER | GE_BULK,
"running job %p-%p\n",
method,
data);
#endif
method(data);
- MUTEX_LOCK(&deltaListLock_);
- runningJob_ = NULL;
+ MUTEX_LOCK(cron->deltaListLock_);
+ cron->runningJob_ = NULL;
#if DEBUG_CRON
- GE_LOG(NULL,
+ GE_LOG(cron->ectx,
GE_STATUS | GE_DEVELOPER | GE_BULK,
"job %p-%p done\n",
method,
@@ -572,40 +555,42 @@
/**
* The main-method of cron.
*/
-static void * cron(void * unused) {
+static void * cron_main_method(void * ctx) {
+ struct CronManager * cron = ctx;
cron_t now;
cron_t next;
- while (cron_shutdown == NO) {
+ while (cron->cron_shutdown == NO) {
#if HAVE_PRINT_CRON_TAB
- printCronTab();
+ printCronTab(cron);
#endif
- cronTime(&now);
+ now = get_time();
next = now + 0xFFFFFFFF;
- MUTEX_LOCK(&deltaListLock_);
- while (firstUsed_ != -1) {
- cronTime(&now);
- next = deltaList_[firstUsed_].delta;
+ MUTEX_LOCK(cron->deltaListLock_);
+ while (cron->firstUsed_ != -1) {
+ now = get_time();
+ next = cron->deltaList_[cron->firstUsed_].delta;
if (next <= now) {
#if DEBUG_CRON
- LOG(LOG_CRON,
- "running cron job, table is\n");
- printCronTab();
+ GE_LOG(cron->ectx,
+ GE_STATUS | GE_DEVELOPER | GE_BULK,
+ "running cron job, table is\n");
+ printCronTab(cron);
#endif
- runJob();
+ runJob(cron);
#if DEBUG_CRON
- GE_LOG(NULL,
+ GE_LOG(cron->ectx,
GE_STATUS | GE_DEVELOPER | GE_BULK,
"job run, new table is\n");
- printCronTab();
+ printCronTab(cron);
#endif
} else
break;
}
- MUTEX_UNLOCK(&deltaListLock_);
+ MUTEX_UNLOCK(cron->deltaListLock_);
next = next - now; /* how long to sleep */
#if DEBUG_CRON
- GE_LOG(NULL,
+ GE_LOG(cron->ectx,
GE_STATUS | GE_DEVELOPER | GE_BULK,
"Sleeping at %llu for %llu CU (%llu s, %llu CU)\n",
now,
@@ -615,22 +600,22 @@
#endif
if (next > MAXSLEEP)
next = MAXSLEEP;
- if (cron_shutdown == NO)
- gnunet_util_sleep(next);
+ if (cron->cron_shutdown == NO)
+ PTHREAD_SLEEP(next);
#if DEBUG_CRON
- GE_LOG(NULL,
+ GE_LOG(cron->ectx,
GE_STATUS | GE_DEVELOPER | GE_BULK,
"woke up at %llu - %lld CS late\n",
- cronTime(NULL),
- cronTime(NULL)-(now+next));
+ get_time(),
+ get_time() - (now+next));
#endif
}
- SEMAPHORE_UP(cron_signal);
+ SEMAPHORE_UP(cron->cron_signal);
#if DEBUG_CRON
- GE_LOG(NULL,
+ GE_LOG(cron->ectx,
GE_STATUS | GE_DEVELOPER | GE_BULK,
"Cron thread exits.\n");
- printCronTab();
+ printCronTab(cron);
#endif
return NULL;
}
@@ -639,99 +624,88 @@
/**
* Make sure to call stopCron before calling this method!
*/
-void doneCron() {
+void cron_destroy(struct CronManager * cron) {
int i;
- i = firstUsed_;
+ GE_ASSERT(cron->ectx,
+ cron->cron_signal == NULL);
+ i = cron->firstUsed_;
while (i != -1) {
- FREENONNULL(deltaList_[i].data);
- i = deltaList_[i].next;
+ FREENONNULL(cron->deltaList_[i].data);
+ i = cron->deltaList_[i].next;
}
- MUTEX_DESTROY(&deltaListLock_);
- MUTEX_DESTROY(&inBlockLock_);
- FREE(deltaList_);
- SEMAPHORE_FREE(cron_signal_up);
- deltaList_ = NULL;
+ MUTEX_DESTROY(cron->deltaListLock_);
+ MUTEX_DESTROY(cron->inBlockLock_);
+ FREE(cron->deltaList_);
+ SEMAPHORE_DESTROY(cron->cron_signal_up);
+ FREE(cron);
}
/**
* Start the cron jobs.
*/
-void startCron() {
- GE_ASSERT(NULL, cron_signal == NULL);
- cron_shutdown = NO;
- cron_signal = SEMAPHORE_NEW(0);
+void cron_start(struct CronManager * cron) {
+ GE_ASSERT(cron->ectx,
+ cron->cron_signal == NULL);
+ cron->cron_shutdown = NO;
+ cron->cron_signal = SEMAPHORE_CREATE(0);
/* large stack, we don't know for sure
what the cron jobs may be doing */
- if (0 != PTHREAD_CREATE(&cron_handle,
- &cron,
- NULL,
- 256 * 1024))
- GE_DIE_STRERROR(NULL,
+ cron->cron_handle = PTHREAD_CREATE(&cron_main_method,
+ cron,
+ 256 * 1024);
+ if (cron->cron_handle == 0)
+ GE_DIE_STRERROR(cron->ectx,
GE_FATAL | GE_ADMIN | GE_USER | GE_BULK,
"pthread_create");
}
-
-/**
- * Remove all matching cron-jobs from the list. This method should
- * only be called while cron is suspended or stopped, or from a cron
- * job that deletes another cron job. If cron is not suspended or
- * stopped, it may be running the method that is to be deleted, which
- * could be bad (in this case, the deletion will not affect the
- * running job and may return before the running job has terminated).
- *
- * @param method which method is listed?
- * @param repeat which repeat factor was chosen?
- * @param data what was the data given to the method
- * @return the number of jobs removed
- */
-int delCronJob(CronJob method,
- unsigned int repeat,
- void * data) {
+int cron_del_job(struct CronManager * cron,
+ CronJob method,
+ unsigned int repeat,
+ void * data) {
UTIL_cron_DeltaListEntry * job;
UTIL_cron_DeltaListEntry * last;
int jobId;
#if DEBUG_CRON
- GE_LOG(NULL,
+ GE_LOG(cron->ectx,
GE_STATUS | GE_DEVELOPER | GE_BULK,
"deleting job %p-%p\n",
method,
data);
#endif
- MUTEX_LOCK(&deltaListLock_);
- jobId = firstUsed_;
+ MUTEX_LOCK(cron->deltaListLock_);
+ jobId = cron->firstUsed_;
if (jobId == -1) {
- MUTEX_UNLOCK(&deltaListLock_);
+ MUTEX_UNLOCK(cron->deltaListLock_);
return 0;
}
last = NULL;
- job = &deltaList_[jobId];
+ job = &cron->deltaList_[jobId];
while ( (job->method != method) ||
(job->data != data) ||
(job->deltaRepeat != repeat) ) {
last = job;
if (job->next == -1) {
- MUTEX_UNLOCK(&deltaListLock_);
+ MUTEX_UNLOCK(cron->deltaListLock_);
return 0;
}
jobId = job->next;
- job = &deltaList_[jobId];
+ job = &cron->deltaList_[jobId];
}
if (last != NULL)
last->next = job->next;
else
- firstUsed_ = job->next;
+ cron->firstUsed_ = job->next;
job->next
- = firstFree_;
- firstFree_ = jobId;
+ = cron->firstFree_;
+ cron->firstFree_ = jobId;
job->method = NULL;
job->data = NULL;
job->deltaRepeat = 0;
- MUTEX_UNLOCK(&deltaListLock_);
- /* ok, there may be more matches, go again! */
- return 1 + delCronJob(method, repeat, data);
+ MUTEX_UNLOCK(cron->deltaListLock_);
+ return 1;
}
Modified: GNUnet/src/util/threads/pthread.c
===================================================================
--- GNUnet/src/util/threads/pthread.c 2006-06-25 03:29:57 UTC (rev 3051)
+++ GNUnet/src/util/threads/pthread.c 2006-06-25 07:28:25 UTC (rev 3052)
@@ -112,7 +112,6 @@
&stack_size_custom_attr,
main,
arg);
-
if (ret != 0) {
FREE(handle);
return NULL;
_______________________________________________
GNUnet-SVN mailing list
GNUnet-SVN@gnu.org
http://lists.gnu.org/mailman/listinfo/gnunet-svn
