source: trunk/kernel/fs/fatfs/fat32_node.c @ 2

/*
 * fat32/fat32_node.c - fat32 node related operations
 *
 * Copyright (c) 2008,2009,2010,2011,2012 Ghassan Almaless
 * Copyright (c) 2011,2012 UPMC Sorbonne Universites
 *
 * This file is part of ALMOS-kernel.
 *
 * ALMOS-kernel 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; version 2.0 of the License.
 *
 * ALMOS-kernel 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 ALMOS-kernel; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <kmem.h>
#include <string.h>
#include <thread.h>
#include <cluster.h>
#include <ppm.h>
#include <pmm.h>
#include <page.h>
#include <mapper.h>
#include <vfs.h>

#include <fat32.h>
#include <fat32-private.h>


KMEM_OBJATTR_INIT(vfat_kmem_inode_init)
{
        attr->type   = KMEM_VFAT_NODE;
        attr->name   = "KCM VFAT Node";
        attr->size   = sizeof(struct vfat_inode_s);
        attr->aligne = 0;
        attr->min    = CONFIG_VFAT_NODE_MIN;
        attr->max    = CONFIG_VFAT_NODE_MAX;
        attr->ctor   = NULL;
        attr->dtor   = NULL;
        return 0;
}


inline void vfat_getshortname(char *from, char *to) {
        char *p = to;
        char *q = from;
        uint_fast8_t d;

        for(d=0; (d < 8 && *q != ' '); d++)
                *p++ = *q++;

        if (*(q = &from[8]) != ' ')
        {
                *p++ = '.';
                d = 0;
                while (d++ < 3 && *q != ' ')
                        *p++ = *q++;
        }

        *p = 0;
}

static inline void vfat_convert_name(char *str1, char *str2) {
        uint_fast8_t i;
        char *extention_ptr;

        extention_ptr = str2 + 8;
        memset(str2,' ',11);

        for(i=0; ((*str1) && (*str1 != '.') && (i<11)) ; i++)
                *str2++ = *str1++;

        if((i<=8) && (*str1 == '.')) {
                str1++;
                memcpy(extention_ptr,str1,3);
        }
}


VFS_INIT_NODE(vfat_init_node)
{
        struct vfat_inode_s *inode_info;
        kmem_req_t req;

        if(inode->i_type != VFS_VFAT_TYPE)
                return VFS_EINVAL;

        assert(inode->i_mapper);

        if(inode->i_pv != NULL)
                inode_info = (struct vfat_inode_s*)inode->i_pv;//?
        else 
        {
                req.flags = AF_USER;//?
                req.type = KMEM_VFAT_NODE;
                req.size = sizeof(*inode_info);
    
                if((inode_info = kmem_alloc(&req)) == NULL)
                {
                        return VFS_ENOMEM;
                }
     
                inode->i_pv = (void *) inode_info;
        }

        memset(inode_info, 0, sizeof(*inode_info));    
        return 0;
}


VFS_RELEASE_NODE(vfat_release_node)
{
        kmem_req_t req;
  
        if(inode->i_pv != NULL)
        {
                req.type = KMEM_VFAT_NODE;
                req.ptr  = inode->i_pv;
                kmem_free(&req);
                inode->i_pv = NULL;
        }
  
        return 0;
}


VFS_ICREATE_NODE(vfat_icreate)
{
        struct vfat_inode_s *inode_info;
        struct vfat_context_s *ctx;
        struct page_s *tmp_page;
        kmem_req_t req;
        error_t err;

        
        err                             = 0;
        ctx                             = &ic->ctx->ctx_vfat;
        inode_info                      = inode->i_pv;
        assert(inode->i_mapper);
        inode->i_mapper->m_ops          = &vfat_file_mapper_op;

        inode_info->flags               = ic->vfat_icreate.fat_attr;
        inode_info->first_cluster       = ic->vfat_icreate.first_cluster;

        vfat_dmsg(1, "Creating new inode with flags %x\n", inode_info->flags);


        if(ic->attr & VFS_DIR) 
        {
                inode->i_mapper->m_ops = &vfat_inode_mapper_op;

                if(ic->new)
                {
                        req.type  = KMEM_PAGE;
                        req.size  = 0;
                        req.flags = AF_USER | AF_ZERO;
                        tmp_page  = kmem_alloc(&req);
              
                        if(tmp_page != NULL)
                                err = mapper_add_page(inode->i_mapper, tmp_page, 0);
                        else 
                                err = ENOMEM;

                        if(err)
                        {
                                if(tmp_page != NULL)
                                {
                                        req.ptr = tmp_page;
                                        kmem_free(&req);
                                }
                                return err;
                        }
                        /* FIXME: we should also create dot & dotdot entries */
                }
 
        }

        return err;
}

