static int ashmem_pin_unpin(struct ashmem_area *asma, unsigned long cmd,void __user *p)
{
	struct ashmem_pin pin;
	size_t pgstart, pgend;
	int ret = -EINVAL;
	//判断该块匿名共享内存是否存在对应的临时文件
	if (unlikely(!asma->file))
		return -EINVAL;
    //从用户空间将参数p拷贝到内核空间
	if (unlikely(copy_from_user(&pin, p, sizeof(pin))))
		return -EFAULT;
	//如果要锁定或解锁的内存大小为0，则表示要锁定或解锁的内存块从pin所描述的偏移地址开始，一直到匿名共享内存的末尾
	if (!pin.len)
		pin.len = PAGE_ALIGN(asma->size) - pin.offset;
    //检查要锁定或解锁的内存偏移和大小是否页面对齐
	if (unlikely((pin.offset | pin.len) & ~PAGE_MASK))
		return -EINVAL;
    //检查要锁定或解锁的内存块的末尾地址是否超出无符合整数
	if (unlikely(((__u32) -1) - pin.offset < pin.len))
		return -EINVAL;
	//检查要锁定或解锁的内存块末尾地址是否超出宿主内存的末尾地址
	if (unlikely(PAGE_ALIGN(asma->size) < pin.offset + pin.len))
		return -EINVAL;
    //以页面为单位，计算要锁定或解锁的内存快的起始和结束地址
	pgstart = pin.offset / PAGE_SIZE;
	pgend = pgstart + (pin.len / PAGE_SIZE) - 1;
	mutex_lock(&ashmem_mutex);//加锁
	switch (cmd) {
	case ASHMEM_PIN://锁定操作
		ret = ashmem_pin(asma, pgstart, pgend);
		break;
	case ASHMEM_UNPIN://解锁操作
		ret = ashmem_unpin(asma, pgstart, pgend);
		break;
	case ASHMEM_GET_PIN_STATUS://获取锁定状态
		ret = ashmem_get_pin_status(asma, pgstart, pgend);
		break;
	}
	mutex_unlock(&ashmem_mutex);//解锁
	return ret;
}

static int ashmem_pin(struct ashmem_area *asma, size_t pgstart, size_t pgend)
{
	struct ashmem_range *range, *next;
	int ret = ASHMEM_NOT_PURGED;
	//遍历宿主匿名共享内存的成员unpinned_list链表
	list_for_each_entry_safe(range, next, &asma->unpinned_list, unpinned) {
	    //如果解锁内存块在当前解锁内存块的前面，位置如下，即不和已解锁内存块相交，只有位于unpinned_list的内存块才可以执行锁定操作
		// |----range---|       
		//               |-pgstart-----------pgend-|      
		if (range_before_page(range, pgstart))
			break;
		//      位置3               |           位置2            |       位置4
		//|----range---|            |          |----range---|    |     |----range---|
		//   |-pgstart---pgend-|    |  |-pgstart---pgend-|       |  |-pgstart---pgend-|
		if (page_range_in_range(range, pgstart, pgend)) {
			ret |= range->purged;
			//该位置下的当前内存块已经解锁，因此需要将range从链表中删除，重新锁定
			// |----------range---------|  
			//   |-pgstart---pgend-|  
			if (page_range_subsumes_range(range, pgstart, pgend)) {
				range_del(range);
				continue;
			}
			//        |------range-----|  |                     |---range--|
			//   |-pgstart---pgend-|      |  |-pgstart---pgend-|
			if (range->pgstart >= pgstart) {
				range_shrink(range, pgend + 1, range->pgend);
				continue;
			}
			// |----range---|             |         |---range--|
			//        |-pgstart---pgend-| |                     |-pgstart---pgend-|
			if (range->pgend <= pgend) {
				range_shrink(range, range->pgstart, pgstart-1);
				continue;
			}
			// |--------range-------|   
			//    |pgstart--pgend|
			range_alloc(asma, range, range->purged,pgend + 1, range->pgend);
			range_shrink(range, range->pgstart, pgstart - 1);
			break;
		}
	}
	return ret;
}

