Re: [gentoo-user] Re: [WAS: keyboard stops working] Recent kernels block the loading of non-GPL kernel modules

[Jeremi Piotrowski]

On Wed, 19 Aug 2015, Rich Freeman wrote:

> On Wed, Aug 19, 2015 at 8:31 AM, Jeremi Piotrowski
> <jeremi.piotrowski@×××××.com> wrote:
> > On Wed, 19 Aug 2015, Rich Freeman wrote:
> >
> >> It sounds like you not only expect them to comply with the license,
> >> but also with the kernel devs personal interpretation of copyright
> >> law.
> >
> > What is a license but a statement of the intent of the authors as to what
> > can and can't be done with their work? Well, it does have some legal force
> > too...
>
> The only reason that licenses matter at all is that they have legal
> force.  They only matter to the degree that they do.

This discussion has been going on ever since the kernel was first
conceived, and some matters are still not entirely clear. I have tried
reading about the subject and the discussion is always the same as the one
we're having in this thread.

What I consider a final word on the matter is pretty much written here:

https://lwn.net/Articles/154602/

briefly: the kernel devs *have* consulted lawyers and believe EXPORT_SYMBOL_GPL 
has *some* legal meaning.

But I am not a lawyer, nor do I want to be so let's tune down the law
stuff and get back to technical issues.

> > If you'd try to take away their right to decide about that next thing
> > they'd do is modify the license to be even larger and explicitly cover all
> > corner cases.
>
> And that would accomplish nothing, since companies would just ignore
> any text which doesn't have a basis in law.

They could, but I was under the impression that by using licensed software
you agree to follow it's terms. And the binding nature of licenses is
codified in copyright law.

> The problem is that Linus's words mean nothing unless they're based in
> law.  You don't need to quote Linus.  You need to quote laws, court
> decisions, or treaties.

Copyright law talks of licenses. Linus' talks about the license under
which the kernel is licensed. Ergo, seems to me as though his words
should have some authority, but I won't argue that.

> And none of them say a word about linking creating a derived work.

The FSF says that and who knows if they're actually right, but I believe
so far everyone generally complies with their interpretation.

> And would we really want to live in a world where they did?  Do you
> really want to need permission to use a product in a manner the author
> didn't originally intend?

Proprietary licenses already say that I can't do that, and it's the free
licenses that tell me I can do whatever I want as long as I release the
sources. Sounds reasonable to me.

But again, I'm speaking mostly out of common sense and opinion here.
Neither one of us is going to go around citing cases and laws as that
would be a waste of bandwidth.

>
> Why not just write API wrappers?  If somebody exposes an API called
> do_this() using EXPORT_SYMBOL_GPL just write a module that is licensed
> GPL, exposes an API called do_this_nonGPL() using EXPORT_SYMBOL, and
> have do_this_nonGPL() just pass through a call to do_this().

From what I gather online, this is actually what Nvidia does (or did).
They have an LGPL wrapper in their module, which interfaces with the
kernel, and then talks to their proprietary blob. This [1] stackoverflow
answer has a nice picture:

    /------------.-\
    | Kernel       |
    |              |
    |   /--------\ |
    |   | Module | |     /-------------------\
    |   | (LGPL) <========> proprietary code |
    |   \--------/ |     \-------------------/
    \--------------/

[1]: http://stackoverflow.com/a/2721696

So they already go out of their way to comply with the terms of the kernel
license. But they also need to deal with the breakage on each update.


> All they have to do is have the human-readable license say non-GPL,
> and have it report GPL to the kernel, and not ship the source.  The
> only recourse anybody has is to sue them, and it is doubtful that a
> court is going to force them to comply, as they clearly indicated
> their intent to not release the code as GPL.

On the other hand they would also be clearly indicating to others that
their code is GPL (if they did in fact add MODULE_LICENSE("GPL")). I may
be wrong here, but if that is not in the least bit ambiguous then shoot me.


> Also, you stated that the check is implemented in the build system.  I
> don't know if that is true, but if it is, then the module can simply
> be built using a patched build system.  I suspect the check is really
> in the module loader, which the module builder would not have control
> over.

Some reasearch tells me that this checking is implemented in both the build
system (consider it a warning) and in the module loader. 

To me it seems like it is not hard to bypass, but it would be *atleast*
indecent.