Linux 6.6 To Better Protect Against The Illicit Behavior Of NVIDIA's Proprietary Driver

[oiaohm]

Its not updated any more, (my whole point btw, since it destroys yours that its unstable and shouldn't be used) its still maintained within the confines of the kernel version it was support in

and still exports
the
EXPORT_SYMBOL_GPL(ktime_get_raw_fast_ns)

https://github.com/torvalds/linux/blob/92901222f83d988617aee37680cb29e1a743b5e4/kernel/time/timekeeping.c#L506

with
EXPORT_SYMBOL(dtrace_gethrtime);

https://github.com/oracle/dtrace-linux-kernel/blame/e17855d3134827df98a6a05e0ad84542e60e2c57/kernel/dtrace/dtrace_os.c#L284-L288

for use in the closed source DTrace.

Nothing like being wrong.

https://github.com/oracle/dtrace-utils/blob/dev/LICENSE

The Universal Permissive License (UPL), Version 1.0 that a GPLv2 compatible license.
Dtrace 2.0 is not closed source the user-space is all UPL with all kernel space additions being GPLv2.

Dtrace 1.0 binary does not work with Dtrace 2.0 kernels. Dtrace 2.0 does work with Dtrace 1.0 kernels.

Oracle with Dtrace fixed up the copyright issue in 2019. But they are still going to be bitten in future with stability things.

So current DTrace 2.0 is not closed source. Oracle has been working with upstream to remove their third party usage of EXPORT_SYMBOL_GPL by up-streaming different features into mainline Linux kernel. Every time Oracle has been able to get rid of a EXPORT_SYMBOL_GPL usage for non mainline code they have improve the stability when applying Linux mainline security updates to the kernels.

confines of the kernel version it was support in

True you get away with it there. But when you update the kernel you don't get away with it. People want to have their distribution kernels security updates. This applies to Nvidia just as much as Oracle here that you have breakage by using EXPORT_SYMBOL_GPL.

EXPORT_SYMBOL(dtrace_gethrtime) one scroll to top of page and notice license change in 2019 to GPLv2. Then go to the dtrace utils link and see for yourself the other license.

Oracle has moved Dtrace 2.0 to fully Linux compatible licenses.

[Khrundel]

No you are wrong 0.99 is not the first GPL linux.

https://mirrors.edge.kernel.org/pub/linux/kernel/Historic/v0.99/linux-0.99.11.tar.gz

This is the first Linux to contain the GPL and it also contains the clause. Yes the COPYING in the 0.99.11 is the same as Linux-2.6.12-rc2 nothing changed over that time frame.

So, you prefer outright lie to proof your point?

https://github.com/VARoDeK/linux_v0.01_to_v0.99.9/blob/linux-0.99.10/linux/COPYING

What do I see? GPL2 without any ammends. And you know how I've found it? .11 release looks suspicious so I just subtracted 1 and checked. So, you've found 0.99, it didn't contain any exception, then you've started to search, found the first revision which had this clarification and declared it first to be GPLed.

What you find as the license of 0.99 that you can also get from kernel.org is.

That right a fun way of writing yet to be decided with "linux copyright" being used as placeholder. The debate on what the Linux copyright would be happened in the 0.1-0.99 time frame. GPL without the clause on the Linux kernel is pre the Linux kernel being decided to be GPL so in the place holder license time frame.

OMG. Have you ever heard about "public offer"? Public offer is a legally binding contract. Publicising a source code with license agreement mean releasing this source under this license. Assuming otherwise mean Linus can say tomorrow "You know, all these years it was placeholder. I decided not to release my code under GPL, here is real license, so, please, give me all the money of the world.

There is a time frame before the place holder as well'
Where it just all copyright Linus Torvalds.

And that was a legally binding contract too. You can take 0.1 linux and use it according the terms of previous license.
You can name several software product which was a commercial for some time and then was re-released under GPL terms, so why Linus couldn't do the same? GNU licenses are rare licenses which include a term requiring relicensing any derived work under same terms.

The first GPL containing Linux kernel is 0.99.11. Basically Khrundel stop attempting to rewrite history. Linux kernel GPL has always had the syscall note exception.

Well, it is disarming impudence. You are accusing me of rewriting history few lines after you've written I should ignore same license file before an exception was added. No wonder, though. No honest person would dare to say all these BS is not just attempt to force nvidia to stop linux support. A-holes, whose name you trying to protect do not even try to hide their motives. These guys had tried to do this directly, Linus vetoed that attempt, so they are trying to achieve same gradually. I bet they've singled out nvidia just because it is most high-profile figure, after that precedent nobody would care about banishing of smaller producers. Then there will be Valve: they are selling steamdeck with preinstalled commercial software (steam). And after there will be FSF paradise, where will be a bubble with no privately owned software allowed. Would I be CEO of Microsoft, I would pay these guys, they are doing everything to make linux users' life miserable and to make linux look as a dangerous place.

The Linux kernel has had 4 different licenses.
1) Linus Torvalds only the earliest versions
2) Time frame of the "Linux copyright"
3) GPLv2 with syscall note/exception for user space program all in 1 file.
4) The recent split up version but it still GPLv2 with syscall note/exception.
There is no time frame that the Linux kernel is a pure GPL work.

