PageRenderTime 77ms CodeModel.GetById 12ms app.highlight 50ms RepoModel.GetById 0ms app.codeStats 0ms

/fs/ceph/caps.c

https://bitbucket.org/slukk/jb-tsm-kernel-4.2
C | 3087 lines | 2272 code | 326 blank | 489 comment | 450 complexity | 420bae9a1f20f122fa6e49b116857865 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0

Large files files are truncated, but you can click here to view the full file

   1#include <linux/ceph/ceph_debug.h>
   2
   3#include <linux/fs.h>
   4#include <linux/kernel.h>
   5#include <linux/sched.h>
   6#include <linux/slab.h>
   7#include <linux/vmalloc.h>
   8#include <linux/wait.h>
   9#include <linux/writeback.h>
  10
  11#include "super.h"
  12#include "mds_client.h"
  13#include <linux/ceph/decode.h>
  14#include <linux/ceph/messenger.h>
  15
  16/*
  17 * Capability management
  18 *
  19 * The Ceph metadata servers control client access to inode metadata
  20 * and file data by issuing capabilities, granting clients permission
  21 * to read and/or write both inode field and file data to OSDs
  22 * (storage nodes).  Each capability consists of a set of bits
  23 * indicating which operations are allowed.
  24 *
  25 * If the client holds a *_SHARED cap, the client has a coherent value
  26 * that can be safely read from the cached inode.
  27 *
  28 * In the case of a *_EXCL (exclusive) or FILE_WR capabilities, the
  29 * client is allowed to change inode attributes (e.g., file size,
  30 * mtime), note its dirty state in the ceph_cap, and asynchronously
  31 * flush that metadata change to the MDS.
  32 *
  33 * In the event of a conflicting operation (perhaps by another
  34 * client), the MDS will revoke the conflicting client capabilities.
  35 *
  36 * In order for a client to cache an inode, it must hold a capability
  37 * with at least one MDS server.  When inodes are released, release
  38 * notifications are batched and periodically sent en masse to the MDS
  39 * cluster to release server state.
  40 */
  41
  42
  43/*
  44 * Generate readable cap strings for debugging output.
  45 */
  46#define MAX_CAP_STR 20
  47static char cap_str[MAX_CAP_STR][40];
  48static DEFINE_SPINLOCK(cap_str_lock);
  49static int last_cap_str;
  50
  51static char *gcap_string(char *s, int c)
  52{
  53	if (c & CEPH_CAP_GSHARED)
  54		*s++ = 's';
  55	if (c & CEPH_CAP_GEXCL)
  56		*s++ = 'x';
  57	if (c & CEPH_CAP_GCACHE)
  58		*s++ = 'c';
  59	if (c & CEPH_CAP_GRD)
  60		*s++ = 'r';
  61	if (c & CEPH_CAP_GWR)
  62		*s++ = 'w';
  63	if (c & CEPH_CAP_GBUFFER)
  64		*s++ = 'b';
  65	if (c & CEPH_CAP_GLAZYIO)
  66		*s++ = 'l';
  67	return s;
  68}
  69
  70const char *ceph_cap_string(int caps)
  71{
  72	int i;
  73	char *s;
  74	int c;
  75
  76	spin_lock(&cap_str_lock);
  77	i = last_cap_str++;
  78	if (last_cap_str == MAX_CAP_STR)
  79		last_cap_str = 0;
  80	spin_unlock(&cap_str_lock);
  81
  82	s = cap_str[i];
  83
  84	if (caps & CEPH_CAP_PIN)
  85		*s++ = 'p';
  86
  87	c = (caps >> CEPH_CAP_SAUTH) & 3;
  88	if (c) {
  89		*s++ = 'A';
  90		s = gcap_string(s, c);
  91	}
  92
  93	c = (caps >> CEPH_CAP_SLINK) & 3;
  94	if (c) {
  95		*s++ = 'L';
  96		s = gcap_string(s, c);
  97	}
  98
  99	c = (caps >> CEPH_CAP_SXATTR) & 3;
 100	if (c) {
 101		*s++ = 'X';
 102		s = gcap_string(s, c);
 103	}
 104
 105	c = caps >> CEPH_CAP_SFILE;
 106	if (c) {
 107		*s++ = 'F';
 108		s = gcap_string(s, c);
 109	}
 110
 111	if (s == cap_str[i])
 112		*s++ = '-';
 113	*s = 0;
 114	return cap_str[i];
 115}
 116
 117void ceph_caps_init(struct ceph_mds_client *mdsc)
 118{
 119	INIT_LIST_HEAD(&mdsc->caps_list);
 120	spin_lock_init(&mdsc->caps_list_lock);
 121}
 122
 123void ceph_caps_finalize(struct ceph_mds_client *mdsc)
 124{
 125	struct ceph_cap *cap;
 126
 127	spin_lock(&mdsc->caps_list_lock);
 128	while (!list_empty(&mdsc->caps_list)) {
 129		cap = list_first_entry(&mdsc->caps_list,
 130				       struct ceph_cap, caps_item);
 131		list_del(&cap->caps_item);
 132		kmem_cache_free(ceph_cap_cachep, cap);
 133	}
 134	mdsc->caps_total_count = 0;
 135	mdsc->caps_avail_count = 0;
 136	mdsc->caps_use_count = 0;
 137	mdsc->caps_reserve_count = 0;
 138	mdsc->caps_min_count = 0;
 139	spin_unlock(&mdsc->caps_list_lock);
 140}
 141
 142void ceph_adjust_min_caps(struct ceph_mds_client *mdsc, int delta)
 143{
 144	spin_lock(&mdsc->caps_list_lock);
 145	mdsc->caps_min_count += delta;
 146	BUG_ON(mdsc->caps_min_count < 0);
 147	spin_unlock(&mdsc->caps_list_lock);
 148}
 149
 150int ceph_reserve_caps(struct ceph_mds_client *mdsc,
 151		      struct ceph_cap_reservation *ctx, int need)
 152{
 153	int i;
 154	struct ceph_cap *cap;
 155	int have;
 156	int alloc = 0;
 157	LIST_HEAD(newcaps);
 158	int ret = 0;
 159
 160	dout("reserve caps ctx=%p need=%d\n", ctx, need);
 161
 162	/* first reserve any caps that are already allocated */
 163	spin_lock(&mdsc->caps_list_lock);
 164	if (mdsc->caps_avail_count >= need)
 165		have = need;
 166	else
 167		have = mdsc->caps_avail_count;
 168	mdsc->caps_avail_count -= have;
 169	mdsc->caps_reserve_count += have;
 170	BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
 171					 mdsc->caps_reserve_count +
 172					 mdsc->caps_avail_count);
 173	spin_unlock(&mdsc->caps_list_lock);
 174
 175	for (i = have; i < need; i++) {
 176		cap = kmem_cache_alloc(ceph_cap_cachep, GFP_NOFS);
 177		if (!cap) {
 178			ret = -ENOMEM;
 179			goto out_alloc_count;
 180		}
 181		list_add(&cap->caps_item, &newcaps);
 182		alloc++;
 183	}
 184	BUG_ON(have + alloc != need);
 185
 186	spin_lock(&mdsc->caps_list_lock);
 187	mdsc->caps_total_count += alloc;
 188	mdsc->caps_reserve_count += alloc;
 189	list_splice(&newcaps, &mdsc->caps_list);
 190
 191	BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
 192					 mdsc->caps_reserve_count +
 193					 mdsc->caps_avail_count);
 194	spin_unlock(&mdsc->caps_list_lock);
 195
 196	ctx->count = need;
 197	dout("reserve caps ctx=%p %d = %d used + %d resv + %d avail\n",
 198	     ctx, mdsc->caps_total_count, mdsc->caps_use_count,
 199	     mdsc->caps_reserve_count, mdsc->caps_avail_count);
 200	return 0;
 201
 202out_alloc_count:
 203	/* we didn't manage to reserve as much as we needed */
 204	pr_warning("reserve caps ctx=%p ENOMEM need=%d got=%d\n",
 205		   ctx, need, have);
 206	return ret;
 207}
 208
 209int ceph_unreserve_caps(struct ceph_mds_client *mdsc,
 210			struct ceph_cap_reservation *ctx)
 211{
 212	dout("unreserve caps ctx=%p count=%d\n", ctx, ctx->count);
 213	if (ctx->count) {
 214		spin_lock(&mdsc->caps_list_lock);
 215		BUG_ON(mdsc->caps_reserve_count < ctx->count);
 216		mdsc->caps_reserve_count -= ctx->count;
 217		mdsc->caps_avail_count += ctx->count;
 218		ctx->count = 0;
 219		dout("unreserve caps %d = %d used + %d resv + %d avail\n",
 220		     mdsc->caps_total_count, mdsc->caps_use_count,
 221		     mdsc->caps_reserve_count, mdsc->caps_avail_count);
 222		BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
 223						 mdsc->caps_reserve_count +
 224						 mdsc->caps_avail_count);
 225		spin_unlock(&mdsc->caps_list_lock);
 226	}
 227	return 0;
 228}
 229
 230static struct ceph_cap *get_cap(struct ceph_mds_client *mdsc,
 231				struct ceph_cap_reservation *ctx)
 232{
 233	struct ceph_cap *cap = NULL;
 234
 235	/* temporary, until we do something about cap import/export */
 236	if (!ctx) {
 237		cap = kmem_cache_alloc(ceph_cap_cachep, GFP_NOFS);
 238		if (cap) {
 239			mdsc->caps_use_count++;
 240			mdsc->caps_total_count++;
 241		}
 242		return cap;
 243	}
 244
 245	spin_lock(&mdsc->caps_list_lock);
 246	dout("get_cap ctx=%p (%d) %d = %d used + %d resv + %d avail\n",
 247	     ctx, ctx->count, mdsc->caps_total_count, mdsc->caps_use_count,
 248	     mdsc->caps_reserve_count, mdsc->caps_avail_count);
 249	BUG_ON(!ctx->count);
 250	BUG_ON(ctx->count > mdsc->caps_reserve_count);
 251	BUG_ON(list_empty(&mdsc->caps_list));
 252
 253	ctx->count--;
 254	mdsc->caps_reserve_count--;
 255	mdsc->caps_use_count++;
 256
 257	cap = list_first_entry(&mdsc->caps_list, struct ceph_cap, caps_item);
 258	list_del(&cap->caps_item);
 259
 260	BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
 261	       mdsc->caps_reserve_count + mdsc->caps_avail_count);
 262	spin_unlock(&mdsc->caps_list_lock);
 263	return cap;
 264}
 265
 266void ceph_put_cap(struct ceph_mds_client *mdsc, struct ceph_cap *cap)
 267{
 268	spin_lock(&mdsc->caps_list_lock);
 269	dout("put_cap %p %d = %d used + %d resv + %d avail\n",
 270	     cap, mdsc->caps_total_count, mdsc->caps_use_count,
 271	     mdsc->caps_reserve_count, mdsc->caps_avail_count);
 272	mdsc->caps_use_count--;
 273	/*
 274	 * Keep some preallocated caps around (ceph_min_count), to
 275	 * avoid lots of free/alloc churn.
 276	 */
 277	if (mdsc->caps_avail_count >= mdsc->caps_reserve_count +
 278				      mdsc->caps_min_count) {
 279		mdsc->caps_total_count--;
 280		kmem_cache_free(ceph_cap_cachep, cap);
 281	} else {
 282		mdsc->caps_avail_count++;
 283		list_add(&cap->caps_item, &mdsc->caps_list);
 284	}
 285
 286	BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
 287	       mdsc->caps_reserve_count + mdsc->caps_avail_count);
 288	spin_unlock(&mdsc->caps_list_lock);
 289}
 290
 291void ceph_reservation_status(struct ceph_fs_client *fsc,
 292			     int *total, int *avail, int *used, int *reserved,
 293			     int *min)
 294{
 295	struct ceph_mds_client *mdsc = fsc->mdsc;
 296
 297	if (total)
 298		*total = mdsc->caps_total_count;
 299	if (avail)
 300		*avail = mdsc->caps_avail_count;
 301	if (used)
 302		*used = mdsc->caps_use_count;
 303	if (reserved)
 304		*reserved = mdsc->caps_reserve_count;
 305	if (min)
 306		*min = mdsc->caps_min_count;
 307}
 308
 309/*
 310 * Find ceph_cap for given mds, if any.
 311 *
 312 * Called with i_lock held.
 313 */
 314static struct ceph_cap *__get_cap_for_mds(struct ceph_inode_info *ci, int mds)
 315{
 316	struct ceph_cap *cap;
 317	struct rb_node *n = ci->i_caps.rb_node;
 318
 319	while (n) {
 320		cap = rb_entry(n, struct ceph_cap, ci_node);
 321		if (mds < cap->mds)
 322			n = n->rb_left;
 323		else if (mds > cap->mds)
 324			n = n->rb_right;
 325		else
 326			return cap;
 327	}
 328	return NULL;
 329}
 330
 331struct ceph_cap *ceph_get_cap_for_mds(struct ceph_inode_info *ci, int mds)
 332{
 333	struct ceph_cap *cap;
 334
 335	spin_lock(&ci->vfs_inode.i_lock);
 336	cap = __get_cap_for_mds(ci, mds);
 337	spin_unlock(&ci->vfs_inode.i_lock);
 338	return cap;
 339}
 340
 341/*
 342 * Return id of any MDS with a cap, preferably FILE_WR|BUFFER|EXCL, else -1.
 343 */
 344static int __ceph_get_cap_mds(struct ceph_inode_info *ci)
 345{
 346	struct ceph_cap *cap;
 347	int mds = -1;
 348	struct rb_node *p;
 349
 350	/* prefer mds with WR|BUFFER|EXCL caps */
 351	for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
 352		cap = rb_entry(p, struct ceph_cap, ci_node);
 353		mds = cap->mds;
 354		if (cap->issued & (CEPH_CAP_FILE_WR |
 355				   CEPH_CAP_FILE_BUFFER |
 356				   CEPH_CAP_FILE_EXCL))
 357			break;
 358	}
 359	return mds;
 360}
 361
 362int ceph_get_cap_mds(struct inode *inode)
 363{
 364	int mds;
 365	spin_lock(&inode->i_lock);
 366	mds = __ceph_get_cap_mds(ceph_inode(inode));
 367	spin_unlock(&inode->i_lock);
 368	return mds;
 369}
 370
 371/*
 372 * Called under i_lock.
 373 */
 374static void __insert_cap_node(struct ceph_inode_info *ci,
 375			      struct ceph_cap *new)
 376{
 377	struct rb_node **p = &ci->i_caps.rb_node;
 378	struct rb_node *parent = NULL;
 379	struct ceph_cap *cap = NULL;
 380
 381	while (*p) {
 382		parent = *p;
 383		cap = rb_entry(parent, struct ceph_cap, ci_node);
 384		if (new->mds < cap->mds)
 385			p = &(*p)->rb_left;
 386		else if (new->mds > cap->mds)
 387			p = &(*p)->rb_right;
 388		else
 389			BUG();
 390	}
 391
 392	rb_link_node(&new->ci_node, parent, p);
 393	rb_insert_color(&new->ci_node, &ci->i_caps);
 394}
 395
 396/*
 397 * (re)set cap hold timeouts, which control the delayed release
 398 * of unused caps back to the MDS.  Should be called on cap use.
 399 */
 400static void __cap_set_timeouts(struct ceph_mds_client *mdsc,
 401			       struct ceph_inode_info *ci)
 402{
 403	struct ceph_mount_options *ma = mdsc->fsc->mount_options;
 404
 405	ci->i_hold_caps_min = round_jiffies(jiffies +
 406					    ma->caps_wanted_delay_min * HZ);
 407	ci->i_hold_caps_max = round_jiffies(jiffies +
 408					    ma->caps_wanted_delay_max * HZ);
 409	dout("__cap_set_timeouts %p min %lu max %lu\n", &ci->vfs_inode,
 410	     ci->i_hold_caps_min - jiffies, ci->i_hold_caps_max - jiffies);
 411}
 412
 413/*
 414 * (Re)queue cap at the end of the delayed cap release list.
 415 *
 416 * If I_FLUSH is set, leave the inode at the front of the list.
 417 *
 418 * Caller holds i_lock
 419 *    -> we take mdsc->cap_delay_lock
 420 */
 421static void __cap_delay_requeue(struct ceph_mds_client *mdsc,
 422				struct ceph_inode_info *ci)
 423{
 424	__cap_set_timeouts(mdsc, ci);
 425	dout("__cap_delay_requeue %p flags %d at %lu\n", &ci->vfs_inode,
 426	     ci->i_ceph_flags, ci->i_hold_caps_max);
 427	if (!mdsc->stopping) {
 428		spin_lock(&mdsc->cap_delay_lock);
 429		if (!list_empty(&ci->i_cap_delay_list)) {
 430			if (ci->i_ceph_flags & CEPH_I_FLUSH)
 431				goto no_change;
 432			list_del_init(&ci->i_cap_delay_list);
 433		}
 434		list_add_tail(&ci->i_cap_delay_list, &mdsc->cap_delay_list);
 435no_change:
 436		spin_unlock(&mdsc->cap_delay_lock);
 437	}
 438}
 439
 440/*
 441 * Queue an inode for immediate writeback.  Mark inode with I_FLUSH,
 442 * indicating we should send a cap message to flush dirty metadata
 443 * asap, and move to the front of the delayed cap list.
 444 */
 445static void __cap_delay_requeue_front(struct ceph_mds_client *mdsc,
 446				      struct ceph_inode_info *ci)
 447{
 448	dout("__cap_delay_requeue_front %p\n", &ci->vfs_inode);
 449	spin_lock(&mdsc->cap_delay_lock);
 450	ci->i_ceph_flags |= CEPH_I_FLUSH;
 451	if (!list_empty(&ci->i_cap_delay_list))
 452		list_del_init(&ci->i_cap_delay_list);
 453	list_add(&ci->i_cap_delay_list, &mdsc->cap_delay_list);
 454	spin_unlock(&mdsc->cap_delay_lock);
 455}
 456
 457/*
 458 * Cancel delayed work on cap.
 459 *
 460 * Caller must hold i_lock.
 461 */
 462static void __cap_delay_cancel(struct ceph_mds_client *mdsc,
 463			       struct ceph_inode_info *ci)
 464{
 465	dout("__cap_delay_cancel %p\n", &ci->vfs_inode);
 466	if (list_empty(&ci->i_cap_delay_list))
 467		return;
 468	spin_lock(&mdsc->cap_delay_lock);
 469	list_del_init(&ci->i_cap_delay_list);
 470	spin_unlock(&mdsc->cap_delay_lock);
 471}
 472
 473/*
 474 * Common issue checks for add_cap, handle_cap_grant.
 475 */
 476static void __check_cap_issue(struct ceph_inode_info *ci, struct ceph_cap *cap,
 477			      unsigned issued)
 478{
 479	unsigned had = __ceph_caps_issued(ci, NULL);
 480
 481	/*
 482	 * Each time we receive FILE_CACHE anew, we increment
 483	 * i_rdcache_gen.
 484	 */
 485	if ((issued & (CEPH_CAP_FILE_CACHE|CEPH_CAP_FILE_LAZYIO)) &&
 486	    (had & (CEPH_CAP_FILE_CACHE|CEPH_CAP_FILE_LAZYIO)) == 0)
 487		ci->i_rdcache_gen++;
 488
 489	/*
 490	 * if we are newly issued FILE_SHARED, clear I_COMPLETE; we
 491	 * don't know what happened to this directory while we didn't
 492	 * have the cap.
 493	 */
 494	if ((issued & CEPH_CAP_FILE_SHARED) &&
 495	    (had & CEPH_CAP_FILE_SHARED) == 0) {
 496		ci->i_shared_gen++;
 497		if (S_ISDIR(ci->vfs_inode.i_mode)) {
 498			dout(" marking %p NOT complete\n", &ci->vfs_inode);
 499			ci->i_ceph_flags &= ~CEPH_I_COMPLETE;
 500		}
 501	}
 502}
 503
 504/*
 505 * Add a capability under the given MDS session.
 506 *
 507 * Caller should hold session snap_rwsem (read) and s_mutex.
 508 *
 509 * @fmode is the open file mode, if we are opening a file, otherwise
 510 * it is < 0.  (This is so we can atomically add the cap and add an
 511 * open file reference to it.)
 512 */
 513int ceph_add_cap(struct inode *inode,
 514		 struct ceph_mds_session *session, u64 cap_id,
 515		 int fmode, unsigned issued, unsigned wanted,
 516		 unsigned seq, unsigned mseq, u64 realmino, int flags,
 517		 struct ceph_cap_reservation *caps_reservation)
 518{
 519	struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
 520	struct ceph_inode_info *ci = ceph_inode(inode);
 521	struct ceph_cap *new_cap = NULL;
 522	struct ceph_cap *cap;
 523	int mds = session->s_mds;
 524	int actual_wanted;
 525
 526	dout("add_cap %p mds%d cap %llx %s seq %d\n", inode,
 527	     session->s_mds, cap_id, ceph_cap_string(issued), seq);
 528
 529	/*
 530	 * If we are opening the file, include file mode wanted bits
 531	 * in wanted.
 532	 */
 533	if (fmode >= 0)
 534		wanted |= ceph_caps_for_mode(fmode);
 535
 536retry:
 537	spin_lock(&inode->i_lock);
 538	cap = __get_cap_for_mds(ci, mds);
 539	if (!cap) {
 540		if (new_cap) {
 541			cap = new_cap;
 542			new_cap = NULL;
 543		} else {
 544			spin_unlock(&inode->i_lock);
 545			new_cap = get_cap(mdsc, caps_reservation);
 546			if (new_cap == NULL)
 547				return -ENOMEM;
 548			goto retry;
 549		}
 550
 551		cap->issued = 0;
 552		cap->implemented = 0;
 553		cap->mds = mds;
 554		cap->mds_wanted = 0;
 555
 556		cap->ci = ci;
 557		__insert_cap_node(ci, cap);
 558
 559		/* clear out old exporting info?  (i.e. on cap import) */
 560		if (ci->i_cap_exporting_mds == mds) {
 561			ci->i_cap_exporting_issued = 0;
 562			ci->i_cap_exporting_mseq = 0;
 563			ci->i_cap_exporting_mds = -1;
 564		}
 565
 566		/* add to session cap list */
 567		cap->session = session;
 568		spin_lock(&session->s_cap_lock);
 569		list_add_tail(&cap->session_caps, &session->s_caps);
 570		session->s_nr_caps++;
 571		spin_unlock(&session->s_cap_lock);
 572	} else if (new_cap)
 573		ceph_put_cap(mdsc, new_cap);
 574
 575	if (!ci->i_snap_realm) {
 576		/*
 577		 * add this inode to the appropriate snap realm
 578		 */
 579		struct ceph_snap_realm *realm = ceph_lookup_snap_realm(mdsc,
 580							       realmino);
 581		if (realm) {
 582			ceph_get_snap_realm(mdsc, realm);
 583			spin_lock(&realm->inodes_with_caps_lock);
 584			ci->i_snap_realm = realm;
 585			list_add(&ci->i_snap_realm_item,
 586				 &realm->inodes_with_caps);
 587			spin_unlock(&realm->inodes_with_caps_lock);
 588		} else {
 589			pr_err("ceph_add_cap: couldn't find snap realm %llx\n",
 590			       realmino);
 591			WARN_ON(!realm);
 592		}
 593	}
 594
 595	__check_cap_issue(ci, cap, issued);
 596
 597	/*
 598	 * If we are issued caps we don't want, or the mds' wanted
 599	 * value appears to be off, queue a check so we'll release
 600	 * later and/or update the mds wanted value.
 601	 */
 602	actual_wanted = __ceph_caps_wanted(ci);
 603	if ((wanted & ~actual_wanted) ||
 604	    (issued & ~actual_wanted & CEPH_CAP_ANY_WR)) {
 605		dout(" issued %s, mds wanted %s, actual %s, queueing\n",
 606		     ceph_cap_string(issued), ceph_cap_string(wanted),
 607		     ceph_cap_string(actual_wanted));
 608		__cap_delay_requeue(mdsc, ci);
 609	}
 610
 611	if (flags & CEPH_CAP_FLAG_AUTH)
 612		ci->i_auth_cap = cap;
 613	else if (ci->i_auth_cap == cap)
 614		ci->i_auth_cap = NULL;
 615
 616	dout("add_cap inode %p (%llx.%llx) cap %p %s now %s seq %d mds%d\n",
 617	     inode, ceph_vinop(inode), cap, ceph_cap_string(issued),
 618	     ceph_cap_string(issued|cap->issued), seq, mds);
 619	cap->cap_id = cap_id;
 620	cap->issued = issued;
 621	cap->implemented |= issued;
 622	cap->mds_wanted |= wanted;
 623	cap->seq = seq;
 624	cap->issue_seq = seq;
 625	cap->mseq = mseq;
 626	cap->cap_gen = session->s_cap_gen;
 627
 628	if (fmode >= 0)
 629		__ceph_get_fmode(ci, fmode);
 630	spin_unlock(&inode->i_lock);
 631	wake_up_all(&ci->i_cap_wq);
 632	return 0;
 633}
 634
 635/*
 636 * Return true if cap has not timed out and belongs to the current
 637 * generation of the MDS session (i.e. has not gone 'stale' due to
 638 * us losing touch with the mds).
 639 */
 640static int __cap_is_valid(struct ceph_cap *cap)
 641{
 642	unsigned long ttl;
 643	u32 gen;
 644
 645	spin_lock(&cap->session->s_cap_lock);
 646	gen = cap->session->s_cap_gen;
 647	ttl = cap->session->s_cap_ttl;
 648	spin_unlock(&cap->session->s_cap_lock);
 649
 650	if (cap->cap_gen < gen || time_after_eq(jiffies, ttl)) {
 651		dout("__cap_is_valid %p cap %p issued %s "
 652		     "but STALE (gen %u vs %u)\n", &cap->ci->vfs_inode,
 653		     cap, ceph_cap_string(cap->issued), cap->cap_gen, gen);
 654		return 0;
 655	}
 656
 657	return 1;
 658}
 659
 660/*
 661 * Return set of valid cap bits issued to us.  Note that caps time
 662 * out, and may be invalidated in bulk if the client session times out
 663 * and session->s_cap_gen is bumped.
 664 */
 665int __ceph_caps_issued(struct ceph_inode_info *ci, int *implemented)
 666{
 667	int have = ci->i_snap_caps | ci->i_cap_exporting_issued;
 668	struct ceph_cap *cap;
 669	struct rb_node *p;
 670
 671	if (implemented)
 672		*implemented = 0;
 673	for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
 674		cap = rb_entry(p, struct ceph_cap, ci_node);
 675		if (!__cap_is_valid(cap))
 676			continue;
 677		dout("__ceph_caps_issued %p cap %p issued %s\n",
 678		     &ci->vfs_inode, cap, ceph_cap_string(cap->issued));
 679		have |= cap->issued;
 680		if (implemented)
 681			*implemented |= cap->implemented;
 682	}
 683	return have;
 684}
 685
 686/*
 687 * Get cap bits issued by caps other than @ocap
 688 */
 689int __ceph_caps_issued_other(struct ceph_inode_info *ci, struct ceph_cap *ocap)
 690{
 691	int have = ci->i_snap_caps;
 692	struct ceph_cap *cap;
 693	struct rb_node *p;
 694
 695	for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
 696		cap = rb_entry(p, struct ceph_cap, ci_node);
 697		if (cap == ocap)
 698			continue;
 699		if (!__cap_is_valid(cap))
 700			continue;
 701		have |= cap->issued;
 702	}
 703	return have;
 704}
 705
 706/*
 707 * Move a cap to the end of the LRU (oldest caps at list head, newest
 708 * at list tail).
 709 */
 710static void __touch_cap(struct ceph_cap *cap)
 711{
 712	struct ceph_mds_session *s = cap->session;
 713
 714	spin_lock(&s->s_cap_lock);
 715	if (s->s_cap_iterator == NULL) {
 716		dout("__touch_cap %p cap %p mds%d\n", &cap->ci->vfs_inode, cap,
 717		     s->s_mds);
 718		list_move_tail(&cap->session_caps, &s->s_caps);
 719	} else {
 720		dout("__touch_cap %p cap %p mds%d NOP, iterating over caps\n",
 721		     &cap->ci->vfs_inode, cap, s->s_mds);
 722	}
 723	spin_unlock(&s->s_cap_lock);
 724}
 725
 726/*
 727 * Check if we hold the given mask.  If so, move the cap(s) to the
 728 * front of their respective LRUs.  (This is the preferred way for
 729 * callers to check for caps they want.)
 730 */
 731int __ceph_caps_issued_mask(struct ceph_inode_info *ci, int mask, int touch)
 732{
 733	struct ceph_cap *cap;
 734	struct rb_node *p;
 735	int have = ci->i_snap_caps;
 736
 737	if ((have & mask) == mask) {
 738		dout("__ceph_caps_issued_mask %p snap issued %s"
 739		     " (mask %s)\n", &ci->vfs_inode,
 740		     ceph_cap_string(have),
 741		     ceph_cap_string(mask));
 742		return 1;
 743	}
 744
 745	for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
 746		cap = rb_entry(p, struct ceph_cap, ci_node);
 747		if (!__cap_is_valid(cap))
 748			continue;
 749		if ((cap->issued & mask) == mask) {
 750			dout("__ceph_caps_issued_mask %p cap %p issued %s"
 751			     " (mask %s)\n", &ci->vfs_inode, cap,
 752			     ceph_cap_string(cap->issued),
 753			     ceph_cap_string(mask));
 754			if (touch)
 755				__touch_cap(cap);
 756			return 1;
 757		}
 758
 759		/* does a combination of caps satisfy mask? */
 760		have |= cap->issued;
 761		if ((have & mask) == mask) {
 762			dout("__ceph_caps_issued_mask %p combo issued %s"
 763			     " (mask %s)\n", &ci->vfs_inode,
 764			     ceph_cap_string(cap->issued),
 765			     ceph_cap_string(mask));
 766			if (touch) {
 767				struct rb_node *q;
 768
 769				/* touch this + preceding caps */
 770				__touch_cap(cap);
 771				for (q = rb_first(&ci->i_caps); q != p;
 772				     q = rb_next(q)) {
 773					cap = rb_entry(q, struct ceph_cap,
 774						       ci_node);
 775					if (!__cap_is_valid(cap))
 776						continue;
 777					__touch_cap(cap);
 778				}
 779			}
 780			return 1;
 781		}
 782	}
 783
 784	return 0;
 785}
 786
 787/*
 788 * Return true if mask caps are currently being revoked by an MDS.
 789 */
 790int ceph_caps_revoking(struct ceph_inode_info *ci, int mask)
 791{
 792	struct inode *inode = &ci->vfs_inode;
 793	struct ceph_cap *cap;
 794	struct rb_node *p;
 795	int ret = 0;
 796
 797	spin_lock(&inode->i_lock);
 798	for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
 799		cap = rb_entry(p, struct ceph_cap, ci_node);
 800		if (__cap_is_valid(cap) &&
 801		    (cap->implemented & ~cap->issued & mask)) {
 802			ret = 1;
 803			break;
 804		}
 805	}
 806	spin_unlock(&inode->i_lock);
 807	dout("ceph_caps_revoking %p %s = %d\n", inode,
 808	     ceph_cap_string(mask), ret);
 809	return ret;
 810}
 811
 812int __ceph_caps_used(struct ceph_inode_info *ci)
 813{
 814	int used = 0;
 815	if (ci->i_pin_ref)
 816		used |= CEPH_CAP_PIN;
 817	if (ci->i_rd_ref)
 818		used |= CEPH_CAP_FILE_RD;
 819	if (ci->i_rdcache_ref || ci->vfs_inode.i_data.nrpages)
 820		used |= CEPH_CAP_FILE_CACHE;
 821	if (ci->i_wr_ref)
 822		used |= CEPH_CAP_FILE_WR;
 823	if (ci->i_wb_ref || ci->i_wrbuffer_ref)
 824		used |= CEPH_CAP_FILE_BUFFER;
 825	return used;
 826}
 827
 828/*
 829 * wanted, by virtue of open file modes
 830 */
 831int __ceph_caps_file_wanted(struct ceph_inode_info *ci)
 832{
 833	int want = 0;
 834	int mode;
 835	for (mode = 0; mode < CEPH_FILE_MODE_NUM; mode++)
 836		if (ci->i_nr_by_mode[mode])
 837			want |= ceph_caps_for_mode(mode);
 838	return want;
 839}
 840
 841/*
 842 * Return caps we have registered with the MDS(s) as 'wanted'.
 843 */
 844int __ceph_caps_mds_wanted(struct ceph_inode_info *ci)
 845{
 846	struct ceph_cap *cap;
 847	struct rb_node *p;
 848	int mds_wanted = 0;
 849
 850	for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
 851		cap = rb_entry(p, struct ceph_cap, ci_node);
 852		if (!__cap_is_valid(cap))
 853			continue;
 854		mds_wanted |= cap->mds_wanted;
 855	}
 856	return mds_wanted;
 857}
 858
 859/*
 860 * called under i_lock
 861 */
 862static int __ceph_is_any_caps(struct ceph_inode_info *ci)
 863{
 864	return !RB_EMPTY_ROOT(&ci->i_caps) || ci->i_cap_exporting_mds >= 0;
 865}
 866
 867/*
 868 * Remove a cap.  Take steps to deal with a racing iterate_session_caps.
 869 *
 870 * caller should hold i_lock.
 871 * caller will not hold session s_mutex if called from destroy_inode.
 872 */
 873void __ceph_remove_cap(struct ceph_cap *cap)
 874{
 875	struct ceph_mds_session *session = cap->session;
 876	struct ceph_inode_info *ci = cap->ci;
 877	struct ceph_mds_client *mdsc =
 878		ceph_sb_to_client(ci->vfs_inode.i_sb)->mdsc;
 879	int removed = 0;
 880
 881	dout("__ceph_remove_cap %p from %p\n", cap, &ci->vfs_inode);
 882
 883	/* remove from session list */
 884	spin_lock(&session->s_cap_lock);
 885	if (session->s_cap_iterator == cap) {
 886		/* not yet, we are iterating over this very cap */
 887		dout("__ceph_remove_cap  delaying %p removal from session %p\n",
 888		     cap, cap->session);
 889	} else {
 890		list_del_init(&cap->session_caps);
 891		session->s_nr_caps--;
 892		cap->session = NULL;
 893		removed = 1;
 894	}
 895	/* protect backpointer with s_cap_lock: see iterate_session_caps */
 896	cap->ci = NULL;
 897	spin_unlock(&session->s_cap_lock);
 898
 899	/* remove from inode list */
 900	rb_erase(&cap->ci_node, &ci->i_caps);
 901	if (ci->i_auth_cap == cap)
 902		ci->i_auth_cap = NULL;
 903
 904	if (removed)
 905		ceph_put_cap(mdsc, cap);
 906
 907	if (!__ceph_is_any_caps(ci) && ci->i_snap_realm) {
 908		struct ceph_snap_realm *realm = ci->i_snap_realm;
 909		spin_lock(&realm->inodes_with_caps_lock);
 910		list_del_init(&ci->i_snap_realm_item);
 911		ci->i_snap_realm_counter++;
 912		ci->i_snap_realm = NULL;
 913		spin_unlock(&realm->inodes_with_caps_lock);
 914		ceph_put_snap_realm(mdsc, realm);
 915	}
 916	if (!__ceph_is_any_real_caps(ci))
 917		__cap_delay_cancel(mdsc, ci);
 918}
 919
 920/*
 921 * Build and send a cap message to the given MDS.
 922 *
 923 * Caller should be holding s_mutex.
 924 */
 925static int send_cap_msg(struct ceph_mds_session *session,
 926			u64 ino, u64 cid, int op,
 927			int caps, int wanted, int dirty,
 928			u32 seq, u64 flush_tid, u32 issue_seq, u32 mseq,
 929			u64 size, u64 max_size,
 930			struct timespec *mtime, struct timespec *atime,
 931			u64 time_warp_seq,
 932			uid_t uid, gid_t gid, mode_t mode,
 933			u64 xattr_version,
 934			struct ceph_buffer *xattrs_buf,
 935			u64 follows)
 936{
 937	struct ceph_mds_caps *fc;
 938	struct ceph_msg *msg;
 939
 940	dout("send_cap_msg %s %llx %llx caps %s wanted %s dirty %s"
 941	     " seq %u/%u mseq %u follows %lld size %llu/%llu"
 942	     " xattr_ver %llu xattr_len %d\n", ceph_cap_op_name(op),
 943	     cid, ino, ceph_cap_string(caps), ceph_cap_string(wanted),
 944	     ceph_cap_string(dirty),
 945	     seq, issue_seq, mseq, follows, size, max_size,
 946	     xattr_version, xattrs_buf ? (int)xattrs_buf->vec.iov_len : 0);
 947
 948	msg = ceph_msg_new(CEPH_MSG_CLIENT_CAPS, sizeof(*fc), GFP_NOFS);
 949	if (!msg)
 950		return -ENOMEM;
 951
 952	msg->hdr.tid = cpu_to_le64(flush_tid);
 953
 954	fc = msg->front.iov_base;
 955	memset(fc, 0, sizeof(*fc));
 956
 957	fc->cap_id = cpu_to_le64(cid);
 958	fc->op = cpu_to_le32(op);
 959	fc->seq = cpu_to_le32(seq);
 960	fc->issue_seq = cpu_to_le32(issue_seq);
 961	fc->migrate_seq = cpu_to_le32(mseq);
 962	fc->caps = cpu_to_le32(caps);
 963	fc->wanted = cpu_to_le32(wanted);
 964	fc->dirty = cpu_to_le32(dirty);
 965	fc->ino = cpu_to_le64(ino);
 966	fc->snap_follows = cpu_to_le64(follows);
 967
 968	fc->size = cpu_to_le64(size);
 969	fc->max_size = cpu_to_le64(max_size);
 970	if (mtime)
 971		ceph_encode_timespec(&fc->mtime, mtime);
 972	if (atime)
 973		ceph_encode_timespec(&fc->atime, atime);
 974	fc->time_warp_seq = cpu_to_le32(time_warp_seq);
 975
 976	fc->uid = cpu_to_le32(uid);
 977	fc->gid = cpu_to_le32(gid);
 978	fc->mode = cpu_to_le32(mode);
 979
 980	fc->xattr_version = cpu_to_le64(xattr_version);
 981	if (xattrs_buf) {
 982		msg->middle = ceph_buffer_get(xattrs_buf);
 983		fc->xattr_len = cpu_to_le32(xattrs_buf->vec.iov_len);
 984		msg->hdr.middle_len = cpu_to_le32(xattrs_buf->vec.iov_len);
 985	}
 986
 987	ceph_con_send(&session->s_con, msg);
 988	return 0;
 989}
 990
 991static void __queue_cap_release(struct ceph_mds_session *session,
 992				u64 ino, u64 cap_id, u32 migrate_seq,
 993				u32 issue_seq)
 994{
 995	struct ceph_msg *msg;
 996	struct ceph_mds_cap_release *head;
 997	struct ceph_mds_cap_item *item;
 998
 999	spin_lock(&session->s_cap_lock);
1000	BUG_ON(!session->s_num_cap_releases);
1001	msg = list_first_entry(&session->s_cap_releases,
1002			       struct ceph_msg, list_head);
1003
1004	dout(" adding %llx release to mds%d msg %p (%d left)\n",
1005	     ino, session->s_mds, msg, session->s_num_cap_releases);
1006
1007	BUG_ON(msg->front.iov_len + sizeof(*item) > PAGE_CACHE_SIZE);
1008	head = msg->front.iov_base;
1009	head->num = cpu_to_le32(le32_to_cpu(head->num) + 1);
1010	item = msg->front.iov_base + msg->front.iov_len;
1011	item->ino = cpu_to_le64(ino);
1012	item->cap_id = cpu_to_le64(cap_id);
1013	item->migrate_seq = cpu_to_le32(migrate_seq);
1014	item->seq = cpu_to_le32(issue_seq);
1015
1016	session->s_num_cap_releases--;
1017
1018	msg->front.iov_len += sizeof(*item);
1019	if (le32_to_cpu(head->num) == CEPH_CAPS_PER_RELEASE) {
1020		dout(" release msg %p full\n", msg);
1021		list_move_tail(&msg->list_head, &session->s_cap_releases_done);
1022	} else {
1023		dout(" release msg %p at %d/%d (%d)\n", msg,
1024		     (int)le32_to_cpu(head->num),
1025		     (int)CEPH_CAPS_PER_RELEASE,
1026		     (int)msg->front.iov_len);
1027	}
1028	spin_unlock(&session->s_cap_lock);
1029}
1030
1031/*
1032 * Queue cap releases when an inode is dropped from our cache.  Since
1033 * inode is about to be destroyed, there is no need for i_lock.
1034 */
1035void ceph_queue_caps_release(struct inode *inode)
1036{
1037	struct ceph_inode_info *ci = ceph_inode(inode);
1038	struct rb_node *p;
1039
1040	p = rb_first(&ci->i_caps);
1041	while (p) {
1042		struct ceph_cap *cap = rb_entry(p, struct ceph_cap, ci_node);
1043		struct ceph_mds_session *session = cap->session;
1044
1045		__queue_cap_release(session, ceph_ino(inode), cap->cap_id,
1046				    cap->mseq, cap->issue_seq);
1047		p = rb_next(p);
1048		__ceph_remove_cap(cap);
1049	}
1050}
1051
1052/*
1053 * Send a cap msg on the given inode.  Update our caps state, then
1054 * drop i_lock and send the message.
1055 *
1056 * Make note of max_size reported/requested from mds, revoked caps
1057 * that have now been implemented.
1058 *
1059 * Make half-hearted attempt ot to invalidate page cache if we are
1060 * dropping RDCACHE.  Note that this will leave behind locked pages
1061 * that we'll then need to deal with elsewhere.
1062 *
1063 * Return non-zero if delayed release, or we experienced an error
1064 * such that the caller should requeue + retry later.
1065 *
1066 * called with i_lock, then drops it.
1067 * caller should hold snap_rwsem (read), s_mutex.
1068 */
1069static int __send_cap(struct ceph_mds_client *mdsc, struct ceph_cap *cap,
1070		      int op, int used, int want, int retain, int flushing,
1071		      unsigned *pflush_tid)
1072	__releases(cap->ci->vfs_inode->i_lock)
1073{
1074	struct ceph_inode_info *ci = cap->ci;
1075	struct inode *inode = &ci->vfs_inode;
1076	u64 cap_id = cap->cap_id;
1077	int held, revoking, dropping, keep;
1078	u64 seq, issue_seq, mseq, time_warp_seq, follows;
1079	u64 size, max_size;
1080	struct timespec mtime, atime;
1081	int wake = 0;
1082	mode_t mode;
1083	uid_t uid;
1084	gid_t gid;
1085	struct ceph_mds_session *session;
1086	u64 xattr_version = 0;
1087	struct ceph_buffer *xattr_blob = NULL;
1088	int delayed = 0;
1089	u64 flush_tid = 0;
1090	int i;
1091	int ret;
1092
1093	held = cap->issued | cap->implemented;
1094	revoking = cap->implemented & ~cap->issued;
1095	retain &= ~revoking;
1096	dropping = cap->issued & ~retain;
1097
1098	dout("__send_cap %p cap %p session %p %s -> %s (revoking %s)\n",
1099	     inode, cap, cap->session,
1100	     ceph_cap_string(held), ceph_cap_string(held & retain),
1101	     ceph_cap_string(revoking));
1102	BUG_ON((retain & CEPH_CAP_PIN) == 0);
1103
1104	session = cap->session;
1105
1106	/* don't release wanted unless we've waited a bit. */
1107	if ((ci->i_ceph_flags & CEPH_I_NODELAY) == 0 &&
1108	    time_before(jiffies, ci->i_hold_caps_min)) {
1109		dout(" delaying issued %s -> %s, wanted %s -> %s on send\n",
1110		     ceph_cap_string(cap->issued),
1111		     ceph_cap_string(cap->issued & retain),
1112		     ceph_cap_string(cap->mds_wanted),
1113		     ceph_cap_string(want));
1114		want |= cap->mds_wanted;
1115		retain |= cap->issued;
1116		delayed = 1;
1117	}
1118	ci->i_ceph_flags &= ~(CEPH_I_NODELAY | CEPH_I_FLUSH);
1119
1120	cap->issued &= retain;  /* drop bits we don't want */
1121	if (cap->implemented & ~cap->issued) {
1122		/*
1123		 * Wake up any waiters on wanted -> needed transition.
1124		 * This is due to the weird transition from buffered
1125		 * to sync IO... we need to flush dirty pages _before_
1126		 * allowing sync writes to avoid reordering.
1127		 */
1128		wake = 1;
1129	}
1130	cap->implemented &= cap->issued | used;
1131	cap->mds_wanted = want;
1132
1133	if (flushing) {
1134		/*
1135		 * assign a tid for flush operations so we can avoid
1136		 * flush1 -> dirty1 -> flush2 -> flushack1 -> mark
1137		 * clean type races.  track latest tid for every bit
1138		 * so we can handle flush AxFw, flush Fw, and have the
1139		 * first ack clean Ax.
1140		 */
1141		flush_tid = ++ci->i_cap_flush_last_tid;
1142		if (pflush_tid)
1143			*pflush_tid = flush_tid;
1144		dout(" cap_flush_tid %d\n", (int)flush_tid);
1145		for (i = 0; i < CEPH_CAP_BITS; i++)
1146			if (flushing & (1 << i))
1147				ci->i_cap_flush_tid[i] = flush_tid;
1148
1149		follows = ci->i_head_snapc->seq;
1150	} else {
1151		follows = 0;
1152	}
1153
1154	keep = cap->implemented;
1155	seq = cap->seq;
1156	issue_seq = cap->issue_seq;
1157	mseq = cap->mseq;
1158	size = inode->i_size;
1159	ci->i_reported_size = size;
1160	max_size = ci->i_wanted_max_size;
1161	ci->i_requested_max_size = max_size;
1162	mtime = inode->i_mtime;
1163	atime = inode->i_atime;
1164	time_warp_seq = ci->i_time_warp_seq;
1165	uid = inode->i_uid;
1166	gid = inode->i_gid;
1167	mode = inode->i_mode;
1168
1169	if (flushing & CEPH_CAP_XATTR_EXCL) {
1170		__ceph_build_xattrs_blob(ci);
1171		xattr_blob = ci->i_xattrs.blob;
1172		xattr_version = ci->i_xattrs.version;
1173	}
1174
1175	spin_unlock(&inode->i_lock);
1176
1177	ret = send_cap_msg(session, ceph_vino(inode).ino, cap_id,
1178		op, keep, want, flushing, seq, flush_tid, issue_seq, mseq,
1179		size, max_size, &mtime, &atime, time_warp_seq,
1180		uid, gid, mode, xattr_version, xattr_blob,
1181		follows);
1182	if (ret < 0) {
1183		dout("error sending cap msg, must requeue %p\n", inode);
1184		delayed = 1;
1185	}
1186
1187	if (wake)
1188		wake_up_all(&ci->i_cap_wq);
1189
1190	return delayed;
1191}
1192
1193/*
1194 * When a snapshot is taken, clients accumulate dirty metadata on
1195 * inodes with capabilities in ceph_cap_snaps to describe the file
1196 * state at the time the snapshot was taken.  This must be flushed
1197 * asynchronously back to the MDS once sync writes complete and dirty
1198 * data is written out.
1199 *
1200 * Unless @again is true, skip cap_snaps that were already sent to
1201 * the MDS (i.e., during this session).
1202 *
1203 * Called under i_lock.  Takes s_mutex as needed.
1204 */
1205void __ceph_flush_snaps(struct ceph_inode_info *ci,
1206			struct ceph_mds_session **psession,
1207			int again)
1208		__releases(ci->vfs_inode->i_lock)
1209		__acquires(ci->vfs_inode->i_lock)
1210{
1211	struct inode *inode = &ci->vfs_inode;
1212	int mds;
1213	struct ceph_cap_snap *capsnap;
1214	u32 mseq;
1215	struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
1216	struct ceph_mds_session *session = NULL; /* if session != NULL, we hold
1217						    session->s_mutex */
1218	u64 next_follows = 0;  /* keep track of how far we've gotten through the
1219			     i_cap_snaps list, and skip these entries next time
1220			     around to avoid an infinite loop */
1221
1222	if (psession)
1223		session = *psession;
1224
1225	dout("__flush_snaps %p\n", inode);
1226retry:
1227	list_for_each_entry(capsnap, &ci->i_cap_snaps, ci_item) {
1228		/* avoid an infiniute loop after retry */
1229		if (capsnap->follows < next_follows)
1230			continue;
1231		/*
1232		 * we need to wait for sync writes to complete and for dirty
1233		 * pages to be written out.
1234		 */
1235		if (capsnap->dirty_pages || capsnap->writing)
1236			break;
1237
1238		/*
1239		 * if cap writeback already occurred, we should have dropped
1240		 * the capsnap in ceph_put_wrbuffer_cap_refs.
1241		 */
1242		BUG_ON(capsnap->dirty == 0);
1243
1244		/* pick mds, take s_mutex */
1245		if (ci->i_auth_cap == NULL) {
1246			dout("no auth cap (migrating?), doing nothing\n");
1247			goto out;
1248		}
1249
1250		/* only flush each capsnap once */
1251		if (!again && !list_empty(&capsnap->flushing_item)) {
1252			dout("already flushed %p, skipping\n", capsnap);
1253			continue;
1254		}
1255
1256		mds = ci->i_auth_cap->session->s_mds;
1257		mseq = ci->i_auth_cap->mseq;
1258
1259		if (session && session->s_mds != mds) {
1260			dout("oops, wrong session %p mutex\n", session);
1261			mutex_unlock(&session->s_mutex);
1262			ceph_put_mds_session(session);
1263			session = NULL;
1264		}
1265		if (!session) {
1266			spin_unlock(&inode->i_lock);
1267			mutex_lock(&mdsc->mutex);
1268			session = __ceph_lookup_mds_session(mdsc, mds);
1269			mutex_unlock(&mdsc->mutex);
1270			if (session) {
1271				dout("inverting session/ino locks on %p\n",
1272				     session);
1273				mutex_lock(&session->s_mutex);
1274			}
1275			/*
1276			 * if session == NULL, we raced against a cap
1277			 * deletion or migration.  retry, and we'll
1278			 * get a better @mds value next time.
1279			 */
1280			spin_lock(&inode->i_lock);
1281			goto retry;
1282		}
1283
1284		capsnap->flush_tid = ++ci->i_cap_flush_last_tid;
1285		atomic_inc(&capsnap->nref);
1286		if (!list_empty(&capsnap->flushing_item))
1287			list_del_init(&capsnap->flushing_item);
1288		list_add_tail(&capsnap->flushing_item,
1289			      &session->s_cap_snaps_flushing);
1290		spin_unlock(&inode->i_lock);
1291
1292		dout("flush_snaps %p cap_snap %p follows %lld tid %llu\n",
1293		     inode, capsnap, capsnap->follows, capsnap->flush_tid);
1294		send_cap_msg(session, ceph_vino(inode).ino, 0,
1295			     CEPH_CAP_OP_FLUSHSNAP, capsnap->issued, 0,
1296			     capsnap->dirty, 0, capsnap->flush_tid, 0, mseq,
1297			     capsnap->size, 0,
1298			     &capsnap->mtime, &capsnap->atime,
1299			     capsnap->time_warp_seq,
1300			     capsnap->uid, capsnap->gid, capsnap->mode,
1301			     capsnap->xattr_version, capsnap->xattr_blob,
1302			     capsnap->follows);
1303
1304		next_follows = capsnap->follows + 1;
1305		ceph_put_cap_snap(capsnap);
1306
1307		spin_lock(&inode->i_lock);
1308		goto retry;
1309	}
1310
1311	/* we flushed them all; remove this inode from the queue */
1312	spin_lock(&mdsc->snap_flush_lock);
1313	list_del_init(&ci->i_snap_flush_item);
1314	spin_unlock(&mdsc->snap_flush_lock);
1315
1316out:
1317	if (psession)
1318		*psession = session;
1319	else if (session) {
1320		mutex_unlock(&session->s_mutex);
1321		ceph_put_mds_session(session);
1322	}
1323}
1324
1325static void ceph_flush_snaps(struct ceph_inode_info *ci)
1326{
1327	struct inode *inode = &ci->vfs_inode;
1328
1329	spin_lock(&inode->i_lock);
1330	__ceph_flush_snaps(ci, NULL, 0);
1331	spin_unlock(&inode->i_lock);
1332}
1333
1334/*
1335 * Mark caps dirty.  If inode is newly dirty, return the dirty flags.
1336 * Caller is then responsible for calling __mark_inode_dirty with the
1337 * returned flags value.
1338 */
1339int __ceph_mark_dirty_caps(struct ceph_inode_info *ci, int mask)
1340{
1341	struct ceph_mds_client *mdsc =
1342		ceph_sb_to_client(ci->vfs_inode.i_sb)->mdsc;
1343	struct inode *inode = &ci->vfs_inode;
1344	int was = ci->i_dirty_caps;
1345	int dirty = 0;
1346
1347	dout("__mark_dirty_caps %p %s dirty %s -> %s\n", &ci->vfs_inode,
1348	     ceph_cap_string(mask), ceph_cap_string(was),
1349	     ceph_cap_string(was | mask));
1350	ci->i_dirty_caps |= mask;
1351	if (was == 0) {
1352		if (!ci->i_head_snapc)
1353			ci->i_head_snapc = ceph_get_snap_context(
1354				ci->i_snap_realm->cached_context);
1355		dout(" inode %p now dirty snapc %p\n", &ci->vfs_inode,
1356			ci->i_head_snapc);
1357		BUG_ON(!list_empty(&ci->i_dirty_item));
1358		spin_lock(&mdsc->cap_dirty_lock);
1359		list_add(&ci->i_dirty_item, &mdsc->cap_dirty);
1360		spin_unlock(&mdsc->cap_dirty_lock);
1361		if (ci->i_flushing_caps == 0) {
1362			ihold(inode);
1363			dirty |= I_DIRTY_SYNC;
1364		}
1365	}
1366	BUG_ON(list_empty(&ci->i_dirty_item));
1367	if (((was | ci->i_flushing_caps) & CEPH_CAP_FILE_BUFFER) &&
1368	    (mask & CEPH_CAP_FILE_BUFFER))
1369		dirty |= I_DIRTY_DATASYNC;
1370	__cap_delay_requeue(mdsc, ci);
1371	return dirty;
1372}
1373
1374/*
1375 * Add dirty inode to the flushing list.  Assigned a seq number so we
1376 * can wait for caps to flush without starving.
1377 *
1378 * Called under i_lock.
1379 */
1380static int __mark_caps_flushing(struct inode *inode,
1381				 struct ceph_mds_session *session)
1382{
1383	struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
1384	struct ceph_inode_info *ci = ceph_inode(inode);
1385	int flushing;
1386
1387	BUG_ON(ci->i_dirty_caps == 0);
1388	BUG_ON(list_empty(&ci->i_dirty_item));
1389
1390	flushing = ci->i_dirty_caps;
1391	dout("__mark_caps_flushing flushing %s, flushing_caps %s -> %s\n",
1392	     ceph_cap_string(flushing),
1393	     ceph_cap_string(ci->i_flushing_caps),
1394	     ceph_cap_string(ci->i_flushing_caps | flushing));
1395	ci->i_flushing_caps |= flushing;
1396	ci->i_dirty_caps = 0;
1397	dout(" inode %p now !dirty\n", inode);
1398
1399	spin_lock(&mdsc->cap_dirty_lock);
1400	list_del_init(&ci->i_dirty_item);
1401
1402	ci->i_cap_flush_seq = ++mdsc->cap_flush_seq;
1403	if (list_empty(&ci->i_flushing_item)) {
1404		list_add_tail(&ci->i_flushing_item, &session->s_cap_flushing);
1405		mdsc->num_cap_flushing++;
1406		dout(" inode %p now flushing seq %lld\n", inode,
1407		     ci->i_cap_flush_seq);
1408	} else {
1409		list_move_tail(&ci->i_flushing_item, &session->s_cap_flushing);
1410		dout(" inode %p now flushing (more) seq %lld\n", inode,
1411		     ci->i_cap_flush_seq);
1412	}
1413	spin_unlock(&mdsc->cap_dirty_lock);
1414
1415	return flushing;
1416}
1417
1418/*
1419 * try to invalidate mapping pages without blocking.
1420 */
1421static int try_nonblocking_invalidate(struct inode *inode)
1422{
1423	struct ceph_inode_info *ci = ceph_inode(inode);
1424	u32 invalidating_gen = ci->i_rdcache_gen;
1425
1426	spin_unlock(&inode->i_lock);
1427	invalidate_mapping_pages(&inode->i_data, 0, -1);
1428	spin_lock(&inode->i_lock);
1429
1430	if (inode->i_data.nrpages == 0 &&
1431	    invalidating_gen == ci->i_rdcache_gen) {
1432		/* success. */
1433		dout("try_nonblocking_invalidate %p success\n", inode);
1434		/* save any racing async invalidate some trouble */
1435		ci->i_rdcache_revoking = ci->i_rdcache_gen - 1;
1436		return 0;
1437	}
1438	dout("try_nonblocking_invalidate %p failed\n", inode);
1439	return -1;
1440}
1441
1442/*
1443 * Swiss army knife function to examine currently used and wanted
1444 * versus held caps.  Release, flush, ack revoked caps to mds as
1445 * appropriate.
1446 *
1447 *  CHECK_CAPS_NODELAY - caller is delayed work and we should not delay
1448 *    cap release further.
1449 *  CHECK_CAPS_AUTHONLY - we should only check the auth cap
1450 *  CHECK_CAPS_FLUSH - we should flush any dirty caps immediately, without
1451 *    further delay.
1452 */
1453void ceph_check_caps(struct ceph_inode_info *ci, int flags,
1454		     struct ceph_mds_session *session)
1455{
1456	struct ceph_fs_client *fsc = ceph_inode_to_client(&ci->vfs_inode);
1457	struct ceph_mds_client *mdsc = fsc->mdsc;
1458	struct inode *inode = &ci->vfs_inode;
1459	struct ceph_cap *cap;
1460	int file_wanted, used;
1461	int took_snap_rwsem = 0;             /* true if mdsc->snap_rwsem held */
1462	int issued, implemented, want, retain, revoking, flushing = 0;
1463	int mds = -1;   /* keep track of how far we've gone through i_caps list
1464			   to avoid an infinite loop on retry */
1465	struct rb_node *p;
1466	int tried_invalidate = 0;
1467	int delayed = 0, sent = 0, force_requeue = 0, num;
1468	int queue_invalidate = 0;
1469	int is_delayed = flags & CHECK_CAPS_NODELAY;
1470
1471	/* if we are unmounting, flush any unused caps immediately. */
1472	if (mdsc->stopping)
1473		is_delayed = 1;
1474
1475	spin_lock(&inode->i_lock);
1476
1477	if (ci->i_ceph_flags & CEPH_I_FLUSH)
1478		flags |= CHECK_CAPS_FLUSH;
1479
1480	/* flush snaps first time around only */
1481	if (!list_empty(&ci->i_cap_snaps))
1482		__ceph_flush_snaps(ci, &session, 0);
1483	goto retry_locked;
1484retry:
1485	spin_lock(&inode->i_lock);
1486retry_locked:
1487	file_wanted = __ceph_caps_file_wanted(ci);
1488	used = __ceph_caps_used(ci);
1489	want = file_wanted | used;
1490	issued = __ceph_caps_issued(ci, &implemented);
1491	revoking = implemented & ~issued;
1492
1493	retain = want | CEPH_CAP_PIN;
1494	if (!mdsc->stopping && inode->i_nlink > 0) {
1495		if (want) {
1496			retain |= CEPH_CAP_ANY;       /* be greedy */
1497		} else {
1498			retain |= CEPH_CAP_ANY_SHARED;
1499			/*
1500			 * keep RD only if we didn't have the file open RW,
1501			 * because then the mds would revoke it anyway to
1502			 * journal max_size=0.
1503			 */
1504			if (ci->i_max_size == 0)
1505				retain |= CEPH_CAP_ANY_RD;
1506		}
1507	}
1508
1509	dout("check_caps %p file_want %s used %s dirty %s flushing %s"
1510	     " issued %s revoking %s retain %s %s%s%s\n", inode,
1511	     ceph_cap_string(file_wanted),
1512	     ceph_cap_string(used), ceph_cap_string(ci->i_dirty_caps),
1513	     ceph_cap_string(ci->i_flushing_caps),
1514	     ceph_cap_string(issued), ceph_cap_string(revoking),
1515	     ceph_cap_string(retain),
1516	     (flags & CHECK_CAPS_AUTHONLY) ? " AUTHONLY" : "",
1517	     (flags & CHECK_CAPS_NODELAY) ? " NODELAY" : "",
1518	     (flags & CHECK_CAPS_FLUSH) ? " FLUSH" : "");
1519
1520	/*
1521	 * If we no longer need to hold onto old our caps, and we may
1522	 * have cached pages, but don't want them, then try to invalidate.
1523	 * If we fail, it's because pages are locked.... try again later.
1524	 */
1525	if ((!is_delayed || mdsc->stopping) &&
1526	    ci->i_wrbuffer_ref == 0 &&               /* no dirty pages... */
1527	    inode->i_data.nrpages &&                 /* have cached pages */
1528	    (file_wanted == 0 ||                     /* no open files */
1529	     (revoking & (CEPH_CAP_FILE_CACHE|
1530			  CEPH_CAP_FILE_LAZYIO))) && /*  or revoking cache */
1531	    !tried_invalidate) {
1532		dout("check_caps trying to invalidate on %p\n", inode);
1533		if (try_nonblocking_invalidate(inode) < 0) {
1534			if (revoking & (CEPH_CAP_FILE_CACHE|
1535					CEPH_CAP_FILE_LAZYIO)) {
1536				dout("check_caps queuing invalidate\n");
1537				queue_invalidate = 1;
1538				ci->i_rdcache_revoking = ci->i_rdcache_gen;
1539			} else {
1540				dout("check_caps failed to invalidate pages\n");
1541				/* we failed to invalidate pages.  check these
1542				   caps again later. */
1543				force_requeue = 1;
1544				__cap_set_timeouts(mdsc, ci);
1545			}
1546		}
1547		tried_invalidate = 1;
1548		goto retry_locked;
1549	}
1550
1551	num = 0;
1552	for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
1553		cap = rb_entry(p, struct ceph_cap, ci_node);
1554		num++;
1555
1556		/* avoid looping forever */
1557		if (mds >= cap->mds ||
1558		    ((flags & CHECK_CAPS_AUTHONLY) && cap != ci->i_auth_cap))
1559			continue;
1560
1561		/* NOTE: no side-effects allowed, until we take s_mutex */
1562
1563		revoking = cap->implemented & ~cap->issued;
1564		dout(" mds%d cap %p issued %s implemented %s revoking %s\n",
1565		     cap->mds, cap, ceph_cap_string(cap->issued),
1566		     ceph_cap_string(cap->implemented),
1567		     ceph_cap_string(revoking));
1568
1569		if (cap == ci->i_auth_cap &&
1570		    (cap->issued & CEPH_CAP_FILE_WR)) {
1571			/* request larger max_size from MDS? */
1572			if (ci->i_wanted_max_size > ci->i_max_size &&
1573			    ci->i_wanted_max_size > ci->i_requested_max_size) {
1574				dout("requesting new max_size\n");
1575				goto ack;
1576			}
1577
1578			/* approaching file_max? */
1579			if ((inode->i_size << 1) >= ci->i_max_size &&
1580			    (ci->i_reported_size << 1) < ci->i_max_size) {
1581				dout("i_size approaching max_size\n");
1582				goto ack;
1583			}
1584		}
1585		/* flush anything dirty? */
1586		if (cap == ci->i_auth_cap && (flags & CHECK_CAPS_FLUSH) &&
1587		    ci->i_dirty_caps) {
1588			dout("flushing dirty caps\n");
1589			goto ack;
1590		}
1591
1592		/* completed revocation? going down and there are no caps? */
1593		if (revoking && (revoking & used) == 0) {
1594			dout("completed revocation of %s\n",
1595			     ceph_cap_string(cap->implemented & ~cap->issued));
1596			goto ack;
1597		}
1598
1599		/* want more caps from mds? */
1600		if (want & ~(cap->mds_wanted | cap->issued))
1601			goto ack;
1602
1603		/* things we might delay */
1604		if ((cap->issued & ~retain) == 0 &&
1605		    cap->mds_wanted == want)
1606			continue;     /* nope, all good */
1607
1608		if (is_delayed)
1609			goto ack;
1610
1611		/* delay? */
1612		if ((ci->i_ceph_flags & CEPH_I_NODELAY) == 0 &&
1613		    time_before(jiffies, ci->i_hold_caps_max)) {
1614			dout(" delaying issued %s -> %s, wanted %s -> %s\n",
1615			     ceph_cap_string(cap->issued),
1616			     ceph_cap_string(cap->issued & retain),
1617			     ceph_cap_string(cap->mds_wanted),
1618			     ceph_cap_string(want));
1619			delayed++;
1620			continue;
1621		}
1622
1623ack:
1624		if (ci->i_ceph_flags & CEPH_I_NOFLUSH) {
1625			dout(" skipping %p I_NOFLUSH set\n", inode);
1626			continue;
1627		}
1628
1629		if (session && session != cap->session) {
1630			dout("oops, wrong session %p mutex\n", session);
1631			mutex_unlock(&session->s_mutex);
1632			session = NULL;
1633		}
1634		if (!session) {
1635			session = cap->session;
1636			if (mutex_trylock(&session->s_mutex) == 0) {
1637				dout("inverting session/ino locks on %p\n",
1638				     session);
1639				spin_unlock(&inode->i_lock);
1640				if (took_snap_rwsem) {
1641					up_read(&mdsc->snap_rwsem);
1642					took_snap_rwsem = 0;
1643				}
1644				mutex_lock(&session->s_mutex);
1645				goto retry;
1646			}
1647		}
1648		/* take snap_rwsem after session mutex */
1649		if (!took_snap_rwsem) {
1650			if (down_read_trylock(&mdsc->snap_rwsem) == 0) {
1651				dout("inverting snap/in locks on %p\n",
1652				     inode);
1653				spin_unlock(&inode->i_lock);
1654				down_read(&mdsc->snap_rwsem);
1655				took_snap_rwsem = 1;
1656				goto retry;
1657			}
1658			took_snap_rwsem = 1;
1659		}
1660
1661		if (cap == ci->i_auth_cap && ci->i_dirty_caps)
1662			flushing = __mark_caps_flushing(inode, session);
1663		else
1664			flushing = 0;
1665
1666		mds = cap->mds;  /* remember mds, so we don't repeat */
1667		sent++;
1668
1669		/* __send_cap drops i_lock */
1670		delayed += __send_cap(mdsc, cap, CEPH_CAP_OP_UPDATE, used, want,
1671				      retain, flushing, NULL);
1672		goto retry; /* retake i_lock and restart our cap scan. */
1673	}
1674
1675	/*
1676	 * Reschedule delayed caps release if we delayed anything,
1677	 * otherwise cancel.
1678	 */
1679	if (delayed && is_delayed)
1680		force_requeue = 1;   /* __send_cap delayed release; requeue */
1681	if (!delayed && !is_delayed)
1682		__cap_delay_cancel(mdsc, ci);
1683	else if (!is_delayed || force_requeue)
1684		__cap_delay_requeue(mdsc, ci);
1685
1686	spin_unlock(&inode->i_lock);
1687
1688	if (queue_invalidate)
1689		ceph_queue_invalidate(inode);
1690
1691	if (session)
1692		mutex_unlock(&session->s_mutex);
1693	if (took_snap_rwsem)
1694		up_read(&mdsc->snap_rwsem);
1695}
1696
1697/*
1698 * Try to flush dirty caps back to the auth mds.
1699 */
1700static int try_flush_caps(struct inode *inode, struct ceph_mds_session *session,
1701			  unsigned *flush_tid)
1702{
1703	struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
1704	struct ceph_inode_info *ci = ceph_inode(inode);
1705	int unlock_session = session ? 0 : 1;
1706	int flushing = 0;
1707
1708retry:
1709	spin_lock(&inode->i_lock);
1710	if (ci->i_ceph_flags & CEPH_I_NOFLUSH) {
1711		dout("try_flush_caps skipping %p I_NOFLUSH set\n", inode);
1712		goto out;
1713	}
1714	if (ci->i_dirty_caps && ci->i_auth_cap) {
1715		struct ceph_cap *cap = ci->i_auth_cap;
1716		int used = __ceph_caps_used(ci);
1717		int want = __ceph_caps_wanted(ci);
1718		int delayed;
1719
1720		if (!session) {
1721			spin_unlock(&inode->i_lock);
1722			session = cap->session;
1723			mutex_lock(&session->s_mutex);
1724			goto retry;
1725		}
1726		BUG_ON(session != cap->session);
1727		if (cap->session->s_state < CEPH_MDS_SESSION_OPEN)
1728			goto out;
1729
1730		flushing = __mark_caps_flushing(inode, session);
1731
1732		/* __send_cap drops i_lock */
1733		delayed = __send_cap(mdsc, cap, CEPH_CAP_OP_FLUSH, used, want,
1734				     cap->issued | cap->implemented, flushing,
1735				     flush_tid);
1736		if (!delayed)
1737			goto out_unlocked;
1738
1739		spin_lock(&inode->i_lock);
1740		__cap_delay_requeue(mdsc, ci);
1741	}
1742out:
1743	spin_unlock(&inode->i_lock);
1744out_unlocked:
1745	if (session && unlock_session)
1746		mutex_unlock(&session->s_mutex);
1747	return flushing;
1748}
1749
1750/*
1751 * Return true if we've flushed caps through the given flush_tid.
1752 */
1753static int caps_are_flushed(struct inode *inode, unsigned tid)
1754{
1755	struct ceph_inode_info *ci = ceph_inode(inode);
1756	int i, ret = 1;
1757
1758	spin_lock(&inode->i_lock);
1759	for (i = 0; i < CEPH_CAP_BITS; i++)
1760		if ((ci->i_flushing_caps & (1 << i)) &&
1761		    ci->i_cap_flush_tid[i] <= tid) {
1762			/* still flushing this bit */
1763			ret = 0;
1764			break;
1765		}
1766	spin_unlock(&inode->i_lock);
1767	return ret;
1768}
1769
1770/*
1771 * Wait on any unsafe replies for the given inode.  First wait on the
1772 * newest request, and make that the upper bound.  Then, if there are
1773 * more requests, keep waiting on the oldest as long as it is still older
1774 * than the original request.
1775 */
1776static void sync_write_wait(struct inode *inode)
1777{
1778	struct ceph_inode_info *ci = ceph_inode(inode);
1779	struct list_head *head = &ci->i_unsafe_writes;
1780	struct ceph_osd_request *req;
1781	u64 last_tid;
1782
1783	spin_lock(&ci->i_unsafe_lock);
1784	if (list_empty(head))
1785		goto out;
1786
1787	/* set upper bound as _last_ entry in chain */
1788	req = list_entry(head->prev, struct ceph_osd_request,
1789			 r_unsafe_item);
1790	last_tid = req->r_tid;
1791
1792	do {
1793		ceph_osdc_get_request(req);
1794		spin_unlock(&ci->i_unsafe_lock);
1795		dout("sync_write_wait on tid %llu (until %llu)\n",
1796		     req->r_tid, last_tid);
1797		wait_for_completion(&req->r_safe_completion);
1798		spin_lock(&ci->i_unsafe_lock);
1799		ceph_osdc_put_request(req);
1800
1801		/*
1802		 * from here on look at first entry in chain, since we
1803		 * only want to wait for anything older than last_tid
1804		 */
1805		if (list_empty(head))
1806			break;
1807		req = list_entry(head->next, struct ceph_osd_request,
1808				 r_unsafe_item);
1809	} while (req->r_tid < last_tid);
1810out:
1811	spin_unlock(&ci->i_unsafe_lock);
1812}
1813
1814int cep

Large files files are truncated, but you can click here to view the full file