
Linux 3.6 released - moonboots
https://lkml.org/lkml/2012/9/30/152
======
alexholehouse
OK, so here's a question. I've always wanted to spend some time reading
through the Linux kernel - I really enjoyed operating systems when I studied
it (and reading through MINIX src) but I don't really know where/how to start
with Linux.

I mean, I guess I can just dive in, and maybe that's the best approach, but is
there a strategy anyone would recommend for reading the Linux source in terms
of it making sense as a combined unit of code (as opposed to a collection of
algorithms, if that makes sense)?

~~~
timsally
I recently did exactly what you describe. My first contribution to the Linux
kernel actually shipped with this release. If I recall correctly it took me
about 80 hours to go from no knowledge to first patch. Assuming no knowledge,
it is a two step process.

(1) Learn basic OS concepts through xv6.

xv6 is a reimplementation of an early version of Unix, designed to be as
simple as possible and accompanied by a whole book of commentary. Get the book
and the source cost listing printed and bound:
<http://pdos.csail.mit.edu/6.828/2012/xv6.html>. Work through the book and
exercises. Use the lecture videos from 6.828 from 2011 if you need extra
material in order to understand:
<http://pdos.csail.mit.edu/6.828/2011/schedule.html>.

(2) Pick a part of OSes that you are interested in. Contribute to that part in
Linux.

Figure out where that part is in the Linux kernel. Find a bug in the bug
tracker and submit the patch. I found filesystems interesting, so I fixed a
small bug in one of the filesystems. Use a cross reference, it will save you a
lot of time: <http://lxr.free-electrons.com/source/include/linux/cpu.h>. Also
feel free to subscribe to the Linux kernel subreddit:
<http://www.reddit.com/r/kernel>. I've set up the sidebar with a lot of useful
links.

The Linux kernel is large and complex. You need to equipe yourself with a
mental model of an OS through xv6 and then pick one small, specific part to
attack in Linux. Be tactical! Otherwise you will be overwhelmed.

\--

As an aside, I'm actually currently working on a tool that parses the Linux
source code to find symbol definitions and then works its way back through the
Git history to find the commit message for when the symbol was first defined.
These commit messages usually contain really useful information about the
original intent of the symbol and implementation details. Currently fighting
with a few bugs in my C grammar, but should be able to work through those
soon. Please feel free to email me at tsally@atomicpeace.com if you want to be
pinged when the tool is released.

~~~
nitrogen
_As an aside, I'm actually currently working on a tool that parses the Linux
source code to find symbol definitions and then works its way back through the
Git history to find the commit message for when the symbol was first defined._

Are you just doing something similar to cscope to find the definition of a
symbol, then running git blame on that line? Or are you actually checking
earlier revisions as well, to see if the symbol was moved or changed types?

~~~
timsally
I'm finding the definition of a symbol using a parsing expression grammar for
C. I haven't yet decided upon the particular algorithm for finding the first
commit, but I plan on using libgit2 to work directly with the repository. In
the simplest case, you just iterate through all versions of a file and find
the earliest one with the string in question. Obviously care is required when
walking the repository history.

------
jeltz
See the Kernel newbies page for a good summary of the news in 3.6.

<http://kernelnewbies.org/Linux_3.6>

------
jeffdavis
I'd really like to see btrfs start to stabilize and become more mainstream,
but everything still seems to say that it's experimental.

