Changes in / [758f8d5:1e371cf] in mainline


Ignore:
Files:
3 deleted
19 edited

Legend:

Unmodified
Added
Removed

  • boot/Makefile.common

    r758f8d5 r1e371cf  
    206206        $(USPACE_PATH)/app/websrv/websrv \
    207207        $(USPACE_PATH)/app/date/date \
    208         $(USPACE_PATH)/app/vdemo/vdemo \
    209         $(USPACE_PATH)/app/df/df
     208        $(USPACE_PATH)/app/vdemo/vdemo
    210209
    211210ifeq ($(CONFIG_PCC),y)

  • uspace/Makefile

    r758f8d5 r1e371cf  
    8181        app/vlaunch \
    8282        app/vterm \
    83         app/df \
    8483        app/wavplay \
    8584        app/websrv \

  • uspace/app/trace/trace.c

    r758f8d5 r1e371cf  
    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);
    728726
    729727        proto_register(SERVICE_VFS, p);

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

    r758f8d5 r1e371cf  
    4343#include <stdio.h>
    4444#include <sys/stat.h>
    45 #include <sys/statfs.h>
    4645#include <sys/types.h>
    4746#include <ipc/services.h>
    … …  
    893892}
    894893
    895 int statfs(const char *path, struct statfs *statfs)
    896 {
    897         sysarg_t rc;
    898         sysarg_t rc_orig;
    899         aid_t req;
    900         size_t pa_size;
    901        
    902         char *pa = absolutize(path, &pa_size);
    903         if (!pa)
    904                 return ENOMEM;
    905         async_exch_t *exch = vfs_exchange_begin();
    906        
    907         req = async_send_0(exch, VFS_IN_STATFS, NULL);
    908         rc = async_data_write_start(exch, pa, pa_size);
    909         if (rc != EOK) {
    910                 vfs_exchange_end(exch);
    911                 free(pa);
    912                 async_wait_for(req, &rc_orig);
    913                 if (rc_orig == EOK)
    914                         return (int) rc;
    915                 else
    916                         return (int) rc_orig;
    917         }
    918         rc = async_data_read_start(exch, (void *) statfs, sizeof(struct statfs));
    919         if (rc != EOK) {
    920                 vfs_exchange_end(exch);
    921                 free(pa);
    922                 async_wait_for(req, &rc_orig);
    923                 if (rc_orig == EOK)
    924                         return (int) rc;
    925                 else
    926                         return (int) rc_orig;
    927         }
    928         vfs_exchange_end(exch);
    929         free(pa);
    930         async_wait_for(req, &rc);
    931         return rc;
    932 }
    933 
    934894/** @}
    935895 */

  • uspace/lib/c/include/ipc/vfs.h

    r758f8d5 r1e371cf  
    8282        VFS_IN_WAIT_HANDLE,
    8383        VFS_IN_MTAB_GET,
    84         VFS_IN_STATFS
    8584} vfs_in_request_t;
    8685
    … …  
    9998        VFS_OUT_LOOKUP,
    10099        VFS_OUT_DESTROY,
    101         VFS_OUT_STATFS,
    102100        VFS_OUT_LAST
    103101} vfs_out_request_t;

  • uspace/lib/c/include/vfs/vfs.h

    r758f8d5 r1e371cf  
    4444#include "vfs_mtab.h"
    4545
    46 
    4746enum vfs_change_state_type {
    4847        VFS_PASS_HANDLE
    4948};
    50 
    5149
    5250extern char *absolutize(const char *, size_t *);
    … …  
    6361extern async_exch_t *vfs_exchange_begin(void);
    6462extern void vfs_exchange_end(async_exch_t *);
     63
    6564#endif
    6665

  • uspace/lib/fs/libfs.c

    r758f8d5 r1e371cf  
    4545#include <mem.h>
    4646#include <sys/stat.h>
    47 #include <sys/statfs.h>
    4847#include <stdlib.h>
    4948
    … …  
    7574static void libfs_open_node(libfs_ops_t *, fs_handle_t, ipc_callid_t,
    7675    ipc_call_t *);
    77 static void libfs_statfs(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *);
    7876
    7977static void vfs_out_mounted(ipc_callid_t rid, ipc_call_t *req)
    … …  
    221219}
    222220
    223 static void vfs_out_statfs(ipc_callid_t rid, ipc_call_t *req)
    224 {
    225         libfs_statfs(libfs_ops, reg.fs_handle, rid, req);
    226 }
    227221static void vfs_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    228222{
    … …  
    282276                case VFS_OUT_SYNC:
    283277                        vfs_out_sync(callid, &call);
    284                         break;
    285                 case VFS_OUT_STATFS:
    286                         vfs_out_statfs(callid, &call);
    287278                        break;
    288279                default:
    … …  
    834825       
    835826        ops->node_put(fn);
    836 
    837 
     827       
    838828        async_data_read_finalize(callid, &stat, sizeof(struct stat));
    839829        async_answer_0(rid, EOK);
    840830}
    841 
    842 void libfs_statfs(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
    843     ipc_call_t *request)
    844 {
    845         service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    846         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    847        
    848         fs_node_t *fn;
    849         int rc = ops->node_get(&fn, service_id, index);
    850         on_error(rc, answer_and_return(rid, rc));
    851        
    852         ipc_callid_t callid;
    853         size_t size;
    854         if ((!async_data_read_receive(&callid, &size)) ||
    855             (size != sizeof(struct statfs))) {
    856                 ops->node_put(fn);
    857                 async_answer_0(callid, EINVAL);
    858                 async_answer_0(rid, EINVAL);
    859                 return;
    860         }
    861        
    862         struct statfs statfs;
    863         memset(&statfs, 0, sizeof(struct statfs));
    864 
    865         if (NULL != ops->size_block) { 
    866                 rc = ops->size_block(service_id, &statfs.f_bsize);
    867                 if (rc != EOK) goto error;
    868         }
    869 
    870         if (NULL != ops->total_block_count) {
    871                 rc = ops->total_block_count(service_id, &statfs.f_blocks);
    872                 if (rc != EOK) goto error;
    873         }
    874 
    875         if (NULL != ops->free_block_count) {
    876                 rc = ops->free_block_count(service_id, &statfs.f_bfree);
    877                 if (rc != EOK) goto error;
    878         }
    879 
    880         ops->node_put(fn);
    881         async_data_read_finalize(callid, &statfs, sizeof(struct statfs));
    882         async_answer_0(rid, EOK);
    883         return;
    884 
    885 error:
    886         ops->node_put(fn);
    887         async_answer_0(callid, EINVAL);
    888         async_answer_0(rid, EINVAL);
    889 }
    890 
    891831
    892832/** Open VFS triplet.

  • uspace/lib/fs/libfs.h

    r758f8d5 r1e371cf  
    9393        bool (* is_file)(fs_node_t *);
    9494        service_id_t (* service_get)(fs_node_t *);
    95         int (* size_block)(service_id_t, uint32_t *);
    96         int (* total_block_count)(service_id_t, uint64_t *);
    97         int (* free_block_count)(service_id_t, uint64_t *);
    9895} libfs_ops_t;
    9996

  • uspace/srv/fs/cdfs/cdfs_ops.c

    r758f8d5 r1e371cf  
    619619}
    620620
    621 static int cdfs_size_block(service_id_t service_id, uint32_t *size)
    622 {
    623         *size = BLOCK_SIZE;
    624 
    625         return EOK;
    626 }
    627 
    628 static int cdfs_total_block_count(service_id_t service_id, uint64_t *count)
    629 {
    630         *count = 0;
    631        
    632         return EOK;
    633 }
    634 
    635 static int cdfs_free_block_count(service_id_t service_id, uint64_t *count)
    636 {
    637         *count = 0;
    638        
    639         return EOK;
    640 }
    641 
    642621libfs_ops_t cdfs_libfs_ops = {
    643622        .root_get = cdfs_root_get,
    … …  
    656635        .is_directory = cdfs_is_directory,
    657636        .is_file = cdfs_is_file,
    658         .service_get = cdfs_service_get,
    659         .size_block = cdfs_size_block,
    660         .total_block_count = cdfs_total_block_count,
    661         .free_block_count = cdfs_free_block_count
     637        .service_get = cdfs_service_get
    662638};
    663639

  • uspace/srv/fs/exfat/exfat_ops.c

    r758f8d5 r1e371cf  
    8989static bool exfat_is_file(fs_node_t *node);
    9090static service_id_t exfat_service_get(fs_node_t *node);
    91 static int exfat_size_block(service_id_t, uint32_t *);
    92 static int exfat_total_block_count(service_id_t, uint64_t *);
    93 static int exfat_free_block_count(service_id_t, uint64_t *);
    9491
    9592/*
    … …  
    913910}
    914911
    915 int exfat_size_block(service_id_t service_id, uint32_t *size)
    916 {
    917         exfat_bs_t *bs;
    918         bs = block_bb_get(service_id);
    919         *size = BPC(bs);
    920 
    921         return EOK;
    922 }
    923 
    924 int exfat_total_block_count(service_id_t service_id, uint64_t *count)
    925 {
    926         exfat_bs_t *bs;
    927         bs = block_bb_get(service_id);
    928         *count = DATA_CNT(bs);
    929        
    930         return EOK;
    931 }
    932 
    933 int exfat_free_block_count(service_id_t service_id, uint64_t *count)
    934 {
    935         fs_node_t *node;
    936         exfat_node_t *bmap_node;
    937         exfat_bs_t *bs;
    938         uint64_t free_block_count = 0;
    939         uint64_t block_count;
    940         unsigned sector;
    941         int rc;
    942 
    943         rc = exfat_total_block_count(service_id, &block_count);
    944         if (rc != EOK)
    945                 goto exit;
    946 
    947         bs = block_bb_get(service_id);
    948         node = NULL;
    949         rc = exfat_bitmap_get(&node, service_id);
    950         if (rc != EOK)
    951                 goto exit;
    952 
    953         bmap_node = (exfat_node_t *) node->data;
    954 
    955         unsigned const bmap_sectors = ROUND_UP(bmap_node->size, BPS(bs)) /
    956             BPS(bs);
    957 
    958         for (sector = 0; sector < bmap_sectors; ++sector) {
    959 
    960                 block_t *block;
    961                 uint8_t *bitmap;
    962                 unsigned bit;
    963 
    964                 rc = exfat_block_get(&block, bs, bmap_node, sector,
    965                     BLOCK_FLAGS_NONE);
    966                 if (rc != EOK) {
    967                         free_block_count = 0;
    968                         goto exit;
    969                 }
    970 
    971                 bitmap = (uint8_t *) block->data;
    972 
    973                 for (bit = 0; bit < BPS(bs) * 8 && block_count > 0;
    974                     ++bit, --block_count) {
    975                         if (!(bitmap[bit / 8] & (1 << (bit % 8))))
    976                                 ++free_block_count;
    977                 }
    978 
    979                 block_put(block);
    980 
    981                 if (block_count == 0) {
    982                         /* Reached the end of the bitmap */
    983                         goto exit;
    984                 }
    985         }
    986 
    987 exit:
    988         exfat_node_put(node);
    989         *count = free_block_count;
    990         return rc;
    991 }
    992912
    993913/** libfs operations */
    … …  
    1008928        .is_directory = exfat_is_directory,
    1009929        .is_file = exfat_is_file,
    1010         .service_get = exfat_service_get,
    1011         .size_block = exfat_size_block,
    1012         .total_block_count = exfat_total_block_count,
    1013         .free_block_count = exfat_free_block_count
     930        .service_get = exfat_service_get
    1014931};
    1015932

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

    r758f8d5 r1e371cf  
    101101static bool ext4fs_is_file(fs_node_t *node);
    102102static service_id_t ext4fs_service_get(fs_node_t *node);
    103 static int ext4fs_size_block(service_id_t, uint32_t *);
    104 static int ext4fs_total_block_count(service_id_t, uint64_t *);
    105 static int ext4fs_free_block_count(service_id_t, uint64_t *);
    106103
    107104/* Static variables */
    … …  
    836833        ext4fs_node_t *enode = EXT4FS_NODE(fn);
    837834        return enode->instance->service_id;
    838 }
    839 
    840 int ext4fs_size_block(service_id_t service_id, uint32_t *size)
    841 {
    842         ext4fs_instance_t *inst;
    843         int rc = ext4fs_instance_get(service_id, &inst);
    844         if (rc != EOK)
    845                 return rc;
    846 
    847         if (NULL == inst)
    848                 return ENOENT;
    849 
    850         ext4_superblock_t *sb = inst->filesystem->superblock;
    851         *size = ext4_superblock_get_block_size(sb);
    852 
    853         return EOK;
    854 }
    855 
    856 int ext4fs_total_block_count(service_id_t service_id, uint64_t *count)
    857 {
    858         ext4fs_instance_t *inst;
    859         int rc = ext4fs_instance_get(service_id, &inst);
    860         if (rc != EOK)
    861                 return rc;
    862 
    863         if (NULL == inst)
    864                 return ENOENT;
    865 
    866         ext4_superblock_t *sb = inst->filesystem->superblock;
    867         *count = ext4_superblock_get_blocks_count(sb);
    868 
    869         return EOK;
    870 }
    871 
    872 int ext4fs_free_block_count(service_id_t service_id, uint64_t *count)
    873 {
    874         ext4fs_instance_t *inst;
    875         int rc = ext4fs_instance_get(service_id, &inst);
    876         if (rc != EOK)
    877                 return rc;
    878         if (NULL == inst)
    879                 return ENOENT;
    880 
    881         ext4_superblock_t *sb = inst->filesystem->superblock;
    882         *count = ext4_superblock_get_free_blocks_count(sb);
    883 
    884         return EOK;
    885835}
    886836
    … …  
    904854        .is_directory = ext4fs_is_directory,
    905855        .is_file = ext4fs_is_file,
    906         .service_get = ext4fs_service_get,
    907         .size_block = ext4fs_size_block,
    908         .total_block_count = ext4fs_total_block_count,
    909         .free_block_count = ext4fs_free_block_count
     856        .service_get = ext4fs_service_get
    910857};
    911858

  • uspace/srv/fs/fat/fat_ops.c

    r758f8d5 r1e371cf  
    9191static bool fat_is_file(fs_node_t *node);
    9292static service_id_t fat_service_get(fs_node_t *node);
    93 static int fat_size_block(service_id_t, uint32_t *);
    94 static int fat_total_block_count(service_id_t, uint64_t *);
    95 static int fat_free_block_count(service_id_t, uint64_t *);
    9693
    9794/*
    … …  
    844841}
    845842
    846 int fat_size_block(service_id_t service_id, uint32_t *size)
    847 {
    848         fat_bs_t *bs;
    849 
    850         bs = block_bb_get(service_id);
    851         *size = BPC(bs);
    852 
    853         return EOK;
    854 }
    855 
    856 int fat_total_block_count(service_id_t service_id, uint64_t *count)
    857 {
    858         fat_bs_t *bs;
    859        
    860         bs = block_bb_get(service_id);
    861         *count = (SPC(bs)) ? TS(bs) / SPC(bs) : 0;
    862 
    863         return EOK;
    864 }
    865 
    866 int fat_free_block_count(service_id_t service_id, uint64_t *count)
    867 {
    868         fat_bs_t *bs;
    869         fat_cluster_t e0;
    870         uint64_t block_count;
    871         int rc;
    872         uint32_t cluster_no, clusters;
    873 
    874         block_count = 0;
    875         bs = block_bb_get(service_id);
    876         clusters = (SPC(bs)) ? TS(bs) / SPC(bs) : 0;
    877         for (cluster_no = 0; cluster_no < clusters; cluster_no++) {
    878                 rc = fat_get_cluster(bs, service_id, FAT1, cluster_no, &e0);
    879                 if (rc != EOK)
    880                         return EIO;
    881 
    882                 if (e0 == FAT_CLST_RES0)
    883                         block_count++;
    884         }
    885         *count = block_count;
    886        
    887         return EOK;
    888 }
    889 
    890843/** libfs operations */
    891844libfs_ops_t fat_libfs_ops = {
    … …  
    905858        .is_directory = fat_is_directory,
    906859        .is_file = fat_is_file,
    907         .service_get = fat_service_get,
    908         .size_block = fat_size_block,
    909         .total_block_count = fat_total_block_count,
    910         .free_block_count = fat_free_block_count
     860        .service_get = fat_service_get
    911861};
    912862

  • uspace/srv/fs/mfs/mfs.h

    r758f8d5 r1e371cf  
    5858#endif
    5959
    60 #define MFS_BMAP_START_BLOCK(sbi, bid) \
    61     ((bid) == BMAP_ZONE ? 2 + (sbi)->ibmap_blocks : 2)
    62 
    63 #define MFS_BMAP_SIZE_BITS(sbi, bid) \
    64     ((bid) == BMAP_ZONE ? (sbi)->nzones - (sbi)->firstdatazone - 1 : \
    65     (sbi)->ninodes - 1)
    66 
    67 #define MFS_BMAP_SIZE_BLOCKS(sbi, bid) \
    68     ((bid) == BMAP_ZONE ? (sbi)->zbmap_blocks : (sbi)->ibmap_blocks)
    69 
    7060typedef uint32_t bitchunk_t;
    7161
    … …  
    211201mfs_free_zone(struct mfs_instance *inst, uint32_t zone);
    212202
    213 extern int
    214 mfs_count_free_zones(struct mfs_instance *inst, uint32_t *zones);
    215 
    216 extern int
    217 mfs_count_free_inodes(struct mfs_instance *inst, uint32_t *inodes);
    218 
    219 
    220203/* mfs_utils.c */
    221204extern uint16_t

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

    r758f8d5 r1e371cf  
    4444mfs_alloc_bit(struct mfs_instance *inst, uint32_t *idx, bmap_id_t bid);
    4545
    46 static int
    47 mfs_count_free_bits(struct mfs_instance *inst, bmap_id_t bid, uint32_t *free);
    48 
    49 
    5046/**Allocate a new inode.
    5147 *
    … …  
    106102
    107103        return mfs_free_bit(inst, zone, BMAP_ZONE);
    108 }
    109 
    110 /** Count the number of free zones
    111  *
    112  * @param inst          Pointer to the instance structure.
    113  * @param zones         Pointer to the memory location where the result
    114  *                      will be stored.
    115  *
    116  * @return              EOK on success or a negative error code.
    117  */
    118 int
    119 mfs_count_free_zones(struct mfs_instance *inst, uint32_t *zones)
    120 {
    121         return mfs_count_free_bits(inst, BMAP_ZONE, zones);
    122 }
    123 
    124 /** Count the number of free inodes
    125  *
    126  * @param inst          Pointer to the instance structure.
    127  * @param zones         Pointer to the memory location where the result
    128  *                      will be stored.
    129  *
    130  * @return              EOK on success or a negative error code.
    131  */
    132 
    133 int
    134 mfs_count_free_inodes(struct mfs_instance *inst, uint32_t *inodes)
    135 {
    136         return mfs_count_free_bits(inst, BMAP_INODE, inodes);
    137 }
    138 
    139 /** Count the number of free bits in a bitmap
    140  *
    141  * @param inst          Pointer to the instance structure.
    142  * @param bid           Type of the bitmap (inode or zone).
    143  * @param free          Pointer to the memory location where the result
    144  *                      will be stores.
    145  *
    146  * @return              EOK on success or a negative error code.
    147  */
    148 static int
    149 mfs_count_free_bits(struct mfs_instance *inst, bmap_id_t bid, uint32_t *free)
    150 {
    151         int r;
    152         unsigned start_block;
    153         unsigned long nblocks;
    154         unsigned long nbits;
    155         unsigned long block;
    156         unsigned long free_bits = 0;
    157         bitchunk_t chunk;
    158         size_t const bitchunk_bits = sizeof(bitchunk_t) * 8;
    159         block_t *b;
    160         struct mfs_sb_info *sbi = inst->sbi;
    161 
    162         start_block = MFS_BMAP_START_BLOCK(sbi, bid);
    163         nblocks = MFS_BMAP_SIZE_BLOCKS(sbi, bid);
    164         nbits = MFS_BMAP_SIZE_BITS(sbi, bid);
    165 
    166         for (block = 0; block < nblocks; ++block) {
    167                 r = block_get(&b, inst->service_id, block + start_block,
    168                     BLOCK_FLAGS_NONE);
    169                 if (r != EOK)
    170                         return r;
    171 
    172                 size_t i;
    173                 bitchunk_t *data = (bitchunk_t *) b->data;
    174 
    175                 /* Read the bitmap block, chunk per chunk,
    176                  * counting the zero bits.
    177                  */
    178                 for (i = 0; i < sbi->block_size / sizeof(bitchunk_t); ++i) {
    179                         chunk = conv32(sbi->native, data[i]);
    180 
    181                         size_t bit;
    182                         for (bit = 0; bit < bitchunk_bits && nbits > 0;
    183                             ++bit, --nbits) {
    184                                 if (!(chunk & (1 << bit)))
    185                                         free_bits++;
    186                         }
    187 
    188                         if (nbits == 0)
    189                                 break;
    190                 }
    191 
    192                 r = block_put(b);
    193                 if (r != EOK)
    194                         return r;
    195         }
    196 
    197         *free = free_bits;
    198         assert(nbits == 0);
    199 
    200         return EOK;
    201104}
    202105
    … …  
    221124        sbi = inst->sbi;
    222125
    223         start_block = MFS_BMAP_START_BLOCK(sbi, bid);
    224 
    225126        if (bid == BMAP_ZONE) {
    226127                search = &sbi->zsearch;
     128                start_block = 2 + sbi->ibmap_blocks;
    227129                if (idx > sbi->nzones) {
    228130                        printf(NAME ": Error! Trying to free beyond the "
    … …  
    233135                /* bid == BMAP_INODE */
    234136                search = &sbi->isearch;
     137                start_block = 2;
    235138                if (idx > sbi->ninodes) {
    236139                        printf(NAME ": Error! Trying to free beyond the "
    … …  
    289192        sbi = inst->sbi;
    290193
    291         start_block = MFS_BMAP_START_BLOCK(sbi, bid);
    292         limit = MFS_BMAP_SIZE_BITS(sbi, bid);
    293         nblocks = MFS_BMAP_SIZE_BLOCKS(sbi, bid);
    294 
    295194        if (bid == BMAP_ZONE) {
    296195                search = &sbi->zsearch;
     196                start_block = 2 + sbi->ibmap_blocks;
     197                nblocks = sbi->zbmap_blocks;
     198                limit = sbi->nzones - sbi->firstdatazone - 1;
    297199        } else {
    298200                /* bid == BMAP_INODE */
    299201                search = &sbi->isearch;
     202                start_block = 2;
     203                nblocks = sbi->ibmap_blocks;
     204                limit = sbi->ninodes - 1;
    300205        }
    301206        bits_per_block = sbi->block_size * 8;

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

    r758f8d5 r1e371cf  
    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
    … …  
    11351129}
    11361130
    1137 static int
    1138 mfs_size_block(service_id_t service_id, uint32_t *size)
    1139 {
    1140         struct mfs_instance *inst;
    1141         int rc;
    1142 
    1143         rc = mfs_instance_get(service_id, &inst);
    1144         if (rc != EOK)
    1145                 return rc;
    1146 
    1147         if (NULL == inst)
    1148                 return ENOENT;
    1149        
    1150         *size = inst->sbi->block_size;
    1151 
    1152         return EOK;
    1153 }
    1154 
    1155 static int
    1156 mfs_total_block_count(service_id_t service_id, uint64_t *count)
    1157 {
    1158         struct mfs_instance *inst;
    1159         int rc;
    1160        
    1161         rc = mfs_instance_get(service_id, &inst);
    1162         if (rc != EOK)
    1163                 return rc;
    1164 
    1165         if (NULL == inst)
    1166                 return ENOENT;
    1167        
    1168         *count = (uint64_t) MFS_BMAP_SIZE_BITS(inst->sbi, BMAP_ZONE);
    1169 
    1170         return EOK;
    1171 }
    1172 
    1173 static int
    1174 mfs_free_block_count(service_id_t service_id, uint64_t *count)
    1175 {
    1176         uint32_t block_free;
    1177        
    1178         struct mfs_instance *inst;
    1179         int rc = mfs_instance_get(service_id, &inst);
    1180         if (rc != EOK)
    1181                 return rc;
    1182 
    1183         if (NULL == inst)
    1184                 return ENOENT;
    1185 
    1186         mfs_count_free_zones(inst, &block_free);
    1187         *count = block_free;
    1188 
    1189         return EOK;
    1190 }
    1191 
    11921131vfs_out_ops_t mfs_ops = {
    11931132        .mounted = mfs_mounted,

  • uspace/srv/fs/udf/udf_ops.c

    r758f8d5 r1e371cf  
    249249}
    250250
    251 static int udf_size_block(service_id_t service_id, uint32_t *size)
    252 {
    253         udf_instance_t *instance;
    254         int rc = fs_instance_get(service_id, (void **) &instance);
    255         if (rc != EOK)
    256                 return rc;
    257 
    258         if (NULL == instance)
    259                 return ENOENT;
    260        
    261         *size = instance->volumes[DEFAULT_VOL].logical_block_size;
    262        
    263         return EOK;
    264 }
    265 
    266 static int udf_total_block_count(service_id_t service_id, uint64_t *count)
    267 {
    268         *count = 0;
    269        
    270         return EOK;
    271 }
    272 
    273 static int udf_free_block_count(service_id_t service_id, uint64_t *count)
    274 {
    275         *count = 0;
    276        
    277         return EOK;
    278 }
    279 
    280251libfs_ops_t udf_libfs_ops = {
    281252        .root_get = udf_root_get,
    … …  
    294265        .is_directory = udf_is_directory,
    295266        .is_file = udf_is_file,
    296         .service_get = udf_service_get,
    297         .size_block = udf_size_block,
    298         .total_block_count = udf_total_block_count,
    299         .free_block_count = udf_free_block_count
     267        .service_get = udf_service_get
    300268};
    301269

  • uspace/srv/vfs/vfs.c

    r758f8d5 r1e371cf  
    130130                        vfs_get_mtab(callid, &call);
    131131                        break;
    132                 case VFS_IN_STATFS:
    133                         vfs_statfs(callid, &call);
    134                         break;
    135132                default:
    136133                        async_answer_0(callid, ENOTSUP);

  • uspace/srv/vfs/vfs.h

    r758f8d5 r1e371cf  
    222222extern void vfs_wait_handle(ipc_callid_t, ipc_call_t *);
    223223extern void vfs_get_mtab(ipc_callid_t, ipc_call_t *);
    224 extern void vfs_statfs(ipc_callid_t, ipc_call_t *);
    225224
    226225#endif

  • uspace/srv/vfs/vfs_ops.c

    r758f8d5 r1e371cf  
    14121412}
    14131413
    1414 void vfs_statfs(ipc_callid_t rid, ipc_call_t *request)
    1415 {
    1416         char *path;
    1417         int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
    1418         if (rc != EOK) {
    1419                 async_answer_0(rid, rc);
    1420                 return;
    1421         }
    1422        
    1423         ipc_callid_t callid;
    1424         if (!async_data_read_receive(&callid, NULL)) {
    1425                 free(path);
    1426                 async_answer_0(callid, EINVAL);
    1427                 async_answer_0(rid, EINVAL);
    1428                 return;
    1429         }
    1430 
    1431         vfs_lookup_res_t lr;
    1432         fibril_rwlock_read_lock(&namespace_rwlock);
    1433         rc = vfs_lookup_internal(path, L_NONE, &lr, NULL);
    1434         free(path);
    1435         if (rc != EOK) {
    1436                 fibril_rwlock_read_unlock(&namespace_rwlock);
    1437                 async_answer_0(callid, rc);
    1438                 async_answer_0(rid, rc);
    1439                 return;
    1440         }
    1441         vfs_node_t *node = vfs_node_get(&lr);
    1442         if (!node) {
    1443                 fibril_rwlock_read_unlock(&namespace_rwlock);
    1444                 async_answer_0(callid, ENOMEM);
    1445                 async_answer_0(rid, ENOMEM);
    1446                 return;
    1447         }
    1448 
    1449         fibril_rwlock_read_unlock(&namespace_rwlock);
    1450 
    1451         async_exch_t *exch = vfs_exchange_grab(node->fs_handle);
    1452        
    1453         aid_t msg;
    1454         msg = async_send_3(exch, VFS_OUT_STATFS, node->service_id,
    1455             node->index, false, NULL);
    1456         async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    1457        
    1458         vfs_exchange_release(exch);
    1459        
    1460         sysarg_t rv;
    1461         async_wait_for(msg, &rv);
    1462 
    1463         async_answer_0(rid, rv);
    1464 
    1465         vfs_node_put(node);
    1466 }
    1467 
    14681414/**
    14691415 * @}
Note: See TracChangeset for help on using the changeset viewer.