2 * Copyright (c) 2002 Red Hat, Inc. All rights reserved.
4 * This software may be freely redistributed under the terms of the
5 * GNU General Public License.
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.
11 * Authors: David Woodhouse <dwmw2@infradead.org>
12 * David Howells <dhowells@redhat.com>
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/init.h>
20 #include <linux/pagemap.h>
21 #include <linux/sched.h>
22 #include <linux/mount.h>
23 #include <linux/namei.h>
24 #include <linux/iversion.h>
28 static const struct inode_operations afs_symlink_inode_operations
= {
29 .get_link
= page_get_link
,
30 .listxattr
= afs_listxattr
,
33 static noinline
void dump_vnode(struct afs_vnode
*vnode
, struct afs_vnode
*parent_vnode
)
35 static unsigned long once_only
;
37 pr_warn("kAFS: AFS vnode with undefined type %u\n",
39 pr_warn("kAFS: A=%d m=%o s=%llx v=%llx\n",
40 vnode
->status
.abort_code
,
43 vnode
->status
.data_version
);
44 pr_warn("kAFS: vnode %llx:%llx:%x\n",
49 pr_warn("kAFS: dir %llx:%llx:%x\n",
50 parent_vnode
->fid
.vid
,
51 parent_vnode
->fid
.vnode
,
52 parent_vnode
->fid
.unique
);
54 if (!test_and_set_bit(0, &once_only
))
59 * Initialise an inode from the vnode status.
61 static int afs_inode_init_from_status(struct afs_vnode
*vnode
, struct key
*key
,
62 struct afs_cb_interest
*cbi
,
63 struct afs_vnode
*parent_vnode
,
64 struct afs_status_cb
*scb
)
66 struct afs_cb_interest
*old_cbi
= NULL
;
67 struct afs_file_status
*status
= &scb
->status
;
68 struct inode
*inode
= AFS_VNODE_TO_I(vnode
);
71 _debug("FS: ft=%d lk=%d sz=%llu ver=%Lu mod=%hu",
74 (unsigned long long) status
->size
,
78 write_seqlock(&vnode
->cb_lock
);
80 vnode
->status
= *status
;
82 t
= status
->mtime_client
;
86 inode
->i_uid
= make_kuid(&init_user_ns
, status
->owner
);
87 inode
->i_gid
= make_kgid(&init_user_ns
, status
->group
);
88 set_nlink(&vnode
->vfs_inode
, status
->nlink
);
90 switch (status
->type
) {
92 inode
->i_mode
= S_IFREG
| status
->mode
;
93 inode
->i_op
= &afs_file_inode_operations
;
94 inode
->i_fop
= &afs_file_operations
;
95 inode
->i_mapping
->a_ops
= &afs_fs_aops
;
98 inode
->i_mode
= S_IFDIR
| status
->mode
;
99 inode
->i_op
= &afs_dir_inode_operations
;
100 inode
->i_fop
= &afs_dir_file_operations
;
101 inode
->i_mapping
->a_ops
= &afs_dir_aops
;
103 case AFS_FTYPE_SYMLINK
:
104 /* Symlinks with a mode of 0644 are actually mountpoints. */
105 if ((status
->mode
& 0777) == 0644) {
106 inode
->i_flags
|= S_AUTOMOUNT
;
108 set_bit(AFS_VNODE_MOUNTPOINT
, &vnode
->flags
);
110 inode
->i_mode
= S_IFDIR
| 0555;
111 inode
->i_op
= &afs_mntpt_inode_operations
;
112 inode
->i_fop
= &afs_mntpt_file_operations
;
113 inode
->i_mapping
->a_ops
= &afs_fs_aops
;
115 inode
->i_mode
= S_IFLNK
| status
->mode
;
116 inode
->i_op
= &afs_symlink_inode_operations
;
117 inode
->i_mapping
->a_ops
= &afs_fs_aops
;
119 inode_nohighmem(inode
);
122 dump_vnode(vnode
, parent_vnode
);
123 write_sequnlock(&vnode
->cb_lock
);
124 return afs_protocol_error(NULL
, -EBADMSG
, afs_eproto_file_type
);
128 * Estimate 512 bytes blocks used, rounded up to nearest 1K
129 * for consistency with other AFS clients.
131 inode
->i_blocks
= ((i_size_read(inode
) + 1023) >> 10) << 1;
132 i_size_write(&vnode
->vfs_inode
, status
->size
);
134 vnode
->invalid_before
= status
->data_version
;
135 inode_set_iversion_raw(&vnode
->vfs_inode
, status
->data_version
);
138 /* it's a symlink we just created (the fileserver
139 * didn't give us a callback) */
140 vnode
->cb_expires_at
= ktime_get_real_seconds();
142 vnode
->cb_expires_at
= scb
->callback
.expires_at
;
143 old_cbi
= rcu_dereference_protected(vnode
->cb_interest
,
144 lockdep_is_held(&vnode
->cb_lock
.lock
));
146 rcu_assign_pointer(vnode
->cb_interest
, afs_get_cb_interest(cbi
));
149 set_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
);
152 write_sequnlock(&vnode
->cb_lock
);
153 afs_put_cb_interest(afs_v2net(vnode
), old_cbi
);
158 * Update the core inode struct from a returned status record.
160 static void afs_apply_status(struct afs_fs_cursor
*fc
,
161 struct afs_vnode
*vnode
,
162 struct afs_status_cb
*scb
,
163 const afs_dataversion_t
*expected_version
)
165 struct afs_file_status
*status
= &scb
->status
;
168 bool data_changed
= false;
170 BUG_ON(test_bit(AFS_VNODE_UNSET
, &vnode
->flags
));
172 if (status
->type
!= vnode
->status
.type
) {
173 pr_warning("Vnode %llx:%llx:%x changed type %u to %u\n",
177 status
->type
, vnode
->status
.type
);
178 afs_protocol_error(NULL
, -EBADMSG
, afs_eproto_bad_status
);
182 if (status
->nlink
!= vnode
->status
.nlink
)
183 set_nlink(&vnode
->vfs_inode
, status
->nlink
);
185 if (status
->owner
!= vnode
->status
.owner
)
186 vnode
->vfs_inode
.i_uid
= make_kuid(&init_user_ns
, status
->owner
);
188 if (status
->group
!= vnode
->status
.group
)
189 vnode
->vfs_inode
.i_gid
= make_kgid(&init_user_ns
, status
->group
);
191 if (status
->mode
!= vnode
->status
.mode
) {
192 mode
= vnode
->vfs_inode
.i_mode
;
194 mode
|= status
->mode
;
195 WRITE_ONCE(vnode
->vfs_inode
.i_mode
, mode
);
198 t
= status
->mtime_client
;
199 vnode
->vfs_inode
.i_ctime
= t
;
200 vnode
->vfs_inode
.i_mtime
= t
;
201 vnode
->vfs_inode
.i_atime
= t
;
203 if (vnode
->status
.data_version
!= status
->data_version
)
206 vnode
->status
= *status
;
208 if (expected_version
&&
209 *expected_version
!= status
->data_version
) {
210 kdebug("vnode modified %llx on {%llx:%llu} [exp %llx] %s",
211 (unsigned long long) status
->data_version
,
212 vnode
->fid
.vid
, vnode
->fid
.vnode
,
213 (unsigned long long) *expected_version
,
214 fc
->type
? fc
->type
->name
: "???");
215 vnode
->invalid_before
= status
->data_version
;
216 if (vnode
->status
.type
== AFS_FTYPE_DIR
) {
217 if (test_and_clear_bit(AFS_VNODE_DIR_VALID
, &vnode
->flags
))
218 afs_stat_v(vnode
, n_inval
);
220 set_bit(AFS_VNODE_ZAP_DATA
, &vnode
->flags
);
222 } else if (vnode
->status
.type
== AFS_FTYPE_DIR
) {
223 /* Expected directory change is handled elsewhere so
224 * that we can locally edit the directory and save on a
227 if (test_bit(AFS_VNODE_DIR_VALID
, &vnode
->flags
))
228 data_changed
= false;
232 inode_set_iversion_raw(&vnode
->vfs_inode
, status
->data_version
);
233 i_size_write(&vnode
->vfs_inode
, status
->size
);
238 * Apply a callback to a vnode.
240 static void afs_apply_callback(struct afs_fs_cursor
*fc
,
241 struct afs_vnode
*vnode
,
242 struct afs_status_cb
*scb
,
243 unsigned int cb_break
)
245 struct afs_cb_interest
*old
;
246 struct afs_callback
*cb
= &scb
->callback
;
248 if (!afs_cb_is_broken(cb_break
, vnode
, fc
->cbi
)) {
249 vnode
->cb_expires_at
= cb
->expires_at
;
250 old
= rcu_dereference_protected(vnode
->cb_interest
,
251 lockdep_is_held(&vnode
->cb_lock
.lock
));
252 if (old
!= fc
->cbi
) {
253 rcu_assign_pointer(vnode
->cb_interest
, afs_get_cb_interest(fc
->cbi
));
254 afs_put_cb_interest(afs_v2net(vnode
), old
);
256 set_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
);
261 * Apply the received status and callback to an inode all in the same critical
262 * section to avoid races with afs_validate().
264 void afs_vnode_commit_status(struct afs_fs_cursor
*fc
,
265 struct afs_vnode
*vnode
,
266 unsigned int cb_break
,
267 const afs_dataversion_t
*expected_version
,
268 struct afs_status_cb
*scb
)
270 if (fc
->ac
.error
!= 0)
273 write_seqlock(&vnode
->cb_lock
);
275 if (scb
->have_error
) {
276 if (scb
->status
.abort_code
== VNOVNODE
) {
277 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
278 clear_nlink(&vnode
->vfs_inode
);
279 __afs_break_callback(vnode
);
282 if (scb
->have_status
)
283 afs_apply_status(fc
, vnode
, scb
, expected_version
);
285 afs_apply_callback(fc
, vnode
, scb
, cb_break
);
288 write_sequnlock(&vnode
->cb_lock
);
290 if (fc
->ac
.error
== 0 && scb
->have_status
)
291 afs_cache_permit(vnode
, fc
->key
, cb_break
, scb
);
295 * Fetch file status from the volume.
297 int afs_fetch_status(struct afs_vnode
*vnode
, struct key
*key
, bool is_new
,
298 afs_access_t
*_caller_access
)
300 struct afs_status_cb
*scb
;
301 struct afs_fs_cursor fc
;
304 _enter("%s,{%llx:%llu.%u,S=%lx}",
306 vnode
->fid
.vid
, vnode
->fid
.vnode
, vnode
->fid
.unique
,
309 scb
= kzalloc(sizeof(struct afs_status_cb
), GFP_KERNEL
);
314 if (afs_begin_vnode_operation(&fc
, vnode
, key
, true)) {
315 afs_dataversion_t data_version
= vnode
->status
.data_version
;
317 while (afs_select_fileserver(&fc
)) {
318 fc
.cb_break
= afs_calc_vnode_cb_break(vnode
);
319 afs_fs_fetch_file_status(&fc
, scb
, NULL
);
325 ret
= afs_inode_init_from_status(vnode
, key
, fc
.cbi
,
329 afs_cache_permit(vnode
, key
, fc
.cb_break
, scb
);
331 afs_vnode_commit_status(&fc
, vnode
, fc
.cb_break
,
334 afs_check_for_remote_deletion(&fc
, vnode
);
335 ret
= afs_end_vnode_operation(&fc
);
338 if (ret
== 0 && _caller_access
)
339 *_caller_access
= scb
->status
.caller_access
;
341 _leave(" = %d", ret
);
348 int afs_iget5_test(struct inode
*inode
, void *opaque
)
350 struct afs_iget_data
*iget_data
= opaque
;
351 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
353 return memcmp(&vnode
->fid
, &iget_data
->fid
, sizeof(iget_data
->fid
)) == 0;
357 * iget5() comparator for inode created by autocell operations
359 * These pseudo inodes don't match anything.
361 static int afs_iget5_pseudo_dir_test(struct inode
*inode
, void *opaque
)
367 * iget5() inode initialiser
369 static int afs_iget5_set(struct inode
*inode
, void *opaque
)
371 struct afs_iget_data
*iget_data
= opaque
;
372 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
374 vnode
->fid
= iget_data
->fid
;
375 vnode
->volume
= iget_data
->volume
;
376 vnode
->cb_v_break
= iget_data
->cb_v_break
;
377 vnode
->cb_s_break
= iget_data
->cb_s_break
;
379 /* YFS supports 96-bit vnode IDs, but Linux only supports
380 * 64-bit inode numbers.
382 inode
->i_ino
= iget_data
->fid
.vnode
;
383 inode
->i_generation
= iget_data
->fid
.unique
;
388 * Create an inode for a dynamic root directory or an autocell dynamic
391 struct inode
*afs_iget_pseudo_dir(struct super_block
*sb
, bool root
)
393 struct afs_super_info
*as
;
394 struct afs_vnode
*vnode
;
396 static atomic_t afs_autocell_ino
;
398 struct afs_iget_data iget_data
= {
407 iget_data
.volume
= as
->volume
;
408 iget_data
.fid
.vid
= as
->volume
->vid
;
411 iget_data
.fid
.vnode
= 1;
412 iget_data
.fid
.unique
= 1;
414 iget_data
.fid
.vnode
= atomic_inc_return(&afs_autocell_ino
);
415 iget_data
.fid
.unique
= 0;
418 inode
= iget5_locked(sb
, iget_data
.fid
.vnode
,
419 afs_iget5_pseudo_dir_test
, afs_iget5_set
,
422 _leave(" = -ENOMEM");
423 return ERR_PTR(-ENOMEM
);
426 _debug("GOT INODE %p { ino=%lu, vl=%llx, vn=%llx, u=%x }",
427 inode
, inode
->i_ino
, iget_data
.fid
.vid
, iget_data
.fid
.vnode
,
428 iget_data
.fid
.unique
);
430 vnode
= AFS_FS_I(inode
);
432 /* there shouldn't be an existing inode */
433 BUG_ON(!(inode
->i_state
& I_NEW
));
436 inode
->i_mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
;
438 inode
->i_op
= &afs_dynroot_inode_operations
;
439 inode
->i_fop
= &afs_dynroot_file_operations
;
441 inode
->i_op
= &afs_autocell_inode_operations
;
444 inode
->i_uid
= GLOBAL_ROOT_UID
;
445 inode
->i_gid
= GLOBAL_ROOT_GID
;
446 inode
->i_ctime
= inode
->i_atime
= inode
->i_mtime
= current_time(inode
);
448 inode_set_iversion_raw(inode
, 0);
449 inode
->i_generation
= 0;
451 set_bit(AFS_VNODE_PSEUDODIR
, &vnode
->flags
);
453 set_bit(AFS_VNODE_MOUNTPOINT
, &vnode
->flags
);
454 inode
->i_flags
|= S_AUTOMOUNT
;
457 inode
->i_flags
|= S_NOATIME
;
458 unlock_new_inode(inode
);
459 _leave(" = %p", inode
);
464 * Get a cache cookie for an inode.
466 static void afs_get_inode_cache(struct afs_vnode
*vnode
)
468 #ifdef CONFIG_AFS_FSCACHE
472 u32 vnode_id_ext
[2]; /* Allow for a 96-bit key */
474 struct afs_vnode_cache_aux aux
;
476 if (vnode
->status
.type
== AFS_FTYPE_DIR
) {
481 key
.vnode_id
= vnode
->fid
.vnode
;
482 key
.unique
= vnode
->fid
.unique
;
483 key
.vnode_id_ext
[0] = vnode
->fid
.vnode
>> 32;
484 key
.vnode_id_ext
[1] = vnode
->fid
.vnode_hi
;
485 aux
.data_version
= vnode
->status
.data_version
;
487 vnode
->cache
= fscache_acquire_cookie(vnode
->volume
->cache
,
488 &afs_vnode_cache_index_def
,
491 vnode
, vnode
->status
.size
, true);
498 struct inode
*afs_iget(struct super_block
*sb
, struct key
*key
,
499 struct afs_iget_data
*iget_data
,
500 struct afs_status_cb
*scb
,
501 struct afs_cb_interest
*cbi
,
502 struct afs_vnode
*parent_vnode
)
504 struct afs_super_info
*as
;
505 struct afs_vnode
*vnode
;
506 struct afs_fid
*fid
= &iget_data
->fid
;
510 _enter(",{%llx:%llu.%u},,", fid
->vid
, fid
->vnode
, fid
->unique
);
513 iget_data
->volume
= as
->volume
;
515 inode
= iget5_locked(sb
, fid
->vnode
, afs_iget5_test
, afs_iget5_set
,
518 _leave(" = -ENOMEM");
519 return ERR_PTR(-ENOMEM
);
522 _debug("GOT INODE %p { vl=%llx vn=%llx, u=%x }",
523 inode
, fid
->vid
, fid
->vnode
, fid
->unique
);
525 vnode
= AFS_FS_I(inode
);
527 /* deal with an existing inode */
528 if (!(inode
->i_state
& I_NEW
)) {
529 _leave(" = %p", inode
);
534 /* it's a remotely extant inode */
535 ret
= afs_fetch_status(vnode
, key
, true, NULL
);
539 ret
= afs_inode_init_from_status(vnode
, key
, cbi
, parent_vnode
,
545 afs_get_inode_cache(vnode
);
548 clear_bit(AFS_VNODE_UNSET
, &vnode
->flags
);
549 inode
->i_flags
|= S_NOATIME
;
550 unlock_new_inode(inode
);
551 _leave(" = %p", inode
);
557 _leave(" = %d [bad]", ret
);
562 * mark the data attached to an inode as obsolete due to a write on the server
563 * - might also want to ditch all the outstanding writes and dirty pages
565 void afs_zap_data(struct afs_vnode
*vnode
)
567 _enter("{%llx:%llu}", vnode
->fid
.vid
, vnode
->fid
.vnode
);
569 #ifdef CONFIG_AFS_FSCACHE
570 fscache_invalidate(vnode
->cache
);
573 /* nuke all the non-dirty pages that aren't locked, mapped or being
574 * written back in a regular file and completely discard the pages in a
575 * directory or symlink */
576 if (S_ISREG(vnode
->vfs_inode
.i_mode
))
577 invalidate_remote_inode(&vnode
->vfs_inode
);
579 invalidate_inode_pages2(vnode
->vfs_inode
.i_mapping
);
583 * Check the validity of a vnode/inode.
585 bool afs_check_validity(struct afs_vnode
*vnode
)
587 struct afs_cb_interest
*cbi
;
588 struct afs_server
*server
;
589 struct afs_volume
*volume
= vnode
->volume
;
590 time64_t now
= ktime_get_real_seconds();
591 bool valid
, need_clear
= false;
592 unsigned int cb_break
, cb_s_break
, cb_v_break
;
596 read_seqbegin_or_lock(&vnode
->cb_lock
, &seq
);
597 cb_v_break
= READ_ONCE(volume
->cb_v_break
);
598 cb_break
= vnode
->cb_break
;
600 if (test_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
)) {
601 cbi
= rcu_dereference(vnode
->cb_interest
);
602 server
= rcu_dereference(cbi
->server
);
603 cb_s_break
= READ_ONCE(server
->cb_s_break
);
605 if (vnode
->cb_s_break
!= cb_s_break
||
606 vnode
->cb_v_break
!= cb_v_break
) {
607 vnode
->cb_s_break
= cb_s_break
;
608 vnode
->cb_v_break
= cb_v_break
;
611 } else if (test_bit(AFS_VNODE_ZAP_DATA
, &vnode
->flags
)) {
614 } else if (vnode
->cb_expires_at
- 10 <= now
) {
620 } else if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
)) {
623 vnode
->cb_v_break
= cb_v_break
;
627 } while (need_seqretry(&vnode
->cb_lock
, seq
));
629 done_seqretry(&vnode
->cb_lock
, seq
);
632 write_seqlock(&vnode
->cb_lock
);
633 if (cb_break
== vnode
->cb_break
)
634 __afs_break_callback(vnode
);
635 write_sequnlock(&vnode
->cb_lock
);
643 * validate a vnode/inode
644 * - there are several things we need to check
645 * - parent dir data changes (rm, rmdir, rename, mkdir, create, link,
647 * - parent dir metadata changed (security changes)
648 * - dentry data changed (write, truncate)
649 * - dentry metadata changed (security changes)
651 int afs_validate(struct afs_vnode
*vnode
, struct key
*key
)
656 _enter("{v={%llx:%llu} fl=%lx},%x",
657 vnode
->fid
.vid
, vnode
->fid
.vnode
, vnode
->flags
,
661 valid
= afs_check_validity(vnode
);
664 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
))
665 clear_nlink(&vnode
->vfs_inode
);
670 down_write(&vnode
->validate_lock
);
672 /* if the promise has expired, we need to check the server again to get
673 * a new promise - note that if the (parent) directory's metadata was
674 * changed then the security may be different and we may no longer have
676 if (!test_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
)) {
677 _debug("not promised");
678 ret
= afs_fetch_status(vnode
, key
, false, NULL
);
680 if (ret
== -ENOENT
) {
681 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
686 _debug("new promise [fl=%lx]", vnode
->flags
);
689 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
)) {
690 _debug("file already deleted");
695 /* if the vnode's data version number changed then its contents are
697 if (test_and_clear_bit(AFS_VNODE_ZAP_DATA
, &vnode
->flags
))
699 up_write(&vnode
->validate_lock
);
705 up_write(&vnode
->validate_lock
);
706 _leave(" = %d", ret
);
711 * read the attributes of an inode
713 int afs_getattr(const struct path
*path
, struct kstat
*stat
,
714 u32 request_mask
, unsigned int query_flags
)
716 struct inode
*inode
= d_inode(path
->dentry
);
717 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
720 _enter("{ ino=%lu v=%u }", inode
->i_ino
, inode
->i_generation
);
723 read_seqbegin_or_lock(&vnode
->cb_lock
, &seq
);
724 generic_fillattr(inode
, stat
);
725 } while (need_seqretry(&vnode
->cb_lock
, seq
));
727 done_seqretry(&vnode
->cb_lock
, seq
);
732 * discard an AFS inode
734 int afs_drop_inode(struct inode
*inode
)
738 if (test_bit(AFS_VNODE_PSEUDODIR
, &AFS_FS_I(inode
)->flags
))
739 return generic_delete_inode(inode
);
741 return generic_drop_inode(inode
);
747 void afs_evict_inode(struct inode
*inode
)
749 struct afs_cb_interest
*cbi
;
750 struct afs_vnode
*vnode
;
752 vnode
= AFS_FS_I(inode
);
754 _enter("{%llx:%llu.%d}",
759 _debug("CLEAR INODE %p", inode
);
761 ASSERTCMP(inode
->i_ino
, ==, vnode
->fid
.vnode
);
763 truncate_inode_pages_final(&inode
->i_data
);
766 write_seqlock(&vnode
->cb_lock
);
767 cbi
= rcu_dereference_protected(vnode
->cb_interest
,
768 lockdep_is_held(&vnode
->cb_lock
.lock
));
770 afs_put_cb_interest(afs_i2net(inode
), cbi
);
771 rcu_assign_pointer(vnode
->cb_interest
, NULL
);
773 write_sequnlock(&vnode
->cb_lock
);
775 while (!list_empty(&vnode
->wb_keys
)) {
776 struct afs_wb_key
*wbk
= list_entry(vnode
->wb_keys
.next
,
777 struct afs_wb_key
, vnode_link
);
778 list_del(&wbk
->vnode_link
);
782 #ifdef CONFIG_AFS_FSCACHE
784 struct afs_vnode_cache_aux aux
;
786 aux
.data_version
= vnode
->status
.data_version
;
787 fscache_relinquish_cookie(vnode
->cache
, &aux
,
788 test_bit(AFS_VNODE_DELETED
, &vnode
->flags
));
793 afs_prune_wb_keys(vnode
);
794 afs_put_permits(rcu_access_pointer(vnode
->permit_cache
));
795 key_put(vnode
->silly_key
);
796 vnode
->silly_key
= NULL
;
797 key_put(vnode
->lock_key
);
798 vnode
->lock_key
= NULL
;
803 * set the attributes of an inode
805 int afs_setattr(struct dentry
*dentry
, struct iattr
*attr
)
807 struct afs_fs_cursor fc
;
808 struct afs_status_cb
*scb
;
809 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(dentry
));
813 _enter("{%llx:%llu},{n=%pd},%x",
814 vnode
->fid
.vid
, vnode
->fid
.vnode
, dentry
,
817 if (!(attr
->ia_valid
& (ATTR_SIZE
| ATTR_MODE
| ATTR_UID
| ATTR_GID
|
819 _leave(" = 0 [unsupported]");
823 scb
= kzalloc(sizeof(struct afs_status_cb
), GFP_KERNEL
);
827 /* flush any dirty data outstanding on a regular file */
828 if (S_ISREG(vnode
->vfs_inode
.i_mode
))
829 filemap_write_and_wait(vnode
->vfs_inode
.i_mapping
);
831 if (attr
->ia_valid
& ATTR_FILE
) {
832 key
= afs_file_key(attr
->ia_file
);
834 key
= afs_request_key(vnode
->volume
->cell
);
842 if (afs_begin_vnode_operation(&fc
, vnode
, key
, false)) {
843 afs_dataversion_t data_version
= vnode
->status
.data_version
;
845 if (attr
->ia_valid
& ATTR_SIZE
)
848 while (afs_select_fileserver(&fc
)) {
849 fc
.cb_break
= afs_calc_vnode_cb_break(vnode
);
850 afs_fs_setattr(&fc
, attr
, scb
);
853 afs_check_for_remote_deletion(&fc
, vnode
);
854 afs_vnode_commit_status(&fc
, vnode
, fc
.cb_break
,
856 ret
= afs_end_vnode_operation(&fc
);
859 if (!(attr
->ia_valid
& ATTR_FILE
))
865 _leave(" = %d", ret
);