forked from FreeRTOS/FreeRTOS-Kernel
/
History.txt
3285 lines (2811 loc) · 163 KB
/
History.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
Documentation and download available at https://www.FreeRTOS.org/
+ Update all the APIs to use configSTACK_DEPTH_TYPE for stack type. If left
undefined, configSTACK_DEPTH_TYPE defaults to StackType_t.
Changes between FreeRTOS V11.0.0 and FreeRTOS V11.0.1 released December 21, 2023
+ Updated the SBOM file.
Changes between FreeRTOS V10.6.2 and FreeRTOS V11.0.0 released December 18, 2023
+ SMP merged into the mainline: While FreeRTOS introduced Asymmetric
Multiprocessing (AMP) support in 2017, FreeRTOS Version 11.0.0 is the
first to merge Symmetric Multiprocessing (SMP) support into the mainline
release. SMP enables one instance of the FreeRTOS Kernel to schedule tasks
across multiple identical processor cores. We thank Mike Bruno and Jerry
McCarthy of XMOS and, Darian Liang, Sudeep Mohanty and Zim Kalinowski of
Espressif Systems for their contributions.
+ Switch MISRA compliance checking from PC Lint to Coverity, and update from
MISRA C:2004 to MISRA C:2012.
+ Add a template FreeRTOSConfig.h, inclusive of an abbreviated explanation of
each configuration item. Application writers can use this template as a
starting point to create the FreeRTOSConfig.h file for their application.
+ Add a template FreeRTOS port which can be used as a starting point for
developing a new FreeRTOS port.
+ Add bounds checking and obfuscation to internal heap block pointers in
heap_4.c and heap_5.c to help catch pointer corruptions. The application can
enable these checks by setting configENABLE_HEAP_PROTECTOR to 1 in their
FreeRTOSConfig.h. We thank @oliverlavery for their contribution.
+ Update vTaskList and vTaskGetRunTimeStats APIs to replace the use of sprintf
with snprintf.
+ Add trace macros to ports that enable tracing the interaction of ISRs with
scheduler events. We thank @conara for their contribution.
+ Add trace macros that enable tracing of entering and exiting all APIs. We
thank @Techcore123 for their contribution.
+ Add uxTaskBasePriorityGet and uxTaskBasePriorityGetFromISR APIs to get the
base priority of a task. The base priority of a task is the priority that
was last assigned to the task - which due to priority inheritance, may not
be the current priority of the task.
+ Add pdTICKS_TO_MS macro to convert time in FreeRTOS ticks to time in
milliseconds. We thank @Dazza0 for their contribution.
+ Add default implementations of vApplicationGetIdleTaskMemory and
vApplicationGetTimerTaskMemory. The application can enable these default
implementations by setting configKERNEL_PROVIDED_STATIC_MEMORY to 1 in their
FreeRTOSConfig.h. We thank @mdnr-g for their contribution.
+ Update vTaskGetInfo to include start and end of the stack whenever both
values are available. We thank @vinceburns for their contribution.
+ Prevent tasks waiting for a notification from being resumed by calls to
vTaskResume or vTaskResumeFromISR. We thank @Moral-Hao for their
contribution.
+ Add asserts to validate that the application has correctly installed
FreeRTOS handlers for PendSV and SVCall interrupts on Cortex-M devices.
We thank @jefftenney for their contribution.
+ Rename ARM_CA53_64_BIT and ARM_CA53_64_BIT_SRE ports to Arm_AARCH64 and
Arm_AARCH64_SRE respectively as these ports are applicable to all AArch64
architecture. We thank @urutva for their contribution.
+ Add CMake support to allow the application writer to select the RISC-V
chip extension. We thank @JoeBenczarski for their contribution.
+ Add CMake support to allow the application writer to build an application
with static allocation only. We thank @conara for their contribution.
+ Make taskYIELD available to unprivileged tasks for ARMv8-M ports.
+ Update Cortex-M23 ports to not use PSPLIM_NS. We thank @urutva for their
contribution.
+ Update the SysTick setup code for ARMv8-M ports to first configure the clock
source and then enable SysTick. This is needed to address a bug in QEMU
versions older than 7.0.0, which causes an emulation error if SysTick is
enabled without first selecting a valid clock source. We thank @jefftenney
for their contribution.
+ Add the port-optimized task selection algorithm optionally available for
ARMv7-M ports to the ARMv8-M ports. We thank @jefftenney for their
contribution.
+ Improve the speed of pvPortMalloc in heap_4.c and heap_5.c by removing
unnecessary steps while splitting a large memory block into two. We thank
@Moral-Hao for their contribution.
+ Shorten the critical section in pvPortMalloc in heap_2.c, heap_4.c and
heap_5.c by moving the size calculation out of the critical section. We thank
@Moral-Hao for their contribution.
+ Update xTaskNotifyWait and ulTaskNotifyTake to remove the non-deterministic
operation of traversing a linked link from a critical section. We thank
@karver8 for their contribution.
+ Fix stack end and stack size computation in POSIX port to meet the stack
alignment requirements on MacOS. We thank @tegimeki for their contribution.
+ Update the vTaskPrioritySet implementation to use the new priority when the
task has inherited priority from a mutex it is holding, and the new priority
is bigger than the inherited priority. We thank @Moral-Hao for their
contribution.
+ Add stack alignment adjustment if stack grows upwards. We thank @ivq for
their contribution.
+ Fix pxTopOfStack calculation in configINIT_TLS_BLOCK when picolib C is
selected as the C library implementation to ensure that
pxPortInitialiseStack does not overwrite the data in the TLS block portion
of the stack. We thank @bebebib-rs for their contribution.
+ Fix vPortEndScheduler() for the MSVC port so that the function
prvProcessSimulatedInterrupts is not stuck in an infinite loop when the
scheduler is stopped. We thank @Ju1He1 for their contribution.
+ Add the Pull Request (PR) Process explaining the stages a PR goes through.
Changes between FreeRTOS V10.6.1 and FreeRTOS V10.6.2 released November 29, 2023
+ Add the following improvements to the new MPU wrapper (mpu_wrappers_v2.c)
introduced in version 10.6.0:
- Introduce Access Control List (ACL) feature to allow the application
writer to control an unprivileged task’s access to kernel objects.
- Update the system call entry mechanism to only require one Supervisor
Call (SVC) instruction.
- Wrap parameters for system calls with more than four parameters in a
struct to avoid special handling during system call entry.
- Fix 2 possible integer overflows.
- Convert some asserts to run time parameter checks.
Changes between FreeRTOS V10.6.0 and FreeRTOS V10.6.1 released August 17, 2023
+ Add runtime parameter checks to functions in mpu_wrappers_v2.c file.
The same checks are already performed in API implementations using
asserts.
We thank the following people for their inputs in these changes:
- Lan Luo, Zixia Liu of School of Computer Science and Technology,
Anhui University of Technology, China.
- Xinwen Fu of Department of Computer Science, University of
Massachusetts Lowell, USA.
- Xinhui Shao, Yumeng Wei, Huaiyu Yan, Zhen Ling of School of
Computer Science and Engineering, Southeast University, China.
Changes between FreeRTOS V10.5.1 and FreeRTOS 10.6.0 released July 13, 2023
+ Add a new MPU wrapper that places additional restrictions on unprivileged
tasks. The following is the list of changes introduced with the new MPU
wrapper:
1. Opaque and indirectly verifiable integers for kernel object handles:
All the kernel object handles (for example, queue handles) are now
opaque integers. Previously object handles were raw pointers.
2. Save the task context in Task Control Block (TCB): When a task is
swapped out by the scheduler, the task's context is now saved in its
TCB. Previously the task's context was saved on its stack.
3. Execute system calls on a separate privileged only stack: FreeRTOS
system calls, which execute with elevated privilege, now use a
separate privileged only stack. Previously system calls used the
calling task's stack. The application writer can control the size of
the system call stack using new configSYSTEM_CALL_STACK_SIZE config
macro.
4. Memory bounds checks: FreeRTOS system calls which accept a pointer
and de-reference it, now verify that the calling task has required
permissions to access the memory location referenced by the pointer.
5. System calls restrictions: The following system calls are no longer
available to unprivileged tasks:
- vQueueDelete
- xQueueCreateMutex
- xQueueCreateMutexStatic
- xQueueCreateCountingSemaphore
- xQueueCreateCountingSemaphoreStatic
- xQueueGenericCreate
- xQueueGenericCreateStatic
- xQueueCreateSet
- xQueueRemoveFromSet
- xQueueGenericReset
- xTaskCreate
- xTaskCreateStatic
- vTaskDelete
- vTaskPrioritySet
- vTaskSuspendAll
- xTaskResumeAll
- xTaskGetHandle
- xTaskCallApplicationTaskHook
- vTaskList
- vTaskGetRunTimeStats
- xTaskCatchUpTicks
- xEventGroupCreate
- xEventGroupCreateStatic
- vEventGroupDelete
- xStreamBufferGenericCreate
- xStreamBufferGenericCreateStatic
- vStreamBufferDelete
- xStreamBufferReset
Also, an unprivileged task can no longer use vTaskSuspend to suspend
any task other than itself.
We thank the following people for their inputs in these enhancements:
- David Reiss of Meta Platforms, Inc.
- Lan Luo, Xinhui Shao, Yumeng Wei, Zixia Liu, Huaiyu Yan and Zhen Ling
of School of Computer Science and Engineering, Southeast University,
China.
- Xinwen Fu of Department of Computer Science, University of
Massachusetts Lowell, USA.
- Yueqi Chen, Zicheng Wang, Minghao Lin, Jiahe Wang of University of
Colorado Boulder, USA.
+ Add Cortex-M35P port. Contributed by @urutva.
+ Add embedded extension (RV32E) support to the IAR RISC-V port.
+ Add ulTaskGetRunTimeCounter and ulTaskGetRunTimePercent APIs. Contributed by
@chrisnc.
+ Add APIs to get the application supplied buffers from statically
created kernel objects. The following new APIs are added:
- xTaskGetStaticBuffers
- xQueueGetStaticBuffers
- xQueueGenericGetStaticBuffers
- xSemaphoreGetStaticBuffer
- xEventGroupGetStaticBuffer
- xStreamBufferGetStaticBuffers
- xMessageBufferGetStaticBuffers
These APIs enable the application writer to obtain static buffers from
the kernel object and free/reuse them at the time of deletion. Earlier
the application writer had to maintain the association of static buffers
and the kernel object in the application. Contributed by @Dazza0.
+ Add Thread Local Storage (TLS) support using picolibc function. Contributed
by @keith-packard.
+ Add configTICK_TYPE_WIDTH_IN_BITS to configure TickType_t data type. As a result,
the number of bits in an event group also increases with big data type. Contributed
by @Hadatko.
+ Update eTaskGetState and uxTaskGetSystemState to return eReady for pending ready
tasks. Contributed by @Dazza0.
+ Update heap_4 and heap_5 to add padding only if the resulting block is not
already aligned.
+ Fix the scheduler logic in a couple of places to not preempt a task when an
equal priority task becomes ready.
+ Add macros used in FreeRTOS-Plus libraries. Contributed by @Holden.
+ Fix clang compiler warnings. Contributed by @phelter.
+ Add assertions to ARMv8-M ports to detect when FreeRTOS APIs are called from
interrupts with priority higher than the configMAX_SYSCALL_INTERRUPT_PRIORITY.
Contributed by @urutva.
+ Add xPortIsInsideInterrupt API to ARM_CM0 ports.
+ Fix build warning in MSP430X port when large data model is used.
+ Add the ability to use Cortex-R5 port on the parts without FPU.
+ Fix build warning in heap implementations on PIC24/dsPIC.
+ Update interrupt priority asserts for Cortex-M ports so that these do not fire
on QEMU which does not implement PRIO bits.
+ Update ARMv7-M ports to ensure that kernel interrupts run at the lowest priority.
configKERNEL_INTERRUPT_PRIORITY is now obsolete for ARMv7-M ports and brings
these ports inline with the newer ARMv8-M ports. Contributed by @chrisnc.
+ Fix build issue in POSIX GCC port on Windows Subsystem for Linux (WSL). Contributed
by @jacky309.
+ Add portMEMORY_BARRIER to Microblaze port. Contributed by @bbain.
+ Add portPOINTER_SIZE_TYPE definition for ATmega port. Contributed by @jputcu.
+ Multiple improvements in the CMake support. Contributed by @phelte and @cookpate.
Changes between FreeRTOS V10.5.0 and FreeRTOS V10.5.1 released November 16 2022
+ Updated the kernel version in manifest and SBOM
Changes between FreeRTOS V10.4.6 and FreeRTOS V10.5.0 released September 16 2022
+ ARMv7-M and ARMv8-M MPU ports: It was possible for a third party that
already independently gained the ability to execute injected code to
read from or write to arbitrary addresses by passing a negative argument
as the xIndex parameter to pvTaskGetThreadLocalStoragePointer() or
vTaskSetThreadLocalStoragePointer respectively. A check has been added to
ensure that passing a negative argument as the xIndex parameter does not
cause arbitrary read or write.
We thank Certibit Consulting, LLC for reporting this issue.
+ ARMv7-M and ARMv8-M MPU ports: It was possible for an unprivileged task
to invoke any function with privilege by passing it as a parameter to
MPU_xTaskCreate, MPU_xTaskCreateStatic, MPU_xTimerCreate,
MPU_xTimerCreateStatic, or MPU_xTimerPendFunctionCall. MPU_xTaskCreate
and MPU_xTaskCreateStatic have been updated to only allow creation of
unprivileged tasks. MPU_xTimerCreate, MPU_xTimerCreateStatic and
MPU_xTimerPendFunctionCall APIs have been removed.
We thank Huazhong University of Science and Technology for reporting
this issue.
+ ARMv7-M and ARMv8-M MPU ports: It was possible for a third party that
already independently gained the ability to execute injected code to
achieve further privilege escalation by branching directly inside a
FreeRTOS MPU API wrapper function with a manually crafted stack frame.
The local stack variable `xRunningPrivileged` has been removed so that
a manually crafted stack frame cannot be used for privilege escalation
by branching directly inside a FreeRTOS MPU API wrapper.
We thank Certibit Consulting, LLC, Huazhong University of Science and
Technology and the SecLab team at Northeastern University for reporting
this issue.
+ ARMv7-M MPU ports: It was possible to configure overlapping memory
protection unit (MPU) regions such that an unprivileged task could access
privileged data. The kernel now uses highest numbered MPU regions for
kernel protections to prevent such MPU configurations.
We thank the SecLab team at Northeastern University for reporting this
issue.
+ Add support for ARM Cortex-M55.
+ Add support for ARM Cortex-M85. Contributed by @gbrtth.
+ Add vectored mode interrupt support to the RISC-V port.
+ Add support for RV32E extension (Embedded Profile) in RISC-V GCC port.
Contributed by @Limoto.
+ Heap improvements:
- Add a check to heap_2 to track if a memory block is allocated to
the application or not. The MSB of the size field is used for this
purpose. The same check already exists in heap_4 and heap_5. This
check prevents double free errors.
- Add a new flag configHEAP_CLEAR_MEMORY_ON_FREE to heap_2, heap_4
and heap_5. If the flag is set in FreeRTOSConfig.h then memory freed using
vPortFree() is automatically cleared to zero.
- Add a new API pvPortCalloc to heap_2, heap_4 and heap_5 which has the same
signature as the standard library calloc function.
- Update the pointer types to portPOINTER_SIZE_TYPE. Contributed by
@Octaviarius.
+ Add the ability to override send and receive completed callbacks for each
instance of a stream buffer or message buffer. Earlier there could be
one send and one receive callback for all instances of stream and message
buffers. Having separate callbacks per instance allows different message
and stream buffers to be used differently - for example, some for inter core
communication and others for same core communication.
The feature can be controlled by setting the configuration option
configUSE_SB_COMPLETED_CALLBACK in FreeRTOSConfig.h. When the option is set to 1,
APIs xStreamBufferCreateWithCallback() or xStreamBufferCreateStaticWithCallback()
(and likewise APIs for message buffer) can be used to create a stream buffer
or message buffer instance with application provided callback overrides. When
the option is set to 0, then the default callbacks as defined by
sbSEND_COMPLETED() and sbRECEIVE_COMPLETED() macros are invoked. To maintain
backwards compatibility, configUSE_SB_COMPLETED_CALLBACK defaults to 0. The
functionality is currently not supported for MPU enabled ports.
+ Generalize the FreeRTOS's Thread Local Storage (TLS) support so that it
is not tied to newlib and can be used with other c-runtime libraries also.
The default behavior for newlib support is kept same for backward
compatibility.
+ Add support to build and link FreeRTOS using CMake build system. Contributed
by @yhsb2k.
+ Add support to generate Software Bill of Materials (SBOM) for every release.
+ Add support for 16 MPU regions to the GCC Cortex-M33 ports.
+ Add ARM Cortex-M7 r0p0/r0p1 Errata 837070 workaround to ARM CM4 MPU ports.
The application writer needs to define configENABLE_ERRATA_837070_WORKAROUND
when using CM4 MPU ports on a Cortex-M7 r0p0/r0p1 core.
+ Add configSYSTICK_CLOCK_HZ to Cortex-M0 ports. This is needed to support
the case when the SysTick timer is not clocked from the same source as the CPU.
+ Add hardware stack protection support to MicroBlazeV9 port. This ensures that
the CPU immediately raises Stack Protection Violation exception as soon as any
task violates its stack limits. Contributed by @uecasm.
+ Introduce the configUSE_MINI_LIST_ITEM configuration option. When this
option is set to 1, ListItem_t and MiniLitItem_t remain separate types.
However, when configUSE_MINI_LIST_ITEM == 0, MiniLitItem_t and ListItem_t
are both typedefs of the same struct xLIST_ITEM. This addresses some issues
observed when strict-aliasing and link time optimization are enabled.
To maintain backwards compatibility, configUSE_MINI_LIST_ITEM defaults to 1.
+ Simplify prvInitialiseNewTask to memset newly allocated TCB structures
to zero, and remove code that set individual structure members to zero.
+ Add prototype for prvPortYieldFromISR to the POSIX port so that it builds
without any warning with -Wmissing-prototypes compiler option.
+ Add top of stack and end of stack to the task info report obtained using
vTaskGetInfo(). Contributed by @shreyasbharath.
+ Add a cap to the cRxLock and cTxLock members of the queue data structure.
These locks count the number items received and sent to the queue while
the queue was locked. These are later used to unblock tasks waiting on
the queue when the queue is unlocked. This PR caps the values of the
cRxLock and cTxLock to the number of tasks in the system because we cannot
unblock more tasks than there are in the system. Note that the same assert
could still be triggered is the application creates more than 127 tasks.
+ Changed uxAutoReload parameter in timer functions to xAutoReload. The
type is now BaseType_t. This matches the type of pdTRUE and pdFALSE.
The new function xTimerGetAutoReload() provides the auto-reload state as
a BaseType_t. The legacy function uxTimerGetAutoReload is retained with the
original UBaseType_t return value.
+ Fix support for user implementations of tickless idle that call
vTaskStepTick() with xExpectedIdleTime ticks to step. The new code
ensures xTickCount reaches xNextTaskUnblockTime inside xTaskIncrementTick()
instead of inside vTaskStepTick(). This fixes the typical case where a task
wakes up one tick late and a rare case assertion failure when xTickCount\
rolls over. Contributed by @jefftenney.
+ Fix deadlock in event groups when pvPortMalloc and vPortFree functions
are protected with a mutex. Contributed by @clemenskresser.
+ Fix a warning in tasks.c when compiled with -Wduplicated-branches
GCC option. Contributed by @pierrenoel-bouteville-act.
+ Fix compilation error in tasks.c when configSUPPORT_DYNAMIC_ALLOCATION
is set to zero. Contributed by @rdpoor.
+ Fix prvWriteMessageToBuffer() function in stream_buffer.c so that it correctly
copies length on big endian platforms too.
+ Remove the need for INCLUDE_vTaskSuspend to be set to 1
when configUSE_TICKLESS_IDLE is enabled. Contributed by @pramithkv.
+ Update the RL78 IAR port to the latest version of IAR which uses the
industry standard ELF format as opposed to earlier UBROF object format.
Contributed by @felipe-iar.
+ Add tick type is atomic flag when tick count is 16-bit to PIC24 port. This
allows the PIC24 family of 16 bit processors to read the tick count without
a critical section when the tick count is also 16 bits.
+ Fix offset-out-of-range errors for GCC CM3/CM4 mpu ports when
Link Time Optimization is enabled. Contributed by @niniemann.
+ Remove #error when RISC-V port is compiled on a 64-bit RISC-V platform.
Contributed by @cmdrf.
+ Fix ullPortInterruptNesting alignment in Cortex-A53 port so that it is
8-byte aligned. This fixes the unaligned access exception. Contributed
by @Atomar25.
+ Fix Interrupt Handler Register Function and Exception Process in NiosII
Port. Contributed by @ghost.
+ Change FreeRTOS IRQ Handler for Cortex-A53 SRE port to store and restore
interrupt acknowledge register. This ensures that the SRE port behavior
matches the Memory Mapped IO port. Contributed by @sviaunxp.
+ Update the uncrustify config file to match the version of the uncrustify
used in the CI Action. Also, pin the version of uncrustify in CI. Contributed
by @swaldhoer.
Changes between FreeRTOS V10.4.5 and FreeRTOS V10.4.6 released November 12 2021
+ ARMv7-M and ARMv8-M MPU ports – prevent non-kernel code from calling the
internal functions xPortRaisePrivilege and vPortResetPrivilege by changing
them to macros.
+ Introduce a new config configALLOW_UNPRIVILEGED_CRITICAL_SECTIONS which
enables developers to prevent critical sections from unprivileged tasks.
It defaults to 1 for backward compatibility. Application should set it to
0 to disable critical sections from unprivileged tasks.
Changes between FreeRTOS V10.4.4 and FreeRTOS V10.4.5 released September 10 2021
See https://www.FreeRTOS.org/FreeRTOS-V10.4.5.html
+ Introduce configRUN_TIME_COUNTER_TYPE which enables developers to define
the type used to hold run time statistic counters. Defaults to uint32_t
for backward compatibility. #define configRUN_TIME_COUNTER_TYPE to a type
(for example, uint64_t) in FreeRTOSConfig.h to override the default.
+ Introduce ulTaskGetIdleRunTimePercent() to complement the pre-existing
ulTaskGetIdleRunTimeCounter(). Whereas the pre-existing function returns
the raw run time counter value, the new function returns the percentage of
the entire run time consumed by the idle task. Note the amount of idle
time is only a good measure of the slack time in a system if there are no
other tasks executing at the idle priority, tickless idle is not used, and
configIDLE_SHOULD_YIELD is set to 0.
+ ARMv8-M secure-side port: Tasks that call secure functions from the
non-secure side of an ARMv8-M MCU (ARM Cortex-M23 and Cortex-M33) have two
contexts - one on the non-secure side and one on the secure-side. Previous
versions of the FreeRTOS ARMv8-M secure-side ports allocated the structures
that reference secure-side contexts at run time. Now the structures are
allocated statically at compile time. The change necessitates the
introduction of the secureconfigMAX_SECURE_CONTEXTS configuration constant,
which sets the number of statically allocated secure contexts.
secureconfigMAX_SECURE_CONTEXTS defaults to 8 if left undefined.
Applications that only use FreeRTOS code on the non-secure side, such as
those running third-party code on the secure side, are not affected by
this change.
Changes between FreeRTOS V10.4.3 and FreeRTOS V10.4.4 released May 28 2021
+ Minor performance improvements to xTaskIncrementTick() achieved by providing
macro versions of uxListRemove() and vListInsertEnd().
+ Minor refactor of timers.c that obsoletes the need for the
tmrCOMMAND_START_DONT_TRACE macro and removes the need for timers.c to
post to its own event queue. A consequence of this change is that auto-
reload timers that miss their intended next execution time will execute
again immediately rather than executing again the next time the command
queue is processed. (thanks Jeff Tenney).
+ Fix a race condition in the message buffer implementation. The
underlying cause was that length and data bytes are written and read as
two distinct operations, which both modify the size of the buffer. If a
context switch occurs after adding or removing the length bytes, but
before adding or removing the data bytes, then another task may observe
the message buffer in an invalid state.
+ The xTaskCreate() and xTaskCreateStatic() functions accept a task priority
as an input parameter. The priority has always been silently capped to
(configMAX_PRIORITIES - 1) should it be set to a value above that priority.
Now values above that priority will also trigger a configASSERT() failure.
+ Replace configASSERT( pcQueueName ) in vQueueAddToRegistry with a NULL
pointer check.
+ Introduce the configSTACK_ALLOCATION_FROM_SEPARATE_HEAP configuration
constant that enables the stack allocated to tasks to come from a heap other
than the heap used by other memory allocations. This enables stacks to be
placed within special regions, such as fast tightly coupled memory.
+ If there is an attempt to add the same queue or semaphore handle to the
queue registry more than once then prior versions would create two separate
entries. Now if this is done the first entry is overwritten rather than
duplicated.
+ Update the ESP32 port and TF-M (Trusted Firmware M)code to the latest from
their respective repositories.
+ Correct a build error in the POSIX port.
+ Additional minor formatting updates, including replacing tabs with spaces
in more files.
+ Other minor updates include adding additional configASSERT() checks and
correcting and improving code comments.
+ Go look at the smp branch to see the progress towards the Symetric
Multiprocessing Kernel. https://github.com/FreeRTOS/FreeRTOS-Kernel/tree/smp
Changes between FreeRTOS V10.4.2 and FreeRTOS V10.4.3 released December 14 2020
V10.4.3 is included in the 202012.00 LTS release. Learn more at https:/freertos.org/lts-libraries.html
See https://www.FreeRTOS.org/FreeRTOS-V10.4.x.html
+ Changes to improve robustness and consistency for buffer allocation in
the heap, queue and stream buffer.
+ The following functions can no longer be called from unprivileged code.
- xTaskCreateRestricted
- xTaskCreateRestrictedStatic
- vTaskAllocateMPURegions
Changes between FreeRTOS V10.4.1 and FreeRTOS V10.4.2 released November 10 2020
See https://www.FreeRTOS.org/FreeRTOS-V10.4.x.html
+ Fix an issue in the ARMv8-M ports that caused BASEPRI to be masked
between the first task starting to execute and that task making
a FreeRTOS API call.
+ Introduced xTaskDelayUntil(), which is functionally equivalent to
vTaskDelayUntil(), with the addition of returning a value to
indicating whether or not the function placed the calling task into
the Blocked state or not.
+ Update WolfSSL to 4.5.0 and add the FIPS ready demo.
+ Add support for ESP IDF 4.2 to ThirdParty Xtensa port.
+ Re-introduce uxTopUsedPriority to support OpenOCD debugging.
+ Convert most dependent libraries in FreeRTOS/FreeRTOS to submodules.
+ Various general maintenance and improvements to MISRA compliance.
Changes between FreeRTOS V10.4.0 and FreeRTOS V10.4.1 released September 17 2020
See https://www.FreeRTOS.org/FreeRTOS-V10.4.x.html
+ Fixed an incorrectly named parameter that prevented the
ulTaskNotifyTakeIndexed macro compiling, and the name space clash in the
test code that prevented this error causing test failures.
Changes between FreeRTOS V10.3.1 and FreeRTOS V10.4.0 released September 10 2020
See https://www.FreeRTOS.org/FreeRTOS-V10.4.x.html
Major enhancements:
+ Task notifications: Prior to FreeRTOS V10.4.0 each created task had a
single direct to task notification. From FreeRTOS V10.4.0 each task has
an array of notifications. The direct to task notification API has been
extended with API functions postfixed with "Indexed" to enable the API to
operate on a task notification at any array index. See
https://www.freertos.org/RTOS-task-notifications.html for more information.
+ Kernel ports that support memory protection units (MPUs): The ARMv7-M and
ARMv8-M MPU ports now support a privilege access only heap. The ARMv7-M
MPU ports now support devices that have 16 MPU regions, have the ability
to override default memory attributes for privileged code and data
regions, and have the ability to place the FreeRTOS kernel code outside of
the Flash memory. The ARMv8-M MPU ports now support tickless idle mode.
See https://www.freertos.org/FreeRTOS-MPU-memory-protection-unit.html
for more information.
Additional noteworthy updates:
+ Code formatting is now automated to facilitate the increase in
collaborative development in Git. The auto-formated code is not identical
to the original formatting conventions. Most notably spaces are now used
in place of tabs.
+ The prototypes for callback functions (those that start with "Application",
such as vApplicationStackOverflowHook()) are now in the FreeRTOS header
files, removing the need for application writers to add prototypes into
the C files in which they define the functions.
+ New Renesas RXv3 port layer.
+ Updates to the Synopsys ARC code, including support for EM and HS cores,
and updated BSP.
+ Added new POSIX port layer that allows FreeRTOS to run on Linux hosts in
the same way the Windows port layer enables FreeRTOS to run on Windows
hosts.
+ Many other minor optimisations and enhancements. For full details
see https://github.com/FreeRTOS/FreeRTOS-Kernel/commits/main
Changes between FreeRTOS V10.3.0 and FreeRTOS V10.3.1 released February 18 2020
See https://www.FreeRTOS.org/FreeRTOS-V10.3.x.html
+ ./FreeRTOS-Labs directory was removed from this file. The libraries it
contained are now available as a separate download.
Changes between FreeRTOS V10.2.1 and FreeRTOS V10.3.0 released February 7 2020
See https://www.FreeRTOS.org/FreeRTOS-V10.3.x.html
New and updated kernel ports:
+ Added RISC-V port for the IAR compiler.
+ Update the Windows simulator port to use a synchronous object to prevent
a user reported error whereby a task continues to run for a short time
after being moved to the Blocked state. Note we were not able to
replicate the reported issue and it likely depends on your CPU model.
+ Correct alignment of stack top in RISC-V port when
configISR_STACK_SIZE_WORDS is defined to a non zero value, which causes
the interrupt stack to be statically allocated.
+ The RISC-V machine timer compare register can now be for any HART, whereas
previously it was always assumed FreeRTOS was running on HART 0.
+ Update the sequence used to update the 64-bit machine timer
compare register on 32-bit cores to match that suggested in RISC-V
documentation.
+ Added tickless low power modes into the ARM, IAR and GCC Cortex-M0 compiler
ports.
+ Updated the behaviour of the ARMv7-M MPU (Memory Protection Unit) ports to
match that of the ARMv8-M ports whereby privilege escalations can only
originate from within the kernel's own memory segment. Added
configENFORCE_SYSTEM_CALLS_FROM_KERNEL_ONLY configuration constant.
+ Update existing MPU ports to correctly disable the MPU before it is
updated.
+ Added contributed port and demo application for a T-Head (formally C-SKY)
microcontroller.
New API functions:
+ Added the vPortGetHeapStats() API function which returns information on
the heap_4 and heap_5 state.
+ Added xTaskCatchUpTicks(), which corrects the tick count value after the
application code has held interrupts disabled for an extended period.
+ Added xTaskNotifyValueClear() API function.
+ Added uxTimerGetReloadMode() API function.
Other miscellaneous changes:
+ Change type of uxPendedTicks from UBaseType_t to TickType_t to ensure it
has the same type as variables with which it is compared to, and therefore
also renamed the variable xPendingTicks.
+ Update Keil projects that use the MPU so memory regions come from linker
script (scatter file) variables instead of being hard coded.
+ Added LPC51U68 Cortex-M0+ demos for GCC (MCUXpresso), Keil and IAR
compilers.
+ Added CORTEX_MPU_STM32L4_Discovery_Keil_STM32Cube demo.
+ Added LPC54018 MPU demo.
+ Rename xTaskGetIdleRunTimeCounter() to ulTaskGetIdleRunTimeCounter().
Changes between FreeRTOS V10.2.1 and FreeRTOS V10.2.0 released May 13 2019:
+ Added ARM Cortex-M23 port layer to complement the pre-existing ARM
Cortex-M33 port layer.
+ The RISC-V port now automatically switches between 32-bit and 64-bit
cores.
+ Introduced the portMEMORY_BARRIER macro to prevent instruction re-ordering
when GCC link time optimisation is used.
+ Introduced the portDONT_DISCARD macro to the ARMv8-M ports to try and
prevent the secure side builds from removing symbols required by the
non secure side build.
+ Introduced the portARCH_NAME to provide additional data to select semi-
automated build environments.
+ Cortex-M33 and Cortex-M23 ports now correctly disable the MPU before
updating the MPU registers.
+ Added Nuvoton NuMaker-PFM-M2351 ARM Cortex-M23 demo.
+ Added LPC55S69 ARM Cortex-M33 demo.
+ Added an STM32 dual core AMP stress test demo.
Changes between FreeRTOS V10.1.1 and FreeRTOS V10.2.0 released February 25 2019:
+ Added GCC RISC-V MCU port with three separate demo applications.
+ Included pre-existing ARM Cortex-M33 (ARMv8-M) GCC/ARMclang and IAR ports
with Keil simulator demo.
+ Update the method used to detect if a timer is active. Previously the
timer was deemed to be inactive if it was not referenced from a list.
However, when a timer is updated it is temporarily removed from, then
re-added to a list, so now the timer's active status is stored separately.
+ Add vTimerSetReloadMode(), xTaskGetIdleRunTimeCounter(), and
xTaskGetApplicationTaskTagFromISR() API functions.
+ Updated third party Xtensa port so it is MIT licensed.
+ Added configINCLUDE_PLATFORM_H_INSTEAD_OF_IODEFINE_H to the Renesas
compiler RX600v2 port to enable switching between platform.h and
iodefine.h includes within that port's port.c file.
+ Removed the 'FromISR' functions from the MPU ports as ISRs run privileged
anyway.
+ Added uxTaskGetStackHighWaterMark2() function to enable the return type to
be changed without breaking backward compatibility.
uxTaskGetStackHighWaterMark() returns a UBaseType_t as always,
uxTaskGetStackHighWaterMark2() returns configSTACK_DEPTH_TYPE to allow the
user to determine the return type.
+ Fixed issues in memory protected ports related to different combinations
of static memory only and dynamic memory only builds. As a result the
definition of tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE became more
complex and was moved to FreeRTOS.h with a table explaining its definition.
+ Added a 'get task tag from ISR' function.
+ Change the method used to determine if a timer is active or not from just
seeing if it is referenced from the active timer list to storing its
active state explicitly. The change prevents the timer reporting that it
is inactive while it is being moved from one list to another.
+ The pcName parameter passed into the task create functions can be NULL,
previously a name had to be provided.
+ When using tickless idle, prvResetNextTaskUnblockTime() is now only called
in xTaskRemoveFromEventList() if the scheduler is not suspended.
+ Introduced portHAS_STACK_OVERFLOW_CHECKING, which should be set to 1 for
FreeRTOS ports that run on architectures that have stack limit registers.
Changes between FreeRTOS V10.1.0 and FreeRTOS V10.1.1 released 7 September 2018
+ Reverted a few structure name changes that broke several kernel aware
debugger plug-ins.
+ Updated to the latest trace recorder code.
+ Fixed some formatting in the FreeRTOS+TCP TCP/IP stack code.
+ Reverted moving some variables from file to function scope as doing so
broke debug scenarios that require the static qualifier to be removed.
Changes between FreeRTOS V10.0.1 and FreeRTOS V10.1.0 released 22 August 2018
FreeRTOS Kernel Changes:
+ Update lint checked MISRA compliance to use the latest MISRA standard, was
previously using the original MISRA standard.
+ Updated all object handles (TaskHandle_t, QueueHandle_t, etc.) to be
unique types instead of void pointers, improving type safety. (this was
attempted some years back but had to be backed out due to bugs in some
debuggers). Note this required the pvContainer member of a ListItem_t
struct to be renamed - set configENABLE_BACKWARD_COMPATIBILITY to 1 if
this causes an issue.
+ Added configUSE_POSIX_ERRNO to enable per task POSIX style errno
functionality in a more user friendly way - previously the generic thread
local storage feature was used for this purpose.
+ Added Xtensa port and demo application for the XCC compiler.
+ Changed the implementation of vPortEndScheduler() for the Win32 port to
simply call exit( 0 ).
+ Bug fix in vPortEnableInterrupt() for the GCC Microblaze port to protect
the read modify write access to an internal Microblaze register.
+ Fix minor niggles when the MPU is used with regards to prototype
differences, static struct size differences, etc.
+ The usStackHighWaterMark member of the TaskStatus_t structure now has type
configSTACK_DEPTH_TYPE in place of uint16_t - that change should have been
made when the configSTACK_DEPTH_TYPE type (which gets around the previous
16-bit limit on stack size specifications) was introduced.
+ Added the xMessageBufferNextLengthBytes() API function and likewise stream
buffer equivalent.
+ Introduce configMESSAGE_BUFFER_LENGTH_TYPE to allow the number of bytes
used to hold the length of a message in the message buffer to be reduced.
configMESSAGE_BUFFER_LENGTH_TYPE default to size_t, but if, for example,
messages can never be more than 255 bytes it could be set to uint8_t,
saving 3 bytes each time a message is written into the message buffer
(assuming sizeof( size_t ) is 4).
+ Updated the StaticTimer_t structure to ensure it matches the size of the
Timer_t structure when the size of TaskFunction_t does not equal the size
of void *.
+ Update various Xilinx demos to use 2018.1 version of the SDK tools.
+ Various updates to demo tasks to maintain test coverage.
+ FreeRTOS+UDP was removed in FreeRTOS V10.1.0 as it was replaced by
FreeRTOS+TCP, which was brought into the main download in FreeRTOS
V10.0.0. FreeRTOS+TCP can be configured as a UDP only stack, and
FreeRTOS+UDP does not contain the patches applied to FreeRTOS+TCP.
FreeRTOS+TCP Changes:
+ Multiple security improvements and fixes in packet parsing routines, DNS
caching, and TCP sequence number and ID generation.
+ Disable NBNS and LLMNR by default.
+ Add TCP hang protection by default.
We thank Ori Karliner of Zimperium zLabs Team for reporting these issues.
Changes between FreeRTOS V10.0.0 and FreeRTOS V10.0.1, released December 20 2017
+ Fix position of "#if defined( __cplusplus )" in stream_buffer.h.
+ Correct declarations of MPU_xQueuePeek() and MPU_xQueueSemaphoreTake() in
mpu_prototypes.h.
+ Correct formatting in vTaskList() helper function when it prints the state
of the currently executing task.
+ Introduce #error if stream_buffer.c is built without
configUSE_TASK_NOTIFICATIONS set to 1.
+ Update FreeRTOS+TCP to V2.0.0
- Improve the formatting of text that displays the available netword
interfaces when FreeRTOS+TCP is used on Windows with WinPCap.
- Introduce ipconfigSOCKET_HAS_USER_WAKE_CALLBACK option to enable a user
definable callback to execute when data arrives on a socket.
Changes between FreeRTOS V9.0.1 and FreeRTOS V10.0.0:
The FreeRTOS kernel is now MIT licensed: https://www.FreeRTOS.org/license
New Features and components:
+ Stream Buffers - see https://www.FreeRTOS.org/RTOS-stream-buffer-example.html
+ Message Buffers - see https://www.FreeRTOS.org//RTOS-message-buffer-example.html
+ Move FreeRTOS+TCP into the main repository, along with the basic Win32
TCP demo FreeRTOS_Plus_TCP_Minimal_Windows_Simulator.
New ports or demos:
+ Added demo for TI SimpleLink CC3220 MCU.
+ Added MPU and non MPU projects for Microchip CEC and MEC 17xx and 51xx
MCUs.
+ Added CORTEX_MPU_Static_Simulator_Keil_GCC demo to test static allocation
in the MPU port.
Fixes or enhancements:
+ Cortex-M ports push additional register prior to calling
vTaskSwitchContext to ensure 8-byte alignment is maintained. Only
important if a user defined tick hook function performs an operation that
requires 8-byte alignment.
+ Optimisations to the implementation of the standard tickless idle mode on
Cortex-M devices.
+ Improvements to the Win32 port including using higher priority threads.
+ Ensure interrupt stack alignment on PIC32 ports.
+ Updated GCC TriCore port to build with later compiler versions.
+ Update mpu_wrappers.c to support static allocation.
+ The uxNumberOfItems member of List_t is now volatile - solving an issue
when the IAR compiler was used with maximum optimization.
+ Introduced configRECORD_STACK_HIGH_ADDRESS. When set to 1 the stack start
address is saved into each task's TCB (assuming stack grows down).
+ Introduced configINCLUDE_FREERTOS_TASK_C_ADDITIONS_H to allow user defined
functionality, and user defined initialisation, to be added to FreeRTOS's
tasks.c source file. When configINCLUDE_FREERTOS_TASK_C_ADDITIONS_H is
set to 1 a user provided header file called freertos_task_c_additions.h
will be included at the bottom of tasks.c. Functions defined in that
header file can call freertos_tasks_c_additions_init(), which in turn
calls a macro called FREERTOS_TASKS_C_ADDITIONS_INIT(), if it is defined.
FREERTOS_TASKS_C_ADDITIONS_INIT() can be defined in FreeRTOSConfig.h.
+ Introduced configPRE_SUPPRESS_TICKS_AND_SLEEP_PROCESSING( x ) which can be
defined by a user in FreeRTOSConfig.h. The macro is called before
assessing whether to enter tickless idle mode or not. If the macro sets
x to zero then tickless idle mode will not be entered. This allows users
to abort tickless idle mode entry before the tickless idle function is
even called - previously it was only possible to abort from within the
tickless idle function itself.
+ Added configPRINTF(), which can be defined by users to allow all libraries
to use the same print formatter.
+ Introduced configMAX() and configMIN() macros which default to standard
max( x, y ) and min( x, y ) macro behaviour, but can be overridden if the
application writer defines the same macros in FreeRTOSConfig.h.
+ Corrected the definition of StaticTask_t in the case where
INCLUDE_xTaskAbortDelay is set to 1.
+ Introduced configTIMER_SERVICE_TASK_NAME and configIDLE_TASK_NAME, both of
which can be defined to strings in FreeRTOSConfig.h to change the default
names of the timer service and idle tasks respectively.
+ Only fill the stack of a newly created task with a known value if stack
checking, or high water mark checking/viewing, is in use - removing the
dependency on memset() in other cases.
+ Introduced xTaskCreateRestrictedStatic() so static allocation can be used
with the MPU.
+ Ensure suspended tasks cannot be unsuspended by a received task
notification.
+ Fix race condition in vTaskSetTimeOutState().
+ Updated trace recorder files to the latest version.
Changes since FreeRTOS V9.0.0:
+ Priority dis-inheritance behaviour has been enhanced in the case where a
task that attempted to take a mutex that was held by a lower priority task
timed out before it was able to obtain the mutex (causing the task that
holds the mutex to have its priority raised, then lowered again, in
accordance with the priority inheritance protocol).
+ Split the overloaded xQueueGenericReceive() function into three separate
dedicated functions.
+ Allow the default human readable text names given to the Idle and Timer
tasks to be overridden by defining the configIDLE_TASK_NAME and
configTIMER_SERVICE_TASK_NAME definitions respectively in FreeRTOSConfig.h.
+ Introduced configINITIAL_TICK_COUNT to allow the tick count to take a
value of than than 0 when the system boots. This can be useful for
testing purposes - although setting configUSE_16_BIT_TICKS to 1 can also
be used to test frequent tick overflows.
+ Ensure the Cortex-M SysTick count is cleared to zero before starting the
first task.
+ Add configASSERT() into ARM Cortex-M ports to check the number of priority
bit settings.
+ Clear the 'control' register before starting ARM Cortex-M4F ports in case
the FPU is used before the scheduler is started. This just saves a few
bytes on the main stack as it prevents space being left for a later save
of FPU registers.
+ Added xSemaphoreGetMutexHolderFromISR().
+ Corrected use of portNVIC_PENDSVSET to portNVIC_PENDSVSET_BIT in MPU ports.
+ Introduced configSTACK_DEPTH_TYPE to allow users to change the type used
to specify the stack size when using xTaskCreate(). For historic reasons,
when FreeRTOS was only used on small MCUs, the type was set to uint16_t,
but that can be too restrictive when FreeRTOS is used on larger
processors. configSTACK_DEPTH_TYPE defaults to uint16_t.
xTaskCreateStatic(), being a newer function, used a uint32_t.
+ Increase the priority of the Windows threads used by the Win32 port. As
all the threads run on the same core, and the threads run with very high
priority, there is a risk that the host will become unresponsive, so also
prevent the Windows port executing on single core hosts.
Changes between FreeRTOS V9.0.0 and FreeRTOS V9.0.0rc2 released May 25 2016:
See https://www.FreeRTOS.org/FreeRTOS-V9.html
RTOS kernel updates:
+ The prototype of the new xTaskCreateStatic() API function was modified to
remove a parameter and improve compatibility with other new
"CreateStatic()" API functions. The stack size parameter in
xTaskCreateStatic() is now uint32_t, which changes the prototype of the
callback functions. See the following URL:
https://www.FreeRTOS.org/xTaskCreateStatic.html
+ GCC ARM Cortex-A port: Introduced the configUSE_TASK_FPU_SUPPORT
constant. When configUSE_TASK_FPU_SUPPORT is set to 2 every task is
automatically given a floating point (FPU) context.
+ GCC ARM Cortex-A port: It is now possible to automatically save and
restore all floating point (FPU) registers on entry to each potentially
nested interrupt by defining vApplicationFPUSafeIRQHandler() instead of
vApplicationIRQHandler().
+ All ARM Cortex-M3/4F/7 ports: Clear the least significant bit of the task
entry address placed onto the stack of a task when the task is created for
strict compliance with the ARM Cortex-M3/4/7 architecture documentation
(no noticeable effect unless using the QMEU emulator).
+ Added GCC and Keil ARM Cortex-M4F MPU ports - previously the MPU was only
supported on ARM Cortex-M3.
+ ARM Cortex-M3/4F MPU ports: Update to fully support the FreeRTOS V9.0.0
API (other than static object creation) and added the
FreeRTOS/Demo/CORTEX_MPU_Simulator_Keil_GCC demo application to
demonstrate how to use the updated MPU port.
+ All ARM Cortex-M3/4F/7 ports: Add additional barrier instructions to the
default low power tickless implementation.
+ All ARM Cortex-M0 ports: Prevent an item being left on the stack of the
first task that executes.
+ Win32 ports: Reduce the amount of stack used and change the way Windows
threads are deleted to increase the maximum execution time.
+ Add an ARM Cortex-M4F port for the MikroC compiler. Ensure to read the
documentation page for this port before use.
+ MPS430X IAR port: Update to be compatible with the latest EW430 tools
release.
+ IAR32 GCC port: Correct vPortExitCritical() when
configMAX_API_CALL_INTERRUPT_PRIORITY == portMAX_PRIORITY.
+ For consistency vTaskGetTaskInfo() now has the alias vTaskGetInfo(),
xTaskGetTaskHandle() now has the alias xTaskGetHandle() and
pcQueueGetQueueName() now has an alias pcQueueGetName().
+ Fix various errors in comments and compiler warnings.
Demo application updates:
+ Update Atmel Studio projects to use Atmel Studio 7.
+ Update Xilinx SDK projects to use the 2016.1 version of the SDK.
+ Remove dependency on legacy IO libraries from the PIC32 demos.
+ Move the Xilinx UltraScale Cortex-R5 demo into the main distribution.
+ Update the MSP432 libraries to the latest version.
+ Add Microchip CEC1302 (ARM Cortex-M4F) demos for GCC, Keil and MikroC
compilers.
+ Move the Atmel SAMA5D2 demo into the main distribution.
Changes between FreeRTOS V9.0.0rc1 and FreeRTOS V9.0.0rc2 (release candidate 2)
released March 30 2016:
NOTE - See https://www.FreeRTOS.org/FreeRTOS-V9.html for details
+ The functions that create RTOS objects using static memory allocation have
been simplified and will not revert to using dynamic allocation if a
buffer is passed into a function as NULL.
+ Introduced the configSUPPORT_DYNAMIC_ALLOCATION configuration constant to
allow a FreeRTOS application to be built without a heap even being being
defined. The Win32 example located in the
/FreeRTOS/demo/WIN32-MSVC-Static-Allocation-Only directory is provided as
a reference for projects that do not include a FreeRTOS heap.
+ Minor run-time optimisations.
+ Two new low power tickless implementations that target Silicon Labs EFM32
microcontrollers.
+ Addition of the xTimerGetPeriod() and xTimerGetExpireTime() API functions.
Changes between FreeRTOS V8.2.3 and FreeRTOS V9.0.0rc1 (release candidate 1)
released February 19 2016:
RTOS Kernel Updates:
+ Major new feature - tasks, semaphores, queues, timers and event groups can
now be created using statically allocated memory, so without any calls to
pvPortMalloc().
+ Major new features - Added the xTaskAbortDelay() API function which allows
one task to force another task to immediately leave the Blocked state,
even if the event the blocked task is waiting for has not occurred, or the
blocked task's timeout has not expired.
+ Updates necessary to allow FreeRTOS to run on 64-bit architectures.
+ Added vApplicationDaemonTaskStartupHook() which executes when the RTOS
daemon task (which used to be called the timer service task) starts
running. This is useful if the application includes initialisation code
that would benefit from executing after the scheduler has been started.
+ Added the xTaskGetTaskHandle() API function, which obtains a task handle
from the task's name. xTaskGetTaskHandle() uses multiple string compare
operations, so it is recommended that it is called only once per task.
The handle returned by xTaskGetTaskHandle() can then be stored locally for
later re-use.
+ Added the pcQueueGetQueueName() API function, which obtains the name of
a queue from the queue's handle.
+ Tickless idling (for low power applications) can now also be used when
configUSE_PREEMPTION is 0.
+ If one task deletes another task, then the stack and TCB of the deleted
task is now freed immediately. If a task deletes itself, then the stack
and TCB of the deleted task are freed by the Idle task as before.
+ If a task notification is used to unblock a task from an ISR, but the
xHigherPriorityTaskWoken parameter is not used, then pend a context switch
that will then occur during the next tick interrupt.
+ Heap_1.c and Heap_2.c now use the configAPPLICATION_ALLOCATED_HEAP
settings, which previously was only used by heap_4.c.
configAPPLICATION_ALLOCATED_HEAP allows the application writer to declare
the array that will be used as the FreeRTOS heap, and in-so-doing, place
the heap at a specific memory location.
+ TaskStatus_t structures are used to obtain details of a task.
TaskStatus_t now includes the bae address of the task's stack.
+ Added the vTaskGetTaskInfo() API function, which returns a TaskStatus_t
structure that contains information about a single task. Previously this
information could only be obtained for all the tasks at once, as an array
of TaskStatus_t structures.
+ Added the uxSemaphoreGetCount() API function.
+ Replicate previous Cortex-M4F and Cortex-M7 optimisations in some
Cortex-M3 port layers.
Demo Application Updates:
Further demo applications will be added prior to the final FreeRTOS V9
release.
+ Updated SAM4L Atmel Studio project to use Atmel Studio 7.
+ Added ARM Cortex-A53 64-bit port.
+ Added a port and demo for the ARM Cortex-A53 64-bit cores on the Xilinx
Ultrascale MPSoC.
+ Added Cortex-M7 SAME70 GCC demo.
+ Added EFM32 Giant and Wonder Gecko demos.
Changes between V8.2.2 and V8.2.3 released October 16, 2015
RTOS kernel updates:
+ Fix bug identified in a modification made in V8.2.2 to the software timer
code that allows tickless low power applications to sleep indefinitely
when software timers are used.
+ Simplify and improve efficiency of stack overflow checking.
+ Add xTaskNotifyStateClear() API function.
+ New IAR and GCC Cortex-R ports for microprocessors that do not use an ARM
generic interrupt controller (GIC).
+ New PIC32MEC14xx port.
+ Add support for PIC32MZ EF parts (with floating point) into the PIC32MZ
port.
+ Zynq7000 port layer now declares the functions that setup and clear the
tick interrupt as weak symbols so they can be overridden by the
application, and uses a global XScuGic object so the same object can be
used by the application code.
+ Introduced configUSE_TASK_FPU_SUPPORT, although the PIC32MZ EF port is
currently the only port that uses it.