common_modules/module_manager/src/txm_module_manager_absolute_load.c (threadx)

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

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

/**************************************************************************/ /* */ /* Copyright (c) Microsoft Corporation. All rights reserved. */ /* */ /* This software is licensed under the Microsoft Software License */ /* Terms for Microsoft Azure RTOS. Full text of the license can be */ /* found in the LICENSE file at https://aka.ms/AzureRTOS_EULA */ /* and in the root directory of this software. */ /* */ /**************************************************************************/ /**************************************************************************/ /**************************************************************************/ /** */ /** ThreadX Component */ /** */ /** Module Manager */ /** */ /**************************************************************************/ /**************************************************************************/ #define TX_SOURCE_CODE #include "tx_api.h" #include "tx_initialize.h" #include "tx_mutex.h" #include "tx_thread.h" #include "tx_byte_pool.h" #include "txm_module.h" #include "txm_module_manager_util.h" /**************************************************************************/ /* */ /* FUNCTION RELEASE */ /* */ /* _txm_module_manager_absolute_load PORTABLE C */ /* 6.1.3 */ /* AUTHOR */ /* */ /* Andres Mlinar, Microsoft Corporation */ /* */ /* DESCRIPTION */ /* */ /* This function ensures the code-related and data-related parts of */ /* the module preamble are valid and prepares the module for */ /* execution. */ /* */ /* INPUT */ /* */ /* module_instance Module instance pointer */ /* module_name Module name pointer */ /* module_location Module code location */ /* */ /* OUTPUT */ /* */ /* status Completion status */ /* */ /* CALLS */ /* */ /* _tx_byte_allocate Allocate data area */ /* _tx_mutex_get Get protection mutex */ /* _tx_mutex_put Release protection mutex */ /* */ /* CALLED BY */ /* */ /* Application code */ /* */ /* RELEASE HISTORY */ /* */ /* DATE NAME DESCRIPTION */ /* */ /* 12-31-2020 Andres Mlinar Initial Version 6.1.3 */ /* */ /**************************************************************************/ UINT _txm_module_manager_absolute_load(TXM_MODULE_INSTANCE *module_instance, CHAR *module_name, VOID *module_location) { TX_INTERRUPT_SAVE_AREA TXM_MODULE_PREAMBLE *module_preamble; ULONG code_size; ULONG code_alignment; ULONG code_allocation_size_ignored; UINT status; TXM_MODULE_INSTANCE *next_module, *previous_module; ULONG start_stop_stack_size; ULONG callback_stack_size; ULONG code_size_ignored; ULONG code_alignment_ignored; ALIGN_TYPE data_start; ULONG data_size; ULONG data_alignment; ULONG data_allocation_size; ULONG module_properties; CHAR *memory_ptr; /* Check for interrupt call. */ if (TX_THREAD_GET_SYSTEM_STATE() != 0) { /* Now, make sure the call is from an interrupt and not initialization. */ if (TX_THREAD_GET_SYSTEM_STATE() < TX_INITIALIZE_IN_PROGRESS) { /* Invalid caller of this function, return appropriate error code. */ return(TX_CALLER_ERROR); } } /* Determine if the module manager has not been initialized yet. */ if (_txm_module_manager_ready != TX_TRUE) { /* Module manager has not been initialized. */ return(TX_NOT_AVAILABLE); } /* Determine if the module is valid. */ if (module_instance == TX_NULL) { /* Invalid module pointer. */ return(TX_PTR_ERROR); } /* Get module manager protection mutex. */ _tx_mutex_get(&_txm_module_manager_mutex, TX_WAIT_FOREVER); /* Determine if the module is already valid. */ if (module_instance -> txm_module_instance_id == TXM_MODULE_ID) { /* Release the protection mutex. */ _tx_mutex_put(&_txm_module_manager_mutex); /* Module already loaded. */ return(TXM_MODULE_ALREADY_LOADED); } /* Pickup the module's information. */ module_preamble = (TXM_MODULE_PREAMBLE *) module_location; /* Check to make sure there is a valid module to load. */ if (module_preamble -> txm_module_preamble_id != TXM_MODULE_ID) { /* Release the protection mutex. */ _tx_mutex_put(&_txm_module_manager_mutex); /* Invalid module preamble. */ return(TXM_MODULE_INVALID); } /* Check the properties of this module. */ module_properties = module_preamble -> txm_module_preamble_property_flags & TXM_MODULE_OPTIONS_MASK; if (/* Ensure the requested properties are supported. */ ((module_properties & _txm_module_manager_properties_supported) != module_properties) || /* Ensure the required properties are there. */ ((_txm_module_manager_properties_required & module_properties) != _txm_module_manager_properties_required) || /* If memory protection is enabled, then so must user mode. */ ((module_properties & TXM_MODULE_MEMORY_PROTECTION) && !(module_properties & TXM_MODULE_USER_MODE)) ) { /* Release the protection mutex. */ _tx_mutex_put(&_txm_module_manager_mutex); /* Invalid properties. Return error. */ return(TXM_MODULE_INVALID_PROPERTIES); } /* Check for valid module entry offsets. */ if ((module_preamble -> txm_module_preamble_shell_entry_function == 0) || (module_preamble -> txm_module_preamble_start_function == 0)) { /* Release the protection mutex. */ _tx_mutex_put(&_txm_module_manager_mutex); /* Invalid module preamble. */ return(TXM_MODULE_INVALID); } /* Check for valid sizes. */ if ((module_preamble -> txm_module_preamble_code_size == 0) || /* (module_preamble -> txm_module_preamble_data_size == 0) || *** a zero data size is valid */ (module_preamble -> txm_module_preamble_start_stop_stack_size == 0) || (module_preamble -> txm_module_preamble_callback_stack_size == 0)) { /* Release the protection mutex. */ _tx_mutex_put(&_txm_module_manager_mutex); /* Invalid module preamble. */ return(TXM_MODULE_INVALID); } /* Get the amount of the bytes we need to allocate for the module's code as well as the required alignment. Note that because this is an absolute load, we only want the code alignment so we can check it. */ status = _txm_module_manager_util_code_allocation_size_and_alignment_get(module_preamble, &code_alignment, &code_allocation_size_ignored); if (status != TX_SUCCESS) { /* Math overflow error occurred. */ return(status); } /* Since this is an absolute load, check the alignment of the module's instruction area (code). */ TXM_MODULE_MANAGER_CHECK_CODE_ALIGNMENT(module_location, code_alignment) /* Initialize module control block to all zeros. */ TX_MEMSET(module_instance, 0, sizeof(TXM_MODULE_INSTANCE)); /* Pickup the basic module sizes. */ code_size = module_preamble -> txm_module_preamble_code_size; data_size = module_preamble -> txm_module_preamble_data_size; start_stop_stack_size = module_preamble -> txm_module_preamble_start_stop_stack_size; callback_stack_size = module_preamble -> txm_module_preamble_callback_stack_size; TXM_MODULE_MANAGER_UTIL_MATH_ADD_ULONG(data_size, TXM_MODULE_DATA_ALIGNMENT, data_size); data_size = ((data_size - 1)/TXM_MODULE_DATA_ALIGNMENT) * TXM_MODULE_DATA_ALIGNMENT; /* Adjust the size of the module elements to be aligned to the default alignment. We do this so that when we partition the allocated memory, we can simply place these regions right beside each other without having to align their pointers. Note this only works when they all have the same alignment. */ TXM_MODULE_MANAGER_UTIL_MATH_ADD_ULONG(start_stop_stack_size, TXM_MODULE_DATA_ALIGNMENT, start_stop_stack_size); start_stop_stack_size = ((start_stop_stack_size - 1)/TXM_MODULE_DATA_ALIGNMENT) * TXM_MODULE_DATA_ALIGNMENT; TXM_MODULE_MANAGER_UTIL_MATH_ADD_ULONG(callback_stack_size, TXM_MODULE_DATA_ALIGNMENT, callback_stack_size); callback_stack_size = ((callback_stack_size - 1)/TXM_MODULE_DATA_ALIGNMENT) * TXM_MODULE_DATA_ALIGNMENT; /* Update the data size to account for the default thread stacks. */ data_allocation_size = 0; TXM_MODULE_MANAGER_UTIL_MATH_ADD_ULONG(data_allocation_size, start_stop_stack_size, data_allocation_size); TXM_MODULE_MANAGER_UTIL_MATH_ADD_ULONG(data_allocation_size, callback_stack_size, data_allocation_size); /* Setup the default code and data alignments. */ data_alignment = (ULONG) TXM_MODULE_DATA_ALIGNMENT; /* Get the port-specific alignment for the data size. Note we only want data so we pass values of 1 for code (to avoid any possible div by 0 errors). */ code_size_ignored = 1; code_alignment_ignored = 1; TXM_MODULE_MANAGER_ALIGNMENT_ADJUST(module_preamble, code_size_ignored, code_alignment_ignored, data_allocation_size, data_alignment) /* Calculate the module's total RAM memory requirement. This entire area is allocated from the module manager's byte pool. The general layout is defined as follows: Lowest Address: Start of start/stop thread stack ... [note: thread entry info is embedded near end of stack areas] End of start/stop thread stack Start of callback thread stack ... [note: thread entry info is embedded near end of stack areas] End of callback thread stack Highest Address: */ /* Add an extra alignment increment so we can align the pointer after allocation. */ TXM_MODULE_MANAGER_UTIL_MATH_ADD_ULONG(data_allocation_size, data_alignment, data_allocation_size); /* Allocate memory for the module. */ status = _tx_byte_allocate(&_txm_module_manager_byte_pool, (VOID **) &memory_ptr, data_allocation_size, TX_NO_WAIT); /* Determine if the module memory allocation was successful. */ if (status) { /* Release the protection mutex. */ _tx_mutex_put(&_txm_module_manager_mutex); /* No memory, return an error. */ return(TX_NO_MEMORY); } /* Clear the allocated memory. */ TX_MEMSET(memory_ptr, ((UCHAR) 0), data_allocation_size); /* Disable interrupts. */ TX_DISABLE /* Setup the module instance structure. */ module_instance -> txm_module_instance_id = TXM_MODULE_ID; /* Save the module name. */ module_instance -> txm_module_instance_name = module_name; /* Save the module properties. */ module_instance -> txm_module_instance_property_flags = module_preamble -> txm_module_preamble_property_flags; /* Set the module data memory allocation. This is the address released when the module is unloaded. */ module_instance -> txm_module_instance_data_allocation_ptr = (VOID *) memory_ptr; /* Save the data allocation size. */ module_instance -> txm_module_instance_data_allocation_size = data_allocation_size; /* Calculate the actual start of the data area. This needs to be adjusted based on the alignment. */ data_start = (ALIGN_TYPE) memory_ptr; data_start = (data_start + (((ALIGN_TYPE)data_alignment) - 1)) & ~(((ALIGN_TYPE)data_alignment) - 1); memory_ptr = (CHAR *) data_start; /* Compute the beginning and end of the data area. */ #ifdef ALIGN_TYPE_DEFINED module_instance -> txm_module_instance_data_start = (VOID *) (((CHAR *) (ALIGN_TYPE) module_preamble->txm_module_preamble_code_size) + sizeof(TXM_MODULE_PREAMBLE)); module_instance -> txm_module_instance_data_end = (VOID *) (((CHAR *) (ALIGN_TYPE) module_instance -> txm_module_instance_data_start) + module_preamble->txm_module_preamble_data_size); #else module_instance -> txm_module_instance_data_start = (VOID *) (((CHAR *) module_preamble->txm_module_preamble_code_size) + sizeof(TXM_MODULE_PREAMBLE)); module_instance -> txm_module_instance_data_end = (VOID *) (((CHAR *) module_instance -> txm_module_instance_data_start) + module_preamble->txm_module_preamble_data_size); #endif /* Save the size of the data area. */ module_instance -> txm_module_instance_data_size = data_size; /* Set the module code memory allocation. This is the address released when the module is unloaded. */ module_instance -> txm_module_instance_code_allocation_ptr = (VOID *) NULL; /* Save the code allocation size. */ module_instance -> txm_module_instance_code_allocation_size = 0; /* Setup the code pointers. Since the code was loaded in-place, this is effectively just the values supplied in the API call. */ module_instance -> txm_module_instance_code_start = (VOID *) module_location; module_instance -> txm_module_instance_code_end = (VOID *) (((CHAR *) module_location) + (code_size - 1)); /* Setup the code size. */ module_instance -> txm_module_instance_code_size = code_size; /* Save the module's total memory usage. */ module_instance -> txm_module_instance_total_ram_usage = 0 /* Code is executed in place */ + data_allocation_size /* just the size of stacks */; /* Set the module state to started. */ module_instance -> txm_module_instance_state = TXM_MODULE_LOADED; /* Save the preamble pointer. */ module_instance -> txm_module_instance_preamble_ptr = module_preamble; /* Save the module application ID in the module instance. */ module_instance -> txm_module_instance_application_module_id = module_preamble -> txm_module_preamble_application_module_id; /* Setup the module's start/stop thread stack area. */ module_instance -> txm_module_instance_start_stop_stack_start_address = (VOID *) (memory_ptr); module_instance -> txm_module_instance_start_stop_stack_size = start_stop_stack_size; module_instance -> txm_module_instance_start_stop_stack_end_address = (VOID *) (memory_ptr + (start_stop_stack_size - 1)); /* Move the memory pointer forward. */ memory_ptr = memory_ptr + start_stop_stack_size; /* Save the start/stop thread priority. */ module_instance -> txm_module_instance_start_stop_priority = module_preamble -> txm_module_preamble_start_stop_priority; /* Setup the module's callback thread stack area. */ module_instance -> txm_module_instance_callback_stack_start_address = (VOID *) (memory_ptr); module_instance -> txm_module_instance_callback_stack_size = callback_stack_size; module_instance -> txm_module_instance_callback_stack_end_address = (VOID *) (memory_ptr + (callback_stack_size - 1)); /* Move the memory pointer forward. */ memory_ptr = memory_ptr + callback_stack_size; /* Save the callback thread priority. */ module_instance -> txm_module_instance_callback_priority = module_preamble -> txm_module_preamble_callback_priority; /* Setup the start of the module data section. */ module_instance -> txm_module_instance_module_data_base_address = (VOID *) (memory_ptr); /* Build actual addresses based on load... Setup all the function pointers. Any adjustments needed to shell entry, start function, and callback function are defined in the module preamble. */ #ifdef ALIGN_TYPE_DEFINED module_instance -> txm_module_instance_shell_entry_function = (VOID (*)(TX_THREAD *, TXM_MODULE_INSTANCE *)) ((VOID *) (ALIGN_TYPE) module_preamble -> txm_module_preamble_shell_entry_function); module_instance -> txm_module_instance_start_thread_entry = (VOID (*)(ULONG)) ((VOID *) (ALIGN_TYPE) module_preamble -> txm_module_preamble_start_function); module_instance -> txm_module_instance_callback_request_thread_entry = (VOID (*)(ULONG)) ((VOID *) (ALIGN_TYPE) module_preamble -> txm_module_preamble_callback_function); #else module_instance -> txm_module_instance_shell_entry_function = (VOID (*)(TX_THREAD *, TXM_MODULE_INSTANCE *)) ((VOID *) module_preamble -> txm_module_preamble_shell_entry_function); module_instance -> txm_module_instance_start_thread_entry = (VOID (*)(ULONG)) ((VOID *) module_preamble -> txm_module_preamble_start_function); module_instance -> txm_module_instance_callback_request_thread_entry = (VOID (*)(ULONG)) ((VOID *) module_preamble -> txm_module_preamble_callback_function); #endif /* Determine if there is a stop function for this module. */ if (module_preamble -> txm_module_preamble_stop_function) { /* Yes, there is a stop function, build the address. */ #ifdef ALIGN_TYPE_DEFINED module_instance -> txm_module_instance_stop_thread_entry = (VOID (*)(ULONG)) ((VOID *) (ALIGN_TYPE) module_preamble -> txm_module_preamble_stop_function); #else module_instance -> txm_module_instance_stop_thread_entry = (VOID (*)(ULONG)) ((VOID *) module_preamble -> txm_module_preamble_stop_function); #endif } else { /* No, there is no stop function. Just set the pointer to NULL. */ module_instance -> txm_module_instance_stop_thread_entry = TX_NULL; } /* Load the module control block with port-specific information. */ TXM_MODULE_MANAGER_MODULE_SETUP(module_instance); /* Now add the module to the linked list of created modules. */ if (_txm_module_manger_loaded_count++ == 0) { /* The loaded module list is empty. Add module to empty list. */ _txm_module_manager_loaded_list_ptr = module_instance; module_instance -> txm_module_instance_loaded_next = module_instance; module_instance -> txm_module_instance_loaded_previous = module_instance; } else { /* This list is not NULL, add to the end of the list. */ next_module = _txm_module_manager_loaded_list_ptr; previous_module = next_module -> txm_module_instance_loaded_previous; /* Place the new module in the list. */ next_module -> txm_module_instance_loaded_previous = module_instance; previous_module -> txm_module_instance_loaded_next = module_instance; /* Setup this module's created links. */ module_instance -> txm_module_instance_loaded_previous = previous_module; module_instance -> txm_module_instance_loaded_next = next_module; } /* Restore interrupts. */ TX_RESTORE /* Release the protection mutex. */ _tx_mutex_put(&_txm_module_manager_mutex); /* Return success. */ return(TX_SUCCESS); }