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 "libc.h" !! 020 #include "string.h"
021 #include "stdarg.h" 021 #include "stdarg.h"
022 022
>> 023 #include "libc.h"
023 024
024 void * fakemmap(void *start, size_t length, in !! 025 void exit (int status)
025 const char *path, loff_t offse <<
026 { 026 {
027 !! 027 _sos_exit(status);
028 if (offset < 0) !! 028 }
029 return NULL; <<
030 029
031 if (0 != _sos_fakemmap(& start, length, prot <<
032 return NULL; <<
033 030
034 return start; !! 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
>> 048
>> 049 int nanosleep(unsigned long int sec,
>> 050 unsigned long int nanosec)
>> 051 {
>> 052 return _sos_nanosleep(sec, nanosec);
>> 053 }
>> 054
>> 055
>> 056
>> 057 int munmap(void * start, size_t length)
>> 058 {
>> 059 return _sos_munmap(start, length);
035 } 060 }
036 061
037 062
038 void * mremap(void * old_addr, size_t old_len, 063 void * mremap(void * old_addr, size_t old_len,
039 size_t new_len, 064 size_t new_len,
040 unsigned long flags) 065 unsigned long flags)
041 { 066 {
042 void * new_uaddr = old_addr; 067 void * new_uaddr = old_addr;
043 if (0 != _sos_mresize(old_addr, old_len, & n 068 if (0 != _sos_mresize(old_addr, old_len, & new_uaddr, new_len, flags))
044 return NULL; 069 return NULL;
045 070
046 return new_uaddr; 071 return new_uaddr;
047 } 072 }
048 073
049 074
>> 075 int mprotect(const void *addr, size_t len, int prot)
>> 076 {
>> 077 return _sos_mprotect(addr, len, prot);
>> 078 }
>> 079
>> 080
050 081
051 082
052 083
053 084
054 static void * kernel_heap_top = NULL; 085 static void * kernel_heap_top = NULL;
055 int brk(void *end_data_seg) 086 int brk(void *end_data_seg)
056 { 087 {
057 if (! end_data_seg) 088 if (! end_data_seg)
058 return -1; 089 return -1;
059 090
060 kernel_heap_top = _sos_brk(end_data_seg); 091 kernel_heap_top = _sos_brk(end_data_seg);
061 return 0; 092 return 0;
062 } 093 }
063 094
064 095
065 void *sbrk(ptrdiff_t increment) 096 void *sbrk(ptrdiff_t increment)
066 { 097 {
067 if (! kernel_heap_top) 098 if (! kernel_heap_top)
068 kernel_heap_top = _sos_brk(0); 099 kernel_heap_top = _sos_brk(0);
069 100
070 kernel_heap_top = _sos_brk(kernel_heap_top + 101 kernel_heap_top = _sos_brk(kernel_heap_top + increment);
071 return kernel_heap_top; 102 return kernel_heap_top;
072 } 103 }
073 104
074 105
075 void * calloc (size_t nmemb, size_t size) 106 void * calloc (size_t nmemb, size_t size)
076 { 107 {
077 return malloc(nmemb * size); 108 return malloc(nmemb * size);
078 } 109 }
079 110
080 111
081 112
082 113
083 114
084 115
085 116
086 static void * malloc_heap_top = NULL; 117 static void * malloc_heap_top = NULL;
087 void * malloc (size_t size) 118 void * malloc (size_t size)
088 { 119 {
089 void * retval; 120 void * retval;
090 121
091 if (size <= 0) 122 if (size <= 0)
092 return NULL; 123 return NULL;
093 124
094 125
095 size = ((size-1) & ~3) + 4; 126 size = ((size-1) & ~3) + 4;
096 127
097 if (! kernel_heap_top) 128 if (! kernel_heap_top)
098 kernel_heap_top = _sos_brk(0); 129 kernel_heap_top = _sos_brk(0);
099 130
100 if (! malloc_heap_top) 131 if (! malloc_heap_top)
101 malloc_heap_top = kernel_heap_top; 132 malloc_heap_top = kernel_heap_top;
102 133
103 retval = malloc_heap_top; 134 retval = malloc_heap_top;
104 malloc_heap_top += size; 135 malloc_heap_top += size;
105 136
106 _sos_brk(malloc_heap_top); 137 _sos_brk(malloc_heap_top);
107 return retval; 138 return retval;
108 } 139 }
109 140
110 141
111 void free(void *ptr) 142 void free(void *ptr)
112 { 143 {
113 144
114 } 145 }
115 146
116 147
>> 148
>> 149 int mount(const char *source, const char *target,
>> 150 const char *filesystemtype, unsigned long mountflags,
>> 151 const char *data)
>> 152 {
>> 153 return _sos_mount(source, target, filesystemtype, mountflags, data);
>> 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 *buf)
>> 170 {
>> 171 return _sos_statvfs(path, buf);
>> 172 }
>> 173
>> 174
117 int open(const char *pathname, int flags, 175 int open(const char *pathname, int flags, ...)
118 { 176 {
119 va_list ap; 177 va_list ap;
120 unsigned int mode = 0; 178 unsigned int mode = 0;
121 179
122 va_start(ap, flags); 180 va_start(ap, flags);
123 if (flags & O_CREAT) 181 if (flags & O_CREAT)
124 mode = va_arg(ap, unsigned int); 182 mode = va_arg(ap, unsigned int);
125 va_end(ap); 183 va_end(ap);
126 184
127 return _sos_open(pathname, flags, mode); 185 return _sos_open(pathname, flags, mode);
128 } 186 }
129 187
130 188
>> 189 int close(int fd)
>> 190 {
>> 191 return _sos_close(fd);
>> 192 }
>> 193
>> 194
131 int read(int fd, char * buf, size_t len) 195 int read(int fd, char * buf, size_t len)
132 { 196 {
133 int retval = _sos_read(fd, buf, & len); 197 int retval = _sos_read(fd, buf, & len);
134 if (retval < 0) 198 if (retval < 0)
135 return retval; 199 return retval;
136 return len; 200 return len;
137 } 201 }
138 202
139 203
140 int write(int fd, const char * buf, size_t len 204 int write(int fd, const char * buf, size_t len)
141 { 205 {
142 int retval = _sos_write(fd, buf, & len); 206 int retval = _sos_write(fd, buf, & len);
143 if (retval < 0) 207 if (retval < 0)
144 return retval; 208 return retval;
145 return len; 209 return len;
146 } 210 }
147 211
148 212
149 off_t lseek(int fd, off_t offset, int whence) 213 off_t lseek(int fd, off_t offset, int whence)
150 { 214 {
151 loff_t result = offset; 215 loff_t result = offset;
152 int retval = _sos_seek64(fd, & result, whenc 216 int retval = _sos_seek64(fd, & result, whence);
153 if (retval < 0) 217 if (retval < 0)
154 return retval; 218 return retval;
155 return result; 219 return result;
156 } 220 }
157 221
158 222
159 loff_t lseek64(int fd, loff_t offset, int when 223 loff_t lseek64(int fd, loff_t offset, int whence)
160 { 224 {
161 loff_t result = offset; 225 loff_t result = offset;
162 int retval = _sos_seek64(fd, & result, whenc 226 int retval = _sos_seek64(fd, & result, whence);
163 if (retval < 0) 227 if (retval < 0)
164 return retval; 228 return retval;
165 return result; 229 return result;
166 } 230 }
167 231
168 232
169 void * mmap(void *start, size_t length, int pr 233 void * mmap(void *start, size_t length, int prot , int flags,
170 int fd, loff_t offset) 234 int fd, loff_t offset)
171 { 235 {
172 236
173 if (offset < 0) 237 if (offset < 0)
174 return NULL; 238 return NULL;
175 239
176 if (0 != _sos_fmmap(& start, length, prot, f 240 if (0 != _sos_fmmap(& start, length, prot, flags, fd, offset))
177 return NULL; 241 return NULL;
178 242
179 return start; 243 return start;
180 } 244 }
181 245
182 246
183 int ftruncate(int fd, off_t length) 247 int ftruncate(int fd, off_t length)
184 { 248 {
185 return _sos_ftruncate64(fd, length); 249 return _sos_ftruncate64(fd, length);
186 } 250 }
187 251
188 252
>> 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 *newpath)
>> 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 *newpath)
>> 289 {
>> 290 return _sos_rename(oldpath, newpath);
>> 291 }
>> 292
>> 293
>> 294 int symlink(const char *target, const char *path)
>> 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
189 struct sos_DIR_struct 330 struct sos_DIR_struct
190 { 331 {
191 int fd; 332 int fd;
192 struct dirent dirent; 333 struct dirent dirent;
193 }; 334 };
194 335
195 336
196 DIR *opendir(const char *name) 337 DIR *opendir(const char *name)
197 { 338 {
198 DIR * result = malloc(sizeof(DIR)); 339 DIR * result = malloc(sizeof(DIR));
199 if (! result) 340 if (! result)
200 return NULL; 341 return NULL;
201 342
202 result->fd = _sos_open(name, O_DIRECTORY | O 343 result->fd = _sos_open(name, O_DIRECTORY | O_RDONLY, 0);
203 return result; 344 return result;
204 } 345 }
205 346
206 347
207 int dirfd(const DIR * dir) 348 int dirfd(const DIR * dir)
208 { 349 {
209 if (dir) 350 if (dir)
210 return dir->fd; 351 return dir->fd;
211 return -1; 352 return -1;
212 } 353 }
213 354
214 355
215 struct dirent *readdir(DIR *dir) 356 struct dirent *readdir(DIR *dir)
216 { 357 {
217 int retval = _sos_readdir(dir->fd, & dir->di 358 int retval = _sos_readdir(dir->fd, & dir->dirent);
218 if (retval < 0) 359 if (retval < 0)
219 return NULL; 360 return NULL;
220 return & dir->dirent; 361 return & dir->dirent;
221 } 362 }
222 363
223 364
224 int closedir(DIR *dir) 365 int closedir(DIR *dir)
225 { 366 {
226 close(dir->fd); 367 close(dir->fd);
227 free(dir); 368 free(dir);
228 return 0; 369 return 0;
229 } 370 }
230 371
231 372
232 int stat(const char *file_name, struct stat *b 373 int stat(const char *file_name, struct stat *buf)
233 { 374 {
234 return _sos_stat(file_name, TRUE, buf); 375 return _sos_stat(file_name, TRUE, buf);
235 } 376 }
236 377
237 378
238 int lstat(const char *file_name, struct stat * 379 int lstat(const char *file_name, struct stat *buf)
239 { 380 {
240 return _sos_stat(file_name, FALSE, buf); 381 return _sos_stat(file_name, FALSE, buf);
241 } 382 }
>> 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