Subversion Repositories shark

Rev

Rev 2 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 pj 1
/*
2
 * Project: HARTIK (HA-rd R-eal TI-me K-ernel)
3
 *
4
 * Coordinators: Giorgio Buttazzo <giorgio@sssup.it>
5
 *               Gerardo Lamastra <gerardo@sssup.it>
6
 *
7
 * Authors     : Massimiliano Giorgi <massy@hartik.sssup.it>
8
 * (see authors.txt for full list of hartik's authors)
9
 *
10
 * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
11
 *
12
 * http://www.sssup.it
13
 * http://retis.sssup.it
14
 * http://hartik.sssup.it
15
 */
16
 
17
/*
18
 * Copyright (C) 1999 Massimiliano Giorgi
19
 *
20
 * This program is free software; you can redistribute it and/or modify
21
 * it under the terms of the GNU General Public License as published by
22
 * the Free Software Foundation; either version 2 of the License, or
23
 * (at your option) any later version.
24
 *
25
 * This program is distributed in the hope that it will be useful,
26
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
27
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
28
 * GNU General Public License for more details.
29
 *
30
 * You should have received a copy of the GNU General Public License
31
 * along with this program; if not, write to the Free Software
32
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
33
 *
34
 */
35
 
36
/*
37
 * CVS :        $Id: dentry.c,v 1.1.1.1 2002-03-29 14:12:50 pj Exp $
38
 *
39
 * File:        $File$
40
 * Revision:    $Revision: 1.1.1.1 $
41
 * Last update: $Date: 2002-03-29 14:12:50 $
42
 */
43
 
44
#include <fs/util.h>
45
#include <fs/types.h>
46
#include <fs/assert.h>
47
#include "fs.h"
48
#include "super.h"
49
#include "superop.h"
50
#include "dentry.h"
51
#include "dentryop.h"
52
#include "inode.h"
53
#include "inodeop.h"
54
#include "fsconst.h"
55
#include "mutex.h"
56
 
57
#include "debug.h"
58
 
59
/*
60
 * DEBUG
61
 */
62
 
63
/* if defined:
64
 * a short message is printed on console when a task go in/out of
65
 * functions dentry_find() & dentry_unlock()
66
 * (after  and before the lock/unlock of the mutex!)
67
 */
68
#define DEBUGFINDUNLOCK KERN_DEBUG
69
#undef DEBUGFINDUNLOCK
70
 
71
#ifdef DEBUGFINDUNLOCK
72
#define printdd(fmt,pid) kern_printf(fmt,pid)
73
#else
74
#define printdd(fmt,pid)
75
#endif
76
 
77
/* if you modify this you must modify MAXINODE */
78
#define MAXDENTRY 128
79
 
80
static __fs_mutex_t mutex;
81
static __fs_fastmutex_t mutexreq;
82
static struct dentry *freelist;
83
//static struct dentry *leaflist;
84
static struct dentry direntry[MAXDENTRY];
85
 
86
static struct dentry *root_direntry=NULL;
87
 
88
#ifdef FSMUTEXCHECK
89
void debug_dump_dentry_mutex(void)
90
{
91
  //printk(KERN_DEBUG "dentry mutex: %i",(int)mutex);
92
  //printk(KERN_DEBUG "dentry mutex req: %i",(int)mutexreq);
93
}
94
 
95
//static __fs_mutex_t regmutex;
96
//static __fs_mutex_t regmutexreq;
97
 
98
int debug_check_dentry_mutex(void)
99
{
100
  /*
101
  if (mutex!=regmutex) {
102
    printk(KERN_DEBUG "dentry mutex CHANGED! (prev: %i)",regmutex);
103
    return 0;
104
  }
105
  if (mutexreq!=regmutexreq) {
106
    printk(KERN_DEBUG "dentry mutexreq CHANGED! (prev: %i)",regmutexreq);
107
    return 0;
108
  }
109
  */
110
  return -1;
111
}
112
 
