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: dentry.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/types.h>

#include <fs/assert.h>

#include "fs.h"

#include "super.h"

#include "superop.h"

#include "dentry.h"

#include "dentryop.h"

#include "inode.h"

#include "inodeop.h"

#include "fsconst.h"

#include "mutex.h"

#include "debug.h"

/*

 * DEBUG

 */

/* if defined:

 * a short message is printed on console when a task go in/out of

 * functions dentry_find() & dentry_unlock()

 * (after  and before the lock/unlock of the mutex!)

 */

#define DEBUGFINDUNLOCK KERN_DEBUG

#undef DEBUGFINDUNLOCK

#ifdef DEBUGFINDUNLOCK

#define printdd(fmt,pid) kern_printf(fmt,pid)

#else

#define printdd(fmt,pid)

#endif

/* if you modify this you must modify MAXINODE */

#define MAXDENTRY 128

static __fs_mutex_t mutex;

static __fs_fastmutex_t mutexreq;

static struct dentry *freelist;

//static struct dentry *leaflist;

static struct dentry direntry[MAXDENTRY];

static struct dentry *root_direntry=NULL;

#ifdef FSMUTEXCHECK

void debug_dump_dentry_mutex(void)

{

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

  //printk(KERN_DEBUG "dentry mutex req: %i",(int)mutexreq);

}

//static __fs_mutex_t regmutex;

//static __fs_mutex_t regmutexreq;

int debug_check_dentry_mutex(void)

{

  /*

  if (mutex!=regmutex) {

    printk(KERN_DEBUG "dentry mutex CHANGED! (prev: %i)",regmutex);

    return 0;

  }

  if (mutexreq!=regmutexreq) {

    printk(KERN_DEBUG "dentry mutexreq CHANGED! (prev: %i)",regmutexreq);

    return 0;

  }

  */

  return -1;

}

void debug_save_dentry_mutex(void)

{

  //regmutex=mutex;

  //regmutexreq=mutexreq;

}

#endif

int dentry_init(void)

{

  int i;

  __fs_mutex_init(&mutex);

  __fs_fastmutex_init(&mutexreq);

#ifdef FSMUTEXCHECK

  debug_save_dentry_mutex();

#endif

  freelist=direntry;

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

    memset(direntry+i,0,sizeof(struct dentry));

    magic_set(direntry[i].magic,DENTRY_MAGIC);

    direntry[i].d_next=direntry+i+1;

    direntry[i].d_lock=-1;

  }

  direntry[MAXDENTRY-1].d_next=NULL;

  return 0;

}

static __inline__ struct dentry *__get_dentry(void)

{

  struct dentry *den;

  if (freelist==NULL) return NULL;    

  den=freelist;

  freelist=den->d_next;

  _assert(den->d_lock==-1);

  magic_assert(den->magic,DENTRY_MAGIC,"get_dentry: dentry MAGIC failed!");

  den->d_lock=0;

  return den;

}

/* get a dentry from the free queue */

struct dentry *get_dentry(void)

{

  struct dentry *den;

  __fs_fastmutex_lock(&mutexreq);

  den=__get_dentry();

  __fs_fastmutex_unlock(&mutexreq);

  return den;

}

static __inline__ void __free_dentry(struct dentry *den)

{

  _assert(den>=direntry&&den<direntry+MAXDENTRY);

  _assert(den->d_lock==0);

  magic_assert(den->magic,DENTRY_MAGIC,"free_dentry: dentry MAGIC failed!");

  den->d_lock=-1;

  den->d_next=freelist;

  freelist=den;

}

/* insert dentry into the free queue */

void free_dentry(struct dentry *den)

{

  __fs_fastmutex_lock(&mutexreq);

  __free_dentry(den);

  __fs_fastmutex_unlock(&mutexreq);

}

static void __insert_dentry(struct dentry *den, struct dentry *parent)

{

  _assert(den>=direntry&&den<direntry+MAXDENTRY);

  magic_assert(den->magic,DENTRY_MAGIC,"insert_dentry: dentry MAGIC failed!");

  den->d_acc=gettimek();

  den->d_parent=parent;

  den->d_child=NULL;

  den->d_prev=NULL;

  den->d_next=parent->d_child;

  if (parent->d_child!=NULL)

    parent->d_child->d_prev=den;

  parent->d_child=den;

}

