Changes in / [3a67d63:224174f] in mainline

Files:

• boot/Makefile.common (modified) (1 diff)
• uspace/Makefile (modified) (1 diff)
• uspace/app/df/Makefile (added)
• uspace/app/df/df.c (added)
• uspace/app/trace/trace.c (modified) (1 diff)
• uspace/lib/c/generic/vfs/vfs.c (modified) (2 diffs)
• uspace/lib/c/include/ipc/vfs.h (modified) (2 diffs)
• uspace/lib/c/include/sys/statfs.h (added)
• uspace/lib/c/include/vfs/vfs.h (modified) (2 diffs)
• uspace/lib/fs/libfs.c (modified) (5 diffs)
• uspace/lib/fs/libfs.h (modified) (1 diff)
• uspace/srv/fs/exfat/exfat_ops.c (modified) (3 diffs)
• uspace/srv/fs/ext4fs/ext4fs_ops.c (modified) (3 diffs)
• uspace/srv/fs/fat/fat_ops.c (modified) (3 diffs)
• uspace/srv/fs/mfs/mfs_ops.c (modified) (3 diffs)
• uspace/srv/vfs/vfs.c (modified) (1 diff)
• uspace/srv/vfs/vfs.h (modified) (1 diff)
• uspace/srv/vfs/vfs_ops.c (modified) (1 diff)

boot/Makefile.common

@@ -202 +202 @@
         $(USPACE_PATH)/app/websrv/websrv \
         $(USPACE_PATH)/app/date/date \
-        $(USPACE_PATH)/app/vdemo/vdemo
+        $(USPACE_PATH)/app/vdemo/vdemo \
+        $(USPACE_PATH)/app/df/df
 
 ifeq ($(CONFIG_PCC),y)

uspace/Makefile

@@ -80 +80 @@
         app/vlaunch \
         app/vterm \
+        app/df \
         srv/clipboard \
         srv/locsrv \

uspace/app/trace/trace.c

@@ -724 +724 @@
         o = oper_new("stat", 0, arg_def, V_ERRNO, 0, resp_def);
         proto_add_oper(p, VFS_IN_STAT, o);
+        o = oper_new("statfs", 0, arg_def, V_ERRNO, 0, resp_def);
+        proto_add_oper(p, VFS_IN_STATFS, o);
 
         proto_register(SERVICE_VFS, p);

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

@@ -43 +43 @@
 #include <stdio.h>
 #include <sys/stat.h>
+#include <sys/statfs.h>
 #include <sys/types.h>
 #include <ipc/services.h>
@@ -892 +893 @@
 }
 
+int statfs(const char *path, struct statfs *statfs)
+{
+        sysarg_t rc;
+        sysarg_t rc_orig;
+        aid_t req;
+        size_t pa_size;
+        
+        char *pa = absolutize(path, &pa_size);
+        if (!pa)
+                return ENOMEM;
+        async_exch_t *exch = vfs_exchange_begin();
+        
+        req = async_send_0(exch, VFS_IN_STATFS, NULL);
+        rc = async_data_write_start(exch, pa, pa_size);
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
+                free(pa);
+                async_wait_for(req, &rc_orig);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        rc = async_data_read_start(exch, (void *) statfs, sizeof(struct statfs));
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
+                free(pa);
+                async_wait_for(req, &rc_orig);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        vfs_exchange_end(exch);
+        free(pa);
+        async_wait_for(req, &rc);
+        return rc;
+}
+
 /** @}
  */

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

@@ -82 +82 @@
         VFS_IN_WAIT_HANDLE,
         VFS_IN_MTAB_GET,
+        VFS_IN_STATFS
 } vfs_in_request_t;
 
@@ -98 +99 @@
         VFS_OUT_LOOKUP,
         VFS_OUT_DESTROY,
+        VFS_OUT_STATFS,
         VFS_OUT_LAST
 } vfs_out_request_t;

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

@@ -44 +44 @@
 #include "vfs_mtab.h"
 
+
 enum vfs_change_state_type {
         VFS_PASS_HANDLE
 };
+
 
 extern char *absolutize(const char *, size_t *);
@@ -61 +63 @@
 extern async_exch_t *vfs_exchange_begin(void);
 extern void vfs_exchange_end(async_exch_t *);
-
 #endif
 

uspace/lib/fs/libfs.c

@@ -45 +45 @@
 #include <mem.h>
 #include <sys/stat.h>
