inode.c 60.5 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
2
#include <linux/ceph/ceph_debug.h>
S
Sage Weil 已提交
3 4 5 6 7 8 9 10 11

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/uaccess.h>
#include <linux/kernel.h>
#include <linux/writeback.h>
#include <linux/vmalloc.h>
12
#include <linux/xattr.h>
13
#include <linux/posix_acl.h>
14
#include <linux/random.h>
15
#include <linux/sort.h>
S
Sage Weil 已提交
16 17

#include "super.h"
18
#include "mds_client.h"
19
#include "cache.h"
20
#include <linux/ceph/decode.h>
S
Sage Weil 已提交
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

/*
 * Ceph inode operations
 *
 * Implement basic inode helpers (get, alloc) and inode ops (getattr,
 * setattr, etc.), xattr helpers, and helpers for assimilating
 * metadata returned by the MDS into our cache.
 *
 * Also define helpers for doing asynchronous writeback, invalidation,
 * and truncation for the benefit of those who can't afford to block
 * (typically because they are in the message handler path).
 */

static const struct inode_operations ceph_symlink_iops;

36 37 38
static void ceph_invalidate_work(struct work_struct *work);
static void ceph_writeback_work(struct work_struct *work);
static void ceph_vmtruncate_work(struct work_struct *work);
S
Sage Weil 已提交
39 40 41 42

/*
 * find or create an inode, given the ceph ino number
 */
Y
Yehuda Sadeh 已提交
43 44 45 46 47 48 49
static int ceph_set_ino_cb(struct inode *inode, void *data)
{
	ceph_inode(inode)->i_vino = *(struct ceph_vino *)data;
	inode->i_ino = ceph_vino_to_ino(*(struct ceph_vino *)data);
	return 0;
}

S
Sage Weil 已提交
50 51 52 53 54 55
struct inode *ceph_get_inode(struct super_block *sb, struct ceph_vino vino)
{
	struct inode *inode;
	ino_t t = ceph_vino_to_ino(vino);

	inode = iget5_locked(sb, t, ceph_ino_compare, ceph_set_ino_cb, &vino);
56
	if (!inode)
S
Sage Weil 已提交
57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78
		return ERR_PTR(-ENOMEM);
	if (inode->i_state & I_NEW) {
		dout("get_inode created new inode %p %llx.%llx ino %llx\n",
		     inode, ceph_vinop(inode), (u64)inode->i_ino);
		unlock_new_inode(inode);
	}

	dout("get_inode on %lu=%llx.%llx got %p\n", inode->i_ino, vino.ino,
	     vino.snap, inode);
	return inode;
}

/*
 * get/constuct snapdir inode for a given directory
 */
struct inode *ceph_get_snapdir(struct inode *parent)
{
	struct ceph_vino vino = {
		.ino = ceph_ino(parent),
		.snap = CEPH_SNAPDIR,
	};
	struct inode *inode = ceph_get_inode(parent->i_sb, vino);
79
	struct ceph_inode_info *ci = ceph_inode(inode);
S
Sage Weil 已提交
80 81 82

	BUG_ON(!S_ISDIR(parent->i_mode));
	if (IS_ERR(inode))
J
Julia Lawall 已提交
83
		return inode;
S
Sage Weil 已提交
84 85 86
	inode->i_mode = parent->i_mode;
	inode->i_uid = parent->i_uid;
	inode->i_gid = parent->i_gid;
87 88
	inode->i_op = &ceph_snapdir_iops;
	inode->i_fop = &ceph_snapdir_fops;
89 90
	ci->i_snap_caps = CEPH_CAP_PIN; /* so we can open */
	ci->i_rbytes = 0;
S
Sage Weil 已提交
91 92 93 94 95 96 97 98
	return inode;
}

const struct inode_operations ceph_file_iops = {
	.permission = ceph_permission,
	.setattr = ceph_setattr,
	.getattr = ceph_getattr,
	.listxattr = ceph_listxattr,
G
Guangliang Zhao 已提交
99
	.get_acl = ceph_get_acl,
S
Sage Weil 已提交
100
	.set_acl = ceph_set_acl,
S
Sage Weil 已提交
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
};


/*
 * We use a 'frag tree' to keep track of the MDS's directory fragments
 * for a given inode (usually there is just a single fragment).  We
 * need to know when a child frag is delegated to a new MDS, or when
 * it is flagged as replicated, so we can direct our requests
 * accordingly.
 */

/*
 * find/create a frag in the tree
 */
static struct ceph_inode_frag *__get_or_create_frag(struct ceph_inode_info *ci,
						    u32 f)
{
	struct rb_node **p;
	struct rb_node *parent = NULL;
	struct ceph_inode_frag *frag;
	int c;

	p = &ci->i_fragtree.rb_node;
	while (*p) {
		parent = *p;
		frag = rb_entry(parent, struct ceph_inode_frag, node);
		c = ceph_frag_compare(f, frag->frag);
		if (c < 0)
			p = &(*p)->rb_left;
		else if (c > 0)
			p = &(*p)->rb_right;
		else
			return frag;
	}

	frag = kmalloc(sizeof(*frag), GFP_NOFS);
137
	if (!frag)
S
Sage Weil 已提交
138
		return ERR_PTR(-ENOMEM);
139

S
Sage Weil 已提交
140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178
	frag->frag = f;
	frag->split_by = 0;
	frag->mds = -1;
	frag->ndist = 0;

	rb_link_node(&frag->node, parent, p);
	rb_insert_color(&frag->node, &ci->i_fragtree);

	dout("get_or_create_frag added %llx.%llx frag %x\n",
	     ceph_vinop(&ci->vfs_inode), f);
	return frag;
}

/*
 * find a specific frag @f
 */
struct ceph_inode_frag *__ceph_find_frag(struct ceph_inode_info *ci, u32 f)
{
	struct rb_node *n = ci->i_fragtree.rb_node;

	while (n) {
		struct ceph_inode_frag *frag =
			rb_entry(n, struct ceph_inode_frag, node);
		int c = ceph_frag_compare(f, frag->frag);
		if (c < 0)
			n = n->rb_left;
		else if (c > 0)
			n = n->rb_right;
		else
			return frag;
	}
	return NULL;
}

/*
 * Choose frag containing the given value @v.  If @pfrag is
 * specified, copy the frag delegation info to the caller if
 * it is present.
 */
179 180
static u32 __ceph_choose_frag(struct ceph_inode_info *ci, u32 v,
			      struct ceph_inode_frag *pfrag, int *found)
S
Sage Weil 已提交
181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220
{
	u32 t = ceph_frag_make(0, 0);
	struct ceph_inode_frag *frag;
	unsigned nway, i;
	u32 n;

	if (found)
		*found = 0;

	while (1) {
		WARN_ON(!ceph_frag_contains_value(t, v));
		frag = __ceph_find_frag(ci, t);
		if (!frag)
			break; /* t is a leaf */
		if (frag->split_by == 0) {
			if (pfrag)
				memcpy(pfrag, frag, sizeof(*pfrag));
			if (found)
				*found = 1;
			break;
		}

		/* choose child */
		nway = 1 << frag->split_by;
		dout("choose_frag(%x) %x splits by %d (%d ways)\n", v, t,
		     frag->split_by, nway);
		for (i = 0; i < nway; i++) {
			n = ceph_frag_make_child(t, frag->split_by, i);
			if (ceph_frag_contains_value(n, v)) {
				t = n;
				break;
			}
		}
		BUG_ON(i == nway);
	}
	dout("choose_frag(%x) = %x\n", v, t);

	return t;
}

221 222 223 224 225 226 227 228 229 230
u32 ceph_choose_frag(struct ceph_inode_info *ci, u32 v,
		     struct ceph_inode_frag *pfrag, int *found)
{
	u32 ret;
	mutex_lock(&ci->i_fragtree_mutex);
	ret = __ceph_choose_frag(ci, v, pfrag, found);
	mutex_unlock(&ci->i_fragtree_mutex);
	return ret;
}

S
Sage Weil 已提交
231 232 233 234 235 236 237 238 239 240 241 242 243
/*
 * Process dirfrag (delegation) info from the mds.  Include leaf
 * fragment in tree ONLY if ndist > 0.  Otherwise, only
 * branches/splits are included in i_fragtree)
 */
static int ceph_fill_dirfrag(struct inode *inode,
			     struct ceph_mds_reply_dirfrag *dirinfo)
{
	struct ceph_inode_info *ci = ceph_inode(inode);
	struct ceph_inode_frag *frag;
	u32 id = le32_to_cpu(dirinfo->frag);
	int mds = le32_to_cpu(dirinfo->auth);
	int ndist = le32_to_cpu(dirinfo->ndist);
244
	int diri_auth = -1;
S
Sage Weil 已提交
245 246 247
	int i;
	int err = 0;

248 249 250 251 252
	spin_lock(&ci->i_ceph_lock);
	if (ci->i_auth_cap)
		diri_auth = ci->i_auth_cap->mds;
	spin_unlock(&ci->i_ceph_lock);

253 254 255
	if (mds == -1) /* CDIR_AUTH_PARENT */
		mds = diri_auth;

S
Sage Weil 已提交
256
	mutex_lock(&ci->i_fragtree_mutex);
257
	if (ndist == 0 && mds == diri_auth) {
S
Sage Weil 已提交
258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
		/* no delegation info needed. */
		frag = __ceph_find_frag(ci, id);
		if (!frag)
			goto out;
		if (frag->split_by == 0) {
			/* tree leaf, remove */
			dout("fill_dirfrag removed %llx.%llx frag %x"
			     " (no ref)\n", ceph_vinop(inode), id);
			rb_erase(&frag->node, &ci->i_fragtree);
			kfree(frag);
		} else {
			/* tree branch, keep and clear */
			dout("fill_dirfrag cleared %llx.%llx frag %x"
			     " referral\n", ceph_vinop(inode), id);
			frag->mds = -1;
			frag->ndist = 0;
		}
		goto out;
	}


	/* find/add this frag to store mds delegation info */
	frag = __get_or_create_frag(ci, id);
	if (IS_ERR(frag)) {
		/* this is not the end of the world; we can continue
		   with bad/inaccurate delegation info */
		pr_err("fill_dirfrag ENOMEM on mds ref %llx.%llx fg %x\n",
		       ceph_vinop(inode), le32_to_cpu(dirinfo->frag));
		err = -ENOMEM;
		goto out;
	}

	frag->mds = mds;
	frag->ndist = min_t(u32, ndist, CEPH_MAX_DIRFRAG_REP);
	for (i = 0; i < frag->ndist; i++)
		frag->dist[i] = le32_to_cpu(dirinfo->dist[i]);
	dout("fill_dirfrag %llx.%llx frag %x ndist=%d\n",
	     ceph_vinop(inode), frag->frag, frag->ndist);

out:
	mutex_unlock(&ci->i_fragtree_mutex);
	return err;
}

302 303 304 305
static int frag_tree_split_cmp(const void *l, const void *r)
{
	struct ceph_frag_tree_split *ls = (struct ceph_frag_tree_split*)l;
	struct ceph_frag_tree_split *rs = (struct ceph_frag_tree_split*)r;
306 307
	return ceph_frag_compare(le32_to_cpu(ls->frag),
				 le32_to_cpu(rs->frag));
308 309
}

310 311 312 313 314 315 316 317 318
static bool is_frag_child(u32 f, struct ceph_inode_frag *frag)
{
	if (!frag)
		return f == ceph_frag_make(0, 0);
	if (ceph_frag_bits(f) != ceph_frag_bits(frag->frag) + frag->split_by)
		return false;
	return ceph_frag_contains_value(frag->frag, ceph_frag_value(f));
}

319 320 321 322 323
static int ceph_fill_fragtree(struct inode *inode,
			      struct ceph_frag_tree_head *fragtree,
			      struct ceph_mds_reply_dirfrag *dirinfo)
{
	struct ceph_inode_info *ci = ceph_inode(inode);
324
	struct ceph_inode_frag *frag, *prev_frag = NULL;
325
	struct rb_node *rb_node;
326 327
	unsigned i, split_by, nsplits;
	u32 id;
328 329 330 331
	bool update = false;

