← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/staging/autofs/dirhash.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/autofs/dirhash.c
1
 
/* -*- linux-c -*- --------------------------------------------------------- *
2
 
 *
3
 
 * drivers/staging/autofs/dirhash.c
4
 
 *
5
 
 *  Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
6
 
 *
7
 
 * This file is part of the Linux kernel and is made available under
8
 
 * the terms of the GNU General Public License, version 2, or at your
9
 
 * option, any later version, incorporated herein by reference.
10
 
 *
11
 
 * ------------------------------------------------------------------------- */
12
 
 
13
 
#include "autofs_i.h"
14
 
 
15
 
/* Functions for maintenance of expiry queue */
16
 
 
17
 
static void autofs_init_usage(struct autofs_dirhash *dh,
18
 
                              struct autofs_dir_ent *ent)
19
 
{
20
 
        list_add_tail(&ent->exp, &dh->expiry_head);
21
 
        ent->last_usage = jiffies;
22
 
}
23
 
 
24
 
static void autofs_delete_usage(struct autofs_dir_ent *ent)
25
 
{
26
 
        list_del(&ent->exp);
27
 
}
28
 
 
29
 
void autofs_update_usage(struct autofs_dirhash *dh,
30
 
                         struct autofs_dir_ent *ent)
31
 
{
32
 
        autofs_delete_usage(ent);   /* Unlink from current position */
33
 
        autofs_init_usage(dh, ent);  /* Relink at queue tail */
34
 
}
35
 
 
36
 
struct autofs_dir_ent *autofs_expire(struct super_block *sb,
37
 
                                     struct autofs_sb_info *sbi,
38
 
                                     struct vfsmount *mnt)
39
 