113
void debug_save_dentry_mutex(void)
114
{
115
  //regmutex=mutex;
116
  //regmutexreq=mutexreq;
117
}
118
#endif
119
 
120
int dentry_init(void)
121
{
122
  int i;
123
 
124
  __fs_mutex_init(&mutex);
125
  __fs_fastmutex_init(&mutexreq);
126
 
127
#ifdef FSMUTEXCHECK
128
  debug_save_dentry_mutex();
129
#endif
130
 
131
  freelist=direntry;
132
  for (i=0;i<MAXDENTRY;i++) {
133
    memset(direntry+i,0,sizeof(struct dentry));
134
    magic_set(direntry[i].magic,DENTRY_MAGIC);
135
    direntry[i].d_next=direntry+i+1;
136
    direntry[i].d_lock=-1;
137
  }
138
  direntry[MAXDENTRY-1].d_next=NULL;
139
  return 0;
140
}
141
 
142
static __inline__ struct dentry *__get_dentry(void)
143
{
144
  struct dentry *den;
145
  if (freelist==NULL) return NULL;    
146
  den=freelist;
147
  freelist=den->d_next;
148
 
149
  _assert(den->d_lock==-1);
150
  magic_assert(den->magic,DENTRY_MAGIC,"get_dentry: dentry MAGIC failed!");
151
 
152
  den->d_lock=0;
153
  return den;
154
}
155
 
156
/* get a dentry from the free queue */
157
struct dentry *get_dentry(void)
158
{
159
  struct dentry *den;
160
  __fs_fastmutex_lock(&mutexreq);
161
  den=__get_dentry();
162
  __fs_fastmutex_unlock(&mutexreq);
163
  return den;
164
}
165
 
166
static __inline__ void __free_dentry(struct dentry *den)
167
{
168
  _assert(den>=direntry&&den<direntry+MAXDENTRY);
169
  _assert(den->d_lock==0);
170
  magic_assert(den->magic,DENTRY_MAGIC,"free_dentry: dentry MAGIC failed!");
171
 
172
  den->d_lock=-1;
173
  den->d_next=freelist;
174
  freelist=den;
175
}
176
 
177
/* insert dentry into the free queue */
178
void free_dentry(struct dentry *den)
179
{
180
  __fs_fastmutex_lock(&mutexreq);
181
  __free_dentry(den);
182
  __fs_fastmutex_unlock(&mutexreq);
183
}
184
 
185
static void __insert_dentry(struct dentry *den, struct dentry *parent)
186
{
187
  _assert(den>=direntry&&den<direntry+MAXDENTRY);
188
  magic_assert(den->magic,DENTRY_MAGIC,"insert_dentry: dentry MAGIC failed!");
189
 
190
  den->d_acc=gettimek();
191
  den->d_parent=parent;
192
  den->d_child=NULL;
193
  den->d_prev=NULL;
194
  den->d_next=parent->d_child;
195
  if (parent->d_child!=NULL)
196
    parent->d_child->d_prev=den;
197
  parent->d_child=den;
198
}
199
 
200
/* insert a dentry into the tree */
201
void insert_dentry(struct dentry *den, struct dentry *parent)
202
{
203
  __fs_mutex_lock(&mutex);
204
  __insert_dentry(den,parent);
205
  __fs_mutex_unlock(&mutex);
206
}
207
 
208
static void __remove_dentry_only(struct dentry *den)
209
{
210
  _assert(den>=direntry&&den<direntry+MAXDENTRY);
211
  magic_assert(den->magic,DENTRY_MAGIC,"remove_dentry: dentry MAGIC failed!");
212
  _assert(den->d_lock==0);
213
 
214
  if (den->d_prev!=NULL)
215
    den->d_prev->d_next=den->d_next;
216
  else
217
    den->d_parent->d_child=den->d_next;
218
  if (den->d_next!=NULL)
219
    den->d_next->d_prev=den->d_prev;
220
}
221
 
