xref: /openbmc/linux/fs/9p/fid.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
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 	struct v9fs_session_info *v9ses, int fid, int create)
76 {
77 	struct v9fs_fid *new;
78 
79 	dprintk(DEBUG_9P, "fid create dentry %p, fid %d, create %d\n",
80 		dentry, fid, create);
81 
82 	new = kmalloc(sizeof(struct v9fs_fid), GFP_KERNEL);
83 	if (new == NULL) {
84 		dprintk(DEBUG_ERROR, "Out of Memory\n");
85 		return ERR_PTR(-ENOMEM);
86 	}
87 
88 	new->fid = fid;
89 	new->v9ses = v9ses;
90 	new->fidopen = 0;
91 	new->fidcreate = create;
92 	new->fidclunked = 0;
93 	new->iounit = 0;
94 	new->rdir_pos = 0;
95 	new->rdir_fcall = NULL;
96 
97 	if (v9fs_fid_insert(new, dentry) == 0)
98 		return new;
99 	else {
100 		dprintk(DEBUG_ERROR, "Problems inserting to dentry\n");
101 		kfree(new);
102 		return NULL;
103 	}
104 }
105 
106 /**
107  * v9fs_fid_destroy - deallocate a FID structure
108  * @fid: fid to destroy
109  *
110  */
111 
112 void v9fs_fid_destroy(struct v9fs_fid *fid)
113 {
114 	list_del(&fid->list);
115 	kfree(fid);
116 }
117 
118 /**
119  * v9fs_fid_walk_up - walks from the process current directory
120  * 	up to the specified dentry.
121  */
122 static struct v9fs_fid *v9fs_fid_walk_up(struct dentry *dentry)
123 {
124 	int fidnum, cfidnum, err;
125 	struct v9fs_fid *cfid;
126 	struct dentry *cde;
127 	struct v9fs_session_info *v9ses;
128 
129 	v9ses = v9fs_inode2v9ses(current->fs->pwd->d_inode);
130 	cfid = v9fs_fid_lookup(current->fs->pwd);
131 	if (cfid == NULL) {
132 		dprintk(DEBUG_ERROR, "process cwd doesn't have a fid\n");
133 		return ERR_PTR(-ENOENT);
134 	}
135 
136 	cfidnum = cfid->fid;
137 	cde = current->fs->pwd;
138 	/* TODO: take advantage of multiwalk */
139 
140 	fidnum = v9fs_get_idpool(&v9ses->fidpool);
141 	if (fidnum < 0) {
142 		dprintk(DEBUG_ERROR, "could not get a new fid num\n");
143 		err = -ENOENT;
144 		goto clunk_fid;
145 	}
146 
147 	while (cde != dentry) {
148 		if (cde == cde->d_parent) {
149 			dprintk(DEBUG_ERROR, "can't find dentry\n");
150 			err = -ENOENT;
151 			goto clunk_fid;
152 		}
153 
154 		err = v9fs_t_walk(v9ses, cfidnum, fidnum, "..", NULL);
155 		if (err < 0) {
156 			dprintk(DEBUG_ERROR, "problem walking to parent\n");
157 			goto clunk_fid;
158 		}
159 
160 		cfidnum = fidnum;
161 		cde = cde->d_parent;
162 	}
163 
164 	return v9fs_fid_create(dentry, v9ses, fidnum, 0);
165 
166 clunk_fid:
167 	v9fs_t_clunk(v9ses, fidnum, NULL);
168 	return ERR_PTR(err);
169 }
170 
171 /**
172  * v9fs_fid_lookup - retrieve the right fid from a  particular dentry
173  * @dentry: dentry to look for fid in
174  * @type: intent of lookup (operation or traversal)
175  *
176  * search list of fids associated with a dentry for a fid with a matching
177  * thread id or uid.  If that fails, look up the dentry's parents to see if you
178  * can find a matching fid.
179  *
180  */
181 
182 struct v9fs_fid *v9fs_fid_lookup(struct dentry *dentry)
183 {
184 	struct list_head *fid_list = (struct list_head *)dentry->d_fsdata;
185 	struct v9fs_fid *current_fid = NULL;
186 	struct v9fs_fid *temp = NULL;
187 	struct v9fs_fid *return_fid = NULL;
188 
189 	dprintk(DEBUG_9P, " dentry: %s (%p)\n", dentry->d_iname, dentry);
190 
191 	if (fid_list) {
192 		list_for_each_entry_safe(current_fid, temp, fid_list, list) {
193 			if (!current_fid->fidcreate) {
194 				return_fid = current_fid;
195 				break;
196 			}
197 		}
198 
199 		if (!return_fid)
200 			return_fid = current_fid;
201 	}
202 
203 	/* we are at the root but didn't match */
204 	if ((!return_fid) && (dentry->d_parent == dentry)) {
205 		/* TODO: clone attach with new uid */
206 		return_fid = current_fid;
207 	}
208 
209 	if (!return_fid) {
210 		struct dentry *par = current->fs->pwd->d_parent;
211 		int count = 1;
212 		while (par != NULL) {
213 			if (par == dentry)
214 				break;
215 			count++;
216 			if (par == par->d_parent) {
217 				dprintk(DEBUG_ERROR,
218 					"got to root without finding dentry\n");
219 				break;
220 			}
221 			par = par->d_parent;
222 		}
223 
224 /* XXX - there may be some duplication we can get rid of */
225 		if (par == dentry) {
226 			return_fid = v9fs_fid_walk_up(dentry);
227 			if (IS_ERR(return_fid))
228 				return_fid = NULL;
229 		}
230 	}
231 
232 	return return_fid;
233 }
234 
235 struct v9fs_fid *v9fs_fid_get_created(struct dentry *dentry)
236 {
237 	struct list_head *fid_list;
238 	struct v9fs_fid *fid, *ftmp, *ret;
239 
240 	dprintk(DEBUG_9P, " dentry: %s (%p)\n", dentry->d_iname, dentry);
241 	fid_list = (struct list_head *)dentry->d_fsdata;
242 	ret = NULL;
243 	if (fid_list) {
244 		list_for_each_entry_safe(fid, ftmp, fid_list, list) {
245 			if (fid->fidcreate && fid->pid == current->pid) {
246 				list_del(&fid->list);
247 				ret = fid;
248 				break;
249 			}
250 		}
251 	}
252 
253 	dprintk(DEBUG_9P, "return %p\n", ret);
254 	return ret;
255 }
256