Whamcloud - gitweb
208198ce93b5199af2e932519f52d0dd2cbea1d3
[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.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 (c) 2009, 2010, Oracle and/or its affiliates. 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/ofd_lvb.c
37  *
38  * Author: Mikhail Pershin <tappro@whamcloud.com>
39  * Author: Alexey Zhuravlev <bzzz@whamcloud.com>
40  */
41
42 #define DEBUG_SUBSYSTEM S_FILTER
43
44 #include "ofd_internal.h"
45
46 static int ofd_lvbo_free(struct ldlm_resource *res)
47 {
48         if (res->lr_lvb_data)
49                 OBD_FREE(res->lr_lvb_data, res->lr_lvb_len);
50
51         return 0;
52 }
53
54 /* Called with res->lr_lvb_sem held */
55 static int ofd_lvbo_init(struct ldlm_resource *res)
56 {
57         struct ost_lvb          *lvb = NULL;
58         struct ofd_device       *ofd;
59         struct ofd_object       *fo;
60         struct ofd_thread_info  *info;
61         struct lu_env            env;
62         int                      rc = 0;
63
64         ENTRY;
65
66         LASSERT(res);
67         LASSERT_MUTEX_LOCKED(&res->lr_lvb_mutex);
68
69         if (res->lr_lvb_data != NULL)
70                 RETURN(0);
71
72         ofd = ldlm_res_to_ns(res)->ns_lvbp;
73         LASSERT(ofd != NULL);
74
75         rc = lu_env_init(&env, LCT_DT_THREAD);
76         if (rc)
77                 RETURN(rc);
78
79         OBD_ALLOC_PTR(lvb);
80         if (lvb == NULL)
81                 RETURN(-ENOMEM);
82
83         res->lr_lvb_data = lvb;
84         res->lr_lvb_len = sizeof(*lvb);
85
86         info = ofd_info_init(&env, NULL);
87         ofd_fid_from_resid(&info->fti_fid, &res->lr_name);
88         fo = ofd_object_find(&env, ofd, &info->fti_fid);
89         if (IS_ERR(fo))
90                 GOTO(out, rc = PTR_ERR(fo));
91
92         rc = ofd_attr_get(&env, fo, &info->fti_attr);
93         if (rc)
94                 GOTO(out_put, rc);
95
96         lvb->lvb_size = info->fti_attr.la_size;
97         lvb->lvb_blocks = info->fti_attr.la_blocks;
98         lvb->lvb_mtime = info->fti_attr.la_mtime;
99         lvb->lvb_atime = info->fti_attr.la_atime;
100         lvb->lvb_ctime = info->fti_attr.la_ctime;
101
102         CDEBUG(D_DLMTRACE, "res: "LPX64" initial lvb size: "LPX64", "
103                "mtime: "LPX64", blocks: "LPX64"\n",
104                res->lr_name.name[0], lvb->lvb_size,
105                lvb->lvb_mtime, lvb->lvb_blocks);
106
107         EXIT;
108 out_put:
109         ofd_object_put(&env, fo);
110 out:
111         lu_env_fini(&env);
112         if (rc)
113                 OST_LVB_SET_ERR(lvb->lvb_blocks, rc);
114         /* Don't free lvb data on lookup error */
115         return rc;
116 }
117
118 /* This will be called in two ways:
119  *
120  *   r != NULL : called by the DLM itself after a glimpse callback
121  *   r == NULL : called by the ofd after a disk write
122  *
123  *   If 'increase_only' is true, don't allow values to move backwards.
124  */
125 static int ofd_lvbo_update(struct ldlm_resource *res,
126                            struct ptlrpc_request *req, int increase_only)
127 {
128         struct ofd_device       *ofd;
129         struct ofd_object       *fo;
130         struct ofd_thread_info  *info;
131         struct ost_lvb          *lvb;
132         struct lu_env            env;
133         int                      rc = 0;
134
135         ENTRY;
136
137         LASSERT(res != NULL);
138
139         ofd = ldlm_res_to_ns(res)->ns_lvbp;
140         LASSERT(ofd != NULL);
141
142         lvb = res->lr_lvb_data;
143         if (lvb == NULL) {
144                 CERROR("%s: no lvb when running lvbo_update, res: "LPU64"!\n",
145                        ofd_obd(ofd)->obd_name, res->lr_name.name[0]);
146                 RETURN(0);
147         }
148
149         rc = lu_env_init(&env, LCT_DT_THREAD);
150         if (rc)
151                 GOTO(out_unlock, rc);
152
153         info = ofd_info_init(&env, NULL);
154         /* Update the LVB from the network message */
155         if (req != NULL) {
156                 struct ost_lvb *rpc_lvb;
157
158                 /* XXX update always from reply buffer */
159                 rpc_lvb = req_capsule_server_get(&req->rq_pill, &RMF_DLM_LVB);
160                 if (rpc_lvb == NULL) {
161                         CERROR("lustre_swab_buf failed\n");
162                         goto disk_update;
163                 }
164                 lock_res(res);
165                 if (rpc_lvb->lvb_size > lvb->lvb_size || !increase_only) {
166                         CDEBUG(D_DLMTRACE, "res: "LPU64" updating lvb size: "
167                                LPU64" -> "LPU64"\n", res->lr_name.name[0],
168                                lvb->lvb_size, rpc_lvb->lvb_size);
169                         lvb->lvb_size = rpc_lvb->lvb_size;
170                 }
171                 if (rpc_lvb->lvb_mtime > lvb->lvb_mtime || !increase_only) {
172                         CDEBUG(D_DLMTRACE, "res: "LPU64" updating lvb mtime: "
173                                LPU64" -> "LPU64"\n", res->lr_name.name[0],
174                                lvb->lvb_mtime, rpc_lvb->lvb_mtime);
175                         lvb->lvb_mtime = rpc_lvb->lvb_mtime;
176                 }
177                 if (rpc_lvb->lvb_atime > lvb->lvb_atime || !increase_only) {
178                         CDEBUG(D_DLMTRACE, "res: "LPU64" updating lvb atime: "
179                                LPU64" -> "LPU64"\n", res->lr_name.name[0],
180                                lvb->lvb_atime, rpc_lvb->lvb_atime);
181                         lvb->lvb_atime = rpc_lvb->lvb_atime;
182                 }
183                 if (rpc_lvb->lvb_ctime > lvb->lvb_ctime || !increase_only) {
184                         CDEBUG(D_DLMTRACE, "res: "LPU64" updating lvb ctime: "
185                                LPU64" -> "LPU64"\n", res->lr_name.name[0],
186                                lvb->lvb_ctime, rpc_lvb->lvb_ctime);
187                         lvb->lvb_ctime = rpc_lvb->lvb_ctime;
188                 }
189                 unlock_res(res);
190         }
191
192 disk_update:
193         /* Update the LVB from the disk inode */
194         ofd_fid_from_resid(&info->fti_fid, &res->lr_name);
195         fo = ofd_object_find(&env, ofd, &info->fti_fid);
196         if (IS_ERR(fo))
197                 GOTO(out_env, rc = PTR_ERR(fo));
198
199         rc = ofd_attr_get(&env, fo, &info->fti_attr);
200         if (rc)
201                 GOTO(out_obj, rc);
202
203         lock_res(res);
204         if (info->fti_attr.la_size > lvb->lvb_size || !increase_only) {
205                 CDEBUG(D_DLMTRACE, "res: "LPU64" updating lvb size from disk: "
206                        LPU64" -> %llu\n", res->lr_name.name[0],
207                        lvb->lvb_size, info->fti_attr.la_size);
208                 lvb->lvb_size = info->fti_attr.la_size;
209         }
210
211         if (info->fti_attr.la_mtime >lvb->lvb_mtime || !increase_only) {
212                 CDEBUG(D_DLMTRACE, "res: "LPU64" updating lvb mtime from disk: "
213                        LPU64" -> "LPU64"\n", res->lr_name.name[0],
214                        lvb->lvb_mtime, info->fti_attr.la_mtime);
215                 lvb->lvb_mtime = info->fti_attr.la_mtime;
216         }
217         if (info->fti_attr.la_atime >lvb->lvb_atime || !increase_only) {
218                 CDEBUG(D_DLMTRACE, "res: "LPU64" updating lvb atime from disk: "
219                        LPU64" -> "LPU64"\n", res->lr_name.name[0],
220                        lvb->lvb_atime, info->fti_attr.la_atime);
221                 lvb->lvb_atime = info->fti_attr.la_atime;
222         }
223         if (info->fti_attr.la_ctime >lvb->lvb_ctime || !increase_only) {
224                 CDEBUG(D_DLMTRACE, "res: "LPU64" updating lvb ctime from disk: "
225                        LPU64" -> "LPU64"\n", res->lr_name.name[0],
226                        lvb->lvb_ctime, info->fti_attr.la_ctime);
227                 lvb->lvb_ctime = info->fti_attr.la_ctime;
228         }
229         if (lvb->lvb_blocks != info->fti_attr.la_blocks) {
230                 CDEBUG(D_DLMTRACE,"res: "LPU64" updating lvb blocks from disk: "
231                        LPU64" -> %llu\n", res->lr_name.name[0],
232                        lvb->lvb_blocks,
233                        (unsigned long long)info->fti_attr.la_blocks);
234                 lvb->lvb_blocks = info->fti_attr.la_blocks;
235         }
236         unlock_res(res);
237
238 out_obj:
239         ofd_object_put(&env, fo);
240 out_env:
241         lu_env_fini(&env);
242 out_unlock:
243         return rc;
244 }
245
246 struct ldlm_valblock_ops ofd_lvbo = {
247         lvbo_init:      ofd_lvbo_init,
248         lvbo_update:    ofd_lvbo_update,
249         lvbo_free:      ofd_lvbo_free,
250 };