Whamcloud - gitweb
LU-1346 libcfs: replace libcfs wrappers with kernel API
[fs/lustre-release.git] / lustre / ofd / ofd_fmd.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program 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 version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
19  *
20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21  * CA 95054 USA or visit www.sun.com if you need additional information or
22  * have any questions.
23  *
24  * GPL HEADER END
25  */
26 /*
27  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
28  * Use is subject to license terms.
29  *
30  * Copyright (c) 2011, 2012, Whamcloud, Inc.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  *
36  *  lustre/ofd/filter_fmd.c
37  */
38
39 #define DEBUG_SUBSYSTEM S_FILTER
40
41 #include "ofd_internal.h"
42
43 static cfs_mem_cache_t *ll_fmd_cachep;
44
45 /* drop fmd reference, free it if last ref. must be called with fed_lock held.*/
46 static inline void ofd_fmd_put_nolock(struct obd_export *exp,
47                                       struct ofd_mod_data *fmd)
48 {
49         struct filter_export_data *fed = &exp->exp_filter_data;
50
51         LASSERT_SPIN_LOCKED(&fed->fed_lock);
52         if (--fmd->fmd_refcount == 0) {
53                 /* XXX when we have persistent reservations and the handle
54                  * is stored herein we need to drop it here. */
55                 fed->fed_mod_count--;
56                 cfs_list_del(&fmd->fmd_list);
57                 OBD_SLAB_FREE(fmd, ll_fmd_cachep, sizeof(*fmd));
58         }
59 }
60
61 /* drop fmd reference, free it if last ref */
62 void ofd_fmd_put(struct obd_export *exp, struct ofd_mod_data *fmd)
63 {
64         struct filter_export_data *fed = &exp->exp_filter_data;
65
66         if (fmd == NULL)
67                 return;
68
69         spin_lock(&fed->fed_lock);
70         ofd_fmd_put_nolock(exp, fmd); /* caller reference */
71         spin_unlock(&fed->fed_lock);
72 }
73
74 /* expire entries from the end of the list if there are too many
75  * or they are too old */
76 static void ofd_fmd_expire_nolock(struct obd_export *exp,
77                                   struct ofd_mod_data *keep)
78 {
79         struct filter_export_data       *fed = &exp->exp_filter_data;
80         struct ofd_device               *ofd = ofd_exp(exp);
81         struct ofd_mod_data             *fmd, *tmp;
82
83         cfs_time_t now = cfs_time_current();
84
85         cfs_list_for_each_entry_safe(fmd, tmp, &fed->fed_mod_list, fmd_list) {
86                 if (fmd == keep)
87                         break;
88
89                 if (cfs_time_before(now, fmd->fmd_expire) &&
90                     fed->fed_mod_count < ofd->ofd_fmd_max_num)
91                         break;
92
93                 cfs_list_del_init(&fmd->fmd_list);
94                 ofd_fmd_put_nolock(exp, fmd); /* list reference */
95         }
96 }
97
98 void ofd_fmd_expire(struct obd_export *exp)
99 {
100         struct filter_export_data *fed = &exp->exp_filter_data;
101
102         spin_lock(&fed->fed_lock);
103         ofd_fmd_expire_nolock(exp, NULL);
104         spin_unlock(&fed->fed_lock);
105 }
106
107 /* find specified fid in fed_fmd_list.
108  * caller must hold fed_lock and take fmd reference itself */
109 static struct ofd_mod_data *ofd_fmd_find_nolock(struct obd_export *exp,
110                                                 const struct lu_fid *fid)
111 {
112         struct filter_export_data       *fed = &exp->exp_filter_data;
113         struct ofd_mod_data             *found = NULL, *fmd;
114         struct ofd_device               *ofd = ofd_exp(exp);
115
116         cfs_time_t now = cfs_time_current();
117
118         LASSERT_SPIN_LOCKED(&fed->fed_lock);
119
120         cfs_list_for_each_entry_reverse(fmd, &fed->fed_mod_list, fmd_list) {
121                 if (lu_fid_eq(&fmd->fmd_fid, fid)) {
122                         found = fmd;
123                         cfs_list_del(&fmd->fmd_list);
124                         cfs_list_add_tail(&fmd->fmd_list, &fed->fed_mod_list);
125                         fmd->fmd_expire = cfs_time_add(now, ofd->ofd_fmd_max_age);
126                         break;
127                 }
128         }
129
130         ofd_fmd_expire_nolock(exp, found);
131
132         return found;
133 }
134
135 /* Find fmd based on fid or return NULL if not found. */
136 struct ofd_mod_data *ofd_fmd_find(struct obd_export *exp,
137                                   struct lu_fid *fid)
138 {
139         struct filter_export_data       *fed = &exp->exp_filter_data;
140         struct ofd_mod_data             *fmd;
141
142         spin_lock(&fed->fed_lock);
143         fmd = ofd_fmd_find_nolock(exp, fid);
144         if (fmd)
145                 fmd->fmd_refcount++;    /* caller reference */
146         spin_unlock(&fed->fed_lock);
147
148         return fmd;
149 }
150
151 /* Find fmd based on FID, or create a new one if none is found.
152  * It is possible for this function to return NULL under memory pressure,
153  * or if fid = 0 is passed (which will only cause old entries to expire).
154  * Currently this is not fatal because any fmd state is transient and
155  * may also be freed when it gets sufficiently old. */
156 struct ofd_mod_data *ofd_fmd_get(struct obd_export *exp, struct lu_fid *fid)
157 {
158         struct filter_export_data       *fed = &exp->exp_filter_data;
159         struct ofd_device               *ofd = ofd_exp(exp);
160         struct ofd_mod_data             *found = NULL, *fmd_new = NULL;
161
162         cfs_time_t now = cfs_time_current();
163
164         OBD_SLAB_ALLOC_PTR(fmd_new, ll_fmd_cachep);
165
166         spin_lock(&fed->fed_lock);
167         found = ofd_fmd_find_nolock(exp, fid);
168         if (fmd_new) {
169                 if (found == NULL) {
170                         cfs_list_add_tail(&fmd_new->fmd_list,
171                                           &fed->fed_mod_list);
172                         fmd_new->fmd_fid = *fid;
173                         fmd_new->fmd_refcount++;   /* list reference */
174                         found = fmd_new;
175                         fed->fed_mod_count++;
176                 } else {
177                         OBD_SLAB_FREE_PTR(fmd_new, ll_fmd_cachep);
178                 }
179         }
180         if (found) {
181                 found->fmd_refcount++; /* caller reference */
182                 found->fmd_expire = cfs_time_add(now, ofd->ofd_fmd_max_age);
183         }
184
185         spin_unlock(&fed->fed_lock);
186
187         return found;
188 }
189
190 #ifdef DO_FMD_DROP
191 /* drop fmd list reference so it will disappear when last reference is put.
192  * This isn't so critical because it would in fact only affect the one client
193  * that is doing the unlink and at worst we have an stale entry referencing
194  * an object that should never be used again. */
195 void ofd_fmd_drop(struct obd_export *exp, struct lu_fid *fid)
196 {
197         struct filter_export_data       *fed = &exp->exp_filter_data;
198         struct ofd_mod_data             *found = NULL;
199
200         spin_lock(&fed->fed_lock);
201         found = ofd_fmd_find_nolock(exp, fid);
202         if (found) {
203                 cfs_list_del_init(&found->fmd_list);
204                 ofd_fmd_put_nolock(exp, found);
205         }
206         spin_unlock(&fed->fed_lock);
207 }
208 #endif
209
210 /* remove all entries from fmd list */
211 void ofd_fmd_cleanup(struct obd_export *exp)
212 {
213         struct filter_export_data       *fed = &exp->exp_filter_data;
214         struct ofd_mod_data             *fmd = NULL, *tmp;
215
216         spin_lock(&fed->fed_lock);
217         cfs_list_for_each_entry_safe(fmd, tmp, &fed->fed_mod_list, fmd_list) {
218                 cfs_list_del_init(&fmd->fmd_list);
219                 if (fmd->fmd_refcount > 1) {
220                         CDEBUG(D_INFO, "fmd %p still referenced (refcount = %d)\n",
221                                fmd, fmd->fmd_refcount);
222                 }
223                 ofd_fmd_put_nolock(exp, fmd);
224         }
225         spin_unlock(&fed->fed_lock);
226 }
227
228 int ofd_fmd_init(void)
229 {
230         ll_fmd_cachep = cfs_mem_cache_create("ll_fmd_cache",
231                                              sizeof(struct ofd_mod_data),
232                                              0, 0);
233         if (!ll_fmd_cachep)
234                 return -ENOMEM;
235         else
236                 return 0;
237 }
238
239 void ofd_fmd_exit(void)
240 {
241         if (ll_fmd_cachep) {
242                 int rc = cfs_mem_cache_destroy(ll_fmd_cachep);
243
244                 LASSERTF(rc == 0, "Cannot destroy ll_fmd_cachep: rc %d\n", rc);
245                 ll_fmd_cachep = NULL;
246         }
247 }