Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/sage/ceph-client

Pull Ceph update from Sage Weil: "There are a few fixes for snapshot behavior with CephFS and support for the new keepalive protocol from Zheng, a libceph fix that affects both RBD and CephFS, a few bug fixes and cleanups for RBD from Ilya, and several small fixes and cleanups from Jianpeng and others" * 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/sage/ceph-client: ceph: improve readahead for file holes ceph: get inode size for each append write libceph: check data_len in ->alloc_msg() libceph: use keepalive2 to verify the mon session is alive rbd: plug rbd_dev->header.object_prefix memory leak rbd: fix double free on rbd_dev->header_name libceph: set 'exists' flag for newly up osd ceph: cleanup use of ceph_msg_get ceph: no need to get parent inode in ceph_open ceph: remove the useless judgement ceph: remove redundant test of head->safe and silence static analysis warnings ceph: fix queuing inode to mdsdir's snaprealm libceph: rename con_work() to ceph_con_workfn() libceph: Avoid holding the zero page on ceph_msgr_slab_init errors libceph: remove the unused macro AES_KEY_SIZE ceph: invalidate dirty pages after forced umount ceph: EIO all operations after forced umount

Linus Torvalds committed 11 years ago

Commit e013f742 parents 01cab55 438386817 files · +191 −98Browse files

Unified · Split

17 files

drivers/block/rbd.c +4 −2
fs/ceph/addr.c +4 −2
fs/ceph/caps.c +8 −0
fs/ceph/file.c +8 −6
fs/ceph/mds_client.c +45 −14
fs/ceph/mds_client.h +1 −0
fs/ceph/snap.c +0 −7
fs/ceph/super.c +1 −0
include/linux/ceph/libceph.h +2 −0
include/linux/ceph/messenger.h +4 −0
include/linux/ceph/msgr.h +3 −1
net/ceph/ceph_common.c +1 −0
net/ceph/crypto.c +0 −4
net/ceph/messenger.c +62 −20
net/ceph/mon_client.c +29 −8
net/ceph/osd_client.c +18 −33
net/ceph/osdmap.c +1 −1

drivers/block/rbd.c+4−2

 	}
 	ret = rbd_dev_v2_snap_context(rbd_dev);
-	dout("rbd_dev_v2_snap_context returned %d\n", ret);
+	if (ret && first_time) {
+		kfree(rbd_dev->header.object_prefix);
+		rbd_dev->header.object_prefix = NULL;
+	}
 	return ret;
 }
 out_err:
 	if (parent) {
 		rbd_dev_unparent(rbd_dev);
-		kfree(rbd_dev->header_name);
 		rbd_dev_destroy(parent);
 	} else {
 		rbd_put_client(rbdc);

fs/ceph/addr.c+4−2

 	for (i = 0; i < num_pages; i++) {
 		struct page *page = osd_data->pages[i];
-		if (rc < 0)
+		if (rc < 0 && rc != ENOENT)
 			goto unlock;
 		if (bytes < (int)PAGE_CACHE_SIZE) {
 			/* zero (remainder of) page */
 	     wbc->sync_mode == WB_SYNC_NONE ? "NONE" :
 	     (wbc->sync_mode == WB_SYNC_ALL ? "ALL" : "HOLD"));
-	if (fsc->mount_state == CEPH_MOUNT_SHUTDOWN) {
+	if (ACCESS_ONCE(fsc->mount_state) == CEPH_MOUNT_SHUTDOWN) {
 		pr_warn("writepage_start %p on forced umount\n", inode);
+		truncate_pagecache(inode, 0);
+		mapping_set_error(mapping, -EIO);
 		return -EIO; /* we're in a forced umount, don't write! */
 	}
 	if (fsc->mount_options->wsize && fsc->mount_options->wsize < wsize)

fs/ceph/caps.c+8−0

@@ -2413,6 +2413,14 @@ again: · 2412 unmodified lines
2413	goto out_unlock;	2413	goto out_unlock;
2414	}	2414	}
2415		2415
		2416	if (!__ceph_is_any_caps(ci) &&
		2417	ACCESS_ONCE(mdsc->fsc->mount_state) == CEPH_MOUNT_SHUTDOWN) {
		2418	dout("get_cap_refs %p forced umount\n", inode);
		2419	*err = -EIO;
		2420	ret = 1;
		2421	goto out_unlock;
		2422	}
		2423
2416	dout("get_cap_refs %p have %s needed %s\n", inode,	2424	dout("get_cap_refs %p have %s needed %s\n", inode,
2417	ceph_cap_string(have), ceph_cap_string(need));	2425	ceph_cap_string(have), ceph_cap_string(need));
2418	}	2426	}

