Merge branch 'merge'

7 files changed, 26 insertions, 31 deletions

diff --git a/net/ax25/af_ax25.c b/net/ax25/af_ax25.c
index 10a3c0aa8398..000695c48583 100644
--- a/net/ax25/af_ax25.c
+++ b/net/ax25/af_ax25.c
@@ -145,7 +145,7 @@ struct sock *ax25_find_listener(ax25_address *addr, int digi,
         ax25_cb *s;
         struct hlist_node *node;
 
-        spin_lock_bh(&ax25_list_lock);
+        spin_lock(&ax25_list_lock);
         ax25_for_each(s, node, &ax25_list) {
                 if ((s->iamdigi && !digi) || (!s->iamdigi && digi))
                         continue;
@@ -154,12 +154,12 @@ struct sock *ax25_find_listener(ax25_address *addr, int digi,
                         /* If device is null we match any device */
                         if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) {
                                 sock_hold(s->sk);
-                                spin_unlock_bh(&ax25_list_lock);
+                                spin_unlock(&ax25_list_lock);
                                 return s->sk;
                         }
                 }
         }
-        spin_unlock_bh(&ax25_list_lock);
+        spin_unlock(&ax25_list_lock);
 
         return NULL;
 }
@@ -174,7 +174,7 @@ struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
         ax25_cb *s;
         struct hlist_node *node;
 
-        spin_lock_bh(&ax25_list_lock);
+        spin_lock(&ax25_list_lock);
         ax25_for_each(s, node, &ax25_list) {
                 if (s->sk && !ax25cmp(&s->source_addr, my_addr) &&
                     !ax25cmp(&s->dest_addr, dest_addr) &&
@@ -185,7 +185,7 @@ struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
                 }
         }
 
-        spin_unlock_bh(&ax25_list_lock);
+        spin_unlock(&ax25_list_lock);
 
         return sk;
 }
@@ -235,7 +235,7 @@ void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
         struct sk_buff *copy;
         struct hlist_node *node;
 
-        spin_lock_bh(&ax25_list_lock);
+        spin_lock(&ax25_list_lock);
         ax25_for_each(s, node, &ax25_list) {
                 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 &&
                     s->sk->sk_type == SOCK_RAW &&
@@ -248,7 +248,7 @@ void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
                                 kfree_skb(copy);
                 }
         }