You've lied again. There was a period of GPL2 without exceptions and you know it. But, this doesn't matter actually. Lets imagine we live in the universe where versions 0.99-0.99.10 never existed. Just look at transfer between 3 and 4. According to GPL2 you can't change terms in any derived work (new versions are derived works too). Even if you pretend this was some clarification, any "clarification" within an accepted contract remove some gray zones so litterally changing terms of contract. Like imagine a bank which would "clarify" something within already signed contract with you without your permission. That is nonsense. And GPL2 forbids this. So, either any version after 4 are illegal, because they violate clause about relicensing under same conditions legally revoking permission to create derived works given by all previous contributors, or this "exception" wasn't part of license all the time. And that was indirectly confirmed when text about exception was moved out of license file.
You can clarify clarification, you can't "clarify" a contract itself, assuming "clarification" becomes a part of contract.

Warning base copyright law has no concept of dynamic library or kernel modules or programs. Yes calling a function that in a dynamic library might make your program a derived work of that dynamic library.

Sure, but there is a concept of fair use, and every sapient man understands that communication via an interface is a fair use. Only FSF zealots pretend this is not obvious, when comes to GPL software. Their moto is "fight fire with fire": when it comes to GPL that morons try to implement any horror stories about copyright known to them. The only thing which allow them to pretend there is some gray zone here is that there no precedent meaning no moron ever dared to go to court with such absurd claim.

No read the second sentence in the quote. GPL2 usage of derivative work means not everything in a GPL2 work has to be GPL. We get into a few issues with copyright law.
1) Copyright law does not say something cannot be doubled licensed.
2) Embedded existing work into Linux kernel is the second sentence.

Protection does not extend to any preexisting material, that is, previously published or previously registered works or works in the public domain or owned by a third party.

OK, I've got your point, you can't distinguish a copyright from a license. Look, it is simple: copyright belongs to an author from the moment of work creation, regardless of exixtence of any license or copyright symbol. Copyright law describes this. By default noone except an author can use a copyrighted material, but author can give permission to other via contract. License, including MIT and GPL are such contracts. The idea of compatibility between MIT and GPL comes from the fact that MIT allows sublicensing while GPL requires it.
Let say a person A have created work w1 and published it under MIT.
A Person B have integrated w1 into combined work c1 creating derived work c2 and publising under GPL2. He has right to do so because MIT allow this.
For now w1 belongs to A and exist within c2 without changes so you may say it is MIT licensed because a such license to w1 still exist. And it also licensed under GPL2 by B on a ground of a right given to him by A within MIT licensing.
Now lets say a person C make some change to w1 within c2 creating c3 containing modified version we will name w2. And, according to requirement, he republishes c3 under GPL2. Under which terms w2 is licensed? Under a GPL2 only. Well, being derived from w1 it still shall respect MIT condition, but it is not permitted to do with it anything which GPL2 doesn't allow like sublicensing it or including into a commercial software. C being an author of changes, can get a license to w1 and, using his ownership right and permission given to him by MIT, relicense w2 under MIT or any other license but he must do this explicitly. Person A for example, can't do this, because a copyright to w2 do not belong to him. If he failed to do so, some person D will make another change, making w3 within c4, this D person will have no right to license w3 under MIT because chain of sublicensing permissions is broken.

So, everything within kernel is licensed by GPL2 only. Some parts, which was embedded into kernel without change, also are MIT licensed, but this doesn't matter when you speaking of them within kernel context. And would you want to get some of these parts, I would suggest to you do not take a copy from kernel: it may be they was changed somehow, so you can accidentally infect your work with GPL2, better find them in the wild.


