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: fs.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 "dentry.h"

#include <kernel/func.h>

#include <fs/util.h>

#include <fs/types.h>

#include <fs/const.h>

#include <fs/bdev.h>

#include <fs/fsconf.h>

#include <fs/fsinit.h>

#include <fs/major.h>

#include <fs/fs.h>

#include <fs/sysmacro.h>

#include <fs/fsind.h>

#include <fs/assert.h>

#include <fs/mount.h>

#include <fs/errno.h>

#include <fs/task.h>

#include "mutex.h"

#include "fs.h"

#include "dcache.h"

#include "inode.h"

#include "super.h"

#include "superop.h"

#include "file.h"

#include "fileop.h"

#include "fsconst.h"

#include "debug.h"

// number of filesystem types supported

#define MAXFILESYSTEMS 8

// pointer into "fst"

static int nextfs=0;

// file system that are registered 

static struct file_system_type *fst[MAXFILESYSTEMS];

NOP_mutexattr_t fsdef_mutexattr=NOP_MUTEXATTR_INITIALIZER;

//static __fs_mutex_t    mutex;

void            *fsmutexattr=NULL;

/* if an assert fails into this module this go UP */

int fs_crash=0;

/*

 * used to block all filesystem calls

 */

/*+ state of the fs +*/

/*+ -1: before initialization 0:system calls allowed 1:calls rejected +*/

int              fssysstate=-1;

/*+ number of syscalls in progress +*/

long             fssyscounter=0;

/*+ mutex to update the above two variables +*/

__fs_fastmutex_t fssysmutex;

/*+ syncronization semaphore to change fssysstate from 0 to 1 +*/

__fs_sem_t       fssyssync;

/*+ number of task waiting for fs +*/

long             fssysinitcounter=0;

/*+ syncronization semaphore to change fssysstate from -1 to 0 +*/

__fs_sem_t       fssysinit;

/*

 * variables needed to have a proper filesystem shutdown

 */

/*+ number of module that needs filesystem support +*/

long             needcounter=0;

/*+ syncronization semaphore to start a filesystem shutdown +*/

__fs_sem_t       needsync;

/**

   This is the first function that must be called prior to call

   another function if the filesystem module; it initialize every

   sub-module of the filesystem.

   @memo

   @param ptr

   a pointer to a structure that contains information on how initialize

   the filesystem

   @return

*/

void filesystem_end(void *);

int filesystem_init(FILESYSTEM_PARMS *ptr)

{

  int result;

  int i,fd;

  printk(KERN_INFO "initializing filesystems...");

  printkb("fs_init: START");

  //__fs_mutex_init(&mutex);

  __fs_fastmutex_init(&fssysmutex);

  __fs_sem_init(&fssyssync,0);

  __fs_sem_init(&needsync,0);

  __fs_sem_init(&fssysinit,0);

  fsmutexattr=ptr->fs_mutexattr;

  if (fsmutexattr==NULL) {

    printk(KERN_ERR "filesystem_init failed: mutex attribute not specified!");

    printkb("fs_init: END");

    return -1;

  }

  nextfs=0;

  for (i=0;i<MAXFILESYSTEMS;i++)

    fst[i]=NULL;

  printkb("fs_init: initiating cache...");

  dcache_init();

  printkb("fs_init: initiating supers...");

  super_init();

  printkb("fs_init: initiating inodes...");

  inode_init();

  printkb("fs_init: initiating dentries...");

  dentry_init();

  /*--*/

#ifdef MSDOS_FILESYSTEM

  printkb("fs_init: initiating FAT16 filesystem...");

  msdos_fs_init(ptr);

#endif

  /*--*/

  printkb("fs_init: mounting root...");

  result=mount_root(ptr->device,ptr->fs_ind,ptr->fs_opts);

  if (result!=0) {

    /*if (ptr->fs_showinfo)*/

    printk(KERN_CRIT "Mounting root FAILED! (error: %i)",result);

    /* for safety */

    _assert(result==0);

    printkb("fs_init: END");

    return result;

  }

  /*--*/

  /* must be done after mounting of the root filesystem because

   * the file descriptors table of every process contains a

   * pointer to a 'struct dentry' (the current working directory)

   */

  printkb("fs_init: initiating files...");

  file_init();

  /*--*/

  /* to do better: reserve the first 3 file descriptors for

   * console I/O  

   */

  printkb("fs_init: initiating console descriptors...");

  for (i=0;i<3;i++) {

    fd=get_fd(__get_pid(),(void*)-1);

    if (fd!=i) {

      printk(KERN_CRIT "Can't reserve file descriptor %i for console i/o",fd);

      _assert(fd==i);

      return -1;

    }

  }

  /*--*/

  printkb("fs_init: initiating shutdown routines...");

  sys_atrunlevel(filesystem_end,NULL,RUNLEVEL_SHUTDOWN);  

  /* -- */

  permit_all_fs_calls();

  printkb("fs_init: END");

  return 0;

}

