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 | * |
11 | * Authors: David Woodhouse <dwmw2@infradead.org> |
12 | * David Howells <dhowells@redhat.com> |
13 | * |
14 | */ |
15 | |
16 | #include <linux/kernel.h> |
17 | #include <linux/module.h> |
18 | #include <linux/init.h> |
19 | #include <linux/fs.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> |
25 | #include "internal.h" |
26 | #include "afs_fs.h" |
27 | |
28 | static const struct inode_operations afs_symlink_inode_operations = { |
29 | .get_link = page_get_link, |
30 | }; |
31 | |
32 | static noinline void dump_vnode(struct afs_vnode *vnode, struct afs_vnode *parent_vnode) |
33 | { |
34 | static unsigned long once_only; |
35 | |
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, |
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(nr: 0, addr: &once_only)) |
53 | dump_stack(); |
54 | } |
55 | |
56 | /* |
57 | * Set parameters for the netfs library |
58 | */ |
59 | static void afs_set_netfs_context(struct afs_vnode *vnode) |
60 | { |
61 | netfs_inode_init(ctx: &vnode->netfs, ops: &afs_req_ops); |
62 | } |
63 | |
64 | /* |
65 | * Initialise an inode from the vnode status. |
66 | */ |
67 | static int afs_inode_init_from_status(struct afs_operation *op, |
68 | struct afs_vnode_param *vp, |
69 | struct afs_vnode *vnode) |
70 | { |
71 | struct afs_file_status *status = &vp->scb.status; |
72 | struct inode *inode = AFS_VNODE_TO_I(vnode); |
73 | struct timespec64 t; |
74 | |
75 | _enter("{%llx:%llu.%u} %s" , |
76 | vp->fid.vid, vp->fid.vnode, vp->fid.unique, |
77 | op->type ? op->type->name : "???" ); |
78 | |
79 | _debug("FS: ft=%d lk=%d sz=%llu ver=%Lu mod=%hu" , |
80 | status->type, |
81 | status->nlink, |
82 | (unsigned long long) status->size, |
83 | status->data_version, |
84 | status->mode); |
85 | |
86 | write_seqlock(sl: &vnode->cb_lock); |
87 | |
88 | vnode->cb_v_break = op->cb_v_break; |
89 | vnode->cb_s_break = op->cb_s_break; |
90 | vnode->status = *status; |
91 | |
92 | t = status->mtime_client; |
93 | inode_set_ctime_to_ts(inode, ts: t); |
94 | inode_set_mtime_to_ts(inode, ts: t); |
95 | inode_set_atime_to_ts(inode, ts: t); |
96 | inode->i_flags |= S_NOATIME; |
97 | inode->i_uid = make_kuid(from: &init_user_ns, uid: status->owner); |
98 | inode->i_gid = make_kgid(from: &init_user_ns, gid: status->group); |
99 | set_nlink(inode: &vnode->netfs.inode, nlink: status->nlink); |
100 | |
101 | switch (status->type) { |
102 | case AFS_FTYPE_FILE: |
103 | inode->i_mode = S_IFREG | (status->mode & S_IALLUGO); |
104 | inode->i_op = &afs_file_inode_operations; |
105 | inode->i_fop = &afs_file_operations; |
106 | inode->i_mapping->a_ops = &afs_file_aops; |
107 | mapping_set_large_folios(mapping: inode->i_mapping); |
108 | break; |
109 | case AFS_FTYPE_DIR: |
110 | inode->i_mode = S_IFDIR | (status->mode & S_IALLUGO); |
111 | inode->i_op = &afs_dir_inode_operations; |
112 | inode->i_fop = &afs_dir_file_operations; |
113 | inode->i_mapping->a_ops = &afs_dir_aops; |
114 | mapping_set_large_folios(mapping: inode->i_mapping); |
115 | break; |
116 | case AFS_FTYPE_SYMLINK: |
117 | /* Symlinks with a mode of 0644 are actually mountpoints. */ |
118 | if ((status->mode & 0777) == 0644) { |
119 | inode->i_flags |= S_AUTOMOUNT; |
120 | |
121 | set_bit(AFS_VNODE_MOUNTPOINT, addr: &vnode->flags); |
122 | |
123 | inode->i_mode = S_IFDIR | 0555; |
124 | inode->i_op = &afs_mntpt_inode_operations; |
125 | inode->i_fop = &afs_mntpt_file_operations; |
126 | inode->i_mapping->a_ops = &afs_symlink_aops; |
127 | } else { |
128 | inode->i_mode = S_IFLNK | status->mode; |
129 | inode->i_op = &afs_symlink_inode_operations; |
130 | inode->i_mapping->a_ops = &afs_symlink_aops; |
131 | } |
132 | inode_nohighmem(inode); |
133 | break; |
134 | default: |
135 | dump_vnode(vnode, parent_vnode: op->file[0].vnode != vnode ? op->file[0].vnode : NULL); |
136 | write_sequnlock(sl: &vnode->cb_lock); |
137 | return afs_protocol_error(NULL, afs_eproto_file_type); |
138 | } |
139 | |
140 | afs_set_i_size(vnode, size: status->size); |
141 | afs_set_netfs_context(vnode); |
142 | |
143 | vnode->invalid_before = status->data_version; |
144 | inode_set_iversion_raw(inode: &vnode->netfs.inode, val: status->data_version); |
145 | |
146 | if (!vp->scb.have_cb) { |
147 | /* it's a symlink we just created (the fileserver |
148 | * didn't give us a callback) */ |
149 | vnode->cb_expires_at = ktime_get_real_seconds(); |
150 | } else { |
151 | vnode->cb_expires_at = vp->scb.callback.expires_at; |
152 | vnode->cb_server = op->server; |
153 | set_bit(AFS_VNODE_CB_PROMISED, addr: &vnode->flags); |
154 | } |
155 | |
156 | write_sequnlock(sl: &vnode->cb_lock); |
157 | return 0; |
158 | } |
159 | |
160 | /* |
161 | * Update the core inode struct from a returned status record. |
162 | */ |
163 | static void afs_apply_status(struct afs_operation *op, |
164 | struct afs_vnode_param *vp) |
165 | { |
166 | struct afs_file_status *status = &vp->scb.status; |
167 | struct afs_vnode *vnode = vp->vnode; |
168 | struct inode *inode = &vnode->netfs.inode; |
169 | struct timespec64 t; |
170 | umode_t mode; |
171 | bool data_changed = false; |
172 | bool change_size = vp->set_size; |
173 | |
174 | _enter("{%llx:%llu.%u} %s" , |
175 | vp->fid.vid, vp->fid.vnode, vp->fid.unique, |
176 | op->type ? op->type->name : "???" ); |
177 | |
178 | BUG_ON(test_bit(AFS_VNODE_UNSET, &vnode->flags)); |
179 | |
180 | if (status->type != vnode->status.type) { |
181 | pr_warn("Vnode %llx:%llx:%x changed type %u to %u\n" , |
182 | vnode->fid.vid, |
183 | vnode->fid.vnode, |
184 | vnode->fid.unique, |
185 | status->type, vnode->status.type); |
186 | afs_protocol_error(NULL, afs_eproto_bad_status); |
187 | return; |
188 | } |
189 | |
190 | if (status->nlink != vnode->status.nlink) |
191 | set_nlink(inode, nlink: status->nlink); |
192 | |
193 | if (status->owner != vnode->status.owner) |
194 | inode->i_uid = make_kuid(from: &init_user_ns, uid: status->owner); |
195 | |
196 | if (status->group != vnode->status.group) |
197 | inode->i_gid = make_kgid(from: &init_user_ns, gid: status->group); |
198 | |
199 | if (status->mode != vnode->status.mode) { |
200 | mode = inode->i_mode; |
201 | mode &= ~S_IALLUGO; |
202 | mode |= status->mode & S_IALLUGO; |
203 | WRITE_ONCE(inode->i_mode, mode); |
204 | } |
205 | |
206 | t = status->mtime_client; |
207 | inode_set_mtime_to_ts(inode, ts: t); |
208 | if (vp->update_ctime) |
209 | inode_set_ctime_to_ts(inode, ts: op->ctime); |
210 | |
211 | if (vnode->status.data_version != status->data_version) |
212 | data_changed = true; |
213 | |
214 | vnode->status = *status; |
215 | |
216 | if (vp->dv_before + vp->dv_delta != status->data_version) { |
217 | if (test_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) |
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 : "???" , |
223 | op->debug_id); |
224 | |
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, addr: &vnode->flags)) |
228 | afs_stat_v(vnode, n_inval); |
229 | } else { |
230 | set_bit(AFS_VNODE_ZAP_DATA, addr: &vnode->flags); |
231 | } |
232 | change_size = true; |
233 | data_changed = true; |
234 | } else if (vnode->status.type == AFS_FTYPE_DIR) { |
235 | /* Expected directory change is handled elsewhere so |
236 | * that we can locally edit the directory and save on a |
237 | * download. |
238 | */ |
239 | if (test_bit(AFS_VNODE_DIR_VALID, &vnode->flags)) |
240 | data_changed = false; |
241 | change_size = true; |
242 | } |
243 | |
244 | if (data_changed) { |
245 | inode_set_iversion_raw(inode, val: status->data_version); |
246 | |
247 | /* Only update the size if the data version jumped. If the |
248 | * file is being modified locally, then we might have our own |
249 | * idea of what the size should be that's not the same as |
250 | * what's on the server. |
251 | */ |
252 | vnode->netfs.remote_i_size = status->size; |
253 | if (change_size) { |
254 | afs_set_i_size(vnode, size: status->size); |
255 | inode_set_ctime_to_ts(inode, ts: t); |
256 | inode_set_atime_to_ts(inode, ts: t); |
257 | } |
258 | } |
259 | } |
260 | |
261 | /* |
262 | * Apply a callback to a vnode. |
263 | */ |
264 | static void afs_apply_callback(struct afs_operation *op, |
265 | struct afs_vnode_param *vp) |
266 | { |
267 | struct afs_callback *cb = &vp->scb.callback; |
268 | struct afs_vnode *vnode = vp->vnode; |
269 | |
270 | if (!afs_cb_is_broken(cb_break: vp->cb_break_before, vnode)) { |
271 | vnode->cb_expires_at = cb->expires_at; |
272 | vnode->cb_server = op->server; |
273 | set_bit(AFS_VNODE_CB_PROMISED, addr: &vnode->flags); |
274 | } |
275 | } |
276 | |
277 | /* |
278 | * Apply the received status and callback to an inode all in the same critical |
279 | * section to avoid races with afs_validate(). |
280 | */ |
281 | void afs_vnode_commit_status(struct afs_operation *op, struct afs_vnode_param *vp) |
282 | { |
283 | struct afs_vnode *vnode = vp->vnode; |
284 | |
285 | _enter("" ); |
286 | |
287 | write_seqlock(sl: &vnode->cb_lock); |
288 | |
289 | if (vp->scb.have_error) { |
290 | /* A YFS server will return this from RemoveFile2 and AFS and |
291 | * YFS will return this from InlineBulkStatus. |
292 | */ |
293 | if (vp->scb.status.abort_code == VNOVNODE) { |
294 | set_bit(AFS_VNODE_DELETED, addr: &vnode->flags); |
295 | clear_nlink(inode: &vnode->netfs.inode); |
296 | __afs_break_callback(vnode, afs_cb_break_for_deleted); |
297 | op->flags &= ~AFS_OPERATION_DIR_CONFLICT; |
298 | } |
299 | } else if (vp->scb.have_status) { |
300 | if (vp->speculative && |
301 | (test_bit(AFS_VNODE_MODIFYING, &vnode->flags) || |
302 | vp->dv_before != vnode->status.data_version)) |
303 | /* Ignore the result of a speculative bulk status fetch |
304 | * if it splits around a modification op, thereby |
305 | * appearing to regress the data version. |
306 | */ |
307 | goto out; |
308 | afs_apply_status(op, vp); |
309 | if (vp->scb.have_cb) |
310 | afs_apply_callback(op, vp); |
311 | } else if (vp->op_unlinked && !(op->flags & AFS_OPERATION_DIR_CONFLICT)) { |
312 | drop_nlink(inode: &vnode->netfs.inode); |
313 | if (vnode->netfs.inode.i_nlink == 0) { |
314 | set_bit(AFS_VNODE_DELETED, addr: &vnode->flags); |
315 | __afs_break_callback(vnode, afs_cb_break_for_deleted); |
316 | } |
317 | } |
318 | |
319 | out: |
320 | write_sequnlock(sl: &vnode->cb_lock); |
321 | |
322 | if (vp->scb.have_status) |
323 | afs_cache_permit(vnode, op->key, vp->cb_break_before, &vp->scb); |
324 | } |
325 | |
326 | static void afs_fetch_status_success(struct afs_operation *op) |
327 | { |
328 | struct afs_vnode_param *vp = &op->file[op->fetch_status.which]; |
329 | struct afs_vnode *vnode = vp->vnode; |
330 | int ret; |
331 | |
332 | if (vnode->netfs.inode.i_state & I_NEW) { |
333 | ret = afs_inode_init_from_status(op, vp, vnode); |
334 | op->error = ret; |
335 | if (ret == 0) |
336 | afs_cache_permit(vnode, op->key, vp->cb_break_before, &vp->scb); |
337 | } else { |
338 | afs_vnode_commit_status(op, vp); |
339 | } |
340 | } |
341 | |
342 | const struct afs_operation_ops afs_fetch_status_operation = { |
343 | .issue_afs_rpc = afs_fs_fetch_status, |
344 | .issue_yfs_rpc = yfs_fs_fetch_status, |
345 | .success = afs_fetch_status_success, |
346 | .aborted = afs_check_for_remote_deletion, |
347 | }; |
348 | |
349 | /* |
350 | * Fetch file status from the volume. |
351 | */ |
352 | int afs_fetch_status(struct afs_vnode *vnode, struct key *key, bool is_new, |
353 | afs_access_t *_caller_access) |
354 | { |
355 | struct afs_operation *op; |
356 | |
357 | _enter("%s,{%llx:%llu.%u,S=%lx}" , |
358 | vnode->volume->name, |
359 | vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique, |
360 | vnode->flags); |
361 | |
362 | op = afs_alloc_operation(key, vnode->volume); |
363 | if (IS_ERR(ptr: op)) |
364 | return PTR_ERR(ptr: op); |
365 | |
366 | afs_op_set_vnode(op, n: 0, vnode); |
367 | |
368 | op->nr_files = 1; |
369 | op->ops = &afs_fetch_status_operation; |
370 | afs_begin_vnode_operation(op); |
371 | afs_wait_for_operation(op); |
372 | |
373 | if (_caller_access) |
374 | *_caller_access = op->file[0].scb.status.caller_access; |
375 | return afs_put_operation(op); |
376 | } |
377 | |
378 | /* |
379 | * ilookup() comparator |
380 | */ |
381 | int afs_ilookup5_test_by_fid(struct inode *inode, void *opaque) |
382 | { |
383 | struct afs_vnode *vnode = AFS_FS_I(inode); |
384 | struct afs_fid *fid = opaque; |
385 | |
386 | return (fid->vnode == vnode->fid.vnode && |
387 | fid->vnode_hi == vnode->fid.vnode_hi && |
388 | fid->unique == vnode->fid.unique); |
389 | } |
390 | |
391 | /* |
392 | * iget5() comparator |
393 | */ |
394 | static int afs_iget5_test(struct inode *inode, void *opaque) |
395 | { |
396 | struct afs_vnode_param *vp = opaque; |
397 | //struct afs_vnode *vnode = AFS_FS_I(inode); |
398 | |
399 | return afs_ilookup5_test_by_fid(inode, opaque: &vp->fid); |
400 | } |
401 | |
402 | /* |
403 | * iget5() inode initialiser |
404 | */ |
405 | static int afs_iget5_set(struct inode *inode, void *opaque) |
406 | { |
407 | struct afs_vnode_param *vp = opaque; |
408 | struct afs_super_info *as = AFS_FS_S(sb: inode->i_sb); |
409 | struct afs_vnode *vnode = AFS_FS_I(inode); |
410 | |
411 | vnode->volume = as->volume; |
412 | vnode->fid = vp->fid; |
413 | |
414 | /* YFS supports 96-bit vnode IDs, but Linux only supports |
415 | * 64-bit inode numbers. |
416 | */ |
417 | inode->i_ino = vnode->fid.vnode; |
418 | inode->i_generation = vnode->fid.unique; |
419 | return 0; |
420 | } |
421 | |
422 | /* |
423 | * Get a cache cookie for an inode. |
424 | */ |
425 | static void afs_get_inode_cache(struct afs_vnode *vnode) |
426 | { |
427 | #ifdef CONFIG_AFS_FSCACHE |
428 | struct { |
429 | __be32 vnode_id; |
430 | __be32 unique; |
431 | __be32 vnode_id_ext[2]; /* Allow for a 96-bit key */ |
432 | } __packed key; |
433 | struct afs_vnode_cache_aux aux; |
434 | |
435 | if (vnode->status.type != AFS_FTYPE_FILE) { |
436 | vnode->netfs.cache = NULL; |
437 | return; |
438 | } |
439 | |
440 | key.vnode_id = htonl(vnode->fid.vnode); |
441 | key.unique = htonl(vnode->fid.unique); |
442 | key.vnode_id_ext[0] = htonl(vnode->fid.vnode >> 32); |
443 | key.vnode_id_ext[1] = htonl(vnode->fid.vnode_hi); |
444 | afs_set_cache_aux(vnode, aux: &aux); |
445 | |
446 | afs_vnode_set_cache(vnode, |
447 | cookie: fscache_acquire_cookie( |
448 | volume: vnode->volume->cache, |
449 | advice: vnode->status.type == AFS_FTYPE_FILE ? |
450 | 0 : FSCACHE_ADV_SINGLE_CHUNK, |
451 | index_key: &key, index_key_len: sizeof(key), |
452 | aux_data: &aux, aux_data_len: sizeof(aux), |
453 | object_size: i_size_read(inode: &vnode->netfs.inode))); |
454 | #endif |
455 | } |
456 | |
457 | /* |
458 | * inode retrieval |
459 | */ |
460 | struct inode *afs_iget(struct afs_operation *op, struct afs_vnode_param *vp) |
461 | { |
462 | struct afs_vnode_param *dvp = &op->file[0]; |
463 | struct super_block *sb = dvp->vnode->netfs.inode.i_sb; |
464 | struct afs_vnode *vnode; |
465 | struct inode *inode; |
466 | int ret; |
467 | |
468 | _enter(",{%llx:%llu.%u},," , vp->fid.vid, vp->fid.vnode, vp->fid.unique); |
469 | |
470 | inode = iget5_locked(sb, vp->fid.vnode, test: afs_iget5_test, set: afs_iget5_set, vp); |
471 | if (!inode) { |
472 | _leave(" = -ENOMEM" ); |
473 | return ERR_PTR(error: -ENOMEM); |
474 | } |
475 | |
476 | vnode = AFS_FS_I(inode); |
477 | |
478 | _debug("GOT INODE %p { vl=%llx vn=%llx, u=%x }" , |
479 | inode, vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique); |
480 | |
481 | /* deal with an existing inode */ |
482 | if (!(inode->i_state & I_NEW)) { |
483 | _leave(" = %p" , inode); |
484 | return inode; |
485 | } |
486 | |
487 | ret = afs_inode_init_from_status(op, vp, vnode); |
488 | if (ret < 0) |
489 | goto bad_inode; |
490 | |
491 | afs_get_inode_cache(vnode); |
492 | |
493 | /* success */ |
494 | clear_bit(AFS_VNODE_UNSET, addr: &vnode->flags); |
495 | unlock_new_inode(inode); |
496 | _leave(" = %p" , inode); |
497 | return inode; |
498 | |
499 | /* failure */ |
500 | bad_inode: |
501 | iget_failed(inode); |
502 | _leave(" = %d [bad]" , ret); |
503 | return ERR_PTR(error: ret); |
504 | } |
505 | |
506 | static int afs_iget5_set_root(struct inode *inode, void *opaque) |
507 | { |
508 | struct afs_super_info *as = AFS_FS_S(sb: inode->i_sb); |
509 | struct afs_vnode *vnode = AFS_FS_I(inode); |
510 | |
511 | vnode->volume = as->volume; |
512 | vnode->fid.vid = as->volume->vid, |
513 | vnode->fid.vnode = 1; |
514 | vnode->fid.unique = 1; |
515 | inode->i_ino = 1; |
516 | inode->i_generation = 1; |
517 | return 0; |
518 | } |
519 | |
520 | /* |
521 | * Set up the root inode for a volume. This is always vnode 1, unique 1 within |
522 | * the volume. |
523 | */ |
524 | struct inode *afs_root_iget(struct super_block *sb, struct key *key) |
525 | { |
526 | struct afs_super_info *as = AFS_FS_S(sb); |
527 | struct afs_operation *op; |
528 | struct afs_vnode *vnode; |
529 | struct inode *inode; |
530 | int ret; |
531 | |
532 | _enter(",{%llx},," , as->volume->vid); |
533 | |
534 | inode = iget5_locked(sb, 1, NULL, set: afs_iget5_set_root, NULL); |
535 | if (!inode) { |
536 | _leave(" = -ENOMEM" ); |
537 | return ERR_PTR(error: -ENOMEM); |
538 | } |
539 | |
540 | _debug("GOT ROOT INODE %p { vl=%llx }" , inode, as->volume->vid); |
541 | |
542 | BUG_ON(!(inode->i_state & I_NEW)); |
543 | |
544 | vnode = AFS_FS_I(inode); |
545 | vnode->cb_v_break = as->volume->cb_v_break, |
546 | afs_set_netfs_context(vnode); |
547 | |
548 | op = afs_alloc_operation(key, as->volume); |
549 | if (IS_ERR(ptr: op)) { |
550 | ret = PTR_ERR(ptr: op); |
551 | goto error; |
552 | } |
553 | |
554 | afs_op_set_vnode(op, n: 0, vnode); |
555 | |
556 | op->nr_files = 1; |
557 | op->ops = &afs_fetch_status_operation; |
558 | ret = afs_do_sync_operation(op); |
559 | if (ret < 0) |
560 | goto error; |
561 | |
562 | afs_get_inode_cache(vnode); |
563 | |
564 | clear_bit(AFS_VNODE_UNSET, addr: &vnode->flags); |
565 | unlock_new_inode(inode); |
566 | _leave(" = %p" , inode); |
567 | return inode; |
568 | |
569 | error: |
570 | iget_failed(inode); |
571 | _leave(" = %d [bad]" , ret); |
572 | return ERR_PTR(error: ret); |
573 | } |
574 | |
575 | /* |
576 | * mark the data attached to an inode as obsolete due to a write on the server |
577 | * - might also want to ditch all the outstanding writes and dirty pages |
578 | */ |
579 | static void afs_zap_data(struct afs_vnode *vnode) |
580 | { |
581 | _enter("{%llx:%llu}" , vnode->fid.vid, vnode->fid.vnode); |
582 | |
583 | afs_invalidate_cache(vnode, flags: 0); |
584 | |
585 | /* nuke all the non-dirty pages that aren't locked, mapped or being |
586 | * written back in a regular file and completely discard the pages in a |
587 | * directory or symlink */ |
588 | if (S_ISREG(vnode->netfs.inode.i_mode)) |
589 | invalidate_remote_inode(inode: &vnode->netfs.inode); |
590 | else |
591 | invalidate_inode_pages2(mapping: vnode->netfs.inode.i_mapping); |
592 | } |
593 | |
594 | /* |
595 | * Check to see if we have a server currently serving this volume and that it |
596 | * hasn't been reinitialised or dropped from the list. |
597 | */ |
598 | static bool afs_check_server_good(struct afs_vnode *vnode) |
599 | { |
600 | struct afs_server_list *slist; |
601 | struct afs_server *server; |
602 | bool good; |
603 | int i; |
604 | |
605 | if (vnode->cb_fs_s_break == atomic_read(v: &vnode->volume->cell->fs_s_break)) |
606 | return true; |
607 | |
608 | rcu_read_lock(); |
609 | |
610 | slist = rcu_dereference(vnode->volume->servers); |
611 | for (i = 0; i < slist->nr_servers; i++) { |
612 | server = slist->servers[i].server; |
613 | if (server == vnode->cb_server) { |
614 | good = (vnode->cb_s_break == server->cb_s_break); |
615 | rcu_read_unlock(); |
616 | return good; |
617 | } |
618 | } |
619 | |
620 | rcu_read_unlock(); |
621 | return false; |
622 | } |
623 | |
624 | /* |
625 | * Check the validity of a vnode/inode. |
626 | */ |
627 | bool afs_check_validity(struct afs_vnode *vnode) |
628 | { |
629 | enum afs_cb_break_reason need_clear = afs_cb_break_no_break; |
630 | time64_t now = ktime_get_real_seconds(); |
631 | unsigned int cb_break; |
632 | int seq = 0; |
633 | |
634 | do { |
635 | read_seqbegin_or_lock(lock: &vnode->cb_lock, seq: &seq); |
636 | cb_break = vnode->cb_break; |
637 | |
638 | if (test_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) { |
639 | if (vnode->cb_v_break != vnode->volume->cb_v_break) |
640 | need_clear = afs_cb_break_for_v_break; |
641 | else if (!afs_check_server_good(vnode)) |
642 | need_clear = afs_cb_break_for_s_reinit; |
643 | else if (test_bit(AFS_VNODE_ZAP_DATA, &vnode->flags)) |
644 | need_clear = afs_cb_break_for_zap; |
645 | else if (vnode->cb_expires_at - 10 <= now) |
646 | need_clear = afs_cb_break_for_lapsed; |
647 | } else if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) { |
648 | ; |
649 | } else { |
650 | need_clear = afs_cb_break_no_promise; |
651 | } |
652 | |
653 | } while (need_seqretry(lock: &vnode->cb_lock, seq)); |
654 | |
655 | done_seqretry(lock: &vnode->cb_lock, seq); |
656 | |
657 | if (need_clear == afs_cb_break_no_break) |
658 | return true; |
659 | |
660 | write_seqlock(sl: &vnode->cb_lock); |
661 | if (need_clear == afs_cb_break_no_promise) |
662 | vnode->cb_v_break = vnode->volume->cb_v_break; |
663 | else if (cb_break == vnode->cb_break) |
664 | __afs_break_callback(vnode, need_clear); |
665 | else |
666 | trace_afs_cb_miss(fid: &vnode->fid, reason: need_clear); |
667 | write_sequnlock(sl: &vnode->cb_lock); |
668 | return false; |
669 | } |
670 | |
671 | /* |
672 | * Returns true if the pagecache is still valid. Does not sleep. |
673 | */ |
674 | bool afs_pagecache_valid(struct afs_vnode *vnode) |
675 | { |
676 | if (unlikely(test_bit(AFS_VNODE_DELETED, &vnode->flags))) { |
677 | if (vnode->netfs.inode.i_nlink) |
678 | clear_nlink(inode: &vnode->netfs.inode); |
679 | return true; |
680 | } |
681 | |
682 | if (test_bit(AFS_VNODE_CB_PROMISED, &vnode->flags) && |
683 | afs_check_validity(vnode)) |
684 | return true; |
685 | |
686 | return false; |
687 | } |
688 | |
689 | /* |
690 | * validate a vnode/inode |
691 | * - there are several things we need to check |
692 | * - parent dir data changes (rm, rmdir, rename, mkdir, create, link, |
693 | * symlink) |
694 | * - parent dir metadata changed (security changes) |
695 | * - dentry data changed (write, truncate) |
696 | * - dentry metadata changed (security changes) |
697 | */ |
698 | int afs_validate(struct afs_vnode *vnode, struct key *key) |
699 | { |
700 | int ret; |
701 | |
702 | _enter("{v={%llx:%llu} fl=%lx},%x" , |
703 | vnode->fid.vid, vnode->fid.vnode, vnode->flags, |
704 | key_serial(key)); |
705 | |
706 | if (afs_pagecache_valid(vnode)) |
707 | goto valid; |
708 | |
709 | down_write(sem: &vnode->validate_lock); |
710 | |
711 | /* if the promise has expired, we need to check the server again to get |
712 | * a new promise - note that if the (parent) directory's metadata was |
713 | * changed then the security may be different and we may no longer have |
714 | * access */ |
715 | if (!test_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) { |
716 | _debug("not promised" ); |
717 | ret = afs_fetch_status(vnode, key, is_new: false, NULL); |
718 | if (ret < 0) { |
719 | if (ret == -ENOENT) { |
720 | set_bit(AFS_VNODE_DELETED, addr: &vnode->flags); |
721 | ret = -ESTALE; |
722 | } |
723 | goto error_unlock; |
724 | } |
725 | _debug("new promise [fl=%lx]" , vnode->flags); |
726 | } |
727 | |
728 | if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) { |
729 | _debug("file already deleted" ); |
730 | ret = -ESTALE; |
731 | goto error_unlock; |
732 | } |
733 | |
734 | /* if the vnode's data version number changed then its contents are |
735 | * different */ |
736 | if (test_and_clear_bit(AFS_VNODE_ZAP_DATA, addr: &vnode->flags)) |
737 | afs_zap_data(vnode); |
738 | up_write(sem: &vnode->validate_lock); |
739 | valid: |
740 | _leave(" = 0" ); |
741 | return 0; |
742 | |
743 | error_unlock: |
744 | up_write(sem: &vnode->validate_lock); |
745 | _leave(" = %d" , ret); |
746 | return ret; |
747 | } |
748 | |
749 | /* |
750 | * read the attributes of an inode |
751 | */ |
752 | int afs_getattr(struct mnt_idmap *idmap, const struct path *path, |
753 | struct kstat *stat, u32 request_mask, unsigned int query_flags) |
754 | { |
755 | struct inode *inode = d_inode(dentry: path->dentry); |
756 | struct afs_vnode *vnode = AFS_FS_I(inode); |
757 | struct key *key; |
758 | int ret, seq = 0; |
759 | |
760 | _enter("{ ino=%lu v=%u }" , inode->i_ino, inode->i_generation); |
761 | |
762 | if (vnode->volume && |
763 | !(query_flags & AT_STATX_DONT_SYNC) && |
764 | !test_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) { |
765 | key = afs_request_key(vnode->volume->cell); |
766 | if (IS_ERR(ptr: key)) |
767 | return PTR_ERR(ptr: key); |
768 | ret = afs_validate(vnode, key); |
769 | key_put(key); |
770 | if (ret < 0) |
771 | return ret; |
772 | } |
773 | |
774 | do { |
775 | read_seqbegin_or_lock(lock: &vnode->cb_lock, seq: &seq); |
776 | generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat); |
777 | if (test_bit(AFS_VNODE_SILLY_DELETED, &vnode->flags) && |
778 | stat->nlink > 0) |
779 | stat->nlink -= 1; |
780 | |
781 | /* Lie about the size of directories. We maintain a locally |
782 | * edited copy and may make different allocation decisions on |
783 | * it, but we need to give userspace the server's size. |
784 | */ |
785 | if (S_ISDIR(inode->i_mode)) |
786 | stat->size = vnode->netfs.remote_i_size; |
787 | } while (need_seqretry(lock: &vnode->cb_lock, seq)); |
788 | |
789 | done_seqretry(lock: &vnode->cb_lock, seq); |
790 | return 0; |
791 | } |
792 | |
793 | /* |
794 | * discard an AFS inode |
795 | */ |
796 | int afs_drop_inode(struct inode *inode) |
797 | { |
798 | _enter("" ); |
799 | |
800 | if (test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(inode)->flags)) |
801 | return generic_delete_inode(inode); |
802 | else |
803 | return generic_drop_inode(inode); |
804 | } |
805 | |
806 | /* |
807 | * clear an AFS inode |
808 | */ |
809 | void afs_evict_inode(struct inode *inode) |
810 | { |
811 | struct afs_vnode_cache_aux aux; |
812 | struct afs_vnode *vnode = AFS_FS_I(inode); |
813 | |
814 | _enter("{%llx:%llu.%d}" , |
815 | vnode->fid.vid, |
816 | vnode->fid.vnode, |
817 | vnode->fid.unique); |
818 | |
819 | _debug("CLEAR INODE %p" , inode); |
820 | |
821 | ASSERTCMP(inode->i_ino, ==, vnode->fid.vnode); |
822 | |
823 | truncate_inode_pages_final(&inode->i_data); |
824 | |
825 | afs_set_cache_aux(vnode, aux: &aux); |
826 | fscache_clear_inode_writeback(cookie: afs_vnode_cache(vnode), inode, aux: &aux); |
827 | clear_inode(inode); |
828 | |
829 | while (!list_empty(head: &vnode->wb_keys)) { |
830 | struct afs_wb_key *wbk = list_entry(vnode->wb_keys.next, |
831 | struct afs_wb_key, vnode_link); |
832 | list_del(entry: &wbk->vnode_link); |
833 | afs_put_wb_key(wbk); |
834 | } |
835 | |
836 | fscache_relinquish_cookie(cookie: afs_vnode_cache(vnode), |
837 | test_bit(AFS_VNODE_DELETED, &vnode->flags)); |
838 | |
839 | afs_prune_wb_keys(vnode); |
840 | afs_put_permits(rcu_access_pointer(vnode->permit_cache)); |
841 | key_put(key: vnode->silly_key); |
842 | vnode->silly_key = NULL; |
843 | key_put(key: vnode->lock_key); |
844 | vnode->lock_key = NULL; |
845 | _leave("" ); |
846 | } |
847 | |
848 | static void afs_setattr_success(struct afs_operation *op) |
849 | { |
850 | struct afs_vnode_param *vp = &op->file[0]; |
851 | struct inode *inode = &vp->vnode->netfs.inode; |
852 | loff_t old_i_size = i_size_read(inode); |
853 | |
854 | op->setattr.old_i_size = old_i_size; |
855 | afs_vnode_commit_status(op, vp); |
856 | /* inode->i_size has now been changed. */ |
857 | |
858 | if (op->setattr.attr->ia_valid & ATTR_SIZE) { |
859 | loff_t size = op->setattr.attr->ia_size; |
860 | if (size > old_i_size) |
861 | pagecache_isize_extended(inode, from: old_i_size, to: size); |
862 | } |
863 | } |
864 | |
865 | static void afs_setattr_edit_file(struct afs_operation *op) |
866 | { |
867 | struct afs_vnode_param *vp = &op->file[0]; |
868 | struct inode *inode = &vp->vnode->netfs.inode; |
869 | |
870 | if (op->setattr.attr->ia_valid & ATTR_SIZE) { |
871 | loff_t size = op->setattr.attr->ia_size; |
872 | loff_t i_size = op->setattr.old_i_size; |
873 | |
874 | if (size < i_size) |
875 | truncate_pagecache(inode, new: size); |
876 | if (size != i_size) |
877 | fscache_resize_cookie(cookie: afs_vnode_cache(vnode: vp->vnode), |
878 | new_size: vp->scb.status.size); |
879 | } |
880 | } |
881 | |
882 | static const struct afs_operation_ops afs_setattr_operation = { |
883 | .issue_afs_rpc = afs_fs_setattr, |
884 | .issue_yfs_rpc = yfs_fs_setattr, |
885 | .success = afs_setattr_success, |
886 | .edit_dir = afs_setattr_edit_file, |
887 | }; |
888 | |
889 | /* |
890 | * set the attributes of an inode |
891 | */ |
892 | int afs_setattr(struct mnt_idmap *idmap, struct dentry *dentry, |
893 | struct iattr *attr) |
894 | { |
895 | const unsigned int supported = |
896 | ATTR_SIZE | ATTR_MODE | ATTR_UID | ATTR_GID | |
897 | ATTR_MTIME | ATTR_MTIME_SET | ATTR_TIMES_SET | ATTR_TOUCH; |
898 | struct afs_operation *op; |
899 | struct afs_vnode *vnode = AFS_FS_I(inode: d_inode(dentry)); |
900 | struct inode *inode = &vnode->netfs.inode; |
901 | loff_t i_size; |
902 | int ret; |
903 | |
904 | _enter("{%llx:%llu},{n=%pd},%x" , |
905 | vnode->fid.vid, vnode->fid.vnode, dentry, |
906 | attr->ia_valid); |
907 | |
908 | if (!(attr->ia_valid & supported)) { |
909 | _leave(" = 0 [unsupported]" ); |
910 | return 0; |
911 | } |
912 | |
913 | i_size = i_size_read(inode); |
914 | if (attr->ia_valid & ATTR_SIZE) { |
915 | if (!S_ISREG(inode->i_mode)) |
916 | return -EISDIR; |
917 | |
918 | ret = inode_newsize_ok(inode, offset: attr->ia_size); |
919 | if (ret) |
920 | return ret; |
921 | |
922 | if (attr->ia_size == i_size) |
923 | attr->ia_valid &= ~ATTR_SIZE; |
924 | } |
925 | |
926 | fscache_use_cookie(cookie: afs_vnode_cache(vnode), will_modify: true); |
927 | |
928 | /* Prevent any new writebacks from starting whilst we do this. */ |
929 | down_write(sem: &vnode->validate_lock); |
930 | |
931 | if ((attr->ia_valid & ATTR_SIZE) && S_ISREG(inode->i_mode)) { |
932 | loff_t size = attr->ia_size; |
933 | |
934 | /* Wait for any outstanding writes to the server to complete */ |
935 | loff_t from = min(size, i_size); |
936 | loff_t to = max(size, i_size); |
937 | ret = filemap_fdatawait_range(inode->i_mapping, lstart: from, lend: to); |
938 | if (ret < 0) |
939 | goto out_unlock; |
940 | |
941 | /* Don't talk to the server if we're just shortening in-memory |
942 | * writes that haven't gone to the server yet. |
943 | */ |
944 | if (!(attr->ia_valid & (supported & ~ATTR_SIZE & ~ATTR_MTIME)) && |
945 | attr->ia_size < i_size && |
946 | attr->ia_size > vnode->status.size) { |
947 | truncate_pagecache(inode, new: attr->ia_size); |
948 | fscache_resize_cookie(cookie: afs_vnode_cache(vnode), |
949 | new_size: attr->ia_size); |
950 | i_size_write(inode, i_size: attr->ia_size); |
951 | ret = 0; |
952 | goto out_unlock; |
953 | } |
954 | } |
955 | |
956 | op = afs_alloc_operation(((attr->ia_valid & ATTR_FILE) ? |
957 | afs_file_key(file: attr->ia_file) : NULL), |
958 | vnode->volume); |
959 | if (IS_ERR(ptr: op)) { |
960 | ret = PTR_ERR(ptr: op); |
961 | goto out_unlock; |
962 | } |
963 | |
964 | afs_op_set_vnode(op, n: 0, vnode); |
965 | op->setattr.attr = attr; |
966 | |
967 | if (attr->ia_valid & ATTR_SIZE) { |
968 | op->file[0].dv_delta = 1; |
969 | op->file[0].set_size = true; |
970 | } |
971 | op->ctime = attr->ia_ctime; |
972 | op->file[0].update_ctime = 1; |
973 | op->file[0].modification = true; |
974 | |
975 | op->ops = &afs_setattr_operation; |
976 | ret = afs_do_sync_operation(op); |
977 | |
978 | out_unlock: |
979 | up_write(sem: &vnode->validate_lock); |
980 | fscache_unuse_cookie(cookie: afs_vnode_cache(vnode), NULL, NULL); |
981 | _leave(" = %d" , ret); |
982 | return ret; |
983 | } |
984 | |