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_expires_at
= ktime_get_real_seconds();
141 vnode
->cb_expires_at
= scb
->callback
.expires_at
;
142 old_cbi
= vnode
->cb_interest
;
144 vnode
->cb_interest
= afs_get_cb_interest(cbi
);
147 set_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
);
150 write_sequnlock(&vnode
->cb_lock
);
151 afs_put_cb_interest(afs_v2net(vnode
), old_cbi
);
156 * Update the core inode struct from a returned status record.
158 static void afs_apply_status(struct afs_fs_cursor
*fc
,
159 struct afs_vnode
*vnode
,
160 struct afs_status_cb
*scb
,
161 const afs_dataversion_t
*expected_version
)
163 struct afs_file_status
*status
= &scb
->status
;
166 bool data_changed
= false;
168 BUG_ON(test_bit(AFS_VNODE_UNSET
, &vnode
->flags
));
170 if (status
->type
!= vnode
->status
.type
) {
171 pr_warning("Vnode %llx:%llx:%x changed type %u to %u\n",
175 status
->type
, vnode
->status
.type
);
176 afs_protocol_error(NULL
, -EBADMSG
, afs_eproto_bad_status
);
180 if (status
->nlink
!= vnode
->status
.nlink
)
181 set_nlink(&vnode
->vfs_inode
, status
->nlink
);
183 if (status
->owner
!= vnode
->status
.owner
)
184 vnode
->vfs_inode
.i_uid
= make_kuid(&init_user_ns
, status
->owner
);
186 if (status
->group
!= vnode
->status
.group
)
187 vnode
->vfs_inode
.i_gid
= make_kgid(&init_user_ns
, status
->group
);
189 if (status
->mode
!= vnode
->status
.mode
) {
190 mode
= vnode
->vfs_inode
.i_mode
;
192 mode
|= status
->mode
;
193 WRITE_ONCE(vnode
->vfs_inode
.i_mode
, mode
);
196 t
= status
->mtime_client
;
197 vnode
->vfs_inode
.i_ctime
= t
;
198 vnode
->vfs_inode
.i_mtime
= t
;
199 vnode
->vfs_inode
.i_atime
= t
;
201 if (vnode
->status
.data_version
!= status
->data_version
)
204 vnode
->status
= *status
;
206 if (expected_version
&&
207 *expected_version
!= status
->data_version
) {
208 kdebug("vnode modified %llx on {%llx:%llu} [exp %llx] %s",
209 (unsigned long long) status
->data_version
,
210 vnode
->fid
.vid
, vnode
->fid
.vnode
,
211 (unsigned long long) *expected_version
,
212 fc
->type
? fc
->type
->name
: "???");
213 vnode
->invalid_before
= status
->data_version
;
214 if (vnode
->status
.type
== AFS_FTYPE_DIR
) {
215 if (test_and_clear_bit(AFS_VNODE_DIR_VALID
, &vnode
->flags
))
216 afs_stat_v(vnode
, n_inval
);
218 set_bit(AFS_VNODE_ZAP_DATA
, &vnode
->flags
);
220 } else if (vnode
->status
.type
== AFS_FTYPE_DIR
) {
221 /* Expected directory change is handled elsewhere so
222 * that we can locally edit the directory and save on a
225 if (test_bit(AFS_VNODE_DIR_VALID
, &vnode
->flags
))
226 data_changed
= false;
230 inode_set_iversion_raw(&vnode
->vfs_inode
, status
->data_version
);
231 i_size_write(&vnode
->vfs_inode
, status
->size
);
236 * Apply a callback to a vnode.
238 static void afs_apply_callback(struct afs_fs_cursor
*fc
,
239 struct afs_vnode
*vnode
,
240 struct afs_status_cb
*scb
,
241 unsigned int cb_break
)
243 struct afs_cb_interest
*old
;
244 struct afs_callback
*cb
= &scb
->callback
;
246 if (!afs_cb_is_broken(cb_break
, vnode
, fc
->cbi
)) {
247 vnode
->cb_expires_at
= cb
->expires_at
;
248 old
= vnode
->cb_interest
;
249 if (old
!= fc
->cbi
) {
250 vnode
->cb_interest
= afs_get_cb_interest(fc
->cbi
);
251 afs_put_cb_interest(afs_v2net(vnode
), old
);
253 set_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
);
258 * Apply the received status and callback to an inode all in the same critical
259 * section to avoid races with afs_validate().
261 void afs_vnode_commit_status(struct afs_fs_cursor
*fc
,
262 struct afs_vnode
*vnode
,
263 unsigned int cb_break
,
264 const afs_dataversion_t
*expected_version
,
265 struct afs_status_cb
*scb
)
267 if (fc
->ac
.error
!= 0)
270 write_seqlock(&vnode
->cb_lock
);
272 afs_apply_status(fc
, vnode
, scb
, expected_version
);
274 afs_apply_callback(fc
, vnode
, scb
, cb_break
);
276 write_sequnlock(&vnode
->cb_lock
);
278 if (fc
->ac
.error
== 0)
279 afs_cache_permit(vnode
, fc
->key
, cb_break
, scb
);
283 * Fetch file status from the volume.
285 int afs_fetch_status(struct afs_vnode
*vnode
, struct key
*key
, bool is_new
,
286 afs_access_t
*_caller_access
)
288 struct afs_status_cb
*scb
;
289 struct afs_fs_cursor fc
;
292 _enter("%s,{%llx:%llu.%u,S=%lx}",
294 vnode
->fid
.vid
, vnode
->fid
.vnode
, vnode
->fid
.unique
,
297 scb
= kzalloc(sizeof(struct afs_status_cb
), GFP_KERNEL
);
302 if (afs_begin_vnode_operation(&fc
, vnode
, key
, true)) {
303 afs_dataversion_t data_version
= vnode
->status
.data_version
;
305 while (afs_select_fileserver(&fc
)) {
306 fc
.cb_break
= afs_calc_vnode_cb_break(vnode
);
307 afs_fs_fetch_file_status(&fc
, scb
, NULL
);
313 ret
= afs_inode_init_from_status(vnode
, key
, fc
.cbi
,
317 afs_cache_permit(vnode
, key
, fc
.cb_break
, scb
);
319 afs_vnode_commit_status(&fc
, vnode
, fc
.cb_break
,
322 afs_check_for_remote_deletion(&fc
, vnode
);
323 ret
= afs_end_vnode_operation(&fc
);
326 if (ret
== 0 && _caller_access
)
327 *_caller_access
= scb
->status
.caller_access
;
329 _leave(" = %d", ret
);
336 int afs_iget5_test(struct inode
*inode
, void *opaque
)
338 struct afs_iget_data
*data
= opaque
;
339 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
341 return memcmp(&vnode
->fid
, &data
->fid
, sizeof(data
->fid
)) == 0;
345 * iget5() comparator for inode created by autocell operations
347 * These pseudo inodes don't match anything.
349 static int afs_iget5_pseudo_dir_test(struct inode
*inode
, void *opaque
)
355 * iget5() inode initialiser
357 static int afs_iget5_set(struct inode
*inode
, void *opaque
)
359 struct afs_iget_data
*data
= opaque
;
360 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
362 vnode
->fid
= data
->fid
;
363 vnode
->volume
= data
->volume
;
365 /* YFS supports 96-bit vnode IDs, but Linux only supports
366 * 64-bit inode numbers.
368 inode
->i_ino
= data
->fid
.vnode
;
369 inode
->i_generation
= data
->fid
.unique
;
374 * Create an inode for a dynamic root directory or an autocell dynamic
377 struct inode
*afs_iget_pseudo_dir(struct super_block
*sb
, bool root
)
379 struct afs_iget_data data
;
380 struct afs_super_info
*as
;
381 struct afs_vnode
*vnode
;
383 static atomic_t afs_autocell_ino
;
389 data
.volume
= as
->volume
;
390 data
.fid
.vid
= as
->volume
->vid
;
396 data
.fid
.vnode
= atomic_inc_return(&afs_autocell_ino
);
400 inode
= iget5_locked(sb
, data
.fid
.vnode
,
401 afs_iget5_pseudo_dir_test
, afs_iget5_set
,
404 _leave(" = -ENOMEM");
405 return ERR_PTR(-ENOMEM
);
408 _debug("GOT INODE %p { ino=%lu, vl=%llx, vn=%llx, u=%x }",
409 inode
, inode
->i_ino
, data
.fid
.vid
, data
.fid
.vnode
,
412 vnode
= AFS_FS_I(inode
);
414 /* there shouldn't be an existing inode */
415 BUG_ON(!(inode
->i_state
& I_NEW
));
418 inode
->i_mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
;
420 inode
->i_op
= &afs_dynroot_inode_operations
;
421 inode
->i_fop
= &afs_dynroot_file_operations
;
423 inode
->i_op
= &afs_autocell_inode_operations
;
426 inode
->i_uid
= GLOBAL_ROOT_UID
;
427 inode
->i_gid
= GLOBAL_ROOT_GID
;
428 inode
->i_ctime
= inode
->i_atime
= inode
->i_mtime
= current_time(inode
);
430 inode_set_iversion_raw(inode
, 0);
431 inode
->i_generation
= 0;
433 set_bit(AFS_VNODE_PSEUDODIR
, &vnode
->flags
);
435 set_bit(AFS_VNODE_MOUNTPOINT
, &vnode
->flags
);
436 inode
->i_flags
|= S_AUTOMOUNT
;
439 inode
->i_flags
|= S_NOATIME
;
440 unlock_new_inode(inode
);
441 _leave(" = %p", inode
);
446 * Get a cache cookie for an inode.
448 static void afs_get_inode_cache(struct afs_vnode
*vnode
)
450 #ifdef CONFIG_AFS_FSCACHE
454 u32 vnode_id_ext
[2]; /* Allow for a 96-bit key */
456 struct afs_vnode_cache_aux aux
;
458 if (vnode
->status
.type
== AFS_FTYPE_DIR
) {
463 key
.vnode_id
= vnode
->fid
.vnode
;
464 key
.unique
= vnode
->fid
.unique
;
465 key
.vnode_id_ext
[0] = vnode
->fid
.vnode
>> 32;
466 key
.vnode_id_ext
[1] = vnode
->fid
.vnode_hi
;
467 aux
.data_version
= vnode
->status
.data_version
;
469 vnode
->cache
= fscache_acquire_cookie(vnode
->volume
->cache
,
470 &afs_vnode_cache_index_def
,
473 vnode
, vnode
->status
.size
, true);
480 struct inode
*afs_iget(struct super_block
*sb
, struct key
*key
,
481 struct afs_fid
*fid
, struct afs_status_cb
*scb
,
482 struct afs_cb_interest
*cbi
,
483 struct afs_vnode
*parent_vnode
)
485 struct afs_iget_data data
= { .fid
= *fid
};
486 struct afs_super_info
*as
;
487 struct afs_vnode
*vnode
;
491 _enter(",{%llx:%llu.%u},,", fid
->vid
, fid
->vnode
, fid
->unique
);
494 data
.volume
= as
->volume
;
496 inode
= iget5_locked(sb
, fid
->vnode
, afs_iget5_test
, afs_iget5_set
,
499 _leave(" = -ENOMEM");
500 return ERR_PTR(-ENOMEM
);
503 _debug("GOT INODE %p { vl=%llx vn=%llx, u=%x }",
504 inode
, fid
->vid
, fid
->vnode
, fid
->unique
);
506 vnode
= AFS_FS_I(inode
);
508 /* deal with an existing inode */
509 if (!(inode
->i_state
& I_NEW
)) {
510 _leave(" = %p", inode
);
515 /* it's a remotely extant inode */
516 ret
= afs_fetch_status(vnode
, key
, true, NULL
);
520 ret
= afs_inode_init_from_status(vnode
, key
, cbi
, parent_vnode
,
526 afs_get_inode_cache(vnode
);
529 clear_bit(AFS_VNODE_UNSET
, &vnode
->flags
);
530 inode
->i_flags
|= S_NOATIME
;
531 unlock_new_inode(inode
);
532 _leave(" = %p", inode
);
538 _leave(" = %d [bad]", ret
);
543 * mark the data attached to an inode as obsolete due to a write on the server
544 * - might also want to ditch all the outstanding writes and dirty pages
546 void afs_zap_data(struct afs_vnode
*vnode
)
548 _enter("{%llx:%llu}", vnode
->fid
.vid
, vnode
->fid
.vnode
);
550 #ifdef CONFIG_AFS_FSCACHE
551 fscache_invalidate(vnode
->cache
);
554 /* nuke all the non-dirty pages that aren't locked, mapped or being
555 * written back in a regular file and completely discard the pages in a
556 * directory or symlink */
557 if (S_ISREG(vnode
->vfs_inode
.i_mode
))
558 invalidate_remote_inode(&vnode
->vfs_inode
);
560 invalidate_inode_pages2(vnode
->vfs_inode
.i_mapping
);
564 * validate a vnode/inode
565 * - there are several things we need to check
566 * - parent dir data changes (rm, rmdir, rename, mkdir, create, link,
568 * - parent dir metadata changed (security changes)
569 * - dentry data changed (write, truncate)
570 * - dentry metadata changed (security changes)
572 int afs_validate(struct afs_vnode
*vnode
, struct key
*key
)
574 time64_t now
= ktime_get_real_seconds();
578 _enter("{v={%llx:%llu} fl=%lx},%x",
579 vnode
->fid
.vid
, vnode
->fid
.vnode
, vnode
->flags
,
582 /* Quickly check the callback state. Ideally, we'd use read_seqbegin
583 * here, but we have no way to pass the net namespace to the RCU
584 * cleanup for the server record.
586 read_seqlock_excl(&vnode
->cb_lock
);
588 if (test_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
)) {
589 if (vnode
->cb_s_break
!= vnode
->cb_interest
->server
->cb_s_break
||
590 vnode
->cb_v_break
!= vnode
->volume
->cb_v_break
) {
591 vnode
->cb_s_break
= vnode
->cb_interest
->server
->cb_s_break
;
592 vnode
->cb_v_break
= vnode
->volume
->cb_v_break
;
594 } else if (test_bit(AFS_VNODE_ZAP_DATA
, &vnode
->flags
)) {
596 } else if (vnode
->cb_expires_at
- 10 <= now
) {
601 } else if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
)) {
604 vnode
->cb_v_break
= vnode
->volume
->cb_v_break
;
608 read_sequnlock_excl(&vnode
->cb_lock
);
610 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
))
611 clear_nlink(&vnode
->vfs_inode
);
616 down_write(&vnode
->validate_lock
);
618 /* if the promise has expired, we need to check the server again to get
619 * a new promise - note that if the (parent) directory's metadata was
620 * changed then the security may be different and we may no longer have
622 if (!test_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
)) {
623 _debug("not promised");
624 ret
= afs_fetch_status(vnode
, key
, false, NULL
);
626 if (ret
== -ENOENT
) {
627 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
632 _debug("new promise [fl=%lx]", vnode
->flags
);
635 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
)) {
636 _debug("file already deleted");
641 /* if the vnode's data version number changed then its contents are
643 if (test_and_clear_bit(AFS_VNODE_ZAP_DATA
, &vnode
->flags
))
645 up_write(&vnode
->validate_lock
);
651 up_write(&vnode
->validate_lock
);
652 _leave(" = %d", ret
);
657 * read the attributes of an inode
659 int afs_getattr(const struct path
*path
, struct kstat
*stat
,
660 u32 request_mask
, unsigned int query_flags
)
662 struct inode
*inode
= d_inode(path
->dentry
);
663 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
666 _enter("{ ino=%lu v=%u }", inode
->i_ino
, inode
->i_generation
);
669 read_seqbegin_or_lock(&vnode
->cb_lock
, &seq
);
670 generic_fillattr(inode
, stat
);
671 } while (need_seqretry(&vnode
->cb_lock
, seq
));
673 done_seqretry(&vnode
->cb_lock
, seq
);
678 * discard an AFS inode
680 int afs_drop_inode(struct inode
*inode
)
684 if (test_bit(AFS_VNODE_PSEUDODIR
, &AFS_FS_I(inode
)->flags
))
685 return generic_delete_inode(inode
);
687 return generic_drop_inode(inode
);
693 void afs_evict_inode(struct inode
*inode
)
695 struct afs_vnode
*vnode
;
697 vnode
= AFS_FS_I(inode
);
699 _enter("{%llx:%llu.%d}",
704 _debug("CLEAR INODE %p", inode
);
706 ASSERTCMP(inode
->i_ino
, ==, vnode
->fid
.vnode
);
708 truncate_inode_pages_final(&inode
->i_data
);
711 if (vnode
->cb_interest
) {
712 afs_put_cb_interest(afs_i2net(inode
), vnode
->cb_interest
);
713 vnode
->cb_interest
= NULL
;
716 while (!list_empty(&vnode
->wb_keys
)) {
717 struct afs_wb_key
*wbk
= list_entry(vnode
->wb_keys
.next
,
718 struct afs_wb_key
, vnode_link
);
719 list_del(&wbk
->vnode_link
);
723 #ifdef CONFIG_AFS_FSCACHE
725 struct afs_vnode_cache_aux aux
;
727 aux
.data_version
= vnode
->status
.data_version
;
728 fscache_relinquish_cookie(vnode
->cache
, &aux
,
729 test_bit(AFS_VNODE_DELETED
, &vnode
->flags
));
734 afs_prune_wb_keys(vnode
);
735 afs_put_permits(rcu_access_pointer(vnode
->permit_cache
));
736 key_put(vnode
->silly_key
);
737 vnode
->silly_key
= NULL
;
738 key_put(vnode
->lock_key
);
739 vnode
->lock_key
= NULL
;
744 * set the attributes of an inode
746 int afs_setattr(struct dentry
*dentry
, struct iattr
*attr
)
748 struct afs_fs_cursor fc
;
749 struct afs_status_cb
*scb
;
750 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(dentry
));
754 _enter("{%llx:%llu},{n=%pd},%x",
755 vnode
->fid
.vid
, vnode
->fid
.vnode
, dentry
,
758 if (!(attr
->ia_valid
& (ATTR_SIZE
| ATTR_MODE
| ATTR_UID
| ATTR_GID
|
760 _leave(" = 0 [unsupported]");
764 scb
= kzalloc(sizeof(struct afs_status_cb
), GFP_KERNEL
);
768 /* flush any dirty data outstanding on a regular file */
769 if (S_ISREG(vnode
->vfs_inode
.i_mode
))
770 filemap_write_and_wait(vnode
->vfs_inode
.i_mapping
);
772 if (attr
->ia_valid
& ATTR_FILE
) {
773 key
= afs_file_key(attr
->ia_file
);
775 key
= afs_request_key(vnode
->volume
->cell
);
783 if (afs_begin_vnode_operation(&fc
, vnode
, key
, false)) {
784 afs_dataversion_t data_version
= vnode
->status
.data_version
;
786 if (attr
->ia_valid
& ATTR_SIZE
)
789 while (afs_select_fileserver(&fc
)) {
790 fc
.cb_break
= afs_calc_vnode_cb_break(vnode
);
791 afs_fs_setattr(&fc
, attr
, scb
);
794 afs_check_for_remote_deletion(&fc
, vnode
);
795 afs_vnode_commit_status(&fc
, vnode
, fc
.cb_break
,
797 ret
= afs_end_vnode_operation(&fc
);
800 if (!(attr
->ia_valid
& ATTR_FILE
))
806 _leave(" = %d", ret
);