/*+

   This function is used to find what filesystem module manage the

   requested file system indicator

   @memo

   @param fs_ind

   the file system to find

   @return

   the file system struct or NULL in case of error

+*/

struct file_system_type *filesystem_find_byid(BYTE fs_ind)

{

  int i;

  for (i=0;i<nextfs;i++)

    if (fst[i]->fs_ind==fs_ind) return fst[i];

  return NULL;

}

/*+

   This function is used by a filesystem to register itself to the

   filesystem manager; can be called more than one time.

   @memo

   @param ptr

   a pointer to the strutc file\_system\_type of that filesystem

   @return

   @see file\_system\_type

   +*/

int filesystem_register(struct file_system_type *ptr)

{

  if (nextfs==MAXFILESYSTEMS) return -1;

  fst[nextfs]=ptr;

  nextfs++;

  return 0;

}

__uint8_t filesystem_find_byname(char *name)

{

  int i;

  for (i=0;i<nextfs;i++)

    if (!strcmp(name,(char *)fst[i]->name)) return fst[i]->fs_ind;

  return 255;  

}

/* --- */

int mount_root(__dev_t device, __uint8_t fs_ind,

               struct mount_opts *opts)

{

  struct super_block      *sb;

  struct file_system_type *ptr;

  int res;

  printk9("START mount_root()");

  ptr=filesystem_find_byid(fs_ind);

  if (ptr==NULL) {

    printk(KERN_CRIT "mount_root(): errore -2");

    return -2;

  }

  printk9("mount_root(): filesystem type '%s'",ptr->name);

  printk9("mount_root(): filesystem entry at %p",(void *)ptr->read_super);

  printk9("mount_root(): filesystem found");

  res=dcache_lockdevice(device);

  _assert(res!=DCACHE_ERR);

  if (res==DCACHE_FAIL) {

    printk(KERN_CRIT "mount_root(): errore -6");

    return -6;

  }

  printk9("mount_root(): device locked");

  sb=ptr->read_super(device,fs_ind,opts);

  if (sb==NULL) {

    printk(KERN_CRIT "mount_root(): errore -4");

    return -4;

  }

  sb->sb_dev=device;

  sb->sb_fs=ptr;

  sb->sb_parent=NULL;

  sb->sb_childs=NULL;

  sb->sb_next=NULL;

  printk9("mount_root(): super read");

  set_root_superblock(sb);

  res=set_root_dentry(sb);

  if (res) {

    printk(KERN_CRIT "mount_root(): errore -5");

    return -5;

  }

  printk9("mount_root(): root dentry set");

  /* so other task can use this superblock */

  super_release(sb);

  printk9("mount_root(): super available");

  {

    char *n0,*n1;

    bdev_findname(device,&n0,&n1);

    printk(KERN_INFO "mounted %s%c%s (%s) on /",

           n0,DIRDELIMCHAR,n1,

           opts->flags&MOUNT_FLAG_RW?"rw":"ro");

  }

  printk9("END mount_root()");

  return 0;

}

/* --- */

int mount_device(__dev_t device, __uint8_t fs_ind, char *pathname,

                 struct mount_opts *opts)

{

  struct file_system_type *fs;

  struct super_block      *sb,*psb;

  struct dentry           *de;

  int ret,res;

  printk9("START mount_device()");

  fs=filesystem_find_byid(fs_ind);

  if (fs==NULL) {

    printk(KERN_ERR

           "mount_device(): can't find filesystem");

    return -ENODEV;

  }

