Whamcloud - gitweb
Branch HEAD
[fs/lustre-release.git] / lustre / mdd / mdd_trans.c
1 /* -*- MODE: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  *  mdd/mdd_handler.c
5  *  Lustre Metadata Server (mdd) routines
6  *
7  *  Copyright (C) 2006 Cluster File Systems, Inc.
8  *   Author: Wang Di <wangdi@clusterfs.com>
9  *
10  *   This file is part of the Lustre file system, http://www.lustre.org
11  *   Lustre is a trademark of Cluster File Systems, Inc.
12  *
13  *   You may have signed or agreed to another license before downloading
14  *   this software.  If so, you are bound by the terms and conditions
15  *   of that agreement, and the following does not apply to you.  See the
16  *   LICENSE file included with this distribution for more information.
17  *
18  *   If you did not agree to a different license, then this copy of Lustre
19  *   is open source software; you can redistribute it and/or modify it
20  *   under the terms of version 2 of the GNU General Public License as
21  *   published by the Free Software Foundation.
22  *
23  *   In either case, Lustre is distributed in the hope that it will be
24  *   useful, but WITHOUT ANY WARRANTY; without even the implied warranty
25  *   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
26  *   license text for more details.
27  */
28 #ifndef EXPORT_SYMTAB
29 # define EXPORT_SYMTAB
30 #endif
31 #define DEBUG_SUBSYSTEM S_MDS
32
33 #include <linux/module.h>
34 #include <linux/jbd.h>
35 #include <obd.h>
36 #include <obd_class.h>
37 #include <lustre_ver.h>
38 #include <obd_support.h>
39 #include <lprocfs_status.h>
40
41 #include <linux/ldiskfs_fs.h>
42 #include <lustre_mds.h>
43 #include <lustre/lustre_idl.h>
44
45 #include "mdd_internal.h"
46
47 int mdd_txn_start_cb(const struct lu_env *env, struct txn_param *param,
48                      void *cookie)
49 {
50         return 0;
51 }
52
53 int mdd_txn_stop_cb(const struct lu_env *env, struct thandle *txn,
54                     void *cookie)
55 {
56         struct mdd_device *mdd = cookie;
57         struct obd_device *obd = mdd2obd_dev(mdd);
58
59         LASSERT(obd);
60         return mds_lov_write_objids(obd);
61 }
62
63 int mdd_txn_commit_cb(const struct lu_env *env, struct thandle *txn,
64                       void *cookie)
65 {
66         return 0;
67 }
68
69 static int dto_txn_credits[DTO_NR];
70 void mdd_txn_param_build(const struct lu_env *env, struct mdd_device *mdd,
71                          enum mdd_txn_op op)
72 {
73         LASSERT(0 <= op && op < MDD_TXN_LAST_OP);
74
75         txn_param_init(&mdd_env_info(env)->mti_param,
76                        mdd->mdd_tod[op].mod_credits);
77 }
78
79 int mdd_log_txn_param_build(const struct lu_env *env, struct md_object *obj,
80                             struct md_attr *ma, enum mdd_txn_op op)
81 {
82         struct mdd_device *mdd = mdo2mdd(&md2mdd_obj(obj)->mod_obj);
83         int rc, log_credits, stripe;
84         ENTRY;
85
86         mdd_txn_param_build(env, mdd, op);
87
88         if (S_ISDIR(lu_object_attr(&obj->mo_lu)))
89                 RETURN(0);
90
91         LASSERT(op == MDD_TXN_UNLINK_OP || op == MDD_TXN_RENAME_OP);
92         rc = mdd_lmm_get_locked(env, md2mdd_obj(obj), ma);
93         if (rc || !(ma->ma_valid & MA_LOV))
94                 RETURN(rc);
95
96         LASSERT(le32_to_cpu(ma->ma_lmm->lmm_magic) == LOV_MAGIC);
97         if ((int)le32_to_cpu(ma->ma_lmm->lmm_stripe_count) < 0)
98                 stripe = mdd2obd_dev(mdd)->u.mds.mds_lov_desc.ld_tgt_count;
99         else
100                 stripe = le32_to_cpu(ma->ma_lmm->lmm_stripe_count);
101
102         log_credits = stripe * dto_txn_credits[DTO_LOG_REC];
103         mdd_env_info(env)->mti_param.tp_credits += log_credits;
104         RETURN(rc);
105 }
106
107 static void mdd_txn_init_dto_credits(const struct lu_env *env,
108                                      struct mdd_device *mdd, int *dto_credits)
109 {
110         int op, credits;
111         for (op = 0; op < DTO_NR; op++) {
112                 credits = mdd_child_ops(mdd)->dt_credit_get(env, mdd->mdd_child,
113                                                             op);
114                 LASSERT(credits > 0);
115                 dto_txn_credits[op] = credits;
116         }
117 }
118
119 int mdd_txn_init_credits(const struct lu_env *env, struct mdd_device *mdd)
120 {
121         int op;
122
123         /* Init credits for each ops. */
124         mdd_txn_init_dto_credits(env, mdd, dto_txn_credits);
125
126         /* Calculate the mdd credits. */
127         for (op = MDD_TXN_OBJECT_DESTROY_OP; op < MDD_TXN_LAST_OP; op++) {
128                 int *c = &mdd->mdd_tod[op].mod_credits;
129                 int *dt = dto_txn_credits;
130                 mdd->mdd_tod[op].mod_op = op;
131                 switch(op) {
132                         case MDD_TXN_OBJECT_DESTROY_OP:
133                                 *c = dt[DTO_OBJECT_DELETE];
134                                 break;
135                         case MDD_TXN_OBJECT_CREATE_OP:
136                                 /* OI_INSERT + CREATE OBJECT */
137                                 *c = dt[DTO_INDEX_INSERT] +
138                                         dt[DTO_OBJECT_CREATE];
139                                 break;
140                         case MDD_TXN_ATTR_SET_OP:
141                                 /* ATTR set + XATTR(lsm, lmv) set */
142                                 *c = dt[DTO_ATTR_SET] + dt[DTO_XATTR_SET];
143                                 break;
144                         case MDD_TXN_XATTR_SET_OP:
145                                 *c = dt[DTO_XATTR_SET];
146                                 break;
147                         case MDD_TXN_INDEX_INSERT_OP:
148                                 *c = dt[DTO_INDEX_INSERT];
149                                 break;
150                         case MDD_TXN_INDEX_DELETE_OP:
151                                 *c = dt[DTO_INDEX_DELETE];
152                                 break;
153                         case MDD_TXN_LINK_OP:
154                                 *c = dt[DTO_INDEX_INSERT];
155                                 break;
156                         case MDD_TXN_UNLINK_OP:
157                                 /* delete index + Unlink log */
158                                 *c = dt[DTO_INDEX_DELETE];
159                                 break;
160                         case MDD_TXN_RENAME_OP:
161                                 /* 2 delete index + 1 insert + Unlink log */
162                                 *c = 2 * dt[DTO_INDEX_DELETE] +
163                                         dt[DTO_INDEX_INSERT];
164                                 break;
165                         case MDD_TXN_RENAME_TGT_OP:
166                                 /* index insert + index delete */
167                                 *c = dt[DTO_INDEX_DELETE] +
168                                      dt[DTO_INDEX_INSERT];
169                                 break;
170                         case MDD_TXN_CREATE_DATA_OP:
171                                 /* same as set xattr(lsm) */
172                                 *c = dt[DTO_XATTR_SET];
173                                 break;
174                         case MDD_TXN_MKDIR_OP:
175                                 /* INDEX INSERT + OI INSERT +
176                                  * CREATE_OBJECT_CREDITS
177                                  * SET_MD CREDITS is already counted in
178                                  * CREATE_OBJECT CREDITS
179                                  */
180                                  *c = 2 * dt[DTO_INDEX_INSERT] +
181                                          dt[DTO_OBJECT_CREATE];
182                                 break;
183                         default:
184                                 CERROR("Invalid op %d init its credit\n", op);
185                                 LBUG();
186                 }
187         }
188         RETURN(0);
189 }
190
191 struct thandle* mdd_trans_start(const struct lu_env *env,
192                                 struct mdd_device *mdd)
193 {
194         struct txn_param *p = &mdd_env_info(env)->mti_param;
195         struct thandle *th;
196
197         th = mdd_child_ops(mdd)->dt_trans_start(env, mdd->mdd_child, p);
198         return th;
199 }
200
201 void mdd_trans_stop(const struct lu_env *env, struct mdd_device *mdd,
202                     int result, struct thandle *handle)
203 {
204         handle->th_result = result;
205         mdd_child_ops(mdd)->dt_trans_stop(env, handle);
206 }