-        spin_unlock_bh(&ax25_list_lock);
+        spin_unlock(&ax25_list_lock);
 }
 
 /*
@@ -486,10 +486,9 @@ ax25_cb *ax25_create_cb(void)
 {
         ax25_cb *ax25;
 
-        if ((ax25 = kmalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
+        if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
                 return NULL;
 
-        memset(ax25, 0x00, sizeof(*ax25));
         atomic_set(&ax25->refcount, 1);
 
         skb_queue_head_init(&ax25->write_queue);
diff --git a/net/ax25/ax25_dev.c b/net/ax25/ax25_dev.c
index 47e6e790bd67..b787678220ff 100644
--- a/net/ax25/ax25_dev.c
+++ b/net/ax25/ax25_dev.c
@@ -55,15 +55,13 @@ void ax25_dev_device_up(struct net_device *dev)
 {
         ax25_dev *ax25_dev;
 
-        if ((ax25_dev = kmalloc(sizeof(*ax25_dev), GFP_ATOMIC)) == NULL) {
+        if ((ax25_dev = kzalloc(sizeof(*ax25_dev), GFP_ATOMIC)) == NULL) {
                 printk(KERN_ERR "AX.25: ax25_dev_device_up - out of memory\n");
                 return;
         }
 
         ax25_unregister_sysctl();
 
-        memset(ax25_dev, 0x00, sizeof(*ax25_dev));
-
         dev->ax25_ptr     = ax25_dev;
         ax25_dev->dev     = dev;
         dev_hold(dev);
diff --git a/net/ax25/ax25_ds_subr.c b/net/ax25/ax25_ds_subr.c
index 1d4ab641f82b..4d22d4430ec8 100644
--- a/net/ax25/ax25_ds_subr.c
+++ b/net/ax25/ax25_ds_subr.c
@@ -80,7 +80,7 @@ void ax25_ds_enquiry_response(ax25_cb *ax25)
         ax25_start_t3timer(ax25);
         ax25_ds_set_timer(ax25->ax25_dev);
 
-        spin_lock_bh(&ax25_list_lock);
+        spin_lock(&ax25_list_lock);
         ax25_for_each(ax25o, node, &ax25_list) {
                 if (ax25o == ax25)
                         continue;
@@ -106,7 +106,7 @@ void ax25_ds_enquiry_response(ax25_cb *ax25)
                 if (ax25o->state != AX25_STATE_0)
                         ax25_start_t3timer(ax25o);
         }
-        spin_unlock_bh(&ax25_list_lock);
+        spin_unlock(&ax25_list_lock);
 }
 
 void ax25_ds_establish_data_link(ax25_cb *ax25)
@@ -162,13 +162,13 @@ static int ax25_check_dama_slave(ax25_dev *ax25_dev)
         int res = 0;
         struct hlist_node *node;
 
-        spin_lock_bh(&ax25_list_lock);
+        spin_lock(&ax25_list_lock);
         ax25_for_each(ax25, node, &ax25_list)
                 if (ax25->ax25_dev == ax25_dev && (ax25->condition & AX25_COND_DAMA_MODE) && ax25->state > AX25_STATE_1) {
                         res = 1;
                         break;
                 }
-        spin_unlock_bh(&ax25_list_lock);
+        spin_unlock(&ax25_list_lock);
 
         return res;
 }
diff --git a/net/ax25/ax25_ds_timer.c b/net/ax25/ax25_ds_timer.c
index 5961459935eb..4f44185955c7 100644
--- a/net/ax25/ax25_ds_timer.c
+++ b/net/ax25/ax25_ds_timer.c
@@ -85,7 +85,7 @@ static void ax25_ds_timeout(unsigned long arg)
                 return;
         }
 
-        spin_lock_bh(&ax25_list_lock);
+        spin_lock(&ax25_list_lock);
         ax25_for_each(ax25, node, &ax25_list) {
                 if (ax25->ax25_dev != ax25_dev || !(ax25->condition & AX25_COND_DAMA_MODE))
                         continue;
@@ -93,7 +93,7 @@ static void ax25_ds_timeout(unsigned long arg)
                 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
                 ax25_disconnect(ax25, ETIMEDOUT);
         }
-        spin_unlock_bh(&ax25_list_lock);
+        spin_unlock(&ax25_list_lock);
 
         ax25_dev_dama_off(ax25_dev);
 }
diff --git a/net/ax25/ax25_iface.c b/net/ax25/ax25_iface.c
index 77ba07c67682..07ac0207eb69 100644
--- a/net/ax25/ax25_iface.c
+++ b/net/ax25/ax25_iface.c
@@ -66,10 +66,10 @@ int ax25_protocol_register(unsigned int pid,
         protocol->pid  = pid;
         protocol->func = func;
 
-        write_lock(&protocol_list_lock);
+        write_lock_bh(&protocol_list_lock);
         protocol->next = protocol_list;
         protocol_list  = protocol;
-        write_unlock(&protocol_list_lock);
+        write_unlock_bh(&protocol_list_lock);
 
         return 1;
 }
@@ -80,16 +80,16 @@ void ax25_protocol_release(unsigned int pid)
 {
         struct protocol_struct *s, *protocol;
 
-        write_lock(&protocol_list_lock);
+        write_lock_bh(&protocol_list_lock);
         protocol = protocol_list;
         if (protocol == NULL) {
-                write_unlock(&protocol_list_lock);
+                write_unlock_bh(&protocol_list_lock);
                 return;
         }
 
         if (protocol->pid == pid) {
                 protocol_list = protocol->next;
-                write_unlock(&protocol_list_lock);
+                write_unlock_bh(&protocol_list_lock);
                 kfree(protocol);
                 return;
         }
@@ -98,14 +98,14 @@ void ax25_protocol_release(unsigned int pid)
                 if (protocol->next->pid == pid) {
                         s = protocol->next;
                         protocol->next = protocol->next->next;
-                        write_unlock(&protocol_list_lock);
+                        write_unlock_bh(&protocol_list_lock);
                         kfree(s);
                         return;
                 }
 
                 protocol = protocol->next;
         }
-        write_unlock(&protocol_list_lock);
+        write_unlock_bh(&protocol_list_lock);
 }
 
 EXPORT_SYMBOL(ax25_protocol_release);
@@ -266,13 +266,13 @@ int ax25_protocol_is_registered(unsigned int pid)
         struct protocol_struct *protocol;
         int res = 0;
 
-        read_lock(&protocol_list_lock);
+        read_lock_bh(&protocol_list_lock);
         for (protocol = protocol_list; protocol != NULL; protocol = protocol->next)
                 if (protocol->pid == pid) {
                         res = 1;
                         break;
                 }
-        read_unlock(&protocol_list_lock);
+        read_unlock_bh(&protocol_list_lock);
 
         return res;
 }
diff --git a/net/ax25/ax25_in.c b/net/ax25/ax25_in.c
index 4cf87540fb3a..e9d94291581e 100644
--- a/net/ax25/ax25_in.c
+++ b/net/ax25/ax25_in.c
@@ -102,8 +102,8 @@ static int ax25_rx_fragment(ax25_cb *ax25, struct sk_buff *skb)
 int ax25_rx_iframe(ax25_cb *ax25, struct sk_buff *skb)
 {
         int (*func)(struct sk_buff *, ax25_cb *);
-        volatile int queued = 0;
         unsigned char pid;
+        int queued = 0;
 
         if (skb == NULL) return 0;
 
diff --git a/net/ax25/sysctl_net_ax25.c b/net/ax25/sysctl_net_ax25.c
index 369a75b160f2..867d42537979 100644
--- a/net/ax25/sysctl_net_ax25.c
+++ b/net/ax25/sysctl_net_ax25.c
@@ -203,13 +203,11 @@ void ax25_register_sysctl(void)
         for (ax25_table_size = sizeof(ctl_table), ax25_dev = ax25_dev_list; ax25_dev != NULL; ax25_dev = ax25_dev->next)
                 ax25_table_size += sizeof(ctl_table);
 
-        if ((ax25_table = kmalloc(ax25_table_size, GFP_ATOMIC)) == NULL) {
+        if ((ax25_table = kzalloc(ax25_table_size, GFP_ATOMIC)) == NULL) {
                 spin_unlock_bh(&ax25_dev_lock);
                 return;
         }
 
-        memset(ax25_table, 0x00, ax25_table_size);
-
         for (n = 0, ax25_dev = ax25_dev_list; ax25_dev != NULL; ax25_dev = ax25_dev->next) {
                 ctl_table *child = kmalloc(sizeof(ax25_param_table), GFP_ATOMIC);
                 if (!child) {