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 <net/9p/9p.h> 36 #include <net/9p/client.h> 37 38 #include "v9fs.h" 39 #include "v9fs_vfs.h" 40 #include "fid.h" 41 42 /** 43 * struct p9_rdir - readdir accounting 44 * @mutex: mutex protecting readdir 45 * @head: start offset of current dirread buffer 46 * @tail: end offset of current dirread buffer 47 * @buf: dirread buffer 48 * 49 * private structure for keeping track of readdir 50 * allocated on demand 51 */ 52 53 struct p9_rdir { 54 struct mutex mutex; 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 /** 80 * v9fs_dir_readdir - read a directory 81 * @filp: opened file structure 82 * @dirent: directory structure ??? 83 * @filldir: function to populate directory structure ??? 84 * 85 */ 86 87 static int v9fs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir) 88 { 89 int over; 90 struct p9_wstat st; 91 int err = 0; 92 struct p9_fid *fid; 93 int buflen; 94 int reclen = 0; 95 struct p9_rdir *rdir; 96 97 P9_DPRINTK(P9_DEBUG_VFS, "name %s\n", filp->f_path.dentry->d_name.name); 98 fid = filp->private_data; 99 100 buflen = fid->clnt->msize - P9_IOHDRSZ; 101 102 /* allocate rdir on demand */ 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 rdir = (struct p9_rdir *) fid->rdir; 122 123 err = mutex_lock_interruptible(&rdir->mutex); 124 while (err == 0) { 125 if (rdir->tail == rdir->head) { 126 err = v9fs_file_readn(filp, rdir->buf, NULL, 127 buflen, filp->f_pos); 128 if (err <= 0) 129 goto unlock_and_exit; 130 131 rdir->head = 0; 132 rdir->tail = err; 133 } 134 135 while (rdir->head < rdir->tail) { 136 err = p9stat_read(rdir->buf + rdir->head, 137 buflen - rdir->head, &st, 138 fid->clnt->dotu); 139 if (err) { 140 P9_DPRINTK(P9_DEBUG_VFS, "returned %d\n", err); 141 err = -EIO; 142 p9stat_free(&st); 143 goto unlock_and_exit; 144 } 145 reclen = st.size+2; 146 147 over = filldir(dirent, st.name, strlen(st.name), 148 filp->f_pos, v9fs_qid2ino(&st.qid), dt_type(&st)); 149 150 p9stat_free(&st); 151 152 if (over) { 153 err = 0; 154 goto unlock_and_exit; 155 } 156 rdir->head += reclen; 157 filp->f_pos += reclen; 158 } 159 } 160 161 unlock_and_exit: 162 mutex_unlock(&rdir->mutex); 163 exit: 164 return err; 165 } 166 167 168 /** 169 * v9fs_dir_release - close a directory 170 * @inode: inode of the directory 171 * @filp: file pointer to a directory 172 * 173 */ 174 175 int v9fs_dir_release(struct inode *inode, struct file *filp) 176 { 177 struct p9_fid *fid; 178 179 fid = filp->private_data; 180 P9_DPRINTK(P9_DEBUG_VFS, 181 "inode: %p filp: %p fid: %d\n", inode, filp, fid->fid); 182 filemap_write_and_wait(inode->i_mapping); 183 p9_client_clunk(fid); 184 return 0; 185 } 186 187 const struct file_operations v9fs_dir_operations = { 188 .read = generic_read_dir, 189 .llseek = generic_file_llseek, 190 .readdir = v9fs_dir_readdir, 191 .open = v9fs_file_open, 192 .release = v9fs_dir_release, 193 }; 194