Subversion Repositories shark

/*
 * Project: HARTIK (HA-rd R-eal TI-me K-ernel)
 *
 * Coordinators: Giorgio Buttazzo <giorgio@sssup.it>
 *               Gerardo Lamastra <gerardo@sssup.it>
 *
 * Authors     : Massimiliano Giorgi <massy@hartik.sssup.it>
 * (see authors.txt for full list of hartik's authors)
 *
 * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
 *
 * http://www.sssup.it
 * http://retis.sssup.it
 * http://hartik.sssup.it
 */

/*
 * Copyright (C) 1999 Massimiliano Giorgi
 *
 * 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
 *
 */

/*
 * CVS :        $Id: file.c,v 1.1.1.1 2002-03-29 14:12:50 pj Exp $
 *
 * File:        $File$
 * Revision:    $Revision: 1.1.1.1 $
 * Last update: $Date: 2002-03-29 14:12:50 $
 */

#include <fs/fsconf.h>
#include <fs/util.h>
#include <fs/types.h>
#include <fs/fcntl.h>
#include <fs/stat.h>
#include <fs/errno.h>
#include <fs/maccess.h>
#include <fs/limits.h>
#include <fs/task.h>

#include "mutex.h"
#include "fs.h"
#include "file.h"
#include "fsconst.h"
#include "dentry.h"
#include "fileop.h"
#include "inode.h"
#include "inodeop.h"

#include "debug.h"

/* OSKit stdio need this */
int getdtablesize(void)
{
  return MAXOPENFILES;
}

/*-----------*/

//#if !defined GLOB_DESC_TABLE
//#if !defined LOC_DESC_TABLE
//#error "GLOB_DESC_TABLE or LOC_DESC_TABLE must be defined! (see fsconfig.h)"
//#endif
//#else
//#if defined LOC_DESC_TABLE
//#error "GLOB_DESC_TABLE and LOC_DESC_TABLE are defined! (see fsconfig.h)"
//#endif
//#endif

/*-----------*/

//static __fs_mutex_t mutex;
static __fs_mutex_t mutexreq;

static struct file *freelist;
static struct file filetab[MAXSYSFILE];

//#ifdef GLOB_DESC_TABLE
//#include "fileg.inc"
//#else
//#include "filel.inc"
//#endif

struct file_descriptors desctable[MAXIMUMPROCESS];

int get_fd(__pid_t pid, struct file *f)
{
  int i;
  lock_desctable(pid);
  for (i=0;i<MAXOPENFILES;i++)
    if (desctable[pid].fd_file[i]==NULL) {
      desctable[pid].fd_file[i]=f;
      desctable[pid].fd_file[i]->f_count=1;
      desctable[pid].fd_flags[i]=0;
      desctable[pid].fd_fflags[i]=0;
      unlock_desctable(pid);
      return i;
    }
  unlock_desctable(pid);
  return -1;
}

int __duplicate_fd(__pid_t pid, int fd, int low)
{
  while (low<MAXOPENFILES) {
    if (desctable[pid].fd_file[low]==NULL) {
      desctable[pid].fd_file[low]=desctable[pid].fd_file[fd];
      desctable[pid].fd_file[fd]->f_count++;
      return low;
    }
    low++;
  }
  return -1;
}


int __isvalid_fd(__pid_t pid, int fd)
{
  return desctable[pid].fd_file[fd]!=NULL;
}


struct file *free_fd(__pid_t pid, int fd)
{
  struct file *ret;
  lock_desctable(pid);
  ret=desctable[pid].fd_file[fd];
  desctable[pid].fd_file[fd]=NULL;  
  unlock_desctable(pid);
  return ret;  
}

static int subfile_init(void)
{
  int i,j;
  for (j=0;j<MAXIMUMPROCESS;j++) {

    strcpy(desctable[j].fd_cwd,ROOTDIRNAME);
    desctable[j].fd_cwden=get_root_dentry();
    get_root_dentry()->d_lock++;
    desctable[j].fd_umask=__DEFUMASK;

    /* TO FIX : 0,1,2 are reserved file descriptors */
    /*
    desctable[j].fd_file[0]=(void*)(-1);
    desctable[j].fd_flags[0]=0;
    desctable[j].fd_fflags[0]=0;
    desctable[j].fd_file[1]=(void*)(-1);
    desctable[j].fd_flags[1]=0;
    desctable[j].fd_fflags[1]=0;
    desctable[j].fd_file[2]=(void*)(-1);
    desctable[j].fd_flags[2]=0;
    desctable[j].fd_fflags[2]=0;
    */
    for (i=0;i<MAXOPENFILES;i++) {
      desctable[j].fd_file[i]=NULL;
      desctable[j].fd_flags[i]=0;
      desctable[j].fd_fflags[i]=0;
    }

   
    init_mutex(j);
  }
 
  return 0;
}