//parent must be refcounted!
//dentry must be set as INLOAD: no other thread can
//deleted or insert it's entry!
VFS_CREATE_NODE(vfat_create) 
{
        struct vfat_dentry_s *dentry_info;
        struct vfat_inode_s *parent_info;
        struct vfat_context_s *ctx;
        struct page_s *page;
        struct mapper_s *mapper;
        struct vfat_DirEntry_s *dir;
        struct page_s *tmp_page;
        kmem_req_t req;
        uint_t current_page;
        uint_t entries_nr;
        uint_t entry;
        vfat_cluster_t new_cluster;
        size_t current_offset;
        error_t err;

        ctx         = &parent->i_ctx->ctx_vfat;
        entries_nr  = PMM_PAGE_SIZE / sizeof(struct vfat_DirEntry_s);
        mapper      = parent->i_mapper;
        dir         = NULL;
        parent_info = NULL;
        new_cluster = 0;
        err         = 0;
        entry       = 0;
        page        = NULL;

        vfat_dmsg(1,"vfat_create started, dentry/node to be created %s, its parent %s\n",
                  dentry->d_name, parent->i_number);

        if(dentry->d_ctx->ctx_type != VFS_VFAT_TYPE)
                return VFS_EINVAL;

        // find a first cluster for the new file
        if(!(dentry->d_attr & (VFS_FIFO | VFS_DEV)))
        {
                if(vfat_alloc_fat_entry(ctx, &new_cluster))
                        return VFS_IO_ERR;
    
                if(new_cluster == 0)
                        return -VFS_ENOSPC;
        }

        dentry_info    = &dentry->d_vfat;
        parent_info    = (struct vfat_inode_s*) parent->i_pv;
        current_page   = 0;
        current_offset = 0;

        while(1) 
        {
                //TODO: lock the page in read_only to read it and then lock it back to lock to modify it or 
                //use CAS to allocate entrys ?
                if ((page = mapper_get_page(mapper, current_page, MAPPER_SYNC_OP)) == NULL)
                {
                        err = VFS_IO_ERR;
                        goto VFAT_CREATE_NODE_ERR;
                }

                dir = (struct vfat_DirEntry_s*) ppm_page2addr(page);
    
                page_lock(page);
    
                for(entry=0; entry < entries_nr; entry ++)
                {
                        if((dir[entry].DIR_Name[0] == 0x00) || (dir[entry].DIR_Name[0] == 0xE5))
                        {
                                vfat_dmsg(1,"%s: found entry %d in page %d, name[0] %d\n",
                                          __FUNCTION__,
                                          entry, 
                                          current_page, 
                                          dir[entry].DIR_Name[0]);
                                goto FREE_ENTRY_FOUND;
                        }
                        current_offset += sizeof (struct vfat_DirEntry_s);
                }
    
                page_unlock(page);
                current_page ++;
        }

FREE_ENTRY_FOUND:
        current_offset += sizeof (struct vfat_DirEntry_s);
        // we need to set the next entry to 0 if we got the last one
        if (dir[entry].DIR_Name[0] == 0x00) 
        {
                if(entry == entries_nr - 1) 
                {
                        req.type  = KMEM_PAGE;
                        req.size  = 0;
                        req.flags = AF_USER | AF_ZERO;
                        tmp_page  = kmem_alloc(&req);
      
                        if(tmp_page != NULL)
                                err = mapper_add_page(mapper, tmp_page, current_page + 1);
                        else 
                                err = ENOMEM;

                        if(err)
                        {
                                page_unlock(page);

                                if(tmp_page != NULL)
                                {
                                        req.ptr = tmp_page;
                                        kmem_free(&req);
                                }

                                goto VFAT_CREATE_NODE_ERR;
                        }
                
                        mapper->m_ops->set_page_dirty(tmp_page);

                        if (current_offset == parent->i_size)
                                parent->i_size += ctx->bytes_per_cluster;
                }
                else
                        dir[entry+1].DIR_Name[0] = 0x00;
        }

        dir[entry].DIR_FstClusHI = new_cluster >> 16;
        dir[entry].DIR_FstClusLO = new_cluster & 0xFFFF;
        dir[entry].DIR_FileSize  = 0;
        dir[entry].DIR_Attr      = 0;

        if((dentry->d_attr & (VFS_SYS | VFS_FIFO | VFS_DEV)))
                dir[entry].DIR_Attr |= VFAT_ATTR_SYSTEM;

        if(dentry->d_attr & VFS_ARCHIVE)
                dir[entry].DIR_Attr |= VFAT_ATTR_ARCHIVE;

        if((dentry->d_attr & (VFS_RD_ONLY | VFS_FIFO | VFS_DEV)))
                dir[entry].DIR_Attr |= VFAT_ATTR_READ_ONLY;

        if(dentry->d_attr & VFS_DIR)
                dir[entry].DIR_Attr  |= VFAT_ATTR_DIRECTORY;

        vfat_convert_name(dentry->d_name,(char *)dir[entry].DIR_Name);  /* FIXME: name may be long */


#if VFAT_INSTRUMENT
        wr_count ++;
#endif

        dentry_info->entry_index    = current_page*entries_nr + entry;
        dentry_info->first_cluster  = new_cluster;
        page_unlock(page);

        uint32_t ino = vfs_inum_new(parent->i_ctx);
        /* As a dir has alwas a page allocated */
        uint32_t isize = dentry->d_attr & VFS_DIR ? ctx->bytes_per_cluster : 0;

        struct vfs_icreate_s ic = 
                        {.ctx = parent->i_ctx, 
                        .dentry = dentry, 
                        .parent = {.ptr = parent, 
                                .gc = parent->i_gc, 
                                .cid = current_cid},
                        .ino = ino,
                        .size = isize,
                        .attr = dentry->d_attr
                        };

        ic.vfat_icreate.first_cluster = new_cluster;
        ic.vfat_icreate.fat_attr = dir[entry].DIR_Attr;

        err = vfs_create_inode(&ic);

        if(!err)
                return 0;

        //find the page of dir, lock it and remove the entry!
        page_lock(page); //FIXME: is the page still valid ?
        dir->DIR_Name[0] = (dir[1].DIR_Name[0] == 0x00) ? 0x00 : 0xE5;
        page_unlock(page);

VFAT_CREATE_NODE_ERR:
        vfat_free_fat_entry(ctx, new_cluster);
        return err;
}


