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> | |
a01179e6 | 24 | #include <linux/iversion.h> |
1da177e4 LT |
25 | #include "internal.h" |
26 | ||
d3e3b7ea DH |
27 | static const struct inode_operations afs_symlink_inode_operations = { |
28 | .get_link = page_get_link, | |
29 | .listxattr = afs_listxattr, | |
30 | }; | |
31 | ||
1da177e4 LT |
32 | /* |
33 | * map the AFS file status to the inode member variables | |
34 | */ | |
00d3b7a4 | 35 | static int afs_inode_map_status(struct afs_vnode *vnode, struct key *key) |
1da177e4 LT |
36 | { |
37 | struct inode *inode = AFS_VNODE_TO_I(vnode); | |
c435ee34 | 38 | bool changed; |
1da177e4 | 39 | |
260a9803 | 40 | _debug("FS: ft=%d lk=%d sz=%llu ver=%Lu mod=%hu", |
1da177e4 LT |
41 | vnode->status.type, |
42 | vnode->status.nlink, | |
ba3e0e1a | 43 | (unsigned long long) vnode->status.size, |
08e0e7c8 | 44 | vnode->status.data_version, |
1da177e4 LT |
45 | vnode->status.mode); |
46 | ||
c435ee34 DH |
47 | read_seqlock_excl(&vnode->cb_lock); |
48 | ||
1da177e4 LT |
49 | switch (vnode->status.type) { |
50 | case AFS_FTYPE_FILE: | |
51 | inode->i_mode = S_IFREG | vnode->status.mode; | |
52 | inode->i_op = &afs_file_inode_operations; | |
00d3b7a4 | 53 | inode->i_fop = &afs_file_operations; |
1da177e4 LT |
54 | break; |
55 | case AFS_FTYPE_DIR: | |
56 | inode->i_mode = S_IFDIR | vnode->status.mode; | |
57 | inode->i_op = &afs_dir_inode_operations; | |
58 | inode->i_fop = &afs_dir_file_operations; | |
59 | break; | |
60 | case AFS_FTYPE_SYMLINK: | |
944c74f4 DH |
61 | /* Symlinks with a mode of 0644 are actually mountpoints. */ |
62 | if ((vnode->status.mode & 0777) == 0644) { | |
63 | inode->i_flags |= S_AUTOMOUNT; | |
64 | ||
944c74f4 | 65 | set_bit(AFS_VNODE_MOUNTPOINT, &vnode->flags); |
944c74f4 DH |
66 | |
67 | inode->i_mode = S_IFDIR | 0555; | |
68 | inode->i_op = &afs_mntpt_inode_operations; | |
69 | inode->i_fop = &afs_mntpt_file_operations; | |
70 | } else { | |
71 | inode->i_mode = S_IFLNK | vnode->status.mode; | |
d3e3b7ea | 72 | inode->i_op = &afs_symlink_inode_operations; |
944c74f4 | 73 | } |
21fc61c7 | 74 | inode_nohighmem(inode); |
1da177e4 LT |
75 | break; |
76 | default: | |
77 | printk("kAFS: AFS vnode with undefined type\n"); | |
c435ee34 | 78 | read_sequnlock_excl(&vnode->cb_lock); |
1da177e4 LT |
79 | return -EBADMSG; |
80 | } | |
81 | ||
c435ee34 | 82 | changed = (vnode->status.size != inode->i_size); |
9b3f26c9 | 83 | |
bfe86848 | 84 | set_nlink(inode, vnode->status.nlink); |
1da177e4 | 85 | inode->i_uid = vnode->status.owner; |
6186f078 | 86 | inode->i_gid = vnode->status.group; |
1da177e4 | 87 | inode->i_size = vnode->status.size; |
ab94f5d0 | 88 | inode->i_ctime.tv_sec = vnode->status.mtime_client; |
1da177e4 LT |
89 | inode->i_ctime.tv_nsec = 0; |
90 | inode->i_atime = inode->i_mtime = inode->i_ctime; | |
1da177e4 | 91 | inode->i_blocks = 0; |
d6e43f75 | 92 | inode->i_generation = vnode->fid.unique; |
a01179e6 | 93 | inode_set_iversion_raw(inode, vnode->status.data_version); |
1da177e4 | 94 | inode->i_mapping->a_ops = &afs_fs_aops; |
c435ee34 DH |
95 | |
96 | read_sequnlock_excl(&vnode->cb_lock); | |
97 | ||
98 | #ifdef CONFIG_AFS_FSCACHE | |
99 | if (changed) | |
100 | fscache_attr_changed(vnode->cache); | |
101 | #endif | |
1da177e4 | 102 | return 0; |
ec26815a | 103 | } |
1da177e4 | 104 | |
d2ddc776 DH |
105 | /* |
106 | * Fetch file status from the volume. | |
107 | */ | |
108 | int afs_fetch_status(struct afs_vnode *vnode, struct key *key) | |
109 | { | |
110 | struct afs_fs_cursor fc; | |
111 | int ret; | |
112 | ||
113 | _enter("%s,{%x:%u.%u,S=%lx}", | |
114 | vnode->volume->name, | |
115 | vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique, | |
116 | vnode->flags); | |
117 | ||
118 | ret = -ERESTARTSYS; | |
119 | if (afs_begin_vnode_operation(&fc, vnode, key)) { | |
120 | while (afs_select_fileserver(&fc)) { | |
121 | fc.cb_break = vnode->cb_break + vnode->cb_s_break; | |
122 | afs_fs_fetch_file_status(&fc, NULL); | |
123 | } | |
124 | ||
125 | afs_check_for_remote_deletion(&fc, fc.vnode); | |
126 | afs_vnode_commit_status(&fc, vnode, fc.cb_break); | |
127 | ret = afs_end_vnode_operation(&fc); | |
128 | } | |
129 | ||
130 | _leave(" = %d", ret); | |
131 | return ret; | |
132 | } | |
133 | ||
1da177e4 LT |
134 | /* |
135 | * iget5() comparator | |
136 | */ | |
c435ee34 | 137 | int afs_iget5_test(struct inode *inode, void *opaque) |
1da177e4 LT |
138 | { |
139 | struct afs_iget_data *data = opaque; | |
140 | ||
141 | return inode->i_ino == data->fid.vnode && | |
d6e43f75 | 142 | inode->i_generation == data->fid.unique; |
ec26815a | 143 | } |
1da177e4 | 144 | |
bec5eb61 | 145 | /* |
146 | * iget5() comparator for inode created by autocell operations | |
147 | * | |
148 | * These pseudo inodes don't match anything. | |
149 | */ | |
4d673da1 | 150 | static int afs_iget5_pseudo_dir_test(struct inode *inode, void *opaque) |
bec5eb61 | 151 | { |
152 | return 0; | |
153 | } | |
154 | ||
1da177e4 LT |
155 | /* |
156 | * iget5() inode initialiser | |
157 | */ | |
158 | static int afs_iget5_set(struct inode *inode, void *opaque) | |
159 | { | |
160 | struct afs_iget_data *data = opaque; | |
161 | struct afs_vnode *vnode = AFS_FS_I(inode); | |
162 | ||
163 | inode->i_ino = data->fid.vnode; | |
d6e43f75 | 164 | inode->i_generation = data->fid.unique; |
1da177e4 LT |
165 | vnode->fid = data->fid; |
166 | vnode->volume = data->volume; | |
167 | ||
168 | return 0; | |
ec26815a | 169 | } |
1da177e4 | 170 | |
bec5eb61 | 171 | /* |
4d673da1 DH |
172 | * Create an inode for a dynamic root directory or an autocell dynamic |
173 | * automount dir. | |
bec5eb61 | 174 | */ |
4d673da1 | 175 | struct inode *afs_iget_pseudo_dir(struct super_block *sb, bool root) |
bec5eb61 | 176 | { |
177 | struct afs_iget_data data; | |
178 | struct afs_super_info *as; | |
179 | struct afs_vnode *vnode; | |
bec5eb61 | 180 | struct inode *inode; |
181 | static atomic_t afs_autocell_ino; | |
182 | ||
4d673da1 | 183 | _enter(""); |
bec5eb61 | 184 | |
bec5eb61 | 185 | as = sb->s_fs_info; |
4d673da1 DH |
186 | if (as->volume) { |
187 | data.volume = as->volume; | |
188 | data.fid.vid = as->volume->vid; | |
189 | } | |
190 | if (root) { | |
191 | data.fid.vnode = 1; | |
192 | data.fid.unique = 1; | |
193 | } else { | |
194 | data.fid.vnode = atomic_inc_return(&afs_autocell_ino); | |
195 | data.fid.unique = 0; | |
196 | } | |
bec5eb61 | 197 | |
4d673da1 DH |
198 | inode = iget5_locked(sb, data.fid.vnode, |
199 | afs_iget5_pseudo_dir_test, afs_iget5_set, | |
bec5eb61 | 200 | &data); |
201 | if (!inode) { | |
202 | _leave(" = -ENOMEM"); | |
203 | return ERR_PTR(-ENOMEM); | |
204 | } | |
205 | ||
206 | _debug("GOT INODE %p { ino=%lu, vl=%x, vn=%x, u=%x }", | |
207 | inode, inode->i_ino, data.fid.vid, data.fid.vnode, | |
208 | data.fid.unique); | |
209 | ||
210 | vnode = AFS_FS_I(inode); | |
211 | ||
212 | /* there shouldn't be an existing inode */ | |
213 | BUG_ON(!(inode->i_state & I_NEW)); | |
214 | ||
215 | inode->i_size = 0; | |
216 | inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO; | |
4d673da1 DH |
217 | if (root) { |
218 | inode->i_op = &afs_dynroot_inode_operations; | |
219 | inode->i_fop = &afs_dynroot_file_operations; | |
220 | } else { | |
221 | inode->i_op = &afs_autocell_inode_operations; | |
222 | } | |
bfe86848 | 223 | set_nlink(inode, 2); |
a0a5386a EB |
224 | inode->i_uid = GLOBAL_ROOT_UID; |
225 | inode->i_gid = GLOBAL_ROOT_GID; | |
bec5eb61 | 226 | inode->i_ctime.tv_sec = get_seconds(); |
227 | inode->i_ctime.tv_nsec = 0; | |
228 | inode->i_atime = inode->i_mtime = inode->i_ctime; | |
229 | inode->i_blocks = 0; | |
a01179e6 | 230 | inode_set_iversion_raw(inode, 0); |
bec5eb61 | 231 | inode->i_generation = 0; |
232 | ||
233 | set_bit(AFS_VNODE_PSEUDODIR, &vnode->flags); | |
4d673da1 DH |
234 | if (!root) { |
235 | set_bit(AFS_VNODE_MOUNTPOINT, &vnode->flags); | |
236 | inode->i_flags |= S_AUTOMOUNT; | |
237 | } | |
238 | ||
239 | inode->i_flags |= S_NOATIME; | |
bec5eb61 | 240 | unlock_new_inode(inode); |
241 | _leave(" = %p", inode); | |
242 | return inode; | |
243 | } | |
244 | ||
1da177e4 LT |
245 | /* |
246 | * inode retrieval | |
247 | */ | |
260a9803 DH |
248 | struct inode *afs_iget(struct super_block *sb, struct key *key, |
249 | struct afs_fid *fid, struct afs_file_status *status, | |
d2ddc776 | 250 | struct afs_callback *cb, struct afs_cb_interest *cbi) |
1da177e4 LT |
251 | { |
252 | struct afs_iget_data data = { .fid = *fid }; | |
253 | struct afs_super_info *as; | |
254 | struct afs_vnode *vnode; | |
255 | struct inode *inode; | |
256 | int ret; | |
257 | ||
416351f2 | 258 | _enter(",{%x:%u.%u},,", fid->vid, fid->vnode, fid->unique); |
1da177e4 LT |
259 | |
260 | as = sb->s_fs_info; | |
261 | data.volume = as->volume; | |
262 | ||
263 | inode = iget5_locked(sb, fid->vnode, afs_iget5_test, afs_iget5_set, | |
264 | &data); | |
265 | if (!inode) { | |
266 | _leave(" = -ENOMEM"); | |
08e0e7c8 | 267 | return ERR_PTR(-ENOMEM); |
1da177e4 LT |
268 | } |
269 | ||
08e0e7c8 DH |
270 | _debug("GOT INODE %p { vl=%x vn=%x, u=%x }", |
271 | inode, fid->vid, fid->vnode, fid->unique); | |
272 | ||
1da177e4 LT |
273 | vnode = AFS_FS_I(inode); |
274 | ||
275 | /* deal with an existing inode */ | |
276 | if (!(inode->i_state & I_NEW)) { | |
08e0e7c8 DH |
277 | _leave(" = %p", inode); |
278 | return inode; | |
1da177e4 LT |
279 | } |
280 | ||
260a9803 DH |
281 | if (!status) { |
282 | /* it's a remotely extant inode */ | |
d2ddc776 | 283 | ret = afs_fetch_status(vnode, key); |
260a9803 DH |
284 | if (ret < 0) |
285 | goto bad_inode; | |
286 | } else { | |
287 | /* it's an inode we just created */ | |
288 | memcpy(&vnode->status, status, sizeof(vnode->status)); | |
289 | ||
290 | if (!cb) { | |
291 | /* it's a symlink we just created (the fileserver | |
292 | * didn't give us a callback) */ | |
293 | vnode->cb_version = 0; | |
260a9803 | 294 | vnode->cb_type = 0; |
c435ee34 | 295 | vnode->cb_expires_at = 0; |
260a9803 DH |
296 | } else { |
297 | vnode->cb_version = cb->version; | |
260a9803 | 298 | vnode->cb_type = cb->type; |
c435ee34 | 299 | vnode->cb_expires_at = cb->expiry; |
d2ddc776 | 300 | vnode->cb_interest = afs_get_cb_interest(cbi); |
c435ee34 | 301 | set_bit(AFS_VNODE_CB_PROMISED, &vnode->flags); |
260a9803 | 302 | } |
c435ee34 DH |
303 | |
304 | vnode->cb_expires_at += ktime_get_real_seconds(); | |
260a9803 DH |
305 | } |
306 | ||
9b3f26c9 DH |
307 | /* set up caching before mapping the status, as map-status reads the |
308 | * first page of symlinks to see if they're really mountpoints */ | |
309 | inode->i_size = vnode->status.size; | |
310 | #ifdef CONFIG_AFS_FSCACHE | |
311 | vnode->cache = fscache_acquire_cookie(vnode->volume->cache, | |
312 | &afs_vnode_cache_index_def, | |
94d30ae9 | 313 | vnode, true); |
9b3f26c9 DH |
314 | #endif |
315 | ||
00d3b7a4 | 316 | ret = afs_inode_map_status(vnode, key); |
08e0e7c8 | 317 | if (ret < 0) |
1da177e4 LT |
318 | goto bad_inode; |
319 | ||
320 | /* success */ | |
260a9803 | 321 | clear_bit(AFS_VNODE_UNSET, &vnode->flags); |
08e0e7c8 | 322 | inode->i_flags |= S_NOATIME; |
1da177e4 | 323 | unlock_new_inode(inode); |
08e0e7c8 DH |
324 | _leave(" = %p [CB { v=%u t=%u }]", inode, vnode->cb_version, vnode->cb_type); |
325 | return inode; | |
1da177e4 LT |
326 | |
327 | /* failure */ | |
ec26815a | 328 | bad_inode: |
9b3f26c9 DH |
329 | #ifdef CONFIG_AFS_FSCACHE |
330 | fscache_relinquish_cookie(vnode->cache, 0); | |
331 | vnode->cache = NULL; | |
332 | #endif | |
aa7fa240 | 333 | iget_failed(inode); |
1da177e4 | 334 | _leave(" = %d [bad]", ret); |
08e0e7c8 | 335 | return ERR_PTR(ret); |
ec26815a | 336 | } |
1da177e4 | 337 | |
416351f2 DH |
338 | /* |
339 | * mark the data attached to an inode as obsolete due to a write on the server | |
340 | * - might also want to ditch all the outstanding writes and dirty pages | |
341 | */ | |
342 | void afs_zap_data(struct afs_vnode *vnode) | |
343 | { | |
0f300ca9 | 344 | _enter("{%x:%u}", vnode->fid.vid, vnode->fid.vnode); |
416351f2 DH |
345 | |
346 | /* nuke all the non-dirty pages that aren't locked, mapped or being | |
0f300ca9 DH |
347 | * written back in a regular file and completely discard the pages in a |
348 | * directory or symlink */ | |
349 | if (S_ISREG(vnode->vfs_inode.i_mode)) | |
350 | invalidate_remote_inode(&vnode->vfs_inode); | |
351 | else | |
352 | invalidate_inode_pages2(vnode->vfs_inode.i_mapping); | |
416351f2 DH |
353 | } |
354 | ||
260a9803 DH |
355 | /* |
356 | * validate a vnode/inode | |
357 | * - there are several things we need to check | |
358 | * - parent dir data changes (rm, rmdir, rename, mkdir, create, link, | |
359 | * symlink) | |
360 | * - parent dir metadata changed (security changes) | |
361 | * - dentry data changed (write, truncate) | |
362 | * - dentry metadata changed (security changes) | |
363 | */ | |
364 | int afs_validate(struct afs_vnode *vnode, struct key *key) | |
365 | { | |
c435ee34 DH |
366 | time64_t now = ktime_get_real_seconds(); |
367 | bool valid = false; | |
260a9803 DH |
368 | int ret; |
369 | ||
370 | _enter("{v={%x:%u} fl=%lx},%x", | |
371 | vnode->fid.vid, vnode->fid.vnode, vnode->flags, | |
372 | key_serial(key)); | |
373 | ||
c435ee34 DH |
374 | /* Quickly check the callback state. Ideally, we'd use read_seqbegin |
375 | * here, but we have no way to pass the net namespace to the RCU | |
376 | * cleanup for the server record. | |
377 | */ | |
378 | read_seqlock_excl(&vnode->cb_lock); | |
379 | ||
380 | if (test_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) { | |
381 | if (vnode->cb_s_break != vnode->cb_interest->server->cb_s_break) { | |
382 | vnode->cb_s_break = vnode->cb_interest->server->cb_s_break; | |
383 | } else if (!test_bit(AFS_VNODE_DIR_MODIFIED, &vnode->flags) && | |
384 | !test_bit(AFS_VNODE_ZAP_DATA, &vnode->flags) && | |
385 | vnode->cb_expires_at - 10 > now) { | |
386 | valid = true; | |
260a9803 | 387 | } |
c435ee34 DH |
388 | } else if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) { |
389 | valid = true; | |
260a9803 DH |
390 | } |
391 | ||
c435ee34 | 392 | read_sequnlock_excl(&vnode->cb_lock); |
440fbc3a DH |
393 | |
394 | if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) | |
395 | clear_nlink(&vnode->vfs_inode); | |
396 | ||
c435ee34 | 397 | if (valid) |
260a9803 DH |
398 | goto valid; |
399 | ||
400 | mutex_lock(&vnode->validate_lock); | |
401 | ||
402 | /* if the promise has expired, we need to check the server again to get | |
403 | * a new promise - note that if the (parent) directory's metadata was | |
404 | * changed then the security may be different and we may no longer have | |
405 | * access */ | |
c435ee34 | 406 | if (!test_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) { |
260a9803 | 407 | _debug("not promised"); |
d2ddc776 | 408 | ret = afs_fetch_status(vnode, key); |
c435ee34 DH |
409 | if (ret < 0) { |
410 | if (ret == -ENOENT) { | |
411 | set_bit(AFS_VNODE_DELETED, &vnode->flags); | |
412 | ret = -ESTALE; | |
413 | } | |
260a9803 | 414 | goto error_unlock; |
c435ee34 | 415 | } |
260a9803 DH |
416 | _debug("new promise [fl=%lx]", vnode->flags); |
417 | } | |
418 | ||
419 | if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) { | |
420 | _debug("file already deleted"); | |
421 | ret = -ESTALE; | |
422 | goto error_unlock; | |
423 | } | |
424 | ||
425 | /* if the vnode's data version number changed then its contents are | |
426 | * different */ | |
416351f2 DH |
427 | if (test_and_clear_bit(AFS_VNODE_ZAP_DATA, &vnode->flags)) |
428 | afs_zap_data(vnode); | |
260a9803 | 429 | |
c435ee34 | 430 | clear_bit(AFS_VNODE_DIR_MODIFIED, &vnode->flags); |
260a9803 DH |
431 | mutex_unlock(&vnode->validate_lock); |
432 | valid: | |
433 | _leave(" = 0"); | |
434 | return 0; | |
435 | ||
436 | error_unlock: | |
437 | mutex_unlock(&vnode->validate_lock); | |
438 | _leave(" = %d", ret); | |
439 | return ret; | |
440 | } | |
441 | ||
1da177e4 LT |
442 | /* |
443 | * read the attributes of an inode | |
444 | */ | |
a528d35e DH |
445 | int afs_getattr(const struct path *path, struct kstat *stat, |
446 | u32 request_mask, unsigned int query_flags) | |
1da177e4 | 447 | { |
a528d35e | 448 | struct inode *inode = d_inode(path->dentry); |
c435ee34 DH |
449 | struct afs_vnode *vnode = AFS_FS_I(inode); |
450 | int seq = 0; | |
1da177e4 | 451 | |
d6e43f75 | 452 | _enter("{ ino=%lu v=%u }", inode->i_ino, inode->i_generation); |
1da177e4 | 453 | |
c435ee34 DH |
454 | do { |
455 | read_seqbegin_or_lock(&vnode->cb_lock, &seq); | |
456 | generic_fillattr(inode, stat); | |
457 | } while (need_seqretry(&vnode->cb_lock, seq)); | |
458 | ||
459 | done_seqretry(&vnode->cb_lock, seq); | |
1da177e4 | 460 | return 0; |
ec26815a | 461 | } |
1da177e4 | 462 | |
bec5eb61 | 463 | /* |
464 | * discard an AFS inode | |
465 | */ | |
466 | int afs_drop_inode(struct inode *inode) | |
467 | { | |
468 | _enter(""); | |
469 | ||
470 | if (test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(inode)->flags)) | |
471 | return generic_delete_inode(inode); | |
472 | else | |
473 | return generic_drop_inode(inode); | |
474 | } | |
475 | ||
1da177e4 LT |
476 | /* |
477 | * clear an AFS inode | |
478 | */ | |
b57922d9 | 479 | void afs_evict_inode(struct inode *inode) |
1da177e4 LT |
480 | { |
481 | struct afs_vnode *vnode; | |
482 | ||
483 | vnode = AFS_FS_I(inode); | |
484 | ||
c435ee34 | 485 | _enter("{%x:%u.%d}", |
260a9803 | 486 | vnode->fid.vid, |
1da177e4 | 487 | vnode->fid.vnode, |
c435ee34 | 488 | vnode->fid.unique); |
1da177e4 | 489 | |
08e0e7c8 DH |
490 | _debug("CLEAR INODE %p", inode); |
491 | ||
492 | ASSERTCMP(inode->i_ino, ==, vnode->fid.vnode); | |
493 | ||
91b0abe3 | 494 | truncate_inode_pages_final(&inode->i_data); |
dbd5768f | 495 | clear_inode(inode); |
b57922d9 | 496 | |
c435ee34 DH |
497 | if (vnode->cb_interest) { |
498 | afs_put_cb_interest(afs_i2net(inode), vnode->cb_interest); | |
499 | vnode->cb_interest = NULL; | |
08e0e7c8 | 500 | } |
1da177e4 | 501 | |
4343d008 DH |
502 | while (!list_empty(&vnode->wb_keys)) { |
503 | struct afs_wb_key *wbk = list_entry(vnode->wb_keys.next, | |
504 | struct afs_wb_key, vnode_link); | |
505 | list_del(&wbk->vnode_link); | |
506 | afs_put_wb_key(wbk); | |
507 | } | |
1da177e4 | 508 | |
9b3f26c9 DH |
509 | #ifdef CONFIG_AFS_FSCACHE |
510 | fscache_relinquish_cookie(vnode->cache, 0); | |
1da177e4 LT |
511 | vnode->cache = NULL; |
512 | #endif | |
513 | ||
be080a6f | 514 | afs_put_permits(vnode->permit_cache); |
1da177e4 | 515 | _leave(""); |
ec26815a | 516 | } |
31143d5d DH |
517 | |
518 | /* | |
519 | * set the attributes of an inode | |
520 | */ | |
521 | int afs_setattr(struct dentry *dentry, struct iattr *attr) | |
522 | { | |
d2ddc776 | 523 | struct afs_fs_cursor fc; |
2b0143b5 | 524 | struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry)); |
31143d5d DH |
525 | struct key *key; |
526 | int ret; | |
527 | ||
a455589f AV |
528 | _enter("{%x:%u},{n=%pd},%x", |
529 | vnode->fid.vid, vnode->fid.vnode, dentry, | |
31143d5d DH |
530 | attr->ia_valid); |
531 | ||
532 | if (!(attr->ia_valid & (ATTR_SIZE | ATTR_MODE | ATTR_UID | ATTR_GID | | |
533 | ATTR_MTIME))) { | |
534 | _leave(" = 0 [unsupported]"); | |
535 | return 0; | |
536 | } | |
537 | ||
538 | /* flush any dirty data outstanding on a regular file */ | |
4343d008 | 539 | if (S_ISREG(vnode->vfs_inode.i_mode)) |
31143d5d | 540 | filemap_write_and_wait(vnode->vfs_inode.i_mapping); |
31143d5d DH |
541 | |
542 | if (attr->ia_valid & ATTR_FILE) { | |
215804a9 | 543 | key = afs_file_key(attr->ia_file); |
31143d5d DH |
544 | } else { |
545 | key = afs_request_key(vnode->volume->cell); | |
546 | if (IS_ERR(key)) { | |
547 | ret = PTR_ERR(key); | |
548 | goto error; | |
549 | } | |
550 | } | |
551 | ||
d2ddc776 DH |
552 | ret = -ERESTARTSYS; |
553 | if (afs_begin_vnode_operation(&fc, vnode, key)) { | |
554 | while (afs_select_fileserver(&fc)) { | |
555 | fc.cb_break = vnode->cb_break + vnode->cb_s_break; | |
556 | afs_fs_setattr(&fc, attr); | |
557 | } | |
558 | ||
559 | afs_check_for_remote_deletion(&fc, fc.vnode); | |
560 | afs_vnode_commit_status(&fc, vnode, fc.cb_break); | |
561 | ret = afs_end_vnode_operation(&fc); | |
562 | } | |
563 | ||
31143d5d DH |
564 | if (!(attr->ia_valid & ATTR_FILE)) |
565 | key_put(key); | |
566 | ||
567 | error: | |
568 | _leave(" = %d", ret); | |
569 | return ret; | |
570 | } |