Release 4.10 fs/fat/cache.c

Directory: fs/fat
/*
 *  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.
 */

#include <linux/slab.h>
#include "fat.h"

/* this must be > 0. */

#define FAT_MAX_CACHE	8


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


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



static inline int fat_max_cache(struct inode *inode)
{
	return FAT_MAX_CACHE;
}

Contributors
Person Tokens Prop Commits CommitProp
hirofumi ogawa hirofumi ogawa 14 93.33% 2 66.67%
pre-git pre-git 1 6.67% 1 33.33%
Total 15 100.00% 3 100.00%


static struct kmem_cache *fat_cache_cachep;



static void init_once(void *foo)
{
	struct fat_cache *cache = (struct fat_cache *)foo;

	INIT_LIST_HEAD(&cache->cache_list);
}

Contributors
Person Tokens Prop Commits CommitProp
hirofumi ogawa hirofumi ogawa 22 73.33% 1 20.00%
pre-git pre-git 5 16.67% 3 60.00%
christoph lameter christoph lameter 3 10.00% 1 20.00%
Total 30 100.00% 5 100.00%



int __init fat_cache_init(void)
{
	fat_cache_cachep = kmem_cache_create("fat_cache",
				sizeof(struct fat_cache),
				0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
				init_once);
	if (fat_cache_cachep == NULL)
		return -ENOMEM;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
hirofumi ogawa hirofumi ogawa 28 66.67% 2 33.33%
pre-git pre-git 12 28.57% 3 50.00%
paul jackson paul jackson 2 4.76% 1 16.67%
Total 42 100.00% 6 100.00%



void fat_cache_destroy(void)
{
	kmem_cache_destroy(fat_cache_cachep);
}

Contributors
Person Tokens Prop Commits CommitProp
hirofumi ogawa hirofumi ogawa 8 66.67% 1 50.00%
pre-git pre-git 4 33.33% 1 50.00%
Total 12 100.00% 2 100.00%



static inline struct fat_cache *fat_cache_alloc(struct inode *inode)
{
	return kmem_cache_alloc(fat_cache_cachep, GFP_NOFS);
}

Contributors
Person Tokens Prop Commits CommitProp
hirofumi ogawa hirofumi ogawa 18 81.82% 1 33.33%
pre-git pre-git 3 13.64% 1 33.33%
linus torvalds linus torvalds 1 4.55% 1 33.33%
Total 22 100.00% 3 100.00%



static inline void fat_cache_free(struct fat_cache *cache)
{
	BUG_ON(!list_empty(&cache->cache_list));
	kmem_cache_free(fat_cache_cachep, cache);
}

Contributors
Person Tokens Prop Commits CommitProp
hirofumi ogawa hirofumi ogawa 30 96.77% 1 50.00%
pre-git pre-git 1 3.23% 1 50.00%
Total 31 100.00% 2 100.00%



static inline void fat_cache_update_lru(struct inode *inode,
					struct fat_cache *cache)
{
	if (MSDOS_I(inode)->cache_lru.next != &cache->cache_list)
		list_move(&cache->cache_list, &MSDOS_I(inode)->cache_lru);
}

Contributors
Person Tokens Prop Commits CommitProp
hirofumi ogawa hirofumi ogawa 44 89.80% 1 33.33%
pre-git pre-git 5 10.20% 2 66.67%
Total 49 100.00% 3 100.00%



static int fat_cache_lookup(struct inode *inode, int fclus,
			    struct fat_cache_id *cid,
			    int *cached_fclus, int *cached_dclus)
{
	static struct fat_cache nohit = { .fcluster = 0, };

	struct fat_cache *hit = &nohit, *p;
	int offset = -1;

	spin_lock(&MSDOS_I(inode)->cache_lru_lock);
	list_for_each_entry(p, &MSDOS_I(inode)->cache_lru, cache_list) {
		/* Find the cache of "fclus" or nearest cache. */
		if (p->fcluster <= fclus && hit->fcluster < p->fcluster) {
			hit = p;
			if ((hit->fcluster + hit->nr_contig) < fclus) {
				offset = hit->nr_contig;
			} else {
				offset = fclus - hit->fcluster;
				break;
			}
		}
	}
	if (hit != &nohit) {
		fat_cache_update_lru(inode, hit);

		cid->id = MSDOS_I(inode)->cache_valid_id;
		cid->nr_contig = hit->nr_contig;
		cid->fcluster = hit->fcluster;
		cid->dcluster = hit->dcluster;
		*cached_fclus = cid->fcluster + offset;
		*cached_dclus = cid->dcluster + offset;
	}
	spin_unlock(&MSDOS_I(inode)->cache_lru_lock);

	return offset;
}

Contributors
Person Tokens Prop Commits CommitProp
hirofumi ogawa hirofumi ogawa 184 84.79% 4 44.44%
pre-git pre-git 32 14.75% 4 44.44%
linus torvalds linus torvalds 1 0.46% 1 11.11%
Total 217 100.00% 9 100.00%



static struct fat_cache *fat_cache_merge(struct inode *inode,
					 struct fat_cache_id *new)
{
	struct fat_cache *p;

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

Contributors
Person Tokens Prop Commits CommitProp
hirofumi ogawa hirofumi ogawa 63 77.78% 3 42.86%
pre-git pre-git 16 19.75% 3 42.86%
linus torvalds linus torvalds 2 2.47% 1 14.29%
Total 81 100.00% 7 100.00%



static void fat_cache_add(struct inode *inode, struct fat_cache_id *new)
{
	struct fat_cache *cache, *tmp;

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

	spin_lock(&MSDOS_I(inode)->cache_lru_lock);
	if (new->id != FAT_CACHE_VALID &&
	    new->id != MSDOS_I(inode)->cache_valid_id)
		goto out;	/* this cache was invalidated */

	cache = fat_cache_merge(inode, new);
	if (cache == NULL) {
		if (MSDOS_I(inode)->nr_caches < fat_max_cache(inode)) {
			MSDOS_I(inode)->nr_caches++;
			spin_unlock(&MSDOS_I(inode)->cache_lru_lock);

			tmp = fat_cache_alloc(inode);
			if (!tmp) {
				spin_lock(&MSDOS_I(inode)->cache_lru_lock);
				MSDOS_I(inode)->nr_caches--;
				spin_unlock(&MSDOS_I(inode)->cache_lru_lock);
				return;
			}

			spin_lock(&MSDOS_I(inode)->cache_lru_lock);
			cache = fat_cache_merge(inode, new);
			if (cache != NULL) {
				MSDOS_I(inode)->nr_caches--;
				fat_cache_free(tmp);
				goto out_update_lru;
			}
			cache = tmp;
		} else {
			struct list_head *p = MSDOS_I(inode)->cache_lru.prev;
			cache = list_entry(p, struct fat_cache, cache_list);
		}
		cache->fcluster = new->fcluster;
		cache->dcluster = new->dcluster;
		cache->nr_contig = new->nr_contig;
	}
out_update_lru:
	fat_cache_update_lru(inode, cache);
out:
	spin_unlock(&MSDOS_I(inode)->cache_lru_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
hirofumi ogawa hirofumi ogawa 242 83.74% 5 55.56%
pre-git pre-git 36 12.46% 3 33.33%
linus torvalds linus torvalds 11 3.81% 1 11.11%
Total 289 100.00% 9 100.00%

/*
 * Cache invalidation occurs rarely, thus the LRU chain is not updated. It
 * fixes itself after a while.
 */


static void __fat_cache_inval_inode(struct inode *inode)
{
	struct msdos_inode_info *i = MSDOS_I(inode);
	struct fat_cache *cache;

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

Contributors
Person Tokens Prop Commits CommitProp
hirofumi ogawa hirofumi ogawa 76 82.61% 3 60.00%
pre-git pre-git 13 14.13% 1 20.00%
linus torvalds linus torvalds 3 3.26% 1 20.00%
Total 92 100.00% 5 100.00%



void fat_cache_inval_inode(struct inode *inode)
{
	spin_lock(&MSDOS_I(inode)->cache_lru_lock);
	__fat_cache_inval_inode(inode);
	spin_unlock(&MSDOS_I(inode)->cache_lru_lock);
}

Contributors
Person Tokens Prop Commits CommitProp
hirofumi ogawa hirofumi ogawa 31 83.78% 2 66.67%
pre-git pre-git 6 16.22% 1 33.33%
Total 37 100.00% 3 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
hirofumi ogawa hirofumi ogawa 33 94.29% 3 75.00%
pre-git pre-git 2 5.71% 1 25.00%
Total 35 100.00% 4 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
hirofumi ogawa hirofumi ogawa 40 95.24% 3 60.00%
pre-git pre-git 1 2.38% 1 20.00%
linus torvalds linus torvalds 1 2.38% 1 20.00%
Total 42 100.00% 5 100.00%



int fat_get_cluster(struct inode *inode, int cluster, int *fclus, int *dclus)
{
	struct super_block *sb = inode->i_sb;
	const int limit = sb->s_maxbytes >> MSDOS_SB(sb)->cluster_bits;
	struct fat_entry fatent;
	struct fat_cache_id cid;
	int nr;

	BUG_ON(MSDOS_I(inode)->i_start == 0);

	*fclus = 0;
	*dclus = MSDOS_I(inode)->i_start;
	if (cluster == 0)
		return 0;

	if (fat_cache_lookup(inode, cluster, &cid, fclus, dclus) < 0) {
		/*
                 * dummy, always not contiguous
                 * This is reinitialized by cache_init(), later.
                 */
		cache_init(&cid, -1, -1);
	}

	fatent_init(&fatent);
	while (*fclus < cluster) {
		/* prevent the infinite loop of cluster chain */
		if (*fclus > limit) {
			fat_fs_error_ratelimit(sb,
					"%s: detected the cluster chain loop"
					" (i_pos %lld)", __func__,
					MSDOS_I(inode)->i_pos);
			nr = -EIO;
			goto out;
		}

		nr = fat_ent_read(inode, &fatent, *dclus);
		if (nr < 0)
			goto out;
		else if (nr == FAT_ENT_FREE) {
			fat_fs_error_ratelimit(sb,
				       "%s: invalid cluster chain (i_pos %lld)",
				       __func__,
				       MSDOS_I(inode)->i_pos);
			nr = -EIO;
			goto out;
		} else if (nr == FAT_ENT_EOF) {
			fat_cache_add(inode, &cid);
			goto out;
		}
		(*fclus)++;
		*dclus = nr;
		if (!cache_contiguous(&cid, *dclus))
			cache_init(&cid, *fclus, *dclus);
	}
	nr = 0;
	fat_cache_add(inode, &cid);
out:
	fatent_brelse(&fatent);
	return nr;
}

Contributors
Person Tokens Prop Commits CommitProp
hirofumi ogawa hirofumi ogawa 295 95.78% 6 60.00%
pre-git pre-git 10 3.25% 2 20.00%
harvey harrison harvey harrison 2 0.65% 1 10.00%
cruz julian bishop cruz julian bishop 1 0.32% 1 10.00%
Total 308 100.00% 10 100.00%



static int fat_bmap_cluster(struct inode *inode, int cluster)
{
	struct super_block *sb = inode->i_sb;
	int ret, fclus, dclus;

	if (MSDOS_I(inode)->i_start == 0)
		return 0;

	ret = fat_get_cluster(inode, cluster, &fclus, &dclus);
	if (ret < 0)
		return ret;
	else if (ret == FAT_ENT_EOF) {
		fat_fs_error(sb, "%s: request beyond EOF (i_pos %lld)",
			     __func__, MSDOS_I(inode)->i_pos);
		return -EIO;
	}
	return dclus;
}

Contributors
Person Tokens Prop Commits CommitProp
hirofumi ogawa hirofumi ogawa 62 62.00% 4 50.00%
pre-git pre-git 36 36.00% 2 25.00%
harvey harrison harvey harrison 1 1.00% 1 12.50%
denis karpov denis karpov 1 1.00% 1 12.50%
Total 100 100.00% 8 100.00%



int fat_get_mapped_cluster(struct inode *inode, sector_t sector,
			   sector_t last_block,
			   unsigned long *mapped_blocks, sector_t *bmap)
{
	struct super_block *sb = inode->i_sb;
	struct msdos_sb_info *sbi = MSDOS_SB(sb);
	int cluster, offset;

	cluster = sector >> (sbi->cluster_bits - sb->s_blocksize_bits);
	offset  = sector & (sbi->sec_per_clus - 1);
	cluster = fat_bmap_cluster(inode, cluster);
	if (cluster < 0)
		return cluster;
	else if (cluster) {
		*bmap = fat_clus_to_blknr(sbi, cluster) + offset;
		*mapped_blocks = sbi->sec_per_clus - offset;
		if (*mapped_blocks > last_block - sector)
			*mapped_blocks = last_block - sector;
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
namjae jeon namjae jeon 69 49.29% 1 12.50%
pre-git pre-git 35 25.00% 3 37.50%
hirofumi ogawa hirofumi ogawa 23 16.43% 3 37.50%
linus torvalds linus torvalds 13 9.29% 1 12.50%
Total 140 100.00% 8 100.00%



static int is_exceed_eof(struct inode *inode, sector_t sector,
			 sector_t *last_block, int create)
{
	struct super_block *sb = inode->i_sb;
	const unsigned long blocksize = sb->s_blocksize;
	const unsigned char blocksize_bits = sb->s_blocksize_bits;

	*last_block = (i_size_read(inode) + (blocksize - 1)) >> blocksize_bits;
	if (sector >= *last_block) {
		if (!create)
			return 1;

		/*
                 * ->mmu_private can access on only allocation path.
                 * (caller must hold ->i_mutex)
                 */
		*last_block = (MSDOS_I(inode)->mmu_private + (blocksize - 1))
			>> blocksize_bits;
		if (sector >= *last_block)
			return 1;
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
namjae jeon namjae jeon 56 47.86% 1 16.67%
hirofumi ogawa hirofumi ogawa 35 29.91% 1 16.67%
pre-git pre-git 14 11.97% 3 50.00%
linus torvalds linus torvalds 12 10.26% 1 16.67%
Total 117 100.00% 6 100.00%



int fat_bmap(struct inode *inode, sector_t sector, sector_t *phys,
	     unsigned long *mapped_blocks, int create, bool from_bmap)
{
	struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb);
	sector_t last_block;

	*phys = 0;
	*mapped_blocks = 0;
	if ((sbi->fat_bits != 32) && (inode->i_ino == MSDOS_ROOT_INO)) {
		if (sector < (sbi->dir_entries >> sbi->dir_per_block_bits)) {
			*phys = sector + sbi->dir_start;
			*mapped_blocks = 1;
		}
		return 0;
	}

	if (!from_bmap) {
		if (is_exceed_eof(inode, sector, &last_block, create))
			return 0;
	} else {
		last_block = inode->i_blocks >>
				(inode->i_sb->s_blocksize_bits - 9);
		if (sector >= last_block)
			return 0;
	}

	return fat_get_mapped_cluster(inode, sector, last_block, mapped_blocks,
				      phys);
}
Contributors
Person Tokens Prop Commits CommitProp
namjae jeon namjae jeon 137 79.65% 1 16.67%
hirofumi ogawa hirofumi ogawa 23 13.37% 3 50.00%
pre-git pre-git 10 5.81% 1 16.67%
linus torvalds linus torvalds 2 1.16% 1 16.67%
Total 172 100.00% 6 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
hirofumi ogawa hirofumi ogawa 1318 69.77% 18 45.00%
namjae jeon namjae jeon 262 13.87% 1 2.50%
pre-git pre-git 248 13.13% 11 27.50%
linus torvalds linus torvalds 46 2.44% 3 7.50%
christoph lameter christoph lameter 5 0.26% 2 5.00%
tejun heo tejun heo 3 0.16% 1 2.50%
harvey harrison harvey harrison 3 0.16% 1 2.50%
paul jackson paul jackson 2 0.11% 1 2.50%
cruz julian bishop cruz julian bishop 1 0.05% 1 2.50%
denis karpov denis karpov 1 0.05% 1 2.50%
Total 1889 100.00% 40 100.00%
Directory: fs/fat

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
hirofumi ogawa	hirofumi ogawa	14	93.33%	2	66.67%
pre-git	pre-git	1	6.67%	1	33.33%
	Total	15	100.00%	3	100.00%
cregit-Linux how code gets into the kernel

Release 4.10 fs/fat/cache.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