//Synchro: since the corresponding dentry is set INLOAD
//no one can delete the dentry
VFS_LOOKUP_NODE(vfat_lookup)
{
        struct vfat_context_s *ctx;
        struct vfat_inode_s *parent_info;
        struct vfat_dentry_s *dentry_info;
        struct vfat_entry_request_s rq;
        struct vfat_DirEntry_s dir;
        size_t isize;
        vfat_cluster_t first_cluster;
        uint_t entry_index;
        error_t err;

        ctx         = &parent->i_ctx->ctx_vfat;
        parent_info = parent->i_pv;
        dentry_info = &dentry->d_vfat;
        err         = 0;
        isize       = 0;

        if(!(parent_info->flags & VFAT_ATTR_DIRECTORY))
                return VFS_ENOTDIR;

        rq.ctx         = ctx;
        rq.parent      = parent;
        rq.entry       = &dir;
        rq.entry_name  = dentry->d_name;
        rq.entry_index = &entry_index;

        if((err=vfat_locate_entry(&rq)))
                return err;

#if 0
        if(((node->i_attr & VFS_DIR) && 1) ^ ((dir.DIR_Attr & VFAT_ATTR_DIRECTORY) && 1))
                return VFS_ENOTDIR;
#else
        if((dentry->d_attr & VFS_DIR) && !(dir.DIR_Attr & VFAT_ATTR_DIRECTORY))
                return VFS_ENOTDIR;
#endif

        if(dir.DIR_Attr & VFAT_ATTR_DIRECTORY)
                dentry->d_attr |= VFS_DIR;
        else
                isize = dir.DIR_FileSize;

        if(dir.DIR_Attr & VFAT_ATTR_SYSTEM)    dentry->d_attr |= VFS_SYS;
        if(dir.DIR_Attr & VFAT_ATTR_ARCHIVE)   dentry->d_attr |= VFS_ARCHIVE;
        if(dir.DIR_Attr & VFAT_ATTR_READ_ONLY) dentry->d_attr |= VFS_RD_ONLY;
 
        first_cluster                   = dir.DIR_FstClusHI << 16;
        first_cluster                   |= (0x0000FFFF & dir.DIR_FstClusLO);

        if((!first_cluster)   && 
           (dentry->d_attr & VFS_SYS)     && 
           (dentry->d_attr & VFS_RD_ONLY) && 
           (dentry->d_attr & VFS_DIR)) 
        {
                dentry->d_attr |= VFS_DEV;
                dentry->d_attr &= ~(VFS_SYS | VFS_RD_ONLY | VFS_DIR);
        } 
        else
        {
                if((!first_cluster) && 
                   (dentry->d_attr & VFS_SYS)   && 
                   (dentry->d_attr & VFS_RD_ONLY)) 
                {
                        dentry->d_attr |= VFS_FIFO;
                        dentry->d_attr &= ~(VFS_SYS | VFS_RD_ONLY);
                }
        }

        if((first_cluster) && (dentry->d_attr & VFS_DIR))
                isize = vfat_cluster_count(ctx, first_cluster) * ctx->bytes_per_cluster;

        dentry_info->entry_index        = entry_index;
        dentry_info->first_cluster      = first_cluster;

        uint32_t ino = vfs_inum_new(parent->i_ctx);
        /* As a dir has alwas a page allocated */

        struct vfs_icreate_s ic = 
                        {.ctx = parent->i_ctx, 
                        .dentry = dentry, 
                        .parent = {.ptr = parent, 
                                .gc = parent->i_gc, 
                                .cid = current_cid},
                        .ino = ino,
                        .size = isize,
                        .attr = dentry->d_attr,
                        };

        ic.vfat_icreate.first_cluster = first_cluster;
        ic.vfat_icreate.fat_attr = dir.DIR_Attr;

        err = vfs_create_inode(&ic);

        //drop page ?
        if(err) return err;

        return VFS_FOUND;
}

