1 // SPDX-License-Identifier: GPL-2.0-or-later <<
2 /* AFS Cache Manager Service 1 /* AFS Cache Manager Service
3 * 2 *
4 * Copyright (C) 2002 Red Hat, Inc. All Rights 3 * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.c 4 * Written by David Howells (dhowells@redhat.com)
>> 5 *
>> 6 * This program is free software; you can redistribute it and/or
>> 7 * modify it under the terms of the GNU General Public License
>> 8 * as published by the Free Software Foundation; either version
>> 9 * 2 of the License, or (at your option) any later version.
6 */ 10 */
7 11
8 #include <linux/module.h> 12 #include <linux/module.h>
9 #include <linux/init.h> 13 #include <linux/init.h>
10 #include <linux/slab.h> 14 #include <linux/slab.h>
11 #include <linux/sched.h> 15 #include <linux/sched.h>
12 #include <linux/ip.h> 16 #include <linux/ip.h>
13 #include "internal.h" 17 #include "internal.h"
14 #include "afs_cm.h" 18 #include "afs_cm.h"
15 #include "protocol_yfs.h" <<
16 #define RXRPC_TRACE_ONLY_DEFINE_ENUMS <<
17 #include <trace/events/rxrpc.h> <<
18 19
19 static int afs_deliver_cb_init_call_back_state 20 static int afs_deliver_cb_init_call_back_state(struct afs_call *);
20 static int afs_deliver_cb_init_call_back_state 21 static int afs_deliver_cb_init_call_back_state3(struct afs_call *);
21 static int afs_deliver_cb_probe(struct afs_cal 22 static int afs_deliver_cb_probe(struct afs_call *);
22 static int afs_deliver_cb_callback(struct afs_ 23 static int afs_deliver_cb_callback(struct afs_call *);
23 static int afs_deliver_cb_probe_uuid(struct af 24 static int afs_deliver_cb_probe_uuid(struct afs_call *);
24 static int afs_deliver_cb_tell_me_about_yourse 25 static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *);
25 static void afs_cm_destructor(struct afs_call 26 static void afs_cm_destructor(struct afs_call *);
26 static void SRXAFSCB_CallBack(struct work_stru 27 static void SRXAFSCB_CallBack(struct work_struct *);
27 static void SRXAFSCB_InitCallBackState(struct 28 static void SRXAFSCB_InitCallBackState(struct work_struct *);
28 static void SRXAFSCB_Probe(struct work_struct 29 static void SRXAFSCB_Probe(struct work_struct *);
29 static void SRXAFSCB_ProbeUuid(struct work_str 30 static void SRXAFSCB_ProbeUuid(struct work_struct *);
30 static void SRXAFSCB_TellMeAboutYourself(struc 31 static void SRXAFSCB_TellMeAboutYourself(struct work_struct *);
31 32
32 static int afs_deliver_yfs_cb_callback(struct !! 33 #define CM_NAME(name) \
>> 34 const char afs_SRXCB##name##_name[] __tracepoint_string = \
>> 35 "CB." #name
33 36
34 /* 37 /*
35 * CB.CallBack operation type 38 * CB.CallBack operation type
36 */ 39 */
>> 40 static CM_NAME(CallBack);
37 static const struct afs_call_type afs_SRXCBCal 41 static const struct afs_call_type afs_SRXCBCallBack = {
38 .name = "CB.CallBack", !! 42 .name = afs_SRXCBCallBack_name,
39 .deliver = afs_deliver_cb_callb 43 .deliver = afs_deliver_cb_callback,
40 .destructor = afs_cm_destructor, 44 .destructor = afs_cm_destructor,
41 .work = SRXAFSCB_CallBack, 45 .work = SRXAFSCB_CallBack,
42 }; 46 };
43 47
44 /* 48 /*
45 * CB.InitCallBackState operation type 49 * CB.InitCallBackState operation type
46 */ 50 */
>> 51 static CM_NAME(InitCallBackState);
47 static const struct afs_call_type afs_SRXCBIni 52 static const struct afs_call_type afs_SRXCBInitCallBackState = {
48 .name = "CB.InitCallBackStat !! 53 .name = afs_SRXCBInitCallBackState_name,
49 .deliver = afs_deliver_cb_init_ 54 .deliver = afs_deliver_cb_init_call_back_state,
50 .destructor = afs_cm_destructor, 55 .destructor = afs_cm_destructor,
51 .work = SRXAFSCB_InitCallBac 56 .work = SRXAFSCB_InitCallBackState,
52 }; 57 };
53 58
54 /* 59 /*
55 * CB.InitCallBackState3 operation type 60 * CB.InitCallBackState3 operation type
56 */ 61 */
>> 62 static CM_NAME(InitCallBackState3);
57 static const struct afs_call_type afs_SRXCBIni 63 static const struct afs_call_type afs_SRXCBInitCallBackState3 = {
58 .name = "CB.InitCallBackStat !! 64 .name = afs_SRXCBInitCallBackState3_name,
59 .deliver = afs_deliver_cb_init_ 65 .deliver = afs_deliver_cb_init_call_back_state3,
60 .destructor = afs_cm_destructor, 66 .destructor = afs_cm_destructor,
61 .work = SRXAFSCB_InitCallBac 67 .work = SRXAFSCB_InitCallBackState,
62 }; 68 };
63 69
64 /* 70 /*
65 * CB.Probe operation type 71 * CB.Probe operation type
66 */ 72 */
>> 73 static CM_NAME(Probe);
67 static const struct afs_call_type afs_SRXCBPro 74 static const struct afs_call_type afs_SRXCBProbe = {
68 .name = "CB.Probe", !! 75 .name = afs_SRXCBProbe_name,
69 .deliver = afs_deliver_cb_probe 76 .deliver = afs_deliver_cb_probe,
70 .destructor = afs_cm_destructor, 77 .destructor = afs_cm_destructor,
71 .work = SRXAFSCB_Probe, 78 .work = SRXAFSCB_Probe,
72 }; 79 };
73 80
74 /* 81 /*
75 * CB.ProbeUuid operation type 82 * CB.ProbeUuid operation type
76 */ 83 */
>> 84 static CM_NAME(ProbeUuid);
77 static const struct afs_call_type afs_SRXCBPro 85 static const struct afs_call_type afs_SRXCBProbeUuid = {
78 .name = "CB.ProbeUuid", !! 86 .name = afs_SRXCBProbeUuid_name,
79 .deliver = afs_deliver_cb_probe 87 .deliver = afs_deliver_cb_probe_uuid,
80 .destructor = afs_cm_destructor, 88 .destructor = afs_cm_destructor,
81 .work = SRXAFSCB_ProbeUuid, 89 .work = SRXAFSCB_ProbeUuid,
82 }; 90 };
83 91
84 /* 92 /*
85 * CB.TellMeAboutYourself operation type 93 * CB.TellMeAboutYourself operation type
86 */ 94 */
>> 95 static CM_NAME(TellMeAboutYourself);
87 static const struct afs_call_type afs_SRXCBTel 96 static const struct afs_call_type afs_SRXCBTellMeAboutYourself = {
88 .name = "CB.TellMeAboutYours !! 97 .name = afs_SRXCBTellMeAboutYourself_name,
89 .deliver = afs_deliver_cb_tell_ 98 .deliver = afs_deliver_cb_tell_me_about_yourself,
90 .destructor = afs_cm_destructor, 99 .destructor = afs_cm_destructor,
91 .work = SRXAFSCB_TellMeAbout 100 .work = SRXAFSCB_TellMeAboutYourself,
92 }; 101 };
93 102
94 /* 103 /*
95 * YFS CB.CallBack operation type <<
96 */ <<
97 static const struct afs_call_type afs_SRXYFSCB <<
98 .name = "YFSCB.CallBack", <<
99 .deliver = afs_deliver_yfs_cb_c <<
100 .destructor = afs_cm_destructor, <<
101 .work = SRXAFSCB_CallBack, <<
102 }; <<
103 <<
104 /* <<
105 * route an incoming cache manager call 104 * route an incoming cache manager call
106 * - return T if supported, F if not 105 * - return T if supported, F if not
107 */ 106 */
108 bool afs_cm_incoming_call(struct afs_call *cal 107 bool afs_cm_incoming_call(struct afs_call *call)
109 { 108 {
110 _enter("{%u, CB.OP %u}", call->service !! 109 _enter("{CB.OP %u}", call->operation_ID);
111 110
112 switch (call->operation_ID) { 111 switch (call->operation_ID) {
113 case CBCallBack: 112 case CBCallBack:
114 call->type = &afs_SRXCBCallBac 113 call->type = &afs_SRXCBCallBack;
115 return true; 114 return true;
116 case CBInitCallBackState: 115 case CBInitCallBackState:
117 call->type = &afs_SRXCBInitCal 116 call->type = &afs_SRXCBInitCallBackState;
118 return true; 117 return true;
119 case CBInitCallBackState3: 118 case CBInitCallBackState3:
120 call->type = &afs_SRXCBInitCal 119 call->type = &afs_SRXCBInitCallBackState3;
121 return true; 120 return true;
122 case CBProbe: 121 case CBProbe:
123 call->type = &afs_SRXCBProbe; 122 call->type = &afs_SRXCBProbe;
124 return true; 123 return true;
125 case CBProbeUuid: 124 case CBProbeUuid:
126 call->type = &afs_SRXCBProbeUu 125 call->type = &afs_SRXCBProbeUuid;
127 return true; 126 return true;
128 case CBTellMeAboutYourself: 127 case CBTellMeAboutYourself:
129 call->type = &afs_SRXCBTellMeA 128 call->type = &afs_SRXCBTellMeAboutYourself;
130 return true; 129 return true;
131 case YFSCBCallBack: <<
132 if (call->service_id != YFS_CM <<
133 return false; <<
134 call->type = &afs_SRXYFSCB_Cal <<
135 return true; <<
136 default: 130 default:
137 return false; 131 return false;
138 } 132 }
139 } 133 }
140 134
141 /* 135 /*
142 * Find the server record by peer address and <<
143 * manager from a server. <<
144 */ <<
145 static int afs_find_cm_server_by_peer(struct a <<
146 { <<
147 struct sockaddr_rxrpc srx; <<
148 struct afs_server *server; <<
149 struct rxrpc_peer *peer; <<
150 <<
151 peer = rxrpc_kernel_get_call_peer(call <<
152 <<
153 server = afs_find_server(call->net, pe <<
154 if (!server) { <<
155 trace_afs_cm_no_server(call, & <<
156 return 0; <<
157 } <<
158 <<
159 call->server = server; <<
160 return 0; <<
161 } <<
162 <<
163 /* <<
164 * Find the server record by server UUID and r <<
165 * manager from a server. <<
166 */ <<
167 static int afs_find_cm_server_by_uuid(struct a <<
168 struct a <<
169 { <<
170 struct afs_server *server; <<
171 <<
172 rcu_read_lock(); <<
173 server = afs_find_server_by_uuid(call- <<
174 rcu_read_unlock(); <<
175 if (!server) { <<
176 trace_afs_cm_no_server_u(call, <<
177 return 0; <<
178 } <<
179 <<
180 call->server = server; <<
181 return 0; <<
182 } <<
183 <<
184 /* <<
185 * Clean up a cache manager call. 136 * Clean up a cache manager call.
186 */ 137 */
187 static void afs_cm_destructor(struct afs_call 138 static void afs_cm_destructor(struct afs_call *call)
188 { 139 {
189 kfree(call->buffer); 140 kfree(call->buffer);
190 call->buffer = NULL; 141 call->buffer = NULL;
191 } 142 }
192 143
193 /* 144 /*
194 * Abort a service call from within an action <<
195 */ <<
196 static void afs_abort_service_call(struct afs_ <<
197 enum rxrpc_ <<
198 { <<
199 rxrpc_kernel_abort_call(call->net->soc <<
200 abort_code, er <<
201 afs_set_call_complete(call, error, 0); <<
202 } <<
203 <<
204 /* <<
205 * The server supplied a list of callbacks tha 145 * The server supplied a list of callbacks that it wanted to break.
206 */ 146 */
207 static void SRXAFSCB_CallBack(struct work_stru 147 static void SRXAFSCB_CallBack(struct work_struct *work)
208 { 148 {
209 struct afs_call *call = container_of(w 149 struct afs_call *call = container_of(work, struct afs_call, work);
210 150
211 _enter(""); 151 _enter("");
212 152
213 /* We need to break the callbacks befo 153 /* We need to break the callbacks before sending the reply as the
214 * server holds up change visibility t 154 * server holds up change visibility till it receives our reply so as
215 * to maintain cache coherency. 155 * to maintain cache coherency.
216 */ 156 */
217 if (call->server) { !! 157 if (call->cm_server)
218 trace_afs_server(call->server- !! 158 afs_break_callbacks(call->cm_server, call->count, call->request);
219 refcount_read <<
220 atomic_read(& <<
221 afs_server_tr <<
222 afs_break_callbacks(call->serv <<
223 } <<
224 159
225 afs_send_empty_reply(call); 160 afs_send_empty_reply(call);
226 afs_put_call(call); 161 afs_put_call(call);
227 _leave(""); 162 _leave("");
228 } 163 }
229 164
230 /* 165 /*
231 * deliver request data to a CB.CallBack call 166 * deliver request data to a CB.CallBack call
232 */ 167 */
233 static int afs_deliver_cb_callback(struct afs_ 168 static int afs_deliver_cb_callback(struct afs_call *call)
234 { 169 {
235 struct afs_callback_break *cb; 170 struct afs_callback_break *cb;
>> 171 struct sockaddr_rxrpc srx;
236 __be32 *bp; 172 __be32 *bp;
237 int ret, loop; 173 int ret, loop;
238 174
239 _enter("{%u}", call->unmarshall); 175 _enter("{%u}", call->unmarshall);
240 176
241 switch (call->unmarshall) { 177 switch (call->unmarshall) {
242 case 0: 178 case 0:
243 afs_extract_to_tmp(call); !! 179 call->offset = 0;
244 call->unmarshall++; 180 call->unmarshall++;
245 181
246 /* extract the FID array and i 182 /* extract the FID array and its count in two steps */
247 fallthrough; <<
248 case 1: 183 case 1:
249 _debug("extract FID count"); 184 _debug("extract FID count");
250 ret = afs_extract_data(call, t !! 185 ret = afs_extract_data(call, &call->tmp, 4, true);
251 if (ret < 0) 186 if (ret < 0)
252 return ret; 187 return ret;
253 188
254 call->count = ntohl(call->tmp) 189 call->count = ntohl(call->tmp);
255 _debug("FID count: %u", call-> 190 _debug("FID count: %u", call->count);
256 if (call->count > AFSCBMAX) 191 if (call->count > AFSCBMAX)
257 return afs_protocol_er !! 192 return afs_protocol_error(call, -EBADMSG);
258 193
259 call->buffer = kmalloc(array3_ 194 call->buffer = kmalloc(array3_size(call->count, 3, 4),
260 GFP_KER 195 GFP_KERNEL);
261 if (!call->buffer) 196 if (!call->buffer)
262 return -ENOMEM; 197 return -ENOMEM;
263 afs_extract_to_buf(call, call- !! 198 call->offset = 0;
264 call->unmarshall++; 199 call->unmarshall++;
265 200
266 fallthrough; <<
267 case 2: 201 case 2:
268 _debug("extract FID array"); 202 _debug("extract FID array");
269 ret = afs_extract_data(call, t !! 203 ret = afs_extract_data(call, call->buffer,
>> 204 call->count * 3 * 4, true);
270 if (ret < 0) 205 if (ret < 0)
271 return ret; 206 return ret;
272 207
273 _debug("unmarshall FID array") 208 _debug("unmarshall FID array");
274 call->request = kcalloc(call-> 209 call->request = kcalloc(call->count,
275 sizeof 210 sizeof(struct afs_callback_break),
276 GFP_KE 211 GFP_KERNEL);
277 if (!call->request) 212 if (!call->request)
278 return -ENOMEM; 213 return -ENOMEM;
279 214
280 cb = call->request; 215 cb = call->request;
281 bp = call->buffer; 216 bp = call->buffer;
282 for (loop = call->count; loop 217 for (loop = call->count; loop > 0; loop--, cb++) {
283 cb->fid.vid = ntoh 218 cb->fid.vid = ntohl(*bp++);
284 cb->fid.vnode = ntoh 219 cb->fid.vnode = ntohl(*bp++);
285 cb->fid.unique = ntoh 220 cb->fid.unique = ntohl(*bp++);
>> 221 cb->cb.type = AFSCM_CB_UNTYPED;
286 } 222 }
287 223
288 afs_extract_to_tmp(call); !! 224 call->offset = 0;
289 call->unmarshall++; 225 call->unmarshall++;
290 226
291 /* extract the callback array 227 /* extract the callback array and its count in two steps */
292 fallthrough; <<
293 case 3: 228 case 3:
294 _debug("extract CB count"); 229 _debug("extract CB count");
295 ret = afs_extract_data(call, t !! 230 ret = afs_extract_data(call, &call->tmp, 4, true);
296 if (ret < 0) 231 if (ret < 0)
297 return ret; 232 return ret;
298 233
299 call->count2 = ntohl(call->tmp 234 call->count2 = ntohl(call->tmp);
300 _debug("CB count: %u", call->c 235 _debug("CB count: %u", call->count2);
301 if (call->count2 != call->coun 236 if (call->count2 != call->count && call->count2 != 0)
302 return afs_protocol_er !! 237 return afs_protocol_error(call, -EBADMSG);
303 call->iter = &call->def_iter; !! 238 call->offset = 0;
304 iov_iter_discard(&call->def_it <<
305 call->unmarshall++; 239 call->unmarshall++;
306 240
307 fallthrough; <<
308 case 4: 241 case 4:
309 _debug("extract discard %zu/%u !! 242 _debug("extract CB array");
310 iov_iter_count(call->it !! 243 ret = afs_extract_data(call, call->buffer,
311 !! 244 call->count2 * 3 * 4, false);
312 ret = afs_extract_data(call, f <<
313 if (ret < 0) 245 if (ret < 0)
314 return ret; 246 return ret;
315 247
316 call->unmarshall++; !! 248 _debug("unmarshall CB array");
317 fallthrough; !! 249 cb = call->request;
>> 250 bp = call->buffer;
>> 251 for (loop = call->count2; loop > 0; loop--, cb++) {
>> 252 cb->cb.version = ntohl(*bp++);
>> 253 cb->cb.expiry = ntohl(*bp++);
>> 254 cb->cb.type = ntohl(*bp++);
>> 255 }
318 256
>> 257 call->offset = 0;
>> 258 call->unmarshall++;
319 case 5: 259 case 5:
320 break; 260 break;
321 } 261 }
322 262
323 if (!afs_check_call_state(call, AFS_CA 263 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
324 return afs_io_error(call, afs_ !! 264 return -EIO;
325 265
326 /* we'll need the file server record a 266 /* we'll need the file server record as that tells us which set of
327 * vnodes to operate upon */ 267 * vnodes to operate upon */
328 return afs_find_cm_server_by_peer(call !! 268 rxrpc_kernel_get_peer(call->net->socket, call->rxcall, &srx);
>> 269 call->cm_server = afs_find_server(call->net, &srx);
>> 270 if (!call->cm_server)
>> 271 trace_afs_cm_no_server(call, &srx);
>> 272
>> 273 return afs_queue_call_work(call);
329 } 274 }
330 275
331 /* 276 /*
332 * allow the fileserver to request callback st 277 * allow the fileserver to request callback state (re-)initialisation
333 */ 278 */
334 static void SRXAFSCB_InitCallBackState(struct 279 static void SRXAFSCB_InitCallBackState(struct work_struct *work)
335 { 280 {
336 struct afs_call *call = container_of(w 281 struct afs_call *call = container_of(work, struct afs_call, work);
337 282
338 _enter("{%p}", call->server); !! 283 _enter("{%p}", call->cm_server);
339 284
340 if (call->server) !! 285 if (call->cm_server)
341 afs_init_callback_state(call-> !! 286 afs_init_callback_state(call->cm_server);
342 afs_send_empty_reply(call); 287 afs_send_empty_reply(call);
343 afs_put_call(call); 288 afs_put_call(call);
344 _leave(""); 289 _leave("");
345 } 290 }
346 291
347 /* 292 /*
348 * deliver request data to a CB.InitCallBackSt 293 * deliver request data to a CB.InitCallBackState call
349 */ 294 */
350 static int afs_deliver_cb_init_call_back_state 295 static int afs_deliver_cb_init_call_back_state(struct afs_call *call)
351 { 296 {
>> 297 struct sockaddr_rxrpc srx;
352 int ret; 298 int ret;
353 299
354 _enter(""); 300 _enter("");
355 301
356 afs_extract_discard(call, 0); !! 302 rxrpc_kernel_get_peer(call->net->socket, call->rxcall, &srx);
357 ret = afs_extract_data(call, false); !! 303
>> 304 ret = afs_extract_data(call, NULL, 0, false);
358 if (ret < 0) 305 if (ret < 0)
359 return ret; 306 return ret;
360 307
361 /* we'll need the file server record a 308 /* we'll need the file server record as that tells us which set of
362 * vnodes to operate upon */ 309 * vnodes to operate upon */
363 return afs_find_cm_server_by_peer(call !! 310 call->cm_server = afs_find_server(call->net, &srx);
>> 311 if (!call->cm_server)
>> 312 trace_afs_cm_no_server(call, &srx);
>> 313
>> 314 return afs_queue_call_work(call);
364 } 315 }
365 316
366 /* 317 /*
367 * deliver request data to a CB.InitCallBackSt 318 * deliver request data to a CB.InitCallBackState3 call
368 */ 319 */
369 static int afs_deliver_cb_init_call_back_state 320 static int afs_deliver_cb_init_call_back_state3(struct afs_call *call)
370 { 321 {
371 struct afs_uuid *r; 322 struct afs_uuid *r;
372 unsigned loop; 323 unsigned loop;
373 __be32 *b; 324 __be32 *b;
374 int ret; 325 int ret;
375 326
376 _enter(""); 327 _enter("");
377 328
378 _enter("{%u}", call->unmarshall); 329 _enter("{%u}", call->unmarshall);
379 330
380 switch (call->unmarshall) { 331 switch (call->unmarshall) {
381 case 0: 332 case 0:
>> 333 call->offset = 0;
382 call->buffer = kmalloc_array(1 334 call->buffer = kmalloc_array(11, sizeof(__be32), GFP_KERNEL);
383 if (!call->buffer) 335 if (!call->buffer)
384 return -ENOMEM; 336 return -ENOMEM;
385 afs_extract_to_buf(call, 11 * <<
386 call->unmarshall++; 337 call->unmarshall++;
387 338
388 fallthrough; <<
389 case 1: 339 case 1:
390 _debug("extract UUID"); 340 _debug("extract UUID");
391 ret = afs_extract_data(call, f !! 341 ret = afs_extract_data(call, call->buffer,
>> 342 11 * sizeof(__be32), false);
392 switch (ret) { 343 switch (ret) {
393 case 0: break; 344 case 0: break;
394 case -EAGAIN: return 0; 345 case -EAGAIN: return 0;
395 default: return ret; 346 default: return ret;
396 } 347 }
397 348
398 _debug("unmarshall UUID"); 349 _debug("unmarshall UUID");
399 call->request = kmalloc(sizeof 350 call->request = kmalloc(sizeof(struct afs_uuid), GFP_KERNEL);
400 if (!call->request) 351 if (!call->request)
401 return -ENOMEM; 352 return -ENOMEM;
402 353
403 b = call->buffer; 354 b = call->buffer;
404 r = call->request; 355 r = call->request;
405 r->time_low 356 r->time_low = b[0];
406 r->time_mid 357 r->time_mid = htons(ntohl(b[1]));
407 r->time_hi_and_version 358 r->time_hi_and_version = htons(ntohl(b[2]));
408 r->clock_seq_hi_and_reserved 359 r->clock_seq_hi_and_reserved = ntohl(b[3]);
409 r->clock_seq_low 360 r->clock_seq_low = ntohl(b[4]);
410 361
411 for (loop = 0; loop < 6; loop+ 362 for (loop = 0; loop < 6; loop++)
412 r->node[loop] = ntohl( 363 r->node[loop] = ntohl(b[loop + 5]);
413 364
>> 365 call->offset = 0;
414 call->unmarshall++; 366 call->unmarshall++;
415 fallthrough; <<
416 367
417 case 2: 368 case 2:
418 break; 369 break;
419 } 370 }
420 371
421 if (!afs_check_call_state(call, AFS_CA 372 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
422 return afs_io_error(call, afs_ !! 373 return -EIO;
423 374
424 /* we'll need the file server record a 375 /* we'll need the file server record as that tells us which set of
425 * vnodes to operate upon */ 376 * vnodes to operate upon */
426 return afs_find_cm_server_by_uuid(call !! 377 rcu_read_lock();
>> 378 call->cm_server = afs_find_server_by_uuid(call->net, call->request);
>> 379 rcu_read_unlock();
>> 380 if (!call->cm_server)
>> 381 trace_afs_cm_no_server_u(call, call->request);
>> 382
>> 383 return afs_queue_call_work(call);
427 } 384 }
428 385
429 /* 386 /*
430 * allow the fileserver to see if the cache ma 387 * allow the fileserver to see if the cache manager is still alive
431 */ 388 */
432 static void SRXAFSCB_Probe(struct work_struct 389 static void SRXAFSCB_Probe(struct work_struct *work)
433 { 390 {
434 struct afs_call *call = container_of(w 391 struct afs_call *call = container_of(work, struct afs_call, work);
435 392
436 _enter(""); 393 _enter("");
437 afs_send_empty_reply(call); 394 afs_send_empty_reply(call);
438 afs_put_call(call); 395 afs_put_call(call);
439 _leave(""); 396 _leave("");
440 } 397 }
441 398
442 /* 399 /*
443 * deliver request data to a CB.Probe call 400 * deliver request data to a CB.Probe call
444 */ 401 */
445 static int afs_deliver_cb_probe(struct afs_cal 402 static int afs_deliver_cb_probe(struct afs_call *call)
446 { 403 {
447 int ret; 404 int ret;
448 405
449 _enter(""); 406 _enter("");
450 407
451 afs_extract_discard(call, 0); !! 408 ret = afs_extract_data(call, NULL, 0, false);
452 ret = afs_extract_data(call, false); <<
453 if (ret < 0) 409 if (ret < 0)
454 return ret; 410 return ret;
455 411
456 if (!afs_check_call_state(call, AFS_CA 412 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
457 return afs_io_error(call, afs_ !! 413 return -EIO;
458 return afs_find_cm_server_by_peer(call !! 414
>> 415 return afs_queue_call_work(call);
459 } 416 }
460 417
461 /* 418 /*
462 * Allow the fileserver to quickly find out if !! 419 * allow the fileserver to quickly find out if the fileserver has been rebooted
463 * rebooted. <<
464 */ 420 */
465 static void SRXAFSCB_ProbeUuid(struct work_str 421 static void SRXAFSCB_ProbeUuid(struct work_struct *work)
466 { 422 {
467 struct afs_call *call = container_of(w 423 struct afs_call *call = container_of(work, struct afs_call, work);
468 struct afs_uuid *r = call->request; 424 struct afs_uuid *r = call->request;
469 425
470 _enter(""); 426 _enter("");
471 427
472 if (memcmp(r, &call->net->uuid, sizeof 428 if (memcmp(r, &call->net->uuid, sizeof(call->net->uuid)) == 0)
473 afs_send_empty_reply(call); 429 afs_send_empty_reply(call);
474 else 430 else
475 afs_abort_service_call(call, 1 !! 431 rxrpc_kernel_abort_call(call->net->socket, call->rxcall,
>> 432 1, 1, "K-1");
476 433
477 afs_put_call(call); 434 afs_put_call(call);
478 _leave(""); 435 _leave("");
479 } 436 }
480 437
481 /* 438 /*
482 * deliver request data to a CB.ProbeUuid call 439 * deliver request data to a CB.ProbeUuid call
483 */ 440 */
484 static int afs_deliver_cb_probe_uuid(struct af 441 static int afs_deliver_cb_probe_uuid(struct afs_call *call)
485 { 442 {
486 struct afs_uuid *r; 443 struct afs_uuid *r;
487 unsigned loop; 444 unsigned loop;
488 __be32 *b; 445 __be32 *b;
489 int ret; 446 int ret;
490 447
491 _enter("{%u}", call->unmarshall); 448 _enter("{%u}", call->unmarshall);
492 449
493 switch (call->unmarshall) { 450 switch (call->unmarshall) {
494 case 0: 451 case 0:
>> 452 call->offset = 0;
495 call->buffer = kmalloc_array(1 453 call->buffer = kmalloc_array(11, sizeof(__be32), GFP_KERNEL);
496 if (!call->buffer) 454 if (!call->buffer)
497 return -ENOMEM; 455 return -ENOMEM;
498 afs_extract_to_buf(call, 11 * <<
499 call->unmarshall++; 456 call->unmarshall++;
500 457
501 fallthrough; <<
502 case 1: 458 case 1:
503 _debug("extract UUID"); 459 _debug("extract UUID");
504 ret = afs_extract_data(call, f !! 460 ret = afs_extract_data(call, call->buffer,
>> 461 11 * sizeof(__be32), false);
505 switch (ret) { 462 switch (ret) {
506 case 0: break; 463 case 0: break;
507 case -EAGAIN: return 0; 464 case -EAGAIN: return 0;
508 default: return ret; 465 default: return ret;
509 } 466 }
510 467
511 _debug("unmarshall UUID"); 468 _debug("unmarshall UUID");
512 call->request = kmalloc(sizeof 469 call->request = kmalloc(sizeof(struct afs_uuid), GFP_KERNEL);
513 if (!call->request) 470 if (!call->request)
514 return -ENOMEM; 471 return -ENOMEM;
515 472
516 b = call->buffer; 473 b = call->buffer;
517 r = call->request; 474 r = call->request;
518 r->time_low 475 r->time_low = b[0];
519 r->time_mid 476 r->time_mid = htons(ntohl(b[1]));
520 r->time_hi_and_version 477 r->time_hi_and_version = htons(ntohl(b[2]));
521 r->clock_seq_hi_and_reserved 478 r->clock_seq_hi_and_reserved = ntohl(b[3]);
522 r->clock_seq_low 479 r->clock_seq_low = ntohl(b[4]);
523 480
524 for (loop = 0; loop < 6; loop+ 481 for (loop = 0; loop < 6; loop++)
525 r->node[loop] = ntohl( 482 r->node[loop] = ntohl(b[loop + 5]);
526 483
>> 484 call->offset = 0;
527 call->unmarshall++; 485 call->unmarshall++;
528 fallthrough; <<
529 486
530 case 2: 487 case 2:
531 break; 488 break;
532 } 489 }
533 490
534 if (!afs_check_call_state(call, AFS_CA 491 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
535 return afs_io_error(call, afs_ !! 492 return -EIO;
536 return afs_find_cm_server_by_peer(call !! 493
>> 494 return afs_queue_call_work(call);
537 } 495 }
538 496
539 /* 497 /*
540 * allow the fileserver to ask about the cache 498 * allow the fileserver to ask about the cache manager's capabilities
541 */ 499 */
542 static void SRXAFSCB_TellMeAboutYourself(struc 500 static void SRXAFSCB_TellMeAboutYourself(struct work_struct *work)
543 { 501 {
>> 502 struct afs_interface *ifs;
544 struct afs_call *call = container_of(w 503 struct afs_call *call = container_of(work, struct afs_call, work);
545 int loop; !! 504 int loop, nifs;
546 505
547 struct { 506 struct {
548 struct /* InterfaceAddr */ { 507 struct /* InterfaceAddr */ {
549 __be32 nifs; 508 __be32 nifs;
550 __be32 uuid[11]; 509 __be32 uuid[11];
551 __be32 ifaddr[32]; 510 __be32 ifaddr[32];
552 __be32 netmask[32]; 511 __be32 netmask[32];
553 __be32 mtu[32]; 512 __be32 mtu[32];
554 } ia; 513 } ia;
555 struct /* Capabilities */ { 514 struct /* Capabilities */ {
556 __be32 capcount; 515 __be32 capcount;
557 __be32 caps[1]; 516 __be32 caps[1];
558 } cap; 517 } cap;
559 } reply; 518 } reply;
560 519
561 _enter(""); 520 _enter("");
562 521
>> 522 nifs = 0;
>> 523 ifs = kcalloc(32, sizeof(*ifs), GFP_KERNEL);
>> 524 if (ifs) {
>> 525 nifs = afs_get_ipv4_interfaces(call->net, ifs, 32, false);
>> 526 if (nifs < 0) {
>> 527 kfree(ifs);
>> 528 ifs = NULL;
>> 529 nifs = 0;
>> 530 }
>> 531 }
>> 532
563 memset(&reply, 0, sizeof(reply)); 533 memset(&reply, 0, sizeof(reply));
>> 534 reply.ia.nifs = htonl(nifs);
564 535
565 reply.ia.uuid[0] = call->net->uuid.tim 536 reply.ia.uuid[0] = call->net->uuid.time_low;
566 reply.ia.uuid[1] = htonl(ntohs(call->n 537 reply.ia.uuid[1] = htonl(ntohs(call->net->uuid.time_mid));
567 reply.ia.uuid[2] = htonl(ntohs(call->n 538 reply.ia.uuid[2] = htonl(ntohs(call->net->uuid.time_hi_and_version));
568 reply.ia.uuid[3] = htonl((s8) call->ne 539 reply.ia.uuid[3] = htonl((s8) call->net->uuid.clock_seq_hi_and_reserved);
569 reply.ia.uuid[4] = htonl((s8) call->ne 540 reply.ia.uuid[4] = htonl((s8) call->net->uuid.clock_seq_low);
570 for (loop = 0; loop < 6; loop++) 541 for (loop = 0; loop < 6; loop++)
571 reply.ia.uuid[loop + 5] = hton 542 reply.ia.uuid[loop + 5] = htonl((s8) call->net->uuid.node[loop]);
572 543
>> 544 if (ifs) {
>> 545 for (loop = 0; loop < nifs; loop++) {
>> 546 reply.ia.ifaddr[loop] = ifs[loop].address.s_addr;
>> 547 reply.ia.netmask[loop] = ifs[loop].netmask.s_addr;
>> 548 reply.ia.mtu[loop] = htonl(ifs[loop].mtu);
>> 549 }
>> 550 kfree(ifs);
>> 551 }
>> 552
573 reply.cap.capcount = htonl(1); 553 reply.cap.capcount = htonl(1);
574 reply.cap.caps[0] = htonl(AFS_CAP_ERRO 554 reply.cap.caps[0] = htonl(AFS_CAP_ERROR_TRANSLATION);
575 afs_send_simple_reply(call, &reply, si 555 afs_send_simple_reply(call, &reply, sizeof(reply));
576 afs_put_call(call); 556 afs_put_call(call);
577 _leave(""); 557 _leave("");
578 } 558 }
579 559
580 /* 560 /*
581 * deliver request data to a CB.TellMeAboutYou 561 * deliver request data to a CB.TellMeAboutYourself call
582 */ 562 */
583 static int afs_deliver_cb_tell_me_about_yourse 563 static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *call)
584 { 564 {
585 int ret; 565 int ret;
586 566
587 _enter(""); 567 _enter("");
588 568
589 afs_extract_discard(call, 0); !! 569 ret = afs_extract_data(call, NULL, 0, false);
590 ret = afs_extract_data(call, false); <<
591 if (ret < 0) 570 if (ret < 0)
592 return ret; 571 return ret;
593 572
594 if (!afs_check_call_state(call, AFS_CA 573 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
595 return afs_io_error(call, afs_ !! 574 return -EIO;
596 return afs_find_cm_server_by_peer(call <<
597 } <<
598 <<
599 /* <<
600 * deliver request data to a YFS CB.CallBack c <<
601 */ <<
602 static int afs_deliver_yfs_cb_callback(struct <<
603 { <<
604 struct afs_callback_break *cb; <<
605 struct yfs_xdr_YFSFid *bp; <<
606 size_t size; <<
607 int ret, loop; <<
608 <<
609 _enter("{%u}", call->unmarshall); <<
610 <<
611 switch (call->unmarshall) { <<
612 case 0: <<
613 afs_extract_to_tmp(call); <<
614 call->unmarshall++; <<
615 <<
616 /* extract the FID array and i <<
617 fallthrough; <<
618 case 1: <<
619 _debug("extract FID count"); <<
620 ret = afs_extract_data(call, t <<
621 if (ret < 0) <<
622 return ret; <<
623 <<
624 call->count = ntohl(call->tmp) <<
625 _debug("FID count: %u", call-> <<
626 if (call->count > YFSCBMAX) <<
627 return afs_protocol_er <<
628 <<
629 size = array_size(call->count, <<
630 call->buffer = kmalloc(size, G <<
631 if (!call->buffer) <<
632 return -ENOMEM; <<
633 afs_extract_to_buf(call, size) <<
634 call->unmarshall++; <<
635 <<
636 fallthrough; <<
637 case 2: <<
638 _debug("extract FID array"); <<
639 ret = afs_extract_data(call, f <<
640 if (ret < 0) <<
641 return ret; <<
642 <<
643 _debug("unmarshall FID array") <<
644 call->request = kcalloc(call-> <<
645 sizeof <<
646 GFP_KE <<
647 if (!call->request) <<
648 return -ENOMEM; <<
649 <<
650 cb = call->request; <<
651 bp = call->buffer; <<
652 for (loop = call->count; loop <<
653 cb->fid.vid = xdr_ <<
654 cb->fid.vnode = xdr_ <<
655 cb->fid.vnode_hi = nto <<
656 cb->fid.unique = ntoh <<
657 bp++; <<
658 } <<
659 <<
660 afs_extract_to_tmp(call); <<
661 call->unmarshall++; <<
662 fallthrough; <<
663 <<
664 case 3: <<
665 break; <<
666 } <<
667 <<
668 if (!afs_check_call_state(call, AFS_CA <<
669 return afs_io_error(call, afs_ <<
670 575
671 /* We'll need the file server record a !! 576 return afs_queue_call_work(call);
672 * vnodes to operate upon. <<
673 */ <<
674 return afs_find_cm_server_by_peer(call <<
675 } 577 }
676 578
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.