struct swap_info_struct {
	/**
	 * 交换区标志
	 */
	unsigned int flags;
	/** 
	 * 保护交换区的自旋锁。它防止 SMP 系统上对交换区数据结构的并发访问
	 */
	spinlock_t sdev_lock;
	/**
	 * 指针，指向存放交换区的普通文件或设备文件的文件对象。
	 */
	struct file *swap_file;
	/**
	 * 存放交换区的块设备描述符。
	 */
	struct block_device *bdev;
	/**
	 * 指向交换区的子区链表的头部。
	 */
	struct list_head extent_list;
	/**
	 * 组成交换区的子区数量。
	 */
	int nr_extents;
	/**
	 * 指向最近使用的子区描述符的指针。
	 */
	struct swap_extent *curr_swap_extent;
	/**
	 * 存放交换区的磁盘分区自然块大小。
	 */
	unsigned old_block_size;
	/**
	 * 指向计数器数组的指针，交换区的每个页槽对应一个数组元素。如果这个计数器的值等于0，那么页槽就是空闲的，如果计数器值大于0，
	 那么换出页就是填充了这个页槽，实际上这个值是表示贡享这个换出页的进程数量，如果计数器的值为 SWAP_MAP_MAX（32767），那么存放在该页槽中的页就是“永    久”的，并且不能从相应的页槽中删除。如果计数器的值是 SWAP_MAP_BAD（32768），那么就认为该页槽是有缺陷的，不可用。
	 */
	unsigned short * swap_map;
	/**
	 * 在搜索一个空闲页槽时要扫描的第一个页槽。
	 */
	unsigned int lowest_bit;
	/**
	 * 在搜索一个空闲页槽时要扫描的最后一个页槽。
	 */
	unsigned int highest_bit;
	/**
	 * 在搜索一个空闲页槽时要扫描的下一个页槽。
	 */
	unsigned int cluster_next;

	unsigned int cluster_nr;
	/**
	 * 交换区优先级。表示交换子系统依据该值考虑每个交换区的次序
	 */
	int prio;			/* swap priority */
	/**
	 * 可用页槽的个数。
	 */
	int pages;
	/**
	 * 交换区的大小，以页为单位。
	 */
	unsigned long max;
	/**
	 * 交换区内已用页槽数。
	 */
	unsigned long inuse_pages;
	/**
	 * 指向下一个交换区描述符的指针。
	 */
	int next;			/* next entry on swap list */
};

//根据子区的首页索引、子区的磁盘块那么可以很方便的知道某一个页槽在磁盘中的存放位置
struct swap_extent {
	/**
	 * 子区链表指针。
	 */
	struct list_head list;
	/**
	 * 子区的首页索引。
	 */
	pgoff_t start_page;
	/**
	 * 子区页数。
	 */
	pgoff_t nr_pages;
	/**
	 * 子区的起始磁盘区号。
	 */
	sector_t start_block;
};

/**
 * 每个交换区的第一个页槽用来永久存放有关交换区的信息，用本结构表示。
 */
union swap_header {
	struct {
		char reserved[PAGE_SIZE - 10];
		/**
		 * 交换区标识，一般是"SWAPSPACE2"
		 */
		char magic[10];			/* SWAP-SPACE or SWAPSPACE2 */
	} magic;
	struct {
		/**
		 * 不用于交换算法。存放分区数据、磁盘标签等。
		 */
		char	     bootbits[1024];	/* Space for disklabel etc. */
		/**
		 * 交换区的版本。
		 */
		unsigned int version;
		/**
		 * 可有效使用的最后一个页槽。
		 */
		unsigned int last_page;
		/**
		 * 有缺陷的页槽个数。
		 */
		unsigned int nr_badpages;
		/**
		 * 填充字段。
		 */
		unsigned int padding[125];
		/**
		 * 共637个字节，用来指定有缺陷页槽的位置。
		 */
		unsigned int badpages[1];
	} info;
};

