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
 119         ENTRY;
 120
 121         LASSERT(ofd);
 122         LASSERT(info->fti_exp);
 123
 124         fed = &info->fti_exp->exp_filter_data;
 125         LASSERT(fed);
 126         lcd = fed->fed_ted.ted_lcd;
 127         /* if the export has already been disconnected, we have no last_rcvd
 128          * slot, update server data with latest transno then */
 129         if (lcd == NULL) {
 130                 CWARN("commit transaction for disconnected client %s: rc %d\n",
 131                       info->fti_exp->exp_client_uuid.uuid, rc);
 132                 err = lut_server_data_write(info->fti_env, &ofd->ofd_lut, th);
 133                 RETURN(err);
 134         }
 135         /* ofd connect may cause transaction before export has last_rcvd
 136          * slot */
 137         if (fed->fed_ted.ted_lr_idx < 0)
 138                 RETURN(0);
 139         off = fed->fed_ted.ted_lr_off;
 140
 141         transno_p = &lcd->lcd_last_transno;
 142         lcd->lcd_last_xid = info->fti_xid;
 143
 144         /*
 145          * When we store zero transno in mcd we can lost last transno value
 146          * because mcd contains 0, but msd is not yet written
 147          * The server data should be updated also if the latest
 148          * transno is rewritten by zero. See the bug 11125 for details.
 149          */
 150         if (info->fti_transno == 0 &&
 151             *transno_p == ofd->ofd_lut.lut_last_transno) {
 152                 cfs_spin_lock(&ofd->ofd_lut.lut_translock);
 153                 ofd->ofd_lut.lut_lsd.lsd_last_transno =
 154                                                 ofd->ofd_lut.lut_last_transno;
 155                 cfs_spin_unlock(&ofd->ofd_lut.lut_translock);
 156                 lut_server_data_write(info->fti_env, &ofd->ofd_lut, th);
 157         }
 158
 159         *transno_p = info->fti_transno;
 160         LASSERT(fed->fed_ted.ted_lr_off > 0);
 161         err = lut_client_data_write(info->fti_env, &ofd->ofd_lut, lcd,
 162                                     &off, th);
 163
 164         RETURN(err);
 165 }
 166
 167 /* Update last_rcvd records with the latest transaction data */
 168 int ofd_txn_stop_cb(const struct lu_env *env, struct thandle *txn,
 169                     void *cookie)
 170 {
 171         struct ofd_device *ofd = cookie;
 172         struct ofd_thread_info *info;
 173
 174         ENTRY;
 175
 176         info = lu_context_key_get(&env->le_ctx, &ofd_thread_key);
 177
 178         if (info->fti_exp == NULL)
 179                  RETURN(0);
 180
 181         LASSERT(ofd_exp(info->fti_exp) == ofd);
 182         if (info->fti_has_trans) {
 183                 if (info->fti_mult_trans == 0) {
 184                         CERROR("More than one transaction "LPU64"\n",
 185                                info->fti_transno);
 186                         RETURN(0);
 187                 }
 188                 /* we need another transno to be assigned */
 189                 info->fti_transno = 0;
 190         } else if (txn->th_result == 0) {
 191                 info->fti_has_trans = 1;
 192         }
 193
 194         cfs_spin_lock(&ofd->ofd_lut.lut_translock);
 195         if (txn->th_result != 0) {
 196                 if (info->fti_transno != 0) {
 197                         CERROR("Replay transno "LPU64" failed: rc %d\n",
 198                                info->fti_transno, txn->th_result);
 199                         info->fti_transno = 0;
 200                 }
 201         } else if (info->fti_transno == 0) {
 202                 info->fti_transno = ++ofd->ofd_lut.lut_last_transno;
 203         } else {
 204                 /* should be replay */
 205                 if (info->fti_transno > ofd->ofd_lut.lut_last_transno)
 206                         ofd->ofd_lut.lut_last_transno = info->fti_transno;
 207         }
 208         cfs_spin_unlock(&ofd->ofd_lut.lut_translock);
 209
 210         /** VBR: set new versions */
 211         if (txn->th_result == 0 && info->fti_obj != NULL) {
 212                 dt_version_set(env, ofd_object_child(info->fti_obj),
 213                                info->fti_transno, txn);
 214                 info->fti_obj = NULL;
 215         }
 216
 217         /* filling reply data */
 218         CDEBUG(D_INODE, "transno = %llu, last_committed = %llu\n",
 219                info->fti_transno, ofd_obd(ofd)->obd_last_committed);
 220
 221         /* if can't add callback, do sync write */
 222         txn->th_sync = !!lut_last_commit_cb_add(txn, &ofd->ofd_lut,
 223                                                 info->fti_exp,
 224                                                 info->fti_transno);
 225
 226         return ofd_last_rcvd_update(info, txn);
 227 }
 228