CONFIG_ASHMEM=y

/dev/ashmem

static int __init ashmem_init(void)
{
	int ret = -ENOMEM;

	ashmem_area_cachep = kmem_cache_create("ashmem_area_cache",
					       sizeof(struct ashmem_area),
					       0, 0, NULL);
	if (!ashmem_area_cachep) {
		pr_err("failed to create slab cache\n");
		goto out;
	}

	ashmem_range_cachep = kmem_cache_create("ashmem_range_cache",
						sizeof(struct ashmem_range),
						0, SLAB_RECLAIM_ACCOUNT, NULL);
	if (!ashmem_range_cachep) {
		pr_err("failed to create slab cache\n");
		goto out_free1;
	}

	ret = misc_register(&ashmem_misc);
	if (ret) {
		pr_err("failed to register misc device!\n");
		goto out_free2;
	}

	ret = ashmem_init_shrinker();
	if (ret) {
		pr_err("failed to register shrinker!\n");
		goto out_demisc;
	}

	pr_info("initialized\n");

	return 0;

out_demisc:
	misc_deregister(&ashmem_misc);
out_free2:
	kmem_cache_destroy(ashmem_range_cachep);
out_free1:
	kmem_cache_destroy(ashmem_area_cachep);
out:
	return ret;
}

// device_initcall(ashmem_init); 这行代码是一个宏调用，它确保`ashmem_init`函数在设备初始化阶段被调用。这意味着在系统启动过程中，内核会自动调用`ashmem_init`函数来初始化ashmem子系统。
device_initcall(ashmem_init);

static const struct file_operations ashmem_fops = {
	// 指定模块的所有者，通常设置为`THIS_MODULE`，以确保在使用文件操作时模块不会被卸载。
	.owner = THIS_MODULE,
	// 当打开ashmem虚拟文件时调用的函数（此处为`ashmem_open`），它负责初始化或分配资源。
	.open = ashmem_open,
	// 当关闭ashmem虚拟文件时调用的函数（此处为`ashmem_release`），它负责释放由`.open`分配的资源。
	.release = ashmem_release,
	// 实现了对该设备文件的读操作（此处为`ashmem_read_iter`）。
	.read_iter = ashmem_read_iter,
	// 重新定位文件（此处为`ashmem_llseek`），使得文件的读写位置可以改变，以支持随机访问。
	.llseek = ashmem_llseek,
	// 将设备或文件的某段内存映射到用户空间（此处为`ashmem_mmap`），以便提供更高效的数据访问方式。
	.mmap = ashmem_mmap,
	// 提供一个设备特定的I/O操作接口（此处为`ashmem_ioctl`）。
	.unlocked_ioctl = ashmem_ioctl,
#ifdef CONFIG_COMPAT
	// 如果条件编译配置`CONFIG_COMPAT`开启）：为32位应用程序提供支持，允许它们在64位系统上执行ioctl调用。
	.compat_ioctl = compat_ashmem_ioctl,
#endif
#ifdef CONFIG_PROC_FS
	// 如果条件编译配置`CONFIG_PROC_FS`开启）：该函数（此处为`ashmem_show_fdinfo`）允许显示关于文件描述符的信息，增强proc文件系统中的`/proc`
	// /proc/<pid>/fdinfo/<fd>
	.show_fdinfo = ashmem_show_fdinfo,
#endif
};

// `miscdevice` 结构体 `ashmem_misc` 用于注册 ashmem 作为一个杂项（miscellaneous）设备。在 Linux 内核中，杂项设备是一种简化的设备注册方式，相比完整的字符设备驱动来说，其注册过程更简单，被广泛用于不需要自己专属设备号的小型设备。
static struct miscdevice ashmem_misc = {
	// 指定设备的次设备号。设置为 `MISC_DYNAMIC_MINOR` 表示请求动态分配一个次设备号，而不需要手动指定。
	.minor = MISC_DYNAMIC_MINOR,
	// 设备的名称，这将出现在 `/dev/` 目录下。对于ashmem，设备文件通常会被创建为 `/dev/ashmem`。
	.name = "ashmem",
	// 指向前面定义的 `file_operations` 结构体的指针。这个结构体包含了设备支持的文件操作函数，如打开、释放、读取、写入、映射等。
	.fops = &ashmem_fops,
};

static struct shrinker *ashmem_shrinker;

static int __init ashmem_init_shrinker(void)
{
	ashmem_shrinker = shrinker_alloc(0, "android-ashmem");
	if (!ashmem_shrinker)
		return -ENOMEM;

	ashmem_shrinker->count_objects = ashmem_shrink_count;
	ashmem_shrinker->scan_objects = ashmem_shrink_scan;
	/*
	 * XXX (dchinner): I wish people would comment on why they need on
	 * significant changes to the default value here
	 */
	ashmem_shrinker->seeks = DEFAULT_SEEKS * 4;

	shrinker_register(ashmem_shrinker);

	return 0;
}

// *shrink : 指向当前收缩器实例的指针
// *sc: 该参数包含了关于当前收缩请求的上下文信息，包括触发收缩操作的原因（比如内存压力）
static unsigned long
ashmem_shrink_count(struct shrinker *shrink, struct shrink_control *sc)
{
	/*
	 * note that lru_count is count of pages on the lru, not a count of
	 * objects on the list. This means the scan function needs to return the
	 * number of pages freed, not the number of objects scanned.
	 */
	 // 一个全局变量，它代表了当前在ashmem的最近最少使用（LRU）列表中未被固定并且可被收缩（回收/清除）的内存页数。此函数简单地返回该计数，这样内核就知道有多少页可能因为ashmem的操作而被释放。
	return lru_count;
}

/*
 * ashmem_shrink - our cache shrinker, called from mm/vmscan.c
 *
 * 'nr_to_scan' is the number of objects to scan for freeing.
 *
 * 'gfp_mask' is the mask of the allocation that got us into this mess.
 *
 * Return value is the number of objects freed or -1 if we cannot
 * proceed without risk of deadlock (due to gfp_mask).
 *
 * We approximate LRU via least-recently-unpinned, jettisoning unpinned partial
 * chunks of ashmem regions LRU-wise one-at-a-time until we hit 'nr_to_scan'
 * pages freed.
 */
static unsigned long
ashmem_shrink_scan(struct shrinker *shrink, struct shrink_control *sc)
{
	unsigned long freed = 0;

	/* We might recurse into filesystem code, so bail out if necessary */
	if (!(sc->gfp_mask & __GFP_FS))
		return SHRINK_STOP;

	if (!mutex_trylock(&ashmem_mutex))
		return -1;

	while (!list_empty(&ashmem_lru_list)) {
		struct ashmem_range *range =
			list_first_entry(&ashmem_lru_list, typeof(*range), lru);
		loff_t start = range->pgstart * PAGE_SIZE;
		loff_t end = (range->pgend + 1) * PAGE_SIZE;
		struct file *f = range->asma->file;

		get_file(f);
		atomic_inc(&ashmem_shrink_inflight);
		range->purged = ASHMEM_WAS_PURGED;
		lru_del(range);

		freed += range_size(range);
		mutex_unlock(&ashmem_mutex);
		f->f_op->fallocate(f,
				   FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
				   start, end - start);
		fput(f);
		if (atomic_dec_and_test(&ashmem_shrink_inflight))
			wake_up_all(&ashmem_shrink_wait);
		if (!mutex_trylock(&ashmem_mutex))
			goto out;
		if (--sc->nr_to_scan <= 0)
			break;
	}
	mutex_unlock(&ashmem_mutex);
out:
	return freed;
}