diff options
Diffstat (limited to 'fs/9p/fid.c')
-rw-r--r-- | fs/9p/fid.c | 241 |
1 files changed, 241 insertions, 0 deletions
diff --git a/fs/9p/fid.c b/fs/9p/fid.c new file mode 100644 index 000000000000..821c9c4d76aa --- /dev/null +++ b/fs/9p/fid.c | |||
@@ -0,0 +1,241 @@ | |||
1 | /* | ||
2 | * V9FS FID Management | ||
3 | * | ||
4 | * Copyright (C) 2005 by Eric Van Hensbergen <ericvh@gmail.com> | ||
5 | * | ||
6 | * This program is free software; you can redistribute it and/or modify | ||
7 | * it under the terms of the GNU General Public License as published by | ||
8 | * the Free Software Foundation; either version 2 of the License, or | ||
9 | * (at your option) any later version. | ||
10 | * | ||
11 | * This program is distributed in the hope that it will be useful, | ||
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
14 | * GNU General Public License for more details. | ||
15 | * | ||
16 | * You should have received a copy of the GNU General Public License | ||
17 | * along with this program; if not, write to: | ||
18 | * Free Software Foundation | ||
19 | * 51 Franklin Street, Fifth Floor | ||
20 | * Boston, MA 02111-1301 USA | ||
21 | * | ||
22 | */ | ||
23 | |||
24 | #include <linux/config.h> | ||
25 | #include <linux/module.h> | ||
26 | #include <linux/errno.h> | ||
27 | #include <linux/fs.h> | ||
28 | #include <linux/idr.h> | ||
29 | |||
30 | #include "debug.h" | ||
31 | #include "v9fs.h" | ||
32 | #include "9p.h" | ||
33 | #include "v9fs_vfs.h" | ||
34 | #include "transport.h" | ||
35 | #include "mux.h" | ||
36 | #include "conv.h" | ||
37 | #include "fid.h" | ||
38 | |||
39 | /** | ||
40 | * v9fs_fid_insert - add a fid to a dentry | ||
41 | * @fid: fid to add | ||
42 | * @dentry: dentry that it is being added to | ||
43 | * | ||
44 | */ | ||
45 | |||
46 | static int v9fs_fid_insert(struct v9fs_fid *fid, struct dentry *dentry) | ||
47 | { | ||
48 | struct list_head *fid_list = (struct list_head *)dentry->d_fsdata; | ||
49 | dprintk(DEBUG_9P, "fid %d (%p) dentry %s (%p)\n", fid->fid, fid, | ||
50 | dentry->d_iname, dentry); | ||
51 | if (dentry->d_fsdata == NULL) { | ||
52 | dentry->d_fsdata = | ||
53 | kmalloc(sizeof(struct list_head), GFP_KERNEL); | ||
54 | if (dentry->d_fsdata == NULL) { | ||
55 | dprintk(DEBUG_ERROR, "Out of memory\n"); | ||
56 | return -ENOMEM; | ||
57 | } | ||
58 | fid_list = (struct list_head *)dentry->d_fsdata; | ||
59 | INIT_LIST_HEAD(fid_list); /* Initialize list head */ | ||
60 | } | ||
61 | |||
62 | fid->uid = current->uid; | ||
63 | fid->pid = current->pid; | ||
64 | list_add(&fid->list, fid_list); | ||
65 | return 0; | ||
66 | } | ||
67 | |||
68 | /** | ||
69 | * v9fs_fid_create - allocate a FID structure | ||
70 | * @dentry - dentry to link newly created fid to | ||
71 | * | ||
72 | */ | ||
73 | |||
74 | struct v9fs_fid *v9fs_fid_create(struct dentry *dentry) | ||
75 | { | ||
76 | struct v9fs_fid *new; | ||
77 | |||
78 | new = kmalloc(sizeof(struct v9fs_fid), GFP_KERNEL); | ||
79 | if (new == NULL) { | ||
80 | dprintk(DEBUG_ERROR, "Out of Memory\n"); | ||
81 | return ERR_PTR(-ENOMEM); | ||
82 | } | ||
83 | |||
84 | new->fid = -1; | ||
85 | new->fidopen = 0; | ||
86 | new->fidcreate = 0; | ||
87 | new->fidclunked = 0; | ||
88 | new->iounit = 0; | ||
89 | |||
90 | if (v9fs_fid_insert(new, dentry) == 0) | ||
91 | return new; | ||
92 | else { | ||
93 | dprintk(DEBUG_ERROR, "Problems inserting to dentry\n"); | ||
94 | kfree(new); | ||
95 | return NULL; | ||
96 | } | ||
97 | } | ||
98 | |||
99 | /** | ||
100 | * v9fs_fid_destroy - deallocate a FID structure | ||
101 | * @fid: fid to destroy | ||
102 | * | ||
103 | */ | ||
104 | |||
105 | void v9fs_fid_destroy(struct v9fs_fid *fid) | ||
106 | { | ||
107 | list_del(&fid->list); | ||
108 | kfree(fid); | ||
109 | } | ||
110 | |||
111 | /** | ||
112 | * v9fs_fid_lookup - retrieve the right fid from a particular dentry | ||
113 | * @dentry: dentry to look for fid in | ||
114 | * @type: intent of lookup (operation or traversal) | ||
115 | * | ||
116 | * search list of fids associated with a dentry for a fid with a matching | ||
117 | * thread id or uid. If that fails, look up the dentry's parents to see if you | ||
118 | * can find a matching fid. | ||
119 | * | ||
120 | */ | ||
121 | |||
122 | struct v9fs_fid *v9fs_fid_lookup(struct dentry *dentry, int type) | ||
123 | { | ||
124 | struct list_head *fid_list = (struct list_head *)dentry->d_fsdata; | ||
125 | struct v9fs_fid *current_fid = NULL; | ||
126 | struct v9fs_fid *temp = NULL; | ||
127 | struct v9fs_fid *return_fid = NULL; | ||
128 | int found_parent = 0; | ||
129 | int found_user = 0; | ||
130 | |||
131 | dprintk(DEBUG_9P, " dentry: %s (%p) type %d\n", dentry->d_iname, dentry, | ||
132 | type); | ||
133 | |||
134 | if (fid_list && !list_empty(fid_list)) { | ||
135 | list_for_each_entry_safe(current_fid, temp, fid_list, list) { | ||
136 | if (current_fid->uid == current->uid) { | ||
137 | if (return_fid == NULL) { | ||
138 | if ((type == FID_OP) | ||
139 | || (!current_fid->fidopen)) { | ||
140 | return_fid = current_fid; | ||
141 | found_user = 1; | ||
142 | } | ||
143 | } | ||
144 | } | ||
145 | if (current_fid->pid == current->real_parent->pid) { | ||
146 | if ((return_fid == NULL) || (found_parent) | ||
147 | || (found_user)) { | ||
148 | if ((type == FID_OP) | ||
149 | || (!current_fid->fidopen)) { | ||
150 | return_fid = current_fid; | ||
151 | found_parent = 1; | ||
152 | found_user = 0; | ||
153 | } | ||
154 | } | ||
155 | } | ||
156 | if (current_fid->pid == current->pid) { | ||
157 | if ((type == FID_OP) || | ||
158 | (!current_fid->fidopen)) { | ||
159 | return_fid = current_fid; | ||
160 | found_parent = 0; | ||
161 | found_user = 0; | ||
162 | } | ||
163 | } | ||
164 | } | ||
165 | } | ||
166 | |||
167 | /* we are at the root but didn't match */ | ||
168 | if ((!return_fid) && (dentry->d_parent == dentry)) { | ||
169 | /* TODO: clone attach with new uid */ | ||
170 | return_fid = current_fid; | ||
171 | } | ||
172 | |||
173 | if (!return_fid) { | ||
174 | struct dentry *par = current->fs->pwd->d_parent; | ||
175 | int count = 1; | ||
176 | while (par != NULL) { | ||
177 | if (par == dentry) | ||
178 | break; | ||
179 | count++; | ||
180 | if (par == par->d_parent) { | ||
181 | dprintk(DEBUG_ERROR, | ||
182 | "got to root without finding dentry\n"); | ||
183 | break; | ||
184 | } | ||
185 | par = par->d_parent; | ||
186 | } | ||
187 | |||
188 | /* XXX - there may be some duplication we can get rid of */ | ||
189 | if (par == dentry) { | ||
190 | /* we need to fid_lookup the starting point */ | ||
191 | int fidnum = -1; | ||
192 | int oldfid = -1; | ||
193 | int result = -1; | ||
194 | struct v9fs_session_info *v9ses = | ||
195 | v9fs_inode2v9ses(current->fs->pwd->d_inode); | ||
196 | |||
197 | current_fid = | ||
198 | v9fs_fid_lookup(current->fs->pwd, FID_WALK); | ||
199 | if (current_fid == NULL) { | ||
200 | dprintk(DEBUG_ERROR, | ||
201 | "process cwd doesn't have a fid\n"); | ||
202 | return return_fid; | ||
203 | } | ||
204 | oldfid = current_fid->fid; | ||
205 | par = current->fs->pwd; | ||
206 | /* TODO: take advantage of multiwalk */ | ||
207 | |||
208 | fidnum = v9fs_get_idpool(&v9ses->fidpool); | ||
209 | if (fidnum < 0) { | ||
210 | dprintk(DEBUG_ERROR, | ||
211 | "could not get a new fid num\n"); | ||
212 | return return_fid; | ||
213 | } | ||
214 | |||
215 | while (par != dentry) { | ||
216 | result = | ||
217 | v9fs_t_walk(v9ses, oldfid, fidnum, "..", | ||
218 | NULL); | ||
219 | if (result < 0) { | ||
220 | dprintk(DEBUG_ERROR, | ||
221 | "problem walking to parent\n"); | ||
222 | |||
223 | break; | ||
224 | } | ||
225 | oldfid = fidnum; | ||
226 | if (par == par->d_parent) { | ||
227 | dprintk(DEBUG_ERROR, | ||
228 | "can't find dentry\n"); | ||
229 | break; | ||
230 | } | ||
231 | par = par->d_parent; | ||
232 | } | ||
233 | if (par == dentry) { | ||
234 | return_fid = v9fs_fid_create(dentry); | ||
235 | return_fid->fid = fidnum; | ||
236 | } | ||
237 | } | ||
238 | } | ||
239 | |||
240 | return return_fid; | ||
241 | } | ||