	mutex_lock(&ci->i_fragtree_mutex);
	nsplits = le32_to_cpu(fragtree->nsplits);
332 333 334
	if (nsplits != ci->i_fragtree_nsplits) {
		update = true;
	} else if (nsplits) {
335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
		i = prandom_u32() % nsplits;
		id = le32_to_cpu(fragtree->splits[i].frag);
		if (!__ceph_find_frag(ci, id))
			update = true;
	} else if (!RB_EMPTY_ROOT(&ci->i_fragtree)) {
		rb_node = rb_first(&ci->i_fragtree);
		frag = rb_entry(rb_node, struct ceph_inode_frag, node);
		if (frag->frag != ceph_frag_make(0, 0) || rb_next(rb_node))
			update = true;
	}
	if (!update && dirinfo) {
		id = le32_to_cpu(dirinfo->frag);
		if (id != __ceph_choose_frag(ci, id, NULL, NULL))
			update = true;
	}
	if (!update)
		goto out_unlock;

353 354 355 356 357
	if (nsplits > 1) {
		sort(fragtree->splits, nsplits, sizeof(fragtree->splits[0]),
		     frag_tree_split_cmp, NULL);
	}

358 359 360 361
	dout("fill_fragtree %llx.%llx\n", ceph_vinop(inode));
	rb_node = rb_first(&ci->i_fragtree);
	for (i = 0; i < nsplits; i++) {
		id = le32_to_cpu(fragtree->splits[i].frag);
362 363 364 365 366 367 368
		split_by = le32_to_cpu(fragtree->splits[i].by);
		if (split_by == 0 || ceph_frag_bits(id) + split_by > 24) {
			pr_err("fill_fragtree %llx.%llx invalid split %d/%u, "
			       "frag %x split by %d\n", ceph_vinop(inode),
			       i, nsplits, id, split_by);
			continue;
		}
369 370 371 372 373 374 375 376 377 378 379
		frag = NULL;
		while (rb_node) {
			frag = rb_entry(rb_node, struct ceph_inode_frag, node);
			if (ceph_frag_compare(frag->frag, id) >= 0) {
				if (frag->frag != id)
					frag = NULL;
				else
					rb_node = rb_next(rb_node);
				break;
			}
			rb_node = rb_next(rb_node);
380 381 382 383
			/* delete stale split/leaf node */
			if (frag->split_by > 0 ||
			    !is_frag_child(frag->frag, prev_frag)) {
				rb_erase(&frag->node, &ci->i_fragtree);
384 385
				if (frag->split_by > 0)
					ci->i_fragtree_nsplits--;
386 387
				kfree(frag);
			}
388 389 390 391 392 393 394
			frag = NULL;
		}
		if (!frag) {
			frag = __get_or_create_frag(ci, id);
			if (IS_ERR(frag))
				continue;
		}
395 396 397
		if (frag->split_by == 0)
			ci->i_fragtree_nsplits++;
		frag->split_by = split_by;
398
		dout(" frag %x split by %d\n", frag->frag, frag->split_by);
399
		prev_frag = frag;
400 401 402 403
	}
	while (rb_node) {
		frag = rb_entry(rb_node, struct ceph_inode_frag, node);
		rb_node = rb_next(rb_node);
404 405 406 407
		/* delete stale split/leaf node */
		if (frag->split_by > 0 ||
		    !is_frag_child(frag->frag, prev_frag)) {
			rb_erase(&frag->node, &ci->i_fragtree);
408 409
			if (frag->split_by > 0)
				ci->i_fragtree_nsplits--;
410 411
			kfree(frag);
		}
412 413 414 415 416
	}
out_unlock:
	mutex_unlock(&ci->i_fragtree_mutex);
	return 0;
}
S
Sage Weil 已提交
417 418 419 420 421 422 423 424 425 426 427 428 429 430 431

/*
 * initialize a newly allocated inode.
 */
struct inode *ceph_alloc_inode(struct super_block *sb)
{
	struct ceph_inode_info *ci;
	int i;

	ci = kmem_cache_alloc(ceph_inode_cachep, GFP_NOFS);
	if (!ci)
		return NULL;

	dout("alloc_inode %p\n", &ci->vfs_inode);

432 433
	spin_lock_init(&ci->i_ceph_lock);

S
Sage Weil 已提交
434
	ci->i_version = 0;
Y
Yan, Zheng 已提交
435
	ci->i_inline_version = 0;
S
Sage Weil 已提交
436 437
	ci->i_time_warp_seq = 0;
	ci->i_ceph_flags = 0;
Y
Yan, Zheng 已提交
438 439 440 441
	atomic64_set(&ci->i_ordered_count, 1);
	atomic64_set(&ci->i_release_count, 1);
	atomic64_set(&ci->i_complete_seq[0], 0);
	atomic64_set(&ci->i_complete_seq[1], 0);
S
Sage Weil 已提交
442 443
	ci->i_symlink = NULL;

S
Sage Weil 已提交
444
	memset(&ci->i_dir_layout, 0, sizeof(ci->i_dir_layout));
445
	RCU_INIT_POINTER(ci->i_layout.pool_ns, NULL);
S
Sage Weil 已提交
446

S
Sage Weil 已提交
447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465
	ci->i_fragtree = RB_ROOT;
	mutex_init(&ci->i_fragtree_mutex);

	ci->i_xattrs.blob = NULL;
	ci->i_xattrs.prealloc_blob = NULL;
	ci->i_xattrs.dirty = false;
	ci->i_xattrs.index = RB_ROOT;
	ci->i_xattrs.count = 0;
	ci->i_xattrs.names_size = 0;
	ci->i_xattrs.vals_size = 0;
	ci->i_xattrs.version = 0;
	ci->i_xattrs.index_version = 0;

	ci->i_caps = RB_ROOT;
	ci->i_auth_cap = NULL;
	ci->i_dirty_caps = 0;
	ci->i_flushing_caps = 0;
	INIT_LIST_HEAD(&ci->i_dirty_item);
	INIT_LIST_HEAD(&ci->i_flushing_item);
466
	ci->i_prealloc_cap_flush = NULL;
467
	INIT_LIST_HEAD(&ci->i_cap_flush_list);
S
Sage Weil 已提交
468 469 470 471 472 473 474 475
	init_waitqueue_head(&ci->i_cap_wq);
	ci->i_hold_caps_min = 0;
	ci->i_hold_caps_max = 0;
	INIT_LIST_HEAD(&ci->i_cap_delay_list);
	INIT_LIST_HEAD(&ci->i_cap_snaps);
	ci->i_head_snapc = NULL;
	ci->i_snap_caps = 0;

476
	for (i = 0; i < CEPH_FILE_MODE_BITS; i++)
S
Sage Weil 已提交
477 478
		ci->i_nr_by_mode[i] = 0;

Y
Yan, Zheng 已提交
479
	mutex_init(&ci->i_truncate_mutex);
S
Sage Weil 已提交
480 481 482 483 484 485 486 487 488 489 490 491 492
	ci->i_truncate_seq = 0;
	ci->i_truncate_size = 0;
	ci->i_truncate_pending = 0;

	ci->i_max_size = 0;
	ci->i_reported_size = 0;
	ci->i_wanted_max_size = 0;
	ci->i_requested_max_size = 0;

	ci->i_pin_ref = 0;
	ci->i_rd_ref = 0;
	ci->i_rdcache_ref = 0;
	ci->i_wr_ref = 0;
493
	ci->i_wb_ref = 0;
S
Sage Weil 已提交
494 495
	ci->i_wrbuffer_ref = 0;
	ci->i_wrbuffer_ref_head = 0;
496
	atomic_set(&ci->i_filelock_ref, 0);
S
Sage Weil 已提交
497 498 499 500 501
	ci->i_shared_gen = 0;
	ci->i_rdcache_gen = 0;
	ci->i_rdcache_revoking = 0;

	INIT_LIST_HEAD(&ci->i_unsafe_dirops);
502
	INIT_LIST_HEAD(&ci->i_unsafe_iops);
S
Sage Weil 已提交
503 504 505 506 507 508
	spin_lock_init(&ci->i_unsafe_lock);

	ci->i_snap_realm = NULL;
	INIT_LIST_HEAD(&ci->i_snap_realm_item);
	INIT_LIST_HEAD(&ci->i_snap_flush_item);

509 510
	INIT_WORK(&ci->i_wb_work, ceph_writeback_work);
	INIT_WORK(&ci->i_pg_inv_work, ceph_invalidate_work);
S
Sage Weil 已提交
511 512 513

	INIT_WORK(&ci->i_vmtruncate_work, ceph_vmtruncate_work);

514 515
	ceph_fscache_inode_init(ci);

S
Sage Weil 已提交
516 517 518
	return &ci->vfs_inode;
}

N
Nick Piggin 已提交
519 520 521 522 523 524 525 526
static void ceph_i_callback(struct rcu_head *head)
{
	struct inode *inode = container_of(head, struct inode, i_rcu);
	struct ceph_inode_info *ci = ceph_inode(inode);

	kmem_cache_free(ceph_inode_cachep, ci);
}

S
Sage Weil 已提交
527 528 529 530 531 532 533 534
void ceph_destroy_inode(struct inode *inode)
{
	struct ceph_inode_info *ci = ceph_inode(inode);
	struct ceph_inode_frag *frag;
	struct rb_node *n;

	dout("destroy_inode %p ino %llx.%llx\n", inode, ceph_vinop(inode));

535 536
	ceph_fscache_unregister_inode_cookie(ci);

S
Sage Weil 已提交
537 538
	ceph_queue_caps_release(inode);

539 540
	/*
	 * we may still have a snap_realm reference if there are stray
541
	 * caps in i_snap_caps.
542 543 544
	 */
	if (ci->i_snap_realm) {
		struct ceph_mds_client *mdsc =
545
			ceph_sb_to_client(ci->vfs_inode.i_sb)->mdsc;
546 547 548 549 550 551 552 553 554
		struct ceph_snap_realm *realm = ci->i_snap_realm;

		dout(" dropping residual ref to snap realm %p\n", realm);
		spin_lock(&realm->inodes_with_caps_lock);
		list_del_init(&ci->i_snap_realm_item);
		spin_unlock(&realm->inodes_with_caps_lock);
		ceph_put_snap_realm(mdsc, realm);
	}

S
Sage Weil 已提交
555 556 557 558 559 560
	kfree(ci->i_symlink);
	while ((n = rb_first(&ci->i_fragtree)) != NULL) {
		frag = rb_entry(n, struct ceph_inode_frag, node);
		rb_erase(n, &ci->i_fragtree);
		kfree(frag);
	}
561
	ci->i_fragtree_nsplits = 0;
S
Sage Weil 已提交
562 563

	__ceph_destroy_xattrs(ci);
S
Sage Weil 已提交
564 565 566 567
	if (ci->i_xattrs.blob)
		ceph_buffer_put(ci->i_xattrs.blob);
	if (ci->i_xattrs.prealloc_blob)
		ceph_buffer_put(ci->i_xattrs.prealloc_blob);
S
Sage Weil 已提交
568

Y
Yan, Zheng 已提交
569
	ceph_put_string(rcu_dereference_raw(ci->i_layout.pool_ns));
570

N
Nick Piggin 已提交
571
	call_rcu(&inode->i_rcu, ceph_i_callback);
S
Sage Weil 已提交
572 573
}

Y
Yan, Zheng 已提交
574 575 576 577 578 579 580 581 582 583
int ceph_drop_inode(struct inode *inode)
{
	/*
	 * Positve dentry and corresponding inode are always accompanied
	 * in MDS reply. So no need to keep inode in the cache after
	 * dropping all its aliases.
	 */
	return 1;
}

584 585 586 587 588
static inline blkcnt_t calc_inode_blocks(u64 size)
{
	return (size + (1<<9) - 1) >> 9;
}

S
Sage Weil 已提交
589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605
/*
 * Helpers to fill in size, ctime, mtime, and atime.  We have to be
 * careful because either the client or MDS may have more up to date
 * info, depending on which capabilities are held, and whether
 * time_warp_seq or truncate_seq have increased.  (Ordinarily, mtime
 * and size are monotonically increasing, except when utimes() or
 * truncate() increments the corresponding _seq values.)
 */
int ceph_fill_file_size(struct inode *inode, int issued,
			u32 truncate_seq, u64 truncate_size, u64 size)
{
	struct ceph_inode_info *ci = ceph_inode(inode);
	int queue_trunc = 0;

	if (ceph_seq_cmp(truncate_seq, ci->i_truncate_seq) > 0 ||
	    (truncate_seq == ci->i_truncate_seq && size > inode->i_size)) {
		dout("size %lld -> %llu\n", inode->i_size, size);
606 607 608 609
		if (size > 0 && S_ISDIR(inode->i_mode)) {
			pr_err("fill_file_size non-zero size for directory\n");
			size = 0;
		}
610
		i_size_write(inode, size);
611
		inode->i_blocks = calc_inode_blocks(size);
S
Sage Weil 已提交
612 613 614 615 616
		ci->i_reported_size = size;
		if (truncate_seq != ci->i_truncate_seq) {
			dout("truncate_seq %u -> %u\n",
			     ci->i_truncate_seq, truncate_seq);
			ci->i_truncate_seq = truncate_seq;
Y
Yan, Zheng 已提交
617 618 619 620 621 622

			/* the MDS should have revoked these caps */
			WARN_ON_ONCE(issued & (CEPH_CAP_FILE_EXCL |
					       CEPH_CAP_FILE_RD |
					       CEPH_CAP_FILE_WR |
					       CEPH_CAP_FILE_LAZYIO));
623 624 625 626 627 628
			/*
			 * If we hold relevant caps, or in the case where we're
			 * not the only client referencing this file and we
			 * don't hold those caps, then we need to check whether
			 * the file is either opened or mmaped
			 */
Y
Yan, Zheng 已提交
629 630
			if ((issued & (CEPH_CAP_FILE_CACHE|
				       CEPH_CAP_FILE_BUFFER)) ||
631 632
			    mapping_mapped(inode->i_mapping) ||
			    __ceph_caps_file_wanted(ci)) {
S
Sage Weil 已提交
633 634 635 636 637 638 639 640 641 642 643
				ci->i_truncate_pending++;
				queue_trunc = 1;
			}
		}
	}
	if (ceph_seq_cmp(truncate_seq, ci->i_truncate_seq) >= 0 &&
	    ci->i_truncate_size != truncate_size) {
		dout("truncate_size %lld -> %llu\n", ci->i_truncate_size,
		     truncate_size);
		ci->i_truncate_size = truncate_size;
	}
644 645 646 647

	if (queue_trunc)
		ceph_fscache_invalidate(inode);

S
Sage Weil 已提交
648 649 650 651 652 653 654 655 656 657 658 659
	return queue_trunc;
}

