GeMRTOS
listfunctions.c
Go to the documentation of this file.
1 
22 /******************************************************************************
23 * *
24 * License Agreement *
25 * Copyright (c) Ricardo L. Cayssials *
26 * All rights reserved. *
27 * *
28 ******************************************************************************/
29 
30 #include <gemrtos_core.h>
31 
32 OPTIMEZE_CODE(3)
33 
34 // https://gcc.gnu.org/onlinedocs/gcc/Nios-II-Options.html#index-mno-bypass-cache
35 // #pragma GCC optimize('mno-cache-volatile')
36 
37 
38 
39 /***********************************************************************************
40  * *********************************************************************************
41  * gRTOS SUPPORT FUNCTIONS
42  * *********************************************************************************
43  ***********************************************************************************/
44 
45 
53 INT32 gk_ECBAEL_Link(GS_ECB *pevent1, GS_ECB *pevent2)
54 {
55  SAMPLE_FUNCTION_BEGIN(2)
56  GS_ECB *pevent;
57 
58 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
59  if (ECB_IsValid(pevent1) != G_TRUE) G_DEBUG_WHILEFOREVER;
60  if (ECB_IsValid(pevent2) != G_TRUE) G_DEBUG_WHILEFOREVER;
61 #endif
62 
63  if (pevent1->ECB_NextECBAEL == (struct gs_ecb *) 00)
64  //if ((GS_ECB *) *((char *) pevent1 + offsetof(struct gs_ecb, ECB_NextECBAEL)) == (struct gs_ecb *) 00)
65  {
66  if (pevent2->ECB_NextECBAEL == (struct gs_ecb *) 00)
67  {
68  pevent1->ECB_NextECBAEL = (struct gs_ecb *) pevent2;
69  pevent2->ECB_NextECBAEL = (struct gs_ecb *) pevent1;
70  }
71  else
72  {
73  pevent1->ECB_NextECBAEL = pevent2->ECB_NextECBAEL;
74  pevent2->ECB_NextECBAEL = (struct gs_ecb *) pevent1;
75  }
76  }
77  else
78  {
79  if (pevent2->ECB_NextECBAEL == (struct gs_ecb *) 00)
80  {
81  pevent2->ECB_NextECBAEL = pevent1->ECB_NextECBAEL;
82  pevent1->ECB_NextECBAEL = (struct gs_ecb *) pevent2;
83  }
84  else
85  {
86  pevent = pevent1->ECB_NextECBAEL;
87  pevent1->ECB_NextECBAEL = pevent2->ECB_NextECBAEL;
88  pevent2->ECB_NextECBAEL = (struct gs_ecb *) pevent;
89  }
90  }
91  SAMPLE_FUNCTION_END(2)
92  return(G_TRUE);
93 }
94 
102 INT32 gk_ECBAEL_Remove(GS_ECB *pevent)
103 {
104  SAMPLE_FUNCTION_BEGIN(3)
105  GS_ECB *pevent1;
106  INT32 retorno = G_FALSE;
107 
108  #if G_DEBUG_WHILEFOREVER_ENABLE == 1
109  if (ECB_IsValid(pevent) != G_TRUE) G_DEBUG_WHILEFOREVER;
110  #endif
111 
112  if (pevent->ECB_NextECBAEL != (struct gs_ecb *) 0)
113  {
114  // Looks the previous ECB that points to pevent
115  pevent1 = pevent->ECB_NextECBAEL;
116  while (pevent1->ECB_NextECBAEL != (struct gs_ecb *) pevent)
117  {
118  #if G_DEBUG_WHILEFOREVER_ENABLE == 1
119  if (ECB_IsValid(pevent1) != G_TRUE) G_DEBUG_WHILEFOREVER;
120  #endif
121  pevent1 = (GS_ECB *) pevent1->ECB_NextECBAEL;
122  }
123  if (pevent->ECB_NextECBAEL != pevent1) pevent1->ECB_NextECBAEL = pevent->ECB_NextECBAEL; // there is more ECB
124  else pevent1->ECB_NextECBAEL = (struct gs_ecb *) 0;
125  pevent->ECB_NextECBAEL = (struct gs_ecb *) 0;
126  retorno = G_TRUE;
127  }
128  SAMPLE_FUNCTION_END(3)
129  return(retorno);
130 }
131 
139 void gk_ECBASL_Link(GS_ECB *pevent, GS_SCB *psignal)
140 {
141  SAMPLE_FUNCTION_BEGIN(4)
142  INT32 priority;
143  GS_SCB *psignal2;
144 
145  priority = psignal->SCBType;
146  if (pevent->ECB_NextECBASL == (struct gs_scb *) 0)
147  {
148  // it is the only SCB associated to pevent
149  psignal->SCB_NextSCB = (struct gs_scb *) 0;
150  pevent->ECB_NextECBASL = (struct gs_scb *) psignal;
151  }
152  else
153  {
154  if(pevent->ECB_NextECBASL->SCBType > priority)
155  {
156  // it is the first SCB associated to pevent
157  psignal->SCB_NextSCB = pevent->ECB_NextECBASL;
158  pevent->ECB_NextECBASL = (struct gs_scb *) psignal;
159  }
160  else
161  {
162  // Sort by priotiy
163  psignal2 = pevent->ECB_NextECBASL;
164  while (psignal2 != (struct gs_scb *) 0)
165  {
166  if (psignal2->SCB_NextSCB == (struct gs_scb *) 0)
167  {
168  // It is inserted as the last SCB
169  psignal->SCB_NextSCB = (struct gs_scb *) 0;
170  psignal2->SCB_NextSCB = (struct gs_scb *) psignal;
171  psignal2 = (struct gs_scb *) 0;
172  }
173  else
174  {
175  if (psignal2->SCB_NextSCB->SCBType > priority)
176  {
177  psignal->SCB_NextSCB = psignal2->SCB_NextSCB;
178  psignal2->SCB_NextSCB = (struct gs_scb *) psignal;
179  psignal2 = (struct gs_scb *) 0;
180  }
181  else
182  {
183  // Keep searching
184  psignal2 = psignal2->SCB_NextSCB;
185  }
186  }
187  }
188  }
189  psignal->SCBState = G_SCBState_IN_ECB;
190  }
191  SAMPLE_FUNCTION_END(4)
192 }
193 
203 INT32 gk_ECBASL_Unlink(GS_ECB *pevent, GS_SCB *psignal)
204 {
205  SAMPLE_FUNCTION_BEGIN(5)
206  int retorno = G_FALSE;
207  GS_SCB *psignal1;
208  GS_SCB *psignal2;
209 
210  if (pevent->ECB_NextECBASL == psignal)
211  {
212  // It is the fist ESB of the list
213  pevent->ECB_NextECBASL = psignal->SCB_NextSCB;
214  psignal->SCBState = G_SCBState_UNLINKED;
215  retorno = G_TRUE;
216  }
217  else
218  {
219  psignal2 = pevent->ECB_NextECBASL;
220  while (psignal2 != psignal && psignal2 != (struct gs_scb *) 0)
221  {
222  psignal1 = psignal2;
223  psignal2 = psignal2->SCB_NextSCB;
224  }
225  if (psignal2 == (struct gs_scb *) 0)
226  {
227  retorno = G_FALSE;
228  }
229  else
230  {
231  psignal1->SCB_NextSCB = psignal->SCB_NextSCB;
232  psignal->SCBState = G_SCBState_UNLINKED;
233  retorno = G_TRUE;
234  }
235  }
236  SAMPLE_FUNCTION_END(5)
237  return(retorno);
238 }
239 
248 INT32 gk_ECB_List_Unlink(GS_ECB *pevent)
249 {
250  SAMPLE_FUNCTION_BEGIN(6)
251  GS_SCB *psignal1;
252 
255  // INT32 ECBState; /** Granted, Waiting, Free */
256  // INT32 ECBType; /** Type of event control block (see OS_EVENT_TYPE_xxxx) */
257  // TIMEPRIORITY ECBValue; /** Occurrence Time of the event or Priority */
258  // # struct gs_ecb *ECB_NextECB; /** Pointer to linked list of waiting events of this event */
259  // # struct gs_ecb *ECB_PrevECB; /** Pointer to linked list of waiting events of this event */
260  // struct gs_tcb *ECB_AssocTCB; /** Pointer to the task associated with the event */
261  // struct g_rcb *ECB_AssocRCB; /** Pointer to the resource associated with the event */
262  // # struct gs_ecb *ECB_NextTCBAEL; /** Pointer to the next event of the same task */
263  // # struct gs_ecb *ECB_PrevTCBAEL; /** Pointer to the previous event of the same task */
264  // # struct gs_ecb *ECB_NextECBAEL; /** Pointer to the event associated with this (ie timeout) */
265  // # struct gs_scb *ECB_NextECBASL; /** Pointer to the Linked list of signals */
266  // struct gs_rrds *ECB_RRDS; /** Pointer to the resource request structure or MCB */
268 
269  // Remove ECB from waiting list ECB_NextECB and ECB_PrevECB pointed in timed or resource list
270  // according the pevent->ECBState field
271  switch (pevent->ECBState)
272  {
273  case GS_ECBState_WAITING_TIME:
274  gk_ECBTL_Unlink(pevent);
275  break;
276  case GS_ECBState_GRANTED_RESOURCE:
277  gk_RCBGEL_Unlink(pevent);
278  break;
279  case GS_ECBState_WAITING_RESOURCE:
280  gk_RCBWEL_Unlink(pevent);
281  break;
282  case GS_ECBState_UNLINKED:
283  break;
284  default:
285  G_DEBUG_WHILEFOREVER;
286  break;
287  }
288 
289  // Remove from the task list
290  gk_TCBAEL_Unlink(pevent);
291 
292  // Remove from the ECB Associated list
293  gk_ECBAEL_Remove(pevent);
294 
295  // Remove SCB from ASL
296  while (pevent->ECB_NextECBASL != (struct gs_scb *) 0)
297  {
298  psignal1 = pevent->ECB_NextECBASL;
299  gk_ECBASL_Unlink(pevent, psignal1);
300  gk_SCBFL_Link(psignal1);
301  }
302 
303  // Remove RRDS
304  struct gs_rrds *prrds;
305  struct gs_rrds *prrds1;
306  prrds = (struct gs_rrds *) pevent->ECB_RRDS;
307  pevent->ECB_RRDS = (struct gs_rrds *) 0;
308  while (prrds != (struct gs_rrds *) 0) {
309  prrds1 = (struct gs_rrds *) prrds->RRDS_NextRRDS;
310  gk_RRDSFL_Link(prrds);
311  prrds = prrds1;
312  }
313  SAMPLE_FUNCTION_END(6)
314  return(G_TRUE);
315 }
316 
324 INT32 gk_ECBFL_Link(GS_ECB *pevent)
325 {
326  SAMPLE_FUNCTION_BEGIN(7)
327  // Unlink the ECB
328  gk_ECB_List_Unlink(pevent);
329 
330 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
331  if (ECB_IsValid(pevent) != G_TRUE) G_DEBUG_WHILEFOREVER;
332  if (pevent->ECBState != GS_ECBState_UNLINKED) G_DEBUG_WHILEFOREVER;
333 #endif
334 
336  if (g_kcb.KCB_ROOT_ECBs != (struct gs_ecb *) pevent) pevent->ECB_PREV_ECBs->ECB_NEXT_ECBs = pevent->ECB_NEXT_ECBs;
337  else g_kcb.KCB_ROOT_ECBs = pevent->ECB_NEXT_ECBs;
338  if (pevent->ECB_NEXT_ECBs != (struct gs_ecb *) 0) pevent->ECB_NEXT_ECBs->ECB_PREV_ECBs = pevent->ECB_PREV_ECBs;
339 
340  free(pevent->malloc_address);
341  g_kcb.KCB_NUMBER_OF_ECBs-- ;
342 
343  SAMPLE_FUNCTION_END(7)
344  return(G_TRUE);
345 }
346 
355 inline INT32 gk_ECBTL_Link (GS_ECB *pevent)
356 {
357  SAMPLE_FUNCTION_BEGIN(8)
358  GS_ECB *pevent2;
359 
360 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
361  if (ECB_IsValid(pevent) != G_TRUE) G_DEBUG_WHILEFOREVER;
362  if (pevent->ECBState != GS_ECBState_UNLINKED) G_DEBUG_WHILEFOREVER;
363 #endif
364  //printf("pevent = %p, %p", (void *)*((char *) pevent + 16), pevent->ECB_NextECB);
365 
366  if (g_kcb.KCB_NextECBTL->ECBValue.i64 > pevent->ECBValue.i64)
367  {/* Event inserted is the next occurence */
368  pevent->ECB_NextECB = g_kcb.KCB_NextECBTL;
369  pevent->ECB_PrevECB = (struct gs_ecb *) 00;
370  g_kcb.KCB_NextECBTL->ECB_PrevECB = (struct gs_ecb *) pevent;
371  g_kcb.KCB_NextECBTL = (struct gs_ecb *) pevent;
372  GRTOS_CMD_NXT_OCC_TM_EVN_SET(pevent->ECBValue.i64);
373  } else {
374  /* Recorro la lista para buscar el punto de insercion del evento */
375  /* siempre habra un ultimo elemento */
376  pevent2 = g_kcb.KCB_NextECBTL;
377  while (pevent2->ECBValue.i64 <= pevent->ECBValue.i64){
378  pevent2 = pevent2->ECB_NextECB;
379  }
380 
381  pevent->ECB_NextECB = (struct gs_ecb *) pevent2; /* Insert the task in the linked list */
382  pevent->ECB_PrevECB = pevent2->ECB_PrevECB;
383  pevent2->ECB_PrevECB->ECB_NextECB = (struct gs_ecb *) pevent;
384  pevent2->ECB_PrevECB = (struct gs_ecb *) pevent;
385  }
386  /* Change Status of the Event */
387  pevent->ECBState = GS_ECBState_WAITING_TIME;
388  SAMPLE_FUNCTION_END(8)
389  return(G_TRUE);
390 }
391 
405 inline INT32 gk_ECBTL_Unlink(GS_ECB *pevent)
406 {
407  SAMPLE_FUNCTION_BEGIN(9)
408  #if G_DEBUG_WHILEFOREVER_ENABLE == 1
409  if (ECB_IsValid(pevent) != G_TRUE) G_DEBUG_WHILEFOREVER;
410  if (pevent->ECBState != GS_ECBState_WAITING_TIME) G_DEBUG_WHILEFOREVER;
411  #endif
412 
413  /* Remove from the time linked list */
414  if (g_kcb.KCB_NextECBTL == (struct gs_ecb *) pevent)
415  {
416  g_kcb.KCB_NextECBTL = pevent->ECB_NextECB;
417  // g_kcb.KCB_NextECBTL is never NULL becuase the latest ECB is linked
418 
419  if (g_kcb.KCB_NextECBTL == (struct gs_ecb *) 0) G_DEBUG_WHILEFOREVER;
420 
421  g_kcb.KCB_NextECBTL->ECB_PrevECB = (struct gs_ecb *) 00;
422  GRTOS_CMD_NXT_OCC_TM_EVN_SET(g_kcb.KCB_NextECBTL->ECBValue.i64);
423  } else
424  {
425  pevent->ECB_PrevECB->ECB_NextECB = pevent->ECB_NextECB;
426  pevent->ECB_NextECB->ECB_PrevECB = pevent->ECB_PrevECB;
427  }
428  /* Set the pointer to unlinked */
429  pevent->ECB_PrevECB = (struct gs_ecb *) 0;
430  pevent->ECB_NextECB = (struct gs_ecb *) 0;
431  pevent->ECBState = GS_ECBState_UNLINKED;
432  SAMPLE_FUNCTION_END(9)
433  return(G_TRUE);
434 }
435 
443 INT32 gk_KCBASL_Link(GS_SCB *psignal)
444 {
445  SAMPLE_FUNCTION_BEGIN(10)
446  INT32 priority;
447  GS_SCB *psignal2;
448 
449  priority = psignal->SCBType;
450  if (g_kcb.KCB_NextKCBASL == (struct gs_scb *) 0)
451  {
452  // it is the only SCB associated to pevent
453  psignal->SCB_NextSCB = (struct gs_scb *) 0;
454  g_kcb.KCB_NextKCBASL = (struct gs_scb *)psignal;
455  }
456  else
457  {
458  if(g_kcb.KCB_NextKCBASL->SCBType > priority)
459  {
460  // it is the first SCB associated to pevent
461  psignal->SCB_NextSCB = g_kcb.KCB_NextKCBASL;
462  g_kcb.KCB_NextKCBASL = (struct gs_scb *) psignal;
463  }
464  else
465  {
466  // Sort by priotiy
467  psignal2 = g_kcb.KCB_NextKCBASL;
468  while (psignal2 != (struct gs_scb *) 0)
469  {
470  if (psignal2->SCB_NextSCB == (struct gs_scb *) 0)
471  {
472  // It is inserted as the last SCB
473  psignal->SCB_NextSCB = (struct gs_scb *) 0;
474  psignal2->SCB_NextSCB = (struct gs_scb *) psignal;
475  psignal2 = (struct gs_scb *) 0;
476  }
477  else
478  {
479  if (psignal2->SCB_NextSCB->SCBType > priority)
480  {
481  psignal->SCB_NextSCB = psignal2->SCB_NextSCB;
482  psignal2->SCB_NextSCB = (struct gs_scb *) psignal;
483  psignal2 = (struct gs_scb *) 0;
484  }
485  else
486  {
487  // Keep searching
488  psignal2 = psignal2->SCB_NextSCB;
489  }
490  }
491  }
492  }
493  psignal->SCBState = G_SCBState_IN_KCB;
494  }
495  SAMPLE_FUNCTION_END(10)
496  return(G_TRUE);
497 }
498 
507 INT32 gk_KCBASL_Unlink(GS_SCB *psignal)
508 {
509  SAMPLE_FUNCTION_BEGIN(11)
510  int retorno = G_FALSE;
511  GS_SCB *psignal1;
512  GS_SCB *psignal2;
513 
514  if (g_kcb.KCB_NextKCBASL == psignal)
515  {
516  // It is the fist ESB of the list
517  g_kcb.KCB_NextKCBASL = psignal->SCB_NextSCB;
518  psignal->SCBState = G_SCBState_UNLINKED;
519  retorno = G_TRUE;
520  }
521  else
522  {
523  psignal2 = g_kcb.KCB_NextKCBASL;
524  while (psignal2 != psignal && psignal2 != (struct gs_scb *) 0)
525  {
526  psignal1 = psignal2;
527  psignal2 = psignal2->SCB_NextSCB;
528  }
529  if (psignal2 == (struct gs_scb *) 0)
530  {
531  retorno = G_FALSE;
532  }
533  else
534  {
535  psignal1->SCB_NextSCB = psignal->SCB_NextSCB;
536  psignal->SCBState = G_SCBState_UNLINKED;
537  retorno = G_TRUE;
538  }
539  }
540  SAMPLE_FUNCTION_END(11)
541  return(retorno);
542 }
543 
553 INT32 gk_LCBL_Link(GS_LCB *plcb)
554 {
555  SAMPLE_FUNCTION_BEGIN(12)
556  GS_LCB *plcb1 = g_kcb.KCB_NextLCBL;
557 
558 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
559  if (LCB_IsValid(plcb) != G_TRUE) G_DEBUG_WHILEFOREVER;
560 #endif
561 
562  if (g_kcb.KCB_NextLCBL == (struct gs_lcb *) 0)
563  {/* it is the first list to be added */
564  g_kcb.KCB_NextLCBL = (struct gs_lcb *) plcb;
565  plcb->LCB_NextLCBL = (struct gs_lcb *) 0;
566  plcb->LCB_PrevLCBL = (struct gs_lcb *) 0;
567  }
568  else
569  {/* The list it is not empty */
570  if (gk_LCBLowerPriorityThanLCB(plcb, g_kcb.KCB_NextLCBL) == G_TRUE)
571  {
572  /* It should be inserted as first element */
573  plcb->LCB_NextLCBL = g_kcb.KCB_NextLCBL;
574  plcb->LCB_PrevLCBL = (struct gs_lcb *) 0;
575  plcb->LCB_NextLCBL->LCB_PrevLCBL = (struct gs_lcb *) plcb;
576  g_kcb.KCB_NextLCBL = (struct gs_lcb *) plcb;
577  }
578  else
579  {
580  while (plcb1 != (struct gs_lcb *) 0) {
581 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
582  if (LCB_IsValid(plcb1) != G_TRUE) G_DEBUG_WHILEFOREVER;
583 #endif
584  if (plcb1->LCB_NextLCBL == (struct gs_lcb *) 0){
585  /* It has to be inserted as the last element */
586  plcb->LCB_NextLCBL = (struct gs_lcb *) 0;
587  plcb->LCB_PrevLCBL = (struct gs_lcb *) plcb1;
588  plcb1->LCB_NextLCBL = (struct gs_lcb *) plcb;
589  plcb1 = (struct gs_lcb *) 0; /* to exit the while */
590  }
591  else
592  {
593  /* Chheck if it has to be inserted before next */
594  if (gk_LCBLowerPriorityThanLCB(plcb, plcb1->LCB_NextLCBL) == G_TRUE){
595  plcb->LCB_NextLCBL = plcb1->LCB_NextLCBL;
596  plcb->LCB_PrevLCBL = (struct gs_lcb *) plcb1;
597  plcb->LCB_NextLCBL->LCB_PrevLCBL = (struct gs_lcb *) plcb;
598  plcb1->LCB_NextLCBL = (struct gs_lcb *) plcb;
599  plcb1 = (struct gs_lcb *) 0; /* to exit the while */
600  }
601  else
602  {
603  plcb1 = plcb1->LCB_NextLCBL;
604  }
605  }
606  }
607  }
608  }
609  plcb->LCBState = GS_LCBState_LINKED;
610  SAMPLE_FUNCTION_END(12)
611  return(G_TRUE);
612 }
613 
614 
623 INT32 gk_LCBL_UnLink(GS_LCB *plcb)
624 {
625  SAMPLE_FUNCTION_BEGIN(13)
626 
627 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
628  if (LCB_IsValid(plcb) != G_TRUE) G_DEBUG_WHILEFOREVER;
629  if (LCB_IsValid(g_kcb.KCB_NextLCBL) != G_TRUE) G_DEBUG_WHILEFOREVER;
630 #endif
631 
633  if (g_kcb.KCB_NextLCBL == plcb)
634  {/* Remove as first element */
635  g_kcb.KCB_NextLCBL = plcb->LCB_NextLCBL;
636  if (g_kcb.KCB_NextLCBL != (struct gs_lcb *) 0) g_kcb.KCB_NextLCBL->LCB_PrevLCBL =(struct gs_lcb *) 0;
637  }
638  else
639  {/* It is not the firstLCB in the list */
640  plcb->LCB_PrevLCBL->LCB_NextLCBL = plcb->LCB_NextLCBL;
641  if (plcb->LCB_NextLCBL != (struct gs_lcb *) 0) plcb->LCB_NextLCBL->LCB_PrevLCBL = plcb->LCB_PrevLCBL;
642  }
643  plcb->LCBState = GS_LCBState_UNLINKED;
644 
645  SAMPLE_FUNCTION_END(13)
646  return(G_TRUE);
647 }
648 
659 INT32 gk_LCBFPL_Link(int processorID)
660 {
661  SAMPLE_FUNCTION_BEGIN(14)
662  GS_PCB *ppcb = &g_kcb.G_PCBTbl[processorID-1];
663  GS_LCB *plcb = ppcb->PCB_RDY_LCBL[0];
664 
665 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
666  if (processorID < 1 || processorID > G_NUMBER_OF_PCB) G_DEBUG_WHILEFOREVER;
667 #endif
668 
669  if (ppcb->PCBState != GS_PCBState_FREE) {
670  if (plcb->LCB_NextLCBFPL == (struct gs_pcb *) 0) {
671  plcb->LCB_NextLCBFPL = (struct gs_pcb *) ppcb;
672  ppcb->PCB_NextPCB = (struct gs_pcb *) 0;
673  ppcb->PCB_PrevPCB = (struct gs_pcb *) 0;
674  }
675  else
676  {
677  plcb->LCB_NextLCBFPL->PCB_PrevPCB = (struct gs_pcb *) ppcb;
678  ppcb->PCB_NextPCB = plcb->LCB_NextLCBFPL;
679  ppcb->PCB_PrevPCB = (struct gs_pcb *) 0;
680  plcb->LCB_NextLCBFPL = (struct gs_pcb *) ppcb;
681  }
682  }
683  ppcb->PCBState = GS_PCBState_FREE;
684 
685 
686 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
687  if (plcb->LCB_NextLCBFPL == (struct gs_pcb *) 0) G_DEBUG_WHILEFOREVER;
688 #endif
689  SAMPLE_FUNCTION_END(14)
690  return(G_TRUE);
691 }
692 
702 INT32 gk_LCBFPL_Unlink(int processorID)
703 {
704  SAMPLE_FUNCTION_BEGIN(15)
705  GS_PCB *ppcb = &g_kcb.G_PCBTbl[processorID-1];
706  GS_LCB *plcb = ppcb->PCB_RDY_LCBL[0];
707 
708 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
709  if (processorID < 1 || processorID > G_NUMBER_OF_PCB) G_DEBUG_WHILEFOREVER;
710 #endif
711 
712  if (ppcb->PCBState != GS_PCBState_RUNNING) {
713  if (plcb->LCB_NextLCBFPL == ppcb) { /* It is the first element */
714  plcb->LCB_NextLCBFPL = ppcb->PCB_NextPCB;
715  }
716  else {
717  ppcb->PCB_PrevPCB->PCB_NextPCB = ppcb->PCB_NextPCB;
718  }
719  if (ppcb->PCB_NextPCB != (struct gs_pcb *) 0) ppcb->PCB_NextPCB->PCB_PrevPCB = ppcb->PCB_PrevPCB;
720  }
721 
722  ppcb->PCBState = GS_PCBState_RUNNING;
723  SAMPLE_FUNCTION_END(15)
724  return(G_TRUE);
725 }
726 
737 INT32 gk_RCBASL_Link(G_RCB *presource, GS_SCB *psignal)
738 {
739  SAMPLE_FUNCTION_BEGIN(16)
740  INT32 priority = psignal->SCBType;
741  GS_SCB *psignal1;
742 
743  if (presource->RCB_NextRCBASL == (struct gs_scb *) 0)
744  {
745  // it is the only SCB associated to pevent
746  psignal->SCB_NextSCB = (struct gs_scb *) 0;
747  presource->RCB_NextRCBASL = (struct gs_scb *) psignal;
748  }
749  else
750  {
751  if(presource->RCB_NextRCBASL->SCBType < priority)
752  {
753  // it is the first SCB associated to pevent
754  psignal->SCB_NextSCB = presource->RCB_NextRCBASL;
755  presource->RCB_NextRCBASL = (struct gs_scb *) psignal;
756  }
757  else
758  {
759  // Sort by priotiy
760  psignal1 = presource->RCB_NextRCBASL;
761  while (psignal1 != (struct gs_scb *) 0)
762  {
763  if (psignal1->SCB_NextSCB == (struct gs_scb *) 0)
764  {
765  // It is inserted as the last SCB
766  psignal->SCB_NextSCB = (struct gs_scb *) 0;
767  psignal1->SCB_NextSCB = (struct gs_scb *) psignal;
768  psignal1 = (struct gs_scb *) 0;
769  }
770  else
771  {
772  if (psignal1->SCB_NextSCB->SCBType < priority)
773  {
774  psignal->SCB_NextSCB = psignal1->SCB_NextSCB;
775  psignal1->SCB_NextSCB = (struct gs_scb *) psignal;
776  psignal1 = (struct gs_scb *) 0;
777  }
778  else
779  {
780  // Keep searching
781  psignal1 = psignal1->SCB_NextSCB;
782  }
783  }
784  }
785  }
786  }
787  psignal->SCBState = G_SCBState_IN_RCB;
788  SAMPLE_FUNCTION_END(16)
789  return(G_TRUE);
790 }
791 
802 INT32 gk_RCBASL_Unlink(G_RCB *presource, GS_SCB *psignal)
803 {
804  SAMPLE_FUNCTION_BEGIN(17)
805  GS_SCB *psignal1;
806 
807 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
808  if (psignal->SCBState == G_SCBState_UNLINKED) G_DEBUG_WHILEFOREVER;
809 #endif
810 
811  if (presource->RCB_NextRCBASL != (struct gs_scb *) 0)
812  {
813  if (presource->RCB_NextRCBASL == psignal)
814  {
815  presource->RCB_NextRCBASL = psignal->SCB_NextSCB;
816  }
817  else
818  {
819  psignal1 = presource->RCB_NextRCBASL;
820  while (psignal1 != (struct gs_scb *) 0)
821  {
822  if (psignal1->SCB_NextSCB == psignal)
823  {
824  psignal1->SCB_NextSCB = psignal->SCB_NextSCB;
825  psignal1 = (struct gs_scb *) 0;
826  }
827  else
828  {
829  psignal1 = psignal1->SCB_NextSCB;
830  }
831  }
832  }
833  psignal->SCBState = G_SCBState_UNLINKED;
834  }
835 
836 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
837  if (psignal->SCBState != G_SCBState_UNLINKED) G_DEBUG_WHILEFOREVER;
838 #endif
839  SAMPLE_FUNCTION_END(17)
840  return(G_TRUE);
841 }
842 
851 INT32 gk_RCBFL_Link(G_RCB *presource)
852 {
853  SAMPLE_FUNCTION_BEGIN(18)
854 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
855  if (presource->RCBType != GK_RCBType_UNUSED) G_DEBUG_WHILEFOREVER;
856 #endif
857 
859  if (g_kcb.KCB_ROOT_RCBs != (struct g_rcb *) presource) presource->RCB_PREV_RCBs->RCB_NEXT_RCBs = presource->RCB_NEXT_RCBs;
860  else g_kcb.KCB_ROOT_RCBs = (struct g_rcb *) presource->RCB_NEXT_RCBs;
861  if (presource->RCB_NEXT_RCBs != (G_RCB *) 0) presource->RCB_NEXT_RCBs->RCB_PREV_RCBs = presource->RCB_PREV_RCBs;
862 
863  free(presource->malloc_address);
864  g_kcb.KCB_NUMBER_OF_RCBs--;
865 
866  SAMPLE_FUNCTION_END(18)
867  return(G_TRUE);
868 }
869 
870 // /**gk_RCB_GetFree
871 // * \brief
872 // * Unlinks an RCB from the RCBFL list and returns its pointer or NULL if no free RCB is available
873 // * \return Pointer to the RCB or NULL when no RCB available
874 // * \relates Resource
875 // */
876 // G_RCB *gk_RCB_GetFree(void)
877 // {
878 // SAMPLE_FUNCTION_BEGIN(19)
879 //
880 // G_RCB *presource = gk_Get_RCB();
881 // if (presource != (G_RCB *) 0) {
882 // presource->RCBType = GK_RCBType_UNUSED;
883 // }
884 // SAMPLE_FUNCTION_END(19)
885 // return(presource);
886 // }
887 
897 INT32 gk_TASK_RELEASE(GS_TCB *ptcb)
898 {
899  SAMPLE_FUNCTION_BEGIN(20)
900  GS_SCB *psignal = ptcb->TCB_NextTCBASL; // Preserve the Associated Signal list
901  unsigned int state = ptcb->TCBState; // Preserve the currente state of task
902 
903  gk_TCB_Unlink(ptcb);
904  // Debo dejar la tarea como si recien se ejecutara
905  ptcb->TCB_NextTCBASL = (struct gs_scb *) 0;
906  gk_TCB_List_Unlink(ptcb); // Remove all the lists from the TCB
907  gk_TASK_STK_Init(ptcb); // Initiates the stack of the task
908 
909  gk_TCBRDYL_Link(ptcb); PRINT_DEBUG_LINE
910  ptcb->TCB_NextTCBASL = (struct gs_scb *) psignal; // Put back the Associated Signal list
911 
912  // Check if there is G_SCBType_TCB_ABORTED signal
913  if (state == G_TCBState_WAITING) { // It is waiting not completed
914  psignal = gk_TCBASL_GetSCB(ptcb, G_SCBType_TCB_ABORTED); PRINT_DEBUG_LINE
915  if (psignal != (GS_SCB *) 0) {
916  psignal = gk_SCB_Copy((GS_SCB *) psignal); PRINT_DEBUG_LINE
917  gk_TCBPSL_Link(ptcb, (GS_SCB *) psignal); PRINT_DEBUG_LINE
918  // fprintf(stderr,"[ MESSAGE ] SIGNAL next ASL of task 1 is %p copy is %p \n", (void *) ptcb->TCB_NextTCBASL, (void *) psignal);
919  }
920  }
921  SAMPLE_FUNCTION_END(20)
922  return(G_TRUE);
923 }
924 
935 GS_ECB *gk_RCBGEL_Link(G_RCB *presource, GS_ECB *pevent)
936 {
937  SAMPLE_FUNCTION_BEGIN(21)
938  GS_ECB *pevent1;
939 
940  if (pevent == (struct gs_ecb *) 0) pevent = gk_ECB_GetFree();
941  if (pevent == (struct gs_ecb *) 0) {
942  SAMPLE_FUNCTION_END(21)
943  return(pevent);
944  }
945 
946  #if G_DEBUG_WHILEFOREVER_ENABLE == 1
947  if (ECB_IsValid(pevent) != G_TRUE) G_DEBUG_WHILEFOREVER;
948  #endif
949 
950  /* Set the priority of the event to link */
951  // !!!! cambiar para prioridad de diferetnes structures
952  if (pevent->ECB_RRDS != (struct gs_rrds *) 0) pevent->ECBValue.i64 = pevent->ECB_RRDS->RRDSGrantedPriority.i64;
953  else pevent->ECBValue.i64 = (INT64) G_LOWEST_PRIORITY - (INT64) 100;
954 
955  /* Get the priority of the Event of highest priority */
956  pevent1 = presource->RCB_NextRCBGEL;
957 
958  if (pevent1 == (struct gs_ecb *) 0)
959  {
960  pevent->ECB_NextECB = (struct gs_ecb *)0;
961  pevent->ECB_PrevECB = (struct gs_ecb *)0;
962  presource->RCB_NextRCBGEL = (struct gs_ecb *) pevent;
963  }
964  else
965  {
966  if (pevent1->ECBValue.i64 > pevent->ECBValue.i64)
967  {
968  pevent->ECB_NextECB = (struct gs_ecb *) pevent1;
969  pevent->ECB_NextECB->ECB_PrevECB = (struct gs_ecb *) pevent;
970  pevent->ECB_PrevECB = (struct gs_ecb *)0;
971  presource->RCB_NextRCBGEL = (struct gs_ecb *) pevent;
972  } else {
973  while (pevent1 != (struct gs_ecb *) 0)
974  {
975  if (pevent1->ECBValue.i64 > pevent->ECBValue.i64)
976  {
977  pevent->ECB_NextECB = (struct gs_ecb *) pevent1;
978  pevent->ECB_PrevECB = pevent1->ECB_PrevECB;
979  pevent1->ECB_PrevECB->ECB_NextECB = (struct gs_ecb *) pevent;
980  pevent1->ECB_PrevECB = (struct gs_ecb *) pevent;
981  pevent1 = (GS_ECB *) 0;
982  }
983  else
984  {
985  if (pevent1->ECB_NextECB == (struct gs_ecb *) 0)
986  {
987  pevent->ECB_NextECB = (struct gs_ecb *) 0;
988  pevent->ECB_PrevECB = (struct gs_ecb *)pevent1;
989  pevent1->ECB_NextECB = (struct gs_ecb *)pevent;
990  pevent1 = (struct gs_ecb *) 0;
991  }
992  else
993  {
994  pevent1 = pevent1->ECB_NextECB;
995  }
996  }
997  }
998  }
999  }
1000  pevent->ECB_AssocRCB = (struct g_rcb *) presource;
1001  pevent->ECBState = GS_ECBState_GRANTED_RESOURCE;
1002  SAMPLE_FUNCTION_END(21)
1003  return((GS_ECB *)pevent);
1004 }
1005 
1012 void gk_RCBGEL_Unlink(GS_ECB *pevent)
1013 {
1014  SAMPLE_FUNCTION_BEGIN(22)
1015 
1016  G_RCB *presource = (G_RCB *) pevent->ECB_AssocRCB;
1017 
1018 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
1019  if (ECB_IsValid(pevent) != G_TRUE) G_DEBUG_WHILEFOREVER;
1020  if (pevent->ECBState != GS_ECBState_GRANTED_RESOURCE) G_DEBUG_WHILEFOREVER;
1021  if (ECB_IsValid(presource->RCB_NextRCBGEL) != G_TRUE) G_DEBUG_WHILEFOREVER;
1022 #endif
1023 
1024  /* Remove from the resource linked list */
1025  if (presource->RCB_NextRCBGEL == pevent)
1026  {
1027  presource->RCB_NextRCBGEL = pevent->ECB_NextECB;
1028  }
1029  else
1030  {
1031  pevent->ECB_PrevECB->ECB_NextECB = pevent->ECB_NextECB;
1032  }
1033  if (pevent->ECB_NextECB != (struct gs_ecb *) 0) pevent->ECB_NextECB->ECB_PrevECB = pevent->ECB_PrevECB;
1034 
1035  /* Set the pointer to unlinked */
1036  pevent->ECBState = GS_ECBState_UNLINKED;
1037  pevent->ECB_PrevECB = (struct gs_ecb *) 0;
1038  pevent->ECB_NextECB = (struct gs_ecb *) 0;
1039  SAMPLE_FUNCTION_END(22)
1040 }
1041 
1042 
1054 GS_ECB *gk_RCBWEL_Link(G_RCB *presource, GS_ECB *pevent)
1055 {
1056  SAMPLE_FUNCTION_BEGIN(23)
1057  GS_ECB *pevent1;
1058 
1059  // Get event if it is NULL
1060  if (pevent == (struct gs_ecb *) 0){
1061  pevent = gk_ECB_GetFree();
1062  if (pevent != (struct gs_ecb *) 0) pevent->ECB_RRDS = (struct gs_rrds *) 0;
1063  }
1064  if (pevent == (struct gs_ecb *) 0) G_DEBUG_WHILEFOREVER;
1065 
1066 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
1067  if (ECB_IsValid(pevent) != G_TRUE) G_DEBUG_WHILEFOREVER;
1068 #endif
1069 
1070  // Set the priority of the event
1071  if (pevent->ECB_RRDS != (struct gs_rrds *) 0) pevent->ECBValue.i64 = pevent->ECB_RRDS->RRDSWaitingPriority.i64;
1072  else pevent->ECBValue.i64 = presource->RCBPriority.i64;
1073 
1074  /* Get the priority of the Event of highest priority */
1075  //pevent1 = GetFirstEventWaitingForResource(presource);
1076  pevent1 = presource->RCB_NextRCBWEL;
1077 
1078  if (pevent1 == (struct gs_ecb *) 00)
1079  {
1080  pevent->ECB_NextECB = (struct gs_ecb *) 00;
1081  pevent->ECB_PrevECB = (struct gs_ecb *) 00;
1082  presource->RCB_NextRCBWEL = (struct gs_ecb *) pevent;
1083  }
1084  else
1085  {
1086  if (pevent1->ECBValue.i64 > pevent->ECBValue.i64){
1087  pevent->ECB_NextECB = presource->RCB_NextRCBWEL;
1088  pevent->ECB_PrevECB = (struct gs_ecb *) 00;
1089  presource->RCB_NextRCBWEL = (struct gs_ecb *) pevent;
1090  pevent1->ECB_PrevECB = (struct gs_ecb *) pevent;
1091  }
1092  else
1093  {
1094  while (pevent1 != (struct gs_ecb *) 00){
1095  if (pevent1->ECB_NextECB == (struct gs_ecb *) 00) {
1096  pevent->ECB_NextECB = (struct gs_ecb *) 0;
1097  pevent->ECB_PrevECB = (struct gs_ecb *) pevent1;
1098  pevent1->ECB_NextECB = (struct gs_ecb *) pevent;
1099  pevent1 = (struct gs_ecb *) 0;
1100  }
1101  else
1102  {
1103  if (pevent1->ECB_NextECB->ECBValue.i64 > pevent->ECBValue.i64){
1104  pevent->ECB_NextECB = pevent1->ECB_NextECB;
1105  pevent->ECB_PrevECB = (struct gs_ecb *) pevent1;
1106  pevent->ECB_NextECB->ECB_PrevECB = (struct gs_ecb *) pevent;
1107  pevent1->ECB_NextECB = (struct gs_ecb *) pevent;
1108  pevent1 = (struct gs_ecb *) 0;
1109  }
1110  else
1111  {
1112  pevent1 = pevent1->ECB_NextECB;
1113  }
1114  }
1115  }
1116  }
1117  }
1118  pevent->ECBState = GS_ECBState_WAITING_RESOURCE;
1119  pevent->ECB_AssocRCB = (struct g_rcb *) presource;
1120  SAMPLE_FUNCTION_END(23)
1121  return(pevent);
1122 }
1123 
1135 void gk_RCBWEL_Unlink(GS_ECB *pevent)
1136 {
1137  SAMPLE_FUNCTION_BEGIN(24)
1138  G_RCB *presource = (G_RCB *) pevent->ECB_AssocRCB;
1139 
1140 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
1141  if (ECB_IsValid(pevent) != G_TRUE) G_DEBUG_WHILEFOREVER;
1142  if (pevent->ECBState == GS_ECBState_UNLINKED) G_DEBUG_WHILEFOREVER;
1143 #endif
1144 
1145  /* Remove from the resource linked list */
1146  if (presource->RCB_NextRCBWEL == pevent)
1147  {
1148  presource->RCB_NextRCBWEL = pevent->ECB_NextECB;
1149  presource->RCB_NextRCBWEL->ECB_PrevECB = (struct gs_ecb *) 0;
1150  } else
1151  {
1152  pevent->ECB_PrevECB->ECB_NextECB = pevent->ECB_NextECB;
1153  if (pevent->ECB_NextECB != (struct gs_ecb *) 0) {
1154  pevent->ECB_NextECB->ECB_PrevECB = pevent->ECB_PrevECB;
1155  }
1156  }
1157  /* Set the pointer to unlinked */
1158  pevent->ECBState = GS_ECBState_UNLINKED;
1159  pevent->ECB_PrevECB = (struct gs_ecb *) 0;
1160  pevent->ECB_NextECB = (struct gs_ecb *) 0;
1161  SAMPLE_FUNCTION_END(24)
1162 }
1163 
1164 
1173 INT32 gk_SCBFL_Link(GS_SCB *psignal)
1174 {
1175  SAMPLE_FUNCTION_BEGIN(25)
1176 
1177 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
1178  if (psignal->SCBState != G_SCBState_UNLINKED) G_DEBUG_WHILEFOREVER;
1179 #endif
1180 
1182  if (g_kcb.KCB_ROOT_SCBs != (struct gs_scb *) psignal) psignal->SCB_PREV_SCBs->SCB_NEXT_SCBs = psignal->SCB_NEXT_SCBs;
1183  else g_kcb.KCB_ROOT_SCBs = psignal->SCB_NEXT_SCBs;
1184  if (psignal->SCB_NEXT_SCBs != (struct gs_scb *) 0) psignal->SCB_NEXT_SCBs->SCB_PREV_SCBs = psignal->SCB_PREV_SCBs;
1185 
1186  free(psignal->malloc_address);
1187  g_kcb.KCB_NUMBER_OF_SCBs--;
1188 
1189  SAMPLE_FUNCTION_END(25)
1190  return(G_TRUE);
1191 }
1192 
1193 
1201 GS_SCB *gk_SCB_Copy(GS_SCB *psignal)
1202 {
1203  SAMPLE_FUNCTION_BEGIN(27)
1204  GS_SCB *psignal1 = gk_SCB_GetFree();
1205 
1206  if (psignal1 != (struct gs_scb *) 0){
1207  psignal1->SCBState = psignal->SCBState;
1208  psignal1->SCBType = psignal->SCBType;
1209  psignal1->SCBPriority = psignal->SCBPriority;
1210  psignal1->SCB_TaskCode = psignal->SCB_TaskCode;
1211  psignal1->SCB_TaskArg = psignal->SCB_TaskArg;
1212  psignal1->SCB_NextSCB = (struct gs_scb *) 0;
1213  psignal1->SCB_NextSCBAPSL = (struct gs_scb *) 0;
1214  psignal1->SCB_AssocXCB = psignal->SCB_AssocXCB;
1215  }
1216  SAMPLE_FUNCTION_END(27)
1217  return(psignal1);
1218 }
1219 
1228 void gk_SCBAPSL_Link(GS_SCB *pscb_root, GS_SCB *pscb_pending)
1229 {
1230  SAMPLE_FUNCTION_BEGIN(28)
1231  pscb_pending->SCB_NextSCBAPSL = pscb_root->SCB_NextSCBAPSL;
1232  pscb_root = pscb_pending;
1233  SAMPLE_FUNCTION_END(28)
1234 }
1235 
1244 INT32 gk_SCBAPSL_UnLink(GS_SCB *pscb_root, GS_SCB *pscb_pending)
1245 {
1246  SAMPLE_FUNCTION_BEGIN(29)
1247  GS_SCB * pscb;
1248  if (pscb_pending->SCBState == G_SCBState_EXECUTING) return(G_FALSE);
1249 
1250  if (pscb_root->SCB_NextSCBAPSL == pscb_pending)
1251  {
1252  pscb_root->SCB_NextSCBAPSL = pscb_pending->SCB_NextSCBAPSL;
1253  }
1254  else
1255  {
1256  pscb = pscb_root->SCB_NextSCBAPSL;
1257  while (pscb != (struct gs_scb *) 0)
1258  {
1259  if (pscb->SCB_NextSCBAPSL == pscb_pending)
1260  {
1261  pscb->SCB_NextSCBAPSL = pscb_pending->SCB_NextSCBAPSL;
1262  pscb = (struct gs_scb *) 0;
1263  }
1264  else
1265  {
1266  pscb = pscb->SCB_NextSCBAPSL;
1267  }
1268  }
1269  }
1270  SAMPLE_FUNCTION_END(29)
1271  return(G_TRUE);
1272 }
1273 
1284 INT32 gk_TCBAEL_Link(GS_ECB *pevent, GS_TCB *ptcb)
1285 {
1286  SAMPLE_FUNCTION_BEGIN(30)
1287  #if G_DEBUG_WHILEFOREVER_ENABLE == 1
1288  if (ECB_IsValid(pevent) != G_TRUE) G_DEBUG_WHILEFOREVER;
1289  if (TCB_IsValid(ptcb) != G_TRUE) G_DEBUG_WHILEFOREVER;
1290  #endif
1291 
1292  pevent->ECB_AssocTCB = (struct gs_tcb *) ptcb; /* Associate EVENT to the Task */
1293 
1294  pevent->ECB_NextTCBAEL = ptcb->TCB_NextTCBAEL; /* Associate TASK to EVENT */
1295  pevent->ECB_PrevTCBAEL = (struct gs_ecb *) 0;
1296  if (ptcb->TCB_NextTCBAEL != (struct gs_ecb *) 0) ptcb->TCB_NextTCBAEL->ECB_PrevTCBAEL = (struct gs_ecb *) pevent;
1297  ptcb->TCB_NextTCBAEL = (struct gs_ecb *) pevent;
1298  SAMPLE_FUNCTION_END(30)
1299  return(G_TRUE);
1300 }
1301 
1310 INT32 gk_TCBAEL_Unlink(GS_ECB *pevent)
1311 {
1312  SAMPLE_FUNCTION_BEGIN(31)
1313  int retorno = G_FALSE;
1314 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
1315  if (ECB_IsValid(pevent) != G_TRUE) G_DEBUG_WHILEFOREVER;
1316 #endif
1317  if (pevent->ECB_AssocTCB != (GS_TCB *)0)
1318  {
1319  if (pevent->ECB_PrevTCBAEL == (struct gs_ecb *) 0) {
1320  pevent->ECB_AssocTCB->TCB_NextTCBAEL = pevent->ECB_NextTCBAEL;
1321  }
1322  else {
1323  pevent->ECB_PrevTCBAEL->ECB_NextTCBAEL = pevent->ECB_NextTCBAEL;
1324  }
1325  if (pevent->ECB_NextTCBAEL != (struct gs_ecb *) 0) pevent->ECB_NextTCBAEL->ECB_PrevTCBAEL = pevent->ECB_PrevTCBAEL;
1326 
1327  /* Set the event unlink from task list */
1328  pevent->ECB_PrevTCBAEL = (struct gs_ecb *) 0;
1329  pevent->ECB_NextTCBAEL = (struct gs_ecb *) 0;
1330  pevent->ECB_AssocTCB = (struct gs_tcb *) 0;
1331  retorno = G_TRUE;
1332  }
1333  SAMPLE_FUNCTION_END(31)
1334  return(retorno);
1335 }
1336 
1346 INT32 gk_TCBASL_Link(GS_TCB *ptcb, GS_SCB *psignal)
1347 {
1348  SAMPLE_FUNCTION_BEGIN(32)
1349  INT32 priority = psignal->SCBType;
1350  GS_SCB *psignal1;
1351 
1352  if (ptcb->TCB_NextTCBASL == (struct gs_scb *) 0)
1353  {
1354  // it is the only SCB associated to pevent
1355  psignal->SCB_NextSCB = (struct gs_scb *) 0;
1356  ptcb->TCB_NextTCBASL = (struct gs_scb *) psignal;
1357  }
1358  else
1359  {
1360  if(ptcb->TCB_NextTCBASL->SCBType < priority)
1361  {
1362  // it is the first SCB associated to pevent
1363  psignal->SCB_NextSCB = ptcb->TCB_NextTCBASL;
1364  ptcb->TCB_NextTCBASL = (struct gs_scb *) psignal;
1365  }
1366  else
1367  {
1368  // Sort by priotiy
1369  psignal1 = ptcb->TCB_NextTCBASL;
1370  while (psignal1 != (struct gs_scb *) 0)
1371  {
1372  if (psignal1->SCB_NextSCB == (struct gs_scb *) 0)
1373  {
1374  // It is inserted as the last SCB
1375  psignal->SCB_NextSCB = (struct gs_scb *) 0;
1376  psignal1->SCB_NextSCB = (struct gs_scb *) psignal;
1377  psignal1 = (struct gs_scb *) 0;
1378  }
1379  else
1380  {
1381  if (psignal1->SCB_NextSCB->SCBType > priority)
1382  {
1383  psignal->SCB_NextSCB = psignal1->SCB_NextSCB;
1384  psignal1->SCB_NextSCB = (struct gs_scb *) psignal;
1385  psignal1 = (struct gs_scb *) 0;
1386  }
1387  else
1388  {
1389  // Keep searching
1390  psignal1 = psignal1->SCB_NextSCB;
1391  }
1392  }
1393  }
1394  }
1395  }
1396  psignal->SCBState = G_SCBState_IN_TCB;
1397  SAMPLE_FUNCTION_END(32)
1398  return(G_TRUE);
1399 }
1400 
1411 INT32 gk_TCBASL_Unlink(GS_TCB *ptcb, GS_SCB *psignal)
1412 {
1413  SAMPLE_FUNCTION_BEGIN(33)
1414  GS_SCB *psignal1;
1415 
1416 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
1417  if (psignal->SCBState == G_SCBState_UNLINKED) G_DEBUG_WHILEFOREVER;
1418 #endif
1419 
1420  if (ptcb->TCB_NextTCBASL != (struct gs_scb *) 0)
1421  {
1422  if (ptcb->TCB_NextTCBASL == psignal)
1423  {
1424  ptcb->TCB_NextTCBASL = psignal->SCB_NextSCB;
1425  }
1426  else
1427  {
1428  psignal1 = ptcb->TCB_NextTCBASL;
1429  while (psignal1 != (struct gs_scb *) 0)
1430  {
1431  if (psignal1->SCB_NextSCB == psignal)
1432  {
1433  psignal1->SCB_NextSCB = psignal->SCB_NextSCB;
1434  psignal1 = (struct gs_scb *) 0;
1435  }
1436  else
1437  {
1438  psignal1 = psignal1->SCB_NextSCB;
1439  }
1440  }
1441  }
1442  psignal->SCBState = G_SCBState_UNLINKED;
1443  }
1444 
1445 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
1446  if (psignal->SCBState != G_SCBState_UNLINKED) G_DEBUG_WHILEFOREVER;
1447 #endif
1448  SAMPLE_FUNCTION_END(33)
1449  return G_TRUE;
1450 }
1451 
1460 INT32 gk_TCB_List_Unlink(GS_TCB *ptcb)
1461 {
1462  SAMPLE_FUNCTION_BEGIN(34)
1463  GS_SCB *psignal1;
1464  GS_ECB *pevent1;
1465 
1466  // GS_ECB *pevent;
1467  // GS_ECB *peventime;
1468 
1469  // Remove SCB from ASL
1470  while (ptcb->TCB_NextTCBASL != (struct gs_scb *) 0)
1471  {
1472  psignal1 = ptcb->TCB_NextTCBASL;
1473  gk_TCBASL_Unlink(ptcb, psignal1);
1474  gk_SCBFL_Link(psignal1);
1475  }
1476 
1477  // Remove SCB from PSL
1478  while (ptcb->TCB_NextTCBPSL != (struct gs_scb *) 0)
1479  {
1480  psignal1 = ptcb->TCB_NextTCBPSL;
1481  gk_TCBPSL_Unlink(ptcb, psignal1);
1482  gk_SCBFL_Link(psignal1);
1483  }
1484 
1485  // Remove ECB from AEL
1486  // UNGRANT and UNWAIT resouce related event
1487  pevent1 = ptcb->TCB_NextTCBAEL;
1488  while (pevent1 != (struct gs_ecb *) 0)
1489  {
1490  gk_RESOURCE_ECB_KILL_CALLBACK((GS_ECB *) pevent1);
1491  pevent1 = ptcb->TCB_NextTCBAEL;
1492  }
1493  SAMPLE_FUNCTION_END(34)
1494  return(G_TRUE);
1495 }
1496 
1504 INT32 gk_TCBFL_Link(GS_TCB *ptcb)
1505 {
1506  SAMPLE_FUNCTION_BEGIN(35)
1507  // GS_SCB *psignal1;
1508 
1509 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
1510  if (TCB_IsValid(ptcb) != G_TRUE) G_DEBUG_WHILEFOREVER;
1511  if (ptcb->TCBState != G_TCBState_UNLINKED) G_DEBUG_WHILEFOREVER;
1512 #endif
1513 
1514  /* Remove the links from TCB */
1515  gk_TCB_List_Unlink(ptcb);
1516 
1518  if (g_kcb.KCB_ROOT_TCBs != (struct gs_tcb *) ptcb) ptcb->TCB_PREV_TCBs->TCB_NEXT_TCBs = ptcb->TCB_NEXT_TCBs;
1519  else g_kcb.KCB_ROOT_TCBs = ptcb->TCB_NEXT_TCBs;
1520  if (ptcb->TCB_NEXT_TCBs != (struct gs_tcb *) 0) ptcb->TCB_NEXT_TCBs->TCB_PREV_TCBs = ptcb->TCB_PREV_TCBs;
1521 
1523  free(ptcb->malloc_address);
1524  g_kcb.KCB_NUMBER_OF_TCBs--;
1525 
1526 
1527  G_DEBUG_VERBOSE
1528 
1529  SAMPLE_FUNCTION_END(35)
1530  return(G_TRUE);
1531 }
1532 
1533 
1543 INT32 gk_TCBPSL_Link(GS_TCB *ptcb, GS_SCB *psignal)
1544 {
1545  SAMPLE_FUNCTION_BEGIN(37)
1546  INT32 priority;
1547  GS_SCB *psignal1;
1548 
1549  priority = psignal->SCBPriority;
1550  if ((ptcb->TCB_NextTCBPSL == (struct gs_scb *) 0))
1551  {
1552  psignal->SCB_NextSCB = (struct gs_scb *) 0;
1553  ptcb->TCB_NextTCBPSL = (struct gs_scb *) psignal;
1554  }
1555  else
1556  {
1557  if (ptcb->TCB_NextTCBPSL->SCBPriority > priority)
1558  {
1559  psignal->SCB_NextSCB = ptcb->TCB_NextTCBPSL;
1560  ptcb->TCB_NextTCBPSL = (struct gs_scb *) psignal;
1561  }
1562  else
1563  {
1564  psignal1 = ptcb->TCB_NextTCBPSL;
1565  while (psignal1 != (struct gs_scb *) 0)
1566  {
1567  if (psignal1->SCB_NextSCB == (struct gs_scb *) 0)
1568  {
1569  // It is inserted as the last SCB
1570  psignal->SCB_NextSCB = (struct gs_scb *) 0;
1571  psignal1->SCB_NextSCB = (struct gs_scb *) psignal;
1572  psignal1 = (struct gs_scb *) 0;
1573  }
1574  else
1575  {
1576  if (psignal1->SCB_NextSCB->SCBPriority > priority)
1577  {
1578  psignal->SCB_NextSCB = psignal1->SCB_NextSCB;
1579  psignal1->SCB_NextSCB = (struct gs_scb *) psignal;
1580  psignal1 = (struct gs_scb *) 0;
1581  }
1582  else
1583  {
1584  // Keep searching
1585  psignal1 = psignal1->SCB_NextSCB;
1586  }
1587  }
1588  }
1589  }
1590  }
1591  psignal->SCBState = G_SCBState_PENDING;
1592  SAMPLE_FUNCTION_END(37)
1593  return(G_TRUE);
1594 }
1595 
1606 INT32 gk_TCBPSL_Unlink(GS_TCB *ptcb, GS_SCB *psignal)
1607 {
1608  SAMPLE_FUNCTION_BEGIN(38)
1609  GS_SCB *psignal1;
1610 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
1611  if (psignal->SCBState == G_SCBState_UNLINKED) G_DEBUG_WHILEFOREVER;
1612 #endif
1613  if (ptcb->TCB_NextTCBPSL != (struct gs_scb *) 0)
1614  {
1615  if (ptcb->TCB_NextTCBPSL == psignal)
1616  {
1617  ptcb->TCB_NextTCBPSL = psignal->SCB_NextSCB;
1618  }
1619  else
1620  {
1621  psignal1 = ptcb->TCB_NextTCBPSL;
1622  while (psignal1 != (struct gs_scb *) 0)
1623  {
1624  if (psignal1->SCB_NextSCB == psignal)
1625  {
1626  psignal1->SCB_NextSCB = psignal->SCB_NextSCB;
1627  psignal1 = (struct gs_scb *) 0;
1628  }
1629  else
1630  {
1631  psignal1 = psignal1->SCB_NextSCB;
1632  }
1633  }
1634  }
1635  psignal->SCBState = G_SCBState_UNLINKED;
1636  }
1637 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
1638  if (psignal->SCBState != G_SCBState_UNLINKED) G_DEBUG_WHILEFOREVER;
1639 #endif
1640  SAMPLE_FUNCTION_END(38)
1641  return G_TRUE;
1642 
1643 }
1644 
1653 INT32 gk_TCBRDYL_Link(GS_TCB *ptcb)
1654 {
1655  SAMPLE_FUNCTION_BEGIN(39)
1656  GS_TCB *ptcb1;
1657 
1658  GS_LCB *readylist = ptcb->TCB_RDY_LCB_Index; PRINT_DEBUG_LINE
1659  // int i; PRINT_DEBUG_LINE
1660 
1661 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
1662  if (TCB_IsValid(ptcb) != G_TRUE) G_DEBUG_WHILEFOREVER; PRINT_DEBUG_LINE
1663  if (ptcb->TCBState != G_TCBState_UNLINKED) G_DEBUG_WHILEFOREVER; PRINT_DEBUG_LINE
1664 #endif
1665  G_DEBUG_VERBOSE
1666  gk_TASK_PRIORITY_SET(ptcb, G_TCBState_READY); PRINT_DEBUG_LINE
1667 
1668  if (ptcb->TCBType != G_TCBType_IDLE) /* Idle task are not inserted in Ready Lists */
1669  {
1670  if (readylist->LCB_NextTCBRDYL == (struct gs_tcb *) 0)
1671  {// It is the first TCB to insert
1672  ptcb->TCB_NextTCB = (struct gs_tcb *) 0; PRINT_DEBUG_LINE
1673  ptcb->TCB_PrevTCB = (struct gs_tcb *) 0; PRINT_DEBUG_LINE
1674  readylist->LCB_NextTCBRDYL = (struct gs_tcb *) ptcb; PRINT_DEBUG_LINE
1675  }
1676  else
1677  {
1678  if (readylist->LCB_NextTCBRDYL->TCBCurrentPriority > ptcb->TCBCurrentPriority) { /* Task inserted is the highest priority one */
1679  ptcb->TCB_NextTCB = readylist->LCB_NextTCBRDYL ; PRINT_DEBUG_LINE
1680  ptcb->TCB_PrevTCB = (struct gs_tcb *) 0; PRINT_DEBUG_LINE
1681  ptcb->TCB_NextTCB->TCB_PrevTCB = (struct gs_tcb *) ptcb; PRINT_DEBUG_LINE
1682  readylist->LCB_NextTCBRDYL = (struct gs_tcb *) ptcb; PRINT_DEBUG_LINE
1683  } else {
1684  ptcb1 = readylist->LCB_NextTCBRDYL; PRINT_DEBUG_LINE
1685  while (ptcb1 != (struct gs_tcb *) 0)
1686  {
1687 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
1688  if (TCB_IsValid(ptcb1) != G_TRUE) G_DEBUG_WHILEFOREVER; PRINT_DEBUG_LINE
1689 #endif
1690  if (ptcb1->TCB_NextTCB == (struct gs_tcb *) 0){ /* It has to be inserted as the last element */
1691  ptcb->TCB_NextTCB = (struct gs_tcb *) 0; PRINT_DEBUG_LINE
1692  ptcb->TCB_PrevTCB = (struct gs_tcb *) ptcb1; PRINT_DEBUG_LINE
1693  ptcb1->TCB_NextTCB = (struct gs_tcb *) ptcb; PRINT_DEBUG_LINE
1694  ptcb1 = (struct gs_tcb *) 0; PRINT_DEBUG_LINE /* to exit the while */
1695  }
1696  else
1697  {
1698  if (ptcb1->TCB_NextTCB->TCBCurrentPriority > ptcb->TCBCurrentPriority){
1699  /* It has to be inserted before next */
1700  ptcb->TCB_NextTCB = ptcb1->TCB_NextTCB; PRINT_DEBUG_LINE
1701  ptcb->TCB_PrevTCB = (struct gs_tcb *) ptcb1; PRINT_DEBUG_LINE
1702  ptcb->TCB_NextTCB->TCB_PrevTCB = (struct gs_tcb *) ptcb; PRINT_DEBUG_LINE
1703  ptcb1->TCB_NextTCB = (struct gs_tcb *) ptcb; PRINT_DEBUG_LINE
1704  ptcb1 = (struct gs_tcb *) 0; PRINT_DEBUG_LINE /* to exit the while */
1705  }
1706  else
1707  {
1708  ptcb1 = (GS_TCB *) ptcb1->TCB_NextTCB; PRINT_DEBUG_LINE
1709  }
1710  }
1711  }
1712  }
1713  }
1714  }
1715  ptcb->TCB_AssocPCB = (INT32) 0; PRINT_DEBUG_LINE
1716  ptcb->TCBState = G_TCBState_READY; PRINT_DEBUG_LINE
1717  // Check if Inversion occurs !!!!!!!!!!!
1719  if (readylist->LCB_NextLCBFPL != (struct gs_pcb *) 0)
1720  {
1721  if (readylist->LCB_NextLCBFPL->PCBID != GRTOS_CMD_PRC_ID ) {
1722  // fprintf(stderr, "[ OK ] Processor %d trigger proc %d in %s, %d\n", GRTOS_CMD_PRC_ID, i, __FUNCTION__,__LINE__);
1723  GRTOS_CMD_PRC_INT(readylist->LCB_NextLCBFPL->PCBID);
1724  }
1725  }
1726  //gk_LCB_CheckInvertion(readylist); PRINT_DEBUG_LINE
1727  G_DEBUG_VERBOSE; PRINT_DEBUG_LINE // Print Debug information
1728  SAMPLE_FUNCTION_END(39)
1729  return(G_TRUE);
1730 }
1731 
1740 INT32 gk_TCBRDYL_Unlink(GS_TCB *ptcb)
1741 {
1742  SAMPLE_FUNCTION_BEGIN(40)
1743  GS_LCB *readylist = ptcb->TCB_RDY_LCB_Index; PRINT_DEBUG_LINE
1744 
1745 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
1746  if (TCB_IsValid(ptcb) != G_TRUE) G_DEBUG_WHILEFOREVER; PRINT_DEBUG_LINE
1747  if ((TCB_IsValid(readylist->LCB_NextTCBRDYL) != G_TRUE && readylist->LCB_NextTCBRDYL != 0) ||
1748  (readylist->LCB_NextTCBRDYL == (struct gs_tcb *) 0 && ptcb->TCBType != G_TCBType_IDLE)) G_DEBUG_WHILEFOREVER; PRINT_DEBUG_LINE
1749  if (ptcb->TCBState != G_TCBState_READY) G_DEBUG_WHILEFOREVER; PRINT_DEBUG_LINE
1750 #endif
1751 
1752  if (ptcb->TCBType != G_TCBType_IDLE) /* Task Idle is not inserted in ready lists */
1753  {
1754  if (readylist->LCB_NextTCBRDYL == ptcb) /* It is the first ready task */
1755  {
1756  readylist->LCB_NextTCBRDYL = (struct gs_tcb *) ptcb->TCB_NextTCB; PRINT_DEBUG_LINE
1757  if (ptcb->TCB_NextTCB != (GS_TCB *)0) ptcb->TCB_NextTCB->TCB_PrevTCB = (struct gs_tcb *) 0; PRINT_DEBUG_LINE
1758  }
1759  else
1760  {/* It is not the first one */
1761  if (ptcb->TCB_NextTCB != (GS_TCB *)0) ptcb->TCB_NextTCB->TCB_PrevTCB = ptcb->TCB_PrevTCB; PRINT_DEBUG_LINE
1762  ptcb->TCB_PrevTCB->TCB_NextTCB = ptcb->TCB_NextTCB; PRINT_DEBUG_LINE
1763  }
1764  }
1765 
1766  ptcb->TCBState = G_TCBState_UNLINKED; PRINT_DEBUG_LINE
1767 
1768 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
1769  if (TCB_IsValid(readylist->LCB_NextTCBRDYL) != G_TRUE &&
1770  readylist->LCB_NextTCBRDYL != (struct gs_tcb *) 0) G_DEBUG_WHILEFOREVER; PRINT_DEBUG_LINE
1771 #endif
1772  // Check if Inversion occurs !!!!
1773  //gk_LCB_CheckInvertion(readylist); PRINT_DEBUG_LINE
1774  SAMPLE_FUNCTION_END(40)
1775  return(G_TRUE);
1776 }
1777 
1786 INT32 gk_TCBRUNL_Link(GS_TCB *ptcb)
1787 {
1788  SAMPLE_FUNCTION_BEGIN(41)
1789  GS_TCB *ptcb1;
1790  GS_LCB *RunList = ptcb->TCB_RDY_LCB_Index; PRINT_DEBUG_LINE
1791  ptcb1 = RunList->LCB_NextTCBRUNL; PRINT_DEBUG_LINE
1792 
1793 
1794 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
1795  if (TCB_IsValid(ptcb1) != G_TRUE && ptcb1 != (struct gs_tcb *) 0) G_DEBUG_WHILEFOREVER; PRINT_DEBUG_LINE
1796  if ((TCB_IsValid(ptcb) != G_TRUE) && (ptcb != (struct gs_tcb *) 0))G_DEBUG_WHILEFOREVER; PRINT_DEBUG_LINE
1797  G_DEBUG_VERBOSE
1798  if (ptcb->TCBState != G_TCBState_UNLINKED) G_DEBUG_WHILEFOREVER; PRINT_DEBUG_LINE
1799 #endif
1800 
1801 
1802  gk_TASK_PRIORITY_SET(ptcb, G_TCBState_RUNNING); PRINT_DEBUG_LINE
1803 
1804  /* Set the current processor as the processor associated of the task */
1805  ptcb->TCB_AssocPCB = (INT32) GRTOS_CMD_PRC_ID; PRINT_DEBUG_LINE
1806 
1807  if (RunList->LCB_NextTCBRUNL == (struct gs_tcb *) 0) /* It is the first element in the running list */
1808  {
1809  RunList->LCBRunPriority = ptcb->TCBCurrentPriority; PRINT_DEBUG_LINE
1810  RunList->LCB_NextTCBRUNL = (struct gs_tcb *) ptcb; PRINT_DEBUG_LINE
1811  ptcb->TCB_NextTCB = (struct gs_tcb *) 0; PRINT_DEBUG_LINE
1812  ptcb->TCB_PrevTCB = (struct gs_tcb *) 0; PRINT_DEBUG_LINE
1813  gk_LCBL_UnLink(RunList); PRINT_DEBUG_LINE /* Unlink the LCB and link again to update the priority */
1814  gk_LCBL_Link(RunList); PRINT_DEBUG_LINE
1815  }
1816  else
1817  {
1818  ptcb1 = RunList->LCB_NextTCBRUNL; PRINT_DEBUG_LINE
1819  if (gk_TCBLowerPriorityThanTCB(ptcb, ptcb1) == G_TRUE) /* It has to be inserted as first element */
1820  {
1821  RunList->LCBRunPriority = ptcb->TCBCurrentPriority; PRINT_DEBUG_LINE
1822  ptcb->TCB_NextTCB = RunList->LCB_NextTCBRUNL; PRINT_DEBUG_LINE
1823  ptcb->TCB_PrevTCB = (struct gs_tcb *) 0; PRINT_DEBUG_LINE
1824  ptcb->TCB_NextTCB->TCB_PrevTCB = (struct gs_tcb *) ptcb; PRINT_DEBUG_LINE
1825  RunList->LCB_NextTCBRUNL = (struct gs_tcb *) ptcb; PRINT_DEBUG_LINE
1826  gk_LCBL_UnLink(RunList); PRINT_DEBUG_LINE /* Unlink the LCB and link again to update the priority */
1827  gk_LCBL_Link(RunList); PRINT_DEBUG_LINE
1828  }
1829  else
1830  {
1831  /* Search the place in the list to insert ptcb */
1832  while (ptcb1 != (struct gs_tcb *) 0)
1833  {
1834  if (ptcb1->TCB_NextTCB == (struct gs_tcb *) 0) { /* It has to be inserted as the last element */
1835  ptcb->TCB_NextTCB = (struct gs_tcb *) 0; PRINT_DEBUG_LINE
1836  ptcb->TCB_PrevTCB = (struct gs_tcb *) ptcb1; PRINT_DEBUG_LINE
1837  ptcb1->TCB_NextTCB = (struct gs_tcb *) ptcb; PRINT_DEBUG_LINE
1838  ptcb1 = (struct gs_tcb *) 0; PRINT_DEBUG_LINE /* to exit the while */
1839  }
1840  else
1841  {
1842  if (gk_TCBLowerPriorityThanTCB(ptcb, (GS_TCB *) ptcb1->TCB_NextTCB) == G_TRUE) { /* It has to be inserted before next */
1843  ptcb->TCB_NextTCB = ptcb1->TCB_NextTCB; PRINT_DEBUG_LINE
1844  ptcb->TCB_PrevTCB = (struct gs_tcb *) ptcb1; PRINT_DEBUG_LINE
1845  ptcb->TCB_NextTCB->TCB_PrevTCB = (struct gs_tcb *) ptcb; PRINT_DEBUG_LINE
1846  ptcb1->TCB_NextTCB = (struct gs_tcb *) ptcb; PRINT_DEBUG_LINE
1847  ptcb1 = (struct gs_tcb *) 0; PRINT_DEBUG_LINE /* to exit the while */
1848  }
1849  else
1850  {
1851  ptcb1 = (GS_TCB *) ptcb1->TCB_NextTCB; PRINT_DEBUG_LINE
1852  }
1853  }
1854  }
1855  }
1856  }
1857 
1858  ptcb->TCBState = G_TCBState_RUNNING; PRINT_DEBUG_LINE
1859  // Check if Inversion occurs !!!!!!!!!
1860  //gk_LCB_CheckInvertion(RunList); PRINT_DEBUG_LINE
1861  // Si no esta en la lista principal del procesador o es tarea idle, el procesador es puesto como libre
1862  if (ptcb->TCB_RDY_LCB_Index != g_kcb.G_PCBTbl[ptcb->TCB_AssocPCB-1].PCB_RDY_LCBL[0] || ptcb->TCBType == G_TCBType_IDLE)
1863  {
1864  if (g_kcb.G_PCBTbl[ptcb->TCB_AssocPCB-1].PCBState != GS_PCBState_FREE)
1865  gk_LCBFPL_Link(ptcb->TCB_AssocPCB); PRINT_DEBUG_LINE // Link the processor to the free list
1866  }
1867 
1868  // Si esta en la lista de ready principal del procesador, entocnes es sacado de la lista de libres
1869  if (ptcb->TCB_RDY_LCB_Index == g_kcb.G_PCBTbl[ptcb->TCB_AssocPCB-1].PCB_RDY_LCBL[0])
1870  {
1871  if (g_kcb.G_PCBTbl[ptcb->TCB_AssocPCB-1].PCBState == GS_PCBState_FREE)
1872  gk_LCBFPL_Unlink(ptcb->TCB_AssocPCB); PRINT_DEBUG_LINE // Unlink the processor from the free list
1873  }
1874 
1875  /***********************************************/
1876  /* Set the processor to ptcb */
1877  G_DEBUG_VERBOSE
1878 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
1879  int i;
1880  g_kcb.G_PCBTbl[GRTOS_CMD_PRC_ID -1].PCB_EXECTCB = (struct gs_tcb *) 0; /* just to check no duplication */
1881  if (TCB_IsValid(ptcb) != G_TRUE) {PRINT_TO_DEBUG("ERROR TCB= %p\n",ptcb); G_DEBUG_WHILEFOREVER;}
1882  for (i=0; i<G_NUMBER_OF_PCB;i++){
1883  if (g_kcb.G_PCBTbl[i].PCB_EXECTCB == ptcb) {
1884  PRINT_TO_DEBUG("ERROR %s, %s, %d, pi %x, tcb %p, ptcb %p, proc %x, mtx %x\n",__FUNCTION__,__FILE__,__LINE__, i, g_kcb.G_PCBTbl[i].PCB_EXECTCB, ptcb, GRTOS_CMD_PRC_ID, GRTOS_MTX_PRC_GRANTED);
1885  PRINT_TO_DEBUG("ERROR %s, %s, %d, pi %x, tcb %p, ptcb %p, proc %x, mtx %x\n",__FUNCTION__,__FILE__,__LINE__, i, g_kcb.G_PCBTbl[i].PCB_EXECTCB, ptcb, GRTOS_CMD_PRC_ID, GRTOS_MTX_PRC_GRANTED);
1886  G_DEBUG_WHILEFOREVER;
1887  }
1888  }
1889  if ((ptcb->TCB_StackPointer < ptcb->TCB_StackTop - 300) || (ptcb->TCB_StackPointer > ptcb->TCB_StackBottom)) {
1890  PRINT_TO_DEBUG("ERROR TCB= %p, TCB_StackBottom = %p, TCB_StackPointer = %p, TCB_StackTop = %p\n",ptcb, (void *) ptcb->TCB_StackBottom, (void *) ptcb->TCB_StackPointer, (void *) ptcb->TCB_StackTop);
1891  PRINT_TO_DEBUG("ERROR TCB_IDLE= %p\n", (void *) g_kcb.G_PCBTbl[GRTOS_CMD_PRC_ID -1].PCB_IDLETCB );
1892  G_DEBUG_WHILEFOREVER; }
1893 #endif
1894 
1895  g_kcb.G_PCBTbl[GRTOS_CMD_PRC_ID -1].PCB_EXECTCB = (struct gs_tcb *) ptcb;
1896  ptcb->TCB_AssocPCB = GRTOS_CMD_PRC_ID;
1897  if (g_kcb.G_PCBTbl[GRTOS_CMD_PRC_ID -1].PCB_RDY_LCBL[0] == ptcb->TCB_RDY_LCB_Index) { /* processor is not idle */
1898  gk_LCBFPL_Unlink(GRTOS_CMD_PRC_ID);
1899  }
1900  else { /* processor is idle */
1901  gk_LCBFPL_Link(GRTOS_CMD_PRC_ID);
1902  }
1903  SAMPLE_FUNCTION_END(41)
1904  return(G_TRUE);
1905 }
1906 
1915 INT32 gk_TCBRUNL_Unlink(GS_TCB *ptcb)
1916 {
1917  SAMPLE_FUNCTION_BEGIN(42)
1918 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
1919  if (TCB_IsValid(ptcb) != G_TRUE) G_DEBUG_WHILEFOREVER; PRINT_DEBUG_LINE
1920  if (ptcb->TCBState != G_TCBState_RUNNING) G_DEBUG_WHILEFOREVER; PRINT_DEBUG_LINE
1921  if (ptcb->TCBState == G_TCBState_UNLINKED) G_DEBUG_WHILEFOREVER; PRINT_DEBUG_LINE
1922 #endif
1923 
1924  GS_LCB *RunList = ptcb->TCB_RDY_LCB_Index; PRINT_DEBUG_LINE
1925 
1926 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
1927  if (TCB_IsValid(RunList->LCB_NextTCBRUNL) != G_TRUE) G_DEBUG_WHILEFOREVER; PRINT_DEBUG_LINE
1928  if (ptcb->TCB_AssocPCB < 1 || ptcb->TCB_AssocPCB > G_NUMBER_OF_PCB) G_DEBUG_WHILEFOREVER; PRINT_DEBUG_LINE
1929 #endif
1930 
1931 
1933  if (ptcb->TCB_AssocPCB != GRTOS_CMD_PRC_ID ) {
1934  // fprintf(stderr, "[ OK ] Processor %d trigger proc %d in %s, %d\n", GRTOS_CMD_PRC_ID, ptcb->TCB_AssocPCB, __FUNCTION__,__LINE__);
1935  GRTOS_CMD_PRC_INT(ptcb->TCB_AssocPCB);
1936  }
1937  if (g_kcb.G_PCBTbl[ptcb->TCB_AssocPCB-1].PCBState != GS_PCBState_FREE)
1938  gk_LCBFPL_Link(ptcb->TCB_AssocPCB); PRINT_DEBUG_LINE // Link processor to free list
1939 
1940 
1941  /* Runs in background or it is an IDLE TCB, then unlink processor from Free List */
1942  //if (ptcb->TCB_RDY_LCB_Index != g_kcb.G_PCBTbl[ptcb->TCB_AssocPCB-1].PCB_RDY_LCBL[0] ||
1943  // ptcb->TCBType == G_TCBType_IDLE) gk_LCBFPL_Unlink(ptcb->TCB_AssocPCB); PRINT_DEBUG_LINE
1944 
1945 
1946  if (RunList->LCB_NextTCBRUNL == ptcb){ // checks if it is the first TCP in RUNNING LIST
1947  RunList->LCB_NextTCBRUNL = (GS_TCB *) ptcb->TCB_NextTCB; PRINT_DEBUG_LINE
1948  if (RunList->LCB_NextTCBRUNL != (struct gs_tcb *) 0) /* It is not the only element */
1949  {
1950  RunList->LCB_NextTCBRUNL->TCB_PrevTCB = (struct gs_tcb *) 0; PRINT_DEBUG_LINE
1951  RunList->LCBRunPriority = ptcb->TCBCurrentPriority; PRINT_DEBUG_LINE
1952  }
1953  else
1954  {/* The list will be empty therefore lowest priority */
1955  RunList->LCBRunPriority = G_LOWEST_PRIORITY; PRINT_DEBUG_LINE
1956  }
1957  /* Unlink the LCB and link again to update the priority */
1958  gk_LCBL_UnLink(RunList); PRINT_DEBUG_LINE
1959  gk_LCBL_Link(RunList); PRINT_DEBUG_LINE
1960  }
1961  else
1962  {
1963  /* It is not the first element in the list */
1964  ptcb->TCB_PrevTCB->TCB_NextTCB = ptcb->TCB_NextTCB; PRINT_DEBUG_LINE
1965  if (ptcb->TCB_NextTCB != (GS_TCB *)0) ptcb->TCB_NextTCB->TCB_PrevTCB = ptcb->TCB_PrevTCB; PRINT_DEBUG_LINE
1966  }
1967 
1968  // g_kcb.G_PCBTbl[ptcb->TCB_AssocPCB-1].PCB_EXECTCB = g_kcb.G_PCBTbl[ptcb->TCB_AssocPCB-1].PCB_IDLETCB; PRINT_DEBUG_LINE
1969  // g_kcb.G_PCBTbl[ptcb->TCB_AssocPCB-1].PCB_IDLETCB->TCBState = G_TCBState_RUNNING; PRINT_DEBUG_LINE
1970 
1971  /* Desassociate the task from the processor */
1972  g_kcb.G_PCBTbl[ptcb->TCB_AssocPCB-1].PCB_EXECTCB = (struct gs_tcb *) 0;
1973  ptcb->TCB_AssocPCB = (INT32) 0; PRINT_DEBUG_LINE
1974  ptcb->TCBState = G_TCBState_UNLINKED; PRINT_DEBUG_LINE
1975  // Check if Inversion occurs
1976  //gk_LCB_CheckInvertion(RunList); PRINT_DEBUG_LINE
1977  SAMPLE_FUNCTION_END(42)
1978  return(G_TRUE);
1979 }
1980 
1990 INT32 gk_TCBWL_Link(GS_TCB *ptcb, unsigned int state)
1991 {
1992  SAMPLE_FUNCTION_BEGIN(43)
1993 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
1994  if (TCB_IsValid(ptcb) != G_TRUE) G_DEBUG_WHILEFOREVER;
1995  if (ptcb->TCBState != G_TCBState_UNLINKED)G_DEBUG_WHILEFOREVER;
1996 #endif
1997 
1998  // int i;
1999 
2000  /* Insert the task in the Waiting List */
2001  ptcb->TCB_NextTCB = g_kcb.KCB_NextTCBWL;
2002  ptcb->TCB_PrevTCB = (struct gs_tcb *) 0;
2003 
2004  if (g_kcb.KCB_NextTCBWL != (struct gs_tcb *) 0) g_kcb.KCB_NextTCBWL->TCB_PrevTCB = (struct gs_tcb *) ptcb;
2005 
2006  g_kcb.KCB_NextTCBWL = (struct gs_tcb *) ptcb;
2007  ptcb->TCBState = state;
2008  SAMPLE_FUNCTION_END(43)
2009  return(G_TRUE);
2010 }
2011 
2020 INT32 gk_TCBWL_Unlink(GS_TCB *ptcb)
2021 {
2022  SAMPLE_FUNCTION_BEGIN(44)
2023 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
2024  if (TCB_IsValid(ptcb) != G_TRUE) G_DEBUG_WHILEFOREVER;
2025  if (!GRTOS_TASK_STATE_WAITING(ptcb)) G_DEBUG_WHILEFOREVER;
2026 #endif
2027 
2028  if (g_kcb.KCB_NextTCBWL == ptcb) g_kcb.KCB_NextTCBWL = (GS_TCB *) ptcb->TCB_NextTCB;
2029  else ptcb->TCB_PrevTCB->TCB_NextTCB = ptcb->TCB_NextTCB;
2030 
2031  if (ptcb->TCB_NextTCB != (struct gs_tcb *) 0) ptcb->TCB_NextTCB->TCB_PrevTCB = ptcb->TCB_PrevTCB;
2032 
2033  ptcb->TCBState = G_TCBState_UNLINKED;
2034  SAMPLE_FUNCTION_END(44)
2035  return(G_TRUE);
2036 }
2037 
2046 INT32 gk_TASK_IS_BLOCKED(GS_TCB *ptcb)
2047 {
2048  SAMPLE_FUNCTION_BEGIN(45)
2049  GS_ECB *pevent; PRINT_DEBUG_LINE
2050  INT32 return_int; PRINT_DEBUG_LINE
2051 
2052  return_int = G_FALSE; PRINT_DEBUG_LINE
2053 
2054  pevent = ptcb->TCB_NextTCBAEL; PRINT_DEBUG_LINE
2055 
2056  while (pevent != (struct gs_ecb *) 0)
2057  {
2058  /* GET THE TYPE OF THE EVENT */
2059  switch (pevent->ECBState)
2060  {
2061  /* It is a Waiting for resource Event *****************************/
2062  case GS_ECBState_WAITING_RESOURCE:
2063  return_int = G_TRUE; PRINT_DEBUG_LINE
2064  break;
2065  }
2066  pevent = pevent->ECB_NextECB; PRINT_DEBUG_LINE
2067  }
2068  SAMPLE_FUNCTION_END(45)
2069  return return_int;
2070 }
2071 
2081 GS_ECB *gk_TCB_in_RCBGEL(G_RCB *presource, GS_TCB *ptcb)
2082 {
2083  SAMPLE_FUNCTION_BEGIN(46)
2084  GS_ECB *pevent; PRINT_DEBUG_LINE
2085 
2086  pevent = presource->RCB_NextRCBGEL; PRINT_DEBUG_LINE
2087  while ((pevent != (struct gs_ecb *) 0)) {
2088  // if(pevent->ECB_AssocTCB == ptcb) return(pevent);
2089  if(pevent->ECB_AssocTCB == ptcb) break;
2090  pevent = pevent->ECB_NextECB; PRINT_DEBUG_LINE
2091  }
2092  SAMPLE_FUNCTION_END(46)
2093  return(pevent);
2094 }
2095 
2105 INT32 gk_RRDSFL_Link(GS_RRDS *prrds)
2106 {
2107  SAMPLE_FUNCTION_BEGIN(47)
2108  GS_SCB *psignal1;
2109 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
2110  fprintf(stderr,"[ MESSAGE ] Remove SCB from ASL\n");
2111 #endif
2112  // Remove SCB from ASL
2113  while (prrds->RRDS_NextSCB != (struct gs_scb *) 0)
2114  {
2115  psignal1 = prrds->RRDS_NextSCB;
2116  gk_RRDSASL_UnLink(prrds, psignal1);
2117  gk_SCBFL_Link(psignal1);
2118  }
2119 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
2120  fprintf(stderr,"[ MESSAGE ] Insert the RRDS in the Free RRDS List\n");
2121 #endif
2122 
2124  if (g_kcb.KCB_ROOT_RRDSs != (struct gs_rrds *) prrds) prrds->RRDS_PREV_RRDSs->RRDS_NEXT_RRDSs = prrds->RRDS_NEXT_RRDSs;
2125  else g_kcb.KCB_ROOT_RRDSs = prrds->RRDS_NEXT_RRDSs;
2126  if (prrds->RRDS_NEXT_RRDSs != (struct gs_rrds *) 0) prrds->RRDS_NEXT_RRDSs->RRDS_PREV_RRDSs = prrds->RRDS_PREV_RRDSs;
2127 
2128  free(prrds->malloc_address);
2129  g_kcb.KCB_NUMBER_OF_RRDSs-- ;
2130 
2131  SAMPLE_FUNCTION_END(47)
2132  return(G_TRUE);
2133 }
2134 
2143 INT32 gk_RRDSASL_Link(GS_RRDS *prrds, GS_SCB *psignal)
2144 {
2145  SAMPLE_FUNCTION_BEGIN(49)
2146  INT32 priority = psignal->SCBType;
2147  GS_SCB *psignal1;
2148 
2149  if (prrds->RRDS_NextSCB == (struct gs_scb *) 0)
2150  {
2151  // it is the only SCB associated to pevent
2152  psignal->SCB_NextSCB = (struct gs_scb *) 0;
2153  prrds->RRDS_NextSCB = (struct gs_scb *) psignal;
2154  }
2155  else
2156  {
2157  if(prrds->RRDS_NextSCB->SCBType < priority)
2158  {
2159  // it is the first SCB associated to pevent
2160  psignal->SCB_NextSCB = prrds->RRDS_NextSCB;
2161  prrds->RRDS_NextSCB = (struct gs_scb *) psignal;
2162  }
2163  else
2164  {
2165  // Sort by priotiy
2166  psignal1 = prrds->RRDS_NextSCB;
2167  while (psignal1 != (struct gs_scb *) 0)
2168  {
2169  if (psignal1->SCB_NextSCB == (struct gs_scb *) 0)
2170  {
2171  // It is inserted as the last SCB
2172  psignal->SCB_NextSCB = (struct gs_scb *) 0;
2173  psignal1->SCB_NextSCB = (struct gs_scb *) psignal;
2174  psignal1 = (struct gs_scb *) 0;
2175  }
2176  else
2177  {
2178  if (psignal1->SCB_NextSCB->SCBType > priority)
2179  {
2180  psignal->SCB_NextSCB = psignal1->SCB_NextSCB;
2181  psignal1->SCB_NextSCB = (struct gs_scb *) psignal;
2182  psignal1 = (struct gs_scb *) 0;
2183  }
2184  else
2185  {
2186  // Keep searching
2187  psignal1 = psignal1->SCB_NextSCB;
2188  }
2189  }
2190  }
2191  }
2192  }
2193  psignal->SCBState = G_SCBState_IN_TCB;
2194  SAMPLE_FUNCTION_END(49)
2195  return(G_TRUE);
2196 }
2197 
2207 INT32 gk_RRDSASL_UnLink(GS_RRDS *prrds, GS_SCB *psignal)
2208 {
2209  SAMPLE_FUNCTION_BEGIN(50)
2210  GS_SCB *psignal1;
2211 
2212 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
2213  if (psignal->SCBState == G_SCBState_UNLINKED) G_DEBUG_WHILEFOREVER;
2214 #endif
2215 
2216  if (prrds->RRDS_NextSCB != (struct gs_scb *) 0)
2217  {
2218  if (prrds->RRDS_NextSCB == psignal)
2219  {
2220  prrds->RRDS_NextSCB = psignal->SCB_NextSCB;
2221  }
2222  else
2223  {
2224  psignal1 = prrds->RRDS_NextSCB;
2225  while (psignal1 != (struct gs_scb *) 0)
2226  {
2227  if (psignal1->SCB_NextSCB == psignal)
2228  {
2229  psignal1->SCB_NextSCB = psignal->SCB_NextSCB;
2230  psignal1 = (struct gs_scb *) 0;
2231  }
2232  else
2233  {
2234  psignal1 = psignal1->SCB_NextSCB;
2235  }
2236  }
2237  }
2238  psignal->SCBState = G_SCBState_UNLINKED;
2239  }
2240 
2241 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
2242  if (psignal->SCBState != G_SCBState_UNLINKED) G_DEBUG_WHILEFOREVER;
2243 #endif
2244  SAMPLE_FUNCTION_END(50)
2245  return(G_TRUE);
2246 }
2247 
2248 /***********************************************************************************
2249 *********************** GRTOS INTERNAL FUNCTIONS *********************************
2250 ***********************************************************************************/
2262 GS_TCB *gk_PCB_GetCurrentTCB(void)
2263 {
2264  SAMPLE_FUNCTION_BEGIN(51)
2265  #if G_DEBUG_WHILEFOREVER_ENABLE == 1
2266  if (TCB_IsValid(g_kcb.G_PCBTbl[GRTOS_CMD_PRC_ID -1].PCB_EXECTCB) != G_TRUE && g_kcb.G_PCBTbl[GRTOS_CMD_PRC_ID -1].PCB_EXECTCB != (struct gs_tcb *) 0) {
2267  PRINT_TO_DEBUG("g_kcb.G_PCBTbl[GRTOS_CMD_PRC_ID -1].PCB_EXECTCB = %p", (void *) g_kcb.G_PCBTbl[GRTOS_CMD_PRC_ID -1].PCB_EXECTCB)
2268  G_DEBUG_WHILEFOREVER;
2269  }
2270  #endif
2271  SAMPLE_FUNCTION_END(51)
2272  return(g_kcb.G_PCBTbl[GRTOS_CMD_PRC_ID -1].PCB_EXECTCB);
2273 }
2274 
2275 
2284 INT32 gk_LCBLowerPriorityThanLCB(GS_LCB *plcb1, GS_LCB *plcb2)
2285 {
2286  SAMPLE_FUNCTION_BEGIN(52)
2287  int retorno = G_FALSE;
2288 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
2289  if (LCB_IsValid(plcb1) != G_TRUE) G_DEBUG_WHILEFOREVER;
2290  if (LCB_IsValid(plcb2) != G_TRUE) G_DEBUG_WHILEFOREVER;
2291 #endif
2292  if ((plcb1->LCB_NextTCBRUNL != (struct gs_tcb *) 0) && (plcb2->LCB_NextTCBRUNL == (struct gs_tcb *) 0)) retorno = G_TRUE;
2293  if (((plcb1->LCB_NextTCBRUNL != (struct gs_tcb *) 0) && (plcb2->LCB_NextTCBRUNL != (struct gs_tcb *) 0)) &&
2294  (plcb1->LCBRunPriority > plcb2->LCBRunPriority)) retorno = G_TRUE;
2295  SAMPLE_FUNCTION_END(52)
2296  return(retorno);
2297 }
2298 
2307 INT32 gk_TCBLowerPriorityThanTCB(GS_TCB *ptcb1, GS_TCB *ptcb2)
2308 {
2309  SAMPLE_FUNCTION_BEGIN(53)
2310  int retorno = G_FALSE;
2311 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
2312  if (TCB_IsValid(ptcb1) != G_TRUE) G_DEBUG_WHILEFOREVER;
2313  if (TCB_IsValid(ptcb2) != G_TRUE) G_DEBUG_WHILEFOREVER;
2314 #endif
2315 
2316  if (ptcb1->TCBCurrentPriority > ptcb2->TCBCurrentPriority) retorno = G_TRUE;
2317  SAMPLE_FUNCTION_END(53)
2318  return(retorno);
2319 }
2320 
2321 
2333 GS_TCB *gk_PCB_GetNextTCB(void)
2334 {
2335  SAMPLE_FUNCTION_BEGIN(54)
2336  GS_TCB *ptcb = g_kcb.G_PCBTbl[GRTOS_CMD_PRC_ID -1].PCB_EXECTCB;
2337  GS_PCB *ppcb = &g_kcb.G_PCBTbl[GRTOS_CMD_PRC_ID -1];
2338  int i;
2339  // int run_main;
2340 
2341  // fprintf(stderr, "[ OK1 ] ptcb %p, IDLE %p, PCBState %d, ptcb->TCB_RDY_LCB_Index %d PCB_RDY_LCBL[0] %d in %s, %d\n", ptcb, ppcb->PCB_IDLETCB, ppcb->PCBState, ptcb->TCB_RDY_LCB_Index, g_kcb.G_PCBTbl[GRTOS_CMD_PRC_ID -1].PCB_RDY_LCBL[0], __FUNCTION__,__LINE__);
2342 
2343  if (ppcb->PCBState == GS_PCBState_FREE) { // It is not executing a main list task
2344  // Unlink if it executing a task
2345  if ((ptcb != ppcb->PCB_IDLETCB) && (ptcb != (struct gs_tcb *) 0)) { // It is executing a task (no from main list)
2346  gk_TCBRUNL_Unlink(ptcb);
2347  gk_TCBRDYL_Link(ptcb);
2348  }
2349  if (ppcb->PCB_RDY_LCBL[0]->LCB_NextTCBRDYL != (struct gs_tcb *) 0) { // main list has a ready task
2350  ptcb = ppcb->PCB_RDY_LCBL[0]->LCB_NextTCBRDYL;
2351  }
2352  else { // No task to execute from main list
2353  ptcb = ppcb->PCB_IDLETCB;
2354  for (i = 1; i < G_NUMBER_OF_LCBs_FOR_PCB; i++) {
2355  if (ppcb->PCB_RDY_LCBL[i]->LCB_NextTCBRDYL != (struct gs_tcb *) 0) {
2356  ptcb = ppcb->PCB_RDY_LCBL[i]->LCB_NextTCBRDYL;
2357  break;
2358  }
2359  i++;
2360  }
2361  }
2362  }
2363  else {
2364  if (ppcb->PCB_RDY_LCBL[0]->LCB_NextTCBRDYL != (struct gs_tcb *) 0) { // main list has a ready task
2365  if (ptcb->TCBCurrentPriority > ppcb->PCB_RDY_LCBL[0]->LCB_NextTCBRDYL->TCBCurrentPriority) {
2366  gk_TCBRUNL_Unlink(ptcb);
2367  gk_TCBRDYL_Link(ptcb);
2368  ptcb = ppcb->PCB_RDY_LCBL[0]->LCB_NextTCBRDYL;
2369  }
2370  }
2371  else {
2372  ptcb = ptcb;
2373  }
2374  }
2375  SAMPLE_FUNCTION_END(54)
2376  return(ptcb);
2377 }
2378 
2386 INT32 gk_SetLowestProcessor(void)
2387 {
2388  SAMPLE_FUNCTION_BEGIN(55)
2389  #if G_DEBUG_WHILEFOREVER_ENABLE == 1
2390  if (g_kcb.KCB_NextLCBL == (GS_LCB *)0) G_DEBUG_WHILEFOREVER;
2391  if (g_kcb.KCB_NextLCBL->LCB_NextTCBRUNL == (GS_TCB *)0) G_DEBUG_WHILEFOREVER;
2392  if (g_kcb.KCB_NextLCBL->LCB_NextTCBRUNL->TCB_AssocPCB <= 0) G_DEBUG_WHILEFOREVER;
2393  if (g_kcb.KCB_NextLCBL->LCB_NextTCBRUNL->TCB_AssocPCB == 0) G_DEBUG_WHILEFOREVER;
2394  if (g_kcb.KCB_NextLCBL->LCB_NextTCBRUNL->TCB_AssocPCB > G_NUMBER_OF_PCB) G_DEBUG_WHILEFOREVER;
2395  #endif
2396 
2397  GRTOS_CMD_LOW_PRC_SET((int)g_kcb.KCB_NextLCBL->LCB_NextTCBRUNL->TCB_AssocPCB);
2398  SAMPLE_FUNCTION_END(55)
2399  return(G_TRUE);
2400 }
2401 
2408 INT32 gk_SetNextTimeProcessor(void)
2409 {
2410  SAMPLE_FUNCTION_BEGIN(56)
2411  #if G_DEBUG_WHILEFOREVER_ENABLE == 1
2412  if (g_kcb.KCB_NextECBTL == (struct gs_ecb *) 0) G_DEBUG_WHILEFOREVER;
2413  if (g_kcb.KCB_NextECBTL->ECB_AssocTCB == (GS_TCB *)0 &&
2414  g_kcb.KCB_NextECBTL->ECBType != (INT32) G_ECBType_LASTEST_TIME) G_DEBUG_WHILEFOREVER;
2415  if (g_kcb.KCB_NextECBTL->ECB_AssocTCB->TCB_AssocPCB > G_NUMBER_OF_PCB) G_DEBUG_WHILEFOREVER;
2416  #endif
2417 
2418  if (g_kcb.KCB_NextECBTL->ECBType != (INT32) G_ECBType_LASTEST_TIME) {
2419  GRTOS_CMD_NXT_TM_PRC_SET((int) g_kcb.KCB_NextECBTL->ECB_AssocTCB->TCB_AssocPCB);
2420  } else {
2421  GRTOS_CMD_NXT_TM_PRC_SET((int) 0);
2422  }
2423  SAMPLE_FUNCTION_END(56)
2424  return(G_TRUE);
2425 }
2426 
2435 INT32 gk_TASK_INHERENCE_PRIORITY_SET(GS_TCB *ptcb)
2436 {
2437  SAMPLE_FUNCTION_BEGIN(57)
2438  GS_ECB *pevent;
2439  INT64 priority;
2440  INT64 priority2;
2441  G_RCB *presource;
2442 
2443 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
2444  if (TCB_IsValid(ptcb) != G_TRUE) G_DEBUG_WHILEFOREVER;
2445 #endif
2446 
2447  priority = ptcb->TCBReadyPriority;
2448  pevent = ptcb->TCB_NextTCBAEL;
2449 
2450  while (pevent != (struct gs_ecb *) 0) {
2451  if (pevent->ECBState == GS_ECBState_GRANTED_RESOURCE){
2452  presource = (G_RCB *) pevent->ECB_AssocRCB;
2453  priority2 = presource->RCBPriority.i64;
2454  if (priority2 < priority){
2455  priority = priority2;
2456  }
2457  }
2458  pevent = pevent->ECB_NextTCBAEL;
2459  }
2460  ptcb->TCBInherPriority = priority;
2461  SAMPLE_FUNCTION_END(57)
2462  return(G_TRUE);
2463 }
2464 
2474 INT32 gk_TASK_PRIORITY_SET(GS_TCB *ptcb, INT32 task_state)
2475 {
2476  SAMPLE_FUNCTION_BEGIN(58)
2477 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
2478  if (TCB_IsValid(ptcb) != G_TRUE || ptcb == (struct gs_tcb *) 0) G_DEBUG_WHILEFOREVER;
2479 #endif
2480 
2481  if (ptcb->TCBReadyPriority < ptcb->TCBInherPriority) {ptcb->TCBCurrentPriority = ptcb->TCBReadyPriority;}
2482  else {ptcb->TCBCurrentPriority = ptcb->TCBInherPriority;}
2483  if (task_state == G_TCBState_RUNNING && ptcb->TCBCurrentPriority > ptcb->TCBRunPriority) {
2484  ptcb->TCBCurrentPriority = ptcb->TCBRunPriority;}
2485  SAMPLE_FUNCTION_END(58)
2486  return(G_TRUE);
2487 }
2488 
2496 INT32 gk_LCB_CheckInvertion(void)
2497 {
2498  SAMPLE_FUNCTION_BEGIN(59)
2499  GS_LCB *readylist = g_kcb.G_PCBTbl[GRTOS_CMD_PRC_ID-1].PCB_RDY_LCBL[0];
2500  int i = GRTOS_CMD_PRC_ID ;
2501  // int j;
2502 
2503 
2504  if (readylist->LCB_NextTCBRDYL != (struct gs_tcb *) 0)
2505  {/* There is at least a Ready Task */
2506  if (readylist->LCB_NextLCBFPL != (struct gs_pcb *) 0)
2507  {/* There is a Free Processor then interrupt it */
2508 
2509 
2510  if (i != readylist->LCB_NextLCBFPL->PCBID) {
2511 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
2512  fprintf(stderr, "[ OK ] Processor %d trigger proc %d in %s, %d\n", GRTOS_CMD_PRC_ID, readylist->LCB_NextLCBFPL->PCBID, __FUNCTION__,__LINE__);
2513 #endif
2514  GRTOS_CMD_PRC_INT(readylist->LCB_NextLCBFPL->PCBID);
2515  }
2516  }
2517  else
2518  {
2519  if (readylist->LCB_NextTCBRUNL != (struct gs_tcb *) 0)
2520  {/*�There is not Free Processor then check the priority of running task */
2521  if (readylist->LCB_NextTCBRUNL->TCBCurrentPriority > readylist->LCB_NextTCBRDYL->TCBCurrentPriority){
2522  /* Ready priority is greater then processor assigned is interrupted */
2523 
2524 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
2525  if (readylist->LCB_NextTCBRUNL->TCB_AssocPCB < 1 || readylist->LCB_NextTCBRUNL->TCB_AssocPCB > G_NUMBER_OF_PCB) G_DEBUG_WHILEFOREVER;
2526 #endif
2527 
2528  if (i != readylist->LCB_NextTCBRUNL->TCB_AssocPCB) {
2529 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
2530  fprintf(stderr, "[ OK ] Processor %d trigger proc %d in %s, %d\n", GRTOS_CMD_PRC_ID, readylist->LCB_NextTCBRUNL->TCB_AssocPCB, __FUNCTION__,__LINE__);
2531 #endif
2532  GRTOS_CMD_PRC_INT(readylist->LCB_NextTCBRUNL->TCB_AssocPCB);
2533  }
2534  }
2535  }
2536  }
2537  }
2538  SAMPLE_FUNCTION_END(59)
2539  return(G_TRUE);
2540 }
2541 
2550 INT32 gk_TCB_Unlink(GS_TCB *ptcb)
2551 {
2552  SAMPLE_FUNCTION_BEGIN(60)
2553 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
2554  if (TCB_IsValid(ptcb) != G_TRUE) G_DEBUG_WHILEFOREVER;
2555 #endif
2556 
2557  switch (ptcb->TCBState)
2558  {
2559  case G_TCBState_RUNNING: gk_TCBRUNL_Unlink(ptcb); PRINT_DEBUG_LINE break;
2560  case G_TCBState_READY: gk_TCBRDYL_Unlink(ptcb); PRINT_DEBUG_LINE break;
2561  case G_TCBState_WAITING_COMPLETED: gk_TCBWL_Unlink(ptcb); PRINT_DEBUG_LINE break;
2562  case G_TCBState_WAITING : gk_TCBWL_Unlink(ptcb); PRINT_DEBUG_LINE break;
2563  case G_TCBState_UNLINKED:
2564  if (ptcb->TCBType != G_TCBType_IDLE) G_DEBUG_WHILEFOREVER;
2565  break;
2566  default:
2567  G_DEBUG_WHILEFOREVER;
2568  break;
2569  }
2570  SAMPLE_FUNCTION_END(60)
2571  return(G_TRUE);
2572 }
2573 
2583 INT32 gk_ECB_Unlink(GS_ECB *pecb)
2584 {
2585  SAMPLE_FUNCTION_BEGIN(61)
2586  G_DEBUG_VERBOSE
2587 
2588 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
2589  if (ECB_IsValid(pecb) != G_TRUE) G_DEBUG_WHILEFOREVER;
2590 #endif
2591 
2592  if (pecb != (struct gs_ecb *) 0)
2593  {
2594  switch (pecb->ECBState)
2595  {
2596  case GS_ECBState_WAITING_TIME: gk_ECBTL_Unlink(pecb); break;
2597  case GS_ECBState_WAITING_RESOURCE: gk_RCBWEL_Unlink(pecb); break;
2598  case GS_ECBState_GRANTED_RESOURCE: gk_RCBGEL_Unlink(pecb); break;
2599  default: G_DEBUG_WHILEFOREVER; break;
2600  }
2601  }
2602  SAMPLE_FUNCTION_END(61)
2603  return(G_TRUE);
2604 }
2605 
2615 GS_SCB *gk_TCBPSL_GetSCB(GS_TCB *ptcb, INT32 SignalType)
2616 {
2617  SAMPLE_FUNCTION_BEGIN(62)
2618  GS_SCB *psignal = (struct gs_scb *) 0;
2619  GS_SCB *psignal1 = ptcb->TCB_NextTCBPSL;
2620 
2621  while (psignal1 != (struct gs_scb *) 0)
2622  {
2623  if (psignal1->SCBType == SignalType)
2624  {
2625  psignal = psignal1;
2626  psignal1 = (struct gs_scb *) 0;
2627  }
2628  else
2629  {
2630  psignal1 = psignal1->SCB_NextSCB;
2631  }
2632  }
2633  SAMPLE_FUNCTION_END(62)
2634  return(psignal);
2635 }
2636 
2647 GS_SCB *gk_RRDSASL_GetSCB(GS_RRDS *prrds, INT32 SignalType)
2648 {
2649  SAMPLE_FUNCTION_BEGIN(63)
2650  GS_SCB *psignal = (struct gs_scb *) 0;
2651  GS_SCB *psignal1 = prrds->RRDS_NextSCB;
2652 
2653  while (psignal1 != (struct gs_scb *) 0)
2654  {
2655  if (psignal1->SCBType == SignalType)
2656  {
2657  psignal = psignal1;
2658  psignal1 = (struct gs_scb *) 0;
2659  }
2660  else
2661  {
2662  psignal1 = psignal1->SCB_NextSCB;
2663  }
2664  }
2665  SAMPLE_FUNCTION_END(63)
2666  return(psignal);
2667 }
2668 
2678 GS_SCB *gk_KCBASL_GetSCB(INT32 SignalType)
2679 {
2680  SAMPLE_FUNCTION_BEGIN(64)
2681  GS_SCB *psignal = (struct gs_scb *) 0;
2682  GS_SCB *psignal1 = g_kcb.KCB_NextKCBASL;
2683 
2684  while (psignal1 != (struct gs_scb *) 0)
2685  {
2686  if (psignal1->SCBType == SignalType)
2687  {
2688  psignal = psignal1;
2689  psignal1 = (struct gs_scb *) 0;
2690  }
2691  else
2692  {
2693  psignal1 = psignal1->SCB_NextSCB;
2694  }
2695  }
2696  SAMPLE_FUNCTION_END(64)
2697  return(psignal);
2698 }
2699 
2709 GS_SCB *gk_TCBASL_GetSCB(GS_TCB *ptcb, INT32 SignalType)
2710 {
2711  SAMPLE_FUNCTION_BEGIN(65)
2712  GS_SCB *psignal = (struct gs_scb *) 0;
2713  GS_SCB *psignal1 = ptcb->TCB_NextTCBASL;
2714 
2715  while (psignal1 != (struct gs_scb *) 0)
2716  {
2717  if (psignal1->SCBType == SignalType)
2718  {
2719  psignal = psignal1;
2720  psignal1 = (struct gs_scb *) 0;
2721  }
2722  else
2723  {
2724  psignal1 = psignal1->SCB_NextSCB;
2725  }
2726  }
2727  SAMPLE_FUNCTION_END(65)
2728  return(psignal);
2729 }
2730 
2740 GS_SCB *gk_ECBASL_GetSCB(GS_ECB *pecb, INT32 SignalType)
2741 {
2742  SAMPLE_FUNCTION_BEGIN(66)
2743  GS_SCB *psignal = (struct gs_scb *) 0;
2744  GS_SCB *psignal1 = pecb->ECB_NextECBASL;
2745 
2746  while (psignal != (struct gs_scb *) 0)
2747  {
2748  if (psignal->SCBType == SignalType)
2749  {
2750  psignal = psignal1;
2751  psignal1 = (struct gs_scb *) 0;
2752  }
2753  else
2754  {
2755  psignal1 = psignal->SCB_NextSCB;
2756  }
2757  }
2758  SAMPLE_FUNCTION_END(66)
2759  return(psignal);
2760 }
2761 
2770 GS_SCB *gk_RCBASL_GetSCB(G_RCB *prcb, INT32 SignalType)
2771 {
2772  SAMPLE_FUNCTION_BEGIN(67)
2773  GS_SCB *psignal = (struct gs_scb *) 0;
2774  GS_SCB *psignal1 = prcb->RCB_NextRCBASL;
2775 
2776  while (psignal1 != (struct gs_scb *) 0)
2777  {
2778  if (psignal1->SCBType == SignalType)
2779  {
2780  psignal = psignal1;
2781  psignal1 = (struct gs_scb *) 0;
2782  }
2783  else
2784  {
2785  psignal1 = psignal->SCB_NextSCB;
2786  }
2787  }
2788  SAMPLE_FUNCTION_END(67)
2789  return(psignal);
2790 }
2791 
2792 
2793 /***********************************************************************************
2794 *********************** GRTOS COMPLEMENTARY FUNCTIONS ****************************
2795 ***********************************************************************************/
2796 
2805 INT32 gk_TASK_STK_Init(GS_TCB *ptcb)
2806 {
2807  SAMPLE_FUNCTION_BEGIN(69)
2808  GS_STK *stk;
2809 
2810  stk = (GS_STK *) ptcb->TCB_StackBottom - 80; /* It has to be aligned */
2811  ptcb->TCB_StackPointer = stk; /* Load Stack pointer in TCB */
2812 
2813  /* Lleno la pila del primer llamado que llamar� a OSStartTsk */
2814  stk[0] = 1; /* estatus */
2815  stk[1] = (INT32) gk_KERNEL_TASK_COMPLETE; /* register r31 ra */
2816  stk[2] = (INT32)ptcb->TCB_TaskCode + 4; /* register r29 ea */
2817  stk[3] = (INT32)ptcb->TCB_StackPointer-1; /* register r28 fp */
2818  stk[4] = 0; /* register r15 */
2819  stk[5] = 0; /* register r14 */
2820  stk[6] = 0; /* register r13 */
2821  stk[7] = 0; /* register r12 */
2822  stk[8] = 0; /* register r11 */
2823  stk[9] = 0; /* register r10 */
2824  stk[10] = 0; /* register r9 */
2825  stk[11] = 0; /* register r8 */
2826  stk[12] = 0; /* register r7 */
2827  stk[13] = 0; /* register r6 */
2828  stk[14] = 0; /* register r5 */
2829  stk[15] = (INT32) ptcb->TCB_TaskArg; /* register r4 */
2830  stk[16] = 0; /* register r3 */
2831  stk[17] = (INT32) ptcb->TCB_TaskArg; /* register r2 */
2832  stk[18] = 0; /* register r1 */
2833  stk[19] = 0; /* register r24 */
2834  stk[20] = 0; /* register r23 */
2835  stk[21] = 0; /* register r22 */
2836  stk[22] = 0; /* register r21 */
2837  stk[23] = 0; /* register r20 */
2838  stk[24] = 0; /* register r19 */
2839  stk[25] = 0; /* register r18 */
2840  stk[26] = 0; /* register r17 */
2841  stk[27] = 0; /* register r16 */
2842  SAMPLE_FUNCTION_END(69)
2843  return(G_TRUE);
2844 }
2845 
2855 INT32 gk_TASK_Kill(GS_TCB *ptcb)
2856 {
2857  SAMPLE_FUNCTION_BEGIN(70)
2858  gk_TCB_Unlink(ptcb); /* Unlinks the TCB structure */
2859  gk_TCB_List_Unlink(ptcb); /* Unlinks all the linked lists of the TCB */
2860  gk_TCBFL_Link(ptcb); /* Links the TCB to the TCBFL */
2861  SAMPLE_FUNCTION_END(70)
2862  return G_TRUE;
2863 }
2864 
2865 /***********************************************************************************
2866 *********************** GRTOS COMPLEMENTARY FUNCTIONS to be added!!!!!!! ****************************
2867 ***********************************************************************************/
2868 
2877 int gu_Get_CPU_ID(void)
2878 {
2879  SAMPLE_FUNCTION_BEGIN(72)
2880  SAMPLE_FUNCTION_END(72)
2881  return(GRTOS_CMD_PRC_ID );
2882 }
2883 
2884 
2892 gt_time gu_Get_Next_Occurrence_Time(void)
2893 {
2894  SAMPLE_FUNCTION_BEGIN(73)
2895  SAMPLE_FUNCTION_END(73)
2896  return(g_kcb.KCB_NextECBTL->ECBValue.i64);
2897 }
2898 
2899 
2900 /***********************************************************************************
2901 *********************** FINISH COMPLEMENTARY FUNCTIONS ***************************
2902 ***********************************************************************************/
2903 
2912 INT64 gk_TASK_GRANTED_PRIORITY_GET(GS_TCB *ptcb)
2913 {
2914  SAMPLE_FUNCTION_BEGIN(74)
2915  GS_ECB *pevent;
2916  INT64 priority;
2917 
2918 #if G_DEBUG_WHILEFOREVER_ENABLE == 1
2919  if ((TCB_IsValid(ptcb) != G_TRUE)) G_DEBUG_WHILEFOREVER;
2920 #endif
2921 
2922  priority = G_LOWEST_PRIORITY;
2923  pevent = ptcb->TCB_NextTCBAEL;
2924  while ((pevent != (struct gs_ecb *) 0))
2925  {
2926  // Controlar que solo sean recursos granted !!!!!!!!!!!!!!
2927  if (priority > pevent->ECBValue.i64) priority = pevent->ECBValue.i64;
2928  pevent = pevent->ECB_NextECB;
2929  }
2930  SAMPLE_FUNCTION_END(74)
2931  return priority;
2932 }
2933 
2934 
2935 OPTIMEZE_RESTORE
2936 
gs_pcb::PCB_PrevPCB
struct gs_pcb* PCB_PrevPCB
Pointer to the previous free processor.
Definition: gemrtos_core.h:247
gs_ecb::ECB_NextECBAEL
struct gs_ecb* ECB_NextECBAEL
Pointer to the event associated with this (ie timeout)
Definition: gemrtos_core.h:119
INT32
unsigned INT32
Definition: gemrtos_core.h:62
ECB_IsValid
INT32 ECB_IsValid(GS_ECB *pevent)
Returns G_TRUE is pointer points to ECB.
Definition: monitor.c:109
gs_pcb::PCB_NextPCB
struct gs_pcb* PCB_NextPCB
Pointer to the next free processor.
Definition: gemrtos_core.h:246
gs_ecb::ECBState
INT32 ECBState
Granted, Waiting, Free.
Definition: gemrtos_core.h:109
gs_rrds::RRDS_NextRRDS
struct gs_rrds* RRDS_NextRRDS
Pointer to the next RRDS structure
Definition: gemrtos_core.h:363
Processor::gk_LCB_CheckInvertion
INT32 gk_LCB_CheckInvertion(void)
Checks if there is a processor that has to be interrupted to switch task and interruupt it all.
Definition: listfunctions.c:2496
Task::gk_TCBASL_Link
INT32 gk_TCBASL_Link(GS_TCB *ptcb, GS_SCB *psignal)
Links SCB to TCB Associated Signal List.
Definition: listfunctions.c:1346
Task::gk_TCBPSL_GetSCB
GS_SCB* gk_TCBPSL_GetSCB(GS_TCB *ptcb, INT32 SignalType)
Returns pointer to the SCB in te TCBPSL.
Definition: listfunctions.c:2615
gs_tcb::TCB_PrevTCB
struct gs_tcb* TCB_PrevTCB
Pointer to previous TCB in the TCB list.
Definition: gemrtos_core.h:457
GS_TCB
struct gs_tcb GS_TCB
Definition: gemrtos_core.h:50
Task::gk_TCB_Unlink
INT32 gk_TCB_Unlink(GS_TCB *ptcb)
Unlinks the TCB according to the list it is linked.
Definition: listfunctions.c:2550
gs_scb::SCBState
INT32 SCBState
STATE of the signal.
Definition: gemrtos_core.h:395
Task::gk_TCBAEL_Link
INT32 gk_TCBAEL_Link(GS_ECB *pevent, GS_TCB *ptcb)
Links an ECB to the associated ECB list of TCB.
Definition: listfunctions.c:1284
gs_lcb::LCB_NextLCBFPL
struct gs_pcb* LCB_NextLCBFPL
Next free processor for this list.
Definition: gemrtos_core.h:215
gt_time
unsigned long long gt_time
Definition: gemrtos_core.h:65
Signal::gk_ECBASL_Link
void gk_ECBASL_Link(GS_ECB *pevent, GS_SCB *psignal)
Links a SCB to the ECB Associated Signal List.
Definition: listfunctions.c:139
Signal::gk_RCBASL_Link
INT32 gk_RCBASL_Link(G_RCB *presource, GS_SCB *psignal)
Links a signal SCB to the resource RCB Associated Signal List.
Definition: listfunctions.c:737
gs_rrds::RRDS_NEXT_RRDSs
struct gs_rrds* RRDS_NEXT_RRDSs
Fields for debugging.
Definition: gemrtos_core.h:368
Event::gk_TCBAEL_Unlink
INT32 gk_TCBAEL_Unlink(GS_ECB *pevent)
Unlinks the ECB from the associated TCB.
Definition: listfunctions.c:1310
LCB_IsValid
INT32 LCB_IsValid(GS_LCB *plcb)
Definition: monitor.c:167
Signal::gk_KCBASL_Unlink
INT32 gk_KCBASL_Unlink(GS_SCB *psignal)
Unlinks a SCG from the Associated Signal list of KCB.
Definition: listfunctions.c:507
Signal::gk_SCB_GetFree
GS_SCB* gk_SCB_GetFree(void)
Unlinks a SCB from free list and return its pointer.
Definition: gemrtos_core.c:194
Task::gk_TCBLowerPriorityThanTCB
INT32 gk_TCBLowerPriorityThanTCB(GS_TCB *ptcb1, GS_TCB *ptcb2)
Return G_TRUE if current priority of ptct1 is greater than the current priority of ptcb2,...
Definition: listfunctions.c:2307
List::gk_LCBLowerPriorityThanLCB
INT32 gk_LCBLowerPriorityThanLCB(GS_LCB *plcb1, GS_LCB *plcb2)
Return G_TRUE if plct1 is greater than plcb2, otherwise returns G_FALSE.
Definition: listfunctions.c:2284
gs_scb::SCBPriority
INT32 SCBPriority
Priority of the SCB when it is linked.
Definition: gemrtos_core.h:398
Signal::gk_RCBASL_GetSCB
GS_SCB* gk_RCBASL_GetSCB(G_RCB *prcb, INT32 SignalType)
Returns the pointer to the SCB of a resource or NULL otherwise.
Definition: listfunctions.c:2770
Processor::gk_LCBFPL_Unlink
INT32 gk_LCBFPL_Unlink(int processorID)
Unlinks a PCB from the LCB Free Processor List.
Definition: listfunctions.c:702
Task::gk_TCB_in_RCBGEL
GS_ECB* gk_TCB_in_RCBGEL(G_RCB *presource, GS_TCB *ptcb)
Returns the event of the TCB that grants the resource.
Definition: listfunctions.c:2081
gk_RRDSFL_Link
INT32 gk_RRDSFL_Link(GS_RRDS *prrds)
Links a RRDS to the Free List.
Definition: listfunctions.c:2105
Event::gk_RCBWEL_Unlink
void gk_RCBWEL_Unlink(GS_ECB *pevent)
Unlinks ECB from RCB waiting list.
Definition: listfunctions.c:1135
gs_scb::SCB_NextSCB
struct gs_scb* SCB_NextSCB
Pointer to the next SCB linked.
Definition: gemrtos_core.h:401
gs_scb::SCB_NEXT_SCBs
struct gs_scb* SCB_NEXT_SCBs
Fields for debugging.
Definition: gemrtos_core.h:406
gs_lcb::LCB_NextTCBRUNL
struct gs_tcb* LCB_NextTCBRUNL
Pointer to the TCB list of running tasks.
Definition: gemrtos_core.h:211
Task::gk_TASK_PRIORITY_SET
INT32 gk_TASK_PRIORITY_SET(GS_TCB *ptcb, INT32 task_state)
Computes the current priority of the task.
Definition: listfunctions.c:2474
List::gk_LCBL_Link
INT32 gk_LCBL_Link(GS_LCB *plcb)
Inserts a RunList in LCB Runining list ordered by background list and then priority.
Definition: listfunctions.c:553
gk_ECBAEL_Link
INT32 gk_ECBAEL_Link(GS_ECB *pevent1, GS_ECB *pevent2)
gs_ecb
GS_ECB Event Control Block structure.
Definition: gemrtos_core.h:107
gs_ecb::malloc_address
void* malloc_address
Pointer memory address of the malloc block
Definition: gemrtos_core.h:111
gs_lcb
GS_LCB List Control Block.
Definition: gemrtos_core.h:203
Processor::gu_Get_CPU_ID
int gu_Get_CPU_ID(void)
Returns the ID of the current processor.
Definition: listfunctions.c:2877
Task::gk_TCBWL_Link
INT32 gk_TCBWL_Link(GS_TCB *ptcb, unsigned int state)
Links a TCB in the waiting list.
Definition: listfunctions.c:1990
Signal::gk_SCB_Copy
GS_SCB* gk_SCB_Copy(GS_SCB *psignal)
Returns a pointer to a SCB with same values that psignal. Used when an associated signal has to be co...
Definition: listfunctions.c:1201
Processor::gk_PCB_GetNextTCB
GS_TCB* gk_PCB_GetNextTCB(void)
Returns the next TCB to be executed by the current processor. If no task is requesting for execution,...
Definition: listfunctions.c:2333
Task::gk_TCBFL_Link
INT32 gk_TCBFL_Link(GS_TCB *ptcb)
Links a TCB to the Free TCB List removing associated and pending SCBs and ECBs.
Definition: listfunctions.c:1504
gs_tcb
gs_tcb Task Control Block (TCB) structure
Definition: gemrtos_core.h:439
Task::gk_TCBRDYL_Unlink
INT32 gk_TCBRDYL_Unlink(GS_TCB *ptcb)
Unlinks the TCB from the Ready Task List.
Definition: listfunctions.c:1740
gs_scb
GS_SCB Signal Control Block structure.
Definition: gemrtos_core.h:393
GS_PCB
struct gs_pcb GS_PCB
Definition: gemrtos_core.h:48
gs_pcb
GS_PCB Processor Control Block.
Definition: gemrtos_core.h:238
GS_SCB
struct gs_scb GS_SCB
Definition: gemrtos_core.h:52
Event::gk_ECBASL_Unlink
INT32 gk_ECBASL_Unlink(GS_ECB *pevent, GS_SCB *psignal)
Unlinks a signal SCB from the ECB Associated Signal List of and event.
Definition: listfunctions.c:203
Task::gk_TCBPSL_Unlink
INT32 gk_TCBPSL_Unlink(GS_TCB *ptcb, GS_SCB *psignal)
Unlinks SCB from TCB Pending Signal List.
Definition: listfunctions.c:1606
Signal::gk_RCBASL_Unlink
INT32 gk_RCBASL_Unlink(G_RCB *presource, GS_SCB *psignal)
Unlinks a SCB of a signal from the RCB Associated Signal List of a resource.
Definition: listfunctions.c:802
gs_ecb::ECB_PrevECB
struct gs_ecb* ECB_PrevECB
Pointer to linked list of waiting events of this event.
Definition: gemrtos_core.h:114
gs_ecb::ECB_NextECB
struct gs_ecb* ECB_NextECB
Pointer to linked list of waiting events of this event.
Definition: gemrtos_core.h:113
Task::gk_TCBWL_Unlink
INT32 gk_TCBWL_Unlink(GS_TCB *ptcb)
Unlinks the TCB from the waiting list.
Definition: listfunctions.c:2020
GS_RRDS
struct gs_rrds GS_RRDS
Definition: gemrtos_core.h:53
gs_tcb::TCBState
unsigned int TCBState
STATE of the task.
Definition: gemrtos_core.h:442
Task::gk_TCBPSL_Link
INT32 gk_TCBPSL_Link(GS_TCB *ptcb, GS_SCB *psignal)
Link a SCB to TCB Pending Signal List.
Definition: listfunctions.c:1543
Time::gu_Get_Next_Occurrence_Time
gt_time gu_Get_Next_Occurrence_Time(void)
Returns the Next Occurrence Time.
Definition: listfunctions.c:2892
Resource::gk_TASK_IS_BLOCKED
INT32 gk_TASK_IS_BLOCKED(GS_TCB *ptcb)
Returns G_TRUE when TCB is blocked waiting for a resource.
Definition: listfunctions.c:2046
Signal::gk_SCBAPSL_UnLink
INT32 gk_SCBAPSL_UnLink(GS_SCB *pscb_root, GS_SCB *pscb_pending)
Unlinks a pending signal from the root signal.
Definition: listfunctions.c:1244
Resource::gk_RCBWEL_Link
GS_ECB* gk_RCBWEL_Link(G_RCB *presource, GS_ECB *pevent)
Links an event ECB to the resource waiting list of RCB. If no ECB is given then a new ECB is obtained...
Definition: listfunctions.c:1054
g_kcb
GS_KCB g_kcb
RRSD::gk_RRDSASL_UnLink
INT32 gk_RRDSASL_UnLink(GS_RRDS *prrds, GS_SCB *psignal)
Unlinks SCB from RRDS Associated Signal List.
Definition: listfunctions.c:2207
gs_tcb::TCB_NEXT_TCBs
struct gs_tcb* TCB_NEXT_TCBs
Fields for debugging.
Definition: gemrtos_core.h:469
Task::gk_TCBASL_Unlink
INT32 gk_TCBASL_Unlink(GS_TCB *ptcb, GS_SCB *psignal)
Unlinks SCB from a TCB Associated Signal List.
Definition: listfunctions.c:1411
GS_LCB
struct gs_lcb GS_LCB
Definition: gemrtos_core.h:49
Event::gk_ECB_List_Unlink
INT32 gk_ECB_List_Unlink(GS_ECB *pevent)
Unlinks all the structures linked to a ECB.
Definition: listfunctions.c:248
Signal::gk_RRDSASL_GetSCB
GS_SCB* gk_RRDSASL_GetSCB(GS_RRDS *prrds, INT32 SignalType)
Returns pointer to the SCB linked in the RRDSASL list.
Definition: listfunctions.c:2647
Event::gk_ECBTL_Link
INT32 gk_ECBTL_Link(GS_ECB *pevent)
Links the ECB from the Time Event List.
Definition: listfunctions.c:355
INT64
unsigned long long INT64
Definition: gemrtos_core.h:61
Event::gk_ECB_Unlink
INT32 gk_ECB_Unlink(GS_ECB *pecb)
Unlinks the ECB according to the list it is linked.
Definition: listfunctions.c:2583
gs_scb::SCBType
INT32 SCBType
TYPE of the signal.
Definition: gemrtos_core.h:396
gs_rrds::malloc_address
void* malloc_address
Pointer memory address of the malloc block
Definition: gemrtos_core.h:362
gs_tcb::TCB_PREV_TCBs
struct gs_tcb* TCB_PREV_TCBs
Pointer to previous TCB structure. Used for debugging purposes.
Definition: gemrtos_core.h:470
Processor::gk_LCBFPL_Link
INT32 gk_LCBFPL_Link(int processorID)
Links a PCB to the LCB Free Processor List of foreground list of the processor.
Definition: listfunctions.c:659
Task::gk_PCB_GetCurrentTCB
GS_TCB* gk_PCB_GetCurrentTCB(void)
Returns the task that the current processor was executing.
Definition: listfunctions.c:2262
Kernel::gk_KCBASL_GetSCB
GS_SCB* gk_KCBASL_GetSCB(INT32 SignalType)
Returns a pointer to the SCB linked to the KCBASL with the same SignalType.
Definition: listfunctions.c:2678
gs_lcb::LCB_NextTCBRDYL
struct gs_tcb* LCB_NextTCBRDYL
Pointer to the TCB of the Highest Priority Task.
Definition: gemrtos_core.h:212
gs_tcb::malloc_address
void* malloc_address
Pointer memory address of the malloc block
Definition: gemrtos_core.h:444
Processor::gk_SetLowestProcessor
INT32 gk_SetLowestProcessor(void)
Sets the Lowest Processor register in GRTOS Controller.
Definition: listfunctions.c:2386
GS_ECB
struct gs_ecb GS_ECB
Definition: gemrtos_core.h:51
Task::gk_TCBRUNL_Unlink
INT32 gk_TCBRUNL_Unlink(GS_TCB *ptcb)
Unlinks TCB from Running List.
Definition: listfunctions.c:1915
g_rgb::RCBPriority
TIMEPRIORITY RCBPriority
Priority of the resource.
Definition: gemrtos_core.h:313
Task::gk_TCBRDYL_Link
INT32 gk_TCBRDYL_Link(GS_TCB *ptcb)
Links the TCB in the Ready Task List sorted by its priority.
Definition: listfunctions.c:1653
gs_pcb::PCBState
int PCBState
State of the PCB : GS_FREE_PROCESSOR, GS_RUNNING_PROCESSOR.
Definition: gemrtos_core.h:240
Processor::gk_SetNextTimeProcessor
INT32 gk_SetNextTimeProcessor(void)
Sets the Next Time Processor register in GRTOS Controller.
Definition: listfunctions.c:2408
gs_ecb::ECB_NEXT_ECBs
struct gs_ecb* ECB_NEXT_ECBs
Fields for debugging.
Definition: gemrtos_core.h:124
Signal::gk_KCBASL_Link
INT32 gk_KCBASL_Link(GS_SCB *psignal)
Links a SCG to the Associated Signal list of KCB.
Definition: listfunctions.c:443
gs_rrds
GS_RRDS Resource Request Data Structure.
Definition: gemrtos_core.h:357
g_rgb::RCB_NextRCBWEL
struct gs_ecb* RCB_NextRCBWEL
Pointer to linked list of waiting events of this event.
Definition: gemrtos_core.h:317
Task::gk_TASK_Kill
INT32 gk_TASK_Kill(GS_TCB *ptcb)
Destroys a task and return the data structure to the TCB free list.
Definition: listfunctions.c:2855
gk_KERNEL_TASK_COMPLETE
void gk_KERNEL_TASK_COMPLETE(void)
This function is executed when a task finishes its execution.
Definition: grtos_kernel.c:411
Task::gk_TCB_List_Unlink
INT32 gk_TCB_List_Unlink(GS_TCB *ptcb)
Unlinks the TCB from events and signals and links them to the free lists respectively.
Definition: listfunctions.c:1460
GS_STK
unsigned int GS_STK
Definition: gemrtos_core.h:63
Task::gk_TCBASL_GetSCB
GS_SCB* gk_TCBASL_GetSCB(GS_TCB *ptcb, INT32 SignalType)
Returns the pointer to the SCB associated to a task, NULL otherwise.
Definition: listfunctions.c:2709
Task::gk_TASK_GRANTED_PRIORITY_GET
INT64 gk_TASK_GRANTED_PRIORITY_GET(GS_TCB *ptcb)
Determine the priority of a taks according to the resources granted.
Definition: listfunctions.c:2912
gs_tcb::TCB_NextTCB
volatile struct gs_tcb* TCB_NextTCB
Pointer to next TCB in the TCB list.
Definition: gemrtos_core.h:456
Event::gk_RCBGEL_Unlink
void gk_RCBGEL_Unlink(GS_ECB *pevent)
Unlinks ECB from RCB granted list.
Definition: listfunctions.c:1012
Task::gk_TASK_STK_Init
INT32 gk_TASK_STK_Init(GS_TCB *ptcb)
Initializes the Task Stack acording to the TCB parameters.
Definition: listfunctions.c:2805
gemrtos_core.h
GEmRTOS CORE definitions.
g_rgb::RCB_NextRCBGEL
struct gs_ecb* RCB_NextRCBGEL
Pointer to the linked highest priority event.
Definition: gemrtos_core.h:318
Resource::gk_RCBFL_Link
INT32 gk_RCBFL_Link(G_RCB *presource)
Links the RCB of a resource to Free List.
Definition: listfunctions.c:851
gs_ecb::ECB_PREV_ECBs
struct gs_ecb* ECB_PREV_ECBs
Pointer to previous TCB structure. Used for debugging purposes.
Definition: gemrtos_core.h:125
Event::gk_ECBFL_Link
INT32 gk_ECBFL_Link(GS_ECB *pevent)
Link ECB to Free List. Removes the signals from ECB.
Definition: listfunctions.c:324
Resource::gk_RCBGEL_Link
GS_ECB* gk_RCBGEL_Link(G_RCB *presource, GS_ECB *pevent)
Links ECB to RCB granted list and return pointer to the ECB linked.
Definition: listfunctions.c:935
gs_scb::SCB_NextSCBAPSL
struct gs_scb* SCB_NextSCBAPSL
Pointer to the next pending SCB lined.
Definition: gemrtos_core.h:402
Task::gk_TASK_INHERENCE_PRIORITY_SET
INT32 gk_TASK_INHERENCE_PRIORITY_SET(GS_TCB *ptcb)
Sets the inherence priority of TCB according the priority of granted resources.
Definition: listfunctions.c:2435
Event::gk_ECB_GetFree
GS_ECB* gk_ECB_GetFree(void)
Returns a pointer to a Free ECB, NULL if there is not ECB available.
Definition: gemrtos_core.c:107
gs_scb::malloc_address
void* malloc_address
Pointer memory address of the malloc block
Definition: gemrtos_core.h:397
TCB_IsValid
INT32 TCB_IsValid(GS_TCB *ptcb)
Definition: monitor.c:76
G_RCB
struct g_rgb G_RCB
Definition: gemrtos_core.h:54
Task::gk_TASK_RELEASE
INT32 gk_TASK_RELEASE(GS_TCB *ptcb)
Release a new invocation of the task. Preserves the Associated signal list. If task is not completed,...
Definition: listfunctions.c:897
Event::OPTIMEZE_CODE
OPTIMEZE_CODE(3)
Definition: listfunctions.c:32
Signal::gk_RRDSASL_Link
INT32 gk_RRDSASL_Link(GS_RRDS *prrds, GS_SCB *psignal)
Links SCB to RRDS Associated Signal List.
Definition: listfunctions.c:2143
Signal::gk_SCBFL_Link
INT32 gk_SCBFL_Link(GS_SCB *psignal)
Links a SCB to the Free List.
Definition: listfunctions.c:1173
gs_scb::SCB_PREV_SCBs
struct gs_scb* SCB_PREV_SCBs
Pointer to previous SCB structure. Used for debugging purposes.
Definition: gemrtos_core.h:407
Task::gk_TCBRUNL_Link
INT32 gk_TCBRUNL_Link(GS_TCB *ptcb)
Links the TCB to the Run Task List.
Definition: listfunctions.c:1786
Event::gk_ECBAEL_Remove
INT32 gk_ECBAEL_Remove(GS_ECB *pevent)
Unlinks the pevent from the associated ECB list.
Definition: listfunctions.c:102
Event::gk_ECBTL_Unlink
INT32 gk_ECBTL_Unlink(GS_ECB *pevent)
Unlinks the ECB from the Time Event List.
Definition: listfunctions.c:405
List::gk_LCBL_UnLink
INT32 gk_LCBL_UnLink(GS_LCB *plcb)
Unlinks the LCB from the LCB List.
Definition: listfunctions.c:623
Event::gk_ECBASL_GetSCB
GS_SCB* gk_ECBASL_GetSCB(GS_ECB *pecb, INT32 SignalType)
Returns a pointer to the GS_SCB in the associated GS_SCBs of an event or NULL if any.
Definition: listfunctions.c:2740
Resource::gk_RESOURCE_ECB_KILL_CALLBACK
void gk_RESOURCE_ECB_KILL_CALLBACK(GS_ECB *pevent)
This function is called when a resource event is kill. It has to resolve according the event type.
Definition: grtosuserfunctions.c:896
gs_rrds::RRDS_PREV_RRDSs
struct gs_rrds* RRDS_PREV_RRDSs
Pointer to previous RRDS structure. Used for debugging purposes.
Definition: gemrtos_core.h:369
Signal::gk_SCBAPSL_Link
void gk_SCBAPSL_Link(GS_SCB *pscb_root, GS_SCB *pscb_pending)
Links a pending signal to the root signal to create a signal list.
Definition: listfunctions.c:1228
Generated by   doxygen 1.8.17