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