fs/afs/inode.c

32 static noinline void dump_vnode(struct afs_vnode *vnode, struct afs_vnode *parent_vnode)
36 	pr_warn("kAFS: AFS vnode with undefined type %u\n", vnode->status.type);
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);
49 			parent_vnode->fid.vnode,
59 static void afs_set_netfs_context(struct afs_vnode *vnode)
61 	netfs_inode_init(&vnode->netfs, &afs_req_ops, true);
65  * Initialise an inode from the vnode status.
69 				      struct afs_vnode *vnode)
72 	struct inode *inode = AFS_VNODE_TO_I(vnode);
76 	       vp->fid.vid, vp->fid.vnode, vp->fid.unique,
86 	write_seqlock(&vnode->cb_lock);
88 	vnode->cb_v_check = op->cb_v_break;
89 	vnode->status = *status;
98 	set_nlink(&vnode->netfs.inode, status->nlink);
120 			set_bit(AFS_VNODE_MOUNTPOINT, &vnode->flags);
134 		dump_vnode(vnode, op->file[0].vnode != vnode ? op->file[0].vnode : NULL);
135 		write_sequnlock(&vnode->cb_lock);
139 	afs_set_i_size(vnode, status->size);
140 	afs_set_netfs_context(vnode);
142 	vnode->invalid_before	= status->data_version;
143 	inode_set_iversion_raw(&vnode->netfs.inode, status->data_version);
148 		atomic64_set(&vnode->cb_expires_at, AFS_NO_CB_PROMISE);
150 		vnode->cb_server = op->server;
151 		atomic64_set(&vnode->cb_expires_at, vp->scb.callback.expires_at);
154 	write_sequnlock(&vnode->cb_lock);
165 	struct afs_vnode *vnode = vp->vnode;
166 	struct inode *inode = &vnode->netfs.inode;
174 	       vp->fid.vid, vp->fid.vnode, vp->fid.unique,
177 	BUG_ON(test_bit(AFS_VNODE_UNSET, &vnode->flags));
179 	if (status->type != vnode->status.type) {
181 			vnode->fid.vid,
182 			vnode->fid.vnode,
183 			vnode->fid.unique,
184 			status->type, vnode->status.type);
189 	if (status->nlink != vnode->status.nlink)
192 	if (status->owner != vnode->status.owner)
195 	if (status->group != vnode->status.group)
198 	if (status->mode != vnode->status.mode) {
210 	if (vnode->status.data_version != status->data_version)
213 	vnode->status = *status;
216 		if (vnode->cb_ro_snapshot == atomic_read(&vnode->volume->cb_ro_snapshot) &&
217 		    atomic64_read(&vnode->cb_expires_at) != AFS_NO_CB_PROMISE)
218 			pr_warn("kAFS: vnode modified {%llx:%llu} %llx->%llx %s (op=%x)\n",
219 				vnode->fid.vid, vnode->fid.vnode,
225 		vnode->invalid_before = status->data_version;
226 		if (vnode->status.type == AFS_FTYPE_DIR) {
227 			if (test_and_clear_bit(AFS_VNODE_DIR_VALID, &vnode->flags))
228 				afs_stat_v(vnode, n_inval);
230 			set_bit(AFS_VNODE_ZAP_DATA, &vnode->flags);
235 	} else if (vnode->status.type == AFS_FTYPE_DIR) {
240 		if (test_bit(AFS_VNODE_DIR_VALID, &vnode->flags))
253 		vnode->netfs.remote_i_size = status->size;
255 			afs_set_i_size(vnode, status->size);
257 				vnode->netfs.zero_point = status->size;
265  * Apply a callback to a vnode.
271 	struct afs_vnode *vnode = vp->vnode;
273 	if (!afs_cb_is_broken(vp->cb_break_before, vnode)) {
275 			vnode->cb_server = op->server;
276 		atomic64_set(&vnode->cb_expires_at, cb->expires_at);
286 	struct afs_vnode *vnode = vp->vnode;
290 	write_seqlock(&vnode->cb_lock);
297 			set_bit(AFS_VNODE_DELETED, &vnode->flags);
298 			clear_nlink(&vnode->netfs.inode);
299 			__afs_break_callback(vnode, afs_cb_break_for_deleted);
304 		    (test_bit(AFS_VNODE_MODIFYING, &vnode->flags) ||
305 		     vp->dv_before != vnode->status.data_version))
315 		drop_nlink(&vnode->netfs.inode);
316 		if (vnode->netfs.inode.i_nlink == 0) {
317 			set_bit(AFS_VNODE_DELETED, &vnode->flags);
318 			__afs_break_callback(vnode, afs_cb_break_for_deleted);
323 	write_sequnlock(&vnode->cb_lock);
326 		afs_cache_permit(vnode, op->key, vp->cb_break_before, &vp->scb);
332 	struct afs_vnode *vnode = vp->vnode;
335 	if (vnode->netfs.inode.i_state & I_NEW) {
336 		ret = afs_inode_init_from_status(op, vp, vnode);
339 			afs_cache_permit(vnode, op->key, vp->cb_break_before, &vp->scb);
355 int afs_fetch_status(struct afs_vnode *vnode, struct key *key, bool is_new,
361 	       vnode->volume->name,
362 	       vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique,
363 	       vnode->flags);
365 	op = afs_alloc_operation(key, vnode->volume);
369 	afs_op_set_vnode(op, 0, vnode);
386 	struct afs_vnode *vnode = AFS_FS_I(inode);
389 	return (fid->vnode == vnode->fid.vnode &&
390 		fid->vnode_hi == vnode->fid.vnode_hi &&
391 		fid->unique == vnode->fid.unique);
400 	//struct afs_vnode *vnode = AFS_FS_I(inode);
412 	struct afs_vnode *vnode = AFS_FS_I(inode);
414 	vnode->volume		= as->volume;
415 	vnode->fid		= vp->fid;
417 	/* YFS supports 96-bit vnode IDs, but Linux only supports
420 	inode->i_ino		= vnode->fid.vnode;
421 	inode->i_generation	= vnode->fid.unique;
428 static void afs_get_inode_cache(struct afs_vnode *vnode)
438 	if (vnode->status.type != AFS_FTYPE_FILE) {
439 		vnode->netfs.cache = NULL;
443 	key.vnode_id		= htonl(vnode->fid.vnode);
444 	key.unique		= htonl(vnode->fid.unique);
445 	key.vnode_id_ext[0]	= htonl(vnode->fid.vnode >> 32);
446 	key.vnode_id_ext[1]	= htonl(vnode->fid.vnode_hi);
447 	afs_set_cache_aux(vnode, &aux);
449 	afs_vnode_set_cache(vnode,
451 				    vnode->volume->cache,
452 				    vnode->status.type == AFS_FTYPE_FILE ?
456 				    i_size_read(&vnode->netfs.inode)));
466 	struct super_block *sb = dvp->vnode->netfs.inode.i_sb;
467 	struct afs_vnode *vnode;
471 	_enter(",{%llx:%llu.%u},,", vp->fid.vid, vp->fid.vnode, vp->fid.unique);
473 	inode = iget5_locked(sb, vp->fid.vnode, afs_iget5_test, afs_iget5_set, vp);
479 	vnode = AFS_FS_I(inode);
482 	       inode, vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique);
490 	ret = afs_inode_init_from_status(op, vp, vnode);
494 	afs_get_inode_cache(vnode);
497 	clear_bit(AFS_VNODE_UNSET, &vnode->flags);
512 	struct afs_vnode *vnode = AFS_FS_I(inode);
514 	vnode->volume		= as->volume;
515 	vnode->fid.vid		= as->volume->vid,
516 	vnode->fid.vnode	= 1;
517 	vnode->fid.unique	= 1;
524  * Set up the root inode for a volume.  This is always vnode 1, unique 1 within
531 	struct afs_vnode *vnode;
547 	vnode = AFS_FS_I(inode);
548 	vnode->cb_v_check = atomic_read(&as->volume->cb_v_break),
549 	afs_set_netfs_context(vnode);
557 	afs_op_set_vnode(op, 0, vnode);
565 	afs_get_inode_cache(vnode);
567 	clear_bit(AFS_VNODE_UNSET, &vnode->flags);
585 	struct afs_vnode *vnode = AFS_FS_I(inode);
591 	if (vnode->volume &&
593 	    atomic64_read(&vnode->cb_expires_at) == AFS_NO_CB_PROMISE) {
594 		key = afs_request_key(vnode->volume->cell);
597 		ret = afs_validate(vnode, key);
604 		seq = read_seqbegin(&vnode->cb_lock);
606 		if (test_bit(AFS_VNODE_SILLY_DELETED, &vnode->flags) &&
615 			stat->size = vnode->netfs.remote_i_size;
616 	} while (read_seqretry(&vnode->cb_lock, seq));
640 	struct afs_vnode *vnode = AFS_FS_I(inode);
643 	       vnode->fid.vid,
644 	       vnode->fid.vnode,
645 	       vnode->fid.unique);
649 	ASSERTCMP(inode->i_ino, ==, vnode->fid.vnode);
653 	afs_set_cache_aux(vnode, &aux);
657 	while (!list_empty(&vnode->wb_keys)) {
658 		struct afs_wb_key *wbk = list_entry(vnode->wb_keys.next,
664 	fscache_relinquish_cookie(afs_vnode_cache(vnode),
665 				  test_bit(AFS_VNODE_DELETED, &vnode->flags));
667 	afs_prune_wb_keys(vnode);
668 	afs_put_permits(rcu_access_pointer(vnode->permit_cache));
669 	key_put(vnode->silly_key);
670 	vnode->silly_key = NULL;
671 	key_put(vnode->lock_key);
672 	vnode->lock_key = NULL;
679 	struct inode *inode = &vp->vnode->netfs.inode;
696 	struct afs_vnode *vnode = vp->vnode;
703 			truncate_setsize(&vnode->netfs.inode, size);
704 			netfs_resize_file(&vnode->netfs, size, true);
705 			fscache_resize_cookie(afs_vnode_cache(vnode), size);
727 	struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry));
728 	struct inode *inode = &vnode->netfs.inode;
733 	       vnode->fid.vid, vnode->fid.vnode, dentry,
754 	fscache_use_cookie(afs_vnode_cache(vnode), true);
757 	down_write(&vnode->validate_lock);
774 		    attr->ia_size > vnode->netfs.remote_i_size) {
776 			netfs_resize_file(&vnode->netfs, size, false);
777 			fscache_resize_cookie(afs_vnode_cache(vnode),
786 				 vnode->volume);
792 	afs_op_set_vnode(op, 0, vnode);
807 	up_write(&vnode->validate_lock);
808 	fscache_unuse_cookie(afs_vnode_cache(vnode), NULL, NULL);