The main reasons that I want it on my desktop are:

    
    
      * easy backups
      * checksums
      * maybe it will become integrated with package manager (I'm on ubuntu) so that I can roll back package updates if they don't work properly

~~~
rogerbinns
It will be marked as experimental for a long time. There isn't a magical point
at which it will suddenly be perfect and bug free. That said kernel 3.2 was a
major point of stability.
[https://btrfs.wiki.kernel.org/index.php/FAQ#Is_btrfs_stable....](https://btrfs.wiki.kernel.org/index.php/FAQ#Is_btrfs_stable.3F)

It is integrated with the package manager on Ubuntu already. I just upgraded
my laptop to Quantal and part of the upgrade process spotted I was using btrfs
and created a snapshot. (It was a complete waste of time as I have
automatically created hourly, daily, weekly and monthly snapshots.) Doing
regular package updates is very slow with btrfs. This is due to fsync() being
called several times per file.

You'll also want Quantal for an updated btrfs-tools package. For example it
lets you do scrubbing. You also need it (and kernel 3.3+) to change raid
levels after filesystem creation. The Ubuntu 12.04 installer does create and
install to btrfs but didn't let you configure things like raid level so you
were stuck with whatever it did.

I've been running all my systems on btrfs for several months now on Ubuntu
12.04 (kernel 3.2) on both SSD and HDD including using RAID 0, RAID 1,
dmcrypt/LUKS, inplace conversion from ext4 and who knows what else. (Across my
server, workstation, laptop and HTPC.)

The only problem I have had is when filesystems fill up. I've never lost data
but it can be quite frustrating trying to find files to delete (also need to
be removed from snapshots), rebalancing etc to get things running smoothly
again. The various ways of doing df are mostly a work of fiction.

My data is duplicated to offline backups, Dropbox, multiple systems and git/hg
repositories so the failure of any system would be annoying but I'd never lose
anything. You should make sure you are in that position first, independent of
what filesystems are being used.

~~~
jeffdavis
"Doing regular package updates is very slow with btrfs. This is due to fsync()
being called several times per file."

You mean that fsync()s are more expensive on btrfs, or ubuntu calls them more
often when using btrfs for some reason?

~~~
rogerbinns
The former - fsyncs are more expensive because they involve copy on write
updates all the way up the tree to the root. Some of the fsyncs are there
because of ext4 quirks. That all said, every kernel release brings big
improvements in btrfs especially metadata handling. IOW it is currently the
worst it will be.

~~~
jeffdavis
Why not just sync the data change and sync the metadata changes only to a
write-ahead log? Or if the data is logged also, you only need to sync the log.

I assume btrfs uses a log, right?

~~~
rogerbinns
A tree is the main data structure. The inspiration is this pdf
<http://www.usenix.org/events/lsf07/tech/rodeh.pdf>

There is a log to help with fsyncs. <http://en.wikipedia.org/wiki/Btrfs>

------
DASD
TCP Fast Open (client side) is quite interesting. Is anyone aware of testable
server examples/implementations yet?

~~~
nine_k
I suppose [some] Google services may be the server side with Fast Open
support: [http://googlecode.blogspot.com/2012/01/lets-make-tcp-
faster....](http://googlecode.blogspot.com/2012/01/lets-make-tcp-faster.html)

------
DiabloD3
And I still can't sleep my Powerbook /w Radeon because post KMS radeon doesn't
support it yet (no one ported the pre-KMS code from the X driver portion of
radeon into the post-KMS radeon kernel driver).

OTOH, I can just leave KMS off and have no 2D or 3D acceleration.

/rant

------
mtgx
Looking forward to Linux 3.7 with its support for ARM64:

[http://www.phoronix.com/scan.php?page=news_item&px=MTE5N...](http://www.phoronix.com/scan.php?page=news_item&px=MTE5NjQ)

~~~
ajross
The code is already out there, all 3.7 integration would represent is a stamp
of approval. Consider that there is no hardware for the architecture yet, I
don't know why approval would be very interesting:

[http://git.kernel.org/?p=linux/kernel/git/cmarinas/linux-
aar...](http://git.kernel.org/?p=linux/kernel/git/cmarinas/linux-aarch64.git)

------
Nux
Lots of goodies!

~~~
viraptor
From the desktop perspective, I really like the "Suspend to disk and memory at
the same time" part. It's great that you don't have to think anymore if you're
going to use your laptop in the next 2 days or not. If it runs out of power,
it does - nothing gets lost!

Adding bufferbloat pieces into the main release is also good news (although
that probably won't hit the servers that really need it for many more
months...)

~~~
jlgreco
Do you think this will obsolete the 'hybrid suspend' functionality in pm-
utils? I think that works by suspending to ram, waking up in 10 minutes then
immediately suspending to disk.

Maybe a combination of these two approaches could be useful.