And also, all these nonsense you've written about exporting them under MIT with some macro marker is a complete BS, because even simple wrapping function like

MACRO1 wrapperN()
{
   some_func_from_MIT_library();
}

is a part of kernel and HAVE to be licensed under GPL so if calling a function infects no EXPORT_SYMBOL will save you.
And even if you will wrap pointers to direct MIT functions and place them into an array or structure, accessing this array or struct will still be touching to GPL code. The only escape here is an fair use rule. Which you dont believe in this context.


And these statements about preexisting material is just about you can't claim copyright ownership of some folks tale by including this tale into your book and you can't prolong a protection of your original work by re-releasing it with some new picture added.

So, I guess we finished with that and I will not see more idiotic claims from you.

You've wasted too much of my time already.

[Magissia]

Dude, you keep parroting stuff like facts without proving a shit and with a pretty poor grammar... I don't understand why so many activists here can agree with you. Maybe they're also not very smart and just like to parrot as well their political ideas like chickens in a farm running from one side to the other and making noise.

It is very low to attack grammar on international discussion, not everyone one is British perfect English.

[oiaohm]

So, you prefer outright lie to proof your point?

https://github.com/VARoDeK/linux_v0.01_to_v0.99.9/blob/linux-0.99.10/linux/COPYING

What do I see? GPL2 without any ammends. And you know how I've found it? .11 release looks suspicious so I just subtracted 1 and checked. So, you've found 0.99, it didn't contain any exception, then you've started to search, found the first revision which had this clarification and declared it first to be GPLed.

https://mirrors.edge.kernel.org/pub/linux/kernel/Historic

I have found a interesting glitch. Extract the tar.Z with modern tar on debian testing and the COPYING file does not extract this is true for 0.99 all the way to 0.99.10 hello software issue tricking me.

https://opensource.guide/legal/#what-if-i-want-to-change-the-license-of-my-project

The reality is Linus Torvalds got agreement from all contributors of 0.99.10 to add the syscall exception in 0.99.11 under how you can re-license projects..

There was a period of GPL2 without exceptions and you know it.

No I did not know it there is a really annoying tar glitch why I did not know it yes use "tar (GNU tar) 1.34" on the tar.Z archives from kernel.org and watch it glitch it and not extract the COPING file. Also since it 0.99.11 was a valid re-license you really don't need to know 0.99.10 and before because all authors at that time agreed to the change..

You can name several software product which was a commercial for some time and then was re-released under GPL terms, so why Linus couldn't do the same? GNU licenses are rare licenses which include a term requiring relicensing any derived work under same terms.

GPL projects have been re-licensed closed source. Linus Torvalds only could re-license with 0.99.11 due to all author agreement at the time. Try to get a all author agreement today with the Linux kernel not going to happen because there are now too many authors. There is no CLA or equal on the Linux kernel giving Linus Torvalds the power todo this. Commercial re-licensing is possible because the developers paid from the company signed agreement giving over the powers to re-license to the companies..

OK, I've got your point, you can't distinguish a copyright from a license. Look, it is simple: copyright belongs to an author from the moment of work creation, regardless of exixtence of any license or copyright symbol. Copyright law describes this. By default noone except an author can use a copyrighted material, but author can give permission to other via contract. License, including MIT and GPL are such contracts. The idea of compatibility between MIT and GPL comes from the fact that MIT allows sublicensing while GPL requires it.

You have mentioned something important. Author unless by employment or other means owns the works he creates. Current owner of copyright work is important there is such a thing. lets say you author a program under contract from company to write that program the copyright may not own to you at all but instead to the company you are working for thank you copyright law.

Let say a person A have created work w1 and published it under MIT.
A Person B have integrated w1 into combined work c1 creating derived work c2 and publising under GPL2. He has right to do so because MIT allow this.
For now w1 belongs to A and exist within c2 without changes so you may say it is MIT licensed because a such license to w1 still exist. And it also licensed under GPL2 by B on a ground of a right given to him by A within MIT licensing. Now lets say a person C make some change to w1 within c2 creating c3 containing modified version we will name w2. And, according to requirement, he republishes c3 under GPL2. Under which terms w2 is licensed? Under a GPL2 only. Well, being derived from w1 it still shall respect MIT condition, but it is not permitted to do with it anything which GPL2 doesn't allow like sublicensing it or including into a commercial software.

