trigger_manager.c - OpenGrok cross reference for /base/startup/init/services/param/trigger/trigger

Lines Matching refs:workSpace
114 static TriggerNode *AddJobTrigger_(const TriggerWorkSpace *workSpace,

117     PARAM_CHECK(workSpace != NULL, return NULL, "workSpace is null");

120     TriggerHeader *triggerHead = GetTriggerHeader(workSpace, extInfo->type);

127     PARAM_CHECK(ret == 0, FreeTrigger(workSpace, node);

138 static void DelJobTrigger_(const TriggerWorkSpace *workSpace, TriggerNode *trigger)

140     PARAM_CHECK(workSpace != NULL, return, "Param is null");

143     TriggerHeader *triggerHead = GetTriggerHeader(workSpace, trigger->type);

160     OH_HashMapRemove(workSpace->hashMap, jobNode->name);

166     TriggerExecuteQueue *executeQueue = (TriggerExecuteQueue *)&workSpace->executeQueue;

176 static TriggerNode *AddWatchTrigger_(const TriggerWorkSpace *workSpace,

179     PARAM_CHECK(workSpace != NULL, return NULL, "workSpace is null");

181     TriggerHeader *triggerHead = GetTriggerHeader(workSpace, extInfo->type);

195     PARAM_CHECK(ret == 0, FreeTrigger(workSpace, node);

203 static void DelWatchTrigger_(const TriggerWorkSpace *workSpace, TriggerNode *trigger)

205     PARAM_CHECK(workSpace != NULL && trigger != NULL, return, "Param is null");

206     TriggerHeader *triggerHead = GetTriggerHeader(workSpace, trigger->type);

269 JobNode *UpdateJobTrigger(const TriggerWorkSpace *workSpace,

272     PARAM_CHECK(workSpace != NULL && name != NULL, return NULL, "name is null");

274     TriggerHeader *triggerHead = GetTriggerHeader(workSpace, type);

276     JobNode *jobNode = GetTriggerByName(workSpace, name);

282         return (JobNode *)triggerHead->addTrigger(workSpace, condition, &extInfo);

285         PARAM_CHECK(ret == 0, FreeTrigger(workSpace, (TriggerNode*)jobNode);

291 JobNode *GetTriggerByName(const TriggerWorkSpace *workSpace, const char *triggerName)

293     PARAM_CHECK(workSpace != NULL && triggerName != NULL, return NULL, "Invalid param");

294     HashNode *node = OH_HashMapGet(workSpace->hashMap, triggerName);

302 void FreeTrigger(const TriggerWorkSpace *workSpace, TriggerNode *trigger)

304     PARAM_CHECK(workSpace != NULL && trigger != NULL, return, "Invalid param");

305     TriggerHeader *head = GetTriggerHeader(workSpace, trigger->type);

307         head->delTrigger(workSpace, trigger);

311 void ClearTrigger(const TriggerWorkSpace *workSpace, int8_t type)

313     PARAM_CHECK(workSpace != NULL, return, "head is null");

314     TriggerHeader *head = GetTriggerHeader(workSpace, type);

319         FreeTrigger(workSpace, trigger);

325 int ExecuteQueuePush(TriggerWorkSpace *workSpace, const TriggerNode *trigger)

327     PARAM_CHECK(workSpace != NULL, return -1, "Invalid workSpace");

328     uint32_t index = workSpace->executeQueue.endIndex++ % workSpace->executeQueue.queueCount;

329     workSpace->executeQueue.executeQueue[index] = (TriggerNode *)trigger;

333 TriggerNode *ExecuteQueuePop(TriggerWorkSpace *workSpace)

335     PARAM_CHECK(workSpace != NULL, return NULL, "Invalid workSpace");

338         if (workSpace->executeQueue.endIndex <= workSpace->executeQueue.startIndex) {

341         uint32_t currIndex = workSpace->executeQueue.startIndex % workSpace->executeQueue.queueCount;

342         trigger = workSpace->executeQueue.executeQueue[currIndex];

343         workSpace->executeQueue.executeQueue[currIndex] = NULL;

344         workSpace->executeQueue.startIndex++;

392 static int ExecTriggerMatch_(const TriggerWorkSpace *workSpace,

395     TriggerHeader *head = GetTriggerHeader(workSpace, type);

409 static int CheckBootMatch_(const TriggerWorkSpace *workSpace,

412     PARAM_CHECK(workSpace != NULL, return -1, "Invalid space");

414     return ExecTriggerMatch_(workSpace, type, calculator, content, contentSize);

417 static int CheckParamMatch_(const TriggerWorkSpace *workSpace,

420     PARAM_CHECK(workSpace != NULL, return -1, "Invalid space");

429     return ExecTriggerMatch_(workSpace, type, calculator, content, contentSize);

432 static int CheckUnknowMatch_(const TriggerWorkSpace *workSpace,

435     PARAM_CHECK(workSpace != NULL && content != NULL, return -1, "Failed arg for trigger");

443     return ExecTriggerMatch_(workSpace, type, calculator, content, contentSize);

446 int32_t CheckAndMarkTrigger_(const TriggerWorkSpace *workSpace, int type, const char *name)

448     PARAM_CHECK(workSpace != NULL && name != NULL, return 0, "Failed arg for trigger");

449     TriggerHeader *head = GetTriggerHeader(workSpace, type);

467 int CheckTrigger(TriggerWorkSpace *workSpace, int type,

470     PARAM_CHECK(workSpace != NULL && content != NULL && triggerCheckDone != NULL,

473     TriggerHeader *triggerHead = GetTriggerHeader(workSpace, type);

477         int ret = triggerHead->checkTriggerMatch(workSpace, type, &calculator, content, contentSize);

484 static void DumpJobTrigger_(const TriggerWorkSpace *workSpace, const TriggerNode *trigger)

502 static void DumpWatchTrigger_(const TriggerWorkSpace *workSpace, const TriggerNode *trigger)

511 static void DumpWaitTrigger_(const TriggerWorkSpace *workSpace, const TriggerNode *trigger)

522 static void DumpTrigger_(const TriggerWorkSpace *workSpace, int type)

524     PARAM_CHECK(workSpace != NULL, return, "Invalid workSpace ");

525     TriggerHeader *head = GetTriggerHeader(workSpace, type);

529         head->dumpTrigger(workSpace, trigger);

541     TriggerWorkSpace *workSpace = GetTriggerWorkSpace();

542     PARAM_CHECK(workSpace != NULL, return, "Invalid workSpace ");

544     DumpTrigger_(workSpace, TRIGGER_BOOT);

546     DumpTrigger_(workSpace, TRIGGER_PARAM);

548     DumpTrigger_(workSpace, TRIGGER_UNKNOW);

550     DumpTrigger_(workSpace, TRIGGER_PARAM_WATCH);

552     DumpTrigger_(workSpace, TRIGGER_PARAM_WAIT);

556         workSpace->executeQueue.queueCount, workSpace->executeQueue.startIndex, workSpace->executeQueue.endIndex);

557     for (uint32_t index = workSpace->executeQueue.startIndex; index < workSpace->executeQueue.endIndex; index++) {

558         TriggerNode *trigger = workSpace->executeQueue.executeQueue[index % workSpace->executeQueue.queueCount];

637 void InitTriggerHead(const TriggerWorkSpace *workSpace)

647     PARAM_CHECK(workSpace != NULL, return, "Invalid workSpace");

648     int ret = OH_HashMapCreate((HashMapHandle *)&workSpace->hashMap, &info);

651     TriggerHeader *head = (TriggerHeader *)&workSpace->triggerHead[TRIGGER_BOOT];

654     head = (TriggerHeader *)&workSpace->triggerHead[TRIGGER_PARAM];

660     head = (TriggerHeader *)&workSpace->triggerHead[TRIGGER_UNKNOW];

666     head = (TriggerHeader *)&workSpace->triggerHead[TRIGGER_PARAM_WAIT];

676     head = (TriggerHeader *)&workSpace->triggerHead[TRIGGER_PARAM_WATCH];

747 TriggerHeader *GetTriggerHeader(const TriggerWorkSpace *workSpace, int type)

749     if (workSpace == NULL || type >= TRIGGER_MAX) {

752     return (TriggerHeader *)&workSpace->triggerHead[type];