Commit | Line | Data |
---|---|---|
ec26815a | 1 | /* AFS Cache Manager Service |
1da177e4 LT |
2 | * |
3 | * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved. | |
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. | |
10 | */ | |
11 | ||
12 | #include <linux/module.h> | |
13 | #include <linux/init.h> | |
5a0e3ad6 | 14 | #include <linux/slab.h> |
1da177e4 | 15 | #include <linux/sched.h> |
08e0e7c8 | 16 | #include <linux/ip.h> |
1da177e4 | 17 | #include "internal.h" |
08e0e7c8 | 18 | #include "afs_cm.h" |
1da177e4 | 19 | |
c1206a2c | 20 | #if 0 |
08e0e7c8 | 21 | struct workqueue_struct *afs_cm_workqueue; |
c1206a2c | 22 | #endif /* 0 */ |
1da177e4 | 23 | |
08e0e7c8 DH |
24 | static int afs_deliver_cb_init_call_back_state(struct afs_call *, |
25 | struct sk_buff *, bool); | |
c35eccb1 DH |
26 | static int afs_deliver_cb_init_call_back_state3(struct afs_call *, |
27 | struct sk_buff *, bool); | |
08e0e7c8 DH |
28 | static int afs_deliver_cb_probe(struct afs_call *, struct sk_buff *, bool); |
29 | static int afs_deliver_cb_callback(struct afs_call *, struct sk_buff *, bool); | |
9396d496 | 30 | static int afs_deliver_cb_probe_uuid(struct afs_call *, struct sk_buff *, bool); |
7c80bcce DH |
31 | static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *, |
32 | struct sk_buff *, bool); | |
08e0e7c8 | 33 | static void afs_cm_destructor(struct afs_call *); |
1da177e4 | 34 | |
1da177e4 | 35 | /* |
08e0e7c8 | 36 | * CB.CallBack operation type |
1da177e4 | 37 | */ |
08e0e7c8 | 38 | static const struct afs_call_type afs_SRXCBCallBack = { |
00d3b7a4 | 39 | .name = "CB.CallBack", |
08e0e7c8 DH |
40 | .deliver = afs_deliver_cb_callback, |
41 | .abort_to_error = afs_abort_to_error, | |
42 | .destructor = afs_cm_destructor, | |
43 | }; | |
1da177e4 | 44 | |
1da177e4 | 45 | /* |
08e0e7c8 | 46 | * CB.InitCallBackState operation type |
1da177e4 | 47 | */ |
08e0e7c8 | 48 | static const struct afs_call_type afs_SRXCBInitCallBackState = { |
00d3b7a4 | 49 | .name = "CB.InitCallBackState", |
08e0e7c8 DH |
50 | .deliver = afs_deliver_cb_init_call_back_state, |
51 | .abort_to_error = afs_abort_to_error, | |
52 | .destructor = afs_cm_destructor, | |
53 | }; | |
1da177e4 | 54 | |
c35eccb1 DH |
55 | /* |
56 | * CB.InitCallBackState3 operation type | |
57 | */ | |
58 | static const struct afs_call_type afs_SRXCBInitCallBackState3 = { | |
59 | .name = "CB.InitCallBackState3", | |
60 | .deliver = afs_deliver_cb_init_call_back_state3, | |
61 | .abort_to_error = afs_abort_to_error, | |
62 | .destructor = afs_cm_destructor, | |
63 | }; | |
64 | ||
1da177e4 | 65 | /* |
08e0e7c8 | 66 | * CB.Probe operation type |
1da177e4 | 67 | */ |
08e0e7c8 | 68 | static const struct afs_call_type afs_SRXCBProbe = { |
00d3b7a4 | 69 | .name = "CB.Probe", |
08e0e7c8 DH |
70 | .deliver = afs_deliver_cb_probe, |
71 | .abort_to_error = afs_abort_to_error, | |
72 | .destructor = afs_cm_destructor, | |
73 | }; | |
1da177e4 | 74 | |
9396d496 DH |
75 | /* |
76 | * CB.ProbeUuid operation type | |
77 | */ | |
78 | static const struct afs_call_type afs_SRXCBProbeUuid = { | |
79 | .name = "CB.ProbeUuid", | |
80 | .deliver = afs_deliver_cb_probe_uuid, | |
81 | .abort_to_error = afs_abort_to_error, | |
82 | .destructor = afs_cm_destructor, | |
83 | }; | |
84 | ||
b908fe6b | 85 | /* |
7c80bcce | 86 | * CB.TellMeAboutYourself operation type |
b908fe6b | 87 | */ |
7c80bcce DH |
88 | static const struct afs_call_type afs_SRXCBTellMeAboutYourself = { |
89 | .name = "CB.TellMeAboutYourself", | |
90 | .deliver = afs_deliver_cb_tell_me_about_yourself, | |
b908fe6b DH |
91 | .abort_to_error = afs_abort_to_error, |
92 | .destructor = afs_cm_destructor, | |
93 | }; | |
94 | ||
1da177e4 | 95 | /* |
08e0e7c8 DH |
96 | * route an incoming cache manager call |
97 | * - return T if supported, F if not | |
1da177e4 | 98 | */ |
08e0e7c8 | 99 | bool afs_cm_incoming_call(struct afs_call *call) |
1da177e4 | 100 | { |
08e0e7c8 DH |
101 | u32 operation_id = ntohl(call->operation_ID); |
102 | ||
103 | _enter("{CB.OP %u}", operation_id); | |
104 | ||
105 | switch (operation_id) { | |
106 | case CBCallBack: | |
107 | call->type = &afs_SRXCBCallBack; | |
108 | return true; | |
109 | case CBInitCallBackState: | |
110 | call->type = &afs_SRXCBInitCallBackState; | |
111 | return true; | |
c35eccb1 DH |
112 | case CBInitCallBackState3: |
113 | call->type = &afs_SRXCBInitCallBackState3; | |
114 | return true; | |
08e0e7c8 DH |
115 | case CBProbe: |
116 | call->type = &afs_SRXCBProbe; | |
117 | return true; | |
7c80bcce DH |
118 | case CBTellMeAboutYourself: |
119 | call->type = &afs_SRXCBTellMeAboutYourself; | |
b908fe6b | 120 | return true; |
08e0e7c8 DH |
121 | default: |
122 | return false; | |
1da177e4 | 123 | } |
ec26815a | 124 | } |
1da177e4 | 125 | |
1da177e4 | 126 | /* |
08e0e7c8 | 127 | * clean up a cache manager call |
1da177e4 | 128 | */ |
08e0e7c8 | 129 | static void afs_cm_destructor(struct afs_call *call) |
1da177e4 | 130 | { |
08e0e7c8 DH |
131 | _enter(""); |
132 | ||
6c67c7c3 DH |
133 | /* Break the callbacks here so that we do it after the final ACK is |
134 | * received. The step number here must match the final number in | |
135 | * afs_deliver_cb_callback(). | |
136 | */ | |
137 | if (call->unmarshall == 6) { | |
138 | ASSERT(call->server && call->count && call->request); | |
139 | afs_break_callbacks(call->server, call->count, call->request); | |
140 | } | |
141 | ||
08e0e7c8 DH |
142 | afs_put_server(call->server); |
143 | call->server = NULL; | |
144 | kfree(call->buffer); | |
145 | call->buffer = NULL; | |
ec26815a | 146 | } |
1da177e4 | 147 | |
1da177e4 | 148 | /* |
08e0e7c8 | 149 | * allow the fileserver to see if the cache manager is still alive |
1da177e4 | 150 | */ |
08e0e7c8 | 151 | static void SRXAFSCB_CallBack(struct work_struct *work) |
1da177e4 | 152 | { |
08e0e7c8 | 153 | struct afs_call *call = container_of(work, struct afs_call, work); |
1da177e4 | 154 | |
08e0e7c8 | 155 | _enter(""); |
1da177e4 | 156 | |
08e0e7c8 DH |
157 | /* be sure to send the reply *before* attempting to spam the AFS server |
158 | * with FSFetchStatus requests on the vnodes with broken callbacks lest | |
159 | * the AFS server get into a vicious cycle of trying to break further | |
160 | * callbacks because it hadn't received completion of the CBCallBack op | |
161 | * yet */ | |
162 | afs_send_empty_reply(call); | |
1da177e4 | 163 | |
08e0e7c8 DH |
164 | afs_break_callbacks(call->server, call->count, call->request); |
165 | _leave(""); | |
ec26815a | 166 | } |
1da177e4 | 167 | |
1da177e4 | 168 | /* |
08e0e7c8 | 169 | * deliver request data to a CB.CallBack call |
1da177e4 | 170 | */ |
08e0e7c8 DH |
171 | static int afs_deliver_cb_callback(struct afs_call *call, struct sk_buff *skb, |
172 | bool last) | |
1da177e4 | 173 | { |
08e0e7c8 DH |
174 | struct afs_callback *cb; |
175 | struct afs_server *server; | |
176 | struct in_addr addr; | |
177 | __be32 *bp; | |
178 | u32 tmp; | |
179 | int ret, loop; | |
180 | ||
181 | _enter("{%u},{%u},%d", call->unmarshall, skb->len, last); | |
182 | ||
183 | switch (call->unmarshall) { | |
184 | case 0: | |
185 | call->offset = 0; | |
186 | call->unmarshall++; | |
187 | ||
188 | /* extract the FID array and its count in two steps */ | |
189 | case 1: | |
190 | _debug("extract FID count"); | |
191 | ret = afs_extract_data(call, skb, last, &call->tmp, 4); | |
192 | switch (ret) { | |
193 | case 0: break; | |
194 | case -EAGAIN: return 0; | |
195 | default: return ret; | |
1da177e4 | 196 | } |
1da177e4 | 197 | |
08e0e7c8 DH |
198 | call->count = ntohl(call->tmp); |
199 | _debug("FID count: %u", call->count); | |
200 | if (call->count > AFSCBMAX) | |
201 | return -EBADMSG; | |
202 | ||
203 | call->buffer = kmalloc(call->count * 3 * 4, GFP_KERNEL); | |
204 | if (!call->buffer) | |
205 | return -ENOMEM; | |
206 | call->offset = 0; | |
207 | call->unmarshall++; | |
208 | ||
209 | case 2: | |
210 | _debug("extract FID array"); | |
211 | ret = afs_extract_data(call, skb, last, call->buffer, | |
212 | call->count * 3 * 4); | |
213 | switch (ret) { | |
214 | case 0: break; | |
215 | case -EAGAIN: return 0; | |
216 | default: return ret; | |
1da177e4 | 217 | } |
1da177e4 | 218 | |
08e0e7c8 DH |
219 | _debug("unmarshall FID array"); |
220 | call->request = kcalloc(call->count, | |
221 | sizeof(struct afs_callback), | |
222 | GFP_KERNEL); | |
223 | if (!call->request) | |
224 | return -ENOMEM; | |
225 | ||
226 | cb = call->request; | |
227 | bp = call->buffer; | |
228 | for (loop = call->count; loop > 0; loop--, cb++) { | |
229 | cb->fid.vid = ntohl(*bp++); | |
230 | cb->fid.vnode = ntohl(*bp++); | |
231 | cb->fid.unique = ntohl(*bp++); | |
232 | cb->type = AFSCM_CB_UNTYPED; | |
1da177e4 LT |
233 | } |
234 | ||
08e0e7c8 DH |
235 | call->offset = 0; |
236 | call->unmarshall++; | |
237 | ||
238 | /* extract the callback array and its count in two steps */ | |
239 | case 3: | |
240 | _debug("extract CB count"); | |
241 | ret = afs_extract_data(call, skb, last, &call->tmp, 4); | |
242 | switch (ret) { | |
243 | case 0: break; | |
244 | case -EAGAIN: return 0; | |
245 | default: return ret; | |
246 | } | |
1da177e4 | 247 | |
08e0e7c8 DH |
248 | tmp = ntohl(call->tmp); |
249 | _debug("CB count: %u", tmp); | |
250 | if (tmp != call->count && tmp != 0) | |
251 | return -EBADMSG; | |
252 | call->offset = 0; | |
253 | call->unmarshall++; | |
254 | if (tmp == 0) | |
255 | goto empty_cb_array; | |
256 | ||
257 | case 4: | |
258 | _debug("extract CB array"); | |
259 | ret = afs_extract_data(call, skb, last, call->request, | |
260 | call->count * 3 * 4); | |
261 | switch (ret) { | |
262 | case 0: break; | |
263 | case -EAGAIN: return 0; | |
264 | default: return ret; | |
1da177e4 | 265 | } |
1da177e4 | 266 | |
08e0e7c8 DH |
267 | _debug("unmarshall CB array"); |
268 | cb = call->request; | |
269 | bp = call->buffer; | |
270 | for (loop = call->count; loop > 0; loop--, cb++) { | |
271 | cb->version = ntohl(*bp++); | |
272 | cb->expiry = ntohl(*bp++); | |
273 | cb->type = ntohl(*bp++); | |
274 | } | |
1da177e4 | 275 | |
08e0e7c8 DH |
276 | empty_cb_array: |
277 | call->offset = 0; | |
278 | call->unmarshall++; | |
1da177e4 | 279 | |
08e0e7c8 DH |
280 | case 5: |
281 | _debug("trailer"); | |
282 | if (skb->len != 0) | |
283 | return -EBADMSG; | |
6c67c7c3 DH |
284 | |
285 | /* Record that the message was unmarshalled successfully so | |
286 | * that the call destructor can know do the callback breaking | |
287 | * work, even if the final ACK isn't received. | |
288 | * | |
289 | * If the step number changes, then afs_cm_destructor() must be | |
290 | * updated also. | |
291 | */ | |
292 | call->unmarshall++; | |
293 | case 6: | |
1da177e4 LT |
294 | break; |
295 | } | |
296 | ||
08e0e7c8 DH |
297 | if (!last) |
298 | return 0; | |
1da177e4 | 299 | |
08e0e7c8 | 300 | call->state = AFS_CALL_REPLYING; |
1da177e4 | 301 | |
08e0e7c8 DH |
302 | /* we'll need the file server record as that tells us which set of |
303 | * vnodes to operate upon */ | |
304 | memcpy(&addr, &ip_hdr(skb)->saddr, 4); | |
305 | server = afs_find_server(&addr); | |
306 | if (!server) | |
307 | return -ENOTCONN; | |
308 | call->server = server; | |
309 | ||
310 | INIT_WORK(&call->work, SRXAFSCB_CallBack); | |
0ad53eee | 311 | queue_work(afs_wq, &call->work); |
08e0e7c8 | 312 | return 0; |
ec26815a | 313 | } |
1da177e4 | 314 | |
1da177e4 | 315 | /* |
08e0e7c8 | 316 | * allow the fileserver to request callback state (re-)initialisation |
1da177e4 | 317 | */ |
08e0e7c8 | 318 | static void SRXAFSCB_InitCallBackState(struct work_struct *work) |
1da177e4 | 319 | { |
08e0e7c8 | 320 | struct afs_call *call = container_of(work, struct afs_call, work); |
1da177e4 | 321 | |
08e0e7c8 | 322 | _enter("{%p}", call->server); |
1da177e4 | 323 | |
08e0e7c8 DH |
324 | afs_init_callback_state(call->server); |
325 | afs_send_empty_reply(call); | |
326 | _leave(""); | |
ec26815a | 327 | } |
1da177e4 | 328 | |
1da177e4 | 329 | /* |
08e0e7c8 | 330 | * deliver request data to a CB.InitCallBackState call |
1da177e4 | 331 | */ |
08e0e7c8 DH |
332 | static int afs_deliver_cb_init_call_back_state(struct afs_call *call, |
333 | struct sk_buff *skb, | |
334 | bool last) | |
1da177e4 LT |
335 | { |
336 | struct afs_server *server; | |
08e0e7c8 | 337 | struct in_addr addr; |
1da177e4 | 338 | |
08e0e7c8 | 339 | _enter(",{%u},%d", skb->len, last); |
1da177e4 | 340 | |
08e0e7c8 DH |
341 | if (skb->len > 0) |
342 | return -EBADMSG; | |
343 | if (!last) | |
344 | return 0; | |
1da177e4 | 345 | |
08e0e7c8 DH |
346 | /* no unmarshalling required */ |
347 | call->state = AFS_CALL_REPLYING; | |
1da177e4 | 348 | |
08e0e7c8 DH |
349 | /* we'll need the file server record as that tells us which set of |
350 | * vnodes to operate upon */ | |
351 | memcpy(&addr, &ip_hdr(skb)->saddr, 4); | |
352 | server = afs_find_server(&addr); | |
353 | if (!server) | |
354 | return -ENOTCONN; | |
355 | call->server = server; | |
1da177e4 | 356 | |
08e0e7c8 | 357 | INIT_WORK(&call->work, SRXAFSCB_InitCallBackState); |
0ad53eee | 358 | queue_work(afs_wq, &call->work); |
08e0e7c8 DH |
359 | return 0; |
360 | } | |
1da177e4 | 361 | |
c35eccb1 DH |
362 | /* |
363 | * deliver request data to a CB.InitCallBackState3 call | |
364 | */ | |
365 | static int afs_deliver_cb_init_call_back_state3(struct afs_call *call, | |
366 | struct sk_buff *skb, | |
367 | bool last) | |
368 | { | |
369 | struct afs_server *server; | |
370 | struct in_addr addr; | |
371 | ||
372 | _enter(",{%u},%d", skb->len, last); | |
373 | ||
374 | if (!last) | |
375 | return 0; | |
376 | ||
377 | /* no unmarshalling required */ | |
378 | call->state = AFS_CALL_REPLYING; | |
379 | ||
380 | /* we'll need the file server record as that tells us which set of | |
381 | * vnodes to operate upon */ | |
382 | memcpy(&addr, &ip_hdr(skb)->saddr, 4); | |
383 | server = afs_find_server(&addr); | |
384 | if (!server) | |
385 | return -ENOTCONN; | |
386 | call->server = server; | |
387 | ||
388 | INIT_WORK(&call->work, SRXAFSCB_InitCallBackState); | |
0ad53eee | 389 | queue_work(afs_wq, &call->work); |
c35eccb1 DH |
390 | return 0; |
391 | } | |
392 | ||
08e0e7c8 DH |
393 | /* |
394 | * allow the fileserver to see if the cache manager is still alive | |
395 | */ | |
396 | static void SRXAFSCB_Probe(struct work_struct *work) | |
397 | { | |
398 | struct afs_call *call = container_of(work, struct afs_call, work); | |
1da177e4 | 399 | |
08e0e7c8 DH |
400 | _enter(""); |
401 | afs_send_empty_reply(call); | |
402 | _leave(""); | |
403 | } | |
1da177e4 | 404 | |
08e0e7c8 DH |
405 | /* |
406 | * deliver request data to a CB.Probe call | |
407 | */ | |
408 | static int afs_deliver_cb_probe(struct afs_call *call, struct sk_buff *skb, | |
409 | bool last) | |
410 | { | |
411 | _enter(",{%u},%d", skb->len, last); | |
1da177e4 | 412 | |
08e0e7c8 DH |
413 | if (skb->len > 0) |
414 | return -EBADMSG; | |
415 | if (!last) | |
416 | return 0; | |
1da177e4 | 417 | |
08e0e7c8 DH |
418 | /* no unmarshalling required */ |
419 | call->state = AFS_CALL_REPLYING; | |
1da177e4 | 420 | |
08e0e7c8 | 421 | INIT_WORK(&call->work, SRXAFSCB_Probe); |
0ad53eee | 422 | queue_work(afs_wq, &call->work); |
08e0e7c8 | 423 | return 0; |
ec26815a | 424 | } |
b908fe6b | 425 | |
9396d496 DH |
426 | /* |
427 | * allow the fileserver to quickly find out if the fileserver has been rebooted | |
428 | */ | |
429 | static void SRXAFSCB_ProbeUuid(struct work_struct *work) | |
430 | { | |
431 | struct afs_call *call = container_of(work, struct afs_call, work); | |
432 | struct afs_uuid *r = call->request; | |
433 | ||
434 | struct { | |
435 | __be32 match; | |
436 | } reply; | |
437 | ||
438 | _enter(""); | |
439 | ||
440 | ||
441 | if (memcmp(r, &afs_uuid, sizeof(afs_uuid)) == 0) | |
442 | reply.match = htonl(0); | |
443 | else | |
444 | reply.match = htonl(1); | |
445 | ||
446 | afs_send_simple_reply(call, &reply, sizeof(reply)); | |
447 | _leave(""); | |
448 | } | |
449 | ||
450 | /* | |
451 | * deliver request data to a CB.ProbeUuid call | |
452 | */ | |
453 | static int afs_deliver_cb_probe_uuid(struct afs_call *call, struct sk_buff *skb, | |
454 | bool last) | |
455 | { | |
456 | struct afs_uuid *r; | |
457 | unsigned loop; | |
458 | __be32 *b; | |
459 | int ret; | |
460 | ||
461 | _enter("{%u},{%u},%d", call->unmarshall, skb->len, last); | |
462 | ||
463 | if (skb->len > 0) | |
464 | return -EBADMSG; | |
465 | if (!last) | |
466 | return 0; | |
467 | ||
468 | switch (call->unmarshall) { | |
469 | case 0: | |
470 | call->offset = 0; | |
471 | call->buffer = kmalloc(11 * sizeof(__be32), GFP_KERNEL); | |
472 | if (!call->buffer) | |
473 | return -ENOMEM; | |
474 | call->unmarshall++; | |
475 | ||
476 | case 1: | |
477 | _debug("extract UUID"); | |
478 | ret = afs_extract_data(call, skb, last, call->buffer, | |
479 | 11 * sizeof(__be32)); | |
480 | switch (ret) { | |
481 | case 0: break; | |
482 | case -EAGAIN: return 0; | |
483 | default: return ret; | |
484 | } | |
485 | ||
486 | _debug("unmarshall UUID"); | |
487 | call->request = kmalloc(sizeof(struct afs_uuid), GFP_KERNEL); | |
488 | if (!call->request) | |
489 | return -ENOMEM; | |
490 | ||
491 | b = call->buffer; | |
492 | r = call->request; | |
493 | r->time_low = ntohl(b[0]); | |
494 | r->time_mid = ntohl(b[1]); | |
495 | r->time_hi_and_version = ntohl(b[2]); | |
496 | r->clock_seq_hi_and_reserved = ntohl(b[3]); | |
497 | r->clock_seq_low = ntohl(b[4]); | |
498 | ||
499 | for (loop = 0; loop < 6; loop++) | |
500 | r->node[loop] = ntohl(b[loop + 5]); | |
501 | ||
502 | call->offset = 0; | |
503 | call->unmarshall++; | |
504 | ||
505 | case 2: | |
506 | _debug("trailer"); | |
507 | if (skb->len != 0) | |
508 | return -EBADMSG; | |
509 | break; | |
510 | } | |
511 | ||
512 | if (!last) | |
513 | return 0; | |
514 | ||
515 | call->state = AFS_CALL_REPLYING; | |
516 | ||
517 | INIT_WORK(&call->work, SRXAFSCB_ProbeUuid); | |
0ad53eee | 518 | queue_work(afs_wq, &call->work); |
9396d496 DH |
519 | return 0; |
520 | } | |
521 | ||
b908fe6b DH |
522 | /* |
523 | * allow the fileserver to ask about the cache manager's capabilities | |
524 | */ | |
7c80bcce | 525 | static void SRXAFSCB_TellMeAboutYourself(struct work_struct *work) |
b908fe6b DH |
526 | { |
527 | struct afs_interface *ifs; | |
528 | struct afs_call *call = container_of(work, struct afs_call, work); | |
529 | int loop, nifs; | |
530 | ||
531 | struct { | |
532 | struct /* InterfaceAddr */ { | |
533 | __be32 nifs; | |
534 | __be32 uuid[11]; | |
535 | __be32 ifaddr[32]; | |
536 | __be32 netmask[32]; | |
537 | __be32 mtu[32]; | |
538 | } ia; | |
539 | struct /* Capabilities */ { | |
540 | __be32 capcount; | |
541 | __be32 caps[1]; | |
542 | } cap; | |
543 | } reply; | |
544 | ||
545 | _enter(""); | |
546 | ||
547 | nifs = 0; | |
548 | ifs = kcalloc(32, sizeof(*ifs), GFP_KERNEL); | |
549 | if (ifs) { | |
550 | nifs = afs_get_ipv4_interfaces(ifs, 32, false); | |
551 | if (nifs < 0) { | |
552 | kfree(ifs); | |
553 | ifs = NULL; | |
554 | nifs = 0; | |
555 | } | |
556 | } | |
557 | ||
558 | memset(&reply, 0, sizeof(reply)); | |
559 | reply.ia.nifs = htonl(nifs); | |
560 | ||
561 | reply.ia.uuid[0] = htonl(afs_uuid.time_low); | |
562 | reply.ia.uuid[1] = htonl(afs_uuid.time_mid); | |
563 | reply.ia.uuid[2] = htonl(afs_uuid.time_hi_and_version); | |
564 | reply.ia.uuid[3] = htonl((s8) afs_uuid.clock_seq_hi_and_reserved); | |
565 | reply.ia.uuid[4] = htonl((s8) afs_uuid.clock_seq_low); | |
566 | for (loop = 0; loop < 6; loop++) | |
567 | reply.ia.uuid[loop + 5] = htonl((s8) afs_uuid.node[loop]); | |
568 | ||
569 | if (ifs) { | |
570 | for (loop = 0; loop < nifs; loop++) { | |
571 | reply.ia.ifaddr[loop] = ifs[loop].address.s_addr; | |
572 | reply.ia.netmask[loop] = ifs[loop].netmask.s_addr; | |
573 | reply.ia.mtu[loop] = htonl(ifs[loop].mtu); | |
574 | } | |
5b35fad9 | 575 | kfree(ifs); |
b908fe6b DH |
576 | } |
577 | ||
578 | reply.cap.capcount = htonl(1); | |
579 | reply.cap.caps[0] = htonl(AFS_CAP_ERROR_TRANSLATION); | |
580 | afs_send_simple_reply(call, &reply, sizeof(reply)); | |
581 | ||
582 | _leave(""); | |
583 | } | |
584 | ||
585 | /* | |
7c80bcce | 586 | * deliver request data to a CB.TellMeAboutYourself call |
b908fe6b | 587 | */ |
7c80bcce DH |
588 | static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *call, |
589 | struct sk_buff *skb, bool last) | |
b908fe6b DH |
590 | { |
591 | _enter(",{%u},%d", skb->len, last); | |
592 | ||
593 | if (skb->len > 0) | |
594 | return -EBADMSG; | |
595 | if (!last) | |
596 | return 0; | |
597 | ||
598 | /* no unmarshalling required */ | |
599 | call->state = AFS_CALL_REPLYING; | |
600 | ||
7c80bcce | 601 | INIT_WORK(&call->work, SRXAFSCB_TellMeAboutYourself); |
0ad53eee | 602 | queue_work(afs_wq, &call->work); |
b908fe6b DH |
603 | return 0; |
604 | } |