222
static __inline__ void __remove_dentry(struct dentry *den)
223
{
224
  __remove_dentry_only(den);
225
  unlock_inode(den->d_inode);  
226
}
227
 
228
/* remove a dentry from the tree */
229
void remove_dentry(struct dentry *den)
230
{
231
  __fs_mutex_lock(&mutex);
232
  __remove_dentry(den);
233
  __fs_mutex_unlock(&mutex);
234
}
235
 
236
/* find the oldest dentry into the tree */
237
/*
238
 * (potrebbe essere fatto in maniera non ricorsiva usando un
239
 * puntatore alle foglie e scandendo questa lista invece di visitare
240
 * tutto l'albero!)
241
 *
242
 * si potrebbe usare un task NRT periodico per mantenere liberi (se
243
 * possibile l'X% delle dentry libere.
244
 */
245
 
246
static struct dentry *__recurse(struct dentry *den, struct dentry *act)
247
{
248
  while (den!=NULL) {    
249
    if (den->d_child!=NULL) {
250
      act=__recurse(den->d_child,act);
251
    } else {
252
      if (den->d_lock==0) {
253
        if (act==NULL)
254
          act=den;
255
        else {
256
          if (den->d_acc<act->d_acc)
257
            act=den;
258
        }
259
      }      
260
    }
261
    den=den->d_next;
262
  }
263
  return act;
264
}
265
 
266
struct dentry *__purge_dentry(void)
267
{
268
  struct dentry *act;
269
  act=__recurse(root_direntry,NULL);
270
  if (act!=NULL) __remove_dentry(act);
271
  return act;
272
}
273
 
274
/* find & remove the oldest dentry from the tree */
275
struct dentry *purge_dentry(void)
276
{
277
  struct dentry *act;
278
  __fs_mutex_lock(&mutex);
279
  act=__purge_dentry();  
280
  __fs_mutex_unlock(&mutex);
281
  return act;
282
}
283
 
284
struct dentry *__catch_dentry(void)
285
{
286
  struct dentry *den;
287
  den=__get_dentry();
288
  if (den==NULL) den=__purge_dentry();
289
  return den;
290
}
291
 
292
/* get a dentry by searching into the free space or purging an old one */
293
/*
294
static struct dentry *catch_dentry(void)
295
{
296
  struct dentry *den;
297
  __fs_mutex_lock(&mutex);
298
  den=__catch_dentry();  
299
  __fs_mutex_unlock(&mutex);
300
  return den;
301
}
302
*/
303
 
304
/*---------------------*/
305
 
306
int set_root_dentry(struct super_block *sb)
307
{
308
  struct dentry *den;
309
 
310
  __fs_mutex_lock(&mutex);
311
  if (sb==NULL) {
312
    _assert(root_direntry!=NULL);
313
    root_direntry->d_lock--;
314
    _assert(root_direntry->d_lock==1);
315
    root_direntry=NULL;
316
    __fs_mutex_unlock(&mutex);
317
    return 0;
318
  }
319
  _assert(root_direntry==NULL);
320
  __fs_mutex_unlock(&mutex);
321
 
322
  den=get_dentry();
323
  if (den==NULL) return -1;
324
 
325
  den->d_next=NULL;
326
  den->d_prev=NULL;
327
  den->d_parent=NULL;
328
  den->d_child=NULL;
329
 
330
  den->d_acc=0;
331
  den->d_name.nameptr=ROOTDIRNAME;
332
 
333
  den->d_op=sb->sb_dop;
334
  den->d_sb=sb;
335
  den->d_inode=sb->sb_root;
336
 
337
  den->d_lock=1;
338
 
339
  sb->sb_droot=den;
340
  root_direntry=den;
341
 
342
  return 0;
343
}
344
 
345
struct dentry *get_root_dentry(void)
346
{
347
  _assert(root_direntry!=NULL);
348
  return root_direntry;
349
}
350
 