/* insert a dentry into the tree */

void insert_dentry(struct dentry *den, struct dentry *parent)

{

  __fs_mutex_lock(&mutex);

  __insert_dentry(den,parent);

  __fs_mutex_unlock(&mutex);

}

static void __remove_dentry_only(struct dentry *den)

{

  _assert(den>=direntry&&den<direntry+MAXDENTRY);

  magic_assert(den->magic,DENTRY_MAGIC,"remove_dentry: dentry MAGIC failed!");

  _assert(den->d_lock==0);

  if (den->d_prev!=NULL)

    den->d_prev->d_next=den->d_next;

  else

    den->d_parent->d_child=den->d_next;

  if (den->d_next!=NULL)

    den->d_next->d_prev=den->d_prev;

}

static __inline__ void __remove_dentry(struct dentry *den)

{

  __remove_dentry_only(den);

  unlock_inode(den->d_inode);  

}

/* remove a dentry from the tree */

void remove_dentry(struct dentry *den)

{

  __fs_mutex_lock(&mutex);

  __remove_dentry(den);

  __fs_mutex_unlock(&mutex);

}

/* find the oldest dentry into the tree */

/*

 * (potrebbe essere fatto in maniera non ricorsiva usando un

 * puntatore alle foglie e scandendo questa lista invece di visitare

 * tutto l'albero!)

 *

 * si potrebbe usare un task NRT periodico per mantenere liberi (se

 * possibile l'X% delle dentry libere.

 */

static struct dentry *__recurse(struct dentry *den, struct dentry *act)

{

  while (den!=NULL) {    

    if (den->d_child!=NULL) {

      act=__recurse(den->d_child,act);

    } else {

      if (den->d_lock==0) {

        if (act==NULL)

          act=den;

        else {

          if (den->d_acc<act->d_acc)

            act=den;

        }

      }      

    }

    den=den->d_next;

  }

  return act;

}

struct dentry *__purge_dentry(void)

{

  struct dentry *act;

  act=__recurse(root_direntry,NULL);

  if (act!=NULL) __remove_dentry(act);

  return act;

}

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

struct dentry *purge_dentry(void)

{

  struct dentry *act;

  __fs_mutex_lock(&mutex);

  act=__purge_dentry();  

  __fs_mutex_unlock(&mutex);

  return act;

}

struct dentry *__catch_dentry(void)

{

  struct dentry *den;

  den=__get_dentry();

  if (den==NULL) den=__purge_dentry();

  return den;

}

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

/*

static struct dentry *catch_dentry(void)

{

  struct dentry *den;

  __fs_mutex_lock(&mutex);

  den=__catch_dentry();  

  __fs_mutex_unlock(&mutex);

  return den;

}

*/

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

int set_root_dentry(struct super_block *sb)

{

  struct dentry *den;

  __fs_mutex_lock(&mutex);

  if (sb==NULL) {

    _assert(root_direntry!=NULL);

    root_direntry->d_lock--;

    _assert(root_direntry->d_lock==1);

    root_direntry=NULL;

    __fs_mutex_unlock(&mutex);

    return 0;

  }

  _assert(root_direntry==NULL);

  __fs_mutex_unlock(&mutex);

  den=get_dentry();

  if (den==NULL) return -1;

  den->d_next=NULL;

  den->d_prev=NULL;

  den->d_parent=NULL;

  den->d_child=NULL;

  den->d_acc=0;

  den->d_name.nameptr=ROOTDIRNAME;

  den->d_op=sb->sb_dop;

  den->d_sb=sb;

  den->d_inode=sb->sb_root;

  den->d_lock=1;

  sb->sb_droot=den;

  root_direntry=den;

  return 0;

}

struct dentry *get_root_dentry(void)

{

  _assert(root_direntry!=NULL);

  return root_direntry;

}

#ifdef DEBUG_FIND_DUMP

static void dump_dentry(struct dentry *ptr)

{

  printk7(KERN_DEBUG "dentry dump:");

  printk7(KERN_DEBUG "  name : %s",QSTRNAME(&ptr->d_name));

  printk7(KERN_DEBUG "  lock : %i",ptr->d_lock);

  printk7(KERN_DEBUG "  inode: %i",ptr->d_inode->i_st.st_ino);

}

