Diff markup
001 001
002 002
003 003
004 004
005 005
006 006
007 007
008 008
009 009
010 010
011 011
012 012
013 013
014 014
015 015
016 016
017 017
018 018
019 #include "crt.h" 019 #include "crt.h"
020 #include "string.h" <<
021 #include "stdarg.h" <<
022 <<
023 #include "libc.h" 020 #include "libc.h"
024 !! 021 #include "stdarg.h"
025 void exit (int status) <<
026 { <<
027 _sos_exit(status); <<
028 } <<
029 <<
030 <<
031 pid_t fork(void) <<
032 { <<
033 return _sos_fork(); <<
034 } <<
035 <<
036 <<
037 int exec(const char *progname) <<
038 { <<
039 return _sos_exec(progname); <<
040 } <<
041 <<
042 <<
043 int sleep(unsigned int seconds) <<
044 { <<
045 return nanosleep(seconds, 0); <<
046 } <<
047 022
048 023
049 int nanosleep(unsigned long int sec, !! 024 void * fakemmap(void *start, size_t length, int prot , int flags,
050 unsigned long int nanosec) !! 025 const char *path, loff_t offset)
051 { 026 {
052 return _sos_nanosleep(sec, nanosec); !! 027
053 } !! 028 if (offset < 0)
054 !! 029 return NULL;
055 030
>> 031 if (0 != _sos_fakemmap(& start, length, prot, flags, path, offset))
>> 032 return NULL;
056 033
057 int munmap(void * start, size_t length) !! 034 return start;
058 { <<
059 return _sos_munmap(start, length); <<
060 } 035 }
061 036
062 037
063 void * mremap(void * old_addr, size_t old_len, 038 void * mremap(void * old_addr, size_t old_len,
064 size_t new_len, 039 size_t new_len,
065 unsigned long flags) 040 unsigned long flags)
066 { 041 {
067 void * new_uaddr = old_addr; 042 void * new_uaddr = old_addr;
068 if (0 != _sos_mresize(old_addr, old_len, & n 043 if (0 != _sos_mresize(old_addr, old_len, & new_uaddr, new_len, flags))
069 return NULL; 044 return NULL;
070 045
071 return new_uaddr; 046 return new_uaddr;
072 } 047 }
073 048
074 049
075 int mprotect(const void *addr, size_t len, int <<
076 { <<
077 return _sos_mprotect(addr, len, prot); <<
078 } <<
079 <<
080 <<
081 050
082 051
083 052
084 053
085 static void * kernel_heap_top = NULL; 054 static void * kernel_heap_top = NULL;
086 int brk(void *end_data_seg) 055 int brk(void *end_data_seg)
087 { 056 {
088 if (! end_data_seg) 057 if (! end_data_seg)
089 return -1; 058 return -1;
090 059
091 kernel_heap_top = _sos_brk(end_data_seg); 060 kernel_heap_top = _sos_brk(end_data_seg);
092 return 0; 061 return 0;
093 } 062 }
094 063
095 064
096 void *sbrk(ptrdiff_t increment) 065 void *sbrk(ptrdiff_t increment)
097 { 066 {
098 if (! kernel_heap_top) 067 if (! kernel_heap_top)
099 kernel_heap_top = _sos_brk(0); 068 kernel_heap_top = _sos_brk(0);
100 069
101 kernel_heap_top = _sos_brk(kernel_heap_top + 070 kernel_heap_top = _sos_brk(kernel_heap_top + increment);
102 return kernel_heap_top; 071 return kernel_heap_top;
103 } 072 }
104 073
105 074
106 void * calloc (size_t nmemb, size_t size) 075 void * calloc (size_t nmemb, size_t size)
107 { 076 {
108 return malloc(nmemb * size); 077 return malloc(nmemb * size);
109 } 078 }
110 079
111 080
112 081
113 082
114 083
115 084
116 085
117 static void * malloc_heap_top = NULL; 086 static void * malloc_heap_top = NULL;
118 void * malloc (size_t size) 087 void * malloc (size_t size)
119 { 088 {
120 void * retval; 089 void * retval;
121 090
122 if (size <= 0) 091 if (size <= 0)
123 return NULL; 092 return NULL;
124 093
125 094
126 size = ((size-1) & ~3) + 4; 095 size = ((size-1) & ~3) + 4;
127 096
128 if (! kernel_heap_top) 097 if (! kernel_heap_top)
129 kernel_heap_top = _sos_brk(0); 098 kernel_heap_top = _sos_brk(0);
130 099
131 if (! malloc_heap_top) 100 if (! malloc_heap_top)
132 malloc_heap_top = kernel_heap_top; 101 malloc_heap_top = kernel_heap_top;
133 102
134 retval = malloc_heap_top; 103 retval = malloc_heap_top;
135 malloc_heap_top += size; 104 malloc_heap_top += size;
136 105
137 _sos_brk(malloc_heap_top); 106 _sos_brk(malloc_heap_top);
138 return retval; 107 return retval;
139 } 108 }
140 109
141 110
142 void free(void *ptr) 111 void free(void *ptr)
143 { 112 {
144 113
145 } 114 }
146 115
147 116
148 <<
149 int mount(const char *source, const char *targ <<
150 const char *filesystemtype, unsigned <<
151 const char *data) <<
152 { <<
153 return _sos_mount(source, target, filesystem <<
154 } <<
155 <<
156 <<
157 int umount(const char *target) <<
158 { <<
159 return _sos_umount(target); <<
160 } <<
161 <<
162 <<
163 void sync(void) <<
164 { <<
165 return _sos_sync(); <<
166 } <<
167 <<
168 <<
169 int statvfs(const char *path, struct statvfs * <<
170 { <<
171 return _sos_statvfs(path, buf); <<
172 } <<
173 <<
174 <<
175 int open(const char *pathname, int flags, 117 int open(const char *pathname, int flags, ...)
176 { 118 {
177 va_list ap; 119 va_list ap;
178 unsigned int mode = 0; 120 unsigned int mode = 0;
179 121
180 va_start(ap, flags); 122 va_start(ap, flags);
181 if (flags & O_CREAT) 123 if (flags & O_CREAT)
182 mode = va_arg(ap, unsigned int); 124 mode = va_arg(ap, unsigned int);
183 va_end(ap); 125 va_end(ap);
184 126
185 return _sos_open(pathname, flags, mode); 127 return _sos_open(pathname, flags, mode);
186 } 128 }
187 129
188 130
189 int close(int fd) <<
190 { <<
191 return _sos_close(fd); <<
192 } <<
193 <<
194 <<
195 int read(int fd, char * buf, size_t len) 131 int read(int fd, char * buf, size_t len)
196 { 132 {
197 int retval = _sos_read(fd, buf, & len); 133 int retval = _sos_read(fd, buf, & len);
198 if (retval < 0) 134 if (retval < 0)
199 return retval; 135 return retval;
200 return len; 136 return len;
201 } 137 }
202 138
203 139
204 int write(int fd, const char * buf, size_t len 140 int write(int fd, const char * buf, size_t len)
205 { 141 {
206 int retval = _sos_write(fd, buf, & len); 142 int retval = _sos_write(fd, buf, & len);
207 if (retval < 0) 143 if (retval < 0)
208 return retval; 144 return retval;
209 return len; 145 return len;
210 } 146 }
211 147
212 148
213 off_t lseek(int fd, off_t offset, int whence) 149 off_t lseek(int fd, off_t offset, int whence)
214 { 150 {
215 loff_t result = offset; 151 loff_t result = offset;
216 int retval = _sos_seek64(fd, & result, whenc 152 int retval = _sos_seek64(fd, & result, whence);
217 if (retval < 0) 153 if (retval < 0)
218 return retval; 154 return retval;
219 return result; 155 return result;
220 } 156 }
221 157
222 158
223 loff_t lseek64(int fd, loff_t offset, int when 159 loff_t lseek64(int fd, loff_t offset, int whence)
224 { 160 {
225 loff_t result = offset; 161 loff_t result = offset;
226 int retval = _sos_seek64(fd, & result, whenc 162 int retval = _sos_seek64(fd, & result, whence);
227 if (retval < 0) 163 if (retval < 0)
228 return retval; 164 return retval;
229 return result; 165 return result;
230 } 166 }
231 167
232 168
233 void * mmap(void *start, size_t length, int pr 169 void * mmap(void *start, size_t length, int prot , int flags,
234 int fd, loff_t offset) 170 int fd, loff_t offset)
235 { 171 {
236 172
237 if (offset < 0) 173 if (offset < 0)
238 return NULL; 174 return NULL;
239 175
240 if (0 != _sos_fmmap(& start, length, prot, f 176 if (0 != _sos_fmmap(& start, length, prot, flags, fd, offset))
241 return NULL; 177 return NULL;
242 178
243 return start; 179 return start;
244 } 180 }
245 181
246 182
247 int ftruncate(int fd, off_t length) 183 int ftruncate(int fd, off_t length)
248 { 184 {
249 return _sos_ftruncate64(fd, length); 185 return _sos_ftruncate64(fd, length);
250 } 186 }
251 187
252 188
253 int ftruncate64(int fd, loff_t length) <<
254 { <<
255 return _sos_ftruncate64(fd, length); <<
256 } <<
257 <<
258 <<
259 int fcntl(int fd, int cmd, int arg) <<
260 { <<
261 return _sos_fcntl(fd, cmd, arg); <<
262 } <<
263 <<
264 <<
265 int ioctl(int fd, int cmd, int arg) <<
266 { <<
267 return _sos_ioctl(fd, cmd, arg); <<
268 } <<
269 <<
270 <<
271 int creat(const char *pathname, mode_t mode) <<
272 { <<
273 return _sos_creat(pathname, mode); <<
274 } <<
275 <<
276 int link (const char *oldpath, const char *new <<
277 { <<
278 return _sos_link(oldpath, newpath); <<
279 } <<
280 <<
281 <<
282 int unlink(const char *pathname) <<
283 { <<
284 return _sos_unlink(pathname); <<
285 } <<
286 <<
287 <<
288 int rename(const char *oldpath, const char *ne <<
289 { <<
290 return _sos_rename(oldpath, newpath); <<
291 } <<
292 <<
293 <<
294 int symlink(const char *target, const char *pa <<
295 { <<
296 return _sos_symlink(target, path); <<
297 } <<
298 <<
299 <<
300 int mknod(const char *pathname, mode_t mode, <<
301 int type, <<
302 unsigned int major, unsigned minor) <<
303 { <<
304 if (type == S_IFREG) <<
305 return creat(pathname, mode); <<
306 <<
307 return _sos_mknod(pathname, mode, type, <<
308 major, minor); <<
309 } <<
310 <<
311 <<
312 int mkdir(const char *pathname, mode_t mode) <<
313 { <<
314 return _sos_mkdir(pathname, mode); <<
315 } <<
316 <<
317 <<
318 int rmdir(const char *pathname) <<
319 { <<
320 return _sos_rmdir(pathname); <<
321 } <<
322 <<
323 <<
324 int chmod(const char *path, mode_t mode) <<
325 { <<
326 return _sos_chmod(path, mode); <<
327 } <<
328 <<
329 <<
330 struct sos_DIR_struct 189 struct sos_DIR_struct
331 { 190 {
332 int fd; 191 int fd;
333 struct dirent dirent; 192 struct dirent dirent;
334 }; 193 };
335 194
336 195
337 DIR *opendir(const char *name) 196 DIR *opendir(const char *name)
338 { 197 {
339 DIR * result = malloc(sizeof(DIR)); 198 DIR * result = malloc(sizeof(DIR));
340 if (! result) 199 if (! result)
341 return NULL; 200 return NULL;
342 201
343 result->fd = _sos_open(name, O_DIRECTORY | O 202 result->fd = _sos_open(name, O_DIRECTORY | O_RDONLY, 0);
344 return result; 203 return result;
345 } 204 }
346 205
347 206
348 int dirfd(const DIR * dir) 207 int dirfd(const DIR * dir)
349 { 208 {
350 if (dir) 209 if (dir)
351 return dir->fd; 210 return dir->fd;
352 return -1; 211 return -1;
353 } 212 }
354 213
355 214
356 struct dirent *readdir(DIR *dir) 215 struct dirent *readdir(DIR *dir)
357 { 216 {
358 int retval = _sos_readdir(dir->fd, & dir->di 217 int retval = _sos_readdir(dir->fd, & dir->dirent);
359 if (retval < 0) 218 if (retval < 0)
360 return NULL; 219 return NULL;
361 return & dir->dirent; 220 return & dir->dirent;
362 } 221 }
363 222
364 223
365 int closedir(DIR *dir) 224 int closedir(DIR *dir)
366 { 225 {
367 close(dir->fd); 226 close(dir->fd);
368 free(dir); 227 free(dir);
369 return 0; 228 return 0;
370 } 229 }
371 230
372 231
373 int stat(const char *file_name, struct stat *b 232 int stat(const char *file_name, struct stat *buf)
374 { 233 {
375 return _sos_stat(file_name, TRUE, buf); 234 return _sos_stat(file_name, TRUE, buf);
376 } 235 }
377 236
378 237
379 int lstat(const char *file_name, struct stat * 238 int lstat(const char *file_name, struct stat *buf)
380 { 239 {
381 return _sos_stat(file_name, FALSE, buf); 240 return _sos_stat(file_name, FALSE, buf);
382 } 241 }
383 <<
384 <<
385 int chroot(const char *path) <<
386 { <<
387 return _sos_chroot(path); <<
388 } <<
389 <<
390 <<
391 int chdir(const char *path) <<
392 { <<
393 return _sos_chdir(path); <<
394 } <<
395 <<
396 int fchdir(int fd) <<
397 { <<
398 return _sos_fchdir(fd); <<
399 } <<
400 <<
401 <<
402 <<
403 int printf (const char *format, ...) <<
404 { <<
405 char buff[4096]; <<
406 va_list ap; <<
407 <<
408 va_start(ap, format); <<
409 vsnprintf(buff, sizeof(buff), format, ap); <<
410 va_end(ap); <<
411 <<
412 return write (1, buff, strlen(buff)); <<
413 } <<
414 <<
415 <<