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