static inline int handle_pte_fault(struct mm_struct *mm,
	struct vm_area_struct * vma, unsigned long address,
	int write_access, pte_t *pte, pmd_t *pmd)
{
	pte_t entry;

	entry = *pte;
	/**
	 * 页还不存在，内核分配一个新的页框并适当的初始化。
	 * 即请求调页。 页表的某些位是不
	 */
	if (!pte_present(entry)) {
		/*
		 * If it truly wasn't present, we know that kswapd
		 * and the PTE updates will not touch it later. So
		 * drop the lock.
		 */
		/**
		 * pte_none返回1，说明页从未被进程访问且没有映射磁盘文件。
		 */
		if (pte_none(entry))
			return do_no_page(mm, vma, address, write_access, pte, pmd);
		/**
		 * pte_file返回1，说明页属于非线性磁盘文件的映射。
		 */
		if (pte_file(entry))
			return do_file_page(mm, vma, address, write_access, pte, pmd);

		/**
		 * 这个页曾经被访问过，但是其内容被临时保存在磁盘上。
		 */
		return do_swap_page(mm, vma, address, pte, pmd, entry, write_access);
	}
    /*
      ...............以下代码忽略.................  
    */
}

/**
 *
激活交换区系统调用。
 *		specialfile:		设备文件或分区的路径径名(用户态地址空间)，或指向实现交换区的普通文件的路径名。
 *		swap_flags:			由一个单独的SWAP_FLAG_PREFER位加上交换区优先级的31位组成。只有在SWAP_FLAG_PREFER位置位时，优先级才有效。
 */
