WebSVN - shark - Rev 2 - /shark/trunk/fs/dentry.c

/*
* 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;
}

/*
* Phase 1
*/

/* purge all childs (if possible) */

if (de->d_child!=NULL) {
ret=__purgeallchilds(de);
if (ret) {
printk9("PURGECHILD!");
__fs_mutex_unlock(&mutex);
return ret;
}

}

/*
* Phase 2
*/

ret=destroy_inode(de->d_inode);
if (ret) {
printk9("DESTROY INODE!");
__fs_mutex_unlock(&mutex);
return ret;
}

de->d_op=sb->sb_dop;
de->d_inode=sb->sb_root;
de->d_sb=sb;

sb->sb_droot=de;

__fs_mutex_unlock(&mutex);
printk9("END mount_dentry()!");
return 0;
}

int umount_dentry(struct super_block *sb)
{
struct dentry *de;
int res;

printk9("START umount_dentry()");

__fs_mutex_lock(&mutex);

_assert(sb!=NULL);
_assert(sb->sb_droot!=NULL);
if (sb->sb_droot->d_child!=NULL) {
res=__purgeallchilds(sb->sb_droot);
if (res) {
printk9("PURGING CHILD!");
__fs_mutex_unlock(&mutex);
return res;
}
}

printk9("umount_dentry: phase 1");

de=sb->sb_droot;
_assert(de->d_lock>0);
if (de->d_lock!=1) {
printk9("LOCK COUNT! (%i)",de->d_lock);
__fs_mutex_unlock(&mutex);
return -1;
}
de->d_lock--;

printk9("umount_dentry: phase 2");

__remove_dentry_only(de);
destroy_inode(de->d_inode);
__free_dentry(de);

printk9("umount_dentry: phase 3");

sb->sb_droot=NULL;
sb->sb_root=NULL;

__fs_mutex_unlock(&mutex);

printk9("END umount_dentry()!");
return 0;
}

int unlink_dentry(struct dentry *d)
{
struct inode *in;
int res;

printkd("unlink_dentry: START");

__fs_mutex_lock(&mutex);
if (d->d_lock!=1) return EBUSY;

in=d->d_inode;

printkd("unlink_dentry: dentry ok");

__rwlock_wrlock(&in->i_lock);

printkd("unlink_dentry: locked inode");

res=in->i_op->unlink(d);

printkd("unlink_dentry: inode unlinked from dentry");

if (res==0&&in->i_st.st_nlink==0) {
printkd("unlink_dentry: no more links erasing inode");
erase_inode(in);
}

__rwlock_wrunlock(&in->i_lock);

printkd("unlink_dentry: unlocked inode");

if (res==0) {
d->d_lock--;
__remove_dentry_only(d);
printkd("unlink_dentry: dentry unlinked");
}

__fs_mutex_unlock(&mutex);

printkd("unlink_dentry: END");
return -res;
}

Subversion Repositories shark

(root)/shark/trunk/fs/dentry.c - Rev 2