libc.c

Simple Operating Systems （简称SOS）是一个可以运行在X86平台上（包括QEMU

/* Copyright (C) 2005 David Decotigny

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; either version 2
   of the License, or (at your option) any later version.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
   USA. 
*/

#include "crt.h"
#include "string.h"
#include "stdarg.h"

#include "libc.h"

void exit (int status)
{
  _sos_exit(status);
}


pid_t fork(void)
{
  return _sos_fork();
}


int exec(const char *progname)
{
  return _sos_exec(progname);
}


int sleep(unsigned int seconds)
{
  return nanosleep(seconds, 0);
}


int nanosleep(unsigned long int sec,
	      unsigned long int nanosec)
{
  return _sos_nanosleep(sec, nanosec);
}



int munmap(void * start, size_t length)
{
  return _sos_munmap(start, length);
}


void * mremap(void * old_addr, size_t old_len,
	      size_t new_len,
	      unsigned long flags)
{
  void * new_uaddr = old_addr;
  if (0 != _sos_mresize(old_addr, old_len, & new_uaddr, new_len, flags))
    return NULL;

  return new_uaddr;
}


int mprotect(const void *addr, size_t len, int prot)
{
  return _sos_mprotect(addr, len, prot);
}


/**
 * The presence of this global variable without any protected access
 * to it explains why the "brk/sbrk" functions below are MT-unsafe !
 */
static void * kernel_heap_top = NULL;
int brk(void *end_data_seg)
{
  if (! end_data_seg)
    return -1;

  kernel_heap_top = _sos_brk(end_data_seg);
  return 0;
}


void *sbrk(ptrdiff_t increment)
{
  if (! kernel_heap_top)
    kernel_heap_top = _sos_brk(0);

  kernel_heap_top = _sos_brk(kernel_heap_top + increment);
  return kernel_heap_top;
}


void * calloc (size_t nmemb, size_t size)
{
  return malloc(nmemb * size);
}


/**
 * The presence of this global variable without any protected access
 * to it explains why the "malloc/calloc" functions below are
 * MT-unsafe !
 */
static void * malloc_heap_top = NULL;
void * malloc (size_t size)
{
  void * retval;

  if (size <= 0)
    return NULL;

  /* Align on a 4B boundary */
  size = ((size-1) & ~3) + 4;

  if (! kernel_heap_top)
    kernel_heap_top = _sos_brk(0);

  if (! malloc_heap_top)
    malloc_heap_top = kernel_heap_top;

  retval = malloc_heap_top;
  malloc_heap_top += size;

  _sos_brk(malloc_heap_top);
  return retval;
}


void free(void *ptr)
{
  //  bochs_printf("Free ignored (not implemented yet)\n");
}



int mount(const char *source, const char *target,
	  const char *filesystemtype, unsigned long mountflags,
	  const char *data)
{
  return _sos_mount(source, target, filesystemtype, mountflags, data);
}


int umount(const char *target)
{
  return _sos_umount(target);
}


void sync(void)
{
  return _sos_sync();
}


int statvfs(const char *path, struct statvfs *buf)
{
  return _sos_statvfs(path, buf);
}


int open(const char *pathname, int flags, /* mode_t mode */...)
{
  va_list ap;
  unsigned int mode = 0;
 
  va_start(ap, flags);
  if (flags & O_CREAT)
    mode = va_arg(ap, unsigned int);
  va_end(ap);
 
  return _sos_open(pathname, flags, mode);
}


int close(int fd)
{
  return _sos_close(fd);
}


int read(int fd, char * buf, size_t len)
{
  int retval = _sos_read(fd, buf, & len);
  if (retval < 0)
    return retval;
  return len;
}


int write(int fd, const char * buf, size_t len)
{
  int retval = _sos_write(fd, buf, & len);
  if (retval < 0)
    return retval;
  return len;
}


off_t lseek(int fd, off_t offset, int whence)
{
  loff_t result = offset;
  int retval = _sos_seek64(fd, & result, whence);
  if (retval < 0)
    return retval;
  return result;
}


loff_t lseek64(int fd, loff_t offset, int whence)
{
  loff_t result = offset;
  int retval = _sos_seek64(fd, & result, whence);
  if (retval < 0)
    return retval;
  return result;
}


void * mmap(void *start, size_t length, int prot , int flags,
	    int fd, loff_t offset)
{
  /* At kernel side, offset is considered positive */
  if (offset < 0)
    return NULL;

  if (0 != _sos_fmmap(& start, length, prot, flags, fd, offset))
    return NULL;

  return start;
}


int ftruncate(int fd, off_t length)
{
  return _sos_ftruncate64(fd, length);
}


int ftruncate64(int fd, loff_t length)
{
  return _sos_ftruncate64(fd, length);
}


int fcntl(int fd, int cmd, int arg)
{
  return _sos_fcntl(fd, cmd, arg);
}


int ioctl(int fd, int cmd, int arg)
{
  return _sos_ioctl(fd, cmd, arg);
}


int creat(const char *pathname, mode_t mode)
{
  return _sos_creat(pathname, mode);
}

int link (const char *oldpath, const char *newpath)
{
  return _sos_link(oldpath, newpath);
}


int unlink(const char *pathname)
{
  return _sos_unlink(pathname);
}


int rename(const char *oldpath, const char *newpath)
{
  return _sos_rename(oldpath, newpath);
}


int symlink(const char *target, const char *path)
{
  return _sos_symlink(target, path);
}


int mknod(const char *pathname, mode_t mode,
	  int type,
	  unsigned int major, unsigned minor)
{
  if (type == S_IFREG)
    return creat(pathname, mode);
  
  return _sos_mknod(pathname, mode, type,
		    major, minor);
}


int mkdir(const char *pathname, mode_t mode)
{
  return _sos_mkdir(pathname, mode);
}


int rmdir(const char *pathname)
{
  return _sos_rmdir(pathname);
}


int chmod(const char *path, mode_t mode)
{
  return _sos_chmod(path, mode);
}


struct sos_DIR_struct
{
  int fd;
  struct dirent dirent;
};


DIR *opendir(const char *name)
{
  DIR * result = malloc(sizeof(DIR));
  if (! result)
    return NULL;

  result->fd = _sos_open(name, O_DIRECTORY | O_RDONLY, 0);
  return result;
}


int dirfd(const DIR * dir)
{
  if (dir)
    return dir->fd;
  return -1;
}


struct dirent *readdir(DIR *dir)
{
  int retval = _sos_readdir(dir->fd, & dir->dirent);
  if (retval < 0)
    return NULL;
  return & dir->dirent;
}


int closedir(DIR *dir)
{
  close(dir->fd);
  free(dir);
  return 0;
}


int stat(const char *file_name, struct stat *buf)
{
  return _sos_stat(file_name, TRUE, buf);
}


int lstat(const char *file_name, struct stat *buf)
{
  return _sos_stat(file_name, FALSE, buf);
}


int chroot(const char *path)
{
  return _sos_chroot(path);
}


int chdir(const char *path)
{
  return _sos_chdir(path);
}

int fchdir(int fd)
{
  return _sos_fchdir(fd);
}



int printf (const char *format, ...)
{
  char buff[4096];
  va_list ap;

  va_start(ap, format);
  vsnprintf(buff, sizeof(buff), format, ap);
  va_end(ap);

  return write (1, buff, strlen(buff));
}