[v1] docs: describe how to quickly build Linux

  Add a text explaining how to quickly build a kernel, as that's something
users will often have to do when they want to report an issue or test
proposed fixes. This is a huge and frightening task for quite a few
users these days, as many rely on pre-compiled kernels and have never
built their own. They find help on quite a few websites explaining the
process in various ways, but those howtos often omit important details
or make things too hard for the 'quickly build just for testing' case
that 'localmodconfig' is really useful for. Hence give users something
at hand to guide them, as that makes it easier for them to help with
testing, debugging, and fixing the kernel.

To keep the complexity at bay, the document explicitly focuses on how to
compile the kernel on commodity distributions running on commodity
hardware. People that deal with less common distributions or hardware
will often know their way around already anyway.

The text describes a few oddities of Arch and Debian that were found by
the author and a few volunteers that tested the described procedure.
There are likely more such quirks that need to be covered as well as a
few things the author will have missed -- but one has to start
somewhere.

The document heavily uses anchors and links to them, which makes things
slightly harder to read in the source tree. But the intended target
audience is way more likely to read rendered versions of this text on
pages like docs.kernel.org anyway -- and there those anchors and links
allow easy jumps to the reference section and back, which makes the
document a lot easier to work with for the intended target audience.

Aspects relevant for bisection were left out on purpose, as that is a
related, but in the end different use case. The rough plan is to have a
second document with a similar style to cover bisection. The idea is to
reuse a few bits from this document and link quite often to entries in
the reference section with the help of the anchors in this text.

Signed-off-by: Thorsten Leemhuis <linux@leemhuis.info>
---

Hi! Above patch description covers nearly everything already, there is
just one thing where I'm unsure about the approach and would like to
hear other opinions on:

The text currently describes two approaches to retrieve Linux' sources
using git: the regular clone with linux-stable as a remote and a shallow
clone with just one branch from linux-stable. The shallow clone approach
is a little bit more tricky to describe and handle, but downloads way
less data – and thus is a lot quicker, unless you have a really really
quick link to the internet (which in some parts of the world is hard to
come by). That's why I wonder if the text should switch to making the
shallow clone with selected stable branches the default. What do you
think, dear reader?

Ciao, Thorsten

P.S.: a rendered version of this text is temporarily available at:
https://www.leemhuis.info/files/misc/How%20to%20quickly%20build%20a%20Linux%20kernel%20%E2%80%94%20The%20Linux%20Kernel%20documentation.html
---
 .../admin-guide/howto-quickly-build-linux.rst | 903 ++++++++++++++++++
 Documentation/admin-guide/index.rst           |   1 +
 MAINTAINERS                                   |   1 +
 3 files changed, 905 insertions(+)
 create mode 100644 Documentation/admin-guide/howto-quickly-build-linux.rst


base-commit: a16abc68e66c86ca9d80c4a04a2103ef7ed1a40f
  

On Wed, Feb 01, 2023 at 12:52:30PM +0100, Thorsten Leemhuis wrote:
> Add a text explaining how to quickly build a kernel, as that's something
> users will often have to do when they want to report an issue or test
> proposed fixes. This is a huge and frightening task for quite a few
> users these days, as many rely on pre-compiled kernels and have never
> built their own. They find help on quite a few websites explaining the
> process in various ways, but those howtos often omit important details
> or make things too hard for the 'quickly build just for testing' case
> that 'localmodconfig' is really useful for. Hence give users something
> at hand to guide them, as that makes it easier for them to help with
> testing, debugging, and fixing the kernel.

First off, this is great, thanks for doing this.

One minor comment, to prevent people from "overloading" the
git.kernel.org systems:

> +.. _sources_sbs:
> +
> + * Retrieve the sources of the Linux version you intend to build; then change
> +   into the directory holding them, as all further commands in this guide are
> +   meant to be executed from there.
> +
> +   If you plan to only build one particular kernel version, download its source
> +   archive from https://kernel.org; afterwards extract its content to '~/linux/'
> +   and change into the directory created during extraction.
> +
> +   In most other situations your best choice is to fetch the sources using git::
> +
> +          git clone https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git \
> +            ~/linux/sources
> +          cd ~/linux/sources/

Ideally you should never do a "full clone from scratch" like this, as it
takes up loads of server resources.  The "best" way to do this is to
download the kernel git bundle, and then pull and resolve the remaining
bits.  It's explained, with a script to do the work for you, here:

	https://kernel.org/best-way-to-do-linux-clones-for-your-ci.html

Using that will save you time (the CI bundles are mirrored around the
world), and greatly reduce the server load (which is already high
enough.)

thanks,

greg k-h
  

On Wed, Feb 01, 2023 at 01:42:29PM +0100, Greg KH wrote:
> On Wed, Feb 01, 2023 at 12:52:30PM +0100, Thorsten Leemhuis wrote:
> > Add a text explaining how to quickly build a kernel, as that's something
> > users will often have to do when they want to report an issue or test
> > proposed fixes. This is a huge and frightening task for quite a few
> > users these days, as many rely on pre-compiled kernels and have never
> > built their own. They find help on quite a few websites explaining the
> > process in various ways, but those howtos often omit important details
> > or make things too hard for the 'quickly build just for testing' case
> > that 'localmodconfig' is really useful for. Hence give users something
> > at hand to guide them, as that makes it easier for them to help with
> > testing, debugging, and fixing the kernel.
> 
> First off, this is great, thanks for doing this.
> 
> One minor comment, to prevent people from "overloading" the
> git.kernel.org systems:
> 
> > +.. _sources_sbs:
> > +
> > + * Retrieve the sources of the Linux version you intend to build; then change
> > +   into the directory holding them, as all further commands in this guide are
> > +   meant to be executed from there.
> > +
> > +   If you plan to only build one particular kernel version, download its source
> > +   archive from https://kernel.org; afterwards extract its content to '~/linux/'
> > +   and change into the directory created during extraction.
> > +
> > +   In most other situations your best choice is to fetch the sources using git::
> > +
> > +          git clone https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git \
> > +            ~/linux/sources
> > +          cd ~/linux/sources/
> 
> Ideally you should never do a "full clone from scratch" like this, as it
> takes up loads of server resources.  The "best" way to do this is to
> download the kernel git bundle, and then pull and resolve the remaining
> bits.  It's explained, with a script to do the work for you, here:
> 
> 	https://kernel.org/best-way-to-do-linux-clones-for-your-ci.html

