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 | 25 | #include "internal.h" |
a38a7558 | 26 | #include "afs_fs.h" |
1da177e4 | 27 | |
d3e3b7ea DH |
28 | static const struct inode_operations afs_symlink_inode_operations = { |
29 | .get_link = page_get_link, | |
d3e3b7ea DH |
30 | }; |
31 | ||
b134d687 DH |
32 | static noinline void dump_vnode(struct afs_vnode *vnode, struct afs_vnode *parent_vnode) |
33 | { | |
34 | static unsigned long once_only; | |
35 | ||
a4e530ae | 36 | pr_warn("kAFS: AFS vnode with undefined type %u\n", vnode->status.type); |
b134d687 DH |
37 | pr_warn("kAFS: A=%d m=%o s=%llx v=%llx\n", |
38 | vnode->status.abort_code, | |
39 | vnode->status.mode, | |
40 | vnode->status.size, | |
41 | vnode->status.data_version); | |
42 | pr_warn("kAFS: vnode %llx:%llx:%x\n", | |
43 | vnode->fid.vid, | |
44 | vnode->fid.vnode, | |
45 | vnode->fid.unique); | |
46 | if (parent_vnode) | |
47 | pr_warn("kAFS: dir %llx:%llx:%x\n", | |
48 | parent_vnode->fid.vid, | |
49 | parent_vnode->fid.vnode, | |
50 | parent_vnode->fid.unique); | |
51 | ||
52 | if (!test_and_set_bit(0, &once_only)) | |
53 | dump_stack(); | |
54 | } | |
55 | ||
bc899ee1 DH |
56 | /* |
57 | * Set parameters for the netfs library | |
58 | */ | |
59 | static void afs_set_netfs_context(struct afs_vnode *vnode) | |
60 | { | |
100ccd18 | 61 | netfs_inode_init(&vnode->netfs, &afs_req_ops, true); |
bc899ee1 DH |
62 | } |
63 | ||
1da177e4 | 64 | /* |
dd9fbcb8 | 65 | * Initialise an inode from the vnode status. |
1da177e4 | 66 | */ |
e49c7b2f DH |
67 | static int afs_inode_init_from_status(struct afs_operation *op, |
68 | struct afs_vnode_param *vp, | |
69 | struct afs_vnode *vnode) | |
1da177e4 | 70 | { |
e49c7b2f | 71 | struct afs_file_status *status = &vp->scb.status; |
1da177e4 | 72 | struct inode *inode = AFS_VNODE_TO_I(vnode); |
a58823ac | 73 | struct timespec64 t; |
1da177e4 | 74 | |
e49c7b2f DH |
75 | _enter("{%llx:%llu.%u} %s", |
76 | vp->fid.vid, vp->fid.vnode, vp->fid.unique, | |
77 | op->type ? op->type->name : "???"); | |
78 | ||
260a9803 | 79 | _debug("FS: ft=%d lk=%d sz=%llu ver=%Lu mod=%hu", |
a58823ac DH |
80 | status->type, |
81 | status->nlink, | |
82 | (unsigned long long) status->size, | |
83 | status->data_version, | |
84 | status->mode); | |
1da177e4 | 85 | |
a58823ac DH |
86 | write_seqlock(&vnode->cb_lock); |
87 | ||
453924de | 88 | vnode->cb_v_check = op->cb_v_break; |
a58823ac | 89 | vnode->status = *status; |
c435ee34 | 90 | |
a58823ac | 91 | t = status->mtime_client; |
b9170a28 | 92 | inode_set_ctime_to_ts(inode, t); |
562ce1f7 JL |
93 | inode_set_mtime_to_ts(inode, t); |
94 | inode_set_atime_to_ts(inode, t); | |
e49c7b2f | 95 | inode->i_flags |= S_NOATIME; |
a58823ac DH |
96 | inode->i_uid = make_kuid(&init_user_ns, status->owner); |
97 | inode->i_gid = make_kgid(&init_user_ns, status->group); | |
874c8ca1 | 98 | set_nlink(&vnode->netfs.inode, status->nlink); |
dd9fbcb8 | 99 | |
a58823ac | 100 | switch (status->type) { |
1da177e4 | 101 | case AFS_FTYPE_FILE: |
6e1eb04a | 102 | inode->i_mode = S_IFREG | (status->mode & S_IALLUGO); |
1da177e4 | 103 | inode->i_op = &afs_file_inode_operations; |
00d3b7a4 | 104 | inode->i_fop = &afs_file_operations; |
75bd228d | 105 | inode->i_mapping->a_ops = &afs_file_aops; |
8549a263 | 106 | mapping_set_large_folios(inode->i_mapping); |
1da177e4 LT |
107 | break; |
108 | case AFS_FTYPE_DIR: | |
6e1eb04a | 109 | inode->i_mode = S_IFDIR | (status->mode & S_IALLUGO); |
1da177e4 LT |
110 | inode->i_op = &afs_dir_inode_operations; |
111 | inode->i_fop = &afs_dir_file_operations; | |
f3ddee8d | 112 | inode->i_mapping->a_ops = &afs_dir_aops; |
8549a263 | 113 | mapping_set_large_folios(inode->i_mapping); |
1da177e4 LT |
114 | break; |
115 | case AFS_FTYPE_SYMLINK: | |
944c74f4 | 116 | /* Symlinks with a mode of 0644 are actually mountpoints. */ |
a58823ac | 117 | if ((status->mode & 0777) == 0644) { |
944c74f4 DH |
118 | inode->i_flags |= S_AUTOMOUNT; |
119 | ||
944c74f4 | 120 | set_bit(AFS_VNODE_MOUNTPOINT, &vnode->flags); |
944c74f4 DH |
121 | |
122 | inode->i_mode = S_IFDIR | 0555; | |
123 | inode->i_op = &afs_mntpt_inode_operations; | |
124 | inode->i_fop = &afs_mntpt_file_operations; | |
75bd228d | 125 | inode->i_mapping->a_ops = &afs_symlink_aops; |
944c74f4 | 126 | } else { |
a58823ac | 127 | inode->i_mode = S_IFLNK | status->mode; |
d3e3b7ea | 128 | inode->i_op = &afs_symlink_inode_operations; |
75bd228d | 129 | inode->i_mapping->a_ops = &afs_symlink_aops; |
944c74f4 | 130 | } |
21fc61c7 | 131 | inode_nohighmem(inode); |
1da177e4 LT |
132 | break; |
133 | default: | |
e49c7b2f | 134 | dump_vnode(vnode, op->file[0].vnode != vnode ? op->file[0].vnode : NULL); |
a58823ac | 135 | write_sequnlock(&vnode->cb_lock); |
7126ead9 | 136 | return afs_protocol_error(NULL, afs_eproto_file_type); |
1da177e4 LT |
137 | } |
138 | ||
2cd42d19 | 139 | afs_set_i_size(vnode, status->size); |
bc899ee1 | 140 | afs_set_netfs_context(vnode); |
c435ee34 | 141 | |
a58823ac | 142 | vnode->invalid_before = status->data_version; |
874c8ca1 | 143 | inode_set_iversion_raw(&vnode->netfs.inode, status->data_version); |
a58823ac | 144 | |
e49c7b2f | 145 | if (!vp->scb.have_cb) { |
a58823ac DH |
146 | /* it's a symlink we just created (the fileserver |
147 | * didn't give us a callback) */ | |
453924de | 148 | atomic64_set(&vnode->cb_expires_at, AFS_NO_CB_PROMISE); |
a58823ac | 149 | } else { |
20325960 | 150 | vnode->cb_server = op->server; |
453924de | 151 | atomic64_set(&vnode->cb_expires_at, vp->scb.callback.expires_at); |
a58823ac DH |
152 | } |
153 | ||
154 | write_sequnlock(&vnode->cb_lock); | |
1da177e4 | 155 | return 0; |
ec26815a | 156 | } |
1da177e4 | 157 | |
a58823ac DH |
158 | /* |
159 | * Update the core inode struct from a returned status record. | |
160 | */ | |
e49c7b2f DH |
161 | static void afs_apply_status(struct afs_operation *op, |
162 | struct afs_vnode_param *vp) | |
a58823ac | 163 | { |
e49c7b2f DH |
164 | struct afs_file_status *status = &vp->scb.status; |
165 | struct afs_vnode *vnode = vp->vnode; | |
874c8ca1 | 166 | struct inode *inode = &vnode->netfs.inode; |
a58823ac DH |
167 | struct timespec64 t; |
168 | umode_t mode; | |
100ccd18 | 169 | bool unexpected_jump = false; |
a58823ac | 170 | bool data_changed = false; |
793fe82e | 171 | bool change_size = vp->set_size; |
a58823ac | 172 | |
e49c7b2f DH |
173 | _enter("{%llx:%llu.%u} %s", |
174 | vp->fid.vid, vp->fid.vnode, vp->fid.unique, | |
175 | op->type ? op->type->name : "???"); | |
176 | ||
a58823ac DH |
177 | BUG_ON(test_bit(AFS_VNODE_UNSET, &vnode->flags)); |
178 | ||
179 | if (status->type != vnode->status.type) { | |
a4e530ae KW |
180 | pr_warn("Vnode %llx:%llx:%x changed type %u to %u\n", |
181 | vnode->fid.vid, | |
182 | vnode->fid.vnode, | |
183 | vnode->fid.unique, | |
184 | status->type, vnode->status.type); | |
7126ead9 | 185 | afs_protocol_error(NULL, afs_eproto_bad_status); |
a58823ac DH |
186 | return; |
187 | } | |
188 | ||
189 | if (status->nlink != vnode->status.nlink) | |
da8d0755 | 190 | set_nlink(inode, status->nlink); |
a58823ac DH |
191 | |
192 | if (status->owner != vnode->status.owner) | |
da8d0755 | 193 | inode->i_uid = make_kuid(&init_user_ns, status->owner); |
a58823ac DH |
194 | |
195 | if (status->group != vnode->status.group) | |
da8d0755 | 196 | inode->i_gid = make_kgid(&init_user_ns, status->group); |
a58823ac DH |
197 | |
198 | if (status->mode != vnode->status.mode) { | |
da8d0755 | 199 | mode = inode->i_mode; |
a58823ac | 200 | mode &= ~S_IALLUGO; |
6e1eb04a | 201 | mode |= status->mode & S_IALLUGO; |
da8d0755 | 202 | WRITE_ONCE(inode->i_mode, mode); |
a58823ac DH |
203 | } |
204 | ||
205 | t = status->mtime_client; | |
562ce1f7 | 206 | inode_set_mtime_to_ts(inode, t); |
da8d0755 | 207 | if (vp->update_ctime) |
b9170a28 | 208 | inode_set_ctime_to_ts(inode, op->ctime); |
a58823ac DH |
209 | |
210 | if (vnode->status.data_version != status->data_version) | |
211 | data_changed = true; | |
212 | ||
213 | vnode->status = *status; | |
214 | ||
e49c7b2f | 215 | if (vp->dv_before + vp->dv_delta != status->data_version) { |
453924de DH |
216 | if (vnode->cb_ro_snapshot == atomic_read(&vnode->volume->cb_ro_snapshot) && |
217 | atomic64_read(&vnode->cb_expires_at) != AFS_NO_CB_PROMISE) | |
f015cf1d | 218 | pr_warn("kAFS: vnode modified {%llx:%llu} %llx->%llx %s (op=%x)\n", |
3647e42b | 219 | vnode->fid.vid, vnode->fid.vnode, |
e49c7b2f | 220 | (unsigned long long)vp->dv_before + vp->dv_delta, |
3647e42b | 221 | (unsigned long long)status->data_version, |
f015cf1d DH |
222 | op->type ? op->type->name : "???", |
223 | op->debug_id); | |
3647e42b | 224 | |
a58823ac DH |
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); | |
229 | } else { | |
230 | set_bit(AFS_VNODE_ZAP_DATA, &vnode->flags); | |
231 | } | |
3f4aa981 | 232 | change_size = true; |
d7f74e9a | 233 | data_changed = true; |
100ccd18 | 234 | unexpected_jump = true; |
a58823ac DH |
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 | |
238 | * download. | |
239 | */ | |
240 | if (test_bit(AFS_VNODE_DIR_VALID, &vnode->flags)) | |
241 | data_changed = false; | |
3f4aa981 | 242 | change_size = true; |
a58823ac DH |
243 | } |
244 | ||
245 | if (data_changed) { | |
da8d0755 | 246 | inode_set_iversion_raw(inode, status->data_version); |
3f4aa981 DH |
247 | |
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. | |
252 | */ | |
874c8ca1 | 253 | vnode->netfs.remote_i_size = status->size; |
153a9961 | 254 | if (change_size || status->size > i_size_read(inode)) { |
3f4aa981 | 255 | afs_set_i_size(vnode, status->size); |
100ccd18 DH |
256 | if (unexpected_jump) |
257 | vnode->netfs.zero_point = status->size; | |
b9170a28 | 258 | inode_set_ctime_to_ts(inode, t); |
562ce1f7 | 259 | inode_set_atime_to_ts(inode, t); |
da8d0755 | 260 | } |
a58823ac DH |
261 | } |
262 | } | |
263 | ||
264 | /* | |
265 | * Apply a callback to a vnode. | |
266 | */ | |
e49c7b2f DH |
267 | static void afs_apply_callback(struct afs_operation *op, |
268 | struct afs_vnode_param *vp) | |
a58823ac | 269 | { |
e49c7b2f DH |
270 | struct afs_callback *cb = &vp->scb.callback; |
271 | struct afs_vnode *vnode = vp->vnode; | |
a58823ac | 272 | |
20325960 | 273 | if (!afs_cb_is_broken(vp->cb_break_before, vnode)) { |
453924de DH |
274 | if (op->volume->type == AFSVL_RWVOL) |
275 | vnode->cb_server = op->server; | |
276 | atomic64_set(&vnode->cb_expires_at, cb->expires_at); | |
a58823ac DH |
277 | } |
278 | } | |
279 | ||
280 | /* | |
281 | * Apply the received status and callback to an inode all in the same critical | |
282 | * section to avoid races with afs_validate(). | |
283 | */ | |
e49c7b2f | 284 | void afs_vnode_commit_status(struct afs_operation *op, struct afs_vnode_param *vp) |
a58823ac | 285 | { |
e49c7b2f DH |
286 | struct afs_vnode *vnode = vp->vnode; |
287 | ||
288 | _enter(""); | |
289 | ||
a58823ac DH |
290 | write_seqlock(&vnode->cb_lock); |
291 | ||
e49c7b2f | 292 | if (vp->scb.have_error) { |
b6489a49 DH |
293 | /* A YFS server will return this from RemoveFile2 and AFS and |
294 | * YFS will return this from InlineBulkStatus. | |
295 | */ | |
e49c7b2f | 296 | if (vp->scb.status.abort_code == VNOVNODE) { |
a38a7558 | 297 | set_bit(AFS_VNODE_DELETED, &vnode->flags); |
874c8ca1 | 298 | clear_nlink(&vnode->netfs.inode); |
051d2525 | 299 | __afs_break_callback(vnode, afs_cb_break_for_deleted); |
b6489a49 | 300 | op->flags &= ~AFS_OPERATION_DIR_CONFLICT; |
a38a7558 | 301 | } |
b6489a49 | 302 | } else if (vp->scb.have_status) { |
22650f14 DH |
303 | if (vp->speculative && |
304 | (test_bit(AFS_VNODE_MODIFYING, &vnode->flags) || | |
305 | vp->dv_before != vnode->status.data_version)) | |
a9e5c87c DH |
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. | |
309 | */ | |
310 | goto out; | |
b6489a49 | 311 | afs_apply_status(op, vp); |
e49c7b2f DH |
312 | if (vp->scb.have_cb) |
313 | afs_apply_callback(op, vp); | |
b6489a49 | 314 | } else if (vp->op_unlinked && !(op->flags & AFS_OPERATION_DIR_CONFLICT)) { |
874c8ca1 DH |
315 | drop_nlink(&vnode->netfs.inode); |
316 | if (vnode->netfs.inode.i_nlink == 0) { | |
b6489a49 DH |
317 | set_bit(AFS_VNODE_DELETED, &vnode->flags); |
318 | __afs_break_callback(vnode, afs_cb_break_for_deleted); | |
319 | } | |
a38a7558 | 320 | } |
a58823ac | 321 | |
a9e5c87c | 322 | out: |
a58823ac DH |
323 | write_sequnlock(&vnode->cb_lock); |
324 | ||
7c295eec | 325 | if (vp->scb.have_status) |
e49c7b2f | 326 | afs_cache_permit(vnode, op->key, vp->cb_break_before, &vp->scb); |
a58823ac DH |
327 | } |
328 | ||
e49c7b2f DH |
329 | static void afs_fetch_status_success(struct afs_operation *op) |
330 | { | |
b6489a49 | 331 | struct afs_vnode_param *vp = &op->file[op->fetch_status.which]; |
e49c7b2f DH |
332 | struct afs_vnode *vnode = vp->vnode; |
333 | int ret; | |
334 | ||
874c8ca1 | 335 | if (vnode->netfs.inode.i_state & I_NEW) { |
e49c7b2f | 336 | ret = afs_inode_init_from_status(op, vp, vnode); |
2de5599f | 337 | afs_op_set_error(op, ret); |
e49c7b2f DH |
338 | if (ret == 0) |
339 | afs_cache_permit(vnode, op->key, vp->cb_break_before, &vp->scb); | |
340 | } else { | |
341 | afs_vnode_commit_status(op, vp); | |
342 | } | |
343 | } | |
344 | ||
b6489a49 | 345 | const struct afs_operation_ops afs_fetch_status_operation = { |
e49c7b2f DH |
346 | .issue_afs_rpc = afs_fs_fetch_status, |
347 | .issue_yfs_rpc = yfs_fs_fetch_status, | |
348 | .success = afs_fetch_status_success, | |
728279a5 | 349 | .aborted = afs_check_for_remote_deletion, |
e49c7b2f DH |
350 | }; |
351 | ||
d2ddc776 DH |
352 | /* |
353 | * Fetch file status from the volume. | |
354 | */ | |
a58823ac DH |
355 | int afs_fetch_status(struct afs_vnode *vnode, struct key *key, bool is_new, |
356 | afs_access_t *_caller_access) | |
d2ddc776 | 357 | { |
e49c7b2f | 358 | struct afs_operation *op; |
d2ddc776 | 359 | |
3b6492df | 360 | _enter("%s,{%llx:%llu.%u,S=%lx}", |
d2ddc776 DH |
361 | vnode->volume->name, |
362 | vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique, | |
363 | vnode->flags); | |
364 | ||
e49c7b2f DH |
365 | op = afs_alloc_operation(key, vnode->volume); |
366 | if (IS_ERR(op)) | |
367 | return PTR_ERR(op); | |
a58823ac | 368 | |
e49c7b2f | 369 | afs_op_set_vnode(op, 0, vnode); |
a58823ac | 370 | |
e49c7b2f DH |
371 | op->nr_files = 1; |
372 | op->ops = &afs_fetch_status_operation; | |
373 | afs_begin_vnode_operation(op); | |
374 | afs_wait_for_operation(op); | |
d2ddc776 | 375 | |
e49c7b2f DH |
376 | if (_caller_access) |
377 | *_caller_access = op->file[0].scb.status.caller_access; | |
378 | return afs_put_operation(op); | |
d2ddc776 DH |
379 | } |
380 | ||
1da177e4 | 381 | /* |
e49c7b2f | 382 | * ilookup() comparator |
1da177e4 | 383 | */ |
e49c7b2f | 384 | int afs_ilookup5_test_by_fid(struct inode *inode, void *opaque) |
1da177e4 | 385 | { |
3b6492df | 386 | struct afs_vnode *vnode = AFS_FS_I(inode); |
e49c7b2f | 387 | struct afs_fid *fid = opaque; |
1da177e4 | 388 | |
e49c7b2f DH |
389 | return (fid->vnode == vnode->fid.vnode && |
390 | fid->vnode_hi == vnode->fid.vnode_hi && | |
391 | fid->unique == vnode->fid.unique); | |
ec26815a | 392 | } |
1da177e4 | 393 | |
bec5eb61 | 394 | /* |
e49c7b2f | 395 | * iget5() comparator |
bec5eb61 | 396 | */ |
e49c7b2f | 397 | static int afs_iget5_test(struct inode *inode, void *opaque) |
bec5eb61 | 398 | { |
e49c7b2f DH |
399 | struct afs_vnode_param *vp = opaque; |
400 | //struct afs_vnode *vnode = AFS_FS_I(inode); | |
401 | ||
402 | return afs_ilookup5_test_by_fid(inode, &vp->fid); | |
bec5eb61 | 403 | } |
404 | ||
1da177e4 LT |
405 | /* |
406 | * iget5() inode initialiser | |
407 | */ | |
408 | static int afs_iget5_set(struct inode *inode, void *opaque) | |
409 | { | |
e49c7b2f DH |
410 | struct afs_vnode_param *vp = opaque; |
411 | struct afs_super_info *as = AFS_FS_S(inode->i_sb); | |
1da177e4 LT |
412 | struct afs_vnode *vnode = AFS_FS_I(inode); |
413 | ||
e49c7b2f DH |
414 | vnode->volume = as->volume; |
415 | vnode->fid = vp->fid; | |
1da177e4 | 416 | |
3b6492df DH |
417 | /* YFS supports 96-bit vnode IDs, but Linux only supports |
418 | * 64-bit inode numbers. | |
419 | */ | |
e49c7b2f DH |
420 | inode->i_ino = vnode->fid.vnode; |
421 | inode->i_generation = vnode->fid.unique; | |
1da177e4 | 422 | return 0; |
ec26815a | 423 | } |
1da177e4 | 424 | |
402cb8dd DH |
425 | /* |
426 | * Get a cache cookie for an inode. | |
427 | */ | |
428 | static void afs_get_inode_cache(struct afs_vnode *vnode) | |
429 | { | |
430 | #ifdef CONFIG_AFS_FSCACHE | |
431 | struct { | |
523d27cd DH |
432 | __be32 vnode_id; |
433 | __be32 unique; | |
434 | __be32 vnode_id_ext[2]; /* Allow for a 96-bit key */ | |
402cb8dd DH |
435 | } __packed key; |
436 | struct afs_vnode_cache_aux aux; | |
437 | ||
03ffae90 | 438 | if (vnode->status.type != AFS_FTYPE_FILE) { |
874c8ca1 | 439 | vnode->netfs.cache = NULL; |
f3ddee8d DH |
440 | return; |
441 | } | |
442 | ||
523d27cd DH |
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); | |
448 | ||
bc899ee1 DH |
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, | |
454 | &key, sizeof(key), | |
455 | &aux, sizeof(aux), | |
45f66fa0 | 456 | i_size_read(&vnode->netfs.inode))); |
402cb8dd DH |
457 | #endif |
458 | } | |
459 | ||
1da177e4 LT |
460 | /* |
461 | * inode retrieval | |
462 | */ | |
e49c7b2f | 463 | struct inode *afs_iget(struct afs_operation *op, struct afs_vnode_param *vp) |
1da177e4 | 464 | { |
e49c7b2f | 465 | struct afs_vnode_param *dvp = &op->file[0]; |
874c8ca1 | 466 | struct super_block *sb = dvp->vnode->netfs.inode.i_sb; |
1da177e4 LT |
467 | struct afs_vnode *vnode; |
468 | struct inode *inode; | |
469 | int ret; | |
470 | ||
e49c7b2f | 471 | _enter(",{%llx:%llu.%u},,", vp->fid.vid, vp->fid.vnode, vp->fid.unique); |
1da177e4 | 472 | |
e49c7b2f | 473 | inode = iget5_locked(sb, vp->fid.vnode, afs_iget5_test, afs_iget5_set, vp); |
1da177e4 LT |
474 | if (!inode) { |
475 | _leave(" = -ENOMEM"); | |
08e0e7c8 | 476 | return ERR_PTR(-ENOMEM); |
1da177e4 LT |
477 | } |
478 | ||
479 | vnode = AFS_FS_I(inode); | |
480 | ||
e49c7b2f DH |
481 | _debug("GOT INODE %p { vl=%llx vn=%llx, u=%x }", |
482 | inode, vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique); | |
483 | ||
1da177e4 LT |
484 | /* deal with an existing inode */ |
485 | if (!(inode->i_state & I_NEW)) { | |
08e0e7c8 DH |
486 | _leave(" = %p", inode); |
487 | return inode; | |
1da177e4 LT |
488 | } |
489 | ||
e49c7b2f DH |
490 | ret = afs_inode_init_from_status(op, vp, vnode); |
491 | if (ret < 0) | |
492 | goto bad_inode; | |
260a9803 | 493 | |
5800db81 DH |
494 | afs_get_inode_cache(vnode); |
495 | ||
1da177e4 | 496 | /* success */ |
260a9803 | 497 | clear_bit(AFS_VNODE_UNSET, &vnode->flags); |
1da177e4 | 498 | unlock_new_inode(inode); |
7c712458 | 499 | _leave(" = %p", inode); |
08e0e7c8 | 500 | return inode; |
1da177e4 LT |
501 | |
502 | /* failure */ | |
ec26815a | 503 | bad_inode: |
aa7fa240 | 504 | iget_failed(inode); |
1da177e4 | 505 | _leave(" = %d [bad]", ret); |
08e0e7c8 | 506 | return ERR_PTR(ret); |
ec26815a | 507 | } |
1da177e4 | 508 | |
e49c7b2f DH |
509 | static int afs_iget5_set_root(struct inode *inode, void *opaque) |
510 | { | |
511 | struct afs_super_info *as = AFS_FS_S(inode->i_sb); | |
512 | struct afs_vnode *vnode = AFS_FS_I(inode); | |
513 | ||
514 | vnode->volume = as->volume; | |
655593a4 | 515 | vnode->fid.vid = as->volume->vid; |
e49c7b2f DH |
516 | vnode->fid.vnode = 1; |
517 | vnode->fid.unique = 1; | |
518 | inode->i_ino = 1; | |
519 | inode->i_generation = 1; | |
520 | return 0; | |
521 | } | |
522 | ||
523 | /* | |
524 | * Set up the root inode for a volume. This is always vnode 1, unique 1 within | |
525 | * the volume. | |
526 | */ | |
527 | struct inode *afs_root_iget(struct super_block *sb, struct key *key) | |
528 | { | |
529 | struct afs_super_info *as = AFS_FS_S(sb); | |
530 | struct afs_operation *op; | |
531 | struct afs_vnode *vnode; | |
532 | struct inode *inode; | |
533 | int ret; | |
534 | ||
535 | _enter(",{%llx},,", as->volume->vid); | |
536 | ||
537 | inode = iget5_locked(sb, 1, NULL, afs_iget5_set_root, NULL); | |
538 | if (!inode) { | |
539 | _leave(" = -ENOMEM"); | |
540 | return ERR_PTR(-ENOMEM); | |
541 | } | |
542 | ||
543 | _debug("GOT ROOT INODE %p { vl=%llx }", inode, as->volume->vid); | |
544 | ||
545 | BUG_ON(!(inode->i_state & I_NEW)); | |
546 | ||
547 | vnode = AFS_FS_I(inode); | |
655593a4 | 548 | vnode->cb_v_check = atomic_read(&as->volume->cb_v_break); |
bc899ee1 | 549 | afs_set_netfs_context(vnode); |
e49c7b2f DH |
550 | |
551 | op = afs_alloc_operation(key, as->volume); | |
552 | if (IS_ERR(op)) { | |
553 | ret = PTR_ERR(op); | |
554 | goto error; | |
555 | } | |
556 | ||
557 | afs_op_set_vnode(op, 0, vnode); | |
558 | ||
559 | op->nr_files = 1; | |
560 | op->ops = &afs_fetch_status_operation; | |
561 | ret = afs_do_sync_operation(op); | |
562 | if (ret < 0) | |
563 | goto error; | |
564 | ||
565 | afs_get_inode_cache(vnode); | |
566 | ||
567 | clear_bit(AFS_VNODE_UNSET, &vnode->flags); | |
568 | unlock_new_inode(inode); | |
569 | _leave(" = %p", inode); | |
570 | return inode; | |
571 | ||
572 | error: | |
573 | iget_failed(inode); | |
574 | _leave(" = %d [bad]", ret); | |
575 | return ERR_PTR(ret); | |
576 | } | |
577 | ||
1da177e4 LT |
578 | /* |
579 | * read the attributes of an inode | |
580 | */ | |
b74d24f7 | 581 | int afs_getattr(struct mnt_idmap *idmap, const struct path *path, |
549c7297 | 582 | struct kstat *stat, u32 request_mask, unsigned int query_flags) |
1da177e4 | 583 | { |
a528d35e | 584 | struct inode *inode = d_inode(path->dentry); |
c435ee34 | 585 | struct afs_vnode *vnode = AFS_FS_I(inode); |
2aeb8c86 | 586 | struct key *key; |
df91b9df | 587 | int ret, seq; |
1da177e4 | 588 | |
d6e43f75 | 589 | _enter("{ ino=%lu v=%u }", inode->i_ino, inode->i_generation); |
1da177e4 | 590 | |
cb78d1b5 DH |
591 | if (vnode->volume && |
592 | !(query_flags & AT_STATX_DONT_SYNC) && | |
453924de | 593 | atomic64_read(&vnode->cb_expires_at) == AFS_NO_CB_PROMISE) { |
2aeb8c86 DH |
594 | key = afs_request_key(vnode->volume->cell); |
595 | if (IS_ERR(key)) | |
596 | return PTR_ERR(key); | |
597 | ret = afs_validate(vnode, key); | |
598 | key_put(key); | |
599 | if (ret < 0) | |
600 | return ret; | |
601 | } | |
602 | ||
c435ee34 | 603 | do { |
df91b9df | 604 | seq = read_seqbegin(&vnode->cb_lock); |
0d72b928 | 605 | generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat); |
b6489a49 DH |
606 | if (test_bit(AFS_VNODE_SILLY_DELETED, &vnode->flags) && |
607 | stat->nlink > 0) | |
608 | stat->nlink -= 1; | |
45f66fa0 DH |
609 | |
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. | |
613 | */ | |
614 | if (S_ISDIR(inode->i_mode)) | |
615 | stat->size = vnode->netfs.remote_i_size; | |
df91b9df | 616 | } while (read_seqretry(&vnode->cb_lock, seq)); |
c435ee34 | 617 | |
1da177e4 | 618 | return 0; |
ec26815a | 619 | } |
1da177e4 | 620 | |
bec5eb61 | 621 | /* |
622 | * discard an AFS inode | |
623 | */ | |
624 | int afs_drop_inode(struct inode *inode) | |
625 | { | |
626 | _enter(""); | |
627 | ||
628 | if (test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(inode)->flags)) | |
629 | return generic_delete_inode(inode); | |
630 | else | |
631 | return generic_drop_inode(inode); | |
632 | } | |
633 | ||
1da177e4 LT |
634 | /* |
635 | * clear an AFS inode | |
636 | */ | |
b57922d9 | 637 | void afs_evict_inode(struct inode *inode) |
1da177e4 | 638 | { |
c7f75ef3 DH |
639 | struct afs_vnode_cache_aux aux; |
640 | struct afs_vnode *vnode = AFS_FS_I(inode); | |
1da177e4 | 641 | |
3b6492df | 642 | _enter("{%llx:%llu.%d}", |
260a9803 | 643 | vnode->fid.vid, |
1da177e4 | 644 | vnode->fid.vnode, |
c435ee34 | 645 | vnode->fid.unique); |
1da177e4 | 646 | |
08e0e7c8 DH |
647 | _debug("CLEAR INODE %p", inode); |
648 | ||
649 | ASSERTCMP(inode->i_ino, ==, vnode->fid.vnode); | |
650 | ||
f89ea63f | 651 | netfs_wait_for_outstanding_io(inode); |
91b0abe3 | 652 | truncate_inode_pages_final(&inode->i_data); |
c7f75ef3 DH |
653 | |
654 | afs_set_cache_aux(vnode, &aux); | |
c9c4ff12 | 655 | netfs_clear_inode_writeback(inode, &aux); |
dbd5768f | 656 | clear_inode(inode); |
b57922d9 | 657 | |
4343d008 DH |
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); | |
662 | afs_put_wb_key(wbk); | |
663 | } | |
1da177e4 | 664 | |
bc899ee1 | 665 | fscache_relinquish_cookie(afs_vnode_cache(vnode), |
523d27cd | 666 | test_bit(AFS_VNODE_DELETED, &vnode->flags)); |
1da177e4 | 667 | |
a1b879ee | 668 | afs_prune_wb_keys(vnode); |
fe342cf7 | 669 | afs_put_permits(rcu_access_pointer(vnode->permit_cache)); |
79ddbfa5 DH |
670 | key_put(vnode->silly_key); |
671 | vnode->silly_key = NULL; | |
59d49076 DH |
672 | key_put(vnode->lock_key); |
673 | vnode->lock_key = NULL; | |
1da177e4 | 674 | _leave(""); |
ec26815a | 675 | } |
31143d5d | 676 | |
e49c7b2f DH |
677 | static void afs_setattr_success(struct afs_operation *op) |
678 | { | |
ec0fa0b6 | 679 | struct afs_vnode_param *vp = &op->file[0]; |
874c8ca1 | 680 | struct inode *inode = &vp->vnode->netfs.inode; |
ec0fa0b6 DH |
681 | loff_t old_i_size = i_size_read(inode); |
682 | ||
683 | op->setattr.old_i_size = old_i_size; | |
684 | afs_vnode_commit_status(op, vp); | |
685 | /* inode->i_size has now been changed. */ | |
686 | ||
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); | |
691 | } | |
692 | } | |
693 | ||
694 | static void afs_setattr_edit_file(struct afs_operation *op) | |
695 | { | |
696 | struct afs_vnode_param *vp = &op->file[0]; | |
100ccd18 | 697 | struct afs_vnode *vnode = vp->vnode; |
a74ee0e8 | 698 | struct inode *inode = &vnode->netfs.inode; |
793fe82e | 699 | |
793fe82e | 700 | if (op->setattr.attr->ia_valid & ATTR_SIZE) { |
ec0fa0b6 | 701 | loff_t size = op->setattr.attr->ia_size; |
a74ee0e8 DH |
702 | loff_t old = op->setattr.old_i_size; |
703 | ||
704 | /* Note: inode->i_size was updated by afs_apply_status() inside | |
705 | * the I/O and callback locks. | |
706 | */ | |
ec0fa0b6 | 707 | |
a74ee0e8 DH |
708 | if (size != old) { |
709 | truncate_pagecache(inode, size); | |
100ccd18 DH |
710 | netfs_resize_file(&vnode->netfs, size, true); |
711 | fscache_resize_cookie(afs_vnode_cache(vnode), size); | |
712 | } | |
793fe82e | 713 | } |
e49c7b2f DH |
714 | } |
715 | ||
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, | |
ec0fa0b6 | 720 | .edit_dir = afs_setattr_edit_file, |
e49c7b2f DH |
721 | }; |
722 | ||
31143d5d DH |
723 | /* |
724 | * set the attributes of an inode | |
725 | */ | |
c1632a0f | 726 | int afs_setattr(struct mnt_idmap *idmap, struct dentry *dentry, |
549c7297 | 727 | struct iattr *attr) |
31143d5d | 728 | { |
0770bd41 DH |
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; | |
e49c7b2f | 732 | struct afs_operation *op; |
2b0143b5 | 733 | struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry)); |
874c8ca1 | 734 | struct inode *inode = &vnode->netfs.inode; |
0770bd41 | 735 | loff_t i_size; |
793fe82e | 736 | int ret; |
31143d5d | 737 | |
3b6492df | 738 | _enter("{%llx:%llu},{n=%pd},%x", |
a455589f | 739 | vnode->fid.vid, vnode->fid.vnode, dentry, |
31143d5d DH |
740 | attr->ia_valid); |
741 | ||
0770bd41 | 742 | if (!(attr->ia_valid & supported)) { |
31143d5d DH |
743 | _leave(" = 0 [unsupported]"); |
744 | return 0; | |
745 | } | |
746 | ||
0770bd41 | 747 | i_size = i_size_read(inode); |
793fe82e | 748 | if (attr->ia_valid & ATTR_SIZE) { |
0770bd41 | 749 | if (!S_ISREG(inode->i_mode)) |
793fe82e DH |
750 | return -EISDIR; |
751 | ||
0770bd41 | 752 | ret = inode_newsize_ok(inode, attr->ia_size); |
793fe82e DH |
753 | if (ret) |
754 | return ret; | |
755 | ||
0770bd41 | 756 | if (attr->ia_size == i_size) |
793fe82e DH |
757 | attr->ia_valid &= ~ATTR_SIZE; |
758 | } | |
759 | ||
523d27cd DH |
760 | fscache_use_cookie(afs_vnode_cache(vnode), true); |
761 | ||
ec0fa0b6 DH |
762 | /* Prevent any new writebacks from starting whilst we do this. */ |
763 | down_write(&vnode->validate_lock); | |
764 | ||
0770bd41 DH |
765 | if ((attr->ia_valid & ATTR_SIZE) && S_ISREG(inode->i_mode)) { |
766 | loff_t size = attr->ia_size; | |
767 | ||
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); | |
772 | if (ret < 0) | |
773 | goto out_unlock; | |
774 | ||
775 | /* Don't talk to the server if we're just shortening in-memory | |
776 | * writes that haven't gone to the server yet. | |
777 | */ | |
778 | if (!(attr->ia_valid & (supported & ~ATTR_SIZE & ~ATTR_MTIME)) && | |
779 | attr->ia_size < i_size && | |
100ccd18 DH |
780 | attr->ia_size > vnode->netfs.remote_i_size) { |
781 | truncate_setsize(inode, attr->ia_size); | |
782 | netfs_resize_file(&vnode->netfs, size, false); | |
0770bd41 DH |
783 | fscache_resize_cookie(afs_vnode_cache(vnode), |
784 | attr->ia_size); | |
0770bd41 DH |
785 | ret = 0; |
786 | goto out_unlock; | |
787 | } | |
788 | } | |
789 | ||
e49c7b2f DH |
790 | op = afs_alloc_operation(((attr->ia_valid & ATTR_FILE) ? |
791 | afs_file_key(attr->ia_file) : NULL), | |
792 | vnode->volume); | |
ec0fa0b6 DH |
793 | if (IS_ERR(op)) { |
794 | ret = PTR_ERR(op); | |
795 | goto out_unlock; | |
796 | } | |
d2ddc776 | 797 | |
e49c7b2f DH |
798 | afs_op_set_vnode(op, 0, vnode); |
799 | op->setattr.attr = attr; | |
d2ddc776 | 800 | |
793fe82e | 801 | if (attr->ia_valid & ATTR_SIZE) { |
e49c7b2f | 802 | op->file[0].dv_delta = 1; |
793fe82e DH |
803 | op->file[0].set_size = true; |
804 | } | |
da8d0755 DH |
805 | op->ctime = attr->ia_ctime; |
806 | op->file[0].update_ctime = 1; | |
22650f14 | 807 | op->file[0].modification = true; |
31143d5d | 808 | |
e49c7b2f | 809 | op->ops = &afs_setattr_operation; |
ec0fa0b6 DH |
810 | ret = afs_do_sync_operation(op); |
811 | ||
812 | out_unlock: | |
813 | up_write(&vnode->validate_lock); | |
523d27cd | 814 | fscache_unuse_cookie(afs_vnode_cache(vnode), NULL, NULL); |
ec0fa0b6 DH |
815 | _leave(" = %d", ret); |
816 | return ret; | |
31143d5d | 817 | } |