Fixes bug in close_all_files()
[akaros.git] / kern / src / vfs.c
index 3d84be2..743413b 100644 (file)
@@ -207,7 +207,7 @@ static int follow_symlink(struct nameidata *nd)
 {
        int retval;
        char *symname;
-       if (nd->dentry->d_inode->i_type != FS_I_SYMLINK)
+       if (!S_ISLNK(nd->dentry->d_inode->i_mode))
                return 0;
        if (nd->depth > MAX_SYMLINK_DEPTH)
                return -ELOOP;
@@ -283,9 +283,17 @@ static int link_path_walk(char *path, struct nameidata *nd)
        /* skip all leading /'s */
        while (*link == '/')
                link++;
-       /* if there's nothing left (null terminated), we're done */
-       if (*link == '\0')
+       /* if there's nothing left (null terminated), we're done.  This should only
+        * happen for "/", which if we wanted a PARENT, should fail (there is no
+        * parent). */
+       if (*link == '\0') {
+               if (nd->flags & LOOKUP_PARENT) {
+                       set_errno(ENOENT);
+                       return -1;
+               }
+               /* o/w, we're good */
                return 0;
+       }
        /* iterate through each intermediate link of the path.  in general, nd
         * tracks where we are in the path, as far as dentries go.  once we have the
         * next dentry, we try to update nd based on that dentry.  link is the part
@@ -328,7 +336,7 @@ static int link_path_walk(char *path, struct nameidata *nd)
                 * during the follow_symlink (a symlink could have had a directory at
                 * the end), though it was in the middle of the real path. */
                nd->flags &= ~LOOKUP_DIRECTORY;
-               if (!(nd->dentry->d_inode->i_type & FS_I_DIR))
+               if (!S_ISDIR(nd->dentry->d_inode->i_mode))
                        return -ENOTDIR;
 next_loop:
                /* move through the path string to the next entry */
@@ -345,6 +353,7 @@ next_loop:
         * the last item (link). */
        if (!strcmp(".", link)) {
                if (nd->flags & LOOKUP_PARENT) {
+                       assert(nd->dentry->d_name.name);
                        stash_nd_name(nd, nd->dentry->d_name.name);
                        climb_up(nd);
                }
@@ -353,6 +362,7 @@ next_loop:
        if (!strcmp("..", link)) {
                climb_up(nd);
                if (nd->flags & LOOKUP_PARENT) {
+                       assert(nd->dentry->d_name.name);
                        stash_nd_name(nd, nd->dentry->d_name.name);
                        climb_up(nd);
                }
@@ -363,6 +373,7 @@ next_loop:
        if (!link_dentry) {
                /* if there's no dentry, we are okay if we are looking for the parent */
                if (nd->flags & LOOKUP_PARENT) {
+                       assert(strcmp(link, ""));
                        stash_nd_name(nd, link);
                        return 0;
                } else {
@@ -384,6 +395,7 @@ next_loop:
         * all.  Now we need to climb up to set nd back on the parent, if that's
         * what we wanted */
        if (nd->flags & LOOKUP_PARENT) {
+               assert(nd->dentry->d_name.name);
                stash_nd_name(nd, link_dentry->d_name.name);
                climb_up(nd);
                return 0;
@@ -392,8 +404,7 @@ next_loop:
         * mountpoint still.  FYI: this hasn't been thought through completely. */
        follow_mount(nd);
        /* If we wanted a directory, but didn't get one, error out */
-       if ((nd->flags & LOOKUP_DIRECTORY) &&
-          !(nd->dentry->d_inode->i_type & FS_I_DIR))
+       if ((nd->flags & LOOKUP_DIRECTORY) && !S_ISDIR(nd->dentry->d_inode->i_mode))
                return -ENOTDIR;
        return 0;
 }
@@ -402,10 +413,18 @@ next_loop:
  * initialized for the first call - specifically, we need the intent. 
  * LOOKUP_PARENT and friends go in the flags var, which is not the intent.
  *
+ * If path_lookup wants a PARENT, but hits the top of the FS (root or
+ * otherwise), we want it to error out.  It's still unclear how we want to
+ * handle processes with roots that aren't root, but at the very least, we don't
+ * want to think we have the parent of /, but have / itself.  Due to the way
+ * link_path_walk works, if that happened, we probably don't have a
+ * nd->last.name.  This needs more thought (TODO).
+ *
  * Need to be careful too.  While the path has been copied-in to the kernel,
  * it's still user input.  */
 int path_lookup(char *path, int flags, struct nameidata *nd)
 {
+       int retval;
        printd("Path lookup for %s\n", path);
        /* we allow absolute lookups with no process context */
        if (path[0] == '/') {                   /* absolute lookup */
@@ -425,7 +444,11 @@ int path_lookup(char *path, int flags, struct nameidata *nd)
        kref_get(&nd->dentry->d_kref, 1);
        nd->flags = flags;
        nd->depth = 0;                                  /* used in symlink following */
-       return link_path_walk(path, nd);        
+       retval =  link_path_walk(path, nd);     
+       /* make sure our PARENT lookup worked */
+       if (!retval && (flags & LOOKUP_PARENT))
+               assert(nd->last.name);
+       return retval;
 }
 
 /* Call this after any use of path_lookup when you are done with its results,
@@ -677,13 +700,15 @@ struct inode *get_inode(struct dentry *dentry)
  * note we don't pass this an nd, like Linux does... */
 static struct inode *create_inode(struct dentry *dentry, int mode)
 {
-       /* note it is the i_ino that uniquely identifies a file in the system.
-        * there's a diff between creating an inode (even for an in-use ino) and
-        * then filling it in, and vs creating a brand new one */
+       /* note it is the i_ino that uniquely identifies a file in the specific
+        * filesystem.  there's a diff between creating an inode (even for an in-use
+        * ino) and then filling it in, and vs creating a brand new one.
+        * get_inode() sets it to 0, and it should be filled in later in an
+        * FS-specific manner. */
        struct inode *inode = get_inode(dentry);
        if (!inode)
                return 0;
-       inode->i_mode = mode;
+       inode->i_mode = mode & S_PMASK; /* note that after this, we have no type */
        inode->i_nlink = 1;
        inode->i_size = 0;
        inode->i_blocks = 0;
@@ -702,13 +727,16 @@ static struct inode *create_inode(struct dentry *dentry, int mode)
 
 /* Create a new disk inode in dir associated with dentry, with the given mode.
  * called when creating a regular file.  dir is the directory/parent.  dentry is
- * the dentry of the inode we are creating.  Note the lack of the nd... */
+ * the dentry of the inode we are creating.  Note the lack of the nd...
+ * Also, we do the nlink++ in here, since we want to give the FS's a chance to
+ * fail. */
 int create_file(struct inode *dir, struct dentry *dentry, int mode)
 {
        struct inode *new_file = create_inode(dentry, mode);
        if (!new_file)
                return -1;
        dir->i_op->create(dir, dentry, mode, 0);
+       dir->i_nlink++;
        kref_put(&new_file->i_kref);
        return 0;
 }
@@ -721,6 +749,7 @@ int create_dir(struct inode *dir, struct dentry *dentry, int mode)
        if (!new_dir)
                return -1;
        dir->i_op->mkdir(dir, dentry, mode);
+       dir->i_nlink++;
        /* Make sure my parent tracks me.  This is okay, since no directory (dir)
         * can have more than one dentry */
        struct dentry *parent = TAILQ_FIRST(&dir->i_dentry);
@@ -740,6 +769,7 @@ int create_symlink(struct inode *dir, struct dentry *dentry,
        if (!new_sym)
                return -1;
        dir->i_op->symlink(dir, dentry, symname);
+       dir->i_nlink++;                 /* TODO: race with this, among other things */
        kref_put(&new_sym->i_kref);
        return 0;
 }
@@ -758,6 +788,7 @@ int check_perms(struct inode *inode, int access_mode)
 void inode_release(struct kref *kref)
 {
        struct inode *inode = container_of(kref, struct inode, i_kref);
+       TAILQ_REMOVE(&inode->i_sb->s_inodes, inode, i_sb_list);
        /* If we still have links, just dealloc the in-memory inode.  if we have no
         * links, we need to delete it too (which calls destroy). */
        if (inode->i_nlink)
@@ -950,60 +981,66 @@ struct file *do_file_open(char *path, int flags, int mode)
        struct nameidata nd_r = {0}, *nd = &nd_r;
        int error;
 
-       /* this isn't quite right, due to the nature of O_CREAT */
-       if (flags & O_CREAT)
-               nd->intent = LOOKUP_CREATE;
-       else
-               nd->intent = LOOKUP_OPEN;
+       /* The file might exist, lets try to just open it right away */
+       nd->intent = LOOKUP_OPEN;
+       error = path_lookup(path, LOOKUP_FOLLOW, nd);
+       if (!error) {
+               /* Still need to make sure we didn't want to O_EXCL create */
+               if ((flags & O_CREAT) && (flags & O_EXCL)) {
+                       set_errno(EEXIST);
+                       goto out_path_only;
+               }
+               file_d = nd->dentry;
+               kref_get(&file_d->d_kref, 1);
+               goto open_the_file;
+       }
+       /* So it didn't already exist, release the path from the previous lookup,
+        * and then we try to create it. */
+       path_release(nd);       
        /* get the parent, following links.  this means you get the parent of the
         * final link (which may not be in 'path' in the first place. */
+       nd->intent = LOOKUP_CREATE;
        error = path_lookup(path, LOOKUP_PARENT | LOOKUP_FOLLOW, nd);
        if (error) {
-               path_release(nd);
                set_errno(-error);
-               return 0;
+               goto out_path_only;
        }
-       /* see if the target is there, handle accordingly */
+       /* see if the target is there (shouldn't be), and handle accordingly */
        file_d = do_lookup(nd->dentry, nd->last.name); 
        if (!file_d) {
                if (!(flags & O_CREAT)) {
-                       path_release(nd);
                        set_errno(ENOENT);
-                       return 0;
+                       goto out_path_only;
                }
                /* Create the inode/file.  get a fresh dentry too: */
                file_d = get_dentry(nd->dentry->d_sb, nd->dentry, nd->last.name);
                parent_i = nd->dentry->d_inode;
                /* Note that the mode technically should only apply to future opens,
                 * but we apply it immediately. */
-               if (current)
-                       mode &= ~current->fs_env.umask;
-               if (create_file(parent_i, file_d, mode)) {
-                       kref_put(&file_d->d_kref);
-                       path_release(nd);
-                       return 0;
-               }
+               if (create_file(parent_i, file_d, mode))        /* sets errno */
+                       goto out_file_d;
                dcache_put(file_d);
-       } else {        /* something already exists (might be a dir) */
+       } else {        /* something already exists */
+               /* this can happen due to concurrent access, but needs to be thought
+                * through */
+               panic("File shouldn't be here!");
                if ((flags & O_CREAT) && (flags & O_EXCL)) {
                        /* wanted to create, not open, bail out */
-                       kref_put(&file_d->d_kref);
-                       path_release(nd);
                        set_errno(EEXIST);
-                       return 0;
+                       goto out_file_d;
                }
        }
+open_the_file:
        /* now open the file (freshly created or if it already existed).  At this
         * point, file_d is a refcnt'd dentry, regardless of which branch we took.*/
        if (flags & O_TRUNC)
                warn("File truncation not supported yet.");
-       file = dentry_open(file_d, flags);              /* sets errno */
-       if (!file) {
-               kref_put(&file_d->d_kref);
-               path_release(nd);
-               return 0;
-       }
+       file = dentry_open(file_d, flags);                              /* sets errno */
+       /* Note the fall through to the exit paths.  File is 0 by default and if
+        * dentry_open fails. */
+out_file_d:
        kref_put(&file_d->d_kref);
+out_path_only:
        path_release(nd);
        return file;
 }
@@ -1016,41 +1053,37 @@ int do_symlink(char *path, const char *symname, int mode)
        struct inode *parent_i;
        struct nameidata nd_r = {0}, *nd = &nd_r;
        int error;
+       int retval = -1;
 
        nd->intent = LOOKUP_CREATE;
        /* get the parent, but don't follow links */
        error = path_lookup(path, LOOKUP_PARENT, nd);
        if (error) {
                set_errno(-error);
-               path_release(nd);
-               return -1;
+               goto out_path_only;
        }
        /* see if the target is already there, handle accordingly */
        sym_d = do_lookup(nd->dentry, nd->last.name); 
        if (sym_d) {
                set_errno(EEXIST);
-               kref_put(&sym_d->d_kref);
-               path_release(nd);
-               return -1;
+               goto out_sym_d;
        }
        /* Doesn't already exist, let's try to make it: */
        sym_d = get_dentry(nd->dentry->d_sb, nd->dentry, nd->last.name);
        if (!sym_d) {
                set_errno(ENOMEM);
-               path_release(nd);
-               return -1;
+               goto out_path_only;
        }
        parent_i = nd->dentry->d_inode;
-       /* TODO: mode should be & ~umask. */
-       if (create_symlink(parent_i, sym_d, symname, mode)) {
-               kref_put(&sym_d->d_kref);
-               path_release(nd);
-               return -1;
-       }
+       if (create_symlink(parent_i, sym_d, symname, mode))
+               goto out_sym_d;
        dcache_put(sym_d);
+       retval = 0;                             /* Note the fall through to the exit paths */
+out_sym_d:
        kref_put(&sym_d->d_kref);
+out_path_only:
        path_release(nd);
-       return 0;
+       return retval;
 }
 
 /* Makes a hard link for the file behind old_path to new_path */
@@ -1088,7 +1121,7 @@ int do_link(char *old_path, char *new_path)
        if (!old_d)                                     /* errno set by lookup_dentry */
                goto out_link_d;
        /* For now, can only link to files */
-       if (old_d->d_inode->i_type != FS_I_FILE) {
+       if (!S_ISREG(old_d->d_inode->i_mode)) {
                set_errno(EPERM);
                goto out_both_ds;
        }
@@ -1109,6 +1142,7 @@ int do_link(char *old_path, char *new_path)
        kref_get(&inode->i_kref, 1);
        link_d->d_inode = inode;
        inode->i_nlink++;
+       parent_dir->i_nlink++;
        TAILQ_INSERT_TAIL(&inode->i_dentry, link_d, d_alias);   /* weak ref */
        dcache_put(link_d);
        retval = 0;                             /* Note the fall through to the exit paths */
@@ -1121,6 +1155,8 @@ out_path_only:
        return retval;
 }
 
+/* Unlinks path from the directory tree.  Read the Documentation for more info.
+ */
 int do_unlink(char *path)
 {
        struct dentry *dentry;
@@ -1143,7 +1179,7 @@ int do_unlink(char *path)
                goto out_path_only;
        }
        /* Make sure the target is not a directory */
-       if (dentry->d_inode->i_type == FS_I_DIR) {
+       if (S_ISDIR(dentry->d_inode->i_mode)) {
                set_errno(EISDIR);
                goto out_dentry;
        }
@@ -1155,7 +1191,7 @@ int do_unlink(char *path)
        }
        kref_put(&dentry->d_parent->d_kref);
        dentry->d_parent = 0;           /* so we don't double-decref it later */
-       dentry->d_inode->i_nlink--;     /* TODO: race here */
+       dentry->d_inode->i_nlink--;     /* TODO: race here, esp with a decref */
        /* At this point, the dentry is unlinked from the FS, and the inode has one
         * less link.  When the in-memory objects (dentry, inode) are going to be
         * released (after all open files are closed, and maybe after entries are
@@ -1169,10 +1205,10 @@ out_path_only:
        return retval;
 }
 
-/* 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)
+/* Checks to see if path can be accessed via mode.  Need to actually send the
+ * mode along somehow, so this doesn't do much now.  This is an example of
+ * decent error propagation from the lower levels via int retvals. */
+int do_access(char *path, int mode)
 {
        struct nameidata nd_r = {0}, *nd = &nd_r;
        int retval = 0;
@@ -1182,6 +1218,120 @@ int do_file_access(char *path, int mode)
        return retval;
 }
 
+int do_chmod(char *path, int mode)
+{
+       struct nameidata nd_r = {0}, *nd = &nd_r;
+       int retval = 0;
+       retval = path_lookup(path, 0, nd);
+       if (!retval) {
+               #if 0
+               /* TODO: when we have notions of uid, check for the proc's uid */
+               if (nd->dentry->d_inode->i_uid != UID_OF_ME)
+                       retval = -EPERM;
+               else
+               #endif
+                       nd->dentry->d_inode->i_mode |= mode & S_PMASK;
+       }
+       path_release(nd);       
+       return retval;
+}
+
+/* Make a directory at path with mode.  Returns -1 and sets errno on errors */
+int do_mkdir(char *path, int mode)
+{
+       struct dentry *dentry;
+       struct inode *parent_i;
+       struct nameidata nd_r = {0}, *nd = &nd_r;
+       int error;
+       int retval = -1;
+
+       nd->intent = LOOKUP_CREATE;
+       /* get the parent, but don't follow links */
+       error = path_lookup(path, LOOKUP_PARENT, nd);
+       if (error) {
+               set_errno(-error);
+               goto out_path_only;
+       }
+       /* see if the target is already there, handle accordingly */
+       dentry = do_lookup(nd->dentry, nd->last.name); 
+       if (dentry) {
+               set_errno(EEXIST);
+               goto out_dentry;
+       }
+       /* Doesn't already exist, let's try to make it: */
+       dentry = get_dentry(nd->dentry->d_sb, nd->dentry, nd->last.name);
+       if (!dentry) {
+               set_errno(ENOMEM);
+               goto out_path_only;
+       }
+       parent_i = nd->dentry->d_inode;
+       if (create_dir(parent_i, dentry, mode))
+               goto out_dentry;
+       dcache_put(dentry);
+       retval = 0;                             /* Note the fall through to the exit paths */
+out_dentry:
+       kref_put(&dentry->d_kref);
+out_path_only:
+       path_release(nd);
+       return retval;
+}
+
+int do_rmdir(char *path)
+{
+       struct dentry *dentry;
+       struct inode *parent_i;
+       struct nameidata nd_r = {0}, *nd = &nd_r;
+       int error;
+       int retval = -1;
+
+       /* get the parent, following links (probably want this), and we must get a
+        * directory.  Note, current versions of path_lookup can't handle both
+        * PARENT and DIRECTORY, at least, it doesn't check that *path is a
+        * directory. */
+       error = path_lookup(path, LOOKUP_PARENT | LOOKUP_FOLLOW | LOOKUP_DIRECTORY,
+                           nd);
+       if (error) {
+               set_errno(-error);
+               goto out_path_only;
+       }
+       /* make sure the target is already there, handle accordingly */
+       dentry = do_lookup(nd->dentry, nd->last.name); 
+       if (!dentry) {
+               set_errno(ENOENT);
+               goto out_path_only;
+       }
+       if (!S_ISDIR(dentry->d_inode->i_mode)) {
+               set_errno(ENOTDIR);
+               goto out_dentry;
+       }
+       /* TODO: make sure we aren't a mount or processes root (EBUSY) */
+       /* make sure we are empty.  TODO: Race with this, and anything touching
+        * i_nlink! */
+       if (dentry->d_inode->i_nlink != 1) {
+               set_errno(ENOTEMPTY);
+               goto out_dentry;
+       }
+       /* now for the removal */
+       parent_i = nd->dentry->d_inode;
+       error = parent_i->i_op->rmdir(parent_i, dentry);
+       if (error < 0) {
+               set_errno(-error);
+               goto out_dentry;
+       }
+       /* Decref ourselves, so inode_release() knows we are done */
+       dentry->d_inode->i_nlink--;
+       TAILQ_REMOVE(&nd->dentry->d_subdirs, dentry, d_subdirs_link);
+       parent_i->i_nlink--;            /* TODO: race on this, esp since its a decref */
+       /* we still have d_parent and a kref on our parent, which will go away when
+        * the in-memory dentry object goes away. */
+       retval = 0;                             /* Note the fall through to the exit paths */
+out_dentry:
+       kref_put(&dentry->d_kref);
+out_path_only:
+       path_release(nd);
+       return retval;
+}
+
 /* Opens and returns the file specified by dentry */
 struct file *dentry_open(struct dentry *dentry, int flags)
 {
@@ -1417,10 +1567,9 @@ struct file *put_file_from_fd(struct files_struct *open_files, int file_desc)
                        assert(file_desc < open_files->max_files);
                        file = open_files->fd[file_desc];
                        open_files->fd[file_desc] = 0;
+                       assert(file);
+                       kref_put(&file->f_kref);
                        CLR_BITMASK_BIT(open_files->open_fds->fds_bits, file_desc);
-                       /* the if case is due to files (stdin) without a *file yet */
-                       if (file)
-                               kref_put(&file->f_kref);
                }
        }
        spin_unlock(&open_files->lock);
@@ -1428,12 +1577,14 @@ struct file *put_file_from_fd(struct files_struct *open_files, int file_desc)
 }
 
 /* Inserts the file in the files_struct, returning the corresponding new file
- * descriptor, or an error code.  We currently grab the first open FD. */
-int insert_file(struct files_struct *open_files, struct file *file)
+ * descriptor, or an error code.  We start looking for open fds from low_fd. */
+int insert_file(struct files_struct *open_files, struct file *file, int low_fd)
 {
        int slot = -1;
+       if ((low_fd < 0) || (low_fd > NR_FILE_DESC_MAX))
+               return -EINVAL;
        spin_lock(&open_files->lock);
-       for (int i = 0; i < open_files->max_fdset; i++) {
+       for (int i = low_fd; i < open_files->max_fdset; i++) {
                if (GET_BITMASK_BIT(open_files->open_fds->fds_bits, i))
                        continue;
                slot = i;
@@ -1463,12 +1614,12 @@ void close_all_files(struct files_struct *open_files, bool cloexec)
                         * have a valid fdset higher than files */
                        assert(i < open_files->max_files);
                        file = open_files->fd[i];
-                       if (cloexec && !(file->f_flags | O_CLOEXEC))
+                       if (cloexec && !(file->f_flags & O_CLOEXEC))
                                continue;
+                       /* Actually close the file */
                        open_files->fd[i] = 0;
-                       /* the if case is due to files (stdin) without a *file yet */
-                       if (file)
-                               kref_put(&file->f_kref);
+                       assert(file);
+                       kref_put(&file->f_kref);
                        CLR_BITMASK_BIT(open_files->open_fds->fds_bits, i);
                }
        }
@@ -1487,12 +1638,13 @@ void clone_files(struct files_struct *src, struct files_struct *dst)
                         * have a valid fdset higher than files */
                        assert(i < src->max_files);
                        file = src->fd[i];
-                       SET_BITMASK_BIT(dst->open_fds->fds_bits, i);
                        assert(i < dst->max_files && dst->fd[i] == 0);
+                       SET_BITMASK_BIT(dst->open_fds->fds_bits, i);
                        dst->fd[i] = file;
-                       /* the if case is due to files (stdin) without a *file yet */
-                       if (file)
-                               kref_get(&file->f_kref, 1);
+                       assert(file);
+                       kref_get(&file->f_kref, 1);
+                       if (i >= dst->next_fd)
+                               dst->next_fd = i + 1;
                }
        }
        spin_unlock(&dst->lock);
@@ -1568,12 +1720,13 @@ static void print_dir(struct dentry *dentry, char *buf, int depth)
        int retval;
        int child_num = 0;
 
-       if (!dentry->d_inode->i_type & FS_I_DIR) {
+       if (!S_ISDIR(dentry->d_inode->i_mode)) {
                warn("Thought this was only directories!!");
                return;
        }
        /* Print this dentry */
-       printk("%s%s/\n", buf, dentry->d_name.name);
+       printk("%s%s/ nlink: %d\n", buf, dentry->d_name.name,
+              dentry->d_inode->i_nlink);
        if (depth >= 32)
                return;
        /* Set buffer for our kids */
@@ -1591,18 +1744,22 @@ static void print_dir(struct dentry *dentry, char *buf, int depth)
                        if (!child_d)
                                panic("Inconsistent FS, dirent doesn't have a dentry!");
                        /* Recurse for directories, or just print the name for others */
-                       switch (child_d->d_inode->i_type) {
-                               case (FS_I_DIR):
+                       switch (child_d->d_inode->i_mode & __S_IFMT) {
+                               case (__S_IFDIR):
                                        print_dir(child_d, buf, depth + 1);
                                        break;
-                               case (FS_I_FILE):
+                               case (__S_IFREG):
                                        printk("%s%s size(B): %d nlink: %d\n", buf, next.d_name,
                                               child_d->d_inode->i_size, child_d->d_inode->i_nlink);
                                        break;
-                               case (FS_I_SYMLINK):
+                               case (__S_IFLNK):
                                        printk("%s%s -> %s\n", buf, next.d_name,
                                               child_d->d_inode->i_op->readlink(child_d));
                                        break;
+                               case (__S_IFCHR):
+                                       printk("%s%s (char device) nlink: %d\n", buf, next.d_name,
+                                              child_d->d_inode->i_nlink);
+                                       break;
                                default:
                                        warn("Look around you!  Unknown filetype!");
                        }