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: super.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/sysmacro.h>
#include <fs/util.h>
#include <fs/major.h>
#include <fs/fsinit.h>
#include <fs/bdev.h>
#include <fs/fsind.h>
#include <fs/mount.h>
#include <fs/assert.h>

#include "mutex.h"
#include "fs.h"
#include "super.h"

#define MAXSUPERBLOCKS 8
static __fs_mutex_t mutex;
static __fs_mutex_t mutexsb;
static struct super_block sbs[MAXSUPERBLOCKS];

static struct super_block *root_superblock=NULL;

int super_init(void)
{
  int i;
 
  __fs_mutex_init(&mutex);
  __fs_mutex_init(&mutexsb);

  for (i=0;i<MAXSUPERBLOCKS;i++) {
    memset(sbs+i,0,sizeof(struct super_block));
    mount_std_parms(sbs[i].sb_mopts);
    sbs[i].sb_busycount=0;
    sbs[i].sb_used=0;
    sbs[i].sb_blocked=0;
  }

  return 0;
}

struct super_block *super_getblock(void)
{
  struct super_block *ptr=NULL;
  int i;

  __fs_mutex_lock(&mutexsb);
  for (i=0;i<MAXSUPERBLOCKS;i++)
    if (!sbs[i].sb_used) {
      sbs[i].sb_used=1;
      sbs[i].sb_blocked=1;
      sbs[i].sb_busycount=0;
      ptr=sbs+i;
      break;
    }
  __fs_mutex_unlock(&mutexsb);

  return ptr;
}

void super_freeblock(struct super_block *ptr)
{
  __fs_mutex_lock(&mutexsb);
  _assert(ptr->sb_used==1);
  _assert(ptr->sb_blocked==1);
  _assert(ptr->sb_busycount==0);
  ptr->sb_used=0;
  __fs_mutex_unlock(&mutexsb);
}

/* --- */

struct super_block *get_root_superblock(void)
{
  _assert(root_superblock!=NULL);
  return root_superblock;
}

void set_root_superblock(struct super_block *sb)
{
  __fs_mutex_lock(&mutex);
  if (sb==NULL) {
    _assert(root_superblock!=NULL);
    root_superblock=NULL;
    __fs_mutex_unlock(&mutex);
    return;
  }
  _assert(root_superblock==NULL);
  __fs_mutex_unlock(&mutex);
  root_superblock=sb;
}

/* --- */

int super_incbusy(struct super_block *sb)
{
  int ret=-1;
 
  _assert(sb>=sbs&&sb<sbs+MAXSUPERBLOCKS);
 
  __fs_mutex_lock(&mutex);
 
  if (sb->sb_blocked==0) {
    ret=0;
    sb->sb_busycount++;
  }
 
  __fs_mutex_unlock(&mutex);
 
  return ret;
}

void super_decbusy(struct super_block *sb)
{
  _assert(sb>=sbs&&sb<sbs+MAXSUPERBLOCKS);
 
  __fs_mutex_lock(&mutex);
 
  _assert(sb->sb_busycount>0);
  _assert(sb->sb_blocked==0);

  sb->sb_busycount--;
 
  __fs_mutex_unlock(&mutex);
}

struct super_block *super_aquire(__dev_t dev)
{
  struct super_block *ptr=NULL;
  int i;
 
  __fs_mutex_lock(&mutex);
 
  for (i=0;i<MAXSUPERBLOCKS;i++) {
    if (sbs[i].sb_used==1&&sbs[i].sb_dev==dev) {
      if (sbs[i].sb_blocked==1||sbs[i].sb_busycount!=0) break;      
      sbs[i].sb_blocked=1;
      ptr=sbs+i;
      break;
    }
  }
  __fs_mutex_unlock(&mutex);
  return ptr;
}

void super_release(struct super_block *sb)
{
  _assert(sb>=sbs&&sb<sbs+MAXSUPERBLOCKS);
  __fs_mutex_lock(&mutex);
  _assert(sb->sb_used==1&&sb->sb_blocked==1);
  sb->sb_blocked=0;
  __fs_mutex_unlock(&mutex);
}

/* -- */

void super_insertintotree(struct super_block *sb, struct super_block *psb)
{
  __fs_mutex_lock(&mutex);
  sb->sb_parent=psb;
  sb->sb_next=psb->sb_childs;
  sb->sb_childs=NULL;
  psb->sb_childs=sb;
  __fs_mutex_unlock(&mutex);
}

void super_removefromtree(struct super_block *sb)
{
  struct super_block *ptr,*prev;
  ptr=sb->sb_parent->sb_childs;
  prev=NULL;
  __fs_mutex_lock(&mutex);
  while (ptr!=sb) {
    prev=ptr;
    ptr=ptr->sb_next;
    _assert(ptr!=NULL);
  }
  if (prev!=NULL) prev->sb_next=sb->sb_next;
  else sb->sb_parent->sb_childs=sb->sb_next;
  __fs_mutex_unlock(&mutex);
}

static int visittree(struct super_block *sb,int(*func)(__dev_t))
{
  struct super_block *ptr;
  ptr=sb->sb_childs;
  while (ptr!=NULL) {
    if (visittree(ptr,func)) return -1;
    ptr=ptr->sb_next;
  }
  return (*func)(sb->sb_dev);
}

/* can be called only during shutdown!
 * (there must be no lock on superblocks tree during shutdown)
 * (the shutdown function is responsable not to call the
 * insert/remove_to/from tree functions)
 */

int super_enumdevice(int(*func)(__dev_t))
{
  int res;
  res=visittree(root_superblock,func);
  return res;
}