void ceph_fill_file_time(struct inode *inode, int issued,
			 u64 time_warp_seq, struct timespec *ctime,
			 struct timespec *mtime, struct timespec *atime)
{
	struct ceph_inode_info *ci = ceph_inode(inode);
	int warn = 0;

	if (issued & (CEPH_CAP_FILE_EXCL|
		      CEPH_CAP_FILE_WR|
S
Sage Weil 已提交
660 661 662
		      CEPH_CAP_FILE_BUFFER|
		      CEPH_CAP_AUTH_EXCL|
		      CEPH_CAP_XATTR_EXCL)) {
S
Sage Weil 已提交
663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701
		if (timespec_compare(ctime, &inode->i_ctime) > 0) {
			dout("ctime %ld.%09ld -> %ld.%09ld inc w/ cap\n",
			     inode->i_ctime.tv_sec, inode->i_ctime.tv_nsec,
			     ctime->tv_sec, ctime->tv_nsec);
			inode->i_ctime = *ctime;
		}
		if (ceph_seq_cmp(time_warp_seq, ci->i_time_warp_seq) > 0) {
			/* the MDS did a utimes() */
			dout("mtime %ld.%09ld -> %ld.%09ld "
			     "tw %d -> %d\n",
			     inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec,
			     mtime->tv_sec, mtime->tv_nsec,
			     ci->i_time_warp_seq, (int)time_warp_seq);

			inode->i_mtime = *mtime;
			inode->i_atime = *atime;
			ci->i_time_warp_seq = time_warp_seq;
		} else if (time_warp_seq == ci->i_time_warp_seq) {
			/* nobody did utimes(); take the max */
			if (timespec_compare(mtime, &inode->i_mtime) > 0) {
				dout("mtime %ld.%09ld -> %ld.%09ld inc\n",
				     inode->i_mtime.tv_sec,
				     inode->i_mtime.tv_nsec,
				     mtime->tv_sec, mtime->tv_nsec);
				inode->i_mtime = *mtime;
			}
			if (timespec_compare(atime, &inode->i_atime) > 0) {
				dout("atime %ld.%09ld -> %ld.%09ld inc\n",
				     inode->i_atime.tv_sec,
				     inode->i_atime.tv_nsec,
				     atime->tv_sec, atime->tv_nsec);
				inode->i_atime = *atime;
			}
		} else if (issued & CEPH_CAP_FILE_EXCL) {
			/* we did a utimes(); ignore mds values */
		} else {
			warn = 1;
		}
	} else {
S
Sage Weil 已提交
702
		/* we have no write|excl caps; whatever the MDS says is true */
S
Sage Weil 已提交
703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720
		if (ceph_seq_cmp(time_warp_seq, ci->i_time_warp_seq) >= 0) {
			inode->i_ctime = *ctime;
			inode->i_mtime = *mtime;
			inode->i_atime = *atime;
			ci->i_time_warp_seq = time_warp_seq;
		} else {
			warn = 1;
		}
	}
	if (warn) /* time_warp_seq shouldn't go backwards */
		dout("%p mds time_warp_seq %llu < %u\n",
		     inode, time_warp_seq, ci->i_time_warp_seq);
}

/*
 * Populate an inode based on info from mds.  May be called on new or
 * existing inodes.
 */
721
static int fill_inode(struct inode *inode, struct page *locked_page,
S
Sage Weil 已提交
722 723 724 725 726 727
		      struct ceph_mds_reply_info_in *iinfo,
		      struct ceph_mds_reply_dirfrag *dirinfo,
		      struct ceph_mds_session *session,
		      unsigned long ttl_from, int cap_fmode,
		      struct ceph_cap_reservation *caps_reservation)
{
728
	struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
S
Sage Weil 已提交
729 730
	struct ceph_mds_reply_inode *info = iinfo->in;
	struct ceph_inode_info *ci = ceph_inode(inode);
731
	int issued = 0, implemented, new_issued;
S
Sage Weil 已提交
732 733
	struct timespec mtime, atime, ctime;
	struct ceph_buffer *xattr_blob = NULL;
Y
Yan, Zheng 已提交
734
	struct ceph_string *pool_ns = NULL;
735
	struct ceph_cap *new_cap = NULL;
S
Sage Weil 已提交
736
	int err = 0;
737
	bool wake = false;
738 739
	bool queue_trunc = false;
	bool new_version = false;
Y
Yan, Zheng 已提交
740
	bool fill_inline = false;
S
Sage Weil 已提交
741 742 743 744 745

	dout("fill_inode %p ino %llx.%llx v %llu had %llu\n",
	     inode, ceph_vinop(inode), le64_to_cpu(info->version),
	     ci->i_version);

746 747 748 749
	/* prealloc new cap struct */
	if (info->cap.caps && ceph_snap(inode) == CEPH_NOSNAP)
		new_cap = ceph_get_cap(mdsc, caps_reservation);

S
Sage Weil 已提交
750 751 752 753 754 755
	/*
	 * prealloc xattr data, if it looks like we'll need it.  only
	 * if len > 4 (meaning there are actually xattrs; the first 4
	 * bytes are the xattr count).
	 */
	if (iinfo->xattr_len > 4) {
S
Sage Weil 已提交
756
		xattr_blob = ceph_buffer_new(iinfo->xattr_len, GFP_NOFS);
S
Sage Weil 已提交
757 758 759 760 761
		if (!xattr_blob)
			pr_err("fill_inode ENOMEM xattr blob %d bytes\n",
			       iinfo->xattr_len);
	}

Y
Yan, Zheng 已提交
762 763 764 765
	if (iinfo->pool_ns_len > 0)
		pool_ns = ceph_find_or_create_string(iinfo->pool_ns_data,
						     iinfo->pool_ns_len);

766
	spin_lock(&ci->i_ceph_lock);
S
Sage Weil 已提交
767 768 769

	/*
	 * provided version will be odd if inode value is projected,
770 771 772 773 774 775 776 777
	 * even if stable.  skip the update if we have newer stable
	 * info (ours>=theirs, e.g. due to racing mds replies), unless
	 * we are getting projected (unstable) info (in which case the
	 * version is odd, and we want ours>theirs).
	 *   us   them
	 *   2    2     skip
	 *   3    2     skip
	 *   3    3     update
S
Sage Weil 已提交
778
	 */
779 780 781 782 783
	if (ci->i_version == 0 ||
	    ((info->cap.flags & CEPH_CAP_FLAG_AUTH) &&
	     le64_to_cpu(info->version) > (ci->i_version & ~1)))
		new_version = true;

S
Sage Weil 已提交
784 785
	issued = __ceph_caps_issued(ci, &implemented);
	issued |= implemented | __ceph_caps_dirty(ci);
786
	new_issued = ~issued & le32_to_cpu(info->cap.caps);
S
Sage Weil 已提交
787 788 789 790

	/* update inode */
	ci->i_version = le64_to_cpu(info->version);
	inode->i_rdev = le32_to_cpu(info->rdev);
791
	inode->i_blkbits = fls(le32_to_cpu(info->layout.fl_stripe_unit)) - 1;
S
Sage Weil 已提交
792

793 794
	if ((new_version || (new_issued & CEPH_CAP_AUTH_SHARED)) &&
	    (issued & CEPH_CAP_AUTH_EXCL) == 0) {
S
Sage Weil 已提交
795
		inode->i_mode = le32_to_cpu(info->mode);
796 797
		inode->i_uid = make_kuid(&init_user_ns, le32_to_cpu(info->uid));
		inode->i_gid = make_kgid(&init_user_ns, le32_to_cpu(info->gid));
S
Sage Weil 已提交
798
		dout("%p mode 0%o uid.gid %d.%d\n", inode, inode->i_mode,
799 800
		     from_kuid(&init_user_ns, inode->i_uid),
		     from_kgid(&init_user_ns, inode->i_gid));
S
Sage Weil 已提交
801 802
	}

803 804
	if ((new_version || (new_issued & CEPH_CAP_LINK_SHARED)) &&
	    (issued & CEPH_CAP_LINK_EXCL) == 0)
M
Miklos Szeredi 已提交
805
		set_nlink(inode, le32_to_cpu(info->nlink));
S
Sage Weil 已提交
806

807 808 809 810 811 812 813 814 815 816 817 818
	if (new_version || (new_issued & CEPH_CAP_ANY_RD)) {
		/* be careful with mtime, atime, size */
		ceph_decode_timespec(&atime, &info->atime);
		ceph_decode_timespec(&mtime, &info->mtime);
		ceph_decode_timespec(&ctime, &info->ctime);
		ceph_fill_file_time(inode, issued,
				le32_to_cpu(info->time_warp_seq),
				&ctime, &mtime, &atime);
	}

	if (new_version ||
	    (new_issued & (CEPH_CAP_ANY_FILE_RD | CEPH_CAP_ANY_FILE_WR))) {
819
		s64 old_pool = ci->i_layout.pool_id;
Y
Yan, Zheng 已提交
820 821
		struct ceph_string *old_ns;

822
		ceph_file_layout_from_legacy(&ci->i_layout, &info->layout);
Y
Yan, Zheng 已提交
823 824 825 826 827
		old_ns = rcu_dereference_protected(ci->i_layout.pool_ns,
					lockdep_is_held(&ci->i_ceph_lock));
		rcu_assign_pointer(ci->i_layout.pool_ns, pool_ns);

		if (ci->i_layout.pool_id != old_pool || pool_ns != old_ns)
828 829
			ci->i_ceph_flags &= ~CEPH_I_POOL_PERM;

Y
Yan, Zheng 已提交
830
		pool_ns = old_ns;
831

832 833 834 835 836 837 838 839 840 841 842 843
		queue_trunc = ceph_fill_file_size(inode, issued,
					le32_to_cpu(info->truncate_seq),
					le64_to_cpu(info->truncate_size),
					le64_to_cpu(info->size));
		/* only update max_size on auth cap */
		if ((info->cap.flags & CEPH_CAP_FLAG_AUTH) &&
		    ci->i_max_size != le64_to_cpu(info->max_size)) {
			dout("max_size %lld -> %llu\n", ci->i_max_size,
					le64_to_cpu(info->max_size));
			ci->i_max_size = le64_to_cpu(info->max_size);
		}
	}
S
Sage Weil 已提交
844 845 846

	/* xattrs */
	/* note that if i_xattrs.len <= 4, i_xattrs.data will still be NULL. */
847
	if ((ci->i_xattrs.version == 0 || !(issued & CEPH_CAP_XATTR_EXCL))  &&
S
Sage Weil 已提交
848 849 850 851 852 853 854 855
	    le64_to_cpu(info->xattr_version) > ci->i_xattrs.version) {
		if (ci->i_xattrs.blob)
			ceph_buffer_put(ci->i_xattrs.blob);
		ci->i_xattrs.blob = xattr_blob;
		if (xattr_blob)
			memcpy(ci->i_xattrs.blob->vec.iov_base,
			       iinfo->xattr_data, iinfo->xattr_len);
		ci->i_xattrs.version = le64_to_cpu(info->xattr_version);
G
Guangliang Zhao 已提交
856
		ceph_forget_all_cached_acls(inode);
857
		xattr_blob = NULL;
S
Sage Weil 已提交
858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876
	}

	inode->i_mapping->a_ops = &ceph_aops;