Oops, here's the full steps involved:
	https://www.kernel.org/cloning-linux-from-a-bundle.html
the first link above has a script that does it all for you, but you
probably just want to copy the steps at this last link instead.

thanks,

greg k-h
  

On 01.02.23 13:44, Greg KH wrote:
> On Wed, Feb 01, 2023 at 01:42:29PM +0100, Greg KH wrote:
>> On Wed, Feb 01, 2023 at 12:52:30PM +0100, Thorsten Leemhuis wrote:
>>> Add a text explaining how to quickly build a kernel, as that's something
>>> users will often have to do when they want to report an issue or test
>>> proposed fixes. This is a huge and frightening task for quite a few
>>> users these days, as many rely on pre-compiled kernels and have never
>>> built their own. They find help on quite a few websites explaining the
>>> process in various ways, but those howtos often omit important details
>>> or make things too hard for the 'quickly build just for testing' case
>>> that 'localmodconfig' is really useful for. Hence give users something
>>> at hand to guide them, as that makes it easier for them to help with
>>> testing, debugging, and fixing the kernel.
>>
>> First off, this is great, thanks for doing this.

Thx, feels good to hear.

Bisection is next on my todo list once this matured...

>> One minor comment, to prevent people from "overloading" the
>> git.kernel.org systems:
>>
>>> +.. _sources_sbs:
>>> +
>>> + * Retrieve the sources of the Linux version you intend to build; then change
>>> +   into the directory holding them, as all further commands in this guide are
>>> +   meant to be executed from there.
>>> +
>>> +   If you plan to only build one particular kernel version, download its source
>>> +   archive from https://kernel.org; afterwards extract its content to '~/linux/'
>>> +   and change into the directory created during extraction.
>>> +
>>> +   In most other situations your best choice is to fetch the sources using git::
>>> +
>>> +          git clone https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git \
>>> +            ~/linux/sources
>>> +          cd ~/linux/sources/
>>
>> Ideally you should never do a "full clone from scratch" like this, as it
>> takes up loads of server resources.  The "best" way to do this is to
>> download the kernel git bundle, and then pull and resolve the remaining
>> bits.  It's explained, with a script to do the work for you, here:
>>
>> 	https://kernel.org/best-way-to-do-linux-clones-for-your-ci.html
> 
> Oops, here's the full steps involved:
> 	https://www.kernel.org/cloning-linux-from-a-bundle.html
> the first link above has a script that does it all for you, but you
> probably just want to copy the steps at this last link instead.

Great idea, thx for bringing this up -- now that you mention it, I
remember those pages and the script again... :-/

Sadly my "after cloning Linus tree, add the stable tree as remote and
fetch everything" approach would will still create a lot of load. I
could use the script with the stable git repo, as that includes
mainline; but I noticed it sometimes is not fully up2date. At least I
once noticed it was quite a few hours (or maybe even a day?) behind. Is
that normal? I assume you should know.

Anyway: maybe "a little bit behind" isn't something that's much of a
problem for this document.

Ciao, Thorsten
  

On Wed, Feb 01, 2023 at 02:22:07PM +0100, Thorsten Leemhuis wrote:
> On 01.02.23 13:44, Greg KH wrote:
> > On Wed, Feb 01, 2023 at 01:42:29PM +0100, Greg KH wrote:
> >> On Wed, Feb 01, 2023 at 12:52:30PM +0100, Thorsten Leemhuis wrote:
> >>> Add a text explaining how to quickly build a kernel, as that's something
> >>> users will often have to do when they want to report an issue or test
> >>> proposed fixes. This is a huge and frightening task for quite a few
> >>> users these days, as many rely on pre-compiled kernels and have never
> >>> built their own. They find help on quite a few websites explaining the
> >>> process in various ways, but those howtos often omit important details
> >>> or make things too hard for the 'quickly build just for testing' case
> >>> that 'localmodconfig' is really useful for. Hence give users something
> >>> at hand to guide them, as that makes it easier for them to help with
> >>> testing, debugging, and fixing the kernel.
> >>
> >> First off, this is great, thanks for doing this.
> 
> Thx, feels good to hear.
> 
> Bisection is next on my todo list once this matured...
> 
> >> One minor comment, to prevent people from "overloading" the
> >> git.kernel.org systems:
> >>
> >>> +.. _sources_sbs:
> >>> +
> >>> + * Retrieve the sources of the Linux version you intend to build; then change
> >>> +   into the directory holding them, as all further commands in this guide are
> >>> +   meant to be executed from there.
> >>> +
> >>> +   If you plan to only build one particular kernel version, download its source
> >>> +   archive from https://kernel.org; afterwards extract its content to '~/linux/'
> >>> +   and change into the directory created during extraction.
> >>> +
> >>> +   In most other situations your best choice is to fetch the sources using git::
> >>> +
> >>> +          git clone https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git \
> >>> +            ~/linux/sources
> >>> +          cd ~/linux/sources/
> >>
> >> Ideally you should never do a "full clone from scratch" like this, as it
> >> takes up loads of server resources.  The "best" way to do this is to
> >> download the kernel git bundle, and then pull and resolve the remaining
> >> bits.  It's explained, with a script to do the work for you, here:
> >>
> >> 	https://kernel.org/best-way-to-do-linux-clones-for-your-ci.html
> > 
> > Oops, here's the full steps involved:
> > 	https://www.kernel.org/cloning-linux-from-a-bundle.html
> > the first link above has a script that does it all for you, but you
> > probably just want to copy the steps at this last link instead.
> 
> Great idea, thx for bringing this up -- now that you mention it, I
> remember those pages and the script again... :-/
> 
> Sadly my "after cloning Linus tree, add the stable tree as remote and
> fetch everything" approach would will still create a lot of load.

Not really, nothing like doing a "full" clone of the original repo.
It's a much smaller working set that needs to be handled that way on the
server side.

I do this (as do many others) for CI systems, and the primary workload
is on the client resolving the bundle, that can take a bit of time, but
that's all client side, not server.

> I
> could use the script with the stable git repo, as that includes
> mainline; but I noticed it sometimes is not fully up2date. At least I
> once noticed it was quite a few hours (or maybe even a day?) behind. Is
> that normal? I assume you should know.

I think it's generated daily, so yes, it will be a bit out of date, but
that's fine.

> Anyway: maybe "a little bit behind" isn't something that's much of a
> problem for this document.

Adding the remote and doing a pull is good and recommended, so it's fine
if it's a day or so out of date.

thanks,

greg k-h
  

