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 int head; 56 int tail; 57 uint8_t buf[]; 58 }; 59 60 /** 61 * dt_type - return file type 62 * @mistat: mistat structure 63 * 64 */ 65 66 static inline int dt_type(struct p9_wstat *mistat) 67 { 68 unsigned long perm = mistat->mode; 69 int rettype = DT_REG; 70 71 if (perm & P9_DMDIR) 72 rettype = DT_DIR; 73 if (perm & P9_DMSYMLINK) 74 rettype = DT_LNK; 75 76 return rettype; 77 } 78 79 static void p9stat_init(struct p9_wstat *stbuf) 80 { 81 stbuf->name = NULL; 82 stbuf->uid = NULL; 83 stbuf->gid = NULL; 84 stbuf->muid = NULL; 85 stbuf->extension = NULL; 86 } 87 88 /** 89 * v9fs_alloc_rdir_buf - Allocate buffer used for read and readdir 90 * @filp: opened file structure 91 * @buflen: Length in bytes of buffer to allocate 92 * 93 */ 94 95 static struct p9_rdir *v9fs_alloc_rdir_buf(struct file *filp, int buflen) 96 { 97 struct p9_fid *fid = filp->private_data; 98 if (!fid->rdir) 99 fid->rdir = kzalloc(sizeof(struct p9_rdir) + buflen, GFP_KERNEL); 100 return fid->rdir; 101 } 102 103 /** 104 * v9fs_dir_readdir - read a directory 105 * @filp: opened file structure 106 * @dirent: directory structure ??? 107 * @filldir: function to populate directory structure ??? 108 * 109 */ 110 111 static int v9fs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir) 112 { 113 int over; 114 struct p9_wstat st; 115 int err = 0; 116 struct p9_fid *fid; 117 int buflen; 118 int reclen = 0; 119 struct p9_rdir *rdir; 120 121 p9_debug(P9_DEBUG_VFS, "name %s\n", filp->f_path.dentry->d_name.name); 122 fid = filp->private_data; 123 124 buflen = fid->clnt->msize - P9_IOHDRSZ; 125 126 rdir = v9fs_alloc_rdir_buf(filp, buflen); 127 if (!rdir) 128 return -ENOMEM; 129 130 while (1) { 131 if (rdir->tail == rdir->head) { 132 err = v9fs_file_readn(filp, rdir->buf, NULL, 133 buflen, filp->f_pos); 134 if (err <= 0) 135 return err; 136 137 rdir->head = 0; 138 rdir->tail = err; 139 } 140 while (rdir->head < rdir->tail) { 141 p9stat_init(&st); 142 err = p9stat_read(fid->clnt, rdir->buf + rdir->head, 143 rdir->tail - rdir->head, &st); 144 if (err) { 145 p9_debug(P9_DEBUG_VFS, "returned %d\n", err); 146 p9stat_free(&st); 147 return -EIO; 148 } 149 reclen = st.size+2; 150 151 over = filldir(dirent, st.name, strlen(st.name), 152 filp->f_pos, v9fs_qid2ino(&st.qid), dt_type(&st)); 153 154 p9stat_free(&st); 155 156 if (over) 157 return 0; 158 159 rdir->head += reclen; 160 filp->f_pos += reclen; 161 } 162 } 163 } 164 165 /** 166 * v9fs_dir_readdir_dotl - read a directory 167 * @filp: opened file structure 168 * @dirent: buffer to fill dirent structures 169 * @filldir: function to populate dirent structures 170 * 171 */ 172 static int v9fs_dir_readdir_dotl(struct file *filp, void *dirent, 173 filldir_t filldir) 174 { 175 int over; 176 int err = 0; 177 struct p9_fid *fid; 178 int buflen; 179 struct p9_rdir *rdir; 180 struct p9_dirent curdirent; 181 u64 oldoffset = 0; 182 183 p9_debug(P9_DEBUG_VFS, "name %s\n", filp->f_path.dentry->d_name.name); 184 fid = filp->private_data; 185 186 buflen = fid->clnt->msize - P9_READDIRHDRSZ; 187 188 rdir = v9fs_alloc_rdir_buf(filp, buflen); 189 if (!rdir) 190 return -ENOMEM; 191 192 while (1) { 193 if (rdir->tail == rdir->head) { 194 err = p9_client_readdir(fid, rdir->buf, buflen, 195 filp->f_pos); 196 if (err <= 0) 197 return err; 198 199 rdir->head = 0; 200 rdir->tail = err; 201 } 202 203 while (rdir->head < rdir->tail) { 204 205 err = p9dirent_read(fid->clnt, rdir->buf + rdir->head, 206 rdir->tail - rdir->head, 207 &curdirent); 208 if (err < 0) { 209 p9_debug(P9_DEBUG_VFS, "returned %d\n", err); 210 return -EIO; 211 } 212 213 /* d_off in dirent structure tracks the offset into 214 * the next dirent in the dir. However, filldir() 215 * expects offset into the current dirent. Hence 216 * while calling filldir send the offset from the 217 * previous dirent structure. 218 */ 219 over = filldir(dirent, curdirent.d_name, 220 strlen(curdirent.d_name), 221 oldoffset, v9fs_qid2ino(&curdirent.qid), 222 curdirent.d_type); 223 oldoffset = curdirent.d_off; 224 225 if (over) 226 return 0; 227 228 filp->f_pos = curdirent.d_off; 229 rdir->head += err; 230 } 231 } 232 } 233 234 235 /** 236 * v9fs_dir_release - close a directory 237 * @inode: inode of the directory 238 * @filp: file pointer to a directory 239 * 240 */ 241 242 int v9fs_dir_release(struct inode *inode, struct file *filp) 243 { 244 struct p9_fid *fid; 245 246 fid = filp->private_data; 247 p9_debug(P9_DEBUG_VFS, "inode: %p filp: %p fid: %d\n", 248 inode, filp, fid ? fid->fid : -1); 249 if (fid) 250 p9_client_clunk(fid); 251 return 0; 252 } 253 254 const struct file_operations v9fs_dir_operations = { 255 .read = generic_read_dir, 256 .llseek = generic_file_llseek, 257 .readdir = v9fs_dir_readdir, 258 .open = v9fs_file_open, 259 .release = v9fs_dir_release, 260 }; 261 262 const struct file_operations v9fs_dir_operations_dotl = { 263 .read = generic_read_dir, 264 .llseek = generic_file_llseek, 265 .readdir = v9fs_dir_readdir_dotl, 266 .open = v9fs_file_open, 267 .release = v9fs_dir_release, 268 .fsync = v9fs_file_fsync_dotl, 269 }; 270