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