db_devices.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399
  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. * db_device.c
  17. *
  18. * This file contains operands to handle streams with URIs that start with
  19. * "dev:".
  20. */
  21. #include "pal_defs.h"
  22. #include "pal_linux_defs.h"
  23. #include "pal.h"
  24. #include "pal_internal.h"
  25. #include "pal_linux.h"
  26. #include "pal_debug.h"
  27. #include "pal_error.h"
  28. #include "api.h"
  29. #include <linux/types.h>
  30. typedef __kernel_pid_t pid_t;
  31. #include <linux/stat.h>
  32. #include <asm/stat.h>
  33. #include <asm/fcntl.h>
  34. #define DEVICE_OPS(handle) \
  35. ({ int _type = (handle)->dev.dev_type; \
  36. (_type <= 0 || _type >= PAL_DEVICE_TYPE_BOUND) ? \
  37. NULL : pal_device_ops[_type]; \
  38. })
  39. enum {
  40. device_type_none = 0,
  41. device_type_term,
  42. PAL_DEVICE_TYPE_BOUND,
  43. };
  44. static struct handle_ops term_ops;
  45. static const struct handle_ops * pal_device_ops [PAL_DEVICE_TYPE_BOUND] = {
  46. NULL,
  47. &term_ops,
  48. };
  49. /* parse-device_uri scan the uri, parse the prefix of the uri and search
  50. for stream handler wich will open or access the device */
  51. static int parse_device_uri (const char ** uri, const char ** type,
  52. struct handle_ops ** ops)
  53. {
  54. struct handle_ops * dops = NULL;
  55. const char * p, * u = (*uri);
  56. for (p = u ; (*p) && (*p) != ',' && (*p) != '/' ; p++);
  57. if (strpartcmp_static(u, "tty"))
  58. dops = &term_ops;
  59. if (!dops)
  60. return -PAL_ERROR_NOTSUPPORT;
  61. *uri = (*p) ? p + 1 : p;
  62. if (type)
  63. *type = u;
  64. if (ops)
  65. *ops = dops;
  66. return 0;
  67. }
  68. static inline void
  69. dev_attrcopy (PAL_STREAM_ATTR * attr, struct stat * stat);
  70. static int char_read (PAL_HANDLE handle, int offset, int count, void * buffer);
  71. static int char_write (PAL_HANDLE handle, int offset, int count,
  72. const void * buffer);
  73. static int term_attrquery (const char * type, const char * uri,
  74. PAL_STREAM_ATTR * attr);
  75. static int term_attrquerybyhdl (PAL_HANDLE hdl,
  76. PAL_STREAM_ATTR * attr);
  77. /* Method to open standard terminal */
  78. static int open_standard_term (PAL_HANDLE * handle, const char * param,
  79. int access)
  80. {
  81. if (param)
  82. return -PAL_ERROR_NOTIMPLEMENTED;
  83. PAL_HANDLE hdl = malloc(HANDLE_SIZE(dev));
  84. SET_HANDLE_TYPE(hdl, dev);
  85. hdl->dev.dev_type = device_type_term;
  86. if (!(access & PAL_ACCESS_WRONLY)) {
  87. HANDLE_HDR(hdl)->flags |= RFD(0);
  88. hdl->dev.fd_in = 0;
  89. }
  90. if (access & (PAL_ACCESS_WRONLY|PAL_ACCESS_RDWR)) {
  91. HANDLE_HDR(hdl)->flags |= WFD(1);
  92. hdl->dev.fd_out = 1;
  93. }
  94. *handle = hdl;
  95. return 0;
  96. }
  97. /* 'open' operation for terminal stream */
  98. static int term_open (PAL_HANDLE *handle, const char * type, const char * uri,
  99. int access, int share, int create, int options)
  100. {
  101. const char * term = NULL;
  102. const char * param = NULL;
  103. const char * tmp = uri;
  104. while (*tmp) {
  105. if (!term && *tmp == '/')
  106. term = tmp + 1;
  107. if (*tmp == ',') {
  108. param = param + 1;
  109. break;
  110. }
  111. tmp++;
  112. }
  113. if (term)
  114. return -PAL_ERROR_NOTIMPLEMENTED;
  115. return open_standard_term(handle, param, access);
  116. }
  117. static int term_close (PAL_HANDLE handle)
  118. {
  119. return 0;
  120. }
  121. /* 'attrquery' operation for terminal stream */
  122. static int term_attrquery (const char * type, const char * uri,
  123. PAL_STREAM_ATTR * attr)
  124. {
  125. attr->handle_type = pal_type_dev;
  126. attr->readable = PAL_TRUE;
  127. attr->writeable = PAL_TRUE;
  128. attr->runnable = PAL_FALSE;
  129. attr->pending_size = 0;
  130. return 0;
  131. }
  132. /* 'attrquery' operation for terminal stream */
  133. static int term_attrquerybyhdl (PAL_HANDLE hdl,
  134. PAL_STREAM_ATTR * attr)
  135. {
  136. attr->handle_type = pal_type_dev;
  137. attr->readable = (hdl->dev.fd_in != PAL_IDX_POISON);
  138. attr->writeable = (hdl->dev.fd_out != PAL_IDX_POISON);
  139. attr->runnable = PAL_FALSE;
  140. attr->pending_size = 0;
  141. return 0;
  142. }
  143. static struct handle_ops term_ops = {
  144. .open = &term_open,
  145. .close = &term_close,
  146. .read = &char_read,
  147. .write = &char_write,
  148. .attrquery = &term_attrquery,
  149. .attrquerybyhdl = &term_attrquerybyhdl,
  150. };
  151. /* 'read' operation for character streams. */
  152. static int char_read (PAL_HANDLE handle, int offset, int size, void * buffer)
  153. {
  154. int fd = handle->dev.fd_in;
  155. if (fd == PAL_IDX_POISON)
  156. return -PAL_ERROR_DENIED;
  157. return ocall_read(fd, buffer, size);
  158. }
  159. /* 'write' operation for character streams. */
  160. static int char_write (PAL_HANDLE handle, int offset, int size,
  161. const void * buffer)
  162. {
  163. int fd = handle->dev.fd_out;
  164. if (fd == PAL_IDX_POISON)
  165. return -PAL_ERROR_DENIED;
  166. return ocall_write(fd, buffer, size);
  167. }
  168. /* 'open' operation for device streams */
  169. static int dev_open (PAL_HANDLE * handle, const char * type, const char * uri,
  170. int access, int share, int create, int options)
  171. {
  172. struct handle_ops * ops = NULL;
  173. const char * dev_type = NULL;
  174. int ret = 0;
  175. ret = parse_device_uri(&uri, &dev_type, &ops);
  176. if (ret < 0)
  177. return ret;
  178. if (!ops->open)
  179. return -PAL_ERROR_NOTSUPPORT;
  180. PAL_HANDLE hdl = malloc(HANDLE_SIZE(dev));
  181. SET_HANDLE_TYPE(hdl, dev);
  182. hdl->dev.fd_in = PAL_IDX_POISON;
  183. hdl->dev.fd_out = PAL_IDX_POISON;
  184. *handle = hdl;
  185. return ops->open(handle, dev_type, uri,
  186. access, share, create, options);
  187. }
  188. /* 'read' operation for device stream */
  189. static int dev_read (PAL_HANDLE handle, int offset, int size, void * buffer)
  190. {
  191. const struct handle_ops * ops = DEVICE_OPS(handle);
  192. if (!ops || !ops->read)
  193. return -PAL_ERROR_NOTSUPPORT;
  194. return ops->read(handle, offset, size, buffer);
  195. }
  196. /* 'write' operation for device stream */
  197. static int dev_write (PAL_HANDLE handle, int offset, int size,
  198. const void * buffer)
  199. {
  200. const struct handle_ops * ops = DEVICE_OPS(handle);
  201. if (!ops || !ops->write)
  202. return -PAL_ERROR_NOTSUPPORT;
  203. return ops->write(handle, offset, size, buffer);
  204. }
  205. /* 'close' operation for device streams */
  206. static int dev_close (PAL_HANDLE handle)
  207. {
  208. const struct handle_ops * ops = DEVICE_OPS(handle);
  209. if (ops && ops->close)
  210. return ops->close(handle);
  211. if (handle->dev.fd_in != PAL_IDX_POISON) {
  212. int fd = handle->dev.fd_in;
  213. ocall_close(fd);
  214. }
  215. if (handle->dev.fd_out != PAL_IDX_POISON) {
  216. int fd = handle->dev.fd_out;
  217. ocall_close(fd);
  218. }
  219. if (handle->file.realpath)
  220. free((void *) handle->file.realpath);
  221. return 0;
  222. }
  223. /* 'delete' operation for device streams */
  224. static int dev_delete (PAL_HANDLE handle, int access)
  225. {
  226. const struct handle_ops * ops = DEVICE_OPS(handle);
  227. if (!ops || !ops->delete)
  228. return -PAL_ERROR_DENIED;
  229. int ret = dev_close(handle);
  230. if (ret < 0)
  231. return ret;
  232. return ops->delete(handle, access);
  233. }
  234. /* 'flush' operation for device streams */
  235. static int dev_flush (PAL_HANDLE handle)
  236. {
  237. const struct handle_ops * ops = DEVICE_OPS(handle);
  238. if (ops && ops->flush)
  239. return ops->flush(handle);
  240. /* try to flush input stream */
  241. if (handle->dev.fd_in != PAL_IDX_POISON) {
  242. int fd = handle->dev.fd_in;
  243. ocall_fsync(fd);
  244. }
  245. /* if output stream exists and does not equal to input stream,
  246. flush output stream as well */
  247. if (handle->dev.fd_out != PAL_IDX_POISON &&
  248. handle->dev.fd_out != handle->dev.fd_in) {
  249. int fd = handle->dev.fd_out;
  250. ocall_fsync(fd);
  251. }
  252. return 0;
  253. }
  254. static inline void
  255. dev_attrcopy (PAL_STREAM_ATTR * attr, struct stat * stat)
  256. {
  257. attr->handle_type = pal_type_dev;
  258. /* readable, writable and runnable are decied by euidstataccess */
  259. attr->readable = stataccess(stat, ACCESS_R);
  260. attr->writeable = stataccess(stat, ACCESS_W);
  261. attr->runnable = stataccess(stat, ACCESS_X);
  262. attr->pending_size = stat->st_size;
  263. }
  264. /* 'attrquery' operation for device streams */
  265. static int dev_attrquery (const char * type, const char * uri,
  266. PAL_STREAM_ATTR * attr)
  267. {
  268. struct handle_ops * ops = NULL;
  269. const char * dev_type = NULL;
  270. int ret = 0;
  271. ret = parse_device_uri(&uri, &dev_type, &ops);
  272. if (ret < 0)
  273. return ret;
  274. if (!ops || !ops->attrquery)
  275. return -PAL_ERROR_NOTSUPPORT;
  276. return ops->attrquery(dev_type, uri, attr);
  277. }
  278. /* 'attrquerybyhdl' operation for device stream */
  279. static int dev_attrquerybyhdl (PAL_HANDLE handle,
  280. PAL_STREAM_ATTR * attr)
  281. {
  282. const struct handle_ops * ops = DEVICE_OPS(handle);
  283. if (ops && ops->attrquerybyhdl)
  284. return ops->attrquerybyhdl(handle, attr);
  285. struct stat stat_buf, * stat_in = NULL, * stat_out = NULL;
  286. int ret;
  287. attr->handle_type = pal_type_dev;
  288. if (handle->dev.fd_in != PAL_IDX_POISON) {
  289. ret = ocall_fstat(handle->dev.fd_in, &stat_buf);
  290. if (!ret)
  291. stat_in = &stat_buf;
  292. }
  293. if (handle->dev.fd_in != PAL_IDX_POISON) {
  294. ret = ocall_fstat(handle->dev.fd_in, &stat_buf);
  295. if (!ret)
  296. stat_out = &stat_buf;
  297. }
  298. attr->readable = (stat_in && stataccess(stat_in, ACCESS_R));
  299. attr->writeable = (stat_in && stataccess(stat_in, ACCESS_W));
  300. attr->runnable = (stat_out && stataccess(stat_out, ACCESS_X));
  301. attr->pending_size = stat_in ? stat_in->st_size :
  302. (stat_out ? stat_out->st_size : 0);
  303. return 0;
  304. }
  305. static const char * dev_getrealpath (PAL_HANDLE handle)
  306. {
  307. return handle->dev.realpath;
  308. }
  309. struct handle_ops dev_ops = {
  310. .getrealpath = &dev_getrealpath,
  311. .open = &dev_open,
  312. .read = &dev_read,
  313. .write = &dev_write,
  314. .close = &dev_close,
  315. .delete = &dev_delete,
  316. .flush = &dev_flush,
  317. .attrquery = &dev_attrquery,
  318. .attrquerybyhdl = &dev_attrquerybyhdl,
  319. };