Merge bk://linux.bkbits.net/linux-2.5

into hostme.bitkeeper.com:/repos/c/cifs/linux-2.5cifs

drivers/acpi/pci_root.c

@@ -66,7 +66,7 @@ struct acpi_pci_root {
 	u64			io_tra;
 };
 
-struct list_head		acpi_pci_roots;
+static LIST_HEAD(acpi_pci_roots);
 
 static struct acpi_pci_driver *sub_driver;
 
@@ -375,8 +375,6 @@ static int __init acpi_pci_root_init (void)
 	acpi_dbg_level = 0xFFFFFFFF;
 	 */
 
- 	INIT_LIST_HEAD(&acpi_pci_roots);
-
 	if (acpi_bus_register_driver(&acpi_pci_root_driver) < 0)
 		return_VALUE(-ENODEV);
 

drivers/net/tg3.c

@@ -56,8 +56,8 @@
 
 #define DRV_MODULE_NAME		"tg3"
 #define PFX DRV_MODULE_NAME	": "
-#define DRV_MODULE_VERSION	"2.2"
-#define DRV_MODULE_RELDATE	"August 24, 2003"
+#define DRV_MODULE_VERSION	"2.3"
+#define DRV_MODULE_RELDATE	"November 5, 2003"
 
 #define TG3_DEF_MAC_MODE	0
 #define TG3_DEF_RX_MODE		0
@@ -5935,6 +5935,10 @@ static int tg3_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 					tp->link_config.phy_is_low_power)
 		return -EAGAIN;
 
+	spin_lock_irq(&tp->lock);
+	spin_lock(&tp->tx_lock);
+
+	tp->link_config.autoneg = cmd->autoneg;
 	if (cmd->autoneg == AUTONEG_ENABLE) {
 		tp->link_config.advertising = cmd->advertising;
 		tp->link_config.speed = SPEED_INVALID;

net/ipv6/addrconf.c

@@ -1877,10 +1877,12 @@ int addrconf_notify(struct notifier_block *this, unsigned long event,
 		break;
 	case NETDEV_CHANGENAME:
 #ifdef CONFIG_SYSCTL
-		addrconf_sysctl_unregister(&idev->cnf);
-		neigh_sysctl_unregister(idev->nd_parms);
-		neigh_sysctl_register(dev, idev->nd_parms, NET_IPV6, NET_IPV6_NEIGH, "ipv6");
-		addrconf_sysctl_register(idev, &idev->cnf);
+		if (idev) {
+			addrconf_sysctl_unregister(&idev->cnf);
+			neigh_sysctl_unregister(idev->nd_parms);
+			neigh_sysctl_register(dev, idev->nd_parms, NET_IPV6, NET_IPV6_NEIGH, "ipv6");
+			addrconf_sysctl_register(idev, &idev->cnf);
+		}
 #endif
 		break;
 	};

net/ipv6/ip6_tunnel.c

@@ -681,7 +681,6 @@ int ip6ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev)
 		icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu, dev);
 		goto tx_err_dst_release;
 	}