static inline void range_shrink(struct ashmem_range *range,
				size_t start, size_t end)
{
	//计算该内存块的大小
	size_t pre = range_size(range);
    //调整该内存块的大小
	range->pgstart = start;
	range->pgend = end;
    //判断该内存块是否被回收
	if (range_on_lru(range))
		//调整处于解锁状态的内存块大小
		lru_count -= pre - range_size(range);
}

static int ashmem_unpin(struct ashmem_area *asma, size_t pgstart, size_t pgend)
{
	struct ashmem_range *range, *next;
	unsigned int purged = ASHMEM_NOT_PURGED;
restart:
	//遍历宿主匿名共享内存的成员unpinned_list链表中的所有已解锁的小内存块range
	list_for_each_entry_safe(range, next, &asma->unpinned_list, unpinned) {
		//如果解锁内存块在当前解锁内存块的前面，位置如下，即不和已解锁内存块相交，因此不需要继续遍历，
		// |----range---|       
		//               |-pgstart-----------pgend-|      
		if (range_before_page(range, pgstart))
			break;
		//该位置下已经解锁
		// |----------range---------|  
		//   |-pgstart---pgend-|  
		if (page_range_subsumed_by_range(range, pgstart, pgend))
			return 0;
		//      位置3               |           位置2            |       位置4
		//|----range---|            |          |----range---|    |     |----range---|
		//   |-pgstart---pgend-|    |  |-pgstart---pgend-|       |  |-pgstart---pgend-|
		if (page_range_in_range(range, pgstart, pgend)) {
			//调整解锁内存块的起始地址为两个内存块的最小起始地址
			pgstart = min_t(size_t, range->pgstart, pgstart),
			//调整解锁内存块的末尾地址为两个内存块的最大末尾地址
			pgend = max_t(size_t, range->pgend, pgend);
			//保存这块解锁内存的锁定状态
			purged |= range->purged;
			//从宿主匿名共享内存的成员unpinned_list链表中删除当前这块已解锁的内存块
			range_del(range);
			goto restart;
		}
	}
    //解锁当前内存块，并且插入到宿主匿名共享内存的成员unpinned_list链表中
	return range_alloc(asma, range, purged, pgstart, pgend);
}

register_shrinker(&ashmem_shrinker);
static struct shrinker ashmem_shrinker = {
	.shrink = ashmem_shrink,
	.seeks = DEFAULT_SEEKS * 4,
};

static int ashmem_shrink(struct shrinker *s, struct shrink_control *sc)
{
	struct ashmem_range *range, *next;
	/* We might recurse into filesystem code, so bail out if necessary */
	if (sc->nr_to_scan && !(sc->gfp_mask & __GFP_FS))
		return -1;
	//nr_to_scan表示内存管理系统回收的内存页数，如果等于0，表示查询处于解锁状态的内存大小
	if (!sc->nr_to_scan)
		return lru_count;
	mutex_lock(&ashmem_mutex);
	list_for_each_entry_safe(range, next, &ashmem_lru_list, lru) {
		struct inode *inode = range->asma->file->f_dentry->d_inode;
		loff_t start = range->pgstart * PAGE_SIZE;
		loff_t end = (range->pgend + 1) * PAGE_SIZE - 1;
		//释放当前内存块所占用的物理内存
		vmtruncate_range(inode, start, end);
		//设置标志位，表示该内存块已经被回收
		range->purged = ASHMEM_WAS_PURGED;
		//从保存解锁内存块的链表中删除该内存
		lru_del(range);
		//调整内存管理系统要回收的内存页数
		sc->nr_to_scan -= range_size(range);
		//如果完成内存管理系统要求回收的页数，则停止回收
		if (sc->nr_to_scan <= 0)
			break;
	}
	mutex_unlock(&ashmem_mutex);
	//返回剩下可以回收的内存大小
	return lru_count;
}