// 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 intexfat_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;}