Whamcloud - gitweb
LU-13922 osd-ldiskfs: no need to add OI cache in readdir
[fs/lustre-release.git] / lustre / ofd / ofd_lvb.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 (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Use is subject to license terms.
25  *
26  * Copyright (c) 2012, 2017, Intel Corporation.
27  */
28 /*
29  * This file is part of Lustre, http://www.lustre.org/
30  * Lustre is a trademark of Sun Microsystems, Inc.
31  *
32  * lustre/ofd/ofd_lvb.c
33  *
34  * This file contains methods for OBD Filter Device (OFD)
35  * Lock Value Block (LVB) operations.
36  *
37  * LVB is special opaque (to LDLM) data that is associated with an LDLM lock
38  * and transferred from client to server and back. OFD LVBs are used to
39  * maintain current object size/times.
40  *
41  * Author: Andreas Dilger <andreas.dilger@intel.com>
42  * Author: Mikhail Pershin <mike.pershin@intel.com>
43  * Author: Alexey Zhuravlev <alexey.zhuravlev@intel.com>
44  */
45
46 #define DEBUG_SUBSYSTEM S_FILTER
47
48 #include <lustre_swab.h>
49 #include "ofd_internal.h"
50
51 /**
52  * Implementation of ldlm_valblock_ops::lvbo_free for OFD.
53  *
54  * This function frees allocated LVB data if it associated with the given
55  * LDLM resource.
56  *
57  * \param[in] res       LDLM resource
58  *
59  * \retval              0 on successful setup
60  * \retval              negative value on error
61  */
62 static int ofd_lvbo_free(struct ldlm_resource *res)
63 {
64         if (res->lr_lvb_data)
65                 OBD_FREE(res->lr_lvb_data, res->lr_lvb_len);
66
67         return 0;
68 }
69
70 /**
71  * Implementation of ldlm_valblock_ops::lvbo_init for OFD.
72  *
73  * This function allocates and initializes new LVB data for the given
74  * LDLM resource if it is not allocated yet. New LVB is filled with attributes
75  * of the object associated with that resource. Function does nothing if LVB
76  * for the given LDLM resource is allocated already.
77  *
78  * Called with res->lr_lvb_sem held.
79  *
80  * \param[in] lock      LDLM lock on resource
81  *
82  * \retval              0 on successful setup
83  * \retval              negative value on error
84  */
85 static int ofd_lvbo_init(struct ldlm_resource *res)
86 {
87         struct ost_lvb          *lvb;
88         struct ofd_device       *ofd;
89         struct ofd_object       *fo;
90         struct ofd_thread_info  *info;
91         struct lu_env *env;
92         int rc = 0;
93         ENTRY;
94
95         LASSERT(res);
96         LASSERT(mutex_is_locked(&res->lr_lvb_mutex));
97
98         if (res->lr_lvb_data != NULL)
99                 RETURN(0);
100
101         ofd = ldlm_res_to_ns(res)->ns_lvbp;
102         LASSERT(ofd != NULL);
103
104         if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_OST_LVB))
105                 RETURN(-ENOMEM);
106
107         env = lu_env_find();
108         LASSERT(env);
109
110         OBD_ALLOC_PTR(lvb);
111         if (lvb == NULL)
112                 GOTO(out, rc = -ENOMEM);
113
114         info = ofd_info(env);
115         res->lr_lvb_data = lvb;
116         res->lr_lvb_len = sizeof(*lvb);
117
118         ost_fid_from_resid(&info->fti_fid, &res->lr_name,
119                            ofd->ofd_lut.lut_lsd.lsd_osd_index);
120         fo = ofd_object_find(env, ofd, &info->fti_fid);
121         if (IS_ERR(fo))
122                 GOTO(out_lvb, rc = PTR_ERR(fo));
123
124         rc = ofd_attr_get(env, fo, &info->fti_attr);
125         if (rc) {
126                 struct ofd_seq          *oseq;
127                 __u64                    seq;
128
129                 /* Object could be recreated during the first
130                  * CLEANUP_ORPHAN request. */
131                 if (rc == -ENOENT) {
132                         seq = fid_seq(&info->fti_fid);
133                         oseq = ofd_seq_load(env, ofd, fid_seq_is_idif(seq) ?
134                                             FID_SEQ_OST_MDT0 : seq);
135                         if (!IS_ERR_OR_NULL(oseq)) {
136                                 if (!oseq->os_last_id_synced)
137                                         rc = -EAGAIN;
138                                 ofd_seq_put(env, oseq);
139                         }
140                 }
141                 GOTO(out_obj, rc);
142         }
143
144         lvb->lvb_size = info->fti_attr.la_size;
145         lvb->lvb_blocks = info->fti_attr.la_blocks;
146         lvb->lvb_mtime = info->fti_attr.la_mtime;
147         lvb->lvb_atime = info->fti_attr.la_atime;
148         lvb->lvb_ctime = info->fti_attr.la_ctime;
149
150         if (fo->ofo_atime_ondisk == 0)
151                 fo->ofo_atime_ondisk = info->fti_attr.la_atime;
152
153         CDEBUG(D_DLMTRACE,
154                "res: "DFID" initial LVB size: %llu, mtime: %#llx, atime: %#llx, ctime: %#llx, blocks: %#llx\n",
155                PFID(&info->fti_fid), lvb->lvb_size, lvb->lvb_mtime,
156                lvb->lvb_atime, lvb->lvb_ctime, lvb->lvb_blocks);
157
158         info->fti_attr.la_valid = 0;
159
160         EXIT;
161 out_obj:
162         ofd_object_put(env, fo);
163 out_lvb:
164         if (rc != 0)
165                 OST_LVB_SET_ERR(lvb->lvb_blocks, rc);
166 out:
167         /* Don't free lvb data on lookup error */
168         return rc;
169 }
170
171 /**
172  * Implementation of ldlm_valblock_ops::lvbo_update for OFD.
173  *
174  * When a client generates a glimpse enqueue, it wants to get the current
175  * file size and updated attributes for a stat() type operation, but these
176  * attributes may be writeback cached on another client. The client with
177  * the DLM extent lock at the highest offset is asked for its current
178  * attributes via a glimpse callback on its extent lock, on the assumption
179  * that it has the highest file size and the newest timestamps. The timestamps
180  * are guaranteed to be correct if there is only a single writer on the file,
181  * but may be slightly inaccurate if there are multiple concurrent writers on
182  * the same object. In order to avoid race conditions between the glimpse AST
183  * and the client cancelling the lock, ofd_lvbo_update() also updates
184  * the attributes from the local object. If the last client hasn't done any
185  * writes yet, or has already written its data and cancelled its lock before
186  * it processed the glimpse, then the local inode will have more uptodate
187  * information.
188  *
189  * This is called in two ways:
190  *  \a req != NULL : called by the DLM itself after a glimpse callback
191  *  \a req == NULL : called by the OFD after a disk write
192  *
193  * \param[in] lock              LDLM lock
194  * \param[in] req               PTLRPC request
195  * \param[in] increase_only     don't allow LVB values to decrease
196  *
197  * \retval              0 on successful setup
198  * \retval              negative value on error
199  */
200 static int ofd_lvbo_update(struct ldlm_resource *res, struct ldlm_lock *lock,
201                            struct ptlrpc_request *req, int increase_only)
202 {
203         struct ofd_thread_info *info;
204         struct ofd_device *ofd;
205         struct ofd_object *fo;
206         struct ost_lvb  *lvb;
207         const struct lu_env *env;
208         int rc = 0;
209
210         ENTRY;
211
212         env = lu_env_find();
213         LASSERT(env);
214         info = ofd_info(env);
215         LASSERT(res != NULL);
216
217         ofd = ldlm_res_to_ns(res)->ns_lvbp;
218         LASSERT(ofd != NULL);
219
220         fid_extract_from_res_name(&info->fti_fid, &res->lr_name);
221
222         lvb = res->lr_lvb_data;
223         if (lvb == NULL) {
224                 CERROR("%s: no LVB data for "DFID"\n",
225                        ofd_name(ofd), PFID(&info->fti_fid));
226                 GOTO(out, rc = 0);
227         }
228
229         /* Update the LVB from the network message */
230         if (req != NULL) {
231                 struct ost_lvb *rpc_lvb;
232                 bool lvb_type;
233
234                 if (req->rq_import != NULL)
235                         lvb_type = imp_connect_lvb_type(req->rq_import);
236                 else
237                         lvb_type = exp_connect_lvb_type(req->rq_export);
238
239                 if (!lvb_type) {
240                         struct ost_lvb_v1 *lvb_v1;
241
242                         lvb_v1 = req_capsule_server_swab_get(&req->rq_pill,
243                                         &RMF_DLM_LVB, lustre_swab_ost_lvb_v1);
244                         if (lvb_v1 == NULL)
245                                 goto disk_update;
246
247                         rpc_lvb = &info->fti_lvb;
248                         memcpy(rpc_lvb, lvb_v1, sizeof *lvb_v1);
249                         rpc_lvb->lvb_mtime_ns = 0;
250                         rpc_lvb->lvb_atime_ns = 0;
251                         rpc_lvb->lvb_ctime_ns = 0;
252                 } else {
253                         rpc_lvb = req_capsule_server_swab_get(&req->rq_pill,
254                                                               &RMF_DLM_LVB,
255                                                         lustre_swab_ost_lvb);
256                         if (rpc_lvb == NULL)
257                                 goto disk_update;
258                 }
259
260                 lock_res(res);
261                 if (rpc_lvb->lvb_size > lvb->lvb_size || !increase_only) {
262                         CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb size: "
263                                "%llu -> %llu\n", PFID(&info->fti_fid),
264                                lvb->lvb_size, rpc_lvb->lvb_size);
265                         lvb->lvb_size = rpc_lvb->lvb_size;
266                 }
267                 if (rpc_lvb->lvb_mtime > lvb->lvb_mtime || !increase_only) {
268                         CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb mtime: "
269                                "%llu -> %llu\n", PFID(&info->fti_fid),
270                                lvb->lvb_mtime, rpc_lvb->lvb_mtime);
271                         lvb->lvb_mtime = rpc_lvb->lvb_mtime;
272                 }
273                 if (rpc_lvb->lvb_atime > lvb->lvb_atime || !increase_only) {
274                         CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb atime: "
275                                "%llu -> %llu\n", PFID(&info->fti_fid),
276                                lvb->lvb_atime, rpc_lvb->lvb_atime);
277                         lvb->lvb_atime = rpc_lvb->lvb_atime;
278                 }
279                 if (rpc_lvb->lvb_ctime > lvb->lvb_ctime || !increase_only) {
280                         CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb ctime: "
281                                "%llu -> %llu\n", PFID(&info->fti_fid),
282                                lvb->lvb_ctime, rpc_lvb->lvb_ctime);
283                         lvb->lvb_ctime = rpc_lvb->lvb_ctime;
284                 }
285                 if (rpc_lvb->lvb_blocks > lvb->lvb_blocks || !increase_only) {
286                         CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb blocks: "
287                                "%llu -> %llu\n", PFID(&info->fti_fid),
288                                lvb->lvb_blocks, rpc_lvb->lvb_blocks);
289                         lvb->lvb_blocks = rpc_lvb->lvb_blocks;
290                 }
291                 unlock_res(res);
292         }
293
294 disk_update:
295         /* Update the LVB from the disk inode */
296         ost_fid_from_resid(&info->fti_fid, &res->lr_name,
297                            ofd->ofd_lut.lut_lsd.lsd_osd_index);
298         fo = ofd_object_find(env, ofd, &info->fti_fid);
299         if (IS_ERR(fo))
300                 GOTO(out, rc = PTR_ERR(fo));
301
302         rc = ofd_attr_get(env, fo, &info->fti_attr);
303         if (rc)
304                 GOTO(out_obj, rc);
305
306         lock_res(res);
307         if (info->fti_attr.la_size > lvb->lvb_size || !increase_only) {
308                 CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb size from disk: "
309                        "%llu -> %llu\n", PFID(&info->fti_fid),
310                        lvb->lvb_size, info->fti_attr.la_size);
311                 lvb->lvb_size = info->fti_attr.la_size;
312         }
313
314         if (info->fti_attr.la_mtime >lvb->lvb_mtime || !increase_only) {
315                 CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb mtime from disk: "
316                        "%llu -> %llu\n", PFID(&info->fti_fid),
317                        lvb->lvb_mtime, info->fti_attr.la_mtime);
318                 lvb->lvb_mtime = info->fti_attr.la_mtime;
319         }
320         if (info->fti_attr.la_atime >lvb->lvb_atime || !increase_only) {
321                 CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb atime from disk: "
322                        "%llu -> %llu\n", PFID(&info->fti_fid),
323                        lvb->lvb_atime, info->fti_attr.la_atime);
324                 lvb->lvb_atime = info->fti_attr.la_atime;
325         }
326         if (info->fti_attr.la_ctime >lvb->lvb_ctime || !increase_only) {
327                 CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb ctime from disk: "
328                        "%llu -> %llu\n", PFID(&info->fti_fid),
329                        lvb->lvb_ctime, info->fti_attr.la_ctime);
330                 lvb->lvb_ctime = info->fti_attr.la_ctime;
331         }
332         if (info->fti_attr.la_blocks > lvb->lvb_blocks || !increase_only) {
333                 CDEBUG(D_DLMTRACE, "res: "DFID" updating lvb blocks from disk: "
334                        "%llu -> %llu\n", PFID(&info->fti_fid), lvb->lvb_blocks,
335                        (unsigned long long)info->fti_attr.la_blocks);
336                 lvb->lvb_blocks = info->fti_attr.la_blocks;
337         }
338         unlock_res(res);
339
340         info->fti_attr.la_valid = 0;
341 out_obj:
342         ofd_object_put(env, fo);
343 out:
344         return rc;
345 }
346
347 /**
348  * Implementation of ldlm_valblock_ops::lvbo_size for OFD.
349  *
350  * This function returns size of LVB data so appropriate RPC size will be
351  * reserved. This is used for compatibility needs between server and client
352  * of different Lustre versions.
353  *
354  * \param[in] lock      LDLM lock
355  *
356  * \retval              size of LVB data
357  */
358 static int ofd_lvbo_size(struct ldlm_lock *lock)
359 {
360         if (lock->l_export != NULL && exp_connect_lvb_type(lock->l_export))
361                 return sizeof(struct ost_lvb);
362         else
363                 return sizeof(struct ost_lvb_v1);
364 }
365
366 /**
367  * Implementation of ldlm_valblock_ops::lvbo_fill for OFD.
368  *
369  * This function is called to fill the given RPC buffer \a buf with LVB data
370  *
371  * \param[in] env       execution environment
372  * \param[in] lock      LDLM lock
373  * \param[in] buf       RPC buffer to fill
374  * \param[in] buflen    buffer length
375  *
376  * \retval              size of LVB data written into \a buf buffer
377  */
378 static int ofd_lvbo_fill(struct ldlm_lock *lock, void *buf, int *buflen)
379 {
380         struct ldlm_resource *res = lock->l_resource;
381         int lvb_len;
382
383         /* Former lvbo_init not allocate the "LVB". */
384         if (unlikely(res->lr_lvb_len == 0))
385                 return 0;
386
387         lvb_len = ofd_lvbo_size(lock);
388         LASSERT(lvb_len <= res->lr_lvb_len);
389
390         if (lvb_len > *buflen)
391                 lvb_len = *buflen;
392
393         lock_res(res);
394         memcpy(buf, res->lr_lvb_data, lvb_len);
395         unlock_res(res);
396
397         return lvb_len;
398 }
399
400 struct ldlm_valblock_ops ofd_lvbo = {
401         .lvbo_init      = ofd_lvbo_init,
402         .lvbo_update    = ofd_lvbo_update,
403         .lvbo_free      = ofd_lvbo_free,
404         .lvbo_size      = ofd_lvbo_size,
405         .lvbo_fill      = ofd_lvbo_fill
406 };