shim_semget.c 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955
  1. /* -*- mode:c; c-file-style:"k&r"; c-basic-offset: 4; tab-width:4; indent-tabs-mode:nil; mode:auto-fill; fill-column:78; -*- */
  2. /* vim: set ts=4 sw=4 et tw=78 fo=cqt wm=0: */
  3. /* Copyright (C) 2014 Stony Brook University
  4. This file is part of Graphene Library OS.
  5. Graphene Library OS is free software: you can redistribute it and/or
  6. modify it under the terms of the GNU Lesser General Public License
  7. as published by the Free Software Foundation, either version 3 of the
  8. License, or (at your option) any later version.
  9. Graphene Library OS is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. GNU Lesser General Public License for more details.
  13. You should have received a copy of the GNU Lesser General Public License
  14. along with this program. If not, see <http://www.gnu.org/licenses/>. */
  15. /*
  16. * shim_semget.c
  17. *
  18. * Implementation of system call "semget", "semop", "semtimedop" and "semctl".
  19. */
  20. #include <shim_internal.h>
  21. #include <shim_table.h>
  22. #include <shim_utils.h>
  23. #include <shim_handle.h>
  24. #include <shim_ipc.h>
  25. #include <shim_sysv.h>
  26. #include <shim_profile.h>
  27. #include <pal.h>
  28. #include <pal_error.h>
  29. #include <list.h>
  30. #include <errno.h>
  31. #define SEM_HASH_LEN 8
  32. #define SEM_HASH_NUM (1 << SEM_HASH_LEN)
  33. #define SEM_HASH_MASK (SEM_HASH_NUM - 1)
  34. #define SEM_HASH(idx) ((idx) & SEM_HASH_MASK)
  35. /* The sem_list links shim_sem_handle objects by the list field.
  36. * The sem_key_hlist links them by key_hlist, and qid_hlist by qid_hlist */
  37. DEFINE_LISTP(shim_sem_handle);
  38. static LISTP_TYPE(shim_sem_handle) sem_list;
  39. static LISTP_TYPE(shim_sem_handle) sem_key_hlist [SEM_HASH_NUM];
  40. static LISTP_TYPE(shim_sem_handle) sem_sid_hlist [SEM_HASH_NUM];
  41. static LOCKTYPE sem_list_lock;
  42. DEFINE_PROFILE_CATAGORY(sysv_sem, );
  43. #define SEM_TO_HANDLE(semhdl) \
  44. container_of((semhdl), struct shim_handle, info.sem)
  45. static int __add_sem_handle (unsigned long key, IDTYPE semid,
  46. int nsems, bool owned,
  47. struct shim_sem_handle ** semhdl)
  48. {
  49. LISTP_TYPE(shim_sem_handle) * key_head = (key != IPC_PRIVATE) ?
  50. &sem_key_hlist[SEM_HASH(key)] : NULL;
  51. LISTP_TYPE(shim_sem_handle) * sid_head = semid ?
  52. &sem_sid_hlist[SEM_HASH(semid)] : NULL;
  53. struct shim_sem_handle * tmp;
  54. int ret = 0;
  55. if (key_head)
  56. listp_for_each_entry(tmp, key_head, key_hlist)
  57. if (tmp->semkey == key) {
  58. if (tmp->semid == semid)
  59. goto out;
  60. return -EEXIST;
  61. }
  62. if (sid_head)
  63. listp_for_each_entry(tmp, sid_head, sid_hlist)
  64. if (tmp->semid == semid) {
  65. if (key)
  66. tmp->semkey = key;
  67. goto out;
  68. }
  69. struct shim_handle * hdl = get_new_handle();
  70. if (!hdl)
  71. return -ENOMEM;
  72. tmp = &hdl->info.sem;
  73. hdl->type = TYPE_SEM;
  74. tmp->semkey = key;
  75. tmp->semid = semid;
  76. tmp->owned = owned;
  77. tmp->event = DkNotificationEventCreate(PAL_FALSE);
  78. if (owned && nsems) {
  79. tmp->nsems = nsems;
  80. tmp->sems = malloc(sizeof(struct sem_obj) * nsems);
  81. if (!tmp->sems) {
  82. ret = -ENOMEM;
  83. goto failed;
  84. }
  85. for (int i = 0 ; i < nsems ; i++) {
  86. tmp->sems[i].num = i;
  87. tmp->sems[i].val = 0;
  88. tmp->sems[i].host_sem_id = 0;
  89. tmp->sems[i].host_sem = NULL;
  90. INIT_LISTP(&tmp->sems[i].ops);
  91. INIT_LISTP(&tmp->sems[i].next_ops);
  92. }
  93. }
  94. INIT_LISTP(&tmp->migrated);
  95. INIT_LIST_HEAD(tmp, list);
  96. get_handle(hdl);
  97. listp_add_tail(tmp, &sem_list, list);
  98. INIT_LIST_HEAD(tmp, key_hlist);
  99. if (key_head) {
  100. get_handle(hdl);
  101. listp_add(tmp, key_head, key_hlist);
  102. }
  103. if (sid_head) {
  104. get_handle(hdl);
  105. listp_add(tmp, sid_head, sid_hlist);
  106. }
  107. out:
  108. if (!semhdl) {
  109. put_handle(hdl);
  110. return 0;
  111. }
  112. *semhdl = tmp;
  113. return 0;
  114. failed:
  115. put_handle(hdl);
  116. return ret;
  117. }
  118. int add_sem_handle (unsigned long key, IDTYPE id, int nsems, bool owned)
  119. {
  120. lock(sem_list_lock);
  121. int ret = __add_sem_handle(key, id, nsems, owned, NULL);
  122. unlock(sem_list_lock);
  123. return ret;
  124. }
  125. struct shim_sem_handle * get_sem_handle_by_key (unsigned long key)
  126. {
  127. LISTP_TYPE(shim_sem_handle) * key_head = &sem_key_hlist[SEM_HASH(key)];
  128. struct shim_sem_handle * tmp, * found = NULL;
  129. lock(sem_list_lock);
  130. listp_for_each_entry(tmp, key_head, key_hlist)
  131. if (tmp->semkey == key) {
  132. found = tmp;
  133. break;
  134. }
  135. if (found)
  136. get_handle(SEM_TO_HANDLE(found));
  137. unlock(sem_list_lock);
  138. return found;
  139. }
  140. struct shim_sem_handle * get_sem_handle_by_id (IDTYPE semid)
  141. {
  142. LISTP_TYPE(shim_sem_handle) * sid_head = &sem_sid_hlist[SEM_HASH(semid)];
  143. struct shim_sem_handle * tmp, * found = NULL;
  144. lock(sem_list_lock);
  145. listp_for_each_entry(tmp, sid_head, sid_hlist)
  146. if (tmp->semid == semid) {
  147. found = tmp;
  148. break;
  149. }
  150. if (found)
  151. get_handle(SEM_TO_HANDLE(found));
  152. unlock(sem_list_lock);
  153. return found;
  154. }
  155. void put_sem_handle (struct shim_sem_handle * sem)
  156. {
  157. put_handle(SEM_TO_HANDLE(sem));
  158. }
  159. static int __del_sem_handle (struct shim_sem_handle * sem)
  160. {
  161. if (sem->deleted)
  162. return 0;
  163. sem->deleted = true;
  164. struct shim_handle * hdl = SEM_TO_HANDLE(sem);
  165. lock(sem_list_lock);
  166. listp_del_init(sem, &sem_list, list);
  167. put_handle(hdl);
  168. if (!list_empty(sem, key_hlist)) {
  169. // DEP: Yuck
  170. LISTP_TYPE(shim_sem_handle) * key_head = &sem_key_hlist[SEM_HASH(sem->semkey)];
  171. listp_del_init(sem, key_head, key_hlist);
  172. put_handle(hdl);
  173. }
  174. if (!list_empty(sem, sid_hlist)) {
  175. // DEP: Yuck
  176. LISTP_TYPE(shim_sem_handle) * sid_head = &sem_sid_hlist[SEM_HASH(sem->semid)];
  177. listp_del_init(sem, sid_head, sid_hlist);
  178. put_handle(hdl);
  179. }
  180. unlock(sem_list_lock);
  181. return 0;
  182. }
  183. int del_sem_handle (struct shim_sem_handle * sem)
  184. {
  185. struct shim_handle * hdl = SEM_TO_HANDLE(sem);
  186. lock(hdl->lock);
  187. int ret = del_sem_handle(sem);
  188. unlock(hdl->lock);
  189. return ret;
  190. }
  191. static void __try_create_lock (void)
  192. {
  193. create_lock_runtime(&sem_list_lock);
  194. }
  195. int shim_do_semget (key_t key, int nsems, int semflg)
  196. {
  197. INC_PROFILE_OCCURENCE(syscall_use_ipc);
  198. IDTYPE semid = 0;
  199. int ret;
  200. __try_create_lock();
  201. if (key != IPC_PRIVATE) {
  202. struct shim_sem_handle * sem = get_sem_handle_by_key(key);
  203. if (sem) {
  204. semid = sem->semid;
  205. put_sem_handle(sem);
  206. return (semflg & IPC_EXCL) ? -EEXIST : semid;
  207. }
  208. }
  209. struct sysv_key k;
  210. k.key = key;
  211. k.type = SYSV_SEM;
  212. if (semflg & IPC_CREAT) {
  213. do {
  214. semid = allocate_sysv(0, 0);
  215. if (!semid)
  216. semid = ipc_sysv_lease_send(NULL);
  217. } while (!semid);
  218. if (key != IPC_PRIVATE) {
  219. if ((ret = ipc_sysv_tellkey_send(NULL, 0, &k, semid, 0)) < 0) {
  220. release_sysv(semid);
  221. return ret;
  222. }
  223. }
  224. add_sem_handle(key, semid, nsems, true);
  225. } else {
  226. if ((ret = ipc_sysv_findkey_send(&k)) < 0)
  227. return ret;
  228. semid = ret;
  229. if ((ret = ipc_sysv_query_send(semid)) < 0)
  230. return ret;
  231. }
  232. return semid;
  233. }
  234. static int connect_sem_handle (int semid, int nsems,
  235. struct shim_sem_handle ** semp)
  236. {
  237. struct shim_sem_handle * sem = get_sem_handle_by_id(semid);
  238. int ret;
  239. if (!sem) {
  240. if ((ret = ipc_sysv_query_send(semid)) < 0)
  241. return ret;
  242. if (!sem) {
  243. lock(sem_list_lock);
  244. ret = __add_sem_handle(IPC_PRIVATE, semid, nsems, false, &sem);
  245. unlock(sem_list_lock);
  246. if (ret < 0)
  247. return ret;
  248. }
  249. }
  250. *semp = sem;
  251. return 0;
  252. }
  253. int recover_sem_ownership (struct shim_sem_handle * sem,
  254. struct sem_backup * backups, int nbackups,
  255. struct sem_client_backup * clients, int nclients)
  256. {
  257. struct shim_handle * hdl = SEM_TO_HANDLE(sem);
  258. lock(hdl->lock);
  259. assert(!sem->owned);
  260. assert(!sem->nsems && !sem->sems);
  261. sem->nsems = nbackups;
  262. if (!sem->sems && !(sem->sems = malloc(sizeof(struct sem_obj) * nbackups)))
  263. goto out;
  264. for (int i = 0 ; i < nbackups ; i++) {
  265. sem->sems[i].num = i;
  266. sem->sems[i].val = backups[i].val;
  267. sem->sems[i].zcnt = backups[i].zcnt;
  268. sem->sems[i].ncnt = backups[i].ncnt;
  269. sem->sems[i].pid = backups[i].pid;
  270. INIT_LISTP(&sem->sems[i].ops);
  271. INIT_LISTP(&sem->sems[i].next_ops);
  272. }
  273. for (int i = 0 ; i < nclients ; i++) {
  274. struct sem_ops * op = malloc(sizeof(struct sem_ops));
  275. if (!op)
  276. continue;
  277. op->stat.completed = false;
  278. op->stat.failed = false;
  279. op->stat.nops = clients[i].nops;
  280. op->stat.current = clients[i].current;
  281. op->stat.timeout = -1;
  282. op->client.vmid = clients[i].vmid;
  283. op->client.port = NULL;
  284. op->client.seq = clients[i].seq;
  285. INIT_LIST_HEAD(op, progress);
  286. listp_add_tail(op, &sem->migrated, progress);
  287. }
  288. sem->owned = true;
  289. DkEventSet(sem->event);
  290. out:
  291. unlock(hdl->lock);
  292. return 0;
  293. }
  294. static int __do_semop (int semid, struct sembuf * sops, unsigned int nsops,
  295. unsigned long timeout)
  296. {
  297. int ret;
  298. struct shim_sem_handle * sem;
  299. int nsems = 0;
  300. for (int i = 0 ; i < nsops ; i++)
  301. if (sops[i].sem_num >= nsems)
  302. nsems = sops[i].sem_num + 1;
  303. __try_create_lock();
  304. if ((ret = connect_sem_handle(semid, nsems, &sem)) < 0)
  305. return ret;
  306. ret = submit_sysv_sem(sem, sops, nsops, timeout, NULL);
  307. put_sem_handle(sem);
  308. return ret;
  309. }
  310. int shim_do_semop (int semid, struct sembuf * sops, unsigned int nsops)
  311. {
  312. INC_PROFILE_OCCURENCE(syscall_use_ipc);
  313. return __do_semop(semid, sops, nsops, IPC_SEM_NOTIMEOUT);
  314. }
  315. int shim_do_semtimedop (int semid, struct sembuf * sops, unsigned int nsops,
  316. const struct timespec * timeout)
  317. {
  318. INC_PROFILE_OCCURENCE(syscall_use_ipc);
  319. return __do_semop(semid, sops, nsops,
  320. timeout->tv_sec * 1000000000ULL + timeout->tv_nsec);
  321. }
  322. int shim_do_semctl (int semid, int semnum, int cmd, unsigned long arg)
  323. {
  324. INC_PROFILE_OCCURENCE(syscall_use_ipc);
  325. struct shim_sem_handle * sem;
  326. int ret;
  327. __try_create_lock();
  328. if ((ret = connect_sem_handle(semid, 0, &sem)) < 0)
  329. return ret;
  330. struct shim_handle * hdl = SEM_TO_HANDLE(sem);
  331. lock(hdl->lock);
  332. switch (cmd) {
  333. case IPC_RMID: {
  334. if (!sem->owned) {
  335. ret = ipc_sysv_delres_send(NULL, 0, semid, SYSV_SEM);
  336. if (ret < 0)
  337. goto out;
  338. }
  339. __del_sem_handle(sem);
  340. goto out;
  341. }
  342. }
  343. if (sem->owned) {
  344. if (sem->deleted) {
  345. ret = -EIDRM;
  346. goto out;
  347. }
  348. switch (cmd) {
  349. case GETALL:
  350. for (int i = 0 ; i < sem->nsems ; i++) {
  351. unsigned short val = sem->sems[i].val;
  352. ((unsigned short *) arg)[i] = val;
  353. }
  354. break;
  355. case GETNCNT:
  356. ret = sem->sems[semnum].ncnt;
  357. break;
  358. case GETPID:
  359. ret = sem->sems[semnum].pid;
  360. break;
  361. case GETVAL:
  362. ret = sem->sems[semnum].val;
  363. break;
  364. case GETZCNT:
  365. ret = sem->sems[semnum].zcnt;
  366. break;
  367. case SETALL:
  368. for (int i = 0 ; i < sem->nsems ; i++) {
  369. unsigned short val = ((unsigned short *) arg)[i];
  370. sem->sems[i].val = val;
  371. }
  372. break;
  373. case SETVAL: {
  374. unsigned short val = arg;
  375. sem->sems[semnum].val = val;
  376. break;
  377. }
  378. }
  379. } else {
  380. switch (cmd) {
  381. case GETALL:
  382. case SETALL: {
  383. int valsize = sem->nsems * sizeof(unsigned short);
  384. ret = ipc_sysv_semctl_send(sem->semid, 0, cmd,
  385. (unsigned short *) arg, valsize);
  386. break;
  387. }
  388. case GETVAL:
  389. case GETNCNT:
  390. case GETPID:
  391. case GETZCNT: {
  392. int valsize = sizeof(unsigned short);
  393. unsigned short val;
  394. ret = ipc_sysv_semctl_send(sem->semid, semnum, cmd,
  395. &val, valsize);
  396. if (!ret)
  397. ret = val;
  398. break;
  399. }
  400. case SETVAL: {
  401. unsigned short val = arg;
  402. ret = ipc_sysv_semctl_send(sem->semid, semnum, cmd,
  403. &val, sizeof(unsigned short));
  404. break;
  405. }
  406. }
  407. }
  408. out:
  409. unlock(hdl->lock);
  410. put_sem_handle(sem);
  411. return ret;
  412. }
  413. static bool __handle_sysv_sems (struct shim_sem_handle * sem)
  414. {
  415. bool progressed = false;
  416. bool setevent = false;
  417. struct sem_obj * sobj;
  418. for (sobj = sem->sems ; sobj < &sem->sems[sem->nsems] ; sobj++)
  419. listp_splice_tail_init(&sobj->next_ops, &sobj->ops, progress, sem_ops);
  420. for (sobj = sem->sems ; sobj < &sem->sems[sem->nsems] ; sobj++) {
  421. struct sem_ops * sops, * n;
  422. listp_for_each_entry_safe(sops, n, &sobj->ops, progress) {
  423. struct sembuf * op = &sops->ops[sops->stat.current];
  424. assert(op->sem_num == sobj->num);
  425. // first_iter is a variable defined by listp_for_each_entry_safe
  426. // The second part of this assertion is only valid after the first attempt
  427. assert(first_iter || (sops != n));
  428. if (sops->stat.completed)
  429. goto send_result;
  430. again:
  431. if (op->sem_op > 0) {
  432. sobj->val += op->sem_op;
  433. debug("sem %u: add %u => %u\n", sobj->num, op->sem_op,
  434. sobj->val);
  435. } else if (op->sem_op < 0) {
  436. if (sobj->val < -op->sem_op) {
  437. if (op->sem_flg & IPC_NOWAIT) {
  438. debug("sem %u: wait for %u failed\n", sobj->num,
  439. -op->sem_op);
  440. goto failed;
  441. }
  442. continue;
  443. }
  444. sobj->val -= -op->sem_op;
  445. debug("sem %u: wait for %u => %u\n", sobj->num, -op->sem_op,
  446. sobj->val);
  447. } else {
  448. if (sobj->val) {
  449. if (op->sem_flg & IPC_NOWAIT) {
  450. debug("sem %u: wait for 0 failed\n", sobj->num);
  451. goto failed;
  452. }
  453. continue;
  454. }
  455. debug("sem %u: wait for 0\n", sobj->num);
  456. }
  457. progressed = true;
  458. sops->stat.current++;
  459. if (sops->stat.current == sops->stat.nops) {
  460. sops->stat.completed = true;
  461. goto send_result;
  462. }
  463. op = &sops->ops[sops->stat.current];
  464. if (op->sem_num != sobj->num) {
  465. listp_move_tail(sops,
  466. &sem->sems[op->sem_num].next_ops,
  467. &sobj->ops,
  468. progress);
  469. continue;
  470. }
  471. goto again;
  472. failed:
  473. progressed = true;
  474. sops->stat.failed = true;
  475. send_result:
  476. /* Chia-Che 10/17/17: If the code reaches this point, sops should
  477. * still be in sobj->ops. */
  478. listp_del_init(sops, &sobj->ops, progress);
  479. sem->nreqs--;
  480. if (!sops->client.vmid) {
  481. setevent = true;
  482. continue;
  483. }
  484. send_ipc_message(create_ipc_resp_msg_on_stack(
  485. sops->stat.completed ? 0 : -EAGAIN,
  486. sops->client.vmid,
  487. sops->client.seq), sops->client.port);
  488. put_ipc_port(sops->client.port);
  489. sops->client.vmid = 0;
  490. sops->client.port = NULL;
  491. sops->client.seq = 0;
  492. free(sops);
  493. }
  494. }
  495. if (setevent)
  496. DkEventSet(sem->event);
  497. return progressed;
  498. }
  499. static void __handle_one_sysv_sem (struct shim_sem_handle * sem,
  500. struct sem_stat * stat,
  501. struct sembuf * sops)
  502. {
  503. bool progressed = false;
  504. again:
  505. while (stat->current < stat->nops) {
  506. struct sem_obj * sobj = &sem->sems[sops[stat->current].sem_num];
  507. struct sembuf * op = &sops[stat->current];
  508. if (op->sem_op > 0) {
  509. progressed = true;
  510. sobj->val += op->sem_op;
  511. debug("sem %u: add %u => %u\n", sobj->num, op->sem_op,
  512. sobj->val);
  513. } else if (op->sem_op < 0) {
  514. if (sobj->val < -op->sem_op) {
  515. if (op->sem_flg & IPC_NOWAIT) {
  516. stat->failed = true;
  517. debug("sem %u: wait for %u failed\n", sobj->num,
  518. -op->sem_op);
  519. return;
  520. }
  521. goto failed;
  522. }
  523. progressed = true;
  524. sobj->val -= -op->sem_op;
  525. debug("sem %u: wait for %u => %u\n", sobj->num, -op->sem_op,
  526. sobj->val);
  527. } else {
  528. if (sobj->val) {
  529. if (op->sem_flg & IPC_NOWAIT) {
  530. stat->failed = true;
  531. debug("sem %u: wait for 0 failed\n", sobj->num);
  532. return;
  533. }
  534. goto failed;
  535. }
  536. progressed = true;
  537. debug("sem %u: wait for 0\n", sobj->num);
  538. }
  539. stat->current++;
  540. }
  541. stat->completed = true;
  542. failed:
  543. if (progressed) {
  544. while (__handle_sysv_sems(sem));
  545. progressed = false;
  546. if (!stat->completed)
  547. goto again;
  548. }
  549. }
  550. static int sem_balance_migrate (struct shim_handle * hdl,
  551. struct sysv_client * client);
  552. static struct sysv_balance_policy sem_policy = {
  553. .score_decay = SEM_SCORE_DECAY,
  554. .score_max = SEM_SCORE_MAX,
  555. .balance_threshold = SEM_BALANCE_THRESHOLD,
  556. .migrate = &sem_balance_migrate,
  557. };
  558. DEFINE_PROFILE_CATAGORY(submit_sysv_sem, sysv_sem);
  559. DEFINE_PROFILE_INTERVAL(sem_prepare_stat, submit_sysv_sem);
  560. DEFINE_PROFILE_INTERVAL(sem_lock_handle, submit_sysv_sem);
  561. DEFINE_PROFILE_INTERVAL(sem_count_score, submit_sysv_sem);
  562. DEFINE_PROFILE_INTERVAL(sem_handle_by_shared_semaphore, submit_sysv_sem);
  563. DEFINE_PROFILE_INTERVAL(sem_send_ipc_movres, submit_sysv_sem);
  564. DEFINE_PROFILE_INTERVAL(sem_send_ipc_semop, submit_sysv_sem);
  565. DEFINE_PROFILE_INTERVAL(sem_handle_one_sysv_sem, submit_sysv_sem);
  566. DEFINE_PROFILE_INTERVAL(sem_send_ipc_response, submit_sysv_sem);
  567. DEFINE_PROFILE_INTERVAL(sem_alloc_semop, submit_sysv_sem);
  568. DEFINE_PROFILE_INTERVAL(sem_append_semop, submit_sysv_sem);
  569. DEFINE_PROFILE_INTERVAL(sem_wait_for_complete, submit_sysv_sem);
  570. int submit_sysv_sem (struct shim_sem_handle * sem, struct sembuf * sops,
  571. int nsops, unsigned long timeout,
  572. struct sysv_client * client)
  573. {
  574. BEGIN_PROFILE_INTERVAL();
  575. int ret = 0;
  576. struct shim_handle * hdl = SEM_TO_HANDLE(sem);
  577. struct sem_ops * sem_ops = NULL;
  578. bool malloced = false;
  579. struct sem_stat stat;
  580. stat.nops = nsops;
  581. stat.current = 0;
  582. stat.timeout = timeout;
  583. stat.completed = false;
  584. stat.failed = false;
  585. SAVE_PROFILE_INTERVAL(sem_prepare_stat);
  586. lock(hdl->lock);
  587. SAVE_PROFILE_INTERVAL(sem_lock_handle);
  588. if (sem->deleted) {
  589. ret = -EIDRM;
  590. goto out_locked;
  591. }
  592. IDTYPE semid = sem->semid;
  593. bool sendreply = false;
  594. unsigned long seq = client ? client->seq : 0;
  595. int score = 0;
  596. for (int i = 0 ; i < nsops ; i++) {
  597. struct sembuf * op = &sops[i];
  598. if (op->sem_num > 0) {
  599. score += SEM_POSITIVE_SCORE(op->sem_num);
  600. } else if (op->sem_num < 0) {
  601. score += SEM_NEGATIVE_SCORE(-op->sem_num);
  602. sendreply = true;
  603. } else {
  604. score += SEM_ZERO_SCORE;
  605. sendreply = true;
  606. }
  607. }
  608. SAVE_PROFILE_INTERVAL(sem_count_score);
  609. if (sem->deleted) {
  610. if (!client || sendreply) {
  611. ret = -EIDRM;
  612. goto out_locked;
  613. }
  614. ret = ipc_sysv_delres_send(client->port, client->vmid, sem->semid,
  615. SYSV_SEM);
  616. goto out_locked;
  617. }
  618. if (sem->owned) {
  619. __balance_sysv_score(&sem_policy, hdl, sem->scores, MAX_SYSV_CLIENTS,
  620. client, score);
  621. if (!sem->owned && client) {
  622. struct shim_ipc_info * owner = sem->owner;
  623. assert(owner);
  624. ret = ipc_sysv_movres_send(client, owner->vmid,
  625. qstrgetstr(&owner->uri), sem->lease,
  626. sem->semid, SYSV_SEM);
  627. goto out_locked;
  628. }
  629. }
  630. if (!sem->owned) {
  631. if (client) {
  632. struct shim_ipc_info * owner = sem->owner;
  633. ret = owner ?
  634. ipc_sysv_movres_send(client, owner->vmid,
  635. qstrgetstr(&owner->uri), sem->lease,
  636. sem->semid, SYSV_SEM) :
  637. -ECONNREFUSED;
  638. SAVE_PROFILE_INTERVAL(sem_send_ipc_movres);
  639. goto out_locked;
  640. }
  641. unowned:
  642. unlock(hdl->lock);
  643. ret = ipc_sysv_semop_send(semid, sops, nsops, timeout, &seq);
  644. if (ret != -EAGAIN &&
  645. ret != -ECONNREFUSED)
  646. goto out;
  647. lock(hdl->lock);
  648. SAVE_PROFILE_INTERVAL(sem_send_ipc_semop);
  649. if (!sem->owned)
  650. goto out_locked;
  651. }
  652. if (seq) {
  653. struct sem_ops * op;
  654. listp_for_each_entry(op, &sem->migrated, progress)
  655. if (op->client.vmid == (client ? client->vmid : cur_process.vmid)
  656. && seq == op->client.seq) {
  657. listp_del_init(op, &sem->migrated, progress);
  658. sem_ops = op;
  659. stat = sem_ops->stat;
  660. malloced = true;
  661. break;
  662. }
  663. }
  664. __handle_one_sysv_sem(sem, &stat, sops);
  665. SAVE_PROFILE_INTERVAL(sem_handle_one_sysv_sem);
  666. if (stat.completed || stat.failed) {
  667. ret = stat.completed ? 0 : -EAGAIN;
  668. if (client && sendreply)
  669. ret = send_ipc_message(create_ipc_resp_msg_on_stack(
  670. ret, client->vmid,
  671. client->seq), client->port);
  672. SAVE_PROFILE_INTERVAL(sem_send_ipc_response);
  673. goto out_locked;
  674. }
  675. if (client) {
  676. assert(sendreply);
  677. if (!sem_ops || !malloced) {
  678. sem_ops = malloc(sizeof(struct sem_ops) +
  679. sizeof(struct sembuf) * nsops);
  680. if (!sem_ops) {
  681. ret = -ENOMEM;
  682. goto out_locked;
  683. }
  684. sem_ops->client.vmid = 0;
  685. sem_ops->client.port = NULL;
  686. sem_ops->client.seq = 0;
  687. INIT_LIST_HEAD(sem_ops, progress);
  688. malloced = true;
  689. SAVE_PROFILE_INTERVAL(sem_alloc_semop);
  690. }
  691. } else {
  692. if (!sem_ops) {
  693. sem_ops = __alloca(sizeof(struct sem_ops) +
  694. sizeof(struct sembuf) * nsops);
  695. sem_ops->client.vmid = 0;
  696. sem_ops->client.port = NULL;
  697. sem_ops->client.seq = 0;
  698. INIT_LIST_HEAD(sem_ops, progress);
  699. SAVE_PROFILE_INTERVAL(sem_alloc_semop);
  700. }
  701. }
  702. sem_ops->stat = stat;
  703. for (int i = 0 ; i < nsops ; i++)
  704. sem_ops->ops[i] = sops[i];
  705. LISTP_TYPE(sem_ops) * next_ops =
  706. &sem->sems[sops[stat.current].sem_num].next_ops;
  707. assert(list_empty(sem_ops, progress));
  708. listp_add_tail(sem_ops, next_ops, progress);
  709. //check_list_head(next_ops);
  710. sem->nreqs++;
  711. SAVE_PROFILE_INTERVAL(sem_append_semop);
  712. if (client) {
  713. assert(sendreply);
  714. add_ipc_port(client->port, client->vmid, IPC_PORT_SYSVCON, NULL);
  715. get_ipc_port(client->port);
  716. sem_ops->client = *client;
  717. sem_ops = NULL;
  718. goto out_locked;
  719. }
  720. while (!sem_ops->stat.completed &&
  721. !sem_ops->stat.failed) {
  722. if (!sem->owned) {
  723. /* Chia-Che 10/17/17: sem_ops may move from semaphore to semaphore
  724. base on its current state */
  725. next_ops = &sem->sems[sem_ops->ops[sem_ops->stat.current].sem_num].next_ops;
  726. listp_del_init(sem_ops, next_ops, progress);
  727. goto unowned;
  728. }
  729. unlock(hdl->lock);
  730. DkObjectsWaitAny(1, &sem->event, NO_TIMEOUT);
  731. lock(hdl->lock);
  732. SAVE_PROFILE_INTERVAL(sem_wait_for_complete);
  733. }
  734. ret = sem_ops->stat.completed ? 0 : -EAGAIN;
  735. out_locked:
  736. unlock(hdl->lock);
  737. out:
  738. if (sem_ops && malloced)
  739. free(sem_ops);
  740. return ret;
  741. }
  742. static int sem_balance_migrate (struct shim_handle * hdl,
  743. struct sysv_client * src)
  744. {
  745. struct shim_sem_handle * sem = &hdl->info.sem;
  746. int ret = 0;
  747. debug("trigger semaphore balancing, migrate to process %u\n", src->vmid);
  748. struct sem_backup * sem_backups = __alloca(sizeof(struct sem_backup) *
  749. sem->nsems);
  750. struct sem_client_backup * clients =
  751. __alloca(sizeof(struct sem_client_backup) * sem->nreqs);
  752. int sem_cnt = 0, client_cnt = 0;
  753. struct sem_obj * sobj;
  754. for (sobj = sem->sems ; sobj < &sem->sems[sem->nsems] ; sobj++) {
  755. assert(sem_cnt < sem->nsems);
  756. struct sem_backup * b = sem_backups + (sem_cnt++);
  757. b->val = sobj->val;
  758. b->zcnt = sobj->zcnt;
  759. b->ncnt = sobj->ncnt;
  760. b->pid = sobj->pid;
  761. listp_splice_tail(&sobj->next_ops, &sobj->ops, progress, sem_ops);
  762. struct sem_ops * sops;
  763. listp_for_each_entry(sops, &sobj->ops, progress) {
  764. assert(client_cnt < sem->nreqs);
  765. struct sem_client_backup * c = clients + (client_cnt)++;
  766. c->vmid = sops->client.vmid;
  767. c->seq = sops->client.seq;
  768. c->current = sops->stat.current;
  769. c->nops = sops->stat.nops;
  770. }
  771. }
  772. struct shim_ipc_info * info = discover_client(src->port, src->vmid);
  773. if (!info)
  774. goto out;
  775. ipc_sysv_sublease_send(src->vmid, sem->semid,
  776. qstrgetstr(&info->uri),
  777. &sem->lease);
  778. ret = ipc_sysv_semmov_send(src->port, src->vmid, sem->semid, sem->lease,
  779. sem_backups, sem_cnt, clients, client_cnt,
  780. sem->scores, MAX_SYSV_CLIENTS);
  781. if (ret < 0)
  782. goto failed_info;
  783. sem->owned = false;
  784. sem->owner = info;
  785. for (sobj = sem->sems ; sobj < &sem->sems[sem->nsems] ; sobj++) {
  786. struct sem_ops * sops, * n;
  787. listp_for_each_entry_safe(sops, n, &sobj->ops, progress) {
  788. listp_del_init(sops, &sobj->ops, progress);
  789. sem->nreqs--;
  790. sops->stat.failed = true;
  791. if (!sops->client.vmid)
  792. continue;
  793. ipc_sysv_movres_send(&sops->client, src->vmid,
  794. qstrgetstr(&info->uri), sem->lease,
  795. sem->semid, SYSV_SEM);
  796. put_ipc_port(sops->client.port);
  797. free(sops);
  798. }
  799. }
  800. sem->nsems = 0;
  801. free(sem->sems);
  802. sem->sems = NULL;
  803. ret = 0;
  804. DkEventSet(sem->event);
  805. goto out;
  806. failed_info:
  807. put_ipc_info(info);
  808. out:
  809. return ret;
  810. }