HeJian E-Commerce Consult

Pages
Page is the basic unit of memory managed by Linux memory manager. Read more…

Page Tables
To access physical memory, every process must go through the paging system. In or to be able to access any physical page, the page must be in your page tables. Every process has it’s own page tables.

Kernel Space & User Space
The Kernel Space is a set of addresses that contains kernel code+kernel related structures

The User Space is an area of the memory used by user mode applications.

Kernel space and user space always refer to the virtual addresses, and in return these virtual addresses points to the physical addresses through page tables.

Checks if a user space pointer is valid:

access_ok ( type, addr, size);


Process Address Space
The process address space is described by the mm_struct struct. Only one exists for each process and is shared between threads:

struct mm_struct {
struct vm_area_struct * mmap; /* list of VMAs */
struct rb_root mm_rb;
struct vm_area_struct * mmap_cache; /* last find_vma result */
unsigned long (*get_unmapped_area) (struct file *filp,
unsigned long addr, unsigned long len,
unsigned long pgoff, unsigned long flags);
void (*unmap_area) (struct mm_struct *mm, unsigned long addr);
unsigned long mmap_base; /* base of mmap area */
unsigned long task_size; /* size of task vm space */
unsigned long cached_hole_size;
unsigned long free_area_cache;
pgd_t * pgd;
atomic_t mm_users; /* How many users with user space? */
atomic_t mm_count;
int map_count; /* number of VMAs */
struct rw_semaphore mmap_sem;
spinlock_t page_table_lock;
struct list_head mmlist;
/* Special counters, in some configurations protected by the
* page_table_lock, in other configurations by being atomic.
*/
mm_counter_t _file_rss;
mm_counter_t _anon_rss;
unsigned long hiwater_rss; /* High-watermark of RSS usage */
unsigned long hiwater_vm; /* High-water virtual memory usage */
unsigned long total_vm, locked_vm, shared_vm, exec_vm;
unsigned long stack_vm, reserved_vm, def_flags, nr_ptes;
unsigned long start_code, end_code, start_data, end_data;
unsigned long start_brk, brk, start_stack;
unsigned long arg_start, arg_end, env_start, env_end;
unsigned long saved_auxv[AT_VECTOR_SIZE];
unsigned dumpable:2;
cpumask_t cpu_vm_mask;
/* Architecture-specific MM context */
mm_context_t context;
/* Token based thrashing protection. */
unsigned long swap_token_time;
char recent_pagein;
/* coredumping support */
int core_waiters;
struct completion *core_startup_done, core_done;
/* aio bits */
rwlock_t ioctx_list_lock;
struct kioctx *ioctx_list;
};


VM area
The full address space of a process is rarely used, only sparse areas are. Each area is represented by a vm_area_struct which never overlap and represent a set of addresses with the same protection and purpose. Read more…

Splice
Splice is a system all that copies data between a file handle and a pipe, or between a pipe and user space.
There has 3 system calls in the linux kernel:
sys_splice - transfers between a file descriptor and a pipe:

asmlinkage long sys_splice(int fd_in, loff_t __user *off_in,
int fd_out, loff_t __user *off_out,
size_t len, unsigned int flags);

sys_vmsplice - map an application data area into a pipe (or vice versa), thus allowing transfer between pipes and user memory:

asmlinkage long sys_vmsplice(int fd, const struct iovec __user *iov,
unsigned long nr_segs, unsigned int flags);

sys_tee - duplicates one pipe to another, enabling forks in the way applications are connected with pipes:

asmlinkage long sys_tee(int fdin, int fdout, size_t len, unsigned int flags);