#else

#define dump_dentry(x)

#endif

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

/*

 * flags for createflags:

 * DENTRY_NOCREATE   -> can't create a new inode

 * DENTRY_CANCREATE  -> an inode (only the last) can be created

 * DENTRY_MUSTCREATE -> the last inode MUST be created (it must no exist)

 *

 * return flags for createflags:

 * DENTRY_CREATED -> the last inode has been created

 * DENTRY_EXIST   -> (error) the last inode already exist

 *

 * return NULL on error (not found or DENTRY_EXIST)

 *

 * NB:

 * if createflag is NULL a DENTRY_NOCREATE is assumed

 * 'act' can be NULL if pathname is an absolute path

 */

struct dentry *find_dentry_from_ext(struct dentry *act,

                                    char *pathname,

                                    int *createflag)

{

  struct dentry *ptr;

  struct dentry *den;

  struct inode *ino;

  struct qstr str;

  char *sp;

  char *s;

  int  found,created;

  /* too much 'goto' :-( and 'if' */

  sp=pathname;

  if (*pathname==DIRDELIMCHAR) {

    act=root_direntry;

    sp++;

  }

  if (act==NULL) return NULL;

  printdd("°f<%i>",exec_shadow);

  __fs_mutex_lock(&mutex);

  printdd("±f<%i>",exec_shadow);

  if (*sp=='\0') goto END0;

  created=0;

  found=1;

  while (found) {

    s=strchr(sp,DIRDELIMCHAR);

    if (s!=NULL) *s='\0';

    printk7("dentry find: searching for %s...",sp);

    /* for handle special directory entry "." and ".." */

    if (*sp=='.') {

      if (*sp=='\0') {

        /* found "." special directory */

        printk7("dentry find: special directory entry '.'");

        found=1;

        if (s==NULL) goto END0;

        *s=DIRDELIMCHAR;

        sp=s+1;

        s=strchr(sp,DIRDELIMCHAR);

        continue;      

      }

      if (*sp=='.') {

        if (*sp=='\0') {

          /* found ".." special directory */

          printk7("dentry find: special directory entry '..'");

          found=1;

          if (act->d_parent!=NULL) act=act->d_parent;

          if (s==NULL) goto END0;

          *s=DIRDELIMCHAR;

          sp=s+1;

          s=strchr(sp,DIRDELIMCHAR);

          continue;    

        }      

      }

    }

    ptr=act->d_child;

    found=0;

    str.nameptr=sp;

    while (ptr!=NULL) {

      if (ptr->d_op->d_compare(ptr,&ptr->d_name,&str)==0) {

        printk7("dentry find: found!");

        found=1;

        act=ptr;

        if (s==NULL) goto END0;

        *s=DIRDELIMCHAR;

        sp=s+1;

        s=strchr(sp,DIRDELIMCHAR);

        break;

      }

      ptr=ptr->d_next;

    }        

  }

  printk7("dentry find: NOT found!");

  for (;;) {

    den=__catch_dentry();

    if (den==NULL) {

      if (s!=NULL) *s=DIRDELIMCHAR;

      printk7("dentry find: can't have new struct dentry!");

      act=NULL;

      goto END1;

    }

    den->d_acc=0;

    den->d_name.nameptr=NULL;

    strcpy(den->d_name.name,sp);

    den->d_lock=0;

    den->d_op=act->d_op;

    den->d_sb=act->d_sb;

    printk7("dentry find: looking up for %s....",sp);

    dump_dentry(act);

    ino=act->d_inode->i_op->lookup(act->d_inode,den);

    printk7("dentry find: end looking");

    if (ino==NULL) {

      printk7("dentry find: NOT found!");

      if (s!=NULL) *s=DIRDELIMCHAR;      

      if (createflag==NULL) {

        __free_dentry(den);

        act=NULL;

        goto END1;

      }

      if ((s==NULL)&&(*createflag&DENTRY_CANCREATE)) {

        printk7("dentry find: check for read-only fs");

        if (!(act->d_sb->sb_mopts.flags&MOUNT_FLAG_RW)) {

          printk7("dentry find: read-only fs.. creating new inode fails");

          __free_dentry(den);

          act=NULL;

          goto END1;

        }

        printk7("dentry find: try to create a new inode");

        ino=act->d_inode->i_op->create(act->d_inode,den);

        if (ino==NULL) {  

          printk7("dentry find: inode creation fail");

          __free_dentry(den);

          act=NULL;

          goto END1;

        }

        printk7("dentry find: new inode created");

        created=1;

      } else {

        __free_dentry(den);

        act=NULL;

        goto END1;

      }

    }

    den->d_inode=ino;

    insert_inode(ino);  

    printk7("dentry find: found!");

    __insert_dentry(den,act);

    act=den;

    if (s==NULL) goto END2;

    sp=s+1;

    *s=DIRDELIMCHAR;    

    s=strchr(sp,DIRDELIMCHAR);

    if (s!=NULL) *s='\0';

  }

  /* for safety */

  _assert(0==-1);

END0:

  /* 'if found' we are here */

  if (createflag!=NULL) {

    *createflag&=~DENTRY_CREATEMASK;

    if (*createflag&DENTRY_MUSTCREATE) {

      _assert(act!=NULL);

      *createflag|=DENTRY_EXIST;

      act=NULL;

    }

  }

  goto END;

END1:

  /* 'if error' we are here */

  _assert(act==NULL);

  if (createflag!=NULL) *createflag&=~DENTRY_CREATEMASK;

  goto END;

END2:

  /* 'if ok' (found or created) we are here */

  _assert(act!=NULL);

  if (createflag!=NULL) {

    if (created) {

      *createflag&=~DENTRY_CREATEMASK;           

      *createflag|=DENTRY_CREATED;

    } else if ((*createflag&DENTRY_MUSTCREATE)==DENTRY_MUSTCREATE) {

      *createflag&=~DENTRY_CREATEMASK;           

      *createflag|=DENTRY_EXIST;

      act=NULL;

    } else

      *createflag&=~DENTRY_CREATEMASK;                   

  }

  goto END;    

END:

  if (act!=NULL) act->d_lock++;

  printdd("²f<%i>",exec_shadow);

  __fs_mutex_unlock(&mutex);

  printdd("Ûf<%i>",exec_shadow);

  return act;

}

