637 lines
18 KiB
C
637 lines
18 KiB
C
/*
|
|
* Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* PROJECT : exFAT & FAT12/16/32 File System */
|
|
/* FILE : sdfat_api.c */
|
|
/* PURPOSE : sdFAT volume lock layer */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
#include <linux/version.h>
|
|
#include <linux/module.h>
|
|
#include <linux/init.h>
|
|
#include <linux/mutex.h>
|
|
|
|
#include "version.h"
|
|
#include "config.h"
|
|
|
|
#include "sdfat.h"
|
|
#include "core.h"
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* Internal structures */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* Constant & Macro Definitions */
|
|
/*----------------------------------------------------------------------*/
|
|
static DEFINE_MUTEX(_lock_core);
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* Global Variable Definitions */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* Local Variable Definitions */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* Local Function Declarations */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
/*======================================================================*/
|
|
/* Global Function Definitions */
|
|
/* - All functions for global use have same return value format, */
|
|
/* that is, 0 on success and minus error number on */
|
|
/* various error condition. */
|
|
/*======================================================================*/
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* sdFAT Filesystem Init & Exit Functions */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
s32 fsapi_init(void)
|
|
{
|
|
return fscore_init();
|
|
}
|
|
|
|
s32 fsapi_shutdown(void)
|
|
{
|
|
return fscore_shutdown();
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* Volume Management Functions */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
/* mount the file system volume */
|
|
s32 fsapi_mount(struct super_block *sb)
|
|
{
|
|
s32 err;
|
|
|
|
/* acquire the core lock for file system ccritical section */
|
|
mutex_lock(&_lock_core);
|
|
|
|
err = meta_cache_init(sb);
|
|
if (err)
|
|
goto out;
|
|
|
|
err = fscore_mount(sb);
|
|
out:
|
|
if (err)
|
|
meta_cache_shutdown(sb);
|
|
|
|
/* release the core lock for file system critical section */
|
|
mutex_unlock(&_lock_core);
|
|
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_mount);
|
|
|
|
/* unmount the file system volume */
|
|
s32 fsapi_umount(struct super_block *sb)
|
|
{
|
|
s32 err;
|
|
|
|
/* acquire the core lock for file system ccritical section */
|
|
mutex_lock(&_lock_core);
|
|
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
err = fscore_umount(sb);
|
|
meta_cache_shutdown(sb);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
|
|
/* release the core lock for file system critical section */
|
|
mutex_unlock(&_lock_core);
|
|
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_umount);
|
|
|
|
/* get the information of a file system volume */
|
|
s32 fsapi_statfs(struct super_block *sb, VOL_INFO_T *info)
|
|
{
|
|
FS_INFO_T *fsi = &(SDFAT_SB(sb)->fsi);
|
|
|
|
/* check the validity of pointer parameters */
|
|
ASSERT(info);
|
|
|
|
if (fsi->used_clusters == (u32) ~0) {
|
|
s32 err;
|
|
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
err = fscore_statfs(sb, info);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
return err;
|
|
}
|
|
|
|
info->FatType = fsi->vol_type;
|
|
info->ClusterSize = fsi->cluster_size;
|
|
info->NumClusters = fsi->num_clusters - 2; /* clu 0 & 1 */
|
|
info->UsedClusters = fsi->used_clusters + fsi->reserved_clusters;
|
|
info->FreeClusters = info->NumClusters - info->UsedClusters;
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_statfs);
|
|
|
|
/* synchronize a file system volume */
|
|
s32 fsapi_sync_fs(struct super_block *sb, s32 do_sync)
|
|
{
|
|
s32 err;
|
|
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
err = fscore_sync_fs(sb, do_sync);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_sync_fs);
|
|
|
|
s32 fsapi_set_vol_flags(struct super_block *sb, u16 new_flag, s32 always_sync)
|
|
{
|
|
s32 err;
|
|
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
err = fscore_set_vol_flags(sb, new_flag, always_sync);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_set_vol_flags);
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* File Operation Functions */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
/* lookup */
|
|
s32 fsapi_lookup(struct inode *inode, u8 *path, FILE_ID_T *fid)
|
|
{
|
|
s32 err;
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
/* check the validity of pointer parameters */
|
|
ASSERT(fid && path);
|
|
|
|
if (unlikely(!strlen(path)))
|
|
return -EINVAL;
|
|
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
err = fscore_lookup(inode, path, fid);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_lookup);
|
|
|
|
/* create a file */
|
|
s32 fsapi_create(struct inode *inode, u8 *path, u8 mode, FILE_ID_T *fid)
|
|
{
|
|
s32 err;
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
/* check the validity of pointer parameters */
|
|
ASSERT(fid && path);
|
|
|
|
if (unlikely(!strlen(path)))
|
|
return -EINVAL;
|
|
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
err = fscore_create(inode, path, mode, fid);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_create);
|
|
|
|
/* read the target string of symlink */
|
|
s32 fsapi_read_link(struct inode *inode, FILE_ID_T *fid, void *buffer, u64 count, u64 *rcount)
|
|
{
|
|
s32 err;
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
/* check the validity of pointer parameters */
|
|
ASSERT(fid && buffer);
|
|
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
err = fscore_read_link(inode, fid, buffer, count, rcount);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_read_link);
|
|
|
|
/* write the target string of symlink */
|
|
s32 fsapi_write_link(struct inode *inode, FILE_ID_T *fid, void *buffer, u64 count, u64 *wcount)
|
|
{
|
|
s32 err;
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
/* check the validity of pointer parameters */
|
|
ASSERT(fid && buffer);
|
|
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
err = fscore_write_link(inode, fid, buffer, count, wcount);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_write_link);
|
|
|
|
/* resize the file length */
|
|
s32 fsapi_truncate(struct inode *inode, u64 old_size, u64 new_size)
|
|
{
|
|
s32 err;
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
TMSG("%s entered (inode %p size %llu)\n", __func__, inode, new_size);
|
|
err = fscore_truncate(inode, old_size, new_size);
|
|
TMSG("%s exitted (%d)\n", __func__, err);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_truncate);
|
|
|
|
/* rename or move a old file into a new file */
|
|
s32 fsapi_rename(struct inode *old_parent_inode, FILE_ID_T *fid,
|
|
struct inode *new_parent_inode, struct dentry *new_dentry)
|
|
{
|
|
s32 err;
|
|
struct super_block *sb = old_parent_inode->i_sb;
|
|
|
|
/* check the validity of pointer parameters */
|
|
ASSERT(fid);
|
|
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
err = fscore_rename(old_parent_inode, fid, new_parent_inode, new_dentry);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_rename);
|
|
|
|
/* remove a file */
|
|
s32 fsapi_remove(struct inode *inode, FILE_ID_T *fid)
|
|
{
|
|
s32 err;
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
/* check the validity of pointer parameters */
|
|
ASSERT(fid);
|
|
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
err = fscore_remove(inode, fid);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_remove);
|
|
|
|
/* get the information of a given file */
|
|
s32 fsapi_read_inode(struct inode *inode, DIR_ENTRY_T *info)
|
|
{
|
|
s32 err;
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
TMSG("%s entered (inode %p info %p\n", __func__, inode, info);
|
|
err = fscore_read_inode(inode, info);
|
|
TMSG("%s exited (err:%d)\n", __func__, err);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_read_inode);
|
|
|
|
/* set the information of a given file */
|
|
s32 fsapi_write_inode(struct inode *inode, DIR_ENTRY_T *info, int sync)
|
|
{
|
|
s32 err;
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
TMSG("%s entered (inode %p info %p sync:%d\n",
|
|
__func__, inode, info, sync);
|
|
err = fscore_write_inode(inode, info, sync);
|
|
TMSG("%s exited (err:%d)\n", __func__, err);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_write_inode);
|
|
|
|
/* return the cluster number in the given cluster offset */
|
|
s32 fsapi_map_clus(struct inode *inode, u32 clu_offset, u32 *clu, int dest)
|
|
{
|
|
s32 err;
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
/* check the validity of pointer parameters */
|
|
ASSERT(clu);
|
|
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
TMSG("%s entered (inode:%p clus:%08x dest:%d\n",
|
|
__func__, inode, *clu, dest);
|
|
err = fscore_map_clus(inode, clu_offset, clu, dest);
|
|
TMSG("%s exited (clu:%08x err:%d)\n", __func__, *clu, err);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_map_clus);
|
|
|
|
/* reserve a cluster */
|
|
s32 fsapi_reserve_clus(struct inode *inode)
|
|
{
|
|
s32 err;
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
TMSG("%s entered (inode:%p)\n", __func__, inode);
|
|
err = fscore_reserve_clus(inode);
|
|
TMSG("%s exited (err:%d)\n", __func__, err);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_reserve_clus);
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* Directory Operation Functions */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
/* create(make) a directory */
|
|
s32 fsapi_mkdir(struct inode *inode, u8 *path, FILE_ID_T *fid)
|
|
{
|
|
s32 err;
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
/* check the validity of pointer parameters */
|
|
ASSERT(fid && path);
|
|
|
|
if (unlikely(!strlen(path)))
|
|
return -EINVAL;
|
|
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
err = fscore_mkdir(inode, path, fid);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_mkdir);
|
|
|
|
/* read a directory entry from the opened directory */
|
|
s32 fsapi_readdir(struct inode *inode, DIR_ENTRY_T *dir_entry)
|
|
{
|
|
s32 err;
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
/* check the validity of pointer parameters */
|
|
ASSERT(dir_entry);
|
|
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
err = fscore_readdir(inode, dir_entry);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_readdir);
|
|
|
|
/* remove a directory */
|
|
s32 fsapi_rmdir(struct inode *inode, FILE_ID_T *fid)
|
|
{
|
|
s32 err;
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
/* check the validity of pointer parameters */
|
|
ASSERT(fid);
|
|
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
err = fscore_rmdir(inode, fid);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_rmdir);
|
|
|
|
/* unlink a file.
|
|
* that is, remove an entry from a directory. BUT don't truncate
|
|
*/
|
|
s32 fsapi_unlink(struct inode *inode, FILE_ID_T *fid)
|
|
{
|
|
s32 err;
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
/* check the validity of pointer parameters */
|
|
ASSERT(fid);
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
err = fscore_unlink(inode, fid);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_unlink);
|
|
|
|
/* reflect the internal dirty flags to VFS bh dirty flags */
|
|
s32 fsapi_cache_flush(struct super_block *sb, int do_sync)
|
|
{
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
fcache_flush(sb, do_sync);
|
|
dcache_flush(sb, do_sync);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_cache_flush);
|
|
|
|
/* release FAT & buf cache */
|
|
s32 fsapi_cache_release(struct super_block *sb)
|
|
{
|
|
#ifdef CONFIG_SDFAT_DEBUG
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
|
|
fcache_release_all(sb);
|
|
dcache_release_all(sb);
|
|
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
#endif /* CONFIG_SDFAT_DEBUG */
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_cache_release);
|
|
|
|
u32 fsapi_get_au_stat(struct super_block *sb, s32 mode)
|
|
{
|
|
/* volume lock is not required */
|
|
return fscore_get_au_stat(sb, mode);
|
|
}
|
|
EXPORT_SYMBOL(fsapi_get_au_stat);
|
|
|
|
/* clear extent cache */
|
|
void fsapi_invalidate_extent(struct inode *inode)
|
|
{
|
|
/* Volume lock is not required,
|
|
* because it is only called by evict_inode.
|
|
* If any other function can call it,
|
|
* you should check whether volume lock is needed or not.
|
|
*/
|
|
extent_cache_inval_inode(inode);
|
|
}
|
|
EXPORT_SYMBOL(fsapi_invalidate_extent);
|
|
|
|
/* check device is ejected */
|
|
s32 fsapi_check_bdi_valid(struct super_block *sb)
|
|
{
|
|
return fscore_check_bdi_valid(sb);
|
|
}
|
|
EXPORT_SYMBOL(fsapi_check_bdi_valid);
|
|
|
|
|
|
|
|
#ifdef CONFIG_SDFAT_DFR
|
|
/*----------------------------------------------------------------------*/
|
|
/* Defragmentation related */
|
|
/*----------------------------------------------------------------------*/
|
|
s32 fsapi_dfr_get_info(struct super_block *sb, void *arg)
|
|
{
|
|
/* volume lock is not required */
|
|
return defrag_get_info(sb, (struct defrag_info_arg *)arg);
|
|
}
|
|
EXPORT_SYMBOL(fsapi_dfr_get_info);
|
|
|
|
s32 fsapi_dfr_scan_dir(struct super_block *sb, void *args)
|
|
{
|
|
s32 err;
|
|
|
|
/* check the validity of pointer parameters */
|
|
ASSERT(args);
|
|
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
err = defrag_scan_dir(sb, (struct defrag_trav_arg *)args);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_dfr_scan_dir);
|
|
|
|
s32 fsapi_dfr_validate_clus(struct inode *inode, void *chunk, int skip_prev)
|
|
{
|
|
s32 err;
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
err = defrag_validate_cluster(inode,
|
|
(struct defrag_chunk_info *)chunk, skip_prev);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_dfr_validate_clus);
|
|
|
|
s32 fsapi_dfr_reserve_clus(struct super_block *sb, s32 nr_clus)
|
|
{
|
|
s32 err;
|
|
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
err = defrag_reserve_clusters(sb, nr_clus);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_dfr_reserve_clus);
|
|
|
|
s32 fsapi_dfr_mark_ignore(struct super_block *sb, unsigned int clus)
|
|
{
|
|
/* volume lock is not required */
|
|
return defrag_mark_ignore(sb, clus);
|
|
}
|
|
EXPORT_SYMBOL(fsapi_dfr_mark_ignore);
|
|
|
|
void fsapi_dfr_unmark_ignore_all(struct super_block *sb)
|
|
{
|
|
/* volume lock is not required */
|
|
defrag_unmark_ignore_all(sb);
|
|
}
|
|
EXPORT_SYMBOL(fsapi_dfr_unmark_ignore_all);
|
|
|
|
s32 fsapi_dfr_map_clus(struct inode *inode, u32 clu_offset, u32 *clu)
|
|
{
|
|
s32 err;
|
|
struct super_block *sb = inode->i_sb;
|
|
|
|
/* check the validity of pointer parameters */
|
|
ASSERT(clu);
|
|
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
err = defrag_map_cluster(inode, clu_offset, clu);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(fsapi_dfr_map_clus);
|
|
|
|
void fsapi_dfr_writepage_endio(struct page *page)
|
|
{
|
|
/* volume lock is not required */
|
|
defrag_writepage_end_io(page);
|
|
}
|
|
EXPORT_SYMBOL(fsapi_dfr_writepage_endio);
|
|
|
|
void fsapi_dfr_update_fat_prev(struct super_block *sb, int force)
|
|
{
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
defrag_update_fat_prev(sb, force);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
}
|
|
EXPORT_SYMBOL(fsapi_dfr_update_fat_prev);
|
|
|
|
void fsapi_dfr_update_fat_next(struct super_block *sb)
|
|
{
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
defrag_update_fat_next(sb);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
}
|
|
EXPORT_SYMBOL(fsapi_dfr_update_fat_next);
|
|
|
|
void fsapi_dfr_check_discard(struct super_block *sb)
|
|
{
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
defrag_check_discard(sb);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
}
|
|
EXPORT_SYMBOL(fsapi_dfr_check_discard);
|
|
|
|
void fsapi_dfr_free_clus(struct super_block *sb, u32 clus)
|
|
{
|
|
mutex_lock(&(SDFAT_SB(sb)->s_vlock));
|
|
defrag_free_cluster(sb, clus);
|
|
mutex_unlock(&(SDFAT_SB(sb)->s_vlock));
|
|
}
|
|
EXPORT_SYMBOL(fsapi_dfr_free_clus);
|
|
|
|
s32 fsapi_dfr_check_dfr_required(struct super_block *sb, int *totalau, int *cleanau, int *fullau)
|
|
{
|
|
/* volume lock is not required */
|
|
return defrag_check_defrag_required(sb, totalau, cleanau, fullau);
|
|
}
|
|
EXPORT_SYMBOL(fsapi_dfr_check_dfr_required);
|
|
|
|
s32 fsapi_dfr_check_dfr_on(struct inode *inode, loff_t start, loff_t end, s32 cancel, const char *caller)
|
|
{
|
|
/* volume lock is not required */
|
|
return defrag_check_defrag_on(inode, start, end, cancel, caller);
|
|
}
|
|
EXPORT_SYMBOL(fsapi_dfr_check_dfr_on);
|
|
|
|
|
|
|
|
#ifdef CONFIG_SDFAT_DFR_DEBUG
|
|
void fsapi_dfr_spo_test(struct super_block *sb, int flag, const char *caller)
|
|
{
|
|
/* volume lock is not required */
|
|
defrag_spo_test(sb, flag, caller);
|
|
}
|
|
EXPORT_SYMBOL(fsapi_dfr_spo_test);
|
|
#endif
|
|
|
|
|
|
#endif /* CONFIG_SDFAT_DFR */
|
|
|
|
/* end of sdfat_api.c */
|