There is a issue here qt being dual license There is a difference between sub-licensing and multi licensing. Lets say I wrote something and decide to license it GPLv3 and CDDL1.0 these are incompatible copyleft licenses Copyright law allows this.

C being an author of changes, can get a license to w1 and, using his ownership right and permission given to him by MIT, relicense w2 under MIT or any other license but he must do this explicitly. Person A for example, can't do this, because a copyright to w2 do not belong to him. If he failed to do so, some person D will make another change, making w3 within c4, this D person will have no right to license w3 under MIT because chain of sublicensing permissions is broken.

Sublicensing idea of yours here is a fiction not backed by copyright law. Yes sublicensing is written in the MIT license but terms by copyright law are not in fact enforceable on the MIT code.. The MIT work always remained linked to it owner that might be the author or the company the author worked for or who the author sold their control rights to..

Read the first bit of MIT license very carefully.

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal

Notice something the MIT license says "any person obtaining a copy" gets the MIT grant. This does not matter if the MIT license gets the the person inside a GPLv2 work or with any other clauses connected. The MIT license automatically does it Explicitly and that grant is always for the text of the MIT license.

"Any person" clause means that complete chain argument overriding MIT is garbage because every person who gets the MIT work gets the MIT license without added conditions no matter how they get it. MIT end up being you can put your own conditions on your own code but the MIT code is always MIT.

MIT by copyright law is a form of copyleft a very permissive form of copyleft. Yes that first line "any person" bit is very simple to miss.

Yes also the first clause of the MIT license is "in the Software without restriction" first clause of the MIT license this automatically takes out any clauses any party has added from applying to the MIT work so taking it back to pure MIT license automatically.

So, everything within kernel is licensed by GPL2 only. Some parts, which was embedded into kernel without change, also are MIT licensed, but this doesn't matter when you speaking of them within kernel context. And would you want to get some of these parts, I would suggest to you do not take a copy from kernel: it may be they was changed somehow, so you can accidentally infect your work with GPL2, better find them in the wild.

MIT license allows you to add terms does not allow you to take ownership or remove/block the original grant from existing. What is called sub-licensing is the means to add terms. This is where copyright law turns around and kicks this in the teeth. The only party that can add terms that must be obeyed is the original owner. So the MIT code in a GPL work is still MIT code and still can be used with just the MIT terms because those are the terms the Author/owner of the work put on that code.

The reality MIT mixed with GPL the derivative works clause of GPL has to be processed to work out if your usage is legal. The Derivative works clause of GPL does not block the MIT work from being copied out of the GPL work and used only under the MIT license. GPL Derivative work clause over MIT by GPL only works when MIT work is new material based on the GPL work because copyright law does not allow Derivative work causes to effect preexisting..

MIT sublicense is not that powerful once you look closer. Most people who think is powerful don't notice they are ignoring MIT first clause of "in the Software without restriction" and that its a "any person" license.

Yes adding to a MIT license work then claiming restriction is breach of MIT license first clause if the person is only attempting to use the MIT work that they somehow got a copy of source code. Yes the sublicense of MIT only really allows you to add extra terms for the combined work as in the bits of code you added that are not covered by MIT this is the way MIT license has always been.

MIT does not say you have to hand over copies of the source code. Remember every person who gets copy of a MIT licensed bit with full source code gets the full MIT grant like it or not this is how MIT license works. There are many open source licenses that are "any person" with a clearing of all other terms clause yes many of these licenses are classed as GPL compatible..

Derivative work enforcement under copyright law does not care what the license of the code is it the question is this a new or preexisting material that has to be answered. New=Derivative so GPL viral applies
Preexisting=Not Derivative GPL viral does not apply.

Copyright law as rules to determine New and Preexisting. MIT being forced to release source code while it part of another work does not break the MIT license grant because the MIT license grant allows adding terms like that.. But the MIT grant also means you cannot block a person splitting the MIT work out of something like the Linux kernel and using it in something else not GPL.

And also, all these nonsense you've written about exporting them under MIT with some macro marker is a complete BS, because even simple wrapping function like

Marking stuff as MIT does not help you.

MIT could be new work with the Linux kernel so when used with the Linux kernel is it Derivative Work so GPL conditions apply but then same code could be copied out of the Linux kernel and then used with BSD kernel due to it being MIT license the GPL terms don't travel with it and once it connected to BSD kernel its no longer a Derivative work of GPL so the GPL terms no longer apply even that point of origin was the Linux kernel.