void unlock_dentry(struct dentry *den)

{

  printdd("°u<%i>",exec_shadow);

  __fs_mutex_lock(&mutex);

  printdd("±u<%i>",exec_shadow);

  _assert(den>=direntry&&den<direntry+MAXDENTRY);

  if (den->d_lock<=0) {

    printk(KERN_DEBUG "unlock_dentry on %s",QSTRNAME(&den->d_name));

  }

  _assert(den->d_lock>0);

  den->d_lock--;

  //if (den->d_lock==0) {

  //  _assert(den->d_inode!=NULL);

  //  unlock_inode(den->d_inode);

  //}

  printdd("²u<%i>",exec_shadow);

  __fs_mutex_unlock(&mutex);

  printdd("Ûu<%i>",exec_shadow);

}

/*

 *

 */

static void __print_name(struct dentry *act,char *buffer)

{

  if (act->d_parent==NULL) return;

  __print_name(act->d_parent,buffer);

  strcat(buffer,ROOTDIRNAME);

  strcat(buffer,QSTRNAME(&act->d_name));

  return;

}

static char *print_name(struct dentry *act)

{

  static char buffer[1024];

  buffer[0]='\0';

  __print_name(act,buffer);

  return buffer;

}

void getfullname_dentry(struct dentry *act, char *buffer, int size)

{

  _assert(act>=direntry&&act<direntry+MAXDENTRY);

  magic_assert(act->magic,DENTRY_MAGIC,

               "getfullname_dentry: dentry MAGIC failed!");

  buffer[0]='\0';

  __print_name(act,buffer);

  _assert(strlen(buffer)<size);

}

static void visit_tree(struct dentry *act)

{

  struct dentry *ptr;

  if (act==root_direntry) printk(KERN_DEBUG "  %s",ROOTDIRNAME);

  else { char *s=print_name(act); printk(KERN_DEBUG "  %s",s);}

  ptr=act->d_child;

  while (ptr!=NULL) {

    visit_tree(ptr);

    ptr=ptr->d_next;

  }

  return;

}

void dump_dentry_tree(void)

{

  printk(KERN_DEBUG "DTREE dump");

  visit_tree(root_direntry);

}

/*

 *

 */

