Navigation
- Accueil
- Présentation :
- FAQ
- Bugs et errata
- Contributions de lecteurs
- Téléchargements
- LXR (référencement des sources)
- Mailing-list
- Liens et Projets reliés
Site hébergé par :
Site hébergé par :
|
[ source navigation ] [ diff markup ] [ identifier search ] [ general search ] |
|||
|
||||
001 /* Copyright (C) 2005 David Decotigny 001 /* Copyright (C) 2005 David Decotigny 002 002 003 This program is free software; you can redi 003 This program is free software; you can redistribute it and/or 004 modify it under the terms of the GNU Genera 004 modify it under the terms of the GNU General Public License 005 as published by the Free Software Foundatio 005 as published by the Free Software Foundation; either version 2 006 of the License, or (at your option) any lat 006 of the License, or (at your option) any later version. 007 007 008 This program is distributed in the hope tha 008 This program is distributed in the hope that it will be useful, 009 but WITHOUT ANY WARRANTY; without even the 009 but WITHOUT ANY WARRANTY; without even the implied warranty of 010 MERCHANTABILITY or FITNESS FOR A PARTICULAR 010 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 011 GNU General Public License for more details 011 GNU General Public License for more details. 012 012 013 You should have received a copy of the GNU 013 You should have received a copy of the GNU General Public License 014 along with this program; if not, write to t 014 along with this program; if not, write to the Free Software 015 Foundation, Inc., 59 Temple Place - Suite 3 015 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 016 USA. 016 USA. 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 /* At kernel side, offset is considered positive */ 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 int msync(void *start, size_t length, int flag << 082 { << 083 return _sos_msync(start, length, flags); << 084 } << 085 << 086 << 087 /** 050 /** 088 * The presence of this global variable withou 051 * The presence of this global variable without any protected access 089 * to it explains why the "brk/sbrk" functions 052 * to it explains why the "brk/sbrk" functions below are MT-unsafe ! 090 */ 053 */ 091 static void * kernel_heap_top = NULL; 054 static void * kernel_heap_top = NULL; 092 int brk(void *end_data_seg) 055 int brk(void *end_data_seg) 093 { 056 { 094 if (! end_data_seg) 057 if (! end_data_seg) 095 return -1; 058 return -1; 096 059 097 kernel_heap_top = _sos_brk(end_data_seg); 060 kernel_heap_top = _sos_brk(end_data_seg); 098 return 0; 061 return 0; 099 } 062 } 100 063 101 064 102 void *sbrk(ptrdiff_t increment) 065 void *sbrk(ptrdiff_t increment) 103 { 066 { 104 if (! kernel_heap_top) 067 if (! kernel_heap_top) 105 kernel_heap_top = _sos_brk(0); 068 kernel_heap_top = _sos_brk(0); 106 069 107 kernel_heap_top = _sos_brk(kernel_heap_top + 070 kernel_heap_top = _sos_brk(kernel_heap_top + increment); 108 return kernel_heap_top; 071 return kernel_heap_top; 109 } 072 } 110 073 111 074 112 void * calloc (size_t nmemb, size_t size) 075 void * calloc (size_t nmemb, size_t size) 113 { 076 { 114 return malloc(nmemb * size); 077 return malloc(nmemb * size); 115 } 078 } 116 079 117 080 118 /** 081 /** 119 * The presence of this global variable withou 082 * The presence of this global variable without any protected access 120 * to it explains why the "malloc/calloc" func 083 * to it explains why the "malloc/calloc" functions below are 121 * MT-unsafe ! 084 * MT-unsafe ! 122 */ 085 */ 123 static void * malloc_heap_top = NULL; 086 static void * malloc_heap_top = NULL; 124 void * malloc (size_t size) 087 void * malloc (size_t size) 125 { 088 { 126 void * retval; 089 void * retval; 127 090 128 if (size <= 0) 091 if (size <= 0) 129 return NULL; 092 return NULL; 130 093 131 /* Align on a 4B boundary */ 094 /* Align on a 4B boundary */ 132 size = ((size-1) & ~3) + 4; 095 size = ((size-1) & ~3) + 4; 133 096 134 if (! kernel_heap_top) 097 if (! kernel_heap_top) 135 kernel_heap_top = _sos_brk(0); 098 kernel_heap_top = _sos_brk(0); 136 099 137 if (! malloc_heap_top) 100 if (! malloc_heap_top) 138 malloc_heap_top = kernel_heap_top; 101 malloc_heap_top = kernel_heap_top; 139 102 140 retval = malloc_heap_top; 103 retval = malloc_heap_top; 141 malloc_heap_top += size; 104 malloc_heap_top += size; 142 105 143 _sos_brk(malloc_heap_top); 106 _sos_brk(malloc_heap_top); 144 return retval; 107 return retval; 145 } 108 } 146 109 147 110 148 void free(void *ptr) 111 void free(void *ptr) 149 { 112 { 150 // bochs_printf("Free ignored (not implemen 113 // bochs_printf("Free ignored (not implemented yet)\n"); 151 } 114 } 152 115 153 116 154 << 155 int mount(const char *source, const char *targ << 156 const char *filesystemtype, unsigned << 157 const char *data) << 158 { << 159 return _sos_mount(source, target, filesystem << 160 } << 161 << 162 << 163 int umount(const char *target) << 164 { << 165 return _sos_umount(target); << 166 } << 167 << 168 << 169 void sync(void) << 170 { << 171 return _sos_sync(); << 172 } << 173 << 174 << 175 int statvfs(const char *path, struct statvfs * << 176 { << 177 return _sos_statvfs(path, buf); << 178 } << 179 << 180 << 181 int open(const char *pathname, int flags, /* m 117 int open(const char *pathname, int flags, /* mode_t mode */...) 182 { 118 { 183 va_list ap; 119 va_list ap; 184 unsigned int mode = 0; 120 unsigned int mode = 0; 185 121 186 va_start(ap, flags); 122 va_start(ap, flags); 187 if (flags & O_CREAT) 123 if (flags & O_CREAT) 188 mode = va_arg(ap, unsigned int); 124 mode = va_arg(ap, unsigned int); 189 va_end(ap); 125 va_end(ap); 190 126 191 return _sos_open(pathname, flags, mode); 127 return _sos_open(pathname, flags, mode); 192 } 128 } 193 129 194 130 195 int close(int fd) << 196 { << 197 return _sos_close(fd); << 198 } << 199 << 200 << 201 int read(int fd, char * buf, size_t len) 131 int read(int fd, char * buf, size_t len) 202 { 132 { 203 int retval = _sos_read(fd, buf, & len); 133 int retval = _sos_read(fd, buf, & len); 204 if (retval < 0) 134 if (retval < 0) 205 return retval; 135 return retval; 206 return len; 136 return len; 207 } 137 } 208 138 209 139 210 int write(int fd, const char * buf, size_t len 140 int write(int fd, const char * buf, size_t len) 211 { 141 { 212 int retval = _sos_write(fd, buf, & len); 142 int retval = _sos_write(fd, buf, & len); 213 if (retval < 0) 143 if (retval < 0) 214 return retval; 144 return retval; 215 return len; 145 return len; 216 } 146 } 217 147 218 148 219 off_t lseek(int fd, off_t offset, int whence) 149 off_t lseek(int fd, off_t offset, int whence) 220 { 150 { 221 loff_t result = offset; 151 loff_t result = offset; 222 int retval = _sos_seek64(fd, & result, whenc 152 int retval = _sos_seek64(fd, & result, whence); 223 if (retval < 0) 153 if (retval < 0) 224 return retval; 154 return retval; 225 return result; 155 return result; 226 } 156 } 227 157 228 158 229 loff_t lseek64(int fd, loff_t offset, int when 159 loff_t lseek64(int fd, loff_t offset, int whence) 230 { 160 { 231 loff_t result = offset; 161 loff_t result = offset; 232 int retval = _sos_seek64(fd, & result, whenc 162 int retval = _sos_seek64(fd, & result, whence); 233 if (retval < 0) 163 if (retval < 0) 234 return retval; 164 return retval; 235 return result; 165 return result; 236 } 166 } 237 167 238 168 239 void * mmap(void *start, size_t length, int pr 169 void * mmap(void *start, size_t length, int prot , int flags, 240 int fd, loff_t offset) 170 int fd, loff_t offset) 241 { 171 { 242 /* At kernel side, offset is considered posi 172 /* At kernel side, offset is considered positive */ 243 if (offset < 0) 173 if (offset < 0) 244 return NULL; 174 return NULL; 245 175 246 if (0 != _sos_fmmap(& start, length, prot, f 176 if (0 != _sos_fmmap(& start, length, prot, flags, fd, offset)) 247 return NULL; 177 return NULL; 248 178 249 return start; 179 return start; 250 } 180 } 251 181 252 182 253 int ftruncate(int fd, off_t length) 183 int ftruncate(int fd, off_t length) 254 { 184 { 255 return _sos_ftruncate64(fd, length); 185 return _sos_ftruncate64(fd, length); 256 } 186 } 257 187 258 188 259 int ftruncate64(int fd, loff_t length) << 260 { << 261 return _sos_ftruncate64(fd, length); << 262 } << 263 << 264 << 265 int fcntl(int fd, int cmd, int arg) << 266 { << 267 return _sos_fcntl(fd, cmd, arg); << 268 } << 269 << 270 << 271 int ioctl(int fd, int cmd, int arg) << 272 { << 273 return _sos_ioctl(fd, cmd, arg); << 274 } << 275 << 276 << 277 int creat(const char *pathname, mode_t mode) << 278 { << 279 return _sos_creat(pathname, mode); << 280 } << 281 << 282 int link (const char *oldpath, const char *new << 283 { << 284 return _sos_link(oldpath, newpath); << 285 } << 286 << 287 << 288 int unlink(const char *pathname) << 289 { << 290 return _sos_unlink(pathname); << 291 } << 292 << 293 << 294 int rename(const char *oldpath, const char *ne << 295 { << 296 return _sos_rename(oldpath, newpath); << 297 } << 298 << 299 << 300 int symlink(const char *target, const char *pa << 301 { << 302 return _sos_symlink(target, path); << 303 } << 304 << 305 << 306 int mknod(const char *pathname, mode_t mode, << 307 int type, << 308 unsigned int major, unsigned minor) << 309 { << 310 if (type == S_IFREG) << 311 return creat(pathname, mode); << 312 << 313 return _sos_mknod(pathname, mode, type, << 314 major, minor); << 315 } << 316 << 317 << 318 int mkdir(const char *pathname, mode_t mode) << 319 { << 320 return _sos_mkdir(pathname, mode); << 321 } << 322 << 323 << 324 int rmdir(const char *pathname) << 325 { << 326 return _sos_rmdir(pathname); << 327 } << 328 << 329 << 330 int chmod(const char *path, mode_t mode) << 331 { << 332 return _sos_chmod(path, mode); << 333 } << 334 << 335 << 336 struct sos_DIR_struct 189 struct sos_DIR_struct 337 { 190 { 338 int fd; 191 int fd; 339 struct dirent dirent; 192 struct dirent dirent; 340 }; 193 }; 341 194 342 195 343 DIR *opendir(const char *name) 196 DIR *opendir(const char *name) 344 { 197 { 345 DIR * result = malloc(sizeof(DIR)); 198 DIR * result = malloc(sizeof(DIR)); 346 if (! result) 199 if (! result) 347 return NULL; 200 return NULL; 348 201 349 result->fd = _sos_open(name, O_DIRECTORY | O 202 result->fd = _sos_open(name, O_DIRECTORY | O_RDONLY, 0); 350 return result; 203 return result; 351 } 204 } 352 205 353 206 354 int dirfd(const DIR * dir) 207 int dirfd(const DIR * dir) 355 { 208 { 356 if (dir) 209 if (dir) 357 return dir->fd; 210 return dir->fd; 358 return -1; 211 return -1; 359 } 212 } 360 213 361 214 362 struct dirent *readdir(DIR *dir) 215 struct dirent *readdir(DIR *dir) 363 { 216 { 364 int retval = _sos_readdir(dir->fd, & dir->di 217 int retval = _sos_readdir(dir->fd, & dir->dirent); 365 if (retval < 0) 218 if (retval < 0) 366 return NULL; 219 return NULL; 367 return & dir->dirent; 220 return & dir->dirent; 368 } 221 } 369 222 370 223 371 int closedir(DIR *dir) 224 int closedir(DIR *dir) 372 { 225 { 373 close(dir->fd); 226 close(dir->fd); 374 free(dir); 227 free(dir); 375 return 0; 228 return 0; 376 } 229 } 377 230 378 231 379 int stat(const char *file_name, struct stat *b 232 int stat(const char *file_name, struct stat *buf) 380 { 233 { 381 return _sos_stat(file_name, TRUE, buf); 234 return _sos_stat(file_name, TRUE, buf); 382 } 235 } 383 236 384 237 385 int lstat(const char *file_name, struct stat * 238 int lstat(const char *file_name, struct stat *buf) 386 { 239 { 387 return _sos_stat(file_name, FALSE, buf); 240 return _sos_stat(file_name, FALSE, buf); 388 } 241 } 389 << 390 << 391 int chroot(const char *path) << 392 { << 393 return _sos_chroot(path); << 394 } << 395 << 396 << 397 int chdir(const char *path) << 398 { << 399 return _sos_chdir(path); << 400 } << 401 << 402 int fchdir(int fd) << 403 { << 404 return _sos_fchdir(fd); << 405 } << 406 << 407 << 408 << 409 int printf (const char *format, ...) << 410 { << 411 char buff[4096]; << 412 va_list ap; << 413 << 414 va_start(ap, format); << 415 vsnprintf(buff, sizeof(buff), format, ap); << 416 va_end(ap); << 417 << 418 return write (1, buff, strlen(buff)); << 419 } << 420 << 421 <<
| [ source navigation ] | [ diff markup ] | [ identifier search ] | [ general search ] |