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 version 2 11 * as published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to: 20 * Free Software Foundation 21 * 51 Franklin Street, Fifth Floor 22 * Boston, MA 02111-1301 USA 23 * 24 */ 25 26 #include <linux/module.h> 27 #include <linux/errno.h> 28 #include <linux/fs.h> 29 #include <linux/file.h> 30 #include <linux/stat.h> 31 #include <linux/string.h> 32 #include <linux/sched.h> 33 #include <linux/inet.h> 34 #include <linux/idr.h> 35 #include <linux/slab.h> 36 #include <net/9p/9p.h> 37 #include <net/9p/client.h> 38 39 #include "v9fs.h" 40 #include "v9fs_vfs.h" 41 #include "fid.h" 42 43 /** 44 * struct p9_rdir - readdir accounting 45 * @mutex: mutex protecting readdir 46 * @head: start offset of current dirread buffer 47 * @tail: end offset of current dirread buffer 48 * @buf: dirread buffer 49 * 50 * private structure for keeping track of readdir 51 * allocated on demand 52 */ 53 54 struct p9_rdir { 55 struct mutex mutex; 56 int head; 57 int tail; 58 uint8_t *buf; 59 }; 60 61 /** 62 * dt_type - return file type 63 * @mistat: mistat structure 64 * 65 */ 66 67 static inline int dt_type(struct p9_wstat *mistat) 68 { 69 unsigned long perm = mistat->mode; 70 int rettype = DT_REG; 71 72 if (perm & P9_DMDIR) 73 rettype = DT_DIR; 74 if (perm & P9_DMSYMLINK) 75 rettype = DT_LNK; 76 77 return rettype; 78 } 79 80 static void p9stat_init(struct p9_wstat *stbuf) 81 { 82 stbuf->name = NULL; 83 stbuf->uid = NULL; 84 stbuf->gid = NULL; 85 stbuf->muid = NULL; 86 stbuf->extension = NULL; 87 } 88 89 /** 90 * v9fs_alloc_rdir_buf - Allocate buffer used for read and readdir 91 * @filp: opened file structure 92 * @buflen: Length in bytes of buffer to allocate 93 * 94 */ 95 96 static int v9fs_alloc_rdir_buf(struct file *filp, int buflen) 97 { 98 struct p9_rdir *rdir; 99 struct p9_fid *fid; 100 int err = 0; 101 102 fid = filp->private_data; 103 if (!fid->rdir) { 104 rdir = kmalloc(sizeof(struct p9_rdir) + buflen, GFP_KERNEL); 105 106 if (rdir == NULL) { 107 err = -ENOMEM; 108 goto exit; 109 } 110 spin_lock(&filp->f_dentry->d_lock); 111 if (!fid->rdir) { 112 rdir->buf = (uint8_t *)rdir + sizeof(struct p9_rdir); 113 mutex_init(&rdir->mutex); 114 rdir->head = rdir->tail = 0; 115 fid->rdir = (void *) rdir; 116 rdir = NULL; 117 } 118 spin_unlock(&filp->f_dentry->d_lock); 119 kfree(rdir); 120 } 121 exit: 122 return err; 123 } 124 125 /** 126 * v9fs_dir_readdir - read a directory 127 * @filp: opened file structure 128 * @dirent: directory structure ??? 129 * @filldir: function to populate directory structure ??? 130 * 131 */ 132 133 static int v9fs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir) 134 { 135 int over; 136 struct p9_wstat st; 137 int err = 0; 138 struct p9_fid *fid; 139 int buflen; 140 int reclen = 0; 141 struct p9_rdir *rdir; 142 143 p9_debug(P9_DEBUG_VFS, "name %s\n", filp->f_path.dentry->d_name.name); 144 fid = filp->private_data; 145 146 buflen = fid->clnt->msize - P9_IOHDRSZ; 147 148 err = v9fs_alloc_rdir_buf(filp, buflen); 149 if (err) 150 goto exit; 151 rdir = (struct p9_rdir *) fid->rdir; 152 153 err = mutex_lock_interruptible(&rdir->mutex); 154 if (err) 155 return err; 156 while (err == 0) { 157 if (rdir->tail == rdir->head) { 158 err = v9fs_file_readn(filp, rdir->buf, NULL, 159 buflen, filp->f_pos); 160 if (err <= 0) 161 goto unlock_and_exit; 162 163 rdir->head = 0; 164 rdir->tail = err; 165 } 166 while (rdir->head < rdir->tail) { 167 p9stat_init(&st); 168 err = p9stat_read(fid->clnt, rdir->buf + rdir->head, 169 rdir->tail - rdir->head, &st); 170 if (err) { 171 p9_debug(P9_DEBUG_VFS, "returned %d\n", err); 172 err = -EIO; 173 p9stat_free(&st); 174 goto unlock_and_exit; 175 } 176 reclen = st.size+2; 177 178 over = filldir(dirent, st.name, strlen(st.name), 179 filp->f_pos, v9fs_qid2ino(&st.qid), dt_type(&st)); 180 181 p9stat_free(&st); 182 183 if (over) { 184 err = 0; 185 goto unlock_and_exit; 186 } 187 rdir->head += reclen; 188 filp->f_pos += reclen; 189 } 190 } 191 192 unlock_and_exit: 193 mutex_unlock(&rdir->mutex); 194 exit: 195 return err; 196 } 197 198 /** 199 * v9fs_dir_readdir_dotl - read a directory 200 * @filp: opened file structure 201 * @dirent: buffer to fill dirent structures 202 * @filldir: function to populate dirent structures 203 * 204 */ 205 static int v9fs_dir_readdir_dotl(struct file *filp, void *dirent, 206 filldir_t filldir) 207 { 208 int over; 209 int err = 0; 210 struct p9_fid *fid; 211 int buflen; 212 struct p9_rdir *rdir; 213 struct p9_dirent curdirent; 214 u64 oldoffset = 0; 215 216 p9_debug(P9_DEBUG_VFS, "name %s\n", filp->f_path.dentry->d_name.name); 217 fid = filp->private_data; 218 219 buflen = fid->clnt->msize - P9_READDIRHDRSZ; 220 221 err = v9fs_alloc_rdir_buf(filp, buflen); 222 if (err) 223 goto exit; 224 rdir = (struct p9_rdir *) fid->rdir; 225 226 err = mutex_lock_interruptible(&rdir->mutex); 227 if (err) 228 return err; 229 230 while (err == 0) { 231 if (rdir->tail == rdir->head) { 232 err = p9_client_readdir(fid, rdir->buf, buflen, 233 filp->f_pos); 234 if (err <= 0) 235 goto unlock_and_exit; 236 237 rdir->head = 0; 238 rdir->tail = err; 239 } 240 241 while (rdir->head < rdir->tail) { 242 243 err = p9dirent_read(fid->clnt, rdir->buf + rdir->head, 244 rdir->tail - rdir->head, 245 &curdirent); 246 if (err < 0) { 247 p9_debug(P9_DEBUG_VFS, "returned %d\n", err); 248 err = -EIO; 249 goto unlock_and_exit; 250 } 251 252 /* d_off in dirent structure tracks the offset into 253 * the next dirent in the dir. However, filldir() 254 * expects offset into the current dirent. Hence 255 * while calling filldir send the offset from the 256 * previous dirent structure. 257 */ 258 over = filldir(dirent, curdirent.d_name, 259 strlen(curdirent.d_name), 260 oldoffset, v9fs_qid2ino(&curdirent.qid), 261 curdirent.d_type); 262 oldoffset = curdirent.d_off; 263 264 if (over) { 265 err = 0; 266 goto unlock_and_exit; 267 } 268 269 filp->f_pos = curdirent.d_off; 270 rdir->head += err; 271 } 272 } 273 274 unlock_and_exit: 275 mutex_unlock(&rdir->mutex); 276 exit: 277 return err; 278 } 279 280 281 /** 282 * v9fs_dir_release - close a directory 283 * @inode: inode of the directory 284 * @filp: file pointer to a directory 285 * 286 */ 287 288 int v9fs_dir_release(struct inode *inode, struct file *filp) 289 { 290 struct p9_fid *fid; 291 292 fid = filp->private_data; 293 p9_debug(P9_DEBUG_VFS, "inode: %p filp: %p fid: %d\n", 294 inode, filp, fid ? fid->fid : -1); 295 if (fid) 296 p9_client_clunk(fid); 297 return 0; 298 } 299 300 const struct file_operations v9fs_dir_operations = { 301 .read = generic_read_dir, 302 .llseek = generic_file_llseek, 303 .readdir = v9fs_dir_readdir, 304 .open = v9fs_file_open, 305 .release = v9fs_dir_release, 306 }; 307 308 const struct file_operations v9fs_dir_operations_dotl = { 309 .read = generic_read_dir, 310 .llseek = generic_file_llseek, 311 .readdir = v9fs_dir_readdir_dotl, 312 .open = v9fs_file_open, 313 .release = v9fs_dir_release, 314 .fsync = v9fs_file_fsync_dotl, 315 }; 316