Merge maxwell.earthlink.net:/usr/src/linus-2.5

into maxwell.earthlink.net:/usr/src/fbdev-2.5

arch/alpha/kernel/module.c

@@ -190,15 +190,10 @@ apply_relocate_add(Elf64_Shdr *sechdrs, const char *strtab,
 		/* This is where to make the change.  */
 		location = base + rela[i].r_offset;
 
-		/* This is the symbol it is referring to.  */
+		/* This is the symbol it is referring to.  Note that all
+		   unresolved symbols have been resolved.  */
 		sym = symtab + r_sym;
-		value = sym->st_value;
-		if (!value) {
-			printk(KERN_ERR "module %s: Unknown symbol %s\n",
-			       me->name, strtab + sym->st_name);
-			return -ENOENT;
-		}
-		value += rela[i].r_addend;
+		value = sym->st_value + rela[i].r_addend;
 
 		switch (r_type) {
 		case R_ALPHA_NONE:

arch/arm/kernel/module.c

@@ -98,11 +98,6 @@ apply_relocate(Elf32_Shdr *sechdrs, const char *strtab, unsigned int symindex,
 		}
 
 		sym = ((Elf32_Sym *)symsec->sh_addr) + offset;
-		if (!sym->st_value) {
-			printk(KERN_WARNING "%s: unknown symbol %s\n",
-				module->name, strtab + sym->st_name);
-			return -ENOENT;
-		}
 
 		if (rel->r_offset < 0 || rel->r_offset > dstsec->sh_size - sizeof(u32)) {
 			printk(KERN_ERR "%s: out of bounds relocation, "

arch/i386/kernel/module.c

@@ -70,14 +70,10 @@ int apply_relocate(Elf32_Shdr *sechdrs,
 		/* This is where to make the change */
 		location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
 			+ rel[i].r_offset;
-		/* This is the symbol it is referring to */
+		/* This is the symbol it is referring to.  Note that all
+		   undefined symbols have been resolved.  */
 		sym = (Elf32_Sym *)sechdrs[symindex].sh_addr
 			+ ELF32_R_SYM(rel[i].r_info);
-		if (!sym->st_value) {
-			printk(KERN_WARNING "%s: Unknown symbol %s\n",
-			       me->name, strtab + sym->st_name);
-			return -ENOENT;
-		}
 
 		switch (ELF32_R_TYPE(rel[i].r_info)) {
 		case R_386_32:

arch/ppc/kernel/module.c

@@ -197,14 +197,10 @@ int apply_relocate_add(Elf32_Shdr *sechdrs,
 		/* This is where to make the change */
 		location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
 			+ rela[i].r_offset;
-		/* This is the symbol it is referring to */
+		/* This is the symbol it is referring to.  Note that all
+		   undefined symbols have been resolved.  */
 		sym = (Elf32_Sym *)sechdrs[symindex].sh_addr
 			+ ELF32_R_SYM(rela[i].r_info);
-		if (!sym->st_value) {
-			printk(KERN_WARNING "%s: Unknown symbol %s\n",
-			       module->name, strtab + sym->st_name);
-			return -ENOENT;
-		}
 		/* `Everything is relative'. */
 		value = sym->st_value + rela[i].r_addend;
 

arch/s390/kernel/module.c

 /*
- *  arch/s390x/kernel/module.c - Kernel module help for s390x.
+ *  arch/s390/kernel/module.c - Kernel module help for s390.
  *
  *  S390 version
  *    Copyright (C) 2002 IBM Deutschland Entwicklung GmbH, IBM Corporation
@@ -77,14 +77,10 @@ int apply_relocate(Elf_Shdr *sechdrs,
 		/* This is where to make the change */
 		location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
 			+ rel[i].r_offset;
-		/* This is the symbol it is referring to */
+		/* This is the symbol it is referring to.  Note that all
+		   undefined symbols have been resolved.  */
 		sym = (ElfW(Sym) *)sechdrs[symindex].sh_addr
 			+ ELFW(R_SYM)(rel[i].r_info);
-		if (!sym->st_value) {
-			printk(KERN_WARNING "%s: Unknown symbol %s\n",
-			       me->name, strtab + sym->st_name);
-			return -ENOENT;
-		}
 
 		switch (ELF_R_TYPE(rel[i].r_info)) {
 		case R_390_8:		/* Direct 8 bit.   */

arch/s390x/kernel/module.c

@@ -78,14 +78,10 @@ int apply_relocate(Elf_Shdr *sechdrs,
 		/* This is where to make the change */
 		location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
 			+ rel[i].r_offset;
-		/* This is the symbol it is referring to */
+		/* This is the symbol it is referring to.  Note that all
+		   undefined symbols have been resolved.  */
 		sym = (ElfW(Sym) *)sechdrs[symindex].sh_addr
 			+ ELFW(R_SYM)(rel[i].r_info);
-		if (!sym->st_value) {
-			printk(KERN_WARNING "%s: Unknown symbol %s\n",
-			       me->name, strtab + sym->st_name);
-			return -ENOENT;
-		}
 
 		switch (ELF_R_TYPE(rel[i].r_info)) {
 		case R_390_8:		/* Direct 8 bit.   */

arch/sparc/kernel/module.c

@@ -75,15 +75,11 @@ int apply_relocate_add(Elf32_Shdr *sechdrs,
 		location = (u8 *)sechdrs[sechdrs[relsec].sh_info].sh_addr
 			+ rel[i].r_offset;
 		loc32 = (u32 *) location;
-		/* This is the symbol it is referring to */
+		/* This is the symbol it is referring to.  Note that all
+		   undefined symbols have been resolved.  */
 		sym = (Elf32_Sym *)sechdrs[symindex].sh_addr
 			+ ELF32_R_SYM(rel[i].r_info);
-		if (!(v = sym->st_value)) {
-			printk(KERN_WARNING "%s: Unknown symbol %s\n",
-			       me->name, strtab + sym->st_name);
-			return -ENOENT;
-		}
-		v += rel[i].r_addend;
+		v = sym->st_value + rel[i].r_addend;
 
 		switch (ELF32_R_TYPE(rel[i].r_info)) {
 		case R_SPARC_32:

arch/sparc64/kernel/module.c

@@ -185,15 +185,11 @@ int apply_relocate_add(Elf64_Shdr *sechdrs,
 
 		BUG_ON(((u64)location >> (u64)32) != (u64)0);
 
-		/* This is the symbol it is referring to */
+		/* This is the symbol it is referring to.  Note that all
+		   undefined symbols have been resolved.  */
 		sym = (Elf64_Sym *)sechdrs[symindex].sh_addr
 			+ ELF64_R_SYM(rel[i].r_info);
-		if (!(v = sym->st_value)) {
-			printk(KERN_WARNING "%s: Unknown symbol %s\n",
-			       me->name, strtab + sym->st_name);
-			return -ENOENT;
-		}
-		v += rel[i].r_addend;
+		v = sym->st_value + rel[i].r_addend;
 
 		switch (ELF64_R_TYPE(rel[i].r_info) & 0xff) {
 		case R_SPARC_64:

arch/v850/kernel/module.c

@@ -184,19 +184,12 @@ int apply_relocate_add (Elf32_Shdr *sechdrs, const char *strtab,
 		uint32_t *loc
 			= ((void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
 			   + rela[i].r_offset);
-		/* This is the symbol it is referring to */
+		/* This is the symbol it is referring to.  Note that all
+		   undefined symbols have been resolved.  */
 		Elf32_Sym *sym
 			= ((Elf32_Sym *)sechdrs[symindex].sh_addr
 			   + ELF32_R_SYM (rela[i].r_info));
-		uint32_t val = sym->st_value;
-
-		if (! val) {
-			printk (KERN_WARNING "%s: Unknown symbol %s\n",
-				mod->name, strtab + sym->st_name);
-			return -ENOENT;
-		}
-
-		val += rela[i].r_addend;
+		uint32_t val = sym->st_value + rela[i].r_addend;
 
 		switch (ELF32_R_TYPE (rela[i].r_info)) {
 		case R_V850_32:

arch/x86_64/kernel/module.c

@@ -53,14 +53,10 @@ int apply_relocate_add(Elf64_Shdr *sechdrs,
 		loc = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
 			+ rel[i].r_offset;
 
-		/* This is the symbol it is referring to */
+		/* This is the symbol it is referring to.  Note that all
+		   undefined symbols have been resolved.  */
 		sym = (Elf64_Sym *)sechdrs[symindex].sh_addr
 			+ ELF64_R_SYM(rel[i].r_info);
-		if (!sym->st_value) {
-			printk(KERN_WARNING "%s: Unknown symbol %s\n",
-			       me->name, strtab + sym->st_name);
-			return -ENOENT;
-		}
 
 	        DEBUGP("type %d st_value %Lx r_addend %Lx loc %Lx\n",
 		       (int)ELF64_R_TYPE(rel[i].r_info), 

drivers/base/bus.c

@@ -43,14 +43,15 @@ drv_attr_show(struct kobject * kobj, struct attribute * attr, char * buf)
 }
 
 static ssize_t
-drv_attr_store(struct kobject * kobj, struct attribute * attr, const char * buf)
+drv_attr_store(struct kobject * kobj, struct attribute * attr, 
+	       const char * buf, size_t count)
 {
 	struct driver_attribute * drv_attr = to_drv_attr(attr);
 	struct device_driver * drv = to_driver(kobj);
 	ssize_t ret = 0;
 
 	if (drv_attr->store)
-		ret = drv_attr->store(drv,buf);
+		ret = drv_attr->store(drv,buf,count);
 	return ret;
 }
 
@@ -90,14 +91,15 @@ bus_attr_show(struct kobject * kobj, struct attribute * attr, char * buf)
 }
 
 static ssize_t
-bus_attr_store(struct kobject * kobj, struct attribute * attr, const char * buf)
+bus_attr_store(struct kobject * kobj, struct attribute * attr, 
+	       const char * buf, size_t count)
 {
 	struct bus_attribute * bus_attr = to_bus_attr(attr);
 	struct bus_type * bus = to_bus(kobj);
 	ssize_t ret = 0;
 
 	if (bus_attr->store)
-		ret = bus_attr->store(bus,buf);
+		ret = bus_attr->store(bus,buf,count);
 	return ret;
 }
 

drivers/base/class.c

@@ -26,14 +26,15 @@ devclass_attr_show(struct kobject * kobj, struct attribute * attr, char * buf)
 }
 
 static ssize_t
-devclass_attr_store(struct kobject * kobj, struct attribute * attr, const char * buf)
+devclass_attr_store(struct kobject * kobj, struct attribute * attr, 
+		    const char * buf, size_t count)
 {
 	struct devclass_attribute * class_attr = to_class_attr(attr);
 	struct device_class * dc = to_class(kobj);
 	ssize_t ret = 0;
 
 	if (class_attr->store)
-		ret = class_attr->store(dc,buf);
+		ret = class_attr->store(dc,buf,count);
 	return ret;
 }
 

drivers/base/core.c

@@ -47,14 +47,15 @@ dev_attr_show(struct kobject * kobj, struct attribute * attr, char * buf)
 }
 
 static ssize_t
-dev_attr_store(struct kobject * kobj, struct attribute * attr, const char * buf)
+dev_attr_store(struct kobject * kobj, struct attribute * attr, 
+	       const char * buf, size_t count)
 {
 	struct device_attribute * dev_attr = to_dev_attr(attr);
 	struct device * dev = to_dev(kobj);
 	ssize_t ret = 0;
 
 	if (dev_attr->store)
-		ret = dev_attr->store(dev,buf);
+		ret = dev_attr->store(dev,buf,count);
 	return ret;
 }
 

drivers/base/interface.c

@@ -24,7 +24,7 @@ device_read_power(struct device * dev, char * page)
 }
 
 static ssize_t
-device_write_power(struct device * dev, const char * buf)
+device_write_power(struct device * dev, const char * buf, size_t count)
 {
 	char	str_command[20];
 	char	str_level[20];
@@ -80,7 +80,7 @@ device_write_power(struct device * dev, const char * buf)
 			error = 0;
 	}
  done:
-	return error < 0 ? error : strlen(buf);
+	return error < 0 ? error : count;
 }
 
 static DEVICE_ATTR(power,S_IWUSR | S_IRUGO,

drivers/base/node.c

@@ -36,29 +36,27 @@ static ssize_t node_read_cpumap(struct device * dev, char * buf, size_t count, l
 static DEVICE_ATTR(cpumap,S_IRUGO,node_read_cpumap,NULL);
 
 #define K(x) ((x) << (PAGE_SHIFT - 10))
-static ssize_t node_read_meminfo(struct device * dev, char * buf, size_t count, loff_t off)
+static ssize_t node_read_meminfo(struct device * dev, char * buf)
 {
 	struct sys_root *node = to_root(dev);
 	int nid = node->id;
 	struct sysinfo i;
 	si_meminfo_node(&i, nid);
-	return off ? 0 : sprintf(buf, "\n"
-			"Node %d MemTotal:     %8lu kB\n"
-			"Node %d MemFree:      %8lu kB\n"
-			"Node %d MemUsed:      %8lu kB\n"
-			"Node %d HighTotal:    %8lu kB\n"
-			"Node %d HighFree:     %8lu kB\n"
-			"Node %d LowTotal:     %8lu kB\n"
-			"Node %d LowFree:      %8lu kB\n",
-			nid, K(i.totalram),
-			nid, K(i.freeram),
-			nid, K(i.totalram-i.freeram),
-			nid, K(i.totalhigh),
-			nid, K(i.freehigh),
-			nid, K(i.totalram-i.totalhigh),
-			nid, K(i.freeram-i.freehigh));
-
-	return 0;
+	return sprintf(buf, "\n"
+		       "Node %d MemTotal:     %8lu kB\n"
+		       "Node %d MemFree:      %8lu kB\n"
+		       "Node %d MemUsed:      %8lu kB\n"
+		       "Node %d HighTotal:    %8lu kB\n"
+		       "Node %d HighFree:     %8lu kB\n"
+		       "Node %d LowTotal:     %8lu kB\n"
+		       "Node %d LowFree:      %8lu kB\n",
+		       nid, K(i.totalram),
+		       nid, K(i.freeram),
+		       nid, K(i.totalram-i.freeram),
+		       nid, K(i.totalhigh),
+		       nid, K(i.freehigh),
+		       nid, K(i.totalram-i.totalhigh),
+		       nid, K(i.freeram-i.freehigh));
 }
 #undef K 
 static DEVICE_ATTR(meminfo,S_IRUGO,node_read_meminfo,NULL);

drivers/isdn/hisax/hisax_fcpcipnp.c

@@ -63,7 +63,7 @@ static struct pnp_card_id fcpnp_ids[] __devinitdata = {
 	  .driver_data = (unsigned long) "Fritz!Card PnP",
 	  .devs = { { "AVM0900" } } }
 };
-//MODULE_DEVICE_TABLE(pnpc, fcpnp_ids); FIXME
+MODULE_DEVICE_TABLE(pnp_card, fcpnp_ids);
 
 static int protocol = 2;       /* EURO-ISDN Default */
 MODULE_PARM(protocol, "i");
@@ -911,7 +911,7 @@ static struct pci_driver fcpci_driver = {
 #ifdef __ISAPNP__
 
 static int __devinit fcpnp_probe(struct pnp_card *card,
-				 const struct pnp_card_id *card_id)
+				 const struct pnp_card_device_id *card_id)
 {
 	struct fritz_adapter *adapter;
 	struct pnp_dev *pnp_dev;

drivers/mca/mca-bus.c

@@ -69,47 +69,28 @@ struct bus_type mca_bus_type = {
 };
 EXPORT_SYMBOL (mca_bus_type);
 
-static ssize_t mca_show_pos_id(struct device *dev, char *buf, size_t count,
-			       loff_t off)
+static ssize_t mca_show_pos_id(struct device *dev, char *buf)
 {
 	/* four digits, \n and trailing \0 */
-	char mybuf[6];
 	struct mca_device *mca_dev = to_mca_device(dev);
 	int len;
 
 	if(mca_dev->pos_id < MCA_DUMMY_POS_START)
-		len = sprintf(mybuf, "%04x\n", mca_dev->pos_id);
+		len = sprintf(buf, "%04x\n", mca_dev->pos_id);
 	else
-		len = sprintf(mybuf, "none\n");
-
-	len++;
-	if(len > off) {
-		len = min((size_t)(len - off), count);
-		memcpy(buf + off, mybuf + off, len);
-	} else {
-		len = 0;
-	}
+		len = sprintf(buf, "none\n");
 	return len;
 }
-static ssize_t mca_show_pos(struct device *dev, char *buf, size_t count,
-			    loff_t off)
+static ssize_t mca_show_pos(struct device *dev, char *buf)
 {
 	/* enough for 8 two byte hex chars plus space and new line */
-	char mybuf[26];
 	int j, len=0;
 	struct mca_device *mca_dev = to_mca_device(dev);
 
 	for(j=0; j<8; j++)
-		len += sprintf(mybuf+len, "%02x ", mca_dev->pos[j]);
+		len += sprintf(buf+len, "%02x ", mca_dev->pos[j]);
 	/* change last trailing space to new line */
-	mybuf[len-1] = '\n';
-	len++;
-	if(len > off) {
-		len = min((size_t)(len - off), count);
-		memcpy(buf + off, mybuf + off, len);
-	} else {
-		len = 0;
-	}
+	buf[len-1] = '\n';
 	return len;
 }
 

drivers/net/aironet4500_card.c

@@ -455,10 +455,7 @@ static void awc_pnp_release(void) {
 
 		if (awc_proc_unset_fun)
 			awc_proc_unset_fun(i);
-		if (isapnp_cfg_begin(logdev->PNP_BUS->PNP_BUS_NUMBER, logdev->PNP_DEV_NUMBER)<0)
-			printk("isapnp cfg failed at release \n");
-		isapnp_deactivate(logdev->PNP_DEV_NUMBER);
-		isapnp_cfg_end();
+		pnp_device_detach(logdev);
 
 		release_region(aironet4500_devices[i]->base_addr, AIRONET4X00_IO_SIZE);
 //		release_region(isa_cisaddr, AIRONET4X00_CIS_SIZE, "aironet4x00 cis");

drivers/net/ne.c

@@ -206,13 +206,14 @@ static int __init ne_probe_isapnp(struct net_device *dev)
 			if (pnp_device_attach(idev) < 0)
 				continue;
 			if (pnp_activate_dev(idev, NULL) < 0) {
-			      __again:
 			      	pnp_device_detach(idev);
 			      	continue;
 			}
 			/* if no io and irq, search for next */
-			if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0))
-				goto __again;
+			if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0)) {
+				pnp_device_detach(idev);
+				continue;
+			}
 			/* found it */
 			dev->base_addr = pnp_port_start(idev, 0);
 			dev->irq = pnp_irq(idev, 0);
@@ -786,9 +787,9 @@ void cleanup_module(void)
 		struct net_device *dev = &dev_ne[this_dev];
 		if (dev->priv != NULL) {
 			void *priv = dev->priv;
-			struct pci_dev *idev = (struct pci_dev *)ei_status.priv;
+			struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
 			if (idev)
-				idev->deactivate(idev);
+				pnp_device_detach(idev);
 			free_irq(dev->irq, dev);
 			release_region(dev->base_addr, NE_IO_EXTENT);
 			unregister_netdev(dev);

drivers/net/smc-ultra.c

@@ -550,9 +550,9 @@ cleanup_module(void)
 			int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET;
 
 #ifdef __ISAPNP__
-			struct pci_dev *idev = (struct pci_dev *)ei_status.priv;
+			struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
 			if (idev)
-				idev->deactivate(idev);
+				pnp_device_detach(idev);
 #endif
 
 			unregister_netdev(dev);

drivers/pnp/card.c

@@ -22,9 +22,9 @@
 
 LIST_HEAD(pnp_cards);
 
-static const struct pnp_card_id * match_card(struct pnpc_driver *drv, struct pnp_card *card)
+static const struct pnp_card_device_id * match_card(struct pnpc_driver *drv, struct pnp_card *card)
 {
-	const struct pnp_card_id *drv_id = drv->id_table;
+	const struct pnp_card_device_id *drv_id = drv->id_table;
 	while (*drv_id->id){
 		if (compare_pnp_id(card->id,drv_id->id))
 			return drv_id;
@@ -216,18 +216,15 @@ struct pnp_dev * pnp_request_card_device(struct pnp_card *card, const char *id,
 	return NULL;
 
 found:
-	spin_lock(&pnp_lock);
-	if(dev->status != PNP_READY){
-		spin_unlock(&pnp_lock);
+	if (pnp_device_attach(dev) < 0)
 		return NULL;
-	}
-	dev->status = PNP_ATTACHED;
-	spin_unlock(&pnp_lock);
 	cdrv = to_pnpc_driver(card->dev.driver);
 	if (dev->active == 0) {
 		if (!(cdrv->flags & PNPC_DRIVER_DO_NOT_ACTIVATE)) {
-			if(pnp_activate_dev(dev,NULL)<0)
+			if(pnp_activate_dev(dev,NULL)<0) {
+				pnp_device_detach(dev);
 				return NULL;
+			}
 		}
 	} else {
 		if ((cdrv->flags & PNPC_DRIVER_DO_NOT_ACTIVATE))
@@ -250,10 +247,8 @@ void pnp_release_card_device(struct pnp_dev *dev)
 {
 	spin_lock(&pnp_lock);
 	list_del(&dev->rdev_list);
-	if (dev->status == PNP_ATTACHED)
-		dev->status = PNP_READY;
 	spin_unlock(&pnp_lock);
-	pnp_disable_dev(dev);
+	pnp_device_detach(dev);
 }
 
 static void pnpc_recover_devices(struct pnp_card *card)
@@ -291,7 +286,7 @@ static int pnpc_card_probe(struct device *dev)
 	int error = 0;
 	struct pnpc_driver *drv = to_pnpc_driver(dev->driver);
 	struct pnp_card *card = to_pnp_card(dev);
-	const struct pnp_card_id *card_id = NULL;
+	const struct pnp_card_device_id *card_id = NULL;
 
 	pnp_dbg("pnp: match found with the PnP card '%s' and the driver '%s'", dev->bus_id,drv->name);
 

drivers/pnp/interface.c

@@ -284,7 +284,7 @@ static ssize_t pnp_show_current_resources(struct device *dmdev, char *buf)
 }
 
 static ssize_t
-pnp_set_current_resources(struct device * dmdev, const char * buf)
+pnp_set_current_resources(struct device * dmdev, const char * buf, size_t count)
 {
 	struct pnp_dev *dev = to_pnp_dev(dmdev);
 	char	command[20];
@@ -326,7 +326,7 @@ pnp_set_current_resources(struct device * dmdev, const char * buf)
 		goto done;
 	}
  done:
-	return error < 0 ? error : strlen(buf);
+	return error < 0 ? error : count;
 }
 
 static DEVICE_ATTR(resources,S_IRUGO | S_IWUSR,

drivers/pnp/isapnp/core.c

@@ -102,7 +102,6 @@ static int isapnp_detected;
 /* some prototypes */
 
 static int isapnp_config_prepare(struct pnp_dev *dev);
-extern struct pnp_protocol isapnp_card_protocol;
 extern struct pnp_protocol isapnp_protocol;
 
 static inline void write_data(unsigned char x)
@@ -1125,7 +1124,7 @@ int __init isapnp_init(void)
 	isapnp_build_device_list();
 	cards = 0;
 
-	protocol_for_each_card(&isapnp_card_protocol,card) {
+	protocol_for_each_card(&isapnp_protocol,card) {
 		cards++;
 		if (isapnp_verbose) {
 			printk(KERN_INFO "isapnp: Card '%s'\n", card->name[0]?card->name:"Unknown");

drivers/s390/block/dasd.c

@@ -1949,28 +1949,22 @@ dasd_generic_set_offline (struct ccw_device *cdev)
  * readonly controls the readonly status of a dasd
  */
 static ssize_t
-dasd_ro_show(struct device *dev, char *buf, size_t count, loff_t off)
+dasd_ro_show(struct device *dev, char *buf)
 {
 	dasd_device_t *device;
 
-	if (off)
-		return 0;
-
 	device = dev->driver_data;
 	if (!device)
-		return snprintf(buf, count, "n/a\n");
+		return snprintf(buf, PAGE_SIZE, "n/a\n");
 
-	return snprintf(buf, count, device->ro_flag ? "1\n" : "0\n");
+	return snprintf(buf, PAGE_SIZE, device->ro_flag ? "1\n" : "0\n");
 }
 
 static ssize_t
-dasd_ro_store(struct device *dev, const char *buf, size_t count, loff_t off)
+dasd_ro_store(struct device *dev, const char *buf, size_t count)
 {
 	dasd_device_t *device = dev->driver_data;
 
-	if (off)
-		return 0;
-
 	if (device)
 		device->ro_flag = (buf[0] == '1') ? 1 : 0;
 	return count;
@@ -1984,29 +1978,22 @@ static DEVICE_ATTR(readonly, 0644, dasd_ro_show, dasd_ro_store);
  */
 /* TODO: Implement */
 static ssize_t 
-dasd_use_diag_show(struct device *dev, char *buf, size_t count, loff_t off)
+dasd_use_diag_show(struct device *dev, char *buf)
 {
 	dasd_device_t *device;
 
-	if (off)
-		return 0;
-
 	device = dev->driver_data;
 	if (!device)
-		return snprintf(buf, count, "n/a\n");
+		return sprintf(buf, "n/a\n");
 
-	return snprintf(buf, count, device->use_diag_flag ? "1\n" : "0\n");
+	return sprintf(buf, device->use_diag_flag ? "1\n" : "0\n");
 }
 
 static ssize_t
-dasd_use_diag_store(struct device *dev, const char *buf, 
-		    size_t count, loff_t off)
+dasd_use_diag_store(struct device *dev, const char *buf, size_t count)
 {
 	dasd_device_t *device = dev->driver_data;
 
-	if (off)
-		return 0;
-
 	if (device)
 		device->use_diag_flag = (buf[0] == '1') ? 1 : 0;
 	return count;
@@ -2020,43 +2007,38 @@ DEVICE_ATTR(use_diag, 0644, dasd_use_diag_show, dasd_use_diag_store);
  * an inaccaptable interface */
 /* TODO: Split this up into smaller files! */
 static ssize_t
-dasd_devices_show(struct device *dev, char *buf, size_t count, loff_t off)
+dasd_devices_show(struct device *dev, char *buf)
 {
 	
 	dasd_device_t *device;
 	dasd_devmap_t *devmap;
 
-	if (off)	/* ignore partial write */
-		return 0;
-
 	devmap = NULL;
 	device = dev->driver_data;
 	if (device)
 		devmap = dasd_devmap_from_devno(device->devno);
 
 	if (!devmap)
-		return snprintf(buf, count, "unused\n");
+		return sprintf(buf, "unused\n");
 
-	return min ((size_t) dasd_devices_print(devmap, buf), count);
+	return min ((size_t) dasd_devices_print(devmap, buf), PAGE_SIZE);
 }
 
 static DEVICE_ATTR(dasd, 0444, dasd_devices_show, 0);
 #endif
 
 static ssize_t
-dasd_discipline_show(struct device *dev, char *buf, size_t count, loff_t off)
+dasd_discipline_show(struct device *dev, char *buf)
 {
 	dasd_device_t *device;
 
-	if (off)
-		return 0;
 	device = dev->driver_data;
 	if (!device || !device->discipline)
-		return snprintf(buf, count, "none\n");
-	return snprintf(buf, count, "%s\n", device->discipline->name);
+		return sprintf(buf, "none\n");
+	return snprintf(buf, PAGE_SIZE, "%s\n", device->discipline->name);
 }
 
-static DEVICE_ATTR(discipline, 0444, dasd_discipline_show, 0);
+static DEVICE_ATTR(discipline, 0444, dasd_discipline_show, NULL);
 
 static int
 dasd_add_sysfs_files(struct ccw_device *cdev)

drivers/s390/cio/ccwgroup.c

@@ -185,15 +185,11 @@ ccwgroup_set_offline(struct ccwgroup_device *gdev)
 }
 
 static ssize_t
-ccwgroup_online_store (struct device *dev, const char *buf, size_t count,
-			loff_t off)
+ccwgroup_online_store (struct device *dev, const char *buf, size_t count)
 {
 	struct ccwgroup_device *gdev;
 	unsigned int value;
 
-	if (off)
-		return 0;
-
 	gdev = to_ccwgroupdev(dev);
 	if (!dev->driver)
 		return count;
@@ -209,16 +205,13 @@ ccwgroup_online_store (struct device *dev, const char *buf, size_t count,
 }
 
 static ssize_t
-ccwgroup_online_show (struct device *dev, char *buf, size_t count, loff_t off)
+ccwgroup_online_show (struct device *dev, char *buf)
 {
 	int online;
 
-	if (off)
-		return 0;
-
 	online = (to_ccwgroupdev(dev)->state == CCWGROUP_ONLINE);
 
-	return snprintf(buf, count, online ? "1\n" : "0\n");
+	return sprintf(buf, online ? "1\n" : "0\n");
 }
 
 static DEVICE_ATTR(online, 0644, ccwgroup_online_show, ccwgroup_online_store);

drivers/s390/cio/chsc.c

@@ -606,30 +606,30 @@ s390_vary_chpid( __u8 chpid, int on)
  * Files for the channel path entries.
  */
 static ssize_t
-chp_status_show(struct device *dev, char *buf, size_t count, loff_t off)
+chp_status_show(struct device *dev, char *buf)
 {
 	struct sys_device *sdev = container_of(dev, struct sys_device, dev);
 	struct channel_path *chp = container_of(sdev, struct channel_path, sdev);
 
 	if (!chp)
-		return off ? 0 : count;
+		return 0;
 
 	switch(chp->state) {
 	case CHP_OFFLINE:
-		return off ? 0 : snprintf(buf, count, "n/a\n");
+		return snprintf(buf, count, "n/a\n");
 	case CHP_LOGICALLY_OFFLINE:
-		return off ? 0 : snprintf(buf, count, "logically offline\n");
+		return snprintf(buf, count, "logically offline\n");
 	case CHP_STANDBY:
-		return off ? 0 : snprintf(buf, count, "n/a\n");
+		return snprintf(buf, count, "n/a\n");
 	case CHP_ONLINE:
-		return off ? 0 : snprintf(buf, count, "online\n");
+		return snprintf(buf, count, "online\n");
 	default:
-		return off ? 0 : count;
+		return 0;
 	}
 }
 
 static ssize_t
-chp_status_write(struct device *dev, const char *buf, size_t count, loff_t off)
+chp_status_write(struct device *dev, const char *buf, size_t count)
 {
 	struct sys_device *sdev = container_of(dev, struct sys_device, dev);
 	struct channel_path *cp = container_of(sdev, struct channel_path, sdev);
@@ -637,9 +637,6 @@ chp_status_write(struct device *dev, const char *buf, size_t count, loff_t off)
 	int num_args;
 	int error;
 
-	if (off)
-		return 0;
-
 	num_args = sscanf(buf, "%5s", cmd);
 	if (!num_args)
 		return count;

drivers/s390/cio/device.c

@@ -157,7 +157,7 @@ module_exit(cleanup_ccw_bus_type);
  * TODO: Split chpids and pimpampom up? Where is "in use" in the tree?
  */
 static ssize_t
-chpids_show (struct device * dev, char * buf, size_t count, loff_t off)
+chpids_show (struct device * dev, char * buf)
 {
 	struct subchannel *sch = to_subchannel(dev);
 	struct ssd_info *ssd = &sch->ssd_info;
@@ -168,48 +168,48 @@ chpids_show (struct device * dev, char * buf, size_t count, loff_t off)
 		ret += sprintf (buf+ret, "%02x ", ssd->chpid[chp]);
 
 	ret += sprintf (buf+ret, "\n");
-	return off ? 0 : min((ssize_t)count, ret);
+	return min((ssize_t)PAGE_SIZE, ret);
 }
 
 static ssize_t
-pimpampom_show (struct device * dev, char * buf, size_t count, loff_t off)
+pimpampom_show (struct device * dev, char * buf)
 {
 	struct subchannel *sch = to_subchannel(dev);
 	struct pmcw *pmcw = &sch->schib.pmcw;
 
-	return off ? 0 : snprintf (buf, count, "%02x %02x %02x\n",
-				   pmcw->pim, pmcw->pam, pmcw->pom);
+	return sprintf (buf, "%02x %02x %02x\n",
+			pmcw->pim, pmcw->pam, pmcw->pom);
 }
 
 static ssize_t
-devtype_show (struct device *dev, char *buf, size_t count, loff_t off)
+devtype_show (struct device *dev, char *buf)
 {
 	struct ccw_device *cdev = to_ccwdev(dev);
 	struct ccw_device_id *id = &(cdev->id);
 
 	if (id->dev_type != 0)
-		return off ? 0 : snprintf(buf, count, "%04x/%02x\n",
-					  id->dev_type, id->dev_model);
+		return sprintf(buf, "%04x/%02x\n",
+				id->dev_type, id->dev_model);
 	else
-		return off ? 0 : snprintf(buf, count, "n/a\n");
+		return sprintf(buf, "n/a\n");
 }
 
 static ssize_t
-cutype_show (struct device *dev, char *buf, size_t count, loff_t off)
+cutype_show (struct device *dev, char *buf)
 {
 	struct ccw_device *cdev = to_ccwdev(dev);
 	struct ccw_device_id *id = &(cdev->id);
 
-	return off ? 0 : snprintf(buf, count, "%04x/%02x\n",
-				  id->cu_type, id->cu_model);
+	return sprintf(buf, "%04x/%02x\n",
+		       id->cu_type, id->cu_model);
 }
 
 static ssize_t
-online_show (struct device *dev, char *buf, size_t count, loff_t off)
+online_show (struct device *dev, char *buf)
 {
 	struct ccw_device *cdev = to_ccwdev(dev);
 
-	return off ? 0 : snprintf(buf, count, cdev->online ? "yes\n" : "no\n");
+	return sprintf(buf, cdev->online ? "yes\n" : "no\n");
 }
 
 void
@@ -256,14 +256,11 @@ ccw_device_set_online(struct ccw_device *cdev)
 }
 
 static ssize_t
-online_store (struct device *dev, const char *buf, size_t count, loff_t off)
+online_store (struct device *dev, const char *buf, size_t count)
 {
 	struct ccw_device *cdev = to_ccwdev(dev);
 	unsigned int value;
 
-	if (off)
-		return 0;
-
 	if (!cdev->drv)
 		return count;
 

drivers/s390/net/ctcmain.c

@@ -2512,27 +2512,24 @@ ctc_stats(struct net_device * dev)
 #define CTRL_BUFSIZE 40
 
 static ssize_t
-buffer_show(struct device *dev, char *buf, size_t count, loff_t off)
+buffer_show(struct device *dev, char *buf)
 {
 	struct ctc_priv *priv;
 
 	priv = dev->driver_data;
 	if (!priv)
 		return -ENODEV;
-	return off ? 0 : snprintf(buf, count, "%d\n",
-				  priv->channel[READ]->max_bufsize);
+	return sprintf(buf, "%d\n",
+		       priv->channel[READ]->max_bufsize);
 }
 
 static ssize_t
-buffer_write(struct device *dev, const char *buf, size_t count, loff_t off)
+buffer_write(struct device *dev, const char *buf, size_t count)
 {
 	struct ctc_priv *priv;
 	struct net_device *ndev;
 	int bs1;
 
-	if (off)
-		return 0;
-
 	priv = dev->driver_data;
 	if (!priv)
 		return -ENODEV;

drivers/s390/net/lcs.c

@@ -1637,32 +1637,30 @@ lcs_open_device(struct net_device *dev)
  * show function for portno called by cat or similar things
  */
 static ssize_t
-lcs_portno_show (struct device *dev, char *buf, size_t count,
-		 loff_t off)
+lcs_portno_show (struct device *dev, char *buf)
 {
         struct lcs_card *card;
 
 	card = (struct lcs_card *)dev->driver_data;
 
-        if (off || !card)
+        if (!card)
                 return 0;
 
-        return snprintf(buf, count, "%d\n", card->portno);
+        return sprintf(buf, "%d\n", card->portno);
 }
 
 /**
  * store the value which is piped to file portno
  */
 static ssize_t
-lcs_portno_store (struct device *dev, const char *buf, size_t count,
-		  loff_t off)
+lcs_portno_store (struct device *dev, const char *buf, size_t count)
 {
         struct lcs_card *card;
         int value;
 
 	card = (struct lcs_card *)dev->driver_data;
 
-        if (off || !card)
+        if (!card)
                 return 0;
 
         sscanf(buf, "%u", &value);

drivers/s390/net/netiucv.c

@@ -1259,16 +1259,16 @@ netiucv_change_mtu (net_device * dev, int new_mtu)
 #define CTRL_BUFSIZE 40
 
 static ssize_t
-user_show (struct device *dev, char *buf, size_t count, loff_t off)
+user_show (struct device *dev, char *buf)
 {
 	netiucv_priv *priv = dev->driver_data;
 
-	return off ? 0 : snprintf(buf, count, "%s\n", 
-				  netiucv_printname(priv->conn->userid));
+	return snprintf(buf, PAGE_SIZE, "%s\n", 
+			netiucv_printname(priv->conn->userid));
 }
 
 static ssize_t
-user_write (struct device *dev, const char *buf, size_t count, loff_t off)
+user_write (struct device *dev, const char *buf, size_t count)
 {
 	netiucv_priv *priv = dev->driver_data;
 	struct net_device *ndev = container_of((void *)priv, struct net_device, priv);
@@ -1305,16 +1305,16 @@ user_write (struct device *dev, const char *buf, size_t count, loff_t off)
 static DEVICE_ATTR(user, 0644, user_show, user_write);
 
 static ssize_t
-buffer_show (struct device *dev, char *buf, size_t count, loff_t off)
+buffer_show (struct device *dev, char *buf)
 {
 	netiucv_priv *priv = dev->driver_data;
 
-	return off ? 0 : snprintf(buf, count, "%d\n", 
-				  priv->conn->max_buffsize);
+	return sprintf(buf, "%d\n", 
+		       priv->conn->max_buffsize);
 }
 
 static ssize_t
-buffer_write (struct device *dev, const char *buf, size_t count, loff_t off)
+buffer_write (struct device *dev, const char *buf, size_t count)
 {
 	netiucv_priv *priv = dev->driver_data;
 	struct net_device *ndev = container_of((void *)priv, struct net_device, priv);
@@ -1352,38 +1352,37 @@ buffer_write (struct device *dev, const char *buf, size_t count, loff_t off)
 static DEVICE_ATTR(buffer, 0644, buffer_show, buffer_write);
 
 static ssize_t
-dev_fsm_show (struct device *dev, char *buf, size_t count, loff_t off)
+dev_fsm_show (struct device *dev, char *buf)
 {
 	netiucv_priv *priv = dev->driver_data;
 	
-	return off ? 0 : snprintf(buf, count, "%s\n",
-				  fsm_getstate_str(priv->fsm));
+	return snprintf(buf, PAGE_SIZE, "%s\n",
+			fsm_getstate_str(priv->fsm));
 }
 
 static DEVICE_ATTR(device_fsm_state, 0444, dev_fsm_show, NULL);
 
 static ssize_t
-conn_fsm_show (struct device *dev, char *buf, size_t count, loff_t off)
+conn_fsm_show (struct device *dev, char *buf)
 {
 	netiucv_priv *priv = dev->driver_data;
 	
-	return off ? 0 : snprintf(buf, count, "%s\n",
-				  fsm_getstate_str(priv->conn->fsm));
+	return snprintf(buf, PAGE_SIZE, "%s\n",
+			fsm_getstate_str(priv->conn->fsm));
 }
 
 static DEVICE_ATTR(connection_fsm_state, 0444, conn_fsm_show, NULL);
 
 static ssize_t
-maxmulti_show (struct device *dev, char *buf, size_t count, loff_t off)
+maxmulti_show (struct device *dev, char *buf)
 {
 	netiucv_priv *priv = dev->driver_data;
 	
-	return off ? 0 : snprintf(buf, count, "%ld\n",
-				  priv->conn->prof.maxmulti);
+	return sprintf(buf, "%ld\n", priv->conn->prof.maxmulti);
 }
 
 static ssize_t
-maxmulti_write (struct device *dev, const char *buf, size_t count, loff_t off)
+maxmulti_write (struct device *dev, const char *buf, size_t count)
 {
 	netiucv_priv *priv = dev->driver_data;
 	
@@ -1394,16 +1393,15 @@ maxmulti_write (struct device *dev, const char *buf, size_t count, loff_t off)
 static DEVICE_ATTR(max_tx_buffer_used, 0644, maxmulti_show, maxmulti_write);
 
 static ssize_t
-maxcq_show (struct device *dev, char *buf, size_t count, loff_t off)
+maxcq_show (struct device *dev, char *buf)
 {
 	netiucv_priv *priv = dev->driver_data;
 	
-	return off ? 0 : snprintf(buf, count, "%ld\n",
-				  priv->conn->prof.maxcqueue);
+	return sprintf(buf, "%ld\n", priv->conn->prof.maxcqueue);
 }
 
 static ssize_t
-maxcq_write (struct device *dev, const char *buf, size_t count, loff_t off)
+maxcq_write (struct device *dev, const char *buf, size_t count)
 {
 	netiucv_priv *priv = dev->driver_data;
 	
@@ -1414,16 +1412,15 @@ maxcq_write (struct device *dev, const char *buf, size_t count, loff_t off)
 static DEVICE_ATTR(max_chained_skbs, 0644, maxcq_show, maxcq_write);
 
 static ssize_t
-sdoio_show (struct device *dev, char *buf, size_t count, loff_t off)
+sdoio_show (struct device *dev, char *buf)
 {
 	netiucv_priv *priv = dev->driver_data;
 	
-	return off ? 0 : snprintf(buf, count, "%ld\n",
-				  priv->conn->prof.doios_single);
+	return sprintf(buf, "%ld\n", priv->conn->prof.doios_single);
 }
 
 static ssize_t
-sdoio_write (struct device *dev, const char *buf, size_t count, loff_t off)
+sdoio_write (struct device *dev, const char *buf, size_t count)
 {
 	netiucv_priv *priv = dev->driver_data;
 	
@@ -1434,16 +1431,15 @@ sdoio_write (struct device *dev, const char *buf, size_t count, loff_t off)
 static DEVICE_ATTR(tx_single_write_ops, 0644, sdoio_show, sdoio_write);
 
 static ssize_t
-mdoio_show (struct device *dev, char *buf, size_t count, loff_t off)
+mdoio_show (struct device *dev, char *buf)
 {
 	netiucv_priv *priv = dev->driver_data;
 	
-	return off ? 0 : snprintf(buf, count, "%ld\n",
-				  priv->conn->prof.doios_multi);
+	return sprintf(buf, "%ld\n", priv->conn->prof.doios_multi);
 }
 
 static ssize_t
-mdoio_write (struct device *dev, const char *buf, size_t count, loff_t off)
+mdoio_write (struct device *dev, const char *buf, size_t count)
 {
 	netiucv_priv *priv = dev->driver_data;
 	
@@ -1454,16 +1450,15 @@ mdoio_write (struct device *dev, const char *buf, size_t count, loff_t off)
 static DEVICE_ATTR(tx_multi_write_ops, 0644, mdoio_show, mdoio_write);
 
 static ssize_t
-txlen_show (struct device *dev, char *buf, size_t count, loff_t off)
+txlen_show (struct device *dev, char *buf)
 {
 	netiucv_priv *priv = dev->driver_data;
 	
-	return off ? 0 : snprintf(buf, count, "%ld\n",
-				  priv->conn->prof.txlen);
+	return sprintf(buf, "%ld\n", priv->conn->prof.txlen);
 }
 
 static ssize_t
-txlen_write (struct device *dev, const char *buf, size_t count, loff_t off)
+txlen_write (struct device *dev, const char *buf, size_t count)
 {
 	netiucv_priv *priv = dev->driver_data;
 	
@@ -1474,16 +1469,15 @@ txlen_write (struct device *dev, const char *buf, size_t count, loff_t off)
 static DEVICE_ATTR(netto_bytes, 0644, txlen_show, txlen_write);
 
 static ssize_t
-txtime_show (struct device *dev, char *buf, size_t count, loff_t off)
+txtime_show (struct device *dev, char *buf)
 {
 	netiucv_priv *priv = dev->driver_data;
 	
-	return off ? 0 : snprintf(buf, count, "%ld\n",
-				  priv->conn->prof.tx_time);
+	return snprintf(buf, count, "%ld\n", priv->conn->prof.tx_time);
 }
 
 static ssize_t
-txtime_write (struct device *dev, const char *buf, size_t count, loff_t off)
+txtime_write (struct device *dev, const char *buf)
 {
 	netiucv_priv *priv = dev->driver_data;
 	

drivers/scsi/osst.c

@@ -5325,17 +5325,17 @@ __setup("osst=", osst_setup);
 #endif
 
 /* Driverfs file support */
-static ssize_t osst_device_kdev_read(struct device *driverfs_dev, char *page, size_t count, loff_t off)
+static ssize_t osst_device_kdev_read(struct device *driverfs_dev, char *page)
 {
 	kdev_t kdev; 
 	kdev.value=(int)(long)driverfs_dev->driver_data;
-	return off ? 0 : sprintf(page, "%x\n",kdev.value);
+	return sprintf(page, "%x\n",kdev.value);
 }
 static DEVICE_ATTR(kdev,S_IRUGO,osst_device_kdev_read,NULL);
 
-static ssize_t osst_device_type_read(struct device *driverfs_dev, char *page, size_t count, loff_t off) 
+static ssize_t osst_device_type_read(struct device *driverfs_dev, char *page) 
 {
-	return off ? 0 : sprintf (page, "CHR\n");
+	return sprintf (page, "CHR\n");
 }
 static DEVICE_ATTR(type,S_IRUGO,osst_device_type_read,NULL);
 

drivers/scsi/scsi_sysfs.c

@@ -158,12 +158,12 @@ static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL)
 	show_function(field, format_string)				\
 									\
 static ssize_t								\
-store_##field (struct device *dev, const char *buf)			\
+store_##field (struct device *dev, const char *buf, size_t count)	\
 {									\
 	struct scsi_device *sdev;					\
 	sdev = to_scsi_device(dev);					\
 	snscanf (buf, 20, format_string, &sdev->field);			\
-	return strlen(buf);						\
+	return count;							\
 }									\
 static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, show_##field, store_##field)
 
@@ -175,7 +175,7 @@ static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, show_##field, store_##field)
 	show_function(field, "%d\n")					\
 									\
 static ssize_t								\
-store_##field (struct device *dev, const char *buf)			\
+store_##field (struct device *dev, const char *buf, size_t count)	\
 {									\
 	int ret;							\
 	struct scsi_device *sdev;					\
@@ -183,7 +183,7 @@ store_##field (struct device *dev, const char *buf)			\
 	if (ret >= 0)	{						\
 		sdev = to_scsi_device(dev);				\
 		sdev->field = ret;					\
-		ret = strlen(buf);					\
+		ret = count;						\
 	}								\
 	return ret;							\
 }									\

drivers/scsi/st.c

@@ -3615,19 +3615,17 @@ __setup("st=", st_setup);
 #endif
 
 /* Driverfs file support */
-static ssize_t st_device_kdev_read(struct device *driverfs_dev, 
-				   char *page, size_t count, loff_t off)
+static ssize_t st_device_kdev_read(struct device *dev, char *page)
 {
 	kdev_t kdev; 
-	kdev.value=(int)(long)driverfs_dev->driver_data;
-	return off ? 0 : sprintf(page, "%x\n",kdev.value);
+	kdev.value=(int)dev->driver_data;
+	return sprintf(page, "%x\n",kdev.value);
 }
 static DEVICE_ATTR(kdev,S_IRUGO,st_device_kdev_read,NULL);
 
-static ssize_t st_device_type_read(struct device *driverfs_dev, 
-				   char *page, size_t count, loff_t off) 
+static ssize_t st_device_type_read(struct device *ev, char * page)
 {
-	return off ? 0 : sprintf (page, "CHR\n");
+	return sprintf (page, "CHR\n");
 }
 static DEVICE_ATTR(type,S_IRUGO,st_device_type_read,NULL);
 

fs/nfsd/nfsproc.c

@@ -482,7 +482,7 @@ nfsd_proc_readdir(struct svc_rqst *rqstp, struct nfsd_readdirargs *argp,
 
 	resp->count = resp->buffer - argp->buffer;
 	if (resp->offset)
-		*resp->offset = (u32)offset;
+		*resp->offset = htonl(offset);
 
 	fh_put(&argp->fh);
 	return nfserr;

fs/sysfs/inode.c

@@ -167,14 +167,15 @@ subsys_attr_show(struct kobject * kobj, struct attribute * attr, char * page)
 }
 
 static ssize_t 
-subsys_attr_store(struct kobject * kobj, struct attribute * attr, const char * page)
+subsys_attr_store(struct kobject * kobj, struct attribute * attr, 
+		  const char * page, size_t count)
 {
 	struct subsystem * s = to_subsys(kobj);
 	struct subsys_attribute * sattr = to_sattr(attr);
 	ssize_t ret = 0;
 
 	if (sattr->store)
-		ret = sattr->store(s,page);
+		ret = sattr->store(s,page,count);
 	return ret;
 }
 
@@ -247,7 +248,7 @@ static int flush_read_buffer(struct sysfs_buffer * buffer, char * buf,
 	error = copy_to_user(buf,buffer->page + *ppos,count);
 	if (!error)
 		*ppos += count;
-	return error ? error : count;
+	return error ? -EFAULT : count;
 }
 
 /**
@@ -308,7 +309,7 @@ fill_write_buffer(struct sysfs_buffer * buffer, const char * buf, size_t count)
 	if (count >= PAGE_SIZE)
 		count = PAGE_SIZE - 1;
 	error = copy_from_user(buffer->page,buf,count);
-	return error ? error : count;
+	return error ? -EFAULT : count;
 }
 
 
@@ -322,13 +323,14 @@ fill_write_buffer(struct sysfs_buffer * buffer, const char * buf, size_t count)
  *	passing the buffer that we acquired in fill_write_buffer().
  */
 
-static int flush_write_buffer(struct file * file, struct sysfs_buffer * buffer)
+static int 
+flush_write_buffer(struct file * file, struct sysfs_buffer * buffer, size_t count)
 {
 	struct attribute * attr = file->f_dentry->d_fsdata;
 	struct kobject * kobj = file->f_dentry->d_parent->d_fsdata;
 	struct sysfs_ops * ops = buffer->ops;
 
-	return ops->store(kobj,attr,buffer->page);
+	return ops->store(kobj,attr,buffer->page,count);
 }
 
 
@@ -356,7 +358,7 @@ sysfs_write_file(struct file *file, const char *buf, size_t count, loff_t *ppos)
 
 	count = fill_write_buffer(buffer,buf,count);
 	if (count > 0)
-		count = flush_write_buffer(file,buffer);
+		count = flush_write_buffer(file,buffer,count);
 	if (count > 0)
 		*ppos += count;
 	return count;

include/linux/device.h

@@ -98,7 +98,7 @@ int bus_for_each_drv(struct bus_type * bus, struct device_driver * start,
 struct bus_attribute {
 	struct attribute	attr;
 	ssize_t (*show)(struct bus_type *, char * buf);
-	ssize_t (*store)(struct bus_type *, const char * buf);
+	ssize_t (*store)(struct bus_type *, const char * buf, size_t count);
 };
 
 #define BUS_ATTR(_name,_mode,_show,_store)	\
@@ -141,7 +141,7 @@ extern void put_driver(struct device_driver * drv);
 struct driver_attribute {
 	struct attribute	attr;
 	ssize_t (*show)(struct device_driver *, char * buf);
-	ssize_t (*store)(struct device_driver *, const char * buf);
+	ssize_t (*store)(struct device_driver *, const char * buf, size_t count);
 };
 
 #define DRIVER_ATTR(_name,_mode,_show,_store)	\
@@ -182,7 +182,7 @@ extern void put_devclass(struct device_class *);
 struct devclass_attribute {
 	struct attribute	attr;
 	ssize_t (*show)(struct device_class *, char * buf);
-	ssize_t (*store)(struct device_class *, const char * buf);
+	ssize_t (*store)(struct device_class *, const char * buf, size_t count);
 };
 
 #define DEVCLASS_ATTR(_name,_str,_mode,_show,_store)	\
@@ -320,7 +320,7 @@ extern void device_release_driver(struct device * dev);
 struct device_attribute {
 	struct attribute	attr;
 	ssize_t (*show)(struct device * dev, char * buf);
-	ssize_t (*store)(struct device * dev, const char * buf);
+	ssize_t (*store)(struct device * dev, const char * buf, size_t count);
 };
 
 #define DEVICE_ATTR(_name,_mode,_show,_store) \

include/linux/elf.h

@@ -156,11 +156,12 @@ typedef __s64	Elf64_Sxword;
 #define STT_SECTION 3
 #define STT_FILE    4
 
-#define ELF32_ST_BIND(x) ((x) >> 4)
-#define ELF32_ST_TYPE(x) (((unsigned int) x) & 0xf)
-
-#define ELF64_ST_BIND(x) ((x) >> 4)
-#define ELF64_ST_TYPE(x) (((unsigned int) x) & 0xf)
+#define ELF_ST_BIND(x)		((x) >> 4)
+#define ELF_ST_TYPE(x)		(((unsigned int) x) & 0xf)
+#define ELF32_ST_BIND(x)	ELF_ST_BIND(x)
+#define ELF32_ST_TYPE(x)	ELF_ST_TYPE(x)
+#define ELF64_ST_BIND(x)	ELF_ST_BIND(x)
+#define ELF64_ST_TYPE(x)	ELF_ST_TYPE(x)
 
 /* Symbolic values for the entries in the auxiliary table
    put on the initial stack */

include/linux/kobject.h

@@ -166,7 +166,7 @@ static inline void subsys_put(struct subsystem * s)
 struct subsys_attribute {
 	struct attribute attr;
 	ssize_t (*show)(struct subsystem *, char *);
-	ssize_t (*store)(struct subsystem *, const char *); 
+	ssize_t (*store)(struct subsystem *, const char *, size_t); 
 };
 
 extern int subsys_create_file(struct subsystem * , struct subsys_attribute *);

include/linux/moduleloader.h

@@ -5,14 +5,6 @@
 #include <linux/module.h>
 #include <linux/elf.h>
 
-/* Helper function for arch-specific module loaders */
-unsigned long find_symbol_internal(Elf_Shdr *sechdrs,
-				   unsigned int symindex,
-				   const char *strtab,
-				   const char *name,
-				   struct module *mod,
-				   struct kernel_symbol_group **group);
-
 /* These must be implemented by the specific architecture */
 
 /* Adjust arch-specific sections.  Return 0 on success.  */

include/linux/pnp.h

@@ -189,7 +189,7 @@ struct pnp_device_id {
 	unsigned long driver_data;	/* data private to the driver */
 };
 
-struct pnp_card_id {
+struct pnp_card_device_id {
 	char id[7];
 	unsigned long driver_data;	/* data private to the driver */
 	struct {
@@ -216,9 +216,9 @@ struct pnp_driver {
 struct pnpc_driver {
 	struct list_head node;
 	char *name;
-	const struct pnp_card_id *id_table;
+	const struct pnp_card_device_id *id_table;
 	unsigned int flags;
-	int  (*probe)  (struct pnp_card *card, const struct pnp_card_id *card_id);
+	int  (*probe)  (struct pnp_card *card, const struct pnp_card_device_id *card_id);
 	void (*remove) (struct pnp_card *card);
 	struct device_driver driver;
 };

include/linux/sysfs.h

@@ -18,7 +18,7 @@ struct attribute {
 
 struct sysfs_ops {
 	ssize_t	(*show)(struct kobject *, struct attribute *,char *);
-	ssize_t	(*store)(struct kobject *,struct attribute *,const char *);
+	ssize_t	(*store)(struct kobject *,struct attribute *,const char *, size_t);
 };
 
 extern int

kernel/module.c

@@ -722,28 +722,22 @@ static int obsolete_params(const char *name,
 }
 #endif /* CONFIG_OBSOLETE_MODPARM */
 
-/* Find an symbol for this module (ie. resolve internals first).
-   It we find one, record usage.  Must be holding module_mutex. */
-unsigned long find_symbol_internal(Elf_Shdr *sechdrs,
-				   unsigned int symindex,
-				   const char *strtab,
-				   const char *name,
-				   struct module *mod,
-				   struct kernel_symbol_group **ksg)
+/* Resolve a symbol for this module.  I.e. if we find one, record usage.
+   Must be holding module_mutex. */
+static unsigned long resolve_symbol(Elf_Shdr *sechdrs,
+				    unsigned int symindex,
+				    const char *strtab,
+				    const char *name,
+				    struct module *mod)
 {
+	struct kernel_symbol_group *ksg;
 	unsigned long ret;
 
-	ret = find_local_symbol(sechdrs, symindex, strtab, name);
-	if (ret) {
-		*ksg = NULL;
-		return ret;
-	}
-	/* Look in other modules... */
 	spin_lock_irq(&modlist_lock);
-	ret = __find_symbol(name, ksg, mod->license_gplok);
+	ret = __find_symbol(name, &ksg, mod->license_gplok);
 	if (ret) {
 		/* This can fail due to OOM, or module unloading */
-		if (!use_module(mod, (*ksg)->owner))
+		if (!use_module(mod, ksg->owner))
 			ret = 0;
 	}
 	spin_unlock_irq(&modlist_lock);
@@ -832,21 +826,19 @@ static int simplify_symbols(Elf_Shdr *sechdrs,
 			    unsigned int strindex,
 			    struct module *mod)
 {
-	unsigned int i;
-	Elf_Sym *sym;
-
-	/* First simplify defined symbols, so if they become the
-           "answer" to undefined symbols, copying their st_value us
-           correct. */
-	for (sym = (void *)sechdrs[symindex].sh_addr, i = 0;
-	     i < sechdrs[symindex].sh_size / sizeof(Elf_Sym);
-	     i++) {
+	Elf_Sym *sym = (void *)sechdrs[symindex].sh_addr;
+	const char *strtab = (char *)sechdrs[strindex].sh_addr;
+	unsigned int i, n = sechdrs[symindex].sh_size / sizeof(Elf_Sym);
+	int ret = 0;
+
+	for (i = 1; i < n; i++) {
 		switch (sym[i].st_shndx) {
 		case SHN_COMMON:
 			/* We compiled with -fno-common.  These are not
 			   supposed to happen.  */
 			DEBUGP("Common symbol: %s\n", strtab + sym[i].st_name);
-			return -ENOEXEC;
+			ret = -ENOEXEC;
+			break;
 
 		case SHN_ABS:
 			/* Don't need to do anything */
@@ -855,6 +847,20 @@ static int simplify_symbols(Elf_Shdr *sechdrs,
 			break;
 
 		case SHN_UNDEF:
+			sym[i].st_value
+			  = resolve_symbol(sechdrs, symindex, strtab,
+					   strtab + sym[i].st_name, mod);
+
+			/* Ok if resolved.  */
+			if (sym[i].st_value != 0)
+				break;
+			/* Ok if weak.  */
+			if (ELF_ST_BIND(sym[i].st_info) == STB_WEAK)
+				break;
+
+			printk(KERN_WARNING "%s: Unknown symbol %s\n",
+			       mod->name, strtab + sym[i].st_name);
+			ret = -ENOENT;
 			break;
 
 		default:
@@ -862,30 +868,11 @@ static int simplify_symbols(Elf_Shdr *sechdrs,
 				= (unsigned long)
 				(sechdrs[sym[i].st_shndx].sh_addr
 				 + sym[i].st_value);
+			break;
 		}
 	}
 
-	/* Now try to resolve undefined symbols */
-	for (sym = (void *)sechdrs[symindex].sh_addr, i = 0;
-	     i < sechdrs[symindex].sh_size / sizeof(Elf_Sym);
-	     i++) {
-		if (sym[i].st_shndx == SHN_UNDEF) {
-			/* Look for symbol */
-			struct kernel_symbol_group *ksg = NULL;
-			const char *strtab 
-				= (char *)sechdrs[strindex].sh_addr;
-
-			sym[i].st_value
-				= find_symbol_internal(sechdrs,
-						       symindex,
-						       strtab,
-						       strtab + sym[i].st_name,
-						       mod,
-						       &ksg);
-		}
-	}
-
-	return 0;
+	return ret;
 }
 
 /* Update size with this section: return offset. */

sound/oss/ad1848.c

@@ -2983,14 +2983,14 @@ static struct pnp_dev *activate_dev(char *devname, char *resname, struct pnp_dev
 {
 	int err;
 
-	/* Device already active? Let's use it */
-	if(dev->active)
-		return(dev);
+	err = pnp_device_attach(dev);
+	if (err < 0)
+		return(NULL);
 
 	if((err = pnp_activate_dev(dev,NULL)) < 0) {
 		printk(KERN_ERR "ad1848: %s %s config failed (out of resources?)[%d]\n", devname, resname, err);
 
-		pnp_disable_dev(dev);
+		pnp_device_detach(dev);
 
 		return(NULL);
 	}
@@ -3006,12 +3006,11 @@ static struct pnp_dev *ad1848_init_generic(struct pnp_card *bus, struct address_
 	{
 		if((ad1848_dev = activate_dev(ad1848_isapnp_list[slot].name, "ad1848", ad1848_dev)))
 		{
-			get_device(&ad1848_dev->dev);
-			hw_config->io_base 	= ad1848_dev->resource[ad1848_isapnp_list[slot].mss_io].start;
-			hw_config->irq 		= ad1848_dev->irq_resource[ad1848_isapnp_list[slot].irq].start;
-			hw_config->dma 		= ad1848_dev->dma_resource[ad1848_isapnp_list[slot].dma].start;
+			hw_config->io_base 	= pnp_port_start(ad1848_dev, ad1848_isapnp_list[slot].mss_io);
+			hw_config->irq 		= pnp_irq(ad1848_dev, ad1848_isapnp_list[slot].irq);
+			hw_config->dma 		= pnp_dma(ad1848_dev, ad1848_isapnp_list[slot].dma);
 			if(ad1848_isapnp_list[slot].dma2 != -1)
-				hw_config->dma2 = ad1848_dev->dma_resource[ad1848_isapnp_list[slot].dma2].start;
+				hw_config->dma2 = pnp_dma(ad1848_dev, ad1848_isapnp_list[slot].dma2);
 			else
 				hw_config->dma2 = -1;
                         hw_config->card_subtype = ad1848_isapnp_list[slot].type;
@@ -3032,7 +3031,7 @@ static int __init ad1848_isapnp_init(struct address_info *hw_config, struct pnp_
 	if(ad1848_init_generic(bus, hw_config, slot)) {
 		/* We got it. */
 
-		printk(KERN_NOTICE "ad1848: ISAPnP reports '%s' at i/o %#x, irq %d, dma %d, %d\n",
+		printk(KERN_NOTICE "ad1848: PnP reports '%s' at i/o %#x, irq %d, dma %d, %d\n",
 		       busname,
 		       hw_config->io_base, hw_config->irq, hw_config->dma,
 		       hw_config->dma2);
@@ -3122,8 +3121,7 @@ static void __exit cleanup_ad1848(void)
 #ifdef CONFIG_PNP
 	if(ad1848_dev){
 		if(audio_activated)
-			pnp_disable_dev(ad1848_dev);
-		put_device(&ad1848_dev->dev);
+			pnp_device_detach(ad1848_dev);
 	}
 #endif
 }

sound/oss/cs4232.c

@@ -357,7 +357,7 @@ MODULE_PARM_DESC(isapnp,"Enable ISAPnP probing (default 1)");
 
 /* All cs4232 based cards have the main ad1848 card either as CSC0000 or
  * CSC0100. */
-static const struct pnp_id cs4232_pnp_table[] = {
+static const struct pnp_device_id cs4232_pnp_table[] = {
 	{ .id = "CSC0100", .driver_data = 0 },
 	{ .id = "CSC0000", .driver_data = 0 },
 	/* Guillemot Turtlebeach something appears to be cs4232 compatible
@@ -366,9 +366,9 @@ static const struct pnp_id cs4232_pnp_table[] = {
 	{ .id = ""}
 };
 
-/*MODULE_DEVICE_TABLE(isapnp, isapnp_cs4232_list);*/
+MODULE_DEVICE_TABLE(pnp, cs4232_pnp_table);
 
-static int cs4232_pnp_probe(struct pnp_dev *dev, const struct pnp_id *card_id, const struct pnp_id *dev_id)
+static int cs4232_pnp_probe(struct pnp_dev *dev, const struct pnp_device_id *dev_id)
 {
 	struct address_info *isapnpcfg;
 
@@ -376,30 +376,31 @@ static int cs4232_pnp_probe(struct pnp_dev *dev, const struct pnp_id *card_id, c
 	if (!isapnpcfg)
 		return -ENOMEM;
 
-	isapnpcfg->irq		= dev->irq_resource[0].start;
-	isapnpcfg->dma		= dev->dma_resource[0].start;
-	isapnpcfg->dma2		= dev->dma_resource[1].start;
-	isapnpcfg->io_base	= dev->resource[0].start;
+	isapnpcfg->irq		= pnp_irq(dev, 0);
+	isapnpcfg->dma		= pnp_dma(dev, 0);
+	isapnpcfg->dma2		= pnp_dma(dev, 1);
+	isapnpcfg->io_base	= pnp_port_start(dev, 0);
 	if (probe_cs4232(isapnpcfg,TRUE) == 0) {
 		printk(KERN_ERR "cs4232: ISA PnP card found, but not detected?\n");
 		kfree(isapnpcfg);
 		return -ENODEV;
 	}
 	attach_cs4232(isapnpcfg);
-	pci_set_drvdata(dev,isapnpcfg);
+	pnp_set_drvdata(dev,isapnpcfg);
 	return 0;
 }
 
 static void cs4232_pnp_remove(struct pnp_dev *dev)
 {
-	struct address_info *cfg = (struct address_info*) dev->driver_data;
-	if (cfg)
+	struct address_info *cfg = pnp_get_drvdata(dev);
+	if (cfg) {
 		unload_cs4232(cfg);
+		kfree(cfg);
+	}
 }
 
 static struct pnp_driver cs4232_driver = {
 	.name		= "cs4232",
-	.card_id_table	= NULL,
 	.id_table	= cs4232_pnp_table,
 	.probe		= cs4232_pnp_probe,
 	.remove		= cs4232_pnp_remove,