static struct buffer_head *minix_update_inode(struct inode *inode)
{
if (INODE_VERSION(inode) == MINIX_V1)
return V1_minix_update_inode(inode);
else
return V2_minix_update_inode(inode);
}
static void minix_clear_inode(struct inode *inode)
{
struct buffer_head *bh = NULL;
printk(KERN_INFO "bitmap: minix_clear_inode\n");
if (INODE_VERSION(inode) == MINIX_V1) {
struct minix_inode *raw_inode;
raw_inode = minix_V1_raw_inode(inode->i_sb, inode->i_ino, &bh);
if (raw_inode) {
raw_inode->i_nlinks = 0;
raw_inode->i_mode = 0;
}
} else {
struct minix2_inode *raw_inode;
raw_inode = minix_V2_raw_inode(inode->i_sb, inode->i_ino, &bh);
if (raw_inode) {
raw_inode->i_nlinks = 0;
raw_inode->i_mode = 0;
}
}
if (bh) {
mark_buffer_dirty(bh);
brelse (bh);
}
}
/*
* The global function to read an inode.
*/
static void minix_read_inode(struct inode * inode)
{
if (INODE_VERSION(inode) == MINIX_V1)
V1_minix_read_inode(inode);
else
V2_minix_read_inode(inode);
}
static int minix_get_block(struct inode *inode, sector_t block,
struct buffer_head *bh_result, int create)
{
if (INODE_VERSION(inode) == MINIX_V1)
return V1_minix_get_block(inode, block, bh_result, create);
else
return V2_minix_get_block(inode, block, bh_result, create);
}
/*
* The function that is called for file truncation.
*/
void minix_truncate(struct inode * inode)
{
if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)))
return;
if (INODE_VERSION(inode) == MINIX_V1)
V1_minix_truncate(inode);
else
V2_minix_truncate(inode);
}
int minix_sync_file(struct file * file, struct dentry *dentry)
{
struct inode *inode = dentry->d_inode;
if (INODE_VERSION(inode) == MINIX_V1)
return V1_minix_sync_file(inode, file);
else
return V2_minix_sync_file(inode, file);
}
int minix_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
{
generic_fillattr(dentry->d_inode, stat);
if (INODE_VERSION(dentry->d_inode) == MINIX_V1)
stat->blocks = (BLOCK_SIZE / 512) * V1_minix_blocks(stat->size);
else
stat->blocks = (BLOCK_SIZE / 512) * V2_minix_blocks(stat->size);
stat->blksize = BLOCK_SIZE;
return 0;
}
int minix_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
{
struct super_block *sb = dentry->d_sb;
generic_fillattr(d_inode(dentry), stat);
if (INODE_VERSION(d_inode(dentry)) == MINIX_V1)
stat->blocks = (BLOCK_SIZE / 512) * V1_minix_blocks(stat->size, sb);
else
stat->blocks = (sb->s_blocksize / 512) * V2_minix_blocks(stat->size, sb);
stat->blksize = sb->s_blocksize;
return 0;
}
/*
* The global function to read an inode.
*/
struct inode *minix_iget(struct super_block *sb, unsigned long ino)
{
struct inode *inode;
inode = iget_locked(sb, ino);
if (!inode)
return ERR_PTR(-ENOMEM);
if (!(inode->i_state & I_NEW))
return inode;
if (INODE_VERSION(inode) == MINIX_V1)
return V1_minix_iget(inode);
else
return V2_minix_iget(inode);
}
static int minix_write_inode(struct inode *inode, struct writeback_control *wbc)
{
int err = 0;
struct buffer_head *bh;
if (INODE_VERSION(inode) == MINIX_V1)
bh = V1_minix_update_inode(inode);
else
bh = V2_minix_update_inode(inode);
if (!bh)
return -EIO;
if (wbc->sync_mode == WB_SYNC_ALL && buffer_dirty(bh)) {
sync_dirty_buffer(bh);
if (buffer_req(bh) && !buffer_uptodate(bh)) {
printk("IO error syncing minix inode [%s:%08lx]\n",
inode->i_sb->s_id, inode->i_ino);
err = -EIO;
}
}
brelse (bh);
return err;
}
static int
unixfs_internal_namei(ino_t parentino, const char* name, struct stat* stbuf)
{
if (parentino == OSXFUSE_ROOTINO)
parentino = MINIX_ROOT_INO;
stbuf->st_ino = ENOENT;
struct inode* dir = unixfs_internal_iget(parentino);
if (!dir)
return ENOENT;
if (!S_ISDIR(dir->I_mode)) {
unixfs_internal_iput(dir);
return ENOTDIR;
}
int ret = ENOENT;
unsigned long namelen = strlen(name);
unsigned long start, n;
unsigned long npages = minix_dir_pages(dir);
minix3_dirent* de3;
minix_dirent* de;
char page[PAGE_SIZE];
char* kaddr = NULL;
struct super_block* sb = dir->I_sb;
struct minix_sb_info* sbi = minix_sb(sb);
unsigned chunk_size = sbi->s_dirsize;
struct minix_inode_info* minix_inode = minix_i(dir);
start = minix_inode->i_dir_start_lookup;
if (start >= npages)
start = 0;
n = start;
ino_t found_ino = 0;
do {
int error = minixfs_get_page(dir, n, page);
if (!error) {
kaddr = (char*)page;
if (INODE_VERSION(dir) == MINIX_V3) {
de3 = (minix3_dirent*)kaddr;
kaddr += PAGE_CACHE_SIZE - chunk_size;
for (; (char*)de3 <= kaddr; de3++) {
if (!de3->inode)
continue;
if (minix_namecompare(namelen, chunk_size,
name, de3->name)) {
found_ino = de3->inode;
goto found;
}
}
} else {
de = (minix_dirent*)kaddr;
kaddr += PAGE_CACHE_SIZE - chunk_size;
for (; (char*)de <= kaddr; de++) {
if (!de->inode)
continue;
if (minix_namecompare(namelen, chunk_size,
name, de->name)) {
found_ino = de->inode;
goto found;
}
}
}
}
if (++n >= npages)
n = 0;
} while (n != start);
found:
if (found_ino)
minix_inode->i_dir_start_lookup = n;
unixfs_internal_iput(dir);
if (found_ino)
ret = unixfs_internal_igetattr(found_ino, stbuf);
return ret;
}