-	skb->h.raw = skb->nh.raw;
 
 	/*
 	 * Okay, now see if we can stuff it in the buffer as-is.
@@ -703,6 +702,8 @@ int ip6ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev)
 	dst_release(skb->dst);
 	skb->dst = dst_clone(dst);
 
+	skb->h.raw = skb->nh.raw;
+
 	if (opt)
 		ipv6_push_nfrag_opts(skb, opt, &proto, NULL);
 
@@ -809,9 +810,9 @@ static void ip6ip6_tnl_link_config(struct ip6_tnl *t)
 	fl->fl6_flowlabel = 0;
 
 	if (!(p->flags&IP6_TNL_F_USE_ORIG_TCLASS))
-		fl->fl6_flowlabel |= IPV6_TCLASS_MASK & htonl(p->flowinfo);
+		fl->fl6_flowlabel |= IPV6_TCLASS_MASK & p->flowinfo;
 	if (!(p->flags&IP6_TNL_F_USE_ORIG_FLOWLABEL))
-		fl->fl6_flowlabel |= IPV6_FLOWLABEL_MASK & htonl(p->flowinfo);
+		fl->fl6_flowlabel |= IPV6_FLOWLABEL_MASK & p->flowinfo;
 
 	ip6_tnl_set_cap(t);
 

net/ipv6/sysctl_net_ipv6.c

@@ -31,7 +31,7 @@ ctl_table ipv6_table[] = {
 		.ctl_name	= NET_IPV6_ICMP,
 		.procname	= "icmp",
 		.maxlen		= 0,
-		.mode		= 0500,
+		.mode		= 0555,
 		.child		= ipv6_icmp_table
 	},
 	{

net/irda/discovery.c

@@ -351,10 +351,6 @@ __u32 irlmp_find_device(hashbin_t *cachelog, char *name, __u32 *saddr)
 }
 
 #ifdef CONFIG_PROC_FS
-struct discovery_iter_state {
-	unsigned long flags;
-};
-
 static inline discovery_t *discovery_seq_idx(loff_t pos)
 
 {
@@ -372,9 +368,7 @@ static inline discovery_t *discovery_seq_idx(loff_t pos)
 
 static void *discovery_seq_start(struct seq_file *seq, loff_t *pos)
 {
-	struct discovery_iter_state *iter = seq->private;
-
-	spin_lock_irqsave(&irlmp->cachelog->hb_spinlock, iter->flags);
+	spin_lock_irq(&irlmp->cachelog->hb_spinlock);
         return *pos ? discovery_seq_idx(*pos - 1) : SEQ_START_TOKEN;
 }
 
@@ -388,8 +382,7 @@ static void *discovery_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 
 static void discovery_seq_stop(struct seq_file *seq, void *v)
 {
-	struct discovery_iter_state *iter = seq->private;
-	spin_unlock_irqrestore(&irlmp->cachelog->hb_spinlock, iter->flags);
+	spin_unlock_irq(&irlmp->cachelog->hb_spinlock);
 }
 
 static int discovery_seq_show(struct seq_file *seq, void *v)
@@ -446,28 +439,9 @@ static struct seq_operations discovery_seq_ops = {
 
 static int discovery_seq_open(struct inode *inode, struct file *file)
 {
-	struct seq_file *seq;
-	int rc = -ENOMEM;
-	struct discovery_iter_state *s;
-       
 	ASSERT(irlmp != NULL, return -EINVAL;);
 
-	s = kmalloc(sizeof(*s), GFP_KERNEL);
-	if (!s)
-		goto out;
-
-	rc = seq_open(file, &discovery_seq_ops);
-	if (rc)
-		goto out_kfree;
-
-	seq	     = file->private_data;
-	seq->private = s;
-	memset(s, 0, sizeof(*s));
-out:
-	return rc;
-out_kfree:
-	kfree(s);
-	goto out;
+	return seq_open(file, &discovery_seq_ops);
 }
 
 struct file_operations discovery_seq_fops = {

net/irda/ircomm/ircomm_core.c

@@ -508,17 +508,12 @@ void ircomm_flow_request(struct ircomm_cb *self, LOCAL_FLOW flow)
 EXPORT_SYMBOL(ircomm_flow_request);
 
 #ifdef CONFIG_PROC_FS
-struct ircomm_iter_state {
-	unsigned long flags;
-};
-
 static void *ircomm_seq_start(struct seq_file *seq, loff_t *pos)
 {
-	struct ircomm_iter_state *iter = seq->private;
 	struct ircomm_cb *self;
 	loff_t off = 0;
 
-	spin_lock_irqsave(&ircomm->hb_spinlock, iter->flags);
+	spin_lock_irq(&ircomm->hb_spinlock);
 
 	for (self = (struct ircomm_cb *) hashbin_get_first(ircomm);
 	     self != NULL;
@@ -539,8 +534,7 @@ static void *ircomm_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 
 static void ircomm_seq_stop(struct seq_file *seq, void *v)
 {
-	struct ircomm_iter_state *iter = seq->private;
-	spin_unlock_irqrestore(&ircomm->hb_spinlock, iter->flags);
+	spin_unlock_irq(&ircomm->hb_spinlock);
 }
 
 static int ircomm_seq_show(struct seq_file *seq, void *v)
@@ -581,25 +575,7 @@ static struct seq_operations ircomm_seq_ops = {
 
 static int ircomm_seq_open(struct inode *inode, struct file *file)
 {
-	struct seq_file *seq;
-	int rc = -ENOMEM;
-	struct ircomm_iter_state *s = kmalloc(sizeof(*s), GFP_KERNEL);
-       
-	if (!s)
-		goto out;
-
-	rc = seq_open(file, &ircomm_seq_ops);
-	if (rc)
-		goto out_kfree;
-
-	seq	     = file->private_data;
-	seq->private = s;
-	memset(s, 0, sizeof(*s));
-out:
-	return rc;
-out_kfree:
-	kfree(s);
-	goto out;
+	return seq_open(file, &ircomm_seq_ops);
 }
 #endif /* CONFIG_PROC_FS */
 

