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
,
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", vnode
->status
.type
);
37 pr_warn("kAFS: A=%d m=%o s=%llx v=%llx\n",
38 vnode
->status
.abort_code
,
41 vnode
->status
.data_version
);
42 pr_warn("kAFS: vnode %llx:%llx:%x\n",
47 pr_warn("kAFS: dir %llx:%llx:%x\n",
48 parent_vnode
->fid
.vid
,
49 parent_vnode
->fid
.vnode
,
50 parent_vnode
->fid
.unique
);
52 if (!test_and_set_bit(0, &once_only
))
57 * Set parameters for the netfs library
59 static void afs_set_netfs_context(struct afs_vnode
*vnode
)
61 netfs_inode_init(&vnode
->netfs
, &afs_req_ops
, true);
65 * Initialise an inode from the vnode status.
67 static int afs_inode_init_from_status(struct afs_operation
*op
,
68 struct afs_vnode_param
*vp
,
69 struct afs_vnode
*vnode
)
71 struct afs_file_status
*status
= &vp
->scb
.status
;
72 struct inode
*inode
= AFS_VNODE_TO_I(vnode
);
75 _enter("{%llx:%llu.%u} %s",
76 vp
->fid
.vid
, vp
->fid
.vnode
, vp
->fid
.unique
,
77 op
->type
? op
->type
->name
: "???");
79 _debug("FS: ft=%d lk=%d sz=%llu ver=%Lu mod=%hu",
82 (unsigned long long) status
->size
,
86 write_seqlock(&vnode
->cb_lock
);
88 vnode
->cb_v_check
= op
->cb_v_break
;
89 vnode
->status
= *status
;
91 t
= status
->mtime_client
;
92 inode_set_ctime_to_ts(inode
, t
);
93 inode_set_mtime_to_ts(inode
, t
);
94 inode_set_atime_to_ts(inode
, t
);
95 inode
->i_flags
|= S_NOATIME
;
96 inode
->i_uid
= make_kuid(&init_user_ns
, status
->owner
);
97 inode
->i_gid
= make_kgid(&init_user_ns
, status
->group
);
98 set_nlink(&vnode
->netfs
.inode
, status
->nlink
);
100 switch (status
->type
) {
102 inode
->i_mode
= S_IFREG
| (status
->mode
& S_IALLUGO
);
103 inode
->i_op
= &afs_file_inode_operations
;
104 inode
->i_fop
= &afs_file_operations
;
105 inode
->i_mapping
->a_ops
= &afs_file_aops
;
106 mapping_set_large_folios(inode
->i_mapping
);
109 inode
->i_mode
= S_IFDIR
| (status
->mode
& S_IALLUGO
);
110 inode
->i_op
= &afs_dir_inode_operations
;
111 inode
->i_fop
= &afs_dir_file_operations
;
112 inode
->i_mapping
->a_ops
= &afs_dir_aops
;
113 mapping_set_large_folios(inode
->i_mapping
);
115 case AFS_FTYPE_SYMLINK
:
116 /* Symlinks with a mode of 0644 are actually mountpoints. */
117 if ((status
->mode
& 0777) == 0644) {
118 inode
->i_flags
|= S_AUTOMOUNT
;
120 set_bit(AFS_VNODE_MOUNTPOINT
, &vnode
->flags
);
122 inode
->i_mode
= S_IFDIR
| 0555;
123 inode
->i_op
= &afs_mntpt_inode_operations
;
124 inode
->i_fop
= &afs_mntpt_file_operations
;
125 inode
->i_mapping
->a_ops
= &afs_symlink_aops
;
127 inode
->i_mode
= S_IFLNK
| status
->mode
;
128 inode
->i_op
= &afs_symlink_inode_operations
;
129 inode
->i_mapping
->a_ops
= &afs_symlink_aops
;
131 inode_nohighmem(inode
);
134 dump_vnode(vnode
, op
->file
[0].vnode
!= vnode
? op
->file
[0].vnode
: NULL
);
135 write_sequnlock(&vnode
->cb_lock
);
136 return afs_protocol_error(NULL
, afs_eproto_file_type
);
139 afs_set_i_size(vnode
, status
->size
);
140 afs_set_netfs_context(vnode
);
142 vnode
->invalid_before
= status
->data_version
;
143 inode_set_iversion_raw(&vnode
->netfs
.inode
, status
->data_version
);
145 if (!vp
->scb
.have_cb
) {
146 /* it's a symlink we just created (the fileserver
147 * didn't give us a callback) */
148 atomic64_set(&vnode
->cb_expires_at
, AFS_NO_CB_PROMISE
);
150 vnode
->cb_server
= op
->server
;
151 atomic64_set(&vnode
->cb_expires_at
, vp
->scb
.callback
.expires_at
);
154 write_sequnlock(&vnode
->cb_lock
);
159 * Update the core inode struct from a returned status record.
161 static void afs_apply_status(struct afs_operation
*op
,
162 struct afs_vnode_param
*vp
)
164 struct afs_file_status
*status
= &vp
->scb
.status
;
165 struct afs_vnode
*vnode
= vp
->vnode
;
166 struct inode
*inode
= &vnode
->netfs
.inode
;
169 bool unexpected_jump
= false;
170 bool data_changed
= false;
171 bool change_size
= vp
->set_size
;
173 _enter("{%llx:%llu.%u} %s",
174 vp
->fid
.vid
, vp
->fid
.vnode
, vp
->fid
.unique
,
175 op
->type
? op
->type
->name
: "???");
177 BUG_ON(test_bit(AFS_VNODE_UNSET
, &vnode
->flags
));
179 if (status
->type
!= vnode
->status
.type
) {
180 pr_warn("Vnode %llx:%llx:%x changed type %u to %u\n",
184 status
->type
, vnode
->status
.type
);
185 afs_protocol_error(NULL
, afs_eproto_bad_status
);
189 if (status
->nlink
!= vnode
->status
.nlink
)
190 set_nlink(inode
, status
->nlink
);
192 if (status
->owner
!= vnode
->status
.owner
)
193 inode
->i_uid
= make_kuid(&init_user_ns
, status
->owner
);
195 if (status
->group
!= vnode
->status
.group
)
196 inode
->i_gid
= make_kgid(&init_user_ns
, status
->group
);
198 if (status
->mode
!= vnode
->status
.mode
) {
199 mode
= inode
->i_mode
;
201 mode
|= status
->mode
& S_IALLUGO
;
202 WRITE_ONCE(inode
->i_mode
, mode
);
205 t
= status
->mtime_client
;
206 inode_set_mtime_to_ts(inode
, t
);
207 if (vp
->update_ctime
)
208 inode_set_ctime_to_ts(inode
, op
->ctime
);
210 if (vnode
->status
.data_version
!= status
->data_version
)
213 vnode
->status
= *status
;
215 if (vp
->dv_before
+ vp
->dv_delta
!= status
->data_version
) {
216 if (vnode
->cb_ro_snapshot
== atomic_read(&vnode
->volume
->cb_ro_snapshot
) &&
217 atomic64_read(&vnode
->cb_expires_at
) != AFS_NO_CB_PROMISE
)
218 pr_warn("kAFS: vnode modified {%llx:%llu} %llx->%llx %s (op=%x)\n",
219 vnode
->fid
.vid
, vnode
->fid
.vnode
,
220 (unsigned long long)vp
->dv_before
+ vp
->dv_delta
,
221 (unsigned long long)status
->data_version
,
222 op
->type
? op
->type
->name
: "???",
225 vnode
->invalid_before
= status
->data_version
;
226 if (vnode
->status
.type
== AFS_FTYPE_DIR
) {
227 if (test_and_clear_bit(AFS_VNODE_DIR_VALID
, &vnode
->flags
))
228 afs_stat_v(vnode
, n_inval
);
230 set_bit(AFS_VNODE_ZAP_DATA
, &vnode
->flags
);
234 unexpected_jump
= true;
235 } else if (vnode
->status
.type
== AFS_FTYPE_DIR
) {
236 /* Expected directory change is handled elsewhere so
237 * that we can locally edit the directory and save on a
240 if (test_bit(AFS_VNODE_DIR_VALID
, &vnode
->flags
))
241 data_changed
= false;
246 inode_set_iversion_raw(inode
, status
->data_version
);
248 /* Only update the size if the data version jumped. If the
249 * file is being modified locally, then we might have our own
250 * idea of what the size should be that's not the same as
251 * what's on the server.
253 vnode
->netfs
.remote_i_size
= status
->size
;
254 if (change_size
|| status
->size
> i_size_read(inode
)) {
255 afs_set_i_size(vnode
, status
->size
);
257 vnode
->netfs
.zero_point
= status
->size
;
258 inode_set_ctime_to_ts(inode
, t
);
259 inode_set_atime_to_ts(inode
, t
);
265 * Apply a callback to a vnode.
267 static void afs_apply_callback(struct afs_operation
*op
,
268 struct afs_vnode_param
*vp
)
270 struct afs_callback
*cb
= &vp
->scb
.callback
;
271 struct afs_vnode
*vnode
= vp
->vnode
;
273 if (!afs_cb_is_broken(vp
->cb_break_before
, vnode
)) {
274 if (op
->volume
->type
== AFSVL_RWVOL
)
275 vnode
->cb_server
= op
->server
;
276 atomic64_set(&vnode
->cb_expires_at
, cb
->expires_at
);
281 * Apply the received status and callback to an inode all in the same critical
282 * section to avoid races with afs_validate().
284 void afs_vnode_commit_status(struct afs_operation
*op
, struct afs_vnode_param
*vp
)
286 struct afs_vnode
*vnode
= vp
->vnode
;
290 write_seqlock(&vnode
->cb_lock
);
292 if (vp
->scb
.have_error
) {
293 /* A YFS server will return this from RemoveFile2 and AFS and
294 * YFS will return this from InlineBulkStatus.
296 if (vp
->scb
.status
.abort_code
== VNOVNODE
) {
297 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
298 clear_nlink(&vnode
->netfs
.inode
);
299 __afs_break_callback(vnode
, afs_cb_break_for_deleted
);
300 op
->flags
&= ~AFS_OPERATION_DIR_CONFLICT
;
302 } else if (vp
->scb
.have_status
) {
303 if (vp
->speculative
&&
304 (test_bit(AFS_VNODE_MODIFYING
, &vnode
->flags
) ||
305 vp
->dv_before
!= vnode
->status
.data_version
))
306 /* Ignore the result of a speculative bulk status fetch
307 * if it splits around a modification op, thereby
308 * appearing to regress the data version.
311 afs_apply_status(op
, vp
);
313 afs_apply_callback(op
, vp
);
314 } else if (vp
->op_unlinked
&& !(op
->flags
& AFS_OPERATION_DIR_CONFLICT
)) {
315 drop_nlink(&vnode
->netfs
.inode
);
316 if (vnode
->netfs
.inode
.i_nlink
== 0) {
317 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
318 __afs_break_callback(vnode
, afs_cb_break_for_deleted
);
323 write_sequnlock(&vnode
->cb_lock
);
325 if (vp
->scb
.have_status
)
326 afs_cache_permit(vnode
, op
->key
, vp
->cb_break_before
, &vp
->scb
);
329 static void afs_fetch_status_success(struct afs_operation
*op
)
331 struct afs_vnode_param
*vp
= &op
->file
[op
->fetch_status
.which
];
332 struct afs_vnode
*vnode
= vp
->vnode
;
335 if (vnode
->netfs
.inode
.i_state
& I_NEW
) {
336 ret
= afs_inode_init_from_status(op
, vp
, vnode
);
337 afs_op_set_error(op
, ret
);
339 afs_cache_permit(vnode
, op
->key
, vp
->cb_break_before
, &vp
->scb
);
341 afs_vnode_commit_status(op
, vp
);
345 const struct afs_operation_ops afs_fetch_status_operation
= {
346 .issue_afs_rpc
= afs_fs_fetch_status
,
347 .issue_yfs_rpc
= yfs_fs_fetch_status
,
348 .success
= afs_fetch_status_success
,
349 .aborted
= afs_check_for_remote_deletion
,
353 * Fetch file status from the volume.
355 int afs_fetch_status(struct afs_vnode
*vnode
, struct key
*key
, bool is_new
,
356 afs_access_t
*_caller_access
)
358 struct afs_operation
*op
;
360 _enter("%s,{%llx:%llu.%u,S=%lx}",
362 vnode
->fid
.vid
, vnode
->fid
.vnode
, vnode
->fid
.unique
,
365 op
= afs_alloc_operation(key
, vnode
->volume
);
369 afs_op_set_vnode(op
, 0, vnode
);
372 op
->ops
= &afs_fetch_status_operation
;
373 afs_begin_vnode_operation(op
);
374 afs_wait_for_operation(op
);
377 *_caller_access
= op
->file
[0].scb
.status
.caller_access
;
378 return afs_put_operation(op
);
382 * ilookup() comparator
384 int afs_ilookup5_test_by_fid(struct inode
*inode
, void *opaque
)
386 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
387 struct afs_fid
*fid
= opaque
;
389 return (fid
->vnode
== vnode
->fid
.vnode
&&
390 fid
->vnode_hi
== vnode
->fid
.vnode_hi
&&
391 fid
->unique
== vnode
->fid
.unique
);
397 static int afs_iget5_test(struct inode
*inode
, void *opaque
)
399 struct afs_vnode_param
*vp
= opaque
;
400 //struct afs_vnode *vnode = AFS_FS_I(inode);
402 return afs_ilookup5_test_by_fid(inode
, &vp
->fid
);
406 * iget5() inode initialiser
408 static int afs_iget5_set(struct inode
*inode
, void *opaque
)
410 struct afs_vnode_param
*vp
= opaque
;
411 struct afs_super_info
*as
= AFS_FS_S(inode
->i_sb
);
412 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
414 vnode
->volume
= as
->volume
;
415 vnode
->fid
= vp
->fid
;
417 /* YFS supports 96-bit vnode IDs, but Linux only supports
418 * 64-bit inode numbers.
420 inode
->i_ino
= vnode
->fid
.vnode
;
421 inode
->i_generation
= vnode
->fid
.unique
;
426 * Get a cache cookie for an inode.
428 static void afs_get_inode_cache(struct afs_vnode
*vnode
)
430 #ifdef CONFIG_AFS_FSCACHE
434 __be32 vnode_id_ext
[2]; /* Allow for a 96-bit key */
436 struct afs_vnode_cache_aux aux
;
438 if (vnode
->status
.type
!= AFS_FTYPE_FILE
) {
439 vnode
->netfs
.cache
= NULL
;
443 key
.vnode_id
= htonl(vnode
->fid
.vnode
);
444 key
.unique
= htonl(vnode
->fid
.unique
);
445 key
.vnode_id_ext
[0] = htonl(vnode
->fid
.vnode
>> 32);
446 key
.vnode_id_ext
[1] = htonl(vnode
->fid
.vnode_hi
);
447 afs_set_cache_aux(vnode
, &aux
);
449 afs_vnode_set_cache(vnode
,
450 fscache_acquire_cookie(
451 vnode
->volume
->cache
,
452 vnode
->status
.type
== AFS_FTYPE_FILE
?
453 0 : FSCACHE_ADV_SINGLE_CHUNK
,
456 i_size_read(&vnode
->netfs
.inode
)));
463 struct inode
*afs_iget(struct afs_operation
*op
, struct afs_vnode_param
*vp
)
465 struct afs_vnode_param
*dvp
= &op
->file
[0];
466 struct super_block
*sb
= dvp
->vnode
->netfs
.inode
.i_sb
;
467 struct afs_vnode
*vnode
;
471 _enter(",{%llx:%llu.%u},,", vp
->fid
.vid
, vp
->fid
.vnode
, vp
->fid
.unique
);
473 inode
= iget5_locked(sb
, vp
->fid
.vnode
, afs_iget5_test
, afs_iget5_set
, vp
);
475 _leave(" = -ENOMEM");
476 return ERR_PTR(-ENOMEM
);
479 vnode
= AFS_FS_I(inode
);
481 _debug("GOT INODE %p { vl=%llx vn=%llx, u=%x }",
482 inode
, vnode
->fid
.vid
, vnode
->fid
.vnode
, vnode
->fid
.unique
);
484 /* deal with an existing inode */
485 if (!(inode
->i_state
& I_NEW
)) {
486 _leave(" = %p", inode
);
490 ret
= afs_inode_init_from_status(op
, vp
, vnode
);
494 afs_get_inode_cache(vnode
);
497 clear_bit(AFS_VNODE_UNSET
, &vnode
->flags
);
498 unlock_new_inode(inode
);
499 _leave(" = %p", inode
);
505 _leave(" = %d [bad]", ret
);
509 static int afs_iget5_set_root(struct inode
*inode
, void *opaque
)
511 struct afs_super_info
*as
= AFS_FS_S(inode
->i_sb
);
512 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
514 vnode
->volume
= as
->volume
;
515 vnode
->fid
.vid
= as
->volume
->vid
;
516 vnode
->fid
.vnode
= 1;
517 vnode
->fid
.unique
= 1;
519 inode
->i_generation
= 1;
524 * Set up the root inode for a volume. This is always vnode 1, unique 1 within
527 struct inode
*afs_root_iget(struct super_block
*sb
, struct key
*key
)
529 struct afs_super_info
*as
= AFS_FS_S(sb
);
530 struct afs_operation
*op
;
531 struct afs_vnode
*vnode
;
535 _enter(",{%llx},,", as
->volume
->vid
);
537 inode
= iget5_locked(sb
, 1, NULL
, afs_iget5_set_root
, NULL
);
539 _leave(" = -ENOMEM");
540 return ERR_PTR(-ENOMEM
);
543 _debug("GOT ROOT INODE %p { vl=%llx }", inode
, as
->volume
->vid
);
545 BUG_ON(!(inode
->i_state
& I_NEW
));
547 vnode
= AFS_FS_I(inode
);
548 vnode
->cb_v_check
= atomic_read(&as
->volume
->cb_v_break
);
549 afs_set_netfs_context(vnode
);
551 op
= afs_alloc_operation(key
, as
->volume
);
557 afs_op_set_vnode(op
, 0, vnode
);
560 op
->ops
= &afs_fetch_status_operation
;
561 ret
= afs_do_sync_operation(op
);
565 afs_get_inode_cache(vnode
);
567 clear_bit(AFS_VNODE_UNSET
, &vnode
->flags
);
568 unlock_new_inode(inode
);
569 _leave(" = %p", inode
);
574 _leave(" = %d [bad]", ret
);
579 * read the attributes of an inode
581 int afs_getattr(struct mnt_idmap
*idmap
, const struct path
*path
,
582 struct kstat
*stat
, u32 request_mask
, unsigned int query_flags
)
584 struct inode
*inode
= d_inode(path
->dentry
);
585 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
589 _enter("{ ino=%lu v=%u }", inode
->i_ino
, inode
->i_generation
);
592 !(query_flags
& AT_STATX_DONT_SYNC
) &&
593 atomic64_read(&vnode
->cb_expires_at
) == AFS_NO_CB_PROMISE
) {
594 key
= afs_request_key(vnode
->volume
->cell
);
597 ret
= afs_validate(vnode
, key
);
604 seq
= read_seqbegin(&vnode
->cb_lock
);
605 generic_fillattr(&nop_mnt_idmap
, request_mask
, inode
, stat
);
606 if (test_bit(AFS_VNODE_SILLY_DELETED
, &vnode
->flags
) &&
610 /* Lie about the size of directories. We maintain a locally
611 * edited copy and may make different allocation decisions on
612 * it, but we need to give userspace the server's size.
614 if (S_ISDIR(inode
->i_mode
))
615 stat
->size
= vnode
->netfs
.remote_i_size
;
616 } while (read_seqretry(&vnode
->cb_lock
, seq
));
622 * discard an AFS inode
624 int afs_drop_inode(struct inode
*inode
)
628 if (test_bit(AFS_VNODE_PSEUDODIR
, &AFS_FS_I(inode
)->flags
))
629 return generic_delete_inode(inode
);
631 return generic_drop_inode(inode
);
637 void afs_evict_inode(struct inode
*inode
)
639 struct afs_vnode_cache_aux aux
;
640 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
642 _enter("{%llx:%llu.%d}",
647 _debug("CLEAR INODE %p", inode
);
649 ASSERTCMP(inode
->i_ino
, ==, vnode
->fid
.vnode
);
651 netfs_wait_for_outstanding_io(inode
);
652 truncate_inode_pages_final(&inode
->i_data
);
654 afs_set_cache_aux(vnode
, &aux
);
655 netfs_clear_inode_writeback(inode
, &aux
);
658 while (!list_empty(&vnode
->wb_keys
)) {
659 struct afs_wb_key
*wbk
= list_entry(vnode
->wb_keys
.next
,
660 struct afs_wb_key
, vnode_link
);
661 list_del(&wbk
->vnode_link
);
665 fscache_relinquish_cookie(afs_vnode_cache(vnode
),
666 test_bit(AFS_VNODE_DELETED
, &vnode
->flags
));
668 afs_prune_wb_keys(vnode
);
669 afs_put_permits(rcu_access_pointer(vnode
->permit_cache
));
670 key_put(vnode
->silly_key
);
671 vnode
->silly_key
= NULL
;
672 key_put(vnode
->lock_key
);
673 vnode
->lock_key
= NULL
;
677 static void afs_setattr_success(struct afs_operation
*op
)
679 struct afs_vnode_param
*vp
= &op
->file
[0];
680 struct inode
*inode
= &vp
->vnode
->netfs
.inode
;
681 loff_t old_i_size
= i_size_read(inode
);
683 op
->setattr
.old_i_size
= old_i_size
;
684 afs_vnode_commit_status(op
, vp
);
685 /* inode->i_size has now been changed. */
687 if (op
->setattr
.attr
->ia_valid
& ATTR_SIZE
) {
688 loff_t size
= op
->setattr
.attr
->ia_size
;
689 if (size
> old_i_size
)
690 pagecache_isize_extended(inode
, old_i_size
, size
);
694 static void afs_setattr_edit_file(struct afs_operation
*op
)
696 struct afs_vnode_param
*vp
= &op
->file
[0];
697 struct afs_vnode
*vnode
= vp
->vnode
;
698 struct inode
*inode
= &vnode
->netfs
.inode
;
700 if (op
->setattr
.attr
->ia_valid
& ATTR_SIZE
) {
701 loff_t size
= op
->setattr
.attr
->ia_size
;
702 loff_t old
= op
->setattr
.old_i_size
;
704 /* Note: inode->i_size was updated by afs_apply_status() inside
705 * the I/O and callback locks.
709 truncate_pagecache(inode
, size
);
710 netfs_resize_file(&vnode
->netfs
, size
, true);
711 fscache_resize_cookie(afs_vnode_cache(vnode
), size
);
716 static const struct afs_operation_ops afs_setattr_operation
= {
717 .issue_afs_rpc
= afs_fs_setattr
,
718 .issue_yfs_rpc
= yfs_fs_setattr
,
719 .success
= afs_setattr_success
,
720 .edit_dir
= afs_setattr_edit_file
,
724 * set the attributes of an inode
726 int afs_setattr(struct mnt_idmap
*idmap
, struct dentry
*dentry
,
729 const unsigned int supported
=
730 ATTR_SIZE
| ATTR_MODE
| ATTR_UID
| ATTR_GID
|
731 ATTR_MTIME
| ATTR_MTIME_SET
| ATTR_TIMES_SET
| ATTR_TOUCH
;
732 struct afs_operation
*op
;
733 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(dentry
));
734 struct inode
*inode
= &vnode
->netfs
.inode
;
738 _enter("{%llx:%llu},{n=%pd},%x",
739 vnode
->fid
.vid
, vnode
->fid
.vnode
, dentry
,
742 if (!(attr
->ia_valid
& supported
)) {
743 _leave(" = 0 [unsupported]");
747 i_size
= i_size_read(inode
);
748 if (attr
->ia_valid
& ATTR_SIZE
) {
749 if (!S_ISREG(inode
->i_mode
))
752 ret
= inode_newsize_ok(inode
, attr
->ia_size
);
756 if (attr
->ia_size
== i_size
)
757 attr
->ia_valid
&= ~ATTR_SIZE
;
760 fscache_use_cookie(afs_vnode_cache(vnode
), true);
762 /* Prevent any new writebacks from starting whilst we do this. */
763 down_write(&vnode
->validate_lock
);
765 if ((attr
->ia_valid
& ATTR_SIZE
) && S_ISREG(inode
->i_mode
)) {
766 loff_t size
= attr
->ia_size
;
768 /* Wait for any outstanding writes to the server to complete */
769 loff_t from
= min(size
, i_size
);
770 loff_t to
= max(size
, i_size
);
771 ret
= filemap_fdatawait_range(inode
->i_mapping
, from
, to
);
775 /* Don't talk to the server if we're just shortening in-memory
776 * writes that haven't gone to the server yet.
778 if (!(attr
->ia_valid
& (supported
& ~ATTR_SIZE
& ~ATTR_MTIME
)) &&
779 attr
->ia_size
< i_size
&&
780 attr
->ia_size
> vnode
->netfs
.remote_i_size
) {
781 truncate_setsize(inode
, attr
->ia_size
);
782 netfs_resize_file(&vnode
->netfs
, size
, false);
783 fscache_resize_cookie(afs_vnode_cache(vnode
),
790 op
= afs_alloc_operation(((attr
->ia_valid
& ATTR_FILE
) ?
791 afs_file_key(attr
->ia_file
) : NULL
),
798 afs_op_set_vnode(op
, 0, vnode
);
799 op
->setattr
.attr
= attr
;
801 if (attr
->ia_valid
& ATTR_SIZE
) {
802 op
->file
[0].dv_delta
= 1;
803 op
->file
[0].set_size
= true;
805 op
->ctime
= attr
->ia_ctime
;
806 op
->file
[0].update_ctime
= 1;
807 op
->file
[0].modification
= true;
809 op
->ops
= &afs_setattr_operation
;
810 ret
= afs_do_sync_operation(op
);
813 up_write(&vnode
->validate_lock
);
814 fscache_unuse_cookie(afs_vnode_cache(vnode
), NULL
, NULL
);
815 _leave(" = %d", ret
);