[adding Konstantin and Greg to the list of recipients]

On 01.02.23 12:52, Thorsten Leemhuis wrote:
> Add a text explaining how to quickly build a kernel, as that's something
> users will often have to do when they want to report an issue or test
> proposed fixes. This is a huge and frightening task for quite a few
> users these days, as many rely on pre-compiled kernels and have never
> built their own. They find help on quite a few websites explaining the
> process in various ways, but those howtos often omit important details
> or make things too hard for the 'quickly build just for testing' case
> that 'localmodconfig' is really useful for. Hence give users something
> at hand to guide them, as that makes it easier for them to help with
> testing, debugging, and fixing the kernel.

Side note: after feedback on social media I'll likely switch to a title
like "how to quickly configure & build a trimmed-down Linux kernel", as
some people from the current title assumed this would be about things
like ccache. I'll also likely will switch to using a localversion file
in the buildroot instead of modifying the EXTRAVERSION in the top-level
makefile (but I haven't actually tried it yet).

> [...]
>
> The text currently describes two approaches to retrieve Linux' sources
> using git: the regular clone with linux-stable as a remote and a shallow
> clone with just one branch from linux-stable. The shallow clone approach
> is a little bit more tricky to describe and handle, but downloads way
> less data – and thus is a lot quicker, unless you have a really really
> quick link to the internet (which in some parts of the world is hard to
> come by). That's why I wonder if the text should switch to making the
> shallow clone with selected stable branches the default. What do you
> think, dear reader?

So, I looked into what Greg suggested (e.g.
https://kernel.org/best-way-to-do-linux-clones-for-your-ci.html and
https://www.kernel.org/cloning-linux-from-a-bundle.html
). Assuming users have a up2date git (afaics 2.38+) I could use commands
like this in my text:

curl -L
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/clone.bundle
-o ~/linux/linux-stable.git.bundle
git clone --bundle-uri=linux-stable.git.bundle
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
~/linux/sources
rm ~/linux/linix-stable.git.bundle

This took roundabout 16 minutes with my 100 Mbit cable internet
connection (~9 min for the download, 7 for the clone [the machine used
is somewhat old]) and downloads & stores ~4,5 GByte data (without checkout).

[side note: using
"--bundle-uri=https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/clone.bundle"
does not work (due to the redirect? whatever) -- but that might be
unwise anyway in case the download is interrupted]


Then I tried creating a shallow clone like this:

git clone
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
--depth 1 -b v6.1
git remote set-branches --add origin master
git fetch --all --shallow-exclude=v6.1
git remote add -t linux-6.1.y linux-stable
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
git fetch --all --shallow-exclude=v6.1

This took only roundabout 2 minutes and downloads & stores ~512 MByte
data (without checkout).


Not totally sure, but the shallow clone somehow feels more appropriate
for the use case (reminder, there is a "quickly" in the document title),
even if such a clone is less flexible (e.g. users have to manually add
stable branches they are interested it; and they need to be careful when
using git fetch).

That's why I now strongly consider using the shallow clone method by
default in v2 of this text. Or does that also create a lot of load on
the servers? Or are there other strong reason why using a shallow clone
might be a bad idea for this use case?

Ciao, Thorsten

> [...]
> +.. _sources_sbs:
> +
> + * Retrieve the sources of the Linux version you intend to build; then change
> +   into the directory holding them, as all further commands in this guide are
> +   meant to be executed from there.
> +
> +   If you plan to only build one particular kernel version, download its source
> +   archive from https://kernel.org; afterwards extract its content to '~/linux/'
> +   and change into the directory created during extraction.
> +
> +   In most other situations your best choice is to fetch the sources using git::
> +
> +          git clone https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git \
> +            ~/linux/sources
> +          cd ~/linux/sources/
> +
> +   Now you can check out any mainline release with a command like
> +   ``git checkout --detach v6.1``; pre-release like v6.2-rc2 work, too.
> +   Specifying 'origin/master' will hand you the latest mainline code, which is
> +   automatically checked out by the above 'git clone […]' command.
> +
> +   In case you want to build a stable or longterm kernel, run this, too::
> +
> +          git remote add linux-stable \
> +            https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
> +          git fetch --all
> +
> +   Afterwards you can use a command like ``git checkout --detach v6.1.5`` to
> +   access any such release.
> +
> +   This flexibility comes at a cost, as cloning the sources like this will
> +   download quite a bit of data: roundabout 2,5 Gigabyte for mainline and 1,8
> +   for stable/longterm releases as of early 2022. See the reference section for
> +   a somewhat more complicated approach which is also using git, but downloads
> +   only slightly more data than downloading a compressed tarball would.
> +
> +   [:ref:`details<sources>`]
> +
> [...]
> +
> +.. _sources:
> +
> +Download the sources
> +--------------------
> +
> +  *Retrieve the sources of the Linux version you intend to build.*
> +  [:ref:`...<sources_sbs>`]
> +
> +Fetching the complete stable git repository as explained in the step-by-step
> +guide above is easy and offers the most flexibility, but also downloads quite a
> +bit of data (more than 4 Gigabyte as of late 2022). If you want something
> +lighter, you instead might want to create a 'shallow clone' that omits some of
> +the history and only contains stable series you are interested in::
> +
> +       git clone --no-checkout \
> +         https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git \
> +         --depth 1 -b v6.0 ~/linux/sources/
> +       cd ~/linux/sources/
> +       git remote set-branches --add origin master
> +       git remote add -t linux-6.1.y linux-stable \
> +         https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
> +       git fetch --all --shallow-exclude=v6.0
> +
> +The initial command creates a clone with the sources of just Linux v6.0; this
> +downloads just a little more data than retrieving a xz-compressed tarball of
> +that version would (~230 vs 204 Megabyte); afterwards the master branch is added
> +to the list of tracked branches, which allows you to retrieve anything state of
> +mainline since Linux 6.0 was released. The linux-stable repository is then added
> +as a remote which just tracks the linux-6.1.y branch. In early 2022 as of Linux
> +v6.2-rc4 the last two steps downloaded ~95 and ~2 Megabyte.
> +
> +With this tree you can check out the latest mainline code using ``git checkout
> +--detach origin/master``. All versions and individual changes released between
> +6.0 and the latest 6.1.y version are at hand, too -- this tree thus also allows
> +you to bisect a problem introduced in that range.
> +
> +Later run above 'git fetch [...]' command again, when you want to retrieve the
> +latest mainline codebase or access 6.1.y versions released in between. If you
> +want to switch to a release from a newer stable series (say Linux v6.2.y), you
> +first need to add its remote branch with a command like ``git remote
> +set-branches --add linux-stable linux-6.2.y``; once you run 'git fetch [...]'
> +again you'll be able to check out versions from that series.
> +
> +[:ref:`back to step-by-step guide <sources_sbs>`]
> +
  

On Thu, Feb 02, 2023 at 12:15:36PM +0100, Linux kernel regression tracking (Thorsten Leemhuis) wrote:
> [adding Konstantin and Greg to the list of recipients]
> 
> On 01.02.23 12:52, Thorsten Leemhuis wrote:
> > Add a text explaining how to quickly build a kernel, as that's something
> > users will often have to do when they want to report an issue or test
> > proposed fixes. This is a huge and frightening task for quite a few
> > users these days, as many rely on pre-compiled kernels and have never
> > built their own. They find help on quite a few websites explaining the
> > process in various ways, but those howtos often omit important details
> > or make things too hard for the 'quickly build just for testing' case
> > that 'localmodconfig' is really useful for. Hence give users something
> > at hand to guide them, as that makes it easier for them to help with
> > testing, debugging, and fixing the kernel.
> 
> Side note: after feedback on social media I'll likely switch to a title
> like "how to quickly configure & build a trimmed-down Linux kernel", as
> some people from the current title assumed this would be about things
> like ccache. I'll also likely will switch to using a localversion file
> in the buildroot instead of modifying the EXTRAVERSION in the top-level
> makefile (but I haven't actually tried it yet).
> 
> > [...]
> >
> > The text currently describes two approaches to retrieve Linux' sources
> > using git: the regular clone with linux-stable as a remote and a shallow
> > clone with just one branch from linux-stable. The shallow clone approach
> > is a little bit more tricky to describe and handle, but downloads way
> > less data – and thus is a lot quicker, unless you have a really really
> > quick link to the internet (which in some parts of the world is hard to
> > come by). That's why I wonder if the text should switch to making the
> > shallow clone with selected stable branches the default. What do you
> > think, dear reader?
> 
> So, I looked into what Greg suggested (e.g.
> https://kernel.org/best-way-to-do-linux-clones-for-your-ci.html and
> https://www.kernel.org/cloning-linux-from-a-bundle.html
> ). Assuming users have a up2date git (afaics 2.38+) I could use commands
> like this in my text:
> 
> curl -L
> https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/clone.bundle
> -o ~/linux/linux-stable.git.bundle
> git clone --bundle-uri=linux-stable.git.bundle
> https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
> ~/linux/sources
> rm ~/linux/linix-stable.git.bundle
> 
> This took roundabout 16 minutes with my 100 Mbit cable internet
> connection (~9 min for the download, 7 for the clone [the machine used
> is somewhat old]) and downloads & stores ~4,5 GByte data (without checkout).
> 
> [side note: using
> "--bundle-uri=https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/clone.bundle"
> does not work (due to the redirect? whatever) -- but that might be
> unwise anyway in case the download is interrupted]
> 
> 
> Then I tried creating a shallow clone like this:
> 
> git clone
> https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
> --depth 1 -b v6.1
> git remote set-branches --add origin master
> git fetch --all --shallow-exclude=v6.1
> git remote add -t linux-6.1.y linux-stable
> https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
> git fetch --all --shallow-exclude=v6.1
> 
> This took only roundabout 2 minutes and downloads & stores ~512 MByte
> data (without checkout).
> 
> 
> Not totally sure, but the shallow clone somehow feels more appropriate
> for the use case (reminder, there is a "quickly" in the document title),
> even if such a clone is less flexible (e.g. users have to manually add
> stable branches they are interested it; and they need to be careful when
> using git fetch).
> 
> That's why I now strongly consider using the shallow clone method by
> default in v2 of this text. Or does that also create a lot of load on
> the servers? Or are there other strong reason why using a shallow clone
> might be a bad idea for this use case?

I think Konstantin answered your question already on a social network
based on the server load question.

For the "will this work for testing", sure, a shallow clone should work
just fine, if no one has to use 'git bisect' to go back further than the
version you originally clone.  Hopefully that's not a normal thing.

thanks,

greg k-h
  

On 02.02.23 15:27, Greg KH wrote:
> On Thu, Feb 02, 2023 at 12:15:36PM +0100, Linux kernel regression tracking (Thorsten Leemhuis) wrote:
>> [adding Konstantin and Greg to the list of recipients]
>>
>> On 01.02.23 12:52, Thorsten Leemhuis wrote:
>>> Add a text explaining how to quickly build a kernel, as that's something
>>> users will often have to do when they want to report an issue or test
>>> proposed fixes. This is a huge and frightening task for quite a few
>>> users these days, as many rely on pre-compiled kernels and have never
>>> built their own. They find help on quite a few websites explaining the
>>> process in various ways, but those howtos often omit important details
>>> or make things too hard for the 'quickly build just for testing' case
>>> that 'localmodconfig' is really useful for. Hence give users something
>>> at hand to guide them, as that makes it easier for them to help with
>>> testing, debugging, and fixing the kernel.
>>
>> Side note: after feedback on social media I'll likely switch to a title
>> like "how to quickly configure & build a trimmed-down Linux kernel", as
>> some people from the current title assumed this would be about things
>> like ccache. I'll also likely will switch to using a localversion file
>> in the buildroot instead of modifying the EXTRAVERSION in the top-level
>> makefile (but I haven't actually tried it yet).
>>
>>> [...]
>>>
>>> The text currently describes two approaches to retrieve Linux' sources
>>> using git: the regular clone with linux-stable as a remote and a shallow
>>> clone with just one branch from linux-stable. The shallow clone approach
>>> is a little bit more tricky to describe and handle, but downloads way
>>> less data – and thus is a lot quicker, unless you have a really really
>>> quick link to the internet (which in some parts of the world is hard to
>>> come by). That's why I wonder if the text should switch to making the
>>> shallow clone with selected stable branches the default. What do you
>>> think, dear reader?
>>
>> So, I looked into what Greg suggested (e.g.
>> https://kernel.org/best-way-to-do-linux-clones-for-your-ci.html and
>> https://www.kernel.org/cloning-linux-from-a-bundle.html
>> ). Assuming users have a up2date git (afaics 2.38+) I could use commands
>> like this in my text:
>>
>> curl -L
>> https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/clone.bundle
>> -o ~/linux/linux-stable.git.bundle
>> git clone --bundle-uri=linux-stable.git.bundle
>> https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
>> ~/linux/sources
>> rm ~/linux/linix-stable.git.bundle
>>
>> This took roundabout 16 minutes with my 100 Mbit cable internet
>> connection (~9 min for the download, 7 for the clone [the machine used
>> is somewhat old]) and downloads & stores ~4,5 GByte data (without checkout).
>>
>> [side note: using
>> "--bundle-uri=https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/clone.bundle"
>> does not work (due to the redirect? whatever) -- but that might be
>> unwise anyway in case the download is interrupted]
>>
>>
>> Then I tried creating a shallow clone like this:
>>
>> git clone
>> https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
>> --depth 1 -b v6.1
>> git remote set-branches --add origin master
>> git fetch --all --shallow-exclude=v6.1
>> git remote add -t linux-6.1.y linux-stable
>> https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
>> git fetch --all --shallow-exclude=v6.1
>>
>> This took only roundabout 2 minutes and downloads & stores ~512 MByte
>> data (without checkout).
>>
>>
>> Not totally sure, but the shallow clone somehow feels more appropriate
>> for the use case (reminder, there is a "quickly" in the document title),
>> even if such a clone is less flexible (e.g. users have to manually add
>> stable branches they are interested it; and they need to be careful when
>> using git fetch).
>>
>> That's why I now strongly consider using the shallow clone method by
>> default in v2 of this text. Or does that also create a lot of load on
>> the servers? Or are there other strong reason why using a shallow clone
>> might be a bad idea for this use case?
> 
> I think Konstantin answered your question already on a social network
> based on the server load question.

Yup, he did. For the record, this is what he wrote:

```
it [a shallow clone] is pretty expensive on the server side, but it is
only really a problem when a bunch of shallow clones are performed at
once (e.g. when a CI farm does it across 50 nodes or something). When
that happens, it overwhelms the server.

If an actual human being does a single shallow clone it's not a big deal.
```

> For the "will this work for testing", sure, a shallow clone should work
> just fine, if no one has to use 'git bisect' to go back further than the
> version you originally clone.  Hopefully that's not a normal thing.

Yeah, that's something I have in mind already. But seems it's not much
of a problem, as one apparently can access older versions (including
tags) by deepening a shallow clone with a command like "git fetch origin
--shallow-exclude=v5.19" these days.

Ciao, Thorsten
  

On Thu, Feb 02, 2023 at 12:15:36PM +0100, Linux kernel regression tracking (Thorsten Leemhuis) wrote:
> Then I tried creating a shallow clone like this:
> 
> git clone
> https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
> --depth 1 -b v6.1
> git remote set-branches --add origin master
> git fetch --all --shallow-exclude=v6.1
> git remote add -t linux-6.1.y linux-stable
> https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
> git fetch --all --shallow-exclude=v6.1
> 
> This took only roundabout 2 minutes and downloads & stores ~512 MByte
> data (without checkout).

Can we also include the option of just downloading the tarball, if it's a
released version? That's the fastest and most lightweight option 100% of the
time. :)

> Not totally sure, but the shallow clone somehow feels more appropriate
> for the use case (reminder, there is a "quickly" in the document title),
> even if such a clone is less flexible (e.g. users have to manually add
> stable branches they are interested it; and they need to be careful when
> using git fetch).
> 
> That's why I now strongly consider using the shallow clone method by
> default in v2 of this text. Or does that also create a lot of load on
> the servers? Or are there other strong reason why using a shallow clone
> might be a bad idea for this use case?

As I mentioned elsewhere, this is only a problem when it's done in batch mode
by CI systems. A full clone uses pregenerated pack files and is very cheap,
because it's effectively a sendfile operation. A shallow clone requires
generating a brand new pack, compressing it, and then keeping it around in
memory for the duration of the clone process. Not a big deal when a few humans
here and there do it, but when 50 CI nodes do it all at once, it effectively
becomes a DDoS. :)

-K
  

On 02.02.23 16:08, Konstantin Ryabitsev wrote:
> On Thu, Feb 02, 2023 at 12:15:36PM +0100, Linux kernel regression tracking (Thorsten Leemhuis) wrote:
>> Then I tried creating a shallow clone like this:
>>
>> git clone
>> https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
>> --depth 1 -b v6.1
>> git remote set-branches --add origin master
>> git fetch --all --shallow-exclude=v6.1
>> git remote add -t linux-6.1.y linux-stable
>> https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
>> git fetch --all --shallow-exclude=v6.1
>>
>> This took only roundabout 2 minutes and downloads & stores ~512 MByte
>> data (without checkout).
> 
> Can we also include the option of just downloading the tarball, if it's a
> released version? That's the fastest and most lightweight option 100% of the
> time. :)