net/irda/ircomm/ircomm_tty.c

@@ -663,9 +663,10 @@ static void ircomm_tty_do_softint(void *private_)
  *    accepted for writing. This routine is mandatory.
  */
 static int ircomm_tty_write(struct tty_struct *tty, int from_user,
-			    const unsigned char *buf, int count)
+			    const unsigned char *ubuf, int count)
 {
 	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
+	unsigned char *kbuf;		/* Buffer in kernel space */
 	unsigned long flags;
 	struct sk_buff *skb;
 	int tailroom = 0;
@@ -702,6 +703,24 @@ static int ircomm_tty_write(struct tty_struct *tty, int from_user,
 #endif
 	}
 
+	if (count < 1)
+		return 0;
+
+	/* Additional copy to avoid copy_from_user() under spinlock.
+	 * We tradeoff this extra copy to allow to pack more the
+	 * IrCOMM frames. This is advantageous because the IrDA link
+	 * is the bottleneck. */
+	if (from_user) {
+		kbuf = kmalloc(count, GFP_KERNEL);
+		if (kbuf == NULL)
+			return -ENOMEM;
+		if (copy_from_user(kbuf, ubuf, count))
+			return -EFAULT;
+	} else
+		/* The buffer is already in kernel space */
+		kbuf = (unsigned char *) ubuf;
+
+	/* Protect our manipulation of self->tx_skb and related */
 	spin_lock_irqsave(&self->spinlock, flags);
 
 	/* Fetch current transmit buffer */
@@ -761,19 +780,19 @@ static int ircomm_tty_write(struct tty_struct *tty, int from_user,
 			 * change later on - Jean II */
 			self->tx_data_size = self->max_data_size;
 		}
-		
+
 		/* Copy data */
-		if (from_user)
-			copy_from_user(skb_put(skb,size), buf+len, size);
-		else
-			memcpy(skb_put(skb,size), buf+len, size);
-		
+		memcpy(skb_put(skb,size), kbuf + len, size);
+
 		count -= size;
 		len += size;
 	}
 
 	spin_unlock_irqrestore(&self->spinlock, flags);
 
+	if (from_user)
+		kfree(kbuf);
+
 	/*     
 	 * Schedule a new thread which will transmit the frame as soon
 	 * as possible, but at a safe point in time. We do this so the
@@ -837,6 +856,7 @@ static void ircomm_tty_wait_until_sent(struct tty_struct *tty, int timeout)
 {
 	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
 	unsigned long orig_jiffies, poll_time;
+	unsigned long flags;
 	
 	IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
 
@@ -848,14 +868,18 @@ static void ircomm_tty_wait_until_sent(struct tty_struct *tty, int timeout)
 	/* Set poll time to 200 ms */
 	poll_time = IRDA_MIN(timeout, MSECS_TO_JIFFIES(200));
 
+	spin_lock_irqsave(&self->spinlock, flags);
 	while (self->tx_skb && self->tx_skb->len) {
+		spin_unlock_irqrestore(&self->spinlock, flags);
 		current->state = TASK_INTERRUPTIBLE;
 		schedule_timeout(poll_time);
+		spin_lock_irqsave(&self->spinlock, flags);
 		if (signal_pending(current))
 			break;
 		if (timeout && time_after(jiffies, orig_jiffies + timeout))
 			break;
 	}
+	spin_unlock_irqrestore(&self->spinlock, flags);
 	current->state = TASK_RUNNING;
 }
 

net/irda/iriap.c

@@ -978,10 +978,6 @@ static const char *ias_value_types[] = {
 	"IAS_STRING"
 };
 
