summaryrefslogtreecommitdiffstats
path: root/libglusterfs/src/gf-dirent.c
blob: f6fd3ab54ee62536104899d88a801f195b3fd47e (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
/*
  Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com>
  This file is part of GlusterFS.

  This file is licensed to you under your choice of the GNU Lesser
  General Public License, version 3 or any later version (LGPLv3 or
  later), or the GNU General Public License, version 2 (GPLv2), in all
  cases as published by the Free Software Foundation.
*/


#ifndef _CONFIG_H
#define _CONFIG_H
#include "config.h"
#endif


#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include "compat.h"
#include "xlator.h"

gf_dirent_t *
gf_dirent_for_name (const char *name)
{
        gf_dirent_t *gf_dirent = NULL;

        /* TODO: use mem-pool */
        gf_dirent = GF_CALLOC (gf_dirent_size (name), 1,
                               gf_common_mt_gf_dirent_t);
        if (!gf_dirent)
                return NULL;

        INIT_LIST_HEAD (&gf_dirent->list);
        strcpy (gf_dirent->d_name, name);

        gf_dirent->d_off = 0;
        gf_dirent->d_ino = -1;
        gf_dirent->d_type = 0;
        gf_dirent->d_len = strlen (name);

        return gf_dirent;
}


void
gf_dirent_free (gf_dirent_t *entries)
{
        gf_dirent_t *entry = NULL;
        gf_dirent_t *tmp = NULL;

        if (!entries)
                return;

        if (list_empty (&entries->list))
                return;

        list_for_each_entry_safe (entry, tmp, &entries->list, list) {
                if (entry->dict)
                        dict_unref (entry->dict);
                if (entry->inode)
                        inode_unref (entry->inode);

                list_del (&entry->list);
                GF_FREE (entry);
        }
}

void
gf_link_inode_from_dirent (xlator_t *this, inode_t *parent, gf_dirent_t *entry)
{
        inode_t     *link_inode = NULL;
        inode_t     *tmp        = NULL;

        if (!entry->inode)
                return;
        link_inode = inode_link (entry->inode, parent,
                                 entry->d_name, &entry->d_stat);
        if (!link_inode)
                return;

        inode_lookup (link_inode);
        tmp = entry->inode;
        entry->inode = link_inode;
        inode_unref (tmp);
}

/* TODO: Currently, with this function, we will be breaking the
   policy of 1-1 mapping of kernel nlookup refs with our inode_t's
   nlookup count.
   Need more thoughts before finalizing this function
*/
int
gf_link_inodes_from_dirent (xlator_t *this, inode_t *parent,
                            gf_dirent_t *entries)
{
        gf_dirent_t *entry      = NULL;

        list_for_each_entry (entry, &entries->list, list) {
                gf_link_inode_from_dirent (this, parent, entry);
        }

        return 0;
}