VFS_STAT_NODE(vfat_stat_node)
{
        struct vfat_inode_s *inode_info;

        inode_info = inode->i_pv;

        return vfs_stat_inode(inode, inode_info->first_cluster);
}

RPC_DECLARE(__vfat_write_inode, RPC_RET(RPC_RET_PTR(error_t, err)),
                RPC_ARG(RPC_ARG_VAL(struct vfs_dentry_s*, dentry), 
                RPC_ARG_VAL(size_t, size),
                RPC_ARG_VAL(uint32_t, attr)))
{
        struct page_s *page;
        struct mapper_s *mapper;
        struct vfs_inode_s *parent;
        struct vfat_dentry_s *dentry_info;
        struct vfat_DirEntry_s *dir;
        uint_t entry_index_page;

        parent          = dentry->d_parent;
        mapper          = parent->i_mapper;
        dentry_info     = &dentry->d_vfat;
        entry_index_page = dentry_info->entry_index * sizeof(struct vfat_DirEntry_s*) >> PMM_PAGE_SHIFT;
        dentry->d_attr  = attr; 

        *err = VFS_EINVAL;
        if(dentry->d_ctx->ctx_type != VFS_VFAT_TYPE)
                return; 

        *err = VFS_IO_ERR;
        //rd_lock is enough since we are supposed to be holding the dentry above with the INLOAD flag
        if ((page = mapper_get_page(mapper, entry_index_page, MAPPER_SYNC_OP)) == NULL)
                return; 

        //do the locking of mapper_get_page, like : MAPPER_PAGE_RD_LOCK
        page_lock(page);

        dir  = (struct vfat_DirEntry_s*) ppm_page2addr(page);
        dir += dentry_info->entry_index;

        if(attr & VFS_DIR) dir->DIR_Attr |= VFAT_ATTR_DIRECTORY;
        if(attr & VFS_SYS) dir->DIR_Attr |= VFAT_ATTR_SYSTEM;
        if(attr & VFS_ARCHIVE) dir->DIR_Attr |= VFAT_ATTR_ARCHIVE;
        if(attr & VFS_RD_ONLY) dir->DIR_Attr |= VFAT_ATTR_READ_ONLY;

        dir->DIR_FileSize = size;

        mapper->m_ops->set_page_dirty(page);

        page_unlock(page);

        *err = 0;
}

