file.c

Go to the documentation of this file.

/*-
 * Copyright (c) 2002-2018 The UbixOS Project.
 * All rights reserved.
 *
 * This was developed by Christopher W. Olsen for the UbixOS Project.
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted
 * provided that the following conditions are met:
 *
 * 1) Redistributions of source code must retain the above copyright notice, this list of
 *    conditions, the following disclaimer and the list of authors.
 * 2) Redistributions in binary form must reproduce the above copyright notice, this list of
 *    conditions, the following disclaimer and the list of authors in the documentation and/or
 *    other materials provided with the distribution.
 * 3) Neither the name of the UbixOS Project nor the names of its contributors may be used to
 *    endorse or promote products derived from this software without specific prior written
 *    permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#include <ubixos/sched.h>
#include <vfs/vfs.h>
#include <ubixos/vitals.h>
#include <ubixos/kpanic.h>
#include <ubixos/spinlock.h>
#include <lib/kmalloc.h>
#include <string.h>
#include <vmm/paging.h>
#include <lib/kprintf.h>
#include <assert.h>
#include <sys/descrip.h>
 
static struct spinLock fdTable_lock = SPIN_LOCK_INITIALIZER;
 
fileDescriptor_t *fdTable = 0x0;
 
fileDescriptor_t *vfs_fileTable = 0x0;
 
int sys_fwrite(struct thread *td, struct sys_fwrite_args *uap) {
  char *t = uap->buf;
 
  if (uap->fd == 0x0)
    tty_print((char*) uap->buf, _current->term);
  else {
#ifdef DEBUG_VFS
    kprintf("uap->size: %i, FD: [0x%X], BUF: [0x%X][%c]\n", uap->nbytes, uap->fd, uap->buf, t[0]);
#endif
    fwrite(uap->buf, uap->nbytes, 1, uap->fd->fd);
  }
 
  td->td_retval[0] = 0x0;
 
  return (0);
}
 
/* USER */
 
void sysFwrite(char *ptr, int size, userFileDescriptor *userFd) {
  if (userFd == 0x0) {
    tty_print(ptr, _current->term);
  }
  else {
    fwrite(ptr, size, 1, userFd->fd);
  }
  return;
}
 
int sys_fgetc(struct thread *td, struct sys_fgetc_args *args) {
  char c;
 
  if (args->FILE->fd == 0x0) {
 
    while (1) {
 
      if (_current->term == tty_foreground) {
        c = getchar();
 
        if (c != 0x0) {
          td->td_retval[0] = c;
          return (0);
        }
 
        sched_yield();
 
      }
      else {
        sched_yield();
      }
      /*
       else {
       kprintf("Waking Task: %i\n",tty_foreground->owner);
       sched_setStatus(tty_foreground->owner,READY);
       kprintf("Sleeping Task: %i\n",_current->id);
       sched_setStatus(_current->id,WAIT);
       sched_yield();
       }
       */
    }
  }
  else {
    c = fgetc(args->FILE->fd);
    td->td_retval[0] = c;
    return (0);
  }
}
 
void sysRmDir() {
  return;
}
 
int sys_fseek(struct thread *td, struct sys_fseek_args *args) {
  kprintf("offset: %ld, whence: 0x%X", args->offset, args->whence);
 
  // TODO : coredump?
  if (args->FILE == NULL) {
    td->td_retval[0] = -1;
    return (-1);
  }
 
  if (args->FILE->fd == NULL) {
    td->td_retval[0] = -1;
    return (-1);
  }
 
  switch (args->whence) {
    case 0:
      args->FILE->fd->offset = args->offset + args->whence;
      break;
    case 1:
      args->FILE->fd->offset += args->offset;
      break;
    default:
      kprintf("seek-whence: %i", args->whence);
      break;
  }
 
  td->td_retval[0] = args->FILE->fd->offset & 0xFFFFFFFF;
  return (0);
}
 
int sys_lseek(struct thread *td, struct sys_lseek_args *args) {
  int error = 0;
  struct file *fdd = 0x0;
  fileDescriptor_t *fd = 0x0;
 
  getfd(td, &fdd, args->fd);
 
  fd = fdd->fd;
 
  if (fdd == 0 || fdd->fd == 0x0) {
    error = -1;
    kprintf("ERROR!");
  }
 
  kprintf("loffset(%i): %i:%i, whence: 0x%X", sizeof(off_t), args->offset >> 32, args->offset & 0xFFFFFF, args->whence);
 
  switch (args->whence) {
    case SEEK_SET:
      fd->offset = args->offset;
      td->td_retval[0] = fd->offset & 0xFFFFFFFF;
      td->td_retval[1] = fd->offset >> 32;
      break;
    case SEEK_CUR:
      fd->offset += args->offset;
      td->td_retval[0] = fd->offset & 0xFFFFFFFF;
      td->td_retval[1] = fd->offset >> 32;
      break;
    default:
      kprintf("seek-whence: %i", args->whence);
      break;
  }
 
  kprintf("loff: %ld", fd->offset);
 
  return (error);
}
 
