]>
Commit | Line | Data |
---|---|---|
e69e7fe5 EVH |
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 | fid->fidopen--; | |
201 | dprintk(DEBUG_VFS, "fidopen: %d v9f->fid: %d\n", fid->fidopen, | |
202 | fid->fid); | |
203 | ||
204 | if (fid->fidopen == 0) { | |
205 | if (v9fs_t_clunk(v9ses, fidnum, NULL)) | |
206 | dprintk(DEBUG_ERROR, "clunk failed\n"); | |
207 | ||
208 | v9fs_put_idpool(fid->fid, &v9ses->fidpool); | |
209 | } | |
210 | ||
211 | kfree(fid->rdir_fcall); | |
212 | ||
213 | filp->private_data = NULL; | |
214 | v9fs_fid_destroy(fid); | |
215 | } | |
216 | ||
217 | d_drop(filp->f_dentry); | |
218 | return 0; | |
219 | } | |
220 | ||
221 | struct file_operations v9fs_dir_operations = { | |
222 | .read = generic_read_dir, | |
223 | .readdir = v9fs_dir_readdir, | |
224 | .open = v9fs_file_open, | |
225 | .release = v9fs_dir_release, | |
226 | }; |