fs/ceph/file.c+8−6

 	struct ceph_mds_client *mdsc = fsc->mdsc;
 	struct ceph_mds_request *req;
 	struct ceph_file_info *cf = file->private_data;
-	struct inode *parent_inode = NULL;
 	int err;
 	int flags, fmode, wanted;
 	ihold(inode);
 	req->r_num_caps = 1;
-	if (flags & O_CREAT)
+	err = ceph_mdsc_do_request(mdsc, NULL, req);
-		parent_inode = ceph_get_dentry_parent_inode(file->f_path.dentry);
-	err = ceph_mdsc_do_request(mdsc, parent_inode, req);
-	iput(parent_inode);
 	if (!err)
 		err = ceph_init_file(inode, file, req->r_fmode);
 	ceph_mdsc_put_request(req);
 	if (err)
 		goto out_req;
-	if (err == 0 && (flags & O_CREAT) && !req->r_reply_info.head->is_dentry)
+	if ((flags & O_CREAT) && !req->r_reply_info.head->is_dentry)
 		err = ceph_handle_notrace_create(dir, dentry);
 	if (d_unhashed(dentry)) {
 	/* We can write back this queue in page reclaim */
 	current->backing_dev_info = inode_to_bdi(inode);
+	if (iocb->ki_flags & IOCB_APPEND) {
+		err = ceph_do_getattr(inode, CEPH_STAT_CAP_SIZE, false);
+		if (err < 0)
+			goto out;
+	}
 	err = generic_write_checks(iocb, from);
 	if (err <= 0)
 		goto out;

fs/ceph/mds_client.c+45−14

 	msg = create_request_message(mdsc, req, mds, drop_cap_releases);
 	if (IS_ERR(msg)) {
 		req->r_err = PTR_ERR(msg);
-		complete_request(mdsc, req);
 		return PTR_ERR(msg);
 	}
 	req->r_request = msg;
 {
 	struct ceph_mds_session *session = NULL;
 	int mds = -1;
-	int err = -EAGAIN;
+	int err = 0;
 	if (req->r_err || req->r_got_result) {
 		if (req->r_aborted)
 		err = -EIO;
 		goto finish;
 	}
+	if (ACCESS_ONCE(mdsc->fsc->mount_state) == CEPH_MOUNT_SHUTDOWN) {
+		dout("do_request forced umount\n");
+		err = -EIO;
+		goto finish;
+	}
 	put_request_session(req);
 out_session:
 	ceph_put_mds_session(session);
+finish:
+	if (err) {
+		dout("__do_request early error %d\n", err);
+		req->r_err = err;
+		complete_request(mdsc, req);
+		__unregister_request(mdsc, req);
+	}
 out:
 	return err;
-finish:
-	req->r_err = err;
-	complete_request(mdsc, req);
-	goto out;
 }
 /*
 	if (req->r_err) {
 		err = req->r_err;
-		__unregister_request(mdsc, req);
-		dout("do_request early error %d\n", err);
 		goto out;
 	}
 		mutex_unlock(&mdsc->mutex);
 		goto out;
 	}
-	if (req->r_got_safe && !head->safe) {
+	if (req->r_got_safe) {
 		pr_warn("got unsafe after safe on %llu from mds%d\n",
 			   tid, mds);
 		mutex_unlock(&mdsc->mutex);
 		if (err) {
 			req->r_err = err;
 		} else {
-			req->r_reply = msg;
+			req->r_reply =  ceph_msg_get(msg);
-			ceph_msg_get(msg);
 			req->r_got_result = true;
 		}
 	} else {
 {
 	u64 want_tid, want_flush, want_snap;
-	if (mdsc->fsc->mount_state == CEPH_MOUNT_SHUTDOWN)
+	if (ACCESS_ONCE(mdsc->fsc->mount_state) == CEPH_MOUNT_SHUTDOWN)
 		return;
 	dout("sync\n");
  */
 static bool done_closing_sessions(struct ceph_mds_client *mdsc)
 {
-	if (mdsc->fsc->mount_state == CEPH_MOUNT_SHUTDOWN)
+	if (ACCESS_ONCE(mdsc->fsc->mount_state) == CEPH_MOUNT_SHUTDOWN)
 		return true;
 	return atomic_read(&mdsc->num_sessions) == 0;
 }
 	dout("stopped\n");
 }
