Diff markup

Differences between /userland/libc.c (Article 9) and /userland/libc.c (Article 9.5)

 /* Copyright (C) 2005 David Decotigny              /* Copyright (C) 2005 David Decotigny
                                                    
    This program is free software; you can redi        This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU Genera        modify it under the terms of the GNU General Public License
    as published by the Free Software Foundatio        as published by the Free Software Foundation; either version 2
    of the License, or (at your option) any lat        of the License, or (at your option) any later version.
                                                       
    This program is distributed in the hope tha        This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the         but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details        GNU General Public License for more details.
                                                       
    You should have received a copy of the GNU         You should have received a copy of the GNU General Public License
    along with this program; if not, write to t        along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 3        Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
    USA.                                               USA. 
 */                                                 */
                                                    
 #include "crt.h"                                   #include "crt.h"
 #include "string.h"                                #include "string.h"
 #include "stdarg.h"                                #include "stdarg.h"
                                                    
 #include "libc.h"                                  #include "libc.h"
                                                    
 void exit (int status)                             void exit (int status)
 {                                                  {
   _sos_exit(status);                                 _sos_exit(status);
 }                                                  }
                                                    
                                                    
 pid_t fork(void)                                   pid_t fork(void)
 {                                                  {
   return _sos_fork();                                return _sos_fork();
 }                                                  }
                                                    
                                                    
 int exec(const char *progname)                     int exec(const char *progname)
 {                                                  {
   return _sos_exec(progname);                        return _sos_exec(progname);
 }                                                  }
                                                    
                                                    
 int sleep(unsigned int seconds)                    int sleep(unsigned int seconds)
 {                                                  {
   return nanosleep(seconds, 0);                      return nanosleep(seconds, 0);
 }                                                  }
                                                    
                                                    
 int nanosleep(unsigned long int sec,               int nanosleep(unsigned long int sec,
               unsigned long int nanosec)                         unsigned long int nanosec)
 {                                                  {
   return _sos_nanosleep(sec, nanosec);               return _sos_nanosleep(sec, nanosec);
 }                                                  }
                                                    
                                                    
                                                    
 int munmap(void * start, size_t length)            int munmap(void * start, size_t length)
 {                                                  {
   return _sos_munmap(start, length);                 return _sos_munmap(start, length);
 }                                                  }
                                                    
                                                    
 void * mremap(void * old_addr, size_t old_len,     void * mremap(void * old_addr, size_t old_len,
               size_t new_len,                                    size_t new_len,
               unsigned long flags)                               unsigned long flags)
 {                                                  {
   void * new_uaddr = old_addr;                       void * new_uaddr = old_addr;
   if (0 != _sos_mresize(old_addr, old_len, & n       if (0 != _sos_mresize(old_addr, old_len, & new_uaddr, new_len, flags))
     return NULL;                                       return NULL;
                                                    
   return new_uaddr;                                  return new_uaddr;
 }                                                  }
                                                    
                                                    
 int mprotect(const void *addr, size_t len, int     int mprotect(const void *addr, size_t len, int prot)
 {                                                  {
   return _sos_mprotect(addr, len, prot);             return _sos_mprotect(addr, len, prot);
 }                                                  }
                                                    
                                                    
                                                   >>  int msync(void *start, size_t length, int flags)
                                                   >>  {
                                                   >>    return _sos_msync(start, length, flags);
                                                   >>  }
                                                   >>  
                                                   >>  
 /**                                                /**
  * The presence of this global variable withou      * The presence of this global variable without any protected access
  * to it explains why the "brk/sbrk" functions      * to it explains why the "brk/sbrk" functions below are MT-unsafe !
  */                                                 */
 static void * kernel_heap_top = NULL;              static void * kernel_heap_top = NULL;
 int brk(void *end_data_seg)                        int brk(void *end_data_seg)
 {                                                  {
   if (! end_data_seg)                                if (! end_data_seg)
     return -1;                                         return -1;
                                                    
   kernel_heap_top = _sos_brk(end_data_seg);          kernel_heap_top = _sos_brk(end_data_seg);
   return 0;                                          return 0;
 }                                                  }
                                                    
                                                    
 void *sbrk(ptrdiff_t increment)                    void *sbrk(ptrdiff_t increment)
 {                                                  {
   if (! kernel_heap_top)                             if (! kernel_heap_top)
     kernel_heap_top = _sos_brk(0);                     kernel_heap_top = _sos_brk(0);
                                                    
   kernel_heap_top = _sos_brk(kernel_heap_top +       kernel_heap_top = _sos_brk(kernel_heap_top + increment);
   return kernel_heap_top;                            return kernel_heap_top;
 }                                                  }
                                                    
                                                    
 void * calloc (size_t nmemb, size_t size)          void * calloc (size_t nmemb, size_t size)
 {                                                  {
   return malloc(nmemb * size);                       return malloc(nmemb * size);
 }                                                  }
                                                    
                                                    
 /**                                                /**
  * The presence of this global variable withou      * The presence of this global variable without any protected access
  * to it explains why the "malloc/calloc" func      * to it explains why the "malloc/calloc" functions below are
  * MT-unsafe !                                      * MT-unsafe !
  */                                                 */
 static void * malloc_heap_top = NULL;              static void * malloc_heap_top = NULL;
 void * malloc (size_t size)                        void * malloc (size_t size)
 {                                                  {
   void * retval;                                     void * retval;
                                                    
   if (size <= 0)                                     if (size <= 0)
     return NULL;                                       return NULL;
                                                    
   /* Align on a 4B boundary */                       /* Align on a 4B boundary */
   size = ((size-1) & ~3) + 4;                        size = ((size-1) & ~3) + 4;
                                                    
   if (! kernel_heap_top)                             if (! kernel_heap_top)
     kernel_heap_top = _sos_brk(0);                     kernel_heap_top = _sos_brk(0);
                                                    
   if (! malloc_heap_top)                             if (! malloc_heap_top)
     malloc_heap_top = kernel_heap_top;                 malloc_heap_top = kernel_heap_top;
                                                    
   retval = malloc_heap_top;                          retval = malloc_heap_top;
   malloc_heap_top += size;                           malloc_heap_top += size;
                                                    
   _sos_brk(malloc_heap_top);                         _sos_brk(malloc_heap_top);
   return retval;                                     return retval;
 }                                                  }
                                                    
                                                    
 void free(void *ptr)                               void free(void *ptr)
 {                                                  {
   //  bochs_printf("Free ignored (not implemen       //  bochs_printf("Free ignored (not implemented yet)\n");
 }                                                  }
                                                    
                                                    
                                                    
 int mount(const char *source, const char *targ     int mount(const char *source, const char *target,
           const char *filesystemtype, unsigned               const char *filesystemtype, unsigned long mountflags,
           const char *data)                                  const char *data)
 {                                                  {
   return _sos_mount(source, target, filesystem       return _sos_mount(source, target, filesystemtype, mountflags, data);
 }                                                  }
                                                    
                                                    
 int umount(const char *target)                     int umount(const char *target)
 {                                                  {
   return _sos_umount(target);                        return _sos_umount(target);
 }                                                  }
                                                    
                                                    
 void sync(void)                                    void sync(void)
 {                                                  {
   return _sos_sync();                                return _sos_sync();
 }                                                  }
                                                    
                                                    
 int statvfs(const char *path, struct statvfs *     int statvfs(const char *path, struct statvfs *buf)
 {                                                  {
   return _sos_statvfs(path, buf);                    return _sos_statvfs(path, buf);
 }                                                  }
                                                    
                                                    
 int open(const char *pathname, int flags, /* m     int open(const char *pathname, int flags, /* mode_t mode */...)
 {                                                  {
   va_list ap;                                        va_list ap;
   unsigned int mode = 0;                             unsigned int mode = 0;
                                                     
   va_start(ap, flags);                               va_start(ap, flags);
   if (flags & O_CREAT)                               if (flags & O_CREAT)
     mode = va_arg(ap, unsigned int);                   mode = va_arg(ap, unsigned int);
   va_end(ap);                                        va_end(ap);
                                                     
   return _sos_open(pathname, flags, mode);           return _sos_open(pathname, flags, mode);
 }                                                  }
                                                    
                                                    
 int close(int fd)                                  int close(int fd)
 {                                                  {
   return _sos_close(fd);                             return _sos_close(fd);
 }                                                  }
                                                    
                                                    
 int read(int fd, char * buf, size_t len)           int read(int fd, char * buf, size_t len)
 {                                                  {
   int retval = _sos_read(fd, buf, & len);            int retval = _sos_read(fd, buf, & len);
   if (retval < 0)                                    if (retval < 0)
     return retval;                                     return retval;
   return len;                                        return len;
 }                                                  }
                                                    
                                                    
 int write(int fd, const char * buf, size_t len     int write(int fd, const char * buf, size_t len)
 {                                                  {
   int retval = _sos_write(fd, buf, & len);           int retval = _sos_write(fd, buf, & len);
   if (retval < 0)                                    if (retval < 0)
     return retval;                                     return retval;
   return len;                                        return len;
 }                                                  }
                                                    
                                                    
 off_t lseek(int fd, off_t offset, int whence)      off_t lseek(int fd, off_t offset, int whence)
 {                                                  {
   loff_t result = offset;                            loff_t result = offset;
   int retval = _sos_seek64(fd, & result, whenc       int retval = _sos_seek64(fd, & result, whence);
   if (retval < 0)                                    if (retval < 0)
     return retval;                                     return retval;
   return result;                                     return result;
 }                                                  }
                                                    
                                                    
 loff_t lseek64(int fd, loff_t offset, int when     loff_t lseek64(int fd, loff_t offset, int whence)
 {                                                  {
   loff_t result = offset;                            loff_t result = offset;
   int retval = _sos_seek64(fd, & result, whenc       int retval = _sos_seek64(fd, & result, whence);
   if (retval < 0)                                    if (retval < 0)
     return retval;                                     return retval;
   return result;                                     return result;
 }                                                  }
                                                    
                                                    
 void * mmap(void *start, size_t length, int pr     void * mmap(void *start, size_t length, int prot , int flags,
             int fd, loff_t offset)                             int fd, loff_t offset)
 {                                                  {
   /* At kernel side, offset is considered posi       /* At kernel side, offset is considered positive */
   if (offset < 0)                                    if (offset < 0)
     return NULL;                                       return NULL;
                                                    
   if (0 != _sos_fmmap(& start, length, prot, f       if (0 != _sos_fmmap(& start, length, prot, flags, fd, offset))
     return NULL;                                       return NULL;
                                                    
   return start;                                      return start;
 }                                                  }
                                                    
                                                    
 int ftruncate(int fd, off_t length)                int ftruncate(int fd, off_t length)
 {                                                  {
   return _sos_ftruncate64(fd, length);               return _sos_ftruncate64(fd, length);
 }                                                  }
                                                    
                                                    
 int ftruncate64(int fd, loff_t length)             int ftruncate64(int fd, loff_t length)
 {                                                  {
   return _sos_ftruncate64(fd, length);               return _sos_ftruncate64(fd, length);
 }                                                  }
                                                    
                                                    
 int fcntl(int fd, int cmd, int arg)                int fcntl(int fd, int cmd, int arg)
 {                                                  {
   return _sos_fcntl(fd, cmd, arg);                   return _sos_fcntl(fd, cmd, arg);
 }                                                  }
                                                    
                                                    
 int ioctl(int fd, int cmd, int arg)                int ioctl(int fd, int cmd, int arg)
 {                                                  {
   return _sos_ioctl(fd, cmd, arg);                   return _sos_ioctl(fd, cmd, arg);
 }                                                  }
                                                    
                                                    
 int creat(const char *pathname, mode_t mode)       int creat(const char *pathname, mode_t mode)
 {                                                  {
   return _sos_creat(pathname, mode);                 return _sos_creat(pathname, mode);
 }                                                  }
                                                    
 int link (const char *oldpath, const char *new     int link (const char *oldpath, const char *newpath)
 {                                                  {
   return _sos_link(oldpath, newpath);                return _sos_link(oldpath, newpath);
 }                                                  }
                                                    
                                                    
 int unlink(const char *pathname)                   int unlink(const char *pathname)
 {                                                  {
   return _sos_unlink(pathname);                      return _sos_unlink(pathname);
 }                                                  }
                                                    
                                                    
 int rename(const char *oldpath, const char *ne     int rename(const char *oldpath, const char *newpath)
 {                                                  {
   return _sos_rename(oldpath, newpath);              return _sos_rename(oldpath, newpath);
 }                                                  }
                                                    
                                                    
 int symlink(const char *target, const char *pa     int symlink(const char *target, const char *path)
 {                                                  {
   return _sos_symlink(target, path);                 return _sos_symlink(target, path);
 }                                                  }
                                                    
                                                    
 int mknod(const char *pathname, mode_t mode,       int mknod(const char *pathname, mode_t mode,
           int type,                                          int type,
           unsigned int major, unsigned minor)                unsigned int major, unsigned minor)
 {                                                  {
   if (type == S_IFREG)                               if (type == S_IFREG)
     return creat(pathname, mode);                      return creat(pathname, mode);
                                                      
   return _sos_mknod(pathname, mode, type,            return _sos_mknod(pathname, mode, type,
                     major, minor);                                     major, minor);
 }                                                  }
                                                    
                                                    
 int mkdir(const char *pathname, mode_t mode)       int mkdir(const char *pathname, mode_t mode)
 {                                                  {
   return _sos_mkdir(pathname, mode);                 return _sos_mkdir(pathname, mode);
 }                                                  }
                                                    
                                                    
 int rmdir(const char *pathname)                    int rmdir(const char *pathname)
 {                                                  {
   return _sos_rmdir(pathname);                       return _sos_rmdir(pathname);
 }                                                  }
                                                    
                                                    
 int chmod(const char *path, mode_t mode)           int chmod(const char *path, mode_t mode)
 {                                                  {
   return _sos_chmod(path, mode);                     return _sos_chmod(path, mode);
 }                                                  }
                                                    
                                                    
 struct sos_DIR_struct                              struct sos_DIR_struct
 {                                                  {
   int fd;                                            int fd;
   struct dirent dirent;                              struct dirent dirent;
 };                                                 };
                                                    
                                                    
 DIR *opendir(const char *name)                     DIR *opendir(const char *name)
 {                                                  {
   DIR * result = malloc(sizeof(DIR));                DIR * result = malloc(sizeof(DIR));
   if (! result)                                      if (! result)
     return NULL;                                       return NULL;
                                                    
   result->fd = _sos_open(name, O_DIRECTORY | O       result->fd = _sos_open(name, O_DIRECTORY | O_RDONLY, 0);
   return result;                                     return result;
 }                                                  }
                                                    
                                                    
 int dirfd(const DIR * dir)                         int dirfd(const DIR * dir)
 {                                                  {
   if (dir)                                           if (dir)
     return dir->fd;                                    return dir->fd;
   return -1;                                         return -1;
 }                                                  }
                                                    
                                                    
 struct dirent *readdir(DIR *dir)                   struct dirent *readdir(DIR *dir)
 {                                                  {
   int retval = _sos_readdir(dir->fd, & dir->di       int retval = _sos_readdir(dir->fd, & dir->dirent);
   if (retval < 0)                                    if (retval < 0)
     return NULL;                                       return NULL;
   return & dir->dirent;                              return & dir->dirent;
 }                                                  }
                                                    
                                                    
 int closedir(DIR *dir)                             int closedir(DIR *dir)
 {                                                  {
   close(dir->fd);                                    close(dir->fd);
   free(dir);                                         free(dir);
   return 0;                                          return 0;
 }                                                  }
                                                    
                                                    
 int stat(const char *file_name, struct stat *b     int stat(const char *file_name, struct stat *buf)
 {                                                  {
   return _sos_stat(file_name, TRUE, buf);            return _sos_stat(file_name, TRUE, buf);
 }                                                  }
                                                    
                                                    
 int lstat(const char *file_name, struct stat *     int lstat(const char *file_name, struct stat *buf)
 {                                                  {
   return _sos_stat(file_name, FALSE, buf);           return _sos_stat(file_name, FALSE, buf);
 }                                                  }
                                                    
                                                    
 int chroot(const char *path)                       int chroot(const char *path)
 {                                                  {
   return _sos_chroot(path);                          return _sos_chroot(path);
 }                                                  }
                                                    
                                                    
 int chdir(const char *path)                        int chdir(const char *path)
 {                                                  {
   return _sos_chdir(path);                           return _sos_chdir(path);
 }                                                  }
                                                    
 int fchdir(int fd)                                 int fchdir(int fd)
 {                                                  {
   return _sos_fchdir(fd);                            return _sos_fchdir(fd);
 }                                                  }
                                                    
                                                    
                                                    
 int printf (const char *format, ...)               int printf (const char *format, ...)
 {                                                  {
   char buff[4096];                                   char buff[4096];
   va_list ap;                                        va_list ap;
                                                    
   va_start(ap, format);                              va_start(ap, format);
   vsnprintf(buff, sizeof(buff), format, ap);         vsnprintf(buff, sizeof(buff), format, ap);
   va_end(ap);                                        va_end(ap);
                                                    
   return write (1, buff, strlen(buff));              return write (1, buff, strlen(buff));
 }                                                  }