351
#ifdef DEBUG_FIND_DUMP
352
static void dump_dentry(struct dentry *ptr)
353
{
354
  printk7(KERN_DEBUG "dentry dump:");
355
  printk7(KERN_DEBUG "  name : %s",QSTRNAME(&ptr->d_name));
356
  printk7(KERN_DEBUG "  lock : %i",ptr->d_lock);
357
  printk7(KERN_DEBUG "  inode: %i",ptr->d_inode->i_st.st_ino);
358
}
359
#else
360
#define dump_dentry(x)
361
#endif
362
 
363
/*--------------*/
364
 
365
/*
366
 * flags for createflags:
367
 * DENTRY_NOCREATE   -> can't create a new inode
368
 * DENTRY_CANCREATE  -> an inode (only the last) can be created
369
 * DENTRY_MUSTCREATE -> the last inode MUST be created (it must no exist)
370
 *
371
 * return flags for createflags:
372
 * DENTRY_CREATED -> the last inode has been created
373
 * DENTRY_EXIST   -> (error) the last inode already exist
374
 *
375
 * return NULL on error (not found or DENTRY_EXIST)
376
 *
377
 * NB:
378
 * if createflag is NULL a DENTRY_NOCREATE is assumed
379
 * 'act' can be NULL if pathname is an absolute path
380
 */
381
 
382
struct dentry *find_dentry_from_ext(struct dentry *act,
383
                                    char *pathname,
384
                                    int *createflag)