//update the dentry of this inode 
//FIXME: check syncro
VFS_WRITE_NODE(vfat_write_node)
{
        struct vfs_dentry_s *dentry;
        cid_t dentry_cid;
        error_t err;
        uint32_t attr;
        size_t isize;

        dentry          = inode->i_dentry;
        dentry_cid      = inode->i_parent.cid;
        isize           = inode->i_size;
        attr            = inode->i_attr;

        RCPC(dentry_cid, RPC_PRIO_FS_WRITE, __vfat_write_inode, RPC_RECV(RPC_RECV_OBJ(err)),
                RPC_SEND(RPC_SEND_OBJ(dentry), RPC_SEND_OBJ(isize), RPC_SEND_OBJ(attr)));

#if VFAT_INSTRUMENT
        wr_count ++;
#endif
        return err;
}

#if 1
/* Check if dir is empty and    *
 * empty dir/files
 * return 0 if success
 * else return 1                *
 * The deletion of the inode is *
 * no necesseray for the FAT fs *
 * (as inode does not exist).   */
VFS_DELETE_NODE(vfat_delete)
{
        struct vfat_inode_s *inode_info;
        struct vfat_DirEntry_s dir;
        struct vfat_context_s *ctx;
        struct mapper_s *mapper;
        struct page_s *page;
        uint8_t *buff;
        uint32_t found;
        uint32_t offset; //64 bits?
        error_t err;

        ctx             = &inode->i_ctx->ctx_vfat;
        inode_info      = inode->i_pv;
        mapper          = inode->i_mapper;
        found           = 0;
        offset          = 0;
        err             = 0;

        if(!(inode->i_attr & VFS_DIR) )
                goto FREE_CNT;


        /* TODO: dont call mapper every time, as page can be reused */
        while(!found) 
        {
                if ((page = mapper_get_page(mapper, 
                                            offset >> PMM_PAGE_SHIFT, 
                                            MAPPER_SYNC_OP)) == NULL)
                        return VFS_IO_ERR;

                page_lock(page);

                buff  = ppm_page2addr(page);
                buff += offset % PMM_PAGE_SIZE;

                //is a memcpy necessary?
                memcpy(&dir, buff, sizeof(dir));

                if(dir.DIR_Name[0] == 0x00) {
                        vfat_dmsg(3,"vfat_readdir: entries termination found (0x00)\n");
                        page_unlock(page);
                        break;
                }

                if(dir.DIR_Name[0] == 0xE5) {
                        vfat_dmsg(3,"entry was freeed previously\n");
                        goto VFS_READ_DIR_NEXT;
                }

                if(dir.DIR_Attr == 0x0F) {
                        vfat_dmsg(3,"this entry is a long one\n");
                        // FIXME should not delete dirs who contain long name ? 
                        // knowink that we can't read them.
                        //goto VFS_READ_DIR_NEXT;
                        //found = 1;
                        page_unlock(page);
                        break;
                }

                if(dir.DIR_Name[0] == '.') // dot and dot_dot entries: since fat doesnot support hiden file!
                        goto VFS_READ_DIR_NEXT;

                vfat_dmsg(1, "DIR NOT empty (%s), name: %s\n",__FUNCTION__, dir.DIR_Name);
                found = 1;

        VFS_READ_DIR_NEXT:
                page_unlock(page);
                if(found) break;
                offset += sizeof(struct vfat_DirEntry_s);
        }

FREE_CNT:

        //Free content if not fifo
        if(!(inode->i_attr & VFS_FIFO))
                err=vfat_free_fat_entry(ctx, inode_info->first_cluster);

        assert(!err);

        return found ? VFS_ENOTEMPTY : 0;
}