	switch (inode->i_mode & S_IFMT) {
	case S_IFIFO:
	case S_IFBLK:
	case S_IFCHR:
	case S_IFSOCK:
		init_special_inode(inode, inode->i_mode, inode->i_rdev);
		inode->i_op = &ceph_file_iops;
		break;
	case S_IFREG:
		inode->i_op = &ceph_file_iops;
		inode->i_fop = &ceph_file_fops;
		break;
	case S_IFLNK:
		inode->i_op = &ceph_symlink_iops;
		if (!ci->i_symlink) {
877
			u32 symlen = iinfo->symlink_len;
S
Sage Weil 已提交
878 879
			char *sym;

880
			spin_unlock(&ci->i_ceph_lock);
S
Sage Weil 已提交
881

882 883 884 885 886 887 888
			if (symlen != i_size_read(inode)) {
				pr_err("fill_inode %llx.%llx BAD symlink "
					"size %lld\n", ceph_vinop(inode),
					i_size_read(inode));
				i_size_write(inode, symlen);
				inode->i_blocks = calc_inode_blocks(symlen);
			}
889

S
Sage Weil 已提交
890
			err = -ENOMEM;
891
			sym = kstrndup(iinfo->symlink, symlen, GFP_NOFS);
S
Sage Weil 已提交
892 893 894
			if (!sym)
				goto out;

895
			spin_lock(&ci->i_ceph_lock);
S
Sage Weil 已提交
896 897 898 899 900
			if (!ci->i_symlink)
				ci->i_symlink = sym;
			else
				kfree(sym); /* lost a race */
		}
A
Al Viro 已提交
901
		inode->i_link = ci->i_symlink;
S
Sage Weil 已提交
902 903 904 905 906
		break;
	case S_IFDIR:
		inode->i_op = &ceph_dir_iops;
		inode->i_fop = &ceph_dir_fops;

907 908
		ci->i_dir_layout = iinfo->dir_layout;

S
Sage Weil 已提交
909 910 911 912 913 914 915 916 917 918 919 920 921 922 923
		ci->i_files = le64_to_cpu(info->files);
		ci->i_subdirs = le64_to_cpu(info->subdirs);
		ci->i_rbytes = le64_to_cpu(info->rbytes);
		ci->i_rfiles = le64_to_cpu(info->rfiles);
		ci->i_rsubdirs = le64_to_cpu(info->rsubdirs);
		ceph_decode_timespec(&ci->i_rctime, &info->rctime);
		break;
	default:
		pr_err("fill_inode %llx.%llx BAD mode 0%o\n",
		       ceph_vinop(inode), inode->i_mode);
	}

	/* were we issued a capability? */
	if (info->cap.caps) {
		if (ceph_snap(inode) == CEPH_NOSNAP) {
924
			unsigned caps = le32_to_cpu(info->cap.caps);
S
Sage Weil 已提交
925 926
			ceph_add_cap(inode, session,
				     le64_to_cpu(info->cap.cap_id),
927
				     cap_fmode, caps,
S
Sage Weil 已提交
928 929 930 931
				     le32_to_cpu(info->cap.wanted),
				     le32_to_cpu(info->cap.seq),
				     le32_to_cpu(info->cap.mseq),
				     le64_to_cpu(info->cap.realm),
932
				     info->cap.flags, &new_cap);
933 934 935 936 937 938 939 940

			/* set dir completion flag? */
			if (S_ISDIR(inode->i_mode) &&
			    ci->i_files == 0 && ci->i_subdirs == 0 &&
			    (caps & CEPH_CAP_FILE_SHARED) &&
			    (issued & CEPH_CAP_FILE_EXCL) == 0 &&
			    !__ceph_dir_is_complete(ci)) {
				dout(" marking %p complete (empty)\n", inode);
Y
Yan, Zheng 已提交
941
				i_size_write(inode, 0);
942
				__ceph_dir_set_complete(ci,
Y
Yan, Zheng 已提交
943 944
					atomic64_read(&ci->i_release_count),
					atomic64_read(&ci->i_ordered_count));
945 946
			}

947
			wake = true;
S
Sage Weil 已提交
948 949 950 951 952 953 954
		} else {
			dout(" %p got snap_caps %s\n", inode,
			     ceph_cap_string(le32_to_cpu(info->cap.caps)));
			ci->i_snap_caps |= le32_to_cpu(info->cap.caps);
			if (cap_fmode >= 0)
				__ceph_get_fmode(ci, cap_fmode);
		}
955
	} else if (cap_fmode >= 0) {
956
		pr_warn("mds issued no caps on %llx.%llx\n",
957 958
			   ceph_vinop(inode));
		__ceph_get_fmode(ci, cap_fmode);
S
Sage Weil 已提交
959
	}
Y
Yan, Zheng 已提交
960 961 962 963 964 965

	if (iinfo->inline_version > 0 &&
	    iinfo->inline_version >= ci->i_inline_version) {
		int cache_caps = CEPH_CAP_FILE_CACHE | CEPH_CAP_FILE_LAZYIO;
		ci->i_inline_version = iinfo->inline_version;
		if (ci->i_inline_version != CEPH_INLINE_NONE &&
966 967
		    (locked_page ||
		     (le32_to_cpu(info->cap.caps) & cache_caps)))
Y
Yan, Zheng 已提交
968 969 970
			fill_inline = true;
	}

971
	spin_unlock(&ci->i_ceph_lock);
S
Sage Weil 已提交
972

Y
Yan, Zheng 已提交
973
	if (fill_inline)
974
		ceph_fill_inline_data(inode, locked_page,
Y
Yan, Zheng 已提交
975 976
				      iinfo->inline_data, iinfo->inline_len);

977 978 979
	if (wake)
		wake_up_all(&ci->i_cap_wq);

S
Sage Weil 已提交
980 981
	/* queue truncate if we saw i_size decrease */
	if (queue_trunc)
982
		ceph_queue_vmtruncate(inode);
S
Sage Weil 已提交
983 984

	/* populate frag tree */
985 986
	if (S_ISDIR(inode->i_mode))
		ceph_fill_fragtree(inode, &info->fragtree, dirinfo);
S
Sage Weil 已提交
987 988 989 990 991 992 993

	/* update delegation info? */
	if (dirinfo)
		ceph_fill_dirfrag(inode, dirinfo);

	err = 0;
out:
994 995
	if (new_cap)
		ceph_put_cap(mdsc, new_cap);
S
Sage Weil 已提交
996 997
	if (xattr_blob)
		ceph_buffer_put(xattr_blob);
Y
Yan, Zheng 已提交
998
	ceph_put_string(pool_ns);
S
Sage Weil 已提交
999 1000 1001 1002 1003 1004 1005 1006 1007
	return err;
}

/*
 * caller should hold session s_mutex.
 */
static void update_dentry_lease(struct dentry *dentry,
				struct ceph_mds_reply_lease *lease,
				struct ceph_mds_session *session,
1008 1009 1010
				unsigned long from_time,
				struct ceph_vino *tgt_vino,
				struct ceph_vino *dir_vino)
S
Sage Weil 已提交
1011 1012 1013 1014 1015 1016
{
	struct ceph_dentry_info *di = ceph_dentry(dentry);
	long unsigned duration = le32_to_cpu(lease->duration_ms);
	long unsigned ttl = from_time + (duration * HZ) / 1000;
	long unsigned half_ttl = from_time + (duration * HZ / 2) / 1000;
	struct inode *dir;
1017
	struct ceph_mds_session *old_lease_session = NULL;
S
Sage Weil 已提交
1018

1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029
	/*
	 * Make sure dentry's inode matches tgt_vino. NULL tgt_vino means that
	 * we expect a negative dentry.
	 */
	if (!tgt_vino && d_really_is_positive(dentry))
		return;

	if (tgt_vino && (d_really_is_negative(dentry) ||
			!ceph_ino_compare(d_inode(dentry), tgt_vino)))
		return;

S
Sage Weil 已提交
1030
	spin_lock(&dentry->d_lock);
S
Sage Weil 已提交
1031 1032
	dout("update_dentry_lease %p duration %lu ms ttl %lu\n",
	     dentry, duration, ttl);
S
Sage Weil 已提交
1033

1034
	dir = d_inode(dentry->d_parent);
A
Al Viro 已提交
1035

1036 1037 1038 1039
	/* make sure parent matches dir_vino */
	if (!ceph_ino_compare(dir, dir_vino))
		goto out_unlock;

A
Al Viro 已提交
1040 1041 1042 1043
	/* only track leases on regular dentries */
	if (ceph_snap(dir) != CEPH_NOSNAP)
		goto out_unlock;

S
Sage Weil 已提交
1044 1045
	di->lease_shared_gen = ceph_inode(dir)->i_shared_gen;

S
Sage Weil 已提交
1046
	if (duration == 0)
S
Sage Weil 已提交
1047 1048 1049
		goto out_unlock;

	if (di->lease_gen == session->s_cap_gen &&
M
Miklos Szeredi 已提交
1050
	    time_before(ttl, di->time))
S
Sage Weil 已提交
1051 1052
		goto out_unlock;  /* we already have a newer lease. */

1053 1054 1055 1056
	if (di->lease_session && di->lease_session != session) {
		old_lease_session = di->lease_session;
		di->lease_session = NULL;
	}
S
Sage Weil 已提交
1057 1058 1059 1060 1061 1062 1063 1064 1065

	ceph_dentry_lru_touch(dentry);

	if (!di->lease_session)
		di->lease_session = ceph_get_mds_session(session);
	di->lease_gen = session->s_cap_gen;
	di->lease_seq = le32_to_cpu(lease->seq);
	di->lease_renew_after = half_ttl;
	di->lease_renew_from = 0;
M
Miklos Szeredi 已提交
1066
	di->time = ttl;
S
Sage Weil 已提交
1067 1068
out_unlock:
	spin_unlock(&dentry->d_lock);
1069 1070
	if (old_lease_session)
		ceph_put_mds_session(old_lease_session);
S
Sage Weil 已提交
1071 1072 1073 1074 1075 1076
}

/*
 * splice a dentry to an inode.
 * caller must hold directory i_mutex for this to be safe.
 */
1077
static struct dentry *splice_dentry(struct dentry *dn, struct inode *in)
S
Sage Weil 已提交
1078 1079 1080
{
	struct dentry *realdn;

1081
	BUG_ON(d_inode(dn));
S
Sage Weil 已提交
1082

S
Sage Weil 已提交
1083 1084 1085
	/* dn must be unhashed */
	if (!d_unhashed(dn))
		d_drop(dn);
1086
	realdn = d_splice_alias(in, dn);
S
Sage Weil 已提交
1087
	if (IS_ERR(realdn)) {
1088 1089
		pr_err("splice_dentry error %ld %p inode %p ino %llx.%llx\n",
		       PTR_ERR(realdn), dn, in, ceph_vinop(in));
S
Sage Weil 已提交
1090 1091 1092 1093 1094
		dn = realdn; /* note realdn contains the error */
		goto out;
	} else if (realdn) {
		dout("dn %p (%d) spliced with %p (%d) "
		     "inode %p ino %llx.%llx\n",
A
Al Viro 已提交
1095 1096
		     dn, d_count(dn),
		     realdn, d_count(realdn),
1097
		     d_inode(realdn), ceph_vinop(d_inode(realdn)));
S
Sage Weil 已提交
1098 1099 1100 1101 1102
		dput(dn);
		dn = realdn;
	} else {
		BUG_ON(!ceph_dentry(dn));
		dout("dn %p attached to %p ino %llx.%llx\n",
1103
		     dn, d_inode(dn), ceph_vinop(d_inode(dn)));
S
Sage Weil 已提交
1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119
	}
out:
	return dn;
}

/*
 * Incorporate results into the local cache.  This is either just
 * one inode, or a directory, dentry, and possibly linked-to inode (e.g.,
 * after a lookup).
 *
 * A reply may contain
 *         a directory inode along with a dentry.
 *  and/or a target inode
 *
 * Called with snap_rwsem (read).
 */
