4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
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.
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).
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
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
27 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
28 * Use is subject to license terms.
30 * Copyright (c) 2011, 2012, Intel Corporation.
33 * This file is part of Lustre, http://www.lustre.org/
34 * Lustre is a trademark of Sun Microsystems, Inc.
40 #include <obd_support.h>
41 #include <lustre_import.h>
42 #include <lustre_net.h>
44 #include <lustre_lib.h>
45 #include <lustre/lustre_idl.h>
46 #include <lprocfs_status.h>
48 #include <linux/obd_class.h>
50 #define OBD_STATFS_NODELAY 0x0001 /* requests should be send without delay
51 * and resends for avoid deadlocks */
52 #define OBD_STATFS_FROM_CACHE 0x0002 /* the statfs callback should not update
54 #define OBD_STATFS_PTLRPCD 0x0004 /* requests will be sent via ptlrpcd
55 * instead of a specific set. This
56 * means that we cannot rely on the set
57 * interpret routine to be called.
58 * lov_statfs_fini() must thus be called
59 * by the request interpret routine */
60 #define OBD_STATFS_FOR_MDT0 0x0008 /* The statfs is only for retrieving
61 * information from MDT0. */
62 #define OBD_FL_PUNCH 0x00000001 /* To indicate it is punch operation */
64 /* OBD Device Declarations */
65 extern struct obd_device
*obd_devs
[MAX_OBD_DEVICES
];
66 extern rwlock_t obd_dev_lock
;
68 /* OBD Operations Declarations */
69 extern struct obd_device
*class_conn2obd(struct lustre_handle
*);
70 extern struct obd_device
*class_exp2obd(struct obd_export
*);
71 extern int class_handle_ioctl(unsigned int cmd
, unsigned long arg
);
72 extern int lustre_get_jobid(char *jobid
);
74 struct lu_device_type
;
77 struct obd_export
*class_conn2export(struct lustre_handle
*);
78 int class_register_type(struct obd_ops
*, struct md_ops
*,
79 struct lprocfs_vars
*, const char *nm
,
80 struct lu_device_type
*ldt
);
81 int class_unregister_type(const char *nm
);
83 struct obd_device
*class_newdev(const char *type_name
, const char *name
);
84 void class_release_dev(struct obd_device
*obd
);
86 int class_name2dev(const char *name
);
87 struct obd_device
*class_name2obd(const char *name
);
88 int class_uuid2dev(struct obd_uuid
*uuid
);
89 struct obd_device
*class_uuid2obd(struct obd_uuid
*uuid
);
90 void class_obd_list(void);
91 struct obd_device
* class_find_client_obd(struct obd_uuid
*tgt_uuid
,
92 const char * typ_name
,
93 struct obd_uuid
*grp_uuid
);
94 struct obd_device
* class_devices_in_group(struct obd_uuid
*grp_uuid
,
96 struct obd_device
* class_num2obd(int num
);
97 int get_devices_count(void);
99 int class_notify_sptlrpc_conf(const char *fsname
, int namelen
);
101 char *obd_export_nid2str(struct obd_export
*exp
);
103 int obd_export_evict_by_nid(struct obd_device
*obd
, const char *nid
);
104 int obd_export_evict_by_uuid(struct obd_device
*obd
, const char *uuid
);
105 int obd_connect_flags2str(char *page
, int count
, __u64 flags
, char *sep
);
107 int obd_zombie_impexp_init(void);
108 void obd_zombie_impexp_stop(void);
109 void obd_zombie_impexp_cull(void);
110 void obd_zombie_barrier(void);
111 void obd_exports_barrier(struct obd_device
*obd
);
112 int kuc_len(int payload_len
);
113 struct kuc_hdr
* kuc_ptr(void *p
);
114 int kuc_ispayload(void *p
);
115 void *kuc_alloc(int payload_len
, int transport
, int type
);
116 void kuc_free(void *p
, int payload_len
);
120 typedef int (*llog_cb_t
)(const struct lu_env
*, struct llog_handle
*,
121 struct llog_rec_hdr
*, void *);
123 struct lustre_cfg
*lustre_cfg_rename(struct lustre_cfg
*cfg
,
124 const char *new_name
);
125 int class_process_config(struct lustre_cfg
*lcfg
);
126 int class_process_proc_param(char *prefix
, struct lprocfs_vars
*lvars
,
127 struct lustre_cfg
*lcfg
, void *data
);
128 int class_attach(struct lustre_cfg
*lcfg
);
129 int class_setup(struct obd_device
*obd
, struct lustre_cfg
*lcfg
);
130 int class_cleanup(struct obd_device
*obd
, struct lustre_cfg
*lcfg
);
131 int class_detach(struct obd_device
*obd
, struct lustre_cfg
*lcfg
);
132 struct obd_device
*class_incref(struct obd_device
*obd
,
133 const char *scope
, const void *source
);
134 void class_decref(struct obd_device
*obd
,
135 const char *scope
, const void *source
);
136 void dump_exports(struct obd_device
*obd
, int locks
);
137 int class_config_llog_handler(const struct lu_env
*env
,
138 struct llog_handle
*handle
,
139 struct llog_rec_hdr
*rec
, void *data
);
140 int class_add_conn(struct obd_device
*obd
, struct lustre_cfg
*lcfg
);
141 int class_add_uuid(const char *uuid
, __u64 nid
);
145 extern void lprocfs_echo_init_vars(struct lprocfs_static_vars
*lvars
);
147 static inline void lprocfs_echo_init_vars(struct lprocfs_static_vars
*lvars
)
149 memset(lvars
, 0, sizeof(*lvars
));
153 #define CFG_F_START 0x01 /* Set when we start updating from a log */
154 #define CFG_F_MARKER 0x02 /* We are within a maker */
155 #define CFG_F_SKIP 0x04 /* We should ignore this cfg command */
156 #define CFG_F_COMPAT146 0x08 /* Allow old-style logs */
157 #define CFG_F_EXCLUDE 0x10 /* OST exclusion list */
159 /* Passed as data param to class_config_parse_llog */
160 struct config_llog_instance
{
163 struct super_block
*cfg_sb
;
164 struct obd_uuid cfg_uuid
;
165 llog_cb_t cfg_callback
;
166 int cfg_last_idx
; /* for partial llog processing */
169 int class_config_parse_llog(const struct lu_env
*env
, struct llog_ctxt
*ctxt
,
170 char *name
, struct config_llog_instance
*cfg
);
171 int class_config_dump_llog(const struct lu_env
*env
, struct llog_ctxt
*ctxt
,
172 char *name
, struct config_llog_instance
*cfg
);
176 CONFIG_T_SPTLRPC
= 1,
177 CONFIG_T_RECOVER
= 2,
182 #define PARAMS_FILENAME "params"
183 #define LCTL_UPCALL "lctl"
185 /* list of active configuration logs */
186 struct config_llog_data
{
187 struct ldlm_res_id cld_resid
;
188 struct config_llog_instance cld_cfg
;
189 struct list_head cld_list_chain
;
190 atomic_t cld_refcount
;
191 struct config_llog_data
*cld_sptlrpc
;/* depended sptlrpc log */
192 struct config_llog_data
*cld_params
; /* common parameters log */
193 struct config_llog_data
*cld_recover
;/* imperative recover log */
194 struct obd_export
*cld_mgcexp
;
195 struct mutex cld_lock
;
197 unsigned int cld_stopping
:1, /* we were told to stop
199 cld_lostlock
:1; /* lock not requeued */
203 struct lustre_profile
{
204 struct list_head lp_list
;
210 struct lustre_profile
*class_get_profile(const char * prof
);
211 void class_del_profile(const char *prof
);
212 void class_del_profiles(void);
214 #if LUSTRE_TRACKS_LOCK_EXP_REFS
216 void __class_export_add_lock_ref(struct obd_export
*, struct ldlm_lock
*);
217 void __class_export_del_lock_ref(struct obd_export
*, struct ldlm_lock
*);
218 extern void (*class_export_dump_hook
)(struct obd_export
*);
222 #define __class_export_add_lock_ref(exp, lock) do {} while(0)
223 #define __class_export_del_lock_ref(exp, lock) do {} while(0)
227 #define class_export_rpc_inc(exp) \
229 atomic_inc(&(exp)->exp_rpc_count); \
230 CDEBUG(D_INFO, "RPC GETting export %p : new rpc_count %d\n", \
231 (exp), atomic_read(&(exp)->exp_rpc_count)); \
234 #define class_export_rpc_dec(exp) \
236 LASSERT_ATOMIC_POS(&exp->exp_rpc_count); \
237 atomic_dec(&(exp)->exp_rpc_count); \
238 CDEBUG(D_INFO, "RPC PUTting export %p : new rpc_count %d\n", \
239 (exp), atomic_read(&(exp)->exp_rpc_count)); \
242 #define class_export_lock_get(exp, lock) \
244 atomic_inc(&(exp)->exp_locks_count); \
245 __class_export_add_lock_ref(exp, lock); \
246 CDEBUG(D_INFO, "lock GETting export %p : new locks_count %d\n", \
247 (exp), atomic_read(&(exp)->exp_locks_count)); \
248 class_export_get(exp); \
251 #define class_export_lock_put(exp, lock) \
253 LASSERT_ATOMIC_POS(&exp->exp_locks_count); \
254 atomic_dec(&(exp)->exp_locks_count); \
255 __class_export_del_lock_ref(exp, lock); \
256 CDEBUG(D_INFO, "lock PUTting export %p : new locks_count %d\n", \
257 (exp), atomic_read(&(exp)->exp_locks_count)); \
258 class_export_put(exp); \
261 #define class_export_cb_get(exp) \
263 atomic_inc(&(exp)->exp_cb_count); \
264 CDEBUG(D_INFO, "callback GETting export %p : new cb_count %d\n",\
265 (exp), atomic_read(&(exp)->exp_cb_count)); \
266 class_export_get(exp); \
269 #define class_export_cb_put(exp) \
271 LASSERT_ATOMIC_POS(&exp->exp_cb_count); \
272 atomic_dec(&(exp)->exp_cb_count); \
273 CDEBUG(D_INFO, "callback PUTting export %p : new cb_count %d\n",\
274 (exp), atomic_read(&(exp)->exp_cb_count)); \
275 class_export_put(exp); \
279 struct obd_export
*class_export_get(struct obd_export
*exp
);
280 void class_export_put(struct obd_export
*exp
);
281 struct obd_export
*class_new_export(struct obd_device
*obddev
,
282 struct obd_uuid
*cluuid
);
283 void class_unlink_export(struct obd_export
*exp
);
285 struct obd_import
*class_import_get(struct obd_import
*);
286 void class_import_put(struct obd_import
*);
287 struct obd_import
*class_new_import(struct obd_device
*obd
);
288 void class_destroy_import(struct obd_import
*exp
);
290 struct obd_type
*class_search_type(const char *name
);
291 struct obd_type
*class_get_type(const char *name
);
292 void class_put_type(struct obd_type
*type
);
293 int class_connect(struct lustre_handle
*conn
, struct obd_device
*obd
,
294 struct obd_uuid
*cluuid
);
295 int class_disconnect(struct obd_export
*exp
);
296 void class_fail_export(struct obd_export
*exp
);
297 int class_connected_export(struct obd_export
*exp
);
298 void class_disconnect_exports(struct obd_device
*obddev
);
299 int class_manual_cleanup(struct obd_device
*obd
);
300 void class_disconnect_stale_exports(struct obd_device
*,
301 int (*test_export
)(struct obd_export
*));
302 static inline enum obd_option
exp_flags_from_obd(struct obd_device
*obd
)
304 return ((obd
->obd_fail
? OBD_OPT_FAILOVER
: 0) |
305 (obd
->obd_force
? OBD_OPT_FORCE
: 0) |
306 (obd
->obd_abort_recovery
? OBD_OPT_ABORT_RECOV
: 0) |
311 void obdo_cpy_md(struct obdo
*dst
, struct obdo
*src
, obd_flag valid
);
312 void obdo_to_ioobj(struct obdo
*oa
, struct obd_ioobj
*ioobj
);
313 void obdo_from_iattr(struct obdo
*oa
, struct iattr
*attr
,
314 unsigned int ia_valid
);
315 void iattr_from_obdo(struct iattr
*attr
, struct obdo
*oa
, obd_flag valid
);
316 void md_from_obdo(struct md_op_data
*op_data
, struct obdo
*oa
, obd_flag valid
);
317 void obdo_from_md(struct obdo
*oa
, struct md_op_data
*op_data
,
320 void obdo_cpu_to_le(struct obdo
*dobdo
, struct obdo
*sobdo
);
321 void obdo_le_to_cpu(struct obdo
*dobdo
, struct obdo
*sobdo
);
323 #define OBT(dev) (dev)->obd_type
324 #define OBP(dev, op) (dev)->obd_type->typ_dt_ops->o_ ## op
325 #define MDP(dev, op) (dev)->obd_type->typ_md_ops->m_ ## op
326 #define CTXTP(ctxt, op) (ctxt)->loc_logops->lop_##op
328 /* Ensure obd_setup: used for cleanup which must be called
329 while obd is stopping */
330 #define OBD_CHECK_DEV(obd) \
333 CERROR("NULL device\n"); \
338 /* ensure obd_setup and !obd_stopping */
339 #define OBD_CHECK_DEV_ACTIVE(obd) \
341 OBD_CHECK_DEV(obd); \
342 if (!(obd)->obd_set_up || (obd)->obd_stopping) { \
343 CERROR("Device %d not setup\n", \
351 #define OBD_COUNTER_OFFSET(op) \
352 ((offsetof(struct obd_ops, o_ ## op) - \
353 offsetof(struct obd_ops, o_iocontrol)) \
354 / sizeof(((struct obd_ops *)(0))->o_iocontrol))
356 #define OBD_COUNTER_INCREMENT(obdx, op) \
357 if ((obdx)->obd_stats != NULL) { \
358 unsigned int coffset; \
359 coffset = (unsigned int)((obdx)->obd_cntr_base) + \
360 OBD_COUNTER_OFFSET(op); \
361 LASSERT(coffset < (obdx)->obd_stats->ls_num); \
362 lprocfs_counter_incr((obdx)->obd_stats, coffset); \
365 #define EXP_COUNTER_INCREMENT(export, op) \
366 if ((export)->exp_obd->obd_stats != NULL) { \
367 unsigned int coffset; \
368 coffset = (unsigned int)((export)->exp_obd->obd_cntr_base) + \
369 OBD_COUNTER_OFFSET(op); \
370 LASSERT(coffset < (export)->exp_obd->obd_stats->ls_num); \
371 lprocfs_counter_incr((export)->exp_obd->obd_stats, coffset); \
372 if ((export)->exp_nid_stats != NULL && \
373 (export)->exp_nid_stats->nid_stats != NULL) \
374 lprocfs_counter_incr( \
375 (export)->exp_nid_stats->nid_stats, coffset);\
378 #define MD_COUNTER_OFFSET(op) \
379 ((offsetof(struct md_ops, m_ ## op) - \
380 offsetof(struct md_ops, m_getstatus)) \
381 / sizeof(((struct md_ops *)(0))->m_getstatus))
383 #define MD_COUNTER_INCREMENT(obdx, op) \
384 if ((obd)->md_stats != NULL) { \
385 unsigned int coffset; \
386 coffset = (unsigned int)((obdx)->md_cntr_base) + \
387 MD_COUNTER_OFFSET(op); \
388 LASSERT(coffset < (obdx)->md_stats->ls_num); \
389 lprocfs_counter_incr((obdx)->md_stats, coffset); \
392 #define EXP_MD_COUNTER_INCREMENT(export, op) \
393 if ((export)->exp_obd->obd_stats != NULL) { \
394 unsigned int coffset; \
395 coffset = (unsigned int)((export)->exp_obd->md_cntr_base) + \
396 MD_COUNTER_OFFSET(op); \
397 LASSERT(coffset < (export)->exp_obd->md_stats->ls_num); \
398 lprocfs_counter_incr((export)->exp_obd->md_stats, coffset); \
399 if ((export)->exp_md_stats != NULL) \
400 lprocfs_counter_incr( \
401 (export)->exp_md_stats, coffset); \
405 #define OBD_COUNTER_OFFSET(op)
406 #define OBD_COUNTER_INCREMENT(obd, op)
407 #define EXP_COUNTER_INCREMENT(exp, op)
408 #define MD_COUNTER_INCREMENT(obd, op)
409 #define EXP_MD_COUNTER_INCREMENT(exp, op)
412 static inline int lprocfs_nid_ldlm_stats_init(struct nid_stat
* tmp
)
414 /* Always add in ldlm_stats */
415 tmp
->nid_ldlm_stats
= lprocfs_alloc_stats(LDLM_LAST_OPC
- LDLM_FIRST_OPC
416 ,LPROCFS_STATS_FLAG_NOPERCPU
);
417 if (tmp
->nid_ldlm_stats
== NULL
)
420 lprocfs_init_ldlm_stats(tmp
->nid_ldlm_stats
);
422 return lprocfs_register_stats(tmp
->nid_proc
, "ldlm_stats",
423 tmp
->nid_ldlm_stats
);
426 #define OBD_CHECK_MD_OP(obd, op, err) \
428 if (!OBT(obd) || !MDP((obd), op)) { \
430 CERROR("md_" #op ": dev %s/%d no operation\n", \
431 obd->obd_name, obd->obd_minor); \
436 #define EXP_CHECK_MD_OP(exp, op) \
438 if ((exp) == NULL) { \
439 CERROR("obd_" #op ": NULL export\n"); \
442 if ((exp)->exp_obd == NULL || !OBT((exp)->exp_obd)) { \
443 CERROR("obd_" #op ": cleaned up obd\n"); \
444 return -EOPNOTSUPP; \
446 if (!OBT((exp)->exp_obd) || !MDP((exp)->exp_obd, op)) { \
447 CERROR("obd_" #op ": dev %s/%d no operation\n", \
448 (exp)->exp_obd->obd_name, \
449 (exp)->exp_obd->obd_minor); \
450 return -EOPNOTSUPP; \
455 #define OBD_CHECK_DT_OP(obd, op, err) \
457 if (!OBT(obd) || !OBP((obd), op)) { \
459 CERROR("obd_" #op ": dev %d no operation\n", \
465 #define EXP_CHECK_DT_OP(exp, op) \
467 if ((exp) == NULL) { \
468 CERROR("obd_" #op ": NULL export\n"); \
471 if ((exp)->exp_obd == NULL || !OBT((exp)->exp_obd)) { \
472 CERROR("obd_" #op ": cleaned up obd\n"); \
473 return -EOPNOTSUPP; \
475 if (!OBT((exp)->exp_obd) || !OBP((exp)->exp_obd, op)) { \
476 CERROR("obd_" #op ": dev %d no operation\n", \
477 (exp)->exp_obd->obd_minor); \
478 return -EOPNOTSUPP; \
482 #define CTXT_CHECK_OP(ctxt, op, err) \
484 if (!OBT(ctxt->loc_obd) || !CTXTP((ctxt), op)) { \
486 CERROR("lop_" #op ": dev %d no operation\n", \
487 ctxt->loc_obd->obd_minor); \
492 static inline int class_devno_max(void)
494 return MAX_OBD_DEVICES
;
497 static inline int obd_get_info(const struct lu_env
*env
,
498 struct obd_export
*exp
, __u32 keylen
,
499 void *key
, __u32
*vallen
, void *val
,
500 struct lov_stripe_md
*lsm
)
504 EXP_CHECK_DT_OP(exp
, get_info
);
505 EXP_COUNTER_INCREMENT(exp
, get_info
);
507 rc
= OBP(exp
->exp_obd
, get_info
)(env
, exp
, keylen
, key
, vallen
, val
,
512 static inline int obd_set_info_async(const struct lu_env
*env
,
513 struct obd_export
*exp
, obd_count keylen
,
514 void *key
, obd_count vallen
, void *val
,
515 struct ptlrpc_request_set
*set
)
519 EXP_CHECK_DT_OP(exp
, set_info_async
);
520 EXP_COUNTER_INCREMENT(exp
, set_info_async
);
522 rc
= OBP(exp
->exp_obd
, set_info_async
)(env
, exp
, keylen
, key
, vallen
,
528 * obd-lu integration.
530 * Functionality is being moved into new lu_device-based layering, but some
531 * pieces of configuration process are still based on obd devices.
533 * Specifically, lu_device_type_operations::ldto_device_alloc() methods fully
534 * subsume ->o_setup() methods of obd devices they replace. The same for
535 * lu_device_operations::ldo_process_config() and ->o_process_config(). As a
536 * result, obd_setup() and obd_process_config() branch and call one XOR
539 * Yet neither lu_device_type_operations::ldto_device_fini() nor
540 * lu_device_type_operations::ldto_device_free() fully implement the
541 * functionality of ->o_precleanup() and ->o_cleanup() they override. Hence,
542 * obd_precleanup() and obd_cleanup() call both lu_device and obd operations.
545 #define DECLARE_LU_VARS(ldt, d) \
546 struct lu_device_type *ldt; \
549 static inline int obd_setup(struct obd_device
*obd
, struct lustre_cfg
*cfg
)
552 DECLARE_LU_VARS(ldt
, d
);
554 ldt
= obd
->obd_type
->typ_lu
;
556 struct lu_context session_ctx
;
558 lu_context_init(&session_ctx
, LCT_SESSION
);
559 session_ctx
.lc_thread
= NULL
;
560 lu_context_enter(&session_ctx
);
562 rc
= lu_env_init(&env
, ldt
->ldt_ctx_tags
);
564 env
.le_ses
= &session_ctx
;
565 d
= ldt
->ldt_ops
->ldto_device_alloc(&env
, ldt
, cfg
);
574 lu_context_exit(&session_ctx
);
575 lu_context_fini(&session_ctx
);
578 OBD_CHECK_DT_OP(obd
, setup
, -EOPNOTSUPP
);
579 OBD_COUNTER_INCREMENT(obd
, setup
);
580 rc
= OBP(obd
, setup
)(obd
, cfg
);
585 static inline int obd_precleanup(struct obd_device
*obd
,
586 enum obd_cleanup_stage cleanup_stage
)
589 DECLARE_LU_VARS(ldt
, d
);
592 ldt
= obd
->obd_type
->typ_lu
;
594 if (ldt
!= NULL
&& d
!= NULL
) {
595 if (cleanup_stage
== OBD_CLEANUP_EXPORTS
) {
598 rc
= lu_env_init(&env
, ldt
->ldt_ctx_tags
);
600 ldt
->ldt_ops
->ldto_device_fini(&env
, d
);
605 OBD_CHECK_DT_OP(obd
, precleanup
, 0);
606 OBD_COUNTER_INCREMENT(obd
, precleanup
);
608 rc
= OBP(obd
, precleanup
)(obd
, cleanup_stage
);
612 static inline int obd_cleanup(struct obd_device
*obd
)
615 DECLARE_LU_VARS(ldt
, d
);
619 ldt
= obd
->obd_type
->typ_lu
;
621 if (ldt
!= NULL
&& d
!= NULL
) {
624 rc
= lu_env_init(&env
, ldt
->ldt_ctx_tags
);
626 ldt
->ldt_ops
->ldto_device_free(&env
, d
);
628 obd
->obd_lu_dev
= NULL
;
631 OBD_CHECK_DT_OP(obd
, cleanup
, 0);
632 OBD_COUNTER_INCREMENT(obd
, cleanup
);
634 rc
= OBP(obd
, cleanup
)(obd
);
638 static inline void obd_cleanup_client_import(struct obd_device
*obd
)
640 /* If we set up but never connected, the
641 client import will not have been cleaned. */
642 down_write(&obd
->u
.cli
.cl_sem
);
643 if (obd
->u
.cli
.cl_import
) {
644 struct obd_import
*imp
;
645 imp
= obd
->u
.cli
.cl_import
;
646 CDEBUG(D_CONFIG
, "%s: client import never connected\n",
648 ptlrpc_invalidate_import(imp
);
649 if (imp
->imp_rq_pool
) {
650 ptlrpc_free_rq_pool(imp
->imp_rq_pool
);
651 imp
->imp_rq_pool
= NULL
;
653 client_destroy_import(imp
);
654 obd
->u
.cli
.cl_import
= NULL
;
656 up_write(&obd
->u
.cli
.cl_sem
);
660 obd_process_config(struct obd_device
*obd
, int datalen
, void *data
)
663 DECLARE_LU_VARS(ldt
, d
);
667 obd
->obd_process_conf
= 1;
668 ldt
= obd
->obd_type
->typ_lu
;
670 if (ldt
!= NULL
&& d
!= NULL
) {
673 rc
= lu_env_init(&env
, ldt
->ldt_ctx_tags
);
675 rc
= d
->ld_ops
->ldo_process_config(&env
, d
, data
);
679 OBD_CHECK_DT_OP(obd
, process_config
, -EOPNOTSUPP
);
680 rc
= OBP(obd
, process_config
)(obd
, datalen
, data
);
682 OBD_COUNTER_INCREMENT(obd
, process_config
);
683 obd
->obd_process_conf
= 0;
688 /* Pack an in-memory MD struct for storage on disk.
689 * Returns +ve size of packed MD (0 for free), or -ve error.
691 * If @disk_tgt == NULL, MD size is returned (max size if @mem_src == NULL).
692 * If @*disk_tgt != NULL and @mem_src == NULL, @*disk_tgt will be freed.
693 * If @*disk_tgt == NULL, it will be allocated
695 static inline int obd_packmd(struct obd_export
*exp
,
696 struct lov_mds_md
**disk_tgt
,
697 struct lov_stripe_md
*mem_src
)
701 EXP_CHECK_DT_OP(exp
, packmd
);
702 EXP_COUNTER_INCREMENT(exp
, packmd
);
704 rc
= OBP(exp
->exp_obd
, packmd
)(exp
, disk_tgt
, mem_src
);
708 static inline int obd_size_diskmd(struct obd_export
*exp
,
709 struct lov_stripe_md
*mem_src
)
711 return obd_packmd(exp
, NULL
, mem_src
);
714 /* helper functions */
715 static inline int obd_alloc_diskmd(struct obd_export
*exp
,
716 struct lov_mds_md
**disk_tgt
)
719 LASSERT(*disk_tgt
== NULL
);
720 return obd_packmd(exp
, disk_tgt
, NULL
);
723 static inline int obd_free_diskmd(struct obd_export
*exp
,
724 struct lov_mds_md
**disk_tgt
)
729 * LU-2590, for caller's convenience, *disk_tgt could be host
730 * endianness, it needs swab to LE if necessary, while just
731 * lov_mds_md header needs it for figuring out how much memory
734 if ((cpu_to_le32(LOV_MAGIC
) != LOV_MAGIC
) &&
735 (((*disk_tgt
)->lmm_magic
== LOV_MAGIC_V1
) ||
736 ((*disk_tgt
)->lmm_magic
== LOV_MAGIC_V3
)))
737 lustre_swab_lov_mds_md(*disk_tgt
);
738 return obd_packmd(exp
, disk_tgt
, NULL
);
741 /* Unpack an MD struct from disk to in-memory format.
742 * Returns +ve size of unpacked MD (0 for free), or -ve error.
744 * If @mem_tgt == NULL, MD size is returned (max size if @disk_src == NULL).
745 * If @*mem_tgt != NULL and @disk_src == NULL, @*mem_tgt will be freed.
746 * If @*mem_tgt == NULL, it will be allocated
748 static inline int obd_unpackmd(struct obd_export
*exp
,
749 struct lov_stripe_md
**mem_tgt
,
750 struct lov_mds_md
*disk_src
,
755 EXP_CHECK_DT_OP(exp
, unpackmd
);
756 EXP_COUNTER_INCREMENT(exp
, unpackmd
);
758 rc
= OBP(exp
->exp_obd
, unpackmd
)(exp
, mem_tgt
, disk_src
, disk_len
);
762 /* helper functions */
763 static inline int obd_alloc_memmd(struct obd_export
*exp
,
764 struct lov_stripe_md
**mem_tgt
)
767 LASSERT(*mem_tgt
== NULL
);
768 return obd_unpackmd(exp
, mem_tgt
, NULL
, 0);
771 static inline int obd_free_memmd(struct obd_export
*exp
,
772 struct lov_stripe_md
**mem_tgt
)
778 rc
= obd_unpackmd(exp
, mem_tgt
, NULL
, 0);
783 static inline int obd_precreate(struct obd_export
*exp
)
787 EXP_CHECK_DT_OP(exp
, precreate
);
788 OBD_COUNTER_INCREMENT(exp
->exp_obd
, precreate
);
790 rc
= OBP(exp
->exp_obd
, precreate
)(exp
);
794 static inline int obd_create_async(struct obd_export
*exp
,
795 struct obd_info
*oinfo
,
796 struct lov_stripe_md
**ea
,
797 struct obd_trans_info
*oti
)
801 EXP_CHECK_DT_OP(exp
, create_async
);
802 EXP_COUNTER_INCREMENT(exp
, create_async
);
804 rc
= OBP(exp
->exp_obd
, create_async
)(exp
, oinfo
, ea
, oti
);
808 static inline int obd_create(const struct lu_env
*env
, struct obd_export
*exp
,
809 struct obdo
*obdo
, struct lov_stripe_md
**ea
,
810 struct obd_trans_info
*oti
)
814 EXP_CHECK_DT_OP(exp
, create
);
815 EXP_COUNTER_INCREMENT(exp
, create
);
817 rc
= OBP(exp
->exp_obd
, create
)(env
, exp
, obdo
, ea
, oti
);
821 static inline int obd_destroy(const struct lu_env
*env
, struct obd_export
*exp
,
822 struct obdo
*obdo
, struct lov_stripe_md
*ea
,
823 struct obd_trans_info
*oti
,
824 struct obd_export
*md_exp
, void *capa
)
828 EXP_CHECK_DT_OP(exp
, destroy
);
829 EXP_COUNTER_INCREMENT(exp
, destroy
);
831 rc
= OBP(exp
->exp_obd
, destroy
)(env
, exp
, obdo
, ea
, oti
, md_exp
, capa
);
835 static inline int obd_getattr(const struct lu_env
*env
, struct obd_export
*exp
,
836 struct obd_info
*oinfo
)
840 EXP_CHECK_DT_OP(exp
, getattr
);
841 EXP_COUNTER_INCREMENT(exp
, getattr
);
843 rc
= OBP(exp
->exp_obd
, getattr
)(env
, exp
, oinfo
);
847 static inline int obd_getattr_async(struct obd_export
*exp
,
848 struct obd_info
*oinfo
,
849 struct ptlrpc_request_set
*set
)
853 EXP_CHECK_DT_OP(exp
, getattr_async
);
854 EXP_COUNTER_INCREMENT(exp
, getattr_async
);
856 rc
= OBP(exp
->exp_obd
, getattr_async
)(exp
, oinfo
, set
);
860 static inline int obd_setattr(const struct lu_env
*env
, struct obd_export
*exp
,
861 struct obd_info
*oinfo
,
862 struct obd_trans_info
*oti
)
866 EXP_CHECK_DT_OP(exp
, setattr
);
867 EXP_COUNTER_INCREMENT(exp
, setattr
);
869 rc
= OBP(exp
->exp_obd
, setattr
)(env
, exp
, oinfo
, oti
);
873 /* This performs all the requests set init/wait/destroy actions. */
874 static inline int obd_setattr_rqset(struct obd_export
*exp
,
875 struct obd_info
*oinfo
,
876 struct obd_trans_info
*oti
)
878 struct ptlrpc_request_set
*set
= NULL
;
881 EXP_CHECK_DT_OP(exp
, setattr_async
);
882 EXP_COUNTER_INCREMENT(exp
, setattr_async
);
884 set
= ptlrpc_prep_set();
888 rc
= OBP(exp
->exp_obd
, setattr_async
)(exp
, oinfo
, oti
, set
);
890 rc
= ptlrpc_set_wait(set
);
891 ptlrpc_set_destroy(set
);
895 /* This adds all the requests into @set if @set != NULL, otherwise
896 all requests are sent asynchronously without waiting for response. */
897 static inline int obd_setattr_async(struct obd_export
*exp
,
898 struct obd_info
*oinfo
,
899 struct obd_trans_info
*oti
,
900 struct ptlrpc_request_set
*set
)
904 EXP_CHECK_DT_OP(exp
, setattr_async
);
905 EXP_COUNTER_INCREMENT(exp
, setattr_async
);
907 rc
= OBP(exp
->exp_obd
, setattr_async
)(exp
, oinfo
, oti
, set
);
911 static inline int obd_add_conn(struct obd_import
*imp
, struct obd_uuid
*uuid
,
914 struct obd_device
*obd
= imp
->imp_obd
;
917 OBD_CHECK_DEV_ACTIVE(obd
);
918 OBD_CHECK_DT_OP(obd
, add_conn
, -EOPNOTSUPP
);
919 OBD_COUNTER_INCREMENT(obd
, add_conn
);
921 rc
= OBP(obd
, add_conn
)(imp
, uuid
, priority
);
925 static inline int obd_del_conn(struct obd_import
*imp
, struct obd_uuid
*uuid
)
927 struct obd_device
*obd
= imp
->imp_obd
;
930 OBD_CHECK_DEV_ACTIVE(obd
);
931 OBD_CHECK_DT_OP(obd
, del_conn
, -EOPNOTSUPP
);
932 OBD_COUNTER_INCREMENT(obd
, del_conn
);
934 rc
= OBP(obd
, del_conn
)(imp
, uuid
);
938 static inline struct obd_uuid
*obd_get_uuid(struct obd_export
*exp
)
940 struct obd_uuid
*uuid
;
942 OBD_CHECK_DT_OP(exp
->exp_obd
, get_uuid
, NULL
);
943 EXP_COUNTER_INCREMENT(exp
, get_uuid
);
945 uuid
= OBP(exp
->exp_obd
, get_uuid
)(exp
);
949 /** Create a new /a exp on device /a obd for the uuid /a cluuid
950 * @param exp New export handle
951 * @param d Connect data, supported flags are set, flags also understood
952 * by obd are returned.
954 static inline int obd_connect(const struct lu_env
*env
,
955 struct obd_export
**exp
,struct obd_device
*obd
,
956 struct obd_uuid
*cluuid
,
957 struct obd_connect_data
*data
,
961 __u64 ocf
= data
? data
->ocd_connect_flags
: 0; /* for post-condition
964 OBD_CHECK_DEV_ACTIVE(obd
);
965 OBD_CHECK_DT_OP(obd
, connect
, -EOPNOTSUPP
);
966 OBD_COUNTER_INCREMENT(obd
, connect
);
968 rc
= OBP(obd
, connect
)(env
, exp
, obd
, cluuid
, data
, localdata
);
969 /* check that only subset is granted */
970 LASSERT(ergo(data
!= NULL
, (data
->ocd_connect_flags
& ocf
) ==
971 data
->ocd_connect_flags
));
975 static inline int obd_reconnect(const struct lu_env
*env
,
976 struct obd_export
*exp
,
977 struct obd_device
*obd
,
978 struct obd_uuid
*cluuid
,
979 struct obd_connect_data
*d
,
983 __u64 ocf
= d
? d
->ocd_connect_flags
: 0; /* for post-condition
986 OBD_CHECK_DEV_ACTIVE(obd
);
987 OBD_CHECK_DT_OP(obd
, reconnect
, 0);
988 OBD_COUNTER_INCREMENT(obd
, reconnect
);
990 rc
= OBP(obd
, reconnect
)(env
, exp
, obd
, cluuid
, d
, localdata
);
991 /* check that only subset is granted */
992 LASSERT(ergo(d
!= NULL
,
993 (d
->ocd_connect_flags
& ocf
) == d
->ocd_connect_flags
));
997 static inline int obd_disconnect(struct obd_export
*exp
)
1001 EXP_CHECK_DT_OP(exp
, disconnect
);
1002 EXP_COUNTER_INCREMENT(exp
, disconnect
);
1004 rc
= OBP(exp
->exp_obd
, disconnect
)(exp
);
1008 static inline int obd_fid_init(struct obd_device
*obd
, struct obd_export
*exp
,
1009 enum lu_cli_type type
)
1013 OBD_CHECK_DT_OP(obd
, fid_init
, 0);
1014 OBD_COUNTER_INCREMENT(obd
, fid_init
);
1016 rc
= OBP(obd
, fid_init
)(obd
, exp
, type
);
1020 static inline int obd_fid_fini(struct obd_device
*obd
)
1024 OBD_CHECK_DT_OP(obd
, fid_fini
, 0);
1025 OBD_COUNTER_INCREMENT(obd
, fid_fini
);
1027 rc
= OBP(obd
, fid_fini
)(obd
);
1031 static inline int obd_fid_alloc(struct obd_export
*exp
,
1033 struct md_op_data
*op_data
)
1037 EXP_CHECK_DT_OP(exp
, fid_alloc
);
1038 EXP_COUNTER_INCREMENT(exp
, fid_alloc
);
1040 rc
= OBP(exp
->exp_obd
, fid_alloc
)(exp
, fid
, op_data
);
1044 static inline int obd_ping(const struct lu_env
*env
, struct obd_export
*exp
)
1048 OBD_CHECK_DT_OP(exp
->exp_obd
, ping
, 0);
1049 EXP_COUNTER_INCREMENT(exp
, ping
);
1051 rc
= OBP(exp
->exp_obd
, ping
)(env
, exp
);
1055 static inline int obd_pool_new(struct obd_device
*obd
, char *poolname
)
1059 OBD_CHECK_DT_OP(obd
, pool_new
, -EOPNOTSUPP
);
1060 OBD_COUNTER_INCREMENT(obd
, pool_new
);
1062 rc
= OBP(obd
, pool_new
)(obd
, poolname
);
1066 static inline int obd_pool_del(struct obd_device
*obd
, char *poolname
)
1070 OBD_CHECK_DT_OP(obd
, pool_del
, -EOPNOTSUPP
);
1071 OBD_COUNTER_INCREMENT(obd
, pool_del
);
1073 rc
= OBP(obd
, pool_del
)(obd
, poolname
);
1077 static inline int obd_pool_add(struct obd_device
*obd
, char *poolname
, char *ostname
)
1081 OBD_CHECK_DT_OP(obd
, pool_add
, -EOPNOTSUPP
);
1082 OBD_COUNTER_INCREMENT(obd
, pool_add
);
1084 rc
= OBP(obd
, pool_add
)(obd
, poolname
, ostname
);
1088 static inline int obd_pool_rem(struct obd_device
*obd
, char *poolname
, char *ostname
)
1092 OBD_CHECK_DT_OP(obd
, pool_rem
, -EOPNOTSUPP
);
1093 OBD_COUNTER_INCREMENT(obd
, pool_rem
);
1095 rc
= OBP(obd
, pool_rem
)(obd
, poolname
, ostname
);
1099 static inline void obd_getref(struct obd_device
*obd
)
1101 if (OBT(obd
) && OBP(obd
, getref
)) {
1102 OBD_COUNTER_INCREMENT(obd
, getref
);
1103 OBP(obd
, getref
)(obd
);
1107 static inline void obd_putref(struct obd_device
*obd
)
1109 if (OBT(obd
) && OBP(obd
, putref
)) {
1110 OBD_COUNTER_INCREMENT(obd
, putref
);
1111 OBP(obd
, putref
)(obd
);
1115 static inline int obd_init_export(struct obd_export
*exp
)
1119 if ((exp
)->exp_obd
!= NULL
&& OBT((exp
)->exp_obd
) &&
1120 OBP((exp
)->exp_obd
, init_export
))
1121 rc
= OBP(exp
->exp_obd
, init_export
)(exp
);
1125 static inline int obd_destroy_export(struct obd_export
*exp
)
1127 if ((exp
)->exp_obd
!= NULL
&& OBT((exp
)->exp_obd
) &&
1128 OBP((exp
)->exp_obd
, destroy_export
))
1129 OBP(exp
->exp_obd
, destroy_export
)(exp
);
1133 static inline int obd_extent_calc(struct obd_export
*exp
,
1134 struct lov_stripe_md
*md
,
1135 int cmd
, obd_off
*offset
)
1139 EXP_CHECK_DT_OP(exp
, extent_calc
);
1140 rc
= OBP(exp
->exp_obd
, extent_calc
)(exp
, md
, cmd
, offset
);
1144 static inline struct dentry
*
1145 obd_lvfs_fid2dentry(struct obd_export
*exp
, struct ost_id
*oi
, __u32 gen
)
1147 struct lvfs_run_ctxt
*ctxt
= &exp
->exp_obd
->obd_lvfs_ctxt
;
1148 LASSERT(exp
->exp_obd
);
1150 return ctxt
->cb_ops
.l_fid2dentry(ostid_id(oi
), gen
, ostid_seq(oi
),
1154 /* @max_age is the oldest time in jiffies that we accept using a cached data.
1155 * If the cache is older than @max_age we will get a new value from the
1156 * target. Use a value of "cfs_time_current() + HZ" to guarantee freshness. */
1157 static inline int obd_statfs_async(struct obd_export
*exp
,
1158 struct obd_info
*oinfo
,
1160 struct ptlrpc_request_set
*rqset
)
1163 struct obd_device
*obd
;
1165 if (exp
== NULL
|| exp
->exp_obd
== NULL
)
1169 OBD_CHECK_DT_OP(obd
, statfs
, -EOPNOTSUPP
);
1170 OBD_COUNTER_INCREMENT(obd
, statfs
);
1172 CDEBUG(D_SUPER
, "%s: osfs %p age "LPU64
", max_age "LPU64
"\n",
1173 obd
->obd_name
, &obd
->obd_osfs
, obd
->obd_osfs_age
, max_age
);
1174 if (cfs_time_before_64(obd
->obd_osfs_age
, max_age
)) {
1175 rc
= OBP(obd
, statfs_async
)(exp
, oinfo
, max_age
, rqset
);
1177 CDEBUG(D_SUPER
,"%s: use %p cache blocks "LPU64
"/"LPU64
1178 " objects "LPU64
"/"LPU64
"\n",
1179 obd
->obd_name
, &obd
->obd_osfs
,
1180 obd
->obd_osfs
.os_bavail
, obd
->obd_osfs
.os_blocks
,
1181 obd
->obd_osfs
.os_ffree
, obd
->obd_osfs
.os_files
);
1182 spin_lock(&obd
->obd_osfs_lock
);
1183 memcpy(oinfo
->oi_osfs
, &obd
->obd_osfs
, sizeof(*oinfo
->oi_osfs
));
1184 spin_unlock(&obd
->obd_osfs_lock
);
1185 oinfo
->oi_flags
|= OBD_STATFS_FROM_CACHE
;
1186 if (oinfo
->oi_cb_up
)
1187 oinfo
->oi_cb_up(oinfo
, 0);
1192 static inline int obd_statfs_rqset(struct obd_export
*exp
,
1193 struct obd_statfs
*osfs
, __u64 max_age
,
1196 struct ptlrpc_request_set
*set
= NULL
;
1197 struct obd_info oinfo
= { { { 0 } } };
1200 set
= ptlrpc_prep_set();
1204 oinfo
.oi_osfs
= osfs
;
1205 oinfo
.oi_flags
= flags
;
1206 rc
= obd_statfs_async(exp
, &oinfo
, max_age
, set
);
1208 rc
= ptlrpc_set_wait(set
);
1209 ptlrpc_set_destroy(set
);
1213 /* @max_age is the oldest time in jiffies that we accept using a cached data.
1214 * If the cache is older than @max_age we will get a new value from the
1215 * target. Use a value of "cfs_time_current() + HZ" to guarantee freshness. */
1216 static inline int obd_statfs(const struct lu_env
*env
, struct obd_export
*exp
,
1217 struct obd_statfs
*osfs
, __u64 max_age
,
1221 struct obd_device
*obd
= exp
->exp_obd
;
1226 OBD_CHECK_DT_OP(obd
, statfs
, -EOPNOTSUPP
);
1227 OBD_COUNTER_INCREMENT(obd
, statfs
);
1229 CDEBUG(D_SUPER
, "osfs "LPU64
", max_age "LPU64
"\n",
1230 obd
->obd_osfs_age
, max_age
);
1231 if (cfs_time_before_64(obd
->obd_osfs_age
, max_age
)) {
1232 rc
= OBP(obd
, statfs
)(env
, exp
, osfs
, max_age
, flags
);
1234 spin_lock(&obd
->obd_osfs_lock
);
1235 memcpy(&obd
->obd_osfs
, osfs
, sizeof(obd
->obd_osfs
));
1236 obd
->obd_osfs_age
= cfs_time_current_64();
1237 spin_unlock(&obd
->obd_osfs_lock
);
1240 CDEBUG(D_SUPER
, "%s: use %p cache blocks "LPU64
"/"LPU64
1241 " objects "LPU64
"/"LPU64
"\n",
1242 obd
->obd_name
, &obd
->obd_osfs
,
1243 obd
->obd_osfs
.os_bavail
, obd
->obd_osfs
.os_blocks
,
1244 obd
->obd_osfs
.os_ffree
, obd
->obd_osfs
.os_files
);
1245 spin_lock(&obd
->obd_osfs_lock
);
1246 memcpy(osfs
, &obd
->obd_osfs
, sizeof(*osfs
));
1247 spin_unlock(&obd
->obd_osfs_lock
);
1252 static inline int obd_sync_rqset(struct obd_export
*exp
, struct obd_info
*oinfo
,
1253 obd_size start
, obd_size end
)
1255 struct ptlrpc_request_set
*set
= NULL
;
1258 OBD_CHECK_DT_OP(exp
->exp_obd
, sync
, -EOPNOTSUPP
);
1259 EXP_COUNTER_INCREMENT(exp
, sync
);
1261 set
= ptlrpc_prep_set();
1265 rc
= OBP(exp
->exp_obd
, sync
)(NULL
, exp
, oinfo
, start
, end
, set
);
1267 rc
= ptlrpc_set_wait(set
);
1268 ptlrpc_set_destroy(set
);
1272 static inline int obd_sync(const struct lu_env
*env
, struct obd_export
*exp
,
1273 struct obd_info
*oinfo
, obd_size start
, obd_size end
,
1274 struct ptlrpc_request_set
*set
)
1278 OBD_CHECK_DT_OP(exp
->exp_obd
, sync
, -EOPNOTSUPP
);
1279 EXP_COUNTER_INCREMENT(exp
, sync
);
1281 rc
= OBP(exp
->exp_obd
, sync
)(env
, exp
, oinfo
, start
, end
, set
);
1285 static inline int obd_punch_rqset(struct obd_export
*exp
,
1286 struct obd_info
*oinfo
,
1287 struct obd_trans_info
*oti
)
1289 struct ptlrpc_request_set
*set
= NULL
;
1292 EXP_CHECK_DT_OP(exp
, punch
);
1293 EXP_COUNTER_INCREMENT(exp
, punch
);
1295 set
= ptlrpc_prep_set();
1299 rc
= OBP(exp
->exp_obd
, punch
)(NULL
, exp
, oinfo
, oti
, set
);
1301 rc
= ptlrpc_set_wait(set
);
1302 ptlrpc_set_destroy(set
);
1306 static inline int obd_punch(const struct lu_env
*env
, struct obd_export
*exp
,
1307 struct obd_info
*oinfo
, struct obd_trans_info
*oti
,
1308 struct ptlrpc_request_set
*rqset
)
1312 EXP_CHECK_DT_OP(exp
, punch
);
1313 EXP_COUNTER_INCREMENT(exp
, punch
);
1315 rc
= OBP(exp
->exp_obd
, punch
)(env
, exp
, oinfo
, oti
, rqset
);
1319 static inline int obd_brw(int cmd
, struct obd_export
*exp
,
1320 struct obd_info
*oinfo
, obd_count oa_bufs
,
1321 struct brw_page
*pg
, struct obd_trans_info
*oti
)
1325 EXP_CHECK_DT_OP(exp
, brw
);
1326 EXP_COUNTER_INCREMENT(exp
, brw
);
1328 if (!(cmd
& (OBD_BRW_RWMASK
| OBD_BRW_CHECK
))) {
1329 CERROR("obd_brw: cmd must be OBD_BRW_READ, OBD_BRW_WRITE, "
1330 "or OBD_BRW_CHECK\n");
1334 rc
= OBP(exp
->exp_obd
, brw
)(cmd
, exp
, oinfo
, oa_bufs
, pg
, oti
);
1338 static inline int obd_preprw(const struct lu_env
*env
, int cmd
,
1339 struct obd_export
*exp
, struct obdo
*oa
,
1340 int objcount
, struct obd_ioobj
*obj
,
1341 struct niobuf_remote
*remote
, int *pages
,
1342 struct niobuf_local
*local
,
1343 struct obd_trans_info
*oti
,
1344 struct lustre_capa
*capa
)
1348 EXP_CHECK_DT_OP(exp
, preprw
);
1349 EXP_COUNTER_INCREMENT(exp
, preprw
);
1351 rc
= OBP(exp
->exp_obd
, preprw
)(env
, cmd
, exp
, oa
, objcount
, obj
, remote
,
1352 pages
, local
, oti
, capa
);
1356 static inline int obd_commitrw(const struct lu_env
*env
, int cmd
,
1357 struct obd_export
*exp
, struct obdo
*oa
,
1358 int objcount
, struct obd_ioobj
*obj
,
1359 struct niobuf_remote
*rnb
, int pages
,
1360 struct niobuf_local
*local
,
1361 struct obd_trans_info
*oti
, int rc
)
1363 EXP_CHECK_DT_OP(exp
, commitrw
);
1364 EXP_COUNTER_INCREMENT(exp
, commitrw
);
1366 rc
= OBP(exp
->exp_obd
, commitrw
)(env
, cmd
, exp
, oa
, objcount
, obj
,
1367 rnb
, pages
, local
, oti
, rc
);
1371 static inline int obd_merge_lvb(struct obd_export
*exp
,
1372 struct lov_stripe_md
*lsm
,
1373 struct ost_lvb
*lvb
, int kms_only
)
1377 EXP_CHECK_DT_OP(exp
, merge_lvb
);
1378 EXP_COUNTER_INCREMENT(exp
, merge_lvb
);
1380 rc
= OBP(exp
->exp_obd
, merge_lvb
)(exp
, lsm
, lvb
, kms_only
);
1384 static inline int obd_adjust_kms(struct obd_export
*exp
,
1385 struct lov_stripe_md
*lsm
, obd_off size
,
1390 EXP_CHECK_DT_OP(exp
, adjust_kms
);
1391 EXP_COUNTER_INCREMENT(exp
, adjust_kms
);
1393 rc
= OBP(exp
->exp_obd
, adjust_kms
)(exp
, lsm
, size
, shrink
);
1397 static inline int obd_iocontrol(unsigned int cmd
, struct obd_export
*exp
,
1398 int len
, void *karg
, void *uarg
)
1402 EXP_CHECK_DT_OP(exp
, iocontrol
);
1403 EXP_COUNTER_INCREMENT(exp
, iocontrol
);
1405 rc
= OBP(exp
->exp_obd
, iocontrol
)(cmd
, exp
, len
, karg
, uarg
);
1409 static inline int obd_enqueue_rqset(struct obd_export
*exp
,
1410 struct obd_info
*oinfo
,
1411 struct ldlm_enqueue_info
*einfo
)
1413 struct ptlrpc_request_set
*set
= NULL
;
1416 EXP_CHECK_DT_OP(exp
, enqueue
);
1417 EXP_COUNTER_INCREMENT(exp
, enqueue
);
1419 set
= ptlrpc_prep_set();
1423 rc
= OBP(exp
->exp_obd
, enqueue
)(exp
, oinfo
, einfo
, set
);
1425 rc
= ptlrpc_set_wait(set
);
1426 ptlrpc_set_destroy(set
);
1430 static inline int obd_enqueue(struct obd_export
*exp
,
1431 struct obd_info
*oinfo
,
1432 struct ldlm_enqueue_info
*einfo
,
1433 struct ptlrpc_request_set
*set
)
1437 EXP_CHECK_DT_OP(exp
, enqueue
);
1438 EXP_COUNTER_INCREMENT(exp
, enqueue
);
1440 rc
= OBP(exp
->exp_obd
, enqueue
)(exp
, oinfo
, einfo
, set
);
1444 static inline int obd_change_cbdata(struct obd_export
*exp
,
1445 struct lov_stripe_md
*lsm
,
1446 ldlm_iterator_t it
, void *data
)
1450 EXP_CHECK_DT_OP(exp
, change_cbdata
);
1451 EXP_COUNTER_INCREMENT(exp
, change_cbdata
);
1453 rc
= OBP(exp
->exp_obd
, change_cbdata
)(exp
, lsm
, it
, data
);
1457 static inline int obd_find_cbdata(struct obd_export
*exp
,
1458 struct lov_stripe_md
*lsm
,
1459 ldlm_iterator_t it
, void *data
)
1463 EXP_CHECK_DT_OP(exp
, find_cbdata
);
1464 EXP_COUNTER_INCREMENT(exp
, find_cbdata
);
1466 rc
= OBP(exp
->exp_obd
, find_cbdata
)(exp
, lsm
, it
, data
);
1470 static inline int obd_cancel(struct obd_export
*exp
,
1471 struct lov_stripe_md
*ea
, __u32 mode
,
1472 struct lustre_handle
*lockh
)
1476 EXP_CHECK_DT_OP(exp
, cancel
);
1477 EXP_COUNTER_INCREMENT(exp
, cancel
);
1479 rc
= OBP(exp
->exp_obd
, cancel
)(exp
, ea
, mode
, lockh
);
1483 static inline int obd_cancel_unused(struct obd_export
*exp
,
1484 struct lov_stripe_md
*ea
,
1485 ldlm_cancel_flags_t flags
,
1490 EXP_CHECK_DT_OP(exp
, cancel_unused
);
1491 EXP_COUNTER_INCREMENT(exp
, cancel_unused
);
1493 rc
= OBP(exp
->exp_obd
, cancel_unused
)(exp
, ea
, flags
, opaque
);
1497 static inline int obd_pin(struct obd_export
*exp
, const struct lu_fid
*fid
,
1498 struct obd_capa
*oc
, struct obd_client_handle
*handle
,
1503 EXP_CHECK_DT_OP(exp
, pin
);
1504 EXP_COUNTER_INCREMENT(exp
, pin
);
1506 rc
= OBP(exp
->exp_obd
, pin
)(exp
, fid
, oc
, handle
, flag
);
1510 static inline int obd_unpin(struct obd_export
*exp
,
1511 struct obd_client_handle
*handle
, int flag
)
1515 EXP_CHECK_DT_OP(exp
, unpin
);
1516 EXP_COUNTER_INCREMENT(exp
, unpin
);
1518 rc
= OBP(exp
->exp_obd
, unpin
)(exp
, handle
, flag
);
1523 static inline void obd_import_event(struct obd_device
*obd
,
1524 struct obd_import
*imp
,
1525 enum obd_import_event event
)
1528 CERROR("NULL device\n");
1531 if (obd
->obd_set_up
&& OBP(obd
, import_event
)) {
1532 OBD_COUNTER_INCREMENT(obd
, import_event
);
1533 OBP(obd
, import_event
)(obd
, imp
, event
);
1537 static inline int obd_llog_connect(struct obd_export
*exp
,
1538 struct llogd_conn_body
*body
)
1542 OBD_CHECK_DT_OP(exp
->exp_obd
, llog_connect
, 0);
1543 EXP_COUNTER_INCREMENT(exp
, llog_connect
);
1545 rc
= OBP(exp
->exp_obd
, llog_connect
)(exp
, body
);
1550 static inline int obd_notify(struct obd_device
*obd
,
1551 struct obd_device
*watched
,
1552 enum obd_notify_event ev
,
1559 /* the check for async_recov is a complete hack - I'm hereby
1560 overloading the meaning to also mean "this was called from
1561 mds_postsetup". I know that my mds is able to handle notifies
1562 by this point, and it needs to get them to execute mds_postrecov. */
1563 if (!obd
->obd_set_up
&& !obd
->obd_async_recov
) {
1564 CDEBUG(D_HA
, "obd %s not set up\n", obd
->obd_name
);
1568 if (!OBP(obd
, notify
)) {
1569 CDEBUG(D_HA
, "obd %s has no notify handler\n", obd
->obd_name
);
1573 OBD_COUNTER_INCREMENT(obd
, notify
);
1574 rc
= OBP(obd
, notify
)(obd
, watched
, ev
, data
);
1578 static inline int obd_notify_observer(struct obd_device
*observer
,
1579 struct obd_device
*observed
,
1580 enum obd_notify_event ev
,
1586 struct obd_notify_upcall
*onu
;
1588 if (observer
->obd_observer
)
1589 rc1
= obd_notify(observer
->obd_observer
, observed
, ev
, data
);
1593 * Also, call non-obd listener, if any
1595 onu
= &observer
->obd_upcall
;
1596 if (onu
->onu_upcall
!= NULL
)
1597 rc2
= onu
->onu_upcall(observer
, observed
, ev
,
1598 onu
->onu_owner
, NULL
);
1602 return rc1
? rc1
: rc2
;
1605 static inline int obd_quotacheck(struct obd_export
*exp
,
1606 struct obd_quotactl
*oqctl
)
1610 EXP_CHECK_DT_OP(exp
, quotacheck
);
1611 EXP_COUNTER_INCREMENT(exp
, quotacheck
);
1613 rc
= OBP(exp
->exp_obd
, quotacheck
)(exp
->exp_obd
, exp
, oqctl
);
1617 static inline int obd_quotactl(struct obd_export
*exp
,
1618 struct obd_quotactl
*oqctl
)
1622 EXP_CHECK_DT_OP(exp
, quotactl
);
1623 EXP_COUNTER_INCREMENT(exp
, quotactl
);
1625 rc
= OBP(exp
->exp_obd
, quotactl
)(exp
->exp_obd
, exp
, oqctl
);
1629 static inline int obd_health_check(const struct lu_env
*env
,
1630 struct obd_device
*obd
)
1632 /* returns: 0 on healthy
1633 * >0 on unhealthy + reason code/flag
1634 * however the only supported reason == 1 right now
1635 * We'll need to define some better reasons
1636 * or flags in the future.
1641 /* don't use EXP_CHECK_DT_OP, because NULL method is normal here */
1642 if (obd
== NULL
|| !OBT(obd
)) {
1643 CERROR("cleaned up obd\n");
1646 if (!obd
->obd_set_up
|| obd
->obd_stopping
)
1648 if (!OBP(obd
, health_check
))
1651 rc
= OBP(obd
, health_check
)(env
, obd
);
1655 static inline int obd_register_observer(struct obd_device
*obd
,
1656 struct obd_device
*observer
)
1659 down_write(&obd
->obd_observer_link_sem
);
1660 if (obd
->obd_observer
&& observer
) {
1661 up_write(&obd
->obd_observer_link_sem
);
1664 obd
->obd_observer
= observer
;
1665 up_write(&obd
->obd_observer_link_sem
);
1669 static inline int obd_pin_observer(struct obd_device
*obd
,
1670 struct obd_device
**observer
)
1672 down_read(&obd
->obd_observer_link_sem
);
1673 if (!obd
->obd_observer
) {
1675 up_read(&obd
->obd_observer_link_sem
);
1678 *observer
= obd
->obd_observer
;
1682 static inline int obd_unpin_observer(struct obd_device
*obd
)
1684 up_read(&obd
->obd_observer_link_sem
);
1689 static inline int obd_register_page_removal_cb(struct obd_export
*exp
,
1690 obd_page_removal_cb_t cb
,
1691 obd_pin_extent_cb pin_cb
)
1695 OBD_CHECK_DT_OP(exp
->exp_obd
, register_page_removal_cb
, 0);
1696 OBD_COUNTER_INCREMENT(exp
->exp_obd
, register_page_removal_cb
);
1698 rc
= OBP(exp
->exp_obd
, register_page_removal_cb
)(exp
, cb
, pin_cb
);
1702 static inline int obd_unregister_page_removal_cb(struct obd_export
*exp
,
1703 obd_page_removal_cb_t cb
)
1707 OBD_CHECK_DT_OP(exp
->exp_obd
, unregister_page_removal_cb
, 0);
1708 OBD_COUNTER_INCREMENT(exp
->exp_obd
, unregister_page_removal_cb
);
1710 rc
= OBP(exp
->exp_obd
, unregister_page_removal_cb
)(exp
, cb
);
1714 static inline int obd_register_lock_cancel_cb(struct obd_export
*exp
,
1715 obd_lock_cancel_cb cb
)
1719 OBD_CHECK_DT_OP(exp
->exp_obd
, register_lock_cancel_cb
, 0);
1720 OBD_COUNTER_INCREMENT(exp
->exp_obd
, register_lock_cancel_cb
);
1722 rc
= OBP(exp
->exp_obd
, register_lock_cancel_cb
)(exp
, cb
);
1726 static inline int obd_unregister_lock_cancel_cb(struct obd_export
*exp
,
1727 obd_lock_cancel_cb cb
)
1731 OBD_CHECK_DT_OP(exp
->exp_obd
, unregister_lock_cancel_cb
, 0);
1732 OBD_COUNTER_INCREMENT(exp
->exp_obd
, unregister_lock_cancel_cb
);
1734 rc
= OBP(exp
->exp_obd
, unregister_lock_cancel_cb
)(exp
, cb
);
1739 /* metadata helpers */
1740 static inline int md_getstatus(struct obd_export
*exp
,
1741 struct lu_fid
*fid
, struct obd_capa
**pc
)
1745 EXP_CHECK_MD_OP(exp
, getstatus
);
1746 EXP_MD_COUNTER_INCREMENT(exp
, getstatus
);
1747 rc
= MDP(exp
->exp_obd
, getstatus
)(exp
, fid
, pc
);
1751 static inline int md_getattr(struct obd_export
*exp
, struct md_op_data
*op_data
,
1752 struct ptlrpc_request
**request
)
1756 EXP_CHECK_MD_OP(exp
, getattr
);
1757 EXP_MD_COUNTER_INCREMENT(exp
, getattr
);
1758 rc
= MDP(exp
->exp_obd
, getattr
)(exp
, op_data
, request
);
1762 static inline int md_null_inode(struct obd_export
*exp
,
1763 const struct lu_fid
*fid
)
1767 EXP_CHECK_MD_OP(exp
, null_inode
);
1768 EXP_MD_COUNTER_INCREMENT(exp
, null_inode
);
1769 rc
= MDP(exp
->exp_obd
, null_inode
)(exp
, fid
);
1773 static inline int md_find_cbdata(struct obd_export
*exp
,
1774 const struct lu_fid
*fid
,
1775 ldlm_iterator_t it
, void *data
)
1779 EXP_CHECK_MD_OP(exp
, find_cbdata
);
1780 EXP_MD_COUNTER_INCREMENT(exp
, find_cbdata
);
1781 rc
= MDP(exp
->exp_obd
, find_cbdata
)(exp
, fid
, it
, data
);
1785 static inline int md_close(struct obd_export
*exp
, struct md_op_data
*op_data
,
1786 struct md_open_data
*mod
,
1787 struct ptlrpc_request
**request
)
1791 EXP_CHECK_MD_OP(exp
, close
);
1792 EXP_MD_COUNTER_INCREMENT(exp
, close
);
1793 rc
= MDP(exp
->exp_obd
, close
)(exp
, op_data
, mod
, request
);
1797 static inline int md_create(struct obd_export
*exp
, struct md_op_data
*op_data
,
1798 const void *data
, int datalen
, int mode
, __u32 uid
,
1799 __u32 gid
, cfs_cap_t cap_effective
, __u64 rdev
,
1800 struct ptlrpc_request
**request
)
1804 EXP_CHECK_MD_OP(exp
, create
);
1805 EXP_MD_COUNTER_INCREMENT(exp
, create
);
1806 rc
= MDP(exp
->exp_obd
, create
)(exp
, op_data
, data
, datalen
, mode
,
1807 uid
, gid
, cap_effective
, rdev
, request
);
1811 static inline int md_done_writing(struct obd_export
*exp
,
1812 struct md_op_data
*op_data
,
1813 struct md_open_data
*mod
)
1817 EXP_CHECK_MD_OP(exp
, done_writing
);
1818 EXP_MD_COUNTER_INCREMENT(exp
, done_writing
);
1819 rc
= MDP(exp
->exp_obd
, done_writing
)(exp
, op_data
, mod
);
1823 static inline int md_enqueue(struct obd_export
*exp
,
1824 struct ldlm_enqueue_info
*einfo
,
1825 struct lookup_intent
*it
,
1826 struct md_op_data
*op_data
,
1827 struct lustre_handle
*lockh
,
1828 void *lmm
, int lmmsize
,
1829 struct ptlrpc_request
**req
,
1830 int extra_lock_flags
)
1834 EXP_CHECK_MD_OP(exp
, enqueue
);
1835 EXP_MD_COUNTER_INCREMENT(exp
, enqueue
);
1836 rc
= MDP(exp
->exp_obd
, enqueue
)(exp
, einfo
, it
, op_data
, lockh
,
1837 lmm
, lmmsize
, req
, extra_lock_flags
);
1841 static inline int md_getattr_name(struct obd_export
*exp
,
1842 struct md_op_data
*op_data
,
1843 struct ptlrpc_request
**request
)
1847 EXP_CHECK_MD_OP(exp
, getattr_name
);
1848 EXP_MD_COUNTER_INCREMENT(exp
, getattr_name
);
1849 rc
= MDP(exp
->exp_obd
, getattr_name
)(exp
, op_data
, request
);
1853 static inline int md_intent_lock(struct obd_export
*exp
,
1854 struct md_op_data
*op_data
, void *lmm
,
1855 int lmmsize
, struct lookup_intent
*it
,
1856 int lookup_flags
, struct ptlrpc_request
**reqp
,
1857 ldlm_blocking_callback cb_blocking
,
1858 __u64 extra_lock_flags
)
1862 EXP_CHECK_MD_OP(exp
, intent_lock
);
1863 EXP_MD_COUNTER_INCREMENT(exp
, intent_lock
);
1864 rc
= MDP(exp
->exp_obd
, intent_lock
)(exp
, op_data
, lmm
, lmmsize
,
1865 it
, lookup_flags
, reqp
, cb_blocking
,
1870 static inline int md_link(struct obd_export
*exp
, struct md_op_data
*op_data
,
1871 struct ptlrpc_request
**request
)
1875 EXP_CHECK_MD_OP(exp
, link
);
1876 EXP_MD_COUNTER_INCREMENT(exp
, link
);
1877 rc
= MDP(exp
->exp_obd
, link
)(exp
, op_data
, request
);
1881 static inline int md_rename(struct obd_export
*exp
, struct md_op_data
*op_data
,
1882 const char *old
, int oldlen
, const char *new,
1883 int newlen
, struct ptlrpc_request
**request
)
1887 EXP_CHECK_MD_OP(exp
, rename
);
1888 EXP_MD_COUNTER_INCREMENT(exp
, rename
);
1889 rc
= MDP(exp
->exp_obd
, rename
)(exp
, op_data
, old
, oldlen
, new,
1894 static inline int md_is_subdir(struct obd_export
*exp
,
1895 const struct lu_fid
*pfid
,
1896 const struct lu_fid
*cfid
,
1897 struct ptlrpc_request
**request
)
1901 EXP_CHECK_MD_OP(exp
, is_subdir
);
1902 EXP_MD_COUNTER_INCREMENT(exp
, is_subdir
);
1903 rc
= MDP(exp
->exp_obd
, is_subdir
)(exp
, pfid
, cfid
, request
);
1907 static inline int md_setattr(struct obd_export
*exp
, struct md_op_data
*op_data
,
1908 void *ea
, int ealen
, void *ea2
, int ea2len
,
1909 struct ptlrpc_request
**request
,
1910 struct md_open_data
**mod
)
1914 EXP_CHECK_MD_OP(exp
, setattr
);
1915 EXP_MD_COUNTER_INCREMENT(exp
, setattr
);
1916 rc
= MDP(exp
->exp_obd
, setattr
)(exp
, op_data
, ea
, ealen
,
1917 ea2
, ea2len
, request
, mod
);
1921 static inline int md_sync(struct obd_export
*exp
, const struct lu_fid
*fid
,
1922 struct obd_capa
*oc
, struct ptlrpc_request
**request
)
1926 EXP_CHECK_MD_OP(exp
, sync
);
1927 EXP_MD_COUNTER_INCREMENT(exp
, sync
);
1928 rc
= MDP(exp
->exp_obd
, sync
)(exp
, fid
, oc
, request
);
1932 static inline int md_readpage(struct obd_export
*exp
, struct md_op_data
*opdata
,
1933 struct page
**pages
,
1934 struct ptlrpc_request
**request
)
1938 EXP_CHECK_MD_OP(exp
, readpage
);
1939 EXP_MD_COUNTER_INCREMENT(exp
, readpage
);
1940 rc
= MDP(exp
->exp_obd
, readpage
)(exp
, opdata
, pages
, request
);
1944 static inline int md_unlink(struct obd_export
*exp
, struct md_op_data
*op_data
,
1945 struct ptlrpc_request
**request
)
1949 EXP_CHECK_MD_OP(exp
, unlink
);
1950 EXP_MD_COUNTER_INCREMENT(exp
, unlink
);
1951 rc
= MDP(exp
->exp_obd
, unlink
)(exp
, op_data
, request
);
1955 static inline int md_get_lustre_md(struct obd_export
*exp
,
1956 struct ptlrpc_request
*req
,
1957 struct obd_export
*dt_exp
,
1958 struct obd_export
*md_exp
,
1959 struct lustre_md
*md
)
1961 EXP_CHECK_MD_OP(exp
, get_lustre_md
);
1962 EXP_MD_COUNTER_INCREMENT(exp
, get_lustre_md
);
1963 return MDP(exp
->exp_obd
, get_lustre_md
)(exp
, req
, dt_exp
, md_exp
, md
);
1966 static inline int md_free_lustre_md(struct obd_export
*exp
,
1967 struct lustre_md
*md
)
1969 EXP_CHECK_MD_OP(exp
, free_lustre_md
);
1970 EXP_MD_COUNTER_INCREMENT(exp
, free_lustre_md
);
1971 return MDP(exp
->exp_obd
, free_lustre_md
)(exp
, md
);
1974 static inline int md_setxattr(struct obd_export
*exp
,
1975 const struct lu_fid
*fid
, struct obd_capa
*oc
,
1976 obd_valid valid
, const char *name
,
1977 const char *input
, int input_size
,
1978 int output_size
, int flags
, __u32 suppgid
,
1979 struct ptlrpc_request
**request
)
1981 EXP_CHECK_MD_OP(exp
, setxattr
);
1982 EXP_MD_COUNTER_INCREMENT(exp
, setxattr
);
1983 return MDP(exp
->exp_obd
, setxattr
)(exp
, fid
, oc
, valid
, name
, input
,
1984 input_size
, output_size
, flags
,
1988 static inline int md_getxattr(struct obd_export
*exp
,
1989 const struct lu_fid
*fid
, struct obd_capa
*oc
,
1990 obd_valid valid
, const char *name
,
1991 const char *input
, int input_size
,
1992 int output_size
, int flags
,
1993 struct ptlrpc_request
**request
)
1995 EXP_CHECK_MD_OP(exp
, getxattr
);
1996 EXP_MD_COUNTER_INCREMENT(exp
, getxattr
);
1997 return MDP(exp
->exp_obd
, getxattr
)(exp
, fid
, oc
, valid
, name
, input
,
1998 input_size
, output_size
, flags
,
2002 static inline int md_set_open_replay_data(struct obd_export
*exp
,
2003 struct obd_client_handle
*och
,
2004 struct lookup_intent
*it
)
2006 EXP_CHECK_MD_OP(exp
, set_open_replay_data
);
2007 EXP_MD_COUNTER_INCREMENT(exp
, set_open_replay_data
);
2008 return MDP(exp
->exp_obd
, set_open_replay_data
)(exp
, och
, it
);
2011 static inline int md_clear_open_replay_data(struct obd_export
*exp
,
2012 struct obd_client_handle
*och
)
2014 EXP_CHECK_MD_OP(exp
, clear_open_replay_data
);
2015 EXP_MD_COUNTER_INCREMENT(exp
, clear_open_replay_data
);
2016 return MDP(exp
->exp_obd
, clear_open_replay_data
)(exp
, och
);
2019 static inline int md_set_lock_data(struct obd_export
*exp
,
2020 __u64
*lockh
, void *data
, __u64
*bits
)
2022 EXP_CHECK_MD_OP(exp
, set_lock_data
);
2023 EXP_MD_COUNTER_INCREMENT(exp
, set_lock_data
);
2024 return MDP(exp
->exp_obd
, set_lock_data
)(exp
, lockh
, data
, bits
);
2027 static inline int md_cancel_unused(struct obd_export
*exp
,
2028 const struct lu_fid
*fid
,
2029 ldlm_policy_data_t
*policy
,
2031 ldlm_cancel_flags_t flags
,
2036 EXP_CHECK_MD_OP(exp
, cancel_unused
);
2037 EXP_MD_COUNTER_INCREMENT(exp
, cancel_unused
);
2039 rc
= MDP(exp
->exp_obd
, cancel_unused
)(exp
, fid
, policy
, mode
,
2044 static inline ldlm_mode_t
md_lock_match(struct obd_export
*exp
, __u64 flags
,
2045 const struct lu_fid
*fid
,
2047 ldlm_policy_data_t
*policy
,
2049 struct lustre_handle
*lockh
)
2051 EXP_CHECK_MD_OP(exp
, lock_match
);
2052 EXP_MD_COUNTER_INCREMENT(exp
, lock_match
);
2053 return MDP(exp
->exp_obd
, lock_match
)(exp
, flags
, fid
, type
,
2054 policy
, mode
, lockh
);
2057 static inline int md_init_ea_size(struct obd_export
*exp
, int easize
,
2058 int def_asize
, int cookiesize
)
2060 EXP_CHECK_MD_OP(exp
, init_ea_size
);
2061 EXP_MD_COUNTER_INCREMENT(exp
, init_ea_size
);
2062 return MDP(exp
->exp_obd
, init_ea_size
)(exp
, easize
, def_asize
,
2066 static inline int md_get_remote_perm(struct obd_export
*exp
,
2067 const struct lu_fid
*fid
,
2068 struct obd_capa
*oc
, __u32 suppgid
,
2069 struct ptlrpc_request
**request
)
2071 EXP_CHECK_MD_OP(exp
, get_remote_perm
);
2072 EXP_MD_COUNTER_INCREMENT(exp
, get_remote_perm
);
2073 return MDP(exp
->exp_obd
, get_remote_perm
)(exp
, fid
, oc
, suppgid
,
2077 static inline int md_renew_capa(struct obd_export
*exp
, struct obd_capa
*ocapa
,
2082 EXP_CHECK_MD_OP(exp
, renew_capa
);
2083 EXP_MD_COUNTER_INCREMENT(exp
, renew_capa
);
2084 rc
= MDP(exp
->exp_obd
, renew_capa
)(exp
, ocapa
, cb
);
2088 static inline int md_unpack_capa(struct obd_export
*exp
,
2089 struct ptlrpc_request
*req
,
2090 const struct req_msg_field
*field
,
2091 struct obd_capa
**oc
)
2095 EXP_CHECK_MD_OP(exp
, unpack_capa
);
2096 EXP_MD_COUNTER_INCREMENT(exp
, unpack_capa
);
2097 rc
= MDP(exp
->exp_obd
, unpack_capa
)(exp
, req
, field
, oc
);
2101 static inline int md_intent_getattr_async(struct obd_export
*exp
,
2102 struct md_enqueue_info
*minfo
,
2103 struct ldlm_enqueue_info
*einfo
)
2107 EXP_CHECK_MD_OP(exp
, intent_getattr_async
);
2108 EXP_MD_COUNTER_INCREMENT(exp
, intent_getattr_async
);
2109 rc
= MDP(exp
->exp_obd
, intent_getattr_async
)(exp
, minfo
, einfo
);
2113 static inline int md_revalidate_lock(struct obd_export
*exp
,
2114 struct lookup_intent
*it
,
2115 struct lu_fid
*fid
, __u64
*bits
)
2119 EXP_CHECK_MD_OP(exp
, revalidate_lock
);
2120 EXP_MD_COUNTER_INCREMENT(exp
, revalidate_lock
);
2121 rc
= MDP(exp
->exp_obd
, revalidate_lock
)(exp
, it
, fid
, bits
);
2126 /* OBD Metadata Support */
2128 extern int obd_init_caches(void);
2129 extern void obd_cleanup_caches(void);
2131 /* support routines */
2132 extern struct kmem_cache
*obdo_cachep
;
2134 #define OBDO_ALLOC(ptr) \
2136 OBD_SLAB_ALLOC_PTR_GFP((ptr), obdo_cachep, __GFP_IO); \
2139 #define OBDO_FREE(ptr) \
2141 OBD_SLAB_FREE_PTR((ptr), obdo_cachep); \
2145 static inline void obdo2fid(struct obdo
*oa
, struct lu_fid
*fid
)
2147 /* something here */
2150 static inline void fid2obdo(struct lu_fid
*fid
, struct obdo
*oa
)
2152 /* something here */
2155 typedef int (*register_lwp_cb
)(void *data
);
2157 struct lwp_register_item
{
2158 struct obd_export
**lri_exp
;
2159 register_lwp_cb lri_cb_func
;
2161 struct list_head lri_list
;
2162 char lri_name
[MTI_NAME_MAXLEN
];
2165 /* I'm as embarrassed about this as you are.
2167 * <shaver> // XXX do not look into _superhack with remaining eye
2168 * <shaver> // XXX if this were any uglier, I'd get my own show on MTV */
2169 extern int (*ptlrpc_put_connection_superhack
)(struct ptlrpc_connection
*c
);
2174 extern void obd_sysctl_init (void);
2175 extern void obd_sysctl_clean (void);
2178 typedef __u8 class_uuid_t
[16];
2179 void class_uuid_unparse(class_uuid_t in
, struct obd_uuid
*out
);
2182 int lustre_uuid_to_peer(const char *uuid
, lnet_nid_t
*peer_nid
, int index
);
2183 int class_add_uuid(const char *uuid
, __u64 nid
);
2184 int class_del_uuid (const char *uuid
);
2185 int class_check_uuid(struct obd_uuid
*uuid
, __u64 nid
);
2186 void class_init_uuidlist(void);
2187 void class_exit_uuidlist(void);
2190 int mea_name2idx(struct lmv_stripe_md
*mea
, const char *name
, int namelen
);
2191 int raw_name2idx(int hashtype
, int count
, const char *name
, int namelen
);
2194 #define ll_generate_random_uuid(uuid_out) cfs_get_random_bytes(uuid_out, sizeof(class_uuid_t))
2196 #endif /* __LINUX_OBD_CLASS_H */