OpenClovis Logo

clOsalApi.h
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2002-2012 OpenClovis Solutions Inc. All Rights Reserved.
3  *
4  * This file is available under a commercial license from the
5  * copyright holder or the GNU General Public License Version 2.0.
6  *
7  * The source code for this program is not published or otherwise
8  * divested of its trade secrets, irrespective of what has been
9  * deposited with the U.S. Copyright office.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * General Public License for more details.
15  *
16  * For more information, see the file COPYING provided with this
17  * material.
18  */
19 
32 /*********************************************************************************/
33 /************************************* OSAL APIs ********************************/
34 /*********************************************************************************/
35 /* */
36 /* clOsalInitialize */
37 /* clOsalFinalize */
38 /* clOsalTaskCreate */
39 /* clOsalTaskDelete */
40 /* clOsalSelfTaskIdGet */
41 /* clOsalTaskNameGet */
42 /* clOsalTaskPriorityGet */
43 /* clOsalTaskPrioritySet */
44 /* clOsalTaskDelay */
45 /* clOsalTimeOfDayGet */
46 /* clOsalMutexCreate */
47 /* clOsalMutexCreateAndLock */
48 /* clOsalMutexLock */
49 /* clOsalMutexUnlock */
50 /* clOsalMutexDelete */
51 /* clOsalNumMemoryAllocGet */
52 /* clOsalNumMemoryDeallocedGet */
53 /* clOsalCondCreate */
54 /* clOsalCondDelete */
55 /* clOsalCondWait */
56 /* clOsalCondBroadcast */
57 /* clOsalCondSignal */
58 /* clOsalTaskKeyCreate */
59 /* clOsalTaskKeyDelete */
60 /* clOsalTaskDataSet */
61 /* clOsalTaskDataGet */
62 /* clOsalPrintf */
63 /* clOsalPrintf */
64 /* clOsalSemCreate */
65 /* clOsalSemIdGet */
66 /* clOsalSemLock */
67 /* clOsalSemTryLock */
68 /* clOsalSemUnlock */
69 /* clOsalSemValueGet */
70 /* clOsalSemDelete */
71 /* clOsalProcessCreate */
72 /* cosProcessResume */
73 /* cosProcessSuspend */
74 /* clOsalProcessDelete */
75 /* clOsalProcessWait */
76 /* clOsalProcessSelfIdGet */
77 /* clOsalShmCreate */
78 /* clOsalShmIdGet */
79 /* clOsalShmDelete */
80 /* clOsalShmAttach */
81 /* clOsalShmDetach */
82 /* clOsalShmSecurityModeSet */
83 /* clOsalShmSecurityModeGet */
84 /* clOsalShmSizeGet */
85 /* clOsalSigHandlerInitialize */
86 /* clOsalErrorReportHandler */
87 /* */
88 /*********************************************************************************/
89 
90 #ifndef _CL_OSAL_API_H_
91 #define _CL_OSAL_API_H_
92 
93 #ifdef __cplusplus
94 extern "C" {
95 #endif
96 
97 #ifndef __KERNEL__
98 #include <stdlib.h>
99 #include <pthread.h>
100 #endif
101 
102 
103 #include <clCommon.h>
104 #include <clTimerApi.h>
105 #include <clHeapApi.h>
106 #ifdef DMALLOC
107 #include <dmalloc.h>
108 #endif /* DMALLOC */
109 
110 #ifdef CL_OSAL_DEBUG
111 #include <clList.h>
112 #endif
113 
114 /******************************************************************************
115  * Constant and Macro Definitions
116  *****************************************************************************/
117 
118 
119 
123 #define CL_OSAL_MIN_STACK_SIZE 196608
124 
128 #define CL_OSAL_NAME_MAX 32
129 
130 
131 #ifdef __KERNEL__
132 #define clOsalPrintf printk
133 #endif /* __KERNEL__ */
134 /* FIXME: This doesn't look clean */
135 /* Remove the #if 0 below to enable memleak detection tool in kernel space */
136 #if 0
137 #define MEM_LEAK_DETECT
138 #endif
139 #ifdef MEM_LEAK_DETECT
140 # define kmalloc(x,y) clHeapAllocate(x)
141 # define kfree clHeapFree
142 #endif /* MEM_LEAK_DETECT */
143 
144 /******************************************************************************
145  * Data Types
146  *****************************************************************************/
147 
148 #ifndef __KERNEL__
149 
150 #include <clArchHeaders.h>
151 #include <semaphore.h>
152 
156 typedef enum ClOsalSharedMutexFlags
157 {
158  CL_OSAL_SHARED_INVALID = 0x0,
159  CL_OSAL_SHARED_NORMAL = 0x1,
160  CL_OSAL_SHARED_SYSV_SEM = 0x2,
161  CL_OSAL_SHARED_POSIX_SEM = 0x4,
162  CL_OSAL_SHARED_RECURSIVE = 0x8,
163  CL_OSAL_SHARED_PROCESS = 0x10,
164  CL_OSAL_SHARED_ERROR_CHECK = 0x20,
165 }ClOsalSharedMutexFlagsT;
166 
167 typedef struct ClOsalMutex
168 {
169 #ifdef CL_OSAL_DEBUG
170 #define CL_OSAL_DEBUG_MAGIC 0xDEADBEEF
171  ClUint32T magic;
172  pthread_t tid;
173  const ClCharT *creatorFile;
174  ClInt32T creatorLine;
175  const ClCharT *ownerFile;
176  ClInt32T ownerLine;
177  ClListHeadT list; /*entry into the mutex pool*/
178 #endif
179  ClOsalSharedMutexFlagsT flags;
180  union shared_lock
181  {
182  pthread_mutex_t mutex;
183  struct ClSem
184  {
185  sem_t posSem;
186  int semId;
187  ClInt32T numSems;
188  }sem;
189  }shared_lock;
190 }ClOsalMutexT;
191 
192 typedef pthread_mutexattr_t ClOsalMutexAttrT;
193 typedef pthread_condattr_t ClOsalCondAttrT;
194 typedef enum ClOsalSharedType
195 {
196  CL_OSAL_PROCESS_PRIVATE = 0, /*default*/
197  CL_OSAL_PROCESS_SHARED = 1
198 }ClOsalSharedTypeT;
199 
203 typedef pthread_cond_t ClOsalCondT;
204 #endif
205 
209 typedef ClUint64T ClOsalTaskIdT;
210 
214 #ifndef __KERNEL__
215 typedef ClOsalMutexT* ClOsalMutexIdT;
216 #else
217 typedef ClPtrT ClOsalMutexIdT;
218 #endif
219 
220 
221 
225 #ifndef __KERNEL__
226 typedef ClOsalCondT* ClOsalCondIdT;
227 #else
228 typedef ClPtrT ClOsalCondIdT; // Mynk NTC
229 #endif
230 
233 #ifndef POSIX_BUILD
234 typedef ClHandleT ClOsalSemIdT;
235 #else
236 typedef sem_t* ClOsalSemIdT;
237 #endif
238 
242 typedef ClUint32T ClOsalShmIdT;
243 
247 typedef ClUint32T ClOsalPidT;
248 
252 typedef ClPtrT ClOsalTaskDataT;
253 
254 typedef struct timespec ClNanoTimeT;
255 
260 typedef void (*ClOsalProcessFuncT)(void*);
261 
267 typedef void (*ClOsalTaskKeyDeleteCallBackT)(void*);
268 
269 /* ENUM */
270 
277 typedef enum { /* DO NOT CHANGE the order of this enum, since it must be aligned with the Posix ordering */
278 
280  CL_OSAL_SCHED_OTHER = SCHED_OTHER,
281 
283  CL_OSAL_SCHED_FIFO = SCHED_FIFO,
284 
286  CL_OSAL_SCHED_RR = SCHED_RR
287 } ClOsalSchedulePolicyT;
288 
293 typedef enum
294 {
298  CL_OSAL_THREAD_PRI_NOT_APPLICABLE = 0,
299 
303  CL_OSAL_THREAD_PRI_HIGH = 160, /* COS_MAX_PRIORITY, */
304 
308  CL_OSAL_THREAD_PRI_MEDIUM = 80, /* (COS_MAX_PRIORITY - COS_MIN_PRIORITY)/2, */
309 
313  CL_OSAL_THREAD_PRI_LOW = 1, /* COS_MIN_PRIORITY */
314 } ClOsalThreadPriorityT;
315 
321 typedef enum {
323  CL_OSAL_PROCESS_WITH_NEW_SESSION = CL_BIT(0),
325  CL_OSAL_PROCESS_WITH_NEW_GROUP = CL_BIT(1)
326 } ClOsalProcessFlagT;
327 
328 #if 0
329 
336 typedef enum{
337 
341  CL_OSAL_SHM_PRIVATE = BIT0,
342 
346  CL_OSAL_SHM_PUBLIC = BIT1
347  } CosShmFlag_e;
348 #endif
349 
351 typedef enum {
353  CL_OSAL_SHM_MODE_READ_USER = 0x0100,
355  CL_OSAL_SHM_MODE_READ_GROUP = 0x0020,
357  CL_OSAL_SHM_MODE_READ_OTHERS = 0x0004,
359  CL_OSAL_SHM_MODE_WRITE_USER = 0x0080,
361  CL_OSAL_SHM_MODE_WRITE_GROUP = 0x0010,
363  CL_OSAL_SHM_MODE_WRITE_OTHERS = 0x0002
364 } ClOsalShmSecurityModeFlagT;
365 
369 #define CL_OSAL_SHM_EXCEPTION_LENGTH 2048
370 typedef struct {
374  ClCharT exceptionInfo[CL_OSAL_SHM_EXCEPTION_LENGTH];
375 }ClOsalShmAreaDefT;
376 
380 extern ClOsalShmAreaDefT *gpClShmArea;
384 extern ClOsalShmIdT gClCompUniqueShmId;
385 
386 /*****************************************************************************
387  * OSAL APIs
388  *****************************************************************************/
389 
411 ClRcT clOsalInitialize(const ClPtrT pConfig);
412 
426 ClRcT clOsalFinalize(void);
427 
428 /* Tasking API's */
429 
430 
478 ClRcT clOsalTaskCreateDetached (const ClCharT *taskName,
479  ClOsalSchedulePolicyT schedulePolicy,
480  ClUint32T priority,
481  ClUint32T stackSize,
482  void* (*fpTaskFunction)(void*),
483  void* pTaskFuncArgument);
484 
536 ClRcT clOsalTaskCreateAttached(const ClCharT *taskName,
537  ClOsalSchedulePolicyT schedulePolicy,
538  ClUint32T priority,
539  ClUint32T stackSize,
540  void* (*fpTaskFunction)(void*),
541  void* pTaskFuncArgument,
542  ClOsalTaskIdT* pTaskId);
543 
564 ClRcT clOsalTaskJoin (ClOsalTaskIdT taskId);
565 
586 ClRcT clOsalTaskDelete (ClOsalTaskIdT taskId);
587 
588 
610 ClRcT clOsalTaskKill (ClOsalTaskIdT taskId, ClInt32T sig);
611 
612 
635 ClRcT clOsalTaskDetach (ClOsalTaskIdT taskId);
636 
637 
638 
655 ClRcT clOsalSelfTaskIdGet (ClOsalTaskIdT* pTaskId);
656 
657 
658 
659 
679 ClRcT clOsalTaskNameGet (ClOsalTaskIdT taskId, ClCharT** ppTaskName);
680 
681 
682 
683 
704 ClRcT clOsalTaskPriorityGet (ClOsalTaskIdT taskId,
705  ClUint32T* pTaskPriority);
706 
707 
708 
709 
731 ClRcT clOsalTaskPrioritySet (ClOsalTaskIdT taskId,
732  ClUint32T taskPriority);
733 
734 
735 
736 
759 ClRcT clOsalTaskDelay (ClTimerTimeOutT timeOut);
760 
761 
777 ClRcT clOsalTimeOfDayGet (ClTimerTimeOutT* pTime);
778 
796 ClRcT clOsalNanoTimeGet (ClNanoTimeT* pTime);
797 
811 ClTimeT clOsalStopWatchTimeGet(void);
812 
813 
814 /* Mutex */
815 
816 
837 #ifndef __KERNEL__
838 
839 #ifndef CL_OSAL_DEBUG
840 
841 ClRcT clOsalMutexInit (ClOsalMutexT* pMutex);
842 
843 #else
844 
845 extern ClRcT clOsalMutexInitDebug(ClOsalMutexT *pMutex, const ClCharT *file, ClInt32T line);
846 #define clOsalMutexInit(mutex) clOsalMutexInitDebug(mutex, __FILE__, __LINE__)
847 
848 #endif
849 
850 ClRcT clOsalMutexErrorCheckInit (ClOsalMutexT* pMutex);
851 
852 ClRcT clOsalMutexValueSet(ClOsalMutexIdT mutexId, ClInt32T value);
853 
854 ClRcT clOsalMutexValueGet(ClOsalMutexIdT mutexId, ClInt32T *pValue);
855 
856 #endif
857 
858 
876 #ifndef __KERNEL__
877 ClRcT clOsalProcessSharedMutexInit (ClOsalMutexT* pMutex, ClOsalSharedMutexFlagsT flags, ClUint8T *pKey, ClUint32T keyLen, ClInt32T value);
878 
879 ClRcT clOsalSharedMutexCreate (ClOsalMutexIdT* pMutex, ClOsalSharedMutexFlagsT flags, ClUint8T *pKey, ClUint32T keyLen, ClInt32T value);
880 #endif
881 
882 #define clOsalMutexIdGet(pClOsalMutexT) ((ClOsalMutexIdT)(pClOsalMutexT))
883 
903 #ifndef __KERNEL__
904 
905 #ifndef CL_OSAL_DEBUG
906 
907 ClRcT clOsalRecursiveMutexInit (ClOsalMutexT* pMutex);
908 
909 #else
910 
911 extern ClRcT clOsalRecursiveMutexInitDebug(ClOsalMutexT *pMutex, const ClCharT *file, ClInt32T line);
912 #define clOsalRecursiveMutexInit(mutex) clOsalRecursiveMutexInitDebug(mutex, __FILE__, __LINE__)
913 
914 #endif
915 
916 #endif
917 
936 #ifndef CL_OSAL_DEBUG
937 
938 ClRcT clOsalMutexCreate (ClOsalMutexIdT* pMutexId);
939 
940 #else
941 
942 extern ClRcT clOsalMutexCreateDebug(ClOsalMutexIdT *pMutexId, const ClCharT *file, ClInt32T line);
943 #define clOsalMutexCreate(mutexId) clOsalMutexCreateDebug(mutexId, __FILE__, __LINE__)
944 
945 #endif
946 
947 ClRcT clOsalMutexErrorCheckCreate (ClOsalMutexIdT* pMutexId);
948 
949 
969 #ifndef CL_OSAL_DEBUG
970 
971 ClRcT clOsalMutexCreateAndLock (ClOsalMutexIdT* pMutexId);
972 
973 #else
974 
975 extern ClRcT clOsalMutexCreateAndLockDebug(ClOsalMutexIdT *pMutexId, const ClCharT *file, ClInt32T line);
976 #define clOsalMutexCreateAndLock(mutexId) clOsalMutexCreateAndLockDebug(mutexId, __FILE__, __LINE__)
977 
978 #endif
979 
997 #ifndef CL_OSAL_DEBUG
998 
999 ClRcT clOsalMutexLock (ClOsalMutexIdT mutexId);
1000 
1001 #else
1002 
1003 extern ClRcT clOsalMutexLockDebug(ClOsalMutexIdT mutexId, const ClCharT *file, ClInt32T line);
1004 #define clOsalMutexLock(mutexId) clOsalMutexLockDebug(mutexId, __FILE__, __LINE__)
1005 
1006 #endif
1007 
1008 ClRcT clOsalMutexLockSilent (ClOsalMutexIdT mutexId);
1009 
1010 ClRcT
1011 clOsalMutexUnlockNonDebug(ClOsalMutexIdT mutexId);
1012 
1013 ClRcT
1014 clOsalMutexTryLock(ClOsalMutexIdT mutexId);
1015 
1033 #ifndef CL_OSAL_DEBUG
1034 
1035 ClRcT clOsalMutexUnlock (ClOsalMutexIdT mutexId);
1036 
1037 #else
1038 
1039 extern ClRcT clOsalMutexUnlockDebug(ClOsalMutexIdT mutexId, const ClCharT *file, ClInt32T line);
1040 #define clOsalMutexUnlock(mutexId) clOsalMutexUnlockDebug(mutexId, __FILE__, __LINE__)
1041 
1042 #endif
1043 
1044 ClRcT clOsalMutexUnlockSilent (ClOsalMutexIdT mutexId);
1045 
1063 #ifndef CL_OSAL_DEBUG
1064 
1065 ClRcT clOsalMutexDelete (ClOsalMutexIdT mutexId);
1066 
1067 #else
1068 
1069 extern ClRcT clOsalMutexDeleteDebug(ClOsalMutexIdT mutexId, const ClCharT *file, ClInt32T line);
1070 #define clOsalMutexDelete(mutexId) clOsalMutexDeleteDebug(mutexId, __FILE__, __LINE__)
1071 
1072 #endif
1073 
1091 #ifndef __KERNEL__
1092 
1093 #ifndef CL_OSAL_DEBUG
1094 
1095 ClRcT clOsalMutexDestroy (ClOsalMutexT *pMutex);
1096 
1097 #else
1098 
1099 extern ClRcT clOsalMutexDestroyDebug(ClOsalMutexT *pMutex, const ClCharT *file, ClInt32T line);
1100 #define clOsalMutexDestroy(mutex) clOsalMutexDestroyDebug(mutex, __FILE__, __LINE__)
1101 
1102 extern ClRcT clOsalBustLocks(void);
1103 
1104 #endif
1105 #endif
1106 
1107 #ifndef __KERNEL__
1108 
1125 ClRcT clOsalCondInit (ClOsalCondT* pCond);
1126 #endif
1127 
1128 #ifndef __KERNEL__
1129 
1146 ClRcT clOsalProcessSharedCondInit (ClOsalCondT* pCond);
1147 
1148 #endif
1149 
1169 ClRcT clOsalCondCreate (ClOsalCondIdT* pConditionId);
1170 
1171 
1172 
1193 ClRcT clOsalCondDelete (ClOsalCondIdT conditionId);
1194 
1195 
1217 #ifndef __KERNEL__
1218 ClRcT clOsalCondDestroy (ClOsalCondT *pCond);
1219 #endif
1220 
1221 
1251 #ifndef CL_OSAL_DEBUG
1252 ClRcT clOsalCondWait (ClOsalCondIdT conditionId,
1253  ClOsalMutexIdT mutexId,
1254  ClTimerTimeOutT time);
1255 #else
1256 extern ClRcT clOsalCondWaitDebug (ClOsalCondIdT conditionId,
1257  ClOsalMutexIdT mutexId,
1258  ClTimerTimeOutT time,
1259  const ClCharT *file, ClInt32T line);
1260 #define clOsalCondWait(cond, mutex, time) clOsalCondWaitDebug(cond, mutex, time, __FILE__, __LINE__)
1261 #endif
1262 
1283 ClRcT clOsalCondBroadcast (ClOsalCondIdT conditionId);
1284 
1306 ClRcT clOsalCondSignal (ClOsalCondIdT conditionId);
1307 
1308 
1326 ClRcT clOsalTaskKeyCreate(ClUint32T* pKey,
1327  ClOsalTaskKeyDeleteCallBackT pCallbackFunc);
1328 
1329 
1330 
1331 
1347 ClRcT clOsalTaskKeyDelete(ClUint32T key);
1348 
1349 
1366 ClRcT clOsalTaskDataSet(ClUint32T key,
1367  ClOsalTaskDataT threadData);
1368 
1369 
1370 
1389 ClRcT clOsalTaskDataGet(ClUint32T key,
1390  ClOsalTaskDataT* pThreadData);
1391 
1392 
1393 
1406 #ifndef __KERNEL__
1407 ClRcT clOsalPrintf(const ClCharT* fmt, ...);
1408 #endif /* __KERNEL__ */
1409 
1410 /* Semaphores */
1438 ClRcT clOsalSemCreate(ClUint8T* pName,
1439  ClUint32T value,
1440  ClOsalSemIdT* pSemId);
1441 
1442 
1463 ClRcT clOsalSemIdGet(ClUint8T* pName, ClOsalSemIdT* pSemId);
1464 
1465 
1487 ClRcT clOsalSemLock(ClOsalSemIdT semId);
1488 
1489 
1513 ClRcT clOsalSemTryLock(ClOsalSemIdT semId);
1514 
1515 
1516 
1538 ClRcT clOsalSemUnlock(ClOsalSemIdT semId);
1539 
1540 
1541 
1563 ClRcT clOsalSemValueGet(ClOsalSemIdT semId,
1564  ClUint32T* pSemValue);
1565 
1566 
1567 
1589 ClRcT clOsalSemDelete(ClOsalSemIdT semId);
1590 
1591 
1592 /* Process */
1593 
1594 
1618 ClRcT clOsalProcessCreate(ClOsalProcessFuncT fpFunction,
1619  void* functionArg,
1620  ClOsalProcessFlagT creationFlags,
1621  ClOsalPidT* pProcessId);
1622 
1638 ClRcT clOsalProcessDelete(ClOsalPidT processId);
1639 
1640 
1660 ClRcT clOsalProcessWait(ClOsalPidT processId);
1661 
1662 
1663 
1678 ClRcT clOsalProcessSelfIdGet(ClOsalPidT* pProcessId);
1679 
1680 
1681 /* Shared Memory */
1682 
1683 
1713 ClRcT clOsalShmCreate(ClUint8T* pName,
1714  ClUint32T size,
1715  ClOsalShmIdT *pShmId);
1716 
1717 
1718 
1740 ClRcT clOsalShmIdGet(ClUint8T *pName,
1741  ClOsalShmIdT *pShmId);
1742 
1743 
1744 
1745 
1768 ClRcT clOsalShmDelete(ClOsalShmIdT shmId);
1769 
1770 
1771 
1799 ClRcT clOsalShmAttach(ClOsalShmIdT shmId,
1800  void* pInMem,
1801  void** ppOutMem);
1802 
1803 
1804 
1805 
1826 ClRcT clOsalShmDetach(void* pMem);
1827 
1828 
1829 
1830 
1853 ClRcT clOsalShmSecurityModeSet(ClOsalShmIdT shmId,
1854  ClUint32T mode);
1855 
1856 
1876 ClRcT clOsalShmSecurityModeGet(ClOsalShmIdT shmId,
1877  ClUint32T* pMode);
1878 
1879 
1880 
1903 ClRcT clOsalShmSizeGet(ClOsalShmIdT shmId,
1904  ClUint32T* pSize);
1905 
1906 #if 0 /* Deprecated R4.0. Use the standard C library routines */
1907 
1921 ClRcT clOsalFileClose (ClFdT *fd);
1922 #endif
1923 
1924 
1925 ClRcT clOsalMmap(ClPtrT start, ClUint32T length, ClInt32T prot, ClInt32T flags,
1926  ClHandleT fd, ClHandleT offset, ClPtrT *mmapped);
1927 
1928 
1929 ClRcT clOsalMunmap(ClPtrT start, ClUint32T length);
1930 
1931 
1932 ClRcT clOsalMsync (ClPtrT start, ClUint32T length, ClInt32T flags);
1933 
1934 
1935 ClRcT clOsalFtruncate (ClFdT fd, off_t length);
1936 
1937 ClRcT clOsalShmOpen (const ClCharT *name, ClInt32T oflag, ClUint32T mode, ClFdT *fd);
1938 ClRcT clOsalShmClose (ClFdT *fd);
1939 
1940 ClRcT clOsalShmUnlink (const ClCharT *name);
1941 
1954 void clOsalSigHandlerInitialize(void);
1955 
1956 
1957 /*
1958  * \brief Returns the maximum allowed length of a relative pathname when 'path' is the working directory.
1959  *
1960  * \param path: Relative or absolute path of a directory
1961  *
1962  * \param pLength: The returned length
1963  *
1964  * \retval CL_OK: This API executed successfully.
1965  * \retval CL_OSAL_ERR_OS_ERROR: The OS abstraction layer has not been
1966  * initialized. In other words, clOsalInitialize() has not been called.
1967  * \retval CL_ERR_NULL_PTR: Either 'path' or 'pLength' is NULL
1968  * \retval CL_ERR_NOT_SUPPORTED: This limit cannot be queried at run-time.
1969  * \retval CL_ERR_DOESNT_EXIST: There is no definite limit.
1970  * \retval CL_ERR_UNSPECIFIED: An unknown error was returned by pathconf()
1971  *
1972  * \par Description:
1973  * This function is a wrapper for pathconf().
1974  *
1975  */
1976 ClRcT clOsalMaxPathGet(const ClCharT* path, ClInt32T* pLength);
1977 
2008 ClRcT clOsalPageSizeGet(ClInt32T* pSize);
2009 
2010 
2011 /* Deprecated functions */
2012 
2013 void clOsalErrorReportHandler(void *info) CL_DEPRECATED;
2014 
2015 ClPtrT clOsalMalloc(ClUint32T size) CL_DEPRECATED;
2016 
2017 ClPtrT clOsalCalloc(ClUint32T size) CL_DEPRECATED;
2018 
2019 void clOsalFree(ClPtrT pAddress) CL_DEPRECATED;
2020 
2021 #ifndef __KERNEL__
2022 
2023 ClRcT clOsalMutexAttrInit(ClOsalMutexAttrT *pAttr) CL_DEPRECATED;
2024 
2025 ClRcT clOsalMutexAttrDestroy(ClOsalMutexAttrT *pAttr) CL_DEPRECATED;
2026 
2027 ClRcT clOsalMutexAttrPSharedSet(ClOsalMutexAttrT *pAttr, ClOsalSharedTypeT type) CL_DEPRECATED;
2028 
2029 ClRcT clOsalMutexInitEx(ClOsalMutexT *pMutex, ClOsalMutexAttrT *pAttr) CL_DEPRECATED;
2030 
2031 
2032 ClRcT clOsalCondInitEx(ClOsalCondT *pCond, ClOsalCondAttrT *pAttr) CL_DEPRECATED;
2033 
2034 ClRcT clOsalCondAttrInit(ClOsalCondAttrT *pAttr) CL_DEPRECATED;
2035 
2036 ClRcT clOsalCondAttrDestroy(ClOsalCondAttrT *pAttr) CL_DEPRECATED;
2037 
2038 ClRcT clOsalCondAttrPSharedSet(ClOsalCondAttrT *pAttr, ClOsalSharedTypeT type) CL_DEPRECATED;
2039 #endif
2040 
2041 
2042 
2043 #ifdef __cplusplus
2044 }
2045 #endif
2046 
2047 
2053 #endif /* _CL_OSAL_API_H_ */
2054 
2055 
Generated on Tue Jan 10 10:29:15 PST 2012 for OpenClovis SDK using Doxygen