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