Changeset 5930e3f in mainline


Ignore:
Timestamp:
2013-07-09T06:06:37Z (11 years ago)
Author:
Manuele Conti <conti.ma@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
951f32ce
Parents:
11baebb
Message:

Implement size_block function for ext4fs.
Fix typo in libfs VFS_OUT_STATFS operation.
Remove all debug code.

Location:
uspace
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/df/df.c

    r11baebb r5930e3f  
    5959                mtab_ent_t *mtab_ent = list_get_instance(cur, mtab_ent_t,
    6060                    link);
    61                 if (statfs(/*mtab_ent->mp*/ "/data", &st) < 0)
    62                         return 1;
    63                        
     61                statfs(mtab_ent->mp, &st);
     62                printf("block size:%ld\n", st.f_bsize);
    6463                printf("%13s %15lld %9lld %9lld %3ld%% %s\n",
    6564                        mtab_ent->fs_name,
    … …  
    6766                        (long long) st.f_bfree * st.f_bsize,
    6867                        (long long) (st.f_blocks - st.f_bfree) * st.f_bsize,
    69                         PERCENTAGE(st.f_blocks - st.f_bfree, st.f_blocks),
     68                        (st.f_blocks)?PERCENTAGE(st.f_blocks - st.f_bfree, st.f_blocks):0L,
    7069                        mtab_ent->mp);
    7170        }

  • uspace/app/trace/trace.c

    r11baebb r5930e3f  
    724724        o = oper_new("stat", 0, arg_def, V_ERRNO, 0, resp_def);
    725725        proto_add_oper(p, VFS_IN_STAT, o);
     726        o = oper_new("statfs", 0, arg_def, V_ERRNO, 0, resp_def);
     727        proto_add_oper(p, VFS_IN_STATFS, o);
    726728
    727729        proto_register(SERVICE_VFS, p);

  • uspace/lib/c/generic/vfs/vfs.c

    r11baebb r5930e3f  
    893893}
    894894
    895 #include <stdio.h>
    896895int statfs(const char *path, struct statfs *statfs)
    897896{
    … …  
    904903        if (!pa)
    905904                return ENOMEM;
    906        
    907905        async_exch_t *exch = vfs_exchange_begin();
    908906       
    … …  
    918916                        return (int) rc_orig;
    919917        }
    920         printf("TRACE: send VFS_IN_STATFS\n");
    921         rc = async_data_read_start(exch, statfs, sizeof(struct statfs));
    922         if (rc != EOK) {
    923                 printf("TRACE: error reply\n");
     918        rc = async_data_read_start(exch, (void *) statfs, sizeof(struct statfs));
     919        if (rc != EOK) {
    924920                vfs_exchange_end(exch);
    925921                free(pa);

  • uspace/lib/fs/libfs.c

    r11baebb r5930e3f  
    7575static void libfs_open_node(libfs_ops_t *, fs_handle_t, ipc_callid_t,
    7676    ipc_call_t *);
     77static void libfs_statfs(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *);
    7778
    7879static void vfs_out_mounted(ipc_callid_t rid, ipc_call_t *req)
    … …  
    219220        async_answer_0(rid, rc);
    220221}
    221 #include<stdio.h>
     222
    222223static void vfs_out_statfs(ipc_callid_t rid, ipc_call_t *req)
    223 {       
    224         printf("TRACE: vfs_out_statfs\n");
    225         service_id_t service_id = (service_id_t) IPC_GET_ARG1(*req);
    226         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*req);
    227        
    228         fs_node_t *fn;
    229         int rc = libfs_ops->node_get(&fn, service_id, index);
    230         on_error(rc, answer_and_return(rid, rc));
    231        
    232         ipc_callid_t callid;
    233         size_t size;
    234         if ((!async_data_read_receive(&callid, &size)) ||
    235             (size != sizeof(struct stat))) {
    236                 libfs_ops->node_put(fn);
    237                 async_answer_0(callid, EINVAL);
    238                 async_answer_0(rid, EINVAL);
    239                 return;
    240         }
    241        
    242         struct statfs statfs;
    243         memset(&statfs, 0, sizeof(struct statfs));
    244        
    245         statfs.f_bsize = libfs_ops->size_block(service_id);
    246 
    247         libfs_ops->node_put(fn);
    248        
    249         async_data_read_finalize(callid, &statfs, sizeof(struct statfs));
    250         async_answer_0(rid, EOK);
    251 }
    252 
     224{
     225        libfs_statfs(libfs_ops, reg.fs_handle, rid, req);
     226}
    253227static void vfs_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    254228{
    … …  
    865839}
    866840
     841void libfs_statfs(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
     842    ipc_call_t *request)
     843{
     844        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
     845        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
     846       
     847        fs_node_t *fn;
     848        int rc = ops->node_get(&fn, service_id, index);
     849        on_error(rc, answer_and_return(rid, rc));
     850       
     851        ipc_callid_t callid;
     852        size_t size;
     853        if ((!async_data_read_receive(&callid, &size)) ||
     854            (size != sizeof(struct statfs))) {
     855                ops->node_put(fn);
     856                async_answer_0(callid, EINVAL);
     857                async_answer_0(rid, EINVAL);
     858                return;
     859        }
     860       
     861        struct statfs statfs;
     862        memset(&statfs, 0, sizeof(struct statfs));
     863
     864        if (NULL != ops->size_block)   
     865                statfs.f_bsize = ops->size_block(service_id);
     866       
     867        ops->node_put(fn);
     868       
     869        async_data_read_finalize(callid, &statfs, sizeof(struct statfs));
     870        async_answer_0(rid, EOK);
     871}
     872
     873
    867874/** Open VFS triplet.
    868875 *

  • uspace/srv/fs/ext4fs/ext4fs_ops.c

    r11baebb r5930e3f  
    101101static bool ext4fs_is_file(fs_node_t *node);
    102102static service_id_t ext4fs_service_get(fs_node_t *node);
     103static long ext4fs_size_block(service_id_t);
    103104
    104105/* Static variables */
    … …  
    836837        ext4fs_node_t *enode = EXT4FS_NODE(fn);
    837838        return enode->instance->service_id;
     839}
     840
     841long ext4fs_size_block(service_id_t service_id)
     842{
     843        ext4fs_instance_t *inst;
     844        int rc = ext4fs_instance_get(service_id, &inst);
     845        if (rc != EOK)
     846                return rc;
     847        if (NULL == inst)
     848                return ENOENT;
     849        ext4_superblock_t *sb = inst->filesystem->superblock;
     850        uint32_t block_size = ext4_superblock_get_block_size(sb);
     851        return block_size;
    838852}
    839853
    … …  
    857871        .is_directory = ext4fs_is_directory,
    858872        .is_file = ext4fs_is_file,
    859         .service_get = ext4fs_service_get
     873        .service_get = ext4fs_service_get,
     874        .size_block = ext4fs_size_block
    860875};
    861876

  • uspace/srv/fs/mfs/mfs_ops.c

    r11baebb r5930e3f  
    11491149        if (NULL == inst)
    11501150                return ENOENT;
    1151         block_size = inst->sbi->block_size;     
     1151        block_size = inst->sbi->block_size;
    11521152        return block_size;
    11531153}
Note: See TracChangeset for help on using the changeset viewer.