1120
int ceph_fill_trace(struct super_block *sb, struct ceph_mds_request *req)
S
Sage Weil 已提交
1121
{
1122
	struct ceph_mds_session *session = req->r_session;
S
Sage Weil 已提交
1123 1124
	struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info;
	struct inode *in = NULL;
1125
	struct ceph_vino tvino, dvino;
1126
	struct ceph_fs_client *fsc = ceph_sb_to_client(sb);
S
Sage Weil 已提交
1127 1128 1129 1130 1131 1132 1133
	int err = 0;

	dout("fill_trace %p is_dentry %d is_target %d\n", req,
	     rinfo->head->is_dentry, rinfo->head->is_target);

	if (!rinfo->head->is_target && !rinfo->head->is_dentry) {
		dout("fill_trace reply is empty!\n");
1134
		if (rinfo->head->result == 0 && req->r_parent)
1135
			ceph_invalidate_dir_request(req);
S
Sage Weil 已提交
1136 1137 1138 1139
		return 0;
	}

	if (rinfo->head->is_dentry) {
1140
		struct inode *dir = req->r_parent;
1141

1142
		if (dir) {
1143 1144
			err = fill_inode(dir, NULL,
					 &rinfo->diri, rinfo->dirfrag,
1145 1146 1147
					 session, req->r_request_started, -1,
					 &req->r_caps_reservation);
			if (err < 0)
1148
				goto done;
1149 1150 1151
		} else {
			WARN_ON_ONCE(1);
		}
1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164

		if (dir && req->r_op == CEPH_MDS_OP_LOOKUPNAME) {
			struct qstr dname;
			struct dentry *dn, *parent;

			BUG_ON(!rinfo->head->is_target);
			BUG_ON(req->r_dentry);

			parent = d_find_any_alias(dir);
			BUG_ON(!parent);

			dname.name = rinfo->dname;
			dname.len = rinfo->dname_len;
1165
			dname.hash = full_name_hash(parent, dname.name, dname.len);
1166 1167
			tvino.ino = le64_to_cpu(rinfo->targeti.in->ino);
			tvino.snap = le64_to_cpu(rinfo->targeti.in->snapid);
1168 1169 1170 1171 1172 1173 1174 1175 1176
retry_lookup:
			dn = d_lookup(parent, &dname);
			dout("d_lookup on parent=%p name=%.*s got %p\n",
			     parent, dname.len, dname.name, dn);

			if (!dn) {
				dn = d_alloc(parent, &dname);
				dout("d_alloc %p '%.*s' = %p\n", parent,
				     dname.len, dname.name, dn);
1177
				if (!dn) {
1178 1179 1180 1181
					dput(parent);
					err = -ENOMEM;
					goto done;
				}
A
Al Viro 已提交
1182
				err = 0;
1183
			} else if (d_really_is_positive(dn) &&
1184 1185
				   (ceph_ino(d_inode(dn)) != tvino.ino ||
				    ceph_snap(d_inode(dn)) != tvino.snap)) {
1186
				dout(" dn %p points to wrong inode %p\n",
1187
				     dn, d_inode(dn));
1188
				ceph_dir_clear_ordered(dir);
1189 1190 1191 1192 1193 1194 1195 1196
				d_delete(dn);
				dput(dn);
				goto retry_lookup;
			}

			req->r_dentry = dn;
			dput(parent);
		}
1197 1198
	}

1199
	if (rinfo->head->is_target) {
1200 1201
		tvino.ino = le64_to_cpu(rinfo->targeti.in->ino);
		tvino.snap = le64_to_cpu(rinfo->targeti.in->snapid);
1202

1203
		in = ceph_get_inode(sb, tvino);
1204 1205 1206 1207 1208 1209
		if (IS_ERR(in)) {
			err = PTR_ERR(in);
			goto done;
		}
		req->r_target_inode = in;

1210
		err = fill_inode(in, req->r_locked_page, &rinfo->targeti, NULL,
1211
				session, req->r_request_started,
1212 1213
				(!test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags) &&
				rinfo->head->result == 0) ?  req->r_fmode : -1,
1214 1215 1216 1217 1218 1219 1220 1221
				&req->r_caps_reservation);
		if (err < 0) {
			pr_err("fill_inode badness %p %llx.%llx\n",
				in, ceph_vinop(in));
			goto done;
		}
	}

1222 1223 1224 1225
	/*
	 * ignore null lease/binding on snapdir ENOENT, or else we
	 * will have trouble splicing in the virtual snapdir later
	 */
1226 1227 1228
	if (rinfo->head->is_dentry &&
            !test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags) &&
	    test_bit(CEPH_MDS_R_PARENT_LOCKED, &req->r_req_flags) &&
1229
	    (rinfo->head->is_target || strncmp(req->r_dentry->d_name.name,
1230
					       fsc->mount_options->snapdir_name,
1231
					       req->r_dentry->d_name.len))) {
S
Sage Weil 已提交
1232 1233 1234 1235 1236
		/*
		 * lookup link rename   : null -> possibly existing inode
		 * mknod symlink mkdir  : null -> new inode
		 * unlink               : linked -> null
		 */
1237
		struct inode *dir = req->r_parent;
S
Sage Weil 已提交
1238 1239 1240 1241 1242
		struct dentry *dn = req->r_dentry;
		bool have_dir_cap, have_lease;

		BUG_ON(!dn);
		BUG_ON(!dir);
1243
		BUG_ON(d_inode(dn->d_parent) != dir);
1244 1245 1246 1247 1248 1249

		dvino.ino = le64_to_cpu(rinfo->diri.in->ino);
		dvino.snap = le64_to_cpu(rinfo->diri.in->snapid);

		BUG_ON(ceph_ino(dir) != dvino.ino);
		BUG_ON(ceph_snap(dir) != dvino.snap);
S
Sage Weil 已提交
1250 1251 1252 1253 1254 1255 1256 1257

		/* do we have a lease on the whole dir? */
		have_dir_cap =
			(le32_to_cpu(rinfo->diri.in->cap.caps) &
			 CEPH_CAP_FILE_SHARED);

		/* do we have a dn lease? */
		have_lease = have_dir_cap ||
S
Sage Weil 已提交
1258
			le32_to_cpu(rinfo->dlease->duration_ms);
S
Sage Weil 已提交
1259 1260 1261 1262 1263
		if (!have_lease)
			dout("fill_trace  no dentry lease or dir cap\n");

		/* rename? */
		if (req->r_old_dentry && req->r_op == CEPH_MDS_OP_RENAME) {
1264 1265 1266
			struct inode *olddir = req->r_old_dentry_dir;
			BUG_ON(!olddir);

A
Al Viro 已提交
1267
			dout(" src %p '%pd' dst %p '%pd'\n",
S
Sage Weil 已提交
1268
			     req->r_old_dentry,
A
Al Viro 已提交
1269 1270
			     req->r_old_dentry,
			     dn, dn);
S
Sage Weil 已提交
1271 1272
			dout("fill_trace doing d_move %p -> %p\n",
			     req->r_old_dentry, dn);
S
Sage Weil 已提交
1273

Y
Yan, Zheng 已提交
1274 1275 1276 1277
			/* d_move screws up sibling dentries' offsets */
			ceph_dir_clear_ordered(dir);
			ceph_dir_clear_ordered(olddir);

S
Sage Weil 已提交
1278
			d_move(req->r_old_dentry, dn);
A
Al Viro 已提交
1279 1280
			dout(" src %p '%pd' dst %p '%pd'\n",
			     req->r_old_dentry,
S
Sage Weil 已提交
1281
			     req->r_old_dentry,
A
Al Viro 已提交
1282
			     dn, dn);
1283

1284 1285
			/* ensure target dentry is invalidated, despite
			   rehashing bug in vfs_rename_dir */
1286 1287
			ceph_invalidate_dentry_lease(dn);

1288
			dout("dn %p gets new offset %lld\n", req->r_old_dentry,
S
Sage Weil 已提交
1289
			     ceph_dentry(req->r_old_dentry)->offset);
1290

S
Sage Weil 已提交
1291 1292 1293 1294 1295 1296
			dn = req->r_old_dentry;  /* use old_dentry */
		}

		/* null dentry? */
		if (!rinfo->head->is_target) {
			dout("fill_trace null dentry\n");
1297
			if (d_really_is_positive(dn)) {
1298
				ceph_dir_clear_ordered(dir);
S
Sage Weil 已提交
1299 1300
				dout("d_delete %p\n", dn);
				d_delete(dn);
1301 1302
			} else if (have_lease) {
				if (d_unhashed(dn))
1303
					d_add(dn, NULL);
S
Sage Weil 已提交
1304 1305
				update_dentry_lease(dn, rinfo->dlease,
						    session,
1306 1307
						    req->r_request_started,
						    NULL, &dvino);
S
Sage Weil 已提交
1308 1309 1310 1311 1312
			}
			goto done;
		}

		/* attach proper inode */
1313
		if (d_really_is_negative(dn)) {
1314
			ceph_dir_clear_ordered(dir);
1315
			ihold(in);
1316
			dn = splice_dentry(dn, in);
S
Sage Weil 已提交
1317 1318 1319 1320 1321
			if (IS_ERR(dn)) {
				err = PTR_ERR(dn);
				goto done;
			}
			req->r_dentry = dn;  /* may have spliced */
1322
		} else if (d_really_is_positive(dn) && d_inode(dn) != in) {
S
Sage Weil 已提交
1323
			dout(" %p links to %p %llx.%llx, not %llx.%llx\n",
1324
			     dn, d_inode(dn), ceph_vinop(d_inode(dn)),
1325
			     ceph_vinop(in));
1326
			ceph_dir_clear_ordered(dir);
1327
			d_invalidate(dn);
S
Sage Weil 已提交
1328 1329 1330
			have_lease = false;
		}

1331 1332 1333
		if (have_lease) {
			tvino.ino = le64_to_cpu(rinfo->targeti.in->ino);
			tvino.snap = le64_to_cpu(rinfo->targeti.in->snapid);
S
Sage Weil 已提交
1334
			update_dentry_lease(dn, rinfo->dlease, session,
1335 1336 1337
					    req->r_request_started,
					    &tvino, &dvino);
		}
S
Sage Weil 已提交
1338
		dout(" final dn %p\n", dn);
1339 1340 1341
	} else if ((req->r_op == CEPH_MDS_OP_LOOKUPSNAP ||
		    req->r_op == CEPH_MDS_OP_MKSNAP) &&
		   !test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags)) {
S
Sage Weil 已提交
1342
		struct dentry *dn = req->r_dentry;
1343
		struct inode *dir = req->r_parent;
S
Sage Weil 已提交
1344 1345 1346

		/* fill out a snapdir LOOKUPSNAP dentry */
		BUG_ON(!dn);
1347 1348
		BUG_ON(!dir);
		BUG_ON(ceph_snap(dir) != CEPH_SNAPDIR);
S
Sage Weil 已提交
1349
		dout(" linking snapped dir %p to dn %p\n", in, dn);
1350
		ceph_dir_clear_ordered(dir);
1351
		ihold(in);
1352
		dn = splice_dentry(dn, in);
S
Sage Weil 已提交
1353 1354 1355 1356 1357
		if (IS_ERR(dn)) {
			err = PTR_ERR(dn);
			goto done;
		}
		req->r_dentry = dn;  /* may have spliced */
1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377
	} else if (rinfo->head->is_dentry) {
		struct ceph_vino *ptvino = NULL;

		if ((le32_to_cpu(rinfo->diri.in->cap.caps) & CEPH_CAP_FILE_SHARED) ||
		    le32_to_cpu(rinfo->dlease->duration_ms)) {
			dvino.ino = le64_to_cpu(rinfo->diri.in->ino);
			dvino.snap = le64_to_cpu(rinfo->diri.in->snapid);

			if (rinfo->head->is_target) {
				tvino.ino = le64_to_cpu(rinfo->targeti.in->ino);
				tvino.snap = le64_to_cpu(rinfo->targeti.in->snapid);
				ptvino = &tvino;
			}

			update_dentry_lease(req->r_dentry, rinfo->dlease,
				session, req->r_request_started, ptvino,
				&dvino);
		} else {
			dout("%s: no dentry lease or dir cap\n", __func__);
		}
S
Sage Weil 已提交
1378 1379 1380 1381 1382 1383 1384 1385 1386
	}
done:
	dout("fill_trace done err=%d\n", err);
	return err;
}

/*
 * Prepopulate our cache with readdir results, leases, etc.
 */
1387 1388 1389 1390 1391 1392 1393
static int readdir_prepopulate_inodes_only(struct ceph_mds_request *req,
					   struct ceph_mds_session *session)
{
	struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info;
	int i, err = 0;

	for (i = 0; i < rinfo->dir_nr; i++) {
1394
		struct ceph_mds_reply_dir_entry *rde = rinfo->dir_entries + i;
1395 1396 1397 1398
		struct ceph_vino vino;
		struct inode *in;
		int rc;

1399 1400
		vino.ino = le64_to_cpu(rde->inode.in->ino);
		vino.snap = le64_to_cpu(rde->inode.in->snapid);
1401 1402 1403 1404 1405 1406 1407

		in = ceph_get_inode(req->r_dentry->d_sb, vino);
		if (IS_ERR(in)) {
			err = PTR_ERR(in);
			dout("new_inode badness got %d\n", err);
			continue;
		}
1408
		rc = fill_inode(in, NULL, &rde->inode, NULL, session,
1409 1410 1411 1412 1413 1414
				req->r_request_started, -1,
				&req->r_caps_reservation);
		if (rc < 0) {
			pr_err("fill_inode badness on %p got %d\n", in, rc);
			err = rc;
		}
Y
Yan, Zheng 已提交
1415
		iput(in);
1416 1417 1418 1419 1420
	}

	return err;
}

Y
Yan, Zheng 已提交
1421 1422 1423 1424
void ceph_readdir_cache_release(struct ceph_readdir_cache_control *ctl)
{
	if (ctl->page) {
		kunmap(ctl->page);
1425
		put_page(ctl->page);
Y
Yan, Zheng 已提交
1426 1427 1428 1429 1430 1431 1432 1433 1434
		ctl->page = NULL;
	}
}

