Merge branch 'net-dev'. See body of commit for details.
[akaros.git] / user / parlib / inc / newlib_backend.h
1 /* See COPYRIGHT for copyright information. */
2 /* Kevin Klues <klueska@cs.berkeley.edu>        */
3
4 #ifndef _NEWLIB_LIBC_WRAPPERS_H_
5 #define _NEWLIB_LIBC_WRAPPERS_H_
6
7 #include <errno.h>
8 #include <sys/stat.h>
9
10 #define OPEN_ID         0
11 #define CLOSE_ID        1
12 #define READ_ID         2
13 #define WRITE_ID        3
14 #define LINK_ID         4
15 #define UNLINK_ID       5
16 #define LSEEK_ID        6
17 #define FSTAT_ID        7
18 #define ISATTY_ID       8
19 #define STAT_ID         9
20 #define NUM_CALLS       10
21
22 #define debug_in_out(...) // debug(__VA_ARGS__)  
23 #define debug_write_check(fmt, ...)  //debug(fmt, __VA_ARGS__)
24
25 typedef uint32_t syscall_id_t;
26
27 // ALL STRUCTS MUST BE PADDED TO THE SAME SIZE.
28 // Basically, to make IVY annotation possible with as few TC's as possible
29 // We do some ugly things with unions, which results in us needing this padding
30 typedef struct open_subheader {
31         uint32_t flags;
32         uint32_t mode;
33         uint32_t len;
34         char buf[0];
35 } open_subheader_t;
36
37 typedef struct close_subheader {
38         uint32_t fd;
39         uint32_t FILL1;
40         uint32_t FILL2;
41 } close_subheader_t;
42
43 typedef struct read_subheader {
44         uint32_t fd;
45         uint32_t len;
46         uint32_t FILL1;
47 } read_subheader_t;
48
49 typedef struct write_subheader {
50         uint32_t fd;
51         uint32_t len;
52         uint32_t FILL1;
53         char buf[0];
54 } write_subheader_t;
55
56 typedef struct lseek_subheader {
57         uint32_t fd;
58         uint32_t ptr;
59         uint32_t dir;
60 } lseek_subheader_t;
61
62 typedef struct isatty_subheader {
63         uint32_t fd;
64         uint32_t FILL1;
65         uint32_t FILL2;
66 } isatty_subheader_t;
67
68 typedef struct link_subheader {
69         uint32_t old_len;
70         uint32_t new_len;
71         uint32_t FILL1;
72         char buf[0];
73 } link_subheader_t;
74
75 typedef struct unlink_subheader {
76         uint32_t len;
77         uint32_t FILL1;
78         uint32_t FILL2;
79         char buf[0];
80 } unlink_subheader_t;
81
82 typedef struct fstat_subheader {
83         uint32_t fd;
84         uint32_t FILL1;
85         uint32_t FILL2;
86 } fstat_subheader_t;
87
88 typedef struct stat_subheader {
89         uint32_t len;
90         uint32_t FILL1;
91         uint32_t FILL2;
92         char buf[0];
93 } stat_subheader_t;
94
95 typedef struct backend_msg {
96         syscall_id_t id;
97         union {
98                 open_subheader_t open;
99                 close_subheader_t close;
100                 read_subheader_t read;
101                 write_subheader_t write;
102                 lseek_subheader_t lseek;
103                 isatty_subheader_t isatty;
104                 link_subheader_t link;
105                 unlink_subheader_t unlink;
106                 fstat_subheader_t fstat;
107                 stat_subheader_t stat;  
108         };
109 } msg_t;
110
111 typedef struct response {
112         int32_t ret;
113         uint32_t err;
114         struct stat st;
115         char buf[0];
116 } response_t;
117
118
119 // New errno we want to define if a channel error occurs
120 // Not yet fully implimented
121 #define ECHANNEL -999
122
123 // Value to send across the channel as a function return value in the event of server side termination
124 // Note yet fully implimented
125 #define CONNECTION_TERMINATED -2
126
127 // Macros for the read_from_channel function
128 #define PEEK    1
129 #define NO_PEEK 0
130
131
132 /* Read len bytes from the given channel to the buffer.
133  * If peek is NO_PEEK, will wait indefinitely until that much data is read.
134  * If peek is PEEK, if no data is available, will return immediately.
135  *              However once some data is available,
136  *                      will block until the entire amount is available.
137  */
138 int read_from_channel(char * buf, int len, int peek);
139
140 int read_response_from_channel(response_t *response);
141 int read_buffer_from_channel(char *buf, int len);
142
143
144 /* send_message()
145  * Write the message defined in buffer out across the channel, and wait for a response.
146  * Caller is responsible for management of both the buffer passed in and the buffer ptr returned.
147  */
148 response_t *send_message(msg_t *msg, int len);
149
150 /* write_to_channel()
151  * Send a message out over the channel, defined by msg, of length len
152  */
153 int write_to_channel(msg_t *msg, int len);
154
155 #endif //_NEWLIB_LIBC_WRAPPERS_H_
156