Don't worry, that was in there and will stay in there:

+   If you plan to only build one particular kernel version, download
its source
+   archive from https://kernel.org; afterwards extract its content to
'~/linux/'
+   and change into the directory created during extraction.
>> Not totally sure, but the shallow clone somehow feels more appropriate
>> for the use case (reminder, there is a "quickly" in the document title),
>> even if such a clone is less flexible (e.g. users have to manually add
>> stable branches they are interested it; and they need to be careful when
>> using git fetch).
>>
>> That's why I now strongly consider using the shallow clone method by
>> default in v2 of this text. Or does that also create a lot of load on
>> the servers? Or are there other strong reason why using a shallow clone
>> might be a bad idea for this use case?
> 
> As I mentioned elsewhere, this is only a problem when it's done in batch mode
> by CI systems. A full clone uses pregenerated pack files and is very cheap,
> because it's effectively a sendfile operation. A shallow clone requires
> generating a brand new pack, compressing it, and then keeping it around in
> memory for the duration of the clone process. Not a big deal when a few humans
> here and there do it, but when 50 CI nodes do it all at once, it effectively
> becomes a DDoS. :)

Thx again for your insights, much appreciated.

Ciao, Thorsten
  

On Thu, 02 Feb 2023, Thorsten Leemhuis <linux@leemhuis.info> wrote:
> On 02.02.23 16:08, Konstantin Ryabitsev wrote:
>> On Thu, Feb 02, 2023 at 12:15:36PM +0100, Linux kernel regression tracking (Thorsten Leemhuis) wrote:
>>> Then I tried creating a shallow clone like this:
>>>
>>> git clone
>>> https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
>>> --depth 1 -b v6.1
>>> git remote set-branches --add origin master
>>> git fetch --all --shallow-exclude=v6.1
>>> git remote add -t linux-6.1.y linux-stable
>>> https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
>>> git fetch --all --shallow-exclude=v6.1
>>>
>>> This took only roundabout 2 minutes and downloads & stores ~512 MByte
>>> data (without checkout).
>> 
>> Can we also include the option of just downloading the tarball, if it's a
>> released version? That's the fastest and most lightweight option 100% of the
>> time. :)
>
> Don't worry, that was in there and will stay in there:
>
> +   If you plan to only build one particular kernel version, download
> its source
> +   archive from https://kernel.org; afterwards extract its content to
> '~/linux/'
> +   and change into the directory created during extraction.

