Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * llc_conn.c - Driver routines for connection component. | |
3 | * | |
4 | * Copyright (c) 1997 by Procom Technology, Inc. | |
5 | * 2001-2003 by Arnaldo Carvalho de Melo <acme@conectiva.com.br> | |
6 | * | |
7 | * This program can be redistributed or modified under the terms of the | |
8 | * GNU General Public License as published by the Free Software Foundation. | |
9 | * This program is distributed without any warranty or implied warranty | |
10 | * of merchantability or fitness for a particular purpose. | |
11 | * | |
12 | * See the GNU General Public License for more details. | |
13 | */ | |
14 | ||
15 | #include <linux/init.h> | |
5a0e3ad6 | 16 | #include <linux/slab.h> |
1da177e4 LT |
17 | #include <net/llc_sap.h> |
18 | #include <net/llc_conn.h> | |
19 | #include <net/sock.h> | |
c752f073 | 20 | #include <net/tcp_states.h> |
1da177e4 LT |
21 | #include <net/llc_c_ev.h> |
22 | #include <net/llc_c_ac.h> | |
23 | #include <net/llc_c_st.h> | |
24 | #include <net/llc_pdu.h> | |
25 | ||
26 | #if 0 | |
27 | #define dprintk(args...) printk(KERN_DEBUG args) | |
28 | #else | |
29 | #define dprintk(args...) | |
30 | #endif | |
31 | ||
32 | static int llc_find_offset(int state, int ev_type); | |
b74555de | 33 | static void llc_conn_send_pdus(struct sock *sk); |
1da177e4 LT |
34 | static int llc_conn_service(struct sock *sk, struct sk_buff *skb); |
35 | static int llc_exec_conn_trans_actions(struct sock *sk, | |
36 | struct llc_conn_state_trans *trans, | |
37 | struct sk_buff *ev); | |
38 | static struct llc_conn_state_trans *llc_qualify_conn_ev(struct sock *sk, | |
39 | struct sk_buff *skb); | |
40 | ||
41 | /* Offset table on connection states transition diagram */ | |
42 | static int llc_offset_table[NBR_CONN_STATES][NBR_CONN_EV]; | |
43 | ||
590232a7 ACM |
44 | int sysctl_llc2_ack_timeout = LLC2_ACK_TIME * HZ; |
45 | int sysctl_llc2_p_timeout = LLC2_P_TIME * HZ; | |
46 | int sysctl_llc2_rej_timeout = LLC2_REJ_TIME * HZ; | |
47 | int sysctl_llc2_busy_timeout = LLC2_BUSY_TIME * HZ; | |
48 | ||
1da177e4 LT |
49 | /** |
50 | * llc_conn_state_process - sends event to connection state machine | |
51 | * @sk: connection | |
52 | * @skb: occurred event | |
53 | * | |
54 | * Sends an event to connection state machine. After processing event | |
55 | * (executing it's actions and changing state), upper layer will be | |
56 | * indicated or confirmed, if needed. Returns 0 for success, 1 for | |
57 | * failure. The socket lock has to be held before calling this function. | |
fc8d5db1 EB |
58 | * |
59 | * This function always consumes a reference to the skb. | |
1da177e4 LT |
60 | */ |
61 | int llc_conn_state_process(struct sock *sk, struct sk_buff *skb) | |
62 | { | |
63 | int rc; | |
d389424e | 64 | struct llc_sock *llc = llc_sk(skb->sk); |
1da177e4 LT |
65 | struct llc_conn_state_ev *ev = llc_conn_ev(skb); |
66 | ||
1da177e4 | 67 | ev->ind_prim = ev->cfm_prim = 0; |
d389424e ACM |
68 | /* |
69 | * Send event to state machine | |
70 | */ | |
71 | rc = llc_conn_service(skb->sk, skb); | |
af426d32 | 72 | if (unlikely(rc != 0)) { |
0dc47877 | 73 | printk(KERN_ERR "%s: llc_conn_service failed\n", __func__); |
1da177e4 LT |
74 | goto out_skb_put; |
75 | } | |
76 | ||
1da177e4 LT |
77 | switch (ev->ind_prim) { |
78 | case LLC_DATA_PRIM: | |
36453c85 | 79 | skb_get(skb); |
04e4223f ACM |
80 | llc_save_primitive(sk, skb, LLC_DATA_PRIM); |
81 | if (unlikely(sock_queue_rcv_skb(sk, skb))) { | |
1da177e4 LT |
82 | /* |
83 | * shouldn't happen | |
84 | */ | |
85 | printk(KERN_ERR "%s: sock_queue_rcv_skb failed!\n", | |
0dc47877 | 86 | __func__); |
1da177e4 LT |
87 | kfree_skb(skb); |
88 | } | |
89 | break; | |
d389424e | 90 | case LLC_CONN_PRIM: |
04e4223f | 91 | /* |
d389424e ACM |
92 | * Can't be sock_queue_rcv_skb, because we have to leave the |
93 | * skb->sk pointing to the newly created struct sock in | |
94 | * llc_conn_handler. -acme | |
04e4223f | 95 | */ |
36453c85 | 96 | skb_get(skb); |
d389424e ACM |
97 | skb_queue_tail(&sk->sk_receive_queue, skb); |
98 | sk->sk_state_change(sk); | |
1da177e4 LT |
99 | break; |
100 | case LLC_DISC_PRIM: | |
101 | sock_hold(sk); | |
102 | if (sk->sk_type == SOCK_STREAM && | |
103 | sk->sk_state == TCP_ESTABLISHED) { | |
104 | sk->sk_shutdown = SHUTDOWN_MASK; | |
105 | sk->sk_socket->state = SS_UNCONNECTED; | |
106 | sk->sk_state = TCP_CLOSE; | |
107 | if (!sock_flag(sk, SOCK_DEAD)) { | |
1da177e4 | 108 | sock_set_flag(sk, SOCK_DEAD); |
8420e1b5 | 109 | sk->sk_state_change(sk); |
1da177e4 LT |
110 | } |
111 | } | |
1da177e4 LT |
112 | sock_put(sk); |
113 | break; | |
114 | case LLC_RESET_PRIM: | |
115 | /* | |
116 | * FIXME: | |
117 | * RESET is not being notified to upper layers for now | |
118 | */ | |
0dc47877 | 119 | printk(KERN_INFO "%s: received a reset ind!\n", __func__); |
1da177e4 LT |
120 | break; |
121 | default: | |
36453c85 | 122 | if (ev->ind_prim) |
1da177e4 | 123 | printk(KERN_INFO "%s: received unknown %d prim!\n", |
0dc47877 | 124 | __func__, ev->ind_prim); |
1da177e4 LT |
125 | /* No indication */ |
126 | break; | |
127 | } | |
128 | ||
129 | switch (ev->cfm_prim) { | |
130 | case LLC_DATA_PRIM: | |
131 | if (!llc_data_accept_state(llc->state)) | |
132 | sk->sk_write_space(sk); | |
133 | else | |
134 | rc = llc->failed_data_req = 1; | |
135 | break; | |
136 | case LLC_CONN_PRIM: | |
137 | if (sk->sk_type == SOCK_STREAM && | |
138 | sk->sk_state == TCP_SYN_SENT) { | |
139 | if (ev->status) { | |
140 | sk->sk_socket->state = SS_UNCONNECTED; | |
141 | sk->sk_state = TCP_CLOSE; | |
142 | } else { | |
143 | sk->sk_socket->state = SS_CONNECTED; | |
144 | sk->sk_state = TCP_ESTABLISHED; | |
145 | } | |
146 | sk->sk_state_change(sk); | |
147 | } | |
148 | break; | |
149 | case LLC_DISC_PRIM: | |
150 | sock_hold(sk); | |
151 | if (sk->sk_type == SOCK_STREAM && sk->sk_state == TCP_CLOSING) { | |
152 | sk->sk_socket->state = SS_UNCONNECTED; | |
153 | sk->sk_state = TCP_CLOSE; | |
154 | sk->sk_state_change(sk); | |
155 | } | |
156 | sock_put(sk); | |
157 | break; | |
158 | case LLC_RESET_PRIM: | |
159 | /* | |
160 | * FIXME: | |
161 | * RESET is not being notified to upper layers for now | |
162 | */ | |
0dc47877 | 163 | printk(KERN_INFO "%s: received a reset conf!\n", __func__); |
1da177e4 LT |
164 | break; |
165 | default: | |
36453c85 | 166 | if (ev->cfm_prim) |
1da177e4 | 167 | printk(KERN_INFO "%s: received unknown %d prim!\n", |
0dc47877 | 168 | __func__, ev->cfm_prim); |
36453c85 EB |
169 | /* No confirmation */ |
170 | break; | |
1da177e4 | 171 | } |
1da177e4 LT |
172 | out_skb_put: |
173 | kfree_skb(skb); | |
174 | return rc; | |
175 | } | |
176 | ||
b74555de | 177 | void llc_conn_send_pdu(struct sock *sk, struct sk_buff *skb) |
1da177e4 LT |
178 | { |
179 | /* queue PDU to send to MAC layer */ | |
180 | skb_queue_tail(&sk->sk_write_queue, skb); | |
b74555de | 181 | llc_conn_send_pdus(sk); |
1da177e4 LT |
182 | } |
183 | ||
184 | /** | |
185 | * llc_conn_rtn_pdu - sends received data pdu to upper layer | |
186 | * @sk: Active connection | |
187 | * @skb: Received data frame | |
188 | * | |
189 | * Sends received data pdu to upper layer (by using indicate function). | |
190 | * Prepares service parameters (prim and prim_data). calling indication | |
191 | * function will be done in llc_conn_state_process. | |
192 | */ | |
193 | void llc_conn_rtn_pdu(struct sock *sk, struct sk_buff *skb) | |
194 | { | |
195 | struct llc_conn_state_ev *ev = llc_conn_ev(skb); | |
196 | ||
197 | ev->ind_prim = LLC_DATA_PRIM; | |
198 | } | |
199 | ||
200 | /** | |
201 | * llc_conn_resend_i_pdu_as_cmd - resend all all unacknowledged I PDUs | |
202 | * @sk: active connection | |
203 | * @nr: NR | |
204 | * @first_p_bit: p_bit value of first pdu | |
205 | * | |
206 | * Resend all unacknowledged I PDUs, starting with the NR; send first as | |
207 | * command PDU with P bit equal first_p_bit; if more than one send | |
208 | * subsequent as command PDUs with P bit equal zero (0). | |
209 | */ | |
210 | void llc_conn_resend_i_pdu_as_cmd(struct sock *sk, u8 nr, u8 first_p_bit) | |
211 | { | |
212 | struct sk_buff *skb; | |
213 | struct llc_pdu_sn *pdu; | |
214 | u16 nbr_unack_pdus; | |
215 | struct llc_sock *llc; | |
216 | u8 howmany_resend = 0; | |
217 | ||
218 | llc_conn_remove_acked_pdus(sk, nr, &nbr_unack_pdus); | |
219 | if (!nbr_unack_pdus) | |
220 | goto out; | |
221 | /* | |
222 | * Process unack PDUs only if unack queue is not empty; remove | |
223 | * appropriate PDUs, fix them up, and put them on mac_pdu_q. | |
224 | */ | |
225 | llc = llc_sk(sk); | |
226 | ||
227 | while ((skb = skb_dequeue(&llc->pdu_unack_q)) != NULL) { | |
228 | pdu = llc_pdu_sn_hdr(skb); | |
229 | llc_pdu_set_cmd_rsp(skb, LLC_PDU_CMD); | |
230 | llc_pdu_set_pf_bit(skb, first_p_bit); | |
231 | skb_queue_tail(&sk->sk_write_queue, skb); | |
232 | first_p_bit = 0; | |
233 | llc->vS = LLC_I_GET_NS(pdu); | |
234 | howmany_resend++; | |
235 | } | |
236 | if (howmany_resend > 0) | |
237 | llc->vS = (llc->vS + 1) % LLC_2_SEQ_NBR_MODULO; | |
238 | /* any PDUs to re-send are queued up; start sending to MAC */ | |
b74555de | 239 | llc_conn_send_pdus(sk); |
1da177e4 LT |
240 | out:; |
241 | } | |
242 | ||
243 | /** | |
244 | * llc_conn_resend_i_pdu_as_rsp - Resend all unacknowledged I PDUs | |
245 | * @sk: active connection. | |
246 | * @nr: NR | |
247 | * @first_f_bit: f_bit value of first pdu. | |
248 | * | |
249 | * Resend all unacknowledged I PDUs, starting with the NR; send first as | |
250 | * response PDU with F bit equal first_f_bit; if more than one send | |
251 | * subsequent as response PDUs with F bit equal zero (0). | |
252 | */ | |
253 | void llc_conn_resend_i_pdu_as_rsp(struct sock *sk, u8 nr, u8 first_f_bit) | |
254 | { | |
255 | struct sk_buff *skb; | |
256 | u16 nbr_unack_pdus; | |
257 | struct llc_sock *llc = llc_sk(sk); | |
258 | u8 howmany_resend = 0; | |
259 | ||
260 | llc_conn_remove_acked_pdus(sk, nr, &nbr_unack_pdus); | |
261 | if (!nbr_unack_pdus) | |
262 | goto out; | |
263 | /* | |
264 | * Process unack PDUs only if unack queue is not empty; remove | |
265 | * appropriate PDUs, fix them up, and put them on mac_pdu_q | |
266 | */ | |
267 | while ((skb = skb_dequeue(&llc->pdu_unack_q)) != NULL) { | |
268 | struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb); | |
269 | ||
270 | llc_pdu_set_cmd_rsp(skb, LLC_PDU_RSP); | |
271 | llc_pdu_set_pf_bit(skb, first_f_bit); | |
272 | skb_queue_tail(&sk->sk_write_queue, skb); | |
273 | first_f_bit = 0; | |
274 | llc->vS = LLC_I_GET_NS(pdu); | |
275 | howmany_resend++; | |
276 | } | |
277 | if (howmany_resend > 0) | |
278 | llc->vS = (llc->vS + 1) % LLC_2_SEQ_NBR_MODULO; | |
279 | /* any PDUs to re-send are queued up; start sending to MAC */ | |
b74555de | 280 | llc_conn_send_pdus(sk); |
1da177e4 LT |
281 | out:; |
282 | } | |
283 | ||
284 | /** | |
285 | * llc_conn_remove_acked_pdus - Removes acknowledged pdus from tx queue | |
286 | * @sk: active connection | |
74c950c9 AL |
287 | * @nr: NR |
288 | * @how_many_unacked: size of pdu_unack_q after removing acked pdus | |
1da177e4 LT |
289 | * |
290 | * Removes acknowledged pdus from transmit queue (pdu_unack_q). Returns | |
291 | * the number of pdus that removed from queue. | |
292 | */ | |
293 | int llc_conn_remove_acked_pdus(struct sock *sk, u8 nr, u16 *how_many_unacked) | |
294 | { | |
295 | int pdu_pos, i; | |
296 | struct sk_buff *skb; | |
297 | struct llc_pdu_sn *pdu; | |
298 | int nbr_acked = 0; | |
299 | struct llc_sock *llc = llc_sk(sk); | |
300 | int q_len = skb_queue_len(&llc->pdu_unack_q); | |
301 | ||
302 | if (!q_len) | |
303 | goto out; | |
304 | skb = skb_peek(&llc->pdu_unack_q); | |
305 | pdu = llc_pdu_sn_hdr(skb); | |
306 | ||
307 | /* finding position of last acked pdu in queue */ | |
308 | pdu_pos = ((int)LLC_2_SEQ_NBR_MODULO + (int)nr - | |
309 | (int)LLC_I_GET_NS(pdu)) % LLC_2_SEQ_NBR_MODULO; | |
310 | ||
311 | for (i = 0; i < pdu_pos && i < q_len; i++) { | |
312 | skb = skb_dequeue(&llc->pdu_unack_q); | |
c3431ea7 | 313 | kfree_skb(skb); |
1da177e4 LT |
314 | nbr_acked++; |
315 | } | |
316 | out: | |
317 | *how_many_unacked = skb_queue_len(&llc->pdu_unack_q); | |
318 | return nbr_acked; | |
319 | } | |
320 | ||
321 | /** | |
322 | * llc_conn_send_pdus - Sends queued PDUs | |
323 | * @sk: active connection | |
324 | * | |
b74555de | 325 | * Sends queued pdus to MAC layer for transmission. |
1da177e4 | 326 | */ |
b74555de | 327 | static void llc_conn_send_pdus(struct sock *sk) |
1da177e4 LT |
328 | { |
329 | struct sk_buff *skb; | |
330 | ||
331 | while ((skb = skb_dequeue(&sk->sk_write_queue)) != NULL) { | |
332 | struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb); | |
333 | ||
334 | if (LLC_PDU_TYPE_IS_I(pdu) && | |
335 | !(skb->dev->flags & IFF_LOOPBACK)) { | |
336 | struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC); | |
337 | ||
338 | skb_queue_tail(&llc_sk(sk)->pdu_unack_q, skb); | |
339 | if (!skb2) | |
340 | break; | |
b74555de | 341 | skb = skb2; |
1da177e4 | 342 | } |
b74555de | 343 | dev_queue_xmit(skb); |
1da177e4 LT |
344 | } |
345 | } | |
346 | ||
347 | /** | |
348 | * llc_conn_service - finds transition and changes state of connection | |
349 | * @sk: connection | |
350 | * @skb: happened event | |
351 | * | |
352 | * This function finds transition that matches with happened event, then | |
353 | * executes related actions and finally changes state of connection. | |
354 | * Returns 0 for success, 1 for failure. | |
355 | */ | |
356 | static int llc_conn_service(struct sock *sk, struct sk_buff *skb) | |
357 | { | |
358 | int rc = 1; | |
359 | struct llc_sock *llc = llc_sk(sk); | |
360 | struct llc_conn_state_trans *trans; | |
361 | ||
362 | if (llc->state > NBR_CONN_STATES) | |
363 | goto out; | |
364 | rc = 0; | |
365 | trans = llc_qualify_conn_ev(sk, skb); | |
366 | if (trans) { | |
367 | rc = llc_exec_conn_trans_actions(sk, trans, skb); | |
368 | if (!rc && trans->next_state != NO_STATE_CHANGE) { | |
369 | llc->state = trans->next_state; | |
370 | if (!llc_data_accept_state(llc->state)) | |
371 | sk->sk_state_change(sk); | |
372 | } | |
373 | } | |
374 | out: | |
375 | return rc; | |
376 | } | |
377 | ||
378 | /** | |
379 | * llc_qualify_conn_ev - finds transition for event | |
380 | * @sk: connection | |
381 | * @skb: happened event | |
382 | * | |
383 | * This function finds transition that matches with happened event. | |
384 | * Returns pointer to found transition on success, %NULL otherwise. | |
385 | */ | |
386 | static struct llc_conn_state_trans *llc_qualify_conn_ev(struct sock *sk, | |
387 | struct sk_buff *skb) | |
388 | { | |
389 | struct llc_conn_state_trans **next_trans; | |
9b373069 | 390 | const llc_conn_ev_qfyr_t *next_qualifier; |
1da177e4 LT |
391 | struct llc_conn_state_ev *ev = llc_conn_ev(skb); |
392 | struct llc_sock *llc = llc_sk(sk); | |
393 | struct llc_conn_state *curr_state = | |
394 | &llc_conn_state_table[llc->state - 1]; | |
395 | ||
396 | /* search thru events for this state until | |
397 | * list exhausted or until no more | |
398 | */ | |
399 | for (next_trans = curr_state->transitions + | |
400 | llc_find_offset(llc->state - 1, ev->type); | |
401 | (*next_trans)->ev; next_trans++) { | |
402 | if (!((*next_trans)->ev)(sk, skb)) { | |
403 | /* got POSSIBLE event match; the event may require | |
404 | * qualification based on the values of a number of | |
405 | * state flags; if all qualifications are met (i.e., | |
406 | * if all qualifying functions return success, or 0, | |
407 | * then this is THE event we're looking for | |
408 | */ | |
409 | for (next_qualifier = (*next_trans)->ev_qualifiers; | |
410 | next_qualifier && *next_qualifier && | |
411 | !(*next_qualifier)(sk, skb); next_qualifier++) | |
412 | /* nothing */; | |
413 | if (!next_qualifier || !*next_qualifier) | |
414 | /* all qualifiers executed successfully; this is | |
415 | * our transition; return it so we can perform | |
416 | * the associated actions & change the state | |
417 | */ | |
418 | return *next_trans; | |
419 | } | |
420 | } | |
421 | return NULL; | |
422 | } | |
423 | ||
424 | /** | |
425 | * llc_exec_conn_trans_actions - executes related actions | |
426 | * @sk: connection | |
427 | * @trans: transition that it's actions must be performed | |
428 | * @skb: event | |
429 | * | |
430 | * Executes actions that is related to happened event. Returns 0 for | |
431 | * success, 1 to indicate failure of at least one action. | |
432 | */ | |
433 | static int llc_exec_conn_trans_actions(struct sock *sk, | |
434 | struct llc_conn_state_trans *trans, | |
435 | struct sk_buff *skb) | |
436 | { | |
437 | int rc = 0; | |
14b7d95f | 438 | const llc_conn_action_t *next_action; |
1da177e4 LT |
439 | |
440 | for (next_action = trans->ev_actions; | |
441 | next_action && *next_action; next_action++) { | |
442 | int rc2 = (*next_action)(sk, skb); | |
443 | ||
444 | if (rc2 == 2) { | |
445 | rc = rc2; | |
446 | break; | |
447 | } else if (rc2) | |
448 | rc = 1; | |
449 | } | |
450 | return rc; | |
451 | } | |
452 | ||
b76f5a84 OP |
453 | static inline bool llc_estab_match(const struct llc_sap *sap, |
454 | const struct llc_addr *daddr, | |
455 | const struct llc_addr *laddr, | |
97b1d320 KI |
456 | const struct sock *sk, |
457 | const struct net *net) | |
b76f5a84 OP |
458 | { |
459 | struct llc_sock *llc = llc_sk(sk); | |
460 | ||
97b1d320 KI |
461 | return net_eq(sock_net(sk), net) && |
462 | llc->laddr.lsap == laddr->lsap && | |
b76f5a84 | 463 | llc->daddr.lsap == daddr->lsap && |
951fd874 JP |
464 | ether_addr_equal(llc->laddr.mac, laddr->mac) && |
465 | ether_addr_equal(llc->daddr.mac, daddr->mac); | |
b76f5a84 OP |
466 | } |
467 | ||
1da177e4 | 468 | /** |
d389424e | 469 | * __llc_lookup_established - Finds connection for the remote/local sap/mac |
1da177e4 LT |
470 | * @sap: SAP |
471 | * @daddr: address of remote LLC (MAC + SAP) | |
472 | * @laddr: address of local LLC (MAC + SAP) | |
97b1d320 | 473 | * @net: netns to look up a socket in |
1da177e4 LT |
474 | * |
475 | * Search connection list of the SAP and finds connection using the remote | |
476 | * mac, remote sap, local mac, and local sap. Returns pointer for | |
477 | * connection found, %NULL otherwise. | |
d389424e | 478 | * Caller has to make sure local_bh is disabled. |
1da177e4 | 479 | */ |
d389424e ACM |
480 | static struct sock *__llc_lookup_established(struct llc_sap *sap, |
481 | struct llc_addr *daddr, | |
97b1d320 KI |
482 | struct llc_addr *laddr, |
483 | const struct net *net) | |
1da177e4 LT |
484 | { |
485 | struct sock *rc; | |
b76f5a84 | 486 | struct hlist_nulls_node *node; |
52d58aef OP |
487 | int slot = llc_sk_laddr_hashfn(sap, laddr); |
488 | struct hlist_nulls_head *laddr_hb = &sap->sk_laddr_hash[slot]; | |
b76f5a84 OP |
489 | |
490 | rcu_read_lock(); | |
491 | again: | |
52d58aef | 492 | sk_nulls_for_each_rcu(rc, node, laddr_hb) { |
97b1d320 | 493 | if (llc_estab_match(sap, daddr, laddr, rc, net)) { |
5f0d5a3a | 494 | /* Extra checks required by SLAB_TYPESAFE_BY_RCU */ |
41c6d650 | 495 | if (unlikely(!refcount_inc_not_zero(&rc->sk_refcnt))) |
b76f5a84 OP |
496 | goto again; |
497 | if (unlikely(llc_sk(rc)->sap != sap || | |
97b1d320 | 498 | !llc_estab_match(sap, daddr, laddr, rc, net))) { |
b76f5a84 OP |
499 | sock_put(rc); |
500 | continue; | |
501 | } | |
1da177e4 LT |
502 | goto found; |
503 | } | |
504 | } | |
505 | rc = NULL; | |
52d58aef OP |
506 | /* |
507 | * if the nulls value we got at the end of this lookup is | |
508 | * not the expected one, we must restart lookup. | |
509 | * We probably met an item that was moved to another chain. | |
510 | */ | |
511 | if (unlikely(get_nulls_value(node) != slot)) | |
512 | goto again; | |
1da177e4 | 513 | found: |
b76f5a84 | 514 | rcu_read_unlock(); |
1da177e4 LT |
515 | return rc; |
516 | } | |
517 | ||
d389424e ACM |
518 | struct sock *llc_lookup_established(struct llc_sap *sap, |
519 | struct llc_addr *daddr, | |
97b1d320 KI |
520 | struct llc_addr *laddr, |
521 | const struct net *net) | |
d389424e ACM |
522 | { |
523 | struct sock *sk; | |
524 | ||
525 | local_bh_disable(); | |
97b1d320 | 526 | sk = __llc_lookup_established(sap, daddr, laddr, net); |
d389424e ACM |
527 | local_bh_enable(); |
528 | return sk; | |
529 | } | |
530 | ||
b76f5a84 OP |
531 | static inline bool llc_listener_match(const struct llc_sap *sap, |
532 | const struct llc_addr *laddr, | |
97b1d320 KI |
533 | const struct sock *sk, |
534 | const struct net *net) | |
b76f5a84 OP |
535 | { |
536 | struct llc_sock *llc = llc_sk(sk); | |
537 | ||
97b1d320 KI |
538 | return net_eq(sock_net(sk), net) && |
539 | sk->sk_type == SOCK_STREAM && sk->sk_state == TCP_LISTEN && | |
b76f5a84 | 540 | llc->laddr.lsap == laddr->lsap && |
951fd874 | 541 | ether_addr_equal(llc->laddr.mac, laddr->mac); |
b76f5a84 OP |
542 | } |
543 | ||
52d58aef | 544 | static struct sock *__llc_lookup_listener(struct llc_sap *sap, |
97b1d320 KI |
545 | struct llc_addr *laddr, |
546 | const struct net *net) | |
1da177e4 LT |
547 | { |
548 | struct sock *rc; | |
b76f5a84 | 549 | struct hlist_nulls_node *node; |
52d58aef OP |
550 | int slot = llc_sk_laddr_hashfn(sap, laddr); |
551 | struct hlist_nulls_head *laddr_hb = &sap->sk_laddr_hash[slot]; | |
b76f5a84 OP |
552 | |
553 | rcu_read_lock(); | |
554 | again: | |
52d58aef | 555 | sk_nulls_for_each_rcu(rc, node, laddr_hb) { |
97b1d320 | 556 | if (llc_listener_match(sap, laddr, rc, net)) { |
5f0d5a3a | 557 | /* Extra checks required by SLAB_TYPESAFE_BY_RCU */ |
41c6d650 | 558 | if (unlikely(!refcount_inc_not_zero(&rc->sk_refcnt))) |
b76f5a84 OP |
559 | goto again; |
560 | if (unlikely(llc_sk(rc)->sap != sap || | |
97b1d320 | 561 | !llc_listener_match(sap, laddr, rc, net))) { |
b76f5a84 OP |
562 | sock_put(rc); |
563 | continue; | |
564 | } | |
1da177e4 LT |
565 | goto found; |
566 | } | |
567 | } | |
568 | rc = NULL; | |
52d58aef OP |
569 | /* |
570 | * if the nulls value we got at the end of this lookup is | |
571 | * not the expected one, we must restart lookup. | |
572 | * We probably met an item that was moved to another chain. | |
573 | */ | |
574 | if (unlikely(get_nulls_value(node) != slot)) | |
575 | goto again; | |
1da177e4 | 576 | found: |
b76f5a84 | 577 | rcu_read_unlock(); |
1da177e4 LT |
578 | return rc; |
579 | } | |
580 | ||
52d58aef OP |
581 | /** |
582 | * llc_lookup_listener - Finds listener for local MAC + SAP | |
583 | * @sap: SAP | |
584 | * @laddr: address of local LLC (MAC + SAP) | |
97b1d320 | 585 | * @net: netns to look up a socket in |
52d58aef OP |
586 | * |
587 | * Search connection list of the SAP and finds connection listening on | |
588 | * local mac, and local sap. Returns pointer for parent socket found, | |
589 | * %NULL otherwise. | |
590 | * Caller has to make sure local_bh is disabled. | |
591 | */ | |
592 | static struct sock *llc_lookup_listener(struct llc_sap *sap, | |
97b1d320 KI |
593 | struct llc_addr *laddr, |
594 | const struct net *net) | |
52d58aef | 595 | { |
97b1d320 | 596 | struct sock *rc = __llc_lookup_listener(sap, laddr, net); |
52d58aef | 597 | static struct llc_addr null_addr; |
52d58aef OP |
598 | |
599 | if (!rc) | |
97b1d320 | 600 | rc = __llc_lookup_listener(sap, &null_addr, net); |
52d58aef OP |
601 | |
602 | return rc; | |
603 | } | |
604 | ||
d389424e ACM |
605 | static struct sock *__llc_lookup(struct llc_sap *sap, |
606 | struct llc_addr *daddr, | |
97b1d320 KI |
607 | struct llc_addr *laddr, |
608 | const struct net *net) | |
d389424e | 609 | { |
97b1d320 | 610 | struct sock *sk = __llc_lookup_established(sap, daddr, laddr, net); |
d389424e | 611 | |
97b1d320 | 612 | return sk ? : llc_lookup_listener(sap, laddr, net); |
d389424e ACM |
613 | } |
614 | ||
1da177e4 LT |
615 | /** |
616 | * llc_data_accept_state - designates if in this state data can be sent. | |
617 | * @state: state of connection. | |
618 | * | |
619 | * Returns 0 if data can be sent, 1 otherwise. | |
620 | */ | |
621 | u8 llc_data_accept_state(u8 state) | |
622 | { | |
623 | return state != LLC_CONN_STATE_NORMAL && state != LLC_CONN_STATE_BUSY && | |
624 | state != LLC_CONN_STATE_REJ; | |
625 | } | |
626 | ||
627 | /** | |
0eb80172 | 628 | * llc_find_next_offset - finds offset for next category of transitions |
1da177e4 LT |
629 | * @state: state table. |
630 | * @offset: start offset. | |
631 | * | |
632 | * Finds offset of next category of transitions in transition table. | |
633 | * Returns the start index of next category. | |
634 | */ | |
0eb80172 | 635 | static u16 __init llc_find_next_offset(struct llc_conn_state *state, u16 offset) |
1da177e4 LT |
636 | { |
637 | u16 cnt = 0; | |
638 | struct llc_conn_state_trans **next_trans; | |
639 | ||
640 | for (next_trans = state->transitions + offset; | |
641 | (*next_trans)->ev; next_trans++) | |
642 | ++cnt; | |
643 | return cnt; | |
644 | } | |
645 | ||
646 | /** | |
647 | * llc_build_offset_table - builds offset table of connection | |
648 | * | |
649 | * Fills offset table of connection state transition table | |
650 | * (llc_offset_table). | |
651 | */ | |
652 | void __init llc_build_offset_table(void) | |
653 | { | |
654 | struct llc_conn_state *curr_state; | |
655 | int state, ev_type, next_offset; | |
656 | ||
657 | for (state = 0; state < NBR_CONN_STATES; state++) { | |
658 | curr_state = &llc_conn_state_table[state]; | |
659 | next_offset = 0; | |
660 | for (ev_type = 0; ev_type < NBR_CONN_EV; ev_type++) { | |
661 | llc_offset_table[state][ev_type] = next_offset; | |
0eb80172 ACM |
662 | next_offset += llc_find_next_offset(curr_state, |
663 | next_offset) + 1; | |
1da177e4 LT |
664 | } |
665 | } | |
666 | } | |
667 | ||
668 | /** | |
669 | * llc_find_offset - finds start offset of category of transitions | |
670 | * @state: state of connection | |
671 | * @ev_type: type of happened event | |
672 | * | |
673 | * Finds start offset of desired category of transitions. Returns the | |
674 | * desired start offset. | |
675 | */ | |
676 | static int llc_find_offset(int state, int ev_type) | |
677 | { | |
678 | int rc = 0; | |
679 | /* at this stage, llc_offset_table[..][2] is not important. it is for | |
680 | * init_pf_cycle and I don't know what is it. | |
681 | */ | |
682 | switch (ev_type) { | |
683 | case LLC_CONN_EV_TYPE_PRIM: | |
684 | rc = llc_offset_table[state][0]; break; | |
685 | case LLC_CONN_EV_TYPE_PDU: | |
686 | rc = llc_offset_table[state][4]; break; | |
687 | case LLC_CONN_EV_TYPE_SIMPLE: | |
688 | rc = llc_offset_table[state][1]; break; | |
689 | case LLC_CONN_EV_TYPE_P_TMR: | |
690 | case LLC_CONN_EV_TYPE_ACK_TMR: | |
691 | case LLC_CONN_EV_TYPE_REJ_TMR: | |
692 | case LLC_CONN_EV_TYPE_BUSY_TMR: | |
693 | rc = llc_offset_table[state][3]; break; | |
694 | } | |
695 | return rc; | |
696 | } | |
697 | ||
698 | /** | |
699 | * llc_sap_add_socket - adds a socket to a SAP | |
700 | * @sap: SAP | |
701 | * @sk: socket | |
702 | * | |
52d58aef | 703 | * This function adds a socket to the hash tables of a SAP. |
1da177e4 LT |
704 | */ |
705 | void llc_sap_add_socket(struct llc_sap *sap, struct sock *sk) | |
706 | { | |
6d2e3ea2 OP |
707 | struct llc_sock *llc = llc_sk(sk); |
708 | struct hlist_head *dev_hb = llc_sk_dev_hash(sap, llc->dev->ifindex); | |
52d58aef | 709 | struct hlist_nulls_head *laddr_hb = llc_sk_laddr_hash(sap, &llc->laddr); |
6d2e3ea2 | 710 | |
6e2144b7 | 711 | llc_sap_hold(sap); |
1da177e4 | 712 | llc_sk(sk)->sap = sap; |
6d2e3ea2 OP |
713 | |
714 | spin_lock_bh(&sap->sk_lock); | |
5a8e7aea | 715 | sock_set_flag(sk, SOCK_RCU_FREE); |
52d58aef OP |
716 | sap->sk_count++; |
717 | sk_nulls_add_node_rcu(sk, laddr_hb); | |
6d2e3ea2 | 718 | hlist_add_head(&llc->dev_hash_node, dev_hb); |
b76f5a84 | 719 | spin_unlock_bh(&sap->sk_lock); |
1da177e4 LT |
720 | } |
721 | ||
722 | /** | |
723 | * llc_sap_remove_socket - removes a socket from SAP | |
724 | * @sap: SAP | |
725 | * @sk: socket | |
726 | * | |
52d58aef | 727 | * This function removes a connection from the hash tables of a SAP if |
1da177e4 LT |
728 | * the connection was in this list. |
729 | */ | |
730 | void llc_sap_remove_socket(struct llc_sap *sap, struct sock *sk) | |
731 | { | |
6d2e3ea2 OP |
732 | struct llc_sock *llc = llc_sk(sk); |
733 | ||
b76f5a84 OP |
734 | spin_lock_bh(&sap->sk_lock); |
735 | sk_nulls_del_node_init_rcu(sk); | |
6d2e3ea2 | 736 | hlist_del(&llc->dev_hash_node); |
52d58aef | 737 | sap->sk_count--; |
b76f5a84 | 738 | spin_unlock_bh(&sap->sk_lock); |
6e2144b7 | 739 | llc_sap_put(sap); |
1da177e4 LT |
740 | } |
741 | ||
742 | /** | |
743 | * llc_conn_rcv - sends received pdus to the connection state machine | |
744 | * @sk: current connection structure. | |
745 | * @skb: received frame. | |
746 | * | |
747 | * Sends received pdus to the connection state machine. | |
748 | */ | |
3cdba604 | 749 | static int llc_conn_rcv(struct sock *sk, struct sk_buff *skb) |
1da177e4 LT |
750 | { |
751 | struct llc_conn_state_ev *ev = llc_conn_ev(skb); | |
1da177e4 | 752 | |
1da177e4 LT |
753 | ev->type = LLC_CONN_EV_TYPE_PDU; |
754 | ev->reason = 0; | |
755 | return llc_conn_state_process(sk, skb); | |
756 | } | |
757 | ||
d389424e ACM |
758 | static struct sock *llc_create_incoming_sock(struct sock *sk, |
759 | struct net_device *dev, | |
760 | struct llc_addr *saddr, | |
761 | struct llc_addr *daddr) | |
762 | { | |
3b1e0a65 | 763 | struct sock *newsk = llc_sk_alloc(sock_net(sk), sk->sk_family, GFP_ATOMIC, |
11aa9c28 | 764 | sk->sk_prot, 0); |
d389424e ACM |
765 | struct llc_sock *newllc, *llc = llc_sk(sk); |
766 | ||
767 | if (!newsk) | |
768 | goto out; | |
769 | newllc = llc_sk(newsk); | |
770 | memcpy(&newllc->laddr, daddr, sizeof(newllc->laddr)); | |
771 | memcpy(&newllc->daddr, saddr, sizeof(newllc->daddr)); | |
772 | newllc->dev = dev; | |
773 | dev_hold(dev); | |
774 | llc_sap_add_socket(llc->sap, newsk); | |
775 | llc_sap_hold(llc->sap); | |
776 | out: | |
777 | return newsk; | |
778 | } | |
779 | ||
1da177e4 LT |
780 | void llc_conn_handler(struct llc_sap *sap, struct sk_buff *skb) |
781 | { | |
782 | struct llc_addr saddr, daddr; | |
783 | struct sock *sk; | |
784 | ||
785 | llc_pdu_decode_sa(skb, saddr.mac); | |
786 | llc_pdu_decode_ssap(skb, &saddr.lsap); | |
787 | llc_pdu_decode_da(skb, daddr.mac); | |
788 | llc_pdu_decode_dsap(skb, &daddr.lsap); | |
789 | ||
97b1d320 | 790 | sk = __llc_lookup(sap, &saddr, &daddr, dev_net(skb->dev)); |
d389424e ACM |
791 | if (!sk) |
792 | goto drop; | |
793 | ||
794 | bh_lock_sock(sk); | |
795 | /* | |
796 | * This has to be done here and not at the upper layer ->accept | |
797 | * method because of the way the PROCOM state machine works: | |
798 | * it needs to set several state variables (see, for instance, | |
799 | * llc_adm_actions_2 in net/llc/llc_c_st.c) and send a packet to | |
800 | * the originator of the new connection, and this state has to be | |
801 | * in the newly created struct sock private area. -acme | |
802 | */ | |
803 | if (unlikely(sk->sk_state == TCP_LISTEN)) { | |
804 | struct sock *newsk = llc_create_incoming_sock(sk, skb->dev, | |
805 | &saddr, &daddr); | |
806 | if (!newsk) | |
807 | goto drop_unlock; | |
808 | skb_set_owner_r(skb, newsk); | |
809 | } else { | |
1da177e4 | 810 | /* |
d389424e ACM |
811 | * Can't be skb_set_owner_r, this will be done at the |
812 | * llc_conn_state_process function, later on, when we will use | |
813 | * skb_queue_rcv_skb to send it to upper layers, this is | |
814 | * another trick required to cope with how the PROCOM state | |
815 | * machine works. -acme | |
1da177e4 | 816 | */ |
8b74d439 ED |
817 | skb_orphan(skb); |
818 | sock_hold(sk); | |
d389424e | 819 | skb->sk = sk; |
8b74d439 | 820 | skb->destructor = sock_efree; |
04e4223f | 821 | } |
1da177e4 LT |
822 | if (!sock_owned_by_user(sk)) |
823 | llc_conn_rcv(sk, skb); | |
824 | else { | |
0dc47877 | 825 | dprintk("%s: adding to backlog...\n", __func__); |
1da177e4 | 826 | llc_set_backlog_type(skb, LLC_PACKET); |
8265792b | 827 | if (sk_add_backlog(sk, skb, READ_ONCE(sk->sk_rcvbuf))) |
79545b68 | 828 | goto drop_unlock; |
1da177e4 | 829 | } |
d389424e | 830 | out: |
1da177e4 LT |
831 | bh_unlock_sock(sk); |
832 | sock_put(sk); | |
833 | return; | |
834 | drop: | |
835 | kfree_skb(skb); | |
d389424e ACM |
836 | return; |
837 | drop_unlock: | |
838 | kfree_skb(skb); | |
839 | goto out; | |
1da177e4 LT |
840 | } |
841 | ||
842 | #undef LLC_REFCNT_DEBUG | |
843 | #ifdef LLC_REFCNT_DEBUG | |
844 | static atomic_t llc_sock_nr; | |
845 | #endif | |
846 | ||
1da177e4 LT |
847 | /** |
848 | * llc_backlog_rcv - Processes rx frames and expired timers. | |
849 | * @sk: LLC sock (p8022 connection) | |
850 | * @skb: queued rx frame or event | |
851 | * | |
852 | * This function processes frames that has received and timers that has | |
853 | * expired during sending an I pdu (refer to data_req_handler). frames | |
854 | * queue by llc_rcv function (llc_mac.c) and timers queue by timer | |
855 | * callback functions(llc_c_ac.c). | |
856 | */ | |
857 | static int llc_backlog_rcv(struct sock *sk, struct sk_buff *skb) | |
858 | { | |
859 | int rc = 0; | |
860 | struct llc_sock *llc = llc_sk(sk); | |
861 | ||
af426d32 ACM |
862 | if (likely(llc_backlog_type(skb) == LLC_PACKET)) { |
863 | if (likely(llc->state > 1)) /* not closed */ | |
1da177e4 LT |
864 | rc = llc_conn_rcv(sk, skb); |
865 | else | |
866 | goto out_kfree_skb; | |
867 | } else if (llc_backlog_type(skb) == LLC_EVENT) { | |
868 | /* timer expiration event */ | |
af426d32 | 869 | if (likely(llc->state > 1)) /* not closed */ |
1da177e4 LT |
870 | rc = llc_conn_state_process(sk, skb); |
871 | else | |
872 | goto out_kfree_skb; | |
873 | } else { | |
0dc47877 | 874 | printk(KERN_ERR "%s: invalid skb in backlog\n", __func__); |
1da177e4 LT |
875 | goto out_kfree_skb; |
876 | } | |
877 | out: | |
878 | return rc; | |
879 | out_kfree_skb: | |
880 | kfree_skb(skb); | |
881 | goto out; | |
882 | } | |
883 | ||
884 | /** | |
885 | * llc_sk_init - Initializes a socket with default llc values. | |
886 | * @sk: socket to initialize. | |
887 | * | |
888 | * Initializes a socket with default llc values. | |
889 | */ | |
3cdba604 | 890 | static void llc_sk_init(struct sock *sk) |
1da177e4 LT |
891 | { |
892 | struct llc_sock *llc = llc_sk(sk); | |
893 | ||
894 | llc->state = LLC_CONN_STATE_ADM; | |
895 | llc->inc_cntr = llc->dec_cntr = 2; | |
896 | llc->dec_step = llc->connect_step = 1; | |
897 | ||
fc8bcaa0 | 898 | timer_setup(&llc->ack_timer.timer, llc_conn_ack_tmr_cb, 0); |
590232a7 | 899 | llc->ack_timer.expire = sysctl_llc2_ack_timeout; |
1da177e4 | 900 | |
fc8bcaa0 | 901 | timer_setup(&llc->pf_cycle_timer.timer, llc_conn_pf_cycle_tmr_cb, 0); |
590232a7 | 902 | llc->pf_cycle_timer.expire = sysctl_llc2_p_timeout; |
1da177e4 | 903 | |
fc8bcaa0 | 904 | timer_setup(&llc->rej_sent_timer.timer, llc_conn_rej_tmr_cb, 0); |
590232a7 | 905 | llc->rej_sent_timer.expire = sysctl_llc2_rej_timeout; |
1da177e4 | 906 | |
fc8bcaa0 | 907 | timer_setup(&llc->busy_state_timer.timer, llc_conn_busy_tmr_cb, 0); |
590232a7 | 908 | llc->busy_state_timer.expire = sysctl_llc2_busy_timeout; |
1da177e4 LT |
909 | |
910 | llc->n2 = 2; /* max retransmit */ | |
911 | llc->k = 2; /* tx win size, will adjust dynam */ | |
912 | llc->rw = 128; /* rx win size (opt and equal to | |
d57b1869 | 913 | * tx_win of remote LLC) */ |
1da177e4 LT |
914 | skb_queue_head_init(&llc->pdu_unack_q); |
915 | sk->sk_backlog_rcv = llc_backlog_rcv; | |
916 | } | |
917 | ||
918 | /** | |
919 | * llc_sk_alloc - Allocates LLC sock | |
74c950c9 | 920 | * @net: network namespace |
1da177e4 LT |
921 | * @family: upper layer protocol family |
922 | * @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc) | |
8756f474 AL |
923 | * @prot: struct proto associated with this new sock instance |
924 | * @kern: is this to be a kernel socket? | |
1da177e4 LT |
925 | * |
926 | * Allocates a LLC sock and initializes it. Returns the new LLC sock | |
927 | * or %NULL if there's no memory available for one | |
928 | */ | |
11aa9c28 | 929 | struct sock *llc_sk_alloc(struct net *net, int family, gfp_t priority, struct proto *prot, int kern) |
1da177e4 | 930 | { |
11aa9c28 | 931 | struct sock *sk = sk_alloc(net, family, priority, prot, kern); |
1da177e4 LT |
932 | |
933 | if (!sk) | |
934 | goto out; | |
935 | llc_sk_init(sk); | |
936 | sock_init_data(NULL, sk); | |
937 | #ifdef LLC_REFCNT_DEBUG | |
938 | atomic_inc(&llc_sock_nr); | |
939 | printk(KERN_DEBUG "LLC socket %p created in %s, now we have %d alive\n", sk, | |
0dc47877 | 940 | __func__, atomic_read(&llc_sock_nr)); |
1da177e4 LT |
941 | #endif |
942 | out: | |
943 | return sk; | |
944 | } | |
945 | ||
b905ef9a CW |
946 | void llc_sk_stop_all_timers(struct sock *sk, bool sync) |
947 | { | |
948 | struct llc_sock *llc = llc_sk(sk); | |
949 | ||
950 | if (sync) { | |
951 | del_timer_sync(&llc->pf_cycle_timer.timer); | |
952 | del_timer_sync(&llc->ack_timer.timer); | |
953 | del_timer_sync(&llc->rej_sent_timer.timer); | |
954 | del_timer_sync(&llc->busy_state_timer.timer); | |
955 | } else { | |
956 | del_timer(&llc->pf_cycle_timer.timer); | |
957 | del_timer(&llc->ack_timer.timer); | |
958 | del_timer(&llc->rej_sent_timer.timer); | |
959 | del_timer(&llc->busy_state_timer.timer); | |
960 | } | |
961 | ||
962 | llc->ack_must_be_send = 0; | |
963 | llc->ack_pf = 0; | |
964 | } | |
965 | ||
1da177e4 LT |
966 | /** |
967 | * llc_sk_free - Frees a LLC socket | |
74c950c9 | 968 | * @sk: - socket to free |
1da177e4 LT |
969 | * |
970 | * Frees a LLC socket | |
971 | */ | |
972 | void llc_sk_free(struct sock *sk) | |
973 | { | |
974 | struct llc_sock *llc = llc_sk(sk); | |
975 | ||
976 | llc->state = LLC_CONN_OUT_OF_SVC; | |
977 | /* Stop all (possibly) running timers */ | |
b905ef9a | 978 | llc_sk_stop_all_timers(sk, true); |
1da177e4 | 979 | #ifdef DEBUG_LLC_CONN_ALLOC |
0dc47877 | 980 | printk(KERN_INFO "%s: unackq=%d, txq=%d\n", __func__, |
1da177e4 LT |
981 | skb_queue_len(&llc->pdu_unack_q), |
982 | skb_queue_len(&sk->sk_write_queue)); | |
983 | #endif | |
984 | skb_queue_purge(&sk->sk_receive_queue); | |
985 | skb_queue_purge(&sk->sk_write_queue); | |
986 | skb_queue_purge(&llc->pdu_unack_q); | |
987 | #ifdef LLC_REFCNT_DEBUG | |
41c6d650 | 988 | if (refcount_read(&sk->sk_refcnt) != 1) { |
1da177e4 | 989 | printk(KERN_DEBUG "Destruction of LLC sock %p delayed in %s, cnt=%d\n", |
41c6d650 | 990 | sk, __func__, refcount_read(&sk->sk_refcnt)); |
1da177e4 LT |
991 | printk(KERN_DEBUG "%d LLC sockets are still alive\n", |
992 | atomic_read(&llc_sock_nr)); | |
993 | } else { | |
994 | atomic_dec(&llc_sock_nr); | |
995 | printk(KERN_DEBUG "LLC socket %p released in %s, %d are still alive\n", sk, | |
0dc47877 | 996 | __func__, atomic_read(&llc_sock_nr)); |
1da177e4 LT |
997 | } |
998 | #endif | |
999 | sock_put(sk); | |
1000 | } | |
1001 | ||
1002 | /** | |
1003 | * llc_sk_reset - resets a connection | |
1004 | * @sk: LLC socket to reset | |
1005 | * | |
1006 | * Resets a connection to the out of service state. Stops its timers | |
1007 | * and frees any frames in the queues of the connection. | |
1008 | */ | |
1009 | void llc_sk_reset(struct sock *sk) | |
1010 | { | |
1011 | struct llc_sock *llc = llc_sk(sk); | |
1012 | ||
1013 | llc_conn_ac_stop_all_timers(sk, NULL); | |
1014 | skb_queue_purge(&sk->sk_write_queue); | |
1015 | skb_queue_purge(&llc->pdu_unack_q); | |
1016 | llc->remote_busy_flag = 0; | |
1017 | llc->cause_flag = 0; | |
1018 | llc->retry_count = 0; | |
1019 | llc_conn_set_p_flag(sk, 0); | |
1020 | llc->f_flag = 0; | |
1021 | llc->s_flag = 0; | |
1022 | llc->ack_pf = 0; | |
1023 | llc->first_pdu_Ns = 0; | |
1024 | llc->ack_must_be_send = 0; | |
1025 | llc->dec_step = 1; | |
1026 | llc->inc_cntr = 2; | |
1027 | llc->dec_cntr = 2; | |
1028 | llc->X = 0; | |
1029 | llc->failed_data_req = 0 ; | |
1030 | llc->last_nr = 0; | |
1031 | } |