From 95c783fa559f5c214d54cbe3e56e388a6c5966db Mon Sep 17 00:00:00 2001 From: Arnaldo Carvalho de Melo Date: Thu, 26 Sep 2002 14:05:35 -0300 Subject: [X25] remove unneeded typedef x25_address Typedefs can't be forward declared, so we prefer structs, that can. --- include/linux/x25.h | 16 ++++++++-------- include/net/x25.h | 14 ++++++++------ 2 files changed, 16 insertions(+), 14 deletions(-) (limited to 'include') diff --git a/include/linux/x25.h b/include/linux/x25.h index 49bb2a4b39ec..7531cfed5885 100644 --- a/include/linux/x25.h +++ b/include/linux/x25.h @@ -39,16 +39,16 @@ * An X.121 address, it is held as ASCII text, null terminated, up to 15 * digits and a null terminator. */ -typedef struct { - char x25_addr[16]; -} x25_address; +struct x25_address { + char x25_addr[16]; +}; /* * Linux X.25 Address structure, used for bind, and connect mostly. */ struct sockaddr_x25 { - sa_family_t sx25_family; /* Must be AF_X25 */ - x25_address sx25_addr; /* X.121 Address */ + sa_family_t sx25_family; /* Must be AF_X25 */ + struct x25_address sx25_addr; /* X.121 Address */ }; /* @@ -78,9 +78,9 @@ struct x25_subscrip_struct { * Routing table control structure. */ struct x25_route_struct { - x25_address address; - unsigned int sigdigits; - char device[200]; + struct x25_address address; + unsigned int sigdigits; + char device[200]; }; /* diff --git a/include/net/x25.h b/include/net/x25.h index 4d5c3a84e9dc..82fbb74f1765 100644 --- a/include/net/x25.h +++ b/include/net/x25.h @@ -103,9 +103,9 @@ enum { struct x25_route { struct x25_route *next; - x25_address address; /* Start of address range */ + struct x25_address address; /* Start of address range */ unsigned int sigdigits; /* Number of sig digits */ - struct net_device *dev; /* More than one for MLP */ + struct net_device *dev; /* More than one for MLP */ }; struct x25_neigh { @@ -120,7 +120,7 @@ struct x25_neigh { }; typedef struct { - x25_address source_addr, dest_addr; + struct x25_address source_addr, dest_addr; struct x25_neigh *neighbour; unsigned int lci; unsigned char state, condition, qbitincl, intflag; @@ -148,8 +148,10 @@ extern int sysctl_x25_reset_request_timeout; extern int sysctl_x25_clear_request_timeout; extern int sysctl_x25_ack_holdback_timeout; -extern int x25_addr_ntoa(unsigned char *, x25_address *, x25_address *); -extern int x25_addr_aton(unsigned char *, x25_address *, x25_address *); +extern int x25_addr_ntoa(unsigned char *, struct x25_address *, + struct x25_address *); +extern int x25_addr_aton(unsigned char *, struct x25_address *, + struct x25_address *); extern unsigned int x25_new_lci(struct x25_neigh *); extern struct sock *x25_find_socket(unsigned int, struct x25_neigh *); extern void x25_destroy_socket(struct sock *); @@ -194,7 +196,7 @@ extern void x25_kick(struct sock *); extern void x25_enquiry_response(struct sock *); /* x25_route.c */ -extern struct net_device *x25_get_route(x25_address *); +extern struct net_device *x25_get_route(struct x25_address *); extern struct net_device *x25_dev_get(char *); extern void x25_route_device_down(struct net_device *); extern int x25_route_ioctl(unsigned int, void *); -- cgit v1.2.3 From 92acfab52b9d4d8160f9f361f5de636945cdde04 Mon Sep 17 00:00:00 2001 From: Arnaldo Carvalho de Melo Date: Sat, 28 Sep 2002 00:28:57 -0300 Subject: o X25: use refcounts and protect x25_route list Also rename untypedefed x25_cb, renaming it to x25_opt, to make it look like the other protocols. Added some kerneldoc comments. --- include/net/x25.h | 38 +++++++--- net/x25/af_x25.c | 40 +++++----- net/x25/x25_facilities.c | 2 +- net/x25/x25_in.c | 10 +-- net/x25/x25_out.c | 8 +- net/x25/x25_route.c | 185 +++++++++++++++++++++++++---------------------- net/x25/x25_subr.c | 14 ++-- net/x25/x25_timer.c | 12 +-- 8 files changed, 172 insertions(+), 137 deletions(-) (limited to 'include') diff --git a/include/net/x25.h b/include/net/x25.h index 82fbb74f1765..143a1887019a 100644 --- a/include/net/x25.h +++ b/include/net/x25.h @@ -101,16 +101,25 @@ enum { #define X25_MAX_FAC_LEN 20 /* Plenty to spare */ #define X25_MAX_CUD_LEN 128 +/** + * struct x25_route - x25 routing entry + * @node - entry in x25_list_lock + * @address - Start of address range + * @sigdigits - Number of sig digits + * @dev - More than one for MLP + * @refcnt - reference counter + */ struct x25_route { - struct x25_route *next; - struct x25_address address; /* Start of address range */ - unsigned int sigdigits; /* Number of sig digits */ - struct net_device *dev; /* More than one for MLP */ + struct list_head node; + struct x25_address address; + unsigned int sigdigits; + struct net_device *dev; + atomic_t refcnt; }; struct x25_neigh { struct x25_neigh *next; - struct net_device *dev; + struct net_device *dev; unsigned int state; unsigned int extended; struct sk_buff_head queue; @@ -119,7 +128,7 @@ struct x25_neigh { unsigned long global_facil_mask; }; -typedef struct { +struct x25_opt { struct x25_address source_addr, dest_addr; struct x25_neigh *neighbour; unsigned int lci; @@ -137,9 +146,9 @@ typedef struct { struct x25_facilities facilities; struct x25_calluserdata calluserdata; unsigned long vc_facil_mask; /* inc_call facilities mask */ -} x25_cb; +}; -#define x25_sk(__sk) ((x25_cb *)(__sk)->protinfo) +#define x25_sk(__sk) ((struct x25_opt *)(__sk)->protinfo) /* af_x25.c */ extern int sysctl_x25_restart_request_timeout; @@ -196,13 +205,24 @@ extern void x25_kick(struct sock *); extern void x25_enquiry_response(struct sock *); /* x25_route.c */ -extern struct net_device *x25_get_route(struct x25_address *); +extern struct x25_route *x25_get_route(struct x25_address *addr); extern struct net_device *x25_dev_get(char *); extern void x25_route_device_down(struct net_device *); extern int x25_route_ioctl(unsigned int, void *); extern int x25_routes_get_info(char *, char **, off_t, int); extern void x25_route_free(void); +static __inline__ void x25_route_hold(struct x25_route *rt) +{ + atomic_inc(&rt->refcnt); +} + +static __inline__ void x25_route_put(struct x25_route *rt) +{ + if (atomic_dec_and_test(&rt->refcnt)) + kfree(rt); +} + /* x25_subr.c */ extern void x25_clear_queues(struct sock *); extern void x25_frames_acked(struct sock *, unsigned short); diff --git a/net/x25/af_x25.c b/net/x25/af_x25.c index aa2ea0258bac..4a0cf4f5cea1 100644 --- a/net/x25/af_x25.c +++ b/net/x25/af_x25.c @@ -421,7 +421,7 @@ static int x25_listen(struct socket *sock, int backlog) static struct sock *x25_alloc_socket(void) { struct sock *sk; - x25_cb *x25; + struct x25_opt *x25; MOD_INC_USE_COUNT; @@ -455,7 +455,7 @@ decmod: static int x25_create(struct socket *sock, int protocol) { struct sock *sk; - x25_cb *x25; + struct x25_opt *x25; int rc = -ESOCKTNOSUPPORT; if (sock->type != SOCK_SEQPACKET || protocol) @@ -495,7 +495,7 @@ out: static struct sock *x25_make_new(struct sock *osk) { struct sock *sk = NULL; - x25_cb *x25, *ox25; + struct x25_opt *x25, *ox25; if (osk->type != SOCK_SEQPACKET) goto out; @@ -533,7 +533,7 @@ out: static int x25_release(struct socket *sock) { struct sock *sk = sock->sk; - x25_cb *x25; + struct x25_opt *x25; if (!sk) goto out; @@ -590,9 +590,9 @@ static int x25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) static int x25_connect(struct socket *sock, struct sockaddr *uaddr, int addr_len, int flags) { struct sock *sk = sock->sk; - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); struct sockaddr_x25 *addr = (struct sockaddr_x25 *)uaddr; - struct net_device *dev; + struct x25_route *rt; int rc = 0; if (sk->state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) { @@ -619,23 +619,23 @@ static int x25_connect(struct socket *sock, struct sockaddr *uaddr, int addr_len goto out; rc = -ENETUNREACH; - dev = x25_get_route(&addr->sx25_addr); - if (!dev) + rt = x25_get_route(&addr->sx25_addr); + if (!rt) goto out; - x25->neighbour = x25_get_neigh(dev); + x25->neighbour = x25_get_neigh(rt->dev); if (!x25->neighbour) - goto out; + goto out_put_route; x25_limit_facilities(&x25->facilities, x25->neighbour); x25->lci = x25_new_lci(x25->neighbour); if (!x25->lci) - goto out; + goto out_put_route; rc = -EINVAL; if (sk->zapped) /* Must bind first - autobinding does not work */ - goto out; + goto out_put_route; if (!strcmp(x25->source_addr.x25_addr, null_x25_address.x25_addr)) memset(&x25->source_addr, '\0', X25_ADDR_LEN); @@ -656,7 +656,7 @@ static int x25_connect(struct socket *sock, struct sockaddr *uaddr, int addr_len /* Now the loop */ rc = -EINPROGRESS; if (sk->state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) - goto out; + goto out_put_route; cli(); /* To avoid races on the sleep */ @@ -681,6 +681,8 @@ static int x25_connect(struct socket *sock, struct sockaddr *uaddr, int addr_len rc = 0; out_unlock: sti(); +out_put_route: + x25_route_put(rt); out: return rc; } @@ -741,7 +743,7 @@ static int x25_getname(struct socket *sock, struct sockaddr *uaddr, int *uaddr_l { struct sockaddr_x25 *sx25 = (struct sockaddr_x25 *)uaddr; struct sock *sk = sock->sk; - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); if (peer) { if (sk->state != TCP_ESTABLISHED) @@ -760,7 +762,7 @@ int x25_rx_call_request(struct sk_buff *skb, struct x25_neigh *neigh, unsigned i { struct sock *sk; struct sock *make; - x25_cb *makex25; + struct x25_opt *makex25; struct x25_address source_addr, dest_addr; struct x25_facilities facilities; int len, rc; @@ -858,7 +860,7 @@ out_clear_request: static int x25_sendmsg(struct socket *sock, struct msghdr *msg, int len, struct scm_cookie *scm) { struct sock *sk = sock->sk; - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); struct sockaddr_x25 *usx25 = (struct sockaddr_x25 *)msg->msg_name; struct sockaddr_x25 sx25; struct sk_buff *skb; @@ -1033,7 +1035,7 @@ static int x25_recvmsg(struct socket *sock, struct msghdr *msg, int size, int flags, struct scm_cookie *scm) { struct sock *sk = sock->sk; - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); struct sockaddr_x25 *sx25 = (struct sockaddr_x25 *)msg->msg_name; int copied, qbit; struct sk_buff *skb; @@ -1119,7 +1121,7 @@ out: static int x25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) { struct sock *sk = sock->sk; - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); int rc; switch (cmd) { @@ -1266,7 +1268,7 @@ static int x25_get_info(char *buffer, char **start, off_t offset, int length) "t t2 t21 t22 t23 Snd-Q Rcv-Q inode\n"); for (s = x25_list; s; s = s->next) { - x25_cb *x25 = x25_sk(s); + struct x25_opt *x25 = x25_sk(s); if (!x25->neighbour || (dev = x25->neighbour->dev) == NULL) devname = "???"; diff --git a/net/x25/x25_facilities.c b/net/x25/x25_facilities.c index df86846a0a6c..74e34b4e1e9d 100644 --- a/net/x25/x25_facilities.c +++ b/net/x25/x25_facilities.c @@ -172,7 +172,7 @@ int x25_create_facilities(unsigned char *buffer, int x25_negotiate_facilities(struct sk_buff *skb, struct sock *sk, struct x25_facilities *new) { - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); struct x25_facilities *ours = &x25->facilities; struct x25_facilities theirs; int len; diff --git a/net/x25/x25_in.c b/net/x25/x25_in.c index 73d17e5aa99c..b3e41a0526f2 100644 --- a/net/x25/x25_in.c +++ b/net/x25/x25_in.c @@ -48,7 +48,7 @@ static int x25_queue_rx_frame(struct sock *sk, struct sk_buff *skb, int more) { struct sk_buff *skbo, *skbn = skb; - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); if (more) { x25->fraglen += skb->len; @@ -103,7 +103,7 @@ static int x25_state1_machine(struct sock *sk, struct sk_buff *skb, int frametyp switch (frametype) { case X25_CALL_ACCEPTED: { - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); x25_stop_timer(sk); x25->condition = 0x00; @@ -179,7 +179,7 @@ static int x25_state3_machine(struct sock *sk, struct sk_buff *skb, int frametyp { int queued = 0; int modulus; - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); modulus = (x25->neighbour->extended) ? X25_EMODULUS : X25_SMODULUS; @@ -308,7 +308,7 @@ static int x25_state4_machine(struct sock *sk, struct sk_buff *skb, int frametyp case X25_RESET_REQUEST: x25_write_internal(sk, X25_RESET_CONFIRMATION); case X25_RESET_CONFIRMATION: { - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); x25_stop_timer(sk); x25->condition = 0x00; @@ -335,7 +335,7 @@ static int x25_state4_machine(struct sock *sk, struct sk_buff *skb, int frametyp /* Higher level upcall for a LAPB frame */ int x25_process_rx_frame(struct sock *sk, struct sk_buff *skb) { - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); int queued = 0, frametype, ns, nr, q, d, m; if (x25->state == X25_STATE_0) diff --git a/net/x25/x25_out.c b/net/x25/x25_out.c index 93601409ddce..97048413829b 100644 --- a/net/x25/x25_out.c +++ b/net/x25/x25_out.c @@ -67,7 +67,7 @@ int x25_output(struct sock *sk, struct sk_buff *skb) unsigned char header[X25_EXT_MIN_LEN]; int err, frontlen, len; int sent=0, noblock = X25_SKB_CB(skb)->flags & MSG_DONTWAIT; - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); int header_len = x25->neighbour->extended ? X25_EXT_MIN_LEN : X25_STD_MIN_LEN; int max_len = x25_pacsize_to_bytes(x25->facilities.pacsize_out); @@ -129,7 +129,7 @@ int x25_output(struct sock *sk, struct sk_buff *skb) */ static void x25_send_iframe(struct sock *sk, struct sk_buff *skb) { - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); if (!skb) return; @@ -152,7 +152,7 @@ void x25_kick(struct sock *sk) struct sk_buff *skb, *skbn; unsigned short start, end; int modulus; - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); if (x25->state != X25_STATE_3) return; @@ -224,7 +224,7 @@ void x25_kick(struct sock *sk) void x25_enquiry_response(struct sock *sk) { - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); if (x25->condition & X25_COND_OWN_RX_BUSY) x25_write_internal(sk, X25_RNR); diff --git a/net/x25/x25_route.c b/net/x25/x25_route.c index d8a5d1e3299f..0513197a7f8b 100644 --- a/net/x25/x25_route.c +++ b/net/x25/x25_route.c @@ -44,7 +44,8 @@ #include #include -static struct x25_route *x25_route_list; /* = NULL initially */ +static struct list_head x25_route_list = LIST_HEAD_INIT(x25_route_list); +static rwlock_t x25_route_list_lock = RW_LOCK_UNLOCKED; /* * Add a new route. @@ -52,80 +53,75 @@ static struct x25_route *x25_route_list; /* = NULL initially */ static int x25_add_route(struct x25_address *address, unsigned int sigdigits, struct net_device *dev) { - struct x25_route *x25_route; - unsigned long flags; + struct x25_route *rt; + struct list_head *entry; int rc = -EINVAL; - for (x25_route = x25_route_list; x25_route; x25_route = x25_route->next) - if (!memcmp(&x25_route->address, address, sigdigits) && - x25_route->sigdigits == sigdigits) + write_lock_bh(&x25_route_list_lock); + + list_for_each(entry, &x25_route_list) { + rt = list_entry(entry, struct x25_route, node); + + if (!memcmp(&rt->address, address, sigdigits) && + rt->sigdigits == sigdigits) goto out; + } - x25_route = kmalloc(sizeof(*x25_route), GFP_ATOMIC); + rt = kmalloc(sizeof(*rt), GFP_ATOMIC); rc = -ENOMEM; - if (!x25_route) + if (!rt) goto out; - strcpy(x25_route->address.x25_addr, "000000000000000"); - memcpy(x25_route->address.x25_addr, address->x25_addr, sigdigits); + strcpy(rt->address.x25_addr, "000000000000000"); + memcpy(rt->address.x25_addr, address->x25_addr, sigdigits); - x25_route->sigdigits = sigdigits; - x25_route->dev = dev; + rt->sigdigits = sigdigits; + rt->dev = dev; + atomic_set(&rt->refcnt, 1); - save_flags(flags); cli(); - x25_route->next = x25_route_list; - x25_route_list = x25_route; - restore_flags(flags); + list_add(&rt->node, &x25_route_list); rc = 0; out: + write_unlock_bh(&x25_route_list_lock); return rc; } -static void x25_remove_route(struct x25_route *x25_route) +/** + * __x25_remove_route - remove route from x25_route_list + * @rt - route to remove + * + * Remove route from x25_route_list. If it was there. + * Caller must hold x25_route_list_lock. + */ +static void __x25_remove_route(struct x25_route *rt) { - struct x25_route *s; - unsigned long flags; - - save_flags(flags); - cli(); - - if ((s = x25_route_list) == x25_route) { - x25_route_list = x25_route->next; - restore_flags(flags); - return; - } - - while (s && s->next) { - if (s->next == x25_route) { - s->next = x25_route->next; - goto out_kfree_route; - } - - s = s->next; + if (rt->node.next) { + list_del(&rt->node); + x25_route_put(rt); } -out: - restore_flags(flags); - return; -out_kfree_route: - kfree(x25_route); - goto out; } static int x25_del_route(struct x25_address *address, unsigned int sigdigits, struct net_device *dev) { - struct x25_route *x25_route = x25_route_list; + struct x25_route *rt; + struct list_head *entry; int rc = -EINVAL; - for (; x25_route; x25_route = x25_route->next) - if (!memcmp(&x25_route->address, address, sigdigits) && - x25_route->sigdigits == sigdigits && - x25_route->dev == dev) { - x25_remove_route(x25_route); + write_lock_bh(&x25_route_list_lock); + + list_for_each(entry, &x25_route_list) { + rt = list_entry(entry, struct x25_route, node); + + if (!memcmp(&rt->address, address, sigdigits) && + rt->sigdigits == sigdigits && rt->dev == dev) { + __x25_remove_route(rt); rc = 0; break; } + } + write_unlock_bh(&x25_route_list_lock); return rc; } @@ -134,15 +130,18 @@ static int x25_del_route(struct x25_address *address, unsigned int sigdigits, */ void x25_route_device_down(struct net_device *dev) { - struct x25_route *route, *x25_route = x25_route_list; + struct x25_route *rt; + struct list_head *entry, *tmp; - while (x25_route) { - route = x25_route; - x25_route = x25_route->next; + write_lock_bh(&x25_route_list_lock); - if (route->dev == dev) - x25_remove_route(route); + list_for_each_safe(entry, tmp, &x25_route_list) { + rt = list_entry(entry, struct x25_route, node); + + if (rt->dev == dev) + __x25_remove_route(rt); } + write_unlock_bh(&x25_route_list_lock); } /* @@ -163,22 +162,35 @@ struct net_device *x25_dev_get(char *devname) return dev; } -/* - * Find a device given an X.25 address. +/** + * x25_get_route - Find a route given an X.25 address. + * @addr - address to find a route for + * + * Find a route given an X.25 address. */ -struct net_device *x25_get_route(struct x25_address *addr) +struct x25_route *x25_get_route(struct x25_address *addr) { - struct x25_route *route, *use = NULL; + struct x25_route *rt, *use = NULL; + struct list_head *entry; - for (route = x25_route_list; route; route = route->next) - if (!memcmp(&route->address, addr, route->sigdigits)) { + read_lock_bh(&x25_route_list_lock); + + list_for_each(entry, &x25_route_list) { + rt = list_entry(entry, struct x25_route, node); + + if (!memcmp(&rt->address, addr, rt->sigdigits)) { if (!use) - use = route; - else if (route->sigdigits > use->sigdigits) - use = route; + use = rt; + else if (rt->sigdigits > use->sigdigits) + use = rt; } + } - return use ? use->dev : NULL; + if (use) + x25_route_hold(use); + + read_unlock_bh(&x25_route_list_lock); + return use; } /* @@ -186,7 +198,7 @@ struct net_device *x25_get_route(struct x25_address *addr) */ int x25_route_ioctl(unsigned int cmd, void *arg) { - struct x25_route_struct x25_route; + struct x25_route_struct rt; struct net_device *dev; int rc = -EINVAL; @@ -194,21 +206,21 @@ int x25_route_ioctl(unsigned int cmd, void *arg) goto out; rc = -EFAULT; - if (copy_from_user(&x25_route, arg, sizeof(x25_route))) + if (copy_from_user(&rt, arg, sizeof(rt))) goto out; rc = -EINVAL; - if (x25_route.sigdigits < 0 || x25_route.sigdigits > 15) + if (rt.sigdigits < 0 || rt.sigdigits > 15) goto out; - dev = x25_dev_get(x25_route.device); + dev = x25_dev_get(rt.device); if (!dev) goto out; if (cmd == SIOCADDRT) - rc = x25_add_route(&x25_route.address, x25_route.sigdigits, dev); + rc = x25_add_route(&rt.address, rt.sigdigits, dev); else - rc = x25_del_route(&x25_route.address, x25_route.sigdigits, dev); + rc = x25_del_route(&rt.address, rt.sigdigits, dev); dev_put(dev); out: return rc; @@ -216,20 +228,20 @@ out: int x25_routes_get_info(char *buffer, char **start, off_t offset, int length) { - struct x25_route *x25_route; - int len; + struct x25_route *rt; + struct list_head *entry; off_t pos = 0; off_t begin = 0; + int len = sprintf(buffer, "address digits device\n"); - cli(); - - len = sprintf(buffer, "address digits device\n"); + read_lock_bh(&x25_route_list_lock); - for (x25_route = x25_route_list; x25_route; x25_route = x25_route->next) { + list_for_each(entry, &x25_route_list) { + rt = list_entry(entry, struct x25_route, node); len += sprintf(buffer + len, "%-15s %-6d %-5s\n", - x25_route->address.x25_addr, - x25_route->sigdigits, - x25_route->dev ? x25_route->dev->name : "???"); + rt->address.x25_addr, + rt->sigdigits, + rt->dev ? rt->dev->name : "???"); pos = begin + len; @@ -242,7 +254,7 @@ int x25_routes_get_info(char *buffer, char **start, off_t offset, int length) break; } - sti(); + read_unlock_bh(&x25_route_list_lock); *start = buffer + (offset - begin); len -= (offset - begin); @@ -258,12 +270,13 @@ int x25_routes_get_info(char *buffer, char **start, off_t offset, int length) */ void __exit x25_route_free(void) { - struct x25_route *route, *x25_route = x25_route_list; - - while (x25_route) { - route = x25_route; - x25_route = x25_route->next; + struct x25_route *rt; + struct list_head *entry, *tmp; - x25_remove_route(route); + write_lock_bh(&x25_route_list_lock); + list_for_each_safe(entry, tmp, &x25_route_list) { + rt = list_entry(entry, struct x25_route, node); + __x25_remove_route(rt); } + write_unlock_bh(&x25_route_list_lock); } diff --git a/net/x25/x25_subr.c b/net/x25/x25_subr.c index bbd351d40767..b444ba981a8f 100644 --- a/net/x25/x25_subr.c +++ b/net/x25/x25_subr.c @@ -47,7 +47,7 @@ */ void x25_clear_queues(struct sock *sk) { - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); skb_queue_purge(&sk->write_queue); skb_queue_purge(&x25->ack_queue); @@ -65,7 +65,7 @@ void x25_clear_queues(struct sock *sk) void x25_frames_acked(struct sock *sk, unsigned short nr) { struct sk_buff *skb; - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); int modulus = x25->neighbour->extended ? X25_EMODULUS : X25_SMODULUS; /* @@ -103,7 +103,7 @@ void x25_requeue_frames(struct sock *sk) */ int x25_validate_nr(struct sock *sk, unsigned short nr) { - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); unsigned short vc = x25->va; int modulus = x25->neighbour->extended ? X25_EMODULUS : X25_SMODULUS; @@ -122,7 +122,7 @@ int x25_validate_nr(struct sock *sk, unsigned short nr) */ void x25_write_internal(struct sock *sk, int frametype) { - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); struct sk_buff *skb; unsigned char *dptr; unsigned char facilities[X25_MAX_FAC_LEN]; @@ -262,7 +262,7 @@ void x25_write_internal(struct sock *sk, int frametype) int x25_decode(struct sock *sk, struct sk_buff *skb, int *ns, int *nr, int *q, int *d, int *m) { - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); unsigned char *frame = skb->data; *ns = *nr = *q = *d = *m = 0; @@ -329,7 +329,7 @@ int x25_decode(struct sock *sk, struct sk_buff *skb, int *ns, int *nr, int *q, void x25_disconnect(struct sock *sk, int reason, unsigned char cause, unsigned char diagnostic) { - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); x25_clear_queues(sk); x25_stop_timer(sk); @@ -356,7 +356,7 @@ void x25_disconnect(struct sock *sk, int reason, unsigned char cause, */ void x25_check_rbuf(struct sock *sk) { - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); if (atomic_read(&sk->rmem_alloc) < (sk->rcvbuf / 2) && (x25->condition & X25_COND_OWN_RX_BUSY)) { diff --git a/net/x25/x25_timer.c b/net/x25/x25_timer.c index 40ac91b36d06..71f67c0a94e3 100644 --- a/net/x25/x25_timer.c +++ b/net/x25/x25_timer.c @@ -61,7 +61,7 @@ void x25_stop_heartbeat(struct sock *sk) void x25_start_t2timer(struct sock *sk) { - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); del_timer(&x25->timer); @@ -74,7 +74,7 @@ void x25_start_t2timer(struct sock *sk) void x25_start_t21timer(struct sock *sk) { - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); del_timer(&x25->timer); @@ -87,7 +87,7 @@ void x25_start_t21timer(struct sock *sk) void x25_start_t22timer(struct sock *sk) { - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); del_timer(&x25->timer); @@ -100,7 +100,7 @@ void x25_start_t22timer(struct sock *sk) void x25_start_t23timer(struct sock *sk) { - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); del_timer(&x25->timer); @@ -118,7 +118,7 @@ void x25_stop_timer(struct sock *sk) unsigned long x25_display_timer(struct sock *sk) { - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); if (!timer_pending(&x25->timer)) return 0; @@ -164,7 +164,7 @@ unlock: */ static inline void x25_do_timer_expiry(struct sock * sk) { - x25_cb *x25 = x25_sk(sk); + struct x25_opt *x25 = x25_sk(sk); switch (x25->state) { -- cgit v1.2.3 From b498a583ebc2a13e5498352a1c2461ff35b72ed4 Mon Sep 17 00:00:00 2001 From: Arnaldo Carvalho de Melo Date: Sat, 28 Sep 2002 15:23:09 -0300 Subject: o X25: use refcnts and protect x25_neigh structs and list Simplify some other code. --- include/net/x25.h | 15 ++- net/x25/af_x25.c | 38 ++++---- net/x25/x25_dev.c | 121 +++++++++++------------- net/x25/x25_facilities.c | 4 +- net/x25/x25_link.c | 242 ++++++++++++++++++++++++----------------------- 5 files changed, 218 insertions(+), 202 deletions(-) (limited to 'include') diff --git a/include/net/x25.h b/include/net/x25.h index 143a1887019a..a043f5e093c8 100644 --- a/include/net/x25.h +++ b/include/net/x25.h @@ -118,7 +118,7 @@ struct x25_route { }; struct x25_neigh { - struct x25_neigh *next; + struct list_head node; struct net_device *dev; unsigned int state; unsigned int extended; @@ -126,6 +126,7 @@ struct x25_neigh { unsigned long t20; struct timer_list t20timer; unsigned long global_facil_mask; + atomic_t refcnt; }; struct x25_opt { @@ -199,6 +200,18 @@ extern int x25_subscr_ioctl(unsigned int, void *); extern struct x25_neigh *x25_get_neigh(struct net_device *); extern void x25_link_free(void); +/* x25_neigh.c */ +static __inline__ void x25_neigh_hold(struct x25_neigh *nb) +{ + atomic_inc(&nb->refcnt); +} + +static __inline__ void x25_neigh_put(struct x25_neigh *nb) +{ + if (atomic_dec_and_test(&nb->refcnt)) + kfree(nb); +} + /* x25_out.c */ extern int x25_output(struct sock *, struct sk_buff *); extern void x25_kick(struct sock *); diff --git a/net/x25/af_x25.c b/net/x25/af_x25.c index 4a0cf4f5cea1..8ac90e9cbe26 100644 --- a/net/x25/af_x25.c +++ b/net/x25/af_x25.c @@ -188,7 +188,7 @@ static void x25_kill_by_device(struct net_device *dev) static int x25_device_event(struct notifier_block *this, unsigned long event, void *ptr) { struct net_device *dev = ptr; - struct x25_neigh *neigh; + struct x25_neigh *nb; if (dev->type == ARPHRD_X25 #if defined(CONFIG_LLC) || defined(CONFIG_LLC_MODULE) @@ -200,8 +200,11 @@ static int x25_device_event(struct notifier_block *this, unsigned long event, vo x25_link_device_up(dev); break; case NETDEV_GOING_DOWN: - if ((neigh = x25_get_neigh(dev))) - x25_terminate_link(neigh); + nb = x25_get_neigh(dev); + if (nb) { + x25_terminate_link(nb); + x25_neigh_put(nb); + } break; case NETDEV_DOWN: x25_kill_by_device(dev); @@ -255,7 +258,7 @@ static struct sock *x25_find_listener(struct x25_address *addr) /* * Find a connected X.25 socket given my LCI and neighbour. */ -struct sock *x25_find_socket(unsigned int lci, struct x25_neigh *neigh) +struct sock *x25_find_socket(unsigned int lci, struct x25_neigh *nb) { struct sock *s; unsigned long flags; @@ -264,7 +267,7 @@ struct sock *x25_find_socket(unsigned int lci, struct x25_neigh *neigh) cli(); for (s = x25_list; s; s = s->next) - if (x25_sk(s)->lci == lci && x25_sk(s)->neighbour == neigh) + if (x25_sk(s)->lci == lci && x25_sk(s)->neighbour == nb) break; restore_flags(flags); @@ -274,11 +277,11 @@ struct sock *x25_find_socket(unsigned int lci, struct x25_neigh *neigh) /* * Find a unique LCI for a given device. */ -unsigned int x25_new_lci(struct x25_neigh *neigh) +unsigned int x25_new_lci(struct x25_neigh *nb) { unsigned int lci = 1; - while (x25_find_socket(lci, neigh)) + while (x25_find_socket(lci, nb)) if (++lci == 4096) { lci = 0; break; @@ -631,11 +634,11 @@ static int x25_connect(struct socket *sock, struct sockaddr *uaddr, int addr_len x25->lci = x25_new_lci(x25->neighbour); if (!x25->lci) - goto out_put_route; + goto out_put_neigh; rc = -EINVAL; if (sk->zapped) /* Must bind first - autobinding does not work */ - goto out_put_route; + goto out_put_neigh; if (!strcmp(x25->source_addr.x25_addr, null_x25_address.x25_addr)) memset(&x25->source_addr, '\0', X25_ADDR_LEN); @@ -656,7 +659,7 @@ static int x25_connect(struct socket *sock, struct sockaddr *uaddr, int addr_len /* Now the loop */ rc = -EINPROGRESS; if (sk->state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) - goto out_put_route; + goto out_put_neigh; cli(); /* To avoid races on the sleep */ @@ -681,6 +684,9 @@ static int x25_connect(struct socket *sock, struct sockaddr *uaddr, int addr_len rc = 0; out_unlock: sti(); +out_put_neigh: + if (rc) + x25_neigh_put(x25->neighbour); out_put_route: x25_route_put(rt); out: @@ -758,7 +764,7 @@ static int x25_getname(struct socket *sock, struct sockaddr *uaddr, int *uaddr_l return 0; } -int x25_rx_call_request(struct sk_buff *skb, struct x25_neigh *neigh, unsigned int lci) +int x25_rx_call_request(struct sk_buff *skb, struct x25_neigh *nb, unsigned int lci) { struct sock *sk; struct sock *make; @@ -800,7 +806,7 @@ int x25_rx_call_request(struct sk_buff *skb, struct x25_neigh *neigh, unsigned i * on certain facilties */ - x25_limit_facilities(&facilities,neigh); + x25_limit_facilities(&facilities, nb); /* * Try to create a new socket. @@ -821,7 +827,7 @@ int x25_rx_call_request(struct sk_buff *skb, struct x25_neigh *neigh, unsigned i makex25->lci = lci; makex25->dest_addr = dest_addr; makex25->source_addr = source_addr; - makex25->neighbour = neigh; + makex25->neighbour = nb; makex25->facilities = facilities; makex25->vc_facil_mask = x25_sk(sk)->vc_facil_mask; @@ -853,7 +859,7 @@ out: return rc; out_clear_request: rc = 0; - x25_transmit_clear_request(neigh, lci, 0x01); + x25_transmit_clear_request(nb, lci, 0x01); goto out; } @@ -1358,12 +1364,12 @@ struct notifier_block x25_dev_notifier = { .notifier_call = x25_device_event, }; -void x25_kill_by_neigh(struct x25_neigh *neigh) +void x25_kill_by_neigh(struct x25_neigh *nb) { struct sock *s; for (s = x25_list; s; s = s->next) - if (x25_sk(s)->neighbour == neigh) + if (x25_sk(s)->neighbour == nb) x25_disconnect(s, ENETUNREACH, 0, 0); } diff --git a/net/x25/x25_dev.c b/net/x25/x25_dev.c index c6e13a2c240a..aa5137f9a5ed 100644 --- a/net/x25/x25_dev.c +++ b/net/x25/x25_dev.c @@ -44,7 +44,7 @@ #include #include -static int x25_receive_data(struct sk_buff *skb, struct x25_neigh *neigh) +static int x25_receive_data(struct sk_buff *skb, struct x25_neigh *nb) { struct sock *sk; unsigned short frametype; @@ -58,14 +58,14 @@ static int x25_receive_data(struct sk_buff *skb, struct x25_neigh *neigh) * frame. */ if (lci == 0) { - x25_link_control(skb, neigh, frametype); + x25_link_control(skb, nb, frametype); return 0; } /* * Find an existing socket. */ - if ((sk = x25_find_socket(lci, neigh)) != NULL) { + if ((sk = x25_find_socket(lci, nb)) != NULL) { int queued = 1; skb->h.raw = skb->data; @@ -83,91 +83,87 @@ static int x25_receive_data(struct sk_buff *skb, struct x25_neigh *neigh) * Is is a Call Request ? if so process it. */ if (frametype == X25_CALL_REQUEST) - return x25_rx_call_request(skb, neigh, lci); + return x25_rx_call_request(skb, nb, lci); /* * Its not a Call Request, nor is it a control frame. * Let caller throw it away. */ /* - x25_transmit_clear_request(neigh, lci, 0x0D); + x25_transmit_clear_request(nb, lci, 0x0D); */ printk(KERN_DEBUG "x25_receive_data(): unknown frame type %2x\n",frametype); return 0; } -int x25_lapb_receive_frame(struct sk_buff *skb, struct net_device *dev, struct packet_type *ptype) +int x25_lapb_receive_frame(struct sk_buff *skb, struct net_device *dev, + struct packet_type *ptype) { - struct x25_neigh *neigh; - int queued; + struct x25_neigh *nb; skb->sk = NULL; /* - * Packet received from unrecognised device, throw it away. + * Packet received from unrecognised device, throw it away. */ - if ((neigh = x25_get_neigh(dev)) == NULL) { + nb = x25_get_neigh(dev); + if (!nb) { printk(KERN_DEBUG "X.25: unknown neighbour - %s\n", dev->name); - kfree_skb(skb); - return 0; + goto drop; } switch (skb->data[0]) { case 0x00: skb_pull(skb, 1); - queued = x25_receive_data(skb, neigh); - if( ! queued ) - /* We need to free the skb ourselves because - * net_bh() won't care about our return code. - */ - kfree_skb(skb); - return 0; - + if (x25_receive_data(skb, nb)) { + x25_neigh_put(nb); + goto out; + } + break; case 0x01: - x25_link_established(neigh); - kfree_skb(skb); - return 0; - + x25_link_established(nb); + break; case 0x02: - x25_link_terminated(neigh); - kfree_skb(skb); - return 0; - - case 0x03: - kfree_skb(skb); - return 0; - - default: - kfree_skb(skb); - return 0; + x25_link_terminated(nb); + break; } + x25_neigh_put(nb); +drop: + kfree_skb(skb); +out: + return 0; } -int x25_llc_receive_frame(struct sk_buff *skb, struct net_device *dev, struct packet_type *ptype) +int x25_llc_receive_frame(struct sk_buff *skb, struct net_device *dev, + struct packet_type *ptype) { - struct x25_neigh *neigh; + struct x25_neigh *nb; + int rc = 0; skb->sk = NULL; /* - * Packet received from unrecognised device, throw it away. + * Packet received from unrecognised device, throw it away. */ - if ((neigh = x25_get_neigh(dev)) == NULL) { + nb = x25_get_neigh(dev); + if (!nb) { printk(KERN_DEBUG "X.25: unknown_neighbour - %s\n", dev->name); kfree_skb(skb); - return 0; + } else { + rc = x25_receive_data(skb, nb); + x25_neigh_put(nb); } - return x25_receive_data(skb, neigh); + return rc; } -void x25_establish_link(struct x25_neigh *neigh) +void x25_establish_link(struct x25_neigh *nb) { struct sk_buff *skb; unsigned char *ptr; - switch (neigh->dev->type) { + switch (nb->dev->type) { case ARPHRD_X25: if ((skb = alloc_skb(1, GFP_ATOMIC)) == NULL) { printk(KERN_ERR "x25_dev: out of memory\n"); @@ -186,47 +182,44 @@ void x25_establish_link(struct x25_neigh *neigh) } skb->protocol = htons(ETH_P_X25); - skb->dev = neigh->dev; + skb->dev = nb->dev; dev_queue_xmit(skb); } -void x25_terminate_link(struct x25_neigh *neigh) +void x25_terminate_link(struct x25_neigh *nb) { struct sk_buff *skb; unsigned char *ptr; - switch (neigh->dev->type) { - case ARPHRD_X25: - if ((skb = alloc_skb(1, GFP_ATOMIC)) == NULL) { - printk(KERN_ERR "x25_dev: out of memory\n"); - return; - } - ptr = skb_put(skb, 1); - *ptr = 0x02; - break; - #if defined(CONFIG_LLC) || defined(CONFIG_LLC_MODULE) - case ARPHRD_ETHER: - return; + if (nb->dev->type == ARPHRD_ETHER) + return; #endif - default: - return; + if (nb->dev->type != ARPHRD_X25) + return; + + skb = alloc_skb(1, GFP_ATOMIC); + if (!skb) { + printk(KERN_ERR "x25_dev: out of memory\n"); + return; } - skb->protocol = htons(ETH_P_X25); - skb->dev = neigh->dev; + ptr = skb_put(skb, 1); + *ptr = 0x02; + skb->protocol = htons(ETH_P_X25); + skb->dev = nb->dev; dev_queue_xmit(skb); } -void x25_send_frame(struct sk_buff *skb, struct x25_neigh *neigh) +void x25_send_frame(struct sk_buff *skb, struct x25_neigh *nb) { unsigned char *dptr; skb->nh.raw = skb->data; - switch (neigh->dev->type) { + switch (nb->dev->type) { case ARPHRD_X25: dptr = skb_push(skb, 1); *dptr = 0x00; @@ -243,7 +236,7 @@ void x25_send_frame(struct sk_buff *skb, struct x25_neigh *neigh) } skb->protocol = htons(ETH_P_X25); - skb->dev = neigh->dev; + skb->dev = nb->dev; dev_queue_xmit(skb); } diff --git a/net/x25/x25_facilities.c b/net/x25/x25_facilities.c index 74e34b4e1e9d..3872cb4435a4 100644 --- a/net/x25/x25_facilities.c +++ b/net/x25/x25_facilities.c @@ -229,10 +229,10 @@ int x25_negotiate_facilities(struct sk_buff *skb, struct sock *sk, * currently attached x25 link. */ void x25_limit_facilities(struct x25_facilities *facilities, - struct x25_neigh *neighbour) + struct x25_neigh *nb) { - if (!neighbour->extended) { + if (!nb->extended) { if (facilities->winsize_in > 7) { printk(KERN_DEBUG "X.25: incoming winsize limited to 7\n"); facilities->winsize_in = 7; diff --git a/net/x25/x25_link.c b/net/x25/x25_link.c index 1ba5affe5d97..218143ce6d48 100644 --- a/net/x25/x25_link.c +++ b/net/x25/x25_link.c @@ -43,47 +43,48 @@ #include #include -static struct x25_neigh *x25_neigh_list; /* = NULL initially */ +static struct list_head x25_neigh_list = LIST_HEAD_INIT(x25_neigh_list); +static rwlock_t x25_neigh_list_lock = RW_LOCK_UNLOCKED; static void x25_t20timer_expiry(unsigned long); /* * Linux set/reset timer routines */ -static void x25_start_t20timer(struct x25_neigh *neigh) +static void x25_start_t20timer(struct x25_neigh *nb) { - del_timer(&neigh->t20timer); + del_timer(&nb->t20timer); - neigh->t20timer.data = (unsigned long)neigh; - neigh->t20timer.function = &x25_t20timer_expiry; - neigh->t20timer.expires = jiffies + neigh->t20; + nb->t20timer.data = (unsigned long)nb; + nb->t20timer.function = &x25_t20timer_expiry; + nb->t20timer.expires = jiffies + nb->t20; - add_timer(&neigh->t20timer); + add_timer(&nb->t20timer); } static void x25_t20timer_expiry(unsigned long param) { - struct x25_neigh *neigh = (struct x25_neigh *)param; + struct x25_neigh *nb = (struct x25_neigh *)param; - x25_transmit_restart_request(neigh); + x25_transmit_restart_request(nb); - x25_start_t20timer(neigh); + x25_start_t20timer(nb); } -static void x25_stop_t20timer(struct x25_neigh *neigh) +static void x25_stop_t20timer(struct x25_neigh *nb) { - del_timer(&neigh->t20timer); + del_timer(&nb->t20timer); } -static int x25_t20timer_pending(struct x25_neigh *neigh) +static int x25_t20timer_pending(struct x25_neigh *nb) { - return timer_pending(&neigh->t20timer); + return timer_pending(&nb->t20timer); } /* * This handles all restart and diagnostic frames. */ -void x25_link_control(struct sk_buff *skb, struct x25_neigh *neigh, +void x25_link_control(struct sk_buff *skb, struct x25_neigh *nb, unsigned short frametype) { struct sk_buff *skbn; @@ -91,16 +92,16 @@ void x25_link_control(struct sk_buff *skb, struct x25_neigh *neigh, switch (frametype) { case X25_RESTART_REQUEST: - confirm = !x25_t20timer_pending(neigh); - x25_stop_t20timer(neigh); - neigh->state = X25_LINK_STATE_3; + confirm = !x25_t20timer_pending(nb); + x25_stop_t20timer(nb); + nb->state = X25_LINK_STATE_3; if (confirm) - x25_transmit_restart_confirmation(neigh); + x25_transmit_restart_confirmation(nb); break; case X25_RESTART_CONFIRMATION: - x25_stop_t20timer(neigh); - neigh->state = X25_LINK_STATE_3; + x25_stop_t20timer(nb); + nb->state = X25_LINK_STATE_3; break; case X25_DIAGNOSTIC: @@ -116,15 +117,15 @@ void x25_link_control(struct sk_buff *skb, struct x25_neigh *neigh, break; } - if (neigh->state == X25_LINK_STATE_3) - while ((skbn = skb_dequeue(&neigh->queue)) != NULL) - x25_send_frame(skbn, neigh); + if (nb->state == X25_LINK_STATE_3) + while ((skbn = skb_dequeue(&nb->queue)) != NULL) + x25_send_frame(skbn, nb); } /* * This routine is called when a Restart Request is needed */ -void x25_transmit_restart_request(struct x25_neigh *neigh) +void x25_transmit_restart_request(struct x25_neigh *nb) { unsigned char *dptr; int len = X25_MAX_L2_LEN + X25_STD_MIN_LEN + 2; @@ -137,7 +138,7 @@ void x25_transmit_restart_request(struct x25_neigh *neigh) dptr = skb_put(skb, X25_STD_MIN_LEN + 2); - *dptr++ = neigh->extended ? X25_GFI_EXTSEQ : X25_GFI_STDSEQ; + *dptr++ = nb->extended ? X25_GFI_EXTSEQ : X25_GFI_STDSEQ; *dptr++ = 0x00; *dptr++ = X25_RESTART_REQUEST; *dptr++ = 0x00; @@ -145,13 +146,13 @@ void x25_transmit_restart_request(struct x25_neigh *neigh) skb->sk = NULL; - x25_send_frame(skb, neigh); + x25_send_frame(skb, nb); } /* * This routine is called when a Restart Confirmation is needed */ -void x25_transmit_restart_confirmation(struct x25_neigh *neigh) +void x25_transmit_restart_confirmation(struct x25_neigh *nb) { unsigned char *dptr; int len = X25_MAX_L2_LEN + X25_STD_MIN_LEN; @@ -164,19 +165,19 @@ void x25_transmit_restart_confirmation(struct x25_neigh *neigh) dptr = skb_put(skb, X25_STD_MIN_LEN); - *dptr++ = neigh->extended ? X25_GFI_EXTSEQ : X25_GFI_STDSEQ; + *dptr++ = nb->extended ? X25_GFI_EXTSEQ : X25_GFI_STDSEQ; *dptr++ = 0x00; *dptr++ = X25_RESTART_CONFIRMATION; skb->sk = NULL; - x25_send_frame(skb, neigh); + x25_send_frame(skb, nb); } /* * This routine is called when a Diagnostic is required. */ -void x25_transmit_diagnostic(struct x25_neigh *neigh, unsigned char diag) +void x25_transmit_diagnostic(struct x25_neigh *nb, unsigned char diag) { unsigned char *dptr; int len = X25_MAX_L2_LEN + X25_STD_MIN_LEN + 1; @@ -189,21 +190,22 @@ void x25_transmit_diagnostic(struct x25_neigh *neigh, unsigned char diag) dptr = skb_put(skb, X25_STD_MIN_LEN + 1); - *dptr++ = neigh->extended ? X25_GFI_EXTSEQ : X25_GFI_STDSEQ; + *dptr++ = nb->extended ? X25_GFI_EXTSEQ : X25_GFI_STDSEQ; *dptr++ = 0x00; *dptr++ = X25_DIAGNOSTIC; *dptr++ = diag; skb->sk = NULL; - x25_send_frame(skb, neigh); + x25_send_frame(skb, nb); } /* * This routine is called when a Clear Request is needed outside of the context * of a connected socket. */ -void x25_transmit_clear_request(struct x25_neigh *neigh, unsigned int lci, unsigned char cause) +void x25_transmit_clear_request(struct x25_neigh *nb, unsigned int lci, + unsigned char cause) { unsigned char *dptr; int len = X25_MAX_L2_LEN + X25_STD_MIN_LEN + 2; @@ -216,7 +218,7 @@ void x25_transmit_clear_request(struct x25_neigh *neigh, unsigned int lci, unsig dptr = skb_put(skb, X25_STD_MIN_LEN + 2); - *dptr++ = ((lci >> 8) & 0x0F) | neigh->extended ? X25_GFI_EXTSEQ : + *dptr++ = ((lci >> 8) & 0x0F) | nb->extended ? X25_GFI_EXTSEQ : X25_GFI_STDSEQ; *dptr++ = (lci >> 0) & 0xFF; *dptr++ = X25_CLEAR_REQUEST; @@ -225,23 +227,23 @@ void x25_transmit_clear_request(struct x25_neigh *neigh, unsigned int lci, unsig skb->sk = NULL; - x25_send_frame(skb, neigh); + x25_send_frame(skb, nb); } -void x25_transmit_link(struct sk_buff *skb, struct x25_neigh *neigh) +void x25_transmit_link(struct sk_buff *skb, struct x25_neigh *nb) { - switch (neigh->state) { + switch (nb->state) { case X25_LINK_STATE_0: - skb_queue_tail(&neigh->queue, skb); - neigh->state = X25_LINK_STATE_1; - x25_establish_link(neigh); + skb_queue_tail(&nb->queue, skb); + nb->state = X25_LINK_STATE_1; + x25_establish_link(nb); break; case X25_LINK_STATE_1: case X25_LINK_STATE_2: - skb_queue_tail(&neigh->queue, skb); + skb_queue_tail(&nb->queue, skb); break; case X25_LINK_STATE_3: - x25_send_frame(skb, neigh); + x25_send_frame(skb, nb); break; } } @@ -249,16 +251,16 @@ void x25_transmit_link(struct sk_buff *skb, struct x25_neigh *neigh) /* * Called when the link layer has become established. */ -void x25_link_established(struct x25_neigh *neigh) +void x25_link_established(struct x25_neigh *nb) { - switch (neigh->state) { + switch (nb->state) { case X25_LINK_STATE_0: - neigh->state = X25_LINK_STATE_2; + nb->state = X25_LINK_STATE_2; break; case X25_LINK_STATE_1: - x25_transmit_restart_request(neigh); - neigh->state = X25_LINK_STATE_2; - x25_start_t20timer(neigh); + x25_transmit_restart_request(nb); + nb->state = X25_LINK_STATE_2; + x25_start_t20timer(nb); break; } } @@ -268,11 +270,11 @@ void x25_link_established(struct x25_neigh *neigh) * request has failed. */ -void x25_link_terminated(struct x25_neigh *neigh) +void x25_link_terminated(struct x25_neigh *nb) { - neigh->state = X25_LINK_STATE_0; + nb->state = X25_LINK_STATE_0; /* Out of order: clear existing virtual calls (X.25 03/93 4.6.3) */ - x25_kill_by_neigh(neigh); + x25_kill_by_neigh(nb); } /* @@ -280,65 +282,50 @@ void x25_link_terminated(struct x25_neigh *neigh) */ void x25_link_device_up(struct net_device *dev) { - unsigned long flags; - struct x25_neigh *x25_neigh = kmalloc(sizeof(*x25_neigh), GFP_ATOMIC); + struct x25_neigh *nb = kmalloc(sizeof(*nb), GFP_ATOMIC); - if (!x25_neigh) + if (!nb) return; - skb_queue_head_init(&x25_neigh->queue); + skb_queue_head_init(&nb->queue); - init_timer(&x25_neigh->t20timer); + init_timer(&nb->t20timer); dev_hold(dev); - x25_neigh->dev = dev; - x25_neigh->state = X25_LINK_STATE_0; - x25_neigh->extended = 0; + nb->dev = dev; + nb->state = X25_LINK_STATE_0; + nb->extended = 0; /* * Enables negotiation */ - x25_neigh->global_facil_mask = X25_MASK_REVERSE | + nb->global_facil_mask = X25_MASK_REVERSE | X25_MASK_THROUGHPUT | X25_MASK_PACKET_SIZE | X25_MASK_WINDOW_SIZE; - x25_neigh->t20 = sysctl_x25_restart_request_timeout; + nb->t20 = sysctl_x25_restart_request_timeout; + atomic_set(&nb->refcnt, 1); - save_flags(flags); cli(); - x25_neigh->next = x25_neigh_list; - x25_neigh_list = x25_neigh; - restore_flags(flags); + write_lock_bh(&x25_neigh_list_lock); + list_add(&nb->node, &x25_neigh_list); + write_unlock_bh(&x25_neigh_list_lock); } -static void x25_remove_neigh(struct x25_neigh *x25_neigh) +/** + * __x25_remove_neigh - remove neighbour from x25_neigh_list + * @nb - neigh to remove + * + * Remove neighbour from x25_neigh_list. If it was there. + * Caller must hold x25_neigh_list_lock. + */ +static void __x25_remove_neigh(struct x25_neigh *nb) { - struct x25_neigh *s; - unsigned long flags; - - skb_queue_purge(&x25_neigh->queue); - - x25_stop_t20timer(x25_neigh); - - save_flags(flags); cli(); - - if ((s = x25_neigh_list) == x25_neigh) { - x25_neigh_list = x25_neigh->next; - goto out_kfree_neigh; - } - - while (s && s->next) { - if (s->next == x25_neigh) { - s->next = x25_neigh->next; - goto out_kfree_neigh; - } + skb_queue_purge(&nb->queue); + x25_stop_t20timer(nb); - s = s->next; + if (nb->node.next) { + list_del(&nb->node); + x25_neigh_put(nb); } -out: - restore_flags(flags); - return; -out_kfree_neigh: - kfree(x25_neigh); - goto out; } /* @@ -346,17 +333,21 @@ out_kfree_neigh: */ void x25_link_device_down(struct net_device *dev) { - struct x25_neigh *neigh, *x25_neigh = x25_neigh_list; + struct x25_neigh *nb; + struct list_head *entry, *tmp; - while (x25_neigh) { - neigh = x25_neigh; - x25_neigh = x25_neigh->next; + write_lock_bh(&x25_neigh_list_lock); - if (neigh->dev == dev) { - x25_remove_neigh(neigh); + list_for_each_safe(entry, tmp, &x25_neigh_list) { + nb = list_entry(entry, struct x25_neigh, node); + + if (nb->dev == dev) { + __x25_remove_neigh(nb); dev_put(dev); } } + + write_unlock_bh(&x25_neigh_list_lock); } /* @@ -364,13 +355,23 @@ void x25_link_device_down(struct net_device *dev) */ struct x25_neigh *x25_get_neigh(struct net_device *dev) { - struct x25_neigh *x25_neigh = x25_neigh_list; + struct x25_neigh *nb, *use = NULL; + struct list_head *entry; - for (; x25_neigh; x25_neigh = x25_neigh->next) - if (x25_neigh->dev == dev) + read_lock_bh(&x25_neigh_list_lock); + list_for_each(entry, &x25_neigh_list) { + nb = list_entry(entry, struct x25_neigh, node); + + if (nb->dev == dev) { + use = nb; break; + } + } - return x25_neigh; + if (use) + x25_neigh_hold(use); + read_unlock_bh(&x25_neigh_list_lock); + return use; } /* @@ -379,7 +380,7 @@ struct x25_neigh *x25_get_neigh(struct net_device *dev) int x25_subscr_ioctl(unsigned int cmd, void *arg) { struct x25_subscrip_struct x25_subscr; - struct x25_neigh *x25_neigh; + struct x25_neigh *nb; struct net_device *dev; int rc = -EINVAL; @@ -394,27 +395,28 @@ int x25_subscr_ioctl(unsigned int cmd, void *arg) if ((dev = x25_dev_get(x25_subscr.device)) == NULL) goto out; - if ((x25_neigh = x25_get_neigh(dev)) == NULL) - goto out_put; + if ((nb = x25_get_neigh(dev)) == NULL) + goto out_dev_put; dev_put(dev); if (cmd == SIOCX25GSUBSCRIP) { - x25_subscr.extended = x25_neigh->extended; - x25_subscr.global_facil_mask = x25_neigh->global_facil_mask; + x25_subscr.extended = nb->extended; + x25_subscr.global_facil_mask = nb->global_facil_mask; rc = copy_to_user(arg, &x25_subscr, sizeof(x25_subscr)) ? -EFAULT : 0; } else { rc = -EINVAL; - if (x25_subscr.extended && x25_subscr.extended != 1) - goto out; - rc = 0; - x25_neigh->extended = x25_subscr.extended; - x25_neigh->global_facil_mask = x25_subscr.global_facil_mask; + if (!(x25_subscr.extended && x25_subscr.extended != 1)) { + rc = 0; + nb->extended = x25_subscr.extended; + nb->global_facil_mask = x25_subscr.global_facil_mask; + } } + x25_neigh_put(nb); out: return rc; -out_put: +out_dev_put: dev_put(dev); goto out; } @@ -425,12 +427,14 @@ out_put: */ void __exit x25_link_free(void) { - struct x25_neigh *neigh, *x25_neigh = x25_neigh_list; + struct x25_neigh *nb; + struct list_head *entry, *tmp; - while (x25_neigh) { - neigh = x25_neigh; - x25_neigh = x25_neigh->next; + write_lock_bh(&x25_neigh_list_lock); - x25_remove_neigh(neigh); + list_for_each_safe(entry, tmp, &x25_neigh_list) { + nb = list_entry(entry, struct x25_neigh, node); + __x25_remove_neigh(nb); } + write_unlock_bh(&x25_neigh_list_lock); } -- cgit v1.2.3 From a134be24c2012076738593dc3d299765f4d40be3 Mon Sep 17 00:00:00 2001 From: Arnaldo Carvalho de Melo Date: Sat, 28 Sep 2002 20:07:09 -0300 Subject: o LAPB: use refcounts and rwlock to protect lapb_cb and list Also some CodingStyle code reformatting. Ah, killed the typedef for lapb_cb. --- include/net/lapb.h | 60 ++++----- net/lapb/lapb_iface.c | 308 +++++++++++++++++++++++++-------------------- net/lapb/lapb_in.c | 340 +++++++++++++++++++++++++++++++------------------- net/lapb/lapb_out.c | 69 +++++----- net/lapb/lapb_subr.c | 85 ++++++++----- net/lapb/lapb_timer.c | 14 +-- 6 files changed, 513 insertions(+), 363 deletions(-) (limited to 'include') diff --git a/include/net/lapb.h b/include/net/lapb.h index 7cc9b3452abb..50292be77a71 100644 --- a/include/net/lapb.h +++ b/include/net/lapb.h @@ -78,8 +78,8 @@ struct lapb_frame { /* * The per LAPB connection control structure. */ -typedef struct lapb_cb { - struct lapb_cb *next; +struct lapb_cb { + struct list_head node; void *token; /* Link status fields */ @@ -100,43 +100,45 @@ typedef struct lapb_cb { /* FRMR control information */ struct lapb_frame frmr_data; unsigned char frmr_type; -} lapb_cb; + + atomic_t refcnt; +}; /* lapb_iface.c */ -extern void lapb_connect_confirmation(lapb_cb *, int); -extern void lapb_connect_indication(lapb_cb *, int); -extern void lapb_disconnect_confirmation(lapb_cb *, int); -extern void lapb_disconnect_indication(lapb_cb *, int); -extern int lapb_data_indication(lapb_cb *, struct sk_buff *); -extern int lapb_data_transmit(lapb_cb *, struct sk_buff *); +extern void lapb_connect_confirmation(struct lapb_cb *lapb, int); +extern void lapb_connect_indication(struct lapb_cb *lapb, int); +extern void lapb_disconnect_confirmation(struct lapb_cb *lapb, int); +extern void lapb_disconnect_indication(struct lapb_cb *lapb, int); +extern int lapb_data_indication(struct lapb_cb *lapb, struct sk_buff *); +extern int lapb_data_transmit(struct lapb_cb *lapb, struct sk_buff *); /* lapb_in.c */ -extern void lapb_data_input(lapb_cb *, struct sk_buff *); +extern void lapb_data_input(struct lapb_cb *lapb, struct sk_buff *); /* lapb_out.c */ -extern void lapb_kick(lapb_cb *); -extern void lapb_transmit_buffer(lapb_cb *, struct sk_buff *, int); -extern void lapb_establish_data_link(lapb_cb *); -extern void lapb_enquiry_response(lapb_cb *); -extern void lapb_timeout_response(lapb_cb *); -extern void lapb_check_iframes_acked(lapb_cb *, unsigned short); -extern void lapb_check_need_response(lapb_cb *, int, int); +extern void lapb_kick(struct lapb_cb *lapb); +extern void lapb_transmit_buffer(struct lapb_cb *lapb, struct sk_buff *, int); +extern void lapb_establish_data_link(struct lapb_cb *lapb); +extern void lapb_enquiry_response(struct lapb_cb *lapb); +extern void lapb_timeout_response(struct lapb_cb *lapb); +extern void lapb_check_iframes_acked(struct lapb_cb *lapb, unsigned short); +extern void lapb_check_need_response(struct lapb_cb *lapb, int, int); /* lapb_subr.c */ -extern void lapb_clear_queues(lapb_cb *); -extern void lapb_frames_acked(lapb_cb *, unsigned short); -extern void lapb_requeue_frames(lapb_cb *); -extern int lapb_validate_nr(lapb_cb *, unsigned short); -extern void lapb_decode(lapb_cb *, struct sk_buff *, struct lapb_frame *); -extern void lapb_send_control(lapb_cb *, int, int, int); -extern void lapb_transmit_frmr(lapb_cb *); +extern void lapb_clear_queues(struct lapb_cb *lapb); +extern void lapb_frames_acked(struct lapb_cb *lapb, unsigned short); +extern void lapb_requeue_frames(struct lapb_cb *lapb); +extern int lapb_validate_nr(struct lapb_cb *lapb, unsigned short); +extern void lapb_decode(struct lapb_cb *lapb, struct sk_buff *, struct lapb_frame *); +extern void lapb_send_control(struct lapb_cb *lapb, int, int, int); +extern void lapb_transmit_frmr(struct lapb_cb *lapb); /* lapb_timer.c */ -extern void lapb_start_t1timer(lapb_cb *); -extern void lapb_start_t2timer(lapb_cb *); -extern void lapb_stop_t1timer(lapb_cb *); -extern void lapb_stop_t2timer(lapb_cb *); -extern int lapb_t1timer_running(lapb_cb *); +extern void lapb_start_t1timer(struct lapb_cb *lapb); +extern void lapb_start_t2timer(struct lapb_cb *lapb); +extern void lapb_stop_t1timer(struct lapb_cb *lapb); +extern void lapb_stop_t2timer(struct lapb_cb *lapb); +extern int lapb_t1timer_running(struct lapb_cb *lapb); /* * Debug levels. diff --git a/net/lapb/lapb_iface.c b/net/lapb/lapb_iface.c index f932afcea4b8..cb3f7ecded46 100644 --- a/net/lapb/lapb_iface.c +++ b/net/lapb/lapb_iface.c @@ -39,87 +39,93 @@ #include #include -static lapb_cb *volatile lapb_list /* = NULL initially */; +static struct list_head lapb_list = LIST_HEAD_INIT(lapb_list); +static rwlock_t lapb_list_lock = RW_LOCK_UNLOCKED; /* * Free an allocated lapb control block. This is done to centralise * the MOD count code. */ -static void lapb_free_cb(lapb_cb *lapb) +static void lapb_free_cb(struct lapb_cb *lapb) { kfree(lapb); - MOD_DEC_USE_COUNT; } +static __inline__ void lapb_hold(struct lapb_cb *lapb) +{ + atomic_inc(&lapb->refcnt); +} + +static __inline__ void lapb_put(struct lapb_cb *lapb) +{ + if (atomic_dec_and_test(&lapb->refcnt)) + lapb_free_cb(lapb); +} + /* * Socket removal during an interrupt is now safe. */ -static void lapb_remove_cb(lapb_cb *lapb) +static void __lapb_remove_cb(struct lapb_cb *lapb) { - lapb_cb *s; - unsigned long flags; - - save_flags(flags); cli(); - - if ((s = lapb_list) == lapb) { - lapb_list = s->next; - restore_flags(flags); - return; + if (lapb->node.next) { + list_del(&lapb->node); + lapb_put(lapb); } - - while (s != NULL && s->next != NULL) { - if (s->next == lapb) { - s->next = lapb->next; - restore_flags(flags); - return; - } - - s = s->next; - } - - restore_flags(flags); } /* * Add a socket to the bound sockets list. */ -static void lapb_insert_cb(lapb_cb *lapb) +static void __lapb_insert_cb(struct lapb_cb *lapb) { - unsigned long flags; - - save_flags(flags); cli(); - - lapb->next = lapb_list; - lapb_list = lapb; - - restore_flags(flags); + list_add(&lapb->node, &lapb_list); + lapb_hold(lapb); } /* * Convert the integer token used by the device driver into a pointer * to a LAPB control structure. */ -static lapb_cb *lapb_tokentostruct(void *token) +static struct lapb_cb *__lapb_tokentostruct(void *token) { - lapb_cb *lapb; + struct list_head *entry; + struct lapb_cb *lapb, *use = NULL; + + list_for_each(entry, &lapb_list) { + lapb = list_entry(entry, struct lapb_cb, node); + if (lapb->token == token) { + use = lapb; + break; + } + } - for (lapb = lapb_list; lapb != NULL; lapb = lapb->next) - if (lapb->token == token) - return lapb; + if (use) + lapb_hold(use); - return NULL; + return use; } +static struct lapb_cb *lapb_tokentostruct(void *token) +{ + struct lapb_cb *rc; + + read_lock_bh(&lapb_list_lock); + rc = __lapb_tokentostruct(token); + read_unlock_bh(&lapb_list_lock); + + return rc; +} /* * Create an empty LAPB control block. */ -static lapb_cb *lapb_create_cb(void) +static struct lapb_cb *lapb_create_cb(void) { - lapb_cb *lapb; + struct lapb_cb *lapb = kmalloc(sizeof(*lapb), GFP_ATOMIC); + - if ((lapb = kmalloc(sizeof(*lapb), GFP_ATOMIC)) == NULL) - return NULL; + if (!lapb) + goto out; MOD_INC_USE_COUNT; @@ -137,55 +143,73 @@ static lapb_cb *lapb_create_cb(void) lapb->mode = LAPB_DEFAULT_MODE; lapb->window = LAPB_DEFAULT_WINDOW; lapb->state = LAPB_STATE_0; - + atomic_set(&lapb->refcnt, 1); +out: return lapb; } int lapb_register(void *token, struct lapb_register_struct *callbacks) { - lapb_cb *lapb; + struct lapb_cb *lapb; + int rc = LAPB_BADTOKEN; + + write_lock_bh(&lapb_list_lock); - if (lapb_tokentostruct(token) != NULL) - return LAPB_BADTOKEN; + lapb = __lapb_tokentostruct(token); + if (lapb) { + lapb_put(lapb); + goto out; + } - if ((lapb = lapb_create_cb()) == NULL) - return LAPB_NOMEM; + lapb = lapb_create_cb(); + rc = LAPB_NOMEM; + if (!lapb) + goto out; lapb->token = token; lapb->callbacks = *callbacks; - lapb_insert_cb(lapb); + __lapb_insert_cb(lapb); lapb_start_t1timer(lapb); - return LAPB_OK; + rc = LAPB_OK; +out: + write_unlock_bh(&lapb_list_lock); + return rc; } int lapb_unregister(void *token) { - lapb_cb *lapb; + struct lapb_cb *lapb; + int rc = LAPB_BADTOKEN; - if ((lapb = lapb_tokentostruct(token)) == NULL) - return LAPB_BADTOKEN; + write_unlock_bh(&lapb_list_lock); + lapb = __lapb_tokentostruct(token); + if (!lapb) + goto out; lapb_stop_t1timer(lapb); lapb_stop_t2timer(lapb); lapb_clear_queues(lapb); - lapb_remove_cb(lapb); + __lapb_remove_cb(lapb); - lapb_free_cb(lapb); - - return LAPB_OK; + lapb_put(lapb); + rc = LAPB_OK; +out: + write_unlock_bh(&lapb_list_lock); + return rc; } int lapb_getparms(void *token, struct lapb_parms_struct *parms) { - lapb_cb *lapb; + int rc = LAPB_BADTOKEN; + struct lapb_cb *lapb = lapb_tokentostruct(token); - if ((lapb = lapb_tokentostruct(token)) == NULL) - return LAPB_BADTOKEN; + if (!lapb) + goto out; parms->t1 = lapb->t1 / HZ; parms->t2 = lapb->t2 / HZ; @@ -205,33 +229,29 @@ int lapb_getparms(void *token, struct lapb_parms_struct *parms) else parms->t2timer = (lapb->t2timer.expires - jiffies) / HZ; - return LAPB_OK; + lapb_put(lapb); + rc = LAPB_OK; +out: + return rc; } int lapb_setparms(void *token, struct lapb_parms_struct *parms) { - lapb_cb *lapb; - - if ((lapb = lapb_tokentostruct(token)) == NULL) - return LAPB_BADTOKEN; - - if (parms->t1 < 1) - return LAPB_INVALUE; + int rc = LAPB_BADTOKEN; + struct lapb_cb *lapb = lapb_tokentostruct(token); - if (parms->t2 < 1) - return LAPB_INVALUE; + if (!lapb) + goto out; - if (parms->n2 < 1) - return LAPB_INVALUE; + rc = LAPB_INVALUE; + if (parms->t1 < 1 || parms->t2 < 1 || parms->n2 < 1) + goto out_put; if (lapb->state == LAPB_STATE_0) { - if (parms->mode & LAPB_EXTENDED) { - if (parms->window < 1 || parms->window > 127) - return LAPB_INVALUE; - } else { - if (parms->window < 1 || parms->window > 7) - return LAPB_INVALUE; - } + if (((parms->mode & LAPB_EXTENDED) && + (parms->window < 1 || parms->window > 127)) || + (parms->window < 1 || parms->window > 7)) + goto out_put; lapb->mode = parms->mode; lapb->window = parms->window; @@ -241,45 +261,55 @@ int lapb_setparms(void *token, struct lapb_parms_struct *parms) lapb->t2 = parms->t2 * HZ; lapb->n2 = parms->n2; - return LAPB_OK; + rc = LAPB_OK; +out_put: + lapb_put(lapb); +out: + return rc; } int lapb_connect_request(void *token) { - lapb_cb *lapb; + struct lapb_cb *lapb = lapb_tokentostruct(token); + int rc = LAPB_BADTOKEN; - if ((lapb = lapb_tokentostruct(token)) == NULL) - return LAPB_BADTOKEN; + if (!lapb) + goto out; - switch (lapb->state) { - case LAPB_STATE_1: - return LAPB_OK; - case LAPB_STATE_3: - case LAPB_STATE_4: - return LAPB_CONNECTED; - } + rc = LAPB_OK; + if (lapb->state == LAPB_STATE_1) + goto out_put; + + rc = LAPB_CONNECTED; + if (lapb->state == LAPB_STATE_3 || lapb->state == LAPB_STATE_4) + goto out_put; lapb_establish_data_link(lapb); #if LAPB_DEBUG > 0 printk(KERN_DEBUG "lapb: (%p) S0 -> S1\n", lapb->token); #endif - lapb->state = LAPB_STATE_1; - return LAPB_OK; + rc = LAPB_OK; +out_put: + lapb_put(lapb); +out: + return rc; } int lapb_disconnect_request(void *token) { - lapb_cb *lapb; + struct lapb_cb *lapb = lapb_tokentostruct(token); + int rc = LAPB_BADTOKEN; - if ((lapb = lapb_tokentostruct(token)) == NULL) - return LAPB_BADTOKEN; + if (!lapb) + goto out; switch (lapb->state) { case LAPB_STATE_0: - return LAPB_NOTCONNECTED; + rc = LAPB_NOTCONNECTED; + goto out_put; case LAPB_STATE_1: #if LAPB_DEBUG > 1 @@ -291,10 +321,12 @@ int lapb_disconnect_request(void *token) lapb_send_control(lapb, LAPB_DISC, LAPB_POLLON, LAPB_COMMAND); lapb->state = LAPB_STATE_0; lapb_start_t1timer(lapb); - return LAPB_NOTCONNECTED; + rc = LAPB_NOTCONNECTED; + goto out_put; case LAPB_STATE_2: - return LAPB_OK; + rc = LAPB_OK; + goto out_put; } lapb_clear_queues(lapb); @@ -311,77 +343,87 @@ int lapb_disconnect_request(void *token) printk(KERN_DEBUG "lapb: (%p) S3 -> S2\n", lapb->token); #endif - return LAPB_OK; + rc = LAPB_OK; +out_put: + lapb_put(lapb); +out: + return rc; } int lapb_data_request(void *token, struct sk_buff *skb) { - lapb_cb *lapb; + struct lapb_cb *lapb = lapb_tokentostruct(token); + int rc = LAPB_BADTOKEN; - if ((lapb = lapb_tokentostruct(token)) == NULL) - return LAPB_BADTOKEN; + if (!lapb) + goto out; + rc = LAPB_NOTCONNECTED; if (lapb->state != LAPB_STATE_3 && lapb->state != LAPB_STATE_4) - return LAPB_NOTCONNECTED; + goto out_put; skb_queue_tail(&lapb->write_queue, skb); - lapb_kick(lapb); - - return LAPB_OK; + rc = LAPB_OK; +out_put: + lapb_put(lapb); +out: + return rc; } int lapb_data_received(void *token, struct sk_buff *skb) { - lapb_cb *lapb; - - if ((lapb = lapb_tokentostruct(token)) == NULL) - return LAPB_BADTOKEN; + struct lapb_cb *lapb = lapb_tokentostruct(token); + int rc = LAPB_BADTOKEN; - lapb_data_input(lapb, skb); + if (lapb) { + lapb_data_input(lapb, skb); + lapb_put(lapb); + rc = LAPB_OK; + } - return LAPB_OK; + return rc; } -void lapb_connect_confirmation(lapb_cb *lapb, int reason) +void lapb_connect_confirmation(struct lapb_cb *lapb, int reason) { - if (lapb->callbacks.connect_confirmation != NULL) - (lapb->callbacks.connect_confirmation)(lapb->token, reason); + if (lapb->callbacks.connect_confirmation) + lapb->callbacks.connect_confirmation(lapb->token, reason); } -void lapb_connect_indication(lapb_cb *lapb, int reason) +void lapb_connect_indication(struct lapb_cb *lapb, int reason) { - if (lapb->callbacks.connect_indication != NULL) - (lapb->callbacks.connect_indication)(lapb->token, reason); + if (lapb->callbacks.connect_indication) + lapb->callbacks.connect_indication(lapb->token, reason); } -void lapb_disconnect_confirmation(lapb_cb *lapb, int reason) +void lapb_disconnect_confirmation(struct lapb_cb *lapb, int reason) { - if (lapb->callbacks.disconnect_confirmation != NULL) - (lapb->callbacks.disconnect_confirmation)(lapb->token, reason); + if (lapb->callbacks.disconnect_confirmation) + lapb->callbacks.disconnect_confirmation(lapb->token, reason); } -void lapb_disconnect_indication(lapb_cb *lapb, int reason) +void lapb_disconnect_indication(struct lapb_cb *lapb, int reason) { - if (lapb->callbacks.disconnect_indication != NULL) - (lapb->callbacks.disconnect_indication)(lapb->token, reason); + if (lapb->callbacks.disconnect_indication) + lapb->callbacks.disconnect_indication(lapb->token, reason); } -int lapb_data_indication(lapb_cb *lapb, struct sk_buff *skb) +int lapb_data_indication(struct lapb_cb *lapb, struct sk_buff *skb) { - if (lapb->callbacks.data_indication != NULL) { - return (lapb->callbacks.data_indication)(lapb->token, skb); - } + if (lapb->callbacks.data_indication) + return lapb->callbacks.data_indication(lapb->token, skb); + kfree_skb(skb); return NET_RX_CN_HIGH; /* For now; must be != NET_RX_DROP */ } -int lapb_data_transmit(lapb_cb *lapb, struct sk_buff *skb) +int lapb_data_transmit(struct lapb_cb *lapb, struct sk_buff *skb) { int used = 0; - if (lapb->callbacks.data_transmit != NULL) { - (lapb->callbacks.data_transmit)(lapb->token, skb); + if (lapb->callbacks.data_transmit) { + lapb->callbacks.data_transmit(lapb->token, skb); used = 1; } diff --git a/net/lapb/lapb_in.c b/net/lapb/lapb_in.c index b44e7e19ae3e..431c6918aaf0 100644 --- a/net/lapb/lapb_in.c +++ b/net/lapb/lapb_in.c @@ -40,26 +40,33 @@ * State machine for state 0, Disconnected State. * The handling of the timer(s) is in file lapb_timer.c. */ -static void lapb_state0_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_frame *frame) +static void lapb_state0_machine(struct lapb_cb *lapb, struct sk_buff *skb, + struct lapb_frame *frame) { switch (frame->type) { case LAPB_SABM: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S0 RX SABM(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S0 RX SABM(%d)\n", + lapb->token, frame->pf); #endif if (lapb->mode & LAPB_EXTENDED) { #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S0 TX DM(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S0 TX DM(%d)\n", + lapb->token, frame->pf); #endif - lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE); + lapb_send_control(lapb, LAPB_DM, frame->pf, + LAPB_RESPONSE); } else { #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n", + lapb->token, frame->pf); #endif #if LAPB_DEBUG > 0 - printk(KERN_DEBUG "lapb: (%p) S0 -> S3\n", lapb->token); + printk(KERN_DEBUG "lapb: (%p) S0 -> S3\n", + lapb->token); #endif - lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE); + lapb_send_control(lapb, LAPB_UA, frame->pf, + LAPB_RESPONSE); lapb_stop_t1timer(lapb); lapb_stop_t2timer(lapb); lapb->state = LAPB_STATE_3; @@ -74,16 +81,20 @@ static void lapb_state0_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ case LAPB_SABME: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S0 RX SABME(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S0 RX SABME(%d)\n", + lapb->token, frame->pf); #endif if (lapb->mode & LAPB_EXTENDED) { #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n", + lapb->token, frame->pf); #endif #if LAPB_DEBUG > 0 - printk(KERN_DEBUG "lapb: (%p) S0 -> S3\n", lapb->token); + printk(KERN_DEBUG "lapb: (%p) S0 -> S3\n", + lapb->token); #endif - lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE); + lapb_send_control(lapb, LAPB_UA, frame->pf, + LAPB_RESPONSE); lapb_stop_t1timer(lapb); lapb_stop_t2timer(lapb); lapb->state = LAPB_STATE_3; @@ -95,18 +106,23 @@ static void lapb_state0_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ lapb_connect_indication(lapb, LAPB_OK); } else { #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S0 TX DM(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S0 TX DM(%d)\n", + lapb->token, frame->pf); #endif - lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE); + lapb_send_control(lapb, LAPB_DM, frame->pf, + LAPB_RESPONSE); } break; case LAPB_DISC: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S0 RX DISC(%d)\n", lapb->token, frame->pf); - printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S0 RX DISC(%d)\n", + lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n", + lapb->token, frame->pf); #endif - lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE); + lapb_send_control(lapb, LAPB_UA, frame->pf, + LAPB_RESPONSE); break; default: @@ -120,58 +136,74 @@ static void lapb_state0_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ * State machine for state 1, Awaiting Connection State. * The handling of the timer(s) is in file lapb_timer.c. */ -static void lapb_state1_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_frame *frame) +static void lapb_state1_machine(struct lapb_cb *lapb, struct sk_buff *skb, + struct lapb_frame *frame) { switch (frame->type) { case LAPB_SABM: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S1 RX SABM(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S1 RX SABM(%d)\n", + lapb->token, frame->pf); #endif if (lapb->mode & LAPB_EXTENDED) { #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n", + lapb->token, frame->pf); #endif - lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE); + lapb_send_control(lapb, LAPB_DM, frame->pf, + LAPB_RESPONSE); } else { #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S1 TX UA(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S1 TX UA(%d)\n", + lapb->token, frame->pf); #endif - lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE); + lapb_send_control(lapb, LAPB_UA, frame->pf, + LAPB_RESPONSE); } break; case LAPB_SABME: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S1 RX SABME(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S1 RX SABME(%d)\n", + lapb->token, frame->pf); #endif if (lapb->mode & LAPB_EXTENDED) { #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S1 TX UA(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S1 TX UA(%d)\n", + lapb->token, frame->pf); #endif - lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE); + lapb_send_control(lapb, LAPB_UA, frame->pf, + LAPB_RESPONSE); } else { #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n", + lapb->token, frame->pf); #endif - lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE); + lapb_send_control(lapb, LAPB_DM, frame->pf, + LAPB_RESPONSE); } break; case LAPB_DISC: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S1 RX DISC(%d)\n", lapb->token, frame->pf); - printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S1 RX DISC(%d)\n", + lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n", + lapb->token, frame->pf); #endif - lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE); + lapb_send_control(lapb, LAPB_DM, frame->pf, + LAPB_RESPONSE); break; case LAPB_UA: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S1 RX UA(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S1 RX UA(%d)\n", + lapb->token, frame->pf); #endif if (frame->pf) { #if LAPB_DEBUG > 0 - printk(KERN_DEBUG "lapb: (%p) S1 -> S3\n", lapb->token); + printk(KERN_DEBUG "lapb: (%p) S1 -> S3\n", + lapb->token); #endif lapb_stop_t1timer(lapb); lapb_stop_t2timer(lapb); @@ -187,11 +219,13 @@ static void lapb_state1_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ case LAPB_DM: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S1 RX DM(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S1 RX DM(%d)\n", + lapb->token, frame->pf); #endif if (frame->pf) { #if LAPB_DEBUG > 0 - printk(KERN_DEBUG "lapb: (%p) S1 -> S0\n", lapb->token); + printk(KERN_DEBUG "lapb: (%p) S1 -> S0\n", + lapb->token); #endif lapb_clear_queues(lapb); lapb->state = LAPB_STATE_0; @@ -200,9 +234,6 @@ static void lapb_state1_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ lapb_disconnect_indication(lapb, LAPB_REFUSED); } break; - - default: - break; } kfree_skb(skb); @@ -212,33 +243,42 @@ static void lapb_state1_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ * State machine for state 2, Awaiting Release State. * The handling of the timer(s) is in file lapb_timer.c */ -static void lapb_state2_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_frame *frame) +static void lapb_state2_machine(struct lapb_cb *lapb, struct sk_buff *skb, + struct lapb_frame *frame) { switch (frame->type) { case LAPB_SABM: case LAPB_SABME: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S2 RX {SABM,SABME}(%d)\n", lapb->token, frame->pf); - printk(KERN_DEBUG "lapb: (%p) S2 TX DM(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S2 RX {SABM,SABME}(%d)\n", + lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S2 TX DM(%d)\n", + lapb->token, frame->pf); #endif - lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE); + lapb_send_control(lapb, LAPB_DM, frame->pf, + LAPB_RESPONSE); break; case LAPB_DISC: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S2 RX DISC(%d)\n", lapb->token, frame->pf); - printk(KERN_DEBUG "lapb: (%p) S2 TX UA(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S2 RX DISC(%d)\n", + lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S2 TX UA(%d)\n", + lapb->token, frame->pf); #endif - lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE); + lapb_send_control(lapb, LAPB_UA, frame->pf, + LAPB_RESPONSE); break; case LAPB_UA: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S2 RX UA(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S2 RX UA(%d)\n", + lapb->token, frame->pf); #endif if (frame->pf) { #if LAPB_DEBUG > 0 - printk(KERN_DEBUG "lapb: (%p) S2 -> S0\n", lapb->token); + printk(KERN_DEBUG "lapb: (%p) S2 -> S0\n", + lapb->token); #endif lapb->state = LAPB_STATE_0; lapb_start_t1timer(lapb); @@ -249,16 +289,19 @@ static void lapb_state2_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ case LAPB_DM: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S2 RX DM(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S2 RX DM(%d)\n", + lapb->token, frame->pf); #endif if (frame->pf) { #if LAPB_DEBUG > 0 - printk(KERN_DEBUG "lapb: (%p) S2 -> S0\n", lapb->token); + printk(KERN_DEBUG "lapb: (%p) S2 -> S0\n", + lapb->token); #endif lapb->state = LAPB_STATE_0; lapb_start_t1timer(lapb); lapb_stop_t2timer(lapb); - lapb_disconnect_confirmation(lapb, LAPB_NOTCONNECTED); + lapb_disconnect_confirmation(lapb, + LAPB_NOTCONNECTED); } break; @@ -267,13 +310,14 @@ static void lapb_state2_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ case LAPB_RNR: case LAPB_RR: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S2 RX {I,REJ,RNR,RR}(%d)\n", lapb->token, frame->pf); - printk(KERN_DEBUG "lapb: (%p) S2 RX DM(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S2 RX {I,REJ,RNR,RR}" + "(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S2 RX DM(%d)\n", + lapb->token, frame->pf); #endif - if (frame->pf) lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE); - break; - - default: + if (frame->pf) + lapb_send_control(lapb, LAPB_DM, frame->pf, + LAPB_RESPONSE); break; } @@ -284,28 +328,33 @@ static void lapb_state2_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ * State machine for state 3, Connected State. * The handling of the timer(s) is in file lapb_timer.c */ -static void lapb_state3_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_frame *frame) +static void lapb_state3_machine(struct lapb_cb *lapb, struct sk_buff *skb, + struct lapb_frame *frame) { int queued = 0; - int modulus; - - modulus = (lapb->mode & LAPB_EXTENDED) ? LAPB_EMODULUS : LAPB_SMODULUS; + int modulus = (lapb->mode & LAPB_EXTENDED) ? LAPB_EMODULUS : + LAPB_SMODULUS; switch (frame->type) { case LAPB_SABM: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S3 RX SABM(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S3 RX SABM(%d)\n", + lapb->token, frame->pf); #endif if (lapb->mode & LAPB_EXTENDED) { #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S3 TX DM(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S3 TX DM(%d)\n", + lapb->token, frame->pf); #endif - lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE); + lapb_send_control(lapb, LAPB_DM, frame->pf, + LAPB_RESPONSE); } else { #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S3 TX UA(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S3 TX UA(%d)\n", + lapb->token, frame->pf); #endif - lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE); + lapb_send_control(lapb, LAPB_UA, frame->pf, + LAPB_RESPONSE); lapb_stop_t1timer(lapb); lapb_stop_t2timer(lapb); lapb->condition = 0x00; @@ -319,13 +368,16 @@ static void lapb_state3_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ case LAPB_SABME: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S3 RX SABME(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S3 RX SABME(%d)\n", + lapb->token, frame->pf); #endif if (lapb->mode & LAPB_EXTENDED) { #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S3 TX UA(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S3 TX UA(%d)\n", + lapb->token, frame->pf); #endif - lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE); + lapb_send_control(lapb, LAPB_UA, frame->pf, + LAPB_RESPONSE); lapb_stop_t1timer(lapb); lapb_stop_t2timer(lapb); lapb->condition = 0x00; @@ -336,21 +388,26 @@ static void lapb_state3_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ lapb_requeue_frames(lapb); } else { #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S3 TX DM(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S3 TX DM(%d)\n", + lapb->token, frame->pf); #endif - lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE); + lapb_send_control(lapb, LAPB_DM, frame->pf, + LAPB_RESPONSE); } break; case LAPB_DISC: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S3 RX DISC(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S3 RX DISC(%d)\n", + lapb->token, frame->pf); #endif #if LAPB_DEBUG > 0 - printk(KERN_DEBUG "lapb: (%p) S3 -> S0\n", lapb->token); + printk(KERN_DEBUG "lapb: (%p) S3 -> S0\n", + lapb->token); #endif lapb_clear_queues(lapb); - lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE); + lapb_send_control(lapb, LAPB_UA, frame->pf, + LAPB_RESPONSE); lapb_start_t1timer(lapb); lapb_stop_t2timer(lapb); lapb->state = LAPB_STATE_0; @@ -359,10 +416,12 @@ static void lapb_state3_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ case LAPB_DM: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S3 RX DM(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S3 RX DM(%d)\n", + lapb->token, frame->pf); #endif #if LAPB_DEBUG > 0 - printk(KERN_DEBUG "lapb: (%p) S3 -> S0\n", lapb->token); + printk(KERN_DEBUG "lapb: (%p) S3 -> S0\n", + lapb->token); #endif lapb_clear_queues(lapb); lapb->state = LAPB_STATE_0; @@ -373,7 +432,8 @@ static void lapb_state3_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ case LAPB_RNR: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S3 RX RNR(%d) R%d\n", lapb->token, frame->pf, frame->nr); + printk(KERN_DEBUG "lapb: (%p) S3 RX RNR(%d) R%d\n", + lapb->token, frame->pf, frame->nr); #endif lapb->condition |= LAPB_PEER_RX_BUSY_CONDITION; lapb_check_need_response(lapb, frame->cr, frame->pf); @@ -384,7 +444,8 @@ static void lapb_state3_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ lapb->frmr_type = LAPB_FRMR_Z; lapb_transmit_frmr(lapb); #if LAPB_DEBUG > 0 - printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->token); + printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", + lapb->token); #endif lapb_start_t1timer(lapb); lapb_stop_t2timer(lapb); @@ -395,7 +456,8 @@ static void lapb_state3_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ case LAPB_RR: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S3 RX RR(%d) R%d\n", lapb->token, frame->pf, frame->nr); + printk(KERN_DEBUG "lapb: (%p) S3 RX RR(%d) R%d\n", + lapb->token, frame->pf, frame->nr); #endif lapb->condition &= ~LAPB_PEER_RX_BUSY_CONDITION; lapb_check_need_response(lapb, frame->cr, frame->pf); @@ -406,7 +468,8 @@ static void lapb_state3_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ lapb->frmr_type = LAPB_FRMR_Z; lapb_transmit_frmr(lapb); #if LAPB_DEBUG > 0 - printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->token); + printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", + lapb->token); #endif lapb_start_t1timer(lapb); lapb_stop_t2timer(lapb); @@ -417,7 +480,8 @@ static void lapb_state3_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ case LAPB_REJ: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S3 RX REJ(%d) R%d\n", lapb->token, frame->pf, frame->nr); + printk(KERN_DEBUG "lapb: (%p) S3 RX REJ(%d) R%d\n", + lapb->token, frame->pf, frame->nr); #endif lapb->condition &= ~LAPB_PEER_RX_BUSY_CONDITION; lapb_check_need_response(lapb, frame->cr, frame->pf); @@ -431,7 +495,8 @@ static void lapb_state3_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ lapb->frmr_type = LAPB_FRMR_Z; lapb_transmit_frmr(lapb); #if LAPB_DEBUG > 0 - printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->token); + printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", + lapb->token); #endif lapb_start_t1timer(lapb); lapb_stop_t2timer(lapb); @@ -442,14 +507,16 @@ static void lapb_state3_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ case LAPB_I: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S3 RX I(%d) S%d R%d\n", lapb->token, frame->pf, frame->ns, frame->nr); + printk(KERN_DEBUG "lapb: (%p) S3 RX I(%d) S%d R%d\n", + lapb->token, frame->pf, frame->ns, frame->nr); #endif if (!lapb_validate_nr(lapb, frame->nr)) { lapb->frmr_data = *frame; lapb->frmr_type = LAPB_FRMR_Z; lapb_transmit_frmr(lapb); #if LAPB_DEBUG > 0 - printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->token); + printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", + lapb->token); #endif lapb_start_t1timer(lapb); lapb_stop_t2timer(lapb); @@ -457,11 +524,11 @@ static void lapb_state3_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ lapb->n2count = 0; break; } - if (lapb->condition & LAPB_PEER_RX_BUSY_CONDITION) { + if (lapb->condition & LAPB_PEER_RX_BUSY_CONDITION) lapb_frames_acked(lapb, frame->nr); - } else { + else lapb_check_iframes_acked(lapb, frame->nr); - } + if (frame->ns == lapb->vr) { int cn; cn = lapb_data_indication(lapb, skb); @@ -473,16 +540,18 @@ static void lapb_state3_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ * to re-transmit the frame later like * a frame lost on the wire. */ - if(cn == NET_RX_DROP){ - printk(KERN_DEBUG "LAPB: rx congestion\n"); + if (cn == NET_RX_DROP) { + printk(KERN_DEBUG + "LAPB: rx congestion\n"); break; } lapb->vr = (lapb->vr + 1) % modulus; lapb->condition &= ~LAPB_REJECT_CONDITION; - if (frame->pf) { + if (frame->pf) lapb_enquiry_response(lapb); - } else { - if (!(lapb->condition & LAPB_ACK_PENDING_CONDITION)) { + else { + if (!(lapb->condition & + LAPB_ACK_PENDING_CONDITION)) { lapb->condition |= LAPB_ACK_PENDING_CONDITION; lapb_start_t2timer(lapb); } @@ -493,10 +562,14 @@ static void lapb_state3_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ lapb_enquiry_response(lapb); } else { #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S3 TX REJ(%d) R%d\n", lapb->token, frame->pf, lapb->vr); + printk(KERN_DEBUG + "lapb: (%p) S3 TX REJ(%d) R%d\n", + lapb->token, frame->pf, lapb->vr); #endif lapb->condition |= LAPB_REJECT_CONDITION; - lapb_send_control(lapb, LAPB_REJ, frame->pf, LAPB_RESPONSE); + lapb_send_control(lapb, LAPB_REJ, + frame->pf, + LAPB_RESPONSE); lapb->condition &= ~LAPB_ACK_PENDING_CONDITION; } } @@ -504,11 +577,15 @@ static void lapb_state3_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ case LAPB_FRMR: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S3 RX FRMR(%d) %02X %02X %02X %02X %02X\n", lapb->token, frame->pf, skb->data[0], skb->data[1], skb->data[2], skb->data[3], skb->data[4]); + printk(KERN_DEBUG "lapb: (%p) S3 RX FRMR(%d) %02X " + "%02X %02X %02X %02X\n", lapb->token, frame->pf, + skb->data[0], skb->data[1], skb->data[2], + skb->data[3], skb->data[4]); #endif lapb_establish_data_link(lapb); #if LAPB_DEBUG > 0 - printk(KERN_DEBUG "lapb: (%p) S3 -> S1\n", lapb->token); + printk(KERN_DEBUG "lapb: (%p) S3 -> S1\n", + lapb->token); #endif lapb_requeue_frames(lapb); lapb->state = LAPB_STATE_1; @@ -516,7 +593,8 @@ static void lapb_state3_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ case LAPB_ILLEGAL: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S3 RX ILLEGAL(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S3 RX ILLEGAL(%d)\n", + lapb->token, frame->pf); #endif lapb->frmr_data = *frame; lapb->frmr_type = LAPB_FRMR_W; @@ -529,9 +607,6 @@ static void lapb_state3_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ lapb->state = LAPB_STATE_4; lapb->n2count = 0; break; - - default: - break; } if (!queued) @@ -542,26 +617,33 @@ static void lapb_state3_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ * State machine for state 4, Frame Reject State. * The handling of the timer(s) is in file lapb_timer.c. */ -static void lapb_state4_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_frame *frame) +static void lapb_state4_machine(struct lapb_cb *lapb, struct sk_buff *skb, + struct lapb_frame *frame) { switch (frame->type) { case LAPB_SABM: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S4 RX SABM(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S4 RX SABM(%d)\n", + lapb->token, frame->pf); #endif if (lapb->mode & LAPB_EXTENDED) { #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S4 TX DM(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S4 TX DM(%d)\n", + lapb->token, frame->pf); #endif - lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE); + lapb_send_control(lapb, LAPB_DM, frame->pf, + LAPB_RESPONSE); } else { #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S4 TX UA(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S4 TX UA(%d)\n", + lapb->token, frame->pf); #endif #if LAPB_DEBUG > 0 - printk(KERN_DEBUG "lapb: (%p) S4 -> S3\n", lapb->token); + printk(KERN_DEBUG "lapb: (%p) S4 -> S3\n", + lapb->token); #endif - lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE); + lapb_send_control(lapb, LAPB_UA, frame->pf, + LAPB_RESPONSE); lapb_stop_t1timer(lapb); lapb_stop_t2timer(lapb); lapb->state = LAPB_STATE_3; @@ -576,16 +658,20 @@ static void lapb_state4_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ case LAPB_SABME: #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S4 RX SABME(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S4 RX SABME(%d)\n", + lapb->token, frame->pf); #endif if (lapb->mode & LAPB_EXTENDED) { #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S4 TX UA(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S4 TX UA(%d)\n", + lapb->token, frame->pf); #endif #if LAPB_DEBUG > 0 - printk(KERN_DEBUG "lapb: (%p) S4 -> S3\n", lapb->token); + printk(KERN_DEBUG "lapb: (%p) S4 -> S3\n", + lapb->token); #endif - lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE); + lapb_send_control(lapb, LAPB_UA, frame->pf, + LAPB_RESPONSE); lapb_stop_t1timer(lapb); lapb_stop_t2timer(lapb); lapb->state = LAPB_STATE_3; @@ -597,14 +683,13 @@ static void lapb_state4_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ lapb_connect_indication(lapb, LAPB_OK); } else { #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S4 TX DM(%d)\n", lapb->token, frame->pf); + printk(KERN_DEBUG "lapb: (%p) S4 TX DM(%d)\n", + lapb->token, frame->pf); #endif - lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE); + lapb_send_control(lapb, LAPB_DM, frame->pf, + LAPB_RESPONSE); } break; - - default: - break; } kfree_skb(skb); @@ -613,28 +698,23 @@ static void lapb_state4_machine(lapb_cb *lapb, struct sk_buff *skb, struct lapb_ /* * Process an incoming LAPB frame */ -void lapb_data_input(lapb_cb *lapb, struct sk_buff *skb) +void lapb_data_input(struct lapb_cb *lapb, struct sk_buff *skb) { struct lapb_frame frame; lapb_decode(lapb, skb, &frame); switch (lapb->state) { - case LAPB_STATE_0: - lapb_state0_machine(lapb, skb, &frame); - break; - case LAPB_STATE_1: - lapb_state1_machine(lapb, skb, &frame); - break; - case LAPB_STATE_2: - lapb_state2_machine(lapb, skb, &frame); - break; - case LAPB_STATE_3: - lapb_state3_machine(lapb, skb, &frame); - break; - case LAPB_STATE_4: - lapb_state4_machine(lapb, skb, &frame); - break; + case LAPB_STATE_0: + lapb_state0_machine(lapb, skb, &frame); break; + case LAPB_STATE_1: + lapb_state1_machine(lapb, skb, &frame); break; + case LAPB_STATE_2: + lapb_state2_machine(lapb, skb, &frame); break; + case LAPB_STATE_3: + lapb_state3_machine(lapb, skb, &frame); break; + case LAPB_STATE_4: + lapb_state4_machine(lapb, skb, &frame); break; } lapb_kick(lapb); diff --git a/net/lapb/lapb_out.c b/net/lapb/lapb_out.c index c3fcc2f52d01..5ecaa8b66568 100644 --- a/net/lapb/lapb_out.c +++ b/net/lapb/lapb_out.c @@ -38,56 +38,54 @@ * This procedure is passed a buffer descriptor for an iframe. It builds * the rest of the control part of the frame and then writes it out. */ -static void lapb_send_iframe(lapb_cb *lapb, struct sk_buff *skb, int poll_bit) +static void lapb_send_iframe(struct lapb_cb *lapb, struct sk_buff *skb, int poll_bit) { unsigned char *frame; - if (skb == NULL) + if (!skb) return; if (lapb->mode & LAPB_EXTENDED) { frame = skb_push(skb, 2); frame[0] = LAPB_I; - frame[0] |= (lapb->vs << 1); - frame[1] = (poll_bit) ? LAPB_EPF : 0; - frame[1] |= (lapb->vr << 1); + frame[0] |= lapb->vs << 1; + frame[1] = poll_bit ? LAPB_EPF : 0; + frame[1] |= lapb->vr << 1; } else { frame = skb_push(skb, 1); *frame = LAPB_I; - *frame |= (poll_bit) ? LAPB_SPF : 0; - *frame |= (lapb->vr << 5); - *frame |= (lapb->vs << 1); + *frame |= poll_bit ? LAPB_SPF : 0; + *frame |= lapb->vr << 5; + *frame |= lapb->vs << 1; } #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S%d TX I(%d) S%d R%d\n", lapb->token, lapb->state, poll_bit, lapb->vs, lapb->vr); + printk(KERN_DEBUG "lapb: (%p) S%d TX I(%d) S%d R%d\n", + lapb->token, lapb->state, poll_bit, lapb->vs, lapb->vr); #endif lapb_transmit_buffer(lapb, skb, LAPB_COMMAND); } -void lapb_kick(lapb_cb *lapb) +void lapb_kick(struct lapb_cb *lapb) { struct sk_buff *skb, *skbn; unsigned short modulus, start, end; modulus = (lapb->mode & LAPB_EXTENDED) ? LAPB_EMODULUS : LAPB_SMODULUS; - - start = (skb_peek(&lapb->ack_queue) == NULL) ? lapb->va : lapb->vs; + start = !skb_peek(&lapb->ack_queue) ? lapb->va : lapb->vs; end = (lapb->va + lapb->window) % modulus; if (!(lapb->condition & LAPB_PEER_RX_BUSY_CONDITION) && - start != end && - skb_peek(&lapb->write_queue) != NULL) { - + start != end && skb_peek(&lapb->write_queue)) { lapb->vs = start; /* * Dequeue the frame and copy it. */ - skb = skb_dequeue(&lapb->write_queue); + skb = skb_dequeue(&lapb->write_queue); do { if ((skbn = skb_clone(skb, GFP_ATOMIC)) == NULL) { @@ -95,7 +93,7 @@ void lapb_kick(lapb_cb *lapb) break; } - if (skb->sk != NULL) + if (skb->sk) skb_set_owner_w(skbn, skb->sk); /* @@ -119,7 +117,7 @@ void lapb_kick(lapb_cb *lapb) } } -void lapb_transmit_buffer(lapb_cb *lapb, struct sk_buff *skb, int type) +void lapb_transmit_buffer(struct lapb_cb *lapb, struct sk_buff *skb, int type) { unsigned char *ptr; @@ -152,26 +150,30 @@ void lapb_transmit_buffer(lapb_cb *lapb, struct sk_buff *skb, int type) } #if LAPB_DEBUG > 2 - printk(KERN_DEBUG "lapb: (%p) S%d TX %02X %02X %02X\n", lapb->token, lapb->state, skb->data[0], skb->data[1], skb->data[2]); + printk(KERN_DEBUG "lapb: (%p) S%d TX %02X %02X %02X\n", + lapb->token, lapb->state, + skb->data[0], skb->data[1], skb->data[2]); #endif if (!lapb_data_transmit(lapb, skb)) kfree_skb(skb); } -void lapb_establish_data_link(lapb_cb *lapb) +void lapb_establish_data_link(struct lapb_cb *lapb) { lapb->condition = 0x00; lapb->n2count = 0; if (lapb->mode & LAPB_EXTENDED) { #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S%d TX SABME(1)\n", lapb->token, lapb->state); + printk(KERN_DEBUG "lapb: (%p) S%d TX SABME(1)\n", + lapb->token, lapb->state); #endif lapb_send_control(lapb, LAPB_SABME, LAPB_POLLON, LAPB_COMMAND); } else { #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S%d TX SABM(1)\n", lapb->token, lapb->state); + printk(KERN_DEBUG "lapb: (%p) S%d TX SABM(1)\n", + lapb->token, lapb->state); #endif lapb_send_control(lapb, LAPB_SABM, LAPB_POLLON, LAPB_COMMAND); } @@ -180,10 +182,11 @@ void lapb_establish_data_link(lapb_cb *lapb) lapb_stop_t2timer(lapb); } -void lapb_enquiry_response(lapb_cb *lapb) +void lapb_enquiry_response(struct lapb_cb *lapb) { #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S%d TX RR(1) R%d\n", lapb->token, lapb->state, lapb->vr); + printk(KERN_DEBUG "lapb: (%p) S%d TX RR(1) R%d\n", + lapb->token, lapb->state, lapb->vr); #endif lapb_send_control(lapb, LAPB_RR, LAPB_POLLON, LAPB_RESPONSE); @@ -191,32 +194,30 @@ void lapb_enquiry_response(lapb_cb *lapb) lapb->condition &= ~LAPB_ACK_PENDING_CONDITION; } -void lapb_timeout_response(lapb_cb *lapb) +void lapb_timeout_response(struct lapb_cb *lapb) { #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S%d TX RR(0) R%d\n", lapb->token, lapb->state, lapb->vr); + printk(KERN_DEBUG "lapb: (%p) S%d TX RR(0) R%d\n", + lapb->token, lapb->state, lapb->vr); #endif - lapb_send_control(lapb, LAPB_RR, LAPB_POLLOFF, LAPB_RESPONSE); lapb->condition &= ~LAPB_ACK_PENDING_CONDITION; } -void lapb_check_iframes_acked(lapb_cb *lapb, unsigned short nr) +void lapb_check_iframes_acked(struct lapb_cb *lapb, unsigned short nr) { if (lapb->vs == nr) { lapb_frames_acked(lapb, nr); lapb_stop_t1timer(lapb); lapb->n2count = 0; - } else { - if (lapb->va != nr) { - lapb_frames_acked(lapb, nr); - lapb_start_t1timer(lapb); - } + } else if (lapb->va != nr) { + lapb_frames_acked(lapb, nr); + lapb_start_t1timer(lapb); } } -void lapb_check_need_response(lapb_cb *lapb, int type, int pf) +void lapb_check_need_response(struct lapb_cb *lapb, int type, int pf) { if (type == LAPB_COMMAND && pf) lapb_enquiry_response(lapb); diff --git a/net/lapb/lapb_subr.c b/net/lapb/lapb_subr.c index 439a6dd8a8b8..36e1769330e4 100644 --- a/net/lapb/lapb_subr.c +++ b/net/lapb/lapb_subr.c @@ -36,7 +36,7 @@ /* * This routine purges all the queues of frames. */ -void lapb_clear_queues(lapb_cb *lapb) +void lapb_clear_queues(struct lapb_cb *lapb) { skb_queue_purge(&lapb->write_queue); skb_queue_purge(&lapb->ack_queue); @@ -47,7 +47,7 @@ void lapb_clear_queues(lapb_cb *lapb) * acknowledged. This replaces the boxes labelled "V(a) <- N(r)" on the * SDL diagram. */ -void lapb_frames_acked(lapb_cb *lapb, unsigned short nr) +void lapb_frames_acked(struct lapb_cb *lapb, unsigned short nr) { struct sk_buff *skb; int modulus; @@ -57,16 +57,15 @@ void lapb_frames_acked(lapb_cb *lapb, unsigned short nr) /* * Remove all the ack-ed frames from the ack queue. */ - if (lapb->va != nr) { - while (skb_peek(&lapb->ack_queue) != NULL && lapb->va != nr) { + if (lapb->va != nr) + while (skb_peek(&lapb->ack_queue) && lapb->va != nr) { skb = skb_dequeue(&lapb->ack_queue); kfree_skb(skb); lapb->va = (lapb->va + 1) % modulus; } - } } -void lapb_requeue_frames(lapb_cb *lapb) +void lapb_requeue_frames(struct lapb_cb *lapb) { struct sk_buff *skb, *skb_prev = NULL; @@ -76,7 +75,7 @@ void lapb_requeue_frames(lapb_cb *lapb) * possibility of an empty output queue. */ while ((skb = skb_dequeue(&lapb->ack_queue)) != NULL) { - if (skb_prev == NULL) + if (!skb_prev) skb_queue_head(&lapb->write_queue, skb); else skb_append(skb_prev, skb); @@ -88,7 +87,7 @@ void lapb_requeue_frames(lapb_cb *lapb) * Validate that the value of nr is between va and vs. Return true or * false for testing. */ -int lapb_validate_nr(lapb_cb *lapb, unsigned short nr) +int lapb_validate_nr(struct lapb_cb *lapb, unsigned short nr) { unsigned short vc = lapb->va; int modulus; @@ -96,25 +95,27 @@ int lapb_validate_nr(lapb_cb *lapb, unsigned short nr) modulus = (lapb->mode & LAPB_EXTENDED) ? LAPB_EMODULUS : LAPB_SMODULUS; while (vc != lapb->vs) { - if (nr == vc) return 1; + if (nr == vc) + return 1; vc = (vc + 1) % modulus; } - if (nr == lapb->vs) return 1; - - return 0; + return nr == lapb->vs; } /* * This routine is the centralised routine for parsing the control * information for the different frame formats. */ -void lapb_decode(lapb_cb *lapb, struct sk_buff *skb, struct lapb_frame *frame) +void lapb_decode(struct lapb_cb *lapb, struct sk_buff *skb, + struct lapb_frame *frame) { frame->type = LAPB_ILLEGAL; #if LAPB_DEBUG > 2 - printk(KERN_DEBUG "lapb: (%p) S%d RX %02X %02X %02X\n", lapb->token, lapb->state, skb->data[0], skb->data[1], skb->data[2]); + printk(KERN_DEBUG "lapb: (%p) S%d RX %02X %02X %02X\n", + lapb->token, lapb->state, + skb->data[0], skb->data[1], skb->data[2]); #endif if (lapb->mode & LAPB_MLP) { @@ -146,22 +147,31 @@ void lapb_decode(lapb_cb *lapb, struct sk_buff *skb, struct lapb_frame *frame) skb_pull(skb, 1); if (lapb->mode & LAPB_EXTENDED) { - if ((skb->data[0] & LAPB_S) == 0) { - frame->type = LAPB_I; /* I frame - carries NR/NS/PF */ + if (!(skb->data[0] & LAPB_S)) { + /* + * I frame - carries NR/NS/PF + */ + frame->type = LAPB_I; frame->ns = (skb->data[0] >> 1) & 0x7F; frame->nr = (skb->data[1] >> 1) & 0x7F; frame->pf = skb->data[1] & LAPB_EPF; frame->control[0] = skb->data[0]; frame->control[1] = skb->data[1]; skb_pull(skb, 2); - } else if ((skb->data[0] & LAPB_U) == 1) { /* S frame - take out PF/NR */ + } else if ((skb->data[0] & LAPB_U) == 1) { + /* + * S frame - take out PF/NR + */ frame->type = skb->data[0] & 0x0F; frame->nr = (skb->data[1] >> 1) & 0x7F; frame->pf = skb->data[1] & LAPB_EPF; frame->control[0] = skb->data[0]; frame->control[1] = skb->data[1]; skb_pull(skb, 2); - } else if ((skb->data[0] & LAPB_U) == 3) { /* U frame - take out PF */ + } else if ((skb->data[0] & LAPB_U) == 3) { + /* + * U frame - take out PF + */ frame->type = skb->data[0] & ~LAPB_SPF; frame->pf = skb->data[0] & LAPB_SPF; frame->control[0] = skb->data[0]; @@ -169,16 +179,25 @@ void lapb_decode(lapb_cb *lapb, struct sk_buff *skb, struct lapb_frame *frame) skb_pull(skb, 1); } } else { - if ((skb->data[0] & LAPB_S) == 0) { - frame->type = LAPB_I; /* I frame - carries NR/NS/PF */ + if (!(skb->data[0] & LAPB_S)) { + /* + * I frame - carries NR/NS/PF + */ + frame->type = LAPB_I; frame->ns = (skb->data[0] >> 1) & 0x07; frame->nr = (skb->data[0] >> 5) & 0x07; frame->pf = skb->data[0] & LAPB_SPF; - } else if ((skb->data[0] & LAPB_U) == 1) { /* S frame - take out PF/NR */ + } else if ((skb->data[0] & LAPB_U) == 1) { + /* + * S frame - take out PF/NR + */ frame->type = skb->data[0] & 0x0F; frame->nr = (skb->data[0] >> 5) & 0x07; frame->pf = skb->data[0] & LAPB_SPF; - } else if ((skb->data[0] & LAPB_U) == 3) { /* U frame - take out PF */ + } else if ((skb->data[0] & LAPB_U) == 3) { + /* + * U frame - take out PF + */ frame->type = skb->data[0] & ~LAPB_SPF; frame->pf = skb->data[0] & LAPB_SPF; } @@ -195,7 +214,8 @@ void lapb_decode(lapb_cb *lapb, struct sk_buff *skb, struct lapb_frame *frame) * Only supervisory or unnumbered frames are processed, FRMRs are handled * by lapb_transmit_frmr below. */ -void lapb_send_control(lapb_cb *lapb, int frametype, int poll_bit, int type) +void lapb_send_control(struct lapb_cb *lapb, int frametype, + int poll_bit, int type) { struct sk_buff *skb; unsigned char *dptr; @@ -209,18 +229,18 @@ void lapb_send_control(lapb_cb *lapb, int frametype, int poll_bit, int type) if ((frametype & LAPB_U) == LAPB_U) { dptr = skb_put(skb, 1); *dptr = frametype; - *dptr |= (poll_bit) ? LAPB_SPF : 0; + *dptr |= poll_bit ? LAPB_SPF : 0; } else { dptr = skb_put(skb, 2); dptr[0] = frametype; dptr[1] = (lapb->vr << 1); - dptr[1] |= (poll_bit) ? LAPB_EPF : 0; + dptr[1] |= poll_bit ? LAPB_EPF : 0; } } else { dptr = skb_put(skb, 1); *dptr = frametype; - *dptr |= (poll_bit) ? LAPB_SPF : 0; - if ((frametype & LAPB_U) == LAPB_S) /* S frames carry NR */ + *dptr |= poll_bit ? LAPB_SPF : 0; + if ((frametype & LAPB_U) == LAPB_S) /* S frames carry NR */ *dptr |= (lapb->vr << 5); } @@ -231,7 +251,7 @@ void lapb_send_control(lapb_cb *lapb, int frametype, int poll_bit, int type) * This routine generates FRMRs based on information previously stored in * the LAPB control block. */ -void lapb_transmit_frmr(lapb_cb *lapb) +void lapb_transmit_frmr(struct lapb_cb *lapb) { struct sk_buff *skb; unsigned char *dptr; @@ -254,7 +274,10 @@ void lapb_transmit_frmr(lapb_cb *lapb) *dptr++ = lapb->frmr_type; #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S%d TX FRMR %02X %02X %02X %02X %02X\n", lapb->token, lapb->state, skb->data[1], skb->data[2], skb->data[3], skb->data[4], skb->data[5]); + printk(KERN_DEBUG "lapb: (%p) S%d TX FRMR %02X %02X %02X %02X %02X\n", + lapb->token, lapb->state, + skb->data[1], skb->data[2], skb->data[3], + skb->data[4], skb->data[5]); #endif } else { dptr = skb_put(skb, 4); @@ -268,7 +291,9 @@ void lapb_transmit_frmr(lapb_cb *lapb) *dptr++ = lapb->frmr_type; #if LAPB_DEBUG > 1 - printk(KERN_DEBUG "lapb: (%p) S%d TX FRMR %02X %02X %02X\n", lapb->token, lapb->state, skb->data[1], skb->data[2], skb->data[3]); + printk(KERN_DEBUG "lapb: (%p) S%d TX FRMR %02X %02X %02X\n", + lapb->token, lapb->state, skb->data[1], + skb->data[2], skb->data[3]); #endif } diff --git a/net/lapb/lapb_timer.c b/net/lapb/lapb_timer.c index a010ac9d63fc..73b75f2e03de 100644 --- a/net/lapb/lapb_timer.c +++ b/net/lapb/lapb_timer.c @@ -37,7 +37,7 @@ static void lapb_t1timer_expiry(unsigned long); static void lapb_t2timer_expiry(unsigned long); -void lapb_start_t1timer(lapb_cb *lapb) +void lapb_start_t1timer(struct lapb_cb *lapb) { del_timer(&lapb->t1timer); @@ -48,7 +48,7 @@ void lapb_start_t1timer(lapb_cb *lapb) add_timer(&lapb->t1timer); } -void lapb_start_t2timer(lapb_cb *lapb) +void lapb_start_t2timer(struct lapb_cb *lapb) { del_timer(&lapb->t2timer); @@ -59,24 +59,24 @@ void lapb_start_t2timer(lapb_cb *lapb) add_timer(&lapb->t2timer); } -void lapb_stop_t1timer(lapb_cb *lapb) +void lapb_stop_t1timer(struct lapb_cb *lapb) { del_timer(&lapb->t1timer); } -void lapb_stop_t2timer(lapb_cb *lapb) +void lapb_stop_t2timer(struct lapb_cb *lapb) { del_timer(&lapb->t2timer); } -int lapb_t1timer_running(lapb_cb *lapb) +int lapb_t1timer_running(struct lapb_cb *lapb) { return timer_pending(&lapb->t1timer); } static void lapb_t2timer_expiry(unsigned long param) { - lapb_cb *lapb = (lapb_cb *)param; + struct lapb_cb *lapb = (struct lapb_cb *)param; if (lapb->condition & LAPB_ACK_PENDING_CONDITION) { lapb->condition &= ~LAPB_ACK_PENDING_CONDITION; @@ -86,7 +86,7 @@ static void lapb_t2timer_expiry(unsigned long param) static void lapb_t1timer_expiry(unsigned long param) { - lapb_cb *lapb = (lapb_cb *)param; + struct lapb_cb *lapb = (struct lapb_cb *)param; switch (lapb->state) { -- cgit v1.2.3