{
40
 
        struct autofs_dirhash *dh = &sbi->dirhash;
41
 
        struct autofs_dir_ent *ent;
42
 
        unsigned long timeout = sbi->exp_timeout;
43
 
 
44
 
        while (1) {
45
 
                struct path path;
46
 
                int umount_ok;
47
 
 
48
 
                if (list_empty(&dh->expiry_head) || sbi->catatonic)
49
 
                        return NULL;    /* No entries */
50
 
                /* We keep the list sorted by last_usage and want old stuff */
51
 
                ent = list_entry(dh->expiry_head.next,
52
 
                                                struct autofs_dir_ent, exp);
53
 
                if (jiffies - ent->last_usage < timeout)
54
 
                        break;
55
 
                /* Move to end of list in case expiry isn't desirable */
56
 
                autofs_update_usage(dh, ent);
57
 
 
58
 
                /* Check to see that entry is expirable */
59
 
                if (ent->ino < AUTOFS_FIRST_DIR_INO)
60
 
                        return ent; /* Symlinks are always expirable */
61
 
 
62
 
                /* Get the dentry for the autofs subdirectory */
63
 
                path.dentry = ent->dentry;
64
 
 
65
 
                if (!path.dentry) {
66
 
                        /* Should only happen in catatonic mode */
67
 
                        printk(KERN_DEBUG "autofs: dentry == NULL but inode \
68
 
                                range is directory, entry %s\n", ent->name);
69
 
                        autofs_delete_usage(ent);
70
 
                        continue;
71
 
                }
72
 
 
73
 
                if (!path.dentry->d_inode) {
74
 
                        dput(path.dentry);
75
 
                        printk(KERN_DEBUG "autofs: negative dentry on expiry queue: %s\n",
76
 
                               ent->name);
77
 
                        autofs_delete_usage(ent);
78
 
                        continue;
79
 
                }
80
 
 
81
 
                /* Make sure entry is mounted and unused; note that dentry will
82
 
                   point to the mounted-on-top root. */
83
 
                if (!S_ISDIR(path.dentry->d_inode->i_mode) ||
84
 
                    !d_mountpoint(path.dentry)) {
85
 
                        DPRINTK(("autofs: not expirable \
86
 
                                (not a mounted directory): %s\n", ent->name));
87
 
                        continue;
88
 
                }
89
 
                path.mnt = mnt;
90
 
                path_get(&path);
91
 
                if (!follow_down_one(&path)) {
92
 
                        path_put(&path);
93
 
                        DPRINTK(("autofs: not expirable\
94
 
                        (not a mounted directory): %s\n", ent->name));
95
 
                        continue;
96
 
                }
97
 
                follow_down(&path, false);  // TODO: need to check error
98
 
                umount_ok = may_umount(path.mnt);
99
 
                path_put(&path);
100
 
 
101
 
                if (umount_ok) {
102
 
                        DPRINTK(("autofs: signaling expire on %s\n",
103
 
                                                                ent->name));
104
 
                        return ent; /* Expirable! */
105
 
                }
106
 
 
107
 
                DPRINTK(("autofs: didn't expire due to may_umount: %s\n",
108
 
                                                                ent->name));
109
 
        }
110
 
        return NULL;            /* No expirable entries */
111
 
}
112
 
 
113
 
void autofs_initialize_hash(struct autofs_dirhash *dh)
114
 
{
115
 
        memset(&dh->h, 0, AUTOFS_HASH_SIZE*sizeof(struct autofs_dir_ent *));
116
 
        INIT_LIST_HEAD(&dh->expiry_head);
117
 
}
118
 
 
119
 
struct autofs_dir_ent *autofs_hash_lookup(const struct autofs_dirhash *dh,
120
 
                                                struct qstr *name)
121
 
{
122
 
        struct autofs_dir_ent *dhn;
123
 
 
124
 
        DPRINTK(("autofs_hash_lookup: hash = 0x%08x, name = ", name->hash));
125
 
        autofs_say(name->name, name->len);
126
 
 
127
 
        for (dhn = dh->h[(unsigned) name->hash % AUTOFS_HASH_SIZE];
128
 
                dhn;
129
 
                dhn = dhn->next) {
130
 
                if (name->hash == dhn->hash &&
131
 
                     name->len == dhn->len &&
132
 
                     !memcmp(name->name, dhn->name, name->len))
133
 
                        break;
134
 
        }
135
 
 
136
 
        return dhn;
137
 
}
138
 
 
139
 
void autofs_hash_insert(struct autofs_dirhash *dh, struct autofs_dir_ent *ent)
140
 
{
141
 
        struct autofs_dir_ent **dhnp;
142
 
 
143
 
        DPRINTK(("autofs_hash_insert: hash = 0x%08x, name = ", ent->hash));
144
 
        autofs_say(ent->name, ent->len);
145
 
 
146
 
        autofs_init_usage(dh, ent);
147
 
        if (ent->dentry)
148
 
                dget(ent->dentry);
149
 
 
150
 
        dhnp = &dh->h[(unsigned) ent->hash % AUTOFS_HASH_SIZE];
151
 
        ent->next = *dhnp;
152
 
        ent->back = dhnp;
153
 
        *dhnp = ent;
154
 
        if (ent->next)
155
 
                ent->next->back = &(ent->next);
156
 
}
157
 
 
158
 
void autofs_hash_delete(struct autofs_dir_ent *ent)
159
 
{
160
 
        *(ent->back) = ent->next;
161
 
        if (ent->next)
162
 
                ent->next->back = ent->back;
163
 
 
164
 
        autofs_delete_usage(ent);
165
 
 
166
 
        if (ent->dentry)
167
 
                dput(ent->dentry);
168
 
        kfree(ent->name);
169
 
        kfree(ent);
170
 
}
171
 
 
172
 
/*
173
 
 * Used by readdir().  We must validate "ptr", so we can't simply make it
174
 
 * a pointer.  Values below 0xffff are reserved; calling with any value
175
 
 * <= 0x10000 will return the first entry found.
176
 
 *
177
 
 * "last" can be NULL or the value returned by the last search *if* we
178
 
 * want the next sequential entry.
179
 
 */
180
 
struct autofs_dir_ent *autofs_hash_enum(const struct autofs_dirhash *dh,
181
 
                                        off_t *ptr, struct autofs_dir_ent *last)
182
 
{
183
 
        int bucket, ecount, i;
184
 
        struct autofs_dir_ent *ent;
185
 
 
186
 
        bucket = (*ptr >> 16) - 1;
187
 
        ecount = *ptr & 0xffff;
188
 
 
189
 
        if (bucket < 0)
190
 
                bucket = ecount = 0;
191
 
 
192
 
        DPRINTK(("autofs_hash_enum: bucket %d, entry %d\n", bucket, ecount));
193
 
 
194
 
        ent = last ? last->next : NULL;
195
 
 
196
 
        if (ent) {
197
 
                ecount++;
198
 
        } else {
199
 
                while  (bucket < AUTOFS_HASH_SIZE) {
200
 
                        ent = dh->h[bucket];
201
 
                        for (i = ecount ; ent && i ; i--)
202
 
                                ent = ent->next;
203
 
 
204
 
                        if (ent) {
205
 
                                ecount++; /* Point to *next* entry */
206
 
                                break;
207
 
                        }
208
 
 
209
 
                        bucket++; ecount = 0;
210
 
                }
211
 
        }
212
 
 
213
 
#ifdef DEBUG
214
 
        if (!ent)
215
 
                printk(KERN_DEBUG "autofs_hash_enum: nothing found\n");
216
 
        else {
217
 
                printk(KERN_DEBUG "autofs_hash_enum: found hash %08x, name",
218
 
                                                                ent->hash);
219
 
                autofs_say(ent->name, ent->len);
220
 
        }
221
 
#endif
222
 
 
223
 
        *ptr = ((bucket+1) << 16) + ecount;
224
 
        return ent;
225
 
}
226
 
 
227
 
/* Iterate over all the ents, and remove all dentry pointers.  Used on
228
 
   entering catatonic mode, in order to make the filesystem unmountable. */
229
 
void autofs_hash_dputall(struct autofs_dirhash *dh)
230
 
{
231
 
        int i;
232
 
        struct autofs_dir_ent *ent;
233
 
 
234
 
        for (i = 0 ; i < AUTOFS_HASH_SIZE ; i++) {
235
 
                for (ent = dh->h[i] ; ent ; ent = ent->next) {
236
 
                        if (ent->dentry) {
237
 
                                dput(ent->dentry);
238
 
                                ent->dentry = NULL;
239
 
                        }
240
 
                }
241
 
        }
242
 
}
243
 
 
244
 
/* Delete everything.  This is used on filesystem destruction, so we
245
 
   make no attempt to keep the pointers valid */
246
 
void autofs_hash_nuke(struct autofs_sb_info *sbi)
247
 
{
248
 
        int i;
249
 
        struct autofs_dir_ent *ent, *nent;
250
 
 
251
 
        for (i = 0 ; i < AUTOFS_HASH_SIZE ; i++) {
252
 
                for (ent = sbi->dirhash.h[i] ; ent ; ent = nent) {
253
 
                        nent = ent->next;
254
 
                        if (ent->dentry)
255
 
                                dput(ent->dentry);
256
 
                        kfree(ent->name);
257
 
                        kfree(ent);
258
 
                }
259
 
        }
260
 
}