static int fill_readdir_cache(struct inode *dir, struct dentry *dn,
			      struct ceph_readdir_cache_control *ctl,
			      struct ceph_mds_request *req)
{
	struct ceph_inode_info *ci = ceph_inode(dir);
1435
	unsigned nsize = PAGE_SIZE / sizeof(struct dentry*);
Y
Yan, Zheng 已提交
1436 1437 1438 1439 1440
	unsigned idx = ctl->index % nsize;
	pgoff_t pgoff = ctl->index / nsize;

	if (!ctl->page || pgoff != page_index(ctl->page)) {
		ceph_readdir_cache_release(ctl);
1441 1442 1443 1444
		if (idx == 0)
			ctl->page = grab_cache_page(&dir->i_data, pgoff);
		else
			ctl->page = find_lock_page(&dir->i_data, pgoff);
Y
Yan, Zheng 已提交
1445 1446
		if (!ctl->page) {
			ctl->index = -1;
1447
			return idx == 0 ? -ENOMEM : 0;
Y
Yan, Zheng 已提交
1448 1449 1450 1451 1452
		}
		/* reading/filling the cache are serialized by
		 * i_mutex, no need to use page lock */
		unlock_page(ctl->page);
		ctl->dentries = kmap(ctl->page);
1453
		if (idx == 0)
1454
			memset(ctl->dentries, 0, PAGE_SIZE);
Y
Yan, Zheng 已提交
1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468
	}

	if (req->r_dir_release_cnt == atomic64_read(&ci->i_release_count) &&
	    req->r_dir_ordered_cnt == atomic64_read(&ci->i_ordered_count)) {
		dout("readdir cache dn %p idx %d\n", dn, ctl->index);
		ctl->dentries[idx] = dn;
		ctl->index++;
	} else {
		dout("disable readdir cache\n");
		ctl->index = -1;
	}
	return 0;
}

S
Sage Weil 已提交
1469 1470 1471 1472
int ceph_readdir_prepopulate(struct ceph_mds_request *req,
			     struct ceph_mds_session *session)
{
	struct dentry *parent = req->r_dentry;
1473
	struct ceph_inode_info *ci = ceph_inode(d_inode(parent));
S
Sage Weil 已提交
1474 1475 1476 1477
	struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info;
	struct qstr dname;
	struct dentry *dn;
	struct inode *in;
Y
Yan, Zheng 已提交
1478
	int err = 0, skipped = 0, ret, i;
S
Sage Weil 已提交
1479
	struct ceph_mds_request_head *rhead = req->r_request->front.iov_base;
1480
	u32 frag = le32_to_cpu(rhead->args.readdir.frag);
1481 1482
	u32 last_hash = 0;
	u32 fpos_offset;
Y
Yan, Zheng 已提交
1483 1484
	struct ceph_readdir_cache_control cache_ctl = {};

1485
	if (test_bit(CEPH_MDS_R_ABORTED, &req->r_req_flags))
Y
Yan, Zheng 已提交
1486
		return readdir_prepopulate_inodes_only(req, session);
1487

1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498
	if (rinfo->hash_order) {
		if (req->r_path2) {
			last_hash = ceph_str_hash(ci->i_dir_layout.dl_dir_hash,
						  req->r_path2,
						  strlen(req->r_path2));
			last_hash = ceph_frag_value(last_hash);
		} else if (rinfo->offset_hash) {
			/* mds understands offset_hash */
			WARN_ON_ONCE(req->r_readdir_offset != 2);
			last_hash = le32_to_cpu(rhead->args.readdir.offset_hash);
		}
1499 1500
	}

1501 1502 1503 1504 1505
	if (rinfo->dir_dir &&
	    le32_to_cpu(rinfo->dir_dir->frag) != frag) {
		dout("readdir_prepopulate got new frag %x -> %x\n",
		     frag, le32_to_cpu(rinfo->dir_dir->frag));
		frag = le32_to_cpu(rinfo->dir_dir->frag);
1506
		if (!rinfo->hash_order)
Y
Yan, Zheng 已提交
1507
			req->r_readdir_offset = 2;
1508
	}
S
Sage Weil 已提交
1509 1510 1511 1512 1513 1514 1515 1516

	if (le32_to_cpu(rinfo->head->op) == CEPH_MDS_OP_LSSNAP) {
		dout("readdir_prepopulate %d items under SNAPDIR dn %p\n",
		     rinfo->dir_nr, parent);
	} else {
		dout("readdir_prepopulate %d items under dn %p\n",
		     rinfo->dir_nr, parent);
		if (rinfo->dir_dir)
1517
			ceph_fill_dirfrag(d_inode(parent), rinfo->dir_dir);
S
Sage Weil 已提交
1518

1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529
		if (ceph_frag_is_leftmost(frag) &&
		    req->r_readdir_offset == 2 &&
		    !(rinfo->hash_order && last_hash)) {
			/* note dir version at start of readdir so we can
			 * tell if any dentries get dropped */
			req->r_dir_release_cnt =
				atomic64_read(&ci->i_release_count);
			req->r_dir_ordered_cnt =
				atomic64_read(&ci->i_ordered_count);
			req->r_readdir_cache_idx = 0;
		}
Y
Yan, Zheng 已提交
1530 1531 1532
	}

	cache_ctl.index = req->r_readdir_cache_idx;
1533
	fpos_offset = req->r_readdir_offset;
Y
Yan, Zheng 已提交
1534

1535
	/* FIXME: release caps/leases if error occurs */
S
Sage Weil 已提交
1536
	for (i = 0; i < rinfo->dir_nr; i++) {
1537
		struct ceph_mds_reply_dir_entry *rde = rinfo->dir_entries + i;
1538
		struct ceph_vino tvino, dvino;
S
Sage Weil 已提交
1539

1540 1541
		dname.name = rde->name;
		dname.len = rde->name_len;
1542
		dname.hash = full_name_hash(parent, dname.name, dname.len);
S
Sage Weil 已提交
1543

1544 1545
		tvino.ino = le64_to_cpu(rde->inode.in->ino);
		tvino.snap = le64_to_cpu(rde->inode.in->snapid);
S
Sage Weil 已提交
1546

1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557
		if (rinfo->hash_order) {
			u32 hash = ceph_str_hash(ci->i_dir_layout.dl_dir_hash,
						 rde->name, rde->name_len);
			hash = ceph_frag_value(hash);
			if (hash != last_hash)
				fpos_offset = 2;
			last_hash = hash;
			rde->offset = ceph_make_fpos(hash, fpos_offset++, true);
		} else {
			rde->offset = ceph_make_fpos(frag, fpos_offset++, false);
		}
S
Sage Weil 已提交
1558 1559 1560 1561 1562 1563 1564 1565 1566 1567

retry_lookup:
		dn = d_lookup(parent, &dname);
		dout("d_lookup on parent=%p name=%.*s got %p\n",
		     parent, dname.len, dname.name, dn);

		if (!dn) {
			dn = d_alloc(parent, &dname);
			dout("d_alloc %p '%.*s' = %p\n", parent,
			     dname.len, dname.name, dn);
1568
			if (!dn) {
S
Sage Weil 已提交
1569 1570 1571 1572
				dout("d_alloc badness\n");
				err = -ENOMEM;
				goto out;
			}
1573
		} else if (d_really_is_positive(dn) &&
1574 1575
			   (ceph_ino(d_inode(dn)) != tvino.ino ||
			    ceph_snap(d_inode(dn)) != tvino.snap)) {
S
Sage Weil 已提交
1576
			dout(" dn %p points to wrong inode %p\n",
1577
			     dn, d_inode(dn));
1578
			__ceph_dir_clear_ordered(ci);
S
Sage Weil 已提交
1579 1580 1581 1582 1583 1584
			d_delete(dn);
			dput(dn);
			goto retry_lookup;
		}

		/* inode */
1585 1586
		if (d_really_is_positive(dn)) {
			in = d_inode(dn);
S
Sage Weil 已提交
1587
		} else {
1588
			in = ceph_get_inode(parent->d_sb, tvino);
1589
			if (IS_ERR(in)) {
S
Sage Weil 已提交
1590
				dout("new_inode badness\n");
1591
				d_drop(dn);
S
Sage Weil 已提交
1592
				dput(dn);
1593
				err = PTR_ERR(in);
S
Sage Weil 已提交
1594 1595 1596 1597
				goto out;
			}
		}

1598
		ret = fill_inode(in, NULL, &rde->inode, NULL, session,
Y
Yan, Zheng 已提交
1599 1600 1601
				 req->r_request_started, -1,
				 &req->r_caps_reservation);
		if (ret < 0) {
S
Sage Weil 已提交
1602
			pr_err("fill_inode badness on %p\n", in);
1603 1604 1605
			if (d_really_is_positive(dn))
				__ceph_dir_clear_ordered(ci);
			else
1606 1607
				iput(in);
			d_drop(dn);
Y
Yan, Zheng 已提交
1608
			err = ret;
1609
			goto next_item;
S
Sage Weil 已提交
1610
		}
1611

1612
		if (d_really_is_negative(dn)) {
Y
Yan, Zheng 已提交
1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623
			struct dentry *realdn;

			if (ceph_security_xattr_deadlock(in)) {
				dout(" skip splicing dn %p to inode %p"
				     " (security xattr deadlock)\n", dn, in);
				iput(in);
				skipped++;
				goto next_item;
			}

			realdn = splice_dentry(dn, in);
Y
Yan, Zheng 已提交
1624 1625 1626
			if (IS_ERR(realdn)) {
				err = PTR_ERR(realdn);
				d_drop(dn);
1627 1628 1629
				dn = NULL;
				goto next_item;
			}
Y
Yan, Zheng 已提交
1630
			dn = realdn;
1631 1632
		}

1633
		ceph_dentry(dn)->offset = rde->offset;
1634

1635
		dvino = ceph_vino(d_inode(parent));
1636
		update_dentry_lease(dn, rde->lease, req->r_session,
1637
				    req->r_request_started, &tvino, &dvino);
Y
Yan, Zheng 已提交
1638

Y
Yan, Zheng 已提交
1639
		if (err == 0 && skipped == 0 && cache_ctl.index >= 0) {
Y
Yan, Zheng 已提交
1640 1641 1642 1643 1644
			ret = fill_readdir_cache(d_inode(parent), dn,
						 &cache_ctl, req);
			if (ret < 0)
				err = ret;
		}
1645 1646 1647
next_item:
		if (dn)
			dput(dn);
S
Sage Weil 已提交
1648 1649
	}
out:
Y
Yan, Zheng 已提交
1650
	if (err == 0 && skipped == 0) {
1651
		set_bit(CEPH_MDS_R_DID_PREPOPULATE, &req->r_req_flags);
Y
Yan, Zheng 已提交
1652 1653 1654
		req->r_readdir_cache_idx = cache_ctl.index;
	}
	ceph_readdir_cache_release(&cache_ctl);
S
Sage Weil 已提交
1655 1656 1657 1658
	dout("readdir_prepopulate done\n");
	return err;
}

1659
bool ceph_inode_set_size(struct inode *inode, loff_t size)
S
Sage Weil 已提交
1660 1661
{
	struct ceph_inode_info *ci = ceph_inode(inode);
1662
	bool ret;
S
Sage Weil 已提交
1663

1664
	spin_lock(&ci->i_ceph_lock);
S
Sage Weil 已提交
1665
	dout("set_size %p %llu -> %llu\n", inode, inode->i_size, size);
1666
	i_size_write(inode, size);
1667
	inode->i_blocks = calc_inode_blocks(size);
S
Sage Weil 已提交
1668

1669
	ret = __ceph_should_report_size(ci);
S
Sage Weil 已提交
1670

1671
	spin_unlock(&ci->i_ceph_lock);
S
Sage Weil 已提交
1672 1673 1674 1675 1676 1677 1678
	return ret;
}

/*
 * Write back inode data in a worker thread.  (This can't be done
 * in the message handler context.)
 */
1679 1680
void ceph_queue_writeback(struct inode *inode)
{
1681
	ihold(inode);
1682 1683
	if (queue_work(ceph_inode_to_client(inode)->wb_wq,
		       &ceph_inode(inode)->i_wb_work)) {
1684
		dout("ceph_queue_writeback %p\n", inode);
1685
	} else {
1686
		dout("ceph_queue_writeback %p failed\n", inode);
1687
		iput(inode);
1688 1689 1690 1691
	}
}

static void ceph_writeback_work(struct work_struct *work)
S
Sage Weil 已提交
1692 1693 1694 1695 1696 1697 1698 1699 1700 1701
{
	struct ceph_inode_info *ci = container_of(work, struct ceph_inode_info,
						  i_wb_work);
	struct inode *inode = &ci->vfs_inode;

	dout("writeback %p\n", inode);
	filemap_fdatawrite(&inode->i_data);
	iput(inode);
}

1702 1703 1704 1705 1706
/*
 * queue an async invalidation
 */
