Whamcloud - gitweb
LU-2237 tests: new test for re-recreating last_rcvd
[fs/lustre-release.git] / lustre / osc / osc_dev.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) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  */
30 /*
31  * This file is part of Lustre, http://www.lustre.org/
32  * Lustre is a trademark of Sun Microsystems, Inc.
33  *
34  * Implementation of cl_device, cl_req for OSC layer.
35  *
36  *   Author: Nikita Danilov <nikita.danilov@sun.com>
37  */
38
39 #define DEBUG_SUBSYSTEM S_OSC
40
41 /* class_name2obd() */
42 #include <obd_class.h>
43
44 #include "osc_cl_internal.h"
45
46 /** \addtogroup osc 
47  * @{ 
48  */
49
50 cfs_mem_cache_t *osc_page_kmem;
51 cfs_mem_cache_t *osc_lock_kmem;
52 cfs_mem_cache_t *osc_object_kmem;
53 cfs_mem_cache_t *osc_thread_kmem;
54 cfs_mem_cache_t *osc_session_kmem;
55 cfs_mem_cache_t *osc_req_kmem;
56 cfs_mem_cache_t *osc_extent_kmem;
57 cfs_mem_cache_t *osc_quota_kmem;
58
59 struct lu_kmem_descr osc_caches[] = {
60         {
61                 .ckd_cache = &osc_page_kmem,
62                 .ckd_name  = "osc_page_kmem",
63                 .ckd_size  = sizeof (struct osc_page)
64         },
65         {
66                 .ckd_cache = &osc_lock_kmem,
67                 .ckd_name  = "osc_lock_kmem",
68                 .ckd_size  = sizeof (struct osc_lock)
69         },
70         {
71                 .ckd_cache = &osc_object_kmem,
72                 .ckd_name  = "osc_object_kmem",
73                 .ckd_size  = sizeof (struct osc_object)
74         },
75         {
76                 .ckd_cache = &osc_thread_kmem,
77                 .ckd_name  = "osc_thread_kmem",
78                 .ckd_size  = sizeof (struct osc_thread_info)
79         },
80         {
81                 .ckd_cache = &osc_session_kmem,
82                 .ckd_name  = "osc_session_kmem",
83                 .ckd_size  = sizeof (struct osc_session)
84         },
85         {
86                 .ckd_cache = &osc_req_kmem,
87                 .ckd_name  = "osc_req_kmem",
88                 .ckd_size  = sizeof (struct osc_req)
89         },
90         {
91                 .ckd_cache = &osc_extent_kmem,
92                 .ckd_name  = "osc_extent_kmem",
93                 .ckd_size  = sizeof (struct osc_extent)
94         },
95         {
96                 .ckd_cache = &osc_quota_kmem,
97                 .ckd_name  = "osc_quota_kmem",
98                 .ckd_size  = sizeof(struct osc_quota_info)
99         },
100         {
101                 .ckd_cache = NULL
102         }
103 };
104
105 struct lock_class_key osc_ast_guard_class;
106
107 /*****************************************************************************
108  *
109  * Type conversions.
110  *
111  */
112
113 static struct lu_device *osc2lu_dev(struct osc_device *osc)
114 {
115         return &osc->od_cl.cd_lu_dev;
116 }
117
118 /*****************************************************************************
119  *
120  * Osc device and device type functions.
121  *
122  */
123
124 static void *osc_key_init(const struct lu_context *ctx,
125                          struct lu_context_key *key)
126 {
127         struct osc_thread_info *info;
128
129         OBD_SLAB_ALLOC_PTR_GFP(info, osc_thread_kmem, CFS_ALLOC_IO);
130         if (info == NULL)
131                 info = ERR_PTR(-ENOMEM);
132         return info;
133 }
134
135 static void osc_key_fini(const struct lu_context *ctx,
136                          struct lu_context_key *key, void *data)
137 {
138         struct osc_thread_info *info = data;
139         OBD_SLAB_FREE_PTR(info, osc_thread_kmem);
140 }
141
142 struct lu_context_key osc_key = {
143         .lct_tags = LCT_CL_THREAD,
144         .lct_init = osc_key_init,
145         .lct_fini = osc_key_fini
146 };
147
148 static void *osc_session_init(const struct lu_context *ctx,
149                               struct lu_context_key *key)
150 {
151         struct osc_session *info;
152
153         OBD_SLAB_ALLOC_PTR_GFP(info, osc_session_kmem, CFS_ALLOC_IO);
154         if (info == NULL)
155                 info = ERR_PTR(-ENOMEM);
156         return info;
157 }
158
159 static void osc_session_fini(const struct lu_context *ctx,
160                              struct lu_context_key *key, void *data)
161 {
162         struct osc_session *info = data;
163         OBD_SLAB_FREE_PTR(info, osc_session_kmem);
164 }
165
166 struct lu_context_key osc_session_key = {
167         .lct_tags = LCT_SESSION,
168         .lct_init = osc_session_init,
169         .lct_fini = osc_session_fini
170 };
171
172 /* type constructor/destructor: osc_type_{init,fini,start,stop}(). */
173 LU_TYPE_INIT_FINI(osc, &osc_key, &osc_session_key);
174
175 static int osc_cl_process_config(const struct lu_env *env,
176                                  struct lu_device *d, struct lustre_cfg *cfg)
177 {
178         ENTRY;
179         RETURN(osc_process_config_base(d->ld_obd, cfg));
180 }
181
182 static const struct lu_device_operations osc_lu_ops = {
183         .ldo_object_alloc      = osc_object_alloc,
184         .ldo_process_config    = osc_cl_process_config,
185         .ldo_recovery_complete = NULL
186 };
187
188 static const struct cl_device_operations osc_cl_ops = {
189         .cdo_req_init = osc_req_init
190 };
191
192 static int osc_device_init(const struct lu_env *env, struct lu_device *d,
193                            const char *name, struct lu_device *next)
194 {
195         RETURN(0);
196 }
197
198 static struct lu_device *osc_device_fini(const struct lu_env *env,
199                                          struct lu_device *d)
200 {
201         return 0;
202 }
203
204 static struct lu_device *osc_device_free(const struct lu_env *env,
205                                          struct lu_device *d)
206 {
207         struct osc_device *od = lu2osc_dev(d);
208
209         cl_device_fini(lu2cl_dev(d));
210         OBD_FREE_PTR(od);
211         return NULL;
212 }
213
214 static struct lu_device *osc_device_alloc(const struct lu_env *env,
215                                           struct lu_device_type *t,
216                                           struct lustre_cfg *cfg)
217 {
218         struct lu_device *d;
219         struct osc_device *od;
220         struct obd_device *obd;
221         int rc;
222
223         OBD_ALLOC_PTR(od);
224         if (od == NULL)
225                 RETURN(ERR_PTR(-ENOMEM));
226
227         cl_device_init(&od->od_cl, t);
228         d = osc2lu_dev(od);
229         d->ld_ops = &osc_lu_ops;
230         od->od_cl.cd_ops = &osc_cl_ops;
231
232         /* Setup OSC OBD */
233         obd = class_name2obd(lustre_cfg_string(cfg, 0));
234         LASSERT(obd != NULL);
235         rc = osc_setup(obd, cfg);
236         if (rc) {
237                 osc_device_free(env, d);
238                 RETURN(ERR_PTR(rc));
239         }
240         od->od_exp = obd->obd_self_export;
241         RETURN(d);
242 }
243
244 static const struct lu_device_type_operations osc_device_type_ops = {
245         .ldto_init = osc_type_init,
246         .ldto_fini = osc_type_fini,
247
248         .ldto_start = osc_type_start,
249         .ldto_stop  = osc_type_stop,
250
251         .ldto_device_alloc = osc_device_alloc,
252         .ldto_device_free  = osc_device_free,
253
254         .ldto_device_init    = osc_device_init,
255         .ldto_device_fini    = osc_device_fini
256 };
257
258 struct lu_device_type osc_device_type = {
259         .ldt_tags     = LU_DEVICE_CL,
260         .ldt_name     = LUSTRE_OSC_NAME,
261         .ldt_ops      = &osc_device_type_ops,
262         .ldt_ctx_tags = LCT_CL_THREAD
263 };
264
265 /** @} osc */