The trouble is, if this is for someone who needs to try kernels for
debugging, a typical idea is to ask them to revert something or apply a
patch. All the guides for that will be 'git revert' and 'git am'. Bisect
is right up there on the list too. And then they'll first grab a tarball
and fail, then do a shallow copy and fail, and then finally get a full
one... :p

BR,
Jani.


>>> Not totally sure, but the shallow clone somehow feels more appropriate
>>> for the use case (reminder, there is a "quickly" in the document title),
>>> even if such a clone is less flexible (e.g. users have to manually add
>>> stable branches they are interested it; and they need to be careful when
>>> using git fetch).
>>>
>>> That's why I now strongly consider using the shallow clone method by
>>> default in v2 of this text. Or does that also create a lot of load on
>>> the servers? Or are there other strong reason why using a shallow clone
>>> might be a bad idea for this use case?
>> 
>> As I mentioned elsewhere, this is only a problem when it's done in batch mode
>> by CI systems. A full clone uses pregenerated pack files and is very cheap,
>> because it's effectively a sendfile operation. A shallow clone requires
>> generating a brand new pack, compressing it, and then keeping it around in
>> memory for the duration of the clone process. Not a big deal when a few humans
>> here and there do it, but when 50 CI nodes do it all at once, it effectively
>> becomes a DDoS. :)
>
> Thx again for your insights, much appreciated.
>
> Ciao, Thorsten
  