385
{
386
  struct dentry *ptr;
387
  struct dentry *den;
388
  struct inode *ino;
389
  struct qstr str;
390
  char *sp;
391
  char *s;
392
  int  found,created;
393
 
394
  /* too much 'goto' :-( and 'if' */
395
 
396
  sp=pathname;
397
  if (*pathname==DIRDELIMCHAR) {
398
    act=root_direntry;
399
    sp++;
400
  }
401
  if (act==NULL) return NULL;
402
 
403
  printdd("f<%i>",exec_shadow);
404
  __fs_mutex_lock(&mutex);
405
  printdd("f<%i>",exec_shadow);
406
 
407
  if (*sp=='\0') goto END0;
408
 
409
  created=0;
410
  found=1;
411
  while (found) {
412
    s=strchr(sp,DIRDELIMCHAR);
413
    if (s!=NULL) *s='\0';
414
 
415
    printk7("dentry find: searching for %s...",sp);
416
 
417
    /* for handle special directory entry "." and ".." */
418
    if (*sp=='.') {
419
      if (*sp=='\0') {
420
        /* found "." special directory */
421
        printk7("dentry find: special directory entry '.'");
422
        found=1;
423
        if (s==NULL) goto END0;
424
        *s=DIRDELIMCHAR;
425
        sp=s+1;
426
        s=strchr(sp,DIRDELIMCHAR);
427
        continue;      
428
      }
429
      if (*sp=='.') {
430
        if (*sp=='\0') {
431
          /* found ".." special directory */
432
          printk7("dentry find: special directory entry '..'");
433
          found=1;
434
          if (act->d_parent!=NULL) act=act->d_parent;
435
          if (s==NULL) goto END0;
436
          *s=DIRDELIMCHAR;
437
          sp=s+1;
438
          s=strchr(sp,DIRDELIMCHAR);
439
          continue;    
440
        }      
441
      }
442
    }
443
 
444
    ptr=act->d_child;
445
    found=0;
446
    str.nameptr=sp;
447
    while (ptr!=NULL) {
448
      if (ptr->d_op->d_compare(ptr,&ptr->d_name,&str)==0) {
449
 
450
        printk7("dentry find: found!");
451
 
452
        found=1;
453
        act=ptr;
454
        if (s==NULL) goto END0;
455
        *s=DIRDELIMCHAR;
456
        sp=s+1;
457
        s=strchr(sp,DIRDELIMCHAR);
458
        break;
459
      }
460
      ptr=ptr->d_next;
461
    }        
462
  }
463
 
464
  printk7("dentry find: NOT found!");
465
 
466
  for (;;) {
467
    den=__catch_dentry();
468
    if (den==NULL) {
469
      if (s!=NULL) *s=DIRDELIMCHAR;
470
      printk7("dentry find: can't have new struct dentry!");
471
      act=NULL;
472
      goto END1;
473
    }
474
 
475
    den->d_acc=0;
476
    den->d_name.nameptr=NULL;
477
    strcpy(den->d_name.name,sp);
478
    den->d_lock=0;
479
    den->d_op=act->d_op;
480
    den->d_sb=act->d_sb;
481
 
482
    printk7("dentry find: looking up for %s....",sp);
483
    dump_dentry(act);
484
 
485
    ino=act->d_inode->i_op->lookup(act->d_inode,den);
486
 
487
    printk7("dentry find: end looking");
488
 
489
    if (ino==NULL) {
490
 
491
      printk7("dentry find: NOT found!");
492
      if (s!=NULL) *s=DIRDELIMCHAR;      
493
 
494
      if (createflag==NULL) {
495
        __free_dentry(den);
496
        act=NULL;
497
        goto END1;
498
      }
499
 
500
      if ((s==NULL)&&(*createflag&DENTRY_CANCREATE)) {
501
 
502
        printk7("dentry find: check for read-only fs");
503
        if (!(act->d_sb->sb_mopts.flags&MOUNT_FLAG_RW)) {
504
          printk7("dentry find: read-only fs.. creating new inode fails");
505
          __free_dentry(den);
506
          act=NULL;
507
          goto END1;
508
        }
509
 
510
        printk7("dentry find: try to create a new inode");
511
        ino=act->d_inode->i_op->create(act->d_inode,den);
512
 
513
        if (ino==NULL) {  
514
          printk7("dentry find: inode creation fail");
515
          __free_dentry(den);
516
          act=NULL;
517
          goto END1;
518
        }
519
        printk7("dentry find: new inode created");
520
        created=1;
521
 
522
      } else {
523
        __free_dentry(den);
524
        act=NULL;
525
        goto END1;
526
      }
527
    }
528
    den->d_inode=ino;
529
 
530
    insert_inode(ino);  
531
    printk7("dentry find: found!");
532
 
533
    __insert_dentry(den,act);
534
    act=den;
535
 
536
    if (s==NULL) goto END2;
537
 
538
    sp=s+1;
539
    *s=DIRDELIMCHAR;    
540
    s=strchr(sp,DIRDELIMCHAR);
541
    if (s!=NULL) *s='\0';
542
  }
543
 
544
  /* for safety */
545
  _assert(0==-1);
546
 
547
END0:
548
  /* 'if found' we are here */
549
  if (createflag!=NULL) {
550
    *createflag&=~DENTRY_CREATEMASK;
551
    if (*createflag&DENTRY_MUSTCREATE) {
552
      _assert(act!=NULL);
553
      *createflag|=DENTRY_EXIST;
554
      act=NULL;
555
    }
556
  }
557
  goto END;
558
 
559
END1:
560
  /* 'if error' we are here */
561
  _assert(act==NULL);
562
  if (createflag!=NULL) *createflag&=~DENTRY_CREATEMASK;
563
  goto END;
564
 
565
END2:
566
  /* 'if ok' (found or created) we are here */
567
  _assert(act!=NULL);
568
  if (createflag!=NULL) {
569
    if (created) {
570
      *createflag&=~DENTRY_CREATEMASK;           
571
      *createflag|=DENTRY_CREATED;
572
    } else if ((*createflag&DENTRY_MUSTCREATE)==DENTRY_MUSTCREATE) {
573
      *createflag&=~DENTRY_CREATEMASK;           
574
      *createflag|=DENTRY_EXIST;
575
      act=NULL;
576
    } else
577
      *createflag&=~DENTRY_CREATEMASK;                   
578
  }
579
  goto END;    
580
 
581
END:
582
  if (act!=NULL) act->d_lock++;
583
 
584
  printdd("f<%i>",exec_shadow);
585
  __fs_mutex_unlock(&mutex);
586
  printdd("f<%i>",exec_shadow);
587
  return act;
588
 
589
}
590
 
