-
Notifications
You must be signed in to change notification settings - Fork 202
/
cfe_es_apps.h
303 lines (259 loc) · 10.2 KB
/
cfe_es_apps.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
/*
** GSC-18128-1, "Core Flight Executive Version 6.7"
**
** Copyright (c) 2006-2019 United States Government as represented by
** the Administrator of the National Aeronautics and Space Administration.
** All Rights Reserved.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/
/**
* @file
*
* Purpose:
* This file contains the Internal interface for the cFE Application control functions of ES.
* These functions and data structures manage the Applications and Child tasks in the cFE.
*
* References:
* Flight Software Branch C Coding Standard Version 1.0a
* cFE Flight Software Application Developers Guide
*
*/
#ifndef CFE_ES_APPS_H
#define CFE_ES_APPS_H
/*
** Include Files
*/
#include "common_types.h"
#include "cfe_es_api_typedefs.h"
#include "cfe_fs_api_typedefs.h"
/*
** Macro Definitions
*/
#define CFE_ES_STARTSCRIPT_MAX_TOKENS_PER_LINE 8
/*
** Type Definitions
*/
/*
** CFE_ES_AppState_t is a structure of information for External cFE Apps.
** This information is used to control/alter the state of External Apps.
** The fields in this structure are not needed or used for the cFE Core Apps.
*/
typedef struct
{
uint32 AppControlRequest; /* What the App should be doing next */
int32 AppTimerMsec; /* Countdown timer for killing an app, in milliseconds */
} CFE_ES_ControlReq_t;
/*
** CFE_ES_ModuleLoadParams_t contains the information used when a module
** (library or app) load request initially processed in the system. It captures
** the fundamental information - the name, the file to load, its entry point.
** It contains information directly provided by the user, not runtime status or
** other derived information.
**
** This information should remain fairly constant after initial allocation, even
** if the application is restarted for some reason. The major exception is the
** ReloadApp command, which can change the FileName.
*/
typedef struct
{
char InitSymbolName[OS_MAX_API_NAME];
char FileName[OS_MAX_PATH_LEN];
} CFE_ES_ModuleLoadParams_t;
/*
** CFE_ES_ModuleLoadStatus_t is a structure of information used when a module
** (library or app) is actually loaded in the system. It captures the
** runtime information - the module ID and starting address.
**
** This information may change if the module is reloaded.
*/
typedef struct
{
osal_id_t ModuleId;
cpuaddr InitSymbolAddress;
} CFE_ES_ModuleLoadStatus_t;
/*
** CFE_ES_TaskStartParams_t contains basic details about a CFE task
**
** This information needs to be specified when starting a task and is
** stored as part of the task record for future reference.
*/
typedef struct
{
size_t StackSize;
CFE_ES_TaskPriority_Atom_t Priority;
} CFE_ES_TaskStartParams_t;
/*
** CFE_ES_AppStartParams_t contains basic details about a CFE app.
**
** This is an extension of the CFE_ES_ModuleLoadParams_t which adds information
** about the main task and exception action. It is only used for apps, as libraries
** do not have a task associated.
*/
typedef struct
{
/*
* Basic (static) information about the module
*/
CFE_ES_ModuleLoadParams_t BasicInfo;
CFE_ES_TaskStartParams_t MainTaskInfo;
CFE_ES_ExceptionAction_Enum_t ExceptionAction;
} CFE_ES_AppStartParams_t;
/*
** CFE_ES_AppRecord_t is an internal structure used to keep track of
** CFE Applications that are active in the system.
*/
typedef struct
{
CFE_ES_AppId_t AppId; /* The actual AppID of this entry, or undefined */
char AppName[OS_MAX_API_NAME]; /* The name of the app */
CFE_ES_AppState_Enum_t AppState; /* Is the app running, or stopped, or waiting? */
CFE_ES_AppType_Enum_t Type; /* The type of App: CORE or EXTERNAL */
CFE_ES_AppStartParams_t StartParams; /* The start parameters for an App */
CFE_ES_ModuleLoadStatus_t LoadStatus; /* Runtime module information */
CFE_ES_ControlReq_t ControlReq; /* The Control Request Record for External cFE Apps */
CFE_ES_TaskId_t MainTaskId; /* The Application's Main Task ID */
} CFE_ES_AppRecord_t;
/*
** CFE_ES_TaskRecord_t is an internal structure used to keep track of
** CFE Tasks that are active in the system.
*/
typedef struct
{
CFE_ES_TaskId_t TaskId; /* The actual TaskID of this entry, or undefined */
char TaskName[OS_MAX_API_NAME]; /* Task Name */
CFE_ES_AppId_t AppId; /* The parent Application's App ID */
CFE_ES_TaskStartParams_t StartParams; /* The start parameters for the task */
CFE_ES_TaskEntryFuncPtr_t EntryFunc; /* Task entry function */
uint32 ExecutionCounter; /* The execution counter for the task */
} CFE_ES_TaskRecord_t;
/*
** CFE_ES_LibRecord_t is an internal structure used to keep track of
** CFE Shared Libraries that are loaded in the system.
*/
typedef struct
{
CFE_ES_LibId_t LibId; /* The actual LibID of this entry, or undefined */
char LibName[OS_MAX_API_NAME]; /* Library Name */
CFE_ES_ModuleLoadParams_t LoadParams; /* Basic (static) information about the module */
CFE_ES_ModuleLoadStatus_t LoadStatus; /* Runtime information about the module */
} CFE_ES_LibRecord_t;
/*
** CFE_ES_AppTableScanState_t is an internal structure used to keep state of
** the background app table scan/cleanup process
*/
typedef struct
{
uint32 PendingAppStateChanges;
uint32 BackgroundScanTimer;
uint8 LastScanCommandCount;
} CFE_ES_AppTableScanState_t;
/*****************************************************************************/
/*
** Function prototypes
*/
/*
** Internal function start applications based on the startup script
*/
void CFE_ES_StartApplications(uint32 ResetType, const char *StartFilePath);
/*
** Internal function to parse/execute a line of the cFE application startup 'script'
*/
int32 CFE_ES_ParseFileEntry(const char **TokenList, uint32 NumTokens);
/*
** Internal function to load a module (app or library)
** This only loads the code and looks up relevent runtime information.
** It does not start any tasks.
*/
int32 CFE_ES_LoadModule(CFE_ResourceId_t ParentResourceId, const char *ModuleName,
const CFE_ES_ModuleLoadParams_t *LoadParams, CFE_ES_ModuleLoadStatus_t *LoadStatus);
/*
** Internal function to determine the entry point of an app.
** If the app isn't fully registered in the global app table,
** then this delays until the app is completely configured and the entry point is
** confirmed to be valid.
*/
int32 CFE_ES_GetTaskFunction(CFE_ES_TaskEntryFuncPtr_t *FuncPtr);
/*
** Intermediate entry point of all tasks. Determines the actual
** entry point from the global data structures.
*/
void CFE_ES_TaskEntryPoint(void);
/*
** Internal function to start a task associated with an app.
*/
int32 CFE_ES_StartAppTask(CFE_ES_TaskId_t *TaskIdPtr, const char *TaskName, CFE_ES_TaskEntryFuncPtr_t EntryFunc,
const CFE_ES_TaskStartParams_t *Params, CFE_ES_AppId_t ParentAppId);
/*
** Internal function to create/start a new cFE app
** based on the parameters passed in
*/
int32 CFE_ES_AppCreate(CFE_ES_AppId_t *ApplicationIdPtr, const char *AppName, const CFE_ES_AppStartParams_t *Params);
/*
** Internal function to load a a new cFE shared Library
*/
int32 CFE_ES_LoadLibrary(CFE_ES_LibId_t *LibraryIdPtr, const char *LibName, const CFE_ES_ModuleLoadParams_t *Params);
/*
** Scan the Application Table for actions to take
*/
bool CFE_ES_RunAppTableScan(uint32 ElapsedTime, void *Arg);
/*
** Scan for new exceptions stored in the PSP
*/
bool CFE_ES_RunExceptionScan(uint32 ElapsedTime, void *Arg);
/*
* Background file write data getter for ER log entry
*/
bool CFE_ES_BackgroundERLogFileDataGetter(void *Meta, uint32 RecordNum, void **Buffer, size_t *BufSize);
/*
* Background file write event handler for ER log entry
*/
void CFE_ES_BackgroundERLogFileEventHandler(void *Meta, CFE_FS_FileWriteEvent_t Event, int32 Status, uint32 RecordNum,
size_t BlockSize, size_t Position);
/*
** Perform the requested control action for an application
*/
void CFE_ES_ProcessControlRequest(CFE_ES_AppId_t AppId);
/*
** Clean up all app resources and delete it
*/
int32 CFE_ES_CleanUpApp(CFE_ES_AppId_t AppId);
/*
** Clean up all Task resources and detete the task
*/
int32 CFE_ES_CleanupTaskResources(CFE_ES_TaskId_t TaskId);
/*
**---------------------------------------------------------------------------------------
** Name: CFE_ES_CopyModuleBasicInfo
**
** Purpose: Populate the cFE_ES_AppInfo structure from the CFE_ES_ModuleLoadParams_t data
**---------------------------------------------------------------------------------------
*/
void CFE_ES_CopyModuleBasicInfo(const CFE_ES_ModuleLoadParams_t *ParamsPtr, CFE_ES_AppInfo_t *AppInfoPtr);
/*
**---------------------------------------------------------------------------------------
** Name: CFE_ES_CopyModuleStatusInfo
**
** Purpose: Populate the cFE_ES_AppInfo structure from the CFE_ES_ModuleLoadStatus_t data
**---------------------------------------------------------------------------------------
*/
void CFE_ES_CopyModuleStatusInfo(const CFE_ES_ModuleLoadStatus_t *StatusPtr, CFE_ES_AppInfo_t *AppInfoPtr);
/*
**---------------------------------------------------------------------------------------
** Name: CFE_ES_CopyModuleAddressInfo
**
** Purpose: Populate the cFE_ES_AppInfo structure with address information from OSAL.
**---------------------------------------------------------------------------------------
*/
void CFE_ES_CopyModuleAddressInfo(osal_id_t ModuleId, CFE_ES_AppInfo_t *AppInfoPtr);
#endif /* CFE_ES_APPS_H */