?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
acpi: Introduce acpi_arch_get_root_pointer() for getting rsdp address
[linux-2.6/btrfs-unstable.git] / net / rxrpc / conn_event.c
blobb1dfae1074310299fb92a205483ba9437d639af2
1 /* connection-level event handling
2 *
3 * Copyright (C) 2007 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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13
14 #include <linux/module.h>
15 #include <linux/net.h>
16 #include <linux/skbuff.h>
17 #include <linux/errqueue.h>
18 #include <net/sock.h>
19 #include <net/af_rxrpc.h>
20 #include <net/ip.h>
21 #include "ar-internal.h"
22
23 /*
24 * Retransmit terminal ACK or ABORT of the previous call.
25 */
26 static void rxrpc_conn_retransmit_call(struct rxrpc_connection *conn,
27 struct sk_buff *skb,
28 unsigned int channel)
29 {
30 struct rxrpc_skb_priv *sp = skb ? rxrpc_skb(skb) : NULL;
31 struct rxrpc_channel *chan;
32 struct msghdr msg;
33 struct kvec iov[3];
34 struct {
35 struct rxrpc_wire_header whdr;
36 union {
37 __be32 abort_code;
38 struct rxrpc_ackpacket ack;
39 };
40 } __attribute__((packed)) pkt;
41 struct rxrpc_ackinfo ack_info;
42 size_t len;
43 int ioc;
44 u32 serial, mtu, call_id, padding;
45
46 _enter("%d", conn->debug_id);
47
48 chan = &conn->channels[channel];
49
50 /* If the last call got moved on whilst we were waiting to run, just
51 * ignore this packet.
52 */
53 call_id = READ_ONCE(chan->last_call);
54 /* Sync with __rxrpc_disconnect_call() */
55 smp_rmb();
56 if (skb && call_id != sp->hdr.callNumber)
57 return;
58
59 msg.msg_name = &conn->params.peer->srx.transport;
60 msg.msg_namelen = conn->params.peer->srx.transport_len;
61 msg.msg_control = NULL;
62 msg.msg_controllen = 0;
63 msg.msg_flags = 0;
64
65 iov[0].iov_base = &pkt;
66 iov[0].iov_len = sizeof(pkt.whdr);
67 iov[1].iov_base = &padding;
68 iov[1].iov_len = 3;
69 iov[2].iov_base = &ack_info;
70 iov[2].iov_len = sizeof(ack_info);
71
72 pkt.whdr.epoch = htonl(conn->proto.epoch);
73 pkt.whdr.cid = htonl(conn->proto.cid);
74 pkt.whdr.callNumber = htonl(call_id);
75 pkt.whdr.seq = 0;
76 pkt.whdr.type = chan->last_type;
77 pkt.whdr.flags = conn->out_clientflag;
78 pkt.whdr.userStatus = 0;
79 pkt.whdr.securityIndex = conn->security_ix;
80 pkt.whdr._rsvd = 0;
81 pkt.whdr.serviceId = htons(conn->service_id);
82
83 len = sizeof(pkt.whdr);
84 switch (chan->last_type) {
85 case RXRPC_PACKET_TYPE_ABORT:
86 pkt.abort_code = htonl(chan->last_abort);
87 iov[0].iov_len += sizeof(pkt.abort_code);
88 len += sizeof(pkt.abort_code);
89 ioc = 1;
90 break;
91
92 case RXRPC_PACKET_TYPE_ACK:
93 mtu = conn->params.peer->if_mtu;
94 mtu -= conn->params.peer->hdrsize;
95 pkt.ack.bufferSpace = 0;
96 pkt.ack.maxSkew = htons(skb ? skb->priority : 0);
97 pkt.ack.firstPacket = htonl(chan->last_seq + 1);
98 pkt.ack.previousPacket = htonl(chan->last_seq);
99 pkt.ack.serial = htonl(skb ? sp->hdr.serial : 0);
100 pkt.ack.reason = skb ? RXRPC_ACK_DUPLICATE : RXRPC_ACK_IDLE;
101 pkt.ack.nAcks = 0;
102 ack_info.rxMTU = htonl(rxrpc_rx_mtu);
103 ack_info.maxMTU = htonl(mtu);
104 ack_info.rwind = htonl(rxrpc_rx_window_size);
105 ack_info.jumbo_max = htonl(rxrpc_rx_jumbo_max);
106 pkt.whdr.flags |= RXRPC_SLOW_START_OK;
107 padding = 0;
108 iov[0].iov_len += sizeof(pkt.ack);
109 len += sizeof(pkt.ack) + 3 + sizeof(ack_info);
110 ioc = 3;
111 break;
112
113 default:
114 return;
115 }
116
117 /* Resync with __rxrpc_disconnect_call() and check that the last call
118 * didn't get advanced whilst we were filling out the packets.
119 */
120 smp_rmb();
121 if (READ_ONCE(chan->last_call) != call_id)
122 return;
123
124 serial = atomic_inc_return(&conn->serial);
125 pkt.whdr.serial = htonl(serial);
126
127 switch (chan->last_type) {
128 case RXRPC_PACKET_TYPE_ABORT:
129 _proto("Tx ABORT %%%u { %d } [re]", serial, conn->local_abort);
130 break;
131 case RXRPC_PACKET_TYPE_ACK:
132 trace_rxrpc_tx_ack(NULL, serial, chan->last_seq, 0,
133 RXRPC_ACK_DUPLICATE, 0);
134 _proto("Tx ACK %%%u [re]", serial);
135 break;
136 }
137
138 kernel_sendmsg(conn->params.local->socket, &msg, iov, ioc, len);
139 _leave("");
140 return;
141 }
142
143 /*
144 * pass a connection-level abort onto all calls on that connection
145 */
146 static void rxrpc_abort_calls(struct rxrpc_connection *conn,
147 enum rxrpc_call_completion compl,
148 u32 abort_code, int error)
149 {
150 struct rxrpc_call *call;
151 int i;
152
153 _enter("{%d},%x", conn->debug_id, abort_code);
154
155 spin_lock(&conn->channel_lock);
156
157 for (i = 0; i < RXRPC_MAXCALLS; i++) {
158 call = rcu_dereference_protected(
159 conn->channels[i].call,
160 lockdep_is_held(&conn->channel_lock));
161 if (call) {
162 if (compl == RXRPC_CALL_LOCALLY_ABORTED)
163 trace_rxrpc_abort("CON", call->cid,
164 call->call_id, 0,
165 abort_code, error);
166 if (rxrpc_set_call_completion(call, compl,
167 abort_code, error))
168 rxrpc_notify_socket(call);
169 }
170 }
171
172 spin_unlock(&conn->channel_lock);
173 _leave("");
174 }
175
176 /*
177 * generate a connection-level abort
178 */
179 static int rxrpc_abort_connection(struct rxrpc_connection *conn,
180 int error, u32 abort_code)
181 {
182 struct rxrpc_wire_header whdr;
183 struct msghdr msg;
184 struct kvec iov[2];
185 __be32 word;
186 size_t len;
187 u32 serial;
188 int ret;
189
190 _enter("%d,,%u,%u", conn->debug_id, error, abort_code);
191
192 /* generate a connection-level abort */
193 spin_lock_bh(&conn->state_lock);
194 if (conn->state >= RXRPC_CONN_REMOTELY_ABORTED) {
195 spin_unlock_bh(&conn->state_lock);
196 _leave(" = 0 [already dead]");
197 return 0;
198 }
199
200 conn->state = RXRPC_CONN_LOCALLY_ABORTED;
201 spin_unlock_bh(&conn->state_lock);
202
203 rxrpc_abort_calls(conn, RXRPC_CALL_LOCALLY_ABORTED, abort_code, error);
204
205 msg.msg_name = &conn->params.peer->srx.transport;
206 msg.msg_namelen = conn->params.peer->srx.transport_len;
207 msg.msg_control = NULL;
208 msg.msg_controllen = 0;
209 msg.msg_flags = 0;
210
211 whdr.epoch = htonl(conn->proto.epoch);
212 whdr.cid = htonl(conn->proto.cid);
213 whdr.callNumber = 0;
214 whdr.seq = 0;
215 whdr.type = RXRPC_PACKET_TYPE_ABORT;
216 whdr.flags = conn->out_clientflag;
217 whdr.userStatus = 0;
218 whdr.securityIndex = conn->security_ix;
219 whdr._rsvd = 0;
220 whdr.serviceId = htons(conn->service_id);
221
222 word = htonl(conn->local_abort);
223
224 iov[0].iov_base = &whdr;
225 iov[0].iov_len = sizeof(whdr);
226 iov[1].iov_base = &word;
227 iov[1].iov_len = sizeof(word);
228
229 len = iov[0].iov_len + iov[1].iov_len;
230
231 serial = atomic_inc_return(&conn->serial);
232 whdr.serial = htonl(serial);
233 _proto("Tx CONN ABORT %%%u { %d }", serial, conn->local_abort);
234
235 ret = kernel_sendmsg(conn->params.local->socket, &msg, iov, 2, len);
236 if (ret < 0) {
237 _debug("sendmsg failed: %d", ret);
238 return -EAGAIN;
239 }
240
241 _leave(" = 0");
242 return 0;
243 }
244
245 /*
246 * mark a call as being on a now-secured channel
247 * - must be called with BH's disabled.
248 */
249 static void rxrpc_call_is_secure(struct rxrpc_call *call)
250 {
251 _enter("%p", call);
252 if (call) {
253 write_lock_bh(&call->state_lock);
254 if (call->state == RXRPC_CALL_SERVER_SECURING) {
255 call->state = RXRPC_CALL_SERVER_ACCEPTING;
256 rxrpc_notify_socket(call);
257 }
258 write_unlock_bh(&call->state_lock);
259 }
260 }
261
262 /*
263 * connection-level Rx packet processor
264 */
265 static int rxrpc_process_event(struct rxrpc_connection *conn,
266 struct sk_buff *skb,
267 u32 *_abort_code)
268 {
269 struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
270 __be32 wtmp;
271 u32 abort_code;
272 int loop, ret;
273
274 if (conn->state >= RXRPC_CONN_REMOTELY_ABORTED) {
275 _leave(" = -ECONNABORTED [%u]", conn->state);
276 return -ECONNABORTED;
277 }
278
279 _enter("{%d},{%u,%%%u},", conn->debug_id, sp->hdr.type, sp->hdr.serial);
280
281 switch (sp->hdr.type) {
282 case RXRPC_PACKET_TYPE_DATA:
283 case RXRPC_PACKET_TYPE_ACK:
284 rxrpc_conn_retransmit_call(conn, skb,
285 sp->hdr.cid & RXRPC_CHANNELMASK);
286 return 0;
287
288 case RXRPC_PACKET_TYPE_BUSY:
289 /* Just ignore BUSY packets for now. */
290 return 0;
291
292 case RXRPC_PACKET_TYPE_ABORT:
293 if (skb_copy_bits(skb, sizeof(struct rxrpc_wire_header),
294 &wtmp, sizeof(wtmp)) < 0) {
295 trace_rxrpc_rx_eproto(NULL, sp->hdr.serial,
296 tracepoint_string("bad_abort"));
297 return -EPROTO;
298 }
299 abort_code = ntohl(wtmp);
300 _proto("Rx ABORT %%%u { ac=%d }", sp->hdr.serial, abort_code);
301
302 conn->state = RXRPC_CONN_REMOTELY_ABORTED;
303 rxrpc_abort_calls(conn, RXRPC_CALL_REMOTELY_ABORTED,
304 abort_code, -ECONNABORTED);
305 return -ECONNABORTED;
306
307 case RXRPC_PACKET_TYPE_CHALLENGE:
308 return conn->security->respond_to_challenge(conn, skb,
309 _abort_code);
310
311 case RXRPC_PACKET_TYPE_RESPONSE:
312 ret = conn->security->verify_response(conn, skb, _abort_code);
313 if (ret < 0)
314 return ret;
315
316 ret = conn->security->init_connection_security(conn);
317 if (ret < 0)
318 return ret;
319
320 ret = conn->security->prime_packet_security(conn);
321 if (ret < 0)
322 return ret;
323
324 spin_lock(&conn->channel_lock);
325 spin_lock(&conn->state_lock);
326
327 if (conn->state == RXRPC_CONN_SERVICE_CHALLENGING) {
328 conn->state = RXRPC_CONN_SERVICE;
329 spin_unlock(&conn->state_lock);
330 for (loop = 0; loop < RXRPC_MAXCALLS; loop++)
331 rxrpc_call_is_secure(
332 rcu_dereference_protected(
333 conn->channels[loop].call,
334 lockdep_is_held(&conn->channel_lock)));
335 } else {
336 spin_unlock(&conn->state_lock);
337 }
338
339 spin_unlock(&conn->channel_lock);
340 return 0;
341
342 default:
343 trace_rxrpc_rx_eproto(NULL, sp->hdr.serial,
344 tracepoint_string("bad_conn_pkt"));
345 return -EPROTO;
346 }
347 }
348
349 /*
350 * set up security and issue a challenge
351 */
352 static void rxrpc_secure_connection(struct rxrpc_connection *conn)
353 {
354 u32 abort_code;
355 int ret;
356
357 _enter("{%d}", conn->debug_id);
358
359 ASSERT(conn->security_ix != 0);
360
361 if (!conn->params.key) {
362 _debug("set up security");
363 ret = rxrpc_init_server_conn_security(conn);
364 switch (ret) {
365 case 0:
366 break;
367 case -ENOENT:
368 abort_code = RX_CALL_DEAD;
369 goto abort;
370 default:
371 abort_code = RXKADNOAUTH;
372 goto abort;
373 }
374 }
375
376 if (conn->security->issue_challenge(conn) < 0) {
377 abort_code = RX_CALL_DEAD;
378 ret = -ENOMEM;
379 goto abort;
380 }
381
382 _leave("");
383 return;
384
385 abort:
386 _debug("abort %d, %d", ret, abort_code);
387 rxrpc_abort_connection(conn, ret, abort_code);
388 _leave(" [aborted]");
389 }
390
391 /*
392 * Process delayed final ACKs that we haven't subsumed into a subsequent call.
393 */
394 static void rxrpc_process_delayed_final_acks(struct rxrpc_connection *conn)
395 {
396 unsigned long j = jiffies, next_j;
397 unsigned int channel;
398 bool set;
399
400 again:
401 next_j = j + LONG_MAX;
402 set = false;
403 for (channel = 0; channel < RXRPC_MAXCALLS; channel++) {
404 struct rxrpc_channel *chan = &conn->channels[channel];
405 unsigned long ack_at;
406
407 if (!test_bit(RXRPC_CONN_FINAL_ACK_0 + channel, &conn->flags))
408 continue;
409
410 smp_rmb(); /* vs rxrpc_disconnect_client_call */
411 ack_at = READ_ONCE(chan->final_ack_at);
412
413 if (time_before(j, ack_at)) {
414 if (time_before(ack_at, next_j)) {
415 next_j = ack_at;
416 set = true;
417 }
418 continue;
419 }
420
421 if (test_and_clear_bit(RXRPC_CONN_FINAL_ACK_0 + channel,
422 &conn->flags))
423 rxrpc_conn_retransmit_call(conn, NULL, channel);
424 }
425
426 j = jiffies;
427 if (time_before_eq(next_j, j))
428 goto again;
429 if (set)
430 rxrpc_reduce_conn_timer(conn, next_j);
431 }
432
433 /*
434 * connection-level event processor
435 */
436 void rxrpc_process_connection(struct work_struct *work)
437 {
438 struct rxrpc_connection *conn =
439 container_of(work, struct rxrpc_connection, processor);
440 struct sk_buff *skb;
441 u32 abort_code = RX_PROTOCOL_ERROR;
442 int ret;
443
444 rxrpc_see_connection(conn);
445
446 if (test_and_clear_bit(RXRPC_CONN_EV_CHALLENGE, &conn->events))
447 rxrpc_secure_connection(conn);
448
449 /* Process delayed ACKs whose time has come. */
450 if (conn->flags & RXRPC_CONN_FINAL_ACK_MASK)
451 rxrpc_process_delayed_final_acks(conn);
452
453 /* go through the conn-level event packets, releasing the ref on this
454 * connection that each one has when we've finished with it */
455 while ((skb = skb_dequeue(&conn->rx_queue))) {
456 rxrpc_see_skb(skb, rxrpc_skb_rx_seen);
457 ret = rxrpc_process_event(conn, skb, &abort_code);
458 switch (ret) {
459 case -EPROTO:
460 case -EKEYEXPIRED:
461 case -EKEYREJECTED:
462 goto protocol_error;
463 case -ENOMEM:
464 case -EAGAIN:
465 goto requeue_and_leave;
466 case -ECONNABORTED:
467 default:
468 rxrpc_free_skb(skb, rxrpc_skb_rx_freed);
469 break;
470 }
471 }
472
473 out:
474 rxrpc_put_connection(conn);
475 _leave("");
476 return;
477
478 requeue_and_leave:
479 skb_queue_head(&conn->rx_queue, skb);
480 goto out;
481
482 protocol_error:
483 if (rxrpc_abort_connection(conn, ret, abort_code) < 0)
484 goto requeue_and_leave;
485 rxrpc_free_skb(skb, rxrpc_skb_rx_freed);
486 goto out;
487 }
(deprecated) Btrfs devel tree