+void ceph_mdsc_force_umount(struct ceph_mds_client *mdsc)
+{
+	struct ceph_mds_session *session;
+	int mds;
+	dout("force umount\n");
+	mutex_lock(&mdsc->mutex);
+	for (mds = 0; mds < mdsc->max_sessions; mds++) {
+		session = __ceph_lookup_mds_session(mdsc, mds);
+		if (!session)
+			continue;
+		mutex_unlock(&mdsc->mutex);
+		mutex_lock(&session->s_mutex);
+		__close_session(mdsc, session);
+		if (session->s_state == CEPH_MDS_SESSION_CLOSING) {
+			cleanup_session_requests(mdsc, session);
+			remove_session_caps(session);
+		}
+		mutex_unlock(&session->s_mutex);
+		ceph_put_mds_session(session);
+		mutex_lock(&mdsc->mutex);
+		kick_requests(mdsc, mds);
+	}
+	__wake_requests(mdsc, &mdsc->waiting_for_map);
+	mutex_unlock(&mdsc->mutex);
+}
 static void ceph_mdsc_stop(struct ceph_mds_client *mdsc)
 {
 	dout("stop\n");

fs/ceph/mds_client.h+1−0

@@ -366,6 +366,7 @@ extern int ceph_send_msg_mds(struct ceph_mds_client *mdsc, · 365 unmodified lines
366		366
367	extern int ceph_mdsc_init(struct ceph_fs_client *fsc);	367	extern int ceph_mdsc_init(struct ceph_fs_client *fsc);
368	extern void ceph_mdsc_close_sessions(struct ceph_mds_client *mdsc);	368	extern void ceph_mdsc_close_sessions(struct ceph_mds_client *mdsc);
		369	extern void ceph_mdsc_force_umount(struct ceph_mds_client *mdsc);
369	extern void ceph_mdsc_destroy(struct ceph_fs_client *fsc);	370	extern void ceph_mdsc_destroy(struct ceph_fs_client *fsc);
370		371
371	extern void ceph_mdsc_sync(struct ceph_mds_client *mdsc);	372	extern void ceph_mdsc_sync(struct ceph_mds_client *mdsc);

fs/ceph/snap.c+0−7

 		return 0;
 	}
-	if (num == 0 && realm->seq == ceph_empty_snapc->seq) {
-		ceph_get_snap_context(ceph_empty_snapc);
-		snapc = ceph_empty_snapc;
-		goto done;
-	}
 	/* alloc new snap context */
 	err = -ENOMEM;
 	if (num > (SIZE_MAX - sizeof(*snapc)) / sizeof(u64))
 	     realm->ino, realm, snapc, snapc->seq,
 	     (unsigned int) snapc->num_snaps);
