← Back to branch summary

~ubuntu-branches/ubuntu/trusty/glusterfs/trusty

« back to all changes in this revision

Viewing changes to libglusterfs/src/inode.c

  • Committer: Bazaar Package Importer
  • Author(s): Patrick Matthäi
  • Date: 2010-02-09 18:53:10 UTC
  • mfrom: (1.2.4 upstream) (4.1.5 sid)
  • Revision ID: james.westby@ubuntu.com-20100209185310-ww8p82lsbosorg2u
* New upstream release.
* Uploading to unstable.
* Bump Standards-Version to 3.8.4 (no changes needed).

Show diffs side-by-side

added added

removed removed

Lines of Context:
libglusterfs/src/inode.c
1
1
/*
2
 
   Copyright (c) 2007-2009 Gluster, Inc. <http://www.gluster.com>
3
 
   This file is part of GlusterFS.
4
 
 
5
 
   GlusterFS is free software; you can redistribute it and/or modify
6
 
   it under the terms of the GNU General Public License as published
7
 
   by the Free Software Foundation; either version 3 of the License,
8
 
   or (at your option) any later version.
9
 
 
10
 
   GlusterFS is distributed in the hope that it will be useful, but
11
 
   WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 
   General Public License for more details.
14
 
 
15
 
   You should have received a copy of the GNU General Public License
16
 
   along with this program.  If not, see
17
 
   <http://www.gnu.org/licenses/>.
 
2
  Copyright (c) 2007-2009 Gluster, Inc. <http://www.gluster.com>
 
3
  This file is part of GlusterFS.
 
4
 
 
5
  GlusterFS is free software; you can redistribute it and/or modify
 
6
  it under the terms of the GNU General Public License as published
 
7
  by the Free Software Foundation; either version 3 of the License,
 
8
  or (at your option) any later version.
 
9
 
 
10
  GlusterFS is distributed in the hope that it will be useful, but
 
11
  WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
13
  General Public License for more details.
 
14
 
 
15
  You should have received a copy of the GNU General Public License
 
16
  along with this program.  If not, see
 
17
  <http://www.gnu.org/licenses/>.
18
18
*/
19
19
 
20
20
#ifndef _CONFIG_H
24
24
 
25
25
#include "inode.h"
26
26
#include "common-utils.h"
 
27
#include "statedump.h"
27
28
#include <pthread.h>
28
29
#include <sys/types.h>
29
30
#include <stdint.h>
31
32
#include <time.h>
32
33
#include <assert.h>
33
34
 
34
 
/* TODO: 
 
35
/* TODO:
35
36
   move latest accessed dentry to list_head of inode
36
37
*/
37
38
 
 
39
#define INODE_DUMP_LIST(head, key_buf, key_prefix, list_type)           \
 
40
        {                                                               \
 
41
                int i = 1;                                              \
 
42
                inode_t *inode = NULL;                                  \
 
43
                list_for_each_entry (inode, head, list) {               \
 
44
                        gf_proc_dump_build_key(key_buf, key_prefix, "%s.%d",list_type, \
 
45
                                               i++);                    \
 
46
                        gf_proc_dump_add_section(key_buf);              \
 
47
                        inode_dump(inode, key);                         \
 
48
                }                                                       \
 
49
        }
 
50
 
38
51
static inode_t *
39
52
__inode_unref (inode_t *inode);
40
53
 
42
55
inode_table_prune (inode_table_t *table);
43
56
 
44
57
static int
45
 
hash_name (ino_t par,
46
 
           const char *name,
47
 
           int mod)
 
58
hash_dentry (inode_t *parent, const char *name, int mod)
 
59
{
 
60
        int hash = 0;
 
61
        int ret = 0;
 
62
 
 
63
        hash = *name;
 
64
        if (hash) {
 
65
                for (name += 1; *name != '\0'; name++) {
 
66
                        hash = (hash << 5) - hash + *name;
 
67
                }
 
68
        }
 
69
        ret = (hash + (unsigned long)parent) % mod;
 
70
 
 
71
        return ret;
 
72
}
 
73
 
 
74
 
 
75
static int
 
