自学教程：C++ GT_setFailureReason函数代码示例

/*! *  @brief      Setup SysLinkMemUtils module. * *  @sa         _SysLinkMemUtils_exit */static Void_SysLinkMemUtils_init (Void){    List_Params             listParams;    GT_0trace (curTrace, GT_ENTER, "_SysLinkMemUtils_init");    List_Params_init (&listParams);    SysLinkMemUtils_module->addrTable = List_create (&listParams);#if !defined(SYSLINK_BUILD_OPTIMIZE)    if (!SysLinkMemUtils_module->addrTable) {        GT_setFailureReason (curTrace,                             GT_4CLASS,                             (Char *)__func__,                             PROCMGR_E_MEMORY,                             "Translation list could not be created!");    }#endif /* if !defined(SYSLINK_BUILD_OPTIMIZE) */    SysLinkMemUtils_module->semList = OsalSemaphore_create (                                                OsalSemaphore_Type_Counting, 1);#if !defined(SYSLINK_BUILD_OPTIMIZE)    if (!SysLinkMemUtils_module->semList) {        GT_setFailureReason (curTrace,                             GT_4CLASS,                             (Char *)__func__,                             PROCMGR_E_MEMORY,                             "List semaphore could not be created!");    }#endif /* if !defined(SYSLINK_BUILD_OPTIMIZE) */    GT_0trace (curTrace, GT_LEAVE, "_SysLinkMemUtils_init");}

/*! *  @brief      Function to initialize the parameters for this PwrMgr instance. * *  @param      params  Configuration parameters. * *  @sa         DM8168DUCATIPWR_create */VoidDM8168DUCATIPWR_Params_init (DM8168DUCATIPWR_Params * params){    GT_1trace (curTrace, GT_ENTER, "DM8168DUCATIPWR_Params_init", params);    GT_assert (curTrace, (params != NULL));    GT_assert (curTrace, (DM8168DUCATIPWR_state.refCount != 0));#if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)    if (DM8168DUCATIPWR_state.refCount == 0) {        GT_setFailureReason (curTrace,                             GT_4CLASS,                             "DM8168DUCATIPWR_Params_initv",                             DM8168DUCATIPWR_E_INVALIDSTATE,                             "Module was not initialized!");    }    else if (params == NULL) {        GT_setFailureReason (curTrace,                             GT_4CLASS,                             "DM8168DUCATIPWR_Params_init",                             PWRMGR_E_INVALIDARG,                             "Argument of type (DM8168DUCATIPWR_Params *) "                             "passed is null!");    }    else {#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */        params->reserved = 0;#if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)    }#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */    GT_0trace (curTrace, GT_LEAVE, "DM8168DUCATIPWR_Params_init");}

/* Function to allocate the specified number of bytes and memory is set to * the specified value. */PtrMemory_valloc (IHeap_Handle heap, SizeT size, SizeT align, Char value, Ptr eb){    Ptr buffer = NULL;    GT_4trace (curTrace, GT_ENTER, "Memory_valloc", heap, size, align, eb);    /* Check whether the right paramaters are passed or not.*/    GT_assert (curTrace, (size > 0));    (Void) eb; /* Not used. */    if (heap == NULL) {        buffer = MemoryOS_alloc (size, align, 0);#if !defined(SYSLINK_BUILD_OPTIMIZE)        if (buffer == NULL) {            /*! @retval NULL Failed to allocate memory */            GT_setFailureReason (curTrace,                                 GT_4CLASS,                                 "Memory_valloc",                                 Memory_E_MEMORY,                                 "Failed to allocate memory!");        }#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */    }    else {        buffer = IHeap_alloc (heap, size, align);#if !defined(SYSLINK_BUILD_OPTIMIZE)        if (buffer == NULL) {            /*! @retval NULL Heap_alloc failed */            GT_setFailureReason (curTrace,                                 GT_4CLASS,                                 "Memory_valloc",                                 Memory_E_MEMORY,                                 "IHeap_alloc failed!");        }#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */    }#if !defined(SYSLINK_BUILD_OPTIMIZE)    if (buffer != NULL) {#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */        buffer = Memory_set (buffer, value, size);#if !defined(SYSLINK_BUILD_OPTIMIZE)        if (buffer == NULL) {            /*! @retval NULL Memory_set to 0 failed */            GT_setFailureReason (curTrace,                                 GT_4CLASS,                                 "Memory_valloc",                                 Memory_E_MEMORY,                                 "Memory_set to 0 failed!");        }    }#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */    GT_0trace (curTrace, GT_LEAVE, "Memory_valloc");    /*! @retval Pointer Success: Pointer to allocated buffer */    return buffer;}

/*! *  @brief  Function to open the NameServer driver. * *  @sa     NameServerDrv_close */Int NameServerDrv_open(Void){    Int status = NameServer_S_SUCCESS;    GT_0trace(curTrace, GT_ENTER, "NameServerDrv_open");    /* TBD: Protection for refCount. */    if (NameServerDrv_refCount == 0) {        /* open the drive */        NameServerDrv_handle = Dev_pollOpen(NAMESERVER_DRVIER_NAME,                O_SYNC | O_RDWR);        if (NameServerDrv_handle < 0) {            status = NameServer_E_OSFAILURE;            GT_setFailureReason(curTrace, GT_4CLASS, "NameServerDrv_open",                    status, "Failed to open NameServer driver with OS");        }        /* set flag to close file descriptor on exec */        if (status == NameServer_S_SUCCESS) {            status = fcntl(NameServerDrv_handle, F_SETFD, FD_CLOEXEC);            if (status != 0) {                status = NameServer_E_OSFAILURE;                GT_setFailureReason(curTrace, GT_4CLASS, "NameServerDrv_open",                        status, "Failed to set file descriptor flags");            }        }        /* set pid on file descriptor for resource tracking */        if (status == NameServer_S_SUCCESS) {            status = fcntl(NameServerDrv_handle, F_SETOWN, getpid());            if (status != 0) {                status = NameServer_E_OSFAILURE;                GT_setFailureReason(curTrace, GT_4CLASS, "NameServerDrv_open",                    status, "Failed to set process id");            }        }    }    if (status == NameServer_S_SUCCESS) {        NameServerDrv_refCount++;    }    /* failure case */    if (status < 0) {        if (NameServerDrv_handle > 0) {            close(NameServerDrv_handle);            NameServerDrv_handle = 0;        }    }    GT_1trace(curTrace, GT_LEAVE, "NameServerDrv_open", status);    return(status);}

/*! *  @brief  Function to open the HeapMultiBuf driver. * *  @sa     HeapMultiBufDrv_close */IntHeapMultiBufDrv_open (Void){    //Int status      = HEAPMULTIBUF_SUCCESS;    Int status      = 0;    int osStatus    = 0;    GT_0trace (curTrace, GT_ENTER, "HeapMultiBufDrv_open");#if 0    if (HeapMultiBufDrv_refCount == 0) {        HeapMultiBufDrv_handle = open (HEAPMULTIBUF_DRIVER_NAME,                                  O_SYNC | O_RDWR);        if (HeapMultiBufDrv_handle < 0) {            perror (HEAPMULTIBUF_DRIVER_NAME);            /*! @retval HEAPMULTIBUF_E_OSFAILURE Failed to open             *          HeapMultiBuf driver with OS             */            status = HEAPMULTIBUF_E_OSFAILURE;            GT_setFailureReason (curTrace,                                 GT_4CLASS,                                 "HeapMultiBufDrv_open",                                 status,                                 "Failed to open HeapMultiBuf driver with OS!");        }        else {            osStatus = fcntl (HeapMultiBufDrv_handle, F_SETFD, FD_CLOEXEC);            if (osStatus != 0) {                /*! @retval HEAPMULTIBUF_E_OSFAILURE                 *          Failed to set file descriptor flags                 */                status = HEAPMULTIBUF_E_OSFAILURE;                GT_setFailureReason (curTrace,                                     GT_4CLASS,                                     "HeapMultiBufDrv_open",                                     status,                                     "Failed to set file descriptor flags!");            }            else {                /* TBD: Protection for refCount. */                HeapMultiBufDrv_refCount++;            }        }    }    else {        HeapMultiBufDrv_refCount++;    }#endif    GT_1trace (curTrace, GT_LEAVE, "HeapMultiBufDrv_open", status);    /*! @retval HEAPMULTIBUF_SUCCESS Operation successfully completed. */    return status;}

/*! *  @brief  Function to open the ListMP driver. * *  @sa     ListMPDrv_close */IntListMPDrv_open (Void){    Int status      = ListMP_S_SUCCESS;    int osStatus    = 0;    GT_0trace (curTrace, GT_ENTER, "ListMPDrv_open");    if (ListMPDrv_refCount == 0) {        ListMPDrv_handle = open (LISTMP_DRIVER_NAME,                                 O_SYNC | O_RDWR);        if (ListMPDrv_handle < 0) {            perror (LISTMP_DRIVER_NAME);            /*! @retval ListMP_E_OSFAILURE             *          Failed to open ListMP driver with OS             */            status = ListMP_E_OSFAILURE;            GT_setFailureReason (curTrace,                                 GT_4CLASS,                                 "ListMPDrv_open",                                 status,                                 "Failed to open ListMP driver"                                 " with OS!");        }        else {            osStatus = fcntl (ListMPDrv_handle,                              F_SETFD,                              FD_CLOEXEC);            if (osStatus != 0) {                /*! @retval ListMP_E_OSFAILURE                 *          Failed to set file descriptor flags                 */                status = ListMP_E_OSFAILURE;                GT_setFailureReason (curTrace,                                     GT_4CLASS,                                     "ListMPDrv_open",                                     status,                                     "Failed to set file descriptor flags!");            }            else{                /* TBD: Protection for refCount. */                ListMPDrv_refCount++;            }        }    }    else {        ListMPDrv_refCount++;    }    GT_1trace (curTrace, GT_LEAVE, "ListMPDrv_open", status);    /*! @retval ListMP_S_SUCCESS Operation successfully completed. */    return status;}

/*! *  @brief  Function to open the Notify driver. * *  @param  createThread  Flag to indicate whether to create thread or not. * *  @sa     NotifyDrvUsr_close */IntNotifyDrvUsr_open (Bool createThread){    Int    status   = Notify_S_SUCCESS;    GT_1trace (curTrace, GT_ENTER, "NotifyDrvUsr_open", createThread);    if (NotifyDrvUsr_refCount == 0) {        /* TBD: Protection for refCount. */        NotifyDrvUsr_refCount++;        if (createThread == TRUE) {            Notify_CmdArgsThreadAttach attachParams;            attachParams.pid = getpid ();            status = NotifyDrvUsr_ioctl (CMD_NOTIFY_THREADATTACH, &attachParams);            if (status < 0) {                GT_setFailureReason (curTrace,                                     GT_4CLASS,                                     "NotifyDrvUsr_close",                                     status,                                     "Notify attach failed on kernel "                                     "side!");            }            else {                /* Create the pthread */                pthread_create (&NotifyDrv_workerThread,                                NULL,                                (Ptr) _NotifyDrvUsr_eventWorker,                                NULL);                if (NotifyDrv_workerThread == (UInt32) NULL) {                    /*! @retval Notify_E_OSFAILURE Failed to create                                                   Notify thread */                    status = Notify_E_OSFAILURE;                    GT_setFailureReason (curTrace,                                         GT_4CLASS,                                         "NotifyDrvUsr_open",                                         status,                                         "Failed to create Notify "                                         "thread!");                }            }        }    }    else {        /* TBD: Protection for refCount. */        NotifyDrvUsr_refCount++;    }    GT_1trace (curTrace, GT_LEAVE, "NotifyDrvUsr_open", status);    /*! @retval Notify_S_SUCCESS Operation successfully completed. */    return status;}

/*! *  @brief  Function to close the Notify driver. * *  @param  deleteThread  Flag to indicate whether to delete thread or not. * *  @sa     NotifyDrvUsr_open */IntNotifyDrvUsr_close (Bool deleteThread){    Int    status      = Notify_S_SUCCESS;    int    osStatus    = 0;    UInt32 pid;    Notify_CmdArgsThreadDetach cmdArgs;    GT_1trace (curTrace, GT_ENTER, "NotifyDrvUsr_close", deleteThread);    /* TBD: Protection for refCount. */    if (NotifyDrvUsr_refCount == 1) {        if (deleteThread == TRUE) {            pid = getpid ();            cmdArgs.pid = pid;            status = NotifyDrvUsr_ioctl (CMD_NOTIFY_THREADDETACH, &cmdArgs);            if (status < 0) {                GT_setFailureReason (curTrace,                                     GT_4CLASS,                                     "NotifyDrvUsr_close",                                     status,                                     "Notify detach failed on kernel side!");            }#ifndef LINUX_THREAD            pthread_join (NotifyDrv_workerThread, NULL);#endif        }        NotifyDrvUsr_refCount--;        osStatus = close (NotifyDrvUsr_handle);        if (osStatus != 0) {            perror ("Notify driver close: " NOTIFY_DRIVER_NAME);            /*! @retval Notify_E_OSFAILURE Failed to open Notify driver with                                            OS */            status = Notify_E_OSFAILURE;            GT_setFailureReason (curTrace,                                 GT_4CLASS,                                 "NotifyDrvUsr_close",                                 status,                                 "Failed to close Notify driver with OS!");        }        else {            NotifyDrvUsr_handle = -1;        }    }    else {        NotifyDrvUsr_refCount--;    }    GT_1trace (curTrace, GT_LEAVE, "NotifyDrvUsr_close", status);    return status;}

/*! *  @brief      Function to close a handle to an instance of this PwrMgr. * *  @param      handlePtr  Pointer to Handle to the PwrMgr instance * *  @sa         DM8168DUCATIPWR_open */IntDM8168DUCATIPWR_close (DM8168DUCATIPWR_Handle * handlePtr){    Int status = PWRMGR_SUCCESS;    GT_1trace (curTrace, GT_ENTER, "DM8168DUCATIPWR_close", handlePtr);    GT_assert (curTrace, (handlePtr != NULL));    GT_assert (curTrace, ((handlePtr != NULL) && (*handlePtr != NULL)));    GT_assert (curTrace, (DM8168DUCATIPWR_state.refCount != 0));#if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)    if (DM8168DUCATIPWR_state.refCount == 0) {        GT_setFailureReason (curTrace,                             GT_4CLASS,                             "DM8168DUCATIPWR_close",                             DM8168DUCATIPWR_E_INVALIDSTATE,                             "Module was not initialized!");    }    else if (handlePtr == NULL) {        /*! @retval PWRMGR_E_INVALIDARG Invalid NULL handlePtr pointer                                         specified*/        status = PWRMGR_E_INVALIDARG;        GT_setFailureReason (curTrace,                             GT_4CLASS,                             "DM8168DUCATIPWR_close",                             status,                             "Invalid NULL handlePtr pointer specified");    }    else if (*handlePtr == NULL) {        /*! @retval PWRMGR_E_HANDLE Invalid NULL *handlePtr specified */        status = PWRMGR_E_HANDLE;        GT_setFailureReason (curTrace,                             GT_4CLASS,                             "DM8168DUCATIPWR_close",                             status,                             "Invalid NULL *handlePtr specified");    }    else {#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined(SYSLINK_BUILD_HLOS) */        /* Nothing to be done for close. */        *handlePtr = NULL;#if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)    }#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined(SYSLINK_BUILD_HLOS) */    GT_1trace (curTrace, GT_LEAVE, "DM8168DUCATIPWR_close", status);    /*! @retval PWRMGR_SUCCESS Operation successful */    return status;}

/* * ======== OsalKfile_close ======== */IntOsalKfile_close (OsalKfile_Handle * fileHandle){    Int                 status      = OSALKFILE_SUCCESS;    OsalKfile_Object *  fileObject  = NULL;    mm_segment_t        fs;    GT_1trace (curTrace, GT_ENTER, "OsalKfile_close", fileHandle);    GT_assert (curTrace, (fileHandle != NULL));#if !defined(SYSLINK_BUILD_OPTIMIZE)    if (fileHandle == NULL) {        /*! @retval OSALKFILE_E_INVALIDARG NULL provided for argument                                           fileHandle. */        status = OSALKFILE_E_INVALIDARG;        GT_setFailureReason (curTrace,                             GT_4CLASS,                             "OsalKfile_close",                             status,                             "NULL provided for argument fileHandle");    }    else if (*fileHandle == NULL) {        /*! @retval OSALKFILE_E_HANDLE NULL file handle provided. */        status = OSALKFILE_E_HANDLE;        GT_setFailureReason (curTrace,                             GT_4CLASS,                             "OsalKfile_close",                             status,                             "NULL file handle provided.");    }    else {#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */        fileObject = (OsalKfile_Object *) *fileHandle;        fs = get_fs();        set_fs (KERNEL_DS);        filp_close (fileObject->fileDesc, NULL);        set_fs (fs);        Memory_free (NULL, fileObject, sizeof(OsalKfile_Object));        /* Reset user's file handle pointer. */        *fileHandle = NULL;#if !defined(SYSLINK_BUILD_OPTIMIZE)    }#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */    GT_1trace (curTrace, GT_LEAVE, "OsalKfile_close", status);    /*! @retval OSALKFILE_SUCCESS Operation successfully completed. */    return status;}

/*! *  @brief  Function to open the ClientNotifyMgr driver. * *  @sa     GatePetersonDrv_close */IntClientNotifyMgrDrv_open (Void){    Int status      = ClientNotifyMgr_S_SUCCESS;    int osStatus    = 0;    GT_0trace (curTrace, GT_ENTER, "ClientNotifyMgrDrv_open");    if (ClientNotifyMgrDrv_refCount == 0) {        /* TBD: Protection for refCount. */        ClientNotifyMgrDrv_refCount++;        ClientNotifyMgrDrv_handle = Dev_pollOpen (CLIENTNOTIFYMGR_DRVIER_NAME,                              O_SYNC | O_RDWR);        if (ClientNotifyMgrDrv_handle < 0) {            perror (CLIENTNOTIFYMGR_DRVIER_NAME);            /*! @retval ClientNotifyMgr_E_OSFAILURE Failed to open ClientNotifyMgr driver with OS             */            status = ClientNotifyMgr_E_OSFAILURE;            GT_setFailureReason (curTrace,                                 GT_4CLASS,                                 "ClientNotifyMgrDrv_open",                                 status,                                 "Failed to open ClientNotifyMgr driver with OS!");        }        else {            osStatus = fcntl (ClientNotifyMgrDrv_handle, F_SETFD, FD_CLOEXEC);            if (osStatus != 0) {            /*! @retval ClientNotifyMgr_E_OSFAILURE Failed to set file             * descriptor flags             */                status = ClientNotifyMgr_E_OSFAILURE;                GT_setFailureReason (curTrace,                                     GT_4CLASS,                                     "ClientNotifyMgrDrv_open",                                     status,                                     "Failed to set file descriptor flags!");            }        }    }    else {        ClientNotifyMgrDrv_refCount++;    }    GT_1trace (curTrace, GT_LEAVE, "ClientNotifyMgrDrv_open", status);/*! @retval ClientNotifyMgr_SUCCESS Operation successfully completed. */    return (status);}

/*! *  @brief      Deletes an instance of Semaphore object. * *  @param      mutexHandle   Semaphore object handle which needs to be deleted. * *  @sa         OsalSemaphore_create */IntOsalSemaphore_delete(OsalSemaphore_Handle *semHandle){    Int status = OSALSEMAPHORE_SUCCESS;    OsalSemaphore_Object **semObj = (OsalSemaphore_Object **)semHandle;    int osStatus = 0;    GT_1trace (curTrace, GT_ENTER, "OsalSemaphore_delete", semHandle);    GT_assert (curTrace, (semHandle != NULL));#if !defined(SYSLINK_BUILD_OPTIMIZE)    if (semHandle == NULL) {        status = OSALSEMAPHORE_E_INVALIDARG;        GT_setFailureReason (curTrace,                             GT_4CLASS,                             "OsalSemaphore_delete",                             status,                             "NULL provided for argument semHandle");    }    else if (*semHandle == NULL) {        status = OSALSEMAPHORE_E_HANDLE;        GT_setFailureReason (curTrace,                             GT_4CLASS,                             "OsalSemaphore_delete",                             status,                             "NULL Semaphore handle provided.");    }    else {#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */            osStatus = sem_destroy(&((*semObj)->lock));#if !defined(SYSLINK_BUILD_OPTIMIZE)            if (osStatus < 0) {                   status = OSALSEMAPHORE_E_HANDLE;                GT_setFailureReason (curTrace,                            GT_4CLASS,                            "OsalSemaphore_delete",                            status,                            "Failed to destroy semaphore");               }#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */        Memory_free(NULL, *semHandle, sizeof (OsalSemaphore_Object));        *semHandle = NULL;#if !defined(SYSLINK_BUILD_OPTIMIZE)    }#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */    GT_1trace (curTrace, GT_LEAVE, "OsalSemaphore_delete", status);    return status;}

/*! *  @brief  Function to open the Ipc driver. * *  @sa     IpcDrv_close */IntIpcDrv_open (Void){    Int status      = Ipc_S_SUCCESS;    int osStatus    = 0;    GT_0trace (curTrace, GT_ENTER, "IpcDrv_open");    if (IpcDrv_refCount == 0) {        IpcDrv_handle = open (IPC_DRIVER_NAME,                                       O_SYNC | O_RDWR);        if (IpcDrv_handle < 0) {            perror (IPC_DRIVER_NAME);            /*! @retval Ipc_E_OSFAILURE Failed to open Ipc driver with OS             */            status = Ipc_E_OSFAILURE;            GT_setFailureReason (curTrace,                                 GT_4CLASS,                                 "IpcDrv_open",                                 status,                                 "Failed to open Ipc driver with OS!");        }        else {            osStatus = fcntl (IpcDrv_handle, F_SETFD, FD_CLOEXEC);            if (osStatus != 0) {                /*! @retval Ipc_E_OSFAILURE Failed to set file descriptor flags                 */                status = Ipc_E_OSFAILURE;                GT_setFailureReason (curTrace,                                     GT_4CLASS,                                     "IpcDrv_open",                                     status,                                     "Failed to set file descriptor flags!");            }            else {                /* TBD: Protection for refCount. */                IpcDrv_refCount++;            }        }    }    else {        IpcDrv_refCount++;    }    GT_1trace (curTrace, GT_LEAVE, "IpcDrv_open", status);    return status;}

/*! *  @brief      Function to initialize the HAL object * *  @param      halObj      Return parameter: Pointer to the HAL object *  @param      initParams  Optional initialization parameters * *  @sa         OMAPL1XX_halExit *              OMAPL1XX_phyShmemInit */IntOMAPL1XX_halInit (Ptr * halObj, Ptr params){    Int                  status    = PROCESSOR_SUCCESS;    OMAPL1XX_HalObject * halObject = NULL;    GT_2trace (curTrace, GT_ENTER, "OMAPL1XX_halInit", halObj, params);    GT_assert (curTrace, (halObj != NULL));    (Void) params ; /* Not used. */    *halObj = Memory_calloc (NULL, sizeof (OMAPL1XX_HalObject), 0, NULL);#if !defined(SYSLINK_BUILD_OPTIMIZE)    if (*halObj == NULL) {        /*! @retval PROCESSOR_E_MEMORY Memory allocation failed */        status = PROCESSOR_E_MEMORY;        GT_setFailureReason (curTrace,                             GT_4CLASS,                             "OMAPL1XX_halInit",                             status,                             "Memory allocation failed for HAL object!");    }    else {#endif /* if !defined(SYSLINK_BUILD_OPTIMIZE) */        halObject = (OMAPL1XX_HalObject *) *halObj;        halObject->offsetPsc0 = OFFSET_PSC0;        halObject->offsetSysModule = OFFSET_SYSTEM_MODULE;        status = OMAPL1XX_phyShmemInit (*halObj);#if !defined(SYSLINK_BUILD_OPTIMIZE)        if (status < 0) {            GT_setFailureReason (curTrace,                                 GT_4CLASS,                                 "OMAPL1XX_halInit",                                 status,                                 "OMAPL1XX_phyShmemInit failed!");            Memory_free (NULL, *halObj, sizeof (OMAPL1XX_HalObject));            *halObj = NULL;        }    }#endif /* if !defined(SYSLINK_BUILD_OPTIMIZE) */    GT_1trace (curTrace, GT_LEAVE, "OMAPL1XX_halInit", status);    /*! @retval PROCESSOR_SUCCESS Operation successful */    return status;}

/*! *  @brief      Leave/unlock the Mutex object. * *              This function releases the critical section identified by this *              mutex handle. The completion of this function shall make the *              critical section available to any other threads that may be *              waiting to acquire it. * *  @param      mutexHandle   Mutex object handle to be released. *  @param      key           Key received from the corresponding enter call. * *  @sa         OsalMutex_enter */VoidOsalMutex_leave(OsalMutex_Handle mutexHandle, IArg key){    OsalMutex_Object * mutexObj = (OsalMutex_Object*) mutexHandle;    Int                ret      = 0;    GT_2trace (curTrace, GT_ENTER, "OsalMutex_leave", mutexHandle, key);    GT_assert (curTrace, (mutexHandle != NULL));    /* key can be 0, so not checked. */#if !defined(SYSLINK_BUILD_OPTIMIZE)    if (mutexHandle == NULL) {        /* Void function, so not setting status. */        GT_setFailureReason (curTrace,                             GT_4CLASS,                             "OsalMutex_leave",                             OSALMUTEX_E_HANDLE,                             "NULL Mutex handle provided.");    }    else {#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */        ret = pthread_mutex_unlock (&(mutexObj->lock));        GT_assert (curTrace, (ret == 0));#if !defined(SYSLINK_BUILD_OPTIMIZE)    }#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */    GT_0trace (curTrace, GT_LEAVE, "OsalMutex_leave");}

/*! *  @brief      Creates and initializes an event object for thread *              synchronization. The event is initialized to a *              non-signaled state.. * *  @param      Un-allocated event object. *  @sa         EventClose */OsalEvent_HandleOsalEvent_create (Void){#if (!defined(SYSLINK_BUILD_OPTIMIZE)|| defined(SYSLINK_TRACE_ENABLE))Int status = OSALEVENT_SUCCESS ;#endif /*(!defined(SYSLINK_BUILD_OPTIMIZE)|| defined(SYSLINK_TRACE_ENABLE)) */    OsalEvent_Object* event = NULL;    GT_0trace (curTrace, GT_ENTER, "OsalEvent_create");    event = Memory_alloc (NULL, sizeof (OsalEvent_Object), 0, NULL);#if !defined(SYSLINK_BUILD_OPTIMIZE)    if (event == NULL) {        status = OSALEVENT_E_MEMORY;        GT_setFailureReason (curTrace,                             GT_4CLASS,                             "OsalEvent_create",                             OSALEVENT_E_MEMORY,                             "Memory allocation failed");    }    else {#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */        event->value = 0;        event->lock = OsalSpinlock_create (OsalSpinlock_Type_Normal);        init_waitqueue_head (&event->list) ;#if !defined(SYSLINK_BUILD_OPTIMIZE)    }#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */    GT_1trace (curTrace, GT_LEAVE, "OsalEvent_create", status);    /*[email
C++ GUARANTEE函数代码示例
C++ GT_READ函数代码示例