shim_handle.h 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428
  1. /* Copyright (C) 2014 Stony Brook University
  2. This file is part of Graphene Library OS.
  3. Graphene Library OS is free software: you can redistribute it and/or
  4. modify it under the terms of the GNU Lesser General Public License
  5. as published by the Free Software Foundation, either version 3 of the
  6. License, or (at your option) any later version.
  7. Graphene Library OS is distributed in the hope that it will be useful,
  8. but WITHOUT ANY WARRANTY; without even the implied warranty of
  9. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  10. GNU Lesser General Public License for more details.
  11. You should have received a copy of the GNU Lesser General Public License
  12. along with this program. If not, see <http://www.gnu.org/licenses/>. */
  13. /*
  14. * shim_handle.h
  15. *
  16. * Definitions of types and functions for file/handle bookkeeping.
  17. */
  18. #ifndef _SHIM_HANDLE_H_
  19. #define _SHIM_HANDLE_H_
  20. #include <asm/fcntl.h>
  21. #include <asm/resource.h>
  22. #include <atomic.h> // TODO: migrate to stdatomic.h
  23. #include <linux/in.h>
  24. #include <linux/in6.h>
  25. #include <linux/shm.h>
  26. #include <linux/un.h>
  27. #include <list.h>
  28. #include <pal.h>
  29. #include <shim_defs.h>
  30. #include <shim_sysv.h>
  31. #include <shim_types.h>
  32. #include <stdalign.h>
  33. /* start definition of shim handle */
  34. enum shim_handle_type {
  35. TYPE_FILE,
  36. TYPE_DEV,
  37. TYPE_PIPE,
  38. TYPE_SOCK,
  39. TYPE_DIR,
  40. TYPE_SHM,
  41. TYPE_SEM,
  42. TYPE_MSG,
  43. TYPE_FUTEX,
  44. TYPE_STR,
  45. TYPE_EPOLL,
  46. TYPE_EVENTFD
  47. };
  48. struct shim_handle;
  49. struct shim_thread;
  50. struct shim_vma;
  51. enum shim_file_type {
  52. FILE_UNKNOWN,
  53. FILE_REGULAR,
  54. FILE_DIR,
  55. FILE_DEV,
  56. FILE_TTY,
  57. };
  58. struct shim_file_data {
  59. struct shim_lock lock;
  60. struct atomic_int version;
  61. bool queried;
  62. enum shim_file_type type;
  63. mode_t mode;
  64. struct atomic_int size;
  65. struct shim_qstr host_uri;
  66. unsigned long atime;
  67. unsigned long mtime;
  68. unsigned long ctime;
  69. unsigned long nlink;
  70. };
  71. struct shim_file_handle {
  72. unsigned int version;
  73. struct shim_file_data* data;
  74. enum shim_file_type type;
  75. off_t size;
  76. off_t marker;
  77. enum { FILEBUF_MAP, FILEBUF_NONE } buf_type;
  78. size_t mapsize;
  79. off_t mapoffset;
  80. void* mapbuf;
  81. };
  82. #define FILE_HANDLE_DATA(hdl) ((hdl)->info.file.data)
  83. #define FILE_DENTRY_DATA(dent) ((struct shim_file_data*)(dent)->data)
  84. struct shim_dev_ops {
  85. /* open: provide a filename relative to the mount point and flags,
  86. modify the shim handle */
  87. int (*open)(struct shim_handle* hdl, const char* name, int flags);
  88. /* close: clean up the file state inside the handle */
  89. int (*close)(struct shim_handle* hdl);
  90. /* read: the content from the file opened as handle */
  91. ssize_t (*read)(struct shim_handle* hdl, void* buf, size_t count);
  92. /* write: the content from the file opened as handle */
  93. ssize_t (*write)(struct shim_handle* hdl, const void* buf, size_t count);
  94. /* flush: flush out user buffer */
  95. int (*flush)(struct shim_handle* hdl);
  96. /* seek: the content from the file opened as handle */
  97. off_t (*seek)(struct shim_handle* hdl, off_t offset, int wence);
  98. int (*truncate)(struct shim_handle* hdl, uint64_t len);
  99. int (*mode)(const char* name, mode_t* mode);
  100. /* stat, hstat: get status of the file */
  101. int (*stat)(const char* name, struct stat* buf);
  102. int (*hstat)(struct shim_handle* hdl, struct stat* buf);
  103. };
  104. struct shim_dev_handle {
  105. struct shim_dev_ops dev_ops;
  106. };
  107. struct shim_pipe_handle {
  108. #if USE_SIMPLE_PIPE == 1
  109. struct shim_handle* pair;
  110. #else
  111. IDTYPE pipeid;
  112. #endif
  113. };
  114. #define SOCK_STREAM 1
  115. #define SOCK_DGRAM 2
  116. #define SOCK_NONBLOCK 04000
  117. #define SOCK_CLOEXEC 02000000
  118. #define SOL_TCP 6
  119. #define PF_LOCAL 1
  120. #define PF_UNIX PF_LOCAL
  121. #define PF_FILE PF_LOCAL
  122. #define PF_INET 2
  123. #define PF_INET6 10
  124. #define AF_UNIX PF_UNIX
  125. #define AF_INET PF_INET
  126. #define AF_INET6 PF_INET6
  127. enum shim_sock_state {
  128. SOCK_CREATED,
  129. SOCK_BOUND,
  130. SOCK_CONNECTED,
  131. SOCK_BOUNDCONNECTED,
  132. SOCK_LISTENED,
  133. SOCK_ACCEPTED,
  134. SOCK_SHUTDOWN,
  135. };
  136. struct shim_unix_data {
  137. unsigned int pipeid;
  138. };
  139. struct shim_sock_handle {
  140. int domain;
  141. int sock_type;
  142. int protocol;
  143. int error;
  144. enum shim_sock_state sock_state;
  145. union shim_sock_addr {
  146. // INET addr
  147. struct {
  148. struct addr_inet {
  149. unsigned short port;
  150. unsigned short ext_port;
  151. union {
  152. struct in_addr v4;
  153. struct in6_addr v6;
  154. } addr;
  155. } bind, conn;
  156. } in;
  157. // UNIX addr
  158. struct addr_unix {
  159. struct shim_dentry* dentry;
  160. unsigned int pipeid;
  161. struct shim_unix_data* data;
  162. } un;
  163. } addr;
  164. struct shim_sock_option {
  165. struct shim_sock_option* next;
  166. int level;
  167. int optname;
  168. int optlen;
  169. char optval[];
  170. } * pending_options;
  171. };
  172. struct shim_dirent {
  173. struct shim_dirent* next;
  174. unsigned long ino; /* Inode number */
  175. unsigned char type;
  176. char name[]; /* File name (null-terminated) */
  177. };
  178. #define SHIM_DIRENT_SIZE offsetof(struct shim_dirent, name)
  179. #define SHIM_DIRENT_ALIGNMENT alignof(struct shim_dirent)
  180. /* Size of struct shim_dirent instance together with alignment,
  181. * which might be different depending on the length of the name field */
  182. #define SHIM_DIRENT_ALIGNED_SIZE(len) ALIGN_UP(SHIM_DIRENT_SIZE + (len), SHIM_DIRENT_ALIGNMENT)
  183. struct shim_dir_handle {
  184. int offset;
  185. struct shim_dentry* dotdot;
  186. struct shim_dentry* dot;
  187. struct shim_dentry** buf;
  188. struct shim_dentry** ptr;
  189. };
  190. struct shim_shm_handle {
  191. /* XXX: need to implement */
  192. void* __reserved;
  193. };
  194. struct msg_type;
  195. struct msg_item;
  196. struct msg_client;
  197. #define MAX_SYSV_CLIENTS 32
  198. DEFINE_LIST(shim_msg_handle);
  199. struct shim_msg_handle {
  200. unsigned long msqkey; /* msg queue key from user */
  201. IDTYPE msqid; /* msg queue identifier */
  202. bool owned; /* owned by current process */
  203. struct shim_ipc_info* owner;
  204. LEASETYPE lease;
  205. int perm; /* access permissions */
  206. bool deleted; /* marking the queue deleted */
  207. int nmsgs; /* number of msgs */
  208. int currentsize; /* current size in bytes */
  209. struct msg_qobj* queue;
  210. int queuesize;
  211. int queueused;
  212. struct msg_qobj* freed;
  213. PAL_HANDLE event; /* event for waiting */
  214. int ntypes;
  215. int maxtypes;
  216. struct msg_type* types;
  217. struct sysv_score scores[MAX_SYSV_CLIENTS];
  218. LIST_TYPE(shim_msg_handle) list;
  219. LIST_TYPE(shim_msg_handle) key_hlist;
  220. LIST_TYPE(shim_msg_handle) qid_hlist;
  221. };
  222. struct sem_objs;
  223. DEFINE_LIST(shim_sem_handle);
  224. struct shim_sem_handle {
  225. unsigned long semkey;
  226. IDTYPE semid;
  227. bool owned;
  228. struct shim_ipc_info* owner;
  229. LEASETYPE lease;
  230. int perm;
  231. bool deleted;
  232. PAL_HANDLE event;
  233. int nsems;
  234. struct sem_obj* sems;
  235. int nreqs;
  236. struct sysv_score scores[MAX_SYSV_CLIENTS];
  237. LISTP_TYPE(sem_ops) migrated;
  238. LIST_TYPE(shim_sem_handle) list;
  239. LIST_TYPE(shim_sem_handle) key_hlist;
  240. LIST_TYPE(shim_sem_handle) sid_hlist;
  241. };
  242. struct shim_str_data {
  243. REFTYPE ref_count;
  244. char* str;
  245. off_t len;
  246. size_t buf_size;
  247. bool dirty;
  248. int (*update)(struct shim_handle* hdl);
  249. int (*modify)(struct shim_handle* hdl);
  250. };
  251. struct shim_str_handle {
  252. struct shim_str_data* data; /* inode is stored in dentry, too.
  253. store pointer here for efficiency */
  254. char* ptr;
  255. };
  256. DEFINE_LIST(shim_epoll_item);
  257. DEFINE_LISTP(shim_epoll_item);
  258. struct shim_epoll_handle {
  259. int maxfds;
  260. int waiter_cnt;
  261. int pal_cnt;
  262. PAL_HANDLE* pal_handles;
  263. AEVENTTYPE event;
  264. LISTP_TYPE(shim_epoll_item) fds;
  265. };
  266. struct shim_mount;
  267. struct shim_qstr;
  268. struct shim_dentry;
  269. /* The epolls list links to the back field of the shim_epoll_item structure
  270. */
  271. struct shim_handle {
  272. enum shim_handle_type type;
  273. REFTYPE ref_count;
  274. char fs_type[8];
  275. struct shim_mount* fs;
  276. struct shim_qstr path;
  277. struct shim_dentry* dentry;
  278. /* If this handle is registered for any epoll handle, this list contains
  279. * a shim_epoll_item object in correspondence with the epoll handle. */
  280. LISTP_TYPE(shim_epoll_item) epolls;
  281. struct shim_qstr uri; /* URI representing this handle, it is not
  282. * necessary to be set. */
  283. PAL_HANDLE pal_handle;
  284. union {
  285. struct shim_file_handle file;
  286. struct shim_dev_handle dev;
  287. struct shim_pipe_handle pipe;
  288. struct shim_sock_handle sock;
  289. struct shim_shm_handle shm;
  290. struct shim_msg_handle msg;
  291. struct shim_sem_handle sem;
  292. struct shim_str_handle str;
  293. struct shim_epoll_handle epoll;
  294. } info;
  295. struct shim_dir_handle dir_info;
  296. int flags;
  297. int acc_mode;
  298. IDTYPE owner;
  299. struct shim_lock lock;
  300. };
  301. /* allocating / manage handle */
  302. struct shim_handle* get_new_handle(void);
  303. void flush_handle(struct shim_handle* hdl);
  304. void get_handle(struct shim_handle* hdl);
  305. void put_handle(struct shim_handle* hdl);
  306. /* file descriptor table */
  307. struct shim_fd_handle {
  308. FDTYPE vfd; /* virtual file descriptor */
  309. int flags; /* file descriptor flags, only FD_CLOEXEC */
  310. struct shim_handle* handle;
  311. };
  312. struct shim_handle_map {
  313. /* the top of created file descriptors */
  314. FDTYPE fd_size;
  315. FDTYPE fd_top;
  316. /* refrence count and lock */
  317. REFTYPE ref_count;
  318. struct shim_lock lock;
  319. /* An array of file descriptor belong to this mapping */
  320. struct shim_fd_handle** map;
  321. };
  322. /* allocating file descriptors */
  323. #define FD_NULL ((FDTYPE)-1)
  324. #define HANDLE_ALLOCATED(fd_handle) ((fd_handle) && (fd_handle)->vfd != FD_NULL)
  325. struct shim_handle* __get_fd_handle(FDTYPE fd, int* flags, struct shim_handle_map* map);
  326. struct shim_handle* get_fd_handle(FDTYPE fd, int* flags, struct shim_handle_map* map);
  327. /*!
  328. * \brief Assign new fd to a handle.
  329. *
  330. * \param hdl A handle to be mapped to the new fd.
  331. * \param flags Flags assigned to new shim_fd_handle.
  332. * \param handle_map Handle map to be used. If NULL is passed, current thread's handle map is used.
  333. *
  334. * Creates mapping for the given handle to a new file descriptor which is then returned.
  335. * Uses the lowest, non-negative available number for the new fd.
  336. */
  337. int set_new_fd_handle(struct shim_handle* hdl, int flags, struct shim_handle_map* map);
  338. int set_new_fd_handle_by_fd(FDTYPE fd, struct shim_handle* hdl, int flags,
  339. struct shim_handle_map* map);
  340. struct shim_handle* __detach_fd_handle(struct shim_fd_handle* fd, int* flags,
  341. struct shim_handle_map* map);
  342. struct shim_handle* detach_fd_handle(FDTYPE fd, int* flags, struct shim_handle_map* map);
  343. /* manage handle mapping */
  344. int dup_handle_map(struct shim_handle_map** new_map, struct shim_handle_map* old_map);
  345. int flush_handle_map(struct shim_handle_map* map);
  346. void get_handle_map(struct shim_handle_map* map);
  347. void put_handle_map(struct shim_handle_map* map);
  348. int walk_handle_map(int (*callback)(struct shim_fd_handle*, struct shim_handle_map*),
  349. struct shim_handle_map* map);
  350. int init_handle(void);
  351. int init_important_handles(void);
  352. off_t get_file_size(struct shim_handle* file);
  353. int do_handle_read(struct shim_handle* hdl, void* buf, int count);
  354. int do_handle_write(struct shim_handle* hdl, const void* buf, int count);
  355. #endif /* _SHIM_HANDLE_H_ */