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: inode.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/util.h>

#include <fs/magic.h>

#include <fs/assert.h>

#include "fs.h"

#include "dentry.h"

#include "inode.h"

#include "inodeop.h"

#include "mutex.h"

#include "super.h"

#include "superop.h"

#include "debug.h"

#define MAXHASH     64

#define MAXHASHMASK 0x3f

static struct inode *ihash[MAXHASH];

static __fs_mutex_t hashmutex;

/* WARNING: must be greather than MAXDENTRY */

#define MAXINODES 256

static __fs_mutex_t mutex;

static struct inode *freeinode;

static struct inode ino[MAXINODES];

#ifdef FSMUTEXCHECK

void debug_dump_inode_mutex(void)

{

  //printk(KERN_DEBUG "inode mutex: %i",(int)mutex);

  //printk(KERN_DEBUG "inode mutex hasm: %i",(int)hashmutex);

}

static __fs_mutex_t regmutex;

static __fs_mutex_t reghashmutex;

int debug_check_inode_mutex(void)

{

  /*

  if (mutex!=regmutex) {

    printk(KERN_DEBUG "inode mutex CHANGED!");

    return 0;

  }

  if (hashmutex!=reghashmutex) {

    printk(KERN_DEBUG "inode hasmmutex CHANGED!");

    return 0;

  }

  */

  return -1;

}

void debug_save_inode_mutex(void)

{

  regmutex=mutex;

  reghashmutex=hashmutex;

}

#endif

/* WARNIG: if you want to aquire "mutex" and "hashmutex" you MUST

 * aquire first "hashmutex" and then "mutex" (if you do not want

 * a deadlock)

 */

void inode_stats(void)

{

  struct inode *ptr;

  int c,i,l,d;

  __fs_mutex_lock(&hashmutex);

  __fs_mutex_lock(&mutex);

  printk(KERN_INFO "max inodes:        %4i",MAXINODES);

  c=0;

  ptr=freeinode;

  while (ptr!=NULL) {

    c++;

    ptr=ptr->i_next;

  }

  printk(KERN_INFO "  free inodes:     %4i",c);

  for (i=0,l=0,c=0,d=0;i<MAXHASH;i++) {

    ptr=ihash[i];

    while (ptr!=NULL) {

      c++;

      if (ptr->i_dlink!=0) l++;

      if (ptr->i_dirty) d++;

      ptr=ptr->i_next;

    }

  }

  printk(KERN_INFO "  cached inodes:   %4i",c);

  printk(KERN_INFO "    linked inodes: %4i",l);

  printk(KERN_INFO "    dirty inodes:  %4i",d);

  __fs_mutex_unlock(&mutex);

  __fs_mutex_unlock(&hashmutex);

}

int inode_init(void)

{

  int i;

  __fs_mutex_init(&mutex);

  __fs_mutex_init(&hashmutex);

#ifdef FSMUTEXCHECK

  debug_save_inode_mutex();

#endif

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

    /* for safety */

    memset(ino+i,0,sizeof(struct inode));

    magic_clr(ino[i].magic);

    __rwlock_init(&ino[i].i_lock);

    ino[i].i_next=&ino[i+1];    

  }

  freeinode=&ino[0];

  ino[MAXINODES-1].i_next=NULL;

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

    ihash[i]=NULL;

  return 0;

}

static struct inode *__get_inode(void)

{

  struct inode *ptr;

  //if (debug_info) cprintf("__get_inode start\n");

  ptr=freeinode;

  if (freeinode!=NULL) freeinode=freeinode->i_next;

  //if (debug_info) cprintf("__get_inode middle\n");

  if (ptr!=NULL) {

    //if (debug_info) cprintf("__get_inode assert\n");

    magic_assert_ext(ptr->magic,ZERO_MAGIC,inode_stats,

                 "inode_get: inode MAGIC number failed!\n");

    //magic_assert(ptr->magic,ZERO_MAGIC,

    //                  "inode_get: inode MAGIC number failed!\n");

    //if (debug_info) cprintf("__get_inode assert ok\n");

    magic_set(ptr->magic,INODE_MAGIC);

    //if (debug_info) cprintf("__get_inode magic setted\n");

  }

  //if (debug_info) cprintf("__get_inode end\n");

  return ptr;

}

struct inode *get_inode(void)

{

  struct inode *ptr;

  __fs_mutex_lock(&mutex);

  ptr=__get_inode();

  __fs_mutex_unlock(&mutex);  

  return ptr;

}

void free_inode(struct inode *ptr)

{

  magic_assert_ext(ptr->magic,INODE_MAGIC,inode_stats,

               "inode_free: inode MAGIC number failed!\n");

  magic_clr(ptr->magic);

  __fs_mutex_lock(&mutex);

  ptr->i_next=freeinode;

  freeinode=ptr;

  __fs_mutex_unlock(&mutex);

}

/*-------*/

static int hash_fun(__dev_t device, __ino_t inode)

{

  static __uint32_t table[8]={3,5,7,11,13,17,19,23};

  return (table[device&0x07]*(inode+1))&MAXHASHMASK;

}

void __insert_inode(struct inode *ptr)

{

  int h;

  magic_assert_ext(ptr->magic,INODE_MAGIC,inode_stats,

               "inode_insert: inode MAGIC number failed!\n");

  /* these could be done with no mutex syncronization */

  h=hash_fun(ptr->i_st.st_dev,ptr->i_st.st_ino);

  ptr->i_hash=h;

  ptr->i_prev=NULL;

  /* these NO */

  ptr->i_next=ihash[h];

  if (ihash[h]!=NULL) ihash[h]->i_prev=ptr;

  ihash[h]=ptr;

  ptr->i_dlink=1;

}

