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>
27 static const struct inode_operations afs_symlink_inode_operations
= {
28 .get_link
= page_get_link
,
29 .listxattr
= afs_listxattr
,
32 static noinline
void dump_vnode(struct afs_vnode
*vnode
, struct afs_vnode
*parent_vnode
)
34 static unsigned long once_only
;
36 pr_warn("kAFS: AFS vnode with undefined type %u\n",
38 pr_warn("kAFS: A=%d m=%o s=%llx v=%llx\n",
39 vnode
->status
.abort_code
,
42 vnode
->status
.data_version
);
43 pr_warn("kAFS: vnode %llx:%llx:%x\n",
48 pr_warn("kAFS: dir %llx:%llx:%x\n",
49 parent_vnode
->fid
.vid
,
50 parent_vnode
->fid
.vnode
,
51 parent_vnode
->fid
.unique
);
53 if (!test_and_set_bit(0, &once_only
))
58 * Initialise an inode from the vnode status.
60 static int afs_inode_init_from_status(struct afs_vnode
*vnode
, struct key
*key
,
61 struct afs_cb_interest
*cbi
,
62 struct afs_vnode
*parent_vnode
,
63 struct afs_status_cb
*scb
)
65 struct afs_cb_interest
*old_cbi
= NULL
;
66 struct afs_file_status
*status
= &scb
->status
;
67 struct inode
*inode
= AFS_VNODE_TO_I(vnode
);
70 _debug("FS: ft=%d lk=%d sz=%llu ver=%Lu mod=%hu",
73 (unsigned long long) status
->size
,
77 write_seqlock(&vnode
->cb_lock
);
79 vnode
->status
= *status
;
81 t
= status
->mtime_client
;
85 inode
->i_uid
= make_kuid(&init_user_ns
, status
->owner
);
86 inode
->i_gid
= make_kgid(&init_user_ns
, status
->group
);
87 set_nlink(&vnode
->vfs_inode
, status
->nlink
);
89 switch (status
->type
) {
91 inode
->i_mode
= S_IFREG
| status
->mode
;
92 inode
->i_op
= &afs_file_inode_operations
;
93 inode
->i_fop
= &afs_file_operations
;
94 inode
->i_mapping
->a_ops
= &afs_fs_aops
;
97 inode
->i_mode
= S_IFDIR
| status
->mode
;
98 inode
->i_op
= &afs_dir_inode_operations
;
99 inode
->i_fop
= &afs_dir_file_operations
;
100 inode
->i_mapping
->a_ops
= &afs_dir_aops
;
102 case AFS_FTYPE_SYMLINK
:
103 /* Symlinks with a mode of 0644 are actually mountpoints. */
104 if ((status
->mode
& 0777) == 0644) {
105 inode
->i_flags
|= S_AUTOMOUNT
;
107 set_bit(AFS_VNODE_MOUNTPOINT
, &vnode
->flags
);
109 inode
->i_mode
= S_IFDIR
| 0555;
110 inode
->i_op
= &afs_mntpt_inode_operations
;
111 inode
->i_fop
= &afs_mntpt_file_operations
;
112 inode
->i_mapping
->a_ops
= &afs_fs_aops
;
114 inode
->i_mode
= S_IFLNK
| status
->mode
;
115 inode
->i_op
= &afs_symlink_inode_operations
;
116 inode
->i_mapping
->a_ops
= &afs_fs_aops
;
118 inode_nohighmem(inode
);
121 dump_vnode(vnode
, parent_vnode
);
122 write_sequnlock(&vnode
->cb_lock
);
123 return afs_protocol_error(NULL
, -EBADMSG
, afs_eproto_file_type
);
127 * Estimate 512 bytes blocks used, rounded up to nearest 1K
128 * for consistency with other AFS clients.
130 inode
->i_blocks
= ((i_size_read(inode
) + 1023) >> 10) << 1;
131 i_size_write(&vnode
->vfs_inode
, status
->size
);
133 vnode
->invalid_before
= status
->data_version
;
134 inode_set_iversion_raw(&vnode
->vfs_inode
, status
->data_version
);
137 /* it's a symlink we just created (the fileserver
138 * didn't give us a callback) */
139 vnode
->cb_version
= 0;
141 vnode
->cb_expires_at
= ktime_get_real_seconds();
143 vnode
->cb_version
= scb
->callback
.version
;
144 vnode
->cb_type
= scb
->callback
.type
;
145 vnode
->cb_expires_at
= scb
->callback
.expires_at
;
146 old_cbi
= vnode
->cb_interest
;
148 vnode
->cb_interest
= afs_get_cb_interest(cbi
);
151 set_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
);
154 write_sequnlock(&vnode
->cb_lock
);
155 afs_put_cb_interest(afs_v2net(vnode
), old_cbi
);
160 * Update the core inode struct from a returned status record.
162 static void afs_apply_status(struct afs_fs_cursor
*fc
,
163 struct afs_vnode
*vnode
,
164 struct afs_status_cb
*scb
,
165 const afs_dataversion_t
*expected_version
)
167 struct afs_file_status
*status
= &scb
->status
;
170 bool data_changed
= false;
172 BUG_ON(test_bit(AFS_VNODE_UNSET
, &vnode
->flags
));
174 if (status
->type
!= vnode
->status
.type
) {
175 pr_warning("Vnode %llx:%llx:%x changed type %u to %u\n",
179 status
->type
, vnode
->status
.type
);
180 afs_protocol_error(NULL
, -EBADMSG
, afs_eproto_bad_status
);
184 if (status
->nlink
!= vnode
->status
.nlink
)
185 set_nlink(&vnode
->vfs_inode
, status
->nlink
);
187 if (status
->owner
!= vnode
->status
.owner
)
188 vnode
->vfs_inode
.i_uid
= make_kuid(&init_user_ns
, status
->owner
);
190 if (status
->group
!= vnode
->status
.group
)
191 vnode
->vfs_inode
.i_gid
= make_kgid(&init_user_ns
, status
->group
);
193 if (status
->mode
!= vnode
->status
.mode
) {
194 mode
= vnode
->vfs_inode
.i_mode
;
196 mode
|= status
->mode
;
197 WRITE_ONCE(vnode
->vfs_inode
.i_mode
, mode
);
200 t
= status
->mtime_client
;
201 vnode
->vfs_inode
.i_ctime
= t
;
202 vnode
->vfs_inode
.i_mtime
= t
;
203 vnode
->vfs_inode
.i_atime
= t
;
205 if (vnode
->status
.data_version
!= status
->data_version
)
208 vnode
->status
= *status
;
210 if (expected_version
&&
211 *expected_version
!= status
->data_version
) {
212 kdebug("vnode modified %llx on {%llx:%llu} [exp %llx] %s",
213 (unsigned long long) status
->data_version
,
214 vnode
->fid
.vid
, vnode
->fid
.vnode
,
215 (unsigned long long) *expected_version
,
216 fc
->type
? fc
->type
->name
: "???");
217 vnode
->invalid_before
= status
->data_version
;
218 if (vnode
->status
.type
== AFS_FTYPE_DIR
) {
219 if (test_and_clear_bit(AFS_VNODE_DIR_VALID
, &vnode
->flags
))
220 afs_stat_v(vnode
, n_inval
);
222 set_bit(AFS_VNODE_ZAP_DATA
, &vnode
->flags
);
224 } else if (vnode
->status
.type
== AFS_FTYPE_DIR
) {
225 /* Expected directory change is handled elsewhere so
226 * that we can locally edit the directory and save on a
229 if (test_bit(AFS_VNODE_DIR_VALID
, &vnode
->flags
))
230 data_changed
= false;
234 inode_set_iversion_raw(&vnode
->vfs_inode
, status
->data_version
);
235 i_size_write(&vnode
->vfs_inode
, status
->size
);
240 * Apply a callback to a vnode.
242 static void afs_apply_callback(struct afs_fs_cursor
*fc
,
243 struct afs_vnode
*vnode
,
244 struct afs_status_cb
*scb
,
245 unsigned int cb_break
)
247 struct afs_cb_interest
*old
;
248 struct afs_callback
*cb
= &scb
->callback
;
250 if (!afs_cb_is_broken(cb_break
, vnode
, fc
->cbi
)) {
251 vnode
->cb_version
= cb
->version
;
252 vnode
->cb_type
= cb
->type
;
253 vnode
->cb_expires_at
= cb
->expires_at
;
254 old
= vnode
->cb_interest
;
255 if (old
!= fc
->cbi
) {
256 vnode
->cb_interest
= afs_get_cb_interest(fc
->cbi
);
257 afs_put_cb_interest(afs_v2net(vnode
), old
);
259 set_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
);
264 * Apply the received status and callback to an inode all in the same critical
265 * section to avoid races with afs_validate().
267 void afs_vnode_commit_status(struct afs_fs_cursor
*fc
,
268 struct afs_vnode
*vnode
,
269 unsigned int cb_break
,
270 const afs_dataversion_t
*expected_version
,
271 struct afs_status_cb
*scb
)
273 if (fc
->ac
.error
!= 0)
276 write_seqlock(&vnode
->cb_lock
);
278 afs_apply_status(fc
, vnode
, scb
, expected_version
);
280 afs_apply_callback(fc
, vnode
, scb
, cb_break
);
282 write_sequnlock(&vnode
->cb_lock
);
284 if (fc
->ac
.error
== 0)
285 afs_cache_permit(vnode
, fc
->key
, cb_break
, scb
);
289 * Fetch file status from the volume.
291 int afs_fetch_status(struct afs_vnode
*vnode
, struct key
*key
, bool is_new
,
292 afs_access_t
*_caller_access
)
294 struct afs_status_cb
*scb
;
295 struct afs_fs_cursor fc
;
298 _enter("%s,{%llx:%llu.%u,S=%lx}",
300 vnode
->fid
.vid
, vnode
->fid
.vnode
, vnode
->fid
.unique
,
303 scb
= kzalloc(sizeof(struct afs_status_cb
), GFP_KERNEL
);
308 if (afs_begin_vnode_operation(&fc
, vnode
, key
, true)) {
309 afs_dataversion_t data_version
= vnode
->status
.data_version
;
311 while (afs_select_fileserver(&fc
)) {
312 fc
.cb_break
= afs_calc_vnode_cb_break(vnode
);
313 afs_fs_fetch_file_status(&fc
, scb
, NULL
);
319 ret
= afs_inode_init_from_status(vnode
, key
, fc
.cbi
,
323 afs_cache_permit(vnode
, key
, fc
.cb_break
, scb
);
325 afs_vnode_commit_status(&fc
, vnode
, fc
.cb_break
,
328 afs_check_for_remote_deletion(&fc
, vnode
);
329 ret
= afs_end_vnode_operation(&fc
);
332 if (ret
== 0 && _caller_access
)
333 *_caller_access
= scb
->status
.caller_access
;
335 _leave(" = %d", ret
);
342 int afs_iget5_test(struct inode
*inode
, void *opaque
)
344 struct afs_iget_data
*data
= opaque
;
345 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
347 return memcmp(&vnode
->fid
, &data
->fid
, sizeof(data
->fid
)) == 0;
351 * iget5() comparator for inode created by autocell operations
353 * These pseudo inodes don't match anything.
355 static int afs_iget5_pseudo_dir_test(struct inode
*inode
, void *opaque
)
361 * iget5() inode initialiser
363 static int afs_iget5_set(struct inode
*inode
, void *opaque
)
365 struct afs_iget_data
*data
= opaque
;
366 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
368 vnode
->fid
= data
->fid
;
369 vnode
->volume
= data
->volume
;
371 /* YFS supports 96-bit vnode IDs, but Linux only supports
372 * 64-bit inode numbers.
374 inode
->i_ino
= data
->fid
.vnode
;
375 inode
->i_generation
= data
->fid
.unique
;
380 * Create an inode for a dynamic root directory or an autocell dynamic
383 struct inode
*afs_iget_pseudo_dir(struct super_block
*sb
, bool root
)
385 struct afs_iget_data data
;
386 struct afs_super_info
*as
;
387 struct afs_vnode
*vnode
;
389 static atomic_t afs_autocell_ino
;
395 data
.volume
= as
->volume
;
396 data
.fid
.vid
= as
->volume
->vid
;
402 data
.fid
.vnode
= atomic_inc_return(&afs_autocell_ino
);
406 inode
= iget5_locked(sb
, data
.fid
.vnode
,
407 afs_iget5_pseudo_dir_test
, afs_iget5_set
,
410 _leave(" = -ENOMEM");
411 return ERR_PTR(-ENOMEM
);
414 _debug("GOT INODE %p { ino=%lu, vl=%llx, vn=%llx, u=%x }",
415 inode
, inode
->i_ino
, data
.fid
.vid
, data
.fid
.vnode
,
418 vnode
= AFS_FS_I(inode
);
420 /* there shouldn't be an existing inode */
421 BUG_ON(!(inode
->i_state
& I_NEW
));
424 inode
->i_mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
;
426 inode
->i_op
= &afs_dynroot_inode_operations
;
427 inode
->i_fop
= &afs_dynroot_file_operations
;
429 inode
->i_op
= &afs_autocell_inode_operations
;
432 inode
->i_uid
= GLOBAL_ROOT_UID
;
433 inode
->i_gid
= GLOBAL_ROOT_GID
;
434 inode
->i_ctime
= inode
->i_atime
= inode
->i_mtime
= current_time(inode
);
436 inode_set_iversion_raw(inode
, 0);
437 inode
->i_generation
= 0;
439 set_bit(AFS_VNODE_PSEUDODIR
, &vnode
->flags
);
441 set_bit(AFS_VNODE_MOUNTPOINT
, &vnode
->flags
);
442 inode
->i_flags
|= S_AUTOMOUNT
;
445 inode
->i_flags
|= S_NOATIME
;
446 unlock_new_inode(inode
);
447 _leave(" = %p", inode
);
452 * Get a cache cookie for an inode.
454 static void afs_get_inode_cache(struct afs_vnode
*vnode
)
456 #ifdef CONFIG_AFS_FSCACHE
460 u32 vnode_id_ext
[2]; /* Allow for a 96-bit key */
462 struct afs_vnode_cache_aux aux
;
464 if (vnode
->status
.type
== AFS_FTYPE_DIR
) {
469 key
.vnode_id
= vnode
->fid
.vnode
;
470 key
.unique
= vnode
->fid
.unique
;
471 key
.vnode_id_ext
[0] = vnode
->fid
.vnode
>> 32;
472 key
.vnode_id_ext
[1] = vnode
->fid
.vnode_hi
;
473 aux
.data_version
= vnode
->status
.data_version
;
475 vnode
->cache
= fscache_acquire_cookie(vnode
->volume
->cache
,
476 &afs_vnode_cache_index_def
,
479 vnode
, vnode
->status
.size
, true);
486 struct inode
*afs_iget(struct super_block
*sb
, struct key
*key
,
487 struct afs_fid
*fid
, struct afs_status_cb
*scb
,
488 struct afs_cb_interest
*cbi
,
489 struct afs_vnode
*parent_vnode
)
491 struct afs_iget_data data
= { .fid
= *fid
};
492 struct afs_super_info
*as
;
493 struct afs_vnode
*vnode
;
497 _enter(",{%llx:%llu.%u},,", fid
->vid
, fid
->vnode
, fid
->unique
);
500 data
.volume
= as
->volume
;
502 inode
= iget5_locked(sb
, fid
->vnode
, afs_iget5_test
, afs_iget5_set
,
505 _leave(" = -ENOMEM");
506 return ERR_PTR(-ENOMEM
);
509 _debug("GOT INODE %p { vl=%llx vn=%llx, u=%x }",
510 inode
, fid
->vid
, fid
->vnode
, fid
->unique
);
512 vnode
= AFS_FS_I(inode
);
514 /* deal with an existing inode */
515 if (!(inode
->i_state
& I_NEW
)) {
516 _leave(" = %p", inode
);
521 /* it's a remotely extant inode */
522 ret
= afs_fetch_status(vnode
, key
, true, NULL
);
526 ret
= afs_inode_init_from_status(vnode
, key
, cbi
, parent_vnode
,
532 afs_get_inode_cache(vnode
);
535 clear_bit(AFS_VNODE_UNSET
, &vnode
->flags
);
536 inode
->i_flags
|= S_NOATIME
;
537 unlock_new_inode(inode
);
538 _leave(" = %p [CB { v=%u t=%u }]", inode
, vnode
->cb_version
, vnode
->cb_type
);
544 _leave(" = %d [bad]", ret
);
549 * mark the data attached to an inode as obsolete due to a write on the server
550 * - might also want to ditch all the outstanding writes and dirty pages
552 void afs_zap_data(struct afs_vnode
*vnode
)
554 _enter("{%llx:%llu}", vnode
->fid
.vid
, vnode
->fid
.vnode
);
556 #ifdef CONFIG_AFS_FSCACHE
557 fscache_invalidate(vnode
->cache
);
560 /* nuke all the non-dirty pages that aren't locked, mapped or being
561 * written back in a regular file and completely discard the pages in a
562 * directory or symlink */
563 if (S_ISREG(vnode
->vfs_inode
.i_mode
))
564 invalidate_remote_inode(&vnode
->vfs_inode
);
566 invalidate_inode_pages2(vnode
->vfs_inode
.i_mapping
);
570 * validate a vnode/inode
571 * - there are several things we need to check
572 * - parent dir data changes (rm, rmdir, rename, mkdir, create, link,
574 * - parent dir metadata changed (security changes)
575 * - dentry data changed (write, truncate)
576 * - dentry metadata changed (security changes)
578 int afs_validate(struct afs_vnode
*vnode
, struct key
*key
)
580 time64_t now
= ktime_get_real_seconds();
584 _enter("{v={%llx:%llu} fl=%lx},%x",
585 vnode
->fid
.vid
, vnode
->fid
.vnode
, vnode
->flags
,
588 /* Quickly check the callback state. Ideally, we'd use read_seqbegin
589 * here, but we have no way to pass the net namespace to the RCU
590 * cleanup for the server record.
592 read_seqlock_excl(&vnode
->cb_lock
);
594 if (test_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
)) {
595 if (vnode
->cb_s_break
!= vnode
->cb_interest
->server
->cb_s_break
||
596 vnode
->cb_v_break
!= vnode
->volume
->cb_v_break
) {
597 vnode
->cb_s_break
= vnode
->cb_interest
->server
->cb_s_break
;
598 vnode
->cb_v_break
= vnode
->volume
->cb_v_break
;
600 } else if (test_bit(AFS_VNODE_ZAP_DATA
, &vnode
->flags
)) {
602 } else if (vnode
->cb_expires_at
- 10 <= now
) {
607 } else if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
)) {
610 vnode
->cb_v_break
= vnode
->volume
->cb_v_break
;
614 read_sequnlock_excl(&vnode
->cb_lock
);
616 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
))
617 clear_nlink(&vnode
->vfs_inode
);
622 down_write(&vnode
->validate_lock
);
624 /* if the promise has expired, we need to check the server again to get
625 * a new promise - note that if the (parent) directory's metadata was
626 * changed then the security may be different and we may no longer have
628 if (!test_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
)) {
629 _debug("not promised");
630 ret
= afs_fetch_status(vnode
, key
, false, NULL
);
632 if (ret
== -ENOENT
) {
633 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
638 _debug("new promise [fl=%lx]", vnode
->flags
);
641 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
)) {
642 _debug("file already deleted");
647 /* if the vnode's data version number changed then its contents are
649 if (test_and_clear_bit(AFS_VNODE_ZAP_DATA
, &vnode
->flags
))
651 up_write(&vnode
->validate_lock
);
657 up_write(&vnode
->validate_lock
);
658 _leave(" = %d", ret
);
663 * read the attributes of an inode
665 int afs_getattr(const struct path
*path
, struct kstat
*stat
,
666 u32 request_mask
, unsigned int query_flags
)
668 struct inode
*inode
= d_inode(path
->dentry
);
669 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
672 _enter("{ ino=%lu v=%u }", inode
->i_ino
, inode
->i_generation
);
675 read_seqbegin_or_lock(&vnode
->cb_lock
, &seq
);
676 generic_fillattr(inode
, stat
);
677 } while (need_seqretry(&vnode
->cb_lock
, seq
));
679 done_seqretry(&vnode
->cb_lock
, seq
);
684 * discard an AFS inode
686 int afs_drop_inode(struct inode
*inode
)
690 if (test_bit(AFS_VNODE_PSEUDODIR
, &AFS_FS_I(inode
)->flags
))
691 return generic_delete_inode(inode
);
693 return generic_drop_inode(inode
);
699 void afs_evict_inode(struct inode
*inode
)
701 struct afs_vnode
*vnode
;
703 vnode
= AFS_FS_I(inode
);
705 _enter("{%llx:%llu.%d}",
710 _debug("CLEAR INODE %p", inode
);
712 ASSERTCMP(inode
->i_ino
, ==, vnode
->fid
.vnode
);
714 truncate_inode_pages_final(&inode
->i_data
);
717 if (vnode
->cb_interest
) {
718 afs_put_cb_interest(afs_i2net(inode
), vnode
->cb_interest
);
719 vnode
->cb_interest
= NULL
;
722 while (!list_empty(&vnode
->wb_keys
)) {
723 struct afs_wb_key
*wbk
= list_entry(vnode
->wb_keys
.next
,
724 struct afs_wb_key
, vnode_link
);
725 list_del(&wbk
->vnode_link
);
729 #ifdef CONFIG_AFS_FSCACHE
731 struct afs_vnode_cache_aux aux
;
733 aux
.data_version
= vnode
->status
.data_version
;
734 fscache_relinquish_cookie(vnode
->cache
, &aux
,
735 test_bit(AFS_VNODE_DELETED
, &vnode
->flags
));
740 afs_prune_wb_keys(vnode
);
741 afs_put_permits(rcu_access_pointer(vnode
->permit_cache
));
742 key_put(vnode
->silly_key
);
743 vnode
->silly_key
= NULL
;
744 key_put(vnode
->lock_key
);
745 vnode
->lock_key
= NULL
;
750 * set the attributes of an inode
752 int afs_setattr(struct dentry
*dentry
, struct iattr
*attr
)
754 struct afs_fs_cursor fc
;
755 struct afs_status_cb
*scb
;
756 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(dentry
));
760 _enter("{%llx:%llu},{n=%pd},%x",
761 vnode
->fid
.vid
, vnode
->fid
.vnode
, dentry
,
764 if (!(attr
->ia_valid
& (ATTR_SIZE
| ATTR_MODE
| ATTR_UID
| ATTR_GID
|
766 _leave(" = 0 [unsupported]");
770 scb
= kzalloc(sizeof(struct afs_status_cb
), GFP_KERNEL
);
774 /* flush any dirty data outstanding on a regular file */
775 if (S_ISREG(vnode
->vfs_inode
.i_mode
))
776 filemap_write_and_wait(vnode
->vfs_inode
.i_mapping
);
778 if (attr
->ia_valid
& ATTR_FILE
) {
779 key
= afs_file_key(attr
->ia_file
);
781 key
= afs_request_key(vnode
->volume
->cell
);
789 if (afs_begin_vnode_operation(&fc
, vnode
, key
, false)) {
790 afs_dataversion_t data_version
= vnode
->status
.data_version
;
792 if (attr
->ia_valid
& ATTR_SIZE
)
795 while (afs_select_fileserver(&fc
)) {
796 fc
.cb_break
= afs_calc_vnode_cb_break(vnode
);
797 afs_fs_setattr(&fc
, attr
, scb
);
800 afs_check_for_remote_deletion(&fc
, vnode
);
801 afs_vnode_commit_status(&fc
, vnode
, fc
.cb_break
,
803 ret
= afs_end_vnode_operation(&fc
);
806 if (!(attr
->ia_valid
& ATTR_FILE
))
812 _leave(" = %d", ret
);