int sys_chdir(struct thread *td, struct sys_chdir_args *args) {
  if (strstr(args->path, ":") == 0x0) {
    sprintf(_current->oInfo.cwd, "%s%s", _current->oInfo.cwd, args->path);
  }
  else {
    sprintf(_current->oInfo.cwd, args->path);
  }
  td->td_retval[0] = 0;
  return (0);
}
 
int sys_fchdir(struct thread *td, struct sys_fchdir_args *args) {
  int error = 0;
  struct file *fdd = 0x0;
  fileDescriptor_t *fd = 0x0;
 
  getfd(td, &fdd, args->fd);
 
  fd = fdd->fd;
 
  if (fdd == 0 || fdd->fd == 0x0) {
    error = -1;
  }
  else {
    if (strstr(fd->fileName, ":") == 0x0) {
      sprintf(_current->oInfo.cwd, "%s%s", _current->oInfo.cwd, fd->fileName);
    }
    else {
      sprintf(_current->oInfo.cwd, fd->fileName);
    }
  }
  return (error);
}
 
int sys_rename(struct thread *td, struct sys_rename_args *args) {
  td->td_retval[0] = 0;
  return (0);
}
 
int sysUnlink(const char *path, int *retVal) {
  *retVal = 0;
  return (*retVal);
}
 
/************************************************************************
 
 Function: void sysFopen();
 Description: Opens A File Descriptor For A User Task
 Notes:
 
 ************************************************************************/
//void sysFopen(const char *file,char *flags,userFileDescriptor *userFd) {
int sys_fopen(struct thread *td, struct sys_fopen_args *args) {
  kprintf("sys_fopen");
  if (args->FILE == NULL) {
    kprintf("Error: userFd == NULL, File: %s, Line: %i\n", __FILE__, __LINE__);
    return (-1);
  }
 
  args->FILE->fd = fopen(args->path, args->mode);
  if (args->FILE->fd != 0x0) {
    args->FILE->fdSize = args->FILE->fd->size;
  }
  /* Return */
  return (0);
}
 
/************************************************************************
 
 Function: void sysFread();
 Description: Reads SIZE Bytes From The userFd Into DATA
 Notes:
 
 ************************************************************************/
int sys_fread(struct thread *td, struct sys_fread_args *args) {
 
  /* TODO : coredump? */
  if (args->FILE == NULL)
    return (-1);
 
  if (args->FILE->fd == NULL)
    return (-1);
 
  td->td_retval[0] = fread(args->ptr, args->size, args->nmemb, args->FILE->fd);
  return (0);
}
 
/************************************************************************
 
 Function: void sysFclse();
 Description: Closes A File Descriptor For A User Task
 Notes:
 
 ************************************************************************/
int sys_fclose(struct thread *td, struct sys_fclose_args *args) {
  if (args->FILE == NULL) {
    return (-1);
  }
  if (args->FILE == NULL) {
    return (-1);
  }
 
  /* Return */
  return (fclose(args->FILE->fd));
}
 
/* KERNEL */
 
size_t fread(void *ptr, size_t size, size_t nmemb, fileDescriptor_t *fd) {
  size_t i = 0x0;
 
  if (fd == 0x0)
    return (0x0);
 
  if (nmemb == 0x0)
    nmemb = 1; //Temp Fix
 
  assert(fd);
  assert(fd->mp);
  assert(fd->mp->fs);
 
  i = fd->mp->fs->vfsRead(fd, ptr, fd->offset, size * nmemb);
 
  //fd->offset += size * nmemb;
 
  return (i);
}
 
size_t fwrite(void *ptr, int size, int nmemb, fileDescriptor_t *fd) {
  int res = 0x0;
  /*
  kprintf("fd[0x%X]\m", fd);
  kprintf("fd->mp[0x%X]\m", fd->mp);
  kprintf("fd->mp->fs[0x%X]\m", fd->mp->fs);
   */
 
  if (fd != 0x0) {
    res = fd->mp->fs->vfsWrite(fd, ptr, fd->offset, size * nmemb);
    fd->offset += size * nmemb;
  }
  return (res);
}
 
int fseek(fileDescriptor_t *tmpFd, long offset, int whence) {
  tmpFd->offset = offset + whence;
  return (tmpFd->offset);
}
 
