more Driver core patches for 2.6.19
Subsystems (4)
PATCH 1/1 more Driver core patches for 2.6.19
Here are some more driver core patches for 2.6.19
They contain:
- minor driver core bugfixes and memory savings
- debugfs bugfixes and inotify support added.
- userspace io driver interface added. This allows the ability to write userspace drivers for some types of hardware much easier than before, going through a simple interface to get accesses to irqs and memory regions. A small kernel portion is still needed to handle the irq properly, but that is it.
- other minor cleanups and fixes.
All of these patches have been in the -mm tree for a while.
Please pull from:
git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-2.6.git/
or if master.kernel.org hasn't synced up yet:
master.kernel.org:/pub/scm/linux/kernel/git/gregkh/driver-2.6.git/
Patches will be sent as a follow-on to this message to lkml for people to see.
thanks,
greg k-h
Documentation/DocBook/kernel-api.tmpl | 4 + Documentation/DocBook/uio-howto.tmpl | 434 +++++++++++++++++++++++ drivers/Kconfig | 1 + drivers/Makefile | 1 + drivers/base/class.c | 2 + drivers/base/platform.c | 4 +- drivers/uio/Kconfig | 39 ++ drivers/uio/Makefile | 4 + drivers/uio/uio.c | 618 +++++++++++++++++++++++++++++++++ drivers/uio/uio_dummy.c | 174 +++++++++ drivers/uio/uio_events.c | 119 +++++++ drivers/uio/uio_irq.c | 86 +++++ drivers/uio/uio_parport.c | 84 +++++ fs/debugfs/inode.c | 39 ++- include/linux/platform_device.h | 2 +- include/linux/uio_driver.h | 71 ++++ kernel/module.c | 25 ++ kernel/power/Kconfig | 9 +- 18 files changed, 1700 insertions(+), 16 deletions(-) create mode 100644 Documentation/DocBook/uio-howto.tmpl create mode 100644 drivers/uio/Kconfig create mode 100644 drivers/uio/Makefile create mode 100644 drivers/uio/uio.c create mode 100644 drivers/uio/uio_dummy.c create mode 100644 drivers/uio/uio_events.c create mode 100644 drivers/uio/uio_irq.c create mode 100644 drivers/uio/uio_parport.c create mode 100644 include/linux/uio_driver.h
---------------
Akinobu Mita (1):
driver core: delete virtual directory on class_unregister()
Andrew Morton (1):
Driver core: "platform_driver_probe() can save codespace": save codespace
David Brownell (1):
Driver core: deprecate PM_LEGACY, default it to N
Hans J. Koch (4):
UIO: Add the User IO core code
UIO: Documentation
UIO: dummy test module for the uio core
UIO: irq test module for the uio core
Kay Sievers (1):
Driver core: show "initstate" of module
Mathieu Desnoyers (5):
DebugFS : inotify create/mkdir support DebugFS : coding style fixes
DebugFS : file/directory creation error handling DebugFS : more file/directory creation error handling DebugFS : file/directory removal fix
Scott Wood (1):
Driver core: Make platform_device_add_data accept a const pointer
A message that is not in the archive (sent off-list or not yet received): [email protected]
A message that is not in the archive (sent off-list or not yet received): [email protected]
A message that is not in the archive (sent off-list or not yet received): [email protected]
A message that is not in the archive (sent off-list or not yet received): [email protected]
PATCH 5/14 Driver core: show "initstate" of module
From: Kay Sievers <[email protected]>
Show the initialization state(live, coming, going) of the module:
$ cat /sys/module/usbcore/initstate live
--- kernel/module.c | 25 +++++++++++++++++++++++++ 1 files changed, 25 insertions(+), 0 deletions(-)
kernel/module.c +25 -0
@@ -824,9 +824,34 @@ static inline void module_unload_init(struct module *mod) }#endif /* CONFIG_MODULE_UNLOAD */ +static ssize_t show_initstate (struct module_attribute *mattr, +struct module *mod,char *buffer) +{ +const char *state ="unknown" ; + +switch (mod->state) { +case MODULE_STATE_LIVE : + state ="live" ; +break ; +case MODULE_STATE_COMING : + state ="coming" ; +break ; +case MODULE_STATE_GOING : + state ="going" ; +break ; + } +return sprintf (buffer,"%s\n" , state); +} + +static struct module_attribute initstate = { + .attr = { .name ="initstate" , .mode =0444 , .owner =THIS_MODULE }, + .show = show_initstate, +}; +static struct module_attribute *modinfo_attrs[] = { &modinfo_version, &modinfo_srcversion, + &initstate, #ifdef CONFIG_MODULE_UNLOAD &refcnt, #endif
Signature · 1 line
1.4.4.2
PATCH 6/14 driver core: delete virtual directory on class_unregister()
From: Akinobu Mita <[email protected]>
Class virtual directory is created as the need arises. But it is not deleted when the class is unregistered.
--- drivers/base/class.c | 2 ++ 1 files changed, 2 insertions(+), 0 deletions(-)
drivers/base/class.c +2 -0
@@ -163,6 +163,8 @@ int class_register(struct class * cls)void class_unregister (struct class * cls) {pr_debug ("device class '%s': unregistering\n" , cls->name); +if (cls->virtual_dir) +kobject_unregister (cls->virtual_dir);remove_class_attrs (cls);subsystem_unregister (&cls->subsys); }
Signature · 1 line
1.4.4.2
PATCH 7/14 DebugFS : inotify create/mkdir support
From: Mathieu Desnoyers <[email protected]>
Add inotify create and mkdir events to DebugFS.
--- fs/debugfs/inode.c | 12 ++++++++++-- 1 files changed, 10 insertions(+), 2 deletions(-)
fs/debugfs/inode.c +10 -2
@@ -24,6 +24,7 @@#include <linux/kobject.h> #include <linux/namei.h> #include <linux/debugfs.h> +#include <linux/fsnotify.h> #define DEBUGFS_MAGIC 0x64626720
@@ -87,15 +88,22 @@ static int debugfs_mkdir(struct inode *dir, struct dentry *dentry, int mode) mode = (mode & (S_IRWXUGO |S_ISVTX )) |S_IFDIR ; res =debugfs_mknod (dir, dentry, mode,0 ); -if (!res) +if (!res) {inc_nlink (dir); +fsnotify_mkdir (dir, dentry); + }return res; }static int debugfs_create (struct inode *dir,struct dentry *dentry,int mode) { +int res; + mode = (mode &S_IALLUGO ) |S_IFREG ; -return debugfs_mknod (dir, dentry, mode,0 ); + res =debugfs_mknod (dir, dentry, mode,0 ); +if (!res) +fsnotify_create (dir, dentry); +return res; }static inline int debugfs_positive (struct dentry *dentry)
Signature · 1 line
1.4.4.2
PATCH 8/14 DebugFS : coding style fixes
From: Mathieu Desnoyers <[email protected]>
Minor coding style fixes along the way : 80 cols and a white space.
--- fs/debugfs/inode.c | 5 +++-- 1 files changed, 3 insertions(+), 2 deletions(-)
fs/debugfs/inode.c +3 -2
@@ -55,7 +55,8 @@ static struct inode *debugfs_get_inode(struct super_block *sb, int mode, dev_t d inode->i_op = &simple_dir_inode_operations; inode->i_fop = &simple_dir_operations; -/* directory inodes start off with i_nlink == 2 (for "." entry) */ +/* directory inodes start off with i_nlink == 2 +* (for "." entry) */ inc_nlink (inode);break ; }
@@ -143,7 +144,7 @@ static int debugfs_create_by_name(const char *name, mode_t mode,* block. A pointer to that is in the struct vfsmount that we * have around. */ -if (!parent ) { +if (!parent) {if (debugfs_mount && debugfs_mount->mnt_sb) { parent = debugfs_mount->mnt_sb->s_root; }
Signature · 1 line
1.4.4.2
PATCH 9/14 DebugFS : file/directory creation error handling
From: Mathieu Desnoyers <[email protected]>
Fix error handling of file and directory creation in DebugFS.
The error path should release the file system because no _remove will be called for this erroneous creation.
--- fs/debugfs/inode.c | 4 +++- 1 files changed, 3 insertions(+), 1 deletions(-)
fs/debugfs/inode.c +3 -1
@@ -206,13 +206,15 @@ struct dentry *debugfs_create_file(const char *name, mode_t mode,pr_debug ("debugfs: creating file '%s'\n" ,name); - error =simple_pin_fs (&debug_fs_type, &debugfs_mount, &debugfs_mount_count); + error =simple_pin_fs (&debug_fs_type, &debugfs_mount, + &debugfs_mount_count);if (error) goto exit; error =debugfs_create_by_name (name, mode, parent, &dentry);if (error) { dentry =NULL ; +simple_release_fs (&debugfs_mount, &debugfs_mount_count); goto exit; }
Signature · 1 line
1.4.4.2
PATCH 10/14 DebugFS : more file/directory creation error handling
From: Mathieu Desnoyers <[email protected]>
Correct dentry count to handle creation errors.
This patch puts a dput at the file creation instead of the file removal :lookup_one_len already returns a dentry with reference count of 1. Then, the dget() in simple_mknod increments it when the dentry is associated with a file. In a scenario where simple_create or simple_mkdir returns an error, this would lead to an unwanted increment of the reference counter, therefore making file removal impossible.
--- fs/debugfs/inode.c | 14 ++++++++++---- 1 files changed, 10 insertions(+), 4 deletions(-)
fs/debugfs/inode.c +10 -4
@@ -162,6 +162,7 @@ static int debugfs_create_by_name(const char *name, mode_t mode, error =debugfs_mkdir (parent->d_inode, *dentry, mode); else error =debugfs_create (parent->d_inode, *dentry, mode); +dput (*dentry); }else error =PTR_ERR (*dentry);mutex_unlock (&parent->d_inode->i_mutex);
@@ -273,6 +274,7 @@ EXPORT_SYMBOL_GPL(debugfs_create_dir);void debugfs_remove (struct dentry *dentry) {struct dentry *parent; +int ret =0 ;if (!dentry)return ;
@@ -284,11 +286,15 @@ void debugfs_remove(struct dentry *dentry)mutex_lock (&parent->d_inode->i_mutex);if (debugfs_positive (dentry)) {if (dentry->d_inode) { -if (S_ISDIR (dentry->d_inode->i_mode)) -simple_rmdir (parent->d_inode, dentry); -else +if (S_ISDIR (dentry->d_inode->i_mode)) { + ret =simple_rmdir (parent->d_inode, dentry); +if (ret) +printk (KERN_ERR +"DebugFS rmdir on %s failed : " +"directory not empty.\n" , + dentry->d_name.name); + }else simple_unlink (parent->d_inode, dentry); -dput (dentry); } }mutex_unlock (&parent->d_inode->i_mutex);
Signature · 1 line
1.4.4.2
PATCH 11/14 DebugFS : file/directory removal fix
From: Mathieu Desnoyers <[email protected]>
Fix file and directory removal in debugfs. Add inotify support for file removal.
The following scenario :
create dir a
create dir a/b
cd a/b (some process goes in cwd a/b)
rmdir a/b
rmdir a
fails due to the fact that "a" appears to be non empty. It is because the "b" dentry is not deleted from "a" and still in use. The same problem happens if "b" is a file. d_delete is nice enough to know when it needs to unhash and free the dentry if nothing else is using it or, if someone is using it, to remove it from the hash queues and wait for it to be deleted when it has no users.
The nice side-effect of this fix is that it calls the file removal notification.
--- fs/debugfs/inode.c | 4 ++++ 1 files changed, 4 insertions(+), 0 deletions(-)
fs/debugfs/inode.c +4 -0
@@ -286,6 +286,7 @@ void debugfs_remove(struct dentry *dentry)mutex_lock (&parent->d_inode->i_mutex);if (debugfs_positive (dentry)) {if (dentry->d_inode) { +dget (dentry);if (S_ISDIR (dentry->d_inode->i_mode)) { ret =simple_rmdir (parent->d_inode, dentry);if (ret)
@@ -295,6 +296,9 @@ void debugfs_remove(struct dentry *dentry) dentry->d_name.name); }else simple_unlink (parent->d_inode, dentry); +if (!ret) +d_delete (dentry); +dput (dentry); } }mutex_unlock (&parent->d_inode->i_mutex);
Signature · 1 line
1.4.4.2
PATCH 12/14 Driver core: "platform_driver_probe() can save codespace": save codespace
From: Andrew Morton <[email protected]>
This function can be __init
--- drivers/base/platform.c | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-)
drivers/base/platform.c +1 -1
@@ -473,7 +473,7 @@ EXPORT_SYMBOL_GPL(platform_driver_unregister);* Returns zero if the driver registered and bound to a device, else returns * a negative error code and with the driver not registered. */ -int platform_driver_probe (struct platform_driver *drv, +int __init_or_module platform_driver_probe(struct platform_driver *drv,int (*probe)(struct platform_device *)) {int retval, code;
Signature · 1 line
1.4.4.2
PATCH 13/14 Driver core: Make platform_device_add_data accept a const pointer
From: Scott Wood <[email protected]>
platform_device_add_data() makes a copy of the data that is given to it, and thus the parameter can be const. This removes a warning when data from get_property() on powerpc is handed to platform_device_add_data(), as get_property() returns a const pointer.
--- drivers/base/platform.c | 2 +- include/linux/platform_device.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)
drivers/base/platform.c +1 -1
@@ -212,7 +212,7 @@ EXPORT_SYMBOL_GPL(platform_device_add_resources);* pointer. The memory associated with the platform data will be freed * when the platform device is released. */ -int platform_device_add_data (struct platform_device *pdev,void *data,size_t size) +int platform_device_add_data (struct platform_device *pdev,const void *data,size_t size) {void *d;
include/linux/platform_device.h +1 -1
@@ -39,7 +39,7 @@ extern struct platform_device *platform_device_register_simple(char *, unsignedextern struct platform_device *platform_device_alloc (const char *name,unsigned int id);extern int platform_device_add_resources (struct platform_device *pdev,struct resource *res,unsigned int num); -extern int platform_device_add_data (struct platform_device *pdev,void *data,size_t size); +extern int platform_device_add_data (struct platform_device *pdev,const void *data,size_t size);extern int platform_device_add (struct platform_device *pdev);extern void platform_device_del (struct platform_device *pdev);extern void platform_device_put (struct platform_device *pdev);
Signature · 1 line
1.4.4.2
PATCH 14/14 Driver core: deprecate PM_LEGACY, default it to N
From: David Brownell <[email protected]>
Deprecate the old "legacy" PM API, and more importantly default it to "n". Virtually nothing in-tree uses it any more.
--- kernel/power/Kconfig | 9 +++++---- 1 files changed, 5 insertions(+), 4 deletions(-)
kernel/power/Kconfig +5 -4
@@ -20,13 +20,14 @@ config PM sending the processor to sleep and saving power. config PM_LEGACY - bool "Legacy Power Management API" + bool "Legacy Power Management API (DEPRECATED)" depends on PM - default y + default n ---help--- - Support for pm_register() and friends. + Support for pm_register() and friends. This old API is obsoleted + by the driver model. - If unsure, say Y. + If unsure, say N. config PM_DEBUG bool "Power Management Debug Support"
Signature · 1 line
1.4.4.2
Quoted 6 lines · Greg KH
- userspace io driver interface added. This allows the ability to write userspace drivers for some types of hardware much easier than before, going through a simple interface to get accesses to irqs and memory regions. A small kernel portion is still needed to handle the irq properly, but that is it.
Ok, what kind of ass-hat idiotic thing is this?
irqreturn_t uio_irq_handler(int irq, void *dev_id)
{
return IRQ_HANDLED;
}exactly what is the point here? No way will I pull this kind of crap. You just seem to have guaranteed a dead machine if the irq is level-triggered, since it will keep on happening forever.
Please remove.
YOU CANNOT DO IRQ'S BY LETTING USER SPACE SORT IT OUT!
It's really that easy. The irq handler has to be _entirely_ in kernel space. No user-space ass-hattery here.
And I don't care one whit if it happens to work on parport with an old legacy ISA interrupt that is edge-triggered. That's not even the interesting case. Never will be.
NAK NAK NAK NAK.
Linus
Quoted 12 lines · Linus Torvalds
Quoted 6 lines · Greg KH
- userspace io driver interface added. This allows the ability to write userspace drivers for some types of hardware much easier than before, going through a simple interface to get accesses to irqs and memory regions. A small kernel portion is still needed to handle the irq properly, but that is it.
Ok, what kind of ass-hat idiotic thing is this?
Quoted 8 lines
irqreturn_t uio_irq_handler(int irq, void *dev_id) { return IRQ_HANDLED; }exactly what is the point here? No way will I pull this kind of crap. You just seem to have guaranteed a dead machine if the irq is level-triggered, since it will keep on happening forever.
It's a stupid test module for the uio core for isa devices. It's not the main code, or core.
Quoted 3 lines
Please remove.
YOU CANNOT DO IRQ'S BY LETTING USER SPACE SORT IT OUT!
I agree, that's why this code doesn't let userspace sort it out. You have to have a kernel driver to handle the irq.
Quoted 2 lines
It's really that easy. The irq handler has to be _entirely_ in kernel space. No user-space ass-hattery here.
Agreed.
Quoted 3 lines
And I don't care one whit if it happens to work on parport with an old legacy ISA interrupt that is edge-triggered. That's not even the interesting case. Never will be.
I agree. But that's all that this test module did. It handled an isa interrupt that was edge triggered.
Quoted 1 line
NAK NAK NAK NAK.
Ok, I can pull this example module out if you want, but people seem to want examples these days. If I do that, any objection to the rest?
thanks,
greg k-h
Quoted 3 lines · Greg KH
It's a stupid test module for the uio core for isa devices. It's not the main code, or core.
Doesn't matter.
IT IS SO FUNDAMENTALLY AND HORRIBLY WRONG THAT I REFUSE TO HAVE IT IN MY TREE.
As an "example", the _only_ thing it can possibly ever do is to just confuse people - in other words, it's an _anti_example, not a real one.
Quoted 2 lines
Ok, I can pull this example module out if you want, but people seem to want examples these days. If I do that, any objection to the rest?
I'm really not convinced about the user-mode thing unless somebody can show me a good reason for it. Not just some "wouldn't it be nice" kind of thing. A real, honest-to-goodness reason that we actually _want_ to see used.
No features just for features sake.
So please push the tree without this userspace IO driver at all. And if you actually have a real user, not just an example, that is worthy and shows why such a driver in user space is actually a good thing, _then_ we can push that.
In other words, I'd like to see code that uses this that is actually _better_ than an in-kernel driver in some way.
For USB, the user-mode thing made sense. You have tons of random devices, and the abstraction level is higher to begin with. Quite frankly, I simply don't even see the same being true for something like this.
Btw: there's one driver we _know_ we want to support in user space, and that's the X kind of direct-rendering thing. So if you can show that this driver infrastructure actually makes sense as a replacement for the DRI layer, then _that_ would be a hell of a convincing argument.
There may be others. Feel free to fill in the blank: ________.
Linus
Quoted 5 lines · Linus Torvalds
Btw: there's one driver we _know_ we want to support in user space, and that's the X kind of direct-rendering thing. So if you can show that this driver infrastructure actually makes sense as a replacement for the DRI layer, then _that_ would be a hell of a convincing argument.
Btw, the other side of this argument is that if a user-space driver infrastructure can _not_ help the DRI kind of situation, then it's largely by definition not interesting. Merging something like that would just mean that we end up with multiple _different_ user-space helper infrastructure shells, which sounds distinctly unpalatable.
Linus
Quoted 10 lines · Linus Torvalds
Quoted 5 lines · Linus Torvalds
Btw: there's one driver we _know_ we want to support in user space, and that's the X kind of direct-rendering thing. So if you can show that this driver infrastructure actually makes sense as a replacement for the DRI layer, then _that_ would be a hell of a convincing argument.
Btw, the other side of this argument is that if a user-space driver infrastructure can _not_ help the DRI kind of situation, then it's largely
with DRI you have the case where "something" needs to do security validation of the commands that are sent to the card. (to avoid a non-privileged user to DMA all over your memory)
That and a tiny bit of resource management is the bulk of the kernel DRM code... and I don't think userspace can do it fundamentally better. Sure you could pipe things to a root daemon instead of doing a system call. But I don't see that being superior.
Quoted 3 lines · Arjan van de Ven
with DRI you have the case where "something" needs to do security validation of the commands that are sent to the card. (to avoid a non-privileged user to DMA all over your memory)
We also have the interesting case where your card is behind an isolation-capable IOMMU, so if you let userspace program it, you need a userspace-accessible DMA-API for IOMMU mappings (or to pre-map everything in the IOMMU, which loses on some of the benefits of isolation-capable IOMMUs (i.e., only map what you need to use right now)).
Cheers,
Muli
Am Donnerstag, 14. Dezember 2006 10:30 schrieb Muli Ben-Yehuda:
Quoted 6 lines · Arjan van de Ven
Quoted 4 lines
with DRI you have the case where "something" needs to do security validation of the commands that are sent to the card. (to avoid a non-privileged user to DMA all over your memory)
Quoted 6 lines
We also have the interesting case where your card is behind an isolation-capable IOMMU, so if you let userspace program it, you need a userspace-accessible DMA-API for IOMMU mappings (or to pre-map everything in the IOMMU, which loses on some of the benefits of isolation-capable IOMMUs (i.e., only map what you need to use right now)).
Userspace IO (UIO) was never intended to replace all kinds of possible drivers. We wanted to address the situation where a manufacturer of industrial I/O cards wants to do a large part of his driver in userspace to simplify his development process. That's all.
Most of these I/O cards have registers or dual ported RAM that can be mapped to userspace. This is possible with a standard kernel and is done every day. Problem is that you can't handle interrupts. UIO simply adds this capability and offers a standardized interface.
The code Greg added to his tree can do this for most hardware found on industrial IO boards. That's all we wanted to achieve for now. If somebody wants to support more sophisticated things, suggestions are welcome.
Hans
Quoted 6 lines · Linus Torvalds
In other words, I'd like to see code that uses this that is actually _better_ than an in-kernel driver in some way.
For USB, the user-mode thing made sense. You have tons of random devices, and the abstraction level is higher to begin with. Quite frankly, I simply don't even see the same being true for something like this.
We started to work on this for industrial I/O devices. Many of them are dual port memory based, others are dedicated chips for motion control or field busses.
The design requires to have an in kernel stub driver with interrupt handler which is capable to handle shared interrupts. User space _cannot_ override an irq_disable(), it just has access to the chip registers of the device, which is possible right now as well.
The risk, that such a driver stalls the kernel is exactly the same as the risk you have with any other badly written driver.
This is a real world example of such a drivers interrupt handler:
/*
* The chip specific portion of the interrupt handler. The framework code
* takes care of userspace notification when we return IRQ_HANDLED */
static irqreturn_t sercos_handler(int irq, void *dev_id, struct pt_regs *reg)
{
/* Check, if this interrupt is originated from the SERCOS chip */
if (!(sercos_read(IRQ_STATUS) & SERCOS_INTERRUPT_MASK))
return IRQ_NONE;
/* Acknowledge the chip interrupts */
sercos_write(IRQ_ACK1, SERCOS_INTERRUPT_ACK1);
sercos_write(IRQ_ACK2, SERCOS_INTERRUPT_ACK2);
return IRQ_HANDLED;
}With a full kernel driver we need:
1. Interrupt handler
check interrupt
acknowledge interrupt
copy data from/to chip into a kernel buffer wakeup user space task
2. read data from driver, which goes through copy to user
3. do calculations
4. write data to driver, which goes through copy from user
After changing the driver concept we have only:
1. Interrupt handler
check interrupt
acknowledge interrupt
wakeup user space task
2. User space task handles the mmaped chip directly
The change gave a serious performance gain in the range of 20% after the application was optimized for dealing with the chip directly.
There are tons of such exotic hardware devices out there, which now have either a closed source driver or an out of tree patch with an horrible amount of individual ioctl functions to get to the same point with less performance.
Quoted 4 lines
Btw: there's one driver we _know_ we want to support in user space, and that's the X kind of direct-rendering thing. So if you can show that this driver infrastructure actually makes sense as a replacement for the DRI layer, then _that_ would be a hell of a convincing argument.
I did not look closely into that, but I think that it is a valid usage candidate. The interface of graphic cards is user space mappable and it probably needs some interrupt handling + notification mechanism as well as the devices mentioned above.
tglx
Quoted 4 lines
Btw: there's one driver we _know_ we want to support in user space, and that's the X kind of direct-rendering thing. So if you can show that this driver infrastructure actually makes sense as a replacement for the DRI layer, then _that_ would be a hell of a convincing argument.
And even X is trying to move away from that at least partially... With the DRI driver handling IRQs and processing command buffers... except for cards with multiple hardware contexts, but then, we are in a case similar to Infiniband where the HW is -designed- to have specific areas mapped into user space, and there is still a kernel driver to arbitrate, decide who gets what, establish those mappings, etc...
Thus X isn't even a good example :-)
Ben.
Quoted 6 lines · Linus Torvalds
I'm really not convinced about the user-mode thing unless somebody can show me a good reason for it. Not just some "wouldn't it be nice" kind of thing. A real, honest-to-goodness reason that we actually _want_ to see used.
No features just for features sake.
Ok, Thomas just showed at least one example of where this interface is a big advantage over the all-in-kernel model. I'll work with him and try to dig up other real examples before submitting this code again.
In the mean time, I'll leave it in my tree and it will get some more exposure in the -mm releases.
Quoted 1 line
So please push the tree without this userspace IO driver at all.
Done.
Please pull from:
master.kernel.org:/pub/scm/linux/kernel/git/gregkh/driver-2.6.git/
It contains the changes listed below.
thanks,
greg k-h
drivers/base/class.c | 2 ++ drivers/base/platform.c | 4 ++-- fs/debugfs/inode.c | 39 ++++++++++++++++++++++++++++++--------- include/linux/platform_device.h | 2 +- kernel/module.c | 25 +++++++++++++++++++++++++ kernel/power/Kconfig | 9 +++++---- 6 files changed, 65 insertions(+), 16 deletions(-)
---------------
Akinobu Mita (1):
driver core: delete virtual directory on class_unregister()
Andrew Morton (1):
Driver core: "platform_driver_probe() can save codespace": save codespace
David Brownell (1):
Driver core: deprecate PM_LEGACY, default it to N
Kay Sievers (1):
Driver core: show "initstate" of module
Mathieu Desnoyers (5):
DebugFS : inotify create/mkdir support DebugFS : coding style fixes
DebugFS : file/directory creation error handling DebugFS : more file/directory creation error handling DebugFS : file/directory removal fix
Scott Wood (1):
Driver core: Make platform_device_add_data accept a const pointer
Quoted 4 lines
I'm really not convinced about the user-mode thing unless somebody can show me a good reason for it. Not just some "wouldn't it be nice" kind of thing. A real, honest-to-goodness reason that we actually _want_ to see used.
Qemu? It would be nice if emulators could directly drive hardware:
useful for reverse engineering windows drivers for example.
Duncan.
Am Donnerstag, 14. Dezember 2006 09:49 schrieb Duncan Sands:
Quoted 7 lines
Quoted 4 lines
I'm really not convinced about the user-mode thing unless somebody can show me a good reason for it. Not just some "wouldn't it be nice" kind of thing. A real, honest-to-goodness reason that we actually _want_ to see used.
Qemu? It would be nice if emulators could directly drive hardware:
useful for reverse engineering windows drivers for example.
I really think there is a big misunderstanding in this whole discussion. Userspace IO (UIO) was never intended to be a generic userspace interface to all kinds of hardware. I completely agree with Linus and all others who expressed that opinion that a full-fledged kernel module is the, let's say, most beautiful way of writing a driver. But it's not always the best way. Let's look at a real world example:
A small German manufacturer produces high-end AD converter cards. He sells 100 pieces per year, only in Germany and only with Windows drivers. He would now like to make his cards work with Linux. He has two driver programmers with little experience in writing Linux kernel drivers. What do you tell him? Write a large kernel module from scratch? Completely rewrite his code because it uses floating point arithmetics?
And even if they did that, do we really want it? Do we want to add large kernel modules for each exotic card? With UIO, everything becomes much cleaner:
* They let somebody write the small kernel module they need to handle interrupts in a _clean_ way. This module can easily be checked and could even be included in a mainline kernel.
* They do the rest in userspace, with all the libraries and tools they're used to. That's what they _can_ do.
Note that this is a _technical_ reason. I'm not talking about all that licensing possibilities that were discussed here.
UIO's intention is to allow manufacturers of industrial IO hardware to support Linux without the need to hire half a dozen experienced kernel developers. It makes their kernels more stable and easier to maintain. We don't get flooded with requests to include large modules for exotic hardware into the mainline kernel.
The alternative is what we have at the moment: Manufacturers don't support Linux at all, because it's too difficult to handle for them, or they do it in a way that either violates our licence or leads to unstable customized kernels (or both).
So, your qemu suggestion is certainly interesting. But, really, we never thought of such a general thing while we were working at that code. I thought I had to make that clear. Reading this thread, one could get the impression we wanted to start a revolution and handle all hardware in userspace from now on. This is definetly wrong.
Hans
Quoted 6 lines · Hans-Jürgen Koch
A small German manufacturer produces high-end AD converter cards. He sells 100 pieces per year, only in Germany and only with Windows drivers. He would now like to make his cards work with Linux. He has two driver programmers with little experience in writing Linux kernel drivers. What do you tell him? Write a large kernel module from scratch? Completely rewrite his code because it uses floating point arithmetics?
Write a small kernel module which:
- create a device node per-card
- read the data from the A/D as fast as possible and buffer it in main memory without touching it
- implements a read interface to read data from the buffer
- implement ioctls for whatever controls you need
And that's it. All the rest can be done in userspace, safely, with floating point, C++ and everything. If the driver programmers are worth their pay, their driver is probably already split logically at where the userspace-kernel interface would be.
And small means small, like 200 lines or so, more if you want to have fun with sysfs, poll, aio and their ilk, but that's not a necessity.
OG.
Am Donnerstag, 14. Dezember 2006 12:51 schrieb Olivier Galibert:
Quoted 9 lines · Hans-Jürgen Koch
Quoted 6 lines
A small German manufacturer produces high-end AD converter cards. He sells 100 pieces per year, only in Germany and only with Windows drivers. He would now like to make his cards work with Linux. He has two driver programmers with little experience in writing Linux kernel drivers. What do you tell him? Write a large kernel module from scratch? Completely rewrite his code because it uses floating point arithmetics?
Write a small kernel module which:
What you suggest is not a "small kernel module". It's what we have now, writing a complete driver.
Quoted 1 line
- create a device node per-card
That's what UIO does, plus some standard sysfs files, that tell you e.g. the size of the cards memory you can map. There are standard file names that allow you e.g. to automatically search for all registered uio drivers and their properties.
Quoted 2 lines
- read the data from the A/D as fast as possible and buffer it in main memory without touching it
If the card already has that data in its dual port RAM, you do an unneccessary copy.
Quoted 1 line
- implements a read interface to read data from the buffer
Here you do the next unneccessary copy.
Quoted 1 line
- implement ioctls for whatever controls you need
Implementing ioctls for everything is bad coding style and a has bad performance. I said "high-end AD card", that means you have a signal processor on that board, want to download firmware to it and so on. You end up copying lots of data between user space and kernel space.
Quoted 2 lines
And that's it.
Yes, that's a complete kernel driver that you'd never get into a mainline kernel. Furthermore, the card manufacturer would have to employ at least two experienced Linux _kernel_ programmers. That's too much for a small company who's business is something different.
Quoted 7 lines
All the rest can be done in userspace, safely, with floating point, C++ and everything. If the driver programmers are worth their pay, their driver is probably already split logically at where the userspace-kernel interface would be.
And small means small, like 200 lines or so, more if you want to have fun with sysfs, poll, aio and their ilk, but that's not a necessity.
You can achieve 100 lines with uio, including sysfs and poll. What you describe would never fit in 200 lines for a non-trivial card.
Hans
Quoted 2 lines · Hans-Jürgen Koch
What you suggest is not a "small kernel module". It's what we have now, writing a complete driver.
Who says a complete driver has to be big?
Quoted 4 lines
That's what UIO does, plus some standard sysfs files, that tell you e.g. the size of the cards memory you can map. There are standard file names that allow you e.g. to automatically search for all registered uio drivers and their properties.
Which makes the userspace code much more complex than needed.
Quoted 2 lines
If the card already has that data in its dual port RAM, you do an unneccessary copy.
Unnecessary only if
[card data rate]*[maximum userspace latency] < [dual port ram size].
Doing the buffering in the kernel where it belongs changes the right part of the equation to [buffer size], which can be orders of magnitude way bigger. And you can have the card DMA into the buffer directly if you feel like it.
Quoted 3 lines
Quoted 1 line
- implements a read interface to read data from the buffer
Here you do the next unneccessary copy.
You can mmap, you can splice(), none is really hard.
Quoted 4 lines
Quoted 1 line
- implement ioctls for whatever controls you need
Implementing ioctls for everything is bad coding style and a has bad performance.
I thought the ALSA guys always said their stuff was high performance?
In any case, if ioctl is too slow for your controls, it means that your ioctls are too low level, as in register access instead of "reboot card at address x". And uio, with its lack of protection against wandering interrupts, can't cut it.
Quoted 4 lines
I said "high-end AD card", that means you have a signal processor on that board, want to download firmware to it and so on. You end up copying lots of data between user space and kernel space.
You're allowed to implement write() too.
Quoted 4 lines
Yes, that's a complete kernel driver that you'd never get into a mainline kernel. Furthermore, the card manufacturer would have to employ at least two experienced Linux _kernel_ programmers. That's too much for a small company who's business is something different.
So they have a choice between learning a minimum of linux kernel internals, or a minimum of uio. I suspect the hidden kinks of uio and relative lack of documentation make the kernel route *way* easier.
Quoted 2 lines
You can achieve 100 lines with uio, including sysfs and poll. What you describe would never fit in 200 lines for a non-trivial card.
Ok, 200 is an exaggeration. Here is a 600-lines 2.4 driver that does what I say, with direct dma to the internal buffer from the card and userland-driven firmware upload. I know that a 2.6 version would actually be smaller.
OG.
//========================= Official Notice =============================== //
// "This software was developed at the National Institute of Standards // and Technology by employees of the Federal Government in the course of // their official duties. Pursuant to Title 17 Section 105 of the United // States Code this software is not subject to copyright protection and // is in the public domain.
//
// The NIST Data Flow System (NDFS) is an experimental system and is // offered AS IS. NIST assumes no responsibility whatsoever for its use // by other parties, and makes no guarantees and NO WARRANTIES, EXPRESS // OR IMPLIED, about its quality, reliability, fitness for any purpose, // or any other characteristic.
//
// We would appreciate acknowledgement if the software is used. //
// This software can be redistributed and/or modified freely provided // that any derivative works bear some notice that they are derived from // it, and any modified versions bear some notice that they have been // modified from the original."
// //=========================================================================
#include <linux/version.h>
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/poll.h>
#include <linux/pci.h>
#include <linux/signal.h>
#include <asm/io.h>
#include <linux/ioport.h>
#include <asm/pgtable.h>
#include <asm/page.h>
#include <linux/sched.h>
#include <asm/segment.h>
#include <linux/types.h>
#include <linux/wrapper.h>
#include <linux/interrupt.h>
#include <linux/kmod.h>
#include <linux/vmalloc.h>
#include <linux/init.h>
#include "iiadc64.h"
#define DEBUG_AL(format, a...) printk(KERN_WARNING format, ##a) #define DEBUG_ER(format, a...) printk(KERN_WARNING format, ##a) #define DEBUG_WR(format, a...) printk(KERN_WARNING format, ##a) #define DEBUG_IN(format, a...) printk(KERN_WARNING format, ##a) #define DEBUG_TR(format, a...) printk(KERN_WARNING format, ##a)
enum{ MODE_MEMORY, MODE_RING, MODE_MAILBOX };
enum{ RING_SIZE = 4096*4096 };
static int iiadc64_open(struct inode *, struct file *);
static int iiadc64_release(struct inode *, struct file *);
static int iiadc64_ioctl(struct inode *, struct file *, unsigned int, unsigned long); static ssize_t iiadc64_read(struct file *, char *, size_t, loff_t *); static ssize_t iiadc64_write(struct file *, const char *, size_t, loff_t *);
static struct file_operations iiadc64_fops = {
open: iiadc64_open,
release: iiadc64_release,
ioctl: iiadc64_ioctl, read: iiadc64_read, write: iiadc64_write
};
struct iiadc64_state {
struct pci_dev *dev;
unsigned long iobase;
unsigned int irq;
unsigned char *memory;
int access_mode, access_mbox;
int irqen;
int irqtick;
int ring_rpos, ring_wpos;
int dropouts;
spinlock_t lock;
#if LINUX_VERSION_CODE >= 0x20300
wait_queue_head_t ring_wait;
#else
struct wait_queue *ring_wait;
#endif
} is;
/* [DaveM] I've recoded most of this so that:
* 1) It's easier to tell what is happening
* 2) It's more portable, especially for translating things
* out of vmalloc mapped areas in the kernel.
* 3) Less unnecessary translations happen.
*
* The code used to assume that the kernel vmalloc mappings
* existed in the page tables of every process, this is simply
* not guarenteed. We now use pgd_offset_k which is the
* defined way to get at the kernel page tables.
*/
/* Given PGD from the address space's page table, return the kernel
* virtual mapping of the physical memory mapped at ADR.
*/
static inline unsigned long uvirt_to_kva(pgd_t *pgd, unsigned long adr) {
unsigned long ret = 0UL;
pmd_t *pmd;
pte_t *ptep, pte;
if (!pgd_none(*pgd)) {
pmd = pmd_offset(pgd, adr);
if (!pmd_none(*pmd)) {
ptep = pte_offset(pmd, adr);
pte = *ptep;
if(pte_present(pte)) {
ret = (unsigned long) page_address(pte_page(pte));
ret |= (adr & (PAGE_SIZE - 1));
}
} }
return ret;
}
static inline unsigned long uvirt_to_bus(unsigned long adr) {
unsigned long kva, ret;
kva = uvirt_to_kva(pgd_offset(current->mm, adr), adr); ret = virt_to_bus((void *)kva);
return ret;
}
static inline unsigned long kvirt_to_bus(unsigned long adr) {
unsigned long va, kva, ret;
va = VMALLOC_VMADDR(adr);
kva = uvirt_to_kva(pgd_offset_k(va), va);
ret = virt_to_bus((void *)kva);
return ret;
}
/* Here we want the physical address of the memory.
* This is used when initializing the contents of the
* area and marking the pages as reserved.
*/
static inline unsigned long kvirt_to_pa(unsigned long adr) {
unsigned long va, kva, ret;
va = VMALLOC_VMADDR(adr);
kva = uvirt_to_kva(pgd_offset_k(va), va);
ret = __pa(kva);
return ret;
}
static void * rvmalloc(signed long size)
{
void * mem;
unsigned long adr, page;
mem=vmalloc_32(size);
if (mem)
{
memset(mem, 0, size); /* Clear the ram out, no junk to the user */
adr=(unsigned long) mem;
while (size > 0)
{
page = kvirt_to_pa(adr);
mem_map_reserve(virt_to_page(__va(page)));
adr+=PAGE_SIZE;
size-=PAGE_SIZE;
}
} return mem;
}
static void rvfree(void * mem, signed long size)
{
unsigned long adr, page;
if (mem)
{
adr=(unsigned long) mem;
while (size > 0)
{
page = kvirt_to_pa(adr);
mem_map_unreserve(virt_to_page(__va(page)));
adr+=PAGE_SIZE;
size-=PAGE_SIZE;
}
vfree(mem);
}
}static unsigned int iiadc64_mailbox_read(int box) {
int counter = 100000;
int mask = 0xf0000 << (box*4); while(!(inl(is.iobase + 0x34) & mask) && (--counter)); if(!counter)
DEBUG_ER("iiadc64: Timeout on mailbox %d read\n", box); return inl(is.iobase + 0x10 + 4*box);
}
static int iiadc64_mailbox_check_read(int box)
{
int mask = 0xf0000 << (box*4);
return (inl(is.iobase + 0x34) & mask) != 0;
}
static void iiadc64_mailbox_write(int box, unsigned int data) {
int counter = 100000;
int mask = 0xf << box;
while((inl(is.iobase + 0x34) & mask) && (--counter)); if(!counter)
DEBUG_ER("iiadc64: Timeout on mailbox %d write\n", box); outl(data, is.iobase + 4*box);
}
static void iiadc64_irq(int irq, void *dev_id, struct pt_regs *regs) {
unsigned int istat;
istat = inl(is.iobase + 0x38);
if(istat & 0x20000) {
unsigned int request = iiadc64_mailbox_read(1); if(request == 1) {
spin_lock(&is.lock);
is.ring_wpos = 0;
is.ring_rpos = 0;
is.dropouts = 0;
spin_unlock(&is.lock);
iiadc64_mailbox_write(0, 0);
} else {
int delta;
int csize;
request *= 4096;
delta = request - is.ring_wpos;
if(delta < 0)
delta += RING_SIZE;
spin_lock(&is.lock);
csize = is.ring_wpos - is.ring_rpos;
if(csize < 0)
csize += RING_SIZE;
if(csize + delta > RING_SIZE)
is.dropouts++;
is.ring_wpos = request;
is.irqtick++;
spin_unlock(&is.lock);
wake_up_interruptible(&is.ring_wait);
}}
if(istat & 0x800000)
outl(istat, is.iobase + 0x38); }
static void iiadc64_reset(void)
{
unsigned int intcsr;
unsigned int timeout;
unsigned int val;
if(is.irqen)
intcsr = 0x003f1400;
else
intcsr = 0x003f0000;
outl(intcsr, is.iobase + 0x38);
outl(0x0f000000, is.iobase + 0x3c);
timeout = HZ/10;
do {
current->state = TASK_INTERRUPTIBLE;
timeout = schedule_timeout(timeout);
} while (timeout);
outl(0x00000000, is.iobase + 0x3c);
timeout = HZ/5;
do {
current->state = TASK_INTERRUPTIBLE;
timeout = schedule_timeout(timeout);
} while (timeout);
if(is.irqen)
outl(0x00000600, is.iobase + 0x3c);
val = iiadc64_mailbox_read(0);
if(val != 0x1f)
DEBUG_ER("iiadc64: Wrong value in mailbox 0 after reset : %08x\n", val);
else
DEBUG_IN("iiadc64: Reset successful\n");
while(iiadc64_mailbox_check_read(0))
(void)iiadc64_mailbox_read(0); is.ring_rpos = 0;
is.ring_wpos = 0;
}
static int iiadc64_open(struct inode *inode, struct file *file) {
is.access_mode = MODE_MEMORY;
is.irqtick = 0;
is.ring_wpos = is.ring_rpos = 0;
is.dropouts = 0;
if(request_irq(is.irq, iiadc64_irq, SA_SHIRQ, "iiadc64", &is)) {
DEBUG_ER("iiadc64: Couldn't get shared irq %d\n", is.irq);
return -EIO; }
is.irqen = 1;
iiadc64_reset();
MOD_INC_USE_COUNT;
return 0;
}
static int iiadc64_release(struct inode *inode, struct file *file) {
is.irqen = 0;
iiadc64_reset();
free_irq(is.irq, &is);
MOD_DEC_USE_COUNT;
return 0;
}
static int iiadc64_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long param) {
switch(cmd) {
case II_RESET:
iiadc64_reset();
break; case II_MODE_MEMORY:
is.access_mode = MODE_MEMORY;
break;
case II_MODE_RING:
is.access_mode = MODE_RING;
break;
case II_MODE_MAILBOX: {
int mbox, err;
err = get_user(mbox, (int *)param);
if(err)
return err;
if(mbox<0 || mbox>3)
return -EINVAL; is.access_mode = MODE_MAILBOX;
is.access_mbox = mbox;
break;}
case II_PCI_TABLE: {
unsigned int adr;
int err;
int i;
err = get_user(adr, (unsigned int *)param);
if(err)
return err; for(i=0; i<RING_SIZE/4096; i++) {
iiadc64_mailbox_write(0, 1);
iiadc64_mailbox_write(0, adr++);
iiadc64_mailbox_write(0, kvirt_to_bus((unsigned long)is.memory+i*4096));
}
break;}
case II_RUN: {
unsigned int adr;
int err;
err = get_user(adr, (unsigned int *)param);
if(err)
return err; iiadc64_mailbox_write(0, 3);
iiadc64_mailbox_write(0, adr);
break;}
default:
return -ENOTTY;
}
return 0;
}
static ssize_t iiadc64_read(struct file *file, char *buf, size_t size, loff_t *offset) {
switch(is.access_mode) {
case MODE_MEMORY: {
size_t cur_size;
int adr = *offset / 4;
cur_size = size;
while(cur_size > 0) {
size_t block_size = cur_size;
unsigned int *data = (unsigned int *)is.memory;
size_t cb_size;
if(block_size > PAGE_SIZE)
block_size = PAGE_SIZE;
cur_size -= block_size;
cb_size = block_size;
while(cb_size) {
iiadc64_mailbox_write(0, 2);
iiadc64_mailbox_write(0, adr++);
*data++ = iiadc64_mailbox_read(0);
cb_size -= 4;
}
if(copy_to_user(buf, (const void *)is.memory, block_size))
return -EFAULT;
buf += block_size;
}
*offset += size;
return size;
}
case MODE_RING: {
size_t cur_size;
unsigned long flags;
int avail, dropouts;
cur_size = size;
while(cur_size) {
size_t block_size;
spin_lock_irqsave(&is.lock, flags);
while(is.ring_wpos == is.ring_rpos) {
spin_unlock_irqrestore(&is.lock, flags);
interruptible_sleep_on(&is.ring_wait);
if (signal_pending(current)) {
DEBUG_TR("iiadc64: ERESTARTSYS\n");
return -ERESTARTSYS;
}
spin_lock_irqsave(&is.lock, flags);
}
avail = is.ring_wpos - is.ring_rpos;
spin_unlock_irqrestore(&is.lock, flags);
if(avail < 0)
avail += RING_SIZE;
block_size = cur_size;
if(block_size > avail)
block_size = avail;
if(block_size + is.ring_rpos > RING_SIZE)
block_size = RING_SIZE - is.ring_rpos;
if(copy_to_user(buf, (const void *)(is.memory + is.ring_rpos), block_size))
return -EFAULT;
spin_lock_irqsave(&is.lock, flags);
is.ring_rpos += block_size;
if(is.ring_rpos == RING_SIZE)
is.ring_rpos = 0;
dropouts = is.dropouts;
is.dropouts = 0;
spin_unlock_irqrestore(&is.lock, flags);
if(dropouts)
DEBUG_ER("iiadc64: Dropout detected\n");
buf += block_size;
cur_size -= block_size;
}
*offset += size;
return size;
}
case MODE_MAILBOX: {
size_t cur_size = size;
for(;;) {
unsigned int val = iiadc64_mailbox_read(is.access_mbox);
if(put_user(val, (unsigned int *)buf))
return -EFAULT;
buf += sizeof(unsigned int);
if(cur_size <= sizeof(unsigned int))
break;
cur_size -= sizeof(unsigned int);
}
*offset += size;
return size;
}
default:
return -ENOTTY; }
}
static ssize_t iiadc64_write(struct file *file, const char *buf, size_t size, loff_t *offset) {
switch(is.access_mode) {
case MODE_MEMORY: {
size_t cur_size;
int adr = *offset / 4;
cur_size = size;
while(cur_size > 0) {
size_t block_size = cur_size;
unsigned int *data = (unsigned int *)is.memory;
if(block_size > PAGE_SIZE)
block_size = PAGE_SIZE;
if(copy_from_user((void *)is.memory, buf, block_size))
return -EFAULT;
buf += block_size;
cur_size -= block_size;
while(block_size) {
iiadc64_mailbox_write(0, 1);
iiadc64_mailbox_write(0, adr++);
iiadc64_mailbox_write(0, *data++);
block_size -= 4;
}
}
*offset += size;
return size;
}
case MODE_MAILBOX: {
size_t cur_size = size;
for(;;) {
unsigned int val;
if(get_user(val, (unsigned int *)buf))
return -EFAULT;
iiadc64_mailbox_write(is.access_mbox, val);
buf += sizeof(unsigned int);
if(cur_size <= sizeof(unsigned int))
break;
cur_size -= sizeof(unsigned int);
}
*offset += size;
return size;
}
default:
return -ENOTTY; }
}
#ifdef MODULE
int init_module(void)
#else
int iiadc64_init(void)
#endif
{
DEBUG_AL("IIADC64 minimal kernel driver (c) 1999 Olivier Galibert\n");
is.dev = pci_find_device(0x10e8, 0x807f, 0);
if(!is.dev) {
DEBUG_ER("iiadc64: Unable to find the DSP board\n");
return -EIO;
}#if LINUX_VERSION_CODE >= 0x20400
if(pci_enable_device(is.dev))
return -EIO;
pci_set_master(is.dev);
is.iobase = pci_resource_start(is.dev, 0);
#else
is.iobase = is.dev->base_address[0] & PCI_BASE_ADDRESS_IO_MASK;
#endif
is.irq = is.dev->irq;
is.memory = rvmalloc(RING_SIZE);
if(!is.memory) {
DEBUG_ER("iiadc64: Couldn't allocate ring buffer\n");
return -EIO;
}
if (register_chrdev(II_MAJOR, "iiadc64", &iiadc64_fops)) {
DEBUG_ER("iiadc64: Unable to register character device\n");
return -EIO;
}
DEBUG_IN("iiadc64: DSP board found, io at 0x%lx, irq %u\n", is.iobase, is.irq);#if LINUX_VERSION_CODE >= 0x20300
init_waitqueue_head(&is.ring_wait);
#else
is.ring_wait = 0;
init_waitqueue(&is.ring_wait);
#endif
is.lock = SPIN_LOCK_UNLOCKED; iiadc64_reset();
return 0;
}
#ifdef MODULE
void cleanup_module(void)
{
rvfree(is.memory, RING_SIZE);
unregister_chrdev(II_MAJOR, "iiadc64");
}
#endif
//========================= Official Notice =============================== //
// "This software was developed at the National Institute of Standards // and Technology by employees of the Federal Government in the course of // their official duties. Pursuant to Title 17 Section 105 of the United // States Code this software is not subject to copyright protection and // is in the public domain.
//
// The NIST Data Flow System (NDFS) is an experimental system and is // offered AS IS. NIST assumes no responsibility whatsoever for its use // by other parties, and makes no guarantees and NO WARRANTIES, EXPRESS // OR IMPLIED, about its quality, reliability, fitness for any purpose, // or any other characteristic.
//
// We would appreciate acknowledgement if the software is used. //
// This software can be redistributed and/or modified freely provided // that any derivative works bear some notice that they are derived from // it, and any modified versions bear some notice that they have been // modified from the original."
// //=========================================================================
#ifndef __IIADC64_H
#define __IIADC64_H
#include <linux/ioctl.h>
#define II_MAJOR 121
#define II_RESET _IO(II_MAJOR, 0)
#define II_MODE_MEMORY _IO(II_MAJOR, 1)
#define II_MODE_RING _IO(II_MAJOR, 2)
#define II_MODE_MAILBOX _IOR(II_MAJOR, 3, int)
#define II_PCI_TABLE _IOR(II_MAJOR, 4, unsigned int)
#define II_RUN _IOR(II_MAJOR, 5, unsigned int)
#endif
Quoted 3 lines · On Thu, 14 Dec 2006 10:56:03 +0100 Hans-Jürgen Koch <[email protected]> wrote:
* They let somebody write the small kernel module they need to handle interrupts in a _clean_ way. This module can easily be checked and could even be included in a mainline kernel.
And might as well do the mmap work as well. I'm not clear what uio gives us that a decently written pair of PCI and platform template drivers for people to use would not do more cleanly.
Also many of these cases you might not want stuff in userspace but the uio model would push it that way which seems to be an unfortunate side effect. Yes some probably do want to go that way but not all.
Am Donnerstag, 14. Dezember 2006 13:39 schrieb Alan:
Quoted 10 lines
Quoted 3 lines · On Thu, 14 Dec 2006 10:56:03 +0100 Hans-Jürgen Koch <[email protected]> wrote:
* They let somebody write the small kernel module they need to handle interrupts in a _clean_ way. This module can easily be checked and could even be included in a mainline kernel.
And might as well do the mmap work as well. I'm not clear what uio gives us that a decently written pair of PCI and platform template drivers for people to use would not do more cleanly.
* Creation of /dev device files.
* Creation of standardized sysfs files.
* Interrupt registration and handling.
* mmap for physical and logical memory.
* read, poll, and fasync for interrupt handling.
* a predefined, clean design that the hardware manufacturer can use.
Quoted 4 lines
Also many of these cases you might not want stuff in userspace but the uio model would push it that way which seems to be an unfortunate side effect. Yes some probably do want to go that way but not all.
Alright, but everybody has the choice. If the alternative is to have no Linux drivers at all because it's too expensive, then somebody might consider UIO. To have the big parts of the driver in userspace allows them to remain stable across different kernel versions. Driver updates can take place without changing the kernel. For some manufacturers these will be strong arguments in favor of UIO.
Hans
Quoted 7 lines · Hans-Jürgen Koch
A small German manufacturer produces high-end AD converter cards. He sells 100 pieces per year, only in Germany and only with Windows drivers. He would now like to make his cards work with Linux. He has two driver programmers with little experience in writing Linux kernel drivers. What do you tell him? Write a large kernel module from scratch? Completely rewrite his code because it uses floating point arithmetics?
They use floating point in (Windows) kernelspace? Oh my.
-`J'
Am Donnerstag, 14. Dezember 2006 18:02 schrieb Jan Engelhardt:
Quoted 11 lines · Hans-Jürgen Koch
Quoted 7 lines
A small German manufacturer produces high-end AD converter cards. He sells 100 pieces per year, only in Germany and only with Windows drivers. He would now like to make his cards work with Linux. He has two driver programmers with little experience in writing Linux kernel drivers. What do you tell him? Write a large kernel module from scratch? Completely rewrite his code because it uses floating point arithmetics?
They use floating point in (Windows) kernelspace? Oh my.
To be honest, I never really understood where kernel space starts and user space ends in Windows, so I'm not sure about this :-)
Hans
Quoted 5 lines · Hans-Jürgen Koch
Quoted 2 lines
They use floating point in (Windows) kernelspace? Oh my.
To be honest, I never really understood where kernel space starts and user space ends in Windows, so I'm not sure about this :-)
Well, in Windows 95/98 you could do inportb (inb) and friends from "userspace" without an extra kernel driver. Maybe it just always ran in kernelspace, explains why many say 95/98 was less stable than the NT-based versions.
-`J'
Quoted 10 lines · Jan Engelhardt
Quoted 7 lines · Hans-Jürgen Koch
A small German manufacturer produces high-end AD converter cards. He sells 100 pieces per year, only in Germany and only with Windows drivers. He would now like to make his cards work with Linux. He has two driver programmers with little experience in writing Linux kernel drivers. What do you tell him? Write a large kernel module from scratch? Completely rewrite his code because it uses floating point arithmetics?
They use floating point in (Windows) kernelspace? Oh my.
Yes, definitely. For example lots of Windows sound drivers do AC3 decoding in kernelspace. Of course the vendors usually lie and say it's done in hardware...
Lee
Quoted 5 lines · Lee Revell
Quoted 2 lines · Jan Engelhardt
They use floating point in (Windows) kernelspace? Oh my.
Yes, definitely.
Explains why Windows is so slow ;-) [FPU restore and stuff...]
On that matter, when does the Linux kernel do proper FPU handling? At context switches? If so, would not that make a kthread fpu-capable?
Quoted 2 lines
For example lots of Windows sound drivers do AC3 decoding in kernelspace. Of course the vendors usually lie and say it's done in hardware...
They don't need to lie, the user buys it anyway...
-`J'
On Thu, 2006-12-14 at 10:56 +0100, Hans-Jürgen Koch wrote:
[....]
Quoted 6 lines
A small German manufacturer produces high-end AD converter cards. He sells 100 pieces per year, only in Germany and only with Windows drivers. He would now like to make his cards work with Linux. He has two driver programmers with little experience in writing Linux kernel drivers. What do you tell him? Write a large kernel module from scratch? Completely rewrite his code because it uses floating point arithmetics?
Find a Linux kernel guru/company and pay him/them for
-) an evaluation if it is "better" (for whatever better means) to port the driver
or write it from scratch and
-) do the better thing.
Bernd
Signature · 3 lines
Firmix Software GmbH http://www.firmix.at/
mobil: +43 664 4416156 fax: +43 1 7890849-55
Embedded Linux Development and ServicesAm Donnerstag, 14. Dezember 2006 18:34 schrieb Bernd Petrovitsch:
Quoted 9 lines · Hans-Jürgen Koch
[....]
Quoted 6 lines
A small German manufacturer produces high-end AD converter cards. He sells 100 pieces per year, only in Germany and only with Windows drivers. He would now like to make his cards work with Linux. He has two driver programmers with little experience in writing Linux kernel drivers. What do you tell him? Write a large kernel module from scratch? Completely rewrite his code because it uses floating point arithmetics?
Quoted 5 lines
Find a Linux kernel guru/company and pay him/them for
-) an evaluation if it is "better" (for whatever better means) to port the driver
or write it from scratch and
-) do the better thing.
Good idea - whatever "porting" means. There are lots of Windows drivers out there that are also partly user space using that Kithara stuff. They have most of their driver in a dll. So that is similar to what we want with UIO - except that we handle interrupts in a clean way, they don't.
If you need to port such a driver, simply writing a kernel module and a user space library would change so much of the concept that you can start rewriting it from scratch. And you'll have a large kernel module to maintain. OK, the guru/company can earn money with it, at least as long as the customer doesn't realize it is not the best solution for him.
Hans
Quoted 10 lines · Hans-Jürgen Koch
Am Donnerstag, 14. Dezember 2006 18:34 schrieb Bernd Petrovitsch:
Quoted 9 lines · Hans-Jürgen Koch
[....]
Quoted 6 lines
A small German manufacturer produces high-end AD converter cards. He sells 100 pieces per year, only in Germany and only with Windows drivers. He would now like to make his cards work with Linux. He has two driver programmers with little experience in writing Linux kernel drivers. What do you tell him? Write a large kernel module from scratch? Completely rewrite his code because it uses floating point arithmetics?
Quoted 7 lines
Quoted 5 lines
Find a Linux kernel guru/company and pay him/them for
-) an evaluation if it is "better" (for whatever better means) to port the driver
or write it from scratch and
-) do the better thing.Good idea - whatever "porting" means. There are lots of Windows drivers out there
Yes, I didn't want to open that can of worms.
Quoted 5 lines
that are also partly user space using that Kithara stuff. They have most of their driver in a dll. So that is similar to what we want with UIO - except that we handle interrupts in a clean way, they don't.
If you need to port such a driver, simply writing a kernel module and a user space library would change so much of the concept that you can start rewriting it from
Of course, if "better" means "as cheap as possible no matter what", this is probably the way to go.
Tough luck if you get into technical problems .....
Quoted 3 lines
scratch. And you'll have a large kernel module to maintain. OK, the guru/company can earn money with it, at least as long as the customer doesn't realize it is not the best solution for him.
Depending on the definition of "best".
Bernd
Signature · 3 lines
Firmix Software GmbH http://www.firmix.at/
mobil: +43 664 4416156 fax: +43 1 7890849-55
Embedded Linux Development and ServicesQuoted 6 lines · Duncan Sands
Quoted 1 line
I'm really not convinced about the user-mode thing unless somebody can show me a good reason for it. Not just some "wouldn't it be nice" kind of thing. A real, honest-to-goodness reason that we actually _want_ to see used.
Qemu? It would be nice if emulators could directly drive hardware:
useful for reverse engineering windows drivers for example.Duncan.
I have reverse engineered many windows drivers, and what you suggest is not at all helpful. For reverse engineering, one wants to see what is happening. I.e. capture all the IO, MMIO and DMA accesses. Your suggestion bypasses this possibility.
For reverse engineering windows drivers, one puts breakpoints in the HAL.DLL code or replaces the HAL.DLL code with a debugging version of it
while actually running windows.
Your approach runs into problems.
e.g
There is a register on the card that sets the DMA base address, but you don't know which register this is. If you let the driver inside QEMU write to this register, it will write values suitable for the Virtual machine instead of values suitable to for host OS. The DMA transaction will write all over the wrong memory location resulting in CRASH.
One might be able to get round some of these problem with a combination of QEMU and a hacked up HAL.DLL, but it will be complicated.
James
Quoted 1 line · Linus Torvalds
Ok, what kind of ass-hat idiotic thing is this?
C'mon, Linus, tell us how you _really_ feel.
Seriously, though, please please pretty please do not allow a facility for "going through a simple interface to get accesses to irqs and memory regions" into the mainline kernel, with or without toy ISA examples. Embedded systems integrators have enough trouble with chip vendors who think that exposing the device registers to userspace constitutes a "driver". The correct description is more like "porting shim for MMU-less RTOS tasks"; and if the BSP vendors of the world can make a nickel supplying them, more power to them. Just not in mainline, please.
Cheers,
- Michael
Quoted 4 lines · Michael K. Edwards
Seriously, though, please please pretty please do not allow a facility for "going through a simple interface to get accesses to irqs and memory regions" into the mainline kernel, with or without toy ISA examples.
Why? X does it today :)
Quoted 3 lines
Embedded systems integrators have enough trouble with chip vendors who think that exposing the device registers to userspace constitutes a "driver".
Yes, and because of this, they create binary only drivers today. Lots of them. All over the place. Doing crazy stupid crap in kernelspace.
Then there are people who do irq stuff in userspace but get it wrong. I've seen that happen many times in lots of different research papers and presentations.
This interface does it correctly, and it allows those people who for some reason feel they do want to keep their logic in non-gpl code, to do it.
It also allows code that needs floating point to not be in the kernel and in one instance using this interface actually sped up the device because of the lack of the need to go between kernel and userspace a bunch of times.
Quoted 3 lines
The correct description is more like "porting shim for MMU-less RTOS tasks"; and if the BSP vendors of the world can make a nickel supplying them, more power to them. Just not in mainline, please.
Again, X does this today, and does does lots of other applications. This is a way to do it in a sane manner, to keep people who want to do floating point out of the kernel, and to make some embedded people much happier to use Linux, gets them from being so mad at Linux because we keep changing the internal apis, and makes me happier as they stop violating my copyright by creating closed drivers in the kernel.
thanks,
greg k-h
Quoted 7 lines · Greg KH
Quoted 4 lines · Michael K. Edwards
Seriously, though, please please pretty please do not allow a facility for "going through a simple interface to get accesses to irqs and memory regions" into the mainline kernel, with or without toy ISA examples.
Why? X does it today :)
Umm ... and you're trying to use the current X model for a positive example of what we should be doing? that's ... interesting.
Quoted 6 lines
Quoted 3 lines
Embedded systems integrators have enough trouble with chip vendors who think that exposing the device registers to userspace constitutes a "driver".
Yes, and because of this, they create binary only drivers today. Lots of them. All over the place. Doing crazy stupid crap in kernelspace.
So let's come out and ban binary modules, rather than pussyfooting around, if that's what we actually want to do.
It comes down to a question of whether we have enough leverage to push them into doing what we want, or not - are we prepared to call their bluff?
The current half-assed solution of chipping slowly away at things by making them EXPORT_SYMBOL_GPL one by one makes little sense - would be better if we actually made an affirmative decision one way or the other. And yes, I know which side of that argument you'd fall on ;-)
Quoted 6 lines
Again, X does this today, and does does lots of other applications. This is a way to do it in a sane manner, to keep people who want to do floating point out of the kernel, and to make some embedded people much happier to use Linux, gets them from being so mad at Linux because we keep changing the internal apis, and makes me happier as they stop violating my copyright by creating closed drivers in the kernel.
I don't see how this really any different than letting them create GPL shims to export data to binary modules (aside from all the legal wanking over minutae details, which really isn't that interesting).
M.
Quoted 2 lines · On Wed, 13 Dec 2006 13:32:50 -0800 Martin Bligh <[email protected]> wrote:
So let's come out and ban binary modules, rather than pussyfooting around, if that's what we actually want to do.
Give people 12 months warning (time to work out what they're going to do, talk with the legal dept, etc) then make the kernel load only GPL-tagged modules.
I think I'd favour that. It would aid those people who are trying to obtain device specs, and who are persuading organisations to GPL their drivers.
(Whereas the patch which is proposed in this thread hinders those people)
GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 6 lines · Andrew Morton
Quoted 2 lines · On Wed, 13 Dec 2006 13:32:50 -0800 Martin Bligh <[email protected]> wrote:
So let's come out and ban binary modules, rather than pussyfooting around, if that's what we actually want to do.
Quoted 6 lines
Give people 12 months warning (time to work out what they're going to do, talk with the legal dept, etc) then make the kernel load only GPL-tagged modules.
I think I'd favour that. It would aid those people who are trying to obtain device specs, and who are persuading organisations to GPL their drivers.
Ok, I have no objection to that at all. I'll whip up such a patch in a bit to spit out kernel log messages whenever such a module is loaded so that people have some warning.
thanks,
greg k-h
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 11 lines · Greg KH
Quoted 10 lines · Andrew Morton
Quoted 2 lines · On Wed, 13 Dec 2006 13:32:50 -0800 Martin Bligh <[email protected]> wrote:
So let's come out and ban binary modules, rather than pussyfooting around, if that's what we actually want to do.
Give people 12 months warning (time to work out what they're going to do, talk with the legal dept, etc) then make the kernel load only GPL-tagged modules.
Quoted 6 lines
Quoted 2 lines
I think I'd favour that. It would aid those people who are trying to obtain device specs, and who are persuading organisations to GPL their drivers.
Ok, I have no objection to that at all. I'll whip up such a patch in a bit to spit out kernel log messages whenever such a module is loaded so that people have some warning.
Here you go. The wording for the feature-removal-schedule.txt file could probably be cleaned up. Any suggestions would be welcome.
thanks,
greg k-h
-----------
From: Greg Kroah-Hartmna <[email protected]>
Subject: Notify non-GPL module loading will be going away in January 2008
Numerous kernel developers feel that loading non-GPL drivers into the kernel violates the license of the kernel and their copyright. Because of this, a one year notice for everyone to address any non-GPL compatible modules has been set.
--- Documentation/feature-removal-schedule.txt | 9 +++++++++ kernel/module.c | 6 +++++- 2 files changed, 14 insertions(+), 1 deletion(-)
Documentation/feature-removal-schedule.txt +9 -0
@@ -281,3 +281,12 @@ Why: Speedstep-centrino driver with ACPI Who: Venkatesh Pallipadi <[email protected]> --------------------------- + +What: non GPL licensed modules will able to be loaded successfully. +When: January 2008 +Why: Numerous kernel developers feel that loading non-GPL drivers into the + kernel violates the license of the kernel and their copyright. + +Who: Greg Kroah-Hartman <[email protected]> or <[email protected]> + +---------------------------
kernel/module.c +5 -1
@@ -1393,9 +1393,13 @@ static void set_license(struct module *m license ="unspecified" ;if (!license_is_gpl_compatible (license)) { -if (!(tainted &TAINT_PROPRIETARY_MODULE )) +if (!(tainted &TAINT_PROPRIETARY_MODULE )) {printk (KERN_WARNING "%s: module license '%s' taints " "kernel.\n" , mod->name, license); +printk (KERN_WARNING "%s: This module will not be able " +"to be loaded after January 1, 2008 due to its " +"license.\n" , mod->name); + }add_taint_module (mod,TAINT_PROPRIETARY_MODULE ); } }
Jonathan Corbet
maintainerRe: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Greg's patch:
kernel/module.c static void set_license(struct module *m · line 1401
Quoted 3 lines
kernel/module.c +3
-0+printk (KERN_WARNING "%s: This module will not be able " +"to be loaded after January 1, 2008 due to its " +"license.\n" , mod->name);
If you're going to go ahead with this, shouldn't the message say that the module will not be loadable into *kernels released* after January 1, 2008? I bet a lot of people would read the above to say that their system will just drop dead of a New Year's hangover, and they'll freak. I wouldn't want to be the one getting all the email at that point...
jon
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 11 lines · Jonathan Corbet
Greg's patch:
Review
Quoted 3 lines
(quoted diff) +3
-0+ printk(KERN_WARNING "%s: This module will not be able " + "to be loaded after January 1, 2008 due to its " + "license.\n", mod->name);If you're going to go ahead with this, shouldn't the message say that the module will not be loadable into *kernels released* after January 1, 2008? I bet a lot of people would read the above to say that their system will just drop dead of a New Year's hangover, and they'll freak. I wouldn't want to be the one getting all the email at that point...
Heh, good point.
An updated version is below.
Oh, and for those who have asked me how we would enforce this after this date if this decision is made, I'd like to go on record that I will be glad to take whatever legal means necessary to stop people from violating this.
Someone also mentioned that we could just put a nice poem into the kernel module image in order to be able to enforce our copyright license in any court of law.
Full bellies of fish
Penguins sleep under the moon
Dream of wings that fly
thanks,
greg k-h
--------------
From: Greg Kroah-Hartmna <[email protected]>
Subject: Notify non-GPL module loading will be going away in January 2008
Numerous kernel developers feel that loading non-GPL drivers into the kernel violates the license of the kernel and their copyright. Because of this, a one year notice for everyone to address any non-GPL compatible modules has been set.
--- Documentation/feature-removal-schedule.txt | 9 +++++++++ kernel/module.c | 7 ++++++- 2 files changed, 15 insertions(+), 1 deletion(-)
Documentation/feature-removal-schedule.txt +9 -0
@@ -281,3 +281,12 @@ Why: Speedstep-centrino driver with ACPI Who: Venkatesh Pallipadi <[email protected]> --------------------------- + +What: non GPL licensed modules will able to be loaded successfully. +When: January 2008 +Why: Numerous kernel developers feel that loading non-GPL drivers into the + kernel violates the license of the kernel and their copyright. + +Who: Greg Kroah-Hartman <[email protected]> <[email protected]> + +---------------------------
kernel/module.c +6 -1
@@ -1393,9 +1393,14 @@ static void set_license(struct module *m license ="unspecified" ;if (!license_is_gpl_compatible (license)) { -if (!(tainted &TAINT_PROPRIETARY_MODULE )) +if (!(tainted &TAINT_PROPRIETARY_MODULE )) {printk (KERN_WARNING "%s: module license '%s' taints " "kernel.\n" , mod->name, license); +printk (KERN_WARNING "%s: This module will not be able " +"to be loaded in any kernel released after " +"January 1, 2008 due to its license.\n" , + mod->name); + }add_taint_module (mod,TAINT_PROPRIETARY_MODULE ); } }
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 4 lines · Greg KH
Full bellies of fish
Penguins sleep under the moon
Dream of wings that fly
Snif. That touched me deep inside.
Linus
PS. Or maybe it was the curry I ate yesterday.
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
fish for birds alone?
no, teach suits how to leave more
fish to go around
Cheers,
- Michael
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Greg KHHi,
I think that...
Quoted 1 line · Greg KH
From: Greg Kroah-Hartmna <[email protected]>
... (most probably) there...
Quoted 8 lines
Subject: Notify non-GPL module loading will be going away in January 2008
Numerous kernel developers feel that loading non-GPL drivers into the kernel violates the license of the kernel and their copyright. Because of this, a one year notice for everyone to address any non-GPL compatible modules has been set.
Signed-off-by Greg Kroah-Hartman <[email protected]>
... or (less probably) there...
is a typo in your name. :-)
Thanks,
Grzegorz Kulewski
PS. Are you _really_ sure you want this change accepted into mainline kernel?
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 16 lines · Grzegorz Kulewski
Hi,
I think that...
Quoted 1 line · Greg KH
From: Greg Kroah-Hartmna <[email protected]>
... (most probably) there...
Quoted 7 lines
Subject: Notify non-GPL module loading will be going away in January 2008
Numerous kernel developers feel that loading non-GPL drivers into the kernel violates the license of the kernel and their copyright. Because of this, a one year notice for everyone to address any non-GPL compatible modules has been set.
Quoted 5 lines
Quoted 1 line
Signed-off-by Greg Kroah-Hartman <[email protected]>... or (less probably) there...
is a typo in your name. :-)
Heh, thanks. I've also fixed up the wording in the feature-removal-schedule.txt file to say:
What: non-GPL-licensed modules will no longer be loaded.
The wording I had before was not very easy to understand.
Quoted 2 lines
PS. Are you _really_ sure you want this change accepted into mainline kernel?
Yes, I do.
thanks,
greg k-h
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Greg KHQuoted 5 lines · Greg KH
Numerous kernel developers feel that loading non-GPL drivers into the kernel violates the license of the kernel and their copyright. Because of this, a one year notice for everyone to address any non-GPL compatible modules has been set.
Btw, I really think this is shortsighted.
It will only result in _exactly_ the crap we were just trying to avoid, namely stupid "shell game" drivers that don't actually help anything at all, and move code into user space instead.
What was the point again?
Was the point to alienate people by showing how we're less about the technology than about licenses?
Was the point to show that we think we can extend our reach past derived work boundaries by just saying so?
The silly thing is, the people who tend to push most for this are the exact SAME people who say that the RIAA etc should not be able to tell people what to do with the music copyrights that they own, and that the DMCA is bad because it puts technical limits over the rights expressly granted by copyright law.
Doesn't anybody else see that as being hypocritical?
So it's ok when we do it, but bad when other people do it? Somehow I'm not surprised, but I still think it's sad how you guys are showing a marked two-facedness about this.
The fact is, the reason I don't think we should force the issue is very
simple: copyright law is simply _better_off_ when you honor the admittedly gray issue of "derived work". It's gray. It's not black-and-white. But being gray is _good_. Putting artificial black-and-white technical counter-measures is actually bad. It's bad when the RIAA does it, it's bad when anybody else does it.
If a module arguably isn't a derived work, we simply shouldn't try to say that its authors have to conform to our worldview.
We should make decisions on TECHNICAL MERIT. And this one is clearly being pushed on anything but.
I happen to believe that there shouldn't be technical measures that keep me from watching my DVD or listening to my music on whatever device I damn well please. Fair use, man. But it should go the other way too: we should not try to assert _our_ copyright rules on other peoples code that wasn't derived from ours, or assert _our_ technical measures that keep people from combining things their way.
If people take our code, they'd better behave according to our rules. But we shouldn't have to behave according to the RIAA rules just because we _listen_ to their music. Similarly, nobody should be forced to behave according to our rules just because they _use_ our system.
There's a big difference between "copy" and "use". It's exatcly the same issue whether it's music or code. You can't re-distribute other peoples music (becuase it's _their_ copyright), but they shouldn't put limits on how you personally _use_ it (because it's _your_ life).
Same goes for code. Copyright is about _distribution_, not about use. We shouldn't limit how people use the code.
Oh, well. I realize nobody is likely going to listen to me, and everybody has their opinion set in stone.
That said, I'm going to suggest that you people talk to your COMPANY LAWYERS on this, and I'm personally not going to merge that particular code unless you can convince the people you work for to merge it first.
In other words, you guys know my stance. I'll not fight the combined opinion of other kernel developers, but I sure as hell won't be the first to merge this, and I sure as hell won't have _my_ tree be the one that causes this to happen.
So go get it merged in the Ubuntu, (Open)SuSE and RHEL and Fedora trees first. This is not something where we use my tree as a way to get it to other trees. This is something where the push had better come from the other direction.
Because I think it's stupid. So use somebody else than me to push your political agendas, please.
Linus
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 10 lines · Linus Torvalds
Quoted 4 lines · Greg KH
Numerous kernel developers feel that loading non-GPL drivers into the kernel violates the license of the kernel and their copyright. Because of this, a one year notice for everyone to address any non-GPL compatible modules has been set.
Btw, I really think this is shortsighted.
It will only result in _exactly_ the crap we were just trying to avoid, namely stupid "shell game" drivers that don't actually help anything at all, and move code into user space instead.
I don't think pushing the drivers into userspace is a good idea at all, that wasn't what I was getting at. Pushing the problem into a different space doesn't fix it. IMHO, we're not a microkernel, and drivers for hardware belong in the kernel.
Whether we allow binary kernel modules or not, I don't think we should allow an API for userspace drivers - obviously that's not my call, it's yours, but at least I don't want my opinion / intent misinterpreted.
Quoted 4 lines
What was the point again?
Was the point to alienate people by showing how we're less about the technology than about licenses?
The point of banning binary drivers would be to leverage hardware companies into either releasing open source drivers, or the specs for someone else to write them. Whether we have that much leverage is debatable ... I suspect we do in some cases and not in others. It'll cause some pain, as well as some gain, but I think we'd live through it pretty well, personally.
The details of the legal minutiae are, I feel, less interesting than what goal we want to acheive. If we decided to get rid of binary drivers, we could likely find a way to achieve that. Is it a worthwhile goal?
I've done both Linux support, where binary drivers are involved, before, as well as supporting Sequent's Dynix/PTX in the face of a similar situation with CA Unicenter. It makes life extremely difficult, if not impossible for a support organisation, for fairly obvious and well known reasons. When there are two binary drivers from different vendors in there, any semblence of support becomes farcical.
The Ubuntu feisty fawn mess was a dangerous warning bell of where we're going. If we don't stand up at some point, and ban binary drivers, we will, I fear, end up with an unsustainable ecosystem for Linux when binary drivers become pervasive. I don't want to see Linux destroyed like that.
I don't think the motive behind what we decide to do should be decided by legal stuff, though I'm sure we'd have to wade through that to implement it. It's not about that ... it's about what kind of ecosystem we want to create, and whether that can be successful or not. Indeed, there are good arguments both for and against binary drivers on that basis.
But please can we have the pragmatic argument about what we want to achieve, and why ... rather than the legal / religious arguments about licenses? The law is a tool, not an end in itself.
If you don't feel it's legitimate to leverage that tool to achieve a pragmatic end, fair enough. But please don't assume that the motivation was legal / religious, at least not on my part.
Perhaps, in the end, we will decide we'd like to ban binary drivers, but can't. Either for pragmatic reasons (e.g. we don't have enough leverage to create the hardware support base), or for legal ones (we don't think it's enforcable). But we seem to be muddled between those different reasons right now, at least it seems that way to me.
I think allowing binary hardware drivers in userspace hurts our ability to leverage companies to release hardware specs. The 'grey water' of binary kernel drivers convinces a lot of them to release stuff, and Greg and others have pushed that cause, all credit to them. In one way, it does make the kernel easier to support, but I don't think it really helps much to make a supportable *system*.
M.
RE: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 2 lines
I think allowing binary hardware drivers in userspace hurts our ability to leverage companies to release hardware specs.
If filesystems can be in user space, why can't drivers be in user space? On what *technical* ground?
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 4 lines · On Wed, 13 Dec 2006 22:01:15 -0800 "Hua Zhong" <[email protected]> wrote:
Quoted 2 lines
I think allowing binary hardware drivers in userspace hurts our ability to leverage companies to release hardware specs.
If filesystems can be in user space, why can't drivers be in user space? On what *technical* ground?
The FUSE file system interface provides a clean disciplined interface which allows an fs to live in user space. The uio layer (if its ever fixed and cleaned up) provides some basic hooks that allow a user space program to arbitarily control hardware and make a nasty undebuggable mess.
uio also doesn't handle hotplug, pci and other "small" matters.
Now if you wanted to make uio useful at minimum you would need
- PCI support
- The ability to mark sets of I/O addresses for the card as "unmappable", "read only", "read-write", "any read/root write", "root read/write"
- A proper IRQ handler - A DMA interface - The ability to describe sharing rules
Which actually is a description of the core of the DRM layer.
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Am Donnerstag, 14. Dezember 2006 12:14 schrieb Alan:
Quoted 6 lines
Quoted 3 lines · On Wed, 13 Dec 2006 22:01:15 -0800 "Hua Zhong" <[email protected]> wrote:
Quoted 2 lines
I think allowing binary hardware drivers in userspace hurts our ability to leverage companies to release hardware specs.
Quoted 6 lines
Quoted 1 line
If filesystems can be in user space, why can't drivers be in user space? On what *technical* ground?
The FUSE file system interface provides a clean disciplined interface which allows an fs to live in user space. The uio layer (if its ever fixed and cleaned up) provides some basic hooks that allow a user space program to arbitarily control hardware and make a nasty undebuggable mess.
You think it's easier for a manufacturer of industrial IO cards to debug a (large) kernel module?
Quoted 2 lines
uio also doesn't handle hotplug, pci and other "small" matters.
uio is supposed to be a very thin layer. Hotplug and PCI are already handled by other subsystems.
Quoted 3 lines
Now if you wanted to make uio useful at minimum you would need
The majority of industrial IO cards have registers and/or dual port RAM that can be mapped to user space (even today). We want to add a simple way to handle interrupts for such cards. That's all.
The fact that there might be some sort of hardware/interrupts/situations where this is not possible or not so simple isn't that important at the moment. We can extend the UIO system if somebody actually requires these extensions.
Hans
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 2 lines · On Thu, 14 Dec 2006 12:31:16 +0100 Hans-Jürgen Koch <[email protected]> wrote:
You think it's easier for a manufacturer of industrial IO cards to debug a (large) kernel module?
You think its any easier to debug because the code now runs in ring 3 but accessing I/O space.
Quoted 4 lines
Quoted 1 line
uio also doesn't handle hotplug, pci and other "small" matters.
uio is supposed to be a very thin layer. Hotplug and PCI are already handled by other subsystems.
And if you have a PCI or a hotplug card ? How many industrial I/O cards are still ISA btw ?
Alan
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Am Donnerstag, 14. Dezember 2006 13:42 schrieb Alan:
Quoted 7 lines
Quoted 2 lines · On Thu, 14 Dec 2006 12:31:16 +0100 Hans-Jürgen Koch <[email protected]> wrote:
You think it's easier for a manufacturer of industrial IO cards to debug a (large) kernel module?
You think its any easier to debug because the code now runs in ring 3 but accessing I/O space.
For the intended audience, yes.
Quoted 9 lines
Quoted 6 lines
Quoted 3 lines
uio also doesn't handle hotplug, pci and other "small" matters.
uio is supposed to be a very thin layer. Hotplug and PCI are already handled by other subsystems.
And if you have a PCI or a hotplug card ? How many industrial I/O cards are still ISA btw ?
Who is talking about ISA? All cards we had in mind are PCI. Of course you have to do the usual initialization work in your probe/release or init/exit functions. These are just a few lines you find in any beginners device-driver-writing book. I don't think that the UIO framework could simplify that in a sensible way.
Hans
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 6 lines · Hans-J??rgen Koch
Am Donnerstag, 14. Dezember 2006 13:42 schrieb Alan:
Quoted 5 lines
Quoted 4 lines
Quoted 1 line
uio also doesn't handle hotplug, pci and other "small" matters.
uio is supposed to be a very thin layer. Hotplug and PCI are already handled by other subsystems.
Quoted 8 lines
Quoted 2 lines
And if you have a PCI or a hotplug card ? How many industrial I/O cards are still ISA btw ?
Who is talking about ISA? All cards we had in mind are PCI. Of course you have to do the usual initialization work in your probe/release or init/exit functions. These are just a few lines you find in any beginners device-driver-writing book. I don't think that the UIO framework could simplify that in a sensible way.
Agreed, you still have to write a kernel driver to handle the pci probe/disconnect functions and the pci id stuff to use the uio core properly. That's not in question here at all and please don't think that uio even attempts to handle this, as that is not what it's job is.
Think of uio as just a "class" of driver, like input or v4l. It's still up to the driver writer to provide a proper bus interface to the hardware (pci, usb, etc.) in order for the device to work at all.
thanks,
greg k-h
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 3 lines
Think of uio as just a "class" of driver, like input or v4l. It's still up to the driver writer to provide a proper bus interface to the hardware (pci, usb, etc.) in order for the device to work at all.
Understood. That leads me to ask another question of the folks who deal with a lot of these cards. How many could reasonably be described by the following
bar to map, offset, length, ro/rw, root/user, local-offset
(x n ?)
interrupt function or null
It seems if we have a lot of this kind of card that all fit that pattern it might actually get more vendors submitting updates if we had a single pci driver that took a struct of the above as the device_id field so vendors had to write five lines of IRQ code, a struct and update a PCI table ? That seems to have mostly worked with all the parallel/serial boards.
Alan
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 12 lines · Alan
Quoted 3 lines
Think of uio as just a "class" of driver, like input or v4l. It's still up to the driver writer to provide a proper bus interface to the hardware (pci, usb, etc.) in order for the device to work at all.
Understood. That leads me to ask another question of the folks who deal with a lot of these cards. How many could reasonably be described by the following
bar to map, offset, length, ro/rw, root/user, local-offset
(x n ?)
interrupt function or null
Quoted 6 lines
It seems if we have a lot of this kind of card that all fit that pattern it might actually get more vendors submitting updates if we had a single pci driver that took a struct of the above as the
device_idfield so vendors had to write five lines of IRQ code, a struct and update a PCI table ? That seems to have mostly worked with all the parallel/serial boards.
I think that something like this might work out, and it would be a good goal to get there eventually. But I would like to see a few drivers using the uio core to see where we can consolidate things like this first.
thanks,
greg k-h
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to AlanQuoted 7 lines · Alan
Quoted 2 lines · On Thu, 14 Dec 2006 12:31:16 +0100 Hans-Jürgen Koch <[email protected]> wrote:
You think it's easier for a manufacturer of industrial IO cards to debug a (large) kernel module?
You think its any easier to debug because the code now runs in ring 3 but accessing I/O space.
A NULL fault won't oops the system, but of course the wrong inb/inw/inl() or outb* can fubar the machine.
Quoted 7 lines
Quoted 4 lines
Quoted 1 line
uio also doesn't handle hotplug, pci and other "small" matters.
uio is supposed to be a very thin layer. Hotplug and PCI are already handled by other subsystems.
And if you have a PCI or a hotplug card ? How many industrial I/O cards are still ISA btw ?
Something called PC104 out there.
-`J'
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 10 lines · Jan Engelhardt
Quoted 7 lines · Alan
Quoted 2 lines · On Thu, 14 Dec 2006 12:31:16 +0100 Hans-Jürgen Koch <[email protected]> wrote:
You think it's easier for a manufacturer of industrial IO cards to debug a (large) kernel module?
You think its any easier to debug because the code now runs in ring 3 but accessing I/O space.
A NULL fault won't oops the system,
.. except when the userspace driver crashes as a result and then the hw still crashes the hw (for example via an irq storm or by tying the PCI bus or .. )
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 4 lines · Arjan van de Ven
Quoted 3 lines · Jan Engelhardt
Quoted 3 lines
On Thu, 14 Dec 2006 12:31:16 +0100
Hans-Jürgen Koch wrote:
Quoted 8 lines
Quoted 4 lines
Quoted 2 lines
You think its any easier to debug because the code now runs in ring 3 but accessing I/O space.
A NULL fault won't oops the system,
.. except when the userspace driver crashes as a result and then the hw still crashes the hw (for example via an irq storm or by tying the PCI bus or .. )
hw crashes the hw? Anyway, yes it might happen, the more with non-NULL pointers (dangling references f.ex.)
However, if the userspace part is dead, no one acknowledges the irq, hence an irq storm (if not caused by writing bogus stuff into registers) should not happen.
Quoted 2 lines
-`J'
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 14 lines · Jan Engelhardt
Quoted 4 lines · Arjan van de Ven
Quoted 3 lines · Jan Engelhardt
Quoted 3 lines
On Thu, 14 Dec 2006 12:31:16 +0100
Hans-Jürgen Koch wrote:Quoted 8 lines
Quoted 4 lines
Quoted 2 lines
You think its any easier to debug because the code now runs in ring 3 but accessing I/O space.
A NULL fault won't oops the system,
.. except when the userspace driver crashes as a result and then the hw still crashes the hw (for example via an irq storm or by tying the PCI bus or .. )
Quoted 5 lines
hw crashes the hw? Anyway, yes it might happen, the more with non-NULL pointers (dangling references f.ex.)
However, if the userspace part is dead, no one acknowledges the irq, hence an irq storm (if not caused by writing bogus stuff into registers) should not happen.
Shared level IRQ?
Gr{oetje,eeting}s,
Geert
--
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]
In personal conversations with technical people, I call myself a hacker. But when I'm talking to journalists I just say "programmer" or something like that.
-- Linus Torvalds
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Martin J. BlighQuoted 3 lines · Martin J. Bligh
The point of banning binary drivers would be to leverage hardware companies into either releasing open source drivers, or the specs for someone else to write them.
IMHO, it's up to the users to decide if they want to keep buying hardware which leads to inferior support, less reliability, decreased security and all of the other ills associated with binary drivers. Let them also choose distributions which enact the binary driver policies they agree with.
Linux is precisely not about forcing people to do things.
- James
Signature · 2 lines
James Morris <[email protected]>
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 6 lines · James Morris
Quoted 3 lines · Martin J. Bligh
The point of banning binary drivers would be to leverage hardware companies into either releasing open source drivers, or the specs for someone else to write them.
Quoted 6 lines
IMHO, it's up to the users to decide if they want to keep buying hardware which leads to inferior support, less reliability, decreased security and all of the other ills associated with binary drivers. Let them also choose distributions which enact the binary driver policies they agree with.
...
Unfortunately, we are living in an economic system with the strong tendency to create oligopolys.
Situations with only 1-3 manufacturers you can choose from are quite common (consider e.g. the 3D graphics market).
If you aren't a big company with big market power but a simple costumer who needs such hardware you have zero choice if all manufactorers only offer binary-only drivers at best.
And there's also the common misconception all costumers had enough information when buying something. If you are a normal Linux user and buy some hardware labelled "runs under Linux", it could turn out that's with a Windows driver running under ndiswrapper...
Quoted 1 line
- James
cu
Adrian
Signature · 4 lines
"Is there not promise of rain?" Ling Tan asked suddenly out
of the darkness. There had been need of rain for many days.
"Only a promise," Lao Er said.
Pearl S. Buck - Dragon SeedRE: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 5 lines
And there's also the common misconception all costumers had enough information when buying something. If you are a normal Linux user and buy some hardware labelled "runs under Linux", it could turn out that's with a Windows driver running under ndiswrapper...
That is something that I think is well worth fixing. Doesn't Linus own the trademark 'Linux'? How about some rules for use of that trademark and a 'Works with Linux' logo that can only be used if the hardware specifications are provided?
Let them provide a closed-source driver if they want. Let them provide user-space applications for which no source is provided if they want. But don't let them use the logo unless they release sufficient information to allow people to develop their own drivers and applications to interface with the hardware.
That makes it clear that it's not about giving us the fruits of years of your own work but that it's about enabling us to do our own work. (I would have no objection to also requiring them to provide a minimal open-source driver. I'm not trying to work out the exact terms here, just get the idea out.)
DS
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 11 lines · On Thu, 14 Dec 2006 12:08:11 -0800 "David Schwartz" <[email protected]>…
That is something that I think is well worth fixing. Doesn't Linus own the trademark 'Linux'? How about some rules for use of that trademark and a 'Works with Linux' logo that can only be used if the hardware specifications are provided?
Let them provide a closed-source driver if they want. Let them provide user-space applications for which no source is provided if they want. But don't let them use the logo unless they release sufficient information to allow people to develop their own drivers and applications to interface with the hardware.
This is the same I think, but not Linux specific:
http://wiki.duskglow.com/tiki-index.php?page=Open+Hardware+Foundation
------------------------------------------------------------------
P. Mc Namara 12 Jul 06: about the OHF foundation providing "certificates" for hardware, I'd propose (...) levels.
* First, any company that pledges full and complete interface and
behavioral documentation for a device, any docs necessary to make the device do everything it is designed to do, and makes it publicly available under nothing more cumbersome than the basic copyright that exists on all written works receives one certificate. Somebody else used "community friendly" or something similar. I don't know what to call it. Perhaps just "Open Documentation" (...)
* A company that contributes back to the community during the
development of a device get labeled "Community Supporter" or something similar.
* A company that enters into a legal agreement to release the
entire RTL and supporting information for a project at a given point in the future (far enough ahead to protect the companies commercial viability) can get the "Open Hardware" certificate.
------------------------------------------------------------------
Signature · 2 lines
Paolo Ornati Linux 2.6.18 on x86_64
RE: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to David SchwartzQuoted 9 lines · David Schwartz
Quoted 4 lines
And there's also the common misconception all costumers had enough information when buying something. If you are a normal Linux user and buy some hardware labelled "runs under Linux", it could turn out that's with a Windows driver running under ndiswrapper...
That is something that I think is well worth fixing. Doesn't Linus own the trademark 'Linux'? How about some rules for use of that trademark and a 'Works with Linux' logo that can only be used if the hardware specifications are provided?
Exactly my thoughts...
Quoted 11 lines
Let them provide a closed-source driver if they want. Let them provide user-space applications for which no source is provided if they want. But don't let them use the logo unless they release sufficient information to allow people to develop their own drivers and applications to interface with the hardware.
That makes it clear that it's not about giving us the fruits of years of your own work but that it's about enabling us to do our own work. (I would have no objection to also requiring them to provide a minimal open-source driver. I'm not trying to work out the exact terms here, just get the idea out.)
Since works with' may sound a bit too vague, something like LinuxFriendly(tm)', with a happy penguin logo?
Gr{oetje,eeting}s,
Geert
--
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]
In personal conversations with technical people, I call myself a hacker. But when I'm talking to journalists I just say "programmer" or something like that.
-- Linus Torvalds
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 19 lines · Geert Uytterhoeven
Quoted 9 lines · David Schwartz
Quoted 4 lines
And there's also the common misconception all costumers had enough information when buying something. If you are a normal Linux user and buy some hardware labelled "runs under Linux", it could turn out that's with a Windows driver running under ndiswrapper...
That is something that I think is well worth fixing. Doesn't Linus own the trademark 'Linux'? How about some rules for use of that trademark and a 'Works with Linux' logo that can only be used if the hardware specifications are provided?
Exactly my thoughts...
Quoted 6 lines
Let them provide a closed-source driver if they want. Let them provide user-space applications for which no source is provided if they want. But don't let them use the logo unless they release sufficient information to allow people to develop their own drivers and applications to interface with the hardware.
Quoted 8 lines
Quoted 5 lines
That makes it clear that it's not about giving us the fruits of years of your own work but that it's about enabling us to do our own work. (I would have no objection to also requiring them to provide a minimal open-source driver. I'm not trying to work out the exact terms here, just get the idea out.)
Since
works with' may sound a bit too vague, something likeLinuxFriendly(tm)', with a happy penguin logo?
I like this idea.
Greetings,
Rafael
Signature · 3 lines
If you don't have the time to read, you don't have the time or the tools to write. - Stephen King
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Geert UytterhoevenQuoted 2 lines · Geert Uytterhoeven
Since
works with' may sound a bit too vague, something likeLinuxFriendly(tm)', with a happy penguin logo?
It would be really cool to see penguin logos on hardware :)
I had another, probably crazy idea. Would it be possible to utilize the current vendor/device PCI ID database to create Linux friendliness matrix site?
And if you let yourself get carried away, you can also imagine a little multi-platform utility. It would run on a test system collecting PCI IDs before submitting them to the site to get the system's overall Linux friendliness rating.
In cases where the system contains devices which do not have entries in the database, the system could look up and use the vendor's Linux friendliness rating.
Something like that could really help end users to select the right system and would reward those who do the right thing.
Cheers,
Marek Wawrzyczny
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 3 lines · Marek Wawrzyczny
I had another, probably crazy idea. Would it be possible to utilize the current vendor/device PCI ID database to create Linux friendliness matrix site?
I've a script (attached) that looks into /lib/modules/uname -r/modules.pcimap, looks up the IDs in the pci id database and print the real name. At least it shows it's possible to know what devices are supported ...
#!/usr/bin/python
def pciids_to_names(ids):
# Only the last four numbers of the ids have useful info
vendorid = ids[1][6:10]
deviceid = ids[2][6:10]
subvendorid = ids[3][6:10]
subdeviceid = ids[4][6:10]
result = [ids[0], "", "", "", "", ""]
pciids = open('/usr/share/misc/pci.ids', 'r')
# Search for vendor
for line in pciids:
if line[0] == "#" or line[0] == "C" or line[0] == "\t":
continue
if line[0:4] == vendorid:
result[1] = line[6:].strip() # Vendor name
break
if result[1] == "": # Vendor not found
return result
# Search for a device
for line in pciids:
if line[0] != "\t":
continue
if line[1:5] == deviceid:
result[2] = line[7:].strip() # Device name
break
# Search a subsystem name
for line in pciids:
if line[2:11] == subvendorid + " " + subdeviceid: # subsystem name
result[3] = line[12:].strip() # The subvendor and subdevice ids point to a _single_ subsystem name
break
# Search a class name
if ids[5][4:6] == "00" and ids[5][6:8] == "00" and ids[5][6:8] == "00":
pass # void class ids
else:
pciids.seek(0)
# Search a class name
for line in pciids:
if line[0] == "C":
if line[2:4] == ids[5][4:6]: # found class
result[4] = line[6:].strip() # appended class name
break
if result[4] == "": # class not found
return result
# Search subclass name
for line in pciids:
if line [1:3] == ids[5][6:8]:
result[5] = line[5:].strip()
break
return result### Start of the code flow ###
import platform
pcimap = open('/lib/modules/' + platform.uname()[2] + '/modules.pcimap', 'r') previousmodule = ""
for line in pcimap:
if line[0] == "#" or line[0] == " ": continue data = line.split(None) ret = pciids_to_names(data) if ret[0] != previousmodule: previousmodule = ret[0] print "Driver: " + previousmodule if ret[2] == "": output = "\tDevice NOT found in the pciid database: " + repr(data) else: output = "\tDevice: " + ret[2] + " (deviceid " + data[2][6:] + "); made by " + ret[1] + " (vendorid " + data[1][6:] + ")" if ret[3] != "": output += "; Subsystem: " + ret[3] + " (subsysid " + data[3][6:] + ":" + data[4][6:] + ")" if ret[4] != "": output += "; Class: " + ret[4] if ret[5] != "": output += "; Subclass: " + ret[5] print output
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 1 line · Diego Calleja
El Tue, 19 Dec 2006 23:57:45 +1100, Marek Wawrzyczny
Quoted 8 lines · <[email protected]> escribió:
Quoted 3 lines
I had another, probably crazy idea. Would it be possible to utilize the current vendor/device PCI ID database to create Linux friendliness matrix site?
I've a script (attached) that looks into
/lib/modules/uname -r/modules.pcimap, looks up the IDs in the pci id database and print the real name. At least it shows it's possible to know what devices are supported ...
FWIW:
[root@coyote src]# python list-kernel-hardware.py Traceback (most recent call last):
File "list-kernel-hardware.py", line 70, in ?
ret = pciids_to_names(data)
File "list-kernel-hardware.py", line 11, in pciids_to_names
pciids = open('/usr/share/misc/pci.ids', 'r')IOError: [Errno 2] No such file or directory: '/usr/share/misc/pci.ids'
That file apparently doesn't exist on an FC6 i686 system
Signature · 7 lines
Cheers, Gene "There are four boxes to be used in defense of liberty: soap, ballot, jury, and ammo. Please use in that order." -Ed Howdershelt (Author) Yahoo.com and AOL/TW attorneys please note, additions to the above message by Gene Heskett are: Copyright 2006 by Maurice Eugene Heskett, all rights reserved.
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 10 lines · Gene Heskett
FWIW:
[root@coyote src]# pythonlist-kernel-hardware.pyTraceback (most recent call last):
File "list-kernel-hardware.py", line 70, in ?
ret =pciids_to_names(data)
File "list-kernel-hardware.py", line 11, inpciids_to_namespciids = open('/usr/share/misc/pci.ids', 'r')IOError: [Errno 2] No such file or directory: '
/usr/share/misc/pci.ids'That file apparently doesn't exist on an FC6 i686 system
s/misc/hwdata/ for FC and derivatives.
Bill
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 11 lines · Bill Nottingham
Quoted 10 lines · Gene Heskett
FWIW:
[root@coyote src]# pythonlist-kernel-hardware.pyTraceback (most recent call last):
File "list-kernel-hardware.py", line 70, in ?
ret =pciids_to_names(data)
File "list-kernel-hardware.py", line 11, inpciids_to_namespciids = open('/usr/share/misc/pci.ids', 'r')IOError: [Errno 2] No such file or directory:
'/usr/share/misc/pci.ids'
Quoted 5 lines
Quoted 1 line
That file apparently doesn't exist on an FC6 i686 system
s/misc/hwdata/ for FC and derivatives.
Bill
Ah, thanks. Verbose isn't it?
Signature · 7 lines
Cheers, Gene "There are four boxes to be used in defense of liberty: soap, ballot, jury, and ammo. Please use in that order." -Ed Howdershelt (Author) Yahoo.com and AOL/TW attorneys please note, additions to the above message by Gene Heskett are: Copyright 2006 by Maurice Eugene Heskett, all rights reserved.
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Gene HeskettQuoted 3 lines · Gene Heskett
IOError: [Errno 2] No such file or directory: '
/usr/share/misc/pci.ids'That file apparently doesn't exist on an FC6 i686 system
Indeed, I forgot to document that. Ubuntu has it there (package pciutils), and update-pciids updates the file from http://pciids.sourceforge.net/pci.ids. So you can download that file and change the path in the script.
Anyway, you can find the output at http://www.terra.es/personal/diegocg/list.txt
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Marek WawrzycznyQuoted 5 lines · Marek Wawrzyczny
Quoted 2 lines · Geert Uytterhoeven
Since
works with' may sound a bit too vague, something likeLinuxFriendly(tm)', with a happy penguin logo?It would be really cool to see penguin logos on hardware :)
The little Microsoft flag sticker that was on my Dell Latitude got replaced with a sticker that has a Tux and 'linux inside' on it. :)
Quoted 8 lines
I had another, probably crazy idea. Would it be possible to utilize the current vendor/device PCI ID database to create Linux friendliness matrix site?
And if you let yourself get carried away, you can also imagine a little multi-platform utility. It would run on a test system collecting PCI IDs before submitting them to the site to get the system's overall Linux friendliness rating.
This is a can of worms, and then some. For instance, let's consider this Latitude. *THIS* one has an NVidia Quadro NVS 110M in it. However, that's not the default graphics card on a Latitude D820. So what number do you put in? Do you use:
a) the *default* graphics card
b) the one *I* have with the open-source driver
c) the same one, but with the NVidia binary driver?
(Remember that "users" have different criteria than "developers" - most users would consider this entire thread "intellectual wanking", especially since the patch that spawned it got withdrawn. And 'Frames Per Second' trumps that stupid little 'P' in the oops message. Failure to understand this mindset guarantees that your computation of a "friendliness rating" is yet more intellectual wanking... ;)
Similar issues are involved with the wireless card - the Intel 3945 I have isn't the default. Repeat for several different disk options, and at least 4 or 5 different CD/ROM/DVD options. Add in the fact that Dell often changes suppliers for disk and CD/DVD drives, and you have a nightmare coming...
And then there's stuff on this machine that are *not* options, but don't matter to me. I see an 'O2 Micro' Firewire in the 'lspci' output. I have no idea how well it works. I don't care what it contributes to the score. On the other hand, somebody who uses external Firewire disk enclosures may be *very* concerned about it, but not care in the slightest about the wireless card.
Bonus points for figuring out what to do with systems that have some chip that's a supported XYZ driver, but wired up behind a squirrely bridge with some totally bizarre IRQ allocation, so you end up with something that's visible on lspci but not actually *usable* in any real sense of the term...
Quoted 2 lines
Something like that could really help end users to select the right system and would reward those who do the right thing.
"You are trapped in a maze of twisty little configurations, all different..."
RE: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 27 lines
This is a can of worms, and then some. For instance, let's consider this Latitude. *THIS* one has an NVidia Quadro NVS 110M in it. However, that's
not the default graphics card on a Latitude D820. So what number do you put in? Do you use:a) the *default* graphics card
b) the one *I* have with the open-source driver
c) the same one, but with the NVidia binary driver?Similar issues are involved with the wireless card - the Intel 3945 I have isn't the default. Repeat for several different disk options, and at least 4 or 5 different CD/ROM/DVD options. Add in the fact that Dell often changes suppliers for disk and CD/DVD drives, and you have a nightmare
coming...And then there's stuff on this machine that are *not* options, but don't matter to me. I see an 'O2 Micro' Firewire in the 'lspci' output. I have no idea how well it works. I don't care what it contributes to the score. On the other hand, somebody who uses external Firewire disk enclosures may be *very* concerned about it, but not care in the slightest about the wireless
card.
Quoted 5 lines
Bonus points for figuring out what to do with systems that have some chip that's a supported XYZ driver, but wired up behind a squirrely bridge with some totally bizarre IRQ allocation, so you end up with something that's visible on lspci but not actually *usable* in any real sense of the term...
Let's not let the perfect be the enemy of the good. Remember, the goal is to allow consumers to know whether or not their system's hardware specifications are available. It's not about driver availability -- if the hardware specifications are available and a driver is not, that's not the hardware manufacturer's fault.
Linux is about *allowing* people to do things.
DS
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 5 lines · David Schwartz
Let's not let the perfect be the enemy of the good. Remember, the goal is to allow consumers to know whether or not their system's hardware specifications are available. It's not about driver availability -- if the hardware specifications are available and a driver is not, that's not the hardware manufacturer's fault.
My point was "their system's hardware specifications" is, for some popular vendors, a *very* fuzzy notion. You can't (for instance) say "specs are available for a Dell Latitude D820" - there are configurations that specs are available for, and configs that aren't. My D820 has an NVidia card in it - we know the answer there. Do you give a different answer for a D820 that has the Intel i950 graphics chipset instead?
Even more annoying, Dell often *changes* the vendor - the line item for the DVD drive says "8X DVD+/-RW" (other choices include 24X CD-ROM and 24X CD-RW/DVD). Mine showed up with a Philips SDVD8820 - but it's possible that some other D820 will get some other vendor's DVD (I've seen 2 C820's ordered at the same time, they showed up with 2 different vendor's "24X CD-RW/DVD"). It's possible that some poor guy is going to get a D820 that has a DVD that we have a known buggy driver for - what do we tell *them*?
It's *easy* to do a "semi-good" that tells you if there's drivers for the hardware config you're running the program on. But there's 2 problems:
a) You probably already know the answer
b) By the time you can run the program, it's often too late....
So given those 2 points, what actual value-added info does this *give*, over and above 'lspci' and friends? I suppose maybe for a install CD, it gives a quick way to cleanly abort the install with a "Don't bother continuing unless it's OK that your graphics/wireless/whatever won't work". On the other hand, the installer should have a grasp on this *already*....
Perfect may be the enemy of the good, but the good is also the enemy of stuff claiming to be good but misses on an important design goal...
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 29 lines · On Wed, 20 Dec 2006, [email protected] wrote:
Quoted 5 lines · David Schwartz
Let's not let the perfect be the enemy of the good. Remember, the goal is to allow consumers to know whether or not their system's hardware specifications are available. It's not about driver availability -- if the hardware specifications are available and a driver is not, that's not the hardware manufacturer's fault.
My point was "their system's hardware specifications" is, for some popular vendors, a *very* fuzzy notion. You can't (for instance) say "specs are available for a Dell Latitude D820" - there are configurations that specs are available for, and configs that aren't. My D820 has an NVidia card in it - we know the answer there. Do you give a different answer for a D820 that has the Intel i950 graphics chipset instead?
Even more annoying, Dell often *changes* the vendor - the line item for the DVD drive says "8X DVD+/-RW" (other choices include 24X CD-ROM and 24X CD-RW/DVD). Mine showed up with a Philips SDVD8820 - but it's possible that some other D820 will get some other vendor's DVD (I've seen 2 C820's ordered at the same time, they showed up with 2 different vendor's "24X CD-RW/DVD"). It's possible that some poor guy is going to get a D820 that has a DVD that we have a known buggy driver for - what do we tell *them*?
It's *easy* to do a "semi-good" that tells you if there's drivers for the hardware config you're running the program on. But there's 2 problems:
a) You probably already know the answer
b) By the time you can run the program, it's often too late....
Quoted 8 lines
So given those 2 points, what actual value-added info does this *give*, over and above 'lspci' and friends? I suppose maybe for a install CD, it gives a quick way to cleanly abort the install with a "Don't bother continuing unless it's OK that your graphics/wireless/whatever won't work". On the other hand, the installer should have a grasp on this *already*....
Perfect may be the enemy of the good, but the good is also the enemy of stuff claiming to be good but misses on an important design goal...
Valid points, but they are almost more for the distribution than they are for the kernel.
I have considered designing a routine for use in Annaconda or some other installer that lists all the known hardware and how much of it will actually work with that particular distro. I know some people will not care, but many will. (Especially the people who ask "Will my machine work with Linux".)
Many people do not know what they have in the way of hardware. They bought a machine. What they were sold (or requested) and what they got are usually two different things. They may know a few specifics, but they are probably missing important details. (How many people know the model of PCI chip in their machine? Or who made the IDE chipset? Or the ethernet chipset on the motherboard?) For those of us that deal with hardware every day, this is not as big of an issue as those who bought something from Dell or HP and it arrived in a big box pre-assembled.
Is there some way to look at a kernel and determine what drivers are "good" and those that are "less good"? (Other than ordering Alan Cox's brain in a jar...) What needs to be known is the state of the driver for kernel X where X maybe something current or woefully out of date.
Maybe instead of an EXPORT_GPL symbol we need a EXPORT_THIS_DRIVER_IS_CRAP symbol.
Signature · 2 lines
Q: Why do programmers confuse Halloween and Christmas? A: Because OCT 31 == DEC 25
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to [email protected]Quoted 11 lines · On Wednesday 20 December 2006 16:11, [email protected] wrote:
Quoted 5 lines · Marek Wawrzyczny
On Sunday 17 December 2006 21:11, Geert Uytterhoeven wrote:
And if you let yourself get carried away, you can also imagine a little multi-platform utility. It would run on a test system collecting PCI IDs before submitting them to the site to get the system's overall Linux friendliness rating.This is a can of worms, and then some. For instance, let's consider this Latitude. *THIS* one has an NVidia Quadro NVS 110M in it. However, that's not the default graphics card on a Latitude D820. So what number do you put in? Do you use:
No, no, no... I was never proposing that. I was thinking of something more along the lines of reporting back on open-source friendliness of manufacturers of devices, and perhaps on the availability of open source drivers for the devices. I am talking only about "detected" devices. The database would never try and guess the vendor, model and variation of the system.
Quoted 6 lines
(Remember that "users" have different criteria than "developers" - most users would consider this entire thread "intellectual wanking", especially since the patch that spawned it got withdrawn. And 'Frames Per Second' trumps that stupid little 'P' in the oops message. Failure to understand this mindset guarantees that your computation of a "friendliness rating" is yet more intellectual wanking... ;)
I actually find that trying to obtain information about what hardware is/isn't supported in Linux is actually quite difficult to obtain. The information that's on the internet is either outdated or has not yet been written. I was hoping to analyze the system's device information together with driver/device information obtained from the kernel source itself to give users a better (but not perhaps not as authoritative as I'd like to) picture of what to expect.
Quoted 6 lines
And then there's stuff on this machine that are *not* options, but don't matter to me. I see an 'O2 Micro' Firewire in the 'lspci' output. I have no idea how well it works. I don't care what it contributes to the score. On the other hand, somebody who uses external Firewire disk enclosures may be *very* concerned about it, but not care in the slightest about the wireless card.
Perhaps we just report on the individual devices then... forget the system rating.
Quoted 4 lines
Bonus points for figuring out what to do with systems that have some chip that's a supported XYZ driver, but wired up behind a squirrely bridge with some totally bizarre IRQ allocation, so you end up with something that's visible on lspci but not actually *usable* in any real sense of the term...
Hmmm... does this happen often? False results are definedly a show stopper.
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Marek Wawrzyczny <[email protected]> wrote:
[...]
Quoted 6 lines
No, no, no... I was never proposing that. I was thinking of something more along the lines of reporting back on open-source friendliness of manufacturers of devices, and perhaps on the availability of open source drivers for the devices. I am talking only about "detected" devices. The database would never try and guess the vendor, model and variation of the system.
This is a /massive/ ammount of effort, and the data required is hard to come by before buying, so it is rather useless. What chip is in NetworkCard 675? In 675a? (yes, I've seen dLink cards called <foo> and <foo>+ which were /radically/ different!). Yes, here you go to the computer store and ask them to build you a machine from parts you specify. But it is far from the common way to get a PC (those stores mostly cater to heavy-weight gamers, many pieces have to be special ordered), and building a machine that works OK with Linux is a two or three day exercise in hunting down specifications for compatible pieces. Most folks wander into the next department store and buy a PC. Mostly terrible crap, BTW.
Where this makes sense (printers!) the data is there, mostly up to date, and accurate.
[...]
Quoted 7 lines
I actually find that trying to obtain information about what hardware is/isn't supported in Linux is actually quite difficult to obtain. The information that's on the internet is either outdated or has not yet been written. I was hoping to analyze the system's device information together with driver/device information obtained from the kernel source itself to give users a better (but not perhaps not as authoritative as I'd like to) picture of what to expect.
There is just way too much hardware out there, and new pieces come out every day. Then there are lots of integrators that buy chips and build PCI cards. Sometimes cards with supported chips just don't work at all. Etc. It is all over the map.
Besides, many times you don't find information on some piece of hardware it is because it is dirt cheap stuff that has no chance of working, so nobody even tried.
[...]
Quoted 7 lines
Quoted 4 lines
Bonus points for figuring out what to do with systems that have some chip that's a supported XYZ driver, but wired up behind a squirrely bridge with some totally bizarre IRQ allocation, so you end up with something that's visible on lspci but not actually *usable* in any real sense of the term...
Hmmm... does this happen often? False results are definedly a show stopper.
Not just for systems, even for individual cards.
Signature · 4 lines
Dr. Horst H. von Brand User #22616 counter.li.org Departamento de Informatica Fono: +56 32 2654431 Universidad Tecnica Federico Santa Maria +56 32 2654239 Casilla 110-V, Valparaiso, Chile Fax: +56 32 2797513
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Marek WawrzycznyQuoted 10 lines · Marek Wawrzyczny
Quoted 7 lines
And then there's stuff on this machine that are *not* options, but don't matter to me. I see an 'O2 Micro' Firewire in the 'lspci' output. I have no idea how well it works. I don't care what it contributes to the score. On the other hand, somebody who uses external Firewire disk enclosures may be *very* concerned about it, but not care in the slightest about the wireless card.
Perhaps we just report on the individual devices then... forget the system rating.
OK, *that* I see as potentially useful - I frequently get handed older boxen with strange gear in them, and need a way to figure out if I want to install software, or cannibalize it for parts. Also helpful if a buddy has a Frankintel box they build, and they want to know if they can install something other than Windows....
Bonus points if it sees a card that has a known out-of-tree driver and tells you where to find it and what its license status is (I just went down that road with an Intel 3945)...
Quoted 6 lines
Quoted 4 lines
Bonus points for figuring out what to do with systems that have some chip that's a supported XYZ driver, but wired up behind a squirrely bridge with some totally bizarre IRQ allocation, so you end up with something that's visible on lspci but not actually *usable* in any real sense of the term...
Hmmm... does this happen often? False results are definedly a show stopper.
Oh, we see reports of squirrelly or downright confused hardware all the time on this list. :)
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 1 line · [email protected] wrote:
On Fri, 22 Dec 2006 02:34:54 +1100, Marek Wawrzyczny said:
[...]
Quoted 5 lines
Quoted 2 lines
Perhaps we just report on the individual devices then... forget the system rating.
OK, *that* I see as potentially useful - I frequently get handed older boxen with strange gear
== gear for which there is probably no documentation at all
Quoted 2 lines
in them, and need a way to figure out if I want to
install software,
LiveCD of your choice...
Quoted 3 lines
or cannibalize it for parts. Also helpful if a buddy has
a Frankintel box they build, and they want to know if they can install something other than Windows....
Same as above.
Quoted 3 lines
Bonus points if it sees a card that has a known out-of-tree driver and tells you where to find it and what its license status is (I just went down that road with an Intel 3945)...
If in-tree driver is already a challange, out-of-tree is hopeless.
Signature · 4 lines
Dr. Horst H. von Brand User #22616 counter.li.org Departamento de Informatica Fono: +56 32 2654431 Universidad Tecnica Federico Santa Maria +56 32 2654239 Casilla 110-V, Valparaiso, Chile Fax: +56 32 2797513
RE: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Geert UytterhoevenQuoted 11 lines · Geert Uytterhoeven
Quoted 5 lines · David Schwartz
That makes it clear that it's not about giving us the fruits of years of your own work but that it's about enabling us to do our own work. (I would have no objection to also requiring them to provide a minimal open-source driver. I'm not trying to work out the exact terms here, just get the idea out.)
Since
works with' may sound a bit too vague, something likeLinuxFriendly(tm)', with a happy penguin logo?
I've bought a couple of products lately that had the happy penguin logo on it. Just to find out that they only applied a bare minimum functionality of the device for Linux. If you want more, you need to plug it into a Windows box.
Funny, if you own a Mac, it had the same problem. It had a little more functionality than the Linux port, but still far from what they give for Windows.
I like the Open Hardware thing that Paolo mentioned.
-- Steve
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Martin J. BlighQuoted 5 lines · Martin J. Bligh
The Ubuntu feisty fawn mess was a dangerous warning bell of where we're going. If we don't stand up at some point, and ban binary drivers, we will, I fear, end up with an unsustainable ecosystem for Linux when binary drivers become pervasive. I don't want to see Linux destroyed like that.
Thing is, if kernel.org kernels get patched to disallow binary modules, whats to stop Ubuntu (or anyone else) reverting that change in the kernels they distribute ? The landscape doesn't really change much, given that the majority of Linux end-users are probably running distro kernels.
Dave
Signature · 1 line
http://www.codemonkey.org.uk
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 8 lines · Dave Jones
Quoted 5 lines · Martin J. Bligh
The Ubuntu feisty fawn mess was a dangerous warning bell of where we're going. If we don't stand up at some point, and ban binary drivers, we will, I fear, end up with an unsustainable ecosystem for Linux when binary drivers become pervasive. I don't want to see Linux destroyed like that.
Quoted 5 lines
Thing is, if kernel.org kernels get patched to disallow binary modules, whats to stop Ubuntu (or anyone else) reverting that change in the kernels they distribute ? The landscape doesn't really change much, given that the majority of Linux end-users are probably running distro kernels.
If a kernel developer or a competitor sends a cease&desist letter to such a distribution, the situation changes from a complicated "derived work" discussion to a relatively clear "They circumvented a technical measure to enforce the copyright.".
Quoted 1 line
Dave
cu
Adrian
Signature · 4 lines
"Is there not promise of rain?" Ling Tan asked suddenly out
of the darkness. There had been need of rain for many days.
"Only a promise," Lao Er said.
Pearl S. Buck - Dragon SeedRe: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 9 lines · Adrian Bunk
Quoted 7 lines · Dave Jones
On Wed, Dec 13, 2006 at 09:39:11PM -0800, Martin J. Bligh wrote:
Thing is, if kernel.org kernels get patched to disallow binary modules, whats to stop Ubuntu (or anyone else) reverting that change in the kernels they distribute ? The landscape doesn't really change much, given that the majority of Linux end-users are probably running distro kernels.
Quoted 4 lines
If a kernel developer or a competitor sends a cease&desist letter to such a distribution, the situation changes from a complicated "derived work" discussion to a relatively clear "They circumvented a technical measure to enforce the copyright.".
C&D's don't work that way. They can enforce "don't ship my code" but not "ship my code, or else". The modification would be just like any other thats allowable by the GPL.
Dave
Signature · 1 line
http://www.codemonkey.org.uk
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 9 lines · Dave Jones
Quoted 4 lines · Adrian Bunk
If a kernel developer or a competitor sends a cease&desist letter to such a distribution, the situation changes from a complicated "derived work" discussion to a relatively clear "They circumvented a technical measure to enforce the copyright.".
C&D's don't work that way. They can enforce "don't ship my code" but not "ship my code, or else". The modification would be just like any other thats allowable by the GPL.
Careful here. The "technical measure" protection is something unrelated to the copyright license itself. Cf the streambox vcr lawsuit for instance (settled though) where not implementing the handling of one bit that said "don't save to disk" in original code seemed to be illegal.
OG.
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Dave JonesQuoted 8 lines · Dave Jones
Quoted 5 lines · Martin J. Bligh
The Ubuntu feisty fawn mess was a dangerous warning bell of where we're going. If we don't stand up at some point, and ban binary drivers, we will, I fear, end up with an unsustainable ecosystem for Linux when binary drivers become pervasive. I don't want to see Linux destroyed like that.
Quoted 5 lines
Thing is, if kernel.org kernels get patched to disallow binary modules, whats to stop Ubuntu (or anyone else) reverting that change in the kernels they distribute ? The landscape doesn't really change much, given that the majority of Linux end-users are probably running distro kernels.
I don't think they'd dare spit in our faces quite that directly. They think binary modules are permissible because we don't seem to have consistently stated an intent contradicting that - some individual developers have, but ultimately Linus hasn't.
I'm not talking about any legal issues to do with derived works, copyrights or licenses - a clear statement of intent is probably all it'd take to tip the balance.
M.
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Dave JonesQuoted 7 lines
Quoted 6 lines
The Ubuntu feisty fawn mess was a dangerous warning bell of where we're going. If we don't stand up at some point, and ban binary drivers, we will, I fear, end up with an unsustainable ecosystem for Linux when binary drivers become pervasive. I don't want to see Linux destroyed like that.
Quoted 5 lines
Thing is, if kernel.org kernels get patched to disallow binary modules, whats to stop Ubuntu (or anyone else) reverting that change in the kernels they distribute ? The landscape doesn't really change much, given that the majority of Linux end-users are probably running distro kernels.
And even if the distros don't change it (all legal issues aside), there's probably some free user who repacks the distro kernel.
/me eyeballs myself... -`J'
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Martin J. BlighQuoted 5 lines · Martin J. Bligh
The Ubuntu feisty fawn mess was a dangerous warning bell of where we're going. If we don't stand up at some point, and ban binary drivers, we will, I fear, end up with an unsustainable ecosystem for Linux when binary drivers become pervasive. I don't want to see Linux destroyed like that.
Yes, people have been worried about this for years, and to my knowledge, it seems like things have been getting better with drivers, not worse (look at Intel). And yet, people want to enforce more and more restrictions against binary-only drivers, when it appears that we are already winning.
You can't talk about drivers that don't exist for Linux. Things like bcm43xx aren't effected by this new restriction for GPL-only drivers. There's no binary-only driver for it (ndiswrapper doesn't count). If the hardware vendor doesn't want to write a driver for linux, you can't make them. You can buy other hardware, but that's about it.
Here's the list of proprietary drivers that are in Ubuntu's restricted modules package:
madwifi (closed hal implementation, being replaced in openhal) fritz
ati
nvidia
ltmodem (does that even still work?)
ipw3945d (not a kernel module, but just the daemon)
In over a year that list has only grown by ipw3945d. None of our users are asking for new proprietary drivers. Believe me, if they needed them, I'd hear about it. We have more cases of new unsupported hardware than we do of new hardware with binary-only drivers. This proposed restriction doesn't fix that.
You know what I think hurts us more than anything? You know what probably keeps companies from writing drivers or releasing specs? It's because they know some non-paid kernel hackers out there will eventually reverse engineer it and write the drivers for them. Free development, and they didn't even have to release their precious specs.
Don't get me wrong, I'm not bashing reverse engineering, or writing our own drivers. It's how Linux got started. But the problem isn't as narrow as people would like to think. And proprietary code isn't a growing problem. At best, it's just a distraction that will eventually go away on it's own.
The whole hardware vendor landscape is showing this, and it's not because we locked down the kernel, it's because we've shown how well we play with others, and how easy it is to get along with the whole community. Do we want to destroy this good will?
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 11 lines · Ben Collins
Here's the list of proprietary drivers that are in Ubuntu's restricted modules package:
madwifi (closed hal implementation, being replaced in openhal) fritz
ati
nvidia
ltmodem (does that even still work?)
ipw3945d (not a kernel module, but just the daemon)
More items will be added to that list soon.
E.g. Linux Binary only, Creative X-Fi sound card drivers for Q2 2007.
http://opensource.creative.com/
Quoted 5 lines
In over a year that list has only grown by ipw3945d. None of our users are asking for new proprietary drivers. Believe me, if they needed them, I'd hear about it. We have more cases of new unsupported hardware than we do of new hardware with binary-only drivers. This proposed restriction doesn't fix that.
Is there a list of "new unsupported hardware" ?
Reverse engineering or datasheets is the only way out of that.
As Linux becomes more and more popular on the desktop, manufacturers will start feeling the pain of Linux "unsupported hardware" and have to back down and release datasheets. Ubuntu is helping a lot in that direction.
Quoted 6 lines
You know what I think hurts us more than anything? You know what probably keeps companies from writing drivers or releasing specs? It's because they know some non-paid kernel hackers out there will eventually reverse engineer it and write the drivers for them. Free development, and they didn't even have to release their precious specs.
Well, once a device has been reverse engineered and GPLed, the specs are then in public domain and the IP does not exist any more. It actually helps the company release the specs once the information is already out there. The company then sees less reason to hold onto their specs in the first place, and tends to release them earlier next time.
Quoted 7 lines
Don't get me wrong, I'm not bashing reverse engineering, or writing our own drivers. It's how Linux got started. But the problem isn't as narrow as people would like to think. And proprietary code isn't a growing problem. At best, it's just a distraction that will eventually go away on it's own.
I agree, as time goes by, more and more devices are reverse engineered or the manufacturer finally sees sense and releases the specs/datasheets.
James
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 3 lines · James Courtier-Dutton
More items will be added to that list soon.
E.g. Linux Binary only, Creative X-Fi sound card drivers for Q2 2007.
http://opensource.creative.com/
Wow. That wins 'most ironic hostname' award for 2006. Thankfully onboard hardware is "good enough" for most end-users these days, leaving just the high-end audio professionals in the lurch.
Dave
Signature · 1 line
http://www.codemonkey.org.uk
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to James Courtier-DuttonQuoted 13 lines · James Courtier-Dutton
Quoted 11 lines · Ben Collins
Here's the list of proprietary drivers that are in Ubuntu's restricted modules package:
madwifi (closed hal implementation, being replaced in openhal) fritz
ati
nvidia
ltmodem (does that even still work?)
ipw3945d (not a kernel module, but just the daemon)
Quoted 3 lines
More items will be added to that list soon.
E.g. Linux Binary only, Creative X-Fi sound card drivers for Q2 2007.
http://opensource.creative.com/
I haven't even caught wind of this not being supported yet. No demand == no reason to include it when it does become available.
Quoted 11 lines
Quoted 5 lines
In over a year that list has only grown by ipw3945d. None of our users are asking for new proprietary drivers. Believe me, if they needed them, I'd hear about it. We have more cases of new unsupported hardware than we do of new hardware with binary-only drivers. This proposed restriction doesn't fix that.
Is there a list of "new unsupported hardware" ?
Reverse engineering or datasheets is the only way out of that. As Linux becomes more and more popular on the desktop, manufacturers will start feeling the pain of Linux "unsupported hardware" and have to back down and release datasheets. Ubuntu is helping a lot in that direction.
I've not kept a list. Would be non-trivial to go through the bug tracker to find this info. Mostly it's things like webcams, and wacky little hardware that starts cropping up in laptops.
Quoted 7 lines
Quoted 6 lines
You know what I think hurts us more than anything? You know what probably keeps companies from writing drivers or releasing specs? It's because they know some non-paid kernel hackers out there will eventually reverse engineer it and write the drivers for them. Free development, and they didn't even have to release their precious specs.
Quoted 5 lines
Well, once a device has been reverse engineered and GPLed, the specs are then in public domain and the IP does not exist any more. It actually helps the company release the specs once the information is already out there. The company then sees less reason to hold onto their specs in the first place, and tends to release them earlier next time.
Right, I think reverse engineering does help in that aspect. The other aspect is that they now have a driver that sort of works for their hardware. Most of the work is done, and they decide to help things along to make it stable. So laying ground work like this can have advantages.
I think hardware vendors are a lot like users. Once they see the advantages to opening up their drivers, they wonder why they didn't do it a long time ago. Sort of like how users need that one push to use Linux, and they start to wonder why they should go back to Windows.
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Ben CollinsQuoted 6 lines
You know what I think hurts us more than anything? You know what probably keeps companies from writing drivers or releasing specs? It's because they know some non-paid kernel hackers out there will eventually reverse engineer it and write the drivers for them. Free development, and they didn't even have to release their precious specs.
I don't get them either. If reverse-engineering will release their precious trade secrets they wanted to protect by making the thing closed, they could have just asked someone to write a linux driver for free if they don't have the guts to actually pay qualified/experienced developers.
-`J'
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Ben CollinsQuoted 5 lines · Ben Collins
You can't talk about drivers that don't exist for Linux. Things like bcm43xx aren't effected by this new restriction for GPL-only drivers. There's no binary-only driver for it (ndiswrapper doesn't count). If the hardware vendor doesn't want to write a driver for linux, you can't make them. You can buy other hardware, but that's about it.
Not that is matters in this discussion, but there are binary Broadcom 43xx drivers for linux available.
Quoted 5 lines
Here's the list of proprietary drivers that are in Ubuntu's restricted modules package:
madwifi (closed hal implementation, being replaced in openhal) fritz
Well, that's not just one, right?
That's like, 10 or so for the different AVM cards. I'm just estimating. Correct me, if I'm wrong.
(And if I didn't mention it yet; AVM binary drivers are complete crap.)
Quoted 10 lines
ati
nvidia
ltmodem (does that even still work?) ipw3945d (not a kernel module, but just the daemon)Don't get me wrong, I'm not bashing reverse engineering, or writing our own drivers. It's how Linux got started. But the problem isn't as narrow as people would like to think. And proprietary code isn't a growing problem. At best, it's just a distraction that will eventually go away on it's own.
Well, I _hope_ that, too.
Signature · 1 line
Greetings Michael.
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 13 lines · Michael Buesch
Quoted 5 lines · Ben Collins
You can't talk about drivers that don't exist for Linux. Things like bcm43xx aren't effected by this new restriction for GPL-only drivers. There's no binary-only driver for it (ndiswrapper doesn't count). If the hardware vendor doesn't want to write a driver for linux, you can't make them. You can buy other hardware, but that's about it.
Not that is matters in this discussion, but there are binary Broadcom 43xx drivers for linux available.
Quoted 3 lines
Here's the list of proprietary drivers that are in Ubuntu's restricted modules package:
Quoted 6 lines
Quoted 2 lines
madwifi (closed hal implementation, being replaced in openhal) fritz
Well, that's not just one, right?
That's like, 10 or so for the different AVM cards. I'm just estimating. Correct me, if I'm wrong.
One driver, many variations of the chipset. That's true of most drivers.
Quoted 2 lines
(And if I didn't mention it yet; AVM binary drivers are complete crap.)
Wont disagree with you there.
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Linus TorvaldsWell said, and I agree with ALL of your statements contained in this post. About damn time this was addressed.
Jeff
Quoted 59 lines · Linus Torvalds
Quoted 6 lines · Greg KH
Numerous kernel developers feel that loading non-GPL drivers into the kernel violates the license of the kernel and their copyright. Because of this, a one year notice for everyone to address any non-GPL compatible modules has been set.
Btw, I really think this is shortsighted.
It will only result in _exactly_ the crap we were just trying to avoid, namely stupid "shell game" drivers that don't actually help anything at all, and move code into user space instead.
What was the point again?
Was the point to alienate people by showing how we're less about the technology than about licenses?
Was the point to show that we think we can extend our reach past derived work boundaries by just saying so?
The silly thing is, the people who tend to push most for this are the exact SAME people who say that the RIAA etc should not be able to tell people what to do with the music copyrights that they own, and that the DMCA is bad because it puts technical limits over the rights expressly granted by copyright law.
Doesn't anybody else see that as being hypocritical?
So it's ok when we do it, but bad when other people do it? Somehow I'm not surprised, but I still think it's sad how you guys are showing a marked two-facedness about this.
The fact is, the reason I don't think we should force the issue is very simple: copyright law is simply _better_off_ when you honor the admittedly gray issue of "derived work". It's gray. It's not black-and-white. But being gray is _good_. Putting artificial black-and-white technical counter-measures is actually bad. It's bad when the RIAA does it, it's bad when anybody else does it.
If a module arguably isn't a derived work, we simply shouldn't try to say that its authors have to conform to our worldview.
We should make decisions on TECHNICAL MERIT. And this one is clearly being pushed on anything but.
I happen to believe that there shouldn't be technical measures that keep me from watching my DVD or listening to my music on whatever device I damn well please. Fair use, man. But it should go the other way too: we should not try to assert _our_ copyright rules on other peoples code that wasn't derived from ours, or assert _our_ technical measures that keep people from combining things their way.
If people take our code, they'd better behave according to our rules. But we shouldn't have to behave according to the RIAA rules just because we _listen_ to their music. Similarly, nobody should be forced to behave according to our rules just because they _use_ our system.
There's a big difference between "copy" and "use". It's exatcly the same issue whether it's music or code. You can't re-distribute other peoples music (becuase it's _their_ copyright), but they shouldn't put limits on how you personally _use_ it (because it's _your_ life).
Same goes for code. Copyright is about _distribution_, not about use. We shouldn't limit how people use the code.
Oh, well. I realize nobody is likely going to listen to me, and everybody has their opinion set in stone.
That said, I'm going to suggest that you people talk to your COMPANY LAWYERS on this, and I'm personally not going to merge that particular code unless you can convince the people you work for to merge it first.
In other words, you guys know my stance. I'll not fight the combined opinion of other kernel developers, but I sure as hell won't be the first to merge this, and I sure as hell won't have _my_ tree be the one that causes this to happen.
So go get it merged in the Ubuntu, (Open)SuSE and RHEL and Fedora trees first. This is not something where we use my tree as a way to get it to other trees. This is something where the push had better come from the other direction.
Because I think it's stupid. So use somebody else than me to push your political agendas, please.
Linus
-
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Linus TorvaldsQuoted 2 lines · Linus Torvalds
If a module arguably isn't a derived work, we simply shouldn't try to say that its authors have to conform to our worldview.
I wouldn't argue that _anyone_ else should be exposed to my worldview; I think the Geneva Convention has something to say about cruel and unusual punishments.
But I would ask that they honour the licence on the code I release, and perhaps more importantly on the code I import from other GPL sources.
If they fail to do that under the 'honour system' then I'm not averse to 'enforcing' it by technical measures. (For some value of 'enforcement' which is easy for them to patch out if their lawyers are _really_ sure they'll win when I sue them, that is.)
That's the big difference I see between this and the RIAA case you mention -- in the case of Linux refusing to load non-GPL modules, if the user _really_ thinks they'll win in court they can just hack it to load the offending modules again. We are giving a _very_ strong indication of our intent, but we aren't actually _forcing_ it on them in quite the same way. With DRM-crippled players and hardware it's not so easy to get around.
I'm very much in favour of Greg's approach. Give 12 months warning and then just prevent loading of non-GPL modules.
That way, we get back from the current "binary modules are the status quo even though some people are currently psyching themselves up to sue for it" to "binary modules are possible if you're _very_ sure of your legal position and willing to defend it". I think that's a very good thing to do.
Quoted 2 lines
We should make decisions on TECHNICAL MERIT. And this one is clearly being pushed on anything but.
Not on my part. The thing that makes me _particularly_ vehement about binary-only crap this week is a very much a technical issue -- in particular, the fact that we had to do post-production board modifications to shoot our wireless chip in the head when it goes AWOL, because the code for it wasn't available to us.
It's come back time and time again -- closed code is undebuggable, unportable, unimprovable, unworkable. It's a detriment to the whole system. That's very much a _technical_ issue, to me.
For non-kernel code I'm happy enough to release what I write under a BSD licence. I'll default to GPL but usually respond favourably to requests to do otherwise. It _isn't_ a religious issue.
Quoted 2 lines
Same goes for code. Copyright is about _distribution_, not about use. We shouldn't limit how people use the code.
And we don't need to. Aside from the fact that they can patch out the check if they have a genuine need to, they can also mark their module as GPL without consequences as long as they don't _distribute_ it. We still don't limit their _use_ of it.
Quoted 2 lines
Oh, well. I realize nobody is likely going to listen to me, and everybody has their opinion set in stone.
My opinion is fairly much set from all the times I've come up against _technical_ issues, I'll admit. But I did listen, and I agree with what you say about the RIAA 'enforcement'. But I do see that as _very_ different to our 'enforcement', because ours is so easy to patch out it's more of a 'hint' than a lockdown.
Quoted 3 lines
That said, I'm going to suggest that you people talk to your COMPANY LAWYERS on this, and I'm personally not going to merge that particular code unless you can convince the people you work for to merge it first.
We've already merged EXPORT_SYMBOL_GPL. Is there a difference other than one of extent? What about just marking kmalloc as EXPORT_SYMBOL_GPL for a start? :)
Quoted 9 lines
In other words, you guys know my stance. I'll not fight the combined opinion of other kernel developers, but I sure as hell won't be the first to merge this, and I sure as hell won't have _my_ tree be the one that causes this to happen.
So go get it merged in the Ubuntu, (Open)SuSE and RHEL and Fedora trees first. This is not something where we use my tree as a way to get it to other trees. This is something where the push had better come from the other direction.
It's better to have a coherent approach, and for all of us to do it on roughly the same timescale. Getting the distributions do so this is going to be like herding cats -- having it upstream and letting it trickle down is a much better approach, I think.
Signature · 1 line
dwmw2
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 4 lines · On Thu, 14 Dec 2006 08:21:20 +0000 David Woodhouse <[email protected]> wrote:
If they fail to do that under the 'honour system' then I'm not averse to 'enforcing' it by technical measures. (For some value of 'enforcement' which is easy for them to patch out if their lawyers are _really_ sure they'll win when I sue them, that is.)
There are specific rules against removal of technical measures *even if the result is legal*. It is an offence in many countries thanks to the RIAA lobbyists and their corrupt pet politicians to remove technical measures applied to a -public domain- work.
So your argument doesn't fly.
Quoted 5 lines
Not on my part. The thing that makes me _particularly_ vehement about binary-only crap this week is a very much a technical issue -- in particular, the fact that we had to do post-production board modifications to shoot our wireless chip in the head when it goes AWOL, because the code for it wasn't available to us.
Consider it an education process. Hopefully the contracts for the chips/docs were watertight enough you can sue the offending supplier for the total cost of the rework. If not then you are really complaining about getting contract negotiations wrong.
Quoted 4 lines
It's better to have a coherent approach, and for all of us to do it on roughly the same timescale. Getting the distributions do so this is going to be like herding cats -- having it upstream and letting it trickle down is a much better approach, I think.
I doubt any distribution but the FSF "purified" Debian (the one that has no firmware so doesn't work) would do it.
Alan
dfsg isn't fsf (Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19])
On 2006-12-14, Alan wrote:
[]
Quoted 2 lines
I doubt any distribution but the FSF "purified" Debian (the one that has no firmware so doesn't work) would do it.
DFSG "purified" Debian[1], please.
[1] <http://www.debian.org/social_contract>
--
-o--=O C info emacs : not found /. .\ ( is there any reason to live? ) #oo'L O info make : not found o ( yes! -- R.I.P. FSF+RMS, viva ) <___=E M man gcc : not found `-- ( Debian Free Operating System )
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to David WoodhouseQuoted 2 lines
But I would ask that they honour the licence on the code I release, and perhaps more importantly on the code I import from other GPL sources.
It's not a question of "honoring the license"; it's a matter of what is the reach of the license, as it relates to derivitive works. It's a complicated subject, and very dependent on the local law; certainly in the U.S., when I asked a Law Professor from the MIT Sloan School of Management, who specialized in IP issues about the FSF theory of GPL contamination by dynamic linking, after I explained all the details of how dynamic linking work, she told me that it would be "laughed out of the courtroom".
Now, is that a legal opinion? No, because the facts of every single case are different, and it was an opinion from someone over a decade ago, and case law may have changed (although as far as I know, there has been no court ruling directly on this particular point since then).
The bottom line though is that it is not _nearly_ so clear as some people would like to believe. There is a lot of gray --- and that's a GOOD thing. If copyright contamination via dynamic linking was the settled law of the land, then all of the Macintosh extensions that people wrote --- WHICH WORK BY PATCHING THE OPERATING SYSTEM --- would be illegal. And given how much Apple hated people implying that the UI as handed down from the mountain by the great prophet Steve Jobs wasn't good enough, would we really have wanted Apple hounding developers with lawsuits just because "they weren't honoring the license" by daring to patch MacOS, and extending the OS by linking in their code?
And what about people who link in a debugger into the Microsoft HAL or other Microsoft DLL's in order to reverse engineer USB drivers for Linux or reverse engineer protocols for Samba --- that's dynamic linking of a sort too --- should that be illegal as well? Imagine the power that Microsoft could put into their EULA if copyright contamination could be as easily achieved by dynamic linking.
Please, let's try to have a little sanity here,
- Ted
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to David WoodhouseQuoted 3 lines · David Woodhouse
But I would ask that they honour the licence on the code I release, and perhaps more importantly on the code I import from other GPL sources.
This is a total non-argument, and it doesn't get any betetr by being mindlessly repeated over and over and over again.
The license on the code you released talked about "derived works".
Not "everything I want to".
If a module owner can argue successfully in a court of law that a binary driver isn't a derived work, then the GPL simply DOES NOT COVER IT!
In other words, people CAN "honor the license" and still not be required to put their code under the GPL.
And no, including one header file in order to compile against something does not automatically make something a "derived work". It may, or it may not. It really isn't up to you to decide whether it does (and notice how I'm not saying that it's up to _me_ either!).
For example, all the same people who clamor for free software get absolutely RABID about "fair use". Guess what "fair use" actually MEANS?
Think about it for a moment. It expressly _limits_ the right of copyright authors to claim "derived work". So if you argue that anything that ever includes your header file (but none of your code) and compiles against it is a "derived work", then you are basically very close to arguing that "fair use" does not exist.
Do you really want to argue that "everything that has touched anything copyrighted AT ALL is a derived work"? Do you feel lucky, punk?
THAT is why I think this discussion is so hypocritical. Either you accept that "fair use" and copyrights aren't black-and-white, or you don't.
If you think this is a black-and-white "copyright owners have all the rights", then you're standing with the RIAA's and the MPAA's of the world.
Me, personally, I think the RIAA and the MPAA is a shithouse. They are immoral. But guess what? They are immoral exactly _because_ they think that they automatically own ALL the rights, just because they own the copyright.
That is what it boils down to: copyright doesn't really give you "absolute power". This is why I have been _consistently_ arguing that we're not about "black and white" or "good against evil". It simply isn't that simple.
I don't like binary modules. I refuse to support them, and if it turns out that the module was written using Linux code, and just for Linux, I htink that's a _clear_ copyright violation, and that binary module is obviously a license violation.
But if the module was written for other systems, and just ported to Linux, and not using our code, then it's very much debatable whether it's actually a "derived work". Interfaces don't make "derived works" per se.
Now, is it something you could sue people over? Sure. I actually do believe that it's very possible that a judge _would_ consider such a module a derived work, and you can sue people. It probably depends on circumstances too.
But don't you see the problem with a black-and-white technical measure?
Don't you see the problem with the DMCA and the DVD encryption?
Those kinds of things REMOVE the "reasonable thought" from the equation, and turn a gradual process into a sharp "right or wrong" situation. AND THAT IS WRONG. We simply do not LIVE in a world that is black and white.
So if you think somebody violates your copyright, send them a C&D letter, and eventually take them to court. It's been done. Companies that mis-used the GPL have actually been sued, and THEY HAVE LOST. That's a GOOD thing. I'm not arguing against that at all. What I'm arguing against is the "blind belief" that you or I have the right to tell people what to do, just because we own copyrights.
It's not a blind belief that I'm willing to subscribe to. Exactly because I have _seen_ what that blind belief results in - crap like the DMCA and the RIAA lawsuits.
Linus
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Again, I agree with EVERY statement Linus made here. We operate exactly as Linus describes, and legally, NO ONE can take us to task on GPL issues. We post patches of affected kernel code (albiet the code resembles what Linus describes as a "skeleton driver") and our proprietary non derived code we sell with our appliances. He is right, everyone else should just accept it and get on with life or cry linus a river.
Jeff
Quoted 60 lines · Linus Torvalds
Quoted 4 lines · David Woodhouse
But I would ask that they honour the licence on the code I release, and perhaps more importantly on the code I import from other GPL sources.
This is a total non-argument, and it doesn't get any betetr by being mindlessly repeated over and over and over again.
The license on the code you released talked about "derived works".
Not "everything I want to".
If a module owner can argue successfully in a court of law that a binary driver isn't a derived work, then the GPL simply DOES NOT COVER IT!
In other words, people CAN "honor the license" and still not be required to put their code under the GPL.
And no, including one header file in order to compile against something does not automatically make something a "derived work". It may, or it may not. It really isn't up to you to decide whether it does (and notice how I'm not saying that it's up to _me_ either!).
For example, all the same people who clamor for free software get absolutely RABID about "fair use". Guess what "fair use" actually MEANS?
Think about it for a moment. It expressly _limits_ the right of copyright authors to claim "derived work". So if you argue that anything that ever includes your header file (but none of your code) and compiles against it is a "derived work", then you are basically very close to arguing that "fair use" does not exist.
Do you really want to argue that "everything that has touched anything copyrighted AT ALL is a derived work"? Do you feel lucky, punk?
THAT is why I think this discussion is so hypocritical. Either you accept that "fair use" and copyrights aren't black-and-white, or you don't.
If you think this is a black-and-white "copyright owners have all the rights", then you're standing with the RIAA's and the MPAA's of the world.
Me, personally, I think the RIAA and the MPAA is a shithouse. They are immoral. But guess what? They are immoral exactly _because_ they think that they automatically own ALL the rights, just because they own the copyright.
That is what it boils down to: copyright doesn't really give you "absolute power". This is why I have been _consistently_ arguing that we're not about "black and white" or "good against evil". It simply isn't that simple.
I don't like binary modules. I refuse to support them, and if it turns out that the module was written using Linux code, and just for Linux, I htink that's a _clear_ copyright violation, and that binary module is obviously a license violation.
But if the module was written for other systems, and just ported to Linux, and not using our code, then it's very much debatable whether it's actually a "derived work". Interfaces don't make "derived works" per se.
Now, is it something you could sue people over? Sure. I actually do believe that it's very possible that a judge _would_ consider such a module a derived work, and you can sue people. It probably depends on circumstances too.
But don't you see the problem with a black-and-white technical measure?
Don't you see the problem with the DMCA and the DVD encryption?
Those kinds of things REMOVE the "reasonable thought" from the equation, and turn a gradual process into a sharp "right or wrong" situation. AND THAT IS WRONG. We simply do not LIVE in a world that is black and white.
So if you think somebody violates your copyright, send them a C&D letter, and eventually take them to court. It's been done. Companies that mis-used the GPL have actually been sued, and THEY HAVE LOST. That's a GOOD thing. I'm not arguing against that at all. What I'm arguing against is the "blind belief" that you or I have the right to tell people what to do, just because we own copyrights.
It's not a blind belief that I'm willing to subscribe to. Exactly because I have _seen_ what that blind belief results in - crap like the DMCA and the RIAA lawsuits.
Linus
-
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 5 lines · Jeff V. Merkey
Again, I agree with EVERY statement Linus made here. We operate exactly as Linus describes, and legally, NO ONE can take us to task on GPL issues. We post patches of affected kernel code (albiet the code resembles what Linus describes as a "skeleton driver") and our proprietary non derived code we sell with our appliances.
Yeah, like this one?
ftp://ftp.soleranetworks.com/pub/solera/dsfs/FedoraCore6/datascout-only-2.6.18-11-13-06.patch
@@ -1316,8 +1316,8 @@
mod->license_gplok = license_is_gpl_compatible(license);
if (!mod->license_gplok && !(tainted & TAINT_PROPRIETARY_MODULE)) {
- printk(KERN_WARNING "%s: module license '%s' taints kernel.\n",
- mod->name, license);
+// printk(KERN_WARNING "%s: module license '%s' taints kernel.\n",
+// mod->name, license);
add_taint(TAINT_PROPRIETARY_MODULE);
}
}
@@ -1691,10 +1691,10 @@
/* Set up license info based on the info section */
set_license(mod, get_modinfo(sechdrs, infoindex, "license"));- if (strcmp(mod->name, "ndiswrapper") == 0)
- add_taint(TAINT_PROPRIETARY_MODULE);
- if (strcmp(mod->name, "driverloader") == 0)
- add_taint(TAINT_PROPRIETARY_MODULE);
+// if (strcmp(mod->name, "ndiswrapper") == 0)
+// add_taint(TAINT_PROPRIETARY_MODULE);
+// if (strcmp(mod->name, "driverloader") == 0)
+// add_taint(TAINT_PROPRIETARY_MODULE);
/* Set up MODINFO_ATTR fields */
setup_modinfo(mod, sechdrs, infoindex);Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 11 lines · Martin J. Bligh
Quoted 5 lines · Jeff V. Merkey
Again, I agree with EVERY statement Linus made here. We operate exactly as Linus describes, and legally, NO ONE can take us to task on GPL issues. We post patches of affected kernel code (albiet the code resembles what Linus describes as a "skeleton driver") and our proprietary non derived code we sell with our appliances.
Yeah, like this one?
Yeah, like that one. WITH THE POLITICAL AGENDA CODE REMOVED.
Jeff
Quoted 35 lines
ftp://ftp.soleranetworks.com/pub/solera/dsfs/FedoraCore6/datascout-only-2.6.18-11-13-06.patch
(quoted diff) +2
-2@@ -1316,8 +1316,8 @@ mod->license_gplok = license_is_gpl_compatible(license); if (!mod->license_gplok && !(tainted & TAINT_PROPRIETARY_MODULE)) { - printk(KERN_WARNING "%s: module license '%s' taints kernel.\n", - mod->name, license); +// printk(KERN_WARNING "%s: module license '%s' taints kernel.\n", +// mod->name, license);add_taint(TAINT_PROPRIETARY_MODULE); }}
(quoted diff) +4
-4@@ -1691,10 +1691,10 @@ /* Set up license info based on the info section */ set_license(mod, get_modinfo(sechdrs, infoindex, "license")); - if (strcmp(mod->name, "ndiswrapper") == 0) - add_taint(TAINT_PROPRIETARY_MODULE); - if (strcmp(mod->name, "driverloader") == 0) - add_taint(TAINT_PROPRIETARY_MODULE); +// if (strcmp(mod->name, "ndiswrapper") == 0) +// add_taint(TAINT_PROPRIETARY_MODULE); +// if (strcmp(mod->name, "driverloader") == 0) +// add_taint(TAINT_PROPRIETARY_MODULE); /* Set up MODINFO_ATTR fields */ setup_modinfo(mod, sechdrs, infoindex);
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 2 lines · Jeff V. Merkey
Yeah, like that one. WITH THE POLITICAL AGENDA CODE REMOVED.
No. That's really a purely technical thing.
You can still do whatever you want, but people who support the resulting mess know that they shouldn't.
Linus
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 12 lines · Linus Torvalds
Quoted 3 lines · Jeff V. Merkey
Yeah, like that one. WITH THE POLITICAL AGENDA CODE REMOVED.
No. That's really a purely technical thing.
I'm not certain I understand what you mean here. Nasty messages using the word "taint" is purely subjective. (as is your opinion or anyone else's about the use of the word, including my opinion). Based upon the way the GPL is worded, "taint" actually goes the other way in legal circles when corporate attorneys talk about using GPL code with non-GPL code.
i.e. "... If we use that linux code it will TAINT our development process and CONTAMINATE and POULLTE our proprietary development efforts with GPL code and we do not know the IP sources of such code...".
You should change it to "non-GPL" rather than "tainted" since the use of this word is actionable and inaccruate of reality. Free GPL code is what it is. The GPL is the only thing that "taints" IP. The use of the word is reversed. Also Linus, we do open source and promote certain projects outside of the Linux Kernel -- and we fully support the GPL.
You can still do whatever you want, but people who support the resulting mess know that they shouldn't.
BULLSHIT. I diagree and you are talking out of both sides of your mouth.
:-)
Jeff
Quoted 4 lines
Linus
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Linus TorvaldsQuoted 3 lines · Linus Torvalds
That said, I'm going to suggest that you people talk to your COMPANY LAWYERS on this, and I'm personally not going to merge that particular code unless you can convince the people you work for to merge it first.
That's quoting material :) Who's your master, by Linus.
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Linus TorvaldsQuoted 2 lines · Linus Torvalds
So go get it merged in the Ubuntu, (Open)SuSE and RHEL and Fedora trees first.
You don't think I already get enough hatemail from binary-module users ? :)
Dave
Signature · 1 line
http://www.codemonkey.org.uk
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Linus TorvaldsQuoted 5 lines
So go get it merged in the Ubuntu, (Open)SuSE and RHEL and Fedora trees first. This is not something where we use my tree as a way to get it to other trees. This is something where the push had better come from the other direction.
I can probably speak for Ubuntu in saying we wont include any sort of patch like this unless it's forced on us.
I have to agree with your your whole statement. The gradual changes to lock down kernel modules to a particular license(s) tends to mirror the slow lock down of content (music/movies) that people complain about so loudly. It's basically becoming DRM for code.
I don't think anyone ever expected technical mechanisms to be developed to enforce the GPL. It's sort of counter intuitive to why the GPL exists, which is to free the code.
Let the licenses and lawyers fight to protect the code. The code doesn't need to do that itself. It's got better things to do.
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 8 lines · Ben Collins
I have to agree with your your whole statement. The gradual changes to lock down kernel modules to a particular license(s) tends to mirror the slow lock down of content (music/movies) that people complain about so loudly. It's basically becoming DRM for code.
I don't think anyone ever expected technical mechanisms to be developed to enforce the GPL. It's sort of counter intuitive to why the GPL exists, which is to free the code.
"""To protect your rights, we need to make restrictions that forbid anyone to deny you these rights"""
Quoted 2 lines
Let the licenses and lawyers fight to protect the code. The code doesn't need to do that itself. It's got better things to do.
-`J'
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 6 lines · Jan Engelhardt
Quoted 5 lines · Ben Collins
I have to agree with your your whole statement. The gradual changes to lock down kernel modules to a particular license(s) tends to mirror the slow lock down of content (music/movies) that people complain about so loudly. It's basically becoming DRM for code.
Quoted 9 lines
Quoted 3 lines
I don't think anyone ever expected technical mechanisms to be developed to enforce the GPL. It's sort of counter intuitive to why the GPL exists, which is to free the code.
"""To protect your rights, we need to make restrictions that forbid anyone to deny you these rights"""
Quoted 2 lines
Let the licenses and lawyers fight to protect the code. The code doesn't need to do that itself. It's got better things to do.
And these restrictions are in the letter of the GPL, not the function prototypes of my code. Anyone willing to write libgpl-enforcement?
I don't care if someone wants to take my code and blatantly make use of it in their own projects. I encourage it. I wrote it so people could do whatever the hell they wanted to with it. It's when that project is made available to others where I expect the GPL to enforce my copyrights and licenses. I don't expect my code to be self checking for it, and then add conditions that this portion of the code cannot be removed, because then it isn't really GPL anymore, because then it isn't really free either.
Maybe people will be happy if it ends up like this:
Booting Linux...
Please insert your original GNU/Linux source CD...
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Linus TorvaldsQuoted 1 line · Linus Torvalds
Because I think it's stupid. So use somebody else than me to push your political agendas, please.
ACK, I agree completely. I think its a silly, political, non-technical decision being pushed here.
For the record, I also disagree with the sneaky backdoor way people want to add EXPORT_SYMBOL_GPL() to key subsystems that drivers will need. EXPORT_SYMBOL_GPL() is more to emphasize that certain symbols are more 'internal' or frequently changed, and therefore use of them would imply you are using a derived work of the kernel. EXPORT_SYMBOL_GPL() is /not/ a place for political activism either.
Jeff
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 3 lines · Jeff Garzik
For the record, I also disagree with the sneaky backdoor way people want to add
EXPORT_SYMBOL_GPL()to key subsystems that drivers will need.
I actually think the EXPORT_SYMBOL_GPL() thing is a good thing, if done properly (and I think we use it fairly well).
I think we _can_ do things where we give clear hints to people that "we think this is such an internal Linux thing that you simply cannot use this without being considered a derived work".
It's really just a strong hint about what we consider to be internal. The fact is, "intent" actually does matter, and as such our _intent_ in saying "these are very deep and internal interfaces" is actually meaningful - even in a court of law.
So I personally don't see EXPORT_SYMBOL_GPL() to be a "technical measure", I see it as being "documentation".
That said, I think that some people seem to be a bit over-eager to use it. And I actually think that weakens the rest of them too (imagine a lawyer saying in front of a judge:
"Look, they marked 'strcpy()' as a symbol that requires us to be GPL'd,
but look, it's a standard function available everywhere else too, and you can implement it as one line of code, so a module that uses it clearly is NOT a derived work, so EXPORT_SYMBOL_GPL is obviously not something that means anything"
So this is why I've actually argued in the past for some EXPORT_SYMBOL_GPL's to be demoted to "normal" EXPORT_SYMBOL's. Exactly because over-using them actually _weakens_ them, and makes them pointless both from a documentation _and_ from a legal standpoint.
Btw, I've actually had a lawyer tell me that EXPORT_SYMBOL_GPL makes legal sense and has actually made people happier, for what its worth. Of course, you can get <n*2> different opinions from <n> lawyers, so that may not be all that meaningful ;)
Linus
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 6 lines · Linus Torvalds
I actually think the
EXPORT_SYMBOL_GPL()thing is a good thing, if done properly (and I think we use it fairly well).I think we _can_ do things where we give clear hints to people that "we think this is such an internal Linux thing that you simply cannot use this without being considered a derived work".
Then why not change the name to something more along those lines?
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 10 lines · Chris Wedgwood
Quoted 6 lines · Linus Torvalds
I actually think the
EXPORT_SYMBOL_GPL()thing is a good thing, if done properly (and I think we use it fairly well).I think we _can_ do things where we give clear hints to people that "we think this is such an internal Linux thing that you simply cannot use this without being considered a derived work".
Then why not change the name to something more along those lines?
Yes, EXPORT_SYMBOL_INTERNAL would make a lot more sense.
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 1 line · Christoph Hellwig
Yes,
EXPORT_SYMBOL_INTERNALwould make a lot more sense.
A quick grep shows that changing this now would require updating nearly 1900 instances, so patches to do this would be pretty large and disruptive (though we could support both during a transition and migrate them over time).
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 8 lines · Chris Wedgwood
Quoted 1 line · Christoph Hellwig
Yes,
EXPORT_SYMBOL_INTERNALwould make a lot more sense.A quick grep shows that changing this now would require updating nearly 1900 instances, so patches to do this would be pretty large and disruptive (though we could support both during a transition and migrate them over time).
Please don't use that name, it strikes me as much more confusing than EXPORT_SYMBOL_GPL, even though I agree that _GPL doesn't quite convey what it means, either.
EXPORT_SYMBOL_RESTRICTED? EXPORT_SYMBOL_DERIVED? At least something which is not internally inconsistent would be good (how is something which is exported "internal?")
And, as long as EXPORT_SYMBOL_GPL continues to check that the module using it has a GPL license, then it really -is- exactly descriptive of what it's doing and probably shouldn't be changed. IIMHO.
-Eric
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 3 lines · Eric Sandeen
Please don't use that name, it strikes me as much more confusing than
EXPORT_SYMBOL_GPL, even though I agree that_GPLdoesn't quite convey what it means, either.
Calling internal symbols _INTERNAL is confusing?
Quoted 3 lines
EXPORT_SYMBOL_RESTRICTED?EXPORT_SYMBOL_DERIVED? At least something which is not internally inconsistent would be good (how is something which is exported "internal?")
But those symbols aren't, they're about internal interfaces that might change.
Quoted 3 lines
And, as long as
EXPORT_SYMBOL_GPLcontinues to check that the module using it has a GPL license, then it really -is- exactly descriptive of what it's doing and probably shouldn't be changed. IIMHO.
Well, if EXPORT_SYMBOL_GPL / EXPORT_SYMBOL_INTERNAL is about documenting things, why restrict who can use them based on the license?
Surely the licence is more about tainting the kernel and debugging not politics?
Do we even need to check the license at all in that case? Maybe a better idea would be to embed where the source code is located and use the non-existence of that for a tainting?
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 2 lines · Chris Wedgwood
Calling internal symbols
_INTERNALis confusing?
Well, I'm not sure the _INTERNAL name is all that much better than the _GPL one.
In many ways, the _GPL one describes the _effects_ better, and also points out the reason _why_ something is marked differently. Sure, it's marked becasue it's internal, but why is does that have to be pointed out at all? Why not use the same EXPORT_SYMBOL? The answer to that is the "GPL" part, ie the expectation that internal symbols are so internal that they have license effects.
And if you were an external vendor doing binary only modules, would you react to "internal"? It wouldn't have the same "oh, _that_ is what it is all about" thing, would it?
So I do agree that we have probably done a bad job of explaining why that _GPL thing makes sense, and what it means on a deeper level (the license thing is a very superficial thing, but its worth naming just because the superficial thing is also the biggest _impact_ - even if it may not be the underlying deeper _reason_ for it).
So which makes more sense from a naming standpoint: the superficial impact that is what _matters_ for people, or the more subtle issue that causes it to have that impact?
I think that question is what it boils down to, and at least personally, while I see both things as being worthwhile, I think the superficial thing is the one that needs pointing out, because it's the one that may change your behaviour (while the deeper _meaning_ is more of just an explanation).
But I don't personally care that deeply. I mostly care about the fact that changing the name now would just be inconvenient and unnecessary churn, and that's probably my biggest reason to not want to do it ;)
Linus
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Chris WedgwoodQuoted 7 lines · Chris Wedgwood
Quoted 3 lines · Eric Sandeen
Please don't use that name, it strikes me as much more confusing than
EXPORT_SYMBOL_GPL, even though I agree that_GPLdoesn't quite convey what it means, either.Calling internal symbols
_INTERNALis confusing?
I think it's the combination of "INTERNAL" and "EXPORT" that seems contradictory - "If it's internal, why are you exporting it?"
I think "EXPORT_SYMBOL_GPL_ONLY" or "...ONLY UNDER_GPL" would make the meaning clearer, but I don't really think the gain is worth the pain. Anybody using kernel interfaces ought to be able to figure it out.
Quoted 3 lines
But those symbols aren't, they're about internal interfaces that might change.
Folks who think this is likely to make a difference in court might want to look at <http:www.linuxworld.com/news/2006/120806-closed-modules2.html> for a litany of court cases that have rejected infringement claims where a much sterner effort had been made to hide or block use of interfaces. The article claims that courts have increasingly found that interfacing your code to an existing work is not infringement, regardless of what you have to work around to do it.
Of course, that's one author's reading of the case law and I'm sure there are others who disagree, but it's something you'd want to keep in mind in calculating the expected value of a suit...
scott
RE: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
I'd suggest putting a Documentation/GPL-Symbols to explain this.
Then in the "tainted" message, have a pointer to that documentation.
Quoted 56 lines
-----Original Message-----
From: [email protected] [mailto:[email protected]] On Behalf Of Scott Preece
Sent: Thursday, December 14, 2006 11:43 AM
To: Chris Wedgwood
Cc: Eric Sandeen; Christoph Hellwig; Linus Torvalds; Jeff Garzik; Greg KH; Jonathan Corbet; Andrew Morton; Martin Bligh; Michael K. Edwards; [email protected]
Subject: Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]Quoted 4 lines · Chris Wedgwood
Quoted 2 lines · Eric Sandeen
Please don't use that name, it strikes me as much more confusing than
EXPORT_SYMBOL_GPL, even though I agree that_GPLdoesn't quite
Quoted 3 lines
Quoted 1 line
convey what it means, either.
Calling internal symbols
_INTERNALis confusing?I think it's the combination of "INTERNAL" and "EXPORT" that seems contradictory - "If it's internal, why are you exporting it?"
I think "
EXPORT_SYMBOL_GPL_ONLY" or "...ONLYUNDER_GPL" would make the meaning clearer, but I don't really think the gain is worth the pain.
Anybody using kernel interfaces ought to be able to figure it out.Quoted 2 lines
But those symbols aren't, they're about internal interfaces
that might
Quoted 1 line
change.
Folks who think this is likely to make a difference in court might want to look at <http:www.linuxworld.com/news/2006/120806-closed-modules2.html
Quoted 1 line
for a litany of court cases that have rejected infringement
claims where a much sterner effort had been made to hide or block use of interfaces.
The article claims that courts have increasingly found that interfacing your code to an existing work is not infringement, regardless of what you have to work around to do it.Of course, that's one author's reading of the case law and I'm sure there are others who disagree, but it's something you'd want to keep in mind in calculating the expected value of a suit...
scott
-
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected] More majordomo info at
http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Scott PreeceThis whole effort is pointless. This is the same kind of crap MICROSOFT DOES to create incompatibilities
DELIBERATELY. The code is either FREE or its NOT FREE. If the code is FREE then let it be. You can put whatever
you want in the code -- I will remove any such constructs, just like I remove them frm Red Hat's releases when they put in the same kind of deliberate breakage for anti-competitive reasons.
You can go and yell at Novell too, since they do the SAME THING with their releases and mix their modules with Linux.
All someone has to do or say is.
"... I did not ever accept the GPL license with the FREE code I was given. They said the code was FREE, and I took them at their word. .."
FREE implies a transfer of ownsership and you also have to contend with the Doctrine of Estoppel. i.e. if someone has been using the code for over two years, and you have not brought a cause of action, you are BARRED from doing so under the Doctrine of Estoppel and statute of limitations.
Here's what that means so you can look it up:
http://en.wikigadugi.org/wiki/Estoppel
What Linus argued is that FREE means just that.
Jeff
Quoted 43 lines · Scott Preece
Quoted 7 lines · Chris Wedgwood
Quoted 3 lines · Eric Sandeen
Please don't use that name, it strikes me as much more confusing than
EXPORT_SYMBOL_GPL, even though I agree that_GPLdoesn't quite convey what it means, either.Calling internal symbols
_INTERNALis confusing?I think it's the combination of "INTERNAL" and "EXPORT" that seems contradictory - "If it's internal, why are you exporting it?"
I think "
EXPORT_SYMBOL_GPL_ONLY" or "...ONLYUNDER_GPL" would make the meaning clearer, but I don't really think the gain is worth the pain. Anybody using kernel interfaces ought to be able to figure it out.Quoted 3 lines
But those symbols aren't, they're about internal interfaces that might change.
Folks who think this is likely to make a difference in court might want to look at <http:www.linuxworld.com/news/2006/120806-closed-modules2.html> for a litany of court cases that have rejected infringement claims where a much sterner effort had been made to hide or block use of interfaces. The article claims that courts have increasingly found that interfacing your code to an existing work is not infringement, regardless of what you have to work around to do it.
Of course, that's one author's reading of the case law and I'm sure there are others who disagree, but it's something you'd want to keep in mind in calculating the expected value of a suit...
scott
-
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
Re: GPL only modules
Quoted 1 line · Jeff V. Merkey
FREE implies a transfer of ownsership
It's about freedom, not price. And even then, it's the license that has not cost, not the copyright.
Quoted 4 lines
and you also have to contend with the Doctrine of Estoppel. i.e. if someone has been using the code for over two years, and you have not brought a cause of action, you are BARRED from doing so under the Doctrine of Estoppel and statute of limitations.
Sure, but we're not necessarily talking about code that is two years old. We're talking about future releases. Then, if someone interfaces with code that was already there before, they might claim they're still entitled to do so. But if it's new code they interface with, or new code they wrote after this clarification is published, would they still be entitled to estoppel? FWIW, IANAL.
Signature · 4 lines
Alexandre Oliva http://www.lsd.ic.unicamp.br/~oliva/
FSF Latin America Board Member http://www.fsfla.org/
Red Hat Compiler Engineer aoliva@{redhat.com, gcc.gnu.org}
Free Software Evangelist oliva@{lsd.ic.unicamp.br, gnu.org}Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Jeff V. Merkey#include <hallo.h>
Quoted 3 lines · Jeff V. Merkey
This whole effort is pointless. This is the same kind of crap MICROSOFT DOES to create incompatibilities
Just my 0.02€ - one of the things I wonder about is why eg. class* interfaces has been replaced with something "protected" by GPL enforcing macros. What is the point? Nobody wins. The access to the new fine-grained system has been restricted for users, and distributors (yes, I maintain a such module) have to work around this in-kernel restriction and create cludges.
Greg (and others from the "every touch of my bits is a derivation of it and I need to protect it" party) - what are you thinking? Do you seriously think that such restrictions would help anyone? IMO protecting the access to interfaces is an utterly stupid idea in the free software world.
Eduard.
Signature · 3 lines
<Ref|ex> Geht 'n Mantafahrer zum Manta-Treffen.
Fragt: Fährt hier wer Manta
-- #Debian.DERe: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Jeff V. MerkeyQuoted 10 lines · Jeff V. Merkey
This whole effort is pointless. This is the same kind of crap MICROSOFT DOES to create incompatibilities
DELIBERATELY. The code is either FREE or its NOT FREE.All someone has to do or say is.
"... I did not ever accept the GPL license with the FREE code I was given. They said the code was FREE, and I took them
at their word. .."
At which point, hopefully everyone in that courtroom besides the idiot who says this knows the difference between a license and a contract. If anyone doesn't, they can be referred to:
"5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License."
The code is free, as in "redistributable at no charge as long as you adhere to the terms of the license."
Your estoppel argument seems too confused between laches, promissory estoppel and statutes of limitations to even make sense of, sorry.
Dave
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Jeff V. MerkeyThings we can say without being hypocrites and without getting into legal theory:
Kernel modules without source, or that don't have a GPL compatible license are inconsiderate and rude.
Please don't be rude.
Eric
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 7 lines · Eric W. Biederman
Things we can say without being hypocrites and without getting into legal theory:
Kernel modules without source, or that don't have a GPL compatible license are inconsiderate and rude.
??????
Quoted 3 lines
Please don't be rude.
???????
J
Quoted 4 lines
Eric
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Chris WedgwoodQuoted 8 lines · Chris Wedgwood
Quoted 1 line · Christoph Hellwig
Yes,
EXPORT_SYMBOL_INTERNALwould make a lot more sense.A quick grep shows that changing this now would require updating nearly 1900 instances, so patches to do this would be pretty large and disruptive (though we could support both during a transition and migrate them over time).
I'd prefer to do it at once. But that's not my decision so you anyway do what you want.
That said, I would like to keep EXPORT_SYMBOL_GPL, because EXPORT and INTERNAL is somehow contrary. Just a wording issue.
-`J'
Re: GPL only modules
Quoted 10 lines · Jan Engelhardt
Quoted 8 lines · Chris Wedgwood
Quoted 1 line · Christoph Hellwig
Yes,
EXPORT_SYMBOL_INTERNALwould make a lot more sense.A quick grep shows that changing this now would require updating nearly 1900 instances, so patches to do this would be pretty large and disruptive (though we could support both during a transition and migrate them over time).
Quoted 5 lines
I'd prefer to do it at once. But that's not my decision so you anyway do what you want.
That said, I would like to keep
EXPORT_SYMBOL_GPL, because EXPORT and INTERNAL is somehow contrary. Just a wording issue.
I would suggest that we make the prefix MODULE and not EXPORT. It more accurately conveys what we are trying to say, and it doesn't have the conflicting problem with INTERNAL.
I don't know if it is actually worth doing a great rename for such a simple clarification in language. But it is worth considering because it would more strongly convey that we don't expect these symbols to be used by everything.
Eric
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Christoph HellwigQuoted 6 lines · Christoph Hellwig
Quoted 5 lines · Chris Wedgwood
Quoted 3 lines · Linus Torvalds
I actually think the
EXPORT_SYMBOL_GPL()thing is a good thing, if done properly (and I think we use it fairly well).
Quoted 7 lines
Quoted 5 lines
Quoted 3 lines
I think we _can_ do things where we give clear hints to people that "we think this is such an internal Linux thing that you simply cannot use this without being considered a derived work".
Then why not change the name to something more along those lines?
Yes,
EXPORT_SYMBOL_INTERNALwould make a lot more sense.
I find all those names confusing. If these special symbols are GPL/INTERNAL/WHATEVER, what are the other exported symbols?
GPL -> Non-GPL?
INTERNAL -> External?
Gr{oetje,eeting}s,
Geert
--
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]
In personal conversations with technical people, I call myself a hacker. But when I'm talking to journalists I just say "programmer" or something like that.
-- Linus Torvalds
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Linus TorvaldsQuoted 8 lines · Linus Torvalds
...
The fact is, the reason I don't think we should force the issue is very
simple: copyright law is simply _better_off_ when you honor the admittedly gray issue of "derived work". It's gray. It's not black-and-white. But being gray is _good_. Putting artificial black-and-white technical counter-measures is actually bad. It's bad when the RIAA does it, it's bad when anybody else does it.
...
One important question is:
Who gets in danger due to this grey area?
E.g. if I'd consider it important enough to stop Ubuntu from distributing kernels and binary-only modules, I wouldn't try the difficult task to take legal actions against a company located on the Isle of Man.
The trick is to let a lawyer send cease and desist letters to people distributing the infringing software for 1 Euro at Ebay.
The nice thing about cease and desist letters is that the one who accepts one has to pay the > 1000 Euro costs for the lawyer for this letter.
Another lucrative task for the lawer would be to send cease and desist letters to people running mirrors located in Germany distributing the infringing software.
Quoted 1 line
Linus
cu
Adrian
Signature · 4 lines
"Is there not promise of rain?" Ling Tan asked suddenly out
of the darkness. There had been need of rain for many days.
"Only a promise," Lao Er said.
Pearl S. Buck - Dragon SeedRe: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 2 lines
The trick is to let a lawyer send cease and desist letters to people distributing the infringing software for 1 Euro at Ebay.
Doesn't that sound even more like the music industry ? Pick on Grandma, and people who've no clue about the issue. It's not the way to solve such problems. The world does not need "The war on binary modules". Educate people instead, and talk to vendors.
Save the atomic weapons for the people who are straight forward ripping off work in routers, tvs and all sorts of appliances.
Alan
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 10 lines · Alan
Quoted 2 lines
The trick is to let a lawyer send cease and desist letters to people distributing the infringing software for 1 Euro at Ebay.
Doesn't that sound even more like the music industry ? Pick on Grandma, and people who've no clue about the issue. It's not the way to solve such problems. The world does not need "The war on binary modules". Educate people instead, and talk to vendors.
Save the atomic weapons for the people who are straight forward ripping off work in routers, tvs and all sorts of appliances.
I'm not saying that I would do it, but it's the way how it would be done if anyone would do it.
It's not about whether that would be good or bad, the point is that the ones that will most likely be affected if anyone will ever take legal actions will not be the big distributions but people selling their old distributions on Ebay or people operating mirrors.
Cease and desist letters are a lucrative business for lawyers here in Germany, and such grey areas are simply a timebomb waiting for lawyers and/or people wanting to harm Linux to (ab)use them.
Quoted 1 line
Alan
cu
Adrian
Signature · 4 lines
"Is there not promise of rain?" Ling Tan asked suddenly out
of the darkness. There had been need of rain for many days.
"Only a promise," Lao Er said.
Pearl S. Buck - Dragon SeedRe: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to AlanQuoted 7 lines · Alan
Quoted 2 lines
The trick is to let a lawyer send cease and desist letters to people distributing the infringing software for 1 Euro at Ebay.
Doesn't that sound even more like the music industry ? Pick on Grandma, and people who've no clue about the issue. It's not the way to solve such problems. The world does not need "The war on binary modules". Educate people instead, and talk to vendors.
.... or like Microsoft, who is threatening to make war on end-users instead of settling things with vendors. (One of the reasons why I personally find the Microsoft promise not to sue _Novell_'s end users so nasty. Microsoft shouldn't be threatening anyone's users; if they have a problem, they should be taking it up with the relevant vendor, not sueing innocent and relatively shallow-pocketed end-users and distributors.)
One of the things that I find so interesting about how rabid people get about enforcing GPL-only modules is how they start acting more and more like the RIAA, MPAA, and Microsoft every day....
- Ted
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 3 lines
One of the things that I find so interesting about how rabid people get about enforcing GPL-only modules is how they start acting more and more like the RIAA, MPAA, and Microsoft every day....
There is a saying
"That which you fight you become"
It's a warning that is well worth heeding in a lot of situations
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Theodore TsoQuoted 17 lines · Theodore Tso
Quoted 7 lines · Alan
Quoted 2 lines
The trick is to let a lawyer send cease and desist letters to people distributing the infringing software for 1 Euro at Ebay.
Doesn't that sound even more like the music industry ? Pick on Grandma, and people who've no clue about the issue. It's not the way to solve such problems. The world does not need "The war on binary modules". Educate people instead, and talk to vendors.
.... or like Microsoft, who is threatening to make war on end-users instead of settling things with vendors. (One of the reasons why I personally find the Microsoft promise not to sue _Novell_'s end users so nasty. Microsoft shouldn't be threatening anyone's users; if they have a problem, they should be taking it up with the relevant vendor, not sueing innocent and relatively shallow-pocketed end-users and distributors.)
Quoted 3 lines
One of the things that I find so interesting about how rabid people get about enforcing GPL-only modules is how they start acting more and more like the RIAA, MPAA, and Microsoft every day....
Please don't think or imply I'd plan to do this, I'm only saying that there's a risk for users in such grey areas.
It could be that someone who wants to harm Linux starts suing people distributing Linux. If your goal is to harm Linux, suing users can simply be much more effective than suing vendors...
It could even be that people distributing Linux could receive cease and desist letters from people without any real interest in the issue itself - "cease and desist letter"s are so frequent in Germany because the people who have to sign them have to pay the lawyers' costs that are usually > 1000 Euro, and that's a good business for the lawyers.
Quoted 1 line
- Ted
cu
Adrian
Signature · 4 lines
"Is there not promise of rain?" Ling Tan asked suddenly out
of the darkness. There had been need of rain for many days.
"Only a promise," Lao Er said.
Pearl S. Buck - Dragon SeedRe: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 29 lines · Adrian Bunk
Quoted 17 lines · Theodore Tso
Quoted 7 lines · Alan
Quoted 2 lines
The trick is to let a lawyer send cease and desist letters to people distributing the infringing software for 1 Euro at Ebay.
Doesn't that sound even more like the music industry ? Pick on Grandma, and people who've no clue about the issue. It's not the way to solve such problems. The world does not need "The war on binary modules". Educate people instead, and talk to vendors.
.... or like Microsoft, who is threatening to make war on end-users instead of settling things with vendors. (One of the reasons why I personally find the Microsoft promise not to sue _Novell_'s end users so nasty. Microsoft shouldn't be threatening anyone's users; if they have a problem, they should be taking it up with the relevant vendor, not sueing innocent and relatively shallow-pocketed end-users and distributors.)
Quoted 3 lines
One of the things that I find so interesting about how rabid people get about enforcing GPL-only modules is how they start acting more and more like the RIAA, MPAA, and Microsoft every day....
Please don't think or imply I'd plan to do this, I'm only saying that there's a risk for users in such grey areas.
It could be that someone who wants to harm Linux starts suing people distributing Linux. If your goal is to harm Linux, suing users can simply be much more effective than suing vendors...
Quoted 5 lines
It could even be that people distributing Linux could receive cease and desist letters from people without any real interest in the issue itself - "cease and desist letter"s are so frequent in Germany because the people who have to sign them have to pay the lawyers' costs that are usually > 1000 Euro, and that's a good business for the lawyers.
Something is very wrong with German legal system, I'm afraid.
Pavel
Signature · 1 line
Thanks for all the (sleeping) penguins.
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 30 lines · Pavel Machek
Quoted 29 lines · Adrian Bunk
Quoted 17 lines · Theodore Tso
Quoted 7 lines · Alan
Quoted 2 lines
The trick is to let a lawyer send cease and desist letters to people distributing the infringing software for 1 Euro at Ebay.
Doesn't that sound even more like the music industry ? Pick on Grandma, and people who've no clue about the issue. It's not the way to solve such problems. The world does not need "The war on binary modules". Educate people instead, and talk to vendors.
.... or like Microsoft, who is threatening to make war on end-users instead of settling things with vendors. (One of the reasons why I personally find the Microsoft promise not to sue _Novell_'s end users so nasty. Microsoft shouldn't be threatening anyone's users; if they have a problem, they should be taking it up with the relevant vendor, not sueing innocent and relatively shallow-pocketed end-users and distributors.)
Quoted 3 lines
One of the things that I find so interesting about how rabid people get about enforcing GPL-only modules is how they start acting more and more like the RIAA, MPAA, and Microsoft every day....
Please don't think or imply I'd plan to do this, I'm only saying that there's a risk for users in such grey areas.
It could be that someone who wants to harm Linux starts suing people distributing Linux. If your goal is to harm Linux, suing users can simply be much more effective than suing vendors...
Quoted 7 lines
Quoted 5 lines
It could even be that people distributing Linux could receive cease and desist letters from people without any real interest in the issue itself - "cease and desist letter"s are so frequent in Germany because the people who have to sign them have to pay the lawyers' costs that are usually > 1000 Euro, and that's a good business for the lawyers.
Something is very wrong with German legal system, I'm afraid.
The point that you can take legal actions against anyone distributing something that violates your rights should be present in more or less all legal systems.
What might be special in Germany is only that you can demand your costs after successfully taking legal actions.
Quoted 1 line
Pavel
cu
Adrian
Signature · 4 lines
"Is there not promise of rain?" Ling Tan asked suddenly out
of the darkness. There had been need of rain for many days.
"Only a promise," Lao Er said.
Pearl S. Buck - Dragon SeedRe: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 37 lines · Adrian Bunk
Quoted 36 lines · Pavel Machek
Quoted 34 lines · Adrian Bunk
Quoted 17 lines · Theodore Tso
Quoted 7 lines · Alan
Quoted 2 lines
The trick is to let a lawyer send cease and desist letters to people distributing the infringing software for 1 Euro at Ebay.
Doesn't that sound even more like the music industry ? Pick on Grandma, and people who've no clue about the issue. It's not the way to solve such problems. The world does not need "The war on binary modules". Educate people instead, and talk to vendors.
.... or like Microsoft, who is threatening to make war on end-users instead of settling things with vendors. (One of the reasons why I personally find the Microsoft promise not to sue _Novell_'s end users so nasty. Microsoft shouldn't be threatening anyone's users; if they have a problem, they should be taking it up with the relevant vendor, not sueing innocent and relatively shallow-pocketed end-users and distributors.)
Quoted 3 lines
One of the things that I find so interesting about how rabid people get about enforcing GPL-only modules is how they start acting more and more like the RIAA, MPAA, and Microsoft every day....
Please don't think or imply I'd plan to do this, I'm only saying that there's a risk for users in such grey areas.
It could be that someone who wants to harm Linux starts suing people distributing Linux. If your goal is to harm Linux, suing users can simply be much more effective than suing vendors...
It could even be that people distributing Linux could receive cease and desist letters from people without any real interest in the issue itself - "cease and desist letter"s are so frequent in Germany because the people who have to sign them have to pay the lawyers' costs that are usually > 1000 Euro, and that's a good business for the lawyers.
Quoted 8 lines
Quoted 1 line
Something is very wrong with German legal system, I'm afraid.
The point that you can take legal actions against anyone distributing something that violates your rights should be present in more or less all legal systems.
What might be special in Germany is only that you can demand your costs after successfully taking legal actions.
What is special in Germany is fact that any random lawyer can demand $1000 (not his cost, his profit) if you distribute code that is not his...
Pavel
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 44 lines · Pavel Machek
Quoted 43 lines · Adrian Bunk
Quoted 30 lines · Pavel Machek
Quoted 29 lines · Adrian Bunk
Quoted 17 lines · Theodore Tso
Quoted 7 lines · Alan
Quoted 2 lines
The trick is to let a lawyer send cease and desist letters to people distributing the infringing software for 1 Euro at Ebay.
Doesn't that sound even more like the music industry ? Pick on Grandma, and people who've no clue about the issue. It's not the way to solve such problems. The world does not need "The war on binary modules". Educate people instead, and talk to vendors.
.... or like Microsoft, who is threatening to make war on end-users instead of settling things with vendors. (One of the reasons why I personally find the Microsoft promise not to sue _Novell_'s end users so nasty. Microsoft shouldn't be threatening anyone's users; if they have a problem, they should be taking it up with the relevant vendor, not sueing innocent and relatively shallow-pocketed end-users and distributors.)
Quoted 3 lines
One of the things that I find so interesting about how rabid people get about enforcing GPL-only modules is how they start acting more and more like the RIAA, MPAA, and Microsoft every day....
Please don't think or imply I'd plan to do this, I'm only saying that there's a risk for users in such grey areas.
It could be that someone who wants to harm Linux starts suing people distributing Linux. If your goal is to harm Linux, suing users can simply be much more effective than suing vendors...
Quoted 7 lines
Quoted 5 lines
It could even be that people distributing Linux could receive cease and desist letters from people without any real interest in the issue itself - "cease and desist letter"s are so frequent in Germany because the people who have to sign them have to pay the lawyers' costs that are usually > 1000 Euro, and that's a good business for the lawyers.
Something is very wrong with German legal system, I'm afraid.
The point that you can take legal actions against anyone distributing something that violates your rights should be present in more or less all legal systems.
Quoted 6 lines
Quoted 2 lines
What might be special in Germany is only that you can demand your costs after successfully taking legal actions.
What is special in Germany is fact that any random lawyer can demand $1000 (not his cost, his profit) if you distribute code that is not his...
This is a misunderstanding.
You can demand the costs for your lawyer.
The costs for your lawyer depend on the amount in controversy.
The one who tells his lawyer to take legal actions might be a copyright owner, but it's also possible based on competition law.
Quoted 1 line
Pavel
cu
Adrian
Signature · 4 lines
"Is there not promise of rain?" Ling Tan asked suddenly out
of the darkness. There had been need of rain for many days.
"Only a promise," Lao Er said.
Pearl S. Buck - Dragon SeedRe: free module selection
In reply to Linus TorvaldsQuoted 5 lines
Btw, I really think this is shortsighted.
It will only result in _exactly_ the crap we were just trying to avoid, namely stupid "shell game" drivers that don't actually help anything at all, and move code into user space instead.
I would like to contribute some more viewpoints to this hot discussion.
Greg Kroah-Hartman revoked a bit of his code suggestion to take time for second thoughts on the topic.
http://article.gmane.org/gmane.linux.kernel/475890
Quoted 4 lines
So go get it merged in the Ubuntu, (Open)SuSE and RHEL and Fedora trees first. This is not something where we use my tree as a way to get it to other trees. This is something where the push had better come from the other direction.
I hope that people from such distributions will not create too much pressure to "standardise" in licence limitations.
I imagine that there is the important matter of free choice and corresponding fair use. Software techniques can help to choose between available alternatives and possibilities.
1. How much can (kernel) modules be filtered for specific needs like it is performed by class loaders for the Java programming languagge? Are any interceptors internally involved that might throw exceptions to
forward constraints handling to special signal handlers?
http://en.wikipedia.org/wiki/Chain-of-responsibility_pattern
2. Greg's design approach seems to be a nice option for testing purposes.
http://www.kroah.com/log/2006/12/13#uio
Are there any similarities with microkernels?
In which "space" would you like to run your device drivers?
3. All interested parties can develop a Linux distribution for the specific needs of the various users and customers. It may be a fun project as a hobby or it would be something for production applications like IPCop or SELinux. They can also distinguish the acceptable licences on their own. How much do they really want a limited selection that will be enforced by tools for the discussed use case?
http://distrowatch.com/
Regards,
Markus
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Linus TorvaldsQuoted 21 lines · Linus Torvalds
Quoted 4 lines · Greg KH
Numerous kernel developers feel that loading non-GPL drivers into the kernel violates the license of the kernel and their copyright. Because of this, a one year notice for everyone to address any non-GPL compatible modules has been set.
Btw, I really think this is shortsighted.
It will only result in _exactly_ the crap we were just trying to avoid, namely stupid "shell game" drivers that don't actually help anything at all, and move code into user space instead.
What was the point again?
Was the point to alienate people by showing how we're less about the technology than about licenses?
Was the point to show that we think we can extend our reach past derived work boundaries by just saying so?
The silly thing is, the people who tend to push most for this are the exact SAME people who say that the RIAA etc should not be able to tell people what to do with the music copyrights that they own, and that the DMCA is bad because it puts technical limits over the rights expressly granted by copyright law.
Doesn't anybody else see that as being hypocritical?
Quoted 8 lines
So it's ok when we do it, but bad when other people do it? Somehow I'm not surprised, but I still think it's sad how you guys are showing a marked two-facedness about this.
The fact is, the reason I don't think we should force the issue is very simple: copyright law is simply _better_off_ when you honor the admittedly gray issue of "derived work". It's gray. It's not black-and-white. But being gray is _good_. Putting artificial black-and-white technical counter-measures is actually bad. It's bad when the RIAA does it, it's bad when anybody else does it.
If a module arguably isn't a derived work, we simply shouldn't try to say that its authors have to conform to our worldview.
We should make decisions on TECHNICAL MERIT. And this one is clearly being pushed on anything but.
I agree with Linus on these points. The kernel should not be enforcing these issues. Leave the lawyers to do that bit. If companies want to play in the "Grey Area", then it is at their own risk. Binary drivers are already difficult and expensive for the companies because they have to keep updating them as we change the kernel versions. If they do open source drivers, we update them for them as we change the kernel versions, so it works out cheaper for the companies involved.
The open source community tends to be able to reverse engineer all drivers eventually anyway in order to ensure compatibility with all kernel versions and also ensure that the code is well reviewed and therefore contains fewer security loopholes, e.g. Atheros Wireless open source HAL. This also tends to make it rather pointless for companies to do binary drivers, because all it does is delay the open source version of the driver and increase the security risk to users. One other example I have, is that I reverse engineered a sound card driver so that we had an open source driver for it. Once I had manually documented the sound card, so we had details of all the registers and how to use them, the manufacturer finally sent the datasheet to me! A bit late really, but it certainly did encourage the manufacturer to pass datasheets to developers. I now have a large array of datasheets from this manufacturer that save me having to reverse engineer other sound cards in their range. Making binary drivers is therefore not a viable way to protect IP. We are slowly removing the excuses that companies can hide behind as reasons for not releasing datasheets to open source driver developers.
James
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 9 lines · James Courtier-Dutton
I agree with Linus on these points. The kernel should not be enforcing these issues. Leave the lawyers to do that bit. If companies want to play in the "Grey Area", then it is at their own risk. Binary drivers are already difficult and expensive for the companies because they have to keep updating them as we change the kernel versions. If they do open source drivers, we update them for them as we change the kernel versions, so it works out cheaper for the companies involved.
Hum. We open sourced our drivers 2 years ago. Now one is 'changing' them for us. The only way that happens is if they can get in the official tree. I know just from monitoring this list that our drivers would never be acceptable for inclusion in any "functional form". We open sourced them purely out of respect for the way we know the community feels about it.
It would cost more for us to make them acceptable for inclusion than it does for us to just maintain them ourselves. I suspect that is true for most vendor created drivers open source or not.
So kernel developers making the required changes as the kernel changes is NO real incentive for any vendor to open source their drivers. Sorry.
If it were knowingly less difficult to actually get your drivers included, that would be an incentive and then you original point would hold as an additional incentive.
My humble $.02 worth
Regards
Mark
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 6 lines · On Sun, 24 Dec 2006 06:57:58 -0500 Mark Hounschell <[email protected]> wrote:
Hum. We open sourced our drivers 2 years ago. Now one is 'changing' them for us. The only way that happens is if they can get in the official tree. I know just from monitoring this list that our drivers would never be acceptable for inclusion in any "functional form". We open sourced them purely out of respect for the way we know the community feels about it.
That shows some class, thanks.
Quoted 10 lines
It would cost more for us to make them acceptable for inclusion than it does for us to just maintain them ourselves. I suspect that is true for most vendor created drivers open source or not.
So kernel developers making the required changes as the kernel changes is NO real incentive for any vendor to open source their drivers. Sorry.
If it were knowingly less difficult to actually get your drivers included, that would be an incentive and then you original point would hold as an additional incentive.
Out of curiosity what specific technical issues in your driver code make you think that it would be too expensive to whip them into shape for inclusion?
Cheers,
Sean
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 24 lines · Sean
Quoted 6 lines · On Sun, 24 Dec 2006 06:57:58 -0500 Mark Hounschell <[email protected]> wrote:
Hum. We open sourced our drivers 2 years ago. Now one is 'changing' them for us. The only way that happens is if they can get in the official tree. I know just from monitoring this list that our drivers would never be acceptable for inclusion in any "functional form". We open sourced them purely out of respect for the way we know the community feels about it.
That shows some class, thanks.
Quoted 10 lines
It would cost more for us to make them acceptable for inclusion than it does for us to just maintain them ourselves. I suspect that is true for most vendor created drivers open source or not.
So kernel developers making the required changes as the kernel changes is NO real incentive for any vendor to open source their drivers. Sorry.
If it were knowingly less difficult to actually get your drivers included, that would be an incentive and then you original point would hold as an additional incentive.
Quoted 7 lines
Out of curiosity what specific technical issues in your driver code make you think that it would be too expensive to whip them into shape for inclusion?
Cheers,
Sean
Well just off the top of my head, one of our drivers directly mucks with all the irq affinities (irq_desc) via a provided user land library call. This single call forces all 'other' irqs to be serviced by all the 'other' processors. I know this would never fly in kernel. User land /proc manipulation is not an option for us here.
We have another that absolutely requires the Bigphysarea patch. We refuse to use "MEM=xxxx" and use a fixed address. Every installation would require a special configuration and our 'end users' would have to have some understanding of all that. We are also maintaining that patch internally also. So this product (for full functionality with our not so open source application) requires a special kernel to begin with. Other than that this one might have a chance of inclusion. It only requires the bigphysarea when used with this application. It will actually build and work (basically) with or without it.
Another is actually somewhat tied to the one mentioned above in that this one has to facilitate the ability of its card being able to to PIO reads and writes to 'special locations' in userspace and to the SRAM memory of the above card. Even when on different pci busses. I've looked at some of the V4L drivers that also do this sort of thing and I'm confused by how they are doing it so I'm almost certain that what we are doing would be considered 'wrong'.
Then there is probably the biggest one of all. The coding style issue. Don't get me wrong I understand and agree with what I've read about it. Our drivers were written by hardware people. Or I should say they were written by OUR hardware people. I can offend them because I am among them. No offense intended to any of you invaluable hardware guys.
I see 6 months of full time work before I could even sanely ask what I needed to do for inclusion. It seems easier to just try to keep up with the changes.
I'm certain our company is not the only one in this situation. I see many GPL external kernel drivers. Why?
Mark
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Greg KHQuoted 1 line · Greg KH
An updated version is below.
If you're adding this, you should probably schedule EXPORT_SYMBOL_GPL for removal at the same time, as this essentially renders that irrelevant.
That being said...
First, this is adding the measure at module load time. Any copyright infringment happens on distribution; module load isn't (necessarily) that; if I write random code and load it, without ever sending it to anyone, I'm not violating the license, and this would prevent that. So it seems somewhat misplaced.
Secondly...
Quoted 4 lines
Oh, and for those who have asked me how we would enforce this after this date if this decision is made, I'd like to go on record that I will be glad to take whatever legal means necessary to stop people from violating this.
There's nothing stopping you undertaking these means now. Addition of this measure doesn't change the copyright status of any code - what was a violation before would still be a violation. Copyright's not something like trademark, where it's sue-or-lose - there's no requirement for constant action, and there's no requirement for enforcement measures. If I reproduce and start selling copies of the White album, it doesn't matter that there wasn't a mechanism on the CD that prevented me doing that - it's still a copyright violation.
Hence, the only purpose of a clause like this legally would seem to be to *intentionally* go after people using the DMCA. Which seems... tacky.
Of course, I don't have significant code of note in the kernel, so I can't really prevent you from doing this if you want...
Bill
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 7 lines · Bill Nottingham
Quoted 1 line · Greg KH
An updated version is below.
If you're adding this, you should probably schedule
EXPORT_SYMBOL_GPLfor removal at the same time, as this essentially renders that irrelevant.
Quoted 7 lines
That being said...
First, this is adding the measure at module load time. Any copyright infringment happens on distribution; module load isn't (necessarily) that; if I write random code and load it, without ever sending it to anyone, I'm not violating the license, and this would prevent that. So it seems somewhat misplaced.
Yes, as Linus points out, this is the main point here, my apologies. GPL covers distribution, not usage, no matter how much the people working on v3 want to change that :)
Even if we change the kernel this way, it prevents valid and legal usages of the kernel. So I am wrong, sorry.
Quoted 10 lines
Secondly...
Quoted 4 lines
Oh, and for those who have asked me how we would enforce this after this date if this decision is made, I'd like to go on record that I will be glad to take whatever legal means necessary to stop people from violating this.
There's nothing stopping you undertaking these means now. Addition of this measure doesn't change the copyright status of any code - what was a violation before would still be a violation.
Agreed, and I have done this in the past. I only stated this because it seems that some people keep just wishing this whole issue would go away if they ignore it.
Quoted 2 lines
Hence, the only purpose of a clause like this legally would seem to be to *intentionally* go after people using the DMCA. Which seems... tacky.
Despite my wardrobe consisting mainly of old t-shirts and jeans, I still never want to be called tacky :)
It's just that I'm so damn tired of this whole thing. I'm tired of people thinking they have a right to violate my copyright all the time. I'm tired of people and companies somehow treating our license in ways that are blatantly wrong and feeling fine about it. Because we are a loose band of a lot of individuals, and not a company or legal entity, it seems to give companies the chutzpah to feel that they can get away with violating our license.
So when someone like Andrew gives me the opportunity to put a stop to all of the crap that I have to put up with each and every day with a tiny 2 line patch, I jumped in and took it. I need to sit back and remember to see the bigger picture some times, so I apologize to everyone here.
And yes, it is crap that I deal with every day due to the lovely grey area that is Linux kernel module licensing these days. I have customers that demand we support them despite them mixing three and more different closed source kernel modules at once and getting upset that I have no way to help them out. I have loony video tweakers that hand edit kernel oopses to try to hide the fact that they are using a binary module bigger than the sum of the whole kernel and demand that our group fix their suspend/resume issue for them. I see executives who say one thing to the community and then turn around and overrule them just because someone made a horrible purchasing decision on the brand of laptop wifi card that they purchased. I see lawyers who have their hands tied by attorney-client rules and can not speak out in public for how they really feel about licenses and how to interpret them.
And in the midst of all of that are the poor users who have no idea who to listen to. They don't know what is going on, they "just want to use their hardware" and don't give a damm about anyone's license. And then there's the distros out there that listen to those users and give them the working distro as they see a market for it, and again, as a company, justify to themselves that it must be ok to violate those kernel developers rights because no one seems to be stopping them so far.
[side diversion, it's not the video drivers that really matter here everyone, those are just so obvious. It's the hundreds of other blatantly infringing binary kernel modules out there that really matter. The ones that control filesystems, cluster interconnects, disk arrays, media codecs, and a whole host of custom hardware. That's the real problem that Linux faces now and will only get worse in the future. It's not two stupid little video drivers, I could honestly care less about them...]
But it's all part of the process, and I can live with it, even if at times it drives me crazy.
But I know we will succeed, it will just take us a little longer to get there, so I might as well learn to enjoy the view more.
Even though I really think I can get that patch by the Novell lawyers and convince management there that it is something we can do, it's not something that I want to take on, as I think my time can be better spent coding to advance Linux technically, not fight legal battles.
I'll go delete that module.c patch from my tree now.
thanks,
greg k-h
p.s. I still think the UIO interface is a valid and good one. And yes, it might cause people to move stuff to userspace that they really should not be just to get around the GPL issues. But like loots of tools, it can be used in good and bad ways, we shouldn't prevent the good usages of it. I'll work to get more real examples using it before resubmitting.
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 2 lines · Greg KH
It's just that I'm so damn tired of this whole thing. I'm tired of people thinking they have a right to violate my copyright all the time.
Pretty much every license under the sun is getting violated, and people are getting away with it. The GPL is not special in this regard.
Quoted 5 lines
And yes, it is crap that I deal with every day due to the lovely grey area that is Linux kernel module licensing these days. I have customers that demand we support them despite them mixing three and more different closed source kernel modules at once and getting upset that I have no way to help them out.
However, users do not like running unsupportable software when the shit hits the fan - which it will always do with any piece of software, eventually :)
Maybe we should just educate users and teach them to avoid crazy unsupportable configurations and simply buy the hardware that has open drivers available?
In the laptop space, I already try to avoid everything non-Centrino, because chances are a closed source video or network driver would be needed with something else[1].
Judging from how much vendor drivers tend to get improved when they get merged upstream, I don't see how vendors think they can get away with not merging their code upstream.
I'm not talking about this from a legal standpoint (millions of people get away with blatantly illegal stuff every day), but from a technical and market point of view.
Why would users buy a piece of hardware that needs a binary only driver that's unsupportable, when they can buy a similar piece of hardware that has a driver that's upstream and is supported by every single Linux distribution out there?
Sure, the process of getting drivers merged upstream[2] can take some time and effort, but the resulting improvements in driver performance and stability are often worth it. It's happened more than once that the Linux kernel community's review process turned up some opportunities for a 30% performance improvement in a submitted driver.
Hardware companies: can you afford to miss out on the stability and performance improvements that merging a driver upstream tends to get?
Can you afford to miss out when your competitors are getting these benefits?
[1] other vendors: fix your stuff, so I can recommend your hardware too!
[2] http://kernelnewbies.org/UpstreamMerge
Signature · 3 lines
Politics is the struggle between those who want to make their country the best in the world, and those who believe it already is. Each group calls the other unpatriotic.
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 3 lines
Pretty much every license under the sun is getting violated, and people are getting away with it. The GPL is not special in this regard.
That may begin to change in time. There are a lot of people getting very angry at the political level about the way large companies in particular flout copyright law and claim to "not know" because they just bought something in, often from Taiwan or China, with stolen code in it.
There are proposals on the table in the EU to make commercial piracy a criminal not a civil matter in the case of copyright. (The original proposal also suggested for patents which would have been rather dumb but that seems to have been killed off for now). So in a couple years a GPL violating product in the EU may entail a walk down to the local police station rather than a private court case.
In the UK also trading standards whose remit right now is trademark abuse will also be getting enforcement powers and funding for copyright stuff. The powers that be are mostly thinking "pirate DVD in the local market stall", but some of us have other ideas.
We do need to distinguish between the blatant violators and the borderline people - there's a difference between the folks shipping Linux rip-offs binary only in random unlabelled routers and people like Nvidia and Novell who are on the edge of the license corner cases.
Another thing we should do more is aggressively merge prototype open drivers for binary only hardware - lets get Nouveau's DRM bits into the kernel ASAP for example.
Alan
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 3 lines · Alan
Another thing we should do more is aggressively merge prototype open drivers for binary only hardware - lets get Nouveau's DRM bits into the kernel ASAP for example.
ACK++ We should definitely push Nouveau[1] as hard as we can.
Jeff
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 9 lines · Jeff Garzik
Quoted 3 lines · Alan
Another thing we should do more is aggressively merge prototype open drivers for binary only hardware - lets get Nouveau's DRM bits into the kernel ASAP for example.
ACK++ We should definitely push Nouveau[1] as hard as we can.
Jeff
It'll get in when the developers feel it is at a stage where it can be supported, at the moment (I'm not speaking for all the nouveau team only my own opinion) the API isn't stable and putting it into the kernel only means we've declared the API supportable, I know in theory marking it EXPERIMENTAL might work, in practice it will just cause us headaches at this stage, there isn't enough knowledgeable developers working on it both support users and continue development at a decent rate, so mainly ppl are concentrating on development until it can at least play Q3, and for me dualhead on my G5 :-)
Dave.
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 11 lines · Dave Airlie
Quoted 9 lines · Jeff Garzik
Quoted 3 lines · Alan
Another thing we should do more is aggressively merge prototype open drivers for binary only hardware - lets get Nouveau's DRM bits into the kernel ASAP for example.
ACK++ We should definitely push Nouveau[1] as hard as we can.
Jeff
Quoted 9 lines
It'll get in when the developers feel it is at a stage where it can be supported, at the moment (I'm not speaking for all the nouveau team only my own opinion) the API isn't stable and putting it into the kernel only means we've declared the API supportable, I know in theory marking it EXPERIMENTAL might work, in practice it will just cause us headaches at this stage, there isn't enough knowledgeable developers working on it both support users and continue development at a decent rate, so mainly ppl are concentrating on development until it can at least play Q3, and for me dualhead on my G5 :-)
To what degree does it work on the G5?
Can we already drive a desktop system with it?
I'd like to play around with this on my Quad.
Signature · 1 line
Greetings Michael.
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 11 lines
Quoted 10 lines
It'll get in when the developers feel it is at a stage where it can be supported, at the moment (I'm not speaking for all the nouveau team only my own opinion) the API isn't stable and putting it into the kernel only means we've declared the API supportable, I know in theory marking it EXPERIMENTAL might work, in practice it will just cause us headaches at this stage, there isn't enough knowledgeable developers working on it both support users and continue development at a decent rate, so mainly ppl are concentrating on development until it can at least play Q3, and for me dualhead on my G5 :-)
Quoted 4 lines
To what degree does it work on the G5?
Can we already drive a desktop system with it?
I'd like to play around with this on my Quad.
2D worked the last time I tested it and fixed up all the problems, it is slightly faster than nv, but may be more unstable, still only single head... 3D even on x86 doesn't work yet without pre-loading nvidia to set the hardware up correctly.. but it's coming along.... there are summary updates posted ~weekly on the nouveau wiki....
Dave.
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 16 lines · Dave Airlie
Quoted 11 lines
Quoted 10 lines
It'll get in when the developers feel it is at a stage where it can be supported, at the moment (I'm not speaking for all the nouveau team only my own opinion) the API isn't stable and putting it into the kernel only means we've declared the API supportable, I know in theory marking it EXPERIMENTAL might work, in practice it will just cause us headaches at this stage, there isn't enough knowledgeable developers working on it both support users and continue development at a decent rate, so mainly ppl are concentrating on development until it can at least play Q3, and for me dualhead on my G5 :-)
Quoted 4 lines
To what degree does it work on the G5?
Can we already drive a desktop system with it?
I'd like to play around with this on my Quad.
Quoted 5 lines
2D worked the last time I tested it and fixed up all the problems, it is slightly faster than nv, but may be more unstable, still only single head... 3D even on x86 doesn't work yet without pre-loading nvidia to set the hardware up correctly.. but it's coming along.... there are summary updates posted ~weekly on the nouveau wiki....
Ok, that's nice to hear. :)
Can't be much more pain than nv, heh.
And as I only have singlehead, anyway, I'll give it a try.
Signature · 1 line
Greetings Michael.
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Rik van RielQuoted 4 lines · Rik van Riel
Why would users buy a piece of hardware that needs a binary only driver that's unsupportable, when they can buy a similar piece of hardware that has a driver that's upstream and is supported by every single Linux distribution out there?
In my experience it falls into a number of categories:
1) The system that requires the binary driver has other hardware on it that is required for the app.
2) The system that requires the binary driver costs significantly less, enough that they decide to bite the bullet on the software support side.
3) The system that requires the binary driver is the *only* one available in the specified form factor with the specified cpu architecture.
4) The team that decides on the hardware is totally divorced from the OS guys, so they don't know/care what is supported by open source drivers in the first place.
Chris
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Rik van RielQuoted 3 lines · Rik van Riel
Maybe we should just educate users and teach them to avoid crazy unsupportable configurations and simply buy the hardware that has open drivers available?
Educating the users may help, but it's hard to do the education once they've already bought the hardware. Generally, it would be 1) buy hardware 2) run whatever comes with it
3) try Linux. Hard to get the 'if you're ever thinking about running Linux, don't buy XYZ' into that workflow.
Quoted 7 lines
Sure, the process of getting drivers merged upstream[2] can take some time and effort, but the resulting improvements in driver performance and stability are often worth it. It's happened more than once that the Linux kernel community's review process turned up some opportunities for a 30% performance improvement in a submitted driver.
Quoted 6 lines
Hardware companies: can you afford to miss out on the stability and performance improvements that merging a driver upstream tends to get?
Can you afford to miss out when your competitors are getting these benefits?
This is the big point - we need to show the vendors how getting upstream helps them.
Compare costs of all-in-house development versus shared-with-community development.
Compare how quickly issues are fixed, and how often drivers actually regress with in-tree vs. out-of-tree drivers.
Get case studies of drivers that have been opened (qeth? lpfc? Others?) and get other companies to *go on the record* on how opening their drivers and getting them upstream has helped them to lower their development costs and scale their sales.
Bill
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Greg KHHi.
Good arguments have already been put against it, so I'll just keep it short and sweet (FWIW)
Regards,
Nigel
RE: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Greg KHQuoted 10 lines
Someone also mentioned that we could just put a nice poem into the kernel module image in order to be able to enforce our copyright license in any court of law.
Full bellies of fish
Penguins sleep under the moon
Dream of wings that flythanks,
Whoever says that has no understanding of copyright law. Copyright law *only* protects something when there are a large number of equally-good ways to accomplish the same thing. If there is only one way to accomplish a particular function, it cannot be protected by copyright.
The Lexmark v. Static Controls case made this pretty clear. Lexmark did pretty much the same thing with their toner cartridges. You cannot copyright a password to get the effect of a patent (ownership of every way to accomplish a particular function).
By the way, the GPL seems to prohibit this. Why is this not an "additional restriction"? Where does the GPL say that you cannot create and use a derivative work unless you put a notice in it stating that it is licensed under the GPL?
I agree with Linus that this is insane hypocrisy. To be totally blunt, the want to do this -- to control the way other people use the works they own -- is the same evil impulse that drives the RIAA. Shame on you. It's supposed to be about free as in freedom.
DS
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Greg KHQuoted 4 lines · Greg KH
Oh, and for those who have asked me how we would enforce this after this date if this decision is made, I'd like to go on record that I will be glad to take whatever legal means necessary to stop people from violating this.
I see no _overriding_ reason to wait. This is a technical measure which they'd need to deliberately work around, and which might make the case easier to win -- but I think I'm on record already as planning to sue someone soon for binary-only modules, even without this particular technical measure to prevent them.
The only reason it hasn't happened so far is because lawyers make me itch.
Signature · 1 line
dwmw2
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Jonathan CorbetQuoted 3 lines
2008? I bet a lot of people would read the above to say that their system will just drop dead of a New Year's hangover, and they'll freak. I wouldn't want to be the one getting all the email at that point...
I wouldn't worry. Everyone will have patched it back out again by then, or made their driver lie about the license. Both of which make the problem worse not better when it comes to debugging.
Alan
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 7 lines · Alan
Quoted 3 lines
2008? I bet a lot of people would read the above to say that their system will just drop dead of a New Year's hangover, and they'll freak. I wouldn't want to be the one getting all the email at that point...
I wouldn't worry. Everyone will have patched it back out again by then, or made their driver lie about the license. Both of which make the problem worse not better when it comes to debugging.
But make it easier when it comes to court...
Quoted 1 line
Alan
cu
Adrian
Signature · 4 lines
"Is there not promise of rain?" Ling Tan asked suddenly out
of the darkness. There had been need of rain for many days.
"Only a promise," Lao Er said.
Pearl S. Buck - Dragon SeedRe: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
In reply to Greg KHHi!
Quoted 59 lines
Quoted 7 lines
Quoted 7 lines
Quoted 2 lines
So let's come out and ban binary modules, rather than pussyfooting around, if that's what we actually want to do.
Give people 12 months warning (time to work out what they're going to do, talk with the legal dept, etc) then make the kernel load only GPL-tagged modules.
Quoted 6 lines
Quoted 2 lines
I think I'd favour that. It would aid those people who are trying to obtain device specs, and who are persuading organisations to GPL their drivers.
Ok, I have no objection to that at all. I'll whip up such a patch in a bit to spit out kernel log messages whenever such a module is loaded so that people have some warning.
Here you go. The wording for the feature-removal-schedule.txt file could probably be cleaned up. Any suggestions would be welcome.
thanks,
greg k-h
-----------
From: Greg Kroah-Hartmna <[email protected]>
Subject: Notify non-GPL module loading will be going away in January 2008Numerous kernel developers feel that loading non-GPL drivers into the kernel violates the license of the kernel and their copyright. Because of this, a one year notice for everyone to address any non-GPL compatible modules has been set.
Signed-off-by Greg Kroah-Hartman <[email protected]>--- Documentation/feature-removal-schedule.txt | 9 +++++++++ kernel/module.c | 6 +++++- 2 files changed, 14 insertions(+), 1 deletion(-)Documentation/feature-removal-schedule.txt +9
-0@@ -281,3 +281,12 @@ Why: Speedstep-centrino driver with ACPI Who: Venkatesh Pallipadi <[email protected]> --------------------------- + +What: non GPL licensed modules will able to be loaded successfully. +When: January 2008 +Why: Numerous kernel developers feel that loading non-GPL drivers into the + kernel violates the license of the kernel and their copyright. + +Who: Greg Kroah-Hartman <[email protected]> or <[email protected]> + +---------------------------kernel/module.c +0
-1@@ -1393,9 +1393,13 @@ static void set_license(struct module *m license ="unspecified" ;if (!license_is_gpl_compatible (license)) { -if (!(tainted &TAINT_PROPRIETARY_MODULE ))
kernel/module.c static void set_license(struct module *m · line 1405
Quoted 10 lines
kernel/module.c +5
-0+if (!(tainted &TAINT_PROPRIETARY_MODULE )) {printk (KERN_WARNING "%s: module license '%s' taints " "kernel.\n" , mod->name, license); +printk (KERN_WARNING "%s: This module will not be able " +"to be loaded after January 1, 2008 due to its " +"license.\n" , mod->name); + }add_taint_module (mod,TAINT_PROPRIETARY_MODULE ); } }
perhaps printk('Binary only modules are not allowed by kernel license, but copyright law may still allow them in special cases. Be careful, Greg is going tuo sue you at beggining of 2008 if you get it wrong.') would be acceptable way to educate people?
Pavel
Signature · 1 line
Thanks for all the (sleeping) penguins.
Re: GPL only modules [was Re: [GIT PATCH] more Driver core patches for 2.6.19]
Quoted 3 lines · Pavel Machek
perhaps printk('Binary only modules are not allowed by kernel license, but copyright law may still allow them in special cases. Be careful,
Come again?
Quoted 2 lines
Greg is going tuo sue you at beggining of 2008 if you get it wrong.') would be acceptable way to educate people?
Since this message will be seen by an end-user who is likely does not do any distribution he has nothing to fear from Greg ;)
Signature · 1 line
Dmitry
Quoted 9 lines · Andrew Morton
Quoted 2 lines · On Wed, 13 Dec 2006 13:32:50 -0800 Martin Bligh <[email protected]> wrote:
So let's come out and ban binary modules, rather than pussyfooting around, if that's what we actually want to do.
Give people 12 months warning (time to work out what they're going to do, talk with the legal dept, etc) then make the kernel load only GPL-tagged modules.
IIRC, Linus has deliberately and explicitly estopped himself from claiming that loading a binary-only driver is a GPL violation. Do you really want to create an arbitrage opportunity for intermediaries who undo technical measures that don't match Linus's declared policy or, in many people's opinion, the law in at least some jurisdictions? (I'm not going to go all amateur-lawyer on you, but the transcript of oral argument at the Supreme Court level in Lotus v. Borland makes really interesting reading no matter where you live or what your stance is on GPL-and-linking.)
Quoted 2 lines
I think I'd favour that. It would aid those people who are trying to obtain device specs, and who are persuading organisations to GPL their drivers.
I don't think it would. There is a strong argument that GPL drivers in the mainline kernel are a good idea on technical and business grounds. Making a federal case out of it is a distraction at best.
There is a widespread delusion that closed driver code is an asset in an accounting sense. It costs a lot of money to create and even more to maintain in any kind of usable condition. As long as managers of chip development projects get away with shifting some of the real cost of creating yet another buggy undocumented one-off CPU interface onto a "software" team in a different cost center, the pressure to label the code base an intangible asset is overwhelming. It usually takes a reorg or two to diffuse the responsibility enough to call it a sunk cost, at which point someone might be brave enough to argue that opening it up would save money and/or sell more chips.
As things stand, there is a slippery slope (in a good way) from a totally-closed, one-off, buggy vendor driver to a GPL'ed driver in the mainline kernel. Customers get impatient for drivers that work, the vendor allows a customer or a mutually acceptable third party to work on the code, the sky doesn't fall. There are some situations where the business strategy of keeping the driver closed is defensible on both engineering and regulatory/barrier-to-entry grounds, but they're fairly rare; and some fraction of vendors come around to that view in time.
Quoted 1 line
(Whereas the patch which is proposed in this thread hinders those people)
There we agree.
Cheers,
- Michael
Quoted 7 lines · Michael K. Edwards
Quoted 4 lines · Andrew Morton
Quoted 1 line · On Wed, 13 Dec 2006 13:32:50 -0800 Martin Bligh <[email protected]> wrote:
So let's come out and ban binary modules, rather than pussyfooting around, if that's what we actually want to do.
Give people 12 months warning (time to work out what they're going to do, talk with the legal dept, etc) then make the kernel load only GPL-tagged modules.
IIRC, Linus has deliberately and explicitly estopped himself from claiming that loading a binary-only driver is a GPL violation. Do you really want to create an arbitrage opportunity for intermediaries who undo technical measures that don't match Linus's declared policy or, in many people's opinion, the law in at least some jurisdictions? (I'm not going to go all amateur-lawyer on you, but the transcript of oral argument at the Supreme Court level in Lotus v. Borland makes really interesting reading no matter where you live or what your stance is on GPL-and-linking.)
Ok, so what Linus said is true for any code that _Linus_ wrote up until this point. It is perfectly fine for the iptables developers to say "I think linking with my GPL IPTables code for makes your code a derivative work of mine", although I don't really have the legal knowledge to argue technical points either way.
Corporations change their mind on licensing all the time; though you can never revoke privileges you already granted on existing materials. As soon as you start creating new material (in the Linux case at a rate of multiple megs per month) you can set new licensing requirements on that new code as long as it's compatible with the requirements on the old code which it's linked against.
Cheers,
Kyle Moffett
Quoted 2 lines
IIRC, Linus has deliberately and explicitly estopped himself from claiming that loading a binary-only driver is a GPL violation. Do you
He only owns a small amount of the code. Furthermore he imported third party GPL code using the license as sole permission. So he may have dug a personal hole but many of the rest of us have been repeatedly saying whenever he said that - that we do not agree. The FSF has always said binary modules are wrong and there is FSF code imported into the kernel by Linus on license only grounds.
Whether it is a good idea is a different question.
Alan.
Quoted 11 lines · Alan
Quoted 2 lines
IIRC, Linus has deliberately and explicitly estopped himself from claiming that loading a binary-only driver is a GPL violation. Do you
He only owns a small amount of the code. Furthermore he imported third party GPL code using the license as sole permission. So he may have dug a personal hole but many of the rest of us have been repeatedly saying whenever he said that - that we do not agree. The FSF has always said binary modules are wrong and there is FSF code imported into the kernel by Linus on license only grounds.
Whether it is a good idea is a different question.
Wait a bloody minute - the only FSF code in the kernel I know of is from libgcc, which does allow linking to non-GPL code. Is there anything else?
Quoted 5 lines · Alan
He only owns a small amount of the code. Furthermore he imported third party GPL code using the license as sole permission. So he may have dug a personal hole but many of the rest of us have been repeatedly saying whenever he said that - that we do not agree.
[ The "he" being me in the above ]
Btw, I'd like to make it clear in this discussion too (as I have in others), that I agree 100% with Alan here.
The thing is, my opinion is really just _my_ opinion. People shouldn't see it as anything else. When I say "I don't think we should totally disallow binary modules", you should always keep in mind that:
- the fact that I think that _some_ binary modules may be perfectly legal does not mean that I think _all_ binary modules would be legal. I think there are lots of ways to make such a binary module that is obviously not ok.
- I really _am_ just one of hundreds of copyright owners. The fact that _I_ am not necessarily all that eager to take things to court should in no way be seen as estoppel for _others_ who decide that they want to flex their legal rights.
So when I "may have dug a personal hole", please realize that this is actually a personal - and conscious - choice. I've never wanted to do copyright assignments, for several reasons: I think they are nasty and wrong personally, and I'd hate all the paperwork, and I think it would actually detract from the development model.
But one of the reasons I've never wanted copyright assignments is that I'm personally actually _more_ comfortable with the system being co-owned. I _like_ having my hands bound, and being in that hole. Not because of any strange sexual hangups either, but simply because I think being personally limited is something that makes people trust me more in the end - or rather, it is something that means that people don't _have_ to trust me.
So people know that I can't unilaterally change the license. And they _know_ that they can actually take things to court on their own. AND THAT IS A GOOD THING. The last thing anybody _ever_ wants is to have me having absolute powers. Not you guys, and certainly not me.
So you guys should always be happy, realizing that Linus may have his quirks, but that my quirks can't ever really screw you guys up.
So I repeat: my opinions are _my_ opinions. Nobody else is legally bound by them. And I'm certainly willing to bend my behaviour in the presense of pressure (I think only mindless idiots can't change their mind - I personally change some of my opinions several times a day just to keep them fresh), but in somethign like this, where I _do_ have a fairly strong opinion, I really think that this kind of patch has to be merged in somebody elses tree than mine.
If, after a year, it turns out that my tree is the only one that doesn't have that clause, I think I'll either get the hint, or people will realize that I'm pointless and will just ignore me. It will have taken you long enough to realize that ;)
Because one of the great things about the GPL is that _nobody_ has the power to deny other peoples will. Not even me, not even for the kernel.
Linus
Quoted 3 lines · Michael K. Edwards
I don't think it would. There is a strong argument that GPL drivers in the mainline kernel are a good idea on technical and business grounds.
Any volunteers to expand on that in the Kernelnewbies section on this subject? So far the "business ground" is only half a page or so :)
http://kernelnewbies.org/UpstreamMerge
Signature · 1 line
All Rights Reversed
Quoted 7 lines · Greg KH
Quoted 4 lines · Michael K. Edwards
Seriously, though, please please pretty please do not allow a facility for "going through a simple interface to get accesses to irqs and memory regions" into the mainline kernel, with or without toy ISA examples.
Why? X does it today :)
Er, I rest my case? Anyway, the history around X11 is completely different from the present situation, and there were good arguments at the time for structuring the problem so that the X server was relatively kernel-neutral even if it was banging directly on a framebuffer, and later on 2-D acceleration hardware. As graphics chips have become more sophisticated, pure-userspace X11 has become less tenable.
Quoted 6 lines
Quoted 3 lines
Embedded systems integrators have enough trouble with chip vendors who think that exposing the device registers to userspace constitutes a "driver".
Yes, and because of this, they create binary only drivers today. Lots of them. All over the place. Doing crazy stupid crap in kernelspace.
It does not get less crazy and stupid because we open a big hole from kernelspace to userspace and let them pretend that they have a GPL "driver" when all of the chip init logic is peeked and poked from the same closed code in userspace. Most low-level drivers (the kind that involve IRQs and registers local to the CPU; USB is different) cannot be done right from userspace and we shouldn't encourage people to try.
Quoted 3 lines
Then there are people who do irq stuff in userspace but get it wrong. I've seen that happen many times in lots of different research papers and presentations.
Their problems need not become our problems.
Quoted 3 lines
This interface does it correctly, and it allows those people who for some reason feel they do want to keep their logic in non-gpl code, to do it.
People who want to keep their logic in non-GPL code do so by providing binary-only drivers. That's a sane compromise in certain sectors, and occasionally results in the eventual opening of the driver (when the illusion of competitive advantage in closed-ness wears off) in integrable shape. A customer with some leverage and technical skill can negotiate for access to the source code so that he can fix the bugs that are biting him, rebuild with a toolchain that isn't from the Dark Ages, and so forth: a real-life demonstration to the vendor that letting outsiders work on the code will sell more chips. But if you actively encourage a brain-damaged userspace driver strategy, that opportunity is lost.
Quoted 4 lines
It also allows code that needs floating point to not be in the kernel and in one instance using this interface actually sped up the device because of the lack of the need to go between kernel and userspace a bunch of times.
What instance is that? Are you sure it wasn't a case of things being done in the driver that should have been done in a library all along?
Quoted 10 lines
Quoted 3 lines
The correct description is more like "porting shim for MMU-less RTOS tasks"; and if the BSP vendors of the world can make a nickel supplying them, more power to them. Just not in mainline, please.
Again, X does this today, and does does lots of other applications. This is a way to do it in a sane manner, to keep people who want to do floating point out of the kernel, and to make some embedded people much happier to use Linux, gets them from being so mad at Linux because we keep changing the internal apis, and makes me happier as they stop violating my copyright by creating closed drivers in the kernel.
Today's problem is that too many chip suppliers' in-house software people have neither the skills nor the schedule room nor the influence to insist that drivers be written competently and maintainably, whether or not they are maintained in the public view. So chipmakers turn to the BSP vendors, whose business model is built around being the only people who can do incremental development on the code they write.
I'm not at all hostile to BSP vendors or to chipmakers who wind up in this position; that's the way most of the industry works nowadays. But I do want to know when I'm dealing with that situation, because the appropriate strategies for getting a product to market are different when it costs the chip vendor real cash money each time they commission a recompile to meet some customer's expectations. Pretending that driver code doesn't need reviewing every few months as the kernel's locking strategies, timer handling, internal APIs, etc. evolve makes things worse.
Just like the only thing worse that a salesperson who's on commission is a salesperson who isn't on commission, the only thing worse than a closed device driver in kernelspace is a closed device driver in userspace.
Cheers,
- Michael
Quoted 5 lines · Michael K. Edwards
Quoted 1 line · Linus Torvalds
Ok, what kind of ass-hat idiotic thing is this?
C'mon, Linus, tell us how you _really_ feel.
I'll try to be less subtle next time ;)
Quoted 4 lines
Seriously, though, please please pretty please do not allow a facility for "going through a simple interface to get accesses to irqs and memory regions" into the mainline kernel, with or without toy ISA examples.
I do agree.
I'm not violently opposed to something like this in practice (we've already allowed it for USB devices), but there definitely needs to be a real reason that helps _us_, not just some ass-hat vendor that looks for a way to avoid open-sourcing their driver.
If there are real and valid uses (and as mentioned, I actually think that the whole graphics-3D-engine-thing is such a use) where a kernel driver simply doesn't work out well, or where there are serious tecnical reasons why it wants to be in user space (and "stability" is not one such thing:
if you access hardware directly in user space, and your driver is buggy, the machine is equally deal, and a hell of a lot harder to control to boot).
Microkernel people have their heads up their arses, none of their arguments have actually ever made any real logical sense. So look elsewhere for real reasons to do it in user space.
Linus
Hi!
Quoted 12 lines
Quoted 4 lines
Seriously, though, please please pretty please do not allow a facility for "going through a simple interface to get accesses to irqs and memory regions" into the mainline kernel, with or without toy ISA examples.
I do agree.
I'm not violently opposed to something like this in practice (we've already allowed it for USB devices), but there definitely needs to be a real reason that helps _us_, not just some ass-hat vendor that looks for a way to avoid open-sourcing their driver.
Quoted 7 lines
If there are real and valid uses (and as mentioned, I actually think that the whole graphics-3D-engine-thing is such a use) where a kernel driver simply doesn't work out well, or where there are serious tecnical reasons why it wants to be in user space (and "stability" is not one such thing:
if you access hardware directly in user space, and your driver is buggy, the machine is equally deal, and a hell of a lot harder to control to boot).
Well.. it is easier to debug in userspace. While bad hw access can still kill the box, bad free() will not, and most bugs in early developent are actually of 2nd kind.
Pavel
Signature · 1 line
Thanks for all the (sleeping) penguins.
Quoted 4 lines · Pavel Machek
Well.. it is easier to debug in userspace. While bad hw access can still kill the box, bad
free()will not, and most bugs in early developent are actually of 2nd kind.
Isn't that what qemu is for?
Jörn
Signature · 2 lines
Happiness isn't having what you want, it's wanting what you have. -- unknown
Hi!
Quoted 5 lines
Quoted 3 lines
Well.. it is easier to debug in userspace. While bad hw access can still kill the box, bad
free()will not, and most bugs in early developent are actually of 2nd kind.Isn't that what qemu is for?
I do not think you can reasonably debug driver for new hardware under qemu.
Anyway, doing it in userspace is just convenient.
Pavel
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
Quoted 7 lines
Ok, what kind of ass-hat idiotic thing is this?
irqreturn_t uio_irq_handler(int irq, void *dev_id) { return IRQ_HANDLED; }
Quoted 7 lines
exactly what is the point here? No way will I pull this kind of crap. You just seem to have guaranteed a dead machine if the irq is level-triggered, since it will keep on happening forever.
Please remove.
YOU CANNOT DO IRQ'S BY LETTING USER SPACE SORT IT OUT!
Actually, you can... but wether you want is a different story :-)
You can simply mask it, have it handled by userspace and re-enable it when that's done. Though say hello to horrible interrupt latencies and hope you aren't sharing it with anything critical...
I don't mean I -like- the approach... I just say it can be made to sort-of work. But I don't see the point.
Ben.
Quoted 4 lines
You can simply mask it, have it handled by userspace and re-enable it when that's done. Though say hello to horrible interrupt latencies and hope you aren't sharing it with anything critical...
For the sharing case, some sort of softirq should be created. That is, when a hard interrupt is generated and the irq handler is executed, set a flag that at some other point in time, the irq is delivered to userspace. Like you do with signals in userspace:
void sighandler(int s) {
exit_main_loop_soon = 1;}
something similar could be done in kernelspace without interrupting important devices/irq_handlers sharing the same IRQ.
-`J'
Quoted 5 lines · Jan Engelhardt
For the sharing case, some sort of softirq should be created. That is, when a hard interrupt is generated and the irq handler is executed, set a flag that at some other point in time, the irq is delivered to userspace. Like you do with signals in userspace:
NO.
The whole point is, YOU CANNOT DO THIS.
You need to shut the device up. Otherwise it keeps screaming.
Please, people, don't confuse the issue any further. A hardware driver
ABSOLUTELY POSITIVELY HAS TO
have an in-kernel irq handler that knows how to turn the irq off.
End of story. No ifs, buts, maybes about it.
You cannot have a generic kernel driver that doesn't know about the low-level hardware (not with current hardware - you could make the "shut the f*ck up" a generic thing if you designed hardware properly, but that simply does not exist in general right now).
In short: a user-space device driver has exactly TWO choices:
- don't use interrupts at all, just polling
- have an in-kernel irq handler that at a minimum knows how to test whether the irq came from that device and knows how to shut it up.
This means NOT A GENERIC DRIVER. That simply isn't an option on the table, no matter how much people would like it to be.
Linus
Quoted 12 lines
Quoted 5 lines
For the sharing case, some sort of softirq should be created. That is, when a hard interrupt is generated and the irq handler is executed, set a flag that at some other point in time, the irq is delivered to userspace. Like you do with signals in userspace:
NO.
The whole point is, YOU CANNOT DO THIS.
You need to shut the device up. Otherwise it keeps screaming.
Quoted 7 lines
Please, people, don't confuse the issue any further. A hardware driver
ABSOLUTELY POSITIVELY HAS TO
have an in-kernel irq handler that knows how to turn the irq off.
End of story. No ifs, buts, maybes about it.
I don't get you. The rtc module does something similar (RTC generates interrupts and notifies userspace about it)
irqreturn_t uio_handler(...) {
disable interrupts for this dev;
set a flag that notifies userspace the next best time;
seomstruct->flag |= IRQ_ARRIVED;
return IRQ_HANDLED;
}
/* Userspace->kernel notification, e.g. by means of a device node
/dev/uio or some ioctl. */
int uio_write(...) {
somestruct->flag &= ~IRQ_ARRIVED;
enable interrupts for the device;
}Quoted 5 lines
- have an in-kernel irq handler that at a minimum knows how to test whether the irq came from that device and knows how to shut it up.
This means NOT A GENERIC DRIVER. That simply isn't an option on the table, no matter how much people would like it to be.
-`J'
Quoted 7 lines
irqreturn_t uio_handler(...) { disable interrupts for this dev; set a flag that notifies userspace the next best time; seomstruct->flag |= IRQ_ARRIVED; return IRQ_HANDLED;}
Rather than IRQ_HANDLED, it should have been: remove this irq handler from the irq handlers for irq number N, so that it does not get called again until userspace has acked it.
See, maybe I don't have enough clue yet to exactly figure out why you say it does not work. However, this is how simple people see it 8)
-`J'
Quoted 4 lines · Jan Engelhardt
Rather than
IRQ_HANDLED, it should have been: remove this irq handler from the irq handlers for irq number N, so that it does not get called again until userspace has acked it.
Wrongo.
That just means that the _handler_ won't be called.
But the irq still stays active, and if it's shared, ALL THE OTHER HANDLERS FOR THAT INTERRUPT will be called.
Over and over again. Forever. Because the machine won't be making any progress, and the user-level code (which might know how to shut it up) won't ever be called, because the machine is busy just doing interrupt delivery all the time.
Quoted 2 lines
See, maybe I don't have enough clue yet to exactly figure out why you say it does not work. However, this is how simple people see it 8)
You may be a bit simple. But I think it's more polite to call you "special". Or maybe just not very used to how hardware works.
Btw, this is not something theoretical. We used to have this particular problem _all_ the time with PCMCIA back when we weren't as good at interrupt routing. You'd insert a PCMCIA card, and the machine just hung. Hard.
And the reason was that it would send an irq, but we were expecting it on another interrupt. But if it showed up on something that was shared, you'd have a hung machine, because you'd just have the (say) ethernet driver saying "not for me", and returning. And obviously not able to actually shut it up, so when we returned from the interrupt handler, the interrupt happened immediately again.
So this really isn't theoretical. It's a very common failure schenario for mishandled interrupts. In fact, exactly because it's so common, these days we have all this special logic in the generic interrupt layer that notices, and shuts them up entirely (but does so by disabling _all_ the devices on that interrupt, so when this happens, you might well lose your disk driver or somethign else).
Linus
Quoted 6 lines · Linus Torvalds
Quoted 4 lines · Jan Engelhardt
Rather than
IRQ_HANDLED, it should have been: remove this irq handler from the irq handlers for irq number N, so that it does not get called again until userspace has acked it.
Quoted 10 lines
That just means that the _handler_ won't be called. But the irq still stays active, and if it's shared, ALL THE OTHER HANDLERS FOR THAT INTERRUPT will be called.
[...]
And the reason was that it would send an irq, but we were expecting it on another interrupt. But if it showed up on something that was shared, you'd have a hung machine, because you'd just have the (say) ethernet driver saying "not for me", and returning. And obviously not able to actually shut it up, so when we returned from the interrupt handler, the interrupt happened immediately again.
Thanks for this explanation, I see the point. Removing the uio irq handler will leave the irq chain only with "not for me" devices. In that case, would it make sense to install a replacement uio handler that says "yes, that's mine" [but ignoring it since userspace has not yet finished with it]? (I think I've gotten into a loop since that would be the IRQ_HANDLED case.) Mh, delicate problem.
-`J'
Quoted 3 lines · Jan Engelhardt
I don't get you. The rtc module does something similar (RTC generates interrupts and notifies userspace about it)
The RTC module knows how to shut the interrupt up.
(And in many cases, timers are special. Timers, by design, are often "edge triggered" even in systems that have no other interrupts that work that way. Exactly because a timer is special. So the RTC module often knows that it doesn't need to do anything at all to shut it up, but even that is special per-device knowledge, that is NOT TRUE for any normal devices).
Linus
Quoted 7 lines · Linus Torvalds
Quoted 3 lines · Jan Engelhardt
I don't get you. The rtc module does something similar (RTC generates interrupts and notifies userspace about it)
The RTC module knows how to shut the interrupt up.
The kernel part of the UIO driver also knows how to shut the interrupt up, so where is the difference ?
tglx
Quoted 3 lines · Thomas Gleixner
The kernel part of the UIO driver also knows how to shut the interrupt up, so where is the difference ?
Thomas, you've been discussing some totally different and private Thomas-only thread than everybody else in this thread has been.
The point is NO, THE UIO DRIVER DID NOT KNOW THAT AT ALL. Go and read the post that STARTED this whole thread. Go and read the "example driver".
The example driver was complete crap and drivel.
Linus
Linus,
Quoted 5 lines · Linus Torvalds
Quoted 2 lines
The kernel part of the UIO driver also knows how to shut the interrupt up, so where is the difference ?
Thomas, you've been discussing some totally different and private Thomas-only thread than everybody else in this thread has been.
Yeah, I even looked at different code than others, until they noticed that email before coffee is bad. :)
Quoted 4 lines
The point is NO, THE UIO DRIVER DID NOT KNOW THAT AT ALL. Go and read the post that STARTED this whole thread. Go and read the "example driver".
The example driver was complete crap and drivel.
Sigh, I accept and also Greg has done this before, that the example driver based on the LPT port was not a fortunate choice. It was done to provide some example which is reproducible on COTS hardware.
Real world drivers like the sercos example I provided - and I do it again - are aware of that problem:
/*
* The chip specific portion of the interrupt handler. The framework code
* takes care of userspace notification when we return IRQ_HANDLED */
static irqreturn_t sercos_handler(int irq, void *dev_id, struct pt_regs *reg)
{
/* Check, if this interrupt is originated from the SERCOS chip */
if (!(sercos_read(IRQ_STATUS) & SERCOS_INTERRUPT_MASK))
return IRQ_NONE;---------^ Makes it safe for IRQ sharing
/* Acknowledge the chip interrupts */
sercos_write(IRQ_ACK1, SERCOS_INTERRUPT_ACK1);
sercos_write(IRQ_ACK2, SERCOS_INTERRUPT_ACK2);----------^
Actually prevents the box is dead scenario, as it disables the
interrupt from that device until it is reenabled from the user space driver code. This covers also the case where the user space driver dies, as the kernel still has the portion of code to shut this thing up for ever.
return IRQ_HANDLED; }
The concept requires, that
- the interrupt handling is in the kernel _AND_ open source
- the mapping of the device is done via the kernel controlled mapping function rather than by poking in the PCI regs
I really regret that I ever came up with this LPT example, but cutting the whole discussion down to that ugly example driver does not get us anywhere.
tglx
Quoted 5 lines · Benjamin Herrenschmidt
Actually, you can... but wether you want is a different story :-)
You can simply mask it, have it handled by userspace and re-enable it when that's done.
Nope. Again, this whole mentality is WRONG.
It DOES NOT WORK. No architecture does per-device interrupts portably, which means that you'll always see sharing.
And once you see sharing, you have small "details" like the harddisk interrupt or network interrupt that the user-land driver will depend on.
Oops. Instant deadlock.
Quoted 2 lines
I don't mean I -like- the approach... I just say it can be made to sort-of work. But I don't see the point.
No. The point really is that it fundamentally _cannot_ work. Not in the real world.
It can only work in some alternate reality where you can always disable interrupts per-device, and even in that alternate reality it would be wrong to use that quoted interrupt handler: not only do you need to disable the irq, you need to have an "acknowledge" phase too
So you'd actually have to fix things _architecturally_, not just add some code to the irq handler.
Linus
Quoted 11 lines
No. The point really is that it fundamentally _cannot_ work. Not in the real world.
It can only work in some alternate reality where you can always disable interrupts per-device, and even in that alternate reality it would be wrong to use that quoted interrupt handler: not only do you need to disable the irq, you need to have an "acknowledge" phase too
So you'd actually have to fix things _architecturally_, not just add some code to the irq handler.
Oh, it works well enough for non shared iqs if you are really anal about it, but I agree that it sucks and I don't see the point of having it in linux. The flow has to be different for level vs. edge and it's really ugly but it works. I've seen people doing it in embedded space. But again, I do agree it sucks big time :-)
the edge flow is easy. the level one is:
- IRQ happens
- kernel handler masks it and queue a msg for userland
- later on, userland gets the message, talks to the device, (MMAP'ed mmio, acks the interrupt on the device itself) and does an ioctl/syscall/write/whatever to tell kernel it's done
- kernel unmasks it.
But yeah, I hate it too, so let's not waste time talking about how to make it work :-)
Ben.
Quoted 8 lines · Benjamin Herrenschmidt
the edge flow is easy. the level one is:
- IRQ happens
- kernel handler masks it and queue a msg for userland
- later on, userland gets the message, talks to the device, (MMAP'ed mmio, acks the interrupt on the device itself) and does an ioctl/syscall/write/whatever to tell kernel it's done
- kernel unmasks it.
That's simply not true.
- IRQ happens
- kernel handler runs and masks the chip irq, which removes the IRQ request
- user space message get queued or waiting reader woken
- kernel handler returns IRQ_HANDLED, which reenables the irq in the PIC
- user space handles the device
- user space reenables the device irq
No need for an ioctl. Neither for edge nor for level irqs.
tglx
Quoted 20 lines · Thomas Gleixner
Quoted 8 lines · Benjamin Herrenschmidt
the edge flow is easy. the level one is:
- IRQ happens
- kernel handler masks it and queue a msg for userland
- later on, userland gets the message, talks to the device, (MMAP'ed mmio, acks the interrupt on the device itself) and does an ioctl/syscall/write/whatever to tell kernel it's done
- kernel unmasks it.That's simply not true.
- IRQ happens
- kernel handler runs and masks the chip irq, which removes the IRQ request
- user space message get queued or waiting reader woken
- kernel handler returnsIRQ_HANDLED, which reenables the irq in the PIC
- user space handles the device
- user space reenables the device irq
Quoted 1 line
No need for an ioctl. Neither for edge nor for level irqs.
Wait wait wait... your scenario implies that the kernel has knowledge of the chip to mask the irq in the chip in the first place.
If that is the case, then you have a chip specific kernel driver, yadada, the whole story is moot :-)
We were talking about the idea of having some "generic" reflector of irqs to userspace without device specific knowledge.
Ben.
Quoted 10 lines · Benjamin Herrenschmidt
Quoted 1 line
No need for an ioctl. Neither for edge nor for level irqs.
Wait wait wait... your scenario implies that the kernel has knowledge of the chip to mask the irq in the chip in the first place.
If that is the case, then you have a chip specific kernel driver, yadada, the whole story is moot :-)
We were talking about the idea of having some "generic" reflector of irqs to userspace without device specific knowledge.
Which simply is not possible, especially for shared irqs.
Can you please elaborate why this effort is moot, instead of throwing the usual flamewar arguments around ?
The concept of UIO divides the problem in two spaces:
- kernel interface, which controls interrupts and mapping
- user space restricted interface
I don't see why the necessarity of a kernel stub driver is a killer argument. The chip internals, which companies might want to protect are certainly not in the interrupt registers.
Aside of that there are huge performance gains for certain application / driver scenarios and I really don't see an advantage that people are doing excactly the same thing in out of tree hackeries with a lot of inconsistent user land interfaces.
tglx
Quoted 4 lines · Thomas Gleixner
Aside of that there are huge performance gains for certain application / driver scenarios and I really don't see an advantage that people are doing excactly the same thing in out of tree hackeries with a lot of inconsistent user land interfaces.
Greg's effort is noble but I think it is targeted at the wrong problem and would actually make things worse. Inconsistent interfaces from one "driver" to another are the surface design flaw that obscures the fundamental design flaw of exposing hardware to userland: abdication of the driver writer's responsibility to choose and justify which things belong in the driver and which belong in a hardware-agnostic driver framework or a userspace library instead.
When you are talking about unique, one-off hardware, it doesn't really matter whether the shim for a closed, out-of-tree, userspace driver fits into a framework or not. Who cares whether they use the preferred MMIO reservation paths or just throw ioctl(POKE_ME_HARDER) or mmap(/dev/mem) at the problem? But I don't want to see ALSA or iwconfig or i2c-core or any of the other competently designed and implemented driver frameworks mangled into unusability by attempts to facilitate this "design pattern".
Truth in advertising is an advantage even if it doesn't change the underlying reality. I can (and do) tell chip vendors, "that's not a driver, that's a shim for some other customer's pre-existing eCos task", and justify the cost of writing an actual driver to the client. I may or may not succeed in arguing that the new driver should be designed to an existing API when that means rethinking the userspace app, or that it should be implemented against a current kernel and offered promptly up to the appropriate Linus lieutenant. But at least the project isn't crippled by confusion about whether or not the existing blob constitutes a driver.
Cheers,
- Michael
Quoted 3 lines
I don't see why the necessarity of a kernel stub driver is a killer argument. The chip internals, which companies might want to protect are certainly not in the interrupt registers.
So they can go off and write themselves a driver. Without putting junk in the kernel "just in case", and if the driver and the user space code using it are closely interdependant I'd suggest they look up the *legal* definition of derivative work.
Quoted 3 lines · On Wed, 13 Dec 2006 23:30:55 +0100 Thomas Gleixner <[email protected]> wrote:
- IRQ happens
- kernel handler runs and masks the chip irq, which removes the IRQ request
IRQ is shared with the disk driver, box dead. Plus if this is like the uio crap in -mm its full of security holes.
Quoted 9 lines · Alan
Quoted 3 lines · On Wed, 13 Dec 2006 23:30:55 +0100 Thomas Gleixner <[email protected]> wrote:
- IRQ happens
- kernel handler runs and masks the chip irq, which removes the IRQ requestIRQ is shared with the disk driver, box dead. Plus if this is like the uio crap in -mm its full of security holes.
All of those security holes should now be taken care of, as all of the nasty memory stuff has been either cleaned up or ripped out.
Please take a look at the most recent stuff (thomas just mentioned to me on irc that he has a few more minor fixes for it) and let me know if you still see any problems.
thanks,
greg k-h
Quoted 8 lines · Alan
Quoted 3 lines · On Wed, 13 Dec 2006 23:30:55 +0100 Thomas Gleixner <[email protected]> wrote:
- IRQ happens
- kernel handler runs and masks the chip irq, which removes the IRQ requestIRQ is shared with the disk driver, box dead.
Err ?
IRQ happens
IRQ is disabled by the generic handling code
Handler is invoked and checks, whether the irq is from the device or not.
- If not, it returns IRQ_NONE, so the next driver (e.g. disk) is
invoked.
- If yes, it masks the chip on the device, which disables the chip
interrupt line and returns IRQ_HANDLED.
In both cases the IRQ gets reenabled from the generic irq handling code on return, so why is the box dead ?
tglx
Quoted 15 lines
Quoted 1 line
IRQ is shared with the disk driver, box dead.
Err ?
IRQ happens
IRQ is disabled by the generic handling code
Handler is invoked and checks, whether the irq is from the device or not.
- If not, it returnsIRQ_NONE, so the next driver (e.g. disk) is
invoked.
- If yes, it masks the chip on the device, which disables the chip
interrupt line and returnsIRQ_HANDLED.
Quoted 2 lines
In both cases the IRQ gets reenabled from the generic irq handling code on return, so why is the box dead ?
I wrote this before your "generic" layer was in fact explained further to not be generic at all and involve a new driver for each device. Your original explanation was not clear.
Alan
Quoted 1 line · Benjamin Herrenschmidt
Oh, it works well enough for non shared iqs if you are really anal about
It works well for shared irqs. Thats the whole reason why you need an in kernel part.
tglx
Quoted 5 lines · Thomas Gleixner
Quoted 1 line · Benjamin Herrenschmidt
Oh, it works well enough for non shared iqs if you are really anal about
It works well for shared irqs. Thats the whole reason why you need an in kernel part.
As soon as you have an in-kernel part that is chip specific, yes, of course it works, because essentially, what you have done is a kernel driver for your chip and the whole discussion is moot :-) And I agree, that's the right thing to do btw.
Ben.
Quoted 11 lines · Benjamin Herrenschmidt
Quoted 5 lines · Thomas Gleixner
Quoted 1 line · Benjamin Herrenschmidt
Oh, it works well enough for non shared iqs if you are really anal about
It works well for shared irqs. Thats the whole reason why you need an in kernel part.
As soon as you have an in-kernel part that is chip specific, yes, of course it works, because essentially, what you have done is a kernel driver for your chip and the whole discussion is moot :-) And I agree, that's the right thing to do btw.
Still the framework has a benefit, as it removes the bunch of incompatible out of tree attempts to achieve the same result.
tglx