  de=find_dentry_from(NULL,pathname);

  if (de==NULL) {

    printk(KERN_ERR

           "mount_device(): can't find directory entry");

    return -ENOENT;

  }

  if (!__S_ISDIR(de->d_inode->i_st.st_mode)) {

    printk(KERN_ERR

           "mount_device(): pathname is not a directory");

    unlock_dentry(de);

    return -ENOTDIR;

  }

  res=dcache_lockdevice(device);

  _assert(res!=DCACHE_ERR);

  if (res==DCACHE_FAIL) {

    unlock_dentry(de);

    printk(KERN_ERR "mount_device(): can't lock device");

    return -EBUSY;

  }

  sb=fs->read_super(device,fs_ind,opts);

  if (sb==NULL) {

    unlock_dentry(de);

    printk(KERN_ERR

           "mount_device(): can't read superblock");

    return -EINVAL;

  }

  sb->sb_dev=device;

  sb->sb_fs=fs;

  psb=de->d_sb;

  ret=mount_dentry(sb,de);

  if (ret) {

    unlock_dentry(de);

    super_freeblock(sb);

    printk(KERN_ERR

           "mount_device(): can't associate directory entry with superblock");

    return -EBUSY;    

  }

  /* insert superblock into tree */

  super_insertintotree(sb,psb);

  /* so other task can use this superblock */

  super_release(sb);

  {

    char *n0,*n1;

    bdev_findname(device,&n0,&n1);

    printk(KERN_INFO "mounted %s%c%s (%s) on %s",

           n0,DIRDELIMCHAR,n1,

           opts->flags&MOUNT_FLAG_RW?"rw":"ro",

           pathname);

  }

  printk9("END mount_device()");

  return 0;

}

/*

int mount_device(__dev_t device, __uint8_t fs_ind, char *pathname,

                 struct mount_opts *opts)

{

  int res;

  //__fs_mutex_lock(&mutex);

  res=__mount_device(device,fs_ind,pathname,opts);

  //__fs_mutex_unlock(&mutex);

  return res;

}

*/

int umount_device(__dev_t device)

{

  char path[1024];

  struct super_block *sb;

  int res;

  char *n0,*n1;

  printk9("START umount_device()");

  if (device==get_root_device()) {

    printk9(KERN_ERR

           "umount_device(): can't umount root");

    return -EBUSY;

  }

  sb=super_aquire(device);

  if (sb==NULL) {

    printk9(KERN_ERR

           "umount_device(): can't aquire super block");

    printk(KERN_ERR "can't unmount device 0x%04x",device);

    return -EBUSY;

  }

  printk9("getting pathname");

  /* get names for logging */

  getfullname_dentry(sb->sb_droot,path,sizeof(path));

  bdev_findname(device,&n0,&n1);

  printk9("checking for childs super_blocks");

  if (sb->sb_childs!=NULL) {

    super_release(sb);

    printk9(KERN_ERR

           "umount_device(): super block has childs");

    printk(KERN_ERR "can't unmount %s%c%s from %s",n0,DIRDELIMCHAR,n1,path);

    return -EBUSY;    

  }

  printk9("calling virtual function put_super");

  res=sb->sb_op->put_super(sb);

  if (res!=0) {

    super_release(sb);

    printk9(KERN_ERR

           "umount_device(): can't put_super");

    printk(KERN_ERR "can't unmount %s%c%s from %s",n0,DIRDELIMCHAR,n1,path);

    return -EIO;

  }

  printk9("calling umount_dentry");

  res=umount_dentry(sb);

  if (res!=0) {

    super_release(sb);

    printk9(KERN_ERR

           "umount_device(): can't umount directory tree");

    printk(KERN_ERR "can't unmount %s%c%s from %s",n0,DIRDELIMCHAR,n1,path);

    return -EBUSY;

  }

  /* this is not needed but allows sync of cache with hard-diskes */

  res=dcache_purgedevice(device,0);

  /*

    the dentry has been unmounted so we must continue

  if (res!=0) {

    super_release(sb);

    printk(KERN_ERR

           "umount_device(): can't sync cache with hard-disk");

    return -EIO;

  }

  */

  res=dcache_unlockdevice(device);

  _assert(res!=DCACHE_ERR);

  if (res!=DCACHE_OK) {

    // we must not go here

    _assert(0==-1);

    super_release(sb);

    printk9(KERN_ERR

           "umount_device(): can't unlock device.cache");

    printk(KERN_ERR "can't unmount %s%c%s from %s",n0,DIRDELIMCHAR,n1,path);

    return -EBUSY;

  }

  /* remove superblock from tree */

  super_removefromtree(sb);

  /* free superblock! */

  super_freeblock(sb);

  printk(KERN_INFO "unmounted %s%c%s from %s",n0,DIRDELIMCHAR,n1,path);

  printk9("END umount_device()");

  return EOK;

}