void insert_inode(struct inode *ptr)

{  

  __fs_mutex_lock(&hashmutex);

  __insert_inode(ptr);

  __fs_mutex_unlock(&hashmutex);

}

static void __remove_inode(struct inode *ptr)

{

  magic_assert_ext(ptr->magic,INODE_MAGIC,inode_stats,

               "inode_remove: inode MAGIC number failed!\n");

  if (ptr->i_next!=NULL) ptr->i_next->i_prev=ptr->i_prev;

  if (ptr->i_prev!=NULL) ptr->i_prev->i_next=ptr->i_next;

  else ihash[ptr->i_hash]=ptr->i_next;

}

void remove_inode(struct inode *ptr)

{  

  __fs_mutex_lock(&hashmutex);

  _assert(ptr->i_dlink==0);

  __remove_inode(ptr);

  __fs_mutex_unlock(&hashmutex);

}

static struct inode *__purge_inode(void)

{

  struct inode *ptr;

  int i;

  /* Well, this can be implemented better; actually a scan for the

   * unused inode into the buckets is done.

   * (for examples the unused inodes can be mantained into an unused

   * queue)

   */

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

    ptr=ihash[i];

    while (ptr!=NULL) {

      if (ptr->i_dlink==0) {

        __remove_inode(ptr);

        return ptr;

      }

      ptr=ptr->i_next;

    }

  }

  return NULL;

}

/* find & remove the oldest dentry from the tree */

/*

static struct inode *purge_inode(void)

{

  struct inode *act;

  __fs_mutex_lock(&hashmutex);

  act=__purge_inode();  

  __fs_mutex_unlock(&hashmutex);

  return act;

}

*/

static struct inode *__catch_inode(void)

{

  struct inode *ptr;

  //if (debug_info) cprintf("get\n");

  ptr=get_inode(); /* aquiring "mutex" is required!! don't call __get_inode */

  if (ptr==NULL) {

    //if (debug_info) cprintf("get FAIL\n");

    ptr=__purge_inode();

    //if (debug_info) cprintf("catch\n");

    if (ptr==NULL) {

      //if (debug_info) cprintf("catch FAIL\n");

    }

  }

  return ptr;

}

/* get an inode by searching into the free space or purging an old one */

struct inode *catch_inode(void)

{

  struct inode *ptr;

  //if (debug_info) cprintf("catch called\n");

  __fs_mutex_lock(&hashmutex);

  //if (debug_info) cprintf("calling __catch...\n");

  ptr=__catch_inode();

  //if (debug_info) cprintf("__catch exiting\n");

  __fs_mutex_unlock(&hashmutex);

  return ptr;

}

struct inode *find_inode(__dev_t device, __ino_t ino)

{

  struct inode *ptr;

  int h;

  //h=hash_fun(ptr->i_st.st_dev,ptr->i_st.st_ino);

  h=hash_fun(device,ino);

  __fs_mutex_lock(&hashmutex);

  ptr=ihash[h];

  while (ptr!=NULL) {

    if (ptr->i_st.st_dev==device&&ptr->i_st.st_ino==ino) {

      ptr->i_dlink++;

      break;

    }

    ptr=ptr->i_next;

  }

  if (ptr==NULL) {

    ptr=__catch_inode();

    if (ptr!=NULL) {

      ptr->i_st.st_dev=device;

      ptr->i_st.st_ino=ino;

      __insert_inode(ptr);      

    }

  } else

    magic_assert_ext(ptr->magic,INODE_MAGIC,inode_stats,

                 "find_inode: inode MAGIC number failed!\n");

  __fs_mutex_unlock(&hashmutex);

  return ptr;  

}

/* unlock inode */

void unlock_inode(struct inode *ptr)

{

  magic_assert_ext(ptr->magic,INODE_MAGIC,inode_stats,

               "unlock_inode: inode MAGIC number failed!\n");

  __fs_mutex_lock(&hashmutex);

  _assert(ptr->i_dlink>0);  

  ptr->i_dlink--;

  __fs_mutex_unlock(&hashmutex);

}

/* unlock & remove inode from hash table */

int destroy_inode(struct inode *ptr)

{

  int ret;

  magic_assert_ext(ptr->magic,INODE_MAGIC,inode_stats,

                   "unlock_inode: inode MAGIC number failed!\n");

  __fs_mutex_lock(&hashmutex);

  _assert(ptr->i_dlink>0);  

  if (ptr->i_dlink!=1) {

    __fs_mutex_unlock(&hashmutex);

    return -1;

  }

  if (ptr->i_dirty) {

    ret=ptr->i_sb->sb_op->write_inode(ptr);

    if (ret!=0) {

      __fs_mutex_unlock(&hashmutex);

      return -1;

    }

  }

  ptr->i_dlink--;

  __remove_inode(ptr);

  __fs_mutex_unlock(&hashmutex);

  return 0;

}

/* unlock, remove the inode from the hast table

 * erase inode on disk

 */

int erase_inode(struct inode *ptr)

{

  int ret;

  magic_assert_ext(ptr->magic,INODE_MAGIC,inode_stats,

                   "erase_inode: inode MAGIC number failed!\n");

  __fs_mutex_lock(&hashmutex);

  _assert(ptr->i_dlink>0);

  if (ptr->i_dlink!=1) {

    __fs_mutex_unlock(&hashmutex);

    return -1;

  }

  ptr->i_op->destroy(ptr);

  ret=ptr->i_sb->sb_op->delete_inode(ptr);

  if (ret==0) {

    ptr->i_dlink--;

    __remove_inode(ptr);

  }

  __fs_mutex_unlock(&hashmutex);

  return ret;

}