I&#39;m running Vagrant (1.8.1) + VirtualBox (5.0.12) on Windows 7 and trying to boot up a Windows 7 image (modernIE/w7-ie8). However, I get this error:

    ---------------------------
    VirtualBox - Error In supR3HardenedWinReSpawn
    ---------------------------
    &lt;html&gt;&lt;b&gt;NtCreateFile(\Device\VBoxDrvStub) failed: 0xc0000034 STATUS_OBJECT_NAME_NOT_FOUND (0 retries) (rc=-101)&lt;/b&gt;&lt;br/&gt;&lt;br/&gt;Make sure the kernel module has been loaded successfully.&lt;br&gt;&lt;br&gt;&lt;!--EOM--&gt;where: supR3HardenedWinReSpawn
    what:  3
    VERR_OPEN_FAILED (-101) - File/Device open failed.

    Driver is probably stuck stopping/starting. Try &#39;sc.exe query vboxdrv&#39; to get more information about its state. Rebooting may actually help.&lt;/html&gt;
    ---------------------------
    OK
    ---------------------------


I ran the query command, but the service &quot;is not found&quot;.

    &gt; sc.exe query vboxdrv
    [SC] EnumQueryServicesStatus:OpenService FAILED 1060:

    The specified service does not exist as an installed service.

I tried rebooting, too. Nothing.

Cannot boot Windows guest in VirtualBox without kernel module error