-done:
 	ceph_put_snap_context(realm->cached_context);
 	realm->cached_context = snapc;
 	return 0;

fs/ceph/super.c+1−0

@@ -708,6 +708,7 @@ static void ceph_umount_begin(struct super_block *sb) · 707 unmodified lines
708	if (!fsc)	708	if (!fsc)
709	return;	709	return;
710	fsc->mount_state = CEPH_MOUNT_SHUTDOWN;	710	fsc->mount_state = CEPH_MOUNT_SHUTDOWN;
		711	ceph_mdsc_force_umount(fsc->mdsc);
711	return;	712	return;
712	}	713	}
713		714

include/linux/ceph/libceph.h+2−0

 	unsigned long mount_timeout;		/* jiffies */
 	unsigned long osd_idle_ttl;		/* jiffies */
 	unsigned long osd_keepalive_timeout;	/* jiffies */
+	unsigned long monc_ping_timeout;	/* jiffies */
 	/*
 	 * any type that can't be simply compared or doesn't need need
 #define CEPH_MOUNT_TIMEOUT_DEFAULT	msecs_to_jiffies(60 * 1000)
 #define CEPH_OSD_KEEPALIVE_DEFAULT	msecs_to_jiffies(5 * 1000)
 #define CEPH_OSD_IDLE_TTL_DEFAULT	msecs_to_jiffies(60 * 1000)
+#define CEPH_MONC_PING_TIMEOUT_DEFAULT	msecs_to_jiffies(30 * 1000)
 #define CEPH_MSG_MAX_FRONT_LEN	(16*1024*1024)
 #define CEPH_MSG_MAX_MIDDLE_LEN	(16*1024*1024)

include/linux/ceph/messenger.h+4−0

 	int in_base_pos;     /* bytes read */
 	__le64 in_temp_ack;  /* for reading an ack */
+	struct timespec last_keepalive_ack;
 	struct delayed_work work;	    /* send|recv work */
 	unsigned long       delay;          /* current delay interval */
 };
 extern void ceph_msg_revoke_incoming(struct ceph_msg *msg);
 extern void ceph_con_keepalive(struct ceph_connection *con);
+extern bool ceph_con_keepalive_expired(struct ceph_connection *con,
+				       unsigned long interval);
 extern void ceph_msg_data_add_pages(struct ceph_msg *msg, struct page **pages,
 				size_t length, size_t alignment);

include/linux/ceph/msgr.h+3−1

 #define CEPH_MSGR_TAG_MSG           7  /* message */
 #define CEPH_MSGR_TAG_ACK           8  /* message ack */
 #define CEPH_MSGR_TAG_KEEPALIVE     9  /* just a keepalive byte! */
-#define CEPH_MSGR_TAG_BADPROTOVER  10  /* bad protocol version */
+#define CEPH_MSGR_TAG_BADPROTOVER   10 /* bad protocol version */
 #define CEPH_MSGR_TAG_BADAUTHORIZER 11 /* bad authorizer */
 #define CEPH_MSGR_TAG_FEATURES      12 /* insufficient features */
 #define CEPH_MSGR_TAG_SEQ           13 /* 64-bit int follows with seen seq number */
+#define CEPH_MSGR_TAG_KEEPALIVE2    14 /* keepalive2 byte + ceph_timespec */
+#define CEPH_MSGR_TAG_KEEPALIVE2_ACK 15 /* keepalive2 reply */
 /*

net/ceph/ceph_common.c+1−0

@@ -357,6 +357,7 @@ ceph_parse_options(char options, const char dev_name, · 356 unmodified lines
357	opt->osd_keepalive_timeout = CEPH_OSD_KEEPALIVE_DEFAULT;	357	opt->osd_keepalive_timeout = CEPH_OSD_KEEPALIVE_DEFAULT;
358	opt->mount_timeout = CEPH_MOUNT_TIMEOUT_DEFAULT;	358	opt->mount_timeout = CEPH_MOUNT_TIMEOUT_DEFAULT;
359	opt->osd_idle_ttl = CEPH_OSD_IDLE_TTL_DEFAULT;	359	opt->osd_idle_ttl = CEPH_OSD_IDLE_TTL_DEFAULT;
		360	opt->monc_ping_timeout = CEPH_MONC_PING_TIMEOUT_DEFAULT;
360		361
361	/* get mon ip(s) */	362	/* get mon ip(s) */
362	/* ip1[:port1][,ip2[:port2]...] */	363	/* ip1[:port1][,ip2[:port2]...] */