Copyright law the location of the work is a factor and when work was created is a factor if it derivative work or not.

Copyright law defines how Derivative Work determination functions. Derivative work determination is not linked to License its linked to the new/preexisting material stuff. GPL clauses says particular things happen if something is determined to be a Derivative work of the GPL work. Yes MIT is fun because code can be Derivative work when added to Linux kernel but then not Derivative work when copied into BSD and so on due to MIT license grant. Yes MIT work made on BSD then copied from BSD into Linux kernel is a preexisting work so not a Derivative work so not under the rules of the GPL License of the Linux kernel.

Also fun GPL says must be available under GPL does not say the the source code cannot be available under a different license. Multi-licensing is part of copyright law.

The way copyright law defines Derivative work is not what people would normally think.

[mSparks]

Nothing like being wrong.

https://github.com/oracle/dtrace-utils/blob/dev/LICENSE

Ahhh,
All problems already solved 10 years ago then.

https://github.com/NVIDIA/nvidia-installer/blob/main/COPYING

ROFL.

So, you prefer outright lie to proof your point?

As much as I was being sarcastic about them "copying leaked windows source into the Linux Kernel".
The level of intellectual dishonesty they are demonstrating really does suggest it is exactly the kind of thing we should expect from them.

[braiam]

Except they are retrospectively declaring functions like "mutex_destroy" as GPL only

https://forums.developer.nvidia.com/t/nvidia-drivers-378-09-fails-to-build-fatal-modpost-gpl-incompatible-module-nvidia-drm-ko-uses-gpl-only-symbol-mutex-destroy/47491

which is about as "GPL_ONLY" as a function containing if(true){}

At which point GPL_ONLY signage becomes meaningless in determining whether a symbol really is GPL_ONLY and makes the people declaring it so look like the bad actors.

Heck, nvidia should be the ones sueing for wasting their developers time and slandering their brand.

Interesting, because the actual fix was literally changing the function interface from (dev, file, handle) to (file, handle) because acquiring a spin_lock on a device is considered internal operations, which is reasonable.

[WorBlux]

Ehmm... No.
Look, you should know how copyright works.
Lets imagine you've published under GPL2 some software commit 1. Who is owner of it? It is you, as an author. I've changed 1 line of code and republished it as GPL2 requires, commit 2. What happened here? From copyright perspective, I've created derived work, and its belongs to me and you (as an author of original work). Lets say you've accepted my pull request and then added some changes, creating commit 3. As a derrivative of commit 2 it belongs to you and me. When you, for some reason, will change your mind and decide to develop this project as closed, you will have to rewind and start from commit 1. If you want to start with commit 3 you shall get my permission. Maybe a verb 'belong' is not right word, from copyright perspective, to use commit 3 anybody have to get permission of owners of all chain of derrivation, but in our case it is already granted by GPL2. What you need to understand, that the copyright object is a whole commit 3. It has been licensed under GPL2 terms. So, speaking of parts licensed under MIT or another is wrong. It was incorporated and relicensed under GPL2....

The legal theory that every patch is a derivative work of every other, is not well supported.

The actual test for a derivative work is well established. If my commit 1 is 10,000 lines and your commit 2 is 10, and 3 is another 1000. Then no you don't have a good claim of my work being derivative/infringing on yours. If my commit 1 is 10,000, and we go back and forth with 99 small patches to get to a highly revised 15,000 lines, then you have a good claim of our contributions being mutually derivative. At that point I'd be infringing if I just ripped out your contributions, and wrote code to fill in the holes. Point being the derivative works test is highly sensitive to context. The mere technical act of patched, isn't necessarily a legally recognized derivation.

Some kernel subsystems and drivers, not notably the DRM subsystem maintain a tree separately from the Linux kernel and provide functionality/backbone to several different kernel projects. .

Other interfaces are ripped straight from POSIX (which is patch 1)

As for the another BS about working with proprietary module is somehow violates GPL2, well, it is another "either or" situation.
It either any proprietary module violates GPL or no proprietary module violates. License violation can't depend on some macro, unless license text includes such term. GPL2 say nothing about EXPORT_GPL_ONLY.
And from legal perspective, kernel module is no different from another executable. So if you insist GPL2 of kernel requires to execute directly or indirectly only GPL licensed software then your arguments are valid for userspace software too. You won't be able to run any nongpl game, for example.

