Each process page will map to its own linear address space when process paging, and process execution will not interfere with each other. But, in some cases, a process needs to share the page, such as the father and child process needs to share the page. The most obvious example is that the process 1 creates process 2, and before the process 2 load shell, they share code. It is shown below:
//Code path:init/main.c:
void init(void) {
……
if (!(pid=fork())) {
close(0); //These codes share with the process if (open(“/etc/rc”,O_RDONLY,0))
_exit(1);
execve(“/bin/sh”,argv_rc,envp_rc);
_exit(2);
}
if (pid>0)
while (pid != wait(&i))
……
}
The best choice is when the child processes have been created, it uses the parent process code at first, and the child process shares the pages that belongs to the father.
Then, the child process remaps when loading its program. This raises a question:
Multiple processes operate on the same page and have read and written, and this is equivalent to break a hole the process-enclosed environment. Therefore, we need to do something to make the hole blocked.
Linux 0.11 uses two bits of a page table to make the hole blocked.
First, introduce the U/S bit, and if the U/S bit is set to 0, it indicates a program of the privilege level of 3 cannot access this page while another privilege level can. If set to 1, it indicates all programs of the privilege level of 3 can access this page. Its function is watching the user processes, preventing the page, which only accessed by kernel, from using by a user process. Of course, the protection of Linux 0.11 is more stress to the use of “segment.”
U/S bit is set to 1 when the kernel pages before idling; the code is as follows:
The binary of 7 is 111 in the code; it indicates that the U/S-bit is set to 1.
The U/S-bit of the child processes page directory entry and page table is set to 1 when creating the process; the code is shown below:
//Code path:boot/head.s:
……
setup_paging:
movl $1024*5,%ecx /* 5 pages - pg_dir+4 page tables */
xorl%eax,%eax
xorl%edi,%edi /* pg_dir is at 0x000 */
cld;rep;stosl
movl $pg0+7,_pg_dir /* set present bit/user r/w */
movl $pg1+7,_pg_dir+4 /*— — — — - “ “— — — — - */
movl $pg2+7,_pg_dir+8 /*— — — — - “ “— — — — - */
movl $pg3+7,_pg_dir+12 /*— — — — - “ “— — — — - */
movl $pg3+4092,%edi
movl $0xfff007,%eax /* 16Mb - 4096 + 7 (r/w user,p) */
std
1: stosl /* fill pages backwards - more efficient :-) */
subl $0x1000,%eax jge 1b
……
//Code path:mm/memory.c:
int copy_page_tables(unsigned long from,unsigned long to,long size) {
……
from_page_table = (unsigned long *) (0xfffff000 & *from_dir);
if (!(to_page_table = (unsigned long *) get_free_page())) return -1; /* Out of memory, see freeing */
*to_dir = ((unsigned long) to_page_table) | 7; //Set the U/S-bit of page //directory table entry to 1 nr = (from==0)?0xA0:1024;
for (; nr— > 0 ; from_page_table++,to_page_table++) { this_page = *from_page_table;
if (!(1 & this_page))
The new application page of the process maps to the linear address space of the pro- cess will set the U/S-bit of the corresponding page table entry to 1. If it is a new page table, it will also set the U/S-bit of the corresponding page directory entry to 1.
Next, we introduce the R/W. If it is set to 0, it indicates the page can only read and can’t write. If it is set to 1, it indicates that it can read and write.
The process can share the page that will bring you a question, if multiple processes write the data to one page, this page will appear chaotic, so it needs protection. The R/W bit provides this kind of protection.
The father and child process share pages when create the child process, and the shared page cannot be written into the data; the R/W bit is set to 0. The code is shown below:
//Code path:mm/memory.c:
unsigned long put_page(unsigned long page,unsigned long address) {
……
if ((*page_table)&1)
page_table = (unsigned long *) (0xfffff000 & *page_table);
else {
if (!(tmp = get_free_page())) return 0;
*page_table = tmp|7; //Set the U/S-bit of page directory //entry to 1
page_table = (unsigned long *) tmp;
}
page_table[(address>>12) & 0x3ff] = page | 7; //Set the U/S-bit of page //table entry to 1
……
}
continue;
this_page &= ~2; //Set the U/S-bit of page table entry to 1, the //binary of ~2 is 101
*to_page_table = this_page;
if (this_page > LOW_MEM) {
*from_page_table = this_page;
……
}
//Code path:mm/memory.c:
int copy_page_tables(unsigned long from,unsigned long to,long size) {
……
this_page = *from_page_table;
if (!(1 & this_page)) continue;
this_page &= ~2; //Set the R/W-bit of page table item to 1,the //binary of ~2 is 101
*to_page_table = this_page;
if (this_page > LOW_MEM) {
*from_page_table = this_page;
……
}
Furthermore, the processes without father and child relationship can also share the page and do not need load again. At this time, it will set the R/W to 0 and prohibit writing data.
Through the above introduction, it is not difficult to locate a process sharing page, and there are only two possible operations, either read or write. Although read will not cause data chaos, it will result in literally reading. If it is written, it is possible to cause chaos, and it needs to be banned. To the writing requirements, Linux 0.11 takes the write-on-copy strategy to solve, namely to copy the written data page to process, and the two processes each have one, and each writes each page, so it won’t result in chaos. We will use an oper- ating example to explain the write-on-copy mechanism at the end of this chapter section.
//Code path:mm/memory.c:
void do_no_page(unsigned long error_code,unsigned long address) {
……
if (!current->executable || tmp >= current->end_data) { get_empty_page(address);
return;
}
if (share_page(tmp)) return;
if (!(page = get_free_page())) oom();
……
}
static int share_page(unsigned long address) //ready to share page {
……
if ((*p)->executable ! = current->executable) continue;
if (try_to_share(address,*p)) return 1;
}
return 0;
}
static int try_to_share(unsigned long address, struct task_struct * p) //detect whether can share page
{ ……
to &= 0xfffff000;
to_page = to + ((address>>10) & 0xffc);
if (1 & *(unsigned long *) to_page)
panic(“try_to_share: to_page already exists”);
/* share them: write-protect */
*(unsigned long *) from_page &= ~2; //Set the R/W-bit of page //table item to 1,the // binary of ~2 is 101
*(unsigned long *) to_page = *(unsigned long *) from_page;
invalidate();
……
}
Linux 0.11 does have such demand like pipeline, and two processes in the same page can read and write. We will introduce how to ensure that process operating does not pro- duce data of chaos in Chapter 8.