VFS_UNLINK_NODE(vfat_unlink_node)
{
        struct vfat_entry_request_s rq;
        struct page_s *page;
        struct page_s *page2;
        struct mapper_s *mapper;
        struct vfat_context_s *ctx;
        struct vfat_dentry_s *dentry_info;
        struct vfat_DirEntry_s *dir;
        struct vfat_DirEntry_s *last_dir;
        uint_t entry_index;
        uint_t entry_index_page;
        error_t err;
        uint_t val;

        page2           = NULL;
        err             = 0;
        ctx             = &dentry->d_ctx->ctx_vfat;
        dentry_info     = &dentry->d_vfat;
        mapper          = parent->i_mapper;

        //Free FAT name directory entry
        if((dentry->d_attr & VFS_FIFO) && (dentry->d_op != &vfat_d_op)) //?
        {
                rq.entry       = NULL;
                rq.ctx         = ctx;
                rq.parent      = parent;
                rq.entry_name  = dentry->d_name;
                rq.entry_index = &entry_index;

                if((err=vfat_locate_entry(&rq)))
                        return err;

        } else 
        {
                entry_index = dentry_info->entry_index;
        }

        entry_index_page = (entry_index*sizeof(struct vfat_DirEntry_s)) >> PMM_PAGE_SHIFT;
        page = mapper_get_page(mapper, entry_index_page, MAPPER_SYNC_OP);

        if(page == NULL)
        { 
                val = entry_index_page;
                err = VFS_IO_ERR;
                goto UNLINK_IOERR;
        }

        dir = (struct vfat_DirEntry_s*) ppm_page2addr(page);
        dir += entry_index % (PMM_PAGE_SIZE / sizeof(struct vfat_DirEntry_s));

        uint_t entries_nr = PMM_PAGE_SIZE / sizeof(struct vfat_DirEntry_s);
        val = 0;

        // we are at the last entry in the page, looking for the next page
        if (entry_index == (entries_nr - 1))
        {
                page2 = mapper_get_page(mapper, entry_index_page+1, MAPPER_SYNC_OP);

                if(page2 == NULL)
                {
                        val = entry_index_page + 1;
                        err = VFS_IO_ERR;
                        goto UNLINK_IOERR;
                }
                
                last_dir = (struct vfat_DirEntry_s*) ppm_page2addr(page2);
        } 
        else 
        {
                last_dir = &dir[1];
        }

        //TODO: set page up (here) when the cache can shrink

        //TODO: negatif dentry should be handled in the upper layer
        assert(dentry->d_inode.cid != CID_NULL);
        
        /*  For dirs, this function also check that it is empty.*/
        err=vfs_unlink_inode(&dentry->d_inode);
        if(err)
                goto UNLINK_IOERR;

        if(page2) page_lock(page2);
        page_lock(page);

        if (last_dir->DIR_Name[0] == 0x00)
                dir->DIR_Name[0] = 0x00;
        else
                dir->DIR_Name[0] = 0xE5;

        mapper->m_ops->set_page_dirty(page);
        page_unlock(page);

        if(page2) page_unlock(page2);

#if VFAT_INSTRUMENT
        wr_count ++;
#endif

UNLINK_IOERR:

        if (err == VFS_IO_ERR)
        {
                printk(WARNING,"%s: unable to load page #%d of inode %d while removing node %s\n",
                       __FUNCTION__,
                       val,
                       parent->i_number,
                       dentry->d_name);
        }
        return err;
}
#endif

const struct vfs_inode_op_s vfat_i_op =
{
        .init    = vfat_init_node,
        .create  = vfat_create,
        .icreate = vfat_icreate,
        .lookup  = vfat_lookup,
        .write   = vfat_write_node,
        .release = vfat_release_node,
        .unlink  = vfat_unlink_node,
        .delete  = vfat_delete,
        .stat    = vfat_stat_node,
        .trunc   = NULL
};

VFS_COMPARE_DIRENT(vfat_compare)
{
        return strcasecmp(first, second);//TODO
}

const struct vfs_dentry_op_s vfat_d_op =
{
        .compare    = vfat_compare
};