fs/exfat/cache.c - linux/kernel/git/gregkh/usb - Git at Google

 // SPDX-License-Identifier: GPL-2.0-or-later
 /*
  *  linux/fs/fat/cache.c
  *
  *  Written 1992,1993 by Werner Almesberger
  *
  *  Mar 1999. AV. Changed cache, so that it uses the starting cluster instead
  *	of inode number.
  *  May 1999. AV. Fixed the bogosity with FAT32 (read "FAT28"). Fscking lusers.
  *  Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
  */

 #include <linux/slab.h>
 #include <linux/unaligned.h>
 #include <linux/buffer_head.h>

 #include "exfat_raw.h"
 #include "exfat_fs.h"

 #define EXFAT_MAX_CACHE		16

 struct exfat_cache {
 	struct list_head cache_list;
 	unsigned int nr_contig;	/* number of contiguous clusters */
 	unsigned int fcluster;	/* cluster number in the file. */
 	unsigned int dcluster;	/* cluster number on disk. */
 };

 struct exfat_cache_id {
 	unsigned int id;
 	unsigned int nr_contig;
 	unsigned int fcluster;
 	unsigned int dcluster;
 };

 static struct kmem_cache *exfat_cachep;

 static void exfat_cache_init_once(void *c)
 {
 	struct exfat_cache *cache = (struct exfat_cache *)c;

 	INIT_LIST_HEAD(&cache->cache_list);
 }

 int exfat_cache_init(void)
 {
 	exfat_cachep = kmem_cache_create("exfat_cache",
 				sizeof(struct exfat_cache),
 				0, SLAB_RECLAIM_ACCOUNT,
 				exfat_cache_init_once);
 	if (!exfat_cachep)
 		return -ENOMEM;
 	return 0;
 }

 void exfat_cache_shutdown(void)
 {
 	if (!exfat_cachep)
 		return;
 	kmem_cache_destroy(exfat_cachep);
 }

 static inline struct exfat_cache *exfat_cache_alloc(void)
 {
 	return kmem_cache_alloc(exfat_cachep, GFP_NOFS);
 }

 static inline void exfat_cache_free(struct exfat_cache *cache)
 {
 	WARN_ON(!list_empty(&cache->cache_list));
 	kmem_cache_free(exfat_cachep, cache);
 }

 static inline void exfat_cache_update_lru(struct inode *inode,
 		struct exfat_cache *cache)
 {
 	struct exfat_inode_info *ei = EXFAT_I(inode);

 	if (ei->cache_lru.next != &cache->cache_list)
 		list_move(&cache->cache_list, &ei->cache_lru);
 }

 /*
  * Find the cache that covers or precedes 'fclus' and return the last
  * cluster before the next cache range.
  */
 static inline unsigned int
 exfat_cache_lookup(struct inode *inode, struct exfat_cache_id *cid,
 		unsigned int fclus, unsigned int end,
 		unsigned int *cached_fclus, unsigned int *cached_dclus)
 {
 	struct exfat_inode_info *ei = EXFAT_I(inode);
 	static struct exfat_cache nohit = { .fcluster = 0, };
 	struct exfat_cache *hit = &nohit, *p;
 	unsigned int tail = 0;		/* End boundary of hit cache */

 	/*
 	 * Search range [fclus, end]. Stop early if:
 	 * 1. Cache covers entire range, or
 	 * 2. Next cache starts at current cache tail
 	 */
 	spin_lock(&ei->cache_lru_lock);
 	list_for_each_entry(p, &ei->cache_lru, cache_list) {
 		/* Find the cache of "fclus" or nearest cache. */
 		if (p->fcluster <= fclus) {
 			if (p->fcluster < hit->fcluster)
 				continue;

 			hit = p;
 			tail = hit->fcluster + hit->nr_contig;

 			/* Current cache covers [fclus, end] completely */
 			if (tail >= end)
 				break;
 		} else if (p->fcluster <= end) {
 			end = p->fcluster - 1;

 			/*
 			 * If we have a hit and next cache starts within/at
 			 * its tail, caches are contiguous, stop searching.
 			 */
 			if (tail && tail >= end)
 				break;
 		}
 	}
 	if (hit != &nohit) {
 		unsigned int offset;

 		exfat_cache_update_lru(inode, hit);
 		cid->id = ei->cache_valid_id;
 		cid->nr_contig = hit->nr_contig;
 		cid->fcluster = hit->fcluster;
 		cid->dcluster = hit->dcluster;

 		offset = min(cid->nr_contig, fclus - cid->fcluster);
 		*cached_fclus = cid->fcluster + offset;
 		*cached_dclus = cid->dcluster + offset;
 	}
 	spin_unlock(&ei->cache_lru_lock);

 	/* Return next cache start or 'end' if no more caches */
 	return end;
 }

 static struct exfat_cache *exfat_cache_merge(struct inode *inode,
 		struct exfat_cache_id *new)
 {
 	struct exfat_inode_info *ei = EXFAT_I(inode);
 	struct exfat_cache *p;

 	list_for_each_entry(p, &ei->cache_lru, cache_list) {
 		/* Find the same part as "new" in cluster-chain. */
 		if (p->fcluster == new->fcluster) {
 			if (new->nr_contig > p->nr_contig)
 				p->nr_contig = new->nr_contig;
 			return p;
 		}
 	}
 	return NULL;
 }

 static void exfat_cache_add(struct inode *inode,
 		struct exfat_cache_id *new)
 {
 	struct exfat_inode_info *ei = EXFAT_I(inode);
 	struct exfat_cache *cache, *tmp;

 	if (new->fcluster == EXFAT_EOF_CLUSTER) /* dummy cache */
 		return;

 	spin_lock(&ei->cache_lru_lock);
 	if (new->id != EXFAT_CACHE_VALID &&
 	    new->id != ei->cache_valid_id)
 		goto unlock;	/* this cache was invalidated */

 	cache = exfat_cache_merge(inode, new);
 	if (cache == NULL) {
 		if (ei->nr_caches < EXFAT_MAX_CACHE) {
 			ei->nr_caches++;
 			spin_unlock(&ei->cache_lru_lock);

 			tmp = exfat_cache_alloc();
 			if (!tmp) {
 				spin_lock(&ei->cache_lru_lock);
 				ei->nr_caches--;
 				spin_unlock(&ei->cache_lru_lock);
 				return;
 			}

 			spin_lock(&ei->cache_lru_lock);
 			cache = exfat_cache_merge(inode, new);
 			if (cache != NULL) {
 				ei->nr_caches--;
 				exfat_cache_free(tmp);
 				goto out_update_lru;
 			}
 			cache = tmp;
 		} else {
 			struct list_head *p = ei->cache_lru.prev;

 			cache = list_entry(p,
 					struct exfat_cache, cache_list);
 		}
 		cache->fcluster = new->fcluster;
 		cache->dcluster = new->dcluster;
 		cache->nr_contig = new->nr_contig;
 	}
 out_update_lru:
 	exfat_cache_update_lru(inode, cache);
 unlock:
 	spin_unlock(&ei->cache_lru_lock);
 }

 /*
  * Cache invalidation occurs rarely, thus the LRU chain is not updated. It
  * fixes itself after a while.
  */
 static void __exfat_cache_inval_inode(struct inode *inode)
 {
 	struct exfat_inode_info *ei = EXFAT_I(inode);
 	struct exfat_cache *cache;

 	while (!list_empty(&ei->cache_lru)) {
 		cache = list_entry(ei->cache_lru.next,
 				   struct exfat_cache, cache_list);
 		list_del_init(&cache->cache_list);
 		ei->nr_caches--;
 		exfat_cache_free(cache);
 	}
 	/* Update. The copy of caches before this id is discarded. */
 	ei->cache_valid_id++;
 	if (ei->cache_valid_id == EXFAT_CACHE_VALID)
 		ei->cache_valid_id++;
 }

 void exfat_cache_inval_inode(struct inode *inode)
 {
 	struct exfat_inode_info *ei = EXFAT_I(inode);

 	spin_lock(&ei->cache_lru_lock);
 	__exfat_cache_inval_inode(inode);
 	spin_unlock(&ei->cache_lru_lock);
 }

 static inline int cache_contiguous(struct exfat_cache_id *cid,
 		unsigned int dclus)
 {
 	cid->nr_contig++;
 	return cid->dcluster + cid->nr_contig == dclus;
 }

 static inline void cache_init(struct exfat_cache_id *cid,
 		unsigned int fclus, unsigned int dclus)
 {
 	cid->id = EXFAT_CACHE_VALID;
 	cid->fcluster = fclus;
 	cid->dcluster = dclus;
 	cid->nr_contig = 0;
 }

 int exfat_get_cluster(struct inode *inode, unsigned int cluster,
 		unsigned int *dclus, unsigned int *count,
 		unsigned int *last_dclus)
 {
 	struct super_block *sb = inode->i_sb;
 	struct exfat_inode_info *ei = EXFAT_I(inode);
 	struct buffer_head *bh = NULL;
 	struct exfat_cache_id cid;
 	unsigned int content, fclus;
 	unsigned int end = cluster + *count - 1;

 	if (ei->start_clu == EXFAT_FREE_CLUSTER) {
 		exfat_fs_error(sb,
 			"invalid access to exfat cache (entry 0x%08x)",
 			ei->start_clu);
 		return -EIO;
 	}

 	fclus = 0;
 	*dclus = ei->start_clu;
 	*last_dclus = *dclus;

 	/*
 	 * This case should not exist, as exfat_map_cluster function doesn't
 	 * call this routine when start_clu == EXFAT_EOF_CLUSTER.
 	 * This case is retained here for routine completeness.
 	 */
 	if (*dclus == EXFAT_EOF_CLUSTER) {
 		*count = 0;
 		return 0;
 	}

 	/* If only the first cluster is needed, return now. */
 	if (fclus == cluster && *count == 1)
 		return 0;

 	cache_init(&cid, fclus, *dclus);
 	/*
 	 * Update the 'end' to exclude the next cache range, as clusters in
 	 * different cache are typically not contiguous.
 	 */
 	end = exfat_cache_lookup(inode, &cid, cluster, end, &fclus, dclus);

 	/* Return if the cache covers the entire range. */
 	if (cid.fcluster + cid.nr_contig >= end) {
 		*count = end - cluster + 1;
 		return 0;
 	}

 	/* Find the first cluster we need. */
 	while (fclus < cluster) {
 		if (exfat_ent_get(sb, *dclus, &content, &bh))
 			return -EIO;

 		*last_dclus = *dclus;
 		*dclus = content;
 		fclus++;

 		if (content == EXFAT_EOF_CLUSTER)
 			break;

 		if (!cache_contiguous(&cid, *dclus))
 			cache_init(&cid, fclus, *dclus);
 	}

 	/*
 	 * Now the cid cache contains the first cluster requested, collect
 	 * the remaining clusters of this contiguous extent.
 	 */
 	if (*dclus != EXFAT_EOF_CLUSTER) {
 		unsigned int clu = *dclus;

 		while (fclus < end) {
 			if (exfat_ent_get(sb, clu, &content, &bh))
 				return -EIO;
 			if (++clu != content)
 				break;
 			fclus++;
 		}
 		cid.nr_contig = fclus - cid.fcluster;
 		*count = fclus - cluster + 1;

 		/*
 		 * Cache this discontiguous cluster, we'll definitely need
 		 * it later
 		 */
 		if (fclus < end && content != EXFAT_EOF_CLUSTER) {
 			exfat_cache_add(inode, &cid);
 			cache_init(&cid, fclus + 1, content);
 		}
 	} else {
 		*count = 0;
 	}
 	brelse(bh);
 	exfat_cache_add(inode, &cid);
 	return 0;
 }
	// SPDX-License-Identifier: GPL-2.0-or-later
	/*
	* linux/fs/fat/cache.c
	*
	* Written 1992,1993 by Werner Almesberger
	*
	* Mar 1999. AV. Changed cache, so that it uses the starting cluster instead
	* of inode number.
	* May 1999. AV. Fixed the bogosity with FAT32 (read "FAT28"). Fscking lusers.
	* Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
	*/

	#include <linux/slab.h>
	#include <linux/unaligned.h>
	#include <linux/buffer_head.h>

	#include "exfat_raw.h"
	#include "exfat_fs.h"

	#define EXFAT_MAX_CACHE 16

	struct exfat_cache {
	struct list_head cache_list;
	unsigned int nr_contig; /* number of contiguous clusters */
	unsigned int fcluster; /* cluster number in the file. */
	unsigned int dcluster; /* cluster number on disk. */
	};

	struct exfat_cache_id {
	unsigned int id;
	unsigned int nr_contig;
	unsigned int fcluster;
	unsigned int dcluster;
	};

	static struct kmem_cache *exfat_cachep;

	static void exfat_cache_init_once(void *c)
	{
	struct exfat_cache cache = (struct exfat_cache )c;

	INIT_LIST_HEAD(&cache->cache_list);
	}

	int exfat_cache_init(void)
	{
	exfat_cachep = kmem_cache_create("exfat_cache",
	sizeof(struct exfat_cache),
	0, SLAB_RECLAIM_ACCOUNT,
	exfat_cache_init_once);
	if (!exfat_cachep)
	return -ENOMEM;
	return 0;
	}

	void exfat_cache_shutdown(void)
	{
	if (!exfat_cachep)
	return;
	kmem_cache_destroy(exfat_cachep);
	}

	static inline struct exfat_cache *exfat_cache_alloc(void)
	{
	return kmem_cache_alloc(exfat_cachep, GFP_NOFS);
	}

	static inline void exfat_cache_free(struct exfat_cache *cache)
	{
	WARN_ON(!list_empty(&cache->cache_list));
	kmem_cache_free(exfat_cachep, cache);
	}

	static inline void exfat_cache_update_lru(struct inode *inode,
	struct exfat_cache *cache)
	{
	struct exfat_inode_info *ei = EXFAT_I(inode);

	if (ei->cache_lru.next != &cache->cache_list)
	list_move(&cache->cache_list, &ei->cache_lru);
	}

	/*
	* Find the cache that covers or precedes 'fclus' and return the last
	* cluster before the next cache range.
	*/
	static inline unsigned int
	exfat_cache_lookup(struct inode inode, struct exfat_cache_id cid,
	unsigned int fclus, unsigned int end,
	unsigned int cached_fclus, unsigned int cached_dclus)
	{
	struct exfat_inode_info *ei = EXFAT_I(inode);
	static struct exfat_cache nohit = { .fcluster = 0, };
	struct exfat_cache hit = &nohit, p;
	unsigned int tail = 0; /* End boundary of hit cache */

	/*
	* Search range [fclus, end]. Stop early if:
	* 1. Cache covers entire range, or
	* 2. Next cache starts at current cache tail
	*/
	spin_lock(&ei->cache_lru_lock);
	list_for_each_entry(p, &ei->cache_lru, cache_list) {
	/* Find the cache of "fclus" or nearest cache. */
	if (p->fcluster <= fclus) {
	if (p->fcluster < hit->fcluster)
	continue;

	hit = p;
	tail = hit->fcluster + hit->nr_contig;

	/* Current cache covers [fclus, end] completely */
	if (tail >= end)
	break;
	} else if (p->fcluster <= end) {
	end = p->fcluster - 1;

	/*
	* If we have a hit and next cache starts within/at
	* its tail, caches are contiguous, stop searching.
	*/
	if (tail && tail >= end)
	break;
	}
	}
	if (hit != &nohit) {
	unsigned int offset;

	exfat_cache_update_lru(inode, hit);
	cid->id = ei->cache_valid_id;
	cid->nr_contig = hit->nr_contig;
	cid->fcluster = hit->fcluster;
	cid->dcluster = hit->dcluster;

	offset = min(cid->nr_contig, fclus - cid->fcluster);
	*cached_fclus = cid->fcluster + offset;
	*cached_dclus = cid->dcluster + offset;
	}
	spin_unlock(&ei->cache_lru_lock);

	/* Return next cache start or 'end' if no more caches */
	return end;
	}

	static struct exfat_cache exfat_cache_merge(struct inode inode,
	struct exfat_cache_id *new)
	{
	struct exfat_inode_info *ei = EXFAT_I(inode);
	struct exfat_cache *p;

	list_for_each_entry(p, &ei->cache_lru, cache_list) {
	/* Find the same part as "new" in cluster-chain. */
	if (p->fcluster == new->fcluster) {
	if (new->nr_contig > p->nr_contig)
	p->nr_contig = new->nr_contig;
	return p;
	}
	}
	return NULL;
	}

	static void exfat_cache_add(struct inode *inode,
	struct exfat_cache_id *new)
	{
	struct exfat_inode_info *ei = EXFAT_I(inode);
	struct exfat_cache cache, tmp;

	if (new->fcluster == EXFAT_EOF_CLUSTER) /* dummy cache */
	return;

	spin_lock(&ei->cache_lru_lock);
	if (new->id != EXFAT_CACHE_VALID &&
	new->id != ei->cache_valid_id)
	goto unlock; /* this cache was invalidated */

	cache = exfat_cache_merge(inode, new);
	if (cache == NULL) {
	if (ei->nr_caches < EXFAT_MAX_CACHE) {
	ei->nr_caches++;
	spin_unlock(&ei->cache_lru_lock);

	tmp = exfat_cache_alloc();
	if (!tmp) {
	spin_lock(&ei->cache_lru_lock);
	ei->nr_caches--;
	spin_unlock(&ei->cache_lru_lock);
	return;
	}

	spin_lock(&ei->cache_lru_lock);
	cache = exfat_cache_merge(inode, new);
	if (cache != NULL) {
	ei->nr_caches--;
	exfat_cache_free(tmp);
	goto out_update_lru;
	}
	cache = tmp;
	} else {
	struct list_head *p = ei->cache_lru.prev;

	cache = list_entry(p,
	struct exfat_cache, cache_list);
	}
	cache->fcluster = new->fcluster;
	cache->dcluster = new->dcluster;
	cache->nr_contig = new->nr_contig;
	}
	out_update_lru:
	exfat_cache_update_lru(inode, cache);
	unlock:
	spin_unlock(&ei->cache_lru_lock);
	}

	/*
	* Cache invalidation occurs rarely, thus the LRU chain is not updated. It
	* fixes itself after a while.
	*/
	static void __exfat_cache_inval_inode(struct inode *inode)
	{
	struct exfat_inode_info *ei = EXFAT_I(inode);
	struct exfat_cache *cache;

	while (!list_empty(&ei->cache_lru)) {
	cache = list_entry(ei->cache_lru.next,
	struct exfat_cache, cache_list);
	list_del_init(&cache->cache_list);
	ei->nr_caches--;
	exfat_cache_free(cache);
	}
	/* Update. The copy of caches before this id is discarded. */
	ei->cache_valid_id++;
	if (ei->cache_valid_id == EXFAT_CACHE_VALID)
	ei->cache_valid_id++;
	}

	void exfat_cache_inval_inode(struct inode *inode)
	{
	struct exfat_inode_info *ei = EXFAT_I(inode);

	spin_lock(&ei->cache_lru_lock);
	__exfat_cache_inval_inode(inode);
	spin_unlock(&ei->cache_lru_lock);
	}

	static inline int cache_contiguous(struct exfat_cache_id *cid,
	unsigned int dclus)
	{
	cid->nr_contig++;
	return cid->dcluster + cid->nr_contig == dclus;
	}

	static inline void cache_init(struct exfat_cache_id *cid,
	unsigned int fclus, unsigned int dclus)
	{
	cid->id = EXFAT_CACHE_VALID;
	cid->fcluster = fclus;
	cid->dcluster = dclus;
	cid->nr_contig = 0;
	}

	int exfat_get_cluster(struct inode *inode, unsigned int cluster,
	unsigned int dclus, unsigned int count,
	unsigned int *last_dclus)
	{
	struct super_block *sb = inode->i_sb;
	struct exfat_inode_info *ei = EXFAT_I(inode);
	struct buffer_head *bh = NULL;
	struct exfat_cache_id cid;
	unsigned int content, fclus;
	unsigned int end = cluster + *count - 1;

	if (ei->start_clu == EXFAT_FREE_CLUSTER) {
	exfat_fs_error(sb,
	"invalid access to exfat cache (entry 0x%08x)",
	ei->start_clu);
	return -EIO;
	}

	fclus = 0;
	*dclus = ei->start_clu;
	last_dclus = dclus;

	/*
	* This case should not exist, as exfat_map_cluster function doesn't
	* call this routine when start_clu == EXFAT_EOF_CLUSTER.
	* This case is retained here for routine completeness.
	*/
	if (*dclus == EXFAT_EOF_CLUSTER) {
	*count = 0;
	return 0;
	}

	/* If only the first cluster is needed, return now. */
	if (fclus == cluster && *count == 1)
	return 0;

	cache_init(&cid, fclus, *dclus);
	/*
	* Update the 'end' to exclude the next cache range, as clusters in
	* different cache are typically not contiguous.
	*/
	end = exfat_cache_lookup(inode, &cid, cluster, end, &fclus, dclus);

	/* Return if the cache covers the entire range. */
	if (cid.fcluster + cid.nr_contig >= end) {
	*count = end - cluster + 1;
	return 0;
	}

	/* Find the first cluster we need. */
	while (fclus < cluster) {
	if (exfat_ent_get(sb, *dclus, &content, &bh))
	return -EIO;

	last_dclus = dclus;
	*dclus = content;
	fclus++;

	if (content == EXFAT_EOF_CLUSTER)
	break;

	if (!cache_contiguous(&cid, *dclus))
	cache_init(&cid, fclus, *dclus);
	}

	/*
	* Now the cid cache contains the first cluster requested, collect
	* the remaining clusters of this contiguous extent.
	*/
	if (*dclus != EXFAT_EOF_CLUSTER) {
	unsigned int clu = *dclus;

	while (fclus < end) {
	if (exfat_ent_get(sb, clu, &content, &bh))
	return -EIO;
	if (++clu != content)
	break;
	fclus++;
	}
	cid.nr_contig = fclus - cid.fcluster;
	*count = fclus - cluster + 1;

	/*
	* Cache this discontiguous cluster, we'll definitely need
	* it later
	*/
	if (fclus < end && content != EXFAT_EOF_CLUSTER) {
	exfat_cache_add(inode, &cid);
	cache_init(&cid, fclus + 1, content);
	}
	} else {
	*count = 0;
	}
	brelse(bh);
	exfat_cache_add(inode, &cid);
	return 0;
	}