-struct irias_iter_state {
-	unsigned long flags;
-};
-
 static inline struct ias_object *irias_seq_idx(loff_t pos) 
 {
 	struct ias_object *obj;
@@ -997,9 +993,7 @@ static inline struct ias_object *irias_seq_idx(loff_t pos)
 
 static void *irias_seq_start(struct seq_file *seq, loff_t *pos)
 {
-	struct irias_iter_state *iter = seq->private;
-
-	spin_lock_irqsave(&irias_objects->hb_spinlock, iter->flags);
+	spin_lock_irq(&irias_objects->hb_spinlock);
 
 	return *pos ? irias_seq_idx(*pos - 1) : SEQ_START_TOKEN;
 }
@@ -1015,9 +1009,7 @@ static void *irias_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 
 static void irias_seq_stop(struct seq_file *seq, void *v)
 {
-	struct irias_iter_state *iter = seq->private;
-
-	spin_unlock_irqrestore(&irias_objects->hb_spinlock, iter->flags);
+	spin_unlock_irq(&irias_objects->hb_spinlock);
 }
 
 static int irias_seq_show(struct seq_file *seq, void *v)
@@ -1088,26 +1080,9 @@ static struct seq_operations irias_seq_ops = {
 
 static int irias_seq_open(struct inode *inode, struct file *file)
 {
-	struct seq_file *seq;
-	int rc = -ENOMEM;
-	struct irias_iter_state *s;
-
 	ASSERT( irias_objects != NULL, return -EINVAL;);
-	s = kmalloc(sizeof(*s), GFP_KERNEL);
-	if (!s)
-		goto out;
 
-	rc = seq_open(file, &irias_seq_ops);
-	if (rc)
-		goto out_kfree;
-	seq	     = file->private_data;
-	seq->private = s;
-	memset(s, 0, sizeof(*s));
-out:
-	return rc;
-out_kfree:
-	kfree(s);
-	goto out;
+	return seq_open(file, &irias_seq_ops);
 }
 
 struct file_operations irias_seq_fops = {

net/irda/irlap.c

@@ -1094,7 +1094,6 @@ void irlap_apply_connection_parameters(struct irlap_cb *self, int now)
 #ifdef CONFIG_PROC_FS
 struct irlap_iter_state {
 	int id;
-	unsigned long flags;
 };
 
 static void *irlap_seq_start(struct seq_file *seq, loff_t *pos)
@@ -1103,7 +1102,7 @@ static void *irlap_seq_start(struct seq_file *seq, loff_t *pos)
 	struct irlap_cb *self;
 
 	/* Protect our access to the tsap list */
-	spin_lock_irqsave(&irlap->hb_spinlock, iter->flags);
+	spin_lock_irq(&irlap->hb_spinlock);
 	iter->id = 0;
 
 	for (self = (struct irlap_cb *) hashbin_get_first(irlap); 
@@ -1127,8 +1126,7 @@ static void *irlap_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 
 static void irlap_seq_stop(struct seq_file *seq, void *v)
 {
-	struct irlap_iter_state *iter = seq->private;
-	spin_unlock_irqrestore(&irlap->hb_spinlock, iter->flags);
+	spin_unlock_irq(&irlap->hb_spinlock);
 }
 
 static int irlap_seq_show(struct seq_file *seq, void *v)

net/irda/irlmp.c

@@ -146,6 +146,7 @@ struct lsap_cb *irlmp_open_lsap(__u8 slsap_sel, notify_t *notify, __u8 pid)
 	ASSERT(notify != NULL, return NULL;);
 	ASSERT(irlmp != NULL, return NULL;);
 	ASSERT(irlmp->magic == LMP_MAGIC, return NULL;);
+	ASSERT(notify->instance != NULL, return NULL;);
 
 	/*  Does the client care which Source LSAP selector it gets?  */
 	if (slsap_sel == LSAP_ANY) {
@@ -178,7 +179,6 @@ struct lsap_cb *irlmp_open_lsap(__u8 slsap_sel, notify_t *notify, __u8 pid)
 
 	init_timer(&self->watchdog_timer);
 
-	ASSERT(notify->instance != NULL, return NULL;);
 	self->notify = *notify;
 
 	self->lsap_state = LSAP_DISCONNECTED;
@@ -1780,7 +1780,6 @@ __u32 irlmp_get_daddr(struct lsap_cb *self)
 #ifdef CONFIG_PROC_FS
 
 struct irlmp_iter_state {
-	unsigned long flags;
 	hashbin_t *hashbin;
 };
 
@@ -1791,7 +1790,7 @@ static void *irlmp_seq_hb_idx(struct irlmp_iter_state *iter, loff_t *off)
 {
 	void *element;
 
-	spin_lock_irqsave(&iter->hashbin->hb_spinlock, iter->flags);
+	spin_lock_irq(&iter->hashbin->hb_spinlock);
 	for (element = hashbin_get_first(iter->hashbin);
 	     element != NULL; 
 	     element = hashbin_get_next(iter->hashbin)) {
@@ -1800,7 +1799,7 @@ static void *irlmp_seq_hb_idx(struct irlmp_iter_state *iter, loff_t *off)
 			return element;
 		}
 	}
-	spin_unlock_irqrestore(&iter->hashbin->hb_spinlock, iter->flags);
+	spin_unlock_irq(&iter->hashbin->hb_spinlock);
 	iter->hashbin = NULL;
 	return NULL;
 }
@@ -1848,8 +1847,7 @@ static void *irlmp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 	v = hashbin_get_next(iter->hashbin);
 
 	if (v == NULL) {			/* no more in this hash bin */
-		spin_unlock_irqrestore(&iter->hashbin->hb_spinlock, 
-				       iter->flags);
+		spin_unlock_irq(&iter->hashbin->hb_spinlock);
 
 		if (iter->hashbin == irlmp->unconnected_lsaps) 
 			v =  LINK_START_TOKEN;
@@ -1862,10 +1860,9 @@ static void *irlmp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 static void irlmp_seq_stop(struct seq_file *seq, void *v)
 {
 	struct irlmp_iter_state *iter = seq->private;
-	
+
 	if (iter->hashbin)
-		spin_unlock_irqrestore(&iter->hashbin->hb_spinlock, iter->flags);
-		
+		spin_unlock_irq(&iter->hashbin->hb_spinlock);
 }
 
 static int irlmp_seq_show(struct seq_file *seq, void *v)

net/irda/irnet/irnet_ppp.c

@@ -512,8 +512,8 @@ dev_irnet_close(struct inode *	inode,
   if(ap->ppp_open)
     {
       DERROR(FS_ERROR, "Channel still registered - deregistering !\n");
-      ppp_unregister_channel(&ap->chan);
       ap->ppp_open = 0;
+      ppp_unregister_channel(&ap->chan);
     }
 
   kfree(ap);
@@ -651,10 +651,12 @@ dev_irnet_ioctl(struct inode *	inode,
 	  DEBUG(FS_INFO, "Exiting PPP discipline.\n");
 	  /* Disconnect from the generic PPP layer */
 	  if(ap->ppp_open)
-	    ppp_unregister_channel(&ap->chan);
+	    {
+	      ap->ppp_open = 0;
+	      ppp_unregister_channel(&ap->chan);
+	    }
 	  else
 	    DERROR(FS_ERROR, "Channel not registered !\n");
-	  ap->ppp_open = 0;
 	  err = 0;
 	}
       break;

net/irda/irttp.c

@@ -968,6 +968,10 @@ void irttp_status_indication(void *instance,
 	ASSERT(self != NULL, return;);
 	ASSERT(self->magic == TTP_TSAP_MAGIC, return;);
 
+	/* Check if client has already closed the TSAP and gone away */
+	if (self->close_pend)
+		return;
+
 	/*
 	 *  Inform service user if he has requested it
 	 */
@@ -1603,7 +1607,7 @@ void irttp_do_data_indication(struct tsap_cb *self, struct sk_buff *skb)
 {
 	int err;
 
-	/* Check if client has already tried to close the TSAP */
+	/* Check if client has already closed the TSAP and gone away */
 	if (self->close_pend) {
 		dev_kfree_skb(skb);
 		return;
@@ -1770,7 +1774,6 @@ void irttp_run_rx_queue(struct tsap_cb *self)
 #ifdef CONFIG_PROC_FS
 struct irttp_iter_state {
 	int id;
-	unsigned long flags;
 };
 
 static void *irttp_seq_start(struct seq_file *seq, loff_t *pos)
@@ -1779,7 +1782,7 @@ static void *irttp_seq_start(struct seq_file *seq, loff_t *pos)
 	struct tsap_cb *self;
 
 	/* Protect our access to the tsap list */
-	spin_lock_irqsave(&irttp->tsaps->hb_spinlock, iter->flags);
+	spin_lock_irq(&irttp->tsaps->hb_spinlock);
 	iter->id = 0;
 
 	for (self = (struct tsap_cb *) hashbin_get_first(irttp->tsaps); 
@@ -1804,8 +1807,7 @@ static void *irttp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 
 static void irttp_seq_stop(struct seq_file *seq, void *v)
 {
-	struct irttp_iter_state *iter = seq->private;
-	spin_unlock_irqrestore(&irttp->tsaps->hb_spinlock, iter->flags);
+	spin_unlock_irq(&irttp->tsaps->hb_spinlock);
 }
 
 static int irttp_seq_show(struct seq_file *seq, void *v)