+#include <sys/statfs.h>
 #include <stdlib.h>
 
@@ -74 +75 @@
 static void libfs_open_node(libfs_ops_t *, fs_handle_t, ipc_callid_t,
     ipc_call_t *);
+static void libfs_statfs(libfs_ops_t *, fs_handle_t, ipc_callid_t, ipc_call_t *);
 
 static void vfs_out_mounted(ipc_callid_t rid, ipc_call_t *req)
@@ -219 +221 @@
 }
 
+static void vfs_out_statfs(ipc_callid_t rid, ipc_call_t *req)
+{
+        libfs_statfs(libfs_ops, reg.fs_handle, rid, req);
+}
 static void vfs_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
 {
@@ -276 +282 @@
                 case VFS_OUT_SYNC:
                         vfs_out_sync(callid, &call);
+                        break;
+                case VFS_OUT_STATFS:
+                        vfs_out_statfs(callid, &call);
                         break;
                 default:
@@ -830 +839 @@
 }
 
+void libfs_statfs(libfs_ops_t *ops, fs_handle_t fs_handle, ipc_callid_t rid,
+    ipc_call_t *request)
+{
+        service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
+        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
+        
+        fs_node_t *fn;
+        int rc = ops->node_get(&fn, service_id, index);
+        on_error(rc, answer_and_return(rid, rc));
+        
+        ipc_callid_t callid;
+        size_t size;
+        if ((!async_data_read_receive(&callid, &size)) ||
+            (size != sizeof(struct statfs))) {
+                ops->node_put(fn);
+                async_answer_0(callid, EINVAL);
+                async_answer_0(rid, EINVAL);
+                return;
+        }
+        
+        struct statfs statfs;
+        memset(&statfs, 0, sizeof(struct statfs));
+
+        if (NULL != ops->size_block)    
+                statfs.f_bsize = ops->size_block(service_id);
+        
+        ops->node_put(fn);
+        
+        async_data_read_finalize(callid, &statfs, sizeof(struct statfs));
+        async_answer_0(rid, EOK);
+}
+
+
 /** Open VFS triplet.
  *

uspace/lib/fs/libfs.h

@@ -93 +93 @@
         bool (* is_file)(fs_node_t *);
         service_id_t (* service_get)(fs_node_t *);
+        long (* size_block)(service_id_t);
 } libfs_ops_t;
 

uspace/srv/fs/exfat/exfat_ops.c

@@ -89 +89 @@
 static bool exfat_is_file(fs_node_t *node);
 static service_id_t exfat_service_get(fs_node_t *node);
+static long exfat_size_block(service_id_t);
 
 /*
@@ -912 +913 @@
 }
 
+long exfat_size_block(service_id_t service_id)
+{
+        exfat_bs_t *bs;
+        bs = block_bb_get(service_id);
+        
+        return BPC(bs);
+}
 
 /** libfs operations */
@@ -930 +938 @@
         .is_directory = exfat_is_directory,
         .is_file = exfat_is_file,
-        .service_get = exfat_service_get
+        .service_get = exfat_service_get,
+        .size_block = exfat_size_block
 };
 

uspace/srv/fs/ext4fs/ext4fs_ops.c

@@ -101 +101 @@
 static bool ext4fs_is_file(fs_node_t *node);
 static service_id_t ext4fs_service_get(fs_node_t *node);
+static long ext4fs_size_block(service_id_t);
 
 /* Static variables */
@@ -836 +837 @@
         ext4fs_node_t *enode = EXT4FS_NODE(fn);
         return enode->instance->service_id;
+}
+
+long ext4fs_size_block(service_id_t service_id)
+{
+        ext4fs_instance_t *inst;
+        int rc = ext4fs_instance_get(service_id, &inst);
+        if (rc != EOK)
+                return rc;
+        if (NULL == inst)
+                return ENOENT;
+        ext4_superblock_t *sb = inst->filesystem->superblock;
+        uint32_t block_size = ext4_superblock_get_block_size(sb);
+        return block_size;
 }
 
@@ -857 +871 @@
         .is_directory = ext4fs_is_directory,
         .is_file = ext4fs_is_file,
-        .service_get = ext4fs_service_get
+        .service_get = ext4fs_service_get,
+        .size_block = ext4fs_size_block
 };
 

uspace/srv/fs/fat/fat_ops.c

