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