On 03.02.23 10:44, Jani Nikula wrote:
> On Thu, 02 Feb 2023, Thorsten Leemhuis <linux@leemhuis.info> wrote:
>> On 02.02.23 16:08, Konstantin Ryabitsev wrote:
>>> On Thu, Feb 02, 2023 at 12:15:36PM +0100, Linux kernel regression tracking (Thorsten Leemhuis) wrote:
>>>> Then I tried creating a shallow clone like this:
>>>>
>>>> git clone
>>>> https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
>>>> --depth 1 -b v6.1
>>>> git remote set-branches --add origin master
>>>> git fetch --all --shallow-exclude=v6.1
>>>> git remote add -t linux-6.1.y linux-stable
>>>> https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
>>>> git fetch --all --shallow-exclude=v6.1
>>>>
>>>> This took only roundabout 2 minutes and downloads & stores ~512 MByte
>>>> data (without checkout).
>>>
>>> Can we also include the option of just downloading the tarball, if it's a
>>> released version? That's the fastest and most lightweight option 100% of the
>>> time. :)
>>
>> Don't worry, that was in there and will stay in there:
>>
>> +   If you plan to only build one particular kernel version, download
>> its source
>> +   archive from https://kernel.org; afterwards extract its content to
>> '~/linux/'
>> +   and change into the directory created during extraction.
> 
> The trouble is, if this is for someone who needs to try kernels for
> debugging, a typical idea is to ask them to revert something or apply a
> patch. All the guides for that will be 'git revert' and 'git am'. Bisect
> is right up there on the list too. And then they'll first grab a tarball
> and fail,

Yeah, those are the reasons why I don't like the tarball approach too
much myself. Guess I should point them out in the text to make readers
aware of them...

> then do a shallow copy and fail,

The new test I wrote (still a draft) will suggest to use a recent
release as base, hence bisection or reverting a patch will be possible.
And if the range turns out to be to shallow, there is still "git fetch
--shallow-exclude=v6.1" to deepen it, which should avoid...

> and then finally get a full one... :p

...this scenario -- at least unless I missed anything.

Ciao, Thorsten

>>>> Not totally sure, but the shallow clone somehow feels more appropriate
>>>> for the use case (reminder, there is a "quickly" in the document title),
>>>> even if such a clone is less flexible (e.g. users have to manually add
>>>> stable branches they are interested it; and they need to be careful when
>>>> using git fetch).
>>>>
>>>> That's why I now strongly consider using the shallow clone method by
>>>> default in v2 of this text. Or does that also create a lot of load on
>>>> the servers? Or are there other strong reason why using a shallow clone
>>>> might be a bad idea for this use case?
>>>
>>> As I mentioned elsewhere, this is only a problem when it's done in batch mode
>>> by CI systems. A full clone uses pregenerated pack files and is very cheap,
>>> because it's effectively a sendfile operation. A shallow clone requires
>>> generating a brand new pack, compressing it, and then keeping it around in
>>> memory for the duration of the clone process. Not a big deal when a few humans
>>> here and there do it, but when 50 CI nodes do it all at once, it effectively
>>> becomes a DDoS. :)
>>
>> Thx again for your insights, much appreciated.
>>
>> Ciao, Thorsten
>
  

Quick update, in case anyone wants an early look at the reworked
sections that likely will soon be posted as part of a v2:

On 02.02.23 12:15, Linux kernel regression tracking (Thorsten Leemhuis)
wrote:
> [adding Konstantin and Greg to the list of recipients]
> 
> On 01.02.23 12:52, Thorsten Leemhuis wrote:
>> Add a text explaining how to quickly build a kernel, as that's something
>> users will often have to do when they want to report an issue or test
>> proposed fixes. This is a huge and frightening task for quite a few
>> users these days, as many rely on pre-compiled kernels and have never
>> built their own. They find help on quite a few websites explaining the
>> process in various ways, but those howtos often omit important details
>> or make things too hard for the 'quickly build just for testing' case
>> that 'localmodconfig' is really useful for. Hence give users something
>> at hand to guide them, as that makes it easier for them to help with
>> testing, debugging, and fixing the kernel.
> 
> Side note: after feedback on social media I'll likely switch to a title
> like "how to quickly configure & build a trimmed-down Linux kernel", as
> some people from the current title assumed this would be about things
> like ccache.

I for now settled for "How to quickly build a trimmed Linux kernel". I
wonder if "adapt" or "attuned" might be better than "trimmed". I'd
appreciate any input from native speakers here.

