Changes in uspace/lib/c/generic/vfs/vfs.c [f77c1c9:8d2dd7f2] in mainline

File:

• uspace/lib/c/generic/vfs/vfs.c (modified) (28 diffs)

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

@@ -86 +86 @@
  * and consume system resources.
  *
- * Functions that return int return an error code on error and do not
+ * Functions that return int return a negative error code on error and do not
  * set errno. Depending on function, success is signalled by returning either
  * EOK or a non-negative file handle.
@@ -104 +104 @@
  *      aoff64_t pos = 42;
  *      char buf[512];
- *      size_t nread;
- *      rc = vfs_read(file, &pos, buf, sizeof(buf), &nread);
- *      if (rc != EOK) {
+ *      ssize_t size = vfs_read(file, &pos, buf, sizeof(buf));
+ *      if (size < 0) {
  *              vfs_put(file);
- *              return rc;
+ *              return size;
  *      }
  *
- *      // buf is now filled with nread bytes from file
+ *      // buf is now filled with data from file
  *
  *      vfs_put(file);
@@ -128 +127 @@
 static int root_fd = -1;
 
-static int get_parent_and_child(const char *path, int *parent, char **child)
+static int get_parent_and_child(const char *path, char **child)
 {
         size_t size;
@@ -136 +135 @@
 
         char *slash = str_rchr(apath, L'/');
+        int parent;
         if (slash == apath) {
-                *parent = vfs_root();
-                if (*parent < 0) {
-                        free(apath);
-                        return EBADF;
-                }
+                parent = vfs_root();
                 *child = apath;
-                return EOK;
         } else {
                 *slash = '\0';
-                int rc = vfs_lookup(apath, WALK_DIRECTORY, parent);
-                if (rc != EOK) {
+                parent = vfs_lookup(apath, WALK_DIRECTORY);
+                if (parent < 0) {
                         free(apath);
-                        return rc;
+                        return parent;
                 }
                 *slash = '/';
@@ -155 +150 @@
                 free(apath);
                 if (!*child) {
-                        vfs_put(*parent);
+                        vfs_put(parent);
                         return ENOMEM;
                 }
-
-                return rc;
-        }
-
+        }
+
+        return parent;
 }
 
@@ -238 +232 @@
  * @return              New file handle on success or a negative error code
  */
-int vfs_clone(int file_from, int file_to, bool high, int *handle)
-{
-        assert(handle != NULL);
-
+int vfs_clone(int file_from, int file_to, bool high)
+{
         async_exch_t *vfs_exch = vfs_exchange_begin();
-        sysarg_t ret;
-        int rc = async_req_3_1(vfs_exch, VFS_IN_CLONE, (sysarg_t) file_from,
-            (sysarg_t) file_to, (sysarg_t) high, &ret);
+        int rc = async_req_3_0(vfs_exch, VFS_IN_CLONE, (sysarg_t) file_from,
+            (sysarg_t) file_to, (sysarg_t) high);
         vfs_exchange_end(vfs_exch);
-
-        if (rc == EOK) {
-                *handle = ret;
-        }
         return rc;
 }
@@ -289 +276 @@
                 return ENOMEM;
         
-        int fd;
-        int rc = vfs_lookup(abs, WALK_DIRECTORY, &fd);
-        if (rc != EOK) {
+        int fd = vfs_lookup(abs, WALK_DIRECTORY);
+        if (fd < 0) {
                 free(abs);
-                return rc;
+                return fd;
         }
         
@@ -504 +490 @@
 {
         int flags = (kind == KIND_DIRECTORY) ? WALK_DIRECTORY : WALK_REGULAR;
-        int file = -1;
-        int rc = vfs_walk(parent, child, WALK_MUST_CREATE | flags, &file);
-        if (rc != EOK)
-                return rc;
+        int file = vfs_walk(parent, child, WALK_MUST_CREATE | flags);
+
+        if (file < 0)
+                return file;
 
         if (linkedfd)
@@ -534 +520 @@
 {
         char *child;
-        int parent;
-        int rc = get_parent_and_child(path, &parent, &child);
-        if (rc != EOK)
-                return rc;
-
-        rc = vfs_link(parent, child, kind, linkedfd);
+        int parent = get_parent_and_child(path, &child);
+        if (parent < 0)
+                return parent;
+
+        int rc = vfs_link(parent, child, kind, linkedfd);
 
         free(child);
         vfs_put(parent);
         return rc;
-}
+}       
 
 /** Lookup a path relative to the local root
@@ -550 +535 @@
  * @param path  Path to be looked up
  * @param flags Walk flags
- * @param[out] handle Pointer to variable where handle is to be written.
- *
- * @return      EOK on success or an error code.
- */
-int vfs_lookup(const char *path, int flags, int *handle)
+ *
+ * @return      File handle representing the result on success or a negative
+ *              error code on error
+ */
+int vfs_lookup(const char *path, int flags)
 {
         size_t size;
@@ -560 +545 @@
         if (!p)
                 return ENOMEM;
-
         int root = vfs_root();
         if (root < 0) {
@@ -566 +550 @@
                 return ENOENT;
         }
-
-        int rc = vfs_walk(root, p, flags, handle);
+        int rc = vfs_walk(root, p, flags);
         vfs_put(root);
         free(p);
@@ -580 +563 @@
  * @param flags Walk flags
  * @param mode  Mode in which to open file in
- * @param[out] handle Pointer to variable where handle is to be written.
  *
  * @return      EOK on success or a negative error code
  */
-int vfs_lookup_open(const char *path, int flags, int mode, int *handle)
-{
-        int file;
-        int rc = vfs_lookup(path, flags, &file);
-        if (rc != EOK)
-                return rc;
-
-        rc = vfs_open(file, mode);
+int vfs_lookup_open(const char *path, int flags, int mode)
+{
+        int file = vfs_lookup(path, flags);
+        if (file < 0)
+                return file;
+
+        int rc = vfs_open(file, mode);
         if (rc != EOK) {
                 vfs_put(file);
                 return rc;
         }
-
-        *handle = file;
-        return EOK;
+        
+        return file;
 }
 
@@ -726 +706 @@
                 }
                 
-                int mpfd;
-                rc = vfs_walk(root_fd, mpa, WALK_DIRECTORY, &mpfd);
-                if (rc == EOK) {
+                int mpfd = vfs_walk(root_fd, mpa, WALK_DIRECTORY);
+                if (mpfd >= 0) {
                         rc = vfs_mount(mpfd, fs_name, service_id, opts, flags,
                             instance, NULL);
                         vfs_put(mpfd);
+                } else {
+                        rc = mpfd;
                 }
         }
@@ -793 +774 @@
  * @param high   If true, the received file handle will be allocated from high
  *               indices
- * @param[out] handle  Received handle.
  *
  * @return       EOK on success or a negative error code
  */
-int vfs_receive_handle(bool high, int *handle)
+int vfs_receive_handle(bool high)
 {
         ipc_callid_t callid;
@@ -814 +794 @@
         async_exchange_end(vfs_exch);
 
-        if (rc == EOK) {
-                *handle = (int) ret;
-        }
-
-        return rc;
+        if (rc != EOK)
+                return rc;
+        return ret;
 }
 
@@ -830 +808 @@
  * @param buf           Buffer, @a nbytes bytes long
  * @param nbytes        Number of bytes to read
- * @param nread         Place to store number of bytes actually read
- *
- * @return              On success, EOK and @a *nread is filled with number
- *                      of bytes actually read.
- * @return              On failure, an error code
- */
-int vfs_read(int file, aoff64_t *pos, void *buf, size_t nbyte, size_t *nread)
+ *
+ * @return              On success, non-negative number of bytes read
+ * @return              On failure, a negative error code
+ */
+ssize_t vfs_read(int file, aoff64_t *pos, void *buf, size_t nbyte)
 {
         ssize_t cnt = 0;
-        size_t nr = 0;
+        size_t nread = 0;
         uint8_t *bp = (uint8_t *) buf;
         int rc;
@@ -845 +821 @@
         do {
                 bp += cnt;
-                nr += cnt;
+                nread += cnt;
                 *pos += cnt;
-                rc = vfs_read_short(file, *pos, bp, nbyte - nr, &cnt);
-        } while (rc == EOK && cnt > 0 && (nbyte - nr - cnt) > 0);
-        
-        if (rc != EOK) {
-                *nread = nr;
+                rc = vfs_read_short(file, *pos, bp, nbyte - nread, &cnt);
+        } while (rc == EOK && cnt > 0 && (nbyte - nread - cnt) > 0);
+        
+        if (rc != EOK)
                 return rc;
-        }
-        
-        nr += cnt;
+        
         *pos += cnt;
-        *nread = nr;
-        return EOK;
+        return nread + cnt;
 }
 
@@ -997 +969 @@
 /** Return a new file handle representing the local root
  *
- * @return      A clone of the local root file handle or -1
+ * @return      A clone of the local root file handle or a negative error code
  */
 int vfs_root(void)
 {
-        fibril_mutex_lock(&root_mutex);
-        int fd;
-        if (root_fd < 0) {
-                fd = -1;
-        } else {
-                int rc = vfs_clone(root_fd, -1, true, &fd);
-                if (rc != EOK) {
-                        fd = -1;
-                }
-        }
+        fibril_mutex_lock(&root_mutex); 
+        int r;
+        if (root_fd < 0)
+                r = ENOENT;
+        else
+                r = vfs_clone(root_fd, -1, true);
         fibril_mutex_unlock(&root_mutex);
-        return fd;
+        return r;
 }
 
@@ -1022 +990 @@
  *
  * @param nroot The new local root file handle
- *
- * @return  Error code
- */
-int vfs_root_set(int nroot)
-{
-        int new_root;
-        int rc = vfs_clone(nroot, -1, true, &new_root);
-        if (rc != EOK) {
-                return rc;
-        }
-
+ */
+void vfs_root_set(int nroot)
+{
         fibril_mutex_lock(&root_mutex);
         if (root_fd >= 0)
                 vfs_put(root_fd);
-        root_fd = new_root;
+        root_fd = vfs_clone(nroot, -1, true);
         fibril_mutex_unlock(&root_mutex);
-
-        return EOK;
 }
 
@@ -1085 +1043 @@
 int vfs_stat_path(const char *path, struct stat *stat)
 {
-        int file;
-        int rc = vfs_lookup(path, 0, &file);
-        if (rc != EOK)
-                return rc;
-        
-        rc = vfs_stat(file, stat);
+        int file = vfs_lookup(path, 0);
+        if (file < 0)
+                return file;
+        
+        int rc = vfs_stat(file, stat);
 
         vfs_put(file);
@@ -1131 +1088 @@
 int vfs_statfs_path(const char *path, struct statfs *st)
 {
-        int file;
-        int rc = vfs_lookup(path, 0, &file);
-        if (rc != EOK)
-                return rc;
-        
-        rc = vfs_statfs(file, st);
+        int file = vfs_lookup(path, 0);
+        if (file < 0)
+                return file;
+        
+        int rc = vfs_statfs(file, st);
 
         vfs_put(file);
@@ -1202 +1158 @@
 int vfs_unlink_path(const char *path)
 {
-        int expect;
-        int rc = vfs_lookup(path, 0, &expect);
-        if (rc != EOK)
-                return rc;
+        int expect = vfs_lookup(path, 0);
+        if (expect < 0)
+                return expect;
 
         char *child;
-        int parent;
-        rc = get_parent_and_child(path, &parent, &child);
-        if (rc != EOK) {
+        int parent = get_parent_and_child(path, &child);
+        if (parent < 0) {
                 vfs_put(expect);
-                return rc;
-        }
-
-        rc = vfs_unlink(parent, child, expect);
+                return parent;
+        }
+
+        int rc = vfs_unlink(parent, child, expect);
         
         free(child);
@@ -1245 +1199 @@
 int vfs_unmount_path(const char *mpp)
 {
-        int mp;
-        int rc = vfs_lookup(mpp, WALK_MOUNT_POINT | WALK_DIRECTORY, &mp);
-        if (rc != EOK)
-                return rc;
-        
-        rc = vfs_unmount(mp);
+        int mp = vfs_lookup(mpp, WALK_MOUNT_POINT | WALK_DIRECTORY);
+        if (mp < 0)
+                return mp;
+        
+        int rc = vfs_unmount(mp);
         vfs_put(mp);
         return rc;
@@ -1260 +1213 @@
  * @param path          Parent-relative path to be walked
  * @param flags         Flags influencing the walk
- * @param[out] handle   File handle representing the result on success.
- *
- * @return              Error code.
- */
-int vfs_walk(int parent, const char *path, int flags, int *handle)
+ *
+ * @retrun              File handle representing the result on success or
+ *                      a negative error code on error
+ */
+int vfs_walk(int parent, const char *path, int flags)
 {
         async_exch_t *exch = vfs_exchange_begin();
@@ -1282 +1235 @@
                 return (int) rc;
         
-        *handle = (int) IPC_GET_ARG1(answer);
-        return EOK;
+        return (int) IPC_GET_ARG1(answer);
 }
 
@@ -1295 +1247 @@
  * @param buf           Data, @a nbytes bytes long
  * @param nbytes        Number of bytes to write
- * @param nwritten      Place to store number of bytes written
- *
- * @return              On success, EOK, @a *nwr is filled with number
- *                      of bytes written
- * @return              On failure, an error code
- */
-int vfs_write(int file, aoff64_t *pos, const void *buf, size_t nbyte,
-    size_t *nwritten)
+ *
+ * @return              On success, non-negative number of bytes written
+ * @return              On failure, a negative error code
+ */
+ssize_t vfs_write(int file, aoff64_t *pos, const void *buf, size_t nbyte)
 {
         ssize_t cnt = 0;
-        ssize_t nwr = 0;
+        ssize_t nwritten = 0;
         const uint8_t *bp = (uint8_t *) buf;
         int rc;
@@ -1311 +1260 @@
         do {
                 bp += cnt;
-                nwr += cnt;
+                nwritten += cnt;
                 *pos += cnt;
-                rc = vfs_write_short(file, *pos, bp, nbyte - nwr, &cnt);
-        } while (rc == EOK && ((ssize_t )nbyte - nwr - cnt) > 0);
-
-        if (rc != EOK) {
-                *nwritten = nwr;
+                rc = vfs_write_short(file, *pos, bp, nbyte - nwritten, &cnt);
+        } while (rc == EOK && ((ssize_t )nbyte - nwritten - cnt) > 0);
+
+        if (rc != EOK)
                 return rc;
-        }
-
-        nwr += cnt;
+
         *pos += cnt;
-        *nwritten = nwr;
-        return EOK;
+        return nbyte;
 }