Whamcloud - gitweb
LU-15122 osd-ldiskfs: Fix ASSERTION( iobuf->dr_rw == 0 ) with 64KB PAGE_SIZE
[fs/lustre-release.git] / lustre / target / tgt_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.gnu.org/licenses/gpl-2.0.html
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
24  * Use is subject to license terms.
25  *
26  * Copyright (c) 2012, 2014, Intel Corporation.
27  *
28  * Copyright (c) 2019, DDN Storage Corporation.
29  */
30 /*
31  * This file is part of Lustre, http://www.lustre.org/
32  *
33  * lustre/target/tgt_fmd.c
34  *
35  * This file provides functions to handle Filter Modification Data (FMD).
36  * The FMD is responsible for file attributes to be applied in
37  * Transaction ID (XID) order, so older requests can't re-write newer
38  * attributes.
39  *
40  * FMD is organized as per-client list and identified by FID of object. Each
41  * FMD stores FID of object and the highest received XID of modification
42  * request for this object.
43  *
44  * FMD can expire if there are no updates for a long time to keep the list
45  * reasonably small.
46  *
47  * Author: Andreas Dilger <adilger@whamcloud.com>
48  * Author: Mike Pershin <mpershin@whamcloud.com>
49  */
50
51 #define DEBUG_SUBSYSTEM S_CLASS
52
53 #include <obd.h>
54 #include <obd_class.h>
55
56 #include "tgt_internal.h"
57
58 /**
59  * Drop FMD reference and free it if reference drops to zero.
60  *
61  * Must be called with ted_fmd_lock held.
62  *
63  * \param[in] exp       OBD export
64  * \param[in] fmd       FMD to put
65  */
66 static inline void tgt_fmd_put_nolock(struct obd_export *exp,
67                                       struct tgt_fmd_data *fmd)
68 {
69         struct tg_export_data *ted = &exp->exp_target_data;
70
71         assert_spin_locked(&ted->ted_fmd_lock);
72         if (--fmd->fmd_refcount == 0) {
73                 ted->ted_fmd_count--;
74                 list_del(&fmd->fmd_list);
75                 OBD_SLAB_FREE_PTR(fmd, tgt_fmd_kmem);
76         }
77 }
78
79 /**
80  * Wrapper to drop FMD reference with ted_fmd_lock held.
81  *
82  * \param[in] exp       OBD export
83  * \param[in] fmd       FMD to put
84  */
85 void tgt_fmd_put(struct obd_export *exp, struct tgt_fmd_data *fmd)
86 {
87         struct tg_export_data *ted = &exp->exp_target_data;
88
89         spin_lock(&ted->ted_fmd_lock);
90         tgt_fmd_put_nolock(exp, fmd); /* caller reference */
91         spin_unlock(&ted->ted_fmd_lock);
92 }
93
94 /**
95  * Expire FMD entries.
96  *
97  * Expire entries from the FMD list if there are too many
98  * of them or they are too old.
99  *
100  * This function must be called with ted_fmd_lock held.
101  *
102  * The \a keep FMD is not to be expired in any case. This parameter is used
103  * by ofd_fmd_find_nolock() to prohibit a FMD that was just found from
104  * expiring.
105  *
106  * \param[in] exp       OBD export
107  * \param[in] keep      FMD to keep always
108  */
109 static void tgt_fmd_expire_nolock(struct obd_export *exp,
110                                   struct tgt_fmd_data *keep)
111 {
112         struct tg_export_data *ted = &exp->exp_target_data;
113         struct lu_target *lut = exp->exp_obd->u.obt.obt_lut;
114         time64_t now = ktime_get_seconds();
115         struct tgt_fmd_data *fmd, *tmp;
116
117         list_for_each_entry_safe(fmd, tmp, &ted->ted_fmd_list, fmd_list) {
118                 if (fmd == keep)
119                         break;
120
121                 if (now < fmd->fmd_expire &&
122                     ted->ted_fmd_count < lut->lut_fmd_max_num)
123                         break;
124
125                 list_del_init(&fmd->fmd_list);
126                 tgt_fmd_put_nolock(exp, fmd); /* list reference */
127         }
128 }
129
130 /**
131  * Expire FMD entries.
132  *
133  * This is a wrapper to call ofd_fmd_expire_nolock() with the required lock.
134  *
135  * \param[in] exp       OBD export
136  */
137 void tgt_fmd_expire(struct obd_export *exp)
138 {
139         struct tg_export_data *ted = &exp->exp_target_data;
140
141         spin_lock(&ted->ted_fmd_lock);
142         tgt_fmd_expire_nolock(exp, NULL);
143         spin_unlock(&ted->ted_fmd_lock);
144 }
145
146 /**
147  * Find FMD by specified FID.
148  *
149  * Function finds FMD entry by FID in the tg_export_data::ted_fmd_list.
150  *
151  * Caller must hold tg_export_data::ted_fmd_lock and take FMD reference.
152  *
153  * \param[in] exp       OBD export
154  * \param[in] fid       FID of FMD to find
155  *
156  * \retval              struct tgt_fmd_data found by FID
157  * \retval              NULL is FMD is not found
158  */
159 static struct tgt_fmd_data *tgt_fmd_find_nolock(struct obd_export *exp,
160                                                 const struct lu_fid *fid)
161 {
162         struct tg_export_data *ted = &exp->exp_target_data;
163         struct tgt_fmd_data *found = NULL, *fmd;
164         struct lu_target *lut = exp->exp_obd->u.obt.obt_lut;
165         time64_t now = ktime_get_seconds();
166
167         assert_spin_locked(&ted->ted_fmd_lock);
168
169         list_for_each_entry_reverse(fmd, &ted->ted_fmd_list, fmd_list) {
170                 if (lu_fid_eq(&fmd->fmd_fid, fid)) {
171                         found = fmd;
172                         list_move_tail(&fmd->fmd_list, &ted->ted_fmd_list);
173                         fmd->fmd_expire = now + lut->lut_fmd_max_age;
174                         break;
175                 }
176         }
177
178         tgt_fmd_expire_nolock(exp, found);
179
180         return found;
181 }
182
183 /**
184  * Find FMD by specified FID with locking.
185  *
186  * Wrapper to the ofd_fmd_find_nolock() with correct locks.
187  *
188  * \param[in] exp       OBD export
189  * \param[in] fid       FID of FMD to find
190  *
191  * \retval              struct tgt_fmd_data found by FID
192  * \retval              NULL indicates FMD is not found
193  */
194 struct tgt_fmd_data *tgt_fmd_find(struct obd_export *exp,
195                                   const struct lu_fid *fid)
196 {
197         struct tg_export_data *ted = &exp->exp_target_data;
198         struct tgt_fmd_data *fmd;
199
200         spin_lock(&ted->ted_fmd_lock);
201         fmd = tgt_fmd_find_nolock(exp, fid);
202         if (fmd)
203                 fmd->fmd_refcount++;    /* caller reference */
204         spin_unlock(&ted->ted_fmd_lock);
205
206         return fmd;
207 }
208
209 /**
210  * Find FMD by FID or create a new one if none is found.
211  *
212  * It is possible for this function to return NULL under memory pressure,
213  * or if the passed FID is zero (which will only cause old entries to expire).
214  * Currently this is not fatal because any FMD state is transient and
215  * may also be freed when it gets sufficiently old.
216  *
217  * \param[in] exp       OBD export
218  * \param[in] fid       FID of FMD to find
219  *
220  * \retval              struct tgt_fmd_data found by FID
221  * \retval              NULL indicates FMD is not found
222  */
223 struct tgt_fmd_data *tgt_fmd_get(struct obd_export *exp,
224                                  const struct lu_fid *fid)
225 {
226         struct tg_export_data *ted = &exp->exp_target_data;
227         struct tgt_fmd_data *found = NULL, *fmd_new = NULL;
228
229         OBD_SLAB_ALLOC_PTR(fmd_new, tgt_fmd_kmem);
230
231         spin_lock(&ted->ted_fmd_lock);
232         found = tgt_fmd_find_nolock(exp, fid);
233         if (fmd_new) {
234                 if (!found) {
235                         list_add_tail(&fmd_new->fmd_list, &ted->ted_fmd_list);
236                         fmd_new->fmd_fid = *fid;
237                         fmd_new->fmd_refcount++;   /* list reference */
238                         found = fmd_new;
239                         ted->ted_fmd_count++;
240                 } else {
241                         OBD_SLAB_FREE_PTR(fmd_new, tgt_fmd_kmem);
242                 }
243         }
244         if (found) {
245                 found->fmd_refcount++; /* caller reference */
246                 found->fmd_expire = ktime_get_seconds() +
247                         class_exp2tgt(exp)->lut_fmd_max_age;
248         } else {
249                 LCONSOLE_WARN("%s: cannot allocate FMD for "DFID
250                               ", timestamps may be out of sync\n",
251                               exp->exp_obd->obd_name, PFID(fid));
252         }
253         spin_unlock(&ted->ted_fmd_lock);
254
255         return found;
256 }
257
258 #ifdef DO_FMD_DROP
259 /**
260  * Drop FMD list reference so it will disappear when last reference is dropped
261  * to zero.
262  *
263  * This function is called from ofd_destroy() and may only affect
264  * the one client that is doing the unlink and at worst we have an stale entry
265  * referencing an object that should never be used again.
266  *
267  * NB: this function is used only if DO_FMD_DROP is defined. It is not
268  * currently defined, so FMD drop doesn't happen and FMD are dropped only
269  * when expired.
270  *
271  * \param[in] exp       OBD export
272  * \param[in] fid       FID of FMD to drop
273  */
274 void tgt_fmd_drop(struct obd_export *exp, const struct lu_fid *fid)
275 {
276         struct tg_export_data *ted = &exp->exp_target_data;
277         struct tgt_fmd_data *fmd = NULL;
278
279         spin_lock(&ted->ted_fmd_lock);
280         fmd = tgt_fmd_find_nolock(exp, fid);
281         if (fmd) {
282                 list_del_init(&fmd->fmd_list);
283                 tgt_fmd_put_nolock(exp, fmd);
284         }
285         spin_unlock(&ted->ted_fmd_lock);
286 }
287 EXPORT_SYMBOL(tgt_fmd_drop);
288 #endif
289
290 /**
291  * Remove all entries from FMD list.
292  *
293  * Cleanup function to free all FMD enries on the given export.
294  *
295  * \param[in] exp       OBD export
296  */
297 void tgt_fmd_cleanup(struct obd_export *exp)
298 {
299         struct tg_export_data *ted = &exp->exp_target_data;
300         struct tgt_fmd_data *fmd = NULL, *tmp;
301
302         spin_lock(&ted->ted_fmd_lock);
303         list_for_each_entry_safe(fmd, tmp, &ted->ted_fmd_list, fmd_list) {
304                 list_del_init(&fmd->fmd_list);
305                 if (fmd->fmd_refcount > 1) {
306                         CDEBUG(D_INFO,
307                                "fmd %p still referenced (refcount = %d)\n",
308                                fmd, fmd->fmd_refcount);
309                 }
310                 tgt_fmd_put_nolock(exp, fmd);
311         }
312         spin_unlock(&ted->ted_fmd_lock);
313         LASSERT(list_empty(&exp->exp_target_data.ted_fmd_list));
314 }
315
316 /**
317  * Update FMD with the latest request XID.
318  *
319  * Save a new setattr/punch XID in FMD if exists.
320  *
321  * \param[in] exp       OBD export
322  * \param[in] fid       FID of FMD to find
323  * \param[in] xid       request XID
324  */
325 void tgt_fmd_update(struct obd_export *exp, const struct lu_fid *fid, __u64 xid)
326 {
327         struct tgt_fmd_data *fmd;
328
329         fmd = tgt_fmd_get(exp, fid);
330         if (fmd) {
331                 if (fmd->fmd_mactime_xid < xid)
332                         fmd->fmd_mactime_xid = xid;
333                 tgt_fmd_put(exp, fmd);
334         }
335 }
336 EXPORT_SYMBOL(tgt_fmd_update);
337
338 /**
339  * Chech that time can be updated by the request with given XID.
340  *
341  * Check FMD XID if exists to be less than supplied XID
342  *
343  * \param[in] exp       OBD export
344  * \param[in] fid       FID of FMD to find
345  * \param[in] xid       request XID
346  *
347  * \retval true if FMD has no greater XID, so time attr can be updated
348  */
349 bool tgt_fmd_check(struct obd_export *exp, const struct lu_fid *fid, __u64 xid)
350 {
351         struct tgt_fmd_data *fmd;
352         bool can_update = true;
353
354         fmd = tgt_fmd_find(exp, fid);
355         if (fmd) {
356                 can_update = fmd->fmd_mactime_xid < xid;
357                 tgt_fmd_put(exp, fmd);
358         }
359
360         return can_update;
361 }
362 EXPORT_SYMBOL(tgt_fmd_check);
363