asmlinkage long sys_swapon(const char __user * specialfile, int swap_flags)
{
	struct swap_info_struct * p;
	char *name = NULL;
	struct block_device *bdev = NULL;
	struct file *swap_file = NULL;
	struct address_space *mapping;
	unsigned int type;
	int i, prev;
	int error;
	static int least_priority;
	union swap_header *swap_header = NULL;
	int swap_header_version;
	int nr_good_pages = 0;
	unsigned long maxpages = 1;
	int swapfilesize;
	unsigned short *swap_map;
	struct page *page = NULL;
	struct inode *inode = NULL;
	int did_down = 0;

	/**
	 * 检查当前进程是否具有CAP_SYS_ADMIN权限。
	 */
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;
	
	//对操作的swap描述符进行加锁操作
	swap_list_lock();

	//存放所有交换区的数组
	p = swap_info;
	/**
	 * 在交换区数据组中查找SWP_USED标志为0的第一个一个描述符。
	 */
	for (type = 0 ; type < nr_swapfiles ; type++,p++)
		if (!(p->flags & SWP_USED))
			break;
	error = -EPERM;
	/*
	 * Test if adding another swap device is possible. There are
	 * two limiting factors: 1) the number of bits for the swap
	 * type swp_entry_t definition and 2) the number of bits for
	 * the swap type in the swap ptes as defined by the different
	 * architectures. To honor both limitations a swap entry
	 * with swap offset 0 and swap type ~0UL is created, encoded
	 * to a swap pte, decoded to a swp_entry_t again and finally
	 * the swap type part is extracted. This will mask all bits
	 * from the initial ~0UL that can't be encoded in either the
	 * swp_entry_t or the architecture definition of a swap pte.
	 */
	if (type > swp_type(pte_to_swp_entry(swp_entry_to_pte(swp_entry(~0UL,0))))) {
		swap_list_unlock();
		goto out;
	}
	if (type >= nr_swapfiles)
		nr_swapfiles = type+1;
	INIT_LIST_HEAD(&p->extent_list);
	/**
	 * 找到交换区索引，初始化描述符。
	 */
	p->flags = SWP_USED;
	p->nr_extents = 0;
	p->swap_file = NULL;
	p->old_block_size = 0;
	p->swap_map = NULL;
	p->lowest_bit = 0;
	p->highest_bit = 0;
	p->cluster_nr = 0;
	p->inuse_pages = 0;
	spin_lock_init(&p->sdev_lock);
	p->next = -1;
	/**
	 * 如果参数为新交换区指定了优先级，则设置描述符的prio字段。
	 */
	if (swap_flags & SWAP_FLAG_PREFER) {
		p->prio =
		  (swap_flags & SWAP_FLAG_PRIO_MASK)>>SWAP_FLAG_PRIO_SHIFT;
	} else {
		/**
		 * 否则将交换区的优先级设置为当前优先级中最低优先级再减一。也就是说，新交换区是最低优先级。
		 */
		p->prio = --least_priority;
	}
	swap_list_unlock();
	/**
	 * 从用户态地址空间复制specialfile参数所指向的字符串。
	 */
	name = getname(specialfile);
	error = PTR_ERR(name);
	if (IS_ERR(name)) {
		name = NULL;
		goto bad_swap_2;
	}
	/**
	 * 打开指定的文件。
	 */
	swap_file = filp_open(name, O_RDWR|O_LARGEFILE, 0);
	error = PTR_ERR(swap_file);
	if (IS_ERR(swap_file)) {
		swap_file = NULL;
		goto bad_swap_2;
	}

	/**
	 * 将打开的文件描述符存放在swap_file中。
	 */
	p->swap_file = swap_file;
	mapping = swap_file->f_mapping;

	//指向inode
	inode = mapping->host;

	error = -EBUSY;
	/**
	 * 检查交换区，以确认该交换区没有被激活。
	 */
	for (i = 0; i < nr_swapfiles; i++) {
		struct swap_info_struct *q = &swap_info[i];

		if (i == type || !q->swap_file)
			continue;
		if (mapping == q->swap_file->f_mapping)
			goto bad_swap;
	}

	error = -EINVAL;
	/**
	 * 检查打开文件是否为一个块设备文件。
	 */
	if (S_ISBLK(inode->i_mode)) {
		bdev = I_BDEV(inode);
		/**
		 * bd_claim将交换子系统设置成块设备的占有者。如果块设备已经有一个占有者，则返回错误码。
		 */
		error = bd_claim(bdev, sys_swapon);
		if (error < 0) {
			bdev = NULL;
			goto bad_swap;
		}
		/**
		 * 把块设备的当前块大小存放在交换区描述符的old_block_size字段，然后把设备的块设备大小设成页的大小。
		 */
		p->old_block_size = block_size(bdev);
		error = set_blocksize(bdev, PAGE_SIZE);
		if (error < 0)
			goto bad_swap;
		/**
		 * 将块设备描述符存入交换区描述符的bdev字段。
		 */
		p->bdev = bdev;
	} else if (S_ISREG(inode->i_mode)) {
		/**
		 * 交换区是一个普通文件。
		 */
		p->bdev = inode->i_sb->s_bdev;
		down(&inode->i_sem);
		did_down = 1;
		/**
		 * 检查文件索引节点i_flags字段中的S_SWAPFILE字段。如果该标志置位，说明文件已经用做交换区，返回失败。
		 */
		if (IS_SWAPFILE(inode)) {
			error = -EBUSY;
			goto bad_swap;
		}
	} else {
		goto bad_swap;
	}

	swapfilesize = i_size_read(inode) >> PAGE_SHIFT;

	/*
	 * Read the swap header.
	 */
	if (!mapping->a_ops->readpage) {
		error = -EINVAL;
		goto bad_swap;
	}
	/**
	 * 读取存放在交换区页槽0中的swap_header描述符。
	 */
	page = read_cache_page(mapping, 0,
			(filler_t *)mapping->a_ops->readpage, swap_file);
	if (IS_ERR(page)) {
		error = PTR_ERR(page);
		goto bad_swap;
	}
	wait_on_page_locked(page);
	if (!PageUptodate(page))
		goto bad_swap;
	kmap(page);
	swap_header = page_address(page);

	/**
	 * 检查最后10个字符，以确定版本号。
	 */
	if (!memcmp("SWAP-SPACE",swap_header->magic.magic,10))
		swap_header_version = 1;
	else if (!memcmp("SWAPSPACE2",swap_header->magic.magic,10))
		swap_header_version = 2;
	else {
		printk("Unable to find swap-space signature\n");
		error = -EINVAL;
		goto bad_swap;
	}
	
	switch (swap_header_version) {
	case 1:
		printk(KERN_ERR "version 0 swap is no longer supported. "
			"Use mkswap -v1 %s\n", name);
		error = -EINVAL;
		goto bad_swap;
	case 2:
		/* Check the swap header's sub-version and the size of
                   the swap file and bad block lists */
		if (swap_header->info.version != 1) {
			printk(KERN_WARNING
			       "Unable to handle swap header version %d\n",
			       swap_header->info.version);
			error = -EINVAL;
			goto bad_swap;
		}

		p->lowest_bit  = 1;
		/*
		 * Find out how many pages are allowed for a single swap
		 * device. There are two limiting factors: 1) the number of
		 * bits for the swap offset in the swp_entry_t type and
		 * 2) the number of bits in the a swap pte as defined by
		 * the different architectures. In order to find the
		 * largest possible bit mask a swap entry with swap type 0
		 * and swap offset ~0UL is created, encoded to a swap pte,
		 * decoded to a swp_entry_t again and finally the swap
		 * offset is extracted. This will mask all the bits from
		 * the initial ~0UL mask that can't be encoded in either
		 * the swp_entry_t or the architecture definition of a
		 * swap pte.
		 */
		maxpages = swp_offset(pte_to_swp_entry(swp_entry_to_pte(swp_entry(0,~0UL)))) - 1;
		/**
		 * 根据last_page确定交换区的大小。
		 */
		if (maxpages > swap_header->info.last_page)
			maxpages = swap_header->info.last_page;
		/**
		 * 根据交换区大小设置lowest_bit和highest_bit
		 */
		p->highest_bit = maxpages - 1;

		error = -EINVAL;
		if (swap_header->info.nr_badpages > MAX_SWAP_BADPAGES)
			goto bad_swap;
		
		/* OK, set up the swap map and apply the bad block list */
		/**
		 * 分配新交换区相关的计数器数组。并将它存放在交换区描述符的swap_map中。
		 */
		if (!(p->swap_map = vmalloc(maxpages * sizeof(short)))) {
			error = -ENOMEM;
			goto bad_swap;
		}

		error = 0;
		/**
		 * 根据bad_pages字段中存放的有缺陷的页槽链表把计数器数组元素初始化成0或者SWAP_MAP_BAD。
		 */
		memset(p->swap_map, 0, maxpages * sizeof(short));
		for (i=0; i<swap_header->info.nr_badpages; i++) {
			int page = swap_header->info.badpages[i];
			if (page <= 0 || page >= swap_header->info.last_page)
				error = -EINVAL;
			else
				p->swap_map[page] = SWAP_MAP_BAD;
		}
		/**
		 * 计算可用页槽数。
		 */
		nr_good_pages = swap_header->info.last_page -
				swap_header->info.nr_badpages -
				1 /* header page */;
		if (error) 
			goto bad_swap;
	}
	
	if (swapfilesize && maxpages > swapfilesize) {
		printk(KERN_WARNING
		       "Swap area shorter than signature indicates\n");
		error = -EINVAL;
		goto bad_swap;
	}
	if (!nr_good_pages) {
		printk(KERN_WARNING "Empty swap-file\n");
		error = -EINVAL;
		goto bad_swap;
	}
	p->swap_map[0] = SWAP_MAP_BAD;
	p->max = maxpages;
	p->pages = nr_good_pages;

	/**
	 * 为新交换区建立子区链表，并设置交换区描述符的nr_externs和curr_swap_extent字段。
	 */
	error = setup_swap_extents(p);
	if (error)
		goto bad_swap;

	down(&swapon_sem);
	swap_list_lock();
	swap_device_lock(p);
	/**
	 * 设置flag标志为SWP_ACTIVE，然后更新几个全局变量。
	 */
	p->flags = SWP_ACTIVE;
	nr_swap_pages += nr_good_pages;
	total_swap_pages += nr_good_pages;
	printk(KERN_INFO "Adding %dk swap on %s.  Priority:%d extents:%d\n",
		nr_good_pages<<(PAGE_SHIFT-10), name,
		p->prio, p->nr_extents);

	/* insert swap space into swap_list: */
	/**
	 * 将交换区插入swap_list链表中。
	 */
	prev = -1;
	for (i = swap_list.head; i >= 0; i = swap_info[i].next) {
		if (p->prio >= swap_info[i].prio) {
			break;
		}
		prev = i;
	}
	p->next = i;
	if (prev < 0) {
		swap_list.head = swap_list.next = p - swap_info;
	} else {
		swap_info[prev].next = p - swap_info;
	}
	swap_device_unlock(p);
	swap_list_unlock();
	up(&swapon_sem);
	error = 0;
	goto out;
bad_swap:
	if (bdev) {
		set_blocksize(bdev, p->old_block_size);
		bd_release(bdev);
	}
bad_swap_2:
	swap_list_lock();
	swap_map = p->swap_map;
	p->swap_file = NULL;
	p->swap_map = NULL;
	p->flags = 0;
	if (!(swap_flags & SWAP_FLAG_PREFER))
		++least_priority;
	swap_list_unlock();
	destroy_swap_extents(p);
	vfree(swap_map);
	if (swap_file)
		filp_close(swap_file, NULL);
out:
	if (page && !IS_ERR(page)) {
		kunmap(page);
		page_cache_release(page);
	}
	if (name)
		putname(name);
	if (did_down) {
		if (!error)
			inode->i_flags |= S_SWAPFILE;
		up(&inode->i_sem);
	}
	return error;
}