591
void unlock_dentry(struct dentry *den)
592
{
593
  printdd("u<%i>",exec_shadow);
594
  __fs_mutex_lock(&mutex);
595
  printdd("u<%i>",exec_shadow);
596
 
597
  _assert(den>=direntry&&den<direntry+MAXDENTRY);
598
  if (den->d_lock<=0) {
599
    printk(KERN_DEBUG "unlock_dentry on %s",QSTRNAME(&den->d_name));
600
  }
601
  _assert(den->d_lock>0);
602
 
603
  den->d_lock--;
604
  //if (den->d_lock==0) {
605
  //  _assert(den->d_inode!=NULL);
606
  //  unlock_inode(den->d_inode);
607
  //}
608
 
609
  printdd("u<%i>",exec_shadow);
610
  __fs_mutex_unlock(&mutex);
611
  printdd("u<%i>",exec_shadow);
612
}
613
 
614
/*
615
 *
616
 */
617
 
618
static void __print_name(struct dentry *act,char *buffer)
619
{
620
  if (act->d_parent==NULL) return;
621
  __print_name(act->d_parent,buffer);
622
  strcat(buffer,ROOTDIRNAME);
623
  strcat(buffer,QSTRNAME(&act->d_name));
624
  return;
625
}
626
 
627
static char *print_name(struct dentry *act)
628
{
629
  static char buffer[1024];
630
  buffer[0]='\0';
631
  __print_name(act,buffer);
632
  return buffer;
633
}
634
 
635
void getfullname_dentry(struct dentry *act, char *buffer, int size)
636
{
637
  _assert(act>=direntry&&act<direntry+MAXDENTRY);
638
  magic_assert(act->magic,DENTRY_MAGIC,
639
               "getfullname_dentry: dentry MAGIC failed!");
640
 
641
  buffer[0]='\0';
642
  __print_name(act,buffer);
643
  _assert(strlen(buffer)<size);
644
}
645
 
646
static void visit_tree(struct dentry *act)
647
{
648
  struct dentry *ptr;
649
  if (act==root_direntry) printk(KERN_DEBUG "  %s",ROOTDIRNAME);
650
  else { char *s=print_name(act); printk(KERN_DEBUG "  %s",s);}
651
  ptr=act->d_child;
652
  while (ptr!=NULL) {
653
    visit_tree(ptr);
654
    ptr=ptr->d_next;
655
  }
656
  return;
657
}
658
 
659
void dump_dentry_tree(void)
660
{
661
  printk(KERN_DEBUG "DTREE dump");
662
  visit_tree(root_direntry);
663
}
664
 
665
/*
666
 *
667
 */
668
 
669
#ifdef DEBUGPURGECHILD
670
#define dprint(fmt,args...) printk(fmt,##args)
671
#else
672
#define dprint(fmt,args...)
673
#endif
674
 