net/ceph/crypto.c+0−4

@@ -79,10 +79,6 @@ int ceph_crypto_key_unarmor(struct ceph_crypto_key key, const char inkey) · 78 unmodified lines
79	return 0;	79	return 0;
80	}	80	}
81		81
82
83
84	#define AES_KEY_SIZE 16
85
86	static struct crypto_blkcipher *ceph_crypto_alloc_cipher(void)	82	static struct crypto_blkcipher *ceph_crypto_alloc_cipher(void)
87	{	83	{
88	return crypto_alloc_blkcipher("cbc(aes)", 0, CRYPTO_ALG_ASYNC);	84	return crypto_alloc_blkcipher("cbc(aes)", 0, CRYPTO_ALG_ASYNC);

net/ceph/messenger.c+62−20

 static char tag_msg = CEPH_MSGR_TAG_MSG;
 static char tag_ack = CEPH_MSGR_TAG_ACK;
 static char tag_keepalive = CEPH_MSGR_TAG_KEEPALIVE;
+static char tag_keepalive2 = CEPH_MSGR_TAG_KEEPALIVE2;
 #ifdef CONFIG_LOCKDEP
 static struct lock_class_key socket_class;
 static void queue_con(struct ceph_connection *con);
 static void cancel_con(struct ceph_connection *con);
-static void con_work(struct work_struct *);
+static void ceph_con_workfn(struct work_struct *);
 static void con_fault(struct ceph_connection *con);
 /*
 		ceph_msgr_wq = NULL;
 	}
-	ceph_msgr_slab_exit();
 	BUG_ON(zero_page == NULL);
 	page_cache_release(zero_page);
 	zero_page = NULL;
+	ceph_msgr_slab_exit();
 }
 int ceph_msgr_init(void)
 {
+	if (ceph_msgr_slab_init())
+		return -ENOMEM;
 	BUG_ON(zero_page != NULL);
 	zero_page = ZERO_PAGE(0);
 	page_cache_get(zero_page);
-	if (ceph_msgr_slab_init())
-		return -ENOMEM;
 	/*
 	 * The number of active work items is limited by the number of
 	 * connections, so leave @max_active at default.
 	mutex_init(&con->mutex);
 	INIT_LIST_HEAD(&con->out_queue);
 	INIT_LIST_HEAD(&con->out_sent);
-	INIT_DELAYED_WORK(&con->work, con_work);
+	INIT_DELAYED_WORK(&con->work, ceph_con_workfn);
 	con->state = CON_STATE_CLOSED;
 }
 {
 	dout("prepare_write_keepalive %p\n", con);
 	con_out_kvec_reset(con);
-	con_out_kvec_add(con, sizeof (tag_keepalive), &tag_keepalive);
+	if (con->peer_features & CEPH_FEATURE_MSGR_KEEPALIVE2) {
+		struct timespec ts = CURRENT_TIME;
+		struct ceph_timespec ceph_ts;
+		ceph_encode_timespec(&ceph_ts, &ts);
+		con_out_kvec_add(con, sizeof(tag_keepalive2), &tag_keepalive2);
+		con_out_kvec_add(con, sizeof(ceph_ts), &ceph_ts);
+	} else {
+		con_out_kvec_add(con, sizeof(tag_keepalive), &tag_keepalive);
+	}
 	con_flag_set(con, CON_FLAG_WRITE_PENDING);
 }
 	con->in_tag = CEPH_MSGR_TAG_READY;
 }
+static void prepare_read_keepalive_ack(struct ceph_connection *con)
+{
+	dout("prepare_read_keepalive_ack %p\n", con);
+	con->in_base_pos = 0;
+}
 /*
  * Prepare to read a message.
  */
 			return ret;
 		BUG_ON(!con->in_msg ^ skip);
-		if (con->in_msg && data_len > con->in_msg->data_length) {
-			pr_warn("%s skipping long message (%u > %zd)\n",
-				__func__, data_len, con->in_msg->data_length);
-			ceph_msg_put(con->in_msg);
-			con->in_msg = NULL;
-			skip = 1;
-		}
 		if (skip) {
 			/* skip this message */
 			dout("alloc_msg said skip message\n");
 	mutex_lock(&con->mutex);
 }
+static int read_keepalive_ack(struct ceph_connection *con)
+{
+	struct ceph_timespec ceph_ts;
+	size_t size = sizeof(ceph_ts);
+	int ret = read_partial(con, size, size, &ceph_ts);
+	if (ret <= 0)
+		return ret;
+	ceph_decode_timespec(&con->last_keepalive_ack, &ceph_ts);
+	prepare_read_tag(con);
+	return 1;
+}
 /*
  * Write something to the socket.  Called in a worker thread when the
 do_next:
 	if (con->state == CON_STATE_OPEN) {
+		if (con_flag_test_and_clear(con, CON_FLAG_KEEPALIVE_PENDING)) {
+			prepare_write_keepalive(con);
+			goto more;
+		}
 		/* is anything else pending? */
 		if (!list_empty(&con->out_queue)) {
 			prepare_write_message(con);
 			prepare_write_ack(con);
 			goto more;
 		}
-		if (con_flag_test_and_clear(con, CON_FLAG_KEEPALIVE_PENDING)) {
-			prepare_write_keepalive(con);
-			goto more;
-		}
 	}
 	/* Nothing to do! */
 		case CEPH_MSGR_TAG_ACK:
 			prepare_read_ack(con);
 			break;
+		case CEPH_MSGR_TAG_KEEPALIVE2_ACK:
+			prepare_read_keepalive_ack(con);
+			break;
 		case CEPH_MSGR_TAG_CLOSE:
 			con_close_socket(con);
 			con->state = CON_STATE_CLOSED;
 		process_ack(con);
 		goto more;
 	}