/*

int umount_device(__dev_t device)

{

  int res;

  //__fs_mutex_lock(&mutex);

  res=__umount_device(device);

  //__fs_mutex_unlock(&mutex);

  return res;

}

*/

int umount_root(void)

{

  struct super_block *sb;

  __dev_t device;

  int res;

  char *n0,*n1;

  printk9("START umount_root()");

  device=get_root_device();

  sb=super_aquire(device);

  if (sb==NULL) {

    printk9(KERN_ERR

           "umount_root(): can't aquire super block");

    printk(KERN_ERR "can't unmount device 0x%04x",device);

    return -EBUSY;

  }

  /* get names for logging */

  bdev_findname(device,&n0,&n1);

  printk9("unsetting root");

  set_root_superblock(NULL);  

  set_root_dentry(NULL);

  printk9("calling umount_dentry");

  res=umount_dentry(sb);

  printk9("called umount_dentry");

  if (res!=0) {

    super_release(sb);

    printk9(KERN_ERR

           "umount_root(): can't umount directory tree");

    printk(KERN_ERR "can't unmount %s%c%s from /",n0,DIRDELIMCHAR,n1);

    return -EBUSY;

  }

  printk9("calling virtual function put_super");

  /* */

  res=sb->sb_op->put_super(sb);

  if (res!=0) {

    super_release(sb);

    printk9(KERN_ERR

           "umount_root(): can't put_super");

    printk(KERN_ERR "can't unmount %s%c%s from /",n0,DIRDELIMCHAR,n1);

    return -EIO;

  }

  /* this is not needed but allows sync of cache with hard-diskes */

  res=dcache_purgedevice(device,0);

  if (res!=0) {

    super_release(sb);

    printk9(KERN_ERR

           "umount_root(): can't sync cache with hard-disk");

    printk(KERN_ERR "can't unmount %s%c%s from /",n0,DIRDELIMCHAR,n1);

    return -EIO;

  }

  res=dcache_unlockdevice(device);

  _assert(res!=DCACHE_ERR);

  if (res!=DCACHE_OK) {

    super_release(sb);

    printk9(KERN_ERR

           "umount_root(): can't unlock device.cache");

    printk(KERN_ERR "can't unmount %s%c%s from /",n0,DIRDELIMCHAR,n1);

    return -EBUSY;

  }

  /* free superblock! */

  super_freeblock(sb);

  printk(KERN_INFO "unmounted %s%c%s from /",n0,DIRDELIMCHAR,n1);

  printk9("END umount_root()");

  return EOK;

}

/* -- */

int suspend_fs_shutdown(void)

{

  SYS_FLAGS f;

  _printk0("<ssd%i>",exec_shadow);

  f=kern_fsave();

  if (needcounter==-1) {

    kern_frestore(f);

    _printk0("<ssd%ifail>",exec_shadow);

    return -1;

  }

  needcounter++;

  kern_frestore(f);

  _printk0("<ssd%i,%li>",exec_shadow,needcounter);

  return 0;

}

void resume_fs_shutdown(void)

{

  SYS_FLAGS f;

  _printk0("<rfs%i>",exec_shadow);

  f=kern_fsave();

  needcounter--;

  if (needcounter==0) {

    needcounter=-1;

    kern_frestore(f);      

    _printk0("<rfs%isig>",exec_shadow);

    __fs_sem_signal(&needsync);

    return;

  }

  kern_frestore(f);

}

/*+ wait the initialization of the fs +*/

int wait_for_fs_initialization(void)

