ceph: make mon client statfs handling more generic

This is being done so that we could reuse the statfs
infrastructure with other requests that return values.

Signed-off-by: Yehuda Sadeh <yehuda@hq.newdream.net>
Signed-off-by: Sage Weil <sage@newdream.net>

diff --git a/fs/ceph/debugfs.c b/fs/ceph/debugfs.c
index f7048da92acc58a9479657ad933e4a99b5199fa3..3be33fb066cc5f1ada8be5ebb50115c5dc9c9a7e 100644 (file)
--- a/fs/ceph/debugfs.c
+++ b/fs/ceph/debugfs.c
@@ -113,7 +113,7 @@ static int osdmap_show(struct seq_file *s, void *p)
 static int monc_show(struct seq_file *s, void *p)
 {
        struct ceph_client *client = s->private;
-       struct ceph_mon_statfs_request *req;
+       struct ceph_mon_generic_request *req;
        struct ceph_mon_client *monc = &client->monc;
        struct rb_node *rp;
 
@@ -126,9 +126,14 @@ static int monc_show(struct seq_file *s, void *p)
        if (monc->want_next_osdmap)
                seq_printf(s, "want next osdmap\n");
 
-       for (rp = rb_first(&monc->statfs_request_tree); rp; rp = rb_next(rp)) {
-               req = rb_entry(rp, struct ceph_mon_statfs_request, node);
-               seq_printf(s, "%lld statfs\n", req->tid);
+       for (rp = rb_first(&monc->generic_request_tree); rp; rp = rb_next(rp)) {
+               __u16 op;
+               req = rb_entry(rp, struct ceph_mon_generic_request, node);
+               op = le16_to_cpu(req->request->hdr.type);
+               if (op == CEPH_MSG_STATFS)
+                       seq_printf(s, "%lld statfs\n", req->tid);
+               else
+                       seq_printf(s, "%lld unknown\n", req->tid);
        }
 
        mutex_unlock(&monc->mutex);

diff --git a/fs/ceph/mon_client.c b/fs/ceph/mon_client.c
index 9900706fee7515e868ca1025e233fdf184b177fd..7df2f8c157f1aeff4246d4fdb46a80a242c7e9f7 100644 (file)
--- a/fs/ceph/mon_client.c
+++ b/fs/ceph/mon_client.c
@@ -353,14 +353,14 @@ out:
 /*
  * statfs
  */
-static struct ceph_mon_statfs_request *__lookup_statfs(
+static struct ceph_mon_generic_request *__lookup_generic_req(
        struct ceph_mon_client *monc, u64 tid)
 {
-       struct ceph_mon_statfs_request *req;
-       struct rb_node *n = monc->statfs_request_tree.rb_node;
+       struct ceph_mon_generic_request *req;
+       struct rb_node *n = monc->generic_request_tree.rb_node;
 
        while (n) {
-               req = rb_entry(n, struct ceph_mon_statfs_request, node);
+               req = rb_entry(n, struct ceph_mon_generic_request, node);
                if (tid < req->tid)
                        n = n->rb_left;
                else if (tid > req->tid)
@@ -371,16 +371,16 @@ static struct ceph_mon_statfs_request *__lookup_statfs(
        return NULL;
 }
 
-static void __insert_statfs(struct ceph_mon_client *monc,
-                           struct ceph_mon_statfs_request *new)
+static void __insert_generic_request(struct ceph_mon_client *monc,
+                           struct ceph_mon_generic_request *new)
 {
-       struct rb_node **p = &monc->statfs_request_tree.rb_node;
+       struct rb_node **p = &monc->generic_request_tree.rb_node;
        struct rb_node *parent = NULL;
-       struct ceph_mon_statfs_request *req = NULL;
+       struct ceph_mon_generic_request *req = NULL;
 
        while (*p) {
                parent = *p;
-               req = rb_entry(parent, struct ceph_mon_statfs_request, node);
+               req = rb_entry(parent, struct ceph_mon_generic_request, node);
                if (new->tid < req->tid)
                        p = &(*p)->rb_left;
                else if (new->tid > req->tid)
@@ -390,13 +390,13 @@ static void __insert_statfs(struct ceph_mon_client *monc,
        }
 
        rb_link_node(&new->node, parent, p);
-       rb_insert_color(&new->node, &monc->statfs_request_tree);
+       rb_insert_color(&new->node, &monc->generic_request_tree);
 }
 
-static void release_statfs_request(struct kref *kref)
+static void release_generic_request(struct kref *kref)
 {
-       struct ceph_mon_statfs_request *req =
-               container_of(kref, struct ceph_mon_statfs_request, kref);
+       struct ceph_mon_generic_request *req =
+               container_of(kref, struct ceph_mon_generic_request, kref);
 
        if (req->reply)
                ceph_msg_put(req->reply);
@@ -404,33 +404,33 @@ static void release_statfs_request(struct kref *kref)
                ceph_msg_put(req->request);
 }
 
-static void put_statfs_request(struct ceph_mon_statfs_request *req)
+static void put_generic_request(struct ceph_mon_generic_request *req)
 {
-       kref_put(&req->kref, release_statfs_request);
+       kref_put(&req->kref, release_generic_request);
 }
 
-static void get_statfs_request(struct ceph_mon_statfs_request *req)
+static void get_generic_request(struct ceph_mon_generic_request *req)
 {
        kref_get(&req->kref);
 }
 
-static struct ceph_msg *get_statfs_reply(struct ceph_connection *con,
+static struct ceph_msg *get_generic_reply(struct ceph_connection *con,
                                         struct ceph_msg_header *hdr,
                                         int *skip)
 {
        struct ceph_mon_client *monc = con->private;
-       struct ceph_mon_statfs_request *req;
+       struct ceph_mon_generic_request *req;
        u64 tid = le64_to_cpu(hdr->tid);
        struct ceph_msg *m;
 
        mutex_lock(&monc->mutex);
-       req = __lookup_statfs(monc, tid);
+       req = __lookup_generic_req(monc, tid);
        if (!req) {
-               dout("get_statfs_reply %lld dne\n", tid);
+               dout("get_generic_reply %lld dne\n", tid);
                *skip = 1;
                m = NULL;
        } else {
-               dout("get_statfs_reply %lld got %p\n", tid, req->reply);
+               dout("get_generic_reply %lld got %p\n", tid, req->reply);
                m = ceph_msg_get(req->reply);
                /*
                 * we don't need to track the connection reading into
@@ -445,7 +445,7 @@ static struct ceph_msg *get_statfs_reply(struct ceph_connection *con,
 static void handle_statfs_reply(struct ceph_mon_client *monc,
                                struct ceph_msg *msg)
 {
-       struct ceph_mon_statfs_request *req;
+       struct ceph_mon_generic_request *req;
        struct ceph_mon_statfs_reply *reply = msg->front.iov_base;
        u64 tid = le64_to_cpu(msg->hdr.tid);
 
@@ -454,21 +454,21 @@ static void handle_statfs_reply(struct ceph_mon_client *monc,
        dout("handle_statfs_reply %p tid %llu\n", msg, tid);
 
        mutex_lock(&monc->mutex);
-       req = __lookup_statfs(monc, tid);
+       req = __lookup_generic_req(monc, tid);
        if (req) {
-               *req->buf = reply->st;
+               *(struct ceph_statfs *)req->buf = reply->st;
                req->result = 0;
-               get_statfs_request(req);
+               get_generic_request(req);
        }
        mutex_unlock(&monc->mutex);
        if (req) {
                complete(&req->completion);
-               put_statfs_request(req);
+               put_generic_request(req);
        }
        return;
 
 bad:
-       pr_err("corrupt statfs reply, no tid\n");
+       pr_err("corrupt generic reply, no tid\n");
        ceph_msg_dump(msg);
 }
 
@@ -477,7 +477,7 @@ bad:
  */
 int ceph_monc_do_statfs(struct ceph_mon_client *monc, struct ceph_statfs *buf)
 {
-       struct ceph_mon_statfs_request *req;
+       struct ceph_mon_generic_request *req;
        struct ceph_mon_statfs *h;
        int err;
 
@@ -509,8 +509,8 @@ int ceph_monc_do_statfs(struct ceph_mon_client *monc, struct ceph_statfs *buf)
        mutex_lock(&monc->mutex);
        req->tid = ++monc->last_tid;
        req->request->hdr.tid = cpu_to_le64(req->tid);
-       __insert_statfs(monc, req);
-       monc->num_statfs_requests++;
+       __insert_generic_request(monc, req);
+       monc->num_generic_requests++;
        mutex_unlock(&monc->mutex);
 
        /* send request and wait */
@@ -518,28 +518,28 @@ int ceph_monc_do_statfs(struct ceph_mon_client *monc, struct ceph_statfs *buf)
        err = wait_for_completion_interruptible(&req->completion);
 
        mutex_lock(&monc->mutex);
-       rb_erase(&req->node, &monc->statfs_request_tree);
-       monc->num_statfs_requests--;
+       rb_erase(&req->node, &monc->generic_request_tree);
+       monc->num_generic_requests--;
        mutex_unlock(&monc->mutex);
 
        if (!err)
                err = req->result;
 
 out:
-       kref_put(&req->kref, release_statfs_request);
+       kref_put(&req->kref, release_generic_request);
        return err;
 }
 
 /*
  * Resend pending statfs requests.
  */
-static void __resend_statfs(struct ceph_mon_client *monc)
+static void __resend_generic_request(struct ceph_mon_client *monc)
 {
-       struct ceph_mon_statfs_request *req;
+       struct ceph_mon_generic_request *req;
        struct rb_node *p;
 
-       for (p = rb_first(&monc->statfs_request_tree); p; p = rb_next(p)) {
-               req = rb_entry(p, struct ceph_mon_statfs_request, node);
+       for (p = rb_first(&monc->generic_request_tree); p; p = rb_next(p)) {
+               req = rb_entry(p, struct ceph_mon_generic_request, node);
                ceph_con_send(monc->con, ceph_msg_get(req->request));
        }
 }
@@ -652,8 +652,8 @@ int ceph_monc_init(struct ceph_mon_client *monc, struct ceph_client *cl)
        monc->sub_sent = 0;
 
        INIT_DELAYED_WORK(&monc->delayed_work, delayed_work);
-       monc->statfs_request_tree = RB_ROOT;
-       monc->num_statfs_requests = 0;
+       monc->generic_request_tree = RB_ROOT;
+       monc->num_generic_requests = 0;
        monc->last_tid = 0;
 
        monc->have_mdsmap = 0;
@@ -717,7 +717,7 @@ static void handle_auth_reply(struct ceph_mon_client *monc,
                monc->client->msgr->inst.name.num = monc->auth->global_id;
 
                __send_subscribe(monc);
-               __resend_statfs(monc);
+               __resend_generic_request(monc);
        }
        mutex_unlock(&monc->mutex);
 }
@@ -809,7 +809,7 @@ static struct ceph_msg *mon_alloc_msg(struct ceph_connection *con,
                m = ceph_msg_get(monc->m_subscribe_ack);
                break;
        case CEPH_MSG_STATFS_REPLY:
-               return get_statfs_reply(con, hdr, skip);
+               return get_generic_reply(con, hdr, skip);
        case CEPH_MSG_AUTH_REPLY:
                m = ceph_msg_get(monc->m_auth_reply);
                break;

diff --git a/fs/ceph/mon_client.h b/fs/ceph/mon_client.h
index 0046deed074017d2bc15ea7e303135fe3235c0fb..76887785a4d7d6f849d67f526ae72c1e4429120c 100644 (file)
--- a/fs/ceph/mon_client.h
+++ b/fs/ceph/mon_client.h
@@ -22,7 +22,7 @@ struct ceph_monmap {
 };
 
 struct ceph_mon_client;
-struct ceph_mon_statfs_request;
+struct ceph_mon_generic_request;
 
 
 /*
@@ -40,15 +40,16 @@ struct ceph_mon_request {
 };
 
 /*
- * statfs() is done a bit differently because we need to get data back
+ * ceph_mon_generic_request is being used for the statfs and poolop requests
+ * which are bening done a bit differently because we need to get data back
  * to the caller
  */
-struct ceph_mon_statfs_request {
+struct ceph_mon_generic_request {
        struct kref kref;
        u64 tid;
        struct rb_node node;
        int result;
-       struct ceph_statfs *buf;
+       void *buf;
        struct completion completion;
        struct ceph_msg *request;  /* original request */
        struct ceph_msg *reply;    /* and reply */
@@ -71,9 +72,9 @@ struct ceph_mon_client {
        struct ceph_connection *con;
        bool have_fsid;
 
-       /* pending statfs requests */
-       struct rb_root statfs_request_tree;
-       int num_statfs_requests;
+       /* pending generic requests */
+       struct rb_root generic_request_tree;
+       int num_generic_requests;
        u64 last_tid;
 
        /* mds/osd map */