2010-04-07 00:14:15 +02:00
|
|
|
#include <linux/ceph/ceph_debug.h>
|
2009-10-06 20:31:10 +02:00
|
|
|
|
2010-04-07 00:14:15 +02:00
|
|
|
#include <linux/module.h>
|
2009-10-06 20:31:10 +02:00
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/highmem.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/pagemap.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/uaccess.h>
|
2010-04-07 00:01:27 +02:00
|
|
|
#ifdef CONFIG_BLOCK
|
|
|
|
#include <linux/bio.h>
|
|
|
|
#endif
|
2009-10-06 20:31:10 +02:00
|
|
|
|
2010-04-07 00:14:15 +02:00
|
|
|
#include <linux/ceph/libceph.h>
|
|
|
|
#include <linux/ceph/osd_client.h>
|
|
|
|
#include <linux/ceph/messenger.h>
|
|
|
|
#include <linux/ceph/decode.h>
|
|
|
|
#include <linux/ceph/auth.h>
|
|
|
|
#include <linux/ceph/pagelist.h>
|
2009-10-06 20:31:10 +02:00
|
|
|
|
2010-03-01 22:02:00 +01:00
|
|
|
#define OSD_OP_FRONT_LEN 4096
|
|
|
|
#define OSD_OPREPLY_FRONT_LEN 512
|
2010-01-14 02:03:23 +01:00
|
|
|
|
2010-05-20 10:40:19 +02:00
|
|
|
static const struct ceph_connection_operations osd_con_ops;
|
2009-10-06 20:31:10 +02:00
|
|
|
|
2013-02-15 18:42:29 +01:00
|
|
|
static void __send_queued(struct ceph_osd_client *osdc);
|
2011-01-18 05:34:08 +01:00
|
|
|
static int __reset_osd(struct ceph_osd_client *osdc, struct ceph_osd *osd);
|
2011-03-21 23:07:16 +01:00
|
|
|
static void __register_request(struct ceph_osd_client *osdc,
|
|
|
|
struct ceph_osd_request *req);
|
|
|
|
static void __unregister_linger_request(struct ceph_osd_client *osdc,
|
|
|
|
struct ceph_osd_request *req);
|
2012-01-03 21:34:34 +01:00
|
|
|
static void __send_request(struct ceph_osd_client *osdc,
|
|
|
|
struct ceph_osd_request *req);
|
2009-10-06 20:31:10 +02:00
|
|
|
|
2010-04-07 00:01:27 +02:00
|
|
|
static int op_has_extent(int op)
|
|
|
|
{
|
|
|
|
return (op == CEPH_OSD_OP_READ ||
|
|
|
|
op == CEPH_OSD_OP_WRITE);
|
|
|
|
}
|
|
|
|
|
2009-10-06 20:31:10 +02:00
|
|
|
/*
|
|
|
|
* Implement client access to distributed object storage cluster.
|
|
|
|
*
|
|
|
|
* All data objects are stored within a cluster/cloud of OSDs, or
|
|
|
|
* "object storage devices." (Note that Ceph OSDs have _nothing_ to
|
|
|
|
* do with the T10 OSD extensions to SCSI.) Ceph OSDs are simply
|
|
|
|
* remote daemons serving up and coordinating consistent and safe
|
|
|
|
* access to storage.
|
|
|
|
*
|
|
|
|
* Cluster membership and the mapping of data objects onto storage devices
|
|
|
|
* are described by the osd map.
|
|
|
|
*
|
|
|
|
* We keep track of pending OSD requests (read, write), resubmit
|
|
|
|
* requests to different OSDs when the cluster topology/data layout
|
|
|
|
* change, or retry the affected requests when the communications
|
|
|
|
* channel with an OSD is reset.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* calculate the mapping of a file extent onto an object, and fill out the
|
|
|
|
* request accordingly. shorten extent as necessary if it crosses an
|
|
|
|
* object boundary.
|
|
|
|
*
|
|
|
|
* fill osd op in request message.
|
|
|
|
*/
|
2013-02-16 05:10:17 +01:00
|
|
|
static int calc_layout(struct ceph_file_layout *layout, u64 off, u64 *plen,
|
2013-02-16 05:10:17 +01:00
|
|
|
struct ceph_osd_req_op *op, u64 *bno)
|
2009-10-06 20:31:10 +02:00
|
|
|
{
|
2013-02-15 18:42:29 +01:00
|
|
|
u64 orig_len = *plen;
|
|
|
|
u64 objoff = 0;
|
|
|
|
u64 objlen = 0;
|
2012-09-25 05:59:48 +02:00
|
|
|
int r;
|
2009-10-06 20:31:10 +02:00
|
|
|
|
2013-02-15 18:42:29 +01:00
|
|
|
/* object extent? */
|
2013-02-16 05:10:17 +01:00
|
|
|
r = ceph_calc_file_object_mapping(layout, off, orig_len, bno,
|
2013-02-15 18:42:29 +01:00
|
|
|
&objoff, &objlen);
|
2012-09-25 05:59:48 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2013-02-15 18:42:29 +01:00
|
|
|
if (objlen < orig_len) {
|
|
|
|
*plen = objlen;
|
|
|
|
dout(" skipping last %llu, final file extent %llu~%llu\n",
|
|
|
|
orig_len - *plen, off, *plen);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (op_has_extent(op->op)) {
|
|
|
|
u32 osize = le32_to_cpu(layout->fl_object_size);
|
|
|
|
op->extent.offset = objoff;
|
|
|
|
op->extent.length = objlen;
|
|
|
|
if (op->extent.truncate_size <= off - objoff) {
|
|
|
|
op->extent.truncate_size = 0;
|
|
|
|
} else {
|
|
|
|
op->extent.truncate_size -= off - objoff;
|
|
|
|
if (op->extent.truncate_size > osize)
|
|
|
|
op->extent.truncate_size = osize;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (op->op == CEPH_OSD_OP_WRITE)
|
|
|
|
op->payload_len = *plen;
|
|
|
|
|
2013-02-16 05:10:17 +01:00
|
|
|
dout("calc_layout bno=%llx %llu~%llu\n", *bno, objoff, objlen);
|
2009-10-06 20:31:10 +02:00
|
|
|
|
2013-02-16 05:10:17 +01:00
|
|
|
return 0;
|
2009-10-06 20:31:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* requests
|
|
|
|
*/
|
2009-12-07 22:37:03 +01:00
|
|
|
void ceph_osdc_release_request(struct kref *kref)
|
2009-10-06 20:31:10 +02:00
|
|
|
{
|
2009-12-07 22:37:03 +01:00
|
|
|
struct ceph_osd_request *req = container_of(kref,
|
|
|
|
struct ceph_osd_request,
|
|
|
|
r_kref);
|
|
|
|
|
|
|
|
if (req->r_request)
|
|
|
|
ceph_msg_put(req->r_request);
|
2010-01-14 02:03:23 +01:00
|
|
|
if (req->r_con_filling_msg) {
|
2013-01-31 23:02:00 +01:00
|
|
|
dout("%s revoking msg %p from con %p\n", __func__,
|
|
|
|
req->r_reply, req->r_con_filling_msg);
|
2012-06-01 21:56:43 +02:00
|
|
|
ceph_msg_revoke_incoming(req->r_reply);
|
2012-06-01 05:22:18 +02:00
|
|
|
req->r_con_filling_msg->ops->put(req->r_con_filling_msg);
|
2013-01-31 23:02:00 +01:00
|
|
|
req->r_con_filling_msg = NULL;
|
2009-12-22 19:45:45 +01:00
|
|
|
}
|
2012-06-04 21:43:32 +02:00
|
|
|
if (req->r_reply)
|
|
|
|
ceph_msg_put(req->r_reply);
|
2009-12-07 22:37:03 +01:00
|
|
|
if (req->r_own_pages)
|
|
|
|
ceph_release_page_vector(req->r_pages,
|
|
|
|
req->r_num_pages);
|
|
|
|
ceph_put_snap_context(req->r_snapc);
|
2012-11-14 04:11:15 +01:00
|
|
|
ceph_pagelist_release(&req->r_trail);
|
2009-12-07 22:37:03 +01:00
|
|
|
if (req->r_mempool)
|
|
|
|
mempool_free(req, req->r_osdc->req_mempool);
|
|
|
|
else
|
|
|
|
kfree(req);
|
2009-10-06 20:31:10 +02:00
|
|
|
}
|
2010-04-07 00:14:15 +02:00
|
|
|
EXPORT_SYMBOL(ceph_osdc_release_request);
|
2010-04-07 00:01:27 +02:00
|
|
|
|
2010-04-06 23:51:47 +02:00
|
|
|
struct ceph_osd_request *ceph_osdc_alloc_request(struct ceph_osd_client *osdc,
|
2009-10-06 20:31:10 +02:00
|
|
|
struct ceph_snap_context *snapc,
|
2013-02-26 01:11:12 +01:00
|
|
|
unsigned int num_ops,
|
2010-04-06 23:51:47 +02:00
|
|
|
bool use_mempool,
|
2012-11-14 04:11:15 +01:00
|
|
|
gfp_t gfp_flags)
|
2009-10-06 20:31:10 +02:00
|
|
|
{
|
|
|
|
struct ceph_osd_request *req;
|
|
|
|
struct ceph_msg *msg;
|
2013-02-26 01:11:12 +01:00
|
|
|
size_t msg_size;
|
|
|
|
|
|
|
|
msg_size = 4 + 4 + 8 + 8 + 4+8;
|
|
|
|
msg_size += 2 + 4 + 8 + 4 + 4; /* oloc */
|
|
|
|
msg_size += 1 + 8 + 4 + 4; /* pg_t */
|
|
|
|
msg_size += 4 + MAX_OBJ_NAME_SIZE;
|
|
|
|
msg_size += 2 + num_ops*sizeof(struct ceph_osd_op);
|
|
|
|
msg_size += 8; /* snapid */
|
|
|
|
msg_size += 8; /* snap_seq */
|
|
|
|
msg_size += 8 * (snapc ? snapc->num_snaps : 0); /* snaps */
|
|
|
|
msg_size += 4;
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
if (use_mempool) {
|
2010-04-06 23:51:47 +02:00
|
|
|
req = mempool_alloc(osdc->req_mempool, gfp_flags);
|
2009-10-06 20:31:10 +02:00
|
|
|
memset(req, 0, sizeof(*req));
|
|
|
|
} else {
|
2010-04-06 23:51:47 +02:00
|
|
|
req = kzalloc(sizeof(*req), gfp_flags);
|
2009-10-06 20:31:10 +02:00
|
|
|
}
|
|
|
|
if (req == NULL)
|
2010-04-02 01:06:19 +02:00
|
|
|
return NULL;
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
req->r_osdc = osdc;
|
|
|
|
req->r_mempool = use_mempool;
|
2010-04-07 00:01:27 +02:00
|
|
|
|
2009-12-07 22:37:03 +01:00
|
|
|
kref_init(&req->r_kref);
|
2009-10-06 20:31:10 +02:00
|
|
|
init_completion(&req->r_completion);
|
|
|
|
init_completion(&req->r_safe_completion);
|
2012-12-17 19:23:48 +01:00
|
|
|
RB_CLEAR_NODE(&req->r_node);
|
2009-10-06 20:31:10 +02:00
|
|
|
INIT_LIST_HEAD(&req->r_unsafe_item);
|
2011-03-21 23:07:16 +01:00
|
|
|
INIT_LIST_HEAD(&req->r_linger_item);
|
|
|
|
INIT_LIST_HEAD(&req->r_linger_osd);
|
2011-09-16 20:13:17 +02:00
|
|
|
INIT_LIST_HEAD(&req->r_req_lru_item);
|
2012-07-09 23:31:41 +02:00
|
|
|
INIT_LIST_HEAD(&req->r_osd_item);
|
|
|
|
|
2010-03-01 22:02:00 +01:00
|
|
|
/* create reply message */
|
|
|
|
if (use_mempool)
|
|
|
|
msg = ceph_msgpool_get(&osdc->msgpool_op_reply, 0);
|
|
|
|
else
|
|
|
|
msg = ceph_msg_new(CEPH_MSG_OSD_OPREPLY,
|
2011-08-10 00:03:46 +02:00
|
|
|
OSD_OPREPLY_FRONT_LEN, gfp_flags, true);
|
2010-04-02 01:06:19 +02:00
|
|
|
if (!msg) {
|
2010-03-01 22:02:00 +01:00
|
|
|
ceph_osdc_put_request(req);
|
2010-04-02 01:06:19 +02:00
|
|
|
return NULL;
|
2010-03-01 22:02:00 +01:00
|
|
|
}
|
|
|
|
req->r_reply = msg;
|
|
|
|
|
2012-11-14 04:11:15 +01:00
|
|
|
ceph_pagelist_init(&req->r_trail);
|
2012-07-09 23:22:34 +02:00
|
|
|
|
2010-03-01 22:02:00 +01:00
|
|
|
/* create request message; allow space for oid */
|
2009-10-06 20:31:10 +02:00
|
|
|
if (use_mempool)
|
2009-10-15 02:36:07 +02:00
|
|
|
msg = ceph_msgpool_get(&osdc->msgpool_op, 0);
|
2009-10-06 20:31:10 +02:00
|
|
|
else
|
2011-08-10 00:03:46 +02:00
|
|
|
msg = ceph_msg_new(CEPH_MSG_OSD_OP, msg_size, gfp_flags, true);
|
2010-04-02 01:06:19 +02:00
|
|
|
if (!msg) {
|
2009-10-06 20:31:10 +02:00
|
|
|
ceph_osdc_put_request(req);
|
2010-04-02 01:06:19 +02:00
|
|
|
return NULL;
|
2009-10-06 20:31:10 +02:00
|
|
|
}
|
2010-04-07 00:01:27 +02:00
|
|
|
|
2009-10-06 20:31:10 +02:00
|
|
|
memset(msg->front.iov_base, 0, msg->front.iov_len);
|
2010-04-06 23:51:47 +02:00
|
|
|
|
|
|
|
req->r_request = msg;
|
|
|
|
|
|
|
|
return req;
|
|
|
|
}
|
2010-04-07 00:14:15 +02:00
|
|
|
EXPORT_SYMBOL(ceph_osdc_alloc_request);
|
2010-04-06 23:51:47 +02:00
|
|
|
|
2010-04-07 00:01:27 +02:00
|
|
|
static void osd_req_encode_op(struct ceph_osd_request *req,
|
|
|
|
struct ceph_osd_op *dst,
|
|
|
|
struct ceph_osd_req_op *src)
|
|
|
|
{
|
|
|
|
dst->op = cpu_to_le16(src->op);
|
|
|
|
|
2012-04-20 22:49:43 +02:00
|
|
|
switch (src->op) {
|
2013-02-08 16:55:48 +01:00
|
|
|
case CEPH_OSD_OP_STAT:
|
|
|
|
break;
|
2010-04-07 00:01:27 +02:00
|
|
|
case CEPH_OSD_OP_READ:
|
|
|
|
case CEPH_OSD_OP_WRITE:
|
|
|
|
dst->extent.offset =
|
|
|
|
cpu_to_le64(src->extent.offset);
|
|
|
|
dst->extent.length =
|
|
|
|
cpu_to_le64(src->extent.length);
|
|
|
|
dst->extent.truncate_size =
|
|
|
|
cpu_to_le64(src->extent.truncate_size);
|
|
|
|
dst->extent.truncate_seq =
|
|
|
|
cpu_to_le32(src->extent.truncate_seq);
|
|
|
|
break;
|
2010-05-19 01:38:08 +02:00
|
|
|
case CEPH_OSD_OP_CALL:
|
|
|
|
dst->cls.class_len = src->cls.class_len;
|
|
|
|
dst->cls.method_len = src->cls.method_len;
|
|
|
|
dst->cls.indata_len = cpu_to_le32(src->cls.indata_len);
|
|
|
|
|
2012-11-14 04:11:15 +01:00
|
|
|
ceph_pagelist_append(&req->r_trail, src->cls.class_name,
|
2010-05-19 01:38:08 +02:00
|
|
|
src->cls.class_len);
|
2012-11-14 04:11:15 +01:00
|
|
|
ceph_pagelist_append(&req->r_trail, src->cls.method_name,
|
2010-05-19 01:38:08 +02:00
|
|
|
src->cls.method_len);
|
2012-11-14 04:11:15 +01:00
|
|
|
ceph_pagelist_append(&req->r_trail, src->cls.indata,
|
2010-05-19 01:38:08 +02:00
|
|
|
src->cls.indata_len);
|
|
|
|
break;
|
2010-04-07 00:01:27 +02:00
|
|
|
case CEPH_OSD_OP_STARTSYNC:
|
|
|
|
break;
|
2011-03-21 23:07:16 +01:00
|
|
|
case CEPH_OSD_OP_NOTIFY_ACK:
|
|
|
|
case CEPH_OSD_OP_WATCH:
|
|
|
|
dst->watch.cookie = cpu_to_le64(src->watch.cookie);
|
|
|
|
dst->watch.ver = cpu_to_le64(src->watch.ver);
|
|
|
|
dst->watch.flag = src->watch.flag;
|
|
|
|
break;
|
2010-04-07 00:01:27 +02:00
|
|
|
default:
|
|
|
|
pr_err("unrecognized osd opcode %d\n", dst->op);
|
|
|
|
WARN_ON(1);
|
|
|
|
break;
|
2013-02-15 18:42:30 +01:00
|
|
|
case CEPH_OSD_OP_MAPEXT:
|
|
|
|
case CEPH_OSD_OP_MASKTRUNC:
|
|
|
|
case CEPH_OSD_OP_SPARSE_READ:
|
2013-02-15 18:42:30 +01:00
|
|
|
case CEPH_OSD_OP_NOTIFY:
|
2013-02-15 18:42:30 +01:00
|
|
|
case CEPH_OSD_OP_ASSERT_VER:
|
|
|
|
case CEPH_OSD_OP_WRITEFULL:
|
|
|
|
case CEPH_OSD_OP_TRUNCATE:
|
|
|
|
case CEPH_OSD_OP_ZERO:
|
|
|
|
case CEPH_OSD_OP_DELETE:
|
|
|
|
case CEPH_OSD_OP_APPEND:
|
|
|
|
case CEPH_OSD_OP_SETTRUNC:
|
|
|
|
case CEPH_OSD_OP_TRIMTRUNC:
|
|
|
|
case CEPH_OSD_OP_TMAPUP:
|
|
|
|
case CEPH_OSD_OP_TMAPPUT:
|
|
|
|
case CEPH_OSD_OP_TMAPGET:
|
|
|
|
case CEPH_OSD_OP_CREATE:
|
2013-02-15 18:42:30 +01:00
|
|
|
case CEPH_OSD_OP_ROLLBACK:
|
2013-02-15 18:42:30 +01:00
|
|
|
case CEPH_OSD_OP_OMAPGETKEYS:
|
|
|
|
case CEPH_OSD_OP_OMAPGETVALS:
|
|
|
|
case CEPH_OSD_OP_OMAPGETHEADER:
|
|
|
|
case CEPH_OSD_OP_OMAPGETVALSBYKEYS:
|
|
|
|
case CEPH_OSD_OP_MODE_RD:
|
|
|
|
case CEPH_OSD_OP_OMAPSETVALS:
|
|
|
|
case CEPH_OSD_OP_OMAPSETHEADER:
|
|
|
|
case CEPH_OSD_OP_OMAPCLEAR:
|
|
|
|
case CEPH_OSD_OP_OMAPRMKEYS:
|
|
|
|
case CEPH_OSD_OP_OMAP_CMP:
|
|
|
|
case CEPH_OSD_OP_CLONERANGE:
|
|
|
|
case CEPH_OSD_OP_ASSERT_SRC_VERSION:
|
|
|
|
case CEPH_OSD_OP_SRC_CMPXATTR:
|
2013-02-15 18:42:30 +01:00
|
|
|
case CEPH_OSD_OP_GETXATTR:
|
2013-02-15 18:42:30 +01:00
|
|
|
case CEPH_OSD_OP_GETXATTRS:
|
2013-02-15 18:42:30 +01:00
|
|
|
case CEPH_OSD_OP_CMPXATTR:
|
|
|
|
case CEPH_OSD_OP_SETXATTR:
|
2013-02-15 18:42:30 +01:00
|
|
|
case CEPH_OSD_OP_SETXATTRS:
|
|
|
|
case CEPH_OSD_OP_RESETXATTRS:
|
|
|
|
case CEPH_OSD_OP_RMXATTR:
|
|
|
|
case CEPH_OSD_OP_PULL:
|
|
|
|
case CEPH_OSD_OP_PUSH:
|
|
|
|
case CEPH_OSD_OP_BALANCEREADS:
|
|
|
|
case CEPH_OSD_OP_UNBALANCEREADS:
|
|
|
|
case CEPH_OSD_OP_SCRUB:
|
|
|
|
case CEPH_OSD_OP_SCRUB_RESERVE:
|
|
|
|
case CEPH_OSD_OP_SCRUB_UNRESERVE:
|
|
|
|
case CEPH_OSD_OP_SCRUB_STOP:
|
|
|
|
case CEPH_OSD_OP_SCRUB_MAP:
|
|
|
|
case CEPH_OSD_OP_WRLOCK:
|
|
|
|
case CEPH_OSD_OP_WRUNLOCK:
|
|
|
|
case CEPH_OSD_OP_RDLOCK:
|
|
|
|
case CEPH_OSD_OP_RDUNLOCK:
|
|
|
|
case CEPH_OSD_OP_UPLOCK:
|
|
|
|
case CEPH_OSD_OP_DNLOCK:
|
|
|
|
case CEPH_OSD_OP_PGLS:
|
|
|
|
case CEPH_OSD_OP_PGLS_FILTER:
|
|
|
|
pr_err("unsupported osd opcode %s\n",
|
|
|
|
ceph_osd_op_name(dst->op));
|
|
|
|
WARN_ON(1);
|
|
|
|
break;
|
2010-04-07 00:01:27 +02:00
|
|
|
}
|
|
|
|
dst->payload_len = cpu_to_le32(src->payload_len);
|
|
|
|
}
|
|
|
|
|
2010-04-06 23:51:47 +02:00
|
|
|
/*
|
|
|
|
* build new request AND message
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void ceph_osdc_build_request(struct ceph_osd_request *req,
|
2013-02-26 01:11:12 +01:00
|
|
|
u64 off, u64 len, unsigned int num_ops,
|
2010-04-07 00:01:27 +02:00
|
|
|
struct ceph_osd_req_op *src_ops,
|
2012-11-14 04:11:15 +01:00
|
|
|
struct ceph_snap_context *snapc, u64 snap_id,
|
2012-11-09 15:43:15 +01:00
|
|
|
struct timespec *mtime)
|
2010-04-06 23:51:47 +02:00
|
|
|
{
|
|
|
|
struct ceph_msg *msg = req->r_request;
|
2010-04-07 00:01:27 +02:00
|
|
|
struct ceph_osd_req_op *src_op;
|
2010-04-06 23:51:47 +02:00
|
|
|
void *p;
|
2013-02-26 01:11:12 +01:00
|
|
|
size_t msg_size;
|
2010-04-06 23:51:47 +02:00
|
|
|
int flags = req->r_flags;
|
2013-02-14 19:16:43 +01:00
|
|
|
u64 data_len;
|
2010-04-07 00:01:27 +02:00
|
|
|
int i;
|
2010-04-06 23:51:47 +02:00
|
|
|
|
2013-02-26 01:11:12 +01:00
|
|
|
req->r_num_ops = num_ops;
|
|
|
|
req->r_snapid = snap_id;
|
2009-10-06 20:31:10 +02:00
|
|
|
req->r_snapc = ceph_get_snap_context(snapc);
|
|
|
|
|
2013-02-26 01:11:12 +01:00
|
|
|
/* encode request */
|
|
|
|
msg->hdr.version = cpu_to_le16(4);
|
|
|
|
|
|
|
|
p = msg->front.iov_base;
|
|
|
|
ceph_encode_32(&p, 1); /* client_inc is always 1 */
|
|
|
|
req->r_request_osdmap_epoch = p;
|
|
|
|
p += 4;
|
|
|
|
req->r_request_flags = p;
|
|
|
|
p += 4;
|
|
|
|
if (req->r_flags & CEPH_OSD_FLAG_WRITE)
|
|
|
|
ceph_encode_timespec(p, mtime);
|
|
|
|
p += sizeof(struct ceph_timespec);
|
|
|
|
req->r_request_reassert_version = p;
|
|
|
|
p += sizeof(struct ceph_eversion); /* will get filled in */
|
|
|
|
|
|
|
|
/* oloc */
|
|
|
|
ceph_encode_8(&p, 4);
|
|
|
|
ceph_encode_8(&p, 4);
|
|
|
|
ceph_encode_32(&p, 8 + 4 + 4);
|
|
|
|
req->r_request_pool = p;
|
|
|
|
p += 8;
|
|
|
|
ceph_encode_32(&p, -1); /* preferred */
|
|
|
|
ceph_encode_32(&p, 0); /* key len */
|
|
|
|
|
|
|
|
ceph_encode_8(&p, 1);
|
|
|
|
req->r_request_pgid = p;
|
|
|
|
p += 8 + 4;
|
|
|
|
ceph_encode_32(&p, -1); /* preferred */
|
|
|
|
|
|
|
|
/* oid */
|
|
|
|
ceph_encode_32(&p, req->r_oid_len);
|
2012-11-09 15:43:15 +01:00
|
|
|
memcpy(p, req->r_oid, req->r_oid_len);
|
2013-02-26 01:11:12 +01:00
|
|
|
dout("oid '%.*s' len %d\n", req->r_oid_len, req->r_oid, req->r_oid_len);
|
2012-11-09 15:43:15 +01:00
|
|
|
p += req->r_oid_len;
|
2009-10-06 20:31:10 +02:00
|
|
|
|
2013-02-26 01:11:12 +01:00
|
|
|
/* ops */
|
|
|
|
ceph_encode_16(&p, num_ops);
|
2010-04-07 00:01:27 +02:00
|
|
|
src_op = src_ops;
|
2013-02-26 01:11:12 +01:00
|
|
|
req->r_request_ops = p;
|
|
|
|
for (i = 0; i < num_ops; i++, src_op++) {
|
|
|
|
osd_req_encode_op(req, p, src_op);
|
|
|
|
p += sizeof(struct ceph_osd_op);
|
|
|
|
}
|
2010-04-07 00:01:27 +02:00
|
|
|
|
2013-02-26 01:11:12 +01:00
|
|
|
/* snaps */
|
|
|
|
ceph_encode_64(&p, req->r_snapid);
|
|
|
|
ceph_encode_64(&p, req->r_snapc ? req->r_snapc->seq : 0);
|
|
|
|
ceph_encode_32(&p, req->r_snapc ? req->r_snapc->num_snaps : 0);
|
|
|
|
if (req->r_snapc) {
|
2009-10-06 20:31:10 +02:00
|
|
|
for (i = 0; i < snapc->num_snaps; i++) {
|
2013-02-26 01:11:12 +01:00
|
|
|
ceph_encode_64(&p, req->r_snapc->snaps[i]);
|
2009-10-06 20:31:10 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-26 01:11:12 +01:00
|
|
|
req->r_request_attempts = p;
|
|
|
|
p += 4;
|
|
|
|
|
2013-02-14 19:16:43 +01:00
|
|
|
data_len = req->r_trail.length;
|
2010-04-07 00:01:27 +02:00
|
|
|
if (flags & CEPH_OSD_FLAG_WRITE) {
|
|
|
|
req->r_request->hdr.data_off = cpu_to_le16(off);
|
2013-02-14 19:16:43 +01:00
|
|
|
data_len += len;
|
2010-04-07 00:01:27 +02:00
|
|
|
}
|
2013-02-14 19:16:43 +01:00
|
|
|
req->r_request->hdr.data_len = cpu_to_le32(data_len);
|
2010-11-09 21:40:00 +01:00
|
|
|
|
2009-10-06 20:31:10 +02:00
|
|
|
BUG_ON(p > msg->front.iov_base + msg->front.iov_len);
|
2010-03-02 00:26:41 +01:00
|
|
|
msg_size = p - msg->front.iov_base;
|
|
|
|
msg->front.iov_len = msg_size;
|
|
|
|
msg->hdr.front_len = cpu_to_le32(msg_size);
|
2013-02-26 01:11:12 +01:00
|
|
|
|
|
|
|
dout("build_request msg_size was %d num_ops %d\n", (int)msg_size,
|
|
|
|
num_ops);
|
2010-04-06 23:51:47 +02:00
|
|
|
return;
|
|
|
|
}
|
2010-04-07 00:14:15 +02:00
|
|
|
EXPORT_SYMBOL(ceph_osdc_build_request);
|
2010-04-06 23:51:47 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* build new request AND message, calculate layout, and adjust file
|
|
|
|
* extent as needed.
|
|
|
|
*
|
|
|
|
* if the file was recently truncated, we include information about its
|
|
|
|
* old and new size so that the object can be updated appropriately. (we
|
|
|
|
* avoid synchronously deleting truncated objects because it's slow.)
|
|
|
|
*
|
|
|
|
* if @do_sync, include a 'startsync' command so that the osd will flush
|
|
|
|
* data quickly.
|
|
|
|
*/
|
|
|
|
struct ceph_osd_request *ceph_osdc_new_request(struct ceph_osd_client *osdc,
|
|
|
|
struct ceph_file_layout *layout,
|
|
|
|
struct ceph_vino vino,
|
|
|
|
u64 off, u64 *plen,
|
|
|
|
int opcode, int flags,
|
|
|
|
struct ceph_snap_context *snapc,
|
|
|
|
int do_sync,
|
|
|
|
u32 truncate_seq,
|
|
|
|
u64 truncate_size,
|
|
|
|
struct timespec *mtime,
|
2013-02-15 18:42:29 +01:00
|
|
|
bool use_mempool,
|
2010-11-09 21:43:12 +01:00
|
|
|
int page_align)
|
2010-04-06 23:51:47 +02:00
|
|
|
{
|
2012-11-14 04:11:15 +01:00
|
|
|
struct ceph_osd_req_op ops[2];
|
2010-04-07 00:01:27 +02:00
|
|
|
struct ceph_osd_request *req;
|
2012-11-14 04:11:15 +01:00
|
|
|
unsigned int num_op = 1;
|
2013-02-16 05:10:17 +01:00
|
|
|
u64 bno = 0;
|
2012-09-25 06:01:02 +02:00
|
|
|
int r;
|
2010-04-07 00:01:27 +02:00
|
|
|
|
2012-11-14 04:11:15 +01:00
|
|
|
memset(&ops, 0, sizeof ops);
|
|
|
|
|
2010-04-07 00:01:27 +02:00
|
|
|
ops[0].op = opcode;
|
|
|
|
ops[0].extent.truncate_seq = truncate_seq;
|
|
|
|
ops[0].extent.truncate_size = truncate_size;
|
|
|
|
|
|
|
|
if (do_sync) {
|
|
|
|
ops[1].op = CEPH_OSD_OP_STARTSYNC;
|
2012-11-14 04:11:15 +01:00
|
|
|
num_op++;
|
|
|
|
}
|
2010-04-07 00:01:27 +02:00
|
|
|
|
2012-11-14 04:11:15 +01:00
|
|
|
req = ceph_osdc_alloc_request(osdc, snapc, num_op, use_mempool,
|
|
|
|
GFP_NOFS);
|
2011-05-03 18:23:36 +02:00
|
|
|
if (!req)
|
2012-09-25 06:01:02 +02:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2012-11-14 04:11:15 +01:00
|
|
|
req->r_flags = flags;
|
2010-04-06 23:51:47 +02:00
|
|
|
|
|
|
|
/* calculate max write size */
|
2013-02-16 05:10:17 +01:00
|
|
|
r = calc_layout(layout, off, plen, ops, &bno);
|
2013-02-16 05:10:17 +01:00
|
|
|
if (r < 0) {
|
|
|
|
ceph_osdc_put_request(req);
|
2012-09-25 06:01:02 +02:00
|
|
|
return ERR_PTR(r);
|
2013-02-16 05:10:17 +01:00
|
|
|
}
|
2013-02-16 05:10:17 +01:00
|
|
|
|
2010-04-06 23:51:47 +02:00
|
|
|
req->r_file_layout = *layout; /* keep a copy */
|
|
|
|
|
2013-02-16 05:10:17 +01:00
|
|
|
snprintf(req->r_oid, sizeof(req->r_oid), "%llx.%08llx", vino.ino, bno);
|
|
|
|
req->r_oid_len = strlen(req->r_oid);
|
|
|
|
|
2013-02-16 05:10:17 +01:00
|
|
|
/* The alignment may differ from the natural (file) alignment */
|
|
|
|
|
2011-06-14 01:20:18 +02:00
|
|
|
req->r_num_pages = calc_pages_for(page_align, *plen);
|
2010-11-09 21:43:12 +01:00
|
|
|
req->r_page_alignment = page_align;
|
|
|
|
|
2012-11-14 04:11:15 +01:00
|
|
|
ceph_osdc_build_request(req, off, *plen, num_op, ops,
|
|
|
|
snapc, vino.snap, mtime);
|
2010-04-06 23:51:47 +02:00
|
|
|
|
2009-10-06 20:31:10 +02:00
|
|
|
return req;
|
|
|
|
}
|
2010-04-07 00:14:15 +02:00
|
|
|
EXPORT_SYMBOL(ceph_osdc_new_request);
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We keep osd requests in an rbtree, sorted by ->r_tid.
|
|
|
|
*/
|
|
|
|
static void __insert_request(struct ceph_osd_client *osdc,
|
|
|
|
struct ceph_osd_request *new)
|
|
|
|
{
|
|
|
|
struct rb_node **p = &osdc->requests.rb_node;
|
|
|
|
struct rb_node *parent = NULL;
|
|
|
|
struct ceph_osd_request *req = NULL;
|
|
|
|
|
|
|
|
while (*p) {
|
|
|
|
parent = *p;
|
|
|
|
req = rb_entry(parent, struct ceph_osd_request, r_node);
|
|
|
|
if (new->r_tid < req->r_tid)
|
|
|
|
p = &(*p)->rb_left;
|
|
|
|
else if (new->r_tid > req->r_tid)
|
|
|
|
p = &(*p)->rb_right;
|
|
|
|
else
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
|
|
|
rb_link_node(&new->r_node, parent, p);
|
|
|
|
rb_insert_color(&new->r_node, &osdc->requests);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ceph_osd_request *__lookup_request(struct ceph_osd_client *osdc,
|
|
|
|
u64 tid)
|
|
|
|
{
|
|
|
|
struct ceph_osd_request *req;
|
|
|
|
struct rb_node *n = osdc->requests.rb_node;
|
|
|
|
|
|
|
|
while (n) {
|
|
|
|
req = rb_entry(n, struct ceph_osd_request, r_node);
|
|
|
|
if (tid < req->r_tid)
|
|
|
|
n = n->rb_left;
|
|
|
|
else if (tid > req->r_tid)
|
|
|
|
n = n->rb_right;
|
|
|
|
else
|
|
|
|
return req;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ceph_osd_request *
|
|
|
|
__lookup_request_ge(struct ceph_osd_client *osdc,
|
|
|
|
u64 tid)
|
|
|
|
{
|
|
|
|
struct ceph_osd_request *req;
|
|
|
|
struct rb_node *n = osdc->requests.rb_node;
|
|
|
|
|
|
|
|
while (n) {
|
|
|
|
req = rb_entry(n, struct ceph_osd_request, r_node);
|
|
|
|
if (tid < req->r_tid) {
|
|
|
|
if (!n->rb_left)
|
|
|
|
return req;
|
|
|
|
n = n->rb_left;
|
|
|
|
} else if (tid > req->r_tid) {
|
|
|
|
n = n->rb_right;
|
|
|
|
} else {
|
|
|
|
return req;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-01-18 05:34:08 +01:00
|
|
|
/*
|
|
|
|
* Resubmit requests pending on the given osd.
|
|
|
|
*/
|
|
|
|
static void __kick_osd_requests(struct ceph_osd_client *osdc,
|
|
|
|
struct ceph_osd *osd)
|
|
|
|
{
|
2011-03-21 23:07:16 +01:00
|
|
|
struct ceph_osd_request *req, *nreq;
|
2011-01-18 05:34:08 +01:00
|
|
|
int err;
|
|
|
|
|
|
|
|
dout("__kick_osd_requests osd%d\n", osd->o_osd);
|
|
|
|
err = __reset_osd(osdc, osd);
|
2012-12-07 16:57:58 +01:00
|
|
|
if (err)
|
2011-01-18 05:34:08 +01:00
|
|
|
return;
|
|
|
|
|
|
|
|
list_for_each_entry(req, &osd->o_requests, r_osd_item) {
|
|
|
|
list_move(&req->r_req_lru_item, &osdc->req_unsent);
|
|
|
|
dout("requeued %p tid %llu osd%d\n", req, req->r_tid,
|
|
|
|
osd->o_osd);
|
2011-03-21 23:07:16 +01:00
|
|
|
if (!req->r_linger)
|
|
|
|
req->r_flags |= CEPH_OSD_FLAG_RETRY;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry_safe(req, nreq, &osd->o_linger_requests,
|
|
|
|
r_linger_osd) {
|
2011-04-06 18:09:16 +02:00
|
|
|
/*
|
|
|
|
* reregister request prior to unregistering linger so
|
|
|
|
* that r_osd is preserved.
|
|
|
|
*/
|
|
|
|
BUG_ON(!list_empty(&req->r_req_lru_item));
|
2011-03-21 23:07:16 +01:00
|
|
|
__register_request(osdc, req);
|
2011-04-06 18:09:16 +02:00
|
|
|
list_add(&req->r_req_lru_item, &osdc->req_unsent);
|
|
|
|
list_add(&req->r_osd_item, &req->r_osd->o_requests);
|
|
|
|
__unregister_linger_request(osdc, req);
|
2011-03-21 23:07:16 +01:00
|
|
|
dout("requeued lingering %p tid %llu osd%d\n", req, req->r_tid,
|
|
|
|
osd->o_osd);
|
2011-01-18 05:34:08 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-06 20:31:10 +02:00
|
|
|
/*
|
2009-10-09 19:29:18 +02:00
|
|
|
* If the osd connection drops, we need to resubmit all requests.
|
2009-10-06 20:31:10 +02:00
|
|
|
*/
|
|
|
|
static void osd_reset(struct ceph_connection *con)
|
|
|
|
{
|
|
|
|
struct ceph_osd *osd = con->private;
|
|
|
|
struct ceph_osd_client *osdc;
|
|
|
|
|
|
|
|
if (!osd)
|
|
|
|
return;
|
|
|
|
dout("osd_reset osd%d\n", osd->o_osd);
|
|
|
|
osdc = osd->o_osdc;
|
|
|
|
down_read(&osdc->map_sem);
|
2012-11-28 21:28:24 +01:00
|
|
|
mutex_lock(&osdc->request_mutex);
|
|
|
|
__kick_osd_requests(osdc, osd);
|
2013-02-15 18:42:29 +01:00
|
|
|
__send_queued(osdc);
|
2012-11-28 21:28:24 +01:00
|
|
|
mutex_unlock(&osdc->request_mutex);
|
2009-10-06 20:31:10 +02:00
|
|
|
up_read(&osdc->map_sem);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Track open sessions with osds.
|
|
|
|
*/
|
2012-05-27 06:26:43 +02:00
|
|
|
static struct ceph_osd *create_osd(struct ceph_osd_client *osdc, int onum)
|
2009-10-06 20:31:10 +02:00
|
|
|
{
|
|
|
|
struct ceph_osd *osd;
|
|
|
|
|
|
|
|
osd = kzalloc(sizeof(*osd), GFP_NOFS);
|
|
|
|
if (!osd)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
atomic_set(&osd->o_ref, 1);
|
|
|
|
osd->o_osdc = osdc;
|
2012-05-27 06:26:43 +02:00
|
|
|
osd->o_osd = onum;
|
2012-12-06 14:22:04 +01:00
|
|
|
RB_CLEAR_NODE(&osd->o_node);
|
2009-10-06 20:31:10 +02:00
|
|
|
INIT_LIST_HEAD(&osd->o_requests);
|
2011-03-21 23:07:16 +01:00
|
|
|
INIT_LIST_HEAD(&osd->o_linger_requests);
|
2010-02-03 20:00:26 +01:00
|
|
|
INIT_LIST_HEAD(&osd->o_osd_lru);
|
2009-10-06 20:31:10 +02:00
|
|
|
osd->o_incarnation = 1;
|
|
|
|
|
2012-06-27 21:24:08 +02:00
|
|
|
ceph_con_init(&osd->o_con, osd, &osd_con_ops, &osdc->client->msgr);
|
2009-11-19 01:19:57 +01:00
|
|
|
|
2010-02-27 00:32:31 +01:00
|
|
|
INIT_LIST_HEAD(&osd->o_keepalive_item);
|
2009-10-06 20:31:10 +02:00
|
|
|
return osd;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ceph_osd *get_osd(struct ceph_osd *osd)
|
|
|
|
{
|
|
|
|
if (atomic_inc_not_zero(&osd->o_ref)) {
|
|
|
|
dout("get_osd %p %d -> %d\n", osd, atomic_read(&osd->o_ref)-1,
|
|
|
|
atomic_read(&osd->o_ref));
|
|
|
|
return osd;
|
|
|
|
} else {
|
|
|
|
dout("get_osd %p FAIL\n", osd);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void put_osd(struct ceph_osd *osd)
|
|
|
|
{
|
|
|
|
dout("put_osd %p %d -> %d\n", osd, atomic_read(&osd->o_ref),
|
|
|
|
atomic_read(&osd->o_ref) - 1);
|
2012-05-16 22:16:39 +02:00
|
|
|
if (atomic_dec_and_test(&osd->o_ref) && osd->o_auth.authorizer) {
|
2010-05-27 23:15:49 +02:00
|
|
|
struct ceph_auth_client *ac = osd->o_osdc->client->monc.auth;
|
|
|
|
|
2012-05-16 22:16:39 +02:00
|
|
|
if (ac->ops && ac->ops->destroy_authorizer)
|
2012-05-16 22:16:38 +02:00
|
|
|
ac->ops->destroy_authorizer(ac, osd->o_auth.authorizer);
|
2009-10-06 20:31:10 +02:00
|
|
|
kfree(osd);
|
2010-05-27 23:15:49 +02:00
|
|
|
}
|
2009-10-06 20:31:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* remove an osd from our map
|
|
|
|
*/
|
2010-02-03 20:00:26 +01:00
|
|
|
static void __remove_osd(struct ceph_osd_client *osdc, struct ceph_osd *osd)
|
2009-10-06 20:31:10 +02:00
|
|
|
{
|
2010-02-03 20:00:26 +01:00
|
|
|
dout("__remove_osd %p\n", osd);
|
2009-10-06 20:31:10 +02:00
|
|
|
BUG_ON(!list_empty(&osd->o_requests));
|
|
|
|
rb_erase(&osd->o_node, &osdc->osds);
|
2010-02-03 20:00:26 +01:00
|
|
|
list_del_init(&osd->o_osd_lru);
|
2009-10-06 20:31:10 +02:00
|
|
|
ceph_con_close(&osd->o_con);
|
|
|
|
put_osd(osd);
|
|
|
|
}
|
|
|
|
|
2011-08-31 23:45:53 +02:00
|
|
|
static void remove_all_osds(struct ceph_osd_client *osdc)
|
|
|
|
{
|
2012-07-20 15:18:36 +02:00
|
|
|
dout("%s %p\n", __func__, osdc);
|
2011-08-31 23:45:53 +02:00
|
|
|
mutex_lock(&osdc->request_mutex);
|
|
|
|
while (!RB_EMPTY_ROOT(&osdc->osds)) {
|
|
|
|
struct ceph_osd *osd = rb_entry(rb_first(&osdc->osds),
|
|
|
|
struct ceph_osd, o_node);
|
|
|
|
__remove_osd(osdc, osd);
|
|
|
|
}
|
|
|
|
mutex_unlock(&osdc->request_mutex);
|
|
|
|
}
|
|
|
|
|
2010-02-03 20:00:26 +01:00
|
|
|
static void __move_osd_to_lru(struct ceph_osd_client *osdc,
|
|
|
|
struct ceph_osd *osd)
|
|
|
|
{
|
|
|
|
dout("__move_osd_to_lru %p\n", osd);
|
|
|
|
BUG_ON(!list_empty(&osd->o_osd_lru));
|
|
|
|
list_add_tail(&osd->o_osd_lru, &osdc->osd_lru);
|
2010-04-07 00:14:15 +02:00
|
|
|
osd->lru_ttl = jiffies + osdc->client->options->osd_idle_ttl * HZ;
|
2010-02-03 20:00:26 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __remove_osd_from_lru(struct ceph_osd *osd)
|
|
|
|
{
|
|
|
|
dout("__remove_osd_from_lru %p\n", osd);
|
|
|
|
if (!list_empty(&osd->o_osd_lru))
|
|
|
|
list_del_init(&osd->o_osd_lru);
|
|
|
|
}
|
|
|
|
|
2011-08-31 23:45:53 +02:00
|
|
|
static void remove_old_osds(struct ceph_osd_client *osdc)
|
2010-02-03 20:00:26 +01:00
|
|
|
{
|
|
|
|
struct ceph_osd *osd, *nosd;
|
|
|
|
|
|
|
|
dout("__remove_old_osds %p\n", osdc);
|
|
|
|
mutex_lock(&osdc->request_mutex);
|
|
|
|
list_for_each_entry_safe(osd, nosd, &osdc->osd_lru, o_osd_lru) {
|
2011-08-31 23:45:53 +02:00
|
|
|
if (time_before(jiffies, osd->lru_ttl))
|
2010-02-03 20:00:26 +01:00
|
|
|
break;
|
|
|
|
__remove_osd(osdc, osd);
|
|
|
|
}
|
|
|
|
mutex_unlock(&osdc->request_mutex);
|
|
|
|
}
|
|
|
|
|
2009-10-06 20:31:10 +02:00
|
|
|
/*
|
|
|
|
* reset osd connect
|
|
|
|
*/
|
2010-02-03 20:00:26 +01:00
|
|
|
static int __reset_osd(struct ceph_osd_client *osdc, struct ceph_osd *osd)
|
2009-10-06 20:31:10 +02:00
|
|
|
{
|
2012-12-07 16:57:58 +01:00
|
|
|
struct ceph_entity_addr *peer_addr;
|
2009-10-06 20:31:10 +02:00
|
|
|
|
2010-02-03 20:00:26 +01:00
|
|
|
dout("__reset_osd %p osd%d\n", osd, osd->o_osd);
|
2011-03-21 23:07:16 +01:00
|
|
|
if (list_empty(&osd->o_requests) &&
|
|
|
|
list_empty(&osd->o_linger_requests)) {
|
2010-02-03 20:00:26 +01:00
|
|
|
__remove_osd(osdc, osd);
|
2012-12-07 16:57:58 +01:00
|
|
|
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
peer_addr = &osdc->osdmap->osd_addr[osd->o_osd];
|
|
|
|
if (!memcmp(peer_addr, &osd->o_con.peer_addr, sizeof (*peer_addr)) &&
|
|
|
|
!ceph_con_opened(&osd->o_con)) {
|
|
|
|
struct ceph_osd_request *req;
|
|
|
|
|
ceph: avoid reopening osd connections when address hasn't changed
We get a fault callback on _every_ tcp connection fault. Normally, we
want to reopen the connection when that happens. If the address we have
is bad, however, and connection attempts always result in a connection
refused or similar error, explicitly closing and reopening the msgr
connection just prevents the messenger's backoff logic from kicking in.
The result can be a console full of
[ 3974.417106] ceph: osd11 10.3.14.138:6800 connection failed
[ 3974.423295] ceph: osd11 10.3.14.138:6800 connection failed
[ 3974.429709] ceph: osd11 10.3.14.138:6800 connection failed
Instead, if we get a fault, and have outstanding requests, but the osd
address hasn't changed and the connection never successfully connected in
the first place, do nothing to the osd connection. The messenger layer
will back off and retry periodically, because we never connected and thus
the lossy bit is not set.
Instead, touch each request's r_stamp so that handle_timeout can tell the
request is still alive and kicking.
Signed-off-by: Sage Weil <sage@newdream.net>
2010-03-22 22:51:18 +01:00
|
|
|
dout(" osd addr hasn't changed and connection never opened,"
|
|
|
|
" letting msgr retry");
|
|
|
|
/* touch each r_stamp for handle_timeout()'s benfit */
|
|
|
|
list_for_each_entry(req, &osd->o_requests, r_osd_item)
|
|
|
|
req->r_stamp = jiffies;
|
2012-12-07 16:57:58 +01:00
|
|
|
|
|
|
|
return -EAGAIN;
|
2009-10-06 20:31:10 +02:00
|
|
|
}
|
2012-12-07 16:57:58 +01:00
|
|
|
|
|
|
|
ceph_con_close(&osd->o_con);
|
|
|
|
ceph_con_open(&osd->o_con, CEPH_ENTITY_TYPE_OSD, osd->o_osd, peer_addr);
|
|
|
|
osd->o_incarnation++;
|
|
|
|
|
|
|
|
return 0;
|
2009-10-06 20:31:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __insert_osd(struct ceph_osd_client *osdc, struct ceph_osd *new)
|
|
|
|
{
|
|
|
|
struct rb_node **p = &osdc->osds.rb_node;
|
|
|
|
struct rb_node *parent = NULL;
|
|
|
|
struct ceph_osd *osd = NULL;
|
|
|
|
|
2011-08-31 23:45:53 +02:00
|
|
|
dout("__insert_osd %p osd%d\n", new, new->o_osd);
|
2009-10-06 20:31:10 +02:00
|
|
|
while (*p) {
|
|
|
|
parent = *p;
|
|
|
|
osd = rb_entry(parent, struct ceph_osd, o_node);
|
|
|
|
if (new->o_osd < osd->o_osd)
|
|
|
|
p = &(*p)->rb_left;
|
|
|
|
else if (new->o_osd > osd->o_osd)
|
|
|
|
p = &(*p)->rb_right;
|
|
|
|
else
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
|
|
|
rb_link_node(&new->o_node, parent, p);
|
|
|
|
rb_insert_color(&new->o_node, &osdc->osds);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ceph_osd *__lookup_osd(struct ceph_osd_client *osdc, int o)
|
|
|
|
{
|
|
|
|
struct ceph_osd *osd;
|
|
|
|
struct rb_node *n = osdc->osds.rb_node;
|
|
|
|
|
|
|
|
while (n) {
|
|
|
|
osd = rb_entry(n, struct ceph_osd, o_node);
|
|
|
|
if (o < osd->o_osd)
|
|
|
|
n = n->rb_left;
|
|
|
|
else if (o > osd->o_osd)
|
|
|
|
n = n->rb_right;
|
|
|
|
else
|
|
|
|
return osd;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-02-27 00:32:31 +01:00
|
|
|
static void __schedule_osd_timeout(struct ceph_osd_client *osdc)
|
|
|
|
{
|
|
|
|
schedule_delayed_work(&osdc->timeout_work,
|
2010-04-07 00:14:15 +02:00
|
|
|
osdc->client->options->osd_keepalive_timeout * HZ);
|
2010-02-27 00:32:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __cancel_osd_timeout(struct ceph_osd_client *osdc)
|
|
|
|
{
|
|
|
|
cancel_delayed_work(&osdc->timeout_work);
|
|
|
|
}
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Register request, assign tid. If this is the first request, set up
|
|
|
|
* the timeout event.
|
|
|
|
*/
|
2011-03-21 23:07:16 +01:00
|
|
|
static void __register_request(struct ceph_osd_client *osdc,
|
|
|
|
struct ceph_osd_request *req)
|
2009-10-06 20:31:10 +02:00
|
|
|
{
|
|
|
|
req->r_tid = ++osdc->last_tid;
|
2009-12-22 20:24:33 +01:00
|
|
|
req->r_request->hdr.tid = cpu_to_le64(req->r_tid);
|
2011-04-06 18:09:16 +02:00
|
|
|
dout("__register_request %p tid %lld\n", req, req->r_tid);
|
2009-10-06 20:31:10 +02:00
|
|
|
__insert_request(osdc, req);
|
|
|
|
ceph_osdc_get_request(req);
|
|
|
|
osdc->num_requests++;
|
|
|
|
if (osdc->num_requests == 1) {
|
2010-02-27 00:32:31 +01:00
|
|
|
dout(" first request, scheduling timeout\n");
|
|
|
|
__schedule_osd_timeout(osdc);
|
2009-10-06 20:31:10 +02:00
|
|
|
}
|
2011-03-21 23:07:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void register_request(struct ceph_osd_client *osdc,
|
|
|
|
struct ceph_osd_request *req)
|
|
|
|
{
|
|
|
|
mutex_lock(&osdc->request_mutex);
|
|
|
|
__register_request(osdc, req);
|
2009-10-06 20:31:10 +02:00
|
|
|
mutex_unlock(&osdc->request_mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* called under osdc->request_mutex
|
|
|
|
*/
|
|
|
|
static void __unregister_request(struct ceph_osd_client *osdc,
|
|
|
|
struct ceph_osd_request *req)
|
|
|
|
{
|
2012-05-16 22:16:38 +02:00
|
|
|
if (RB_EMPTY_NODE(&req->r_node)) {
|
|
|
|
dout("__unregister_request %p tid %lld not registered\n",
|
|
|
|
req, req->r_tid);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-10-06 20:31:10 +02:00
|
|
|
dout("__unregister_request %p tid %lld\n", req, req->r_tid);
|
|
|
|
rb_erase(&req->r_node, &osdc->requests);
|
|
|
|
osdc->num_requests--;
|
|
|
|
|
2009-10-09 01:57:16 +02:00
|
|
|
if (req->r_osd) {
|
|
|
|
/* make sure the original request isn't in flight. */
|
2012-06-01 21:56:43 +02:00
|
|
|
ceph_msg_revoke(req->r_request);
|
2009-10-09 01:57:16 +02:00
|
|
|
|
|
|
|
list_del_init(&req->r_osd_item);
|
2011-03-21 23:07:16 +01:00
|
|
|
if (list_empty(&req->r_osd->o_requests) &&
|
|
|
|
list_empty(&req->r_osd->o_linger_requests)) {
|
|
|
|
dout("moving osd to %p lru\n", req->r_osd);
|
2010-02-03 20:00:26 +01:00
|
|
|
__move_osd_to_lru(osdc, req->r_osd);
|
2011-03-21 23:07:16 +01:00
|
|
|
}
|
2011-03-29 21:11:06 +02:00
|
|
|
if (list_empty(&req->r_linger_item))
|
2011-03-21 23:07:16 +01:00
|
|
|
req->r_osd = NULL;
|
2009-10-09 01:57:16 +02:00
|
|
|
}
|
2009-10-06 20:31:10 +02:00
|
|
|
|
2012-11-29 15:37:03 +01:00
|
|
|
list_del_init(&req->r_req_lru_item);
|
2009-10-06 20:31:10 +02:00
|
|
|
ceph_osdc_put_request(req);
|
|
|
|
|
2010-02-27 00:32:31 +01:00
|
|
|
if (osdc->num_requests == 0) {
|
|
|
|
dout(" no requests, canceling timeout\n");
|
|
|
|
__cancel_osd_timeout(osdc);
|
2009-10-06 20:31:10 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Cancel a previously queued request message
|
|
|
|
*/
|
|
|
|
static void __cancel_request(struct ceph_osd_request *req)
|
|
|
|
{
|
2010-09-27 19:18:52 +02:00
|
|
|
if (req->r_sent && req->r_osd) {
|
2012-06-01 21:56:43 +02:00
|
|
|
ceph_msg_revoke(req->r_request);
|
2009-10-06 20:31:10 +02:00
|
|
|
req->r_sent = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-03-21 23:07:16 +01:00
|
|
|
static void __register_linger_request(struct ceph_osd_client *osdc,
|
|
|
|
struct ceph_osd_request *req)
|
|
|
|
{
|
|
|
|
dout("__register_linger_request %p\n", req);
|
|
|
|
list_add_tail(&req->r_linger_item, &osdc->req_linger);
|
2012-07-31 01:19:28 +02:00
|
|
|
if (req->r_osd)
|
|
|
|
list_add_tail(&req->r_linger_osd,
|
|
|
|
&req->r_osd->o_linger_requests);
|
2011-03-21 23:07:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __unregister_linger_request(struct ceph_osd_client *osdc,
|
|
|
|
struct ceph_osd_request *req)
|
|
|
|
{
|
|
|
|
dout("__unregister_linger_request %p\n", req);
|
2012-12-06 16:37:23 +01:00
|
|
|
list_del_init(&req->r_linger_item);
|
2011-03-21 23:07:16 +01:00
|
|
|
if (req->r_osd) {
|
|
|
|
list_del_init(&req->r_linger_osd);
|
|
|
|
|
|
|
|
if (list_empty(&req->r_osd->o_requests) &&
|
|
|
|
list_empty(&req->r_osd->o_linger_requests)) {
|
|
|
|
dout("moving osd to %p lru\n", req->r_osd);
|
|
|
|
__move_osd_to_lru(osdc, req->r_osd);
|
|
|
|
}
|
2011-03-29 21:11:06 +02:00
|
|
|
if (list_empty(&req->r_osd_item))
|
|
|
|
req->r_osd = NULL;
|
2011-03-21 23:07:16 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void ceph_osdc_unregister_linger_request(struct ceph_osd_client *osdc,
|
|
|
|
struct ceph_osd_request *req)
|
|
|
|
{
|
|
|
|
mutex_lock(&osdc->request_mutex);
|
|
|
|
if (req->r_linger) {
|
|
|
|
__unregister_linger_request(osdc, req);
|
|
|
|
ceph_osdc_put_request(req);
|
|
|
|
}
|
|
|
|
mutex_unlock(&osdc->request_mutex);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ceph_osdc_unregister_linger_request);
|
|
|
|
|
|
|
|
void ceph_osdc_set_request_linger(struct ceph_osd_client *osdc,
|
|
|
|
struct ceph_osd_request *req)
|
|
|
|
{
|
|
|
|
if (!req->r_linger) {
|
|
|
|
dout("set_request_linger %p\n", req);
|
|
|
|
req->r_linger = 1;
|
|
|
|
/*
|
|
|
|
* caller is now responsible for calling
|
|
|
|
* unregister_linger_request
|
|
|
|
*/
|
|
|
|
ceph_osdc_get_request(req);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ceph_osdc_set_request_linger);
|
|
|
|
|
2009-10-06 20:31:10 +02:00
|
|
|
/*
|
|
|
|
* Pick an osd (the first 'up' osd in the pg), allocate the osd struct
|
|
|
|
* (as needed), and set the request r_osd appropriately. If there is
|
2011-03-31 03:57:33 +02:00
|
|
|
* no up osd, set r_osd to NULL. Move the request to the appropriate list
|
2011-01-18 05:34:08 +01:00
|
|
|
* (unsent, homeless) or leave on in-flight lru.
|
2009-10-06 20:31:10 +02:00
|
|
|
*
|
|
|
|
* Return 0 if unchanged, 1 if changed, or negative on error.
|
|
|
|
*
|
|
|
|
* Caller should hold map_sem for read and request_mutex.
|
|
|
|
*/
|
2011-01-18 05:34:08 +01:00
|
|
|
static int __map_request(struct ceph_osd_client *osdc,
|
2011-10-14 22:33:55 +02:00
|
|
|
struct ceph_osd_request *req, int force_resend)
|
2009-10-06 20:31:10 +02:00
|
|
|
{
|
2013-02-23 19:38:16 +01:00
|
|
|
struct ceph_pg pgid;
|
2010-05-10 19:24:48 +02:00
|
|
|
int acting[CEPH_PG_MAX_SIZE];
|
|
|
|
int o = -1, num = 0;
|
2009-10-06 20:31:10 +02:00
|
|
|
int err;
|
|
|
|
|
2011-01-18 05:34:08 +01:00
|
|
|
dout("map_request %p tid %lld\n", req, req->r_tid);
|
2013-02-26 01:13:08 +01:00
|
|
|
err = ceph_calc_object_layout(&pgid, req->r_oid,
|
2009-10-06 20:31:10 +02:00
|
|
|
&req->r_file_layout, osdc->osdmap);
|
2011-01-18 05:34:08 +01:00
|
|
|
if (err) {
|
|
|
|
list_move(&req->r_req_lru_item, &osdc->req_notarget);
|
2009-10-06 20:31:10 +02:00
|
|
|
return err;
|
2011-01-18 05:34:08 +01:00
|
|
|
}
|
2010-01-09 00:58:25 +01:00
|
|
|
req->r_pgid = pgid;
|
|
|
|
|
2010-05-10 19:24:48 +02:00
|
|
|
err = ceph_calc_pg_acting(osdc->osdmap, pgid, acting);
|
|
|
|
if (err > 0) {
|
|
|
|
o = acting[0];
|
|
|
|
num = err;
|
|
|
|
}
|
2009-10-06 20:31:10 +02:00
|
|
|
|
2011-10-14 22:33:55 +02:00
|
|
|
if ((!force_resend &&
|
|
|
|
req->r_osd && req->r_osd->o_osd == o &&
|
2010-05-10 19:24:48 +02:00
|
|
|
req->r_sent >= req->r_osd->o_incarnation &&
|
|
|
|
req->r_num_pg_osds == num &&
|
|
|
|
memcmp(req->r_pg_osds, acting, sizeof(acting[0])*num) == 0) ||
|
2009-10-06 20:31:10 +02:00
|
|
|
(req->r_osd == NULL && o == -1))
|
|
|
|
return 0; /* no change */
|
|
|
|
|
2013-02-23 19:38:16 +01:00
|
|
|
dout("map_request tid %llu pgid %lld.%x osd%d (was osd%d)\n",
|
|
|
|
req->r_tid, pgid.pool, pgid.seed, o,
|
2009-10-06 20:31:10 +02:00
|
|
|
req->r_osd ? req->r_osd->o_osd : -1);
|
|
|
|
|
2010-05-10 19:24:48 +02:00
|
|
|
/* record full pg acting set */
|
|
|
|
memcpy(req->r_pg_osds, acting, sizeof(acting[0]) * num);
|
|
|
|
req->r_num_pg_osds = num;
|
|
|
|
|
2009-10-06 20:31:10 +02:00
|
|
|
if (req->r_osd) {
|
|
|
|
__cancel_request(req);
|
|
|
|
list_del_init(&req->r_osd_item);
|
|
|
|
req->r_osd = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
req->r_osd = __lookup_osd(osdc, o);
|
|
|
|
if (!req->r_osd && o >= 0) {
|
2010-02-26 18:37:33 +01:00
|
|
|
err = -ENOMEM;
|
2012-05-27 06:26:43 +02:00
|
|
|
req->r_osd = create_osd(osdc, o);
|
2011-01-18 05:34:08 +01:00
|
|
|
if (!req->r_osd) {
|
|
|
|
list_move(&req->r_req_lru_item, &osdc->req_notarget);
|
2010-02-26 18:37:33 +01:00
|
|
|
goto out;
|
2011-01-18 05:34:08 +01:00
|
|
|
}
|
2009-10-06 20:31:10 +02:00
|
|
|
|
2011-01-18 05:34:08 +01:00
|
|
|
dout("map_request osd %p is osd%d\n", req->r_osd, o);
|
2009-10-06 20:31:10 +02:00
|
|
|
__insert_osd(osdc, req->r_osd);
|
|
|
|
|
2012-06-27 21:24:08 +02:00
|
|
|
ceph_con_open(&req->r_osd->o_con,
|
|
|
|
CEPH_ENTITY_TYPE_OSD, o,
|
|
|
|
&osdc->osdmap->osd_addr[o]);
|
2009-10-06 20:31:10 +02:00
|
|
|
}
|
|
|
|
|
2010-02-03 20:00:26 +01:00
|
|
|
if (req->r_osd) {
|
|
|
|
__remove_osd_from_lru(req->r_osd);
|
2009-10-06 20:31:10 +02:00
|
|
|
list_add(&req->r_osd_item, &req->r_osd->o_requests);
|
2011-01-18 05:34:08 +01:00
|
|
|
list_move(&req->r_req_lru_item, &osdc->req_unsent);
|
|
|
|
} else {
|
|
|
|
list_move(&req->r_req_lru_item, &osdc->req_notarget);
|
2010-02-03 20:00:26 +01:00
|
|
|
}
|
2010-05-10 19:24:48 +02:00
|
|
|
err = 1; /* osd or pg changed */
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* caller should hold map_sem (for read) and request_mutex
|
|
|
|
*/
|
2012-01-03 21:34:34 +01:00
|
|
|
static void __send_request(struct ceph_osd_client *osdc,
|
|
|
|
struct ceph_osd_request *req)
|
2009-10-06 20:31:10 +02:00
|
|
|
{
|
2013-02-26 01:11:12 +01:00
|
|
|
void *p;
|
2009-10-06 20:31:10 +02:00
|
|
|
|
2013-02-26 01:11:12 +01:00
|
|
|
dout("send_request %p tid %llu to osd%d flags %d pg %lld.%x\n",
|
|
|
|
req, req->r_tid, req->r_osd->o_osd, req->r_flags,
|
|
|
|
(unsigned long long)req->r_pgid.pool, req->r_pgid.seed);
|
|
|
|
|
|
|
|
/* fill in message content that changes each time we send it */
|
|
|
|
put_unaligned_le32(osdc->osdmap->epoch, req->r_request_osdmap_epoch);
|
|
|
|
put_unaligned_le32(req->r_flags, req->r_request_flags);
|
|
|
|
put_unaligned_le64(req->r_pgid.pool, req->r_request_pool);
|
|
|
|
p = req->r_request_pgid;
|
|
|
|
ceph_encode_64(&p, req->r_pgid.pool);
|
|
|
|
ceph_encode_32(&p, req->r_pgid.seed);
|
|
|
|
put_unaligned_le64(1, req->r_request_attempts); /* FIXME */
|
|
|
|
memcpy(req->r_request_reassert_version, &req->r_reassert_version,
|
|
|
|
sizeof(req->r_reassert_version));
|
2013-02-26 01:13:08 +01:00
|
|
|
|
2010-03-22 22:42:30 +01:00
|
|
|
req->r_stamp = jiffies;
|
2010-08-23 06:34:27 +02:00
|
|
|
list_move_tail(&req->r_req_lru_item, &osdc->req_lru);
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
ceph_msg_get(req->r_request); /* send consumes a ref */
|
|
|
|
ceph_con_send(&req->r_osd->o_con, req->r_request);
|
|
|
|
req->r_sent = req->r_osd->o_incarnation;
|
|
|
|
}
|
|
|
|
|
2011-01-18 05:34:08 +01:00
|
|
|
/*
|
|
|
|
* Send any requests in the queue (req_unsent).
|
|
|
|
*/
|
2013-02-15 18:42:29 +01:00
|
|
|
static void __send_queued(struct ceph_osd_client *osdc)
|
2011-01-18 05:34:08 +01:00
|
|
|
{
|
|
|
|
struct ceph_osd_request *req, *tmp;
|
|
|
|
|
2013-02-15 18:42:29 +01:00
|
|
|
dout("__send_queued\n");
|
|
|
|
list_for_each_entry_safe(req, tmp, &osdc->req_unsent, r_req_lru_item)
|
2011-01-18 05:34:08 +01:00
|
|
|
__send_request(osdc, req);
|
|
|
|
}
|
|
|
|
|
2009-10-06 20:31:10 +02:00
|
|
|
/*
|
|
|
|
* Timeout callback, called every N seconds when 1 or more osd
|
|
|
|
* requests has been active for more than N seconds. When this
|
|
|
|
* happens, we ping all OSDs with requests who have timed out to
|
|
|
|
* ensure any communications channel reset is detected. Reset the
|
|
|
|
* request timeouts another N seconds in the future as we go.
|
|
|
|
* Reschedule the timeout event another N seconds in future (unless
|
|
|
|
* there are no open requests).
|
|
|
|
*/
|
|
|
|
static void handle_timeout(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct ceph_osd_client *osdc =
|
|
|
|
container_of(work, struct ceph_osd_client, timeout_work.work);
|
2012-11-28 21:28:24 +01:00
|
|
|
struct ceph_osd_request *req;
|
2009-10-06 20:31:10 +02:00
|
|
|
struct ceph_osd *osd;
|
2010-02-27 00:32:31 +01:00
|
|
|
unsigned long keepalive =
|
2010-04-07 00:14:15 +02:00
|
|
|
osdc->client->options->osd_keepalive_timeout * HZ;
|
2010-02-27 00:32:31 +01:00
|
|
|
struct list_head slow_osds;
|
2009-10-06 20:31:10 +02:00
|
|
|
dout("timeout\n");
|
|
|
|
down_read(&osdc->map_sem);
|
|
|
|
|
|
|
|
ceph_monc_request_next_osdmap(&osdc->client->monc);
|
|
|
|
|
|
|
|
mutex_lock(&osdc->request_mutex);
|
|
|
|
|
2010-02-27 00:32:31 +01:00
|
|
|
/*
|
|
|
|
* ping osds that are a bit slow. this ensures that if there
|
|
|
|
* is a break in the TCP connection we will notice, and reopen
|
|
|
|
* a connection with that osd (from the fault callback).
|
|
|
|
*/
|
|
|
|
INIT_LIST_HEAD(&slow_osds);
|
|
|
|
list_for_each_entry(req, &osdc->req_lru, r_req_lru_item) {
|
2010-03-22 22:42:30 +01:00
|
|
|
if (time_before(jiffies, req->r_stamp + keepalive))
|
2010-02-27 00:32:31 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
osd = req->r_osd;
|
|
|
|
BUG_ON(!osd);
|
|
|
|
dout(" tid %llu is slow, will send keepalive on osd%d\n",
|
2009-10-06 20:31:10 +02:00
|
|
|
req->r_tid, osd->o_osd);
|
2010-02-27 00:32:31 +01:00
|
|
|
list_move_tail(&osd->o_keepalive_item, &slow_osds);
|
|
|
|
}
|
|
|
|
while (!list_empty(&slow_osds)) {
|
|
|
|
osd = list_entry(slow_osds.next, struct ceph_osd,
|
|
|
|
o_keepalive_item);
|
|
|
|
list_del_init(&osd->o_keepalive_item);
|
2009-10-06 20:31:10 +02:00
|
|
|
ceph_con_keepalive(&osd->o_con);
|
|
|
|
}
|
|
|
|
|
2010-02-27 00:32:31 +01:00
|
|
|
__schedule_osd_timeout(osdc);
|
2013-02-15 18:42:29 +01:00
|
|
|
__send_queued(osdc);
|
2009-10-06 20:31:10 +02:00
|
|
|
mutex_unlock(&osdc->request_mutex);
|
|
|
|
up_read(&osdc->map_sem);
|
|
|
|
}
|
|
|
|
|
2010-02-03 20:00:26 +01:00
|
|
|
static void handle_osds_timeout(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct ceph_osd_client *osdc =
|
|
|
|
container_of(work, struct ceph_osd_client,
|
|
|
|
osds_timeout_work.work);
|
|
|
|
unsigned long delay =
|
2010-04-07 00:14:15 +02:00
|
|
|
osdc->client->options->osd_idle_ttl * HZ >> 2;
|
2010-02-03 20:00:26 +01:00
|
|
|
|
|
|
|
dout("osds timeout\n");
|
|
|
|
down_read(&osdc->map_sem);
|
2011-08-31 23:45:53 +02:00
|
|
|
remove_old_osds(osdc);
|
2010-02-03 20:00:26 +01:00
|
|
|
up_read(&osdc->map_sem);
|
|
|
|
|
|
|
|
schedule_delayed_work(&osdc->osds_timeout_work,
|
|
|
|
round_jiffies_relative(delay));
|
|
|
|
}
|
|
|
|
|
2011-06-03 18:37:09 +02:00
|
|
|
static void complete_request(struct ceph_osd_request *req)
|
|
|
|
{
|
|
|
|
if (req->r_safe_callback)
|
|
|
|
req->r_safe_callback(req, NULL);
|
|
|
|
complete_all(&req->r_safe_completion); /* fsync waiter */
|
|
|
|
}
|
|
|
|
|
2013-02-26 01:11:12 +01:00
|
|
|
static int __decode_pgid(void **p, void *end, struct ceph_pg *pgid)
|
|
|
|
{
|
|
|
|
__u8 v;
|
|
|
|
|
|
|
|
ceph_decode_need(p, end, 1 + 8 + 4 + 4, bad);
|
|
|
|
v = ceph_decode_8(p);
|
|
|
|
if (v > 1) {
|
|
|
|
pr_warning("do not understand pg encoding %d > 1", v);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
pgid->pool = ceph_decode_64(p);
|
|
|
|
pgid->seed = ceph_decode_32(p);
|
|
|
|
*p += 4;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
bad:
|
|
|
|
pr_warning("incomplete pg encoding");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-10-06 20:31:10 +02:00
|
|
|
/*
|
|
|
|
* handle osd op reply. either call the callback if it is specified,
|
|
|
|
* or do the completion to wake up the waiting thread.
|
|
|
|
*/
|
2009-12-22 19:45:45 +01:00
|
|
|
static void handle_reply(struct ceph_osd_client *osdc, struct ceph_msg *msg,
|
|
|
|
struct ceph_connection *con)
|
2009-10-06 20:31:10 +02:00
|
|
|
{
|
2013-02-26 01:11:12 +01:00
|
|
|
void *p, *end;
|
2009-10-06 20:31:10 +02:00
|
|
|
struct ceph_osd_request *req;
|
|
|
|
u64 tid;
|
2013-02-26 01:11:12 +01:00
|
|
|
int object_len;
|
|
|
|
int numops, payload_len, flags;
|
2010-05-11 18:53:18 +02:00
|
|
|
s32 result;
|
2013-02-26 01:11:12 +01:00
|
|
|
s32 retry_attempt;
|
|
|
|
struct ceph_pg pg;
|
|
|
|
int err;
|
|
|
|
u32 reassert_epoch;
|
|
|
|
u64 reassert_version;
|
|
|
|
u32 osdmap_epoch;
|
2013-02-27 17:26:25 +01:00
|
|
|
int already_completed;
|
2013-02-26 01:11:12 +01:00
|
|
|
int i;
|
2009-10-06 20:31:10 +02:00
|
|
|
|
2009-12-22 20:24:33 +01:00
|
|
|
tid = le64_to_cpu(msg->hdr.tid);
|
2013-02-26 01:11:12 +01:00
|
|
|
dout("handle_reply %p tid %llu\n", msg, tid);
|
|
|
|
|
|
|
|
p = msg->front.iov_base;
|
|
|
|
end = p + msg->front.iov_len;
|
|
|
|
|
|
|
|
ceph_decode_need(&p, end, 4, bad);
|
|
|
|
object_len = ceph_decode_32(&p);
|
|
|
|
ceph_decode_need(&p, end, object_len, bad);
|
|
|
|
p += object_len;
|
|
|
|
|
|
|
|
err = __decode_pgid(&p, end, &pg);
|
|
|
|
if (err)
|
2009-10-06 20:31:10 +02:00
|
|
|
goto bad;
|
2013-02-26 01:11:12 +01:00
|
|
|
|
|
|
|
ceph_decode_need(&p, end, 8 + 4 + 4 + 8 + 4, bad);
|
|
|
|
flags = ceph_decode_64(&p);
|
|
|
|
result = ceph_decode_32(&p);
|
|
|
|
reassert_epoch = ceph_decode_32(&p);
|
|
|
|
reassert_version = ceph_decode_64(&p);
|
|
|
|
osdmap_epoch = ceph_decode_32(&p);
|
|
|
|
|
2009-10-06 20:31:10 +02:00
|
|
|
/* lookup */
|
|
|
|
mutex_lock(&osdc->request_mutex);
|
|
|
|
req = __lookup_request(osdc, tid);
|
|
|
|
if (req == NULL) {
|
|
|
|
dout("handle_reply tid %llu dne\n", tid);
|
|
|
|
mutex_unlock(&osdc->request_mutex);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ceph_osdc_get_request(req);
|
2013-02-26 01:11:12 +01:00
|
|
|
|
|
|
|
dout("handle_reply %p tid %llu req %p result %d\n", msg, tid,
|
|
|
|
req, result);
|
|
|
|
|
|
|
|
ceph_decode_need(&p, end, 4, bad);
|
|
|
|
numops = ceph_decode_32(&p);
|
|
|
|
if (numops > CEPH_OSD_MAX_OP)
|
|
|
|
goto bad_put;
|
|
|
|
if (numops != req->r_num_ops)
|
|
|
|
goto bad_put;
|
|
|
|
payload_len = 0;
|
|
|
|
ceph_decode_need(&p, end, numops * sizeof(struct ceph_osd_op), bad);
|
|
|
|
for (i = 0; i < numops; i++) {
|
|
|
|
struct ceph_osd_op *op = p;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
len = le32_to_cpu(op->payload_len);
|
|
|
|
req->r_reply_op_len[i] = len;
|
|
|
|
dout(" op %d has %d bytes\n", i, len);
|
|
|
|
payload_len += len;
|
|
|
|
p += sizeof(*op);
|
|
|
|
}
|
|
|
|
if (payload_len != le32_to_cpu(msg->hdr.data_len)) {
|
|
|
|
pr_warning("sum of op payload lens %d != data_len %d",
|
|
|
|
payload_len, le32_to_cpu(msg->hdr.data_len));
|
|
|
|
goto bad_put;
|
|
|
|
}
|
|
|
|
|
|
|
|
ceph_decode_need(&p, end, 4 + numops * 4, bad);
|
|
|
|
retry_attempt = ceph_decode_32(&p);
|
|
|
|
for (i = 0; i < numops; i++)
|
|
|
|
req->r_reply_op_result[i] = ceph_decode_32(&p);
|
2009-10-06 20:31:10 +02:00
|
|
|
|
2009-12-22 19:45:45 +01:00
|
|
|
/*
|
2010-01-14 02:03:23 +01:00
|
|
|
* if this connection filled our message, drop our reference now, to
|
2009-12-22 19:45:45 +01:00
|
|
|
* avoid a (safe but slower) revoke later.
|
|
|
|
*/
|
2010-01-14 02:03:23 +01:00
|
|
|
if (req->r_con_filling_msg == con && req->r_reply == msg) {
|
2010-03-01 22:02:00 +01:00
|
|
|
dout(" dropping con_filling_msg ref %p\n", con);
|
2010-01-14 02:03:23 +01:00
|
|
|
req->r_con_filling_msg = NULL;
|
2012-06-01 05:22:18 +02:00
|
|
|
con->ops->put(con);
|
2009-12-22 19:45:45 +01:00
|
|
|
}
|
|
|
|
|
2009-10-06 20:31:10 +02:00
|
|
|
if (!req->r_got_reply) {
|
2012-04-15 07:58:06 +02:00
|
|
|
unsigned int bytes;
|
2009-10-06 20:31:10 +02:00
|
|
|
|
2013-02-26 01:11:12 +01:00
|
|
|
req->r_result = result;
|
2009-10-06 20:31:10 +02:00
|
|
|
bytes = le32_to_cpu(msg->hdr.data_len);
|
|
|
|
dout("handle_reply result %d bytes %d\n", req->r_result,
|
|
|
|
bytes);
|
|
|
|
if (req->r_result == 0)
|
|
|
|
req->r_result = bytes;
|
|
|
|
|
|
|
|
/* in case this is a write and we need to replay, */
|
2013-02-26 01:11:12 +01:00
|
|
|
req->r_reassert_version.epoch = cpu_to_le32(reassert_epoch);
|
|
|
|
req->r_reassert_version.version = cpu_to_le64(reassert_version);
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
req->r_got_reply = 1;
|
|
|
|
} else if ((flags & CEPH_OSD_FLAG_ONDISK) == 0) {
|
|
|
|
dout("handle_reply tid %llu dup ack\n", tid);
|
2009-12-01 21:23:54 +01:00
|
|
|
mutex_unlock(&osdc->request_mutex);
|
2009-10-06 20:31:10 +02:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
dout("handle_reply tid %llu flags %d\n", tid, flags);
|
|
|
|
|
2011-03-21 23:07:16 +01:00
|
|
|
if (req->r_linger && (flags & CEPH_OSD_FLAG_ONDISK))
|
|
|
|
__register_linger_request(osdc, req);
|
|
|
|
|
2009-10-06 20:31:10 +02:00
|
|
|
/* either this is a read, or we got the safe response */
|
2010-05-11 18:53:18 +02:00
|
|
|
if (result < 0 ||
|
|
|
|
(flags & CEPH_OSD_FLAG_ONDISK) ||
|
2009-10-06 20:31:10 +02:00
|
|
|
((flags & CEPH_OSD_FLAG_WRITE) == 0))
|
|
|
|
__unregister_request(osdc, req);
|
|
|
|
|
2013-02-27 17:26:25 +01:00
|
|
|
already_completed = req->r_completed;
|
|
|
|
req->r_completed = 1;
|
2009-10-06 20:31:10 +02:00
|
|
|
mutex_unlock(&osdc->request_mutex);
|
2013-02-27 17:26:25 +01:00
|
|
|
if (already_completed)
|
|
|
|
goto done;
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
if (req->r_callback)
|
|
|
|
req->r_callback(req, msg);
|
|
|
|
else
|
2010-07-27 22:11:08 +02:00
|
|
|
complete_all(&req->r_completion);
|
2009-10-06 20:31:10 +02:00
|
|
|
|
2011-06-03 18:37:09 +02:00
|
|
|
if (flags & CEPH_OSD_FLAG_ONDISK)
|
|
|
|
complete_request(req);
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
done:
|
2011-03-21 23:07:16 +01:00
|
|
|
dout("req=%p req->r_linger=%d\n", req, req->r_linger);
|
2009-10-06 20:31:10 +02:00
|
|
|
ceph_osdc_put_request(req);
|
|
|
|
return;
|
|
|
|
|
2013-02-26 01:11:12 +01:00
|
|
|
bad_put:
|
|
|
|
ceph_osdc_put_request(req);
|
2009-10-06 20:31:10 +02:00
|
|
|
bad:
|
2013-02-26 01:11:12 +01:00
|
|
|
pr_err("corrupt osd_op_reply got %d %d\n",
|
|
|
|
(int)msg->front.iov_len, le32_to_cpu(msg->hdr.front_len));
|
2009-12-15 00:13:47 +01:00
|
|
|
ceph_msg_dump(msg);
|
2009-10-06 20:31:10 +02:00
|
|
|
}
|
|
|
|
|
2011-01-18 05:34:08 +01:00
|
|
|
static void reset_changed_osds(struct ceph_osd_client *osdc)
|
2009-10-06 20:31:10 +02:00
|
|
|
{
|
|
|
|
struct rb_node *p, *n;
|
|
|
|
|
2011-01-18 05:34:08 +01:00
|
|
|
for (p = rb_first(&osdc->osds); p; p = n) {
|
|
|
|
struct ceph_osd *osd = rb_entry(p, struct ceph_osd, o_node);
|
2009-10-06 20:31:10 +02:00
|
|
|
|
2011-01-18 05:34:08 +01:00
|
|
|
n = rb_next(p);
|
|
|
|
if (!ceph_osd_is_up(osdc->osdmap, osd->o_osd) ||
|
|
|
|
memcmp(&osd->o_con.peer_addr,
|
|
|
|
ceph_osd_addr(osdc->osdmap,
|
|
|
|
osd->o_osd),
|
|
|
|
sizeof(struct ceph_entity_addr)) != 0)
|
|
|
|
__reset_osd(osdc, osd);
|
2009-10-06 20:31:10 +02:00
|
|
|
}
|
2010-02-27 00:32:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2011-01-18 05:34:08 +01:00
|
|
|
* Requeue requests whose mapping to an OSD has changed. If requests map to
|
|
|
|
* no osd, request a new map.
|
2010-02-27 00:32:31 +01:00
|
|
|
*
|
2012-12-26 21:31:40 +01:00
|
|
|
* Caller should hold map_sem for read.
|
2010-02-27 00:32:31 +01:00
|
|
|
*/
|
2011-10-14 22:33:55 +02:00
|
|
|
static void kick_requests(struct ceph_osd_client *osdc, int force_resend)
|
2010-02-27 00:32:31 +01:00
|
|
|
{
|
2011-03-21 23:07:16 +01:00
|
|
|
struct ceph_osd_request *req, *nreq;
|
2011-01-18 05:34:08 +01:00
|
|
|
struct rb_node *p;
|
|
|
|
int needmap = 0;
|
|
|
|
int err;
|
2010-02-27 00:32:31 +01:00
|
|
|
|
2011-10-14 22:33:55 +02:00
|
|
|
dout("kick_requests %s\n", force_resend ? " (force resend)" : "");
|
2010-02-27 00:32:31 +01:00
|
|
|
mutex_lock(&osdc->request_mutex);
|
2012-07-31 01:19:28 +02:00
|
|
|
for (p = rb_first(&osdc->requests); p; ) {
|
2011-01-18 05:34:08 +01:00
|
|
|
req = rb_entry(p, struct ceph_osd_request, r_node);
|
2012-07-31 01:19:28 +02:00
|
|
|
p = rb_next(p);
|
libceph: move linger requests sooner in kick_requests()
The kick_requests() function is called by ceph_osdc_handle_map()
when an osd map change has been indicated. Its purpose is to
re-queue any request whose target osd is different from what it
was when it was originally sent.
It is structured as two loops, one for incomplete but registered
requests, and a second for handling completed linger requests.
As a special case, in the first loop if a request marked to linger
has not yet completed, it is moved from the request list to the
linger list. This is as a quick and dirty way to have the second
loop handle sending the request along with all the other linger
requests.
Because of the way it's done now, however, this quick and dirty
solution can result in these incomplete linger requests never
getting re-sent as desired. The problem lies in the fact that
the second loop only arranges for a linger request to be sent
if it appears its target osd has changed. This is the proper
handling for *completed* linger requests (it avoids issuing
the same linger request twice to the same osd).
But although the linger requests added to the list in the first loop
may have been sent, they have not yet completed, so they need to be
re-sent regardless of whether their target osd has changed.
The first required fix is we need to avoid calling __map_request()
on any incomplete linger request. Otherwise the subsequent
__map_request() call in the second loop will find the target osd
has not changed and will therefore not re-send the request.
Second, we need to be sure that a sent but incomplete linger request
gets re-sent. If the target osd is the same with the new osd map as
it was when the request was originally sent, this won't happen.
This can be fixed through careful handling when we move these
requests from the request list to the linger list, by unregistering
the request *before* it is registered as a linger request. This
works because a side-effect of unregistering the request is to make
the request's r_osd pointer be NULL, and *that* will ensure the
second loop actually re-sends the linger request.
Processing of such a request is done at that point, so continue with
the next one once it's been moved.
Signed-off-by: Alex Elder <elder@inktank.com>
Reviewed-by: Sage Weil <sage@inktank.com>
2012-12-19 22:52:36 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* For linger requests that have not yet been
|
|
|
|
* registered, move them to the linger list; they'll
|
|
|
|
* be sent to the osd in the loop below. Unregister
|
|
|
|
* the request before re-registering it as a linger
|
|
|
|
* request to ensure the __map_request() below
|
|
|
|
* will decide it needs to be sent.
|
|
|
|
*/
|
|
|
|
if (req->r_linger && list_empty(&req->r_linger_item)) {
|
|
|
|
dout("%p tid %llu restart on osd%d\n",
|
|
|
|
req, req->r_tid,
|
|
|
|
req->r_osd ? req->r_osd->o_osd : -1);
|
|
|
|
__unregister_request(osdc, req);
|
|
|
|
__register_linger_request(osdc, req);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2011-10-14 22:33:55 +02:00
|
|
|
err = __map_request(osdc, req, force_resend);
|
2011-01-18 05:34:08 +01:00
|
|
|
if (err < 0)
|
|
|
|
continue; /* error */
|
|
|
|
if (req->r_osd == NULL) {
|
|
|
|
dout("%p tid %llu maps to no osd\n", req, req->r_tid);
|
|
|
|
needmap++; /* request a newer map */
|
|
|
|
} else if (err > 0) {
|
2012-07-31 01:19:28 +02:00
|
|
|
if (!req->r_linger) {
|
|
|
|
dout("%p tid %llu requeued on osd%d\n", req,
|
|
|
|
req->r_tid,
|
|
|
|
req->r_osd ? req->r_osd->o_osd : -1);
|
2011-03-21 23:07:16 +01:00
|
|
|
req->r_flags |= CEPH_OSD_FLAG_RETRY;
|
2012-07-31 01:19:28 +02:00
|
|
|
}
|
|
|
|
}
|
2011-03-21 23:07:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry_safe(req, nreq, &osdc->req_linger,
|
|
|
|
r_linger_item) {
|
|
|
|
dout("linger req=%p req->r_osd=%p\n", req, req->r_osd);
|
|
|
|
|
2011-10-14 22:33:55 +02:00
|
|
|
err = __map_request(osdc, req, force_resend);
|
libceph: move linger requests sooner in kick_requests()
The kick_requests() function is called by ceph_osdc_handle_map()
when an osd map change has been indicated. Its purpose is to
re-queue any request whose target osd is different from what it
was when it was originally sent.
It is structured as two loops, one for incomplete but registered
requests, and a second for handling completed linger requests.
As a special case, in the first loop if a request marked to linger
has not yet completed, it is moved from the request list to the
linger list. This is as a quick and dirty way to have the second
loop handle sending the request along with all the other linger
requests.
Because of the way it's done now, however, this quick and dirty
solution can result in these incomplete linger requests never
getting re-sent as desired. The problem lies in the fact that
the second loop only arranges for a linger request to be sent
if it appears its target osd has changed. This is the proper
handling for *completed* linger requests (it avoids issuing
the same linger request twice to the same osd).
But although the linger requests added to the list in the first loop
may have been sent, they have not yet completed, so they need to be
re-sent regardless of whether their target osd has changed.
The first required fix is we need to avoid calling __map_request()
on any incomplete linger request. Otherwise the subsequent
__map_request() call in the second loop will find the target osd
has not changed and will therefore not re-send the request.
Second, we need to be sure that a sent but incomplete linger request
gets re-sent. If the target osd is the same with the new osd map as
it was when the request was originally sent, this won't happen.
This can be fixed through careful handling when we move these
requests from the request list to the linger list, by unregistering
the request *before* it is registered as a linger request. This
works because a side-effect of unregistering the request is to make
the request's r_osd pointer be NULL, and *that* will ensure the
second loop actually re-sends the linger request.
Processing of such a request is done at that point, so continue with
the next one once it's been moved.
Signed-off-by: Alex Elder <elder@inktank.com>
Reviewed-by: Sage Weil <sage@inktank.com>
2012-12-19 22:52:36 +01:00
|
|
|
dout("__map_request returned %d\n", err);
|
2011-03-21 23:07:16 +01:00
|
|
|
if (err == 0)
|
|
|
|
continue; /* no change and no osd was specified */
|
|
|
|
if (err < 0)
|
|
|
|
continue; /* hrm! */
|
|
|
|
if (req->r_osd == NULL) {
|
|
|
|
dout("tid %llu maps to no valid osd\n", req->r_tid);
|
|
|
|
needmap++; /* request a newer map */
|
|
|
|
continue;
|
2011-01-18 05:34:08 +01:00
|
|
|
}
|
2011-03-21 23:07:16 +01:00
|
|
|
|
|
|
|
dout("kicking lingering %p tid %llu osd%d\n", req, req->r_tid,
|
|
|
|
req->r_osd ? req->r_osd->o_osd : -1);
|
|
|
|
__register_request(osdc, req);
|
2012-12-06 14:22:04 +01:00
|
|
|
__unregister_linger_request(osdc, req);
|
2011-01-18 05:34:08 +01:00
|
|
|
}
|
2009-10-06 20:31:10 +02:00
|
|
|
mutex_unlock(&osdc->request_mutex);
|
|
|
|
|
|
|
|
if (needmap) {
|
|
|
|
dout("%d requests for down osds, need new map\n", needmap);
|
|
|
|
ceph_monc_request_next_osdmap(&osdc->client->monc);
|
|
|
|
}
|
2012-12-26 21:31:40 +01:00
|
|
|
reset_changed_osds(osdc);
|
2010-02-27 00:32:31 +01:00
|
|
|
}
|
2011-01-18 05:34:08 +01:00
|
|
|
|
|
|
|
|
2009-10-06 20:31:10 +02:00
|
|
|
/*
|
|
|
|
* Process updated osd map.
|
|
|
|
*
|
|
|
|
* The message contains any number of incremental and full maps, normally
|
|
|
|
* indicating some sort of topology change in the cluster. Kick requests
|
|
|
|
* off to different OSDs as needed.
|
|
|
|
*/
|
|
|
|
void ceph_osdc_handle_map(struct ceph_osd_client *osdc, struct ceph_msg *msg)
|
|
|
|
{
|
|
|
|
void *p, *end, *next;
|
|
|
|
u32 nr_maps, maplen;
|
|
|
|
u32 epoch;
|
|
|
|
struct ceph_osdmap *newmap = NULL, *oldmap;
|
|
|
|
int err;
|
|
|
|
struct ceph_fsid fsid;
|
|
|
|
|
|
|
|
dout("handle_map have %u\n", osdc->osdmap ? osdc->osdmap->epoch : 0);
|
|
|
|
p = msg->front.iov_base;
|
|
|
|
end = p + msg->front.iov_len;
|
|
|
|
|
|
|
|
/* verify fsid */
|
|
|
|
ceph_decode_need(&p, end, sizeof(fsid), bad);
|
|
|
|
ceph_decode_copy(&p, &fsid, sizeof(fsid));
|
2009-11-19 01:50:41 +01:00
|
|
|
if (ceph_check_fsid(osdc->client, &fsid) < 0)
|
|
|
|
return;
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
down_write(&osdc->map_sem);
|
|
|
|
|
|
|
|
/* incremental maps */
|
|
|
|
ceph_decode_32_safe(&p, end, nr_maps, bad);
|
|
|
|
dout(" %d inc maps\n", nr_maps);
|
|
|
|
while (nr_maps > 0) {
|
|
|
|
ceph_decode_need(&p, end, 2*sizeof(u32), bad);
|
2009-10-14 18:59:09 +02:00
|
|
|
epoch = ceph_decode_32(&p);
|
|
|
|
maplen = ceph_decode_32(&p);
|
2009-10-06 20:31:10 +02:00
|
|
|
ceph_decode_need(&p, end, maplen, bad);
|
|
|
|
next = p + maplen;
|
|
|
|
if (osdc->osdmap && osdc->osdmap->epoch+1 == epoch) {
|
|
|
|
dout("applying incremental map %u len %d\n",
|
|
|
|
epoch, maplen);
|
|
|
|
newmap = osdmap_apply_incremental(&p, next,
|
|
|
|
osdc->osdmap,
|
2012-05-27 06:26:43 +02:00
|
|
|
&osdc->client->msgr);
|
2009-10-06 20:31:10 +02:00
|
|
|
if (IS_ERR(newmap)) {
|
|
|
|
err = PTR_ERR(newmap);
|
|
|
|
goto bad;
|
|
|
|
}
|
2009-12-21 23:49:37 +01:00
|
|
|
BUG_ON(!newmap);
|
2009-10-06 20:31:10 +02:00
|
|
|
if (newmap != osdc->osdmap) {
|
|
|
|
ceph_osdmap_destroy(osdc->osdmap);
|
|
|
|
osdc->osdmap = newmap;
|
|
|
|
}
|
2011-10-14 22:33:55 +02:00
|
|
|
kick_requests(osdc, 0);
|
2009-10-06 20:31:10 +02:00
|
|
|
} else {
|
|
|
|
dout("ignoring incremental map %u len %d\n",
|
|
|
|
epoch, maplen);
|
|
|
|
}
|
|
|
|
p = next;
|
|
|
|
nr_maps--;
|
|
|
|
}
|
|
|
|
if (newmap)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
/* full maps */
|
|
|
|
ceph_decode_32_safe(&p, end, nr_maps, bad);
|
|
|
|
dout(" %d full maps\n", nr_maps);
|
|
|
|
while (nr_maps) {
|
|
|
|
ceph_decode_need(&p, end, 2*sizeof(u32), bad);
|
2009-10-14 18:59:09 +02:00
|
|
|
epoch = ceph_decode_32(&p);
|
|
|
|
maplen = ceph_decode_32(&p);
|
2009-10-06 20:31:10 +02:00
|
|
|
ceph_decode_need(&p, end, maplen, bad);
|
|
|
|
if (nr_maps > 1) {
|
|
|
|
dout("skipping non-latest full map %u len %d\n",
|
|
|
|
epoch, maplen);
|
|
|
|
} else if (osdc->osdmap && osdc->osdmap->epoch >= epoch) {
|
|
|
|
dout("skipping full map %u len %d, "
|
|
|
|
"older than our %u\n", epoch, maplen,
|
|
|
|
osdc->osdmap->epoch);
|
|
|
|
} else {
|
2011-10-14 22:33:55 +02:00
|
|
|
int skipped_map = 0;
|
|
|
|
|
2009-10-06 20:31:10 +02:00
|
|
|
dout("taking full map %u len %d\n", epoch, maplen);
|
|
|
|
newmap = osdmap_decode(&p, p+maplen);
|
|
|
|
if (IS_ERR(newmap)) {
|
|
|
|
err = PTR_ERR(newmap);
|
|
|
|
goto bad;
|
|
|
|
}
|
2009-12-21 23:49:37 +01:00
|
|
|
BUG_ON(!newmap);
|
2009-10-06 20:31:10 +02:00
|
|
|
oldmap = osdc->osdmap;
|
|
|
|
osdc->osdmap = newmap;
|
2011-10-14 22:33:55 +02:00
|
|
|
if (oldmap) {
|
|
|
|
if (oldmap->epoch + 1 < newmap->epoch)
|
|
|
|
skipped_map = 1;
|
2009-10-06 20:31:10 +02:00
|
|
|
ceph_osdmap_destroy(oldmap);
|
2011-10-14 22:33:55 +02:00
|
|
|
}
|
|
|
|
kick_requests(osdc, skipped_map);
|
2009-10-06 20:31:10 +02:00
|
|
|
}
|
|
|
|
p += maplen;
|
|
|
|
nr_maps--;
|
|
|
|
}
|
|
|
|
|
|
|
|
done:
|
|
|
|
downgrade_write(&osdc->map_sem);
|
|
|
|
ceph_monc_got_osdmap(&osdc->client->monc, osdc->osdmap->epoch);
|
2011-05-12 18:29:18 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* subscribe to subsequent osdmap updates if full to ensure
|
|
|
|
* we find out when we are no longer full and stop returning
|
|
|
|
* ENOSPC.
|
|
|
|
*/
|
|
|
|
if (ceph_osdmap_flag(osdc->osdmap, CEPH_OSDMAP_FULL))
|
|
|
|
ceph_monc_request_next_osdmap(&osdc->client->monc);
|
|
|
|
|
2013-02-15 18:42:29 +01:00
|
|
|
mutex_lock(&osdc->request_mutex);
|
|
|
|
__send_queued(osdc);
|
|
|
|
mutex_unlock(&osdc->request_mutex);
|
2009-10-06 20:31:10 +02:00
|
|
|
up_read(&osdc->map_sem);
|
2010-07-27 22:11:08 +02:00
|
|
|
wake_up_all(&osdc->client->auth_wq);
|
2009-10-06 20:31:10 +02:00
|
|
|
return;
|
|
|
|
|
|
|
|
bad:
|
|
|
|
pr_err("osdc handle_map corrupt msg\n");
|
2009-12-15 00:13:47 +01:00
|
|
|
ceph_msg_dump(msg);
|
2009-10-06 20:31:10 +02:00
|
|
|
up_write(&osdc->map_sem);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-03-21 23:07:16 +01:00
|
|
|
/*
|
|
|
|
* watch/notify callback event infrastructure
|
|
|
|
*
|
|
|
|
* These callbacks are used both for watch and notify operations.
|
|
|
|
*/
|
|
|
|
static void __release_event(struct kref *kref)
|
|
|
|
{
|
|
|
|
struct ceph_osd_event *event =
|
|
|
|
container_of(kref, struct ceph_osd_event, kref);
|
|
|
|
|
|
|
|
dout("__release_event %p\n", event);
|
|
|
|
kfree(event);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void get_event(struct ceph_osd_event *event)
|
|
|
|
{
|
|
|
|
kref_get(&event->kref);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ceph_osdc_put_event(struct ceph_osd_event *event)
|
|
|
|
{
|
|
|
|
kref_put(&event->kref, __release_event);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ceph_osdc_put_event);
|
|
|
|
|
|
|
|
static void __insert_event(struct ceph_osd_client *osdc,
|
|
|
|
struct ceph_osd_event *new)
|
|
|
|
{
|
|
|
|
struct rb_node **p = &osdc->event_tree.rb_node;
|
|
|
|
struct rb_node *parent = NULL;
|
|
|
|
struct ceph_osd_event *event = NULL;
|
|
|
|
|
|
|
|
while (*p) {
|
|
|
|
parent = *p;
|
|
|
|
event = rb_entry(parent, struct ceph_osd_event, node);
|
|
|
|
if (new->cookie < event->cookie)
|
|
|
|
p = &(*p)->rb_left;
|
|
|
|
else if (new->cookie > event->cookie)
|
|
|
|
p = &(*p)->rb_right;
|
|
|
|
else
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
|
|
|
rb_link_node(&new->node, parent, p);
|
|
|
|
rb_insert_color(&new->node, &osdc->event_tree);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ceph_osd_event *__find_event(struct ceph_osd_client *osdc,
|
|
|
|
u64 cookie)
|
|
|
|
{
|
|
|
|
struct rb_node **p = &osdc->event_tree.rb_node;
|
|
|
|
struct rb_node *parent = NULL;
|
|
|
|
struct ceph_osd_event *event = NULL;
|
|
|
|
|
|
|
|
while (*p) {
|
|
|
|
parent = *p;
|
|
|
|
event = rb_entry(parent, struct ceph_osd_event, node);
|
|
|
|
if (cookie < event->cookie)
|
|
|
|
p = &(*p)->rb_left;
|
|
|
|
else if (cookie > event->cookie)
|
|
|
|
p = &(*p)->rb_right;
|
|
|
|
else
|
|
|
|
return event;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __remove_event(struct ceph_osd_event *event)
|
|
|
|
{
|
|
|
|
struct ceph_osd_client *osdc = event->osdc;
|
|
|
|
|
|
|
|
if (!RB_EMPTY_NODE(&event->node)) {
|
|
|
|
dout("__remove_event removed %p\n", event);
|
|
|
|
rb_erase(&event->node, &osdc->event_tree);
|
|
|
|
ceph_osdc_put_event(event);
|
|
|
|
} else {
|
|
|
|
dout("__remove_event didn't remove %p\n", event);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int ceph_osdc_create_event(struct ceph_osd_client *osdc,
|
|
|
|
void (*event_cb)(u64, u64, u8, void *),
|
2013-02-15 18:42:30 +01:00
|
|
|
void *data, struct ceph_osd_event **pevent)
|
2011-03-21 23:07:16 +01:00
|
|
|
{
|
|
|
|
struct ceph_osd_event *event;
|
|
|
|
|
|
|
|
event = kmalloc(sizeof(*event), GFP_NOIO);
|
|
|
|
if (!event)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
dout("create_event %p\n", event);
|
|
|
|
event->cb = event_cb;
|
2013-02-15 18:42:30 +01:00
|
|
|
event->one_shot = 0;
|
2011-03-21 23:07:16 +01:00
|
|
|
event->data = data;
|
|
|
|
event->osdc = osdc;
|
|
|
|
INIT_LIST_HEAD(&event->osd_node);
|
2012-12-17 19:23:48 +01:00
|
|
|
RB_CLEAR_NODE(&event->node);
|
2011-03-21 23:07:16 +01:00
|
|
|
kref_init(&event->kref); /* one ref for us */
|
|
|
|
kref_get(&event->kref); /* one ref for the caller */
|
|
|
|
|
|
|
|
spin_lock(&osdc->event_lock);
|
|
|
|
event->cookie = ++osdc->event_count;
|
|
|
|
__insert_event(osdc, event);
|
|
|
|
spin_unlock(&osdc->event_lock);
|
|
|
|
|
|
|
|
*pevent = event;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ceph_osdc_create_event);
|
|
|
|
|
|
|
|
void ceph_osdc_cancel_event(struct ceph_osd_event *event)
|
|
|
|
{
|
|
|
|
struct ceph_osd_client *osdc = event->osdc;
|
|
|
|
|
|
|
|
dout("cancel_event %p\n", event);
|
|
|
|
spin_lock(&osdc->event_lock);
|
|
|
|
__remove_event(event);
|
|
|
|
spin_unlock(&osdc->event_lock);
|
|
|
|
ceph_osdc_put_event(event); /* caller's */
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ceph_osdc_cancel_event);
|
|
|
|
|
|
|
|
|
|
|
|
static void do_event_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct ceph_osd_event_work *event_work =
|
|
|
|
container_of(work, struct ceph_osd_event_work, work);
|
|
|
|
struct ceph_osd_event *event = event_work->event;
|
|
|
|
u64 ver = event_work->ver;
|
|
|
|
u64 notify_id = event_work->notify_id;
|
|
|
|
u8 opcode = event_work->opcode;
|
|
|
|
|
|
|
|
dout("do_event_work completing %p\n", event);
|
|
|
|
event->cb(ver, notify_id, opcode, event->data);
|
|
|
|
dout("do_event_work completed %p\n", event);
|
|
|
|
ceph_osdc_put_event(event);
|
|
|
|
kfree(event_work);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Process osd watch notifications
|
|
|
|
*/
|
2013-02-15 18:42:30 +01:00
|
|
|
static void handle_watch_notify(struct ceph_osd_client *osdc,
|
|
|
|
struct ceph_msg *msg)
|
2011-03-21 23:07:16 +01:00
|
|
|
{
|
|
|
|
void *p, *end;
|
|
|
|
u8 proto_ver;
|
|
|
|
u64 cookie, ver, notify_id;
|
|
|
|
u8 opcode;
|
|
|
|
struct ceph_osd_event *event;
|
|
|
|
struct ceph_osd_event_work *event_work;
|
|
|
|
|
|
|
|
p = msg->front.iov_base;
|
|
|
|
end = p + msg->front.iov_len;
|
|
|
|
|
|
|
|
ceph_decode_8_safe(&p, end, proto_ver, bad);
|
|
|
|
ceph_decode_8_safe(&p, end, opcode, bad);
|
|
|
|
ceph_decode_64_safe(&p, end, cookie, bad);
|
|
|
|
ceph_decode_64_safe(&p, end, ver, bad);
|
|
|
|
ceph_decode_64_safe(&p, end, notify_id, bad);
|
|
|
|
|
|
|
|
spin_lock(&osdc->event_lock);
|
|
|
|
event = __find_event(osdc, cookie);
|
|
|
|
if (event) {
|
2013-02-15 18:42:30 +01:00
|
|
|
BUG_ON(event->one_shot);
|
2011-03-21 23:07:16 +01:00
|
|
|
get_event(event);
|
|
|
|
}
|
|
|
|
spin_unlock(&osdc->event_lock);
|
|
|
|
dout("handle_watch_notify cookie %lld ver %lld event %p\n",
|
|
|
|
cookie, ver, event);
|
|
|
|
if (event) {
|
|
|
|
event_work = kmalloc(sizeof(*event_work), GFP_NOIO);
|
|
|
|
if (!event_work) {
|
|
|
|
dout("ERROR: could not allocate event_work\n");
|
|
|
|
goto done_err;
|
|
|
|
}
|
2011-03-26 19:29:34 +01:00
|
|
|
INIT_WORK(&event_work->work, do_event_work);
|
2011-03-21 23:07:16 +01:00
|
|
|
event_work->event = event;
|
|
|
|
event_work->ver = ver;
|
|
|
|
event_work->notify_id = notify_id;
|
|
|
|
event_work->opcode = opcode;
|
|
|
|
if (!queue_work(osdc->notify_wq, &event_work->work)) {
|
|
|
|
dout("WARNING: failed to queue notify event work\n");
|
|
|
|
goto done_err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
done_err:
|
|
|
|
ceph_osdc_put_event(event);
|
|
|
|
return;
|
|
|
|
|
|
|
|
bad:
|
|
|
|
pr_err("osdc handle_watch_notify corrupt msg\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-10-06 20:31:10 +02:00
|
|
|
/*
|
|
|
|
* Register request, send initial attempt.
|
|
|
|
*/
|
|
|
|
int ceph_osdc_start_request(struct ceph_osd_client *osdc,
|
|
|
|
struct ceph_osd_request *req,
|
|
|
|
bool nofail)
|
|
|
|
{
|
2009-10-09 01:55:47 +02:00
|
|
|
int rc = 0;
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
req->r_request->pages = req->r_pages;
|
2013-02-26 00:35:46 +01:00
|
|
|
req->r_request->page_count = req->r_num_pages;
|
2013-02-14 19:16:43 +01:00
|
|
|
req->r_request->page_alignment = req->r_page_alignment;
|
2010-04-07 00:01:27 +02:00
|
|
|
#ifdef CONFIG_BLOCK
|
|
|
|
req->r_request->bio = req->r_bio;
|
|
|
|
#endif
|
2012-11-14 04:11:15 +01:00
|
|
|
req->r_request->trail = &req->r_trail;
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
register_request(osdc, req);
|
|
|
|
|
|
|
|
down_read(&osdc->map_sem);
|
|
|
|
mutex_lock(&osdc->request_mutex);
|
2009-10-09 01:55:47 +02:00
|
|
|
/*
|
|
|
|
* a racing kick_requests() may have sent the message for us
|
|
|
|
* while we dropped request_mutex above, so only send now if
|
|
|
|
* the request still han't been touched yet.
|
|
|
|
*/
|
|
|
|
if (req->r_sent == 0) {
|
2011-10-14 22:33:55 +02:00
|
|
|
rc = __map_request(osdc, req, 0);
|
2011-05-13 00:48:16 +02:00
|
|
|
if (rc < 0) {
|
|
|
|
if (nofail) {
|
|
|
|
dout("osdc_start_request failed map, "
|
|
|
|
" will retry %lld\n", req->r_tid);
|
|
|
|
rc = 0;
|
|
|
|
}
|
2011-03-29 05:25:59 +02:00
|
|
|
goto out_unlock;
|
2011-05-13 00:48:16 +02:00
|
|
|
}
|
2011-01-18 05:34:08 +01:00
|
|
|
if (req->r_osd == NULL) {
|
|
|
|
dout("send_request %p no up osds in pg\n", req);
|
|
|
|
ceph_monc_request_next_osdmap(&osdc->client->monc);
|
|
|
|
} else {
|
2012-01-03 21:34:34 +01:00
|
|
|
__send_request(osdc, req);
|
2009-10-06 20:31:10 +02:00
|
|
|
}
|
2012-01-03 21:34:34 +01:00
|
|
|
rc = 0;
|
2009-10-06 20:31:10 +02:00
|
|
|
}
|
2011-03-29 05:25:59 +02:00
|
|
|
|
|
|
|
out_unlock:
|
2009-10-06 20:31:10 +02:00
|
|
|
mutex_unlock(&osdc->request_mutex);
|
|
|
|
up_read(&osdc->map_sem);
|
|
|
|
return rc;
|
|
|
|
}
|
2010-04-07 00:14:15 +02:00
|
|
|
EXPORT_SYMBOL(ceph_osdc_start_request);
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* wait for a request to complete
|
|
|
|
*/
|
|
|
|
int ceph_osdc_wait_request(struct ceph_osd_client *osdc,
|
|
|
|
struct ceph_osd_request *req)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
rc = wait_for_completion_interruptible(&req->r_completion);
|
|
|
|
if (rc < 0) {
|
|
|
|
mutex_lock(&osdc->request_mutex);
|
|
|
|
__cancel_request(req);
|
2009-12-22 19:29:39 +01:00
|
|
|
__unregister_request(osdc, req);
|
2009-10-06 20:31:10 +02:00
|
|
|
mutex_unlock(&osdc->request_mutex);
|
2011-06-03 18:37:09 +02:00
|
|
|
complete_request(req);
|
2009-12-22 19:29:39 +01:00
|
|
|
dout("wait_request tid %llu canceled/timed out\n", req->r_tid);
|
2009-10-06 20:31:10 +02:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
dout("wait_request tid %llu result %d\n", req->r_tid, req->r_result);
|
|
|
|
return req->r_result;
|
|
|
|
}
|
2010-04-07 00:14:15 +02:00
|
|
|
EXPORT_SYMBOL(ceph_osdc_wait_request);
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* sync - wait for all in-flight requests to flush. avoid starvation.
|
|
|
|
*/
|
|
|
|
void ceph_osdc_sync(struct ceph_osd_client *osdc)
|
|
|
|
{
|
|
|
|
struct ceph_osd_request *req;
|
|
|
|
u64 last_tid, next_tid = 0;
|
|
|
|
|
|
|
|
mutex_lock(&osdc->request_mutex);
|
|
|
|
last_tid = osdc->last_tid;
|
|
|
|
while (1) {
|
|
|
|
req = __lookup_request_ge(osdc, next_tid);
|
|
|
|
if (!req)
|
|
|
|
break;
|
|
|
|
if (req->r_tid > last_tid)
|
|
|
|
break;
|
|
|
|
|
|
|
|
next_tid = req->r_tid + 1;
|
|
|
|
if ((req->r_flags & CEPH_OSD_FLAG_WRITE) == 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ceph_osdc_get_request(req);
|
|
|
|
mutex_unlock(&osdc->request_mutex);
|
|
|
|
dout("sync waiting on tid %llu (last is %llu)\n",
|
|
|
|
req->r_tid, last_tid);
|
|
|
|
wait_for_completion(&req->r_safe_completion);
|
|
|
|
mutex_lock(&osdc->request_mutex);
|
|
|
|
ceph_osdc_put_request(req);
|
|
|
|
}
|
|
|
|
mutex_unlock(&osdc->request_mutex);
|
|
|
|
dout("sync done (thru tid %llu)\n", last_tid);
|
|
|
|
}
|
2010-04-07 00:14:15 +02:00
|
|
|
EXPORT_SYMBOL(ceph_osdc_sync);
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* init, shutdown
|
|
|
|
*/
|
|
|
|
int ceph_osdc_init(struct ceph_osd_client *osdc, struct ceph_client *client)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
dout("init\n");
|
|
|
|
osdc->client = client;
|
|
|
|
osdc->osdmap = NULL;
|
|
|
|
init_rwsem(&osdc->map_sem);
|
|
|
|
init_completion(&osdc->map_waiters);
|
|
|
|
osdc->last_requested_map = 0;
|
|
|
|
mutex_init(&osdc->request_mutex);
|
|
|
|
osdc->last_tid = 0;
|
|
|
|
osdc->osds = RB_ROOT;
|
2010-02-03 20:00:26 +01:00
|
|
|
INIT_LIST_HEAD(&osdc->osd_lru);
|
2009-10-06 20:31:10 +02:00
|
|
|
osdc->requests = RB_ROOT;
|
2010-02-27 00:32:31 +01:00
|
|
|
INIT_LIST_HEAD(&osdc->req_lru);
|
2011-01-18 05:34:08 +01:00
|
|
|
INIT_LIST_HEAD(&osdc->req_unsent);
|
|
|
|
INIT_LIST_HEAD(&osdc->req_notarget);
|
2011-03-21 23:07:16 +01:00
|
|
|
INIT_LIST_HEAD(&osdc->req_linger);
|
2009-10-06 20:31:10 +02:00
|
|
|
osdc->num_requests = 0;
|
|
|
|
INIT_DELAYED_WORK(&osdc->timeout_work, handle_timeout);
|
2010-02-03 20:00:26 +01:00
|
|
|
INIT_DELAYED_WORK(&osdc->osds_timeout_work, handle_osds_timeout);
|
2011-03-21 23:07:16 +01:00
|
|
|
spin_lock_init(&osdc->event_lock);
|
|
|
|
osdc->event_tree = RB_ROOT;
|
|
|
|
osdc->event_count = 0;
|
2010-02-03 20:00:26 +01:00
|
|
|
|
|
|
|
schedule_delayed_work(&osdc->osds_timeout_work,
|
2010-04-07 00:14:15 +02:00
|
|
|
round_jiffies_relative(osdc->client->options->osd_idle_ttl * HZ));
|
2009-10-06 20:31:10 +02:00
|
|
|
|
2009-11-18 23:52:18 +01:00
|
|
|
err = -ENOMEM;
|
2009-10-06 20:31:10 +02:00
|
|
|
osdc->req_mempool = mempool_create_kmalloc_pool(10,
|
|
|
|
sizeof(struct ceph_osd_request));
|
|
|
|
if (!osdc->req_mempool)
|
2009-11-18 23:52:18 +01:00
|
|
|
goto out;
|
2009-10-06 20:31:10 +02:00
|
|
|
|
2012-07-09 23:22:34 +02:00
|
|
|
err = ceph_msgpool_init(&osdc->msgpool_op, CEPH_MSG_OSD_OP,
|
|
|
|
OSD_OP_FRONT_LEN, 10, true,
|
2010-04-24 18:56:35 +02:00
|
|
|
"osd_op");
|
2009-10-06 20:31:10 +02:00
|
|
|
if (err < 0)
|
2009-11-18 23:52:18 +01:00
|
|
|
goto out_mempool;
|
2012-07-09 23:22:34 +02:00
|
|
|
err = ceph_msgpool_init(&osdc->msgpool_op_reply, CEPH_MSG_OSD_OPREPLY,
|
2010-04-24 18:56:35 +02:00
|
|
|
OSD_OPREPLY_FRONT_LEN, 10, true,
|
|
|
|
"osd_op_reply");
|
2010-03-01 22:02:00 +01:00
|
|
|
if (err < 0)
|
|
|
|
goto out_msgpool;
|
2011-03-21 23:07:16 +01:00
|
|
|
|
|
|
|
osdc->notify_wq = create_singlethread_workqueue("ceph-watch-notify");
|
|
|
|
if (IS_ERR(osdc->notify_wq)) {
|
|
|
|
err = PTR_ERR(osdc->notify_wq);
|
|
|
|
osdc->notify_wq = NULL;
|
|
|
|
goto out_msgpool;
|
|
|
|
}
|
2009-10-06 20:31:10 +02:00
|
|
|
return 0;
|
2009-11-18 23:52:18 +01:00
|
|
|
|
2010-03-01 22:02:00 +01:00
|
|
|
out_msgpool:
|
|
|
|
ceph_msgpool_destroy(&osdc->msgpool_op);
|
2009-11-18 23:52:18 +01:00
|
|
|
out_mempool:
|
|
|
|
mempool_destroy(osdc->req_mempool);
|
|
|
|
out:
|
|
|
|
return err;
|
2009-10-06 20:31:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void ceph_osdc_stop(struct ceph_osd_client *osdc)
|
|
|
|
{
|
2011-03-21 23:07:16 +01:00
|
|
|
flush_workqueue(osdc->notify_wq);
|
|
|
|
destroy_workqueue(osdc->notify_wq);
|
2009-10-06 20:31:10 +02:00
|
|
|
cancel_delayed_work_sync(&osdc->timeout_work);
|
2010-02-03 20:00:26 +01:00
|
|
|
cancel_delayed_work_sync(&osdc->osds_timeout_work);
|
2009-10-06 20:31:10 +02:00
|
|
|
if (osdc->osdmap) {
|
|
|
|
ceph_osdmap_destroy(osdc->osdmap);
|
|
|
|
osdc->osdmap = NULL;
|
|
|
|
}
|
2011-08-31 23:45:53 +02:00
|
|
|
remove_all_osds(osdc);
|
2009-10-06 20:31:10 +02:00
|
|
|
mempool_destroy(osdc->req_mempool);
|
|
|
|
ceph_msgpool_destroy(&osdc->msgpool_op);
|
2010-03-01 22:02:00 +01:00
|
|
|
ceph_msgpool_destroy(&osdc->msgpool_op_reply);
|
2009-10-06 20:31:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read some contiguous pages. If we cross a stripe boundary, shorten
|
|
|
|
* *plen. Return number of bytes read, or error.
|
|
|
|
*/
|
|
|
|
int ceph_osdc_readpages(struct ceph_osd_client *osdc,
|
|
|
|
struct ceph_vino vino, struct ceph_file_layout *layout,
|
|
|
|
u64 off, u64 *plen,
|
|
|
|
u32 truncate_seq, u64 truncate_size,
|
2010-11-09 21:43:12 +01:00
|
|
|
struct page **pages, int num_pages, int page_align)
|
2009-10-06 20:31:10 +02:00
|
|
|
{
|
|
|
|
struct ceph_osd_request *req;
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
dout("readpages on ino %llx.%llx on %llu~%llu\n", vino.ino,
|
|
|
|
vino.snap, off, *plen);
|
|
|
|
req = ceph_osdc_new_request(osdc, layout, vino, off, plen,
|
|
|
|
CEPH_OSD_OP_READ, CEPH_OSD_FLAG_READ,
|
|
|
|
NULL, 0, truncate_seq, truncate_size, NULL,
|
2013-02-15 18:42:29 +01:00
|
|
|
false, page_align);
|
2012-09-25 06:01:02 +02:00
|
|
|
if (IS_ERR(req))
|
|
|
|
return PTR_ERR(req);
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
/* it may be a short read due to an object boundary */
|
|
|
|
req->r_pages = pages;
|
|
|
|
|
2010-11-09 21:43:12 +01:00
|
|
|
dout("readpages final extent is %llu~%llu (%d pages align %d)\n",
|
|
|
|
off, *plen, req->r_num_pages, page_align);
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
rc = ceph_osdc_start_request(osdc, req, false);
|
|
|
|
if (!rc)
|
|
|
|
rc = ceph_osdc_wait_request(osdc, req);
|
|
|
|
|
|
|
|
ceph_osdc_put_request(req);
|
|
|
|
dout("readpages result %d\n", rc);
|
|
|
|
return rc;
|
|
|
|
}
|
2010-04-07 00:14:15 +02:00
|
|
|
EXPORT_SYMBOL(ceph_osdc_readpages);
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* do a synchronous write on N pages
|
|
|
|
*/
|
|
|
|
int ceph_osdc_writepages(struct ceph_osd_client *osdc, struct ceph_vino vino,
|
|
|
|
struct ceph_file_layout *layout,
|
|
|
|
struct ceph_snap_context *snapc,
|
|
|
|
u64 off, u64 len,
|
|
|
|
u32 truncate_seq, u64 truncate_size,
|
|
|
|
struct timespec *mtime,
|
2013-02-15 18:42:29 +01:00
|
|
|
struct page **pages, int num_pages)
|
2009-10-06 20:31:10 +02:00
|
|
|
{
|
|
|
|
struct ceph_osd_request *req;
|
|
|
|
int rc = 0;
|
2010-11-09 21:43:12 +01:00
|
|
|
int page_align = off & ~PAGE_MASK;
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
BUG_ON(vino.snap != CEPH_NOSNAP);
|
|
|
|
req = ceph_osdc_new_request(osdc, layout, vino, off, &len,
|
|
|
|
CEPH_OSD_OP_WRITE,
|
2013-02-15 18:42:29 +01:00
|
|
|
CEPH_OSD_FLAG_ONDISK | CEPH_OSD_FLAG_WRITE,
|
2013-02-15 18:42:29 +01:00
|
|
|
snapc, 0,
|
2009-10-06 20:31:10 +02:00
|
|
|
truncate_seq, truncate_size, mtime,
|
2013-02-15 18:42:29 +01:00
|
|
|
true, page_align);
|
2012-09-25 06:01:02 +02:00
|
|
|
if (IS_ERR(req))
|
|
|
|
return PTR_ERR(req);
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
/* it may be a short write due to an object boundary */
|
|
|
|
req->r_pages = pages;
|
|
|
|
dout("writepages %llu~%llu (%d pages)\n", off, len,
|
|
|
|
req->r_num_pages);
|
|
|
|
|
2013-02-15 18:42:29 +01:00
|
|
|
rc = ceph_osdc_start_request(osdc, req, true);
|
2009-10-06 20:31:10 +02:00
|
|
|
if (!rc)
|
|
|
|
rc = ceph_osdc_wait_request(osdc, req);
|
|
|
|
|
|
|
|
ceph_osdc_put_request(req);
|
|
|
|
if (rc == 0)
|
|
|
|
rc = len;
|
|
|
|
dout("writepages result %d\n", rc);
|
|
|
|
return rc;
|
|
|
|
}
|
2010-04-07 00:14:15 +02:00
|
|
|
EXPORT_SYMBOL(ceph_osdc_writepages);
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* handle incoming message
|
|
|
|
*/
|
|
|
|
static void dispatch(struct ceph_connection *con, struct ceph_msg *msg)
|
|
|
|
{
|
|
|
|
struct ceph_osd *osd = con->private;
|
2009-11-21 16:53:16 +01:00
|
|
|
struct ceph_osd_client *osdc;
|
2009-10-06 20:31:10 +02:00
|
|
|
int type = le16_to_cpu(msg->hdr.type);
|
|
|
|
|
|
|
|
if (!osd)
|
2010-06-13 19:27:53 +02:00
|
|
|
goto out;
|
2009-11-21 16:53:16 +01:00
|
|
|
osdc = osd->o_osdc;
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case CEPH_MSG_OSD_MAP:
|
|
|
|
ceph_osdc_handle_map(osdc, msg);
|
|
|
|
break;
|
|
|
|
case CEPH_MSG_OSD_OPREPLY:
|
2009-12-22 19:45:45 +01:00
|
|
|
handle_reply(osdc, msg, con);
|
2009-10-06 20:31:10 +02:00
|
|
|
break;
|
2011-03-21 23:07:16 +01:00
|
|
|
case CEPH_MSG_WATCH_NOTIFY:
|
|
|
|
handle_watch_notify(osdc, msg);
|
|
|
|
break;
|
2009-10-06 20:31:10 +02:00
|
|
|
|
|
|
|
default:
|
|
|
|
pr_err("received unknown message type %d %s\n", type,
|
|
|
|
ceph_msg_type_name(type));
|
|
|
|
}
|
2010-06-13 19:27:53 +02:00
|
|
|
out:
|
2009-10-06 20:31:10 +02:00
|
|
|
ceph_msg_put(msg);
|
|
|
|
}
|
|
|
|
|
2010-02-20 06:43:23 +01:00
|
|
|
/*
|
2010-03-04 19:22:59 +01:00
|
|
|
* lookup and return message for incoming reply. set up reply message
|
|
|
|
* pages.
|
2010-02-20 06:43:23 +01:00
|
|
|
*/
|
|
|
|
static struct ceph_msg *get_reply(struct ceph_connection *con,
|
2010-01-08 22:58:34 +01:00
|
|
|
struct ceph_msg_header *hdr,
|
|
|
|
int *skip)
|
2009-10-06 20:31:10 +02:00
|
|
|
{
|
|
|
|
struct ceph_osd *osd = con->private;
|
|
|
|
struct ceph_osd_client *osdc = osd->o_osdc;
|
2010-01-08 22:58:34 +01:00
|
|
|
struct ceph_msg *m;
|
2010-01-11 23:47:13 +01:00
|
|
|
struct ceph_osd_request *req;
|
2010-02-20 06:43:23 +01:00
|
|
|
int front = le32_to_cpu(hdr->front_len);
|
|
|
|
int data_len = le32_to_cpu(hdr->data_len);
|
2010-01-11 23:47:13 +01:00
|
|
|
u64 tid;
|
2009-10-06 20:31:10 +02:00
|
|
|
|
2010-01-11 23:47:13 +01:00
|
|
|
tid = le64_to_cpu(hdr->tid);
|
|
|
|
mutex_lock(&osdc->request_mutex);
|
|
|
|
req = __lookup_request(osdc, tid);
|
|
|
|
if (!req) {
|
|
|
|
*skip = 1;
|
|
|
|
m = NULL;
|
2012-07-31 01:26:13 +02:00
|
|
|
dout("get_reply unknown tid %llu from osd%d\n", tid,
|
|
|
|
osd->o_osd);
|
2010-01-11 23:47:13 +01:00
|
|
|
goto out;
|
|
|
|
}
|
2010-03-01 22:02:00 +01:00
|
|
|
|
|
|
|
if (req->r_con_filling_msg) {
|
2012-06-01 21:56:43 +02:00
|
|
|
dout("%s revoking msg %p from old con %p\n", __func__,
|
2010-03-01 22:02:00 +01:00
|
|
|
req->r_reply, req->r_con_filling_msg);
|
2012-06-01 21:56:43 +02:00
|
|
|
ceph_msg_revoke_incoming(req->r_reply);
|
2012-06-01 05:22:18 +02:00
|
|
|
req->r_con_filling_msg->ops->put(req->r_con_filling_msg);
|
2010-03-25 05:30:19 +01:00
|
|
|
req->r_con_filling_msg = NULL;
|
2010-01-11 23:47:13 +01:00
|
|
|
}
|
|
|
|
|
2010-03-01 22:02:00 +01:00
|
|
|
if (front > req->r_reply->front.iov_len) {
|
|
|
|
pr_warning("get_reply front %d > preallocated %d\n",
|
|
|
|
front, (int)req->r_reply->front.iov_len);
|
2011-08-10 00:03:46 +02:00
|
|
|
m = ceph_msg_new(CEPH_MSG_OSD_OPREPLY, front, GFP_NOFS, false);
|
2010-04-02 01:06:19 +02:00
|
|
|
if (!m)
|
2010-03-01 22:02:00 +01:00
|
|
|
goto out;
|
|
|
|
ceph_msg_put(req->r_reply);
|
|
|
|
req->r_reply = m;
|
|
|
|
}
|
|
|
|
m = ceph_msg_get(req->r_reply);
|
|
|
|
|
2010-01-11 23:47:13 +01:00
|
|
|
if (data_len > 0) {
|
2010-11-09 21:43:12 +01:00
|
|
|
int want = calc_pages_for(req->r_page_alignment, data_len);
|
2010-03-04 19:22:59 +01:00
|
|
|
|
2013-01-31 23:02:00 +01:00
|
|
|
if (req->r_pages && unlikely(req->r_num_pages < want)) {
|
2011-06-14 01:20:18 +02:00
|
|
|
pr_warning("tid %lld reply has %d bytes %d pages, we"
|
|
|
|
" had only %d pages ready\n", tid, data_len,
|
|
|
|
want, req->r_num_pages);
|
2010-01-11 23:47:13 +01:00
|
|
|
*skip = 1;
|
|
|
|
ceph_msg_put(m);
|
2010-04-02 01:06:19 +02:00
|
|
|
m = NULL;
|
2010-03-04 19:22:59 +01:00
|
|
|
goto out;
|
2010-01-11 23:47:13 +01:00
|
|
|
}
|
2010-03-04 19:22:59 +01:00
|
|
|
m->pages = req->r_pages;
|
2013-02-26 00:35:46 +01:00
|
|
|
m->page_count = req->r_num_pages;
|
2010-11-09 21:40:00 +01:00
|
|
|
m->page_alignment = req->r_page_alignment;
|
2010-04-07 00:01:27 +02:00
|
|
|
#ifdef CONFIG_BLOCK
|
|
|
|
m->bio = req->r_bio;
|
|
|
|
#endif
|
2010-01-11 23:47:13 +01:00
|
|
|
}
|
2010-02-20 06:43:23 +01:00
|
|
|
*skip = 0;
|
2012-06-01 05:22:18 +02:00
|
|
|
req->r_con_filling_msg = con->ops->get(con);
|
2010-03-01 22:02:00 +01:00
|
|
|
dout("get_reply tid %lld %p\n", tid, m);
|
2010-01-11 23:47:13 +01:00
|
|
|
|
|
|
|
out:
|
|
|
|
mutex_unlock(&osdc->request_mutex);
|
2010-01-08 22:58:34 +01:00
|
|
|
return m;
|
2010-02-20 06:43:23 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ceph_msg *alloc_msg(struct ceph_connection *con,
|
|
|
|
struct ceph_msg_header *hdr,
|
|
|
|
int *skip)
|
|
|
|
{
|
|
|
|
struct ceph_osd *osd = con->private;
|
|
|
|
int type = le16_to_cpu(hdr->type);
|
|
|
|
int front = le32_to_cpu(hdr->front_len);
|
|
|
|
|
2012-06-04 21:43:32 +02:00
|
|
|
*skip = 0;
|
2010-02-20 06:43:23 +01:00
|
|
|
switch (type) {
|
|
|
|
case CEPH_MSG_OSD_MAP:
|
2011-03-21 23:07:16 +01:00
|
|
|
case CEPH_MSG_WATCH_NOTIFY:
|
2011-08-10 00:03:46 +02:00
|
|
|
return ceph_msg_new(type, front, GFP_NOFS, false);
|
2010-02-20 06:43:23 +01:00
|
|
|
case CEPH_MSG_OSD_OPREPLY:
|
|
|
|
return get_reply(con, hdr, skip);
|
|
|
|
default:
|
|
|
|
pr_info("alloc_msg unexpected msg type %d from osd%d\n", type,
|
|
|
|
osd->o_osd);
|
|
|
|
*skip = 1;
|
|
|
|
return NULL;
|
|
|
|
}
|
2009-10-06 20:31:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wrappers to refcount containing ceph_osd struct
|
|
|
|
*/
|
|
|
|
static struct ceph_connection *get_osd_con(struct ceph_connection *con)
|
|
|
|
{
|
|
|
|
struct ceph_osd *osd = con->private;
|
|
|
|
if (get_osd(osd))
|
|
|
|
return con;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void put_osd_con(struct ceph_connection *con)
|
|
|
|
{
|
|
|
|
struct ceph_osd *osd = con->private;
|
|
|
|
put_osd(osd);
|
|
|
|
}
|
|
|
|
|
2009-11-19 01:19:57 +01:00
|
|
|
/*
|
|
|
|
* authentication
|
|
|
|
*/
|
2012-05-16 22:16:39 +02:00
|
|
|
/*
|
|
|
|
* Note: returned pointer is the address of a structure that's
|
|
|
|
* managed separately. Caller must *not* attempt to free it.
|
|
|
|
*/
|
|
|
|
static struct ceph_auth_handshake *get_authorizer(struct ceph_connection *con,
|
2012-05-16 22:16:39 +02:00
|
|
|
int *proto, int force_new)
|
2009-11-19 01:19:57 +01:00
|
|
|
{
|
|
|
|
struct ceph_osd *o = con->private;
|
|
|
|
struct ceph_osd_client *osdc = o->o_osdc;
|
|
|
|
struct ceph_auth_client *ac = osdc->client->monc.auth;
|
2012-05-16 22:16:39 +02:00
|
|
|
struct ceph_auth_handshake *auth = &o->o_auth;
|
2009-11-19 01:19:57 +01:00
|
|
|
|
2012-05-16 22:16:39 +02:00
|
|
|
if (force_new && auth->authorizer) {
|
2012-05-16 22:16:39 +02:00
|
|
|
if (ac->ops && ac->ops->destroy_authorizer)
|
|
|
|
ac->ops->destroy_authorizer(ac, auth->authorizer);
|
2012-05-16 22:16:39 +02:00
|
|
|
auth->authorizer = NULL;
|
|
|
|
}
|
2012-05-16 22:16:39 +02:00
|
|
|
if (!auth->authorizer && ac->ops && ac->ops->create_authorizer) {
|
2012-05-16 22:16:39 +02:00
|
|
|
int ret = ac->ops->create_authorizer(ac, CEPH_ENTITY_TYPE_OSD,
|
|
|
|
auth);
|
2009-11-19 01:19:57 +01:00
|
|
|
if (ret)
|
2012-05-16 22:16:39 +02:00
|
|
|
return ERR_PTR(ret);
|
2009-11-19 01:19:57 +01:00
|
|
|
}
|
|
|
|
*proto = ac->protocol;
|
2012-05-16 22:16:39 +02:00
|
|
|
|
2012-05-16 22:16:39 +02:00
|
|
|
return auth;
|
2009-11-19 01:19:57 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int verify_authorizer_reply(struct ceph_connection *con, int len)
|
|
|
|
{
|
|
|
|
struct ceph_osd *o = con->private;
|
|
|
|
struct ceph_osd_client *osdc = o->o_osdc;
|
|
|
|
struct ceph_auth_client *ac = osdc->client->monc.auth;
|
|
|
|
|
2012-05-16 22:16:39 +02:00
|
|
|
/*
|
|
|
|
* XXX If ac->ops or ac->ops->verify_authorizer_reply is null,
|
|
|
|
* XXX which do we do: succeed or fail?
|
|
|
|
*/
|
2012-05-16 22:16:38 +02:00
|
|
|
return ac->ops->verify_authorizer_reply(ac, o->o_auth.authorizer, len);
|
2009-11-19 01:19:57 +01:00
|
|
|
}
|
|
|
|
|
2010-02-03 01:21:06 +01:00
|
|
|
static int invalidate_authorizer(struct ceph_connection *con)
|
|
|
|
{
|
|
|
|
struct ceph_osd *o = con->private;
|
|
|
|
struct ceph_osd_client *osdc = o->o_osdc;
|
|
|
|
struct ceph_auth_client *ac = osdc->client->monc.auth;
|
|
|
|
|
2012-05-16 22:16:39 +02:00
|
|
|
if (ac->ops && ac->ops->invalidate_authorizer)
|
2010-02-03 01:21:06 +01:00
|
|
|
ac->ops->invalidate_authorizer(ac, CEPH_ENTITY_TYPE_OSD);
|
|
|
|
|
|
|
|
return ceph_monc_validate_auth(&osdc->client->monc);
|
|
|
|
}
|
2009-11-19 01:19:57 +01:00
|
|
|
|
2010-05-20 10:40:19 +02:00
|
|
|
static const struct ceph_connection_operations osd_con_ops = {
|
2009-10-06 20:31:10 +02:00
|
|
|
.get = get_osd_con,
|
|
|
|
.put = put_osd_con,
|
|
|
|
.dispatch = dispatch,
|
2009-11-19 01:19:57 +01:00
|
|
|
.get_authorizer = get_authorizer,
|
|
|
|
.verify_authorizer_reply = verify_authorizer_reply,
|
2010-02-03 01:21:06 +01:00
|
|
|
.invalidate_authorizer = invalidate_authorizer,
|
2009-10-06 20:31:10 +02:00
|
|
|
.alloc_msg = alloc_msg,
|
2009-10-09 19:29:18 +02:00
|
|
|
.fault = osd_reset,
|
2009-10-06 20:31:10 +02:00
|
|
|
};
|