Linux is literally implementing kernel level DRM, the thing free software swore to destroy.
Or at least the requirement that proprietary drivers do not interact with GPL-only code would in my opinion be considered an EULA.
You are correct that this is kernel level DRM[0], and Linus might even have a legal claim against Nvidia for circumvention of copy protection here. GPLv3 explicitly disclaims any form of copy protection in covered code, which would at least theoretically prevent this kind of lawsuit, except the clause isn't court-tested and Linus specifically hates GPLv3 for adding the TiVo clause[1].
This was implemented decades ago, and the original goal was actually just to stop getting bug reports relating to crashes in the Linux kernel caused by proprietary modules they can't fix. Enforcing the GPL was a side benefit.
[0] Not to be confused with the other DRM in the kernel, the Direct Rendering Manager.
[1] He doesn't hate the TiVo clause itself, he just doesn't like retroactively adding it to v2 software and changing the deal, because he doesn't like what he feels is Linux being co-opted by the FSF.
Did Linus really sought to have every contributor of Linux that licensed their contribution as GPLv2 agree to this specific exception, and relicense it as GPLv2 plus syscall exception? This sounds unbelievable.
When one checks the wording of the "exception", https://github.com/torvalds/linux/blob/master/LICENSES/excep... it says
> NOTE! This copyright does not cover user programs that use kernel services by normal system calls - this is merely considered normal use of the kernel, and does not fall under the heading of "derived work".
This just seems like a legal opinion of Linus that states that userland programs are not derivative from the kernel (and thus don't need to be licensed as GPLv2 themselves), but this is kind of obvious and expected, right? I mean, userland Windows programs aren't derivative from the Windows kernel either, or macOS programs from XNU, or etc.
Also note that at the moment Linux was created, all Linux programs were originally made for other operating systems. Programs like bash and gcc predate Linux. They couldn't be derivative works of the kernel, even if they wanted to, because the kernel didn't exist when they were created.
I highly doubt that any kernel developer could successfully sue authors of userland programs for copyright infringement, regardless of what Linus thinks about it. So this isn't really an exception of the GPLv2 but just a _clarification_ that the wording of the GPLv2 shouldn't be interpreted in a way to make userland programs infringing (because they aren't, and wouldn't be even if Linus didn't clarify)
This means that Linux is free to incorporate any GPLv2 code it wishes without asking people to relicense it as "GPLv2 plus syscall exception" because Linux itself is just GPLv2.
> Also note that at the moment Linux was created, all Linux programs were originally made for other operating systems. Programs like bash and gcc predate Linux. They couldn't be derivative works of the kernel, even if they wanted to, because the kernel didn't exist when they were created.
That might be true for those applications. However, not having the syscall exception would make Linux-specific syscalls such as IO_uring accessible to GPL software only.
> I highly doubt that any kernel developer could successfully sue authors of userland programs for copyright infringement, regardless of what Linus thinks about it.
That would be the intent of the GPL, which is designed to extend its effects to every other software the original work is "linked" with. Remember, the GPL has been tested in Court before.
It's not there in 0.99.9.
I'm not so sure, at least in the US. There were several cases in the '80s and 90s or thereabouts involving video game cartridges which might be relevant.
The consoles back then did not have memory protection or multiple address spaces or user/system modes. The ROM in the cartridge simple appeared at a fixed place in the address space, and typically the firmware in the console would do some system initializing, then call an entry point in the cartridge.
The code in the cartridge had full access to the hardware and to the firmware in the console.
The console manufacturers wanted to control the cartridge market. Among the many ways they tried to keep third parties from making compatible cartridges was copyright. The firmware in the console was copyrighted by the console manufacturer, and the code in the cartridge (in most cases [1]) extensively called into that firmware.
Since the third parties had figured out the firmware by reverse engineering (usually in violation of the console's license) in many cases they even called into firmware code that authorized games did not use because that was not part of the firmware's API.
My recollection is that the third parties won in most of those cases.
[1] I believe that there were some third party games where the game maker had not been able to figure out how the firmware worked but they did know how the hardware worked, and so they made their cartridges completely take over. The console firmware was effectively just a boot loader for them.
Proprietary drivers can interact with the Linux kernel.
Provided they only use fairly generic OS-functions, which are to be found in many similar kernels. Such drivers, which do not rely on Linux-specific functions, cannot be considered "derived works" of the Linux kernel, and are therefore free to choose whatever license they like.
However, any driver which makes use of Linux-kernel-specific interfaces, which are not found in other OSs (even in other Unix-like kernels) are, pretty much by definition, a "work based on the program" of the kernel and therefore must be licensed similarly. See the text of the GPL-2, which the kernel is licensed under:
https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
> This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law:
> These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.
Note that the LGPL exists specifically to allow the linking of separate Free and proprietary software, which is forbidden by the GPL. But Linux is licensed under the GPL-2, so those extra permissions do not apply.
If the Nvidia driver stuck to the generic kernel API, it would be fine. But it doesn't. It tries to use Linux-only APIs, which are marked for use by license-compatible GPLd drivers, without itself being GPLd.
This is a clear violation of the Free Software license that Linux is made available under.
I don't see why. The "Linux-only APIs" are a feature imposed by the Linux kernel developers, not by the GPL. Trying to circumvent it is of course contrary to the wishes of the Linux kernel developers, but that doesn't mean it's a violation of the GPL. The GPL does not say that no program that interfaces with a GPL-licensed work can do anything the authors of the GPL-licensed work don't like.
It would be a violation of the GPL if NVidia tried to ship its own Linux distro including its proprietary drivers. But it's not doing that. NVidia doesn't ship Linux at all. Linux users install NVidia's drivers alongside the Linux that they install.
This is your opinion.
My opinion is that it is a clear violation of the GPL if a program provides two sets of interfaces, one set to be used by other GPL programs and one set with crippled performance for non-GPL programs.
This is a restriction on use that has nothing to do with GPL, which says: "This License explicitly affirms your unlimited permission to run the unmodified Program.".
Crippling the performance for the users who choose to use the GPL program together with a non-GPL program is definitely incompatible with "unlimited permission to run".
Whoever has written the original GPL program has no right to impose limits on the users of the program. If they want to impose limits, they must choose a different license, not GPL.
The restrictions imposed by GPL are based on copyright, i.e. they refer to transferring copies of the covered work, but not to how it should be used.
The GPL does not prevent users from running the Linux kernel in any manner they choose.
What it does disallow is for users to write code which is "based on" Linux code, and then distribute that code to other users on terms which are incompatible with the GPL.
You can run whatever mix of GPLd and non-GPLd code you want. You can even edit your Linux sources in a way that removes the GPL license checks for modules and build your own kernel, and run it, and no-one can legally stop you - not even Linus himself.
But you're not allowed to distribute work-based-on-GPLd-code-that-isn't-licensed-under-the-GPL to anyone else. And neither is Nvidia.
Unfortunately, suing Nvidia over this would cost millions, if not tens of millions, if not hundreds of millions, of dollars. So creating a technological barrier to fuck with them and their bullshit business model instead is a much more achievable goal.
If this theory would be accepted almost all the existing programs that have been written since the first electronic computers would be derivative works and no software companies would have ever existed, because they could never have claimed copyright protection.
NVIDIA has never distributed any derivative of the Linux kernel in their GPU drivers. They distribute their own kernel modules, which are loaded by the end user and this is perfectly compatible with the GPL.
Some kernel developers try to cripple the NVIDIA modules by preventing them to find the symbol addresses that must be used, but this is a use restriction imposed by these developers on the Linux users and which has nothing to do with what is written in the GPL.
If that were the case, the LGPL would never have been needed.
Even with its illogical theory about the coverage of "combined" works, not even the GPL covers the programs that use an interface provided by a GPL program, but which are distributed only separately from it, like a shared library or a kernel module.
So the NVIDIA kernel modules have never been incompatible with the GPL.
The fight against non-GPL kernel modules has nothing to do with the GPL, but it is strictly the creation of certain kernel developers.
With dynamic linking you never distribute someone else's code so you don't need a license to distribute it.
How so? It says "run the unmodified Program". The checks the Linux kernel does are part of the unmodified program. If that unmodified program doesn't meet a particular user's needs, they can go find some other program. The GPL does not impose any requirement that the unmodified Program must meet all of the needs of all users. Nor does it impose any requirement that the unmodified Program must treat all other programs equally. Nor does it impose any requirement that the unmodified Program cannot have any restrictions on use that are not explicitly imposed by the GPL.
> Provided they only use fairly generic OS-functions, which are to be found in many similar kernels. Such drivers, which do not rely on Linux-specific functions, cannot be considered "derived works" of the Linux kernel, and are therefore free to choose whatever license they like.
> However, any driver which makes use of Linux-kernel-specific interfaces, which are not found in other OSs (even in other Unix-like kernels) are, pretty much by definition, a "work based on the program" of the kernel and therefore must be licensed similarly.
Now given that, can you explain why the "save the FPU state" function is marked as one of those special interfaces?
The marking on symbols cannot be trusted.
GPLv2 defines a "work based on the program" thusly: "a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language"
To be a derivative work of another work under US copyright law the work must contain sufficient copyrightable elements copied from that other work to require permission from the owner of that other work's copyright owner.
If all you've copied is a few function names and data structure layouts in order to call those functions that seems unlikely to be enough to make your work a derivative work. It doesn't really matter whether or not those functions do things found in many other works or just one, because you aren't copying the functions themselves.
> Note that the LGPL exists specifically to allow the linking of separate Free and proprietary software, which is forbidden by the GPL.
Linking GPL and proprietary software together is not forbidden by the GPL. If you do so though GPL imposes requirements on you if you distribute the result, and those requirements will likely be impossible to meet.
If you are just linking the GPL and proprietary software for you own use GPL does not care.
or the reverse, if getting rid of non-free modules is the goal, why even have a syscall exception? why not force all modules to be GPL?
I think this question illustrates something of an invisible generation gap in software. GPL is not a utilitarian license. There is no materialistic value in choosing to use the GPL whatsoever. The text of the GPL is itself a legal edifice specifically designed to dismember the very framework in which it exists, rendering it anti-utilitarian.
This is all to say that the GPL is politics. One chooses the GPL specifically for political reasons. In politics, you do not go out of your way to aid your ideological adversaries; you either convert them or destroy them.
> if getting rid of non-free modules is the goal, why even have a syscall exception? why not force all modules to be GPL?
Despite what I just said about GPL as ideology, the GPL is simultaneously a legal construct which necessarily must bend to the rules of the framework it exists within. The logic of GPL extending through syscalls is based in a legal argument similar to that used in the Google vs. Oracle debacle -- we created the "shape" of this API, so we have certain rights regarding it. The "shape" of the Unix syscalls predate Linux and are therefore beyond the project's reach, legally speaking.
Now consider that there is a similar organization: a not-for-profit organization of programmers for which the only qualification for entry is that you agree to use the same license as everybody else. Once you do, you are free to use all the IP of the organization. You may not, however, use the IP of the organization for things you might do under different licenses, since that is not considered to be within the scope of the organization.
In short: if you don't want to join the GPL "organization", don't. But just as you don't expect to get access to Nvidia's internal IP unless you join Nvidia, don't expect to get access to the GPL organization's IP.
That is, yes, you're allowed to port non-GPL code to Linux.
On the other hand: the real practical concern that kernel developers have is needing to debug NVidia's closed source code, or people developing an expectation that such code (or the code of a hundred other vendors) won't be broken between kernel releases.
Except for the fact that the CPU is in privileged mode, there is no difference between loading a kernel module and launching a dynamically-linked user-mode executable file.
Not all non-GPL modules or executables are non-free. Many have licenses that are more permissive than GPL, e.g. BSD or MIT, but they are still affected by these anti-non-GPL measures.
If non-GPL kernel modules were not permitted, then by the same reasoning no non-GPL executable files should be permitted, so in such Linux computers absolutely all programs, libraries and modules would have to be GPL.
Perhaps there are people who dream to use such a computer. I have been using Linux for decades and I have never seen a single computer that would have remained useful for anything after the instant when all the non-GPL programs would have been deleted from it.
I have been using Linux for decades and I have never seen a single computer that would have remained useful for anything after the instant when all the non-GPL programs would have been deleted from it.
if that includes any non-GPL FOSS, sure, but most such software would have switched to GPL very quickly if that would have been the case.
Isn't that reason enough?
> why even have a syscall exception?
Because Linus is more pragmatic than RMS.
Also, syscalls are generally not Linux-specific, so it would be hard to argue that programs that use them are "works based on" Linux. Making the syscall exception explicit is, IMO, mostly a historic reassurance for proprietary driver/program vendors that code they wrote for AIX/Solaris/HP-UX/etc... can be recompiled for Linux without risking any compliance issues.
he probably is, but that is not the reason here. even RMS fully agrees that using it in the normal USING fashion does not trigger copyleft. This is why you can compile proprietary software with gcc, and similarly, when gcc had a java class library project, it was GPL+classpath exception
Does that follow? If someone makes a program that uses an API that's only found in NT or XNU, does that program become a derivative work of those kernels?
Which in the case of proprietary hardware, using non-standard interfaces, would mean that software would need a license from the manufacturer to be distributed.
Free software enforcing its own principles is in no contradiction of free software. Why should proprietary software be able to get all the benefits of free software and play by none of its rules and free software is supposed to just take it?
Even democratic societies have mechanisms to protect themselves that are restrictions of some kind on expression.
There are plenty of proprietary OSes out there that give zero shits. Why there can't be some that do? Or does everything need to be just cold, industry serving tool without any human care behind it?
Because the kernel is licensed under GPL, that's kind of the whole point of Linux. The intention of the license is that anything linked and loaded into the kernel is released under a compatible copyleft license.
Personally, I'm not persuaded that a loadable proprietary kernel module would constitute a derivative work, I don't see how the GPL could be enforced on a 3rd party like that. I think the courts and juries would be very sympathetic to Nvidia.
All Linux would need is for one court in one relevant jurisdiction to interpret GPL like they do. If a French court forces Nvidia to stop making selling data centre products in France, that'd be enough to seriously hurt Nvidias's bottom line. Maybe the Texas it Hamburg courts will side with Nvidia, but Nvidia needs to win everywhere and Linux only needs to win once.
However the Linux devs are still allowed to do whatever they want to make it harder on NVIDIA. Also I assume the distros count as redistributors so they probably can't combine NVIDIA and GPL parts of the kernel.
Currently Nvidia creates a proprietary driver that is not specific to linux, thus is not a derivative work. Then, they create a 'shim' layer that links their driver into the kernel. While the shim is a derivative work, the driver is not, thus copy-left doesn't apply to the driver.
I think many/most would consider the ability to write loadable kernel modules an "API". Google v Oracle decided in the US Supreme court that APIs are not copyrightable. From [1]:
> Supreme Court ruled in a 6–2 decision that Google's use of the Java APIs fell within the four factors of fair use, bypassing the question on the copyrightability of the APIs.
IMO, Nvidia doesn't even need a shim layer, they're just playing nice. If push comes to shove, I think Nvidia will win in court.
1: https://en.wikipedia.org/wiki/Google_LLC_v._Oracle_America,_....
This is not true. The appeals court ruled that the API was copyrightable, and the Supreme Court opted not to rule on whether or not APIs are copyrightable.
What the Supreme Court actually ruled on is that in this specific instance, Google's use of the API would qualify as fair use - and thus it didn't matter if the API is copyrightable or not.
Anyway, Google re-implemented the Java API in many areas, not just wrote code to interact with it. Either way, I think a loadable module would fall under similar treatment.
> the requirement that proprietary drivers do not interact with GPL-only code would in my opinion be considered an EULA.
The requirement that proprietary code does not ""incorporate"" GPL code is the GPL, and the entire point of it. However, it might be reasonable to argue to what extent merely linking against an API is infringing. I can see that going in either direction, and such a ruling would have a big impact on GPL either way.
But I may have misunderstood/misremembered the details. It's been years since I cared enough to do a deep dive on this.
Whether functional elements needed for interoperability are not covered by copyright (so that a work that seems “derived” through its use of them is not a “derivative work” at all) or whether using them is Fair Use (such that while a work using them might be a derivative work that would, but for Fair Use, require a license, it is nonetheless legal without a license due to Fair Use) seems to be a bit of a mixed bag, but either way using copyright to prevent functional interaction (except when you get into DMCA coverage of technical anti-circumvention measures, which is also part of copyright law, but not really applicable here) seems to be a difficult battle for copyright holders, in US law, at least.
heh, I wonder if you could argue that the catalog of functions/methods/symbols is a database and should thus be copyrightable under EU law.
it would obviously be hugely destructive if upheld, but, I think "database right" is fairly incoherent as a concept anyway, other than as an attempt to uphold "sweat of the brow doctrine" (ie "anything I worked to make should be mine by law"), which is already discredited in US law.
The GPL itself is just an idea. I can download GNU emacs, strip out any reference to freedom, and distribute that to others under my own proprietary license. I would be violating the license, obviously, and a court could prevent me from doing so, but nothing in Emacs itself would.