lwp_pmutex.c 9.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413
  1. /*
  2. * Copyright (c) 2006-2021, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date Author Notes
  8. * 2021/01/02 bernard the first version
  9. */
  10. #include <rtthread.h>
  11. #include <lwp.h>
  12. #ifdef ARCH_MM_MMU
  13. #include <lwp_user_mm.h>
  14. #endif
  15. #include <sys/time.h>
  16. #define PMUTEX_NORMAL 0 /* Unable to recursion */
  17. #define PMUTEX_RECURSIVE 1 /* Can be recursion */
  18. #define PMUTEX_ERRORCHECK 2 /* This type of mutex provides error checking */
  19. struct rt_pmutex
  20. {
  21. union
  22. {
  23. rt_mutex_t kmutex;
  24. rt_sem_t ksem; /* use sem to emulate the mutex without recursive */
  25. } lock;
  26. struct lwp_avl_struct node;
  27. struct rt_object *custom_obj;
  28. rt_uint8_t type; /* pmutex type */
  29. };
  30. static struct rt_mutex _pmutex_lock;
  31. static int pmutex_system_init(void)
  32. {
  33. rt_mutex_init(&_pmutex_lock, "pmtxLock", RT_IPC_FLAG_FIFO);
  34. return 0;
  35. }
  36. INIT_PREV_EXPORT(pmutex_system_init);
  37. static rt_err_t pmutex_destory(void *data)
  38. {
  39. rt_err_t ret = -1;
  40. rt_base_t level = 0;
  41. struct rt_pmutex *pmutex = (struct rt_pmutex *)data;
  42. if (pmutex)
  43. {
  44. level = rt_hw_interrupt_disable();
  45. /* remove pmutex from pmutext avl */
  46. lwp_avl_remove(&pmutex->node, (struct lwp_avl_struct **)pmutex->node.data);
  47. rt_hw_interrupt_enable(level);
  48. if (pmutex->type == PMUTEX_NORMAL)
  49. {
  50. rt_sem_delete(pmutex->lock.ksem);
  51. }
  52. else
  53. {
  54. rt_mutex_delete(pmutex->lock.kmutex);
  55. }
  56. /* release object */
  57. rt_free(pmutex);
  58. ret = 0;
  59. }
  60. return ret;
  61. }
  62. static struct rt_pmutex* pmutex_create(void *umutex, struct rt_lwp *lwp)
  63. {
  64. struct rt_pmutex *pmutex = RT_NULL;
  65. struct rt_object *obj = RT_NULL;
  66. rt_ubase_t type;
  67. if (!lwp)
  68. {
  69. return RT_NULL;
  70. }
  71. long *p = (long *)umutex;
  72. /* umutex[0] bit[0-1] saved mutex type */
  73. type = *p & 3;
  74. if (type != PMUTEX_NORMAL && type != PMUTEX_RECURSIVE && type != PMUTEX_ERRORCHECK)
  75. {
  76. return RT_NULL;
  77. }
  78. pmutex = (struct rt_pmutex *)rt_malloc(sizeof(struct rt_pmutex));
  79. if (!pmutex)
  80. {
  81. return RT_NULL;
  82. }
  83. if (type == PMUTEX_NORMAL)
  84. {
  85. pmutex->lock.ksem = rt_sem_create("pmutex", 1, RT_IPC_FLAG_PRIO);
  86. if (!pmutex->lock.ksem)
  87. {
  88. rt_free(pmutex);
  89. return RT_NULL;
  90. }
  91. }
  92. else
  93. {
  94. pmutex->lock.kmutex = rt_mutex_create("pmutex", RT_IPC_FLAG_PRIO);
  95. if (!pmutex->lock.kmutex)
  96. {
  97. rt_free(pmutex);
  98. return RT_NULL;
  99. }
  100. }
  101. obj = rt_custom_object_create("pmutex", (void *)pmutex, pmutex_destory);
  102. if (!obj)
  103. {
  104. if (pmutex->type == PMUTEX_NORMAL)
  105. {
  106. rt_sem_delete(pmutex->lock.ksem);
  107. }
  108. else
  109. {
  110. rt_mutex_delete(pmutex->lock.kmutex);
  111. }
  112. rt_free(pmutex);
  113. return RT_NULL;
  114. }
  115. pmutex->node.avl_key = (avl_key_t)umutex;
  116. pmutex->node.data = &lwp->address_search_head;
  117. pmutex->custom_obj = obj;
  118. pmutex->type = type;
  119. /* insert into pmutex head */
  120. lwp_avl_insert(&pmutex->node, &lwp->address_search_head);
  121. return pmutex;
  122. }
  123. static struct rt_pmutex* pmutex_get(void *umutex, struct rt_lwp *lwp)
  124. {
  125. struct rt_pmutex *pmutex = RT_NULL;
  126. struct lwp_avl_struct *node = RT_NULL;
  127. node = lwp_avl_find((avl_key_t)umutex, lwp->address_search_head);
  128. if (!node)
  129. {
  130. return RT_NULL;
  131. }
  132. pmutex = rt_container_of(node, struct rt_pmutex, node);
  133. return pmutex;
  134. }
  135. static int _pthread_mutex_init(void *umutex)
  136. {
  137. struct rt_lwp *lwp = RT_NULL;
  138. struct rt_pmutex *pmutex = RT_NULL;
  139. rt_err_t lock_ret = 0;
  140. /* umutex union is 6 x (void *) */
  141. if (!lwp_user_accessable(umutex, sizeof(void *) * 6))
  142. {
  143. rt_set_errno(EINVAL);
  144. return -EINVAL;
  145. }
  146. lock_ret = rt_mutex_take_interruptible(&_pmutex_lock, RT_WAITING_FOREVER);
  147. if (lock_ret != RT_EOK)
  148. {
  149. rt_set_errno(EAGAIN);
  150. return -EINTR;
  151. }
  152. lwp = lwp_self();
  153. pmutex = pmutex_get(umutex, lwp);
  154. if (pmutex == RT_NULL)
  155. {
  156. /* create a pmutex according to this umutex */
  157. pmutex = pmutex_create(umutex, lwp);
  158. if (pmutex == RT_NULL)
  159. {
  160. rt_mutex_release(&_pmutex_lock);
  161. rt_set_errno(ENOMEM);
  162. return -ENOMEM;
  163. }
  164. if (lwp_user_object_add(lwp, pmutex->custom_obj) != 0)
  165. {
  166. rt_custom_object_destroy(pmutex->custom_obj);
  167. rt_set_errno(ENOMEM);
  168. return -ENOMEM;
  169. }
  170. }
  171. else
  172. {
  173. rt_base_t level = rt_hw_interrupt_disable();
  174. if (pmutex->type == PMUTEX_NORMAL)
  175. {
  176. pmutex->lock.ksem->value = 1;
  177. }
  178. else
  179. {
  180. pmutex->lock.kmutex->owner = RT_NULL;
  181. pmutex->lock.kmutex->priority = 0xFF;
  182. pmutex->lock.kmutex->hold = 0;
  183. pmutex->lock.kmutex->ceiling_priority = 0xFF;
  184. }
  185. rt_hw_interrupt_enable(level);
  186. }
  187. rt_mutex_release(&_pmutex_lock);
  188. return 0;
  189. }
  190. static int _pthread_mutex_lock_timeout(void *umutex, struct timespec *timeout)
  191. {
  192. struct rt_lwp *lwp = RT_NULL;
  193. struct rt_pmutex *pmutex = RT_NULL;
  194. rt_err_t lock_ret = 0;
  195. rt_int32_t time = RT_WAITING_FOREVER;
  196. register rt_base_t temp;
  197. if (timeout)
  198. {
  199. if (!lwp_user_accessable((void *)timeout, sizeof(struct timespec)))
  200. {
  201. rt_set_errno(EINVAL);
  202. return -EINVAL;
  203. }
  204. time = rt_timespec_to_tick(timeout);
  205. }
  206. lock_ret = rt_mutex_take_interruptible(&_pmutex_lock, RT_WAITING_FOREVER);
  207. if (lock_ret != RT_EOK)
  208. {
  209. rt_set_errno(EAGAIN);
  210. return -EINTR;
  211. }
  212. lwp = lwp_self();
  213. pmutex = pmutex_get(umutex, lwp);
  214. if (pmutex == RT_NULL)
  215. {
  216. rt_mutex_release(&_pmutex_lock);
  217. rt_set_errno(EINVAL);
  218. return -ENOMEM; /* umutex not recored in kernel */
  219. }
  220. rt_mutex_release(&_pmutex_lock);
  221. switch (pmutex->type)
  222. {
  223. case PMUTEX_NORMAL:
  224. lock_ret = rt_sem_take_interruptible(pmutex->lock.ksem, time);
  225. break;
  226. case PMUTEX_RECURSIVE:
  227. lock_ret = rt_mutex_take_interruptible(pmutex->lock.kmutex, time);
  228. break;
  229. case PMUTEX_ERRORCHECK:
  230. temp = rt_hw_interrupt_disable();
  231. if (pmutex->lock.kmutex->owner == rt_thread_self())
  232. {
  233. /* enable interrupt */
  234. rt_hw_interrupt_enable(temp);
  235. return -EDEADLK;
  236. }
  237. lock_ret = rt_mutex_take_interruptible(pmutex->lock.kmutex, time);
  238. rt_hw_interrupt_enable(temp);
  239. break;
  240. default: /* unknown type */
  241. return -EINVAL;
  242. }
  243. if (lock_ret != RT_EOK)
  244. {
  245. if (lock_ret == -RT_ETIMEOUT)
  246. {
  247. if (time == 0) /* timeout is 0, means try lock failed */
  248. {
  249. rt_set_errno(EBUSY);
  250. return -EBUSY;
  251. }
  252. else
  253. {
  254. rt_set_errno(ETIMEDOUT);
  255. return -ETIMEDOUT;
  256. }
  257. }
  258. else
  259. {
  260. rt_set_errno(EAGAIN);
  261. return -EAGAIN;
  262. }
  263. }
  264. return 0;
  265. }
  266. static int _pthread_mutex_unlock(void *umutex)
  267. {
  268. struct rt_lwp *lwp = RT_NULL;
  269. struct rt_pmutex *pmutex = RT_NULL;
  270. rt_err_t lock_ret = 0;
  271. lock_ret = rt_mutex_take_interruptible(&_pmutex_lock, RT_WAITING_FOREVER);
  272. if (lock_ret != RT_EOK)
  273. {
  274. rt_set_errno(EAGAIN);
  275. return -EINTR;
  276. }
  277. lwp = lwp_self();
  278. pmutex = pmutex_get(umutex, lwp);
  279. if (pmutex == RT_NULL)
  280. {
  281. rt_mutex_release(&_pmutex_lock);
  282. rt_set_errno(EPERM);
  283. return -EPERM;//unlock static mutex of unlock state
  284. }
  285. rt_mutex_release(&_pmutex_lock);
  286. switch (pmutex->type)
  287. {
  288. case PMUTEX_NORMAL:
  289. if(pmutex->lock.ksem->value >=1)
  290. {
  291. rt_set_errno(EPERM);
  292. return -EPERM;//unlock dynamic mutex of unlock state
  293. }
  294. else
  295. {
  296. lock_ret = rt_sem_release(pmutex->lock.ksem);
  297. }
  298. break;
  299. case PMUTEX_RECURSIVE:
  300. case PMUTEX_ERRORCHECK:
  301. lock_ret = rt_mutex_release(pmutex->lock.kmutex);
  302. break;
  303. default: /* unknown type */
  304. return -EINVAL;
  305. }
  306. if (lock_ret != RT_EOK)
  307. {
  308. rt_set_errno(EPERM);
  309. return -EAGAIN;
  310. }
  311. return 0;
  312. }
  313. static int _pthread_mutex_destroy(void *umutex)
  314. {
  315. struct rt_lwp *lwp = RT_NULL;
  316. struct rt_pmutex *pmutex = RT_NULL;
  317. rt_err_t lock_ret = 0;
  318. lock_ret = rt_mutex_take_interruptible(&_pmutex_lock, RT_WAITING_FOREVER);
  319. if (lock_ret != RT_EOK)
  320. {
  321. rt_set_errno(EAGAIN);
  322. return -EINTR;
  323. }
  324. lwp = lwp_self();
  325. pmutex = pmutex_get(umutex, lwp);
  326. if (pmutex == RT_NULL)
  327. {
  328. rt_mutex_release(&_pmutex_lock);
  329. rt_set_errno(EINVAL);
  330. return -EINVAL;
  331. }
  332. lwp_user_object_delete(lwp, pmutex->custom_obj);
  333. rt_mutex_release(&_pmutex_lock);
  334. return 0;
  335. }
  336. int sys_pmutex(void *umutex, int op, void *arg)
  337. {
  338. int ret = -EINVAL;
  339. switch (op)
  340. {
  341. case PMUTEX_INIT:
  342. ret = _pthread_mutex_init(umutex);
  343. break;
  344. case PMUTEX_LOCK:
  345. ret = _pthread_mutex_lock_timeout(umutex, (struct timespec*)arg);
  346. if (ret == -ENOMEM)
  347. {
  348. /* lock not init, try init it and lock again. */
  349. ret = _pthread_mutex_init(umutex);
  350. if (ret == 0)
  351. {
  352. ret = _pthread_mutex_lock_timeout(umutex, (struct timespec*)arg);
  353. }
  354. }
  355. break;
  356. case PMUTEX_UNLOCK:
  357. ret = _pthread_mutex_unlock(umutex);
  358. break;
  359. case PMUTEX_DESTROY:
  360. ret = _pthread_mutex_destroy(umutex);
  361. break;
  362. default:
  363. rt_set_errno(EINVAL);
  364. break;
  365. }
  366. return ret;
  367. }