{

  int ret=0;

  _printk0("<wfi%i>",exec_shadow);

  __fs_fastmutex_lock(&fssysmutex);

  if (fssysstate==-1) {

    fssysinitcounter++;

    __fs_fastmutex_unlock(&fssysmutex);

    _printk0("<wfi%ib>",exec_shadow);

    __fs_sem_wait(&fssysinit);

    _printk0("<wfi%ir>",exec_shadow);

    return 0;

  } else if (fssysstate==1) ret=-1;

  __fs_fastmutex_unlock(&fssysmutex);

  _printk0("<wfi%i,%i>",exec_shadow,ret);

  return ret;

}

void wait_for_notneed(void)

{

  SYS_FLAGS f;

  f=kern_fsave();

  printkc("fs_shut: needcounter=%li",needcounter);

  if (needcounter>0) {

    printkc("fs_shut%i: synch needed (sem=%i)",exec_shadow,

            internal_sem_getvalue(&needsync));

    kern_frestore(f);

    __fs_sem_wait(&needsync);

    printkc("fs_shut%i: synch OK",exec_shadow);

    return ;

  }

  needcounter=-1;

  kern_frestore(f);

}

/* -- */

static int filecount=0;

static void func2(struct file *f)

{

  filecount++;

  f->f_op->close(f->f_dentry->d_inode,f);

  unlock_dentry(f->f_dentry);

  /* so operations on this file fail */

  f->f_count=0;

  return;

}

static int func(__dev_t device)

{

  int res;

  if (device==get_root_device()) return 0;

  res=umount_device(device);

  if (res) return -1;

  return 0;

}

TASK filesystem_shutdown(void *dummy)

{

  int res;

  printkc("fs_shut%i: START",exec_shadow);

  /*

  for (res=0;res<4*3;res++) {

    cprintf("Û");

    task_delay(250000l);

  }

  printk(KERN_DEBUG "TASK %i",exec_shadow);

  */

  /* wait for modules */

  printkc("fs_shut%i: waiting for modules that use filesystems",exec_shadow);  

  wait_for_notneed();

  /* block all filesystem calls */

  printkc("fs_shut%i: blocking all filesystem system calls",exec_shadow);

  printkc("fs_shut: task into filesystems primitives are %li",fssyscounter);

  block_all_fs_calls();

  /* close all files */

  printkc("fs_shut%i: closing all files",exec_shadow);

  enums_file(func2);

  printkc("fs_shut%i: closed %i files",exec_shadow,filecount);

  /* umount all devices */

  printkc("fs_shut: umounting all devices");

  res=super_enumdevice(func);

  if (res!=0) {

    printk(KERN_INFO "filesystems shutdown aborted!");

    printkc("fs_shut: ABORTING");

    return (void*)-1;

  }

  /* umount root device */

  printkc("fs_shut: umount root");

  res=umount_root();

  if (res!=0) {

    char *n0,*n1;

    bdev_findname(get_root_device(),&n0,&n1);

    printk(KERN_ERR "can't unmount %s%c%s from /",n0,DIRDELIMCHAR,n1);

    printk(KERN_INFO "filesystems shutdown aborted!");

    printkc("fs_shut: ABORTING");

    return (void*)-1;

  }

  //sys_status(SCHED_STATUS);

  printkc("fs_shut: END");

  return (void*)0;

}

void filesystem_end(void *dummy)

{

  SOFT_TASK_MODEL model;

  PID pid;

  printkc("fs_end: START");

  if (fs_crash) {

    printkc("fs_end: END");

    return;

  }

  printk(KERN_INFO "shuting down filesystems...");

  //nrt_task_default_model(model);

  //nrt_task_def_system(model);

  soft_task_default_model(model);

  soft_task_def_system(model);

  soft_task_def_notrace(model);

  soft_task_def_periodic(model);

  soft_task_def_period(model,50000);

  soft_task_def_met(model,10000);

  soft_task_def_wcet(model,10000);

  pid=task_create("ShutFS",filesystem_shutdown,&model,NULL);

  if (pid==-1)

    printk(KERN_ERR "can't start filesystem shutdown task");

  else {

    printkc("fs_end: shutting down task %i activated",pid);

    task_activate(pid);

  }

  printkc("fs_end: END");

}