What are the most common and why not uncommon methods and tools used to do live debugging on the Linux kernel? I know that Linus for eg. is [against](http://lwn.net/2000/0914/a/lt-debugger.php3) this kind of debugging for the Linux Kernel or it least was and thus nothing much has been done in that sense in those years, but honestly a lot of time has passed since 2000 and i am interested if that mentality has changed regarding the Linux project and what current methods are used to do live debugging on the Linux kernel at the moment(either local or remote)?

References to walkthroughs and tutorials on mentioned techniques and tools are welcome.

Linux kernel live debugging, how it&#39;s done and what tools are used?

I&#39;m trying to get a kernel module to load at boot.

If I run `insmod /path/to/module.ko`, it works fine. But this has to be repeated every time I reboot.

If I run `modprobe /path/to/module.ko`, it can&#39;t find the module.
I know modprobe uses a configuration file, but I can&#39;t get it to load the module even after adding /path/to/module.ko to /etc/modules.

What is the proper configuration?



How do I configure modprobe to find my module?

I want to learn lLinux Kernel programming.

What would be the starting points for that? What could be some of the simpler problems to target?

Learning Kernel Programming

I&#39;m learning the linux kernel internals and while reading &quot;Understanding Linux Kernel&quot;, quite a few memory related questions struck me. One of them is, how the Linux kernel handles the memory mapping if the physical memory of say only 512 MB is installed on my system. 

As I read, kernel maps **0(or 16) MB-896MB** physical RAM into 0xC0000000 linear address and can directly address it. So, in the above described case where I only have 512 MB:

 - How can the kernel map 896 MB from only 512 MB ? In the scheme described, the kernel set things up so that every process&#39;s page tables mapped virtual addresses from 0xC0000000 to 0xFFFFFFFF (1GB) directly to physical addresses from 0x00000000 to 0x3FFFFFFF (1GB). But when I have only 512 MB physical RAM, how can I map, virtual addresses from 0xC0000000-0xFFFFFFFF to physical 0x00000000-0x3FFFFFFF ? Point is I have a physical range of only  0x00000000-0x20000000.

 - What about user mode processes in this situation? 

 - Every article explains only the situation, when you&#39;ve installed 4 GB of memory and the kernel maps the 1 GB into kernel space and user processes uses the remaining amount of RAM.

I would appreciate any help in improving my understanding.

Thanks..!

How does the linux kernel manage less than 1GB physical memory?

How does Linux determine the next PID it will use for a process?  The purpose of this question is to better understand the Linux kernel.  Don&#39;t be afraid to post kernel source code.  If PIDs are allocated sequentially how does Linux fill in the gaps?  What happens when it hits the end?

For example if I run a PHP script from Apache that does a `&lt;?php print(getmypid());?&gt;` the same PID will be printed out for a few minutes while hit refresh.  This period of time is a function of how many requests apache is receiving. Even if there is only one client the PID will eventually change. 

When the PID changes, it will be a close number,  but how close? The number does not appear to be entirely sequential. If I do a `ps aux | grep apache` I get a fair number of processes:

![enter image description here][1]

  How does Linux choose this next number?  The previous few PID&#39;s are still running, as well as the most recent PID that was printed.   How does apache choose to reuse these PIDs? 


  [1]: http://i.stack.imgur.com/XYU90.png

How does Linux determine the next PID?

What is the difference between Trap and Interrupt?

If the terminology is different for different systems, then what do they mean on x86?

What is the difference between Trap and Interrupt?

What is the difference between the kernel space and the user space? Do kernel space, kernel threads, kernel processes and kernel stack mean the same thing? Also, why do we need this differentiation?

What is the difference between the kernel space and the user space?

I am not able to understand the difference between a kernel and an operating system. I do not see any difference between them. Is the kernel an operating system?


What is an OS kernel ? How does it differ from an operating system?

I am trying to understand the `dmesg` timestamp and find it hard to convert that to change it to java date/custom date format.

Sample dmesg log: 

    [14614.647880] airo(eth1): link lost (missed beacons)

So how do I convert `14614.647880` to a standard date?

How do I convert dmesg timestamp to custom date format?

I primarily use vim / gvim as an editor and am looking at using a combination of [lxr (the Linux Cross Reference)][lxr] and either [cscope] or [ctags] for exploring the kernel source.  However, I haven&#39;t ever used either [cscope] or [ctags] and would like to hear why one might choose one over the other taking into consideration my use of vim as a primary editor.


  [lxr]: http://lxr.linux.no/
  [cscope]: http://cscope.sourceforge.net/
  [ctags]: http://ctags.sourceforge.net/

cscope or ctags why choose one over the other?

Could anyone please explain with examples difference between monolithic and micro kernel? Also other classifications of the kernel?

What is difference between monolithic and micro kernel?

One thing I&#39;ve always wanted to do is develop my very own operating system (not necessarily fancy like Linux or Windows, but better than a simple boot loader which I&#39;ve already done).

I&#39;m having a hard time finding resources/guides that take you past writing a simple &quot;Hello World&quot; OS.  

I know lots of people will probably recommend I look at Linux or BSD; but the code base for systems like that is (presumably) so big that I wouldn&#39;t know where to start.

Any suggestions?

Update: To make it easier for people who land on this post through Google here are some OS development resources:

 - [Writing Your Own Operating System][1] (Thanks Adam)

 - [Linux From Scratch][2] (Thanks John)

 - [SharpOS (C# Operating System)][3] (Thanks lomaxx)

 - [Minix3][4] and [Minix2][5] (Thanks Mike)

 - [OS Dev Wiki][6] and [Forums][7] (Thanks Steve)

 - [BonaFide][8] (Thanks Steve)

 - [Bran][9] (Thanks Steve)

 - [Roll your own toy UNIX-clone OS][10] (Thanks Steve)

 - [Broken Thorn OS Development Series][11]

Other resources:

I found a nice resource named [MikeOS][12], &quot;MikeOS is a learning tool to demonstrate how simple OSes work. It uses 16-bit real mode for BIOS access, so that it doesn&#39;t need complex drivers&quot;

*Updated 11/14/08* 

I found some resources at [Freebyte&#39;s Guide to...Free and non-free Operating Systems][13] that links to kits such as OSKit and ExOS library.  These seem super useful in getting started in OS development.

*Updated 2/23/09*

[Ric Tokyo][14] recommended [nanoos][15] in this [question][16].  Nanoos is an OS written in C++.

*Updated 3/9/09*

Dinah provided some useful Stack Overflow discussion of aspiring OS developers: [Roadblocks in creating a custom operating system][17] discusses what pitfalls you might encounter while developing an OS
and [OS Development][18] is a more general discussion.

*Updated 7/9/09*

LB provided a link to the [Pintos Project][19], an education OS designed for students learning OS development.

*Updated 7/27/09 (Still going strong!)*

I stumbled upon an [online OS course][20] from Berkley featuring 23 lectures.

[TomOS][21] is a fork of [MikeOS][12] that includes a little memory manager and mouse support. As MikeOS, it is designed to be an educational project.  It is written in NASM assembler.

*Updated 8/4/09*

I found the [slides and other materials][22] to go along with the online Berkeley lectures listed above. 

*Updated 8/23/09*

All [questions tagged osdev][23] on stackoverflow

[OS/161][24] is an academic OS written in c that runs on a simulated hardware.  This OS is similar in Nachos.  Thanks Novelocrat!

tangurena recommends [http://en.wikipedia.org/wiki/MicroC/OS-II][25], an OS designed for embedded systems.  There is a [companion book][26] as well.

[Linux Kernel Development][27] by Robert Love is suggested by Anders.  It is a &quot;widely acclaimed insider&#39;s look at the Linux kernel.&quot;

*Updated 9/18/2009*

Thanks Tim S. Van Haren for telling us about [Cosmos][28], an OS written entirely in c#.

tgiphil tells us about [Managed Operating System Alliance (MOSA) Framework][29], &quot;a set of tools, specifications and source code to foster development of managed operating systems based on the Common Intermediate Language.&quot;

*Update 9/24/2009*

Steve found a couple resources for development on windows using Visual Studio, check out [BrokenThorn&#39;s guide setup with VS 2005][30] or [OSDev&#39;s VS Section][31].

*Updated 9/5/2012*

kerneltrap.org is no longer available.  The linux kernel v0.01 is available from [kernel.org][32]

*Updated 12/21/2012*
A basic OS development [tutorial][33] designed to be a semester&#39;s project. It guides you through to build an OS with basic components. Very good start for beginners. Related [paper][34].  Thanks Srujan!

*Updated 11/15/2013*

[Writing a Simple Operating System From Scratch][35].  Thanks James Moore!


*Updated 12/8/2013*

[How to make a computer operating system][36]  Thanks ddtoni!

*Updated 3/18/2014*

[ToAruOS an OS built mostly from scratch, including GUI][37]

*Updated Sept 12 2016*

[Writing your own Toy Operating System][38]

*Updated Dec 10 2016*

[Writing a Simple Operating System —from Scratch][39] (thank you @Tyler C)


  [1]: https://web.archive.org/web/20120506110242/http://osix.net/modules/article/?id=359
  [2]: http://www.linuxfromscratch.org/
  [3]: http://en.wikipedia.org/wiki/SharpOS_(operating_system)
  [4]: http://www.minix3.org/
  [5]: http://minix1.woodhull.com/mxdownld.html
  [6]: http://wiki.osdev.org/Main_Page
  [7]: http://forum.osdev.org/
  [8]: http://www.osdever.net/
  [9]: http://osdever.net/bkerndev/Docs/intro.htm
  [10]: http://www.jamesmolloy.co.uk/tutorial_html/index.html
  [11]: http://www.brokenthorn.com/Resources/OSDevIndex.html
  [12]: http://mikeos.berlios.de/
  [13]: http://www.freebyte.com/operatingsystems/#osprojects
  [14]: https://stackoverflow.com/users/42019/ric-tokyo
  [15]: http://code.google.com/p/nanoos/
  [16]: https://stackoverflow.com/questions/580308/making-an-os-in-c/580362#580362
  [17]: https://stackoverflow.com/questions/340674/roadblocks-in-creating-a-custom-operating-system
  [18]: https://stackoverflow.com/questions/130065/os-development
  [19]: http://www.scs.stanford.edu/07au-cs140/pintos/pintos.html
  [20]: http://academicearth.org/courses/operating-systems-and-system-programming
  [21]: http://tomos.sourceforge.net/
  [22]: http://www.cs.berkeley.edu/~kubitron/courses/cs162-F08/
  [23]: https://stackoverflow.com/questions/tagged/osdev
  [24]: http://www.eecs.harvard.edu/syrah/os161/
  [25]: http://en.wikipedia.org/wiki/MicroC/OS-II
  [26]: http://www.amazon.com/MicroC-OS-II-Kernel-CD-ROM/dp/1578201039/ref=sr_1_1?ie=UTF8&amp;s=books&amp;qid=1250989337&amp;sr=8-1
  [27]: http://www.amazon.com/Linux-Kernel-Development-Novell-Press/dp/0672327201/ref=sr_1_1?ie=UTF8&amp;s=books&amp;qid=1250989567&amp;sr=1-1
  [28]: http://www.gocosmos.org/index.en.aspx
  [29]: http://www.mosa-project.org/
  [30]: http://www.brokenthorn.com/Resources/OSDevMSVC.html
  [31]: http://wiki.osdev.org/Visual%5FStudio
  [32]: http://www.kernel.org/pub/linux/kernel/Historic/linux-0.01.tar.gz
  [33]: http://nw08.american.edu/~mblack/teaching.html#OSPROJECT
  [34]: http://nw08.american.edu/~mblack/papers/sigcse09.pdf
  [35]: http://www.cs.bham.ac.uk/~exr/lectures/opsys/10_11/lectures/os-dev.pdf
  [36]: https://github.com/SamyPesse/How-to-Make-a-Computer-Operating-System
  [37]: https://github.com/klange/toaruos
  [38]: http://www.independent-software.com/writing-your-own-toy-operating-system/
  [39]: https://www.cs.bham.ac.uk/~exr/lectures/opsys/10_11/lectures/os-dev.pdf

What are some resources for getting started in operating system development?

I do not understand the difference between operating system and kernel. Can someone please explain it?

What is the difference between the operating system and the kernel?

This is a second-hand question from an OS development site, but it made me curious since I couldn&#39;t find a decent explanation anywhere.

When compiling and linking a free-standing C++ program using gcc, sometimes a linker error like this occurs:

    out/kernel.o:(.eh_frame+0x11): undefined reference to `__gxx_personality_v0&#39;

This is apparently because this symbol is defined in libstdc++, which is missing in a free-standing environment. Fixing the problem simply requires defining this symbol somewhere:

    void *__gxx_personality_v0;

Which is nice, but I don&#39;t like things that just magically work... So the question is, what is the purpose of this symbol?

What is __gxx_personality_v0 for?

I did `sudo cat /proc/1/maps -vv`

I am attempting to make sense of the output.I can see a lot of shared libraries being mapped to the memory mapping segment as expected.

    7f3c00137000-7f3c00179000 r-xp 00000000 08:01 21233923                   /lib/x86_64-linux-gnu/libdbus-1.so.3.5.8
    7f3c00179000-7f3c00379000 ---p 00042000 08:01 21233923                   /lib/x86_64-linux-gnu/libdbus-1.so.3.5.8
    7f3c00379000-7f3c0037a000 r--p 00042000 08:01 21233923                   /lib/x86_64-linux-gnu/libdbus-1.so.3.5.8
    7f3c0037a000-7f3c0037b000 rw-p 00043000 08:01 21233923                   /lib/x86_64-linux-gnu/libdbus-1.so.3.5.8
    7f3c0037b000-7f3c00383000 r-xp 00000000 08:01 21237216                   /lib/x86_64-linux-gnu/libnih-dbus.so.1.0.0
    7f3c00383000-7f3c00583000 ---p 00008000 08:01 21237216                   /lib/x86_64-linux-gnu/libnih-dbus.so.1.0.0
    7f3c00583000-7f3c00584000 r--p 00008000 08:01 21237216                   /lib/x86_64-linux-gnu/libnih-dbus.so.1.0.0
    7f3c00584000-7f3c00585000 rw-p 00009000 08:01 21237216                   /lib/x86_64-linux-gnu/libnih-dbus.so.1.0.0
    7f3c00585000-7f3c0059b000 r-xp 00000000 08:01 21237220                   /lib/x86_64-linux-gnu/libnih.so.1.0.0
    7f3c0059b000-7f3c0079b000 ---p 00016000 08:01 21237220                   /lib/x86_64-linux-gnu/libnih.so.1.0.0
    7f3c0079b000-7f3c0079c000 r--p 00016000 08:01 21237220                   /lib/x86_64-linux-gnu/libnih.so.1.0.0

Towards the end there is something like

    7f3c0165b000-7f3c0177e000 rw-p 00000000 00:00 0                          [heap]
    7fff97863000-7fff97884000 rw-p 00000000 00:00 0                          [stack]
    7fff97945000-7fff97946000 r-xp 00000000 00:00 0                          [vdso]
    ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0                  [vsyscall]

What does `vdso` and `vsyscall` mean? is vsyscall the kernel portion of the memory? It would be great if anyone can throw some light on the issue.



What are vdso and vsyscall?

From [sys.c][1] line 123:

    void *sys_call_table[__NR_syscalls] = 
    {
        [0 ... __NR_syscalls-1] = sys_ni_syscall,
    #include &lt;asm/unistd.h&gt;
    };

`sys_call_table` is a generic pointer to arrays, I can see that. However what is the notation:    

    [0 ... __NR_syscalls-1]

What is the `...`?


----------


**EDIT:**     
I learned another C trick here: `#include &lt;asm/unistd.h&gt;` will be *preprocessed* and replaced with its content and assigned to `[0 ... _NR_syscalls-1]`.

  [1]: http://lxr.linux.no/#linux+v3.3.1/arch/unicore32/kernel/sys.c#L123

What does [ N ... M ] mean in C aggregate initializers?

We are looking to upgrade the OS on our servers from Ubuntu 10.04 LTS to Ubuntu 12.04 LTS. Unfortunately, it seems that the latency to run a thread that has become runnable has significantly increased from the 2.6 kernel to the 3.2 kernel. In fact the latency numbers we are getting are hard to believe.

Let me be more specific about the test. We have a program that runs two threads. The first thread gets the current time (in ticks using RDTSC) and then signals a condition variable once a second. The second thread waits on the condition variable and wakes up when it is signaled. It then gets the current time (in ticks using RDTSC). The difference between the time in the second thread and the time in the first thread is computed and displayed on the console. After this the second thread waits on the condition variable once more. It will be signaled again by the first thread after about a second passes. 

So, in a nutshell we get a *thread to thread communication via condition variable* latency measurement once a second as a result.

In kernel 2.6.32, this latency is somewhere on the order of 2.8-3.5 us, which is reasonable. In kernel 3.2.0, this latency has increased to somewhere on the order of 40-100 us. I have excluded any differences in hardware between the two hosts. They run on identical hardware (dual socket X5687 {Westmere-EP} processors running at 3.6 GHz with hyperthreading, speedstep and all C states turned off). The test app changes the affinity of the threads to run them on independent physical cores of the same socket (i.e., the first thread is run on Core 0 and the second thread is run on Core 1), so there is no bouncing of threads on cores or bouncing/communication between sockets.

The only difference between the two hosts is that one is running Ubuntu 10.04 LTS with kernel 2.6.32-28 (the fast context switch box) and the other is running the latest Ubuntu 12.04 LTS with kernel 3.2.0-23 (the slow context switch box). All BIOS settings and hardware are identical.

Have there been any changes in the kernel that could account for this ridiculous slow down in how long it takes for a thread to be scheduled to run?

**Update:**
If you would like to run the test on your host and linux build, I have [posted the code to pastebin] for your perusal. Compile with:

    g++ -O3 -o test_latency test_latency.cpp -lpthread

Run with (assuming you have at least a dual-core box):

    ./test_latency 0 1 # Thread 1 on Core 0 and Thread 2 on Core 1

[posted the code to pastebin]: http://pastebin.com/3sx8Vhf1

**Update 2**:
After much searching through kernel parameters, posts on kernel changes and personal research, I have figured out what the problem is and have posted the solution as an answer to this question.


Context switches much slower in new linux kernels

In Linux, what happens to the state of a process when it needs to read blocks from a disk? Is it blocked? If so, how is another process chosen to execute?

Linux Process States

As far as I know, `initrd` acts as a block device, thus requiring a filesystem driver (such as `ext2`). The kernel must have at least one built-in module for detecting filesystem of `initrd`. In this article, [Introducing initramfs, a new model for initial RAM disks][1], it is written that:

&gt; But ramdisks actually waste even more memory due to caching. Linux is
&gt; designed to cache all files and directory entries read from or written
&gt; to block devices, so Linux copies data to and from the ramdisk into
&gt; the &quot;page cache&quot; (for file data), and the &quot;dentry cache&quot; (for
&gt; directory entries). The downside of the ramdisk pretending to be a
&gt; block device is it gets treated like a block device.

What&#39;s `page cache` and `dentry cache`? In the paragraph, does it mean the data got duplicated because `ramdisk` is treated as a block device, thus all the data is cached?

In constrast, `ramfs`:

&gt; A few years ago, Linus Torvalds had a neat idea: what if Linux&#39;s cache
&gt; could be mounted like a filesystem? Just keep the files in cache and
&gt; never get rid of them until they&#39;re deleted or the system reboots?
&gt; Linus wrote a tiny wrapper around the cache called &quot;ramfs&quot;, and other
&gt; kernel developers created an improved version called &quot;tmpfs&quot; (which
&gt; can write the data to swap space, and limit the size of a given mount
&gt; point so it fills up before consuming all available memory). Initramfs
&gt; is an instance of tmpfs.
&gt; 
&gt; These ram based filesystems automatically grow or shrink to fit the
&gt; size of the data they contain. Adding files to a ramfs (or extending
&gt; existing files) automatically allocates more memory, and deleting or
&gt; truncating files frees that memory. There&#39;s no duplication between
&gt; block device and cache, because there&#39;s no block device. The copy in
&gt; the cache is the only copy of the data. Best of all, this isn&#39;t new
&gt; code but a new application for the existing Linux caching code, which
&gt; means it adds almost no size, is very simple, and is based on
&gt; extremely well tested infrastructure.

In sum, `ramfs` is just file opened and loaded into memory, isn&#39;t it? 

Both `initrd` and `ramfs` are zipped at compile time, but the difference is, `initrd` is a block device unpacked to be mounted by the kernel at booting, while `ramfs` is unpacked via cpio into memory. Am I correct? Or is `ramfs` a very minimal file system?

Finally, up until this day, the `initrd` image is still presented in the latest kernel. However, is that `initrd` actually the `ramfs` used today and the name is just for historical purpose? 

  [1]: http://www.linuxfordevices.com/c/a/Linux-For-Devices-Articles/Introducing-initramfs-a-new-model-for-initial-RAM-disks/

The difference between initrd and initramfs?

If I load a kernel module and list the loaded modules with `lsmod`, I can get the &quot;use count&quot; of the module (number of other modules with a reference to the module). Is there a way to figure out _what_ is using a module, though?

The issue is that a module I am developing insists its use count is 1 and thus I cannot use `rmmod` to unload it, but its &quot;by&quot; column is empty. This means that every time I want to re-compile and re-load the module, I have to reboot the machine (or, at least, I can&#39;t figure out any other way to unload it).

Is there a way to figure out what is using a Linux kernel module?

What is the correct interpretation of the following segfault messages?

```none
segfault at 10 ip 00007f9bebcca90d sp 00007fffb62705f0 error 4 in libQtWebKit.so.4.5.2[7f9beb83a000+f6f000]
segfault at 10 ip 00007fa44d78890d sp 00007fff43f6b720 error 4 in libQtWebKit.so.4.5.2[7fa44d2f8000+f6f000]
segfault at 11 ip 00007f2b0022acee sp 00007fff368ea610 error 4 in libQtWebKit.so.4.5.2[7f2aff9f7000+f6f000]
segfault at 11 ip 00007f24b21adcee sp 00007fff7379ded0 error 4 in libQtWebKit.so.4.5.2[7f24b197a000+f6f000]
```



Interpreting segfault messages

I want to learn and fill gaps in my knowledge with the help of this question.

So, a user is running a thread (kernel-level) and it now calls `yield` (a system call I presume).
The scheduler must now save the context of the current thread in the TCB (which is stored in the kernel somewhere) and choose another thread to run and loads its context and jump to its `CS:EIP`. 
To narrow things down, I am working on Linux running on top of x86 architecture. Now, I want to get into the details:

So, first we have a system call:

1) The wrapper function for `yield` will push the system call arguments onto the stack. Push the return address and raise an interrupt with the system call number pushed onto some register (say `EAX`). 

2) The interrupt changes the CPU mode from user to kernel and jumps to the interrupt vector table and from there to the actual system call in the kernel.

3) I guess the scheduler gets called now and now it must save the current state in the TCB. Here is my dilemma. Since, the scheduler will use the kernel stack and not the user stack for performing its operation (which means the `SS` and `SP` have to be changed) how does it store the state of the user without modifying any registers in the process. I have read on forums that there are special hardware instructions for saving state but then how does the scheduler get access to them and who runs these instructions and when?

4) The scheduler now stores the state into the TCB and loads another TCB.

5) When the scheduler runs the original thread, the control gets back to the wrapper function which clears the stack and the thread resumes.

Side questions: Does the scheduler run as a kernel-only thread (i.e. a thread which can run only kernel code)? Is there a separate kernel stack for each kernel-thread or each process? 

Context switch internals

I was hoping someone could explain the nuances of the __user macro used in the linux kernel source.

First of all, the macro:

    # define __user         __attribute__((noderef, address_space(1)))

Now, after some googling I read that this macro allows one to designate a pointer as belonging to the user address space, and that it should not be dereferenced.

I may be missing some obvious facts, but could someone please explain the implications of such a macro? For instance, what is a good example of where this macro would be of use? Again, forgive me if I am missing something obvious.

To put this in some context, I came accross the macro while examining some USB code (linux/usbdevice_fs.h). I am only looking for a general understanding of this macros( or others like it) use within the kernel.

Thanks for looking!

What are the implications of the linux __user macro?

I read that Mac OS X and bsd are related. How closely are they related. Can Mac OS X software be tweaked and installed on BSD?

How closely are Mac OS X and BSD related?

Explained in your own words, what is preemption and what does it mean to a (linux) kernel? 

What are advantages and disadvantages in having a preemptible kernel?

What is preemption / What is a preemtible kernel? What is it good for?

looking at the linux kernel source, I found this:


    static struct tty_operations serial_ops = {
      .open = tiny_open,
      .close = tiny_close,
      .write = tiny_write,
      .write_room = tiny_write_room,
      .set_termios = tiny_set_termios,
    };

I&#39;ve never seen such a notation in C.
Why is there a dot before the variable name?


What does a dot before the variable name in struct mean?

I think many developers like to investigate sources with the help of `git gui blame`. As explained in the [commit for Linux-2.6.12-rc2][2] (also [mirrored at Github][1]), it needs to have special historical Linux repository for this purpose.

&gt; ### Linux-2.6.12-rc2

&gt; Initial git repository build. I’m not bothering with the full history,
even though we have it. We can create a separate “historical” git
archive of that later if we want to, and in the meantime it’s about
3.2GB when imported into git — space that would just make the early
git days unnecessarily complicated, when we don’t have a lot of good
infrastructure for it.

&gt; Let it rip!

I have looked at a lot of the prepared historical repositories but I didn’t find one containing changes going back to version zero, so I gave up and am asking this question here.

[1]: https://github.com/torvalds/linux/commit/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2
[2]: https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=1da177e4c3f41524e886b7f1b8a0c1fc7321cac2

Linux kernel &quot;historical&quot; git repository with full history

I have been experimenting with getting `kgdb` to work the Nexus One.

I have pulled the kernel from https://android.googlesource.com and enabled everything to do with `kgdb` including `kgdbts` testing using `menuconfig`. Successfully built the kernel and flashed it to the device (which is unlocked rooted and running CyanogenMod 7)

I have also followed the instructions found on  http://bootloader.wikidot.com/android:kgdb to enable the usb connection to act as a serial connection as required by `kgdb` (and tested communications from `ttyACM0` to `ttyGS0` successfully).

The following folders exist indicating that `kgdboc` and `kgdbts` have been built into the kernel:

    /sys/modules/kgdboc/parameters
    /sys/modules/kgdbts/parameters

The following is the output from dmesg showing the `kgdbts` testing being done show what (I think) is a successful completion of the tests:


    # dmesg | grep kgdb
    &lt;6&gt;[   12.974060] kgdb: Registered I/O driver kgdbts.
    &lt;6&gt;[   12.981781] kgdbts:RUN plant and detach test
    &lt;6&gt;[   12.995178] kgdbts:RUN sw breakpoint test
    &lt;6&gt;[   13.002441] kgdbts:RUN bad memory access test
    &lt;6&gt;[   13.010864] kgdbts:RUN singlestep test 1000 iterations
    &lt;6&gt;[   13.019042] kgdbts:RUN singlestep [0/1000]
    &lt;6&gt;[   13.077850] kgdbts:RUN singlestep [100/1000]
    &lt;6&gt;[   13.132720] kgdbts:RUN singlestep [200/1000]
    &lt;6&gt;[   13.187500] kgdbts:RUN singlestep [300/1000]
    &lt;6&gt;[   13.242370] kgdbts:RUN singlestep [400/1000]
    &lt;6&gt;[   13.297149] kgdbts:RUN singlestep [500/1000]
    &lt;6&gt;[   13.351928] kgdbts:RUN singlestep [600/1000]
    &lt;6&gt;[   13.406829] kgdbts:RUN singlestep [700/1000]
    &lt;6&gt;[   13.461578] kgdbts:RUN singlestep [800/1000]
    &lt;6&gt;[   13.516540] kgdbts:RUN singlestep [900/1000]
    &lt;6&gt;[   13.570922] kgdbts:RUN do_fork for 100 breakpoints
    &lt;6&gt;[   21.117645] kgdb: Unregistered I/O driver kgdbts, debugger disabled.



I believe that the problem I am running into is getting the kernel to trigger `kgdb`.

    # echo -n g &gt; /proc/sysrq-trigger


Just results in dropping me back to the command prompt and (I think) it is suppose to freeze everything and send a prompt over usb which is being used as a psuedo serial port since the phone doesn&#39;t have a real one.

From what I gather from my research that prompt is supposed to be the trigger that will allow me to issue

    (gdb) target remote /dev/ttyACM0

And connect to a debugging session with the kernel.

I have also tested `/proc/sysrq-trigger` with `b` and `c` just confirm that I am able to pass some commands to `sysrq`.

So my question following my long winded attempt to provide as much information as possible is why is `g` not triggering the debugger? 

This is my first attempt at kernel debugging on any system and I have run out of ways to phrase my search on google so I turn to you. Thanks!

(I have also tried putting kdgbwait in the kernel command line without success as I believe this is not yet supported by the android kernel)


Android Kernel Debugging

The title might not be clear enough because I don&#39;t know how to define my questions actually.

I understand Pthread is a thread library meeting POSIX standard (about POSIX, see wikipedia: http://en.wikipedia.org/wiki/Posix). It is available in Unix-like OS.

About thread, I read that there are three different models:

**User level thread:** the kernel does not know it. User himself creates/implements/destroy threads.

**Kernel level thread:** kernel directly supports multiple threads of control in a process.

**Light weight process(LWP):** scheduled by kernel but can be bounded with user threads.

Did you see my confusion? When I call `pthread_create()` to create a thread, did I create a user level thread? I guess so. So can I say, Pthread offers a user level solution for threads? It can not manipulate kernel/LWP?

All Kernel Solutions on Gang of Coders

Total of 30 Kernel Solutions