/**
 * 使指定的交换区无效。
 */
asmlinkage long sys_swapoff(const char __user * specialfile)
{
	struct swap_info_struct * p = NULL;
	unsigned short *swap_map;
	struct file *swap_file, *victim;
	struct address_space *mapping;
	struct inode *inode;
	char * pathname;
	int i, type, prev;
	int err;

	/**
	 * 验证当前进程是否具有CAP_SYS_ADMIN权限。
	 */
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	/**
	 * 拷贝用户态空间的specialfile参数。
	 */
	pathname = getname(specialfile);
	err = PTR_ERR(pathname);
	if (IS_ERR(pathname))
		goto out;

	/**
	 * 打开文件。返回文件对象地址。
	 */
	victim = filp_open(pathname, O_RDWR|O_LARGEFILE, 0);
	putname(pathname);
	err = PTR_ERR(victim);
	if (IS_ERR(victim))
		goto out;

	mapping = victim->f_mapping;
	prev = -1;
	swap_list_lock();
	/**
	 * 扫描交换区描述符链表，比较文件对象地址与活动交换区描述符的swap_file。如果不一致，说明传给函数的是一个无效参数，返回错误码。
	 */
	for (type = swap_list.head; type >= 0; type = swap_info[type].next) {
		p = swap_info + type;
		if ((p->flags & SWP_ACTIVE) == SWP_ACTIVE) {
			if (p->swap_file->f_mapping == mapping)
				break;
		}
		prev = type;
	}
	if (type < 0) {
		err = -EINVAL;
		swap_list_unlock();
		goto out_dput;
	}
	/**
	 * 调用security_vm_enough_memory，检查是否有足够的空闲页框把交换区上存放的所有页换入。
	 */
	if (!security_vm_enough_memory(p->pages))
		vm_unacct_memory(p->pages);
	else {
		err = -ENOMEM;
		swap_list_unlock();
		goto out_dput;
	}
	/**
	 * 将交换区从swap_list中删除。
	 */
	if (prev < 0) {
		swap_list.head = p->next;
	} else {
		swap_info[prev].next = p->next;
	}
	if (type == swap_list.next) {
		/* just pick something that's safe... */
		swap_list.next = swap_list.head;
	}
	/**
	 * 调整两个全局变量。
	 */
	nr_swap_pages -= p->pages;
	total_swap_pages -= p->pages;
	/**
	 * 清除该标志后，将不会再向交换区换出更多的页。
	 */
	p->flags &= ~SWP_WRITEOK;
	swap_list_unlock();
	current->flags |= PF_SWAPOFF;
	/**
	 * 调用try_to_unuse函数强制把这个交换区中剩余的所有页都移到RAM中。并相应地修改这些页的进程的页表。
	 * 当执行该函数时，当前进程的PF_SWAPOFF标志置位。
	 */
	err = try_to_unuse(type);
	current->flags &= ~PF_SWAPOFF;

	/* wait for any unplug function to finish */
	/**
	 * 等待交换区所在的块设备驱动器被卸载，这样在交换区被禁用前，try_to_unuse发出的读请求会被驱动器处理。
	 */
	down_write(&swap_unplug_sem);
	up_write(&swap_unplug_sem);

	/**
	 * try_to_unuse返回失败。不能关闭交换区。
	 */
	if (err) {
		/* re-insert swap space back into swap_list */
		swap_list_lock();
		/**
		 * 将交换区重新插入到swap_list链表。
		 */
		for (prev = -1, i = swap_list.head; i >= 0; prev = i, i = swap_info[i].next)
			if (p->prio >= swap_info[i].prio)
				break;
		p->next = i;
		if (prev < 0)
			swap_list.head = swap_list.next = p - swap_info;
		else
			swap_info[prev].next = p - swap_info;
		/**
		 * 调整全局变量。
		 */
		nr_swap_pages += p->pages;
		total_swap_pages += p->pages;
		p->flags |= SWP_WRITEOK;
		swap_list_unlock();
		goto out_dput;
	}
	/**
	 * 运行到这里，说明所有页槽都已经被成功传送到RAM中。
	 */
	down(&swapon_sem);
	swap_list_lock();
	drain_mmlist();
	swap_device_lock(p);
	swap_file = p->swap_file;
	p->swap_file = NULL;
	p->max = 0;
	swap_map = p->swap_map;
	p->swap_map = NULL;
	p->flags = 0;
	/**
	 * 释放子区描述符。
	 */
	destroy_swap_extents(p);
	swap_device_unlock(p);
	swap_list_unlock();
	up(&swapon_sem);
	/**
	 * 释放swap_map数组。
	 */
	vfree(swap_map);
	inode = mapping->host;
	if (S_ISBLK(inode->i_mode)) {
		/**
		 * 交换区在磁盘分区，恢复块大小为原值。
		 */
		struct block_device *bdev = I_BDEV(inode);
		set_blocksize(bdev, p->old_block_size);
		/**
		 * 交换区不再占有该块设备。
		 */
		bd_release(bdev);
	} else {
		/**
		 * 交换区在普通文件中，则把文件索引节点的S_SWAPFILE标志清0.
		 */
		down(&inode->i_sem);
		inode->i_flags &= ~S_SWAPFILE;
		up(&inode->i_sem);
	}
	/**
	 * 关闭两个文件:swap_file和victim。
	 */
	filp_close(swap_file, NULL);
	err = 0;

out_dput:
	filp_close(victim, NULL);
out:
	return err;
}