fs/9p/vfs_dir.c

   1 /*
   2  * linux/fs/9p/vfs_dir.c
   3  *
   4  * This file contains vfs directory ops for the 9P2000 protocol.
   5  *
   6  *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
   7  *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to:
  21  *  Free Software Foundation
  22  *  51 Franklin Street, Fifth Floor
  23  *  Boston, MA  02111-1301  USA
  24  *
  25  */
  26
  27 #include <linux/module.h>
  28 #include <linux/errno.h>
  29 #include <linux/fs.h>
  30 #include <linux/file.h>
  31 #include <linux/stat.h>
  32 #include <linux/string.h>
  33 #include <linux/smp_lock.h>
  34 #include <linux/inet.h>
  35 #include <linux/idr.h>
  36
  37 #include "debug.h"
  38 #include "v9fs.h"
  39 #include "9p.h"
  40 #include "v9fs_vfs.h"
  41 #include "conv.h"
  42 #include "fid.h"
  43
  44 /**
  45  * dt_type - return file type
  46  * @mistat: mistat structure
  47  *
  48  */
  49
  50 static inline int dt_type(struct v9fs_stat *mistat)
  51 {
  52         unsigned long perm = mistat->mode;
  53         int rettype = DT_REG;
  54
  55         if (perm & V9FS_DMDIR)
  56                 rettype = DT_DIR;
  57         if (perm & V9FS_DMSYMLINK)
  58                 rettype = DT_LNK;
  59
  60         return rettype;
  61 }
  62
  63 /**
  64  * v9fs_dir_readdir - read a directory
  65  * @filep: opened file structure
  66  * @dirent: directory structure ???
  67  * @filldir: function to populate directory structure ???
  68  *
  69  */
  70
  71 static int v9fs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir)
  72 {
  73         struct v9fs_fcall *fcall = NULL;
  74         struct inode *inode = filp->f_dentry->d_inode;
  75         struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
  76         struct v9fs_fid *file = filp->private_data;
  77         unsigned int i, n;
  78         int fid = -1;
  79         int ret = 0;
  80         struct v9fs_stat *mi = NULL;
  81         int over = 0;
  82
  83         dprintk(DEBUG_VFS, "name %s\n", filp->f_dentry->d_name.name);
  84
  85         fid = file->fid;
  86
  87         mi = kmalloc(v9ses->maxdata, GFP_KERNEL);
  88         if (!mi)
  89                 return -ENOMEM;
  90
  91         if (file->rdir_fcall && (filp->f_pos != file->rdir_pos)) {
  92                 kfree(file->rdir_fcall);
  93                 file->rdir_fcall = NULL;
  94         }
  95
  96         if (file->rdir_fcall) {
  97                 n = file->rdir_fcall->params.rread.count;
  98                 i = file->rdir_fpos;
  99                 while (i < n) {
 100                         int s = v9fs_deserialize_stat(v9ses,
 101                                   file->rdir_fcall->params.rread.data + i,
 102                                   n - i, mi, v9ses->maxdata);
 103
 104                         if (s == 0) {
 105                                 dprintk(DEBUG_ERROR,
 106                                         "error while deserializing mistat\n");
 107                                 ret = -EIO;
 108                                 goto FreeStructs;
 109                         }
 110
 111                         over = filldir(dirent, mi->name, strlen(mi->name),
 112                                     filp->f_pos, v9fs_qid2ino(&mi->qid),
 113                                     dt_type(mi));
 114
 115                         if (over) {
 116                                 file->rdir_fpos = i;
 117                                 file->rdir_pos = filp->f_pos;
 118                                 break;
 119                         }
 120
 121                         i += s;
 122                         filp->f_pos += s;
 123                 }
 124
 125                 if (!over) {
 126                         kfree(file->rdir_fcall);
 127                         file->rdir_fcall = NULL;
 128                 }
 129         }
 130
 131         while (!over) {
 132                 ret = v9fs_t_read(v9ses, fid, filp->f_pos,
 133                                             v9ses->maxdata-V9FS_IOHDRSZ, &fcall);
 134                 if (ret < 0) {
 135                         dprintk(DEBUG_ERROR, "error while reading: %d: %p\n",
 136                                 ret, fcall);
 137                         goto FreeStructs;
 138                 } else if (ret == 0)
 139                         break;
 140
 141                 n = ret;
 142                 i = 0;
 143                 while (i < n) {
 144                         int s = v9fs_deserialize_stat(v9ses,
 145                                   fcall->params.rread.data + i, n - i, mi,
 146                                   v9ses->maxdata);
 147
 148                         if (s == 0) {
 149                                 dprintk(DEBUG_ERROR,
 150                                         "error while deserializing mistat\n");
 151                                 return -EIO;
 152                         }
 153
 154                         over = filldir(dirent, mi->name, strlen(mi->name),
 155                                     filp->f_pos, v9fs_qid2ino(&mi->qid),
 156                                     dt_type(mi));
 157
 158                         if (over) {
 159                                 file->rdir_fcall = fcall;
 160                                 file->rdir_fpos = i;
 161                                 file->rdir_pos = filp->f_pos;
 162                                 fcall = NULL;
 163                                 break;
 164                         }
 165
 166                         i += s;
 167                         filp->f_pos += s;
 168                 }
 169
 170                 kfree(fcall);
 171         }
 172
 173       FreeStructs:
 174         kfree(fcall);
 175         kfree(mi);
 176         return ret;
 177 }
 178
 179 /**
 180  * v9fs_dir_release - close a directory
 181  * @inode: inode of the directory
 182  * @filp: file pointer to a directory
 183  *
 184  */
 185
 186 int v9fs_dir_release(struct inode *inode, struct file *filp)
 187 {
 188         struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
 189         struct v9fs_fid *fid = filp->private_data;
 190         int fidnum = -1;
 191
 192         dprintk(DEBUG_VFS, "inode: %p filp: %p fid: %d\n", inode, filp,
 193                 fid->fid);
 194         fidnum = fid->fid;
 195
 196         filemap_fdatawrite(inode->i_mapping);
 197         filemap_fdatawait(inode->i_mapping);
 198
 199         if (fidnum >= 0) {
 200                 dprintk(DEBUG_VFS, "fidopen: %d v9f->fid: %d\n", fid->fidopen,
 201                         fid->fid);
 202
 203                 if (v9fs_t_clunk(v9ses, fidnum, NULL))
 204                         dprintk(DEBUG_ERROR, "clunk failed\n");
 205
 206                 v9fs_put_idpool(fid->fid, &v9ses->fidpool);
 207
 208                 kfree(fid->rdir_fcall);
 209                 kfree(fid);
 210
 211                 filp->private_data = NULL;
 212         }
 213
 214         d_drop(filp->f_dentry);
 215         return 0;
 216 }
 217
 218 struct file_operations v9fs_dir_operations = {
 219         .read = generic_read_dir,
 220         .readdir = v9fs_dir_readdir,
 221         .open = v9fs_file_open,
 222         .release = v9fs_dir_release,
 223 };