git.oblomov.eu Git - linux-2.6/blob - 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 "conv.h"
  41 #include "v9fs_vfs.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, s;
  78         int fid = -1;
  79         int ret = 0;
  80         struct v9fs_stat stat;
  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         if (file->rdir_fcall && (filp->f_pos != file->rdir_pos)) {
  88                 kfree(file->rdir_fcall);
  89                 file->rdir_fcall = NULL;
  90         }
  91
  92         if (file->rdir_fcall) {
  93                 n = file->rdir_fcall->params.rread.count;
  94                 i = file->rdir_fpos;
  95                 while (i < n) {
  96                         s = v9fs_deserialize_stat(
  97                                 file->rdir_fcall->params.rread.data + i,
  98                                 n - i, &stat, v9ses->extended);
  99
 100                         if (s == 0) {
 101                                 dprintk(DEBUG_ERROR,
 102                                         "error while deserializing stat\n");
 103                                 ret = -EIO;
 104                                 goto FreeStructs;
 105                         }
 106
 107                         over = filldir(dirent, stat.name.str, stat.name.len,
 108                                     filp->f_pos, v9fs_qid2ino(&stat.qid),
 109                                     dt_type(&stat));
 110
 111                         if (over) {
 112                                 file->rdir_fpos = i;
 113                                 file->rdir_pos = filp->f_pos;
 114                                 break;
 115                         }
 116
 117                         i += s;
 118                         filp->f_pos += s;
 119                 }
 120
 121                 if (!over) {
 122                         kfree(file->rdir_fcall);
 123                         file->rdir_fcall = NULL;
 124                 }
 125         }
 126
 127         while (!over) {
 128                 ret = v9fs_t_read(v9ses, fid, filp->f_pos,
 129                         v9ses->maxdata-V9FS_IOHDRSZ, &fcall);
 130                 if (ret < 0) {
 131                         dprintk(DEBUG_ERROR, "error while reading: %d: %p\n",
 132                                 ret, fcall);
 133                         goto FreeStructs;
 134                 } else if (ret == 0)
 135                         break;
 136
 137                 n = ret;
 138                 i = 0;
 139                 while (i < n) {
 140                         s = v9fs_deserialize_stat(fcall->params.rread.data + i,
 141                                 n - i, &stat, v9ses->extended);
 142
 143                         if (s == 0) {
 144                                 dprintk(DEBUG_ERROR,
 145                                         "error while deserializing stat\n");
 146                                 return -EIO;
 147                         }
 148
 149                         over = filldir(dirent, stat.name.str, stat.name.len,
 150                                     filp->f_pos, v9fs_qid2ino(&stat.qid),
 151                                     dt_type(&stat));
 152
 153                         if (over) {
 154                                 file->rdir_fcall = fcall;
 155                                 file->rdir_fpos = i;
 156                                 file->rdir_pos = filp->f_pos;
 157                                 fcall = NULL;
 158                                 break;
 159                         }
 160
 161                         i += s;
 162                         filp->f_pos += s;
 163                 }
 164
 165                 kfree(fcall);
 166         }
 167
 168       FreeStructs:
 169         kfree(fcall);
 170         return ret;
 171 }
 172
 173 /**
 174  * v9fs_dir_release - close a directory
 175  * @inode: inode of the directory
 176  * @filp: file pointer to a directory
 177  *
 178  */
 179
 180 int v9fs_dir_release(struct inode *inode, struct file *filp)
 181 {
 182         struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
 183         struct v9fs_fid *fid = filp->private_data;
 184         int fidnum = -1;
 185
 186         dprintk(DEBUG_VFS, "inode: %p filp: %p fid: %d\n", inode, filp,
 187                 fid->fid);
 188         fidnum = fid->fid;
 189
 190         filemap_write_and_wait(inode->i_mapping);
 191
 192         if (fidnum >= 0) {
 193                 dprintk(DEBUG_VFS, "fidopen: %d v9f->fid: %d\n", fid->fidopen,
 194                         fid->fid);
 195
 196                 if (v9fs_t_clunk(v9ses, fidnum))
 197                         dprintk(DEBUG_ERROR, "clunk failed\n");
 198
 199                 kfree(fid->rdir_fcall);
 200                 kfree(fid);
 201
 202                 filp->private_data = NULL;
 203         }
 204
 205         return 0;
 206 }
 207
 208 struct file_operations v9fs_dir_operations = {
 209         .read = generic_read_dir,
 210         .readdir = v9fs_dir_readdir,
 211         .open = v9fs_file_open,
 212         .release = v9fs_dir_release,
 213 };