Whamcloud - gitweb
LU-1346 libcfs: replace libcfs wrappers with kernel API
[fs/lustre-release.git] / lustre / ofd / ofd_trans.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_recovery.c
37  *
38  * Author: Alex Zhuravlev <bzzz@whamcloud.com>
39  * Author: Mikhail Pershin <tappro@whamcloud.com>
40  */
41
42 #define DEBUG_SUBSYSTEM S_FILTER
43
44 #include "ofd_internal.h"
45
46 struct thandle *ofd_trans_create(const struct lu_env *env,
47                                  struct ofd_device *ofd)
48 {
49         struct ofd_thread_info  *info = ofd_info(env);
50         struct thandle          *th;
51
52         LASSERT(info);
53
54         th = dt_trans_create(env, ofd->ofd_osd);
55         if (IS_ERR(th))
56                 return th;
57
58         /* export can require sync operations */
59         if (info->fti_exp != NULL)
60                 th->th_sync |= info->fti_exp->exp_need_sync;
61         return th;
62 }
63
64 int ofd_trans_start(const struct lu_env *env, struct ofd_device *ofd,
65                     struct ofd_object *obj, struct thandle *th)
66 {
67         struct ofd_thread_info  *info = ofd_info(env);
68         int                      rc;
69
70         if (info->fti_exp == NULL)
71                 return 0;
72
73         /* declare last_rcvd update */
74         rc = dt_declare_record_write(env, ofd->ofd_lut.lut_last_rcvd,
75                                      sizeof(struct lsd_client_data),
76                                      info->fti_exp->exp_target_data.ted_lr_off,
77                                      th);
78         if (rc)
79                 RETURN(rc);
80
81         /* declare last_rcvd header update */
82         rc = dt_declare_record_write(env, ofd->ofd_lut.lut_last_rcvd,
83                                      sizeof(ofd->ofd_lut.lut_lsd), 0, th);
84         if (rc)
85                 RETURN(rc);
86
87         /* version change is required for this object */
88         if (obj) {
89                 ofd_info(env)->fti_obj = obj;
90                 rc = dt_declare_version_set(env, ofd_object_child(obj), th);
91                 if (rc)
92                         RETURN(rc);
93         }
94
95         return dt_trans_start(env, ofd->ofd_osd, th);
96 }
97
98 void ofd_trans_stop(const struct lu_env *env, struct ofd_device *ofd,
99                     struct thandle *th, int rc)
100 {
101         th->th_result = rc;
102         dt_trans_stop(env, ofd->ofd_osd, th);
103 }
104
105 /*
106  * last_rcvd & last_committed update callbacks
107  */
108 static int ofd_last_rcvd_update(struct ofd_thread_info *info,
109                                 struct thandle *th)
110 {
111         struct ofd_device               *ofd = ofd_exp(info->fti_exp);
112         struct filter_export_data       *fed;
113         struct lsd_client_data          *lcd;
114         __s32                            rc = th->th_result;
115         __u64                           *transno_p;
116         loff_t                           off;
117         int                              err;
118         bool                             lw_client = false;
119
120         ENTRY;
121
122         LASSERT(ofd);
123         LASSERT(info->fti_exp);
124
125         if ((info->fti_exp->exp_connect_flags & OBD_CONNECT_LIGHTWEIGHT) != 0)
126                 lw_client = true;
127
128         fed = &info->fti_exp->exp_filter_data;
129         LASSERT(fed);
130         lcd = fed->fed_ted.ted_lcd;
131         /* if the export has already been disconnected, we have no last_rcvd
132          * slot, update server data with latest transno then */
133         if (lcd == NULL) {
134                 CWARN("commit transaction for disconnected client %s: rc %d\n",
135                       info->fti_exp->exp_client_uuid.uuid, rc);
136                 err = tgt_server_data_write(info->fti_env, &ofd->ofd_lut, th);
137                 RETURN(err);
138         }
139         /* ofd connect may cause transaction before export has last_rcvd
140          * slot */
141         if (fed->fed_ted.ted_lr_idx < 0 && !lw_client)
142                 RETURN(0);
143         off = fed->fed_ted.ted_lr_off;
144
145         transno_p = &lcd->lcd_last_transno;
146         lcd->lcd_last_xid = info->fti_xid;
147
148         /*
149          * When we store zero transno in mcd we can lost last transno value
150          * because mcd contains 0, but msd is not yet written
151          * The server data should be updated also if the latest
152          * transno is rewritten by zero. See the bug 11125 for details.
153          */
154         if (info->fti_transno == 0 &&
155             *transno_p == ofd->ofd_lut.lut_last_transno) {
156                 spin_lock(&ofd->ofd_lut.lut_translock);
157                 ofd->ofd_lut.lut_lsd.lsd_last_transno =
158                                                 ofd->ofd_lut.lut_last_transno;
159                 spin_unlock(&ofd->ofd_lut.lut_translock);
160                 tgt_server_data_write(info->fti_env, &ofd->ofd_lut, th);
161         }
162
163         *transno_p = info->fti_transno;
164         if (lw_client) {
165                 /* Although lightweight (LW) connections have no slot in
166                  * last_rcvd, we still want to maintain the in-memory
167                  * lsd_client_data structure in order to properly handle reply
168                  * reconstruction. */
169                 struct lu_target        *tg =&ofd->ofd_lut;
170                 bool                     update = false;
171
172                 err = 0;
173                 /* All operations performed by LW clients are synchronous and
174                  * we store the committed transno in the last_rcvd header */
175                 spin_lock(&tg->lut_translock);
176                 if (info->fti_transno > tg->lut_lsd.lsd_last_transno) {
177                         tg->lut_lsd.lsd_last_transno = info->fti_transno;
178                         update = true;
179                 }
180                 spin_unlock(&tg->lut_translock);
181                 if (update)
182                         err = tgt_server_data_write(info->fti_env, tg, th);
183         } else {
184                 LASSERT(fed->fed_ted.ted_lr_off > 0);
185                 err = tgt_client_data_write(info->fti_env, &ofd->ofd_lut, lcd,
186                                     &off, th);
187         }
188
189         RETURN(err);
190 }
191
192 /* Update last_rcvd records with the latest transaction data */
193 int ofd_txn_stop_cb(const struct lu_env *env, struct thandle *txn,
194                     void *cookie)
195 {
196         struct ofd_device *ofd = cookie;
197         struct ofd_thread_info *info;
198
199         ENTRY;
200
201         info = lu_context_key_get(&env->le_ctx, &ofd_thread_key);
202
203         if (info->fti_exp == NULL)
204                  RETURN(0);
205
206         LASSERT(ofd_exp(info->fti_exp) == ofd);
207         if (info->fti_has_trans) {
208                 if (info->fti_mult_trans == 0) {
209                         CERROR("More than one transaction "LPU64"\n",
210                                info->fti_transno);
211                         RETURN(0);
212                 }
213                 /* we need another transno to be assigned */
214                 info->fti_transno = 0;
215         } else if (txn->th_result == 0) {
216                 info->fti_has_trans = 1;
217         }
218
219         spin_lock(&ofd->ofd_lut.lut_translock);
220         if (txn->th_result != 0) {
221                 if (info->fti_transno != 0) {
222                         CERROR("Replay transno "LPU64" failed: rc %d\n",
223                                info->fti_transno, txn->th_result);
224                         info->fti_transno = 0;
225                 }
226         } else if (info->fti_transno == 0) {
227                 info->fti_transno = ++ofd->ofd_lut.lut_last_transno;
228         } else {
229                 /* should be replay */
230                 if (info->fti_transno > ofd->ofd_lut.lut_last_transno)
231                         ofd->ofd_lut.lut_last_transno = info->fti_transno;
232         }
233         spin_unlock(&ofd->ofd_lut.lut_translock);
234
235         /** VBR: set new versions */
236         if (txn->th_result == 0 && info->fti_obj != NULL) {
237                 dt_version_set(env, ofd_object_child(info->fti_obj),
238                                info->fti_transno, txn);
239                 info->fti_obj = NULL;
240         }
241
242         /* filling reply data */
243         CDEBUG(D_INODE, "transno = %llu, last_committed = %llu\n",
244                info->fti_transno, ofd_obd(ofd)->obd_last_committed);
245
246         /* if can't add callback, do sync write */
247         txn->th_sync = !!tgt_last_commit_cb_add(txn, &ofd->ofd_lut,
248                                                 info->fti_exp,
249                                                 info->fti_transno);
250
251         return ofd_last_rcvd_update(info, txn);
252 }
253