Posted
by
samzenpus
on Wednesday March 07, 2012 @05:00PM
from the read-the-manual dept.

Thinkcloud writes "The Linux From Scratch (LFS) project has published version 7.1 of its manual for building a custom Linux installation. The new release of the step-by-step instructions is 345 pages long and uses more up-to-date components than previous versions – for example, the 3.2.6 Linux kernel and version 4.6.2 of the GNU Compiler Collection (GCC). The update also includes fixes to bootscripts and corrections to the text, as well as updates to 20 packages."

Hmmm. you might be on to something. I'm trying to simultaneously break up with my girlfriend as well as learn more about system administration. Building a LFS box might help me learn to automate a process I'd rather not do manually.

Is that what the kids are calling it these days? I wouldn't know - I'm too busy at my job doing this thing we simply call "work" on systems that were built with exactly that in mind. Of course, that is also one of the reasons why I will not be attempting any LFS builds any time soon.

Right. A bunch of the software in OS X, and a bunch of the libraries that software on it uses are made by the Linux/Unix crowd.
You enjoy Angry Birds though, i'm sure that will be practical experience for a job at some point.

I second this. A couple of years ago I built an LFS system - unfortunately I buggered up the GRUB install somehow and couldn't fix it, so I wound up overwriting it with Slackware instead.
Next time I have a go at it, I'll probably use a desktop rather than a laptop perched on the bed - it was not nice being sat there waiting hours for stuff to compile!

Ten years ago i was an enthusiast of lfs, and i even made a Makefile for automated build of lfs... It was an extremely fun thing to do, and opened my eyes and made me understand that Slackware was the only prebuild distro that anyone should ever need for home use.

I agree completely. I built an LFS system many years ago just to better understand the process a distribution goes through and to get a better grasp of the overall software components and build approaches used by Linux systems overall.

It was a highly educational experience, but I'll stick with Debian-based systems that use APT updates, thank you very much. While educational to roll your own installation, rolling your own updates is incredibly time consuming.

Did it while I was in school. Glad I did it, but wouldn't do it again. Everything was great, but software got out of date quickly, and upgrading anything in the middle of the dependency tree or higher just required too much time and baby-sitting. Just took way too much time to maintain.

If you want something more maintainable I'd suggest Gentoo. It gives you most of the flexibility of LFS, and exposure to enough of what is going on that you're likely to keep learning. It is also a lot easier to keep up-to-date.

LFS is a great learning process that shows you exactly WHAT makes your Linux tick, and what packages depend on eachother. Anyone who uses Linux should do it at least once.

No. Anyone who works with Linux, develops for Linux, is a Linux sysadmin or just happens to be interested should do it at least once. Then there's us who prefer distros of the more automated type (I'd rather avoid terms like "beginner-friendly", "user-friendly" or "bloated" but you probably know what I mean). People who use some flavour of Linux simply because it fits our needs. We shouldn't go anywhere near LFS.

You can build it with clang too. And if you wished the entire userland could be non-FSF as it is in Android. Android uses a BSD licenced C runtime called BIONIC. There are other C runtimes which I assume someone could port, as well as the likes of uClibc which is LGPL but isn't owned by the FSF and could be coupled with Busybox for a userland. Depends on what a person is trying to build of course.

Clang has been able to compile modified versions of the kernel for about 18 months. Here is a summary of the work at the here [lwn.net] time which describes what worked and what didn't. You can track the remaining issues for compilation here [llvm.org]. So while it's not officially supported, clang is able to produce working kernels. This suggests that it is a matter of time, code maturity and will rather than some fundamental problem. Biggest issues appear to relate to some missing register support and 16-bit x86 assembly. Mos

There's a PDF and an HTML version of their manual. With the advent of eBook readers like the Kindle, you think they'd release an eBook version. ePub is more open than Kindle's.mobi, but even an ePub version is easily convertible to.mobi.

There's a PDF and an HTML version of their manual. With the advent of eBook readers like the Kindle, you think they'd release an eBook version. ePub is more open than Kindle's.mobi, but even an ePub version is easily convertible to.mobi.

We use the Docbook XML schema to markup the text of the book. There is support in the Docbook XSL stylesheets for producing ePub output and I tried it once (despite it requiring Ruby which I have no other use for), but the output wasn't particularly good looking. It probably just requires some tweaking to the stock stylesheets, but I didn't have the time to look into it any further than that. I know it's a cop-out, but patches welcome:-)

It would be very welcome, and (cop-out alert) had I had the time I would gladly have taken it as an excuse to learn about ebook formats.

An ebook version would be great, simply because it's searchable. But then, you want to take advantage of the format to create a really good, interactive index, perhaps links to a glossary and to external pages for all the included applications and so on. Suddenly it's no longer a quick format conversion but a whole new document.

There's a PDF and an HTML version of their manual. With the advent of eBook readers like the Kindle, you think they'd release an eBook version. ePub is more open than Kindle's.mobi, but even an ePub version is easily convertible to.mobi.

If only ePub used HTML... then we could write a trivial converter that took HTML pages and zipped them up and call it an ePub.

Oh wait, that's what ePubs are!

Though, ePub uses a restricted subset of HTML - but it does support stuff like CSS. Heck, i think the Kindle format

How about a button to collapse a comment thread? Stick a little toggle button to each displayed comment to collapse/expand it and its children comments.

It would make it easier to skip over off-topic pedantic comment threads (or whatever thread the reader prefer to disregard) that often run interminably long while burying more germane comments far down in the page.

By "collapsing" I mean to hide the child comments entirely including the subjects, with just a marker button, perhaps on the root comment's subject line, to indicate if there is any child comments. This way the comment thread/subtree I'm not interested in will not take up any vertical space.

Well... the last I built an LFS system, I went to the only source of a known functional toolchain without jumping through 300 needless hoops I could think of... I unpacked a Gentoo stage3, chrooted, and started my LFS build from there (which, no, does not mean a necessity to actually *install* Gentoo on the host system. I was working from an old RIP USB I had on hand).

As someone who is currently undergoing a LFS install into a VirtualBox VM, I can confirm that the use of a live environment (live-CD, or what-have you) works perfectly. I am currently building my LFS under the Linux Mint 11 x86 gnome CD.
As for the build itself - wheeee!

You're coming as close as you can to building Linux on a bare machine without manually inputing machine code - the purpose of the host machine is to give you things like:
* a running kernel
* a shell
* a C compiler
* a linker
* The standard C libraries
* Some very basic text processing tools, like awk and sed
* A way to download the source code
* A way to set up a file system on the diskIIRC, Linus Torvalds used an existing Unix for most of this when he was first writing Linux.

The first steps involve setting up a completely empty partition, then compiling the C library (glibc), linker (binutils), C compiler (gcc), a shell (bash), and a few other tools. Then you chroot onto the partition you just set up and work in your chroot jail, with the only dependency on the original distro being the running kernel. Once you get to the point of having a bootable system, you leave the original distro completely behind.

This is all true... but... the previous poster is complaining about the lack of a live cd, and i agree with them.
I built my LFS system from their live cd (a few years ago now), and i suspect a lot of folk would like to approach it this way.
If you are starting with bare metal, a convenient livecd is exactly what you need.