This patch is not intended to be integrated. It just gives an example for using clang-format.
Using AlignConsecutiveDeclarations: false PointerAlignment: Right would be closer to the RTEMS style, however, this combination is not really supported: https://stackoverflow.com/questions/38392889/clang-format-align-asterisk-of-pointer-declaration-with-variable-name Used .clang-format file for -style=file: --- Language: Cpp AccessModifierOffset: -2 AlignAfterOpenBracket: Align AlignConsecutiveMacros: false AlignConsecutiveAssignments: false AlignConsecutiveDeclarations: false AlignEscapedNewlines: Right AlignOperands: true AlignTrailingComments: true AllowAllArgumentsOnNextLine: false AllowAllConstructorInitializersOnNextLine: true AllowAllParametersOfDeclarationOnNextLine: false AllowShortBlocksOnASingleLine: Never AllowShortCaseLabelsOnASingleLine: false AllowShortFunctionsOnASingleLine: None AllowShortLambdasOnASingleLine: All AllowShortIfStatementsOnASingleLine: Never AllowShortLoopsOnASingleLine: false AlwaysBreakAfterDefinitionReturnType: None AlwaysBreakAfterReturnType: None AlwaysBreakBeforeMultilineStrings: false AlwaysBreakTemplateDeclarations: MultiLine BinPackArguments: false BinPackParameters: false BraceWrapping: AfterCaseLabel: false AfterClass: false AfterControlStatement: false AfterEnum: false AfterFunction: true AfterNamespace: false AfterObjCDeclaration: false AfterStruct: false AfterUnion: false AfterExternBlock: false BeforeCatch: false BeforeElse: false IndentBraces: false SplitEmptyFunction: true SplitEmptyRecord: true SplitEmptyNamespace: true BreakBeforeBinaryOperators: None BreakBeforeBraces: Custom BreakBeforeInheritanceComma: false BreakInheritanceList: BeforeColon BreakBeforeTernaryOperators: false BreakConstructorInitializersBeforeComma: false BreakConstructorInitializers: BeforeColon BreakAfterJavaFieldAnnotations: false BreakStringLiterals: true ColumnLimit: 80 CommentPragmas: '^ IWYU pragma:' CompactNamespaces: false ConstructorInitializerAllOnOneLineOrOnePerLine: false ConstructorInitializerIndentWidth: 2 ContinuationIndentWidth: 2 Cpp11BracedListStyle: true DeriveLineEnding: true DerivePointerAlignment: false DisableFormat: false ExperimentalAutoDetectBinPacking: false FixNamespaceComments: true ForEachMacros: - foreach - Q_FOREACH - BOOST_FOREACH IncludeBlocks: Preserve IncludeCategories: - Regex: '^"(llvm|llvm-c|clang|clang-c)/' Priority: 2 SortPriority: 0 - Regex: '^(<|"(gtest|gmock|isl|json)/)' Priority: 3 SortPriority: 0 - Regex: '.*' Priority: 1 SortPriority: 0 IncludeIsMainRegex: '(Test)?$' IncludeIsMainSourceRegex: '' IndentCaseLabels: true IndentGotoLabels: false IndentPPDirectives: None IndentWidth: 2 IndentWrappedFunctionNames: false JavaScriptQuotes: Leave JavaScriptWrapImports: true KeepEmptyLinesAtTheStartOfBlocks: false MacroBlockBegin: '' MacroBlockEnd: '' MaxEmptyLinesToKeep: 1 NamespaceIndentation: None ObjCBinPackProtocolList: Auto ObjCBlockIndentWidth: 2 ObjCSpaceAfterProperty: false ObjCSpaceBeforeProtocolList: true PenaltyBreakAssignment: 2 PenaltyBreakBeforeFirstCallParameter: 19 PenaltyBreakComment: 300 PenaltyBreakFirstLessLess: 120 PenaltyBreakString: 1000 PenaltyBreakTemplateDeclaration: 10 PenaltyExcessCharacter: 1000000 PenaltyReturnTypeOnItsOwnLine: 60 PointerAlignment: Right ReflowComments: true SortIncludes: true SortUsingDeclarations: true SpaceAfterCStyleCast: true SpaceAfterLogicalNot: false SpaceAfterTemplateKeyword: true SpaceBeforeAssignmentOperators: true SpaceBeforeCpp11BracedList: false SpaceBeforeCtorInitializerColon: true SpaceBeforeInheritanceColon: true SpaceBeforeParens: ControlStatements SpaceBeforeRangeBasedForLoopColon: true SpaceInEmptyBlock: false SpaceInEmptyParentheses: false SpacesBeforeTrailingComments: 1 SpacesInAngles: true SpacesInConditionalStatement: true SpacesInContainerLiterals: true SpacesInCStyleCastParentheses: false SpacesInParentheses: true SpacesInSquareBrackets: true SpaceBeforeSquareBrackets: false Standard: Latest StatementMacros: - Q_UNUSED - QT_REQUIRE_VERSION TabWidth: 8 UseCRLF: false UseTab: Never ... --- cpukit/rtems/src/semcreate.c | 150 ++++------ cpukit/score/src/threadqenqueue.c | 455 +++++++++++++----------------- 2 files changed, 252 insertions(+), 353 deletions(-) diff --git a/cpukit/rtems/src/semcreate.c b/cpukit/rtems/src/semcreate.c index b58ea0199f..59437bdef9 100644 --- a/cpukit/rtems/src/semcreate.c +++ b/cpukit/rtems/src/semcreate.c @@ -20,8 +20,8 @@ #include "config.h" #endif -#include <rtems/rtems/semimpl.h> #include <rtems/rtems/attrimpl.h> +#include <rtems/rtems/semimpl.h> #include <rtems/rtems/statusimpl.h> #include <rtems/rtems/support.h> #include <rtems/rtems/tasksimpl.h> @@ -29,27 +29,26 @@ #include <rtems/score/sysstate.h> #include <rtems/sysinit.h> -#define SEMAPHORE_KIND_MASK ( RTEMS_SEMAPHORE_CLASS | RTEMS_INHERIT_PRIORITY \ - | RTEMS_PRIORITY_CEILING | RTEMS_MULTIPROCESSOR_RESOURCE_SHARING ) +#define SEMAPHORE_KIND_MASK \ + ( RTEMS_SEMAPHORE_CLASS | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY_CEILING | \ + RTEMS_MULTIPROCESSOR_RESOURCE_SHARING ) -rtems_status_code rtems_semaphore_create( - rtems_name name, - uint32_t count, - rtems_attribute attribute_set, - rtems_task_priority priority_ceiling, - rtems_id *id -) +rtems_status_code rtems_semaphore_create( rtems_name name, + uint32_t count, + rtems_attribute attribute_set, + rtems_task_priority priority_ceiling, + rtems_id *id ) { - Semaphore_Control *the_semaphore; - Thread_Control *executing; - Status_Control status; - rtems_attribute maybe_global; - rtems_attribute mutex_with_protocol; - Semaphore_Variant variant; + Semaphore_Control *the_semaphore; + Thread_Control *executing; + Status_Control status; + rtems_attribute maybe_global; + rtems_attribute mutex_with_protocol; + Semaphore_Variant variant; const Scheduler_Control *scheduler; - bool valid; - Priority_Control priority; - uintptr_t flags; + bool valid; + Priority_Control priority; + uintptr_t flags; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; @@ -57,7 +56,7 @@ rtems_status_code rtems_semaphore_create( if ( !id ) return RTEMS_INVALID_ADDRESS; -#if defined(RTEMS_MULTIPROCESSING) +#if defined( RTEMS_MULTIPROCESSING ) if ( !_System_state_Is_multiprocessing ) { attribute_set = _Attributes_Clear( attribute_set, RTEMS_GLOBAL ); } @@ -76,21 +75,16 @@ rtems_status_code rtems_semaphore_create( variant = SEMAPHORE_VARIANT_SIMPLE_BINARY; } else if ( maybe_global == RTEMS_BINARY_SEMAPHORE ) { variant = SEMAPHORE_VARIANT_MUTEX_NO_PROTOCOL; - } else if ( - mutex_with_protocol - == ( RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY ) - ) { + } else if ( mutex_with_protocol == ( RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | + RTEMS_INHERIT_PRIORITY ) ) { variant = SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY; - } else if ( - mutex_with_protocol - == ( RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_PRIORITY_CEILING ) - ) { + } else if ( mutex_with_protocol == ( RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | + RTEMS_PRIORITY_CEILING ) ) { variant = SEMAPHORE_VARIANT_MUTEX_PRIORITY_CEILING; - } else if ( - mutex_with_protocol == ( RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | - RTEMS_MULTIPROCESSOR_RESOURCE_SHARING ) - ) { -#if defined(RTEMS_SMP) + } else if ( mutex_with_protocol == + ( RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | + RTEMS_MULTIPROCESSOR_RESOURCE_SHARING ) ) { +#if defined( RTEMS_SMP ) variant = SEMAPHORE_VARIANT_MRSP; #else /* @@ -116,16 +110,14 @@ rtems_status_code rtems_semaphore_create( flags = _Semaphore_Set_variant( 0, variant ); -#if defined(RTEMS_MULTIPROCESSING) +#if defined( RTEMS_MULTIPROCESSING ) if ( _Attributes_Is_global( attribute_set ) ) { bool ok; - ok = _Objects_MP_Allocate_and_open( - &_Semaphore_Information, - name, - the_semaphore->Object.id, - false - ); + ok = _Objects_MP_Allocate_and_open( &_Semaphore_Information, + name, + the_semaphore->Object.id, + false ); if ( !ok ) { _Semaphore_Free( the_semaphore ); @@ -150,14 +142,12 @@ rtems_status_code rtems_semaphore_create( case SEMAPHORE_VARIANT_MUTEX_NO_PROTOCOL: case SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY: _CORE_recursive_mutex_Initialize( - &the_semaphore->Core_control.Mutex.Recursive - ); + &the_semaphore->Core_control.Mutex.Recursive ); if ( count == 0 ) { _CORE_mutex_Set_owner( &the_semaphore->Core_control.Mutex.Recursive.Mutex, - executing - ); + executing ); _Thread_Resource_count_increment( executing ); } @@ -168,11 +158,9 @@ rtems_status_code rtems_semaphore_create( priority = _RTEMS_Priority_To_core( scheduler, priority_ceiling, &valid ); if ( valid ) { - _CORE_ceiling_mutex_Initialize( - &the_semaphore->Core_control.Mutex, - scheduler, - priority - ); + _CORE_ceiling_mutex_Initialize( &the_semaphore->Core_control.Mutex, + scheduler, + priority ); if ( count == 0 ) { Thread_queue_Context queue_context; @@ -182,13 +170,11 @@ rtems_status_code rtems_semaphore_create( _ISR_lock_ISR_disable( &queue_context.Lock_context.Lock_context ); _CORE_mutex_Acquire_critical( &the_semaphore->Core_control.Mutex.Recursive.Mutex, - &queue_context - ); - status = _CORE_ceiling_mutex_Set_owner( - &the_semaphore->Core_control.Mutex, - executing, - &queue_context - ); + &queue_context ); + status = + _CORE_ceiling_mutex_Set_owner( &the_semaphore->Core_control.Mutex, + executing, + &queue_context ); if ( status != STATUS_SUCCESSFUL ) { _Thread_queue_Destroy( &the_semaphore->Core_control.Wait_queue ); @@ -201,19 +187,17 @@ rtems_status_code rtems_semaphore_create( } break; -#if defined(RTEMS_SMP) +#if defined( RTEMS_SMP ) case SEMAPHORE_VARIANT_MRSP: scheduler = _Thread_Scheduler_get_home( executing ); priority = _RTEMS_Priority_To_core( scheduler, priority_ceiling, &valid ); if ( valid ) { - status = _MRSP_Initialize( - &the_semaphore->Core_control.MRSP, - scheduler, - priority, - executing, - count == 0 - ); + status = _MRSP_Initialize( &the_semaphore->Core_control.MRSP, + scheduler, + priority, + executing, + count == 0 ); } else { status = STATUS_INVALID_PRIORITY; } @@ -221,14 +205,10 @@ rtems_status_code rtems_semaphore_create( break; #endif default: - _Assert( - variant == SEMAPHORE_VARIANT_SIMPLE_BINARY - || variant == SEMAPHORE_VARIANT_COUNTING - ); - _CORE_semaphore_Initialize( - &the_semaphore->Core_control.Semaphore, - count - ); + _Assert( variant == SEMAPHORE_VARIANT_SIMPLE_BINARY || + variant == SEMAPHORE_VARIANT_COUNTING ); + _CORE_semaphore_Initialize( &the_semaphore->Core_control.Semaphore, + count ); status = STATUS_SUCCESSFUL; break; } @@ -243,19 +223,15 @@ rtems_status_code rtems_semaphore_create( * Whether we initialized it as a mutex or counting semaphore, it is * now ready to be "offered" for use as a Classic API Semaphore. */ - *id = _Objects_Open_u32( - &_Semaphore_Information, - &the_semaphore->Object, - name - ); + *id = + _Objects_Open_u32( &_Semaphore_Information, &the_semaphore->Object, name ); -#if defined(RTEMS_MULTIPROCESSING) +#if defined( RTEMS_MULTIPROCESSING ) if ( _Attributes_Is_global( attribute_set ) ) - _Semaphore_MP_Send_process_packet( - SEMAPHORE_MP_ANNOUNCE_CREATE, - the_semaphore->Object.id, - name, - 0 /* Not used */ + _Semaphore_MP_Send_process_packet( SEMAPHORE_MP_ANNOUNCE_CREATE, + the_semaphore->Object.id, + name, + 0 /* Not used */ ); #endif _Objects_Allocator_unlock(); @@ -267,8 +243,6 @@ static void _Semaphore_Manager_initialization( void ) _Objects_Initialize_information( &_Semaphore_Information ); } -RTEMS_SYSINIT_ITEM( - _Semaphore_Manager_initialization, - RTEMS_SYSINIT_CLASSIC_SEMAPHORE, - RTEMS_SYSINIT_ORDER_MIDDLE -); +RTEMS_SYSINIT_ITEM( _Semaphore_Manager_initialization, + RTEMS_SYSINIT_CLASSIC_SEMAPHORE, + RTEMS_SYSINIT_ORDER_MIDDLE ); diff --git a/cpukit/score/src/threadqenqueue.c b/cpukit/score/src/threadqenqueue.c index ba31b13dd1..e9214f0abe 100644 --- a/cpukit/score/src/threadqenqueue.c +++ b/cpukit/score/src/threadqenqueue.c @@ -28,23 +28,23 @@ #include "config.h" #endif -#include <rtems/score/threadqimpl.h> #include <rtems/score/assert.h> +#include <rtems/score/status.h> #include <rtems/score/threaddispatch.h> #include <rtems/score/threadimpl.h> -#include <rtems/score/status.h> +#include <rtems/score/threadqimpl.h> #include <rtems/score/watchdogimpl.h> -#define THREAD_QUEUE_INTEND_TO_BLOCK \ - (THREAD_WAIT_CLASS_OBJECT | THREAD_WAIT_STATE_INTEND_TO_BLOCK) +#define THREAD_QUEUE_INTEND_TO_BLOCK \ + ( THREAD_WAIT_CLASS_OBJECT | THREAD_WAIT_STATE_INTEND_TO_BLOCK ) -#define THREAD_QUEUE_BLOCKED \ - (THREAD_WAIT_CLASS_OBJECT | THREAD_WAIT_STATE_BLOCKED) +#define THREAD_QUEUE_BLOCKED \ + ( THREAD_WAIT_CLASS_OBJECT | THREAD_WAIT_STATE_BLOCKED ) -#define THREAD_QUEUE_READY_AGAIN \ - (THREAD_WAIT_CLASS_OBJECT | THREAD_WAIT_STATE_READY_AGAIN) +#define THREAD_QUEUE_READY_AGAIN \ + ( THREAD_WAIT_CLASS_OBJECT | THREAD_WAIT_STATE_READY_AGAIN ) -#if defined(RTEMS_SMP) +#if defined( RTEMS_SMP ) /* * A global registry of active thread queue links is used to provide deadlock * detection on SMP configurations. This is simple to implement and no @@ -62,16 +62,13 @@ typedef struct { static Thread_queue_Links _Thread_queue_Links = { ISR_LOCK_INITIALIZER( "Thread Queue Links" ), - RBTREE_INITIALIZER_EMPTY( _Thread_queue_Links.Links ) -}; + RBTREE_INITIALIZER_EMPTY( _Thread_queue_Links.Links ) }; -static bool _Thread_queue_Link_equal( - const void *left, - const RBTree_Node *right -) +static bool _Thread_queue_Link_equal( const void *left, + const RBTree_Node *right ) { const Thread_queue_Queue *the_left; - const Thread_queue_Link *the_right; + const Thread_queue_Link *the_right; the_left = left; the_right = (Thread_queue_Link *) right; @@ -79,13 +76,11 @@ static bool _Thread_queue_Link_equal( return the_left == the_right->source; } -static bool _Thread_queue_Link_less( - const void *left, - const RBTree_Node *right -) +static bool _Thread_queue_Link_less( const void *left, + const RBTree_Node *right ) { const Thread_queue_Queue *the_left; - const Thread_queue_Link *the_right; + const Thread_queue_Link *the_right; the_left = left; the_right = (Thread_queue_Link *) right; @@ -98,29 +93,23 @@ static void *_Thread_queue_Link_map( RBTree_Node *node ) return node; } -static Thread_queue_Link *_Thread_queue_Link_find( - Thread_queue_Links *links, - Thread_queue_Queue *source -) +static Thread_queue_Link *_Thread_queue_Link_find( Thread_queue_Links *links, + Thread_queue_Queue *source ) { - return _RBTree_Find_inline( - &links->Links, - source, - _Thread_queue_Link_equal, - _Thread_queue_Link_less, - _Thread_queue_Link_map - ); + return _RBTree_Find_inline( &links->Links, + source, + _Thread_queue_Link_equal, + _Thread_queue_Link_less, + _Thread_queue_Link_map ); } -static bool _Thread_queue_Link_add( - Thread_queue_Link *link, - Thread_queue_Queue *source, - Thread_queue_Queue *target -) +static bool _Thread_queue_Link_add( Thread_queue_Link *link, + Thread_queue_Queue *source, + Thread_queue_Queue *target ) { Thread_queue_Links *links; Thread_queue_Queue *recursive_target; - ISR_lock_Context lock_context; + ISR_lock_Context lock_context; link->source = source; link->target = target; @@ -147,12 +136,10 @@ static bool _Thread_queue_Link_add( } } - _RBTree_Insert_inline( - &links->Links, - &link->Registry_node, - source, - _Thread_queue_Link_less - ); + _RBTree_Insert_inline( &links->Links, + &link->Registry_node, + source, + _Thread_queue_Link_less ); _ISR_lock_Release( &links->Lock, &lock_context ); return true; @@ -161,7 +148,7 @@ static bool _Thread_queue_Link_add( static void _Thread_queue_Link_remove( Thread_queue_Link *link ) { Thread_queue_Links *links; - ISR_lock_Context lock_context; + ISR_lock_Context lock_context; links = &_Thread_queue_Links; @@ -171,14 +158,13 @@ static void _Thread_queue_Link_remove( Thread_queue_Link *link ) } #endif -#if !defined(RTEMS_SMP) +#if !defined( RTEMS_SMP ) static #endif -void _Thread_queue_Path_release_critical( - Thread_queue_Context *queue_context -) + void + _Thread_queue_Path_release_critical( Thread_queue_Context *queue_context ) { -#if defined(RTEMS_SMP) +#if defined( RTEMS_SMP ) Chain_Node *head; Chain_Node *node; @@ -192,20 +178,16 @@ void _Thread_queue_Path_release_critical( if ( link->Lock_context.Wait.queue != NULL ) { _Thread_queue_Link_remove( link ); - _Thread_Wait_release_queue_critical( - link->Lock_context.Wait.queue, - &link->Lock_context - ); + _Thread_Wait_release_queue_critical( link->Lock_context.Wait.queue, + &link->Lock_context ); _Thread_Wait_remove_request( link->owner, &link->Lock_context ); } else { - _Thread_Wait_release_default_critical( - link->owner, - &link->Lock_context.Lock_context - ); + _Thread_Wait_release_default_critical( link->owner, + &link->Lock_context.Lock_context ); } node = _Chain_Previous( node ); -#if defined(RTEMS_DEBUG) +#if defined( RTEMS_DEBUG ) _Chain_Set_off_chain( &link->Path_node ); #endif } @@ -214,11 +196,10 @@ void _Thread_queue_Path_release_critical( #endif } -#if defined(RTEMS_SMP) -static void _Thread_queue_Path_append_deadlock_thread( - Thread_Control *the_thread, - Thread_queue_Context *queue_context -) +#if defined( RTEMS_SMP ) +static void +_Thread_queue_Path_append_deadlock_thread( Thread_Control *the_thread, + Thread_queue_Context *queue_context ) { Thread_Control *deadlock; @@ -242,32 +223,26 @@ static void _Thread_queue_Path_append_deadlock_thread( link = &queue_context->Path.Deadlock; _Chain_Initialize_node( &link->Path_node ); - _Chain_Append_unprotected( - &queue_context->Path.Links, - &link->Path_node - ); + _Chain_Append_unprotected( &queue_context->Path.Links, &link->Path_node ); link->owner = deadlock; link->Lock_context.Wait.queue = NULL; - _Thread_Wait_acquire_default_critical( - deadlock, - &link->Lock_context.Lock_context - ); + _Thread_Wait_acquire_default_critical( deadlock, + &link->Lock_context.Lock_context ); } } #endif -#if !defined(RTEMS_SMP) +#if !defined( RTEMS_SMP ) static #endif -bool _Thread_queue_Path_acquire_critical( - Thread_queue_Queue *queue, - Thread_Control *the_thread, - Thread_queue_Context *queue_context -) + bool + _Thread_queue_Path_acquire_critical( Thread_queue_Queue *queue, + Thread_Control *the_thread, + Thread_queue_Context *queue_context ) { - Thread_Control *owner; -#if defined(RTEMS_SMP) - Thread_queue_Link *link; + Thread_Control *owner; +#if defined( RTEMS_SMP ) + Thread_queue_Link *link; Thread_queue_Queue *target; /* @@ -291,8 +266,7 @@ bool _Thread_queue_Path_acquire_critical( } _Chain_Initialize_node( - &queue_context->Path.Start.Lock_context.Wait.Gate.Node - ); + &queue_context->Path.Start.Lock_context.Wait.Gate.Node ); link = &queue_context->Path.Start; _RBTree_Initialize_node( &link->Registry_node ); _Chain_Initialize_node( &link->Path_node ); @@ -301,24 +275,19 @@ bool _Thread_queue_Path_acquire_critical( _Chain_Append_unprotected( &queue_context->Path.Links, &link->Path_node ); link->owner = owner; - _Thread_Wait_acquire_default_critical( - owner, - &link->Lock_context.Lock_context - ); + _Thread_Wait_acquire_default_critical( owner, + &link->Lock_context.Lock_context ); target = owner->Wait.queue; link->Lock_context.Wait.queue = target; if ( target != NULL ) { if ( _Thread_queue_Link_add( link, queue, target ) ) { - _Thread_queue_Gate_add( - &owner->Wait.Lock.Pending_requests, - &link->Lock_context.Wait.Gate - ); + _Thread_queue_Gate_add( &owner->Wait.Lock.Pending_requests, + &link->Lock_context.Wait.Gate ); _Thread_Wait_release_default_critical( owner, - &link->Lock_context.Lock_context - ); + &link->Lock_context.Lock_context ); _Thread_Wait_acquire_queue_critical( target, &link->Lock_context ); if ( link->Lock_context.Wait.queue == NULL ) { @@ -326,8 +295,7 @@ bool _Thread_queue_Path_acquire_critical( _Thread_Wait_release_queue_critical( target, &link->Lock_context ); _Thread_Wait_acquire_default_critical( owner, - &link->Lock_context.Lock_context - ); + &link->Lock_context.Lock_context ); _Thread_Wait_remove_request_locked( owner, &link->Lock_context ); _Assert( owner->Wait.queue == NULL ); return true; @@ -365,11 +333,10 @@ bool _Thread_queue_Path_acquire_critical( } void _Thread_queue_Enqueue_do_nothing_extra( - Thread_queue_Queue *queue, - Thread_Control *the_thread, - Per_CPU_Control *cpu_self, - Thread_queue_Context *queue_context -) + Thread_queue_Queue *queue, + Thread_Control *the_thread, + Per_CPU_Control *cpu_self, + Thread_queue_Context *queue_context ) { /* Do nothing */ } @@ -384,19 +351,17 @@ void _Thread_queue_Deadlock_fatal( Thread_Control *the_thread ) _Internal_error( INTERNAL_ERROR_THREAD_QUEUE_DEADLOCK ); } -void _Thread_queue_Enqueue( - Thread_queue_Queue *queue, - const Thread_queue_Operations *operations, - Thread_Control *the_thread, - Thread_queue_Context *queue_context -) +void _Thread_queue_Enqueue( Thread_queue_Queue *queue, + const Thread_queue_Operations *operations, + Thread_Control *the_thread, + Thread_queue_Context *queue_context ) { Per_CPU_Control *cpu_self; - bool success; + bool success; _Assert( queue_context->enqueue_callout != NULL ); -#if defined(RTEMS_MULTIPROCESSING) +#if defined( RTEMS_MULTIPROCESSING ) if ( _Thread_MP_Is_receive( the_thread ) && the_thread->receive_packet ) { the_thread = _Thread_MP_Allocate_proxy( queue_context->thread_state ); } @@ -404,10 +369,13 @@ void _Thread_queue_Enqueue( _Thread_Wait_claim( the_thread, queue ); - if ( !_Thread_queue_Path_acquire_critical( queue, the_thread, queue_context ) ) { + if ( !_Thread_queue_Path_acquire_critical( queue, + the_thread, + queue_context ) ) { _Thread_queue_Path_release_critical( queue_context ); _Thread_Wait_restore_default( the_thread ); - _Thread_queue_Queue_release( queue, &queue_context->Lock_context.Lock_context ); + _Thread_queue_Queue_release( queue, + &queue_context->Lock_context.Lock_context ); _Thread_Wait_tranquilize( the_thread ); _Assert( queue_context->deadlock_callout != NULL ); ( *queue_context->deadlock_callout )( the_thread ); @@ -423,14 +391,13 @@ void _Thread_queue_Enqueue( the_thread->Wait.return_code = STATUS_SUCCESSFUL; _Thread_Wait_flags_set( the_thread, THREAD_QUEUE_INTEND_TO_BLOCK ); cpu_self = _Thread_queue_Dispatch_disable( queue_context ); - _Thread_queue_Queue_release( queue, &queue_context->Lock_context.Lock_context ); + _Thread_queue_Queue_release( queue, + &queue_context->Lock_context.Lock_context ); - ( *queue_context->enqueue_callout )( - queue, - the_thread, - cpu_self, - queue_context - ); + ( *queue_context->enqueue_callout )( queue, + the_thread, + cpu_self, + queue_context ); /* * Set the blocking state for this thread queue in the thread. @@ -446,11 +413,9 @@ void _Thread_queue_Enqueue( * as long as we are in the THREAD_QUEUE_INTEND_TO_BLOCK thread wait state, * thus we have to cancel the blocking operation ourself if necessary. */ - success = _Thread_Wait_flags_try_change_acquire( - the_thread, - THREAD_QUEUE_INTEND_TO_BLOCK, - THREAD_QUEUE_BLOCKED - ); + success = _Thread_Wait_flags_try_change_acquire( the_thread, + THREAD_QUEUE_INTEND_TO_BLOCK, + THREAD_QUEUE_BLOCKED ); if ( !success ) { _Thread_Remove_timer_and_unblock( the_thread, queue ); } @@ -459,13 +424,12 @@ void _Thread_queue_Enqueue( _Thread_Dispatch_direct( cpu_self ); } -#if defined(RTEMS_SMP) -Status_Control _Thread_queue_Enqueue_sticky( - Thread_queue_Queue *queue, - const Thread_queue_Operations *operations, - Thread_Control *the_thread, - Thread_queue_Context *queue_context -) +#if defined( RTEMS_SMP ) +Status_Control +_Thread_queue_Enqueue_sticky( Thread_queue_Queue *queue, + const Thread_queue_Operations *operations, + Thread_Control *the_thread, + Thread_queue_Context *queue_context ) { Per_CPU_Control *cpu_self; @@ -473,10 +437,13 @@ Status_Control _Thread_queue_Enqueue_sticky( _Thread_Wait_claim( the_thread, queue ); - if ( !_Thread_queue_Path_acquire_critical( queue, the_thread, queue_context ) ) { + if ( !_Thread_queue_Path_acquire_critical( queue, + the_thread, + queue_context ) ) { _Thread_queue_Path_release_critical( queue_context ); _Thread_Wait_restore_default( the_thread ); - _Thread_queue_Queue_release( queue, &queue_context->Lock_context.Lock_context ); + _Thread_queue_Queue_release( queue, + &queue_context->Lock_context.Lock_context ); _Thread_Wait_tranquilize( the_thread ); ( *queue_context->deadlock_callout )( the_thread ); return _Thread_Wait_get_status( the_thread ); @@ -491,28 +458,25 @@ Status_Control _Thread_queue_Enqueue_sticky( the_thread->Wait.return_code = STATUS_SUCCESSFUL; _Thread_Wait_flags_set( the_thread, THREAD_QUEUE_INTEND_TO_BLOCK ); cpu_self = _Thread_queue_Dispatch_disable( queue_context ); - _Thread_queue_Queue_release( queue, &queue_context->Lock_context.Lock_context ); + _Thread_queue_Queue_release( queue, + &queue_context->Lock_context.Lock_context ); if ( cpu_self->thread_dispatch_disable_level != 1 ) { _Internal_error( - INTERNAL_ERROR_THREAD_QUEUE_ENQUEUE_STICKY_FROM_BAD_STATE - ); + INTERNAL_ERROR_THREAD_QUEUE_ENQUEUE_STICKY_FROM_BAD_STATE ); } - ( *queue_context->enqueue_callout )( - queue, - the_thread, - cpu_self, - queue_context - ); + ( *queue_context->enqueue_callout )( queue, + the_thread, + cpu_self, + queue_context ); _Thread_Priority_update( queue_context ); _Thread_Priority_and_sticky_update( the_thread, 1 ); _Thread_Dispatch_enable( cpu_self ); - while ( - _Thread_Wait_flags_get_acquire( the_thread ) == THREAD_QUEUE_INTEND_TO_BLOCK - ) { + while ( _Thread_Wait_flags_get_acquire( the_thread ) == + THREAD_QUEUE_INTEND_TO_BLOCK ) { /* Wait */ } @@ -522,14 +486,13 @@ Status_Control _Thread_queue_Enqueue_sticky( } #endif -#if defined(RTEMS_MULTIPROCESSING) -static bool _Thread_queue_MP_set_callout( - Thread_Control *the_thread, - const Thread_queue_Context *queue_context -) +#if defined( RTEMS_MULTIPROCESSING ) +static bool +_Thread_queue_MP_set_callout( Thread_Control *the_thread, + const Thread_queue_Context *queue_context ) { - Thread_Proxy_control *the_proxy; - Thread_queue_MP_callout mp_callout; + Thread_Proxy_control *the_proxy; + Thread_queue_MP_callout mp_callout; if ( _Objects_Is_local_id( the_thread->Object.id ) ) { return false; @@ -552,11 +515,9 @@ static bool _Thread_queue_Make_ready_again( Thread_Control *the_thread ) * We must update the wait flags under protection of the current thread lock, * otherwise a _Thread_Timeout() running on another processor may interfere. */ - success = _Thread_Wait_flags_try_change_release( - the_thread, - THREAD_QUEUE_INTEND_TO_BLOCK, - THREAD_QUEUE_READY_AGAIN - ); + success = _Thread_Wait_flags_try_change_release( the_thread, + THREAD_QUEUE_INTEND_TO_BLOCK, + THREAD_QUEUE_READY_AGAIN ); if ( success ) { unblock = false; } else { @@ -569,26 +530,22 @@ static bool _Thread_queue_Make_ready_again( Thread_Control *the_thread ) return unblock; } -bool _Thread_queue_Extract_locked( - Thread_queue_Queue *queue, - const Thread_queue_Operations *operations, - Thread_Control *the_thread, - Thread_queue_Context *queue_context -) +bool _Thread_queue_Extract_locked( Thread_queue_Queue *queue, + const Thread_queue_Operations *operations, + Thread_Control *the_thread, + Thread_queue_Context *queue_context ) { -#if defined(RTEMS_MULTIPROCESSING) +#if defined( RTEMS_MULTIPROCESSING ) _Thread_queue_MP_set_callout( the_thread, queue_context ); #endif ( *operations->extract )( queue, the_thread, queue_context ); return _Thread_queue_Make_ready_again( the_thread ); } -void _Thread_queue_Unblock_critical( - bool unblock, - Thread_queue_Queue *queue, - Thread_Control *the_thread, - ISR_lock_Context *lock_context -) +void _Thread_queue_Unblock_critical( bool unblock, + Thread_queue_Queue *queue, + Thread_Control *the_thread, + ISR_lock_Context *lock_context ) { if ( unblock ) { Per_CPU_Control *cpu_self; @@ -604,34 +561,28 @@ void _Thread_queue_Unblock_critical( } } -void _Thread_queue_Extract_critical( - Thread_queue_Queue *queue, - const Thread_queue_Operations *operations, - Thread_Control *the_thread, - Thread_queue_Context *queue_context -) +void _Thread_queue_Extract_critical( Thread_queue_Queue *queue, + const Thread_queue_Operations *operations, + Thread_Control *the_thread, + Thread_queue_Context *queue_context ) { bool unblock; - unblock = _Thread_queue_Extract_locked( - queue, - operations, - the_thread, - queue_context - ); - - _Thread_queue_Unblock_critical( - unblock, - queue, - the_thread, - &queue_context->Lock_context.Lock_context - ); + unblock = _Thread_queue_Extract_locked( queue, + operations, + the_thread, + queue_context ); + + _Thread_queue_Unblock_critical( unblock, + queue, + the_thread, + &queue_context->Lock_context.Lock_context ); } void _Thread_queue_Extract( Thread_Control *the_thread ) { - Thread_queue_Context queue_context; - Thread_queue_Queue *queue; + Thread_queue_Context queue_context; + Thread_queue_Queue *queue; _Thread_queue_Context_initialize( &queue_context ); _Thread_queue_Context_clear_priority_updates( &queue_context ); @@ -643,51 +594,39 @@ void _Thread_queue_Extract( Thread_Control *the_thread ) bool unblock; _Thread_Wait_remove_request( the_thread, &queue_context.Lock_context ); - _Thread_queue_Context_set_MP_callout( - &queue_context, - _Thread_queue_MP_callout_do_nothing - ); - unblock = _Thread_queue_Extract_locked( - queue, - the_thread->Wait.operations, - the_thread, - &queue_context - ); - _Thread_queue_Unblock_critical( - unblock, - queue, - the_thread, - &queue_context.Lock_context.Lock_context - ); + _Thread_queue_Context_set_MP_callout( &queue_context, + _Thread_queue_MP_callout_do_nothing ); + unblock = _Thread_queue_Extract_locked( queue, + the_thread->Wait.operations, + the_thread, + &queue_context ); + _Thread_queue_Unblock_critical( unblock, + queue, + the_thread, + &queue_context.Lock_context.Lock_context ); } else { _Thread_Wait_release( the_thread, &queue_context ); } } -void _Thread_queue_Surrender( - Thread_queue_Queue *queue, - Thread_queue_Heads *heads, - Thread_Control *previous_owner, - Thread_queue_Context *queue_context, - const Thread_queue_Operations *operations -) +void _Thread_queue_Surrender( Thread_queue_Queue *queue, + Thread_queue_Heads *heads, + Thread_Control *previous_owner, + Thread_queue_Context *queue_context, + const Thread_queue_Operations *operations ) { - Thread_Control *new_owner; - bool unblock; + Thread_Control *new_owner; + bool unblock; Per_CPU_Control *cpu_self; _Assert( heads != NULL ); _Thread_queue_Context_clear_priority_updates( queue_context ); - new_owner = ( *operations->surrender )( - queue, - heads, - previous_owner, - queue_context - ); + new_owner = + ( *operations->surrender )( queue, heads, previous_owner, queue_context ); queue->owner = new_owner; -#if defined(RTEMS_MULTIPROCESSING) +#if defined( RTEMS_MULTIPROCESSING ) if ( !_Thread_queue_MP_set_callout( new_owner, queue_context ) ) #endif { @@ -697,10 +636,8 @@ void _Thread_queue_Surrender( unblock = _Thread_queue_Make_ready_again( new_owner ); cpu_self = _Thread_queue_Dispatch_disable( queue_context ); - _Thread_queue_Queue_release( - queue, - &queue_context->Lock_context.Lock_context - ); + _Thread_queue_Queue_release( queue, + &queue_context->Lock_context.Lock_context ); _Thread_Priority_update( queue_context ); @@ -711,52 +648,44 @@ void _Thread_queue_Surrender( _Thread_Dispatch_enable( cpu_self ); } -#if defined(RTEMS_SMP) -void _Thread_queue_Surrender_sticky( - Thread_queue_Queue *queue, - Thread_queue_Heads *heads, - Thread_Control *previous_owner, - Thread_queue_Context *queue_context, - const Thread_queue_Operations *operations -) +#if defined( RTEMS_SMP ) +void _Thread_queue_Surrender_sticky( Thread_queue_Queue *queue, + Thread_queue_Heads *heads, + Thread_Control *previous_owner, + Thread_queue_Context *queue_context, + const Thread_queue_Operations *operations ) { - Thread_Control *new_owner; + Thread_Control *new_owner; Per_CPU_Control *cpu_self; _Assert( heads != NULL ); _Thread_queue_Context_clear_priority_updates( queue_context ); - new_owner = ( *operations->surrender )( - queue, - heads, - previous_owner, - queue_context - ); + new_owner = + ( *operations->surrender )( queue, heads, previous_owner, queue_context ); queue->owner = new_owner; _Thread_queue_Make_ready_again( new_owner ); cpu_self = _Thread_queue_Dispatch_disable( queue_context ); - _Thread_queue_Queue_release( - queue, - &queue_context->Lock_context.Lock_context - ); + _Thread_queue_Queue_release( queue, + &queue_context->Lock_context.Lock_context ); _Thread_Priority_and_sticky_update( previous_owner, -1 ); _Thread_Priority_and_sticky_update( new_owner, 0 ); _Thread_Dispatch_enable( cpu_self ); } #endif -Thread_Control *_Thread_queue_Do_dequeue( - Thread_queue_Control *the_thread_queue, - const Thread_queue_Operations *operations -#if defined(RTEMS_MULTIPROCESSING) - , - Thread_queue_MP_callout mp_callout +Thread_Control * +_Thread_queue_Do_dequeue( Thread_queue_Control *the_thread_queue, + const Thread_queue_Operations *operations +#if defined( RTEMS_MULTIPROCESSING ) + , + Thread_queue_MP_callout mp_callout #endif ) { - Thread_queue_Context queue_context; - Thread_Control *the_thread; + Thread_queue_Context queue_context; + Thread_Control *the_thread; _Thread_queue_Context_initialize( &queue_context ); _Thread_queue_Context_set_MP_callout( &queue_context, mp_callout ); @@ -765,12 +694,10 @@ Thread_Control *_Thread_queue_Do_dequeue( the_thread = _Thread_queue_First_locked( the_thread_queue, operations ); if ( the_thread != NULL ) { - _Thread_queue_Extract_critical( - &the_thread_queue->Queue, - operations, - the_thread, - &queue_context - ); + _Thread_queue_Extract_critical( &the_thread_queue->Queue, + operations, + the_thread, + &queue_context ); } else { _Thread_queue_Release( the_thread_queue, &queue_context ); } @@ -778,15 +705,13 @@ Thread_Control *_Thread_queue_Do_dequeue( return the_thread; } -#if defined(RTEMS_MULTIPROCESSING) -void _Thread_queue_Unblock_proxy( - Thread_queue_Queue *queue, - Thread_Control *the_thread -) +#if defined( RTEMS_MULTIPROCESSING ) +void _Thread_queue_Unblock_proxy( Thread_queue_Queue *queue, + Thread_Control *the_thread ) { const Thread_queue_Object *the_queue_object; - Thread_Proxy_control *the_proxy; - Thread_queue_MP_callout mp_callout; + Thread_Proxy_control *the_proxy; + Thread_queue_MP_callout mp_callout; the_queue_object = THREAD_QUEUE_QUEUE_TO_OBJECT( queue ); the_proxy = (Thread_Proxy_control *) the_thread; -- 2.26.2 _______________________________________________ devel mailing list devel@rtems.org http://lists.rtems.org/mailman/listinfo/devel