@@ -91 +91 @@
 static bool fat_is_file(fs_node_t *node);
 static service_id_t fat_service_get(fs_node_t *node);
+static long fat_size_block(service_id_t);
 
 /*
@@ -843 +844 @@
 }
 
+long fat_size_block(service_id_t service_id)
+{
+        fat_bs_t *bs;
+        bs = block_bb_get(service_id);
+
+        return BPC(bs);
+}
+
 /** libfs operations */
 libfs_ops_t fat_libfs_ops = {
@@ -860 +869 @@
         .is_directory = fat_is_directory,
         .is_file = fat_is_file,
-        .service_get = fat_service_get
+        .service_get = fat_service_get,
+        .size_block = fat_size_block
 };
 

uspace/srv/fs/mfs/mfs_ops.c

@@ -64 +64 @@
 static int mfs_check_sanity(struct mfs_sb_info *sbi);
 static bool is_power_of_two(uint32_t n);
+static long mfs_size_block(service_id_t service_id);
 
 static hash_table_t open_nodes;
@@ -84 +85 @@
         .destroy = mfs_destroy_node,
         .has_children = mfs_has_children,
-        .lnkcnt_get = mfs_lnkcnt_get
+        .lnkcnt_get = mfs_lnkcnt_get,
+        .size_block = mfs_size_block
 };
 
@@ -1129 +1131 @@
 }
 
+static long
+mfs_size_block(service_id_t service_id)
+{
+        long block_size;
+
+        struct mfs_instance *inst;
+        int rc = mfs_instance_get(service_id, &inst);
+        if (rc != EOK)
+                return rc;
+        if (NULL == inst)
+                return ENOENT;
+        block_size = inst->sbi->block_size;
+        return block_size;
+}
+
 vfs_out_ops_t mfs_ops = {
         .mounted = mfs_mounted,

uspace/srv/vfs/vfs.c

@@ -130 +130 @@
                         vfs_get_mtab(callid, &call);
                         break;
+                case VFS_IN_STATFS:
+                        vfs_statfs(callid, &call);
+                        break;
                 default:
                         async_answer_0(callid, ENOTSUP);

uspace/srv/vfs/vfs.h

@@ -222 +222 @@
 extern void vfs_wait_handle(ipc_callid_t, ipc_call_t *);
 extern void vfs_get_mtab(ipc_callid_t, ipc_call_t *);
+extern void vfs_statfs(ipc_callid_t, ipc_call_t *);
 
 #endif

uspace/srv/vfs/vfs_ops.c

@@ -1418 +1418 @@
 }
 
+void vfs_statfs(ipc_callid_t rid, ipc_call_t *request)
+{
+        char *path;
+        int rc = async_data_write_accept((void **) &path, true, 0, 0, 0, NULL);
+        if (rc != EOK) {
+                async_answer_0(rid, rc);
+                return;
+        }
+        
+        ipc_callid_t callid;
+        if (!async_data_read_receive(&callid, NULL)) {
+                free(path);
+                async_answer_0(callid, EINVAL);
+                async_answer_0(rid, EINVAL);
+                return;
+        }
+
+        vfs_lookup_res_t lr;
+        fibril_rwlock_read_lock(&namespace_rwlock);
+        rc = vfs_lookup_internal(path, L_NONE, &lr, NULL);
+        free(path);
+        if (rc != EOK) {
+                fibril_rwlock_read_unlock(&namespace_rwlock);
+                async_answer_0(callid, rc);
+                async_answer_0(rid, rc);
+                return;
+        }
+        vfs_node_t *node = vfs_node_get(&lr);
+        if (!node) {
+                fibril_rwlock_read_unlock(&namespace_rwlock);
+                async_answer_0(callid, ENOMEM);
+                async_answer_0(rid, ENOMEM);
+                return;
+        }
+
+        fibril_rwlock_read_unlock(&namespace_rwlock);
+
+        async_exch_t *exch = vfs_exchange_grab(node->fs_handle);
+        
+        aid_t msg;
+        msg = async_send_3(exch, VFS_OUT_STATFS, node->service_id,
+            node->index, false, NULL);
+        async_forward_fast(callid, exch, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
+        
+        vfs_exchange_release(exch);
+        
+        sysarg_t rv;
+        async_wait_for(msg, &rv);
+
+        async_answer_0(rid, rv);
+
+        vfs_node_put(node);
+}
+
 /**
  * @}