1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#include <linux/kernel.h>
17#include <linux/module.h>
18#include <linux/init.h>
19#include <linux/slab.h>
20#include <linux/fs.h>
21#include <linux/pagemap.h>
22#include <linux/sched.h>
23#include "internal.h"
24
25struct afs_iget_data {
26 struct afs_fid fid;
27 struct afs_volume *volume;
28};
29
30
31
32
33static int afs_inode_map_status(struct afs_vnode *vnode, struct key *key)
34{
35 struct inode *inode = AFS_VNODE_TO_I(vnode);
36
37 _debug("FS: ft=%d lk=%d sz=%llu ver=%Lu mod=%hu",
38 vnode->status.type,
39 vnode->status.nlink,
40 (unsigned long long) vnode->status.size,
41 vnode->status.data_version,
42 vnode->status.mode);
43
44 switch (vnode->status.type) {
45 case AFS_FTYPE_FILE:
46 inode->i_mode = S_IFREG | vnode->status.mode;
47 inode->i_op = &afs_file_inode_operations;
48 inode->i_fop = &afs_file_operations;
49 break;
50 case AFS_FTYPE_DIR:
51 inode->i_mode = S_IFDIR | vnode->status.mode;
52 inode->i_op = &afs_dir_inode_operations;
53 inode->i_fop = &afs_dir_file_operations;
54 break;
55 case AFS_FTYPE_SYMLINK:
56 inode->i_mode = S_IFLNK | vnode->status.mode;
57 inode->i_op = &page_symlink_inode_operations;
58 break;
59 default:
60 printk("kAFS: AFS vnode with undefined type\n");
61 return -EBADMSG;
62 }
63
64#ifdef CONFIG_AFS_FSCACHE
65 if (vnode->status.size != inode->i_size)
66 fscache_attr_changed(vnode->cache);
67#endif
68
69 inode->i_nlink = vnode->status.nlink;
70 inode->i_uid = vnode->status.owner;
71 inode->i_gid = 0;
72 inode->i_size = vnode->status.size;
73 inode->i_ctime.tv_sec = vnode->status.mtime_server;
74 inode->i_ctime.tv_nsec = 0;
75 inode->i_atime = inode->i_mtime = inode->i_ctime;
76 inode->i_blocks = 0;
77 inode->i_version = vnode->fid.unique;
78 inode->i_mapping->a_ops = &afs_fs_aops;
79
80
81 if (vnode->status.type == AFS_FTYPE_SYMLINK) {
82 afs_mntpt_check_symlink(vnode, key);
83
84 if (test_bit(AFS_VNODE_MOUNTPOINT, &vnode->flags)) {
85 inode->i_mode = S_IFDIR | vnode->status.mode;
86 inode->i_op = &afs_mntpt_inode_operations;
87 inode->i_fop = &afs_mntpt_file_operations;
88 }
89 }
90
91 return 0;
92}
93
94
95
96
97static int afs_iget5_test(struct inode *inode, void *opaque)
98{
99 struct afs_iget_data *data = opaque;
100
101 return inode->i_ino == data->fid.vnode &&
102 inode->i_version == data->fid.unique;
103}
104
105
106
107
108static int afs_iget5_set(struct inode *inode, void *opaque)
109{
110 struct afs_iget_data *data = opaque;
111 struct afs_vnode *vnode = AFS_FS_I(inode);
112
113 inode->i_ino = data->fid.vnode;
114 inode->i_version = data->fid.unique;
115 vnode->fid = data->fid;
116 vnode->volume = data->volume;
117
118 return 0;
119}
120
121
122
123
124struct inode *afs_iget(struct super_block *sb, struct key *key,
125 struct afs_fid *fid, struct afs_file_status *status,
126 struct afs_callback *cb)
127{
128 struct afs_iget_data data = { .fid = *fid };
129 struct afs_super_info *as;
130 struct afs_vnode *vnode;
131 struct inode *inode;
132 int ret;
133
134 _enter(",{%x:%u.%u},,", fid->vid, fid->vnode, fid->unique);
135
136 as = sb->s_fs_info;
137 data.volume = as->volume;
138
139 inode = iget5_locked(sb, fid->vnode, afs_iget5_test, afs_iget5_set,
140 &data);
141 if (!inode) {
142 _leave(" = -ENOMEM");
143 return ERR_PTR(-ENOMEM);
144 }
145
146 _debug("GOT INODE %p { vl=%x vn=%x, u=%x }",
147 inode, fid->vid, fid->vnode, fid->unique);
148
149 vnode = AFS_FS_I(inode);
150
151
152 if (!(inode->i_state & I_NEW)) {
153 _leave(" = %p", inode);
154 return inode;
155 }
156
157 if (!status) {
158
159 set_bit(AFS_VNODE_CB_BROKEN, &vnode->flags);
160 ret = afs_vnode_fetch_status(vnode, NULL, key);
161 if (ret < 0)
162 goto bad_inode;
163 } else {
164
165 memcpy(&vnode->status, status, sizeof(vnode->status));
166
167 if (!cb) {
168
169
170 vnode->cb_version = 0;
171 vnode->cb_expiry = 0;
172 vnode->cb_type = 0;
173 vnode->cb_expires = get_seconds();
174 } else {
175 vnode->cb_version = cb->version;
176 vnode->cb_expiry = cb->expiry;
177 vnode->cb_type = cb->type;
178 vnode->cb_expires = vnode->cb_expiry + get_seconds();
179 }
180 }
181
182
183
184 inode->i_size = vnode->status.size;
185#ifdef CONFIG_AFS_FSCACHE
186 vnode->cache = fscache_acquire_cookie(vnode->volume->cache,
187 &afs_vnode_cache_index_def,
188 vnode);
189#endif
190
191 ret = afs_inode_map_status(vnode, key);
192 if (ret < 0)
193 goto bad_inode;
194
195
196 clear_bit(AFS_VNODE_UNSET, &vnode->flags);
197 inode->i_flags |= S_NOATIME;
198 unlock_new_inode(inode);
199 _leave(" = %p [CB { v=%u t=%u }]", inode, vnode->cb_version, vnode->cb_type);
200 return inode;
201
202
203bad_inode:
204#ifdef CONFIG_AFS_FSCACHE
205 fscache_relinquish_cookie(vnode->cache, 0);
206 vnode->cache = NULL;
207#endif
208 iget_failed(inode);
209 _leave(" = %d [bad]", ret);
210 return ERR_PTR(ret);
211}
212
213
214
215
216
217void afs_zap_data(struct afs_vnode *vnode)
218{
219 _enter("{%x:%u}", vnode->fid.vid, vnode->fid.vnode);
220
221
222
223
224 if (S_ISREG(vnode->vfs_inode.i_mode))
225 invalidate_remote_inode(&vnode->vfs_inode);
226 else
227 invalidate_inode_pages2(vnode->vfs_inode.i_mapping);
228}
229
230
231
232
233
234
235
236
237
238
239int afs_validate(struct afs_vnode *vnode, struct key *key)
240{
241 int ret;
242
243 _enter("{v={%x:%u} fl=%lx},%x",
244 vnode->fid.vid, vnode->fid.vnode, vnode->flags,
245 key_serial(key));
246
247 if (vnode->cb_promised &&
248 !test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags) &&
249 !test_bit(AFS_VNODE_MODIFIED, &vnode->flags) &&
250 !test_bit(AFS_VNODE_ZAP_DATA, &vnode->flags)) {
251 if (vnode->cb_expires < get_seconds() + 10) {
252 _debug("callback expired");
253 set_bit(AFS_VNODE_CB_BROKEN, &vnode->flags);
254 } else {
255 goto valid;
256 }
257 }
258
259 if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
260 goto valid;
261
262 mutex_lock(&vnode->validate_lock);
263
264
265
266
267
268 if (!vnode->cb_promised ||
269 test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags)) {
270 _debug("not promised");
271 ret = afs_vnode_fetch_status(vnode, NULL, key);
272 if (ret < 0)
273 goto error_unlock;
274 _debug("new promise [fl=%lx]", vnode->flags);
275 }
276
277 if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) {
278 _debug("file already deleted");
279 ret = -ESTALE;
280 goto error_unlock;
281 }
282
283
284
285 if (test_and_clear_bit(AFS_VNODE_ZAP_DATA, &vnode->flags))
286 afs_zap_data(vnode);
287
288 clear_bit(AFS_VNODE_MODIFIED, &vnode->flags);
289 mutex_unlock(&vnode->validate_lock);
290valid:
291 _leave(" = 0");
292 return 0;
293
294error_unlock:
295 mutex_unlock(&vnode->validate_lock);
296 _leave(" = %d", ret);
297 return ret;
298}
299
300
301
302
303int afs_getattr(struct vfsmount *mnt, struct dentry *dentry,
304 struct kstat *stat)
305{
306 struct inode *inode;
307
308 inode = dentry->d_inode;
309
310 _enter("{ ino=%lu v=%llu }", inode->i_ino,
311 (unsigned long long)inode->i_version);
312
313 generic_fillattr(inode, stat);
314 return 0;
315}
316
317
318
319
320void afs_clear_inode(struct inode *inode)
321{
322 struct afs_permits *permits;
323 struct afs_vnode *vnode;
324
325 vnode = AFS_FS_I(inode);
326
327 _enter("{%x:%u.%d} v=%u x=%u t=%u }",
328 vnode->fid.vid,
329 vnode->fid.vnode,
330 vnode->fid.unique,
331 vnode->cb_version,
332 vnode->cb_expiry,
333 vnode->cb_type);
334
335 _debug("CLEAR INODE %p", inode);
336
337 ASSERTCMP(inode->i_ino, ==, vnode->fid.vnode);
338
339 afs_give_up_callback(vnode);
340
341 if (vnode->server) {
342 spin_lock(&vnode->server->fs_lock);
343 rb_erase(&vnode->server_rb, &vnode->server->fs_vnodes);
344 spin_unlock(&vnode->server->fs_lock);
345 afs_put_server(vnode->server);
346 vnode->server = NULL;
347 }
348
349 ASSERT(list_empty(&vnode->writebacks));
350 ASSERT(!vnode->cb_promised);
351
352#ifdef CONFIG_AFS_FSCACHE
353 fscache_relinquish_cookie(vnode->cache, 0);
354 vnode->cache = NULL;
355#endif
356
357 mutex_lock(&vnode->permits_lock);
358 permits = vnode->permits;
359 rcu_assign_pointer(vnode->permits, NULL);
360 mutex_unlock(&vnode->permits_lock);
361 if (permits)
362 call_rcu(&permits->rcu, afs_zap_permits);
363
364 _leave("");
365}
366
367
368
369
370int afs_setattr(struct dentry *dentry, struct iattr *attr)
371{
372 struct afs_vnode *vnode = AFS_FS_I(dentry->d_inode);
373 struct key *key;
374 int ret;
375
376 _enter("{%x:%u},{n=%s},%x",
377 vnode->fid.vid, vnode->fid.vnode, dentry->d_name.name,
378 attr->ia_valid);
379
380 if (!(attr->ia_valid & (ATTR_SIZE | ATTR_MODE | ATTR_UID | ATTR_GID |
381 ATTR_MTIME))) {
382 _leave(" = 0 [unsupported]");
383 return 0;
384 }
385
386
387 if (S_ISREG(vnode->vfs_inode.i_mode)) {
388 filemap_write_and_wait(vnode->vfs_inode.i_mapping);
389 afs_writeback_all(vnode);
390 }
391
392 if (attr->ia_valid & ATTR_FILE) {
393 key = attr->ia_file->private_data;
394 } else {
395 key = afs_request_key(vnode->volume->cell);
396 if (IS_ERR(key)) {
397 ret = PTR_ERR(key);
398 goto error;
399 }
400 }
401
402 ret = afs_vnode_setattr(vnode, key, attr);
403 if (!(attr->ia_valid & ATTR_FILE))
404 key_put(key);
405
406error:
407 _leave(" = %d", ret);
408 return ret;
409}
410