> I'll also likely will switch to using a localversion file
> in the buildroot instead of modifying the EXTRAVERSION in the top-level
> makefile (but I haven't actually tried it yet).

The section in the step by step guide now reads:

```
 * If you patched your kernel or already have a kernel of the same
version installed, better tag the one you are about to build by
extending its release name::

     echo "-proposed_fix" > ~/linux/build/localversion

   If you build Linux 6.2-rc4 and later execute ``uname -r`` while
running that kernel, it will print '6.2-rc4-proposed_fix'.
```

>> [...]
>>
>> The text currently describes two approaches to retrieve Linux' sources
>> using git: the regular clone with linux-stable as a remote and a shallow
>> clone with just one branch from linux-stable. [...]
>
> [...]>
> That's why I now strongly consider using the shallow clone method by
> default in v2 of this text.

TWIMC, I went down that route and took a bit of back and forth to figure
out a good approach.

The segment in the step-by-step guide now looks like this:

```
 * Retrieve the sources of the Linux version you intend to build; then
change into the directory holding them, as all further commands in this
guide are meant to be executed from there.

   *[Note, the following paragraphs describe how to retrieve the sources
by partially cloning the Linux stable repository. The reference section
explains two alternatives to such a 'shallow clone': packaged archives
and a full clone. Use the latter, if downloading a lot of data does not
bother you, as that will avoid some quirks of shallow clones the
reference section explains.]*

   Execute the following command to retrieve a fresh mainline codebase::

     git clone --no-checkput --depth 1 -b master \
       https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git\
       ~/linux/sources/
     cd ~/linux/sources/

   If you want to access recent mainline releases and pre-releases,
deepen you clone's history to the oldest version you are interested in::

     git fetch --shallow-exclude=v6.1

   In case you want to access a stable/longterm release (say v6.1.5),
simply add the branch holding that series; afterwards fetch the history
up to the mainline version that started the series (v6.1) or is older::

     git remote set-branches --add origin linux-6.1.y
     git fetch --shallow-exclude=v6.1

   Now check out the code you are interested in. If you just performed
the initial clone, you will be able to check out a fresh mainline
codebase ('origin/master') -- it is ideal for checking whether
developers already addressed an issue you face::

      git checkout --detach origin/master

   If you deepened your clone, you instead of 'origin/master' can
specify the version you deepened to; any later releases like 'v6.2' or
pre-release like 'v6.3-rc1' will work, too. Stable or longterm versions
like 'v6.1.5' work just the same, if you added the appropriate
stable/longterm branches as described.

```


The corresponding segment in the reference section got somewhat long and
now looks like this:


```
Download the sources
--------------------

  *Retrieve the sources of the Linux version you intend to build.*
  [:ref:`...<sources_sbs>`]

The step-by-step guide outlines how to retrieve Linux' sources using a
shallow git clone. There is more to tell about this method and two
alternate ways worth describing: packaged archives and a full git clone.
And the aspects 'wouldn't it be wiser to use a proper pre-release than
the latest mainline code' and 'how to get an even fresher mainline
codebase' need elaboration, too.

Unexpected aspects of shallow clones
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

The step-by-step guide uses a shallow clone, as it's the best solution
for most of this document's target audience. There are a few quirks of
this approach worth mentioning:

 * This document in most places uses 'git fetch' with
'--shallow-exclude=' to specify the tag of the earliest version you care
about. You alternatively can use the parameter '--shallow-since=' to
specify an absolute (say '2023-07-15') or relative ('12 months') date to
define the depth of the history you want to download.

 * When running 'git fetch', remember to always specify the oldest
version or time you care about as shown in the step-by-step guide.
Otherwise you'll risk downloading nearly the entire git history, which
will consume quite a bit of time and bandwidth while also stressing the
servers.

   Note, you don't have to use the same version/date all the time, but
when you start using a different one git will deepen or flatten the
history to the specified point. That allows you to retrieve versions you
initially thought you did not need -- or it will discard the sources of
older versions, when you want to free up some disk space. The latter
will happen automatically when using '--shallow-since=' with a relative
date.

 * Be warned, when deepening the history you might encounter an error
like 'fatal: error in object: unshallow
1234567890abcdef1234567890abcdef12345678'. In that case run ``git repack
-d`` and try again.

 * In case you want to revert changes from a certain version (say Linux
6.3) or perform a bisection ending on it (v6.2..v6.3), better tell 'git
fetch' to retrieve objects up to three versions earlier (e.g. 6.0):
``git describe`` will then be able to describe most commits just like it
would in a full tree.

Downloading the sources using a packages archive
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

People new to compiling Linux often assume downloading an archive via
the front-page of https://kernel.org is the best approach to retrieve
Linux' sources. It actually can be, if you are certain to build just one
particular kernel version without changing any code. Thing is: you might
be sure this will be the case, but in practice it then often will turn
out to be a wrong assumption.

That's because when reporting or debugging an issue developers will
often ask to give an earlier or later version a try. They also might
suggest temporarily undoing a commit with 'git revert …' or provide
various patches to try. Sometimes reporters will also be asked to use
'git bisect' to find the change causing a problem. These things rely on
git or are a lot easier and quicker to handle with it.

Additionally, a shallow clone also doesn't add much overhead: when git
is creating one for just the latest mainline codebase it retrieves only
a little more data than downloading a packaged archive would.

A shallow clone therefore is often the better choice. If you
nevertheless want to use a packaged source archive, download one via
kernel.org; afterwards extract its content to '~/linux/' and change to
the directory created during extraction. The rest of the step-by-step
guide will work just fine, apart from things that rely on git -- but
this mainly concerns the section on successive builds of other versions.

Downloading the sources using a full git clone
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

If downloading and storing a lot of data (~4,4 Gigabyte as of early
2023) is nothing that bothers you, instead of a shallow clone perform a
full git clone instead. They are a little easier to handle and will have
the complete development history at hand at any time::

	curl -L
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/clone.bundle
-o ~/linux/linux-stable.git.bundle
	git clone clone.bundle ~/linux/sources/
	rm ~/linux/linux-stable.git.bundle
	cd ~/linux/sources/
	git remote set-url origin
	https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
	git fetch --all
	git checkout --detach origin/master


Proper pre-releases (RCs) vs. latest mainline
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

When cloning the sources using git and checking out origin/master, you
often will retrieve a codebase that is somewhere between the latest and
the next release or pre-release. This almost always is the code you want
when giving mainline a shot: pre-releases like v6.1-rc5 are in no way
special, as they don't get any significant extra testing before being
published.

There is one exception: you might want to stick to the latest mainline
release (say v6.1) before its successor's first pre-release (v6.2-rc1)
is out. That's because compiler errors and other problems are more
likely to occur during this time, as mainline then is in its 'merge
window': a usually two week long phase, in which the bulk of the changes
for the next release is merged.

Avoiding the mainline lag
~~~~~~~~~~~~~~~~~~~~~~~~~

The explanations for both the shallow clone and the full clone both
retrieve the code from the Linux stable git repository. That makes
things simpler for this document's audience, as it allows easy access to
both mainline and stable/longterm releases. This approach has just one
downside:

Changes merged into the mainline repository are only synced to the
master branch of the Linux stable repository  every few hours. This lag
most of the time is not something to worry about; but in case you really
need the latest code, just add the mainline repo as additional remote
and checkout the code from there::

	git remote add mainline
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
	git fetch --all
	git checkout --detach mainline/master
```

Ciao, Thorsten
  

On Fri, Feb 10, 2023 at 12:38:07PM +0100, Thorsten Leemhuis wrote:
> Downloading the sources using a full git clone
> ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> 
> If downloading and storing a lot of data (~4,4 Gigabyte as of early
> 2023) is nothing that bothers you, instead of a shallow clone perform a
> full git clone instead.

As a minor segue, we know we can dramatically reduce the size of the stable
repo (and the stable clone.bundle) if we drop all branches and tags for old
EOL releases and move them to a separate repo (e.g. stable-eol.git).

I have suggested this in the past, but it's not a trivial change:

- it requires a fair amount of git work
- it may disrupt some of the build infra around the world still building EOL
  kernels (for whatever reason)

In my preliminary tests, we easily dropped the size from 4GB to under 3GB.

-K
  

Hi!

> +If your platform uses techniques like Secure Boot, prepare the system to permit
> +starting self-compiled Linux kernels; install compilers and everything else
> +needed for building Linux; make sure to have 15 Gigabyte free space in your home
> +directory. Now run the following commands to download the sources of Linux,
> +which you then use to configure, build and install your own
> kernel::

15GB is quite a lot. Maybe the shallow clone should be given another
chance?

> +       mkdir ~/linux/ ~/linux/sources ~/linux/build
> +       git clone https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git \
> +         ~/linux/sources
> +       cd ~/linux/sources/
> +       # hint: if you don't want to build any stable or longterm kernels, skip the
> +       #   next two commands
> +       git remote add linux-stable \
> +         https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
> +       git fetch --all
> +       # hint: if you want to apply patches, do it at this point (see below for details)
> +       # hint: at this point it's recommended to tag your build (see below for details)
> +       yes "" | make O=~/linux/build/ localmodconfig
> +       # hint: at this point you might want or have to adjust the build configuration
> +       #  (see below for details)
> +       # note: if you are running a Debian kernel, you'll have to adjust the configuration
> +       #  at this point (see below)
> +       make -j $(nproc --all) O=~/linux/build/

Is the complexity of using O= worth it for one-off kernel builds?

Best regards,
								Pavel
  

On 25.02.23 10:17, Pavel Machek wrote:
>> +If your platform uses techniques like Secure Boot, prepare the system to permit
>> +starting self-compiled Linux kernels; install compilers and everything else
>> +needed for building Linux; make sure to have 15 Gigabyte free space in your home
>> +directory. Now run the following commands to download the sources of Linux,
>> +which you then use to configure, build and install your own
>> kernel::
> 
> 15GB is quite a lot. Maybe the shallow clone should be given another
> chance?

It got and made it, see v2:
https://lore.kernel.org/all/8cfcf069d48c1b8d7b83aafe0132f8dad0f1d0ea.1676400947.git.linux@leemhuis.info/

>> +       mkdir ~/linux/ ~/linux/sources ~/linux/build
>> +       git clone https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git \
>> +         ~/linux/sources
>> +       cd ~/linux/sources/
>> +       # hint: if you don't want to build any stable or longterm kernels, skip the
>> +       #   next two commands
>> +       git remote add linux-stable \
>> +         https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
>> +       git fetch --all
>> +       # hint: if you want to apply patches, do it at this point (see below for details)
>> +       # hint: at this point it's recommended to tag your build (see below for details)
>> +       yes "" | make O=~/linux/build/ localmodconfig
>> +       # hint: at this point you might want or have to adjust the build configuration
>> +       #  (see below for details)
>> +       # note: if you are running a Debian kernel, you'll have to adjust the configuration
>> +       #  at this point (see below)
>> +       make -j $(nproc --all) O=~/linux/build/
> 
> Is the complexity of using O= worth it for one-off kernel builds?

That is a good question. I seemed like the right thing to do when I
started writing this guide (maybe just because I've been doing it that
way for ages), but now that you ask I'm unsure myself.

/me wonders how others feel about it

Ciao, Thorsten
  

On 25.02.23 10:29, Thorsten Leemhuis wrote:
> On 25.02.23 10:17, Pavel Machek wrote:
>
>>> +       mkdir ~/linux/ ~/linux/sources ~/linux/build
>>> +       git clone https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git \
>>> +         ~/linux/sources
>>> +       cd ~/linux/sources/
>>> +       # hint: if you don't want to build any stable or longterm kernels, skip the
>>> +       #   next two commands
>>> +       git remote add linux-stable \
>>> +         https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
>>> +       git fetch --all
>>> +       # hint: if you want to apply patches, do it at this point (see below for details)
>>> +       # hint: at this point it's recommended to tag your build (see below for details)
>>> +       yes "" | make O=~/linux/build/ localmodconfig
>>> +       # hint: at this point you might want or have to adjust the build configuration
>>> +       #  (see below for details)
>>> +       # note: if you are running a Debian kernel, you'll have to adjust the configuration
>>> +       #  at this point (see below)
>>> +       make -j $(nproc --all) O=~/linux/build/
>>
>> Is the complexity of using O= worth it for one-off kernel builds?
> 
> That is a good question. I seemed like the right thing to do when I
> started writing this guide (maybe just because I've been doing it that
> way for ages), but now that you ask I'm unsure myself.
> 
> /me wonders how others feel about it

/me should have pondered with the idea for more time before writing aboe
mail, because:

Having thought about this some more, I decided to drop it, the
complexity really is not worth it.

Many thx for the suggestion!

Ciao, Thorsten