+	if (con->in_tag == CEPH_MSGR_TAG_KEEPALIVE2_ACK) {
+		ret = read_keepalive_ack(con);
+		if (ret <= 0)
+			goto out;
+		goto more;
+	}
 out:
 	dout("try_read done on %p ret %d\n", con, ret);
 /*
  * Do some work on a connection.  Drop a connection ref when we're done.
  */
-static void con_work(struct work_struct *work)
+static void ceph_con_workfn(struct work_struct *work)
 {
 	struct ceph_connection *con = container_of(work, struct ceph_connection,
 						   work.work);
 }
 EXPORT_SYMBOL(ceph_con_keepalive);
+bool ceph_con_keepalive_expired(struct ceph_connection *con,
+			       unsigned long interval)
+{
+	if (interval > 0 &&
+	    (con->peer_features & CEPH_FEATURE_MSGR_KEEPALIVE2)) {
+		struct timespec now = CURRENT_TIME;
+		struct timespec ts;
+		jiffies_to_timespec(interval, &ts);
+		ts = timespec_add(con->last_keepalive_ack, ts);
+		return timespec_compare(&now, &ts) >= 0;
+	}
+	return false;
+}
 static struct ceph_msg_data *ceph_msg_data_create(enum ceph_msg_data_type type)
 {
 	struct ceph_msg_data *data;

net/ceph/mon_client.c+29−8

 			      CEPH_ENTITY_TYPE_MON, monc->cur_mon,
 			      &monc->monmap->mon_inst[monc->cur_mon].addr);
