Loading...
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 | /*
* GPL HEADER START
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 only,
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License version 2 for more details (a copy is included
* in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU General Public License
* version 2 along with this program; If not, see
* http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
* GPL HEADER END
*/
/*
* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
* Copyright (c) 2011, 2012, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
* Lustre is a trademark of Sun Microsystems, Inc.
*/
/* Intramodule declarations for ptlrpc. */
#ifndef PTLRPC_INTERNAL_H
#define PTLRPC_INTERNAL_H
#include "../ldlm/ldlm_internal.h"
struct ldlm_namespace;
struct obd_import;
struct ldlm_res_id;
struct ptlrpc_request_set;
extern int test_req_buffer_pressure;
extern struct mutex ptlrpc_all_services_mutex;
int ptlrpc_start_thread(struct ptlrpc_service_part *svcpt, int wait);
/* ptlrpcd.c */
int ptlrpcd_start(int index, int max, const char *name, struct ptlrpcd_ctl *pc);
/* client.c */
struct ptlrpc_bulk_desc *ptlrpc_new_bulk(unsigned npages, unsigned max_brw,
unsigned type, unsigned portal);
void ptlrpc_init_xid(void);
/* events.c */
int ptlrpc_init_portals(void);
void ptlrpc_exit_portals(void);
void ptlrpc_request_handle_notconn(struct ptlrpc_request *);
void lustre_assert_wire_constants(void);
int ptlrpc_import_in_recovery(struct obd_import *imp);
int ptlrpc_set_import_discon(struct obd_import *imp, __u32 conn_cnt);
void ptlrpc_handle_failed_import(struct obd_import *imp);
int ptlrpc_replay_next(struct obd_import *imp, int *inflight);
void ptlrpc_initiate_recovery(struct obd_import *imp);
int lustre_unpack_req_ptlrpc_body(struct ptlrpc_request *req, int offset);
int lustre_unpack_rep_ptlrpc_body(struct ptlrpc_request *req, int offset);
#ifdef LPROCFS
void ptlrpc_lprocfs_register_service(struct proc_dir_entry *proc_entry,
struct ptlrpc_service *svc);
void ptlrpc_lprocfs_unregister_service(struct ptlrpc_service *svc);
void ptlrpc_lprocfs_rpc_sent(struct ptlrpc_request *req, long amount);
void ptlrpc_lprocfs_do_request_stat (struct ptlrpc_request *req,
long q_usec, long work_usec);
#else
#define ptlrpc_lprocfs_register_service(params...) do{}while(0)
#define ptlrpc_lprocfs_unregister_service(params...) do{}while(0)
#define ptlrpc_lprocfs_rpc_sent(params...) do{}while(0)
#define ptlrpc_lprocfs_do_request_stat(params...) do{}while(0)
#endif /* LPROCFS */
/* NRS */
/**
* NRS core object.
*
* Holds NRS core fields.
*/
struct nrs_core {
/**
* Protects nrs_core::nrs_policies, serializes external policy
* registration/unregistration, and NRS core lprocfs operations.
*/
struct mutex nrs_mutex;
/* XXX: This is just for liblustre. Remove the #if defined directive
* when the * "cfs_" prefix is dropped from cfs_list_head. */
/**
* List of all policy descriptors registered with NRS core; protected
* by nrs_core::nrs_mutex.
*/
struct list_head nrs_policies;
};
int ptlrpc_service_nrs_setup(struct ptlrpc_service *svc);
void ptlrpc_service_nrs_cleanup(struct ptlrpc_service *svc);
void ptlrpc_nrs_req_initialize(struct ptlrpc_service_part *svcpt,
struct ptlrpc_request *req, bool hp);
void ptlrpc_nrs_req_finalize(struct ptlrpc_request *req);
void ptlrpc_nrs_req_stop_nolock(struct ptlrpc_request *req);
void ptlrpc_nrs_req_add(struct ptlrpc_service_part *svcpt,
struct ptlrpc_request *req, bool hp);
struct ptlrpc_request *
ptlrpc_nrs_req_get_nolock0(struct ptlrpc_service_part *svcpt, bool hp,
bool peek, bool force);
static inline struct ptlrpc_request *
ptlrpc_nrs_req_get_nolock(struct ptlrpc_service_part *svcpt, bool hp,
bool force)
{
return ptlrpc_nrs_req_get_nolock0(svcpt, hp, false, force);
}
static inline struct ptlrpc_request *
ptlrpc_nrs_req_peek_nolock(struct ptlrpc_service_part *svcpt, bool hp)
{
return ptlrpc_nrs_req_get_nolock0(svcpt, hp, true, false);
}
void ptlrpc_nrs_req_del_nolock(struct ptlrpc_request *req);
bool ptlrpc_nrs_req_pending_nolock(struct ptlrpc_service_part *svcpt, bool hp);
int ptlrpc_nrs_policy_control(const struct ptlrpc_service *svc,
enum ptlrpc_nrs_queue_type queue, char *name,
enum ptlrpc_nrs_ctl opc, bool single, void *arg);
int ptlrpc_nrs_init(void);
void ptlrpc_nrs_fini(void);
static inline bool nrs_svcpt_has_hp(const struct ptlrpc_service_part *svcpt)
{
return svcpt->scp_nrs_hp != NULL;
}
static inline bool nrs_svc_has_hp(const struct ptlrpc_service *svc)
{
/**
* If the first service partition has an HP NRS head, all service
* partitions will.
*/
return nrs_svcpt_has_hp(svc->srv_parts[0]);
}
static inline
struct ptlrpc_nrs *nrs_svcpt2nrs(struct ptlrpc_service_part *svcpt, bool hp)
{
LASSERT(ergo(hp, nrs_svcpt_has_hp(svcpt)));
return hp ? svcpt->scp_nrs_hp : &svcpt->scp_nrs_reg;
}
static inline int nrs_pol2cptid(const struct ptlrpc_nrs_policy *policy)
{
return policy->pol_nrs->nrs_svcpt->scp_cpt;
}
static inline
struct ptlrpc_service *nrs_pol2svc(struct ptlrpc_nrs_policy *policy)
{
return policy->pol_nrs->nrs_svcpt->scp_service;
}
static inline
struct ptlrpc_service_part *nrs_pol2svcpt(struct ptlrpc_nrs_policy *policy)
{
return policy->pol_nrs->nrs_svcpt;
}
static inline
struct cfs_cpt_table *nrs_pol2cptab(struct ptlrpc_nrs_policy *policy)
{
return nrs_pol2svc(policy)->srv_cptable;
}
static inline struct ptlrpc_nrs_resource *
nrs_request_resource(struct ptlrpc_nrs_request *nrq)
{
LASSERT(nrq->nr_initialized);
LASSERT(!nrq->nr_finalized);
return nrq->nr_res_ptrs[nrq->nr_res_idx];
}
static inline
struct ptlrpc_nrs_policy *nrs_request_policy(struct ptlrpc_nrs_request *nrq)
{
return nrs_request_resource(nrq)->res_policy;
}
#define NRS_LPROCFS_QUANTUM_NAME_REG "reg_quantum:"
#define NRS_LPROCFS_QUANTUM_NAME_HP "hp_quantum:"
/**
* the maximum size of nrs_crrn_client::cc_quantum and nrs_orr_data::od_quantum.
*/
#define LPROCFS_NRS_QUANTUM_MAX 65535
/**
* Max valid command string is the size of the labels, plus "65535" twice, plus
* a separating space character.
*/
#define LPROCFS_NRS_WR_QUANTUM_MAX_CMD \
sizeof(NRS_LPROCFS_QUANTUM_NAME_REG __stringify(LPROCFS_NRS_QUANTUM_MAX) " " \
NRS_LPROCFS_QUANTUM_NAME_HP __stringify(LPROCFS_NRS_QUANTUM_MAX))
/* recovd_thread.c */
int ptlrpc_expire_one_request(struct ptlrpc_request *req, int async_unlink);
/* pers.c */
void ptlrpc_fill_bulk_md(lnet_md_t *md, struct ptlrpc_bulk_desc *desc,
int mdcnt);
void ptlrpc_add_bulk_page(struct ptlrpc_bulk_desc *desc, struct page *page,
int pageoffset, int len);
/* pack_generic.c */
struct ptlrpc_reply_state *
lustre_get_emerg_rs(struct ptlrpc_service_part *svcpt);
void lustre_put_emerg_rs(struct ptlrpc_reply_state *rs);
/* pinger.c */
int ptlrpc_start_pinger(void);
int ptlrpc_stop_pinger(void);
void ptlrpc_pinger_sending_on_import(struct obd_import *imp);
void ptlrpc_pinger_commit_expected(struct obd_import *imp);
void ptlrpc_pinger_wake_up(void);
void ptlrpc_ping_import_soon(struct obd_import *imp);
int ping_evictor_wake(struct obd_export *exp);
/* sec_null.c */
int sptlrpc_null_init(void);
void sptlrpc_null_fini(void);
/* sec_plain.c */
int sptlrpc_plain_init(void);
void sptlrpc_plain_fini(void);
/* sec_bulk.c */
int sptlrpc_enc_pool_init(void);
void sptlrpc_enc_pool_fini(void);
int sptlrpc_proc_enc_pool_seq_show(struct seq_file *m, void *v);
/* sec_lproc.c */
int sptlrpc_lproc_init(void);
void sptlrpc_lproc_fini(void);
/* sec_gc.c */
int sptlrpc_gc_init(void);
void sptlrpc_gc_fini(void);
/* sec_config.c */
void sptlrpc_conf_choose_flavor(enum lustre_sec_part from,
enum lustre_sec_part to,
struct obd_uuid *target,
lnet_nid_t nid,
struct sptlrpc_flavor *sf);
int sptlrpc_conf_init(void);
void sptlrpc_conf_fini(void);
/* sec.c */
int sptlrpc_init(void);
void sptlrpc_fini(void);
static inline int ll_rpc_recoverable_error(int rc)
{
return (rc == -ENOTCONN || rc == -ENODEV);
}
static inline int tgt_mod_init(void)
{
return 0;
}
static inline void tgt_mod_exit(void)
{
return;
}
static inline void ptlrpc_reqset_put(struct ptlrpc_request_set *set)
{
if (atomic_dec_and_test(&set->set_refcount))
OBD_FREE_PTR(set);
}
#endif /* PTLRPC_INTERNAL_H */
|