/************************************************************************
 
 Function: int feof(fileDescriptor_t *fd)
 Description: Check A File Descriptor For EOF And Return Result
 Notes:
 
 ************************************************************************/
int feof(fileDescriptor_t *fd) {
  if (fd->status == fdEof) {
    return (-1);
  }
  return (0);
}
 
/************************************************************************
 
 Function: int fputc(int ch,fileDescriptor_t *fd)
 Description: This Will Write Character To FD
 Notes:
 
 ************************************************************************/
int fputc(int ch, fileDescriptor_t *fd) {
  if (fd != 0x0) {
    ch = fd->mp->fs->vfsWrite(fd, (char*) ch, fd->offset, 1);
    fd->offset++;
    return (ch);
  }
  /* Return NULL If FD Is Not Found */
  return (0x0);
}
 
/************************************************************************
 
 Function: int fgetc(fileDescriptor_T *fd)
 Description: This Will Return The Next Character In A FD Stream
 Notes:
 
 ************************************************************************/
int fgetc(fileDescriptor_t *fd) {
  int ch = 0x0;
  /* If Found Return Next Char */
  if (fd != 0x0) {
    fd->mp->fs->vfsRead(fd, (char*) &ch, fd->offset, 1);
    fd->offset++;
    return (ch);
  }
 
  /* Return NULL If FD Is Not Found */
  return (0x0);
}
 
/************************************************************************
 
 Function: fileDescriptor_t *fopen(const char *file,cont char *flags)
 Description: This Will Open A File And Return A File Descriptor
 Notes:
 
 08/05/02 - Just Started A Rewrite Of This Function Should Work Out Well
 
 ************************************************************************/
 
fileDescriptor_t* fopen(const char *file, const char *flags) {
 
  int i = 0x0;
  char *path = 0x0;
  char *mountPoint = 0x0;
  char fileName[1024];
  fileDescriptor_t *tmpFd = 0x0;
 
  /* Allocate Memory For File Descriptor */
  if ((tmpFd = (fileDescriptor_t*) kmalloc(sizeof(fileDescriptor_t))) == 0x0) {
    kprintf("Error: tmpFd == NULL, File: %s, Line: %i\n", __FILE__, __LINE__);
    return (NULL);
  }
 
  memset(tmpFd, 0x0, sizeof(fileDescriptor_t));
 
  path = file;
 
  /* Determine if path is relative or absolute */
  if (path[0] == "." && path[1] == '\0')
    strcpy(fileName, _current->oInfo.cwd);
  else
    strcpy(fileName, file);
 
  path = 0x0;
 
  if (strstr(fileName, ":")) {
    mountPoint = (char*) strtok((char*) &fileName, ":");
    path = strtok(NULL, "\n");
  }
  else {
    path = fileName;
  }
 
  if (path[0] == '/')
    strcpy(tmpFd->fileName, path);
  else
    sprintf(tmpFd->fileName, "/%s", path);
 
  /* Find our mount point or set default to sys */
  if (mountPoint == 0x0) {
    tmpFd->mp = vfs_findMount("sys");
  }
  else {
    tmpFd->mp = vfs_findMount(mountPoint);
  }
 
  if (tmpFd->mp == 0x0) {
    kprintf("Mount Point Bad\n");
    return (0x0);
  }
 
  /* This Will Set Up The Descriptor Modes */
  tmpFd->mode = 0;
  for (i = 0; '\0' != flags[i]; i++) {
    switch (flags[i]) {
      case 'w':
      case 'W':
        tmpFd->mode |= fileWrite;
        break;
      case 'r':
      case 'R':
        tmpFd->mode |= fileRead;
        break;
      case 'b':
      case 'B':
        tmpFd->mode |= fileBinary;
        break;
      case 'a':
      case 'A':
        tmpFd->mode |= fileAppend;
        break;
      default:
        kprintf("Invalid mode '%c' for fopen\n", flags[i]);
        break;
    }
  }
 
  /* Search For The File */
  if (tmpFd->mp->fs->vfsOpenFile(tmpFd->fileName, tmpFd) == 0x1) {
    /* If The File Is Found Then Set Up The Descriptor */
 
    /* in order to save resources we will allocate the buffer later when it is needed */
 
    tmpFd->buffer = (char*) kmalloc(4096);
 
    if (tmpFd->buffer == 0x0) {
      kfree(tmpFd);
      kprintf("Error: tmpFd->buffer == NULL, File: %s, Line: %i\n", __FILE__, __LINE__);
      spinUnlock(&fdTable_lock);
      return (0x0);
    }
 
    /* Set Its Status To Open */
    tmpFd->status = fdOpen;
 
    /* Initial File Offset Is Zero */
    tmpFd->offset = 0;
    tmpFd->prev = 0x0;
 
    /* we do not want to be in a spinlock longer than we need to, so
     it has been moved to here. */
    spinLock(&fdTable_lock);
 
    /* Increment Number Of Open Files */
    systemVitals->openFiles++;
 
    tmpFd->next = fdTable;
 
    if (fdTable != 0x0)
      fdTable->prev = tmpFd;
 
    fdTable = tmpFd;
 
    spinUnlock(&fdTable_lock);
 
    /* Return The FD */
    return (tmpFd);
  }
  else {
    //kprintf("Freeing");
    kfree(tmpFd->buffer);
    kfree(tmpFd);
    spinUnlock(&fdTable_lock);
    //MrOlsen (2016-01-13) NOTE: We don't need this right now kprintf("File Not Found? %s\n",file);
    return (0x0);
  }
 
  /* Return NULL */
  return (0x0);
}
 