Again, the test for derivative works is context sensitive. While it's true the a module under a GPL incompatible license is strongly suspect of infringing, if a careful analysis under copyright law it's not derivative of GPL material on account of having functionality in itself applicable to other contexts, and due to relying only on symbols/code made available under a non-copyleft license, then it's unlikely a court would find it to be infringing.

Also the Kernel uses a slightly modified GPL-2, which specificly exempts userspace calls.

" 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".
Also note that the GPL below is copyrighted by the Free Software
Foundation, but the instance of code that it refers to (the Linux
kernel) is copyrighted by me and others who actually wrote it.

Also note that the only valid version of the GPL as far as the kernel
is concerned is _this_ particular version of the license (ie v2, not
v2.2 or v3.x or whatever), unless explicitly otherwise stated.

Linus Torvalds"

[WorBlux]

All kernel patches have been committed by their authors under the terms of GPLv2. This allows everyone to freely mix GPLv2-licensed code in any manner they see fit. There is no requirement to adhere to the order of patches.
Such actions are relatively common and are performed regularly. For instance, vendor kernels often omit certain patches, backport others, and undertake similar actions. In these scenarios, explicit permissions from patch authors are not required.
Stable kernels are also forked using a similar approach.

So long as you are mixing GPL compatible code, order doesn't matter, and what specificly is deravative of what else doesn't matter.

No. Just read GPL2 for a change. It says nothing about any macro and it clearly allows any modification.
You've been mislead by commercial software, it usually contain some code, protecting license bounds and license usually strictly forbid any modification. That makes creating hack to lift that protection illegal. But GPL is a free license. It was designed that way to protect code authors from some future authoritarian who can want to add restriction.

The legal problem isn't in the fact you changed the code to rename the symbol, the problem is in why you did it.

Contributory infringement is a real thing. While the change itself isn't infringing, the change is made only for the benifit of those who do infringe.

Also in changing the symbol or behavior of the module loader, you demonstrate an element of willfullness here, and wilffullness=extra penalties in court.

[mSparks]

The legal problem isn't in the fact you changed the code to rename the symbol, the problem is in why you did it.

No legal problem can ever manifest,
Its unstable, they made one that will always be stable and do the same thing, even if kernel changes means it needs to change internally.

[oiaohm]

Ahhh,
All problems already solved 10 years ago then.

https://github.com/NVIDIA/nvidia-installer/blob/main/COPYING

ROFL.

No that does not solve it. Oracle changed the licenses on everything that by law could be classed as a derivative work in 2017 with Dtrace.

The code using the dtrace exports is either coming from user space so protected by the user space exception note or is GPL license compadible.

Nvidia binary blob 10 years ago is not under compatible license only the wrapper is. Oracle with Dtrace 2.0 got rid of the CDDL code from the Linux implementation so removing the license problem.

The reality here mSparks Dtrace 1.0 on Linux is not closed source either instead you have a CDDL/GPL license conflict.

https://en.wikipedia.org/wiki/DTrace

I got the date wrong it was 2017 when Oracle fixed the license issue on Linux moving to pure GPLv2 and UPL.

Dtrace is external module that before 2017 that use to have a license problem using EXPORT_SYMBOL_GPL symbol due to being CDDL.

Nvidia installer has you using Nvidia blob that is not under a GPL compatible license with out any question. CDDL there is a stack of legal debates if GPL/CDDL can be mixed in a legally acceptable way never tested in court if that stuff is right.

mSparks basically Dtrace is unless item to attempt to use to win for Nvidia driver. Dtrace 1.0 case only is helpful to OpenZFS nothing more.

mSparks reality here dtrace on Linux has never been closed source and never in fact had closed source parts.

There is a catch here . Proprietary Linux Kernel module does not mean closed source in means contains something not under a Linux kernel compatible license this is why CDDL dtrace is classed as Proprietary .

https://docs.kernel.org/process/license-rules.html There are only 7 valid license tags for a Linux kernel module with Proprietary being the catch all for everything that does not fit in the first 6(yes technically 4 because there is 2 you should not use at all due to those being historic left overs) . Is current Linux dtrace kernel module Proprietary no its not its a simple GPL module.

The write you had on dtrace having issues that was from 2014 when dtrace was still cddl. Oracle re-licensed dtrace to fix it. Nvidia is free to re-license and release the source code their incompatible parts when they wish to.