File: | rpc/rpc-lib/src/rpc-clnt.c |
Location: | line 1207, column 25 |
Description: | Value stored to 'recordhdr' during its initialization is never read |
1 | /* |
2 | Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com> |
3 | This file is part of GlusterFS. |
4 | |
5 | This file is licensed to you under your choice of the GNU Lesser |
6 | General Public License, version 3 or any later version (LGPLv3 or |
7 | later), or the GNU General Public License, version 2 (GPLv2), in all |
8 | cases as published by the Free Software Foundation. |
9 | */ |
10 | |
11 | |
12 | #ifndef _CONFIG_H |
13 | #define _CONFIG_H |
14 | #include "config.h" |
15 | #endif |
16 | |
17 | #define RPC_CLNT_DEFAULT_REQUEST_COUNT512 512 |
18 | |
19 | #include "rpc-clnt.h" |
20 | #include "byte-order.h" |
21 | #include "xdr-rpcclnt.h" |
22 | #include "rpc-transport.h" |
23 | #include "protocol-common.h" |
24 | #include "mem-pool.h" |
25 | #include "xdr-rpc.h" |
26 | #include "rpc-common-xdr.h" |
27 | |
28 | void |
29 | rpc_clnt_reply_deinit (struct rpc_req *req, struct mem_pool *pool); |
30 | |
31 | uint64_t |
32 | rpc_clnt_new_callid (struct rpc_clnt *clnt) |
33 | { |
34 | uint64_t callid = 0; |
35 | |
36 | pthread_mutex_lock (&clnt->lock); |
37 | { |
38 | callid = ++clnt->xid; |
39 | } |
40 | pthread_mutex_unlock (&clnt->lock); |
41 | |
42 | return callid; |
43 | } |
44 | |
45 | |
46 | struct saved_frame * |
47 | __saved_frames_get_timedout (struct saved_frames *frames, uint32_t timeout, |
48 | struct timeval *current) |
49 | { |
50 | struct saved_frame *bailout_frame = NULL((void*)0), *tmp = NULL((void*)0); |
51 | |
52 | if (!list_empty(&frames->sf.list)) { |
53 | tmp = list_entry (frames->sf.list.next, typeof (*tmp), list)((typeof (*tmp) *)((char *)(frames->sf.list.next)-(unsigned long)(&((typeof (*tmp) *)0)->list))); |
54 | if ((tmp->saved_at.tv_sec + timeout) < current->tv_sec) { |
55 | bailout_frame = tmp; |
56 | list_del_init (&bailout_frame->list); |
57 | frames->count--; |
58 | } |
59 | } |
60 | |
61 | return bailout_frame; |
62 | } |
63 | |
64 | static int |
65 | _is_lock_fop (struct saved_frame *sframe) |
66 | { |
67 | int fop = 0; |
68 | |
69 | if (SFRAME_GET_PROGNUM (sframe)(sframe->rpcreq->prog->prognum) == GLUSTER_FOP_PROGRAM1298437 && |
70 | SFRAME_GET_PROGVER (sframe)(sframe->rpcreq->prog->progver) == GLUSTER_FOP_VERSION330) |
71 | fop = SFRAME_GET_PROCNUM (sframe)(sframe->rpcreq->procnum); |
72 | |
73 | return ((fop == GFS3_OP_LK) || |
74 | (fop == GFS3_OP_INODELK) || |
75 | (fop == GFS3_OP_FINODELK) || |
76 | (fop == GFS3_OP_ENTRYLK) || |
77 | (fop == GFS3_OP_FENTRYLK)); |
78 | } |
79 | |
80 | struct saved_frame * |
81 | __saved_frames_put (struct saved_frames *frames, void *frame, |
82 | struct rpc_req *rpcreq) |
83 | { |
84 | struct saved_frame *saved_frame = NULL((void*)0); |
85 | |
86 | saved_frame = mem_get (rpcreq->conn->rpc_clnt->saved_frames_pool); |
87 | if (!saved_frame) { |
88 | goto out; |
89 | } |
90 | /* THIS should be saved and set back */ |
91 | |
92 | memset (saved_frame, 0, sizeof (*saved_frame)); |
93 | INIT_LIST_HEAD (&saved_frame->list)do { (&saved_frame->list)->next = (&saved_frame ->list)->prev = &saved_frame->list; } while (0); |
94 | |
95 | saved_frame->capital_this = THIS(*__glusterfs_this_location()); |
96 | saved_frame->frame = frame; |
97 | saved_frame->rpcreq = rpcreq; |
98 | gettimeofday (&saved_frame->saved_at, NULL((void*)0)); |
99 | |
100 | if (_is_lock_fop (saved_frame)) |
101 | list_add_tail (&saved_frame->list, &frames->lk_sf.list); |
102 | else |
103 | list_add_tail (&saved_frame->list, &frames->sf.list); |
104 | |
105 | frames->count++; |
106 | |
107 | out: |
108 | return saved_frame; |
109 | } |
110 | |
111 | |
112 | void |
113 | saved_frames_delete (struct saved_frame *saved_frame, |
114 | rpc_clnt_connection_t *conn) |
115 | { |
116 | GF_VALIDATE_OR_GOTO ("rpc-clnt", saved_frame, out)do { if (!saved_frame) { (*__errno_location ()) = 22; do { do { if (0) printf ("invalid argument: " "saved_frame"); } while (0); _gf_log_callingfn ("rpc-clnt", "rpc-clnt.c", __FUNCTION__ , 116, GF_LOG_ERROR, "invalid argument: " "saved_frame"); } while (0); goto out; } } while (0); |
117 | GF_VALIDATE_OR_GOTO ("rpc-clnt", conn, out)do { if (!conn) { (*__errno_location ()) = 22; do { do { if ( 0) printf ("invalid argument: " "conn"); } while (0); _gf_log_callingfn ("rpc-clnt", "rpc-clnt.c", __FUNCTION__, 117, GF_LOG_ERROR, "invalid argument: " "conn"); } while (0); goto out; } } while (0); |
118 | |
119 | pthread_mutex_lock (&conn->lock); |
120 | { |
121 | list_del_init (&saved_frame->list); |
122 | conn->saved_frames->count--; |
123 | } |
124 | pthread_mutex_unlock (&conn->lock); |
125 | |
126 | if (saved_frame->rpcreq != NULL((void*)0)) { |
127 | rpc_clnt_reply_deinit (saved_frame->rpcreq, |
128 | conn->rpc_clnt->reqpool); |
129 | } |
130 | |
131 | mem_put (saved_frame); |
132 | out: |
133 | return; |
134 | } |
135 | |
136 | |
137 | static void |
138 | call_bail (void *data) |
139 | { |
140 | struct rpc_clnt *clnt = NULL((void*)0); |
141 | rpc_clnt_connection_t *conn = NULL((void*)0); |
142 | struct timeval current; |
143 | struct list_head list; |
144 | struct saved_frame *saved_frame = NULL((void*)0); |
145 | struct saved_frame *trav = NULL((void*)0); |
146 | struct saved_frame *tmp = NULL((void*)0); |
147 | char frame_sent[256] = {0,}; |
148 | struct timeval timeout = {0,}; |
149 | struct iovec iov = {0,}; |
150 | |
151 | GF_VALIDATE_OR_GOTO ("client", data, out)do { if (!data) { (*__errno_location ()) = 22; do { do { if ( 0) printf ("invalid argument: " "data"); } while (0); _gf_log_callingfn ("client", "rpc-clnt.c", __FUNCTION__, 151, GF_LOG_ERROR, "invalid argument: " "data"); } while (0); goto out; } } while (0); |
152 | |
153 | clnt = data; |
154 | |
155 | conn = &clnt->conn; |
156 | |
157 | gettimeofday (¤t, NULL((void*)0)); |
158 | INIT_LIST_HEAD (&list)do { (&list)->next = (&list)->prev = &list; } while (0); |
159 | |
160 | pthread_mutex_lock (&conn->lock); |
161 | { |
162 | /* Chaining to get call-always functionality from |
163 | call-once timer */ |
164 | if (conn->timer) { |
165 | timeout.tv_sec = 10; |
166 | timeout.tv_usec = 0; |
167 | |
168 | gf_timer_call_cancel (clnt->ctx, conn->timer); |
169 | conn->timer = gf_timer_call_after (clnt->ctx, |
170 | timeout, |
171 | call_bail, |
172 | (void *) clnt); |
173 | |
174 | if (conn->timer == NULL((void*)0)) { |
175 | gf_log (conn->trans->name, GF_LOG_WARNING,do { do { if (0) printf ("Cannot create bailout timer"); } while (0); _gf_log (conn->trans->name, "rpc-clnt.c", __FUNCTION__ , 176, GF_LOG_WARNING, "Cannot create bailout timer"); } while (0) |
176 | "Cannot create bailout timer")do { do { if (0) printf ("Cannot create bailout timer"); } while (0); _gf_log (conn->trans->name, "rpc-clnt.c", __FUNCTION__ , 176, GF_LOG_WARNING, "Cannot create bailout timer"); } while (0); |
177 | } |
178 | } |
179 | |
180 | do { |
181 | saved_frame = |
182 | __saved_frames_get_timedout (conn->saved_frames, |
183 | conn->frame_timeout, |
184 | ¤t); |
185 | if (saved_frame) |
186 | list_add (&saved_frame->list, &list); |
187 | |
188 | } while (saved_frame); |
189 | } |
190 | pthread_mutex_unlock (&conn->lock); |
191 | |
192 | list_for_each_entry_safe (trav, tmp, &list, list)for (trav = ((typeof(*trav) *)((char *)((&list)->next) -(unsigned long)(&((typeof(*trav) *)0)->list))), tmp = ((typeof(*trav) *)((char *)(trav->list.next)-(unsigned long )(&((typeof(*trav) *)0)->list))); &trav->list != (&list); trav = tmp, tmp = ((typeof(*tmp) *)((char *)(tmp ->list.next)-(unsigned long)(&((typeof(*tmp) *)0)-> list)))) { |
193 | gf_time_fmt (frame_sent, sizeof frame_sent, |
194 | trav->saved_at.tv_sec, gf_timefmt_FT); |
195 | snprintf (frame_sent + strlen (frame_sent), |
196 | 256 - strlen (frame_sent), |
197 | ".%"GF_PRI_SUSECONDS"06ld", trav->saved_at.tv_usec); |
198 | |
199 | gf_log (conn->trans->name, GF_LOG_ERROR,do { do { if (0) printf ("bailing out frame type(%s) op(%s(%d)) xid = 0x%ux " "sent = %s. timeout = %d", trav->rpcreq->prog->progname , (trav->rpcreq->prog->procnames) ? trav->rpcreq-> prog->procnames[trav->rpcreq->procnum] : "--", trav-> rpcreq->procnum, trav->rpcreq->xid, frame_sent, conn ->frame_timeout); } while (0); _gf_log (conn->trans-> name, "rpc-clnt.c", __FUNCTION__, 207, GF_LOG_ERROR, "bailing out frame type(%s) op(%s(%d)) xid = 0x%ux " "sent = %s. timeout = %d", trav->rpcreq->prog->progname , (trav->rpcreq->prog->procnames) ? trav->rpcreq-> prog->procnames[trav->rpcreq->procnum] : "--", trav-> rpcreq->procnum, trav->rpcreq->xid, frame_sent, conn ->frame_timeout); } while (0) |
200 | "bailing out frame type(%s) op(%s(%d)) xid = 0x%ux "do { do { if (0) printf ("bailing out frame type(%s) op(%s(%d)) xid = 0x%ux " "sent = %s. timeout = %d", trav->rpcreq->prog->progname , (trav->rpcreq->prog->procnames) ? trav->rpcreq-> prog->procnames[trav->rpcreq->procnum] : "--", trav-> rpcreq->procnum, trav->rpcreq->xid, frame_sent, conn ->frame_timeout); } while (0); _gf_log (conn->trans-> name, "rpc-clnt.c", __FUNCTION__, 207, GF_LOG_ERROR, "bailing out frame type(%s) op(%s(%d)) xid = 0x%ux " "sent = %s. timeout = %d", trav->rpcreq->prog->progname , (trav->rpcreq->prog->procnames) ? trav->rpcreq-> prog->procnames[trav->rpcreq->procnum] : "--", trav-> rpcreq->procnum, trav->rpcreq->xid, frame_sent, conn ->frame_timeout); } while (0) |
201 | "sent = %s. timeout = %d",do { do { if (0) printf ("bailing out frame type(%s) op(%s(%d)) xid = 0x%ux " "sent = %s. timeout = %d", trav->rpcreq->prog->progname , (trav->rpcreq->prog->procnames) ? trav->rpcreq-> prog->procnames[trav->rpcreq->procnum] : "--", trav-> rpcreq->procnum, trav->rpcreq->xid, frame_sent, conn ->frame_timeout); } while (0); _gf_log (conn->trans-> name, "rpc-clnt.c", __FUNCTION__, 207, GF_LOG_ERROR, "bailing out frame type(%s) op(%s(%d)) xid = 0x%ux " "sent = %s. timeout = %d", trav->rpcreq->prog->progname , (trav->rpcreq->prog->procnames) ? trav->rpcreq-> prog->procnames[trav->rpcreq->procnum] : "--", trav-> rpcreq->procnum, trav->rpcreq->xid, frame_sent, conn ->frame_timeout); } while (0) |
202 | trav->rpcreq->prog->progname,do { do { if (0) printf ("bailing out frame type(%s) op(%s(%d)) xid = 0x%ux " "sent = %s. timeout = %d", trav->rpcreq->prog->progname , (trav->rpcreq->prog->procnames) ? trav->rpcreq-> prog->procnames[trav->rpcreq->procnum] : "--", trav-> rpcreq->procnum, trav->rpcreq->xid, frame_sent, conn ->frame_timeout); } while (0); _gf_log (conn->trans-> name, "rpc-clnt.c", __FUNCTION__, 207, GF_LOG_ERROR, "bailing out frame type(%s) op(%s(%d)) xid = 0x%ux " "sent = %s. timeout = %d", trav->rpcreq->prog->progname , (trav->rpcreq->prog->procnames) ? trav->rpcreq-> prog->procnames[trav->rpcreq->procnum] : "--", trav-> rpcreq->procnum, trav->rpcreq->xid, frame_sent, conn ->frame_timeout); } while (0) |
203 | (trav->rpcreq->prog->procnames) ?do { do { if (0) printf ("bailing out frame type(%s) op(%s(%d)) xid = 0x%ux " "sent = %s. timeout = %d", trav->rpcreq->prog->progname , (trav->rpcreq->prog->procnames) ? trav->rpcreq-> prog->procnames[trav->rpcreq->procnum] : "--", trav-> rpcreq->procnum, trav->rpcreq->xid, frame_sent, conn ->frame_timeout); } while (0); _gf_log (conn->trans-> name, "rpc-clnt.c", __FUNCTION__, 207, GF_LOG_ERROR, "bailing out frame type(%s) op(%s(%d)) xid = 0x%ux " "sent = %s. timeout = %d", trav->rpcreq->prog->progname , (trav->rpcreq->prog->procnames) ? trav->rpcreq-> prog->procnames[trav->rpcreq->procnum] : "--", trav-> rpcreq->procnum, trav->rpcreq->xid, frame_sent, conn ->frame_timeout); } while (0) |
204 | trav->rpcreq->prog->procnames[trav->rpcreq->procnum] :do { do { if (0) printf ("bailing out frame type(%s) op(%s(%d)) xid = 0x%ux " "sent = %s. timeout = %d", trav->rpcreq->prog->progname , (trav->rpcreq->prog->procnames) ? trav->rpcreq-> prog->procnames[trav->rpcreq->procnum] : "--", trav-> rpcreq->procnum, trav->rpcreq->xid, frame_sent, conn ->frame_timeout); } while (0); _gf_log (conn->trans-> name, "rpc-clnt.c", __FUNCTION__, 207, GF_LOG_ERROR, "bailing out frame type(%s) op(%s(%d)) xid = 0x%ux " "sent = %s. timeout = %d", trav->rpcreq->prog->progname , (trav->rpcreq->prog->procnames) ? trav->rpcreq-> prog->procnames[trav->rpcreq->procnum] : "--", trav-> rpcreq->procnum, trav->rpcreq->xid, frame_sent, conn ->frame_timeout); } while (0) |
205 | "--",do { do { if (0) printf ("bailing out frame type(%s) op(%s(%d)) xid = 0x%ux " "sent = %s. timeout = %d", trav->rpcreq->prog->progname , (trav->rpcreq->prog->procnames) ? trav->rpcreq-> prog->procnames[trav->rpcreq->procnum] : "--", trav-> rpcreq->procnum, trav->rpcreq->xid, frame_sent, conn ->frame_timeout); } while (0); _gf_log (conn->trans-> name, "rpc-clnt.c", __FUNCTION__, 207, GF_LOG_ERROR, "bailing out frame type(%s) op(%s(%d)) xid = 0x%ux " "sent = %s. timeout = %d", trav->rpcreq->prog->progname , (trav->rpcreq->prog->procnames) ? trav->rpcreq-> prog->procnames[trav->rpcreq->procnum] : "--", trav-> rpcreq->procnum, trav->rpcreq->xid, frame_sent, conn ->frame_timeout); } while (0) |
206 | trav->rpcreq->procnum, trav->rpcreq->xid, frame_sent,do { do { if (0) printf ("bailing out frame type(%s) op(%s(%d)) xid = 0x%ux " "sent = %s. timeout = %d", trav->rpcreq->prog->progname , (trav->rpcreq->prog->procnames) ? trav->rpcreq-> prog->procnames[trav->rpcreq->procnum] : "--", trav-> rpcreq->procnum, trav->rpcreq->xid, frame_sent, conn ->frame_timeout); } while (0); _gf_log (conn->trans-> name, "rpc-clnt.c", __FUNCTION__, 207, GF_LOG_ERROR, "bailing out frame type(%s) op(%s(%d)) xid = 0x%ux " "sent = %s. timeout = %d", trav->rpcreq->prog->progname , (trav->rpcreq->prog->procnames) ? trav->rpcreq-> prog->procnames[trav->rpcreq->procnum] : "--", trav-> rpcreq->procnum, trav->rpcreq->xid, frame_sent, conn ->frame_timeout); } while (0) |
207 | conn->frame_timeout)do { do { if (0) printf ("bailing out frame type(%s) op(%s(%d)) xid = 0x%ux " "sent = %s. timeout = %d", trav->rpcreq->prog->progname , (trav->rpcreq->prog->procnames) ? trav->rpcreq-> prog->procnames[trav->rpcreq->procnum] : "--", trav-> rpcreq->procnum, trav->rpcreq->xid, frame_sent, conn ->frame_timeout); } while (0); _gf_log (conn->trans-> name, "rpc-clnt.c", __FUNCTION__, 207, GF_LOG_ERROR, "bailing out frame type(%s) op(%s(%d)) xid = 0x%ux " "sent = %s. timeout = %d", trav->rpcreq->prog->progname , (trav->rpcreq->prog->procnames) ? trav->rpcreq-> prog->procnames[trav->rpcreq->procnum] : "--", trav-> rpcreq->procnum, trav->rpcreq->xid, frame_sent, conn ->frame_timeout); } while (0); |
208 | |
209 | clnt = rpc_clnt_ref (clnt); |
210 | trav->rpcreq->rpc_status = -1; |
211 | trav->rpcreq->cbkfn (trav->rpcreq, &iov, 1, trav->frame); |
212 | |
213 | rpc_clnt_reply_deinit (trav->rpcreq, clnt->reqpool); |
214 | clnt = rpc_clnt_unref (clnt); |
215 | list_del_init (&trav->list); |
216 | mem_put (trav); |
217 | } |
218 | out: |
219 | return; |
220 | } |
221 | |
222 | |
223 | /* to be called with conn->lock held */ |
224 | struct saved_frame * |
225 | __save_frame (struct rpc_clnt *rpc_clnt, call_frame_t *frame, |
226 | struct rpc_req *rpcreq) |
227 | { |
228 | rpc_clnt_connection_t *conn = NULL((void*)0); |
229 | struct timeval timeout = {0, }; |
230 | struct saved_frame *saved_frame = NULL((void*)0); |
231 | |
232 | conn = &rpc_clnt->conn; |
233 | |
234 | saved_frame = __saved_frames_put (conn->saved_frames, frame, rpcreq); |
235 | |
236 | if (saved_frame == NULL((void*)0)) { |
237 | goto out; |
238 | } |
239 | |
240 | /* TODO: make timeout configurable */ |
241 | if (conn->timer == NULL((void*)0)) { |
242 | timeout.tv_sec = 10; |
243 | timeout.tv_usec = 0; |
244 | conn->timer = gf_timer_call_after (rpc_clnt->ctx, |
245 | timeout, |
246 | call_bail, |
247 | (void *) rpc_clnt); |
248 | } |
249 | |
250 | out: |
251 | return saved_frame; |
252 | } |
253 | |
254 | |
255 | struct saved_frames * |
256 | saved_frames_new (void) |
257 | { |
258 | struct saved_frames *saved_frames = NULL((void*)0); |
259 | |
260 | saved_frames = GF_CALLOC (1, sizeof (*saved_frames),__gf_calloc (1, sizeof (*saved_frames), gf_common_mt_rpcclnt_savedframe_t ) |
261 | gf_common_mt_rpcclnt_savedframe_t)__gf_calloc (1, sizeof (*saved_frames), gf_common_mt_rpcclnt_savedframe_t ); |
262 | if (!saved_frames) { |
263 | return NULL((void*)0); |
264 | } |
265 | |
266 | INIT_LIST_HEAD (&saved_frames->sf.list)do { (&saved_frames->sf.list)->next = (&saved_frames ->sf.list)->prev = &saved_frames->sf.list; } while (0); |
267 | INIT_LIST_HEAD (&saved_frames->lk_sf.list)do { (&saved_frames->lk_sf.list)->next = (&saved_frames ->lk_sf.list)->prev = &saved_frames->lk_sf.list; } while (0); |
268 | |
269 | return saved_frames; |
270 | } |
271 | |
272 | |
273 | int |
274 | __saved_frame_copy (struct saved_frames *frames, int64_t callid, |
275 | struct saved_frame *saved_frame) |
276 | { |
277 | struct saved_frame *tmp = NULL((void*)0); |
278 | int ret = -1; |
279 | |
280 | if (!saved_frame) { |
281 | ret = 0; |
282 | goto out; |
283 | } |
284 | |
285 | list_for_each_entry (tmp, &frames->sf.list, list)for (tmp = ((typeof(*tmp) *)((char *)((&frames->sf.list )->next)-(unsigned long)(&((typeof(*tmp) *)0)->list ))); &tmp->list != (&frames->sf.list); tmp = (( typeof(*tmp) *)((char *)(tmp->list.next)-(unsigned long)(& ((typeof(*tmp) *)0)->list)))) { |
286 | if (tmp->rpcreq->xid == callid) { |
287 | *saved_frame = *tmp; |
288 | ret = 0; |
289 | goto out; |
290 | } |
291 | } |
292 | |
293 | list_for_each_entry (tmp, &frames->lk_sf.list, list)for (tmp = ((typeof(*tmp) *)((char *)((&frames->lk_sf. list)->next)-(unsigned long)(&((typeof(*tmp) *)0)-> list))); &tmp->list != (&frames->lk_sf.list); tmp = ((typeof(*tmp) *)((char *)(tmp->list.next)-(unsigned long )(&((typeof(*tmp) *)0)->list)))) { |
294 | if (tmp->rpcreq->xid == callid) { |
295 | *saved_frame = *tmp; |
296 | ret = 0; |
297 | goto out; |
298 | } |
299 | } |
300 | |
301 | out: |
302 | return ret; |
303 | } |
304 | |
305 | |
306 | struct saved_frame * |
307 | __saved_frame_get (struct saved_frames *frames, int64_t callid) |
308 | { |
309 | struct saved_frame *saved_frame = NULL((void*)0); |
310 | struct saved_frame *tmp = NULL((void*)0); |
311 | |
312 | list_for_each_entry (tmp, &frames->sf.list, list)for (tmp = ((typeof(*tmp) *)((char *)((&frames->sf.list )->next)-(unsigned long)(&((typeof(*tmp) *)0)->list ))); &tmp->list != (&frames->sf.list); tmp = (( typeof(*tmp) *)((char *)(tmp->list.next)-(unsigned long)(& ((typeof(*tmp) *)0)->list)))) { |
313 | if (tmp->rpcreq->xid == callid) { |
314 | list_del_init (&tmp->list); |
315 | frames->count--; |
316 | saved_frame = tmp; |
317 | goto out; |
318 | } |
319 | } |
320 | |
321 | list_for_each_entry (tmp, &frames->lk_sf.list, list)for (tmp = ((typeof(*tmp) *)((char *)((&frames->lk_sf. list)->next)-(unsigned long)(&((typeof(*tmp) *)0)-> list))); &tmp->list != (&frames->lk_sf.list); tmp = ((typeof(*tmp) *)((char *)(tmp->list.next)-(unsigned long )(&((typeof(*tmp) *)0)->list)))) { |
322 | if (tmp->rpcreq->xid == callid) { |
323 | list_del_init (&tmp->list); |
324 | frames->count--; |
325 | saved_frame = tmp; |
326 | goto out; |
327 | } |
328 | } |
329 | |
330 | out: |
331 | if (saved_frame) { |
332 | THIS(*__glusterfs_this_location()) = saved_frame->capital_this; |
333 | } |
334 | |
335 | return saved_frame; |
336 | } |
337 | |
338 | |
339 | void |
340 | saved_frames_unwind (struct saved_frames *saved_frames) |
341 | { |
342 | struct saved_frame *trav = NULL((void*)0); |
343 | struct saved_frame *tmp = NULL((void*)0); |
344 | char timestr[1024] = {0,}; |
345 | struct iovec iov = {0,}; |
346 | |
347 | list_splice_init (&saved_frames->lk_sf.list, &saved_frames->sf.list); |
348 | |
349 | list_for_each_entry_safe (trav, tmp, &saved_frames->sf.list, list)for (trav = ((typeof(*trav) *)((char *)((&saved_frames-> sf.list)->next)-(unsigned long)(&((typeof(*trav) *)0)-> list))), tmp = ((typeof(*trav) *)((char *)(trav->list.next )-(unsigned long)(&((typeof(*trav) *)0)->list))); & trav->list != (&saved_frames->sf.list); trav = tmp, tmp = ((typeof(*tmp) *)((char *)(tmp->list.next)-(unsigned long)(&((typeof(*tmp) *)0)->list)))) { |
350 | gf_time_fmt (timestr, sizeof timestr, |
351 | trav->saved_at.tv_sec, gf_timefmt_FT); |
352 | snprintf (timestr + strlen (timestr), |
353 | sizeof(timestr) - strlen (timestr), |
354 | ".%"GF_PRI_SUSECONDS"06ld", trav->saved_at.tv_usec); |
355 | |
356 | if (!trav->rpcreq || !trav->rpcreq->prog) |
357 | continue; |
358 | |
359 | gf_log_callingfn (trav->rpcreq->conn->trans->name,do { do { if (0) printf ("forced unwinding frame type(%s) op(%s(%d)) " "called at %s (xid=0x%ux)", trav->rpcreq->prog->progname , ((trav->rpcreq->prog->procnames) ? trav->rpcreq ->prog->procnames[trav->rpcreq->procnum] : "--"), trav->rpcreq->procnum, timestr, trav->rpcreq->xid ); } while (0); _gf_log_callingfn (trav->rpcreq->conn-> trans->name, "rpc-clnt.c", __FUNCTION__, 368, GF_LOG_ERROR , "forced unwinding frame type(%s) op(%s(%d)) " "called at %s (xid=0x%ux)" , trav->rpcreq->prog->progname, ((trav->rpcreq-> prog->procnames) ? trav->rpcreq->prog->procnames[ trav->rpcreq->procnum] : "--"), trav->rpcreq->procnum , timestr, trav->rpcreq->xid); } while (0) |
360 | GF_LOG_ERROR,do { do { if (0) printf ("forced unwinding frame type(%s) op(%s(%d)) " "called at %s (xid=0x%ux)", trav->rpcreq->prog->progname , ((trav->rpcreq->prog->procnames) ? trav->rpcreq ->prog->procnames[trav->rpcreq->procnum] : "--"), trav->rpcreq->procnum, timestr, trav->rpcreq->xid ); } while (0); _gf_log_callingfn (trav->rpcreq->conn-> trans->name, "rpc-clnt.c", __FUNCTION__, 368, GF_LOG_ERROR , "forced unwinding frame type(%s) op(%s(%d)) " "called at %s (xid=0x%ux)" , trav->rpcreq->prog->progname, ((trav->rpcreq-> prog->procnames) ? trav->rpcreq->prog->procnames[ trav->rpcreq->procnum] : "--"), trav->rpcreq->procnum , timestr, trav->rpcreq->xid); } while (0) |
361 | "forced unwinding frame type(%s) op(%s(%d)) "do { do { if (0) printf ("forced unwinding frame type(%s) op(%s(%d)) " "called at %s (xid=0x%ux)", trav->rpcreq->prog->progname , ((trav->rpcreq->prog->procnames) ? trav->rpcreq ->prog->procnames[trav->rpcreq->procnum] : "--"), trav->rpcreq->procnum, timestr, trav->rpcreq->xid ); } while (0); _gf_log_callingfn (trav->rpcreq->conn-> trans->name, "rpc-clnt.c", __FUNCTION__, 368, GF_LOG_ERROR , "forced unwinding frame type(%s) op(%s(%d)) " "called at %s (xid=0x%ux)" , trav->rpcreq->prog->progname, ((trav->rpcreq-> prog->procnames) ? trav->rpcreq->prog->procnames[ trav->rpcreq->procnum] : "--"), trav->rpcreq->procnum , timestr, trav->rpcreq->xid); } while (0) |
362 | "called at %s (xid=0x%ux)",do { do { if (0) printf ("forced unwinding frame type(%s) op(%s(%d)) " "called at %s (xid=0x%ux)", trav->rpcreq->prog->progname , ((trav->rpcreq->prog->procnames) ? trav->rpcreq ->prog->procnames[trav->rpcreq->procnum] : "--"), trav->rpcreq->procnum, timestr, trav->rpcreq->xid ); } while (0); _gf_log_callingfn (trav->rpcreq->conn-> trans->name, "rpc-clnt.c", __FUNCTION__, 368, GF_LOG_ERROR , "forced unwinding frame type(%s) op(%s(%d)) " "called at %s (xid=0x%ux)" , trav->rpcreq->prog->progname, ((trav->rpcreq-> prog->procnames) ? trav->rpcreq->prog->procnames[ trav->rpcreq->procnum] : "--"), trav->rpcreq->procnum , timestr, trav->rpcreq->xid); } while (0) |
363 | trav->rpcreq->prog->progname,do { do { if (0) printf ("forced unwinding frame type(%s) op(%s(%d)) " "called at %s (xid=0x%ux)", trav->rpcreq->prog->progname , ((trav->rpcreq->prog->procnames) ? trav->rpcreq ->prog->procnames[trav->rpcreq->procnum] : "--"), trav->rpcreq->procnum, timestr, trav->rpcreq->xid ); } while (0); _gf_log_callingfn (trav->rpcreq->conn-> trans->name, "rpc-clnt.c", __FUNCTION__, 368, GF_LOG_ERROR , "forced unwinding frame type(%s) op(%s(%d)) " "called at %s (xid=0x%ux)" , trav->rpcreq->prog->progname, ((trav->rpcreq-> prog->procnames) ? trav->rpcreq->prog->procnames[ trav->rpcreq->procnum] : "--"), trav->rpcreq->procnum , timestr, trav->rpcreq->xid); } while (0) |
364 | ((trav->rpcreq->prog->procnames) ?do { do { if (0) printf ("forced unwinding frame type(%s) op(%s(%d)) " "called at %s (xid=0x%ux)", trav->rpcreq->prog->progname , ((trav->rpcreq->prog->procnames) ? trav->rpcreq ->prog->procnames[trav->rpcreq->procnum] : "--"), trav->rpcreq->procnum, timestr, trav->rpcreq->xid ); } while (0); _gf_log_callingfn (trav->rpcreq->conn-> trans->name, "rpc-clnt.c", __FUNCTION__, 368, GF_LOG_ERROR , "forced unwinding frame type(%s) op(%s(%d)) " "called at %s (xid=0x%ux)" , trav->rpcreq->prog->progname, ((trav->rpcreq-> prog->procnames) ? trav->rpcreq->prog->procnames[ trav->rpcreq->procnum] : "--"), trav->rpcreq->procnum , timestr, trav->rpcreq->xid); } while (0) |
365 | trav->rpcreq->prog->procnames[trav->rpcreq->procnum]do { do { if (0) printf ("forced unwinding frame type(%s) op(%s(%d)) " "called at %s (xid=0x%ux)", trav->rpcreq->prog->progname , ((trav->rpcreq->prog->procnames) ? trav->rpcreq ->prog->procnames[trav->rpcreq->procnum] : "--"), trav->rpcreq->procnum, timestr, trav->rpcreq->xid ); } while (0); _gf_log_callingfn (trav->rpcreq->conn-> trans->name, "rpc-clnt.c", __FUNCTION__, 368, GF_LOG_ERROR , "forced unwinding frame type(%s) op(%s(%d)) " "called at %s (xid=0x%ux)" , trav->rpcreq->prog->progname, ((trav->rpcreq-> prog->procnames) ? trav->rpcreq->prog->procnames[ trav->rpcreq->procnum] : "--"), trav->rpcreq->procnum , timestr, trav->rpcreq->xid); } while (0) |
366 | : "--"),do { do { if (0) printf ("forced unwinding frame type(%s) op(%s(%d)) " "called at %s (xid=0x%ux)", trav->rpcreq->prog->progname , ((trav->rpcreq->prog->procnames) ? trav->rpcreq ->prog->procnames[trav->rpcreq->procnum] : "--"), trav->rpcreq->procnum, timestr, trav->rpcreq->xid ); } while (0); _gf_log_callingfn (trav->rpcreq->conn-> trans->name, "rpc-clnt.c", __FUNCTION__, 368, GF_LOG_ERROR , "forced unwinding frame type(%s) op(%s(%d)) " "called at %s (xid=0x%ux)" , trav->rpcreq->prog->progname, ((trav->rpcreq-> prog->procnames) ? trav->rpcreq->prog->procnames[ trav->rpcreq->procnum] : "--"), trav->rpcreq->procnum , timestr, trav->rpcreq->xid); } while (0) |
367 | trav->rpcreq->procnum, timestr,do { do { if (0) printf ("forced unwinding frame type(%s) op(%s(%d)) " "called at %s (xid=0x%ux)", trav->rpcreq->prog->progname , ((trav->rpcreq->prog->procnames) ? trav->rpcreq ->prog->procnames[trav->rpcreq->procnum] : "--"), trav->rpcreq->procnum, timestr, trav->rpcreq->xid ); } while (0); _gf_log_callingfn (trav->rpcreq->conn-> trans->name, "rpc-clnt.c", __FUNCTION__, 368, GF_LOG_ERROR , "forced unwinding frame type(%s) op(%s(%d)) " "called at %s (xid=0x%ux)" , trav->rpcreq->prog->progname, ((trav->rpcreq-> prog->procnames) ? trav->rpcreq->prog->procnames[ trav->rpcreq->procnum] : "--"), trav->rpcreq->procnum , timestr, trav->rpcreq->xid); } while (0) |
368 | trav->rpcreq->xid)do { do { if (0) printf ("forced unwinding frame type(%s) op(%s(%d)) " "called at %s (xid=0x%ux)", trav->rpcreq->prog->progname , ((trav->rpcreq->prog->procnames) ? trav->rpcreq ->prog->procnames[trav->rpcreq->procnum] : "--"), trav->rpcreq->procnum, timestr, trav->rpcreq->xid ); } while (0); _gf_log_callingfn (trav->rpcreq->conn-> trans->name, "rpc-clnt.c", __FUNCTION__, 368, GF_LOG_ERROR , "forced unwinding frame type(%s) op(%s(%d)) " "called at %s (xid=0x%ux)" , trav->rpcreq->prog->progname, ((trav->rpcreq-> prog->procnames) ? trav->rpcreq->prog->procnames[ trav->rpcreq->procnum] : "--"), trav->rpcreq->procnum , timestr, trav->rpcreq->xid); } while (0); |
369 | saved_frames->count--; |
370 | |
371 | trav->rpcreq->rpc_status = -1; |
372 | trav->rpcreq->cbkfn (trav->rpcreq, &iov, 1, trav->frame); |
373 | |
374 | rpc_clnt_reply_deinit (trav->rpcreq, |
375 | trav->rpcreq->conn->rpc_clnt->reqpool); |
376 | |
377 | list_del_init (&trav->list); |
378 | mem_put (trav); |
379 | } |
380 | } |
381 | |
382 | |
383 | void |
384 | saved_frames_destroy (struct saved_frames *frames) |
385 | { |
386 | if (!frames) |
387 | return; |
388 | |
389 | saved_frames_unwind (frames); |
390 | |
391 | GF_FREE (frames)__gf_free (frames); |
392 | } |
393 | |
394 | |
395 | void |
396 | rpc_clnt_reconnect (void *trans_ptr) |
397 | { |
398 | rpc_transport_t *trans = NULL((void*)0); |
399 | rpc_clnt_connection_t *conn = NULL((void*)0); |
400 | struct timeval tv = {0, 0}; |
401 | int32_t ret = 0; |
402 | struct rpc_clnt *clnt = NULL((void*)0); |
403 | |
404 | trans = trans_ptr; |
405 | if (!trans || !trans->mydata) |
406 | return; |
407 | |
408 | conn = trans->mydata; |
409 | clnt = conn->rpc_clnt; |
410 | |
411 | pthread_mutex_lock (&conn->lock); |
412 | { |
413 | if (conn->reconnect) |
414 | gf_timer_call_cancel (clnt->ctx, |
415 | conn->reconnect); |
416 | conn->reconnect = 0; |
417 | |
418 | if (conn->connected == 0) { |
419 | tv.tv_sec = 3; |
420 | |
421 | gf_log (trans->name, GF_LOG_TRACE,do { do { if (0) printf ("attempting reconnect"); } while (0) ; _gf_log (trans->name, "rpc-clnt.c", __FUNCTION__, 422, GF_LOG_TRACE , "attempting reconnect"); } while (0) |
422 | "attempting reconnect")do { do { if (0) printf ("attempting reconnect"); } while (0) ; _gf_log (trans->name, "rpc-clnt.c", __FUNCTION__, 422, GF_LOG_TRACE , "attempting reconnect"); } while (0); |
423 | ret = rpc_transport_connect (trans, |
424 | conn->config.remote_port); |
425 | conn->reconnect = |
426 | gf_timer_call_after (clnt->ctx, tv, |
427 | rpc_clnt_reconnect, |
428 | trans); |
429 | } else { |
430 | gf_log (trans->name, GF_LOG_TRACE,do { do { if (0) printf ("breaking reconnect chain"); } while (0); _gf_log (trans->name, "rpc-clnt.c", __FUNCTION__, 431 , GF_LOG_TRACE, "breaking reconnect chain"); } while (0) |
431 | "breaking reconnect chain")do { do { if (0) printf ("breaking reconnect chain"); } while (0); _gf_log (trans->name, "rpc-clnt.c", __FUNCTION__, 431 , GF_LOG_TRACE, "breaking reconnect chain"); } while (0); |
432 | } |
433 | } |
434 | pthread_mutex_unlock (&conn->lock); |
435 | |
436 | if ((ret == -1) && (errno(*__errno_location ()) != EINPROGRESS115) && (clnt->notifyfn)) { |
437 | clnt->notifyfn (clnt, clnt->mydata, RPC_CLNT_DISCONNECT, NULL((void*)0)); |
438 | } |
439 | |
440 | return; |
441 | } |
442 | |
443 | |
444 | int |
445 | rpc_clnt_fill_request_info (struct rpc_clnt *clnt, rpc_request_info_t *info) |
446 | { |
447 | struct saved_frame saved_frame; |
448 | int ret = -1; |
449 | |
450 | pthread_mutex_lock (&clnt->conn.lock); |
451 | { |
452 | ret = __saved_frame_copy (clnt->conn.saved_frames, info->xid, |
453 | &saved_frame); |
454 | } |
455 | pthread_mutex_unlock (&clnt->conn.lock); |
456 | |
457 | if (ret == -1) { |
458 | gf_log (clnt->conn.trans->name, GF_LOG_CRITICAL,do { do { if (0) printf ("cannot lookup the saved " "frame corresponding to xid (%d)" , info->xid); } while (0); _gf_log (clnt->conn.trans-> name, "rpc-clnt.c", __FUNCTION__, 460, GF_LOG_CRITICAL, "cannot lookup the saved " "frame corresponding to xid (%d)", info->xid); } while (0 ) |
459 | "cannot lookup the saved "do { do { if (0) printf ("cannot lookup the saved " "frame corresponding to xid (%d)" , info->xid); } while (0); _gf_log (clnt->conn.trans-> name, "rpc-clnt.c", __FUNCTION__, 460, GF_LOG_CRITICAL, "cannot lookup the saved " "frame corresponding to xid (%d)", info->xid); } while (0 ) |
460 | "frame corresponding to xid (%d)", info->xid)do { do { if (0) printf ("cannot lookup the saved " "frame corresponding to xid (%d)" , info->xid); } while (0); _gf_log (clnt->conn.trans-> name, "rpc-clnt.c", __FUNCTION__, 460, GF_LOG_CRITICAL, "cannot lookup the saved " "frame corresponding to xid (%d)", info->xid); } while (0 ); |
461 | goto out; |
462 | } |
463 | |
464 | info->prognum = saved_frame.rpcreq->prog->prognum; |
465 | info->procnum = saved_frame.rpcreq->procnum; |
466 | info->progver = saved_frame.rpcreq->prog->progver; |
467 | info->rpc_req = saved_frame.rpcreq; |
468 | info->rsp = saved_frame.rsp; |
469 | |
470 | ret = 0; |
471 | out: |
472 | return ret; |
473 | } |
474 | |
475 | int |
476 | rpc_clnt_reconnect_cleanup (rpc_clnt_connection_t *conn) |
477 | { |
478 | struct rpc_clnt *clnt = NULL((void*)0); |
479 | |
480 | if (!conn) { |
481 | goto out; |
482 | } |
483 | |
484 | clnt = conn->rpc_clnt; |
485 | |
486 | pthread_mutex_lock (&conn->lock); |
487 | { |
488 | |
489 | if (conn->reconnect) { |
490 | gf_timer_call_cancel (clnt->ctx, conn->reconnect); |
491 | conn->reconnect = NULL((void*)0); |
492 | } |
493 | |
494 | } |
495 | pthread_mutex_unlock (&conn->lock); |
496 | |
497 | out: |
498 | return 0; |
499 | } |
500 | |
501 | /* |
502 | * client_protocol_cleanup - cleanup function |
503 | * @trans: transport object |
504 | * |
505 | */ |
506 | int |
507 | rpc_clnt_connection_cleanup (rpc_clnt_connection_t *conn) |
508 | { |
509 | struct saved_frames *saved_frames = NULL((void*)0); |
510 | struct rpc_clnt *clnt = NULL((void*)0); |
511 | |
512 | if (!conn) { |
513 | goto out; |
514 | } |
515 | |
516 | clnt = conn->rpc_clnt; |
517 | |
518 | gf_log (conn->trans->name, GF_LOG_TRACE,do { do { if (0) printf ("cleaning up state in transport object %p" , conn->trans); } while (0); _gf_log (conn->trans->name , "rpc-clnt.c", __FUNCTION__, 519, GF_LOG_TRACE, "cleaning up state in transport object %p" , conn->trans); } while (0) |
519 | "cleaning up state in transport object %p", conn->trans)do { do { if (0) printf ("cleaning up state in transport object %p" , conn->trans); } while (0); _gf_log (conn->trans->name , "rpc-clnt.c", __FUNCTION__, 519, GF_LOG_TRACE, "cleaning up state in transport object %p" , conn->trans); } while (0); |
520 | |
521 | pthread_mutex_lock (&conn->lock); |
522 | { |
523 | saved_frames = conn->saved_frames; |
524 | conn->saved_frames = saved_frames_new (); |
525 | |
526 | /* bailout logic cleanup */ |
527 | if (conn->timer) { |
528 | gf_timer_call_cancel (clnt->ctx, conn->timer); |
529 | conn->timer = NULL((void*)0); |
530 | } |
531 | |
532 | conn->connected = 0; |
533 | |
534 | if (conn->ping_timer) { |
535 | gf_timer_call_cancel (clnt->ctx, conn->ping_timer); |
536 | conn->ping_timer = NULL((void*)0); |
537 | conn->ping_started = 0; |
538 | } |
539 | } |
540 | pthread_mutex_unlock (&conn->lock); |
541 | |
542 | saved_frames_destroy (saved_frames); |
543 | |
544 | out: |
545 | return 0; |
546 | } |
547 | |
548 | /* |
549 | * lookup_frame - lookup call frame corresponding to a given callid |
550 | * @trans: transport object |
551 | * @callid: call id of the frame |
552 | * |
553 | * not for external reference |
554 | */ |
555 | |
556 | static struct saved_frame * |
557 | lookup_frame (rpc_clnt_connection_t *conn, int64_t callid) |
558 | { |
559 | struct saved_frame *frame = NULL((void*)0); |
560 | |
561 | pthread_mutex_lock (&conn->lock); |
562 | { |
563 | frame = __saved_frame_get (conn->saved_frames, callid); |
564 | } |
565 | pthread_mutex_unlock (&conn->lock); |
566 | |
567 | return frame; |
568 | } |
569 | |
570 | |
571 | int |
572 | rpc_clnt_reply_fill (rpc_transport_pollin_t *msg, |
573 | rpc_clnt_connection_t *conn, |
574 | struct rpc_msg *replymsg, struct iovec progmsg, |
575 | struct rpc_req *req, |
576 | struct saved_frame *saved_frame) |
577 | { |
578 | int ret = -1; |
579 | |
580 | if ((!conn) || (!replymsg)|| (!req) || (!saved_frame) || (!msg)) { |
581 | goto out; |
582 | } |
583 | |
584 | req->rpc_status = 0; |
585 | if ((rpc_reply_status (replymsg)((replymsg)->ru.RM_rmb.rp_stat) == MSG_DENIED) |
586 | || (rpc_accepted_reply_status (replymsg)((replymsg)->ru.RM_rmb.ru.RP_ar.ar_stat) != SUCCESS)) { |
587 | req->rpc_status = -1; |
588 | } |
589 | |
590 | req->rsp[0] = progmsg; |
591 | req->rsp_iobref = iobref_ref (msg->iobref); |
592 | |
593 | if (msg->vectored) { |
594 | req->rsp[1] = msg->vector[1]; |
595 | req->rspcnt = 2; |
596 | } else { |
597 | req->rspcnt = 1; |
598 | } |
599 | |
600 | /* By this time, the data bytes for the auth scheme would have already |
601 | * been copied into the required sections of the req structure, |
602 | * we just need to fill in the meta-data about it now. |
603 | */ |
604 | if (req->rpc_status == 0) { |
605 | /* |
606 | * req->verf.flavour = rpc_reply_verf_flavour (replymsg); |
607 | * req->verf.datalen = rpc_reply_verf_len (replymsg); |
608 | */ |
609 | } |
610 | |
611 | ret = 0; |
612 | |
613 | out: |
614 | return ret; |
615 | } |
616 | |
617 | |
618 | void |
619 | rpc_clnt_reply_deinit (struct rpc_req *req, struct mem_pool *pool) |
620 | { |
621 | if (!req) { |
622 | goto out; |
623 | } |
624 | |
625 | if (req->rsp_iobref) { |
626 | iobref_unref (req->rsp_iobref); |
627 | } |
628 | |
629 | mem_put (req); |
630 | out: |
631 | return; |
632 | } |
633 | |
634 | |
635 | /* TODO: use mem-pool for allocating requests */ |
636 | int |
637 | rpc_clnt_reply_init (rpc_clnt_connection_t *conn, rpc_transport_pollin_t *msg, |
638 | struct rpc_req *req, struct saved_frame *saved_frame) |
639 | { |
640 | char *msgbuf = NULL((void*)0); |
641 | struct rpc_msg rpcmsg; |
642 | struct iovec progmsg; /* RPC Program payload */ |
643 | size_t msglen = 0; |
644 | int ret = -1; |
645 | |
646 | msgbuf = msg->vector[0].iov_base; |
647 | msglen = msg->vector[0].iov_len; |
648 | |
649 | ret = xdr_to_rpc_reply (msgbuf, msglen, &rpcmsg, &progmsg, |
650 | req->verf.authdata); |
651 | if (ret != 0) { |
652 | gf_log (conn->trans->name, GF_LOG_WARNING,do { do { if (0) printf ("RPC reply decoding failed"); } while (0); _gf_log (conn->trans->name, "rpc-clnt.c", __FUNCTION__ , 653, GF_LOG_WARNING, "RPC reply decoding failed"); } while ( 0) |
653 | "RPC reply decoding failed")do { do { if (0) printf ("RPC reply decoding failed"); } while (0); _gf_log (conn->trans->name, "rpc-clnt.c", __FUNCTION__ , 653, GF_LOG_WARNING, "RPC reply decoding failed"); } while ( 0); |
654 | goto out; |
655 | } |
656 | |
657 | ret = rpc_clnt_reply_fill (msg, conn, &rpcmsg, progmsg, req, |
658 | saved_frame); |
659 | if (ret != 0) { |
660 | goto out; |
661 | } |
662 | |
663 | gf_log (conn->trans->name, GF_LOG_TRACE,do { do { if (0) printf ("received rpc message (RPC XID: 0x%ux" " Program: %s, ProgVers: %d, Proc: %d) from rpc-transport (%s)" , saved_frame->rpcreq->xid, saved_frame->rpcreq-> prog->progname, saved_frame->rpcreq->prog->progver , saved_frame->rpcreq->procnum, conn->trans->name ); } while (0); _gf_log (conn->trans->name, "rpc-clnt.c" , __FUNCTION__, 669, GF_LOG_TRACE, "received rpc message (RPC XID: 0x%ux" " Program: %s, ProgVers: %d, Proc: %d) from rpc-transport (%s)" , saved_frame->rpcreq->xid, saved_frame->rpcreq-> prog->progname, saved_frame->rpcreq->prog->progver , saved_frame->rpcreq->procnum, conn->trans->name ); } while (0) |
664 | "received rpc message (RPC XID: 0x%ux"do { do { if (0) printf ("received rpc message (RPC XID: 0x%ux" " Program: %s, ProgVers: %d, Proc: %d) from rpc-transport (%s)" , saved_frame->rpcreq->xid, saved_frame->rpcreq-> prog->progname, saved_frame->rpcreq->prog->progver , saved_frame->rpcreq->procnum, conn->trans->name ); } while (0); _gf_log (conn->trans->name, "rpc-clnt.c" , __FUNCTION__, 669, GF_LOG_TRACE, "received rpc message (RPC XID: 0x%ux" " Program: %s, ProgVers: %d, Proc: %d) from rpc-transport (%s)" , saved_frame->rpcreq->xid, saved_frame->rpcreq-> prog->progname, saved_frame->rpcreq->prog->progver , saved_frame->rpcreq->procnum, conn->trans->name ); } while (0) |
665 | " Program: %s, ProgVers: %d, Proc: %d) from rpc-transport (%s)",do { do { if (0) printf ("received rpc message (RPC XID: 0x%ux" " Program: %s, ProgVers: %d, Proc: %d) from rpc-transport (%s)" , saved_frame->rpcreq->xid, saved_frame->rpcreq-> prog->progname, saved_frame->rpcreq->prog->progver , saved_frame->rpcreq->procnum, conn->trans->name ); } while (0); _gf_log (conn->trans->name, "rpc-clnt.c" , __FUNCTION__, 669, GF_LOG_TRACE, "received rpc message (RPC XID: 0x%ux" " Program: %s, ProgVers: %d, Proc: %d) from rpc-transport (%s)" , saved_frame->rpcreq->xid, saved_frame->rpcreq-> prog->progname, saved_frame->rpcreq->prog->progver , saved_frame->rpcreq->procnum, conn->trans->name ); } while (0) |
666 | saved_frame->rpcreq->xid,do { do { if (0) printf ("received rpc message (RPC XID: 0x%ux" " Program: %s, ProgVers: %d, Proc: %d) from rpc-transport (%s)" , saved_frame->rpcreq->xid, saved_frame->rpcreq-> prog->progname, saved_frame->rpcreq->prog->progver , saved_frame->rpcreq->procnum, conn->trans->name ); } while (0); _gf_log (conn->trans->name, "rpc-clnt.c" , __FUNCTION__, 669, GF_LOG_TRACE, "received rpc message (RPC XID: 0x%ux" " Program: %s, ProgVers: %d, Proc: %d) from rpc-transport (%s)" , saved_frame->rpcreq->xid, saved_frame->rpcreq-> prog->progname, saved_frame->rpcreq->prog->progver , saved_frame->rpcreq->procnum, conn->trans->name ); } while (0) |
667 | saved_frame->rpcreq->prog->progname,do { do { if (0) printf ("received rpc message (RPC XID: 0x%ux" " Program: %s, ProgVers: %d, Proc: %d) from rpc-transport (%s)" , saved_frame->rpcreq->xid, saved_frame->rpcreq-> prog->progname, saved_frame->rpcreq->prog->progver , saved_frame->rpcreq->procnum, conn->trans->name ); } while (0); _gf_log (conn->trans->name, "rpc-clnt.c" , __FUNCTION__, 669, GF_LOG_TRACE, "received rpc message (RPC XID: 0x%ux" " Program: %s, ProgVers: %d, Proc: %d) from rpc-transport (%s)" , saved_frame->rpcreq->xid, saved_frame->rpcreq-> prog->progname, saved_frame->rpcreq->prog->progver , saved_frame->rpcreq->procnum, conn->trans->name ); } while (0) |
668 | saved_frame->rpcreq->prog->progver,do { do { if (0) printf ("received rpc message (RPC XID: 0x%ux" " Program: %s, ProgVers: %d, Proc: %d) from rpc-transport (%s)" , saved_frame->rpcreq->xid, saved_frame->rpcreq-> prog->progname, saved_frame->rpcreq->prog->progver , saved_frame->rpcreq->procnum, conn->trans->name ); } while (0); _gf_log (conn->trans->name, "rpc-clnt.c" , __FUNCTION__, 669, GF_LOG_TRACE, "received rpc message (RPC XID: 0x%ux" " Program: %s, ProgVers: %d, Proc: %d) from rpc-transport (%s)" , saved_frame->rpcreq->xid, saved_frame->rpcreq-> prog->progname, saved_frame->rpcreq->prog->progver , saved_frame->rpcreq->procnum, conn->trans->name ); } while (0) |
669 | saved_frame->rpcreq->procnum, conn->trans->name)do { do { if (0) printf ("received rpc message (RPC XID: 0x%ux" " Program: %s, ProgVers: %d, Proc: %d) from rpc-transport (%s)" , saved_frame->rpcreq->xid, saved_frame->rpcreq-> prog->progname, saved_frame->rpcreq->prog->progver , saved_frame->rpcreq->procnum, conn->trans->name ); } while (0); _gf_log (conn->trans->name, "rpc-clnt.c" , __FUNCTION__, 669, GF_LOG_TRACE, "received rpc message (RPC XID: 0x%ux" " Program: %s, ProgVers: %d, Proc: %d) from rpc-transport (%s)" , saved_frame->rpcreq->xid, saved_frame->rpcreq-> prog->progname, saved_frame->rpcreq->prog->progver , saved_frame->rpcreq->procnum, conn->trans->name ); } while (0); |
670 | |
671 | out: |
672 | if (ret != 0) { |
673 | req->rpc_status = -1; |
674 | } |
675 | |
676 | return ret; |
677 | } |
678 | |
679 | int |
680 | rpc_clnt_handle_cbk (struct rpc_clnt *clnt, rpc_transport_pollin_t *msg) |
681 | { |
682 | char *msgbuf = NULL((void*)0); |
683 | rpcclnt_cb_program_t *program = NULL((void*)0); |
684 | struct rpc_msg rpcmsg; |
685 | struct iovec progmsg; /* RPC Program payload */ |
686 | size_t msglen = 0; |
687 | int found = 0; |
688 | int ret = -1; |
689 | int procnum = 0; |
690 | |
691 | msgbuf = msg->vector[0].iov_base; |
692 | msglen = msg->vector[0].iov_len; |
693 | |
694 | clnt = rpc_clnt_ref (clnt); |
695 | ret = xdr_to_rpc_call (msgbuf, msglen, &rpcmsg, &progmsg, NULL((void*)0),NULL((void*)0)); |
696 | if (ret == -1) { |
697 | gf_log (clnt->conn.trans->name, GF_LOG_WARNING,do { do { if (0) printf ("RPC call decoding failed"); } while (0); _gf_log (clnt->conn.trans->name, "rpc-clnt.c", __FUNCTION__ , 698, GF_LOG_WARNING, "RPC call decoding failed"); } while ( 0) |
698 | "RPC call decoding failed")do { do { if (0) printf ("RPC call decoding failed"); } while (0); _gf_log (clnt->conn.trans->name, "rpc-clnt.c", __FUNCTION__ , 698, GF_LOG_WARNING, "RPC call decoding failed"); } while ( 0); |
699 | goto out; |
700 | } |
701 | |
702 | gf_log (clnt->conn.trans->name, GF_LOG_TRACE,do { do { if (0) printf ("received rpc message (XID: 0x%lx, " "Ver: %ld, Program: %ld, ProgVers: %ld, Proc: %ld) " "from rpc-transport (%s)" , ((&rpcmsg)->rm_xid), ((&rpcmsg)->ru.RM_cmb.cb_rpcvers ), ((&rpcmsg)->ru.RM_cmb.cb_prog), ((&rpcmsg)-> ru.RM_cmb.cb_vers), ((&rpcmsg)->ru.RM_cmb.cb_proc), clnt ->conn.trans->name); } while (0); _gf_log (clnt->conn .trans->name, "rpc-clnt.c", __FUNCTION__, 708, GF_LOG_TRACE , "received rpc message (XID: 0x%lx, " "Ver: %ld, Program: %ld, ProgVers: %ld, Proc: %ld) " "from rpc-transport (%s)", ((&rpcmsg)->rm_xid), ((& rpcmsg)->ru.RM_cmb.cb_rpcvers), ((&rpcmsg)->ru.RM_cmb .cb_prog), ((&rpcmsg)->ru.RM_cmb.cb_vers), ((&rpcmsg )->ru.RM_cmb.cb_proc), clnt->conn.trans->name); } while (0) |
703 | "received rpc message (XID: 0x%lx, "do { do { if (0) printf ("received rpc message (XID: 0x%lx, " "Ver: %ld, Program: %ld, ProgVers: %ld, Proc: %ld) " "from rpc-transport (%s)" , ((&rpcmsg)->rm_xid), ((&rpcmsg)->ru.RM_cmb.cb_rpcvers ), ((&rpcmsg)->ru.RM_cmb.cb_prog), ((&rpcmsg)-> ru.RM_cmb.cb_vers), ((&rpcmsg)->ru.RM_cmb.cb_proc), clnt ->conn.trans->name); } while (0); _gf_log (clnt->conn .trans->name, "rpc-clnt.c", __FUNCTION__, 708, GF_LOG_TRACE , "received rpc message (XID: 0x%lx, " "Ver: %ld, Program: %ld, ProgVers: %ld, Proc: %ld) " "from rpc-transport (%s)", ((&rpcmsg)->rm_xid), ((& rpcmsg)->ru.RM_cmb.cb_rpcvers), ((&rpcmsg)->ru.RM_cmb .cb_prog), ((&rpcmsg)->ru.RM_cmb.cb_vers), ((&rpcmsg )->ru.RM_cmb.cb_proc), clnt->conn.trans->name); } while (0) |
704 | "Ver: %ld, Program: %ld, ProgVers: %ld, Proc: %ld) "do { do { if (0) printf ("received rpc message (XID: 0x%lx, " "Ver: %ld, Program: %ld, ProgVers: %ld, Proc: %ld) " "from rpc-transport (%s)" , ((&rpcmsg)->rm_xid), ((&rpcmsg)->ru.RM_cmb.cb_rpcvers ), ((&rpcmsg)->ru.RM_cmb.cb_prog), ((&rpcmsg)-> ru.RM_cmb.cb_vers), ((&rpcmsg)->ru.RM_cmb.cb_proc), clnt ->conn.trans->name); } while (0); _gf_log (clnt->conn .trans->name, "rpc-clnt.c", __FUNCTION__, 708, GF_LOG_TRACE , "received rpc message (XID: 0x%lx, " "Ver: %ld, Program: %ld, ProgVers: %ld, Proc: %ld) " "from rpc-transport (%s)", ((&rpcmsg)->rm_xid), ((& rpcmsg)->ru.RM_cmb.cb_rpcvers), ((&rpcmsg)->ru.RM_cmb .cb_prog), ((&rpcmsg)->ru.RM_cmb.cb_vers), ((&rpcmsg )->ru.RM_cmb.cb_proc), clnt->conn.trans->name); } while (0) |
705 | "from rpc-transport (%s)", rpc_call_xid (&rpcmsg),do { do { if (0) printf ("received rpc message (XID: 0x%lx, " "Ver: %ld, Program: %ld, ProgVers: %ld, Proc: %ld) " "from rpc-transport (%s)" , ((&rpcmsg)->rm_xid), ((&rpcmsg)->ru.RM_cmb.cb_rpcvers ), ((&rpcmsg)->ru.RM_cmb.cb_prog), ((&rpcmsg)-> ru.RM_cmb.cb_vers), ((&rpcmsg)->ru.RM_cmb.cb_proc), clnt ->conn.trans->name); } while (0); _gf_log (clnt->conn .trans->name, "rpc-clnt.c", __FUNCTION__, 708, GF_LOG_TRACE , "received rpc message (XID: 0x%lx, " "Ver: %ld, Program: %ld, ProgVers: %ld, Proc: %ld) " "from rpc-transport (%s)", ((&rpcmsg)->rm_xid), ((& rpcmsg)->ru.RM_cmb.cb_rpcvers), ((&rpcmsg)->ru.RM_cmb .cb_prog), ((&rpcmsg)->ru.RM_cmb.cb_vers), ((&rpcmsg )->ru.RM_cmb.cb_proc), clnt->conn.trans->name); } while (0) |
706 | rpc_call_rpcvers (&rpcmsg), rpc_call_program (&rpcmsg),do { do { if (0) printf ("received rpc message (XID: 0x%lx, " "Ver: %ld, Program: %ld, ProgVers: %ld, Proc: %ld) " "from rpc-transport (%s)" , ((&rpcmsg)->rm_xid), ((&rpcmsg)->ru.RM_cmb.cb_rpcvers ), ((&rpcmsg)->ru.RM_cmb.cb_prog), ((&rpcmsg)-> ru.RM_cmb.cb_vers), ((&rpcmsg)->ru.RM_cmb.cb_proc), clnt ->conn.trans->name); } while (0); _gf_log (clnt->conn .trans->name, "rpc-clnt.c", __FUNCTION__, 708, GF_LOG_TRACE , "received rpc message (XID: 0x%lx, " "Ver: %ld, Program: %ld, ProgVers: %ld, Proc: %ld) " "from rpc-transport (%s)", ((&rpcmsg)->rm_xid), ((& rpcmsg)->ru.RM_cmb.cb_rpcvers), ((&rpcmsg)->ru.RM_cmb .cb_prog), ((&rpcmsg)->ru.RM_cmb.cb_vers), ((&rpcmsg )->ru.RM_cmb.cb_proc), clnt->conn.trans->name); } while (0) |
707 | rpc_call_progver (&rpcmsg), rpc_call_progproc (&rpcmsg),do { do { if (0) printf ("received rpc message (XID: 0x%lx, " "Ver: %ld, Program: %ld, ProgVers: %ld, Proc: %ld) " "from rpc-transport (%s)" , ((&rpcmsg)->rm_xid), ((&rpcmsg)->ru.RM_cmb.cb_rpcvers ), ((&rpcmsg)->ru.RM_cmb.cb_prog), ((&rpcmsg)-> ru.RM_cmb.cb_vers), ((&rpcmsg)->ru.RM_cmb.cb_proc), clnt ->conn.trans->name); } while (0); _gf_log (clnt->conn .trans->name, "rpc-clnt.c", __FUNCTION__, 708, GF_LOG_TRACE , "received rpc message (XID: 0x%lx, " "Ver: %ld, Program: %ld, ProgVers: %ld, Proc: %ld) " "from rpc-transport (%s)", ((&rpcmsg)->rm_xid), ((& rpcmsg)->ru.RM_cmb.cb_rpcvers), ((&rpcmsg)->ru.RM_cmb .cb_prog), ((&rpcmsg)->ru.RM_cmb.cb_vers), ((&rpcmsg )->ru.RM_cmb.cb_proc), clnt->conn.trans->name); } while (0) |
708 | clnt->conn.trans->name)do { do { if (0) printf ("received rpc message (XID: 0x%lx, " "Ver: %ld, Program: %ld, ProgVers: %ld, Proc: %ld) " "from rpc-transport (%s)" , ((&rpcmsg)->rm_xid), ((&rpcmsg)->ru.RM_cmb.cb_rpcvers ), ((&rpcmsg)->ru.RM_cmb.cb_prog), ((&rpcmsg)-> ru.RM_cmb.cb_vers), ((&rpcmsg)->ru.RM_cmb.cb_proc), clnt ->conn.trans->name); } while (0); _gf_log (clnt->conn .trans->name, "rpc-clnt.c", __FUNCTION__, 708, GF_LOG_TRACE , "received rpc message (XID: 0x%lx, " "Ver: %ld, Program: %ld, ProgVers: %ld, Proc: %ld) " "from rpc-transport (%s)", ((&rpcmsg)->rm_xid), ((& rpcmsg)->ru.RM_cmb.cb_rpcvers), ((&rpcmsg)->ru.RM_cmb .cb_prog), ((&rpcmsg)->ru.RM_cmb.cb_vers), ((&rpcmsg )->ru.RM_cmb.cb_proc), clnt->conn.trans->name); } while (0); |
709 | |
710 | procnum = rpc_call_progproc (&rpcmsg)((&rpcmsg)->ru.RM_cmb.cb_proc); |
711 | |
712 | pthread_mutex_lock (&clnt->lock); |
713 | { |
714 | list_for_each_entry (program, &clnt->programs, program)for (program = ((typeof(*program) *)((char *)((&clnt-> programs)->next)-(unsigned long)(&((typeof(*program) * )0)->program))); &program->program != (&clnt-> programs); program = ((typeof(*program) *)((char *)(program-> program.next)-(unsigned long)(&((typeof(*program) *)0)-> program)))) { |
715 | if ((program->prognum == rpc_call_program (&rpcmsg)((&rpcmsg)->ru.RM_cmb.cb_prog)) |
716 | && (program->progver |
717 | == rpc_call_progver (&rpcmsg)((&rpcmsg)->ru.RM_cmb.cb_vers))) { |
718 | found = 1; |
719 | break; |
720 | } |
721 | } |
722 | } |
723 | pthread_mutex_unlock (&clnt->lock); |
724 | |
725 | if (found && (procnum < program->numactors) && |
726 | (program->actors[procnum].actor)) { |
727 | program->actors[procnum].actor (clnt, program->mydata, |
728 | &progmsg); |
729 | } |
730 | |
731 | out: |
732 | clnt = rpc_clnt_unref (clnt); |
733 | return ret; |
734 | } |
735 | |
736 | int |
737 | rpc_clnt_handle_reply (struct rpc_clnt *clnt, rpc_transport_pollin_t *pollin) |
738 | { |
739 | rpc_clnt_connection_t *conn = NULL((void*)0); |
740 | struct saved_frame *saved_frame = NULL((void*)0); |
741 | int ret = -1; |
742 | struct rpc_req *req = NULL((void*)0); |
743 | uint32_t xid = 0; |
744 | |
745 | clnt = rpc_clnt_ref (clnt); |
746 | conn = &clnt->conn; |
747 | |
748 | xid = ntoh32hton32 (*((uint32_t *)pollin->vector[0].iov_base)); |
749 | saved_frame = lookup_frame (conn, xid); |
750 | if (saved_frame == NULL((void*)0)) { |
751 | gf_log (conn->trans->name, GF_LOG_ERROR,do { do { if (0) printf ("cannot lookup the saved frame for reply with xid (%u)" , xid); } while (0); _gf_log (conn->trans->name, "rpc-clnt.c" , __FUNCTION__, 753, GF_LOG_ERROR, "cannot lookup the saved frame for reply with xid (%u)" , xid); } while (0) |
752 | "cannot lookup the saved frame for reply with xid (%u)",do { do { if (0) printf ("cannot lookup the saved frame for reply with xid (%u)" , xid); } while (0); _gf_log (conn->trans->name, "rpc-clnt.c" , __FUNCTION__, 753, GF_LOG_ERROR, "cannot lookup the saved frame for reply with xid (%u)" , xid); } while (0) |
753 | xid)do { do { if (0) printf ("cannot lookup the saved frame for reply with xid (%u)" , xid); } while (0); _gf_log (conn->trans->name, "rpc-clnt.c" , __FUNCTION__, 753, GF_LOG_ERROR, "cannot lookup the saved frame for reply with xid (%u)" , xid); } while (0); |
754 | goto out; |
755 | } |
756 | |
757 | req = saved_frame->rpcreq; |
758 | if (req == NULL((void*)0)) { |
759 | gf_log (conn->trans->name, GF_LOG_ERROR,do { do { if (0) printf ("no request with frame for xid (%u)" , xid); } while (0); _gf_log (conn->trans->name, "rpc-clnt.c" , __FUNCTION__, 760, GF_LOG_ERROR, "no request with frame for xid (%u)" , xid); } while (0) |
760 | "no request with frame for xid (%u)", xid)do { do { if (0) printf ("no request with frame for xid (%u)" , xid); } while (0); _gf_log (conn->trans->name, "rpc-clnt.c" , __FUNCTION__, 760, GF_LOG_ERROR, "no request with frame for xid (%u)" , xid); } while (0); |
761 | goto out; |
762 | } |
763 | |
764 | ret = rpc_clnt_reply_init (conn, pollin, req, saved_frame); |
765 | if (ret != 0) { |
766 | req->rpc_status = -1; |
767 | gf_log (conn->trans->name, GF_LOG_WARNING,do { do { if (0) printf ("initialising rpc reply failed"); } while (0); _gf_log (conn->trans->name, "rpc-clnt.c", __FUNCTION__ , 768, GF_LOG_WARNING, "initialising rpc reply failed"); } while (0) |
768 | "initialising rpc reply failed")do { do { if (0) printf ("initialising rpc reply failed"); } while (0); _gf_log (conn->trans->name, "rpc-clnt.c", __FUNCTION__ , 768, GF_LOG_WARNING, "initialising rpc reply failed"); } while (0); |
769 | } |
770 | |
771 | req->cbkfn (req, req->rsp, req->rspcnt, saved_frame->frame); |
772 | |
773 | if (req) { |
774 | rpc_clnt_reply_deinit (req, conn->rpc_clnt->reqpool); |
775 | } |
776 | out: |
777 | |
778 | if (saved_frame) { |
779 | mem_put (saved_frame); |
780 | } |
781 | |
782 | clnt = rpc_clnt_unref (clnt); |
783 | return ret; |
784 | } |
785 | |
786 | |
787 | inline void |
788 | rpc_clnt_set_connected (rpc_clnt_connection_t *conn) |
789 | { |
790 | if (!conn) { |
791 | goto out; |
792 | } |
793 | |
794 | pthread_mutex_lock (&conn->lock); |
795 | { |
796 | conn->connected = 1; |
797 | } |
798 | pthread_mutex_unlock (&conn->lock); |
799 | |
800 | out: |
801 | return; |
802 | } |
803 | |
804 | |
805 | void |
806 | rpc_clnt_unset_connected (rpc_clnt_connection_t *conn) |
807 | { |
808 | if (!conn) { |
809 | goto out; |
810 | } |
811 | |
812 | pthread_mutex_lock (&conn->lock); |
813 | { |
814 | conn->connected = 0; |
815 | } |
816 | pthread_mutex_unlock (&conn->lock); |
817 | |
818 | out: |
819 | return; |
820 | } |
821 | |
822 | int |
823 | rpc_clnt_notify (rpc_transport_t *trans, void *mydata, |
824 | rpc_transport_event_t event, void *data, ...) |
825 | { |
826 | rpc_clnt_connection_t *conn = NULL((void*)0); |
827 | struct rpc_clnt *clnt = NULL((void*)0); |
828 | int ret = -1; |
829 | rpc_request_info_t *req_info = NULL((void*)0); |
830 | rpc_transport_pollin_t *pollin = NULL((void*)0); |
831 | struct timeval tv = {0, }; |
832 | |
833 | conn = mydata; |
834 | if (conn == NULL((void*)0)) { |
835 | goto out; |
836 | } |
837 | clnt = conn->rpc_clnt; |
838 | if (!clnt) |
839 | goto out; |
840 | |
841 | switch (event) { |
842 | case RPC_TRANSPORT_DISCONNECT: |
843 | { |
844 | rpc_clnt_connection_cleanup (conn); |
845 | |
846 | pthread_mutex_lock (&conn->lock); |
847 | { |
848 | if (!conn->rpc_clnt->disabled |
849 | && (conn->reconnect == NULL((void*)0))) { |
850 | tv.tv_sec = 10; |
851 | |
852 | conn->reconnect = |
853 | gf_timer_call_after (clnt->ctx, tv, |
854 | rpc_clnt_reconnect, |
855 | conn->trans); |
856 | } |
857 | } |
858 | pthread_mutex_unlock (&conn->lock); |
859 | |
860 | if (clnt->notifyfn) |
861 | ret = clnt->notifyfn (clnt, clnt->mydata, |
862 | RPC_CLNT_DISCONNECT, NULL((void*)0)); |
863 | break; |
864 | } |
865 | |
866 | case RPC_TRANSPORT_CLEANUP: |
867 | /* this event should not be received on a client for, a |
868 | * transport is only disconnected, but never destroyed. |
869 | */ |
870 | ret = 0; |
871 | break; |
872 | |
873 | case RPC_TRANSPORT_MAP_XID_REQUEST: |
874 | { |
875 | req_info = data; |
876 | ret = rpc_clnt_fill_request_info (clnt, req_info); |
877 | break; |
878 | } |
879 | |
880 | case RPC_TRANSPORT_MSG_RECEIVED: |
881 | { |
882 | pthread_mutex_lock (&conn->lock); |
883 | { |
884 | gettimeofday (&conn->last_received, NULL((void*)0)); |
885 | } |
886 | pthread_mutex_unlock (&conn->lock); |
887 | |
888 | pollin = data; |
889 | if (pollin->is_reply) |
890 | ret = rpc_clnt_handle_reply (clnt, pollin); |
891 | else |
892 | ret = rpc_clnt_handle_cbk (clnt, pollin); |
893 | /* ret = clnt->notifyfn (clnt, clnt->mydata, RPC_CLNT_MSG, |
894 | * data); |
895 | */ |
896 | break; |
897 | } |
898 | |
899 | case RPC_TRANSPORT_MSG_SENT: |
900 | { |
901 | pthread_mutex_lock (&conn->lock); |
902 | { |
903 | gettimeofday (&conn->last_sent, NULL((void*)0)); |
904 | } |
905 | pthread_mutex_unlock (&conn->lock); |
906 | |
907 | ret = 0; |
908 | break; |
909 | } |
910 | |
911 | case RPC_TRANSPORT_CONNECT: |
912 | { |
913 | /* Every time there is a disconnection, processes |
914 | should try to connect to 'glusterd' (ie, default |
915 | port) or whichever port given as 'option remote-port' |
916 | in volume file. */ |
917 | /* Below code makes sure the (re-)configured port lasts |
918 | for just one successful attempt */ |
919 | conn->config.remote_port = 0; |
920 | |
921 | if (clnt->notifyfn) |
922 | ret = clnt->notifyfn (clnt, clnt->mydata, |
923 | RPC_CLNT_CONNECT, NULL((void*)0)); |
924 | break; |
925 | } |
926 | |
927 | case RPC_TRANSPORT_ACCEPT: |
928 | /* only meaningful on a server, no need of handling this event |
929 | * in a client. |
930 | */ |
931 | ret = 0; |
932 | break; |
933 | } |
934 | |
935 | out: |
936 | return ret; |
937 | } |
938 | |
939 | |
940 | void |
941 | rpc_clnt_connection_deinit (rpc_clnt_connection_t *conn) |
942 | { |
943 | return; |
944 | } |
945 | |
946 | |
947 | static inline int |
948 | rpc_clnt_connection_init (struct rpc_clnt *clnt, glusterfs_ctx_t *ctx, |
949 | dict_t *options, char *name) |
950 | { |
951 | int ret = -1; |
952 | rpc_clnt_connection_t *conn = NULL((void*)0); |
953 | |
954 | conn = &clnt->conn; |
955 | pthread_mutex_init (&clnt->conn.lock, NULL((void*)0)); |
956 | |
957 | ret = dict_get_int32 (options, "frame-timeout", |
958 | &conn->frame_timeout); |
959 | if (ret >= 0) { |
960 | gf_log (name, GF_LOG_INFO,do { do { if (0) printf ("setting frame-timeout to %d", conn-> frame_timeout); } while (0); _gf_log (name, "rpc-clnt.c", __FUNCTION__ , 961, GF_LOG_INFO, "setting frame-timeout to %d", conn->frame_timeout ); } while (0) |
961 | "setting frame-timeout to %d", conn->frame_timeout)do { do { if (0) printf ("setting frame-timeout to %d", conn-> frame_timeout); } while (0); _gf_log (name, "rpc-clnt.c", __FUNCTION__ , 961, GF_LOG_INFO, "setting frame-timeout to %d", conn->frame_timeout ); } while (0); |
962 | } else { |
963 | gf_log (name, GF_LOG_DEBUG,do { do { if (0) printf ("defaulting frame-timeout to 30mins" ); } while (0); _gf_log (name, "rpc-clnt.c", __FUNCTION__, 964 , GF_LOG_DEBUG, "defaulting frame-timeout to 30mins"); } while (0) |
964 | "defaulting frame-timeout to 30mins")do { do { if (0) printf ("defaulting frame-timeout to 30mins" ); } while (0); _gf_log (name, "rpc-clnt.c", __FUNCTION__, 964 , GF_LOG_DEBUG, "defaulting frame-timeout to 30mins"); } while (0); |
965 | conn->frame_timeout = 1800; |
966 | } |
967 | |
968 | conn->trans = rpc_transport_load (ctx, options, name); |
969 | if (!conn->trans) { |
970 | gf_log (name, GF_LOG_WARNING, "loading of new rpc-transport"do { do { if (0) printf ("loading of new rpc-transport" " failed" ); } while (0); _gf_log (name, "rpc-clnt.c", __FUNCTION__, 971 , GF_LOG_WARNING, "loading of new rpc-transport" " failed"); } while (0) |
971 | " failed")do { do { if (0) printf ("loading of new rpc-transport" " failed" ); } while (0); _gf_log (name, "rpc-clnt.c", __FUNCTION__, 971 , GF_LOG_WARNING, "loading of new rpc-transport" " failed"); } while (0); |
972 | ret = -1; |
973 | goto out; |
974 | } |
975 | |
976 | rpc_transport_ref (conn->trans); |
977 | |
978 | conn->rpc_clnt = clnt; |
979 | |
980 | ret = rpc_transport_register_notify (conn->trans, rpc_clnt_notify, |
981 | conn); |
982 | if (ret == -1) { |
983 | gf_log (name, GF_LOG_WARNING, "registering notify failed")do { do { if (0) printf ("registering notify failed"); } while (0); _gf_log (name, "rpc-clnt.c", __FUNCTION__, 983, GF_LOG_WARNING , "registering notify failed"); } while (0); |
984 | rpc_clnt_connection_cleanup (conn); |
985 | conn = NULL((void*)0); |
986 | goto out; |
987 | } |
988 | |
989 | conn->saved_frames = saved_frames_new (); |
990 | if (!conn->saved_frames) { |
991 | gf_log (name, GF_LOG_WARNING, "creation of saved_frames "do { do { if (0) printf ("creation of saved_frames " "failed" ); } while (0); _gf_log (name, "rpc-clnt.c", __FUNCTION__, 992 , GF_LOG_WARNING, "creation of saved_frames " "failed"); } while (0) |
992 | "failed")do { do { if (0) printf ("creation of saved_frames " "failed" ); } while (0); _gf_log (name, "rpc-clnt.c", __FUNCTION__, 992 , GF_LOG_WARNING, "creation of saved_frames " "failed"); } while (0); |
993 | rpc_clnt_connection_cleanup (conn); |
994 | goto out; |
995 | } |
996 | |
997 | ret = 0; |
998 | |
999 | out: |
1000 | return ret; |
1001 | } |
1002 | |
1003 | struct rpc_clnt * |
1004 | rpc_clnt_new (dict_t *options, glusterfs_ctx_t *ctx, char *name, |
1005 | uint32_t reqpool_size) |
1006 | { |
1007 | int ret = -1; |
1008 | struct rpc_clnt *rpc = NULL((void*)0); |
1009 | |
1010 | rpc = GF_CALLOC (1, sizeof (*rpc), gf_common_mt_rpcclnt_t)__gf_calloc (1, sizeof (*rpc), gf_common_mt_rpcclnt_t); |
1011 | if (!rpc) { |
1012 | goto out; |
1013 | } |
1014 | |
1015 | pthread_mutex_init (&rpc->lock, NULL((void*)0)); |
1016 | rpc->ctx = ctx; |
1017 | |
1018 | if (!reqpool_size) |
1019 | reqpool_size = RPC_CLNT_DEFAULT_REQUEST_COUNT512; |
1020 | |
1021 | rpc->reqpool = mem_pool_new (struct rpc_req, reqpool_size)mem_pool_new_fn (sizeof(struct rpc_req), reqpool_size, "struct rpc_req" ); |
1022 | if (rpc->reqpool == NULL((void*)0)) { |
1023 | pthread_mutex_destroy (&rpc->lock); |
1024 | GF_FREE (rpc)__gf_free (rpc); |
1025 | rpc = NULL((void*)0); |
1026 | goto out; |
1027 | } |
1028 | |
1029 | rpc->saved_frames_pool = mem_pool_new (struct saved_frame,mem_pool_new_fn (sizeof(struct saved_frame), reqpool_size, "struct saved_frame" ) |
1030 | reqpool_size)mem_pool_new_fn (sizeof(struct saved_frame), reqpool_size, "struct saved_frame" ); |
1031 | if (rpc->saved_frames_pool == NULL((void*)0)) { |
1032 | pthread_mutex_destroy (&rpc->lock); |
1033 | mem_pool_destroy (rpc->reqpool); |
1034 | GF_FREE (rpc)__gf_free (rpc); |
1035 | rpc = NULL((void*)0); |
1036 | goto out; |
1037 | } |
1038 | |
1039 | ret = rpc_clnt_connection_init (rpc, ctx, options, name); |
1040 | if (ret == -1) { |
1041 | pthread_mutex_destroy (&rpc->lock); |
1042 | mem_pool_destroy (rpc->reqpool); |
1043 | mem_pool_destroy (rpc->saved_frames_pool); |
1044 | GF_FREE (rpc)__gf_free (rpc); |
1045 | rpc = NULL((void*)0); |
1046 | if (options) |
1047 | dict_unref (options); |
1048 | goto out; |
1049 | } |
1050 | |
1051 | rpc->auth_null = dict_get_str_boolean (options, "auth-null", 0); |
1052 | |
1053 | rpc = rpc_clnt_ref (rpc); |
1054 | INIT_LIST_HEAD (&rpc->programs)do { (&rpc->programs)->next = (&rpc->programs )->prev = &rpc->programs; } while (0); |
1055 | |
1056 | out: |
1057 | return rpc; |
1058 | } |
1059 | |
1060 | |
1061 | int |
1062 | rpc_clnt_start (struct rpc_clnt *rpc) |
1063 | { |
1064 | struct rpc_clnt_connection *conn = NULL((void*)0); |
1065 | |
1066 | if (!rpc) |
1067 | return -1; |
1068 | |
1069 | conn = &rpc->conn; |
1070 | |
1071 | rpc_clnt_reconnect (conn->trans); |
1072 | |
1073 | return 0; |
1074 | } |
1075 | |
1076 | |
1077 | int |
1078 | rpc_clnt_register_notify (struct rpc_clnt *rpc, rpc_clnt_notify_t fn, |
1079 | void *mydata) |
1080 | { |
1081 | rpc->mydata = mydata; |
1082 | rpc->notifyfn = fn; |
1083 | |
1084 | return 0; |
1085 | } |
1086 | |
1087 | ssize_t |
1088 | xdr_serialize_glusterfs_auth (char *dest, struct auth_glusterfs_parms_v2 *au) |
1089 | { |
1090 | ssize_t ret = -1; |
1091 | XDR xdr; |
1092 | |
1093 | if ((!dest) || (!au)) |
1094 | return -1; |
1095 | |
1096 | xdrmem_create (&xdr, dest, GF_MAX_AUTH_BYTES2048, XDR_ENCODE); |
1097 | |
1098 | if (!xdr_auth_glusterfs_parms_v2 (&xdr, au)) { |
1099 | gf_log (THIS->name, GF_LOG_WARNING,do { do { if (0) printf ("failed to encode auth glusterfs elements" ); } while (0); _gf_log ((*__glusterfs_this_location())->name , "rpc-clnt.c", __FUNCTION__, 1100, GF_LOG_WARNING, "failed to encode auth glusterfs elements" ); } while (0) |
1100 | "failed to encode auth glusterfs elements")do { do { if (0) printf ("failed to encode auth glusterfs elements" ); } while (0); _gf_log ((*__glusterfs_this_location())->name , "rpc-clnt.c", __FUNCTION__, 1100, GF_LOG_WARNING, "failed to encode auth glusterfs elements" ); } while (0); |
1101 | ret = -1; |
1102 | goto ret; |
1103 | } |
1104 | |
1105 | ret = (((size_t)(&xdr)->x_private) - ((size_t)(&xdr)->x_base)); |
1106 | |
1107 | ret: |
1108 | return ret; |
1109 | } |
1110 | |
1111 | |
1112 | int |
1113 | rpc_clnt_fill_request (int prognum, int progver, int procnum, |
1114 | uint64_t xid, struct auth_glusterfs_parms_v2 *au, |
1115 | struct rpc_msg *request, char *auth_data) |
1116 | { |
1117 | int ret = -1; |
1118 | |
1119 | if (!request) { |
1120 | goto out; |
1121 | } |
1122 | |
1123 | memset (request, 0, sizeof (*request)); |
1124 | |
1125 | request->rm_xid = xid; |
1126 | request->rm_direction = CALL; |
1127 | |
1128 | request->rm_callru.RM_cmb.cb_rpcvers = 2; |
1129 | request->rm_callru.RM_cmb.cb_prog = prognum; |
1130 | request->rm_callru.RM_cmb.cb_vers = progver; |
1131 | request->rm_callru.RM_cmb.cb_proc = procnum; |
1132 | |
1133 | /* TODO: Using AUTH_(GLUSTERFS/NULL) in a kludgy way for time-being. |
1134 | * Make it modular in future so it is easy to plug-in new |
1135 | * authentication schemes. |
1136 | */ |
1137 | if (auth_data) { |
1138 | ret = xdr_serialize_glusterfs_auth (auth_data, au); |
1139 | if (ret == -1) { |
1140 | gf_log ("rpc-clnt", GF_LOG_DEBUG,do { do { if (0) printf ("cannot encode credentials"); } while (0); _gf_log ("rpc-clnt", "rpc-clnt.c", __FUNCTION__, 1141, GF_LOG_DEBUG , "cannot encode credentials"); } while (0) |
1141 | "cannot encode credentials")do { do { if (0) printf ("cannot encode credentials"); } while (0); _gf_log ("rpc-clnt", "rpc-clnt.c", __FUNCTION__, 1141, GF_LOG_DEBUG , "cannot encode credentials"); } while (0); |
1142 | goto out; |
1143 | } |
1144 | |
1145 | request->rm_callru.RM_cmb.cb_cred.oa_flavor = AUTH_GLUSTERFS_v2; |
1146 | request->rm_callru.RM_cmb.cb_cred.oa_base = auth_data; |
1147 | request->rm_callru.RM_cmb.cb_cred.oa_length = ret; |
1148 | } else { |
1149 | request->rm_callru.RM_cmb.cb_cred.oa_flavor = AUTH_NULL0; |
1150 | request->rm_callru.RM_cmb.cb_cred.oa_base = NULL((void*)0); |
1151 | request->rm_callru.RM_cmb.cb_cred.oa_length = 0; |
1152 | } |
1153 | request->rm_callru.RM_cmb.cb_verf.oa_flavor = AUTH_NONE0; |
1154 | request->rm_callru.RM_cmb.cb_verf.oa_base = NULL((void*)0); |
1155 | request->rm_callru.RM_cmb.cb_verf.oa_length = 0; |
1156 | |
1157 | ret = 0; |
1158 | out: |
1159 | return ret; |
1160 | } |
1161 | |
1162 | |
1163 | struct iovec |
1164 | rpc_clnt_record_build_header (char *recordstart, size_t rlen, |
1165 | struct rpc_msg *request, size_t payload) |
1166 | { |
1167 | struct iovec requesthdr = {0, }; |
1168 | struct iovec txrecord = {0, 0}; |
1169 | int ret = -1; |
1170 | size_t fraglen = 0; |
1171 | |
1172 | ret = rpc_request_to_xdr (request, recordstart, rlen, &requesthdr); |
1173 | if (ret == -1) { |
1174 | gf_log ("rpc-clnt", GF_LOG_DEBUG,do { do { if (0) printf ("Failed to create RPC request"); } while (0); _gf_log ("rpc-clnt", "rpc-clnt.c", __FUNCTION__, 1175, GF_LOG_DEBUG , "Failed to create RPC request"); } while (0) |
1175 | "Failed to create RPC request")do { do { if (0) printf ("Failed to create RPC request"); } while (0); _gf_log ("rpc-clnt", "rpc-clnt.c", __FUNCTION__, 1175, GF_LOG_DEBUG , "Failed to create RPC request"); } while (0); |
1176 | goto out; |
1177 | } |
1178 | |
1179 | fraglen = payload + requesthdr.iov_len; |
1180 | gf_log ("rpc-clnt", GF_LOG_TRACE, "Request fraglen %zu, payload: %zu, "do { do { if (0) printf ("Request fraglen %zu, payload: %zu, " "rpc hdr: %zu", fraglen, payload, requesthdr.iov_len); } while (0); _gf_log ("rpc-clnt", "rpc-clnt.c", __FUNCTION__, 1181, GF_LOG_TRACE , "Request fraglen %zu, payload: %zu, " "rpc hdr: %zu", fraglen , payload, requesthdr.iov_len); } while (0) |
1181 | "rpc hdr: %zu", fraglen, payload, requesthdr.iov_len)do { do { if (0) printf ("Request fraglen %zu, payload: %zu, " "rpc hdr: %zu", fraglen, payload, requesthdr.iov_len); } while (0); _gf_log ("rpc-clnt", "rpc-clnt.c", __FUNCTION__, 1181, GF_LOG_TRACE , "Request fraglen %zu, payload: %zu, " "rpc hdr: %zu", fraglen , payload, requesthdr.iov_len); } while (0); |
1182 | |
1183 | |
1184 | txrecord.iov_base = recordstart; |
1185 | |
1186 | /* Remember, this is only the vec for the RPC header and does not |
1187 | * include the payload above. We needed the payload only to calculate |
1188 | * the size of the full fragment. This size is sent in the fragment |
1189 | * header. |
1190 | */ |
1191 | txrecord.iov_len = requesthdr.iov_len; |
1192 | |
1193 | out: |
1194 | return txrecord; |
1195 | } |
1196 | |
1197 | |
1198 | struct iobuf * |
1199 | rpc_clnt_record_build_record (struct rpc_clnt *clnt, int prognum, int progver, |
1200 | int procnum, size_t hdrsize, uint64_t xid, |
1201 | struct auth_glusterfs_parms_v2 *au, |
1202 | struct iovec *recbuf) |
1203 | { |
1204 | struct rpc_msg request = {0, }; |
1205 | struct iobuf *request_iob = NULL((void*)0); |
1206 | char *record = NULL((void*)0); |
1207 | struct iovec recordhdr = {0, }; |
Value stored to 'recordhdr' during its initialization is never read | |
1208 | size_t pagesize = 0; |
1209 | int ret = -1; |
1210 | size_t xdr_size = 0; |
1211 | char auth_data[GF_MAX_AUTH_BYTES2048] = {0, }; |
1212 | |
1213 | if ((!clnt) || (!recbuf) || (!au)) { |
1214 | goto out; |
1215 | } |
1216 | |
1217 | /* Fill the rpc structure and XDR it into the buffer got above. */ |
1218 | if (clnt->auth_null) |
1219 | ret = rpc_clnt_fill_request (prognum, progver, procnum, |
1220 | xid, NULL((void*)0), &request, NULL((void*)0)); |
1221 | else |
1222 | ret = rpc_clnt_fill_request (prognum, progver, procnum, |
1223 | xid, au, &request, auth_data); |
1224 | |
1225 | if (ret == -1) { |
1226 | gf_log (clnt->conn.trans->name, GF_LOG_WARNING,do { do { if (0) printf ("cannot build a rpc-request xid (%""ll" "u"")", xid); } while (0); _gf_log (clnt->conn.trans-> name, "rpc-clnt.c", __FUNCTION__, 1227, GF_LOG_WARNING, "cannot build a rpc-request xid (%" "ll" "u"")", xid); } while (0) |
1227 | "cannot build a rpc-request xid (%"PRIu64")", xid)do { do { if (0) printf ("cannot build a rpc-request xid (%""ll" "u"")", xid); } while (0); _gf_log (clnt->conn.trans-> name, "rpc-clnt.c", __FUNCTION__, 1227, GF_LOG_WARNING, "cannot build a rpc-request xid (%" "ll" "u"")", xid); } while (0); |
1228 | goto out; |
1229 | } |
1230 | |
1231 | xdr_size = xdr_sizeof ((xdrproc_t)xdr_callmsg, &request); |
1232 | |
1233 | /* First, try to get a pointer into the buffer which the RPC |
1234 | * layer can use. |
1235 | */ |
1236 | request_iob = iobuf_get2 (clnt->ctx->iobuf_pool, (xdr_size + hdrsize)); |
1237 | if (!request_iob) { |
1238 | goto out; |
1239 | } |
1240 | |
1241 | pagesize = iobuf_pagesize (request_iob)(request_iob->iobuf_arena->page_size); |
1242 | |
1243 | record = iobuf_ptr (request_iob)((request_iob)->ptr); /* Now we have it. */ |
1244 | |
1245 | recordhdr = rpc_clnt_record_build_header (record, pagesize, &request, |
1246 | hdrsize); |
1247 | |
1248 | if (!recordhdr.iov_base) { |
1249 | gf_log (clnt->conn.trans->name, GF_LOG_ERROR,do { do { if (0) printf ("Failed to build record header"); } while (0); _gf_log (clnt->conn.trans->name, "rpc-clnt.c", __FUNCTION__ , 1250, GF_LOG_ERROR, "Failed to build record header"); } while (0) |
1250 | "Failed to build record header")do { do { if (0) printf ("Failed to build record header"); } while (0); _gf_log (clnt->conn.trans->name, "rpc-clnt.c", __FUNCTION__ , 1250, GF_LOG_ERROR, "Failed to build record header"); } while (0); |
1251 | iobuf_unref (request_iob); |
1252 | request_iob = NULL((void*)0); |
1253 | recbuf->iov_base = NULL((void*)0); |
1254 | goto out; |
1255 | } |
1256 | |
1257 | recbuf->iov_base = recordhdr.iov_base; |
1258 | recbuf->iov_len = recordhdr.iov_len; |
1259 | |
1260 | out: |
1261 | return request_iob; |
1262 | } |
1263 | |
1264 | |
1265 | struct iobuf * |
1266 | rpc_clnt_record (struct rpc_clnt *clnt, call_frame_t *call_frame, |
1267 | rpc_clnt_prog_t *prog, int procnum, size_t hdrlen, |
1268 | struct iovec *rpchdr, uint64_t callid) |
1269 | { |
1270 | struct auth_glusterfs_parms_v2 au = {0, }; |
1271 | struct iobuf *request_iob = NULL((void*)0); |
1272 | char owner[4] = {0,}; |
1273 | |
1274 | if (!prog || !rpchdr || !call_frame) { |
1275 | goto out; |
1276 | } |
1277 | |
1278 | au.pid = call_frame->root->pid; |
1279 | au.uid = call_frame->root->uid; |
1280 | au.gid = call_frame->root->gid; |
1281 | au.groups.groups_len = call_frame->root->ngrps; |
1282 | au.lk_owner.lk_owner_len = call_frame->root->lk_owner.len; |
1283 | |
1284 | if (au.groups.groups_len) |
1285 | au.groups.groups_val = call_frame->root->groups; |
1286 | |
1287 | if (call_frame->root->lk_owner.len) |
1288 | au.lk_owner.lk_owner_val = call_frame->root->lk_owner.data; |
1289 | else { |
1290 | owner[0] = (char)(au.pid & 0xff); |
1291 | owner[1] = (char)((au.pid >> 8) & 0xff); |
1292 | owner[2] = (char)((au.pid >> 16) & 0xff); |
1293 | owner[3] = (char)((au.pid >> 24) & 0xff); |
1294 | |
1295 | au.lk_owner.lk_owner_val = owner; |
1296 | au.lk_owner.lk_owner_len = 4; |
1297 | } |
1298 | |
1299 | gf_log (clnt->conn.trans->name, GF_LOG_TRACE, "Auth Info: pid: %u, uid: %d"do { do { if (0) printf ("Auth Info: pid: %u, uid: %d" ", gid: %d, owner: %s" , au.pid, au.uid, au.gid, lkowner_utoa (&call_frame->root ->lk_owner)); } while (0); _gf_log (clnt->conn.trans-> name, "rpc-clnt.c", __FUNCTION__, 1301, GF_LOG_TRACE, "Auth Info: pid: %u, uid: %d" ", gid: %d, owner: %s", au.pid, au.uid, au.gid, lkowner_utoa (&call_frame->root->lk_owner)); } while (0) |
1300 | ", gid: %d, owner: %s", au.pid, au.uid, au.gid,do { do { if (0) printf ("Auth Info: pid: %u, uid: %d" ", gid: %d, owner: %s" , au.pid, au.uid, au.gid, lkowner_utoa (&call_frame->root ->lk_owner)); } while (0); _gf_log (clnt->conn.trans-> name, "rpc-clnt.c", __FUNCTION__, 1301, GF_LOG_TRACE, "Auth Info: pid: %u, uid: %d" ", gid: %d, owner: %s", au.pid, au.uid, au.gid, lkowner_utoa (&call_frame->root->lk_owner)); } while (0) |
1301 | lkowner_utoa (&call_frame->root->lk_owner))do { do { if (0) printf ("Auth Info: pid: %u, uid: %d" ", gid: %d, owner: %s" , au.pid, au.uid, au.gid, lkowner_utoa (&call_frame->root ->lk_owner)); } while (0); _gf_log (clnt->conn.trans-> name, "rpc-clnt.c", __FUNCTION__, 1301, GF_LOG_TRACE, "Auth Info: pid: %u, uid: %d" ", gid: %d, owner: %s", au.pid, au.uid, au.gid, lkowner_utoa (&call_frame->root->lk_owner)); } while (0); |
1302 | |
1303 | request_iob = rpc_clnt_record_build_record (clnt, prog->prognum, |
1304 | prog->progver, |
1305 | procnum, hdrlen, |
1306 | callid, &au, |
1307 | rpchdr); |
1308 | if (!request_iob) { |
1309 | gf_log (clnt->conn.trans->name, GF_LOG_WARNING,do { do { if (0) printf ("cannot build rpc-record"); } while ( 0); _gf_log (clnt->conn.trans->name, "rpc-clnt.c", __FUNCTION__ , 1310, GF_LOG_WARNING, "cannot build rpc-record"); } while ( 0) |
1310 | "cannot build rpc-record")do { do { if (0) printf ("cannot build rpc-record"); } while ( 0); _gf_log (clnt->conn.trans->name, "rpc-clnt.c", __FUNCTION__ , 1310, GF_LOG_WARNING, "cannot build rpc-record"); } while ( 0); |
1311 | goto out; |
1312 | } |
1313 | |
1314 | out: |
1315 | return request_iob; |
1316 | } |
1317 | |
1318 | int |
1319 | rpcclnt_cbk_program_register (struct rpc_clnt *clnt, |
1320 | rpcclnt_cb_program_t *program, void *mydata) |
1321 | { |
1322 | int ret = -1; |
1323 | char already_registered = 0; |
1324 | rpcclnt_cb_program_t *tmp = NULL((void*)0); |
1325 | |
1326 | if (!clnt) |
1327 | goto out; |
1328 | |
1329 | if (program->actors == NULL((void*)0)) |
1330 | goto out; |
1331 | |
1332 | pthread_mutex_lock (&clnt->lock); |
1333 | { |
1334 | list_for_each_entry (tmp, &clnt->programs, program)for (tmp = ((typeof(*tmp) *)((char *)((&clnt->programs )->next)-(unsigned long)(&((typeof(*tmp) *)0)->program ))); &tmp->program != (&clnt->programs); tmp = ( (typeof(*tmp) *)((char *)(tmp->program.next)-(unsigned long )(&((typeof(*tmp) *)0)->program)))) { |
1335 | if ((program->prognum == tmp->prognum) |
1336 | && (program->progver == tmp->progver)) { |
1337 | already_registered = 1; |
1338 | break; |
1339 | } |
1340 | } |
1341 | } |
1342 | pthread_mutex_unlock (&clnt->lock); |
1343 | |
1344 | if (already_registered) { |
1345 | gf_log_callingfn (clnt->conn.trans->name, GF_LOG_DEBUG,do { do { if (0) printf ("already registered"); } while (0); _gf_log_callingfn (clnt->conn.trans->name, "rpc-clnt.c", __FUNCTION__, 1346 , GF_LOG_DEBUG, "already registered"); } while (0) |
1346 | "already registered")do { do { if (0) printf ("already registered"); } while (0); _gf_log_callingfn (clnt->conn.trans->name, "rpc-clnt.c", __FUNCTION__, 1346 , GF_LOG_DEBUG, "already registered"); } while (0); |
1347 | ret = 0; |
1348 | goto out; |
1349 | } |
1350 | |
1351 | tmp = GF_CALLOC (1, sizeof (*tmp),__gf_calloc (1, sizeof (*tmp), gf_common_mt_rpcclnt_cb_program_t ) |
1352 | gf_common_mt_rpcclnt_cb_program_t)__gf_calloc (1, sizeof (*tmp), gf_common_mt_rpcclnt_cb_program_t ); |
1353 | if (tmp == NULL((void*)0)) { |
1354 | goto out; |
1355 | } |
1356 | |
1357 | memcpy (tmp, program, sizeof (*tmp)); |
1358 | INIT_LIST_HEAD (&tmp->program)do { (&tmp->program)->next = (&tmp->program) ->prev = &tmp->program; } while (0); |
1359 | |
1360 | tmp->mydata = mydata; |
1361 | |
1362 | pthread_mutex_lock (&clnt->lock); |
1363 | { |
1364 | list_add_tail (&tmp->program, &clnt->programs); |
1365 | } |
1366 | pthread_mutex_unlock (&clnt->lock); |
1367 | |
1368 | ret = 0; |
1369 | gf_log (clnt->conn.trans->name, GF_LOG_DEBUG,do { do { if (0) printf ("New program registered: %s, Num: %d, Ver: %d" , program->progname, program->prognum, program->progver ); } while (0); _gf_log (clnt->conn.trans->name, "rpc-clnt.c" , __FUNCTION__, 1372, GF_LOG_DEBUG, "New program registered: %s, Num: %d, Ver: %d" , program->progname, program->prognum, program->progver ); } while (0) |
1370 | "New program registered: %s, Num: %d, Ver: %d",do { do { if (0) printf ("New program registered: %s, Num: %d, Ver: %d" , program->progname, program->prognum, program->progver ); } while (0); _gf_log (clnt->conn.trans->name, "rpc-clnt.c" , __FUNCTION__, 1372, GF_LOG_DEBUG, "New program registered: %s, Num: %d, Ver: %d" , program->progname, program->prognum, program->progver ); } while (0) |
1371 | program->progname, program->prognum,do { do { if (0) printf ("New program registered: %s, Num: %d, Ver: %d" , program->progname, program->prognum, program->progver ); } while (0); _gf_log (clnt->conn.trans->name, "rpc-clnt.c" , __FUNCTION__, 1372, GF_LOG_DEBUG, "New program registered: %s, Num: %d, Ver: %d" , program->progname, program->prognum, program->progver ); } while (0) |
1372 | program->progver)do { do { if (0) printf ("New program registered: %s, Num: %d, Ver: %d" , program->progname, program->prognum, program->progver ); } while (0); _gf_log (clnt->conn.trans->name, "rpc-clnt.c" , __FUNCTION__, 1372, GF_LOG_DEBUG, "New program registered: %s, Num: %d, Ver: %d" , program->progname, program->prognum, program->progver ); } while (0); |
1373 | |
1374 | out: |
1375 | if (ret == -1) { |
1376 | gf_log (clnt->conn.trans->name, GF_LOG_ERROR,do { do { if (0) printf ("Program registration failed:" " %s, Num: %d, Ver: %d" , program->progname, program->prognum, program->progver ); } while (0); _gf_log (clnt->conn.trans->name, "rpc-clnt.c" , __FUNCTION__, 1379, GF_LOG_ERROR, "Program registration failed:" " %s, Num: %d, Ver: %d", program->progname, program->prognum , program->progver); } while (0) |
1377 | "Program registration failed:"do { do { if (0) printf ("Program registration failed:" " %s, Num: %d, Ver: %d" , program->progname, program->prognum, program->progver ); } while (0); _gf_log (clnt->conn.trans->name, "rpc-clnt.c" , __FUNCTION__, 1379, GF_LOG_ERROR, "Program registration failed:" " %s, Num: %d, Ver: %d", program->progname, program->prognum , program->progver); } while (0) |
1378 | " %s, Num: %d, Ver: %d", program->progname,do { do { if (0) printf ("Program registration failed:" " %s, Num: %d, Ver: %d" , program->progname, program->prognum, program->progver ); } while (0); _gf_log (clnt->conn.trans->name, "rpc-clnt.c" , __FUNCTION__, 1379, GF_LOG_ERROR, "Program registration failed:" " %s, Num: %d, Ver: %d", program->progname, program->prognum , program->progver); } while (0) |
1379 | program->prognum, program->progver)do { do { if (0) printf ("Program registration failed:" " %s, Num: %d, Ver: %d" , program->progname, program->prognum, program->progver ); } while (0); _gf_log (clnt->conn.trans->name, "rpc-clnt.c" , __FUNCTION__, 1379, GF_LOG_ERROR, "Program registration failed:" " %s, Num: %d, Ver: %d", program->progname, program->prognum , program->progver); } while (0); |
1380 | } |
1381 | |
1382 | return ret; |
1383 | } |
1384 | |
1385 | |
1386 | int |
1387 | rpc_clnt_submit (struct rpc_clnt *rpc, rpc_clnt_prog_t *prog, |
1388 | int procnum, fop_cbk_fn_t cbkfn, |
1389 | struct iovec *proghdr, int proghdrcount, |
1390 | struct iovec *progpayload, int progpayloadcount, |
1391 | struct iobref *iobref, void *frame, struct iovec *rsphdr, |
1392 | int rsphdr_count, struct iovec *rsp_payload, |
1393 | int rsp_payload_count, struct iobref *rsp_iobref) |
1394 | { |
1395 | rpc_clnt_connection_t *conn = NULL((void*)0); |
1396 | struct iobuf *request_iob = NULL((void*)0); |
1397 | struct iovec rpchdr = {0,}; |
1398 | struct rpc_req *rpcreq = NULL((void*)0); |
1399 | rpc_transport_req_t req; |
1400 | int ret = -1; |
1401 | int proglen = 0; |
1402 | char new_iobref = 0; |
1403 | uint64_t callid = 0; |
1404 | |
1405 | if (!rpc || !prog || !frame) { |
1406 | goto out; |
1407 | } |
1408 | |
1409 | conn = &rpc->conn; |
1410 | |
1411 | if (conn->trans == NULL((void*)0)) { |
1412 | goto out; |
1413 | } |
1414 | |
1415 | rpcreq = mem_get (rpc->reqpool); |
1416 | if (rpcreq == NULL((void*)0)) { |
1417 | goto out; |
1418 | } |
1419 | |
1420 | memset (rpcreq, 0, sizeof (*rpcreq)); |
1421 | memset (&req, 0, sizeof (req)); |
1422 | |
1423 | if (!iobref) { |
1424 | iobref = iobref_new (); |
1425 | if (!iobref) { |
1426 | goto out; |
1427 | } |
1428 | |
1429 | new_iobref = 1; |
1430 | } |
1431 | |
1432 | callid = rpc_clnt_new_callid (rpc); |
1433 | |
1434 | rpcreq->prog = prog; |
1435 | rpcreq->procnum = procnum; |
1436 | rpcreq->conn = conn; |
1437 | rpcreq->xid = callid; |
1438 | rpcreq->cbkfn = cbkfn; |
1439 | |
1440 | ret = -1; |
1441 | |
1442 | if (proghdr) { |
1443 | proglen += iov_length (proghdr, proghdrcount); |
1444 | } |
1445 | |
1446 | request_iob = rpc_clnt_record (rpc, frame, prog, |
1447 | procnum, proglen, |
1448 | &rpchdr, callid); |
1449 | if (!request_iob) { |
1450 | gf_log (conn->trans->name, GF_LOG_WARNING,do { do { if (0) printf ("cannot build rpc-record"); } while ( 0); _gf_log (conn->trans->name, "rpc-clnt.c", __FUNCTION__ , 1451, GF_LOG_WARNING, "cannot build rpc-record"); } while ( 0) |
1451 | "cannot build rpc-record")do { do { if (0) printf ("cannot build rpc-record"); } while ( 0); _gf_log (conn->trans->name, "rpc-clnt.c", __FUNCTION__ , 1451, GF_LOG_WARNING, "cannot build rpc-record"); } while ( 0); |
1452 | goto out; |
1453 | } |
1454 | |
1455 | iobref_add (iobref, request_iob); |
1456 | |
1457 | req.msg.rpchdr = &rpchdr; |
1458 | req.msg.rpchdrcount = 1; |
1459 | req.msg.proghdr = proghdr; |
1460 | req.msg.proghdrcount = proghdrcount; |
1461 | req.msg.progpayload = progpayload; |
1462 | req.msg.progpayloadcount = progpayloadcount; |
1463 | req.msg.iobref = iobref; |
1464 | |
1465 | req.rsp.rsphdr = rsphdr; |
1466 | req.rsp.rsphdr_count = rsphdr_count; |
1467 | req.rsp.rsp_payload = rsp_payload; |
1468 | req.rsp.rsp_payload_count = rsp_payload_count; |
1469 | req.rsp.rsp_iobref = rsp_iobref; |
1470 | req.rpc_req = rpcreq; |
1471 | |
1472 | pthread_mutex_lock (&conn->lock); |
1473 | { |
1474 | if (conn->connected == 0) { |
1475 | ret = rpc_transport_connect (conn->trans, |
1476 | conn->config.remote_port); |
1477 | } |
1478 | |
1479 | ret = rpc_transport_submit_request (rpc->conn.trans, |
1480 | &req); |
1481 | if (ret == -1) { |
1482 | gf_log (conn->trans->name, GF_LOG_WARNING,do { do { if (0) printf ("failed to submit rpc-request " "(XID: 0x%ux Program: %s, ProgVers: %d, " "Proc: %d) to rpc-transport (%s)", rpcreq->xid, rpcreq-> prog->progname, rpcreq->prog->progver, rpcreq->procnum , rpc->conn.trans->name); } while (0); _gf_log (conn-> trans->name, "rpc-clnt.c", __FUNCTION__, 1487, GF_LOG_WARNING , "failed to submit rpc-request " "(XID: 0x%ux Program: %s, ProgVers: %d, " "Proc: %d) to rpc-transport (%s)", rpcreq->xid, rpcreq-> prog->progname, rpcreq->prog->progver, rpcreq->procnum , rpc->conn.trans->name); } while (0) |
1483 | "failed to submit rpc-request "do { do { if (0) printf ("failed to submit rpc-request " "(XID: 0x%ux Program: %s, ProgVers: %d, " "Proc: %d) to rpc-transport (%s)", rpcreq->xid, rpcreq-> prog->progname, rpcreq->prog->progver, rpcreq->procnum , rpc->conn.trans->name); } while (0); _gf_log (conn-> trans->name, "rpc-clnt.c", __FUNCTION__, 1487, GF_LOG_WARNING , "failed to submit rpc-request " "(XID: 0x%ux Program: %s, ProgVers: %d, " "Proc: %d) to rpc-transport (%s)", rpcreq->xid, rpcreq-> prog->progname, rpcreq->prog->progver, rpcreq->procnum , rpc->conn.trans->name); } while (0) |
1484 | "(XID: 0x%ux Program: %s, ProgVers: %d, "do { do { if (0) printf ("failed to submit rpc-request " "(XID: 0x%ux Program: %s, ProgVers: %d, " "Proc: %d) to rpc-transport (%s)", rpcreq->xid, rpcreq-> prog->progname, rpcreq->prog->progver, rpcreq->procnum , rpc->conn.trans->name); } while (0); _gf_log (conn-> trans->name, "rpc-clnt.c", __FUNCTION__, 1487, GF_LOG_WARNING , "failed to submit rpc-request " "(XID: 0x%ux Program: %s, ProgVers: %d, " "Proc: %d) to rpc-transport (%s)", rpcreq->xid, rpcreq-> prog->progname, rpcreq->prog->progver, rpcreq->procnum , rpc->conn.trans->name); } while (0) |
1485 | "Proc: %d) to rpc-transport (%s)", rpcreq->xid,do { do { if (0) printf ("failed to submit rpc-request " "(XID: 0x%ux Program: %s, ProgVers: %d, " "Proc: %d) to rpc-transport (%s)", rpcreq->xid, rpcreq-> prog->progname, rpcreq->prog->progver, rpcreq->procnum , rpc->conn.trans->name); } while (0); _gf_log (conn-> trans->name, "rpc-clnt.c", __FUNCTION__, 1487, GF_LOG_WARNING , "failed to submit rpc-request " "(XID: 0x%ux Program: %s, ProgVers: %d, " "Proc: %d) to rpc-transport (%s)", rpcreq->xid, rpcreq-> prog->progname, rpcreq->prog->progver, rpcreq->procnum , rpc->conn.trans->name); } while (0) |
1486 | rpcreq->prog->progname, rpcreq->prog->progver,do { do { if (0) printf ("failed to submit rpc-request " "(XID: 0x%ux Program: %s, ProgVers: %d, " "Proc: %d) to rpc-transport (%s)", rpcreq->xid, rpcreq-> prog->progname, rpcreq->prog->progver, rpcreq->procnum , rpc->conn.trans->name); } while (0); _gf_log (conn-> trans->name, "rpc-clnt.c", __FUNCTION__, 1487, GF_LOG_WARNING , "failed to submit rpc-request " "(XID: 0x%ux Program: %s, ProgVers: %d, " "Proc: %d) to rpc-transport (%s)", rpcreq->xid, rpcreq-> prog->progname, rpcreq->prog->progver, rpcreq->procnum , rpc->conn.trans->name); } while (0) |
1487 | rpcreq->procnum, rpc->conn.trans->name)do { do { if (0) printf ("failed to submit rpc-request " "(XID: 0x%ux Program: %s, ProgVers: %d, " "Proc: %d) to rpc-transport (%s)", rpcreq->xid, rpcreq-> prog->progname, rpcreq->prog->progver, rpcreq->procnum , rpc->conn.trans->name); } while (0); _gf_log (conn-> trans->name, "rpc-clnt.c", __FUNCTION__, 1487, GF_LOG_WARNING , "failed to submit rpc-request " "(XID: 0x%ux Program: %s, ProgVers: %d, " "Proc: %d) to rpc-transport (%s)", rpcreq->xid, rpcreq-> prog->progname, rpcreq->prog->progver, rpcreq->procnum , rpc->conn.trans->name); } while (0); |
1488 | } |
1489 | |
1490 | if ((ret >= 0) && frame) { |
1491 | /* Save the frame in queue */ |
1492 | __save_frame (rpc, frame, rpcreq); |
1493 | |
1494 | gf_log ("rpc-clnt", GF_LOG_TRACE, "submitted request "do { do { if (0) printf ("submitted request " "(XID: 0x%ux Program: %s, ProgVers: %d, " "Proc: %d) to rpc-transport (%s)", rpcreq->xid, rpcreq-> prog->progname, rpcreq->prog->progver, rpcreq->procnum , rpc->conn.trans->name); } while (0); _gf_log ("rpc-clnt" , "rpc-clnt.c", __FUNCTION__, 1498, GF_LOG_TRACE, "submitted request " "(XID: 0x%ux Program: %s, ProgVers: %d, " "Proc: %d) to rpc-transport (%s)" , rpcreq->xid, rpcreq->prog->progname, rpcreq->prog ->progver, rpcreq->procnum, rpc->conn.trans->name ); } while (0) |
1495 | "(XID: 0x%ux Program: %s, ProgVers: %d, "do { do { if (0) printf ("submitted request " "(XID: 0x%ux Program: %s, ProgVers: %d, " "Proc: %d) to rpc-transport (%s)", rpcreq->xid, rpcreq-> prog->progname, rpcreq->prog->progver, rpcreq->procnum , rpc->conn.trans->name); } while (0); _gf_log ("rpc-clnt" , "rpc-clnt.c", __FUNCTION__, 1498, GF_LOG_TRACE, "submitted request " "(XID: 0x%ux Program: %s, ProgVers: %d, " "Proc: %d) to rpc-transport (%s)" , rpcreq->xid, rpcreq->prog->progname, rpcreq->prog ->progver, rpcreq->procnum, rpc->conn.trans->name ); } while (0) |
1496 | "Proc: %d) to rpc-transport (%s)", rpcreq->xid,do { do { if (0) printf ("submitted request " "(XID: 0x%ux Program: %s, ProgVers: %d, " "Proc: %d) to rpc-transport (%s)", rpcreq->xid, rpcreq-> prog->progname, rpcreq->prog->progver, rpcreq->procnum , rpc->conn.trans->name); } while (0); _gf_log ("rpc-clnt" , "rpc-clnt.c", __FUNCTION__, 1498, GF_LOG_TRACE, "submitted request " "(XID: 0x%ux Program: %s, ProgVers: %d, " "Proc: %d) to rpc-transport (%s)" , rpcreq->xid, rpcreq->prog->progname, rpcreq->prog ->progver, rpcreq->procnum, rpc->conn.trans->name ); } while (0) |
1497 | rpcreq->prog->progname, rpcreq->prog->progver,do { do { if (0) printf ("submitted request " "(XID: 0x%ux Program: %s, ProgVers: %d, " "Proc: %d) to rpc-transport (%s)", rpcreq->xid, rpcreq-> prog->progname, rpcreq->prog->progver, rpcreq->procnum , rpc->conn.trans->name); } while (0); _gf_log ("rpc-clnt" , "rpc-clnt.c", __FUNCTION__, 1498, GF_LOG_TRACE, "submitted request " "(XID: 0x%ux Program: %s, ProgVers: %d, " "Proc: %d) to rpc-transport (%s)" , rpcreq->xid, rpcreq->prog->progname, rpcreq->prog ->progver, rpcreq->procnum, rpc->conn.trans->name ); } while (0) |
1498 | rpcreq->procnum, rpc->conn.trans->name)do { do { if (0) printf ("submitted request " "(XID: 0x%ux Program: %s, ProgVers: %d, " "Proc: %d) to rpc-transport (%s)", rpcreq->xid, rpcreq-> prog->progname, rpcreq->prog->progver, rpcreq->procnum , rpc->conn.trans->name); } while (0); _gf_log ("rpc-clnt" , "rpc-clnt.c", __FUNCTION__, 1498, GF_LOG_TRACE, "submitted request " "(XID: 0x%ux Program: %s, ProgVers: %d, " "Proc: %d) to rpc-transport (%s)" , rpcreq->xid, rpcreq->prog->progname, rpcreq->prog ->progver, rpcreq->procnum, rpc->conn.trans->name ); } while (0); |
1499 | } |
1500 | } |
1501 | pthread_mutex_unlock (&conn->lock); |
1502 | |
1503 | if (ret == -1) { |
1504 | goto out; |
1505 | } |
1506 | |
1507 | ret = 0; |
1508 | |
1509 | out: |
1510 | if (request_iob) { |
1511 | iobuf_unref (request_iob); |
1512 | } |
1513 | |
1514 | if (new_iobref && iobref) { |
1515 | iobref_unref (iobref); |
1516 | } |
1517 | |
1518 | if (frame && (ret == -1)) { |
1519 | if (rpcreq) { |
1520 | rpcreq->rpc_status = -1; |
1521 | cbkfn (rpcreq, NULL((void*)0), 0, frame); |
1522 | mem_put (rpcreq); |
1523 | } |
1524 | } |
1525 | return ret; |
1526 | } |
1527 | |
1528 | |
1529 | struct rpc_clnt * |
1530 | rpc_clnt_ref (struct rpc_clnt *rpc) |
1531 | { |
1532 | if (!rpc) |
1533 | return NULL((void*)0); |
1534 | pthread_mutex_lock (&rpc->lock); |
1535 | { |
1536 | rpc->refcount++; |
1537 | } |
1538 | pthread_mutex_unlock (&rpc->lock); |
1539 | return rpc; |
1540 | } |
1541 | |
1542 | |
1543 | static void |
1544 | rpc_clnt_destroy (struct rpc_clnt *rpc) |
1545 | { |
1546 | if (!rpc) |
1547 | return; |
1548 | |
1549 | if (rpc->conn.trans) { |
1550 | rpc_transport_unregister_notify (rpc->conn.trans); |
1551 | rpc_transport_disconnect (rpc->conn.trans); |
1552 | rpc_transport_unref (rpc->conn.trans); |
1553 | } |
1554 | |
1555 | rpc_clnt_reconnect_cleanup (&rpc->conn); |
1556 | saved_frames_destroy (rpc->conn.saved_frames); |
1557 | pthread_mutex_destroy (&rpc->lock); |
1558 | pthread_mutex_destroy (&rpc->conn.lock); |
1559 | |
1560 | /* mem-pool should be destroyed, otherwise, |
1561 | it will cause huge memory leaks */ |
1562 | mem_pool_destroy (rpc->reqpool); |
1563 | mem_pool_destroy (rpc->saved_frames_pool); |
1564 | |
1565 | GF_FREE (rpc)__gf_free (rpc); |
1566 | return; |
1567 | } |
1568 | |
1569 | struct rpc_clnt * |
1570 | rpc_clnt_unref (struct rpc_clnt *rpc) |
1571 | { |
1572 | int count = 0; |
1573 | |
1574 | if (!rpc) |
1575 | return NULL((void*)0); |
1576 | pthread_mutex_lock (&rpc->lock); |
1577 | { |
1578 | count = --rpc->refcount; |
1579 | } |
1580 | pthread_mutex_unlock (&rpc->lock); |
1581 | if (!count) { |
1582 | rpc_clnt_destroy (rpc); |
1583 | return NULL((void*)0); |
1584 | } |
1585 | return rpc; |
1586 | } |
1587 | |
1588 | |
1589 | void |
1590 | rpc_clnt_disable (struct rpc_clnt *rpc) |
1591 | { |
1592 | rpc_clnt_connection_t *conn = NULL((void*)0); |
1593 | |
1594 | if (!rpc) { |
1595 | goto out; |
1596 | } |
1597 | |
1598 | conn = &rpc->conn; |
1599 | |
1600 | pthread_mutex_lock (&conn->lock); |
1601 | { |
1602 | rpc->disabled = 1; |
1603 | |
1604 | if (conn->timer) { |
1605 | gf_timer_call_cancel (rpc->ctx, conn->timer); |
1606 | conn->timer = NULL((void*)0); |
1607 | } |
1608 | |
1609 | if (conn->reconnect) { |
1610 | gf_timer_call_cancel (rpc->ctx, conn->reconnect); |
1611 | conn->reconnect = NULL((void*)0); |
1612 | } |
1613 | conn->connected = 0; |
1614 | |
1615 | if (conn->ping_timer) { |
1616 | gf_timer_call_cancel (rpc->ctx, conn->ping_timer); |
1617 | conn->ping_timer = NULL((void*)0); |
1618 | conn->ping_started = 0; |
1619 | } |
1620 | |
1621 | } |
1622 | pthread_mutex_unlock (&conn->lock); |
1623 | |
1624 | rpc_transport_disconnect (rpc->conn.trans); |
1625 | |
1626 | out: |
1627 | return; |
1628 | } |
1629 | |
1630 | |
1631 | void |
1632 | rpc_clnt_reconfig (struct rpc_clnt *rpc, struct rpc_clnt_config *config) |
1633 | { |
1634 | if (config->rpc_timeout) { |
1635 | if (config->rpc_timeout != rpc->conn.config.rpc_timeout) |
1636 | gf_log (rpc->conn.trans->name, GF_LOG_INFO,do { do { if (0) printf ("changing timeout to %d (from %d)", config ->rpc_timeout, rpc->conn.config.rpc_timeout); } while ( 0); _gf_log (rpc->conn.trans->name, "rpc-clnt.c", __FUNCTION__ , 1639, GF_LOG_INFO, "changing timeout to %d (from %d)", config ->rpc_timeout, rpc->conn.config.rpc_timeout); } while ( 0) |
1637 | "changing timeout to %d (from %d)",do { do { if (0) printf ("changing timeout to %d (from %d)", config ->rpc_timeout, rpc->conn.config.rpc_timeout); } while ( 0); _gf_log (rpc->conn.trans->name, "rpc-clnt.c", __FUNCTION__ , 1639, GF_LOG_INFO, "changing timeout to %d (from %d)", config ->rpc_timeout, rpc->conn.config.rpc_timeout); } while ( 0) |
1638 | config->rpc_timeout,do { do { if (0) printf ("changing timeout to %d (from %d)", config ->rpc_timeout, rpc->conn.config.rpc_timeout); } while ( 0); _gf_log (rpc->conn.trans->name, "rpc-clnt.c", __FUNCTION__ , 1639, GF_LOG_INFO, "changing timeout to %d (from %d)", config ->rpc_timeout, rpc->conn.config.rpc_timeout); } while ( 0) |
1639 | rpc->conn.config.rpc_timeout)do { do { if (0) printf ("changing timeout to %d (from %d)", config ->rpc_timeout, rpc->conn.config.rpc_timeout); } while ( 0); _gf_log (rpc->conn.trans->name, "rpc-clnt.c", __FUNCTION__ , 1639, GF_LOG_INFO, "changing timeout to %d (from %d)", config ->rpc_timeout, rpc->conn.config.rpc_timeout); } while ( 0); |
1640 | rpc->conn.config.rpc_timeout = config->rpc_timeout; |
1641 | } |
1642 | |
1643 | if (config->remote_port) { |
1644 | if (config->remote_port != rpc->conn.config.remote_port) |
1645 | gf_log (rpc->conn.trans->name, GF_LOG_INFO,do { do { if (0) printf ("changing port to %d (from %d)", config ->remote_port, rpc->conn.config.remote_port); } while ( 0); _gf_log (rpc->conn.trans->name, "rpc-clnt.c", __FUNCTION__ , 1648, GF_LOG_INFO, "changing port to %d (from %d)", config-> remote_port, rpc->conn.config.remote_port); } while (0) |
1646 | "changing port to %d (from %d)",do { do { if (0) printf ("changing port to %d (from %d)", config ->remote_port, rpc->conn.config.remote_port); } while ( 0); _gf_log (rpc->conn.trans->name, "rpc-clnt.c", __FUNCTION__ , 1648, GF_LOG_INFO, "changing port to %d (from %d)", config-> remote_port, rpc->conn.config.remote_port); } while (0) |
1647 | config->remote_port,do { do { if (0) printf ("changing port to %d (from %d)", config ->remote_port, rpc->conn.config.remote_port); } while ( 0); _gf_log (rpc->conn.trans->name, "rpc-clnt.c", __FUNCTION__ , 1648, GF_LOG_INFO, "changing port to %d (from %d)", config-> remote_port, rpc->conn.config.remote_port); } while (0) |
1648 | rpc->conn.config.remote_port)do { do { if (0) printf ("changing port to %d (from %d)", config ->remote_port, rpc->conn.config.remote_port); } while ( 0); _gf_log (rpc->conn.trans->name, "rpc-clnt.c", __FUNCTION__ , 1648, GF_LOG_INFO, "changing port to %d (from %d)", config-> remote_port, rpc->conn.config.remote_port); } while (0); |
1649 | |
1650 | rpc->conn.config.remote_port = config->remote_port; |
1651 | } |
1652 | |
1653 | if (config->remote_host) { |
1654 | if (rpc->conn.config.remote_host) { |
1655 | if (strcmp (rpc->conn.config.remote_host, |
1656 | config->remote_host)) |
1657 | gf_log (rpc->conn.trans->name, GF_LOG_INFO,do { do { if (0) printf ("changing hostname to %s (from %s)", config->remote_host, rpc->conn.config.remote_host); } while (0); _gf_log (rpc->conn.trans->name, "rpc-clnt.c", __FUNCTION__ , 1660, GF_LOG_INFO, "changing hostname to %s (from %s)", config ->remote_host, rpc->conn.config.remote_host); } while ( 0) |
1658 | "changing hostname to %s (from %s)",do { do { if (0) printf ("changing hostname to %s (from %s)", config->remote_host, rpc->conn.config.remote_host); } while (0); _gf_log (rpc->conn.trans->name, "rpc-clnt.c", __FUNCTION__ , 1660, GF_LOG_INFO, "changing hostname to %s (from %s)", config ->remote_host, rpc->conn.config.remote_host); } while ( 0) |
1659 | config->remote_host,do { do { if (0) printf ("changing hostname to %s (from %s)", config->remote_host, rpc->conn.config.remote_host); } while (0); _gf_log (rpc->conn.trans->name, "rpc-clnt.c", __FUNCTION__ , 1660, GF_LOG_INFO, "changing hostname to %s (from %s)", config ->remote_host, rpc->conn.config.remote_host); } while ( 0) |
1660 | rpc->conn.config.remote_host)do { do { if (0) printf ("changing hostname to %s (from %s)", config->remote_host, rpc->conn.config.remote_host); } while (0); _gf_log (rpc->conn.trans->name, "rpc-clnt.c", __FUNCTION__ , 1660, GF_LOG_INFO, "changing hostname to %s (from %s)", config ->remote_host, rpc->conn.config.remote_host); } while ( 0); |
1661 | FREE (rpc->conn.config.remote_host)if (rpc->conn.config.remote_host != ((void*)0)) { free ((void *)rpc->conn.config.remote_host); rpc->conn.config.remote_host = (void *)0xeeeeeeee; }; |
1662 | } else { |
1663 | gf_log (rpc->conn.trans->name, GF_LOG_INFO,do { do { if (0) printf ("setting hostname to %s", config-> remote_host); } while (0); _gf_log (rpc->conn.trans->name , "rpc-clnt.c", __FUNCTION__, 1665, GF_LOG_INFO, "setting hostname to %s" , config->remote_host); } while (0) |
1664 | "setting hostname to %s",do { do { if (0) printf ("setting hostname to %s", config-> remote_host); } while (0); _gf_log (rpc->conn.trans->name , "rpc-clnt.c", __FUNCTION__, 1665, GF_LOG_INFO, "setting hostname to %s" , config->remote_host); } while (0) |
1665 | config->remote_host)do { do { if (0) printf ("setting hostname to %s", config-> remote_host); } while (0); _gf_log (rpc->conn.trans->name , "rpc-clnt.c", __FUNCTION__, 1665, GF_LOG_INFO, "setting hostname to %s" , config->remote_host); } while (0); |
1666 | } |
1667 | |
1668 | rpc->conn.config.remote_host = gf_strdup (config->remote_host); |
1669 | } |
1670 | } |
1671 | |
1672 | int |
1673 | rpc_clnt_transport_unix_options_build (dict_t **options, char *filepath, |
1674 | int frame_timeout) |
1675 | { |
1676 | dict_t *dict = NULL((void*)0); |
1677 | char *fpath = NULL((void*)0); |
1678 | int ret = -1; |
1679 | |
1680 | GF_ASSERT (filepath)do { if (!(filepath)) { do { do { if (0) printf ("Assertion failed: " "filepath"); } while (0); _gf_log_callingfn ("", "rpc-clnt.c" , __FUNCTION__, 1680, GF_LOG_ERROR, "Assertion failed: " "filepath" ); } while (0); } } while (0); |
1681 | GF_ASSERT (options)do { if (!(options)) { do { do { if (0) printf ("Assertion failed: " "options"); } while (0); _gf_log_callingfn ("", "rpc-clnt.c" , __FUNCTION__, 1681, GF_LOG_ERROR, "Assertion failed: " "options" ); } while (0); } } while (0); |
1682 | |
1683 | dict = dict_new (); |
1684 | if (!dict) |
1685 | goto out; |
1686 | |
1687 | fpath = gf_strdup (filepath); |
1688 | if (!fpath) { |
1689 | ret = -1; |
1690 | goto out; |
1691 | } |
1692 | |
1693 | ret = dict_set_dynstr (dict, "transport.socket.connect-path", fpath); |
1694 | if (ret) |
1695 | goto out; |
1696 | |
1697 | ret = dict_set_str (dict, "transport.address-family", "unix"); |
1698 | if (ret) |
1699 | goto out; |
1700 | |
1701 | ret = dict_set_str (dict, "transport.socket.nodelay", "off"); |
1702 | if (ret) |
1703 | goto out; |
1704 | |
1705 | ret = dict_set_str (dict, "transport-type", "socket"); |
1706 | if (ret) |
1707 | goto out; |
1708 | |
1709 | ret = dict_set_str (dict, "transport.socket.keepalive", "off"); |
1710 | if (ret) |
1711 | goto out; |
1712 | |
1713 | if (frame_timeout > 0) { |
1714 | ret = dict_set_int32 (dict, "frame-timeout", frame_timeout); |
1715 | if (ret) |
1716 | goto out; |
1717 | } |
1718 | |
1719 | *options = dict; |
1720 | out: |
1721 | if (ret) { |
1722 | GF_FREE (fpath)__gf_free (fpath); |
1723 | if (dict) |
1724 | dict_unref (dict); |
1725 | } |
1726 | return ret; |
1727 | } |