/*-----------*/

/*
 * DANGER: must be called AFTER the mounting of the root device!
 * because the subfile_init() use get_root_dentry()
 */

int file_init(void)
{
  int i;
  //__fs_mutex_init(&mutex);
  __fs_mutex_init(&mutexreq);
  freelist=filetab;
  for (i=0;i<MAXSYSFILE;i++) {
    memset(filetab+i,0,sizeof(struct file));
    filetab[i].f_next=filetab+i+1;
    filetab[i].f_count=0;
  }
  filetab[MAXSYSFILE-1].f_next=NULL;

  return subfile_init();  
}

/**/

struct file *__get_file(void)
{
  struct file *f;
  if (freelist==NULL) return NULL;    
  f=freelist;
  freelist=f->f_next;
  _assert(f->f_count==0);
  f->f_count=1;
  return f;
}

/* get a file struct from the free queue */
struct file *get_file(struct inode *ptr)
{
  /* NB: ptr is not used yet */
  struct file *f;
  __fs_mutex_lock(&mutexreq);
  //cprintf("Û{");
  f=__get_file();
  __fs_mutex_unlock(&mutexreq);
  //cprintf("Û}");
  return f;
}

/**/

static void __free_file(struct file *f)
{
  _assert(f->f_count==1);
  f->f_count=0;
  f->f_next=freelist;
  freelist=f;
}

/* insert file struct into the free queue */
void free_file(struct file *f)
{
  __fs_mutex_lock(&mutexreq);
  //cprintf("Û{");
  __free_file(f);
  __fs_mutex_unlock(&mutexreq);
  //cprintf("Û}");
}

/* enumerate all files */
void enums_file(void (*func)(struct file *))
{
  int i;
  __fs_mutex_lock(&mutexreq);
  //cprintf("Û{");
  for (i=0;i<MAXSYSFILE;i++)
    if (filetab[i].f_count!=0) func(filetab+i);
  __fs_mutex_unlock(&mutexreq);
  //cprintf("Û}");
}


/*
 *
 * DUMMY file operations
 *
 */

__off_t dummy_lseek(struct file *f, __off_t off, int whence)
{
  return -ENOSYS;
}

__ssize_t dummy_read(struct file *f, char *p, __ssize_t d)
{
  return -ENOSYS;
}

__ssize_t dummy_write(struct file *f, char *p, __ssize_t d)
{
  return -ENOSYS;
}

int dummy_readdir(struct file *f, void *e)
{
  return -ENOSYS;
}

int dummy_open(struct inode *i, struct file *f)
{
  return -ENOSYS;
}

int dummy_close(struct inode *i, struct file *f)
{
  return -ENOSYS;
}

/*
 *
 * for function inlines
 *
 *
 */

#ifdef MULTITHREAD

void lock_desctable(__pid_t pid)
{
  __mutex_lock(&desctable[pid].fd_mutex);
}

void unlock_desctable(__pid_t pid)
{
  __mutex_unlock(&desctable[pid].fd_mutex);
}

void init_mutex(__pid_t pid)
{
  __mutex_init(&desctable[pid].fd_mutex,fsmutexattr);
}

#else

void lock_desctable(__pid_t pid)
{}

void unlock_desctable(__pid_t pid)
{}

void init_mutex(__pid_t pid)
{}

#endif

__mode_t *umask_ptr(__pid_t pid)
{
  return &desctable[pid].fd_umask;
}

char *cwd_ptr(__pid_t pid)
{
  return desctable[pid].fd_cwd;
}

struct dentry *cwden_ptr(__pid_t pid)
{
  return desctable[pid].fd_cwden;
}

struct file *file_ptr(__pid_t pid, int i)
{
  return desctable[pid].fd_file[i];
}