CODEWITHSUNDEEP
linuxlinux-kernelkernelinternals
Maro
Maro

Reputation: 91

Why mm_struct->start_stack and vm_area_struct->start don't point to the same address?

As far as I understand memory management in Linux kernel, there is a mm_struct structure responsible for address space in each process. One important memory region is stack. This should be identified by vm_area_struct memory region and mm_struct itself has a pointer mm_struct->stack_start which is stack's address.

I came accross the code below and what I cannot understand is why any of the memory region start/end addresses are not equal to mm_struct->stack_start value. Any help in understanding this would be very much appreciated. Thanks

Some of the results of loading the compiled kernel module:

Vma number 14: Starts at 0x7fff4bb68000, Ends at 0x7fff4bb8a000 Vma number 15: Starts at 0x7fff4bbfc000, Ends at 0x7fff4bbfe000 Vma number 16: Starts at 0x7fff4bbfe000, Ends at 0x7fff4bc00000 Code Segment start = 0x400000, end = 0x400854 Data Segment start = 0x600858, end = 0x600a94 Stack Segment start = 0x7fff4bb88420

One can find that stack segment start (0x7fff4bb88420) belongs to the vma number 14 but I don't know the addresses are different.

Kernel module source code:

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/mm.h>

static int pid_mem = 1;

static void print_mem(struct task_struct *task)
{
        struct mm_struct *mm;
        struct vm_area_struct *vma;
        int count = 0;
        mm = task->mm;
        printk("\nThis mm_struct has %d vmas.\n", mm->map_count);
        for (vma = mm->mmap ; vma ; vma = vma->vm_next) {
                printk ("\nVma number %d: \n", ++count);
                printk("  Starts at 0x%lx, Ends at 0x%lx\n",
                          vma->vm_start, vma->vm_end);
        }
        printk("\nCode  Segment start = 0x%lx, end = 0x%lx \n"
                 "Data  Segment start = 0x%lx, end = 0x%lx\n"
                 "Stack Segment start = 0x%lx\n",
                 mm->start_code, mm->end_code,
                 mm->start_data, mm->end_data,
                 mm->start_stack);
}

static int mm_exp_load(void){
        struct task_struct *task;
        printk("\nGot the process id to look up as %d.\n", pid_mem);
        for_each_process(task) {
                if ( task->pid == pid_mem) {
                        printk("%s[%d]\n", task->comm, task->pid);
                        print_mem(task);
                }
        }
        return 0;
}

static void mm_exp_unload(void)
{
        printk("\nPrint segment information module exiting.\n");
}

module_init(mm_exp_load);
module_exit(mm_exp_unload);
module_param(pid_mem, int, 0);

MODULE_AUTHOR ("Krishnakumar. R, [email protected]");
MODULE_DESCRIPTION ("Print segment information");
MODULE_LICENSE("GPL");

Upvotes: 5

Views: 4458

Answers (2)

Gil Hamilton
Gil Hamilton

Reputation: 12347

Looks like start_stack is the initial stack pointer address. It's calculated by the kernel when the program is executed and is based on the stack section address given in the executable file. I don't think it gets updated at all thereafter. The system uses start_stack in at least one instance: to identify which vma represents "the stack" (when providing /proc/<pid>/maps), as the vma containing that address is guaranteed to contain the (main) stack.

But note that this is only the stack for the "main" (initial) thread; a multi-threaded program will have other stacks too -- one per thread. Since they all share the same address space, all threads will show the same set of vmas, and I think you'll find they all have the same start_stack value as well. But only the main thread's stack pointer will be within the main stack vma. The other threads will each have their own stack vmas -- this is so that each thread's stack can grow independently.

Upvotes: 4

Akr
Akr

Reputation: 199

In general, there is one mm_struct for a process, but many vm_area_struct and each responds for a mmaped area.

For example, in a 32-bit system, a process have a virtual address space of 4GB, all of which is pointed by the mm_struct. However, there can be many regions within the 4GB space. Each of the region is pointed by a vm_area_struct, and this region is limited by the vm_area_struct->start and vm_area_struct->end. So, obviously the mm_struct struct contains a list of vm_area_struct.

Here is the detail introduction.

Upvotes: 3

Related Questions