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