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.h,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 $
 */

/***
 This files contains the "file" structure that rapresents??? a file in the system and functions
 to manage the local descriptors table of every process (not task).
***/

#ifndef __FILE_H__
#define __FILE_H__

#include <fs/types.h>
#include <fs/limits.h>
#include <fs/fsconf.h>
#include <fs/task.h>
#include <fs/assert.h>

#ifdef MSDOS_FILESYSTEM
#include "msdos/msdos_f.h"
#endif

#include "mutex.h"
#include "inode.h"

struct file {
  struct file            *f_next;

  struct dentry          *f_dentry;
  struct file_operations *f_op;

 
  /*__uint32_t           f_flags;  */
  __loff_t               f_pos;

  __uint32_t             f_flag_isdir:1;

  unsigned int           f_count; /* number of fd that point to this */
 
  union {
#ifdef MSDOS_FILESYSTEM
    struct msdos_file_info msdos_f;
#endif
    unsigned               dummy;
  } u;
 
  unsigned long          f_reada, f_ramax, f_raend, f_ralen, f_rawin;
  unsigned int           f_uid, f_gid;
  int                    f_error;
  unsigned long          f_version;
};

struct file_descriptors {  
  struct file   *fd_file[MAXOPENFILES];

  __uint16_t    fd_flags[MAXOPENFILES];  /* FD_CLOEXEC*/
  __uint32_t    fd_fflags[MAXOPENFILES]; /* O_CREAT, O_SYNC, O_RDONLY, ...*/
 
  __mode_t      fd_umask;
  char          fd_cwd[MAXPATHNAMELEN+1];
  struct dentry *fd_cwden;
#ifdef MULTITHREAD
  __mutex_t     fd_mutex;
#endif
};

/* if fd_file[fd] is
 * NULL       -> fd is free
 * RESERVEDFD -> fd is reserved for console i/o
 * other      -> fd is usuable
 */
#define RESERVEDFD ((void*)-1)

int file_init(void);

struct file *get_file(struct inode *ptr);
void free_file(struct file *f);

int get_fd(__pid_t pid, struct file *f);
struct file *free_fd(__pid_t pid, int fd);

void enums_file(void (*func)(struct file *));

/* does not aquire or release a lock! */
int __isvalid_fd(__pid_t pid, int fd);

int __duplicate_fd(__pid_t pid, int fd, int low);

/* ------ */

extern struct file_descriptors desctable[];

#ifdef MULTITHREAD

extern __inline__ void lock_desctable(__pid_t pid)
{
  __fs_mutex_lock(&desctable[pid].fd_mutex);
}

extern __inline__ void unlock_desctable(__pid_t pid)
{
  __fs_mutex_unlock(&desctable[pid].fd_mutex);
}

extern __inline__ void init_mutex(__pid_t pid)
{
  __fs_mutex_init(&desctable[pid].fd_mutex);
}

#else

#define lock_desctable(pid)

#define unlock_desctable(pid)

#define init_mutex(pid)

#endif

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

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

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

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

extern __inline__ int check_fd(__pid_t pid, int fd)
{
  if (fd<0||fd>=MAXOPENFILES) return -1;
  _assert(pid>=0&&pid<MAXIMUMPROCESS);
  if (desctable[pid].fd_file[fd]==NULL) return -1;
  if (desctable[pid].fd_file[fd]==RESERVEDFD) return -1;
  if (desctable[pid].fd_file[fd]->f_count==0) return -1;
  return 0;
}

extern __inline__ __uint16_t *fildesflags_ptr(__pid_t pid, int i)
{
  return &desctable[pid].fd_flags[i];
}

extern __inline__ __uint32_t *fildesfflags_ptr(__pid_t pid, int i)
{
  return &desctable[pid].fd_fflags[i];
}

#endif