#ifdef DEBUGPURGECHILD

#define dprint(fmt,args...) printk(fmt,##args)

#else

#define dprint(fmt,args...)

#endif

static __inline__ int __purgeallchilds_mg(struct dentry *de)

{

  int ret;

  struct dentry *ptr,*ptr2,*ptr3;

  dprint(KERN_DEBUG "START mg purgechild");

  {

#ifdef DEBUGPURGECHILD

    char *s=print_name(de);

    dprint(KERN_DEBUG "for %s",s);

#endif

  }

  /*

   * Phase 1

   * purge all childs (if possible!)

   */

  ptr=de->d_child;

  ret=0;

  /* why these? I do not want to use recursion... (or goto statement)*/

  for (;;) {

    /* if there is a child... continue using the child's chain */

    if (ptr->d_child!=NULL) {

      ptr=ptr->d_child;

      continue;      

    }    

    /* if a child dentry is locked... can't continue! */

    if (ptr->d_lock) {

      #ifdef DEBUGPURGECHILD

      char *s=print_name(ptr);

      dprint(KERN_DEBUG "%s is locked!!!",s);

      #endif

      ret=-1;

      break;

    }

    /* purge this dentry */

    ptr2=ptr->d_next;

    ptr3=ptr->d_parent;

    dprint(KERN_DEBUG "%s destroy",QSTRNAME(&ptr->d_name));

    ret=destroy_inode(ptr->d_inode);

    if (ret) break;

    __remove_dentry_only(ptr);

    /* if there is not another child... continue with the parent */

    if (ptr2==NULL) {

      ptr=ptr3;

      if (ptr==de) break;

      continue;

    }

    /* continue with next child */

    ptr=ptr2;

  }

  dprint(KERN_DEBUG "END mg purgechild");  

  return ret;

}

static __inline__ int __purgeallchilds_pj(struct dentry *x)

{

  struct dentry *p,*q;

  dprint(KERN_DEBUG "START pj purgechild");

  p = x->d_child;

  q = NULL;

  for(;;) {

    /* scorro i figli */

    while(p) {

      q = p;

      p = p->d_next;

    }

    if (q == x) {

      dprint(KERN_DEBUG "END pj purgechild");  

      return 0; /* finito */

    }

    if (q->d_child) {

      p = q->d_child;

      q = NULL;

    }

    else {

      /* sono su un nodo senza figli */

      /* q punta al nodo */

      if (q->d_prev)

        { /* non e' il primo figlio */

          q = q->d_prev;

          if (q->d_next->d_lock) {

            dprint(KERN_DEBUG "%s is locked",

                   QSTRNAME(&q->d_next->d_name));

            return -1;

          }

          if (destroy_inode(q->d_next->d_inode)) {

            dprint(KERN_DEBUG "error destroing %s",

                   QSTRNAME(&q->d_next->d_name));

            return -1;

          }

          dprint(KERN_DEBUG "removing %s",QSTRNAME(&q->d_next->d_name));

          __remove_dentry_only(q->d_next);

          q->d_next = NULL;

          p = NULL;

        }

      else {

        /* e' il primo figlio */

        q = q->d_parent;

        if (q->d_child->d_lock) {

            dprint(KERN_DEBUG "%s is locked",

                   QSTRNAME(&q->d_child->d_name));

          return -1;

        }

        if (destroy_inode(q->d_child->d_inode)) {

            dprint(KERN_DEBUG "error destroing %s",

                   QSTRNAME(&q->d_child->d_name));

          return -1;

        }

        dprint(KERN_DEBUG "removing %s",QSTRNAME(&q->d_child->d_name));

        __remove_dentry_only(q->d_child);

        q->d_child = NULL;

        p = NULL;

      }

    }

  }

}

#define __purgeallchilds(de) __purgeallchilds_mg(de)

int mount_dentry(struct super_block *sb, struct dentry *de)

{

  int ret;

  printk9("START mount_dentry()!");

  printk9("for %s",QSTRNAME(&de->d_name));

  _assert(de!=NULL);

  _assert(sb!=NULL);

  __fs_mutex_lock(&mutex);

  printk9("locked and ready");

  if (de->d_lock>1) {

    printk9("LOCKED!");    

    /* someone is using this dentry! */

    __fs_mutex_unlock(&mutex);    

    return -1;