Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/fs/mfs/mfs_ops.c

    r1eaa3cf r5b56dc7  
    6464static int mfs_check_sanity(struct mfs_sb_info *sbi);
    6565static bool is_power_of_two(uint32_t n);
    66 static int mfs_size_block(service_id_t service_id, uint32_t *size);
    67 static int mfs_total_block_count(service_id_t service_id, uint64_t *count);
    68 static int mfs_free_block_count(service_id_t service_id, uint64_t *count);
    6966
    7067static hash_table_t open_nodes;
     
    8784        .destroy = mfs_destroy_node,
    8885        .has_children = mfs_has_children,
    89         .lnkcnt_get = mfs_lnkcnt_get,
    90         .size_block = mfs_size_block,
    91         .total_block_count = mfs_total_block_count,
    92         .free_block_count = mfs_free_block_count
     86        .lnkcnt_get = mfs_lnkcnt_get
    9387};
    9488
    9589/* Hash table interface for open nodes hash table */
     90
    9691typedef struct {
    9792        service_id_t service_id;
     
    195190                /* This is a V1 or V2 Minix filesystem */
    196191                magic = sb->s_magic;
    197         } else if (check_magic_number(sb3->s_magic, &native,
    198             &version, &longnames)) {
     192        } else if (check_magic_number(sb3->s_magic, &native, &version, &longnames)) {
    199193                /* This is a V3 Minix filesystem */
    200194                magic = sb3->s_magic;
     
    216210        sbi->isearch = 0;
    217211        sbi->zsearch = 0;
    218         sbi->nfree_zones_valid = false;
    219         sbi->nfree_zones = 0;
    220212
    221213        if (version == MFS_VERSION_V3) {
     
    353345        uint32_t inum;
    354346
     347        mfsdebug("%s()\n", __FUNCTION__);
     348
    355349        r = mfs_instance_get(service_id, &inst);
    356350        if (r != EOK)
     
    385379                ino_i->i_mode = S_IFDIR;
    386380                ino_i->i_nlinks = 1; /* This accounts for the '.' dentry */
    387         } else {
     381        } else
    388382                ino_i->i_mode = S_IFREG;
    389                 ino_i->i_nlinks = 0;
    390         }
    391383
    392384        ino_i->i_uid = 0;
     
    427419        free(ino_i);
    428420out_err:
    429         mfs_free_inode(inst, inum);
    430421        return r;
    431422}
     
    438429        struct mfs_dentry_info d_info;
    439430        int r;
     431
     432        mfsdebug("%s()\n", __FUNCTION__);
    440433
    441434        if (!S_ISDIR(ino_i->i_mode))
     
    459452
    460453                if (comp_size == dentry_name_size &&
    461                     memcmp(component, d_info.d_name, dentry_name_size) == 0) {
     454                    !bcmp(component, d_info.d_name, dentry_name_size)) {
    462455                        /* Hit! */
    463456                        mfs_node_core_get(rfn, mnode->instance,
     
    485478        struct mfs_instance *instance;
    486479
     480        mfsdebug("%s()\n", __FUNCTION__);
     481
    487482        rc = mfs_instance_get(service_id, &instance);
    488483        if (rc != EOK)
     
    497492        int rc = EOK;
    498493        struct mfs_node *mnode = fsnode->data;
     494
     495        mfsdebug("%s()\n", __FUNCTION__);
    499496
    500497        fibril_mutex_lock(&open_nodes_lock);
     
    557554        int rc;
    558555
     556        mfsdebug("%s()\n", __FUNCTION__);
     557
    559558        fibril_mutex_lock(&open_nodes_lock);
    560559
     
    569568        if (already_open) {
    570569                mnode = hash_table_get_inst(already_open, struct mfs_node, link);
    571 
    572570                *rfn = mnode->fsnode;
    573571                mnode->refcnt++;
     
    650648        struct mfs_sb_info *sbi = parent->instance->sbi;
    651649        bool destroy_dentry = false;
     650
     651        mfsdebug("%s()\n", __FUNCTION__);
    652652
    653653        if (str_size(name) > sbi->max_name_len)
     
    673673                r = mfs_insert_dentry(child, "..", parent->ino_i->index);
    674674                if (r != EOK) {
    675                         mfs_remove_dentry(child, ".");
    676675                        destroy_dentry = true;
    677676                        goto exit;
     
    701700        bool has_children;
    702701        int r;
     702
     703        mfsdebug("%s()\n", __FUNCTION__);
    703704
    704705        if (!parent)
     
    923924               
    924925                r = mfs_write_map(mnode, pos, block, &dummy);
    925                 if (r != EOK) {
    926                         mfs_free_zone(mnode->instance, block);
     926                if (r != EOK)
    927927                        goto out_err;
    928                 }
    929928
    930929                flags = BLOCK_FLAGS_NOREAD;
     
    966965mfs_destroy(service_id_t service_id, fs_index_t index)
    967966{
    968         fs_node_t *fn = NULL;
     967        fs_node_t *fn;
    969968        int r;
    970969
     
    11371136}
    11381137
    1139 static int
    1140 mfs_size_block(service_id_t service_id, uint32_t *size)
    1141 {
    1142         struct mfs_instance *inst;
    1143         int rc;
    1144 
    1145         rc = mfs_instance_get(service_id, &inst);
    1146         if (rc != EOK)
    1147                 return rc;
    1148 
    1149         if (NULL == inst)
    1150                 return ENOENT;
    1151        
    1152         *size = inst->sbi->block_size;
    1153 
    1154         return EOK;
    1155 }
    1156 
    1157 static int
    1158 mfs_total_block_count(service_id_t service_id, uint64_t *count)
    1159 {
    1160         struct mfs_instance *inst;
    1161         int rc;
    1162        
    1163         rc = mfs_instance_get(service_id, &inst);
    1164         if (rc != EOK)
    1165                 return rc;
    1166 
    1167         if (NULL == inst)
    1168                 return ENOENT;
    1169        
    1170         *count = (uint64_t) MFS_BMAP_SIZE_BITS(inst->sbi, BMAP_ZONE);
    1171 
    1172         return EOK;
    1173 }
    1174 
    1175 static int
    1176 mfs_free_block_count(service_id_t service_id, uint64_t *count)
    1177 {
    1178         uint32_t block_free;
    1179        
    1180         struct mfs_instance *inst;
    1181         int rc = mfs_instance_get(service_id, &inst);
    1182         if (rc != EOK)
    1183                 return rc;
    1184 
    1185         struct mfs_sb_info *sbi = inst->sbi;
    1186 
    1187         if (!sbi->nfree_zones_valid) {
    1188                 /* The cached number of free zones is not valid,
    1189                  * we need to scan the bitmap to retrieve the
    1190                  * current value.
    1191                  */
    1192 
    1193                 rc = mfs_count_free_zones(inst, &block_free);
    1194                 if (rc != EOK)
    1195                         return rc;
    1196 
    1197                 sbi->nfree_zones = block_free;
    1198                 sbi->nfree_zones_valid = true;
    1199         }
    1200 
    1201         *count = sbi->nfree_zones;
    1202 
    1203         return EOK;
    1204 }
    1205 
    12061138vfs_out_ops_t mfs_ops = {
    12071139        .mounted = mfs_mounted,
Note: See TracChangeset for help on using the changeset viewer.