xref: /openbmc/linux/fs/afs/inode.c (revision c8ed9fc9) 
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 	.listxattr	= afs_listxattr,
31 };
32 
33 static noinline void dump_vnode(struct afs_vnode *vnode, struct afs_vnode *parent_vnode)
34 {
35 	static unsigned long once_only;
36 
37 	pr_warn("kAFS: AFS vnode with undefined type %u\n", vnode->status.type);
38 	pr_warn("kAFS: A=%d m=%o s=%llx v=%llx\n",
39 		vnode->status.abort_code,
40 		vnode->status.mode,
41 		vnode->status.size,
42 		vnode->status.data_version);
43 	pr_warn("kAFS: vnode %llx:%llx:%x\n",
44 		vnode->fid.vid,
45 		vnode->fid.vnode,
46 		vnode->fid.unique);
47 	if (parent_vnode)
48 		pr_warn("kAFS: dir %llx:%llx:%x\n",
49 			parent_vnode->fid.vid,
50 			parent_vnode->fid.vnode,
51 			parent_vnode->fid.unique);
52 
53 	if (!test_and_set_bit(0, &once_only))
54 		dump_stack();
55 }
56 
57 /*
58  * Set the file size and block count.  Estimate the number of 512 bytes blocks
59  * used, rounded up to nearest 1K for consistency with other AFS clients.
60  */
61 static void afs_set_i_size(struct afs_vnode *vnode, u64 size)
62 {
63 	i_size_write(&vnode->vfs_inode, size);
64 	vnode->vfs_inode.i_blocks = ((size + 1023) >> 10) << 1;
65 }
66 
67 /*
68  * Initialise an inode from the vnode status.
69  */
70 static int afs_inode_init_from_status(struct afs_operation *op,
71 				      struct afs_vnode_param *vp,
72 				      struct afs_vnode *vnode)
73 {
74 	struct afs_file_status *status = &vp->scb.status;
75 	struct inode *inode = AFS_VNODE_TO_I(vnode);
76 	struct timespec64 t;
77 
78 	_enter("{%llx:%llu.%u} %s",
79 	       vp->fid.vid, vp->fid.vnode, vp->fid.unique,
80 	       op->type ? op->type->name : "???");
81 
82 	_debug("FS: ft=%d lk=%d sz=%llu ver=%Lu mod=%hu",
83 	       status->type,
84 	       status->nlink,
85 	       (unsigned long long) status->size,
86 	       status->data_version,
87 	       status->mode);
88 
89 	write_seqlock(&vnode->cb_lock);
90 
91 	vnode->cb_v_break = op->cb_v_break;
92 	vnode->cb_s_break = op->cb_s_break;
93 	vnode->status = *status;
94 
95 	t = status->mtime_client;
96 	inode->i_ctime = t;
97 	inode->i_mtime = t;
98 	inode->i_atime = t;
99 	inode->i_flags |= S_NOATIME;
100 	inode->i_uid = make_kuid(&init_user_ns, status->owner);
101 	inode->i_gid = make_kgid(&init_user_ns, status->group);
102 	set_nlink(&vnode->vfs_inode, status->nlink);
103 
104 	switch (status->type) {
105 	case AFS_FTYPE_FILE:
106 		inode->i_mode	= S_IFREG | status->mode;
107 		inode->i_op	= &afs_file_inode_operations;
108 		inode->i_fop	= &afs_file_operations;
109 		inode->i_mapping->a_ops	= &afs_fs_aops;
110 		break;
111 	case AFS_FTYPE_DIR:
112 		inode->i_mode	= S_IFDIR | status->mode;
113 		inode->i_op	= &afs_dir_inode_operations;
114 		inode->i_fop	= &afs_dir_file_operations;
115 		inode->i_mapping->a_ops	= &afs_dir_aops;
116 		break;
117 	case AFS_FTYPE_SYMLINK:
118 		/* Symlinks with a mode of 0644 are actually mountpoints. */
119 		if ((status->mode & 0777) == 0644) {
120 			inode->i_flags |= S_AUTOMOUNT;
121 
122 			set_bit(AFS_VNODE_MOUNTPOINT, &vnode->flags);
123 
124 			inode->i_mode	= S_IFDIR | 0555;
125 			inode->i_op	= &afs_mntpt_inode_operations;
126 			inode->i_fop	= &afs_mntpt_file_operations;
127 			inode->i_mapping->a_ops	= &afs_fs_aops;
128 		} else {
129 			inode->i_mode	= S_IFLNK | status->mode;
130 			inode->i_op	= &afs_symlink_inode_operations;
131 			inode->i_mapping->a_ops	= &afs_fs_aops;
132 		}
133 		inode_nohighmem(inode);
134 		break;
135 	default:
136 		dump_vnode(vnode, op->file[0].vnode != vnode ? op->file[0].vnode : NULL);
137 		write_sequnlock(&vnode->cb_lock);
138 		return afs_protocol_error(NULL, afs_eproto_file_type);
139 	}
140 
141 	afs_set_i_size(vnode, status->size);
142 
143 	vnode->invalid_before	= status->data_version;
144 	inode_set_iversion_raw(&vnode->vfs_inode, 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, &vnode->flags);
154 	}
155 
156 	write_sequnlock(&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->vfs_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, status->nlink);
192 
193 	if (status->owner != vnode->status.owner)
194 		inode->i_uid = make_kuid(&init_user_ns, status->owner);
195 
196 	if (status->group != vnode->status.group)
197 		inode->i_gid = make_kgid(&init_user_ns, status->group);
198 
199 	if (status->mode != vnode->status.mode) {
200 		mode = inode->i_mode;
201 		mode &= ~S_IALLUGO;
202 		mode |= status->mode;
203 		WRITE_ONCE(inode->i_mode, mode);
204 	}
205 
206 	t = status->mtime_client;
207 	inode->i_mtime = t;
208 	if (vp->update_ctime)
209 		inode->i_ctime = 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\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 
224 		vnode->invalid_before = status->data_version;
225 		if (vnode->status.type == AFS_FTYPE_DIR) {
226 			if (test_and_clear_bit(AFS_VNODE_DIR_VALID, &vnode->flags))
227 				afs_stat_v(vnode, n_inval);
228 		} else {
229 			set_bit(AFS_VNODE_ZAP_DATA, &vnode->flags);
230 		}
231 		change_size = true;
232 	} else if (vnode->status.type == AFS_FTYPE_DIR) {
233 		/* Expected directory change is handled elsewhere so
234 		 * that we can locally edit the directory and save on a
235 		 * download.
236 		 */
237 		if (test_bit(AFS_VNODE_DIR_VALID, &vnode->flags))
238 			data_changed = false;
239 		change_size = true;
240 	}
241 
242 	if (data_changed) {
243 		inode_set_iversion_raw(inode, status->data_version);
244 
245 		/* Only update the size if the data version jumped.  If the
246 		 * file is being modified locally, then we might have our own
247 		 * idea of what the size should be that's not the same as
248 		 * what's on the server.
249 		 */
250 		if (change_size) {
251 			afs_set_i_size(vnode, status->size);
252 			inode->i_ctime = t;
253 			inode->i_atime = t;
254 		}
255 	}
256 }
257 
258 /*
259  * Apply a callback to a vnode.
260  */
261 static void afs_apply_callback(struct afs_operation *op,
262 			       struct afs_vnode_param *vp)
263 {
264 	struct afs_callback *cb = &vp->scb.callback;
265 	struct afs_vnode *vnode = vp->vnode;
266 
267 	if (!afs_cb_is_broken(vp->cb_break_before, vnode)) {
268 		vnode->cb_expires_at	= cb->expires_at;
269 		vnode->cb_server	= op->server;
270 		set_bit(AFS_VNODE_CB_PROMISED, &vnode->flags);
271 	}
272 }
273 
274 /*
275  * Apply the received status and callback to an inode all in the same critical
276  * section to avoid races with afs_validate().
277  */
278 void afs_vnode_commit_status(struct afs_operation *op, struct afs_vnode_param *vp)
279 {
280 	struct afs_vnode *vnode = vp->vnode;
281 
282 	_enter("");
283 
284 	write_seqlock(&vnode->cb_lock);
285 
286 	if (vp->scb.have_error) {
287 		/* A YFS server will return this from RemoveFile2 and AFS and
288 		 * YFS will return this from InlineBulkStatus.
289 		 */
290 		if (vp->scb.status.abort_code == VNOVNODE) {
291 			set_bit(AFS_VNODE_DELETED, &vnode->flags);
292 			clear_nlink(&vnode->vfs_inode);
293 			__afs_break_callback(vnode, afs_cb_break_for_deleted);
294 			op->flags &= ~AFS_OPERATION_DIR_CONFLICT;
295 		}
296 	} else if (vp->scb.have_status) {
297 		afs_apply_status(op, vp);
298 		if (vp->scb.have_cb)
299 			afs_apply_callback(op, vp);
300 	} else if (vp->op_unlinked && !(op->flags & AFS_OPERATION_DIR_CONFLICT)) {
301 		drop_nlink(&vnode->vfs_inode);
302 		if (vnode->vfs_inode.i_nlink == 0) {
303 			set_bit(AFS_VNODE_DELETED, &vnode->flags);
304 			__afs_break_callback(vnode, afs_cb_break_for_deleted);
305 		}
306 	}
307 
308 	write_sequnlock(&vnode->cb_lock);
309 
310 	if (vp->scb.have_status)
311 		afs_cache_permit(vnode, op->key, vp->cb_break_before, &vp->scb);
312 }
313 
314 static void afs_fetch_status_success(struct afs_operation *op)
315 {
316 	struct afs_vnode_param *vp = &op->file[op->fetch_status.which];
317 	struct afs_vnode *vnode = vp->vnode;
318 	int ret;
319 
320 	if (vnode->vfs_inode.i_state & I_NEW) {
321 		ret = afs_inode_init_from_status(op, vp, vnode);
322 		op->error = ret;
323 		if (ret == 0)
324 			afs_cache_permit(vnode, op->key, vp->cb_break_before, &vp->scb);
325 	} else {
326 		afs_vnode_commit_status(op, vp);
327 	}
328 }
329 
330 const struct afs_operation_ops afs_fetch_status_operation = {
331 	.issue_afs_rpc	= afs_fs_fetch_status,
332 	.issue_yfs_rpc	= yfs_fs_fetch_status,
333 	.success	= afs_fetch_status_success,
334 	.aborted	= afs_check_for_remote_deletion,
335 };
336 
337 /*
338  * Fetch file status from the volume.
339  */
340 int afs_fetch_status(struct afs_vnode *vnode, struct key *key, bool is_new,
341 		     afs_access_t *_caller_access)
342 {
343 	struct afs_operation *op;
344 
345 	_enter("%s,{%llx:%llu.%u,S=%lx}",
346 	       vnode->volume->name,
347 	       vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique,
348 	       vnode->flags);
349 
350 	op = afs_alloc_operation(key, vnode->volume);
351 	if (IS_ERR(op))
352 		return PTR_ERR(op);
353 
354 	afs_op_set_vnode(op, 0, vnode);
355 
356 	op->nr_files	= 1;
357 	op->ops		= &afs_fetch_status_operation;
358 	afs_begin_vnode_operation(op);
359 	afs_wait_for_operation(op);
360 
361 	if (_caller_access)
362 		*_caller_access = op->file[0].scb.status.caller_access;
363 	return afs_put_operation(op);
364 }
365 
366 /*
367  * ilookup() comparator
368  */
369 int afs_ilookup5_test_by_fid(struct inode *inode, void *opaque)
370 {
371 	struct afs_vnode *vnode = AFS_FS_I(inode);
372 	struct afs_fid *fid = opaque;
373 
374 	return (fid->vnode == vnode->fid.vnode &&
375 		fid->vnode_hi == vnode->fid.vnode_hi &&
376 		fid->unique == vnode->fid.unique);
377 }
378 
379 /*
380  * iget5() comparator
381  */
382 static int afs_iget5_test(struct inode *inode, void *opaque)
383 {
384 	struct afs_vnode_param *vp = opaque;
385 	//struct afs_vnode *vnode = AFS_FS_I(inode);
386 
387 	return afs_ilookup5_test_by_fid(inode, &vp->fid);
388 }
389 
390 /*
391  * iget5() inode initialiser
392  */
393 static int afs_iget5_set(struct inode *inode, void *opaque)
394 {
395 	struct afs_vnode_param *vp = opaque;
396 	struct afs_super_info *as = AFS_FS_S(inode->i_sb);
397 	struct afs_vnode *vnode = AFS_FS_I(inode);
398 
399 	vnode->volume		= as->volume;
400 	vnode->fid		= vp->fid;
401 
402 	/* YFS supports 96-bit vnode IDs, but Linux only supports
403 	 * 64-bit inode numbers.
404 	 */
405 	inode->i_ino		= vnode->fid.vnode;
406 	inode->i_generation	= vnode->fid.unique;
407 	return 0;
408 }
409 
410 /*
411  * Get a cache cookie for an inode.
412  */
413 static void afs_get_inode_cache(struct afs_vnode *vnode)
414 {
415 #ifdef CONFIG_AFS_FSCACHE
416 	struct {
417 		u32 vnode_id;
418 		u32 unique;
419 		u32 vnode_id_ext[2];	/* Allow for a 96-bit key */
420 	} __packed key;
421 	struct afs_vnode_cache_aux aux;
422 
423 	if (vnode->status.type == AFS_FTYPE_DIR) {
424 		vnode->cache = NULL;
425 		return;
426 	}
427 
428 	key.vnode_id		= vnode->fid.vnode;
429 	key.unique		= vnode->fid.unique;
430 	key.vnode_id_ext[0]	= vnode->fid.vnode >> 32;
431 	key.vnode_id_ext[1]	= vnode->fid.vnode_hi;
432 	aux.data_version	= vnode->status.data_version;
433 
434 	vnode->cache = fscache_acquire_cookie(vnode->volume->cache,
435 					      &afs_vnode_cache_index_def,
436 					      &key, sizeof(key),
437 					      &aux, sizeof(aux),
438 					      vnode, vnode->status.size, true);
439 #endif
440 }
441 
442 /*
443  * inode retrieval
444  */
445 struct inode *afs_iget(struct afs_operation *op, struct afs_vnode_param *vp)
446 {
447 	struct afs_vnode_param *dvp = &op->file[0];
448 	struct super_block *sb = dvp->vnode->vfs_inode.i_sb;
449 	struct afs_vnode *vnode;
450 	struct inode *inode;
451 	int ret;
452 
453 	_enter(",{%llx:%llu.%u},,", vp->fid.vid, vp->fid.vnode, vp->fid.unique);
454 
455 	inode = iget5_locked(sb, vp->fid.vnode, afs_iget5_test, afs_iget5_set, vp);
456 	if (!inode) {
457 		_leave(" = -ENOMEM");
458 		return ERR_PTR(-ENOMEM);
459 	}
460 
461 	vnode = AFS_FS_I(inode);
462 
463 	_debug("GOT INODE %p { vl=%llx vn=%llx, u=%x }",
464 	       inode, vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique);
465 
466 	/* deal with an existing inode */
467 	if (!(inode->i_state & I_NEW)) {
468 		_leave(" = %p", inode);
469 		return inode;
470 	}
471 
472 	ret = afs_inode_init_from_status(op, vp, vnode);
473 	if (ret < 0)
474 		goto bad_inode;
475 
476 	afs_get_inode_cache(vnode);
477 
478 	/* success */
479 	clear_bit(AFS_VNODE_UNSET, &vnode->flags);
480 	unlock_new_inode(inode);
481 	_leave(" = %p", inode);
482 	return inode;
483 
484 	/* failure */
485 bad_inode:
486 	iget_failed(inode);
487 	_leave(" = %d [bad]", ret);
488 	return ERR_PTR(ret);
489 }
490 
491 static int afs_iget5_set_root(struct inode *inode, void *opaque)
492 {
493 	struct afs_super_info *as = AFS_FS_S(inode->i_sb);
494 	struct afs_vnode *vnode = AFS_FS_I(inode);
495 
496 	vnode->volume		= as->volume;
497 	vnode->fid.vid		= as->volume->vid,
498 	vnode->fid.vnode	= 1;
499 	vnode->fid.unique	= 1;
500 	inode->i_ino		= 1;
501 	inode->i_generation	= 1;
502 	return 0;
503 }
504 
505 /*
506  * Set up the root inode for a volume.  This is always vnode 1, unique 1 within
507  * the volume.
508  */
509 struct inode *afs_root_iget(struct super_block *sb, struct key *key)
510 {
511 	struct afs_super_info *as = AFS_FS_S(sb);
512 	struct afs_operation *op;
513 	struct afs_vnode *vnode;
514 	struct inode *inode;
515 	int ret;
516 
517 	_enter(",{%llx},,", as->volume->vid);
518 
519 	inode = iget5_locked(sb, 1, NULL, afs_iget5_set_root, NULL);
520 	if (!inode) {
521 		_leave(" = -ENOMEM");
522 		return ERR_PTR(-ENOMEM);
523 	}
524 
525 	_debug("GOT ROOT INODE %p { vl=%llx }", inode, as->volume->vid);
526 
527 	BUG_ON(!(inode->i_state & I_NEW));
528 
529 	vnode = AFS_FS_I(inode);
530 	vnode->cb_v_break = as->volume->cb_v_break,
531 
532 	op = afs_alloc_operation(key, as->volume);
533 	if (IS_ERR(op)) {
534 		ret = PTR_ERR(op);
535 		goto error;
536 	}
537 
538 	afs_op_set_vnode(op, 0, vnode);
539 
540 	op->nr_files	= 1;
541 	op->ops		= &afs_fetch_status_operation;
542 	ret = afs_do_sync_operation(op);
543 	if (ret < 0)
544 		goto error;
545 
546 	afs_get_inode_cache(vnode);
547 
548 	clear_bit(AFS_VNODE_UNSET, &vnode->flags);
549 	unlock_new_inode(inode);
550 	_leave(" = %p", inode);
551 	return inode;
552 
553 error:
554 	iget_failed(inode);
555 	_leave(" = %d [bad]", ret);
556 	return ERR_PTR(ret);
557 }
558 
559 /*
560  * mark the data attached to an inode as obsolete due to a write on the server
561  * - might also want to ditch all the outstanding writes and dirty pages
562  */
563 static void afs_zap_data(struct afs_vnode *vnode)
564 {
565 	_enter("{%llx:%llu}", vnode->fid.vid, vnode->fid.vnode);
566 
567 #ifdef CONFIG_AFS_FSCACHE
568 	fscache_invalidate(vnode->cache);
569 #endif
570 
571 	/* nuke all the non-dirty pages that aren't locked, mapped or being
572 	 * written back in a regular file and completely discard the pages in a
573 	 * directory or symlink */
574 	if (S_ISREG(vnode->vfs_inode.i_mode))
575 		invalidate_remote_inode(&vnode->vfs_inode);
576 	else
577 		invalidate_inode_pages2(vnode->vfs_inode.i_mapping);
578 }
579 
580 /*
581  * Get the server reinit counter for a vnode's current server.
582  */
583 static bool afs_get_s_break_rcu(struct afs_vnode *vnode, unsigned int *_s_break)
584 {
585 	struct afs_server_list *slist = rcu_dereference(vnode->volume->servers);
586 	struct afs_server *server;
587 	int i;
588 
589 	for (i = 0; i < slist->nr_servers; i++) {
590 		server = slist->servers[i].server;
591 		if (server == vnode->cb_server) {
592 			*_s_break = READ_ONCE(server->cb_s_break);
593 			return true;
594 		}
595 	}
596 
597 	return false;
598 }
599 
600 /*
601  * Check the validity of a vnode/inode.
602  */
603 bool afs_check_validity(struct afs_vnode *vnode)
604 {
605 	struct afs_volume *volume = vnode->volume;
606 	enum afs_cb_break_reason need_clear = afs_cb_break_no_break;
607 	time64_t now = ktime_get_real_seconds();
608 	bool valid;
609 	unsigned int cb_break, cb_s_break, cb_v_break;
610 	int seq = 0;
611 
612 	do {
613 		read_seqbegin_or_lock(&vnode->cb_lock, &seq);
614 		cb_v_break = READ_ONCE(volume->cb_v_break);
615 		cb_break = vnode->cb_break;
616 
617 		if (test_bit(AFS_VNODE_CB_PROMISED, &vnode->flags) &&
618 		    afs_get_s_break_rcu(vnode, &cb_s_break)) {
619 			if (vnode->cb_s_break != cb_s_break ||
620 			    vnode->cb_v_break != cb_v_break) {
621 				vnode->cb_s_break = cb_s_break;
622 				vnode->cb_v_break = cb_v_break;
623 				need_clear = afs_cb_break_for_vsbreak;
624 				valid = false;
625 			} else if (test_bit(AFS_VNODE_ZAP_DATA, &vnode->flags)) {
626 				need_clear = afs_cb_break_for_zap;
627 				valid = false;
628 			} else if (vnode->cb_expires_at - 10 <= now) {
629 				need_clear = afs_cb_break_for_lapsed;
630 				valid = false;
631 			} else {
632 				valid = true;
633 			}
634 		} else if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) {
635 			valid = true;
636 		} else {
637 			vnode->cb_v_break = cb_v_break;
638 			valid = false;
639 		}
640 
641 	} while (need_seqretry(&vnode->cb_lock, seq));
642 
643 	done_seqretry(&vnode->cb_lock, seq);
644 
645 	if (need_clear != afs_cb_break_no_break) {
646 		write_seqlock(&vnode->cb_lock);
647 		if (cb_break == vnode->cb_break)
648 			__afs_break_callback(vnode, need_clear);
649 		else
650 			trace_afs_cb_miss(&vnode->fid, need_clear);
651 		write_sequnlock(&vnode->cb_lock);
652 		valid = false;
653 	}
654 
655 	return valid;
656 }
657 
658 /*
659  * validate a vnode/inode
660  * - there are several things we need to check
661  *   - parent dir data changes (rm, rmdir, rename, mkdir, create, link,
662  *     symlink)
663  *   - parent dir metadata changed (security changes)
664  *   - dentry data changed (write, truncate)
665  *   - dentry metadata changed (security changes)
666  */
667 int afs_validate(struct afs_vnode *vnode, struct key *key)
668 {
669 	bool valid;
670 	int ret;
671 
672 	_enter("{v={%llx:%llu} fl=%lx},%x",
673 	       vnode->fid.vid, vnode->fid.vnode, vnode->flags,
674 	       key_serial(key));
675 
676 	rcu_read_lock();
677 	valid = afs_check_validity(vnode);
678 	rcu_read_unlock();
679 
680 	if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
681 		clear_nlink(&vnode->vfs_inode);
682 
683 	if (valid)
684 		goto valid;
685 
686 	down_write(&vnode->validate_lock);
687 
688 	/* if the promise has expired, we need to check the server again to get
689 	 * a new promise - note that if the (parent) directory's metadata was
690 	 * changed then the security may be different and we may no longer have
691 	 * access */
692 	if (!test_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) {
693 		_debug("not promised");
694 		ret = afs_fetch_status(vnode, key, false, NULL);
695 		if (ret < 0) {
696 			if (ret == -ENOENT) {
697 				set_bit(AFS_VNODE_DELETED, &vnode->flags);
698 				ret = -ESTALE;
699 			}
700 			goto error_unlock;
701 		}
702 		_debug("new promise [fl=%lx]", vnode->flags);
703 	}
704 
705 	if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) {
706 		_debug("file already deleted");
707 		ret = -ESTALE;
708 		goto error_unlock;
709 	}
710 
711 	/* if the vnode's data version number changed then its contents are
712 	 * different */
713 	if (test_and_clear_bit(AFS_VNODE_ZAP_DATA, &vnode->flags))
714 		afs_zap_data(vnode);
715 	up_write(&vnode->validate_lock);
716 valid:
717 	_leave(" = 0");
718 	return 0;
719 
720 error_unlock:
721 	up_write(&vnode->validate_lock);
722 	_leave(" = %d", ret);
723 	return ret;
724 }
725 
726 /*
727  * read the attributes of an inode
728  */
729 int afs_getattr(const struct path *path, struct kstat *stat,
730 		u32 request_mask, unsigned int query_flags)
731 {
732 	struct inode *inode = d_inode(path->dentry);
733 	struct afs_vnode *vnode = AFS_FS_I(inode);
734 	int seq = 0;
735 
736 	_enter("{ ino=%lu v=%u }", inode->i_ino, inode->i_generation);
737 
738 	do {
739 		read_seqbegin_or_lock(&vnode->cb_lock, &seq);
740 		generic_fillattr(inode, stat);
741 		if (test_bit(AFS_VNODE_SILLY_DELETED, &vnode->flags) &&
742 		    stat->nlink > 0)
743 			stat->nlink -= 1;
744 	} while (need_seqretry(&vnode->cb_lock, seq));
745 
746 	done_seqretry(&vnode->cb_lock, seq);
747 	return 0;
748 }
749 
750 /*
751  * discard an AFS inode
752  */
753 int afs_drop_inode(struct inode *inode)
754 {
755 	_enter("");
756 
757 	if (test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(inode)->flags))
758 		return generic_delete_inode(inode);
759 	else
760 		return generic_drop_inode(inode);
761 }
762 
763 /*
764  * clear an AFS inode
765  */
766 void afs_evict_inode(struct inode *inode)
767 {
768 	struct afs_vnode *vnode;
769 
770 	vnode = AFS_FS_I(inode);
771 
772 	_enter("{%llx:%llu.%d}",
773 	       vnode->fid.vid,
774 	       vnode->fid.vnode,
775 	       vnode->fid.unique);
776 
777 	_debug("CLEAR INODE %p", inode);
778 
779 	ASSERTCMP(inode->i_ino, ==, vnode->fid.vnode);
780 
781 	truncate_inode_pages_final(&inode->i_data);
782 	clear_inode(inode);
783 
784 	while (!list_empty(&vnode->wb_keys)) {
785 		struct afs_wb_key *wbk = list_entry(vnode->wb_keys.next,
786 						    struct afs_wb_key, vnode_link);
787 		list_del(&wbk->vnode_link);
788 		afs_put_wb_key(wbk);
789 	}
790 
791 #ifdef CONFIG_AFS_FSCACHE
792 	{
793 		struct afs_vnode_cache_aux aux;
794 
795 		aux.data_version = vnode->status.data_version;
796 		fscache_relinquish_cookie(vnode->cache, &aux,
797 					  test_bit(AFS_VNODE_DELETED, &vnode->flags));
798 		vnode->cache = NULL;
799 	}
800 #endif
801 
802 	afs_prune_wb_keys(vnode);
803 	afs_put_permits(rcu_access_pointer(vnode->permit_cache));
804 	key_put(vnode->silly_key);
805 	vnode->silly_key = NULL;
806 	key_put(vnode->lock_key);
807 	vnode->lock_key = NULL;
808 	_leave("");
809 }
810 
811 static void afs_setattr_success(struct afs_operation *op)
812 {
813 	struct inode *inode = &op->file[0].vnode->vfs_inode;
814 
815 	afs_vnode_commit_status(op, &op->file[0]);
816 	if (op->setattr.attr->ia_valid & ATTR_SIZE) {
817 		loff_t i_size = inode->i_size, size = op->setattr.attr->ia_size;
818 		if (size > i_size)
819 			pagecache_isize_extended(inode, i_size, size);
820 		truncate_pagecache(inode, size);
821 	}
822 }
823 
824 static const struct afs_operation_ops afs_setattr_operation = {
825 	.issue_afs_rpc	= afs_fs_setattr,
826 	.issue_yfs_rpc	= yfs_fs_setattr,
827 	.success	= afs_setattr_success,
828 };
829 
830 /*
831  * set the attributes of an inode
832  */
833 int afs_setattr(struct dentry *dentry, struct iattr *attr)
834 {
835 	struct afs_operation *op;
836 	struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry));
837 	int ret;
838 
839 	_enter("{%llx:%llu},{n=%pd},%x",
840 	       vnode->fid.vid, vnode->fid.vnode, dentry,
841 	       attr->ia_valid);
842 
843 	if (!(attr->ia_valid & (ATTR_SIZE | ATTR_MODE | ATTR_UID | ATTR_GID |
844 				ATTR_MTIME | ATTR_MTIME_SET | ATTR_TIMES_SET |
845 				ATTR_TOUCH))) {
846 		_leave(" = 0 [unsupported]");
847 		return 0;
848 	}
849 
850 	if (attr->ia_valid & ATTR_SIZE) {
851 		if (!S_ISREG(vnode->vfs_inode.i_mode))
852 			return -EISDIR;
853 
854 		ret = inode_newsize_ok(&vnode->vfs_inode, attr->ia_size);
855 		if (ret)
856 			return ret;
857 
858 		if (attr->ia_size == i_size_read(&vnode->vfs_inode))
859 			attr->ia_valid &= ~ATTR_SIZE;
860 	}
861 
862 	/* flush any dirty data outstanding on a regular file */
863 	if (S_ISREG(vnode->vfs_inode.i_mode))
864 		filemap_write_and_wait(vnode->vfs_inode.i_mapping);
865 
866 	op = afs_alloc_operation(((attr->ia_valid & ATTR_FILE) ?
867 				  afs_file_key(attr->ia_file) : NULL),
868 				 vnode->volume);
869 	if (IS_ERR(op))
870 		return PTR_ERR(op);
871 
872 	afs_op_set_vnode(op, 0, vnode);
873 	op->setattr.attr = attr;
874 
875 	if (attr->ia_valid & ATTR_SIZE) {
876 		op->file[0].dv_delta = 1;
877 		op->file[0].set_size = true;
878 	}
879 	op->ctime = attr->ia_ctime;
880 	op->file[0].update_ctime = 1;
881 
882 	op->ops = &afs_setattr_operation;
883 	return afs_do_sync_operation(op);
884 }
885