[kernel] Fix permission for /dev files

base/home/root/rootfile.txt

···
+Root file

base/home/user/userfile.txt

···
+User file

build/tools/build_scripts.py

···
 sudo mkdir -p {0}/mountpoint/tmp
 sudo cp -r {0}/base/* {0}/mountpoint/
 sudo cp -r {1}/base/* {0}/mountpoint/
+
+sudo chmod -R 644 {0}/mountpoint/proc
+sudo chmod -R 644 {0}/mountpoint/dev
+sudo chmod -R 666 {0}/mountpoint/tmp
+sudo chmod -R 755 {0}/mountpoint/bin
+sudo chmod -R 700 {0}/mountpoint/home
+sudo chmod 777 {0}/mountpoint/home
+sudo chmod -R 755 {0}/mountpoint/System
+sudo chmod -R 755 {0}/mountpoint/Applications
+
+sudo chown -R 0 {0}/mountpoint/home/root
+sudo chown -R 10 {0}/mountpoint/home/user
+
 sudo umount {0}/mountpoint
 if [ $? -ne 0 ]; then echo -e "${{ERROR}} Can't umount {0}/mountpoint" && exit 1; fi
 echo -e "${{SUCCESS}} Sync"

kernel/include/fs/vfs.h

···
 int vfs_munmap(struct proc* p, struct proc_zone*);
 
 struct thread;
-int vfs_perm_to_read(file_descriptor_t* fd, struct thread* t);
-int vfs_perm_to_write(file_descriptor_t* fd, struct thread* t);
-int vfs_perm_to_execute(file_descriptor_t* fd, struct thread* t);
+int vfs_perm_to_read(dentry_t* dentry, struct thread* t);
+int vfs_perm_to_write(dentry_t* dentry, struct thread* t);
+int vfs_perm_to_execute(dentry_t* dentry, struct thread* t);
 
 #endif // _KERNEL_FS_VFS_H

kernel/kernel/drivers/aarch32/pl050_mouse.c

···
         file_ops_t fops = { 0 };
         fops.can_read = _mouse_can_read;
         fops.read = _mouse_read;
-        devfs_inode_t* res = devfs_register(mp, MKDEV(10, 1), "mouse", 5, 0, &fops);
+        devfs_inode_t* res = devfs_register(mp, MKDEV(10, 1), "mouse", 5, 0600, &fops);
 
         dentry_put(mp);
     }

kernel/kernel/drivers/aarch32/pl111.c

···
         file_ops_t fops = { 0 };
         fops.ioctl = _pl111_ioctl;
         fops.mmap = _pl111_mmap;
-        devfs_inode_t* res = devfs_register(mp, MKDEV(10, 156), "bga", 3, 0, &fops);
+        devfs_inode_t* res = devfs_register(mp, MKDEV(10, 156), "bga", 3, 0777, &fops);
 
         dentry_put(mp);
     }

kernel/kernel/drivers/generic/keyboard.c

···
     file_ops_t fops = { 0 };
     fops.can_read = _generic_keyboard_can_read;
     fops.read = _generic_keyboard_read;
-    devfs_inode_t* res = devfs_register(mp, MKDEV(11, 0), "kbd", 3, 0, &fops);
+    devfs_inode_t* res = devfs_register(mp, MKDEV(11, 0), "kbd", 3, 0400, &fops);
 
     dentry_put(mp);
     return 0;

kernel/kernel/drivers/x86/bga.c

···
         file_ops_t fops = { 0 };
         fops.ioctl = _bga_ioctl;
         fops.mmap = _bga_mmap;
-        devfs_inode_t* res = devfs_register(mp, MKDEV(10, 156), "bga", 3, 0, &fops);
+        devfs_inode_t* res = devfs_register(mp, MKDEV(10, 156), "bga", 3, 0777, &fops);
 
         dentry_put(mp);
     }

kernel/kernel/drivers/x86/mouse.c

···
         file_ops_t fops = { 0 };
         fops.can_read = _mouse_can_read;
         fops.read = _mouse_read;
-        devfs_inode_t* res = devfs_register(mp, MKDEV(10, 1), "mouse", 5, 0, &fops);
+        devfs_inode_t* res = devfs_register(mp, MKDEV(10, 1), "mouse", 5, 0400, &fops);
 
         dentry_put(mp);
     }

kernel/kernel/fs/vfs.c

···
     }
 
     if (flags & O_EXEC) {
-        if (vfs_perm_to_execute(fd, cur_thread) != 0) {
+        if (vfs_perm_to_execute(file, cur_thread) != 0) {
+            log("can't open exec");
             return -EACCES;
         }
     }
 
     if (flags & O_WRONLY) {
-        if (vfs_perm_to_write(fd, cur_thread) != 0) {
+        if (vfs_perm_to_write(file, cur_thread) != 0) {
+            log("can't open write");
             return -EACCES;
         }
         if (dentry_inode_test_flag(file, S_IFDIR)) {
···
     }
 
     if (flags & O_RDONLY) {
-        if (vfs_perm_to_read(fd, cur_thread) != 0) {
+        if (vfs_perm_to_read(file, cur_thread) != 0) {
+            log("can't open read");
             return -EACCES;
         }
     }
···
     return 0;
 }
 
-int vfs_perm_to_read(file_descriptor_t* fd, thread_t* thread)
+int vfs_perm_to_read(dentry_t* dentry, thread_t* thread)
 {
     // If no running, so call is from kernel
     uid_t uid = 0;
···
         gid = thread->process->gid;
     }
 
-    mode_t mode = fd->dentry->inode->mode;
-    uid_t fuid = fd->dentry->inode->uid;
-    gid_t fgid = fd->dentry->inode->gid;
+    mode_t mode = dentry->inode->mode;
+    uid_t fuid = dentry->inode->uid;
+    gid_t fgid = dentry->inode->gid;
     if (uid == 0) {
         return 0;
     }
···
     return -EPERM;
 }
 
-int vfs_perm_to_write(file_descriptor_t* fd, thread_t* thread)
+int vfs_perm_to_write(dentry_t* dentry, thread_t* thread)
 {
     // If no running, so call is from kernel
     uid_t uid = 0;
···
         gid = thread->process->gid;
     }
 
-    mode_t mode = fd->dentry->inode->mode;
-    uid_t fuid = fd->dentry->inode->uid;
-    gid_t fgid = fd->dentry->inode->gid;
+    mode_t mode = dentry->inode->mode;
+    uid_t fuid = dentry->inode->uid;
+    gid_t fgid = dentry->inode->gid;
     if (uid == 0) {
         return 0;
     }
···
     return -EPERM;
 }
 
-int vfs_perm_to_execute(file_descriptor_t* fd, thread_t* thread)
+int vfs_perm_to_execute(dentry_t* dentry, thread_t* thread)
 {
     // If no running, so call is from kernel
     uid_t uid = 0;
···
         gid = thread->process->gid;
     }
 
-    mode_t mode = fd->dentry->inode->mode;
-    uid_t fuid = fd->dentry->inode->uid;
-    gid_t fgid = fd->dentry->inode->gid;
+    mode_t mode = dentry->inode->mode;
+    uid_t fuid = dentry->inode->uid;
+    gid_t fgid = dentry->inode->gid;
     if (uid == 0) {
         return 0;
     }

kernel/kernel/io/tty/ptmx.c

···
     fops.can_write = ptmx_can_write;
     fops.read = ptmx_read;
     fops.write = ptmx_write;
-    devfs_inode_t* res = devfs_register(mp, MKDEV(5, 2), "ptmx", 4, 0, &fops);
+    devfs_inode_t* res = devfs_register(mp, MKDEV(5, 2), "ptmx", 4, 0777, &fops);
     dentry_put(mp);
     return 0;
 }

kernel/kernel/io/tty/pty_slave.c

···
         fops.read = pty_slave_read;
         fops.write = pty_slave_write;
         fops.ioctl = pty_slave_ioctl;
-        devfs_inode_t* res = devfs_register(mp, MKDEV(136, id), name, 4, 0, &fops);
+        devfs_inode_t* res = devfs_register(mp, MKDEV(136, id), name, 4, 0777, &fops);
         pty_slaves[id].inode_indx = res->index;
         pty_slaves[id].ptm = ptm;
         pty_slaves[id].buffer = sync_ringbuffer_create_std();

kernel/kernel/io/tty/tty.c

···
     fops.read = tty_read;
     fops.write = tty_write;
     fops.ioctl = tty_ioctl;
-    devfs_inode_t* res = devfs_register(mp, MKDEV(4, next_tty), name, 4, 0, &fops);
+    devfs_inode_t* res = devfs_register(mp, MKDEV(4, next_tty), name, 4, 0777, &fops);
     ttys[next_tty].id = next_tty;
     ttys[next_tty].inode_indx = res->index;
     ttys[next_tty].buffer = sync_ringbuffer_create_std();

kernel/kernel/tasking/proc.c

···
     file_descriptor_t fd;
     dentry_t* dentry;
 
+    log("starting %s", path);
     if (vfs_resolve_path_start_from(p->cwd, path, &dentry) != 0) {
         return -ENOENT;
     }

userland/system/dock/DockView.cpp

···
 void DockView::launch(const FastLaunchEntity& ent)
 {
     if (fork() == 0) {
+        // Switching to test "user"
+        setuid(10);
+        setgid(10);
         execve(ent.path_to_exec().c_str(), 0, 0);
         std::abort();
     }

userland/utilities/cat/main.c

···
     }
 
     for (i = 1; i < argc; i++) {
-        if ((fd = open(argv[i], 0)) < 0) {
-            // printf(1, "cat: cannot open %s\n", argv[i]);
+        if ((fd = open(argv[i], O_RDONLY)) < 0) {
+            printf("cat: cannot open %s\n", argv[i]);
             return 1;
         }
         cat(fd);