76
hash_name (ino_t par, const char *name, int mod)
48
77
{
49
78
        int hash = 0;
50
79
        int ret = 0;
62
91
 
63
92
 
64
93
static int
65
 
hash_inode (ino_t ino,
66
 
            int mod)
 
94
hash_inode (ino_t ino, int mod)
67
95
{
68
96
        int hash = 0;
69
97
 
80
108
        int              hash = 0;
81
109
 
82
110
        table = dentry->inode->table;
83
 
        hash = hash_name (dentry->parent->ino, dentry->name,
84
 
                          table->hashsize);
 
111
        hash = hash_dentry (dentry->parent, dentry->name,
 
112
                            table->hashsize);
85
113
 
86
114
        list_del_init (&dentry->hash);
87
115
        list_add (&dentry->hash, &table->name_hash[hash]);
88
 
 
89
 
        list_del_init (&dentry->parent_list);
90
 
        list_add (&dentry->parent_list, &dentry->parent->child_list);
91
116
}
92
117
 
93
118
 
116
141
                FREE (dentry->name);
117
142
 
118
143
        if (dentry->parent) {
119
 
                list_del_init (&dentry->parent_list);
120
144
                __inode_unref (dentry->parent);
121
145
                dentry->parent = NULL;
122
146
        }
128
152
static void
129
153
__inode_unhash (inode_t *inode)
130
154
{
 
155
        if (!list_empty (&inode->hash)) {
 
156
                if (inode->in_attic)
 
157
                        inode->table->attic_size--;
 
158
                inode->in_attic = 0;
 
159
        }
 
160
 
131
161
        list_del_init (&inode->hash);
132
162
}
133
163
 
154
184
 
155
185
 
156
186
static inode_t *
157
 
__inode_search (inode_table_t *table,
158
 
                ino_t ino)
 
187
__inode_search (inode_table_t *table, ino_t ino)
159
188
{
160
 
        int  hash = 0;
 
189
        int       hash = 0;
161
190
        inode_t  *inode = NULL;
162
191
        inode_t  *tmp = NULL;
163
192
 
174
203
}
175
204
 
176
205
 
 
206
static inode_t *
 
207
__inode_search_attic (inode_table_t *table, ino_t ino, uint64_t gen)
 
208
{
 
209
        inode_t  *inode = NULL;
 
210
        inode_t  *tmp = NULL;
 
211
 
 
212
        list_for_each_entry (tmp, &table->attic, hash) {
 
213
                if (tmp->ino == ino && tmp->generation == gen) {
 
214
                        inode = tmp;
 
215
                        break;
 
216
                }
 
217
        }
 
218
 
 
219
        return inode;
 
220
}
 
221
 
 
222
 
177
223
static dentry_t *
178
 
__dentry_search_for_inode (inode_t *inode,
179
 
                           ino_t par,
180
 
                           const char *name)
 
224
__dentry_search_for_inode (inode_t *inode, ino_t par, const char *name)
181
225
{
182
226
        dentry_t *dentry = NULL;
183
227
        dentry_t *tmp = NULL;
194
238
 
195
239
 
196
240
dentry_t *
197
 
dentry_search_for_inode (inode_t *inode,
198
 
                         ino_t par,
199
 
                         const char *name)
 
241
dentry_search_for_inode (inode_t *inode, ino_t par, const char *name)
200
242
{
201
243
        dentry_t *dentry = NULL;
202
244
        pthread_mutex_lock (&inode->table->lock);
204
246
                dentry = __dentry_search_for_inode (inode, par, name);
205
247
        }
206
248
        pthread_mutex_unlock (&inode->table->lock);
207
 
        
 
249
 
208
250
        return dentry;
209
251
}
210
252
 
211
253
 
212
254
static dentry_t *
213
 
__dentry_search (inode_table_t *table,
214
 
                 ino_t par,
215
 
                 const char *name)
 
255
__dentry_search (inode_table_t *table, ino_t par, const char *name)
216
256
{
217
257
        int       hash = 0;
218
258
        dentry_t *dentry = NULL;
234
274
static void
235
275
__inode_destroy (inode_t *inode)
236
276
{
237
 
        int          index = 0;
238
 
        data_pair_t *pair = NULL;
 
277
        int          index = 0;
239
278
        xlator_t    *xl = NULL;
 
279
        xlator_t    *old_THIS = NULL;
240
280
 
241
 
        if (!inode->ctx) {
 
281
        if (!inode->_ctx)
242
282
                goto noctx;
243
 
        }
244
 
        for (pair = inode->ctx->members_list; pair; pair = pair->next) {
245
 
                /* notify all xlators which have a context */
246
 
                xl = xlator_search_by_name (inode->table->xl, pair->key);
247
283
 
248
 
                if (!xl) {
249
 
                        gf_log (inode->table->name, GF_LOG_DEBUG,
250
 
                                "inode(%"PRId64")->ctx has invalid key(%s)",
251
 
                                inode->ino, pair->key);
252
 
                        continue;
 
284
        for (index = 0; index < inode->table->xl->ctx->xl_count; index++) {
 
285
                if (inode->_ctx[index].key) {
 
286
                        xl = (xlator_t *)(long)inode->_ctx[index].key;
 
287
                        old_THIS = THIS;
 
288
                        THIS = xl;
 
289
                        if (xl->cbks->forget)
 
290
                                xl->cbks->forget (xl, inode);
 
291
                        THIS = old_THIS;
253
292
                }
254
 
 
255
 
                if (xl->cbks->forget)
256
 
                        xl->cbks->forget (xl, inode);
257
 
                else
258
 
                        gf_log (inode->table->name, GF_LOG_DEBUG,
259
 
                                "xlator(%s) in inode(%"PRId64") no FORGET fop",
260
 
                                xl->name, inode->ino);
261
293
        }
262
 
        dict_destroy (inode->ctx);
263
 
 
264
 
        if (!inode->_ctx)
265
 
                goto noctx;
266
 
 
267
 
        for (index = 0; index < inode->table->xl->ctx->xl_count; index++) {
268
 
                if (inode->_ctx[index].key) {
269
 
                        xl = (xlator_t *)(long)inode->_ctx[index].key;
270
 
                        if (xl->cbks->forget)
271
 
                                xl->cbks->forget (xl, inode);
272
 
                }
273
 
        }       
274
 
 
275
 
        FREE (inode->_ctx);
 
294
 
 
295
        FREE (inode->_ctx);
276
296
noctx:
277
297
        LOCK_DESTROY (&inode->lock);
278
298
        //  memset (inode, 0xb, sizeof (*inode));
320
340
        inode->table->purge_size++;
321
341
 
322
342
        __inode_unhash (inode);
323
 
        assert (list_empty (&inode->child_list));
324
343
 
325
344
        list_for_each_entry_safe (dentry, t, &inode->dentry_list, inode_list) {
326
345
                __dentry_unset (dentry);
341
360
        if (!inode->ref) {
342
361
                inode->table->active_size--;
343
362
 
344
 
                if (inode->nlookup && __is_inode_hashed (inode))
 
363
                if (inode->nlookup)
345
364
                        __inode_passivate (inode);
346
365
                else
347
366
                        __inode_retire (inode);
401
420
 
402
421
 
403
422
static dentry_t *
404
 
__dentry_create (inode_t *inode,
405
 
                 inode_t *parent,
406
 
                 const char *name)
 
423
__dentry_create (inode_t *inode, inode_t *parent, const char *name)
407
424
{
408
425
        dentry_t      *newd = NULL;
409
426
 
410
427
        newd = (void *) CALLOC (1, sizeof (*newd));
 
428
        if (newd == NULL) {
 
429
                gf_log ("inode", GF_LOG_ERROR, "out of memory");
 
430
                goto out;
 
431
        }
411
432
 
412
433
        INIT_LIST_HEAD (&newd->inode_list);
413
 
        INIT_LIST_HEAD (&newd->parent_list);
414
434
        INIT_LIST_HEAD (&newd->hash);
415
435
 
416
 
        list_add (&newd->parent_list, &parent->child_list);
417
 
        newd->parent = __inode_ref (parent);
418
436
        newd->name = strdup (name);
 
437
        if (newd->name == NULL) {
 
438
                gf_log ("inode", GF_LOG_ERROR, "out of memory");
 
439
                FREE (newd);
 
440
                newd = NULL;
 
441
                goto out;
 
442
        }
 
443
 
 
444
        if (parent)
 
445
                newd->parent = __inode_ref (parent);
419
446
 
420
447
        list_add (&newd->inode_list, &inode->dentry_list);
421
448
        newd->inode = inode;
422
449
 
 
450
out:
423
451
        return newd;
424
452
}
425
453
 
430
458
        inode_t  *newi = NULL;
431
459
 
432
460
        newi = (void *) CALLOC (1, sizeof (*newi));
433
 
        if (!newi)
434
 
                return NULL;
 
461
        if (!newi) {
 
462
                gf_log ("inode", GF_LOG_ERROR, "out of memory");
 
463
                goto out;
 
464
        }
435
465
 
436
466
        newi->table = table;
437
467
 
441
471
        INIT_LIST_HEAD (&newi->list);
442
472
        INIT_LIST_HEAD (&newi->hash);
443
473
        INIT_LIST_HEAD (&newi->dentry_list);
444
 
        INIT_LIST_HEAD (&newi->child_list);
445
474
 
 
475
        newi->_ctx = CALLOC (1, (sizeof (struct _inode_ctx) *
 
476
                                 table->xl->ctx->xl_count));
 
477
        if (newi->_ctx == NULL) {
 
478
                gf_log ("inode", GF_LOG_ERROR, "out of memory");
 
479
                LOCK_DESTROY (&newi->lock);
 
480
                FREE (newi);
 
481
                newi = NULL;
 
482
                goto out;
 
483
        }
446
484
 
447
485
        list_add (&newi->list, &table->lru);
448
486
        table->lru_size++;
449
487
 
450
 
        newi->_ctx = CALLOC (1, (sizeof (struct _inode_ctx) * 
451
 
                                 table->xl->ctx->xl_count));
452
 
 
453
 
        newi->ctx = get_new_dict ();
454
 
 
 
488
out:
455
489
        return newi;
456
490
}
457
491
 
464
498
        pthread_mutex_lock (&table->lock);
465
499
        {
466
500
                inode = __inode_create (table);
467
 
                __inode_ref (inode);
 
501
                if (inode != NULL) {
 
502
                        __inode_ref (inode);
 
503
                }
468
504
        }
469
505
        pthread_mutex_unlock (&table->lock);
470
506
 
496
532
 
497
533
 
498
534
inode_t *
499
 
inode_search (inode_table_t *table,
500
 
              ino_t ino,
501
 
              const char *name)
 
535
inode_search (inode_table_t *table, ino_t ino, const char *name)
502
536
{
503
 
        inode_t *inode = NULL;
 
537
        inode_t  *inode = NULL;
504
538
        dentry_t *dentry = NULL;
505
539
 
506
540
        pthread_mutex_lock (&table->lock);
509
543
                        inode = __inode_search (table, ino);
510
544
                } else {
511
545
                        dentry = __dentry_search (table, ino, name);
512
 
      
 
546
 
513
547
                        if (dentry)
514
548
                                inode = dentry->inode;
515
549
                }
516
 
    
 
550
 
517
551
                if (inode)
518
552
                        __inode_ref (inode);
519
553
        }
523
557
}
524
558
 
525
559
 
526
 
static void
527
 
__copy_dentries (inode_t *oldi, inode_t *newi)
 
560
dentry_t *
 
561
__dentry_grep (inode_table_t *table, inode_t *parent, const char *name)
528
562
{
 
563
        int       hash = 0;
529
564
        dentry_t *dentry = NULL;
530
 
        dentry_t *newd = NULL;
531
565
        dentry_t *tmp = NULL;
532
566
 
533
 
        list_for_each_entry (dentry, &oldi->dentry_list, inode_list) {
534
 
                tmp = __dentry_search_for_inode (newi, dentry->parent->ino,
535
 
                                                 dentry->name);
536
 
 
537
 
                if (!tmp) {
538
 
                        newd = __dentry_create (newi, dentry->parent,
539
 
                                                dentry->name);
540
 
                } else {
541
 
                        newd = tmp;
542
 
                }
543
 
 
544
 
                if (__is_dentry_hashed (dentry)) {
545
 
                        __dentry_unhash (dentry);
546
 
                        __dentry_hash (newd);
547
 
                }
548
 
        }
549
 
}
550
 
 
551
 
 
552
 
static void
553
 
__adopt_children (inode_t *oldi, inode_t *newi)
554
 
{
555
 
        dentry_t *dentry = NULL;
556
 
 
557
 
        list_for_each_entry (dentry, &oldi->child_list, parent_list) {
558
 
                assert (dentry->parent == oldi);
559
 
                __inode_unref (dentry->parent);
560
 
                dentry->parent = __inode_ref (newi);
561
 
        }
562
 
 
563
 
        list_splice_init (&oldi->child_list, &newi->child_list);
564
 
}
565
 
 
566
 
 
567
 
static void
568
 
__inode_replace (inode_t *oldi, inode_t *newi)
569
 
{
570
 
        gf_log (oldi->table->name, GF_LOG_DEBUG,
571
 
                "inode(%"PRId64") replaced (%"PRId64"",
572
 
                oldi->ino, newi->ino);
573
 
 
574
 
        __copy_dentries (oldi, newi);
575
 
        __adopt_children (oldi, newi);
576
 
 
577
 
        newi->nlookup    = oldi->nlookup;
578
 
        newi->generation = oldi->generation;
579
 
 
580
 
        oldi->nlookup    = 0;
581
 
        oldi->generation = 0;
582
 
 
583
 
        __inode_unhash (oldi);
584
 
 
585
 
        if (newi->ino == 1)
586
 
                newi->table->root = newi;
 
567
        hash = hash_dentry (parent, name, table->hashsize);
 
568
 
 
569
        list_for_each_entry (tmp, &table->name_hash[hash], hash) {
 
570
                if (tmp->parent == parent && !strcmp (tmp->name, name)) {
 
571
                        dentry = tmp;
 
572
                        break;
 
573
                }
 
574
        }
 
575
 
 
576
        return dentry;
 
577
}
 
578
 
 
579
 
 
580
inode_t *
 
581
inode_grep (inode_table_t *table, inode_t *parent, const char *name)
 
582
{
 
583
        inode_t   *inode = NULL;
 
584
        dentry_t  *dentry = NULL;
 
585
 
 
586
        pthread_mutex_lock (&table->lock);
 
587
        {
 
588
                dentry = __dentry_grep (table, parent, name);
 
589
 
 
590
                if (dentry)
 
591
                        inode = dentry->inode;
 
592
 
 
593
                if (inode)
 
594
                        __inode_ref (inode);
 
595
        }
 
596
        pthread_mutex_unlock (&table->lock);
 
597
 
 
598
        return inode;
 
599
}
 
600
 
 
601
 
 
602
inode_t *
 
603
__inode_get (inode_table_t *table, ino_t ino, uint64_t gen)
 
604
{
 
605
        inode_t   *inode = NULL;
 
606
 
 
607
        if (ino == 1) {
 
608
                inode = table->root;
 
609
                goto out;
 
610
        }
 
611
 
 
612
        inode = __inode_search (table, ino);
 
613
 
 
614
        if (gen) {
 
615
                if (!inode || inode->generation != gen) {
 
616
                        inode = __inode_search_attic (table, ino, gen);
 
617
                }
 
618
        }
 
619
 
 
620
out:
 
621
        return inode;
 
622
}
 
623
 
 
624
 
 
625
inode_t *
 
626
inode_get (inode_table_t *table, ino_t ino, uint64_t gen)
 
627
{
 
628
        inode_t   *inode = NULL;
 
629
 
 
630
        pthread_mutex_lock (&table->lock);
 
631
        {
 
632
                inode = __inode_get (table, ino, gen);
 
633
                if (inode)
 
634
                        __inode_ref (inode);
 
635
        }
 
636
        pthread_mutex_unlock (&table->lock);
 
637
 
 
638
        return inode;
 
639
}
 
640
 
 
641
 
 
642
static int
 
643
__inode_atticize (inode_t *inode)
 
644
{
 
645
        inode_table_t *table = NULL;
 
646
 
 
647
        table = inode->table;
 
648
 
 
649
        __inode_unhash (inode);
 
650
 
 
651
        list_add (&inode->hash, &table->attic);
 
652
        inode->in_attic = 1;
 
653
        table->attic_size++;
 
654
 
 
655
        return 0;
 
656
}
 
657
 
 
658
 
 
659
uint64_t
 
660
inode_gen_from_stat (struct stat *stbuf)
 
661
{
 
662
        return (uint64_t) stbuf->st_dev;
587
663
}
588
664
 
589
665
 
590
666
static inode_t *
591
 
__inode_link (inode_t *inode,
592
 
              inode_t *parent,
593
 
              const char *name,
 
667
__inode_link (inode_t *inode, inode_t *parent, const char *name,
594
668
              struct stat *stbuf)
595
669
{
596
670
        dentry_t      *dentry = NULL;
597
671
        dentry_t      *old_dentry = NULL;
598
672
        inode_t       *old_inode = NULL;
599
673
        inode_table_t *table = NULL;
 
674
        inode_t       *link_inode = NULL;
600
675
 
601
676
        table = inode->table;
602
677
 
603
 
        if (inode->ino)
604
 
                assert (inode->ino == stbuf->st_ino);
605
 
 
606
 
        inode->ino     = stbuf->st_ino;
607
 
        inode->st_mode = stbuf->st_mode;
608
 
 
609
 
        old_inode = __inode_search (table, stbuf->st_ino);
610
 
 
611
 
        if (old_inode && old_inode != inode) {
612
 
                __inode_ref (old_inode);
613
 
                __inode_replace (old_inode, inode);
614
 
                __inode_unref (old_inode);
 
678
        link_inode = inode;
 
679
 
 
680
        if (!__is_inode_hashed (inode)) {
 
681
                inode->ino        = stbuf->st_ino;
 
682
                inode->st_mode    = stbuf->st_mode;
 
683
                inode->generation = inode_gen_from_stat (stbuf);
 
684
 
 
685
                old_inode = __inode_search (table, inode->ino);
 
686
 
 
687
                if (old_inode) {
 
688
                        if (old_inode->generation < inode->generation) {
 
689
                                __inode_atticize (old_inode);
 
690
                                __inode_hash (inode);
 
691
                        } else {
 
692
                                link_inode = old_inode;
 
693
                        }
 
694
                } else {
 
695
                        __inode_hash (inode);
 
696
                }
615
697
        }
616
 
        __inode_hash (inode);
617
698
 
 
699
        /* use only link_inode beyond this point */
618
700
        if (parent) {
619
 
                dentry = __dentry_search_for_inode (inode, parent->ino, name);
620
 
                if (!dentry) {
621
 
                        dentry = __dentry_create (inode, parent, name);
622
 
                }
623
 
 
624
 
                old_dentry = __dentry_search (table, parent->ino, name);
625
 
                if (old_dentry) {
626
 
                        __dentry_unhash (old_dentry);
627
 
                }
628
 
 
629
 
                __dentry_hash (dentry);
630
 
        } else if (inode->ino != 1) {
631
 
                gf_log (table->name, GF_LOG_DEBUG,
632
 
                        "child (%"PRId64") without a parent!", inode->ino);
633
 
        }
634
 
        
635
 
        return inode;
 
701
                old_dentry = __dentry_grep (table, parent, name);
 
702
 
 
703
                if (!old_dentry || old_dentry->inode != link_inode) {
 
704
                        dentry = __dentry_create (link_inode, parent, name);
 
705
                        __dentry_hash (dentry);
 
706
 
 
707
                        if (old_dentry)
 
708
                                __dentry_unset (old_dentry);
 
709
                }
 
710
        }
 
711
 
 
712
        return link_inode;
636
713
}
637
714
 
638
715
 
639
 
int
640
 
inode_link (inode_t *inode,
641
 
            inode_t *parent,
642
 
            const char *name,
 
716
inode_t *
 
717
inode_link (inode_t *inode, inode_t *parent, const char *name,
643
718
            struct stat *stbuf)
644
719
{
645
720
        inode_table_t *table = NULL;
 
721
        inode_t       *linked_inode = NULL;
646
722
 
647
723
        table = inode->table;
648
724
 
649
725
        pthread_mutex_lock (&table->lock);
650
726
        {
651
 
                inode = __inode_link (inode, parent, name, stbuf);
 
727
                linked_inode = __inode_link (inode, parent, name, stbuf);
 
728
 
 
729
                if (linked_inode)
 
730
                        __inode_ref (linked_inode);
652
731
        }
653
732
        pthread_mutex_unlock (&table->lock);
654
733
 
655
734
        inode_table_prune (table);
656
735
 
657
 
        return 0;
 
736
        return linked_inode;
658
737
}
659
738
 
660
739
 
662
741
inode_lookup (inode_t *inode)
663
742
{
664
743
        inode_table_t *table = NULL;
665
 
        inode_t       *lookup_inode = NULL;
666
744
 
667
745
        table = inode->table;
668
 
        lookup_inode = inode;
669
746
 
670
747
        pthread_mutex_lock (&table->lock);
671
748
        {
672
 
                if (!__is_inode_hashed (inode)) {
673
 
                        lookup_inode = __inode_search (table, inode->ino);
674
 
                        if (lookup_inode == NULL)
675
 
                                lookup_inode = inode;
676
 
                }
677
 
 
678
 
                __inode_lookup (lookup_inode);
 
749
                __inode_lookup (inode);
679
750
        }
680
751
        pthread_mutex_unlock (&table->lock);
681
752
 
687
758
inode_forget (inode_t *inode, uint64_t nlookup)
688
759
{
689
760
        inode_table_t *table = NULL;
690
 
        inode_t       *forget_inode = NULL;
691
761
 
692
762
        table = inode->table;
693
 
        forget_inode = inode;
694
763
 
695
764
        pthread_mutex_lock (&table->lock);
696
765
        {
697
 
                if (!__is_inode_hashed (inode)) {
698
 
                        forget_inode = __inode_search (table, inode->ino);
699
 
                        if (forget_inode == NULL)
700
 
                                forget_inode = inode;
701
 
                }
702
 
 
703
 
                 __inode_forget (forget_inode, nlookup);
 
766
                __inode_forget (inode, nlookup);
704
767
        }
705
768
        pthread_mutex_unlock (&table->lock);
706
769
 
711
774
 
712
775
 
713
776
static void
714
 
__inode_unlink (inode_t *inode,
715
 
                inode_t *parent,
716
 
                const char *name)
 
777
__inode_unlink (inode_t *inode, inode_t *parent, const char *name)
717
778
{
718
779
        dentry_t *dentry = NULL;
719
780
 
720
781
        dentry = __dentry_search_for_inode (inode, parent->ino, name);
721
782
 
722
 
        /* dentry NULL for corrupted backend */
723
 
        if (dentry) 
724
 
                __dentry_unset (dentry);
 
783
        /* dentry NULL for corrupted backend */
 
784
        if (dentry)
 
785
                __dentry_unset (dentry);
725
786
}
726
787
 
727
 
                              
 
788
 
728
789
void
729
 
inode_unlink (inode_t *inode,
730
 
              inode_t *parent,
731
 
              const char *name)
 
790
inode_unlink (inode_t *inode, inode_t *parent, const char *name)
732
791
{
733
792
        inode_table_t *table = NULL;
734
 
        inode_t       *unlink_inode = NULL;
 
793
 
 
794
        if (!inode)
 
795
                return;
735
796
 
736
797
        table = inode->table;
737
 
        unlink_inode = inode;
738
798
 
739
799
        pthread_mutex_lock (&table->lock);
740
800
        {
741
 
                if (!__is_inode_hashed (inode)) {
742
 
                        unlink_inode = __inode_search (table, inode->ino);
743
 
                        if (unlink_inode == NULL)
744
 
                                unlink_inode = inode;
745
 
                }
746
 
 
747
 
                __inode_unlink (unlink_inode, parent, name);
 
801
                __inode_unlink (inode, parent, name);
748
802
        }
749
803
        pthread_mutex_unlock (&table->lock);
750
804
 
753
807
 
754
808
 
755
809
int
756
 
inode_rename (inode_table_t *table,
757
 
              inode_t *srcdir,
758
 
              const char *srcname,
759
 
              inode_t *dstdir,
760
 
              const char *dstname,
761
 
              inode_t *inode,
 
810
inode_rename (inode_table_t *table, inode_t *srcdir, const char *srcname,
 
811
              inode_t *dstdir, const char *dstname, inode_t *inode,
762
812
              struct stat *stbuf)
763
813
{
764
 
        dentry_t      *old_dst = NULL;
765
 
        inode_t       *rename_inode = NULL;
766
 
 
767
 
        rename_inode = inode;
 
814
        table = inode->table;
768
815
 
769
816
        pthread_mutex_lock (&table->lock);
770
817
        {
771
 
                if (!__is_inode_hashed (inode)) {
772
 
                        rename_inode = __inode_search (table, inode->ino);
773
 
                        if (rename_inode == NULL)
774
 
                                rename_inode = inode;
775
 
                }
776
 
 
777
 
                old_dst = __dentry_search (table, dstdir->ino, dstname);
778
 
                if (old_dst)
779
 
                        __dentry_unset (old_dst);
780
 
 
781
 
                __inode_unlink (rename_inode, srcdir, srcname);
782
 
                __inode_link (rename_inode, dstdir, dstname, stbuf);
 
818
                __inode_link (inode, dstdir, dstname, stbuf);
 
819
                __inode_unlink (inode, srcdir, srcname);
783
820
        }
784
821
        pthread_mutex_unlock (&table->lock);
785
822
 
792
829
static dentry_t *
793
830
__dentry_search_arbit (inode_t *inode)
794
831
{
795
 
        dentry_t *dentry = NULL;
796
 
        dentry_t *trav = NULL;
 
832
        dentry_t *dentry = NULL;
 
833
        dentry_t *trav = NULL;
797
834
 
798
835
        if (!inode)
799
836
                return NULL;
800
837
 
801
 
        list_for_each_entry (trav, &inode->dentry_list, inode_list) {
802
 
                if (__is_dentry_hashed (trav)) {
803
 
                        dentry = trav;
804
 
                        break;
805
 
                }
806
 
        }
807
 
 
808
 
        if (!dentry) {
809
 
                list_for_each_entry (trav, &inode->dentry_list, inode_list) {
810
 
                        dentry = trav;
811
 
                        break;
812
 
                }
813
 
        }
814
 
 
815
 
        return dentry;
 
838
        list_for_each_entry (trav, &inode->dentry_list, inode_list) {
 
839
                if (__is_dentry_hashed (trav)) {
 
840
                        dentry = trav;
 
841
                        break;
 
842
                }
 
843
        }
 
844
 
 
845
        if (!dentry) {
 
846
                list_for_each_entry (trav, &inode->dentry_list, inode_list) {
 
847
                        dentry = trav;
 
848
                        break;
 
849
                }
 
850
        }
 
851
 
 
852
        return dentry;
816
853
}
817
854
 
818
855
 
834
871
                }
835
872
 
836
873
                if (dentry)
837
 
                        parent = __inode_ref (dentry->parent);
 
874
                        parent = dentry->parent;
 
875
 
 
876
                if (parent)
 
877
                        __inode_ref (parent);
838
878
        }
839
879
        pthread_mutex_unlock (&table->lock);
840
880
 
842
882
}
843
883
 
844
884
 
845
 
int32_t
846
 
inode_path (inode_t *inode, 
847
 
            const char *name, 
848
 
            char **bufp)
 
885
int
 
886
inode_path (inode_t *inode, const char *name, char **bufp)
849
887
{
850
888
        inode_table_t *table = NULL;
851
889
        dentry_t      *trav = NULL;
852
890
        size_t         i = 0, size = 0;
853
891
        int64_t        ret = 0;
854
892
        int            len = 0;
855
 
        char          *buf = NULL;
856
 
        
 
893
        char          *buf = NULL;
 
894
 
857
895
        table = inode->table;
858
896
 
859
897
        pthread_mutex_lock (&table->lock);
862
900
                     trav = __dentry_search_arbit (trav->parent)) {
863
901
                        i ++; /* "/" */
864
902
                        i += strlen (trav->name);
865
 
                        if (i >= PATH_MAX) {
866
 
                                gf_log ("inode", GF_LOG_CRITICAL, 
 
903
                        if (i > PATH_MAX) {
 
904
                                gf_log ("inode", GF_LOG_CRITICAL,
867
905
                                        "possible infinite loop detected, "
868
906
                                        "forcing break. name=(%s)", name);
869
907
                                ret = -ENOENT;
870
908
                                goto unlock;
871
909
                        }
872
910
                }
873
 
                
874
 
                if ((inode->ino != 1) &&
875
 
                    (i == 0)) {
876
 
                        gf_log (table->name, GF_LOG_DEBUG,
877
 
                                "no dentry for non-root inode %"PRId64,
878
 
                                inode->ino);
879
 
                        ret = -ENOENT;
880
 
                        goto unlock;
881
 
                }
 
911
 
 
912
                if ((inode->ino != 1) &&
 
913
                    (i == 0)) {
 
914
                        gf_log (table->name, GF_LOG_DEBUG,
 
915
                                "no dentry for non-root inode %"PRId64,
 
916
                                inode->ino);
 
917
                        ret = -ENOENT;
 
918
                        goto unlock;
 
919
                }
882
920
 
883
921
                if (name) {
884
922
                        i++;
886
924
                }
887
925
 
888
926
                ret = i;
889
 
                size = i + 1;
890
 
                buf = CALLOC (size, sizeof (char));
 
927
                size = i + 1;
 
928
                buf = CALLOC (size, sizeof (char));
891
929
                if (buf) {
892
930
 
893
931
                        buf[size - 1] = 0;
906
944
                                buf[i-len-1] = '/';
907
945
                                i -= (len + 1);
908
946
                        }
909
 
                        *bufp = buf;
 
947
                        *bufp = buf;
910
948
                } else {
911
 
                        gf_log (table->name, GF_LOG_ERROR,
912
 
                                "out of memory");
913
 
                        ret = -ENOMEM;
914
 
                }
 
949
                        gf_log (table->name, GF_LOG_ERROR,
 
950
                                "out of memory");
 
951
                        ret = -ENOMEM;
 
952
                }
915
953
        }
916
954
unlock:
917
955
        pthread_mutex_unlock (&table->lock);
918
956
 
919
 
        if (inode->ino == 1 && !name) {
920
 
                ret = 1;
921
 
                if (buf) {
922
 
                        FREE (buf);
923
 
                }
924
 
                buf = CALLOC (ret + 1, sizeof (char));
925
 
                if (buf) {
926
 
                        strcpy (buf, "/");
927
 
                        *bufp = buf;
928
 
                } else {
929
 
                        gf_log (table->name, GF_LOG_ERROR,
930
 
                                "out of memory");
931
 
                        ret = -ENOMEM;
932
 
                }
933
 
        }
 
957
        if (inode->ino == 1 && !name) {
 
958
                ret = 1;
 
959
                if (buf) {
 
960
                        FREE (buf);
 
961
                }
 
962
                buf = CALLOC (ret + 1, sizeof (char));
 
963
                if (buf) {
 
964
                        strcpy (buf, "/");
 
965
                        *bufp = buf;
 
966
                } else {
 
967
                        gf_log (table->name, GF_LOG_ERROR,
 
968
                                "out of memory");
 
969
                        ret = -ENOMEM;
 
970
                }
 
971
        }
934
972
 
935
973
        return ret;
936
974
}
940
978
{
941
979
        int               ret = 0;
942
980
        struct list_head  purge = {0, };
943
 
        inode_t          *del = NULL;
944
 
        inode_t          *tmp = NULL;
945
 
        inode_t          *entry = NULL;
 
981
        inode_t          *del = NULL;
 
982
        inode_t          *tmp = NULL;
 
983
        inode_t          *entry = NULL;
946
984
 
947
985
 
948
986
        INIT_LIST_HEAD (&purge);
951
989
        {
952
990
                while (table->lru_limit
953
991
                       && table->lru_size > (table->lru_limit)) {
954
 
        
 
992
 
955
993
                        entry = list_entry (table->lru.next, inode_t, list);
956
994
 
957
995
                        table->lru_size--;
961
999
                }
962
1000
 
963
1001
                list_splice_init (&table->purge, &purge);
964
 
                table->purge_size = 0;
 
1002
                table->purge_size = 0;
965
1003
        }
966
1004
        pthread_mutex_unlock (&table->lock);
967
1005
 
997
1035
inode_table_new (size_t lru_limit, xlator_t *xl)
998
1036
{
999
1037
        inode_table_t *new = NULL;
 
1038
        int            ret = 0;
1000
1039
        int            i = 0;
1001
1040
 
1002
 
 
1003
1041
        new = (void *)calloc (1, sizeof (*new));
1004
1042
        if (!new)
1005
1043
                return NULL;
1037
1075
        INIT_LIST_HEAD (&new->active);
1038
1076
        INIT_LIST_HEAD (&new->lru);
1039
1077
        INIT_LIST_HEAD (&new->purge);
1040
 
 
1041
 
        asprintf (&new->name, "%s/inode", xl->name);
1042
 
 
1043
 
        __inode_table_init_root (new);
 
1078
        INIT_LIST_HEAD (&new->attic);
 
1079
 
 
1080
        ret = asprintf (&new->name, "%s/inode", xl->name);
 
1081
        if (-1 == ret) {
 
1082
                /* TODO: This should be ok to continue, check with avati */
 
1083
                ;
 
1084
        }
 
1085
 
 
1086
        __inode_table_init_root (new);
1044
1087
 
1045
1088
        pthread_mutex_init (&new->lock, NULL);
1046
1089
 
1051
1094
inode_t *
1052
1095
inode_from_path (inode_table_t *itable, const char *path)
1053
1096
{
1054
 
        inode_t  *inode = NULL;
1055
 
        inode_t  *parent = NULL;
1056
 
        inode_t  *root = NULL;
1057
 
        inode_t  *curr = NULL;
1058
 
        char     *pathname = NULL;
1059
 
        char     *component = NULL, *next_component = NULL;
1060
 
        char     *strtokptr = NULL;
1061
 
 
1062
 
        /* top-down approach */
1063
 
        root = itable->root;
1064
 
        parent = inode_ref (root);
1065
 
        pathname = strdup (path);
1066
 
        component = strtok_r (pathname, "/", &strtokptr);
1067
 
 
1068
 
        if (component == NULL)
1069
 
                /* root inode */
1070
 
                inode = inode_ref (parent);
1071
 
 
1072
 
        while (component) {
1073
 
                curr = inode_search (itable, parent->ino, component);
1074
 
                
1075
 
                if (curr == NULL) {
1076
 
                        component = strtok_r (NULL, "/", &strtokptr);
1077
 
                        break;
1078
 
                }
1079
 
 
1080
 
                next_component = strtok_r (NULL, "/", &strtokptr);
1081
 
                
1082
 
                if (next_component) {
1083
 
                        inode_unref (parent);
1084
 
                        parent = curr;
1085
 
                        curr = NULL;
1086
 
                } else {
1087
 
                        inode = curr;
1088
 
                }
1089
 
                
1090
 
                component = next_component;
1091
 
        }
1092
 
        
1093
 
        if (parent)
1094
 
                inode_unref (parent);
1095
 
 
1096
 
        if (pathname)
1097
 
                free (pathname);
1098
 
 
1099
 
        return inode;
 
1097
        inode_t  *inode = NULL;
 
1098
        inode_t  *parent = NULL;
 
1099
        inode_t  *root = NULL;
 
1100
        inode_t  *curr = NULL;
 
1101
        char     *pathname = NULL;
 
1102
        char     *component = NULL, *next_component = NULL;
 
1103
        char     *strtokptr = NULL;
 
1104
 
 
1105
        /* top-down approach */
 
1106
        pathname = strdup (path);
 
1107
        if (pathname == NULL) {
 
1108
                gf_log ("inode", GF_LOG_ERROR, "out of memory");
 
1109
                goto out;
 
1110
        }
 
1111
 
 
1112
        root = itable->root;
 
1113
        parent = inode_ref (root);
 
1114
        component = strtok_r (pathname, "/", &strtokptr);
 
1115
 
 
1116
        if (component == NULL)
 
1117
                /* root inode */
 
1118
                inode = inode_ref (parent);
 
1119
 
 
1120
        while (component) {
 
1121
                curr = inode_grep (itable, parent, component);
 
1122
 
 
1123
                if (curr == NULL) {
 
1124
                        component = strtok_r (NULL, "/", &strtokptr);
 
1125
                        break;
 
1126
                }
 
1127
 
 
1128
                next_component = strtok_r (NULL, "/", &strtokptr);
 
1129
 
 
1130
                if (next_component) {
 
1131
                        inode_unref (parent);
 
1132
                        parent = curr;
 
1133
                        curr = NULL;
 
1134
                } else {
 
1135
                        inode = curr;
 
1136
                }
 
1137
 
 
1138
                component = next_component;
 
1139
        }
 
1140
 
 
1141
        if (parent)
 
1142
                inode_unref (parent);
 
1143
 
 
1144
        if (pathname)
 
1145
                free (pathname);
 
1146
 
 
1147
out:
 
1148
        return inode;
1100
1149
}
1101
1150
 
 
1151
 
1102
1152
int
1103
 
__inode_ctx_put (inode_t *inode, xlator_t *xlator, uint64_t value)
 
1153
__inode_ctx_put2 (inode_t *inode, xlator_t *xlator, uint64_t value1,
 
1154
                  uint64_t value2)
1104
1155
{
1105
1156
        int ret = 0;
1106
1157
        int index = 0;
1113
1164
                        /* dont break, to check if key already exists
1114
1165
                           further on */
1115
1166
                }
1116
 
                if (inode->_ctx[index].key == (uint64_t)(long) xlator) {
 
1167
                if (inode->_ctx[index].xl_key == xlator) {
1117
1168
                        put_idx = index;
1118
1169
                        break;
1119
1170
                }
1120
1171
        }
1121
 
        
 
1172
 
1122
1173
        if (put_idx == -1) {
1123
1174
                ret = -1;
1124
1175
                goto out;;
1125
1176
        }
1126
1177
 
1127
 
        inode->_ctx[put_idx].key   = (uint64_t)(long) xlator;
1128
 
        inode->_ctx[put_idx].value = value;
 
1178
        inode->_ctx[put_idx].xl_key = xlator;
 
1179
        inode->_ctx[put_idx].value1 = value1;
 
1180
        inode->_ctx[put_idx].value2 = value2;
1129
1181
out:
1130
1182
        return ret;
1131
1183
}
1132
1184
 
 
1185
 
1133
1186
int
1134
 
inode_ctx_put (inode_t *inode, xlator_t *xlator, uint64_t value)
 
1187
inode_ctx_put2 (inode_t *inode, xlator_t *xlator, uint64_t value1,
 
1188
                uint64_t value2)
1135
1189
{
1136
1190
        int ret = 0;
1137
1191
 
1138
 
        if (!inode || !xlator)
1139
 
                return -1;
 
1192
        if (!inode || !xlator)
 
1193
                return -1;
1140
1194
 
1141
1195
        LOCK (&inode->lock);
1142
1196
        {
1143
 
                ret = __inode_ctx_put (inode, xlator, value);
 
1197
                ret = __inode_ctx_put2 (inode, xlator, value1, value2);
1144
1198
        }
1145
1199
        UNLOCK (&inode->lock);
1146
1200
 
1147
 
        return ret;
 
1201
        return ret;
1148
1202
}
1149
1203
 
 
1204
 
1150
1205
int
1151
 
__inode_ctx_get (inode_t *inode, xlator_t *xlator, uint64_t *value)
 
1206
__inode_ctx_get2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
 
1207
                  uint64_t *value2)
1152
1208
{
1153
 
        int index = 0;
 
1209
        int index = 0;
1154
1210
        int ret = 0;
 
1211
 
1155
1212
        for (index = 0; index < xlator->ctx->xl_count; index++) {
1156
 
                if (inode->_ctx[index].key == (uint64_t)(long)xlator)
 
1213
                if (inode->_ctx[index].xl_key == xlator)
1157
1214
                        break;
1158
1215
        }
1159
1216
 
1162
1219
                goto out;
1163
1220
        }
1164
1221
 
1165
 
        if (value) 
1166
 
                *value = inode->_ctx[index].value;
 
1222
        if (value1)
 
1223
                *value1 = inode->_ctx[index].value1;
 
1224
 
 
1225
        if (value2)
 
1226
                *value2 = inode->_ctx[index].value2;
1167
1227
 
1168
1228
out:
1169
1229
        return ret;
1170
1230
}
1171
1231
 
1172
 
int 
1173
 
inode_ctx_get (inode_t *inode, xlator_t *xlator, uint64_t *value)
 
1232
 
 
1233
int
 
1234
inode_ctx_get2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
 
1235
                uint64_t *value2)
1174
1236
{
1175
1237
        int ret = 0;
1176
1238
 
1177
 
        if (!inode || !xlator)
1178
 
                return -1;
 
1239
        if (!inode || !xlator)
 
1240
                return -1;
1179
1241
 
1180
1242
        LOCK (&inode->lock);
1181
1243
        {
1182
 
                ret = __inode_ctx_get (inode, xlator, value);
 
1244
                ret = __inode_ctx_get2 (inode, xlator, value1, value2);
1183
1245
        }
1184
1246
        UNLOCK (&inode->lock);
1185
1247
 
1186
 
        return ret;
 
1248
        return ret;
1187
1249
}
1188
1250
 
1189
1251
 
1190
 
int 
1191
 
inode_ctx_del (inode_t *inode, xlator_t *xlator, uint64_t *value)
 
1252
int
 
1253
inode_ctx_del2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
 
1254
                uint64_t *value2)
1192
1255
{
1193
 
        int index = 0;
 
1256
        int index = 0;
1194
1257
        int ret = 0;
1195
1258
 
1196
 
        if (!inode || !xlator)
1197
 
                return -1;
 
1259
        if (!inode || !xlator)
 
1260
                return -1;
1198
1261
 
1199
1262
        LOCK (&inode->lock);
1200
1263
        {
1201
1264
                for (index = 0; index < xlator->ctx->xl_count; index++) {
1202
 
                        if (inode->_ctx[index].key == (uint64_t)(long)xlator)
 
1265
                        if (inode->_ctx[index].xl_key == xlator)
1203
1266
                                break;
1204
1267
                }
1205
1268
 
1208
1271
                        goto unlock;
1209
1272
                }
1210
1273
 
1211
 
                if (value)
1212
 
                        *value = inode->_ctx[index].value;              
 
1274
                if (value1)
 
1275
                        *value1 = inode->_ctx[index].value1;
 
1276
                if (value2)
 
1277
                        *value2 = inode->_ctx[index].value2;
1213
1278
 
1214
 
                inode->_ctx[index].key   = 0;
1215
 
                inode->_ctx[index].value = 0;
 
1279
                inode->_ctx[index].key    = 0;
 
1280
                inode->_ctx[index].value1 = 0;
 
1281
                inode->_ctx[index].value2 = 0;
1216
1282
        }
1217
1283
unlock:
1218
1284
        UNLOCK (&inode->lock);
1219
1285
 
1220
 
        return ret;
 
1286
        return ret;
 
1287
}
 
1288
 
 
1289
 
 
1290
int
 
1291
__inode_ctx_put (inode_t *inode, xlator_t *key, uint64_t value)
 
1292
{
 
1293
        return __inode_ctx_put2 (inode, key, value, 0);
 
1294
}
 
1295
 
 
1296
 
 
1297
int
 
1298
inode_ctx_put (inode_t *inode, xlator_t *key, uint64_t value)
 
1299
{
 
1300
        return inode_ctx_put2 (inode, key, value, 0);
 
1301
}
 
1302
 
 
1303
 
 
1304
int
 
1305
__inode_ctx_get (inode_t *inode, xlator_t *key, uint64_t *value)
 
1306
{
 
1307
        return __inode_ctx_get2 (inode, key, value, 0);
 
1308
}
 
1309
 
 
1310
 
 
1311
int
 
1312
inode_ctx_get (inode_t *inode, xlator_t *key, uint64_t *value)
 
1313
{
 
1314
        return inode_ctx_get2 (inode, key, value, 0);
 
1315
}
 
1316
 
 
1317
 
 
1318
int
 
1319
inode_ctx_del (inode_t *inode, xlator_t *key, uint64_t *value)
 
1320
{
 
1321
        return inode_ctx_del2 (inode, key, value, 0);
 
1322
}
 
1323
 
 
1324
 
 
1325
void
 
1326
inode_dump (inode_t *inode, char *prefix)
 
1327
{
 
1328
        char            key[GF_DUMP_MAX_BUF_LEN];
 
1329
        int             ret = -1;
 
1330
        xlator_t        *xl = NULL;
 
1331
        int             i = 0;
 
1332
 
 
1333
        if (!inode)
 
1334
                return;
 
1335
 
 
1336
        ret = TRY_LOCK(&inode->lock);
 
1337
 
 
1338
        if (ret != 0) {
 
1339
                gf_log("", GF_LOG_WARNING, "Unable to dump inode"
 
1340
                       " errno: %d", errno);
 
1341
                return;
 
1342
        }
 
1343
 
 
1344
        gf_proc_dump_build_key(key, prefix, "nlookup");
 
1345
        gf_proc_dump_write(key, "%ld", inode->nlookup);
 
1346
        gf_proc_dump_build_key(key, prefix, "generation");
 
1347
        gf_proc_dump_write(key, "%ld", inode->generation);
 
1348
        gf_proc_dump_build_key(key, prefix, "ref");
 
1349
        gf_proc_dump_write(key, "%u", inode->ref);
 
1350
        gf_proc_dump_build_key(key, prefix, "ino");
 
1351
        gf_proc_dump_write(key, "%ld", inode->ino);
 
1352
        gf_proc_dump_build_key(key, prefix, "st_mode");
 
1353
        gf_proc_dump_write(key, "%d", inode->st_mode);
 
1354
        UNLOCK(&inode->lock);
 
1355
        if (!inode->_ctx)
 
1356
                goto out;
 
1357
 
 
1358
        for (i = 0; i < inode->table->xl->ctx->xl_count; i++) {
 
1359
                if (inode->_ctx[i].key) {
 
1360
                        xl = (xlator_t *)(long)inode->_ctx[i].key;
 
1361
                        if (xl->dumpops && xl->dumpops->inodectx)
 
1362
                                xl->dumpops->inodectx (xl, inode);
 
1363
                }
 
1364
        }
 
1365
 
 
1366
out:
 
1367
        return;
 
1368
}
 
1369
 
 
1370
void
 
1371
inode_table_dump (inode_table_t *itable, char *prefix)
 
1372
{
 
1373
 
 
1374
        char    key[GF_DUMP_MAX_BUF_LEN];
 
1375
        int     ret = 0;
 
1376
 
 
1377
        if (!itable)
 
1378
                return;
 
1379
 
 
1380
        memset(key, 0, sizeof(key));
 
1381
        ret = pthread_mutex_trylock(&itable->lock);
 
1382
 
 
1383
        if (ret != 0) {
 
1384
                gf_log("", GF_LOG_WARNING, "Unable to dump inode table"
 
1385
                       " errno: %d", errno);
 
1386
                return;
 
1387
        }
 
1388
 
 
1389
        gf_proc_dump_build_key(key, prefix, "hashsize");
 
1390
        gf_proc_dump_write(key, "%d", itable->hashsize);
 
1391
        gf_proc_dump_build_key(key, prefix, "name");
 
1392
        gf_proc_dump_write(key, "%s", itable->name);
 
1393
 
 
1394
        gf_proc_dump_build_key(key, prefix, "lru_limit");
 
1395
        gf_proc_dump_write(key, "%d", itable->lru_limit);
 
1396
        gf_proc_dump_build_key(key, prefix, "active_size");
 
1397
        gf_proc_dump_write(key, "%d", itable->active_size);
 
1398
        gf_proc_dump_build_key(key, prefix, "lru_size");
 
1399
        gf_proc_dump_write(key, "%d", itable->lru_size);
 
1400
        gf_proc_dump_build_key(key, prefix, "purge_size");
 
1401
        gf_proc_dump_write(key, "%d", itable->purge_size);
 
1402
 
 
1403
        INODE_DUMP_LIST(&itable->active, key, prefix, "active");
 
1404
        INODE_DUMP_LIST(&itable->lru, key, prefix, "lru");
 
1405
        INODE_DUMP_LIST(&itable->purge, key, prefix, "purge");
 
1406
 
 
1407
        pthread_mutex_unlock(&itable->lock);
1221
1408
}