675
static __inline__ int __purgeallchilds_mg(struct dentry *de)
676
{
677
  int ret;
678
  struct dentry *ptr,*ptr2,*ptr3;
679
 
680
  dprint(KERN_DEBUG "START mg purgechild");
681
 
682
  {
683
#ifdef DEBUGPURGECHILD
684
    char *s=print_name(de);
685
    dprint(KERN_DEBUG "for %s",s);
686
#endif
687
  }
688
 
689
  /*
690
   * Phase 1
691
   * purge all childs (if possible!)
692
   */
693
 
694
  ptr=de->d_child;
695
  ret=0;
696
 
697
  /* why these? I do not want to use recursion... (or goto statement)*/
698
  for (;;) {
699
    /* if there is a child... continue using the child's chain */
700
    if (ptr->d_child!=NULL) {
701
      ptr=ptr->d_child;
702
      continue;      
703
    }    
704
    /* if a child dentry is locked... can't continue! */
705
    if (ptr->d_lock) {
706
      #ifdef DEBUGPURGECHILD
707
      char *s=print_name(ptr);
708
      dprint(KERN_DEBUG "%s is locked!!!",s);
709
      #endif
710
      ret=-1;
711
      break;
712
    }
713
    /* purge this dentry */
714
    ptr2=ptr->d_next;
715
    ptr3=ptr->d_parent;
716
 
717
    dprint(KERN_DEBUG "%s destroy",QSTRNAME(&ptr->d_name));
718
    ret=destroy_inode(ptr->d_inode);
719
    if (ret) break;
720
    __remove_dentry_only(ptr);
721
 
722
    /* if there is not another child... continue with the parent */
723
    if (ptr2==NULL) {
724
      ptr=ptr3;
725
      if (ptr==de) break;
726
      continue;
727
    }
728
    /* continue with next child */
729
    ptr=ptr2;
730
  }
731
 
732
  dprint(KERN_DEBUG "END mg purgechild");  
733
  return ret;
734
}
735
 
736
static __inline__ int __purgeallchilds_pj(struct dentry *x)
737
{
738
  struct dentry *p,*q;
739
 
740
  dprint(KERN_DEBUG "START pj purgechild");
741
 
742
  p = x->d_child;
743
  q = NULL;
744
  for(;;) {
745
    /* scorro i figli */
746
    while(p) {
747
      q = p;
748
      p = p->d_next;
749
    }
750
 
751
    if (q == x) {
752
      dprint(KERN_DEBUG "END pj purgechild");  
753
      return 0; /* finito */
754
    }
755
 
756
    if (q->d_child) {
757
      p = q->d_child;
758
      q = NULL;
759
    }
760
    else {
761
      /* sono su un nodo senza figli */
762
      /* q punta al nodo */
763
      if (q->d_prev)
764
        { /* non e' il primo figlio */
765
          q = q->d_prev;
766
          if (q->d_next->d_lock) {
767
            dprint(KERN_DEBUG "%s is locked",
768
                   QSTRNAME(&q->d_next->d_name));
769
            return -1;
770
          }
771
          if (destroy_inode(q->d_next->d_inode)) {
772
            dprint(KERN_DEBUG "error destroing %s",
773
                   QSTRNAME(&q->d_next->d_name));
774
            return -1;
775
          }
776
          dprint(KERN_DEBUG "removing %s",QSTRNAME(&q->d_next->d_name));
777
          __remove_dentry_only(q->d_next);
778
          q->d_next = NULL;
779
          p = NULL;
780
        }
781
      else {
782
        /* e' il primo figlio */
783
        q = q->d_parent;
784
        if (q->d_child->d_lock) {
785
            dprint(KERN_DEBUG "%s is locked",
786
                   QSTRNAME(&q->d_child->d_name));
787
          return -1;
788
        }
789
        if (destroy_inode(q->d_child->d_inode)) {
790
            dprint(KERN_DEBUG "error destroing %s",
791
                   QSTRNAME(&q->d_child->d_name));
792
          return -1;
793
        }
794
        dprint(KERN_DEBUG "removing %s",QSTRNAME(&q->d_child->d_name));
795
        __remove_dentry_only(q->d_child);
796
        q->d_child = NULL;
797
        p = NULL;
798
      }
799
    }
800
  }
801
 
802
}
803
 
804
#define __purgeallchilds(de) __purgeallchilds_mg(de)
805
 