+		/* send an initial keepalive to ensure our timestamp is
+		 * valid by the time we are in an OPENED state */
+		ceph_con_keepalive(&monc->con);
 		/* initiatiate authentication handshake */
 		ret = ceph_auth_build_hello(monc->auth,
 					    monc->m_auth->front.iov_base,
  */
 static void __schedule_delayed(struct ceph_mon_client *monc)
 {
-	unsigned int delay;
+	struct ceph_options *opt = monc->client->options;
+	unsigned long delay;
-	if (monc->cur_mon < 0 || __sub_expired(monc))
+	if (monc->cur_mon < 0 || __sub_expired(monc)) {
 		delay = 10 * HZ;
-	else
+	} else {
 		delay = 20 * HZ;
-	dout("__schedule_delayed after %u\n", delay);
+		if (opt->monc_ping_timeout > 0)
-	schedule_delayed_work(&monc->delayed_work, delay);
+			delay = min(delay, opt->monc_ping_timeout / 3);
+	}
+	dout("__schedule_delayed after %lu\n", delay);
+	schedule_delayed_work(&monc->delayed_work,
+			      round_jiffies_relative(delay));
 }
 /*
 		__close_session(monc);
 		__open_session(monc);  /* continue hunting */
 	} else {
-		ceph_con_keepalive(&monc->con);
+		struct ceph_options *opt = monc->client->options;
+		int is_auth = ceph_auth_is_authenticated(monc->auth);
+		if (ceph_con_keepalive_expired(&monc->con,
+					       opt->monc_ping_timeout)) {
+			dout("monc keepalive timeout\n");
+			is_auth = 0;
+			__close_session(monc);
+			monc->hunting = true;
+			__open_session(monc);
+		}
-		__validate_auth(monc);
+		if (!monc->hunting) {
+			ceph_con_keepalive(&monc->con);
+			__validate_auth(monc);
+		}
-		if (ceph_auth_is_authenticated(monc->auth))
+		if (is_auth)
 			__send_subscribe(monc);
 	}
 	__schedule_delayed(monc);

net/ceph/osd_client.c+18−33

