1 /*
2 * Copyright (c) 2002 Red Hat, Inc. All rights reserved.
3 *
4 * This software may be freely redistributed under the terms of the
5 * GNU General Public License.
6 *
7 * You should have received a copy of the GNU General Public License
8 * along with this program; if not, write to the Free Software
9 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
10 *
11 * Authors: David Woodhouse <dwmw2@infradead.org>
12 * David Howells <dhowells@redhat.com>
13 *
14 */
15
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/init.h>
19 #include <linux/fs.h>
20 #include <linux/pagemap.h>
21 #include <linux/sched.h>
22 #include <linux/mount.h>
23 #include <linux/namei.h>
24 #include "internal.h"
25
26 struct afs_iget_data {
27 struct afs_fid fid;
28 struct afs_volume *volume; /* volume on which resides */
29 };
30
31 /*
32 * map the AFS file status to the inode member variables
33 */
afs_inode_map_status(struct afs_vnode * vnode,struct key * key)34 static int afs_inode_map_status(struct afs_vnode *vnode, struct key *key)
35 {
36 struct inode *inode = AFS_VNODE_TO_I(vnode);
37
38 _debug("FS: ft=%d lk=%d sz=%llu ver=%Lu mod=%hu",
39 vnode->status.type,
40 vnode->status.nlink,
41 (unsigned long long) vnode->status.size,
42 vnode->status.data_version,
43 vnode->status.mode);
44
45 switch (vnode->status.type) {
46 case AFS_FTYPE_FILE:
47 inode->i_mode = S_IFREG | vnode->status.mode;
48 inode->i_op = &afs_file_inode_operations;
49 inode->i_fop = &afs_file_operations;
50 break;
51 case AFS_FTYPE_DIR:
52 inode->i_mode = S_IFDIR | vnode->status.mode;
53 inode->i_op = &afs_dir_inode_operations;
54 inode->i_fop = &afs_dir_file_operations;
55 break;
56 case AFS_FTYPE_SYMLINK:
57 inode->i_mode = S_IFLNK | vnode->status.mode;
58 inode->i_op = &page_symlink_inode_operations;
59 break;
60 default:
61 printk("kAFS: AFS vnode with undefined type\n");
62 return -EBADMSG;
63 }
64
65 #ifdef CONFIG_AFS_FSCACHE
66 if (vnode->status.size != inode->i_size)
67 fscache_attr_changed(vnode->cache);
68 #endif
69
70 inode->i_nlink = vnode->status.nlink;
71 inode->i_uid = vnode->status.owner;
72 inode->i_gid = 0;
73 inode->i_size = vnode->status.size;
74 inode->i_ctime.tv_sec = vnode->status.mtime_server;
75 inode->i_ctime.tv_nsec = 0;
76 inode->i_atime = inode->i_mtime = inode->i_ctime;
77 inode->i_blocks = 0;
78 inode->i_version = vnode->fid.unique;
79 inode->i_mapping->a_ops = &afs_fs_aops;
80
81 /* check to see whether a symbolic link is really a mountpoint */
82 if (vnode->status.type == AFS_FTYPE_SYMLINK) {
83 afs_mntpt_check_symlink(vnode, key);
84
85 if (test_bit(AFS_VNODE_MOUNTPOINT, &vnode->flags)) {
86 inode->i_mode = S_IFDIR | vnode->status.mode;
87 inode->i_op = &afs_mntpt_inode_operations;
88 inode->i_fop = &afs_mntpt_file_operations;
89 }
90 }
91
92 return 0;
93 }
94
95 /*
96 * iget5() comparator
97 */
afs_iget5_test(struct inode * inode,void * opaque)98 static int afs_iget5_test(struct inode *inode, void *opaque)
99 {
100 struct afs_iget_data *data = opaque;
101
102 return inode->i_ino == data->fid.vnode &&
103 inode->i_version == data->fid.unique;
104 }
105
106 /*
107 * iget5() comparator for inode created by autocell operations
108 *
109 * These pseudo inodes don't match anything.
110 */
afs_iget5_autocell_test(struct inode * inode,void * opaque)111 static int afs_iget5_autocell_test(struct inode *inode, void *opaque)
112 {
113 return 0;
114 }
115
116 /*
117 * iget5() inode initialiser
118 */
afs_iget5_set(struct inode * inode,void * opaque)119 static int afs_iget5_set(struct inode *inode, void *opaque)
120 {
121 struct afs_iget_data *data = opaque;
122 struct afs_vnode *vnode = AFS_FS_I(inode);
123
124 inode->i_ino = data->fid.vnode;
125 inode->i_version = data->fid.unique;
126 vnode->fid = data->fid;
127 vnode->volume = data->volume;
128
129 return 0;
130 }
131
132 /*
133 * inode retrieval for autocell
134 */
afs_iget_autocell(struct inode * dir,const char * dev_name,int namesz,struct key * key)135 struct inode *afs_iget_autocell(struct inode *dir, const char *dev_name,
136 int namesz, struct key *key)
137 {
138 struct afs_iget_data data;
139 struct afs_super_info *as;
140 struct afs_vnode *vnode;
141 struct super_block *sb;
142 struct inode *inode;
143 static atomic_t afs_autocell_ino;
144
145 _enter("{%x:%u},%*.*s,",
146 AFS_FS_I(dir)->fid.vid, AFS_FS_I(dir)->fid.vnode,
147 namesz, namesz, dev_name ?: "");
148
149 sb = dir->i_sb;
150 as = sb->s_fs_info;
151 data.volume = as->volume;
152 data.fid.vid = as->volume->vid;
153 data.fid.unique = 0;
154 data.fid.vnode = 0;
155
156 inode = iget5_locked(sb, atomic_inc_return(&afs_autocell_ino),
157 afs_iget5_autocell_test, afs_iget5_set,
158 &data);
159 if (!inode) {
160 _leave(" = -ENOMEM");
161 return ERR_PTR(-ENOMEM);
162 }
163
164 _debug("GOT INODE %p { ino=%lu, vl=%x, vn=%x, u=%x }",
165 inode, inode->i_ino, data.fid.vid, data.fid.vnode,
166 data.fid.unique);
167
168 vnode = AFS_FS_I(inode);
169
170 /* there shouldn't be an existing inode */
171 BUG_ON(!(inode->i_state & I_NEW));
172
173 inode->i_size = 0;
174 inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
175 inode->i_op = &afs_autocell_inode_operations;
176 inode->i_nlink = 2;
177 inode->i_uid = 0;
178 inode->i_gid = 0;
179 inode->i_ctime.tv_sec = get_seconds();
180 inode->i_ctime.tv_nsec = 0;
181 inode->i_atime = inode->i_mtime = inode->i_ctime;
182 inode->i_blocks = 0;
183 inode->i_version = 0;
184 inode->i_generation = 0;
185
186 set_bit(AFS_VNODE_PSEUDODIR, &vnode->flags);
187 set_bit(AFS_VNODE_MOUNTPOINT, &vnode->flags);
188 inode->i_flags |= S_AUTOMOUNT | S_NOATIME;
189 unlock_new_inode(inode);
190 _leave(" = %p", inode);
191 return inode;
192 }
193
194 /*
195 * inode retrieval
196 */
afs_iget(struct super_block * sb,struct key * key,struct afs_fid * fid,struct afs_file_status * status,struct afs_callback * cb)197 struct inode *afs_iget(struct super_block *sb, struct key *key,
198 struct afs_fid *fid, struct afs_file_status *status,
199 struct afs_callback *cb)
200 {
201 struct afs_iget_data data = { .fid = *fid };
202 struct afs_super_info *as;
203 struct afs_vnode *vnode;
204 struct inode *inode;
205 int ret;
206
207 _enter(",{%x:%u.%u},,", fid->vid, fid->vnode, fid->unique);
208
209 as = sb->s_fs_info;
210 data.volume = as->volume;
211
212 inode = iget5_locked(sb, fid->vnode, afs_iget5_test, afs_iget5_set,
213 &data);
214 if (!inode) {
215 _leave(" = -ENOMEM");
216 return ERR_PTR(-ENOMEM);
217 }
218
219 _debug("GOT INODE %p { vl=%x vn=%x, u=%x }",
220 inode, fid->vid, fid->vnode, fid->unique);
221
222 vnode = AFS_FS_I(inode);
223
224 /* deal with an existing inode */
225 if (!(inode->i_state & I_NEW)) {
226 _leave(" = %p", inode);
227 return inode;
228 }
229
230 if (!status) {
231 /* it's a remotely extant inode */
232 set_bit(AFS_VNODE_CB_BROKEN, &vnode->flags);
233 ret = afs_vnode_fetch_status(vnode, NULL, key);
234 if (ret < 0)
235 goto bad_inode;
236 } else {
237 /* it's an inode we just created */
238 memcpy(&vnode->status, status, sizeof(vnode->status));
239
240 if (!cb) {
241 /* it's a symlink we just created (the fileserver
242 * didn't give us a callback) */
243 vnode->cb_version = 0;
244 vnode->cb_expiry = 0;
245 vnode->cb_type = 0;
246 vnode->cb_expires = get_seconds();
247 } else {
248 vnode->cb_version = cb->version;
249 vnode->cb_expiry = cb->expiry;
250 vnode->cb_type = cb->type;
251 vnode->cb_expires = vnode->cb_expiry + get_seconds();
252 }
253 }
254
255 /* set up caching before mapping the status, as map-status reads the
256 * first page of symlinks to see if they're really mountpoints */
257 inode->i_size = vnode->status.size;
258 #ifdef CONFIG_AFS_FSCACHE
259 vnode->cache = fscache_acquire_cookie(vnode->volume->cache,
260 &afs_vnode_cache_index_def,
261 vnode);
262 #endif
263
264 ret = afs_inode_map_status(vnode, key);
265 if (ret < 0)
266 goto bad_inode;
267
268 /* success */
269 clear_bit(AFS_VNODE_UNSET, &vnode->flags);
270 inode->i_flags |= S_NOATIME;
271 unlock_new_inode(inode);
272 _leave(" = %p [CB { v=%u t=%u }]", inode, vnode->cb_version, vnode->cb_type);
273 return inode;
274
275 /* failure */
276 bad_inode:
277 #ifdef CONFIG_AFS_FSCACHE
278 fscache_relinquish_cookie(vnode->cache, 0);
279 vnode->cache = NULL;
280 #endif
281 iget_failed(inode);
282 _leave(" = %d [bad]", ret);
283 return ERR_PTR(ret);
284 }
285
286 /*
287 * mark the data attached to an inode as obsolete due to a write on the server
288 * - might also want to ditch all the outstanding writes and dirty pages
289 */
afs_zap_data(struct afs_vnode * vnode)290 void afs_zap_data(struct afs_vnode *vnode)
291 {
292 _enter("{%x:%u}", vnode->fid.vid, vnode->fid.vnode);
293
294 /* nuke all the non-dirty pages that aren't locked, mapped or being
295 * written back in a regular file and completely discard the pages in a
296 * directory or symlink */
297 if (S_ISREG(vnode->vfs_inode.i_mode))
298 invalidate_remote_inode(&vnode->vfs_inode);
299 else
300 invalidate_inode_pages2(vnode->vfs_inode.i_mapping);
301 }
302
303 /*
304 * validate a vnode/inode
305 * - there are several things we need to check
306 * - parent dir data changes (rm, rmdir, rename, mkdir, create, link,
307 * symlink)
308 * - parent dir metadata changed (security changes)
309 * - dentry data changed (write, truncate)
310 * - dentry metadata changed (security changes)
311 */
afs_validate(struct afs_vnode * vnode,struct key * key)312 int afs_validate(struct afs_vnode *vnode, struct key *key)
313 {
314 int ret;
315
316 _enter("{v={%x:%u} fl=%lx},%x",
317 vnode->fid.vid, vnode->fid.vnode, vnode->flags,
318 key_serial(key));
319
320 if (vnode->cb_promised &&
321 !test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags) &&
322 !test_bit(AFS_VNODE_MODIFIED, &vnode->flags) &&
323 !test_bit(AFS_VNODE_ZAP_DATA, &vnode->flags)) {
324 if (vnode->cb_expires < get_seconds() + 10) {
325 _debug("callback expired");
326 set_bit(AFS_VNODE_CB_BROKEN, &vnode->flags);
327 } else {
328 goto valid;
329 }
330 }
331
332 if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
333 goto valid;
334
335 mutex_lock(&vnode->validate_lock);
336
337 /* if the promise has expired, we need to check the server again to get
338 * a new promise - note that if the (parent) directory's metadata was
339 * changed then the security may be different and we may no longer have
340 * access */
341 if (!vnode->cb_promised ||
342 test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags)) {
343 _debug("not promised");
344 ret = afs_vnode_fetch_status(vnode, NULL, key);
345 if (ret < 0)
346 goto error_unlock;
347 _debug("new promise [fl=%lx]", vnode->flags);
348 }
349
350 if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) {
351 _debug("file already deleted");
352 ret = -ESTALE;
353 goto error_unlock;
354 }
355
356 /* if the vnode's data version number changed then its contents are
357 * different */
358 if (test_and_clear_bit(AFS_VNODE_ZAP_DATA, &vnode->flags))
359 afs_zap_data(vnode);
360
361 clear_bit(AFS_VNODE_MODIFIED, &vnode->flags);
362 mutex_unlock(&vnode->validate_lock);
363 valid:
364 _leave(" = 0");
365 return 0;
366
367 error_unlock:
368 mutex_unlock(&vnode->validate_lock);
369 _leave(" = %d", ret);
370 return ret;
371 }
372
373 /*
374 * read the attributes of an inode
375 */
afs_getattr(struct vfsmount * mnt,struct dentry * dentry,struct kstat * stat)376 int afs_getattr(struct vfsmount *mnt, struct dentry *dentry,
377 struct kstat *stat)
378 {
379 struct inode *inode;
380
381 inode = dentry->d_inode;
382
383 _enter("{ ino=%lu v=%llu }", inode->i_ino,
384 (unsigned long long)inode->i_version);
385
386 generic_fillattr(inode, stat);
387 return 0;
388 }
389
390 /*
391 * discard an AFS inode
392 */
afs_drop_inode(struct inode * inode)393 int afs_drop_inode(struct inode *inode)
394 {
395 _enter("");
396
397 if (test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(inode)->flags))
398 return generic_delete_inode(inode);
399 else
400 return generic_drop_inode(inode);
401 }
402
403 /*
404 * clear an AFS inode
405 */
afs_evict_inode(struct inode * inode)406 void afs_evict_inode(struct inode *inode)
407 {
408 struct afs_permits *permits;
409 struct afs_vnode *vnode;
410
411 vnode = AFS_FS_I(inode);
412
413 _enter("{%x:%u.%d} v=%u x=%u t=%u }",
414 vnode->fid.vid,
415 vnode->fid.vnode,
416 vnode->fid.unique,
417 vnode->cb_version,
418 vnode->cb_expiry,
419 vnode->cb_type);
420
421 _debug("CLEAR INODE %p", inode);
422
423 ASSERTCMP(inode->i_ino, ==, vnode->fid.vnode);
424
425 truncate_inode_pages(&inode->i_data, 0);
426 end_writeback(inode);
427
428 afs_give_up_callback(vnode);
429
430 if (vnode->server) {
431 spin_lock(&vnode->server->fs_lock);
432 rb_erase(&vnode->server_rb, &vnode->server->fs_vnodes);
433 spin_unlock(&vnode->server->fs_lock);
434 afs_put_server(vnode->server);
435 vnode->server = NULL;
436 }
437
438 ASSERT(list_empty(&vnode->writebacks));
439 ASSERT(!vnode->cb_promised);
440
441 #ifdef CONFIG_AFS_FSCACHE
442 fscache_relinquish_cookie(vnode->cache, 0);
443 vnode->cache = NULL;
444 #endif
445
446 mutex_lock(&vnode->permits_lock);
447 permits = vnode->permits;
448 rcu_assign_pointer(vnode->permits, NULL);
449 mutex_unlock(&vnode->permits_lock);
450 if (permits)
451 call_rcu(&permits->rcu, afs_zap_permits);
452
453 _leave("");
454 }
455
456 /*
457 * set the attributes of an inode
458 */
afs_setattr(struct dentry * dentry,struct iattr * attr)459 int afs_setattr(struct dentry *dentry, struct iattr *attr)
460 {
461 struct afs_vnode *vnode = AFS_FS_I(dentry->d_inode);
462 struct key *key;
463 int ret;
464
465 _enter("{%x:%u},{n=%s},%x",
466 vnode->fid.vid, vnode->fid.vnode, dentry->d_name.name,
467 attr->ia_valid);
468
469 if (!(attr->ia_valid & (ATTR_SIZE | ATTR_MODE | ATTR_UID | ATTR_GID |
470 ATTR_MTIME))) {
471 _leave(" = 0 [unsupported]");
472 return 0;
473 }
474
475 /* flush any dirty data outstanding on a regular file */
476 if (S_ISREG(vnode->vfs_inode.i_mode)) {
477 filemap_write_and_wait(vnode->vfs_inode.i_mapping);
478 afs_writeback_all(vnode);
479 }
480
481 if (attr->ia_valid & ATTR_FILE) {
482 key = attr->ia_file->private_data;
483 } else {
484 key = afs_request_key(vnode->volume->cell);
485 if (IS_ERR(key)) {
486 ret = PTR_ERR(key);
487 goto error;
488 }
489 }
490
491 ret = afs_vnode_setattr(vnode, key, attr);
492 if (!(attr->ia_valid & ATTR_FILE))
493 key_put(key);
494
495 error:
496 _leave(" = %d", ret);
497 return ret;
498 }
499