void ceph_queue_invalidate(struct inode *inode)
{
1707
	ihold(inode);
1708 1709 1710 1711 1712
	if (queue_work(ceph_inode_to_client(inode)->pg_inv_wq,
		       &ceph_inode(inode)->i_pg_inv_work)) {
		dout("ceph_queue_invalidate %p\n", inode);
	} else {
		dout("ceph_queue_invalidate %p failed\n", inode);
1713
		iput(inode);
1714 1715 1716
	}
}

S
Sage Weil 已提交
1717 1718 1719 1720
/*
 * Invalidate inode pages in a worker thread.  (This can't be done
 * in the message handler context.)
 */
1721
static void ceph_invalidate_work(struct work_struct *work)
S
Sage Weil 已提交
1722 1723 1724 1725
{
	struct ceph_inode_info *ci = container_of(work, struct ceph_inode_info,
						  i_pg_inv_work);
	struct inode *inode = &ci->vfs_inode;
1726
	struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
S
Sage Weil 已提交
1727 1728 1729
	u32 orig_gen;
	int check = 0;

Y
Yan, Zheng 已提交
1730
	mutex_lock(&ci->i_truncate_mutex);
1731

1732
	if (READ_ONCE(fsc->mount_state) == CEPH_MOUNT_SHUTDOWN) {
1733 1734 1735 1736 1737 1738 1739 1740
		pr_warn_ratelimited("invalidate_pages %p %lld forced umount\n",
				    inode, ceph_ino(inode));
		mapping_set_error(inode->i_mapping, -EIO);
		truncate_pagecache(inode, 0);
		mutex_unlock(&ci->i_truncate_mutex);
		goto out;
	}

1741
	spin_lock(&ci->i_ceph_lock);
S
Sage Weil 已提交
1742 1743
	dout("invalidate_pages %p gen %d revoking %d\n", inode,
	     ci->i_rdcache_gen, ci->i_rdcache_revoking);
1744
	if (ci->i_rdcache_revoking != ci->i_rdcache_gen) {
Y
Yan, Zheng 已提交
1745 1746
		if (__ceph_caps_revoking_other(ci, NULL, CEPH_CAP_FILE_CACHE))
			check = 1;
1747
		spin_unlock(&ci->i_ceph_lock);
Y
Yan, Zheng 已提交
1748
		mutex_unlock(&ci->i_truncate_mutex);
S
Sage Weil 已提交
1749 1750 1751
		goto out;
	}
	orig_gen = ci->i_rdcache_gen;
1752
	spin_unlock(&ci->i_ceph_lock);
S
Sage Weil 已提交
1753

1754 1755 1756
	if (invalidate_inode_pages2(inode->i_mapping) < 0) {
		pr_err("invalidate_pages %p fails\n", inode);
	}
S
Sage Weil 已提交
1757

1758
	spin_lock(&ci->i_ceph_lock);
1759 1760
	if (orig_gen == ci->i_rdcache_gen &&
	    orig_gen == ci->i_rdcache_revoking) {
S
Sage Weil 已提交
1761 1762
		dout("invalidate_pages %p gen %d successful\n", inode,
		     ci->i_rdcache_gen);
1763
		ci->i_rdcache_revoking--;
S
Sage Weil 已提交
1764 1765
		check = 1;
	} else {
1766 1767 1768
		dout("invalidate_pages %p gen %d raced, now %d revoking %d\n",
		     inode, orig_gen, ci->i_rdcache_gen,
		     ci->i_rdcache_revoking);
Y
Yan, Zheng 已提交
1769 1770
		if (__ceph_caps_revoking_other(ci, NULL, CEPH_CAP_FILE_CACHE))
			check = 1;
S
Sage Weil 已提交
1771
	}
1772
	spin_unlock(&ci->i_ceph_lock);
Y
Yan, Zheng 已提交
1773
	mutex_unlock(&ci->i_truncate_mutex);
Y
Yan, Zheng 已提交
1774
out:
S
Sage Weil 已提交
1775 1776 1777 1778 1779 1780 1781
	if (check)
		ceph_check_caps(ci, 0, NULL);
	iput(inode);
}


/*
1782
 * called by trunc_wq;
S
Sage Weil 已提交
1783 1784 1785
 *
 * We also truncate in a separate thread as well.
 */
1786
static void ceph_vmtruncate_work(struct work_struct *work)
S
Sage Weil 已提交
1787 1788 1789 1790 1791 1792
{
	struct ceph_inode_info *ci = container_of(work, struct ceph_inode_info,
						  i_vmtruncate_work);
	struct inode *inode = &ci->vfs_inode;

	dout("vmtruncate_work %p\n", inode);
Y
Yan, Zheng 已提交
1793
	__ceph_do_pending_vmtruncate(inode);
S
Sage Weil 已提交
1794 1795 1796
	iput(inode);
}

1797 1798 1799 1800 1801 1802 1803 1804
/*
 * Queue an async vmtruncate.  If we fail to queue work, we will handle
 * the truncation the next time we call __ceph_do_pending_vmtruncate.
 */
void ceph_queue_vmtruncate(struct inode *inode)
{
	struct ceph_inode_info *ci = ceph_inode(inode);

1805
	ihold(inode);
1806

1807
	if (queue_work(ceph_sb_to_client(inode->i_sb)->trunc_wq,
1808 1809 1810 1811 1812
		       &ci->i_vmtruncate_work)) {
		dout("ceph_queue_vmtruncate %p\n", inode);
	} else {
		dout("ceph_queue_vmtruncate %p failed, pending=%d\n",
		     inode, ci->i_truncate_pending);
1813
		iput(inode);
1814 1815 1816
	}
}

S
Sage Weil 已提交
1817 1818 1819 1820
/*
 * Make sure any pending truncation is applied before doing anything
 * that may depend on it.
 */
Y
Yan, Zheng 已提交
1821
void __ceph_do_pending_vmtruncate(struct inode *inode)
S
Sage Weil 已提交
1822 1823 1824
{
	struct ceph_inode_info *ci = ceph_inode(inode);
	u64 to;
1825
	int wrbuffer_refs, finish = 0;
S
Sage Weil 已提交
1826

Y
Yan, Zheng 已提交
1827
	mutex_lock(&ci->i_truncate_mutex);
S
Sage Weil 已提交
1828
retry:
1829
	spin_lock(&ci->i_ceph_lock);
S
Sage Weil 已提交
1830 1831
	if (ci->i_truncate_pending == 0) {
		dout("__do_pending_vmtruncate %p none pending\n", inode);
1832
		spin_unlock(&ci->i_ceph_lock);
Y
Yan, Zheng 已提交
1833
		mutex_unlock(&ci->i_truncate_mutex);
S
Sage Weil 已提交
1834 1835 1836 1837 1838 1839 1840 1841
		return;
	}

	/*
	 * make sure any dirty snapped pages are flushed before we
	 * possibly truncate them.. so write AND block!
	 */
	if (ci->i_wrbuffer_ref_head < ci->i_wrbuffer_ref) {
1842 1843 1844 1845 1846 1847 1848 1849 1850
		struct ceph_cap_snap *capsnap;
		to = ci->i_truncate_size;
		list_for_each_entry(capsnap, &ci->i_cap_snaps, ci_item) {
			// MDS should have revoked Frw caps
			WARN_ON_ONCE(capsnap->writing);
			if (capsnap->dirty_pages && capsnap->size > to)
				to = capsnap->size;
		}
		spin_unlock(&ci->i_ceph_lock);
S
Sage Weil 已提交
1851 1852
		dout("__do_pending_vmtruncate %p flushing snaps first\n",
		     inode);
1853 1854 1855

		truncate_pagecache(inode, to);

S
Sage Weil 已提交
1856 1857 1858 1859 1860
		filemap_write_and_wait_range(&inode->i_data, 0,
					     inode->i_sb->s_maxbytes);
		goto retry;
	}

Y
Yan, Zheng 已提交
1861 1862 1863
	/* there should be no reader or writer */
	WARN_ON_ONCE(ci->i_rd_ref || ci->i_wr_ref);

S
Sage Weil 已提交
1864 1865 1866 1867
	to = ci->i_truncate_size;
	wrbuffer_refs = ci->i_wrbuffer_ref;
	dout("__do_pending_vmtruncate %p (%d) to %lld\n", inode,
	     ci->i_truncate_pending, to);
1868
	spin_unlock(&ci->i_ceph_lock);
S
Sage Weil 已提交
1869

1870
	truncate_pagecache(inode, to);
S
Sage Weil 已提交
1871

1872
	spin_lock(&ci->i_ceph_lock);
1873 1874 1875 1876
	if (to == ci->i_truncate_size) {
		ci->i_truncate_pending = 0;
		finish = 1;
	}
1877
	spin_unlock(&ci->i_ceph_lock);
1878 1879
	if (!finish)
		goto retry;
S
Sage Weil 已提交
1880

Y
Yan, Zheng 已提交
1881 1882
	mutex_unlock(&ci->i_truncate_mutex);

S
Sage Weil 已提交
1883 1884
	if (wrbuffer_refs == 0)
		ceph_check_caps(ci, CHECK_CAPS_AUTHONLY, NULL);
1885 1886

	wake_up_all(&ci->i_cap_wq);
S
Sage Weil 已提交
1887 1888 1889 1890 1891 1892
}

/*
 * symlinks
 */
static const struct inode_operations ceph_symlink_iops = {
1893
	.get_link = simple_get_link,
Y
Yan, Zheng 已提交
1894 1895 1896
	.setattr = ceph_setattr,
	.getattr = ceph_getattr,
	.listxattr = ceph_listxattr,
S
Sage Weil 已提交
1897 1898
};

1899
int __ceph_setattr(struct inode *inode, struct iattr *attr)
S
Sage Weil 已提交
1900 1901 1902 1903
{
	struct ceph_inode_info *ci = ceph_inode(inode);
	const unsigned int ia_valid = attr->ia_valid;
	struct ceph_mds_request *req;
1904
	struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
1905
	struct ceph_cap_flush *prealloc_cf;
S
Sage Weil 已提交
1906 1907 1908 1909
	int issued;
	int release = 0, dirtied = 0;
	int mask = 0;
	int err = 0;
1910
	int inode_dirty_flags = 0;
1911
	bool lock_snap_rwsem = false;
S
Sage Weil 已提交
1912

1913 1914 1915 1916
	prealloc_cf = ceph_alloc_cap_flush();
	if (!prealloc_cf)
		return -ENOMEM;

S
Sage Weil 已提交
1917 1918
	req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SETATTR,
				       USE_AUTH_MDS);
1919 1920
	if (IS_ERR(req)) {
		ceph_free_cap_flush(prealloc_cf);
S
Sage Weil 已提交
1921
		return PTR_ERR(req);
1922
	}
S
Sage Weil 已提交
1923

1924
	spin_lock(&ci->i_ceph_lock);
S
Sage Weil 已提交
1925
	issued = __ceph_caps_issued(ci, NULL);
1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937

	if (!ci->i_head_snapc &&
	    (issued & (CEPH_CAP_ANY_EXCL | CEPH_CAP_FILE_WR))) {
		lock_snap_rwsem = true;
		if (!down_read_trylock(&mdsc->snap_rwsem)) {
			spin_unlock(&ci->i_ceph_lock);
			down_read(&mdsc->snap_rwsem);
			spin_lock(&ci->i_ceph_lock);
			issued = __ceph_caps_issued(ci, NULL);
		}
	}