@@ -2817,8 +2817,9 @@ out: · 2816 unmodified lines
2817	}	2817	}
2818		2818
2819	/*	2819	/*
2820	* lookup and return message for incoming reply. set up reply message	2820	* Lookup and return message for incoming reply. Don't try to do
2821	* pages.	2821	* anything about a larger than preallocated data portion of the
		2822	* message at the moment - for now, just skip the message.
2822	*/	2823	*/
2823	static struct ceph_msg get_reply(struct ceph_connection con,	2824	static struct ceph_msg get_reply(struct ceph_connection con,
2824	struct ceph_msg_header *hdr,	2825	struct ceph_msg_header *hdr,
@@ -2836,10 +2837,10 @@ static struct ceph_msg get_reply(struct ceph_connection con, · 11 unmodified lines
2836	mutex_lock(&osdc->request_mutex);	2837	mutex_lock(&osdc->request_mutex);
2837	req = __lookup_request(osdc, tid);	2838	req = __lookup_request(osdc, tid);
2838	if (!req) {	2839	if (!req) {
2839	*skip = 1;	2840	pr_warn("%s osd%d tid %llu unknown, skipping\n",
		2841	__func__, osd->o_osd, tid);
2840	m = NULL;	2842	m = NULL;
2841	dout("get_reply unknown tid %llu from osd%d\n", tid,	2843	*skip = 1;
2842	osd->o_osd);
2843	goto out;	2844	goto out;
2844	}	2845	}
2845		2846
@@ -2849,10 +2850,9 @@ static struct ceph_msg get_reply(struct ceph_connection con, · 3 unmodified lines
2849	ceph_msg_revoke_incoming(req->r_reply);	2850	ceph_msg_revoke_incoming(req->r_reply);
2850		2851
2851	if (front_len > req->r_reply->front_alloc_len) {	2852	if (front_len > req->r_reply->front_alloc_len) {
2852	pr_warn("get_reply front %d > preallocated %d (%u#%llu)\n",	2853	pr_warn("%s osd%d tid %llu front %d > preallocated %d\n",
2853	front_len, req->r_reply->front_alloc_len,	2854	__func__, osd->o_osd, req->r_tid, front_len,
2854	(unsigned int)con->peer_name.type,	2855	req->r_reply->front_alloc_len);
2855	le64_to_cpu(con->peer_name.num));
2856	m = ceph_msg_new(CEPH_MSG_OSD_OPREPLY, front_len, GFP_NOFS,	2856	m = ceph_msg_new(CEPH_MSG_OSD_OPREPLY, front_len, GFP_NOFS,
2857	false);	2857	false);
2858	if (!m)	2858	if (!m)
@@ -2860,37 +2860,22 @@ static struct ceph_msg get_reply(struct ceph_connection con, · 1 unmodified line
2860	ceph_msg_put(req->r_reply);	2860	ceph_msg_put(req->r_reply);
2861	req->r_reply = m;	2861	req->r_reply = m;
2862	}	2862	}
2863	m = ceph_msg_get(req->r_reply);
2864
2865	if (data_len > 0) {
2866	struct ceph_osd_data *osd_data;
2867		2863
2868	/*	2864	if (data_len > req->r_reply->data_length) {
2869	* XXX This is assuming there is only one op containing	2865	pr_warn("%s osd%d tid %llu data %d > preallocated %zu, skipping\n",
2870	* XXX page data. Probably OK for reads, but this	2866	__func__, osd->o_osd, req->r_tid, data_len,
2871	* XXX ought to be done more generally.	2867	req->r_reply->data_length);
2872	*/	2868	m = NULL;
2873	osd_data = osd_req_op_extent_osd_data(req, 0);	2869	*skip = 1;
2874	if (osd_data->type == CEPH_OSD_DATA_TYPE_PAGES) {	2870	goto out;
2875	if (osd_data->pages &&
2876	unlikely(osd_data->length < data_len)) {
2877
2878	pr_warn("tid %lld reply has %d bytes we had only %llu bytes ready\n",
2879	tid, data_len, osd_data->length);
2880	*skip = 1;
2881	ceph_msg_put(m);
2882	m = NULL;
2883	goto out;
2884	}
2885	}
2886	}	2871	}
2887	*skip = 0;	2872
		2873	m = ceph_msg_get(req->r_reply);
2888	dout("get_reply tid %lld %p\n", tid, m);	2874	dout("get_reply tid %lld %p\n", tid, m);
2889		2875
2890	out:	2876	out:
2891	mutex_unlock(&osdc->request_mutex);	2877	mutex_unlock(&osdc->request_mutex);
2892	return m;	2878	return m;
2893
2894	}	2879	}
2895		2880
2896	static struct ceph_msg alloc_msg(struct ceph_connection con,	2881	static struct ceph_msg alloc_msg(struct ceph_connection con,

net/ceph/osdmap.c+1−1

@@ -1300,7 +1300,7 @@ struct ceph_osdmap osdmap_apply_incremental(void p, void end, · 1299 unmodified lines
1300	ceph_decode_addr(&addr);	1300	ceph_decode_addr(&addr);
1301	pr_info("osd%d up\n", osd);	1301	pr_info("osd%d up\n", osd);
1302	BUG_ON(osd >= map->max_osd);	1302	BUG_ON(osd >= map->max_osd);
1303	map->osd_state[osd] \|= CEPH_OSD_UP;	1303	map->osd_state[osd] \|= CEPH_OSD_UP \| CEPH_OSD_EXISTS;
1304	map->osd_addr[osd] = addr;	1304	map->osd_addr[osd] = addr;
1305	}	1305	}
1306		1306