806
int mount_dentry(struct super_block *sb, struct dentry *de)
807
{
808
  int ret;
809
 
810
  printk9("START mount_dentry()!");
811
  printk9("for %s",QSTRNAME(&de->d_name));
812
 
813
  _assert(de!=NULL);
814
  _assert(sb!=NULL);
815
 
816
  __fs_mutex_lock(&mutex);
817
 
818
  printk9("locked and ready");
819
 
820
  if (de->d_lock>1) {
821
    printk9("LOCKED!");    
822
    /* someone is using this dentry! */
823
    __fs_mutex_unlock(&mutex);    
824
    return -1;    
825
  }
826
 
827
  /*
828
   * Phase 1
829
   */
830
 
831
  /* purge all childs (if possible) */
832
 
833
  if (de->d_child!=NULL) {
834
    ret=__purgeallchilds(de);      
835
    if (ret) {
836
      printk9("PURGECHILD!");      
837
      __fs_mutex_unlock(&mutex);
838
      return ret;
839
    }
840
 
841
  }
842
 
843
  /*
844
   * Phase 2
845
   */
846
 
847
  ret=destroy_inode(de->d_inode);
848
  if (ret) {
849
    printk9("DESTROY INODE!");    
850
    __fs_mutex_unlock(&mutex);
851
    return ret;
852
  }
853
 
854
  de->d_op=sb->sb_dop;
855
  de->d_inode=sb->sb_root;
856
  de->d_sb=sb;
857
 
858
  sb->sb_droot=de;
859
 
860
  __fs_mutex_unlock(&mutex);
861
  printk9("END mount_dentry()!");
862
  return 0;
863
}
864
 
865
int umount_dentry(struct super_block *sb)
866
{
867
  struct dentry *de;
868
  int res;
869
 
870
  printk9("START umount_dentry()");
871
 
872
  __fs_mutex_lock(&mutex);
873
 
874
  _assert(sb!=NULL);
875
  _assert(sb->sb_droot!=NULL);
876
  if (sb->sb_droot->d_child!=NULL) {
877
    res=__purgeallchilds(sb->sb_droot);
878
    if (res) {      
879
      printk9("PURGING CHILD!");    
880
      __fs_mutex_unlock(&mutex);
881
      return res;
882
    }
883
  }
884
 
885
  printk9("umount_dentry: phase 1");
886
 
887
  de=sb->sb_droot;
888
  _assert(de->d_lock>0);
889
  if (de->d_lock!=1) {
890
    printk9("LOCK COUNT! (%i)",de->d_lock);
891
    __fs_mutex_unlock(&mutex);
892
    return -1;
893
  }
894
  de->d_lock--;
895
 
896
  printk9("umount_dentry: phase 2");
897
 
898
  __remove_dentry_only(de);
899
  destroy_inode(de->d_inode);
900
  __free_dentry(de);
901
 
902
  printk9("umount_dentry: phase 3");
903
 
904
  sb->sb_droot=NULL;
905
  sb->sb_root=NULL;
906
 
907
  __fs_mutex_unlock(&mutex);
908
 
909
  printk9("END umount_dentry()!");
910
  return 0;
911
}
912
 
913
int unlink_dentry(struct dentry *d)
914
{
915
  struct inode *in;
916
  int res;
917
 
918
  printkd("unlink_dentry: START");
919
 
920
  __fs_mutex_lock(&mutex);
921
  if (d->d_lock!=1) return EBUSY;
922
 
923
  in=d->d_inode;
924
 
925
  printkd("unlink_dentry: dentry ok");
926
 
927
  __rwlock_wrlock(&in->i_lock);  
928
 
929
  printkd("unlink_dentry: locked inode");
930
 
931
  res=in->i_op->unlink(d);
932
 
933
  printkd("unlink_dentry: inode unlinked from dentry");
934
 
935
  if (res==0&&in->i_st.st_nlink==0) {
936
    printkd("unlink_dentry: no more links erasing inode");
937
    erase_inode(in);    
938
  }
939
 
940
  __rwlock_wrunlock(&in->i_lock);
941
 
942
  printkd("unlink_dentry: unlocked inode");
943
 
944
  if (res==0) {
945
    d->d_lock--;
946
    __remove_dentry_only(d);
947
    printkd("unlink_dentry: dentry unlinked");
948
  }
949
 
950
  __fs_mutex_unlock(&mutex);
951
 
952
  printkd("unlink_dentry: END");
953
  return -res;
954
}