S
Sage Weil 已提交
1938 1939 1940 1941
	dout("setattr %p issued %s\n", inode, ceph_cap_string(issued));

	if (ia_valid & ATTR_UID) {
		dout("setattr %p uid %d -> %d\n", inode,
1942 1943
		     from_kuid(&init_user_ns, inode->i_uid),
		     from_kuid(&init_user_ns, attr->ia_uid));
S
Sage Weil 已提交
1944 1945 1946 1947
		if (issued & CEPH_CAP_AUTH_EXCL) {
			inode->i_uid = attr->ia_uid;
			dirtied |= CEPH_CAP_AUTH_EXCL;
		} else if ((issued & CEPH_CAP_AUTH_SHARED) == 0 ||
1948 1949 1950
			   !uid_eq(attr->ia_uid, inode->i_uid)) {
			req->r_args.setattr.uid = cpu_to_le32(
				from_kuid(&init_user_ns, attr->ia_uid));
S
Sage Weil 已提交
1951 1952 1953 1954 1955 1956
			mask |= CEPH_SETATTR_UID;
			release |= CEPH_CAP_AUTH_SHARED;
		}
	}
	if (ia_valid & ATTR_GID) {
		dout("setattr %p gid %d -> %d\n", inode,
1957 1958
		     from_kgid(&init_user_ns, inode->i_gid),
		     from_kgid(&init_user_ns, attr->ia_gid));
S
Sage Weil 已提交
1959 1960 1961 1962
		if (issued & CEPH_CAP_AUTH_EXCL) {
			inode->i_gid = attr->ia_gid;
			dirtied |= CEPH_CAP_AUTH_EXCL;
		} else if ((issued & CEPH_CAP_AUTH_SHARED) == 0 ||
1963 1964 1965
			   !gid_eq(attr->ia_gid, inode->i_gid)) {
			req->r_args.setattr.gid = cpu_to_le32(
				from_kgid(&init_user_ns, attr->ia_gid));
S
Sage Weil 已提交
1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977
			mask |= CEPH_SETATTR_GID;
			release |= CEPH_CAP_AUTH_SHARED;
		}
	}
	if (ia_valid & ATTR_MODE) {
		dout("setattr %p mode 0%o -> 0%o\n", inode, inode->i_mode,
		     attr->ia_mode);
		if (issued & CEPH_CAP_AUTH_EXCL) {
			inode->i_mode = attr->ia_mode;
			dirtied |= CEPH_CAP_AUTH_EXCL;
		} else if ((issued & CEPH_CAP_AUTH_SHARED) == 0 ||
			   attr->ia_mode != inode->i_mode) {
G
Guangliang Zhao 已提交
1978
			inode->i_mode = attr->ia_mode;
S
Sage Weil 已提交
1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033
			req->r_args.setattr.mode = cpu_to_le32(attr->ia_mode);
			mask |= CEPH_SETATTR_MODE;
			release |= CEPH_CAP_AUTH_SHARED;
		}
	}

	if (ia_valid & ATTR_ATIME) {
		dout("setattr %p atime %ld.%ld -> %ld.%ld\n", inode,
		     inode->i_atime.tv_sec, inode->i_atime.tv_nsec,
		     attr->ia_atime.tv_sec, attr->ia_atime.tv_nsec);
		if (issued & CEPH_CAP_FILE_EXCL) {
			ci->i_time_warp_seq++;
			inode->i_atime = attr->ia_atime;
			dirtied |= CEPH_CAP_FILE_EXCL;
		} else if ((issued & CEPH_CAP_FILE_WR) &&
			   timespec_compare(&inode->i_atime,
					    &attr->ia_atime) < 0) {
			inode->i_atime = attr->ia_atime;
			dirtied |= CEPH_CAP_FILE_WR;
		} else if ((issued & CEPH_CAP_FILE_SHARED) == 0 ||
			   !timespec_equal(&inode->i_atime, &attr->ia_atime)) {
			ceph_encode_timespec(&req->r_args.setattr.atime,
					     &attr->ia_atime);
			mask |= CEPH_SETATTR_ATIME;
			release |= CEPH_CAP_FILE_CACHE | CEPH_CAP_FILE_RD |
				CEPH_CAP_FILE_WR;
		}
	}
	if (ia_valid & ATTR_MTIME) {
		dout("setattr %p mtime %ld.%ld -> %ld.%ld\n", inode,
		     inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec,
		     attr->ia_mtime.tv_sec, attr->ia_mtime.tv_nsec);
		if (issued & CEPH_CAP_FILE_EXCL) {
			ci->i_time_warp_seq++;
			inode->i_mtime = attr->ia_mtime;
			dirtied |= CEPH_CAP_FILE_EXCL;
		} else if ((issued & CEPH_CAP_FILE_WR) &&
			   timespec_compare(&inode->i_mtime,
					    &attr->ia_mtime) < 0) {
			inode->i_mtime = attr->ia_mtime;
			dirtied |= CEPH_CAP_FILE_WR;
		} else if ((issued & CEPH_CAP_FILE_SHARED) == 0 ||
			   !timespec_equal(&inode->i_mtime, &attr->ia_mtime)) {
			ceph_encode_timespec(&req->r_args.setattr.mtime,
					     &attr->ia_mtime);
			mask |= CEPH_SETATTR_MTIME;
			release |= CEPH_CAP_FILE_SHARED | CEPH_CAP_FILE_RD |
				CEPH_CAP_FILE_WR;
		}
	}
	if (ia_valid & ATTR_SIZE) {
		dout("setattr %p size %lld -> %lld\n", inode,
		     inode->i_size, attr->ia_size);
		if ((issued & CEPH_CAP_FILE_EXCL) &&
		    attr->ia_size > inode->i_size) {
2034
			i_size_write(inode, attr->ia_size);
2035
			inode->i_blocks = calc_inode_blocks(attr->ia_size);
S
Sage Weil 已提交
2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076
			ci->i_reported_size = attr->ia_size;
			dirtied |= CEPH_CAP_FILE_EXCL;
		} else if ((issued & CEPH_CAP_FILE_SHARED) == 0 ||
			   attr->ia_size != inode->i_size) {
			req->r_args.setattr.size = cpu_to_le64(attr->ia_size);
			req->r_args.setattr.old_size =
				cpu_to_le64(inode->i_size);
			mask |= CEPH_SETATTR_SIZE;
			release |= CEPH_CAP_FILE_SHARED | CEPH_CAP_FILE_RD |
				CEPH_CAP_FILE_WR;
		}
	}

	/* these do nothing */
	if (ia_valid & ATTR_CTIME) {
		bool only = (ia_valid & (ATTR_SIZE|ATTR_MTIME|ATTR_ATIME|
					 ATTR_MODE|ATTR_UID|ATTR_GID)) == 0;
		dout("setattr %p ctime %ld.%ld -> %ld.%ld (%s)\n", inode,
		     inode->i_ctime.tv_sec, inode->i_ctime.tv_nsec,
		     attr->ia_ctime.tv_sec, attr->ia_ctime.tv_nsec,
		     only ? "ctime only" : "ignored");
		if (only) {
			/*
			 * if kernel wants to dirty ctime but nothing else,
			 * we need to choose a cap to dirty under, or do
			 * a almost-no-op setattr
			 */
			if (issued & CEPH_CAP_AUTH_EXCL)
				dirtied |= CEPH_CAP_AUTH_EXCL;
			else if (issued & CEPH_CAP_FILE_EXCL)
				dirtied |= CEPH_CAP_FILE_EXCL;
			else if (issued & CEPH_CAP_XATTR_EXCL)
				dirtied |= CEPH_CAP_XATTR_EXCL;
			else
				mask |= CEPH_SETATTR_CTIME;
		}
	}
	if (ia_valid & ATTR_FILE)
		dout("setattr %p ATTR_FILE ... hrm!\n", inode);

	if (dirtied) {
2077 2078
		inode_dirty_flags = __ceph_mark_dirty_caps(ci, dirtied,
							   &prealloc_cf);
Y
Yan, Zheng 已提交
2079
		inode->i_ctime = attr->ia_ctime;
S
Sage Weil 已提交
2080 2081 2082
	}

	release &= issued;
2083
	spin_unlock(&ci->i_ceph_lock);
2084 2085
	if (lock_snap_rwsem)
		up_read(&mdsc->snap_rwsem);
S
Sage Weil 已提交
2086

2087 2088 2089
	if (inode_dirty_flags)
		__mark_inode_dirty(inode, inode_dirty_flags);

G
Guangliang Zhao 已提交
2090

S
Sage Weil 已提交
2091
	if (mask) {
2092 2093
		req->r_inode = inode;
		ihold(inode);
S
Sage Weil 已提交
2094 2095 2096
		req->r_inode_drop = release;
		req->r_args.setattr.mask = cpu_to_le32(mask);
		req->r_num_caps = 1;
Y
Yan, Zheng 已提交
2097
		req->r_stamp = attr->ia_ctime;
2098
		err = ceph_mdsc_do_request(mdsc, NULL, req);
S
Sage Weil 已提交
2099 2100 2101 2102 2103
	}
	dout("setattr %p result=%d (%s locally, %d remote)\n", inode, err,
	     ceph_cap_string(dirtied), mask);

	ceph_mdsc_put_request(req);
2104
	ceph_free_cap_flush(prealloc_cf);
2105 2106 2107 2108

	if (err >= 0 && (mask & CEPH_SETATTR_SIZE))
		__ceph_do_pending_vmtruncate(inode);

S
Sage Weil 已提交
2109 2110 2111
	return err;
}

2112 2113 2114 2115 2116
/*
 * setattr
 */
int ceph_setattr(struct dentry *dentry, struct iattr *attr)
{
2117 2118 2119 2120 2121 2122
	struct inode *inode = d_inode(dentry);
	int err;

	if (ceph_snap(inode) != CEPH_NOSNAP)
		return -EROFS;

2123
	err = setattr_prepare(dentry, attr);
2124 2125 2126
	if (err != 0)
		return err;

2127 2128 2129 2130 2131 2132
	err = __ceph_setattr(inode, attr);

	if (err >= 0 && (attr->ia_valid & ATTR_MODE))
		err = posix_acl_chmod(inode, attr->ia_mode);

	return err;
2133 2134
}

S
Sage Weil 已提交
2135 2136 2137 2138
/*
 * Verify that we have a lease on the given mask.  If not,
 * do a getattr against an mds.
 */
2139 2140
int __ceph_do_getattr(struct inode *inode, struct page *locked_page,
		      int mask, bool force)
S
Sage Weil 已提交
2141
{
2142 2143
	struct ceph_fs_client *fsc = ceph_sb_to_client(inode->i_sb);
	struct ceph_mds_client *mdsc = fsc->mdsc;
S
Sage Weil 已提交
2144 2145 2146 2147 2148 2149 2150 2151
	struct ceph_mds_request *req;
	int err;

	if (ceph_snap(inode) == CEPH_SNAPDIR) {
		dout("do_getattr inode %p SNAPDIR\n", inode);
		return 0;
	}

2152 2153
	dout("do_getattr inode %p mask %s mode 0%o\n",
	     inode, ceph_cap_string(mask), inode->i_mode);
2154
	if (!force && ceph_caps_issued_mask(ceph_inode(inode), mask, 1))
S
Sage Weil 已提交
2155 2156 2157 2158 2159
		return 0;

	req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_GETATTR, USE_ANY_MDS);
	if (IS_ERR(req))
		return PTR_ERR(req);
2160 2161
	req->r_inode = inode;
	ihold(inode);
S
Sage Weil 已提交
2162 2163
	req->r_num_caps = 1;
	req->r_args.getattr.mask = cpu_to_le32(mask);
2164
	req->r_locked_page = locked_page;
S
Sage Weil 已提交
2165
	err = ceph_mdsc_do_request(mdsc, NULL, req);
2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176
	if (locked_page && err == 0) {
		u64 inline_version = req->r_reply_info.targeti.inline_version;
		if (inline_version == 0) {
			/* the reply is supposed to contain inline data */
			err = -EINVAL;
		} else if (inline_version == CEPH_INLINE_NONE) {
			err = -ENODATA;
		} else {
			err = req->r_reply_info.targeti.inline_len;
		}
	}
S
Sage Weil 已提交
2177 2178 2179 2180 2181 2182 2183 2184 2185 2186
	ceph_mdsc_put_request(req);
	dout("do_getattr result=%d\n", err);
	return err;
}


/*
 * Check inode permissions.  We verify we have a valid value for
 * the AUTH cap, then call the generic handler.
 */
2187
int ceph_permission(struct inode *inode, int mask)
S
Sage Weil 已提交
2188
{
2189 2190
	int err;

2191
	if (mask & MAY_NOT_BLOCK)
2192 2193
		return -ECHILD;

2194
	err = ceph_do_getattr(inode, CEPH_CAP_AUTH_SHARED, false);
S
Sage Weil 已提交
2195 2196

	if (!err)
2197
		err = generic_permission(inode, mask);
S
Sage Weil 已提交
2198 2199 2200 2201 2202 2203 2204
	return err;
}

/*
 * Get all attributes.  Hopefully somedata we'll have a statlite()
 * and can limit the fields we require to be accurate.
 */
2205 2206
int ceph_getattr(const struct path *path, struct kstat *stat,
		 u32 request_mask, unsigned int flags)
S
Sage Weil 已提交
2207
{
2208
	struct inode *inode = d_inode(path->dentry);
2209
	struct ceph_inode_info *ci = ceph_inode(inode);
S
Sage Weil 已提交
2210 2211
	int err;

2212
	err = ceph_do_getattr(inode, CEPH_STAT_CAP_INODE_ALL, false);
S
Sage Weil 已提交
2213 2214
	if (!err) {
		generic_fillattr(inode, stat);
Y
Yehuda Sadeh 已提交
2215
		stat->ino = ceph_translate_ino(inode->i_sb, inode->i_ino);
S
Sage Weil 已提交
2216 2217 2218 2219
		if (ceph_snap(inode) != CEPH_NOSNAP)
			stat->dev = ceph_snap(inode);
		else
			stat->dev = 0;
2220
		if (S_ISDIR(inode->i_mode)) {
2221 2222 2223 2224 2225
			if (ceph_test_mount_opt(ceph_sb_to_client(inode->i_sb),
						RBYTES))
				stat->size = ci->i_rbytes;
			else
				stat->size = ci->i_files + ci->i_subdirs;
2226
			stat->blocks = 0;
S
Sage Weil 已提交
2227
			stat->blksize = 65536;
2228
		}
S
Sage Weil 已提交
2229 2230 2231
	}
	return err;
}