/************************************************************************
 
 Function: int fclose(fileDescriptor_t *fd);
 Description: This Will Close And Free A File Descriptor
 Notes:
 
 ************************************************************************/
int fclose(fileDescriptor_t *fd) {
  fileDescriptor_t *tmpFd = 0x0;
 
  if (fd == 0)
    return (0x0);
 
  spinLock(&fdTable_lock);
 
  kprintf("[%s:%i]", __FILE__, __LINE__);
 
  for (tmpFd = fdTable; tmpFd != 0x0; tmpFd = tmpFd->next) {
    if (tmpFd == fd) {
      kprintf("DUP: [%i:0x%X]", fd->dup, fd);
      if (fd->dup > 0)
        fd->dup--;
      else {
        fd->dup = -2;
        if (fd->res != 0x0)
          fl_fclose(fd->res);
 
        if (tmpFd->prev)
          tmpFd->prev->next = tmpFd->next;
        if (tmpFd->next)
          tmpFd->next->prev = tmpFd->prev;
 
        if (tmpFd == fdTable)
          fdTable = tmpFd->next;
 
        systemVitals->openFiles--;
        spinUnlock(&fdTable_lock);
        if (tmpFd->buffer != NULL)
          kfree(tmpFd->buffer);
        kfree(tmpFd);
        return (0x0);
      }
    }
  }
 
  spinUnlock(&fdTable_lock);
  return (0x1);
}
 
/* UBU */
 
/************************************************************************
 
 Function: void sysMkDir(const char *path)
 Description: This Will Create A New Directory
 Notes:
 
 ************************************************************************/
void sysMkDir(const char *path) {
  fileDescriptor_t *tmpFD = 0x0;
  char tmpDir[1024];
  char rootPath[256];
  char *dir = 0x0; //UBU*mountPoint = 0x0;
  char *tmp = 0x0;
  rootPath[0] = '\0';
  dir = (char*) path;
 
  if (strstr(path, ":") == 0x0) {
    sprintf(tmpDir, "%s%s", _current->oInfo.cwd, path);
    dir = (char*) &tmpDir;
  }
  while (strstr(dir, "/")) {
    if (rootPath[0] == 0x0)
      sprintf(rootPath, "%s/", strtok(dir, "/"));
    else
      sprintf(rootPath, "%s%s/", rootPath, strtok(dir, "/"));
    tmp = strtok(NULL, "\n");
    dir = tmp;
  }
 
  //kprintf("rootPath: [%s]\n",rootPath);
  tmpFD = fopen(rootPath, "rb");
 
  if (tmpFD->mp == 0x0) {
    kprintf("Invalid Mount Point\n");
  }
  tmpFD->mp->fs->vfsMakeDir(dir, tmpFD);
 
  fclose(tmpFD);
 
  return;
}
 
/************************************************************************
 
 Function: int unlink(const char *node)
 Description: This will unlink a file
 Notes:
 
 ************************************************************************/
 
int unlink(const char *node) {
  char *path = 0x0, *mountPoint = 0x0;
  struct vfs_mountPoint *mp = 0x0;
 
  path = (char*) strtok((char*) node, "@");
  mountPoint = strtok(NULL, "\n");
  if (mountPoint == 0x0) {
    mp = vfs_findMount("sys"); /* _current->oInfo.container; */
  }
  else {
    mp = vfs_findMount(mountPoint);
  }
  if (mp == 0x0) {
    //kpanic("Mount Point Bad");
    return (0x0);
  }
  mp->fs->vfsUnlink(path, mp);
  return (0x0);
}