sys_access()
authorBarret Rhoden <brho@cs.berkeley.edu>
Sat, 7 Aug 2010 01:06:11 +0000 (18:06 -0700)
committerKevin Klues <klueska@cs.berkeley.edu>
Thu, 3 Nov 2011 00:35:50 +0000 (17:35 -0700)
Since we don't have any resembling security or users, we just attempt a
lookup.  It can tell if files don't exist (ENOENT), but that's about it
for now.

kern/include/vfs.h
kern/src/syscall.c
kern/src/vfs.c
tests/file_test.c

index 07270d7..41284be 100644 (file)
@@ -478,6 +478,7 @@ ssize_t generic_file_read(struct file *file, char *buf, size_t count,
 ssize_t generic_file_write(struct file *file, const char *buf, size_t count,
                            off_t *offset);
 struct file *do_file_open(char *path, int flags, int mode);
+int do_file_access(char *path, int mode);
 struct file *dentry_open(struct dentry *dentry);
 void file_release(struct kref *kref);
 
index 2a256f9..5c79dff 100644 (file)
@@ -895,14 +895,21 @@ intreg_t sys_fcntl(struct proc* p, int fd, int cmd, int arg)
        return ufe(fcntl,fd,cmd,arg,0);
 }
 
-intreg_t sys_access(struct proc* p, const char* path, int type)
+static intreg_t sys_access(struct proc *p, const char *path, int mode)
 {
-       char* fn = user_strdup_errno(p,path,PGSIZE);
-       if(fn == NULL)
+       int retval;
+
+       char *t_path = user_strdup_errno(p, path, PGSIZE);
+       if (t_path == NULL)
                return -1;
-       int ret = ufe(access,PADDR(fn),type,0,0);
-       user_memdup_free(p,fn);
-       return ret;
+       retval = do_file_access(t_path, mode);
+       user_memdup_free(p, t_path);
+       printd("Access for path: %s retval: %d\n", path, retval);
+       if (retval < 0) {
+               set_errno(current_tf, -retval);
+               return -1;
+       }
+       return retval;
 }
 
 intreg_t sys_umask(struct proc* p, int mask)
index e33ef3b..9ff6051 100644 (file)
@@ -779,6 +779,22 @@ struct file *do_file_open(char *path, int flags, int mode)
        return file;
 }
 
+/* Checks to see if path can be accessed via mode.  Doesn't do much now.  This
+ * is an example of decent error propagation from the lower levels via int
+ * retvals. */
+int do_file_access(char *path, int mode)
+{
+       struct nameidata nd_r = {0}, *nd = &nd_r;
+       int retval = 0;
+       /* TODO: when we care about access, do stuff here.  Need to be a bit careful
+        * about how intent works with access (F_OK, R_OK, etc) and open (O_RDONLY)
+        */
+       nd->intent = mode;
+       retval = path_lookup(path, 0, nd);
+       path_release(nd);       
+       return retval;
+}
+
 /* Opens and returns the file specified by dentry */
 struct file *dentry_open(struct dentry *dentry)
 {
index 9182112..a2ae2ed 100644 (file)
@@ -4,6 +4,7 @@
 #include <fcntl.h>
 #include <arch/arch.h>
 #include <unistd.h>
+#include <errno.h>
 
 int main() 
 { 
@@ -27,5 +28,10 @@ int main()
        retval = read(fd, rbuf, 64);
        printf("Tried to read again, got %d bytes of buf: %s\n", retval, rbuf);
 
-       breakpoint();
+       retval = access("/bin/laden", X_OK);
+       if (errno != ENOENT)
+               printf("WARNING! Access error for Osama!\n");
+       retval = access("/dir1/f1.txt", R_OK);
+       if (retval < 0)
+               printf("WARNING! Access error for f1.txt!\n");
 }